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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)