Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- removed target_process_events as only used in handle_resume_command and events...
[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 int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1759 {
1760 int retval;
1761 struct timeval timeout, now;
1762 int once=1;
1763 gettimeofday(&timeout, NULL);
1764 timeval_add_time(&timeout, 0, ms * 1000);
1765
1766 target_t *target = get_current_target(cmd_ctx);
1767 for (;;)
1768 {
1769 if ((retval=target_poll(target))!=ERROR_OK)
1770 return retval;
1771 target_call_timer_callbacks_now();
1772 if (target->state == state)
1773 {
1774 break;
1775 }
1776 if (once)
1777 {
1778 once=0;
1779 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1780 }
1781
1782 gettimeofday(&now, NULL);
1783 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1784 {
1785 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1786 break;
1787 }
1788 }
1789
1790 return ERROR_OK;
1791 }
1792
1793 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1794 {
1795 int retval;
1796 target_t *target = get_current_target(cmd_ctx);
1797
1798 LOG_DEBUG("-");
1799
1800 if ((retval = target_halt(target)) != ERROR_OK)
1801 {
1802 return retval;
1803 }
1804
1805 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1806 }
1807
1808 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1809 {
1810 target_t *target = get_current_target(cmd_ctx);
1811
1812 LOG_USER("requesting target halt and executing a soft reset");
1813
1814 target->type->soft_reset_halt(target);
1815
1816 return ERROR_OK;
1817 }
1818
1819 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1820 {
1821 target_t *target = get_current_target(cmd_ctx);
1822 enum target_reset_mode reset_mode = target->reset_mode;
1823 enum target_reset_mode save = target->reset_mode;
1824
1825 LOG_DEBUG("-");
1826
1827 if (argc >= 1)
1828 {
1829 if (strcmp("run", args[0]) == 0)
1830 reset_mode = RESET_RUN;
1831 else if (strcmp("halt", args[0]) == 0)
1832 reset_mode = RESET_HALT;
1833 else if (strcmp("init", args[0]) == 0)
1834 reset_mode = RESET_INIT;
1835 else if (strcmp("run_and_halt", args[0]) == 0)
1836 {
1837 reset_mode = RESET_RUN_AND_HALT;
1838 if (argc >= 2)
1839 {
1840 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1841 }
1842 }
1843 else if (strcmp("run_and_init", args[0]) == 0)
1844 {
1845 reset_mode = RESET_RUN_AND_INIT;
1846 if (argc >= 2)
1847 {
1848 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1849 }
1850 }
1851 else
1852 {
1853 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1854 return ERROR_OK;
1855 }
1856 }
1857
1858 /* temporarily modify mode of current reset target */
1859 target->reset_mode = reset_mode;
1860
1861 /* reset *all* targets */
1862 target_process_reset(cmd_ctx);
1863
1864 /* Restore default reset mode for this target */
1865 target->reset_mode = save;
1866
1867 return ERROR_OK;
1868 }
1869
1870 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1871 {
1872 int retval;
1873 target_t *target = get_current_target(cmd_ctx);
1874
1875 target_invoke_script(cmd_ctx, target, "pre_resume");
1876
1877 if (argc == 0)
1878 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1879 else if (argc == 1)
1880 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1881 else
1882 {
1883 return ERROR_COMMAND_SYNTAX_ERROR;
1884 }
1885
1886 return retval;
1887 }
1888
1889 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1890 {
1891 target_t *target = get_current_target(cmd_ctx);
1892
1893 LOG_DEBUG("-");
1894
1895 if (argc == 0)
1896 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1897
1898 if (argc == 1)
1899 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1900
1901 return ERROR_OK;
1902 }
1903
1904 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1905 {
1906 const int line_bytecnt = 32;
1907 int count = 1;
1908 int size = 4;
1909 u32 address = 0;
1910 int line_modulo;
1911 int i;
1912
1913 char output[128];
1914 int output_len;
1915
1916 int retval;
1917
1918 u8 *buffer;
1919 target_t *target = get_current_target(cmd_ctx);
1920
1921 if (argc < 1)
1922 return ERROR_OK;
1923
1924 if (argc == 2)
1925 count = strtoul(args[1], NULL, 0);
1926
1927 address = strtoul(args[0], NULL, 0);
1928
1929
1930 switch (cmd[2])
1931 {
1932 case 'w':
1933 size = 4; line_modulo = line_bytecnt / 4;
1934 break;
1935 case 'h':
1936 size = 2; line_modulo = line_bytecnt / 2;
1937 break;
1938 case 'b':
1939 size = 1; line_modulo = line_bytecnt / 1;
1940 break;
1941 default:
1942 return ERROR_OK;
1943 }
1944
1945 buffer = calloc(count, size);
1946 retval = target->type->read_memory(target, address, size, count, buffer);
1947 if (retval == ERROR_OK)
1948 {
1949 output_len = 0;
1950
1951 for (i = 0; i < count; i++)
1952 {
1953 if (i%line_modulo == 0)
1954 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1955
1956 switch (size)
1957 {
1958 case 4:
1959 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1960 break;
1961 case 2:
1962 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1963 break;
1964 case 1:
1965 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1966 break;
1967 }
1968
1969 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1970 {
1971 command_print(cmd_ctx, output);
1972 output_len = 0;
1973 }
1974 }
1975 }
1976
1977 free(buffer);
1978
1979 return retval;
1980 }
1981
1982 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1983 {
1984 u32 address = 0;
1985 u32 value = 0;
1986 int count = 1;
1987 int i;
1988 int wordsize;
1989 target_t *target = get_current_target(cmd_ctx);
1990 u8 value_buf[4];
1991
1992 if ((argc < 2) || (argc > 3))
1993 return ERROR_COMMAND_SYNTAX_ERROR;
1994
1995 address = strtoul(args[0], NULL, 0);
1996 value = strtoul(args[1], NULL, 0);
1997 if (argc == 3)
1998 count = strtoul(args[2], NULL, 0);
1999
2000 switch (cmd[2])
2001 {
2002 case 'w':
2003 wordsize = 4;
2004 target_buffer_set_u32(target, value_buf, value);
2005 break;
2006 case 'h':
2007 wordsize = 2;
2008 target_buffer_set_u16(target, value_buf, value);
2009 break;
2010 case 'b':
2011 wordsize = 1;
2012 value_buf[0] = value;
2013 break;
2014 default:
2015 return ERROR_COMMAND_SYNTAX_ERROR;
2016 }
2017 for (i=0; i<count; i++)
2018 {
2019 int retval;
2020 switch (wordsize)
2021 {
2022 case 4:
2023 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
2024 break;
2025 case 2:
2026 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
2027 break;
2028 case 1:
2029 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
2030 break;
2031 default:
2032 return ERROR_OK;
2033 }
2034 if (retval!=ERROR_OK)
2035 {
2036 return retval;
2037 }
2038 }
2039
2040 return ERROR_OK;
2041
2042 }
2043
2044 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2045 {
2046 u8 *buffer;
2047 u32 buf_cnt;
2048 u32 image_size;
2049 int i;
2050 int retval;
2051
2052 image_t image;
2053
2054 duration_t duration;
2055 char *duration_text;
2056
2057 target_t *target = get_current_target(cmd_ctx);
2058
2059 if (argc < 1)
2060 {
2061 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
2062 return ERROR_OK;
2063 }
2064
2065 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2066 if (argc >= 2)
2067 {
2068 image.base_address_set = 1;
2069 image.base_address = strtoul(args[1], NULL, 0);
2070 }
2071 else
2072 {
2073 image.base_address_set = 0;
2074 }
2075
2076 image.start_address_set = 0;
2077
2078 duration_start_measure(&duration);
2079
2080 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2081 {
2082 return ERROR_OK;
2083 }
2084
2085 image_size = 0x0;
2086 retval = ERROR_OK;
2087 for (i = 0; i < image.num_sections; i++)
2088 {
2089 buffer = malloc(image.sections[i].size);
2090 if (buffer == NULL)
2091 {
2092 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2093 break;
2094 }
2095
2096 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2097 {
2098 free(buffer);
2099 break;
2100 }
2101 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
2102 {
2103 free(buffer);
2104 break;
2105 }
2106 image_size += buf_cnt;
2107 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2108
2109 free(buffer);
2110 }
2111
2112 duration_stop_measure(&duration, &duration_text);
2113 if (retval==ERROR_OK)
2114 {
2115 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2116 }
2117 free(duration_text);
2118
2119 image_close(&image);
2120
2121 return retval;
2122
2123 }
2124
2125 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2126 {
2127 fileio_t fileio;
2128
2129 u32 address;
2130 u32 size;
2131 u8 buffer[560];
2132 int retval=ERROR_OK;
2133
2134 duration_t duration;
2135 char *duration_text;
2136
2137 target_t *target = get_current_target(cmd_ctx);
2138
2139 if (argc != 3)
2140 {
2141 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2142 return ERROR_OK;
2143 }
2144
2145 address = strtoul(args[1], NULL, 0);
2146 size = strtoul(args[2], NULL, 0);
2147
2148 if ((address & 3) || (size & 3))
2149 {
2150 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2151 return ERROR_OK;
2152 }
2153
2154 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2155 {
2156 return ERROR_OK;
2157 }
2158
2159 duration_start_measure(&duration);
2160
2161 while (size > 0)
2162 {
2163 u32 size_written;
2164 u32 this_run_size = (size > 560) ? 560 : size;
2165
2166 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2167 if (retval != ERROR_OK)
2168 {
2169 break;
2170 }
2171
2172 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2173 if (retval != ERROR_OK)
2174 {
2175 break;
2176 }
2177
2178 size -= this_run_size;
2179 address += this_run_size;
2180 }
2181
2182 fileio_close(&fileio);
2183
2184 duration_stop_measure(&duration, &duration_text);
2185 if (retval==ERROR_OK)
2186 {
2187 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2188 }
2189 free(duration_text);
2190
2191 return ERROR_OK;
2192 }
2193
2194 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2195 {
2196 u8 *buffer;
2197 u32 buf_cnt;
2198 u32 image_size;
2199 int i;
2200 int retval;
2201 u32 checksum = 0;
2202 u32 mem_checksum = 0;
2203
2204 image_t image;
2205
2206 duration_t duration;
2207 char *duration_text;
2208
2209 target_t *target = get_current_target(cmd_ctx);
2210
2211 if (argc < 1)
2212 {
2213 return ERROR_COMMAND_SYNTAX_ERROR;
2214 }
2215
2216 if (!target)
2217 {
2218 LOG_ERROR("no target selected");
2219 return ERROR_FAIL;
2220 }
2221
2222 duration_start_measure(&duration);
2223
2224 if (argc >= 2)
2225 {
2226 image.base_address_set = 1;
2227 image.base_address = strtoul(args[1], NULL, 0);
2228 }
2229 else
2230 {
2231 image.base_address_set = 0;
2232 image.base_address = 0x0;
2233 }
2234
2235 image.start_address_set = 0;
2236
2237 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2238 {
2239 return retval;
2240 }
2241
2242 image_size = 0x0;
2243 retval=ERROR_OK;
2244 for (i = 0; i < image.num_sections; i++)
2245 {
2246 buffer = malloc(image.sections[i].size);
2247 if (buffer == NULL)
2248 {
2249 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2250 break;
2251 }
2252 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2253 {
2254 free(buffer);
2255 break;
2256 }
2257
2258 /* calculate checksum of image */
2259 image_calculate_checksum( buffer, buf_cnt, &checksum );
2260
2261 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2262 if( retval != ERROR_OK )
2263 {
2264 free(buffer);
2265 break;
2266 }
2267
2268 if( checksum != mem_checksum )
2269 {
2270 /* failed crc checksum, fall back to a binary compare */
2271 u8 *data;
2272
2273 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2274
2275 data = (u8*)malloc(buf_cnt);
2276
2277 /* Can we use 32bit word accesses? */
2278 int size = 1;
2279 int count = buf_cnt;
2280 if ((count % 4) == 0)
2281 {
2282 size *= 4;
2283 count /= 4;
2284 }
2285 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2286 if (retval == ERROR_OK)
2287 {
2288 int t;
2289 for (t = 0; t < buf_cnt; t++)
2290 {
2291 if (data[t] != buffer[t])
2292 {
2293 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]);
2294 free(data);
2295 free(buffer);
2296 retval=ERROR_FAIL;
2297 goto done;
2298 }
2299 }
2300 }
2301
2302 free(data);
2303 }
2304
2305 free(buffer);
2306 image_size += buf_cnt;
2307 }
2308 done:
2309 duration_stop_measure(&duration, &duration_text);
2310 if (retval==ERROR_OK)
2311 {
2312 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2313 }
2314 free(duration_text);
2315
2316 image_close(&image);
2317
2318 return retval;
2319 }
2320
2321 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2322 {
2323 int retval;
2324 target_t *target = get_current_target(cmd_ctx);
2325
2326 if (argc == 0)
2327 {
2328 breakpoint_t *breakpoint = target->breakpoints;
2329
2330 while (breakpoint)
2331 {
2332 if (breakpoint->type == BKPT_SOFT)
2333 {
2334 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2335 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2336 free(buf);
2337 }
2338 else
2339 {
2340 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2341 }
2342 breakpoint = breakpoint->next;
2343 }
2344 }
2345 else if (argc >= 2)
2346 {
2347 int hw = BKPT_SOFT;
2348 u32 length = 0;
2349
2350 length = strtoul(args[1], NULL, 0);
2351
2352 if (argc >= 3)
2353 if (strcmp(args[2], "hw") == 0)
2354 hw = BKPT_HARD;
2355
2356 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2357 {
2358 LOG_ERROR("Failure setting breakpoints");
2359 }
2360 else
2361 {
2362 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2363 }
2364 }
2365 else
2366 {
2367 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2368 }
2369
2370 return ERROR_OK;
2371 }
2372
2373 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2374 {
2375 target_t *target = get_current_target(cmd_ctx);
2376
2377 if (argc > 0)
2378 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2379
2380 return ERROR_OK;
2381 }
2382
2383 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2384 {
2385 target_t *target = get_current_target(cmd_ctx);
2386 int retval;
2387
2388 if (argc == 0)
2389 {
2390 watchpoint_t *watchpoint = target->watchpoints;
2391
2392 while (watchpoint)
2393 {
2394 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);
2395 watchpoint = watchpoint->next;
2396 }
2397 }
2398 else if (argc >= 2)
2399 {
2400 enum watchpoint_rw type = WPT_ACCESS;
2401 u32 data_value = 0x0;
2402 u32 data_mask = 0xffffffff;
2403
2404 if (argc >= 3)
2405 {
2406 switch(args[2][0])
2407 {
2408 case 'r':
2409 type = WPT_READ;
2410 break;
2411 case 'w':
2412 type = WPT_WRITE;
2413 break;
2414 case 'a':
2415 type = WPT_ACCESS;
2416 break;
2417 default:
2418 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2419 return ERROR_OK;
2420 }
2421 }
2422 if (argc >= 4)
2423 {
2424 data_value = strtoul(args[3], NULL, 0);
2425 }
2426 if (argc >= 5)
2427 {
2428 data_mask = strtoul(args[4], NULL, 0);
2429 }
2430
2431 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2432 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2433 {
2434 LOG_ERROR("Failure setting breakpoints");
2435 }
2436 }
2437 else
2438 {
2439 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2440 }
2441
2442 return ERROR_OK;
2443 }
2444
2445 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2446 {
2447 target_t *target = get_current_target(cmd_ctx);
2448
2449 if (argc > 0)
2450 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2451
2452 return ERROR_OK;
2453 }
2454
2455 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2456 {
2457 int retval;
2458 target_t *target = get_current_target(cmd_ctx);
2459 u32 va;
2460 u32 pa;
2461
2462 if (argc != 1)
2463 {
2464 return ERROR_COMMAND_SYNTAX_ERROR;
2465 }
2466 va = strtoul(args[0], NULL, 0);
2467
2468 retval = target->type->virt2phys(target, va, &pa);
2469 if (retval == ERROR_OK)
2470 {
2471 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2472 }
2473 else
2474 {
2475 /* lower levels will have logged a detailed error which is
2476 * forwarded to telnet/GDB session.
2477 */
2478 }
2479 return retval;
2480 }
2481 static void writeLong(FILE *f, int l)
2482 {
2483 int i;
2484 for (i=0; i<4; i++)
2485 {
2486 char c=(l>>(i*8))&0xff;
2487 fwrite(&c, 1, 1, f);
2488 }
2489
2490 }
2491 static void writeString(FILE *f, char *s)
2492 {
2493 fwrite(s, 1, strlen(s), f);
2494 }
2495
2496
2497
2498 // Dump a gmon.out histogram file.
2499 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2500 {
2501 int i;
2502 FILE *f=fopen(filename, "w");
2503 if (f==NULL)
2504 return;
2505 fwrite("gmon", 1, 4, f);
2506 writeLong(f, 0x00000001); // Version
2507 writeLong(f, 0); // padding
2508 writeLong(f, 0); // padding
2509 writeLong(f, 0); // padding
2510
2511 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2512
2513 // figure out bucket size
2514 u32 min=samples[0];
2515 u32 max=samples[0];
2516 for (i=0; i<sampleNum; i++)
2517 {
2518 if (min>samples[i])
2519 {
2520 min=samples[i];
2521 }
2522 if (max<samples[i])
2523 {
2524 max=samples[i];
2525 }
2526 }
2527
2528 int addressSpace=(max-min+1);
2529
2530 static int const maxBuckets=256*1024; // maximum buckets.
2531 int length=addressSpace;
2532 if (length > maxBuckets)
2533 {
2534 length=maxBuckets;
2535 }
2536 int *buckets=malloc(sizeof(int)*length);
2537 if (buckets==NULL)
2538 {
2539 fclose(f);
2540 return;
2541 }
2542 memset(buckets, 0, sizeof(int)*length);
2543 for (i=0; i<sampleNum;i++)
2544 {
2545 u32 address=samples[i];
2546 long long a=address-min;
2547 long long b=length-1;
2548 long long c=addressSpace-1;
2549 int index=(a*b)/c; // danger!!!! int32 overflows
2550 buckets[index]++;
2551 }
2552
2553 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2554 writeLong(f, min); // low_pc
2555 writeLong(f, max); // high_pc
2556 writeLong(f, length); // # of samples
2557 writeLong(f, 64000000); // 64MHz
2558 writeString(f, "seconds");
2559 for (i=0; i<(15-strlen("seconds")); i++)
2560 {
2561 fwrite("", 1, 1, f); // padding
2562 }
2563 writeString(f, "s");
2564
2565 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2566
2567 char *data=malloc(2*length);
2568 if (data!=NULL)
2569 {
2570 for (i=0; i<length;i++)
2571 {
2572 int val;
2573 val=buckets[i];
2574 if (val>65535)
2575 {
2576 val=65535;
2577 }
2578 data[i*2]=val&0xff;
2579 data[i*2+1]=(val>>8)&0xff;
2580 }
2581 free(buckets);
2582 fwrite(data, 1, length*2, f);
2583 free(data);
2584 } else
2585 {
2586 free(buckets);
2587 }
2588
2589 fclose(f);
2590 }
2591
2592 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2593 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2594 {
2595 target_t *target = get_current_target(cmd_ctx);
2596 struct timeval timeout, now;
2597
2598 gettimeofday(&timeout, NULL);
2599 if (argc!=2)
2600 {
2601 return ERROR_COMMAND_SYNTAX_ERROR;
2602 }
2603 char *end;
2604 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2605 if (*end)
2606 {
2607 return ERROR_OK;
2608 }
2609
2610 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2611
2612 static const int maxSample=10000;
2613 u32 *samples=malloc(sizeof(u32)*maxSample);
2614 if (samples==NULL)
2615 return ERROR_OK;
2616
2617 int numSamples=0;
2618 int retval=ERROR_OK;
2619 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2620 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2621
2622 for (;;)
2623 {
2624 target_poll(target);
2625 if (target->state == TARGET_HALTED)
2626 {
2627 u32 t=*((u32 *)reg->value);
2628 samples[numSamples++]=t;
2629 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2630 target_poll(target);
2631 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2632 } else if (target->state == TARGET_RUNNING)
2633 {
2634 // We want to quickly sample the PC.
2635 target_halt(target);
2636 } else
2637 {
2638 command_print(cmd_ctx, "Target not halted or running");
2639 retval=ERROR_OK;
2640 break;
2641 }
2642 if (retval!=ERROR_OK)
2643 {
2644 break;
2645 }
2646
2647 gettimeofday(&now, NULL);
2648 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2649 {
2650 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2651 target_poll(target);
2652 if (target->state == TARGET_HALTED)
2653 {
2654 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2655 }
2656 target_poll(target);
2657 writeGmon(samples, numSamples, args[1]);
2658 command_print(cmd_ctx, "Wrote %s", args[1]);
2659 break;
2660 }
2661 }
2662 free(samples);
2663
2664 return ERROR_OK;
2665 }
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)