Code Review / openocd.git / blob
? search:


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