Code Review / openocd.git / blob
? search:


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