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