Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Reset wip. Just adding hooks. This is just to reduce the size of the actual change...
[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
53 int handle_target_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 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
78 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
79
80 /* targets
81 */
82 extern target_type_t arm7tdmi_target;
83 extern target_type_t arm720t_target;
84 extern target_type_t arm9tdmi_target;
85 extern target_type_t arm920t_target;
86 extern target_type_t arm966e_target;
87 extern target_type_t arm926ejs_target;
88 extern target_type_t feroceon_target;
89 extern target_type_t xscale_target;
90 extern target_type_t cortexm3_target;
91 extern target_type_t arm11_target;
92
93 target_type_t *target_types[] =
94 {
95 &arm7tdmi_target,
96 &arm9tdmi_target,
97 &arm920t_target,
98 &arm720t_target,
99 &arm966e_target,
100 &arm926ejs_target,
101 &feroceon_target,
102 &xscale_target,
103 &cortexm3_target,
104 &arm11_target,
105 NULL,
106 };
107
108 target_t *targets = NULL;
109 target_event_callback_t *target_event_callbacks = NULL;
110 target_timer_callback_t *target_timer_callbacks = NULL;
111
112 char *target_state_strings[] =
113 {
114 "unknown",
115 "running",
116 "halted",
117 "reset",
118 "debug_running",
119 };
120
121 char *target_debug_reason_strings[] =
122 {
123 "debug request", "breakpoint", "watchpoint",
124 "watchpoint and breakpoint", "single step",
125 "target not halted", "undefined"
126 };
127
128 char *target_endianess_strings[] =
129 {
130 "big endian",
131 "little endian",
132 };
133
134 static int target_continous_poll = 1;
135
136 /* read a u32 from a buffer in target memory endianness */
137 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
138 {
139 if (target->endianness == TARGET_LITTLE_ENDIAN)
140 return le_to_h_u32(buffer);
141 else
142 return be_to_h_u32(buffer);
143 }
144
145 /* read a u16 from a buffer in target memory endianness */
146 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
147 {
148 if (target->endianness == TARGET_LITTLE_ENDIAN)
149 return le_to_h_u16(buffer);
150 else
151 return be_to_h_u16(buffer);
152 }
153
154 /* write a u32 to a buffer in target memory endianness */
155 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
156 {
157 if (target->endianness == TARGET_LITTLE_ENDIAN)
158 h_u32_to_le(buffer, value);
159 else
160 h_u32_to_be(buffer, value);
161 }
162
163 /* write a u16 to a buffer in target memory endianness */
164 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
165 {
166 if (target->endianness == TARGET_LITTLE_ENDIAN)
167 h_u16_to_le(buffer, value);
168 else
169 h_u16_to_be(buffer, value);
170 }
171
172 /* returns a pointer to the n-th configured target */
173 target_t* get_target_by_num(int num)
174 {
175 target_t *target = targets;
176 int i = 0;
177
178 while (target)
179 {
180 if (num == i)
181 return target;
182 target = target->next;
183 i++;
184 }
185
186 return NULL;
187 }
188
189 int get_num_by_target(target_t *query_target)
190 {
191 target_t *target = targets;
192 int i = 0;
193
194 while (target)
195 {
196 if (target == query_target)
197 return i;
198 target = target->next;
199 i++;
200 }
201
202 return -1;
203 }
204
205 target_t* get_current_target(command_context_t *cmd_ctx)
206 {
207 target_t *target = get_target_by_num(cmd_ctx->current_target);
208
209 if (target == NULL)
210 {
211 LOG_ERROR("BUG: current_target out of bounds");
212 exit(-1);
213 }
214
215 return target;
216 }
217
218 /* Process target initialization, when target entered debug out of reset
219 * the handler is unregistered at the end of this function, so it's only called once
220 */
221 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
222 {
223 FILE *script;
224 struct command_context_s *cmd_ctx = priv;
225
226 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
227 {
228 target_unregister_event_callback(target_init_handler, priv);
229
230 script = open_file_from_path(target->reset_script, "r");
231 if (!script)
232 {
233 LOG_ERROR("couldn't open script file %s", target->reset_script);
234 return ERROR_OK;
235 }
236
237 LOG_INFO("executing reset script '%s'", target->reset_script);
238 command_run_file(cmd_ctx, script, COMMAND_EXEC);
239 fclose(script);
240
241 jtag_execute_queue();
242 }
243
244 return ERROR_OK;
245 }
246
247 int target_run_and_halt_handler(void *priv)
248 {
249 target_t *target = priv;
250
251 target_halt(target);
252
253 return ERROR_OK;
254 }
255
256 int target_poll(struct target_s *target)
257 {
258 /* We can't poll until after examine */
259 if (!target->type->examined)
260 {
261 /* Fail silently lest we pollute the log */
262 return ERROR_FAIL;
263 }
264 return target->type->poll(target);
265 }
266
267 int target_halt(struct target_s *target)
268 {
269 /* We can't poll until after examine */
270 if (!target->type->examined)
271 {
272 LOG_ERROR("Target not examined yet");
273 return ERROR_FAIL;
274 }
275 return target->type->halt(target);
276 }
277
278 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
279 {
280 /* We can't poll until after examine */
281 if (!target->type->examined)
282 {
283 LOG_ERROR("Target not examined yet");
284 return ERROR_FAIL;
285 }
286 return target->type->resume(target, current, address, handle_breakpoints, debug_execution);
287 }
288
289
290 int target_process_reset(struct command_context_s *cmd_ctx)
291 {
292 int retval = ERROR_OK;
293 target_t *target;
294 struct timeval timeout, now;
295
296 jtag->speed(jtag_speed);
297
298 if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
299 return retval;
300
301 if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
302 return retval;
303
304 /* prepare reset_halt where necessary */
305 target = targets;
306 while (target)
307 {
308 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
309 {
310 switch (target->reset_mode)
311 {
312 case RESET_HALT:
313 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
314 target->reset_mode = RESET_RUN_AND_HALT;
315 break;
316 case RESET_INIT:
317 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
318 target->reset_mode = RESET_RUN_AND_INIT;
319 break;
320 default:
321 break;
322 }
323 }
324 target = target->next;
325 }
326
327 target = targets;
328 while (target)
329 {
330 /* we have no idea what state the target is in, so we
331 * have to drop working areas
332 */
333 target_free_all_working_areas_restore(target, 0);
334 target->type->assert_reset(target);
335 target = target->next;
336 }
337 if ((retval = jtag_execute_queue()) != ERROR_OK)
338 {
339 LOG_WARNING("JTAG communication failed asserting reset.");
340 retval = ERROR_OK;
341 }
342
343 /* request target halt if necessary, and schedule further action */
344 target = targets;
345 while (target)
346 {
347 switch (target->reset_mode)
348 {
349 case RESET_RUN:
350 /* nothing to do if target just wants to be run */
351 break;
352 case RESET_RUN_AND_HALT:
353 /* schedule halt */
354 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
355 break;
356 case RESET_RUN_AND_INIT:
357 /* schedule halt */
358 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
359 target_register_event_callback(target_init_handler, cmd_ctx);
360 break;
361 case RESET_HALT:
362 target_halt(target);
363 break;
364 case RESET_INIT:
365 target_halt(target);
366 target_register_event_callback(target_init_handler, cmd_ctx);
367 break;
368 default:
369 LOG_ERROR("BUG: unknown target->reset_mode");
370 }
371 target = target->next;
372 }
373
374 if ((retval = jtag_execute_queue()) != ERROR_OK)
375 {
376 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
377 retval = ERROR_OK;
378 }
379
380 target = targets;
381 while (target)
382 {
383 target->type->deassert_reset(target);
384 target = target->next;
385 }
386
387 if ((retval = jtag_execute_queue()) != ERROR_OK)
388 {
389 LOG_WARNING("JTAG communication failed while deasserting reset.");
390 retval = ERROR_OK;
391 }
392
393 LOG_DEBUG("Waiting for halted stated as approperiate");
394
395 /* Wait for reset to complete, maximum 5 seconds. */
396 gettimeofday(&timeout, NULL);
397 timeval_add_time(&timeout, 5, 0);
398 for(;;)
399 {
400 gettimeofday(&now, NULL);
401
402 target_call_timer_callbacks_now();
403
404 target = targets;
405 while (target)
406 {
407 LOG_DEBUG("Polling target");
408 target_poll(target);
409 if ((target->reset_mode == RESET_RUN_AND_INIT) ||
410 (target->reset_mode == RESET_RUN_AND_HALT) ||
411 (target->reset_mode == RESET_HALT) ||
412 (target->reset_mode == RESET_INIT))
413 {
414 if (target->state != TARGET_HALTED)
415 {
416 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
417 {
418 LOG_USER("Timed out waiting for halt after reset");
419 goto done;
420 }
421 /* this will send alive messages on e.g. GDB remote protocol. */
422 usleep(500*1000);
423 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
424 goto again;
425 }
426 }
427 target = target->next;
428 }
429 /* All targets we're waiting for are halted */
430 break;
431
432 again:;
433 }
434 done:
435
436
437 /* We want any events to be processed before the prompt */
438 target_call_timer_callbacks_now();
439
440 /* if we timed out we need to unregister these handlers */
441 target = targets;
442 while (target)
443 {
444 target_unregister_timer_callback(target_run_and_halt_handler, target);
445 target = target->next;
446 }
447 target_unregister_event_callback(target_init_handler, cmd_ctx);
448
449
450 jtag->speed(jtag_speed_post_reset);
451
452 return retval;
453 }
454
455 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
456 {
457 *physical = virtual;
458 return ERROR_OK;
459 }
460
461 static int default_mmu(struct target_s *target, int *enabled)
462 {
463 *enabled = 0;
464 return ERROR_OK;
465 }
466
467 static int default_examine(struct command_context_s *cmd_ctx, struct target_s *target)
468 {
469 return ERROR_OK;
470 }
471
472
473 /* Targets that correctly implement init+examine, i.e.
474 * no communication with target during init:
475 *
476 * XScale
477 */
478 int target_examine(struct command_context_s *cmd_ctx)
479 {
480 int retval = ERROR_OK;
481 target_t *target = targets;
482 while (target)
483 {
484 if ((retval = target->type->examine(cmd_ctx, target))!=ERROR_OK)
485 return retval;
486 target = target->next;
487 }
488 return retval;
489 }
490
491
492 int target_init(struct command_context_s *cmd_ctx)
493 {
494 target_t *target = targets;
495
496 while (target)
497 {
498 target->type->examined = 0;
499 if (target->type->examine == NULL)
500 {
501 target->type->examine = default_examine;
502 }
503
504 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
505 {
506 LOG_ERROR("target '%s' init failed", target->type->name);
507 exit(-1);
508 }
509
510 /* Set up default functions if none are provided by target */
511 if (target->type->virt2phys == NULL)
512 {
513 target->type->virt2phys = default_virt2phys;
514 }
515 if (target->type->mmu == NULL)
516 {
517 target->type->mmu = default_mmu;
518 }
519 target = target->next;
520 }
521
522 if (targets)
523 {
524 target_register_user_commands(cmd_ctx);
525 target_register_timer_callback(handle_target, 100, 1, NULL);
526 }
527
528 return ERROR_OK;
529 }
530
531 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
532 {
533 target_event_callback_t **callbacks_p = &target_event_callbacks;
534
535 if (callback == NULL)
536 {
537 return ERROR_INVALID_ARGUMENTS;
538 }
539
540 if (*callbacks_p)
541 {
542 while ((*callbacks_p)->next)
543 callbacks_p = &((*callbacks_p)->next);
544 callbacks_p = &((*callbacks_p)->next);
545 }
546
547 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
548 (*callbacks_p)->callback = callback;
549 (*callbacks_p)->priv = priv;
550 (*callbacks_p)->next = NULL;
551
552 return ERROR_OK;
553 }
554
555 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
556 {
557 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
558 struct timeval now;
559
560 if (callback == NULL)
561 {
562 return ERROR_INVALID_ARGUMENTS;
563 }
564
565 if (*callbacks_p)
566 {
567 while ((*callbacks_p)->next)
568 callbacks_p = &((*callbacks_p)->next);
569 callbacks_p = &((*callbacks_p)->next);
570 }
571
572 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
573 (*callbacks_p)->callback = callback;
574 (*callbacks_p)->periodic = periodic;
575 (*callbacks_p)->time_ms = time_ms;
576
577 gettimeofday(&now, NULL);
578 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
579 time_ms -= (time_ms % 1000);
580 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
581 if ((*callbacks_p)->when.tv_usec > 1000000)
582 {
583 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
584 (*callbacks_p)->when.tv_sec += 1;
585 }
586
587 (*callbacks_p)->priv = priv;
588 (*callbacks_p)->next = NULL;
589
590 return ERROR_OK;
591 }
592
593 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
594 {
595 target_event_callback_t **p = &target_event_callbacks;
596 target_event_callback_t *c = target_event_callbacks;
597
598 if (callback == NULL)
599 {
600 return ERROR_INVALID_ARGUMENTS;
601 }
602
603 while (c)
604 {
605 target_event_callback_t *next = c->next;
606 if ((c->callback == callback) && (c->priv == priv))
607 {
608 *p = next;
609 free(c);
610 return ERROR_OK;
611 }
612 else
613 p = &(c->next);
614 c = next;
615 }
616
617 return ERROR_OK;
618 }
619
620 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
621 {
622 target_timer_callback_t **p = &target_timer_callbacks;
623 target_timer_callback_t *c = target_timer_callbacks;
624
625 if (callback == NULL)
626 {
627 return ERROR_INVALID_ARGUMENTS;
628 }
629
630 while (c)
631 {
632 target_timer_callback_t *next = c->next;
633 if ((c->callback == callback) && (c->priv == priv))
634 {
635 *p = next;
636 free(c);
637 return ERROR_OK;
638 }
639 else
640 p = &(c->next);
641 c = next;
642 }
643
644 return ERROR_OK;
645 }
646
647 int target_call_event_callbacks(target_t *target, enum target_event event)
648 {
649 target_event_callback_t *callback = target_event_callbacks;
650 target_event_callback_t *next_callback;
651
652 LOG_DEBUG("target event %i", event);
653
654 while (callback)
655 {
656 next_callback = callback->next;
657 callback->callback(target, event, callback->priv);
658 callback = next_callback;
659 }
660
661 return ERROR_OK;
662 }
663
664 static int target_call_timer_callbacks_check_time(int checktime)
665 {
666 target_timer_callback_t *callback = target_timer_callbacks;
667 target_timer_callback_t *next_callback;
668 struct timeval now;
669
670 gettimeofday(&now, NULL);
671
672 while (callback)
673 {
674 next_callback = callback->next;
675
676 if ((!checktime&&callback->periodic)||
677 (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
678 || (now.tv_sec > callback->when.tv_sec)))
679 {
680 callback->callback(callback->priv);
681 if (callback->periodic)
682 {
683 int time_ms = callback->time_ms;
684 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
685 time_ms -= (time_ms % 1000);
686 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
687 if (callback->when.tv_usec > 1000000)
688 {
689 callback->when.tv_usec = callback->when.tv_usec - 1000000;
690 callback->when.tv_sec += 1;
691 }
692 }
693 else
694 target_unregister_timer_callback(callback->callback, callback->priv);
695 }
696
697 callback = next_callback;
698 }
699
700 return ERROR_OK;
701 }
702
703 int target_call_timer_callbacks()
704 {
705 return target_call_timer_callbacks_check_time(1);
706 }
707
708 /* invoke periodic callbacks immediately */
709 int target_call_timer_callbacks_now()
710 {
711 return target_call_timer_callbacks(0);
712 }
713
714
715 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
716 {
717 working_area_t *c = target->working_areas;
718 working_area_t *new_wa = NULL;
719
720 /* Reevaluate working area address based on MMU state*/
721 if (target->working_areas == NULL)
722 {
723 int retval;
724 int enabled;
725 retval = target->type->mmu(target, &enabled);
726 if (retval != ERROR_OK)
727 {
728 return retval;
729 }
730 if (enabled)
731 {
732 target->working_area = target->working_area_virt;
733 }
734 else
735 {
736 target->working_area = target->working_area_phys;
737 }
738 }
739
740 /* only allocate multiples of 4 byte */
741 if (size % 4)
742 {
743 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
744 size = CEIL(size, 4);
745 }
746
747 /* see if there's already a matching working area */
748 while (c)
749 {
750 if ((c->free) && (c->size == size))
751 {
752 new_wa = c;
753 break;
754 }
755 c = c->next;
756 }
757
758 /* if not, allocate a new one */
759 if (!new_wa)
760 {
761 working_area_t **p = &target->working_areas;
762 u32 first_free = target->working_area;
763 u32 free_size = target->working_area_size;
764
765 LOG_DEBUG("allocating new working area");
766
767 c = target->working_areas;
768 while (c)
769 {
770 first_free += c->size;
771 free_size -= c->size;
772 p = &c->next;
773 c = c->next;
774 }
775
776 if (free_size < size)
777 {
778 LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
779 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
780 }
781
782 new_wa = malloc(sizeof(working_area_t));
783 new_wa->next = NULL;
784 new_wa->size = size;
785 new_wa->address = first_free;
786
787 if (target->backup_working_area)
788 {
789 new_wa->backup = malloc(new_wa->size);
790 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
791 }
792 else
793 {
794 new_wa->backup = NULL;
795 }
796
797 /* put new entry in list */
798 *p = new_wa;
799 }
800
801 /* mark as used, and return the new (reused) area */
802 new_wa->free = 0;
803 *area = new_wa;
804
805 /* user pointer */
806 new_wa->user = area;
807
808 return ERROR_OK;
809 }
810
811 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
812 {
813 if (area->free)
814 return ERROR_OK;
815
816 if (restore&&target->backup_working_area)
817 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
818
819 area->free = 1;
820
821 /* mark user pointer invalid */
822 *area->user = NULL;
823 area->user = NULL;
824
825 return ERROR_OK;
826 }
827
828 int target_free_working_area(struct target_s *target, working_area_t *area)
829 {
830 return target_free_working_area_restore(target, area, 1);
831 }
832
833 int target_free_all_working_areas_restore(struct target_s *target, int restore)
834 {
835 working_area_t *c = target->working_areas;
836
837 while (c)
838 {
839 working_area_t *next = c->next;
840 target_free_working_area_restore(target, c, restore);
841
842 if (c->backup)
843 free(c->backup);
844
845 free(c);
846
847 c = next;
848 }
849
850 target->working_areas = NULL;
851
852 return ERROR_OK;
853 }
854
855 int target_free_all_working_areas(struct target_s *target)
856 {
857 return target_free_all_working_areas_restore(target, 1);
858 }
859
860 int target_register_commands(struct command_context_s *cmd_ctx)
861 {
862 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
863 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
864 register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
865 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, "<target> <run time ms>");
866 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
867 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
868 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
869
870 return ERROR_OK;
871 }
872
873 int target_arch_state(struct target_s *target)
874 {
875 int retval;
876 if (target==NULL)
877 {
878 LOG_USER("No target has been configured");
879 return ERROR_OK;
880 }
881
882 LOG_USER("target state: %s", target_state_strings[target->state]);
883
884 if (target->state!=TARGET_HALTED)
885 return ERROR_OK;
886
887 retval=target->type->arch_state(target);
888 return retval;
889 }
890
891 /* Single aligned words are guaranteed to use 16 or 32 bit access
892 * mode respectively, otherwise data is handled as quickly as
893 * possible
894 */
895 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
896 {
897 int retval;
898
899 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
900
901 if (((address % 2) == 0) && (size == 2))
902 {
903 return target->type->write_memory(target, address, 2, 1, buffer);
904 }
905
906 /* handle unaligned head bytes */
907 if (address % 4)
908 {
909 int unaligned = 4 - (address % 4);
910
911 if (unaligned > size)
912 unaligned = size;
913
914 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
915 return retval;
916
917 buffer += unaligned;
918 address += unaligned;
919 size -= unaligned;
920 }
921
922 /* handle aligned words */
923 if (size >= 4)
924 {
925 int aligned = size - (size % 4);
926
927 /* use bulk writes above a certain limit. This may have to be changed */
928 if (aligned > 128)
929 {
930 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
931 return retval;
932 }
933 else
934 {
935 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
936 return retval;
937 }
938
939 buffer += aligned;
940 address += aligned;
941 size -= aligned;
942 }
943
944 /* handle tail writes of less than 4 bytes */
945 if (size > 0)
946 {
947 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
948 return retval;
949 }
950
951 return ERROR_OK;
952 }
953
954
955 /* Single aligned words are guaranteed to use 16 or 32 bit access
956 * mode respectively, otherwise data is handled as quickly as
957 * possible
958 */
959 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
960 {
961 int retval;
962
963 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
964
965 if (((address % 2) == 0) && (size == 2))
966 {
967 return target->type->read_memory(target, address, 2, 1, buffer);
968 }
969
970 /* handle unaligned head bytes */
971 if (address % 4)
972 {
973 int unaligned = 4 - (address % 4);
974
975 if (unaligned > size)
976 unaligned = size;
977
978 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
979 return retval;
980
981 buffer += unaligned;
982 address += unaligned;
983 size -= unaligned;
984 }
985
986 /* handle aligned words */
987 if (size >= 4)
988 {
989 int aligned = size - (size % 4);
990
991 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
992 return retval;
993
994 buffer += aligned;
995 address += aligned;
996 size -= aligned;
997 }
998
999 /* handle tail writes of less than 4 bytes */
1000 if (size > 0)
1001 {
1002 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1003 return retval;
1004 }
1005
1006 return ERROR_OK;
1007 }
1008
1009 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1010 {
1011 u8 *buffer;
1012 int retval;
1013 int i;
1014 u32 checksum = 0;
1015
1016 if ((retval = target->type->checksum_memory(target, address,
1017 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1018 {
1019 buffer = malloc(size);
1020 if (buffer == NULL)
1021 {
1022 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1023 return ERROR_INVALID_ARGUMENTS;
1024 }
1025 retval = target_read_buffer(target, address, size, buffer);
1026 if (retval != ERROR_OK)
1027 {
1028 free(buffer);
1029 return retval;
1030 }
1031
1032 /* convert to target endianess */
1033 for (i = 0; i < (size/sizeof(u32)); i++)
1034 {
1035 u32 target_data;
1036 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1037 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1038 }
1039
1040 retval = image_calculate_checksum( buffer, size, &checksum );
1041 free(buffer);
1042 }
1043
1044 *crc = checksum;
1045
1046 return retval;
1047 }
1048
1049 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1050 {
1051 u8 value_buf[4];
1052
1053 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1054
1055 if (retval == ERROR_OK)
1056 {
1057 *value = target_buffer_get_u32(target, value_buf);
1058 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1059 }
1060 else
1061 {
1062 *value = 0x0;
1063 LOG_DEBUG("address: 0x%8.8x failed", address);
1064 }
1065
1066 return retval;
1067 }
1068
1069 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1070 {
1071 u8 value_buf[2];
1072
1073 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1074
1075 if (retval == ERROR_OK)
1076 {
1077 *value = target_buffer_get_u16(target, value_buf);
1078 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1079 }
1080 else
1081 {
1082 *value = 0x0;
1083 LOG_DEBUG("address: 0x%8.8x failed", address);
1084 }
1085
1086 return retval;
1087 }
1088
1089 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1090 {
1091 int retval = target->type->read_memory(target, address, 1, 1, value);
1092
1093 if (retval == ERROR_OK)
1094 {
1095 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1096 }
1097 else
1098 {
1099 *value = 0x0;
1100 LOG_DEBUG("address: 0x%8.8x failed", address);
1101 }
1102
1103 return retval;
1104 }
1105
1106 int target_write_u32(struct target_s *target, u32 address, u32 value)
1107 {
1108 int retval;
1109 u8 value_buf[4];
1110
1111 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1112
1113 target_buffer_set_u32(target, value_buf, value);
1114 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1115 {
1116 LOG_DEBUG("failed: %i", retval);
1117 }
1118
1119 return retval;
1120 }
1121
1122 int target_write_u16(struct target_s *target, u32 address, u16 value)
1123 {
1124 int retval;
1125 u8 value_buf[2];
1126
1127 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1128
1129 target_buffer_set_u16(target, value_buf, value);
1130 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1131 {
1132 LOG_DEBUG("failed: %i", retval);
1133 }
1134
1135 return retval;
1136 }
1137
1138 int target_write_u8(struct target_s *target, u32 address, u8 value)
1139 {
1140 int retval;
1141
1142 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1143
1144 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1145 {
1146 LOG_DEBUG("failed: %i", retval);
1147 }
1148
1149 return retval;
1150 }
1151
1152 int target_register_user_commands(struct command_context_s *cmd_ctx)
1153 {
1154 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1155 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1156 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1157 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1158 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1159 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1160 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1161 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1162
1163 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1164 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1165 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1166
1167 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1168 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1169 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1170
1171 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1172 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1173 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1174 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1175
1176 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1177 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1178 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1179 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1180 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1181
1182 target_request_register_commands(cmd_ctx);
1183 trace_register_commands(cmd_ctx);
1184
1185 return ERROR_OK;
1186 }
1187
1188 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1189 {
1190 target_t *target = targets;
1191 int count = 0;
1192
1193 if (argc == 1)
1194 {
1195 int num = strtoul(args[0], NULL, 0);
1196
1197 while (target)
1198 {
1199 count++;
1200 target = target->next;
1201 }
1202
1203 if (num < count)
1204 cmd_ctx->current_target = num;
1205 else
1206 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1207
1208 return ERROR_OK;
1209 }
1210
1211 while (target)
1212 {
1213 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1214 target = target->next;
1215 }
1216
1217 return ERROR_OK;
1218 }
1219
1220 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1221 {
1222 int i;
1223 int found = 0;
1224
1225 if (argc < 3)
1226 {
1227 return ERROR_COMMAND_SYNTAX_ERROR;
1228 }
1229
1230 /* search for the specified target */
1231 if (args[0] && (args[0][0] != 0))
1232 {
1233 for (i = 0; target_types[i]; i++)
1234 {
1235 if (strcmp(args[0], target_types[i]->name) == 0)
1236 {
1237 target_t **last_target_p = &targets;
1238
1239 /* register target specific commands */
1240 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1241 {
1242 LOG_ERROR("couldn't register '%s' commands", args[0]);
1243 exit(-1);
1244 }
1245
1246 if (*last_target_p)
1247 {
1248 while ((*last_target_p)->next)
1249 last_target_p = &((*last_target_p)->next);
1250 last_target_p = &((*last_target_p)->next);
1251 }
1252
1253 *last_target_p = malloc(sizeof(target_t));
1254
1255 (*last_target_p)->type = target_types[i];
1256
1257 if (strcmp(args[1], "big") == 0)
1258 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1259 else if (strcmp(args[1], "little") == 0)
1260 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1261 else
1262 {
1263 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1264 return ERROR_COMMAND_SYNTAX_ERROR;
1265 }
1266
1267 /* what to do on a target reset */
1268 (*last_target_p)->reset_mode = RESET_INIT; /* default */
1269 if (strcmp(args[2], "reset_halt") == 0)
1270 (*last_target_p)->reset_mode = RESET_HALT;
1271 else if (strcmp(args[2], "reset_run") == 0)
1272 (*last_target_p)->reset_mode = RESET_RUN;
1273 else if (strcmp(args[2], "reset_init") == 0)
1274 (*last_target_p)->reset_mode = RESET_INIT;
1275 else if (strcmp(args[2], "run_and_halt") == 0)
1276 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1277 else if (strcmp(args[2], "run_and_init") == 0)
1278 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1279 else
1280 {
1281 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1282 args--;
1283 argc++;
1284 }
1285 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1286
1287 (*last_target_p)->reset_script = NULL;
1288 (*last_target_p)->post_halt_script = NULL;
1289 (*last_target_p)->pre_resume_script = NULL;
1290 (*last_target_p)->gdb_program_script = NULL;
1291
1292 (*last_target_p)->working_area = 0x0;
1293 (*last_target_p)->working_area_size = 0x0;
1294 (*last_target_p)->working_areas = NULL;
1295 (*last_target_p)->backup_working_area = 0;
1296
1297 (*last_target_p)->state = TARGET_UNKNOWN;
1298 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1299 (*last_target_p)->reg_cache = NULL;
1300 (*last_target_p)->breakpoints = NULL;
1301 (*last_target_p)->watchpoints = NULL;
1302 (*last_target_p)->next = NULL;
1303 (*last_target_p)->arch_info = NULL;
1304
1305 /* initialize trace information */
1306 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1307 (*last_target_p)->trace_info->num_trace_points = 0;
1308 (*last_target_p)->trace_info->trace_points_size = 0;
1309 (*last_target_p)->trace_info->trace_points = NULL;
1310 (*last_target_p)->trace_info->trace_history_size = 0;
1311 (*last_target_p)->trace_info->trace_history = NULL;
1312 (*last_target_p)->trace_info->trace_history_pos = 0;
1313 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1314
1315 (*last_target_p)->dbgmsg = NULL;
1316 (*last_target_p)->dbg_msg_enabled = 0;
1317
1318 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1319
1320 found = 1;
1321 break;
1322 }
1323 }
1324 }
1325
1326 /* no matching target found */
1327 if (!found)
1328 {
1329 LOG_ERROR("target '%s' not found", args[0]);
1330 return ERROR_COMMAND_SYNTAX_ERROR;
1331 }
1332
1333 return ERROR_OK;
1334 }
1335
1336 /* usage: target_script <target#> <event> <script_file> */
1337 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1338 {
1339 target_t *target = NULL;
1340
1341 if (argc < 3)
1342 {
1343 LOG_ERROR("incomplete target_script command");
1344 return ERROR_COMMAND_SYNTAX_ERROR;
1345 }
1346
1347 target = get_target_by_num(strtoul(args[0], NULL, 0));
1348
1349 if (!target)
1350 {
1351 return ERROR_COMMAND_SYNTAX_ERROR;
1352 }
1353
1354 if (strcmp(args[1], "reset") == 0)
1355 {
1356 if (target->reset_script)
1357 free(target->reset_script);
1358 target->reset_script = strdup(args[2]);
1359 }
1360 else if (strcmp(args[1], "post_halt") == 0)
1361 {
1362 if (target->post_halt_script)
1363 free(target->post_halt_script);
1364 target->post_halt_script = strdup(args[2]);
1365 }
1366 else if (strcmp(args[1], "pre_resume") == 0)
1367 {
1368 if (target->pre_resume_script)
1369 free(target->pre_resume_script);
1370 target->pre_resume_script = strdup(args[2]);
1371 }
1372 else if (strcmp(args[1], "gdb_program_config") == 0)
1373 {
1374 if (target->gdb_program_script)
1375 free(target->gdb_program_script);
1376 target->gdb_program_script = strdup(args[2]);
1377 }
1378 else
1379 {
1380 LOG_ERROR("unknown event type: '%s", args[1]);
1381 return ERROR_COMMAND_SYNTAX_ERROR;
1382 }
1383
1384 return ERROR_OK;
1385 }
1386
1387 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1388 {
1389 target_t *target = NULL;
1390
1391 if (argc < 2)
1392 {
1393 return ERROR_COMMAND_SYNTAX_ERROR;
1394 }
1395
1396 target = get_target_by_num(strtoul(args[0], NULL, 0));
1397 if (!target)
1398 {
1399 return ERROR_COMMAND_SYNTAX_ERROR;
1400 }
1401
1402 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1403
1404 return ERROR_OK;
1405 }
1406
1407 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1408 {
1409 target_t *target = NULL;
1410
1411 if ((argc < 4) || (argc > 5))
1412 {
1413 return ERROR_COMMAND_SYNTAX_ERROR;
1414 }
1415
1416 target = get_target_by_num(strtoul(args[0], NULL, 0));
1417 if (!target)
1418 {
1419 return ERROR_COMMAND_SYNTAX_ERROR;
1420 }
1421 target_free_all_working_areas(target);
1422
1423 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1424 if (argc == 5)
1425 {
1426 target->working_area_virt = strtoul(args[4], NULL, 0);
1427 }
1428 target->working_area_size = strtoul(args[2], NULL, 0);
1429
1430 if (strcmp(args[3], "backup") == 0)
1431 {
1432 target->backup_working_area = 1;
1433 }
1434 else if (strcmp(args[3], "nobackup") == 0)
1435 {
1436 target->backup_working_area = 0;
1437 }
1438 else
1439 {
1440 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1441 return ERROR_COMMAND_SYNTAX_ERROR;
1442 }
1443
1444 return ERROR_OK;
1445 }
1446
1447
1448 /* process target state changes */
1449 int handle_target(void *priv)
1450 {
1451 target_t *target = targets;
1452
1453 while (target)
1454 {
1455 if (target_continous_poll)
1456 {
1457 /* polling may fail silently until the target has been examined */
1458 target_poll(target);
1459 }
1460
1461 target = target->next;
1462 }
1463
1464 return ERROR_OK;
1465 }
1466
1467 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1468 {
1469 target_t *target;
1470 reg_t *reg = NULL;
1471 int count = 0;
1472 char *value;
1473
1474 LOG_DEBUG("-");
1475
1476 target = get_current_target(cmd_ctx);
1477
1478 /* list all available registers for the current target */
1479 if (argc == 0)
1480 {
1481 reg_cache_t *cache = target->reg_cache;
1482
1483 count = 0;
1484 while(cache)
1485 {
1486 int i;
1487 for (i = 0; i < cache->num_regs; i++)
1488 {
1489 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1490 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);
1491 free(value);
1492 }
1493 cache = cache->next;
1494 }
1495
1496 return ERROR_OK;
1497 }
1498
1499 /* access a single register by its ordinal number */
1500 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1501 {
1502 int num = strtoul(args[0], NULL, 0);
1503 reg_cache_t *cache = target->reg_cache;
1504
1505 count = 0;
1506 while(cache)
1507 {
1508 int i;
1509 for (i = 0; i < cache->num_regs; i++)
1510 {
1511 if (count++ == num)
1512 {
1513 reg = &cache->reg_list[i];
1514 break;
1515 }
1516 }
1517 if (reg)
1518 break;
1519 cache = cache->next;
1520 }
1521
1522 if (!reg)
1523 {
1524 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1525 return ERROR_OK;
1526 }
1527 } else /* access a single register by its name */
1528 {
1529 reg = register_get_by_name(target->reg_cache, args[0], 1);
1530
1531 if (!reg)
1532 {
1533 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1534 return ERROR_OK;
1535 }
1536 }
1537
1538 /* display a register */
1539 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1540 {
1541 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1542 reg->valid = 0;
1543
1544 if (reg->valid == 0)
1545 {
1546 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1547 if (arch_type == NULL)
1548 {
1549 LOG_ERROR("BUG: encountered unregistered arch type");
1550 return ERROR_OK;
1551 }
1552 arch_type->get(reg);
1553 }
1554 value = buf_to_str(reg->value, reg->size, 16);
1555 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1556 free(value);
1557 return ERROR_OK;
1558 }
1559
1560 /* set register value */
1561 if (argc == 2)
1562 {
1563 u8 *buf = malloc(CEIL(reg->size, 8));
1564 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1565
1566 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1567 if (arch_type == NULL)
1568 {
1569 LOG_ERROR("BUG: encountered unregistered arch type");
1570 return ERROR_OK;
1571 }
1572
1573 arch_type->set(reg, buf);
1574
1575 value = buf_to_str(reg->value, reg->size, 16);
1576 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1577 free(value);
1578
1579 free(buf);
1580
1581 return ERROR_OK;
1582 }
1583
1584 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1585
1586 return ERROR_OK;
1587 }
1588
1589 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1590
1591 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1592 {
1593 target_t *target = get_current_target(cmd_ctx);
1594
1595 if (argc == 0)
1596 {
1597 target_poll(target);
1598 target_arch_state(target);
1599 }
1600 else
1601 {
1602 if (strcmp(args[0], "on") == 0)
1603 {
1604 target_continous_poll = 1;
1605 }
1606 else if (strcmp(args[0], "off") == 0)
1607 {
1608 target_continous_poll = 0;
1609 }
1610 else
1611 {
1612 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1613 }
1614 }
1615
1616
1617 return ERROR_OK;
1618 }
1619
1620 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1621 {
1622 int ms = 5000;
1623
1624 if (argc > 0)
1625 {
1626 char *end;
1627
1628 ms = strtoul(args[0], &end, 0) * 1000;
1629 if (*end)
1630 {
1631 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1632 return ERROR_OK;
1633 }
1634 }
1635
1636 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1637 }
1638
1639 static void target_process_events(struct command_context_s *cmd_ctx)
1640 {
1641 target_t *target = get_current_target(cmd_ctx);
1642 target_poll(target);
1643 target_call_timer_callbacks_now();
1644 }
1645
1646 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1647 {
1648 int retval;
1649 struct timeval timeout, now;
1650 int once=1;
1651 gettimeofday(&timeout, NULL);
1652 timeval_add_time(&timeout, 0, ms * 1000);
1653
1654 target_t *target = get_current_target(cmd_ctx);
1655 for (;;)
1656 {
1657 if ((retval=target_poll(target))!=ERROR_OK)
1658 return retval;
1659 target_call_timer_callbacks_now();
1660 if (target->state == state)
1661 {
1662 break;
1663 }
1664 if (once)
1665 {
1666 once=0;
1667 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1668 }
1669
1670 gettimeofday(&now, NULL);
1671 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1672 {
1673 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1674 break;
1675 }
1676 }
1677
1678 return ERROR_OK;
1679 }
1680
1681 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1682 {
1683 int retval;
1684 target_t *target = get_current_target(cmd_ctx);
1685
1686 LOG_DEBUG("-");
1687
1688 if ((retval = target_halt(target)) != ERROR_OK)
1689 {
1690 return retval;
1691 }
1692
1693 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1694 }
1695
1696
1697 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1698 {
1699 target_t *target = get_current_target(cmd_ctx);
1700
1701 LOG_USER("requesting target halt and executing a soft reset");
1702
1703 target->type->soft_reset_halt(target);
1704
1705 return ERROR_OK;
1706 }
1707
1708 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1709 {
1710 target_t *target = get_current_target(cmd_ctx);
1711 enum target_reset_mode reset_mode = target->reset_mode;
1712 enum target_reset_mode save = target->reset_mode;
1713
1714 LOG_DEBUG("-");
1715
1716 if (argc >= 1)
1717 {
1718 if (strcmp("run", args[0]) == 0)
1719 reset_mode = RESET_RUN;
1720 else if (strcmp("halt", args[0]) == 0)
1721 reset_mode = RESET_HALT;
1722 else if (strcmp("init", args[0]) == 0)
1723 reset_mode = RESET_INIT;
1724 else if (strcmp("run_and_halt", args[0]) == 0)
1725 {
1726 reset_mode = RESET_RUN_AND_HALT;
1727 if (argc >= 2)
1728 {
1729 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1730 }
1731 }
1732 else if (strcmp("run_and_init", args[0]) == 0)
1733 {
1734 reset_mode = RESET_RUN_AND_INIT;
1735 if (argc >= 2)
1736 {
1737 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1738 }
1739 }
1740 else
1741 {
1742 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1743 return ERROR_OK;
1744 }
1745 }
1746
1747 /* temporarily modify mode of current reset target */
1748 target->reset_mode = reset_mode;
1749
1750 /* reset *all* targets */
1751 target_process_reset(cmd_ctx);
1752
1753 /* Restore default reset mode for this target */
1754 target->reset_mode = save;
1755
1756 return ERROR_OK;
1757 }
1758
1759 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1760 {
1761 int retval;
1762 target_t *target = get_current_target(cmd_ctx);
1763
1764 if (argc == 0)
1765 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1766 else if (argc == 1)
1767 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1768 else
1769 {
1770 return ERROR_COMMAND_SYNTAX_ERROR;
1771 }
1772
1773 target_process_events(cmd_ctx);
1774
1775 return retval;
1776 }
1777
1778 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1779 {
1780 target_t *target = get_current_target(cmd_ctx);
1781
1782 LOG_DEBUG("-");
1783
1784 if (argc == 0)
1785 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1786
1787 if (argc == 1)
1788 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1789
1790 return ERROR_OK;
1791 }
1792
1793 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1794 {
1795 const int line_bytecnt = 32;
1796 int count = 1;
1797 int size = 4;
1798 u32 address = 0;
1799 int line_modulo;
1800 int i;
1801
1802 char output[128];
1803 int output_len;
1804
1805 int retval;
1806
1807 u8 *buffer;
1808 target_t *target = get_current_target(cmd_ctx);
1809
1810 if (argc < 1)
1811 return ERROR_OK;
1812
1813 if (argc == 2)
1814 count = strtoul(args[1], NULL, 0);
1815
1816 address = strtoul(args[0], NULL, 0);
1817
1818
1819 switch (cmd[2])
1820 {
1821 case 'w':
1822 size = 4; line_modulo = line_bytecnt / 4;
1823 break;
1824 case 'h':
1825 size = 2; line_modulo = line_bytecnt / 2;
1826 break;
1827 case 'b':
1828 size = 1; line_modulo = line_bytecnt / 1;
1829 break;
1830 default:
1831 return ERROR_OK;
1832 }
1833
1834 buffer = calloc(count, size);
1835 retval = target->type->read_memory(target, address, size, count, buffer);
1836 if (retval == ERROR_OK)
1837 {
1838 output_len = 0;
1839
1840 for (i = 0; i < count; i++)
1841 {
1842 if (i%line_modulo == 0)
1843 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1844
1845 switch (size)
1846 {
1847 case 4:
1848 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1849 break;
1850 case 2:
1851 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1852 break;
1853 case 1:
1854 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1855 break;
1856 }
1857
1858 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1859 {
1860 command_print(cmd_ctx, output);
1861 output_len = 0;
1862 }
1863 }
1864 } else
1865 {
1866 LOG_ERROR("Failure examining memory");
1867 }
1868
1869 free(buffer);
1870
1871 return ERROR_OK;
1872 }
1873
1874 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1875 {
1876 u32 address = 0;
1877 u32 value = 0;
1878 int count = 1;
1879 int i;
1880 int wordsize;
1881 target_t *target = get_current_target(cmd_ctx);
1882 u8 value_buf[4];
1883
1884 if ((argc < 2) || (argc > 3))
1885 return ERROR_COMMAND_SYNTAX_ERROR;
1886
1887 address = strtoul(args[0], NULL, 0);
1888 value = strtoul(args[1], NULL, 0);
1889 if (argc == 3)
1890 count = strtoul(args[2], NULL, 0);
1891
1892
1893 switch (cmd[2])
1894 {
1895 case 'w':
1896 wordsize = 4;
1897 target_buffer_set_u32(target, value_buf, value);
1898 break;
1899 case 'h':
1900 wordsize = 2;
1901 target_buffer_set_u16(target, value_buf, value);
1902 break;
1903 case 'b':
1904 wordsize = 1;
1905 value_buf[0] = value;
1906 break;
1907 default:
1908 return ERROR_COMMAND_SYNTAX_ERROR;
1909 }
1910 for (i=0; i<count; i++)
1911 {
1912 int retval;
1913 switch (wordsize)
1914 {
1915 case 4:
1916 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1917 break;
1918 case 2:
1919 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1920 break;
1921 case 1:
1922 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1923 break;
1924 default:
1925 return ERROR_OK;
1926 }
1927 if (retval!=ERROR_OK)
1928 {
1929 return retval;
1930 }
1931 }
1932
1933 return ERROR_OK;
1934
1935 }
1936
1937 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1938 {
1939 u8 *buffer;
1940 u32 buf_cnt;
1941 u32 image_size;
1942 int i;
1943 int retval;
1944
1945 image_t image;
1946
1947 duration_t duration;
1948 char *duration_text;
1949
1950 target_t *target = get_current_target(cmd_ctx);
1951
1952 if (argc < 1)
1953 {
1954 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1955 return ERROR_OK;
1956 }
1957
1958 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1959 if (argc >= 2)
1960 {
1961 image.base_address_set = 1;
1962 image.base_address = strtoul(args[1], NULL, 0);
1963 }
1964 else
1965 {
1966 image.base_address_set = 0;
1967 }
1968
1969 image.start_address_set = 0;
1970
1971 duration_start_measure(&duration);
1972
1973 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1974 {
1975 return ERROR_OK;
1976 }
1977
1978 image_size = 0x0;
1979 retval = ERROR_OK;
1980 for (i = 0; i < image.num_sections; i++)
1981 {
1982 buffer = malloc(image.sections[i].size);
1983 if (buffer == NULL)
1984 {
1985 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1986 break;
1987 }
1988
1989 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1990 {
1991 free(buffer);
1992 break;
1993 }
1994 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
1995 {
1996 free(buffer);
1997 break;
1998 }
1999 image_size += buf_cnt;
2000 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2001
2002 free(buffer);
2003 }
2004
2005 duration_stop_measure(&duration, &duration_text);
2006 if (retval==ERROR_OK)
2007 {
2008 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2009 }
2010 free(duration_text);
2011
2012 image_close(&image);
2013
2014 return retval;
2015
2016 }
2017
2018 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2019 {
2020 fileio_t fileio;
2021
2022 u32 address;
2023 u32 size;
2024 u8 buffer[560];
2025 int retval=ERROR_OK;
2026
2027 duration_t duration;
2028 char *duration_text;
2029
2030 target_t *target = get_current_target(cmd_ctx);
2031
2032 if (argc != 3)
2033 {
2034 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2035 return ERROR_OK;
2036 }
2037
2038 address = strtoul(args[1], NULL, 0);
2039 size = strtoul(args[2], NULL, 0);
2040
2041 if ((address & 3) || (size & 3))
2042 {
2043 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2044 return ERROR_OK;
2045 }
2046
2047 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2048 {
2049 return ERROR_OK;
2050 }
2051
2052 duration_start_measure(&duration);
2053
2054 while (size > 0)
2055 {
2056 u32 size_written;
2057 u32 this_run_size = (size > 560) ? 560 : size;
2058
2059 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2060 if (retval != ERROR_OK)
2061 {
2062 break;
2063 }
2064
2065 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2066 if (retval != ERROR_OK)
2067 {
2068 break;
2069 }
2070
2071 size -= this_run_size;
2072 address += this_run_size;
2073 }
2074
2075 fileio_close(&fileio);
2076
2077 duration_stop_measure(&duration, &duration_text);
2078 if (retval==ERROR_OK)
2079 {
2080 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2081 }
2082 free(duration_text);
2083
2084 return ERROR_OK;
2085 }
2086
2087 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2088 {
2089 u8 *buffer;
2090 u32 buf_cnt;
2091 u32 image_size;
2092 int i;
2093 int retval;
2094 u32 checksum = 0;
2095 u32 mem_checksum = 0;
2096
2097 image_t image;
2098
2099 duration_t duration;
2100 char *duration_text;
2101
2102 target_t *target = get_current_target(cmd_ctx);
2103
2104 if (argc < 1)
2105 {
2106 return ERROR_COMMAND_SYNTAX_ERROR;
2107 }
2108
2109 if (!target)
2110 {
2111 LOG_ERROR("no target selected");
2112 return ERROR_FAIL;
2113 }
2114
2115 duration_start_measure(&duration);
2116
2117 if (argc >= 2)
2118 {
2119 image.base_address_set = 1;
2120 image.base_address = strtoul(args[1], NULL, 0);
2121 }
2122 else
2123 {
2124 image.base_address_set = 0;
2125 image.base_address = 0x0;
2126 }
2127
2128 image.start_address_set = 0;
2129
2130 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2131 {
2132 return retval;
2133 }
2134
2135 image_size = 0x0;
2136 retval=ERROR_OK;
2137 for (i = 0; i < image.num_sections; i++)
2138 {
2139 buffer = malloc(image.sections[i].size);
2140 if (buffer == NULL)
2141 {
2142 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2143 break;
2144 }
2145 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2146 {
2147 free(buffer);
2148 break;
2149 }
2150
2151 /* calculate checksum of image */
2152 image_calculate_checksum( buffer, buf_cnt, &checksum );
2153
2154 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2155 if( retval != ERROR_OK )
2156 {
2157 free(buffer);
2158 break;
2159 }
2160
2161 if( checksum != mem_checksum )
2162 {
2163 /* failed crc checksum, fall back to a binary compare */
2164 u8 *data;
2165
2166 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2167
2168 data = (u8*)malloc(buf_cnt);
2169
2170 /* Can we use 32bit word accesses? */
2171 int size = 1;
2172 int count = buf_cnt;
2173 if ((count % 4) == 0)
2174 {
2175 size *= 4;
2176 count /= 4;
2177 }
2178 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2179 if (retval == ERROR_OK)
2180 {
2181 int t;
2182 for (t = 0; t < buf_cnt; t++)
2183 {
2184 if (data[t] != buffer[t])
2185 {
2186 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]);
2187 free(data);
2188 free(buffer);
2189 retval=ERROR_FAIL;
2190 goto done;
2191 }
2192 }
2193 }
2194
2195 free(data);
2196 }
2197
2198 free(buffer);
2199 image_size += buf_cnt;
2200 }
2201 done:
2202 duration_stop_measure(&duration, &duration_text);
2203 if (retval==ERROR_OK)
2204 {
2205 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2206 }
2207 free(duration_text);
2208
2209 image_close(&image);
2210
2211 return retval;
2212 }
2213
2214 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2215 {
2216 int retval;
2217 target_t *target = get_current_target(cmd_ctx);
2218
2219 if (argc == 0)
2220 {
2221 breakpoint_t *breakpoint = target->breakpoints;
2222
2223 while (breakpoint)
2224 {
2225 if (breakpoint->type == BKPT_SOFT)
2226 {
2227 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2228 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2229 free(buf);
2230 }
2231 else
2232 {
2233 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2234 }
2235 breakpoint = breakpoint->next;
2236 }
2237 }
2238 else if (argc >= 2)
2239 {
2240 int hw = BKPT_SOFT;
2241 u32 length = 0;
2242
2243 length = strtoul(args[1], NULL, 0);
2244
2245 if (argc >= 3)
2246 if (strcmp(args[2], "hw") == 0)
2247 hw = BKPT_HARD;
2248
2249 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2250 {
2251 LOG_ERROR("Failure setting breakpoints");
2252 }
2253 else
2254 {
2255 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2256 }
2257 }
2258 else
2259 {
2260 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2261 }
2262
2263 return ERROR_OK;
2264 }
2265
2266 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2267 {
2268 target_t *target = get_current_target(cmd_ctx);
2269
2270 if (argc > 0)
2271 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2272
2273 return ERROR_OK;
2274 }
2275
2276 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2277 {
2278 target_t *target = get_current_target(cmd_ctx);
2279 int retval;
2280
2281 if (argc == 0)
2282 {
2283 watchpoint_t *watchpoint = target->watchpoints;
2284
2285 while (watchpoint)
2286 {
2287 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);
2288 watchpoint = watchpoint->next;
2289 }
2290 }
2291 else if (argc >= 2)
2292 {
2293 enum watchpoint_rw type = WPT_ACCESS;
2294 u32 data_value = 0x0;
2295 u32 data_mask = 0xffffffff;
2296
2297 if (argc >= 3)
2298 {
2299 switch(args[2][0])
2300 {
2301 case 'r':
2302 type = WPT_READ;
2303 break;
2304 case 'w':
2305 type = WPT_WRITE;
2306 break;
2307 case 'a':
2308 type = WPT_ACCESS;
2309 break;
2310 default:
2311 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2312 return ERROR_OK;
2313 }
2314 }
2315 if (argc >= 4)
2316 {
2317 data_value = strtoul(args[3], NULL, 0);
2318 }
2319 if (argc >= 5)
2320 {
2321 data_mask = strtoul(args[4], NULL, 0);
2322 }
2323
2324 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2325 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2326 {
2327 LOG_ERROR("Failure setting breakpoints");
2328 }
2329 }
2330 else
2331 {
2332 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2333 }
2334
2335 return ERROR_OK;
2336 }
2337
2338 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2339 {
2340 target_t *target = get_current_target(cmd_ctx);
2341
2342 if (argc > 0)
2343 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2344
2345 return ERROR_OK;
2346 }
2347
2348 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2349 {
2350 int retval;
2351 target_t *target = get_current_target(cmd_ctx);
2352 u32 va;
2353 u32 pa;
2354
2355 if (argc != 1)
2356 {
2357 return ERROR_COMMAND_SYNTAX_ERROR;
2358 }
2359 va = strtoul(args[0], NULL, 0);
2360
2361 retval = target->type->virt2phys(target, va, &pa);
2362 if (retval == ERROR_OK)
2363 {
2364 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2365 }
2366 else
2367 {
2368 /* lower levels will have logged a detailed error which is
2369 * forwarded to telnet/GDB session.
2370 */
2371 }
2372 return retval;
2373 }
2374 static void writeLong(FILE *f, int l)
2375 {
2376 int i;
2377 for (i=0; i<4; i++)
2378 {
2379 char c=(l>>(i*8))&0xff;
2380 fwrite(&c, 1, 1, f);
2381 }
2382
2383 }
2384 static void writeString(FILE *f, char *s)
2385 {
2386 fwrite(s, 1, strlen(s), f);
2387 }
2388
2389
2390
2391 // Dump a gmon.out histogram file.
2392 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2393 {
2394 int i;
2395 FILE *f=fopen(filename, "w");
2396 if (f==NULL)
2397 return;
2398 fwrite("gmon", 1, 4, f);
2399 writeLong(f, 0x00000001); // Version
2400 writeLong(f, 0); // padding
2401 writeLong(f, 0); // padding
2402 writeLong(f, 0); // padding
2403
2404 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2405
2406 // figure out bucket size
2407 u32 min=samples[0];
2408 u32 max=samples[0];
2409 for (i=0; i<sampleNum; i++)
2410 {
2411 if (min>samples[i])
2412 {
2413 min=samples[i];
2414 }
2415 if (max<samples[i])
2416 {
2417 max=samples[i];
2418 }
2419 }
2420
2421 int addressSpace=(max-min+1);
2422
2423 static int const maxBuckets=256*1024; // maximum buckets.
2424 int length=addressSpace;
2425 if (length > maxBuckets)
2426 {
2427 length=maxBuckets;
2428 }
2429 int *buckets=malloc(sizeof(int)*length);
2430 if (buckets==NULL)
2431 {
2432 fclose(f);
2433 return;
2434 }
2435 memset(buckets, 0, sizeof(int)*length);
2436 for (i=0; i<sampleNum;i++)
2437 {
2438 u32 address=samples[i];
2439 long long a=address-min;
2440 long long b=length-1;
2441 long long c=addressSpace-1;
2442 int index=(a*b)/c; // danger!!!! int32 overflows
2443 buckets[index]++;
2444 }
2445
2446 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2447 writeLong(f, min); // low_pc
2448 writeLong(f, max); // high_pc
2449 writeLong(f, length); // # of samples
2450 writeLong(f, 64000000); // 64MHz
2451 writeString(f, "seconds");
2452 for (i=0; i<(15-strlen("seconds")); i++)
2453 {
2454 fwrite("", 1, 1, f); // padding
2455 }
2456 writeString(f, "s");
2457
2458 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2459
2460 char *data=malloc(2*length);
2461 if (data!=NULL)
2462 {
2463 for (i=0; i<length;i++)
2464 {
2465 int val;
2466 val=buckets[i];
2467 if (val>65535)
2468 {
2469 val=65535;
2470 }
2471 data[i*2]=val&0xff;
2472 data[i*2+1]=(val>>8)&0xff;
2473 }
2474 free(buckets);
2475 fwrite(data, 1, length*2, f);
2476 free(data);
2477 } else
2478 {
2479 free(buckets);
2480 }
2481
2482 fclose(f);
2483 }
2484
2485 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2486 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2487 {
2488 target_t *target = get_current_target(cmd_ctx);
2489 struct timeval timeout, now;
2490
2491 gettimeofday(&timeout, NULL);
2492 if (argc!=2)
2493 {
2494 return ERROR_COMMAND_SYNTAX_ERROR;
2495 }
2496 char *end;
2497 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2498 if (*end)
2499 {
2500 return ERROR_OK;
2501 }
2502
2503 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2504
2505 static const int maxSample=10000;
2506 u32 *samples=malloc(sizeof(u32)*maxSample);
2507 if (samples==NULL)
2508 return ERROR_OK;
2509
2510 int numSamples=0;
2511 int retval=ERROR_OK;
2512 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2513 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2514
2515 for (;;)
2516 {
2517 target_poll(target);
2518 if (target->state == TARGET_HALTED)
2519 {
2520 u32 t=*((u32 *)reg->value);
2521 samples[numSamples++]=t;
2522 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2523 target_poll(target);
2524 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2525 } else if (target->state == TARGET_RUNNING)
2526 {
2527 // We want to quickly sample the PC.
2528 target_halt(target);
2529 } else
2530 {
2531 command_print(cmd_ctx, "Target not halted or running");
2532 retval=ERROR_OK;
2533 break;
2534 }
2535 if (retval!=ERROR_OK)
2536 {
2537 break;
2538 }
2539
2540 gettimeofday(&now, NULL);
2541 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2542 {
2543 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2544 target_poll(target);
2545 if (target->state == TARGET_HALTED)
2546 {
2547 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2548 }
2549 target_poll(target);
2550 writeGmon(samples, numSamples, args[1]);
2551 command_print(cmd_ctx, "Wrote %s", args[1]);
2552 break;
2553 }
2554 }
2555 free(samples);
2556
2557 return ERROR_OK;
2558 }
2559
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)