Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Fixed bogus error message and plugged memory leak for the case when there was no...
[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 (*last_target_p)->type = target_types[i];
1407
1408 if (strcmp(args[1], "big") == 0)
1409 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1410 else if (strcmp(args[1], "little") == 0)
1411 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1412 else
1413 {
1414 LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1415 return ERROR_COMMAND_SYNTAX_ERROR;
1416 }
1417
1418 /* what to do on a target reset */
1419 (*last_target_p)->reset_mode = RESET_INIT; /* default */
1420 if (strcmp(args[2], "reset_halt") == 0)
1421 (*last_target_p)->reset_mode = RESET_HALT;
1422 else if (strcmp(args[2], "reset_run") == 0)
1423 (*last_target_p)->reset_mode = RESET_RUN;
1424 else if (strcmp(args[2], "reset_init") == 0)
1425 (*last_target_p)->reset_mode = RESET_INIT;
1426 else if (strcmp(args[2], "run_and_halt") == 0)
1427 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1428 else if (strcmp(args[2], "run_and_init") == 0)
1429 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1430 else
1431 {
1432 /* Kludge! we want to make this reset arg optional while remaining compatible! */
1433 args--;
1434 argc++;
1435 }
1436 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1437
1438 (*last_target_p)->reset_script = NULL;
1439 (*last_target_p)->pre_reset_script = NULL;
1440 (*last_target_p)->post_halt_script = NULL;
1441 (*last_target_p)->pre_resume_script = NULL;
1442 (*last_target_p)->gdb_program_script = NULL;
1443
1444 (*last_target_p)->working_area = 0x0;
1445 (*last_target_p)->working_area_size = 0x0;
1446 (*last_target_p)->working_areas = NULL;
1447 (*last_target_p)->backup_working_area = 0;
1448
1449 (*last_target_p)->state = TARGET_UNKNOWN;
1450 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1451 (*last_target_p)->reg_cache = NULL;
1452 (*last_target_p)->breakpoints = NULL;
1453 (*last_target_p)->watchpoints = NULL;
1454 (*last_target_p)->next = NULL;
1455 (*last_target_p)->arch_info = NULL;
1456
1457 /* initialize trace information */
1458 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1459 (*last_target_p)->trace_info->num_trace_points = 0;
1460 (*last_target_p)->trace_info->trace_points_size = 0;
1461 (*last_target_p)->trace_info->trace_points = NULL;
1462 (*last_target_p)->trace_info->trace_history_size = 0;
1463 (*last_target_p)->trace_info->trace_history = NULL;
1464 (*last_target_p)->trace_info->trace_history_pos = 0;
1465 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1466
1467 (*last_target_p)->dbgmsg = NULL;
1468 (*last_target_p)->dbg_msg_enabled = 0;
1469
1470 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1471
1472 found = 1;
1473 break;
1474 }
1475 }
1476 }
1477
1478 /* no matching target found */
1479 if (!found)
1480 {
1481 LOG_ERROR("target '%s' not found", args[0]);
1482 return ERROR_COMMAND_SYNTAX_ERROR;
1483 }
1484
1485 return ERROR_OK;
1486 }
1487
1488 /* usage: target_script <target#> <event> <script_file> */
1489 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1490 {
1491 target_t *target = NULL;
1492
1493 if (argc < 3)
1494 {
1495 LOG_ERROR("incomplete target_script command");
1496 return ERROR_COMMAND_SYNTAX_ERROR;
1497 }
1498
1499 target = get_target_by_num(strtoul(args[0], NULL, 0));
1500
1501 if (!target)
1502 {
1503 return ERROR_COMMAND_SYNTAX_ERROR;
1504 }
1505
1506 if ((strcmp(args[1], "reset") == 0)||(strcmp(args[1], "post_reset") == 0))
1507 {
1508 if (target->reset_script)
1509 free(target->reset_script);
1510 target->reset_script = strdup(args[2]);
1511 }
1512 else if (strcmp(args[1], "pre_reset") == 0)
1513 {
1514 if (target->pre_reset_script)
1515 free(target->pre_reset_script);
1516 target->pre_reset_script = strdup(args[2]);
1517 }
1518 else if (strcmp(args[1], "post_halt") == 0)
1519 {
1520 if (target->post_halt_script)
1521 free(target->post_halt_script);
1522 target->post_halt_script = strdup(args[2]);
1523 }
1524 else if (strcmp(args[1], "pre_resume") == 0)
1525 {
1526 if (target->pre_resume_script)
1527 free(target->pre_resume_script);
1528 target->pre_resume_script = strdup(args[2]);
1529 }
1530 else if (strcmp(args[1], "gdb_program_config") == 0)
1531 {
1532 if (target->gdb_program_script)
1533 free(target->gdb_program_script);
1534 target->gdb_program_script = strdup(args[2]);
1535 }
1536 else
1537 {
1538 LOG_ERROR("unknown event type: '%s", args[1]);
1539 return ERROR_COMMAND_SYNTAX_ERROR;
1540 }
1541
1542 return ERROR_OK;
1543 }
1544
1545 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1546 {
1547 target_t *target = NULL;
1548
1549 if (argc < 2)
1550 {
1551 return ERROR_COMMAND_SYNTAX_ERROR;
1552 }
1553
1554 target = get_target_by_num(strtoul(args[0], NULL, 0));
1555 if (!target)
1556 {
1557 return ERROR_COMMAND_SYNTAX_ERROR;
1558 }
1559
1560 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1561
1562 return ERROR_OK;
1563 }
1564
1565 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1566 {
1567 target_t *target = NULL;
1568
1569 if ((argc < 4) || (argc > 5))
1570 {
1571 return ERROR_COMMAND_SYNTAX_ERROR;
1572 }
1573
1574 target = get_target_by_num(strtoul(args[0], NULL, 0));
1575 if (!target)
1576 {
1577 return ERROR_COMMAND_SYNTAX_ERROR;
1578 }
1579 target_free_all_working_areas(target);
1580
1581 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1582 if (argc == 5)
1583 {
1584 target->working_area_virt = strtoul(args[4], NULL, 0);
1585 }
1586 target->working_area_size = strtoul(args[2], NULL, 0);
1587
1588 if (strcmp(args[3], "backup") == 0)
1589 {
1590 target->backup_working_area = 1;
1591 }
1592 else if (strcmp(args[3], "nobackup") == 0)
1593 {
1594 target->backup_working_area = 0;
1595 }
1596 else
1597 {
1598 LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1599 return ERROR_COMMAND_SYNTAX_ERROR;
1600 }
1601
1602 return ERROR_OK;
1603 }
1604
1605
1606 /* process target state changes */
1607 int handle_target(void *priv)
1608 {
1609 target_t *target = targets;
1610
1611 while (target)
1612 {
1613 if (target_continous_poll)
1614 {
1615 /* polling may fail silently until the target has been examined */
1616 target_poll(target);
1617 }
1618
1619 target = target->next;
1620 }
1621
1622 return ERROR_OK;
1623 }
1624
1625 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1626 {
1627 target_t *target;
1628 reg_t *reg = NULL;
1629 int count = 0;
1630 char *value;
1631
1632 LOG_DEBUG("-");
1633
1634 target = get_current_target(cmd_ctx);
1635
1636 /* list all available registers for the current target */
1637 if (argc == 0)
1638 {
1639 reg_cache_t *cache = target->reg_cache;
1640
1641 count = 0;
1642 while(cache)
1643 {
1644 int i;
1645 for (i = 0; i < cache->num_regs; i++)
1646 {
1647 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1648 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);
1649 free(value);
1650 }
1651 cache = cache->next;
1652 }
1653
1654 return ERROR_OK;
1655 }
1656
1657 /* access a single register by its ordinal number */
1658 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1659 {
1660 int num = strtoul(args[0], NULL, 0);
1661 reg_cache_t *cache = target->reg_cache;
1662
1663 count = 0;
1664 while(cache)
1665 {
1666 int i;
1667 for (i = 0; i < cache->num_regs; i++)
1668 {
1669 if (count++ == num)
1670 {
1671 reg = &cache->reg_list[i];
1672 break;
1673 }
1674 }
1675 if (reg)
1676 break;
1677 cache = cache->next;
1678 }
1679
1680 if (!reg)
1681 {
1682 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1683 return ERROR_OK;
1684 }
1685 } else /* access a single register by its name */
1686 {
1687 reg = register_get_by_name(target->reg_cache, args[0], 1);
1688
1689 if (!reg)
1690 {
1691 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1692 return ERROR_OK;
1693 }
1694 }
1695
1696 /* display a register */
1697 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1698 {
1699 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1700 reg->valid = 0;
1701
1702 if (reg->valid == 0)
1703 {
1704 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1705 if (arch_type == NULL)
1706 {
1707 LOG_ERROR("BUG: encountered unregistered arch type");
1708 return ERROR_OK;
1709 }
1710 arch_type->get(reg);
1711 }
1712 value = buf_to_str(reg->value, reg->size, 16);
1713 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1714 free(value);
1715 return ERROR_OK;
1716 }
1717
1718 /* set register value */
1719 if (argc == 2)
1720 {
1721 u8 *buf = malloc(CEIL(reg->size, 8));
1722 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1723
1724 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1725 if (arch_type == NULL)
1726 {
1727 LOG_ERROR("BUG: encountered unregistered arch type");
1728 return ERROR_OK;
1729 }
1730
1731 arch_type->set(reg, buf);
1732
1733 value = buf_to_str(reg->value, reg->size, 16);
1734 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1735 free(value);
1736
1737 free(buf);
1738
1739 return ERROR_OK;
1740 }
1741
1742 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1743
1744 return ERROR_OK;
1745 }
1746
1747 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1748
1749 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1750 {
1751 target_t *target = get_current_target(cmd_ctx);
1752
1753 if (argc == 0)
1754 {
1755 target_poll(target);
1756 target_arch_state(target);
1757 }
1758 else
1759 {
1760 if (strcmp(args[0], "on") == 0)
1761 {
1762 target_continous_poll = 1;
1763 }
1764 else if (strcmp(args[0], "off") == 0)
1765 {
1766 target_continous_poll = 0;
1767 }
1768 else
1769 {
1770 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1771 }
1772 }
1773
1774
1775 return ERROR_OK;
1776 }
1777
1778 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1779 {
1780 int ms = 5000;
1781
1782 if (argc > 0)
1783 {
1784 char *end;
1785
1786 ms = strtoul(args[0], &end, 0) * 1000;
1787 if (*end)
1788 {
1789 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1790 return ERROR_OK;
1791 }
1792 }
1793
1794 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1795 }
1796
1797 static void target_process_events(struct command_context_s *cmd_ctx)
1798 {
1799 target_t *target = get_current_target(cmd_ctx);
1800 target_poll(target);
1801 target_call_timer_callbacks_now();
1802 }
1803
1804 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1805 {
1806 int retval;
1807 struct timeval timeout, now;
1808 int once=1;
1809 gettimeofday(&timeout, NULL);
1810 timeval_add_time(&timeout, 0, ms * 1000);
1811
1812 target_t *target = get_current_target(cmd_ctx);
1813 for (;;)
1814 {
1815 if ((retval=target_poll(target))!=ERROR_OK)
1816 return retval;
1817 target_call_timer_callbacks_now();
1818 if (target->state == state)
1819 {
1820 break;
1821 }
1822 if (once)
1823 {
1824 once=0;
1825 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1826 }
1827
1828 gettimeofday(&now, NULL);
1829 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1830 {
1831 LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
1832 break;
1833 }
1834 }
1835
1836 return ERROR_OK;
1837 }
1838
1839 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1840 {
1841 int retval;
1842 target_t *target = get_current_target(cmd_ctx);
1843
1844 LOG_DEBUG("-");
1845
1846 if ((retval = target_halt(target)) != ERROR_OK)
1847 {
1848 return retval;
1849 }
1850
1851 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1852 }
1853
1854
1855 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1856 {
1857 target_t *target = get_current_target(cmd_ctx);
1858
1859 LOG_USER("requesting target halt and executing a soft reset");
1860
1861 target->type->soft_reset_halt(target);
1862
1863 return ERROR_OK;
1864 }
1865
1866 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1867 {
1868 target_t *target = get_current_target(cmd_ctx);
1869 enum target_reset_mode reset_mode = target->reset_mode;
1870 enum target_reset_mode save = target->reset_mode;
1871
1872 LOG_DEBUG("-");
1873
1874 if (argc >= 1)
1875 {
1876 if (strcmp("run", args[0]) == 0)
1877 reset_mode = RESET_RUN;
1878 else if (strcmp("halt", args[0]) == 0)
1879 reset_mode = RESET_HALT;
1880 else if (strcmp("init", args[0]) == 0)
1881 reset_mode = RESET_INIT;
1882 else if (strcmp("run_and_halt", args[0]) == 0)
1883 {
1884 reset_mode = RESET_RUN_AND_HALT;
1885 if (argc >= 2)
1886 {
1887 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1888 }
1889 }
1890 else if (strcmp("run_and_init", args[0]) == 0)
1891 {
1892 reset_mode = RESET_RUN_AND_INIT;
1893 if (argc >= 2)
1894 {
1895 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1896 }
1897 }
1898 else
1899 {
1900 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1901 return ERROR_OK;
1902 }
1903 }
1904
1905 /* temporarily modify mode of current reset target */
1906 target->reset_mode = reset_mode;
1907
1908 /* reset *all* targets */
1909 target_process_reset(cmd_ctx);
1910
1911 /* Restore default reset mode for this target */
1912 target->reset_mode = save;
1913
1914 return ERROR_OK;
1915 }
1916
1917 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1918 {
1919 int retval;
1920 target_t *target = get_current_target(cmd_ctx);
1921
1922 if (argc == 0)
1923 retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1924 else if (argc == 1)
1925 retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1926 else
1927 {
1928 return ERROR_COMMAND_SYNTAX_ERROR;
1929 }
1930
1931 target_process_events(cmd_ctx);
1932
1933 return retval;
1934 }
1935
1936 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1937 {
1938 target_t *target = get_current_target(cmd_ctx);
1939
1940 LOG_DEBUG("-");
1941
1942 if (argc == 0)
1943 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1944
1945 if (argc == 1)
1946 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1947
1948 return ERROR_OK;
1949 }
1950
1951 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1952 {
1953 const int line_bytecnt = 32;
1954 int count = 1;
1955 int size = 4;
1956 u32 address = 0;
1957 int line_modulo;
1958 int i;
1959
1960 char output[128];
1961 int output_len;
1962
1963 int retval;
1964
1965 u8 *buffer;
1966 target_t *target = get_current_target(cmd_ctx);
1967
1968 if (argc < 1)
1969 return ERROR_OK;
1970
1971 if (argc == 2)
1972 count = strtoul(args[1], NULL, 0);
1973
1974 address = strtoul(args[0], NULL, 0);
1975
1976
1977 switch (cmd[2])
1978 {
1979 case 'w':
1980 size = 4; line_modulo = line_bytecnt / 4;
1981 break;
1982 case 'h':
1983 size = 2; line_modulo = line_bytecnt / 2;
1984 break;
1985 case 'b':
1986 size = 1; line_modulo = line_bytecnt / 1;
1987 break;
1988 default:
1989 return ERROR_OK;
1990 }
1991
1992 buffer = calloc(count, size);
1993 retval = target->type->read_memory(target, address, size, count, buffer);
1994 if (retval == ERROR_OK)
1995 {
1996 output_len = 0;
1997
1998 for (i = 0; i < count; i++)
1999 {
2000 if (i%line_modulo == 0)
2001 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
2002
2003 switch (size)
2004 {
2005 case 4:
2006 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
2007 break;
2008 case 2:
2009 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
2010 break;
2011 case 1:
2012 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
2013 break;
2014 }
2015
2016 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
2017 {
2018 command_print(cmd_ctx, output);
2019 output_len = 0;
2020 }
2021 }
2022 } else
2023 {
2024 LOG_ERROR("Failure examining memory");
2025 }
2026
2027 free(buffer);
2028
2029 return ERROR_OK;
2030 }
2031
2032 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2033 {
2034 u32 address = 0;
2035 u32 value = 0;
2036 int count = 1;
2037 int i;
2038 int wordsize;
2039 target_t *target = get_current_target(cmd_ctx);
2040 u8 value_buf[4];
2041
2042 if ((argc < 2) || (argc > 3))
2043 return ERROR_COMMAND_SYNTAX_ERROR;
2044
2045 address = strtoul(args[0], NULL, 0);
2046 value = strtoul(args[1], NULL, 0);
2047 if (argc == 3)
2048 count = strtoul(args[2], NULL, 0);
2049
2050
2051 switch (cmd[2])
2052 {
2053 case 'w':
2054 wordsize = 4;
2055 target_buffer_set_u32(target, value_buf, value);
2056 break;
2057 case 'h':
2058 wordsize = 2;
2059 target_buffer_set_u16(target, value_buf, value);
2060 break;
2061 case 'b':
2062 wordsize = 1;
2063 value_buf[0] = value;
2064 break;
2065 default:
2066 return ERROR_COMMAND_SYNTAX_ERROR;
2067 }
2068 for (i=0; i<count; i++)
2069 {
2070 int retval;
2071 switch (wordsize)
2072 {
2073 case 4:
2074 retval = target->type->write_memory(target, address + i*wordsize, 4, 1, value_buf);
2075 break;
2076 case 2:
2077 retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf);
2078 break;
2079 case 1:
2080 retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf);
2081 break;
2082 default:
2083 return ERROR_OK;
2084 }
2085 if (retval!=ERROR_OK)
2086 {
2087 return retval;
2088 }
2089 }
2090
2091 return ERROR_OK;
2092
2093 }
2094
2095 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2096 {
2097 u8 *buffer;
2098 u32 buf_cnt;
2099 u32 image_size;
2100 int i;
2101 int retval;
2102
2103 image_t image;
2104
2105 duration_t duration;
2106 char *duration_text;
2107
2108 target_t *target = get_current_target(cmd_ctx);
2109
2110 if (argc < 1)
2111 {
2112 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
2113 return ERROR_OK;
2114 }
2115
2116 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
2117 if (argc >= 2)
2118 {
2119 image.base_address_set = 1;
2120 image.base_address = strtoul(args[1], NULL, 0);
2121 }
2122 else
2123 {
2124 image.base_address_set = 0;
2125 }
2126
2127 image.start_address_set = 0;
2128
2129 duration_start_measure(&duration);
2130
2131 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
2132 {
2133 return ERROR_OK;
2134 }
2135
2136 image_size = 0x0;
2137 retval = ERROR_OK;
2138 for (i = 0; i < image.num_sections; i++)
2139 {
2140 buffer = malloc(image.sections[i].size);
2141 if (buffer == NULL)
2142 {
2143 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2144 break;
2145 }
2146
2147 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2148 {
2149 free(buffer);
2150 break;
2151 }
2152 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
2153 {
2154 free(buffer);
2155 break;
2156 }
2157 image_size += buf_cnt;
2158 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
2159
2160 free(buffer);
2161 }
2162
2163 duration_stop_measure(&duration, &duration_text);
2164 if (retval==ERROR_OK)
2165 {
2166 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
2167 }
2168 free(duration_text);
2169
2170 image_close(&image);
2171
2172 return retval;
2173
2174 }
2175
2176 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2177 {
2178 fileio_t fileio;
2179
2180 u32 address;
2181 u32 size;
2182 u8 buffer[560];
2183 int retval=ERROR_OK;
2184
2185 duration_t duration;
2186 char *duration_text;
2187
2188 target_t *target = get_current_target(cmd_ctx);
2189
2190 if (argc != 3)
2191 {
2192 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
2193 return ERROR_OK;
2194 }
2195
2196 address = strtoul(args[1], NULL, 0);
2197 size = strtoul(args[2], NULL, 0);
2198
2199 if ((address & 3) || (size & 3))
2200 {
2201 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
2202 return ERROR_OK;
2203 }
2204
2205 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
2206 {
2207 return ERROR_OK;
2208 }
2209
2210 duration_start_measure(&duration);
2211
2212 while (size > 0)
2213 {
2214 u32 size_written;
2215 u32 this_run_size = (size > 560) ? 560 : size;
2216
2217 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
2218 if (retval != ERROR_OK)
2219 {
2220 break;
2221 }
2222
2223 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
2224 if (retval != ERROR_OK)
2225 {
2226 break;
2227 }
2228
2229 size -= this_run_size;
2230 address += this_run_size;
2231 }
2232
2233 fileio_close(&fileio);
2234
2235 duration_stop_measure(&duration, &duration_text);
2236 if (retval==ERROR_OK)
2237 {
2238 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2239 }
2240 free(duration_text);
2241
2242 return ERROR_OK;
2243 }
2244
2245 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2246 {
2247 u8 *buffer;
2248 u32 buf_cnt;
2249 u32 image_size;
2250 int i;
2251 int retval;
2252 u32 checksum = 0;
2253 u32 mem_checksum = 0;
2254
2255 image_t image;
2256
2257 duration_t duration;
2258 char *duration_text;
2259
2260 target_t *target = get_current_target(cmd_ctx);
2261
2262 if (argc < 1)
2263 {
2264 return ERROR_COMMAND_SYNTAX_ERROR;
2265 }
2266
2267 if (!target)
2268 {
2269 LOG_ERROR("no target selected");
2270 return ERROR_FAIL;
2271 }
2272
2273 duration_start_measure(&duration);
2274
2275 if (argc >= 2)
2276 {
2277 image.base_address_set = 1;
2278 image.base_address = strtoul(args[1], NULL, 0);
2279 }
2280 else
2281 {
2282 image.base_address_set = 0;
2283 image.base_address = 0x0;
2284 }
2285
2286 image.start_address_set = 0;
2287
2288 if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
2289 {
2290 return retval;
2291 }
2292
2293 image_size = 0x0;
2294 retval=ERROR_OK;
2295 for (i = 0; i < image.num_sections; i++)
2296 {
2297 buffer = malloc(image.sections[i].size);
2298 if (buffer == NULL)
2299 {
2300 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2301 break;
2302 }
2303 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2304 {
2305 free(buffer);
2306 break;
2307 }
2308
2309 /* calculate checksum of image */
2310 image_calculate_checksum( buffer, buf_cnt, &checksum );
2311
2312 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2313 if( retval != ERROR_OK )
2314 {
2315 free(buffer);
2316 break;
2317 }
2318
2319 if( checksum != mem_checksum )
2320 {
2321 /* failed crc checksum, fall back to a binary compare */
2322 u8 *data;
2323
2324 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2325
2326 data = (u8*)malloc(buf_cnt);
2327
2328 /* Can we use 32bit word accesses? */
2329 int size = 1;
2330 int count = buf_cnt;
2331 if ((count % 4) == 0)
2332 {
2333 size *= 4;
2334 count /= 4;
2335 }
2336 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2337 if (retval == ERROR_OK)
2338 {
2339 int t;
2340 for (t = 0; t < buf_cnt; t++)
2341 {
2342 if (data[t] != buffer[t])
2343 {
2344 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]);
2345 free(data);
2346 free(buffer);
2347 retval=ERROR_FAIL;
2348 goto done;
2349 }
2350 }
2351 }
2352
2353 free(data);
2354 }
2355
2356 free(buffer);
2357 image_size += buf_cnt;
2358 }
2359 done:
2360 duration_stop_measure(&duration, &duration_text);
2361 if (retval==ERROR_OK)
2362 {
2363 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2364 }
2365 free(duration_text);
2366
2367 image_close(&image);
2368
2369 return retval;
2370 }
2371
2372 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2373 {
2374 int retval;
2375 target_t *target = get_current_target(cmd_ctx);
2376
2377 if (argc == 0)
2378 {
2379 breakpoint_t *breakpoint = target->breakpoints;
2380
2381 while (breakpoint)
2382 {
2383 if (breakpoint->type == BKPT_SOFT)
2384 {
2385 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2386 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2387 free(buf);
2388 }
2389 else
2390 {
2391 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2392 }
2393 breakpoint = breakpoint->next;
2394 }
2395 }
2396 else if (argc >= 2)
2397 {
2398 int hw = BKPT_SOFT;
2399 u32 length = 0;
2400
2401 length = strtoul(args[1], NULL, 0);
2402
2403 if (argc >= 3)
2404 if (strcmp(args[2], "hw") == 0)
2405 hw = BKPT_HARD;
2406
2407 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2408 {
2409 LOG_ERROR("Failure setting breakpoints");
2410 }
2411 else
2412 {
2413 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2414 }
2415 }
2416 else
2417 {
2418 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2419 }
2420
2421 return ERROR_OK;
2422 }
2423
2424 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2425 {
2426 target_t *target = get_current_target(cmd_ctx);
2427
2428 if (argc > 0)
2429 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2430
2431 return ERROR_OK;
2432 }
2433
2434 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2435 {
2436 target_t *target = get_current_target(cmd_ctx);
2437 int retval;
2438
2439 if (argc == 0)
2440 {
2441 watchpoint_t *watchpoint = target->watchpoints;
2442
2443 while (watchpoint)
2444 {
2445 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);
2446 watchpoint = watchpoint->next;
2447 }
2448 }
2449 else if (argc >= 2)
2450 {
2451 enum watchpoint_rw type = WPT_ACCESS;
2452 u32 data_value = 0x0;
2453 u32 data_mask = 0xffffffff;
2454
2455 if (argc >= 3)
2456 {
2457 switch(args[2][0])
2458 {
2459 case 'r':
2460 type = WPT_READ;
2461 break;
2462 case 'w':
2463 type = WPT_WRITE;
2464 break;
2465 case 'a':
2466 type = WPT_ACCESS;
2467 break;
2468 default:
2469 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2470 return ERROR_OK;
2471 }
2472 }
2473 if (argc >= 4)
2474 {
2475 data_value = strtoul(args[3], NULL, 0);
2476 }
2477 if (argc >= 5)
2478 {
2479 data_mask = strtoul(args[4], NULL, 0);
2480 }
2481
2482 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2483 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2484 {
2485 LOG_ERROR("Failure setting breakpoints");
2486 }
2487 }
2488 else
2489 {
2490 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2491 }
2492
2493 return ERROR_OK;
2494 }
2495
2496 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2497 {
2498 target_t *target = get_current_target(cmd_ctx);
2499
2500 if (argc > 0)
2501 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2502
2503 return ERROR_OK;
2504 }
2505
2506 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2507 {
2508 int retval;
2509 target_t *target = get_current_target(cmd_ctx);
2510 u32 va;
2511 u32 pa;
2512
2513 if (argc != 1)
2514 {
2515 return ERROR_COMMAND_SYNTAX_ERROR;
2516 }
2517 va = strtoul(args[0], NULL, 0);
2518
2519 retval = target->type->virt2phys(target, va, &pa);
2520 if (retval == ERROR_OK)
2521 {
2522 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2523 }
2524 else
2525 {
2526 /* lower levels will have logged a detailed error which is
2527 * forwarded to telnet/GDB session.
2528 */
2529 }
2530 return retval;
2531 }
2532 static void writeLong(FILE *f, int l)
2533 {
2534 int i;
2535 for (i=0; i<4; i++)
2536 {
2537 char c=(l>>(i*8))&0xff;
2538 fwrite(&c, 1, 1, f);
2539 }
2540
2541 }
2542 static void writeString(FILE *f, char *s)
2543 {
2544 fwrite(s, 1, strlen(s), f);
2545 }
2546
2547
2548
2549 // Dump a gmon.out histogram file.
2550 static void writeGmon(u32 *samples, int sampleNum, char *filename)
2551 {
2552 int i;
2553 FILE *f=fopen(filename, "w");
2554 if (f==NULL)
2555 return;
2556 fwrite("gmon", 1, 4, f);
2557 writeLong(f, 0x00000001); // Version
2558 writeLong(f, 0); // padding
2559 writeLong(f, 0); // padding
2560 writeLong(f, 0); // padding
2561
2562 fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST
2563
2564 // figure out bucket size
2565 u32 min=samples[0];
2566 u32 max=samples[0];
2567 for (i=0; i<sampleNum; i++)
2568 {
2569 if (min>samples[i])
2570 {
2571 min=samples[i];
2572 }
2573 if (max<samples[i])
2574 {
2575 max=samples[i];
2576 }
2577 }
2578
2579 int addressSpace=(max-min+1);
2580
2581 static int const maxBuckets=256*1024; // maximum buckets.
2582 int length=addressSpace;
2583 if (length > maxBuckets)
2584 {
2585 length=maxBuckets;
2586 }
2587 int *buckets=malloc(sizeof(int)*length);
2588 if (buckets==NULL)
2589 {
2590 fclose(f);
2591 return;
2592 }
2593 memset(buckets, 0, sizeof(int)*length);
2594 for (i=0; i<sampleNum;i++)
2595 {
2596 u32 address=samples[i];
2597 long long a=address-min;
2598 long long b=length-1;
2599 long long c=addressSpace-1;
2600 int index=(a*b)/c; // danger!!!! int32 overflows
2601 buckets[index]++;
2602 }
2603
2604 // append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
2605 writeLong(f, min); // low_pc
2606 writeLong(f, max); // high_pc
2607 writeLong(f, length); // # of samples
2608 writeLong(f, 64000000); // 64MHz
2609 writeString(f, "seconds");
2610 for (i=0; i<(15-strlen("seconds")); i++)
2611 {
2612 fwrite("", 1, 1, f); // padding
2613 }
2614 writeString(f, "s");
2615
2616 // append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
2617
2618 char *data=malloc(2*length);
2619 if (data!=NULL)
2620 {
2621 for (i=0; i<length;i++)
2622 {
2623 int val;
2624 val=buckets[i];
2625 if (val>65535)
2626 {
2627 val=65535;
2628 }
2629 data[i*2]=val&0xff;
2630 data[i*2+1]=(val>>8)&0xff;
2631 }
2632 free(buckets);
2633 fwrite(data, 1, length*2, f);
2634 free(data);
2635 } else
2636 {
2637 free(buckets);
2638 }
2639
2640 fclose(f);
2641 }
2642
2643 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
2644 int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2645 {
2646 target_t *target = get_current_target(cmd_ctx);
2647 struct timeval timeout, now;
2648
2649 gettimeofday(&timeout, NULL);
2650 if (argc!=2)
2651 {
2652 return ERROR_COMMAND_SYNTAX_ERROR;
2653 }
2654 char *end;
2655 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
2656 if (*end)
2657 {
2658 return ERROR_OK;
2659 }
2660
2661 command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
2662
2663 static const int maxSample=10000;
2664 u32 *samples=malloc(sizeof(u32)*maxSample);
2665 if (samples==NULL)
2666 return ERROR_OK;
2667
2668 int numSamples=0;
2669 int retval=ERROR_OK;
2670 // hopefully it is safe to cache! We want to stop/restart as quickly as possible.
2671 reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1);
2672
2673 for (;;)
2674 {
2675 target_poll(target);
2676 if (target->state == TARGET_HALTED)
2677 {
2678 u32 t=*((u32 *)reg->value);
2679 samples[numSamples++]=t;
2680 retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2681 target_poll(target);
2682 usleep(10*1000); // sleep 10ms, i.e. <100 samples/second.
2683 } else if (target->state == TARGET_RUNNING)
2684 {
2685 // We want to quickly sample the PC.
2686 target_halt(target);
2687 } else
2688 {
2689 command_print(cmd_ctx, "Target not halted or running");
2690 retval=ERROR_OK;
2691 break;
2692 }
2693 if (retval!=ERROR_OK)
2694 {
2695 break;
2696 }
2697
2698 gettimeofday(&now, NULL);
2699 if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
2700 {
2701 command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
2702 target_poll(target);
2703 if (target->state == TARGET_HALTED)
2704 {
2705 target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
2706 }
2707 target_poll(target);
2708 writeGmon(samples, numSamples, args[1]);
2709 command_print(cmd_ctx, "Wrote %s", args[1]);
2710 break;
2711 }
2712 }
2713 free(samples);
2714
2715 return ERROR_OK;
2716 }
2717
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)