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 ); */