Code Review / openocd.git / blob
? search:


91d48c45648953b19e71b83ac448c89e5f3abbdb
[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 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "replacements.h"
28 #include "target.h"
29 #include "target_request.h"
30
31 #include "log.h"
32 #include "configuration.h"
33 #include "binarybuffer.h"
34 #include "jtag.h"
35
36 #include <string.h>
37 #include <stdlib.h>
38 #include <inttypes.h>
39
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <errno.h>
44
45 #include <sys/time.h>
46 #include <time.h>
47
48 #include <time_support.h>
49
50 #include <fileio.h>
51 #include <image.h>
52
53 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
54
55 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57
58 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
60
61 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
77 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
78 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
79 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
80 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
81 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
82
83
84 /* targets */
85 extern target_type_t arm7tdmi_target;
86 extern target_type_t arm720t_target;
87 extern target_type_t arm9tdmi_target;
88 extern target_type_t arm920t_target;
89 extern target_type_t arm966e_target;
90 extern target_type_t arm926ejs_target;
91 extern target_type_t feroceon_target;
92 extern target_type_t xscale_target;
93 extern target_type_t cortexm3_target;
94 extern target_type_t arm11_target;
95
96 target_type_t *target_types[] =
97 {
98 &arm7tdmi_target,
99 &arm9tdmi_target,
100 &arm920t_target,
101 &arm720t_target,
102 &arm966e_target,
103 &arm926ejs_target,
104 &feroceon_target,
105 &xscale_target,
106 &cortexm3_target,
107 &arm11_target,
108 NULL,
109 };
110
111 target_t *targets = NULL;
112 target_event_callback_t *target_event_callbacks = NULL;
113 target_timer_callback_t *target_timer_callbacks = NULL;
114
115 char *target_state_strings[] =
116 {
117 "unknown",
118 "running",
119 "halted",
120 "reset",
121 "debug_running",
122 };
123
124 char *target_debug_reason_strings[] =
125 {
126 "debug request", "breakpoint", "watchpoint",
127 "watchpoint and breakpoint", "single step",
128 "target not halted", "undefined"
129 };
130
131 char *target_endianess_strings[] =
132 {
133 "big endian",
134 "little endian",
135 };
136
137 static int target_continous_poll = 1;
138
139 /* read a u32 from a buffer in target memory endianness */
140 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
141 {
142 if (target->endianness == TARGET_LITTLE_ENDIAN)
143 return le_to_h_u32(buffer);
144 else
145 return be_to_h_u32(buffer);
146 }
147
148 /* read a u16 from a buffer in target memory endianness */
149 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
150 {
151 if (target->endianness == TARGET_LITTLE_ENDIAN)
152 return le_to_h_u16(buffer);
153 else
154 return be_to_h_u16(buffer);
155 }
156
157 /* write a u32 to a buffer in target memory endianness */
158 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
159 {
160 if (target->endianness == TARGET_LITTLE_ENDIAN)
161 h_u32_to_le(buffer, value);
162 else
163 h_u32_to_be(buffer, value);
164 }
165
166 /* write a u16 to a buffer in target memory endianness */
167 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
168 {
169 if (target->endianness == TARGET_LITTLE_ENDIAN)
170 h_u16_to_le(buffer, value);
171 else
172 h_u16_to_be(buffer, value);
173 }
174
175 /* returns a pointer to the n-th configured target */
176 target_t* get_target_by_num(int num)
177 {
178 target_t *target = targets;
179 int i = 0;
180
181 while (target)
182 {
183 if (num == i)
184 return target;
185 target = target->next;
186 i++;
187 }
188
189 return NULL;
190 }
191
192 int get_num_by_target(target_t *query_target)
193 {
194 target_t *target = targets;
195 int i = 0;
196
197 while (target)
198 {
199 if (target == query_target)
200 return i;
201 target = target->next;
202 i++;
203 }
204
205 return -1;
206 }
207
208 target_t* get_current_target(command_context_t *cmd_ctx)
209 {
210 target_t *target = get_target_by_num(cmd_ctx->current_target);
211
212 if (target == NULL)
213 {
214 LOG_ERROR("BUG: current_target out of bounds");
215 exit(-1);
216 }
217
218 return target;
219 }
220
221 /* Process target initialization, when target entered debug out of reset
222 * the handler is unregistered at the end of this function, so it's only called once
223 */
224 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
225 {
226 struct command_context_s *cmd_ctx = priv;
227
228 if (event == TARGET_EVENT_HALTED)
229 {
230 target_unregister_event_callback(target_init_handler, priv);
231 target_invoke_script(cmd_ctx, target, "post_reset");
232 jtag_execute_queue();
233 }
234
235 return ERROR_OK;
236 }
237
238 int target_run_and_halt_handler(void *priv)
239 {
240 target_t *target = priv;
241
242 target_halt(target);
243
244 return ERROR_OK;
245 }
246
247 int target_poll(struct target_s *target)
248 {
249 /* We can't poll until after examine */
250 if (!target->type->examined)
251 {
252 /* Fail silently lest we pollute the log */
253 return ERROR_FAIL;
254 }
255 return target->type->poll(target);
256 }
257
258 int target_halt(struct target_s *target)
259 {
260 /* We can't poll until after examine */
261 if (!target->type->examined)
262 {
263 LOG_ERROR("Target not examined yet");
264 return ERROR_FAIL;
265 }
266 return target->type->halt(target);
267 }
268
269 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
270 {
271 int retval;
272
273 /* We can't poll until after examine */
274 if (!target->type->examined)
275 {
276 LOG_ERROR("Target not examined yet");
277 return ERROR_FAIL;
278 }
279
280 /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
281 * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
282 * the application.
283 */
284 if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
285 return retval;
286
287 return retval;
288 }
289
290 int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
291 {
292 int retval = ERROR_OK;
293 target_t *target;
294 struct timeval timeout, now;
295
296 target = targets;
297 while (target)
298 {
299 target_invoke_script(cmd_ctx, target, "pre_reset");
300 target = target->next;
301 }
302
303 if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
304 return retval;
305
306 keep_alive(); /* we might be running on a very slow JTAG clk */
307
308 /* First time this is executed after launching OpenOCD, it will read out
309 * the type of CPU, etc. and init Embedded ICE registers in host
310 * memory.
311 *
312 * It will also set up ICE registers in the target.
313 *
314 * However, if we assert TRST later, we need to set up the registers again.
315 *
316 * For the "reset halt/init" case we must only set up the registers here.
317 */
318 if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
319 return retval;
320
321 keep_alive(); /* we might be running on a very slow JTAG clk */
322
323 target = targets;
324 while (target)
325 {
326 /* we have no idea what state the target is in, so we
327 * have to drop working areas
328 */
329 target_free_all_working_areas_restore(target, 0);
330 target->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT));
331 target->type->assert_reset(target);
332 target = target->next;
333 }
334 if ((retval = jtag_execute_queue()) != ERROR_OK)
335 {
336 LOG_WARNING("JTAG communication failed asserting reset.");
337 retval = ERROR_OK;
338 }
339
340 /* request target halt if necessary, and schedule further action */
341 target = targets;
342 while (target)
343 {
344 switch (reset_mode)
345 {
346 case RESET_RUN:
347 /* nothing to do if target just wants to be run */
348 break;
349 case RESET_RUN_AND_HALT:
350 /* schedule halt */
351 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
352 break;
353 case RESET_RUN_AND_INIT:
354 /* schedule halt */
355 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
356 target_register_event_callback(target_init_handler, cmd_ctx);
357 break;
358 case RESET_HALT:
359 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
360 target_halt(target);
361 break;
362 case RESET_INIT:
363 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
364 target_halt(target);
365 target_register_event_callback(target_init_handler, cmd_ctx);
366 break;
367 default:
368 LOG_ERROR("BUG: unknown target->reset_mode");
369 }
370 target = target->next;
371 }
372
373 if ((retval = jtag_execute_queue()) != ERROR_OK)
374 {
375 LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config.");
376 retval = ERROR_OK;
377 }
378
379 target = targets;
380 while (target)
381 {
382 target->type->deassert_reset(target);
383 /* We can fail to bring the target into the halted state */
384 target_poll(target);
385 if (target->reset_halt&&((target->state != TARGET_HALTED)))
386 {
387 LOG_WARNING("Failed to reset target into halted mode - issuing halt");
388 target->type->halt(target);
389 }
390
391 target = target->next;
392 }
393
394 if ((retval = jtag_execute_queue()) != ERROR_OK)
395 {
396 LOG_WARNING("JTAG communication failed while deasserting reset.");
397 retval = ERROR_OK;
398 }
399
400 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
401 {
402 /* If TRST was asserted we need to set up registers again */
403 if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
404 return retval;
405 }
406
407 LOG_DEBUG("Waiting for halted stated as appropriate");
408
409 /* Wait for reset to complete, maximum 5 seconds. */
410 gettimeofday(&timeout, NULL);
411 timeval_add_time(&timeout, 5, 0);
412 for(;;)
413 {
414 gettimeofday(&now, NULL);
415
416 target_call_timer_callbacks_now();
417
418 target = targets;
419 while (target)
420 {
421 LOG_DEBUG("Polling target");
422 target_poll(target);
423 if ((reset_mode == RESET_RUN_AND_INIT) ||
424 (reset_mode == RESET_RUN_AND_HALT) ||
425 (reset_mode == RESET_HALT) ||
426 (reset_mode == RESET_INIT))
427 {
428 if (target->state != TARGET_HALTED)
429 {
430 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
431 {
432 LOG_USER("Timed out waiting for halt after reset");
433 goto done;
434 }
435 /* this will send alive messages on e.g. GDB remote protocol. */
436 usleep(500*1000);
437 LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/
438 goto again;
439 }
440 }
441 target = target->next;
442 }
443 /* All targets we're waiting for are halted */
444 break;
445
446 again:;
447 }
448 done:
449
450
451 /* We want any events to be processed before the prompt */
452 target_call_timer_callbacks_now();
453
454 /* if we timed out we need to unregister these handlers */
455 target = targets;
456 while (target)
457 {
458 target_unregister_timer_callback(target_run_and_halt_handler, target);
459 target = target->next;
460 }
461 target_unregister_event_callback(target_init_handler, cmd_ctx);
462
463 return retval;
464 }
465
466 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
467 {
468 *physical = virtual;
469 return ERROR_OK;
470 }
471
472 static int default_mmu(struct target_s *target, int *enabled)
473 {
474 *enabled = 0;
475 return ERROR_OK;
476 }
477
478 static int default_examine(struct command_context_s *cmd_ctx, struct target_s *target)
479 {
480 target->type->examined = 1;
481 return ERROR_OK;
482 }
483
484
485 /* Targets that correctly implement init+examine, i.e.
486 * no communication with target during init:
487 *
488 * XScale
489 */
490 int target_examine(struct command_context_s *cmd_ctx)
491 {
492 int retval = ERROR_OK;
493 target_t *target = targets;
494 while (target)
495 {
496 if ((retval = target->type->examine(cmd_ctx, target))!=ERROR_OK)
497 return retval;
498 target = target->next;
499 }
500 return retval;
501 }
502
503 static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
504 {
505 if (!target->type->examined)
506 {
507 LOG_ERROR("Target not examined yet");
508 return ERROR_FAIL;
509 }
510 return target->type->write_memory_imp(target, address, size, count, buffer);
511 }
512
513 static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
514 {
515 if (!target->type->examined)
516 {
517 LOG_ERROR("Target not examined yet");
518 return ERROR_FAIL;
519 }
520 return target->type->read_memory_imp(target, address, size, count, buffer);
521 }
522
523 static int target_soft_reset_halt_imp(struct target_s *target)
524 {
525 if (!target->type->examined)
526 {
527 LOG_ERROR("Target not examined yet");
528 return ERROR_FAIL;
529 }
530 return target->type->soft_reset_halt_imp(target);
531 }
532
533 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)
534 {
535 if (!target->type->examined)
536 {
537 LOG_ERROR("Target not examined yet");
538 return ERROR_FAIL;
539 }
540 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);
541 }
542
543 int target_init(struct command_context_s *cmd_ctx)
544 {
545 target_t *target = targets;
546
547 while (target)
548 {
549 target->type->examined = 0;
550 if (target->type->examine == NULL)
551 {
552 target->type->examine = default_examine;
553 }
554
555 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
556 {
557 LOG_ERROR("target '%s' init failed", target->type->name);
558 exit(-1);
559 }
560
561 /* Set up default functions if none are provided by target */
562 if (target->type->virt2phys == NULL)
563 {
564 target->type->virt2phys = default_virt2phys;
565 }
566 target->type->virt2phys = default_virt2phys;
567 /* a non-invasive way(in terms of patches) to add some code that
568 * runs before the type->write/read_memory implementation
569 */
570 target->type->write_memory_imp = target->type->write_memory;
571 target->type->write_memory = target_write_memory_imp;
572 target->type->read_memory_imp = target->type->read_memory;
573 target->type->read_memory = target_read_memory_imp;
574 target->type->soft_reset_halt_imp = target->type->soft_reset_halt;
575 target->type->soft_reset_halt = target_soft_reset_halt_imp;
576 target->type->run_algorithm_imp = target->type->run_algorithm;
577 target->type->run_algorithm = target_run_algorithm_imp;
578
579
580 if (target->type->mmu == NULL)
581 {
582 target->type->mmu = default_mmu;
583 }
584 target = target->next;
585 }
586
587 if (targets)
588 {
589 target_register_user_commands(cmd_ctx);
590 target_register_timer_callback(handle_target, 100, 1, NULL);
591 }
592
593 return ERROR_OK;
594 }
595
596 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
597 {
598 target_event_callback_t **callbacks_p = &target_event_callbacks;
599
600 if (callback == NULL)
601 {
602 return ERROR_INVALID_ARGUMENTS;
603 }
604
605 if (*callbacks_p)
606 {
607 while ((*callbacks_p)->next)
608 callbacks_p = &((*callbacks_p)->next);
609 callbacks_p = &((*callbacks_p)->next);
610 }
611
612 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
613 (*callbacks_p)->callback = callback;
614 (*callbacks_p)->priv = priv;
615 (*callbacks_p)->next = NULL;
616
617 return ERROR_OK;
618 }
619
620 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
621 {
622 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
623 struct timeval now;
624
625 if (callback == NULL)
626 {
627 return ERROR_INVALID_ARGUMENTS;
628 }
629
630 if (*callbacks_p)
631 {
632 while ((*callbacks_p)->next)
633 callbacks_p = &((*callbacks_p)->next);
634 callbacks_p = &((*callbacks_p)->next);
635 }
636
637 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
638 (*callbacks_p)->callback = callback;
639 (*callbacks_p)->periodic = periodic;
640 (*callbacks_p)->time_ms = time_ms;
641
642 gettimeofday(&now, NULL);
643 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
644 time_ms -= (time_ms % 1000);
645 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
646 if ((*callbacks_p)->when.tv_usec > 1000000)
647 {
648 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
649 (*callbacks_p)->when.tv_sec += 1;
650 }
651
652 (*callbacks_p)->priv = priv;
653 (*callbacks_p)->next = NULL;
654
655 return ERROR_OK;
656 }
657
658 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
659 {
660 target_event_callback_t **p = &target_event_callbacks;
661 target_event_callback_t *c = target_event_callbacks;
662
663 if (callback == NULL)
664 {
665 return ERROR_INVALID_ARGUMENTS;
666 }
667
668 while (c)
669 {
670 target_event_callback_t *next = c->next;
671 if ((c->callback == callback) && (c->priv == priv))
672 {
673 *p = next;
674 free(c);
675 return ERROR_OK;
676 }
677 else
678 p = &(c->next);
679 c = next;
680 }
681
682 return ERROR_OK;
683 }
684
685 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
686 {
687 target_timer_callback_t **p = &target_timer_callbacks;
688 target_timer_callback_t *c = target_timer_callbacks;
689
690 if (callback == NULL)
691 {
692 return ERROR_INVALID_ARGUMENTS;
693 }
694
695 while (c)
696 {
697 target_timer_callback_t *next = c->next;
698 if ((c->callback == callback) && (c->priv == priv))
699 {
700 *p = next;
701 free(c);
702 return ERROR_OK;
703 }
704 else
705 p = &(c->next);
706 c = next;
707 }
708
709 return ERROR_OK;
710 }
711
712 int target_call_event_callbacks(target_t *target, enum target_event event)
713 {
714 target_event_callback_t *callback = target_event_callbacks;
715 target_event_callback_t *next_callback;
716
717 LOG_DEBUG("target event %i", event);
718
719 while (callback)
720 {
721 next_callback = callback->next;
722 callback->callback(target, event, callback->priv);
723 callback = next_callback;
724 }
725
726 return ERROR_OK;
727 }
728
729 static int target_call_timer_callbacks_check_time(int checktime)
730 {
731 target_timer_callback_t *callback = target_timer_callbacks;
732 target_timer_callback_t *next_callback;
733 struct timeval now;
734
735 keep_alive();
736
737 gettimeofday(&now, NULL);
738
739 while (callback)
740 {
741 next_callback = callback->next;
742
743 if ((!checktime&&callback->periodic)||
744 (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
745 || (now.tv_sec > callback->when.tv_sec)))
746 {
747 if(callback->callback != NULL)
748 {
749 callback->callback(callback->priv);
750 if (callback->periodic)
751 {
752 int time_ms = callback->time_ms;
753 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
754 time_ms -= (time_ms % 1000);
755 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
756 if (callback->when.tv_usec > 1000000)
757 {
758 callback->when.tv_usec = callback->when.tv_usec - 1000000;
759 callback->when.tv_sec += 1;
760 }
761 }
762 else
763 target_unregister_timer_callback(callback->callback, callback->priv);
764 }
765 }
766
767 callback = next_callback;
768 }
769
770 return ERROR_OK;
771 }
772
773 int target_call_timer_callbacks()
774 {
775 return target_call_timer_callbacks_check_time(1);
776 }
777
778 /* invoke periodic callbacks immediately */
779 int target_call_timer_callbacks_now()
780 {
781 return target_call_timer_callbacks(0);
782 }
783
784 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
785 {
786 working_area_t *c = target->working_areas;
787 working_area_t *new_wa = NULL;
788
789 /* Reevaluate working area address based on MMU state*/
790 if (target->working_areas == NULL)
791 {
792 int retval;
793 int enabled;
794 retval = target->type->mmu(target, &enabled);
795 if (retval != ERROR_OK)
796 {
797 return retval;
798 }
799 if (enabled)
800 {
801 target->working_area = target->working_area_virt;
802 }
803 else
804 {
805 target->working_area = target->working_area_phys;
806 }
807 }
808
809 /* only allocate multiples of 4 byte */
810 if (size % 4)
811 {
812 LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
813 size = CEIL(size, 4);
814 }
815
816 /* see if there's already a matching working area */
817 while (c)
818 {
819 if ((c->free) && (c->size == size))
820 {
821 new_wa = c;
822 break;
823 }
824 c = c->next;
825 }
826
827 /* if not, allocate a new one */
828 if (!new_wa)
829 {
830 working_area_t **p = &target->working_areas;
831 u32 first_free = target->working_area;
832 u32 free_size = target->working_area_size;
833
834 LOG_DEBUG("allocating new working area");
835
836 c = target->working_areas;
837 while (c)
838 {
839 first_free += c->size;
840 free_size -= c->size;
841 p = &c->next;
842 c = c->next;
843 }
844
845 if (free_size < size)
846 {
847 LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
848 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
849 }
850
851 new_wa = malloc(sizeof(working_area_t));
852 new_wa->next = NULL;
853 new_wa->size = size;
854 new_wa->address = first_free;
855
856 if (target->backup_working_area)
857 {
858 new_wa->backup = malloc(new_wa->size);
859 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
860 }
861 else
862 {
863 new_wa->backup = NULL;
864 }
865
866 /* put new entry in list */
867 *p = new_wa;
868 }
869
870 /* mark as used, and return the new (reused) area */
871 new_wa->free = 0;
872 *area = new_wa;
873
874 /* user pointer */
875 new_wa->user = area;
876
877 return ERROR_OK;
878 }
879
880 int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore)
881 {
882 if (area->free)
883 return ERROR_OK;
884
885 if (restore&&target->backup_working_area)
886 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
887
888 area->free = 1;
889
890 /* mark user pointer invalid */
891 *area->user = NULL;
892 area->user = NULL;
893
894 return ERROR_OK;
895 }
896
897 int target_free_working_area(struct target_s *target, working_area_t *area)
898 {
899 return target_free_working_area_restore(target, area, 1);
900 }
901
902 int target_free_all_working_areas_restore(struct target_s *target, int restore)
903 {
904 working_area_t *c = target->working_areas;
905
906 while (c)
907 {
908 working_area_t *next = c->next;
909 target_free_working_area_restore(target, c, restore);
910
911 if (c->backup)
912 free(c->backup);
913
914 free(c);
915
916 c = next;
917 }
918
919 target->working_areas = NULL;
920
921 return ERROR_OK;
922 }
923
924 int target_free_all_working_areas(struct target_s *target)
925 {
926 return target_free_all_working_areas_restore(target, 1);
927 }
928
929 int target_register_commands(struct command_context_s *cmd_ctx)
930 {
931 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
932 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
933 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, "<target> <run time ms>");
934 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
935 register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
936 register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
937
938
939 /* script procedures */
940 register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
941 register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
942 return ERROR_OK;
943 }
944
945 int target_arch_state(struct target_s *target)
946 {
947 int retval;
948 if (target==NULL)
949 {
950 LOG_USER("No target has been configured");
951 return ERROR_OK;
952 }
953
954 LOG_USER("target state: %s", target_state_strings[target->state]);
955
956 if (target->state!=TARGET_HALTED)
957 return ERROR_OK;
958
959 retval=target->type->arch_state(target);
960 return retval;
961 }
962
963 /* Single aligned words are guaranteed to use 16 or 32 bit access
964 * mode respectively, otherwise data is handled as quickly as
965 * possible
966 */
967 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
968 {
969 int retval;
970 if (!target->type->examined)
971 {
972 LOG_ERROR("Target not examined yet");
973 return ERROR_FAIL;
974 }
975
976 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
977
978 if (((address % 2) == 0) && (size == 2))
979 {
980 return target->type->write_memory(target, address, 2, 1, buffer);
981 }
982
983 /* handle unaligned head bytes */
984 if (address % 4)
985 {
986 int unaligned = 4 - (address % 4);
987
988 if (unaligned > size)
989 unaligned = size;
990
991 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
992 return retval;
993
994 buffer += unaligned;
995 address += unaligned;
996 size -= unaligned;
997 }
998
999 /* handle aligned words */
1000 if (size >= 4)
1001 {
1002 int aligned = size - (size % 4);
1003
1004 /* use bulk writes above a certain limit. This may have to be changed */
1005 if (aligned > 128)
1006 {
1007 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1008 return retval;
1009 }
1010 else
1011 {
1012 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1013 return retval;
1014 }
1015
1016 buffer += aligned;
1017 address += aligned;
1018 size -= aligned;
1019 }
1020
1021 /* handle tail writes of less than 4 bytes */
1022 if (size > 0)
1023 {
1024 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1025 return retval;
1026 }
1027
1028 return ERROR_OK;
1029 }
1030
1031
1032 /* Single aligned words are guaranteed to use 16 or 32 bit access
1033 * mode respectively, otherwise data is handled as quickly as
1034 * possible
1035 */
1036 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
1037 {
1038 int retval;
1039 if (!target->type->examined)
1040 {
1041 LOG_ERROR("Target not examined yet");
1042 return ERROR_FAIL;
1043 }
1044
1045 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
1046
1047 if (((address % 2) == 0) && (size == 2))
1048 {
1049 return target->type->read_memory(target, address, 2, 1, buffer);
1050 }
1051
1052 /* handle unaligned head bytes */
1053 if (address % 4)
1054 {
1055 int unaligned = 4 - (address % 4);
1056
1057 if (unaligned > size)
1058 unaligned = size;
1059
1060 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1061 return retval;
1062
1063 buffer += unaligned;
1064 address += unaligned;
1065 size -= unaligned;
1066 }
1067
1068 /* handle aligned words */
1069 if (size >= 4)
1070 {
1071 int aligned = size - (size % 4);
1072
1073 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1074 return retval;
1075
1076 buffer += aligned;
1077 address += aligned;
1078 size -= aligned;
1079 }
1080
1081 /* handle tail writes of less than 4 bytes */
1082 if (size > 0)
1083 {
1084 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1085 return retval;
1086 }
1087
1088 return ERROR_OK;
1089 }
1090
1091 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1092 {
1093 u8 *buffer;
1094 int retval;
1095 int i;
1096 u32 checksum = 0;
1097 if (!target->type->examined)
1098 {
1099 LOG_ERROR("Target not examined yet");
1100 return ERROR_FAIL;
1101 }
1102
1103 if ((retval = target->type->checksum_memory(target, address,
1104 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1105 {
1106 buffer = malloc(size);
1107 if (buffer == NULL)
1108 {
1109 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1110 return ERROR_INVALID_ARGUMENTS;
1111 }
1112 retval = target_read_buffer(target, address, size, buffer);
1113 if (retval != ERROR_OK)
1114 {
1115 free(buffer);
1116 return retval;
1117 }
1118
1119 /* convert to target endianess */
1120 for (i = 0; i < (size/sizeof(u32)); i++)
1121 {
1122 u32 target_data;
1123 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1124 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1125 }
1126
1127 retval = image_calculate_checksum( buffer, size, &checksum );
1128 free(buffer);
1129 }
1130
1131 *crc = checksum;
1132
1133 return retval;
1134 }
1135
1136 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
1137 {
1138 int retval;
1139 if (!target->type->examined)
1140 {
1141 LOG_ERROR("Target not examined yet");
1142 return ERROR_FAIL;
1143 }
1144
1145 if (target->type->blank_check_memory == 0)
1146 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1147
1148 retval = target->type->blank_check_memory(target, address, size, blank);
1149
1150 return retval;
1151 }
1152
1153 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1154 {
1155 u8 value_buf[4];
1156 if (!target->type->examined)
1157 {
1158 LOG_ERROR("Target not examined yet");
1159 return ERROR_FAIL;
1160 }
1161
1162 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1163
1164 if (retval == ERROR_OK)
1165 {
1166 *value = target_buffer_get_u32(target, value_buf);
1167 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1168 }
1169 else
1170 {
1171 *value = 0x0;
1172 LOG_DEBUG("address: 0x%8.8x failed", address);
1173 }
1174
1175 return retval;
1176 }
1177
1178 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1179 {
1180 u8 value_buf[2];
1181 if (!target->type->examined)
1182 {
1183 LOG_ERROR("Target not examined yet");
1184 return ERROR_FAIL;
1185 }
1186
1187 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1188
1189 if (retval == ERROR_OK)
1190 {
1191 *value = target_buffer_get_u16(target, value_buf);
1192 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1193 }
1194 else
1195 {
1196 *value = 0x0;
1197 LOG_DEBUG("address: 0x%8.8x failed", address);
1198 }
1199
1200 return retval;
1201 }
1202
1203 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1204 {
1205 int retval = target->type->read_memory(target, address, 1, 1, value);
1206 if (!target->type->examined)
1207 {
1208 LOG_ERROR("Target not examined yet");
1209 return ERROR_FAIL;
1210 }
1211
1212 if (retval == ERROR_OK)
1213 {
1214 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1215 }
1216 else
1217 {
1218 *value = 0x0;
1219 LOG_DEBUG("address: 0x%8.8x failed", address);
1220 }
1221
1222 return retval;
1223 }
1224
1225 int target_write_u32(struct target_s *target, u32 address, u32 value)
1226 {
1227 int retval;
1228 u8 value_buf[4];
1229 if (!target->type->examined)
1230 {
1231 LOG_ERROR("Target not examined yet");
1232 return ERROR_FAIL;
1233 }
1234
1235 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1236
1237 target_buffer_set_u32(target, value_buf, value);
1238 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1239 {
1240 LOG_DEBUG("failed: %i", retval);
1241 }
1242
1243 return retval;
1244 }
1245
1246 int target_write_u16(struct target_s *target, u32 address, u16 value)
1247 {
1248 int retval;
1249 u8 value_buf[2];
1250 if (!target->type->examined)
1251 {
1252 LOG_ERROR("Target not examined yet");
1253 return ERROR_FAIL;
1254 }
1255
1256 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1257
1258 target_buffer_set_u16(target, value_buf, value);
1259 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1260 {
1261 LOG_DEBUG("failed: %i", retval);
1262 }
1263
1264 return retval;
1265 }
1266
1267 int target_write_u8(struct target_s *target, u32 address, u8 value)
1268 {
1269 int retval;
1270 if (!target->type->examined)
1271 {
1272 LOG_ERROR("Target not examined yet");
1273 return ERROR_FAIL;
1274 }
1275
1276 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1277
1278 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1279 {
1280 LOG_DEBUG("failed: %i", retval);
1281 }
1282
1283 return retval;
1284 }
1285
1286 int target_register_user_commands(struct command_context_s *cmd_ctx)
1287 {
1288 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1289 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1290 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1291 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1292 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1293 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1294 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1295 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1296
1297 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1298 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1299 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1300
1301 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1302 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1303 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1304
1305 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1306 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1307 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1308 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1309
1310 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1311 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1312 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1313 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1314 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1315
1316 target_request_register_commands(cmd_ctx);
1317 trace_register_commands(cmd_ctx);
1318
1319 return ERROR_OK;
1320 }
1321
1322 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1323 {
1324 target_t *target = targets;
1325 int count = 0;
1326
1327 if (argc == 1)
1328 {
1329 int num = strtoul(args[0], NULL, 0);
1330
1331 while (target)
1332 {
1333 count++;
1334 target = target->next;
1335 }
1336
1337 if (num < count)
1338 cmd_ctx->current_target = num;
1339 else
1340 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1341
1342 return ERROR_OK;
1343 }
1344
1345 while (target)
1346 {
1347 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1348 target = target->next;
1349 }
1350
1351 return ERROR_OK;
1352 }
1353
1354 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1355 {
1356 int i;
1357 int found = 0;
1358
1359 if (argc < 3)
1360 {
1361 return ERROR_COMMAND_SYNTAX_ERROR;
1362 }
1363
1364 /* search for the specified target */
1365 if (args[0] && (args[0][0] != 0))
1366 {
1367 for (i = 0; target_types[i]; i++)
1368 {
1369 if (strcmp(args[0], target_types[i]->name) == 0)
1370 {
1371 target_t **last_target_p = &targets;
1372
1373 /* register target specific commands */
1374 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1375 {
1376 LOG_ERROR("couldn't register '%s' commands", args[0]);
1377 exit(-1);
1378 }
1379
1380 if (*last_target_p)
1381 {
1382 while ((*last_target_p)->next)
1383 last_target_p = &((*last_target_p)->next);
1384 last_target_p = &((*last_target_p)->next);
1385 }
1386
1387 *last_target_p = malloc(sizeof(target_t));
1388
1389 /* allocate memory for each unique target type */
1390 (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
1391 *((*last_target_p)->type) = *target_types[i];
1392
1393 if (strcmp(args[1], "big") == 0)
1394 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1395 else if (strcmp(args[1], "little") == 0)
1396 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1397 else
1398 {
1399 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1400 return ERROR_COMMAND_SYNTAX_ERROR;
1401 }
1402
1403 if (strcmp(args[2], "reset_halt") == 0)
1404 {
1405 LOG_WARNING("reset_mode argument is obsolete.");
1406 return ERROR_COMMAND_SYNTAX_ERROR;
1407 }
1408 else if (strcmp(args[2], "reset_run") == 0)
1409 {
1410 LOG_WARNING("reset_mode argument is obsolete.");
1411 return ERROR_COMMAND_SYNTAX_ERROR;
1412 }
1413 else if (strcmp(args[2], "reset_init") == 0)
1414 {
1415 LOG_WARNING("reset_mode argument is obsolete.");
1416 return ERROR_COMMAND_SYNTAX_ERROR;
1417 }
1418 else if (strcmp(args[2], "run_and_halt") == 0)
1419 {
1420 LOG_WARNING("reset_mode argument is obsolete.");
1421 return ERROR_COMMAND_SYNTAX_ERROR;
1422 }
1423 else if (strcmp(args[2], "run_and_init") == 0)
1424 {
1425 LOG_WARNING("reset_mode argument is obsolete.");
1426 return ERROR_COMMAND_SYNTAX_ERROR;
1427 }
1428 else
1429 {
1430 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1431 args--;
1432 argc++;
1433 }
1434 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1435
1436 (*last_target_p)->working_area = 0x0;
1437 (*last_target_p)->working_area_size = 0x0;
1438 (*last_target_p)->working_areas = NULL;
1439 (*last_target_p)->backup_working_area = 0;
1440
1441 (*last_target_p)->state = TARGET_UNKNOWN;
1442 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1443 (*last_target_p)->reg_cache = NULL;
1444 (*last_target_p)->breakpoints = NULL;
1445 (*last_target_p)->watchpoints = NULL;
1446 (*last_target_p)->next = NULL;
1447 (*last_target_p)->arch_info = NULL;
1448
1449 /* initialize trace information */
1450 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1451 (*last_target_p)->trace_info->num_trace_points = 0;
1452 (*last_target_p)->trace_info->trace_points_size = 0;
1453 (*last_target_p)->trace_info->trace_points = NULL;
1454 (*last_target_p)->trace_info->trace_history_size = 0;
1455 (*last_target_p)->trace_info->trace_history = NULL;
1456 (*last_target_p)->trace_info->trace_history_pos = 0;
1457 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1458
1459 (*last_target_p)->dbgmsg = NULL;
1460 (*last_target_p)->dbg_msg_enabled = 0;
1461
1462 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1463
1464 found = 1;
1465 break;
1466 }
1467 }
1468 }
1469
1470 /* no matching target found */
1471 if (!found)
1472 {
1473 LOG_ERROR("target '%s' not found", args[0]);
1474 return ERROR_COMMAND_SYNTAX_ERROR;
1475 }
1476
1477 return ERROR_OK;
1478 }
1479
1480 int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
1481 {
1482 return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
1483 get_num_by_target(target), name,
1484 get_num_by_target(target), name);
1485 }
1486
1487 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1488 {
1489 target_t *target = NULL;
1490
1491 if (argc < 2)
1492 {
1493 return ERROR_COMMAND_SYNTAX_ERROR;
1494 }
1495
1496 target = get_target_by_num(strtoul(args[0], NULL, 0));
1497 if (!target)
1498 {
1499 return ERROR_COMMAND_SYNTAX_ERROR;
1500 }
1501
1502 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1503
1504 return ERROR_OK;
1505 }
1506
1507 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1508 {
1509 target_t *target = NULL;
1510
1511 if ((argc < 4) || (argc > 5))
1512 {
1513 return ERROR_COMMAND_SYNTAX_ERROR;
1514 }
1515
1516 target = get_target_by_num(strtoul(args[0], NULL, 0));
1517 if (!target)
1518 {
1519 return ERROR_COMMAND_SYNTAX_ERROR;
1520 }
1521 target_free_all_working_areas(target);
1522
1523 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1524 if (argc == 5)
1525 {
1526 target->working_area_virt = strtoul(args[4], NULL, 0);
1527 }
1528 target->working_area_size = strtoul(args[2], NULL, 0);
1529
1530 if (strcmp(args[3], "backup") == 0)
1531 {
1532 target->backup_working_area = 1;
1533 }
1534 else if (strcmp(args[3], "nobackup") == 0)
1535 {
1536 target->backup_working_area = 0;
1537 }
1538 else
1539 {
1540 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1541 return ERROR_COMMAND_SYNTAX_ERROR;
1542 }
1543
1544 return ERROR_OK;
1545 }
1546
1547
1548 /* process target state changes */
1549 int handle_target(void *priv)
1550 {
1551 target_t *target = targets;
1552
1553 while (target)
1554 {
1555 if (target_continous_poll)
1556 {
1557 /* polling may fail silently until the target has been examined */
1558 target_poll(target);
1559 }
1560
1561 target = target->next;
1562 }
1563
1564 return ERROR_OK;
1565 }
1566
1567 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1568 {
1569 target_t *target;
1570 reg_t *reg = NULL;
1571 int count = 0;
1572 char *value;
1573
1574 LOG_DEBUG("-");
1575
1576 target = get_current_target(cmd_ctx);
1577
1578 /* list all available registers for the current target */
1579 if (argc == 0)
1580 {
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 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1590 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);
1591 free(value);
1592 }
1593 cache = cache->next;
1594 }
1595
1596 return ERROR_OK;
1597 }
1598
1599 /* access a single register by its ordinal number */
1600 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1601 {
1602 int num = strtoul(args[0], NULL, 0);
1603 reg_cache_t *cache = target->reg_cache;
1604
1605 count = 0;
1606 while(cache)
1607 {
1608 int i;
1609 for (i = 0; i < cache->num_regs; i++)
1610 {
1611 if (count++ == num)
1612 {
1613 reg = &cache->reg_list[i];
1614 break;
1615 }
1616 }
1617 if (reg)
1618 break;
1619 cache = cache->next;
1620 }
1621
1622 if (!reg)
1623 {
1624 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1625 return ERROR_OK;
1626 }
1627 } else /* access a single register by its name */
1628 {
1629 reg = register_get_by_name(target->reg_cache, args[0], 1);
1630
1631 if (!reg)
1632 {
1633 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1634 return ERROR_OK;
1635 }
1636 }
1637
1638 /* display a register */
1639 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1640 {
1641 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1642 reg->valid = 0;
1643
1644 if (reg->valid == 0)
1645 {
1646 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1647 if (arch_type == NULL)
1648 {
1649 LOG_ERROR("BUG: encountered unregistered arch type");
1650 return ERROR_OK;
1651 }
1652 arch_type->get(reg);
1653 }
1654 value = buf_to_str(reg->value, reg->size, 16);
1655 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1656 free(value);
1657 return ERROR_OK;
1658 }
1659
1660 /* set register value */
1661 if (argc == 2)
1662 {
1663 u8 *buf = malloc(CEIL(reg->size, 8));
1664 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1665
1666 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1667 if (arch_type == NULL)
1668 {
1669 LOG_ERROR("BUG: encountered unregistered arch type");
1670 return ERROR_OK;
1671 }
1672
1673 arch_type->set(reg, buf);
1674
1675 value = buf_to_str(reg->value, reg->size, 16);
1676 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1677 free(value);
1678
1679 free(buf);
1680
1681 return ERROR_OK;
1682 }
1683
1684 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1685
1686 return ERROR_OK;
1687 }
1688
1689
1690 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1691 {
1692 target_t *target = get_current_target(cmd_ctx);
1693
1694 if (argc == 0)
1695 {
1696 target_poll(target);
1697 target_arch_state(target);
1698 }
1699 else
1700 {
1701 if (strcmp(args[0], "on") == 0)
1702 {
1703 target_continous_poll = 1;
1704 }
1705 else if (strcmp(args[0], "off") == 0)
1706 {
1707 target_continous_poll = 0;
1708 }
1709 else
1710 {
1711 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1712 }
1713 }
1714
1715
1716 return ERROR_OK;
1717 }
1718
1719 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1720 {
1721 int ms = 5000;
1722
1723 if (argc > 0)
1724 {
1725 char *end;
1726
1727 ms = strtoul(args[0], &end, 0) * 1000;
1728 if (*end)
1729 {
1730 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1731 return ERROR_OK;
1732 }
1733 }
1734 target_t *target = get_current_target(cmd_ctx);
1735
1736 return target_wait_state(target, TARGET_HALTED, ms);
1737 }
1738
1739 int target_wait_state(target_t *target, enum target_state state, int ms)
1740 {
1741 int retval;
1742 struct timeval timeout, now;
1743 int once=1;
1744 gettimeofday(&timeout, NULL);
1745 timeval_add_time(&timeout, 0, ms * 1000);
1746
1747 for (;;)
1748 {
1749 if ((retval=target_poll(target))!=ERROR_OK)
1750 return retval;
1751 target_call_timer_callbacks_now();
1752 if (target->state == state)
1753 {
1754 break;
1755 }
1756 if (once)
1757 {
1758 once=0;
1759 LOG_USER("waiting for target %s...", target_state_strings[state]);
1760 }
1761
1762 gettimeofday(&now, NULL);
1763 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1764 {
1765 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1766 break;
1767 }
1768 }
1769
1770 return ERROR_OK;
1771 }
1772
1773 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1774 {
1775 int retval;
1776 target_t *target = get_current_target(cmd_ctx);
1777
1778 LOG_DEBUG("-");
1779
1780 if ((retval = target_halt(target)) != ERROR_OK)
1781 {
1782 return retval;
1783 }
1784
1785 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1786 }
1787
1788 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1789 {
1790 target_t *target = get_current_target(cmd_ctx);
1791
1792 LOG_USER("requesting target halt and executing a soft reset");
1793
1794 target->type->soft_reset_halt(target);
1795
1796 return ERROR_OK;
1797 }
1798
1799 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1800 {
1801 target_t *target = get_current_target(cmd_ctx);
1802 enum target_reset_mode reset_mode = RESET_RUN;
1803
1804 LOG_DEBUG("-");
1805
1806 if (argc >= 1)
1807 {
1808 if (strcmp("run", args[0]) == 0)
1809 reset_mode = RESET_RUN;
1810 else if (strcmp("halt", args[0]) == 0)
1811 reset_mode = RESET_HALT;
1812 else if (strcmp("init", args[0]) == 0)
1813 reset_mode = RESET_INIT;
1814 else if (strcmp("run_and_halt", args[0]) == 0)
1815 {
1816 reset_mode = RESET_RUN_AND_HALT;
1817 if (argc >= 2)
1818 {
1819 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1820 }
1821 }
1822 else if (strcmp("run_and_init", args[0]) == 0)
1823 {
1824 reset_mode = RESET_RUN_AND_INIT;
1825 if (argc >= 2)
1826 {
1827 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1828 }
1829 }
1830 else
1831 {
1832 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1833 return ERROR_OK;
1834 }
1835 }
1836
1837 /* reset *all* targets */
1838 target_process_reset(cmd_ctx, reset_mode);
1839
1840 return ERROR_OK;
1841 }
1842
1843 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1844 {
1845 int retval;
1846 target_t *target = get_current_target(cmd_ctx);
1847
1848 target_invoke_script(cmd_ctx, target, "pre_resume");
1849
1850 if (argc == 0)
1851 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1852 else if (argc == 1)
1853 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1854 else
1855 {
1856 return ERROR_COMMAND_SYNTAX_ERROR;
1857 }
1858
1859 return retval;
1860 }
1861
1862 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1863 {
1864 target_t *target = get_current_target(cmd_ctx);
1865
1866 LOG_DEBUG("-");
1867
1868 if (argc == 0)
1869 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1870
1871 if (argc == 1)
1872 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1873
1874 return ERROR_OK;
1875 }
1876
1877 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1878 {
1879 const int line_bytecnt = 32;
1880 int count = 1;
1881 int size = 4;
1882 u32 address = 0;
1883 int line_modulo;
1884 int i;
1885
1886 char output[128];
1887 int output_len;
1888
1889 int retval;
1890
1891 u8 *buffer;
1892 target_t *target = get_current_target(cmd_ctx);
1893
1894 if (argc < 1)
1895 return ERROR_OK;
1896
1897 if (argc == 2)
1898 count = strtoul(args[1], NULL, 0);
1899
1900 address = strtoul(args[0], NULL, 0);
1901
1902
1903 switch (cmd[2])
1904 {
1905 case 'w':
1906 size = 4; line_modulo = line_bytecnt / 4;
1907 break;
1908 case 'h':
1909 size = 2; line_modulo = line_bytecnt / 2;
1910 break;
1911 case 'b':
1912 size = 1; line_modulo = line_bytecnt / 1;
1913 break;
1914 default:
1915 return ERROR_OK;
1916 }
1917
1918 buffer = calloc(count, size);
1919 retval = target->type->read_memory(target, address, size, count, buffer);
1920 if (retval == ERROR_OK)
1921 {
1922 output_len = 0;
1923
1924 for (i = 0; i < count; i++)
1925 {
1926 if (i%line_modulo == 0)
1927 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1928
1929 switch (size)
1930 {
1931 case 4:
1932 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1933 break;
1934 case 2:
1935 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1936 break;
1937 case 1:
1938 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1939 break;
1940 }
1941
1942 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1943 {
1944 command_print(cmd_ctx, output);
1945 output_len = 0;
1946 }
1947 }
1948 }
1949
1950 free(buffer);
1951
1952 return retval;
1953 }
1954
1955 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1956 {
1957 u32 address = 0;
1958 u32 value = 0;
1959 int count = 1;
1960 int i;
1961 int wordsize;
1962 target_t *target = get_current_target(cmd_ctx);
1963 u8 value_buf[4];
1964
1965 if ((argc < 2) || (argc > 3))
1966 return ERROR_COMMAND_SYNTAX_ERROR;
1967
1968 address = strtoul(args[0], NULL, 0);
1969 value = strtoul(args[1], NULL, 0);
1970 if (argc == 3)
1971 count = strtoul(args[2], NULL, 0);
1972
1973 switch (cmd[2])
1974 {
1975 case 'w':
1976 wordsize = 4;
1977 target_buffer_set_u32(target, value_buf, value);
1978 break;
1979 case 'h':
1980 wordsize = 2;
1981 target_buffer_set_u16(target, value_buf, value);
1982 break;
1983 case 'b':
1984 wordsize = 1;
1985 value_buf[0] = value;
1986 break;
1987 default:
1988 return ERROR_COMMAND_SYNTAX_ERROR;
1989 }
1990 for (i=0; i<count; i++)
1991 {
1992 int retval;
1993 switch (wordsize)
1994 {
1995 case 4:
1996 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
1997 break;
1998 case 2:
1999 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
2000 break;
2001 case 1:
2002 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
2003 break;
2004 default:
2005 return ERROR_OK;
2006 }
2007 if (retval!=ERROR_OK)
2008 {
2009 return retval;
2010 }
2011 }
2012
2013 return ERROR_OK;
2014
2015 }
2016
2017 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2018 {
2019 u8 *buffer;
2020 u32 buf_cnt;
2021 u32 image_size;
2022 int i;
2023 int retval;
2024
2025 image_t image;
2026
2027 duration_t duration;
2028 char *duration_text;
2029
2030 target_t *target = get_current_target(cmd_ctx);
2031
2032 if (argc < 1)
2033 {
2034 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
2035 return ERROR_OK;
2036 }
2037
2038 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2039 if (argc >= 2)
2040 {
2041 image.base_address_set = 1;
2042 image.base_address = strtoul(args[1], NULL, 0);
2043 }
2044 else
2045 {
2046 image.base_address_set = 0;
2047 }
2048
2049 image.start_address_set = 0;
2050
2051 duration_start_measure(&duration);
2052
2053 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2054 {
2055 return ERROR_OK;
2056 }
2057
2058 image_size = 0x0;
2059 retval = ERROR_OK;
2060 for (i = 0; i < image.num_sections; i++)
2061 {
2062 buffer = malloc(image.sections[i].size);
2063 if (buffer == NULL)
2064 {
2065 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2066 break;
2067 }
2068
2069 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2070 {
2071 free(buffer);
2072 break;
2073 }
2074 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
2075 {
2076 free(buffer);
2077 break;
2078 }
2079 image_size += buf_cnt;
2080 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2081
2082 free(buffer);
2083 }
2084
2085 duration_stop_measure(&duration, &duration_text);
2086 if (retval==ERROR_OK)
2087 {
2088 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2089 }
2090 free(duration_text);
2091
2092 image_close(&image);
2093
2094 return retval;
2095
2096 }
2097
2098 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2099 {
2100 fileio_t fileio;
2101
2102 u32 address;
2103 u32 size;
2104 u8 buffer[560];
2105 int retval=ERROR_OK;
2106
2107 duration_t duration;
2108 char *duration_text;
2109
2110 target_t *target = get_current_target(cmd_ctx);
2111
2112 if (argc != 3)
2113 {
2114 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2115 return ERROR_OK;
2116 }
2117
2118 address = strtoul(args[1], NULL, 0);
2119 size = strtoul(args[2], NULL, 0);
2120
2121 if ((address & 3) || (size & 3))
2122 {
2123 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2124 return ERROR_OK;
2125 }
2126
2127 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2128 {
2129 return ERROR_OK;
2130 }
2131
2132 duration_start_measure(&duration);
2133
2134 while (size > 0)
2135 {
2136 u32 size_written;
2137 u32 this_run_size = (size > 560) ? 560 : size;
2138
2139 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2140 if (retval != ERROR_OK)
2141 {
2142 break;
2143 }
2144
2145 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2146 if (retval != ERROR_OK)
2147 {
2148 break;
2149 }
2150
2151 size -= this_run_size;
2152 address += this_run_size;
2153 }
2154
2155 fileio_close(&fileio);
2156
2157 duration_stop_measure(&duration, &duration_text);
2158 if (retval==ERROR_OK)
2159 {
2160 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2161 }
2162 free(duration_text);
2163
2164 return ERROR_OK;
2165 }
2166
2167 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2168 {
2169 u8 *buffer;
2170 u32 buf_cnt;
2171 u32 image_size;
2172 int i;
2173 int retval;
2174 u32 checksum = 0;
2175 u32 mem_checksum = 0;
2176
2177 image_t image;
2178
2179 duration_t duration;
2180 char *duration_text;
2181
2182 target_t *target = get_current_target(cmd_ctx);
2183
2184 if (argc < 1)
2185 {
2186 return ERROR_COMMAND_SYNTAX_ERROR;
2187 }
2188
2189 if (!target)
2190 {
2191 LOG_ERROR("no target selected");
2192 return ERROR_FAIL;
2193 }
2194
2195 duration_start_measure(&duration);
2196
2197 if (argc >= 2)
2198 {
2199 image.base_address_set = 1;
2200 image.base_address = strtoul(args[1], NULL, 0);
2201 }
2202 else
2203 {
2204 image.base_address_set = 0;
2205 image.base_address = 0x0;
2206 }
2207
2208 image.start_address_set = 0;
2209
2210 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2211 {
2212 return retval;
2213 }
2214
2215 image_size = 0x0;
2216 retval=ERROR_OK;
2217 for (i = 0; i < image.num_sections; i++)
2218 {
2219 buffer = malloc(image.sections[i].size);
2220 if (buffer == NULL)
2221 {
2222 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2223 break;
2224 }
2225 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2226 {
2227 free(buffer);
2228 break;
2229 }
2230
2231 /* calculate checksum of image */
2232 image_calculate_checksum( buffer, buf_cnt, &checksum );
2233
2234 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2235 if( retval != ERROR_OK )
2236 {
2237 free(buffer);
2238 break;
2239 }
2240
2241 if( checksum != mem_checksum )
2242 {
2243 /* failed crc checksum, fall back to a binary compare */
2244 u8 *data;
2245
2246 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2247
2248 data = (u8*)malloc(buf_cnt);
2249
2250 /* Can we use 32bit word accesses? */
2251 int size = 1;
2252 int count = buf_cnt;
2253 if ((count % 4) == 0)
2254 {
2255 size *= 4;
2256 count /= 4;
2257 }
2258 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2259 if (retval == ERROR_OK)
2260 {
2261 int t;
2262 for (t = 0; t < buf_cnt; t++)
2263 {
2264 if (data[t] != buffer[t])
2265 {
2266 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]);
2267 free(data);
2268 free(buffer);
2269 retval=ERROR_FAIL;
2270 goto done;
2271 }
2272 }
2273 }
2274
2275 free(data);
2276 }
2277
2278 free(buffer);
2279 image_size += buf_cnt;
2280 }
2281 done:
2282 duration_stop_measure(&duration, &duration_text);
2283 if (retval==ERROR_OK)
2284 {
2285 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2286 }
2287 free(duration_text);
2288
2289 image_close(&image);
2290
2291 return retval;
2292 }
2293
2294 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2295 {
2296 int retval;
2297 target_t *target = get_current_target(cmd_ctx);
2298
2299 if (argc == 0)
2300 {
2301 breakpoint_t *breakpoint = target->breakpoints;
2302
2303 while (breakpoint)
2304 {
2305 if (breakpoint->type == BKPT_SOFT)
2306 {
2307 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2308 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2309 free(buf);
2310 }
2311 else
2312 {
2313 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2314 }
2315 breakpoint = breakpoint->next;
2316 }
2317 }
2318 else if (argc >= 2)
2319 {
2320 int hw = BKPT_SOFT;
2321 u32 length = 0;
2322
2323 length = strtoul(args[1], NULL, 0);
2324
2325 if (argc >= 3)
2326 if (strcmp(args[2], "hw") == 0)
2327 hw = BKPT_HARD;
2328
2329 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2330 {
2331 LOG_ERROR("Failure setting breakpoints");
2332 }
2333 else
2334 {
2335 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2336 }
2337 }
2338 else
2339 {
2340 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2341 }
2342
2343 return ERROR_OK;
2344 }
2345
2346 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2347 {
2348 target_t *target = get_current_target(cmd_ctx);
2349
2350 if (argc > 0)
2351 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2352
2353 return ERROR_OK;
2354 }
2355
2356 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2357 {
2358 target_t *target = get_current_target(cmd_ctx);
2359 int retval;
2360
2361 if (argc == 0)
2362 {
2363 watchpoint_t *watchpoint = target->watchpoints;
2364
2365 while (watchpoint)
2366 {
2367 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);
2368 watchpoint = watchpoint->next;
2369 }
2370 }
2371 else if (argc >= 2)
2372 {
2373 enum watchpoint_rw type = WPT_ACCESS;
2374 u32 data_value = 0x0;
2375 u32 data_mask = 0xffffffff;
2376
2377 if (argc >= 3)
2378 {
2379 switch(args[2][0])
2380 {
2381 case 'r':
2382 type = WPT_READ;
2383 break;
2384 case 'w':
2385 type = WPT_WRITE;
2386 break;
2387 case 'a':
2388 type = WPT_ACCESS;
2389 break;
2390 default:
2391 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2392 return ERROR_OK;
2393 }
2394 }
2395 if (argc >= 4)
2396 {
2397 data_value = strtoul(args[3], NULL, 0);
2398 }
2399 if (argc >= 5)
2400 {
2401 data_mask = strtoul(args[4], NULL, 0);
2402 }
2403
2404 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2405 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2406 {
2407 LOG_ERROR("Failure setting breakpoints");
2408 }
2409 }
2410 else
2411 {
2412 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2413 }
2414
2415 return ERROR_OK;
2416 }
2417
2418 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2419 {
2420 target_t *target = get_current_target(cmd_ctx);
2421
2422 if (argc > 0)
2423 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2424
2425 return ERROR_OK;
2426 }
2427
2428 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2429 {
2430 int retval;
2431 target_t *target = get_current_target(cmd_ctx);
2432 u32 va;
2433 u32 pa;
2434
2435 if (argc != 1)
2436 {
2437 return ERROR_COMMAND_SYNTAX_ERROR;
2438 }
2439 va = strtoul(args[0], NULL, 0);
2440
2441 retval = target->type->virt2phys(target, va, &pa);
2442 if (retval == ERROR_OK)
2443 {
2444 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2445 }
2446 else
2447 {
2448 /* lower levels will have logged a detailed error which is
2449 * forwarded to telnet/GDB session.
2450 */
2451 }
2452 return retval;
2453 }
2454 static void writeLong(FILE *f, int l)
2455 {
2456 int i;
2457 for (i=0; i<4; i++)
2458 {
2459 char c=(l>>(i*8))&0xff;
2460 fwrite(&c, 1, 1, f);
2461 }
2462
2463 }
2464 static void writeString(FILE *f, char *s)
2465 {
2466 fwrite(s, 1, strlen(s), f);
2467 }
2468
2469
2470
2471 // Dump a gmon.out histogram file.
2472 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2473 {
2474 int i;
2475 FILE *f=fopen(filename, "w");
2476 if (f==NULL)
2477 return;
2478 fwrite("gmon", 1, 4, f);
2479 writeLong(f, 0x00000001); // Version
2480 writeLong(f, 0); // padding
2481 writeLong(f, 0); // padding
2482 writeLong(f, 0); // padding
2483
2484 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2485
2486 // figure out bucket size
2487 u32 min=samples[0];
2488 u32 max=samples[0];
2489 for (i=0; i<sampleNum; i++)
2490 {
2491 if (min>samples[i])
2492 {
2493 min=samples[i];
2494 }
2495 if (max<samples[i])
2496 {
2497 max=samples[i];
2498 }
2499 }
2500
2501 int addressSpace=(max-min+1);
2502
2503 static int const maxBuckets=256*1024; // maximum buckets.
2504 int length=addressSpace;
2505 if (length > maxBuckets)
2506 {
2507 length=maxBuckets;
2508 }
2509 int *buckets=malloc(sizeof(int)*length);
2510 if (buckets==NULL)
2511 {
2512 fclose(f);
2513 return;
2514 }
2515 memset(buckets, 0, sizeof(int)*length);
2516 for (i=0; i<sampleNum;i++)
2517 {
2518 u32 address=samples[i];
2519 long long a=address-min;
2520 long long b=length-1;
2521 long long c=addressSpace-1;
2522 int index=(a*b)/c; // danger!!!! int32 overflows
2523 buckets[index]++;
2524 }
2525
2526 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2527 writeLong(f, min); // low_pc
2528 writeLong(f, max); // high_pc
2529 writeLong(f, length); // # of samples
2530 writeLong(f, 64000000); // 64MHz
2531 writeString(f, "seconds");
2532 for (i=0; i<(15-strlen("seconds")); i++)
2533 {
2534 fwrite("", 1, 1, f); // padding
2535 }
2536 writeString(f, "s");
2537
2538 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2539
2540 char *data=malloc(2*length);
2541 if (data!=NULL)
2542 {
2543 for (i=0; i<length;i++)
2544 {
2545 int val;
2546 val=buckets[i];
2547 if (val>65535)
2548 {
2549 val=65535;
2550 }
2551 data[i*2]=val&0xff;
2552 data[i*2+1]=(val>>8)&0xff;
2553 }
2554 free(buckets);
2555 fwrite(data, 1, length*2, f);
2556 free(data);
2557 } else
2558 {
2559 free(buckets);
2560 }
2561
2562 fclose(f);
2563 }
2564
2565 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2566 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2567 {
2568 target_t *target = get_current_target(cmd_ctx);
2569 struct timeval timeout, now;
2570
2571 gettimeofday(&timeout, NULL);
2572 if (argc!=2)
2573 {
2574 return ERROR_COMMAND_SYNTAX_ERROR;
2575 }
2576 char *end;
2577 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2578 if (*end)
2579 {
2580 return ERROR_OK;
2581 }
2582
2583 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2584
2585 static const int maxSample=10000;
2586 u32 *samples=malloc(sizeof(u32)*maxSample);
2587 if (samples==NULL)
2588 return ERROR_OK;
2589
2590 int numSamples=0;
2591 int retval=ERROR_OK;
2592 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2593 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2594
2595 for (;;)
2596 {
2597 target_poll(target);
2598 if (target->state == TARGET_HALTED)
2599 {
2600 u32 t=*((u32 *)reg->value);
2601 samples[numSamples++]=t;
2602 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2603 target_poll(target);
2604 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2605 } else if (target->state == TARGET_RUNNING)
2606 {
2607 // We want to quickly sample the PC.
2608 target_halt(target);
2609 } else
2610 {
2611 command_print(cmd_ctx, "Target not halted or running");
2612 retval=ERROR_OK;
2613 break;
2614 }
2615 if (retval!=ERROR_OK)
2616 {
2617 break;
2618 }
2619
2620 gettimeofday(&now, NULL);
2621 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2622 {
2623 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2624 target_poll(target);
2625 if (target->state == TARGET_HALTED)
2626 {
2627 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2628 }
2629 target_poll(target);
2630 writeGmon(samples, numSamples, args[1]);
2631 command_print(cmd_ctx, "Wrote %s", args[1]);
2632 break;
2633 }
2634 }
2635 free(samples);
2636
2637 return ERROR_OK;
2638 }
2639
2640 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2641 {
2642 char *namebuf;
2643 Jim_Obj *nameObjPtr, *valObjPtr;
2644 int result;
2645
2646 namebuf = alloc_printf("%s(%d)", varname, idx);
2647 if (!namebuf)
2648 return JIM_ERR;
2649
2650 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2651 valObjPtr = Jim_NewIntObj(interp, val);
2652 if (!nameObjPtr || !valObjPtr)
2653 {
2654 free(namebuf);
2655 return JIM_ERR;
2656 }
2657
2658 Jim_IncrRefCount(nameObjPtr);
2659 Jim_IncrRefCount(valObjPtr);
2660 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2661 Jim_DecrRefCount(interp, nameObjPtr);
2662 Jim_DecrRefCount(interp, valObjPtr);
2663 free(namebuf);
2664 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2665 return result;
2666 }
2667
2668 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2669 {
2670 target_t *target;
2671 command_context_t *context;
2672 long l;
2673 u32 width;
2674 u32 len;
2675 u32 addr;
2676 u32 count;
2677 u32 v;
2678 const char *varname;
2679 u8 buffer[4096];
2680 int i, n, e, retval;
2681
2682 /* argv[1] = name of array to receive the data
2683 * argv[2] = desired width
2684 * argv[3] = memory address
2685 * argv[4] = count of times to read
2686 */
2687 if (argc != 5) {
2688 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2689 return JIM_ERR;
2690 }
2691 varname = Jim_GetString(argv[1], &len);
2692 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2693
2694 e = Jim_GetLong(interp, argv[2], &l);
2695 width = l;
2696 if (e != JIM_OK) {
2697 return e;
2698 }
2699
2700 e = Jim_GetLong(interp, argv[3], &l);
2701 addr = l;
2702 if (e != JIM_OK) {
2703 return e;
2704 }
2705 e = Jim_GetLong(interp, argv[4], &l);
2706 len = l;
2707 if (e != JIM_OK) {
2708 return e;
2709 }
2710 switch (width) {
2711 case 8:
2712 width = 1;
2713 break;
2714 case 16:
2715 width = 2;
2716 break;
2717 case 32:
2718 width = 4;
2719 break;
2720 default:
2721 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2722 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2723 return JIM_ERR;
2724 }
2725 if (len == 0) {
2726 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2727 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2728 return JIM_ERR;
2729 }
2730 if ((addr + (len * width)) < addr) {
2731 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2732 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2733 return JIM_ERR;
2734 }
2735 /* absurd transfer size? */
2736 if (len > 65536) {
2737 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2738 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2739 return JIM_ERR;
2740 }
2741
2742 if ((width == 1) ||
2743 ((width == 2) && ((addr & 1) == 0)) ||
2744 ((width == 4) && ((addr & 3) == 0))) {
2745 /* all is well */
2746 } else {
2747 char buf[100];
2748 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2749 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2750 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2751 return JIM_ERR;
2752 }
2753
2754 context = Jim_GetAssocData(interp, "context");
2755 if (context == NULL)
2756 {
2757 LOG_ERROR("mem2array: no command context");
2758 return JIM_ERR;
2759 }
2760 target = get_current_target(context);
2761 if (target == NULL)
2762 {
2763 LOG_ERROR("mem2array: no current target");
2764 return JIM_ERR;
2765 }
2766
2767 /* Transfer loop */
2768
2769 /* index counter */
2770 n = 0;
2771 /* assume ok */
2772 e = JIM_OK;
2773 while (len) {
2774 /* Slurp... in buffer size chunks */
2775
2776 count = len; /* in objects.. */
2777 if (count > (sizeof(buffer)/width)) {
2778 count = (sizeof(buffer)/width);
2779 }
2780
2781 retval = target->type->read_memory( target, addr, width, count, buffer );
2782 if (retval != ERROR_OK) {
2783 /* BOO !*/
2784 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2785 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2786 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2787 e = JIM_ERR;
2788 len = 0;
2789 } else {
2790 v = 0; /* shut up gcc */
2791 for (i = 0 ;i < count ;i++, n++) {
2792 switch (width) {
2793 case 4:
2794 v = target_buffer_get_u32(target, &buffer[i*width]);
2795 break;
2796 case 2:
2797 v = target_buffer_get_u16(target, &buffer[i*width]);
2798 break;
2799 case 1:
2800 v = buffer[i] & 0x0ff;
2801 break;
2802 }
2803 new_int_array_element(interp, varname, n, v);
2804 }
2805 len -= count;
2806 }
2807 }
2808
2809 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2810
2811 return JIM_OK;
2812 }
2813
2814 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2815 {
2816 char *namebuf;
2817 Jim_Obj *nameObjPtr, *valObjPtr;
2818 int result;
2819 long l;
2820
2821 namebuf = alloc_printf("%s(%d)", varname, idx);
2822 if (!namebuf)
2823 return JIM_ERR;
2824
2825 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2826 if (!nameObjPtr)
2827 {
2828 free(namebuf);
2829 return JIM_ERR;
2830 }
2831
2832 Jim_IncrRefCount(nameObjPtr);
2833 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2834 Jim_DecrRefCount(interp, nameObjPtr);
2835 free(namebuf);
2836 if (valObjPtr == NULL)
2837 return JIM_ERR;
2838
2839 result = Jim_GetLong(interp, valObjPtr, &l);
2840 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2841 *val = l;
2842 return result;
2843 }
2844
2845 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2846 {
2847 target_t *target;
2848 command_context_t *context;
2849 long l;
2850 u32 width;
2851 u32 len;
2852 u32 addr;
2853 u32 count;
2854 u32 v;
2855 const char *varname;
2856 u8 buffer[4096];
2857 int i, n, e, retval;
2858
2859 /* argv[1] = name of array to get the data
2860 * argv[2] = desired width
2861 * argv[3] = memory address
2862 * argv[4] = count to write
2863 */
2864 if (argc != 5) {
2865 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2866 return JIM_ERR;
2867 }
2868 varname = Jim_GetString(argv[1], &len);
2869 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2870
2871 e = Jim_GetLong(interp, argv[2], &l);
2872 width = l;
2873 if (e != JIM_OK) {
2874 return e;
2875 }
2876
2877 e = Jim_GetLong(interp, argv[3], &l);
2878 addr = l;
2879 if (e != JIM_OK) {
2880 return e;
2881 }
2882 e = Jim_GetLong(interp, argv[4], &l);
2883 len = l;
2884 if (e != JIM_OK) {
2885 return e;
2886 }
2887 switch (width) {
2888 case 8:
2889 width = 1;
2890 break;
2891 case 16:
2892 width = 2;
2893 break;
2894 case 32:
2895 width = 4;
2896 break;
2897 default:
2898 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2899 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2900 return JIM_ERR;
2901 }
2902 if (len == 0) {
2903 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2904 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2905 return JIM_ERR;
2906 }
2907 if ((addr + (len * width)) < addr) {
2908 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2909 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2910 return JIM_ERR;
2911 }
2912 /* absurd transfer size? */
2913 if (len > 65536) {
2914 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2915 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2916 return JIM_ERR;
2917 }
2918
2919 if ((width == 1) ||
2920 ((width == 2) && ((addr & 1) == 0)) ||
2921 ((width == 4) && ((addr & 3) == 0))) {
2922 /* all is well */
2923 } else {
2924 char buf[100];
2925 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2926 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2927 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2928 return JIM_ERR;
2929 }
2930
2931 context = Jim_GetAssocData(interp, "context");
2932 if (context == NULL)
2933 {
2934 LOG_ERROR("array2mem: no command context");
2935 return JIM_ERR;
2936 }
2937 target = get_current_target(context);
2938 if (target == NULL)
2939 {
2940 LOG_ERROR("array2mem: no current target");
2941 return JIM_ERR;
2942 }
2943
2944 /* Transfer loop */
2945
2946 /* index counter */
2947 n = 0;
2948 /* assume ok */
2949 e = JIM_OK;
2950 while (len) {
2951 /* Slurp... in buffer size chunks */
2952
2953 count = len; /* in objects.. */
2954 if (count > (sizeof(buffer)/width)) {
2955 count = (sizeof(buffer)/width);
2956 }
2957
2958 v = 0; /* shut up gcc */
2959 for (i = 0 ;i < count ;i++, n++) {
2960 get_int_array_element(interp, varname, n, &v);
2961 switch (width) {
2962 case 4:
2963 target_buffer_set_u32(target, &buffer[i*width], v);
2964 break;
2965 case 2:
2966 target_buffer_set_u16(target, &buffer[i*width], v);
2967 break;
2968 case 1:
2969 buffer[i] = v & 0x0ff;
2970 break;
2971 }
2972 }
2973 len -= count;
2974
2975 retval = target->type->write_memory(target, addr, width, count, buffer);
2976 if (retval != ERROR_OK) {
2977 /* BOO !*/
2978 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2979 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2980 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2981 e = JIM_ERR;
2982 len = 0;
2983 }
2984 }
2985
2986 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2987
2988 return JIM_OK;
2989 }
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)