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