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