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