Code Review / openocd.git / blob
? search:


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