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