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

Linking to existing account procedure

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

SSH host keys fingerprints

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