Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
use COMMAND_PARSE_ON_OFF where appropriate
[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 (CMD_ARGC == 1)
1652 {
1653 target = get_target(CMD_ARGV[0]);
1654 if (target == NULL) {
1655 command_print(CMD_CTX,"Target: %s is unknown, try one of:\n", CMD_ARGV[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 (CMD_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 ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9'))
1912 {
1913 unsigned num;
1914 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[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, CMD_ARGV[0], 1);
1942
1943 if (!reg)
1944 {
1945 command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
1946 return ERROR_OK;
1947 }
1948 }
1949
1950 /* display a register */
1951 if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0') && (CMD_ARGV[1][0] <= '9'))))
1952 {
1953 if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[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 (CMD_ARGC == 2)
1968 {
1969 uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
1970 str_to_buf(CMD_ARGV[1], strlen(CMD_ARGV[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 (CMD_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 else if (CMD_ARGC == 1)
2008 {
2009 bool enable;
2010 COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
2011 jtag_poll_set_enabled(enable);
2012 }
2013 else
2014 {
2015 return ERROR_COMMAND_SYNTAX_ERROR;
2016 }
2017
2018 return retval;
2019 }
2020
2021 COMMAND_HANDLER(handle_wait_halt_command)
2022 {
2023 if (CMD_ARGC > 1)
2024 return ERROR_COMMAND_SYNTAX_ERROR;
2025
2026 unsigned ms = 5000;
2027 if (1 == CMD_ARGC)
2028 {
2029 int retval = parse_uint(CMD_ARGV[0], &ms);
2030 if (ERROR_OK != retval)
2031 {
2032 command_print(CMD_CTX, "usage: %s [seconds]", CMD_NAME);
2033 return ERROR_COMMAND_SYNTAX_ERROR;
2034 }
2035 // convert seconds (given) to milliseconds (needed)
2036 ms *= 1000;
2037 }
2038
2039 struct target *target = get_current_target(CMD_CTX);
2040 return target_wait_state(target, TARGET_HALTED, ms);
2041 }
2042
2043 /* wait for target state to change. The trick here is to have a low
2044 * latency for short waits and not to suck up all the CPU time
2045 * on longer waits.
2046 *
2047 * After 500ms, keep_alive() is invoked
2048 */
2049 int target_wait_state(struct target *target, enum target_state state, int ms)
2050 {
2051 int retval;
2052 long long then = 0, cur;
2053 int once = 1;
2054
2055 for (;;)
2056 {
2057 if ((retval = target_poll(target)) != ERROR_OK)
2058 return retval;
2059 if (target->state == state)
2060 {
2061 break;
2062 }
2063 cur = timeval_ms();
2064 if (once)
2065 {
2066 once = 0;
2067 then = timeval_ms();
2068 LOG_DEBUG("waiting for target %s...",
2069 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2070 }
2071
2072 if (cur-then > 500)
2073 {
2074 keep_alive();
2075 }
2076
2077 if ((cur-then) > ms)
2078 {
2079 LOG_ERROR("timed out while waiting for target %s",
2080 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2081 return ERROR_FAIL;
2082 }
2083 }
2084
2085 return ERROR_OK;
2086 }
2087
2088 COMMAND_HANDLER(handle_halt_command)
2089 {
2090 LOG_DEBUG("-");
2091
2092 struct target *target = get_current_target(CMD_CTX);
2093 int retval = target_halt(target);
2094 if (ERROR_OK != retval)
2095 return retval;
2096
2097 if (CMD_ARGC == 1)
2098 {
2099 unsigned wait;
2100 retval = parse_uint(CMD_ARGV[0], &wait);
2101 if (ERROR_OK != retval)
2102 return ERROR_COMMAND_SYNTAX_ERROR;
2103 if (!wait)
2104 return ERROR_OK;
2105 }
2106
2107 return CALL_COMMAND_HANDLER(handle_wait_halt_command);
2108 }
2109
2110 COMMAND_HANDLER(handle_soft_reset_halt_command)
2111 {
2112 struct target *target = get_current_target(CMD_CTX);
2113
2114 LOG_USER("requesting target halt and executing a soft reset");
2115
2116 target->type->soft_reset_halt(target);
2117
2118 return ERROR_OK;
2119 }
2120
2121 COMMAND_HANDLER(handle_reset_command)
2122 {
2123 if (CMD_ARGC > 1)
2124 return ERROR_COMMAND_SYNTAX_ERROR;
2125
2126 enum target_reset_mode reset_mode = RESET_RUN;
2127 if (CMD_ARGC == 1)
2128 {
2129 const Jim_Nvp *n;
2130 n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]);
2131 if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
2132 return ERROR_COMMAND_SYNTAX_ERROR;
2133 }
2134 reset_mode = n->value;
2135 }
2136
2137 /* reset *all* targets */
2138 return target_process_reset(CMD_CTX, reset_mode);
2139 }
2140
2141
2142 COMMAND_HANDLER(handle_resume_command)
2143 {
2144 int current = 1;
2145 if (CMD_ARGC > 1)
2146 return ERROR_COMMAND_SYNTAX_ERROR;
2147
2148 struct target *target = get_current_target(CMD_CTX);
2149 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
2150
2151 /* with no CMD_ARGV, resume from current pc, addr = 0,
2152 * with one arguments, addr = CMD_ARGV[0],
2153 * handle breakpoints, not debugging */
2154 uint32_t addr = 0;
2155 if (CMD_ARGC == 1)
2156 {
2157 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2158 current = 0;
2159 }
2160
2161 return target_resume(target, current, addr, 1, 0);
2162 }
2163
2164 COMMAND_HANDLER(handle_step_command)
2165 {
2166 if (CMD_ARGC > 1)
2167 return ERROR_COMMAND_SYNTAX_ERROR;
2168
2169 LOG_DEBUG("-");
2170
2171 /* with no CMD_ARGV, step from current pc, addr = 0,
2172 * with one argument addr = CMD_ARGV[0],
2173 * handle breakpoints, debugging */
2174 uint32_t addr = 0;
2175 int current_pc = 1;
2176 if (CMD_ARGC == 1)
2177 {
2178 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2179 current_pc = 0;
2180 }
2181
2182 struct target *target = get_current_target(CMD_CTX);
2183
2184 return target->type->step(target, current_pc, addr, 1);
2185 }
2186
2187 static void handle_md_output(struct command_context *cmd_ctx,
2188 struct target *target, uint32_t address, unsigned size,
2189 unsigned count, const uint8_t *buffer)
2190 {
2191 const unsigned line_bytecnt = 32;
2192 unsigned line_modulo = line_bytecnt / size;
2193
2194 char output[line_bytecnt * 4 + 1];
2195 unsigned output_len = 0;
2196
2197 const char *value_fmt;
2198 switch (size) {
2199 case 4: value_fmt = "%8.8x "; break;
2200 case 2: value_fmt = "%4.2x "; break;
2201 case 1: value_fmt = "%2.2x "; break;
2202 default:
2203 LOG_ERROR("invalid memory read size: %u", size);
2204 exit(-1);
2205 }
2206
2207 for (unsigned i = 0; i < count; i++)
2208 {
2209 if (i % line_modulo == 0)
2210 {
2211 output_len += snprintf(output + output_len,
2212 sizeof(output) - output_len,
2213 "0x%8.8x: ",
2214 (unsigned)(address + (i*size)));
2215 }
2216
2217 uint32_t value = 0;
2218 const uint8_t *value_ptr = buffer + i * size;
2219 switch (size) {
2220 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2221 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2222 case 1: value = *value_ptr;
2223 }
2224 output_len += snprintf(output + output_len,
2225 sizeof(output) - output_len,
2226 value_fmt, value);
2227
2228 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2229 {
2230 command_print(cmd_ctx, "%s", output);
2231 output_len = 0;
2232 }
2233 }
2234 }
2235
2236 COMMAND_HANDLER(handle_md_command)
2237 {
2238 if (CMD_ARGC < 1)
2239 return ERROR_COMMAND_SYNTAX_ERROR;
2240
2241 unsigned size = 0;
2242 switch (CMD_NAME[2]) {
2243 case 'w': size = 4; break;
2244 case 'h': size = 2; break;
2245 case 'b': size = 1; break;
2246 default: return ERROR_COMMAND_SYNTAX_ERROR;
2247 }
2248
2249 bool physical=strcmp(CMD_ARGV[0], "phys")==0;
2250 int (*fn)(struct target *target,
2251 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2252 if (physical)
2253 {
2254 CMD_ARGC--;
2255 CMD_ARGV++;
2256 fn=target_read_phys_memory;
2257 } else
2258 {
2259 fn=target_read_memory;
2260 }
2261 if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
2262 {
2263 return ERROR_COMMAND_SYNTAX_ERROR;
2264 }
2265
2266 uint32_t address;
2267 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2268
2269 unsigned count = 1;
2270 if (CMD_ARGC == 2)
2271 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count);
2272
2273 uint8_t *buffer = calloc(count, size);
2274
2275 struct target *target = get_current_target(CMD_CTX);
2276 int retval = fn(target, address, size, count, buffer);
2277 if (ERROR_OK == retval)
2278 handle_md_output(CMD_CTX, target, address, size, count, buffer);
2279
2280 free(buffer);
2281
2282 return retval;
2283 }
2284
2285 COMMAND_HANDLER(handle_mw_command)
2286 {
2287 if (CMD_ARGC < 2)
2288 {
2289 return ERROR_COMMAND_SYNTAX_ERROR;
2290 }
2291 bool physical=strcmp(CMD_ARGV[0], "phys")==0;
2292 int (*fn)(struct target *target,
2293 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2294 if (physical)
2295 {
2296 CMD_ARGC--;
2297 CMD_ARGV++;
2298 fn=target_write_phys_memory;
2299 } else
2300 {
2301 fn=target_write_memory;
2302 }
2303 if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
2304 return ERROR_COMMAND_SYNTAX_ERROR;
2305
2306 uint32_t address;
2307 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
2308
2309 uint32_t value;
2310 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
2311
2312 unsigned count = 1;
2313 if (CMD_ARGC == 3)
2314 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
2315
2316 struct target *target = get_current_target(CMD_CTX);
2317 unsigned wordsize;
2318 uint8_t value_buf[4];
2319 switch (CMD_NAME[2])
2320 {
2321 case 'w':
2322 wordsize = 4;
2323 target_buffer_set_u32(target, value_buf, value);
2324 break;
2325 case 'h':
2326 wordsize = 2;
2327 target_buffer_set_u16(target, value_buf, value);
2328 break;
2329 case 'b':
2330 wordsize = 1;
2331 value_buf[0] = value;
2332 break;
2333 default:
2334 return ERROR_COMMAND_SYNTAX_ERROR;
2335 }
2336 for (unsigned i = 0; i < count; i++)
2337 {
2338 int retval = fn(target,
2339 address + i * wordsize, wordsize, 1, value_buf);
2340 if (ERROR_OK != retval)
2341 return retval;
2342 keep_alive();
2343 }
2344
2345 return ERROR_OK;
2346
2347 }
2348
2349 static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
2350 uint32_t *min_address, uint32_t *max_address)
2351 {
2352 if (CMD_ARGC < 1 || CMD_ARGC > 5)
2353 return ERROR_COMMAND_SYNTAX_ERROR;
2354
2355 /* a base address isn't always necessary,
2356 * default to 0x0 (i.e. don't relocate) */
2357 if (CMD_ARGC >= 2)
2358 {
2359 uint32_t addr;
2360 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2361 image->base_address = addr;
2362 image->base_address_set = 1;
2363 }
2364 else
2365 image->base_address_set = 0;
2366
2367 image->start_address_set = 0;
2368
2369 if (CMD_ARGC >= 4)
2370 {
2371 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
2372 }
2373 if (CMD_ARGC == 5)
2374 {
2375 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
2376 // use size (given) to find max (required)
2377 *max_address += *min_address;
2378 }
2379
2380 if (*min_address > *max_address)
2381 return ERROR_COMMAND_SYNTAX_ERROR;
2382
2383 return ERROR_OK;
2384 }
2385
2386 COMMAND_HANDLER(handle_load_image_command)
2387 {
2388 uint8_t *buffer;
2389 size_t buf_cnt;
2390 uint32_t image_size;
2391 uint32_t min_address = 0;
2392 uint32_t max_address = 0xffffffff;
2393 int i;
2394 struct image image;
2395
2396 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
2397 &image, &min_address, &max_address);
2398 if (ERROR_OK != retval)
2399 return retval;
2400
2401 struct target *target = get_current_target(CMD_CTX);
2402
2403 struct duration bench;
2404 duration_start(&bench);
2405
2406 if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
2407 {
2408 return ERROR_OK;
2409 }
2410
2411 image_size = 0x0;
2412 retval = ERROR_OK;
2413 for (i = 0; i < image.num_sections; i++)
2414 {
2415 buffer = malloc(image.sections[i].size);
2416 if (buffer == NULL)
2417 {
2418 command_print(CMD_CTX,
2419 "error allocating buffer for section (%d bytes)",
2420 (int)(image.sections[i].size));
2421 break;
2422 }
2423
2424 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2425 {
2426 free(buffer);
2427 break;
2428 }
2429
2430 uint32_t offset = 0;
2431 uint32_t length = buf_cnt;
2432
2433 /* DANGER!!! beware of unsigned comparision here!!! */
2434
2435 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
2436 (image.sections[i].base_address < max_address))
2437 {
2438 if (image.sections[i].base_address < min_address)
2439 {
2440 /* clip addresses below */
2441 offset += min_address-image.sections[i].base_address;
2442 length -= offset;
2443 }
2444
2445 if (image.sections[i].base_address + buf_cnt > max_address)
2446 {
2447 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2448 }
2449
2450 if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
2451 {
2452 free(buffer);
2453 break;
2454 }
2455 image_size += length;
2456 command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
2457 (unsigned int)length,
2458 image.sections[i].base_address + offset);
2459 }
2460
2461 free(buffer);
2462 }
2463
2464 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2465 {
2466 command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
2467 "in %fs (%0.3f kb/s)", image_size,
2468 duration_elapsed(&bench), duration_kbps(&bench, image_size));
2469 }
2470
2471 image_close(&image);
2472
2473 return retval;
2474
2475 }
2476
2477 COMMAND_HANDLER(handle_dump_image_command)
2478 {
2479 struct fileio fileio;
2480
2481 uint8_t buffer[560];
2482 int retvaltemp;
2483
2484
2485 struct target *target = get_current_target(CMD_CTX);
2486
2487 if (CMD_ARGC != 3)
2488 {
2489 command_print(CMD_CTX, "usage: dump_image <filename> <address> <size>");
2490 return ERROR_OK;
2491 }
2492
2493 uint32_t address;
2494 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
2495 uint32_t size;
2496 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
2497
2498 if (fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2499 {
2500 return ERROR_OK;
2501 }
2502
2503 struct duration bench;
2504 duration_start(&bench);
2505
2506 int retval = ERROR_OK;
2507 while (size > 0)
2508 {
2509 size_t size_written;
2510 uint32_t this_run_size = (size > 560) ? 560 : size;
2511 retval = target_read_buffer(target, address, this_run_size, buffer);
2512 if (retval != ERROR_OK)
2513 {
2514 break;
2515 }
2516
2517 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2518 if (retval != ERROR_OK)
2519 {
2520 break;
2521 }
2522
2523 size -= this_run_size;
2524 address += this_run_size;
2525 }
2526
2527 if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2528 return retvaltemp;
2529
2530 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2531 {
2532 command_print(CMD_CTX,
2533 "dumped %zu bytes in %fs (%0.3f kb/s)", fileio.size,
2534 duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
2535 }
2536
2537 return retval;
2538 }
2539
2540 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
2541 {
2542 uint8_t *buffer;
2543 size_t buf_cnt;
2544 uint32_t image_size;
2545 int i;
2546 int retval;
2547 uint32_t checksum = 0;
2548 uint32_t mem_checksum = 0;
2549
2550 struct image image;
2551
2552 struct target *target = get_current_target(CMD_CTX);
2553
2554 if (CMD_ARGC < 1)
2555 {
2556 return ERROR_COMMAND_SYNTAX_ERROR;
2557 }
2558
2559 if (!target)
2560 {
2561 LOG_ERROR("no target selected");
2562 return ERROR_FAIL;
2563 }
2564
2565 struct duration bench;
2566 duration_start(&bench);
2567
2568 if (CMD_ARGC >= 2)
2569 {
2570 uint32_t addr;
2571 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
2572 image.base_address = addr;
2573 image.base_address_set = 1;
2574 }
2575 else
2576 {
2577 image.base_address_set = 0;
2578 image.base_address = 0x0;
2579 }
2580
2581 image.start_address_set = 0;
2582
2583 if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK)
2584 {
2585 return retval;
2586 }
2587
2588 image_size = 0x0;
2589 retval = ERROR_OK;
2590 for (i = 0; i < image.num_sections; i++)
2591 {
2592 buffer = malloc(image.sections[i].size);
2593 if (buffer == NULL)
2594 {
2595 command_print(CMD_CTX,
2596 "error allocating buffer for section (%d bytes)",
2597 (int)(image.sections[i].size));
2598 break;
2599 }
2600 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2601 {
2602 free(buffer);
2603 break;
2604 }
2605
2606 if (verify)
2607 {
2608 /* calculate checksum of image */
2609 image_calculate_checksum(buffer, buf_cnt, &checksum);
2610
2611 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2612 if (retval != ERROR_OK)
2613 {
2614 free(buffer);
2615 break;
2616 }
2617
2618 if (checksum != mem_checksum)
2619 {
2620 /* failed crc checksum, fall back to a binary compare */
2621 uint8_t *data;
2622
2623 command_print(CMD_CTX, "checksum mismatch - attempting binary compare");
2624
2625 data = (uint8_t*)malloc(buf_cnt);
2626
2627 /* Can we use 32bit word accesses? */
2628 int size = 1;
2629 int count = buf_cnt;
2630 if ((count % 4) == 0)
2631 {
2632 size *= 4;
2633 count /= 4;
2634 }
2635 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2636 if (retval == ERROR_OK)
2637 {
2638 uint32_t t;
2639 for (t = 0; t < buf_cnt; t++)
2640 {
2641 if (data[t] != buffer[t])
2642 {
2643 command_print(CMD_CTX,
2644 "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
2645 (unsigned)(t + image.sections[i].base_address),
2646 data[t],
2647 buffer[t]);
2648 free(data);
2649 free(buffer);
2650 retval = ERROR_FAIL;
2651 goto done;
2652 }
2653 if ((t%16384) == 0)
2654 {
2655 keep_alive();
2656 }
2657 }
2658 }
2659
2660 free(data);
2661 }
2662 } else
2663 {
2664 command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
2665 image.sections[i].base_address,
2666 buf_cnt);
2667 }
2668
2669 free(buffer);
2670 image_size += buf_cnt;
2671 }
2672 done:
2673 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
2674 {
2675 command_print(CMD_CTX, "verified %" PRIu32 " bytes "
2676 "in %fs (%0.3f kb/s)", image_size,
2677 duration_elapsed(&bench), duration_kbps(&bench, image_size));
2678 }
2679
2680 image_close(&image);
2681
2682 return retval;
2683 }
2684
2685 COMMAND_HANDLER(handle_verify_image_command)
2686 {
2687 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1);
2688 }
2689
2690 COMMAND_HANDLER(handle_test_image_command)
2691 {
2692 return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0);
2693 }
2694
2695 static int handle_bp_command_list(struct command_context *cmd_ctx)
2696 {
2697 struct target *target = get_current_target(cmd_ctx);
2698 struct breakpoint *breakpoint = target->breakpoints;
2699 while (breakpoint)
2700 {
2701 if (breakpoint->type == BKPT_SOFT)
2702 {
2703 char* buf = buf_to_str(breakpoint->orig_instr,
2704 breakpoint->length, 16);
2705 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
2706 breakpoint->address,
2707 breakpoint->length,
2708 breakpoint->set, buf);
2709 free(buf);
2710 }
2711 else
2712 {
2713 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
2714 breakpoint->address,
2715 breakpoint->length, breakpoint->set);
2716 }
2717
2718 breakpoint = breakpoint->next;
2719 }
2720 return ERROR_OK;
2721 }
2722
2723 static int handle_bp_command_set(struct command_context *cmd_ctx,
2724 uint32_t addr, uint32_t length, int hw)
2725 {
2726 struct target *target = get_current_target(cmd_ctx);
2727 int retval = breakpoint_add(target, addr, length, hw);
2728 if (ERROR_OK == retval)
2729 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
2730 else
2731 LOG_ERROR("Failure setting breakpoint");
2732 return retval;
2733 }
2734
2735 COMMAND_HANDLER(handle_bp_command)
2736 {
2737 if (CMD_ARGC == 0)
2738 return handle_bp_command_list(CMD_CTX);
2739
2740 if (CMD_ARGC < 2 || CMD_ARGC > 3)
2741 {
2742 command_print(CMD_CTX, "usage: bp <address> <length> ['hw']");
2743 return ERROR_COMMAND_SYNTAX_ERROR;
2744 }
2745
2746 uint32_t addr;
2747 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2748 uint32_t length;
2749 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
2750
2751 int hw = BKPT_SOFT;
2752 if (CMD_ARGC == 3)
2753 {
2754 if (strcmp(CMD_ARGV[2], "hw") == 0)
2755 hw = BKPT_HARD;
2756 else
2757 return ERROR_COMMAND_SYNTAX_ERROR;
2758 }
2759
2760 return handle_bp_command_set(CMD_CTX, addr, length, hw);
2761 }
2762
2763 COMMAND_HANDLER(handle_rbp_command)
2764 {
2765 if (CMD_ARGC != 1)
2766 return ERROR_COMMAND_SYNTAX_ERROR;
2767
2768 uint32_t addr;
2769 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2770
2771 struct target *target = get_current_target(CMD_CTX);
2772 breakpoint_remove(target, addr);
2773
2774 return ERROR_OK;
2775 }
2776
2777 COMMAND_HANDLER(handle_wp_command)
2778 {
2779 struct target *target = get_current_target(CMD_CTX);
2780
2781 if (CMD_ARGC == 0)
2782 {
2783 struct watchpoint *watchpoint = target->watchpoints;
2784
2785 while (watchpoint)
2786 {
2787 command_print(CMD_CTX, "address: 0x%8.8" PRIx32
2788 ", len: 0x%8.8" PRIx32
2789 ", r/w/a: %i, value: 0x%8.8" PRIx32
2790 ", mask: 0x%8.8" PRIx32,
2791 watchpoint->address,
2792 watchpoint->length,
2793 (int)watchpoint->rw,
2794 watchpoint->value,
2795 watchpoint->mask);
2796 watchpoint = watchpoint->next;
2797 }
2798 return ERROR_OK;
2799 }
2800
2801 enum watchpoint_rw type = WPT_ACCESS;
2802 uint32_t addr = 0;
2803 uint32_t length = 0;
2804 uint32_t data_value = 0x0;
2805 uint32_t data_mask = 0xffffffff;
2806
2807 switch (CMD_ARGC)
2808 {
2809 case 5:
2810 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
2811 // fall through
2812 case 4:
2813 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
2814 // fall through
2815 case 3:
2816 switch (CMD_ARGV[2][0])
2817 {
2818 case 'r':
2819 type = WPT_READ;
2820 break;
2821 case 'w':
2822 type = WPT_WRITE;
2823 break;
2824 case 'a':
2825 type = WPT_ACCESS;
2826 break;
2827 default:
2828 LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
2829 return ERROR_COMMAND_SYNTAX_ERROR;
2830 }
2831 // fall through
2832 case 2:
2833 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
2834 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2835 break;
2836
2837 default:
2838 command_print(CMD_CTX, "usage: wp [address length "
2839 "[(r|w|a) [value [mask]]]]");
2840 return ERROR_COMMAND_SYNTAX_ERROR;
2841 }
2842
2843 int retval = watchpoint_add(target, addr, length, type,
2844 data_value, data_mask);
2845 if (ERROR_OK != retval)
2846 LOG_ERROR("Failure setting watchpoints");
2847
2848 return retval;
2849 }
2850
2851 COMMAND_HANDLER(handle_rwp_command)
2852 {
2853 if (CMD_ARGC != 1)
2854 return ERROR_COMMAND_SYNTAX_ERROR;
2855
2856 uint32_t addr;
2857 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
2858
2859 struct target *target = get_current_target(CMD_CTX);
2860 watchpoint_remove(target, addr);
2861
2862 return ERROR_OK;
2863 }
2864
2865
2866 /**
2867 * Translate a virtual address to a physical address.
2868 *
2869 * The low-level target implementation must have logged a detailed error
2870 * which is forwarded to telnet/GDB session.
2871 */
2872 COMMAND_HANDLER(handle_virt2phys_command)
2873 {
2874 if (CMD_ARGC != 1)
2875 return ERROR_COMMAND_SYNTAX_ERROR;
2876
2877 uint32_t va;
2878 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
2879 uint32_t pa;
2880
2881 struct target *target = get_current_target(CMD_CTX);
2882 int retval = target->type->virt2phys(target, va, &pa);
2883 if (retval == ERROR_OK)
2884 command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
2885
2886 return retval;
2887 }
2888
2889 static void writeData(FILE *f, const void *data, size_t len)
2890 {
2891 size_t written = fwrite(data, 1, len, f);
2892 if (written != len)
2893 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
2894 }
2895
2896 static void writeLong(FILE *f, int l)
2897 {
2898 int i;
2899 for (i = 0; i < 4; i++)
2900 {
2901 char c = (l >> (i*8))&0xff;
2902 writeData(f, &c, 1);
2903 }
2904
2905 }
2906
2907 static void writeString(FILE *f, char *s)
2908 {
2909 writeData(f, s, strlen(s));
2910 }
2911
2912 /* Dump a gmon.out histogram file. */
2913 static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
2914 {
2915 uint32_t i;
2916 FILE *f = fopen(filename, "w");
2917 if (f == NULL)
2918 return;
2919 writeString(f, "gmon");
2920 writeLong(f, 0x00000001); /* Version */
2921 writeLong(f, 0); /* padding */
2922 writeLong(f, 0); /* padding */
2923 writeLong(f, 0); /* padding */
2924
2925 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
2926 writeData(f, &zero, 1);
2927
2928 /* figure out bucket size */
2929 uint32_t min = samples[0];
2930 uint32_t max = samples[0];
2931 for (i = 0; i < sampleNum; i++)
2932 {
2933 if (min > samples[i])
2934 {
2935 min = samples[i];
2936 }
2937 if (max < samples[i])
2938 {
2939 max = samples[i];
2940 }
2941 }
2942
2943 int addressSpace = (max-min + 1);
2944
2945 static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
2946 uint32_t length = addressSpace;
2947 if (length > maxBuckets)
2948 {
2949 length = maxBuckets;
2950 }
2951 int *buckets = malloc(sizeof(int)*length);
2952 if (buckets == NULL)
2953 {
2954 fclose(f);
2955 return;
2956 }
2957 memset(buckets, 0, sizeof(int)*length);
2958 for (i = 0; i < sampleNum;i++)
2959 {
2960 uint32_t address = samples[i];
2961 long long a = address-min;
2962 long long b = length-1;
2963 long long c = addressSpace-1;
2964 int index = (a*b)/c; /* danger!!!! int32 overflows */
2965 buckets[index]++;
2966 }
2967
2968 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2969 writeLong(f, min); /* low_pc */
2970 writeLong(f, max); /* high_pc */
2971 writeLong(f, length); /* # of samples */
2972 writeLong(f, 64000000); /* 64MHz */
2973 writeString(f, "seconds");
2974 for (i = 0; i < (15-strlen("seconds")); i++)
2975 writeData(f, &zero, 1);
2976 writeString(f, "s");
2977
2978 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2979
2980 char *data = malloc(2*length);
2981 if (data != NULL)
2982 {
2983 for (i = 0; i < length;i++)
2984 {
2985 int val;
2986 val = buckets[i];
2987 if (val > 65535)
2988 {
2989 val = 65535;
2990 }
2991 data[i*2]=val&0xff;
2992 data[i*2 + 1]=(val >> 8)&0xff;
2993 }
2994 free(buckets);
2995 writeData(f, data, length * 2);
2996 free(data);
2997 } else
2998 {
2999 free(buckets);
3000 }
3001
3002 fclose(f);
3003 }
3004
3005 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
3006 COMMAND_HANDLER(handle_profile_command)
3007 {
3008 struct target *target = get_current_target(CMD_CTX);
3009 struct timeval timeout, now;
3010
3011 gettimeofday(&timeout, NULL);
3012 if (CMD_ARGC != 2)
3013 {
3014 return ERROR_COMMAND_SYNTAX_ERROR;
3015 }
3016 unsigned offset;
3017 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
3018
3019 timeval_add_time(&timeout, offset, 0);
3020
3021 command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
3022
3023 static const int maxSample = 10000;
3024 uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3025 if (samples == NULL)
3026 return ERROR_OK;
3027
3028 int numSamples = 0;
3029 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3030 struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
3031
3032 for (;;)
3033 {
3034 int retval;
3035 target_poll(target);
3036 if (target->state == TARGET_HALTED)
3037 {
3038 uint32_t t=*((uint32_t *)reg->value);
3039 samples[numSamples++]=t;
3040 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3041 target_poll(target);
3042 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3043 } else if (target->state == TARGET_RUNNING)
3044 {
3045 /* We want to quickly sample the PC. */
3046 if ((retval = target_halt(target)) != ERROR_OK)
3047 {
3048 free(samples);
3049 return retval;
3050 }
3051 } else
3052 {
3053 command_print(CMD_CTX, "Target not halted or running");
3054 retval = ERROR_OK;
3055 break;
3056 }
3057 if (retval != ERROR_OK)
3058 {
3059 break;
3060 }
3061
3062 gettimeofday(&now, NULL);
3063 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
3064 {
3065 command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
3066 if ((retval = target_poll(target)) != ERROR_OK)
3067 {
3068 free(samples);
3069 return retval;
3070 }
3071 if (target->state == TARGET_HALTED)
3072 {
3073 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3074 }
3075 if ((retval = target_poll(target)) != ERROR_OK)
3076 {
3077 free(samples);
3078 return retval;
3079 }
3080 writeGmon(samples, numSamples, CMD_ARGV[1]);
3081 command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
3082 break;
3083 }
3084 }
3085 free(samples);
3086
3087 return ERROR_OK;
3088 }
3089
3090 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
3091 {
3092 char *namebuf;
3093 Jim_Obj *nameObjPtr, *valObjPtr;
3094 int result;
3095
3096 namebuf = alloc_printf("%s(%d)", varname, idx);
3097 if (!namebuf)
3098 return JIM_ERR;
3099
3100 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3101 valObjPtr = Jim_NewIntObj(interp, val);
3102 if (!nameObjPtr || !valObjPtr)
3103 {
3104 free(namebuf);
3105 return JIM_ERR;
3106 }
3107
3108 Jim_IncrRefCount(nameObjPtr);
3109 Jim_IncrRefCount(valObjPtr);
3110 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3111 Jim_DecrRefCount(interp, nameObjPtr);
3112 Jim_DecrRefCount(interp, valObjPtr);
3113 free(namebuf);
3114 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3115 return result;
3116 }
3117
3118 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3119 {
3120 struct command_context *context;
3121 struct target *target;
3122
3123 context = Jim_GetAssocData(interp, "context");
3124 if (context == NULL)
3125 {
3126 LOG_ERROR("mem2array: no command context");
3127 return JIM_ERR;
3128 }
3129 target = get_current_target(context);
3130 if (target == NULL)
3131 {
3132 LOG_ERROR("mem2array: no current target");
3133 return JIM_ERR;
3134 }
3135
3136 return target_mem2array(interp, target, argc-1, argv + 1);
3137 }
3138
3139 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
3140 {
3141 long l;
3142 uint32_t width;
3143 int len;
3144 uint32_t addr;
3145 uint32_t count;
3146 uint32_t v;
3147 const char *varname;
3148 uint8_t buffer[4096];
3149 int n, e, retval;
3150 uint32_t i;
3151
3152 /* argv[1] = name of array to receive the data
3153 * argv[2] = desired width
3154 * argv[3] = memory address
3155 * argv[4] = count of times to read
3156 */
3157 if (argc != 4) {
3158 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3159 return JIM_ERR;
3160 }
3161 varname = Jim_GetString(argv[0], &len);
3162 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3163
3164 e = Jim_GetLong(interp, argv[1], &l);
3165 width = l;
3166 if (e != JIM_OK) {
3167 return e;
3168 }
3169
3170 e = Jim_GetLong(interp, argv[2], &l);
3171 addr = l;
3172 if (e != JIM_OK) {
3173 return e;
3174 }
3175 e = Jim_GetLong(interp, argv[3], &l);
3176 len = l;
3177 if (e != JIM_OK) {
3178 return e;
3179 }
3180 switch (width) {
3181 case 8:
3182 width = 1;
3183 break;
3184 case 16:
3185 width = 2;
3186 break;
3187 case 32:
3188 width = 4;
3189 break;
3190 default:
3191 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3192 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3193 return JIM_ERR;
3194 }
3195 if (len == 0) {
3196 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3197 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3198 return JIM_ERR;
3199 }
3200 if ((addr + (len * width)) < addr) {
3201 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3202 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3203 return JIM_ERR;
3204 }
3205 /* absurd transfer size? */
3206 if (len > 65536) {
3207 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3208 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3209 return JIM_ERR;
3210 }
3211
3212 if ((width == 1) ||
3213 ((width == 2) && ((addr & 1) == 0)) ||
3214 ((width == 4) && ((addr & 3) == 0))) {
3215 /* all is well */
3216 } else {
3217 char buf[100];
3218 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3219 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3220 addr,
3221 width);
3222 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3223 return JIM_ERR;
3224 }
3225
3226 /* Transfer loop */
3227
3228 /* index counter */
3229 n = 0;
3230 /* assume ok */
3231 e = JIM_OK;
3232 while (len) {
3233 /* Slurp... in buffer size chunks */
3234
3235 count = len; /* in objects.. */
3236 if (count > (sizeof(buffer)/width)) {
3237 count = (sizeof(buffer)/width);
3238 }
3239
3240 retval = target_read_memory(target, addr, width, count, buffer);
3241 if (retval != ERROR_OK) {
3242 /* BOO !*/
3243 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3244 (unsigned int)addr,
3245 (int)width,
3246 (int)count);
3247 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3248 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3249 e = JIM_ERR;
3250 len = 0;
3251 } else {
3252 v = 0; /* shut up gcc */
3253 for (i = 0 ;i < count ;i++, n++) {
3254 switch (width) {
3255 case 4:
3256 v = target_buffer_get_u32(target, &buffer[i*width]);
3257 break;
3258 case 2:
3259 v = target_buffer_get_u16(target, &buffer[i*width]);
3260 break;
3261 case 1:
3262 v = buffer[i] & 0x0ff;
3263 break;
3264 }
3265 new_int_array_element(interp, varname, n, v);
3266 }
3267 len -= count;
3268 }
3269 }
3270
3271 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3272
3273 return JIM_OK;
3274 }
3275
3276 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
3277 {
3278 char *namebuf;
3279 Jim_Obj *nameObjPtr, *valObjPtr;
3280 int result;
3281 long l;
3282
3283 namebuf = alloc_printf("%s(%d)", varname, idx);
3284 if (!namebuf)
3285 return JIM_ERR;
3286
3287 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3288 if (!nameObjPtr)
3289 {
3290 free(namebuf);
3291 return JIM_ERR;
3292 }
3293
3294 Jim_IncrRefCount(nameObjPtr);
3295 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3296 Jim_DecrRefCount(interp, nameObjPtr);
3297 free(namebuf);
3298 if (valObjPtr == NULL)
3299 return JIM_ERR;
3300
3301 result = Jim_GetLong(interp, valObjPtr, &l);
3302 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3303 *val = l;
3304 return result;
3305 }
3306
3307 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3308 {
3309 struct command_context *context;
3310 struct target *target;
3311
3312 context = Jim_GetAssocData(interp, "context");
3313 if (context == NULL) {
3314 LOG_ERROR("array2mem: no command context");
3315 return JIM_ERR;
3316 }
3317 target = get_current_target(context);
3318 if (target == NULL) {
3319 LOG_ERROR("array2mem: no current target");
3320 return JIM_ERR;
3321 }
3322
3323 return target_array2mem(interp,target, argc-1, argv + 1);
3324 }
3325 static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
3326 {
3327 long l;
3328 uint32_t width;
3329 int len;
3330 uint32_t addr;
3331 uint32_t count;
3332 uint32_t v;
3333 const char *varname;
3334 uint8_t buffer[4096];
3335 int n, e, retval;
3336 uint32_t i;
3337
3338 /* argv[1] = name of array to get the data
3339 * argv[2] = desired width
3340 * argv[3] = memory address
3341 * argv[4] = count to write
3342 */
3343 if (argc != 4) {
3344 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3345 return JIM_ERR;
3346 }
3347 varname = Jim_GetString(argv[0], &len);
3348 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3349
3350 e = Jim_GetLong(interp, argv[1], &l);
3351 width = l;
3352 if (e != JIM_OK) {
3353 return e;
3354 }
3355
3356 e = Jim_GetLong(interp, argv[2], &l);
3357 addr = l;
3358 if (e != JIM_OK) {
3359 return e;
3360 }
3361 e = Jim_GetLong(interp, argv[3], &l);
3362 len = l;
3363 if (e != JIM_OK) {
3364 return e;
3365 }
3366 switch (width) {
3367 case 8:
3368 width = 1;
3369 break;
3370 case 16:
3371 width = 2;
3372 break;
3373 case 32:
3374 width = 4;
3375 break;
3376 default:
3377 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3378 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3379 return JIM_ERR;
3380 }
3381 if (len == 0) {
3382 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3383 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3384 return JIM_ERR;
3385 }
3386 if ((addr + (len * width)) < addr) {
3387 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3388 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3389 return JIM_ERR;
3390 }
3391 /* absurd transfer size? */
3392 if (len > 65536) {
3393 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3394 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3395 return JIM_ERR;
3396 }
3397
3398 if ((width == 1) ||
3399 ((width == 2) && ((addr & 1) == 0)) ||
3400 ((width == 4) && ((addr & 3) == 0))) {
3401 /* all is well */
3402 } else {
3403 char buf[100];
3404 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3405 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3406 (unsigned int)addr,
3407 (int)width);
3408 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3409 return JIM_ERR;
3410 }
3411
3412 /* Transfer loop */
3413
3414 /* index counter */
3415 n = 0;
3416 /* assume ok */
3417 e = JIM_OK;
3418 while (len) {
3419 /* Slurp... in buffer size chunks */
3420
3421 count = len; /* in objects.. */
3422 if (count > (sizeof(buffer)/width)) {
3423 count = (sizeof(buffer)/width);
3424 }
3425
3426 v = 0; /* shut up gcc */
3427 for (i = 0 ;i < count ;i++, n++) {
3428 get_int_array_element(interp, varname, n, &v);
3429 switch (width) {
3430 case 4:
3431 target_buffer_set_u32(target, &buffer[i*width], v);
3432 break;
3433 case 2:
3434 target_buffer_set_u16(target, &buffer[i*width], v);
3435 break;
3436 case 1:
3437 buffer[i] = v & 0x0ff;
3438 break;
3439 }
3440 }
3441 len -= count;
3442
3443 retval = target_write_memory(target, addr, width, count, buffer);
3444 if (retval != ERROR_OK) {
3445 /* BOO !*/
3446 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3447 (unsigned int)addr,
3448 (int)width,
3449 (int)count);
3450 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3451 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3452 e = JIM_ERR;
3453 len = 0;
3454 }
3455 }
3456
3457 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3458
3459 return JIM_OK;
3460 }
3461
3462 void target_all_handle_event(enum target_event e)
3463 {
3464 struct target *target;
3465
3466 LOG_DEBUG("**all*targets: event: %d, %s",
3467 (int)e,
3468 Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
3469
3470 target = all_targets;
3471 while (target) {
3472 target_handle_event(target, e);
3473 target = target->next;
3474 }
3475 }
3476
3477
3478 /* FIX? should we propagate errors here rather than printing them
3479 * and continuing?
3480 */
3481 void target_handle_event(struct target *target, enum target_event e)
3482 {
3483 struct target_event_action *teap;
3484
3485 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3486 if (teap->event == e) {
3487 LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3488 target->target_number,
3489 target->cmd_name,
3490 target_get_name(target),
3491 e,
3492 Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3493 Jim_GetString(teap->body, NULL));
3494 if (Jim_EvalObj(interp, teap->body) != JIM_OK)
3495 {
3496 Jim_PrintErrorMessage(interp);
3497 }
3498 }
3499 }
3500 }
3501
3502 enum target_cfg_param {
3503 TCFG_TYPE,
3504 TCFG_EVENT,
3505 TCFG_WORK_AREA_VIRT,
3506 TCFG_WORK_AREA_PHYS,
3507 TCFG_WORK_AREA_SIZE,
3508 TCFG_WORK_AREA_BACKUP,
3509 TCFG_ENDIAN,
3510 TCFG_VARIANT,
3511 TCFG_CHAIN_POSITION,
3512 };
3513
3514 static Jim_Nvp nvp_config_opts[] = {
3515 { .name = "-type", .value = TCFG_TYPE },
3516 { .name = "-event", .value = TCFG_EVENT },
3517 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3518 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3519 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3520 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3521 { .name = "-endian" , .value = TCFG_ENDIAN },
3522 { .name = "-variant", .value = TCFG_VARIANT },
3523 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3524
3525 { .name = NULL, .value = -1 }
3526 };
3527
3528 static int target_configure(Jim_GetOptInfo *goi, struct target *target)
3529 {
3530 Jim_Nvp *n;
3531 Jim_Obj *o;
3532 jim_wide w;
3533 char *cp;
3534 int e;
3535
3536 /* parse config or cget options ... */
3537 while (goi->argc > 0) {
3538 Jim_SetEmptyResult(goi->interp);
3539 /* Jim_GetOpt_Debug(goi); */
3540
3541 if (target->type->target_jim_configure) {
3542 /* target defines a configure function */
3543 /* target gets first dibs on parameters */
3544 e = (*(target->type->target_jim_configure))(target, goi);
3545 if (e == JIM_OK) {
3546 /* more? */
3547 continue;
3548 }
3549 if (e == JIM_ERR) {
3550 /* An error */
3551 return e;
3552 }
3553 /* otherwise we 'continue' below */
3554 }
3555 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
3556 if (e != JIM_OK) {
3557 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
3558 return e;
3559 }
3560 switch (n->value) {
3561 case TCFG_TYPE:
3562 /* not setable */
3563 if (goi->isconfigure) {
3564 Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
3565 return JIM_ERR;
3566 } else {
3567 no_params:
3568 if (goi->argc != 0) {
3569 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
3570 return JIM_ERR;
3571 }
3572 }
3573 Jim_SetResultString(goi->interp, target_get_name(target), -1);
3574 /* loop for more */
3575 break;
3576 case TCFG_EVENT:
3577 if (goi->argc == 0) {
3578 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3579 return JIM_ERR;
3580 }
3581
3582 e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
3583 if (e != JIM_OK) {
3584 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
3585 return e;
3586 }
3587
3588 if (goi->isconfigure) {
3589 if (goi->argc != 1) {
3590 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3591 return JIM_ERR;
3592 }
3593 } else {
3594 if (goi->argc != 0) {
3595 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3596 return JIM_ERR;
3597 }
3598 }
3599
3600 {
3601 struct target_event_action *teap;
3602
3603 teap = target->event_action;
3604 /* replace existing? */
3605 while (teap) {
3606 if (teap->event == (enum target_event)n->value) {
3607 break;
3608 }
3609 teap = teap->next;
3610 }
3611
3612 if (goi->isconfigure) {
3613 bool replace = true;
3614 if (teap == NULL) {
3615 /* create new */
3616 teap = calloc(1, sizeof(*teap));
3617 replace = false;
3618 }
3619 teap->event = n->value;
3620 Jim_GetOpt_Obj(goi, &o);
3621 if (teap->body) {
3622 Jim_DecrRefCount(interp, teap->body);
3623 }
3624 teap->body = Jim_DuplicateObj(goi->interp, o);
3625 /*
3626 * FIXME:
3627 * Tcl/TK - "tk events" have a nice feature.
3628 * See the "BIND" command.
3629 * We should support that here.
3630 * You can specify %X and %Y in the event code.
3631 * The idea is: %T - target name.
3632 * The idea is: %N - target number
3633 * The idea is: %E - event name.
3634 */
3635 Jim_IncrRefCount(teap->body);
3636
3637 if (!replace)
3638 {
3639 /* add to head of event list */
3640 teap->next = target->event_action;
3641 target->event_action = teap;
3642 }
3643 Jim_SetEmptyResult(goi->interp);
3644 } else {
3645 /* get */
3646 if (teap == NULL) {
3647 Jim_SetEmptyResult(goi->interp);
3648 } else {
3649 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
3650 }
3651 }
3652 }
3653 /* loop for more */
3654 break;
3655
3656 case TCFG_WORK_AREA_VIRT:
3657 if (goi->isconfigure) {
3658 target_free_all_working_areas(target);
3659 e = Jim_GetOpt_Wide(goi, &w);
3660 if (e != JIM_OK) {
3661 return e;
3662 }
3663 target->working_area_virt = w;
3664 target->working_area_virt_spec = true;
3665 } else {
3666 if (goi->argc != 0) {
3667 goto no_params;
3668 }
3669 }
3670 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
3671 /* loop for more */
3672 break;
3673
3674 case TCFG_WORK_AREA_PHYS:
3675 if (goi->isconfigure) {
3676 target_free_all_working_areas(target);
3677 e = Jim_GetOpt_Wide(goi, &w);
3678 if (e != JIM_OK) {
3679 return e;
3680 }
3681 target->working_area_phys = w;
3682 target->working_area_phys_spec = true;
3683 } else {
3684 if (goi->argc != 0) {
3685 goto no_params;
3686 }
3687 }
3688 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
3689 /* loop for more */
3690 break;
3691
3692 case TCFG_WORK_AREA_SIZE:
3693 if (goi->isconfigure) {
3694 target_free_all_working_areas(target);
3695 e = Jim_GetOpt_Wide(goi, &w);
3696 if (e != JIM_OK) {
3697 return e;
3698 }
3699 target->working_area_size = w;
3700 } else {
3701 if (goi->argc != 0) {
3702 goto no_params;
3703 }
3704 }
3705 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_size));
3706 /* loop for more */
3707 break;
3708
3709 case TCFG_WORK_AREA_BACKUP:
3710 if (goi->isconfigure) {
3711 target_free_all_working_areas(target);
3712 e = Jim_GetOpt_Wide(goi, &w);
3713 if (e != JIM_OK) {
3714 return e;
3715 }
3716 /* make this exactly 1 or 0 */
3717 target->backup_working_area = (!!w);
3718 } else {
3719 if (goi->argc != 0) {
3720 goto no_params;
3721 }
3722 }
3723 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
3724 /* loop for more e*/
3725 break;
3726
3727 case TCFG_ENDIAN:
3728 if (goi->isconfigure) {
3729 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
3730 if (e != JIM_OK) {
3731 Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
3732 return e;
3733 }
3734 target->endianness = n->value;
3735 } else {
3736 if (goi->argc != 0) {
3737 goto no_params;
3738 }
3739 }
3740 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3741 if (n->name == NULL) {
3742 target->endianness = TARGET_LITTLE_ENDIAN;
3743 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3744 }
3745 Jim_SetResultString(goi->interp, n->name, -1);
3746 /* loop for more */
3747 break;
3748
3749 case TCFG_VARIANT:
3750 if (goi->isconfigure) {
3751 if (goi->argc < 1) {
3752 Jim_SetResult_sprintf(goi->interp,
3753 "%s ?STRING?",
3754 n->name);
3755 return JIM_ERR;
3756 }
3757 if (target->variant) {
3758 free((void *)(target->variant));
3759 }
3760 e = Jim_GetOpt_String(goi, &cp, NULL);
3761 target->variant = strdup(cp);
3762 } else {
3763 if (goi->argc != 0) {
3764 goto no_params;
3765 }
3766 }
3767 Jim_SetResultString(goi->interp, target->variant,-1);
3768 /* loop for more */
3769 break;
3770 case TCFG_CHAIN_POSITION:
3771 if (goi->isconfigure) {
3772 Jim_Obj *o;
3773 struct jtag_tap *tap;
3774 target_free_all_working_areas(target);
3775 e = Jim_GetOpt_Obj(goi, &o);
3776 if (e != JIM_OK) {
3777 return e;
3778 }
3779 tap = jtag_tap_by_jim_obj(goi->interp, o);
3780 if (tap == NULL) {
3781 return JIM_ERR;
3782 }
3783 /* make this exactly 1 or 0 */
3784 target->tap = tap;
3785 } else {
3786 if (goi->argc != 0) {
3787 goto no_params;
3788 }
3789 }
3790 Jim_SetResultString(interp, target->tap->dotted_name, -1);
3791 /* loop for more e*/
3792 break;
3793 }
3794 } /* while (goi->argc) */
3795
3796
3797 /* done - we return */
3798 return JIM_OK;
3799 }
3800
3801 /** this is the 'tcl' handler for the target specific command */
3802 static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3803 {
3804 Jim_GetOptInfo goi;
3805 jim_wide a,b,c;
3806 int x,y,z;
3807 uint8_t target_buf[32];
3808 Jim_Nvp *n;
3809 struct target *target;
3810 struct command_context *cmd_ctx;
3811 int e;
3812
3813 enum {
3814 TS_CMD_CONFIGURE,
3815 TS_CMD_CGET,
3816
3817 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3818 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3819 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3820 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3821 TS_CMD_EXAMINE,
3822 TS_CMD_POLL,
3823 TS_CMD_RESET,
3824 TS_CMD_HALT,
3825 TS_CMD_WAITSTATE,
3826 TS_CMD_EVENTLIST,
3827 TS_CMD_CURSTATE,
3828 TS_CMD_INVOKE_EVENT,
3829 };
3830
3831 static const Jim_Nvp target_options[] = {
3832 { .name = "configure", .value = TS_CMD_CONFIGURE },
3833 { .name = "cget", .value = TS_CMD_CGET },
3834 { .name = "mww", .value = TS_CMD_MWW },
3835 { .name = "mwh", .value = TS_CMD_MWH },
3836 { .name = "mwb", .value = TS_CMD_MWB },
3837 { .name = "mdw", .value = TS_CMD_MDW },
3838 { .name = "mdh", .value = TS_CMD_MDH },
3839 { .name = "mdb", .value = TS_CMD_MDB },
3840 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3841 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3842 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3843 { .name = "curstate", .value = TS_CMD_CURSTATE },
3844
3845 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3846 { .name = "arp_poll", .value = TS_CMD_POLL },
3847 { .name = "arp_reset", .value = TS_CMD_RESET },
3848 { .name = "arp_halt", .value = TS_CMD_HALT },
3849 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3850 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3851
3852 { .name = NULL, .value = -1 },
3853 };
3854
3855 /* go past the "command" */
3856 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
3857
3858 target = Jim_CmdPrivData(goi.interp);
3859 cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3860
3861 /* commands here are in an NVP table */
3862 e = Jim_GetOpt_Nvp(&goi, target_options, &n);
3863 if (e != JIM_OK) {
3864 Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
3865 return e;
3866 }
3867 /* Assume blank result */
3868 Jim_SetEmptyResult(goi.interp);
3869
3870 switch (n->value) {
3871 case TS_CMD_CONFIGURE:
3872 if (goi.argc < 2) {
3873 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3874 return JIM_ERR;
3875 }
3876 goi.isconfigure = 1;
3877 return target_configure(&goi, target);
3878 case TS_CMD_CGET:
3879 // some things take params
3880 if (goi.argc < 1) {
3881 Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
3882 return JIM_ERR;
3883 }
3884 goi.isconfigure = 0;
3885 return target_configure(&goi, target);
3886 break;
3887 case TS_CMD_MWW:
3888 case TS_CMD_MWH:
3889 case TS_CMD_MWB:
3890 /* argv[0] = cmd
3891 * argv[1] = address
3892 * argv[2] = data
3893 * argv[3] = optional count.
3894 */
3895
3896 if ((goi.argc == 2) || (goi.argc == 3)) {
3897 /* all is well */
3898 } else {
3899 mwx_error:
3900 Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
3901 return JIM_ERR;
3902 }
3903
3904 e = Jim_GetOpt_Wide(&goi, &a);
3905 if (e != JIM_OK) {
3906 goto mwx_error;
3907 }
3908
3909 e = Jim_GetOpt_Wide(&goi, &b);
3910 if (e != JIM_OK) {
3911 goto mwx_error;
3912 }
3913 if (goi.argc == 3) {
3914 e = Jim_GetOpt_Wide(&goi, &c);
3915 if (e != JIM_OK) {
3916 goto mwx_error;
3917 }
3918 } else {
3919 c = 1;
3920 }
3921
3922 switch (n->value) {
3923 case TS_CMD_MWW:
3924 target_buffer_set_u32(target, target_buf, b);
3925 b = 4;
3926 break;
3927 case TS_CMD_MWH:
3928 target_buffer_set_u16(target, target_buf, b);
3929 b = 2;
3930 break;
3931 case TS_CMD_MWB:
3932 target_buffer_set_u8(target, target_buf, b);
3933 b = 1;
3934 break;
3935 }
3936 for (x = 0 ; x < c ; x++) {
3937 e = target_write_memory(target, a, b, 1, target_buf);
3938 if (e != ERROR_OK) {
3939 Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
3940 return JIM_ERR;
3941 }
3942 /* b = width */
3943 a = a + b;
3944 }
3945 return JIM_OK;
3946 break;
3947
3948 /* display */
3949 case TS_CMD_MDW:
3950 case TS_CMD_MDH:
3951 case TS_CMD_MDB:
3952 /* argv[0] = command
3953 * argv[1] = address
3954 * argv[2] = optional count
3955 */
3956 if ((goi.argc == 2) || (goi.argc == 3)) {
3957 Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
3958 return JIM_ERR;
3959 }
3960 e = Jim_GetOpt_Wide(&goi, &a);
3961 if (e != JIM_OK) {
3962 return JIM_ERR;
3963 }
3964 if (goi.argc) {
3965 e = Jim_GetOpt_Wide(&goi, &c);
3966 if (e != JIM_OK) {
3967 return JIM_ERR;
3968 }
3969 } else {
3970 c = 1;
3971 }
3972 b = 1; /* shut up gcc */
3973 switch (n->value) {
3974 case TS_CMD_MDW:
3975 b = 4;
3976 break;
3977 case TS_CMD_MDH:
3978 b = 2;
3979 break;
3980 case TS_CMD_MDB:
3981 b = 1;
3982 break;
3983 }
3984
3985 /* convert to "bytes" */
3986 c = c * b;
3987 /* count is now in 'BYTES' */
3988 while (c > 0) {
3989 y = c;
3990 if (y > 16) {
3991 y = 16;
3992 }
3993 e = target_read_memory(target, a, b, y / b, target_buf);
3994 if (e != ERROR_OK) {
3995 Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
3996 return JIM_ERR;
3997 }
3998
3999 Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
4000 switch (b) {
4001 case 4:
4002 for (x = 0 ; (x < 16) && (x < y) ; x += 4) {
4003 z = target_buffer_get_u32(target, &(target_buf[ x * 4 ]));
4004 Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
4005 }
4006 for (; (x < 16) ; x += 4) {
4007 Jim_fprintf(interp, interp->cookie_stdout, " ");
4008 }
4009 break;
4010 case 2:
4011 for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
4012 z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
4013 Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
4014 }
4015 for (; (x < 16) ; x += 2) {
4016 Jim_fprintf(interp, interp->cookie_stdout, " ");
4017 }
4018 break;
4019 case 1:
4020 default:
4021 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4022 z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
4023 Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
4024 }
4025 for (; (x < 16) ; x += 1) {
4026 Jim_fprintf(interp, interp->cookie_stdout, " ");
4027 }
4028 break;
4029 }
4030 /* ascii-ify the bytes */
4031 for (x = 0 ; x < y ; x++) {
4032 if ((target_buf[x] >= 0x20) &&
4033 (target_buf[x] <= 0x7e)) {
4034 /* good */
4035 } else {
4036 /* smack it */
4037 target_buf[x] = '.';
4038 }
4039 }
4040 /* space pad */
4041 while (x < 16) {
4042 target_buf[x] = ' ';
4043 x++;
4044 }
4045 /* terminate */
4046 target_buf[16] = 0;
4047 /* print - with a newline */
4048 Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
4049 /* NEXT... */
4050 c -= 16;
4051 a += 16;
4052 }
4053 return JIM_OK;
4054 case TS_CMD_MEM2ARRAY:
4055 return target_mem2array(goi.interp, target, goi.argc, goi.argv);
4056 break;
4057 case TS_CMD_ARRAY2MEM:
4058 return target_array2mem(goi.interp, target, goi.argc, goi.argv);
4059 break;
4060 case TS_CMD_EXAMINE:
4061 if (goi.argc) {
4062 Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4063 return JIM_ERR;
4064 }
4065 if (!target->tap->enabled)
4066 goto err_tap_disabled;
4067 e = target->type->examine(target);
4068 if (e != ERROR_OK) {
4069 Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
4070 return JIM_ERR;
4071 }
4072 return JIM_OK;
4073 case TS_CMD_POLL:
4074 if (goi.argc) {
4075 Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4076 return JIM_ERR;
4077 }
4078 if (!target->tap->enabled)
4079 goto err_tap_disabled;
4080 if (!(target_was_examined(target))) {
4081 e = ERROR_TARGET_NOT_EXAMINED;
4082 } else {
4083 e = target->type->poll(target);
4084 }
4085 if (e != ERROR_OK) {
4086 Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
4087 return JIM_ERR;
4088 } else {
4089 return JIM_OK;
4090 }
4091 break;
4092 case TS_CMD_RESET:
4093 if (goi.argc != 2) {
4094 Jim_WrongNumArgs(interp, 2, argv,
4095 "([tT]|[fF]|assert|deassert) BOOL");
4096 return JIM_ERR;
4097 }
4098 e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4099 if (e != JIM_OK) {
4100 Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4101 return e;
4102 }
4103 /* the halt or not param */
4104 e = Jim_GetOpt_Wide(&goi, &a);
4105 if (e != JIM_OK) {
4106 return e;
4107 }
4108 if (!target->tap->enabled)
4109 goto err_tap_disabled;
4110 if (!target->type->assert_reset
4111 || !target->type->deassert_reset) {
4112 Jim_SetResult_sprintf(interp,
4113 "No target-specific reset for %s",
4114 target->cmd_name);
4115 return JIM_ERR;
4116 }
4117 /* determine if we should halt or not. */
4118 target->reset_halt = !!a;
4119 /* When this happens - all workareas are invalid. */
4120 target_free_all_working_areas_restore(target, 0);
4121
4122 /* do the assert */
4123 if (n->value == NVP_ASSERT) {
4124 e = target->type->assert_reset(target);
4125 } else {
4126 e = target->type->deassert_reset(target);
4127 }
4128 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4129 case TS_CMD_HALT:
4130 if (goi.argc) {
4131 Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
4132 return JIM_ERR;
4133 }
4134 if (!target->tap->enabled)
4135 goto err_tap_disabled;
4136 e = target->type->halt(target);
4137 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4138 case TS_CMD_WAITSTATE:
4139 /* params: <name> statename timeoutmsecs */
4140 if (goi.argc != 2) {
4141 Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
4142 return JIM_ERR;
4143 }
4144 e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4145 if (e != JIM_OK) {
4146 Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
4147 return e;
4148 }
4149 e = Jim_GetOpt_Wide(&goi, &a);
4150 if (e != JIM_OK) {
4151 return e;
4152 }
4153 if (!target->tap->enabled)
4154 goto err_tap_disabled;
4155 e = target_wait_state(target, n->value, a);
4156 if (e != ERROR_OK) {
4157 Jim_SetResult_sprintf(goi.interp,
4158 "target: %s wait %s fails (%d) %s",
4159 target->cmd_name,
4160 n->name,
4161 e, target_strerror_safe(e));
4162 return JIM_ERR;
4163 } else {
4164 return JIM_OK;
4165 }
4166 case TS_CMD_EVENTLIST:
4167 /* List for human, Events defined for this target.
4168 * scripts/programs should use 'name cget -event NAME'
4169 */
4170 {
4171 struct target_event_action *teap;
4172 teap = target->event_action;
4173 command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4174 target->target_number,
4175 target->cmd_name);
4176 command_print(cmd_ctx, "%-25s | Body", "Event");
4177 command_print(cmd_ctx, "------------------------- | ----------------------------------------");
4178 while (teap) {
4179 command_print(cmd_ctx,
4180 "%-25s | %s",
4181 Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
4182 Jim_GetString(teap->body, NULL));
4183 teap = teap->next;
4184 }
4185 command_print(cmd_ctx, "***END***");
4186 return JIM_OK;
4187 }
4188 case TS_CMD_CURSTATE:
4189 if (goi.argc != 0) {
4190 Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
4191 return JIM_ERR;
4192 }
4193 Jim_SetResultString(goi.interp,
4194 target_state_name( target ),
4195 -1);
4196 return JIM_OK;
4197 case TS_CMD_INVOKE_EVENT:
4198 if (goi.argc != 1) {
4199 Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
4200 return JIM_ERR;
4201 }
4202 e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4203 if (e != JIM_OK) {
4204 Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4205 return e;
4206 }
4207 target_handle_event(target, n->value);
4208 return JIM_OK;
4209 }
4210 return JIM_ERR;
4211
4212 err_tap_disabled:
4213 Jim_SetResult_sprintf(interp, "[TAP is disabled]");
4214 return JIM_ERR;
4215 }
4216
4217 static int target_create(Jim_GetOptInfo *goi)
4218 {
4219 Jim_Obj *new_cmd;
4220 Jim_Cmd *cmd;
4221 const char *cp;
4222 char *cp2;
4223 int e;
4224 int x;
4225 struct target *target;
4226 struct command_context *cmd_ctx;
4227
4228 cmd_ctx = Jim_GetAssocData(goi->interp, "context");
4229 if (goi->argc < 3) {
4230 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4231 return JIM_ERR;
4232 }
4233
4234 /* COMMAND */
4235 Jim_GetOpt_Obj(goi, &new_cmd);
4236 /* does this command exist? */
4237 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4238 if (cmd) {
4239 cp = Jim_GetString(new_cmd, NULL);
4240 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
4241 return JIM_ERR;
4242 }
4243
4244 /* TYPE */
4245 e = Jim_GetOpt_String(goi, &cp2, NULL);
4246 cp = cp2;
4247 /* now does target type exist */
4248 for (x = 0 ; target_types[x] ; x++) {
4249 if (0 == strcmp(cp, target_types[x]->name)) {
4250 /* found */
4251 break;
4252 }
4253 }
4254 if (target_types[x] == NULL) {
4255 Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
4256 for (x = 0 ; target_types[x] ; x++) {
4257 if (target_types[x + 1]) {
4258 Jim_AppendStrings(goi->interp,
4259 Jim_GetResult(goi->interp),
4260 target_types[x]->name,
4261 ", ", NULL);
4262 } else {
4263 Jim_AppendStrings(goi->interp,
4264 Jim_GetResult(goi->interp),
4265 " or ",
4266 target_types[x]->name,NULL);
4267 }
4268 }
4269 return JIM_ERR;
4270 }
4271
4272 /* Create it */
4273 target = calloc(1,sizeof(struct target));
4274 /* set target number */
4275 target->target_number = new_target_number();
4276
4277 /* allocate memory for each unique target type */
4278 target->type = (struct target_type*)calloc(1,sizeof(struct target_type));
4279
4280 memcpy(target->type, target_types[x], sizeof(struct target_type));
4281
4282 /* will be set by "-endian" */
4283 target->endianness = TARGET_ENDIAN_UNKNOWN;
4284
4285 target->working_area = 0x0;
4286 target->working_area_size = 0x0;
4287 target->working_areas = NULL;
4288 target->backup_working_area = 0;
4289
4290 target->state = TARGET_UNKNOWN;
4291 target->debug_reason = DBG_REASON_UNDEFINED;
4292 target->reg_cache = NULL;
4293 target->breakpoints = NULL;
4294 target->watchpoints = NULL;
4295 target->next = NULL;
4296 target->arch_info = NULL;
4297
4298 target->display = 1;
4299
4300 target->halt_issued = false;
4301
4302 /* initialize trace information */
4303 target->trace_info = malloc(sizeof(struct trace));
4304 target->trace_info->num_trace_points = 0;
4305 target->trace_info->trace_points_size = 0;
4306 target->trace_info->trace_points = NULL;
4307 target->trace_info->trace_history_size = 0;
4308 target->trace_info->trace_history = NULL;
4309 target->trace_info->trace_history_pos = 0;
4310 target->trace_info->trace_history_overflowed = 0;
4311
4312 target->dbgmsg = NULL;
4313 target->dbg_msg_enabled = 0;
4314
4315 target->endianness = TARGET_ENDIAN_UNKNOWN;
4316
4317 /* Do the rest as "configure" options */
4318 goi->isconfigure = 1;
4319 e = target_configure(goi, target);
4320
4321 if (target->tap == NULL)
4322 {
4323 Jim_SetResultString(interp, "-chain-position required when creating target", -1);
4324 e = JIM_ERR;
4325 }
4326
4327 if (e != JIM_OK) {
4328 free(target->type);
4329 free(target);
4330 return e;
4331 }
4332
4333 if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
4334 /* default endian to little if not specified */
4335 target->endianness = TARGET_LITTLE_ENDIAN;
4336 }
4337
4338 /* incase variant is not set */
4339 if (!target->variant)
4340 target->variant = strdup("");
4341
4342 /* create the target specific commands */
4343 if (target->type->register_commands) {
4344 (*(target->type->register_commands))(cmd_ctx);
4345 }
4346 if (target->type->target_create) {
4347 (*(target->type->target_create))(target, goi->interp);
4348 }
4349
4350 /* append to end of list */
4351 {
4352 struct target **tpp;
4353 tpp = &(all_targets);
4354 while (*tpp) {
4355 tpp = &((*tpp)->next);
4356 }
4357 *tpp = target;
4358 }
4359
4360 cp = Jim_GetString(new_cmd, NULL);
4361 target->cmd_name = strdup(cp);
4362
4363 /* now - create the new target name command */
4364 e = Jim_CreateCommand(goi->interp,
4365 /* name */
4366 cp,
4367 tcl_target_func, /* C function */
4368 target, /* private data */
4369 NULL); /* no del proc */
4370
4371 return e;
4372 }
4373
4374 static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4375 {
4376 int x,r,e;
4377 jim_wide w;
4378 struct command_context *cmd_ctx;
4379 struct target *target;
4380 Jim_GetOptInfo goi;
4381 enum tcmd {
4382 /* TG = target generic */
4383 TG_CMD_CREATE,
4384 TG_CMD_TYPES,
4385 TG_CMD_NAMES,
4386 TG_CMD_CURRENT,
4387 TG_CMD_NUMBER,
4388 TG_CMD_COUNT,
4389 };
4390 const char *target_cmds[] = {
4391 "create", "types", "names", "current", "number",
4392 "count",
4393 NULL /* terminate */
4394 };
4395
4396 LOG_DEBUG("Target command params:");
4397 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
4398
4399 cmd_ctx = Jim_GetAssocData(interp, "context");
4400
4401 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
4402
4403 if (goi.argc == 0) {
4404 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
4405 return JIM_ERR;
4406 }
4407
4408 /* Jim_GetOpt_Debug(&goi); */
4409 r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
4410 if (r != JIM_OK) {
4411 return r;
4412 }
4413
4414 switch (x) {
4415 default:
4416 Jim_Panic(goi.interp,"Why am I here?");
4417 return JIM_ERR;
4418 case TG_CMD_CURRENT:
4419 if (goi.argc != 0) {
4420 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4421 return JIM_ERR;
4422 }
4423 Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
4424 return JIM_OK;
4425 case TG_CMD_TYPES:
4426 if (goi.argc != 0) {
4427 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4428 return JIM_ERR;
4429 }
4430 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4431 for (x = 0 ; target_types[x] ; x++) {
4432 Jim_ListAppendElement(goi.interp,
4433 Jim_GetResult(goi.interp),
4434 Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
4435 }
4436 return JIM_OK;
4437 case TG_CMD_NAMES:
4438 if (goi.argc != 0) {
4439 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4440 return JIM_ERR;
4441 }
4442 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4443 target = all_targets;
4444 while (target) {
4445 Jim_ListAppendElement(goi.interp,
4446 Jim_GetResult(goi.interp),
4447 Jim_NewStringObj(goi.interp, target->cmd_name, -1));
4448 target = target->next;
4449 }
4450 return JIM_OK;
4451 case TG_CMD_CREATE:
4452 if (goi.argc < 3) {
4453 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name ... config options ...");
4454 return JIM_ERR;
4455 }
4456 return target_create(&goi);
4457 break;
4458 case TG_CMD_NUMBER:
4459 /* It's OK to remove this mechanism sometime after August 2010 or so */
4460 LOG_WARNING("don't use numbers as target identifiers; use names");
4461 if (goi.argc != 1) {
4462 Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
4463 return JIM_ERR;
4464 }
4465 e = Jim_GetOpt_Wide(&goi, &w);
4466 if (e != JIM_OK) {
4467 return JIM_ERR;
4468 }
4469 for (x = 0, target = all_targets; target; target = target->next, x++) {
4470 if (target->target_number == w)
4471 break;
4472 }
4473 if (target == NULL) {
4474 Jim_SetResult_sprintf(goi.interp,
4475 "Target: number %d does not exist", (int)(w));
4476 return JIM_ERR;
4477 }
4478 Jim_SetResultString(goi.interp, target->cmd_name, -1);
4479 return JIM_OK;
4480 case TG_CMD_COUNT:
4481 if (goi.argc != 0) {
4482 Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
4483 return JIM_ERR;
4484 }
4485 for (x = 0, target = all_targets; target; target = target->next, x++)
4486 continue;
4487 Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
4488 return JIM_OK;
4489 }
4490
4491 return JIM_ERR;
4492 }
4493
4494
4495 struct FastLoad
4496 {
4497 uint32_t address;
4498 uint8_t *data;
4499 int length;
4500
4501 };
4502
4503 static int fastload_num;
4504 static struct FastLoad *fastload;
4505
4506 static void free_fastload(void)
4507 {
4508 if (fastload != NULL)
4509 {
4510 int i;
4511 for (i = 0; i < fastload_num; i++)
4512 {
4513 if (fastload[i].data)
4514 free(fastload[i].data);
4515 }
4516 free(fastload);
4517 fastload = NULL;
4518 }
4519 }
4520
4521
4522
4523
4524 COMMAND_HANDLER(handle_fast_load_image_command)
4525 {
4526 uint8_t *buffer;
4527 size_t buf_cnt;
4528 uint32_t image_size;
4529 uint32_t min_address = 0;
4530 uint32_t max_address = 0xffffffff;
4531 int i;
4532
4533 struct image image;
4534
4535 int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
4536 &image, &min_address, &max_address);
4537 if (ERROR_OK != retval)
4538 return retval;
4539
4540 struct duration bench;
4541 duration_start(&bench);
4542
4543 if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
4544 {
4545 return ERROR_OK;
4546 }
4547
4548 image_size = 0x0;
4549 retval = ERROR_OK;
4550 fastload_num = image.num_sections;
4551 fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4552 if (fastload == NULL)
4553 {
4554 image_close(&image);
4555 return ERROR_FAIL;
4556 }
4557 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4558 for (i = 0; i < image.num_sections; i++)
4559 {
4560 buffer = malloc(image.sections[i].size);
4561 if (buffer == NULL)
4562 {
4563 command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
4564 (int)(image.sections[i].size));
4565 break;
4566 }
4567
4568 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4569 {
4570 free(buffer);
4571 break;
4572 }
4573
4574 uint32_t offset = 0;
4575 uint32_t length = buf_cnt;
4576
4577
4578 /* DANGER!!! beware of unsigned comparision here!!! */
4579
4580 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
4581 (image.sections[i].base_address < max_address))
4582 {
4583 if (image.sections[i].base_address < min_address)
4584 {
4585 /* clip addresses below */
4586 offset += min_address-image.sections[i].base_address;
4587 length -= offset;
4588 }
4589
4590 if (image.sections[i].base_address + buf_cnt > max_address)
4591 {
4592 length -= (image.sections[i].base_address + buf_cnt)-max_address;
4593 }
4594
4595 fastload[i].address = image.sections[i].base_address + offset;
4596 fastload[i].data = malloc(length);
4597 if (fastload[i].data == NULL)
4598 {
4599 free(buffer);
4600 break;
4601 }
4602 memcpy(fastload[i].data, buffer + offset, length);
4603 fastload[i].length = length;
4604
4605 image_size += length;
4606 command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
4607 (unsigned int)length,
4608 ((unsigned int)(image.sections[i].base_address + offset)));
4609 }
4610
4611 free(buffer);
4612 }
4613
4614 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
4615 {
4616 command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
4617 "in %fs (%0.3f kb/s)", image_size,
4618 duration_elapsed(&bench), duration_kbps(&bench, image_size));
4619
4620 command_print(CMD_CTX,
4621 "WARNING: image has not been loaded to target!"
4622 "You can issue a 'fast_load' to finish loading.");
4623 }
4624
4625 image_close(&image);
4626
4627 if (retval != ERROR_OK)
4628 {
4629 free_fastload();
4630 }
4631
4632 return retval;
4633 }
4634
4635 COMMAND_HANDLER(handle_fast_load_command)
4636 {
4637 if (CMD_ARGC > 0)
4638 return ERROR_COMMAND_SYNTAX_ERROR;
4639 if (fastload == NULL)
4640 {
4641 LOG_ERROR("No image in memory");
4642 return ERROR_FAIL;
4643 }
4644 int i;
4645 int ms = timeval_ms();
4646 int size = 0;
4647 int retval = ERROR_OK;
4648 for (i = 0; i < fastload_num;i++)
4649 {
4650 struct target *target = get_current_target(CMD_CTX);
4651 command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
4652 (unsigned int)(fastload[i].address),
4653 (unsigned int)(fastload[i].length));
4654 if (retval == ERROR_OK)
4655 {
4656 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
4657 }
4658 size += fastload[i].length;
4659 }
4660 int after = timeval_ms();
4661 command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
4662 return retval;
4663 }
4664
4665 static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4666 {
4667 struct command_context *context;
4668 struct target *target;
4669 int retval;
4670
4671 context = Jim_GetAssocData(interp, "context");
4672 if (context == NULL) {
4673 LOG_ERROR("array2mem: no command context");
4674 return JIM_ERR;
4675 }
4676 target = get_current_target(context);
4677 if (target == NULL) {
4678 LOG_ERROR("array2mem: no current target");
4679 return JIM_ERR;
4680 }
4681
4682 if ((argc < 6) || (argc > 7))
4683 {
4684 return JIM_ERR;
4685 }
4686
4687 int cpnum;
4688 uint32_t op1;
4689 uint32_t op2;
4690 uint32_t CRn;
4691 uint32_t CRm;
4692 uint32_t value;
4693
4694 int e;
4695 long l;
4696 e = Jim_GetLong(interp, argv[1], &l);
4697 if (e != JIM_OK) {
4698 return e;
4699 }
4700 cpnum = l;
4701
4702 e = Jim_GetLong(interp, argv[2], &l);
4703 if (e != JIM_OK) {
4704 return e;
4705 }
4706 op1 = l;
4707
4708 e = Jim_GetLong(interp, argv[3], &l);
4709 if (e != JIM_OK) {
4710 return e;
4711 }
4712 CRn = l;
4713
4714 e = Jim_GetLong(interp, argv[4], &l);
4715 if (e != JIM_OK) {
4716 return e;
4717 }
4718 CRm = l;
4719
4720 e = Jim_GetLong(interp, argv[5], &l);
4721 if (e != JIM_OK) {
4722 return e;
4723 }
4724 op2 = l;
4725
4726 value = 0;
4727
4728 if (argc == 7)
4729 {
4730 e = Jim_GetLong(interp, argv[6], &l);
4731 if (e != JIM_OK) {
4732 return e;
4733 }
4734 value = l;
4735
4736 retval = target_mcr(target, cpnum, op1, op2, CRn, CRm, value);
4737 if (retval != ERROR_OK)
4738 return JIM_ERR;
4739 } else
4740 {
4741 retval = target_mrc(target, cpnum, op1, op2, CRn, CRm, &value);
4742 if (retval != ERROR_OK)
4743 return JIM_ERR;
4744
4745 Jim_SetResult(interp, Jim_NewIntObj(interp, value));
4746 }
4747
4748 return JIM_OK;
4749 }
4750
4751 int target_register_commands(struct command_context *cmd_ctx)
4752 {
4753
4754 register_command(cmd_ctx, NULL, "targets",
4755 handle_targets_command, COMMAND_EXEC,
4756 "change current command line target (one parameter) "
4757 "or list targets (no parameters)");
4758
4759 register_jim(cmd_ctx, "target", jim_target, "configure target");
4760
4761 return ERROR_OK;
4762 }
4763
4764 int target_register_user_commands(struct command_context *cmd_ctx)
4765 {
4766 int retval = ERROR_OK;
4767 if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
4768 return retval;
4769
4770 if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
4771 return retval;
4772
4773 register_command(cmd_ctx, NULL, "profile",
4774 handle_profile_command, COMMAND_EXEC,
4775 "profiling samples the CPU PC");
4776
4777 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array,
4778 "read memory and return as a TCL array for script processing "
4779 "<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
4780
4781 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem,
4782 "convert a TCL array to memory locations and write the values "
4783 "<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
4784
4785 register_command(cmd_ctx, NULL, "fast_load_image",
4786 handle_fast_load_image_command, COMMAND_ANY,
4787 "same CMD_ARGV as load_image, image stored in memory "
4788 "- mainly for profiling purposes");
4789
4790 register_command(cmd_ctx, NULL, "fast_load",
4791 handle_fast_load_command, COMMAND_ANY,
4792 "loads active fast load image to current target "
4793 "- mainly for profiling purposes");
4794
4795 /** @todo don't register virt2phys() unless target supports it */
4796 register_command(cmd_ctx, NULL, "virt2phys",
4797 handle_virt2phys_command, COMMAND_ANY,
4798 "translate a virtual address into a physical address");
4799
4800 register_command(cmd_ctx, NULL, "reg",
4801 handle_reg_command, COMMAND_EXEC,
4802 "display or set a register");
4803
4804 register_command(cmd_ctx, NULL, "poll",
4805 handle_poll_command, COMMAND_EXEC,
4806 "poll target state");
4807 register_command(cmd_ctx, NULL, "wait_halt",
4808 handle_wait_halt_command, COMMAND_EXEC,
4809 "wait for target halt [time (s)]");
4810 register_command(cmd_ctx, NULL, "halt",
4811 handle_halt_command, COMMAND_EXEC,
4812 "halt target");
4813 register_command(cmd_ctx, NULL, "resume",
4814 handle_resume_command, COMMAND_EXEC,
4815 "resume target [addr]");
4816 register_command(cmd_ctx, NULL, "reset",
4817 handle_reset_command, COMMAND_EXEC,
4818 "reset target [run | halt | init] - default is run");
4819 register_command(cmd_ctx, NULL, "soft_reset_halt",
4820 handle_soft_reset_halt_command, COMMAND_EXEC,
4821 "halt the target and do a soft reset");
4822
4823 register_command(cmd_ctx, NULL, "step",
4824 handle_step_command, COMMAND_EXEC,
4825 "step one instruction from current PC or [addr]");
4826
4827 register_command(cmd_ctx, NULL, "mdw",
4828 handle_md_command, COMMAND_EXEC,
4829 "display memory words [phys] <addr> [count]");
4830 register_command(cmd_ctx, NULL, "mdh",
4831 handle_md_command, COMMAND_EXEC,
4832 "display memory half-words [phys] <addr> [count]");
4833 register_command(cmd_ctx, NULL, "mdb",
4834 handle_md_command, COMMAND_EXEC,
4835 "display memory bytes [phys] <addr> [count]");
4836
4837 register_command(cmd_ctx, NULL, "mww",
4838 handle_mw_command, COMMAND_EXEC,
4839 "write memory word [phys] <addr> <value> [count]");
4840 register_command(cmd_ctx, NULL, "mwh",
4841 handle_mw_command, COMMAND_EXEC,
4842 "write memory half-word [phys] <addr> <value> [count]");
4843 register_command(cmd_ctx, NULL, "mwb",
4844 handle_mw_command, COMMAND_EXEC,
4845 "write memory byte [phys] <addr> <value> [count]");
4846
4847 register_command(cmd_ctx, NULL, "bp",
4848 handle_bp_command, COMMAND_EXEC,
4849 "list or set breakpoint [<address> <length> [hw]]");
4850 register_command(cmd_ctx, NULL, "rbp",
4851 handle_rbp_command, COMMAND_EXEC,
4852 "remove breakpoint <address>");
4853
4854 register_command(cmd_ctx, NULL, "wp",
4855 handle_wp_command, COMMAND_EXEC,
4856 "list or set watchpoint "
4857 "[<address> <length> <r/w/a> [value] [mask]]");
4858 register_command(cmd_ctx, NULL, "rwp",
4859 handle_rwp_command, COMMAND_EXEC,
4860 "remove watchpoint <address>");
4861
4862 register_command(cmd_ctx, NULL, "load_image",
4863 handle_load_image_command, COMMAND_EXEC,
4864 "load_image <file> <address> "
4865 "['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
4866 register_command(cmd_ctx, NULL, "dump_image",
4867 handle_dump_image_command, COMMAND_EXEC,
4868 "dump_image <file> <address> <size>");
4869 register_command(cmd_ctx, NULL, "verify_image",
4870 handle_verify_image_command, COMMAND_EXEC,
4871 "verify_image <file> [offset] [type]");
4872 register_command(cmd_ctx, NULL, "test_image",
4873 handle_test_image_command, COMMAND_EXEC,
4874 "test_image <file> [offset] [type]");
4875
4876 return ERROR_OK;
4877 }
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)