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