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