Code Review / openocd.git / blob
? search:


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