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