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