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