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