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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)