Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
make target_wait_state() usable from other places, made LOG_USER() output LOG_DEBUG...
[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(void)
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(void)
670 {
671 return target_call_timer_callbacks_check_time(1);
672 }
673
674 /* invoke periodic callbacks immediately */
675 int target_call_timer_callbacks_now(void)
676 {
677 return target_call_timer_callbacks();
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] - default is run");
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_DEBUG("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 return target_process_reset(cmd_ctx, reset_mode);
1705 }
1706
1707 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1708 {
1709 int retval;
1710 target_t *target = get_current_target(cmd_ctx);
1711
1712 target_invoke_script(cmd_ctx, target, "pre_resume");
1713
1714 if (argc == 0)
1715 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1716 else if (argc == 1)
1717 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1718 else
1719 {
1720 return ERROR_COMMAND_SYNTAX_ERROR;
1721 }
1722
1723 return retval;
1724 }
1725
1726 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1727 {
1728 target_t *target = get_current_target(cmd_ctx);
1729
1730 LOG_DEBUG("-");
1731
1732 if (argc == 0)
1733 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1734
1735 if (argc == 1)
1736 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1737
1738 return ERROR_OK;
1739 }
1740
1741 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1742 {
1743 const int line_bytecnt = 32;
1744 int count = 1;
1745 int size = 4;
1746 u32 address = 0;
1747 int line_modulo;
1748 int i;
1749
1750 char output[128];
1751 int output_len;
1752
1753 int retval;
1754
1755 u8 *buffer;
1756 target_t *target = get_current_target(cmd_ctx);
1757
1758 if (argc < 1)
1759 return ERROR_OK;
1760
1761 if (argc == 2)
1762 count = strtoul(args[1], NULL, 0);
1763
1764 address = strtoul(args[0], NULL, 0);
1765
1766
1767 switch (cmd[2])
1768 {
1769 case 'w':
1770 size = 4; line_modulo = line_bytecnt / 4;
1771 break;
1772 case 'h':
1773 size = 2; line_modulo = line_bytecnt / 2;
1774 break;
1775 case 'b':
1776 size = 1; line_modulo = line_bytecnt / 1;
1777 break;
1778 default:
1779 return ERROR_OK;
1780 }
1781
1782 buffer = calloc(count, size);
1783 retval = target->type->read_memory(target, address, size, count, buffer);
1784 if (retval == ERROR_OK)
1785 {
1786 output_len = 0;
1787
1788 for (i = 0; i < count; i++)
1789 {
1790 if (i%line_modulo == 0)
1791 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1792
1793 switch (size)
1794 {
1795 case 4:
1796 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1797 break;
1798 case 2:
1799 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1800 break;
1801 case 1:
1802 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1803 break;
1804 }
1805
1806 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1807 {
1808 command_print(cmd_ctx, output);
1809 output_len = 0;
1810 }
1811 }
1812 }
1813
1814 free(buffer);
1815
1816 return retval;
1817 }
1818
1819 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1820 {
1821 u32 address = 0;
1822 u32 value = 0;
1823 int count = 1;
1824 int i;
1825 int wordsize;
1826 target_t *target = get_current_target(cmd_ctx);
1827 u8 value_buf[4];
1828
1829 if ((argc < 2) || (argc > 3))
1830 return ERROR_COMMAND_SYNTAX_ERROR;
1831
1832 address = strtoul(args[0], NULL, 0);
1833 value = strtoul(args[1], NULL, 0);
1834 if (argc == 3)
1835 count = strtoul(args[2], NULL, 0);
1836
1837 switch (cmd[2])
1838 {
1839 case 'w':
1840 wordsize = 4;
1841 target_buffer_set_u32(target, value_buf, value);
1842 break;
1843 case 'h':
1844 wordsize = 2;
1845 target_buffer_set_u16(target, value_buf, value);
1846 break;
1847 case 'b':
1848 wordsize = 1;
1849 value_buf[0] = value;
1850 break;
1851 default:
1852 return ERROR_COMMAND_SYNTAX_ERROR;
1853 }
1854 for (i=0; i<count; i++)
1855 {
1856 int retval;
1857 switch (wordsize)
1858 {
1859 case 4:
1860 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1861 break;
1862 case 2:
1863 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
1864 break;
1865 case 1:
1866 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
1867 break;
1868 default:
1869 return ERROR_OK;
1870 }
1871 if (retval!=ERROR_OK)
1872 {
1873 return retval;
1874 }
1875 }
1876
1877 return ERROR_OK;
1878
1879 }
1880
1881 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1882 {
1883 u8 *buffer;
1884 u32 buf_cnt;
1885 u32 image_size;
1886 u32 min_address=0;
1887 u32 max_address=0xffffffff;
1888 int i;
1889 int retval;
1890
1891 image_t image;
1892
1893 duration_t duration;
1894 char *duration_text;
1895
1896 target_t *target = get_current_target(cmd_ctx);
1897
1898 if ((argc < 1)||(argc > 5))
1899 {
1900 return ERROR_COMMAND_SYNTAX_ERROR;
1901 }
1902
1903 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1904 if (argc >= 2)
1905 {
1906 image.base_address_set = 1;
1907 image.base_address = strtoul(args[1], NULL, 0);
1908 }
1909 else
1910 {
1911 image.base_address_set = 0;
1912 }
1913
1914
1915 image.start_address_set = 0;
1916
1917 if (argc>=4)
1918 {
1919 min_address=strtoul(args[3], NULL, 0);
1920 }
1921 if (argc>=5)
1922 {
1923 max_address=strtoul(args[4], NULL, 0)+min_address;
1924 }
1925
1926 if (min_address>max_address)
1927 {
1928 return ERROR_COMMAND_SYNTAX_ERROR;
1929 }
1930
1931
1932 duration_start_measure(&duration);
1933
1934 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1935 {
1936 return ERROR_OK;
1937 }
1938
1939 image_size = 0x0;
1940 retval = ERROR_OK;
1941 for (i = 0; i < image.num_sections; i++)
1942 {
1943 buffer = malloc(image.sections[i].size);
1944 if (buffer == NULL)
1945 {
1946 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1947 break;
1948 }
1949
1950 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1951 {
1952 free(buffer);
1953 break;
1954 }
1955
1956 u32 offset=0;
1957 u32 length=buf_cnt;
1958
1959
1960 /* DANGER!!! beware of unsigned comparision here!!! */
1961
1962 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
1963 (image.sections[i].base_address<max_address))
1964 {
1965 if (image.sections[i].base_address<min_address)
1966 {
1967 /* clip addresses below */
1968 offset+=min_address-image.sections[i].base_address;
1969 length-=offset;
1970 }
1971
1972 if (image.sections[i].base_address+buf_cnt>max_address)
1973 {
1974 length-=(image.sections[i].base_address+buf_cnt)-max_address;
1975 }
1976
1977 if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
1978 {
1979 free(buffer);
1980 break;
1981 }
1982 image_size += length;
1983 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
1984 }
1985
1986 free(buffer);
1987 }
1988
1989 duration_stop_measure(&duration, &duration_text);
1990 if (retval==ERROR_OK)
1991 {
1992 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1993 }
1994 free(duration_text);
1995
1996 image_close(&image);
1997
1998 return retval;
1999
2000 }
2001
2002 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2003 {
2004 fileio_t fileio;
2005
2006 u32 address;
2007 u32 size;
2008 u8 buffer[560];
2009 int retval=ERROR_OK;
2010
2011 duration_t duration;
2012 char *duration_text;
2013
2014 target_t *target = get_current_target(cmd_ctx);
2015
2016 if (argc != 3)
2017 {
2018 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2019 return ERROR_OK;
2020 }
2021
2022 address = strtoul(args[1], NULL, 0);
2023 size = strtoul(args[2], NULL, 0);
2024
2025 if ((address & 3) || (size & 3))
2026 {
2027 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2028 return ERROR_OK;
2029 }
2030
2031 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2032 {
2033 return ERROR_OK;
2034 }
2035
2036 duration_start_measure(&duration);
2037
2038 while (size > 0)
2039 {
2040 u32 size_written;
2041 u32 this_run_size = (size > 560) ? 560 : size;
2042
2043 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2044 if (retval != ERROR_OK)
2045 {
2046 break;
2047 }
2048
2049 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2050 if (retval != ERROR_OK)
2051 {
2052 break;
2053 }
2054
2055 size -= this_run_size;
2056 address += this_run_size;
2057 }
2058
2059 fileio_close(&fileio);
2060
2061 duration_stop_measure(&duration, &duration_text);
2062 if (retval==ERROR_OK)
2063 {
2064 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2065 }
2066 free(duration_text);
2067
2068 return ERROR_OK;
2069 }
2070
2071 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2072 {
2073 u8 *buffer;
2074 u32 buf_cnt;
2075 u32 image_size;
2076 int i;
2077 int retval;
2078 u32 checksum = 0;
2079 u32 mem_checksum = 0;
2080
2081 image_t image;
2082
2083 duration_t duration;
2084 char *duration_text;
2085
2086 target_t *target = get_current_target(cmd_ctx);
2087
2088 if (argc < 1)
2089 {
2090 return ERROR_COMMAND_SYNTAX_ERROR;
2091 }
2092
2093 if (!target)
2094 {
2095 LOG_ERROR("no target selected");
2096 return ERROR_FAIL;
2097 }
2098
2099 duration_start_measure(&duration);
2100
2101 if (argc >= 2)
2102 {
2103 image.base_address_set = 1;
2104 image.base_address = strtoul(args[1], NULL, 0);
2105 }
2106 else
2107 {
2108 image.base_address_set = 0;
2109 image.base_address = 0x0;
2110 }
2111
2112 image.start_address_set = 0;
2113
2114 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2115 {
2116 return retval;
2117 }
2118
2119 image_size = 0x0;
2120 retval=ERROR_OK;
2121 for (i = 0; i < image.num_sections; i++)
2122 {
2123 buffer = malloc(image.sections[i].size);
2124 if (buffer == NULL)
2125 {
2126 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2127 break;
2128 }
2129 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2130 {
2131 free(buffer);
2132 break;
2133 }
2134
2135 /* calculate checksum of image */
2136 image_calculate_checksum( buffer, buf_cnt, &checksum );
2137
2138 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2139 if( retval != ERROR_OK )
2140 {
2141 free(buffer);
2142 break;
2143 }
2144
2145 if( checksum != mem_checksum )
2146 {
2147 /* failed crc checksum, fall back to a binary compare */
2148 u8 *data;
2149
2150 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2151
2152 data = (u8*)malloc(buf_cnt);
2153
2154 /* Can we use 32bit word accesses? */
2155 int size = 1;
2156 int count = buf_cnt;
2157 if ((count % 4) == 0)
2158 {
2159 size *= 4;
2160 count /= 4;
2161 }
2162 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2163 if (retval == ERROR_OK)
2164 {
2165 int t;
2166 for (t = 0; t < buf_cnt; t++)
2167 {
2168 if (data[t] != buffer[t])
2169 {
2170 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]);
2171 free(data);
2172 free(buffer);
2173 retval=ERROR_FAIL;
2174 goto done;
2175 }
2176 }
2177 }
2178
2179 free(data);
2180 }
2181
2182 free(buffer);
2183 image_size += buf_cnt;
2184 }
2185 done:
2186 duration_stop_measure(&duration, &duration_text);
2187 if (retval==ERROR_OK)
2188 {
2189 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2190 }
2191 free(duration_text);
2192
2193 image_close(&image);
2194
2195 return retval;
2196 }
2197
2198 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2199 {
2200 int retval;
2201 target_t *target = get_current_target(cmd_ctx);
2202
2203 if (argc == 0)
2204 {
2205 breakpoint_t *breakpoint = target->breakpoints;
2206
2207 while (breakpoint)
2208 {
2209 if (breakpoint->type == BKPT_SOFT)
2210 {
2211 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2212 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2213 free(buf);
2214 }
2215 else
2216 {
2217 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2218 }
2219 breakpoint = breakpoint->next;
2220 }
2221 }
2222 else if (argc >= 2)
2223 {
2224 int hw = BKPT_SOFT;
2225 u32 length = 0;
2226
2227 length = strtoul(args[1], NULL, 0);
2228
2229 if (argc >= 3)
2230 if (strcmp(args[2], "hw") == 0)
2231 hw = BKPT_HARD;
2232
2233 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2234 {
2235 LOG_ERROR("Failure setting breakpoints");
2236 }
2237 else
2238 {
2239 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2240 }
2241 }
2242 else
2243 {
2244 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2245 }
2246
2247 return ERROR_OK;
2248 }
2249
2250 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2251 {
2252 target_t *target = get_current_target(cmd_ctx);
2253
2254 if (argc > 0)
2255 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2256
2257 return ERROR_OK;
2258 }
2259
2260 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2261 {
2262 target_t *target = get_current_target(cmd_ctx);
2263 int retval;
2264
2265 if (argc == 0)
2266 {
2267 watchpoint_t *watchpoint = target->watchpoints;
2268
2269 while (watchpoint)
2270 {
2271 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);
2272 watchpoint = watchpoint->next;
2273 }
2274 }
2275 else if (argc >= 2)
2276 {
2277 enum watchpoint_rw type = WPT_ACCESS;
2278 u32 data_value = 0x0;
2279 u32 data_mask = 0xffffffff;
2280
2281 if (argc >= 3)
2282 {
2283 switch(args[2][0])
2284 {
2285 case 'r':
2286 type = WPT_READ;
2287 break;
2288 case 'w':
2289 type = WPT_WRITE;
2290 break;
2291 case 'a':
2292 type = WPT_ACCESS;
2293 break;
2294 default:
2295 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2296 return ERROR_OK;
2297 }
2298 }
2299 if (argc >= 4)
2300 {
2301 data_value = strtoul(args[3], NULL, 0);
2302 }
2303 if (argc >= 5)
2304 {
2305 data_mask = strtoul(args[4], NULL, 0);
2306 }
2307
2308 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2309 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2310 {
2311 LOG_ERROR("Failure setting breakpoints");
2312 }
2313 }
2314 else
2315 {
2316 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2317 }
2318
2319 return ERROR_OK;
2320 }
2321
2322 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2323 {
2324 target_t *target = get_current_target(cmd_ctx);
2325
2326 if (argc > 0)
2327 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2328
2329 return ERROR_OK;
2330 }
2331
2332 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2333 {
2334 int retval;
2335 target_t *target = get_current_target(cmd_ctx);
2336 u32 va;
2337 u32 pa;
2338
2339 if (argc != 1)
2340 {
2341 return ERROR_COMMAND_SYNTAX_ERROR;
2342 }
2343 va = strtoul(args[0], NULL, 0);
2344
2345 retval = target->type->virt2phys(target, va, &pa);
2346 if (retval == ERROR_OK)
2347 {
2348 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2349 }
2350 else
2351 {
2352 /* lower levels will have logged a detailed error which is
2353 * forwarded to telnet/GDB session.
2354 */
2355 }
2356 return retval;
2357 }
2358 static void writeLong(FILE *f, int l)
2359 {
2360 int i;
2361 for (i=0; i<4; i++)
2362 {
2363 char c=(l>>(i*8))&0xff;
2364 fwrite(&c, 1, 1, f);
2365 }
2366
2367 }
2368 static void writeString(FILE *f, char *s)
2369 {
2370 fwrite(s, 1, strlen(s), f);
2371 }
2372
2373
2374
2375 // Dump a gmon.out histogram file.
2376 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2377 {
2378 int i;
2379 FILE *f=fopen(filename, "w");
2380 if (f==NULL)
2381 return;
2382 fwrite("gmon", 1, 4, f);
2383 writeLong(f, 0x00000001); // Version
2384 writeLong(f, 0); // padding
2385 writeLong(f, 0); // padding
2386 writeLong(f, 0); // padding
2387
2388 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2389
2390 // figure out bucket size
2391 u32 min=samples[0];
2392 u32 max=samples[0];
2393 for (i=0; i<sampleNum; i++)
2394 {
2395 if (min>samples[i])
2396 {
2397 min=samples[i];
2398 }
2399 if (max<samples[i])
2400 {
2401 max=samples[i];
2402 }
2403 }
2404
2405 int addressSpace=(max-min+1);
2406
2407 static int const maxBuckets=256*1024; // maximum buckets.
2408 int length=addressSpace;
2409 if (length > maxBuckets)
2410 {
2411 length=maxBuckets;
2412 }
2413 int *buckets=malloc(sizeof(int)*length);
2414 if (buckets==NULL)
2415 {
2416 fclose(f);
2417 return;
2418 }
2419 memset(buckets, 0, sizeof(int)*length);
2420 for (i=0; i<sampleNum;i++)
2421 {
2422 u32 address=samples[i];
2423 long long a=address-min;
2424 long long b=length-1;
2425 long long c=addressSpace-1;
2426 int index=(a*b)/c; // danger!!!! int32 overflows
2427 buckets[index]++;
2428 }
2429
2430 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2431 writeLong(f, min); // low_pc
2432 writeLong(f, max); // high_pc
2433 writeLong(f, length); // # of samples
2434 writeLong(f, 64000000); // 64MHz
2435 writeString(f, "seconds");
2436 for (i=0; i<(15-strlen("seconds")); i++)
2437 {
2438 fwrite("", 1, 1, f); // padding
2439 }
2440 writeString(f, "s");
2441
2442 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2443
2444 char *data=malloc(2*length);
2445 if (data!=NULL)
2446 {
2447 for (i=0; i<length;i++)
2448 {
2449 int val;
2450 val=buckets[i];
2451 if (val>65535)
2452 {
2453 val=65535;
2454 }
2455 data[i*2]=val&0xff;
2456 data[i*2+1]=(val>>8)&0xff;
2457 }
2458 free(buckets);
2459 fwrite(data, 1, length*2, f);
2460 free(data);
2461 } else
2462 {
2463 free(buckets);
2464 }
2465
2466 fclose(f);
2467 }
2468
2469 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2470 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2471 {
2472 target_t *target = get_current_target(cmd_ctx);
2473 struct timeval timeout, now;
2474
2475 gettimeofday(&timeout, NULL);
2476 if (argc!=2)
2477 {
2478 return ERROR_COMMAND_SYNTAX_ERROR;
2479 }
2480 char *end;
2481 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2482 if (*end)
2483 {
2484 return ERROR_OK;
2485 }
2486
2487 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2488
2489 static const int maxSample=10000;
2490 u32 *samples=malloc(sizeof(u32)*maxSample);
2491 if (samples==NULL)
2492 return ERROR_OK;
2493
2494 int numSamples=0;
2495 int retval=ERROR_OK;
2496 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2497 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2498
2499 for (;;)
2500 {
2501 target_poll(target);
2502 if (target->state == TARGET_HALTED)
2503 {
2504 u32 t=*((u32 *)reg->value);
2505 samples[numSamples++]=t;
2506 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2507 target_poll(target);
2508 alive_sleep(10); // sleep 10ms, i.e. <100 samples/second.
2509 } else if (target->state == TARGET_RUNNING)
2510 {
2511 // We want to quickly sample the PC.
2512 target_halt(target);
2513 } else
2514 {
2515 command_print(cmd_ctx, "Target not halted or running");
2516 retval=ERROR_OK;
2517 break;
2518 }
2519 if (retval!=ERROR_OK)
2520 {
2521 break;
2522 }
2523
2524 gettimeofday(&now, NULL);
2525 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2526 {
2527 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2528 target_poll(target);
2529 if (target->state == TARGET_HALTED)
2530 {
2531 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2532 }
2533 target_poll(target);
2534 writeGmon(samples, numSamples, args[1]);
2535 command_print(cmd_ctx, "Wrote %s", args[1]);
2536 break;
2537 }
2538 }
2539 free(samples);
2540
2541 return ERROR_OK;
2542 }
2543
2544 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2545 {
2546 char *namebuf;
2547 Jim_Obj *nameObjPtr, *valObjPtr;
2548 int result;
2549
2550 namebuf = alloc_printf("%s(%d)", varname, idx);
2551 if (!namebuf)
2552 return JIM_ERR;
2553
2554 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2555 valObjPtr = Jim_NewIntObj(interp, val);
2556 if (!nameObjPtr || !valObjPtr)
2557 {
2558 free(namebuf);
2559 return JIM_ERR;
2560 }
2561
2562 Jim_IncrRefCount(nameObjPtr);
2563 Jim_IncrRefCount(valObjPtr);
2564 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2565 Jim_DecrRefCount(interp, nameObjPtr);
2566 Jim_DecrRefCount(interp, valObjPtr);
2567 free(namebuf);
2568 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2569 return result;
2570 }
2571
2572 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2573 {
2574 target_t *target;
2575 command_context_t *context;
2576 long l;
2577 u32 width;
2578 u32 len;
2579 u32 addr;
2580 u32 count;
2581 u32 v;
2582 const char *varname;
2583 u8 buffer[4096];
2584 int i, n, e, retval;
2585
2586 /* argv[1] = name of array to receive the data
2587 * argv[2] = desired width
2588 * argv[3] = memory address
2589 * argv[4] = count of times to read
2590 */
2591 if (argc != 5) {
2592 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2593 return JIM_ERR;
2594 }
2595 varname = Jim_GetString(argv[1], &len);
2596 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2597
2598 e = Jim_GetLong(interp, argv[2], &l);
2599 width = l;
2600 if (e != JIM_OK) {
2601 return e;
2602 }
2603
2604 e = Jim_GetLong(interp, argv[3], &l);
2605 addr = l;
2606 if (e != JIM_OK) {
2607 return e;
2608 }
2609 e = Jim_GetLong(interp, argv[4], &l);
2610 len = l;
2611 if (e != JIM_OK) {
2612 return e;
2613 }
2614 switch (width) {
2615 case 8:
2616 width = 1;
2617 break;
2618 case 16:
2619 width = 2;
2620 break;
2621 case 32:
2622 width = 4;
2623 break;
2624 default:
2625 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2626 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2627 return JIM_ERR;
2628 }
2629 if (len == 0) {
2630 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2631 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2632 return JIM_ERR;
2633 }
2634 if ((addr + (len * width)) < addr) {
2635 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2636 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2637 return JIM_ERR;
2638 }
2639 /* absurd transfer size? */
2640 if (len > 65536) {
2641 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2642 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2643 return JIM_ERR;
2644 }
2645
2646 if ((width == 1) ||
2647 ((width == 2) && ((addr & 1) == 0)) ||
2648 ((width == 4) && ((addr & 3) == 0))) {
2649 /* all is well */
2650 } else {
2651 char buf[100];
2652 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2653 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2654 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2655 return JIM_ERR;
2656 }
2657
2658 context = Jim_GetAssocData(interp, "context");
2659 if (context == NULL)
2660 {
2661 LOG_ERROR("mem2array: no command context");
2662 return JIM_ERR;
2663 }
2664 target = get_current_target(context);
2665 if (target == NULL)
2666 {
2667 LOG_ERROR("mem2array: no current target");
2668 return JIM_ERR;
2669 }
2670
2671 /* Transfer loop */
2672
2673 /* index counter */
2674 n = 0;
2675 /* assume ok */
2676 e = JIM_OK;
2677 while (len) {
2678 /* Slurp... in buffer size chunks */
2679
2680 count = len; /* in objects.. */
2681 if (count > (sizeof(buffer)/width)) {
2682 count = (sizeof(buffer)/width);
2683 }
2684
2685 retval = target->type->read_memory( target, addr, width, count, buffer );
2686 if (retval != ERROR_OK) {
2687 /* BOO !*/
2688 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2689 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2690 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2691 e = JIM_ERR;
2692 len = 0;
2693 } else {
2694 v = 0; /* shut up gcc */
2695 for (i = 0 ;i < count ;i++, n++) {
2696 switch (width) {
2697 case 4:
2698 v = target_buffer_get_u32(target, &buffer[i*width]);
2699 break;
2700 case 2:
2701 v = target_buffer_get_u16(target, &buffer[i*width]);
2702 break;
2703 case 1:
2704 v = buffer[i] & 0x0ff;
2705 break;
2706 }
2707 new_int_array_element(interp, varname, n, v);
2708 }
2709 len -= count;
2710 }
2711 }
2712
2713 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2714
2715 return JIM_OK;
2716 }
2717
2718 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2719 {
2720 char *namebuf;
2721 Jim_Obj *nameObjPtr, *valObjPtr;
2722 int result;
2723 long l;
2724
2725 namebuf = alloc_printf("%s(%d)", varname, idx);
2726 if (!namebuf)
2727 return JIM_ERR;
2728
2729 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2730 if (!nameObjPtr)
2731 {
2732 free(namebuf);
2733 return JIM_ERR;
2734 }
2735
2736 Jim_IncrRefCount(nameObjPtr);
2737 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2738 Jim_DecrRefCount(interp, nameObjPtr);
2739 free(namebuf);
2740 if (valObjPtr == NULL)
2741 return JIM_ERR;
2742
2743 result = Jim_GetLong(interp, valObjPtr, &l);
2744 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2745 *val = l;
2746 return result;
2747 }
2748
2749 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2750 {
2751 target_t *target;
2752 command_context_t *context;
2753 long l;
2754 u32 width;
2755 u32 len;
2756 u32 addr;
2757 u32 count;
2758 u32 v;
2759 const char *varname;
2760 u8 buffer[4096];
2761 int i, n, e, retval;
2762
2763 /* argv[1] = name of array to get the data
2764 * argv[2] = desired width
2765 * argv[3] = memory address
2766 * argv[4] = count to write
2767 */
2768 if (argc != 5) {
2769 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2770 return JIM_ERR;
2771 }
2772 varname = Jim_GetString(argv[1], &len);
2773 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2774
2775 e = Jim_GetLong(interp, argv[2], &l);
2776 width = l;
2777 if (e != JIM_OK) {
2778 return e;
2779 }
2780
2781 e = Jim_GetLong(interp, argv[3], &l);
2782 addr = l;
2783 if (e != JIM_OK) {
2784 return e;
2785 }
2786 e = Jim_GetLong(interp, argv[4], &l);
2787 len = l;
2788 if (e != JIM_OK) {
2789 return e;
2790 }
2791 switch (width) {
2792 case 8:
2793 width = 1;
2794 break;
2795 case 16:
2796 width = 2;
2797 break;
2798 case 32:
2799 width = 4;
2800 break;
2801 default:
2802 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2803 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2804 return JIM_ERR;
2805 }
2806 if (len == 0) {
2807 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2808 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2809 return JIM_ERR;
2810 }
2811 if ((addr + (len * width)) < addr) {
2812 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2813 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2814 return JIM_ERR;
2815 }
2816 /* absurd transfer size? */
2817 if (len > 65536) {
2818 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2819 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2820 return JIM_ERR;
2821 }
2822
2823 if ((width == 1) ||
2824 ((width == 2) && ((addr & 1) == 0)) ||
2825 ((width == 4) && ((addr & 3) == 0))) {
2826 /* all is well */
2827 } else {
2828 char buf[100];
2829 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2830 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2831 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2832 return JIM_ERR;
2833 }
2834
2835 context = Jim_GetAssocData(interp, "context");
2836 if (context == NULL)
2837 {
2838 LOG_ERROR("array2mem: no command context");
2839 return JIM_ERR;
2840 }
2841 target = get_current_target(context);
2842 if (target == NULL)
2843 {
2844 LOG_ERROR("array2mem: no current target");
2845 return JIM_ERR;
2846 }
2847
2848 /* Transfer loop */
2849
2850 /* index counter */
2851 n = 0;
2852 /* assume ok */
2853 e = JIM_OK;
2854 while (len) {
2855 /* Slurp... in buffer size chunks */
2856
2857 count = len; /* in objects.. */
2858 if (count > (sizeof(buffer)/width)) {
2859 count = (sizeof(buffer)/width);
2860 }
2861
2862 v = 0; /* shut up gcc */
2863 for (i = 0 ;i < count ;i++, n++) {
2864 get_int_array_element(interp, varname, n, &v);
2865 switch (width) {
2866 case 4:
2867 target_buffer_set_u32(target, &buffer[i*width], v);
2868 break;
2869 case 2:
2870 target_buffer_set_u16(target, &buffer[i*width], v);
2871 break;
2872 case 1:
2873 buffer[i] = v & 0x0ff;
2874 break;
2875 }
2876 }
2877 len -= count;
2878
2879 retval = target->type->write_memory(target, addr, width, count, buffer);
2880 if (retval != ERROR_OK) {
2881 /* BOO !*/
2882 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2883 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2884 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2885 e = JIM_ERR;
2886 len = 0;
2887 }
2888 }
2889
2890 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2891
2892 return JIM_OK;
2893 }
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)