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