Code Review / openocd.git / blob
? search:


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