Code Review / openocd.git / blob
? search:


905b10743589486bb40dddb3925e75a37cbbe701
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "replacements.h"
25 #include "target.h"
26 #include "target_request.h"
27
28 #include "log.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
31 #include "jtag.h"
32
33 #include <string.h>
34 #include <stdlib.h>
35 #include <inttypes.h>
36
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <unistd.h>
40 #include <errno.h>
41
42 #include <sys/time.h>
43 #include <time.h>
44
45 #include <time_support.h>
46
47 #include <fileio.h>
48 #include <image.h>
49
50 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
51
52 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55
56 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59
60 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76
77 /* targets
78 */
79 extern target_type_t arm7tdmi_target;
80 extern target_type_t arm720t_target;
81 extern target_type_t arm9tdmi_target;
82 extern target_type_t arm920t_target;
83 extern target_type_t arm966e_target;
84 extern target_type_t arm926ejs_target;
85 extern target_type_t xscale_target;
86 extern target_type_t cortexm3_target;
87
88 target_type_t *target_types[] =
89 {
90 &arm7tdmi_target,
91 &arm9tdmi_target,
92 &arm920t_target,
93 &arm720t_target,
94 &arm966e_target,
95 &arm926ejs_target,
96 &xscale_target,
97 &cortexm3_target,
98 NULL,
99 };
100
101 target_t *targets = NULL;
102 target_event_callback_t *target_event_callbacks = NULL;
103 target_timer_callback_t *target_timer_callbacks = NULL;
104
105 char *target_state_strings[] =
106 {
107 "unknown",
108 "running",
109 "halted",
110 "reset",
111 "debug_running",
112 };
113
114 char *target_debug_reason_strings[] =
115 {
116 "debug request", "breakpoint", "watchpoint",
117 "watchpoint and breakpoint", "single step",
118 "target not halted"
119 };
120
121 char *target_endianess_strings[] =
122 {
123 "big endian",
124 "little endian",
125 };
126
127 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
128
129 static int target_continous_poll = 1;
130
131 /* read a u32 from a buffer in target memory endianness */
132 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
133 {
134 if (target->endianness == TARGET_LITTLE_ENDIAN)
135 return le_to_h_u32(buffer);
136 else
137 return be_to_h_u32(buffer);
138 }
139
140 /* read a u16 from a buffer in target memory endianness */
141 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
142 {
143 if (target->endianness == TARGET_LITTLE_ENDIAN)
144 return le_to_h_u16(buffer);
145 else
146 return be_to_h_u16(buffer);
147 }
148
149 /* write a u32 to a buffer in target memory endianness */
150 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
151 {
152 if (target->endianness == TARGET_LITTLE_ENDIAN)
153 h_u32_to_le(buffer, value);
154 else
155 h_u32_to_be(buffer, value);
156 }
157
158 /* write a u16 to a buffer in target memory endianness */
159 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
160 {
161 if (target->endianness == TARGET_LITTLE_ENDIAN)
162 h_u16_to_le(buffer, value);
163 else
164 h_u16_to_be(buffer, value);
165 }
166
167 /* returns a pointer to the n-th configured target */
168 target_t* get_target_by_num(int num)
169 {
170 target_t *target = targets;
171 int i = 0;
172
173 while (target)
174 {
175 if (num == i)
176 return target;
177 target = target->next;
178 i++;
179 }
180
181 return NULL;
182 }
183
184 int get_num_by_target(target_t *query_target)
185 {
186 target_t *target = targets;
187 int i = 0;
188
189 while (target)
190 {
191 if (target == query_target)
192 return i;
193 target = target->next;
194 i++;
195 }
196
197 return -1;
198 }
199
200 target_t* get_current_target(command_context_t *cmd_ctx)
201 {
202 target_t *target = get_target_by_num(cmd_ctx->current_target);
203
204 if (target == NULL)
205 {
206 ERROR("BUG: current_target out of bounds");
207 exit(-1);
208 }
209
210 return target;
211 }
212
213 /* Process target initialization, when target entered debug out of reset
214 * the handler is unregistered at the end of this function, so it's only called once
215 */
216 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
217 {
218 FILE *script;
219 struct command_context_s *cmd_ctx = priv;
220
221 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
222 {
223 target_unregister_event_callback(target_init_handler, priv);
224
225 script = fopen(target->reset_script, "r");
226 if (!script)
227 {
228 ERROR("couldn't open script file %s", target->reset_script);
229 return ERROR_OK;
230 }
231
232 INFO("executing reset script '%s'", target->reset_script);
233 command_run_file(cmd_ctx, script, COMMAND_EXEC);
234 fclose(script);
235
236 jtag_execute_queue();
237 }
238
239 return ERROR_OK;
240 }
241
242 int target_run_and_halt_handler(void *priv)
243 {
244 target_t *target = priv;
245
246 target->type->halt(target);
247
248 return ERROR_OK;
249 }
250
251 int target_process_reset(struct command_context_s *cmd_ctx)
252 {
253 int retval = ERROR_OK;
254 target_t *target;
255
256 /* prepare reset_halt where necessary */
257 target = targets;
258 while (target)
259 {
260 switch (target->reset_mode)
261 {
262 case RESET_HALT:
263 case RESET_INIT:
264 target->type->prepare_reset_halt(target);
265 break;
266 default:
267 break;
268 }
269 target = target->next;
270 }
271
272 target = targets;
273 while (target)
274 {
275 target->type->assert_reset(target);
276 target = target->next;
277 }
278 jtag_execute_queue();
279
280 /* request target halt if necessary, and schedule further action */
281 target = targets;
282 while (target)
283 {
284 switch (target->reset_mode)
285 {
286 case RESET_RUN:
287 /* nothing to do if target just wants to be run */
288 break;
289 case RESET_RUN_AND_HALT:
290 /* schedule halt */
291 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
292 break;
293 case RESET_RUN_AND_INIT:
294 /* schedule halt */
295 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
296 target_register_event_callback(target_init_handler, cmd_ctx);
297 break;
298 case RESET_HALT:
299 target->type->halt(target);
300 break;
301 case RESET_INIT:
302 target->type->halt(target);
303 target_register_event_callback(target_init_handler, cmd_ctx);
304 break;
305 default:
306 ERROR("BUG: unknown target->reset_mode");
307 }
308 target = target->next;
309 }
310
311 target = targets;
312 while (target)
313 {
314 target->type->deassert_reset(target);
315 target = target->next;
316 }
317 jtag_execute_queue();
318
319 return retval;
320 }
321
322 int target_init(struct command_context_s *cmd_ctx)
323 {
324 target_t *target = targets;
325
326 while (target)
327 {
328 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
329 {
330 ERROR("target '%s' init failed", target->type->name);
331 exit(-1);
332 }
333 target = target->next;
334 }
335
336 if (targets)
337 {
338 target_register_user_commands(cmd_ctx);
339 target_register_timer_callback(handle_target, 100, 1, NULL);
340 }
341
342 if (startup_mode == DAEMON_RESET)
343 target_process_reset(cmd_ctx);
344
345 return ERROR_OK;
346 }
347
348 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
349 {
350 target_event_callback_t **callbacks_p = &target_event_callbacks;
351
352 if (callback == NULL)
353 {
354 return ERROR_INVALID_ARGUMENTS;
355 }
356
357 if (*callbacks_p)
358 {
359 while ((*callbacks_p)->next)
360 callbacks_p = &((*callbacks_p)->next);
361 callbacks_p = &((*callbacks_p)->next);
362 }
363
364 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
365 (*callbacks_p)->callback = callback;
366 (*callbacks_p)->priv = priv;
367 (*callbacks_p)->next = NULL;
368
369 return ERROR_OK;
370 }
371
372 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
373 {
374 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
375 struct timeval now;
376
377 if (callback == NULL)
378 {
379 return ERROR_INVALID_ARGUMENTS;
380 }
381
382 if (*callbacks_p)
383 {
384 while ((*callbacks_p)->next)
385 callbacks_p = &((*callbacks_p)->next);
386 callbacks_p = &((*callbacks_p)->next);
387 }
388
389 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
390 (*callbacks_p)->callback = callback;
391 (*callbacks_p)->periodic = periodic;
392 (*callbacks_p)->time_ms = time_ms;
393
394 gettimeofday(&now, NULL);
395 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
396 time_ms -= (time_ms % 1000);
397 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
398 if ((*callbacks_p)->when.tv_usec > 1000000)
399 {
400 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
401 (*callbacks_p)->when.tv_sec += 1;
402 }
403
404 (*callbacks_p)->priv = priv;
405 (*callbacks_p)->next = NULL;
406
407 return ERROR_OK;
408 }
409
410 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
411 {
412 target_event_callback_t **p = &target_event_callbacks;
413 target_event_callback_t *c = target_event_callbacks;
414
415 if (callback == NULL)
416 {
417 return ERROR_INVALID_ARGUMENTS;
418 }
419
420 while (c)
421 {
422 target_event_callback_t *next = c->next;
423 if ((c->callback == callback) && (c->priv == priv))
424 {
425 *p = next;
426 free(c);
427 return ERROR_OK;
428 }
429 else
430 p = &(c->next);
431 c = next;
432 }
433
434 return ERROR_OK;
435 }
436
437 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
438 {
439 target_timer_callback_t **p = &target_timer_callbacks;
440 target_timer_callback_t *c = target_timer_callbacks;
441
442 if (callback == NULL)
443 {
444 return ERROR_INVALID_ARGUMENTS;
445 }
446
447 while (c)
448 {
449 target_timer_callback_t *next = c->next;
450 if ((c->callback == callback) && (c->priv == priv))
451 {
452 *p = next;
453 free(c);
454 return ERROR_OK;
455 }
456 else
457 p = &(c->next);
458 c = next;
459 }
460
461 return ERROR_OK;
462 }
463
464 int target_call_event_callbacks(target_t *target, enum target_event event)
465 {
466 target_event_callback_t *callback = target_event_callbacks;
467 target_event_callback_t *next_callback;
468
469 DEBUG("target event %i", event);
470
471 while (callback)
472 {
473 next_callback = callback->next;
474 callback->callback(target, event, callback->priv);
475 callback = next_callback;
476 }
477
478 return ERROR_OK;
479 }
480
481 int target_call_timer_callbacks()
482 {
483 target_timer_callback_t *callback = target_timer_callbacks;
484 target_timer_callback_t *next_callback;
485 struct timeval now;
486
487 gettimeofday(&now, NULL);
488
489 while (callback)
490 {
491 next_callback = callback->next;
492
493 if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
494 || (now.tv_sec > callback->when.tv_sec))
495 {
496 callback->callback(callback->priv);
497 if (callback->periodic)
498 {
499 int time_ms = callback->time_ms;
500 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
501 time_ms -= (time_ms % 1000);
502 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
503 if (callback->when.tv_usec > 1000000)
504 {
505 callback->when.tv_usec = callback->when.tv_usec - 1000000;
506 callback->when.tv_sec += 1;
507 }
508 }
509 else
510 target_unregister_timer_callback(callback->callback, callback->priv);
511 }
512
513 callback = next_callback;
514 }
515
516 return ERROR_OK;
517 }
518
519 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
520 {
521 working_area_t *c = target->working_areas;
522 working_area_t *new_wa = NULL;
523
524 /* only allocate multiples of 4 byte */
525 if (size % 4)
526 {
527 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
528 size = CEIL(size, 4);
529 }
530
531 /* see if there's already a matching working area */
532 while (c)
533 {
534 if ((c->free) && (c->size == size))
535 {
536 new_wa = c;
537 break;
538 }
539 c = c->next;
540 }
541
542 /* if not, allocate a new one */
543 if (!new_wa)
544 {
545 working_area_t **p = &target->working_areas;
546 u32 first_free = target->working_area;
547 u32 free_size = target->working_area_size;
548
549 DEBUG("allocating new working area");
550
551 c = target->working_areas;
552 while (c)
553 {
554 first_free += c->size;
555 free_size -= c->size;
556 p = &c->next;
557 c = c->next;
558 }
559
560 if (free_size < size)
561 {
562 WARNING("not enough working area available");
563 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
564 }
565
566 new_wa = malloc(sizeof(working_area_t));
567 new_wa->next = NULL;
568 new_wa->size = size;
569 new_wa->address = first_free;
570
571 if (target->backup_working_area)
572 {
573 new_wa->backup = malloc(new_wa->size);
574 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
575 }
576 else
577 {
578 new_wa->backup = NULL;
579 }
580
581 /* put new entry in list */
582 *p = new_wa;
583 }
584
585 /* mark as used, and return the new (reused) area */
586 new_wa->free = 0;
587 *area = new_wa;
588
589 /* user pointer */
590 new_wa->user = area;
591
592 return ERROR_OK;
593 }
594
595 int target_free_working_area(struct target_s *target, working_area_t *area)
596 {
597 if (area->free)
598 return ERROR_OK;
599
600 if (target->backup_working_area)
601 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
602
603 area->free = 1;
604
605 /* mark user pointer invalid */
606 *area->user = NULL;
607 area->user = NULL;
608
609 return ERROR_OK;
610 }
611
612 int target_free_all_working_areas(struct target_s *target)
613 {
614 working_area_t *c = target->working_areas;
615
616 while (c)
617 {
618 working_area_t *next = c->next;
619 target_free_working_area(target, c);
620
621 if (c->backup)
622 free(c->backup);
623
624 free(c);
625
626 c = next;
627 }
628
629 target->working_areas = NULL;
630
631 return ERROR_OK;
632 }
633
634 int target_register_commands(struct command_context_s *cmd_ctx)
635 {
636 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL);
637 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
638 register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
639 register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
640 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
641 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
642
643 return ERROR_OK;
644 }
645
646 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
647 {
648 int retval;
649
650 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
651
652 /* handle writes of less than 4 byte */
653 if (size < 4)
654 {
655 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
656 return retval;
657 return ERROR_OK;
658 }
659
660 /* handle unaligned head bytes */
661 if (address % 4)
662 {
663 int unaligned = 4 - (address % 4);
664
665 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
666 return retval;
667
668 buffer += unaligned;
669 address += unaligned;
670 size -= unaligned;
671 }
672
673 /* handle aligned words */
674 if (size >= 4)
675 {
676 int aligned = size - (size % 4);
677
678 /* use bulk writes above a certain limit. This may have to be changed */
679 if (aligned > 128)
680 {
681 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
682 return retval;
683 }
684 else
685 {
686 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
687 return retval;
688 }
689
690 buffer += aligned;
691 address += aligned;
692 size -= aligned;
693 }
694
695 /* handle tail writes of less than 4 bytes */
696 if (size > 0)
697 {
698 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
699 return retval;
700 }
701
702 return ERROR_OK;
703 }
704
705 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
706 {
707 int retval;
708
709 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
710
711 /* handle reads of less than 4 byte */
712 if (size < 4)
713 {
714 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
715 return retval;
716 return ERROR_OK;
717 }
718
719 /* handle unaligned head bytes */
720 if (address % 4)
721 {
722 int unaligned = 4 - (address % 4);
723
724 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
725 return retval;
726
727 buffer += unaligned;
728 address += unaligned;
729 size -= unaligned;
730 }
731
732 /* handle aligned words */
733 if (size >= 4)
734 {
735 int aligned = size - (size % 4);
736
737 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
738 return retval;
739
740 buffer += aligned;
741 address += aligned;
742 size -= aligned;
743 }
744
745 /* handle tail writes of less than 4 bytes */
746 if (size > 0)
747 {
748 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
749 return retval;
750 }
751
752 return ERROR_OK;
753 }
754
755 int target_read_u32(struct target_s *target, u32 address, u32 *value)
756 {
757 u8 value_buf[4];
758
759 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
760
761 if (retval == ERROR_OK)
762 {
763 *value = target_buffer_get_u32(target, value_buf);
764 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
765 }
766 else
767 {
768 *value = 0x0;
769 DEBUG("address: 0x%8.8x failed", address);
770 }
771
772 return retval;
773 }
774
775 int target_read_u16(struct target_s *target, u32 address, u16 *value)
776 {
777 u8 value_buf[2];
778
779 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
780
781 if (retval == ERROR_OK)
782 {
783 *value = target_buffer_get_u16(target, value_buf);
784 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
785 }
786 else
787 {
788 *value = 0x0;
789 DEBUG("address: 0x%8.8x failed", address);
790 }
791
792 return retval;
793 }
794
795 int target_read_u8(struct target_s *target, u32 address, u8 *value)
796 {
797 int retval = target->type->read_memory(target, address, 1, 1, value);
798
799 if (retval == ERROR_OK)
800 {
801 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
802 }
803 else
804 {
805 *value = 0x0;
806 DEBUG("address: 0x%8.8x failed", address);
807 }
808
809 return retval;
810 }
811
812 int target_write_u32(struct target_s *target, u32 address, u32 value)
813 {
814 int retval;
815 u8 value_buf[4];
816
817 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
818
819 target_buffer_set_u32(target, value_buf, value);
820 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
821 {
822 DEBUG("failed: %i", retval);
823 }
824
825 return retval;
826 }
827
828 int target_write_u16(struct target_s *target, u32 address, u16 value)
829 {
830 int retval;
831 u8 value_buf[2];
832
833 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
834
835 target_buffer_set_u16(target, value_buf, value);
836 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
837 {
838 DEBUG("failed: %i", retval);
839 }
840
841 return retval;
842 }
843
844 int target_write_u8(struct target_s *target, u32 address, u8 value)
845 {
846 int retval;
847
848 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
849
850 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
851 {
852 DEBUG("failed: %i", retval);
853 }
854
855 return retval;
856 }
857
858 int target_register_user_commands(struct command_context_s *cmd_ctx)
859 {
860 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
861 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
862 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
863 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
864 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
865 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction");
866 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
867 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
868
869 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
870 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
871 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
872
873 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
874 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
875 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
876
877 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
878 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
879 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
880 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
881
882 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
883 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
884 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
885 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
886
887 target_request_register_commands(cmd_ctx);
888
889 return ERROR_OK;
890 }
891
892 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
893 {
894 target_t *target = targets;
895 int count = 0;
896
897 if (argc == 1)
898 {
899 int num = strtoul(args[0], NULL, 0);
900
901 while (target)
902 {
903 count++;
904 target = target->next;
905 }
906
907 if (num < count)
908 cmd_ctx->current_target = num;
909 else
910 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
911
912 return ERROR_OK;
913 }
914
915 while (target)
916 {
917 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
918 target = target->next;
919 }
920
921 return ERROR_OK;
922 }
923
924 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
925 {
926 int i;
927 int found = 0;
928
929 if (argc < 3)
930 {
931 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
932 exit(-1);
933 }
934
935 /* search for the specified target */
936 if (args[0] && (args[0][0] != 0))
937 {
938 for (i = 0; target_types[i]; i++)
939 {
940 if (strcmp(args[0], target_types[i]->name) == 0)
941 {
942 target_t **last_target_p = &targets;
943
944 /* register target specific commands */
945 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
946 {
947 ERROR("couldn't register '%s' commands", args[0]);
948 exit(-1);
949 }
950
951 if (*last_target_p)
952 {
953 while ((*last_target_p)->next)
954 last_target_p = &((*last_target_p)->next);
955 last_target_p = &((*last_target_p)->next);
956 }
957
958 *last_target_p = malloc(sizeof(target_t));
959
960 (*last_target_p)->type = target_types[i];
961
962 if (strcmp(args[1], "big") == 0)
963 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
964 else if (strcmp(args[1], "little") == 0)
965 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
966 else
967 {
968 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
969 exit(-1);
970 }
971
972 /* what to do on a target reset */
973 if (strcmp(args[2], "reset_halt") == 0)
974 (*last_target_p)->reset_mode = RESET_HALT;
975 else if (strcmp(args[2], "reset_run") == 0)
976 (*last_target_p)->reset_mode = RESET_RUN;
977 else if (strcmp(args[2], "reset_init") == 0)
978 (*last_target_p)->reset_mode = RESET_INIT;
979 else if (strcmp(args[2], "run_and_halt") == 0)
980 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
981 else if (strcmp(args[2], "run_and_init") == 0)
982 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
983 else
984 {
985 ERROR("unknown target startup mode %s", args[2]);
986 exit(-1);
987 }
988 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
989
990 (*last_target_p)->reset_script = NULL;
991 (*last_target_p)->post_halt_script = NULL;
992 (*last_target_p)->pre_resume_script = NULL;
993
994 (*last_target_p)->working_area = 0x0;
995 (*last_target_p)->working_area_size = 0x0;
996 (*last_target_p)->working_areas = NULL;
997 (*last_target_p)->backup_working_area = 0;
998
999 (*last_target_p)->state = TARGET_UNKNOWN;
1000 (*last_target_p)->reg_cache = NULL;
1001 (*last_target_p)->breakpoints = NULL;
1002 (*last_target_p)->watchpoints = NULL;
1003 (*last_target_p)->next = NULL;
1004 (*last_target_p)->arch_info = NULL;
1005
1006 /* initialize trace information */
1007 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1008 (*last_target_p)->trace_info->num_trace_points = 0;
1009 (*last_target_p)->trace_info->trace_points = NULL;
1010 (*last_target_p)->trace_info->trace_history_size = 0;
1011 (*last_target_p)->trace_info->trace_history = NULL;
1012
1013 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1014
1015 found = 1;
1016 break;
1017 }
1018 }
1019 }
1020
1021 /* no matching target found */
1022 if (!found)
1023 {
1024 ERROR("target '%s' not found", args[0]);
1025 exit(-1);
1026 }
1027
1028 return ERROR_OK;
1029 }
1030
1031 /* usage: target_script <target#> <event> <script_file> */
1032 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1033 {
1034 target_t *target = NULL;
1035
1036 if (argc < 3)
1037 {
1038 ERROR("incomplete target_script command");
1039 exit(-1);
1040 }
1041
1042 target = get_target_by_num(strtoul(args[0], NULL, 0));
1043
1044 if (!target)
1045 {
1046 ERROR("target number '%s' not defined", args[0]);
1047 exit(-1);
1048 }
1049
1050 if (strcmp(args[1], "reset") == 0)
1051 {
1052 if (target->reset_script)
1053 free(target->reset_script);
1054 target->reset_script = strdup(args[2]);
1055 }
1056 else if (strcmp(args[1], "post_halt") == 0)
1057 {
1058 if (target->post_halt_script)
1059 free(target->post_halt_script);
1060 target->post_halt_script = strdup(args[2]);
1061 }
1062 else if (strcmp(args[1], "pre_resume") == 0)
1063 {
1064 if (target->pre_resume_script)
1065 free(target->pre_resume_script);
1066 target->pre_resume_script = strdup(args[2]);
1067 }
1068 else
1069 {
1070 ERROR("unknown event type: '%s", args[1]);
1071 exit(-1);
1072 }
1073
1074 return ERROR_OK;
1075 }
1076
1077 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1078 {
1079 target_t *target = NULL;
1080
1081 if (argc < 2)
1082 {
1083 ERROR("incomplete run_and_halt_time command");
1084 exit(-1);
1085 }
1086
1087 target = get_target_by_num(strtoul(args[0], NULL, 0));
1088
1089 if (!target)
1090 {
1091 ERROR("target number '%s' not defined", args[0]);
1092 exit(-1);
1093 }
1094
1095 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1096
1097 return ERROR_OK;
1098 }
1099
1100 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1101 {
1102 target_t *target = NULL;
1103
1104 if (argc < 4)
1105 {
1106 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1107 exit(-1);
1108 }
1109
1110 target = get_target_by_num(strtoul(args[0], NULL, 0));
1111
1112 if (!target)
1113 {
1114 ERROR("target number '%s' not defined", args[0]);
1115 exit(-1);
1116 }
1117
1118 target->working_area = strtoul(args[1], NULL, 0);
1119 target->working_area_size = strtoul(args[2], NULL, 0);
1120
1121 if (strcmp(args[3], "backup") == 0)
1122 {
1123 target->backup_working_area = 1;
1124 }
1125 else if (strcmp(args[3], "nobackup") == 0)
1126 {
1127 target->backup_working_area = 0;
1128 }
1129 else
1130 {
1131 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1132 exit(-1);
1133 }
1134
1135 return ERROR_OK;
1136 }
1137
1138
1139 /* process target state changes */
1140 int handle_target(void *priv)
1141 {
1142 int retval;
1143 target_t *target = targets;
1144
1145 while (target)
1146 {
1147 /* only poll if target isn't already halted */
1148 if (target->state != TARGET_HALTED)
1149 {
1150 if (target_continous_poll)
1151 if ((retval = target->type->poll(target)) < 0)
1152 {
1153 ERROR("couldn't poll target, exiting");
1154 exit(-1);
1155 }
1156 }
1157
1158 target = target->next;
1159 }
1160
1161 return ERROR_OK;
1162 }
1163
1164 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1165 {
1166 target_t *target;
1167 reg_t *reg = NULL;
1168 int count = 0;
1169 char *value;
1170
1171 DEBUG("-");
1172
1173 target = get_current_target(cmd_ctx);
1174
1175 /* list all available registers for the current target */
1176 if (argc == 0)
1177 {
1178 reg_cache_t *cache = target->reg_cache;
1179
1180 count = 0;
1181 while(cache)
1182 {
1183 int i;
1184 for (i = 0; i < cache->num_regs; i++)
1185 {
1186 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1187 command_print(cmd_ctx, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count++, cache->reg_list[i].name, cache->reg_list[i].size, value, cache->reg_list[i].dirty, cache->reg_list[i].valid);
1188 free(value);
1189 }
1190 cache = cache->next;
1191 }
1192
1193 return ERROR_OK;
1194 }
1195
1196 /* access a single register by its ordinal number */
1197 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1198 {
1199 int num = strtoul(args[0], NULL, 0);
1200 reg_cache_t *cache = target->reg_cache;
1201
1202 count = 0;
1203 while(cache)
1204 {
1205 int i;
1206 for (i = 0; i < cache->num_regs; i++)
1207 {
1208 if (count++ == num)
1209 {
1210 reg = &cache->reg_list[i];
1211 break;
1212 }
1213 }
1214 if (reg)
1215 break;
1216 cache = cache->next;
1217 }
1218
1219 if (!reg)
1220 {
1221 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1222 return ERROR_OK;
1223 }
1224 } else /* access a single register by its name */
1225 {
1226 reg = register_get_by_name(target->reg_cache, args[0], 1);
1227
1228 if (!reg)
1229 {
1230 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1231 return ERROR_OK;
1232 }
1233 }
1234
1235 /* display a register */
1236 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1237 {
1238 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1239 reg->valid = 0;
1240
1241 if (reg->valid == 0)
1242 {
1243 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1244 if (arch_type == NULL)
1245 {
1246 ERROR("BUG: encountered unregistered arch type");
1247 return ERROR_OK;
1248 }
1249 arch_type->get(reg);
1250 }
1251 value = buf_to_str(reg->value, reg->size, 16);
1252 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1253 free(value);
1254 return ERROR_OK;
1255 }
1256
1257 /* set register value */
1258 if (argc == 2)
1259 {
1260 u8 *buf = malloc(CEIL(reg->size, 8));
1261 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1262
1263 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1264 if (arch_type == NULL)
1265 {
1266 ERROR("BUG: encountered unregistered arch type");
1267 return ERROR_OK;
1268 }
1269
1270 arch_type->set(reg, buf);
1271
1272 value = buf_to_str(reg->value, reg->size, 16);
1273 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1274 free(value);
1275
1276 free(buf);
1277
1278 return ERROR_OK;
1279 }
1280
1281 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1282
1283 return ERROR_OK;
1284 }
1285
1286 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1287 {
1288 target_t *target = get_current_target(cmd_ctx);
1289 char buffer[512];
1290
1291 if (argc == 0)
1292 {
1293 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1294 if (target->state == TARGET_HALTED)
1295 {
1296 target->type->arch_state(target, buffer, 512);
1297 buffer[511] = 0;
1298 command_print(cmd_ctx, "%s", buffer);
1299 }
1300 }
1301 else
1302 {
1303 if (strcmp(args[0], "on") == 0)
1304 {
1305 target_continous_poll = 1;
1306 }
1307 else if (strcmp(args[0], "off") == 0)
1308 {
1309 target_continous_poll = 0;
1310 }
1311 }
1312
1313
1314 return ERROR_OK;
1315 }
1316
1317 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1318 {
1319 target_t *target = get_current_target(cmd_ctx);
1320 struct timeval timeout, now;
1321
1322 gettimeofday(&timeout, NULL);
1323 if (!argc)
1324 timeval_add_time(&timeout, 5, 0);
1325 else {
1326 char *end;
1327
1328 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1329 if (*end) {
1330 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1331 return ERROR_OK;
1332 }
1333 }
1334
1335 command_print(cmd_ctx, "waiting for target halted...");
1336
1337 while(target->type->poll(target))
1338 {
1339 if (target->state == TARGET_HALTED)
1340 {
1341 command_print(cmd_ctx, "target halted");
1342 break;
1343 }
1344 target_call_timer_callbacks();
1345
1346 gettimeofday(&now, NULL);
1347 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1348 {
1349 command_print(cmd_ctx, "timed out while waiting for target halt");
1350 ERROR("timed out while waiting for target halt");
1351 break;
1352 }
1353 }
1354
1355 return ERROR_OK;
1356 }
1357
1358 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1359 {
1360 int retval;
1361 target_t *target = get_current_target(cmd_ctx);
1362
1363 DEBUG("-");
1364
1365 command_print(cmd_ctx, "requesting target halt...");
1366
1367 if ((retval = target->type->halt(target)) != ERROR_OK)
1368 {
1369 switch (retval)
1370 {
1371 case ERROR_TARGET_ALREADY_HALTED:
1372 command_print(cmd_ctx, "target already halted");
1373 break;
1374 case ERROR_TARGET_TIMEOUT:
1375 command_print(cmd_ctx, "target timed out... shutting down");
1376 exit(-1);
1377 default:
1378 command_print(cmd_ctx, "unknown error... shutting down");
1379 exit(-1);
1380 }
1381 }
1382
1383 return ERROR_OK;
1384
1385 }
1386
1387 /* what to do on daemon startup */
1388 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1389 {
1390 if (argc == 1)
1391 {
1392 if (strcmp(args[0], "attach") == 0)
1393 {
1394 startup_mode = DAEMON_ATTACH;
1395 return ERROR_OK;
1396 }
1397 else if (strcmp(args[0], "reset") == 0)
1398 {
1399 startup_mode = DAEMON_RESET;
1400 return ERROR_OK;
1401 }
1402 }
1403
1404 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1405 return ERROR_OK;
1406
1407 }
1408
1409 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1410 {
1411 target_t *target = get_current_target(cmd_ctx);
1412 int retval;
1413
1414 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1415
1416 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1417 {
1418 switch (retval)
1419 {
1420 case ERROR_TARGET_TIMEOUT:
1421 command_print(cmd_ctx, "target timed out... shutting down");
1422 exit(-1);
1423 default:
1424 command_print(cmd_ctx, "unknown error... shutting down");
1425 exit(-1);
1426 }
1427 }
1428
1429 return ERROR_OK;
1430 }
1431
1432 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1433 {
1434 target_t *target = get_current_target(cmd_ctx);
1435 enum target_reset_mode reset_mode = RESET_RUN;
1436
1437 DEBUG("-");
1438
1439 if (argc >= 1)
1440 {
1441 if (strcmp("run", args[0]) == 0)
1442 reset_mode = RESET_RUN;
1443 else if (strcmp("halt", args[0]) == 0)
1444 reset_mode = RESET_HALT;
1445 else if (strcmp("init", args[0]) == 0)
1446 reset_mode = RESET_INIT;
1447 else if (strcmp("run_and_halt", args[0]) == 0)
1448 {
1449 reset_mode = RESET_RUN_AND_HALT;
1450 if (argc >= 2)
1451 {
1452 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1453 }
1454 }
1455 else if (strcmp("run_and_init", args[0]) == 0)
1456 {
1457 reset_mode = RESET_RUN_AND_INIT;
1458 if (argc >= 2)
1459 {
1460 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1461 }
1462 }
1463 else
1464 {
1465 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1466 return ERROR_OK;
1467 }
1468 target->reset_mode = reset_mode;
1469 }
1470
1471 target_process_reset(cmd_ctx);
1472
1473 return ERROR_OK;
1474 }
1475
1476 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1477 {
1478 int retval;
1479 target_t *target = get_current_target(cmd_ctx);
1480
1481 DEBUG("-");
1482
1483 if (argc == 0)
1484 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1485 else if (argc == 1)
1486 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1487 else
1488 {
1489 command_print(cmd_ctx, "usage: resume [address]");
1490 return ERROR_OK;
1491 }
1492
1493 if (retval != ERROR_OK)
1494 {
1495 switch (retval)
1496 {
1497 case ERROR_TARGET_NOT_HALTED:
1498 command_print(cmd_ctx, "target not halted");
1499 break;
1500 default:
1501 command_print(cmd_ctx, "unknown error... shutting down");
1502 exit(-1);
1503 }
1504 }
1505
1506 return ERROR_OK;
1507 }
1508
1509 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1510 {
1511 target_t *target = get_current_target(cmd_ctx);
1512
1513 DEBUG("-");
1514
1515 if (argc == 0)
1516 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1517
1518 if (argc == 1)
1519 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1520
1521 return ERROR_OK;
1522 }
1523
1524 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1525 {
1526 int count = 1;
1527 int size = 4;
1528 u32 address = 0;
1529 int i;
1530
1531 char output[128];
1532 int output_len;
1533
1534 int retval;
1535
1536 u8 *buffer;
1537 target_t *target = get_current_target(cmd_ctx);
1538
1539 if (argc < 1)
1540 return ERROR_OK;
1541
1542 if (argc == 2)
1543 count = strtoul(args[1], NULL, 0);
1544
1545 address = strtoul(args[0], NULL, 0);
1546
1547
1548 switch (cmd[2])
1549 {
1550 case 'w':
1551 size = 4;
1552 break;
1553 case 'h':
1554 size = 2;
1555 break;
1556 case 'b':
1557 size = 1;
1558 break;
1559 default:
1560 return ERROR_OK;
1561 }
1562
1563 buffer = calloc(count, size);
1564 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1565 {
1566 switch (retval)
1567 {
1568 case ERROR_TARGET_UNALIGNED_ACCESS:
1569 command_print(cmd_ctx, "error: address not aligned");
1570 break;
1571 case ERROR_TARGET_NOT_HALTED:
1572 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1573 break;
1574 case ERROR_TARGET_DATA_ABORT:
1575 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1576 break;
1577 default:
1578 command_print(cmd_ctx, "error: unknown error");
1579 break;
1580 }
1581 return ERROR_OK;
1582 }
1583
1584 output_len = 0;
1585
1586 for (i = 0; i < count; i++)
1587 {
1588 if (i%8 == 0)
1589 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1590
1591 switch (size)
1592 {
1593 case 4:
1594 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1595 break;
1596 case 2:
1597 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1598 break;
1599 case 1:
1600 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1601 break;
1602 }
1603
1604 if ((i%8 == 7) || (i == count - 1))
1605 {
1606 command_print(cmd_ctx, output);
1607 output_len = 0;
1608 }
1609 }
1610
1611 free(buffer);
1612
1613 return ERROR_OK;
1614 }
1615
1616 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1617 {
1618 u32 address = 0;
1619 u32 value = 0;
1620 int retval;
1621 target_t *target = get_current_target(cmd_ctx);
1622 u8 value_buf[4];
1623
1624 if (argc < 2)
1625 return ERROR_OK;
1626
1627 address = strtoul(args[0], NULL, 0);
1628 value = strtoul(args[1], NULL, 0);
1629
1630 switch (cmd[2])
1631 {
1632 case 'w':
1633 target_buffer_set_u32(target, value_buf, value);
1634 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1635 break;
1636 case 'h':
1637 target_buffer_set_u16(target, value_buf, value);
1638 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1639 break;
1640 case 'b':
1641 value_buf[0] = value;
1642 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1643 break;
1644 default:
1645 return ERROR_OK;
1646 }
1647
1648 switch (retval)
1649 {
1650 case ERROR_TARGET_UNALIGNED_ACCESS:
1651 command_print(cmd_ctx, "error: address not aligned");
1652 break;
1653 case ERROR_TARGET_DATA_ABORT:
1654 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1655 break;
1656 case ERROR_TARGET_NOT_HALTED:
1657 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1658 break;
1659 case ERROR_OK:
1660 break;
1661 default:
1662 command_print(cmd_ctx, "error: unknown error");
1663 break;
1664 }
1665
1666 return ERROR_OK;
1667
1668 }
1669
1670 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1671 {
1672 u8 *buffer;
1673 u32 buf_cnt;
1674 u32 image_size;
1675 int i;
1676 int retval;
1677
1678 image_t image;
1679
1680 duration_t duration;
1681 char *duration_text;
1682
1683 target_t *target = get_current_target(cmd_ctx);
1684
1685 if (argc < 1)
1686 {
1687 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1688 return ERROR_OK;
1689 }
1690
1691 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1692 if (argc >= 2)
1693 {
1694 image.base_address_set = 1;
1695 image.base_address = strtoul(args[1], NULL, 0);
1696 }
1697 else
1698 {
1699 image.base_address_set = 0;
1700 }
1701
1702 image.start_address_set = 0;
1703
1704 duration_start_measure(&duration);
1705
1706 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1707 {
1708 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1709 return ERROR_OK;
1710 }
1711
1712 image_size = 0x0;
1713 for (i = 0; i < image.num_sections; i++)
1714 {
1715 buffer = malloc(image.sections[i].size);
1716 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1717 {
1718 ERROR("image_read_section failed with error code: %i", retval);
1719 command_print(cmd_ctx, "image reading failed, download aborted");
1720 free(buffer);
1721 image_close(&image);
1722 return ERROR_OK;
1723 }
1724 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1725 image_size += buf_cnt;
1726 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1727
1728 free(buffer);
1729 }
1730
1731 duration_stop_measure(&duration, &duration_text);
1732 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1733 free(duration_text);
1734
1735 image_close(&image);
1736
1737 return ERROR_OK;
1738
1739 }
1740
1741 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1742 {
1743 fileio_t fileio;
1744
1745 u32 address;
1746 u32 size;
1747 u8 buffer[560];
1748
1749 duration_t duration;
1750 char *duration_text;
1751
1752 target_t *target = get_current_target(cmd_ctx);
1753
1754 if (argc != 3)
1755 {
1756 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1757 return ERROR_OK;
1758 }
1759
1760 address = strtoul(args[1], NULL, 0);
1761 size = strtoul(args[2], NULL, 0);
1762
1763 if ((address & 3) || (size & 3))
1764 {
1765 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1766 return ERROR_OK;
1767 }
1768
1769 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1770 {
1771 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1772 return ERROR_OK;
1773 }
1774
1775 duration_start_measure(&duration);
1776
1777 while (size > 0)
1778 {
1779 u32 size_written;
1780 u32 this_run_size = (size > 560) ? 560 : size;
1781
1782 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1783 fileio_write(&fileio, this_run_size, buffer, &size_written);
1784
1785 size -= this_run_size;
1786 address += this_run_size;
1787 }
1788
1789 fileio_close(&fileio);
1790
1791 duration_stop_measure(&duration, &duration_text);
1792 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1793 free(duration_text);
1794
1795 return ERROR_OK;
1796
1797 }
1798
1799 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1800 {
1801 int retval;
1802 target_t *target = get_current_target(cmd_ctx);
1803
1804 if (argc == 0)
1805 {
1806 breakpoint_t *breakpoint = target->breakpoints;
1807
1808 while (breakpoint)
1809 {
1810 if (breakpoint->type == BKPT_SOFT)
1811 {
1812 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1813 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1814 free(buf);
1815 }
1816 else
1817 {
1818 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1819 }
1820 breakpoint = breakpoint->next;
1821 }
1822 }
1823 else if (argc >= 2)
1824 {
1825 int hw = BKPT_SOFT;
1826 u32 length = 0;
1827
1828 length = strtoul(args[1], NULL, 0);
1829
1830 if (argc >= 3)
1831 if (strcmp(args[2], "hw") == 0)
1832 hw = BKPT_HARD;
1833
1834 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1835 {
1836 switch (retval)
1837 {
1838 case ERROR_TARGET_NOT_HALTED:
1839 command_print(cmd_ctx, "target must be halted to set breakpoints");
1840 break;
1841 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1842 command_print(cmd_ctx, "no more breakpoints available");
1843 break;
1844 default:
1845 command_print(cmd_ctx, "unknown error, breakpoint not set");
1846 break;
1847 }
1848 }
1849 else
1850 {
1851 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1852 }
1853 }
1854 else
1855 {
1856 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1857 }
1858
1859 return ERROR_OK;
1860 }
1861
1862 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1863 {
1864 target_t *target = get_current_target(cmd_ctx);
1865
1866 if (argc > 0)
1867 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1868
1869 return ERROR_OK;
1870 }
1871
1872 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1873 {
1874 target_t *target = get_current_target(cmd_ctx);
1875 int retval;
1876
1877 if (argc == 0)
1878 {
1879 watchpoint_t *watchpoint = target->watchpoints;
1880
1881 while (watchpoint)
1882 {
1883 command_print(cmd_ctx, "address: 0x%8.8x, mask: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint->address, watchpoint->length, watchpoint->rw, watchpoint->value, watchpoint->mask);
1884 watchpoint = watchpoint->next;
1885 }
1886 }
1887 else if (argc >= 2)
1888 {
1889 enum watchpoint_rw type = WPT_ACCESS;
1890 u32 data_value = 0x0;
1891 u32 data_mask = 0xffffffff;
1892
1893 if (argc >= 3)
1894 {
1895 switch(args[2][0])
1896 {
1897 case 'r':
1898 type = WPT_READ;
1899 break;
1900 case 'w':
1901 type = WPT_WRITE;
1902 break;
1903 case 'a':
1904 type = WPT_ACCESS;
1905 break;
1906 default:
1907 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1908 return ERROR_OK;
1909 }
1910 }
1911 if (argc >= 4)
1912 {
1913 data_value = strtoul(args[3], NULL, 0);
1914 }
1915 if (argc >= 5)
1916 {
1917 data_mask = strtoul(args[4], NULL, 0);
1918 }
1919
1920 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
1921 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
1922 {
1923 switch (retval)
1924 {
1925 case ERROR_TARGET_NOT_HALTED:
1926 command_print(cmd_ctx, "target must be halted to set watchpoints");
1927 break;
1928 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1929 command_print(cmd_ctx, "no more watchpoints available");
1930 break;
1931 default:
1932 command_print(cmd_ctx, "unknown error, watchpoint not set");
1933 break;
1934 }
1935 }
1936 }
1937 else
1938 {
1939 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1940 }
1941
1942 return ERROR_OK;
1943 }
1944
1945 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1946 {
1947 target_t *target = get_current_target(cmd_ctx);
1948
1949 if (argc > 0)
1950 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1951
1952 return ERROR_OK;
1953 }
1954
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)