Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
target read/write is no longer attempted for target_xxx() functions when the target...
[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 if (!target->type->examined)
900 {
901 LOG_ERROR("Target not examined yet");
902 return ERROR_FAIL;
903 }
904
905 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
906
907 if (((address % 2) == 0) && (size == 2))
908 {
909 return target->type->write_memory(target, address, 2, 1, buffer);
910 }
911
912 /* handle unaligned head bytes */
913 if (address % 4)
914 {
915 int unaligned = 4 - (address % 4);
916
917 if (unaligned > size)
918 unaligned = size;
919
920 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
921 return retval;
922
923 buffer += unaligned;
924 address += unaligned;
925 size -= unaligned;
926 }
927
928 /* handle aligned words */
929 if (size >= 4)
930 {
931 int aligned = size - (size % 4);
932
933 /* use bulk writes above a certain limit. This may have to be changed */
934 if (aligned > 128)
935 {
936 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
937 return retval;
938 }
939 else
940 {
941 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
942 return retval;
943 }
944
945 buffer += aligned;
946 address += aligned;
947 size -= aligned;
948 }
949
950 /* handle tail writes of less than 4 bytes */
951 if (size > 0)
952 {
953 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
954 return retval;
955 }
956
957 return ERROR_OK;
958 }
959
960
961 /* Single aligned words are guaranteed to use 16 or 32 bit access
962 * mode respectively, otherwise data is handled as quickly as
963 * possible
964 */
965 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
966 {
967 int retval;
968 if (!target->type->examined)
969 {
970 LOG_ERROR("Target not examined yet");
971 return ERROR_FAIL;
972 }
973
974 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
975
976 if (((address % 2) == 0) && (size == 2))
977 {
978 return target->type->read_memory(target, address, 2, 1, buffer);
979 }
980
981 /* handle unaligned head bytes */
982 if (address % 4)
983 {
984 int unaligned = 4 - (address % 4);
985
986 if (unaligned > size)
987 unaligned = size;
988
989 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
990 return retval;
991
992 buffer += unaligned;
993 address += unaligned;
994 size -= unaligned;
995 }
996
997 /* handle aligned words */
998 if (size >= 4)
999 {
1000 int aligned = size - (size % 4);
1001
1002 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1003 return retval;
1004
1005 buffer += aligned;
1006 address += aligned;
1007 size -= aligned;
1008 }
1009
1010 /* handle tail writes of less than 4 bytes */
1011 if (size > 0)
1012 {
1013 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1014 return retval;
1015 }
1016
1017 return ERROR_OK;
1018 }
1019
1020 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1021 {
1022 u8 *buffer;
1023 int retval;
1024 int i;
1025 u32 checksum = 0;
1026 if (!target->type->examined)
1027 {
1028 LOG_ERROR("Target not examined yet");
1029 return ERROR_FAIL;
1030 }
1031
1032 if ((retval = target->type->checksum_memory(target, address,
1033 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1034 {
1035 buffer = malloc(size);
1036 if (buffer == NULL)
1037 {
1038 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1039 return ERROR_INVALID_ARGUMENTS;
1040 }
1041 retval = target_read_buffer(target, address, size, buffer);
1042 if (retval != ERROR_OK)
1043 {
1044 free(buffer);
1045 return retval;
1046 }
1047
1048 /* convert to target endianess */
1049 for (i = 0; i < (size/sizeof(u32)); i++)
1050 {
1051 u32 target_data;
1052 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1053 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1054 }
1055
1056 retval = image_calculate_checksum( buffer, size, &checksum );
1057 free(buffer);
1058 }
1059
1060 *crc = checksum;
1061
1062 return retval;
1063 }
1064
1065 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1066 {
1067 u8 value_buf[4];
1068 if (!target->type->examined)
1069 {
1070 LOG_ERROR("Target not examined yet");
1071 return ERROR_FAIL;
1072 }
1073
1074 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1075
1076 if (retval == ERROR_OK)
1077 {
1078 *value = target_buffer_get_u32(target, value_buf);
1079 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", 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_u16(struct target_s *target, u32 address, u16 *value)
1091 {
1092 u8 value_buf[2];
1093 if (!target->type->examined)
1094 {
1095 LOG_ERROR("Target not examined yet");
1096 return ERROR_FAIL;
1097 }
1098
1099 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1100
1101 if (retval == ERROR_OK)
1102 {
1103 *value = target_buffer_get_u16(target, value_buf);
1104 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1105 }
1106 else
1107 {
1108 *value = 0x0;
1109 LOG_DEBUG("address: 0x%8.8x failed", address);
1110 }
1111
1112 return retval;
1113 }
1114
1115 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1116 {
1117 int retval = target->type->read_memory(target, address, 1, 1, value);
1118 if (!target->type->examined)
1119 {
1120 LOG_ERROR("Target not examined yet");
1121 return ERROR_FAIL;
1122 }
1123
1124 if (retval == ERROR_OK)
1125 {
1126 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1127 }
1128 else
1129 {
1130 *value = 0x0;
1131 LOG_DEBUG("address: 0x%8.8x failed", address);
1132 }
1133
1134 return retval;
1135 }
1136
1137 int target_write_u32(struct target_s *target, u32 address, u32 value)
1138 {
1139 int retval;
1140 u8 value_buf[4];
1141 if (!target->type->examined)
1142 {
1143 LOG_ERROR("Target not examined yet");
1144 return ERROR_FAIL;
1145 }
1146
1147 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1148
1149 target_buffer_set_u32(target, value_buf, value);
1150 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1151 {
1152 LOG_DEBUG("failed: %i", retval);
1153 }
1154
1155 return retval;
1156 }
1157
1158 int target_write_u16(struct target_s *target, u32 address, u16 value)
1159 {
1160 int retval;
1161 u8 value_buf[2];
1162 if (!target->type->examined)
1163 {
1164 LOG_ERROR("Target not examined yet");
1165 return ERROR_FAIL;
1166 }
1167
1168 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1169
1170 target_buffer_set_u16(target, value_buf, value);
1171 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1172 {
1173 LOG_DEBUG("failed: %i", retval);
1174 }
1175
1176 return retval;
1177 }
1178
1179 int target_write_u8(struct target_s *target, u32 address, u8 value)
1180 {
1181 int retval;
1182 if (!target->type->examined)
1183 {
1184 LOG_ERROR("Target not examined yet");
1185 return ERROR_FAIL;
1186 }
1187
1188 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1189
1190 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1191 {
1192 LOG_DEBUG("failed: %i", retval);
1193 }
1194
1195 return retval;
1196 }
1197
1198 int target_register_user_commands(struct command_context_s *cmd_ctx)
1199 {
1200 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1201 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1202 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1203 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1204 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1205 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1206 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1207 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1208
1209 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1210 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1211 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1212
1213 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1214 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1215 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1216
1217 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1218 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1219 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1220 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1221
1222 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1223 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1224 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1225 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1226 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1227
1228 target_request_register_commands(cmd_ctx);
1229 trace_register_commands(cmd_ctx);
1230
1231 return ERROR_OK;
1232 }
1233
1234 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1235 {
1236 target_t *target = targets;
1237 int count = 0;
1238
1239 if (argc == 1)
1240 {
1241 int num = strtoul(args[0], NULL, 0);
1242
1243 while (target)
1244 {
1245 count++;
1246 target = target->next;
1247 }
1248
1249 if (num < count)
1250 cmd_ctx->current_target = num;
1251 else
1252 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1253
1254 return ERROR_OK;
1255 }
1256
1257 while (target)
1258 {
1259 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1260 target = target->next;
1261 }
1262
1263 return ERROR_OK;
1264 }
1265
1266 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1267 {
1268 int i;
1269 int found = 0;
1270
1271 if (argc < 3)
1272 {
1273 return ERROR_COMMAND_SYNTAX_ERROR;
1274 }
1275
1276 /* search for the specified target */
1277 if (args[0] && (args[0][0] != 0))
1278 {
1279 for (i = 0; target_types[i]; i++)
1280 {
1281 if (strcmp(args[0], target_types[i]->name) == 0)
1282 {
1283 target_t **last_target_p = &targets;
1284
1285 /* register target specific commands */
1286 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1287 {
1288 LOG_ERROR("couldn't register '%s' commands", args[0]);
1289 exit(-1);
1290 }
1291
1292 if (*last_target_p)
1293 {
1294 while ((*last_target_p)->next)
1295 last_target_p = &((*last_target_p)->next);
1296 last_target_p = &((*last_target_p)->next);
1297 }
1298
1299 *last_target_p = malloc(sizeof(target_t));
1300
1301 (*last_target_p)->type = target_types[i];
1302
1303 if (strcmp(args[1], "big") == 0)
1304 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1305 else if (strcmp(args[1], "little") == 0)
1306 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1307 else
1308 {
1309 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1310 return ERROR_COMMAND_SYNTAX_ERROR;
1311 }
1312
1313 /* what to do on a target reset */
1314 (*last_target_p)->reset_mode = RESET_INIT; /* default */
1315 if (strcmp(args[2], "reset_halt") == 0)
1316 (*last_target_p)->reset_mode = RESET_HALT;
1317 else if (strcmp(args[2], "reset_run") == 0)
1318 (*last_target_p)->reset_mode = RESET_RUN;
1319 else if (strcmp(args[2], "reset_init") == 0)
1320 (*last_target_p)->reset_mode = RESET_INIT;
1321 else if (strcmp(args[2], "run_and_halt") == 0)
1322 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1323 else if (strcmp(args[2], "run_and_init") == 0)
1324 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1325 else
1326 {
1327 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1328 args--;
1329 argc++;
1330 }
1331 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1332
1333 (*last_target_p)->reset_script = NULL;
1334 (*last_target_p)->post_halt_script = NULL;
1335 (*last_target_p)->pre_resume_script = NULL;
1336 (*last_target_p)->gdb_program_script = NULL;
1337
1338 (*last_target_p)->working_area = 0x0;
1339 (*last_target_p)->working_area_size = 0x0;
1340 (*last_target_p)->working_areas = NULL;
1341 (*last_target_p)->backup_working_area = 0;
1342
1343 (*last_target_p)->state = TARGET_UNKNOWN;
1344 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1345 (*last_target_p)->reg_cache = NULL;
1346 (*last_target_p)->breakpoints = NULL;
1347 (*last_target_p)->watchpoints = NULL;
1348 (*last_target_p)->next = NULL;
1349 (*last_target_p)->arch_info = NULL;
1350
1351 /* initialize trace information */
1352 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1353 (*last_target_p)->trace_info->num_trace_points = 0;
1354 (*last_target_p)->trace_info->trace_points_size = 0;
1355 (*last_target_p)->trace_info->trace_points = NULL;
1356 (*last_target_p)->trace_info->trace_history_size = 0;
1357 (*last_target_p)->trace_info->trace_history = NULL;
1358 (*last_target_p)->trace_info->trace_history_pos = 0;
1359 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1360
1361 (*last_target_p)->dbgmsg = NULL;
1362 (*last_target_p)->dbg_msg_enabled = 0;
1363
1364 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1365
1366 found = 1;
1367 break;
1368 }
1369 }
1370 }
1371
1372 /* no matching target found */
1373 if (!found)
1374 {
1375 LOG_ERROR("target '%s' not found", args[0]);
1376 return ERROR_COMMAND_SYNTAX_ERROR;
1377 }
1378
1379 return ERROR_OK;
1380 }
1381
1382 /* usage: target_script <target#> <event> <script_file> */
1383 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1384 {
1385 target_t *target = NULL;
1386
1387 if (argc < 3)
1388 {
1389 LOG_ERROR("incomplete target_script command");
1390 return ERROR_COMMAND_SYNTAX_ERROR;
1391 }
1392
1393 target = get_target_by_num(strtoul(args[0], NULL, 0));
1394
1395 if (!target)
1396 {
1397 return ERROR_COMMAND_SYNTAX_ERROR;
1398 }
1399
1400 if (strcmp(args[1], "reset") == 0)
1401 {
1402 if (target->reset_script)
1403 free(target->reset_script);
1404 target->reset_script = strdup(args[2]);
1405 }
1406 else if (strcmp(args[1], "post_halt") == 0)
1407 {
1408 if (target->post_halt_script)
1409 free(target->post_halt_script);
1410 target->post_halt_script = strdup(args[2]);
1411 }
1412 else if (strcmp(args[1], "pre_resume") == 0)
1413 {
1414 if (target->pre_resume_script)
1415 free(target->pre_resume_script);
1416 target->pre_resume_script = strdup(args[2]);
1417 }
1418 else if (strcmp(args[1], "gdb_program_config") == 0)
1419 {
1420 if (target->gdb_program_script)
1421 free(target->gdb_program_script);
1422 target->gdb_program_script = strdup(args[2]);
1423 }
1424 else
1425 {
1426 LOG_ERROR("unknown event type: '%s", args[1]);
1427 return ERROR_COMMAND_SYNTAX_ERROR;
1428 }
1429
1430 return ERROR_OK;
1431 }
1432
1433 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1434 {
1435 target_t *target = NULL;
1436
1437 if (argc < 2)
1438 {
1439 return ERROR_COMMAND_SYNTAX_ERROR;
1440 }
1441
1442 target = get_target_by_num(strtoul(args[0], NULL, 0));
1443 if (!target)
1444 {
1445 return ERROR_COMMAND_SYNTAX_ERROR;
1446 }
1447
1448 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1449
1450 return ERROR_OK;
1451 }
1452
1453 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1454 {
1455 target_t *target = NULL;
1456
1457 if ((argc < 4) || (argc > 5))
1458 {
1459 return ERROR_COMMAND_SYNTAX_ERROR;
1460 }
1461
1462 target = get_target_by_num(strtoul(args[0], NULL, 0));
1463 if (!target)
1464 {
1465 return ERROR_COMMAND_SYNTAX_ERROR;
1466 }
1467 target_free_all_working_areas(target);
1468
1469 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1470 if (argc == 5)
1471 {
1472 target->working_area_virt = strtoul(args[4], NULL, 0);
1473 }
1474 target->working_area_size = strtoul(args[2], NULL, 0);
1475
1476 if (strcmp(args[3], "backup") == 0)
1477 {
1478 target->backup_working_area = 1;
1479 }
1480 else if (strcmp(args[3], "nobackup") == 0)
1481 {
1482 target->backup_working_area = 0;
1483 }
1484 else
1485 {
1486 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1487 return ERROR_COMMAND_SYNTAX_ERROR;
1488 }
1489
1490 return ERROR_OK;
1491 }
1492
1493
1494 /* process target state changes */
1495 int handle_target(void *priv)
1496 {
1497 target_t *target = targets;
1498
1499 while (target)
1500 {
1501 if (target_continous_poll)
1502 {
1503 /* polling may fail silently until the target has been examined */
1504 target_poll(target);
1505 }
1506
1507 target = target->next;
1508 }
1509
1510 return ERROR_OK;
1511 }
1512
1513 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1514 {
1515 target_t *target;
1516 reg_t *reg = NULL;
1517 int count = 0;
1518 char *value;
1519
1520 LOG_DEBUG("-");
1521
1522 target = get_current_target(cmd_ctx);
1523
1524 /* list all available registers for the current target */
1525 if (argc == 0)
1526 {
1527 reg_cache_t *cache = target->reg_cache;
1528
1529 count = 0;
1530 while(cache)
1531 {
1532 int i;
1533 for (i = 0; i < cache->num_regs; i++)
1534 {
1535 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1536 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);
1537 free(value);
1538 }
1539 cache = cache->next;
1540 }
1541
1542 return ERROR_OK;
1543 }
1544
1545 /* access a single register by its ordinal number */
1546 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1547 {
1548 int num = strtoul(args[0], NULL, 0);
1549 reg_cache_t *cache = target->reg_cache;
1550
1551 count = 0;
1552 while(cache)
1553 {
1554 int i;
1555 for (i = 0; i < cache->num_regs; i++)
1556 {
1557 if (count++ == num)
1558 {
1559 reg = &cache->reg_list[i];
1560 break;
1561 }
1562 }
1563 if (reg)
1564 break;
1565 cache = cache->next;
1566 }
1567
1568 if (!reg)
1569 {
1570 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1571 return ERROR_OK;
1572 }
1573 } else /* access a single register by its name */
1574 {
1575 reg = register_get_by_name(target->reg_cache, args[0], 1);
1576
1577 if (!reg)
1578 {
1579 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1580 return ERROR_OK;
1581 }
1582 }
1583
1584 /* display a register */
1585 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1586 {
1587 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1588 reg->valid = 0;
1589
1590 if (reg->valid == 0)
1591 {
1592 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1593 if (arch_type == NULL)
1594 {
1595 LOG_ERROR("BUG: encountered unregistered arch type");
1596 return ERROR_OK;
1597 }
1598 arch_type->get(reg);
1599 }
1600 value = buf_to_str(reg->value, reg->size, 16);
1601 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1602 free(value);
1603 return ERROR_OK;
1604 }
1605
1606 /* set register value */
1607 if (argc == 2)
1608 {
1609 u8 *buf = malloc(CEIL(reg->size, 8));
1610 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1611
1612 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1613 if (arch_type == NULL)
1614 {
1615 LOG_ERROR("BUG: encountered unregistered arch type");
1616 return ERROR_OK;
1617 }
1618
1619 arch_type->set(reg, buf);
1620
1621 value = buf_to_str(reg->value, reg->size, 16);
1622 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1623 free(value);
1624
1625 free(buf);
1626
1627 return ERROR_OK;
1628 }
1629
1630 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1631
1632 return ERROR_OK;
1633 }
1634
1635 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1636
1637 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1638 {
1639 target_t *target = get_current_target(cmd_ctx);
1640
1641 if (argc == 0)
1642 {
1643 target_poll(target);
1644 target_arch_state(target);
1645 }
1646 else
1647 {
1648 if (strcmp(args[0], "on") == 0)
1649 {
1650 target_continous_poll = 1;
1651 }
1652 else if (strcmp(args[0], "off") == 0)
1653 {
1654 target_continous_poll = 0;
1655 }
1656 else
1657 {
1658 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1659 }
1660 }
1661
1662
1663 return ERROR_OK;
1664 }
1665
1666 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1667 {
1668 int ms = 5000;
1669
1670 if (argc > 0)
1671 {
1672 char *end;
1673
1674 ms = strtoul(args[0], &end, 0) * 1000;
1675 if (*end)
1676 {
1677 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1678 return ERROR_OK;
1679 }
1680 }
1681
1682 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1683 }
1684
1685 static void target_process_events(struct command_context_s *cmd_ctx)
1686 {
1687 target_t *target = get_current_target(cmd_ctx);
1688 target_poll(target);
1689 target_call_timer_callbacks_now();
1690 }
1691
1692 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1693 {
1694 int retval;
1695 struct timeval timeout, now;
1696 int once=1;
1697 gettimeofday(&timeout, NULL);
1698 timeval_add_time(&timeout, 0, ms * 1000);
1699
1700 target_t *target = get_current_target(cmd_ctx);
1701 for (;;)
1702 {
1703 if ((retval=target_poll(target))!=ERROR_OK)
1704 return retval;
1705 target_call_timer_callbacks_now();
1706 if (target->state == state)
1707 {
1708 break;
1709 }
1710 if (once)
1711 {
1712 once=0;
1713 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1714 }
1715
1716 gettimeofday(&now, NULL);
1717 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1718 {
1719 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1720 break;
1721 }
1722 }
1723
1724 return ERROR_OK;
1725 }
1726
1727 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1728 {
1729 int retval;
1730 target_t *target = get_current_target(cmd_ctx);
1731
1732 LOG_DEBUG("-");
1733
1734 if ((retval = target_halt(target)) != ERROR_OK)
1735 {
1736 return retval;
1737 }
1738
1739 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1740 }
1741
1742
1743 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1744 {
1745 target_t *target = get_current_target(cmd_ctx);
1746
1747 LOG_USER("requesting target halt and executing a soft reset");
1748
1749 target->type->soft_reset_halt(target);
1750
1751 return ERROR_OK;
1752 }
1753
1754 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1755 {
1756 target_t *target = get_current_target(cmd_ctx);
1757 enum target_reset_mode reset_mode = target->reset_mode;
1758 enum target_reset_mode save = target->reset_mode;
1759
1760 LOG_DEBUG("-");
1761
1762 if (argc >= 1)
1763 {
1764 if (strcmp("run", args[0]) == 0)
1765 reset_mode = RESET_RUN;
1766 else if (strcmp("halt", args[0]) == 0)
1767 reset_mode = RESET_HALT;
1768 else if (strcmp("init", args[0]) == 0)
1769 reset_mode = RESET_INIT;
1770 else if (strcmp("run_and_halt", args[0]) == 0)
1771 {
1772 reset_mode = RESET_RUN_AND_HALT;
1773 if (argc >= 2)
1774 {
1775 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1776 }
1777 }
1778 else if (strcmp("run_and_init", args[0]) == 0)
1779 {
1780 reset_mode = RESET_RUN_AND_INIT;
1781 if (argc >= 2)
1782 {
1783 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1784 }
1785 }
1786 else
1787 {
1788 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1789 return ERROR_OK;
1790 }
1791 }
1792
1793 /* temporarily modify mode of current reset target */
1794 target->reset_mode = reset_mode;
1795
1796 /* reset *all* targets */
1797 target_process_reset(cmd_ctx);
1798
1799 /* Restore default reset mode for this target */
1800 target->reset_mode = save;
1801
1802 return ERROR_OK;
1803 }
1804
1805 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1806 {
1807 int retval;
1808 target_t *target = get_current_target(cmd_ctx);
1809
1810 if (argc == 0)
1811 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1812 else if (argc == 1)
1813 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1814 else
1815 {
1816 return ERROR_COMMAND_SYNTAX_ERROR;
1817 }
1818
1819 target_process_events(cmd_ctx);
1820
1821 return retval;
1822 }
1823
1824 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1825 {
1826 target_t *target = get_current_target(cmd_ctx);
1827
1828 LOG_DEBUG("-");
1829
1830 if (argc == 0)
1831 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1832
1833 if (argc == 1)
1834 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1835
1836 return ERROR_OK;
1837 }
1838
1839 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1840 {
1841 const int line_bytecnt = 32;
1842 int count = 1;
1843 int size = 4;
1844 u32 address = 0;
1845 int line_modulo;
1846 int i;
1847
1848 char output[128];
1849 int output_len;
1850
1851 int retval;
1852
1853 u8 *buffer;
1854 target_t *target = get_current_target(cmd_ctx);
1855
1856 if (argc < 1)
1857 return ERROR_OK;
1858
1859 if (argc == 2)
1860 count = strtoul(args[1], NULL, 0);
1861
1862 address = strtoul(args[0], NULL, 0);
1863
1864
1865 switch (cmd[2])
1866 {
1867 case 'w':
1868 size = 4; line_modulo = line_bytecnt / 4;
1869 break;
1870 case 'h':
1871 size = 2; line_modulo = line_bytecnt / 2;
1872 break;
1873 case 'b':
1874 size = 1; line_modulo = line_bytecnt / 1;
1875 break;
1876 default:
1877 return ERROR_OK;
1878 }
1879
1880 buffer = calloc(count, size);
1881 retval = target->type->read_memory(target, address, size, count, buffer);
1882 if (retval == ERROR_OK)
1883 {
1884 output_len = 0;
1885
1886 for (i = 0; i < count; i++)
1887 {
1888 if (i%line_modulo == 0)
1889 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1890
1891 switch (size)
1892 {
1893 case 4:
1894 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1895 break;
1896 case 2:
1897 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1898 break;
1899 case 1:
1900 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1901 break;
1902 }
1903
1904 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1905 {
1906 command_print(cmd_ctx, output);
1907 output_len = 0;
1908 }
1909 }
1910 } else
1911 {
1912 LOG_ERROR("Failure examining memory");
1913 }
1914
1915 free(buffer);
1916
1917 return ERROR_OK;
1918 }
1919
1920 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1921 {
1922 u32 address = 0;
1923 u32 value = 0;
1924 int count = 1;
1925 int i;
1926 int wordsize;
1927 target_t *target = get_current_target(cmd_ctx);
1928 u8 value_buf[4];
1929
1930 if ((argc < 2) || (argc > 3))
1931 return ERROR_COMMAND_SYNTAX_ERROR;
1932
1933 address = strtoul(args[0], NULL, 0);
1934 value = strtoul(args[1], NULL, 0);
1935 if (argc == 3)
1936 count = strtoul(args[2], NULL, 0);
1937
1938
1939 switch (cmd[2])
1940 {
1941 case 'w':
1942 wordsize = 4;
1943 target_buffer_set_u32(target, value_buf, value);
1944 break;
1945 case 'h':
1946 wordsize = 2;
1947 target_buffer_set_u16(target, value_buf, value);
1948 break;
1949 case 'b':
1950 wordsize = 1;
1951 value_buf[0] = value;
1952 break;
1953 default:
1954 return ERROR_COMMAND_SYNTAX_ERROR;
1955 }
1956 for (i=0; i<count; i++)
1957 {
1958 int retval;
1959 switch (wordsize)
1960 {
1961 case 4:
1962 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1963 break;
1964 case 2:
1965 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1966 break;
1967 case 1:
1968 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1969 break;
1970 default:
1971 return ERROR_OK;
1972 }
1973 if (retval!=ERROR_OK)
1974 {
1975 return retval;
1976 }
1977 }
1978
1979 return ERROR_OK;
1980
1981 }
1982
1983 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1984 {
1985 u8 *buffer;
1986 u32 buf_cnt;
1987 u32 image_size;
1988 int i;
1989 int retval;
1990
1991 image_t image;
1992
1993 duration_t duration;
1994 char *duration_text;
1995
1996 target_t *target = get_current_target(cmd_ctx);
1997
1998 if (argc < 1)
1999 {
2000 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
2001 return ERROR_OK;
2002 }
2003
2004 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2005 if (argc >= 2)
2006 {
2007 image.base_address_set = 1;
2008 image.base_address = strtoul(args[1], NULL, 0);
2009 }
2010 else
2011 {
2012 image.base_address_set = 0;
2013 }
2014
2015 image.start_address_set = 0;
2016
2017 duration_start_measure(&duration);
2018
2019 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2020 {
2021 return ERROR_OK;
2022 }
2023
2024 image_size = 0x0;
2025 retval = ERROR_OK;
2026 for (i = 0; i < image.num_sections; i++)
2027 {
2028 buffer = malloc(image.sections[i].size);
2029 if (buffer == NULL)
2030 {
2031 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2032 break;
2033 }
2034
2035 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2036 {
2037 free(buffer);
2038 break;
2039 }
2040 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
2041 {
2042 free(buffer);
2043 break;
2044 }
2045 image_size += buf_cnt;
2046 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2047
2048 free(buffer);
2049 }
2050
2051 duration_stop_measure(&duration, &duration_text);
2052 if (retval==ERROR_OK)
2053 {
2054 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2055 }
2056 free(duration_text);
2057
2058 image_close(&image);
2059
2060 return retval;
2061
2062 }
2063
2064 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2065 {
2066 fileio_t fileio;
2067
2068 u32 address;
2069 u32 size;
2070 u8 buffer[560];
2071 int retval=ERROR_OK;
2072
2073 duration_t duration;
2074 char *duration_text;
2075
2076 target_t *target = get_current_target(cmd_ctx);
2077
2078 if (argc != 3)
2079 {
2080 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2081 return ERROR_OK;
2082 }
2083
2084 address = strtoul(args[1], NULL, 0);
2085 size = strtoul(args[2], NULL, 0);
2086
2087 if ((address & 3) || (size & 3))
2088 {
2089 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2090 return ERROR_OK;
2091 }
2092
2093 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2094 {
2095 return ERROR_OK;
2096 }
2097
2098 duration_start_measure(&duration);
2099
2100 while (size > 0)
2101 {
2102 u32 size_written;
2103 u32 this_run_size = (size > 560) ? 560 : size;
2104
2105 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2106 if (retval != ERROR_OK)
2107 {
2108 break;
2109 }
2110
2111 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2112 if (retval != ERROR_OK)
2113 {
2114 break;
2115 }
2116
2117 size -= this_run_size;
2118 address += this_run_size;
2119 }
2120
2121 fileio_close(&fileio);
2122
2123 duration_stop_measure(&duration, &duration_text);
2124 if (retval==ERROR_OK)
2125 {
2126 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2127 }
2128 free(duration_text);
2129
2130 return ERROR_OK;
2131 }
2132
2133 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2134 {
2135 u8 *buffer;
2136 u32 buf_cnt;
2137 u32 image_size;
2138 int i;
2139 int retval;
2140 u32 checksum = 0;
2141 u32 mem_checksum = 0;
2142
2143 image_t image;
2144
2145 duration_t duration;
2146 char *duration_text;
2147
2148 target_t *target = get_current_target(cmd_ctx);
2149
2150 if (argc < 1)
2151 {
2152 return ERROR_COMMAND_SYNTAX_ERROR;
2153 }
2154
2155 if (!target)
2156 {
2157 LOG_ERROR("no target selected");
2158 return ERROR_FAIL;
2159 }
2160
2161 duration_start_measure(&duration);
2162
2163 if (argc >= 2)
2164 {
2165 image.base_address_set = 1;
2166 image.base_address = strtoul(args[1], NULL, 0);
2167 }
2168 else
2169 {
2170 image.base_address_set = 0;
2171 image.base_address = 0x0;
2172 }
2173
2174 image.start_address_set = 0;
2175
2176 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2177 {
2178 return retval;
2179 }
2180
2181 image_size = 0x0;
2182 retval=ERROR_OK;
2183 for (i = 0; i < image.num_sections; i++)
2184 {
2185 buffer = malloc(image.sections[i].size);
2186 if (buffer == NULL)
2187 {
2188 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2189 break;
2190 }
2191 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2192 {
2193 free(buffer);
2194 break;
2195 }
2196
2197 /* calculate checksum of image */
2198 image_calculate_checksum( buffer, buf_cnt, &checksum );
2199
2200 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2201 if( retval != ERROR_OK )
2202 {
2203 free(buffer);
2204 break;
2205 }
2206
2207 if( checksum != mem_checksum )
2208 {
2209 /* failed crc checksum, fall back to a binary compare */
2210 u8 *data;
2211
2212 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2213
2214 data = (u8*)malloc(buf_cnt);
2215
2216 /* Can we use 32bit word accesses? */
2217 int size = 1;
2218 int count = buf_cnt;
2219 if ((count % 4) == 0)
2220 {
2221 size *= 4;
2222 count /= 4;
2223 }
2224 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2225 if (retval == ERROR_OK)
2226 {
2227 int t;
2228 for (t = 0; t < buf_cnt; t++)
2229 {
2230 if (data[t] != buffer[t])
2231 {
2232 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]);
2233 free(data);
2234 free(buffer);
2235 retval=ERROR_FAIL;
2236 goto done;
2237 }
2238 }
2239 }
2240
2241 free(data);
2242 }
2243
2244 free(buffer);
2245 image_size += buf_cnt;
2246 }
2247 done:
2248 duration_stop_measure(&duration, &duration_text);
2249 if (retval==ERROR_OK)
2250 {
2251 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2252 }
2253 free(duration_text);
2254
2255 image_close(&image);
2256
2257 return retval;
2258 }
2259
2260 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2261 {
2262 int retval;
2263 target_t *target = get_current_target(cmd_ctx);
2264
2265 if (argc == 0)
2266 {
2267 breakpoint_t *breakpoint = target->breakpoints;
2268
2269 while (breakpoint)
2270 {
2271 if (breakpoint->type == BKPT_SOFT)
2272 {
2273 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2274 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2275 free(buf);
2276 }
2277 else
2278 {
2279 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2280 }
2281 breakpoint = breakpoint->next;
2282 }
2283 }
2284 else if (argc >= 2)
2285 {
2286 int hw = BKPT_SOFT;
2287 u32 length = 0;
2288
2289 length = strtoul(args[1], NULL, 0);
2290
2291 if (argc >= 3)
2292 if (strcmp(args[2], "hw") == 0)
2293 hw = BKPT_HARD;
2294
2295 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2296 {
2297 LOG_ERROR("Failure setting breakpoints");
2298 }
2299 else
2300 {
2301 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2302 }
2303 }
2304 else
2305 {
2306 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2307 }
2308
2309 return ERROR_OK;
2310 }
2311
2312 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2313 {
2314 target_t *target = get_current_target(cmd_ctx);
2315
2316 if (argc > 0)
2317 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2318
2319 return ERROR_OK;
2320 }
2321
2322 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2323 {
2324 target_t *target = get_current_target(cmd_ctx);
2325 int retval;
2326
2327 if (argc == 0)
2328 {
2329 watchpoint_t *watchpoint = target->watchpoints;
2330
2331 while (watchpoint)
2332 {
2333 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);
2334 watchpoint = watchpoint->next;
2335 }
2336 }
2337 else if (argc >= 2)
2338 {
2339 enum watchpoint_rw type = WPT_ACCESS;
2340 u32 data_value = 0x0;
2341 u32 data_mask = 0xffffffff;
2342
2343 if (argc >= 3)
2344 {
2345 switch(args[2][0])
2346 {
2347 case 'r':
2348 type = WPT_READ;
2349 break;
2350 case 'w':
2351 type = WPT_WRITE;
2352 break;
2353 case 'a':
2354 type = WPT_ACCESS;
2355 break;
2356 default:
2357 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2358 return ERROR_OK;
2359 }
2360 }
2361 if (argc >= 4)
2362 {
2363 data_value = strtoul(args[3], NULL, 0);
2364 }
2365 if (argc >= 5)
2366 {
2367 data_mask = strtoul(args[4], NULL, 0);
2368 }
2369
2370 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2371 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2372 {
2373 LOG_ERROR("Failure setting breakpoints");
2374 }
2375 }
2376 else
2377 {
2378 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2379 }
2380
2381 return ERROR_OK;
2382 }
2383
2384 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2385 {
2386 target_t *target = get_current_target(cmd_ctx);
2387
2388 if (argc > 0)
2389 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2390
2391 return ERROR_OK;
2392 }
2393
2394 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2395 {
2396 int retval;
2397 target_t *target = get_current_target(cmd_ctx);
2398 u32 va;
2399 u32 pa;
2400
2401 if (argc != 1)
2402 {
2403 return ERROR_COMMAND_SYNTAX_ERROR;
2404 }
2405 va = strtoul(args[0], NULL, 0);
2406
2407 retval = target->type->virt2phys(target, va, &pa);
2408 if (retval == ERROR_OK)
2409 {
2410 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2411 }
2412 else
2413 {
2414 /* lower levels will have logged a detailed error which is
2415 * forwarded to telnet/GDB session.
2416 */
2417 }
2418 return retval;
2419 }
2420 static void writeLong(FILE *f, int l)
2421 {
2422 int i;
2423 for (i=0; i<4; i++)
2424 {
2425 char c=(l>>(i*8))&0xff;
2426 fwrite(&c, 1, 1, f);
2427 }
2428
2429 }
2430 static void writeString(FILE *f, char *s)
2431 {
2432 fwrite(s, 1, strlen(s), f);
2433 }
2434
2435
2436
2437 // Dump a gmon.out histogram file.
2438 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2439 {
2440 int i;
2441 FILE *f=fopen(filename, "w");
2442 if (f==NULL)
2443 return;
2444 fwrite("gmon", 1, 4, f);
2445 writeLong(f, 0x00000001); // Version
2446 writeLong(f, 0); // padding
2447 writeLong(f, 0); // padding
2448 writeLong(f, 0); // padding
2449
2450 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2451
2452 // figure out bucket size
2453 u32 min=samples[0];
2454 u32 max=samples[0];
2455 for (i=0; i<sampleNum; i++)
2456 {
2457 if (min>samples[i])
2458 {
2459 min=samples[i];
2460 }
2461 if (max<samples[i])
2462 {
2463 max=samples[i];
2464 }
2465 }
2466
2467 int addressSpace=(max-min+1);
2468
2469 static int const maxBuckets=256*1024; // maximum buckets.
2470 int length=addressSpace;
2471 if (length > maxBuckets)
2472 {
2473 length=maxBuckets;
2474 }
2475 int *buckets=malloc(sizeof(int)*length);
2476 if (buckets==NULL)
2477 {
2478 fclose(f);
2479 return;
2480 }
2481 memset(buckets, 0, sizeof(int)*length);
2482 for (i=0; i<sampleNum;i++)
2483 {
2484 u32 address=samples[i];
2485 long long a=address-min;
2486 long long b=length-1;
2487 long long c=addressSpace-1;
2488 int index=(a*b)/c; // danger!!!! int32 overflows
2489 buckets[index]++;
2490 }
2491
2492 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2493 writeLong(f, min); // low_pc
2494 writeLong(f, max); // high_pc
2495 writeLong(f, length); // # of samples
2496 writeLong(f, 64000000); // 64MHz
2497 writeString(f, "seconds");
2498 for (i=0; i<(15-strlen("seconds")); i++)
2499 {
2500 fwrite("", 1, 1, f); // padding
2501 }
2502 writeString(f, "s");
2503
2504 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2505
2506 char *data=malloc(2*length);
2507 if (data!=NULL)
2508 {
2509 for (i=0; i<length;i++)
2510 {
2511 int val;
2512 val=buckets[i];
2513 if (val>65535)
2514 {
2515 val=65535;
2516 }
2517 data[i*2]=val&0xff;
2518 data[i*2+1]=(val>>8)&0xff;
2519 }
2520 free(buckets);
2521 fwrite(data, 1, length*2, f);
2522 free(data);
2523 } else
2524 {
2525 free(buckets);
2526 }
2527
2528 fclose(f);
2529 }
2530
2531 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2532 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2533 {
2534 target_t *target = get_current_target(cmd_ctx);
2535 struct timeval timeout, now;
2536
2537 gettimeofday(&timeout, NULL);
2538 if (argc!=2)
2539 {
2540 return ERROR_COMMAND_SYNTAX_ERROR;
2541 }
2542 char *end;
2543 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2544 if (*end)
2545 {
2546 return ERROR_OK;
2547 }
2548
2549 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2550
2551 static const int maxSample=10000;
2552 u32 *samples=malloc(sizeof(u32)*maxSample);
2553 if (samples==NULL)
2554 return ERROR_OK;
2555
2556 int numSamples=0;
2557 int retval=ERROR_OK;
2558 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2559 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2560
2561 for (;;)
2562 {
2563 target_poll(target);
2564 if (target->state == TARGET_HALTED)
2565 {
2566 u32 t=*((u32 *)reg->value);
2567 samples[numSamples++]=t;
2568 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2569 target_poll(target);
2570 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2571 } else if (target->state == TARGET_RUNNING)
2572 {
2573 // We want to quickly sample the PC.
2574 target_halt(target);
2575 } else
2576 {
2577 command_print(cmd_ctx, "Target not halted or running");
2578 retval=ERROR_OK;
2579 break;
2580 }
2581 if (retval!=ERROR_OK)
2582 {
2583 break;
2584 }
2585
2586 gettimeofday(&now, NULL);
2587 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2588 {
2589 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2590 target_poll(target);
2591 if (target->state == TARGET_HALTED)
2592 {
2593 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2594 }
2595 target_poll(target);
2596 writeGmon(samples, numSamples, args[1]);
2597 command_print(cmd_ctx, "Wrote %s", args[1]);
2598 break;
2599 }
2600 }
2601 free(samples);
2602
2603 return ERROR_OK;
2604 }
2605
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)