Code Review / openocd.git / blob
? search:


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