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