Code Review / openocd.git / blob
? search:


45b45770197d2bb569e034d1665a2ab5f9060748
[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 %s failed, GDB will be halted. Polling again in %dms",
2252 target_name(target),
2253 backoff_times * polling_interval);
2254
2255 /* Tell GDB to halt the debugger. This allows the user to
2256 * run monitor commands to handle the situation.
2257 */
2258 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
2259 return retval;
2260 }
2261 /* Since we succeeded, we reset backoff count */
2262 if (backoff_times > 0)
2263 LOG_USER("Polling target %s succeeded again", target_name(target));
2264 backoff_times = 0;
2265 }
2266 }
2267
2268 return retval;
2269 }
2270
2271 COMMAND_HANDLER(handle_reg_command)
2272 {
2273 struct target *target;
2274 struct reg *reg = NULL;
2275 unsigned count = 0;
2276 char *value;
2277
2278 LOG_DEBUG("-");
2279
2280 target = get_current_target(CMD_CTX);
2281
2282 /* list all available registers for the current target */
2283 if (CMD_ARGC == 0) {
2284 struct reg_cache *cache = target->reg_cache;
2285
2286 count = 0;
2287 while (cache) {
2288 unsigned i;
2289
2290 command_print(CMD_CTX, "===== %s", cache->name);
2291
2292 for (i = 0, reg = cache->reg_list;
2293 i < cache->num_regs;
2294 i++, reg++, count++) {
2295 /* only print cached values if they are valid */
2296 if (reg->valid) {
2297 value = buf_to_str(reg->value,
2298 reg->size, 16);
2299 command_print(CMD_CTX,
2300 "(%i) %s (/%" PRIu32 "): 0x%s%s",
2301 count, reg->name,
2302 reg->size, value,
2303 reg->dirty
2304 ? " (dirty)"
2305 : "");
2306 free(value);
2307 } else {
2308 command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
2309 count, reg->name,
2310 reg->size) ;
2311 }
2312 }
2313 cache = cache->next;
2314 }
2315
2316 return ERROR_OK;
2317 }
2318
2319 /* access a single register by its ordinal number */
2320 if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9')) {
2321 unsigned num;
2322 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
2323
2324 struct reg_cache *cache = target->reg_cache;
2325 count = 0;
2326 while (cache) {
2327 unsigned i;
2328 for (i = 0; i < cache->num_regs; i++) {
2329 if (count++ == num) {
2330 reg = &cache->reg_list[i];
2331 break;
2332 }
2333 }
2334 if (reg)
2335 break;
2336 cache = cache->next;
2337 }
2338
2339 if (!reg) {
2340 command_print(CMD_CTX, "%i is out of bounds, the current target "
2341 "has only %i registers (0 - %i)", num, count, count - 1);
2342 return ERROR_OK;
2343 }
2344 } else {
2345 /* access a single register by its name */
2346 reg = register_get_by_name(target->reg_cache, CMD_ARGV[0], 1);
2347
2348 if (!reg) {
2349 command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
2350 return ERROR_OK;
2351 }
2352 }
2353
2354 assert(reg != NULL); /* give clang a hint that we *know* reg is != NULL here */
2355
2356 /* display a register */
2357 if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0')
2358 && (CMD_ARGV[1][0] <= '9')))) {
2359 if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0))
2360 reg->valid = 0;
2361
2362 if (reg->valid == 0)
2363 reg->type->get(reg);
2364 value = buf_to_str(reg->value, reg->size, 16);
2365 command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2366 free(value);
2367 return ERROR_OK;
2368 }
2369
2370 /* set register value */
2371 if (CMD_ARGC == 2) {
2372 uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
2373 if (buf == NULL)
2374 return ERROR_FAIL;
2375 str_to_buf(CMD_ARGV[1], strlen(CMD_ARGV[1]), buf, reg->size, 0);
2376
2377 reg->type->set(reg, buf);
2378
2379 value = buf_to_str(reg->value, reg->size, 16);
2380 command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2381 free(value);
2382
2383 free(buf);
2384
2385 return ERROR_OK;
2386 }
2387
2388 return ERROR_COMMAND_SYNTAX_ERROR;
2389 }
2390
2391 COMMAND_HANDLER(handle_poll_command)
2392 {
2393 int retval = ERROR_OK;
2394 struct target *target = get_current_target(CMD_CTX);
2395
2396 if (CMD_ARGC == 0) {
2397 command_print(CMD_CTX, "background polling: %s",
2398 jtag_poll_get_enabled() ? "on" : "off");
2399 command_print(CMD_CTX, "TAP: %s (%s)",
2400 target->tap->dotted_name,
2401 target->tap->enabled ? "enabled" : "disabled");
2402 if (!target->tap->enabled)
2403 return ERROR_OK;
2404 retval = target_poll(target);
2405 if (retval != ERROR_OK)
2406 return retval;
2407 retval = target_arch_state(target);
2408 if (retval != ERROR_OK)
2409 return retval;
2410 } else if (CMD_ARGC == 1) {
2411 bool enable;
2412 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
2413 jtag_poll_set_enabled(enable);
2414 } else
2415 return ERROR_COMMAND_SYNTAX_ERROR;
2416
2417 return retval;
2418 }
2419
2420 COMMAND_HANDLER(handle_wait_halt_command)
2421 {
2422 if (CMD_ARGC > 1)
2423 return ERROR_COMMAND_SYNTAX_ERROR;
2424
2425 unsigned ms = 5000;
2426 if (1 == CMD_ARGC) {
2427 int retval = parse_uint(CMD_ARGV[0], &ms);
2428 if (ERROR_OK != retval)
2429 return ERROR_COMMAND_SYNTAX_ERROR;
2430 /* convert seconds (given) to milliseconds (needed) */
2431 ms *= 1000;
2432 }
2433
2434 struct target *target = get_current_target(CMD_CTX);
2435 return target_wait_state(target, TARGET_HALTED, ms);
2436 }
2437
2438 /* wait for target state to change. The trick here is to have a low
2439 * latency for short waits and not to suck up all the CPU time
2440 * on longer waits.
2441 *
2442 * After 500ms, keep_alive() is invoked
2443 */
2444 int target_wait_state(struct target *target, enum target_state state, int ms)
2445 {
2446 int retval;
2447 long long then = 0, cur;
2448 int once = 1;
2449
2450 for (;;) {
2451 retval = target_poll(target);
2452 if (retval != ERROR_OK)
2453 return retval;
2454 if (target->state == state)
2455 break;
2456 cur = timeval_ms();
2457 if (once) {
2458 once = 0;
2459 then = timeval_ms();
2460 LOG_DEBUG("waiting for target %s...",
2461 Jim_Nvp_value2name_simple(nvp_target_state, state)->name);
2462 }
2463
2464 if (cur-then > 500)
2465 keep_alive();
2466
2467 if ((cur-then) > ms) {
2468 LOG_ERROR("timed out while waiting for target %s",
2469 Jim_Nvp_value2name_simple(nvp_target_state, state)->name);
2470 return ERROR_FAIL;
2471 }
2472 }
2473
2474 return ERROR_OK;
2475 }
2476
2477 COMMAND_HANDLER(handle_halt_command)
2478 {
2479 LOG_DEBUG("-");
2480
2481 struct target *target = get_current_target(CMD_CTX);
2482 int retval = target_halt(target);
2483 if (ERROR_OK != retval)
2484 return retval;
2485
2486 if (CMD_ARGC == 1) {
2487 unsigned wait_local;
2488 retval = parse_uint(CMD_ARGV[0], &wait_local);
2489 if (ERROR_OK != retval)
2490 return ERROR_COMMAND_SYNTAX_ERROR;
2491 if (!wait_local)
2492 return ERROR_OK;
2493 }
2494
2495 return CALL_COMMAND_HANDLER(handle_wait_halt_command);
2496 }
2497
2498 COMMAND_HANDLER(handle_soft_reset_halt_command)
2499 {
2500 struct target *target = get_current_target(CMD_CTX);
2501
2502 LOG_USER("requesting target halt and executing a soft reset");
2503
2504 target->type->soft_reset_halt(target);
2505
2506 return ERROR_OK;
2507 }
2508
2509 COMMAND_HANDLER(handle_reset_command)
2510 {
2511 if (CMD_ARGC > 1)
2512 return ERROR_COMMAND_SYNTAX_ERROR;
2513
2514 enum target_reset_mode reset_mode = RESET_RUN;
2515 if (CMD_ARGC == 1) {
2516 const Jim_Nvp *n;
2517 n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]);
2518 if ((n->name == NULL) || (n->value == RESET_UNKNOWN))
2519 return ERROR_COMMAND_SYNTAX_ERROR;
2520 reset_mode = n->value;
2521 }
2522
2523 /* reset *all* targets */
2524 return target_process_reset(CMD_CTX, reset_mode);
2525 }
2526
2527
2528 COMMAND_HANDLER(handle_resume_command)
2529 {
2530 int current = 1;
2531 if (CMD_ARGC > 1)
2532 return ERROR_COMMAND_SYNTAX_ERROR;
2533
2534 struct target *target = get_current_target(CMD_CTX);
2535
2536 /* with no CMD_ARGV, resume from current pc, addr = 0,
2537 * with one arguments, addr = CMD_ARGV[0],
2538 * handle breakpoints, not debugging */
2539 uint32_t addr = 0;
2540 if (CMD_ARGC == 1) {
2541 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2542 current = 0;
2543 }
2544
2545 return target_resume(target, current, addr, 1, 0);
2546 }
2547
2548 COMMAND_HANDLER(handle_step_command)
2549 {
2550 if (CMD_ARGC > 1)
2551 return ERROR_COMMAND_SYNTAX_ERROR;
2552
2553 LOG_DEBUG("-");
2554
2555 /* with no CMD_ARGV, step from current pc, addr = 0,
2556 * with one argument addr = CMD_ARGV[0],
2557 * handle breakpoints, debugging */
2558 uint32_t addr = 0;
2559 int current_pc = 1;
2560 if (CMD_ARGC == 1) {
2561 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2562 current_pc = 0;
2563 }
2564
2565 struct target *target = get_current_target(CMD_CTX);
2566
2567 return target->type->step(target, current_pc, addr, 1);
2568 }
2569
2570 static void handle_md_output(struct command_context *cmd_ctx,
2571 struct target *target, uint32_t address, unsigned size,
2572 unsigned count, const uint8_t *buffer)
2573 {
2574 const unsigned line_bytecnt = 32;
2575 unsigned line_modulo = line_bytecnt / size;
2576
2577 char output[line_bytecnt * 4 + 1];
2578 unsigned output_len = 0;
2579
2580 const char *value_fmt;
2581 switch (size) {
2582 case 4:
2583 value_fmt = "%8.8x ";
2584 break;
2585 case 2:
2586 value_fmt = "%4.4x ";
2587 break;
2588 case 1:
2589 value_fmt = "%2.2x ";
2590 break;
2591 default:
2592 /* "can't happen", caller checked */
2593 LOG_ERROR("invalid memory read size: %u", size);
2594 return;
2595 }
2596
2597 for (unsigned i = 0; i < count; i++) {
2598 if (i % line_modulo == 0) {
2599 output_len += snprintf(output + output_len,
2600 sizeof(output) - output_len,
2601 "0x%8.8x: ",
2602 (unsigned)(address + (i*size)));
2603 }
2604
2605 uint32_t value = 0;
2606 const uint8_t *value_ptr = buffer + i * size;
2607 switch (size) {
2608 case 4:
2609 value = target_buffer_get_u32(target, value_ptr);
2610 break;
2611 case 2:
2612 value = target_buffer_get_u16(target, value_ptr);
2613 break;
2614 case 1:
2615 value = *value_ptr;
2616 }
2617 output_len += snprintf(output + output_len,
2618 sizeof(output) - output_len,
2619 value_fmt, value);
2620
2621 if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
2622 command_print(cmd_ctx, "%s", output);
2623 output_len = 0;
2624 }
2625 }
2626 }
2627
2628 COMMAND_HANDLER(handle_md_command)
2629 {
2630 if (CMD_ARGC < 1)
2631 return ERROR_COMMAND_SYNTAX_ERROR;
2632
2633 unsigned size = 0;
2634 switch (CMD_NAME[2]) {
2635 case 'w':
2636 size = 4;
2637 break;
2638 case 'h':
2639 size = 2;
2640 break;
2641 case 'b':
2642 size = 1;
2643 break;
2644 default:
2645 return ERROR_COMMAND_SYNTAX_ERROR;
2646 }
2647
2648 bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
2649 int (*fn)(struct target *target,
2650 uint32_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);
2651 if (physical) {
2652 CMD_ARGC--;
2653 CMD_ARGV++;
2654 fn = target_read_phys_memory;
2655 } else
2656 fn = target_read_memory;
2657 if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
2658 return ERROR_COMMAND_SYNTAX_ERROR;
2659
2660 uint32_t address;
2661 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2662
2663 unsigned count = 1;
2664 if (CMD_ARGC == 2)
2665 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count);
2666
2667 uint8_t *buffer = calloc(count, size);
2668
2669 struct target *target = get_current_target(CMD_CTX);
2670 int retval = fn(target, address, size, count, buffer);
2671 if (ERROR_OK == retval)
2672 handle_md_output(CMD_CTX, target, address, size, count, buffer);
2673
2674 free(buffer);
2675
2676 return retval;
2677 }
2678
2679 typedef int (*target_write_fn)(struct target *target,
2680 uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
2681
2682 static int target_write_memory_fast(struct target *target,
2683 uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
2684 {
2685 return target_write_buffer(target, address, size * count, buffer);
2686 }
2687
2688 static int target_fill_mem(struct target *target,
2689 uint32_t address,
2690 target_write_fn fn,
2691 unsigned data_size,
2692 /* value */
2693 uint32_t b,
2694 /* count */
2695 unsigned c)
2696 {
2697 /* We have to write in reasonably large chunks to be able
2698 * to fill large memory areas with any sane speed */
2699 const unsigned chunk_size = 16384;
2700 uint8_t *target_buf = malloc(chunk_size * data_size);
2701 if (target_buf == NULL) {
2702 LOG_ERROR("Out of memory");
2703 return ERROR_FAIL;
2704 }
2705
2706 for (unsigned i = 0; i < chunk_size; i++) {
2707 switch (data_size) {
2708 case 4:
2709 target_buffer_set_u32(target, target_buf + i * data_size, b);
2710 break;
2711 case 2:
2712 target_buffer_set_u16(target, target_buf + i * data_size, b);
2713 break;
2714 case 1:
2715 target_buffer_set_u8(target, target_buf + i * data_size, b);
2716 break;
2717 default:
2718 exit(-1);
2719 }
2720 }
2721
2722 int retval = ERROR_OK;
2723
2724 for (unsigned x = 0; x < c; x += chunk_size) {
2725 unsigned current;
2726 current = c - x;
2727 if (current > chunk_size)
2728 current = chunk_size;
2729 retval = fn(target, address + x * data_size, data_size, current, target_buf);
2730 if (retval != ERROR_OK)
2731 break;
2732 /* avoid GDB timeouts */
2733 keep_alive();
2734 }
2735 free(target_buf);
2736
2737 return retval;
2738 }
2739
2740
2741 COMMAND_HANDLER(handle_mw_command)
2742 {
2743 if (CMD_ARGC < 2)
2744 return ERROR_COMMAND_SYNTAX_ERROR;
2745 bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
2746 target_write_fn fn;
2747 if (physical) {
2748 CMD_ARGC--;
2749 CMD_ARGV++;
2750 fn = target_write_phys_memory;
2751 } else
2752 fn = target_write_memory_fast;
2753 if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
2754 return ERROR_COMMAND_SYNTAX_ERROR;
2755
2756 uint32_t address;
2757 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2758
2759 uint32_t value;
2760 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2761
2762 unsigned count = 1;
2763 if (CMD_ARGC == 3)
2764 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
2765
2766 struct target *target = get_current_target(CMD_CTX);
2767 unsigned wordsize;
2768 switch (CMD_NAME[2]) {
2769 case 'w':
2770 wordsize = 4;
2771 break;
2772 case 'h':
2773 wordsize = 2;
2774 break;
2775 case 'b':
2776 wordsize = 1;
2777 break;
2778 default:
2779 return ERROR_COMMAND_SYNTAX_ERROR;
2780 }
2781
2782 return target_fill_mem(target, address, fn, wordsize, value, count);
2783 }
2784
2785 static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
2786 uint32_t *min_address, uint32_t *max_address)
2787 {
2788 if (CMD_ARGC < 1 || CMD_ARGC > 5)
2789 return ERROR_COMMAND_SYNTAX_ERROR;
2790
2791 /* a base address isn't always necessary,
2792 * default to 0x0 (i.e. don't relocate) */
2793 if (CMD_ARGC >= 2) {
2794 uint32_t addr;
2795 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2796 image->base_address = addr;
2797 image->base_address_set = 1;
2798 } else
2799 image->base_address_set = 0;
2800
2801 image->start_address_set = 0;
2802
2803 if (CMD_ARGC >= 4)
2804 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
2805 if (CMD_ARGC == 5) {
2806 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
2807 /* use size (given) to find max (required) */
2808 *max_address += *min_address;
2809 }
2810
2811 if (*min_address > *max_address)
2812 return ERROR_COMMAND_SYNTAX_ERROR;
2813
2814 return ERROR_OK;
2815 }
2816
2817 COMMAND_HANDLER(handle_load_image_command)
2818 {
2819 uint8_t *buffer;
2820 size_t buf_cnt;
2821 uint32_t image_size;
2822 uint32_t min_address = 0;
2823 uint32_t max_address = 0xffffffff;
2824 int i;
2825 struct image image;
2826
2827 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
2828 &image, &min_address, &max_address);
2829 if (ERROR_OK != retval)
2830 return retval;
2831
2832 struct target *target = get_current_target(CMD_CTX);
2833
2834 struct duration bench;
2835 duration_start(&bench);
2836
2837 if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
2838 return ERROR_OK;
2839
2840 image_size = 0x0;
2841 retval = ERROR_OK;
2842 for (i = 0; i < image.num_sections; i++) {
2843 buffer = malloc(image.sections[i].size);
2844 if (buffer == NULL) {
2845 command_print(CMD_CTX,
2846 "error allocating buffer for section (%d bytes)",
2847 (int)(image.sections[i].size));
2848 break;
2849 }
2850
2851 retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
2852 if (retval != ERROR_OK) {
2853 free(buffer);
2854 break;
2855 }
2856
2857 uint32_t offset = 0;
2858 uint32_t length = buf_cnt;
2859
2860 /* DANGER!!! beware of unsigned comparision here!!! */
2861
2862 if ((image.sections[i].base_address + buf_cnt >= min_address) &&
2863 (image.sections[i].base_address < max_address)) {
2864
2865 if (image.sections[i].base_address < min_address) {
2866 /* clip addresses below */
2867 offset += min_address-image.sections[i].base_address;
2868 length -= offset;
2869 }
2870
2871 if (image.sections[i].base_address + buf_cnt > max_address)
2872 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2873
2874 retval = target_write_buffer(target,
2875 image.sections[i].base_address + offset, length, buffer + offset);
2876 if (retval != ERROR_OK) {
2877 free(buffer);
2878 break;
2879 }
2880 image_size += length;
2881 command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
2882 (unsigned int)length,
2883 image.sections[i].base_address + offset);
2884 }
2885
2886 free(buffer);
2887 }
2888
2889 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
2890 command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
2891 "in %fs (%0.3f KiB/s)", image_size,
2892 duration_elapsed(&bench), duration_kbps(&bench, image_size));
2893 }
2894
2895 image_close(&image);
2896
2897 return retval;
2898
2899 }
2900
2901 COMMAND_HANDLER(handle_dump_image_command)
2902 {
2903 struct fileio fileio;
2904 uint8_t *buffer;
2905 int retval, retvaltemp;
2906 uint32_t address, size;
2907 struct duration bench;
2908 struct target *target = get_current_target(CMD_CTX);
2909
2910 if (CMD_ARGC != 3)
2911 return ERROR_COMMAND_SYNTAX_ERROR;
2912
2913 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
2914 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
2915
2916 uint32_t buf_size = (size > 4096) ? 4096 : size;
2917 buffer = malloc(buf_size);
2918 if (!buffer)
2919 return ERROR_FAIL;
2920
2921 retval = fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY);
2922 if (retval != ERROR_OK) {
2923 free(buffer);
2924 return retval;
2925 }
2926
2927 duration_start(&bench);
2928
2929 while (size > 0) {
2930 size_t size_written;
2931 uint32_t this_run_size = (size > buf_size) ? buf_size : size;
2932 retval = target_read_buffer(target, address, this_run_size, buffer);
2933 if (retval != ERROR_OK)
2934 break;
2935
2936 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2937 if (retval != ERROR_OK)
2938 break;
2939
2940 size -= this_run_size;
2941 address += this_run_size;
2942 }
2943
2944 free(buffer);
2945
2946 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
2947 int filesize;
2948 retval = fileio_size(&fileio, &filesize);
2949 if (retval != ERROR_OK)
2950 return retval;
2951 command_print(CMD_CTX,
2952 "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
2953 duration_elapsed(&bench), duration_kbps(&bench, filesize));
2954 }
2955
2956 retvaltemp = fileio_close(&fileio);
2957 if (retvaltemp != ERROR_OK)
2958 return retvaltemp;
2959
2960 return retval;
2961 }
2962
2963 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
2964 {
2965 uint8_t *buffer;
2966 size_t buf_cnt;
2967 uint32_t image_size;
2968 int i;
2969 int retval;
2970 uint32_t checksum = 0;
2971 uint32_t mem_checksum = 0;
2972
2973 struct image image;
2974
2975 struct target *target = get_current_target(CMD_CTX);
2976
2977 if (CMD_ARGC < 1)
2978 return ERROR_COMMAND_SYNTAX_ERROR;
2979
2980 if (!target) {
2981 LOG_ERROR("no target selected");
2982 return ERROR_FAIL;
2983 }
2984
2985 struct duration bench;
2986 duration_start(&bench);
2987
2988 if (CMD_ARGC >= 2) {
2989 uint32_t addr;
2990 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2991 image.base_address = addr;
2992 image.base_address_set = 1;
2993 } else {
2994 image.base_address_set = 0;
2995 image.base_address = 0x0;
2996 }
2997
2998 image.start_address_set = 0;
2999
3000 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
3001 if (retval != ERROR_OK)
3002 return retval;
3003
3004 image_size = 0x0;
3005 int diffs = 0;
3006 retval = ERROR_OK;
3007 for (i = 0; i < image.num_sections; i++) {
3008 buffer = malloc(image.sections[i].size);
3009 if (buffer == NULL) {
3010 command_print(CMD_CTX,
3011 "error allocating buffer for section (%d bytes)",
3012 (int)(image.sections[i].size));
3013 break;
3014 }
3015 retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
3016 if (retval != ERROR_OK) {
3017 free(buffer);
3018 break;
3019 }
3020
3021 if (verify) {
3022 /* calculate checksum of image */
3023 retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
3024 if (retval != ERROR_OK) {
3025 free(buffer);
3026 break;
3027 }
3028
3029 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
3030 if (retval != ERROR_OK) {
3031 free(buffer);
3032 break;
3033 }
3034
3035 if (checksum != mem_checksum) {
3036 /* failed crc checksum, fall back to a binary compare */
3037 uint8_t *data;
3038
3039 if (diffs == 0)
3040 LOG_ERROR("checksum mismatch - attempting binary compare");
3041
3042 data = (uint8_t *)malloc(buf_cnt);
3043
3044 /* Can we use 32bit word accesses? */
3045 int size = 1;
3046 int count = buf_cnt;
3047 if ((count % 4) == 0) {
3048 size *= 4;
3049 count /= 4;
3050 }
3051 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
3052 if (retval == ERROR_OK) {
3053 uint32_t t;
3054 for (t = 0; t < buf_cnt; t++) {
3055 if (data[t] != buffer[t]) {
3056 command_print(CMD_CTX,
3057 "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
3058 diffs,
3059 (unsigned)(t + image.sections[i].base_address),
3060 data[t],
3061 buffer[t]);
3062 if (diffs++ >= 127) {
3063 command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
3064 free(data);
3065 free(buffer);
3066 goto done;
3067 }
3068 }
3069 keep_alive();
3070 }
3071 }
3072 free(data);
3073 }
3074 } else {
3075 command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
3076 image.sections[i].base_address,
3077 buf_cnt);
3078 }
3079
3080 free(buffer);
3081 image_size += buf_cnt;
3082 }
3083 if (diffs > 0)
3084 command_print(CMD_CTX, "No more differences found.");
3085 done:
3086 if (diffs > 0)
3087 retval = ERROR_FAIL;
3088 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
3089 command_print(CMD_CTX, "verified %" PRIu32 " bytes "
3090 "in %fs (%0.3f KiB/s)", image_size,
3091 duration_elapsed(&bench), duration_kbps(&bench, image_size));
3092 }
3093
3094 image_close(&image);
3095
3096 return retval;
3097 }
3098
3099 COMMAND_HANDLER(handle_verify_image_command)
3100 {
3101 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1);
3102 }
3103
3104 COMMAND_HANDLER(handle_test_image_command)
3105 {
3106 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0);
3107 }
3108
3109 static int handle_bp_command_list(struct command_context *cmd_ctx)
3110 {
3111 struct target *target = get_current_target(cmd_ctx);
3112 struct breakpoint *breakpoint = target->breakpoints;
3113 while (breakpoint) {
3114 if (breakpoint->type == BKPT_SOFT) {
3115 char *buf = buf_to_str(breakpoint->orig_instr,
3116 breakpoint->length, 16);
3117 command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
3118 breakpoint->address,
3119 breakpoint->length,
3120 breakpoint->set, buf);
3121 free(buf);
3122 } else {
3123 if ((breakpoint->address == 0) && (breakpoint->asid != 0))
3124 command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
3125 breakpoint->asid,
3126 breakpoint->length, breakpoint->set);
3127 else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
3128 command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
3129 breakpoint->address,
3130 breakpoint->length, breakpoint->set);
3131 command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
3132 breakpoint->asid);
3133 } else
3134 command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
3135 breakpoint->address,
3136 breakpoint->length, breakpoint->set);
3137 }
3138
3139 breakpoint = breakpoint->next;
3140 }
3141 return ERROR_OK;
3142 }
3143
3144 static int handle_bp_command_set(struct command_context *cmd_ctx,
3145 uint32_t addr, uint32_t asid, uint32_t length, int hw)
3146 {
3147 struct target *target = get_current_target(cmd_ctx);
3148
3149 if (asid == 0) {
3150 int retval = breakpoint_add(target, addr, length, hw);
3151 if (ERROR_OK == retval)
3152 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
3153 else {
3154 LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
3155 return retval;
3156 }
3157 } else if (addr == 0) {
3158 int retval = context_breakpoint_add(target, asid, length, hw);
3159 if (ERROR_OK == retval)
3160 command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
3161 else {
3162 LOG_ERROR("Failure setting breakpoint, the same address(CONTEXTID) is already used");
3163 return retval;
3164 }
3165 } else {
3166 int retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
3167 if (ERROR_OK == retval)
3168 command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
3169 else {
3170 LOG_ERROR("Failure setting breakpoint, the same address is already used");
3171 return retval;
3172 }
3173 }
3174 return ERROR_OK;
3175 }
3176
3177 COMMAND_HANDLER(handle_bp_command)
3178 {
3179 uint32_t addr;
3180 uint32_t asid;
3181 uint32_t length;
3182 int hw = BKPT_SOFT;
3183
3184 switch (CMD_ARGC) {
3185 case 0:
3186 return handle_bp_command_list(CMD_CTX);
3187
3188 case 2:
3189 asid = 0;
3190 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3191 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3192 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3193
3194 case 3:
3195 if (strcmp(CMD_ARGV[2], "hw") == 0) {
3196 hw = BKPT_HARD;
3197 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3198
3199 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3200
3201 asid = 0;
3202 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3203 } else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) {
3204 hw = BKPT_HARD;
3205 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid);
3206 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3207 addr = 0;
3208 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3209 }
3210
3211 case 4:
3212 hw = BKPT_HARD;
3213 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3214 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
3215 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length);
3216 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3217
3218 default:
3219 return ERROR_COMMAND_SYNTAX_ERROR;
3220 }
3221 }
3222
3223 COMMAND_HANDLER(handle_rbp_command)
3224 {
3225 if (CMD_ARGC != 1)
3226 return ERROR_COMMAND_SYNTAX_ERROR;
3227
3228 uint32_t addr;
3229 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3230
3231 struct target *target = get_current_target(CMD_CTX);
3232 breakpoint_remove(target, addr);
3233
3234 return ERROR_OK;
3235 }
3236
3237 COMMAND_HANDLER(handle_wp_command)
3238 {
3239 struct target *target = get_current_target(CMD_CTX);
3240
3241 if (CMD_ARGC == 0) {
3242 struct watchpoint *watchpoint = target->watchpoints;
3243
3244 while (watchpoint) {
3245 command_print(CMD_CTX, "address: 0x%8.8" PRIx32
3246 ", len: 0x%8.8" PRIx32
3247 ", r/w/a: %i, value: 0x%8.8" PRIx32
3248 ", mask: 0x%8.8" PRIx32,
3249 watchpoint->address,
3250 watchpoint->length,
3251 (int)watchpoint->rw,
3252 watchpoint->value,
3253 watchpoint->mask);
3254 watchpoint = watchpoint->next;
3255 }
3256 return ERROR_OK;
3257 }
3258
3259 enum watchpoint_rw type = WPT_ACCESS;
3260 uint32_t addr = 0;
3261 uint32_t length = 0;
3262 uint32_t data_value = 0x0;
3263 uint32_t data_mask = 0xffffffff;
3264
3265 switch (CMD_ARGC) {
3266 case 5:
3267 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
3268 /* fall through */
3269 case 4:
3270 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
3271 /* fall through */
3272 case 3:
3273 switch (CMD_ARGV[2][0]) {
3274 case 'r':
3275 type = WPT_READ;
3276 break;
3277 case 'w':
3278 type = WPT_WRITE;
3279 break;
3280 case 'a':
3281 type = WPT_ACCESS;
3282 break;
3283 default:
3284 LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
3285 return ERROR_COMMAND_SYNTAX_ERROR;
3286 }
3287 /* fall through */
3288 case 2:
3289 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3290 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3291 break;
3292
3293 default:
3294 return ERROR_COMMAND_SYNTAX_ERROR;
3295 }
3296
3297 int retval = watchpoint_add(target, addr, length, type,
3298 data_value, data_mask);
3299 if (ERROR_OK != retval)
3300 LOG_ERROR("Failure setting watchpoints");
3301
3302 return retval;
3303 }
3304
3305 COMMAND_HANDLER(handle_rwp_command)
3306 {
3307 if (CMD_ARGC != 1)
3308 return ERROR_COMMAND_SYNTAX_ERROR;
3309
3310 uint32_t addr;
3311 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3312
3313 struct target *target = get_current_target(CMD_CTX);
3314 watchpoint_remove(target, addr);
3315
3316 return ERROR_OK;
3317 }
3318
3319 /**
3320 * Translate a virtual address to a physical address.
3321 *
3322 * The low-level target implementation must have logged a detailed error
3323 * which is forwarded to telnet/GDB session.
3324 */
3325 COMMAND_HANDLER(handle_virt2phys_command)
3326 {
3327 if (CMD_ARGC != 1)
3328 return ERROR_COMMAND_SYNTAX_ERROR;
3329
3330 uint32_t va;
3331 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
3332 uint32_t pa;
3333
3334 struct target *target = get_current_target(CMD_CTX);
3335 int retval = target->type->virt2phys(target, va, &pa);
3336 if (retval == ERROR_OK)
3337 command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
3338
3339 return retval;
3340 }
3341
3342 static void writeData(FILE *f, const void *data, size_t len)
3343 {
3344 size_t written = fwrite(data, 1, len, f);
3345 if (written != len)
3346 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3347 }
3348
3349 static void writeLong(FILE *f, int l)
3350 {
3351 int i;
3352 for (i = 0; i < 4; i++) {
3353 char c = (l >> (i*8))&0xff;
3354 writeData(f, &c, 1);
3355 }
3356
3357 }
3358
3359 static void writeString(FILE *f, char *s)
3360 {
3361 writeData(f, s, strlen(s));
3362 }
3363
3364 /* Dump a gmon.out histogram file. */
3365 static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
3366 {
3367 uint32_t i;
3368 FILE *f = fopen(filename, "w");
3369 if (f == NULL)
3370 return;
3371 writeString(f, "gmon");
3372 writeLong(f, 0x00000001); /* Version */
3373 writeLong(f, 0); /* padding */
3374 writeLong(f, 0); /* padding */
3375 writeLong(f, 0); /* padding */
3376
3377 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
3378 writeData(f, &zero, 1);
3379
3380 /* figure out bucket size */
3381 uint32_t min = samples[0];
3382 uint32_t max = samples[0];
3383 for (i = 0; i < sampleNum; i++) {
3384 if (min > samples[i])
3385 min = samples[i];
3386 if (max < samples[i])
3387 max = samples[i];
3388 }
3389
3390 int addressSpace = (max - min + 1);
3391 assert(addressSpace >= 2);
3392
3393 static const uint32_t maxBuckets = 16 * 1024; /* maximum buckets. */
3394 uint32_t length = addressSpace;
3395 if (length > maxBuckets)
3396 length = maxBuckets;
3397 int *buckets = malloc(sizeof(int)*length);
3398 if (buckets == NULL) {
3399 fclose(f);
3400 return;
3401 }
3402 memset(buckets, 0, sizeof(int) * length);
3403 for (i = 0; i < sampleNum; i++) {
3404 uint32_t address = samples[i];
3405 long long a = address - min;
3406 long long b = length - 1;
3407 long long c = addressSpace - 1;
3408 int index_t = (a * b) / c; /* danger!!!! int32 overflows */
3409 buckets[index_t]++;
3410 }
3411
3412 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3413 writeLong(f, min); /* low_pc */
3414 writeLong(f, max); /* high_pc */
3415 writeLong(f, length); /* # of samples */
3416 writeLong(f, 100); /* KLUDGE! We lie, ca. 100Hz best case. */
3417 writeString(f, "seconds");
3418 for (i = 0; i < (15-strlen("seconds")); i++)
3419 writeData(f, &zero, 1);
3420 writeString(f, "s");
3421
3422 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3423
3424 char *data = malloc(2 * length);
3425 if (data != NULL) {
3426 for (i = 0; i < length; i++) {
3427 int val;
3428 val = buckets[i];
3429 if (val > 65535)
3430 val = 65535;
3431 data[i * 2] = val&0xff;
3432 data[i * 2 + 1] = (val >> 8) & 0xff;
3433 }
3434 free(buckets);
3435 writeData(f, data, length * 2);
3436 free(data);
3437 } else
3438 free(buckets);
3439
3440 fclose(f);
3441 }
3442
3443 /* profiling samples the CPU PC as quickly as OpenOCD is able,
3444 * which will be used as a random sampling of PC */
3445 COMMAND_HANDLER(handle_profile_command)
3446 {
3447 struct target *target = get_current_target(CMD_CTX);
3448 struct timeval timeout, now;
3449
3450 gettimeofday(&timeout, NULL);
3451 if (CMD_ARGC != 2)
3452 return ERROR_COMMAND_SYNTAX_ERROR;
3453 unsigned offset;
3454 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
3455
3456 timeval_add_time(&timeout, offset, 0);
3457
3458 /**
3459 * @todo: Some cores let us sample the PC without the
3460 * annoying halt/resume step; for example, ARMv7 PCSR.
3461 * Provide a way to use that more efficient mechanism.
3462 */
3463
3464 command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
3465
3466 static const int maxSample = 10000;
3467 uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3468 if (samples == NULL)
3469 return ERROR_OK;
3470
3471 int numSamples = 0;
3472 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3473 struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
3474
3475 int retval = ERROR_OK;
3476 for (;;) {
3477 target_poll(target);
3478 if (target->state == TARGET_HALTED) {
3479 uint32_t t = *((uint32_t *)reg->value);
3480 samples[numSamples++] = t;
3481 /* current pc, addr = 0, do not handle breakpoints, not debugging */
3482 retval = target_resume(target, 1, 0, 0, 0);
3483 target_poll(target);
3484 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3485 } else if (target->state == TARGET_RUNNING) {
3486 /* We want to quickly sample the PC. */
3487 retval = target_halt(target);
3488 if (retval != ERROR_OK) {
3489 free(samples);
3490 return retval;
3491 }
3492 } else {
3493 command_print(CMD_CTX, "Target not halted or running");
3494 retval = ERROR_OK;
3495 break;
3496 }
3497 if (retval != ERROR_OK)
3498 break;
3499
3500 gettimeofday(&now, NULL);
3501 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec)
3502 && (now.tv_usec >= timeout.tv_usec))) {
3503 command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
3504 retval = target_poll(target);
3505 if (retval != ERROR_OK) {
3506 free(samples);
3507 return retval;
3508 }
3509 if (target->state == TARGET_HALTED) {
3510 /* current pc, addr = 0, do not handle
3511 * breakpoints, not debugging */
3512 target_resume(target, 1, 0, 0, 0);
3513 }
3514 retval = target_poll(target);
3515 if (retval != ERROR_OK) {
3516 free(samples);
3517 return retval;
3518 }
3519 writeGmon(samples, numSamples, CMD_ARGV[1]);
3520 command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
3521 break;
3522 }
3523 }
3524 free(samples);
3525
3526 return retval;
3527 }
3528
3529 static int new_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t val)
3530 {
3531 char *namebuf;
3532 Jim_Obj *nameObjPtr, *valObjPtr;
3533 int result;
3534
3535 namebuf = alloc_printf("%s(%d)", varname, idx);
3536 if (!namebuf)
3537 return JIM_ERR;
3538
3539 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3540 valObjPtr = Jim_NewIntObj(interp, val);
3541 if (!nameObjPtr || !valObjPtr) {
3542 free(namebuf);
3543 return JIM_ERR;
3544 }
3545
3546 Jim_IncrRefCount(nameObjPtr);
3547 Jim_IncrRefCount(valObjPtr);
3548 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3549 Jim_DecrRefCount(interp, nameObjPtr);
3550 Jim_DecrRefCount(interp, valObjPtr);
3551 free(namebuf);
3552 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3553 return result;
3554 }
3555
3556 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3557 {
3558 struct command_context *context;
3559 struct target *target;
3560
3561 context = current_command_context(interp);
3562 assert(context != NULL);
3563
3564 target = get_current_target(context);
3565 if (target == NULL) {
3566 LOG_ERROR("mem2array: no current target");
3567 return JIM_ERR;
3568 }
3569
3570 return target_mem2array(interp, target, argc - 1, argv + 1);
3571 }
3572
3573 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
3574 {
3575 long l;
3576 uint32_t width;
3577 int len;
3578 uint32_t addr;
3579 uint32_t count;
3580 uint32_t v;
3581 const char *varname;
3582 int n, e, retval;
3583 uint32_t i;
3584
3585 /* argv[1] = name of array to receive the data
3586 * argv[2] = desired width
3587 * argv[3] = memory address
3588 * argv[4] = count of times to read
3589 */
3590 if (argc != 4) {
3591 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3592 return JIM_ERR;
3593 }
3594 varname = Jim_GetString(argv[0], &len);
3595 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3596
3597 e = Jim_GetLong(interp, argv[1], &l);
3598 width = l;
3599 if (e != JIM_OK)
3600 return e;
3601
3602 e = Jim_GetLong(interp, argv[2], &l);
3603 addr = l;
3604 if (e != JIM_OK)
3605 return e;
3606 e = Jim_GetLong(interp, argv[3], &l);
3607 len = l;
3608 if (e != JIM_OK)
3609 return e;
3610 switch (width) {
3611 case 8:
3612 width = 1;
3613 break;
3614 case 16:
3615 width = 2;
3616 break;
3617 case 32:
3618 width = 4;
3619 break;
3620 default:
3621 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3622 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3623 return JIM_ERR;
3624 }
3625 if (len == 0) {
3626 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3627 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3628 return JIM_ERR;
3629 }
3630 if ((addr + (len * width)) < addr) {
3631 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3632 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3633 return JIM_ERR;
3634 }
3635 /* absurd transfer size? */
3636 if (len > 65536) {
3637 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3638 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3639 return JIM_ERR;
3640 }
3641
3642 if ((width == 1) ||
3643 ((width == 2) && ((addr & 1) == 0)) ||
3644 ((width == 4) && ((addr & 3) == 0))) {
3645 /* all is well */
3646 } else {
3647 char buf[100];
3648 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3649 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3650 addr,
3651 width);
3652 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3653 return JIM_ERR;
3654 }
3655
3656 /* Transfer loop */
3657
3658 /* index counter */
3659 n = 0;
3660
3661 size_t buffersize = 4096;
3662 uint8_t *buffer = malloc(buffersize);
3663 if (buffer == NULL)
3664 return JIM_ERR;
3665
3666 /* assume ok */
3667 e = JIM_OK;
3668 while (len) {
3669 /* Slurp... in buffer size chunks */
3670
3671 count = len; /* in objects.. */
3672 if (count > (buffersize / width))
3673 count = (buffersize / width);
3674
3675 retval = target_read_memory(target, addr, width, count, buffer);
3676 if (retval != ERROR_OK) {
3677 /* BOO !*/
3678 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3679 (unsigned int)addr,
3680 (int)width,
3681 (int)count);
3682 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3683 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3684 e = JIM_ERR;
3685 break;
3686 } else {
3687 v = 0; /* shut up gcc */
3688 for (i = 0; i < count ; i++, n++) {
3689 switch (width) {
3690 case 4:
3691 v = target_buffer_get_u32(target, &buffer[i*width]);
3692 break;
3693 case 2:
3694 v = target_buffer_get_u16(target, &buffer[i*width]);
3695 break;
3696 case 1:
3697 v = buffer[i] & 0x0ff;
3698 break;
3699 }
3700 new_int_array_element(interp, varname, n, v);
3701 }
3702 len -= count;
3703 }
3704 }
3705
3706 free(buffer);
3707
3708 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3709
3710 return e;
3711 }
3712
3713 static int get_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t *val)
3714 {
3715 char *namebuf;
3716 Jim_Obj *nameObjPtr, *valObjPtr;
3717 int result;
3718 long l;
3719
3720 namebuf = alloc_printf("%s(%d)", varname, idx);
3721 if (!namebuf)
3722 return JIM_ERR;
3723
3724 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3725 if (!nameObjPtr) {
3726 free(namebuf);
3727 return JIM_ERR;
3728 }
3729
3730 Jim_IncrRefCount(nameObjPtr);
3731 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3732 Jim_DecrRefCount(interp, nameObjPtr);
3733 free(namebuf);
3734 if (valObjPtr == NULL)
3735 return JIM_ERR;
3736
3737 result = Jim_GetLong(interp, valObjPtr, &l);
3738 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3739 *val = l;
3740 return result;
3741 }
3742
3743 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3744 {
3745 struct command_context *context;
3746 struct target *target;
3747
3748 context = current_command_context(interp);
3749 assert(context != NULL);
3750
3751 target = get_current_target(context);
3752 if (target == NULL) {
3753 LOG_ERROR("array2mem: no current target");
3754 return JIM_ERR;
3755 }
3756
3757 return target_array2mem(interp, target, argc-1, argv + 1);
3758 }
3759
3760 static int target_array2mem(Jim_Interp *interp, struct target *target,
3761 int argc, Jim_Obj *const *argv)
3762 {
3763 long l;
3764 uint32_t width;
3765 int len;
3766 uint32_t addr;
3767 uint32_t count;
3768 uint32_t v;
3769 const char *varname;
3770 int n, e, retval;
3771 uint32_t i;
3772
3773 /* argv[1] = name of array to get the data
3774 * argv[2] = desired width
3775 * argv[3] = memory address
3776 * argv[4] = count to write
3777 */
3778 if (argc != 4) {
3779 Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
3780 return JIM_ERR;
3781 }
3782 varname = Jim_GetString(argv[0], &len);
3783 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3784
3785 e = Jim_GetLong(interp, argv[1], &l);
3786 width = l;
3787 if (e != JIM_OK)
3788 return e;
3789
3790 e = Jim_GetLong(interp, argv[2], &l);
3791 addr = l;
3792 if (e != JIM_OK)
3793 return e;
3794 e = Jim_GetLong(interp, argv[3], &l);
3795 len = l;
3796 if (e != JIM_OK)
3797 return e;
3798 switch (width) {
3799 case 8:
3800 width = 1;
3801 break;
3802 case 16:
3803 width = 2;
3804 break;
3805 case 32:
3806 width = 4;
3807 break;
3808 default:
3809 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3810 Jim_AppendStrings(interp, Jim_GetResult(interp),
3811 "Invalid width param, must be 8/16/32", NULL);
3812 return JIM_ERR;
3813 }
3814 if (len == 0) {
3815 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3816 Jim_AppendStrings(interp, Jim_GetResult(interp),
3817 "array2mem: zero width read?", NULL);
3818 return JIM_ERR;
3819 }
3820 if ((addr + (len * width)) < addr) {
3821 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3822 Jim_AppendStrings(interp, Jim_GetResult(interp),
3823 "array2mem: addr + len - wraps to zero?", NULL);
3824 return JIM_ERR;
3825 }
3826 /* absurd transfer size? */
3827 if (len > 65536) {
3828 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3829 Jim_AppendStrings(interp, Jim_GetResult(interp),
3830 "array2mem: absurd > 64K item request", NULL);
3831 return JIM_ERR;
3832 }
3833
3834 if ((width == 1) ||
3835 ((width == 2) && ((addr & 1) == 0)) ||
3836 ((width == 4) && ((addr & 3) == 0))) {
3837 /* all is well */
3838 } else {
3839 char buf[100];
3840 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3841 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3842 (unsigned int)addr,
3843 (int)width);
3844 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3845 return JIM_ERR;
3846 }
3847
3848 /* Transfer loop */
3849
3850 /* index counter */
3851 n = 0;
3852 /* assume ok */
3853 e = JIM_OK;
3854
3855 size_t buffersize = 4096;
3856 uint8_t *buffer = malloc(buffersize);
3857 if (buffer == NULL)
3858 return JIM_ERR;
3859
3860 while (len) {
3861 /* Slurp... in buffer size chunks */
3862
3863 count = len; /* in objects.. */
3864 if (count > (buffersize / width))
3865 count = (buffersize / width);
3866
3867 v = 0; /* shut up gcc */
3868 for (i = 0; i < count; i++, n++) {
3869 get_int_array_element(interp, varname, n, &v);
3870 switch (width) {
3871 case 4:
3872 target_buffer_set_u32(target, &buffer[i * width], v);
3873 break;
3874 case 2:
3875 target_buffer_set_u16(target, &buffer[i * width], v);
3876 break;
3877 case 1:
3878 buffer[i] = v & 0x0ff;
3879 break;
3880 }
3881 }
3882 len -= count;
3883
3884 retval = target_write_memory(target, addr, width, count, buffer);
3885 if (retval != ERROR_OK) {
3886 /* BOO !*/
3887 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3888 (unsigned int)addr,
3889 (int)width,
3890 (int)count);
3891 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3892 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3893 e = JIM_ERR;
3894 break;
3895 }
3896 }
3897
3898 free(buffer);
3899
3900 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3901
3902 return e;
3903 }
3904
3905 /* FIX? should we propagate errors here rather than printing them
3906 * and continuing?
3907 */
3908 void target_handle_event(struct target *target, enum target_event e)
3909 {
3910 struct target_event_action *teap;
3911
3912 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3913 if (teap->event == e) {
3914 LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3915 target->target_number,
3916 target_name(target),
3917 target_type_name(target),
3918 e,
3919 Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3920 Jim_GetString(teap->body, NULL));
3921 if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK) {
3922 Jim_MakeErrorMessage(teap->interp);
3923 command_print(NULL, "%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
3924 }
3925 }
3926 }
3927 }
3928
3929 /**
3930 * Returns true only if the target has a handler for the specified event.
3931 */
3932 bool target_has_event_action(struct target *target, enum target_event event)
3933 {
3934 struct target_event_action *teap;
3935
3936 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3937 if (teap->event == event)
3938 return true;
3939 }
3940 return false;
3941 }
3942
3943 enum target_cfg_param {
3944 TCFG_TYPE,
3945 TCFG_EVENT,
3946 TCFG_WORK_AREA_VIRT,
3947 TCFG_WORK_AREA_PHYS,
3948 TCFG_WORK_AREA_SIZE,
3949 TCFG_WORK_AREA_BACKUP,
3950 TCFG_ENDIAN,
3951 TCFG_VARIANT,
3952 TCFG_COREID,
3953 TCFG_CHAIN_POSITION,
3954 TCFG_DBGBASE,
3955 TCFG_RTOS,
3956 };
3957
3958 static Jim_Nvp nvp_config_opts[] = {
3959 { .name = "-type", .value = TCFG_TYPE },
3960 { .name = "-event", .value = TCFG_EVENT },
3961 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3962 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3963 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3964 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3965 { .name = "-endian" , .value = TCFG_ENDIAN },
3966 { .name = "-variant", .value = TCFG_VARIANT },
3967 { .name = "-coreid", .value = TCFG_COREID },
3968 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3969 { .name = "-dbgbase", .value = TCFG_DBGBASE },
3970 { .name = "-rtos", .value = TCFG_RTOS },
3971 { .name = NULL, .value = -1 }
3972 };
3973
3974 static int target_configure(Jim_GetOptInfo *goi, struct target *target)
3975 {
3976 Jim_Nvp *n;
3977 Jim_Obj *o;
3978 jim_wide w;
3979 char *cp;
3980 int e;
3981
3982 /* parse config or cget options ... */
3983 while (goi->argc > 0) {
3984 Jim_SetEmptyResult(goi->interp);
3985 /* Jim_GetOpt_Debug(goi); */
3986
3987 if (target->type->target_jim_configure) {
3988 /* target defines a configure function */
3989 /* target gets first dibs on parameters */
3990 e = (*(target->type->target_jim_configure))(target, goi);
3991 if (e == JIM_OK) {
3992 /* more? */
3993 continue;
3994 }
3995 if (e == JIM_ERR) {
3996 /* An error */
3997 return e;
3998 }
3999 /* otherwise we 'continue' below */
4000 }
4001 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
4002 if (e != JIM_OK) {
4003 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
4004 return e;
4005 }
4006 switch (n->value) {
4007 case TCFG_TYPE:
4008 /* not setable */
4009 if (goi->isconfigure) {
4010 Jim_SetResultFormatted(goi->interp,
4011 "not settable: %s", n->name);
4012 return JIM_ERR;
4013 } else {
4014 no_params:
4015 if (goi->argc != 0) {
4016 Jim_WrongNumArgs(goi->interp,
4017 goi->argc, goi->argv,
4018 "NO PARAMS");
4019 return JIM_ERR;
4020 }
4021 }
4022 Jim_SetResultString(goi->interp,
4023 target_type_name(target), -1);
4024 /* loop for more */
4025 break;
4026 case TCFG_EVENT:
4027 if (goi->argc == 0) {
4028 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
4029 return JIM_ERR;
4030 }
4031
4032 e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
4033 if (e != JIM_OK) {
4034 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
4035 return e;
4036 }
4037
4038 if (goi->isconfigure) {
4039 if (goi->argc != 1) {
4040 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
4041 return JIM_ERR;
4042 }
4043 } else {
4044 if (goi->argc != 0) {
4045 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
4046 return JIM_ERR;
4047 }
4048 }
4049
4050 {
4051 struct target_event_action *teap;
4052
4053 teap = target->event_action;
4054 /* replace existing? */
4055 while (teap) {
4056 if (teap->event == (enum target_event)n->value)
4057 break;
4058 teap = teap->next;
4059 }
4060
4061 if (goi->isconfigure) {
4062 bool replace = true;
4063 if (teap == NULL) {
4064 /* create new */
4065 teap = calloc(1, sizeof(*teap));
4066 replace = false;
4067 }
4068 teap->event = n->value;
4069 teap->interp = goi->interp;
4070 Jim_GetOpt_Obj(goi, &o);
4071 if (teap->body)
4072 Jim_DecrRefCount(teap->interp, teap->body);
4073 teap->body = Jim_DuplicateObj(goi->interp, o);
4074 /*
4075 * FIXME:
4076 * Tcl/TK - "tk events" have a nice feature.
4077 * See the "BIND" command.
4078 * We should support that here.
4079 * You can specify %X and %Y in the event code.
4080 * The idea is: %T - target name.
4081 * The idea is: %N - target number
4082 * The idea is: %E - event name.
4083 */
4084 Jim_IncrRefCount(teap->body);
4085
4086 if (!replace) {
4087 /* add to head of event list */
4088 teap->next = target->event_action;
4089 target->event_action = teap;
4090 }
4091 Jim_SetEmptyResult(goi->interp);
4092 } else {
4093 /* get */
4094 if (teap == NULL)
4095 Jim_SetEmptyResult(goi->interp);
4096 else
4097 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
4098 }
4099 }
4100 /* loop for more */
4101 break;
4102
4103 case TCFG_WORK_AREA_VIRT:
4104 if (goi->isconfigure) {
4105 target_free_all_working_areas(target);
4106 e = Jim_GetOpt_Wide(goi, &w);
4107 if (e != JIM_OK)
4108 return e;
4109 target->working_area_virt = w;
4110 target->working_area_virt_spec = true;
4111 } else {
4112 if (goi->argc != 0)
4113 goto no_params;
4114 }
4115 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
4116 /* loop for more */
4117 break;
4118
4119 case TCFG_WORK_AREA_PHYS:
4120 if (goi->isconfigure) {
4121 target_free_all_working_areas(target);
4122 e = Jim_GetOpt_Wide(goi, &w);
4123 if (e != JIM_OK)
4124 return e;
4125 target->working_area_phys = w;
4126 target->working_area_phys_spec = true;
4127 } else {
4128 if (goi->argc != 0)
4129 goto no_params;
4130 }
4131 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
4132 /* loop for more */
4133 break;
4134
4135 case TCFG_WORK_AREA_SIZE:
4136 if (goi->isconfigure) {
4137 target_free_all_working_areas(target);
4138 e = Jim_GetOpt_Wide(goi, &w);
4139 if (e != JIM_OK)
4140 return e;
4141 target->working_area_size = w;
4142 } else {
4143 if (goi->argc != 0)
4144 goto no_params;
4145 }
4146 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
4147 /* loop for more */
4148 break;
4149
4150 case TCFG_WORK_AREA_BACKUP:
4151 if (goi->isconfigure) {
4152 target_free_all_working_areas(target);
4153 e = Jim_GetOpt_Wide(goi, &w);
4154 if (e != JIM_OK)
4155 return e;
4156 /* make this exactly 1 or 0 */
4157 target->backup_working_area = (!!w);
4158 } else {
4159 if (goi->argc != 0)
4160 goto no_params;
4161 }
4162 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
4163 /* loop for more e*/
4164 break;
4165
4166
4167 case TCFG_ENDIAN:
4168 if (goi->isconfigure) {
4169 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
4170 if (e != JIM_OK) {
4171 Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
4172 return e;
4173 }
4174 target->endianness = n->value;
4175 } else {
4176 if (goi->argc != 0)
4177 goto no_params;
4178 }
4179 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
4180 if (n->name == NULL) {
4181 target->endianness = TARGET_LITTLE_ENDIAN;
4182 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
4183 }
4184 Jim_SetResultString(goi->interp, n->name, -1);
4185 /* loop for more */
4186 break;
4187
4188 case TCFG_VARIANT:
4189 if (goi->isconfigure) {
4190 if (goi->argc < 1) {
4191 Jim_SetResultFormatted(goi->interp,
4192 "%s ?STRING?",
4193 n->name);
4194 return JIM_ERR;
4195 }
4196 if (target->variant)
4197 free((void *)(target->variant));
4198 e = Jim_GetOpt_String(goi, &cp, NULL);
4199 if (e != JIM_OK)
4200 return e;
4201 target->variant = strdup(cp);
4202 } else {
4203 if (goi->argc != 0)
4204 goto no_params;
4205 }
4206 Jim_SetResultString(goi->interp, target->variant, -1);
4207 /* loop for more */
4208 break;
4209
4210 case TCFG_COREID:
4211 if (goi->isconfigure) {
4212 e = Jim_GetOpt_Wide(goi, &w);
4213 if (e != JIM_OK)
4214 return e;
4215 target->coreid = (int32_t)w;
4216 } else {
4217 if (goi->argc != 0)
4218 goto no_params;
4219 }
4220 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
4221 /* loop for more */
4222 break;
4223
4224 case TCFG_CHAIN_POSITION:
4225 if (goi->isconfigure) {
4226 Jim_Obj *o_t;
4227 struct jtag_tap *tap;
4228 target_free_all_working_areas(target);
4229 e = Jim_GetOpt_Obj(goi, &o_t);
4230 if (e != JIM_OK)
4231 return e;
4232 tap = jtag_tap_by_jim_obj(goi->interp, o_t);
4233 if (tap == NULL)
4234 return JIM_ERR;
4235 /* make this exactly 1 or 0 */
4236 target->tap = tap;
4237 } else {
4238 if (goi->argc != 0)
4239 goto no_params;
4240 }
4241 Jim_SetResultString(goi->interp, target->tap->dotted_name, -1);
4242 /* loop for more e*/
4243 break;
4244 case TCFG_DBGBASE:
4245 if (goi->isconfigure) {
4246 e = Jim_GetOpt_Wide(goi, &w);
4247 if (e != JIM_OK)
4248 return e;
4249 target->dbgbase = (uint32_t)w;
4250 target->dbgbase_set = true;
4251 } else {
4252 if (goi->argc != 0)
4253 goto no_params;
4254 }
4255 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->dbgbase));
4256 /* loop for more */
4257 break;
4258
4259 case TCFG_RTOS:
4260 /* RTOS */
4261 {
4262 int result = rtos_create(goi, target);
4263 if (result != JIM_OK)
4264 return result;
4265 }
4266 /* loop for more */
4267 break;
4268 }
4269 } /* while (goi->argc) */
4270
4271
4272 /* done - we return */
4273 return JIM_OK;
4274 }
4275
4276 static int jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
4277 {
4278 Jim_GetOptInfo goi;
4279
4280 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4281 goi.isconfigure = !strcmp(Jim_GetString(argv[0], NULL), "configure");
4282 int need_args = 1 + goi.isconfigure;
4283 if (goi.argc < need_args) {
4284 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
4285 goi.isconfigure
4286 ? "missing: -option VALUE ..."
4287 : "missing: -option ...");
4288 return JIM_ERR;
4289 }
4290 struct target *target = Jim_CmdPrivData(goi.interp);
4291 return target_configure(&goi, target);
4292 }
4293
4294 static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4295 {
4296 const char *cmd_name = Jim_GetString(argv[0], NULL);
4297
4298 Jim_GetOptInfo goi;
4299 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4300
4301 if (goi.argc < 2 || goi.argc > 4) {
4302 Jim_SetResultFormatted(goi.interp,
4303 "usage: %s [phys] <address> <data> [<count>]", cmd_name);
4304 return JIM_ERR;
4305 }
4306
4307 target_write_fn fn;
4308 fn = target_write_memory_fast;
4309
4310 int e;
4311 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) {
4312 /* consume it */
4313 struct Jim_Obj *obj;
4314 e = Jim_GetOpt_Obj(&goi, &obj);
4315 if (e != JIM_OK)
4316 return e;
4317
4318 fn = target_write_phys_memory;
4319 }
4320
4321 jim_wide a;
4322 e = Jim_GetOpt_Wide(&goi, &a);
4323 if (e != JIM_OK)
4324 return e;
4325
4326 jim_wide b;
4327 e = Jim_GetOpt_Wide(&goi, &b);
4328 if (e != JIM_OK)
4329 return e;
4330
4331 jim_wide c = 1;
4332 if (goi.argc == 1) {
4333 e = Jim_GetOpt_Wide(&goi, &c);
4334 if (e != JIM_OK)
4335 return e;
4336 }
4337
4338 /* all args must be consumed */
4339 if (goi.argc != 0)
4340 return JIM_ERR;
4341
4342 struct target *target = Jim_CmdPrivData(goi.interp);
4343 unsigned data_size;
4344 if (strcasecmp(cmd_name, "mww") == 0)
4345 data_size = 4;
4346 else if (strcasecmp(cmd_name, "mwh") == 0)
4347 data_size = 2;
4348 else if (strcasecmp(cmd_name, "mwb") == 0)
4349 data_size = 1;
4350 else {
4351 LOG_ERROR("command '%s' unknown: ", cmd_name);
4352 return JIM_ERR;
4353 }
4354
4355 return (target_fill_mem(target, a, fn, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
4356 }
4357
4358 /**
4359 * @brief Reads an array of words/halfwords/bytes from target memory starting at specified address.
4360 *
4361 * Usage: mdw [phys] <address> [<count>] - for 32 bit reads
4362 * mdh [phys] <address> [<count>] - for 16 bit reads
4363 * mdb [phys] <address> [<count>] - for 8 bit reads
4364 *
4365 * Count defaults to 1.
4366 *
4367 * Calls target_read_memory or target_read_phys_memory depending on
4368 * the presence of the "phys" argument
4369 * Reads the target memory in blocks of max. 32 bytes, and returns an array of ints formatted
4370 * to int representation in base16.
4371 * Also outputs read data in a human readable form using command_print
4372 *
4373 * @param phys if present target_read_phys_memory will be used instead of target_read_memory
4374 * @param address address where to start the read. May be specified in decimal or hex using the standard "0x" prefix
4375 * @param count optional count parameter to read an array of values. If not specified, defaults to 1.
4376 * @returns: JIM_ERR on error or JIM_OK on success and sets the result string to an array of ascii formatted numbers
4377 * on success, with [<count>] number of elements.
4378 *
4379 * In case of little endian target:
4380 * Example1: "mdw 0x00000000" returns "10123456"
4381 * Exmaple2: "mdh 0x00000000 1" returns "3456"
4382 * Example3: "mdb 0x00000000" returns "56"
4383 * Example4: "mdh 0x00000000 2" returns "3456 1012"
4384 * Example5: "mdb 0x00000000 3" returns "56 34 12"
4385 **/
4386 static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4387 {
4388 const char *cmd_name = Jim_GetString(argv[0], NULL);
4389
4390 Jim_GetOptInfo goi;
4391 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4392
4393 if ((goi.argc < 1) || (goi.argc > 3)) {
4394 Jim_SetResultFormatted(goi.interp,
4395 "usage: %s [phys] <address> [<count>]", cmd_name);
4396 return JIM_ERR;
4397 }
4398
4399 int (*fn)(struct target *target,
4400 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
4401 fn = target_read_memory;
4402
4403 int e;
4404 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) {
4405 /* consume it */
4406 struct Jim_Obj *obj;
4407 e = Jim_GetOpt_Obj(&goi, &obj);
4408 if (e != JIM_OK)
4409 return e;
4410
4411 fn = target_read_phys_memory;
4412 }
4413
4414 /* Read address parameter */
4415 jim_wide addr;
4416 e = Jim_GetOpt_Wide(&goi, &addr);
4417 if (e != JIM_OK)
4418 return JIM_ERR;
4419
4420 /* If next parameter exists, read it out as the count parameter, if not, set it to 1 (default) */
4421 jim_wide count;
4422 if (goi.argc == 1) {
4423 e = Jim_GetOpt_Wide(&goi, &count);
4424 if (e != JIM_OK)
4425 return JIM_ERR;
4426 } else
4427 count = 1;
4428
4429 /* all args must be consumed */
4430 if (goi.argc != 0)
4431 return JIM_ERR;
4432
4433 jim_wide dwidth = 1; /* shut up gcc */
4434 if (strcasecmp(cmd_name, "mdw") == 0)
4435 dwidth = 4;
4436 else if (strcasecmp(cmd_name, "mdh") == 0)
4437 dwidth = 2;
4438 else if (strcasecmp(cmd_name, "mdb") == 0)
4439 dwidth = 1;
4440 else {
4441 LOG_ERROR("command '%s' unknown: ", cmd_name);
4442 return JIM_ERR;
4443 }
4444
4445 /* convert count to "bytes" */
4446 int bytes = count * dwidth;
4447
4448 struct target *target = Jim_CmdPrivData(goi.interp);
4449 uint8_t target_buf[32];
4450 jim_wide x, y, z;
4451 while (bytes > 0) {
4452 y = (bytes < 16) ? bytes : 16; /* y = min(bytes, 16); */
4453
4454 /* Try to read out next block */
4455 e = fn(target, addr, dwidth, y / dwidth, target_buf);
4456
4457 if (e != ERROR_OK) {
4458 Jim_SetResultFormatted(interp, "error reading target @ 0x%08lx", (long)addr);
4459 return JIM_ERR;
4460 }
4461
4462 command_print_sameline(NULL, "0x%08x ", (int)(addr));
4463 switch (dwidth) {
4464 case 4:
4465 for (x = 0; x < 16 && x < y; x += 4) {
4466 z = target_buffer_get_u32(target, &(target_buf[x]));
4467 command_print_sameline(NULL, "%08x ", (int)(z));
4468 }
4469 for (; (x < 16) ; x += 4)
4470 command_print_sameline(NULL, " ");
4471 break;
4472 case 2:
4473 for (x = 0; x < 16 && x < y; x += 2) {
4474 z = target_buffer_get_u16(target, &(target_buf[x]));
4475 command_print_sameline(NULL, "%04x ", (int)(z));
4476 }
4477 for (; (x < 16) ; x += 2)
4478 command_print_sameline(NULL, " ");
4479 break;
4480 case 1:
4481 default:
4482 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4483 z = target_buffer_get_u8(target, &(target_buf[x]));
4484 command_print_sameline(NULL, "%02x ", (int)(z));
4485 }
4486 for (; (x < 16) ; x += 1)
4487 command_print_sameline(NULL, " ");
4488 break;
4489 }
4490 /* ascii-ify the bytes */
4491 for (x = 0 ; x < y ; x++) {
4492 if ((target_buf[x] >= 0x20) &&
4493 (target_buf[x] <= 0x7e)) {
4494 /* good */
4495 } else {
4496 /* smack it */
4497 target_buf[x] = '.';
4498 }
4499 }
4500 /* space pad */
4501 while (x < 16) {
4502 target_buf[x] = ' ';
4503 x++;
4504 }
4505 /* terminate */
4506 target_buf[16] = 0;
4507 /* print - with a newline */
4508 command_print_sameline(NULL, "%s\n", target_buf);
4509 /* NEXT... */
4510 bytes -= 16;
4511 addr += 16;
4512 }
4513 return JIM_OK;
4514 }
4515
4516 static int jim_target_mem2array(Jim_Interp *interp,
4517 int argc, Jim_Obj *const *argv)
4518 {
4519 struct target *target = Jim_CmdPrivData(interp);
4520 return target_mem2array(interp, target, argc - 1, argv + 1);
4521 }
4522
4523 static int jim_target_array2mem(Jim_Interp *interp,
4524 int argc, Jim_Obj *const *argv)
4525 {
4526 struct target *target = Jim_CmdPrivData(interp);
4527 return target_array2mem(interp, target, argc - 1, argv + 1);
4528 }
4529
4530 static int jim_target_tap_disabled(Jim_Interp *interp)
4531 {
4532 Jim_SetResultFormatted(interp, "[TAP is disabled]");
4533 return JIM_ERR;
4534 }
4535
4536 static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4537 {
4538 if (argc != 1) {
4539 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4540 return JIM_ERR;
4541 }
4542 struct target *target = Jim_CmdPrivData(interp);
4543 if (!target->tap->enabled)
4544 return jim_target_tap_disabled(interp);
4545
4546 int e = target->type->examine(target);
4547 if (e != ERROR_OK)
4548 return JIM_ERR;
4549 return JIM_OK;
4550 }
4551
4552 static int jim_target_halt_gdb(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4553 {
4554 if (argc != 1) {
4555 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4556 return JIM_ERR;
4557 }
4558 struct target *target = Jim_CmdPrivData(interp);
4559
4560 if (target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT) != ERROR_OK)
4561 return JIM_ERR;
4562
4563 return JIM_OK;
4564 }
4565
4566 static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4567 {
4568 if (argc != 1) {
4569 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4570 return JIM_ERR;
4571 }
4572 struct target *target = Jim_CmdPrivData(interp);
4573 if (!target->tap->enabled)
4574 return jim_target_tap_disabled(interp);
4575
4576 int e;
4577 if (!(target_was_examined(target)))
4578 e = ERROR_TARGET_NOT_EXAMINED;
4579 else
4580 e = target->type->poll(target);
4581 if (e != ERROR_OK)
4582 return JIM_ERR;
4583 return JIM_OK;
4584 }
4585
4586 static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4587 {
4588 Jim_GetOptInfo goi;
4589 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4590
4591 if (goi.argc != 2) {
4592 Jim_WrongNumArgs(interp, 0, argv,
4593 "([tT]|[fF]|assert|deassert) BOOL");
4594 return JIM_ERR;
4595 }
4596
4597 Jim_Nvp *n;
4598 int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4599 if (e != JIM_OK) {
4600 Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4601 return e;
4602 }
4603 /* the halt or not param */
4604 jim_wide a;
4605 e = Jim_GetOpt_Wide(&goi, &a);
4606 if (e != JIM_OK)
4607 return e;
4608
4609 struct target *target = Jim_CmdPrivData(goi.interp);
4610 if (!target->tap->enabled)
4611 return jim_target_tap_disabled(interp);
4612 if (!(target_was_examined(target))) {
4613 LOG_ERROR("Target not examined yet");
4614 return ERROR_TARGET_NOT_EXAMINED;
4615 }
4616 if (!target->type->assert_reset || !target->type->deassert_reset) {
4617 Jim_SetResultFormatted(interp,
4618 "No target-specific reset for %s",
4619 target_name(target));
4620 return JIM_ERR;
4621 }
4622 /* determine if we should halt or not. */
4623 target->reset_halt = !!a;
4624 /* When this happens - all workareas are invalid. */
4625 target_free_all_working_areas_restore(target, 0);
4626
4627 /* do the assert */
4628 if (n->value == NVP_ASSERT)
4629 e = target->type->assert_reset(target);
4630 else
4631 e = target->type->deassert_reset(target);
4632 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4633 }
4634
4635 static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4636 {
4637 if (argc != 1) {
4638 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4639 return JIM_ERR;
4640 }
4641 struct target *target = Jim_CmdPrivData(interp);
4642 if (!target->tap->enabled)
4643 return jim_target_tap_disabled(interp);
4644 int e = target->type->halt(target);
4645 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4646 }
4647
4648 static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4649 {
4650 Jim_GetOptInfo goi;
4651 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4652
4653 /* params: <name> statename timeoutmsecs */
4654 if (goi.argc != 2) {
4655 const char *cmd_name = Jim_GetString(argv[0], NULL);
4656 Jim_SetResultFormatted(goi.interp,
4657 "%s <state_name> <timeout_in_msec>", cmd_name);
4658 return JIM_ERR;
4659 }
4660
4661 Jim_Nvp *n;
4662 int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4663 if (e != JIM_OK) {
4664 Jim_GetOpt_NvpUnknown(&goi, nvp_target_state, 1);
4665 return e;
4666 }
4667 jim_wide a;
4668 e = Jim_GetOpt_Wide(&goi, &a);
4669 if (e != JIM_OK)
4670 return e;
4671 struct target *target = Jim_CmdPrivData(interp);
4672 if (!target->tap->enabled)
4673 return jim_target_tap_disabled(interp);
4674
4675 e = target_wait_state(target, n->value, a);
4676 if (e != ERROR_OK) {
4677 Jim_Obj *eObj = Jim_NewIntObj(interp, e);
4678 Jim_SetResultFormatted(goi.interp,
4679 "target: %s wait %s fails (%#s) %s",
4680 target_name(target), n->name,
4681 eObj, target_strerror_safe(e));
4682 Jim_FreeNewObj(interp, eObj);
4683 return JIM_ERR;
4684 }
4685 return JIM_OK;
4686 }
4687 /* List for human, Events defined for this target.
4688 * scripts/programs should use 'name cget -event NAME'
4689 */
4690 static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4691 {
4692 struct command_context *cmd_ctx = current_command_context(interp);
4693 assert(cmd_ctx != NULL);
4694
4695 struct target *target = Jim_CmdPrivData(interp);
4696 struct target_event_action *teap = target->event_action;
4697 command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4698 target->target_number,
4699 target_name(target));
4700 command_print(cmd_ctx, "%-25s | Body", "Event");
4701 command_print(cmd_ctx, "------------------------- | "
4702 "----------------------------------------");
4703 while (teap) {
4704 Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
4705 command_print(cmd_ctx, "%-25s | %s",
4706 opt->name, Jim_GetString(teap->body, NULL));
4707 teap = teap->next;
4708 }
4709 command_print(cmd_ctx, "***END***");
4710 return JIM_OK;
4711 }
4712 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4713 {
4714 if (argc != 1) {
4715 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4716 return JIM_ERR;
4717 }
4718 struct target *target = Jim_CmdPrivData(interp);
4719 Jim_SetResultString(interp, target_state_name(target), -1);
4720 return JIM_OK;
4721 }
4722 static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4723 {
4724 Jim_GetOptInfo goi;
4725 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4726 if (goi.argc != 1) {
4727 const char *cmd_name = Jim_GetString(argv[0], NULL);
4728 Jim_SetResultFormatted(goi.interp, "%s <eventname>", cmd_name);
4729 return JIM_ERR;
4730 }
4731 Jim_Nvp *n;
4732 int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4733 if (e != JIM_OK) {
4734 Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4735 return e;
4736 }
4737 struct target *target = Jim_CmdPrivData(interp);
4738 target_handle_event(target, n->value);
4739 return JIM_OK;
4740 }
4741
4742 static const struct command_registration target_instance_command_handlers[] = {
4743 {
4744 .name = "configure",
4745 .mode = COMMAND_CONFIG,
4746 .jim_handler = jim_target_configure,
4747 .help = "configure a new target for use",
4748 .usage = "[target_attribute ...]",
4749 },
4750 {
4751 .name = "cget",
4752 .mode = COMMAND_ANY,
4753 .jim_handler = jim_target_configure,
4754 .help = "returns the specified target attribute",
4755 .usage = "target_attribute",
4756 },
4757 {
4758 .name = "mww",
4759 .mode = COMMAND_EXEC,
4760 .jim_handler = jim_target_mw,
4761 .help = "Write 32-bit word(s) to target memory",
4762 .usage = "address data [count]",
4763 },
4764 {
4765 .name = "mwh",
4766 .mode = COMMAND_EXEC,
4767 .jim_handler = jim_target_mw,
4768 .help = "Write 16-bit half-word(s) to target memory",
4769 .usage = "address data [count]",
4770 },
4771 {
4772 .name = "mwb",
4773 .mode = COMMAND_EXEC,
4774 .jim_handler = jim_target_mw,
4775 .help = "Write byte(s) to target memory",
4776 .usage = "address data [count]",
4777 },
4778 {
4779 .name = "mdw",
4780 .mode = COMMAND_EXEC,
4781 .jim_handler = jim_target_md,
4782 .help = "Display target memory as 32-bit words",
4783 .usage = "address [count]",
4784 },
4785 {
4786 .name = "mdh",
4787 .mode = COMMAND_EXEC,
4788 .jim_handler = jim_target_md,
4789 .help = "Display target memory as 16-bit half-words",
4790 .usage = "address [count]",
4791 },
4792 {
4793 .name = "mdb",
4794 .mode = COMMAND_EXEC,
4795 .jim_handler = jim_target_md,
4796 .help = "Display target memory as 8-bit bytes",
4797 .usage = "address [count]",
4798 },
4799 {
4800 .name = "array2mem",
4801 .mode = COMMAND_EXEC,
4802 .jim_handler = jim_target_array2mem,
4803 .help = "Writes Tcl array of 8/16/32 bit numbers "
4804 "to target memory",
4805 .usage = "arrayname bitwidth address count",
4806 },
4807 {
4808 .name = "mem2array",
4809 .mode = COMMAND_EXEC,
4810 .jim_handler = jim_target_mem2array,
4811 .help = "Loads Tcl array of 8/16/32 bit numbers "
4812 "from target memory",
4813 .usage = "arrayname bitwidth address count",
4814 },
4815 {
4816 .name = "eventlist",
4817 .mode = COMMAND_EXEC,
4818 .jim_handler = jim_target_event_list,
4819 .help = "displays a table of events defined for this target",
4820 },
4821 {
4822 .name = "curstate",
4823 .mode = COMMAND_EXEC,
4824 .jim_handler = jim_target_current_state,
4825 .help = "displays the current state of this target",
4826 },
4827 {
4828 .name = "arp_examine",
4829 .mode = COMMAND_EXEC,
4830 .jim_handler = jim_target_examine,
4831 .help = "used internally for reset processing",
4832 },
4833 {
4834 .name = "arp_halt_gdb",
4835 .mode = COMMAND_EXEC,
4836 .jim_handler = jim_target_halt_gdb,
4837 .help = "used internally for reset processing to halt GDB",
4838 },
4839 {
4840 .name = "arp_poll",
4841 .mode = COMMAND_EXEC,
4842 .jim_handler = jim_target_poll,
4843 .help = "used internally for reset processing",
4844 },
4845 {
4846 .name = "arp_reset",
4847 .mode = COMMAND_EXEC,
4848 .jim_handler = jim_target_reset,
4849 .help = "used internally for reset processing",
4850 },
4851 {
4852 .name = "arp_halt",
4853 .mode = COMMAND_EXEC,
4854 .jim_handler = jim_target_halt,
4855 .help = "used internally for reset processing",
4856 },
4857 {
4858 .name = "arp_waitstate",
4859 .mode = COMMAND_EXEC,
4860 .jim_handler = jim_target_wait_state,
4861 .help = "used internally for reset processing",
4862 },
4863 {
4864 .name = "invoke-event",
4865 .mode = COMMAND_EXEC,
4866 .jim_handler = jim_target_invoke_event,
4867 .help = "invoke handler for specified event",
4868 .usage = "event_name",
4869 },
4870 COMMAND_REGISTRATION_DONE
4871 };
4872
4873 static int target_create(Jim_GetOptInfo *goi)
4874 {
4875 Jim_Obj *new_cmd;
4876 Jim_Cmd *cmd;
4877 const char *cp;
4878 char *cp2;
4879 int e;
4880 int x;
4881 struct target *target;
4882 struct command_context *cmd_ctx;
4883
4884 cmd_ctx = current_command_context(goi->interp);
4885 assert(cmd_ctx != NULL);
4886
4887 if (goi->argc < 3) {
4888 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4889 return JIM_ERR;
4890 }
4891
4892 /* COMMAND */
4893 Jim_GetOpt_Obj(goi, &new_cmd);
4894 /* does this command exist? */
4895 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4896 if (cmd) {
4897 cp = Jim_GetString(new_cmd, NULL);
4898 Jim_SetResultFormatted(goi->interp, "Command/target: %s Exists", cp);
4899 return JIM_ERR;
4900 }
4901
4902 /* TYPE */
4903 e = Jim_GetOpt_String(goi, &cp2, NULL);
4904 if (e != JIM_OK)
4905 return e;
4906 cp = cp2;
4907 /* now does target type exist */
4908 for (x = 0 ; target_types[x] ; x++) {
4909 if (0 == strcmp(cp, target_types[x]->name)) {
4910 /* found */
4911 break;
4912 }
4913
4914 /* check for deprecated name */
4915 if (target_types[x]->deprecated_name) {
4916 if (0 == strcmp(cp, target_types[x]->deprecated_name)) {
4917 /* found */
4918 LOG_WARNING("target name is deprecated use: \'%s\'", target_types[x]->name);
4919 break;
4920 }
4921 }
4922 }
4923 if (target_types[x] == NULL) {
4924 Jim_SetResultFormatted(goi->interp, "Unknown target type %s, try one of ", cp);
4925 for (x = 0 ; target_types[x] ; x++) {
4926 if (target_types[x + 1]) {
4927 Jim_AppendStrings(goi->interp,
4928 Jim_GetResult(goi->interp),
4929 target_types[x]->name,
4930 ", ", NULL);
4931 } else {
4932 Jim_AppendStrings(goi->interp,
4933 Jim_GetResult(goi->interp),
4934 " or ",
4935 target_types[x]->name, NULL);
4936 }
4937 }
4938 return JIM_ERR;
4939 }
4940
4941 /* Create it */
4942 target = calloc(1, sizeof(struct target));
4943 /* set target number */
4944 target->target_number = new_target_number();
4945
4946 /* allocate memory for each unique target type */
4947 target->type = (struct target_type *)calloc(1, sizeof(struct target_type));
4948
4949 memcpy(target->type, target_types[x], sizeof(struct target_type));
4950
4951 /* will be set by "-endian" */
4952 target->endianness = TARGET_ENDIAN_UNKNOWN;
4953
4954 /* default to first core, override with -coreid */
4955 target->coreid = 0;
4956
4957 target->working_area = 0x0;
4958 target->working_area_size = 0x0;
4959 target->working_areas = NULL;
4960 target->backup_working_area = 0;
4961
4962 target->state = TARGET_UNKNOWN;
4963 target->debug_reason = DBG_REASON_UNDEFINED;
4964 target->reg_cache = NULL;
4965 target->breakpoints = NULL;
4966 target->watchpoints = NULL;
4967 target->next = NULL;
4968 target->arch_info = NULL;
4969
4970 target->display = 1;
4971
4972 target->halt_issued = false;
4973
4974 /* initialize trace information */
4975 target->trace_info = malloc(sizeof(struct trace));
4976 target->trace_info->num_trace_points = 0;
4977 target->trace_info->trace_points_size = 0;
4978 target->trace_info->trace_points = NULL;
4979 target->trace_info->trace_history_size = 0;
4980 target->trace_info->trace_history = NULL;
4981 target->trace_info->trace_history_pos = 0;
4982 target->trace_info->trace_history_overflowed = 0;
4983
4984 target->dbgmsg = NULL;
4985 target->dbg_msg_enabled = 0;
4986
4987 target->endianness = TARGET_ENDIAN_UNKNOWN;
4988
4989 target->rtos = NULL;
4990 target->rtos_auto_detect = false;
4991
4992 /* Do the rest as "configure" options */
4993 goi->isconfigure = 1;
4994 e = target_configure(goi, target);
4995
4996 if (target->tap == NULL) {
4997 Jim_SetResultString(goi->interp, "-chain-position required when creating target", -1);
4998 e = JIM_ERR;
4999 }
5000
5001 if (e != JIM_OK) {
5002 free(target->type);
5003 free(target);
5004 return e;
5005 }
5006
5007 if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
5008 /* default endian to little if not specified */
5009 target->endianness = TARGET_LITTLE_ENDIAN;
5010 }
5011
5012 /* incase variant is not set */
5013 if (!target->variant)
5014 target->variant = strdup("");
5015
5016 cp = Jim_GetString(new_cmd, NULL);
5017 target->cmd_name = strdup(cp);
5018
5019 /* create the target specific commands */
5020 if (target->type->commands) {
5021 e = register_commands(cmd_ctx, NULL, target->type->commands);
5022 if (ERROR_OK != e)
5023 LOG_ERROR("unable to register '%s' commands", cp);
5024 }
5025 if (target->type->target_create)
5026 (*(target->type->target_create))(target, goi->interp);
5027
5028 /* append to end of list */
5029 {
5030 struct target **tpp;
5031 tpp = &(all_targets);
5032 while (*tpp)
5033 tpp = &((*tpp)->next);
5034 *tpp = target;
5035 }
5036
5037 /* now - create the new target name command */
5038 const const struct command_registration target_subcommands[] = {
5039 {
5040 .chain = target_instance_command_handlers,
5041 },
5042 {
5043 .chain = target->type->commands,
5044 },
5045 COMMAND_REGISTRATION_DONE
5046 };
5047 const const struct command_registration target_commands[] = {
5048 {
5049 .name = cp,
5050 .mode = COMMAND_ANY,
5051 .help = "target command group",
5052 .usage = "",
5053 .chain = target_subcommands,
5054 },
5055 COMMAND_REGISTRATION_DONE
5056 };
5057 e = register_commands(cmd_ctx, NULL, target_commands);
5058 if (ERROR_OK != e)
5059 return JIM_ERR;
5060
5061 struct command *c = command_find_in_context(cmd_ctx, cp);
5062 assert(c);
5063 command_set_handler_data(c, target);
5064
5065 return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
5066 }
5067
5068 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5069 {
5070 if (argc != 1) {
5071 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5072 return JIM_ERR;
5073 }
5074 struct command_context *cmd_ctx = current_command_context(interp);
5075 assert(cmd_ctx != NULL);
5076
5077 Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
5078 return JIM_OK;
5079 }
5080
5081 static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5082 {
5083 if (argc != 1) {
5084 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5085 return JIM_ERR;
5086 }
5087 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
5088 for (unsigned x = 0; NULL != target_types[x]; x++) {
5089 Jim_ListAppendElement(interp, Jim_GetResult(interp),
5090 Jim_NewStringObj(interp, target_types[x]->name, -1));
5091 }
5092 return JIM_OK;
5093 }
5094
5095 static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5096 {
5097 if (argc != 1) {
5098 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5099 return JIM_ERR;
5100 }
5101 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
5102 struct target *target = all_targets;
5103 while (target) {
5104 Jim_ListAppendElement(interp, Jim_GetResult(interp),
5105 Jim_NewStringObj(interp, target_name(target), -1));
5106 target = target->next;
5107 }
5108 return JIM_OK;
5109 }
5110
5111 static int jim_target_smp(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5112 {
5113 int i;
5114 const char *targetname;
5115 int retval, len;
5116 struct target *target = (struct target *) NULL;
5117 struct target_list *head, *curr, *new;
5118 curr = (struct target_list *) NULL;
5119 head = (struct target_list *) NULL;
5120
5121 retval = 0;
5122 LOG_DEBUG("%d", argc);
5123 /* argv[1] = target to associate in smp
5124 * argv[2] = target to assoicate in smp
5125 * argv[3] ...
5126 */
5127
5128 for (i = 1; i < argc; i++) {
5129
5130 targetname = Jim_GetString(argv[i], &len);
5131 target = get_target(targetname);
5132 LOG_DEBUG("%s ", targetname);
5133 if (target) {
5134 new = malloc(sizeof(struct target_list));
5135 new->target = target;
5136 new->next = (struct target_list *)NULL;
5137 if (head == (struct target_list *)NULL) {
5138 head = new;
5139 curr = head;
5140 } else {
5141 curr->next = new;
5142 curr = new;
5143 }
5144 }
5145 }
5146 /* now parse the list of cpu and put the target in smp mode*/
5147 curr = head;
5148
5149 while (curr != (struct target_list *)NULL) {
5150 target = curr->target;
5151 target->smp = 1;
5152 target->head = head;
5153 curr = curr->next;
5154 }
5155
5156 if (target && target->rtos)
5157 retval = rtos_smp_init(head->target);
5158
5159 return retval;
5160 }
5161
5162
5163 static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5164 {
5165 Jim_GetOptInfo goi;
5166 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
5167 if (goi.argc < 3) {
5168 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
5169 "<name> <target_type> [<target_options> ...]");
5170 return JIM_ERR;
5171 }
5172 return target_create(&goi);
5173 }
5174
5175 static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5176 {
5177 Jim_GetOptInfo goi;
5178 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
5179
5180 /* It's OK to remove this mechanism sometime after August 2010 or so */
5181 LOG_WARNING("don't use numbers as target identifiers; use names");
5182 if (goi.argc != 1) {
5183 Jim_SetResultFormatted(goi.interp, "usage: target number <number>");
5184 return JIM_ERR;
5185 }
5186 jim_wide w;
5187 int e = Jim_GetOpt_Wide(&goi, &w);
5188 if (e != JIM_OK)
5189 return JIM_ERR;
5190
5191 struct target *target;
5192 for (target = all_targets; NULL != target; target = target->next) {
5193 if (target->target_number != w)
5194 continue;
5195
5196 Jim_SetResultString(goi.interp, target_name(target), -1);
5197 return JIM_OK;
5198 }
5199 {
5200 Jim_Obj *wObj = Jim_NewIntObj(goi.interp, w);
5201 Jim_SetResultFormatted(goi.interp,
5202 "Target: number %#s does not exist", wObj);
5203 Jim_FreeNewObj(interp, wObj);
5204 }
5205 return JIM_ERR;
5206 }
5207
5208 static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5209 {
5210 if (argc != 1) {
5211 Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
5212 return JIM_ERR;
5213 }
5214 unsigned count = 0;
5215 struct target *target = all_targets;
5216 while (NULL != target) {
5217 target = target->next;
5218 count++;
5219 }
5220 Jim_SetResult(interp, Jim_NewIntObj(interp, count));
5221 return JIM_OK;
5222 }
5223
5224 static const struct command_registration target_subcommand_handlers[] = {
5225 {
5226 .name = "init",
5227 .mode = COMMAND_CONFIG,
5228 .handler = handle_target_init_command,
5229 .help = "initialize targets",
5230 },
5231 {
5232 .name = "create",
5233 /* REVISIT this should be COMMAND_CONFIG ... */
5234 .mode = COMMAND_ANY,
5235 .jim_handler = jim_target_create,
5236 .usage = "name type '-chain-position' name [options ...]",
5237 .help = "Creates and selects a new target",
5238 },
5239 {
5240 .name = "current",
5241 .mode = COMMAND_ANY,
5242 .jim_handler = jim_target_current,
5243 .help = "Returns the currently selected target",
5244 },
5245 {
5246 .name = "types",
5247 .mode = COMMAND_ANY,
5248 .jim_handler = jim_target_types,
5249 .help = "Returns the available target types as "
5250 "a list of strings",
5251 },
5252 {
5253 .name = "names",
5254 .mode = COMMAND_ANY,
5255 .jim_handler = jim_target_names,
5256 .help = "Returns the names of all targets as a list of strings",
5257 },
5258 {
5259 .name = "number",
5260 .mode = COMMAND_ANY,
5261 .jim_handler = jim_target_number,
5262 .usage = "number",
5263 .help = "Returns the name of the numbered target "
5264 "(DEPRECATED)",
5265 },
5266 {
5267 .name = "count",
5268 .mode = COMMAND_ANY,
5269 .jim_handler = jim_target_count,
5270 .help = "Returns the number of targets as an integer "
5271 "(DEPRECATED)",
5272 },
5273 {
5274 .name = "smp",
5275 .mode = COMMAND_ANY,
5276 .jim_handler = jim_target_smp,
5277 .usage = "targetname1 targetname2 ...",
5278 .help = "gather several target in a smp list"
5279 },
5280
5281 COMMAND_REGISTRATION_DONE
5282 };
5283
5284 struct FastLoad {
5285 uint32_t address;
5286 uint8_t *data;
5287 int length;
5288
5289 };
5290
5291 static int fastload_num;
5292 static struct FastLoad *fastload;
5293
5294 static void free_fastload(void)
5295 {
5296 if (fastload != NULL) {
5297 int i;
5298 for (i = 0; i < fastload_num; i++) {
5299 if (fastload[i].data)
5300 free(fastload[i].data);
5301 }
5302 free(fastload);
5303 fastload = NULL;
5304 }
5305 }
5306
5307 COMMAND_HANDLER(handle_fast_load_image_command)
5308 {
5309 uint8_t *buffer;
5310 size_t buf_cnt;
5311 uint32_t image_size;
5312 uint32_t min_address = 0;
5313 uint32_t max_address = 0xffffffff;
5314 int i;
5315
5316 struct image image;
5317
5318 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
5319 &image, &min_address, &max_address);
5320 if (ERROR_OK != retval)
5321 return retval;
5322
5323 struct duration bench;
5324 duration_start(&bench);
5325
5326 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
5327 if (retval != ERROR_OK)
5328 return retval;
5329
5330 image_size = 0x0;
5331 retval = ERROR_OK;
5332 fastload_num = image.num_sections;
5333 fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
5334 if (fastload == NULL) {
5335 command_print(CMD_CTX, "out of memory");
5336 image_close(&image);
5337 return ERROR_FAIL;
5338 }
5339 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
5340 for (i = 0; i < image.num_sections; i++) {
5341 buffer = malloc(image.sections[i].size);
5342 if (buffer == NULL) {
5343 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
5344 (int)(image.sections[i].size));
5345 retval = ERROR_FAIL;
5346 break;
5347 }
5348
5349 retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
5350 if (retval != ERROR_OK) {
5351 free(buffer);
5352 break;
5353 }
5354
5355 uint32_t offset = 0;
5356 uint32_t length = buf_cnt;
5357
5358 /* DANGER!!! beware of unsigned comparision here!!! */
5359
5360 if ((image.sections[i].base_address + buf_cnt >= min_address) &&
5361 (image.sections[i].base_address < max_address)) {
5362 if (image.sections[i].base_address < min_address) {
5363 /* clip addresses below */
5364 offset += min_address-image.sections[i].base_address;
5365 length -= offset;
5366 }
5367
5368 if (image.sections[i].base_address + buf_cnt > max_address)
5369 length -= (image.sections[i].base_address + buf_cnt)-max_address;
5370
5371 fastload[i].address = image.sections[i].base_address + offset;
5372 fastload[i].data = malloc(length);
5373 if (fastload[i].data == NULL) {
5374 free(buffer);
5375 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
5376 length);
5377 retval = ERROR_FAIL;
5378 break;
5379 }
5380 memcpy(fastload[i].data, buffer + offset, length);
5381 fastload[i].length = length;
5382
5383 image_size += length;
5384 command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
5385 (unsigned int)length,
5386 ((unsigned int)(image.sections[i].base_address + offset)));
5387 }
5388
5389 free(buffer);
5390 }
5391
5392 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
5393 command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
5394 "in %fs (%0.3f KiB/s)", image_size,
5395 duration_elapsed(&bench), duration_kbps(&bench, image_size));
5396
5397 command_print(CMD_CTX,
5398 "WARNING: image has not been loaded to target!"
5399 "You can issue a 'fast_load' to finish loading.");
5400 }
5401
5402 image_close(&image);
5403
5404 if (retval != ERROR_OK)
5405 free_fastload();
5406
5407 return retval;
5408 }
5409
5410 COMMAND_HANDLER(handle_fast_load_command)
5411 {
5412 if (CMD_ARGC > 0)
5413 return ERROR_COMMAND_SYNTAX_ERROR;
5414 if (fastload == NULL) {
5415 LOG_ERROR("No image in memory");
5416 return ERROR_FAIL;
5417 }
5418 int i;
5419 int ms = timeval_ms();
5420 int size = 0;
5421 int retval = ERROR_OK;
5422 for (i = 0; i < fastload_num; i++) {
5423 struct target *target = get_current_target(CMD_CTX);
5424 command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
5425 (unsigned int)(fastload[i].address),
5426 (unsigned int)(fastload[i].length));
5427 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
5428 if (retval != ERROR_OK)
5429 break;
5430 size += fastload[i].length;
5431 }
5432 if (retval == ERROR_OK) {
5433 int after = timeval_ms();
5434 command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
5435 }
5436 return retval;
5437 }
5438
5439 static const struct command_registration target_command_handlers[] = {
5440 {
5441 .name = "targets",
5442 .handler = handle_targets_command,
5443 .mode = COMMAND_ANY,
5444 .help = "change current default target (one parameter) "
5445 "or prints table of all targets (no parameters)",
5446 .usage = "[target]",
5447 },
5448 {
5449 .name = "target",
5450 .mode = COMMAND_CONFIG,
5451 .help = "configure target",
5452
5453 .chain = target_subcommand_handlers,
5454 },
5455 COMMAND_REGISTRATION_DONE
5456 };
5457
5458 int target_register_commands(struct command_context *cmd_ctx)
5459 {
5460 return register_commands(cmd_ctx, NULL, target_command_handlers);
5461 }
5462
5463 static bool target_reset_nag = true;
5464
5465 bool get_target_reset_nag(void)
5466 {
5467 return target_reset_nag;
5468 }
5469
5470 COMMAND_HANDLER(handle_target_reset_nag)
5471 {
5472 return CALL_COMMAND_HANDLER(handle_command_parse_bool,
5473 &target_reset_nag, "Nag after each reset about options to improve "
5474 "performance");
5475 }
5476
5477 COMMAND_HANDLER(handle_ps_command)
5478 {
5479 struct target *target = get_current_target(CMD_CTX);
5480 char *display;
5481 if (target->state != TARGET_HALTED) {
5482 LOG_INFO("target not halted !!");
5483 return ERROR_OK;
5484 }
5485
5486 if ((target->rtos) && (target->rtos->type)
5487 && (target->rtos->type->ps_command)) {
5488 display = target->rtos->type->ps_command(target);
5489 command_print(CMD_CTX, "%s", display);
5490 free(display);
5491 return ERROR_OK;
5492 } else {
5493 LOG_INFO("failed");
5494 return ERROR_TARGET_FAILURE;
5495 }
5496 }
5497
5498 static const struct command_registration target_exec_command_handlers[] = {
5499 {
5500 .name = "fast_load_image",
5501 .handler = handle_fast_load_image_command,
5502 .mode = COMMAND_ANY,
5503 .help = "Load image into server memory for later use by "
5504 "fast_load; primarily for profiling",
5505 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5506 "[min_address [max_length]]",
5507 },
5508 {
5509 .name = "fast_load",
5510 .handler = handle_fast_load_command,
5511 .mode = COMMAND_EXEC,
5512 .help = "loads active fast load image to current target "
5513 "- mainly for profiling purposes",
5514 .usage = "",
5515 },
5516 {
5517 .name = "profile",
5518 .handler = handle_profile_command,
5519 .mode = COMMAND_EXEC,
5520 .usage = "seconds filename",
5521 .help = "profiling samples the CPU PC",
5522 },
5523 /** @todo don't register virt2phys() unless target supports it */
5524 {
5525 .name = "virt2phys",
5526 .handler = handle_virt2phys_command,
5527 .mode = COMMAND_ANY,
5528 .help = "translate a virtual address into a physical address",
5529 .usage = "virtual_address",
5530 },
5531 {
5532 .name = "reg",
5533 .handler = handle_reg_command,
5534 .mode = COMMAND_EXEC,
5535 .help = "display or set a register; with no arguments, "
5536 "displays all registers and their values",
5537 .usage = "[(register_name|register_number) [value]]",
5538 },
5539 {
5540 .name = "poll",
5541 .handler = handle_poll_command,
5542 .mode = COMMAND_EXEC,
5543 .help = "poll target state; or reconfigure background polling",
5544 .usage = "['on'|'off']",
5545 },
5546 {
5547 .name = "wait_halt",
5548 .handler = handle_wait_halt_command,
5549 .mode = COMMAND_EXEC,
5550 .help = "wait up to the specified number of milliseconds "
5551 "(default 5) for a previously requested halt",
5552 .usage = "[milliseconds]",
5553 },
5554 {
5555 .name = "halt",
5556 .handler = handle_halt_command,
5557 .mode = COMMAND_EXEC,
5558 .help = "request target to halt, then wait up to the specified"
5559 "number of milliseconds (default 5) for it to complete",
5560 .usage = "[milliseconds]",
5561 },
5562 {
5563 .name = "resume",
5564 .handler = handle_resume_command,
5565 .mode = COMMAND_EXEC,
5566 .help = "resume target execution from current PC or address",
5567 .usage = "[address]",
5568 },
5569 {
5570 .name = "reset",
5571 .handler = handle_reset_command,
5572 .mode = COMMAND_EXEC,
5573 .usage = "[run|halt|init]",
5574 .help = "Reset all targets into the specified mode."
5575 "Default reset mode is run, if not given.",
5576 },
5577 {
5578 .name = "soft_reset_halt",
5579 .handler = handle_soft_reset_halt_command,
5580 .mode = COMMAND_EXEC,
5581 .usage = "",
5582 .help = "halt the target and do a soft reset",
5583 },
5584 {
5585 .name = "step",
5586 .handler = handle_step_command,
5587 .mode = COMMAND_EXEC,
5588 .help = "step one instruction from current PC or address",
5589 .usage = "[address]",
5590 },
5591 {
5592 .name = "mdw",
5593 .handler = handle_md_command,
5594 .mode = COMMAND_EXEC,
5595 .help = "display memory words",
5596 .usage = "['phys'] address [count]",
5597 },
5598 {
5599 .name = "mdh",
5600 .handler = handle_md_command,
5601 .mode = COMMAND_EXEC,
5602 .help = "display memory half-words",
5603 .usage = "['phys'] address [count]",
5604 },
5605 {
5606 .name = "mdb",
5607 .handler = handle_md_command,
5608 .mode = COMMAND_EXEC,
5609 .help = "display memory bytes",
5610 .usage = "['phys'] address [count]",
5611 },
5612 {
5613 .name = "mww",
5614 .handler = handle_mw_command,
5615 .mode = COMMAND_EXEC,
5616 .help = "write memory word",
5617 .usage = "['phys'] address value [count]",
5618 },
5619 {
5620 .name = "mwh",
5621 .handler = handle_mw_command,
5622 .mode = COMMAND_EXEC,
5623 .help = "write memory half-word",
5624 .usage = "['phys'] address value [count]",
5625 },
5626 {
5627 .name = "mwb",
5628 .handler = handle_mw_command,
5629 .mode = COMMAND_EXEC,
5630 .help = "write memory byte",
5631 .usage = "['phys'] address value [count]",
5632 },
5633 {
5634 .name = "bp",
5635 .handler = handle_bp_command,
5636 .mode = COMMAND_EXEC,
5637 .help = "list or set hardware or software breakpoint",
5638 .usage = "<address> [<asid>]<length> ['hw'|'hw_ctx']",
5639 },
5640 {
5641 .name = "rbp",
5642 .handler = handle_rbp_command,
5643 .mode = COMMAND_EXEC,
5644 .help = "remove breakpoint",
5645 .usage = "address",
5646 },
5647 {
5648 .name = "wp",
5649 .handler = handle_wp_command,
5650 .mode = COMMAND_EXEC,
5651 .help = "list (no params) or create watchpoints",
5652 .usage = "[address length [('r'|'w'|'a') value [mask]]]",
5653 },
5654 {
5655 .name = "rwp",
5656 .handler = handle_rwp_command,
5657 .mode = COMMAND_EXEC,
5658 .help = "remove watchpoint",
5659 .usage = "address",
5660 },
5661 {
5662 .name = "load_image",
5663 .handler = handle_load_image_command,
5664 .mode = COMMAND_EXEC,
5665 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5666 "[min_address] [max_length]",
5667 },
5668 {
5669 .name = "dump_image",
5670 .handler = handle_dump_image_command,
5671 .mode = COMMAND_EXEC,
5672 .usage = "filename address size",
5673 },
5674 {
5675 .name = "verify_image",
5676 .handler = handle_verify_image_command,
5677 .mode = COMMAND_EXEC,
5678 .usage = "filename [offset [type]]",
5679 },
5680 {
5681 .name = "test_image",
5682 .handler = handle_test_image_command,
5683 .mode = COMMAND_EXEC,
5684 .usage = "filename [offset [type]]",
5685 },
5686 {
5687 .name = "mem2array",
5688 .mode = COMMAND_EXEC,
5689 .jim_handler = jim_mem2array,
5690 .help = "read 8/16/32 bit memory and return as a TCL array "
5691 "for script processing",
5692 .usage = "arrayname bitwidth address count",
5693 },
5694 {
5695 .name = "array2mem",
5696 .mode = COMMAND_EXEC,
5697 .jim_handler = jim_array2mem,
5698 .help = "convert a TCL array to memory locations "
5699 "and write the 8/16/32 bit values",
5700 .usage = "arrayname bitwidth address count",
5701 },
5702 {
5703 .name = "reset_nag",
5704 .handler = handle_target_reset_nag,
5705 .mode = COMMAND_ANY,
5706 .help = "Nag after each reset about options that could have been "
5707 "enabled to improve performance. ",
5708 .usage = "['enable'|'disable']",
5709 },
5710 {
5711 .name = "ps",
5712 .handler = handle_ps_command,
5713 .mode = COMMAND_EXEC,
5714 .help = "list all tasks ",
5715 .usage = " ",
5716 },
5717
5718 COMMAND_REGISTRATION_DONE
5719 };
5720 static int target_register_user_commands(struct command_context *cmd_ctx)
5721 {
5722 int retval = ERROR_OK;
5723 retval = target_request_register_commands(cmd_ctx);
5724 if (retval != ERROR_OK)
5725 return retval;
5726
5727 retval = trace_register_commands(cmd_ctx);
5728 if (retval != ERROR_OK)
5729 return retval;
5730
5731
5732 return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
5733 }
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)