Code Review / openocd.git / blob
? search:


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