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