Code Review / openocd.git / blob
? search:


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