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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)