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