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