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