Code Review / openocd.git / blob
? search:


0950e436a41fd94c2eb8f84b616e1dbe45fa5dfd
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "replacements.h"
28 #include "target.h"
29 #include "target_request.h"
30
31 #include "log.h"
32 #include "configuration.h"
33 #include "binarybuffer.h"
34 #include "jtag.h"
35
36 #include <string.h>
37 #include <stdlib.h>
38 #include <inttypes.h>
39
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <errno.h>
44
45 #include <sys/time.h>
46 #include <time.h>
47
48 #include <time_support.h>
49
50 #include <fileio.h>
51 #include <image.h>
52
53 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
54
55 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57
58 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59
60 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
77 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
78 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
79 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
80 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
81
82
83 /* targets */
84 extern target_type_t arm7tdmi_target;
85 extern target_type_t arm720t_target;
86 extern target_type_t arm9tdmi_target;
87 extern target_type_t arm920t_target;
88 extern target_type_t arm966e_target;
89 extern target_type_t arm926ejs_target;
90 extern target_type_t feroceon_target;
91 extern target_type_t xscale_target;
92 extern target_type_t cortexm3_target;
93 extern target_type_t arm11_target;
94 extern target_type_t mips_m4k_target;
95
96 target_type_t *target_types[] =
97 {
98 &arm7tdmi_target,
99 &arm9tdmi_target,
100 &arm920t_target,
101 &arm720t_target,
102 &arm966e_target,
103 &arm926ejs_target,
104 &feroceon_target,
105 &xscale_target,
106 &cortexm3_target,
107 &arm11_target,
108 &mips_m4k_target,
109 NULL,
110 };
111
112 target_t *targets = NULL;
113 target_event_callback_t *target_event_callbacks = NULL;
114 target_timer_callback_t *target_timer_callbacks = NULL;
115
116 char *target_state_strings[] =
117 {
118 "unknown",
119 "running",
120 "halted",
121 "reset",
122 "debug_running",
123 };
124
125 char *target_debug_reason_strings[] =
126 {
127 "debug request", "breakpoint", "watchpoint",
128 "watchpoint and breakpoint", "single step",
129 "target not halted", "undefined"
130 };
131
132 char *target_endianess_strings[] =
133 {
134 "big endian",
135 "little endian",
136 };
137
138 static int target_continous_poll = 1;
139
140 /* read a u32 from a buffer in target memory endianness */
141 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
142 {
143 if (target->endianness == TARGET_LITTLE_ENDIAN)
144 return le_to_h_u32(buffer);
145 else
146 return be_to_h_u32(buffer);
147 }
148
149 /* read a u16 from a buffer in target memory endianness */
150 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
151 {
152 if (target->endianness == TARGET_LITTLE_ENDIAN)
153 return le_to_h_u16(buffer);
154 else
155 return be_to_h_u16(buffer);
156 }
157
158 /* write a u32 to a buffer in target memory endianness */
159 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
160 {
161 if (target->endianness == TARGET_LITTLE_ENDIAN)
162 h_u32_to_le(buffer, value);
163 else
164 h_u32_to_be(buffer, value);
165 }
166
167 /* write a u16 to a buffer in target memory endianness */
168 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
169 {
170 if (target->endianness == TARGET_LITTLE_ENDIAN)
171 h_u16_to_le(buffer, value);
172 else
173 h_u16_to_be(buffer, value);
174 }
175
176 /* returns a pointer to the n-th configured target */
177 target_t* get_target_by_num(int num)
178 {
179 target_t *target = targets;
180 int i = 0;
181
182 while (target)
183 {
184 if (num == i)
185 return target;
186 target = target->next;
187 i++;
188 }
189
190 return NULL;
191 }
192
193 int get_num_by_target(target_t *query_target)
194 {
195 target_t *target = targets;
196 int i = 0;
197
198 while (target)
199 {
200 if (target == query_target)
201 return i;
202 target = target->next;
203 i++;
204 }
205
206 return -1;
207 }
208
209 target_t* get_current_target(command_context_t *cmd_ctx)
210 {
211 target_t *target = get_target_by_num(cmd_ctx->current_target);
212
213 if (target == NULL)
214 {
215 LOG_ERROR("BUG: current_target out of bounds");
216 exit(-1);
217 }
218
219 return target;
220 }
221
222
223 int target_poll(struct target_s *target)
224 {
225 /* We can't poll until after examine */
226 if (!target->type->examined)
227 {
228 /* Fail silently lest we pollute the log */
229 return ERROR_FAIL;
230 }
231 return target->type->poll(target);
232 }
233
234 int target_halt(struct target_s *target)
235 {
236 /* We can't poll until after examine */
237 if (!target->type->examined)
238 {
239 LOG_ERROR("Target not examined yet");
240 return ERROR_FAIL;
241 }
242 return target->type->halt(target);
243 }
244
245 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
246 {
247 int retval;
248
249 /* We can't poll until after examine */
250 if (!target->type->examined)
251 {
252 LOG_ERROR("Target not examined yet");
253 return ERROR_FAIL;
254 }
255
256 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
257 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
258 * the application.
259 */
260 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
261 return retval;
262
263 return retval;
264 }
265
266 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
267 {
268 int retval = ERROR_OK;
269 target_t *target;
270
271 target = targets;
272 while (target)
273 {
274 target_invoke_script(cmd_ctx, target, "pre_reset");
275 target = target->next;
276 }
277
278 if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
279 return retval;
280
281 keep_alive(); /* we might be running on a very slow JTAG clk */
282
283 /* First time this is executed after launching OpenOCD, it will read out
284 * the type of CPU, etc. and init Embedded ICE registers in host
285 * memory.
286 *
287 * It will also set up ICE registers in the target.
288 *
289 * However, if we assert TRST later, we need to set up the registers again.
290 *
291 * For the "reset halt/init" case we must only set up the registers here.
292 */
293 if ((retval = target_examine()) != ERROR_OK)
294 return retval;
295
296 keep_alive(); /* we might be running on a very slow JTAG clk */
297
298 target = targets;
299 while (target)
300 {
301 /* we have no idea what state the target is in, so we
302 * have to drop working areas
303 */
304 target_free_all_working_areas_restore(target, 0);
305 target->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT));
306 if ((retval = target->type->assert_reset(target))!=ERROR_OK)
307 return retval;
308 target = target->next;
309 }
310
311 target = targets;
312 while (target)
313 {
314 if ((retval = target->type->deassert_reset(target))!=ERROR_OK)
315 return retval;
316 target = target->next;
317 }
318
319 target = targets;
320 while (target)
321 {
322 /* We can fail to bring the target into the halted state, try after reset has been deasserted */
323 if (target->reset_halt)
324 {
325 /* wait up to 1 second for halt. */
326 target_wait_state(target, TARGET_HALTED, 1000);
327 if (target->state != TARGET_HALTED)
328 {
329 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
330 if ((retval = target->type->halt(target))!=ERROR_OK)
331 return retval;
332 }
333 }
334
335 target = target->next;
336 }
337
338
339 LOG_DEBUG("Waiting for halted stated as appropriate");
340
341 if ((reset_mode == RESET_HALT) || (reset_mode == RESET_INIT))
342 {
343 target = targets;
344 while (target)
345 {
346 /* Wait for reset to complete, maximum 5 seconds. */
347 if (((retval=target_wait_state(target, TARGET_HALTED, 5000)))==ERROR_OK)
348 {
349 if (reset_mode == RESET_INIT)
350 target_invoke_script(cmd_ctx, target, "post_reset");
351 }
352 target = target->next;
353 }
354 }
355
356 /* We want any events to be processed before the prompt */
357 target_call_timer_callbacks_now();
358
359 return retval;
360 }
361
362 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
363 {
364 *physical = virtual;
365 return ERROR_OK;
366 }
367
368 static int default_mmu(struct target_s *target, int *enabled)
369 {
370 *enabled = 0;
371 return ERROR_OK;
372 }
373
374 static int default_examine(struct target_s *target)
375 {
376 target->type->examined = 1;
377 return ERROR_OK;
378 }
379
380
381 /* Targets that correctly implement init+examine, i.e.
382 * no communication with target during init:
383 *
384 * XScale
385 */
386 int target_examine(struct command_context_s *cmd_ctx)
387 {
388 int retval = ERROR_OK;
389 target_t *target = targets;
390 while (target)
391 {
392 if ((retval = target->type->examine(target))!=ERROR_OK)
393 return retval;
394 target = target->next;
395 }
396 return retval;
397 }
398
399 static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
400 {
401 if (!target->type->examined)
402 {
403 LOG_ERROR("Target not examined yet");
404 return ERROR_FAIL;
405 }
406 return target->type->write_memory_imp(target, address, size, count, buffer);
407 }
408
409 static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
410 {
411 if (!target->type->examined)
412 {
413 LOG_ERROR("Target not examined yet");
414 return ERROR_FAIL;
415 }
416 return target->type->read_memory_imp(target, address, size, count, buffer);
417 }
418
419 static int target_soft_reset_halt_imp(struct target_s *target)
420 {
421 if (!target->type->examined)
422 {
423 LOG_ERROR("Target not examined yet");
424 return ERROR_FAIL;
425 }
426 return target->type->soft_reset_halt_imp(target);
427 }
428
429 static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info)
430 {
431 if (!target->type->examined)
432 {
433 LOG_ERROR("Target not examined yet");
434 return ERROR_FAIL;
435 }
436 return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
437 }
438
439 int target_init(struct command_context_s *cmd_ctx)
440 {
441 target_t *target = targets;
442
443 while (target)
444 {
445 target->type->examined = 0;
446 if (target->type->examine == NULL)
447 {
448 target->type->examine = default_examine;
449 }
450
451 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
452 {
453 LOG_ERROR("target '%s' init failed", target->type->name);
454 exit(-1);
455 }
456
457 /* Set up default functions if none are provided by target */
458 if (target->type->virt2phys == NULL)
459 {
460 target->type->virt2phys = default_virt2phys;
461 }
462 target->type->virt2phys = default_virt2phys;
463 /* a non-invasive way(in terms of patches) to add some code that
464 * runs before the type->write/read_memory implementation
465 */
466 target->type->write_memory_imp = target->type->write_memory;
467 target->type->write_memory = target_write_memory_imp;
468 target->type->read_memory_imp = target->type->read_memory;
469 target->type->read_memory = target_read_memory_imp;
470 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
471 target->type->soft_reset_halt = target_soft_reset_halt_imp;
472 target->type->run_algorithm_imp = target->type->run_algorithm;
473 target->type->run_algorithm = target_run_algorithm_imp;
474
475
476 if (target->type->mmu == NULL)
477 {
478 target->type->mmu = default_mmu;
479 }
480 target = target->next;
481 }
482
483 if (targets)
484 {
485 target_register_user_commands(cmd_ctx);
486 target_register_timer_callback(handle_target, 100, 1, NULL);
487 }
488
489 return ERROR_OK;
490 }
491
492 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
493 {
494 target_event_callback_t **callbacks_p = &target_event_callbacks;
495
496 if (callback == NULL)
497 {
498 return ERROR_INVALID_ARGUMENTS;
499 }
500
501 if (*callbacks_p)
502 {
503 while ((*callbacks_p)->next)
504 callbacks_p = &((*callbacks_p)->next);
505 callbacks_p = &((*callbacks_p)->next);
506 }
507
508 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
509 (*callbacks_p)->callback = callback;
510 (*callbacks_p)->priv = priv;
511 (*callbacks_p)->next = NULL;
512
513 return ERROR_OK;
514 }
515
516 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
517 {
518 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
519 struct timeval now;
520
521 if (callback == NULL)
522 {
523 return ERROR_INVALID_ARGUMENTS;
524 }
525
526 if (*callbacks_p)
527 {
528 while ((*callbacks_p)->next)
529 callbacks_p = &((*callbacks_p)->next);
530 callbacks_p = &((*callbacks_p)->next);
531 }
532
533 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
534 (*callbacks_p)->callback = callback;
535 (*callbacks_p)->periodic = periodic;
536 (*callbacks_p)->time_ms = time_ms;
537
538 gettimeofday(&now, NULL);
539 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
540 time_ms -= (time_ms % 1000);
541 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
542 if ((*callbacks_p)->when.tv_usec > 1000000)
543 {
544 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
545 (*callbacks_p)->when.tv_sec += 1;
546 }
547
548 (*callbacks_p)->priv = priv;
549 (*callbacks_p)->next = NULL;
550
551 return ERROR_OK;
552 }
553
554 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
555 {
556 target_event_callback_t **p = &target_event_callbacks;
557 target_event_callback_t *c = target_event_callbacks;
558
559 if (callback == NULL)
560 {
561 return ERROR_INVALID_ARGUMENTS;
562 }
563
564 while (c)
565 {
566 target_event_callback_t *next = c->next;
567 if ((c->callback == callback) && (c->priv == priv))
568 {
569 *p = next;
570 free(c);
571 return ERROR_OK;
572 }
573 else
574 p = &(c->next);
575 c = next;
576 }
577
578 return ERROR_OK;
579 }
580
581 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
582 {
583 target_timer_callback_t **p = &target_timer_callbacks;
584 target_timer_callback_t *c = target_timer_callbacks;
585
586 if (callback == NULL)
587 {
588 return ERROR_INVALID_ARGUMENTS;
589 }
590
591 while (c)
592 {
593 target_timer_callback_t *next = c->next;
594 if ((c->callback == callback) && (c->priv == priv))
595 {
596 *p = next;
597 free(c);
598 return ERROR_OK;
599 }
600 else
601 p = &(c->next);
602 c = next;
603 }
604
605 return ERROR_OK;
606 }
607
608 int target_call_event_callbacks(target_t *target, enum target_event event)
609 {
610 target_event_callback_t *callback = target_event_callbacks;
611 target_event_callback_t *next_callback;
612
613 LOG_DEBUG("target event %i", event);
614
615 while (callback)
616 {
617 next_callback = callback->next;
618 callback->callback(target, event, callback->priv);
619 callback = next_callback;
620 }
621
622 return ERROR_OK;
623 }
624
625 static int target_call_timer_callbacks_check_time(int checktime)
626 {
627 target_timer_callback_t *callback = target_timer_callbacks;
628 target_timer_callback_t *next_callback;
629 struct timeval now;
630
631 keep_alive();
632
633 gettimeofday(&now, NULL);
634
635 while (callback)
636 {
637 next_callback = callback->next;
638
639 if ((!checktime&&callback->periodic)||
640 (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
641 || (now.tv_sec > callback->when.tv_sec)))
642 {
643 if(callback->callback != NULL)
644 {
645 callback->callback(callback->priv);
646 if (callback->periodic)
647 {
648 int time_ms = callback->time_ms;
649 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
650 time_ms -= (time_ms % 1000);
651 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
652 if (callback->when.tv_usec > 1000000)
653 {
654 callback->when.tv_usec = callback->when.tv_usec - 1000000;
655 callback->when.tv_sec += 1;
656 }
657 }
658 else
659 target_unregister_timer_callback(callback->callback, callback->priv);
660 }
661 }
662
663 callback = next_callback;
664 }
665
666 return ERROR_OK;
667 }
668
669 int target_call_timer_callbacks()
670 {
671 return target_call_timer_callbacks_check_time(1);
672 }
673
674 /* invoke periodic callbacks immediately */
675 int target_call_timer_callbacks_now()
676 {
677 return target_call_timer_callbacks(0);
678 }
679
680 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
681 {
682 working_area_t *c = target->working_areas;
683 working_area_t *new_wa = NULL;
684
685 /* Reevaluate working area address based on MMU state*/
686 if (target->working_areas == NULL)
687 {
688 int retval;
689 int enabled;
690 retval = target->type->mmu(target, &enabled);
691 if (retval != ERROR_OK)
692 {
693 return retval;
694 }
695 if (enabled)
696 {
697 target->working_area = target->working_area_virt;
698 }
699 else
700 {
701 target->working_area = target->working_area_phys;
702 }
703 }
704
705 /* only allocate multiples of 4 byte */
706 if (size % 4)
707 {
708 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
709 size = CEIL(size, 4);
710 }
711
712 /* see if there's already a matching working area */
713 while (c)
714 {
715 if ((c->free) && (c->size == size))
716 {
717 new_wa = c;
718 break;
719 }
720 c = c->next;
721 }
722
723 /* if not, allocate a new one */
724 if (!new_wa)
725 {
726 working_area_t **p = &target->working_areas;
727 u32 first_free = target->working_area;
728 u32 free_size = target->working_area_size;
729
730 LOG_DEBUG("allocating new working area");
731
732 c = target->working_areas;
733 while (c)
734 {
735 first_free += c->size;
736 free_size -= c->size;
737 p = &c->next;
738 c = c->next;
739 }
740
741 if (free_size < size)
742 {
743 LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
744 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
745 }
746
747 new_wa = malloc(sizeof(working_area_t));
748 new_wa->next = NULL;
749 new_wa->size = size;
750 new_wa->address = first_free;
751
752 if (target->backup_working_area)
753 {
754 new_wa->backup = malloc(new_wa->size);
755 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
756 }
757 else
758 {
759 new_wa->backup = NULL;
760 }
761
762 /* put new entry in list */
763 *p = new_wa;
764 }
765
766 /* mark as used, and return the new (reused) area */
767 new_wa->free = 0;
768 *area = new_wa;
769
770 /* user pointer */
771 new_wa->user = area;
772
773 return ERROR_OK;
774 }
775
776 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
777 {
778 if (area->free)
779 return ERROR_OK;
780
781 if (restore&&target->backup_working_area)
782 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
783
784 area->free = 1;
785
786 /* mark user pointer invalid */
787 *area->user = NULL;
788 area->user = NULL;
789
790 return ERROR_OK;
791 }
792
793 int target_free_working_area(struct target_s *target, working_area_t *area)
794 {
795 return target_free_working_area_restore(target, area, 1);
796 }
797
798 int target_free_all_working_areas_restore(struct target_s *target, int restore)
799 {
800 working_area_t *c = target->working_areas;
801
802 while (c)
803 {
804 working_area_t *next = c->next;
805 target_free_working_area_restore(target, c, restore);
806
807 if (c->backup)
808 free(c->backup);
809
810 free(c);
811
812 c = next;
813 }
814
815 target->working_areas = NULL;
816
817 return ERROR_OK;
818 }
819
820 int target_free_all_working_areas(struct target_s *target)
821 {
822 return target_free_all_working_areas_restore(target, 1);
823 }
824
825 int target_register_commands(struct command_context_s *cmd_ctx)
826 {
827 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
828 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
829 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
830 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
831 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
832
833
834 /* script procedures */
835 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
836 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
837 return ERROR_OK;
838 }
839
840 int target_arch_state(struct target_s *target)
841 {
842 int retval;
843 if (target==NULL)
844 {
845 LOG_USER("No target has been configured");
846 return ERROR_OK;
847 }
848
849 LOG_USER("target state: %s", target_state_strings[target->state]);
850
851 if (target->state!=TARGET_HALTED)
852 return ERROR_OK;
853
854 retval=target->type->arch_state(target);
855 return retval;
856 }
857
858 /* Single aligned words are guaranteed to use 16 or 32 bit access
859 * mode respectively, otherwise data is handled as quickly as
860 * possible
861 */
862 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
863 {
864 int retval;
865 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
866
867 if (!target->type->examined)
868 {
869 LOG_ERROR("Target not examined yet");
870 return ERROR_FAIL;
871 }
872
873 if (address+size<address)
874 {
875 /* GDB can request this when e.g. PC is 0xfffffffc*/
876 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
877 return ERROR_FAIL;
878 }
879
880 if (((address % 2) == 0) && (size == 2))
881 {
882 return target->type->write_memory(target, address, 2, 1, buffer);
883 }
884
885 /* handle unaligned head bytes */
886 if (address % 4)
887 {
888 int unaligned = 4 - (address % 4);
889
890 if (unaligned > size)
891 unaligned = size;
892
893 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
894 return retval;
895
896 buffer += unaligned;
897 address += unaligned;
898 size -= unaligned;
899 }
900
901 /* handle aligned words */
902 if (size >= 4)
903 {
904 int aligned = size - (size % 4);
905
906 /* use bulk writes above a certain limit. This may have to be changed */
907 if (aligned > 128)
908 {
909 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
910 return retval;
911 }
912 else
913 {
914 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
915 return retval;
916 }
917
918 buffer += aligned;
919 address += aligned;
920 size -= aligned;
921 }
922
923 /* handle tail writes of less than 4 bytes */
924 if (size > 0)
925 {
926 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
927 return retval;
928 }
929
930 return ERROR_OK;
931 }
932
933
934 /* Single aligned words are guaranteed to use 16 or 32 bit access
935 * mode respectively, otherwise data is handled as quickly as
936 * possible
937 */
938 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
939 {
940 int retval;
941 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
942
943 if (!target->type->examined)
944 {
945 LOG_ERROR("Target not examined yet");
946 return ERROR_FAIL;
947 }
948
949 if (address+size<address)
950 {
951 /* GDB can request this when e.g. PC is 0xfffffffc*/
952 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
953 return ERROR_FAIL;
954 }
955
956 if (((address % 2) == 0) && (size == 2))
957 {
958 return target->type->read_memory(target, address, 2, 1, buffer);
959 }
960
961 /* handle unaligned head bytes */
962 if (address % 4)
963 {
964 int unaligned = 4 - (address % 4);
965
966 if (unaligned > size)
967 unaligned = size;
968
969 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
970 return retval;
971
972 buffer += unaligned;
973 address += unaligned;
974 size -= unaligned;
975 }
976
977 /* handle aligned words */
978 if (size >= 4)
979 {
980 int aligned = size - (size % 4);
981
982 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
983 return retval;
984
985 buffer += aligned;
986 address += aligned;
987 size -= aligned;
988 }
989
990 /* handle tail writes of less than 4 bytes */
991 if (size > 0)
992 {
993 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
994 return retval;
995 }
996
997 return ERROR_OK;
998 }
999
1000 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1001 {
1002 u8 *buffer;
1003 int retval;
1004 int i;
1005 u32 checksum = 0;
1006 if (!target->type->examined)
1007 {
1008 LOG_ERROR("Target not examined yet");
1009 return ERROR_FAIL;
1010 }
1011
1012 if ((retval = target->type->checksum_memory(target, address,
1013 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1014 {
1015 buffer = malloc(size);
1016 if (buffer == NULL)
1017 {
1018 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1019 return ERROR_INVALID_ARGUMENTS;
1020 }
1021 retval = target_read_buffer(target, address, size, buffer);
1022 if (retval != ERROR_OK)
1023 {
1024 free(buffer);
1025 return retval;
1026 }
1027
1028 /* convert to target endianess */
1029 for (i = 0; i < (size/sizeof(u32)); i++)
1030 {
1031 u32 target_data;
1032 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1033 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1034 }
1035
1036 retval = image_calculate_checksum( buffer, size, &checksum );
1037 free(buffer);
1038 }
1039
1040 *crc = checksum;
1041
1042 return retval;
1043 }
1044
1045 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
1046 {
1047 int retval;
1048 if (!target->type->examined)
1049 {
1050 LOG_ERROR("Target not examined yet");
1051 return ERROR_FAIL;
1052 }
1053
1054 if (target->type->blank_check_memory == 0)
1055 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1056
1057 retval = target->type->blank_check_memory(target, address, size, blank);
1058
1059 return retval;
1060 }
1061
1062 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1063 {
1064 u8 value_buf[4];
1065 if (!target->type->examined)
1066 {
1067 LOG_ERROR("Target not examined yet");
1068 return ERROR_FAIL;
1069 }
1070
1071 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1072
1073 if (retval == ERROR_OK)
1074 {
1075 *value = target_buffer_get_u32(target, value_buf);
1076 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1077 }
1078 else
1079 {
1080 *value = 0x0;
1081 LOG_DEBUG("address: 0x%8.8x failed", address);
1082 }
1083
1084 return retval;
1085 }
1086
1087 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1088 {
1089 u8 value_buf[2];
1090 if (!target->type->examined)
1091 {
1092 LOG_ERROR("Target not examined yet");
1093 return ERROR_FAIL;
1094 }
1095
1096 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1097
1098 if (retval == ERROR_OK)
1099 {
1100 *value = target_buffer_get_u16(target, value_buf);
1101 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1102 }
1103 else
1104 {
1105 *value = 0x0;
1106 LOG_DEBUG("address: 0x%8.8x failed", address);
1107 }
1108
1109 return retval;
1110 }
1111
1112 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1113 {
1114 int retval = target->type->read_memory(target, address, 1, 1, value);
1115 if (!target->type->examined)
1116 {
1117 LOG_ERROR("Target not examined yet");
1118 return ERROR_FAIL;
1119 }
1120
1121 if (retval == ERROR_OK)
1122 {
1123 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1124 }
1125 else
1126 {
1127 *value = 0x0;
1128 LOG_DEBUG("address: 0x%8.8x failed", address);
1129 }
1130
1131 return retval;
1132 }
1133
1134 int target_write_u32(struct target_s *target, u32 address, u32 value)
1135 {
1136 int retval;
1137 u8 value_buf[4];
1138 if (!target->type->examined)
1139 {
1140 LOG_ERROR("Target not examined yet");
1141 return ERROR_FAIL;
1142 }
1143
1144 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1145
1146 target_buffer_set_u32(target, value_buf, value);
1147 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1148 {
1149 LOG_DEBUG("failed: %i", retval);
1150 }
1151
1152 return retval;
1153 }
1154
1155 int target_write_u16(struct target_s *target, u32 address, u16 value)
1156 {
1157 int retval;
1158 u8 value_buf[2];
1159 if (!target->type->examined)
1160 {
1161 LOG_ERROR("Target not examined yet");
1162 return ERROR_FAIL;
1163 }
1164
1165 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1166
1167 target_buffer_set_u16(target, value_buf, value);
1168 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1169 {
1170 LOG_DEBUG("failed: %i", retval);
1171 }
1172
1173 return retval;
1174 }
1175
1176 int target_write_u8(struct target_s *target, u32 address, u8 value)
1177 {
1178 int retval;
1179 if (!target->type->examined)
1180 {
1181 LOG_ERROR("Target not examined yet");
1182 return ERROR_FAIL;
1183 }
1184
1185 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1186
1187 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1188 {
1189 LOG_DEBUG("failed: %i", retval);
1190 }
1191
1192 return retval;
1193 }
1194
1195 int target_register_user_commands(struct command_context_s *cmd_ctx)
1196 {
1197 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1198 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1199 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1200 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1201 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1202 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1203 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init]");
1204 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1205
1206 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1207 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1208 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1209
1210 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1211 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1212 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1213
1214 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1215 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1216 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1217 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1218
1219 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
1220 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1221 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1222
1223 target_request_register_commands(cmd_ctx);
1224 trace_register_commands(cmd_ctx);
1225
1226 return ERROR_OK;
1227 }
1228
1229 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1230 {
1231 target_t *target = targets;
1232 int count = 0;
1233
1234 if (argc == 1)
1235 {
1236 int num = strtoul(args[0], NULL, 0);
1237
1238 while (target)
1239 {
1240 count++;
1241 target = target->next;
1242 }
1243
1244 if (num < count)
1245 cmd_ctx->current_target = num;
1246 else
1247 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1248
1249 return ERROR_OK;
1250 }
1251
1252 while (target)
1253 {
1254 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1255 target = target->next;
1256 }
1257
1258 return ERROR_OK;
1259 }
1260
1261 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1262 {
1263 int i;
1264 int found = 0;
1265
1266 if (argc < 3)
1267 {
1268 return ERROR_COMMAND_SYNTAX_ERROR;
1269 }
1270
1271 /* search for the specified target */
1272 if (args[0] && (args[0][0] != 0))
1273 {
1274 for (i = 0; target_types[i]; i++)
1275 {
1276 if (strcmp(args[0], target_types[i]->name) == 0)
1277 {
1278 target_t **last_target_p = &targets;
1279
1280 /* register target specific commands */
1281 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1282 {
1283 LOG_ERROR("couldn't register '%s' commands", args[0]);
1284 exit(-1);
1285 }
1286
1287 if (*last_target_p)
1288 {
1289 while ((*last_target_p)->next)
1290 last_target_p = &((*last_target_p)->next);
1291 last_target_p = &((*last_target_p)->next);
1292 }
1293
1294 *last_target_p = malloc(sizeof(target_t));
1295
1296 /* allocate memory for each unique target type */
1297 (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
1298 *((*last_target_p)->type) = *target_types[i];
1299
1300 if (strcmp(args[1], "big") == 0)
1301 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1302 else if (strcmp(args[1], "little") == 0)
1303 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1304 else
1305 {
1306 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1307 return ERROR_COMMAND_SYNTAX_ERROR;
1308 }
1309
1310 if (strcmp(args[2], "reset_halt") == 0)
1311 {
1312 LOG_WARNING("reset_mode argument is obsolete.");
1313 return ERROR_COMMAND_SYNTAX_ERROR;
1314 }
1315 else if (strcmp(args[2], "reset_run") == 0)
1316 {
1317 LOG_WARNING("reset_mode argument is obsolete.");
1318 return ERROR_COMMAND_SYNTAX_ERROR;
1319 }
1320 else if (strcmp(args[2], "reset_init") == 0)
1321 {
1322 LOG_WARNING("reset_mode argument is obsolete.");
1323 return ERROR_COMMAND_SYNTAX_ERROR;
1324 }
1325 else if (strcmp(args[2], "run_and_halt") == 0)
1326 {
1327 LOG_WARNING("reset_mode argument is obsolete.");
1328 return ERROR_COMMAND_SYNTAX_ERROR;
1329 }
1330 else if (strcmp(args[2], "run_and_init") == 0)
1331 {
1332 LOG_WARNING("reset_mode argument is obsolete.");
1333 return ERROR_COMMAND_SYNTAX_ERROR;
1334 }
1335 else
1336 {
1337 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1338 args--;
1339 argc++;
1340 }
1341
1342 (*last_target_p)->working_area = 0x0;
1343 (*last_target_p)->working_area_size = 0x0;
1344 (*last_target_p)->working_areas = NULL;
1345 (*last_target_p)->backup_working_area = 0;
1346
1347 (*last_target_p)->state = TARGET_UNKNOWN;
1348 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1349 (*last_target_p)->reg_cache = NULL;
1350 (*last_target_p)->breakpoints = NULL;
1351 (*last_target_p)->watchpoints = NULL;
1352 (*last_target_p)->next = NULL;
1353 (*last_target_p)->arch_info = NULL;
1354
1355 /* initialize trace information */
1356 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1357 (*last_target_p)->trace_info->num_trace_points = 0;
1358 (*last_target_p)->trace_info->trace_points_size = 0;
1359 (*last_target_p)->trace_info->trace_points = NULL;
1360 (*last_target_p)->trace_info->trace_history_size = 0;
1361 (*last_target_p)->trace_info->trace_history = NULL;
1362 (*last_target_p)->trace_info->trace_history_pos = 0;
1363 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1364
1365 (*last_target_p)->dbgmsg = NULL;
1366 (*last_target_p)->dbg_msg_enabled = 0;
1367
1368 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1369
1370 found = 1;
1371 break;
1372 }
1373 }
1374 }
1375
1376 /* no matching target found */
1377 if (!found)
1378 {
1379 LOG_ERROR("target '%s' not found", args[0]);
1380 return ERROR_COMMAND_SYNTAX_ERROR;
1381 }
1382
1383 return ERROR_OK;
1384 }
1385
1386 int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
1387 {
1388 return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1389 get_num_by_target(target), name,
1390 get_num_by_target(target), name);
1391 }
1392
1393 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1394 {
1395 target_t *target = NULL;
1396
1397 if ((argc < 4) || (argc > 5))
1398 {
1399 return ERROR_COMMAND_SYNTAX_ERROR;
1400 }
1401
1402 target = get_target_by_num(strtoul(args[0], NULL, 0));
1403 if (!target)
1404 {
1405 return ERROR_COMMAND_SYNTAX_ERROR;
1406 }
1407 target_free_all_working_areas(target);
1408
1409 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1410 if (argc == 5)
1411 {
1412 target->working_area_virt = strtoul(args[4], NULL, 0);
1413 }
1414 target->working_area_size = strtoul(args[2], NULL, 0);
1415
1416 if (strcmp(args[3], "backup") == 0)
1417 {
1418 target->backup_working_area = 1;
1419 }
1420 else if (strcmp(args[3], "nobackup") == 0)
1421 {
1422 target->backup_working_area = 0;
1423 }
1424 else
1425 {
1426 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1427 return ERROR_COMMAND_SYNTAX_ERROR;
1428 }
1429
1430 return ERROR_OK;
1431 }
1432
1433
1434 /* process target state changes */
1435 int handle_target(void *priv)
1436 {
1437 target_t *target = targets;
1438
1439 while (target)
1440 {
1441 if (target_continous_poll)
1442 {
1443 /* polling may fail silently until the target has been examined */
1444 target_poll(target);
1445 }
1446
1447 target = target->next;
1448 }
1449
1450 return ERROR_OK;
1451 }
1452
1453 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1454 {
1455 target_t *target;
1456 reg_t *reg = NULL;
1457 int count = 0;
1458 char *value;
1459
1460 LOG_DEBUG("-");
1461
1462 target = get_current_target(cmd_ctx);
1463
1464 /* list all available registers for the current target */
1465 if (argc == 0)
1466 {
1467 reg_cache_t *cache = target->reg_cache;
1468
1469 count = 0;
1470 while(cache)
1471 {
1472 int i;
1473 for (i = 0; i < cache->num_regs; i++)
1474 {
1475 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1476 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);
1477 free(value);
1478 }
1479 cache = cache->next;
1480 }
1481
1482 return ERROR_OK;
1483 }
1484
1485 /* access a single register by its ordinal number */
1486 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1487 {
1488 int num = strtoul(args[0], NULL, 0);
1489 reg_cache_t *cache = target->reg_cache;
1490
1491 count = 0;
1492 while(cache)
1493 {
1494 int i;
1495 for (i = 0; i < cache->num_regs; i++)
1496 {
1497 if (count++ == num)
1498 {
1499 reg = &cache->reg_list[i];
1500 break;
1501 }
1502 }
1503 if (reg)
1504 break;
1505 cache = cache->next;
1506 }
1507
1508 if (!reg)
1509 {
1510 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1511 return ERROR_OK;
1512 }
1513 } else /* access a single register by its name */
1514 {
1515 reg = register_get_by_name(target->reg_cache, args[0], 1);
1516
1517 if (!reg)
1518 {
1519 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1520 return ERROR_OK;
1521 }
1522 }
1523
1524 /* display a register */
1525 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1526 {
1527 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1528 reg->valid = 0;
1529
1530 if (reg->valid == 0)
1531 {
1532 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1533 if (arch_type == NULL)
1534 {
1535 LOG_ERROR("BUG: encountered unregistered arch type");
1536 return ERROR_OK;
1537 }
1538 arch_type->get(reg);
1539 }
1540 value = buf_to_str(reg->value, reg->size, 16);
1541 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1542 free(value);
1543 return ERROR_OK;
1544 }
1545
1546 /* set register value */
1547 if (argc == 2)
1548 {
1549 u8 *buf = malloc(CEIL(reg->size, 8));
1550 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1551
1552 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1553 if (arch_type == NULL)
1554 {
1555 LOG_ERROR("BUG: encountered unregistered arch type");
1556 return ERROR_OK;
1557 }
1558
1559 arch_type->set(reg, buf);
1560
1561 value = buf_to_str(reg->value, reg->size, 16);
1562 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1563 free(value);
1564
1565 free(buf);
1566
1567 return ERROR_OK;
1568 }
1569
1570 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1571
1572 return ERROR_OK;
1573 }
1574
1575
1576 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1577 {
1578 target_t *target = get_current_target(cmd_ctx);
1579
1580 if (argc == 0)
1581 {
1582 target_poll(target);
1583 target_arch_state(target);
1584 }
1585 else
1586 {
1587 if (strcmp(args[0], "on") == 0)
1588 {
1589 target_continous_poll = 1;
1590 }
1591 else if (strcmp(args[0], "off") == 0)
1592 {
1593 target_continous_poll = 0;
1594 }
1595 else
1596 {
1597 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1598 }
1599 }
1600
1601
1602 return ERROR_OK;
1603 }
1604
1605 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1606 {
1607 int ms = 5000;
1608
1609 if (argc > 0)
1610 {
1611 char *end;
1612
1613 ms = strtoul(args[0], &end, 0) * 1000;
1614 if (*end)
1615 {
1616 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1617 return ERROR_OK;
1618 }
1619 }
1620 target_t *target = get_current_target(cmd_ctx);
1621
1622 return target_wait_state(target, TARGET_HALTED, ms);
1623 }
1624
1625 int target_wait_state(target_t *target, enum target_state state, int ms)
1626 {
1627 int retval;
1628 struct timeval timeout, now;
1629 int once=1;
1630 gettimeofday(&timeout, NULL);
1631 timeval_add_time(&timeout, 0, ms * 1000);
1632
1633 for (;;)
1634 {
1635 if ((retval=target_poll(target))!=ERROR_OK)
1636 return retval;
1637 target_call_timer_callbacks_now();
1638 if (target->state == state)
1639 {
1640 break;
1641 }
1642 if (once)
1643 {
1644 once=0;
1645 LOG_USER("waiting for target %s...", target_state_strings[state]);
1646 }
1647
1648 gettimeofday(&now, NULL);
1649 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1650 {
1651 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1652 return ERROR_FAIL;
1653 }
1654 }
1655
1656 return ERROR_OK;
1657 }
1658
1659 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1660 {
1661 int retval;
1662 target_t *target = get_current_target(cmd_ctx);
1663
1664 LOG_DEBUG("-");
1665
1666 if ((retval = target_halt(target)) != ERROR_OK)
1667 {
1668 return retval;
1669 }
1670
1671 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1672 }
1673
1674 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1675 {
1676 target_t *target = get_current_target(cmd_ctx);
1677
1678 LOG_USER("requesting target halt and executing a soft reset");
1679
1680 target->type->soft_reset_halt(target);
1681
1682 return ERROR_OK;
1683 }
1684
1685 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1686 {
1687 enum target_reset_mode reset_mode = RESET_RUN;
1688
1689 if (argc >= 1)
1690 {
1691 if (strcmp("run", args[0]) == 0)
1692 reset_mode = RESET_RUN;
1693 else if (strcmp("halt", args[0]) == 0)
1694 reset_mode = RESET_HALT;
1695 else if (strcmp("init", args[0]) == 0)
1696 reset_mode = RESET_INIT;
1697 else
1698 {
1699 return ERROR_COMMAND_SYNTAX_ERROR;
1700 }
1701 }
1702
1703 /* reset *all* targets */
1704 target_process_reset(cmd_ctx, reset_mode);
1705
1706 return ERROR_OK;
1707 }
1708
1709 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1710 {
1711 int retval;
1712 target_t *target = get_current_target(cmd_ctx);
1713
1714 target_invoke_script(cmd_ctx, target, "pre_resume");
1715
1716 if (argc == 0)
1717 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1718 else if (argc == 1)
1719 retval = target_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 return retval;
1726 }
1727
1728 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1729 {
1730 target_t *target = get_current_target(cmd_ctx);
1731
1732 LOG_DEBUG("-");
1733
1734 if (argc == 0)
1735 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1736
1737 if (argc == 1)
1738 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1739
1740 return ERROR_OK;
1741 }
1742
1743 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1744 {
1745 const int line_bytecnt = 32;
1746 int count = 1;
1747 int size = 4;
1748 u32 address = 0;
1749 int line_modulo;
1750 int i;
1751
1752 char output[128];
1753 int output_len;
1754
1755 int retval;
1756
1757 u8 *buffer;
1758 target_t *target = get_current_target(cmd_ctx);
1759
1760 if (argc < 1)
1761 return ERROR_OK;
1762
1763 if (argc == 2)
1764 count = strtoul(args[1], NULL, 0);
1765
1766 address = strtoul(args[0], NULL, 0);
1767
1768
1769 switch (cmd[2])
1770 {
1771 case 'w':
1772 size = 4; line_modulo = line_bytecnt / 4;
1773 break;
1774 case 'h':
1775 size = 2; line_modulo = line_bytecnt / 2;
1776 break;
1777 case 'b':
1778 size = 1; line_modulo = line_bytecnt / 1;
1779 break;
1780 default:
1781 return ERROR_OK;
1782 }
1783
1784 buffer = calloc(count, size);
1785 retval = target->type->read_memory(target, address, size, count, buffer);
1786 if (retval == ERROR_OK)
1787 {
1788 output_len = 0;
1789
1790 for (i = 0; i < count; i++)
1791 {
1792 if (i%line_modulo == 0)
1793 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1794
1795 switch (size)
1796 {
1797 case 4:
1798 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1799 break;
1800 case 2:
1801 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1802 break;
1803 case 1:
1804 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1805 break;
1806 }
1807
1808 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1809 {
1810 command_print(cmd_ctx, output);
1811 output_len = 0;
1812 }
1813 }
1814 }
1815
1816 free(buffer);
1817
1818 return retval;
1819 }
1820
1821 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1822 {
1823 u32 address = 0;
1824 u32 value = 0;
1825 int count = 1;
1826 int i;
1827 int wordsize;
1828 target_t *target = get_current_target(cmd_ctx);
1829 u8 value_buf[4];
1830
1831 if ((argc < 2) || (argc > 3))
1832 return ERROR_COMMAND_SYNTAX_ERROR;
1833
1834 address = strtoul(args[0], NULL, 0);
1835 value = strtoul(args[1], NULL, 0);
1836 if (argc == 3)
1837 count = strtoul(args[2], NULL, 0);
1838
1839 switch (cmd[2])
1840 {
1841 case 'w':
1842 wordsize = 4;
1843 target_buffer_set_u32(target, value_buf, value);
1844 break;
1845 case 'h':
1846 wordsize = 2;
1847 target_buffer_set_u16(target, value_buf, value);
1848 break;
1849 case 'b':
1850 wordsize = 1;
1851 value_buf[0] = value;
1852 break;
1853 default:
1854 return ERROR_COMMAND_SYNTAX_ERROR;
1855 }
1856 for (i=0; i<count; i++)
1857 {
1858 int retval;
1859 switch (wordsize)
1860 {
1861 case 4:
1862 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1863 break;
1864 case 2:
1865 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1866 break;
1867 case 1:
1868 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1869 break;
1870 default:
1871 return ERROR_OK;
1872 }
1873 if (retval!=ERROR_OK)
1874 {
1875 return retval;
1876 }
1877 }
1878
1879 return ERROR_OK;
1880
1881 }
1882
1883 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1884 {
1885 u8 *buffer;
1886 u32 buf_cnt;
1887 u32 image_size;
1888 u32 min_address=0;
1889 u32 max_address=0xffffffff;
1890 int i;
1891 int retval;
1892
1893 image_t image;
1894
1895 duration_t duration;
1896 char *duration_text;
1897
1898 target_t *target = get_current_target(cmd_ctx);
1899
1900 if ((argc < 1)||(argc > 5))
1901 {
1902 return ERROR_COMMAND_SYNTAX_ERROR;
1903 }
1904
1905 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1906 if (argc >= 2)
1907 {
1908 image.base_address_set = 1;
1909 image.base_address = strtoul(args[1], NULL, 0);
1910 }
1911 else
1912 {
1913 image.base_address_set = 0;
1914 }
1915
1916
1917 image.start_address_set = 0;
1918
1919 if (argc>=4)
1920 {
1921 min_address=strtoul(args[3], NULL, 0);
1922 }
1923 if (argc>=5)
1924 {
1925 max_address=strtoul(args[4], NULL, 0)+min_address;
1926 }
1927
1928 if (min_address>max_address)
1929 {
1930 return ERROR_COMMAND_SYNTAX_ERROR;
1931 }
1932
1933
1934 duration_start_measure(&duration);
1935
1936 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1937 {
1938 return ERROR_OK;
1939 }
1940
1941 image_size = 0x0;
1942 retval = ERROR_OK;
1943 for (i = 0; i < image.num_sections; i++)
1944 {
1945 buffer = malloc(image.sections[i].size);
1946 if (buffer == NULL)
1947 {
1948 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1949 break;
1950 }
1951
1952 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1953 {
1954 free(buffer);
1955 break;
1956 }
1957
1958 u32 offset=0;
1959 u32 length=buf_cnt;
1960
1961
1962 /* DANGER!!! beware of unsigned comparision here!!! */
1963
1964 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
1965 (image.sections[i].base_address<max_address))
1966 {
1967 if (image.sections[i].base_address<min_address)
1968 {
1969 /* clip addresses below */
1970 offset+=min_address-image.sections[i].base_address;
1971 length-=offset;
1972 }
1973
1974 if (image.sections[i].base_address+buf_cnt>max_address)
1975 {
1976 length-=(image.sections[i].base_address+buf_cnt)-max_address;
1977 }
1978
1979 if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
1980 {
1981 free(buffer);
1982 break;
1983 }
1984 image_size += length;
1985 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
1986 }
1987
1988 free(buffer);
1989 }
1990
1991 duration_stop_measure(&duration, &duration_text);
1992 if (retval==ERROR_OK)
1993 {
1994 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1995 }
1996 free(duration_text);
1997
1998 image_close(&image);
1999
2000 return retval;
2001
2002 }
2003
2004 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2005 {
2006 fileio_t fileio;
2007
2008 u32 address;
2009 u32 size;
2010 u8 buffer[560];
2011 int retval=ERROR_OK;
2012
2013 duration_t duration;
2014 char *duration_text;
2015
2016 target_t *target = get_current_target(cmd_ctx);
2017
2018 if (argc != 3)
2019 {
2020 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2021 return ERROR_OK;
2022 }
2023
2024 address = strtoul(args[1], NULL, 0);
2025 size = strtoul(args[2], NULL, 0);
2026
2027 if ((address & 3) || (size & 3))
2028 {
2029 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2030 return ERROR_OK;
2031 }
2032
2033 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2034 {
2035 return ERROR_OK;
2036 }
2037
2038 duration_start_measure(&duration);
2039
2040 while (size > 0)
2041 {
2042 u32 size_written;
2043 u32 this_run_size = (size > 560) ? 560 : size;
2044
2045 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2046 if (retval != ERROR_OK)
2047 {
2048 break;
2049 }
2050
2051 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2052 if (retval != ERROR_OK)
2053 {
2054 break;
2055 }
2056
2057 size -= this_run_size;
2058 address += this_run_size;
2059 }
2060
2061 fileio_close(&fileio);
2062
2063 duration_stop_measure(&duration, &duration_text);
2064 if (retval==ERROR_OK)
2065 {
2066 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2067 }
2068 free(duration_text);
2069
2070 return ERROR_OK;
2071 }
2072
2073 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2074 {
2075 u8 *buffer;
2076 u32 buf_cnt;
2077 u32 image_size;
2078 int i;
2079 int retval;
2080 u32 checksum = 0;
2081 u32 mem_checksum = 0;
2082
2083 image_t image;
2084
2085 duration_t duration;
2086 char *duration_text;
2087
2088 target_t *target = get_current_target(cmd_ctx);
2089
2090 if (argc < 1)
2091 {
2092 return ERROR_COMMAND_SYNTAX_ERROR;
2093 }
2094
2095 if (!target)
2096 {
2097 LOG_ERROR("no target selected");
2098 return ERROR_FAIL;
2099 }
2100
2101 duration_start_measure(&duration);
2102
2103 if (argc >= 2)
2104 {
2105 image.base_address_set = 1;
2106 image.base_address = strtoul(args[1], NULL, 0);
2107 }
2108 else
2109 {
2110 image.base_address_set = 0;
2111 image.base_address = 0x0;
2112 }
2113
2114 image.start_address_set = 0;
2115
2116 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2117 {
2118 return retval;
2119 }
2120
2121 image_size = 0x0;
2122 retval=ERROR_OK;
2123 for (i = 0; i < image.num_sections; i++)
2124 {
2125 buffer = malloc(image.sections[i].size);
2126 if (buffer == NULL)
2127 {
2128 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2129 break;
2130 }
2131 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2132 {
2133 free(buffer);
2134 break;
2135 }
2136
2137 /* calculate checksum of image */
2138 image_calculate_checksum( buffer, buf_cnt, &checksum );
2139
2140 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2141 if( retval != ERROR_OK )
2142 {
2143 free(buffer);
2144 break;
2145 }
2146
2147 if( checksum != mem_checksum )
2148 {
2149 /* failed crc checksum, fall back to a binary compare */
2150 u8 *data;
2151
2152 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2153
2154 data = (u8*)malloc(buf_cnt);
2155
2156 /* Can we use 32bit word accesses? */
2157 int size = 1;
2158 int count = buf_cnt;
2159 if ((count % 4) == 0)
2160 {
2161 size *= 4;
2162 count /= 4;
2163 }
2164 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2165 if (retval == ERROR_OK)
2166 {
2167 int t;
2168 for (t = 0; t < buf_cnt; t++)
2169 {
2170 if (data[t] != buffer[t])
2171 {
2172 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]);
2173 free(data);
2174 free(buffer);
2175 retval=ERROR_FAIL;
2176 goto done;
2177 }
2178 }
2179 }
2180
2181 free(data);
2182 }
2183
2184 free(buffer);
2185 image_size += buf_cnt;
2186 }
2187 done:
2188 duration_stop_measure(&duration, &duration_text);
2189 if (retval==ERROR_OK)
2190 {
2191 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2192 }
2193 free(duration_text);
2194
2195 image_close(&image);
2196
2197 return retval;
2198 }
2199
2200 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2201 {
2202 int retval;
2203 target_t *target = get_current_target(cmd_ctx);
2204
2205 if (argc == 0)
2206 {
2207 breakpoint_t *breakpoint = target->breakpoints;
2208
2209 while (breakpoint)
2210 {
2211 if (breakpoint->type == BKPT_SOFT)
2212 {
2213 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2214 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2215 free(buf);
2216 }
2217 else
2218 {
2219 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2220 }
2221 breakpoint = breakpoint->next;
2222 }
2223 }
2224 else if (argc >= 2)
2225 {
2226 int hw = BKPT_SOFT;
2227 u32 length = 0;
2228
2229 length = strtoul(args[1], NULL, 0);
2230
2231 if (argc >= 3)
2232 if (strcmp(args[2], "hw") == 0)
2233 hw = BKPT_HARD;
2234
2235 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2236 {
2237 LOG_ERROR("Failure setting breakpoints");
2238 }
2239 else
2240 {
2241 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2242 }
2243 }
2244 else
2245 {
2246 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2247 }
2248
2249 return ERROR_OK;
2250 }
2251
2252 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2253 {
2254 target_t *target = get_current_target(cmd_ctx);
2255
2256 if (argc > 0)
2257 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2258
2259 return ERROR_OK;
2260 }
2261
2262 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2263 {
2264 target_t *target = get_current_target(cmd_ctx);
2265 int retval;
2266
2267 if (argc == 0)
2268 {
2269 watchpoint_t *watchpoint = target->watchpoints;
2270
2271 while (watchpoint)
2272 {
2273 command_print(cmd_ctx, "address: 0x%8.8x, len: 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);
2274 watchpoint = watchpoint->next;
2275 }
2276 }
2277 else if (argc >= 2)
2278 {
2279 enum watchpoint_rw type = WPT_ACCESS;
2280 u32 data_value = 0x0;
2281 u32 data_mask = 0xffffffff;
2282
2283 if (argc >= 3)
2284 {
2285 switch(args[2][0])
2286 {
2287 case 'r':
2288 type = WPT_READ;
2289 break;
2290 case 'w':
2291 type = WPT_WRITE;
2292 break;
2293 case 'a':
2294 type = WPT_ACCESS;
2295 break;
2296 default:
2297 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2298 return ERROR_OK;
2299 }
2300 }
2301 if (argc >= 4)
2302 {
2303 data_value = strtoul(args[3], NULL, 0);
2304 }
2305 if (argc >= 5)
2306 {
2307 data_mask = strtoul(args[4], NULL, 0);
2308 }
2309
2310 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2311 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2312 {
2313 LOG_ERROR("Failure setting breakpoints");
2314 }
2315 }
2316 else
2317 {
2318 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2319 }
2320
2321 return ERROR_OK;
2322 }
2323
2324 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2325 {
2326 target_t *target = get_current_target(cmd_ctx);
2327
2328 if (argc > 0)
2329 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2330
2331 return ERROR_OK;
2332 }
2333
2334 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2335 {
2336 int retval;
2337 target_t *target = get_current_target(cmd_ctx);
2338 u32 va;
2339 u32 pa;
2340
2341 if (argc != 1)
2342 {
2343 return ERROR_COMMAND_SYNTAX_ERROR;
2344 }
2345 va = strtoul(args[0], NULL, 0);
2346
2347 retval = target->type->virt2phys(target, va, &pa);
2348 if (retval == ERROR_OK)
2349 {
2350 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2351 }
2352 else
2353 {
2354 /* lower levels will have logged a detailed error which is
2355 * forwarded to telnet/GDB session.
2356 */
2357 }
2358 return retval;
2359 }
2360 static void writeLong(FILE *f, int l)
2361 {
2362 int i;
2363 for (i=0; i<4; i++)
2364 {
2365 char c=(l>>(i*8))&0xff;
2366 fwrite(&c, 1, 1, f);
2367 }
2368
2369 }
2370 static void writeString(FILE *f, char *s)
2371 {
2372 fwrite(s, 1, strlen(s), f);
2373 }
2374
2375
2376
2377 // Dump a gmon.out histogram file.
2378 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2379 {
2380 int i;
2381 FILE *f=fopen(filename, "w");
2382 if (f==NULL)
2383 return;
2384 fwrite("gmon", 1, 4, f);
2385 writeLong(f, 0x00000001); // Version
2386 writeLong(f, 0); // padding
2387 writeLong(f, 0); // padding
2388 writeLong(f, 0); // padding
2389
2390 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2391
2392 // figure out bucket size
2393 u32 min=samples[0];
2394 u32 max=samples[0];
2395 for (i=0; i<sampleNum; i++)
2396 {
2397 if (min>samples[i])
2398 {
2399 min=samples[i];
2400 }
2401 if (max<samples[i])
2402 {
2403 max=samples[i];
2404 }
2405 }
2406
2407 int addressSpace=(max-min+1);
2408
2409 static int const maxBuckets=256*1024; // maximum buckets.
2410 int length=addressSpace;
2411 if (length > maxBuckets)
2412 {
2413 length=maxBuckets;
2414 }
2415 int *buckets=malloc(sizeof(int)*length);
2416 if (buckets==NULL)
2417 {
2418 fclose(f);
2419 return;
2420 }
2421 memset(buckets, 0, sizeof(int)*length);
2422 for (i=0; i<sampleNum;i++)
2423 {
2424 u32 address=samples[i];
2425 long long a=address-min;
2426 long long b=length-1;
2427 long long c=addressSpace-1;
2428 int index=(a*b)/c; // danger!!!! int32 overflows
2429 buckets[index]++;
2430 }
2431
2432 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2433 writeLong(f, min); // low_pc
2434 writeLong(f, max); // high_pc
2435 writeLong(f, length); // # of samples
2436 writeLong(f, 64000000); // 64MHz
2437 writeString(f, "seconds");
2438 for (i=0; i<(15-strlen("seconds")); i++)
2439 {
2440 fwrite("", 1, 1, f); // padding
2441 }
2442 writeString(f, "s");
2443
2444 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2445
2446 char *data=malloc(2*length);
2447 if (data!=NULL)
2448 {
2449 for (i=0; i<length;i++)
2450 {
2451 int val;
2452 val=buckets[i];
2453 if (val>65535)
2454 {
2455 val=65535;
2456 }
2457 data[i*2]=val&0xff;
2458 data[i*2+1]=(val>>8)&0xff;
2459 }
2460 free(buckets);
2461 fwrite(data, 1, length*2, f);
2462 free(data);
2463 } else
2464 {
2465 free(buckets);
2466 }
2467
2468 fclose(f);
2469 }
2470
2471 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2472 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2473 {
2474 target_t *target = get_current_target(cmd_ctx);
2475 struct timeval timeout, now;
2476
2477 gettimeofday(&timeout, NULL);
2478 if (argc!=2)
2479 {
2480 return ERROR_COMMAND_SYNTAX_ERROR;
2481 }
2482 char *end;
2483 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2484 if (*end)
2485 {
2486 return ERROR_OK;
2487 }
2488
2489 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2490
2491 static const int maxSample=10000;
2492 u32 *samples=malloc(sizeof(u32)*maxSample);
2493 if (samples==NULL)
2494 return ERROR_OK;
2495
2496 int numSamples=0;
2497 int retval=ERROR_OK;
2498 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2499 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2500
2501 for (;;)
2502 {
2503 target_poll(target);
2504 if (target->state == TARGET_HALTED)
2505 {
2506 u32 t=*((u32 *)reg->value);
2507 samples[numSamples++]=t;
2508 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2509 target_poll(target);
2510 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2511 } else if (target->state == TARGET_RUNNING)
2512 {
2513 // We want to quickly sample the PC.
2514 target_halt(target);
2515 } else
2516 {
2517 command_print(cmd_ctx, "Target not halted or running");
2518 retval=ERROR_OK;
2519 break;
2520 }
2521 if (retval!=ERROR_OK)
2522 {
2523 break;
2524 }
2525
2526 gettimeofday(&now, NULL);
2527 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2528 {
2529 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2530 target_poll(target);
2531 if (target->state == TARGET_HALTED)
2532 {
2533 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2534 }
2535 target_poll(target);
2536 writeGmon(samples, numSamples, args[1]);
2537 command_print(cmd_ctx, "Wrote %s", args[1]);
2538 break;
2539 }
2540 }
2541 free(samples);
2542
2543 return ERROR_OK;
2544 }
2545
2546 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2547 {
2548 char *namebuf;
2549 Jim_Obj *nameObjPtr, *valObjPtr;
2550 int result;
2551
2552 namebuf = alloc_printf("%s(%d)", varname, idx);
2553 if (!namebuf)
2554 return JIM_ERR;
2555
2556 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2557 valObjPtr = Jim_NewIntObj(interp, val);
2558 if (!nameObjPtr || !valObjPtr)
2559 {
2560 free(namebuf);
2561 return JIM_ERR;
2562 }
2563
2564 Jim_IncrRefCount(nameObjPtr);
2565 Jim_IncrRefCount(valObjPtr);
2566 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2567 Jim_DecrRefCount(interp, nameObjPtr);
2568 Jim_DecrRefCount(interp, valObjPtr);
2569 free(namebuf);
2570 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2571 return result;
2572 }
2573
2574 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2575 {
2576 target_t *target;
2577 command_context_t *context;
2578 long l;
2579 u32 width;
2580 u32 len;
2581 u32 addr;
2582 u32 count;
2583 u32 v;
2584 const char *varname;
2585 u8 buffer[4096];
2586 int i, n, e, retval;
2587
2588 /* argv[1] = name of array to receive the data
2589 * argv[2] = desired width
2590 * argv[3] = memory address
2591 * argv[4] = count of times to read
2592 */
2593 if (argc != 5) {
2594 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2595 return JIM_ERR;
2596 }
2597 varname = Jim_GetString(argv[1], &len);
2598 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2599
2600 e = Jim_GetLong(interp, argv[2], &l);
2601 width = l;
2602 if (e != JIM_OK) {
2603 return e;
2604 }
2605
2606 e = Jim_GetLong(interp, argv[3], &l);
2607 addr = l;
2608 if (e != JIM_OK) {
2609 return e;
2610 }
2611 e = Jim_GetLong(interp, argv[4], &l);
2612 len = l;
2613 if (e != JIM_OK) {
2614 return e;
2615 }
2616 switch (width) {
2617 case 8:
2618 width = 1;
2619 break;
2620 case 16:
2621 width = 2;
2622 break;
2623 case 32:
2624 width = 4;
2625 break;
2626 default:
2627 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2628 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2629 return JIM_ERR;
2630 }
2631 if (len == 0) {
2632 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2633 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2634 return JIM_ERR;
2635 }
2636 if ((addr + (len * width)) < addr) {
2637 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2638 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2639 return JIM_ERR;
2640 }
2641 /* absurd transfer size? */
2642 if (len > 65536) {
2643 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2644 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2645 return JIM_ERR;
2646 }
2647
2648 if ((width == 1) ||
2649 ((width == 2) && ((addr & 1) == 0)) ||
2650 ((width == 4) && ((addr & 3) == 0))) {
2651 /* all is well */
2652 } else {
2653 char buf[100];
2654 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2655 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2656 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2657 return JIM_ERR;
2658 }
2659
2660 context = Jim_GetAssocData(interp, "context");
2661 if (context == NULL)
2662 {
2663 LOG_ERROR("mem2array: no command context");
2664 return JIM_ERR;
2665 }
2666 target = get_current_target(context);
2667 if (target == NULL)
2668 {
2669 LOG_ERROR("mem2array: no current target");
2670 return JIM_ERR;
2671 }
2672
2673 /* Transfer loop */
2674
2675 /* index counter */
2676 n = 0;
2677 /* assume ok */
2678 e = JIM_OK;
2679 while (len) {
2680 /* Slurp... in buffer size chunks */
2681
2682 count = len; /* in objects.. */
2683 if (count > (sizeof(buffer)/width)) {
2684 count = (sizeof(buffer)/width);
2685 }
2686
2687 retval = target->type->read_memory( target, addr, width, count, buffer );
2688 if (retval != ERROR_OK) {
2689 /* BOO !*/
2690 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2691 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2692 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2693 e = JIM_ERR;
2694 len = 0;
2695 } else {
2696 v = 0; /* shut up gcc */
2697 for (i = 0 ;i < count ;i++, n++) {
2698 switch (width) {
2699 case 4:
2700 v = target_buffer_get_u32(target, &buffer[i*width]);
2701 break;
2702 case 2:
2703 v = target_buffer_get_u16(target, &buffer[i*width]);
2704 break;
2705 case 1:
2706 v = buffer[i] & 0x0ff;
2707 break;
2708 }
2709 new_int_array_element(interp, varname, n, v);
2710 }
2711 len -= count;
2712 }
2713 }
2714
2715 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2716
2717 return JIM_OK;
2718 }
2719
2720 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2721 {
2722 char *namebuf;
2723 Jim_Obj *nameObjPtr, *valObjPtr;
2724 int result;
2725 long l;
2726
2727 namebuf = alloc_printf("%s(%d)", varname, idx);
2728 if (!namebuf)
2729 return JIM_ERR;
2730
2731 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2732 if (!nameObjPtr)
2733 {
2734 free(namebuf);
2735 return JIM_ERR;
2736 }
2737
2738 Jim_IncrRefCount(nameObjPtr);
2739 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2740 Jim_DecrRefCount(interp, nameObjPtr);
2741 free(namebuf);
2742 if (valObjPtr == NULL)
2743 return JIM_ERR;
2744
2745 result = Jim_GetLong(interp, valObjPtr, &l);
2746 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2747 *val = l;
2748 return result;
2749 }
2750
2751 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2752 {
2753 target_t *target;
2754 command_context_t *context;
2755 long l;
2756 u32 width;
2757 u32 len;
2758 u32 addr;
2759 u32 count;
2760 u32 v;
2761 const char *varname;
2762 u8 buffer[4096];
2763 int i, n, e, retval;
2764
2765 /* argv[1] = name of array to get the data
2766 * argv[2] = desired width
2767 * argv[3] = memory address
2768 * argv[4] = count to write
2769 */
2770 if (argc != 5) {
2771 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2772 return JIM_ERR;
2773 }
2774 varname = Jim_GetString(argv[1], &len);
2775 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2776
2777 e = Jim_GetLong(interp, argv[2], &l);
2778 width = l;
2779 if (e != JIM_OK) {
2780 return e;
2781 }
2782
2783 e = Jim_GetLong(interp, argv[3], &l);
2784 addr = l;
2785 if (e != JIM_OK) {
2786 return e;
2787 }
2788 e = Jim_GetLong(interp, argv[4], &l);
2789 len = l;
2790 if (e != JIM_OK) {
2791 return e;
2792 }
2793 switch (width) {
2794 case 8:
2795 width = 1;
2796 break;
2797 case 16:
2798 width = 2;
2799 break;
2800 case 32:
2801 width = 4;
2802 break;
2803 default:
2804 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2805 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2806 return JIM_ERR;
2807 }
2808 if (len == 0) {
2809 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2810 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2811 return JIM_ERR;
2812 }
2813 if ((addr + (len * width)) < addr) {
2814 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2815 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2816 return JIM_ERR;
2817 }
2818 /* absurd transfer size? */
2819 if (len > 65536) {
2820 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2821 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2822 return JIM_ERR;
2823 }
2824
2825 if ((width == 1) ||
2826 ((width == 2) && ((addr & 1) == 0)) ||
2827 ((width == 4) && ((addr & 3) == 0))) {
2828 /* all is well */
2829 } else {
2830 char buf[100];
2831 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2832 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2833 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2834 return JIM_ERR;
2835 }
2836
2837 context = Jim_GetAssocData(interp, "context");
2838 if (context == NULL)
2839 {
2840 LOG_ERROR("array2mem: no command context");
2841 return JIM_ERR;
2842 }
2843 target = get_current_target(context);
2844 if (target == NULL)
2845 {
2846 LOG_ERROR("array2mem: no current target");
2847 return JIM_ERR;
2848 }
2849
2850 /* Transfer loop */
2851
2852 /* index counter */
2853 n = 0;
2854 /* assume ok */
2855 e = JIM_OK;
2856 while (len) {
2857 /* Slurp... in buffer size chunks */
2858
2859 count = len; /* in objects.. */
2860 if (count > (sizeof(buffer)/width)) {
2861 count = (sizeof(buffer)/width);
2862 }
2863
2864 v = 0; /* shut up gcc */
2865 for (i = 0 ;i < count ;i++, n++) {
2866 get_int_array_element(interp, varname, n, &v);
2867 switch (width) {
2868 case 4:
2869 target_buffer_set_u32(target, &buffer[i*width], v);
2870 break;
2871 case 2:
2872 target_buffer_set_u16(target, &buffer[i*width], v);
2873 break;
2874 case 1:
2875 buffer[i] = v & 0x0ff;
2876 break;
2877 }
2878 }
2879 len -= count;
2880
2881 retval = target->type->write_memory(target, addr, width, count, buffer);
2882 if (retval != ERROR_OK) {
2883 /* BOO !*/
2884 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2885 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2886 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2887 e = JIM_ERR;
2888 len = 0;
2889 }
2890 }
2891
2892 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2893
2894 return JIM_OK;
2895 }
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)