Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- fix incorrectly registered function openocd_array2mem
[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 /* script procedures */
953 register_jim(cmd_ctx, "openocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing");
954 register_jim(cmd_ctx, "openocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values");
955 return ERROR_OK;
956 }
957
958 int target_arch_state(struct target_s *target)
959 {
960 int retval;
961 if (target==NULL)
962 {
963 LOG_USER("No target has been configured");
964 return ERROR_OK;
965 }
966
967 LOG_USER("target state: %s", target_state_strings[target->state]);
968
969 if (target->state!=TARGET_HALTED)
970 return ERROR_OK;
971
972 retval=target->type->arch_state(target);
973 return retval;
974 }
975
976 /* Single aligned words are guaranteed to use 16 or 32 bit access
977 * mode respectively, otherwise data is handled as quickly as
978 * possible
979 */
980 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
981 {
982 int retval;
983 if (!target->type->examined)
984 {
985 LOG_ERROR("Target not examined yet");
986 return ERROR_FAIL;
987 }
988
989 LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
990
991 if (((address % 2) == 0) && (size == 2))
992 {
993 return target->type->write_memory(target, address, 2, 1, buffer);
994 }
995
996 /* handle unaligned head bytes */
997 if (address % 4)
998 {
999 int unaligned = 4 - (address % 4);
1000
1001 if (unaligned > size)
1002 unaligned = size;
1003
1004 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1005 return retval;
1006
1007 buffer += unaligned;
1008 address += unaligned;
1009 size -= unaligned;
1010 }
1011
1012 /* handle aligned words */
1013 if (size >= 4)
1014 {
1015 int aligned = size - (size % 4);
1016
1017 /* use bulk writes above a certain limit. This may have to be changed */
1018 if (aligned > 128)
1019 {
1020 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
1021 return retval;
1022 }
1023 else
1024 {
1025 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1026 return retval;
1027 }
1028
1029 buffer += aligned;
1030 address += aligned;
1031 size -= aligned;
1032 }
1033
1034 /* handle tail writes of less than 4 bytes */
1035 if (size > 0)
1036 {
1037 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
1038 return retval;
1039 }
1040
1041 return ERROR_OK;
1042 }
1043
1044
1045 /* Single aligned words are guaranteed to use 16 or 32 bit access
1046 * mode respectively, otherwise data is handled as quickly as
1047 * possible
1048 */
1049 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
1050 {
1051 int retval;
1052 if (!target->type->examined)
1053 {
1054 LOG_ERROR("Target not examined yet");
1055 return ERROR_FAIL;
1056 }
1057
1058 LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
1059
1060 if (((address % 2) == 0) && (size == 2))
1061 {
1062 return target->type->read_memory(target, address, 2, 1, buffer);
1063 }
1064
1065 /* handle unaligned head bytes */
1066 if (address % 4)
1067 {
1068 int unaligned = 4 - (address % 4);
1069
1070 if (unaligned > size)
1071 unaligned = size;
1072
1073 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
1074 return retval;
1075
1076 buffer += unaligned;
1077 address += unaligned;
1078 size -= unaligned;
1079 }
1080
1081 /* handle aligned words */
1082 if (size >= 4)
1083 {
1084 int aligned = size - (size % 4);
1085
1086 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
1087 return retval;
1088
1089 buffer += aligned;
1090 address += aligned;
1091 size -= aligned;
1092 }
1093
1094 /* handle tail writes of less than 4 bytes */
1095 if (size > 0)
1096 {
1097 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
1098 return retval;
1099 }
1100
1101 return ERROR_OK;
1102 }
1103
1104 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
1105 {
1106 u8 *buffer;
1107 int retval;
1108 int i;
1109 u32 checksum = 0;
1110 if (!target->type->examined)
1111 {
1112 LOG_ERROR("Target not examined yet");
1113 return ERROR_FAIL;
1114 }
1115
1116 if ((retval = target->type->checksum_memory(target, address,
1117 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
1118 {
1119 buffer = malloc(size);
1120 if (buffer == NULL)
1121 {
1122 LOG_ERROR("error allocating buffer for section (%d bytes)", size);
1123 return ERROR_INVALID_ARGUMENTS;
1124 }
1125 retval = target_read_buffer(target, address, size, buffer);
1126 if (retval != ERROR_OK)
1127 {
1128 free(buffer);
1129 return retval;
1130 }
1131
1132 /* convert to target endianess */
1133 for (i = 0; i < (size/sizeof(u32)); i++)
1134 {
1135 u32 target_data;
1136 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
1137 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
1138 }
1139
1140 retval = image_calculate_checksum( buffer, size, &checksum );
1141 free(buffer);
1142 }
1143
1144 *crc = checksum;
1145
1146 return retval;
1147 }
1148
1149 int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
1150 {
1151 int retval;
1152 if (!target->type->examined)
1153 {
1154 LOG_ERROR("Target not examined yet");
1155 return ERROR_FAIL;
1156 }
1157
1158 if (target->type->blank_check_memory == 0)
1159 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
1160
1161 retval = target->type->blank_check_memory(target, address, size, blank);
1162
1163 return retval;
1164 }
1165
1166 int target_read_u32(struct target_s *target, u32 address, u32 *value)
1167 {
1168 u8 value_buf[4];
1169 if (!target->type->examined)
1170 {
1171 LOG_ERROR("Target not examined yet");
1172 return ERROR_FAIL;
1173 }
1174
1175 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
1176
1177 if (retval == ERROR_OK)
1178 {
1179 *value = target_buffer_get_u32(target, value_buf);
1180 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
1181 }
1182 else
1183 {
1184 *value = 0x0;
1185 LOG_DEBUG("address: 0x%8.8x failed", address);
1186 }
1187
1188 return retval;
1189 }
1190
1191 int target_read_u16(struct target_s *target, u32 address, u16 *value)
1192 {
1193 u8 value_buf[2];
1194 if (!target->type->examined)
1195 {
1196 LOG_ERROR("Target not examined yet");
1197 return ERROR_FAIL;
1198 }
1199
1200 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
1201
1202 if (retval == ERROR_OK)
1203 {
1204 *value = target_buffer_get_u16(target, value_buf);
1205 LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
1206 }
1207 else
1208 {
1209 *value = 0x0;
1210 LOG_DEBUG("address: 0x%8.8x failed", address);
1211 }
1212
1213 return retval;
1214 }
1215
1216 int target_read_u8(struct target_s *target, u32 address, u8 *value)
1217 {
1218 int retval = target->type->read_memory(target, address, 1, 1, value);
1219 if (!target->type->examined)
1220 {
1221 LOG_ERROR("Target not examined yet");
1222 return ERROR_FAIL;
1223 }
1224
1225 if (retval == ERROR_OK)
1226 {
1227 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
1228 }
1229 else
1230 {
1231 *value = 0x0;
1232 LOG_DEBUG("address: 0x%8.8x failed", address);
1233 }
1234
1235 return retval;
1236 }
1237
1238 int target_write_u32(struct target_s *target, u32 address, u32 value)
1239 {
1240 int retval;
1241 u8 value_buf[4];
1242 if (!target->type->examined)
1243 {
1244 LOG_ERROR("Target not examined yet");
1245 return ERROR_FAIL;
1246 }
1247
1248 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1249
1250 target_buffer_set_u32(target, value_buf, value);
1251 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
1252 {
1253 LOG_DEBUG("failed: %i", retval);
1254 }
1255
1256 return retval;
1257 }
1258
1259 int target_write_u16(struct target_s *target, u32 address, u16 value)
1260 {
1261 int retval;
1262 u8 value_buf[2];
1263 if (!target->type->examined)
1264 {
1265 LOG_ERROR("Target not examined yet");
1266 return ERROR_FAIL;
1267 }
1268
1269 LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
1270
1271 target_buffer_set_u16(target, value_buf, value);
1272 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
1273 {
1274 LOG_DEBUG("failed: %i", retval);
1275 }
1276
1277 return retval;
1278 }
1279
1280 int target_write_u8(struct target_s *target, u32 address, u8 value)
1281 {
1282 int retval;
1283 if (!target->type->examined)
1284 {
1285 LOG_ERROR("Target not examined yet");
1286 return ERROR_FAIL;
1287 }
1288
1289 LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1290
1291 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1292 {
1293 LOG_DEBUG("failed: %i", retval);
1294 }
1295
1296 return retval;
1297 }
1298
1299 int target_register_user_commands(struct command_context_s *cmd_ctx)
1300 {
1301 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1302 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1303 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1304 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1305 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1306 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1307 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1308 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1309
1310 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1311 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1312 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1313
1314 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
1315 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
1316 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
1317
1318 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1319 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1320 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1321 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1322
1323 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1324 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1325 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1326 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1327 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1328
1329 target_request_register_commands(cmd_ctx);
1330 trace_register_commands(cmd_ctx);
1331
1332 return ERROR_OK;
1333 }
1334
1335 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1336 {
1337 target_t *target = targets;
1338 int count = 0;
1339
1340 if (argc == 1)
1341 {
1342 int num = strtoul(args[0], NULL, 0);
1343
1344 while (target)
1345 {
1346 count++;
1347 target = target->next;
1348 }
1349
1350 if (num < count)
1351 cmd_ctx->current_target = num;
1352 else
1353 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1354
1355 return ERROR_OK;
1356 }
1357
1358 while (target)
1359 {
1360 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1361 target = target->next;
1362 }
1363
1364 return ERROR_OK;
1365 }
1366
1367 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1368 {
1369 int i;
1370 int found = 0;
1371
1372 if (argc < 3)
1373 {
1374 return ERROR_COMMAND_SYNTAX_ERROR;
1375 }
1376
1377 /* search for the specified target */
1378 if (args[0] && (args[0][0] != 0))
1379 {
1380 for (i = 0; target_types[i]; i++)
1381 {
1382 if (strcmp(args[0], target_types[i]->name) == 0)
1383 {
1384 target_t **last_target_p = &targets;
1385
1386 /* register target specific commands */
1387 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1388 {
1389 LOG_ERROR("couldn't register '%s' commands", args[0]);
1390 exit(-1);
1391 }
1392
1393 if (*last_target_p)
1394 {
1395 while ((*last_target_p)->next)
1396 last_target_p = &((*last_target_p)->next);
1397 last_target_p = &((*last_target_p)->next);
1398 }
1399
1400 *last_target_p = malloc(sizeof(target_t));
1401
1402 /* allocate memory for each unique target type */
1403 (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
1404 *((*last_target_p)->type) = *target_types[i];
1405
1406 if (strcmp(args[1], "big") == 0)
1407 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1408 else if (strcmp(args[1], "little") == 0)
1409 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1410 else
1411 {
1412 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1413 return ERROR_COMMAND_SYNTAX_ERROR;
1414 }
1415
1416 /* what to do on a target reset */
1417 (*last_target_p)->reset_mode = RESET_INIT; /* default */
1418 if (strcmp(args[2], "reset_halt") == 0)
1419 (*last_target_p)->reset_mode = RESET_HALT;
1420 else if (strcmp(args[2], "reset_run") == 0)
1421 (*last_target_p)->reset_mode = RESET_RUN;
1422 else if (strcmp(args[2], "reset_init") == 0)
1423 (*last_target_p)->reset_mode = RESET_INIT;
1424 else if (strcmp(args[2], "run_and_halt") == 0)
1425 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1426 else if (strcmp(args[2], "run_and_init") == 0)
1427 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1428 else
1429 {
1430 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1431 args--;
1432 argc++;
1433 }
1434 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1435
1436 (*last_target_p)->working_area = 0x0;
1437 (*last_target_p)->working_area_size = 0x0;
1438 (*last_target_p)->working_areas = NULL;
1439 (*last_target_p)->backup_working_area = 0;
1440
1441 (*last_target_p)->state = TARGET_UNKNOWN;
1442 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1443 (*last_target_p)->reg_cache = NULL;
1444 (*last_target_p)->breakpoints = NULL;
1445 (*last_target_p)->watchpoints = NULL;
1446 (*last_target_p)->next = NULL;
1447 (*last_target_p)->arch_info = NULL;
1448
1449 /* initialize trace information */
1450 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1451 (*last_target_p)->trace_info->num_trace_points = 0;
1452 (*last_target_p)->trace_info->trace_points_size = 0;
1453 (*last_target_p)->trace_info->trace_points = NULL;
1454 (*last_target_p)->trace_info->trace_history_size = 0;
1455 (*last_target_p)->trace_info->trace_history = NULL;
1456 (*last_target_p)->trace_info->trace_history_pos = 0;
1457 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1458
1459 (*last_target_p)->dbgmsg = NULL;
1460 (*last_target_p)->dbg_msg_enabled = 0;
1461
1462 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1463
1464 found = 1;
1465 break;
1466 }
1467 }
1468 }
1469
1470 /* no matching target found */
1471 if (!found)
1472 {
1473 LOG_ERROR("target '%s' not found", args[0]);
1474 return ERROR_COMMAND_SYNTAX_ERROR;
1475 }
1476
1477 return ERROR_OK;
1478 }
1479
1480 int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
1481 {
1482 return command_run_linef(cmd_ctx, " if {[catch {info body target_%s_%d} t]==0} {target_%s_%d}",
1483 name, get_num_by_target(target),
1484 name, get_num_by_target(target));
1485 }
1486
1487 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1488 {
1489 target_t *target = NULL;
1490
1491 if (argc < 2)
1492 {
1493 return ERROR_COMMAND_SYNTAX_ERROR;
1494 }
1495
1496 target = get_target_by_num(strtoul(args[0], NULL, 0));
1497 if (!target)
1498 {
1499 return ERROR_COMMAND_SYNTAX_ERROR;
1500 }
1501
1502 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1503
1504 return ERROR_OK;
1505 }
1506
1507 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1508 {
1509 target_t *target = NULL;
1510
1511 if ((argc < 4) || (argc > 5))
1512 {
1513 return ERROR_COMMAND_SYNTAX_ERROR;
1514 }
1515
1516 target = get_target_by_num(strtoul(args[0], NULL, 0));
1517 if (!target)
1518 {
1519 return ERROR_COMMAND_SYNTAX_ERROR;
1520 }
1521 target_free_all_working_areas(target);
1522
1523 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1524 if (argc == 5)
1525 {
1526 target->working_area_virt = strtoul(args[4], NULL, 0);
1527 }
1528 target->working_area_size = strtoul(args[2], NULL, 0);
1529
1530 if (strcmp(args[3], "backup") == 0)
1531 {
1532 target->backup_working_area = 1;
1533 }
1534 else if (strcmp(args[3], "nobackup") == 0)
1535 {
1536 target->backup_working_area = 0;
1537 }
1538 else
1539 {
1540 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1541 return ERROR_COMMAND_SYNTAX_ERROR;
1542 }
1543
1544 return ERROR_OK;
1545 }
1546
1547
1548 /* process target state changes */
1549 int handle_target(void *priv)
1550 {
1551 target_t *target = targets;
1552
1553 while (target)
1554 {
1555 if (target_continous_poll)
1556 {
1557 /* polling may fail silently until the target has been examined */
1558 target_poll(target);
1559 }
1560
1561 target = target->next;
1562 }
1563
1564 return ERROR_OK;
1565 }
1566
1567 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1568 {
1569 target_t *target;
1570 reg_t *reg = NULL;
1571 int count = 0;
1572 char *value;
1573
1574 LOG_DEBUG("-");
1575
1576 target = get_current_target(cmd_ctx);
1577
1578 /* list all available registers for the current target */
1579 if (argc == 0)
1580 {
1581 reg_cache_t *cache = target->reg_cache;
1582
1583 count = 0;
1584 while(cache)
1585 {
1586 int i;
1587 for (i = 0; i < cache->num_regs; i++)
1588 {
1589 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1590 command_print(cmd_ctx, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count++, cache->reg_list[i].name, cache->reg_list[i].size, value, cache->reg_list[i].dirty, cache->reg_list[i].valid);
1591 free(value);
1592 }
1593 cache = cache->next;
1594 }
1595
1596 return ERROR_OK;
1597 }
1598
1599 /* access a single register by its ordinal number */
1600 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1601 {
1602 int num = strtoul(args[0], NULL, 0);
1603 reg_cache_t *cache = target->reg_cache;
1604
1605 count = 0;
1606 while(cache)
1607 {
1608 int i;
1609 for (i = 0; i < cache->num_regs; i++)
1610 {
1611 if (count++ == num)
1612 {
1613 reg = &cache->reg_list[i];
1614 break;
1615 }
1616 }
1617 if (reg)
1618 break;
1619 cache = cache->next;
1620 }
1621
1622 if (!reg)
1623 {
1624 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1625 return ERROR_OK;
1626 }
1627 } else /* access a single register by its name */
1628 {
1629 reg = register_get_by_name(target->reg_cache, args[0], 1);
1630
1631 if (!reg)
1632 {
1633 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1634 return ERROR_OK;
1635 }
1636 }
1637
1638 /* display a register */
1639 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1640 {
1641 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1642 reg->valid = 0;
1643
1644 if (reg->valid == 0)
1645 {
1646 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1647 if (arch_type == NULL)
1648 {
1649 LOG_ERROR("BUG: encountered unregistered arch type");
1650 return ERROR_OK;
1651 }
1652 arch_type->get(reg);
1653 }
1654 value = buf_to_str(reg->value, reg->size, 16);
1655 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1656 free(value);
1657 return ERROR_OK;
1658 }
1659
1660 /* set register value */
1661 if (argc == 2)
1662 {
1663 u8 *buf = malloc(CEIL(reg->size, 8));
1664 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1665
1666 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1667 if (arch_type == NULL)
1668 {
1669 LOG_ERROR("BUG: encountered unregistered arch type");
1670 return ERROR_OK;
1671 }
1672
1673 arch_type->set(reg, buf);
1674
1675 value = buf_to_str(reg->value, reg->size, 16);
1676 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1677 free(value);
1678
1679 free(buf);
1680
1681 return ERROR_OK;
1682 }
1683
1684 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1685
1686 return ERROR_OK;
1687 }
1688
1689 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1690
1691 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1692 {
1693 target_t *target = get_current_target(cmd_ctx);
1694
1695 if (argc == 0)
1696 {
1697 target_poll(target);
1698 target_arch_state(target);
1699 }
1700 else
1701 {
1702 if (strcmp(args[0], "on") == 0)
1703 {
1704 target_continous_poll = 1;
1705 }
1706 else if (strcmp(args[0], "off") == 0)
1707 {
1708 target_continous_poll = 0;
1709 }
1710 else
1711 {
1712 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1713 }
1714 }
1715
1716
1717 return ERROR_OK;
1718 }
1719
1720 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1721 {
1722 int ms = 5000;
1723
1724 if (argc > 0)
1725 {
1726 char *end;
1727
1728 ms = strtoul(args[0], &end, 0) * 1000;
1729 if (*end)
1730 {
1731 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1732 return ERROR_OK;
1733 }
1734 }
1735
1736 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1737 }
1738
1739 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1740 {
1741 int retval;
1742 struct timeval timeout, now;
1743 int once=1;
1744 gettimeofday(&timeout, NULL);
1745 timeval_add_time(&timeout, 0, ms * 1000);
1746
1747 target_t *target = get_current_target(cmd_ctx);
1748 for (;;)
1749 {
1750 if ((retval=target_poll(target))!=ERROR_OK)
1751 return retval;
1752 target_call_timer_callbacks_now();
1753 if (target->state == state)
1754 {
1755 break;
1756 }
1757 if (once)
1758 {
1759 once=0;
1760 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1761 }
1762
1763 gettimeofday(&now, NULL);
1764 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1765 {
1766 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1767 break;
1768 }
1769 }
1770
1771 return ERROR_OK;
1772 }
1773
1774 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1775 {
1776 int retval;
1777 target_t *target = get_current_target(cmd_ctx);
1778
1779 LOG_DEBUG("-");
1780
1781 if ((retval = target_halt(target)) != ERROR_OK)
1782 {
1783 return retval;
1784 }
1785
1786 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1787 }
1788
1789 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1790 {
1791 target_t *target = get_current_target(cmd_ctx);
1792
1793 LOG_USER("requesting target halt and executing a soft reset");
1794
1795 target->type->soft_reset_halt(target);
1796
1797 return ERROR_OK;
1798 }
1799
1800 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1801 {
1802 target_t *target = get_current_target(cmd_ctx);
1803 enum target_reset_mode reset_mode = target->reset_mode;
1804 enum target_reset_mode save = target->reset_mode;
1805
1806 LOG_DEBUG("-");
1807
1808 if (argc >= 1)
1809 {
1810 if (strcmp("run", args[0]) == 0)
1811 reset_mode = RESET_RUN;
1812 else if (strcmp("halt", args[0]) == 0)
1813 reset_mode = RESET_HALT;
1814 else if (strcmp("init", args[0]) == 0)
1815 reset_mode = RESET_INIT;
1816 else if (strcmp("run_and_halt", args[0]) == 0)
1817 {
1818 reset_mode = RESET_RUN_AND_HALT;
1819 if (argc >= 2)
1820 {
1821 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1822 }
1823 }
1824 else if (strcmp("run_and_init", args[0]) == 0)
1825 {
1826 reset_mode = RESET_RUN_AND_INIT;
1827 if (argc >= 2)
1828 {
1829 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1830 }
1831 }
1832 else
1833 {
1834 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1835 return ERROR_OK;
1836 }
1837 }
1838
1839 /* temporarily modify mode of current reset target */
1840 target->reset_mode = reset_mode;
1841
1842 /* reset *all* targets */
1843 target_process_reset(cmd_ctx);
1844
1845 /* Restore default reset mode for this target */
1846 target->reset_mode = save;
1847
1848 return ERROR_OK;
1849 }
1850
1851 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1852 {
1853 int retval;
1854 target_t *target = get_current_target(cmd_ctx);
1855
1856 target_invoke_script(cmd_ctx, target, "pre_resume");
1857
1858 if (argc == 0)
1859 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1860 else if (argc == 1)
1861 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1862 else
1863 {
1864 return ERROR_COMMAND_SYNTAX_ERROR;
1865 }
1866
1867 return retval;
1868 }
1869
1870 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1871 {
1872 target_t *target = get_current_target(cmd_ctx);
1873
1874 LOG_DEBUG("-");
1875
1876 if (argc == 0)
1877 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1878
1879 if (argc == 1)
1880 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1881
1882 return ERROR_OK;
1883 }
1884
1885 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1886 {
1887 const int line_bytecnt = 32;
1888 int count = 1;
1889 int size = 4;
1890 u32 address = 0;
1891 int line_modulo;
1892 int i;
1893
1894 char output[128];
1895 int output_len;
1896
1897 int retval;
1898
1899 u8 *buffer;
1900 target_t *target = get_current_target(cmd_ctx);
1901
1902 if (argc < 1)
1903 return ERROR_OK;
1904
1905 if (argc == 2)
1906 count = strtoul(args[1], NULL, 0);
1907
1908 address = strtoul(args[0], NULL, 0);
1909
1910
1911 switch (cmd[2])
1912 {
1913 case 'w':
1914 size = 4; line_modulo = line_bytecnt / 4;
1915 break;
1916 case 'h':
1917 size = 2; line_modulo = line_bytecnt / 2;
1918 break;
1919 case 'b':
1920 size = 1; line_modulo = line_bytecnt / 1;
1921 break;
1922 default:
1923 return ERROR_OK;
1924 }
1925
1926 buffer = calloc(count, size);
1927 retval = target->type->read_memory(target, address, size, count, buffer);
1928 if (retval == ERROR_OK)
1929 {
1930 output_len = 0;
1931
1932 for (i = 0; i < count; i++)
1933 {
1934 if (i%line_modulo == 0)
1935 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1936
1937 switch (size)
1938 {
1939 case 4:
1940 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1941 break;
1942 case 2:
1943 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1944 break;
1945 case 1:
1946 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1947 break;
1948 }
1949
1950 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1951 {
1952 command_print(cmd_ctx, output);
1953 output_len = 0;
1954 }
1955 }
1956 }
1957
1958 free(buffer);
1959
1960 return retval;
1961 }
1962
1963 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1964 {
1965 u32 address = 0;
1966 u32 value = 0;
1967 int count = 1;
1968 int i;
1969 int wordsize;
1970 target_t *target = get_current_target(cmd_ctx);
1971 u8 value_buf[4];
1972
1973 if ((argc < 2) || (argc > 3))
1974 return ERROR_COMMAND_SYNTAX_ERROR;
1975
1976 address = strtoul(args[0], NULL, 0);
1977 value = strtoul(args[1], NULL, 0);
1978 if (argc == 3)
1979 count = strtoul(args[2], NULL, 0);
1980
1981 switch (cmd[2])
1982 {
1983 case 'w':
1984 wordsize = 4;
1985 target_buffer_set_u32(target, value_buf, value);
1986 break;
1987 case 'h':
1988 wordsize = 2;
1989 target_buffer_set_u16(target, value_buf, value);
1990 break;
1991 case 'b':
1992 wordsize = 1;
1993 value_buf[0] = value;
1994 break;
1995 default:
1996 return ERROR_COMMAND_SYNTAX_ERROR;
1997 }
1998 for (i=0; i<count; i++)
1999 {
2000 int retval;
2001 switch (wordsize)
2002 {
2003 case 4:
2004 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
2005 break;
2006 case 2:
2007 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
2008 break;
2009 case 1:
2010 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
2011 break;
2012 default:
2013 return ERROR_OK;
2014 }
2015 if (retval!=ERROR_OK)
2016 {
2017 return retval;
2018 }
2019 }
2020
2021 return ERROR_OK;
2022
2023 }
2024
2025 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2026 {
2027 u8 *buffer;
2028 u32 buf_cnt;
2029 u32 image_size;
2030 int i;
2031 int retval;
2032
2033 image_t image;
2034
2035 duration_t duration;
2036 char *duration_text;
2037
2038 target_t *target = get_current_target(cmd_ctx);
2039
2040 if (argc < 1)
2041 {
2042 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
2043 return ERROR_OK;
2044 }
2045
2046 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2047 if (argc >= 2)
2048 {
2049 image.base_address_set = 1;
2050 image.base_address = strtoul(args[1], NULL, 0);
2051 }
2052 else
2053 {
2054 image.base_address_set = 0;
2055 }
2056
2057 image.start_address_set = 0;
2058
2059 duration_start_measure(&duration);
2060
2061 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2062 {
2063 return ERROR_OK;
2064 }
2065
2066 image_size = 0x0;
2067 retval = ERROR_OK;
2068 for (i = 0; i < image.num_sections; i++)
2069 {
2070 buffer = malloc(image.sections[i].size);
2071 if (buffer == NULL)
2072 {
2073 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2074 break;
2075 }
2076
2077 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2078 {
2079 free(buffer);
2080 break;
2081 }
2082 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
2083 {
2084 free(buffer);
2085 break;
2086 }
2087 image_size += buf_cnt;
2088 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2089
2090 free(buffer);
2091 }
2092
2093 duration_stop_measure(&duration, &duration_text);
2094 if (retval==ERROR_OK)
2095 {
2096 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2097 }
2098 free(duration_text);
2099
2100 image_close(&image);
2101
2102 return retval;
2103
2104 }
2105
2106 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2107 {
2108 fileio_t fileio;
2109
2110 u32 address;
2111 u32 size;
2112 u8 buffer[560];
2113 int retval=ERROR_OK;
2114
2115 duration_t duration;
2116 char *duration_text;
2117
2118 target_t *target = get_current_target(cmd_ctx);
2119
2120 if (argc != 3)
2121 {
2122 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2123 return ERROR_OK;
2124 }
2125
2126 address = strtoul(args[1], NULL, 0);
2127 size = strtoul(args[2], NULL, 0);
2128
2129 if ((address & 3) || (size & 3))
2130 {
2131 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2132 return ERROR_OK;
2133 }
2134
2135 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2136 {
2137 return ERROR_OK;
2138 }
2139
2140 duration_start_measure(&duration);
2141
2142 while (size > 0)
2143 {
2144 u32 size_written;
2145 u32 this_run_size = (size > 560) ? 560 : size;
2146
2147 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2148 if (retval != ERROR_OK)
2149 {
2150 break;
2151 }
2152
2153 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2154 if (retval != ERROR_OK)
2155 {
2156 break;
2157 }
2158
2159 size -= this_run_size;
2160 address += this_run_size;
2161 }
2162
2163 fileio_close(&fileio);
2164
2165 duration_stop_measure(&duration, &duration_text);
2166 if (retval==ERROR_OK)
2167 {
2168 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2169 }
2170 free(duration_text);
2171
2172 return ERROR_OK;
2173 }
2174
2175 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2176 {
2177 u8 *buffer;
2178 u32 buf_cnt;
2179 u32 image_size;
2180 int i;
2181 int retval;
2182 u32 checksum = 0;
2183 u32 mem_checksum = 0;
2184
2185 image_t image;
2186
2187 duration_t duration;
2188 char *duration_text;
2189
2190 target_t *target = get_current_target(cmd_ctx);
2191
2192 if (argc < 1)
2193 {
2194 return ERROR_COMMAND_SYNTAX_ERROR;
2195 }
2196
2197 if (!target)
2198 {
2199 LOG_ERROR("no target selected");
2200 return ERROR_FAIL;
2201 }
2202
2203 duration_start_measure(&duration);
2204
2205 if (argc >= 2)
2206 {
2207 image.base_address_set = 1;
2208 image.base_address = strtoul(args[1], NULL, 0);
2209 }
2210 else
2211 {
2212 image.base_address_set = 0;
2213 image.base_address = 0x0;
2214 }
2215
2216 image.start_address_set = 0;
2217
2218 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2219 {
2220 return retval;
2221 }
2222
2223 image_size = 0x0;
2224 retval=ERROR_OK;
2225 for (i = 0; i < image.num_sections; i++)
2226 {
2227 buffer = malloc(image.sections[i].size);
2228 if (buffer == NULL)
2229 {
2230 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2231 break;
2232 }
2233 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2234 {
2235 free(buffer);
2236 break;
2237 }
2238
2239 /* calculate checksum of image */
2240 image_calculate_checksum( buffer, buf_cnt, &checksum );
2241
2242 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2243 if( retval != ERROR_OK )
2244 {
2245 free(buffer);
2246 break;
2247 }
2248
2249 if( checksum != mem_checksum )
2250 {
2251 /* failed crc checksum, fall back to a binary compare */
2252 u8 *data;
2253
2254 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2255
2256 data = (u8*)malloc(buf_cnt);
2257
2258 /* Can we use 32bit word accesses? */
2259 int size = 1;
2260 int count = buf_cnt;
2261 if ((count % 4) == 0)
2262 {
2263 size *= 4;
2264 count /= 4;
2265 }
2266 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2267 if (retval == ERROR_OK)
2268 {
2269 int t;
2270 for (t = 0; t < buf_cnt; t++)
2271 {
2272 if (data[t] != buffer[t])
2273 {
2274 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]);
2275 free(data);
2276 free(buffer);
2277 retval=ERROR_FAIL;
2278 goto done;
2279 }
2280 }
2281 }
2282
2283 free(data);
2284 }
2285
2286 free(buffer);
2287 image_size += buf_cnt;
2288 }
2289 done:
2290 duration_stop_measure(&duration, &duration_text);
2291 if (retval==ERROR_OK)
2292 {
2293 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2294 }
2295 free(duration_text);
2296
2297 image_close(&image);
2298
2299 return retval;
2300 }
2301
2302 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2303 {
2304 int retval;
2305 target_t *target = get_current_target(cmd_ctx);
2306
2307 if (argc == 0)
2308 {
2309 breakpoint_t *breakpoint = target->breakpoints;
2310
2311 while (breakpoint)
2312 {
2313 if (breakpoint->type == BKPT_SOFT)
2314 {
2315 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2316 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2317 free(buf);
2318 }
2319 else
2320 {
2321 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2322 }
2323 breakpoint = breakpoint->next;
2324 }
2325 }
2326 else if (argc >= 2)
2327 {
2328 int hw = BKPT_SOFT;
2329 u32 length = 0;
2330
2331 length = strtoul(args[1], NULL, 0);
2332
2333 if (argc >= 3)
2334 if (strcmp(args[2], "hw") == 0)
2335 hw = BKPT_HARD;
2336
2337 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2338 {
2339 LOG_ERROR("Failure setting breakpoints");
2340 }
2341 else
2342 {
2343 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2344 }
2345 }
2346 else
2347 {
2348 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2349 }
2350
2351 return ERROR_OK;
2352 }
2353
2354 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2355 {
2356 target_t *target = get_current_target(cmd_ctx);
2357
2358 if (argc > 0)
2359 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2360
2361 return ERROR_OK;
2362 }
2363
2364 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2365 {
2366 target_t *target = get_current_target(cmd_ctx);
2367 int retval;
2368
2369 if (argc == 0)
2370 {
2371 watchpoint_t *watchpoint = target->watchpoints;
2372
2373 while (watchpoint)
2374 {
2375 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);
2376 watchpoint = watchpoint->next;
2377 }
2378 }
2379 else if (argc >= 2)
2380 {
2381 enum watchpoint_rw type = WPT_ACCESS;
2382 u32 data_value = 0x0;
2383 u32 data_mask = 0xffffffff;
2384
2385 if (argc >= 3)
2386 {
2387 switch(args[2][0])
2388 {
2389 case 'r':
2390 type = WPT_READ;
2391 break;
2392 case 'w':
2393 type = WPT_WRITE;
2394 break;
2395 case 'a':
2396 type = WPT_ACCESS;
2397 break;
2398 default:
2399 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2400 return ERROR_OK;
2401 }
2402 }
2403 if (argc >= 4)
2404 {
2405 data_value = strtoul(args[3], NULL, 0);
2406 }
2407 if (argc >= 5)
2408 {
2409 data_mask = strtoul(args[4], NULL, 0);
2410 }
2411
2412 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2413 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2414 {
2415 LOG_ERROR("Failure setting breakpoints");
2416 }
2417 }
2418 else
2419 {
2420 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2421 }
2422
2423 return ERROR_OK;
2424 }
2425
2426 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2427 {
2428 target_t *target = get_current_target(cmd_ctx);
2429
2430 if (argc > 0)
2431 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2432
2433 return ERROR_OK;
2434 }
2435
2436 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2437 {
2438 int retval;
2439 target_t *target = get_current_target(cmd_ctx);
2440 u32 va;
2441 u32 pa;
2442
2443 if (argc != 1)
2444 {
2445 return ERROR_COMMAND_SYNTAX_ERROR;
2446 }
2447 va = strtoul(args[0], NULL, 0);
2448
2449 retval = target->type->virt2phys(target, va, &pa);
2450 if (retval == ERROR_OK)
2451 {
2452 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2453 }
2454 else
2455 {
2456 /* lower levels will have logged a detailed error which is
2457 * forwarded to telnet/GDB session.
2458 */
2459 }
2460 return retval;
2461 }
2462 static void writeLong(FILE *f, int l)
2463 {
2464 int i;
2465 for (i=0; i<4; i++)
2466 {
2467 char c=(l>>(i*8))&0xff;
2468 fwrite(&c, 1, 1, f);
2469 }
2470
2471 }
2472 static void writeString(FILE *f, char *s)
2473 {
2474 fwrite(s, 1, strlen(s), f);
2475 }
2476
2477
2478
2479 // Dump a gmon.out histogram file.
2480 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2481 {
2482 int i;
2483 FILE *f=fopen(filename, "w");
2484 if (f==NULL)
2485 return;
2486 fwrite("gmon", 1, 4, f);
2487 writeLong(f, 0x00000001); // Version
2488 writeLong(f, 0); // padding
2489 writeLong(f, 0); // padding
2490 writeLong(f, 0); // padding
2491
2492 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2493
2494 // figure out bucket size
2495 u32 min=samples[0];
2496 u32 max=samples[0];
2497 for (i=0; i<sampleNum; i++)
2498 {
2499 if (min>samples[i])
2500 {
2501 min=samples[i];
2502 }
2503 if (max<samples[i])
2504 {
2505 max=samples[i];
2506 }
2507 }
2508
2509 int addressSpace=(max-min+1);
2510
2511 static int const maxBuckets=256*1024; // maximum buckets.
2512 int length=addressSpace;
2513 if (length > maxBuckets)
2514 {
2515 length=maxBuckets;
2516 }
2517 int *buckets=malloc(sizeof(int)*length);
2518 if (buckets==NULL)
2519 {
2520 fclose(f);
2521 return;
2522 }
2523 memset(buckets, 0, sizeof(int)*length);
2524 for (i=0; i<sampleNum;i++)
2525 {
2526 u32 address=samples[i];
2527 long long a=address-min;
2528 long long b=length-1;
2529 long long c=addressSpace-1;
2530 int index=(a*b)/c; // danger!!!! int32 overflows
2531 buckets[index]++;
2532 }
2533
2534 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2535 writeLong(f, min); // low_pc
2536 writeLong(f, max); // high_pc
2537 writeLong(f, length); // # of samples
2538 writeLong(f, 64000000); // 64MHz
2539 writeString(f, "seconds");
2540 for (i=0; i<(15-strlen("seconds")); i++)
2541 {
2542 fwrite("", 1, 1, f); // padding
2543 }
2544 writeString(f, "s");
2545
2546 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2547
2548 char *data=malloc(2*length);
2549 if (data!=NULL)
2550 {
2551 for (i=0; i<length;i++)
2552 {
2553 int val;
2554 val=buckets[i];
2555 if (val>65535)
2556 {
2557 val=65535;
2558 }
2559 data[i*2]=val&0xff;
2560 data[i*2+1]=(val>>8)&0xff;
2561 }
2562 free(buckets);
2563 fwrite(data, 1, length*2, f);
2564 free(data);
2565 } else
2566 {
2567 free(buckets);
2568 }
2569
2570 fclose(f);
2571 }
2572
2573 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2574 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2575 {
2576 target_t *target = get_current_target(cmd_ctx);
2577 struct timeval timeout, now;
2578
2579 gettimeofday(&timeout, NULL);
2580 if (argc!=2)
2581 {
2582 return ERROR_COMMAND_SYNTAX_ERROR;
2583 }
2584 char *end;
2585 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2586 if (*end)
2587 {
2588 return ERROR_OK;
2589 }
2590
2591 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2592
2593 static const int maxSample=10000;
2594 u32 *samples=malloc(sizeof(u32)*maxSample);
2595 if (samples==NULL)
2596 return ERROR_OK;
2597
2598 int numSamples=0;
2599 int retval=ERROR_OK;
2600 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2601 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2602
2603 for (;;)
2604 {
2605 target_poll(target);
2606 if (target->state == TARGET_HALTED)
2607 {
2608 u32 t=*((u32 *)reg->value);
2609 samples[numSamples++]=t;
2610 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2611 target_poll(target);
2612 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2613 } else if (target->state == TARGET_RUNNING)
2614 {
2615 // We want to quickly sample the PC.
2616 target_halt(target);
2617 } else
2618 {
2619 command_print(cmd_ctx, "Target not halted or running");
2620 retval=ERROR_OK;
2621 break;
2622 }
2623 if (retval!=ERROR_OK)
2624 {
2625 break;
2626 }
2627
2628 gettimeofday(&now, NULL);
2629 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2630 {
2631 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2632 target_poll(target);
2633 if (target->state == TARGET_HALTED)
2634 {
2635 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2636 }
2637 target_poll(target);
2638 writeGmon(samples, numSamples, args[1]);
2639 command_print(cmd_ctx, "Wrote %s", args[1]);
2640 break;
2641 }
2642 }
2643 free(samples);
2644
2645 return ERROR_OK;
2646 }
2647
2648 static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
2649 {
2650 char *namebuf;
2651 Jim_Obj *nameObjPtr, *valObjPtr;
2652 int result;
2653
2654 namebuf = alloc_printf("%s(%d)", varname, idx);
2655 if (!namebuf)
2656 return JIM_ERR;
2657
2658 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2659 valObjPtr = Jim_NewIntObj(interp, val);
2660 if (!nameObjPtr || !valObjPtr)
2661 {
2662 free(namebuf);
2663 return JIM_ERR;
2664 }
2665
2666 Jim_IncrRefCount(nameObjPtr);
2667 Jim_IncrRefCount(valObjPtr);
2668 result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
2669 Jim_DecrRefCount(interp, nameObjPtr);
2670 Jim_DecrRefCount(interp, valObjPtr);
2671 free(namebuf);
2672 /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */
2673 return result;
2674 }
2675
2676 static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2677 {
2678 target_t *target;
2679 command_context_t *context;
2680 long l;
2681 u32 width;
2682 u32 len;
2683 u32 addr;
2684 u32 count;
2685 u32 v;
2686 const char *varname;
2687 u8 buffer[4096];
2688 int i, n, e, retval;
2689
2690 /* argv[1] = name of array to receive the data
2691 * argv[2] = desired width
2692 * argv[3] = memory address
2693 * argv[4] = count of times to read
2694 */
2695 if (argc != 5) {
2696 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2697 return JIM_ERR;
2698 }
2699 varname = Jim_GetString(argv[1], &len);
2700 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2701
2702 e = Jim_GetLong(interp, argv[2], &l);
2703 width = l;
2704 if (e != JIM_OK) {
2705 return e;
2706 }
2707
2708 e = Jim_GetLong(interp, argv[3], &l);
2709 addr = l;
2710 if (e != JIM_OK) {
2711 return e;
2712 }
2713 e = Jim_GetLong(interp, argv[4], &l);
2714 len = l;
2715 if (e != JIM_OK) {
2716 return e;
2717 }
2718 switch (width) {
2719 case 8:
2720 width = 1;
2721 break;
2722 case 16:
2723 width = 2;
2724 break;
2725 case 32:
2726 width = 4;
2727 break;
2728 default:
2729 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2730 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2731 return JIM_ERR;
2732 }
2733 if (len == 0) {
2734 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2735 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
2736 return JIM_ERR;
2737 }
2738 if ((addr + (len * width)) < addr) {
2739 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2740 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
2741 return JIM_ERR;
2742 }
2743 /* absurd transfer size? */
2744 if (len > 65536) {
2745 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2746 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
2747 return JIM_ERR;
2748 }
2749
2750 if ((width == 1) ||
2751 ((width == 2) && ((addr & 1) == 0)) ||
2752 ((width == 4) && ((addr & 3) == 0))) {
2753 /* all is well */
2754 } else {
2755 char buf[100];
2756 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2757 sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
2758 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2759 return JIM_ERR;
2760 }
2761
2762 context = Jim_GetAssocData(interp, "context");
2763 if (context == NULL)
2764 {
2765 LOG_ERROR("mem2array: no command context");
2766 return JIM_ERR;
2767 }
2768 target = get_current_target(context);
2769 if (target == NULL)
2770 {
2771 LOG_ERROR("mem2array: no current target");
2772 return JIM_ERR;
2773 }
2774
2775 /* Transfer loop */
2776
2777 /* index counter */
2778 n = 0;
2779 /* assume ok */
2780 e = JIM_OK;
2781 while (len) {
2782 /* Slurp... in buffer size chunks */
2783
2784 count = len; /* in objects.. */
2785 if (count > (sizeof(buffer)/width)) {
2786 count = (sizeof(buffer)/width);
2787 }
2788
2789 retval = target->type->read_memory( target, addr, width, count, buffer );
2790 if (retval != ERROR_OK) {
2791 /* BOO !*/
2792 LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2793 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2794 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2795 e = JIM_ERR;
2796 len = 0;
2797 } else {
2798 v = 0; /* shut up gcc */
2799 for (i = 0 ;i < count ;i++, n++) {
2800 switch (width) {
2801 case 4:
2802 v = target_buffer_get_u32(target, &buffer[i*width]);
2803 break;
2804 case 2:
2805 v = target_buffer_get_u16(target, &buffer[i*width]);
2806 break;
2807 case 1:
2808 v = buffer[i] & 0x0ff;
2809 break;
2810 }
2811 new_int_array_element(interp, varname, n, v);
2812 }
2813 len -= count;
2814 }
2815 }
2816
2817 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2818
2819 return JIM_OK;
2820 }
2821
2822 static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
2823 {
2824 char *namebuf;
2825 Jim_Obj *nameObjPtr, *valObjPtr;
2826 int result;
2827 long l;
2828
2829 namebuf = alloc_printf("%s(%d)", varname, idx);
2830 if (!namebuf)
2831 return JIM_ERR;
2832
2833 nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
2834 if (!nameObjPtr)
2835 {
2836 free(namebuf);
2837 return JIM_ERR;
2838 }
2839
2840 Jim_IncrRefCount(nameObjPtr);
2841 valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
2842 Jim_DecrRefCount(interp, nameObjPtr);
2843 free(namebuf);
2844 if (valObjPtr == NULL)
2845 return JIM_ERR;
2846
2847 result = Jim_GetLong(interp, valObjPtr, &l);
2848 /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
2849 *val = l;
2850 return result;
2851 }
2852
2853 static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2854 {
2855 target_t *target;
2856 command_context_t *context;
2857 long l;
2858 u32 width;
2859 u32 len;
2860 u32 addr;
2861 u32 count;
2862 u32 v;
2863 const char *varname;
2864 u8 buffer[4096];
2865 int i, n, e, retval;
2866
2867 /* argv[1] = name of array to get the data
2868 * argv[2] = desired width
2869 * argv[3] = memory address
2870 * argv[4] = count to write
2871 */
2872 if (argc != 5) {
2873 Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
2874 return JIM_ERR;
2875 }
2876 varname = Jim_GetString(argv[1], &len);
2877 /* given "foo" get space for worse case "foo(%d)" .. add 20 */
2878
2879 e = Jim_GetLong(interp, argv[2], &l);
2880 width = l;
2881 if (e != JIM_OK) {
2882 return e;
2883 }
2884
2885 e = Jim_GetLong(interp, argv[3], &l);
2886 addr = l;
2887 if (e != JIM_OK) {
2888 return e;
2889 }
2890 e = Jim_GetLong(interp, argv[4], &l);
2891 len = l;
2892 if (e != JIM_OK) {
2893 return e;
2894 }
2895 switch (width) {
2896 case 8:
2897 width = 1;
2898 break;
2899 case 16:
2900 width = 2;
2901 break;
2902 case 32:
2903 width = 4;
2904 break;
2905 default:
2906 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2907 Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL );
2908 return JIM_ERR;
2909 }
2910 if (len == 0) {
2911 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2912 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
2913 return JIM_ERR;
2914 }
2915 if ((addr + (len * width)) < addr) {
2916 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2917 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
2918 return JIM_ERR;
2919 }
2920 /* absurd transfer size? */
2921 if (len > 65536) {
2922 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2923 Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
2924 return JIM_ERR;
2925 }
2926
2927 if ((width == 1) ||
2928 ((width == 2) && ((addr & 1) == 0)) ||
2929 ((width == 4) && ((addr & 3) == 0))) {
2930 /* all is well */
2931 } else {
2932 char buf[100];
2933 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2934 sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
2935 Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
2936 return JIM_ERR;
2937 }
2938
2939 context = Jim_GetAssocData(interp, "context");
2940 if (context == NULL)
2941 {
2942 LOG_ERROR("array2mem: no command context");
2943 return JIM_ERR;
2944 }
2945 target = get_current_target(context);
2946 if (target == NULL)
2947 {
2948 LOG_ERROR("array2mem: no current target");
2949 return JIM_ERR;
2950 }
2951
2952 /* Transfer loop */
2953
2954 /* index counter */
2955 n = 0;
2956 /* assume ok */
2957 e = JIM_OK;
2958 while (len) {
2959 /* Slurp... in buffer size chunks */
2960
2961 count = len; /* in objects.. */
2962 if (count > (sizeof(buffer)/width)) {
2963 count = (sizeof(buffer)/width);
2964 }
2965
2966 v = 0; /* shut up gcc */
2967 for (i = 0 ;i < count ;i++, n++) {
2968 get_int_array_element(interp, varname, n, &v);
2969 switch (width) {
2970 case 4:
2971 target_buffer_set_u32(target, &buffer[i*width], v);
2972 break;
2973 case 2:
2974 target_buffer_set_u16(target, &buffer[i*width], v);
2975 break;
2976 case 1:
2977 buffer[i] = v & 0x0ff;
2978 break;
2979 }
2980 }
2981 len -= count;
2982
2983 retval = target->type->write_memory(target, addr, width, count, buffer);
2984 if (retval != ERROR_OK) {
2985 /* BOO !*/
2986 LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
2987 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2988 Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
2989 e = JIM_ERR;
2990 len = 0;
2991 }
2992 }
2993
2994 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2995
2996 return JIM_OK;
2997 }
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)