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