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