Code Review / openocd.git / blob
? search:


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