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