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