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