Code Review / openocd.git / blob
? search:


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