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