Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- add support for Marvell Feroceon (thanks to Nicolas Pitre for this patch)
[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 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55
56 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59
60 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
77 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
78
79 /* targets
80 */
81 extern target_type_t arm7tdmi_target;
82 extern target_type_t arm720t_target;
83 extern target_type_t arm9tdmi_target;
84 extern target_type_t arm920t_target;
85 extern target_type_t arm966e_target;
86 extern target_type_t arm926ejs_target;
87 extern target_type_t feroceon_target;
88 extern target_type_t xscale_target;
89 extern target_type_t cortexm3_target;
90
91 target_type_t *target_types[] =
92 {
93 &arm7tdmi_target,
94 &arm9tdmi_target,
95 &arm920t_target,
96 &arm720t_target,
97 &arm966e_target,
98 &arm926ejs_target,
99 &feroceon_target,
100 &xscale_target,
101 &cortexm3_target,
102 NULL,
103 };
104
105 target_t *targets = NULL;
106 target_event_callback_t *target_event_callbacks = NULL;
107 target_timer_callback_t *target_timer_callbacks = NULL;
108
109 char *target_state_strings[] =
110 {
111 "unknown",
112 "running",
113 "halted",
114 "reset",
115 "debug_running",
116 };
117
118 char *target_debug_reason_strings[] =
119 {
120 "debug request", "breakpoint", "watchpoint",
121 "watchpoint and breakpoint", "single step",
122 "target not halted"
123 };
124
125 char *target_endianess_strings[] =
126 {
127 "big endian",
128 "little endian",
129 };
130
131 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
132
133 static int target_continous_poll = 1;
134
135 /* read a u32 from a buffer in target memory endianness */
136 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
137 {
138 if (target->endianness == TARGET_LITTLE_ENDIAN)
139 return le_to_h_u32(buffer);
140 else
141 return be_to_h_u32(buffer);
142 }
143
144 /* read a u16 from a buffer in target memory endianness */
145 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
146 {
147 if (target->endianness == TARGET_LITTLE_ENDIAN)
148 return le_to_h_u16(buffer);
149 else
150 return be_to_h_u16(buffer);
151 }
152
153 /* write a u32 to a buffer in target memory endianness */
154 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
155 {
156 if (target->endianness == TARGET_LITTLE_ENDIAN)
157 h_u32_to_le(buffer, value);
158 else
159 h_u32_to_be(buffer, value);
160 }
161
162 /* write a u16 to a buffer in target memory endianness */
163 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
164 {
165 if (target->endianness == TARGET_LITTLE_ENDIAN)
166 h_u16_to_le(buffer, value);
167 else
168 h_u16_to_be(buffer, value);
169 }
170
171 /* returns a pointer to the n-th configured target */
172 target_t* get_target_by_num(int num)
173 {
174 target_t *target = targets;
175 int i = 0;
176
177 while (target)
178 {
179 if (num == i)
180 return target;
181 target = target->next;
182 i++;
183 }
184
185 return NULL;
186 }
187
188 int get_num_by_target(target_t *query_target)
189 {
190 target_t *target = targets;
191 int i = 0;
192
193 while (target)
194 {
195 if (target == query_target)
196 return i;
197 target = target->next;
198 i++;
199 }
200
201 return -1;
202 }
203
204 target_t* get_current_target(command_context_t *cmd_ctx)
205 {
206 target_t *target = get_target_by_num(cmd_ctx->current_target);
207
208 if (target == NULL)
209 {
210 ERROR("BUG: current_target out of bounds");
211 exit(-1);
212 }
213
214 return target;
215 }
216
217 /* Process target initialization, when target entered debug out of reset
218 * the handler is unregistered at the end of this function, so it's only called once
219 */
220 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
221 {
222 FILE *script;
223 struct command_context_s *cmd_ctx = priv;
224
225 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
226 {
227 target_unregister_event_callback(target_init_handler, priv);
228
229 script = open_file_from_path(cmd_ctx, target->reset_script, "r");
230 if (!script)
231 {
232 ERROR("couldn't open script file %s", target->reset_script);
233 return ERROR_OK;
234 }
235
236 INFO("executing reset script '%s'", target->reset_script);
237 command_run_file(cmd_ctx, script, COMMAND_EXEC);
238 fclose(script);
239
240 jtag_execute_queue();
241 }
242
243 return ERROR_OK;
244 }
245
246 int target_run_and_halt_handler(void *priv)
247 {
248 target_t *target = priv;
249
250 target->type->halt(target);
251
252 return ERROR_OK;
253 }
254
255 int target_process_reset(struct command_context_s *cmd_ctx)
256 {
257 int retval = ERROR_OK;
258 target_t *target;
259 struct timeval timeout, now;
260
261 /* prepare reset_halt where necessary */
262 target = targets;
263 while (target)
264 {
265 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
266 {
267 switch (target->reset_mode)
268 {
269 case RESET_HALT:
270 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
271 target->reset_mode = RESET_RUN_AND_HALT;
272 break;
273 case RESET_INIT:
274 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
275 target->reset_mode = RESET_RUN_AND_INIT;
276 break;
277 default:
278 break;
279 }
280 }
281 switch (target->reset_mode)
282 {
283 case RESET_HALT:
284 case RESET_INIT:
285 target->type->prepare_reset_halt(target);
286 break;
287 default:
288 break;
289 }
290 target = target->next;
291 }
292
293 target = targets;
294 while (target)
295 {
296 target->type->assert_reset(target);
297 target = target->next;
298 }
299 jtag_execute_queue();
300
301 /* request target halt if necessary, and schedule further action */
302 target = targets;
303 while (target)
304 {
305 switch (target->reset_mode)
306 {
307 case RESET_RUN:
308 /* nothing to do if target just wants to be run */
309 break;
310 case RESET_RUN_AND_HALT:
311 /* schedule halt */
312 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
313 break;
314 case RESET_RUN_AND_INIT:
315 /* schedule halt */
316 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
317 target_register_event_callback(target_init_handler, cmd_ctx);
318 break;
319 case RESET_HALT:
320 target->type->halt(target);
321 break;
322 case RESET_INIT:
323 target->type->halt(target);
324 target_register_event_callback(target_init_handler, cmd_ctx);
325 break;
326 default:
327 ERROR("BUG: unknown target->reset_mode");
328 }
329 target = target->next;
330 }
331
332 target = targets;
333 while (target)
334 {
335 target->type->deassert_reset(target);
336 target = target->next;
337 }
338 jtag_execute_queue();
339
340 /* Wait for reset to complete, maximum 5 seconds. */
341 gettimeofday(&timeout, NULL);
342 timeval_add_time(&timeout, 5, 0);
343 for(;;)
344 {
345 gettimeofday(&now, NULL);
346
347 target_call_timer_callbacks();
348
349 target = targets;
350 while (target)
351 {
352 target->type->poll(target);
353 if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT))
354 {
355 if (target->state != TARGET_HALTED)
356 {
357 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
358 {
359 command_print(cmd_ctx, "Timed out waiting for reset");
360 goto done;
361 }
362 usleep(100*1000); /* Do not eat all cpu */
363 goto again;
364 }
365 }
366 target = target->next;
367 }
368 /* All targets we're waiting for are halted */
369 break;
370
371 again:;
372 }
373 done:
374
375
376 /* We want any events to be processed before the prompt */
377 target_call_timer_callbacks();
378
379 return retval;
380 }
381
382 static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
383 {
384 *physical = virtual;
385 return ERROR_OK;
386 }
387
388 static int default_mmu(struct target_s *target, int *enabled)
389 {
390 USER("No MMU present");
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 /* Single aligned words are guaranteed to use 16 or 32 bit access
756 * mode respectively, otherwise data is handled as quickly as
757 * possible
758 */
759 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
760 {
761 int retval;
762
763 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
764
765 if (((address % 2) == 0) && (size == 2))
766 {
767 return target->type->write_memory(target, address, 2, 1, buffer);
768 }
769
770 /* handle unaligned head bytes */
771 if (address % 4)
772 {
773 int unaligned = 4 - (address % 4);
774
775 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
776 return retval;
777
778 buffer += unaligned;
779 address += unaligned;
780 size -= unaligned;
781 }
782
783 /* handle aligned words */
784 if (size >= 4)
785 {
786 int aligned = size - (size % 4);
787
788 /* use bulk writes above a certain limit. This may have to be changed */
789 if (aligned > 128)
790 {
791 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
792 return retval;
793 }
794 else
795 {
796 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
797 return retval;
798 }
799
800 buffer += aligned;
801 address += aligned;
802 size -= aligned;
803 }
804
805 /* handle tail writes of less than 4 bytes */
806 if (size > 0)
807 {
808 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
809 return retval;
810 }
811
812 return ERROR_OK;
813 }
814
815
816 /* Single aligned words are guaranteed to use 16 or 32 bit access
817 * mode respectively, otherwise data is handled as quickly as
818 * possible
819 */
820 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
821 {
822 int retval;
823
824 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
825
826 if (((address % 2) == 0) && (size == 2))
827 {
828 return target->type->read_memory(target, address, 2, 1, buffer);
829 }
830
831 /* handle unaligned head bytes */
832 if (address % 4)
833 {
834 int unaligned = 4 - (address % 4);
835
836 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
837 return retval;
838
839 buffer += unaligned;
840 address += unaligned;
841 size -= unaligned;
842 }
843
844 /* handle aligned words */
845 if (size >= 4)
846 {
847 int aligned = size - (size % 4);
848
849 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
850 return retval;
851
852 buffer += aligned;
853 address += aligned;
854 size -= aligned;
855 }
856
857 /* handle tail writes of less than 4 bytes */
858 if (size > 0)
859 {
860 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
861 return retval;
862 }
863
864 return ERROR_OK;
865 }
866
867 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
868 {
869 u8 *buffer;
870 int retval;
871 int i;
872 u32 checksum = 0;
873
874 if ((retval = target->type->checksum_memory(target, address,
875 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
876 {
877 buffer = malloc(size);
878 if (buffer == NULL)
879 {
880 ERROR("error allocating buffer for section (%d bytes)", size);
881 return ERROR_INVALID_ARGUMENTS;
882 }
883 retval = target_read_buffer(target, address, size, buffer);
884 if (retval != ERROR_OK)
885 {
886 free(buffer);
887 return retval;
888 }
889
890 /* convert to target endianess */
891 for (i = 0; i < (size/sizeof(u32)); i++)
892 {
893 u32 target_data;
894 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
895 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
896 }
897
898 retval = image_calculate_checksum( buffer, size, &checksum );
899 free(buffer);
900 }
901
902 *crc = checksum;
903
904 return retval;
905 }
906
907 int target_read_u32(struct target_s *target, u32 address, u32 *value)
908 {
909 u8 value_buf[4];
910
911 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
912
913 if (retval == ERROR_OK)
914 {
915 *value = target_buffer_get_u32(target, value_buf);
916 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
917 }
918 else
919 {
920 *value = 0x0;
921 DEBUG("address: 0x%8.8x failed", address);
922 }
923
924 return retval;
925 }
926
927 int target_read_u16(struct target_s *target, u32 address, u16 *value)
928 {
929 u8 value_buf[2];
930
931 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
932
933 if (retval == ERROR_OK)
934 {
935 *value = target_buffer_get_u16(target, value_buf);
936 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
937 }
938 else
939 {
940 *value = 0x0;
941 DEBUG("address: 0x%8.8x failed", address);
942 }
943
944 return retval;
945 }
946
947 int target_read_u8(struct target_s *target, u32 address, u8 *value)
948 {
949 int retval = target->type->read_memory(target, address, 1, 1, value);
950
951 if (retval == ERROR_OK)
952 {
953 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
954 }
955 else
956 {
957 *value = 0x0;
958 DEBUG("address: 0x%8.8x failed", address);
959 }
960
961 return retval;
962 }
963
964 int target_write_u32(struct target_s *target, u32 address, u32 value)
965 {
966 int retval;
967 u8 value_buf[4];
968
969 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
970
971 target_buffer_set_u32(target, value_buf, value);
972 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
973 {
974 DEBUG("failed: %i", retval);
975 }
976
977 return retval;
978 }
979
980 int target_write_u16(struct target_s *target, u32 address, u16 value)
981 {
982 int retval;
983 u8 value_buf[2];
984
985 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
986
987 target_buffer_set_u16(target, value_buf, value);
988 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
989 {
990 DEBUG("failed: %i", retval);
991 }
992
993 return retval;
994 }
995
996 int target_write_u8(struct target_s *target, u32 address, u8 value)
997 {
998 int retval;
999
1000 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1001
1002 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1003 {
1004 DEBUG("failed: %i", retval);
1005 }
1006
1007 return retval;
1008 }
1009
1010 int target_register_user_commands(struct command_context_s *cmd_ctx)
1011 {
1012 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1013 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1014 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1015 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1016 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1017 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1018 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1019 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1020
1021 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1022 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1023 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1024
1025 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
1026 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
1027 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
1028
1029 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1030 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1031 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1032 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1033
1034 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1035 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1036 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1037 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1038 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1039
1040 target_request_register_commands(cmd_ctx);
1041 trace_register_commands(cmd_ctx);
1042
1043 return ERROR_OK;
1044 }
1045
1046 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1047 {
1048 target_t *target = targets;
1049 int count = 0;
1050
1051 if (argc == 1)
1052 {
1053 int num = strtoul(args[0], NULL, 0);
1054
1055 while (target)
1056 {
1057 count++;
1058 target = target->next;
1059 }
1060
1061 if (num < count)
1062 cmd_ctx->current_target = num;
1063 else
1064 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1065
1066 return ERROR_OK;
1067 }
1068
1069 while (target)
1070 {
1071 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1072 target = target->next;
1073 }
1074
1075 return ERROR_OK;
1076 }
1077
1078 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1079 {
1080 int i;
1081 int found = 0;
1082
1083 if (argc < 3)
1084 {
1085 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1086 exit(-1);
1087 }
1088
1089 /* search for the specified target */
1090 if (args[0] && (args[0][0] != 0))
1091 {
1092 for (i = 0; target_types[i]; i++)
1093 {
1094 if (strcmp(args[0], target_types[i]->name) == 0)
1095 {
1096 target_t **last_target_p = &targets;
1097
1098 /* register target specific commands */
1099 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1100 {
1101 ERROR("couldn't register '%s' commands", args[0]);
1102 exit(-1);
1103 }
1104
1105 if (*last_target_p)
1106 {
1107 while ((*last_target_p)->next)
1108 last_target_p = &((*last_target_p)->next);
1109 last_target_p = &((*last_target_p)->next);
1110 }
1111
1112 *last_target_p = malloc(sizeof(target_t));
1113
1114 (*last_target_p)->type = target_types[i];
1115
1116 if (strcmp(args[1], "big") == 0)
1117 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1118 else if (strcmp(args[1], "little") == 0)
1119 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1120 else
1121 {
1122 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1123 exit(-1);
1124 }
1125
1126 /* what to do on a target reset */
1127 if (strcmp(args[2], "reset_halt") == 0)
1128 (*last_target_p)->reset_mode = RESET_HALT;
1129 else if (strcmp(args[2], "reset_run") == 0)
1130 (*last_target_p)->reset_mode = RESET_RUN;
1131 else if (strcmp(args[2], "reset_init") == 0)
1132 (*last_target_p)->reset_mode = RESET_INIT;
1133 else if (strcmp(args[2], "run_and_halt") == 0)
1134 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1135 else if (strcmp(args[2], "run_and_init") == 0)
1136 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1137 else
1138 {
1139 ERROR("unknown target startup mode %s", args[2]);
1140 exit(-1);
1141 }
1142 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1143
1144 (*last_target_p)->reset_script = NULL;
1145 (*last_target_p)->post_halt_script = NULL;
1146 (*last_target_p)->pre_resume_script = NULL;
1147 (*last_target_p)->gdb_program_script = NULL;
1148
1149 (*last_target_p)->working_area = 0x0;
1150 (*last_target_p)->working_area_size = 0x0;
1151 (*last_target_p)->working_areas = NULL;
1152 (*last_target_p)->backup_working_area = 0;
1153
1154 (*last_target_p)->state = TARGET_UNKNOWN;
1155 (*last_target_p)->reg_cache = NULL;
1156 (*last_target_p)->breakpoints = NULL;
1157 (*last_target_p)->watchpoints = NULL;
1158 (*last_target_p)->next = NULL;
1159 (*last_target_p)->arch_info = NULL;
1160
1161 /* initialize trace information */
1162 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1163 (*last_target_p)->trace_info->num_trace_points = 0;
1164 (*last_target_p)->trace_info->trace_points_size = 0;
1165 (*last_target_p)->trace_info->trace_points = NULL;
1166 (*last_target_p)->trace_info->trace_history_size = 0;
1167 (*last_target_p)->trace_info->trace_history = NULL;
1168 (*last_target_p)->trace_info->trace_history_pos = 0;
1169 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1170
1171 (*last_target_p)->dbgmsg = NULL;
1172 (*last_target_p)->dbg_msg_enabled = 0;
1173
1174 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1175
1176 found = 1;
1177 break;
1178 }
1179 }
1180 }
1181
1182 /* no matching target found */
1183 if (!found)
1184 {
1185 ERROR("target '%s' not found", args[0]);
1186 exit(-1);
1187 }
1188
1189 return ERROR_OK;
1190 }
1191
1192 /* usage: target_script <target#> <event> <script_file> */
1193 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1194 {
1195 target_t *target = NULL;
1196
1197 if (argc < 3)
1198 {
1199 ERROR("incomplete target_script command");
1200 exit(-1);
1201 }
1202
1203 target = get_target_by_num(strtoul(args[0], NULL, 0));
1204
1205 if (!target)
1206 {
1207 ERROR("target number '%s' not defined", args[0]);
1208 exit(-1);
1209 }
1210
1211 if (strcmp(args[1], "reset") == 0)
1212 {
1213 if (target->reset_script)
1214 free(target->reset_script);
1215 target->reset_script = strdup(args[2]);
1216 }
1217 else if (strcmp(args[1], "post_halt") == 0)
1218 {
1219 if (target->post_halt_script)
1220 free(target->post_halt_script);
1221 target->post_halt_script = strdup(args[2]);
1222 }
1223 else if (strcmp(args[1], "pre_resume") == 0)
1224 {
1225 if (target->pre_resume_script)
1226 free(target->pre_resume_script);
1227 target->pre_resume_script = strdup(args[2]);
1228 }
1229 else if (strcmp(args[1], "gdb_program_config") == 0)
1230 {
1231 if (target->gdb_program_script)
1232 free(target->gdb_program_script);
1233 target->gdb_program_script = strdup(args[2]);
1234 }
1235 else
1236 {
1237 ERROR("unknown event type: '%s", args[1]);
1238 exit(-1);
1239 }
1240
1241 return ERROR_OK;
1242 }
1243
1244 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1245 {
1246 target_t *target = NULL;
1247
1248 if (argc < 2)
1249 {
1250 ERROR("incomplete run_and_halt_time command");
1251 exit(-1);
1252 }
1253
1254 target = get_target_by_num(strtoul(args[0], NULL, 0));
1255
1256 if (!target)
1257 {
1258 ERROR("target number '%s' not defined", args[0]);
1259 exit(-1);
1260 }
1261
1262 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1263
1264 return ERROR_OK;
1265 }
1266
1267 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1268 {
1269 target_t *target = NULL;
1270
1271 if ((argc < 4) || (argc > 5))
1272 {
1273 return ERROR_COMMAND_SYNTAX_ERROR;
1274 }
1275
1276 target = get_target_by_num(strtoul(args[0], NULL, 0));
1277
1278 if (!target)
1279 {
1280 ERROR("target number '%s' not defined", args[0]);
1281 exit(-1);
1282 }
1283 target_free_all_working_areas(target);
1284
1285 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1286 if (argc == 5)
1287 {
1288 target->working_area_virt = strtoul(args[4], NULL, 0);
1289 }
1290 target->working_area_size = strtoul(args[2], NULL, 0);
1291
1292 if (strcmp(args[3], "backup") == 0)
1293 {
1294 target->backup_working_area = 1;
1295 }
1296 else if (strcmp(args[3], "nobackup") == 0)
1297 {
1298 target->backup_working_area = 0;
1299 }
1300 else
1301 {
1302 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1303 return ERROR_COMMAND_SYNTAX_ERROR;
1304 }
1305
1306 return ERROR_OK;
1307 }
1308
1309
1310 /* process target state changes */
1311 int handle_target(void *priv)
1312 {
1313 int retval;
1314 target_t *target = targets;
1315
1316 while (target)
1317 {
1318 /* only poll if target isn't already halted */
1319 if (target->state != TARGET_HALTED)
1320 {
1321 if (target_continous_poll)
1322 if ((retval = target->type->poll(target)) < 0)
1323 {
1324 ERROR("couldn't poll target. It's due for a reset.");
1325 }
1326 }
1327
1328 target = target->next;
1329 }
1330
1331 return ERROR_OK;
1332 }
1333
1334 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1335 {
1336 target_t *target;
1337 reg_t *reg = NULL;
1338 int count = 0;
1339 char *value;
1340
1341 DEBUG("-");
1342
1343 target = get_current_target(cmd_ctx);
1344
1345 /* list all available registers for the current target */
1346 if (argc == 0)
1347 {
1348 reg_cache_t *cache = target->reg_cache;
1349
1350 count = 0;
1351 while(cache)
1352 {
1353 int i;
1354 for (i = 0; i < cache->num_regs; i++)
1355 {
1356 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1357 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);
1358 free(value);
1359 }
1360 cache = cache->next;
1361 }
1362
1363 return ERROR_OK;
1364 }
1365
1366 /* access a single register by its ordinal number */
1367 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1368 {
1369 int num = strtoul(args[0], NULL, 0);
1370 reg_cache_t *cache = target->reg_cache;
1371
1372 count = 0;
1373 while(cache)
1374 {
1375 int i;
1376 for (i = 0; i < cache->num_regs; i++)
1377 {
1378 if (count++ == num)
1379 {
1380 reg = &cache->reg_list[i];
1381 break;
1382 }
1383 }
1384 if (reg)
1385 break;
1386 cache = cache->next;
1387 }
1388
1389 if (!reg)
1390 {
1391 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1392 return ERROR_OK;
1393 }
1394 } else /* access a single register by its name */
1395 {
1396 reg = register_get_by_name(target->reg_cache, args[0], 1);
1397
1398 if (!reg)
1399 {
1400 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1401 return ERROR_OK;
1402 }
1403 }
1404
1405 /* display a register */
1406 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1407 {
1408 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1409 reg->valid = 0;
1410
1411 if (reg->valid == 0)
1412 {
1413 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1414 if (arch_type == NULL)
1415 {
1416 ERROR("BUG: encountered unregistered arch type");
1417 return ERROR_OK;
1418 }
1419 arch_type->get(reg);
1420 }
1421 value = buf_to_str(reg->value, reg->size, 16);
1422 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1423 free(value);
1424 return ERROR_OK;
1425 }
1426
1427 /* set register value */
1428 if (argc == 2)
1429 {
1430 u8 *buf = malloc(CEIL(reg->size, 8));
1431 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1432
1433 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1434 if (arch_type == NULL)
1435 {
1436 ERROR("BUG: encountered unregistered arch type");
1437 return ERROR_OK;
1438 }
1439
1440 arch_type->set(reg, buf);
1441
1442 value = buf_to_str(reg->value, reg->size, 16);
1443 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1444 free(value);
1445
1446 free(buf);
1447
1448 return ERROR_OK;
1449 }
1450
1451 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1452
1453 return ERROR_OK;
1454 }
1455
1456 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1457
1458 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1459 {
1460 target_t *target = get_current_target(cmd_ctx);
1461 char buffer[512];
1462
1463 if (argc == 0)
1464 {
1465 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1466 if (target->state == TARGET_HALTED)
1467 {
1468 target->type->arch_state(target, buffer, 512);
1469 buffer[511] = 0;
1470 command_print(cmd_ctx, "%s", buffer);
1471 }
1472 }
1473 else
1474 {
1475 if (strcmp(args[0], "on") == 0)
1476 {
1477 target_continous_poll = 1;
1478 }
1479 else if (strcmp(args[0], "off") == 0)
1480 {
1481 target_continous_poll = 0;
1482 }
1483 else
1484 {
1485 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1486 }
1487 }
1488
1489
1490 return ERROR_OK;
1491 }
1492
1493 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1494 {
1495 int ms = 5000;
1496
1497 if (argc > 0)
1498 {
1499 char *end;
1500
1501 ms = strtoul(args[0], &end, 0) * 1000;
1502 if (*end)
1503 {
1504 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1505 return ERROR_OK;
1506 }
1507 }
1508
1509 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1510 }
1511
1512 static void target_process_events(struct command_context_s *cmd_ctx)
1513 {
1514 target_t *target = get_current_target(cmd_ctx);
1515 target->type->poll(target);
1516 target_call_timer_callbacks();
1517 }
1518
1519 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1520 {
1521 struct timeval timeout, now;
1522
1523 gettimeofday(&timeout, NULL);
1524 timeval_add_time(&timeout, 0, ms * 1000);
1525 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1526
1527 target_t *target = get_current_target(cmd_ctx);
1528 while (target->type->poll(target))
1529 {
1530 target_call_timer_callbacks();
1531 if (target->state == state)
1532 {
1533 command_print(cmd_ctx, "target %s", target_state_strings[state]);
1534 break;
1535 }
1536
1537 gettimeofday(&now, NULL);
1538 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1539 {
1540 command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
1541 ERROR("timed out while waiting for target %s", target_state_strings[state]);
1542 break;
1543 }
1544 }
1545
1546 return ERROR_OK;
1547 }
1548
1549 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1550 {
1551 int retval;
1552 target_t *target = get_current_target(cmd_ctx);
1553
1554 DEBUG("-");
1555
1556 command_print(cmd_ctx, "requesting target halt...");
1557
1558 if ((retval = target->type->halt(target)) != ERROR_OK)
1559 {
1560 switch (retval)
1561 {
1562 case ERROR_TARGET_ALREADY_HALTED:
1563 command_print(cmd_ctx, "target already halted");
1564 break;
1565 case ERROR_TARGET_TIMEOUT:
1566 command_print(cmd_ctx, "target timed out... shutting down");
1567 return retval;
1568 default:
1569 command_print(cmd_ctx, "unknown error... shutting down");
1570 return retval;
1571 }
1572 }
1573
1574 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1575 }
1576
1577 /* what to do on daemon startup */
1578 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1579 {
1580 if (argc == 1)
1581 {
1582 if (strcmp(args[0], "attach") == 0)
1583 {
1584 startup_mode = DAEMON_ATTACH;
1585 return ERROR_OK;
1586 }
1587 else if (strcmp(args[0], "reset") == 0)
1588 {
1589 startup_mode = DAEMON_RESET;
1590 return ERROR_OK;
1591 }
1592 }
1593
1594 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1595 return ERROR_OK;
1596
1597 }
1598
1599 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1600 {
1601 target_t *target = get_current_target(cmd_ctx);
1602 int retval;
1603
1604 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1605
1606 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1607 {
1608 switch (retval)
1609 {
1610 case ERROR_TARGET_TIMEOUT:
1611 command_print(cmd_ctx, "target timed out... shutting down");
1612 exit(-1);
1613 default:
1614 command_print(cmd_ctx, "unknown error... shutting down");
1615 exit(-1);
1616 }
1617 }
1618
1619 return ERROR_OK;
1620 }
1621
1622 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1623 {
1624 target_t *target = get_current_target(cmd_ctx);
1625 enum target_reset_mode reset_mode = target->reset_mode;
1626 enum target_reset_mode save = target->reset_mode;
1627
1628 DEBUG("-");
1629
1630 if (argc >= 1)
1631 {
1632 if (strcmp("run", args[0]) == 0)
1633 reset_mode = RESET_RUN;
1634 else if (strcmp("halt", args[0]) == 0)
1635 reset_mode = RESET_HALT;
1636 else if (strcmp("init", args[0]) == 0)
1637 reset_mode = RESET_INIT;
1638 else if (strcmp("run_and_halt", args[0]) == 0)
1639 {
1640 reset_mode = RESET_RUN_AND_HALT;
1641 if (argc >= 2)
1642 {
1643 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1644 }
1645 }
1646 else if (strcmp("run_and_init", args[0]) == 0)
1647 {
1648 reset_mode = RESET_RUN_AND_INIT;
1649 if (argc >= 2)
1650 {
1651 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1652 }
1653 }
1654 else
1655 {
1656 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1657 return ERROR_OK;
1658 }
1659 }
1660
1661 /* temporarily modify mode of current reset target */
1662 target->reset_mode = reset_mode;
1663
1664 /* reset *all* targets */
1665 target_process_reset(cmd_ctx);
1666
1667 /* Restore default reset mode for this target */
1668 target->reset_mode = save;
1669
1670 return ERROR_OK;
1671 }
1672
1673 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1674 {
1675 int retval;
1676 target_t *target = get_current_target(cmd_ctx);
1677
1678 DEBUG("-");
1679
1680 if (argc == 0)
1681 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1682 else if (argc == 1)
1683 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1684 else
1685 {
1686 command_print(cmd_ctx, "usage: resume [address]");
1687 return ERROR_OK;
1688 }
1689
1690 if (retval != ERROR_OK)
1691 {
1692 switch (retval)
1693 {
1694 case ERROR_TARGET_NOT_HALTED:
1695 command_print(cmd_ctx, "target not halted");
1696 break;
1697 default:
1698 command_print(cmd_ctx, "unknown error... shutting down");
1699 exit(-1);
1700 }
1701 }
1702
1703 target_process_events(cmd_ctx);
1704
1705 return ERROR_OK;
1706 }
1707
1708 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1709 {
1710 target_t *target = get_current_target(cmd_ctx);
1711
1712 DEBUG("-");
1713
1714 if (argc == 0)
1715 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1716
1717 if (argc == 1)
1718 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1719
1720 return ERROR_OK;
1721 }
1722
1723 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1724 {
1725 const int line_bytecnt = 32;
1726 int count = 1;
1727 int size = 4;
1728 u32 address = 0;
1729 int line_modulo;
1730 int i;
1731
1732 char output[128];
1733 int output_len;
1734
1735 int retval;
1736
1737 u8 *buffer;
1738 target_t *target = get_current_target(cmd_ctx);
1739
1740 if (argc < 1)
1741 return ERROR_OK;
1742
1743 if (argc == 2)
1744 count = strtoul(args[1], NULL, 0);
1745
1746 address = strtoul(args[0], NULL, 0);
1747
1748
1749 switch (cmd[2])
1750 {
1751 case 'w':
1752 size = 4; line_modulo = line_bytecnt / 4;
1753 break;
1754 case 'h':
1755 size = 2; line_modulo = line_bytecnt / 2;
1756 break;
1757 case 'b':
1758 size = 1; line_modulo = line_bytecnt / 1;
1759 break;
1760 default:
1761 return ERROR_OK;
1762 }
1763
1764 buffer = calloc(count, size);
1765 retval = target->type->read_memory(target, address, size, count, buffer);
1766 if (retval != ERROR_OK)
1767 {
1768 switch (retval)
1769 {
1770 case ERROR_TARGET_UNALIGNED_ACCESS:
1771 command_print(cmd_ctx, "error: address not aligned");
1772 break;
1773 case ERROR_TARGET_NOT_HALTED:
1774 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1775 break;
1776 case ERROR_TARGET_DATA_ABORT:
1777 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1778 break;
1779 default:
1780 command_print(cmd_ctx, "error: unknown error");
1781 break;
1782 }
1783 return ERROR_OK;
1784 }
1785
1786 output_len = 0;
1787
1788 for (i = 0; i < count; i++)
1789 {
1790 if (i%line_modulo == 0)
1791 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1792
1793 switch (size)
1794 {
1795 case 4:
1796 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1797 break;
1798 case 2:
1799 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1800 break;
1801 case 1:
1802 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1803 break;
1804 }
1805
1806 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1807 {
1808 command_print(cmd_ctx, output);
1809 output_len = 0;
1810 }
1811 }
1812
1813 free(buffer);
1814
1815 return ERROR_OK;
1816 }
1817
1818 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1819 {
1820 u32 address = 0;
1821 u32 value = 0;
1822 int retval;
1823 target_t *target = get_current_target(cmd_ctx);
1824 u8 value_buf[4];
1825
1826 if (argc < 2)
1827 return ERROR_OK;
1828
1829 address = strtoul(args[0], NULL, 0);
1830 value = strtoul(args[1], NULL, 0);
1831
1832 switch (cmd[2])
1833 {
1834 case 'w':
1835 target_buffer_set_u32(target, value_buf, value);
1836 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1837 break;
1838 case 'h':
1839 target_buffer_set_u16(target, value_buf, value);
1840 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1841 break;
1842 case 'b':
1843 value_buf[0] = value;
1844 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1845 break;
1846 default:
1847 return ERROR_OK;
1848 }
1849
1850 switch (retval)
1851 {
1852 case ERROR_TARGET_UNALIGNED_ACCESS:
1853 command_print(cmd_ctx, "error: address not aligned");
1854 break;
1855 case ERROR_TARGET_DATA_ABORT:
1856 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1857 break;
1858 case ERROR_TARGET_NOT_HALTED:
1859 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1860 break;
1861 case ERROR_OK:
1862 break;
1863 default:
1864 command_print(cmd_ctx, "error: unknown error");
1865 break;
1866 }
1867
1868 return ERROR_OK;
1869
1870 }
1871
1872 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1873 {
1874 u8 *buffer;
1875 u32 buf_cnt;
1876 u32 image_size;
1877 int i;
1878 int retval;
1879
1880 image_t image;
1881
1882 duration_t duration;
1883 char *duration_text;
1884
1885 target_t *target = get_current_target(cmd_ctx);
1886
1887 if (argc < 1)
1888 {
1889 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1890 return ERROR_OK;
1891 }
1892
1893 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1894 if (argc >= 2)
1895 {
1896 image.base_address_set = 1;
1897 image.base_address = strtoul(args[1], NULL, 0);
1898 }
1899 else
1900 {
1901 image.base_address_set = 0;
1902 }
1903
1904 image.start_address_set = 0;
1905
1906 duration_start_measure(&duration);
1907
1908 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1909 {
1910 command_print(cmd_ctx, "load_image error: %s", image.error_str);
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 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1981 return ERROR_OK;
1982 }
1983
1984 duration_start_measure(&duration);
1985
1986 while (size > 0)
1987 {
1988 u32 size_written;
1989 u32 this_run_size = (size > 560) ? 560 : size;
1990
1991 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1992 if (retval != ERROR_OK)
1993 {
1994 command_print(cmd_ctx, "Reading memory failed %d", retval);
1995 break;
1996 }
1997
1998 fileio_write(&fileio, this_run_size, buffer, &size_written);
1999
2000 size -= this_run_size;
2001 address += this_run_size;
2002 }
2003
2004 fileio_close(&fileio);
2005
2006 duration_stop_measure(&duration, &duration_text);
2007 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
2008 free(duration_text);
2009
2010 return ERROR_OK;
2011 }
2012
2013 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2014 {
2015 u8 *buffer;
2016 u32 buf_cnt;
2017 u32 image_size;
2018 int i;
2019 int retval;
2020 u32 checksum = 0;
2021 u32 mem_checksum = 0;
2022
2023 image_t image;
2024
2025 duration_t duration;
2026 char *duration_text;
2027
2028 target_t *target = get_current_target(cmd_ctx);
2029
2030 if (argc < 1)
2031 {
2032 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
2033 return ERROR_OK;
2034 }
2035
2036 if (!target)
2037 {
2038 ERROR("no target selected");
2039 return ERROR_OK;
2040 }
2041
2042 duration_start_measure(&duration);
2043
2044 if (argc >= 2)
2045 {
2046 image.base_address_set = 1;
2047 image.base_address = strtoul(args[1], NULL, 0);
2048 }
2049 else
2050 {
2051 image.base_address_set = 0;
2052 image.base_address = 0x0;
2053 }
2054
2055 image.start_address_set = 0;
2056
2057 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
2058 {
2059 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
2060 return ERROR_OK;
2061 }
2062
2063 image_size = 0x0;
2064 for (i = 0; i < image.num_sections; i++)
2065 {
2066 buffer = malloc(image.sections[i].size);
2067 if (buffer == NULL)
2068 {
2069 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2070 break;
2071 }
2072 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2073 {
2074 ERROR("image_read_section failed with error code: %i", retval);
2075 command_print(cmd_ctx, "image reading failed, verify aborted");
2076 free(buffer);
2077 image_close(&image);
2078 return ERROR_OK;
2079 }
2080
2081 /* calculate checksum of image */
2082 image_calculate_checksum( buffer, buf_cnt, &checksum );
2083
2084 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2085
2086 if( retval != ERROR_OK )
2087 {
2088 command_print(cmd_ctx, "could not calculate checksum, verify aborted");
2089 free(buffer);
2090 image_close(&image);
2091 return ERROR_OK;
2092 }
2093
2094 if( checksum != mem_checksum )
2095 {
2096 /* failed crc checksum, fall back to a binary compare */
2097 u8 *data;
2098
2099 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2100
2101 data = (u8*)malloc(buf_cnt);
2102
2103 /* Can we use 32bit word accesses? */
2104 int size = 1;
2105 int count = buf_cnt;
2106 if ((count % 4) == 0)
2107 {
2108 size *= 4;
2109 count /= 4;
2110 }
2111 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2112
2113 if (retval == ERROR_OK)
2114 {
2115 int t;
2116 for (t = 0; t < buf_cnt; t++)
2117 {
2118 if (data[t] != buffer[t])
2119 {
2120 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]);
2121 free(data);
2122 free(buffer);
2123 image_close(&image);
2124 return ERROR_OK;
2125 }
2126 }
2127 }
2128
2129 free(data);
2130 }
2131
2132 free(buffer);
2133 image_size += buf_cnt;
2134 }
2135
2136 duration_stop_measure(&duration, &duration_text);
2137 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2138 free(duration_text);
2139
2140 image_close(&image);
2141
2142 return ERROR_OK;
2143 }
2144
2145 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2146 {
2147 int retval;
2148 target_t *target = get_current_target(cmd_ctx);
2149
2150 if (argc == 0)
2151 {
2152 breakpoint_t *breakpoint = target->breakpoints;
2153
2154 while (breakpoint)
2155 {
2156 if (breakpoint->type == BKPT_SOFT)
2157 {
2158 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2159 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2160 free(buf);
2161 }
2162 else
2163 {
2164 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2165 }
2166 breakpoint = breakpoint->next;
2167 }
2168 }
2169 else if (argc >= 2)
2170 {
2171 int hw = BKPT_SOFT;
2172 u32 length = 0;
2173
2174 length = strtoul(args[1], NULL, 0);
2175
2176 if (argc >= 3)
2177 if (strcmp(args[2], "hw") == 0)
2178 hw = BKPT_HARD;
2179
2180 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2181 {
2182 switch (retval)
2183 {
2184 case ERROR_TARGET_NOT_HALTED:
2185 command_print(cmd_ctx, "target must be halted to set breakpoints");
2186 break;
2187 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2188 command_print(cmd_ctx, "no more breakpoints available");
2189 break;
2190 default:
2191 command_print(cmd_ctx, "unknown error, breakpoint not set");
2192 break;
2193 }
2194 }
2195 else
2196 {
2197 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2198 }
2199 }
2200 else
2201 {
2202 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2203 }
2204
2205 return ERROR_OK;
2206 }
2207
2208 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2209 {
2210 target_t *target = get_current_target(cmd_ctx);
2211
2212 if (argc > 0)
2213 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2214
2215 return ERROR_OK;
2216 }
2217
2218 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2219 {
2220 target_t *target = get_current_target(cmd_ctx);
2221 int retval;
2222
2223 if (argc == 0)
2224 {
2225 watchpoint_t *watchpoint = target->watchpoints;
2226
2227 while (watchpoint)
2228 {
2229 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);
2230 watchpoint = watchpoint->next;
2231 }
2232 }
2233 else if (argc >= 2)
2234 {
2235 enum watchpoint_rw type = WPT_ACCESS;
2236 u32 data_value = 0x0;
2237 u32 data_mask = 0xffffffff;
2238
2239 if (argc >= 3)
2240 {
2241 switch(args[2][0])
2242 {
2243 case 'r':
2244 type = WPT_READ;
2245 break;
2246 case 'w':
2247 type = WPT_WRITE;
2248 break;
2249 case 'a':
2250 type = WPT_ACCESS;
2251 break;
2252 default:
2253 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2254 return ERROR_OK;
2255 }
2256 }
2257 if (argc >= 4)
2258 {
2259 data_value = strtoul(args[3], NULL, 0);
2260 }
2261 if (argc >= 5)
2262 {
2263 data_mask = strtoul(args[4], NULL, 0);
2264 }
2265
2266 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2267 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2268 {
2269 switch (retval)
2270 {
2271 case ERROR_TARGET_NOT_HALTED:
2272 command_print(cmd_ctx, "target must be halted to set watchpoints");
2273 break;
2274 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2275 command_print(cmd_ctx, "no more watchpoints available");
2276 break;
2277 default:
2278 command_print(cmd_ctx, "unknown error, watchpoint not set");
2279 break;
2280 }
2281 }
2282 }
2283 else
2284 {
2285 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2286 }
2287
2288 return ERROR_OK;
2289 }
2290
2291 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2292 {
2293 target_t *target = get_current_target(cmd_ctx);
2294
2295 if (argc > 0)
2296 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2297
2298 return ERROR_OK;
2299 }
2300
2301 int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
2302 {
2303 int retval;
2304 target_t *target = get_current_target(cmd_ctx);
2305 u32 va;
2306 u32 pa;
2307
2308 if (argc != 1)
2309 {
2310 return ERROR_COMMAND_SYNTAX_ERROR;
2311 }
2312 va = strtoul(args[0], NULL, 0);
2313
2314 retval = target->type->virt2phys(target, va, &pa);
2315 if (retval == ERROR_OK)
2316 {
2317 command_print(cmd_ctx, "Physical address 0x%08x", pa);
2318 }
2319 else
2320 {
2321 /* lower levels will have logged a detailed error which is
2322 * forwarded to telnet/GDB session.
2323 */
2324 }
2325 return retval;
2326 }
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)