Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
take #2: 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 (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2119 {
2120 return ERROR_OK;
2121 }
2122
2123 duration_start_measure(&duration);
2124
2125 while (size > 0)
2126 {
2127 u32 size_written;
2128 u32 this_run_size = (size > 560) ? 560 : size;
2129
2130 retval = target_read_buffer(target, address, this_run_size, buffer);
2131 if (retval != ERROR_OK)
2132 {
2133 break;
2134 }
2135
2136 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2137 if (retval != ERROR_OK)
2138 {
2139 break;
2140 }
2141
2142 size -= this_run_size;
2143 address += this_run_size;
2144 }
2145
2146 if((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2147 return retvaltemp;
2148
2149 if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2150 return retvaltemp;
2151
2152 if (retval==ERROR_OK)
2153 {
2154 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2155 free(duration_text);
2156 }
2157
2158 return retval;
2159 }
2160
2161 static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
2162 {
2163 u8 *buffer;
2164 u32 buf_cnt;
2165 u32 image_size;
2166 int i;
2167 int retval, retvaltemp;
2168 u32 checksum = 0;
2169 u32 mem_checksum = 0;
2170
2171 image_t image;
2172
2173 duration_t duration;
2174 char *duration_text;
2175
2176 target_t *target = get_current_target(cmd_ctx);
2177
2178 if (argc < 1)
2179 {
2180 return ERROR_COMMAND_SYNTAX_ERROR;
2181 }
2182
2183 if (!target)
2184 {
2185 LOG_ERROR("no target selected");
2186 return ERROR_FAIL;
2187 }
2188
2189 duration_start_measure(&duration);
2190
2191 if (argc >= 2)
2192 {
2193 image.base_address_set = 1;
2194 image.base_address = strtoul(args[1], NULL, 0);
2195 }
2196 else
2197 {
2198 image.base_address_set = 0;
2199 image.base_address = 0x0;
2200 }
2201
2202 image.start_address_set = 0;
2203
2204 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2205 {
2206 return retval;
2207 }
2208
2209 image_size = 0x0;
2210 retval=ERROR_OK;
2211 for (i = 0; i < image.num_sections; i++)
2212 {
2213 buffer = malloc(image.sections[i].size);
2214 if (buffer == NULL)
2215 {
2216 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2217 break;
2218 }
2219 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2220 {
2221 free(buffer);
2222 break;
2223 }
2224
2225 if (verify)
2226 {
2227 /* calculate checksum of image */
2228 image_calculate_checksum( buffer, buf_cnt, &checksum );
2229
2230 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2231 if( retval != ERROR_OK )
2232 {
2233 free(buffer);
2234 break;
2235 }
2236
2237 if( checksum != mem_checksum )
2238 {
2239 /* failed crc checksum, fall back to a binary compare */
2240 u8 *data;
2241
2242 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2243
2244 data = (u8*)malloc(buf_cnt);
2245
2246 /* Can we use 32bit word accesses? */
2247 int size = 1;
2248 int count = buf_cnt;
2249 if ((count % 4) == 0)
2250 {
2251 size *= 4;
2252 count /= 4;
2253 }
2254 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2255 if (retval == ERROR_OK)
2256 {
2257 u32 t;
2258 for (t = 0; t < buf_cnt; t++)
2259 {
2260 if (data[t] != buffer[t])
2261 {
2262 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]);
2263 free(data);
2264 free(buffer);
2265 retval=ERROR_FAIL;
2266 goto done;
2267 }
2268 if ((t%16384)==0)
2269 {
2270 keep_alive();
2271 }
2272 }
2273 }
2274
2275 free(data);
2276 }
2277 } else
2278 {
2279 command_print(cmd_ctx, "address 0x%08x length 0x%08x", image.sections[i].base_address, buf_cnt);
2280 }
2281
2282 free(buffer);
2283 image_size += buf_cnt;
2284 }
2285 done:
2286
2287 if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2288 {
2289 image_close(&image);
2290 return retvaltemp;
2291 }
2292
2293 if (retval==ERROR_OK)
2294 {
2295 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2296 }
2297 free(duration_text);
2298
2299 image_close(&image);
2300
2301 return retval;
2302 }
2303
2304 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2305 {
2306 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
2307 }
2308
2309 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2310 {
2311 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
2312 }
2313
2314 static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2315 {
2316 int retval;
2317 target_t *target = get_current_target(cmd_ctx);
2318
2319 if (argc == 0)
2320 {
2321 breakpoint_t *breakpoint = target->breakpoints;
2322
2323 while (breakpoint)
2324 {
2325 if (breakpoint->type == BKPT_SOFT)
2326 {
2327 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2328 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2329 free(buf);
2330 }
2331 else
2332 {
2333 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2334 }
2335 breakpoint = breakpoint->next;
2336 }
2337 }
2338 else if (argc >= 2)
2339 {
2340 int hw = BKPT_SOFT;
2341 u32 length = 0;
2342
2343 length = strtoul(args[1], NULL, 0);
2344
2345 if (argc >= 3)
2346 if (strcmp(args[2], "hw") == 0)
2347 hw = BKPT_HARD;
2348
2349 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2350 {
2351 LOG_ERROR("Failure setting breakpoints");
2352 }
2353 else
2354 {
2355 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2356 }
2357 }
2358 else
2359 {
2360 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2361 }
2362
2363 return ERROR_OK;
2364 }
2365
2366 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2367 {
2368 target_t *target = get_current_target(cmd_ctx);
2369
2370 if (argc > 0)
2371 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2372
2373 return ERROR_OK;
2374 }
2375
2376 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2377 {
2378 target_t *target = get_current_target(cmd_ctx);
2379 int retval;
2380
2381 if (argc == 0)
2382 {
2383 watchpoint_t *watchpoint = target->watchpoints;
2384
2385 while (watchpoint)
2386 {
2387 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);
2388 watchpoint = watchpoint->next;
2389 }
2390 }
2391 else if (argc >= 2)
2392 {
2393 enum watchpoint_rw type = WPT_ACCESS;
2394 u32 data_value = 0x0;
2395 u32 data_mask = 0xffffffff;
2396
2397 if (argc >= 3)
2398 {
2399 switch(args[2][0])
2400 {
2401 case 'r':
2402 type = WPT_READ;
2403 break;
2404 case 'w':
2405 type = WPT_WRITE;
2406 break;
2407 case 'a':
2408 type = WPT_ACCESS;
2409 break;
2410 default:
2411 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2412 return ERROR_OK;
2413 }
2414 }
2415 if (argc >= 4)
2416 {
2417 data_value = strtoul(args[3], NULL, 0);
2418 }
2419 if (argc >= 5)
2420 {
2421 data_mask = strtoul(args[4], NULL, 0);
2422 }
2423
2424 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2425 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2426 {
2427 LOG_ERROR("Failure setting breakpoints");
2428 }
2429 }
2430 else
2431 {
2432 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2433 }
2434
2435 return ERROR_OK;
2436 }
2437
2438 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2439 {
2440 target_t *target = get_current_target(cmd_ctx);
2441
2442 if (argc > 0)
2443 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2444
2445 return ERROR_OK;
2446 }
2447
2448 static int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2449 {
2450 int retval;
2451 target_t *target = get_current_target(cmd_ctx);
2452 u32 va;
2453 u32 pa;
2454
2455 if (argc != 1)
2456 {
2457 return ERROR_COMMAND_SYNTAX_ERROR;
2458 }
2459 va = strtoul(args[0], NULL, 0);
2460
2461 retval = target->type->virt2phys(target, va, &pa);
2462 if (retval == ERROR_OK)
2463 {
2464 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2465 }
2466 else
2467 {
2468 /* lower levels will have logged a detailed error which is
2469 * forwarded to telnet/GDB session.
2470 */
2471 }
2472 return retval;
2473 }
2474
2475 static void writeData(FILE *f, const void *data, size_t len)
2476 {
2477 size_t written = fwrite(data, len, 1, f);
2478 if (written != len)
2479 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
2480 }
2481
2482 static void writeLong(FILE *f, int l)
2483 {
2484 int i;
2485 for (i=0; i<4; i++)
2486 {
2487 char c=(l>>(i*8))&0xff;
2488 writeData(f, &c, 1);
2489 }
2490
2491 }
2492
2493 static void writeString(FILE *f, char *s)
2494 {
2495 writeData(f, s, strlen(s));
2496 }
2497
2498 /* Dump a gmon.out histogram file. */
2499 static void writeGmon(u32 *samples, u32 sampleNum, char *filename)
2500 {
2501 u32 i;
2502 FILE *f=fopen(filename, "w");
2503 if (f==NULL)
2504 return;
2505 writeString(f, "gmon");
2506 writeLong(f, 0x00000001); /* Version */
2507 writeLong(f, 0); /* padding */
2508 writeLong(f, 0); /* padding */
2509 writeLong(f, 0); /* padding */
2510
2511 u8 zero = 0; /* GMON_TAG_TIME_HIST */
2512 writeData(f, &zero, 1);
2513
2514 /* figure out bucket size */
2515 u32 min=samples[0];
2516 u32 max=samples[0];
2517 for (i=0; i<sampleNum; i++)
2518 {
2519 if (min>samples[i])
2520 {
2521 min=samples[i];
2522 }
2523 if (max<samples[i])
2524 {
2525 max=samples[i];
2526 }
2527 }
2528
2529 int addressSpace=(max-min+1);
2530
2531 static const u32 maxBuckets = 256 * 1024; /* maximum buckets. */
2532 u32 length = addressSpace;
2533 if (length > maxBuckets)
2534 {
2535 length=maxBuckets;
2536 }
2537 int *buckets=malloc(sizeof(int)*length);
2538 if (buckets==NULL)
2539 {
2540 fclose(f);
2541 return;
2542 }
2543 memset(buckets, 0, sizeof(int)*length);
2544 for (i=0; i<sampleNum;i++)
2545 {
2546 u32 address=samples[i];
2547 long long a=address-min;
2548 long long b=length-1;
2549 long long c=addressSpace-1;
2550 int index=(a*b)/c; /* danger!!!! int32 overflows */
2551 buckets[index]++;
2552 }
2553
2554 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2555 writeLong(f, min); /* low_pc */
2556 writeLong(f, max); /* high_pc */
2557 writeLong(f, length); /* # of samples */
2558 writeLong(f, 64000000); /* 64MHz */
2559 writeString(f, "seconds");
2560 for (i=0; i<(15-strlen("seconds")); i++)
2561 writeData(f, &zero, 1);
2562 writeString(f, "s");
2563
2564 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2565
2566 char *data=malloc(2*length);
2567 if (data!=NULL)
2568 {
2569 for (i=0; i<length;i++)
2570 {
2571 int val;
2572 val=buckets[i];
2573 if (val>65535)
2574 {
2575 val=65535;
2576 }
2577 data[i*2]=val&0xff;
2578 data[i*2+1]=(val>>8)&0xff;
2579 }
2580 free(buckets);
2581 writeData(f, data, length * 2);
2582 free(data);
2583 } else
2584 {
2585 free(buckets);
2586 }
2587
2588 fclose(f);
2589 }
2590
2591 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2592 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2593 {
2594 target_t *target = get_current_target(cmd_ctx);
2595 struct timeval timeout, now;
2596
2597 gettimeofday(&timeout, NULL);
2598 if (argc!=2)
2599 {
2600 return ERROR_COMMAND_SYNTAX_ERROR;
2601 }
2602 char *end;
2603 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2604 if (*end)
2605 {
2606 return ERROR_OK;
2607 }
2608
2609 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2610
2611 static const int maxSample=10000;
2612 u32 *samples=malloc(sizeof(u32)*maxSample);
2613 if (samples==NULL)
2614 return ERROR_OK;
2615
2616 int numSamples=0;
2617 int retval=ERROR_OK;
2618 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2619 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2620
2621 for (;;)
2622 {
2623 target_poll(target);
2624 if (target->state == TARGET_HALTED)
2625 {
2626 u32 t=*((u32 *)reg->value);
2627 samples[numSamples++]=t;
2628 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2629 target_poll(target);
2630 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2631 } else if (target->state == TARGET_RUNNING)
2632 {
2633 /* We want to quickly sample the PC. */
2634 if((retval = target_halt(target)) != ERROR_OK)
2635 {
2636 free(samples);
2637 return retval;
2638 }
2639 } else
2640 {
2641 command_print(cmd_ctx, "Target not halted or running");
2642 retval=ERROR_OK;
2643 break;
2644 }
2645 if (retval!=ERROR_OK)
2646 {
2647 break;
2648 }
2649
2650 gettimeofday(&now, NULL);
2651 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2652 {
2653 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2654 if((retval = target_poll(target)) != ERROR_OK)
2655 {
2656 free(samples);
2657 return retval;
2658 }
2659 if (target->state == TARGET_HALTED)
2660 {
2661 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2662 }
2663 if((retval = target_poll(target)) != ERROR_OK)
2664 {
2665 free(samples);
2666 return retval;
2667 }
2668 writeGmon(samples, numSamples, args[1]);
2669 command_print(cmd_ctx, "Wrote %s", args[1]);
2670 break;
2671 }
2672 }
2673 free(samples);
2674
2675 return ERROR_OK;
2676 }
2677
2678 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2679 {
2680 char *namebuf;
2681 Jim_Obj *nameObjPtr, *valObjPtr;
2682 int result;
2683
2684 namebuf = alloc_printf("%s(%d)", varname, idx);
2685 if (!namebuf)
2686 return JIM_ERR;
2687
2688 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2689 valObjPtr = Jim_NewIntObj(interp, val);
2690 if (!nameObjPtr || !valObjPtr)
2691 {
2692 free(namebuf);
2693 return JIM_ERR;
2694 }
2695
2696 Jim_IncrRefCount(nameObjPtr);
2697 Jim_IncrRefCount(valObjPtr);
2698 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2699 Jim_DecrRefCount(interp, nameObjPtr);
2700 Jim_DecrRefCount(interp, valObjPtr);
2701 free(namebuf);
2702 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2703 return result;
2704 }
2705
2706 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2707 {
2708 command_context_t *context;
2709 target_t *target;
2710
2711 context = Jim_GetAssocData(interp, "context");
2712 if (context == NULL)
2713 {
2714 LOG_ERROR("mem2array: no command context");
2715 return JIM_ERR;
2716 }
2717 target = get_current_target(context);
2718 if (target == NULL)
2719 {
2720 LOG_ERROR("mem2array: no current target");
2721 return JIM_ERR;
2722 }
2723
2724 return target_mem2array(interp, target, argc,argv);
2725 }
2726
2727 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
2728 {
2729 long l;
2730 u32 width;
2731 int len;
2732 u32 addr;
2733 u32 count;
2734 u32 v;
2735 const char *varname;
2736 u8 buffer[4096];
2737 int n, e, retval;
2738 u32 i;
2739
2740 /* argv[1] = name of array to receive the data
2741 * argv[2] = desired width
2742 * argv[3] = memory address
2743 * argv[4] = count of times to read
2744 */
2745 if (argc != 5) {
2746 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2747 return JIM_ERR;
2748 }
2749 varname = Jim_GetString(argv[1], &len);
2750 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2751
2752 e = Jim_GetLong(interp, argv[2], &l);
2753 width = l;
2754 if (e != JIM_OK) {
2755 return e;
2756 }
2757
2758 e = Jim_GetLong(interp, argv[3], &l);
2759 addr = l;
2760 if (e != JIM_OK) {
2761 return e;
2762 }
2763 e = Jim_GetLong(interp, argv[4], &l);
2764 len = l;
2765 if (e != JIM_OK) {
2766 return e;
2767 }
2768 switch (width) {
2769 case 8:
2770 width = 1;
2771 break;
2772 case 16:
2773 width = 2;
2774 break;
2775 case 32:
2776 width = 4;
2777 break;
2778 default:
2779 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2780 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2781 return JIM_ERR;
2782 }
2783 if (len == 0) {
2784 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2785 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2786 return JIM_ERR;
2787 }
2788 if ((addr + (len * width)) < addr) {
2789 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2790 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2791 return JIM_ERR;
2792 }
2793 /* absurd transfer size? */
2794 if (len > 65536) {
2795 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2796 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2797 return JIM_ERR;
2798 }
2799
2800 if ((width == 1) ||
2801 ((width == 2) && ((addr & 1) == 0)) ||
2802 ((width == 4) && ((addr & 3) == 0))) {
2803 /* all is well */
2804 } else {
2805 char buf[100];
2806 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2807 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2808 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2809 return JIM_ERR;
2810 }
2811
2812 /* Transfer loop */
2813
2814 /* index counter */
2815 n = 0;
2816 /* assume ok */
2817 e = JIM_OK;
2818 while (len) {
2819 /* Slurp... in buffer size chunks */
2820
2821 count = len; /* in objects.. */
2822 if (count > (sizeof(buffer)/width)) {
2823 count = (sizeof(buffer)/width);
2824 }
2825
2826 retval = target->type->read_memory( target, addr, width, count, buffer );
2827 if (retval != ERROR_OK) {
2828 /* BOO !*/
2829 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2830 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2831 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2832 e = JIM_ERR;
2833 len = 0;
2834 } else {
2835 v = 0; /* shut up gcc */
2836 for (i = 0 ;i < count ;i++, n++) {
2837 switch (width) {
2838 case 4:
2839 v = target_buffer_get_u32(target, &buffer[i*width]);
2840 break;
2841 case 2:
2842 v = target_buffer_get_u16(target, &buffer[i*width]);
2843 break;
2844 case 1:
2845 v = buffer[i] & 0x0ff;
2846 break;
2847 }
2848 new_int_array_element(interp, varname, n, v);
2849 }
2850 len -= count;
2851 }
2852 }
2853
2854 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2855
2856 return JIM_OK;
2857 }
2858
2859 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2860 {
2861 char *namebuf;
2862 Jim_Obj *nameObjPtr, *valObjPtr;
2863 int result;
2864 long l;
2865
2866 namebuf = alloc_printf("%s(%d)", varname, idx);
2867 if (!namebuf)
2868 return JIM_ERR;
2869
2870 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2871 if (!nameObjPtr)
2872 {
2873 free(namebuf);
2874 return JIM_ERR;
2875 }
2876
2877 Jim_IncrRefCount(nameObjPtr);
2878 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2879 Jim_DecrRefCount(interp, nameObjPtr);
2880 free(namebuf);
2881 if (valObjPtr == NULL)
2882 return JIM_ERR;
2883
2884 result = Jim_GetLong(interp, valObjPtr, &l);
2885 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2886 *val = l;
2887 return result;
2888 }
2889
2890 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2891 {
2892 command_context_t *context;
2893 target_t *target;
2894
2895 context = Jim_GetAssocData(interp, "context");
2896 if (context == NULL){
2897 LOG_ERROR("array2mem: no command context");
2898 return JIM_ERR;
2899 }
2900 target = get_current_target(context);
2901 if (target == NULL){
2902 LOG_ERROR("array2mem: no current target");
2903 return JIM_ERR;
2904 }
2905
2906 return target_array2mem( interp,target, argc, argv );
2907 }
2908
2909 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
2910 {
2911 long l;
2912 u32 width;
2913 int len;
2914 u32 addr;
2915 u32 count;
2916 u32 v;
2917 const char *varname;
2918 u8 buffer[4096];
2919 int n, e, retval;
2920 u32 i;
2921
2922 /* argv[1] = name of array to get the data
2923 * argv[2] = desired width
2924 * argv[3] = memory address
2925 * argv[4] = count to write
2926 */
2927 if (argc != 5) {
2928 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2929 return JIM_ERR;
2930 }
2931 varname = Jim_GetString(argv[1], &len);
2932 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2933
2934 e = Jim_GetLong(interp, argv[2], &l);
2935 width = l;
2936 if (e != JIM_OK) {
2937 return e;
2938 }
2939
2940 e = Jim_GetLong(interp, argv[3], &l);
2941 addr = l;
2942 if (e != JIM_OK) {
2943 return e;
2944 }
2945 e = Jim_GetLong(interp, argv[4], &l);
2946 len = l;
2947 if (e != JIM_OK) {
2948 return e;
2949 }
2950 switch (width) {
2951 case 8:
2952 width = 1;
2953 break;
2954 case 16:
2955 width = 2;
2956 break;
2957 case 32:
2958 width = 4;
2959 break;
2960 default:
2961 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2962 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2963 return JIM_ERR;
2964 }
2965 if (len == 0) {
2966 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2967 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2968 return JIM_ERR;
2969 }
2970 if ((addr + (len * width)) < addr) {
2971 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2972 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2973 return JIM_ERR;
2974 }
2975 /* absurd transfer size? */
2976 if (len > 65536) {
2977 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2978 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2979 return JIM_ERR;
2980 }
2981
2982 if ((width == 1) ||
2983 ((width == 2) && ((addr & 1) == 0)) ||
2984 ((width == 4) && ((addr & 3) == 0))) {
2985 /* all is well */
2986 } else {
2987 char buf[100];
2988 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2989 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2990 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2991 return JIM_ERR;
2992 }
2993
2994 /* Transfer loop */
2995
2996 /* index counter */
2997 n = 0;
2998 /* assume ok */
2999 e = JIM_OK;
3000 while (len) {
3001 /* Slurp... in buffer size chunks */
3002
3003 count = len; /* in objects.. */
3004 if (count > (sizeof(buffer)/width)) {
3005 count = (sizeof(buffer)/width);
3006 }
3007
3008 v = 0; /* shut up gcc */
3009 for (i = 0 ;i < count ;i++, n++) {
3010 get_int_array_element(interp, varname, n, &v);
3011 switch (width) {
3012 case 4:
3013 target_buffer_set_u32(target, &buffer[i*width], v);
3014 break;
3015 case 2:
3016 target_buffer_set_u16(target, &buffer[i*width], v);
3017 break;
3018 case 1:
3019 buffer[i] = v & 0x0ff;
3020 break;
3021 }
3022 }
3023 len -= count;
3024
3025 retval = target->type->write_memory(target, addr, width, count, buffer);
3026 if (retval != ERROR_OK) {
3027 /* BOO !*/
3028 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
3029 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3030 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3031 e = JIM_ERR;
3032 len = 0;
3033 }
3034 }
3035
3036 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3037
3038 return JIM_OK;
3039 }
3040
3041 void target_all_handle_event( enum target_event e )
3042 {
3043 target_t *target;
3044
3045 LOG_DEBUG( "**all*targets: event: %d, %s",
3046 e,
3047 Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3048
3049 target = all_targets;
3050 while (target){
3051 target_handle_event( target, e );
3052 target = target->next;
3053 }
3054 }
3055
3056 void target_handle_event( target_t *target, enum target_event e )
3057 {
3058 target_event_action_t *teap;
3059 int done;
3060
3061 teap = target->event_action;
3062
3063 done = 0;
3064 while( teap ){
3065 if( teap->event == e ){
3066 done = 1;
3067 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3068 target->target_number,
3069 target->cmd_name,
3070 target->type->name,
3071 e,
3072 Jim_Nvp_value2name_simple( nvp_target_event, e )->name,
3073 Jim_GetString( teap->body, NULL ) );
3074 if (Jim_EvalObj( interp, teap->body )!=JIM_OK)
3075 {
3076 Jim_PrintErrorMessage(interp);
3077 }
3078 }
3079 teap = teap->next;
3080 }
3081 if( !done ){
3082 LOG_DEBUG( "event: %d %s - no action",
3083 e,
3084 Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3085 }
3086 }
3087
3088 enum target_cfg_param {
3089 TCFG_TYPE,
3090 TCFG_EVENT,
3091 TCFG_WORK_AREA_VIRT,
3092 TCFG_WORK_AREA_PHYS,
3093 TCFG_WORK_AREA_SIZE,
3094 TCFG_WORK_AREA_BACKUP,
3095 TCFG_ENDIAN,
3096 TCFG_VARIANT,
3097 TCFG_CHAIN_POSITION,
3098 };
3099
3100 static Jim_Nvp nvp_config_opts[] = {
3101 { .name = "-type", .value = TCFG_TYPE },
3102 { .name = "-event", .value = TCFG_EVENT },
3103 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3104 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3105 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3106 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3107 { .name = "-endian" , .value = TCFG_ENDIAN },
3108 { .name = "-variant", .value = TCFG_VARIANT },
3109 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3110
3111 { .name = NULL, .value = -1 }
3112 };
3113
3114 static int target_configure( Jim_GetOptInfo *goi, target_t *target )
3115 {
3116 Jim_Nvp *n;
3117 Jim_Obj *o;
3118 jim_wide w;
3119 char *cp;
3120 int e;
3121
3122 /* parse config or cget options ... */
3123 while( goi->argc > 0 ){
3124 Jim_SetEmptyResult( goi->interp );
3125 /* Jim_GetOpt_Debug( goi ); */
3126
3127 if( target->type->target_jim_configure ){
3128 /* target defines a configure function */
3129 /* target gets first dibs on parameters */
3130 e = (*(target->type->target_jim_configure))( target, goi );
3131 if( e == JIM_OK ){
3132 /* more? */
3133 continue;
3134 }
3135 if( e == JIM_ERR ){
3136 /* An error */
3137 return e;
3138 }
3139 /* otherwise we 'continue' below */
3140 }
3141 e = Jim_GetOpt_Nvp( goi, nvp_config_opts, &n );
3142 if( e != JIM_OK ){
3143 Jim_GetOpt_NvpUnknown( goi, nvp_config_opts, 0 );
3144 return e;
3145 }
3146 switch( n->value ){
3147 case TCFG_TYPE:
3148 /* not setable */
3149 if( goi->isconfigure ){
3150 Jim_SetResult_sprintf( goi->interp, "not setable: %s", n->name );
3151 return JIM_ERR;
3152 } else {
3153 no_params:
3154 if( goi->argc != 0 ){
3155 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "NO PARAMS");
3156 return JIM_ERR;
3157 }
3158 }
3159 Jim_SetResultString( goi->interp, target->type->name, -1 );
3160 /* loop for more */
3161 break;
3162 case TCFG_EVENT:
3163 if( goi->argc == 0 ){
3164 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3165 return JIM_ERR;
3166 }
3167
3168 e = Jim_GetOpt_Nvp( goi, nvp_target_event, &n );
3169 if( e != JIM_OK ){
3170 Jim_GetOpt_NvpUnknown( goi, nvp_target_event, 1 );
3171 return e;
3172 }
3173
3174 if( goi->isconfigure ){
3175 if( goi->argc != 1 ){
3176 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3177 return JIM_ERR;
3178 }
3179 } else {
3180 if( goi->argc != 0 ){
3181 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3182 return JIM_ERR;
3183 }
3184 }
3185
3186 {
3187 target_event_action_t *teap;
3188
3189 teap = target->event_action;
3190 /* replace existing? */
3191 while( teap ){
3192 if( teap->event == (enum target_event)n->value ){
3193 break;
3194 }
3195 teap = teap->next;
3196 }
3197
3198 if( goi->isconfigure ){
3199 if( teap == NULL ){
3200 /* create new */
3201 teap = calloc( 1, sizeof(*teap) );
3202 }
3203 teap->event = n->value;
3204 Jim_GetOpt_Obj( goi, &o );
3205 if( teap->body ){
3206 Jim_DecrRefCount( interp, teap->body );
3207 }
3208 teap->body = Jim_DuplicateObj( goi->interp, o );
3209 /*
3210 * FIXME:
3211 * Tcl/TK - "tk events" have a nice feature.
3212 * See the "BIND" command.
3213 * We should support that here.
3214 * You can specify %X and %Y in the event code.
3215 * The idea is: %T - target name.
3216 * The idea is: %N - target number
3217 * The idea is: %E - event name.
3218 */
3219 Jim_IncrRefCount( teap->body );
3220
3221 /* add to head of event list */
3222 teap->next = target->event_action;
3223 target->event_action = teap;
3224 Jim_SetEmptyResult(goi->interp);
3225 } else {
3226 /* get */
3227 if( teap == NULL ){
3228 Jim_SetEmptyResult( goi->interp );
3229 } else {
3230 Jim_SetResult( goi->interp, Jim_DuplicateObj( goi->interp, teap->body ) );
3231 }
3232 }
3233 }
3234 /* loop for more */
3235 break;
3236
3237 case TCFG_WORK_AREA_VIRT:
3238 if( goi->isconfigure ){
3239 target_free_all_working_areas(target);
3240 e = Jim_GetOpt_Wide( goi, &w );
3241 if( e != JIM_OK ){
3242 return e;
3243 }
3244 target->working_area_virt = w;
3245 } else {
3246 if( goi->argc != 0 ){
3247 goto no_params;
3248 }
3249 }
3250 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_virt ) );
3251 /* loop for more */
3252 break;
3253
3254 case TCFG_WORK_AREA_PHYS:
3255 if( goi->isconfigure ){
3256 target_free_all_working_areas(target);
3257 e = Jim_GetOpt_Wide( goi, &w );
3258 if( e != JIM_OK ){
3259 return e;
3260 }
3261 target->working_area_phys = w;
3262 } else {
3263 if( goi->argc != 0 ){
3264 goto no_params;
3265 }
3266 }
3267 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_phys ) );
3268 /* loop for more */
3269 break;
3270
3271 case TCFG_WORK_AREA_SIZE:
3272 if( goi->isconfigure ){
3273 target_free_all_working_areas(target);
3274 e = Jim_GetOpt_Wide( goi, &w );
3275 if( e != JIM_OK ){
3276 return e;
3277 }
3278 target->working_area_size = w;
3279 } else {
3280 if( goi->argc != 0 ){
3281 goto no_params;
3282 }
3283 }
3284 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
3285 /* loop for more */
3286 break;
3287
3288 case TCFG_WORK_AREA_BACKUP:
3289 if( goi->isconfigure ){
3290 target_free_all_working_areas(target);
3291 e = Jim_GetOpt_Wide( goi, &w );
3292 if( e != JIM_OK ){
3293 return e;
3294 }
3295 /* make this exactly 1 or 0 */
3296 target->backup_working_area = (!!w);
3297 } else {
3298 if( goi->argc != 0 ){
3299 goto no_params;
3300 }
3301 }
3302 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
3303 /* loop for more e*/
3304 break;
3305
3306 case TCFG_ENDIAN:
3307 if( goi->isconfigure ){
3308 e = Jim_GetOpt_Nvp( goi, nvp_target_endian, &n );
3309 if( e != JIM_OK ){
3310 Jim_GetOpt_NvpUnknown( goi, nvp_target_endian, 1 );
3311 return e;
3312 }
3313 target->endianness = n->value;
3314 } else {
3315 if( goi->argc != 0 ){
3316 goto no_params;
3317 }
3318 }
3319 n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3320 if( n->name == NULL ){
3321 target->endianness = TARGET_LITTLE_ENDIAN;
3322 n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3323 }
3324 Jim_SetResultString( goi->interp, n->name, -1 );
3325 /* loop for more */
3326 break;
3327
3328 case TCFG_VARIANT:
3329 if( goi->isconfigure ){
3330 if( goi->argc < 1 ){
3331 Jim_SetResult_sprintf( goi->interp,
3332 "%s ?STRING?",
3333 n->name );
3334 return JIM_ERR;
3335 }
3336 if( target->variant ){
3337 free((void *)(target->variant));
3338 }
3339 e = Jim_GetOpt_String( goi, &cp, NULL );
3340 target->variant = strdup(cp);
3341 } else {
3342 if( goi->argc != 0 ){
3343 goto no_params;
3344 }
3345 }
3346 Jim_SetResultString( goi->interp, target->variant,-1 );
3347 /* loop for more */
3348 break;
3349 case TCFG_CHAIN_POSITION:
3350 if( goi->isconfigure ){
3351 Jim_Obj *o;
3352 jtag_tap_t *tap;
3353 target_free_all_working_areas(target);
3354 e = Jim_GetOpt_Obj( goi, &o );
3355 if( e != JIM_OK ){
3356 return e;
3357 }
3358 tap = jtag_TapByJimObj( goi->interp, o );
3359 if( tap == NULL ){
3360 return JIM_ERR;
3361 }
3362 /* make this exactly 1 or 0 */
3363 target->tap = tap;
3364 } else {
3365 if( goi->argc != 0 ){
3366 goto no_params;
3367 }
3368 }
3369 Jim_SetResultString( interp, target->tap->dotted_name, -1 );
3370 /* loop for more e*/
3371 break;
3372 }
3373 } /* while( goi->argc ) */
3374
3375
3376 /* done - we return */
3377 return JIM_OK;
3378 }
3379
3380 /** this is the 'tcl' handler for the target specific command */
3381 static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
3382 {
3383 Jim_GetOptInfo goi;
3384 jim_wide a,b,c;
3385 int x,y,z;
3386 u8 target_buf[32];
3387 Jim_Nvp *n;
3388 target_t *target;
3389 struct command_context_s *cmd_ctx;
3390 int e;
3391
3392 enum {
3393 TS_CMD_CONFIGURE,
3394 TS_CMD_CGET,
3395
3396 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3397 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3398 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3399 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3400 TS_CMD_EXAMINE,
3401 TS_CMD_POLL,
3402 TS_CMD_RESET,
3403 TS_CMD_HALT,
3404 TS_CMD_WAITSTATE,
3405 TS_CMD_EVENTLIST,
3406 TS_CMD_CURSTATE,
3407 TS_CMD_INVOKE_EVENT,
3408 };
3409
3410 static const Jim_Nvp target_options[] = {
3411 { .name = "configure", .value = TS_CMD_CONFIGURE },
3412 { .name = "cget", .value = TS_CMD_CGET },
3413 { .name = "mww", .value = TS_CMD_MWW },
3414 { .name = "mwh", .value = TS_CMD_MWH },
3415 { .name = "mwb", .value = TS_CMD_MWB },
3416 { .name = "mdw", .value = TS_CMD_MDW },
3417 { .name = "mdh", .value = TS_CMD_MDH },
3418 { .name = "mdb", .value = TS_CMD_MDB },
3419 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3420 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3421 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3422 { .name = "curstate", .value = TS_CMD_CURSTATE },
3423
3424 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3425 { .name = "arp_poll", .value = TS_CMD_POLL },
3426 { .name = "arp_reset", .value = TS_CMD_RESET },
3427 { .name = "arp_halt", .value = TS_CMD_HALT },
3428 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3429 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3430
3431 { .name = NULL, .value = -1 },
3432 };
3433
3434 /* go past the "command" */
3435 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3436
3437 target = Jim_CmdPrivData( goi.interp );
3438 cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3439
3440 /* commands here are in an NVP table */
3441 e = Jim_GetOpt_Nvp( &goi, target_options, &n );
3442 if( e != JIM_OK ){
3443 Jim_GetOpt_NvpUnknown( &goi, target_options, 0 );
3444 return e;
3445 }
3446 /* Assume blank result */
3447 Jim_SetEmptyResult( goi.interp );
3448
3449 switch( n->value ){
3450 case TS_CMD_CONFIGURE:
3451 if( goi.argc < 2 ){
3452 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3453 return JIM_ERR;
3454 }
3455 goi.isconfigure = 1;
3456 return target_configure( &goi, target );
3457 case TS_CMD_CGET:
3458 // some things take params
3459 if( goi.argc < 1 ){
3460 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "missing: ?-option?");
3461 return JIM_ERR;
3462 }
3463 goi.isconfigure = 0;
3464 return target_configure( &goi, target );
3465 break;
3466 case TS_CMD_MWW:
3467 case TS_CMD_MWH:
3468 case TS_CMD_MWB:
3469 /* argv[0] = cmd
3470 * argv[1] = address
3471 * argv[2] = data
3472 * argv[3] = optional count.
3473 */
3474
3475 if( (goi.argc == 3) || (goi.argc == 4) ){
3476 /* all is well */
3477 } else {
3478 mwx_error:
3479 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR DATA [COUNT]", n->name );
3480 return JIM_ERR;
3481 }
3482
3483 e = Jim_GetOpt_Wide( &goi, &a );
3484 if( e != JIM_OK ){
3485 goto mwx_error;
3486 }
3487
3488 e = Jim_GetOpt_Wide( &goi, &b );
3489 if( e != JIM_OK ){
3490 goto mwx_error;
3491 }
3492 if( goi.argc ){
3493 e = Jim_GetOpt_Wide( &goi, &c );
3494 if( e != JIM_OK ){
3495 goto mwx_error;
3496 }
3497 } else {
3498 c = 1;
3499 }
3500
3501 switch( n->value ){
3502 case TS_CMD_MWW:
3503 target_buffer_set_u32( target, target_buf, b );
3504 b = 4;
3505 break;
3506 case TS_CMD_MWH:
3507 target_buffer_set_u16( target, target_buf, b );
3508 b = 2;
3509 break;
3510 case TS_CMD_MWB:
3511 target_buffer_set_u8( target, target_buf, b );
3512 b = 1;
3513 break;
3514 }
3515 for( x = 0 ; x < c ; x++ ){
3516 e = target->type->write_memory( target, a, b, 1, target_buf );
3517 if( e != ERROR_OK ){
3518 Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
3519 return JIM_ERR;
3520 }
3521 /* b = width */
3522 a = a + b;
3523 }
3524 return JIM_OK;
3525 break;
3526
3527 /* display */
3528 case TS_CMD_MDW:
3529 case TS_CMD_MDH:
3530 case TS_CMD_MDB:
3531 /* argv[0] = command
3532 * argv[1] = address
3533 * argv[2] = optional count
3534 */
3535 if( (goi.argc == 2) || (goi.argc == 3) ){
3536 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR [COUNT]", n->name );
3537 return JIM_ERR;
3538 }
3539 e = Jim_GetOpt_Wide( &goi, &a );
3540 if( e != JIM_OK ){
3541 return JIM_ERR;
3542 }
3543 if( goi.argc ){
3544 e = Jim_GetOpt_Wide( &goi, &c );
3545 if( e != JIM_OK ){
3546 return JIM_ERR;
3547 }
3548 } else {
3549 c = 1;
3550 }
3551 b = 1; /* shut up gcc */
3552 switch( n->value ){
3553 case TS_CMD_MDW:
3554 b = 4;
3555 break;
3556 case TS_CMD_MDH:
3557 b = 2;
3558 break;
3559 case TS_CMD_MDB:
3560 b = 1;
3561 break;
3562 }
3563
3564 /* convert to "bytes" */
3565 c = c * b;
3566 /* count is now in 'BYTES' */
3567 while( c > 0 ){
3568 y = c;
3569 if( y > 16 ){
3570 y = 16;
3571 }
3572 e = target->type->read_memory( target, a, b, y / b, target_buf );
3573 if( e != ERROR_OK ){
3574 Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
3575 return JIM_ERR;
3576 }
3577
3578 Jim_fprintf( interp, interp->cookie_stdout, "0x%08x ", (int)(a) );
3579 switch( b ){
3580 case 4:
3581 for( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
3582 z = target_buffer_get_u32( target, &(target_buf[ x * 4 ]) );
3583 Jim_fprintf( interp, interp->cookie_stdout, "%08x ", (int)(z) );
3584 }
3585 for( ; (x < 16) ; x += 4 ){
3586 Jim_fprintf( interp, interp->cookie_stdout, " " );
3587 }
3588 break;
3589 case 2:
3590 for( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
3591 z = target_buffer_get_u16( target, &(target_buf[ x * 2 ]) );
3592 Jim_fprintf( interp, interp->cookie_stdout, "%04x ", (int)(z) );
3593 }
3594 for( ; (x < 16) ; x += 2 ){
3595 Jim_fprintf( interp, interp->cookie_stdout, " " );
3596 }
3597 break;
3598 case 1:
3599 default:
3600 for( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
3601 z = target_buffer_get_u8( target, &(target_buf[ x * 4 ]) );
3602 Jim_fprintf( interp, interp->cookie_stdout, "%02x ", (int)(z) );
3603 }
3604 for( ; (x < 16) ; x += 1 ){
3605 Jim_fprintf( interp, interp->cookie_stdout, " " );
3606 }
3607 break;
3608 }
3609 /* ascii-ify the bytes */
3610 for( x = 0 ; x < y ; x++ ){
3611 if( (target_buf[x] >= 0x20) &&
3612 (target_buf[x] <= 0x7e) ){
3613 /* good */
3614 } else {
3615 /* smack it */
3616 target_buf[x] = '.';
3617 }
3618 }
3619 /* space pad */
3620 while( x < 16 ){
3621 target_buf[x] = ' ';
3622 x++;
3623 }
3624 /* terminate */
3625 target_buf[16] = 0;
3626 /* print - with a newline */
3627 Jim_fprintf( interp, interp->cookie_stdout, "%s\n", target_buf );
3628 /* NEXT... */
3629 c -= 16;
3630 a += 16;
3631 }
3632 return JIM_OK;
3633 case TS_CMD_MEM2ARRAY:
3634 return target_mem2array( goi.interp, target, goi.argc, goi.argv );
3635 break;
3636 case TS_CMD_ARRAY2MEM:
3637 return target_array2mem( goi.interp, target, goi.argc, goi.argv );
3638 break;
3639 case TS_CMD_EXAMINE:
3640 if( goi.argc ){
3641 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3642 return JIM_ERR;
3643 }
3644 e = target->type->examine( target );
3645 if( e != ERROR_OK ){
3646 Jim_SetResult_sprintf( interp, "examine-fails: %d", e );
3647 return JIM_ERR;
3648 }
3649 return JIM_OK;
3650 case TS_CMD_POLL:
3651 if( goi.argc ){
3652 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3653 return JIM_ERR;
3654 }
3655 if( !(target->type->examined) ){
3656 e = ERROR_TARGET_NOT_EXAMINED;
3657 } else {
3658 e = target->type->poll( target );
3659 }
3660 if( e != ERROR_OK ){
3661 Jim_SetResult_sprintf( interp, "poll-fails: %d", e );
3662 return JIM_ERR;
3663 } else {
3664 return JIM_OK;
3665 }
3666 break;
3667 case TS_CMD_RESET:
3668 if( goi.argc != 2 ){
3669 Jim_WrongNumArgs( interp, 2, argv, "t|f|assert|deassert BOOL");
3670 return JIM_ERR;
3671 }
3672 e = Jim_GetOpt_Nvp( &goi, nvp_assert, &n );
3673 if( e != JIM_OK ){
3674 Jim_GetOpt_NvpUnknown( &goi, nvp_assert, 1 );
3675 return e;
3676 }
3677 /* the halt or not param */
3678 e = Jim_GetOpt_Wide( &goi, &a);
3679 if( e != JIM_OK ){
3680 return e;
3681 }
3682 /* determine if we should halt or not. */
3683 target->reset_halt = !!a;
3684 /* When this happens - all workareas are invalid. */
3685 target_free_all_working_areas_restore(target, 0);
3686
3687 /* do the assert */
3688 if( n->value == NVP_ASSERT ){
3689 target->type->assert_reset( target );
3690 } else {
3691 target->type->deassert_reset( target );
3692 }
3693 return JIM_OK;
3694 case TS_CMD_HALT:
3695 if( goi.argc ){
3696 Jim_WrongNumArgs( goi.interp, 0, argv, "halt [no parameters]");
3697 return JIM_ERR;
3698 }
3699 target->type->halt( target );
3700 return JIM_OK;
3701 case TS_CMD_WAITSTATE:
3702 /* params: <name> statename timeoutmsecs */
3703 if( goi.argc != 2 ){
3704 Jim_SetResult_sprintf( goi.interp, "%s STATENAME TIMEOUTMSECS", n->name );
3705 return JIM_ERR;
3706 }
3707 e = Jim_GetOpt_Nvp( &goi, nvp_target_state, &n );
3708 if( e != JIM_OK ){
3709 Jim_GetOpt_NvpUnknown( &goi, nvp_target_state,1 );
3710 return e;
3711 }
3712 e = Jim_GetOpt_Wide( &goi, &a );
3713 if( e != JIM_OK ){
3714 return e;
3715 }
3716 e = target_wait_state( target, n->value, a );
3717 if( e != ERROR_OK ){
3718 Jim_SetResult_sprintf( goi.interp,
3719 "target: %s wait %s fails (%d) %s",
3720 target->cmd_name,
3721 n->name,
3722 e, target_strerror_safe(e) );
3723 return JIM_ERR;
3724 } else {
3725 return JIM_OK;
3726 }
3727 case TS_CMD_EVENTLIST:
3728 /* List for human, Events defined for this target.
3729 * scripts/programs should use 'name cget -event NAME'
3730 */
3731 {
3732 target_event_action_t *teap;
3733 teap = target->event_action;
3734 command_print( cmd_ctx, "Event actions for target (%d) %s\n",
3735 target->target_number,
3736 target->cmd_name );
3737 command_print( cmd_ctx, "%-25s | Body", "Event");
3738 command_print( cmd_ctx, "------------------------- | ----------------------------------------");
3739 while( teap ){
3740 command_print( cmd_ctx,
3741 "%-25s | %s",
3742 Jim_Nvp_value2name_simple( nvp_target_event, teap->event )->name,
3743 Jim_GetString( teap->body, NULL ) );
3744 teap = teap->next;
3745 }
3746 command_print( cmd_ctx, "***END***");
3747 return JIM_OK;
3748 }
3749 case TS_CMD_CURSTATE:
3750 if( goi.argc != 0 ){
3751 Jim_WrongNumArgs( goi.interp, 0, argv, "[no parameters]");
3752 return JIM_ERR;
3753 }
3754 Jim_SetResultString( goi.interp,
3755 Jim_Nvp_value2name_simple(nvp_target_state,target->state)->name,-1);
3756 return JIM_OK;
3757 case TS_CMD_INVOKE_EVENT:
3758 if( goi.argc != 1 ){
3759 Jim_SetResult_sprintf( goi.interp, "%s ?EVENTNAME?",n->name);
3760 return JIM_ERR;
3761 }
3762 e = Jim_GetOpt_Nvp( &goi, nvp_target_event, &n );
3763 if( e != JIM_OK ){
3764 Jim_GetOpt_NvpUnknown( &goi, nvp_target_event, 1 );
3765 return e;
3766 }
3767 target_handle_event( target, n->value );
3768 return JIM_OK;
3769 }
3770 return JIM_ERR;
3771 }
3772
3773 static int target_create( Jim_GetOptInfo *goi )
3774 {
3775 Jim_Obj *new_cmd;
3776 Jim_Cmd *cmd;
3777 const char *cp;
3778 char *cp2;
3779 int e;
3780 int x;
3781 target_t *target;
3782 struct command_context_s *cmd_ctx;
3783
3784 cmd_ctx = Jim_GetAssocData(goi->interp, "context");
3785 if( goi->argc < 3 ){
3786 Jim_WrongNumArgs( goi->interp, 1, goi->argv, "?name? ?type? ..options...");
3787 return JIM_ERR;
3788 }
3789
3790 /* COMMAND */
3791 Jim_GetOpt_Obj( goi, &new_cmd );
3792 /* does this command exist? */
3793 cmd = Jim_GetCommand( goi->interp, new_cmd, JIM_ERRMSG );
3794 if( cmd ){
3795 cp = Jim_GetString( new_cmd, NULL );
3796 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
3797 return JIM_ERR;
3798 }
3799
3800 /* TYPE */
3801 e = Jim_GetOpt_String( goi, &cp2, NULL );
3802 cp = cp2;
3803 /* now does target type exist */
3804 for( x = 0 ; target_types[x] ; x++ ){
3805 if( 0 == strcmp( cp, target_types[x]->name ) ){
3806 /* found */
3807 break;
3808 }
3809 }
3810 if( target_types[x] == NULL ){
3811 Jim_SetResult_sprintf( goi->interp, "Unknown target type %s, try one of ", cp );
3812 for( x = 0 ; target_types[x] ; x++ ){
3813 if( target_types[x+1] ){
3814 Jim_AppendStrings( goi->interp,
3815 Jim_GetResult(goi->interp),
3816 target_types[x]->name,
3817 ", ", NULL);
3818 } else {
3819 Jim_AppendStrings( goi->interp,
3820 Jim_GetResult(goi->interp),
3821 " or ",
3822 target_types[x]->name,NULL );
3823 }
3824 }
3825 return JIM_ERR;
3826 }
3827
3828 /* Create it */
3829 target = calloc(1,sizeof(target_t));
3830 /* set target number */
3831 target->target_number = new_target_number();
3832
3833 /* allocate memory for each unique target type */
3834 target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
3835
3836 memcpy( target->type, target_types[x], sizeof(target_type_t));
3837
3838 /* will be set by "-endian" */
3839 target->endianness = TARGET_ENDIAN_UNKNOWN;
3840
3841 target->working_area = 0x0;
3842 target->working_area_size = 0x0;
3843 target->working_areas = NULL;
3844 target->backup_working_area = 0;
3845
3846 target->state = TARGET_UNKNOWN;
3847 target->debug_reason = DBG_REASON_UNDEFINED;
3848 target->reg_cache = NULL;
3849 target->breakpoints = NULL;
3850 target->watchpoints = NULL;
3851 target->next = NULL;
3852 target->arch_info = NULL;
3853
3854 target->display = 1;
3855
3856 /* initialize trace information */
3857 target->trace_info = malloc(sizeof(trace_t));
3858 target->trace_info->num_trace_points = 0;
3859 target->trace_info->trace_points_size = 0;
3860 target->trace_info->trace_points = NULL;
3861 target->trace_info->trace_history_size = 0;
3862 target->trace_info->trace_history = NULL;
3863 target->trace_info->trace_history_pos = 0;
3864 target->trace_info->trace_history_overflowed = 0;
3865
3866 target->dbgmsg = NULL;
3867 target->dbg_msg_enabled = 0;
3868
3869 target->endianness = TARGET_ENDIAN_UNKNOWN;
3870
3871 /* Do the rest as "configure" options */
3872 goi->isconfigure = 1;
3873 e = target_configure( goi, target);
3874
3875 if (target->tap == NULL)
3876 {
3877 Jim_SetResultString( interp, "-chain-position required when creating target", -1);
3878 e=JIM_ERR;
3879 }
3880
3881 if( e != JIM_OK ){
3882 free( target->type );
3883 free( target );
3884 return e;
3885 }
3886
3887 if( target->endianness == TARGET_ENDIAN_UNKNOWN ){
3888 /* default endian to little if not specified */
3889 target->endianness = TARGET_LITTLE_ENDIAN;
3890 }
3891
3892 /* incase variant is not set */
3893 if (!target->variant)
3894 target->variant = strdup("");
3895
3896 /* create the target specific commands */
3897 if( target->type->register_commands ){
3898 (*(target->type->register_commands))( cmd_ctx );
3899 }
3900 if( target->type->target_create ){
3901 (*(target->type->target_create))( target, goi->interp );
3902 }
3903
3904 /* append to end of list */
3905 {
3906 target_t **tpp;
3907 tpp = &(all_targets);
3908 while( *tpp ){
3909 tpp = &( (*tpp)->next );
3910 }
3911 *tpp = target;
3912 }
3913
3914 cp = Jim_GetString( new_cmd, NULL );
3915 target->cmd_name = strdup(cp);
3916
3917 /* now - create the new target name command */
3918 e = Jim_CreateCommand( goi->interp,
3919 /* name */
3920 cp,
3921 tcl_target_func, /* C function */
3922 target, /* private data */
3923 NULL ); /* no del proc */
3924
3925 return e;
3926 }
3927
3928 static int jim_target( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
3929 {
3930 int x,r,e;
3931 jim_wide w;
3932 struct command_context_s *cmd_ctx;
3933 target_t *target;
3934 Jim_GetOptInfo goi;
3935 enum tcmd {
3936 /* TG = target generic */
3937 TG_CMD_CREATE,
3938 TG_CMD_TYPES,
3939 TG_CMD_NAMES,
3940 TG_CMD_CURRENT,
3941 TG_CMD_NUMBER,
3942 TG_CMD_COUNT,
3943 };
3944 const char *target_cmds[] = {
3945 "create", "types", "names", "current", "number",
3946 "count",
3947 NULL /* terminate */
3948 };
3949
3950 LOG_DEBUG("Target command params:");
3951 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
3952
3953 cmd_ctx = Jim_GetAssocData( interp, "context" );
3954
3955 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3956
3957 if( goi.argc == 0 ){
3958 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
3959 return JIM_ERR;
3960 }
3961
3962 /* Jim_GetOpt_Debug( &goi ); */
3963 r = Jim_GetOpt_Enum( &goi, target_cmds, &x );
3964 if( r != JIM_OK ){
3965 return r;
3966 }
3967
3968 switch(x){
3969 default:
3970 Jim_Panic(goi.interp,"Why am I here?");
3971 return JIM_ERR;
3972 case TG_CMD_CURRENT:
3973 if( goi.argc != 0 ){
3974 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters");
3975 return JIM_ERR;
3976 }
3977 Jim_SetResultString( goi.interp, get_current_target( cmd_ctx )->cmd_name, -1 );
3978 return JIM_OK;
3979 case TG_CMD_TYPES:
3980 if( goi.argc != 0 ){
3981 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
3982 return JIM_ERR;
3983 }
3984 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
3985 for( x = 0 ; target_types[x] ; x++ ){
3986 Jim_ListAppendElement( goi.interp,
3987 Jim_GetResult(goi.interp),
3988 Jim_NewStringObj( goi.interp, target_types[x]->name, -1 ) );
3989 }
3990 return JIM_OK;
3991 case TG_CMD_NAMES:
3992 if( goi.argc != 0 ){
3993 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
3994 return JIM_ERR;
3995 }
3996 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
3997 target = all_targets;
3998 while( target ){
3999 Jim_ListAppendElement( goi.interp,
4000 Jim_GetResult(goi.interp),
4001 Jim_NewStringObj( goi.interp, target->cmd_name, -1 ) );
4002 target = target->next;
4003 }
4004 return JIM_OK;
4005 case TG_CMD_CREATE:
4006 if( goi.argc < 3 ){
4007 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "?name ... config options ...");
4008 return JIM_ERR;
4009 }
4010 return target_create( &goi );
4011 break;
4012 case TG_CMD_NUMBER:
4013 if( goi.argc != 1 ){
4014 Jim_SetResult_sprintf( goi.interp, "expected: target number ?NUMBER?");
4015 return JIM_ERR;
4016 }
4017 e = Jim_GetOpt_Wide( &goi, &w );
4018 if( e != JIM_OK ){
4019 return JIM_ERR;
4020 }
4021 {
4022 target_t *t;
4023 t = get_target_by_num(w);
4024 if( t == NULL ){
4025 Jim_SetResult_sprintf( goi.interp,"Target: number %d does not exist", (int)(w));
4026 return JIM_ERR;
4027 }
4028 Jim_SetResultString( goi.interp, t->cmd_name, -1 );
4029 return JIM_OK;
4030 }
4031 case TG_CMD_COUNT:
4032 if( goi.argc != 0 ){
4033 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "<no parameters>");
4034 return JIM_ERR;
4035 }
4036 Jim_SetResult( goi.interp,
4037 Jim_NewIntObj( goi.interp, max_target_number()));
4038 return JIM_OK;
4039 }
4040
4041 return JIM_ERR;
4042 }
4043
4044
4045 struct FastLoad
4046 {
4047 u32 address;
4048 u8 *data;
4049 int length;
4050
4051 };
4052
4053 static int fastload_num;
4054 static struct FastLoad *fastload;
4055
4056 static void free_fastload(void)
4057 {
4058 if (fastload!=NULL)
4059 {
4060 int i;
4061 for (i=0; i<fastload_num; i++)
4062 {
4063 if (fastload[i].data)
4064 free(fastload[i].data);
4065 }
4066 free(fastload);
4067 fastload=NULL;
4068 }
4069 }
4070
4071
4072
4073
4074 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4075 {
4076 u8 *buffer;
4077 u32 buf_cnt;
4078 u32 image_size;
4079 u32 min_address=0;
4080 u32 max_address=0xffffffff;
4081 int i;
4082 int retval;
4083
4084 image_t image;
4085
4086 duration_t duration;
4087 char *duration_text;
4088
4089 if ((argc < 1)||(argc > 5))
4090 {
4091 return ERROR_COMMAND_SYNTAX_ERROR;
4092 }
4093
4094 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
4095 if (argc >= 2)
4096 {
4097 image.base_address_set = 1;
4098 image.base_address = strtoul(args[1], NULL, 0);
4099 }
4100 else
4101 {
4102 image.base_address_set = 0;
4103 }
4104
4105
4106 image.start_address_set = 0;
4107
4108 if (argc>=4)
4109 {
4110 min_address=strtoul(args[3], NULL, 0);
4111 }
4112 if (argc>=5)
4113 {
4114 max_address=strtoul(args[4], NULL, 0)+min_address;
4115 }
4116
4117 if (min_address>max_address)
4118 {
4119 return ERROR_COMMAND_SYNTAX_ERROR;
4120 }
4121
4122 duration_start_measure(&duration);
4123
4124 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
4125 {
4126 return ERROR_OK;
4127 }
4128
4129 image_size = 0x0;
4130 retval = ERROR_OK;
4131 fastload_num=image.num_sections;
4132 fastload=(struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4133 if (fastload==NULL)
4134 {
4135 image_close(&image);
4136 return ERROR_FAIL;
4137 }
4138 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4139 for (i = 0; i < image.num_sections; i++)
4140 {
4141 buffer = malloc(image.sections[i].size);
4142 if (buffer == NULL)
4143 {
4144 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
4145 break;
4146 }
4147
4148 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4149 {
4150 free(buffer);
4151 break;
4152 }
4153
4154 u32 offset=0;
4155 u32 length=buf_cnt;
4156
4157
4158 /* DANGER!!! beware of unsigned comparision here!!! */
4159
4160 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
4161 (image.sections[i].base_address<max_address))
4162 {
4163 if (image.sections[i].base_address<min_address)
4164 {
4165 /* clip addresses below */
4166 offset+=min_address-image.sections[i].base_address;
4167 length-=offset;
4168 }
4169
4170 if (image.sections[i].base_address+buf_cnt>max_address)
4171 {
4172 length-=(image.sections[i].base_address+buf_cnt)-max_address;
4173 }
4174
4175 fastload[i].address=image.sections[i].base_address+offset;
4176 fastload[i].data=malloc(length);
4177 if (fastload[i].data==NULL)
4178 {
4179 free(buffer);
4180 break;
4181 }
4182 memcpy(fastload[i].data, buffer+offset, length);
4183 fastload[i].length=length;
4184
4185 image_size += length;
4186 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
4187 }
4188
4189 free(buffer);
4190 }
4191
4192 duration_stop_measure(&duration, &duration_text);
4193 if (retval==ERROR_OK)
4194 {
4195 command_print(cmd_ctx, "Loaded %u bytes in %s", image_size, duration_text);
4196 command_print(cmd_ctx, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4197 }
4198 free(duration_text);
4199
4200 image_close(&image);
4201
4202 if (retval!=ERROR_OK)
4203 {
4204 free_fastload();
4205 }
4206
4207 return retval;
4208 }
4209
4210 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4211 {
4212 if (argc>0)
4213 return ERROR_COMMAND_SYNTAX_ERROR;
4214 if (fastload==NULL)
4215 {
4216 LOG_ERROR("No image in memory");
4217 return ERROR_FAIL;
4218 }
4219 int i;
4220 int ms=timeval_ms();
4221 int size=0;
4222 int retval=ERROR_OK;
4223 for (i=0; i<fastload_num;i++)
4224 {
4225 target_t *target = get_current_target(cmd_ctx);
4226 command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x", fastload[i].address, fastload[i].length);
4227 if (retval==ERROR_OK)
4228 {
4229 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
4230 }
4231 size+=fastload[i].length;
4232 }
4233 int after=timeval_ms();
4234 command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
4235 return retval;
4236 }
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)