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