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