Code Review / openocd.git / blob
? search:


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