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