Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- the reset mode parameter is now DEPRECATED. It is implemented
[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, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
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 (*last_target_p)->reset_mode = RESET_INIT; /* default */
1195 if (strcmp(args[2], "reset_halt") == 0)
1196 (*last_target_p)->reset_mode = RESET_HALT;
1197 else if (strcmp(args[2], "reset_run") == 0)
1198 (*last_target_p)->reset_mode = RESET_RUN;
1199 else if (strcmp(args[2], "reset_init") == 0)
1200 (*last_target_p)->reset_mode = RESET_INIT;
1201 else if (strcmp(args[2], "run_and_halt") == 0)
1202 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1203 else if (strcmp(args[2], "run_and_init") == 0)
1204 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1205 else
1206 {
1207 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1208 args--;
1209 argc++;
1210 }
1211 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1212
1213 (*last_target_p)->reset_script = NULL;
1214 (*last_target_p)->post_halt_script = NULL;
1215 (*last_target_p)->pre_resume_script = NULL;
1216 (*last_target_p)->gdb_program_script = NULL;
1217
1218 (*last_target_p)->working_area = 0x0;
1219 (*last_target_p)->working_area_size = 0x0;
1220 (*last_target_p)->working_areas = NULL;
1221 (*last_target_p)->backup_working_area = 0;
1222
1223 (*last_target_p)->state = TARGET_UNKNOWN;
1224 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1225 (*last_target_p)->reg_cache = NULL;
1226 (*last_target_p)->breakpoints = NULL;
1227 (*last_target_p)->watchpoints = NULL;
1228 (*last_target_p)->next = NULL;
1229 (*last_target_p)->arch_info = NULL;
1230
1231 /* initialize trace information */
1232 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1233 (*last_target_p)->trace_info->num_trace_points = 0;
1234 (*last_target_p)->trace_info->trace_points_size = 0;
1235 (*last_target_p)->trace_info->trace_points = NULL;
1236 (*last_target_p)->trace_info->trace_history_size = 0;
1237 (*last_target_p)->trace_info->trace_history = NULL;
1238 (*last_target_p)->trace_info->trace_history_pos = 0;
1239 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1240
1241 (*last_target_p)->dbgmsg = NULL;
1242 (*last_target_p)->dbg_msg_enabled = 0;
1243
1244 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1245
1246 found = 1;
1247 break;
1248 }
1249 }
1250 }
1251
1252 /* no matching target found */
1253 if (!found)
1254 {
1255 LOG_ERROR("target '%s' not found", args[0]);
1256 return ERROR_COMMAND_SYNTAX_ERROR;
1257 }
1258
1259 return ERROR_OK;
1260 }
1261
1262 /* usage: target_script <target#> <event> <script_file> */
1263 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1264 {
1265 target_t *target = NULL;
1266
1267 if (argc < 3)
1268 {
1269 LOG_ERROR("incomplete target_script command");
1270 return ERROR_COMMAND_SYNTAX_ERROR;
1271 }
1272
1273 target = get_target_by_num(strtoul(args[0], NULL, 0));
1274
1275 if (!target)
1276 {
1277 return ERROR_COMMAND_SYNTAX_ERROR;
1278 }
1279
1280 if (strcmp(args[1], "reset") == 0)
1281 {
1282 if (target->reset_script)
1283 free(target->reset_script);
1284 target->reset_script = strdup(args[2]);
1285 }
1286 else if (strcmp(args[1], "post_halt") == 0)
1287 {
1288 if (target->post_halt_script)
1289 free(target->post_halt_script);
1290 target->post_halt_script = strdup(args[2]);
1291 }
1292 else if (strcmp(args[1], "pre_resume") == 0)
1293 {
1294 if (target->pre_resume_script)
1295 free(target->pre_resume_script);
1296 target->pre_resume_script = strdup(args[2]);
1297 }
1298 else if (strcmp(args[1], "gdb_program_config") == 0)
1299 {
1300 if (target->gdb_program_script)
1301 free(target->gdb_program_script);
1302 target->gdb_program_script = strdup(args[2]);
1303 }
1304 else
1305 {
1306 LOG_ERROR("unknown event type: '%s", args[1]);
1307 return ERROR_COMMAND_SYNTAX_ERROR;
1308 }
1309
1310 return ERROR_OK;
1311 }
1312
1313 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1314 {
1315 target_t *target = NULL;
1316
1317 if (argc < 2)
1318 {
1319 return ERROR_COMMAND_SYNTAX_ERROR;
1320 }
1321
1322 target = get_target_by_num(strtoul(args[0], NULL, 0));
1323 if (!target)
1324 {
1325 return ERROR_COMMAND_SYNTAX_ERROR;
1326 }
1327
1328 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1329
1330 return ERROR_OK;
1331 }
1332
1333 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1334 {
1335 target_t *target = NULL;
1336
1337 if ((argc < 4) || (argc > 5))
1338 {
1339 return ERROR_COMMAND_SYNTAX_ERROR;
1340 }
1341
1342 target = get_target_by_num(strtoul(args[0], NULL, 0));
1343 if (!target)
1344 {
1345 return ERROR_COMMAND_SYNTAX_ERROR;
1346 }
1347 target_free_all_working_areas(target);
1348
1349 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1350 if (argc == 5)
1351 {
1352 target->working_area_virt = strtoul(args[4], NULL, 0);
1353 }
1354 target->working_area_size = strtoul(args[2], NULL, 0);
1355
1356 if (strcmp(args[3], "backup") == 0)
1357 {
1358 target->backup_working_area = 1;
1359 }
1360 else if (strcmp(args[3], "nobackup") == 0)
1361 {
1362 target->backup_working_area = 0;
1363 }
1364 else
1365 {
1366 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1367 return ERROR_COMMAND_SYNTAX_ERROR;
1368 }
1369
1370 return ERROR_OK;
1371 }
1372
1373
1374 /* process target state changes */
1375 int handle_target(void *priv)
1376 {
1377 int retval;
1378 target_t *target = targets;
1379
1380 while (target)
1381 {
1382 /* only poll if target isn't already halted */
1383 if (target->state != TARGET_HALTED)
1384 {
1385 if (target_continous_poll)
1386 if ((retval = target->type->poll(target)) != ERROR_OK)
1387 {
1388 LOG_ERROR("couldn't poll target(%d). It's due for a reset.", retval);
1389 }
1390 }
1391
1392 target = target->next;
1393 }
1394
1395 return ERROR_OK;
1396 }
1397
1398 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1399 {
1400 target_t *target;
1401 reg_t *reg = NULL;
1402 int count = 0;
1403 char *value;
1404
1405 LOG_DEBUG("-");
1406
1407 target = get_current_target(cmd_ctx);
1408
1409 /* list all available registers for the current target */
1410 if (argc == 0)
1411 {
1412 reg_cache_t *cache = target->reg_cache;
1413
1414 count = 0;
1415 while(cache)
1416 {
1417 int i;
1418 for (i = 0; i < cache->num_regs; i++)
1419 {
1420 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1421 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);
1422 free(value);
1423 }
1424 cache = cache->next;
1425 }
1426
1427 return ERROR_OK;
1428 }
1429
1430 /* access a single register by its ordinal number */
1431 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1432 {
1433 int num = strtoul(args[0], NULL, 0);
1434 reg_cache_t *cache = target->reg_cache;
1435
1436 count = 0;
1437 while(cache)
1438 {
1439 int i;
1440 for (i = 0; i < cache->num_regs; i++)
1441 {
1442 if (count++ == num)
1443 {
1444 reg = &cache->reg_list[i];
1445 break;
1446 }
1447 }
1448 if (reg)
1449 break;
1450 cache = cache->next;
1451 }
1452
1453 if (!reg)
1454 {
1455 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1456 return ERROR_OK;
1457 }
1458 } else /* access a single register by its name */
1459 {
1460 reg = register_get_by_name(target->reg_cache, args[0], 1);
1461
1462 if (!reg)
1463 {
1464 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1465 return ERROR_OK;
1466 }
1467 }
1468
1469 /* display a register */
1470 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1471 {
1472 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1473 reg->valid = 0;
1474
1475 if (reg->valid == 0)
1476 {
1477 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1478 if (arch_type == NULL)
1479 {
1480 LOG_ERROR("BUG: encountered unregistered arch type");
1481 return ERROR_OK;
1482 }
1483 arch_type->get(reg);
1484 }
1485 value = buf_to_str(reg->value, reg->size, 16);
1486 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1487 free(value);
1488 return ERROR_OK;
1489 }
1490
1491 /* set register value */
1492 if (argc == 2)
1493 {
1494 u8 *buf = malloc(CEIL(reg->size, 8));
1495 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1496
1497 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1498 if (arch_type == NULL)
1499 {
1500 LOG_ERROR("BUG: encountered unregistered arch type");
1501 return ERROR_OK;
1502 }
1503
1504 arch_type->set(reg, buf);
1505
1506 value = buf_to_str(reg->value, reg->size, 16);
1507 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1508 free(value);
1509
1510 free(buf);
1511
1512 return ERROR_OK;
1513 }
1514
1515 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1516
1517 return ERROR_OK;
1518 }
1519
1520 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1521
1522 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1523 {
1524 target_t *target = get_current_target(cmd_ctx);
1525
1526 if (argc == 0)
1527 {
1528 target->type->poll(target);
1529 target_arch_state(target);
1530 }
1531 else
1532 {
1533 if (strcmp(args[0], "on") == 0)
1534 {
1535 target_continous_poll = 1;
1536 }
1537 else if (strcmp(args[0], "off") == 0)
1538 {
1539 target_continous_poll = 0;
1540 }
1541 else
1542 {
1543 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1544 }
1545 }
1546
1547
1548 return ERROR_OK;
1549 }
1550
1551 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1552 {
1553 int ms = 5000;
1554
1555 if (argc > 0)
1556 {
1557 char *end;
1558
1559 ms = strtoul(args[0], &end, 0) * 1000;
1560 if (*end)
1561 {
1562 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1563 return ERROR_OK;
1564 }
1565 }
1566
1567 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1568 }
1569
1570 static void target_process_events(struct command_context_s *cmd_ctx)
1571 {
1572 target_t *target = get_current_target(cmd_ctx);
1573 target->type->poll(target);
1574 target_call_timer_callbacks_now();
1575 }
1576
1577 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1578 {
1579 int retval;
1580 struct timeval timeout, now;
1581 int once=1;
1582 gettimeofday(&timeout, NULL);
1583 timeval_add_time(&timeout, 0, ms * 1000);
1584
1585 target_t *target = get_current_target(cmd_ctx);
1586 for (;;)
1587 {
1588 if ((retval=target->type->poll(target))!=ERROR_OK)
1589 return retval;
1590 target_call_timer_callbacks_now();
1591 if (target->state == state)
1592 {
1593 break;
1594 }
1595 if (once)
1596 {
1597 once=0;
1598 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1599 }
1600
1601 gettimeofday(&now, NULL);
1602 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1603 {
1604 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1605 break;
1606 }
1607 }
1608
1609 return ERROR_OK;
1610 }
1611
1612 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1613 {
1614 int retval;
1615 target_t *target = get_current_target(cmd_ctx);
1616
1617 LOG_DEBUG("-");
1618
1619 if ((retval = target->type->halt(target)) != ERROR_OK)
1620 {
1621 return retval;
1622 }
1623
1624 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1625 }
1626
1627 /* what to do on daemon startup */
1628 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1629 {
1630 if (argc == 1)
1631 {
1632 if (strcmp(args[0], "attach") == 0)
1633 {
1634 startup_mode = DAEMON_ATTACH;
1635 return ERROR_OK;
1636 }
1637 else if (strcmp(args[0], "reset") == 0)
1638 {
1639 startup_mode = DAEMON_RESET;
1640 return ERROR_OK;
1641 }
1642 }
1643
1644 LOG_WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1645 return ERROR_OK;
1646
1647 }
1648
1649 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1650 {
1651 target_t *target = get_current_target(cmd_ctx);
1652
1653 LOG_USER("requesting target halt and executing a soft reset");
1654
1655 target->type->soft_reset_halt(target);
1656
1657 return ERROR_OK;
1658 }
1659
1660 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1661 {
1662 target_t *target = get_current_target(cmd_ctx);
1663 enum target_reset_mode reset_mode = target->reset_mode;
1664 enum target_reset_mode save = target->reset_mode;
1665
1666 LOG_DEBUG("-");
1667
1668 if (argc >= 1)
1669 {
1670 if (strcmp("run", args[0]) == 0)
1671 reset_mode = RESET_RUN;
1672 else if (strcmp("halt", args[0]) == 0)
1673 reset_mode = RESET_HALT;
1674 else if (strcmp("init", args[0]) == 0)
1675 reset_mode = RESET_INIT;
1676 else if (strcmp("run_and_halt", args[0]) == 0)
1677 {
1678 reset_mode = RESET_RUN_AND_HALT;
1679 if (argc >= 2)
1680 {
1681 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1682 }
1683 }
1684 else if (strcmp("run_and_init", args[0]) == 0)
1685 {
1686 reset_mode = RESET_RUN_AND_INIT;
1687 if (argc >= 2)
1688 {
1689 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1690 }
1691 }
1692 else
1693 {
1694 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1695 return ERROR_OK;
1696 }
1697 }
1698
1699 /* temporarily modify mode of current reset target */
1700 target->reset_mode = reset_mode;
1701
1702 /* reset *all* targets */
1703 target_process_reset(cmd_ctx);
1704
1705 /* Restore default reset mode for this target */
1706 target->reset_mode = save;
1707
1708 return ERROR_OK;
1709 }
1710
1711 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1712 {
1713 int retval;
1714 target_t *target = get_current_target(cmd_ctx);
1715
1716 if (argc == 0)
1717 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1718 else if (argc == 1)
1719 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1720 else
1721 {
1722 return ERROR_COMMAND_SYNTAX_ERROR;
1723 }
1724
1725 target_process_events(cmd_ctx);
1726
1727 return retval;
1728 }
1729
1730 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1731 {
1732 target_t *target = get_current_target(cmd_ctx);
1733
1734 LOG_DEBUG("-");
1735
1736 if (argc == 0)
1737 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1738
1739 if (argc == 1)
1740 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1741
1742 return ERROR_OK;
1743 }
1744
1745 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1746 {
1747 const int line_bytecnt = 32;
1748 int count = 1;
1749 int size = 4;
1750 u32 address = 0;
1751 int line_modulo;
1752 int i;
1753
1754 char output[128];
1755 int output_len;
1756
1757 int retval;
1758
1759 u8 *buffer;
1760 target_t *target = get_current_target(cmd_ctx);
1761
1762 if (argc < 1)
1763 return ERROR_OK;
1764
1765 if (argc == 2)
1766 count = strtoul(args[1], NULL, 0);
1767
1768 address = strtoul(args[0], NULL, 0);
1769
1770
1771 switch (cmd[2])
1772 {
1773 case 'w':
1774 size = 4; line_modulo = line_bytecnt / 4;
1775 break;
1776 case 'h':
1777 size = 2; line_modulo = line_bytecnt / 2;
1778 break;
1779 case 'b':
1780 size = 1; line_modulo = line_bytecnt / 1;
1781 break;
1782 default:
1783 return ERROR_OK;
1784 }
1785
1786 buffer = calloc(count, size);
1787 retval = target->type->read_memory(target, address, size, count, buffer);
1788 if (retval == ERROR_OK)
1789 {
1790 output_len = 0;
1791
1792 for (i = 0; i < count; i++)
1793 {
1794 if (i%line_modulo == 0)
1795 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1796
1797 switch (size)
1798 {
1799 case 4:
1800 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1801 break;
1802 case 2:
1803 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1804 break;
1805 case 1:
1806 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1807 break;
1808 }
1809
1810 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1811 {
1812 command_print(cmd_ctx, output);
1813 output_len = 0;
1814 }
1815 }
1816 } else
1817 {
1818 LOG_ERROR("Failure examining memory");
1819 }
1820
1821 free(buffer);
1822
1823 return ERROR_OK;
1824 }
1825
1826 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1827 {
1828 u32 address = 0;
1829 u32 value = 0;
1830 int count = 1;
1831 int i;
1832 int wordsize;
1833 target_t *target = get_current_target(cmd_ctx);
1834 u8 value_buf[4];
1835
1836 if ((argc < 2) || (argc > 3))
1837 return ERROR_COMMAND_SYNTAX_ERROR;
1838
1839 address = strtoul(args[0], NULL, 0);
1840 value = strtoul(args[1], NULL, 0);
1841 if (argc == 3)
1842 count = strtoul(args[2], NULL, 0);
1843
1844
1845 switch (cmd[2])
1846 {
1847 case 'w':
1848 wordsize = 4;
1849 target_buffer_set_u32(target, value_buf, value);
1850 break;
1851 case 'h':
1852 wordsize = 2;
1853 target_buffer_set_u16(target, value_buf, value);
1854 break;
1855 case 'b':
1856 wordsize = 1;
1857 value_buf[0] = value;
1858 break;
1859 default:
1860 return ERROR_COMMAND_SYNTAX_ERROR;
1861 }
1862 for (i=0; i<count; i++)
1863 {
1864 int retval;
1865 switch (wordsize)
1866 {
1867 case 4:
1868 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1869 break;
1870 case 2:
1871 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1872 break;
1873 case 1:
1874 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1875 break;
1876 default:
1877 return ERROR_OK;
1878 }
1879 if (retval!=ERROR_OK)
1880 {
1881 return retval;
1882 }
1883 }
1884
1885 return ERROR_OK;
1886
1887 }
1888
1889 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1890 {
1891 u8 *buffer;
1892 u32 buf_cnt;
1893 u32 image_size;
1894 int i;
1895 int retval;
1896
1897 image_t image;
1898
1899 duration_t duration;
1900 char *duration_text;
1901
1902 target_t *target = get_current_target(cmd_ctx);
1903
1904 if (argc < 1)
1905 {
1906 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1907 return ERROR_OK;
1908 }
1909
1910 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1911 if (argc >= 2)
1912 {
1913 image.base_address_set = 1;
1914 image.base_address = strtoul(args[1], NULL, 0);
1915 }
1916 else
1917 {
1918 image.base_address_set = 0;
1919 }
1920
1921 image.start_address_set = 0;
1922
1923 duration_start_measure(&duration);
1924
1925 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1926 {
1927 return ERROR_OK;
1928 }
1929
1930 image_size = 0x0;
1931 retval = ERROR_OK;
1932 for (i = 0; i < image.num_sections; i++)
1933 {
1934 buffer = malloc(image.sections[i].size);
1935 if (buffer == NULL)
1936 {
1937 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1938 break;
1939 }
1940
1941 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1942 {
1943 free(buffer);
1944 break;
1945 }
1946 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
1947 {
1948 free(buffer);
1949 break;
1950 }
1951 image_size += buf_cnt;
1952 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1953
1954 free(buffer);
1955 }
1956
1957 duration_stop_measure(&duration, &duration_text);
1958 if (retval==ERROR_OK)
1959 {
1960 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1961 }
1962 free(duration_text);
1963
1964 image_close(&image);
1965
1966 return retval;
1967
1968 }
1969
1970 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1971 {
1972 fileio_t fileio;
1973
1974 u32 address;
1975 u32 size;
1976 u8 buffer[560];
1977 int retval=ERROR_OK;
1978
1979 duration_t duration;
1980 char *duration_text;
1981
1982 target_t *target = get_current_target(cmd_ctx);
1983
1984 if (argc != 3)
1985 {
1986 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1987 return ERROR_OK;
1988 }
1989
1990 address = strtoul(args[1], NULL, 0);
1991 size = strtoul(args[2], NULL, 0);
1992
1993 if ((address & 3) || (size & 3))
1994 {
1995 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1996 return ERROR_OK;
1997 }
1998
1999 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2000 {
2001 return ERROR_OK;
2002 }
2003
2004 duration_start_measure(&duration);
2005
2006 while (size > 0)
2007 {
2008 u32 size_written;
2009 u32 this_run_size = (size > 560) ? 560 : size;
2010
2011 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2012 if (retval != ERROR_OK)
2013 {
2014 break;
2015 }
2016
2017 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2018 if (retval != ERROR_OK)
2019 {
2020 break;
2021 }
2022
2023 size -= this_run_size;
2024 address += this_run_size;
2025 }
2026
2027 fileio_close(&fileio);
2028
2029 duration_stop_measure(&duration, &duration_text);
2030 if (retval==ERROR_OK)
2031 {
2032 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2033 }
2034 free(duration_text);
2035
2036 return ERROR_OK;
2037 }
2038
2039 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2040 {
2041 u8 *buffer;
2042 u32 buf_cnt;
2043 u32 image_size;
2044 int i;
2045 int retval;
2046 u32 checksum = 0;
2047 u32 mem_checksum = 0;
2048
2049 image_t image;
2050
2051 duration_t duration;
2052 char *duration_text;
2053
2054 target_t *target = get_current_target(cmd_ctx);
2055
2056 if (argc < 1)
2057 {
2058 return ERROR_COMMAND_SYNTAX_ERROR;
2059 }
2060
2061 if (!target)
2062 {
2063 LOG_ERROR("no target selected");
2064 return ERROR_FAIL;
2065 }
2066
2067 duration_start_measure(&duration);
2068
2069 if (argc >= 2)
2070 {
2071 image.base_address_set = 1;
2072 image.base_address = strtoul(args[1], NULL, 0);
2073 }
2074 else
2075 {
2076 image.base_address_set = 0;
2077 image.base_address = 0x0;
2078 }
2079
2080 image.start_address_set = 0;
2081
2082 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2083 {
2084 return retval;
2085 }
2086
2087 image_size = 0x0;
2088 retval=ERROR_OK;
2089 for (i = 0; i < image.num_sections; i++)
2090 {
2091 buffer = malloc(image.sections[i].size);
2092 if (buffer == NULL)
2093 {
2094 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2095 break;
2096 }
2097 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2098 {
2099 free(buffer);
2100 break;
2101 }
2102
2103 /* calculate checksum of image */
2104 image_calculate_checksum( buffer, buf_cnt, &checksum );
2105
2106 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2107 if( retval != ERROR_OK )
2108 {
2109 free(buffer);
2110 break;
2111 }
2112
2113 if( checksum != mem_checksum )
2114 {
2115 /* failed crc checksum, fall back to a binary compare */
2116 u8 *data;
2117
2118 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2119
2120 data = (u8*)malloc(buf_cnt);
2121
2122 /* Can we use 32bit word accesses? */
2123 int size = 1;
2124 int count = buf_cnt;
2125 if ((count % 4) == 0)
2126 {
2127 size *= 4;
2128 count /= 4;
2129 }
2130 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2131 if (retval == ERROR_OK)
2132 {
2133 int t;
2134 for (t = 0; t < buf_cnt; t++)
2135 {
2136 if (data[t] != buffer[t])
2137 {
2138 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]);
2139 free(data);
2140 free(buffer);
2141 retval=ERROR_FAIL;
2142 goto done;
2143 }
2144 }
2145 }
2146
2147 free(data);
2148 }
2149
2150 free(buffer);
2151 image_size += buf_cnt;
2152 }
2153 done:
2154 duration_stop_measure(&duration, &duration_text);
2155 if (retval==ERROR_OK)
2156 {
2157 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2158 }
2159 free(duration_text);
2160
2161 image_close(&image);
2162
2163 return retval;
2164 }
2165
2166 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2167 {
2168 int retval;
2169 target_t *target = get_current_target(cmd_ctx);
2170
2171 if (argc == 0)
2172 {
2173 breakpoint_t *breakpoint = target->breakpoints;
2174
2175 while (breakpoint)
2176 {
2177 if (breakpoint->type == BKPT_SOFT)
2178 {
2179 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2180 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2181 free(buf);
2182 }
2183 else
2184 {
2185 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2186 }
2187 breakpoint = breakpoint->next;
2188 }
2189 }
2190 else if (argc >= 2)
2191 {
2192 int hw = BKPT_SOFT;
2193 u32 length = 0;
2194
2195 length = strtoul(args[1], NULL, 0);
2196
2197 if (argc >= 3)
2198 if (strcmp(args[2], "hw") == 0)
2199 hw = BKPT_HARD;
2200
2201 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2202 {
2203 LOG_ERROR("Failure setting breakpoints");
2204 }
2205 else
2206 {
2207 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2208 }
2209 }
2210 else
2211 {
2212 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2213 }
2214
2215 return ERROR_OK;
2216 }
2217
2218 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2219 {
2220 target_t *target = get_current_target(cmd_ctx);
2221
2222 if (argc > 0)
2223 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2224
2225 return ERROR_OK;
2226 }
2227
2228 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2229 {
2230 target_t *target = get_current_target(cmd_ctx);
2231 int retval;
2232
2233 if (argc == 0)
2234 {
2235 watchpoint_t *watchpoint = target->watchpoints;
2236
2237 while (watchpoint)
2238 {
2239 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);
2240 watchpoint = watchpoint->next;
2241 }
2242 }
2243 else if (argc >= 2)
2244 {
2245 enum watchpoint_rw type = WPT_ACCESS;
2246 u32 data_value = 0x0;
2247 u32 data_mask = 0xffffffff;
2248
2249 if (argc >= 3)
2250 {
2251 switch(args[2][0])
2252 {
2253 case 'r':
2254 type = WPT_READ;
2255 break;
2256 case 'w':
2257 type = WPT_WRITE;
2258 break;
2259 case 'a':
2260 type = WPT_ACCESS;
2261 break;
2262 default:
2263 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2264 return ERROR_OK;
2265 }
2266 }
2267 if (argc >= 4)
2268 {
2269 data_value = strtoul(args[3], NULL, 0);
2270 }
2271 if (argc >= 5)
2272 {
2273 data_mask = strtoul(args[4], NULL, 0);
2274 }
2275
2276 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2277 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2278 {
2279 LOG_ERROR("Failure setting breakpoints");
2280 }
2281 }
2282 else
2283 {
2284 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2285 }
2286
2287 return ERROR_OK;
2288 }
2289
2290 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2291 {
2292 target_t *target = get_current_target(cmd_ctx);
2293
2294 if (argc > 0)
2295 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2296
2297 return ERROR_OK;
2298 }
2299
2300 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2301 {
2302 int retval;
2303 target_t *target = get_current_target(cmd_ctx);
2304 u32 va;
2305 u32 pa;
2306
2307 if (argc != 1)
2308 {
2309 return ERROR_COMMAND_SYNTAX_ERROR;
2310 }
2311 va = strtoul(args[0], NULL, 0);
2312
2313 retval = target->type->virt2phys(target, va, &pa);
2314 if (retval == ERROR_OK)
2315 {
2316 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2317 }
2318 else
2319 {
2320 /* lower levels will have logged a detailed error which is
2321 * forwarded to telnet/GDB session.
2322 */
2323 }
2324 return retval;
2325 }
2326 static void writeLong(FILE *f, int l)
2327 {
2328 int i;
2329 for (i=0; i<4; i++)
2330 {
2331 char c=(l>>(i*8))&0xff;
2332 fwrite(&c, 1, 1, f);
2333 }
2334
2335 }
2336 static void writeString(FILE *f, char *s)
2337 {
2338 fwrite(s, 1, strlen(s), f);
2339 }
2340
2341
2342
2343 // Dump a gmon.out histogram file.
2344 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2345 {
2346 int i;
2347 FILE *f=fopen(filename, "w");
2348 if (f==NULL)
2349 return;
2350 fwrite("gmon", 1, 4, f);
2351 writeLong(f, 0x00000001); // Version
2352 writeLong(f, 0); // padding
2353 writeLong(f, 0); // padding
2354 writeLong(f, 0); // padding
2355
2356 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2357
2358 // figure out bucket size
2359 u32 min=samples[0];
2360 u32 max=samples[0];
2361 for (i=0; i<sampleNum; i++)
2362 {
2363 if (min>samples[i])
2364 {
2365 min=samples[i];
2366 }
2367 if (max<samples[i])
2368 {
2369 max=samples[i];
2370 }
2371 }
2372
2373 int addressSpace=(max-min+1);
2374
2375 static int const maxBuckets=256*1024; // maximum buckets.
2376 int length=addressSpace;
2377 if (length > maxBuckets)
2378 {
2379 length=maxBuckets;
2380 }
2381 int *buckets=malloc(sizeof(int)*length);
2382 if (buckets==NULL)
2383 {
2384 fclose(f);
2385 return;
2386 }
2387 memset(buckets, 0, sizeof(int)*length);
2388 for (i=0; i<sampleNum;i++)
2389 {
2390 u32 address=samples[i];
2391 long long a=address-min;
2392 long long b=length-1;
2393 long long c=addressSpace-1;
2394 int index=(a*b)/c; // danger!!!! int32 overflows
2395 buckets[index]++;
2396 }
2397
2398 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2399 writeLong(f, min); // low_pc
2400 writeLong(f, max); // high_pc
2401 writeLong(f, length); // # of samples
2402 writeLong(f, 64000000); // 64MHz
2403 writeString(f, "seconds");
2404 for (i=0; i<(15-strlen("seconds")); i++)
2405 {
2406 fwrite("", 1, 1, f); // padding
2407 }
2408 writeString(f, "s");
2409
2410 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2411
2412 char *data=malloc(2*length);
2413 if (data!=NULL)
2414 {
2415 for (i=0; i<length;i++)
2416 {
2417 int val;
2418 val=buckets[i];
2419 if (val>65535)
2420 {
2421 val=65535;
2422 }
2423 data[i*2]=val&0xff;
2424 data[i*2+1]=(val>>8)&0xff;
2425 }
2426 free(buckets);
2427 fwrite(data, 1, length*2, f);
2428 free(data);
2429 } else
2430 {
2431 free(buckets);
2432 }
2433
2434 fclose(f);
2435 }
2436
2437 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2438 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2439 {
2440 target_t *target = get_current_target(cmd_ctx);
2441 struct timeval timeout, now;
2442
2443 gettimeofday(&timeout, NULL);
2444 if (argc!=2)
2445 {
2446 return ERROR_COMMAND_SYNTAX_ERROR;
2447 }
2448 char *end;
2449 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2450 if (*end)
2451 {
2452 return ERROR_OK;
2453 }
2454
2455 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2456
2457 static const int maxSample=10000;
2458 u32 *samples=malloc(sizeof(u32)*maxSample);
2459 if (samples==NULL)
2460 return ERROR_OK;
2461
2462 int numSamples=0;
2463 int retval=ERROR_OK;
2464 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2465 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2466
2467 for (;;)
2468 {
2469 target->type->poll(target);
2470 if (target->state == TARGET_HALTED)
2471 {
2472 u32 t=*((u32 *)reg->value);
2473 samples[numSamples++]=t;
2474 retval = target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2475 target->type->poll(target);
2476 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2477 } else if (target->state == TARGET_RUNNING)
2478 {
2479 // We want to quickly sample the PC.
2480 target->type->halt(target);
2481 } else
2482 {
2483 command_print(cmd_ctx, "Target not halted or running");
2484 retval=ERROR_OK;
2485 break;
2486 }
2487 if (retval!=ERROR_OK)
2488 {
2489 break;
2490 }
2491
2492 gettimeofday(&now, NULL);
2493 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2494 {
2495 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2496 target->type->poll(target);
2497 if (target->state == TARGET_HALTED)
2498 {
2499 target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2500 }
2501 target->type->poll(target);
2502 writeGmon(samples, numSamples, args[1]);
2503 command_print(cmd_ctx, "Wrote %s", args[1]);
2504 break;
2505 }
2506 }
2507 free(samples);
2508
2509 return ERROR_OK;
2510 }
2511
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)