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