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