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