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