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