Code Review / openocd.git / blob
? search:


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