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