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