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