Code Review / openocd.git / blob
? search:


692b78f8b10304428ed735406c3717ceaf1f66d9
[openocd.git] / src / target / target.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * Copyright (C) 2008 by Rick Altherr *
15 * kc8apf@kc8apf.net> *
16 * *
17 * Copyright (C) 2011 by Broadcom Corporation *
18 * Evan Hunter - ehunter@broadcom.com *
19 * *
20 * Copyright (C) ST-Ericsson SA 2011 *
21 * michel.jaouen@stericsson.com : smp minimum support *
22 * *
23 * 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[560];
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 retval = fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY);
2813 if (retval != ERROR_OK)
2814 return retval;
2815
2816 duration_start(&bench);
2817
2818 retval = ERROR_OK;
2819 while (size > 0)
2820 {
2821 size_t size_written;
2822 uint32_t this_run_size = (size > 560) ? 560 : size;
2823 retval = target_read_buffer(target, address, this_run_size, buffer);
2824 if (retval != ERROR_OK)
2825 {
2826 break;
2827 }
2828
2829 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2830 if (retval != ERROR_OK)
2831 {
2832 break;
2833 }
2834
2835 size -= this_run_size;
2836 address += this_run_size;
2837 }
2838
2839 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2840 {
2841 int filesize;
2842 retval = fileio_size(&fileio, &filesize);
2843 if (retval != ERROR_OK)
2844 return retval;
2845 command_print(CMD_CTX,
2846 "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
2847 duration_elapsed(&bench), duration_kbps(&bench, filesize));
2848 }
2849
2850 if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2851 return retvaltemp;
2852
2853 return retval;
2854 }
2855
2856 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
2857 {
2858 uint8_t *buffer;
2859 size_t buf_cnt;
2860 uint32_t image_size;
2861 int i;
2862 int retval;
2863 uint32_t checksum = 0;
2864 uint32_t mem_checksum = 0;
2865
2866 struct image image;
2867
2868 struct target *target = get_current_target(CMD_CTX);
2869
2870 if (CMD_ARGC < 1)
2871 {
2872 return ERROR_COMMAND_SYNTAX_ERROR;
2873 }
2874
2875 if (!target)
2876 {
2877 LOG_ERROR("no target selected");
2878 return ERROR_FAIL;
2879 }
2880
2881 struct duration bench;
2882 duration_start(&bench);
2883
2884 if (CMD_ARGC >= 2)
2885 {
2886 uint32_t addr;
2887 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2888 image.base_address = addr;
2889 image.base_address_set = 1;
2890 }
2891 else
2892 {
2893 image.base_address_set = 0;
2894 image.base_address = 0x0;
2895 }
2896
2897 image.start_address_set = 0;
2898
2899 if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK)
2900 {
2901 return retval;
2902 }
2903
2904 image_size = 0x0;
2905 int diffs = 0;
2906 retval = ERROR_OK;
2907 for (i = 0; i < image.num_sections; i++)
2908 {
2909 buffer = malloc(image.sections[i].size);
2910 if (buffer == NULL)
2911 {
2912 command_print(CMD_CTX,
2913 "error allocating buffer for section (%d bytes)",
2914 (int)(image.sections[i].size));
2915 break;
2916 }
2917 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2918 {
2919 free(buffer);
2920 break;
2921 }
2922
2923 if (verify)
2924 {
2925 /* calculate checksum of image */
2926 retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
2927 if (retval != ERROR_OK)
2928 {
2929 free(buffer);
2930 break;
2931 }
2932
2933 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2934 if (retval != ERROR_OK)
2935 {
2936 free(buffer);
2937 break;
2938 }
2939
2940 if (checksum != mem_checksum)
2941 {
2942 /* failed crc checksum, fall back to a binary compare */
2943 uint8_t *data;
2944
2945 if (diffs == 0)
2946 {
2947 LOG_ERROR("checksum mismatch - attempting binary compare");
2948 }
2949
2950 data = (uint8_t*)malloc(buf_cnt);
2951
2952 /* Can we use 32bit word accesses? */
2953 int size = 1;
2954 int count = buf_cnt;
2955 if ((count % 4) == 0)
2956 {
2957 size *= 4;
2958 count /= 4;
2959 }
2960 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2961 if (retval == ERROR_OK)
2962 {
2963 uint32_t t;
2964 for (t = 0; t < buf_cnt; t++)
2965 {
2966 if (data[t] != buffer[t])
2967 {
2968 command_print(CMD_CTX,
2969 "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
2970 diffs,
2971 (unsigned)(t + image.sections[i].base_address),
2972 data[t],
2973 buffer[t]);
2974 if (diffs++ >= 127)
2975 {
2976 command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
2977 free(data);
2978 free(buffer);
2979 goto done;
2980 }
2981 }
2982 keep_alive();
2983 }
2984 }
2985 free(data);
2986 }
2987 } else
2988 {
2989 command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
2990 image.sections[i].base_address,
2991 buf_cnt);
2992 }
2993
2994 free(buffer);
2995 image_size += buf_cnt;
2996 }
2997 if (diffs > 0)
2998 {
2999 command_print(CMD_CTX, "No more differences found.");
3000 }
3001 done:
3002 if (diffs > 0)
3003 {
3004 retval = ERROR_FAIL;
3005 }
3006 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
3007 {
3008 command_print(CMD_CTX, "verified %" PRIu32 " bytes "
3009 "in %fs (%0.3f KiB/s)", image_size,
3010 duration_elapsed(&bench), duration_kbps(&bench, image_size));
3011 }
3012
3013 image_close(&image);
3014
3015 return retval;
3016 }
3017
3018 COMMAND_HANDLER(handle_verify_image_command)
3019 {
3020 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1);
3021 }
3022
3023 COMMAND_HANDLER(handle_test_image_command)
3024 {
3025 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0);
3026 }
3027
3028 static int handle_bp_command_list(struct command_context *cmd_ctx)
3029 {
3030 struct target *target = get_current_target(cmd_ctx);
3031 struct breakpoint *breakpoint = target->breakpoints;
3032 while (breakpoint)
3033 {
3034 if (breakpoint->type == BKPT_SOFT)
3035 {
3036 char* buf = buf_to_str(breakpoint->orig_instr,
3037 breakpoint->length, 16);
3038 command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
3039 breakpoint->address,
3040 breakpoint->length,
3041 breakpoint->set, buf);
3042 free(buf);
3043 }
3044 else
3045 {
3046 if ((breakpoint->address == 0) && (breakpoint->asid != 0))
3047 command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
3048 breakpoint->asid,
3049 breakpoint->length, breakpoint->set);
3050 else if ((breakpoint->address != 0) && (breakpoint->asid != 0))
3051 {
3052 command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
3053 breakpoint->address,
3054 breakpoint->length, breakpoint->set);
3055 command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
3056 breakpoint->asid);
3057 }
3058 else
3059 command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
3060 breakpoint->address,
3061 breakpoint->length, breakpoint->set);
3062 }
3063
3064 breakpoint = breakpoint->next;
3065 }
3066 return ERROR_OK;
3067 }
3068
3069 static int handle_bp_command_set(struct command_context *cmd_ctx,
3070 uint32_t addr, uint32_t asid, uint32_t length, int hw)
3071 {
3072 struct target *target = get_current_target(cmd_ctx);
3073
3074 if (asid == 0)
3075 {
3076 int retval = breakpoint_add(target, addr, length, hw);
3077 if (ERROR_OK == retval)
3078 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
3079 else
3080 {
3081 LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
3082 return retval;
3083 }
3084 }
3085 else if (addr == 0)
3086 {
3087 int retval = context_breakpoint_add(target, asid, length, hw);
3088 if (ERROR_OK == retval)
3089 command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
3090 else
3091 {
3092 LOG_ERROR("Failure setting breakpoint, the same address(CONTEXTID) is already used");
3093 return retval;
3094 }
3095 }
3096 else
3097 {
3098 int retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
3099 if(ERROR_OK == retval)
3100 command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
3101 else
3102 {
3103 LOG_ERROR("Failure setting breakpoint, the same address is already used");
3104 return retval;
3105 }
3106 }
3107 return ERROR_OK;
3108 }
3109
3110 COMMAND_HANDLER(handle_bp_command)
3111 {
3112 uint32_t addr;
3113 uint32_t asid;
3114 uint32_t length;
3115 int hw = BKPT_SOFT;
3116 switch(CMD_ARGC)
3117 {
3118 case 0:
3119 return handle_bp_command_list(CMD_CTX);
3120
3121 case 2:
3122 asid = 0;
3123 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3124 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3125 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3126
3127 case 3:
3128 if(strcmp(CMD_ARGV[2], "hw") == 0)
3129 {
3130 hw = BKPT_HARD;
3131 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3132
3133 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3134
3135 asid = 0;
3136 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3137 }
3138 else if(strcmp(CMD_ARGV[2], "hw_ctx") == 0)
3139 {
3140 hw = BKPT_HARD;
3141 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid);
3142 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3143 addr = 0;
3144 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3145 }
3146
3147 case 4:
3148 hw = BKPT_HARD;
3149 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3150 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
3151 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length);
3152 return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
3153
3154 default:
3155 return ERROR_COMMAND_SYNTAX_ERROR;
3156 }
3157 }
3158
3159 COMMAND_HANDLER(handle_rbp_command)
3160 {
3161 if (CMD_ARGC != 1)
3162 return ERROR_COMMAND_SYNTAX_ERROR;
3163
3164 uint32_t addr;
3165 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3166
3167 struct target *target = get_current_target(CMD_CTX);
3168 breakpoint_remove(target, addr);
3169
3170 return ERROR_OK;
3171 }
3172
3173 COMMAND_HANDLER(handle_wp_command)
3174 {
3175 struct target *target = get_current_target(CMD_CTX);
3176
3177 if (CMD_ARGC == 0)
3178 {
3179 struct watchpoint *watchpoint = target->watchpoints;
3180
3181 while (watchpoint)
3182 {
3183 command_print(CMD_CTX, "address: 0x%8.8" PRIx32
3184 ", len: 0x%8.8" PRIx32
3185 ", r/w/a: %i, value: 0x%8.8" PRIx32
3186 ", mask: 0x%8.8" PRIx32,
3187 watchpoint->address,
3188 watchpoint->length,
3189 (int)watchpoint->rw,
3190 watchpoint->value,
3191 watchpoint->mask);
3192 watchpoint = watchpoint->next;
3193 }
3194 return ERROR_OK;
3195 }
3196
3197 enum watchpoint_rw type = WPT_ACCESS;
3198 uint32_t addr = 0;
3199 uint32_t length = 0;
3200 uint32_t data_value = 0x0;
3201 uint32_t data_mask = 0xffffffff;
3202
3203 switch (CMD_ARGC)
3204 {
3205 case 5:
3206 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
3207 // fall through
3208 case 4:
3209 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
3210 // fall through
3211 case 3:
3212 switch (CMD_ARGV[2][0])
3213 {
3214 case 'r':
3215 type = WPT_READ;
3216 break;
3217 case 'w':
3218 type = WPT_WRITE;
3219 break;
3220 case 'a':
3221 type = WPT_ACCESS;
3222 break;
3223 default:
3224 LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
3225 return ERROR_COMMAND_SYNTAX_ERROR;
3226 }
3227 // fall through
3228 case 2:
3229 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
3230 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3231 break;
3232
3233 default:
3234 return ERROR_COMMAND_SYNTAX_ERROR;
3235 }
3236
3237 int retval = watchpoint_add(target, addr, length, type,
3238 data_value, data_mask);
3239 if (ERROR_OK != retval)
3240 LOG_ERROR("Failure setting watchpoints");
3241
3242 return retval;
3243 }
3244
3245 COMMAND_HANDLER(handle_rwp_command)
3246 {
3247 if (CMD_ARGC != 1)
3248 return ERROR_COMMAND_SYNTAX_ERROR;
3249
3250 uint32_t addr;
3251 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
3252
3253 struct target *target = get_current_target(CMD_CTX);
3254 watchpoint_remove(target, addr);
3255
3256 return ERROR_OK;
3257 }
3258
3259
3260 /**
3261 * Translate a virtual address to a physical address.
3262 *
3263 * The low-level target implementation must have logged a detailed error
3264 * which is forwarded to telnet/GDB session.
3265 */
3266 COMMAND_HANDLER(handle_virt2phys_command)
3267 {
3268 if (CMD_ARGC != 1)
3269 return ERROR_COMMAND_SYNTAX_ERROR;
3270
3271 uint32_t va;
3272 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
3273 uint32_t pa;
3274
3275 struct target *target = get_current_target(CMD_CTX);
3276 int retval = target->type->virt2phys(target, va, &pa);
3277 if (retval == ERROR_OK)
3278 command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
3279
3280 return retval;
3281 }
3282
3283 static void writeData(FILE *f, const void *data, size_t len)
3284 {
3285 size_t written = fwrite(data, 1, len, f);
3286 if (written != len)
3287 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3288 }
3289
3290 static void writeLong(FILE *f, int l)
3291 {
3292 int i;
3293 for (i = 0; i < 4; i++)
3294 {
3295 char c = (l >> (i*8))&0xff;
3296 writeData(f, &c, 1);
3297 }
3298
3299 }
3300
3301 static void writeString(FILE *f, char *s)
3302 {
3303 writeData(f, s, strlen(s));
3304 }
3305
3306 /* Dump a gmon.out histogram file. */
3307 static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
3308 {
3309 uint32_t i;
3310 FILE *f = fopen(filename, "w");
3311 if (f == NULL)
3312 return;
3313 writeString(f, "gmon");
3314 writeLong(f, 0x00000001); /* Version */
3315 writeLong(f, 0); /* padding */
3316 writeLong(f, 0); /* padding */
3317 writeLong(f, 0); /* padding */
3318
3319 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
3320 writeData(f, &zero, 1);
3321
3322 /* figure out bucket size */
3323 uint32_t min = samples[0];
3324 uint32_t max = samples[0];
3325 for (i = 0; i < sampleNum; i++)
3326 {
3327 if (min > samples[i])
3328 {
3329 min = samples[i];
3330 }
3331 if (max < samples[i])
3332 {
3333 max = samples[i];
3334 }
3335 }
3336
3337 int addressSpace = (max - min + 1);
3338 assert(addressSpace >= 2);
3339
3340 static const uint32_t maxBuckets = 16 * 1024; /* maximum buckets. */
3341 uint32_t length = addressSpace;
3342 if (length > maxBuckets)
3343 {
3344 length = maxBuckets;
3345 }
3346 int *buckets = malloc(sizeof(int)*length);
3347 if (buckets == NULL)
3348 {
3349 fclose(f);
3350 return;
3351 }
3352 memset(buckets, 0, sizeof(int)*length);
3353 for (i = 0; i < sampleNum;i++)
3354 {
3355 uint32_t address = samples[i];
3356 long long a = address-min;
3357 long long b = length-1;
3358 long long c = addressSpace-1;
3359 int index_t = (a*b)/c; /* danger!!!! int32 overflows */
3360 buckets[index_t]++;
3361 }
3362
3363 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3364 writeLong(f, min); /* low_pc */
3365 writeLong(f, max); /* high_pc */
3366 writeLong(f, length); /* # of samples */
3367 writeLong(f, 100); /* KLUDGE! We lie, ca. 100Hz best case. */
3368 writeString(f, "seconds");
3369 for (i = 0; i < (15-strlen("seconds")); i++)
3370 writeData(f, &zero, 1);
3371 writeString(f, "s");
3372
3373 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3374
3375 char *data = malloc(2*length);
3376 if (data != NULL)
3377 {
3378 for (i = 0; i < length;i++)
3379 {
3380 int val;
3381 val = buckets[i];
3382 if (val > 65535)
3383 {
3384 val = 65535;
3385 }
3386 data[i*2]=val&0xff;
3387 data[i*2 + 1]=(val >> 8)&0xff;
3388 }
3389 free(buckets);
3390 writeData(f, data, length * 2);
3391 free(data);
3392 } else
3393 {
3394 free(buckets);
3395 }
3396
3397 fclose(f);
3398 }
3399
3400 /* profiling samples the CPU PC as quickly as OpenOCD is able,
3401 * which will be used as a random sampling of PC */
3402 COMMAND_HANDLER(handle_profile_command)
3403 {
3404 struct target *target = get_current_target(CMD_CTX);
3405 struct timeval timeout, now;
3406
3407 gettimeofday(&timeout, NULL);
3408 if (CMD_ARGC != 2)
3409 {
3410 return ERROR_COMMAND_SYNTAX_ERROR;
3411 }
3412 unsigned offset;
3413 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
3414
3415 timeval_add_time(&timeout, offset, 0);
3416
3417 /**
3418 * @todo: Some cores let us sample the PC without the
3419 * annoying halt/resume step; for example, ARMv7 PCSR.
3420 * Provide a way to use that more efficient mechanism.
3421 */
3422
3423 command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
3424
3425 static const int maxSample = 10000;
3426 uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3427 if (samples == NULL)
3428 return ERROR_OK;
3429
3430 int numSamples = 0;
3431 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3432 struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
3433
3434 int retval = ERROR_OK;
3435 for (;;)
3436 {
3437 target_poll(target);
3438 if (target->state == TARGET_HALTED)
3439 {
3440 uint32_t t=*((uint32_t *)reg->value);
3441 samples[numSamples++]=t;
3442 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3443 target_poll(target);
3444 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3445 } else if (target->state == TARGET_RUNNING)
3446 {
3447 /* We want to quickly sample the PC. */
3448 if ((retval = target_halt(target)) != ERROR_OK)
3449 {
3450 free(samples);
3451 return retval;
3452 }
3453 } else
3454 {
3455 command_print(CMD_CTX, "Target not halted or running");
3456 retval = ERROR_OK;
3457 break;
3458 }
3459 if (retval != ERROR_OK)
3460 {
3461 break;
3462 }
3463
3464 gettimeofday(&now, NULL);
3465 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
3466 {
3467 command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
3468 if ((retval = target_poll(target)) != ERROR_OK)
3469 {
3470 free(samples);
3471 return retval;
3472 }
3473 if (target->state == TARGET_HALTED)
3474 {
3475 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3476 }
3477 if ((retval = target_poll(target)) != ERROR_OK)
3478 {
3479 free(samples);
3480 return retval;
3481 }
3482 writeGmon(samples, numSamples, CMD_ARGV[1]);
3483 command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
3484 break;
3485 }
3486 }
3487 free(samples);
3488
3489 return retval;
3490 }
3491
3492 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
3493 {
3494 char *namebuf;
3495 Jim_Obj *nameObjPtr, *valObjPtr;
3496 int result;
3497
3498 namebuf = alloc_printf("%s(%d)", varname, idx);
3499 if (!namebuf)
3500 return JIM_ERR;
3501
3502 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3503 valObjPtr = Jim_NewIntObj(interp, val);
3504 if (!nameObjPtr || !valObjPtr)
3505 {
3506 free(namebuf);
3507 return JIM_ERR;
3508 }
3509
3510 Jim_IncrRefCount(nameObjPtr);
3511 Jim_IncrRefCount(valObjPtr);
3512 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3513 Jim_DecrRefCount(interp, nameObjPtr);
3514 Jim_DecrRefCount(interp, valObjPtr);
3515 free(namebuf);
3516 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3517 return result;
3518 }
3519
3520 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3521 {
3522 struct command_context *context;
3523 struct target *target;
3524
3525 context = current_command_context(interp);
3526 assert (context != NULL);
3527
3528 target = get_current_target(context);
3529 if (target == NULL)
3530 {
3531 LOG_ERROR("mem2array: no current target");
3532 return JIM_ERR;
3533 }
3534
3535 return target_mem2array(interp, target, argc-1, argv + 1);
3536 }
3537
3538 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
3539 {
3540 long l;
3541 uint32_t width;
3542 int len;
3543 uint32_t addr;
3544 uint32_t count;
3545 uint32_t v;
3546 const char *varname;
3547 int n, e, retval;
3548 uint32_t i;
3549
3550 /* argv[1] = name of array to receive the data
3551 * argv[2] = desired width
3552 * argv[3] = memory address
3553 * argv[4] = count of times to read
3554 */
3555 if (argc != 4) {
3556 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3557 return JIM_ERR;
3558 }
3559 varname = Jim_GetString(argv[0], &len);
3560 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3561
3562 e = Jim_GetLong(interp, argv[1], &l);
3563 width = l;
3564 if (e != JIM_OK) {
3565 return e;
3566 }
3567
3568 e = Jim_GetLong(interp, argv[2], &l);
3569 addr = l;
3570 if (e != JIM_OK) {
3571 return e;
3572 }
3573 e = Jim_GetLong(interp, argv[3], &l);
3574 len = l;
3575 if (e != JIM_OK) {
3576 return e;
3577 }
3578 switch (width) {
3579 case 8:
3580 width = 1;
3581 break;
3582 case 16:
3583 width = 2;
3584 break;
3585 case 32:
3586 width = 4;
3587 break;
3588 default:
3589 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3590 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3591 return JIM_ERR;
3592 }
3593 if (len == 0) {
3594 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3595 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3596 return JIM_ERR;
3597 }
3598 if ((addr + (len * width)) < addr) {
3599 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3600 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3601 return JIM_ERR;
3602 }
3603 /* absurd transfer size? */
3604 if (len > 65536) {
3605 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3606 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3607 return JIM_ERR;
3608 }
3609
3610 if ((width == 1) ||
3611 ((width == 2) && ((addr & 1) == 0)) ||
3612 ((width == 4) && ((addr & 3) == 0))) {
3613 /* all is well */
3614 } else {
3615 char buf[100];
3616 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3617 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3618 addr,
3619 width);
3620 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3621 return JIM_ERR;
3622 }
3623
3624 /* Transfer loop */
3625
3626 /* index counter */
3627 n = 0;
3628
3629 size_t buffersize = 4096;
3630 uint8_t *buffer = malloc(buffersize);
3631 if (buffer == NULL)
3632 return JIM_ERR;
3633
3634 /* assume ok */
3635 e = JIM_OK;
3636 while (len) {
3637 /* Slurp... in buffer size chunks */
3638
3639 count = len; /* in objects.. */
3640 if (count > (buffersize/width)) {
3641 count = (buffersize/width);
3642 }
3643
3644 retval = target_read_memory(target, addr, width, count, buffer);
3645 if (retval != ERROR_OK) {
3646 /* BOO !*/
3647 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3648 (unsigned int)addr,
3649 (int)width,
3650 (int)count);
3651 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3652 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3653 e = JIM_ERR;
3654 break;
3655 } else {
3656 v = 0; /* shut up gcc */
3657 for (i = 0 ;i < count ;i++, n++) {
3658 switch (width) {
3659 case 4:
3660 v = target_buffer_get_u32(target, &buffer[i*width]);
3661 break;
3662 case 2:
3663 v = target_buffer_get_u16(target, &buffer[i*width]);
3664 break;
3665 case 1:
3666 v = buffer[i] & 0x0ff;
3667 break;
3668 }
3669 new_int_array_element(interp, varname, n, v);
3670 }
3671 len -= count;
3672 }
3673 }
3674
3675 free(buffer);
3676
3677 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3678
3679 return e;
3680 }
3681
3682 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
3683 {
3684 char *namebuf;
3685 Jim_Obj *nameObjPtr, *valObjPtr;
3686 int result;
3687 long l;
3688
3689 namebuf = alloc_printf("%s(%d)", varname, idx);
3690 if (!namebuf)
3691 return JIM_ERR;
3692
3693 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3694 if (!nameObjPtr)
3695 {
3696 free(namebuf);
3697 return JIM_ERR;
3698 }
3699
3700 Jim_IncrRefCount(nameObjPtr);
3701 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3702 Jim_DecrRefCount(interp, nameObjPtr);
3703 free(namebuf);
3704 if (valObjPtr == NULL)
3705 return JIM_ERR;
3706
3707 result = Jim_GetLong(interp, valObjPtr, &l);
3708 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3709 *val = l;
3710 return result;
3711 }
3712
3713 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3714 {
3715 struct command_context *context;
3716 struct target *target;
3717
3718 context = current_command_context(interp);
3719 assert (context != NULL);
3720
3721 target = get_current_target(context);
3722 if (target == NULL) {
3723 LOG_ERROR("array2mem: no current target");
3724 return JIM_ERR;
3725 }
3726
3727 return target_array2mem(interp,target, argc-1, argv + 1);
3728 }
3729
3730 static int target_array2mem(Jim_Interp *interp, struct target *target,
3731 int argc, Jim_Obj *const *argv)
3732 {
3733 long l;
3734 uint32_t width;
3735 int len;
3736 uint32_t addr;
3737 uint32_t count;
3738 uint32_t v;
3739 const char *varname;
3740 int n, e, retval;
3741 uint32_t i;
3742
3743 /* argv[1] = name of array to get the data
3744 * argv[2] = desired width
3745 * argv[3] = memory address
3746 * argv[4] = count to write
3747 */
3748 if (argc != 4) {
3749 Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
3750 return JIM_ERR;
3751 }
3752 varname = Jim_GetString(argv[0], &len);
3753 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3754
3755 e = Jim_GetLong(interp, argv[1], &l);
3756 width = l;
3757 if (e != JIM_OK) {
3758 return e;
3759 }
3760
3761 e = Jim_GetLong(interp, argv[2], &l);
3762 addr = l;
3763 if (e != JIM_OK) {
3764 return e;
3765 }
3766 e = Jim_GetLong(interp, argv[3], &l);
3767 len = l;
3768 if (e != JIM_OK) {
3769 return e;
3770 }
3771 switch (width) {
3772 case 8:
3773 width = 1;
3774 break;
3775 case 16:
3776 width = 2;
3777 break;
3778 case 32:
3779 width = 4;
3780 break;
3781 default:
3782 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3783 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3784 return JIM_ERR;
3785 }
3786 if (len == 0) {
3787 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3788 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3789 return JIM_ERR;
3790 }
3791 if ((addr + (len * width)) < addr) {
3792 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3793 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3794 return JIM_ERR;
3795 }
3796 /* absurd transfer size? */
3797 if (len > 65536) {
3798 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3799 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3800 return JIM_ERR;
3801 }
3802
3803 if ((width == 1) ||
3804 ((width == 2) && ((addr & 1) == 0)) ||
3805 ((width == 4) && ((addr & 3) == 0))) {
3806 /* all is well */
3807 } else {
3808 char buf[100];
3809 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3810 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3811 (unsigned int)addr,
3812 (int)width);
3813 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3814 return JIM_ERR;
3815 }
3816
3817 /* Transfer loop */
3818
3819 /* index counter */
3820 n = 0;
3821 /* assume ok */
3822 e = JIM_OK;
3823
3824 size_t buffersize = 4096;
3825 uint8_t *buffer = malloc(buffersize);
3826 if (buffer == NULL)
3827 return JIM_ERR;
3828
3829 while (len) {
3830 /* Slurp... in buffer size chunks */
3831
3832 count = len; /* in objects.. */
3833 if (count > (buffersize/width)) {
3834 count = (buffersize/width);
3835 }
3836
3837 v = 0; /* shut up gcc */
3838 for (i = 0 ;i < count ;i++, n++) {
3839 get_int_array_element(interp, varname, n, &v);
3840 switch (width) {
3841 case 4:
3842 target_buffer_set_u32(target, &buffer[i*width], v);
3843 break;
3844 case 2:
3845 target_buffer_set_u16(target, &buffer[i*width], v);
3846 break;
3847 case 1:
3848 buffer[i] = v & 0x0ff;
3849 break;
3850 }
3851 }
3852 len -= count;
3853
3854 retval = target_write_memory(target, addr, width, count, buffer);
3855 if (retval != ERROR_OK) {
3856 /* BOO !*/
3857 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3858 (unsigned int)addr,
3859 (int)width,
3860 (int)count);
3861 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3862 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3863 e = JIM_ERR;
3864 break;
3865 }
3866 }
3867
3868 free(buffer);
3869
3870 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3871
3872 return e;
3873 }
3874
3875 /* FIX? should we propagate errors here rather than printing them
3876 * and continuing?
3877 */
3878 void target_handle_event(struct target *target, enum target_event e)
3879 {
3880 struct target_event_action *teap;
3881
3882 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3883 if (teap->event == e) {
3884 LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3885 target->target_number,
3886 target_name(target),
3887 target_type_name(target),
3888 e,
3889 Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3890 Jim_GetString(teap->body, NULL));
3891 if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK)
3892 {
3893 Jim_MakeErrorMessage(teap->interp);
3894 command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
3895 }
3896 }
3897 }
3898 }
3899
3900 /**
3901 * Returns true only if the target has a handler for the specified event.
3902 */
3903 bool target_has_event_action(struct target *target, enum target_event event)
3904 {
3905 struct target_event_action *teap;
3906
3907 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3908 if (teap->event == event)
3909 return true;
3910 }
3911 return false;
3912 }
3913
3914 enum target_cfg_param {
3915 TCFG_TYPE,
3916 TCFG_EVENT,
3917 TCFG_WORK_AREA_VIRT,
3918 TCFG_WORK_AREA_PHYS,
3919 TCFG_WORK_AREA_SIZE,
3920 TCFG_WORK_AREA_BACKUP,
3921 TCFG_ENDIAN,
3922 TCFG_VARIANT,
3923 TCFG_COREID,
3924 TCFG_CHAIN_POSITION,
3925 TCFG_DBGBASE,
3926 TCFG_RTOS,
3927 };
3928
3929 static Jim_Nvp nvp_config_opts[] = {
3930 { .name = "-type", .value = TCFG_TYPE },
3931 { .name = "-event", .value = TCFG_EVENT },
3932 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3933 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3934 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3935 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3936 { .name = "-endian" , .value = TCFG_ENDIAN },
3937 { .name = "-variant", .value = TCFG_VARIANT },
3938 { .name = "-coreid", .value = TCFG_COREID },
3939 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3940 { .name = "-dbgbase", .value = TCFG_DBGBASE },
3941 { .name = "-rtos", .value = TCFG_RTOS },
3942 { .name = NULL, .value = -1 }
3943 };
3944
3945 static int target_configure(Jim_GetOptInfo *goi, struct target *target)
3946 {
3947 Jim_Nvp *n;
3948 Jim_Obj *o;
3949 jim_wide w;
3950 char *cp;
3951 int e;
3952
3953 /* parse config or cget options ... */
3954 while (goi->argc > 0) {
3955 Jim_SetEmptyResult(goi->interp);
3956 /* Jim_GetOpt_Debug(goi); */
3957
3958 if (target->type->target_jim_configure) {
3959 /* target defines a configure function */
3960 /* target gets first dibs on parameters */
3961 e = (*(target->type->target_jim_configure))(target, goi);
3962 if (e == JIM_OK) {
3963 /* more? */
3964 continue;
3965 }
3966 if (e == JIM_ERR) {
3967 /* An error */
3968 return e;
3969 }
3970 /* otherwise we 'continue' below */
3971 }
3972 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
3973 if (e != JIM_OK) {
3974 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
3975 return e;
3976 }
3977 switch (n->value) {
3978 case TCFG_TYPE:
3979 /* not setable */
3980 if (goi->isconfigure) {
3981 Jim_SetResultFormatted(goi->interp,
3982 "not settable: %s", n->name);
3983 return JIM_ERR;
3984 } else {
3985 no_params:
3986 if (goi->argc != 0) {
3987 Jim_WrongNumArgs(goi->interp,
3988 goi->argc, goi->argv,
3989 "NO PARAMS");
3990 return JIM_ERR;
3991 }
3992 }
3993 Jim_SetResultString(goi->interp,
3994 target_type_name(target), -1);
3995 /* loop for more */
3996 break;
3997 case TCFG_EVENT:
3998 if (goi->argc == 0) {
3999 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
4000 return JIM_ERR;
4001 }
4002
4003 e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
4004 if (e != JIM_OK) {
4005 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
4006 return e;
4007 }
4008
4009 if (goi->isconfigure) {
4010 if (goi->argc != 1) {
4011 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
4012 return JIM_ERR;
4013 }
4014 } else {
4015 if (goi->argc != 0) {
4016 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
4017 return JIM_ERR;
4018 }
4019 }
4020
4021 {
4022 struct target_event_action *teap;
4023
4024 teap = target->event_action;
4025 /* replace existing? */
4026 while (teap) {
4027 if (teap->event == (enum target_event)n->value) {
4028 break;
4029 }
4030 teap = teap->next;
4031 }
4032
4033 if (goi->isconfigure) {
4034 bool replace = true;
4035 if (teap == NULL) {
4036 /* create new */
4037 teap = calloc(1, sizeof(*teap));
4038 replace = false;
4039 }
4040 teap->event = n->value;
4041 teap->interp = goi->interp;
4042 Jim_GetOpt_Obj(goi, &o);
4043 if (teap->body) {
4044 Jim_DecrRefCount(teap->interp, teap->body);
4045 }
4046 teap->body = Jim_DuplicateObj(goi->interp, o);
4047 /*
4048 * FIXME:
4049 * Tcl/TK - "tk events" have a nice feature.
4050 * See the "BIND" command.
4051 * We should support that here.
4052 * You can specify %X and %Y in the event code.
4053 * The idea is: %T - target name.
4054 * The idea is: %N - target number
4055 * The idea is: %E - event name.
4056 */
4057 Jim_IncrRefCount(teap->body);
4058
4059 if (!replace)
4060 {
4061 /* add to head of event list */
4062 teap->next = target->event_action;
4063 target->event_action = teap;
4064 }
4065 Jim_SetEmptyResult(goi->interp);
4066 } else {
4067 /* get */
4068 if (teap == NULL) {
4069 Jim_SetEmptyResult(goi->interp);
4070 } else {
4071 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
4072 }
4073 }
4074 }
4075 /* loop for more */
4076 break;
4077
4078 case TCFG_WORK_AREA_VIRT:
4079 if (goi->isconfigure) {
4080 target_free_all_working_areas(target);
4081 e = Jim_GetOpt_Wide(goi, &w);
4082 if (e != JIM_OK) {
4083 return e;
4084 }
4085 target->working_area_virt = w;
4086 target->working_area_virt_spec = true;
4087 } else {
4088 if (goi->argc != 0) {
4089 goto no_params;
4090 }
4091 }
4092 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
4093 /* loop for more */
4094 break;
4095
4096 case TCFG_WORK_AREA_PHYS:
4097 if (goi->isconfigure) {
4098 target_free_all_working_areas(target);
4099 e = Jim_GetOpt_Wide(goi, &w);
4100 if (e != JIM_OK) {
4101 return e;
4102 }
4103 target->working_area_phys = w;
4104 target->working_area_phys_spec = true;
4105 } else {
4106 if (goi->argc != 0) {
4107 goto no_params;
4108 }
4109 }
4110 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
4111 /* loop for more */
4112 break;
4113
4114 case TCFG_WORK_AREA_SIZE:
4115 if (goi->isconfigure) {
4116 target_free_all_working_areas(target);
4117 e = Jim_GetOpt_Wide(goi, &w);
4118 if (e != JIM_OK) {
4119 return e;
4120 }
4121 target->working_area_size = w;
4122 } else {
4123 if (goi->argc != 0) {
4124 goto no_params;
4125 }
4126 }
4127 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
4128 /* loop for more */
4129 break;
4130
4131 case TCFG_WORK_AREA_BACKUP:
4132 if (goi->isconfigure) {
4133 target_free_all_working_areas(target);
4134 e = Jim_GetOpt_Wide(goi, &w);
4135 if (e != JIM_OK) {
4136 return e;
4137 }
4138 /* make this exactly 1 or 0 */
4139 target->backup_working_area = (!!w);
4140 } else {
4141 if (goi->argc != 0) {
4142 goto no_params;
4143 }
4144 }
4145 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
4146 /* loop for more e*/
4147 break;
4148
4149
4150 case TCFG_ENDIAN:
4151 if (goi->isconfigure) {
4152 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
4153 if (e != JIM_OK) {
4154 Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
4155 return e;
4156 }
4157 target->endianness = n->value;
4158 } else {
4159 if (goi->argc != 0) {
4160 goto no_params;
4161 }
4162 }
4163 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
4164 if (n->name == NULL) {
4165 target->endianness = TARGET_LITTLE_ENDIAN;
4166 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
4167 }
4168 Jim_SetResultString(goi->interp, n->name, -1);
4169 /* loop for more */
4170 break;
4171
4172 case TCFG_VARIANT:
4173 if (goi->isconfigure) {
4174 if (goi->argc < 1) {
4175 Jim_SetResultFormatted(goi->interp,
4176 "%s ?STRING?",
4177 n->name);
4178 return JIM_ERR;
4179 }
4180 if (target->variant) {
4181 free((void *)(target->variant));
4182 }
4183 e = Jim_GetOpt_String(goi, &cp, NULL);
4184 if (e != JIM_OK)
4185 return e;
4186 target->variant = strdup(cp);
4187 } else {
4188 if (goi->argc != 0) {
4189 goto no_params;
4190 }
4191 }
4192 Jim_SetResultString(goi->interp, target->variant,-1);
4193 /* loop for more */
4194 break;
4195
4196 case TCFG_COREID:
4197 if (goi->isconfigure) {
4198 e = Jim_GetOpt_Wide(goi, &w);
4199 if (e != JIM_OK) {
4200 return e;
4201 }
4202 target->coreid = (int32_t)w;
4203 } else {
4204 if (goi->argc != 0) {
4205 goto no_params;
4206 }
4207 }
4208 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
4209 /* loop for more */
4210 break;
4211
4212 case TCFG_CHAIN_POSITION:
4213 if (goi->isconfigure) {
4214 Jim_Obj *o_t;
4215 struct jtag_tap *tap;
4216 target_free_all_working_areas(target);
4217 e = Jim_GetOpt_Obj(goi, &o_t);
4218 if (e != JIM_OK) {
4219 return e;
4220 }
4221 tap = jtag_tap_by_jim_obj(goi->interp, o_t);
4222 if (tap == NULL) {
4223 return JIM_ERR;
4224 }
4225 /* make this exactly 1 or 0 */
4226 target->tap = tap;
4227 } else {
4228 if (goi->argc != 0) {
4229 goto no_params;
4230 }
4231 }
4232 Jim_SetResultString(goi->interp, target->tap->dotted_name, -1);
4233 /* loop for more e*/
4234 break;
4235 case TCFG_DBGBASE:
4236 if (goi->isconfigure) {
4237 e = Jim_GetOpt_Wide(goi, &w);
4238 if (e != JIM_OK) {
4239 return e;
4240 }
4241 target->dbgbase = (uint32_t)w;
4242 target->dbgbase_set = true;
4243 } else {
4244 if (goi->argc != 0) {
4245 goto no_params;
4246 }
4247 }
4248 Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->dbgbase));
4249 /* loop for more */
4250 break;
4251
4252 case TCFG_RTOS:
4253 /* RTOS */
4254 {
4255 int result = rtos_create( goi, target );
4256 if ( result != JIM_OK )
4257 {
4258 return result;
4259 }
4260 }
4261 /* loop for more */
4262 break;
4263 }
4264 } /* while (goi->argc) */
4265
4266
4267 /* done - we return */
4268 return JIM_OK;
4269 }
4270
4271 static int
4272 jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4273 {
4274 Jim_GetOptInfo goi;
4275
4276 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4277 goi.isconfigure = !strcmp(Jim_GetString(argv[0], NULL), "configure");
4278 int need_args = 1 + goi.isconfigure;
4279 if (goi.argc < need_args)
4280 {
4281 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
4282 goi.isconfigure
4283 ? "missing: -option VALUE ..."
4284 : "missing: -option ...");
4285 return JIM_ERR;
4286 }
4287 struct target *target = Jim_CmdPrivData(goi.interp);
4288 return target_configure(&goi, target);
4289 }
4290
4291 static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4292 {
4293 const char *cmd_name = Jim_GetString(argv[0], NULL);
4294
4295 Jim_GetOptInfo goi;
4296 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4297
4298 if (goi.argc < 2 || goi.argc > 4)
4299 {
4300 Jim_SetResultFormatted(goi.interp,
4301 "usage: %s [phys] <address> <data> [<count>]", cmd_name);
4302 return JIM_ERR;
4303 }
4304
4305 target_write_fn fn;
4306 fn = target_write_memory_fast;
4307
4308 int e;
4309 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
4310 {
4311 /* consume it */
4312 struct Jim_Obj *obj;
4313 e = Jim_GetOpt_Obj(&goi, &obj);
4314 if (e != JIM_OK)
4315 return e;
4316
4317 fn = target_write_phys_memory;
4318 }
4319
4320 jim_wide a;
4321 e = Jim_GetOpt_Wide(&goi, &a);
4322 if (e != JIM_OK)
4323 return e;
4324
4325 jim_wide b;
4326 e = Jim_GetOpt_Wide(&goi, &b);
4327 if (e != JIM_OK)
4328 return e;
4329
4330 jim_wide c = 1;
4331 if (goi.argc == 1)
4332 {
4333 e = Jim_GetOpt_Wide(&goi, &c);
4334 if (e != JIM_OK)
4335 return e;
4336 }
4337
4338 /* all args must be consumed */
4339 if (goi.argc != 0)
4340 {
4341 return JIM_ERR;
4342 }
4343
4344 struct target *target = Jim_CmdPrivData(goi.interp);
4345 unsigned data_size;
4346 if (strcasecmp(cmd_name, "mww") == 0) {
4347 data_size = 4;
4348 }
4349 else if (strcasecmp(cmd_name, "mwh") == 0) {
4350 data_size = 2;
4351 }
4352 else if (strcasecmp(cmd_name, "mwb") == 0) {
4353 data_size = 1;
4354 } else {
4355 LOG_ERROR("command '%s' unknown: ", cmd_name);
4356 return JIM_ERR;
4357 }
4358
4359 return (target_fill_mem(target, a, fn, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
4360 }
4361
4362 static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4363 {
4364 const char *cmd_name = Jim_GetString(argv[0], NULL);
4365
4366 Jim_GetOptInfo goi;
4367 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4368
4369 if ((goi.argc < 1) || (goi.argc > 3))
4370 {
4371 Jim_SetResultFormatted(goi.interp,
4372 "usage: %s [phys] <address> [<count>]", cmd_name);
4373 return JIM_ERR;
4374 }
4375
4376 int (*fn)(struct target *target,
4377 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
4378 fn=target_read_memory;
4379
4380 int e;
4381 if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
4382 {
4383 /* consume it */
4384 struct Jim_Obj *obj;
4385 e = Jim_GetOpt_Obj(&goi, &obj);
4386 if (e != JIM_OK)
4387 return e;
4388
4389 fn=target_read_phys_memory;
4390 }
4391
4392 jim_wide a;
4393 e = Jim_GetOpt_Wide(&goi, &a);
4394 if (e != JIM_OK) {
4395 return JIM_ERR;
4396 }
4397 jim_wide c;
4398 if (goi.argc == 1) {
4399 e = Jim_GetOpt_Wide(&goi, &c);
4400 if (e != JIM_OK) {
4401 return JIM_ERR;
4402 }
4403 } else {
4404 c = 1;
4405 }
4406
4407 /* all args must be consumed */
4408 if (goi.argc != 0)
4409 {
4410 return JIM_ERR;
4411 }
4412
4413 jim_wide b = 1; /* shut up gcc */
4414 if (strcasecmp(cmd_name, "mdw") == 0)
4415 b = 4;
4416 else if (strcasecmp(cmd_name, "mdh") == 0)
4417 b = 2;
4418 else if (strcasecmp(cmd_name, "mdb") == 0)
4419 b = 1;
4420 else {
4421 LOG_ERROR("command '%s' unknown: ", cmd_name);
4422 return JIM_ERR;
4423 }
4424
4425 /* convert count to "bytes" */
4426 c = c * b;
4427
4428 struct target *target = Jim_CmdPrivData(goi.interp);
4429 uint8_t target_buf[32];
4430 jim_wide x, y, z;
4431 while (c > 0) {
4432 y = c;
4433 if (y > 16) {
4434 y = 16;
4435 }
4436 e = fn(target, a, b, y / b, target_buf);
4437 if (e != ERROR_OK) {
4438 char tmp[10];
4439 snprintf(tmp, sizeof(tmp), "%08lx", (long)a);
4440 Jim_SetResultFormatted(interp, "error reading target @ 0x%s", tmp);
4441 return JIM_ERR;
4442 }
4443
4444 command_print(NULL, "0x%08x ", (int)(a));
4445 switch (b) {
4446 case 4:
4447 for (x = 0; x < 16 && x < y; x += 4)
4448 {
4449 z = target_buffer_get_u32(target, &(target_buf[ x ]));
4450 command_print(NULL, "%08x ", (int)(z));
4451 }
4452 for (; (x < 16) ; x += 4) {
4453 command_print(NULL, " ");
4454 }
4455 break;
4456 case 2:
4457 for (x = 0; x < 16 && x < y; x += 2)
4458 {
4459 z = target_buffer_get_u16(target, &(target_buf[ x ]));
4460 command_print(NULL, "%04x ", (int)(z));
4461 }
4462 for (; (x < 16) ; x += 2) {
4463 command_print(NULL, " ");
4464 }
4465 break;
4466 case 1:
4467 default:
4468 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4469 z = target_buffer_get_u8(target, &(target_buf[ x ]));
4470 command_print(NULL, "%02x ", (int)(z));
4471 }
4472 for (; (x < 16) ; x += 1) {
4473 command_print(NULL, " ");
4474 }
4475 break;
4476 }
4477 /* ascii-ify the bytes */
4478 for (x = 0 ; x < y ; x++) {
4479 if ((target_buf[x] >= 0x20) &&
4480 (target_buf[x] <= 0x7e)) {
4481 /* good */
4482 } else {
4483 /* smack it */
4484 target_buf[x] = '.';
4485 }
4486 }
4487 /* space pad */
4488 while (x < 16) {
4489 target_buf[x] = ' ';
4490 x++;
4491 }
4492 /* terminate */
4493 target_buf[16] = 0;
4494 /* print - with a newline */
4495 command_print(NULL, "%s\n", target_buf);
4496 /* NEXT... */
4497 c -= 16;
4498 a += 16;
4499 }
4500 return JIM_OK;
4501 }
4502
4503 static int jim_target_mem2array(Jim_Interp *interp,
4504 int argc, Jim_Obj *const *argv)
4505 {
4506 struct target *target = Jim_CmdPrivData(interp);
4507 return target_mem2array(interp, target, argc - 1, argv + 1);
4508 }
4509
4510 static int jim_target_array2mem(Jim_Interp *interp,
4511 int argc, Jim_Obj *const *argv)
4512 {
4513 struct target *target = Jim_CmdPrivData(interp);
4514 return target_array2mem(interp, target, argc - 1, argv + 1);
4515 }
4516
4517 static int jim_target_tap_disabled(Jim_Interp *interp)
4518 {
4519 Jim_SetResultFormatted(interp, "[TAP is disabled]");
4520 return JIM_ERR;
4521 }
4522
4523 static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4524 {
4525 if (argc != 1)
4526 {
4527 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4528 return JIM_ERR;
4529 }
4530 struct target *target = Jim_CmdPrivData(interp);
4531 if (!target->tap->enabled)
4532 return jim_target_tap_disabled(interp);
4533
4534 int e = target->type->examine(target);
4535 if (e != ERROR_OK)
4536 {
4537 return JIM_ERR;
4538 }
4539 return JIM_OK;
4540 }
4541
4542 static int jim_target_halt_gdb(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4543 {
4544 if (argc != 1)
4545 {
4546 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4547 return JIM_ERR;
4548 }
4549 struct target *target = Jim_CmdPrivData(interp);
4550
4551 if (target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT) != ERROR_OK)
4552 return JIM_ERR;
4553
4554 return JIM_OK;
4555 }
4556
4557 static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4558 {
4559 if (argc != 1)
4560 {
4561 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4562 return JIM_ERR;
4563 }
4564 struct target *target = Jim_CmdPrivData(interp);
4565 if (!target->tap->enabled)
4566 return jim_target_tap_disabled(interp);
4567
4568 int e;
4569 if (!(target_was_examined(target))) {
4570 e = ERROR_TARGET_NOT_EXAMINED;
4571 } else {
4572 e = target->type->poll(target);
4573 }
4574 if (e != ERROR_OK)
4575 {
4576 return JIM_ERR;
4577 }
4578 return JIM_OK;
4579 }
4580
4581 static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4582 {
4583 Jim_GetOptInfo goi;
4584 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4585
4586 if (goi.argc != 2)
4587 {
4588 Jim_WrongNumArgs(interp, 0, argv,
4589 "([tT]|[fF]|assert|deassert) BOOL");
4590 return JIM_ERR;
4591 }
4592
4593 Jim_Nvp *n;
4594 int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4595 if (e != JIM_OK)
4596 {
4597 Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4598 return e;
4599 }
4600 /* the halt or not param */
4601 jim_wide a;
4602 e = Jim_GetOpt_Wide(&goi, &a);
4603 if (e != JIM_OK)
4604 return e;
4605
4606 struct target *target = Jim_CmdPrivData(goi.interp);
4607 if (!target->tap->enabled)
4608 return jim_target_tap_disabled(interp);
4609 if (!(target_was_examined(target)))
4610 {
4611 LOG_ERROR("Target not examined yet");
4612 return ERROR_TARGET_NOT_EXAMINED;
4613 }
4614 if (!target->type->assert_reset || !target->type->deassert_reset)
4615 {
4616 Jim_SetResultFormatted(interp,
4617 "No target-specific reset for %s",
4618 target_name(target));
4619 return JIM_ERR;
4620 }
4621 /* determine if we should halt or not. */
4622 target->reset_halt = !!a;
4623 /* When this happens - all workareas are invalid. */
4624 target_free_all_working_areas_restore(target, 0);
4625
4626 /* do the assert */
4627 if (n->value == NVP_ASSERT) {
4628 e = target->type->assert_reset(target);
4629 } else {
4630 e = target->type->deassert_reset(target);
4631 }
4632 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4633 }
4634
4635 static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4636 {
4637 if (argc != 1) {
4638 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4639 return JIM_ERR;
4640 }
4641 struct target *target = Jim_CmdPrivData(interp);
4642 if (!target->tap->enabled)
4643 return jim_target_tap_disabled(interp);
4644 int e = target->type->halt(target);
4645 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4646 }
4647
4648 static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4649 {
4650 Jim_GetOptInfo goi;
4651 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4652
4653 /* params: <name> statename timeoutmsecs */
4654 if (goi.argc != 2)
4655 {
4656 const char *cmd_name = Jim_GetString(argv[0], NULL);
4657 Jim_SetResultFormatted(goi.interp,
4658 "%s <state_name> <timeout_in_msec>", cmd_name);
4659 return JIM_ERR;
4660 }
4661
4662 Jim_Nvp *n;
4663 int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4664 if (e != JIM_OK) {
4665 Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
4666 return e;
4667 }
4668 jim_wide a;
4669 e = Jim_GetOpt_Wide(&goi, &a);
4670 if (e != JIM_OK) {
4671 return e;
4672 }
4673 struct target *target = Jim_CmdPrivData(interp);
4674 if (!target->tap->enabled)
4675 return jim_target_tap_disabled(interp);
4676
4677 e = target_wait_state(target, n->value, a);
4678 if (e != ERROR_OK)
4679 {
4680 Jim_Obj *eObj = Jim_NewIntObj(interp, e);
4681 Jim_SetResultFormatted(goi.interp,
4682 "target: %s wait %s fails (%#s) %s",
4683 target_name(target), n->name,
4684 eObj, target_strerror_safe(e));
4685 Jim_FreeNewObj(interp, eObj);
4686 return JIM_ERR;
4687 }
4688 return JIM_OK;
4689 }
4690 /* List for human, Events defined for this target.
4691 * scripts/programs should use 'name cget -event NAME'
4692 */
4693 static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4694 {
4695 struct command_context *cmd_ctx = current_command_context(interp);
4696 assert (cmd_ctx != NULL);
4697
4698 struct target *target = Jim_CmdPrivData(interp);
4699 struct target_event_action *teap = target->event_action;
4700 command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4701 target->target_number,
4702 target_name(target));
4703 command_print(cmd_ctx, "%-25s | Body", "Event");
4704 command_print(cmd_ctx, "------------------------- | "
4705 "----------------------------------------");
4706 while (teap)
4707 {
4708 Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
4709 command_print(cmd_ctx, "%-25s | %s",
4710 opt->name, Jim_GetString(teap->body, NULL));
4711 teap = teap->next;
4712 }
4713 command_print(cmd_ctx, "***END***");
4714 return JIM_OK;
4715 }
4716 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4717 {
4718 if (argc != 1)
4719 {
4720 Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
4721 return JIM_ERR;
4722 }
4723 struct target *target = Jim_CmdPrivData(interp);
4724 Jim_SetResultString(interp, target_state_name(target), -1);
4725 return JIM_OK;
4726 }
4727 static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4728 {
4729 Jim_GetOptInfo goi;
4730 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
4731 if (goi.argc != 1)
4732 {
4733 const char *cmd_name = Jim_GetString(argv[0], NULL);
4734 Jim_SetResultFormatted(goi.interp, "%s <eventname>", cmd_name);
4735 return JIM_ERR;
4736 }
4737 Jim_Nvp *n;
4738 int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4739 if (e != JIM_OK)
4740 {
4741 Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4742 return e;
4743 }
4744 struct target *target = Jim_CmdPrivData(interp);
4745 target_handle_event(target, n->value);
4746 return JIM_OK;
4747 }
4748
4749 static const struct command_registration target_instance_command_handlers[] = {
4750 {
4751 .name = "configure",
4752 .mode = COMMAND_CONFIG,
4753 .jim_handler = jim_target_configure,
4754 .help = "configure a new target for use",
4755 .usage = "[target_attribute ...]",
4756 },
4757 {
4758 .name = "cget",
4759 .mode = COMMAND_ANY,
4760 .jim_handler = jim_target_configure,
4761 .help = "returns the specified target attribute",
4762 .usage = "target_attribute",
4763 },
4764 {
4765 .name = "mww",
4766 .mode = COMMAND_EXEC,
4767 .jim_handler = jim_target_mw,
4768 .help = "Write 32-bit word(s) to target memory",
4769 .usage = "address data [count]",
4770 },
4771 {
4772 .name = "mwh",
4773 .mode = COMMAND_EXEC,
4774 .jim_handler = jim_target_mw,
4775 .help = "Write 16-bit half-word(s) to target memory",
4776 .usage = "address data [count]",
4777 },
4778 {
4779 .name = "mwb",
4780 .mode = COMMAND_EXEC,
4781 .jim_handler = jim_target_mw,
4782 .help = "Write byte(s) to target memory",
4783 .usage = "address data [count]",
4784 },
4785 {
4786 .name = "mdw",
4787 .mode = COMMAND_EXEC,
4788 .jim_handler = jim_target_md,
4789 .help = "Display target memory as 32-bit words",
4790 .usage = "address [count]",
4791 },
4792 {
4793 .name = "mdh",
4794 .mode = COMMAND_EXEC,
4795 .jim_handler = jim_target_md,
4796 .help = "Display target memory as 16-bit half-words",
4797 .usage = "address [count]",
4798 },
4799 {
4800 .name = "mdb",
4801 .mode = COMMAND_EXEC,
4802 .jim_handler = jim_target_md,
4803 .help = "Display target memory as 8-bit bytes",
4804 .usage = "address [count]",
4805 },
4806 {
4807 .name = "array2mem",
4808 .mode = COMMAND_EXEC,
4809 .jim_handler = jim_target_array2mem,
4810 .help = "Writes Tcl array of 8/16/32 bit numbers "
4811 "to target memory",
4812 .usage = "arrayname bitwidth address count",
4813 },
4814 {
4815 .name = "mem2array",
4816 .mode = COMMAND_EXEC,
4817 .jim_handler = jim_target_mem2array,
4818 .help = "Loads Tcl array of 8/16/32 bit numbers "
4819 "from target memory",
4820 .usage = "arrayname bitwidth address count",
4821 },
4822 {
4823 .name = "eventlist",
4824 .mode = COMMAND_EXEC,
4825 .jim_handler = jim_target_event_list,
4826 .help = "displays a table of events defined for this target",
4827 },
4828 {
4829 .name = "curstate",
4830 .mode = COMMAND_EXEC,
4831 .jim_handler = jim_target_current_state,
4832 .help = "displays the current state of this target",
4833 },
4834 {
4835 .name = "arp_examine",
4836 .mode = COMMAND_EXEC,
4837 .jim_handler = jim_target_examine,
4838 .help = "used internally for reset processing",
4839 },
4840 {
4841 .name = "arp_halt_gdb",
4842 .mode = COMMAND_EXEC,
4843 .jim_handler = jim_target_halt_gdb,
4844 .help = "used internally for reset processing to halt GDB",
4845 },
4846 {
4847 .name = "arp_poll",
4848 .mode = COMMAND_EXEC,
4849 .jim_handler = jim_target_poll,
4850 .help = "used internally for reset processing",
4851 },
4852 {
4853 .name = "arp_reset",
4854 .mode = COMMAND_EXEC,
4855 .jim_handler = jim_target_reset,
4856 .help = "used internally for reset processing",
4857 },
4858 {
4859 .name = "arp_halt",
4860 .mode = COMMAND_EXEC,
4861 .jim_handler = jim_target_halt,
4862 .help = "used internally for reset processing",
4863 },
4864 {
4865 .name = "arp_waitstate",
4866 .mode = COMMAND_EXEC,
4867 .jim_handler = jim_target_wait_state,
4868 .help = "used internally for reset processing",
4869 },
4870 {
4871 .name = "invoke-event",
4872 .mode = COMMAND_EXEC,
4873 .jim_handler = jim_target_invoke_event,
4874 .help = "invoke handler for specified event",
4875 .usage = "event_name",
4876 },
4877 COMMAND_REGISTRATION_DONE
4878 };
4879
4880 static int target_create(Jim_GetOptInfo *goi)
4881 {
4882 Jim_Obj *new_cmd;
4883 Jim_Cmd *cmd;
4884 const char *cp;
4885 char *cp2;
4886 int e;
4887 int x;
4888 struct target *target;
4889 struct command_context *cmd_ctx;
4890
4891 cmd_ctx = current_command_context(goi->interp);
4892 assert (cmd_ctx != NULL);
4893
4894 if (goi->argc < 3) {
4895 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4896 return JIM_ERR;
4897 }
4898
4899 /* COMMAND */
4900 Jim_GetOpt_Obj(goi, &new_cmd);
4901 /* does this command exist? */
4902 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4903 if (cmd) {
4904 cp = Jim_GetString(new_cmd, NULL);
4905 Jim_SetResultFormatted(goi->interp, "Command/target: %s Exists", cp);
4906 return JIM_ERR;
4907 }
4908
4909 /* TYPE */
4910 e = Jim_GetOpt_String(goi, &cp2, NULL);
4911 if (e != JIM_OK)
4912 return e;
4913 cp = cp2;
4914 /* now does target type exist */
4915 for (x = 0 ; target_types[x] ; x++) {
4916 if (0 == strcmp(cp, target_types[x]->name)) {
4917 /* found */
4918 break;
4919 }
4920 }
4921 if (target_types[x] == NULL) {
4922 Jim_SetResultFormatted(goi->interp, "Unknown target type %s, try one of ", cp);
4923 for (x = 0 ; target_types[x] ; x++) {
4924 if (target_types[x + 1]) {
4925 Jim_AppendStrings(goi->interp,
4926 Jim_GetResult(goi->interp),
4927 target_types[x]->name,
4928 ", ", NULL);
4929 } else {
4930 Jim_AppendStrings(goi->interp,
4931 Jim_GetResult(goi->interp),
4932 " or ",
4933 target_types[x]->name,NULL);
4934 }
4935 }
4936 return JIM_ERR;
4937 }
4938
4939 /* Create it */
4940 target = calloc(1,sizeof(struct target));
4941 /* set target number */
4942 target->target_number = new_target_number();
4943
4944 /* allocate memory for each unique target type */
4945 target->type = (struct target_type*)calloc(1,sizeof(struct target_type));
4946
4947 memcpy(target->type, target_types[x], sizeof(struct target_type));
4948
4949 /* will be set by "-endian" */
4950 target->endianness = TARGET_ENDIAN_UNKNOWN;
4951
4952 /* default to first core, override with -coreid */
4953 target->coreid = 0;
4954
4955 target->working_area = 0x0;
4956 target->working_area_size = 0x0;
4957 target->working_areas = NULL;
4958 target->backup_working_area = 0;
4959
4960 target->state = TARGET_UNKNOWN;
4961 target->debug_reason = DBG_REASON_UNDEFINED;
4962 target->reg_cache = NULL;
4963 target->breakpoints = NULL;
4964 target->watchpoints = NULL;
4965 target->next = NULL;
4966 target->arch_info = NULL;
4967
4968 target->display = 1;
4969
4970 target->halt_issued = false;
4971
4972 /* initialize trace information */
4973 target->trace_info = malloc(sizeof(struct trace));
4974 target->trace_info->num_trace_points = 0;
4975 target->trace_info->trace_points_size = 0;
4976 target->trace_info->trace_points = NULL;
4977 target->trace_info->trace_history_size = 0;
4978 target->trace_info->trace_history = NULL;
4979 target->trace_info->trace_history_pos = 0;
4980 target->trace_info->trace_history_overflowed = 0;
4981
4982 target->dbgmsg = NULL;
4983 target->dbg_msg_enabled = 0;
4984
4985 target->endianness = TARGET_ENDIAN_UNKNOWN;
4986
4987 target->rtos = NULL;
4988 target->rtos_auto_detect = false;
4989
4990 /* Do the rest as "configure" options */
4991 goi->isconfigure = 1;
4992 e = target_configure(goi, target);
4993
4994 if (target->tap == NULL)
4995 {
4996 Jim_SetResultString(goi->interp, "-chain-position required when creating target", -1);
4997 e = JIM_ERR;
4998 }
4999
5000 if (e != JIM_OK) {
5001 free(target->type);
5002 free(target);
5003 return e;
5004 }
5005
5006 if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
5007 /* default endian to little if not specified */
5008 target->endianness = TARGET_LITTLE_ENDIAN;
5009 }
5010
5011 /* incase variant is not set */
5012 if (!target->variant)
5013 target->variant = strdup("");
5014
5015 cp = Jim_GetString(new_cmd, NULL);
5016 target->cmd_name = strdup(cp);
5017
5018 /* create the target specific commands */
5019 if (target->type->commands) {
5020 e = register_commands(cmd_ctx, NULL, target->type->commands);
5021 if (ERROR_OK != e)
5022 LOG_ERROR("unable to register '%s' commands", cp);
5023 }
5024 if (target->type->target_create) {
5025 (*(target->type->target_create))(target, goi->interp);
5026 }
5027
5028 /* append to end of list */
5029 {
5030 struct target **tpp;
5031 tpp = &(all_targets);
5032 while (*tpp) {
5033 tpp = &((*tpp)->next);
5034 }
5035 *tpp = target;
5036 }
5037
5038 /* now - create the new target name command */
5039 const const struct command_registration target_subcommands[] = {
5040 {
5041 .chain = target_instance_command_handlers,
5042 },
5043 {
5044 .chain = target->type->commands,
5045 },
5046 COMMAND_REGISTRATION_DONE
5047 };
5048 const const struct command_registration target_commands[] = {
5049 {
5050 .name = cp,
5051 .mode = COMMAND_ANY,
5052 .help = "target command group",
5053 .chain = target_subcommands,
5054 },
5055 COMMAND_REGISTRATION_DONE
5056 };
5057 e = register_commands(cmd_ctx, NULL, target_commands);
5058 if (ERROR_OK != e)
5059 return JIM_ERR;
5060
5061 struct command *c = command_find_in_context(cmd_ctx, cp);
5062 assert(c);
5063 command_set_handler_data(c, target);
5064
5065 return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
5066 }
5067
5068 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5069 {
5070 if (argc != 1)
5071 {
5072 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5073 return JIM_ERR;
5074 }
5075 struct command_context *cmd_ctx = current_command_context(interp);
5076 assert (cmd_ctx != NULL);
5077
5078 Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
5079 return JIM_OK;
5080 }
5081
5082 static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5083 {
5084 if (argc != 1)
5085 {
5086 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5087 return JIM_ERR;
5088 }
5089 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
5090 for (unsigned x = 0; NULL != target_types[x]; x++)
5091 {
5092 Jim_ListAppendElement(interp, Jim_GetResult(interp),
5093 Jim_NewStringObj(interp, target_types[x]->name, -1));
5094 }
5095 return JIM_OK;
5096 }
5097
5098 static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5099 {
5100 if (argc != 1)
5101 {
5102 Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
5103 return JIM_ERR;
5104 }
5105 Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
5106 struct target *target = all_targets;
5107 while (target)
5108 {
5109 Jim_ListAppendElement(interp, Jim_GetResult(interp),
5110 Jim_NewStringObj(interp, target_name(target), -1));
5111 target = target->next;
5112 }
5113 return JIM_OK;
5114 }
5115
5116 static int jim_target_smp(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5117 {
5118 int i;
5119 const char *targetname;
5120 int retval,len;
5121 struct target *target;
5122 struct target_list *head, *curr;
5123 curr = (struct target_list*) NULL;
5124 head = (struct target_list*) NULL;
5125
5126 retval = 0;
5127 LOG_DEBUG("%d",argc);
5128 /* argv[1] = target to associate in smp
5129 * argv[2] = target to assoicate in smp
5130 * argv[3] ...
5131 */
5132
5133 for(i=1;i<argc;i++)
5134 {
5135
5136 targetname = Jim_GetString(argv[i], &len);
5137 target = get_target(targetname);
5138 LOG_DEBUG("%s ",targetname);
5139 if (target)
5140 {
5141 struct target_list *new;
5142 new=malloc(sizeof(struct target_list));
5143 new->target = target;
5144 new->next = (struct target_list*)NULL;
5145 if (head == (struct target_list*)NULL)
5146 {
5147 head = new;
5148 curr = head;
5149 }
5150 else
5151 {
5152 curr->next = new;
5153 curr = new;
5154 }
5155 }
5156 }
5157 /* now parse the list of cpu and put the target in smp mode*/
5158 curr=head;
5159
5160 while(curr!=(struct target_list *)NULL)
5161 {
5162 target=curr->target;
5163 target->smp = 1;
5164 target->head = head;
5165 curr=curr->next;
5166 }
5167 return retval;
5168 }
5169
5170
5171 static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5172 {
5173 Jim_GetOptInfo goi;
5174 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
5175 if (goi.argc < 3)
5176 {
5177 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
5178 "<name> <target_type> [<target_options> ...]");
5179 return JIM_ERR;
5180 }
5181 return target_create(&goi);
5182 }
5183
5184 static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5185 {
5186 Jim_GetOptInfo goi;
5187 Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
5188
5189 /* It's OK to remove this mechanism sometime after August 2010 or so */
5190 LOG_WARNING("don't use numbers as target identifiers; use names");
5191 if (goi.argc != 1)
5192 {
5193 Jim_SetResultFormatted(goi.interp, "usage: target number <number>");
5194 return JIM_ERR;
5195 }
5196 jim_wide w;
5197 int e = Jim_GetOpt_Wide(&goi, &w);
5198 if (e != JIM_OK)
5199 return JIM_ERR;
5200
5201 struct target *target;
5202 for (target = all_targets; NULL != target; target = target->next)
5203 {
5204 if (target->target_number != w)
5205 continue;
5206
5207 Jim_SetResultString(goi.interp, target_name(target), -1);
5208 return JIM_OK;
5209 }
5210 {
5211 Jim_Obj *wObj = Jim_NewIntObj(goi.interp, w);
5212 Jim_SetResultFormatted(goi.interp,
5213 "Target: number %#s does not exist", wObj);
5214 Jim_FreeNewObj(interp, wObj);
5215 }
5216 return JIM_ERR;
5217 }
5218
5219 static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
5220 {
5221 if (argc != 1)
5222 {
5223 Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
5224 return JIM_ERR;
5225 }
5226 unsigned count = 0;
5227 struct target *target = all_targets;
5228 while (NULL != target)
5229 {
5230 target = target->next;
5231 count++;
5232 }
5233 Jim_SetResult(interp, Jim_NewIntObj(interp, count));
5234 return JIM_OK;
5235 }
5236
5237 static const struct command_registration target_subcommand_handlers[] = {
5238 {
5239 .name = "init",
5240 .mode = COMMAND_CONFIG,
5241 .handler = handle_target_init_command,
5242 .help = "initialize targets",
5243 },
5244 {
5245 .name = "create",
5246 /* REVISIT this should be COMMAND_CONFIG ... */
5247 .mode = COMMAND_ANY,
5248 .jim_handler = jim_target_create,
5249 .usage = "name type '-chain-position' name [options ...]",
5250 .help = "Creates and selects a new target",
5251 },
5252 {
5253 .name = "current",
5254 .mode = COMMAND_ANY,
5255 .jim_handler = jim_target_current,
5256 .help = "Returns the currently selected target",
5257 },
5258 {
5259 .name = "types",
5260 .mode = COMMAND_ANY,
5261 .jim_handler = jim_target_types,
5262 .help = "Returns the available target types as "
5263 "a list of strings",
5264 },
5265 {
5266 .name = "names",
5267 .mode = COMMAND_ANY,
5268 .jim_handler = jim_target_names,
5269 .help = "Returns the names of all targets as a list of strings",
5270 },
5271 {
5272 .name = "number",
5273 .mode = COMMAND_ANY,
5274 .jim_handler = jim_target_number,
5275 .usage = "number",
5276 .help = "Returns the name of the numbered target "
5277 "(DEPRECATED)",
5278 },
5279 {
5280 .name = "count",
5281 .mode = COMMAND_ANY,
5282 .jim_handler = jim_target_count,
5283 .help = "Returns the number of targets as an integer "
5284 "(DEPRECATED)",
5285 },
5286 {
5287 .name = "smp",
5288 .mode = COMMAND_ANY,
5289 .jim_handler = jim_target_smp,
5290 .usage = "targetname1 targetname2 ...",
5291 .help = "gather several target in a smp list"
5292 },
5293
5294 COMMAND_REGISTRATION_DONE
5295 };
5296
5297 struct FastLoad
5298 {
5299 uint32_t address;
5300 uint8_t *data;
5301 int length;
5302
5303 };
5304
5305 static int fastload_num;
5306 static struct FastLoad *fastload;
5307
5308 static void free_fastload(void)
5309 {
5310 if (fastload != NULL)
5311 {
5312 int i;
5313 for (i = 0; i < fastload_num; i++)
5314 {
5315 if (fastload[i].data)
5316 free(fastload[i].data);
5317 }
5318 free(fastload);
5319 fastload = NULL;
5320 }
5321 }
5322
5323
5324
5325
5326 COMMAND_HANDLER(handle_fast_load_image_command)
5327 {
5328 uint8_t *buffer;
5329 size_t buf_cnt;
5330 uint32_t image_size;
5331 uint32_t min_address = 0;
5332 uint32_t max_address = 0xffffffff;
5333 int i;
5334
5335 struct image image;
5336
5337 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
5338 &image, &min_address, &max_address);
5339 if (ERROR_OK != retval)
5340 return retval;
5341
5342 struct duration bench;
5343 duration_start(&bench);
5344
5345 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
5346 if (retval != ERROR_OK)
5347 {
5348 return retval;
5349 }
5350
5351 image_size = 0x0;
5352 retval = ERROR_OK;
5353 fastload_num = image.num_sections;
5354 fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
5355 if (fastload == NULL)
5356 {
5357 command_print(CMD_CTX, "out of memory");
5358 image_close(&image);
5359 return ERROR_FAIL;
5360 }
5361 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
5362 for (i = 0; i < image.num_sections; i++)
5363 {
5364 buffer = malloc(image.sections[i].size);
5365 if (buffer == NULL)
5366 {
5367 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
5368 (int)(image.sections[i].size));
5369 retval = ERROR_FAIL;
5370 break;
5371 }
5372
5373 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
5374 {
5375 free(buffer);
5376 break;
5377 }
5378
5379 uint32_t offset = 0;
5380 uint32_t length = buf_cnt;
5381
5382
5383 /* DANGER!!! beware of unsigned comparision here!!! */
5384
5385 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
5386 (image.sections[i].base_address < max_address))
5387 {
5388 if (image.sections[i].base_address < min_address)
5389 {
5390 /* clip addresses below */
5391 offset += min_address-image.sections[i].base_address;
5392 length -= offset;
5393 }
5394
5395 if (image.sections[i].base_address + buf_cnt > max_address)
5396 {
5397 length -= (image.sections[i].base_address + buf_cnt)-max_address;
5398 }
5399
5400 fastload[i].address = image.sections[i].base_address + offset;
5401 fastload[i].data = malloc(length);
5402 if (fastload[i].data == NULL)
5403 {
5404 free(buffer);
5405 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
5406 length);
5407 retval = ERROR_FAIL;
5408 break;
5409 }
5410 memcpy(fastload[i].data, buffer + offset, length);
5411 fastload[i].length = length;
5412
5413 image_size += length;
5414 command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
5415 (unsigned int)length,
5416 ((unsigned int)(image.sections[i].base_address + offset)));
5417 }
5418
5419 free(buffer);
5420 }
5421
5422 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
5423 {
5424 command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
5425 "in %fs (%0.3f KiB/s)", image_size,
5426 duration_elapsed(&bench), duration_kbps(&bench, image_size));
5427
5428 command_print(CMD_CTX,
5429 "WARNING: image has not been loaded to target!"
5430 "You can issue a 'fast_load' to finish loading.");
5431 }
5432
5433 image_close(&image);
5434
5435 if (retval != ERROR_OK)
5436 {
5437 free_fastload();
5438 }
5439
5440 return retval;
5441 }
5442
5443 COMMAND_HANDLER(handle_fast_load_command)
5444 {
5445 if (CMD_ARGC > 0)
5446 return ERROR_COMMAND_SYNTAX_ERROR;
5447 if (fastload == NULL)
5448 {
5449 LOG_ERROR("No image in memory");
5450 return ERROR_FAIL;
5451 }
5452 int i;
5453 int ms = timeval_ms();
5454 int size = 0;
5455 int retval = ERROR_OK;
5456 for (i = 0; i < fastload_num;i++)
5457 {
5458 struct target *target = get_current_target(CMD_CTX);
5459 command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
5460 (unsigned int)(fastload[i].address),
5461 (unsigned int)(fastload[i].length));
5462 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
5463 if (retval != ERROR_OK)
5464 {
5465 break;
5466 }
5467 size += fastload[i].length;
5468 }
5469 if (retval == ERROR_OK)
5470 {
5471 int after = timeval_ms();
5472 command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
5473 }
5474 return retval;
5475 }
5476
5477 static const struct command_registration target_command_handlers[] = {
5478 {
5479 .name = "targets",
5480 .handler = handle_targets_command,
5481 .mode = COMMAND_ANY,
5482 .help = "change current default target (one parameter) "
5483 "or prints table of all targets (no parameters)",
5484 .usage = "[target]",
5485 },
5486 {
5487 .name = "target",
5488 .mode = COMMAND_CONFIG,
5489 .help = "configure target",
5490
5491 .chain = target_subcommand_handlers,
5492 },
5493 COMMAND_REGISTRATION_DONE
5494 };
5495
5496 int target_register_commands(struct command_context *cmd_ctx)
5497 {
5498 return register_commands(cmd_ctx, NULL, target_command_handlers);
5499 }
5500
5501 static bool target_reset_nag = true;
5502
5503 bool get_target_reset_nag(void)
5504 {
5505 return target_reset_nag;
5506 }
5507
5508 COMMAND_HANDLER(handle_target_reset_nag)
5509 {
5510 return CALL_COMMAND_HANDLER(handle_command_parse_bool,
5511 &target_reset_nag, "Nag after each reset about options to improve "
5512 "performance");
5513 }
5514
5515 static const struct command_registration target_exec_command_handlers[] = {
5516 {
5517 .name = "fast_load_image",
5518 .handler = handle_fast_load_image_command,
5519 .mode = COMMAND_ANY,
5520 .help = "Load image into server memory for later use by "
5521 "fast_load; primarily for profiling",
5522 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5523 "[min_address [max_length]]",
5524 },
5525 {
5526 .name = "fast_load",
5527 .handler = handle_fast_load_command,
5528 .mode = COMMAND_EXEC,
5529 .help = "loads active fast load image to current target "
5530 "- mainly for profiling purposes",
5531 .usage = "",
5532 },
5533 {
5534 .name = "profile",
5535 .handler = handle_profile_command,
5536 .mode = COMMAND_EXEC,
5537 .usage = "seconds filename",
5538 .help = "profiling samples the CPU PC",
5539 },
5540 /** @todo don't register virt2phys() unless target supports it */
5541 {
5542 .name = "virt2phys",
5543 .handler = handle_virt2phys_command,
5544 .mode = COMMAND_ANY,
5545 .help = "translate a virtual address into a physical address",
5546 .usage = "virtual_address",
5547 },
5548 {
5549 .name = "reg",
5550 .handler = handle_reg_command,
5551 .mode = COMMAND_EXEC,
5552 .help = "display or set a register; with no arguments, "
5553 "displays all registers and their values",
5554 .usage = "[(register_name|register_number) [value]]",
5555 },
5556 {
5557 .name = "poll",
5558 .handler = handle_poll_command,
5559 .mode = COMMAND_EXEC,
5560 .help = "poll target state; or reconfigure background polling",
5561 .usage = "['on'|'off']",
5562 },
5563 {
5564 .name = "wait_halt",
5565 .handler = handle_wait_halt_command,
5566 .mode = COMMAND_EXEC,
5567 .help = "wait up to the specified number of milliseconds "
5568 "(default 5) for a previously requested halt",
5569 .usage = "[milliseconds]",
5570 },
5571 {
5572 .name = "halt",
5573 .handler = handle_halt_command,
5574 .mode = COMMAND_EXEC,
5575 .help = "request target to halt, then wait up to the specified"
5576 "number of milliseconds (default 5) for it to complete",
5577 .usage = "[milliseconds]",
5578 },
5579 {
5580 .name = "resume",
5581 .handler = handle_resume_command,
5582 .mode = COMMAND_EXEC,
5583 .help = "resume target execution from current PC or address",
5584 .usage = "[address]",
5585 },
5586 {
5587 .name = "reset",
5588 .handler = handle_reset_command,
5589 .mode = COMMAND_EXEC,
5590 .usage = "[run|halt|init]",
5591 .help = "Reset all targets into the specified mode."
5592 "Default reset mode is run, if not given.",
5593 },
5594 {
5595 .name = "soft_reset_halt",
5596 .handler = handle_soft_reset_halt_command,
5597 .mode = COMMAND_EXEC,
5598 .usage = "",
5599 .help = "halt the target and do a soft reset",
5600 },
5601 {
5602 .name = "step",
5603 .handler = handle_step_command,
5604 .mode = COMMAND_EXEC,
5605 .help = "step one instruction from current PC or address",
5606 .usage = "[address]",
5607 },
5608 {
5609 .name = "mdw",
5610 .handler = handle_md_command,
5611 .mode = COMMAND_EXEC,
5612 .help = "display memory words",
5613 .usage = "['phys'] address [count]",
5614 },
5615 {
5616 .name = "mdh",
5617 .handler = handle_md_command,
5618 .mode = COMMAND_EXEC,
5619 .help = "display memory half-words",
5620 .usage = "['phys'] address [count]",
5621 },
5622 {
5623 .name = "mdb",
5624 .handler = handle_md_command,
5625 .mode = COMMAND_EXEC,
5626 .help = "display memory bytes",
5627 .usage = "['phys'] address [count]",
5628 },
5629 {
5630 .name = "mww",
5631 .handler = handle_mw_command,
5632 .mode = COMMAND_EXEC,
5633 .help = "write memory word",
5634 .usage = "['phys'] address value [count]",
5635 },
5636 {
5637 .name = "mwh",
5638 .handler = handle_mw_command,
5639 .mode = COMMAND_EXEC,
5640 .help = "write memory half-word",
5641 .usage = "['phys'] address value [count]",
5642 },
5643 {
5644 .name = "mwb",
5645 .handler = handle_mw_command,
5646 .mode = COMMAND_EXEC,
5647 .help = "write memory byte",
5648 .usage = "['phys'] address value [count]",
5649 },
5650 {
5651 .name = "bp",
5652 .handler = handle_bp_command,
5653 .mode = COMMAND_EXEC,
5654 .help = "list or set hardware or software breakpoint",
5655 .usage = "<address> [<asid>]<length> ['hw'|'hw_ctx']",
5656 },
5657 {
5658 .name = "rbp",
5659 .handler = handle_rbp_command,
5660 .mode = COMMAND_EXEC,
5661 .help = "remove breakpoint",
5662 .usage = "address",
5663 },
5664 {
5665 .name = "wp",
5666 .handler = handle_wp_command,
5667 .mode = COMMAND_EXEC,
5668 .help = "list (no params) or create watchpoints",
5669 .usage = "[address length [('r'|'w'|'a') value [mask]]]",
5670 },
5671 {
5672 .name = "rwp",
5673 .handler = handle_rwp_command,
5674 .mode = COMMAND_EXEC,
5675 .help = "remove watchpoint",
5676 .usage = "address",
5677 },
5678 {
5679 .name = "load_image",
5680 .handler = handle_load_image_command,
5681 .mode = COMMAND_EXEC,
5682 .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
5683 "[min_address] [max_length]",
5684 },
5685 {
5686 .name = "dump_image",
5687 .handler = handle_dump_image_command,
5688 .mode = COMMAND_EXEC,
5689 .usage = "filename address size",
5690 },
5691 {
5692 .name = "verify_image",
5693 .handler = handle_verify_image_command,
5694 .mode = COMMAND_EXEC,
5695 .usage = "filename [offset [type]]",
5696 },
5697 {
5698 .name = "test_image",
5699 .handler = handle_test_image_command,
5700 .mode = COMMAND_EXEC,
5701 .usage = "filename [offset [type]]",
5702 },
5703 {
5704 .name = "mem2array",
5705 .mode = COMMAND_EXEC,
5706 .jim_handler = jim_mem2array,
5707 .help = "read 8/16/32 bit memory and return as a TCL array "
5708 "for script processing",
5709 .usage = "arrayname bitwidth address count",
5710 },
5711 {
5712 .name = "array2mem",
5713 .mode = COMMAND_EXEC,
5714 .jim_handler = jim_array2mem,
5715 .help = "convert a TCL array to memory locations "
5716 "and write the 8/16/32 bit values",
5717 .usage = "arrayname bitwidth address count",
5718 },
5719 {
5720 .name = "reset_nag",
5721 .handler = handle_target_reset_nag,
5722 .mode = COMMAND_ANY,
5723 .help = "Nag after each reset about options that could have been "
5724 "enabled to improve performance. ",
5725 .usage = "['enable'|'disable']",
5726 },
5727 COMMAND_REGISTRATION_DONE
5728 };
5729 static int target_register_user_commands(struct command_context *cmd_ctx)
5730 {
5731 int retval = ERROR_OK;
5732 if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
5733 return retval;
5734
5735 if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
5736 return retval;
5737
5738
5739 return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
5740 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)