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