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