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