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