Code Review / openocd.git / blob
? search:


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