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