Code Review / openocd.git / blob
? search:


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