Code Review / openocd.git / blob
? search:


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