Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
The bitbang driver leaves the TCK 0 when in idle
[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, "<target> <run time ms>");
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 return ERROR_COMMAND_SYNTAX_ERROR;
1114 }
1115
1116 /* search for the specified target */
1117 if (args[0] && (args[0][0] != 0))
1118 {
1119 for (i = 0; target_types[i]; i++)
1120 {
1121 if (strcmp(args[0], target_types[i]->name) == 0)
1122 {
1123 target_t **last_target_p = &targets;
1124
1125 /* register target specific commands */
1126 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1127 {
1128 ERROR("couldn't register '%s' commands", args[0]);
1129 exit(-1);
1130 }
1131
1132 if (*last_target_p)
1133 {
1134 while ((*last_target_p)->next)
1135 last_target_p = &((*last_target_p)->next);
1136 last_target_p = &((*last_target_p)->next);
1137 }
1138
1139 *last_target_p = malloc(sizeof(target_t));
1140
1141 (*last_target_p)->type = target_types[i];
1142
1143 if (strcmp(args[1], "big") == 0)
1144 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1145 else if (strcmp(args[1], "little") == 0)
1146 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1147 else
1148 {
1149 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1150 return ERROR_COMMAND_SYNTAX_ERROR;
1151 }
1152
1153 /* what to do on a target reset */
1154 if (strcmp(args[2], "reset_halt") == 0)
1155 (*last_target_p)->reset_mode = RESET_HALT;
1156 else if (strcmp(args[2], "reset_run") == 0)
1157 (*last_target_p)->reset_mode = RESET_RUN;
1158 else if (strcmp(args[2], "reset_init") == 0)
1159 (*last_target_p)->reset_mode = RESET_INIT;
1160 else if (strcmp(args[2], "run_and_halt") == 0)
1161 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1162 else if (strcmp(args[2], "run_and_init") == 0)
1163 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1164 else
1165 {
1166 ERROR("unknown target startup mode %s", args[2]);
1167 return ERROR_COMMAND_SYNTAX_ERROR;
1168 }
1169 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1170
1171 (*last_target_p)->reset_script = NULL;
1172 (*last_target_p)->post_halt_script = NULL;
1173 (*last_target_p)->pre_resume_script = NULL;
1174 (*last_target_p)->gdb_program_script = NULL;
1175
1176 (*last_target_p)->working_area = 0x0;
1177 (*last_target_p)->working_area_size = 0x0;
1178 (*last_target_p)->working_areas = NULL;
1179 (*last_target_p)->backup_working_area = 0;
1180
1181 (*last_target_p)->state = TARGET_UNKNOWN;
1182 (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
1183 (*last_target_p)->reg_cache = NULL;
1184 (*last_target_p)->breakpoints = NULL;
1185 (*last_target_p)->watchpoints = NULL;
1186 (*last_target_p)->next = NULL;
1187 (*last_target_p)->arch_info = NULL;
1188
1189 /* initialize trace information */
1190 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1191 (*last_target_p)->trace_info->num_trace_points = 0;
1192 (*last_target_p)->trace_info->trace_points_size = 0;
1193 (*last_target_p)->trace_info->trace_points = NULL;
1194 (*last_target_p)->trace_info->trace_history_size = 0;
1195 (*last_target_p)->trace_info->trace_history = NULL;
1196 (*last_target_p)->trace_info->trace_history_pos = 0;
1197 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1198
1199 (*last_target_p)->dbgmsg = NULL;
1200 (*last_target_p)->dbg_msg_enabled = 0;
1201
1202 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1203
1204 found = 1;
1205 break;
1206 }
1207 }
1208 }
1209
1210 /* no matching target found */
1211 if (!found)
1212 {
1213 ERROR("target '%s' not found", args[0]);
1214 return ERROR_COMMAND_SYNTAX_ERROR;
1215 }
1216
1217 return ERROR_OK;
1218 }
1219
1220 /* usage: target_script <target#> <event> <script_file> */
1221 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1222 {
1223 target_t *target = NULL;
1224
1225 if (argc < 3)
1226 {
1227 ERROR("incomplete target_script command");
1228 return ERROR_COMMAND_SYNTAX_ERROR;
1229 }
1230
1231 target = get_target_by_num(strtoul(args[0], NULL, 0));
1232
1233 if (!target)
1234 {
1235 return ERROR_COMMAND_SYNTAX_ERROR;
1236 }
1237
1238 if (strcmp(args[1], "reset") == 0)
1239 {
1240 if (target->reset_script)
1241 free(target->reset_script);
1242 target->reset_script = strdup(args[2]);
1243 }
1244 else if (strcmp(args[1], "post_halt") == 0)
1245 {
1246 if (target->post_halt_script)
1247 free(target->post_halt_script);
1248 target->post_halt_script = strdup(args[2]);
1249 }
1250 else if (strcmp(args[1], "pre_resume") == 0)
1251 {
1252 if (target->pre_resume_script)
1253 free(target->pre_resume_script);
1254 target->pre_resume_script = strdup(args[2]);
1255 }
1256 else if (strcmp(args[1], "gdb_program_config") == 0)
1257 {
1258 if (target->gdb_program_script)
1259 free(target->gdb_program_script);
1260 target->gdb_program_script = strdup(args[2]);
1261 }
1262 else
1263 {
1264 ERROR("unknown event type: '%s", args[1]);
1265 return ERROR_COMMAND_SYNTAX_ERROR;
1266 }
1267
1268 return ERROR_OK;
1269 }
1270
1271 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1272 {
1273 target_t *target = NULL;
1274
1275 if (argc < 2)
1276 {
1277 return ERROR_COMMAND_SYNTAX_ERROR;
1278 }
1279
1280 target = get_target_by_num(strtoul(args[0], NULL, 0));
1281
1282 if (!target)
1283 {
1284 return ERROR_COMMAND_SYNTAX_ERROR;
1285 }
1286
1287 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1288
1289 return ERROR_OK;
1290 }
1291
1292 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1293 {
1294 target_t *target = NULL;
1295
1296 if ((argc < 4) || (argc > 5))
1297 {
1298 return ERROR_COMMAND_SYNTAX_ERROR;
1299 }
1300
1301 target = get_target_by_num(strtoul(args[0], NULL, 0));
1302
1303 if (!target)
1304 {
1305 return ERROR_COMMAND_SYNTAX_ERROR;
1306 }
1307 target_free_all_working_areas(target);
1308
1309 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1310 if (argc == 5)
1311 {
1312 target->working_area_virt = strtoul(args[4], NULL, 0);
1313 }
1314 target->working_area_size = strtoul(args[2], NULL, 0);
1315
1316 if (strcmp(args[3], "backup") == 0)
1317 {
1318 target->backup_working_area = 1;
1319 }
1320 else if (strcmp(args[3], "nobackup") == 0)
1321 {
1322 target->backup_working_area = 0;
1323 }
1324 else
1325 {
1326 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1327 return ERROR_COMMAND_SYNTAX_ERROR;
1328 }
1329
1330 return ERROR_OK;
1331 }
1332
1333
1334 /* process target state changes */
1335 int handle_target(void *priv)
1336 {
1337 int retval;
1338 target_t *target = targets;
1339
1340 while (target)
1341 {
1342 /* only poll if target isn't already halted */
1343 if (target->state != TARGET_HALTED)
1344 {
1345 if (target_continous_poll)
1346 if ((retval = target->type->poll(target)) != ERROR_OK)
1347 {
1348 ERROR("couldn't poll target(%d). It's due for a reset.", retval);
1349 }
1350 }
1351
1352 target = target->next;
1353 }
1354
1355 return ERROR_OK;
1356 }
1357
1358 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1359 {
1360 target_t *target;
1361 reg_t *reg = NULL;
1362 int count = 0;
1363 char *value;
1364
1365 DEBUG("-");
1366
1367 target = get_current_target(cmd_ctx);
1368
1369 /* list all available registers for the current target */
1370 if (argc == 0)
1371 {
1372 reg_cache_t *cache = target->reg_cache;
1373
1374 count = 0;
1375 while(cache)
1376 {
1377 int i;
1378 for (i = 0; i < cache->num_regs; i++)
1379 {
1380 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1381 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);
1382 free(value);
1383 }
1384 cache = cache->next;
1385 }
1386
1387 return ERROR_OK;
1388 }
1389
1390 /* access a single register by its ordinal number */
1391 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1392 {
1393 int num = strtoul(args[0], NULL, 0);
1394 reg_cache_t *cache = target->reg_cache;
1395
1396 count = 0;
1397 while(cache)
1398 {
1399 int i;
1400 for (i = 0; i < cache->num_regs; i++)
1401 {
1402 if (count++ == num)
1403 {
1404 reg = &cache->reg_list[i];
1405 break;
1406 }
1407 }
1408 if (reg)
1409 break;
1410 cache = cache->next;
1411 }
1412
1413 if (!reg)
1414 {
1415 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1416 return ERROR_OK;
1417 }
1418 } else /* access a single register by its name */
1419 {
1420 reg = register_get_by_name(target->reg_cache, args[0], 1);
1421
1422 if (!reg)
1423 {
1424 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1425 return ERROR_OK;
1426 }
1427 }
1428
1429 /* display a register */
1430 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1431 {
1432 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1433 reg->valid = 0;
1434
1435 if (reg->valid == 0)
1436 {
1437 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1438 if (arch_type == NULL)
1439 {
1440 ERROR("BUG: encountered unregistered arch type");
1441 return ERROR_OK;
1442 }
1443 arch_type->get(reg);
1444 }
1445 value = buf_to_str(reg->value, reg->size, 16);
1446 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1447 free(value);
1448 return ERROR_OK;
1449 }
1450
1451 /* set register value */
1452 if (argc == 2)
1453 {
1454 u8 *buf = malloc(CEIL(reg->size, 8));
1455 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1456
1457 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1458 if (arch_type == NULL)
1459 {
1460 ERROR("BUG: encountered unregistered arch type");
1461 return ERROR_OK;
1462 }
1463
1464 arch_type->set(reg, buf);
1465
1466 value = buf_to_str(reg->value, reg->size, 16);
1467 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1468 free(value);
1469
1470 free(buf);
1471
1472 return ERROR_OK;
1473 }
1474
1475 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1476
1477 return ERROR_OK;
1478 }
1479
1480 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1481
1482 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1483 {
1484 target_t *target = get_current_target(cmd_ctx);
1485
1486 if (argc == 0)
1487 {
1488 target->type->poll(target);
1489 target_arch_state(target);
1490 }
1491 else
1492 {
1493 if (strcmp(args[0], "on") == 0)
1494 {
1495 target_continous_poll = 1;
1496 }
1497 else if (strcmp(args[0], "off") == 0)
1498 {
1499 target_continous_poll = 0;
1500 }
1501 else
1502 {
1503 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1504 }
1505 }
1506
1507
1508 return ERROR_OK;
1509 }
1510
1511 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1512 {
1513 int ms = 5000;
1514
1515 if (argc > 0)
1516 {
1517 char *end;
1518
1519 ms = strtoul(args[0], &end, 0) * 1000;
1520 if (*end)
1521 {
1522 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1523 return ERROR_OK;
1524 }
1525 }
1526
1527 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1528 }
1529
1530 static void target_process_events(struct command_context_s *cmd_ctx)
1531 {
1532 target_t *target = get_current_target(cmd_ctx);
1533 target->type->poll(target);
1534 target_call_timer_callbacks();
1535 }
1536
1537 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1538 {
1539 int retval;
1540 struct timeval timeout, now;
1541 int once=1;
1542 gettimeofday(&timeout, NULL);
1543 timeval_add_time(&timeout, 0, ms * 1000);
1544
1545 target_t *target = get_current_target(cmd_ctx);
1546 for (;;)
1547 {
1548 if ((retval=target->type->poll(target))!=ERROR_OK)
1549 return retval;
1550 target_call_timer_callbacks();
1551 if (target->state == state)
1552 {
1553 break;
1554 }
1555 if (once)
1556 {
1557 once=0;
1558 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1559 }
1560
1561 gettimeofday(&now, NULL);
1562 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1563 {
1564 ERROR("timed out while waiting for target %s", target_state_strings[state]);
1565 break;
1566 }
1567 }
1568
1569 return ERROR_OK;
1570 }
1571
1572 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1573 {
1574 int retval;
1575 target_t *target = get_current_target(cmd_ctx);
1576
1577 DEBUG("-");
1578
1579 if ((retval = target->type->halt(target)) != ERROR_OK)
1580 {
1581 return retval;
1582 }
1583
1584 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1585 }
1586
1587 /* what to do on daemon startup */
1588 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1589 {
1590 if (argc == 1)
1591 {
1592 if (strcmp(args[0], "attach") == 0)
1593 {
1594 startup_mode = DAEMON_ATTACH;
1595 return ERROR_OK;
1596 }
1597 else if (strcmp(args[0], "reset") == 0)
1598 {
1599 startup_mode = DAEMON_RESET;
1600 return ERROR_OK;
1601 }
1602 }
1603
1604 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1605 return ERROR_OK;
1606
1607 }
1608
1609 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1610 {
1611 target_t *target = get_current_target(cmd_ctx);
1612
1613 USER("requesting target halt and executing a soft reset");
1614
1615 target->type->soft_reset_halt(target);
1616
1617 return ERROR_OK;
1618 }
1619
1620 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1621 {
1622 target_t *target = get_current_target(cmd_ctx);
1623 enum target_reset_mode reset_mode = target->reset_mode;
1624 enum target_reset_mode save = target->reset_mode;
1625
1626 DEBUG("-");
1627
1628 if (argc >= 1)
1629 {
1630 if (strcmp("run", args[0]) == 0)
1631 reset_mode = RESET_RUN;
1632 else if (strcmp("halt", args[0]) == 0)
1633 reset_mode = RESET_HALT;
1634 else if (strcmp("init", args[0]) == 0)
1635 reset_mode = RESET_INIT;
1636 else if (strcmp("run_and_halt", args[0]) == 0)
1637 {
1638 reset_mode = RESET_RUN_AND_HALT;
1639 if (argc >= 2)
1640 {
1641 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1642 }
1643 }
1644 else if (strcmp("run_and_init", args[0]) == 0)
1645 {
1646 reset_mode = RESET_RUN_AND_INIT;
1647 if (argc >= 2)
1648 {
1649 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1650 }
1651 }
1652 else
1653 {
1654 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1655 return ERROR_OK;
1656 }
1657 }
1658
1659 /* temporarily modify mode of current reset target */
1660 target->reset_mode = reset_mode;
1661
1662 /* reset *all* targets */
1663 target_process_reset(cmd_ctx);
1664
1665 /* Restore default reset mode for this target */
1666 target->reset_mode = save;
1667
1668 return ERROR_OK;
1669 }
1670
1671 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1672 {
1673 int retval;
1674 target_t *target = get_current_target(cmd_ctx);
1675
1676 if (argc == 0)
1677 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1678 else if (argc == 1)
1679 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1680 else
1681 {
1682 return ERROR_COMMAND_SYNTAX_ERROR;
1683 }
1684
1685 target_process_events(cmd_ctx);
1686
1687 return retval;
1688 }
1689
1690 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1691 {
1692 target_t *target = get_current_target(cmd_ctx);
1693
1694 DEBUG("-");
1695
1696 if (argc == 0)
1697 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1698
1699 if (argc == 1)
1700 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1701
1702 return ERROR_OK;
1703 }
1704
1705 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1706 {
1707 const int line_bytecnt = 32;
1708 int count = 1;
1709 int size = 4;
1710 u32 address = 0;
1711 int line_modulo;
1712 int i;
1713
1714 char output[128];
1715 int output_len;
1716
1717 int retval;
1718
1719 u8 *buffer;
1720 target_t *target = get_current_target(cmd_ctx);
1721
1722 if (argc < 1)
1723 return ERROR_OK;
1724
1725 if (argc == 2)
1726 count = strtoul(args[1], NULL, 0);
1727
1728 address = strtoul(args[0], NULL, 0);
1729
1730
1731 switch (cmd[2])
1732 {
1733 case 'w':
1734 size = 4; line_modulo = line_bytecnt / 4;
1735 break;
1736 case 'h':
1737 size = 2; line_modulo = line_bytecnt / 2;
1738 break;
1739 case 'b':
1740 size = 1; line_modulo = line_bytecnt / 1;
1741 break;
1742 default:
1743 return ERROR_OK;
1744 }
1745
1746 buffer = calloc(count, size);
1747 retval = target->type->read_memory(target, address, size, count, buffer);
1748 if (retval != ERROR_OK)
1749 {
1750 switch (retval)
1751 {
1752 case ERROR_TARGET_UNALIGNED_ACCESS:
1753 command_print(cmd_ctx, "error: address not aligned");
1754 break;
1755 case ERROR_TARGET_NOT_HALTED:
1756 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1757 break;
1758 case ERROR_TARGET_DATA_ABORT:
1759 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1760 break;
1761 default:
1762 command_print(cmd_ctx, "error: unknown error");
1763 break;
1764 }
1765 return ERROR_OK;
1766 }
1767
1768 output_len = 0;
1769
1770 for (i = 0; i < count; i++)
1771 {
1772 if (i%line_modulo == 0)
1773 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1774
1775 switch (size)
1776 {
1777 case 4:
1778 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1779 break;
1780 case 2:
1781 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1782 break;
1783 case 1:
1784 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1785 break;
1786 }
1787
1788 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1789 {
1790 command_print(cmd_ctx, output);
1791 output_len = 0;
1792 }
1793 }
1794
1795 free(buffer);
1796
1797 return ERROR_OK;
1798 }
1799
1800 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1801 {
1802 u32 address = 0;
1803 u32 value = 0;
1804 int retval;
1805 target_t *target = get_current_target(cmd_ctx);
1806 u8 value_buf[4];
1807
1808 if (argc < 2)
1809 return ERROR_OK;
1810
1811 address = strtoul(args[0], NULL, 0);
1812 value = strtoul(args[1], NULL, 0);
1813
1814 switch (cmd[2])
1815 {
1816 case 'w':
1817 target_buffer_set_u32(target, value_buf, value);
1818 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1819 break;
1820 case 'h':
1821 target_buffer_set_u16(target, value_buf, value);
1822 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1823 break;
1824 case 'b':
1825 value_buf[0] = value;
1826 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1827 break;
1828 default:
1829 return ERROR_OK;
1830 }
1831
1832 switch (retval)
1833 {
1834 case ERROR_TARGET_UNALIGNED_ACCESS:
1835 command_print(cmd_ctx, "error: address not aligned");
1836 break;
1837 case ERROR_TARGET_DATA_ABORT:
1838 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1839 break;
1840 case ERROR_TARGET_NOT_HALTED:
1841 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1842 break;
1843 case ERROR_OK:
1844 break;
1845 default:
1846 command_print(cmd_ctx, "error: unknown error");
1847 break;
1848 }
1849
1850 return ERROR_OK;
1851
1852 }
1853
1854 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1855 {
1856 u8 *buffer;
1857 u32 buf_cnt;
1858 u32 image_size;
1859 int i;
1860 int retval;
1861
1862 image_t image;
1863
1864 duration_t duration;
1865 char *duration_text;
1866
1867 target_t *target = get_current_target(cmd_ctx);
1868
1869 if (argc < 1)
1870 {
1871 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1872 return ERROR_OK;
1873 }
1874
1875 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1876 if (argc >= 2)
1877 {
1878 image.base_address_set = 1;
1879 image.base_address = strtoul(args[1], NULL, 0);
1880 }
1881 else
1882 {
1883 image.base_address_set = 0;
1884 }
1885
1886 image.start_address_set = 0;
1887
1888 duration_start_measure(&duration);
1889
1890 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1891 {
1892 return ERROR_OK;
1893 }
1894
1895 image_size = 0x0;
1896 retval = ERROR_OK;
1897 for (i = 0; i < image.num_sections; i++)
1898 {
1899 buffer = malloc(image.sections[i].size);
1900 if (buffer == NULL)
1901 {
1902 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1903 break;
1904 }
1905
1906 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1907 {
1908 free(buffer);
1909 break;
1910 }
1911 if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK)
1912 {
1913 free(buffer);
1914 break;
1915 }
1916 image_size += buf_cnt;
1917 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1918
1919 free(buffer);
1920 }
1921
1922 duration_stop_measure(&duration, &duration_text);
1923 if (retval==ERROR_OK)
1924 {
1925 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1926 }
1927 free(duration_text);
1928
1929 image_close(&image);
1930
1931 return retval;
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=ERROR_OK;
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 break;
1980 }
1981
1982 retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
1983 if (retval != ERROR_OK)
1984 {
1985 break;
1986 }
1987
1988 size -= this_run_size;
1989 address += this_run_size;
1990 }
1991
1992 fileio_close(&fileio);
1993
1994 duration_stop_measure(&duration, &duration_text);
1995 if (retval==ERROR_OK)
1996 {
1997 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1998 }
1999 free(duration_text);
2000
2001 return ERROR_OK;
2002 }
2003
2004 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2005 {
2006 u8 *buffer;
2007 u32 buf_cnt;
2008 u32 image_size;
2009 int i;
2010 int retval;
2011 u32 checksum = 0;
2012 u32 mem_checksum = 0;
2013
2014 image_t image;
2015
2016 duration_t duration;
2017 char *duration_text;
2018
2019 target_t *target = get_current_target(cmd_ctx);
2020
2021 if (argc < 1)
2022 {
2023 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
2024 return ERROR_OK;
2025 }
2026
2027 if (!target)
2028 {
2029 ERROR("no target selected");
2030 return ERROR_OK;
2031 }
2032
2033 duration_start_measure(&duration);
2034
2035 if (argc >= 2)
2036 {
2037 image.base_address_set = 1;
2038 image.base_address = strtoul(args[1], NULL, 0);
2039 }
2040 else
2041 {
2042 image.base_address_set = 0;
2043 image.base_address = 0x0;
2044 }
2045
2046 image.start_address_set = 0;
2047
2048 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
2049 {
2050 return ERROR_OK;
2051 }
2052
2053 image_size = 0x0;
2054 retval=ERROR_OK;
2055 for (i = 0; i < image.num_sections; i++)
2056 {
2057 buffer = malloc(image.sections[i].size);
2058 if (buffer == NULL)
2059 {
2060 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2061 break;
2062 }
2063 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2064 {
2065 free(buffer);
2066 break;
2067 }
2068
2069 /* calculate checksum of image */
2070 image_calculate_checksum( buffer, buf_cnt, &checksum );
2071
2072 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2073
2074 if( retval != ERROR_OK )
2075 {
2076 free(buffer);
2077 break;
2078 }
2079
2080 if( checksum != mem_checksum )
2081 {
2082 /* failed crc checksum, fall back to a binary compare */
2083 u8 *data;
2084
2085 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2086
2087 data = (u8*)malloc(buf_cnt);
2088
2089 /* Can we use 32bit word accesses? */
2090 int size = 1;
2091 int count = buf_cnt;
2092 if ((count % 4) == 0)
2093 {
2094 size *= 4;
2095 count /= 4;
2096 }
2097 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2098
2099 if (retval == ERROR_OK)
2100 {
2101 int t;
2102 for (t = 0; t < buf_cnt; t++)
2103 {
2104 if (data[t] != buffer[t])
2105 {
2106 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]);
2107 free(data);
2108 free(buffer);
2109 retval=ERROR_FAIL;
2110 goto done;
2111 }
2112 }
2113 }
2114
2115 free(data);
2116 }
2117
2118 free(buffer);
2119 image_size += buf_cnt;
2120 }
2121 done:
2122 duration_stop_measure(&duration, &duration_text);
2123 if (retval==ERROR_OK)
2124 {
2125 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2126 }
2127 free(duration_text);
2128
2129 image_close(&image);
2130
2131 return retval;
2132 }
2133
2134 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2135 {
2136 int retval;
2137 target_t *target = get_current_target(cmd_ctx);
2138
2139 if (argc == 0)
2140 {
2141 breakpoint_t *breakpoint = target->breakpoints;
2142
2143 while (breakpoint)
2144 {
2145 if (breakpoint->type == BKPT_SOFT)
2146 {
2147 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2148 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2149 free(buf);
2150 }
2151 else
2152 {
2153 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2154 }
2155 breakpoint = breakpoint->next;
2156 }
2157 }
2158 else if (argc >= 2)
2159 {
2160 int hw = BKPT_SOFT;
2161 u32 length = 0;
2162
2163 length = strtoul(args[1], NULL, 0);
2164
2165 if (argc >= 3)
2166 if (strcmp(args[2], "hw") == 0)
2167 hw = BKPT_HARD;
2168
2169 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2170 {
2171 switch (retval)
2172 {
2173 case ERROR_TARGET_NOT_HALTED:
2174 command_print(cmd_ctx, "target must be halted to set breakpoints");
2175 break;
2176 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2177 command_print(cmd_ctx, "no more breakpoints available");
2178 break;
2179 default:
2180 command_print(cmd_ctx, "unknown error, breakpoint not set");
2181 break;
2182 }
2183 }
2184 else
2185 {
2186 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2187 }
2188 }
2189 else
2190 {
2191 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2192 }
2193
2194 return ERROR_OK;
2195 }
2196
2197 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2198 {
2199 target_t *target = get_current_target(cmd_ctx);
2200
2201 if (argc > 0)
2202 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2203
2204 return ERROR_OK;
2205 }
2206
2207 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2208 {
2209 target_t *target = get_current_target(cmd_ctx);
2210 int retval;
2211
2212 if (argc == 0)
2213 {
2214 watchpoint_t *watchpoint = target->watchpoints;
2215
2216 while (watchpoint)
2217 {
2218 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);
2219 watchpoint = watchpoint->next;
2220 }
2221 }
2222 else if (argc >= 2)
2223 {
2224 enum watchpoint_rw type = WPT_ACCESS;
2225 u32 data_value = 0x0;
2226 u32 data_mask = 0xffffffff;
2227
2228 if (argc >= 3)
2229 {
2230 switch(args[2][0])
2231 {
2232 case 'r':
2233 type = WPT_READ;
2234 break;
2235 case 'w':
2236 type = WPT_WRITE;
2237 break;
2238 case 'a':
2239 type = WPT_ACCESS;
2240 break;
2241 default:
2242 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2243 return ERROR_OK;
2244 }
2245 }
2246 if (argc >= 4)
2247 {
2248 data_value = strtoul(args[3], NULL, 0);
2249 }
2250 if (argc >= 5)
2251 {
2252 data_mask = strtoul(args[4], NULL, 0);
2253 }
2254
2255 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2256 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2257 {
2258 switch (retval)
2259 {
2260 case ERROR_TARGET_NOT_HALTED:
2261 command_print(cmd_ctx, "target must be halted to set watchpoints");
2262 break;
2263 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2264 command_print(cmd_ctx, "no more watchpoints available");
2265 break;
2266 default:
2267 command_print(cmd_ctx, "unknown error, watchpoint not set");
2268 break;
2269 }
2270 }
2271 }
2272 else
2273 {
2274 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2275 }
2276
2277 return ERROR_OK;
2278 }
2279
2280 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2281 {
2282 target_t *target = get_current_target(cmd_ctx);
2283
2284 if (argc > 0)
2285 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2286
2287 return ERROR_OK;
2288 }
2289
2290 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2291 {
2292 int retval;
2293 target_t *target = get_current_target(cmd_ctx);
2294 u32 va;
2295 u32 pa;
2296
2297 if (argc != 1)
2298 {
2299 return ERROR_COMMAND_SYNTAX_ERROR;
2300 }
2301 va = strtoul(args[0], NULL, 0);
2302
2303 retval = target->type->virt2phys(target, va, &pa);
2304 if (retval == ERROR_OK)
2305 {
2306 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2307 }
2308 else
2309 {
2310 /* lower levels will have logged a detailed error which is
2311 * forwarded to telnet/GDB session.
2312 */
2313 }
2314 return retval;
2315 }
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)