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