Code Review / openocd.git / blob
? search:


0874010c03e5d0e26cd54c881cc8fca7ab872c6c
[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
1044 (*last_target_p)->working_area = 0x0;
1045 (*last_target_p)->working_area_size = 0x0;
1046 (*last_target_p)->working_areas = NULL;
1047 (*last_target_p)->backup_working_area = 0;
1048
1049 (*last_target_p)->state = TARGET_UNKNOWN;
1050 (*last_target_p)->reg_cache = NULL;
1051 (*last_target_p)->breakpoints = NULL;
1052 (*last_target_p)->watchpoints = NULL;
1053 (*last_target_p)->next = NULL;
1054 (*last_target_p)->arch_info = NULL;
1055
1056 /* initialize trace information */
1057 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1058 (*last_target_p)->trace_info->num_trace_points = 0;
1059 (*last_target_p)->trace_info->trace_points_size = 0;
1060 (*last_target_p)->trace_info->trace_points = NULL;
1061 (*last_target_p)->trace_info->trace_history_size = 0;
1062 (*last_target_p)->trace_info->trace_history = NULL;
1063 (*last_target_p)->trace_info->trace_history_pos = 0;
1064 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1065
1066 (*last_target_p)->dbgmsg = NULL;
1067
1068 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1069
1070 found = 1;
1071 break;
1072 }
1073 }
1074 }
1075
1076 /* no matching target found */
1077 if (!found)
1078 {
1079 ERROR("target '%s' not found", args[0]);
1080 exit(-1);
1081 }
1082
1083 return ERROR_OK;
1084 }
1085
1086 /* usage: target_script <target#> <event> <script_file> */
1087 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1088 {
1089 target_t *target = NULL;
1090
1091 if (argc < 3)
1092 {
1093 ERROR("incomplete target_script command");
1094 exit(-1);
1095 }
1096
1097 target = get_target_by_num(strtoul(args[0], NULL, 0));
1098
1099 if (!target)
1100 {
1101 ERROR("target number '%s' not defined", args[0]);
1102 exit(-1);
1103 }
1104
1105 if (strcmp(args[1], "reset") == 0)
1106 {
1107 if (target->reset_script)
1108 free(target->reset_script);
1109 target->reset_script = strdup(args[2]);
1110 }
1111 else if (strcmp(args[1], "post_halt") == 0)
1112 {
1113 if (target->post_halt_script)
1114 free(target->post_halt_script);
1115 target->post_halt_script = strdup(args[2]);
1116 }
1117 else if (strcmp(args[1], "pre_resume") == 0)
1118 {
1119 if (target->pre_resume_script)
1120 free(target->pre_resume_script);
1121 target->pre_resume_script = strdup(args[2]);
1122 }
1123 else
1124 {
1125 ERROR("unknown event type: '%s", args[1]);
1126 exit(-1);
1127 }
1128
1129 return ERROR_OK;
1130 }
1131
1132 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1133 {
1134 target_t *target = NULL;
1135
1136 if (argc < 2)
1137 {
1138 ERROR("incomplete run_and_halt_time command");
1139 exit(-1);
1140 }
1141
1142 target = get_target_by_num(strtoul(args[0], NULL, 0));
1143
1144 if (!target)
1145 {
1146 ERROR("target number '%s' not defined", args[0]);
1147 exit(-1);
1148 }
1149
1150 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1151
1152 return ERROR_OK;
1153 }
1154
1155 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1156 {
1157 target_t *target = NULL;
1158
1159 if (argc < 4)
1160 {
1161 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1162 exit(-1);
1163 }
1164
1165 target = get_target_by_num(strtoul(args[0], NULL, 0));
1166
1167 if (!target)
1168 {
1169 ERROR("target number '%s' not defined", args[0]);
1170 exit(-1);
1171 }
1172
1173 target->working_area = strtoul(args[1], NULL, 0);
1174 target->working_area_size = strtoul(args[2], NULL, 0);
1175
1176 if (strcmp(args[3], "backup") == 0)
1177 {
1178 target->backup_working_area = 1;
1179 }
1180 else if (strcmp(args[3], "nobackup") == 0)
1181 {
1182 target->backup_working_area = 0;
1183 }
1184 else
1185 {
1186 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1187 exit(-1);
1188 }
1189
1190 return ERROR_OK;
1191 }
1192
1193
1194 /* process target state changes */
1195 int handle_target(void *priv)
1196 {
1197 int retval;
1198 target_t *target = targets;
1199
1200 while (target)
1201 {
1202 /* only poll if target isn't already halted */
1203 if (target->state != TARGET_HALTED)
1204 {
1205 if (target_continous_poll)
1206 if ((retval = target->type->poll(target)) < 0)
1207 {
1208 ERROR("couldn't poll target. It's due for a reset.");
1209 }
1210 }
1211
1212 target = target->next;
1213 }
1214
1215 return ERROR_OK;
1216 }
1217
1218 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1219 {
1220 target_t *target;
1221 reg_t *reg = NULL;
1222 int count = 0;
1223 char *value;
1224
1225 DEBUG("-");
1226
1227 target = get_current_target(cmd_ctx);
1228
1229 /* list all available registers for the current target */
1230 if (argc == 0)
1231 {
1232 reg_cache_t *cache = target->reg_cache;
1233
1234 count = 0;
1235 while(cache)
1236 {
1237 int i;
1238 for (i = 0; i < cache->num_regs; i++)
1239 {
1240 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1241 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);
1242 free(value);
1243 }
1244 cache = cache->next;
1245 }
1246
1247 return ERROR_OK;
1248 }
1249
1250 /* access a single register by its ordinal number */
1251 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1252 {
1253 int num = strtoul(args[0], NULL, 0);
1254 reg_cache_t *cache = target->reg_cache;
1255
1256 count = 0;
1257 while(cache)
1258 {
1259 int i;
1260 for (i = 0; i < cache->num_regs; i++)
1261 {
1262 if (count++ == num)
1263 {
1264 reg = &cache->reg_list[i];
1265 break;
1266 }
1267 }
1268 if (reg)
1269 break;
1270 cache = cache->next;
1271 }
1272
1273 if (!reg)
1274 {
1275 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1276 return ERROR_OK;
1277 }
1278 } else /* access a single register by its name */
1279 {
1280 reg = register_get_by_name(target->reg_cache, args[0], 1);
1281
1282 if (!reg)
1283 {
1284 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1285 return ERROR_OK;
1286 }
1287 }
1288
1289 /* display a register */
1290 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1291 {
1292 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1293 reg->valid = 0;
1294
1295 if (reg->valid == 0)
1296 {
1297 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1298 if (arch_type == NULL)
1299 {
1300 ERROR("BUG: encountered unregistered arch type");
1301 return ERROR_OK;
1302 }
1303 arch_type->get(reg);
1304 }
1305 value = buf_to_str(reg->value, reg->size, 16);
1306 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1307 free(value);
1308 return ERROR_OK;
1309 }
1310
1311 /* set register value */
1312 if (argc == 2)
1313 {
1314 u8 *buf = malloc(CEIL(reg->size, 8));
1315 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1316
1317 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1318 if (arch_type == NULL)
1319 {
1320 ERROR("BUG: encountered unregistered arch type");
1321 return ERROR_OK;
1322 }
1323
1324 arch_type->set(reg, buf);
1325
1326 value = buf_to_str(reg->value, reg->size, 16);
1327 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1328 free(value);
1329
1330 free(buf);
1331
1332 return ERROR_OK;
1333 }
1334
1335 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1336
1337 return ERROR_OK;
1338 }
1339
1340 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1341 {
1342 target_t *target = get_current_target(cmd_ctx);
1343 char buffer[512];
1344
1345 if (argc == 0)
1346 {
1347 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1348 if (target->state == TARGET_HALTED)
1349 {
1350 target->type->arch_state(target, buffer, 512);
1351 buffer[511] = 0;
1352 command_print(cmd_ctx, "%s", buffer);
1353 }
1354 }
1355 else
1356 {
1357 if (strcmp(args[0], "on") == 0)
1358 {
1359 target_continous_poll = 1;
1360 }
1361 else if (strcmp(args[0], "off") == 0)
1362 {
1363 target_continous_poll = 0;
1364 }
1365 }
1366
1367
1368 return ERROR_OK;
1369 }
1370
1371 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1372 {
1373 target_t *target = get_current_target(cmd_ctx);
1374 struct timeval timeout, now;
1375
1376 gettimeofday(&timeout, NULL);
1377 if (!argc)
1378 timeval_add_time(&timeout, 5, 0);
1379 else {
1380 char *end;
1381
1382 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1383 if (*end) {
1384 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1385 return ERROR_OK;
1386 }
1387 }
1388
1389 command_print(cmd_ctx, "waiting for target halted...");
1390
1391 while(target->type->poll(target))
1392 {
1393 if (target->state == TARGET_HALTED)
1394 {
1395 command_print(cmd_ctx, "target halted");
1396 break;
1397 }
1398 target_call_timer_callbacks();
1399
1400 gettimeofday(&now, NULL);
1401 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1402 {
1403 command_print(cmd_ctx, "timed out while waiting for target halt");
1404 ERROR("timed out while waiting for target halt");
1405 break;
1406 }
1407 }
1408
1409 return ERROR_OK;
1410 }
1411
1412 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1413 {
1414 int retval;
1415 target_t *target = get_current_target(cmd_ctx);
1416
1417 DEBUG("-");
1418
1419 command_print(cmd_ctx, "requesting target halt...");
1420
1421 if ((retval = target->type->halt(target)) != ERROR_OK)
1422 {
1423 switch (retval)
1424 {
1425 case ERROR_TARGET_ALREADY_HALTED:
1426 command_print(cmd_ctx, "target already halted");
1427 break;
1428 case ERROR_TARGET_TIMEOUT:
1429 command_print(cmd_ctx, "target timed out... shutting down");
1430 exit(-1);
1431 default:
1432 command_print(cmd_ctx, "unknown error... shutting down");
1433 exit(-1);
1434 }
1435 }
1436
1437 return ERROR_OK;
1438
1439 }
1440
1441 /* what to do on daemon startup */
1442 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1443 {
1444 if (argc == 1)
1445 {
1446 if (strcmp(args[0], "attach") == 0)
1447 {
1448 startup_mode = DAEMON_ATTACH;
1449 return ERROR_OK;
1450 }
1451 else if (strcmp(args[0], "reset") == 0)
1452 {
1453 startup_mode = DAEMON_RESET;
1454 return ERROR_OK;
1455 }
1456 }
1457
1458 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1459 return ERROR_OK;
1460
1461 }
1462
1463 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1464 {
1465 target_t *target = get_current_target(cmd_ctx);
1466 int retval;
1467
1468 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1469
1470 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1471 {
1472 switch (retval)
1473 {
1474 case ERROR_TARGET_TIMEOUT:
1475 command_print(cmd_ctx, "target timed out... shutting down");
1476 exit(-1);
1477 default:
1478 command_print(cmd_ctx, "unknown error... shutting down");
1479 exit(-1);
1480 }
1481 }
1482
1483 return ERROR_OK;
1484 }
1485
1486 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1487 {
1488 target_t *target = get_current_target(cmd_ctx);
1489 enum target_reset_mode reset_mode = RESET_RUN;
1490
1491 DEBUG("-");
1492
1493 if (argc >= 1)
1494 {
1495 if (strcmp("run", args[0]) == 0)
1496 reset_mode = RESET_RUN;
1497 else if (strcmp("halt", args[0]) == 0)
1498 reset_mode = RESET_HALT;
1499 else if (strcmp("init", args[0]) == 0)
1500 reset_mode = RESET_INIT;
1501 else if (strcmp("run_and_halt", args[0]) == 0)
1502 {
1503 reset_mode = RESET_RUN_AND_HALT;
1504 if (argc >= 2)
1505 {
1506 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1507 }
1508 }
1509 else if (strcmp("run_and_init", args[0]) == 0)
1510 {
1511 reset_mode = RESET_RUN_AND_INIT;
1512 if (argc >= 2)
1513 {
1514 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1515 }
1516 }
1517 else
1518 {
1519 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1520 return ERROR_OK;
1521 }
1522 target->reset_mode = reset_mode;
1523 }
1524
1525 target_process_reset(cmd_ctx);
1526
1527 return ERROR_OK;
1528 }
1529
1530 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1531 {
1532 int retval;
1533 target_t *target = get_current_target(cmd_ctx);
1534
1535 DEBUG("-");
1536
1537 if (argc == 0)
1538 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1539 else if (argc == 1)
1540 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1541 else
1542 {
1543 command_print(cmd_ctx, "usage: resume [address]");
1544 return ERROR_OK;
1545 }
1546
1547 if (retval != ERROR_OK)
1548 {
1549 switch (retval)
1550 {
1551 case ERROR_TARGET_NOT_HALTED:
1552 command_print(cmd_ctx, "target not halted");
1553 break;
1554 default:
1555 command_print(cmd_ctx, "unknown error... shutting down");
1556 exit(-1);
1557 }
1558 }
1559
1560 return ERROR_OK;
1561 }
1562
1563 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1564 {
1565 target_t *target = get_current_target(cmd_ctx);
1566
1567 DEBUG("-");
1568
1569 if (argc == 0)
1570 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1571
1572 if (argc == 1)
1573 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1574
1575 return ERROR_OK;
1576 }
1577
1578 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1579 {
1580 int count = 1;
1581 int size = 4;
1582 u32 address = 0;
1583 int i;
1584
1585 char output[128];
1586 int output_len;
1587
1588 int retval;
1589
1590 u8 *buffer;
1591 target_t *target = get_current_target(cmd_ctx);
1592
1593 if (argc < 1)
1594 return ERROR_OK;
1595
1596 if (argc == 2)
1597 count = strtoul(args[1], NULL, 0);
1598
1599 address = strtoul(args[0], NULL, 0);
1600
1601
1602 switch (cmd[2])
1603 {
1604 case 'w':
1605 size = 4;
1606 break;
1607 case 'h':
1608 size = 2;
1609 break;
1610 case 'b':
1611 size = 1;
1612 break;
1613 default:
1614 return ERROR_OK;
1615 }
1616
1617 buffer = calloc(count, size);
1618 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1619 {
1620 switch (retval)
1621 {
1622 case ERROR_TARGET_UNALIGNED_ACCESS:
1623 command_print(cmd_ctx, "error: address not aligned");
1624 break;
1625 case ERROR_TARGET_NOT_HALTED:
1626 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1627 break;
1628 case ERROR_TARGET_DATA_ABORT:
1629 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1630 break;
1631 default:
1632 command_print(cmd_ctx, "error: unknown error");
1633 break;
1634 }
1635 return ERROR_OK;
1636 }
1637
1638 output_len = 0;
1639
1640 for (i = 0; i < count; i++)
1641 {
1642 if (i%8 == 0)
1643 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1644
1645 switch (size)
1646 {
1647 case 4:
1648 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1649 break;
1650 case 2:
1651 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1652 break;
1653 case 1:
1654 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1655 break;
1656 }
1657
1658 if ((i%8 == 7) || (i == count - 1))
1659 {
1660 command_print(cmd_ctx, output);
1661 output_len = 0;
1662 }
1663 }
1664
1665 free(buffer);
1666
1667 return ERROR_OK;
1668 }
1669
1670 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1671 {
1672 u32 address = 0;
1673 u32 value = 0;
1674 int retval;
1675 target_t *target = get_current_target(cmd_ctx);
1676 u8 value_buf[4];
1677
1678 if (argc < 2)
1679 return ERROR_OK;
1680
1681 address = strtoul(args[0], NULL, 0);
1682 value = strtoul(args[1], NULL, 0);
1683
1684 switch (cmd[2])
1685 {
1686 case 'w':
1687 target_buffer_set_u32(target, value_buf, value);
1688 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1689 break;
1690 case 'h':
1691 target_buffer_set_u16(target, value_buf, value);
1692 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1693 break;
1694 case 'b':
1695 value_buf[0] = value;
1696 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1697 break;
1698 default:
1699 return ERROR_OK;
1700 }
1701
1702 switch (retval)
1703 {
1704 case ERROR_TARGET_UNALIGNED_ACCESS:
1705 command_print(cmd_ctx, "error: address not aligned");
1706 break;
1707 case ERROR_TARGET_DATA_ABORT:
1708 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1709 break;
1710 case ERROR_TARGET_NOT_HALTED:
1711 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1712 break;
1713 case ERROR_OK:
1714 break;
1715 default:
1716 command_print(cmd_ctx, "error: unknown error");
1717 break;
1718 }
1719
1720 return ERROR_OK;
1721
1722 }
1723
1724 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1725 {
1726 u8 *buffer;
1727 u32 buf_cnt;
1728 u32 image_size;
1729 int i;
1730 int retval;
1731
1732 image_t image;
1733
1734 duration_t duration;
1735 char *duration_text;
1736
1737 target_t *target = get_current_target(cmd_ctx);
1738
1739 if (argc < 1)
1740 {
1741 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1742 return ERROR_OK;
1743 }
1744
1745 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1746 if (argc >= 2)
1747 {
1748 image.base_address_set = 1;
1749 image.base_address = strtoul(args[1], NULL, 0);
1750 }
1751 else
1752 {
1753 image.base_address_set = 0;
1754 }
1755
1756 image.start_address_set = 0;
1757
1758 duration_start_measure(&duration);
1759
1760 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1761 {
1762 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1763 return ERROR_OK;
1764 }
1765
1766 image_size = 0x0;
1767 for (i = 0; i < image.num_sections; i++)
1768 {
1769 buffer = malloc(image.sections[i].size);
1770 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1771 {
1772 ERROR("image_read_section failed with error code: %i", retval);
1773 command_print(cmd_ctx, "image reading failed, download aborted");
1774 free(buffer);
1775 image_close(&image);
1776 return ERROR_OK;
1777 }
1778 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1779 image_size += buf_cnt;
1780 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1781
1782 free(buffer);
1783 }
1784
1785 duration_stop_measure(&duration, &duration_text);
1786 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1787 free(duration_text);
1788
1789 image_close(&image);
1790
1791 return ERROR_OK;
1792
1793 }
1794
1795 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1796 {
1797 fileio_t fileio;
1798
1799 u32 address;
1800 u32 size;
1801 u8 buffer[560];
1802
1803 duration_t duration;
1804 char *duration_text;
1805
1806 target_t *target = get_current_target(cmd_ctx);
1807
1808 if (argc != 3)
1809 {
1810 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1811 return ERROR_OK;
1812 }
1813
1814 address = strtoul(args[1], NULL, 0);
1815 size = strtoul(args[2], NULL, 0);
1816
1817 if ((address & 3) || (size & 3))
1818 {
1819 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1820 return ERROR_OK;
1821 }
1822
1823 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1824 {
1825 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1826 return ERROR_OK;
1827 }
1828
1829 duration_start_measure(&duration);
1830
1831 while (size > 0)
1832 {
1833 u32 size_written;
1834 u32 this_run_size = (size > 560) ? 560 : size;
1835
1836 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1837 fileio_write(&fileio, this_run_size, buffer, &size_written);
1838
1839 size -= this_run_size;
1840 address += this_run_size;
1841 }
1842
1843 fileio_close(&fileio);
1844
1845 duration_stop_measure(&duration, &duration_text);
1846 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1847 free(duration_text);
1848
1849 return ERROR_OK;
1850
1851 }
1852
1853 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1854 {
1855 u8 *buffer;
1856 u32 buf_cnt;
1857 u32 image_size;
1858 int i;
1859 int retval;
1860 u32 checksum = 0;
1861 u32 mem_checksum = 0;
1862
1863 image_t image;
1864
1865 duration_t duration;
1866 char *duration_text;
1867
1868 target_t *target = get_current_target(cmd_ctx);
1869
1870 if (argc < 1)
1871 {
1872 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
1873 return ERROR_OK;
1874 }
1875
1876 if (!target)
1877 {
1878 ERROR("no target selected");
1879 return ERROR_OK;
1880 }
1881
1882 duration_start_measure(&duration);
1883
1884 if (argc >= 2)
1885 {
1886 image.base_address_set = 1;
1887 image.base_address = strtoul(args[1], NULL, 0);
1888 }
1889 else
1890 {
1891 image.base_address_set = 0;
1892 image.base_address = 0x0;
1893 }
1894
1895 image.start_address_set = 0;
1896
1897 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
1898 {
1899 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
1900 return ERROR_OK;
1901 }
1902
1903 image_size = 0x0;
1904 for (i = 0; i < image.num_sections; i++)
1905 {
1906 buffer = malloc(image.sections[i].size);
1907 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1908 {
1909 ERROR("image_read_section failed with error code: %i", retval);
1910 command_print(cmd_ctx, "image reading failed, verify aborted");
1911 free(buffer);
1912 image_close(&image);
1913 return ERROR_OK;
1914 }
1915
1916 /* calculate checksum of image */
1917 image_calculate_checksum( buffer, buf_cnt, &checksum );
1918 free(buffer);
1919
1920 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
1921
1922 if( retval != ERROR_OK )
1923 {
1924 command_print(cmd_ctx, "image verify failed, verify aborted");
1925 image_close(&image);
1926 return ERROR_OK;
1927 }
1928
1929 if( checksum != mem_checksum )
1930 {
1931 command_print(cmd_ctx, "image verify failed, verify aborted");
1932 image_close(&image);
1933 return ERROR_OK;
1934 }
1935
1936 image_size += buf_cnt;
1937 }
1938
1939 duration_stop_measure(&duration, &duration_text);
1940 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
1941 free(duration_text);
1942
1943 image_close(&image);
1944
1945 return ERROR_OK;
1946 }
1947
1948 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1949 {
1950 int retval;
1951 target_t *target = get_current_target(cmd_ctx);
1952
1953 if (argc == 0)
1954 {
1955 breakpoint_t *breakpoint = target->breakpoints;
1956
1957 while (breakpoint)
1958 {
1959 if (breakpoint->type == BKPT_SOFT)
1960 {
1961 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1962 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1963 free(buf);
1964 }
1965 else
1966 {
1967 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1968 }
1969 breakpoint = breakpoint->next;
1970 }
1971 }
1972 else if (argc >= 2)
1973 {
1974 int hw = BKPT_SOFT;
1975 u32 length = 0;
1976
1977 length = strtoul(args[1], NULL, 0);
1978
1979 if (argc >= 3)
1980 if (strcmp(args[2], "hw") == 0)
1981 hw = BKPT_HARD;
1982
1983 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1984 {
1985 switch (retval)
1986 {
1987 case ERROR_TARGET_NOT_HALTED:
1988 command_print(cmd_ctx, "target must be halted to set breakpoints");
1989 break;
1990 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1991 command_print(cmd_ctx, "no more breakpoints available");
1992 break;
1993 default:
1994 command_print(cmd_ctx, "unknown error, breakpoint not set");
1995 break;
1996 }
1997 }
1998 else
1999 {
2000 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2001 }
2002 }
2003 else
2004 {
2005 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2006 }
2007
2008 return ERROR_OK;
2009 }
2010
2011 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2012 {
2013 target_t *target = get_current_target(cmd_ctx);
2014
2015 if (argc > 0)
2016 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2017
2018 return ERROR_OK;
2019 }
2020
2021 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2022 {
2023 target_t *target = get_current_target(cmd_ctx);
2024 int retval;
2025
2026 if (argc == 0)
2027 {
2028 watchpoint_t *watchpoint = target->watchpoints;
2029
2030 while (watchpoint)
2031 {
2032 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);
2033 watchpoint = watchpoint->next;
2034 }
2035 }
2036 else if (argc >= 2)
2037 {
2038 enum watchpoint_rw type = WPT_ACCESS;
2039 u32 data_value = 0x0;
2040 u32 data_mask = 0xffffffff;
2041
2042 if (argc >= 3)
2043 {
2044 switch(args[2][0])
2045 {
2046 case 'r':
2047 type = WPT_READ;
2048 break;
2049 case 'w':
2050 type = WPT_WRITE;
2051 break;
2052 case 'a':
2053 type = WPT_ACCESS;
2054 break;
2055 default:
2056 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2057 return ERROR_OK;
2058 }
2059 }
2060 if (argc >= 4)
2061 {
2062 data_value = strtoul(args[3], NULL, 0);
2063 }
2064 if (argc >= 5)
2065 {
2066 data_mask = strtoul(args[4], NULL, 0);
2067 }
2068
2069 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2070 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2071 {
2072 switch (retval)
2073 {
2074 case ERROR_TARGET_NOT_HALTED:
2075 command_print(cmd_ctx, "target must be halted to set watchpoints");
2076 break;
2077 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2078 command_print(cmd_ctx, "no more watchpoints available");
2079 break;
2080 default:
2081 command_print(cmd_ctx, "unknown error, watchpoint not set");
2082 break;
2083 }
2084 }
2085 }
2086 else
2087 {
2088 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2089 }
2090
2091 return ERROR_OK;
2092 }
2093
2094 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2095 {
2096 target_t *target = get_current_target(cmd_ctx);
2097
2098 if (argc > 0)
2099 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2100
2101 return ERROR_OK;
2102 }
2103
2104
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)