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