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