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