Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Fixed gaffes in reset script handling + improved error
[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 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "replacements.h"
34 #include "target.h"
35 #include "target_request.h"
36
37 #include "log.h"
38 #include "configuration.h"
39 #include "binarybuffer.h"
40 #include "jtag.h"
41
42 #include <string.h>
43 #include <stdlib.h>
44 #include <inttypes.h>
45
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <unistd.h>
49 #include <errno.h>
50
51 #include <sys/time.h>
52 #include <time.h>
53
54 #include <time_support.h>
55
56 #include <fileio.h>
57 #include <image.h>
58
59 static int USE_OLD_RESET = 0; // temp
60
61 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
62
63
64 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65
66 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67
68 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_NEWreset_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_pre_reset , .name = "old-pre_reset" },
169 { .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
170 { .value = TARGET_EVENT_OLD_post_reset , .name = "old-post_reset" },
171 { .value = TARGET_EVENT_OLD_pre_resume , .name = "old-pre_resume" },
172
173
174 { .value = TARGET_EVENT_EARLY_HALTED, .name = "early-halted" },
175 { .value = TARGET_EVENT_HALTED, .name = "halted" },
176 { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
177 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
178 { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
179
180 /* historical name */
181
182 { .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
183
184 { .value = TARGET_EVENT_RESET_ASSERT_PRE, .name = "reset-assert-pre" },
185 { .value = TARGET_EVENT_RESET_ASSERT_POST, .name = "reset-assert-post" },
186 { .value = TARGET_EVENT_RESET_DEASSERT_PRE, .name = "reset-deassert-pre" },
187 { .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
188 { .value = TARGET_EVENT_RESET_HALT_PRE, .name = "reset-halt-pre" },
189 { .value = TARGET_EVENT_RESET_HALT_POST, .name = "reset-halt-post" },
190 { .value = TARGET_EVENT_RESET_WAIT_PRE, .name = "reset-wait-pre" },
191 { .value = TARGET_EVENT_RESET_WAIT_POST, .name = "reset-wait-post" },
192 { .value = TARGET_EVENT_RESET_INIT , .name = "reset-init" },
193 { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
194
195
196
197
198
199 { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
200 { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-end" },
201
202
203 { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
204 { .value = TARGET_EVENT_DEBUG_RESUMED, .name = "debug-resumed" },
205
206 { .value = TARGET_EVENT_GDB_ATTACH, .name = "gdb-attach" },
207 { .value = TARGET_EVENT_GDB_DETACH, .name = "gdb-detach" },
208
209
210 { .value = TARGET_EVENT_GDB_FLASH_WRITE_START, .name = "gdb-flash-write-start" },
211 { .value = TARGET_EVENT_GDB_FLASH_WRITE_END , .name = "gdb-flash-write-end" },
212
213 { .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
214 { .value = TARGET_EVENT_GDB_FLASH_ERASE_END , .name = "gdb-flash-erase-end" },
215
216 { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
217 { .value = TARGET_EVENT_RESUMED , .name = "resume-ok" },
218 { .value = TARGET_EVENT_RESUME_END , .name = "resume-end" },
219
220 { .name = NULL, .value = -1 }
221 };
222
223 const Jim_Nvp nvp_target_state[] = {
224 { .name = "unknown", .value = TARGET_UNKNOWN },
225 { .name = "running", .value = TARGET_RUNNING },
226 { .name = "halted", .value = TARGET_HALTED },
227 { .name = "reset", .value = TARGET_RESET },
228 { .name = "debug-running", .value = TARGET_DEBUG_RUNNING },
229 { .name = NULL, .value = -1 },
230 };
231
232
233 const Jim_Nvp nvp_target_debug_reason [] = {
234 { .name = "debug-request" , .value = DBG_REASON_DBGRQ },
235 { .name = "breakpoint" , .value = DBG_REASON_BREAKPOINT },
236 { .name = "watchpoint" , .value = DBG_REASON_WATCHPOINT },
237 { .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
238 { .name = "single-step" , .value = DBG_REASON_SINGLESTEP },
239 { .name = "target-not-halted" , .value = DBG_REASON_NOTHALTED },
240 { .name = "undefined" , .value = DBG_REASON_UNDEFINED },
241 { .name = NULL, .value = -1 },
242 };
243
244
245 const Jim_Nvp nvp_target_endian[] = {
246 { .name = "big", .value = TARGET_BIG_ENDIAN },
247 { .name = "little", .value = TARGET_LITTLE_ENDIAN },
248 { .name = "be", .value = TARGET_BIG_ENDIAN },
249 { .name = "le", .value = TARGET_LITTLE_ENDIAN },
250 { .name = NULL, .value = -1 },
251 };
252
253 const Jim_Nvp nvp_reset_modes[] = {
254 { .name = "unknown", .value = RESET_UNKNOWN },
255 { .name = "run" , .value = RESET_RUN },
256 { .name = "halt" , .value = RESET_HALT },
257 { .name = "init" , .value = RESET_INIT },
258 { .name = NULL , .value = -1 },
259 };
260
261 static int
262 max_target_number( void )
263 {
264 target_t *t;
265 int x;
266
267 x = -1;
268 t = all_targets;
269 while( t ){
270 if( x < t->target_number ){
271 x = (t->target_number)+1;
272 }
273 t = t->next;
274 }
275 return x;
276 }
277
278 /* determine the number of the new target */
279 static int
280 new_target_number( void )
281 {
282 target_t *t;
283 int x;
284
285 /* number is 0 based */
286 x = -1;
287 t = all_targets;
288 while(t){
289 if( x < t->target_number ){
290 x = t->target_number;
291 }
292 t = t->next;
293 }
294 return x+1;
295 }
296
297 static int target_continous_poll = 1;
298
299 /* read a u32 from a buffer in target memory endianness */
300 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
301 {
302 if (target->endianness == TARGET_LITTLE_ENDIAN)
303 return le_to_h_u32(buffer);
304 else
305 return be_to_h_u32(buffer);
306 }
307
308 /* read a u16 from a buffer in target memory endianness */
309 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
310 {
311 if (target->endianness == TARGET_LITTLE_ENDIAN)
312 return le_to_h_u16(buffer);
313 else
314 return be_to_h_u16(buffer);
315 }
316
317 /* read a u8 from a buffer in target memory endianness */
318 u8 target_buffer_get_u8(target_t *target, u8 *buffer)
319 {
320 return *buffer & 0x0ff;
321 }
322
323 /* write a u32 to a buffer in target memory endianness */
324 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
325 {
326 if (target->endianness == TARGET_LITTLE_ENDIAN)
327 h_u32_to_le(buffer, value);
328 else
329 h_u32_to_be(buffer, value);
330 }
331
332 /* write a u16 to a buffer in target memory endianness */
333 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
334 {
335 if (target->endianness == TARGET_LITTLE_ENDIAN)
336 h_u16_to_le(buffer, value);
337 else
338 h_u16_to_be(buffer, value);
339 }
340
341 /* write a u8 to a buffer in target memory endianness */
342 void target_buffer_set_u8(target_t *target, u8 *buffer, u8 value)
343 {
344 *buffer = value;
345 }
346
347 /* returns a pointer to the n-th configured target */
348 target_t* get_target_by_num(int num)
349 {
350 target_t *target = all_targets;
351
352 while (target){
353 if( target->target_number == num ){
354 return target;
355 }
356 target = target->next;
357 }
358
359 return NULL;
360 }
361
362 int get_num_by_target(target_t *query_target)
363 {
364 return query_target->target_number;
365 }
366
367 target_t* get_current_target(command_context_t *cmd_ctx)
368 {
369 target_t *target = get_target_by_num(cmd_ctx->current_target);
370
371 if (target == NULL)
372 {
373 LOG_ERROR("BUG: current_target out of bounds");
374 exit(-1);
375 }
376
377 return target;
378 }
379
380
381 int target_poll(struct target_s *target)
382 {
383 /* We can't poll until after examine */
384 if (!target->type->examined)
385 {
386 /* Fail silently lest we pollute the log */
387 return ERROR_FAIL;
388 }
389 return target->type->poll(target);
390 }
391
392 int target_halt(struct target_s *target)
393 {
394 /* We can't poll until after examine */
395 if (!target->type->examined)
396 {
397 LOG_ERROR("Target not examined yet");
398 return ERROR_FAIL;
399 }
400 return target->type->halt(target);
401 }
402
403 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
404 {
405 int retval;
406
407 /* We can't poll until after examine */
408 if (!target->type->examined)
409 {
410 LOG_ERROR("Target not examined yet");
411 return ERROR_FAIL;
412 }
413
414 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
415 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
416 * the application.
417 */
418 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
419 return retval;
420
421 return retval;
422 }
423
424
425 static int NEW_target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
426 {
427 char buf[100];
428 int retval;
429 Jim_Nvp *n;
430 n = Jim_Nvp_value2name_simple( nvp_reset_modes, reset_mode );
431 if( n->name == NULL ){
432 LOG_ERROR("invalid reset mode");
433 return ERROR_FAIL;
434 }
435
436 sprintf( buf, "ocd_process_reset %s", n->name );
437 retval = Jim_Eval( interp, buf );
438
439 if(retval != JIM_OK) {
440 Jim_PrintErrorMessage(interp);
441 return ERROR_FAIL;
442 }
443
444 /* We want any events to be processed before the prompt */
445 retval = target_call_timer_callbacks_now();
446
447 return retval;
448 }
449
450 // Next patch - this turns into TCL...
451 static int OLD_target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
452 {
453 int retval = ERROR_OK;
454 target_t *target;
455
456 target = all_targets;
457
458 target_all_handle_event( TARGET_EVENT_OLD_pre_reset );
459
460 if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
461 return retval;
462
463 keep_alive(); /* we might be running on a very slow JTAG clk */
464
465 /* First time this is executed after launching OpenOCD, it will read out
466 * the type of CPU, etc. and init Embedded ICE registers in host
467 * memory.
468 *
469 * It will also set up ICE registers in the target.
470 *
471 * However, if we assert TRST later, we need to set up the registers again.
472 *
473 * For the "reset halt/init" case we must only set up the registers here.
474 */
475 if ((retval = target_examine()) != ERROR_OK)
476 return retval;
477
478 keep_alive(); /* we might be running on a very slow JTAG clk */
479
480 target = all_targets;
481 while (target)
482 {
483 /* we have no idea what state the target is in, so we
484 * have to drop working areas
485 */
486 target_free_all_working_areas_restore(target, 0);
487 target->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT));
488 if ((retval = target->type->assert_reset(target))!=ERROR_OK)
489 return retval;
490 target = target->next;
491 }
492
493 target = all_targets;
494 while (target)
495 {
496 if ((retval = target->type->deassert_reset(target))!=ERROR_OK)
497 return retval;
498 target = target->next;
499 }
500
501 target = all_targets;
502 while (target)
503 {
504 /* We can fail to bring the target into the halted state, try after reset has been deasserted */
505 if (target->reset_halt)
506 {
507 /* wait up to 1 second for halt. */
508 if ((retval = target_wait_state(target, TARGET_HALTED, 1000)) != ERROR_OK)
509 return retval;
510 if (target->state != TARGET_HALTED)
511 {
512 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
513 if ((retval = target->type->halt(target))!=ERROR_OK)
514 return retval;
515 }
516 }
517
518 target = target->next;
519 }
520
521
522 LOG_DEBUG("Waiting for halted stated as appropriate");
523
524 if ((reset_mode == RESET_HALT) || (reset_mode == RESET_INIT))
525 {
526 target = all_targets;
527 while (target)
528 {
529 /* Wait for reset to complete, maximum 5 seconds. */
530 if (((retval=target_wait_state(target, TARGET_HALTED, 5000)))==ERROR_OK)
531 {
532 if (reset_mode == RESET_INIT){
533 target_handle_event( target, TARGET_EVENT_OLD_post_reset );
534 }
535
536 }
537 target = target->next;
538 }
539 }
540
541 /* We want any events to be processed before the prompt */
542 if ((retval = target_call_timer_callbacks_now()) != ERROR_OK)
543 return retval;
544
545 return retval;
546 }
547
548 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
549 {
550 if( USE_OLD_RESET ){
551 return OLD_target_process_reset( cmd_ctx, reset_mode );
552 } else {
553 return NEW_target_process_reset( cmd_ctx, reset_mode );
554 }
555 }
556
557
558 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
559 {
560 *physical = virtual;
561 return ERROR_OK;
562 }
563
564 static int default_mmu(struct target_s *target, int *enabled)
565 {
566 *enabled = 0;
567 return ERROR_OK;
568 }
569
570 static int default_examine(struct target_s *target)
571 {
572 target->type->examined = 1;
573 return ERROR_OK;
574 }
575
576
577 /* Targets that correctly implement init+examine, i.e.
578 * no communication with target during init:
579 *
580 * XScale
581 */
582 int target_examine(void)
583 {
584 int retval = ERROR_OK;
585 target_t *target = all_targets;
586 while (target)
587 {
588 if ((retval = target->type->examine(target))!=ERROR_OK)
589 return retval;
590 target = target->next;
591 }
592 return retval;
593 }
594
595 static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
596 {
597 if (!target->type->examined)
598 {
599 LOG_ERROR("Target not examined yet");
600 return ERROR_FAIL;
601 }
602 return target->type->write_memory_imp(target, address, size, count, buffer);
603 }
604
605 static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
606 {
607 if (!target->type->examined)
608 {
609 LOG_ERROR("Target not examined yet");
610 return ERROR_FAIL;
611 }
612 return target->type->read_memory_imp(target, address, size, count, buffer);
613 }
614
615 static int target_soft_reset_halt_imp(struct target_s *target)
616 {
617 if (!target->type->examined)
618 {
619 LOG_ERROR("Target not examined yet");
620 return ERROR_FAIL;
621 }
622 return target->type->soft_reset_halt_imp(target);
623 }
624
625 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)
626 {
627 if (!target->type->examined)
628 {
629 LOG_ERROR("Target not examined yet");
630 return ERROR_FAIL;
631 }
632 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);
633 }
634
635 int target_init(struct command_context_s *cmd_ctx)
636 {
637 target_t *target = all_targets;
638 int retval;
639
640 while (target)
641 {
642 target->type->examined = 0;
643 if (target->type->examine == NULL)
644 {
645 target->type->examine = default_examine;
646 }
647
648 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
649 {
650 LOG_ERROR("target '%s' init failed", target->type->name);
651 exit(-1);
652 }
653
654 /* Set up default functions if none are provided by target */
655 if (target->type->virt2phys == NULL)
656 {
657 target->type->virt2phys = default_virt2phys;
658 }
659 target->type->virt2phys = default_virt2phys;
660 /* a non-invasive way(in terms of patches) to add some code that
661 * runs before the type->write/read_memory implementation
662 */
663 target->type->write_memory_imp = target->type->write_memory;
664 target->type->write_memory = target_write_memory_imp;
665 target->type->read_memory_imp = target->type->read_memory;
666 target->type->read_memory = target_read_memory_imp;
667 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
668 target->type->soft_reset_halt = target_soft_reset_halt_imp;
669 target->type->run_algorithm_imp = target->type->run_algorithm;
670 target->type->run_algorithm = target_run_algorithm_imp;
671
672
673 if (target->type->mmu == NULL)
674 {
675 target->type->mmu = default_mmu;
676 }
677 target = target->next;
678 }
679
680 if (all_targets)
681 {
682 if((retval = target_register_user_commands(cmd_ctx)) != ERROR_OK)
683 return retval;
684 if((retval = target_register_timer_callback(handle_target, 100, 1, NULL)) != ERROR_OK)
685 return retval;
686 }
687
688 return ERROR_OK;
689 }
690
691 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
692 {
693 target_event_callback_t **callbacks_p = &target_event_callbacks;
694
695 if (callback == NULL)
696 {
697 return ERROR_INVALID_ARGUMENTS;
698 }
699
700 if (*callbacks_p)
701 {
702 while ((*callbacks_p)->next)
703 callbacks_p = &((*callbacks_p)->next);
704 callbacks_p = &((*callbacks_p)->next);
705 }
706
707 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
708 (*callbacks_p)->callback = callback;
709 (*callbacks_p)->priv = priv;
710 (*callbacks_p)->next = NULL;
711
712 return ERROR_OK;
713 }
714
715 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
716 {
717 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
718 struct timeval now;
719
720 if (callback == NULL)
721 {
722 return ERROR_INVALID_ARGUMENTS;
723 }
724
725 if (*callbacks_p)
726 {
727 while ((*callbacks_p)->next)
728 callbacks_p = &((*callbacks_p)->next);
729 callbacks_p = &((*callbacks_p)->next);
730 }
731
732 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
733 (*callbacks_p)->callback = callback;
734 (*callbacks_p)->periodic = periodic;
735 (*callbacks_p)->time_ms = time_ms;
736
737 gettimeofday(&now, NULL);
738 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
739 time_ms -= (time_ms % 1000);
740 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
741 if ((*callbacks_p)->when.tv_usec > 1000000)
742 {
743 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
744 (*callbacks_p)->when.tv_sec += 1;
745 }
746
747 (*callbacks_p)->priv = priv;
748 (*callbacks_p)->next = NULL;
749
750 return ERROR_OK;
751 }
752
753 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
754 {
755 target_event_callback_t **p = &target_event_callbacks;
756 target_event_callback_t *c = target_event_callbacks;
757
758 if (callback == NULL)
759 {
760 return ERROR_INVALID_ARGUMENTS;
761 }
762
763 while (c)
764 {
765 target_event_callback_t *next = c->next;
766 if ((c->callback == callback) && (c->priv == priv))
767 {
768 *p = next;
769 free(c);
770 return ERROR_OK;
771 }
772 else
773 p = &(c->next);
774 c = next;
775 }
776
777 return ERROR_OK;
778 }
779
780 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
781 {
782 target_timer_callback_t **p = &target_timer_callbacks;
783 target_timer_callback_t *c = target_timer_callbacks;
784
785 if (callback == NULL)
786 {
787 return ERROR_INVALID_ARGUMENTS;
788 }
789
790 while (c)
791 {
792 target_timer_callback_t *next = c->next;
793 if ((c->callback == callback) && (c->priv == priv))
794 {
795 *p = next;
796 free(c);
797 return ERROR_OK;
798 }
799 else
800 p = &(c->next);
801 c = next;
802 }
803
804 return ERROR_OK;
805 }
806
807 int target_call_event_callbacks(target_t *target, enum target_event event)
808 {
809 target_event_callback_t *callback = target_event_callbacks;
810 target_event_callback_t *next_callback;
811
812 if (event == TARGET_EVENT_HALTED)
813 {
814 /* execute early halted first */
815 target_call_event_callbacks(target, TARGET_EVENT_EARLY_HALTED);
816 }
817
818
819 LOG_DEBUG("target event %i (%s)",
820 event,
821 Jim_Nvp_value2name_simple( nvp_target_event, event )->name );
822
823 target_handle_event( target, event );
824
825 while (callback)
826 {
827 next_callback = callback->next;
828 callback->callback(target, event, callback->priv);
829 callback = next_callback;
830 }
831
832 return ERROR_OK;
833 }
834
835 static int target_call_timer_callbacks_check_time(int checktime)
836 {
837 target_timer_callback_t *callback = target_timer_callbacks;
838 target_timer_callback_t *next_callback;
839 struct timeval now;
840
841 keep_alive();
842
843 gettimeofday(&now, NULL);
844
845 while (callback)
846 {
847 next_callback = callback->next;
848
849 if ((!checktime&&callback->periodic)||
850 (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
851 || (now.tv_sec > callback->when.tv_sec)))
852 {
853 if(callback->callback != NULL)
854 {
855 callback->callback(callback->priv);
856 if (callback->periodic)
857 {
858 int time_ms = callback->time_ms;
859 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
860 time_ms -= (time_ms % 1000);
861 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
862 if (callback->when.tv_usec > 1000000)
863 {
864 callback->when.tv_usec = callback->when.tv_usec - 1000000;
865 callback->when.tv_sec += 1;
866 }
867 }
868 else
869 {
870 int retval;
871 if((retval = target_unregister_timer_callback(callback->callback, callback->priv)) != ERROR_OK)
872 return retval;
873 }
874 }
875 }
876
877 callback = next_callback;
878 }
879
880 return ERROR_OK;
881 }
882
883 int target_call_timer_callbacks(void)
884 {
885 return target_call_timer_callbacks_check_time(1);
886 }
887
888 /* invoke periodic callbacks immediately */
889 int target_call_timer_callbacks_now(void)
890 {
891 return target_call_timer_callbacks_check_time(0);
892 }
893
894 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
895 {
896 working_area_t *c = target->working_areas;
897 working_area_t *new_wa = NULL;
898
899 /* Reevaluate working area address based on MMU state*/
900 if (target->working_areas == NULL)
901 {
902 int retval;
903 int enabled;
904 retval = target->type->mmu(target, &enabled);
905 if (retval != ERROR_OK)
906 {
907 return retval;
908 }
909 if (enabled)
910 {
911 target->working_area = target->working_area_virt;
912 }
913 else
914 {
915 target->working_area = target->working_area_phys;
916 }
917 }
918
919 /* only allocate multiples of 4 byte */
920 if (size % 4)
921 {
922 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
923 size = CEIL(size, 4);
924 }
925
926 /* see if there's already a matching working area */
927 while (c)
928 {
929 if ((c->free) && (c->size == size))
930 {
931 new_wa = c;
932 break;
933 }
934 c = c->next;
935 }
936
937 /* if not, allocate a new one */
938 if (!new_wa)
939 {
940 working_area_t **p = &target->working_areas;
941 u32 first_free = target->working_area;
942 u32 free_size = target->working_area_size;
943
944 LOG_DEBUG("allocating new working area");
945
946 c = target->working_areas;
947 while (c)
948 {
949 first_free += c->size;
950 free_size -= c->size;
951 p = &c->next;
952 c = c->next;
953 }
954
955 if (free_size < size)
956 {
957 LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
958 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
959 }
960
961 new_wa = malloc(sizeof(working_area_t));
962 new_wa->next = NULL;
963 new_wa->size = size;
964 new_wa->address = first_free;
965
966 if (target->backup_working_area)
967 {
968 int retval;
969 new_wa->backup = malloc(new_wa->size);
970 if((retval = target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
971 {
972 free(new_wa->backup);
973 free(new_wa);
974 return retval;
975 }
976 }
977 else
978 {
979 new_wa->backup = NULL;
980 }
981
982 /* put new entry in list */
983 *p = new_wa;
984 }
985
986 /* mark as used, and return the new (reused) area */
987 new_wa->free = 0;
988 *area = new_wa;
989
990 /* user pointer */
991 new_wa->user = area;
992
993 return ERROR_OK;
994 }
995
996 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
997 {
998 if (area->free)
999 return ERROR_OK;
1000
1001 if (restore&&target->backup_working_area)
1002 {
1003 int retval;
1004 if((retval = target->type->write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
1005 return retval;
1006 }
1007
1008 area->free = 1;
1009
1010 /* mark user pointer invalid */
1011 *area->user = NULL;
1012 area->user = NULL;
1013
1014 return ERROR_OK;
1015 }
1016
1017 int target_free_working_area(struct target_s *target, working_area_t *area)
1018 {
1019 return target_free_working_area_restore(target, area, 1);
1020 }
1021
1022 /* free resources and restore memory, if restoring memory fails,
1023 * free up resources anyway
1024 */
1025 void target_free_all_working_areas_restore(struct target_s *target, int restore)
1026 {
1027 working_area_t *c = target->working_areas;
1028
1029 while (c)
1030 {
1031 working_area_t *next = c->next;
1032 target_free_working_area_restore(target, c, restore);
1033
1034 if (c->backup)
1035 free(c->backup);
1036
1037 free(c);
1038
1039 c = next;
1040 }
1041
1042 target->working_areas = NULL;
1043 }
1044
1045 void target_free_all_working_areas(struct target_s *target)
1046 {
1047 target_free_all_working_areas_restore(target, 1);
1048 }
1049
1050 int target_register_commands(struct command_context_s *cmd_ctx)
1051 {
1052
1053 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
1054 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
1055 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
1056 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
1057
1058 register_jim(cmd_ctx, "target", jim_target, "configure target" );
1059
1060
1061 /* script procedures */
1062 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
1063 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
1064 return ERROR_OK;
1065 }
1066
1067 int target_arch_state(struct target_s *target)
1068 {
1069 int retval;
1070 if (target==NULL)
1071 {
1072 LOG_USER("No target has been configured");
1073 return ERROR_OK;
1074 }
1075
1076 LOG_USER("target state: %s",
1077 Jim_Nvp_value2name_simple(nvp_target_state,target->state)->name);
1078
1079 if (target->state!=TARGET_HALTED)
1080 return ERROR_OK;
1081
1082 retval=target->type->arch_state(target);
1083 return retval;
1084 }
1085
1086 /* Single aligned words are guaranteed to use 16 or 32 bit access
1087 * mode respectively, otherwise data is handled as quickly as
1088 * possible
1089 */
1090 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
1091 {
1092 int retval;
1093 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
1094
1095 if (!target->type->examined)
1096 {
1097 LOG_ERROR("Target not examined yet");
1098 return ERROR_FAIL;
1099 }
1100
1101 if ((address + size - 1) < address)
1102 {
1103 /* GDB can request this when e.g. PC is 0xfffffffc*/
1104 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
1105 return ERROR_FAIL;
1106 }
1107
1108 if (((address % 2) == 0) && (size == 2))
1109 {
1110 return target->type->write_memory(target, address, 2, 1, buffer);
1111 }
1112
1113 /* handle unaligned head bytes */
1114 if (address % 4)
1115 {
1116 int unaligned = 4 - (address % 4);
1117
1118 if (unaligned > size)
1119 unaligned = size;
1120
1121 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1122 return retval;
1123
1124 buffer += unaligned;
1125 address += unaligned;
1126 size -= unaligned;
1127 }
1128
1129 /* handle aligned words */
1130 if (size >= 4)
1131 {
1132 int aligned = size - (size % 4);
1133
1134 /* use bulk writes above a certain limit. This may have to be changed */
1135 if (aligned > 128)
1136 {
1137 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1138 return retval;
1139 }
1140 else
1141 {
1142 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1143 return retval;
1144 }
1145
1146 buffer += aligned;
1147 address += aligned;
1148 size -= aligned;
1149 }
1150
1151 /* handle tail writes of less than 4 bytes */
1152 if (size > 0)
1153 {
1154 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1155 return retval;
1156 }
1157
1158 return ERROR_OK;
1159 }
1160
1161
1162 /* Single aligned words are guaranteed to use 16 or 32 bit access
1163 * mode respectively, otherwise data is handled as quickly as
1164 * possible
1165 */
1166 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
1167 {
1168 int retval;
1169 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
1170
1171 if (!target->type->examined)
1172 {
1173 LOG_ERROR("Target not examined yet");
1174 return ERROR_FAIL;
1175 }
1176
1177 if ((address + size - 1) < address)
1178 {
1179 /* GDB can request this when e.g. PC is 0xfffffffc*/
1180 LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
1181 return ERROR_FAIL;
1182 }
1183
1184 if (((address % 2) == 0) && (size == 2))
1185 {
1186 return target->type->read_memory(target, address, 2, 1, buffer);
1187 }
1188
1189 /* handle unaligned head bytes */
1190 if (address % 4)
1191 {
1192 int unaligned = 4 - (address % 4);
1193
1194 if (unaligned > size)
1195 unaligned = size;
1196
1197 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1198 return retval;
1199
1200 buffer += unaligned;
1201 address += unaligned;
1202 size -= unaligned;
1203 }
1204
1205 /* handle aligned words */
1206 if (size >= 4)
1207 {
1208 int aligned = size - (size % 4);
1209
1210 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1211 return retval;
1212
1213 buffer += aligned;
1214 address += aligned;
1215 size -= aligned;
1216 }
1217
1218 /* handle tail writes of less than 4 bytes */
1219 if (size > 0)
1220 {
1221 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1222 return retval;
1223 }
1224
1225 return ERROR_OK;
1226 }
1227
1228 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1229 {
1230 u8 *buffer;
1231 int retval;
1232 int i;
1233 u32 checksum = 0;
1234 if (!target->type->examined)
1235 {
1236 LOG_ERROR("Target not examined yet");
1237 return ERROR_FAIL;
1238 }
1239
1240 if ((retval = target->type->checksum_memory(target, address,
1241 size, &checksum)) != ERROR_OK)
1242 {
1243 buffer = malloc(size);
1244 if (buffer == NULL)
1245 {
1246 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1247 return ERROR_INVALID_ARGUMENTS;
1248 }
1249 retval = target_read_buffer(target, address, size, buffer);
1250 if (retval != ERROR_OK)
1251 {
1252 free(buffer);
1253 return retval;
1254 }
1255
1256 /* convert to target endianess */
1257 for (i = 0; i < (size/sizeof(u32)); i++)
1258 {
1259 u32 target_data;
1260 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1261 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1262 }
1263
1264 retval = image_calculate_checksum( buffer, size, &checksum );
1265 free(buffer);
1266 }
1267
1268 *crc = checksum;
1269
1270 return retval;
1271 }
1272
1273 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
1274 {
1275 int retval;
1276 if (!target->type->examined)
1277 {
1278 LOG_ERROR("Target not examined yet");
1279 return ERROR_FAIL;
1280 }
1281
1282 if (target->type->blank_check_memory == 0)
1283 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1284
1285 retval = target->type->blank_check_memory(target, address, size, blank);
1286
1287 return retval;
1288 }
1289
1290 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1291 {
1292 u8 value_buf[4];
1293 if (!target->type->examined)
1294 {
1295 LOG_ERROR("Target not examined yet");
1296 return ERROR_FAIL;
1297 }
1298
1299 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1300
1301 if (retval == ERROR_OK)
1302 {
1303 *value = target_buffer_get_u32(target, value_buf);
1304 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1305 }
1306 else
1307 {
1308 *value = 0x0;
1309 LOG_DEBUG("address: 0x%8.8x failed", address);
1310 }
1311
1312 return retval;
1313 }
1314
1315 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1316 {
1317 u8 value_buf[2];
1318 if (!target->type->examined)
1319 {
1320 LOG_ERROR("Target not examined yet");
1321 return ERROR_FAIL;
1322 }
1323
1324 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1325
1326 if (retval == ERROR_OK)
1327 {
1328 *value = target_buffer_get_u16(target, value_buf);
1329 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1330 }
1331 else
1332 {
1333 *value = 0x0;
1334 LOG_DEBUG("address: 0x%8.8x failed", address);
1335 }
1336
1337 return retval;
1338 }
1339
1340 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1341 {
1342 int retval = target->type->read_memory(target, address, 1, 1, value);
1343 if (!target->type->examined)
1344 {
1345 LOG_ERROR("Target not examined yet");
1346 return ERROR_FAIL;
1347 }
1348
1349 if (retval == ERROR_OK)
1350 {
1351 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1352 }
1353 else
1354 {
1355 *value = 0x0;
1356 LOG_DEBUG("address: 0x%8.8x failed", address);
1357 }
1358
1359 return retval;
1360 }
1361
1362 int target_write_u32(struct target_s *target, u32 address, u32 value)
1363 {
1364 int retval;
1365 u8 value_buf[4];
1366 if (!target->type->examined)
1367 {
1368 LOG_ERROR("Target not examined yet");
1369 return ERROR_FAIL;
1370 }
1371
1372 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1373
1374 target_buffer_set_u32(target, value_buf, value);
1375 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1376 {
1377 LOG_DEBUG("failed: %i", retval);
1378 }
1379
1380 return retval;
1381 }
1382
1383 int target_write_u16(struct target_s *target, u32 address, u16 value)
1384 {
1385 int retval;
1386 u8 value_buf[2];
1387 if (!target->type->examined)
1388 {
1389 LOG_ERROR("Target not examined yet");
1390 return ERROR_FAIL;
1391 }
1392
1393 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1394
1395 target_buffer_set_u16(target, value_buf, value);
1396 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1397 {
1398 LOG_DEBUG("failed: %i", retval);
1399 }
1400
1401 return retval;
1402 }
1403
1404 int target_write_u8(struct target_s *target, u32 address, u8 value)
1405 {
1406 int retval;
1407 if (!target->type->examined)
1408 {
1409 LOG_ERROR("Target not examined yet");
1410 return ERROR_FAIL;
1411 }
1412
1413 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1414
1415 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1416 {
1417 LOG_DEBUG("failed: %i", retval);
1418 }
1419
1420 return retval;
1421 }
1422
1423 int target_register_user_commands(struct command_context_s *cmd_ctx)
1424 {
1425 int retval = ERROR_OK;
1426 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1427 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1428 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1429 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1430 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1431 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1432 register_command(cmd_ctx, NULL, "NEWreset", handle_NEWreset_command, COMMAND_EXEC, "reset target [run|halt|init] - default is run");
1433 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "OLDreset target [run|halt|init] - default is run");
1434 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1435
1436 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1437 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1438 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1439
1440 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1441 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1442 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1443
1444 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1445 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1446 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1447 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1448
1449 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]");
1450 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1451 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1452
1453 if((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
1454 return retval;
1455 if((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
1456 return retval;
1457
1458
1459 return retval;
1460 }
1461
1462 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1463 {
1464 char *cp;
1465 target_t *target = all_targets;
1466
1467 if (argc == 1)
1468 {
1469 /* try as tcltarget name */
1470 for( target = all_targets ; target ; target++ ){
1471 if( target->cmd_name ){
1472 if( 0 == strcmp( args[0], target->cmd_name ) ){
1473 /* MATCH */
1474 goto Match;
1475 }
1476 }
1477 }
1478 /* no match, try as number */
1479
1480 int num = strtoul(args[0], &cp, 0 );
1481 if( *cp != 0 ){
1482 /* then it was not a number */
1483 command_print( cmd_ctx, "Target: %s unknown, try one of:\n", args[0] );
1484 goto DumpTargets;
1485 }
1486
1487 target = get_target_by_num( num );
1488 if( target == NULL ){
1489 command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0] );
1490 goto DumpTargets;
1491 }
1492 Match:
1493 cmd_ctx->current_target = target->target_number;
1494 return ERROR_OK;
1495 }
1496 DumpTargets:
1497
1498 command_print(cmd_ctx, " CmdName Type Endian ChainPos State ");
1499 command_print(cmd_ctx, "-- ---------- ---------- ---------- -------- ----------");
1500 while (target)
1501 {
1502 /* XX: abcdefghij abcdefghij abcdefghij abcdefghij */
1503 command_print(cmd_ctx, "%2d: %-10s %-10s %-10s %8d %s",
1504 target->target_number,
1505 target->cmd_name,
1506 target->type->name,
1507 Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness )->name,
1508 target->chain_position,
1509 Jim_Nvp_value2name_simple( nvp_target_state, target->state )->name );
1510 target = target->next;
1511 }
1512
1513 return ERROR_OK;
1514 }
1515
1516
1517
1518 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1519 {
1520 int retval = ERROR_OK;
1521 target_t *target = NULL;
1522
1523 if ((argc < 4) || (argc > 5))
1524 {
1525 return ERROR_COMMAND_SYNTAX_ERROR;
1526 }
1527
1528 target = get_target_by_num(strtoul(args[0], NULL, 0));
1529 if (!target)
1530 {
1531 return ERROR_COMMAND_SYNTAX_ERROR;
1532 }
1533 target_free_all_working_areas(target);
1534
1535 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1536 if (argc == 5)
1537 {
1538 target->working_area_virt = strtoul(args[4], NULL, 0);
1539 }
1540 target->working_area_size = strtoul(args[2], NULL, 0);
1541
1542 if (strcmp(args[3], "backup") == 0)
1543 {
1544 target->backup_working_area = 1;
1545 }
1546 else if (strcmp(args[3], "nobackup") == 0)
1547 {
1548 target->backup_working_area = 0;
1549 }
1550 else
1551 {
1552 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1553 return ERROR_COMMAND_SYNTAX_ERROR;
1554 }
1555
1556 return retval;
1557 }
1558
1559
1560 /* process target state changes */
1561 int handle_target(void *priv)
1562 {
1563 int retval = ERROR_OK;
1564 target_t *target = all_targets;
1565
1566 while (target)
1567 {
1568 if (target_continous_poll)
1569 {
1570 /* polling may fail silently until the target has been examined */
1571 if((retval = target_poll(target)) != ERROR_OK)
1572 return retval;
1573 }
1574
1575 target = target->next;
1576 }
1577
1578 return retval;
1579 }
1580
1581 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1582 {
1583 target_t *target;
1584 reg_t *reg = NULL;
1585 int count = 0;
1586 char *value;
1587
1588 LOG_DEBUG("-");
1589
1590 target = get_current_target(cmd_ctx);
1591
1592 /* list all available registers for the current target */
1593 if (argc == 0)
1594 {
1595 reg_cache_t *cache = target->reg_cache;
1596
1597 count = 0;
1598 while(cache)
1599 {
1600 int i;
1601 for (i = 0; i < cache->num_regs; i++)
1602 {
1603 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1604 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);
1605 free(value);
1606 }
1607 cache = cache->next;
1608 }
1609
1610 return ERROR_OK;
1611 }
1612
1613 /* access a single register by its ordinal number */
1614 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1615 {
1616 int num = strtoul(args[0], NULL, 0);
1617 reg_cache_t *cache = target->reg_cache;
1618
1619 count = 0;
1620 while(cache)
1621 {
1622 int i;
1623 for (i = 0; i < cache->num_regs; i++)
1624 {
1625 if (count++ == num)
1626 {
1627 reg = &cache->reg_list[i];
1628 break;
1629 }
1630 }
1631 if (reg)
1632 break;
1633 cache = cache->next;
1634 }
1635
1636 if (!reg)
1637 {
1638 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1639 return ERROR_OK;
1640 }
1641 } else /* access a single register by its name */
1642 {
1643 reg = register_get_by_name(target->reg_cache, args[0], 1);
1644
1645 if (!reg)
1646 {
1647 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1648 return ERROR_OK;
1649 }
1650 }
1651
1652 /* display a register */
1653 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1654 {
1655 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1656 reg->valid = 0;
1657
1658 if (reg->valid == 0)
1659 {
1660 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1661 arch_type->get(reg);
1662 }
1663 value = buf_to_str(reg->value, reg->size, 16);
1664 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1665 free(value);
1666 return ERROR_OK;
1667 }
1668
1669 /* set register value */
1670 if (argc == 2)
1671 {
1672 u8 *buf = malloc(CEIL(reg->size, 8));
1673 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1674
1675 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1676 arch_type->set(reg, buf);
1677
1678 value = buf_to_str(reg->value, reg->size, 16);
1679 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1680 free(value);
1681
1682 free(buf);
1683
1684 return ERROR_OK;
1685 }
1686
1687 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1688
1689 return ERROR_OK;
1690 }
1691
1692
1693 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1694 {
1695 int retval = ERROR_OK;
1696 target_t *target = get_current_target(cmd_ctx);
1697
1698 if (argc == 0)
1699 {
1700 if((retval = target_poll(target)) != ERROR_OK)
1701 return retval;
1702 if((retval = target_arch_state(target)) != ERROR_OK)
1703 return retval;
1704
1705 }
1706 else if (argc==1)
1707 {
1708 if (strcmp(args[0], "on") == 0)
1709 {
1710 target_continous_poll = 1;
1711 }
1712 else if (strcmp(args[0], "off") == 0)
1713 {
1714 target_continous_poll = 0;
1715 }
1716 else
1717 {
1718 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1719 }
1720 } else
1721 {
1722 return ERROR_COMMAND_SYNTAX_ERROR;
1723 }
1724
1725
1726 return retval;
1727 }
1728
1729 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1730 {
1731 int ms = 5000;
1732
1733 if (argc > 0)
1734 {
1735 char *end;
1736
1737 ms = strtoul(args[0], &end, 0) * 1000;
1738 if (*end)
1739 {
1740 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1741 return ERROR_OK;
1742 }
1743 }
1744 target_t *target = get_current_target(cmd_ctx);
1745
1746 return target_wait_state(target, TARGET_HALTED, ms);
1747 }
1748
1749 int target_wait_state(target_t *target, enum target_state state, int ms)
1750 {
1751 int retval;
1752 struct timeval timeout, now;
1753 int once=1;
1754 gettimeofday(&timeout, NULL);
1755 timeval_add_time(&timeout, 0, ms * 1000);
1756
1757 for (;;)
1758 {
1759 if ((retval=target_poll(target))!=ERROR_OK)
1760 return retval;
1761 keep_alive();
1762 if (target->state == state)
1763 {
1764 break;
1765 }
1766 if (once)
1767 {
1768 once=0;
1769 LOG_DEBUG("waiting for target %s...",
1770 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
1771 }
1772
1773 gettimeofday(&now, NULL);
1774 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1775 {
1776 LOG_ERROR("timed out while waiting for target %s",
1777 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
1778 return ERROR_FAIL;
1779 }
1780 }
1781
1782 return ERROR_OK;
1783 }
1784
1785 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1786 {
1787 int retval;
1788 target_t *target = get_current_target(cmd_ctx);
1789
1790 LOG_DEBUG("-");
1791
1792 if ((retval = target_halt(target)) != ERROR_OK)
1793 {
1794 return retval;
1795 }
1796
1797 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1798 }
1799
1800 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1801 {
1802 target_t *target = get_current_target(cmd_ctx);
1803
1804 LOG_USER("requesting target halt and executing a soft reset");
1805
1806 target->type->soft_reset_halt(target);
1807
1808 return ERROR_OK;
1809 }
1810
1811 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1812 {
1813 const Jim_Nvp *n;
1814 enum target_reset_mode reset_mode = RESET_RUN;
1815
1816 if (argc >= 1)
1817 {
1818 n = Jim_Nvp_name2value_simple( nvp_reset_modes, args[0] );
1819 if( (n->name == NULL) || (n->value == RESET_UNKNOWN) ){
1820 return ERROR_COMMAND_SYNTAX_ERROR;
1821 }
1822 reset_mode = n->value;
1823 }
1824
1825 /* reset *all* targets */
1826 return target_process_reset(cmd_ctx, reset_mode);
1827 }
1828
1829 int handle_NEWreset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1830 {
1831 int x;
1832 char *cp;
1833
1834 if (argc >= 1){
1835 x = strtol( args[0], &cp, 0 );
1836 if( *cp != 0 ){
1837 command_print( cmd_ctx, "Not numeric: %s\n", args[0] );
1838 return ERROR_COMMAND_SYNTAX_ERROR;
1839 }
1840 USE_OLD_RESET = !!x;
1841 }
1842 command_print( cmd_ctx, "reset method: %d (%s)\n",
1843 USE_OLD_RESET,
1844 USE_OLD_RESET ? "old-method" : "new-method" );
1845 return ERROR_OK;
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 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1875
1876 if (argc == 1)
1877 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 u32 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 u32 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 /* make this exactly 1 or 0 */
3405 target->chain_position = w;
3406 } else {
3407 if( goi->argc != 0 ){
3408 goto no_params;
3409 }
3410 }
3411 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->chain_position ) );
3412 /* loop for more e*/
3413 break;
3414 }
3415 } /* while( goi->argc ) */
3416 /* done - we return */
3417 return JIM_OK;
3418 }
3419
3420
3421 /** this is the 'tcl' handler for the target specific command */
3422 static int
3423 tcl_target_func( Jim_Interp *interp,
3424 int argc,
3425 Jim_Obj *const *argv )
3426 {
3427 Jim_GetOptInfo goi;
3428 jim_wide a,b,c;
3429 int x,y,z;
3430 u8 target_buf[32];
3431 Jim_Nvp *n;
3432 target_t *target;
3433 struct command_context_s *cmd_ctx;
3434 int e;
3435
3436
3437 enum {
3438 TS_CMD_CONFIGURE,
3439 TS_CMD_CGET,
3440
3441 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3442 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3443 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3444 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3445 TS_CMD_EXAMINE,
3446 TS_CMD_POLL,
3447 TS_CMD_RESET,
3448 TS_CMD_HALT,
3449 TS_CMD_WAITSTATE,
3450 TS_CMD_EVENTLIST,
3451 TS_CMD_CURSTATE,
3452 TS_CMD_INVOKE_EVENT,
3453 };
3454
3455 static const Jim_Nvp target_options[] = {
3456 { .name = "configure", .value = TS_CMD_CONFIGURE },
3457 { .name = "cget", .value = TS_CMD_CGET },
3458 { .name = "mww", .value = TS_CMD_MWW },
3459 { .name = "mwh", .value = TS_CMD_MWH },
3460 { .name = "mwb", .value = TS_CMD_MWB },
3461 { .name = "mdw", .value = TS_CMD_MDW },
3462 { .name = "mdh", .value = TS_CMD_MDH },
3463 { .name = "mdb", .value = TS_CMD_MDB },
3464 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3465 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3466 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3467 { .name = "curstate", .value = TS_CMD_CURSTATE },
3468
3469 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3470 { .name = "arp_poll", .value = TS_CMD_POLL },
3471 { .name = "arp_reset", .value = TS_CMD_RESET },
3472 { .name = "arp_halt", .value = TS_CMD_HALT },
3473 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3474 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3475
3476 { .name = NULL, .value = -1 },
3477 };
3478
3479
3480 /* go past the "command" */
3481 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3482
3483 target = Jim_CmdPrivData( goi.interp );
3484 cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3485
3486 /* commands here are in an NVP table */
3487 e = Jim_GetOpt_Nvp( &goi, target_options, &n );
3488 if( e != JIM_OK ){
3489 Jim_GetOpt_NvpUnknown( &goi, target_options, 0 );
3490 return e;
3491 }
3492 // Assume blank result
3493 Jim_SetEmptyResult( goi.interp );
3494
3495 switch( n->value ){
3496 case TS_CMD_CONFIGURE:
3497 if( goi.argc < 2 ){
3498 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3499 return JIM_ERR;
3500 }
3501 goi.isconfigure = 1;
3502 return target_configure( &goi, target );
3503 case TS_CMD_CGET:
3504 // some things take params
3505 if( goi.argc < 1 ){
3506 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "missing: ?-option?");
3507 return JIM_ERR;
3508 }
3509 goi.isconfigure = 0;
3510 return target_configure( &goi, target );
3511 break;
3512 case TS_CMD_MWW:
3513 case TS_CMD_MWH:
3514 case TS_CMD_MWB:
3515 /* argv[0] = cmd
3516 * argv[1] = address
3517 * argv[2] = data
3518 * argv[3] = optional count.
3519 */
3520
3521 if( (goi.argc == 3) || (goi.argc == 4) ){
3522 /* all is well */
3523 } else {
3524 mwx_error:
3525 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR DATA [COUNT]", n->name );
3526 return JIM_ERR;
3527 }
3528
3529 e = Jim_GetOpt_Wide( &goi, &a );
3530 if( e != JIM_OK ){
3531 goto mwx_error;
3532 }
3533
3534 e = Jim_GetOpt_Wide( &goi, &b );
3535 if( e != JIM_OK ){
3536 goto mwx_error;
3537 }
3538 if( goi.argc ){
3539 e = Jim_GetOpt_Wide( &goi, &c );
3540 if( e != JIM_OK ){
3541 goto mwx_error;
3542 }
3543 } else {
3544 c = 1;
3545 }
3546
3547 switch( n->value ){
3548 case TS_CMD_MWW:
3549 target_buffer_set_u32( target, target_buf, b );
3550 b = 4;
3551 break;
3552 case TS_CMD_MWH:
3553 target_buffer_set_u16( target, target_buf, b );
3554 b = 2;
3555 break;
3556 case TS_CMD_MWB:
3557 target_buffer_set_u8( target, target_buf, b );
3558 b = 1;
3559 break;
3560 }
3561 for( x = 0 ; x < c ; x++ ){
3562 e = target->type->write_memory( target, a, b, 1, target_buf );
3563 if( e != ERROR_OK ){
3564 Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
3565 return JIM_ERR;
3566 }
3567 /* b = width */
3568 a = a + b;
3569 }
3570 return JIM_OK;
3571 break;
3572
3573 /* display */
3574 case TS_CMD_MDW:
3575 case TS_CMD_MDH:
3576 case TS_CMD_MDB:
3577 /* argv[0] = command
3578 * argv[1] = address
3579 * argv[2] = optional count
3580 */
3581 if( (goi.argc == 2) || (goi.argc == 3) ){
3582 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR [COUNT]", n->name );
3583 return JIM_ERR;
3584 }
3585 e = Jim_GetOpt_Wide( &goi, &a );
3586 if( e != JIM_OK ){
3587 return JIM_ERR;
3588 }
3589 if( goi.argc ){
3590 e = Jim_GetOpt_Wide( &goi, &c );
3591 if( e != JIM_OK ){
3592 return JIM_ERR;
3593 }
3594 } else {
3595 c = 1;
3596 }
3597 b = 1; /* shut up gcc */
3598 switch( n->value ){
3599 case TS_CMD_MDW:
3600 b = 4;
3601 break;
3602 case TS_CMD_MDH:
3603 b = 2;
3604 break;
3605 case TS_CMD_MDB:
3606 b = 1;
3607 break;
3608 }
3609
3610 /* convert to "bytes" */
3611 c = c * b;
3612 /* count is now in 'BYTES' */
3613 while( c > 0 ){
3614 y = c;
3615 if( y > 16 ){
3616 y = 16;
3617 }
3618 e = target->type->read_memory( target, a, b, y / b, target_buf );
3619 if( e != ERROR_OK ){
3620 Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
3621 return JIM_ERR;
3622 }
3623
3624 Jim_fprintf( interp, interp->cookie_stdout, "0x%08x ", (int)(a) );
3625 switch( b ){
3626 case 4:
3627 for( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
3628 z = target_buffer_get_u32( target, &(target_buf[ x * 4 ]) );
3629 Jim_fprintf( interp, interp->cookie_stdout, "%08x ", (int)(z) );
3630 }
3631 for( ; (x < 16) ; x += 4 ){
3632 Jim_fprintf( interp, interp->cookie_stdout, " " );
3633 }
3634 break;
3635 case 2:
3636 for( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
3637 z = target_buffer_get_u16( target, &(target_buf[ x * 2 ]) );
3638 Jim_fprintf( interp, interp->cookie_stdout, "%04x ", (int)(z) );
3639 }
3640 for( ; (x < 16) ; x += 2 ){
3641 Jim_fprintf( interp, interp->cookie_stdout, " " );
3642 }
3643 break;
3644 case 1:
3645 default:
3646 for( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
3647 z = target_buffer_get_u8( target, &(target_buf[ x * 4 ]) );
3648 Jim_fprintf( interp, interp->cookie_stdout, "%02x ", (int)(z) );
3649 }
3650 for( ; (x < 16) ; x += 1 ){
3651 Jim_fprintf( interp, interp->cookie_stdout, " " );
3652 }
3653 break;
3654 }
3655 /* ascii-ify the bytes */
3656 for( x = 0 ; x < y ; x++ ){
3657 if( (target_buf[x] >= 0x20) &&
3658 (target_buf[x] <= 0x7e) ){
3659 /* good */
3660 } else {
3661 /* smack it */
3662 target_buf[x] = '.';
3663 }
3664 }
3665 /* space pad */
3666 while( x < 16 ){
3667 target_buf[x] = ' ';
3668 x++;
3669 }
3670 /* terminate */
3671 target_buf[16] = 0;
3672 /* print - with a newline */
3673 Jim_fprintf( interp, interp->cookie_stdout, "%s\n", target_buf );
3674 /* NEXT... */
3675 c -= 16;
3676 a += 16;
3677 }
3678 return JIM_OK;
3679 case TS_CMD_MEM2ARRAY:
3680 return target_mem2array( goi.interp, target, goi.argc, goi.argv );
3681 break;
3682 case TS_CMD_ARRAY2MEM:
3683 return target_array2mem( goi.interp, target, goi.argc, goi.argv );
3684 break;
3685 case TS_CMD_EXAMINE:
3686 if( goi.argc ){
3687 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3688 return JIM_ERR;
3689 }
3690 e = target->type->examine( target );
3691 if( e != ERROR_OK ){
3692 Jim_SetResult_sprintf( interp, "examine-fails: %d", e );
3693 return JIM_ERR;
3694 }
3695 return JIM_OK;
3696 case TS_CMD_POLL:
3697 if( goi.argc ){
3698 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3699 return JIM_ERR;
3700 }
3701 if( !(target->type->examined) ){
3702 e = ERROR_TARGET_NOT_EXAMINED;
3703 } else {
3704 e = target->type->poll( target );
3705 }
3706 if( e != ERROR_OK ){
3707 Jim_SetResult_sprintf( interp, "poll-fails: %d", e );
3708 return JIM_ERR;
3709 } else {
3710 return JIM_OK;
3711 }
3712 break;
3713 case TS_CMD_RESET:
3714 if( goi.argc != 2 ){
3715 Jim_WrongNumArgs( interp, 2, argv, "t|f|assert|deassert BOOL");
3716 return JIM_ERR;
3717 }
3718 e = Jim_GetOpt_Nvp( &goi, nvp_assert, &n );
3719 if( e != JIM_OK ){
3720 Jim_GetOpt_NvpUnknown( &goi, nvp_assert, 1 );
3721 return e;
3722 }
3723 // the halt or not param
3724 e = Jim_GetOpt_Wide( &goi, &a);
3725 if( e != JIM_OK ){
3726 return e;
3727 }
3728 // determine if we should halt or not.
3729 target->reset_halt = !!a;
3730 // When this happens - all workareas are invalid.
3731 target_free_all_working_areas_restore(target, 0);
3732
3733 // do the assert
3734 if( n->value == NVP_ASSERT ){
3735 target->type->assert_reset( target );
3736 } else {
3737 target->type->deassert_reset( target );
3738 }
3739 return JIM_OK;
3740 case TS_CMD_HALT:
3741 if( goi.argc ){
3742 Jim_WrongNumArgs( goi.interp, 0, argv, "halt [no parameters]");
3743 return JIM_ERR;
3744 }
3745 target->type->halt( target );
3746 return JIM_OK;
3747 case TS_CMD_WAITSTATE:
3748 // params: <name> statename timeoutmsecs
3749 if( goi.argc != 2 ){
3750 Jim_SetResult_sprintf( goi.interp, "%s STATENAME TIMEOUTMSECS", n->name );
3751 return JIM_ERR;
3752 }
3753 e = Jim_GetOpt_Nvp( &goi, nvp_target_state, &n );
3754 if( e != JIM_OK ){
3755 Jim_GetOpt_NvpUnknown( &goi, nvp_target_state,1 );
3756 return e;
3757 }
3758 e = Jim_GetOpt_Wide( &goi, &a );
3759 if( e != JIM_OK ){
3760 return e;
3761 }
3762 e = target_wait_state( target, n->value, a );
3763 if( e != ERROR_OK ){
3764 Jim_SetResult_sprintf( goi.interp,
3765 "target: %s wait %s fails (%d) %s",
3766 target->cmd_name,
3767 n->name,
3768 e, target_strerror_safe(e) );
3769 return JIM_ERR;
3770 } else {
3771 return JIM_OK;
3772 }
3773 case TS_CMD_EVENTLIST:
3774 /* List for human, Events defined for this target.
3775 * scripts/programs should use 'name cget -event NAME'
3776 */
3777 {
3778 target_event_action_t *teap;
3779 teap = target->event_action;
3780 command_print( cmd_ctx, "Event actions for target (%d) %s\n",
3781 target->target_number,
3782 target->cmd_name );
3783 command_print( cmd_ctx, "%-25s | Body", "Event");
3784 command_print( cmd_ctx, "------------------------- | ----------------------------------------");
3785 while( teap ){
3786 command_print( cmd_ctx,
3787 "%-25s | %s",
3788 Jim_Nvp_value2name_simple( nvp_target_event, teap->event )->name,
3789 Jim_GetString( teap->body, NULL ) );
3790 teap = teap->next;
3791 }
3792 command_print( cmd_ctx, "***END***");
3793 return JIM_OK;
3794 }
3795 case TS_CMD_CURSTATE:
3796 if( goi.argc != 0 ){
3797 Jim_WrongNumArgs( goi.interp, 0, argv, "[no parameters]");
3798 return JIM_ERR;
3799 }
3800 Jim_SetResultString( goi.interp,
3801 Jim_Nvp_value2name_simple(nvp_target_state,target->state)->name,-1);
3802 return JIM_OK;
3803 case TS_CMD_INVOKE_EVENT:
3804 if( goi.argc != 1 ){
3805 Jim_SetResult_sprintf( goi.interp, "%s ?EVENTNAME?",n->name);
3806 return JIM_ERR;
3807 }
3808 e = Jim_GetOpt_Nvp( &goi, nvp_target_event, &n );
3809 if( e != JIM_OK ){
3810 Jim_GetOpt_NvpUnknown( &goi, nvp_target_event, 1 );
3811 return e;
3812 }
3813 target_handle_event( target, n->value );
3814 return JIM_OK;
3815 }
3816 return JIM_ERR;
3817 }
3818
3819
3820 static int
3821 target_create( Jim_GetOptInfo *goi )
3822 {
3823
3824 Jim_Obj *new_cmd;
3825 Jim_Cmd *cmd;
3826 const char *cp;
3827 char *cp2;
3828 int e;
3829 int x;
3830 target_t *target;
3831 struct command_context_s *cmd_ctx;
3832
3833 cmd_ctx = Jim_GetAssocData(goi->interp, "context");
3834 if( goi->argc < 3 ){
3835 Jim_WrongNumArgs( goi->interp, 1, goi->argv, "?name? ?type? ..options...");
3836 return JIM_ERR;
3837 }
3838
3839 /* COMMAND */
3840 Jim_GetOpt_Obj( goi, &new_cmd );
3841 /* does this command exist? */
3842 cmd = Jim_GetCommand( goi->interp, new_cmd, JIM_ERRMSG );
3843 if( cmd ){
3844 cp = Jim_GetString( new_cmd, NULL );
3845 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
3846 return JIM_ERR;
3847 }
3848
3849 /* TYPE */
3850 e = Jim_GetOpt_String( goi, &cp2, NULL );
3851 cp = cp2;
3852 /* now does target type exist */
3853 for( x = 0 ; target_types[x] ; x++ ){
3854 if( 0 == strcmp( cp, target_types[x]->name ) ){
3855 /* found */
3856 break;
3857 }
3858 }
3859 if( target_types[x] == NULL ){
3860 Jim_SetResult_sprintf( goi->interp, "Unknown target type %s, try one of ", cp );
3861 for( x = 0 ; target_types[x] ; x++ ){
3862 if( target_types[x+1] ){
3863 Jim_AppendStrings( goi->interp,
3864 Jim_GetResult(goi->interp),
3865 target_types[x]->name,
3866 ", ", NULL);
3867 } else {
3868 Jim_AppendStrings( goi->interp,
3869 Jim_GetResult(goi->interp),
3870 " or ",
3871 target_types[x]->name,NULL );
3872 }
3873 }
3874 return JIM_ERR;
3875 }
3876
3877
3878 /* Create it */
3879 target = calloc(1,sizeof(target_t));
3880 /* set target number */
3881 target->target_number = new_target_number();
3882
3883 /* allocate memory for each unique target type */
3884 target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
3885
3886 memcpy( target->type, target_types[x], sizeof(target_type_t));
3887
3888 /* will be set by "-endian" */
3889 target->endianness = TARGET_ENDIAN_UNKNOWN;
3890
3891 target->working_area = 0x0;
3892 target->working_area_size = 0x0;
3893 target->working_areas = NULL;
3894 target->backup_working_area = 0;
3895
3896 target->state = TARGET_UNKNOWN;
3897 target->debug_reason = DBG_REASON_UNDEFINED;
3898 target->reg_cache = NULL;
3899 target->breakpoints = NULL;
3900 target->watchpoints = NULL;
3901 target->next = NULL;
3902 target->arch_info = NULL;
3903
3904 /* initialize trace information */
3905 target->trace_info = malloc(sizeof(trace_t));
3906 target->trace_info->num_trace_points = 0;
3907 target->trace_info->trace_points_size = 0;
3908 target->trace_info->trace_points = NULL;
3909 target->trace_info->trace_history_size = 0;
3910 target->trace_info->trace_history = NULL;
3911 target->trace_info->trace_history_pos = 0;
3912 target->trace_info->trace_history_overflowed = 0;
3913
3914 target->dbgmsg = NULL;
3915 target->dbg_msg_enabled = 0;
3916
3917 target->endianness = TARGET_ENDIAN_UNKNOWN;
3918
3919 /* Do the rest as "configure" options */
3920 goi->isconfigure = 1;
3921 e = target_configure( goi, target);
3922 if( e != JIM_OK ){
3923 free( target->type );
3924 free( target );
3925 return e;
3926 }
3927
3928 if( target->endianness == TARGET_ENDIAN_UNKNOWN ){
3929 /* default endian to little if not specified */
3930 target->endianness = TARGET_LITTLE_ENDIAN;
3931 }
3932
3933 /* create the target specific commands */
3934 if( target->type->register_commands ){
3935 (*(target->type->register_commands))( cmd_ctx );
3936 }
3937 if( target->type->target_create ){
3938 (*(target->type->target_create))( target, goi->interp );
3939 }
3940
3941 /* append to end of list */
3942 {
3943 target_t **tpp;
3944 tpp = &(all_targets);
3945 while( *tpp ){
3946 tpp = &( (*tpp)->next );
3947 }
3948 *tpp = target;
3949 }
3950
3951 cp = Jim_GetString( new_cmd, NULL );
3952 target->cmd_name = strdup(cp);
3953
3954 /* now - create the new target name command */
3955 e = Jim_CreateCommand( goi->interp,
3956 /* name */
3957 cp,
3958 tcl_target_func, /* C function */
3959 target, /* private data */
3960 NULL ); /* no del proc */
3961
3962 (*(target->type->target_create))( target, goi->interp );
3963 return e;
3964 }
3965
3966 static int
3967 jim_target( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
3968 {
3969 int x,r,e;
3970 jim_wide w;
3971 struct command_context_s *cmd_ctx;
3972 const char *cp;
3973 target_t *target;
3974 Jim_GetOptInfo goi;
3975 enum tcmd {
3976 /* TG = target generic */
3977 TG_CMD_CREATE,
3978 TG_CMD_TYPES,
3979 TG_CMD_NAMES,
3980 TG_CMD_CURRENT,
3981 TG_CMD_NUMBER,
3982 TG_CMD_COUNT,
3983 };
3984 const char *target_cmds[] = {
3985 "create", "types", "names", "current", "number",
3986 "count",
3987 NULL // terminate
3988 };
3989
3990 LOG_DEBUG("Target command params:");
3991 LOG_DEBUG(Jim_Debug_ArgvString( interp, argc, argv) );
3992
3993 cmd_ctx = Jim_GetAssocData( interp, "context" );
3994
3995 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3996
3997 if( goi.argc == 0 ){
3998 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
3999 return JIM_ERR;
4000 }
4001
4002 /* is this old syntax? */
4003 /* To determine: We have to peek at argv[0]*/
4004 cp = Jim_GetString( goi.argv[0], NULL );
4005 for( x = 0 ; target_types[x] ; x++ ){
4006 if( 0 == strcmp(cp,target_types[x]->name) ){
4007 break;
4008 }
4009 }
4010 if( target_types[x] ){
4011 /* YES IT IS OLD SYNTAX */
4012 Jim_Obj *new_argv[10];
4013 int new_argc;
4014
4015 /* target_old_syntax
4016 *
4017 * argv[0] typename (above)
4018 * argv[1] endian
4019 * argv[2] reset method, deprecated/ignored
4020 * argv[3] = old param
4021 * argv[4] = old param
4022 *
4023 * We will combine all "old params" into a single param.
4024 * Then later, split them again.
4025 */
4026 if( argc < 4 ){
4027 Jim_WrongNumArgs( interp, 1, argv, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?RESET? ?old-params?");
4028 return JIM_ERR;
4029 }
4030 /* the command */
4031 new_argv[0] = argv[0];
4032 new_argv[1] = Jim_NewStringObj( interp, "create", -1 );
4033 {
4034 char buf[ 30 ];
4035 sprintf( buf, "target%d", new_target_number() );
4036 new_argv[2] = Jim_NewStringObj( interp, buf , -1 );
4037 }
4038 new_argv[3] = goi.argv[0]; /* typename */
4039 new_argv[4] = Jim_NewStringObj( interp, "-endian", -1 );
4040 new_argv[5] = goi.argv[1];
4041 new_argv[6] = Jim_NewStringObj( interp, "-chain-position", -1 );
4042 new_argv[7] = goi.argv[2];
4043 new_argv[8] = Jim_NewStringObj( interp, "-variant", -1 );
4044 new_argv[9] = goi.argv[3];
4045 new_argc = 10;
4046 /*
4047 * new arg syntax:
4048 * argv[0] = command
4049 * argv[1] = create
4050 * argv[2] = cmdname
4051 * argv[3] = typename
4052 * argv[4] = **FIRST** "configure" option.
4053 *
4054 * Here, we make them:
4055 *
4056 * argv[4] = -endian
4057 * argv[5] = little
4058 * argv[6] = -position
4059 * argv[7] = NUMBER
4060 * argv[8] = -variant
4061 * argv[9] = "somestring"
4062 */
4063
4064 /* don't let these be released */
4065 for( x = 0 ; x < new_argc ; x++ ){
4066 Jim_IncrRefCount( new_argv[x]);
4067 }
4068 /* call our self */
4069 LOG_DEBUG("Target OLD SYNTAX - converted to new syntax");
4070
4071 r = jim_target( goi.interp, new_argc, new_argv );
4072
4073 /* release? these items */
4074 for( x = 0 ; x < new_argc ; x++ ){
4075 Jim_DecrRefCount( interp, new_argv[x] );
4076 }
4077 return r;
4078 }
4079
4080 //Jim_GetOpt_Debug( &goi );
4081 r = Jim_GetOpt_Enum( &goi, target_cmds, &x );
4082 if( r != JIM_OK ){
4083 return r;
4084 }
4085
4086 switch(x){
4087 default:
4088 Jim_Panic(goi.interp,"Why am I here?");
4089 return JIM_ERR;
4090 case TG_CMD_CURRENT:
4091 if( goi.argc != 0 ){
4092 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters");
4093 return JIM_ERR;
4094 }
4095 Jim_SetResultString( goi.interp, get_current_target( cmd_ctx )->cmd_name, -1 );
4096 return JIM_OK;
4097 case TG_CMD_TYPES:
4098 if( goi.argc != 0 ){
4099 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4100 return JIM_ERR;
4101 }
4102 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4103 for( x = 0 ; target_types[x] ; x++ ){
4104 Jim_ListAppendElement( goi.interp,
4105 Jim_GetResult(goi.interp),
4106 Jim_NewStringObj( goi.interp, target_types[x]->name, -1 ) );
4107 }
4108 return JIM_OK;
4109 case TG_CMD_NAMES:
4110 if( goi.argc != 0 ){
4111 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4112 return JIM_ERR;
4113 }
4114 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4115 target = all_targets;
4116 while( target ){
4117 Jim_ListAppendElement( goi.interp,
4118 Jim_GetResult(goi.interp),
4119 Jim_NewStringObj( goi.interp, target->cmd_name, -1 ) );
4120 target = target->next;
4121 }
4122 return JIM_OK;
4123 case TG_CMD_CREATE:
4124 if( goi.argc < 3 ){
4125 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "?name ... config options ...");
4126 return JIM_ERR;
4127 }
4128 return target_create( &goi );
4129 break;
4130 case TG_CMD_NUMBER:
4131 if( goi.argc != 1 ){
4132 Jim_SetResult_sprintf( goi.interp, "expected: target number ?NUMBER?");
4133 return JIM_ERR;
4134 }
4135 e = Jim_GetOpt_Wide( &goi, &w );
4136 if( e != JIM_OK ){
4137 return JIM_ERR;
4138 }
4139 {
4140 target_t *t;
4141 t = get_target_by_num(w);
4142 if( t == NULL ){
4143 Jim_SetResult_sprintf( goi.interp,"Target: number %d does not exist", (int)(w));
4144 return JIM_ERR;
4145 }
4146 Jim_SetResultString( goi.interp, t->cmd_name, -1 );
4147 return JIM_OK;
4148 }
4149 case TG_CMD_COUNT:
4150 if( goi.argc != 0 ){
4151 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "<no parameters>");
4152 return JIM_ERR;
4153 }
4154 Jim_SetResult( goi.interp,
4155 Jim_NewIntObj( goi.interp, max_target_number()));
4156 return JIM_OK;
4157 }
4158
4159 return JIM_ERR;
4160 }
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)