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