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