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