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