Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
target: fix ordering of arguments to mcr and mrc commands
[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 retval = target->type->mmu(target, &enabled);
1119 if (retval != ERROR_OK)
1120 {
1121 return retval;
1122 }
1123
1124 if (enabled)
1125 {
1126 if (target->working_area_phys_spec)
1127 {
1128 LOG_DEBUG("MMU disabled, using physical address for working memory 0x%08x", (unsigned)target->working_area_phys);
1129 target->working_area = target->working_area_phys;
1130 } else
1131 {
1132 LOG_ERROR("No working memory available. Specify -work-area-phys to target.");
1133 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1134 }
1135 } else
1136 {
1137 if (target->working_area_virt_spec)
1138 {
1139 LOG_DEBUG("MMU enabled, using virtual address for working memory 0x%08x", (unsigned)target->working_area_virt);
1140 target->working_area = target->working_area_virt;
1141 } else
1142 {
1143 LOG_ERROR("No working memory available. Specify -work-area-virt to target.");
1144 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1145 }
1146 }
1147 }
1148
1149 /* only allocate multiples of 4 byte */
1150 if (size % 4)
1151 {
1152 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes (0x%08x), padding", ((unsigned)(size)));
1153 size = (size + 3) & (~3);
1154 }
1155
1156 /* see if there's already a matching working area */
1157 while (c)
1158 {
1159 if ((c->free) && (c->size == size))
1160 {
1161 new_wa = c;
1162 break;
1163 }
1164 c = c->next;
1165 }
1166
1167 /* if not, allocate a new one */
1168 if (!new_wa)
1169 {
1170 working_area_t **p = &target->working_areas;
1171 uint32_t first_free = target->working_area;
1172 uint32_t free_size = target->working_area_size;
1173
1174 c = target->working_areas;
1175 while (c)
1176 {
1177 first_free += c->size;
1178 free_size -= c->size;
1179 p = &c->next;
1180 c = c->next;
1181 }
1182
1183 if (free_size < size)
1184 {
1185 LOG_WARNING("not enough working area available(requested %u, free %u)",
1186 (unsigned)(size), (unsigned)(free_size));
1187 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1188 }
1189
1190 LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free);
1191
1192 new_wa = malloc(sizeof(working_area_t));
1193 new_wa->next = NULL;
1194 new_wa->size = size;
1195 new_wa->address = first_free;
1196
1197 if (target->backup_working_area)
1198 {
1199 int retval;
1200 new_wa->backup = malloc(new_wa->size);
1201 if ((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
1202 {
1203 free(new_wa->backup);
1204 free(new_wa);
1205 return retval;
1206 }
1207 }
1208 else
1209 {
1210 new_wa->backup = NULL;
1211 }
1212
1213 /* put new entry in list */
1214 *p = new_wa;
1215 }
1216
1217 /* mark as used, and return the new (reused) area */
1218 new_wa->free = 0;
1219 *area = new_wa;
1220
1221 /* user pointer */
1222 new_wa->user = area;
1223
1224 return ERROR_OK;
1225 }
1226
1227 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
1228 {
1229 if (area->free)
1230 return ERROR_OK;
1231
1232 if (restore && target->backup_working_area)
1233 {
1234 int retval;
1235 if ((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
1236 return retval;
1237 }
1238
1239 area->free = 1;
1240
1241 /* mark user pointer invalid */
1242 *area->user = NULL;
1243 area->user = NULL;
1244
1245 return ERROR_OK;
1246 }
1247
1248 int target_free_working_area(struct target_s *target, working_area_t *area)
1249 {
1250 return target_free_working_area_restore(target, area, 1);
1251 }
1252
1253 /* free resources and restore memory, if restoring memory fails,
1254 * free up resources anyway
1255 */
1256 void target_free_all_working_areas_restore(struct target_s *target, int restore)
1257 {
1258 working_area_t *c = target->working_areas;
1259
1260 while (c)
1261 {
1262 working_area_t *next = c->next;
1263 target_free_working_area_restore(target, c, restore);
1264
1265 if (c->backup)
1266 free(c->backup);
1267
1268 free(c);
1269
1270 c = next;
1271 }
1272
1273 target->working_areas = NULL;
1274 }
1275
1276 void target_free_all_working_areas(struct target_s *target)
1277 {
1278 target_free_all_working_areas_restore(target, 1);
1279 }
1280
1281 int target_register_commands(struct command_context_s *cmd_ctx)
1282 {
1283
1284 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)");
1285
1286
1287
1288
1289 register_jim(cmd_ctx, "target", jim_target, "configure target");
1290
1291 return ERROR_OK;
1292 }
1293
1294 int target_arch_state(struct target_s *target)
1295 {
1296 int retval;
1297 if (target == NULL)
1298 {
1299 LOG_USER("No target has been configured");
1300 return ERROR_OK;
1301 }
1302
1303 LOG_USER("target state: %s", target_state_name( target ));
1304
1305 if (target->state != TARGET_HALTED)
1306 return ERROR_OK;
1307
1308 retval = target->type->arch_state(target);
1309 return retval;
1310 }
1311
1312 /* Single aligned words are guaranteed to use 16 or 32 bit access
1313 * mode respectively, otherwise data is handled as quickly as
1314 * possible
1315 */
1316 int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1317 {
1318 int retval;
1319 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
1320 (int)size, (unsigned)address);
1321
1322 if (!target_was_examined(target))
1323 {
1324 LOG_ERROR("Target not examined yet");
1325 return ERROR_FAIL;
1326 }
1327
1328 if (size == 0) {
1329 return ERROR_OK;
1330 }
1331
1332 if ((address + size - 1) < address)
1333 {
1334 /* GDB can request this when e.g. PC is 0xfffffffc*/
1335 LOG_ERROR("address + size wrapped(0x%08x, 0x%08x)",
1336 (unsigned)address,
1337 (unsigned)size);
1338 return ERROR_FAIL;
1339 }
1340
1341 if (((address % 2) == 0) && (size == 2))
1342 {
1343 return target_write_memory(target, address, 2, 1, buffer);
1344 }
1345
1346 /* handle unaligned head bytes */
1347 if (address % 4)
1348 {
1349 uint32_t unaligned = 4 - (address % 4);
1350
1351 if (unaligned > size)
1352 unaligned = size;
1353
1354 if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1355 return retval;
1356
1357 buffer += unaligned;
1358 address += unaligned;
1359 size -= unaligned;
1360 }
1361
1362 /* handle aligned words */
1363 if (size >= 4)
1364 {
1365 int aligned = size - (size % 4);
1366
1367 /* use bulk writes above a certain limit. This may have to be changed */
1368 if (aligned > 128)
1369 {
1370 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1371 return retval;
1372 }
1373 else
1374 {
1375 if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1376 return retval;
1377 }
1378
1379 buffer += aligned;
1380 address += aligned;
1381 size -= aligned;
1382 }
1383
1384 /* handle tail writes of less than 4 bytes */
1385 if (size > 0)
1386 {
1387 if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1388 return retval;
1389 }
1390
1391 return ERROR_OK;
1392 }
1393
1394 /* Single aligned words are guaranteed to use 16 or 32 bit access
1395 * mode respectively, otherwise data is handled as quickly as
1396 * possible
1397 */
1398 int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
1399 {
1400 int retval;
1401 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
1402 (int)size, (unsigned)address);
1403
1404 if (!target_was_examined(target))
1405 {
1406 LOG_ERROR("Target not examined yet");
1407 return ERROR_FAIL;
1408 }
1409
1410 if (size == 0) {
1411 return ERROR_OK;
1412 }
1413
1414 if ((address + size - 1) < address)
1415 {
1416 /* GDB can request this when e.g. PC is 0xfffffffc*/
1417 LOG_ERROR("address + size wrapped(0x%08" PRIx32 ", 0x%08" PRIx32 ")",
1418 address,
1419 size);
1420 return ERROR_FAIL;
1421 }
1422
1423 if (((address % 2) == 0) && (size == 2))
1424 {
1425 return target_read_memory(target, address, 2, 1, buffer);
1426 }
1427
1428 /* handle unaligned head bytes */
1429 if (address % 4)
1430 {
1431 uint32_t unaligned = 4 - (address % 4);
1432
1433 if (unaligned > size)
1434 unaligned = size;
1435
1436 if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1437 return retval;
1438
1439 buffer += unaligned;
1440 address += unaligned;
1441 size -= unaligned;
1442 }
1443
1444 /* handle aligned words */
1445 if (size >= 4)
1446 {
1447 int aligned = size - (size % 4);
1448
1449 if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1450 return retval;
1451
1452 buffer += aligned;
1453 address += aligned;
1454 size -= aligned;
1455 }
1456
1457 /*prevent byte access when possible (avoid AHB access limitations in some cases)*/
1458 if(size >=2)
1459 {
1460 int aligned = size - (size%2);
1461 retval = target_read_memory(target, address, 2, aligned / 2, buffer);
1462 if (retval != ERROR_OK)
1463 return retval;
1464
1465 buffer += aligned;
1466 address += aligned;
1467 size -= aligned;
1468 }
1469 /* handle tail writes of less than 4 bytes */
1470 if (size > 0)
1471 {
1472 if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1473 return retval;
1474 }
1475
1476 return ERROR_OK;
1477 }
1478
1479 int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc)
1480 {
1481 uint8_t *buffer;
1482 int retval;
1483 uint32_t i;
1484 uint32_t checksum = 0;
1485 if (!target_was_examined(target))
1486 {
1487 LOG_ERROR("Target not examined yet");
1488 return ERROR_FAIL;
1489 }
1490
1491 if ((retval = target->type->checksum_memory(target, address,
1492 size, &checksum)) != ERROR_OK)
1493 {
1494 buffer = malloc(size);
1495 if (buffer == NULL)
1496 {
1497 LOG_ERROR("error allocating buffer for section (%d bytes)", (int)size);
1498 return ERROR_INVALID_ARGUMENTS;
1499 }
1500 retval = target_read_buffer(target, address, size, buffer);
1501 if (retval != ERROR_OK)
1502 {
1503 free(buffer);
1504 return retval;
1505 }
1506
1507 /* convert to target endianess */
1508 for (i = 0; i < (size/sizeof(uint32_t)); i++)
1509 {
1510 uint32_t target_data;
1511 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
1512 target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
1513 }
1514
1515 retval = image_calculate_checksum(buffer, size, &checksum);
1516 free(buffer);
1517 }
1518
1519 *crc = checksum;
1520
1521 return retval;
1522 }
1523
1524 int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank)
1525 {
1526 int retval;
1527 if (!target_was_examined(target))
1528 {
1529 LOG_ERROR("Target not examined yet");
1530 return ERROR_FAIL;
1531 }
1532
1533 if (target->type->blank_check_memory == 0)
1534 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1535
1536 retval = target->type->blank_check_memory(target, address, size, blank);
1537
1538 return retval;
1539 }
1540
1541 int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value)
1542 {
1543 uint8_t value_buf[4];
1544 if (!target_was_examined(target))
1545 {
1546 LOG_ERROR("Target not examined yet");
1547 return ERROR_FAIL;
1548 }
1549
1550 int retval = target_read_memory(target, address, 4, 1, value_buf);
1551
1552 if (retval == ERROR_OK)
1553 {
1554 *value = target_buffer_get_u32(target, value_buf);
1555 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1556 address,
1557 *value);
1558 }
1559 else
1560 {
1561 *value = 0x0;
1562 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1563 address);
1564 }
1565
1566 return retval;
1567 }
1568
1569 int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value)
1570 {
1571 uint8_t value_buf[2];
1572 if (!target_was_examined(target))
1573 {
1574 LOG_ERROR("Target not examined yet");
1575 return ERROR_FAIL;
1576 }
1577
1578 int retval = target_read_memory(target, address, 2, 1, value_buf);
1579
1580 if (retval == ERROR_OK)
1581 {
1582 *value = target_buffer_get_u16(target, value_buf);
1583 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4x",
1584 address,
1585 *value);
1586 }
1587 else
1588 {
1589 *value = 0x0;
1590 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1591 address);
1592 }
1593
1594 return retval;
1595 }
1596
1597 int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value)
1598 {
1599 int retval = target_read_memory(target, address, 1, 1, value);
1600 if (!target_was_examined(target))
1601 {
1602 LOG_ERROR("Target not examined yet");
1603 return ERROR_FAIL;
1604 }
1605
1606 if (retval == ERROR_OK)
1607 {
1608 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1609 address,
1610 *value);
1611 }
1612 else
1613 {
1614 *value = 0x0;
1615 LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
1616 address);
1617 }
1618
1619 return retval;
1620 }
1621
1622 int target_write_u32(struct target_s *target, uint32_t address, uint32_t value)
1623 {
1624 int retval;
1625 uint8_t value_buf[4];
1626 if (!target_was_examined(target))
1627 {
1628 LOG_ERROR("Target not examined yet");
1629 return ERROR_FAIL;
1630 }
1631
1632 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
1633 address,
1634 value);
1635
1636 target_buffer_set_u32(target, value_buf, value);
1637 if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1638 {
1639 LOG_DEBUG("failed: %i", retval);
1640 }
1641
1642 return retval;
1643 }
1644
1645 int target_write_u16(struct target_s *target, uint32_t address, uint16_t value)
1646 {
1647 int retval;
1648 uint8_t value_buf[2];
1649 if (!target_was_examined(target))
1650 {
1651 LOG_ERROR("Target not examined yet");
1652 return ERROR_FAIL;
1653 }
1654
1655 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8x",
1656 address,
1657 value);
1658
1659 target_buffer_set_u16(target, value_buf, value);
1660 if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1661 {
1662 LOG_DEBUG("failed: %i", retval);
1663 }
1664
1665 return retval;
1666 }
1667
1668 int target_write_u8(struct target_s *target, uint32_t address, uint8_t value)
1669 {
1670 int retval;
1671 if (!target_was_examined(target))
1672 {
1673 LOG_ERROR("Target not examined yet");
1674 return ERROR_FAIL;
1675 }
1676
1677 LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
1678 address, value);
1679
1680 if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
1681 {
1682 LOG_DEBUG("failed: %i", retval);
1683 }
1684
1685 return retval;
1686 }
1687
1688 int target_register_user_commands(struct command_context_s *cmd_ctx)
1689 {
1690 int retval = ERROR_OK;
1691
1692
1693 /* script procedures */
1694 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
1695 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>");
1696 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>");
1697
1698 register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
1699 "same args as load_image, image stored in memory - mainly for profiling purposes");
1700
1701 register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
1702 "loads active fast load image to current target - mainly for profiling purposes");
1703
1704
1705 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
1706 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
1707 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1708 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1709 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1710 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1711 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1712 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run | halt | init] - default is run");
1713 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1714
1715 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words [phys] <addr> [count]");
1716 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [phys] <addr> [count]");
1717 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [phys] <addr> [count]");
1718
1719 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [phys] <addr> <value> [count]");
1720 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [phys] <addr> <value> [count]");
1721 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [phys] <addr> <value> [count]");
1722
1723 register_command(cmd_ctx, NULL, "bp",
1724 handle_bp_command, COMMAND_EXEC,
1725 "list or set breakpoint [<address> <length> [hw]]");
1726 register_command(cmd_ctx, NULL, "rbp",
1727 handle_rbp_command, COMMAND_EXEC,
1728 "remove breakpoint <address>");
1729 register_command(cmd_ctx, NULL, "wp",
1730 handle_wp_command, COMMAND_EXEC,
1731 "list or set watchpoint "
1732 "[<address> <length> <r/w/a> [value] [mask]]");
1733 register_command(cmd_ctx, NULL, "rwp",
1734 handle_rwp_command, COMMAND_EXEC,
1735 "remove watchpoint <address>");
1736
1737 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]");
1738 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1739 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1740 register_command(cmd_ctx, NULL, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image <file> [offset] [type]");
1741
1742 if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
1743 return retval;
1744 if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
1745 return retval;
1746
1747 return retval;
1748 }
1749
1750 static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1751 {
1752 target_t *target = all_targets;
1753
1754 if (argc == 1)
1755 {
1756 target = get_target(args[0]);
1757 if (target == NULL) {
1758 command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0]);
1759 goto DumpTargets;
1760 }
1761 if (!target->tap->enabled) {
1762 command_print(cmd_ctx,"Target: TAP %s is disabled, "
1763 "can't be the current target\n",
1764 target->tap->dotted_name);
1765 return ERROR_FAIL;
1766 }
1767
1768 cmd_ctx->current_target = target->target_number;
1769 return ERROR_OK;
1770 }
1771 DumpTargets:
1772
1773 target = all_targets;
1774 command_print(cmd_ctx, " TargetName Type Endian TapName State ");
1775 command_print(cmd_ctx, "-- ------------------ ---------- ------ ------------------ ------------");
1776 while (target)
1777 {
1778 const char *state;
1779 char marker = ' ';
1780
1781 if (target->tap->enabled)
1782 state = target_state_name( target );
1783 else
1784 state = "tap-disabled";
1785
1786 if (cmd_ctx->current_target == target->target_number)
1787 marker = '*';
1788
1789 /* keep columns lined up to match the headers above */
1790 command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s",
1791 target->target_number,
1792 marker,
1793 target->cmd_name,
1794 target_get_name(target),
1795 Jim_Nvp_value2name_simple(nvp_target_endian,
1796 target->endianness)->name,
1797 target->tap->dotted_name,
1798 state);
1799 target = target->next;
1800 }
1801
1802 return ERROR_OK;
1803 }
1804
1805 /* every 300ms we check for reset & powerdropout and issue a "reset halt" if so. */
1806
1807 static int powerDropout;
1808 static int srstAsserted;
1809
1810 static int runPowerRestore;
1811 static int runPowerDropout;
1812 static int runSrstAsserted;
1813 static int runSrstDeasserted;
1814
1815 static int sense_handler(void)
1816 {
1817 static int prevSrstAsserted = 0;
1818 static int prevPowerdropout = 0;
1819
1820 int retval;
1821 if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
1822 return retval;
1823
1824 int powerRestored;
1825 powerRestored = prevPowerdropout && !powerDropout;
1826 if (powerRestored)
1827 {
1828 runPowerRestore = 1;
1829 }
1830
1831 long long current = timeval_ms();
1832 static long long lastPower = 0;
1833 int waitMore = lastPower + 2000 > current;
1834 if (powerDropout && !waitMore)
1835 {
1836 runPowerDropout = 1;
1837 lastPower = current;
1838 }
1839
1840 if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
1841 return retval;
1842
1843 int srstDeasserted;
1844 srstDeasserted = prevSrstAsserted && !srstAsserted;
1845
1846 static long long lastSrst = 0;
1847 waitMore = lastSrst + 2000 > current;
1848 if (srstDeasserted && !waitMore)
1849 {
1850 runSrstDeasserted = 1;
1851 lastSrst = current;
1852 }
1853
1854 if (!prevSrstAsserted && srstAsserted)
1855 {
1856 runSrstAsserted = 1;
1857 }
1858
1859 prevSrstAsserted = srstAsserted;
1860 prevPowerdropout = powerDropout;
1861
1862 if (srstDeasserted || powerRestored)
1863 {
1864 /* Other than logging the event we can't do anything here.
1865 * Issuing a reset is a particularly bad idea as we might
1866 * be inside a reset already.
1867 */
1868 }
1869
1870 return ERROR_OK;
1871 }
1872
1873 static void target_call_event_callbacks_all(enum target_event e) {
1874 target_t *target;
1875 target = all_targets;
1876 while (target) {
1877 target_call_event_callbacks(target, e);
1878 target = target->next;
1879 }
1880 }
1881
1882 /* process target state changes */
1883 int handle_target(void *priv)
1884 {
1885 int retval = ERROR_OK;
1886
1887 /* we do not want to recurse here... */
1888 static int recursive = 0;
1889 if (! recursive)
1890 {
1891 recursive = 1;
1892 sense_handler();
1893 /* danger! running these procedures can trigger srst assertions and power dropouts.
1894 * We need to avoid an infinite loop/recursion here and we do that by
1895 * clearing the flags after running these events.
1896 */
1897 int did_something = 0;
1898 if (runSrstAsserted)
1899 {
1900 target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1901 Jim_Eval(interp, "srst_asserted");
1902 did_something = 1;
1903 }
1904 if (runSrstDeasserted)
1905 {
1906 Jim_Eval(interp, "srst_deasserted");
1907 did_something = 1;
1908 }
1909 if (runPowerDropout)
1910 {
1911 target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
1912 Jim_Eval(interp, "power_dropout");
1913 did_something = 1;
1914 }
1915 if (runPowerRestore)
1916 {
1917 Jim_Eval(interp, "power_restore");
1918 did_something = 1;
1919 }
1920
1921 if (did_something)
1922 {
1923 /* clear detect flags */
1924 sense_handler();
1925 }
1926
1927 /* clear action flags */
1928
1929 runSrstAsserted = 0;
1930 runSrstDeasserted = 0;
1931 runPowerRestore = 0;
1932 runPowerDropout = 0;
1933
1934 recursive = 0;
1935 }
1936
1937 /* Poll targets for state changes unless that's globally disabled.
1938 * Skip targets that are currently disabled.
1939 */
1940 for (target_t *target = all_targets;
1941 is_jtag_poll_safe() && target;
1942 target = target->next)
1943 {
1944 if (!target->tap->enabled)
1945 continue;
1946
1947 /* only poll target if we've got power and srst isn't asserted */
1948 if (!powerDropout && !srstAsserted)
1949 {
1950 /* polling may fail silently until the target has been examined */
1951 if ((retval = target_poll(target)) != ERROR_OK)
1952 {
1953 target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
1954 return retval;
1955 }
1956 }
1957 }
1958
1959 return retval;
1960 }
1961
1962 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1963 {
1964 target_t *target;
1965 reg_t *reg = NULL;
1966 int count = 0;
1967 char *value;
1968
1969 LOG_DEBUG("-");
1970
1971 target = get_current_target(cmd_ctx);
1972
1973 /* list all available registers for the current target */
1974 if (argc == 0)
1975 {
1976 reg_cache_t *cache = target->reg_cache;
1977
1978 count = 0;
1979 while (cache)
1980 {
1981 int i;
1982
1983 command_print(cmd_ctx, "===== %s", cache->name);
1984
1985 for (i = 0, reg = cache->reg_list;
1986 i < cache->num_regs;
1987 i++, reg++, count++)
1988 {
1989 /* only print cached values if they are valid */
1990 if (reg->valid) {
1991 value = buf_to_str(reg->value,
1992 reg->size, 16);
1993 command_print(cmd_ctx,
1994 "(%i) %s (/%" PRIu32 "): 0x%s%s",
1995 count, reg->name,
1996 reg->size, value,
1997 reg->dirty
1998 ? " (dirty)"
1999 : "");
2000 free(value);
2001 } else {
2002 command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")",
2003 count, reg->name,
2004 reg->size) ;
2005 }
2006 }
2007 cache = cache->next;
2008 }
2009
2010 return ERROR_OK;
2011 }
2012
2013 /* access a single register by its ordinal number */
2014 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
2015 {
2016 unsigned num;
2017 int retval = parse_uint(args[0], &num);
2018 if (ERROR_OK != retval)
2019 return ERROR_COMMAND_SYNTAX_ERROR;
2020
2021 reg_cache_t *cache = target->reg_cache;
2022 count = 0;
2023 while (cache)
2024 {
2025 int i;
2026 for (i = 0; i < cache->num_regs; i++)
2027 {
2028 if (count++ == (int)num)
2029 {
2030 reg = &cache->reg_list[i];
2031 break;
2032 }
2033 }
2034 if (reg)
2035 break;
2036 cache = cache->next;
2037 }
2038
2039 if (!reg)
2040 {
2041 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
2042 return ERROR_OK;
2043 }
2044 } else /* access a single register by its name */
2045 {
2046 reg = register_get_by_name(target->reg_cache, args[0], 1);
2047
2048 if (!reg)
2049 {
2050 command_print(cmd_ctx, "register %s not found in current target", args[0]);
2051 return ERROR_OK;
2052 }
2053 }
2054
2055 /* display a register */
2056 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
2057 {
2058 if ((argc == 2) && (strcmp(args[1], "force") == 0))
2059 reg->valid = 0;
2060
2061 if (reg->valid == 0)
2062 {
2063 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
2064 arch_type->get(reg);
2065 }
2066 value = buf_to_str(reg->value, reg->size, 16);
2067 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2068 free(value);
2069 return ERROR_OK;
2070 }
2071
2072 /* set register value */
2073 if (argc == 2)
2074 {
2075 uint8_t *buf = malloc(CEIL(reg->size, 8));
2076 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
2077
2078 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
2079 arch_type->set(reg, buf);
2080
2081 value = buf_to_str(reg->value, reg->size, 16);
2082 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
2083 free(value);
2084
2085 free(buf);
2086
2087 return ERROR_OK;
2088 }
2089
2090 command_print(cmd_ctx, "usage: reg <#|name> [value]");
2091
2092 return ERROR_OK;
2093 }
2094
2095 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2096 {
2097 int retval = ERROR_OK;
2098 target_t *target = get_current_target(cmd_ctx);
2099
2100 if (argc == 0)
2101 {
2102 command_print(cmd_ctx, "background polling: %s",
2103 jtag_poll_get_enabled() ? "on" : "off");
2104 command_print(cmd_ctx, "TAP: %s (%s)",
2105 target->tap->dotted_name,
2106 target->tap->enabled ? "enabled" : "disabled");
2107 if (!target->tap->enabled)
2108 return ERROR_OK;
2109 if ((retval = target_poll(target)) != ERROR_OK)
2110 return retval;
2111 if ((retval = target_arch_state(target)) != ERROR_OK)
2112 return retval;
2113
2114 }
2115 else if (argc == 1)
2116 {
2117 if (strcmp(args[0], "on") == 0)
2118 {
2119 jtag_poll_set_enabled(true);
2120 }
2121 else if (strcmp(args[0], "off") == 0)
2122 {
2123 jtag_poll_set_enabled(false);
2124 }
2125 else
2126 {
2127 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
2128 }
2129 } else
2130 {
2131 return ERROR_COMMAND_SYNTAX_ERROR;
2132 }
2133
2134 return retval;
2135 }
2136
2137 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2138 {
2139 if (argc > 1)
2140 return ERROR_COMMAND_SYNTAX_ERROR;
2141
2142 unsigned ms = 5000;
2143 if (1 == argc)
2144 {
2145 int retval = parse_uint(args[0], &ms);
2146 if (ERROR_OK != retval)
2147 {
2148 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
2149 return ERROR_COMMAND_SYNTAX_ERROR;
2150 }
2151 // convert seconds (given) to milliseconds (needed)
2152 ms *= 1000;
2153 }
2154
2155 target_t *target = get_current_target(cmd_ctx);
2156 return target_wait_state(target, TARGET_HALTED, ms);
2157 }
2158
2159 /* wait for target state to change. The trick here is to have a low
2160 * latency for short waits and not to suck up all the CPU time
2161 * on longer waits.
2162 *
2163 * After 500ms, keep_alive() is invoked
2164 */
2165 int target_wait_state(target_t *target, enum target_state state, int ms)
2166 {
2167 int retval;
2168 long long then = 0, cur;
2169 int once = 1;
2170
2171 for (;;)
2172 {
2173 if ((retval = target_poll(target)) != ERROR_OK)
2174 return retval;
2175 if (target->state == state)
2176 {
2177 break;
2178 }
2179 cur = timeval_ms();
2180 if (once)
2181 {
2182 once = 0;
2183 then = timeval_ms();
2184 LOG_DEBUG("waiting for target %s...",
2185 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2186 }
2187
2188 if (cur-then > 500)
2189 {
2190 keep_alive();
2191 }
2192
2193 if ((cur-then) > ms)
2194 {
2195 LOG_ERROR("timed out while waiting for target %s",
2196 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
2197 return ERROR_FAIL;
2198 }
2199 }
2200
2201 return ERROR_OK;
2202 }
2203
2204 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2205 {
2206 LOG_DEBUG("-");
2207
2208 target_t *target = get_current_target(cmd_ctx);
2209 int retval = target_halt(target);
2210 if (ERROR_OK != retval)
2211 return retval;
2212
2213 if (argc == 1)
2214 {
2215 unsigned wait;
2216 retval = parse_uint(args[0], &wait);
2217 if (ERROR_OK != retval)
2218 return ERROR_COMMAND_SYNTAX_ERROR;
2219 if (!wait)
2220 return ERROR_OK;
2221 }
2222
2223 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
2224 }
2225
2226 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2227 {
2228 target_t *target = get_current_target(cmd_ctx);
2229
2230 LOG_USER("requesting target halt and executing a soft reset");
2231
2232 target->type->soft_reset_halt(target);
2233
2234 return ERROR_OK;
2235 }
2236
2237 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2238 {
2239 if (argc > 1)
2240 return ERROR_COMMAND_SYNTAX_ERROR;
2241
2242 enum target_reset_mode reset_mode = RESET_RUN;
2243 if (argc == 1)
2244 {
2245 const Jim_Nvp *n;
2246 n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
2247 if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
2248 return ERROR_COMMAND_SYNTAX_ERROR;
2249 }
2250 reset_mode = n->value;
2251 }
2252
2253 /* reset *all* targets */
2254 return target_process_reset(cmd_ctx, reset_mode);
2255 }
2256
2257
2258 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2259 {
2260 int current = 1;
2261 if (argc > 1)
2262 return ERROR_COMMAND_SYNTAX_ERROR;
2263
2264 target_t *target = get_current_target(cmd_ctx);
2265 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
2266
2267 /* with no args, resume from current pc, addr = 0,
2268 * with one arguments, addr = args[0],
2269 * handle breakpoints, not debugging */
2270 uint32_t addr = 0;
2271 if (argc == 1)
2272 {
2273 int retval = parse_u32(args[0], &addr);
2274 if (ERROR_OK != retval)
2275 return retval;
2276 current = 0;
2277 }
2278
2279 return target_resume(target, current, addr, 1, 0);
2280 }
2281
2282 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2283 {
2284 if (argc > 1)
2285 return ERROR_COMMAND_SYNTAX_ERROR;
2286
2287 LOG_DEBUG("-");
2288
2289 /* with no args, step from current pc, addr = 0,
2290 * with one argument addr = args[0],
2291 * handle breakpoints, debugging */
2292 uint32_t addr = 0;
2293 int current_pc = 1;
2294 if (argc == 1)
2295 {
2296 int retval = parse_u32(args[0], &addr);
2297 if (ERROR_OK != retval)
2298 return retval;
2299 current_pc = 0;
2300 }
2301
2302 target_t *target = get_current_target(cmd_ctx);
2303
2304 return target->type->step(target, current_pc, addr, 1);
2305 }
2306
2307 static void handle_md_output(struct command_context_s *cmd_ctx,
2308 struct target_s *target, uint32_t address, unsigned size,
2309 unsigned count, const uint8_t *buffer)
2310 {
2311 const unsigned line_bytecnt = 32;
2312 unsigned line_modulo = line_bytecnt / size;
2313
2314 char output[line_bytecnt * 4 + 1];
2315 unsigned output_len = 0;
2316
2317 const char *value_fmt;
2318 switch (size) {
2319 case 4: value_fmt = "%8.8x "; break;
2320 case 2: value_fmt = "%4.2x "; break;
2321 case 1: value_fmt = "%2.2x "; break;
2322 default:
2323 LOG_ERROR("invalid memory read size: %u", size);
2324 exit(-1);
2325 }
2326
2327 for (unsigned i = 0; i < count; i++)
2328 {
2329 if (i % line_modulo == 0)
2330 {
2331 output_len += snprintf(output + output_len,
2332 sizeof(output) - output_len,
2333 "0x%8.8x: ",
2334 (unsigned)(address + (i*size)));
2335 }
2336
2337 uint32_t value = 0;
2338 const uint8_t *value_ptr = buffer + i * size;
2339 switch (size) {
2340 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2341 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2342 case 1: value = *value_ptr;
2343 }
2344 output_len += snprintf(output + output_len,
2345 sizeof(output) - output_len,
2346 value_fmt, value);
2347
2348 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2349 {
2350 command_print(cmd_ctx, "%s", output);
2351 output_len = 0;
2352 }
2353 }
2354 }
2355
2356 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2357 {
2358 if (argc < 1)
2359 return ERROR_COMMAND_SYNTAX_ERROR;
2360
2361 unsigned size = 0;
2362 switch (cmd[2]) {
2363 case 'w': size = 4; break;
2364 case 'h': size = 2; break;
2365 case 'b': size = 1; break;
2366 default: return ERROR_COMMAND_SYNTAX_ERROR;
2367 }
2368
2369 bool physical=strcmp(args[0], "phys")==0;
2370 int (*fn)(struct target_s *target,
2371 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2372 if (physical)
2373 {
2374 argc--;
2375 args++;
2376 fn=target_read_phys_memory;
2377 } else
2378 {
2379 fn=target_read_memory;
2380 }
2381 if ((argc < 1) || (argc > 2))
2382 {
2383 return ERROR_COMMAND_SYNTAX_ERROR;
2384 }
2385 uint32_t address;
2386 int retval = parse_u32(args[0], &address);
2387 if (ERROR_OK != retval)
2388 return retval;
2389
2390 unsigned count = 1;
2391 if (argc == 2)
2392 {
2393 retval = parse_uint(args[1], &count);
2394 if (ERROR_OK != retval)
2395 return retval;
2396 }
2397
2398 uint8_t *buffer = calloc(count, size);
2399
2400 target_t *target = get_current_target(cmd_ctx);
2401 retval = fn(target, address, size, count, buffer);
2402 if (ERROR_OK == retval)
2403 handle_md_output(cmd_ctx, target, address, size, count, buffer);
2404
2405 free(buffer);
2406
2407 return retval;
2408 }
2409
2410 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2411 {
2412 if (argc < 2)
2413 {
2414 return ERROR_COMMAND_SYNTAX_ERROR;
2415 }
2416 bool physical=strcmp(args[0], "phys")==0;
2417 int (*fn)(struct target_s *target,
2418 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
2419 if (physical)
2420 {
2421 argc--;
2422 args++;
2423 fn=target_write_phys_memory;
2424 } else
2425 {
2426 fn=target_write_memory;
2427 }
2428 if ((argc < 2) || (argc > 3))
2429 return ERROR_COMMAND_SYNTAX_ERROR;
2430
2431 uint32_t address;
2432 int retval = parse_u32(args[0], &address);
2433 if (ERROR_OK != retval)
2434 return retval;
2435
2436 uint32_t value;
2437 retval = parse_u32(args[1], &value);
2438 if (ERROR_OK != retval)
2439 return retval;
2440
2441 unsigned count = 1;
2442 if (argc == 3)
2443 {
2444 retval = parse_uint(args[2], &count);
2445 if (ERROR_OK != retval)
2446 return retval;
2447 }
2448
2449 target_t *target = get_current_target(cmd_ctx);
2450 unsigned wordsize;
2451 uint8_t value_buf[4];
2452 switch (cmd[2])
2453 {
2454 case 'w':
2455 wordsize = 4;
2456 target_buffer_set_u32(target, value_buf, value);
2457 break;
2458 case 'h':
2459 wordsize = 2;
2460 target_buffer_set_u16(target, value_buf, value);
2461 break;
2462 case 'b':
2463 wordsize = 1;
2464 value_buf[0] = value;
2465 break;
2466 default:
2467 return ERROR_COMMAND_SYNTAX_ERROR;
2468 }
2469 for (unsigned i = 0; i < count; i++)
2470 {
2471 retval = fn(target,
2472 address + i * wordsize, wordsize, 1, value_buf);
2473 if (ERROR_OK != retval)
2474 return retval;
2475 keep_alive();
2476 }
2477
2478 return ERROR_OK;
2479
2480 }
2481
2482 static int parse_load_image_command_args(char **args, int argc,
2483 image_t *image, uint32_t *min_address, uint32_t *max_address)
2484 {
2485 if (argc < 1 || argc > 5)
2486 return ERROR_COMMAND_SYNTAX_ERROR;
2487
2488 /* a base address isn't always necessary,
2489 * default to 0x0 (i.e. don't relocate) */
2490 if (argc >= 2)
2491 {
2492 uint32_t addr;
2493 int retval = parse_u32(args[1], &addr);
2494 if (ERROR_OK != retval)
2495 return ERROR_COMMAND_SYNTAX_ERROR;
2496 image->base_address = addr;
2497 image->base_address_set = 1;
2498 }
2499 else
2500 image->base_address_set = 0;
2501
2502 image->start_address_set = 0;
2503
2504 if (argc >= 4)
2505 {
2506 int retval = parse_u32(args[3], min_address);
2507 if (ERROR_OK != retval)
2508 return ERROR_COMMAND_SYNTAX_ERROR;
2509 }
2510 if (argc == 5)
2511 {
2512 int retval = parse_u32(args[4], max_address);
2513 if (ERROR_OK != retval)
2514 return ERROR_COMMAND_SYNTAX_ERROR;
2515 // use size (given) to find max (required)
2516 *max_address += *min_address;
2517 }
2518
2519 if (*min_address > *max_address)
2520 return ERROR_COMMAND_SYNTAX_ERROR;
2521
2522 return ERROR_OK;
2523 }
2524
2525 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2526 {
2527 uint8_t *buffer;
2528 uint32_t buf_cnt;
2529 uint32_t image_size;
2530 uint32_t min_address = 0;
2531 uint32_t max_address = 0xffffffff;
2532 int i;
2533 int retvaltemp;
2534
2535 image_t image;
2536
2537 duration_t duration;
2538 char *duration_text;
2539
2540 int retval = parse_load_image_command_args(args, argc,
2541 &image, &min_address, &max_address);
2542 if (ERROR_OK != retval)
2543 return retval;
2544
2545 target_t *target = get_current_target(cmd_ctx);
2546 duration_start_measure(&duration);
2547
2548 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2549 {
2550 return ERROR_OK;
2551 }
2552
2553 image_size = 0x0;
2554 retval = ERROR_OK;
2555 for (i = 0; i < image.num_sections; i++)
2556 {
2557 buffer = malloc(image.sections[i].size);
2558 if (buffer == NULL)
2559 {
2560 command_print(cmd_ctx,
2561 "error allocating buffer for section (%d bytes)",
2562 (int)(image.sections[i].size));
2563 break;
2564 }
2565
2566 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2567 {
2568 free(buffer);
2569 break;
2570 }
2571
2572 uint32_t offset = 0;
2573 uint32_t length = buf_cnt;
2574
2575 /* DANGER!!! beware of unsigned comparision here!!! */
2576
2577 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
2578 (image.sections[i].base_address < max_address))
2579 {
2580 if (image.sections[i].base_address < min_address)
2581 {
2582 /* clip addresses below */
2583 offset += min_address-image.sections[i].base_address;
2584 length -= offset;
2585 }
2586
2587 if (image.sections[i].base_address + buf_cnt > max_address)
2588 {
2589 length -= (image.sections[i].base_address + buf_cnt)-max_address;
2590 }
2591
2592 if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
2593 {
2594 free(buffer);
2595 break;
2596 }
2597 image_size += length;
2598 command_print(cmd_ctx, "%u bytes written at address 0x%8.8" PRIx32 "",
2599 (unsigned int)length,
2600 image.sections[i].base_address + offset);
2601 }
2602
2603 free(buffer);
2604 }
2605
2606 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2607 {
2608 image_close(&image);
2609 return retvaltemp;
2610 }
2611
2612 if (retval == ERROR_OK)
2613 {
2614 command_print(cmd_ctx, "downloaded %u byte in %s",
2615 (unsigned int)image_size,
2616 duration_text);
2617 }
2618 free(duration_text);
2619
2620 image_close(&image);
2621
2622 return retval;
2623
2624 }
2625
2626 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2627 {
2628 fileio_t fileio;
2629
2630 uint8_t buffer[560];
2631 int retvaltemp;
2632
2633 duration_t duration;
2634 char *duration_text;
2635
2636 target_t *target = get_current_target(cmd_ctx);
2637
2638 if (argc != 3)
2639 {
2640 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2641 return ERROR_OK;
2642 }
2643
2644 uint32_t address;
2645 int retval = parse_u32(args[1], &address);
2646 if (ERROR_OK != retval)
2647 return retval;
2648
2649 uint32_t size;
2650 retval = parse_u32(args[2], &size);
2651 if (ERROR_OK != retval)
2652 return retval;
2653
2654 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2655 {
2656 return ERROR_OK;
2657 }
2658
2659 duration_start_measure(&duration);
2660
2661 while (size > 0)
2662 {
2663 uint32_t size_written;
2664 uint32_t this_run_size = (size > 560) ? 560 : size;
2665
2666 retval = target_read_buffer(target, address, this_run_size, buffer);
2667 if (retval != ERROR_OK)
2668 {
2669 break;
2670 }
2671
2672 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2673 if (retval != ERROR_OK)
2674 {
2675 break;
2676 }
2677
2678 size -= this_run_size;
2679 address += this_run_size;
2680 }
2681
2682 if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2683 return retvaltemp;
2684
2685 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2686 return retvaltemp;
2687
2688 if (retval == ERROR_OK)
2689 {
2690 command_print(cmd_ctx, "dumped %lld byte in %s",
2691 fileio.size, duration_text);
2692 free(duration_text);
2693 }
2694
2695 return retval;
2696 }
2697
2698 static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
2699 {
2700 uint8_t *buffer;
2701 uint32_t buf_cnt;
2702 uint32_t image_size;
2703 int i;
2704 int retval, retvaltemp;
2705 uint32_t checksum = 0;
2706 uint32_t mem_checksum = 0;
2707
2708 image_t image;
2709
2710 duration_t duration;
2711 char *duration_text;
2712
2713 target_t *target = get_current_target(cmd_ctx);
2714
2715 if (argc < 1)
2716 {
2717 return ERROR_COMMAND_SYNTAX_ERROR;
2718 }
2719
2720 if (!target)
2721 {
2722 LOG_ERROR("no target selected");
2723 return ERROR_FAIL;
2724 }
2725
2726 duration_start_measure(&duration);
2727
2728 if (argc >= 2)
2729 {
2730 uint32_t addr;
2731 retval = parse_u32(args[1], &addr);
2732 if (ERROR_OK != retval)
2733 return ERROR_COMMAND_SYNTAX_ERROR;
2734 image.base_address = addr;
2735 image.base_address_set = 1;
2736 }
2737 else
2738 {
2739 image.base_address_set = 0;
2740 image.base_address = 0x0;
2741 }
2742
2743 image.start_address_set = 0;
2744
2745 if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2746 {
2747 return retval;
2748 }
2749
2750 image_size = 0x0;
2751 retval = ERROR_OK;
2752 for (i = 0; i < image.num_sections; i++)
2753 {
2754 buffer = malloc(image.sections[i].size);
2755 if (buffer == NULL)
2756 {
2757 command_print(cmd_ctx,
2758 "error allocating buffer for section (%d bytes)",
2759 (int)(image.sections[i].size));
2760 break;
2761 }
2762 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2763 {
2764 free(buffer);
2765 break;
2766 }
2767
2768 if (verify)
2769 {
2770 /* calculate checksum of image */
2771 image_calculate_checksum(buffer, buf_cnt, &checksum);
2772
2773 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2774 if (retval != ERROR_OK)
2775 {
2776 free(buffer);
2777 break;
2778 }
2779
2780 if (checksum != mem_checksum)
2781 {
2782 /* failed crc checksum, fall back to a binary compare */
2783 uint8_t *data;
2784
2785 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2786
2787 data = (uint8_t*)malloc(buf_cnt);
2788
2789 /* Can we use 32bit word accesses? */
2790 int size = 1;
2791 int count = buf_cnt;
2792 if ((count % 4) == 0)
2793 {
2794 size *= 4;
2795 count /= 4;
2796 }
2797 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2798 if (retval == ERROR_OK)
2799 {
2800 uint32_t t;
2801 for (t = 0; t < buf_cnt; t++)
2802 {
2803 if (data[t] != buffer[t])
2804 {
2805 command_print(cmd_ctx,
2806 "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
2807 (unsigned)(t + image.sections[i].base_address),
2808 data[t],
2809 buffer[t]);
2810 free(data);
2811 free(buffer);
2812 retval = ERROR_FAIL;
2813 goto done;
2814 }
2815 if ((t%16384) == 0)
2816 {
2817 keep_alive();
2818 }
2819 }
2820 }
2821
2822 free(data);
2823 }
2824 } else
2825 {
2826 command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08" PRIx32 "",
2827 image.sections[i].base_address,
2828 buf_cnt);
2829 }
2830
2831 free(buffer);
2832 image_size += buf_cnt;
2833 }
2834 done:
2835
2836 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2837 {
2838 image_close(&image);
2839 return retvaltemp;
2840 }
2841
2842 if (retval == ERROR_OK)
2843 {
2844 command_print(cmd_ctx, "verified %u bytes in %s",
2845 (unsigned int)image_size,
2846 duration_text);
2847 }
2848 free(duration_text);
2849
2850 image_close(&image);
2851
2852 return retval;
2853 }
2854
2855 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2856 {
2857 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
2858 }
2859
2860 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2861 {
2862 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
2863 }
2864
2865 static int handle_bp_command_list(struct command_context_s *cmd_ctx)
2866 {
2867 target_t *target = get_current_target(cmd_ctx);
2868 breakpoint_t *breakpoint = target->breakpoints;
2869 while (breakpoint)
2870 {
2871 if (breakpoint->type == BKPT_SOFT)
2872 {
2873 char* buf = buf_to_str(breakpoint->orig_instr,
2874 breakpoint->length, 16);
2875 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
2876 breakpoint->address,
2877 breakpoint->length,
2878 breakpoint->set, buf);
2879 free(buf);
2880 }
2881 else
2882 {
2883 command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i",
2884 breakpoint->address,
2885 breakpoint->length, breakpoint->set);
2886 }
2887
2888 breakpoint = breakpoint->next;
2889 }
2890 return ERROR_OK;
2891 }
2892
2893 static int handle_bp_command_set(struct command_context_s *cmd_ctx,
2894 uint32_t addr, uint32_t length, int hw)
2895 {
2896 target_t *target = get_current_target(cmd_ctx);
2897 int retval = breakpoint_add(target, addr, length, hw);
2898 if (ERROR_OK == retval)
2899 command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
2900 else
2901 LOG_ERROR("Failure setting breakpoint");
2902 return retval;
2903 }
2904
2905 static int handle_bp_command(struct command_context_s *cmd_ctx,
2906 char *cmd, char **args, int argc)
2907 {
2908 if (argc == 0)
2909 return handle_bp_command_list(cmd_ctx);
2910
2911 if (argc < 2 || argc > 3)
2912 {
2913 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2914 return ERROR_COMMAND_SYNTAX_ERROR;
2915 }
2916
2917 uint32_t addr;
2918 int retval = parse_u32(args[0], &addr);
2919 if (ERROR_OK != retval)
2920 return retval;
2921
2922 uint32_t length;
2923 retval = parse_u32(args[1], &length);
2924 if (ERROR_OK != retval)
2925 return retval;
2926
2927 int hw = BKPT_SOFT;
2928 if (argc == 3)
2929 {
2930 if (strcmp(args[2], "hw") == 0)
2931 hw = BKPT_HARD;
2932 else
2933 return ERROR_COMMAND_SYNTAX_ERROR;
2934 }
2935
2936 return handle_bp_command_set(cmd_ctx, addr, length, hw);
2937 }
2938
2939 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2940 {
2941 if (argc != 1)
2942 return ERROR_COMMAND_SYNTAX_ERROR;
2943
2944 uint32_t addr;
2945 int retval = parse_u32(args[0], &addr);
2946 if (ERROR_OK != retval)
2947 return retval;
2948
2949 target_t *target = get_current_target(cmd_ctx);
2950 breakpoint_remove(target, addr);
2951
2952 return ERROR_OK;
2953 }
2954
2955 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2956 {
2957 target_t *target = get_current_target(cmd_ctx);
2958
2959 if (argc == 0)
2960 {
2961 watchpoint_t *watchpoint = target->watchpoints;
2962
2963 while (watchpoint)
2964 {
2965 command_print(cmd_ctx,
2966 "address: 0x%8.8" PRIx32 ", len: 0x%8.8x, r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32 "",
2967 watchpoint->address,
2968 watchpoint->length,
2969 (int)(watchpoint->rw),
2970 watchpoint->value,
2971 watchpoint->mask);
2972 watchpoint = watchpoint->next;
2973 }
2974 return ERROR_OK;
2975 }
2976
2977 enum watchpoint_rw type = WPT_ACCESS;
2978 uint32_t addr = 0;
2979 uint32_t length = 0;
2980 uint32_t data_value = 0x0;
2981 uint32_t data_mask = 0xffffffff;
2982 int retval;
2983
2984 switch (argc)
2985 {
2986 case 5:
2987 retval = parse_u32(args[4], &data_mask);
2988 if (ERROR_OK != retval)
2989 return retval;
2990 // fall through
2991 case 4:
2992 retval = parse_u32(args[3], &data_value);
2993 if (ERROR_OK != retval)
2994 return retval;
2995 // fall through
2996 case 3:
2997 switch (args[2][0])
2998 {
2999 case 'r':
3000 type = WPT_READ;
3001 break;
3002 case 'w':
3003 type = WPT_WRITE;
3004 break;
3005 case 'a':
3006 type = WPT_ACCESS;
3007 break;
3008 default:
3009 LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]);
3010 return ERROR_COMMAND_SYNTAX_ERROR;
3011 }
3012 // fall through
3013 case 2:
3014 retval = parse_u32(args[1], &length);
3015 if (ERROR_OK != retval)
3016 return retval;
3017 retval = parse_u32(args[0], &addr);
3018 if (ERROR_OK != retval)
3019 return retval;
3020 break;
3021
3022 default:
3023 command_print(cmd_ctx, "usage: wp [address length "
3024 "[(r|w|a) [value [mask]]]]");
3025 return ERROR_COMMAND_SYNTAX_ERROR;
3026 }
3027
3028 retval = watchpoint_add(target, addr, length, type,
3029 data_value, data_mask);
3030 if (ERROR_OK != retval)
3031 LOG_ERROR("Failure setting watchpoints");
3032
3033 return retval;
3034 }
3035
3036 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3037 {
3038 if (argc != 1)
3039 return ERROR_COMMAND_SYNTAX_ERROR;
3040
3041 uint32_t addr;
3042 int retval = parse_u32(args[0], &addr);
3043 if (ERROR_OK != retval)
3044 return retval;
3045
3046 target_t *target = get_current_target(cmd_ctx);
3047 watchpoint_remove(target, addr);
3048
3049 return ERROR_OK;
3050 }
3051
3052
3053 /**
3054 * Translate a virtual address to a physical address.
3055 *
3056 * The low-level target implementation must have logged a detailed error
3057 * which is forwarded to telnet/GDB session.
3058 */
3059 static int handle_virt2phys_command(command_context_t *cmd_ctx,
3060 char *cmd, char **args, int argc)
3061 {
3062 if (argc != 1)
3063 return ERROR_COMMAND_SYNTAX_ERROR;
3064
3065 uint32_t va;
3066 int retval = parse_u32(args[0], &va);
3067 if (ERROR_OK != retval)
3068 return retval;
3069 uint32_t pa;
3070
3071 target_t *target = get_current_target(cmd_ctx);
3072 retval = target->type->virt2phys(target, va, &pa);
3073 if (retval == ERROR_OK)
3074 command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
3075
3076 return retval;
3077 }
3078
3079 static void writeData(FILE *f, const void *data, size_t len)
3080 {
3081 size_t written = fwrite(data, 1, len, f);
3082 if (written != len)
3083 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
3084 }
3085
3086 static void writeLong(FILE *f, int l)
3087 {
3088 int i;
3089 for (i = 0; i < 4; i++)
3090 {
3091 char c = (l >> (i*8))&0xff;
3092 writeData(f, &c, 1);
3093 }
3094
3095 }
3096
3097 static void writeString(FILE *f, char *s)
3098 {
3099 writeData(f, s, strlen(s));
3100 }
3101
3102 /* Dump a gmon.out histogram file. */
3103 static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
3104 {
3105 uint32_t i;
3106 FILE *f = fopen(filename, "w");
3107 if (f == NULL)
3108 return;
3109 writeString(f, "gmon");
3110 writeLong(f, 0x00000001); /* Version */
3111 writeLong(f, 0); /* padding */
3112 writeLong(f, 0); /* padding */
3113 writeLong(f, 0); /* padding */
3114
3115 uint8_t zero = 0; /* GMON_TAG_TIME_HIST */
3116 writeData(f, &zero, 1);
3117
3118 /* figure out bucket size */
3119 uint32_t min = samples[0];
3120 uint32_t max = samples[0];
3121 for (i = 0; i < sampleNum; i++)
3122 {
3123 if (min > samples[i])
3124 {
3125 min = samples[i];
3126 }
3127 if (max < samples[i])
3128 {
3129 max = samples[i];
3130 }
3131 }
3132
3133 int addressSpace = (max-min + 1);
3134
3135 static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
3136 uint32_t length = addressSpace;
3137 if (length > maxBuckets)
3138 {
3139 length = maxBuckets;
3140 }
3141 int *buckets = malloc(sizeof(int)*length);
3142 if (buckets == NULL)
3143 {
3144 fclose(f);
3145 return;
3146 }
3147 memset(buckets, 0, sizeof(int)*length);
3148 for (i = 0; i < sampleNum;i++)
3149 {
3150 uint32_t address = samples[i];
3151 long long a = address-min;
3152 long long b = length-1;
3153 long long c = addressSpace-1;
3154 int index = (a*b)/c; /* danger!!!! int32 overflows */
3155 buckets[index]++;
3156 }
3157
3158 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
3159 writeLong(f, min); /* low_pc */
3160 writeLong(f, max); /* high_pc */
3161 writeLong(f, length); /* # of samples */
3162 writeLong(f, 64000000); /* 64MHz */
3163 writeString(f, "seconds");
3164 for (i = 0; i < (15-strlen("seconds")); i++)
3165 writeData(f, &zero, 1);
3166 writeString(f, "s");
3167
3168 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
3169
3170 char *data = malloc(2*length);
3171 if (data != NULL)
3172 {
3173 for (i = 0; i < length;i++)
3174 {
3175 int val;
3176 val = buckets[i];
3177 if (val > 65535)
3178 {
3179 val = 65535;
3180 }
3181 data[i*2]=val&0xff;
3182 data[i*2 + 1]=(val >> 8)&0xff;
3183 }
3184 free(buckets);
3185 writeData(f, data, length * 2);
3186 free(data);
3187 } else
3188 {
3189 free(buckets);
3190 }
3191
3192 fclose(f);
3193 }
3194
3195 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
3196 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3197 {
3198 target_t *target = get_current_target(cmd_ctx);
3199 struct timeval timeout, now;
3200
3201 gettimeofday(&timeout, NULL);
3202 if (argc != 2)
3203 {
3204 return ERROR_COMMAND_SYNTAX_ERROR;
3205 }
3206 unsigned offset;
3207 int retval = parse_uint(args[0], &offset);
3208 if (ERROR_OK != retval)
3209 return retval;
3210
3211 timeval_add_time(&timeout, offset, 0);
3212
3213 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
3214
3215 static const int maxSample = 10000;
3216 uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
3217 if (samples == NULL)
3218 return ERROR_OK;
3219
3220 int numSamples = 0;
3221 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
3222 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
3223
3224 for (;;)
3225 {
3226 target_poll(target);
3227 if (target->state == TARGET_HALTED)
3228 {
3229 uint32_t t=*((uint32_t *)reg->value);
3230 samples[numSamples++]=t;
3231 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3232 target_poll(target);
3233 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
3234 } else if (target->state == TARGET_RUNNING)
3235 {
3236 /* We want to quickly sample the PC. */
3237 if ((retval = target_halt(target)) != ERROR_OK)
3238 {
3239 free(samples);
3240 return retval;
3241 }
3242 } else
3243 {
3244 command_print(cmd_ctx, "Target not halted or running");
3245 retval = ERROR_OK;
3246 break;
3247 }
3248 if (retval != ERROR_OK)
3249 {
3250 break;
3251 }
3252
3253 gettimeofday(&now, NULL);
3254 if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
3255 {
3256 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
3257 if ((retval = target_poll(target)) != ERROR_OK)
3258 {
3259 free(samples);
3260 return retval;
3261 }
3262 if (target->state == TARGET_HALTED)
3263 {
3264 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
3265 }
3266 if ((retval = target_poll(target)) != ERROR_OK)
3267 {
3268 free(samples);
3269 return retval;
3270 }
3271 writeGmon(samples, numSamples, args[1]);
3272 command_print(cmd_ctx, "Wrote %s", args[1]);
3273 break;
3274 }
3275 }
3276 free(samples);
3277
3278 return ERROR_OK;
3279 }
3280
3281 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
3282 {
3283 char *namebuf;
3284 Jim_Obj *nameObjPtr, *valObjPtr;
3285 int result;
3286
3287 namebuf = alloc_printf("%s(%d)", varname, idx);
3288 if (!namebuf)
3289 return JIM_ERR;
3290
3291 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3292 valObjPtr = Jim_NewIntObj(interp, val);
3293 if (!nameObjPtr || !valObjPtr)
3294 {
3295 free(namebuf);
3296 return JIM_ERR;
3297 }
3298
3299 Jim_IncrRefCount(nameObjPtr);
3300 Jim_IncrRefCount(valObjPtr);
3301 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
3302 Jim_DecrRefCount(interp, nameObjPtr);
3303 Jim_DecrRefCount(interp, valObjPtr);
3304 free(namebuf);
3305 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
3306 return result;
3307 }
3308
3309 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3310 {
3311 command_context_t *context;
3312 target_t *target;
3313
3314 context = Jim_GetAssocData(interp, "context");
3315 if (context == NULL)
3316 {
3317 LOG_ERROR("mem2array: no command context");
3318 return JIM_ERR;
3319 }
3320 target = get_current_target(context);
3321 if (target == NULL)
3322 {
3323 LOG_ERROR("mem2array: no current target");
3324 return JIM_ERR;
3325 }
3326
3327 return target_mem2array(interp, target, argc-1, argv + 1);
3328 }
3329
3330 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
3331 {
3332 long l;
3333 uint32_t width;
3334 int len;
3335 uint32_t addr;
3336 uint32_t count;
3337 uint32_t v;
3338 const char *varname;
3339 uint8_t buffer[4096];
3340 int n, e, retval;
3341 uint32_t i;
3342
3343 /* argv[1] = name of array to receive the data
3344 * argv[2] = desired width
3345 * argv[3] = memory address
3346 * argv[4] = count of times to read
3347 */
3348 if (argc != 4) {
3349 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3350 return JIM_ERR;
3351 }
3352 varname = Jim_GetString(argv[0], &len);
3353 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3354
3355 e = Jim_GetLong(interp, argv[1], &l);
3356 width = l;
3357 if (e != JIM_OK) {
3358 return e;
3359 }
3360
3361 e = Jim_GetLong(interp, argv[2], &l);
3362 addr = l;
3363 if (e != JIM_OK) {
3364 return e;
3365 }
3366 e = Jim_GetLong(interp, argv[3], &l);
3367 len = l;
3368 if (e != JIM_OK) {
3369 return e;
3370 }
3371 switch (width) {
3372 case 8:
3373 width = 1;
3374 break;
3375 case 16:
3376 width = 2;
3377 break;
3378 case 32:
3379 width = 4;
3380 break;
3381 default:
3382 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3383 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3384 return JIM_ERR;
3385 }
3386 if (len == 0) {
3387 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3388 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3389 return JIM_ERR;
3390 }
3391 if ((addr + (len * width)) < addr) {
3392 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3393 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3394 return JIM_ERR;
3395 }
3396 /* absurd transfer size? */
3397 if (len > 65536) {
3398 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3399 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3400 return JIM_ERR;
3401 }
3402
3403 if ((width == 1) ||
3404 ((width == 2) && ((addr & 1) == 0)) ||
3405 ((width == 4) && ((addr & 3) == 0))) {
3406 /* all is well */
3407 } else {
3408 char buf[100];
3409 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3410 sprintf(buf, "mem2array address: 0x%08" PRIx32 " is not aligned for %" PRId32 " byte reads",
3411 addr,
3412 width);
3413 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3414 return JIM_ERR;
3415 }
3416
3417 /* Transfer loop */
3418
3419 /* index counter */
3420 n = 0;
3421 /* assume ok */
3422 e = JIM_OK;
3423 while (len) {
3424 /* Slurp... in buffer size chunks */
3425
3426 count = len; /* in objects.. */
3427 if (count > (sizeof(buffer)/width)) {
3428 count = (sizeof(buffer)/width);
3429 }
3430
3431 retval = target_read_memory(target, addr, width, count, buffer);
3432 if (retval != ERROR_OK) {
3433 /* BOO !*/
3434 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed",
3435 (unsigned int)addr,
3436 (int)width,
3437 (int)count);
3438 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3439 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3440 e = JIM_ERR;
3441 len = 0;
3442 } else {
3443 v = 0; /* shut up gcc */
3444 for (i = 0 ;i < count ;i++, n++) {
3445 switch (width) {
3446 case 4:
3447 v = target_buffer_get_u32(target, &buffer[i*width]);
3448 break;
3449 case 2:
3450 v = target_buffer_get_u16(target, &buffer[i*width]);
3451 break;
3452 case 1:
3453 v = buffer[i] & 0x0ff;
3454 break;
3455 }
3456 new_int_array_element(interp, varname, n, v);
3457 }
3458 len -= count;
3459 }
3460 }
3461
3462 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3463
3464 return JIM_OK;
3465 }
3466
3467 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
3468 {
3469 char *namebuf;
3470 Jim_Obj *nameObjPtr, *valObjPtr;
3471 int result;
3472 long l;
3473
3474 namebuf = alloc_printf("%s(%d)", varname, idx);
3475 if (!namebuf)
3476 return JIM_ERR;
3477
3478 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3479 if (!nameObjPtr)
3480 {
3481 free(namebuf);
3482 return JIM_ERR;
3483 }
3484
3485 Jim_IncrRefCount(nameObjPtr);
3486 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3487 Jim_DecrRefCount(interp, nameObjPtr);
3488 free(namebuf);
3489 if (valObjPtr == NULL)
3490 return JIM_ERR;
3491
3492 result = Jim_GetLong(interp, valObjPtr, &l);
3493 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3494 *val = l;
3495 return result;
3496 }
3497
3498 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3499 {
3500 command_context_t *context;
3501 target_t *target;
3502
3503 context = Jim_GetAssocData(interp, "context");
3504 if (context == NULL) {
3505 LOG_ERROR("array2mem: no command context");
3506 return JIM_ERR;
3507 }
3508 target = get_current_target(context);
3509 if (target == NULL) {
3510 LOG_ERROR("array2mem: no current target");
3511 return JIM_ERR;
3512 }
3513
3514 return target_array2mem(interp,target, argc-1, argv + 1);
3515 }
3516 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
3517 {
3518 long l;
3519 uint32_t width;
3520 int len;
3521 uint32_t addr;
3522 uint32_t count;
3523 uint32_t v;
3524 const char *varname;
3525 uint8_t buffer[4096];
3526 int n, e, retval;
3527 uint32_t i;
3528
3529 /* argv[1] = name of array to get the data
3530 * argv[2] = desired width
3531 * argv[3] = memory address
3532 * argv[4] = count to write
3533 */
3534 if (argc != 4) {
3535 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3536 return JIM_ERR;
3537 }
3538 varname = Jim_GetString(argv[0], &len);
3539 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3540
3541 e = Jim_GetLong(interp, argv[1], &l);
3542 width = l;
3543 if (e != JIM_OK) {
3544 return e;
3545 }
3546
3547 e = Jim_GetLong(interp, argv[2], &l);
3548 addr = l;
3549 if (e != JIM_OK) {
3550 return e;
3551 }
3552 e = Jim_GetLong(interp, argv[3], &l);
3553 len = l;
3554 if (e != JIM_OK) {
3555 return e;
3556 }
3557 switch (width) {
3558 case 8:
3559 width = 1;
3560 break;
3561 case 16:
3562 width = 2;
3563 break;
3564 case 32:
3565 width = 4;
3566 break;
3567 default:
3568 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3569 Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
3570 return JIM_ERR;
3571 }
3572 if (len == 0) {
3573 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3574 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3575 return JIM_ERR;
3576 }
3577 if ((addr + (len * width)) < addr) {
3578 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3579 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3580 return JIM_ERR;
3581 }
3582 /* absurd transfer size? */
3583 if (len > 65536) {
3584 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3585 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3586 return JIM_ERR;
3587 }
3588
3589 if ((width == 1) ||
3590 ((width == 2) && ((addr & 1) == 0)) ||
3591 ((width == 4) && ((addr & 3) == 0))) {
3592 /* all is well */
3593 } else {
3594 char buf[100];
3595 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3596 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads",
3597 (unsigned int)addr,
3598 (int)width);
3599 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3600 return JIM_ERR;
3601 }
3602
3603 /* Transfer loop */
3604
3605 /* index counter */
3606 n = 0;
3607 /* assume ok */
3608 e = JIM_OK;
3609 while (len) {
3610 /* Slurp... in buffer size chunks */
3611
3612 count = len; /* in objects.. */
3613 if (count > (sizeof(buffer)/width)) {
3614 count = (sizeof(buffer)/width);
3615 }
3616
3617 v = 0; /* shut up gcc */
3618 for (i = 0 ;i < count ;i++, n++) {
3619 get_int_array_element(interp, varname, n, &v);
3620 switch (width) {
3621 case 4:
3622 target_buffer_set_u32(target, &buffer[i*width], v);
3623 break;
3624 case 2:
3625 target_buffer_set_u16(target, &buffer[i*width], v);
3626 break;
3627 case 1:
3628 buffer[i] = v & 0x0ff;
3629 break;
3630 }
3631 }
3632 len -= count;
3633
3634 retval = target_write_memory(target, addr, width, count, buffer);
3635 if (retval != ERROR_OK) {
3636 /* BOO !*/
3637 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed",
3638 (unsigned int)addr,
3639 (int)width,
3640 (int)count);
3641 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3642 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3643 e = JIM_ERR;
3644 len = 0;
3645 }
3646 }
3647
3648 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3649
3650 return JIM_OK;
3651 }
3652
3653 void target_all_handle_event(enum target_event e)
3654 {
3655 target_t *target;
3656
3657 LOG_DEBUG("**all*targets: event: %d, %s",
3658 (int)e,
3659 Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
3660
3661 target = all_targets;
3662 while (target) {
3663 target_handle_event(target, e);
3664 target = target->next;
3665 }
3666 }
3667
3668
3669 /* FIX? should we propagate errors here rather than printing them
3670 * and continuing?
3671 */
3672 void target_handle_event(target_t *target, enum target_event e)
3673 {
3674 target_event_action_t *teap;
3675
3676 for (teap = target->event_action; teap != NULL; teap = teap->next) {
3677 if (teap->event == e) {
3678 LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
3679 target->target_number,
3680 target->cmd_name,
3681 target_get_name(target),
3682 e,
3683 Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
3684 Jim_GetString(teap->body, NULL));
3685 if (Jim_EvalObj(interp, teap->body) != JIM_OK)
3686 {
3687 Jim_PrintErrorMessage(interp);
3688 }
3689 }
3690 }
3691 }
3692
3693 enum target_cfg_param {
3694 TCFG_TYPE,
3695 TCFG_EVENT,
3696 TCFG_WORK_AREA_VIRT,
3697 TCFG_WORK_AREA_PHYS,
3698 TCFG_WORK_AREA_SIZE,
3699 TCFG_WORK_AREA_BACKUP,
3700 TCFG_ENDIAN,
3701 TCFG_VARIANT,
3702 TCFG_CHAIN_POSITION,
3703 };
3704
3705 static Jim_Nvp nvp_config_opts[] = {
3706 { .name = "-type", .value = TCFG_TYPE },
3707 { .name = "-event", .value = TCFG_EVENT },
3708 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3709 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3710 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3711 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3712 { .name = "-endian" , .value = TCFG_ENDIAN },
3713 { .name = "-variant", .value = TCFG_VARIANT },
3714 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3715
3716 { .name = NULL, .value = -1 }
3717 };
3718
3719 static int target_configure(Jim_GetOptInfo *goi, target_t *target)
3720 {
3721 Jim_Nvp *n;
3722 Jim_Obj *o;
3723 jim_wide w;
3724 char *cp;
3725 int e;
3726
3727 /* parse config or cget options ... */
3728 while (goi->argc > 0) {
3729 Jim_SetEmptyResult(goi->interp);
3730 /* Jim_GetOpt_Debug(goi); */
3731
3732 if (target->type->target_jim_configure) {
3733 /* target defines a configure function */
3734 /* target gets first dibs on parameters */
3735 e = (*(target->type->target_jim_configure))(target, goi);
3736 if (e == JIM_OK) {
3737 /* more? */
3738 continue;
3739 }
3740 if (e == JIM_ERR) {
3741 /* An error */
3742 return e;
3743 }
3744 /* otherwise we 'continue' below */
3745 }
3746 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
3747 if (e != JIM_OK) {
3748 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
3749 return e;
3750 }
3751 switch (n->value) {
3752 case TCFG_TYPE:
3753 /* not setable */
3754 if (goi->isconfigure) {
3755 Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
3756 return JIM_ERR;
3757 } else {
3758 no_params:
3759 if (goi->argc != 0) {
3760 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
3761 return JIM_ERR;
3762 }
3763 }
3764 Jim_SetResultString(goi->interp, target_get_name(target), -1);
3765 /* loop for more */
3766 break;
3767 case TCFG_EVENT:
3768 if (goi->argc == 0) {
3769 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3770 return JIM_ERR;
3771 }
3772
3773 e = Jim_GetOpt_Nvp(goi, nvp_target_event, &n);
3774 if (e != JIM_OK) {
3775 Jim_GetOpt_NvpUnknown(goi, nvp_target_event, 1);
3776 return e;
3777 }
3778
3779 if (goi->isconfigure) {
3780 if (goi->argc != 1) {
3781 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3782 return JIM_ERR;
3783 }
3784 } else {
3785 if (goi->argc != 0) {
3786 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3787 return JIM_ERR;
3788 }
3789 }
3790
3791 {
3792 target_event_action_t *teap;
3793
3794 teap = target->event_action;
3795 /* replace existing? */
3796 while (teap) {
3797 if (teap->event == (enum target_event)n->value) {
3798 break;
3799 }
3800 teap = teap->next;
3801 }
3802
3803 if (goi->isconfigure) {
3804 bool replace = true;
3805 if (teap == NULL) {
3806 /* create new */
3807 teap = calloc(1, sizeof(*teap));
3808 replace = false;
3809 }
3810 teap->event = n->value;
3811 Jim_GetOpt_Obj(goi, &o);
3812 if (teap->body) {
3813 Jim_DecrRefCount(interp, teap->body);
3814 }
3815 teap->body = Jim_DuplicateObj(goi->interp, o);
3816 /*
3817 * FIXME:
3818 * Tcl/TK - "tk events" have a nice feature.
3819 * See the "BIND" command.
3820 * We should support that here.
3821 * You can specify %X and %Y in the event code.
3822 * The idea is: %T - target name.
3823 * The idea is: %N - target number
3824 * The idea is: %E - event name.
3825 */
3826 Jim_IncrRefCount(teap->body);
3827
3828 if (!replace)
3829 {
3830 /* add to head of event list */
3831 teap->next = target->event_action;
3832 target->event_action = teap;
3833 }
3834 Jim_SetEmptyResult(goi->interp);
3835 } else {
3836 /* get */
3837 if (teap == NULL) {
3838 Jim_SetEmptyResult(goi->interp);
3839 } else {
3840 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
3841 }
3842 }
3843 }
3844 /* loop for more */
3845 break;
3846
3847 case TCFG_WORK_AREA_VIRT:
3848 if (goi->isconfigure) {
3849 target_free_all_working_areas(target);
3850 e = Jim_GetOpt_Wide(goi, &w);
3851 if (e != JIM_OK) {
3852 return e;
3853 }
3854 target->working_area_virt = w;
3855 target->working_area_virt_spec = true;
3856 } else {
3857 if (goi->argc != 0) {
3858 goto no_params;
3859 }
3860 }
3861 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
3862 /* loop for more */
3863 break;
3864
3865 case TCFG_WORK_AREA_PHYS:
3866 if (goi->isconfigure) {
3867 target_free_all_working_areas(target);
3868 e = Jim_GetOpt_Wide(goi, &w);
3869 if (e != JIM_OK) {
3870 return e;
3871 }
3872 target->working_area_phys = w;
3873 target->working_area_phys_spec = true;
3874 } else {
3875 if (goi->argc != 0) {
3876 goto no_params;
3877 }
3878 }
3879 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
3880 /* loop for more */
3881 break;
3882
3883 case TCFG_WORK_AREA_SIZE:
3884 if (goi->isconfigure) {
3885 target_free_all_working_areas(target);
3886 e = Jim_GetOpt_Wide(goi, &w);
3887 if (e != JIM_OK) {
3888 return e;
3889 }
3890 target->working_area_size = w;
3891 } else {
3892 if (goi->argc != 0) {
3893 goto no_params;
3894 }
3895 }
3896 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->working_area_size));
3897 /* loop for more */
3898 break;
3899
3900 case TCFG_WORK_AREA_BACKUP:
3901 if (goi->isconfigure) {
3902 target_free_all_working_areas(target);
3903 e = Jim_GetOpt_Wide(goi, &w);
3904 if (e != JIM_OK) {
3905 return e;
3906 }
3907 /* make this exactly 1 or 0 */
3908 target->backup_working_area = (!!w);
3909 } else {
3910 if (goi->argc != 0) {
3911 goto no_params;
3912 }
3913 }
3914 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
3915 /* loop for more e*/
3916 break;
3917
3918 case TCFG_ENDIAN:
3919 if (goi->isconfigure) {
3920 e = Jim_GetOpt_Nvp(goi, nvp_target_endian, &n);
3921 if (e != JIM_OK) {
3922 Jim_GetOpt_NvpUnknown(goi, nvp_target_endian, 1);
3923 return e;
3924 }
3925 target->endianness = n->value;
3926 } else {
3927 if (goi->argc != 0) {
3928 goto no_params;
3929 }
3930 }
3931 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3932 if (n->name == NULL) {
3933 target->endianness = TARGET_LITTLE_ENDIAN;
3934 n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
3935 }
3936 Jim_SetResultString(goi->interp, n->name, -1);
3937 /* loop for more */
3938 break;
3939
3940 case TCFG_VARIANT:
3941 if (goi->isconfigure) {
3942 if (goi->argc < 1) {
3943 Jim_SetResult_sprintf(goi->interp,
3944 "%s ?STRING?",
3945 n->name);
3946 return JIM_ERR;
3947 }
3948 if (target->variant) {
3949 free((void *)(target->variant));
3950 }
3951 e = Jim_GetOpt_String(goi, &cp, NULL);
3952 target->variant = strdup(cp);
3953 } else {
3954 if (goi->argc != 0) {
3955 goto no_params;
3956 }
3957 }
3958 Jim_SetResultString(goi->interp, target->variant,-1);
3959 /* loop for more */
3960 break;
3961 case TCFG_CHAIN_POSITION:
3962 if (goi->isconfigure) {
3963 Jim_Obj *o;
3964 jtag_tap_t *tap;
3965 target_free_all_working_areas(target);
3966 e = Jim_GetOpt_Obj(goi, &o);
3967 if (e != JIM_OK) {
3968 return e;
3969 }
3970 tap = jtag_tap_by_jim_obj(goi->interp, o);
3971 if (tap == NULL) {
3972 return JIM_ERR;
3973 }
3974 /* make this exactly 1 or 0 */
3975 target->tap = tap;
3976 } else {
3977 if (goi->argc != 0) {
3978 goto no_params;
3979 }
3980 }
3981 Jim_SetResultString(interp, target->tap->dotted_name, -1);
3982 /* loop for more e*/
3983 break;
3984 }
3985 } /* while (goi->argc) */
3986
3987
3988 /* done - we return */
3989 return JIM_OK;
3990 }
3991
3992 /** this is the 'tcl' handler for the target specific command */
3993 static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3994 {
3995 Jim_GetOptInfo goi;
3996 jim_wide a,b,c;
3997 int x,y,z;
3998 uint8_t target_buf[32];
3999 Jim_Nvp *n;
4000 target_t *target;
4001 struct command_context_s *cmd_ctx;
4002 int e;
4003
4004 enum {
4005 TS_CMD_CONFIGURE,
4006 TS_CMD_CGET,
4007
4008 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
4009 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
4010 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
4011 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
4012 TS_CMD_EXAMINE,
4013 TS_CMD_POLL,
4014 TS_CMD_RESET,
4015 TS_CMD_HALT,
4016 TS_CMD_WAITSTATE,
4017 TS_CMD_EVENTLIST,
4018 TS_CMD_CURSTATE,
4019 TS_CMD_INVOKE_EVENT,
4020 };
4021
4022 static const Jim_Nvp target_options[] = {
4023 { .name = "configure", .value = TS_CMD_CONFIGURE },
4024 { .name = "cget", .value = TS_CMD_CGET },
4025 { .name = "mww", .value = TS_CMD_MWW },
4026 { .name = "mwh", .value = TS_CMD_MWH },
4027 { .name = "mwb", .value = TS_CMD_MWB },
4028 { .name = "mdw", .value = TS_CMD_MDW },
4029 { .name = "mdh", .value = TS_CMD_MDH },
4030 { .name = "mdb", .value = TS_CMD_MDB },
4031 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
4032 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
4033 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
4034 { .name = "curstate", .value = TS_CMD_CURSTATE },
4035
4036 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
4037 { .name = "arp_poll", .value = TS_CMD_POLL },
4038 { .name = "arp_reset", .value = TS_CMD_RESET },
4039 { .name = "arp_halt", .value = TS_CMD_HALT },
4040 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
4041 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
4042
4043 { .name = NULL, .value = -1 },
4044 };
4045
4046 /* go past the "command" */
4047 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
4048
4049 target = Jim_CmdPrivData(goi.interp);
4050 cmd_ctx = Jim_GetAssocData(goi.interp, "context");
4051
4052 /* commands here are in an NVP table */
4053 e = Jim_GetOpt_Nvp(&goi, target_options, &n);
4054 if (e != JIM_OK) {
4055 Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
4056 return e;
4057 }
4058 /* Assume blank result */
4059 Jim_SetEmptyResult(goi.interp);
4060
4061 switch (n->value) {
4062 case TS_CMD_CONFIGURE:
4063 if (goi.argc < 2) {
4064 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
4065 return JIM_ERR;
4066 }
4067 goi.isconfigure = 1;
4068 return target_configure(&goi, target);
4069 case TS_CMD_CGET:
4070 // some things take params
4071 if (goi.argc < 1) {
4072 Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
4073 return JIM_ERR;
4074 }
4075 goi.isconfigure = 0;
4076 return target_configure(&goi, target);
4077 break;
4078 case TS_CMD_MWW:
4079 case TS_CMD_MWH:
4080 case TS_CMD_MWB:
4081 /* argv[0] = cmd
4082 * argv[1] = address
4083 * argv[2] = data
4084 * argv[3] = optional count.
4085 */
4086
4087 if ((goi.argc == 2) || (goi.argc == 3)) {
4088 /* all is well */
4089 } else {
4090 mwx_error:
4091 Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
4092 return JIM_ERR;
4093 }
4094
4095 e = Jim_GetOpt_Wide(&goi, &a);
4096 if (e != JIM_OK) {
4097 goto mwx_error;
4098 }
4099
4100 e = Jim_GetOpt_Wide(&goi, &b);
4101 if (e != JIM_OK) {
4102 goto mwx_error;
4103 }
4104 if (goi.argc == 3) {
4105 e = Jim_GetOpt_Wide(&goi, &c);
4106 if (e != JIM_OK) {
4107 goto mwx_error;
4108 }
4109 } else {
4110 c = 1;
4111 }
4112
4113 switch (n->value) {
4114 case TS_CMD_MWW:
4115 target_buffer_set_u32(target, target_buf, b);
4116 b = 4;
4117 break;
4118 case TS_CMD_MWH:
4119 target_buffer_set_u16(target, target_buf, b);
4120 b = 2;
4121 break;
4122 case TS_CMD_MWB:
4123 target_buffer_set_u8(target, target_buf, b);
4124 b = 1;
4125 break;
4126 }
4127 for (x = 0 ; x < c ; x++) {
4128 e = target_write_memory(target, a, b, 1, target_buf);
4129 if (e != ERROR_OK) {
4130 Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
4131 return JIM_ERR;
4132 }
4133 /* b = width */
4134 a = a + b;
4135 }
4136 return JIM_OK;
4137 break;
4138
4139 /* display */
4140 case TS_CMD_MDW:
4141 case TS_CMD_MDH:
4142 case TS_CMD_MDB:
4143 /* argv[0] = command
4144 * argv[1] = address
4145 * argv[2] = optional count
4146 */
4147 if ((goi.argc == 2) || (goi.argc == 3)) {
4148 Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
4149 return JIM_ERR;
4150 }
4151 e = Jim_GetOpt_Wide(&goi, &a);
4152 if (e != JIM_OK) {
4153 return JIM_ERR;
4154 }
4155 if (goi.argc) {
4156 e = Jim_GetOpt_Wide(&goi, &c);
4157 if (e != JIM_OK) {
4158 return JIM_ERR;
4159 }
4160 } else {
4161 c = 1;
4162 }
4163 b = 1; /* shut up gcc */
4164 switch (n->value) {
4165 case TS_CMD_MDW:
4166 b = 4;
4167 break;
4168 case TS_CMD_MDH:
4169 b = 2;
4170 break;
4171 case TS_CMD_MDB:
4172 b = 1;
4173 break;
4174 }
4175
4176 /* convert to "bytes" */
4177 c = c * b;
4178 /* count is now in 'BYTES' */
4179 while (c > 0) {
4180 y = c;
4181 if (y > 16) {
4182 y = 16;
4183 }
4184 e = target_read_memory(target, a, b, y / b, target_buf);
4185 if (e != ERROR_OK) {
4186 Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
4187 return JIM_ERR;
4188 }
4189
4190 Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
4191 switch (b) {
4192 case 4:
4193 for (x = 0 ; (x < 16) && (x < y) ; x += 4) {
4194 z = target_buffer_get_u32(target, &(target_buf[ x * 4 ]));
4195 Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
4196 }
4197 for (; (x < 16) ; x += 4) {
4198 Jim_fprintf(interp, interp->cookie_stdout, " ");
4199 }
4200 break;
4201 case 2:
4202 for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
4203 z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
4204 Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
4205 }
4206 for (; (x < 16) ; x += 2) {
4207 Jim_fprintf(interp, interp->cookie_stdout, " ");
4208 }
4209 break;
4210 case 1:
4211 default:
4212 for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
4213 z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
4214 Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
4215 }
4216 for (; (x < 16) ; x += 1) {
4217 Jim_fprintf(interp, interp->cookie_stdout, " ");
4218 }
4219 break;
4220 }
4221 /* ascii-ify the bytes */
4222 for (x = 0 ; x < y ; x++) {
4223 if ((target_buf[x] >= 0x20) &&
4224 (target_buf[x] <= 0x7e)) {
4225 /* good */
4226 } else {
4227 /* smack it */
4228 target_buf[x] = '.';
4229 }
4230 }
4231 /* space pad */
4232 while (x < 16) {
4233 target_buf[x] = ' ';
4234 x++;
4235 }
4236 /* terminate */
4237 target_buf[16] = 0;
4238 /* print - with a newline */
4239 Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
4240 /* NEXT... */
4241 c -= 16;
4242 a += 16;
4243 }
4244 return JIM_OK;
4245 case TS_CMD_MEM2ARRAY:
4246 return target_mem2array(goi.interp, target, goi.argc, goi.argv);
4247 break;
4248 case TS_CMD_ARRAY2MEM:
4249 return target_array2mem(goi.interp, target, goi.argc, goi.argv);
4250 break;
4251 case TS_CMD_EXAMINE:
4252 if (goi.argc) {
4253 Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4254 return JIM_ERR;
4255 }
4256 if (!target->tap->enabled)
4257 goto err_tap_disabled;
4258 e = target->type->examine(target);
4259 if (e != ERROR_OK) {
4260 Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
4261 return JIM_ERR;
4262 }
4263 return JIM_OK;
4264 case TS_CMD_POLL:
4265 if (goi.argc) {
4266 Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
4267 return JIM_ERR;
4268 }
4269 if (!target->tap->enabled)
4270 goto err_tap_disabled;
4271 if (!(target_was_examined(target))) {
4272 e = ERROR_TARGET_NOT_EXAMINED;
4273 } else {
4274 e = target->type->poll(target);
4275 }
4276 if (e != ERROR_OK) {
4277 Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
4278 return JIM_ERR;
4279 } else {
4280 return JIM_OK;
4281 }
4282 break;
4283 case TS_CMD_RESET:
4284 if (goi.argc != 2) {
4285 Jim_WrongNumArgs(interp, 2, argv,
4286 "([tT]|[fF]|assert|deassert) BOOL");
4287 return JIM_ERR;
4288 }
4289 e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
4290 if (e != JIM_OK) {
4291 Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
4292 return e;
4293 }
4294 /* the halt or not param */
4295 e = Jim_GetOpt_Wide(&goi, &a);
4296 if (e != JIM_OK) {
4297 return e;
4298 }
4299 if (!target->tap->enabled)
4300 goto err_tap_disabled;
4301 if (!target->type->assert_reset
4302 || !target->type->deassert_reset) {
4303 Jim_SetResult_sprintf(interp,
4304 "No target-specific reset for %s",
4305 target->cmd_name);
4306 return JIM_ERR;
4307 }
4308 /* determine if we should halt or not. */
4309 target->reset_halt = !!a;
4310 /* When this happens - all workareas are invalid. */
4311 target_free_all_working_areas_restore(target, 0);
4312
4313 /* do the assert */
4314 if (n->value == NVP_ASSERT) {
4315 e = target->type->assert_reset(target);
4316 } else {
4317 e = target->type->deassert_reset(target);
4318 }
4319 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4320 case TS_CMD_HALT:
4321 if (goi.argc) {
4322 Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
4323 return JIM_ERR;
4324 }
4325 if (!target->tap->enabled)
4326 goto err_tap_disabled;
4327 e = target->type->halt(target);
4328 return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
4329 case TS_CMD_WAITSTATE:
4330 /* params: <name> statename timeoutmsecs */
4331 if (goi.argc != 2) {
4332 Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
4333 return JIM_ERR;
4334 }
4335 e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
4336 if (e != JIM_OK) {
4337 Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
4338 return e;
4339 }
4340 e = Jim_GetOpt_Wide(&goi, &a);
4341 if (e != JIM_OK) {
4342 return e;
4343 }
4344 if (!target->tap->enabled)
4345 goto err_tap_disabled;
4346 e = target_wait_state(target, n->value, a);
4347 if (e != ERROR_OK) {
4348 Jim_SetResult_sprintf(goi.interp,
4349 "target: %s wait %s fails (%d) %s",
4350 target->cmd_name,
4351 n->name,
4352 e, target_strerror_safe(e));
4353 return JIM_ERR;
4354 } else {
4355 return JIM_OK;
4356 }
4357 case TS_CMD_EVENTLIST:
4358 /* List for human, Events defined for this target.
4359 * scripts/programs should use 'name cget -event NAME'
4360 */
4361 {
4362 target_event_action_t *teap;
4363 teap = target->event_action;
4364 command_print(cmd_ctx, "Event actions for target (%d) %s\n",
4365 target->target_number,
4366 target->cmd_name);
4367 command_print(cmd_ctx, "%-25s | Body", "Event");
4368 command_print(cmd_ctx, "------------------------- | ----------------------------------------");
4369 while (teap) {
4370 command_print(cmd_ctx,
4371 "%-25s | %s",
4372 Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
4373 Jim_GetString(teap->body, NULL));
4374 teap = teap->next;
4375 }
4376 command_print(cmd_ctx, "***END***");
4377 return JIM_OK;
4378 }
4379 case TS_CMD_CURSTATE:
4380 if (goi.argc != 0) {
4381 Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
4382 return JIM_ERR;
4383 }
4384 Jim_SetResultString(goi.interp,
4385 target_state_name( target ),
4386 -1);
4387 return JIM_OK;
4388 case TS_CMD_INVOKE_EVENT:
4389 if (goi.argc != 1) {
4390 Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
4391 return JIM_ERR;
4392 }
4393 e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
4394 if (e != JIM_OK) {
4395 Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
4396 return e;
4397 }
4398 target_handle_event(target, n->value);
4399 return JIM_OK;
4400 }
4401 return JIM_ERR;
4402
4403 err_tap_disabled:
4404 Jim_SetResult_sprintf(interp, "[TAP is disabled]");
4405 return JIM_ERR;
4406 }
4407
4408 static int target_create(Jim_GetOptInfo *goi)
4409 {
4410 Jim_Obj *new_cmd;
4411 Jim_Cmd *cmd;
4412 const char *cp;
4413 char *cp2;
4414 int e;
4415 int x;
4416 target_t *target;
4417 struct command_context_s *cmd_ctx;
4418
4419 cmd_ctx = Jim_GetAssocData(goi->interp, "context");
4420 if (goi->argc < 3) {
4421 Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4422 return JIM_ERR;
4423 }
4424
4425 /* COMMAND */
4426 Jim_GetOpt_Obj(goi, &new_cmd);
4427 /* does this command exist? */
4428 cmd = Jim_GetCommand(goi->interp, new_cmd, JIM_ERRMSG);
4429 if (cmd) {
4430 cp = Jim_GetString(new_cmd, NULL);
4431 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
4432 return JIM_ERR;
4433 }
4434
4435 /* TYPE */
4436 e = Jim_GetOpt_String(goi, &cp2, NULL);
4437 cp = cp2;
4438 /* now does target type exist */
4439 for (x = 0 ; target_types[x] ; x++) {
4440 if (0 == strcmp(cp, target_types[x]->name)) {
4441 /* found */
4442 break;
4443 }
4444 }
4445 if (target_types[x] == NULL) {
4446 Jim_SetResult_sprintf(goi->interp, "Unknown target type %s, try one of ", cp);
4447 for (x = 0 ; target_types[x] ; x++) {
4448 if (target_types[x + 1]) {
4449 Jim_AppendStrings(goi->interp,
4450 Jim_GetResult(goi->interp),
4451 target_types[x]->name,
4452 ", ", NULL);
4453 } else {
4454 Jim_AppendStrings(goi->interp,
4455 Jim_GetResult(goi->interp),
4456 " or ",
4457 target_types[x]->name,NULL);
4458 }
4459 }
4460 return JIM_ERR;
4461 }
4462
4463 /* Create it */
4464 target = calloc(1,sizeof(target_t));
4465 /* set target number */
4466 target->target_number = new_target_number();
4467
4468 /* allocate memory for each unique target type */
4469 target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
4470
4471 memcpy(target->type, target_types[x], sizeof(target_type_t));
4472
4473 /* will be set by "-endian" */
4474 target->endianness = TARGET_ENDIAN_UNKNOWN;
4475
4476 target->working_area = 0x0;
4477 target->working_area_size = 0x0;
4478 target->working_areas = NULL;
4479 target->backup_working_area = 0;
4480
4481 target->state = TARGET_UNKNOWN;
4482 target->debug_reason = DBG_REASON_UNDEFINED;
4483 target->reg_cache = NULL;
4484 target->breakpoints = NULL;
4485 target->watchpoints = NULL;
4486 target->next = NULL;
4487 target->arch_info = NULL;
4488
4489 target->display = 1;
4490
4491 target->halt_issued = false;
4492
4493 /* initialize trace information */
4494 target->trace_info = malloc(sizeof(trace_t));
4495 target->trace_info->num_trace_points = 0;
4496 target->trace_info->trace_points_size = 0;
4497 target->trace_info->trace_points = NULL;
4498 target->trace_info->trace_history_size = 0;
4499 target->trace_info->trace_history = NULL;
4500 target->trace_info->trace_history_pos = 0;
4501 target->trace_info->trace_history_overflowed = 0;
4502
4503 target->dbgmsg = NULL;
4504 target->dbg_msg_enabled = 0;
4505
4506 target->endianness = TARGET_ENDIAN_UNKNOWN;
4507
4508 /* Do the rest as "configure" options */
4509 goi->isconfigure = 1;
4510 e = target_configure(goi, target);
4511
4512 if (target->tap == NULL)
4513 {
4514 Jim_SetResultString(interp, "-chain-position required when creating target", -1);
4515 e = JIM_ERR;
4516 }
4517
4518 if (e != JIM_OK) {
4519 free(target->type);
4520 free(target);
4521 return e;
4522 }
4523
4524 if (target->endianness == TARGET_ENDIAN_UNKNOWN) {
4525 /* default endian to little if not specified */
4526 target->endianness = TARGET_LITTLE_ENDIAN;
4527 }
4528
4529 /* incase variant is not set */
4530 if (!target->variant)
4531 target->variant = strdup("");
4532
4533 /* create the target specific commands */
4534 if (target->type->register_commands) {
4535 (*(target->type->register_commands))(cmd_ctx);
4536 }
4537 if (target->type->target_create) {
4538 (*(target->type->target_create))(target, goi->interp);
4539 }
4540
4541 /* append to end of list */
4542 {
4543 target_t **tpp;
4544 tpp = &(all_targets);
4545 while (*tpp) {
4546 tpp = &((*tpp)->next);
4547 }
4548 *tpp = target;
4549 }
4550
4551 cp = Jim_GetString(new_cmd, NULL);
4552 target->cmd_name = strdup(cp);
4553
4554 /* now - create the new target name command */
4555 e = Jim_CreateCommand(goi->interp,
4556 /* name */
4557 cp,
4558 tcl_target_func, /* C function */
4559 target, /* private data */
4560 NULL); /* no del proc */
4561
4562 return e;
4563 }
4564
4565 static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4566 {
4567 int x,r,e;
4568 jim_wide w;
4569 struct command_context_s *cmd_ctx;
4570 target_t *target;
4571 Jim_GetOptInfo goi;
4572 enum tcmd {
4573 /* TG = target generic */
4574 TG_CMD_CREATE,
4575 TG_CMD_TYPES,
4576 TG_CMD_NAMES,
4577 TG_CMD_CURRENT,
4578 TG_CMD_NUMBER,
4579 TG_CMD_COUNT,
4580 };
4581 const char *target_cmds[] = {
4582 "create", "types", "names", "current", "number",
4583 "count",
4584 NULL /* terminate */
4585 };
4586
4587 LOG_DEBUG("Target command params:");
4588 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
4589
4590 cmd_ctx = Jim_GetAssocData(interp, "context");
4591
4592 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
4593
4594 if (goi.argc == 0) {
4595 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
4596 return JIM_ERR;
4597 }
4598
4599 /* Jim_GetOpt_Debug(&goi); */
4600 r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
4601 if (r != JIM_OK) {
4602 return r;
4603 }
4604
4605 switch (x) {
4606 default:
4607 Jim_Panic(goi.interp,"Why am I here?");
4608 return JIM_ERR;
4609 case TG_CMD_CURRENT:
4610 if (goi.argc != 0) {
4611 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4612 return JIM_ERR;
4613 }
4614 Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
4615 return JIM_OK;
4616 case TG_CMD_TYPES:
4617 if (goi.argc != 0) {
4618 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4619 return JIM_ERR;
4620 }
4621 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4622 for (x = 0 ; target_types[x] ; x++) {
4623 Jim_ListAppendElement(goi.interp,
4624 Jim_GetResult(goi.interp),
4625 Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
4626 }
4627 return JIM_OK;
4628 case TG_CMD_NAMES:
4629 if (goi.argc != 0) {
4630 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
4631 return JIM_ERR;
4632 }
4633 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
4634 target = all_targets;
4635 while (target) {
4636 Jim_ListAppendElement(goi.interp,
4637 Jim_GetResult(goi.interp),
4638 Jim_NewStringObj(goi.interp, target->cmd_name, -1));
4639 target = target->next;
4640 }
4641 return JIM_OK;
4642 case TG_CMD_CREATE:
4643 if (goi.argc < 3) {
4644 Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name ... config options ...");
4645 return JIM_ERR;
4646 }
4647 return target_create(&goi);
4648 break;
4649 case TG_CMD_NUMBER:
4650 /* It's OK to remove this mechanism sometime after August 2010 or so */
4651 LOG_WARNING("don't use numbers as target identifiers; use names");
4652 if (goi.argc != 1) {
4653 Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
4654 return JIM_ERR;
4655 }
4656 e = Jim_GetOpt_Wide(&goi, &w);
4657 if (e != JIM_OK) {
4658 return JIM_ERR;
4659 }
4660 for (x = 0, target = all_targets; target; target = target->next, x++) {
4661 if (target->target_number == w)
4662 break;
4663 }
4664 if (target == NULL) {
4665 Jim_SetResult_sprintf(goi.interp,
4666 "Target: number %d does not exist", (int)(w));
4667 return JIM_ERR;
4668 }
4669 Jim_SetResultString(goi.interp, target->cmd_name, -1);
4670 return JIM_OK;
4671 case TG_CMD_COUNT:
4672 if (goi.argc != 0) {
4673 Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
4674 return JIM_ERR;
4675 }
4676 for (x = 0, target = all_targets; target; target = target->next, x++)
4677 continue;
4678 Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
4679 return JIM_OK;
4680 }
4681
4682 return JIM_ERR;
4683 }
4684
4685
4686 struct FastLoad
4687 {
4688 uint32_t address;
4689 uint8_t *data;
4690 int length;
4691
4692 };
4693
4694 static int fastload_num;
4695 static struct FastLoad *fastload;
4696
4697 static void free_fastload(void)
4698 {
4699 if (fastload != NULL)
4700 {
4701 int i;
4702 for (i = 0; i < fastload_num; i++)
4703 {
4704 if (fastload[i].data)
4705 free(fastload[i].data);
4706 }
4707 free(fastload);
4708 fastload = NULL;
4709 }
4710 }
4711
4712
4713
4714
4715 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4716 {
4717 uint8_t *buffer;
4718 uint32_t buf_cnt;
4719 uint32_t image_size;
4720 uint32_t min_address = 0;
4721 uint32_t max_address = 0xffffffff;
4722 int i;
4723
4724 image_t image;
4725
4726 duration_t duration;
4727 char *duration_text;
4728
4729 int retval = parse_load_image_command_args(args, argc,
4730 &image, &min_address, &max_address);
4731 if (ERROR_OK != retval)
4732 return retval;
4733
4734 duration_start_measure(&duration);
4735
4736 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
4737 {
4738 return ERROR_OK;
4739 }
4740
4741 image_size = 0x0;
4742 retval = ERROR_OK;
4743 fastload_num = image.num_sections;
4744 fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4745 if (fastload == NULL)
4746 {
4747 image_close(&image);
4748 return ERROR_FAIL;
4749 }
4750 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4751 for (i = 0; i < image.num_sections; i++)
4752 {
4753 buffer = malloc(image.sections[i].size);
4754 if (buffer == NULL)
4755 {
4756 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)",
4757 (int)(image.sections[i].size));
4758 break;
4759 }
4760
4761 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4762 {
4763 free(buffer);
4764 break;
4765 }
4766
4767 uint32_t offset = 0;
4768 uint32_t length = buf_cnt;
4769
4770
4771 /* DANGER!!! beware of unsigned comparision here!!! */
4772
4773 if ((image.sections[i].base_address + buf_cnt >= min_address)&&
4774 (image.sections[i].base_address < max_address))
4775 {
4776 if (image.sections[i].base_address < min_address)
4777 {
4778 /* clip addresses below */
4779 offset += min_address-image.sections[i].base_address;
4780 length -= offset;
4781 }
4782
4783 if (image.sections[i].base_address + buf_cnt > max_address)
4784 {
4785 length -= (image.sections[i].base_address + buf_cnt)-max_address;
4786 }
4787
4788 fastload[i].address = image.sections[i].base_address + offset;
4789 fastload[i].data = malloc(length);
4790 if (fastload[i].data == NULL)
4791 {
4792 free(buffer);
4793 break;
4794 }
4795 memcpy(fastload[i].data, buffer + offset, length);
4796 fastload[i].length = length;
4797
4798 image_size += length;
4799 command_print(cmd_ctx, "%u bytes written at address 0x%8.8x",
4800 (unsigned int)length,
4801 ((unsigned int)(image.sections[i].base_address + offset)));
4802 }
4803
4804 free(buffer);
4805 }
4806
4807 duration_stop_measure(&duration, &duration_text);
4808 if (retval == ERROR_OK)
4809 {
4810 command_print(cmd_ctx, "Loaded %u bytes in %s", (unsigned int)image_size, duration_text);
4811 command_print(cmd_ctx, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4812 }
4813 free(duration_text);
4814
4815 image_close(&image);
4816
4817 if (retval != ERROR_OK)
4818 {
4819 free_fastload();
4820 }
4821
4822 return retval;
4823 }
4824
4825 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4826 {
4827 if (argc > 0)
4828 return ERROR_COMMAND_SYNTAX_ERROR;
4829 if (fastload == NULL)
4830 {
4831 LOG_ERROR("No image in memory");
4832 return ERROR_FAIL;
4833 }
4834 int i;
4835 int ms = timeval_ms();
4836 int size = 0;
4837 int retval = ERROR_OK;
4838 for (i = 0; i < fastload_num;i++)
4839 {
4840 target_t *target = get_current_target(cmd_ctx);
4841 command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x",
4842 (unsigned int)(fastload[i].address),
4843 (unsigned int)(fastload[i].length));
4844 if (retval == ERROR_OK)
4845 {
4846 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
4847 }
4848 size += fastload[i].length;
4849 }
4850 int after = timeval_ms();
4851 command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
4852 return retval;
4853 }
4854
4855 static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
4856 {
4857 command_context_t *context;
4858 target_t *target;
4859 int retval;
4860
4861 context = Jim_GetAssocData(interp, "context");
4862 if (context == NULL) {
4863 LOG_ERROR("array2mem: no command context");
4864 return JIM_ERR;
4865 }
4866 target = get_current_target(context);
4867 if (target == NULL) {
4868 LOG_ERROR("array2mem: no current target");
4869 return JIM_ERR;
4870 }
4871
4872 if ((argc < 6) || (argc > 7))
4873 {
4874 return JIM_ERR;
4875 }
4876
4877 int cpnum;
4878 uint32_t op1;
4879 uint32_t op2;
4880 uint32_t CRn;
4881 uint32_t CRm;
4882 uint32_t value;
4883
4884 int e;
4885 long l;
4886 e = Jim_GetLong(interp, argv[1], &l);
4887 if (e != JIM_OK) {
4888 return e;
4889 }
4890 cpnum = l;
4891
4892 e = Jim_GetLong(interp, argv[2], &l);
4893 if (e != JIM_OK) {
4894 return e;
4895 }
4896 op1 = l;
4897
4898 e = Jim_GetLong(interp, argv[3], &l);
4899 if (e != JIM_OK) {
4900 return e;
4901 }
4902 CRn = l;
4903
4904 e = Jim_GetLong(interp, argv[4], &l);
4905 if (e != JIM_OK) {
4906 return e;
4907 }
4908 CRm = l;
4909
4910 e = Jim_GetLong(interp, argv[5], &l);
4911 if (e != JIM_OK) {
4912 return e;
4913 }
4914 op2 = l;
4915
4916 value = 0;
4917
4918 if (argc == 7)
4919 {
4920 e = Jim_GetLong(interp, argv[6], &l);
4921 if (e != JIM_OK) {
4922 return e;
4923 }
4924 value = l;
4925
4926 retval = target_mcr(target, cpnum, op1, op2, CRn, CRm, value);
4927 if (retval != ERROR_OK)
4928 return JIM_ERR;
4929 } else
4930 {
4931 retval = target_mrc(target, cpnum, op1, op2, CRn, CRm, &value);
4932 if (retval != ERROR_OK)
4933 return JIM_ERR;
4934
4935 Jim_SetResult(interp, Jim_NewIntObj(interp, value));
4936 }
4937
4938 return JIM_OK;
4939 }
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)