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