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