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