Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Factor load_image argument parsing to parse_load_image_command_args:
[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_continous_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_continous_poll;
440 target_continous_poll = 0;
441
442 sprintf( buf, "ocd_process_reset %s", n->name );
443 retval = Jim_Eval( interp, buf );
444
445 target_continous_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 target_t *target = all_targets;
1654
1655 while (target)
1656 {
1657
1658 /* only poll target if we've got power and srst isn't asserted */
1659 if (target_continous_poll&&!powerDropout&&!srstAsserted)
1660 {
1661 /* polling may fail silently until the target has been examined */
1662 if((retval = target_poll(target)) != ERROR_OK)
1663 return retval;
1664 }
1665
1666 target = target->next;
1667 }
1668
1669 return retval;
1670 }
1671
1672 static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1673 {
1674 target_t *target;
1675 reg_t *reg = NULL;
1676 int count = 0;
1677 char *value;
1678
1679 LOG_DEBUG("-");
1680
1681 target = get_current_target(cmd_ctx);
1682
1683 /* list all available registers for the current target */
1684 if (argc == 0)
1685 {
1686 reg_cache_t *cache = target->reg_cache;
1687
1688 count = 0;
1689 while(cache)
1690 {
1691 int i;
1692 for (i = 0; i < cache->num_regs; i++)
1693 {
1694 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1695 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);
1696 free(value);
1697 }
1698 cache = cache->next;
1699 }
1700
1701 return ERROR_OK;
1702 }
1703
1704 /* access a single register by its ordinal number */
1705 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1706 {
1707 unsigned num;
1708 int retval = parse_uint(args[0], &num);
1709 if (ERROR_OK != retval)
1710 return ERROR_COMMAND_SYNTAX_ERROR;
1711
1712 reg_cache_t *cache = target->reg_cache;
1713 count = 0;
1714 while(cache)
1715 {
1716 int i;
1717 for (i = 0; i < cache->num_regs; i++)
1718 {
1719 if (count++ == (int)num)
1720 {
1721 reg = &cache->reg_list[i];
1722 break;
1723 }
1724 }
1725 if (reg)
1726 break;
1727 cache = cache->next;
1728 }
1729
1730 if (!reg)
1731 {
1732 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1733 return ERROR_OK;
1734 }
1735 } else /* access a single register by its name */
1736 {
1737 reg = register_get_by_name(target->reg_cache, args[0], 1);
1738
1739 if (!reg)
1740 {
1741 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1742 return ERROR_OK;
1743 }
1744 }
1745
1746 /* display a register */
1747 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1748 {
1749 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1750 reg->valid = 0;
1751
1752 if (reg->valid == 0)
1753 {
1754 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1755 arch_type->get(reg);
1756 }
1757 value = buf_to_str(reg->value, reg->size, 16);
1758 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1759 free(value);
1760 return ERROR_OK;
1761 }
1762
1763 /* set register value */
1764 if (argc == 2)
1765 {
1766 u8 *buf = malloc(CEIL(reg->size, 8));
1767 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1768
1769 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1770 arch_type->set(reg, buf);
1771
1772 value = buf_to_str(reg->value, reg->size, 16);
1773 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1774 free(value);
1775
1776 free(buf);
1777
1778 return ERROR_OK;
1779 }
1780
1781 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1782
1783 return ERROR_OK;
1784 }
1785
1786 static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1787 {
1788 int retval = ERROR_OK;
1789 target_t *target = get_current_target(cmd_ctx);
1790
1791 if (argc == 0)
1792 {
1793 command_print(cmd_ctx, "background polling: %s",
1794 target_continous_poll ? "on" : "off");
1795 if ((retval = target_poll(target)) != ERROR_OK)
1796 return retval;
1797 if ((retval = target_arch_state(target)) != ERROR_OK)
1798 return retval;
1799
1800 }
1801 else if (argc==1)
1802 {
1803 if (strcmp(args[0], "on") == 0)
1804 {
1805 target_continous_poll = 1;
1806 }
1807 else if (strcmp(args[0], "off") == 0)
1808 {
1809 target_continous_poll = 0;
1810 }
1811 else
1812 {
1813 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1814 }
1815 } else
1816 {
1817 return ERROR_COMMAND_SYNTAX_ERROR;
1818 }
1819
1820 return retval;
1821 }
1822
1823 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1824 {
1825 if (argc > 1)
1826 return ERROR_COMMAND_SYNTAX_ERROR;
1827
1828 unsigned ms = 5000;
1829 if (1 == argc)
1830 {
1831 int retval = parse_uint(args[0], &ms);
1832 if (ERROR_OK != retval)
1833 {
1834 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1835 return ERROR_COMMAND_SYNTAX_ERROR;
1836 }
1837 // convert seconds (given) to milliseconds (needed)
1838 ms *= 1000;
1839 }
1840
1841 target_t *target = get_current_target(cmd_ctx);
1842 return target_wait_state(target, TARGET_HALTED, ms);
1843 }
1844
1845 /* wait for target state to change. The trick here is to have a low
1846 * latency for short waits and not to suck up all the CPU time
1847 * on longer waits.
1848 *
1849 * After 500ms, keep_alive() is invoked
1850 */
1851 int target_wait_state(target_t *target, enum target_state state, int ms)
1852 {
1853 int retval;
1854 long long then=0, cur;
1855 int once=1;
1856
1857 for (;;)
1858 {
1859 if ((retval=target_poll(target))!=ERROR_OK)
1860 return retval;
1861 if (target->state == state)
1862 {
1863 break;
1864 }
1865 cur = timeval_ms();
1866 if (once)
1867 {
1868 once=0;
1869 then = timeval_ms();
1870 LOG_DEBUG("waiting for target %s...",
1871 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
1872 }
1873
1874 if (cur-then>500)
1875 {
1876 keep_alive();
1877 }
1878
1879 if ((cur-then)>ms)
1880 {
1881 LOG_ERROR("timed out while waiting for target %s",
1882 Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
1883 return ERROR_FAIL;
1884 }
1885 }
1886
1887 return ERROR_OK;
1888 }
1889
1890 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1891 {
1892 LOG_DEBUG("-");
1893
1894 target_t *target = get_current_target(cmd_ctx);
1895 int retval = target_halt(target);
1896 if (ERROR_OK != retval)
1897 return retval;
1898
1899 if (argc == 1)
1900 {
1901 unsigned wait;
1902 retval = parse_uint(args[0], &wait);
1903 if (ERROR_OK != retval)
1904 return ERROR_COMMAND_SYNTAX_ERROR;
1905 if (!wait)
1906 return ERROR_OK;
1907 }
1908
1909 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1910 }
1911
1912 static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1913 {
1914 target_t *target = get_current_target(cmd_ctx);
1915
1916 LOG_USER("requesting target halt and executing a soft reset");
1917
1918 target->type->soft_reset_halt(target);
1919
1920 return ERROR_OK;
1921 }
1922
1923 static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1924 {
1925 if (argc > 1)
1926 return ERROR_COMMAND_SYNTAX_ERROR;
1927
1928 enum target_reset_mode reset_mode = RESET_RUN;
1929 if (argc == 1)
1930 {
1931 const Jim_Nvp *n;
1932 n = Jim_Nvp_name2value_simple( nvp_reset_modes, args[0] );
1933 if( (n->name == NULL) || (n->value == RESET_UNKNOWN) ){
1934 return ERROR_COMMAND_SYNTAX_ERROR;
1935 }
1936 reset_mode = n->value;
1937 }
1938
1939 /* reset *all* targets */
1940 return target_process_reset(cmd_ctx, reset_mode);
1941 }
1942
1943
1944 static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1945 {
1946 if (argc > 1)
1947 return ERROR_COMMAND_SYNTAX_ERROR;
1948
1949 target_t *target = get_current_target(cmd_ctx);
1950 target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
1951
1952 /* with no args, resume from current pc, addr = 0,
1953 * with one arguments, addr = args[0],
1954 * handle breakpoints, not debugging */
1955 u32 addr = 0;
1956 if (argc == 1)
1957 {
1958 int retval = parse_u32(args[0], &addr);
1959 if (ERROR_OK != retval)
1960 return retval;
1961 }
1962
1963 return target_resume(target, 0, addr, 1, 0);
1964 }
1965
1966 static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1967 {
1968 if (argc > 1)
1969 return ERROR_COMMAND_SYNTAX_ERROR;
1970
1971 LOG_DEBUG("-");
1972
1973 /* with no args, step from current pc, addr = 0,
1974 * with one argument addr = args[0],
1975 * handle breakpoints, debugging */
1976 u32 addr = 0;
1977 if (argc == 1)
1978 {
1979 int retval = parse_u32(args[0], &addr);
1980 if (ERROR_OK != retval)
1981 return retval;
1982 }
1983
1984 target_t *target = get_current_target(cmd_ctx);
1985 return target->type->step(target, 0, addr, 1);
1986 }
1987
1988 static void handle_md_output(struct command_context_s *cmd_ctx,
1989 struct target_s *target, u32 address, unsigned size,
1990 unsigned count, const u8 *buffer)
1991 {
1992 const unsigned line_bytecnt = 32;
1993 unsigned line_modulo = line_bytecnt / size;
1994
1995 char output[line_bytecnt * 4 + 1];
1996 unsigned output_len = 0;
1997
1998 const char *value_fmt;
1999 switch (size) {
2000 case 4: value_fmt = "%8.8x "; break;
2001 case 2: value_fmt = "%4.2x "; break;
2002 case 1: value_fmt = "%2.2x "; break;
2003 default:
2004 LOG_ERROR("invalid memory read size: %u", size);
2005 exit(-1);
2006 }
2007
2008 for (unsigned i = 0; i < count; i++)
2009 {
2010 if (i % line_modulo == 0)
2011 {
2012 output_len += snprintf(output + output_len,
2013 sizeof(output) - output_len,
2014 "0x%8.8x: ", address + (i*size));
2015 }
2016
2017 u32 value=0;
2018 const u8 *value_ptr = buffer + i * size;
2019 switch (size) {
2020 case 4: value = target_buffer_get_u32(target, value_ptr); break;
2021 case 2: value = target_buffer_get_u16(target, value_ptr); break;
2022 case 1: value = *value_ptr;
2023 }
2024 output_len += snprintf(output + output_len,
2025 sizeof(output) - output_len,
2026 value_fmt, value);
2027
2028 if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
2029 {
2030 command_print(cmd_ctx, "%s", output);
2031 output_len = 0;
2032 }
2033 }
2034 }
2035
2036 static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2037 {
2038 if (argc < 1)
2039 return ERROR_COMMAND_SYNTAX_ERROR;
2040
2041 unsigned size = 0;
2042 switch (cmd[2]) {
2043 case 'w': size = 4; break;
2044 case 'h': size = 2; break;
2045 case 'b': size = 1; break;
2046 default: return ERROR_COMMAND_SYNTAX_ERROR;
2047 }
2048
2049 u32 address;
2050 int retval = parse_u32(args[0], &address);
2051 if (ERROR_OK != retval)
2052 return retval;
2053
2054 unsigned count = 1;
2055 if (argc == 2)
2056 {
2057 retval = parse_uint(args[1], &count);
2058 if (ERROR_OK != retval)
2059 return retval;
2060 }
2061
2062 u8 *buffer = calloc(count, size);
2063
2064 target_t *target = get_current_target(cmd_ctx);
2065 retval = target_read_memory(target,
2066 address, size, count, buffer);
2067 if (ERROR_OK == retval)
2068 handle_md_output(cmd_ctx, target, address, size, count, buffer);
2069
2070 free(buffer);
2071
2072 return retval;
2073 }
2074
2075 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2076 {
2077 if ((argc < 2) || (argc > 3))
2078 return ERROR_COMMAND_SYNTAX_ERROR;
2079
2080 u32 address;
2081 int retval = parse_u32(args[0], &address);
2082 if (ERROR_OK != retval)
2083 return retval;
2084
2085 u32 value;
2086 retval = parse_u32(args[1], &value);
2087 if (ERROR_OK != retval)
2088 return retval;
2089
2090 unsigned count = 1;
2091 if (argc == 3)
2092 {
2093 retval = parse_uint(args[2], &count);
2094 if (ERROR_OK != retval)
2095 return retval;
2096 }
2097
2098 target_t *target = get_current_target(cmd_ctx);
2099 unsigned wordsize;
2100 u8 value_buf[4];
2101 switch (cmd[2])
2102 {
2103 case 'w':
2104 wordsize = 4;
2105 target_buffer_set_u32(target, value_buf, value);
2106 break;
2107 case 'h':
2108 wordsize = 2;
2109 target_buffer_set_u16(target, value_buf, value);
2110 break;
2111 case 'b':
2112 wordsize = 1;
2113 value_buf[0] = value;
2114 break;
2115 default:
2116 return ERROR_COMMAND_SYNTAX_ERROR;
2117 }
2118 for (unsigned i = 0; i < count; i++)
2119 {
2120 retval = target_write_memory(target,
2121 address + i * wordsize, wordsize, 1, value_buf);
2122 if (ERROR_OK != retval)
2123 return retval;
2124 keep_alive();
2125 }
2126
2127 return ERROR_OK;
2128
2129 }
2130
2131 static int parse_load_image_command_args(char **args, int argc,
2132 image_t *image, u32 *min_address, u32 *max_address)
2133 {
2134 if (argc < 1 || argc > 5)
2135 return ERROR_COMMAND_SYNTAX_ERROR;
2136
2137 /* a base address isn't always necessary,
2138 * default to 0x0 (i.e. don't relocate) */
2139 if (argc >= 2)
2140 {
2141 u32 addr;
2142 int retval = parse_u32(args[1], &addr);
2143 if (ERROR_OK != retval)
2144 return ERROR_COMMAND_SYNTAX_ERROR;
2145 image->base_address = addr;
2146 image->base_address_set = 1;
2147 }
2148 else
2149 image->base_address_set = 0;
2150
2151 image->start_address_set = 0;
2152
2153 if (argc >= 4)
2154 {
2155 int retval = parse_u32(args[3], min_address);
2156 if (ERROR_OK != retval)
2157 return ERROR_COMMAND_SYNTAX_ERROR;
2158 }
2159 if (argc == 5)
2160 {
2161 int retval = parse_u32(args[4], max_address);
2162 if (ERROR_OK != retval)
2163 return ERROR_COMMAND_SYNTAX_ERROR;
2164 // use size (given) to find max (required)
2165 *max_address += *min_address;
2166 }
2167
2168 if (*min_address > *max_address)
2169 return ERROR_COMMAND_SYNTAX_ERROR;
2170
2171 return ERROR_OK;
2172 }
2173
2174 static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2175 {
2176 u8 *buffer;
2177 u32 buf_cnt;
2178 u32 image_size;
2179 u32 min_address = 0;
2180 u32 max_address = 0xffffffff;
2181 int i;
2182 int retvaltemp;
2183
2184 image_t image;
2185
2186 duration_t duration;
2187 char *duration_text;
2188
2189 int retval = parse_load_image_command_args(args, argc,
2190 &image, &min_address, &max_address);
2191 if (ERROR_OK != retval)
2192 return retval;
2193
2194 target_t *target = get_current_target(cmd_ctx);
2195 duration_start_measure(&duration);
2196
2197 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2198 {
2199 return ERROR_OK;
2200 }
2201
2202 image_size = 0x0;
2203 retval = ERROR_OK;
2204 for (i = 0; i < image.num_sections; i++)
2205 {
2206 buffer = malloc(image.sections[i].size);
2207 if (buffer == NULL)
2208 {
2209 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2210 break;
2211 }
2212
2213 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2214 {
2215 free(buffer);
2216 break;
2217 }
2218
2219 u32 offset=0;
2220 u32 length=buf_cnt;
2221
2222 /* DANGER!!! beware of unsigned comparision here!!! */
2223
2224 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
2225 (image.sections[i].base_address<max_address))
2226 {
2227 if (image.sections[i].base_address<min_address)
2228 {
2229 /* clip addresses below */
2230 offset+=min_address-image.sections[i].base_address;
2231 length-=offset;
2232 }
2233
2234 if (image.sections[i].base_address+buf_cnt>max_address)
2235 {
2236 length-=(image.sections[i].base_address+buf_cnt)-max_address;
2237 }
2238
2239 if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
2240 {
2241 free(buffer);
2242 break;
2243 }
2244 image_size += length;
2245 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
2246 }
2247
2248 free(buffer);
2249 }
2250
2251 if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2252 {
2253 image_close(&image);
2254 return retvaltemp;
2255 }
2256
2257 if (retval==ERROR_OK)
2258 {
2259 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2260 }
2261 free(duration_text);
2262
2263 image_close(&image);
2264
2265 return retval;
2266
2267 }
2268
2269 static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2270 {
2271 fileio_t fileio;
2272
2273 u8 buffer[560];
2274 int retvaltemp;
2275
2276 duration_t duration;
2277 char *duration_text;
2278
2279 target_t *target = get_current_target(cmd_ctx);
2280
2281 if (argc != 3)
2282 {
2283 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2284 return ERROR_OK;
2285 }
2286
2287 u32 address;
2288 int retval = parse_u32(args[1], &address);
2289 if (ERROR_OK != retval)
2290 return retval;
2291
2292 u32 size;
2293 retval = parse_u32(args[2], &size);
2294 if (ERROR_OK != retval)
2295 return retval;
2296
2297 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2298 {
2299 return ERROR_OK;
2300 }
2301
2302 duration_start_measure(&duration);
2303
2304 while (size > 0)
2305 {
2306 u32 size_written;
2307 u32 this_run_size = (size > 560) ? 560 : size;
2308
2309 retval = target_read_buffer(target, address, this_run_size, buffer);
2310 if (retval != ERROR_OK)
2311 {
2312 break;
2313 }
2314
2315 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2316 if (retval != ERROR_OK)
2317 {
2318 break;
2319 }
2320
2321 size -= this_run_size;
2322 address += this_run_size;
2323 }
2324
2325 if((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
2326 return retvaltemp;
2327
2328 if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2329 return retvaltemp;
2330
2331 if (retval==ERROR_OK)
2332 {
2333 command_print(cmd_ctx, "dumped %lld byte in %s",
2334 fileio.size, duration_text);
2335 free(duration_text);
2336 }
2337
2338 return retval;
2339 }
2340
2341 static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
2342 {
2343 u8 *buffer;
2344 u32 buf_cnt;
2345 u32 image_size;
2346 int i;
2347 int retval, retvaltemp;
2348 u32 checksum = 0;
2349 u32 mem_checksum = 0;
2350
2351 image_t image;
2352
2353 duration_t duration;
2354 char *duration_text;
2355
2356 target_t *target = get_current_target(cmd_ctx);
2357
2358 if (argc < 1)
2359 {
2360 return ERROR_COMMAND_SYNTAX_ERROR;
2361 }
2362
2363 if (!target)
2364 {
2365 LOG_ERROR("no target selected");
2366 return ERROR_FAIL;
2367 }
2368
2369 duration_start_measure(&duration);
2370
2371 if (argc >= 2)
2372 {
2373 u32 addr;
2374 retval = parse_u32(args[1], &addr);
2375 if (ERROR_OK != retval)
2376 return ERROR_COMMAND_SYNTAX_ERROR;
2377 image.base_address = addr;
2378 image.base_address_set = 1;
2379 }
2380 else
2381 {
2382 image.base_address_set = 0;
2383 image.base_address = 0x0;
2384 }
2385
2386 image.start_address_set = 0;
2387
2388 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2389 {
2390 return retval;
2391 }
2392
2393 image_size = 0x0;
2394 retval=ERROR_OK;
2395 for (i = 0; i < image.num_sections; i++)
2396 {
2397 buffer = malloc(image.sections[i].size);
2398 if (buffer == NULL)
2399 {
2400 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2401 break;
2402 }
2403 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2404 {
2405 free(buffer);
2406 break;
2407 }
2408
2409 if (verify)
2410 {
2411 /* calculate checksum of image */
2412 image_calculate_checksum( buffer, buf_cnt, &checksum );
2413
2414 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2415 if( retval != ERROR_OK )
2416 {
2417 free(buffer);
2418 break;
2419 }
2420
2421 if( checksum != mem_checksum )
2422 {
2423 /* failed crc checksum, fall back to a binary compare */
2424 u8 *data;
2425
2426 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2427
2428 data = (u8*)malloc(buf_cnt);
2429
2430 /* Can we use 32bit word accesses? */
2431 int size = 1;
2432 int count = buf_cnt;
2433 if ((count % 4) == 0)
2434 {
2435 size *= 4;
2436 count /= 4;
2437 }
2438 retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
2439 if (retval == ERROR_OK)
2440 {
2441 u32 t;
2442 for (t = 0; t < buf_cnt; t++)
2443 {
2444 if (data[t] != buffer[t])
2445 {
2446 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]);
2447 free(data);
2448 free(buffer);
2449 retval=ERROR_FAIL;
2450 goto done;
2451 }
2452 if ((t%16384)==0)
2453 {
2454 keep_alive();
2455 }
2456 }
2457 }
2458
2459 free(data);
2460 }
2461 } else
2462 {
2463 command_print(cmd_ctx, "address 0x%08x length 0x%08x", image.sections[i].base_address, buf_cnt);
2464 }
2465
2466 free(buffer);
2467 image_size += buf_cnt;
2468 }
2469 done:
2470
2471 if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
2472 {
2473 image_close(&image);
2474 return retvaltemp;
2475 }
2476
2477 if (retval==ERROR_OK)
2478 {
2479 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2480 }
2481 free(duration_text);
2482
2483 image_close(&image);
2484
2485 return retval;
2486 }
2487
2488 static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2489 {
2490 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
2491 }
2492
2493 static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2494 {
2495 return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
2496 }
2497
2498 static int handle_bp_command_list(struct command_context_s *cmd_ctx)
2499 {
2500 target_t *target = get_current_target(cmd_ctx);
2501 breakpoint_t *breakpoint = target->breakpoints;
2502 while (breakpoint)
2503 {
2504 if (breakpoint->type == BKPT_SOFT)
2505 {
2506 char* buf = buf_to_str(breakpoint->orig_instr,
2507 breakpoint->length, 16);
2508 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s",
2509 breakpoint->address, breakpoint->length,
2510 breakpoint->set, buf);
2511 free(buf);
2512 }
2513 else
2514 {
2515 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i",
2516 breakpoint->address, breakpoint->length, breakpoint->set);
2517 }
2518
2519 breakpoint = breakpoint->next;
2520 }
2521 return ERROR_OK;
2522 }
2523
2524 static int handle_bp_command_set(struct command_context_s *cmd_ctx,
2525 u32 addr, u32 length, int hw)
2526 {
2527 target_t *target = get_current_target(cmd_ctx);
2528 int retval = breakpoint_add(target, addr, length, hw);
2529 if (ERROR_OK == retval)
2530 command_print(cmd_ctx, "breakpoint set at 0x%8.8x", addr);
2531 else
2532 LOG_ERROR("Failure setting breakpoint");
2533 return retval;
2534 }
2535
2536 static int handle_bp_command(struct command_context_s *cmd_ctx,
2537 char *cmd, char **args, int argc)
2538 {
2539 if (argc == 0)
2540 return handle_bp_command_list(cmd_ctx);
2541
2542 if (argc < 2 || argc > 3)
2543 {
2544 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2545 return ERROR_COMMAND_SYNTAX_ERROR;
2546 }
2547
2548 u32 addr;
2549 int retval = parse_u32(args[0], &addr);
2550 if (ERROR_OK != retval)
2551 return retval;
2552
2553 u32 length;
2554 retval = parse_u32(args[1], &length);
2555 if (ERROR_OK != retval)
2556 return retval;
2557
2558 int hw = BKPT_SOFT;
2559 if (argc == 3)
2560 {
2561 if (strcmp(args[2], "hw") == 0)
2562 hw = BKPT_HARD;
2563 else
2564 return ERROR_COMMAND_SYNTAX_ERROR;
2565 }
2566
2567 return handle_bp_command_set(cmd_ctx, addr, length, hw);
2568 }
2569
2570 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2571 {
2572 if (argc != 1)
2573 return ERROR_COMMAND_SYNTAX_ERROR;
2574
2575 u32 addr;
2576 int retval = parse_u32(args[0], &addr);
2577 if (ERROR_OK != retval)
2578 return retval;
2579
2580 target_t *target = get_current_target(cmd_ctx);
2581 breakpoint_remove(target, addr);
2582
2583 return ERROR_OK;
2584 }
2585
2586 static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2587 {
2588 target_t *target = get_current_target(cmd_ctx);
2589
2590 if (argc == 0)
2591 {
2592 watchpoint_t *watchpoint = target->watchpoints;
2593
2594 while (watchpoint)
2595 {
2596 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);
2597 watchpoint = watchpoint->next;
2598 }
2599 return ERROR_OK;
2600 }
2601
2602 enum watchpoint_rw type = WPT_ACCESS;
2603 u32 addr = 0;
2604 u32 length = 0;
2605 u32 data_value = 0x0;
2606 u32 data_mask = 0xffffffff;
2607 int retval;
2608
2609 switch (argc)
2610 {
2611 case 5:
2612 retval = parse_u32(args[4], &data_mask);
2613 if (ERROR_OK != retval)
2614 return retval;
2615 // fall through
2616 case 4:
2617 retval = parse_u32(args[3], &data_value);
2618 if (ERROR_OK != retval)
2619 return retval;
2620 // fall through
2621 case 3:
2622 switch(args[2][0])
2623 {
2624 case 'r':
2625 type = WPT_READ;
2626 break;
2627 case 'w':
2628 type = WPT_WRITE;
2629 break;
2630 case 'a':
2631 type = WPT_ACCESS;
2632 break;
2633 default:
2634 LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]);
2635 return ERROR_COMMAND_SYNTAX_ERROR;
2636 }
2637 // fall through
2638 case 2:
2639 retval = parse_u32(args[1], &length);
2640 if (ERROR_OK != retval)
2641 return retval;
2642 retval = parse_u32(args[0], &addr);
2643 if (ERROR_OK != retval)
2644 return retval;
2645 break;
2646
2647 default:
2648 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2649 return ERROR_COMMAND_SYNTAX_ERROR;
2650 }
2651
2652 retval = watchpoint_add(target, addr, length, type,
2653 data_value, data_mask);
2654 if (ERROR_OK != retval)
2655 LOG_ERROR("Failure setting watchpoints");
2656
2657 return retval;
2658 }
2659
2660 static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2661 {
2662 if (argc != 1)
2663 return ERROR_COMMAND_SYNTAX_ERROR;
2664
2665 u32 addr;
2666 int retval = parse_u32(args[0], &addr);
2667 if (ERROR_OK != retval)
2668 return retval;
2669
2670 target_t *target = get_current_target(cmd_ctx);
2671 watchpoint_remove(target, addr);
2672
2673 return ERROR_OK;
2674 }
2675
2676
2677 /**
2678 * Translate a virtual address to a physical address.
2679 *
2680 * The low-level target implementation must have logged a detailed error
2681 * which is forwarded to telnet/GDB session.
2682 */
2683 static int handle_virt2phys_command(command_context_t *cmd_ctx,
2684 char *cmd, char **args, int argc)
2685 {
2686 if (argc != 1)
2687 return ERROR_COMMAND_SYNTAX_ERROR;
2688
2689 u32 va;
2690 int retval = parse_u32(args[0], &va);
2691 if (ERROR_OK != retval)
2692 return retval;
2693 u32 pa;
2694
2695 target_t *target = get_current_target(cmd_ctx);
2696 retval = target->type->virt2phys(target, va, &pa);
2697 if (retval == ERROR_OK)
2698 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2699
2700 return retval;
2701 }
2702
2703 static void writeData(FILE *f, const void *data, size_t len)
2704 {
2705 size_t written = fwrite(data, 1, len, f);
2706 if (written != len)
2707 LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
2708 }
2709
2710 static void writeLong(FILE *f, int l)
2711 {
2712 int i;
2713 for (i=0; i<4; i++)
2714 {
2715 char c=(l>>(i*8))&0xff;
2716 writeData(f, &c, 1);
2717 }
2718
2719 }
2720
2721 static void writeString(FILE *f, char *s)
2722 {
2723 writeData(f, s, strlen(s));
2724 }
2725
2726 /* Dump a gmon.out histogram file. */
2727 static void writeGmon(u32 *samples, u32 sampleNum, char *filename)
2728 {
2729 u32 i;
2730 FILE *f=fopen(filename, "w");
2731 if (f==NULL)
2732 return;
2733 writeString(f, "gmon");
2734 writeLong(f, 0x00000001); /* Version */
2735 writeLong(f, 0); /* padding */
2736 writeLong(f, 0); /* padding */
2737 writeLong(f, 0); /* padding */
2738
2739 u8 zero = 0; /* GMON_TAG_TIME_HIST */
2740 writeData(f, &zero, 1);
2741
2742 /* figure out bucket size */
2743 u32 min=samples[0];
2744 u32 max=samples[0];
2745 for (i=0; i<sampleNum; i++)
2746 {
2747 if (min>samples[i])
2748 {
2749 min=samples[i];
2750 }
2751 if (max<samples[i])
2752 {
2753 max=samples[i];
2754 }
2755 }
2756
2757 int addressSpace=(max-min+1);
2758
2759 static const u32 maxBuckets = 256 * 1024; /* maximum buckets. */
2760 u32 length = addressSpace;
2761 if (length > maxBuckets)
2762 {
2763 length=maxBuckets;
2764 }
2765 int *buckets=malloc(sizeof(int)*length);
2766 if (buckets==NULL)
2767 {
2768 fclose(f);
2769 return;
2770 }
2771 memset(buckets, 0, sizeof(int)*length);
2772 for (i=0; i<sampleNum;i++)
2773 {
2774 u32 address=samples[i];
2775 long long a=address-min;
2776 long long b=length-1;
2777 long long c=addressSpace-1;
2778 int index=(a*b)/c; /* danger!!!! int32 overflows */
2779 buckets[index]++;
2780 }
2781
2782 /* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
2783 writeLong(f, min); /* low_pc */
2784 writeLong(f, max); /* high_pc */
2785 writeLong(f, length); /* # of samples */
2786 writeLong(f, 64000000); /* 64MHz */
2787 writeString(f, "seconds");
2788 for (i=0; i<(15-strlen("seconds")); i++)
2789 writeData(f, &zero, 1);
2790 writeString(f, "s");
2791
2792 /*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
2793
2794 char *data=malloc(2*length);
2795 if (data!=NULL)
2796 {
2797 for (i=0; i<length;i++)
2798 {
2799 int val;
2800 val=buckets[i];
2801 if (val>65535)
2802 {
2803 val=65535;
2804 }
2805 data[i*2]=val&0xff;
2806 data[i*2+1]=(val>>8)&0xff;
2807 }
2808 free(buckets);
2809 writeData(f, data, length * 2);
2810 free(data);
2811 } else
2812 {
2813 free(buckets);
2814 }
2815
2816 fclose(f);
2817 }
2818
2819 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2820 static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2821 {
2822 target_t *target = get_current_target(cmd_ctx);
2823 struct timeval timeout, now;
2824
2825 gettimeofday(&timeout, NULL);
2826 if (argc!=2)
2827 {
2828 return ERROR_COMMAND_SYNTAX_ERROR;
2829 }
2830 unsigned offset;
2831 int retval = parse_uint(args[0], &offset);
2832 if (ERROR_OK != retval)
2833 return retval;
2834
2835 timeval_add_time(&timeout, offset, 0);
2836
2837 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2838
2839 static const int maxSample=10000;
2840 u32 *samples=malloc(sizeof(u32)*maxSample);
2841 if (samples==NULL)
2842 return ERROR_OK;
2843
2844 int numSamples=0;
2845 /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
2846 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2847
2848 for (;;)
2849 {
2850 target_poll(target);
2851 if (target->state == TARGET_HALTED)
2852 {
2853 u32 t=*((u32 *)reg->value);
2854 samples[numSamples++]=t;
2855 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2856 target_poll(target);
2857 alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
2858 } else if (target->state == TARGET_RUNNING)
2859 {
2860 /* We want to quickly sample the PC. */
2861 if((retval = target_halt(target)) != ERROR_OK)
2862 {
2863 free(samples);
2864 return retval;
2865 }
2866 } else
2867 {
2868 command_print(cmd_ctx, "Target not halted or running");
2869 retval=ERROR_OK;
2870 break;
2871 }
2872 if (retval!=ERROR_OK)
2873 {
2874 break;
2875 }
2876
2877 gettimeofday(&now, NULL);
2878 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2879 {
2880 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2881 if((retval = target_poll(target)) != ERROR_OK)
2882 {
2883 free(samples);
2884 return retval;
2885 }
2886 if (target->state == TARGET_HALTED)
2887 {
2888 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2889 }
2890 if((retval = target_poll(target)) != ERROR_OK)
2891 {
2892 free(samples);
2893 return retval;
2894 }
2895 writeGmon(samples, numSamples, args[1]);
2896 command_print(cmd_ctx, "Wrote %s", args[1]);
2897 break;
2898 }
2899 }
2900 free(samples);
2901
2902 return ERROR_OK;
2903 }
2904
2905 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2906 {
2907 char *namebuf;
2908 Jim_Obj *nameObjPtr, *valObjPtr;
2909 int result;
2910
2911 namebuf = alloc_printf("%s(%d)", varname, idx);
2912 if (!namebuf)
2913 return JIM_ERR;
2914
2915 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2916 valObjPtr = Jim_NewIntObj(interp, val);
2917 if (!nameObjPtr || !valObjPtr)
2918 {
2919 free(namebuf);
2920 return JIM_ERR;
2921 }
2922
2923 Jim_IncrRefCount(nameObjPtr);
2924 Jim_IncrRefCount(valObjPtr);
2925 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2926 Jim_DecrRefCount(interp, nameObjPtr);
2927 Jim_DecrRefCount(interp, valObjPtr);
2928 free(namebuf);
2929 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2930 return result;
2931 }
2932
2933 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2934 {
2935 command_context_t *context;
2936 target_t *target;
2937
2938 context = Jim_GetAssocData(interp, "context");
2939 if (context == NULL)
2940 {
2941 LOG_ERROR("mem2array: no command context");
2942 return JIM_ERR;
2943 }
2944 target = get_current_target(context);
2945 if (target == NULL)
2946 {
2947 LOG_ERROR("mem2array: no current target");
2948 return JIM_ERR;
2949 }
2950
2951 return target_mem2array(interp, target, argc-1, argv+1);
2952 }
2953
2954 static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
2955 {
2956 long l;
2957 u32 width;
2958 int len;
2959 u32 addr;
2960 u32 count;
2961 u32 v;
2962 const char *varname;
2963 u8 buffer[4096];
2964 int n, e, retval;
2965 u32 i;
2966
2967 /* argv[1] = name of array to receive the data
2968 * argv[2] = desired width
2969 * argv[3] = memory address
2970 * argv[4] = count of times to read
2971 */
2972 if (argc != 4) {
2973 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2974 return JIM_ERR;
2975 }
2976 varname = Jim_GetString(argv[0], &len);
2977 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2978
2979 e = Jim_GetLong(interp, argv[1], &l);
2980 width = l;
2981 if (e != JIM_OK) {
2982 return e;
2983 }
2984
2985 e = Jim_GetLong(interp, argv[2], &l);
2986 addr = l;
2987 if (e != JIM_OK) {
2988 return e;
2989 }
2990 e = Jim_GetLong(interp, argv[3], &l);
2991 len = l;
2992 if (e != JIM_OK) {
2993 return e;
2994 }
2995 switch (width) {
2996 case 8:
2997 width = 1;
2998 break;
2999 case 16:
3000 width = 2;
3001 break;
3002 case 32:
3003 width = 4;
3004 break;
3005 default:
3006 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3007 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
3008 return JIM_ERR;
3009 }
3010 if (len == 0) {
3011 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3012 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
3013 return JIM_ERR;
3014 }
3015 if ((addr + (len * width)) < addr) {
3016 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3017 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
3018 return JIM_ERR;
3019 }
3020 /* absurd transfer size? */
3021 if (len > 65536) {
3022 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3023 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
3024 return JIM_ERR;
3025 }
3026
3027 if ((width == 1) ||
3028 ((width == 2) && ((addr & 1) == 0)) ||
3029 ((width == 4) && ((addr & 3) == 0))) {
3030 /* all is well */
3031 } else {
3032 char buf[100];
3033 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3034 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
3035 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3036 return JIM_ERR;
3037 }
3038
3039 /* Transfer loop */
3040
3041 /* index counter */
3042 n = 0;
3043 /* assume ok */
3044 e = JIM_OK;
3045 while (len) {
3046 /* Slurp... in buffer size chunks */
3047
3048 count = len; /* in objects.. */
3049 if (count > (sizeof(buffer)/width)) {
3050 count = (sizeof(buffer)/width);
3051 }
3052
3053 retval = target_read_memory( target, addr, width, count, buffer );
3054 if (retval != ERROR_OK) {
3055 /* BOO !*/
3056 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
3057 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3058 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
3059 e = JIM_ERR;
3060 len = 0;
3061 } else {
3062 v = 0; /* shut up gcc */
3063 for (i = 0 ;i < count ;i++, n++) {
3064 switch (width) {
3065 case 4:
3066 v = target_buffer_get_u32(target, &buffer[i*width]);
3067 break;
3068 case 2:
3069 v = target_buffer_get_u16(target, &buffer[i*width]);
3070 break;
3071 case 1:
3072 v = buffer[i] & 0x0ff;
3073 break;
3074 }
3075 new_int_array_element(interp, varname, n, v);
3076 }
3077 len -= count;
3078 }
3079 }
3080
3081 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3082
3083 return JIM_OK;
3084 }
3085
3086 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
3087 {
3088 char *namebuf;
3089 Jim_Obj *nameObjPtr, *valObjPtr;
3090 int result;
3091 long l;
3092
3093 namebuf = alloc_printf("%s(%d)", varname, idx);
3094 if (!namebuf)
3095 return JIM_ERR;
3096
3097 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
3098 if (!nameObjPtr)
3099 {
3100 free(namebuf);
3101 return JIM_ERR;
3102 }
3103
3104 Jim_IncrRefCount(nameObjPtr);
3105 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
3106 Jim_DecrRefCount(interp, nameObjPtr);
3107 free(namebuf);
3108 if (valObjPtr == NULL)
3109 return JIM_ERR;
3110
3111 result = Jim_GetLong(interp, valObjPtr, &l);
3112 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
3113 *val = l;
3114 return result;
3115 }
3116
3117 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
3118 {
3119 command_context_t *context;
3120 target_t *target;
3121
3122 context = Jim_GetAssocData(interp, "context");
3123 if (context == NULL){
3124 LOG_ERROR("array2mem: no command context");
3125 return JIM_ERR;
3126 }
3127 target = get_current_target(context);
3128 if (target == NULL){
3129 LOG_ERROR("array2mem: no current target");
3130 return JIM_ERR;
3131 }
3132
3133 return target_array2mem( interp,target, argc-1, argv+1 );
3134 }
3135
3136 static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
3137 {
3138 long l;
3139 u32 width;
3140 int len;
3141 u32 addr;
3142 u32 count;
3143 u32 v;
3144 const char *varname;
3145 u8 buffer[4096];
3146 int n, e, retval;
3147 u32 i;
3148
3149 /* argv[1] = name of array to get the data
3150 * argv[2] = desired width
3151 * argv[3] = memory address
3152 * argv[4] = count to write
3153 */
3154 if (argc != 4) {
3155 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
3156 return JIM_ERR;
3157 }
3158 varname = Jim_GetString(argv[0], &len);
3159 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
3160
3161 e = Jim_GetLong(interp, argv[1], &l);
3162 width = l;
3163 if (e != JIM_OK) {
3164 return e;
3165 }
3166
3167 e = Jim_GetLong(interp, argv[2], &l);
3168 addr = l;
3169 if (e != JIM_OK) {
3170 return e;
3171 }
3172 e = Jim_GetLong(interp, argv[3], &l);
3173 len = l;
3174 if (e != JIM_OK) {
3175 return e;
3176 }
3177 switch (width) {
3178 case 8:
3179 width = 1;
3180 break;
3181 case 16:
3182 width = 2;
3183 break;
3184 case 32:
3185 width = 4;
3186 break;
3187 default:
3188 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3189 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
3190 return JIM_ERR;
3191 }
3192 if (len == 0) {
3193 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3194 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
3195 return JIM_ERR;
3196 }
3197 if ((addr + (len * width)) < addr) {
3198 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3199 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
3200 return JIM_ERR;
3201 }
3202 /* absurd transfer size? */
3203 if (len > 65536) {
3204 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3205 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
3206 return JIM_ERR;
3207 }
3208
3209 if ((width == 1) ||
3210 ((width == 2) && ((addr & 1) == 0)) ||
3211 ((width == 4) && ((addr & 3) == 0))) {
3212 /* all is well */
3213 } else {
3214 char buf[100];
3215 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3216 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
3217 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
3218 return JIM_ERR;
3219 }
3220
3221 /* Transfer loop */
3222
3223 /* index counter */
3224 n = 0;
3225 /* assume ok */
3226 e = JIM_OK;
3227 while (len) {
3228 /* Slurp... in buffer size chunks */
3229
3230 count = len; /* in objects.. */
3231 if (count > (sizeof(buffer)/width)) {
3232 count = (sizeof(buffer)/width);
3233 }
3234
3235 v = 0; /* shut up gcc */
3236 for (i = 0 ;i < count ;i++, n++) {
3237 get_int_array_element(interp, varname, n, &v);
3238 switch (width) {
3239 case 4:
3240 target_buffer_set_u32(target, &buffer[i*width], v);
3241 break;
3242 case 2:
3243 target_buffer_set_u16(target, &buffer[i*width], v);
3244 break;
3245 case 1:
3246 buffer[i] = v & 0x0ff;
3247 break;
3248 }
3249 }
3250 len -= count;
3251
3252 retval = target_write_memory(target, addr, width, count, buffer);
3253 if (retval != ERROR_OK) {
3254 /* BOO !*/
3255 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
3256 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3257 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
3258 e = JIM_ERR;
3259 len = 0;
3260 }
3261 }
3262
3263 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
3264
3265 return JIM_OK;
3266 }
3267
3268 void target_all_handle_event( enum target_event e )
3269 {
3270 target_t *target;
3271
3272 LOG_DEBUG( "**all*targets: event: %d, %s",
3273 e,
3274 Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3275
3276 target = all_targets;
3277 while (target){
3278 target_handle_event( target, e );
3279 target = target->next;
3280 }
3281 }
3282
3283 void target_handle_event( target_t *target, enum target_event e )
3284 {
3285 target_event_action_t *teap;
3286 int done;
3287
3288 teap = target->event_action;
3289
3290 done = 0;
3291 while( teap ){
3292 if( teap->event == e ){
3293 done = 1;
3294 LOG_DEBUG( "target: (%d) %s (%s) event: %d (%s) action: %s\n",
3295 target->target_number,
3296 target->cmd_name,
3297 target_get_name(target),
3298 e,
3299 Jim_Nvp_value2name_simple( nvp_target_event, e )->name,
3300 Jim_GetString( teap->body, NULL ) );
3301 if (Jim_EvalObj( interp, teap->body )!=JIM_OK)
3302 {
3303 Jim_PrintErrorMessage(interp);
3304 }
3305 }
3306 teap = teap->next;
3307 }
3308 if( !done ){
3309 LOG_DEBUG( "event: %d %s - no action",
3310 e,
3311 Jim_Nvp_value2name_simple( nvp_target_event, e )->name );
3312 }
3313 }
3314
3315 enum target_cfg_param {
3316 TCFG_TYPE,
3317 TCFG_EVENT,
3318 TCFG_WORK_AREA_VIRT,
3319 TCFG_WORK_AREA_PHYS,
3320 TCFG_WORK_AREA_SIZE,
3321 TCFG_WORK_AREA_BACKUP,
3322 TCFG_ENDIAN,
3323 TCFG_VARIANT,
3324 TCFG_CHAIN_POSITION,
3325 };
3326
3327 static Jim_Nvp nvp_config_opts[] = {
3328 { .name = "-type", .value = TCFG_TYPE },
3329 { .name = "-event", .value = TCFG_EVENT },
3330 { .name = "-work-area-virt", .value = TCFG_WORK_AREA_VIRT },
3331 { .name = "-work-area-phys", .value = TCFG_WORK_AREA_PHYS },
3332 { .name = "-work-area-size", .value = TCFG_WORK_AREA_SIZE },
3333 { .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
3334 { .name = "-endian" , .value = TCFG_ENDIAN },
3335 { .name = "-variant", .value = TCFG_VARIANT },
3336 { .name = "-chain-position", .value = TCFG_CHAIN_POSITION },
3337
3338 { .name = NULL, .value = -1 }
3339 };
3340
3341 static int target_configure( Jim_GetOptInfo *goi, target_t *target )
3342 {
3343 Jim_Nvp *n;
3344 Jim_Obj *o;
3345 jim_wide w;
3346 char *cp;
3347 int e;
3348
3349 /* parse config or cget options ... */
3350 while( goi->argc > 0 ){
3351 Jim_SetEmptyResult( goi->interp );
3352 /* Jim_GetOpt_Debug( goi ); */
3353
3354 if( target->type->target_jim_configure ){
3355 /* target defines a configure function */
3356 /* target gets first dibs on parameters */
3357 e = (*(target->type->target_jim_configure))( target, goi );
3358 if( e == JIM_OK ){
3359 /* more? */
3360 continue;
3361 }
3362 if( e == JIM_ERR ){
3363 /* An error */
3364 return e;
3365 }
3366 /* otherwise we 'continue' below */
3367 }
3368 e = Jim_GetOpt_Nvp( goi, nvp_config_opts, &n );
3369 if( e != JIM_OK ){
3370 Jim_GetOpt_NvpUnknown( goi, nvp_config_opts, 0 );
3371 return e;
3372 }
3373 switch( n->value ){
3374 case TCFG_TYPE:
3375 /* not setable */
3376 if( goi->isconfigure ){
3377 Jim_SetResult_sprintf( goi->interp, "not setable: %s", n->name );
3378 return JIM_ERR;
3379 } else {
3380 no_params:
3381 if( goi->argc != 0 ){
3382 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "NO PARAMS");
3383 return JIM_ERR;
3384 }
3385 }
3386 Jim_SetResultString( goi->interp, target_get_name(target), -1 );
3387 /* loop for more */
3388 break;
3389 case TCFG_EVENT:
3390 if( goi->argc == 0 ){
3391 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
3392 return JIM_ERR;
3393 }
3394
3395 e = Jim_GetOpt_Nvp( goi, nvp_target_event, &n );
3396 if( e != JIM_OK ){
3397 Jim_GetOpt_NvpUnknown( goi, nvp_target_event, 1 );
3398 return e;
3399 }
3400
3401 if( goi->isconfigure ){
3402 if( goi->argc != 1 ){
3403 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
3404 return JIM_ERR;
3405 }
3406 } else {
3407 if( goi->argc != 0 ){
3408 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
3409 return JIM_ERR;
3410 }
3411 }
3412
3413 {
3414 target_event_action_t *teap;
3415
3416 teap = target->event_action;
3417 /* replace existing? */
3418 while( teap ){
3419 if( teap->event == (enum target_event)n->value ){
3420 break;
3421 }
3422 teap = teap->next;
3423 }
3424
3425 if( goi->isconfigure ){
3426 if( teap == NULL ){
3427 /* create new */
3428 teap = calloc( 1, sizeof(*teap) );
3429 }
3430 teap->event = n->value;
3431 Jim_GetOpt_Obj( goi, &o );
3432 if( teap->body ){
3433 Jim_DecrRefCount( interp, teap->body );
3434 }
3435 teap->body = Jim_DuplicateObj( goi->interp, o );
3436 /*
3437 * FIXME:
3438 * Tcl/TK - "tk events" have a nice feature.
3439 * See the "BIND" command.
3440 * We should support that here.
3441 * You can specify %X and %Y in the event code.
3442 * The idea is: %T - target name.
3443 * The idea is: %N - target number
3444 * The idea is: %E - event name.
3445 */
3446 Jim_IncrRefCount( teap->body );
3447
3448 /* add to head of event list */
3449 teap->next = target->event_action;
3450 target->event_action = teap;
3451 Jim_SetEmptyResult(goi->interp);
3452 } else {
3453 /* get */
3454 if( teap == NULL ){
3455 Jim_SetEmptyResult( goi->interp );
3456 } else {
3457 Jim_SetResult( goi->interp, Jim_DuplicateObj( goi->interp, teap->body ) );
3458 }
3459 }
3460 }
3461 /* loop for more */
3462 break;
3463
3464 case TCFG_WORK_AREA_VIRT:
3465 if( goi->isconfigure ){
3466 target_free_all_working_areas(target);
3467 e = Jim_GetOpt_Wide( goi, &w );
3468 if( e != JIM_OK ){
3469 return e;
3470 }
3471 target->working_area_virt = w;
3472 } else {
3473 if( goi->argc != 0 ){
3474 goto no_params;
3475 }
3476 }
3477 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_virt ) );
3478 /* loop for more */
3479 break;
3480
3481 case TCFG_WORK_AREA_PHYS:
3482 if( goi->isconfigure ){
3483 target_free_all_working_areas(target);
3484 e = Jim_GetOpt_Wide( goi, &w );
3485 if( e != JIM_OK ){
3486 return e;
3487 }
3488 target->working_area_phys = w;
3489 } else {
3490 if( goi->argc != 0 ){
3491 goto no_params;
3492 }
3493 }
3494 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_phys ) );
3495 /* loop for more */
3496 break;
3497
3498 case TCFG_WORK_AREA_SIZE:
3499 if( goi->isconfigure ){
3500 target_free_all_working_areas(target);
3501 e = Jim_GetOpt_Wide( goi, &w );
3502 if( e != JIM_OK ){
3503 return e;
3504 }
3505 target->working_area_size = w;
3506 } else {
3507 if( goi->argc != 0 ){
3508 goto no_params;
3509 }
3510 }
3511 Jim_SetResult( interp, Jim_NewIntObj( goi->interp, target->working_area_size ) );
3512 /* loop for more */
3513 break;
3514
3515 case TCFG_WORK_AREA_BACKUP:
3516 if( goi->isconfigure ){
3517 target_free_all_working_areas(target);
3518 e = Jim_GetOpt_Wide( goi, &w );
3519 if( e != JIM_OK ){
3520 return e;
3521 }
3522 /* make this exactly 1 or 0 */
3523 target->backup_working_area = (!!w);
3524 } else {
3525 if( goi->argc != 0 ){
3526 goto no_params;
3527 }
3528 }
3529 Jim_SetResult(interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
3530 /* loop for more e*/
3531 break;
3532
3533 case TCFG_ENDIAN:
3534 if( goi->isconfigure ){
3535 e = Jim_GetOpt_Nvp( goi, nvp_target_endian, &n );
3536 if( e != JIM_OK ){
3537 Jim_GetOpt_NvpUnknown( goi, nvp_target_endian, 1 );
3538 return e;
3539 }
3540 target->endianness = n->value;
3541 } else {
3542 if( goi->argc != 0 ){
3543 goto no_params;
3544 }
3545 }
3546 n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3547 if( n->name == NULL ){
3548 target->endianness = TARGET_LITTLE_ENDIAN;
3549 n = Jim_Nvp_value2name_simple( nvp_target_endian, target->endianness );
3550 }
3551 Jim_SetResultString( goi->interp, n->name, -1 );
3552 /* loop for more */
3553 break;
3554
3555 case TCFG_VARIANT:
3556 if( goi->isconfigure ){
3557 if( goi->argc < 1 ){
3558 Jim_SetResult_sprintf( goi->interp,
3559 "%s ?STRING?",
3560 n->name );
3561 return JIM_ERR;
3562 }
3563 if( target->variant ){
3564 free((void *)(target->variant));
3565 }
3566 e = Jim_GetOpt_String( goi, &cp, NULL );
3567 target->variant = strdup(cp);
3568 } else {
3569 if( goi->argc != 0 ){
3570 goto no_params;
3571 }
3572 }
3573 Jim_SetResultString( goi->interp, target->variant,-1 );
3574 /* loop for more */
3575 break;
3576 case TCFG_CHAIN_POSITION:
3577 if( goi->isconfigure ){
3578 Jim_Obj *o;
3579 jtag_tap_t *tap;
3580 target_free_all_working_areas(target);
3581 e = Jim_GetOpt_Obj( goi, &o );
3582 if( e != JIM_OK ){
3583 return e;
3584 }
3585 tap = jtag_tap_by_jim_obj( goi->interp, o );
3586 if( tap == NULL ){
3587 return JIM_ERR;
3588 }
3589 /* make this exactly 1 or 0 */
3590 target->tap = tap;
3591 } else {
3592 if( goi->argc != 0 ){
3593 goto no_params;
3594 }
3595 }
3596 Jim_SetResultString( interp, target->tap->dotted_name, -1 );
3597 /* loop for more e*/
3598 break;
3599 }
3600 } /* while( goi->argc ) */
3601
3602
3603 /* done - we return */
3604 return JIM_OK;
3605 }
3606
3607 /** this is the 'tcl' handler for the target specific command */
3608 static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
3609 {
3610 Jim_GetOptInfo goi;
3611 jim_wide a,b,c;
3612 int x,y,z;
3613 u8 target_buf[32];
3614 Jim_Nvp *n;
3615 target_t *target;
3616 struct command_context_s *cmd_ctx;
3617 int e;
3618
3619 enum {
3620 TS_CMD_CONFIGURE,
3621 TS_CMD_CGET,
3622
3623 TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
3624 TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
3625 TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
3626 TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
3627 TS_CMD_EXAMINE,
3628 TS_CMD_POLL,
3629 TS_CMD_RESET,
3630 TS_CMD_HALT,
3631 TS_CMD_WAITSTATE,
3632 TS_CMD_EVENTLIST,
3633 TS_CMD_CURSTATE,
3634 TS_CMD_INVOKE_EVENT,
3635 };
3636
3637 static const Jim_Nvp target_options[] = {
3638 { .name = "configure", .value = TS_CMD_CONFIGURE },
3639 { .name = "cget", .value = TS_CMD_CGET },
3640 { .name = "mww", .value = TS_CMD_MWW },
3641 { .name = "mwh", .value = TS_CMD_MWH },
3642 { .name = "mwb", .value = TS_CMD_MWB },
3643 { .name = "mdw", .value = TS_CMD_MDW },
3644 { .name = "mdh", .value = TS_CMD_MDH },
3645 { .name = "mdb", .value = TS_CMD_MDB },
3646 { .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
3647 { .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
3648 { .name = "eventlist", .value = TS_CMD_EVENTLIST },
3649 { .name = "curstate", .value = TS_CMD_CURSTATE },
3650
3651 { .name = "arp_examine", .value = TS_CMD_EXAMINE },
3652 { .name = "arp_poll", .value = TS_CMD_POLL },
3653 { .name = "arp_reset", .value = TS_CMD_RESET },
3654 { .name = "arp_halt", .value = TS_CMD_HALT },
3655 { .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
3656 { .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
3657
3658 { .name = NULL, .value = -1 },
3659 };
3660
3661 /* go past the "command" */
3662 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
3663
3664 target = Jim_CmdPrivData( goi.interp );
3665 cmd_ctx = Jim_GetAssocData(goi.interp, "context");
3666
3667 /* commands here are in an NVP table */
3668 e = Jim_GetOpt_Nvp( &goi, target_options, &n );
3669 if( e != JIM_OK ){
3670 Jim_GetOpt_NvpUnknown( &goi, target_options, 0 );
3671 return e;
3672 }
3673 /* Assume blank result */
3674 Jim_SetEmptyResult( goi.interp );
3675
3676 switch( n->value ){
3677 case TS_CMD_CONFIGURE:
3678 if( goi.argc < 2 ){
3679 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
3680 return JIM_ERR;
3681 }
3682 goi.isconfigure = 1;
3683 return target_configure( &goi, target );
3684 case TS_CMD_CGET:
3685 // some things take params
3686 if( goi.argc < 1 ){
3687 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "missing: ?-option?");
3688 return JIM_ERR;
3689 }
3690 goi.isconfigure = 0;
3691 return target_configure( &goi, target );
3692 break;
3693 case TS_CMD_MWW:
3694 case TS_CMD_MWH:
3695 case TS_CMD_MWB:
3696 /* argv[0] = cmd
3697 * argv[1] = address
3698 * argv[2] = data
3699 * argv[3] = optional count.
3700 */
3701
3702 if( (goi.argc == 3) || (goi.argc == 4) ){
3703 /* all is well */
3704 } else {
3705 mwx_error:
3706 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR DATA [COUNT]", n->name );
3707 return JIM_ERR;
3708 }
3709
3710 e = Jim_GetOpt_Wide( &goi, &a );
3711 if( e != JIM_OK ){
3712 goto mwx_error;
3713 }
3714
3715 e = Jim_GetOpt_Wide( &goi, &b );
3716 if( e != JIM_OK ){
3717 goto mwx_error;
3718 }
3719 if( goi.argc ){
3720 e = Jim_GetOpt_Wide( &goi, &c );
3721 if( e != JIM_OK ){
3722 goto mwx_error;
3723 }
3724 } else {
3725 c = 1;
3726 }
3727
3728 switch( n->value ){
3729 case TS_CMD_MWW:
3730 target_buffer_set_u32( target, target_buf, b );
3731 b = 4;
3732 break;
3733 case TS_CMD_MWH:
3734 target_buffer_set_u16( target, target_buf, b );
3735 b = 2;
3736 break;
3737 case TS_CMD_MWB:
3738 target_buffer_set_u8( target, target_buf, b );
3739 b = 1;
3740 break;
3741 }
3742 for( x = 0 ; x < c ; x++ ){
3743 e = target_write_memory( target, a, b, 1, target_buf );
3744 if( e != ERROR_OK ){
3745 Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
3746 return JIM_ERR;
3747 }
3748 /* b = width */
3749 a = a + b;
3750 }
3751 return JIM_OK;
3752 break;
3753
3754 /* display */
3755 case TS_CMD_MDW:
3756 case TS_CMD_MDH:
3757 case TS_CMD_MDB:
3758 /* argv[0] = command
3759 * argv[1] = address
3760 * argv[2] = optional count
3761 */
3762 if( (goi.argc == 2) || (goi.argc == 3) ){
3763 Jim_SetResult_sprintf( goi.interp, "expected: %s ADDR [COUNT]", n->name );
3764 return JIM_ERR;
3765 }
3766 e = Jim_GetOpt_Wide( &goi, &a );
3767 if( e != JIM_OK ){
3768 return JIM_ERR;
3769 }
3770 if( goi.argc ){
3771 e = Jim_GetOpt_Wide( &goi, &c );
3772 if( e != JIM_OK ){
3773 return JIM_ERR;
3774 }
3775 } else {
3776 c = 1;
3777 }
3778 b = 1; /* shut up gcc */
3779 switch( n->value ){
3780 case TS_CMD_MDW:
3781 b = 4;
3782 break;
3783 case TS_CMD_MDH:
3784 b = 2;
3785 break;
3786 case TS_CMD_MDB:
3787 b = 1;
3788 break;
3789 }
3790
3791 /* convert to "bytes" */
3792 c = c * b;
3793 /* count is now in 'BYTES' */
3794 while( c > 0 ){
3795 y = c;
3796 if( y > 16 ){
3797 y = 16;
3798 }
3799 e = target_read_memory( target, a, b, y / b, target_buf );
3800 if( e != ERROR_OK ){
3801 Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
3802 return JIM_ERR;
3803 }
3804
3805 Jim_fprintf( interp, interp->cookie_stdout, "0x%08x ", (int)(a) );
3806 switch( b ){
3807 case 4:
3808 for( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
3809 z = target_buffer_get_u32( target, &(target_buf[ x * 4 ]) );
3810 Jim_fprintf( interp, interp->cookie_stdout, "%08x ", (int)(z) );
3811 }
3812 for( ; (x < 16) ; x += 4 ){
3813 Jim_fprintf( interp, interp->cookie_stdout, " " );
3814 }
3815 break;
3816 case 2:
3817 for( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
3818 z = target_buffer_get_u16( target, &(target_buf[ x * 2 ]) );
3819 Jim_fprintf( interp, interp->cookie_stdout, "%04x ", (int)(z) );
3820 }
3821 for( ; (x < 16) ; x += 2 ){
3822 Jim_fprintf( interp, interp->cookie_stdout, " " );
3823 }
3824 break;
3825 case 1:
3826 default:
3827 for( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
3828 z = target_buffer_get_u8( target, &(target_buf[ x * 4 ]) );
3829 Jim_fprintf( interp, interp->cookie_stdout, "%02x ", (int)(z) );
3830 }
3831 for( ; (x < 16) ; x += 1 ){
3832 Jim_fprintf( interp, interp->cookie_stdout, " " );
3833 }
3834 break;
3835 }
3836 /* ascii-ify the bytes */
3837 for( x = 0 ; x < y ; x++ ){
3838 if( (target_buf[x] >= 0x20) &&
3839 (target_buf[x] <= 0x7e) ){
3840 /* good */
3841 } else {
3842 /* smack it */
3843 target_buf[x] = '.';
3844 }
3845 }
3846 /* space pad */
3847 while( x < 16 ){
3848 target_buf[x] = ' ';
3849 x++;
3850 }
3851 /* terminate */
3852 target_buf[16] = 0;
3853 /* print - with a newline */
3854 Jim_fprintf( interp, interp->cookie_stdout, "%s\n", target_buf );
3855 /* NEXT... */
3856 c -= 16;
3857 a += 16;
3858 }
3859 return JIM_OK;
3860 case TS_CMD_MEM2ARRAY:
3861 return target_mem2array( goi.interp, target, goi.argc, goi.argv );
3862 break;
3863 case TS_CMD_ARRAY2MEM:
3864 return target_array2mem( goi.interp, target, goi.argc, goi.argv );
3865 break;
3866 case TS_CMD_EXAMINE:
3867 if( goi.argc ){
3868 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3869 return JIM_ERR;
3870 }
3871 if (!target->tap->enabled)
3872 goto err_tap_disabled;
3873 e = target->type->examine( target );
3874 if( e != ERROR_OK ){
3875 Jim_SetResult_sprintf( interp, "examine-fails: %d", e );
3876 return JIM_ERR;
3877 }
3878 return JIM_OK;
3879 case TS_CMD_POLL:
3880 if( goi.argc ){
3881 Jim_WrongNumArgs( goi.interp, 2, argv, "[no parameters]");
3882 return JIM_ERR;
3883 }
3884 if (!target->tap->enabled)
3885 goto err_tap_disabled;
3886 if( !(target_was_examined(target)) ){
3887 e = ERROR_TARGET_NOT_EXAMINED;
3888 } else {
3889 e = target->type->poll( target );
3890 }
3891 if( e != ERROR_OK ){
3892 Jim_SetResult_sprintf( interp, "poll-fails: %d", e );
3893 return JIM_ERR;
3894 } else {
3895 return JIM_OK;
3896 }
3897 break;
3898 case TS_CMD_RESET:
3899 if( goi.argc != 2 ){
3900 Jim_WrongNumArgs( interp, 2, argv, "t|f|assert|deassert BOOL");
3901 return JIM_ERR;
3902 }
3903 e = Jim_GetOpt_Nvp( &goi, nvp_assert, &n );
3904 if( e != JIM_OK ){
3905 Jim_GetOpt_NvpUnknown( &goi, nvp_assert, 1 );
3906 return e;
3907 }
3908 /* the halt or not param */
3909 e = Jim_GetOpt_Wide( &goi, &a);
3910 if( e != JIM_OK ){
3911 return e;
3912 }
3913 if (!target->tap->enabled)
3914 goto err_tap_disabled;
3915 /* determine if we should halt or not. */
3916 target->reset_halt = !!a;
3917 /* When this happens - all workareas are invalid. */
3918 target_free_all_working_areas_restore(target, 0);
3919
3920 /* do the assert */
3921 if( n->value == NVP_ASSERT ){
3922 target->type->assert_reset( target );
3923 } else {
3924 target->type->deassert_reset( target );
3925 }
3926 return JIM_OK;
3927 case TS_CMD_HALT:
3928 if( goi.argc ){
3929 Jim_WrongNumArgs( goi.interp, 0, argv, "halt [no parameters]");
3930 return JIM_ERR;
3931 }
3932 if (!target->tap->enabled)
3933 goto err_tap_disabled;
3934 target->type->halt( target );
3935 return JIM_OK;
3936 case TS_CMD_WAITSTATE:
3937 /* params: <name> statename timeoutmsecs */
3938 if( goi.argc != 2 ){
3939 Jim_SetResult_sprintf( goi.interp, "%s STATENAME TIMEOUTMSECS", n->name );
3940 return JIM_ERR;
3941 }
3942 e = Jim_GetOpt_Nvp( &goi, nvp_target_state, &n );
3943 if( e != JIM_OK ){
3944 Jim_GetOpt_NvpUnknown( &goi, nvp_target_state,1 );
3945 return e;
3946 }
3947 e = Jim_GetOpt_Wide( &goi, &a );
3948 if( e != JIM_OK ){
3949 return e;
3950 }
3951 if (!target->tap->enabled)
3952 goto err_tap_disabled;
3953 e = target_wait_state( target, n->value, a );
3954 if( e != ERROR_OK ){
3955 Jim_SetResult_sprintf( goi.interp,
3956 "target: %s wait %s fails (%d) %s",
3957 target->cmd_name,
3958 n->name,
3959 e, target_strerror_safe(e) );
3960 return JIM_ERR;
3961 } else {
3962 return JIM_OK;
3963 }
3964 case TS_CMD_EVENTLIST:
3965 /* List for human, Events defined for this target.
3966 * scripts/programs should use 'name cget -event NAME'
3967 */
3968 {
3969 target_event_action_t *teap;
3970 teap = target->event_action;
3971 command_print( cmd_ctx, "Event actions for target (%d) %s\n",
3972 target->target_number,
3973 target->cmd_name );
3974 command_print( cmd_ctx, "%-25s | Body", "Event");
3975 command_print( cmd_ctx, "------------------------- | ----------------------------------------");
3976 while( teap ){
3977 command_print( cmd_ctx,
3978 "%-25s | %s",
3979 Jim_Nvp_value2name_simple( nvp_target_event, teap->event )->name,
3980 Jim_GetString( teap->body, NULL ) );
3981 teap = teap->next;
3982 }
3983 command_print( cmd_ctx, "***END***");
3984 return JIM_OK;
3985 }
3986 case TS_CMD_CURSTATE:
3987 if( goi.argc != 0 ){
3988 Jim_WrongNumArgs( goi.interp, 0, argv, "[no parameters]");
3989 return JIM_ERR;
3990 }
3991 Jim_SetResultString( goi.interp,
3992 Jim_Nvp_value2name_simple(nvp_target_state,target->state)->name,-1);
3993 return JIM_OK;
3994 case TS_CMD_INVOKE_EVENT:
3995 if( goi.argc != 1 ){
3996 Jim_SetResult_sprintf( goi.interp, "%s ?EVENTNAME?",n->name);
3997 return JIM_ERR;
3998 }
3999 e = Jim_GetOpt_Nvp( &goi, nvp_target_event, &n );
4000 if( e != JIM_OK ){
4001 Jim_GetOpt_NvpUnknown( &goi, nvp_target_event, 1 );
4002 return e;
4003 }
4004 target_handle_event( target, n->value );
4005 return JIM_OK;
4006 }
4007 return JIM_ERR;
4008
4009 err_tap_disabled:
4010 Jim_SetResult_sprintf(interp, "[TAP is disabled]");
4011 return JIM_ERR;
4012 }
4013
4014 static int target_create( Jim_GetOptInfo *goi )
4015 {
4016 Jim_Obj *new_cmd;
4017 Jim_Cmd *cmd;
4018 const char *cp;
4019 char *cp2;
4020 int e;
4021 int x;
4022 target_t *target;
4023 struct command_context_s *cmd_ctx;
4024
4025 cmd_ctx = Jim_GetAssocData(goi->interp, "context");
4026 if( goi->argc < 3 ){
4027 Jim_WrongNumArgs( goi->interp, 1, goi->argv, "?name? ?type? ..options...");
4028 return JIM_ERR;
4029 }
4030
4031 /* COMMAND */
4032 Jim_GetOpt_Obj( goi, &new_cmd );
4033 /* does this command exist? */
4034 cmd = Jim_GetCommand( goi->interp, new_cmd, JIM_ERRMSG );
4035 if( cmd ){
4036 cp = Jim_GetString( new_cmd, NULL );
4037 Jim_SetResult_sprintf(goi->interp, "Command/target: %s Exists", cp);
4038 return JIM_ERR;
4039 }
4040
4041 /* TYPE */
4042 e = Jim_GetOpt_String( goi, &cp2, NULL );
4043 cp = cp2;
4044 /* now does target type exist */
4045 for( x = 0 ; target_types[x] ; x++ ){
4046 if( 0 == strcmp( cp, target_types[x]->name ) ){
4047 /* found */
4048 break;
4049 }
4050 }
4051 if( target_types[x] == NULL ){
4052 Jim_SetResult_sprintf( goi->interp, "Unknown target type %s, try one of ", cp );
4053 for( x = 0 ; target_types[x] ; x++ ){
4054 if( target_types[x+1] ){
4055 Jim_AppendStrings( goi->interp,
4056 Jim_GetResult(goi->interp),
4057 target_types[x]->name,
4058 ", ", NULL);
4059 } else {
4060 Jim_AppendStrings( goi->interp,
4061 Jim_GetResult(goi->interp),
4062 " or ",
4063 target_types[x]->name,NULL );
4064 }
4065 }
4066 return JIM_ERR;
4067 }
4068
4069 /* Create it */
4070 target = calloc(1,sizeof(target_t));
4071 /* set target number */
4072 target->target_number = new_target_number();
4073
4074 /* allocate memory for each unique target type */
4075 target->type = (target_type_t*)calloc(1,sizeof(target_type_t));
4076
4077 memcpy( target->type, target_types[x], sizeof(target_type_t));
4078
4079 /* will be set by "-endian" */
4080 target->endianness = TARGET_ENDIAN_UNKNOWN;
4081
4082 target->working_area = 0x0;
4083 target->working_area_size = 0x0;
4084 target->working_areas = NULL;
4085 target->backup_working_area = 0;
4086
4087 target->state = TARGET_UNKNOWN;
4088 target->debug_reason = DBG_REASON_UNDEFINED;
4089 target->reg_cache = NULL;
4090 target->breakpoints = NULL;
4091 target->watchpoints = NULL;
4092 target->next = NULL;
4093 target->arch_info = NULL;
4094
4095 target->display = 1;
4096
4097 /* initialize trace information */
4098 target->trace_info = malloc(sizeof(trace_t));
4099 target->trace_info->num_trace_points = 0;
4100 target->trace_info->trace_points_size = 0;
4101 target->trace_info->trace_points = NULL;
4102 target->trace_info->trace_history_size = 0;
4103 target->trace_info->trace_history = NULL;
4104 target->trace_info->trace_history_pos = 0;
4105 target->trace_info->trace_history_overflowed = 0;
4106
4107 target->dbgmsg = NULL;
4108 target->dbg_msg_enabled = 0;
4109
4110 target->endianness = TARGET_ENDIAN_UNKNOWN;
4111
4112 /* Do the rest as "configure" options */
4113 goi->isconfigure = 1;
4114 e = target_configure( goi, target);
4115
4116 if (target->tap == NULL)
4117 {
4118 Jim_SetResultString( interp, "-chain-position required when creating target", -1);
4119 e=JIM_ERR;
4120 }
4121
4122 if( e != JIM_OK ){
4123 free( target->type );
4124 free( target );
4125 return e;
4126 }
4127
4128 if( target->endianness == TARGET_ENDIAN_UNKNOWN ){
4129 /* default endian to little if not specified */
4130 target->endianness = TARGET_LITTLE_ENDIAN;
4131 }
4132
4133 /* incase variant is not set */
4134 if (!target->variant)
4135 target->variant = strdup("");
4136
4137 /* create the target specific commands */
4138 if( target->type->register_commands ){
4139 (*(target->type->register_commands))( cmd_ctx );
4140 }
4141 if( target->type->target_create ){
4142 (*(target->type->target_create))( target, goi->interp );
4143 }
4144
4145 /* append to end of list */
4146 {
4147 target_t **tpp;
4148 tpp = &(all_targets);
4149 while( *tpp ){
4150 tpp = &( (*tpp)->next );
4151 }
4152 *tpp = target;
4153 }
4154
4155 cp = Jim_GetString( new_cmd, NULL );
4156 target->cmd_name = strdup(cp);
4157
4158 /* now - create the new target name command */
4159 e = Jim_CreateCommand( goi->interp,
4160 /* name */
4161 cp,
4162 tcl_target_func, /* C function */
4163 target, /* private data */
4164 NULL ); /* no del proc */
4165
4166 return e;
4167 }
4168
4169 static int jim_target( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
4170 {
4171 int x,r,e;
4172 jim_wide w;
4173 struct command_context_s *cmd_ctx;
4174 target_t *target;
4175 Jim_GetOptInfo goi;
4176 enum tcmd {
4177 /* TG = target generic */
4178 TG_CMD_CREATE,
4179 TG_CMD_TYPES,
4180 TG_CMD_NAMES,
4181 TG_CMD_CURRENT,
4182 TG_CMD_NUMBER,
4183 TG_CMD_COUNT,
4184 };
4185 const char *target_cmds[] = {
4186 "create", "types", "names", "current", "number",
4187 "count",
4188 NULL /* terminate */
4189 };
4190
4191 LOG_DEBUG("Target command params:");
4192 LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
4193
4194 cmd_ctx = Jim_GetAssocData( interp, "context" );
4195
4196 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
4197
4198 if( goi.argc == 0 ){
4199 Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
4200 return JIM_ERR;
4201 }
4202
4203 /* Jim_GetOpt_Debug( &goi ); */
4204 r = Jim_GetOpt_Enum( &goi, target_cmds, &x );
4205 if( r != JIM_OK ){
4206 return r;
4207 }
4208
4209 switch(x){
4210 default:
4211 Jim_Panic(goi.interp,"Why am I here?");
4212 return JIM_ERR;
4213 case TG_CMD_CURRENT:
4214 if( goi.argc != 0 ){
4215 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters");
4216 return JIM_ERR;
4217 }
4218 Jim_SetResultString( goi.interp, get_current_target( cmd_ctx )->cmd_name, -1 );
4219 return JIM_OK;
4220 case TG_CMD_TYPES:
4221 if( goi.argc != 0 ){
4222 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4223 return JIM_ERR;
4224 }
4225 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4226 for( x = 0 ; target_types[x] ; x++ ){
4227 Jim_ListAppendElement( goi.interp,
4228 Jim_GetResult(goi.interp),
4229 Jim_NewStringObj( goi.interp, target_types[x]->name, -1 ) );
4230 }
4231 return JIM_OK;
4232 case TG_CMD_NAMES:
4233 if( goi.argc != 0 ){
4234 Jim_WrongNumArgs( goi.interp, 1, goi.argv, "Too many parameters" );
4235 return JIM_ERR;
4236 }
4237 Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
4238 target = all_targets;
4239 while( target ){
4240 Jim_ListAppendElement( goi.interp,
4241 Jim_GetResult(goi.interp),
4242 Jim_NewStringObj( goi.interp, target->cmd_name, -1 ) );
4243 target = target->next;
4244 }
4245 return JIM_OK;
4246 case TG_CMD_CREATE:
4247 if( goi.argc < 3 ){
4248 Jim_WrongNumArgs( goi.interp, goi.argc, goi.argv, "?name ... config options ...");
4249 return JIM_ERR;
4250 }
4251 return target_create( &goi );
4252 break;
4253 case TG_CMD_NUMBER:
4254 if( goi.argc != 1 ){
4255 Jim_SetResult_sprintf( goi.interp, "expected: target number ?NUMBER?");
4256 return JIM_ERR;
4257 }
4258 e = Jim_GetOpt_Wide( &goi, &w );
4259 if( e != JIM_OK ){
4260 return JIM_ERR;
4261 }
4262 {
4263 target_t *t;
4264 t = get_target_by_num(w);
4265 if( t == NULL ){
4266 Jim_SetResult_sprintf( goi.interp,"Target: number %d does not exist", (int)(w));
4267 return JIM_ERR;
4268 }
4269 Jim_SetResultString( goi.interp, t->cmd_name, -1 );
4270 return JIM_OK;
4271 }
4272 case TG_CMD_COUNT:
4273 if( goi.argc != 0 ){
4274 Jim_WrongNumArgs( goi.interp, 0, goi.argv, "<no parameters>");
4275 return JIM_ERR;
4276 }
4277 Jim_SetResult( goi.interp,
4278 Jim_NewIntObj( goi.interp, max_target_number()));
4279 return JIM_OK;
4280 }
4281
4282 return JIM_ERR;
4283 }
4284
4285
4286 struct FastLoad
4287 {
4288 u32 address;
4289 u8 *data;
4290 int length;
4291
4292 };
4293
4294 static int fastload_num;
4295 static struct FastLoad *fastload;
4296
4297 static void free_fastload(void)
4298 {
4299 if (fastload!=NULL)
4300 {
4301 int i;
4302 for (i=0; i<fastload_num; i++)
4303 {
4304 if (fastload[i].data)
4305 free(fastload[i].data);
4306 }
4307 free(fastload);
4308 fastload=NULL;
4309 }
4310 }
4311
4312
4313
4314
4315 static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4316 {
4317 u8 *buffer;
4318 u32 buf_cnt;
4319 u32 image_size;
4320 u32 min_address=0;
4321 u32 max_address=0xffffffff;
4322 int i;
4323
4324 image_t image;
4325
4326 duration_t duration;
4327 char *duration_text;
4328
4329 int retval = parse_load_image_command_args(args, argc,
4330 &image, &min_address, &max_address);
4331 if (ERROR_OK != retval)
4332 return retval;
4333
4334 duration_start_measure(&duration);
4335
4336 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
4337 {
4338 return ERROR_OK;
4339 }
4340
4341 image_size = 0x0;
4342 retval = ERROR_OK;
4343 fastload_num=image.num_sections;
4344 fastload=(struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
4345 if (fastload==NULL)
4346 {
4347 image_close(&image);
4348 return ERROR_FAIL;
4349 }
4350 memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
4351 for (i = 0; i < image.num_sections; i++)
4352 {
4353 buffer = malloc(image.sections[i].size);
4354 if (buffer == NULL)
4355 {
4356 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
4357 break;
4358 }
4359
4360 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
4361 {
4362 free(buffer);
4363 break;
4364 }
4365
4366 u32 offset=0;
4367 u32 length=buf_cnt;
4368
4369
4370 /* DANGER!!! beware of unsigned comparision here!!! */
4371
4372 if ((image.sections[i].base_address+buf_cnt>=min_address)&&
4373 (image.sections[i].base_address<max_address))
4374 {
4375 if (image.sections[i].base_address<min_address)
4376 {
4377 /* clip addresses below */
4378 offset+=min_address-image.sections[i].base_address;
4379 length-=offset;
4380 }
4381
4382 if (image.sections[i].base_address+buf_cnt>max_address)
4383 {
4384 length-=(image.sections[i].base_address+buf_cnt)-max_address;
4385 }
4386
4387 fastload[i].address=image.sections[i].base_address+offset;
4388 fastload[i].data=malloc(length);
4389 if (fastload[i].data==NULL)
4390 {
4391 free(buffer);
4392 break;
4393 }
4394 memcpy(fastload[i].data, buffer+offset, length);
4395 fastload[i].length=length;
4396
4397 image_size += length;
4398 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
4399 }
4400
4401 free(buffer);
4402 }
4403
4404 duration_stop_measure(&duration, &duration_text);
4405 if (retval==ERROR_OK)
4406 {
4407 command_print(cmd_ctx, "Loaded %u bytes in %s", image_size, duration_text);
4408 command_print(cmd_ctx, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
4409 }
4410 free(duration_text);
4411
4412 image_close(&image);
4413
4414 if (retval!=ERROR_OK)
4415 {
4416 free_fastload();
4417 }
4418
4419 return retval;
4420 }
4421
4422 static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
4423 {
4424 if (argc>0)
4425 return ERROR_COMMAND_SYNTAX_ERROR;
4426 if (fastload==NULL)
4427 {
4428 LOG_ERROR("No image in memory");
4429 return ERROR_FAIL;
4430 }
4431 int i;
4432 int ms=timeval_ms();
4433 int size=0;
4434 int retval=ERROR_OK;
4435 for (i=0; i<fastload_num;i++)
4436 {
4437 target_t *target = get_current_target(cmd_ctx);
4438 command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x", fastload[i].address, fastload[i].length);
4439 if (retval==ERROR_OK)
4440 {
4441 retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
4442 }
4443 size+=fastload[i].length;
4444 }
4445 int after=timeval_ms();
4446 command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
4447 return retval;
4448 }
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)