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