Code Review / openocd.git / blob
? search:


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