Code Review / openocd.git / blob
? search:


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