Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
TARGET: review handle_load_image_command()
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
26 * *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include <helper/time_support.h>
37 #include <jtag/jtag.h>
38 #include <flash/nor/core.h>
39
40 #include "target.h"
41 #include "target_type.h"
42 #include "target_request.h"
43 #include "breakpoints.h"
44 #include "register.h"
45 #include "trace.h"
46 #include "image.h"
47
48
49 static int target_array2mem(Jim_Interp *interp, struct target *target,
50 int argc, Jim_Obj *const *argv);
51 static int target_mem2array(Jim_Interp *interp, struct target *target,
52 int argc, Jim_Obj *const *argv);
53 static int target_register_user_commands(struct command_context *cmd_ctx);
54
55 /* targets */
56 extern struct target_type arm7tdmi_target;
57 extern struct target_type arm720t_target;
58 extern struct target_type arm9tdmi_target;
59 extern struct target_type arm920t_target;
60 extern struct target_type arm966e_target;
61 extern struct target_type arm926ejs_target;
62 extern struct target_type fa526_target;
63 extern struct target_type feroceon_target;
64 extern struct target_type dragonite_target;
65 extern struct target_type xscale_target;
66 extern struct target_type cortexm3_target;
67 extern struct target_type cortexa8_target;
68 extern struct target_type arm11_target;
69 extern struct target_type mips_m4k_target;
70 extern struct target_type avr_target;
71 extern struct target_type dsp563xx_target;
72 extern struct target_type testee_target;
73 extern struct target_type avr32_ap7k_target;
74
75 static struct target_type *target_types[] =
76 {
77 &arm7tdmi_target,
78 &arm9tdmi_target,
79 &arm920t_target,
80 &arm720t_target,
81 &arm966e_target,
82 &arm926ejs_target,
83 &fa526_target,
84 &feroceon_target,
85 &dragonite_target,
86 &xscale_target,
87 &cortexm3_target,
88 &cortexa8_target,
89 &arm11_target,
90 &mips_m4k_target,
91 &avr_target,
92 &dsp563xx_target,
93 &testee_target,
94 &avr32_ap7k_target,
95 NULL,
96 };
97
98 struct target *all_targets = NULL;
99 static struct target_event_callback *target_event_callbacks = NULL;
100 static struct target_timer_callback *target_timer_callbacks = NULL;
101 static const int polling_interval = 100;
102
103 static const Jim_Nvp nvp_assert[] = {
104 { .name = "assert", NVP_ASSERT },
105 { .name = "deassert", NVP_DEASSERT },
106 { .name = "T", NVP_ASSERT },
107 { .name = "F", NVP_DEASSERT },
108 { .name = "t", NVP_ASSERT },
109 { .name = "f", NVP_DEASSERT },
110 { .name = NULL, .value = -1 }
111 };
112
113 static const Jim_Nvp nvp_error_target[] = {
114 { .value = ERROR_TARGET_INVALID, .name = "err-invalid" },
115 { .value = ERROR_TARGET_INIT_FAILED, .name = "err-init-failed" },
116 { .value = ERROR_TARGET_TIMEOUT, .name = "err-timeout" },
117 { .value = ERROR_TARGET_NOT_HALTED, .name = "err-not-halted" },
118 { .value = ERROR_TARGET_FAILURE, .name = "err-failure" },
119 { .value = ERROR_TARGET_UNALIGNED_ACCESS , .name = "err-unaligned-access" },
120 { .value = ERROR_TARGET_DATA_ABORT , .name = "err-data-abort" },
121 { .value = ERROR_TARGET_RESOURCE_NOT_AVAILABLE , .name = "err-resource-not-available" },
122 { .value = ERROR_TARGET_TRANSLATION_FAULT , .name = "err-translation-fault" },
123 { .value = ERROR_TARGET_NOT_RUNNING, .name = "err-not-running" },
124 { .value = ERROR_TARGET_NOT_EXAMINED, .name = "err-not-examined" },
125 { .value = -1, .name = NULL }
126 };
127
128 static const char *target_strerror_safe(int err)
129 {
130 const Jim_Nvp *n;
131
132 n = Jim_Nvp_value2name_simple(nvp_error_target, err);
133 if (n->name == NULL) {
134 return "unknown";
135 } else {
136 return n->name;
137 }
138 }
139
140 static const Jim_Nvp nvp_target_event[] = {
141 { .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
142 { .value = TARGET_EVENT_OLD_pre_resume , .name = "old-pre_resume" },
143
144 { .value = TARGET_EVENT_GDB_HALT, .name = "gdb-halt" },
145 { .value = TARGET_EVENT_HALTED, .name = "halted" },
146 { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
147 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
148 { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
149
150 { .name = "gdb-start", .value = TARGET_EVENT_GDB_START },
151 { .name = "gdb-end", .value = TARGET_EVENT_GDB_END },
152
153 /* historical name */
154
155 { .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
156
157 { .value = TARGET_EVENT_RESET_ASSERT_PRE, .name = "reset-assert-pre" },
158 { .value = TARGET_EVENT_RESET_ASSERT, .name = "reset-assert" },
159 { .value = TARGET_EVENT_RESET_ASSERT_POST, .name = "reset-assert-post" },
160 { .value = TARGET_EVENT_RESET_DEASSERT_PRE, .name = "reset-deassert-pre" },
161 { .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
162 { .value = TARGET_EVENT_RESET_HALT_PRE, .name = "reset-halt-pre" },
163 { .value = TARGET_EVENT_RESET_HALT_POST, .name = "reset-halt-post" },
164 { .value = TARGET_EVENT_RESET_WAIT_PRE, .name = "reset-wait-pre" },
165 { .value = TARGET_EVENT_RESET_WAIT_POST, .name = "reset-wait-post" },
166 { .value = TARGET_EVENT_RESET_INIT, .name = "reset-init" },
167 { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
168
169 { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
170 { .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
171
172 { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
173 { .value = TARGET_EVENT_DEBUG_RESUMED, .name = "debug-resumed" },
174
175 { .value = TARGET_EVENT_GDB_ATTACH, .name = "gdb-attach" },
176 { .value = TARGET_EVENT_GDB_DETACH, .name = "gdb-detach" },
177
178 { .value = TARGET_EVENT_GDB_FLASH_WRITE_START, .name = "gdb-flash-write-start" },
179 { .value = TARGET_EVENT_GDB_FLASH_WRITE_END , .name = "gdb-flash-write-end" },
180
181 { .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
182 { .value = TARGET_EVENT_GDB_FLASH_ERASE_END , .name = "gdb-flash-erase-end" },
183
184 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
185 { .value = TARGET_EVENT_RESUMED , .name = "resume-ok" },
186 { .value = TARGET_EVENT_RESUME_END , .name = "resume-end" },
187
188 { .name = NULL, .value = -1 }
189 };
190
191 static const Jim_Nvp nvp_target_state[] = {
192 { .name = "unknown", .value = TARGET_UNKNOWN },
193 { .name = "running", .value = TARGET_RUNNING },
194 { .name = "halted", .value = TARGET_HALTED },
195 { .name = "reset", .value = TARGET_RESET },
196 { .name = "debug-running", .value = TARGET_DEBUG_RUNNING },
197 { .name = NULL, .value = -1 },
198 };
199
200 static const Jim_Nvp nvp_target_debug_reason [] = {
201 { .name = "debug-request" , .value = DBG_REASON_DBGRQ },
202 { .name = "breakpoint" , .value = DBG_REASON_BREAKPOINT },
203 { .name = "watchpoint" , .value = DBG_REASON_WATCHPOINT },
204 { .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
205 { .name = "single-step" , .value = DBG_REASON_SINGLESTEP },
206 { .name = "target-not-halted" , .value = DBG_REASON_NOTHALTED },
207 { .name = "undefined" , .value = DBG_REASON_UNDEFINED },
208 { .name = NULL, .value = -1 },
209 };
210
211 static const Jim_Nvp nvp_target_endian[] = {
212 { .name = "big", .value = TARGET_BIG_ENDIAN },
213 { .name = "little", .value = TARGET_LITTLE_ENDIAN },
214 { .name = "be", .value = TARGET_BIG_ENDIAN },
215 { .name = "le", .value = TARGET_LITTLE_ENDIAN },
216 { .name = NULL, .value = -1 },
217 };
218
219 static const Jim_Nvp nvp_reset_modes[] = {
220 { .name = "unknown", .value = RESET_UNKNOWN },
221 { .name = "run" , .value = RESET_RUN },
222 { .name = "halt" , .value = RESET_HALT },
223 { .name = "init" , .value = RESET_INIT },
224 { .name = NULL , .value = -1 },
225 };
226
227 const char *debug_reason_name(struct target *t)
228 {
229 const char *cp;
230
231 cp = Jim_Nvp_value2name_simple(nvp_target_debug_reason,
232 t->debug_reason)->name;
233 if (!cp) {
234 LOG_ERROR("Invalid debug reason: %d", (int)(t->debug_reason));
235 cp = "(*BUG*unknown*BUG*)";
236 }
237 return cp;
238 }
239
240 const char *
241 target_state_name( struct target *t )
242 {
243 const char *cp;
244 cp = Jim_Nvp_value2name_simple(nvp_target_state, t->state)->name;
245 if( !cp ){
246 LOG_ERROR("Invalid target state: %d", (int)(t->state));
247 cp = "(*BUG*unknown*BUG*)";
248 }
249 return cp;
250 }
251
252 /* determine the number of the new target */
253 static int new_target_number(void)
254 {
255 struct target *t;
256 int x;
257
258 /* number is 0 based */
259 x = -1;
260 t = all_targets;
261 while (t) {
262 if (x < t->target_number) {
263 x = t->target_number;
264 }
265 t = t->next;
266 }
267 return x + 1;
268 }
269
270 /* read a uint32_t from a buffer in target memory endianness */
271 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
272 {
273 if (target->endianness == TARGET_LITTLE_ENDIAN)
274 return le_to_h_u32(buffer);
275 else
276 return be_to_h_u32(buffer);
277 }
278
279 /* read a uint16_t from a buffer in target memory endianness */
280 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
281 {
282 if (target->endianness == TARGET_LITTLE_ENDIAN)
283 return le_to_h_u16(buffer);
284 else
285 return be_to_h_u16(buffer);
286 }
287
288 /* read a uint8_t from a buffer in target memory endianness */
289 static uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer)
290 {
291 return *buffer & 0x0ff;
292 }
293
294 /* write a uint32_t to a buffer in target memory endianness */
295 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
296 {
297 if (target->endianness == TARGET_LITTLE_ENDIAN)
298 h_u32_to_le(buffer, value);
299 else
300 h_u32_to_be(buffer, value);
301 }
302
303 /* write a uint16_t to a buffer in target memory endianness */
304 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
305 {
306 if (target->endianness == TARGET_LITTLE_ENDIAN)
307 h_u16_to_le(buffer, value);
308 else
309 h_u16_to_be(buffer, value);
310 }
311
312 /* write a uint8_t to a buffer in target memory endianness */
313 static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
314 {
315 *buffer = value;
316 }
317
318 /* return a pointer to a configured target; id is name or number */
319 struct target *get_target(const char *id)
320 {
321 struct target *target;
322
323 /* try as tcltarget name */
324 for (target = all_targets; target; target = target->next) {
325 if (target->cmd_name == NULL)
326 continue;
327 if (strcmp(id, target->cmd_name) == 0)
328 return target;
329 }
330
331 /* It's OK to remove this fallback sometime after August 2010 or so */
332
333 /* no match, try as number */
334 unsigned num;
335 if (parse_uint(id, &num) != ERROR_OK)
336 return NULL;
337
338 for (target = all_targets; target; target = target->next) {
339 if (target->target_number == (int)num) {
340 LOG_WARNING("use '%s' as target identifier, not '%u'",
341 target->cmd_name, num);
342 return target;
343 }
344 }
345
346 return NULL;
347 }
348
349 /* returns a pointer to the n-th configured target */
350 static struct target *get_target_by_num(int num)
351 {
352 struct target *target = all_targets;
353
354 while (target) {
355 if (target->target_number == num) {
356 return target;
357 }
358 target = target->next;
359 }
360
361 return NULL;
362 }
363
364 struct target* get_current_target(struct command_context *cmd_ctx)
365 {
366 struct target *target = get_target_by_num(cmd_ctx->current_target);
367
368 if (target == NULL)
369 {
370 LOG_ERROR("BUG: current_target out of bounds");
371 exit(-1);
372 }
373
374 return target;
375 }
376
377 int target_poll(struct target *target)
378 {
379 int retval;
380
381 /* We can't poll until after examine */
382 if (!target_was_examined(target))
383 {
384 /* Fail silently lest we pollute the log */
385 return ERROR_FAIL;
386 }
387
388 retval = target->type->poll(target);
389 if (retval != ERROR_OK)
390 return retval;
391
392 if (target->halt_issued)
393 {
394 if (target->state == TARGET_HALTED)
395 {
396 target->halt_issued = false;
397 } else
398 {
399 long long t = timeval_ms() - target->halt_issued_time;
400 if (t>1000)
401 {
402 target->halt_issued = false;
403 LOG_INFO("Halt timed out, wake up GDB.");
404 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
405 }
406 }
407 }
408
409 return ERROR_OK;
410 }
411
412 int target_halt(struct target *target)
413 {
414 int retval;
415 /* We can't poll until after examine */
416 if (!target_was_examined(target))
417 {
418 LOG_ERROR("Target not examined yet");
419 return ERROR_FAIL;
420 }
421
422 retval = target->type->halt(target);
423 if (retval != ERROR_OK)
424 return retval;
425
426 target->halt_issued = true;
427 target->halt_issued_time = timeval_ms();
428
429 return ERROR_OK;
430 }
431
432 /**
433 * Make the target (re)start executing using its saved execution
434 * context (possibly with some modifications).
435 *
436 * @param target Which target should start executing.
437 * @param current True to use the target's saved program counter instead
438 * of the address parameter
439 * @param address Optionally used as the program counter.
440 * @param handle_breakpoints True iff breakpoints at the resumption PC
441 * should be skipped. (For example, maybe execution was stopped by
442 * such a breakpoint, in which case it would be counterprodutive to
443 * let it re-trigger.
444 * @param debug_execution False if all working areas allocated by OpenOCD
445 * should be released and/or restored to their original contents.
446 * (This would for example be true to run some downloaded "helper"
447 * algorithm code, which resides in one such working buffer and uses
448 * another for data storage.)
449 *
450 * @todo Resolve the ambiguity about what the "debug_execution" flag
451 * signifies. For example, Target implementations don't agree on how
452 * it relates to invalidation of the register cache, or to whether
453 * breakpoints and watchpoints should be enabled. (It would seem wrong
454 * to enable breakpoints when running downloaded "helper" algorithms
455 * (debug_execution true), since the breakpoints would be set to match
456 * target firmware being debugged, not the helper algorithm.... and
457 * enabling them could cause such helpers to malfunction (for example,
458 * by overwriting data with a breakpoint instruction. On the other
459 * hand the infrastructure for running such helpers might use this
460 * procedure but rely on hardware breakpoint to detect termination.)
461 */
462 int target_resume(struct target *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
463 {
464 int retval;
465
466 /* We can't poll until after examine */
467 if (!target_was_examined(target))
468 {
469 LOG_ERROR("Target not examined yet");
470 return ERROR_FAIL;
471 }
472
473 /* note that resume *must* be asynchronous. The CPU can halt before
474 * we poll. The CPU can even halt at the current PC as a result of
475 * a software breakpoint being inserted by (a bug?) the application.
476 */
477 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
478 return retval;
479
480 return retval;
481 }
482
483 static int target_process_reset(struct command_context *cmd_ctx, enum target_reset_mode reset_mode)
484 {
485 char buf[100];
486 int retval;
487 Jim_Nvp *n;
488 n = Jim_Nvp_value2name_simple(nvp_reset_modes, reset_mode);
489 if (n->name == NULL) {
490 LOG_ERROR("invalid reset mode");
491 return ERROR_FAIL;
492 }
493
494 /* disable polling during reset to make reset event scripts
495 * more predictable, i.e. dr/irscan & pathmove in events will
496 * not have JTAG operations injected into the middle of a sequence.
497 */
498 bool save_poll = jtag_poll_get_enabled();
499
500 jtag_poll_set_enabled(false);
501
502 sprintf(buf, "ocd_process_reset %s", n->name);
503 retval = Jim_Eval(cmd_ctx->interp, buf);
504
505 jtag_poll_set_enabled(save_poll);
506
507 if (retval != JIM_OK) {
508 Jim_PrintErrorMessage(cmd_ctx->interp);
509 return ERROR_FAIL;
510 }
511
512 /* We want any events to be processed before the prompt */
513 retval = target_call_timer_callbacks_now();
514
515 struct target *target;
516 for (target = all_targets; target; target = target->next) {
517 target->type->check_reset(target);
518 }
519
520 return retval;
521 }
522
523 static int identity_virt2phys(struct target *target,
524 uint32_t virtual, uint32_t *physical)
525 {
526 *physical = virtual;
527 return ERROR_OK;
528 }
529
530 static int no_mmu(struct target *target, int *enabled)
531 {
532 *enabled = 0;
533 return ERROR_OK;
534 }
535
536 static int default_examine(struct target *target)
537 {
538 target_set_examined(target);
539 return ERROR_OK;
540 }
541
542 /* no check by default */
543 static int default_check_reset(struct target *target)
544 {
545 return ERROR_OK;
546 }
547
548 int target_examine_one(struct target *target)
549 {
550 return target->type->examine(target);
551 }
552
553 static int jtag_enable_callback(enum jtag_event event, void *priv)
554 {
555 struct target *target = priv;
556
557 if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled)
558 return ERROR_OK;
559
560 jtag_unregister_event_callback(jtag_enable_callback, target);
561 return target_examine_one(target);
562 }
563
564
565 /* Targets that correctly implement init + examine, i.e.
566 * no communication with target during init:
567 *
568 * XScale
569 */
570 int target_examine(void)
571 {
572 int retval = ERROR_OK;
573 struct target *target;
574
575 for (target = all_targets; target; target = target->next)
576 {
577 /* defer examination, but don't skip it */
578 if (!target->tap->enabled) {
579 jtag_register_event_callback(jtag_enable_callback,
580 target);
581 continue;
582 }
583 if ((retval = target_examine_one(target)) != ERROR_OK)
584 return retval;
585 }
586 return retval;
587 }
588 const char *target_type_name(struct target *target)
589 {
590 return target->type->name;
591 }
592
593 static int target_write_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
594 {
595 if (!target_was_examined(target))
596 {
597 LOG_ERROR("Target not examined yet");
598 return ERROR_FAIL;
599 }
600 return target->type->write_memory_imp(target, address, size, count, buffer);
601 }
602
603 static int target_read_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
604 {
605 if (!target_was_examined(target))
606 {
607 LOG_ERROR("Target not examined yet");
608 return ERROR_FAIL;
609 }
610 return target->type->read_memory_imp(target, address, size, count, buffer);
611 }
612
613 static int target_soft_reset_halt_imp(struct target *target)
614 {
615 if (!target_was_examined(target))
616 {
617 LOG_ERROR("Target not examined yet");
618 return ERROR_FAIL;
619 }
620 if (!target->type->soft_reset_halt_imp) {
621 LOG_ERROR("Target %s does not support soft_reset_halt",
622 target_name(target));
623 return ERROR_FAIL;
624 }
625 return target->type->soft_reset_halt_imp(target);
626 }
627
628 /**
629 * Downloads a target-specific native code algorithm to the target,
630 * and executes it. * Note that some targets may need to set up, enable,
631 * and tear down a breakpoint (hard or * soft) to detect algorithm
632 * termination, while others may support lower overhead schemes where
633 * soft breakpoints embedded in the algorithm automatically terminate the
634 * algorithm.
635 *
636 * @param target used to run the algorithm
637 * @param arch_info target-specific description of the algorithm.
638 */
639 int target_run_algorithm(struct target *target,
640 int num_mem_params, struct mem_param *mem_params,
641 int num_reg_params, struct reg_param *reg_param,
642 uint32_t entry_point, uint32_t exit_point,
643 int timeout_ms, void *arch_info)
644 {
645 int retval = ERROR_FAIL;
646
647 if (!target_was_examined(target))
648 {
649 LOG_ERROR("Target not examined yet");
650 goto done;
651 }
652 if (!target->type->run_algorithm) {
653 LOG_ERROR("Target type '%s' does not support %s",
654 target_type_name(target), __func__);
655 goto done;
656 }
657
658 target->running_alg = true;
659 retval = target->type->run_algorithm(target,
660 num_mem_params, mem_params,
661 num_reg_params, reg_param,
662 entry_point, exit_point, timeout_ms, arch_info);
663 target->running_alg = false;
664
665 done:
666 return retval;
667 }
668
669
670 int target_read_memory(struct target *target,
671 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
672 {
673 return target->type->read_memory(target, address, size, count, buffer);
674 }
675
676 static int target_read_phys_memory(struct target *target,
677 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
678 {
679 return target->type->read_phys_memory(target, address, size, count, buffer);
680 }
681
682 int target_write_memory(struct target *target,
683 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
684 {
685 return target->type->write_memory(target, address, size, count, buffer);
686 }
687
688 static int target_write_phys_memory(struct target *target,
689 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
690 {
691 return target->type->write_phys_memory(target, address, size, count, buffer);
692 }
693
694 int target_bulk_write_memory(struct target *target,
695 uint32_t address, uint32_t count, uint8_t *buffer)
696 {
697 return target->type->bulk_write_memory(target, address, count, buffer);
698 }
699
700 int target_add_breakpoint(struct target *target,
701 struct breakpoint *breakpoint)
702 {
703 if (target->state != TARGET_HALTED) {
704 LOG_WARNING("target %s is not halted", target->cmd_name);
705 return ERROR_TARGET_NOT_HALTED;
706 }
707 return target->type->add_breakpoint(target, breakpoint);
708 }
709 int target_remove_breakpoint(struct target *target,
710 struct breakpoint *breakpoint)
711 {
712 return target->type->remove_breakpoint(target, breakpoint);
713 }
714
715 int target_add_watchpoint(struct target *target,
716 struct watchpoint *watchpoint)
717 {
718 if (target->state != TARGET_HALTED) {
719 LOG_WARNING("target %s is not halted", target->cmd_name);
720 return ERROR_TARGET_NOT_HALTED;
721 }
722 return target->type->add_watchpoint(target, watchpoint);
723 }
724 int target_remove_watchpoint(struct target *target,
725 struct watchpoint *watchpoint)
726 {
727 return target->type->remove_watchpoint(target, watchpoint);
728 }
729
730 int target_get_gdb_reg_list(struct target *target,
731 struct reg **reg_list[], int *reg_list_size)
732 {
733 return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
734 }
735 int target_step(struct target *target,
736 int current, uint32_t address, int handle_breakpoints)
737 {
738 return target->type->step(target, current, address, handle_breakpoints);
739 }
740
741
742 /**
743 * Reset the @c examined flag for the given target.
744 * Pure paranoia -- targets are zeroed on allocation.
745 */
746 static void target_reset_examined(struct target *target)
747 {
748 target->examined = false;
749 }
750
751 static int
752 err_read_phys_memory(struct target *target, uint32_t address,
753 uint32_t size, uint32_t count, uint8_t *buffer)
754 {
755 LOG_ERROR("Not implemented: %s", __func__);
756 return ERROR_FAIL;
757 }
758
759 static int
760 err_write_phys_memory(struct target *target, uint32_t address,
761 uint32_t size, uint32_t count, uint8_t *buffer)
762 {
763 LOG_ERROR("Not implemented: %s", __func__);
764 return ERROR_FAIL;
765 }
766
767 static int handle_target(void *priv);
768
769 static int target_init_one(struct command_context *cmd_ctx,
770 struct target *target)
771 {
772 target_reset_examined(target);
773
774 struct target_type *type = target->type;
775 if (type->examine == NULL)
776 type->examine = default_examine;
777
778 if (type->check_reset== NULL)
779 type->check_reset = default_check_reset;
780
781 int retval = type->init_target(cmd_ctx, target);
782 if (ERROR_OK != retval)
783 {
784 LOG_ERROR("target '%s' init failed", target_name(target));
785 return retval;
786 }
787
788 /**
789 * @todo get rid of those *memory_imp() methods, now that all
790 * callers are using target_*_memory() accessors ... and make
791 * sure the "physical" paths handle the same issues.
792 */
793 /* a non-invasive way(in terms of patches) to add some code that
794 * runs before the type->write/read_memory implementation
795 */
796 type->write_memory_imp = target->type->write_memory;
797 type->write_memory = target_write_memory_imp;
798
799 type->read_memory_imp = target->type->read_memory;
800 type->read_memory = target_read_memory_imp;
801
802 type->soft_reset_halt_imp = target->type->soft_reset_halt;
803 type->soft_reset_halt = target_soft_reset_halt_imp;
804
805 /* Sanity-check MMU support ... stub in what we must, to help
806 * implement it in stages, but warn if we need to do so.
807 */
808 if (type->mmu)
809 {
810 if (type->write_phys_memory == NULL)
811 {
812 LOG_ERROR("type '%s' is missing write_phys_memory",
813 type->name);
814 type->write_phys_memory = err_write_phys_memory;
815 }
816 if (type->read_phys_memory == NULL)
817 {
818 LOG_ERROR("type '%s' is missing read_phys_memory",
819 type->name);
820 type->read_phys_memory = err_read_phys_memory;
821 }
822 if (type->virt2phys == NULL)
823 {
824 LOG_ERROR("type '%s' is missing virt2phys", type->name);
825 type->virt2phys = identity_virt2phys;
826 }
827 }
828 else
829 {
830 /* Make sure no-MMU targets all behave the same: make no
831 * distinction between physical and virtual addresses, and
832 * ensure that virt2phys() is always an identity mapping.
833 */
834 if (type->write_phys_memory || type->read_phys_memory
835 || type->virt2phys)
836 {
837 LOG_WARNING("type '%s' has bad MMU hooks", type->name);
838 }
839
840 type->mmu = no_mmu;
841 type->write_phys_memory = type->write_memory;
842 type->read_phys_memory = type->read_memory;
843 type->virt2phys = identity_virt2phys;
844 }
845 return ERROR_OK;
846 }
847
848 static int target_init(struct command_context *cmd_ctx)
849 {
850 struct target *target;
851 int retval;
852
853 for (target = all_targets; target; target = target->next)
854 {
855 retval = target_init_one(cmd_ctx, target);
856 if (ERROR_OK != retval)
857 return retval;
858 }
859
860 if (!all_targets)
861 return ERROR_OK;
862
863 retval = target_register_user_commands(cmd_ctx);
864 if (ERROR_OK != retval)
865 return retval;
866
867 retval = target_register_timer_callback(&handle_target,
868 polling_interval, 1, cmd_ctx->interp);
869 if (ERROR_OK != retval)
870 return retval;
871
872 return ERROR_OK;
873 }
874
875 COMMAND_HANDLER(handle_target_init_command)
876 {
877 if (CMD_ARGC != 0)
878 return ERROR_COMMAND_SYNTAX_ERROR;
879
880 static bool target_initialized = false;
881 if (target_initialized)
882 {
883 LOG_INFO("'target init' has already been called");
884 return ERROR_OK;
885 }
886 target_initialized = true;
887
888 LOG_DEBUG("Initializing targets...");
889 return target_init(CMD_CTX);
890 }
891
892 int target_register_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv)
893 {
894 struct target_event_callback **callbacks_p = &target_event_callbacks;
895
896 if (callback == NULL)
897 {
898 return ERROR_INVALID_ARGUMENTS;
899 }
900
901 if (*callbacks_p)
902 {
903 while ((*callbacks_p)->next)
904 callbacks_p = &((*callbacks_p)->next);
905 callbacks_p = &((*callbacks_p)->next);
906 }
907
908 (*callbacks_p) = malloc(sizeof(struct target_event_callback));
909 (*callbacks_p)->callback = callback;
910 (*callbacks_p)->priv = priv;
911 (*callbacks_p)->next = NULL;
912
913 return ERROR_OK;
914 }
915
916 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
917 {
918 struct target_timer_callback **callbacks_p = &target_timer_callbacks;
919 struct timeval now;
920
921 if (callback == NULL)
922 {
923 return ERROR_INVALID_ARGUMENTS;
924 }
925
926 if (*callbacks_p)
927 {
928 while ((*callbacks_p)->next)
929 callbacks_p = &((*callbacks_p)->next);
930 callbacks_p = &((*callbacks_p)->next);
931 }
932
933 (*callbacks_p) = malloc(sizeof(struct target_timer_callback));
934 (*callbacks_p)->callback = callback;
935 (*callbacks_p)->periodic = periodic;
936 (*callbacks_p)->time_ms = time_ms;
937
938 gettimeofday(&now, NULL);
939 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
940 time_ms -= (time_ms % 1000);
941 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
942 if ((*callbacks_p)->when.tv_usec > 1000000)
943 {
944 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
945 (*callbacks_p)->when.tv_sec += 1;
946 }
947
948 (*callbacks_p)->priv = priv;
949 (*callbacks_p)->next = NULL;
950
951 return ERROR_OK;
952 }
953
954 int target_unregister_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv)
955 {
956 struct target_event_callback **p = &target_event_callbacks;
957 struct target_event_callback *c = target_event_callbacks;
958
959 if (callback == NULL)
960 {
961 return ERROR_INVALID_ARGUMENTS;
962 }
963
964 while (c)
965 {
966 struct target_event_callback *next = c->next;
967 if ((c->callback == callback) && (c->priv == priv))
968 {
969 *p = next;
970 free(c);
971 return ERROR_OK;
972 }
973 else
974 p = &(c->next);
975 c = next;
976 }
977
978 return ERROR_OK;
979 }
980
981 static int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
982 {
983 struct target_timer_callback **p = &target_timer_callbacks;
984 struct target_timer_callback *c = target_timer_callbacks;
985
986 if (callback == NULL)
987 {
988 return ERROR_INVALID_ARGUMENTS;
989 }
990
991 while (c)
992 {
993 struct target_timer_callback *next = c->next;
994 if ((c->callback == callback) && (c->priv == priv))
995 {
996 *p = next;
997 free(c);
998 return ERROR_OK;
999 }
1000 else
1001 p = &(c->next);
1002 c = next;
1003 }
1004
1005 return ERROR_OK;
1006 }
1007
1008 int target_call_event_callbacks(struct target *target, enum target_event event)
1009 {
1010 struct target_event_callback *callback = target_event_callbacks;
1011 struct target_event_callback *next_callback;
1012
1013 if (event == TARGET_EVENT_HALTED)
1014 {
1015 /* execute early halted first */
1016 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1017 }
1018
1019 LOG_DEBUG("target event %i (%s)",
1020 event,
1021 Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
1022
1023 target_handle_event(target, event);
1024
1025 while (callback)
1026 {
1027 next_callback = callback->next;
1028 callback->callback(target, event, callback->priv);
1029 callback = next_callback;
1030 }
1031
1032 return ERROR_OK;
1033 }
1034
1035 static int target_timer_callback_periodic_restart(
1036 struct target_timer_callback *cb, struct timeval *now)
1037 {
1038 int time_ms = cb->time_ms;
1039 cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
1040 time_ms -= (time_ms % 1000);
1041 cb->when.tv_sec = now->tv_sec + time_ms / 1000;
1042 if (cb->when.tv_usec > 1000000)
1043 {
1044 cb->when.tv_usec = cb->when.tv_usec - 1000000;
1045 cb->when.tv_sec += 1;
1046 }
1047 return ERROR_OK;
1048 }
1049
1050 static int target_call_timer_callback(struct target_timer_callback *cb,
1051 struct timeval *now)
1052 {
1053 cb->callback(cb->priv);
1054
1055 if (cb->periodic)
1056 return target_timer_callback_periodic_restart(cb, now);
1057
1058 return target_unregister_timer_callback(cb->callback, cb->priv);
1059 }
1060
1061 static int target_call_timer_callbacks_check_time(int checktime)
1062 {
1063 keep_alive();
1064
1065 struct timeval now;
1066 gettimeofday(&now, NULL);
1067
1068 struct target_timer_callback *callback = target_timer_callbacks;
1069 while (callback)
1070 {
1071 // cleaning up may unregister and free this callback
1072 struct target_timer_callback *next_callback = callback->next;
1073
1074 bool call_it = callback->callback &&
1075 ((!checktime && callback->periodic) ||
1076 now.tv_sec > callback->when.tv_sec ||
1077 (now.tv_sec == callback->when.tv_sec &&
1078 now.tv_usec >= callback->when.tv_usec));
1079
1080 if (call_it)
1081 {
1082 int retval = target_call_timer_callback(callback, &now);
1083 if (retval != ERROR_OK)
1084 return retval;
1085 }
1086
1087 callback = next_callback;
1088 }
1089
1090 return ERROR_OK;
1091 }
1092
1093 int target_call_timer_callbacks(void)
1094 {
1095 return target_call_timer_callbacks_check_time(1);
1096 }
1097
1098 /* invoke periodic callbacks immediately */
1099 int target_call_timer_callbacks_now(void)
1100 {
1101 return target_call_timer_callbacks_check_time(0);
1102 }
1103
1104 int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
1105 {
1106 struct working_area *c = target->working_areas;
1107 struct working_area *new_wa = NULL;
1108
1109 /* Reevaluate working area address based on MMU state*/
1110 if (target->working_areas == NULL)
1111 {
1112 int retval;
1113 int enabled;
1114
1115 retval = target->type->mmu(target, &enabled);
1116 if (retval != ERROR_OK)
1117 {
1118 return retval;
1119 }
1120
1121 if (!enabled) {
1122 if (target->working_area_phys_spec) {
1123 LOG_DEBUG("MMU disabled, using physical "
1124 "address for working memory 0x%08x",
1125 (unsigned)target->working_area_phys);
1126 target->working_area = target->working_area_phys;
1127 } else {
1128 LOG_ERROR("No working memory available. "
1129 "Specify -work-area-phys to target.");
1130 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1131 }
1132 } else {
1133 if (target->working_area_virt_spec) {
1134 LOG_DEBUG("MMU enabled, using virtual "
1135 "address for working memory 0x%08x",
1136 (unsigned)target->working_area_virt);
1137 target->working_area = target->working_area_virt;
1138 } else {
1139 LOG_ERROR("No working memory available. "
1140 "Specify -work-area-virt to target.");
1141 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1142 }
1143 }
1144 }
1145
1146 /* only allocate multiples of 4 byte */
1147 if (size % 4)
1148 {
1149 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes (0x%08x), padding", ((unsigned)(size)));
1150 size = (size + 3) & (~3);
1151 }
1152
1153 /* see if there's already a matching working area */
1154 while (c)
1155 {
1156 if ((c->free) && (c->size == size))
1157 {
1158 new_wa = c;
1159 break;
1160 }
1161 c = c->next;
1162 }
1163
1164 /* if not, allocate a new one */
1165 if (!new_wa)
1166 {
1167 struct working_area **p = &target->working_areas;
1168 uint32_t first_free = target->working_area;
1169 uint32_t free_size = target->working_area_size;
1170
1171 c = target->working_areas;
1172 while (c)
1173 {
1174 first_free += c->size;
1175 free_size -= c->size;
1176 p = &c->next;
1177 c = c->next;
1178 }
1179
1180 if (free_size < size)
1181 {
1182 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1183 }
1184
1185 LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free);
1186
1187 new_wa = malloc(sizeof(struct working_area));
1188 new_wa->next = NULL;
1189 new_wa->size = size;
1190 new_wa->address = first_free;
1191
1192 if (target->backup_working_area)
1193 {
1194 int retval;
1195 new_wa->backup = malloc(new_wa->size);
1196 if ((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
1197 {
1198 free(new_wa->backup);
1199 free(new_wa);
1200 return retval;
1201 }
1202 }
1203 else
1204 {
1205 new_wa->backup = NULL;
1206 }
1207
1208 /* put new entry in list */
1209 *p = new_wa;
1210 }
1211
1212 /* mark as used, and return the new (reused) area */
1213 new_wa->free = 0;
1214 *area = new_wa;
1215
1216 /* user pointer */
1217 new_wa->user = area;
1218
1219 return ERROR_OK;
1220 }
1221
1222 int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
1223 {
1224 int retval;
1225
1226 retval = target_alloc_working_area_try(target, size, area);
1227 if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1228 {
1229 LOG_WARNING("not enough working area available(requested %u)", (unsigned)(size));
1230 }
1231 return retval;
1232
1233 }
1234
1235 static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
1236 {
1237 if (area->free)
1238 return ERROR_OK;
1239
1240 if (restore && target->backup_working_area)
1241 {
1242 int retval;
1243 if ((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
1244 return retval;
1245 }
1246
1247 area->free = 1;
1248
1249 /* mark user pointer invalid */
1250 *area->user = NULL;
1251 area->user = NULL;
1252
1253 return ERROR_OK;
1254 }
1255
1256 int target_free_working_area(struct target *target, struct working_area *area)
1257 {
1258 return target_free_working_area_restore(target, area, 1);
1259 }
1260
1261 /* free resources and restore memory, if restoring memory fails,
1262 * free up resources anyway
1263 */
1264 static void target_free_all_working_areas_restore(struct target *target, int restore)
1265 {
1266 struct working_area *c = target->working_areas;
1267
1268 while (c)
1269 {
1270 struct working_area *next = c->next;
1271 target_free_working_area_restore(target, c, restore);
1272
1273 if (c->backup)
1274 free(c->backup);
1275
1276 free(c);
1277
1278 c = next;
1279 }
1280
1281 target->working_areas = NULL;
1282 }
1283
1284 void target_free_all_working_areas(struct target *target)
1285 {
1286 target_free_all_working_areas_restore(target, 1);
1287 }
1288
1289 int target_arch_state(struct target *target)
1290 {
1291 int retval;
1292 if (target == NULL)
1293 {
1294 LOG_USER("No target has been configured");
1295 return ERROR_OK;
1296 }
1297
1298 LOG_USER("target state: %s", target_state_name( target ));
1299
1300 if (target->state != TARGET_HALTED)
1301 return ERROR_OK;
1302
1303 retval = target->type->arch_state(target);
1304 return retval;
1305 }
1306
1307 /* Single aligned words are guaranteed to use 16 or 32 bit access
1308 * mode respectively, otherwise data is handled as quickly as
1309 * possible
1310 */
1311 int target_write_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
1312 {
1313 int retval;
1314 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
1315 (int)size, (unsigned)address);
1316
1317 if (!target_was_examined(target))
1318 {
1319 LOG_ERROR("Target not examined yet");
1320 return ERROR_FAIL;
1321 }
1322
1323 if (size == 0) {
1324 return ERROR_OK;
1325 }
1326
1327 if ((address + size - 1) < address)
1328 {
1329 /* GDB can request this when e.g. PC is 0xfffffffc*/
1330 LOG_ERROR("address + size wrapped(0x%08x, 0x%08x)",
1331 (unsigned)address,
1332 (unsigned)size);
1333 return ERROR_FAIL;
1334 }
1335
1336 if (((address % 2) == 0) && (size == 2))
1337 {
1338 return target_write_memory(target, address, 2, 1, buffer);
1339 }
1340
1341 /* handle unaligned head bytes */
1342 if (address % 4)
1343 {
1344 uint32_t unaligned = 4 - (address % 4);
1345
1346 if (unaligned > size)
1347 unaligned = size;
1348
1349 if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1350 return retval;
1351
1352 buffer += unaligned;
1353 address += unaligned;
1354 size -= unaligned;
1355 }
1356
1357 /* handle aligned words */
1358 if (size >= 4)
1359 {
1360 int aligned = size - (size % 4);
1361
1362 /* use bulk writes above a certain limit. This may have to be changed */
1363 if (aligned > 128)
1364 {
1365 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1366 return retval;
1367 }
1368 else
1369 {
1370 if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1371 return retval;
1372 }
1373
1374 buffer += aligned;
1375 address += aligned;
1376 size -= aligned;
1377 }
1378
1379 /* handle tail writes of less than 4 bytes */
1380 if (size > 0)
1381 {
1382 if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1383 return retval;
1384 }
1385
1386 return ERROR_OK;
1387 }
1388
1389 /* Single aligned words are guaranteed to use 16 or 32 bit access
1390 * mode respectively, otherwise data is handled as quickly as
1391 * possible
1392 */
1393 int target_read_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
1394 {
1395 int retval;
1396 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
1397 (int)size, (unsigned)address);
1398
1399 if (!target_was_examined(target))
1400 {
1401 LOG_ERROR("Target not examined yet");
1402 return ERROR_FAIL;
1403 }
1404
1405 if (size == 0) {
1406 return ERROR_OK;
1407 }
1408
1409 if ((address + size - 1) < address)
1410 {
1411 /* GDB can request this when e.g. PC is 0xfffffffc*/
1412 LOG_ERROR("address + size wrapped(0x%08" PRIx32 ", 0x%08" PRIx32 ")",
1413 address,
1414 size);
1415 return ERROR_FAIL;
1416 }
1417
1418 if (((address % 2) == 0) && (size == 2))
1419 {
1420 return target_read_memory(target, address, 2, 1, buffer);
1421 }
1422
1423 /* handle unaligned head bytes */
1424 if (address % 4)
1425 {
1426 uint32_t unaligned = 4 - (address % 4);
1427
1428 if (unaligned > size)
1429 unaligned = size;
1430
1431 if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1432 return retval;
1433
1434 buffer += unaligned;
1435 address += unaligned;
1436 size -= unaligned;
1437 }
1438
1439 /* handle aligned words */
1440 if (size >= 4)
1441 {
1442 int aligned = size - (size % 4);
1443
1444 if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1445 return retval;
1446
1447 buffer += aligned;
1448 address += aligned;
1449 size -= aligned;
1450 }
1451
1452 /*prevent byte access when possible (avoid AHB access limitations in some cases)*/
1453 if(size >=2)
1454 {
1455 int aligned = size - (size%2);
1456 retval = target_read_memory(target, address, 2, aligned / 2, buffer);
1457 if (retval != ERROR_OK)
1458 return retval;
1459
1460 buffer += aligned;
1461 address += aligned;
1462 size -= aligned;
1463 }
1464 /* handle tail writes of less than 4 bytes */
1465 if (size > 0)
1466 {
1467 if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1468 return retval;
1469 }
1470
1471 return ERROR_OK;
1472 }
1473
1474 int target_checksum_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* crc)
1475 {
1476 uint8_t *buffer;
1477 int retval;
1478 uint32_t i;
1479 uint32_t checksum = 0;
1480 if (!target_was_examined(target))
1481 {
1482 LOG_ERROR("Target not examined yet");
1483 return ERROR_FAIL;
1484 }
1485
1486 if ((retval = target->type->checksum_memory(target, address,
1487 size, &checksum)) != ERROR_OK)
1488 {
1489 buffer = malloc(size);
1490 if (buffer == NULL)
1491 {
1492 LOG_ERROR("error allocating buffer for section (%d bytes)", (int)size);
1493 return ERROR_INVALID_ARGUMENTS;
1494 }
1495 retval = target_read_buffer(target, address, size, buffer);
1496 if (retval != ERROR_OK)
1497 {
1498 free(buffer);
1499 return retval;
1500 }
1501
1502 /* convert to target endianess */
1503 for (i = 0; i < (size/sizeof(uint32_t)); i++)
1504 {
1505 uint32_t target_data;
1506 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
1507 target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
1508 }
1509
1510 retval = image_calculate_checksum(buffer, size, &checksum);
1511 free(buffer);
1512 }
1513
1514 *crc = checksum;
1515
1516 return retval;
1517 }
1518
1519 int target_blank_check_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* blank)
1520 {
1521 int retval;
1522 if (!target_was_examined(target))
1523 {
1524 LOG_ERROR("Target not examined yet");
1525 return ERROR_FAIL;
1526 }
1527
1528 if (target->type->blank_check_memory == 0)
1529 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1530
1531 retval = target->type->blank_check_memory(target, address, size, blank);
1532
1533 return retval;
1534 }
1535
1536 int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
1537 {
1538 uint8_t value_buf[4];
1539 if (!target_was_examined(target))
1540 {
1541 LOG_ERROR("Target not examined yet");
1542 return ERROR_FAIL;
1543 }
1544
1545 int retval = target_read_memory(target, address, 4, 1, value_buf);
1546
1547 if (retval == ERROR_OK)
1548 {
1549 *value = target_buffer_get_u32(target, value_buf);
1550 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1551 address,
1552 *value);
1553 }
1554 else
1555 {
1556 *value = 0x0;
1557 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1558 address);
1559 }
1560
1561 return retval;
1562 }
1563
1564 int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
1565 {
1566 uint8_t value_buf[2];
1567 if (!target_was_examined(target))
1568 {
1569 LOG_ERROR("Target not examined yet");
1570 return ERROR_FAIL;
1571 }
1572
1573 int retval = target_read_memory(target, address, 2, 1, value_buf);
1574
1575 if (retval == ERROR_OK)
1576 {
1577 *value = target_buffer_get_u16(target, value_buf);
1578 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4x",
1579 address,
1580 *value);
1581 }
1582 else
1583 {
1584 *value = 0x0;
1585 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1586 address);
1587 }
1588
1589 return retval;
1590 }
1591
1592 int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
1593 {
1594 int retval = target_read_memory(target, address, 1, 1, value);
1595 if (!target_was_examined(target))
1596 {
1597 LOG_ERROR("Target not examined yet");
1598 return ERROR_FAIL;
1599 }
1600
1601 if (retval == ERROR_OK)
1602 {
1603 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1604 address,
1605 *value);
1606 }
1607 else
1608 {
1609 *value = 0x0;
1610 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1611 address);
1612 }
1613
1614 return retval;
1615 }
1616
1617 int target_write_u32(struct target *target, uint32_t address, uint32_t value)
1618 {
1619 int retval;
1620 uint8_t value_buf[4];
1621 if (!target_was_examined(target))
1622 {
1623 LOG_ERROR("Target not examined yet");
1624 return ERROR_FAIL;
1625 }
1626
1627 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1628 address,
1629 value);
1630
1631 target_buffer_set_u32(target, value_buf, value);
1632 if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1633 {
1634 LOG_DEBUG("failed: %i", retval);
1635 }
1636
1637 return retval;
1638 }
1639
1640 int target_write_u16(struct target *target, uint32_t address, uint16_t value)
1641 {
1642 int retval;
1643 uint8_t value_buf[2];
1644 if (!target_was_examined(target))
1645 {
1646 LOG_ERROR("Target not examined yet");
1647 return ERROR_FAIL;
1648 }
1649
1650 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8x",
1651 address,
1652 value);
1653
1654 target_buffer_set_u16(target, value_buf, value);
1655 if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1656 {
1657 LOG_DEBUG("failed: %i", retval);
1658 }
1659
1660 return retval;
1661 }
1662
1663 int target_write_u8(struct target *target, uint32_t address, uint8_t value)
1664 {
1665 int retval;
1666 if (!target_was_examined(target))
1667 {
1668 LOG_ERROR("Target not examined yet");
1669 return ERROR_FAIL;
1670 }
1671
1672 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1673 address, value);
1674
1675 if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
1676 {
1677 LOG_DEBUG("failed: %i", retval);
1678 }
1679
1680 return retval;
1681 }
1682
1683 COMMAND_HANDLER(handle_targets_command)
1684 {
1685 struct target *target = all_targets;
1686
1687 if (CMD_ARGC == 1)
1688 {
1689 target = get_target(CMD_ARGV[0]);
1690 if (target == NULL) {
1691 command_print(CMD_CTX,"Target: %s is unknown, try one of:\n", CMD_ARGV[0]);
1692 goto DumpTargets;
1693 }
1694 if (!target->tap->enabled) {
1695 command_print(CMD_CTX,"Target: TAP %s is disabled, "
1696 "can't be the current target\n",
1697 target->tap->dotted_name);
1698 return ERROR_FAIL;
1699 }
1700
1701 CMD_CTX->current_target = target->target_number;
1702 return ERROR_OK;
1703 }
1704 DumpTargets:
1705
1706 target = all_targets;
1707 command_print(CMD_CTX, " TargetName Type Endian TapName State ");
1708 command_print(CMD_CTX, "-- ------------------ ---------- ------ ------------------ ------------");
1709 while (target)
1710 {
1711 const char *state;
1712 char marker = ' ';
1713
1714 if (target->tap->enabled)
1715 state = target_state_name( target );
1716 else
1717 state = "tap-disabled";
1718
1719 if (CMD_CTX->current_target == target->target_number)
1720 marker = '*';
1721
1722 /* keep columns lined up to match the headers above */
1723 command_print(CMD_CTX, "%2d%c %-18s %-10s %-6s %-18s %s",
1724 target->target_number,
1725 marker,
1726 target_name(target),
1727 target_type_name(target),
1728 Jim_Nvp_value2name_simple(nvp_target_endian,
1729 target->endianness)->name,
1730 target->tap->dotted_name,
1731 state);
1732 target = target->next;
1733 }
1734
1735 return ERROR_OK;
1736 }
1737
1738 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1739
1740 static int powerDropout;
1741 static int srstAsserted;
1742
1743 static int runPowerRestore;
1744 static int runPowerDropout;
1745 static int runSrstAsserted;
1746 static int runSrstDeasserted;
1747
1748 static int sense_handler(void)
1749 {
1750 static int prevSrstAsserted = 0;
1751 static int prevPowerdropout = 0;
1752
1753 int retval;
1754 if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
1755 return retval;
1756
1757 int powerRestored;
1758 powerRestored = prevPowerdropout && !powerDropout;
1759 if (powerRestored)
1760 {
1761 runPowerRestore = 1;
1762 }
1763
1764 long long current = timeval_ms();
1765 static long long lastPower = 0;
1766 int waitMore = lastPower + 2000 > current;
1767 if (powerDropout && !waitMore)
1768 {
1769 runPowerDropout = 1;
1770 lastPower = current;
1771 }
1772
1773 if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
1774 return retval;
1775
1776 int srstDeasserted;
1777 srstDeasserted = prevSrstAsserted && !srstAsserted;
1778
1779 static long long lastSrst = 0;
1780 waitMore = lastSrst + 2000 > current;
1781 if (srstDeasserted && !waitMore)
1782 {
1783 runSrstDeasserted = 1;
1784 lastSrst = current;
1785 }
1786
1787 if (!prevSrstAsserted && srstAsserted)
1788 {
1789 runSrstAsserted = 1;
1790 }
1791
1792 prevSrstAsserted = srstAsserted;
1793 prevPowerdropout = powerDropout;
1794
1795 if (srstDeasserted || powerRestored)
1796 {
1797 /* Other than logging the event we can't do anything here.
1798 * Issuing a reset is a particularly bad idea as we might
1799 * be inside a reset already.
1800 */
1801 }
1802
1803 return ERROR_OK;
1804 }
1805
1806 static int backoff_times = 0;
1807 static int backoff_count = 0;
1808
1809 /* process target state changes */
1810 static int handle_target(void *priv)
1811 {
1812 Jim_Interp *interp = (Jim_Interp *)priv;
1813 int retval = ERROR_OK;
1814
1815 if (!is_jtag_poll_safe())
1816 {
1817 /* polling is disabled currently */
1818 return ERROR_OK;
1819 }
1820
1821 /* we do not want to recurse here... */
1822 static int recursive = 0;
1823 if (! recursive)
1824 {
1825 recursive = 1;
1826 sense_handler();
1827 /* danger! running these procedures can trigger srst assertions and power dropouts.
1828 * We need to avoid an infinite loop/recursion here and we do that by
1829 * clearing the flags after running these events.
1830 */
1831 int did_something = 0;
1832 if (runSrstAsserted)
1833 {
1834 LOG_INFO("srst asserted detected, running srst_asserted proc.");
1835 Jim_Eval(interp, "srst_asserted");
1836 did_something = 1;
1837 }
1838 if (runSrstDeasserted)
1839 {
1840 Jim_Eval(interp, "srst_deasserted");
1841 did_something = 1;
1842 }
1843 if (runPowerDropout)
1844 {
1845 LOG_INFO("Power dropout detected, running power_dropout proc.");
1846 Jim_Eval(interp, "power_dropout");
1847 did_something = 1;
1848 }
1849 if (runPowerRestore)
1850 {
1851 Jim_Eval(interp, "power_restore");
1852 did_something = 1;
1853 }
1854
1855 if (did_something)
1856 {
1857 /* clear detect flags */
1858 sense_handler();
1859 }
1860
1861 /* clear action flags */
1862
1863 runSrstAsserted = 0;
1864 runSrstDeasserted = 0;
1865 runPowerRestore = 0;
1866 runPowerDropout = 0;
1867
1868 recursive = 0;
1869 }
1870
1871 if (backoff_times > backoff_count)
1872 {
1873 /* do not poll this time as we failed previously */
1874 backoff_count++;
1875 return ERROR_OK;
1876 }
1877 backoff_count = 0;
1878
1879 /* Poll targets for state changes unless that's globally disabled.
1880 * Skip targets that are currently disabled.
1881 */
1882 for (struct target *target = all_targets;
1883 is_jtag_poll_safe() && target;
1884 target = target->next)
1885 {
1886 if (!target->tap->enabled)
1887 continue;
1888
1889 /* only poll target if we've got power and srst isn't asserted */
1890 if (!powerDropout && !srstAsserted)
1891 {
1892 /* polling may fail silently until the target has been examined */
1893 if ((retval = target_poll(target)) != ERROR_OK)
1894 {
1895 /* 100ms polling interval. Increase interval between polling up to 5000ms */
1896 if (backoff_times * polling_interval < 5000)
1897 {
1898 backoff_times *= 2;
1899 backoff_times++;
1900 }
1901 LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms", backoff_times * polling_interval);
1902
1903 /* Tell GDB to halt the debugger. This allows the user to
1904 * run monitor commands to handle the situation.
1905 */
1906 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1907 return retval;
1908 }
1909 /* Since we succeeded, we reset backoff count */
1910 if (backoff_times > 0)
1911 {
1912 LOG_USER("Polling succeeded again");
1913 }
1914 backoff_times = 0;
1915 }
1916 }
1917
1918 return retval;
1919 }
1920
1921 COMMAND_HANDLER(handle_reg_command)
1922 {
1923 struct target *target;
1924 struct reg *reg = NULL;
1925 unsigned count = 0;
1926 char *value;
1927
1928 LOG_DEBUG("-");
1929
1930 target = get_current_target(CMD_CTX);
1931
1932 /* list all available registers for the current target */
1933 if (CMD_ARGC == 0)
1934 {
1935 struct reg_cache *cache = target->reg_cache;
1936
1937 count = 0;
1938 while (cache)
1939 {
1940 unsigned i;
1941
1942 command_print(CMD_CTX, "===== %s", cache->name);
1943
1944 for (i = 0, reg = cache->reg_list;
1945 i < cache->num_regs;
1946 i++, reg++, count++)
1947 {
1948 /* only print cached values if they are valid */
1949 if (reg->valid) {
1950 value = buf_to_str(reg->value,
1951 reg->size, 16);
1952 command_print(CMD_CTX,
1953 "(%i) %s (/%" PRIu32 "): 0x%s%s",
1954 count, reg->name,
1955 reg->size, value,
1956 reg->dirty
1957 ? " (dirty)"
1958 : "");
1959 free(value);
1960 } else {
1961 command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
1962 count, reg->name,
1963 reg->size) ;
1964 }
1965 }
1966 cache = cache->next;
1967 }
1968
1969 return ERROR_OK;
1970 }
1971
1972 /* access a single register by its ordinal number */
1973 if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9'))
1974 {
1975 unsigned num;
1976 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
1977
1978 struct reg_cache *cache = target->reg_cache;
1979 count = 0;
1980 while (cache)
1981 {
1982 unsigned i;
1983 for (i = 0; i < cache->num_regs; i++)
1984 {
1985 if (count++ == num)
1986 {
1987 reg = &cache->reg_list[i];
1988 break;
1989 }
1990 }
1991 if (reg)
1992 break;
1993 cache = cache->next;
1994 }
1995
1996 if (!reg)
1997 {
1998 command_print(CMD_CTX, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1999 return ERROR_OK;
2000 }
2001 } else /* access a single register by its name */
2002 {
2003 reg = register_get_by_name(target->reg_cache, CMD_ARGV[0], 1);
2004
2005 if (!reg)
2006 {
2007 command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
2008 return ERROR_OK;
2009 }
2010 }
2011
2012 /* display a register */
2013 if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0') && (CMD_ARGV[1][0] <= '9'))))
2014 {
2015 if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0))
2016 reg->valid = 0;
2017
2018 if (reg->valid == 0)
2019 {
2020 reg->type->get(reg);
2021 }
2022 value = buf_to_str(reg->value, reg->size, 16);
2023 command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2024 free(value);
2025 return ERROR_OK;
2026 }
2027
2028 /* set register value */
2029 if (CMD_ARGC == 2)
2030 {
2031 uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
2032 str_to_buf(CMD_ARGV[1], strlen(CMD_ARGV[1]), buf, reg->size, 0);
2033
2034 reg->type->set(reg, buf);
2035
2036 value = buf_to_str(reg->value, reg->size, 16);
2037 command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2038 free(value);
2039
2040 free(buf);
2041
2042 return ERROR_OK;
2043 }
2044
2045 command_print(CMD_CTX, "usage: reg <#|name> [value]");
2046
2047 return ERROR_OK;
2048 }
2049
2050 COMMAND_HANDLER(handle_poll_command)
2051 {
2052 int retval = ERROR_OK;
2053 struct target *target = get_current_target(CMD_CTX);
2054
2055 if (CMD_ARGC == 0)
2056 {
2057 command_print(CMD_CTX, "background polling: %s",
2058 jtag_poll_get_enabled() ? "on" : "off");
2059 command_print(CMD_CTX, "TAP: %s (%s)",
2060 target->tap->dotted_name,
2061 target->tap->enabled ? "enabled" : "disabled");
2062 if (!target->tap->enabled)
2063 return ERROR_OK;
2064 if ((retval = target_poll(target)) != ERROR_OK)
2065 return retval;
2066 if ((retval = target_arch_state(target)) != ERROR_OK)
2067 return retval;
2068 }
2069 else if (CMD_ARGC == 1)
2070 {
2071 bool enable;
2072 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
2073 jtag_poll_set_enabled(enable);
2074 }
2075 else
2076 {
2077 return ERROR_COMMAND_SYNTAX_ERROR;
2078 }
2079
2080 return retval;
2081 }
2082
2083 COMMAND_HANDLER(handle_wait_halt_command)
2084 {
2085 if (CMD_ARGC > 1)
2086 return ERROR_COMMAND_SYNTAX_ERROR;
2087
2088 unsigned ms = 5000;
2089 if (1 == CMD_ARGC)
2090 {
2091 int retval = parse_uint(CMD_ARGV[0], &ms);
2092 if (ERROR_OK != retval)
2093 {
2094 command_print(CMD_CTX, "usage: %s [seconds]", CMD_NAME);
2095 return ERROR_COMMAND_SYNTAX_ERROR;
2096 }
2097 // convert seconds (given) to milliseconds (needed)
2098 ms *= 1000;
2099 }
2100
2101 struct target *target = get_current_target(CMD_CTX);
2102 return target_wait_state(target, TARGET_HALTED, ms);
2103 }
2104
2105 /* wait for target state to change. The trick here is to have a low
2106 * latency for short waits and not to suck up all the CPU time
2107 * on longer waits.
2108 *
2109 * After 500ms, keep_alive() is invoked
2110 */
2111 int target_wait_state(struct target *target, enum target_state state, int ms)
2112 {
2113 int retval;
2114 long long then = 0, cur;
2115 int once = 1;
2116
2117 for (;;)
2118 {
2119 if ((retval = target_poll(target)) != ERROR_OK)
2120 return retval;
2121 if (target->state == state)
2122 {
2123 break;
2124 }
2125 cur = timeval_ms();
2126 if (once)
2127 {
2128 once = 0;
2129 then = timeval_ms();
2130 LOG_DEBUG("waiting for target %s...",
2131 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2132 }
2133
2134 if (cur-then > 500)
2135 {
2136 keep_alive();
2137 }
2138
2139 if ((cur-then) > ms)
2140 {
2141 LOG_ERROR("timed out while waiting for target %s",
2142 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2143 return ERROR_FAIL;
2144 }
2145 }
2146
2147 return ERROR_OK;
2148 }
2149
2150 COMMAND_HANDLER(handle_halt_command)
2151 {
2152 LOG_DEBUG("-");
2153
2154 struct target *target = get_current_target(CMD_CTX);
2155 int retval = target_halt(target);
2156 if (ERROR_OK != retval)
2157 return retval;
2158
2159 if (CMD_ARGC == 1)
2160 {
2161 unsigned wait_local;
2162 retval = parse_uint(CMD_ARGV[0], &wait_local);
2163 if (ERROR_OK != retval)
2164 return ERROR_COMMAND_SYNTAX_ERROR;
2165 if (!wait_local)
2166 return ERROR_OK;
2167 }
2168
2169 return CALL_COMMAND_HANDLER(handle_wait_halt_command);
2170 }
2171
2172 COMMAND_HANDLER(handle_soft_reset_halt_command)
2173 {
2174 struct target *target = get_current_target(CMD_CTX);
2175
2176 LOG_USER("requesting target halt and executing a soft reset");
2177
2178 target->type->soft_reset_halt(target);
2179
2180 return ERROR_OK;
2181 }
2182
2183 COMMAND_HANDLER(handle_reset_command)
2184 {
2185 if (CMD_ARGC > 1)
2186 return ERROR_COMMAND_SYNTAX_ERROR;
2187
2188 enum target_reset_mode reset_mode = RESET_RUN;
2189 if (CMD_ARGC == 1)
2190 {
2191 const Jim_Nvp *n;
2192 n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]);
2193 if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
2194 return ERROR_COMMAND_SYNTAX_ERROR;
2195 }
2196 reset_mode = n->value;
2197 }
2198
2199 /* reset *all* targets */
2200 return target_process_reset(CMD_CTX, reset_mode);
2201 }
2202
2203
2204 COMMAND_HANDLER(handle_resume_command)
2205 {
2206 int current = 1;
2207 if (CMD_ARGC > 1)
2208 return ERROR_COMMAND_SYNTAX_ERROR;
2209
2210 struct target *target = get_current_target(CMD_CTX);
2211 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
2212
2213 /* with no CMD_ARGV, resume from current pc, addr = 0,
2214 * with one arguments, addr = CMD_ARGV[0],
2215 * handle breakpoints, not debugging */
2216 uint32_t addr = 0;
2217 if (CMD_ARGC == 1)
2218 {
2219 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2220 current = 0;
2221 }
2222
2223 return target_resume(target, current, addr, 1, 0);
2224 }
2225
2226 COMMAND_HANDLER(handle_step_command)
2227 {
2228 if (CMD_ARGC > 1)
2229 return ERROR_COMMAND_SYNTAX_ERROR;
2230
2231 LOG_DEBUG("-");
2232
2233 /* with no CMD_ARGV, step from current pc, addr = 0,
2234 * with one argument addr = CMD_ARGV[0],
2235 * handle breakpoints, debugging */
2236 uint32_t addr = 0;
2237 int current_pc = 1;
2238 if (CMD_ARGC == 1)
2239 {
2240 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2241 current_pc = 0;
2242 }
2243
2244 struct target *target = get_current_target(CMD_CTX);
2245
2246 return target->type->step(target, current_pc, addr, 1);
2247 }
2248
2249 static void handle_md_output(struct command_context *cmd_ctx,
2250 struct target *target, uint32_t address, unsigned size,
2251 unsigned count, const uint8_t *buffer)
2252 {
2253 const unsigned line_bytecnt = 32;
2254 unsigned line_modulo = line_bytecnt / size;
2255
2256 char output[line_bytecnt * 4 + 1];
2257 unsigned output_len = 0;
2258
2259 const char *value_fmt;
2260 switch (size) {
2261 case 4: value_fmt = "%8.8x "; break;
2262 case 2: value_fmt = "%4.4x "; break;
2263 case 1: value_fmt = "%2.2x "; break;
2264 default:
2265 /* "can't happen", caller checked */
2266 LOG_ERROR("invalid memory read size: %u", size);
2267 return;
2268 }
2269
2270 for (unsigned i = 0; i < count; i++)
2271 {
2272 if (i % line_modulo == 0)
2273 {
2274 output_len += snprintf(output + output_len,
2275 sizeof(output) - output_len,
2276 "0x%8.8x: ",
2277 (unsigned)(address + (i*size)));
2278 }
2279
2280 uint32_t value = 0;
2281 const uint8_t *value_ptr = buffer + i * size;
2282 switch (size) {
2283 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2284 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2285 case 1: value = *value_ptr;
2286 }
2287 output_len += snprintf(output + output_len,
2288 sizeof(output) - output_len,
2289 value_fmt, value);
2290
2291 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2292 {
2293 command_print(cmd_ctx, "%s", output);
2294 output_len = 0;
2295 }
2296 }
2297 }
2298
2299 COMMAND_HANDLER(handle_md_command)
2300 {
2301 if (CMD_ARGC < 1)
2302 return ERROR_COMMAND_SYNTAX_ERROR;
2303
2304 unsigned size = 0;
2305 switch (CMD_NAME[2]) {
2306 case 'w': size = 4; break;
2307 case 'h': size = 2; break;
2308 case 'b': size = 1; break;
2309 default: return ERROR_COMMAND_SYNTAX_ERROR;
2310 }
2311
2312 bool physical=strcmp(CMD_ARGV[0], "phys")==0;
2313 int (*fn)(struct target *target,
2314 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2315 if (physical)
2316 {
2317 CMD_ARGC--;
2318 CMD_ARGV++;
2319 fn=target_read_phys_memory;
2320 } else
2321 {
2322 fn=target_read_memory;
2323 }
2324 if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
2325 {
2326 return ERROR_COMMAND_SYNTAX_ERROR;
2327 }
2328
2329 uint32_t address;
2330 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2331
2332 unsigned count = 1;
2333 if (CMD_ARGC == 2)
2334 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count);
2335
2336 uint8_t *buffer = calloc(count, size);
2337
2338 struct target *target = get_current_target(CMD_CTX);
2339 int retval = fn(target, address, size, count, buffer);
2340 if (ERROR_OK == retval)
2341 handle_md_output(CMD_CTX, target, address, size, count, buffer);
2342
2343 free(buffer);
2344
2345 return retval;
2346 }
2347
2348 typedef int (*target_write_fn)(struct target *target,
2349 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2350
2351 static int target_write_memory_fast(struct target *target,
2352 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
2353 {
2354 return target_write_buffer(target, address, size * count, buffer);
2355 }
2356
2357 static int target_fill_mem(struct target *target,
2358 uint32_t address,
2359 target_write_fn fn,
2360 unsigned data_size,
2361 /* value */
2362 uint32_t b,
2363 /* count */
2364 unsigned c)
2365 {
2366 /* We have to write in reasonably large chunks to be able
2367 * to fill large memory areas with any sane speed */
2368 const unsigned chunk_size = 16384;
2369 uint8_t *target_buf = malloc(chunk_size * data_size);
2370 if (target_buf == NULL)
2371 {
2372 LOG_ERROR("Out of memory");
2373 return ERROR_FAIL;
2374 }
2375
2376 for (unsigned i = 0; i < chunk_size; i ++)
2377 {
2378 switch (data_size)
2379 {
2380 case 4:
2381 target_buffer_set_u32(target, target_buf + i*data_size, b);
2382 break;
2383 case 2:
2384 target_buffer_set_u16(target, target_buf + i*data_size, b);
2385 break;
2386 case 1:
2387 target_buffer_set_u8(target, target_buf + i*data_size, b);
2388 break;
2389 default:
2390 exit(-1);
2391 }
2392 }
2393
2394 int retval = ERROR_OK;
2395
2396 for (unsigned x = 0; x < c; x += chunk_size)
2397 {
2398 unsigned current;
2399 current = c - x;
2400 if (current > chunk_size)
2401 {
2402 current = chunk_size;
2403 }
2404 retval = fn(target, address + x * data_size, data_size, current, target_buf);
2405 if (retval != ERROR_OK)
2406 {
2407 break;
2408 }
2409 /* avoid GDB timeouts */
2410 keep_alive();
2411 }
2412 free(target_buf);
2413
2414 return retval;
2415 }
2416
2417
2418 COMMAND_HANDLER(handle_mw_command)
2419 {
2420 if (CMD_ARGC < 2)
2421 {
2422 return ERROR_COMMAND_SYNTAX_ERROR;
2423 }
2424 bool physical=strcmp(CMD_ARGV[0], "phys")==0;
2425 target_write_fn fn;
2426 if (physical)
2427 {
2428 CMD_ARGC--;
2429 CMD_ARGV++;
2430 fn=target_write_phys_memory;
2431 } else
2432 {
2433 fn = target_write_memory_fast;
2434 }
2435 if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
2436 return ERROR_COMMAND_SYNTAX_ERROR;
2437
2438 uint32_t address;
2439 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2440
2441 uint32_t value;
2442 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2443
2444 unsigned count = 1;
2445 if (CMD_ARGC == 3)
2446 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
2447
2448 struct target *target = get_current_target(CMD_CTX);
2449 unsigned wordsize;
2450 switch (CMD_NAME[2])
2451 {
2452 case 'w':
2453 wordsize = 4;
2454 break;
2455 case 'h':
2456 wordsize = 2;
2457 break;
2458 case 'b':
2459 wordsize = 1;
2460 break;
2461 default:
2462 return ERROR_COMMAND_SYNTAX_ERROR;
2463 }
2464
2465 return target_fill_mem(target, address, fn, wordsize, value, count);
2466 }
2467
2468 static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
2469 uint32_t *min_address, uint32_t *max_address)
2470 {
2471 if (CMD_ARGC < 1 || CMD_ARGC > 5)
2472 return ERROR_COMMAND_SYNTAX_ERROR;
2473
2474 /* a base address isn't always necessary,
2475 * default to 0x0 (i.e. don't relocate) */
2476 if (CMD_ARGC >= 2)
2477 {
2478 uint32_t addr;
2479 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2480 image->base_address = addr;
2481 image->base_address_set = 1;
2482 }
2483 else
2484 image->base_address_set = 0;
2485
2486 image->start_address_set = 0;
2487
2488 if (CMD_ARGC >= 4)
2489 {
2490 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
2491 }
2492 if (CMD_ARGC == 5)
2493 {
2494 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
2495 // use size (given) to find max (required)
2496 *max_address += *min_address;
2497 }
2498
2499 if (*min_address > *max_address)
2500 return ERROR_COMMAND_SYNTAX_ERROR;
2501
2502 return ERROR_OK;
2503 }
2504
2505 COMMAND_HANDLER(handle_load_image_command)
2506 {
2507 uint8_t *buffer;
2508 size_t buf_cnt;
2509 uint32_t image_size;
2510 uint32_t min_address = 0;
2511 uint32_t max_address = 0xffffffff;
2512 int i;
2513 struct image image;
2514
2515 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
2516 &image, &min_address, &max_address);
2517 if (ERROR_OK != retval)
2518 return retval;
2519
2520 struct target *target = get_current_target(CMD_CTX);
2521
2522 struct duration bench;
2523 duration_start(&bench);
2524
2525 if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
2526 {
2527 return ERROR_OK;
2528 }
2529
2530 image_size = 0x0;
2531 retval = ERROR_OK;
2532 for (i = 0; i < image.num_sections; i++)
2533 {
2534 buffer = malloc(image.sections[i].size);
2535 if (buffer == NULL)
2536 {
2537 command_print(CMD_CTX,
2538 "error allocating buffer for section (%d bytes)",
2539 (int)(image.sections[i].size));
2540 break;
2541 }
2542
2543 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2544 {
2545 free(buffer);
2546 break;
2547 }
2548
2549 uint32_t offset = 0;
2550 uint32_t length = buf_cnt;
2551
2552 /* DANGER!!! beware of unsigned comparision here!!! */
2553
2554 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
2555 (image.sections[i].base_address < max_address))
2556 {
2557 if (image.sections[i].base_address < min_address)
2558 {
2559 /* clip addresses below */
2560 offset += min_address-image.sections[i].base_address;
2561 length -= offset;
2562 }
2563
2564 if (image.sections[i].base_address + buf_cnt > max_address)
2565 {
2566 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2567 }
2568
2569 if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
2570 {
2571 free(buffer);
2572 break;
2573 }
2574 image_size += length;
2575 command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
2576 (unsigned int)length,
2577 image.sections[i].base_address + offset);
2578 }
2579
2580 free(buffer);
2581 }
2582
2583 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2584 {
2585 command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
2586 "in %fs (%0.3f KiB/s)", image_size,
2587 duration_elapsed(&bench), duration_kbps(&bench, image_size));
2588 }
2589
2590 image_close(&image);
2591
2592 return retval;
2593
2594 }
2595
2596 COMMAND_HANDLER(handle_dump_image_command)
2597 {
2598 struct fileio fileio;
2599 uint8_t buffer[560];
2600 int retval, retvaltemp;
2601 uint32_t address, size;
2602 struct duration bench;
2603 struct target *target = get_current_target(CMD_CTX);
2604
2605 if (CMD_ARGC != 3)
2606 return ERROR_COMMAND_SYNTAX_ERROR;
2607
2608 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
2609 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
2610
2611 retval = fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY);
2612 if (retval != ERROR_OK)
2613 return retval;
2614
2615 duration_start(&bench);
2616
2617 retval = ERROR_OK;
2618 while (size > 0)
2619 {
2620 size_t size_written;
2621 uint32_t this_run_size = (size > 560) ? 560 : size;
2622 retval = target_read_buffer(target, address, this_run_size, buffer);
2623 if (retval != ERROR_OK)
2624 {
2625 break;
2626 }
2627
2628 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2629 if (retval != ERROR_OK)
2630 {
2631 break;
2632 }
2633
2634 size -= this_run_size;
2635 address += this_run_size;
2636 }
2637
2638 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2639 {
2640 int filesize;
2641 retval = fileio_size(&fileio, &filesize);
2642 if (retval != ERROR_OK)
2643 return retval;
2644 command_print(CMD_CTX,
2645 "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
2646 duration_elapsed(&bench), duration_kbps(&bench, filesize));
2647 }
2648
2649 if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2650 return retvaltemp;
2651
2652 return retval;
2653 }
2654
2655 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
2656 {
2657 uint8_t *buffer;
2658 size_t buf_cnt;
2659 uint32_t image_size;
2660 int i;
2661 int retval;
2662 uint32_t checksum = 0;
2663 uint32_t mem_checksum = 0;
2664
2665 struct image image;
2666
2667 struct target *target = get_current_target(CMD_CTX);
2668
2669 if (CMD_ARGC < 1)
2670 {
2671 return ERROR_COMMAND_SYNTAX_ERROR;
2672 }
2673
2674 if (!target)
2675 {
2676 LOG_ERROR("no target selected");
2677 return ERROR_FAIL;
2678 }
2679
2680 struct duration bench;
2681 duration_start(&bench);
2682
2683 if (CMD_ARGC >= 2)
2684 {
2685 uint32_t addr;
2686 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2687 image.base_address = addr;
2688 image.base_address_set = 1;
2689 }
2690 else
2691 {
2692 image.base_address_set = 0;
2693 image.base_address = 0x0;
2694 }
2695
2696 image.start_address_set = 0;
2697
2698 if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK)
2699 {
2700 return retval;
2701 }
2702
2703 image_size = 0x0;
2704 int diffs = 0;
2705 retval = ERROR_OK;
2706 for (i = 0; i < image.num_sections; i++)
2707 {
2708 buffer = malloc(image.sections[i].size);
2709 if (buffer == NULL)
2710 {
2711 command_print(CMD_CTX,
2712 "error allocating buffer for section (%d bytes)",
2713 (int)(image.sections[i].size));
2714 break;
2715 }
2716 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2717 {
2718 free(buffer);
2719 break;
2720 }
2721
2722 if (verify)
2723 {
2724 /* calculate checksum of image */
2725 retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
2726 if (retval != ERROR_OK)
2727 {
2728 free(buffer);
2729 break;
2730 }
2731
2732 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2733 if (retval != ERROR_OK)
2734 {
2735 free(buffer);
2736 break;
2737 }
2738
2739 if (checksum != mem_checksum)
2740 {
2741 /* failed crc checksum, fall back to a binary compare */
2742 uint8_t *data;
2743
2744 if (diffs == 0)
2745 {
2746 LOG_ERROR("checksum mismatch - attempting binary compare");
2747 }
2748
2749 data = (uint8_t*)malloc(buf_cnt);
2750
2751 /* Can we use 32bit word accesses? */
2752 int size = 1;
2753 int count = buf_cnt;
2754 if ((count % 4) == 0)
2755 {
2756 size *= 4;
2757 count /= 4;
2758 }
2759 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2760 if (retval == ERROR_OK)
2761 {
2762 uint32_t t;
2763 for (t = 0; t < buf_cnt; t++)
2764 {
2765 if (data[t] != buffer[t])
2766 {
2767 command_print(CMD_CTX,
2768 "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
2769 diffs,
2770 (unsigned)(t + image.sections[i].base_address),
2771 data[t],
2772 buffer[t]);
2773 if (diffs++ >= 127)
2774 {
2775 command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
2776 free(data);
2777 free(buffer);
2778 goto done;
2779 }
2780 }
2781 keep_alive();
2782 }
2783 }
2784 free(data);
2785 }
2786 } else
2787 {
2788 command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
2789 image.sections[i].base_address,
2790 buf_cnt);
2791 }
2792
2793 free(buffer);
2794 image_size += buf_cnt;
2795 }
2796 if (diffs > 0)
2797 {
2798 command_print(CMD_CTX, "No more differences found.");
2799 }
2800 done:
2801 if (diffs > 0)
2802 {
2803 retval = ERROR_FAIL;
2804 }
2805 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2806 {
2807 command_print(CMD_CTX, "verified %" PRIu32 " bytes "
2808 "in %fs (%0.3f KiB/s)", image_size,
2809 duration_elapsed(&bench), duration_kbps(&bench, image_size));
2810 }
2811
2812 image_close(&image);
2813
2814 return retval;
2815 }
2816
2817 COMMAND_HANDLER(handle_verify_image_command)
2818 {
2819 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1);
2820 }
2821
2822 COMMAND_HANDLER(handle_test_image_command)
2823 {
2824 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0);
2825 }
2826
2827 static int handle_bp_command_list(struct command_context *cmd_ctx)
2828 {
2829 struct target *target = get_current_target(cmd_ctx);
2830 struct breakpoint *breakpoint = target->breakpoints;
2831 while (breakpoint)
2832 {
2833 if (breakpoint->type == BKPT_SOFT)
2834 {
2835 char* buf = buf_to_str(breakpoint->orig_instr,
2836 breakpoint->length, 16);
2837 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
2838 breakpoint->address,
2839 breakpoint->length,
2840 breakpoint->set, buf);
2841 free(buf);
2842 }
2843 else
2844 {
2845 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
2846 breakpoint->address,
2847 breakpoint->length, breakpoint->set);
2848 }
2849
2850 breakpoint = breakpoint->next;
2851 }
2852 return ERROR_OK;
2853 }
2854
2855 static int handle_bp_command_set(struct command_context *cmd_ctx,
2856 uint32_t addr, uint32_t length, int hw)
2857 {
2858 struct target *target = get_current_target(cmd_ctx);
2859 int retval = breakpoint_add(target, addr, length, hw);
2860 if (ERROR_OK == retval)
2861 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
2862 else
2863 LOG_ERROR("Failure setting breakpoint");
2864 return retval;
2865 }
2866
2867 COMMAND_HANDLER(handle_bp_command)
2868 {
2869 if (CMD_ARGC == 0)
2870 return handle_bp_command_list(CMD_CTX);
2871
2872 if (CMD_ARGC < 2 || CMD_ARGC > 3)
2873 {
2874 command_print(CMD_CTX, "usage: bp <address> <length> ['hw']");
2875 return ERROR_COMMAND_SYNTAX_ERROR;
2876 }
2877
2878 uint32_t addr;
2879 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2880 uint32_t length;
2881 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
2882
2883 int hw = BKPT_SOFT;
2884 if (CMD_ARGC == 3)
2885 {
2886 if (strcmp(CMD_ARGV[2], "hw") == 0)
2887 hw = BKPT_HARD;
2888 else
2889 return ERROR_COMMAND_SYNTAX_ERROR;
2890 }
2891
2892 return handle_bp_command_set(CMD_CTX, addr, length, hw);
2893 }
2894
2895 COMMAND_HANDLER(handle_rbp_command)
2896 {
2897 if (CMD_ARGC != 1)
2898 return ERROR_COMMAND_SYNTAX_ERROR;
2899
2900 uint32_t addr;
2901 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2902
2903 struct target *target = get_current_target(CMD_CTX);
2904 breakpoint_remove(target, addr);
2905
2906 return ERROR_OK;
2907 }
2908
2909 COMMAND_HANDLER(handle_wp_command)
2910 {
2911 struct target *target = get_current_target(CMD_CTX);
2912
2913 if (CMD_ARGC == 0)
2914 {
2915 struct watchpoint *watchpoint = target->watchpoints;
2916
2917 while (watchpoint)
2918 {
2919 command_print(CMD_CTX, "address: 0x%8.8" PRIx32
2920 ", len: 0x%8.8" PRIx32
2921 ", r/w/a: %i, value: 0x%8.8" PRIx32
2922 ", mask: 0x%8.8" PRIx32,
2923 watchpoint->address,
2924 watchpoint->length,
2925 (int)watchpoint->rw,
2926 watchpoint->value,
2927 watchpoint->mask);
2928 watchpoint = watchpoint->next;
2929 }
2930 return ERROR_OK;
2931 }
2932
2933 enum watchpoint_rw type = WPT_ACCESS;
2934 uint32_t addr = 0;
2935 uint32_t length = 0;
2936 uint32_t data_value = 0x0;
2937 uint32_t data_mask = 0xffffffff;
2938
2939 switch (CMD_ARGC)
2940 {
2941 case 5:
2942 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
2943 // fall through
2944 case 4:
2945 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
2946 // fall through
2947 case 3:
2948 switch (CMD_ARGV[2][0])
2949 {
2950 case 'r':
2951 type = WPT_READ;
2952 break;
2953 case 'w':
2954 type = WPT_WRITE;
2955 break;
2956 case 'a':
2957 type = WPT_ACCESS;
2958 break;
2959 default:
2960 LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
2961 return ERROR_COMMAND_SYNTAX_ERROR;
2962 }
2963 // fall through
2964 case 2:
2965 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
2966 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2967 break;
2968
2969 default:
2970 command_print(CMD_CTX, "usage: wp [address length "
2971 "[(r|w|a) [value [mask]]]]");
2972 return ERROR_COMMAND_SYNTAX_ERROR;
2973 }
2974
2975 int retval = watchpoint_add(target, addr, length, type,
2976 data_value, data_mask);
2977 if (ERROR_OK != retval)
2978 LOG_ERROR("Failure setting watchpoints");
2979
2980 return retval;
2981 }
2982
2983 COMMAND_HANDLER(handle_rwp_command)
2984 {
2985 if (CMD_ARGC != 1)
2986 return ERROR_COMMAND_SYNTAX_ERROR;
2987
2988 uint32_t addr;
2989 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2990
2991 struct target *target = get_current_target(CMD_CTX);
2992 watchpoint_remove(target, addr);
2993
2994 return ERROR_OK;
2995 }
2996
2997
2998 /**
2999 * Translate a virtual address to a physical address.
3000 *
3001 * The low-level target implementation must have logged a detailed error
3002 * which is forwarded to telnet/GDB session.
3003 */
3004 COMMAND_HANDLER(handle_virt2phys_command)
3005 {
3006 if (CMD_ARGC != 1)
3007 return ERROR_COMMAND_SYNTAX_ERROR;
3008
3009 uint32_t va;
3010 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
3011 uint32_t pa;
3012
3013 struct target *target = get_current_target(CMD_CTX);
3014 int retval = target->type->virt2phys(target, va, &pa);
3015 if (retval == ERROR_OK)
3016 command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
3017
3018 return retval;
3019 }
3020
3021 static void writeData(FILE *f, const void *data, size_t len)
3022 {
3023 size_t written = fwrite(data, 1, len, f);
3024 if (written != len)
3025 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3026 }
3027
3028 static void writeLong(FILE *f, int l)
3029 {
3030 int i;
3031 for (i = 0; i < 4; i++)
3032 {
3033 char c = (l >> (i*8))&0xff;
3034 writeData(f, &c, 1);
3035 }
3036
3037 }
3038
3039 static void writeString(FILE *f, char *s)
3040 {
3041 writeData(f, s, strlen(s));
3042 }
3043
3044 /* Dump a gmon.out histogram file. */
3045 static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
3046 {
3047 uint32_t i;
3048 FILE *f = fopen(filename, "w");
3049 if (f == NULL)
3050 return;
3051 writeString(f, "gmon");
3052 writeLong(f, 0x00000001); /* Version */
3053 writeLong(f, 0); /* padding */
3054 writeLong(f, 0); /* padding */
3055 writeLong(f, 0); /* padding */
3056
3057 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
3058 writeData(f, &zero, 1);
3059
3060 /* figure out bucket size */
3061 uint32_t min = samples[0];
3062 uint32_t max = samples[0];
3063 for (i = 0; i < sampleNum; i++)
3064 {
3065 if (min > samples[i])
3066 {
3067 min = samples[i];
3068 }
3069 if (max < samples[i])
3070 {
3071 max = samples[i];
3072 }
3073 }
3074
3075 int addressSpace = (max-min + 1);
3076
3077 static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
3078 uint32_t length = addressSpace;
3079 if (length > maxBuckets)
3080 {
3081 length = maxBuckets;
3082 }
3083 int *buckets = malloc(sizeof(int)*length);
3084 if (buckets == NULL)
3085 {
3086 fclose(f);
3087 return;
3088 }
3089 memset(buckets, 0, sizeof(int)*length);
3090 for (i = 0; i < sampleNum;i++)
3091 {
3092 uint32_t address = samples[i];
3093 long long a = address-min;
3094 long long b = length-1;
3095 long long c = addressSpace-1;
3096 int index_t = (a*b)/c; /* danger!!!! int32 overflows */
3097 buckets[index_t]++;
3098 }
3099
3100 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3101 writeLong(f, min); /* low_pc */
3102 writeLong(f, max); /* high_pc */
3103 writeLong(f, length); /* # of samples */
3104 writeLong(f, 64000000); /* 64MHz */
3105 writeString(f, "seconds");
3106 for (i = 0; i < (15-strlen("seconds")); i++)
3107 writeData(f, &zero, 1);
3108 writeString(f, "s");
3109
3110 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3111
3112 char *data = malloc(2*length);
3113 if (data != NULL)
3114 {
3115 for (i = 0; i < length;i++)
3116 {
3117 int val;
3118 val = buckets[i];
3119 if (val > 65535)
3120 {
3121 val = 65535;
3122 }
3123 data[i*2]=val&0xff;
3124 data[i*2 + 1]=(val >> 8)&0xff;
3125 }
3126 free(buckets);
3127 writeData(f, data, length * 2);
3128 free(data);
3129 } else
3130 {
3131 free(buckets);
3132 }
3133
3134 fclose(f);
3135 }
3136
3137 /* profiling samples the CPU PC as quickly as OpenOCD is able,
3138 * which will be used as a random sampling of PC */
3139 COMMAND_HANDLER(handle_profile_command)
3140 {
3141 struct target *target = get_current_target(CMD_CTX);
3142 struct timeval timeout, now;
3143
3144 gettimeofday(&timeout, NULL);
3145 if (CMD_ARGC != 2)
3146 {
3147 return ERROR_COMMAND_SYNTAX_ERROR;
3148 }
3149 unsigned offset;
3150 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
3151
3152 timeval_add_time(&timeout, offset, 0);
3153
3154 /**
3155 * @todo: Some cores let us sample the PC without the
3156 * annoying halt/resume step; for example, ARMv7 PCSR.
3157 * Provide a way to use that more efficient mechanism.
3158 */
3159
3160 command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
3161
3162 static const int maxSample = 10000;
3163 uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3164 if (samples == NULL)
3165 return ERROR_OK;
3166
3167 int numSamples = 0;
3168 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3169 struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
3170
3171 for (;;)
3172 {
3173 int retval;
3174 target_poll(target);
3175 if (target->state == TARGET_HALTED)
3176 {
3177 uint32_t t=*((uint32_t *)reg->value);
3178 samples[numSamples++]=t;
3179 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3180 target_poll(target);
3181 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3182 } else if (target->state == TARGET_RUNNING)
3183 {
3184 /* We want to quickly sample the PC. */
3185 if ((retval = target_halt(target)) != ERROR_OK)
3186 {
3187 free(samples);
3188 return retval;
3189 }
3190 } else
3191 {
3192 command_print(CMD_CTX, "Target not halted or running");
3193 retval = ERROR_OK;
3194 break;
3195 }
3196 if (retval != ERROR_OK)
3197 {
3198 break;
3199 }
3200
3201 gettimeofday(&now, NULL);
3202 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
3203 {
3204 command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
3205 if ((retval = target_poll(target)) != ERROR_OK)
3206 {
3207 free(samples);
3208 return retval;
3209 }
3210 if (target->state == TARGET_HALTED)
3211 {
3212 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3213 }
3214 if ((retval = target_poll(target)) != ERROR_OK)
3215 {
3216 free(samples);
3217 return retval;
3218 }
3219 writeGmon(samples, numSamples, CMD_ARGV[1]);
3220 command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
3221 break;
3222 }
3223 }
3224 free(samples);
3225
3226 return ERROR_OK;
3227 }
3228
3229 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
3230 {
3231 char *namebuf;
3232 Jim_Obj *nameObjPtr, *valObjPtr;
3233 int result;
3234
3235 namebuf = alloc_printf("%s(%d)", varname, idx);
3236 if (!namebuf)
3237 return JIM_ERR;
3238
3239 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3240 valObjPtr = Jim_NewIntObj(interp, val);
3241 if (!nameObjPtr || !valObjPtr)
3242 {
3243 free(namebuf);
3244 return JIM_ERR;
3245 }
3246
3247 Jim_IncrRefCount(nameObjPtr);
3248 Jim_IncrRefCount(valObjPtr);
3249 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3250 Jim_DecrRefCount(interp, nameObjPtr);
3251 Jim_DecrRefCount(interp, valObjPtr);
3252 free(namebuf);
3253 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3254 return result;
3255 }
3256
3257 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3258 {
3259 struct command_context *context;
3260 struct target *target;
3261
3262 context = current_command_context(interp);
3263 assert (context != NULL);
3264
3265 target = get_current_target(context);
3266 if (target == NULL)
3267 {
3268 LOG_ERROR("mem2array: no current target");
3269 return JIM_ERR;
3270 }
3271
3272 return target_mem2array(interp, target, argc-1, argv + 1);
3273 }
3274
3275 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
3276 {
3277 long l;
3278 uint32_t width;
3279 int len;
3280 uint32_t addr;
3281 uint32_t count;
3282 uint32_t v;
3283 const char *varname;
3284 int n, e, retval;
3285 uint32_t i;
3286
3287 /* argv[1] = name of array to receive the data
3288 * argv[2] = desired width
3289 * argv[3] = memory address
3290 * argv[4] = count of times to read
3291 */
3292 if (argc != 4) {
3293 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3294 return JIM_ERR;
3295 }
3296 varname = Jim_GetString(argv[0], &len);
3297 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3298
3299 e = Jim_GetLong(interp, argv[1], &l);
3300 width = l;
3301 if (e != JIM_OK) {
3302 return e;
3303 }
3304
3305 e = Jim_GetLong(interp, argv[2], &l);
3306 addr = l;
3307 if (e != JIM_OK) {
3308 return e;
3309 }
3310 e = Jim_GetLong(interp, argv[3], &l);
3311 len = l;
3312 if (e != JIM_OK) {
3313 return e;
3314 }
3315 switch (width) {
3316 case 8:
3317 width = 1;
3318 break;
3319 case 16:
3320 width = 2;
3321 break;
3322 case 32:
3323 width = 4;
3324 break;
3325 default:
3326 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3327 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3328 return JIM_ERR;
3329 }
3330 if (len == 0) {
3331 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3332 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3333 return JIM_ERR;
3334 }
3335 if ((addr + (len * width)) < addr) {
3336 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3337 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3338 return JIM_ERR;
3339 }
3340 /* absurd transfer size? */
3341 if (len > 65536) {
3342 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3343 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3344 return JIM_ERR;
3345 }
3346
3347 if ((width == 1) ||
3348 ((width == 2) && ((addr & 1) == 0)) ||
3349 ((width == 4) && ((addr & 3) == 0))) {
3350 /* all is well */
3351 } else {
3352 char buf[100];
3353 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3354 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3355 addr,
3356 width);
3357 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3358 return JIM_ERR;
3359 }
3360
3361 /* Transfer loop */
3362
3363 /* index counter */
3364 n = 0;
3365
3366 size_t buffersize = 4096;
3367 uint8_t *buffer = malloc(buffersize);
3368 if (buffer == NULL)
3369 return JIM_ERR;
3370
3371 /* assume ok */
3372 e = JIM_OK;
3373 while (len) {
3374 /* Slurp... in buffer size chunks */
3375
3376 count = len; /* in objects.. */
3377 if (count > (buffersize/width)) {
3378 count = (buffersize/width);
3379 }
3380
3381 retval = target_read_memory(target, addr, width, count, buffer);
3382 if (retval != ERROR_OK) {
3383 /* BOO !*/
3384 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3385 (unsigned int)addr,
3386 (int)width,
3387 (int)count);
3388 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3389 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3390 e = JIM_ERR;
3391 len = 0;
3392 } else {
3393 v = 0; /* shut up gcc */
3394 for (i = 0 ;i < count ;i++, n++) {
3395 switch (width) {
3396 case 4:
3397 v = target_buffer_get_u32(target, &buffer[i*width]);
3398 break;
3399 case 2:
3400 v = target_buffer_get_u16(target, &buffer[i*width]);
3401 break;
3402 case 1:
3403 v = buffer[i] & 0x0ff;
3404 break;
3405 }
3406 new_int_array_element(interp, varname, n, v);
3407 }
3408 len -= count;
3409 }
3410 }
3411
3412 free(buffer);
3413
3414 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3415
3416 return JIM_OK;
3417 }
3418
3419 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
3420 {
3421 char *namebuf;
3422 Jim_Obj *nameObjPtr, *valObjPtr;
3423 int result;
3424 long l;
3425
3426 namebuf = alloc_printf("%s(%d)", varname, idx);
3427 if (!namebuf)
3428 return JIM_ERR;
3429
3430 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3431 if (!nameObjPtr)
3432 {
3433 free(namebuf);
3434 return JIM_ERR;
3435 }
3436
3437 Jim_IncrRefCount(nameObjPtr);
3438 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3439 Jim_DecrRefCount(interp, nameObjPtr);
3440 free(namebuf);
3441 if (valObjPtr == NULL)
3442 return JIM_ERR;
3443
3444 result = Jim_GetLong(interp, valObjPtr, &l);
3445 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3446 *val = l;
3447 return result;
3448 }
3449
3450 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3451 {
3452 struct command_context *context;
3453 struct target *target;
3454
3455 context = current_command_context(interp);
3456 assert (context != NULL);
3457
3458 target = get_current_target(context);
3459 if (target == NULL) {
3460 LOG_ERROR("array2mem: no current target");
3461 return JIM_ERR;
3462 }
3463
3464 return target_array2mem(interp,target, argc-1, argv + 1);
3465 }
3466
3467 static int target_array2mem(Jim_Interp *interp, struct target *target,
3468 int argc, Jim_Obj *const *argv)
3469 {
3470 long l;
3471 uint32_t width;
3472 int len;
3473 uint32_t addr;
3474 uint32_t count;
3475 uint32_t v;
3476 const char *varname;
3477 int n, e, retval;
3478 uint32_t i;
3479
3480 /* argv[1] = name of array to get the data
3481 * argv[2] = desired width
3482 * argv[3] = memory address
3483 * argv[4] = count to write
3484 */
3485 if (argc != 4) {
3486 Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
3487 return JIM_ERR;
3488 }
3489 varname = Jim_GetString(argv[0], &len);
3490 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3491
3492 e = Jim_GetLong(interp, argv[1], &l);
3493 width = l;
3494 if (e != JIM_OK) {
3495 return e;
3496 }
3497
3498 e = Jim_GetLong(interp, argv[2], &l);
3499 addr = l;
3500 if (e != JIM_OK) {
3501 return e;
3502 }
3503 e = Jim_GetLong(interp, argv[3], &l);
3504 len = l;
3505 if (e != JIM_OK) {
3506 return e;
3507 }
3508 switch (width) {
3509 case 8:
3510 width = 1;
3511 break;
3512 case 16:
3513 width = 2;
3514 break;
3515 case 32:
3516 width = 4;
3517 break;
3518 default:
3519 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3520 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3521 return JIM_ERR;
3522 }
3523 if (len == 0) {
3524 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3525 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3526 return JIM_ERR;
3527 }
3528 if ((addr + (len * width)) < addr) {
3529 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3530 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3531 return JIM_ERR;
3532 }
3533 /* absurd transfer size? */
3534 if (len > 65536) {
3535 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3536 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3537 return JIM_ERR;
3538 }
3539
3540 if ((width == 1) ||
3541 ((width == 2) && ((addr & 1) == 0)) ||
3542 ((width == 4) && ((addr & 3) == 0))) {
3543 /* all is well */
3544 } else {
3545 char buf[100];
3546 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3547 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3548 (unsigned int)addr,
3549 (int)width);
3550 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3551 return JIM_ERR;
3552 }
3553
3554 /* Transfer loop */
3555
3556 /* index counter */
3557 n = 0;
3558 /* assume ok */
3559 e = JIM_OK;
3560
3561 size_t buffersize = 4096;
3562 uint8_t *buffer = malloc(buffersize);
3563 if (buffer == NULL)
3564 return JIM_ERR;
3565
3566 while (len) {
3567 /* Slurp... in buffer size chunks */
3568
3569 count = len; /* in objects.. */
3570 if (count > (buffersize/width)) {
3571 count = (buffersize/width);
3572 }
3573
3574 v = 0; /* shut up gcc */
3575 for (i = 0 ;i < count ;i++, n++) {
3576 get_int_array_element(interp, varname, n, &v);
3577 switch (width) {
3578 case 4:
3579 target_buffer_set_u32(target, &buffer[i*width], v);
3580 break;
3581 case 2:
3582 target_buffer_set_u16(target, &buffer[i*width], v);
3583 break;
3584 case 1:
3585 buffer[i] = v & 0x0ff;
3586 break;
3587 }
3588 }
3589 len -= count;
3590
3591 retval = target_write_memory(target, addr, width, count, buffer);
3592 if (retval != ERROR_OK) {
3593 /* BOO !*/
3594 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3595 (unsigned int)addr,
3596 (int)width,
3597 (int)count);
3598 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3599 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3600 e = JIM_ERR;
3601 len = 0;
3602 }
3603 }
3604
3605 free(buffer);
3606
3607 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3608
3609 return JIM_OK;
3610 }
3611
3612 /* FIX? should we propagate errors here rather than printing them
3613 * and continuing?
3614 */
3615 void target_handle_event(struct target *target, enum target_event e)
3616 {
3617 struct target_event_action *teap;
3618
3619 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3620 if (teap->event == e) {
3621 LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3622 target->target_number,
3623 target_name(target),
3624 target_type_name(target),
3625 e,
3626 Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3627 Jim_GetString(teap->body, NULL));
3628 if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK)
3629 {
3630 Jim_PrintErrorMessage(teap->interp);
3631 }
3632 }
3633 }
3634 }
3635
3636 /**
3637 * Returns true only if the target has a handler for the specified event.
3638 */
3639 bool target_has_event_action(struct target *target, enum target_event event)
3640 {
3641 struct target_event_action *teap;
3642
3643 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3644 if (teap->event == event)
3645 return true;
3646 }
3647 return false;
3648 }
3649
3650 enum target_cfg_param {
3651 TCFG_TYPE,
3652 TCFG_EVENT,
3653 TCFG_WORK_AREA_VIRT,
3654 TCFG_WORK_AREA_PHYS,
3655 TCFG_WORK_AREA_SIZE,
3656 TCFG_WORK_AREA_BACKUP,
3657 TCFG_ENDIAN,
3658 TCFG_VARIANT,
3659 TCFG_CHAIN_POSITION,
3660 };
3661
3662 static Jim_Nvp nvp_config_opts[] = {
3663 { .name = "-type", .value = TCFG_TYPE },
3664 { .name = "-event", .value = TCFG_EVENT },
3665 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3666 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3667 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3668 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3669 { .name = "-endian" , .value = TCFG_ENDIAN },
3670 { .name = "-variant", .value = TCFG_VARIANT },
3671 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3672
3673 { .name = NULL, .value = -1 }
3674 };
3675
3676 static int target_configure(Jim_GetOptInfo *goi, struct target *target)
3677 {
3678 Jim_Nvp *n;
3679 Jim_Obj *o;
3680 jim_wide w;
3681 char *cp;
3682 int e;
3683
3684 /* parse config or cget options ... */
3685 while (goi->argc > 0) {
3686 Jim_SetEmptyResult(goi->interp);
3687 /* Jim_GetOpt_Debug(goi); */
3688
3689 if (target->type->target_jim_configure) {
3690 /* target defines a configure function */
3691 /* target gets first dibs on parameters */
3692 e = (*(target->type->target_jim_configure))(target, goi);
3693 if (e == JIM_OK) {
3694 /* more? */
3695 continue;
3696 }
3697 if (e == JIM_ERR) {
3698 /* An error */
3699 return e;
3700 }
3701 /* otherwise we 'continue' below */
3702 }
3703 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
3704 if (e != JIM_OK) {
3705 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
3706 return e;
3707 }
3708 switch (n->value) {
3709 case TCFG_TYPE:
3710 /* not setable */
3711 if (goi->isconfigure) {
3712 Jim_SetResult_sprintf(goi->interp,
3713 "not settable: %s", n->name);
3714 return JIM_ERR;
3715 } else {
3716 no_params:
3717 if (goi->argc != 0) {
3718 Jim_WrongNumArgs(goi->interp,
3719 goi->argc, goi->argv,
3720 "NO PARAMS");
3721 return JIM_ERR;
3722 }
3723 }
3724 Jim_SetResultString(goi->interp,
3725 target_type_name(target), -1);
3726 /* loop for more */
3727 break;
3728 case TCFG_EVENT:
3729 if (goi->argc == 0) {
3730 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3731 return JIM_ERR;
3732 }
3733
3734 e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
3735 if (e != JIM_OK) {
3736 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
3737 return e;
3738 }
3739
3740 if (goi->isconfigure) {
3741 if (goi->argc != 1) {
3742 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3743 return JIM_ERR;
3744 }
3745 } else {
3746 if (goi->argc != 0) {
3747 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3748 return JIM_ERR;
3749 }
3750 }
3751
3752 {
3753 struct target_event_action *teap;
3754
3755 teap = target->event_action;
3756 /* replace existing? */
3757 while (teap) {
3758 if (teap->event == (enum target_event)n->value) {
3759 break;
3760 }
3761 teap = teap->next;
3762 }
3763
3764 if (goi->isconfigure) {
3765 bool replace = true;
3766 if (teap == NULL) {
3767 /* create new */
3768 teap = calloc(1, sizeof(*teap));
3769 replace = false;
3770 }
3771 teap->event = n->value;
3772 teap->interp = goi->interp;
3773 Jim_GetOpt_Obj(goi, &o);
3774 if (teap->body) {
3775 Jim_DecrRefCount(teap->interp, teap->body);
3776 }
3777 teap->body = Jim_DuplicateObj(goi->interp, o);
3778 /*
3779 * FIXME:
3780 * Tcl/TK - "tk events" have a nice feature.
3781 * See the "BIND" command.
3782 * We should support that here.
3783 * You can specify %X and %Y in the event code.
3784 * The idea is: %T - target name.
3785 * The idea is: %N - target number
3786 * The idea is: %E - event name.
3787 */
3788 Jim_IncrRefCount(teap->body);
3789
3790 if (!replace)
3791 {
3792 /* add to head of event list */
3793 teap->next = target->event_action;
3794 target->event_action = teap;
3795 }
3796 Jim_SetEmptyResult(goi->interp);
3797 } else {
3798 /* get */
3799 if (teap == NULL) {
3800 Jim_SetEmptyResult(goi->interp);
3801 } else {
3802 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
3803 }
3804 }
3805 }
3806 /* loop for more */
3807 break;
3808
3809 case TCFG_WORK_AREA_VIRT:
3810 if (goi->isconfigure) {
3811 target_free_all_working_areas(target);
3812 e = Jim_GetOpt_Wide(goi, &w);
3813 if (e != JIM_OK) {
3814 return e;
3815 }
3816 target->working_area_virt = w;
3817 target->working_area_virt_spec = true;
3818 } else {
3819 if (goi->argc != 0) {
3820 goto no_params;
3821 }
3822 }
3823 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
3824 /* loop for more */
3825 break;
3826
3827 case TCFG_WORK_AREA_PHYS:
3828 if (goi->isconfigure) {
3829 target_free_all_working_areas(target);
3830 e = Jim_GetOpt_Wide(goi, &w);
3831 if (e != JIM_OK) {
3832 return e;
3833 }
3834 target->working_area_phys = w;
3835 target->working_area_phys_spec = true;
3836 } else {
3837 if (goi->argc != 0) {
3838 goto no_params;
3839 }
3840 }
3841 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
3842 /* loop for more */
3843 break;
3844
3845 case TCFG_WORK_AREA_SIZE:
3846 if (goi->isconfigure) {
3847 target_free_all_working_areas(target);
3848 e = Jim_GetOpt_Wide(goi, &w);
3849 if (e != JIM_OK) {
3850 return e;
3851 }
3852 target->working_area_size = w;
3853 } else {
3854 if (goi->argc != 0) {
3855 goto no_params;
3856 }
3857 }
3858 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
3859 /* loop for more */
3860 break;
3861
3862 case TCFG_WORK_AREA_BACKUP:
3863 if (goi->isconfigure) {
3864 target_free_all_working_areas(target);
3865 e = Jim_GetOpt_Wide(goi, &w);
3866 if (e != JIM_OK) {
3867 return e;
3868 }
3869 /* make this exactly 1 or 0 */
3870 target->backup_working_area = (!!w);
3871 } else {
3872 if (goi->argc != 0) {
3873 goto no_params;
3874 }
3875 }
3876 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
3877 /* loop for more e*/
3878 break;
3879
3880 case TCFG_ENDIAN:
3881 if (goi->isconfigure) {
3882 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
3883 if (e != JIM_OK) {
3884 Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
3885 return e;
3886 }
3887 target->endianness = n->value;
3888 } else {
3889 if (goi->argc != 0) {
3890 goto no_params;
3891 }
3892 }
3893 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3894 if (n->name == NULL) {
3895 target->endianness = TARGET_LITTLE_ENDIAN;
3896 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3897 }
3898 Jim_SetResultString(goi->interp, n->name, -1);
3899 /* loop for more */
3900 break;
3901
3902 case TCFG_VARIANT:
3903 if (goi->isconfigure) {
3904 if (goi->argc < 1) {
3905 Jim_SetResult_sprintf(goi->interp,
3906 "%s ?STRING?",
3907 n->name);
3908 return JIM_ERR;
3909 }
3910 if (target->variant) {
3911 free((void *)(target->variant));
3912 }
3913 e = Jim_GetOpt_String(goi, &cp, NULL);
3914 target->variant = strdup(cp);
3915 } else {
3916 if (goi->argc != 0) {
3917 goto no_params;
3918 }
3919 }
3920 Jim_SetResultString(goi->interp, target->variant,-1);
3921 /* loop for more */
3922 break;
3923 case TCFG_CHAIN_POSITION:
3924 if (goi->isconfigure) {
3925 Jim_Obj *o_t;
3926 struct jtag_tap *tap;
3927 target_free_all_working_areas(target);
3928 e = Jim_GetOpt_Obj(goi, &o_t);
3929 if (e != JIM_OK) {
3930 return e;
3931 }
3932 tap = jtag_tap_by_jim_obj(goi->interp, o_t);
3933 if (tap == NULL) {
3934 return JIM_ERR;
3935 }
3936 /* make this exactly 1 or 0 */
3937 target->tap = tap;
3938 } else {
3939 if (goi->argc != 0) {
3940 goto no_params;
3941 }
3942 }
3943 Jim_SetResultString(goi->interp, target->tap->dotted_name, -1);
3944 /* loop for more e*/
3945 break;
3946 }
3947 } /* while (goi->argc) */
3948
3949
3950 /* done - we return */
3951 return JIM_OK;
3952 }
3953
3954 static int
3955 jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3956 {
3957 Jim_GetOptInfo goi;
3958
3959 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
3960 goi.isconfigure = !strcmp(Jim_GetString(argv[0], NULL), "configure");
3961 int need_args = 1 + goi.isconfigure;
3962 if (goi.argc < need_args)
3963 {
3964 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
3965 goi.isconfigure
3966 ? "missing: -option VALUE ..."
3967 : "missing: -option ...");
3968 return JIM_ERR;
3969 }
3970 struct target *target = Jim_CmdPrivData(goi.interp);
3971 return target_configure(&goi, target);
3972 }
3973
3974 static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3975 {
3976 const char *cmd_name = Jim_GetString(argv[0], NULL);
3977
3978 Jim_GetOptInfo goi;
3979 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
3980
3981 if (goi.argc < 2 || goi.argc > 4)
3982 {
3983 Jim_SetResult_sprintf(goi.interp,
3984 "usage: %s [phys] <address> <data> [<count>]", cmd_name);
3985 return JIM_ERR;
3986 }
3987
3988 target_write_fn fn;
3989 fn = target_write_memory_fast;
3990
3991 int e;
3992 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
3993 {
3994 /* consume it */
3995 struct Jim_Obj *obj;
3996 e = Jim_GetOpt_Obj(&goi, &obj);
3997 if (e != JIM_OK)
3998 return e;
3999
4000 fn = target_write_phys_memory;
4001 }
4002
4003 jim_wide a;
4004 e = Jim_GetOpt_Wide(&goi, &a);
4005 if (e != JIM_OK)
4006 return e;
4007
4008 jim_wide b;
4009 e = Jim_GetOpt_Wide(&goi, &b);
4010 if (e != JIM_OK)
4011 return e;
4012
4013 jim_wide c = 1;
4014 if (goi.argc == 1)
4015 {
4016 e = Jim_GetOpt_Wide(&goi, &c);
4017 if (e != JIM_OK)
4018 return e;
4019 }
4020
4021 /* all args must be consumed */
4022 if (goi.argc != 0)
4023 {
4024 return JIM_ERR;
4025 }
4026
4027 struct target *target = Jim_CmdPrivData(goi.interp);
4028 unsigned data_size;
4029 if (strcasecmp(cmd_name, "mww") == 0) {
4030 data_size = 4;
4031 }
4032 else if (strcasecmp(cmd_name, "mwh") == 0) {
4033 data_size = 2;
4034 }
4035 else if (strcasecmp(cmd_name, "mwb") == 0) {
4036 data_size = 1;
4037 } else {
4038 LOG_ERROR("command '%s' unknown: ", cmd_name);
4039 return JIM_ERR;
4040 }
4041
4042 return (target_fill_mem(target, a, fn, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
4043 }
4044
4045 static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4046 {
4047 const char *cmd_name = Jim_GetString(argv[0], NULL);
4048
4049 Jim_GetOptInfo goi;
4050 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4051
4052 if ((goi.argc < 1) || (goi.argc > 3))
4053 {
4054 Jim_SetResult_sprintf(goi.interp,
4055 "usage: %s [phys] <address> [<count>]", cmd_name);
4056 return JIM_ERR;
4057 }
4058
4059 int (*fn)(struct target *target,
4060 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
4061 fn=target_read_memory;
4062
4063 int e;
4064 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
4065 {
4066 /* consume it */
4067 struct Jim_Obj *obj;
4068 e = Jim_GetOpt_Obj(&goi, &obj);
4069 if (e != JIM_OK)
4070 return e;
4071
4072 fn=target_read_phys_memory;
4073 }
4074
4075 jim_wide a;
4076 e = Jim_GetOpt_Wide(&goi, &a);
4077 if (e != JIM_OK) {
4078 return JIM_ERR;
4079 }
4080 jim_wide c;
4081 if (goi.argc == 1) {
4082 e = Jim_GetOpt_Wide(&goi, &c);
4083 if (e != JIM_OK) {
4084 return JIM_ERR;
4085 }
4086 } else {
4087 c = 1;
4088 }
4089
4090 /* all args must be consumed */
4091 if (goi.argc != 0)
4092 {
4093 return JIM_ERR;
4094 }
4095
4096 jim_wide b = 1; /* shut up gcc */
4097 if (strcasecmp(cmd_name, "mdw") == 0)
4098 b = 4;
4099 else if (strcasecmp(cmd_name, "mdh") == 0)
4100 b = 2;
4101 else if (strcasecmp(cmd_name, "mdb") == 0)
4102 b = 1;
4103 else {
4104 LOG_ERROR("command '%s' unknown: ", cmd_name);
4105 return JIM_ERR;
4106 }
4107
4108 /* convert count to "bytes" */
4109 c = c * b;
4110
4111 struct target *target = Jim_CmdPrivData(goi.interp);
4112 uint8_t target_buf[32];
4113 jim_wide x, y, z;
4114 while (c > 0) {
4115 y = c;
4116 if (y > 16) {
4117 y = 16;
4118 }
4119 e = fn(target, a, b, y / b, target_buf);
4120 if (e != ERROR_OK) {
4121 Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
4122 return JIM_ERR;
4123 }
4124
4125 Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
4126 switch (b) {
4127 case 4:
4128 for (x = 0; x < 16 && x < y; x += 4)
4129 {
4130 z = target_buffer_get_u32(target, &(target_buf[ x ]));
4131 Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
4132 }
4133 for (; (x < 16) ; x += 4) {
4134 Jim_fprintf(interp, interp->cookie_stdout, " ");
4135 }
4136 break;
4137 case 2:
4138 for (x = 0; x < 16 && x < y; x += 2)
4139 {
4140 z = target_buffer_get_u16(target, &(target_buf[ x ]));
4141 Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
4142 }
4143 for (; (x < 16) ; x += 2) {
4144 Jim_fprintf(interp, interp->cookie_stdout, " ");
4145 }
4146 break;
4147 case 1:
4148 default:
4149 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4150 z = target_buffer_get_u8(target, &(target_buf[ x ]));
4151 Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
4152 }
4153 for (; (x < 16) ; x += 1) {
4154 Jim_fprintf(interp, interp->cookie_stdout, " ");
4155 }
4156 break;
4157 }
4158 /* ascii-ify the bytes */
4159 for (x = 0 ; x < y ; x++) {
4160 if ((target_buf[x] >= 0x20) &&
4161 (target_buf[x] <= 0x7e)) {
4162 /* good */
4163 } else {
4164 /* smack it */
4165 target_buf[x] = '.';
4166 }
4167 }
4168 /* space pad */
4169 while (x < 16) {
4170 target_buf[x] = ' ';
4171 x++;
4172 }
4173 /* terminate */
4174 target_buf[16] = 0;
4175 /* print - with a newline */
4176 Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
4177 /* NEXT... */
4178 c -= 16;
4179 a += 16;
4180 }
4181 return JIM_OK;
4182 }
4183
4184 static int jim_target_mem2array(Jim_Interp *interp,
4185 int argc, Jim_Obj *const *argv)
4186 {
4187 struct target *target = Jim_CmdPrivData(interp);
4188 return target_mem2array(interp, target, argc - 1, argv + 1);
4189 }
4190
4191 static int jim_target_array2mem(Jim_Interp *interp,
4192 int argc, Jim_Obj *const *argv)
4193 {
4194 struct target *target = Jim_CmdPrivData(interp);
4195 return target_array2mem(interp, target, argc - 1, argv + 1);
4196 }
4197
4198 static int jim_target_tap_disabled(Jim_Interp *interp)
4199 {
4200 Jim_SetResult_sprintf(interp, "[TAP is disabled]");
4201 return JIM_ERR;
4202 }
4203
4204 static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4205 {
4206 if (argc != 1)
4207 {
4208 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4209 return JIM_ERR;
4210 }
4211 struct target *target = Jim_CmdPrivData(interp);
4212 if (!target->tap->enabled)
4213 return jim_target_tap_disabled(interp);
4214
4215 int e = target->type->examine(target);
4216 if (e != ERROR_OK)
4217 {
4218 Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
4219 return JIM_ERR;
4220 }
4221 return JIM_OK;
4222 }
4223
4224 static int jim_target_halt_gdb(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4225 {
4226 if (argc != 1)
4227 {
4228 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4229 return JIM_ERR;
4230 }
4231 struct target *target = Jim_CmdPrivData(interp);
4232
4233 if (target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT) != ERROR_OK)
4234 return JIM_ERR;
4235
4236 return JIM_OK;
4237 }
4238
4239 static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4240 {
4241 if (argc != 1)
4242 {
4243 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4244 return JIM_ERR;
4245 }
4246 struct target *target = Jim_CmdPrivData(interp);
4247 if (!target->tap->enabled)
4248 return jim_target_tap_disabled(interp);
4249
4250 int e;
4251 if (!(target_was_examined(target))) {
4252 e = ERROR_TARGET_NOT_EXAMINED;
4253 } else {
4254 e = target->type->poll(target);
4255 }
4256 if (e != ERROR_OK)
4257 {
4258 Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
4259 return JIM_ERR;
4260 }
4261 return JIM_OK;
4262 }
4263
4264 static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4265 {
4266 Jim_GetOptInfo goi;
4267 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4268
4269 if (goi.argc != 2)
4270 {
4271 Jim_WrongNumArgs(interp, 0, argv,
4272 "([tT]|[fF]|assert|deassert) BOOL");
4273 return JIM_ERR;
4274 }
4275
4276 Jim_Nvp *n;
4277 int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4278 if (e != JIM_OK)
4279 {
4280 Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4281 return e;
4282 }
4283 /* the halt or not param */
4284 jim_wide a;
4285 e = Jim_GetOpt_Wide(&goi, &a);
4286 if (e != JIM_OK)
4287 return e;
4288
4289 struct target *target = Jim_CmdPrivData(goi.interp);
4290 if (!target->tap->enabled)
4291 return jim_target_tap_disabled(interp);
4292 if (!(target_was_examined(target)))
4293 {
4294 LOG_ERROR("Target not examined yet");
4295 return ERROR_TARGET_NOT_EXAMINED;
4296 }
4297 if (!target->type->assert_reset || !target->type->deassert_reset)
4298 {
4299 Jim_SetResult_sprintf(interp,
4300 "No target-specific reset for %s",
4301 target_name(target));
4302 return JIM_ERR;
4303 }
4304 /* determine if we should halt or not. */
4305 target->reset_halt = !!a;
4306 /* When this happens - all workareas are invalid. */
4307 target_free_all_working_areas_restore(target, 0);
4308
4309 /* do the assert */
4310 if (n->value == NVP_ASSERT) {
4311 e = target->type->assert_reset(target);
4312 } else {
4313 e = target->type->deassert_reset(target);
4314 }
4315 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4316 }
4317
4318 static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4319 {
4320 if (argc != 1) {
4321 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4322 return JIM_ERR;
4323 }
4324 struct target *target = Jim_CmdPrivData(interp);
4325 if (!target->tap->enabled)
4326 return jim_target_tap_disabled(interp);
4327 int e = target->type->halt(target);
4328 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4329 }
4330
4331 static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4332 {
4333 Jim_GetOptInfo goi;
4334 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4335
4336 /* params: <name> statename timeoutmsecs */
4337 if (goi.argc != 2)
4338 {
4339 const char *cmd_name = Jim_GetString(argv[0], NULL);
4340 Jim_SetResult_sprintf(goi.interp,
4341 "%s <state_name> <timeout_in_msec>", cmd_name);
4342 return JIM_ERR;
4343 }
4344
4345 Jim_Nvp *n;
4346 int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4347 if (e != JIM_OK) {
4348 Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
4349 return e;
4350 }
4351 jim_wide a;
4352 e = Jim_GetOpt_Wide(&goi, &a);
4353 if (e != JIM_OK) {
4354 return e;
4355 }
4356 struct target *target = Jim_CmdPrivData(interp);
4357 if (!target->tap->enabled)
4358 return jim_target_tap_disabled(interp);
4359
4360 e = target_wait_state(target, n->value, a);
4361 if (e != ERROR_OK)
4362 {
4363 Jim_SetResult_sprintf(goi.interp,
4364 "target: %s wait %s fails (%d) %s",
4365 target_name(target), n->name,
4366 e, target_strerror_safe(e));
4367 return JIM_ERR;
4368 }
4369 return JIM_OK;
4370 }
4371 /* List for human, Events defined for this target.
4372 * scripts/programs should use 'name cget -event NAME'
4373 */
4374 static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4375 {
4376 struct command_context *cmd_ctx = current_command_context(interp);
4377 assert (cmd_ctx != NULL);
4378
4379 struct target *target = Jim_CmdPrivData(interp);
4380 struct target_event_action *teap = target->event_action;
4381 command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4382 target->target_number,
4383 target_name(target));
4384 command_print(cmd_ctx, "%-25s | Body", "Event");
4385 command_print(cmd_ctx, "------------------------- | "
4386 "----------------------------------------");
4387 while (teap)
4388 {
4389 Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
4390 command_print(cmd_ctx, "%-25s | %s",
4391 opt->name, Jim_GetString(teap->body, NULL));
4392 teap = teap->next;
4393 }
4394 command_print(cmd_ctx, "***END***");
4395 return JIM_OK;
4396 }
4397 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4398 {
4399 if (argc != 1)
4400 {
4401 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4402 return JIM_ERR;
4403 }
4404 struct target *target = Jim_CmdPrivData(interp);
4405 Jim_SetResultString(interp, target_state_name(target), -1);
4406 return JIM_OK;
4407 }
4408 static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4409 {
4410 Jim_GetOptInfo goi;
4411 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4412 if (goi.argc != 1)
4413 {
4414 const char *cmd_name = Jim_GetString(argv[0], NULL);
4415 Jim_SetResult_sprintf(goi.interp, "%s <eventname>", cmd_name);
4416 return JIM_ERR;
4417 }
4418 Jim_Nvp *n;
4419 int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4420 if (e != JIM_OK)
4421 {
4422 Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4423 return e;
4424 }
4425 struct target *target = Jim_CmdPrivData(interp);
4426 target_handle_event(target, n->value);
4427 return JIM_OK;
4428 }
4429
4430 static const struct command_registration target_instance_command_handlers[] = {
4431 {
4432 .name = "configure",
4433 .mode = COMMAND_CONFIG,
4434 .jim_handler = jim_target_configure,
4435 .help = "configure a new target for use",
4436 .usage = "[target_attribute ...]",
4437 },
4438 {
4439 .name = "cget",
4440 .mode = COMMAND_ANY,
4441 .jim_handler = jim_target_configure,
4442 .help = "returns the specified target attribute",
4443 .usage = "target_attribute",
4444 },
4445 {
4446 .name = "mww",
4447 .mode = COMMAND_EXEC,
4448 .jim_handler = jim_target_mw,
4449 .help = "Write 32-bit word(s) to target memory",
4450 .usage = "address data [count]",
4451 },
4452 {
4453 .name = "mwh",
4454 .mode = COMMAND_EXEC,
4455 .jim_handler = jim_target_mw,
4456 .help = "Write 16-bit half-word(s) to target memory",
4457 .usage = "address data [count]",
4458 },
4459 {
4460 .name = "mwb",
4461 .mode = COMMAND_EXEC,
4462 .jim_handler = jim_target_mw,
4463 .help = "Write byte(s) to target memory",
4464 .usage = "address data [count]",
4465 },
4466 {
4467 .name = "mdw",
4468 .mode = COMMAND_EXEC,
4469 .jim_handler = jim_target_md,
4470 .help = "Display target memory as 32-bit words",
4471 .usage = "address [count]",
4472 },
4473 {
4474 .name = "mdh",
4475 .mode = COMMAND_EXEC,
4476 .jim_handler = jim_target_md,
4477 .help = "Display target memory as 16-bit half-words",
4478 .usage = "address [count]",
4479 },
4480 {
4481 .name = "mdb",
4482 .mode = COMMAND_EXEC,
4483 .jim_handler = jim_target_md,
4484 .help = "Display target memory as 8-bit bytes",
4485 .usage = "address [count]",
4486 },
4487 {
4488 .name = "array2mem",
4489 .mode = COMMAND_EXEC,
4490 .jim_handler = jim_target_array2mem,
4491 .help = "Writes Tcl array of 8/16/32 bit numbers "
4492 "to target memory",
4493 .usage = "arrayname bitwidth address count",
4494 },
4495 {
4496 .name = "mem2array",
4497 .mode = COMMAND_EXEC,
4498 .jim_handler = jim_target_mem2array,
4499 .help = "Loads Tcl array of 8/16/32 bit numbers "
4500 "from target memory",
4501 .usage = "arrayname bitwidth address count",
4502 },
4503 {
4504 .name = "eventlist",
4505 .mode = COMMAND_EXEC,
4506 .jim_handler = jim_target_event_list,
4507 .help = "displays a table of events defined for this target",
4508 },
4509 {
4510 .name = "curstate",
4511 .mode = COMMAND_EXEC,
4512 .jim_handler = jim_target_current_state,
4513 .help = "displays the current state of this target",
4514 },
4515 {
4516 .name = "arp_examine",
4517 .mode = COMMAND_EXEC,
4518 .jim_handler = jim_target_examine,
4519 .help = "used internally for reset processing",
4520 },
4521 {
4522 .name = "arp_halt_gdb",
4523 .mode = COMMAND_EXEC,
4524 .jim_handler = jim_target_halt_gdb,
4525 .help = "used internally for reset processing to halt GDB",
4526 },
4527 {
4528 .name = "arp_poll",
4529 .mode = COMMAND_EXEC,
4530 .jim_handler = jim_target_poll,
4531 .help = "used internally for reset processing",
4532 },
4533 {
4534 .name = "arp_reset",
4535 .mode = COMMAND_EXEC,
4536 .jim_handler = jim_target_reset,
4537 .help = "used internally for reset processing",
4538 },
4539 {
4540 .name = "arp_halt",
4541 .mode = COMMAND_EXEC,
4542 .jim_handler = jim_target_halt,
4543 .help = "used internally for reset processing",
4544 },
4545 {
4546 .name = "arp_waitstate",
4547 .mode = COMMAND_EXEC,
4548 .jim_handler = jim_target_wait_state,
4549 .help = "used internally for reset processing",
4550 },
4551 {
4552 .name = "invoke-event",
4553 .mode = COMMAND_EXEC,
4554 .jim_handler = jim_target_invoke_event,
4555 .help = "invoke handler for specified event",
4556 .usage = "event_name",
4557 },
4558 COMMAND_REGISTRATION_DONE
4559 };
4560
4561 static int target_create(Jim_GetOptInfo *goi)
4562 {
4563 Jim_Obj *new_cmd;
4564 Jim_Cmd *cmd;
4565 const char *cp;
4566 char *cp2;
4567 int e;
4568 int x;
4569 struct target *target;
4570 struct command_context *cmd_ctx;
4571
4572 cmd_ctx = current_command_context(goi->interp);
4573 assert (cmd_ctx != NULL);
4574
4575 if (goi->argc < 3) {
4576 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4577 return JIM_ERR;
4578 }
4579
4580 /* COMMAND */
4581 Jim_GetOpt_Obj(goi, &new_cmd);
4582 /* does this command exist? */
4583 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4584 if (cmd) {
4585 cp = Jim_GetString(new_cmd, NULL);
4586 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
4587 return JIM_ERR;
4588 }
4589
4590 /* TYPE */
4591 e = Jim_GetOpt_String(goi, &cp2, NULL);
4592 cp = cp2;
4593 /* now does target type exist */
4594 for (x = 0 ; target_types[x] ; x++) {
4595 if (0 == strcmp(cp, target_types[x]->name)) {
4596 /* found */
4597 break;
4598 }
4599 }
4600 if (target_types[x] == NULL) {
4601 Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
4602 for (x = 0 ; target_types[x] ; x++) {
4603 if (target_types[x + 1]) {
4604 Jim_AppendStrings(goi->interp,
4605 Jim_GetResult(goi->interp),
4606 target_types[x]->name,
4607 ", ", NULL);
4608 } else {
4609 Jim_AppendStrings(goi->interp,
4610 Jim_GetResult(goi->interp),
4611 " or ",
4612 target_types[x]->name,NULL);
4613 }
4614 }
4615 return JIM_ERR;
4616 }
4617
4618 /* Create it */
4619 target = calloc(1,sizeof(struct target));
4620 /* set target number */
4621 target->target_number = new_target_number();
4622
4623 /* allocate memory for each unique target type */
4624 target->type = (struct target_type*)calloc(1,sizeof(struct target_type));
4625
4626 memcpy(target->type, target_types[x], sizeof(struct target_type));
4627
4628 /* will be set by "-endian" */
4629 target->endianness = TARGET_ENDIAN_UNKNOWN;
4630
4631 target->working_area = 0x0;
4632 target->working_area_size = 0x0;
4633 target->working_areas = NULL;
4634 target->backup_working_area = 0;
4635
4636 target->state = TARGET_UNKNOWN;
4637 target->debug_reason = DBG_REASON_UNDEFINED;
4638 target->reg_cache = NULL;
4639 target->breakpoints = NULL;
4640 target->watchpoints = NULL;
4641 target->next = NULL;
4642 target->arch_info = NULL;
4643
4644 target->display = 1;
4645
4646 target->halt_issued = false;
4647
4648 /* initialize trace information */
4649 target->trace_info = malloc(sizeof(struct trace));
4650 target->trace_info->num_trace_points = 0;
4651 target->trace_info->trace_points_size = 0;
4652 target->trace_info->trace_points = NULL;
4653 target->trace_info->trace_history_size = 0;
4654 target->trace_info->trace_history = NULL;
4655 target->trace_info->trace_history_pos = 0;
4656 target->trace_info->trace_history_overflowed = 0;
4657
4658 target->dbgmsg = NULL;
4659 target->dbg_msg_enabled = 0;
4660
4661 target->endianness = TARGET_ENDIAN_UNKNOWN;
4662
4663 /* Do the rest as "configure" options */
4664 goi->isconfigure = 1;
4665 e = target_configure(goi, target);
4666
4667 if (target->tap == NULL)
4668 {
4669 Jim_SetResultString(goi->interp, "-chain-position required when creating target", -1);
4670 e = JIM_ERR;
4671 }
4672
4673 if (e != JIM_OK) {
4674 free(target->type);
4675 free(target);
4676 return e;
4677 }
4678
4679 if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
4680 /* default endian to little if not specified */
4681 target->endianness = TARGET_LITTLE_ENDIAN;
4682 }
4683
4684 /* incase variant is not set */
4685 if (!target->variant)
4686 target->variant = strdup("");
4687
4688 cp = Jim_GetString(new_cmd, NULL);
4689 target->cmd_name = strdup(cp);
4690
4691 /* create the target specific commands */
4692 if (target->type->commands) {
4693 e = register_commands(cmd_ctx, NULL, target->type->commands);
4694 if (ERROR_OK != e)
4695 LOG_ERROR("unable to register '%s' commands", cp);
4696 }
4697 if (target->type->target_create) {
4698 (*(target->type->target_create))(target, goi->interp);
4699 }
4700
4701 /* append to end of list */
4702 {
4703 struct target **tpp;
4704 tpp = &(all_targets);
4705 while (*tpp) {
4706 tpp = &((*tpp)->next);
4707 }
4708 *tpp = target;
4709 }
4710
4711 /* now - create the new target name command */
4712 const const struct command_registration target_subcommands[] = {
4713 {
4714 .chain = target_instance_command_handlers,
4715 },
4716 {
4717 .chain = target->type->commands,
4718 },
4719 COMMAND_REGISTRATION_DONE
4720 };
4721 const const struct command_registration target_commands[] = {
4722 {
4723 .name = cp,
4724 .mode = COMMAND_ANY,
4725 .help = "target command group",
4726 .chain = target_subcommands,
4727 },
4728 COMMAND_REGISTRATION_DONE
4729 };
4730 e = register_commands(cmd_ctx, NULL, target_commands);
4731 if (ERROR_OK != e)
4732 return JIM_ERR;
4733
4734 struct command *c = command_find_in_context(cmd_ctx, cp);
4735 assert(c);
4736 command_set_handler_data(c, target);
4737
4738 return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
4739 }
4740
4741 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4742 {
4743 if (argc != 1)
4744 {
4745 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
4746 return JIM_ERR;
4747 }
4748 struct command_context *cmd_ctx = current_command_context(interp);
4749 assert (cmd_ctx != NULL);
4750
4751 Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
4752 return JIM_OK;
4753 }
4754
4755 static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4756 {
4757 if (argc != 1)
4758 {
4759 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
4760 return JIM_ERR;
4761 }
4762 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
4763 for (unsigned x = 0; NULL != target_types[x]; x++)
4764 {
4765 Jim_ListAppendElement(interp, Jim_GetResult(interp),
4766 Jim_NewStringObj(interp, target_types[x]->name, -1));
4767 }
4768 return JIM_OK;
4769 }
4770
4771 static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4772 {
4773 if (argc != 1)
4774 {
4775 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
4776 return JIM_ERR;
4777 }
4778 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
4779 struct target *target = all_targets;
4780 while (target)
4781 {
4782 Jim_ListAppendElement(interp, Jim_GetResult(interp),
4783 Jim_NewStringObj(interp, target_name(target), -1));
4784 target = target->next;
4785 }
4786 return JIM_OK;
4787 }
4788
4789 static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4790 {
4791 Jim_GetOptInfo goi;
4792 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4793 if (goi.argc < 3)
4794 {
4795 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
4796 "<name> <target_type> [<target_options> ...]");
4797 return JIM_ERR;
4798 }
4799 return target_create(&goi);
4800 }
4801
4802 static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4803 {
4804 Jim_GetOptInfo goi;
4805 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4806
4807 /* It's OK to remove this mechanism sometime after August 2010 or so */
4808 LOG_WARNING("don't use numbers as target identifiers; use names");
4809 if (goi.argc != 1)
4810 {
4811 Jim_SetResult_sprintf(goi.interp, "usage: target number <number>");
4812 return JIM_ERR;
4813 }
4814 jim_wide w;
4815 int e = Jim_GetOpt_Wide(&goi, &w);
4816 if (e != JIM_OK)
4817 return JIM_ERR;
4818
4819 struct target *target;
4820 for (target = all_targets; NULL != target; target = target->next)
4821 {
4822 if (target->target_number != w)
4823 continue;
4824
4825 Jim_SetResultString(goi.interp, target_name(target), -1);
4826 return JIM_OK;
4827 }
4828 Jim_SetResult_sprintf(goi.interp,
4829 "Target: number %d does not exist", (int)(w));
4830 return JIM_ERR;
4831 }
4832
4833 static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4834 {
4835 if (argc != 1)
4836 {
4837 Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
4838 return JIM_ERR;
4839 }
4840 unsigned count = 0;
4841 struct target *target = all_targets;
4842 while (NULL != target)
4843 {
4844 target = target->next;
4845 count++;
4846 }
4847 Jim_SetResult(interp, Jim_NewIntObj(interp, count));
4848 return JIM_OK;
4849 }
4850
4851 static const struct command_registration target_subcommand_handlers[] = {
4852 {
4853 .name = "init",
4854 .mode = COMMAND_CONFIG,
4855 .handler = handle_target_init_command,
4856 .help = "initialize targets",
4857 },
4858 {
4859 .name = "create",
4860 /* REVISIT this should be COMMAND_CONFIG ... */
4861 .mode = COMMAND_ANY,
4862 .jim_handler = jim_target_create,
4863 .usage = "name type '-chain-position' name [options ...]",
4864 .help = "Creates and selects a new target",
4865 },
4866 {
4867 .name = "current",
4868 .mode = COMMAND_ANY,
4869 .jim_handler = jim_target_current,
4870 .help = "Returns the currently selected target",
4871 },
4872 {
4873 .name = "types",
4874 .mode = COMMAND_ANY,
4875 .jim_handler = jim_target_types,
4876 .help = "Returns the available target types as "
4877 "a list of strings",
4878 },
4879 {
4880 .name = "names",
4881 .mode = COMMAND_ANY,
4882 .jim_handler = jim_target_names,
4883 .help = "Returns the names of all targets as a list of strings",
4884 },
4885 {
4886 .name = "number",
4887 .mode = COMMAND_ANY,
4888 .jim_handler = jim_target_number,
4889 .usage = "number",
4890 .help = "Returns the name of the numbered target "
4891 "(DEPRECATED)",
4892 },
4893 {
4894 .name = "count",
4895 .mode = COMMAND_ANY,
4896 .jim_handler = jim_target_count,
4897 .help = "Returns the number of targets as an integer "
4898 "(DEPRECATED)",
4899 },
4900 COMMAND_REGISTRATION_DONE
4901 };
4902
4903 struct FastLoad
4904 {
4905 uint32_t address;
4906 uint8_t *data;
4907 int length;
4908
4909 };
4910
4911 static int fastload_num;
4912 static struct FastLoad *fastload;
4913
4914 static void free_fastload(void)
4915 {
4916 if (fastload != NULL)
4917 {
4918 int i;
4919 for (i = 0; i < fastload_num; i++)
4920 {
4921 if (fastload[i].data)
4922 free(fastload[i].data);
4923 }
4924 free(fastload);
4925 fastload = NULL;
4926 }
4927 }
4928
4929
4930
4931
4932 COMMAND_HANDLER(handle_fast_load_image_command)
4933 {
4934 uint8_t *buffer;
4935 size_t buf_cnt;
4936 uint32_t image_size;
4937 uint32_t min_address = 0;
4938 uint32_t max_address = 0xffffffff;
4939 int i;
4940
4941 struct image image;
4942
4943 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
4944 &image, &min_address, &max_address);
4945 if (ERROR_OK != retval)
4946 return retval;
4947
4948 struct duration bench;
4949 duration_start(&bench);
4950
4951 if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
4952 {
4953 return ERROR_OK;
4954 }
4955
4956 image_size = 0x0;
4957 retval = ERROR_OK;
4958 fastload_num = image.num_sections;
4959 fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4960 if (fastload == NULL)
4961 {
4962 image_close(&image);
4963 return ERROR_FAIL;
4964 }
4965 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4966 for (i = 0; i < image.num_sections; i++)
4967 {
4968 buffer = malloc(image.sections[i].size);
4969 if (buffer == NULL)
4970 {
4971 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
4972 (int)(image.sections[i].size));
4973 break;
4974 }
4975
4976 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4977 {
4978 free(buffer);
4979 break;
4980 }
4981
4982 uint32_t offset = 0;
4983 uint32_t length = buf_cnt;
4984
4985
4986 /* DANGER!!! beware of unsigned comparision here!!! */
4987
4988 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
4989 (image.sections[i].base_address < max_address))
4990 {
4991 if (image.sections[i].base_address < min_address)
4992 {
4993 /* clip addresses below */
4994 offset += min_address-image.sections[i].base_address;
4995 length -= offset;
4996 }
4997
4998 if (image.sections[i].base_address + buf_cnt > max_address)
4999 {
5000 length -= (image.sections[i].base_address + buf_cnt)-max_address;
5001 }
5002
5003 fastload[i].address = image.sections[i].base_address + offset;
5004 fastload[i].data = malloc(length);
5005 if (fastload[i].data == NULL)
5006 {
5007 free(buffer);
5008 break;
5009 }
5010 memcpy(fastload[i].data, buffer + offset, length);
5011 fastload[i].length = length;
5012
5013 image_size += length;
5014 command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
5015 (unsigned int)length,
5016 ((unsigned int)(image.sections[i].base_address + offset)));
5017 }
5018
5019 free(buffer);
5020 }
5021
5022 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
5023 {
5024 command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
5025 "in %fs (%0.3f KiB/s)", image_size,
5026 duration_elapsed(&bench), duration_kbps(&bench, image_size));
5027
5028 command_print(CMD_CTX,
5029 "WARNING: image has not been loaded to target!"
5030 "You can issue a 'fast_load' to finish loading.");
5031 }
5032
5033 image_close(&image);
5034
5035 if (retval != ERROR_OK)
5036 {
5037 free_fastload();
5038 }
5039
5040 return retval;
5041 }
5042
5043 COMMAND_HANDLER(handle_fast_load_command)
5044 {
5045 if (CMD_ARGC > 0)
5046 return ERROR_COMMAND_SYNTAX_ERROR;
5047 if (fastload == NULL)
5048 {
5049 LOG_ERROR("No image in memory");
5050 return ERROR_FAIL;
5051 }
5052 int i;
5053 int ms = timeval_ms();
5054 int size = 0;
5055 int retval = ERROR_OK;
5056 for (i = 0; i < fastload_num;i++)
5057 {
5058 struct target *target = get_current_target(CMD_CTX);
5059 command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
5060 (unsigned int)(fastload[i].address),
5061 (unsigned int)(fastload[i].length));
5062 if (retval == ERROR_OK)
5063 {
5064 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
5065 }
5066 size += fastload[i].length;
5067 }
5068 int after = timeval_ms();
5069 command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
5070 return retval;
5071 }
5072
5073 static const struct command_registration target_command_handlers[] = {
5074 {
5075 .name = "targets",
5076 .handler = handle_targets_command,
5077 .mode = COMMAND_ANY,
5078 .help = "change current default target (one parameter) "
5079 "or prints table of all targets (no parameters)",
5080 .usage = "[target]",
5081 },
5082 {
5083 .name = "target",
5084 .mode = COMMAND_CONFIG,
5085 .help = "configure target",
5086
5087 .chain = target_subcommand_handlers,
5088 },
5089 COMMAND_REGISTRATION_DONE
5090 };
5091
5092 int target_register_commands(struct command_context *cmd_ctx)
5093 {
5094 return register_commands(cmd_ctx, NULL, target_command_handlers);
5095 }
5096
5097 static bool target_reset_nag = true;
5098
5099 bool get_target_reset_nag(void)
5100 {
5101 return target_reset_nag;
5102 }
5103
5104 COMMAND_HANDLER(handle_target_reset_nag)
5105 {
5106 return CALL_COMMAND_HANDLER(handle_command_parse_bool,
5107 &target_reset_nag, "Nag after each reset about options to improve "
5108 "performance");
5109 }
5110
5111 static const struct command_registration target_exec_command_handlers[] = {
5112 {
5113 .name = "fast_load_image",
5114 .handler = handle_fast_load_image_command,
5115 .mode = COMMAND_ANY,
5116 .help = "Load image into server memory for later use by "
5117 "fast_load; primarily for profiling",
5118 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5119 "[min_address [max_length]]",
5120 },
5121 {
5122 .name = "fast_load",
5123 .handler = handle_fast_load_command,
5124 .mode = COMMAND_EXEC,
5125 .help = "loads active fast load image to current target "
5126 "- mainly for profiling purposes",
5127 },
5128 {
5129 .name = "profile",
5130 .handler = handle_profile_command,
5131 .mode = COMMAND_EXEC,
5132 .help = "profiling samples the CPU PC",
5133 },
5134 /** @todo don't register virt2phys() unless target supports it */
5135 {
5136 .name = "virt2phys",
5137 .handler = handle_virt2phys_command,
5138 .mode = COMMAND_ANY,
5139 .help = "translate a virtual address into a physical address",
5140 .usage = "virtual_address",
5141 },
5142 {
5143 .name = "reg",
5144 .handler = handle_reg_command,
5145 .mode = COMMAND_EXEC,
5146 .help = "display or set a register; with no arguments, "
5147 "displays all registers and their values",
5148 .usage = "[(register_name|register_number) [value]]",
5149 },
5150 {
5151 .name = "poll",
5152 .handler = handle_poll_command,
5153 .mode = COMMAND_EXEC,
5154 .help = "poll target state; or reconfigure background polling",
5155 .usage = "['on'|'off']",
5156 },
5157 {
5158 .name = "wait_halt",
5159 .handler = handle_wait_halt_command,
5160 .mode = COMMAND_EXEC,
5161 .help = "wait up to the specified number of milliseconds "
5162 "(default 5) for a previously requested halt",
5163 .usage = "[milliseconds]",
5164 },
5165 {
5166 .name = "halt",
5167 .handler = handle_halt_command,
5168 .mode = COMMAND_EXEC,
5169 .help = "request target to halt, then wait up to the specified"
5170 "number of milliseconds (default 5) for it to complete",
5171 .usage = "[milliseconds]",
5172 },
5173 {
5174 .name = "resume",
5175 .handler = handle_resume_command,
5176 .mode = COMMAND_EXEC,
5177 .help = "resume target execution from current PC or address",
5178 .usage = "[address]",
5179 },
5180 {
5181 .name = "reset",
5182 .handler = handle_reset_command,
5183 .mode = COMMAND_EXEC,
5184 .usage = "[run|halt|init]",
5185 .help = "Reset all targets into the specified mode."
5186 "Default reset mode is run, if not given.",
5187 },
5188 {
5189 .name = "soft_reset_halt",
5190 .handler = handle_soft_reset_halt_command,
5191 .mode = COMMAND_EXEC,
5192 .help = "halt the target and do a soft reset",
5193 },
5194 {
5195 .name = "step",
5196 .handler = handle_step_command,
5197 .mode = COMMAND_EXEC,
5198 .help = "step one instruction from current PC or address",
5199 .usage = "[address]",
5200 },
5201 {
5202 .name = "mdw",
5203 .handler = handle_md_command,
5204 .mode = COMMAND_EXEC,
5205 .help = "display memory words",
5206 .usage = "['phys'] address [count]",
5207 },
5208 {
5209 .name = "mdh",
5210 .handler = handle_md_command,
5211 .mode = COMMAND_EXEC,
5212 .help = "display memory half-words",
5213 .usage = "['phys'] address [count]",
5214 },
5215 {
5216 .name = "mdb",
5217 .handler = handle_md_command,
5218 .mode = COMMAND_EXEC,
5219 .help = "display memory bytes",
5220 .usage = "['phys'] address [count]",
5221 },
5222 {
5223 .name = "mww",
5224 .handler = handle_mw_command,
5225 .mode = COMMAND_EXEC,
5226 .help = "write memory word",
5227 .usage = "['phys'] address value [count]",
5228 },
5229 {
5230 .name = "mwh",
5231 .handler = handle_mw_command,
5232 .mode = COMMAND_EXEC,
5233 .help = "write memory half-word",
5234 .usage = "['phys'] address value [count]",
5235 },
5236 {
5237 .name = "mwb",
5238 .handler = handle_mw_command,
5239 .mode = COMMAND_EXEC,
5240 .help = "write memory byte",
5241 .usage = "['phys'] address value [count]",
5242 },
5243 {
5244 .name = "bp",
5245 .handler = handle_bp_command,
5246 .mode = COMMAND_EXEC,
5247 .help = "list or set hardware or software breakpoint",
5248 .usage = "[address length ['hw']]",
5249 },
5250 {
5251 .name = "rbp",
5252 .handler = handle_rbp_command,
5253 .mode = COMMAND_EXEC,
5254 .help = "remove breakpoint",
5255 .usage = "address",
5256 },
5257 {
5258 .name = "wp",
5259 .handler = handle_wp_command,
5260 .mode = COMMAND_EXEC,
5261 .help = "list (no params) or create watchpoints",
5262 .usage = "[address length [('r'|'w'|'a') value [mask]]]",
5263 },
5264 {
5265 .name = "rwp",
5266 .handler = handle_rwp_command,
5267 .mode = COMMAND_EXEC,
5268 .help = "remove watchpoint",
5269 .usage = "address",
5270 },
5271 {
5272 .name = "load_image",
5273 .handler = handle_load_image_command,
5274 .mode = COMMAND_EXEC,
5275 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5276 "[min_address] [max_length]",
5277 },
5278 {
5279 .name = "dump_image",
5280 .handler = handle_dump_image_command,
5281 .mode = COMMAND_EXEC,
5282 .usage = "filename address size",
5283 },
5284 {
5285 .name = "verify_image",
5286 .handler = handle_verify_image_command,
5287 .mode = COMMAND_EXEC,
5288 .usage = "filename [offset [type]]",
5289 },
5290 {
5291 .name = "test_image",
5292 .handler = handle_test_image_command,
5293 .mode = COMMAND_EXEC,
5294 .usage = "filename [offset [type]]",
5295 },
5296 {
5297 .name = "mem2array",
5298 .mode = COMMAND_EXEC,
5299 .jim_handler = jim_mem2array,
5300 .help = "read 8/16/32 bit memory and return as a TCL array "
5301 "for script processing",
5302 .usage = "arrayname bitwidth address count",
5303 },
5304 {
5305 .name = "array2mem",
5306 .mode = COMMAND_EXEC,
5307 .jim_handler = jim_array2mem,
5308 .help = "convert a TCL array to memory locations "
5309 "and write the 8/16/32 bit values",
5310 .usage = "arrayname bitwidth address count",
5311 },
5312 {
5313 .name = "reset_nag",
5314 .handler = handle_target_reset_nag,
5315 .mode = COMMAND_ANY,
5316 .help = "Nag after each reset about options that could have been "
5317 "enabled to improve performance. ",
5318 .usage = "['enable'|'disable']",
5319 },
5320 COMMAND_REGISTRATION_DONE
5321 };
5322 static int target_register_user_commands(struct command_context *cmd_ctx)
5323 {
5324 int retval = ERROR_OK;
5325 if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
5326 return retval;
5327
5328 if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
5329 return retval;
5330
5331
5332 return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
5333 }
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)