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