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