Code Review / openocd.git / blob
? search:


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

Linking to existing account procedure

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

SSH host keys fingerprints

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