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