Code Review / openocd.git / blob
? search:


ce2d08564307bee2d72b4ba2472f231c943aeb48
[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 (unaligned > size)
776 unaligned = size;
777
778 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
779 return retval;
780
781 buffer += unaligned;
782 address += unaligned;
783 size -= unaligned;
784 }
785
786 /* handle aligned words */
787 if (size >= 4)
788 {
789 int aligned = size - (size % 4);
790
791 /* use bulk writes above a certain limit. This may have to be changed */
792 if (aligned > 128)
793 {
794 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
795 return retval;
796 }
797 else
798 {
799 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
800 return retval;
801 }
802
803 buffer += aligned;
804 address += aligned;
805 size -= aligned;
806 }
807
808 /* handle tail writes of less than 4 bytes */
809 if (size > 0)
810 {
811 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
812 return retval;
813 }
814
815 return ERROR_OK;
816 }
817
818
819 /* Single aligned words are guaranteed to use 16 or 32 bit access
820 * mode respectively, otherwise data is handled as quickly as
821 * possible
822 */
823 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
824 {
825 int retval;
826
827 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
828
829 if (((address % 2) == 0) && (size == 2))
830 {
831 return target->type->read_memory(target, address, 2, 1, buffer);
832 }
833
834 /* handle unaligned head bytes */
835 if (address % 4)
836 {
837 int unaligned = 4 - (address % 4);
838
839 if (unaligned > size)
840 unaligned = size;
841
842 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
843 return retval;
844
845 buffer += unaligned;
846 address += unaligned;
847 size -= unaligned;
848 }
849
850 /* handle aligned words */
851 if (size >= 4)
852 {
853 int aligned = size - (size % 4);
854
855 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
856 return retval;
857
858 buffer += aligned;
859 address += aligned;
860 size -= aligned;
861 }
862
863 /* handle tail writes of less than 4 bytes */
864 if (size > 0)
865 {
866 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
867 return retval;
868 }
869
870 return ERROR_OK;
871 }
872
873 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
874 {
875 u8 *buffer;
876 int retval;
877 int i;
878 u32 checksum = 0;
879
880 if ((retval = target->type->checksum_memory(target, address,
881 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
882 {
883 buffer = malloc(size);
884 if (buffer == NULL)
885 {
886 ERROR("error allocating buffer for section (%d bytes)", size);
887 return ERROR_INVALID_ARGUMENTS;
888 }
889 retval = target_read_buffer(target, address, size, buffer);
890 if (retval != ERROR_OK)
891 {
892 free(buffer);
893 return retval;
894 }
895
896 /* convert to target endianess */
897 for (i = 0; i < (size/sizeof(u32)); i++)
898 {
899 u32 target_data;
900 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
901 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
902 }
903
904 retval = image_calculate_checksum( buffer, size, &checksum );
905 free(buffer);
906 }
907
908 *crc = checksum;
909
910 return retval;
911 }
912
913 int target_read_u32(struct target_s *target, u32 address, u32 *value)
914 {
915 u8 value_buf[4];
916
917 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
918
919 if (retval == ERROR_OK)
920 {
921 *value = target_buffer_get_u32(target, value_buf);
922 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
923 }
924 else
925 {
926 *value = 0x0;
927 DEBUG("address: 0x%8.8x failed", address);
928 }
929
930 return retval;
931 }
932
933 int target_read_u16(struct target_s *target, u32 address, u16 *value)
934 {
935 u8 value_buf[2];
936
937 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
938
939 if (retval == ERROR_OK)
940 {
941 *value = target_buffer_get_u16(target, value_buf);
942 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
943 }
944 else
945 {
946 *value = 0x0;
947 DEBUG("address: 0x%8.8x failed", address);
948 }
949
950 return retval;
951 }
952
953 int target_read_u8(struct target_s *target, u32 address, u8 *value)
954 {
955 int retval = target->type->read_memory(target, address, 1, 1, value);
956
957 if (retval == ERROR_OK)
958 {
959 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
960 }
961 else
962 {
963 *value = 0x0;
964 DEBUG("address: 0x%8.8x failed", address);
965 }
966
967 return retval;
968 }
969
970 int target_write_u32(struct target_s *target, u32 address, u32 value)
971 {
972 int retval;
973 u8 value_buf[4];
974
975 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
976
977 target_buffer_set_u32(target, value_buf, value);
978 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
979 {
980 DEBUG("failed: %i", retval);
981 }
982
983 return retval;
984 }
985
986 int target_write_u16(struct target_s *target, u32 address, u16 value)
987 {
988 int retval;
989 u8 value_buf[2];
990
991 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
992
993 target_buffer_set_u16(target, value_buf, value);
994 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
995 {
996 DEBUG("failed: %i", retval);
997 }
998
999 return retval;
1000 }
1001
1002 int target_write_u8(struct target_s *target, u32 address, u8 value)
1003 {
1004 int retval;
1005
1006 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
1007
1008 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
1009 {
1010 DEBUG("failed: %i", retval);
1011 }
1012
1013 return retval;
1014 }
1015
1016 int target_register_user_commands(struct command_context_s *cmd_ctx)
1017 {
1018 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
1019 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
1020 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
1021 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
1022 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
1023 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
1024 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
1025 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
1026
1027 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
1028 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
1029 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
1030
1031 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
1032 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
1033 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
1034
1035 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
1036 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
1037 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
1038 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
1039
1040 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
1041 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
1042 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
1043 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
1044 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
1045
1046 target_request_register_commands(cmd_ctx);
1047 trace_register_commands(cmd_ctx);
1048
1049 return ERROR_OK;
1050 }
1051
1052 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1053 {
1054 target_t *target = targets;
1055 int count = 0;
1056
1057 if (argc == 1)
1058 {
1059 int num = strtoul(args[0], NULL, 0);
1060
1061 while (target)
1062 {
1063 count++;
1064 target = target->next;
1065 }
1066
1067 if (num < count)
1068 cmd_ctx->current_target = num;
1069 else
1070 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1071
1072 return ERROR_OK;
1073 }
1074
1075 while (target)
1076 {
1077 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1078 target = target->next;
1079 }
1080
1081 return ERROR_OK;
1082 }
1083
1084 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1085 {
1086 int i;
1087 int found = 0;
1088
1089 if (argc < 3)
1090 {
1091 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1092 exit(-1);
1093 }
1094
1095 /* search for the specified target */
1096 if (args[0] && (args[0][0] != 0))
1097 {
1098 for (i = 0; target_types[i]; i++)
1099 {
1100 if (strcmp(args[0], target_types[i]->name) == 0)
1101 {
1102 target_t **last_target_p = &targets;
1103
1104 /* register target specific commands */
1105 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1106 {
1107 ERROR("couldn't register '%s' commands", args[0]);
1108 exit(-1);
1109 }
1110
1111 if (*last_target_p)
1112 {
1113 while ((*last_target_p)->next)
1114 last_target_p = &((*last_target_p)->next);
1115 last_target_p = &((*last_target_p)->next);
1116 }
1117
1118 *last_target_p = malloc(sizeof(target_t));
1119
1120 (*last_target_p)->type = target_types[i];
1121
1122 if (strcmp(args[1], "big") == 0)
1123 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1124 else if (strcmp(args[1], "little") == 0)
1125 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1126 else
1127 {
1128 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1129 exit(-1);
1130 }
1131
1132 /* what to do on a target reset */
1133 if (strcmp(args[2], "reset_halt") == 0)
1134 (*last_target_p)->reset_mode = RESET_HALT;
1135 else if (strcmp(args[2], "reset_run") == 0)
1136 (*last_target_p)->reset_mode = RESET_RUN;
1137 else if (strcmp(args[2], "reset_init") == 0)
1138 (*last_target_p)->reset_mode = RESET_INIT;
1139 else if (strcmp(args[2], "run_and_halt") == 0)
1140 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1141 else if (strcmp(args[2], "run_and_init") == 0)
1142 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1143 else
1144 {
1145 ERROR("unknown target startup mode %s", args[2]);
1146 exit(-1);
1147 }
1148 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1149
1150 (*last_target_p)->reset_script = NULL;
1151 (*last_target_p)->post_halt_script = NULL;
1152 (*last_target_p)->pre_resume_script = NULL;
1153 (*last_target_p)->gdb_program_script = NULL;
1154
1155 (*last_target_p)->working_area = 0x0;
1156 (*last_target_p)->working_area_size = 0x0;
1157 (*last_target_p)->working_areas = NULL;
1158 (*last_target_p)->backup_working_area = 0;
1159
1160 (*last_target_p)->state = TARGET_UNKNOWN;
1161 (*last_target_p)->reg_cache = NULL;
1162 (*last_target_p)->breakpoints = NULL;
1163 (*last_target_p)->watchpoints = NULL;
1164 (*last_target_p)->next = NULL;
1165 (*last_target_p)->arch_info = NULL;
1166
1167 /* initialize trace information */
1168 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1169 (*last_target_p)->trace_info->num_trace_points = 0;
1170 (*last_target_p)->trace_info->trace_points_size = 0;
1171 (*last_target_p)->trace_info->trace_points = NULL;
1172 (*last_target_p)->trace_info->trace_history_size = 0;
1173 (*last_target_p)->trace_info->trace_history = NULL;
1174 (*last_target_p)->trace_info->trace_history_pos = 0;
1175 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1176
1177 (*last_target_p)->dbgmsg = NULL;
1178 (*last_target_p)->dbg_msg_enabled = 0;
1179
1180 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1181
1182 found = 1;
1183 break;
1184 }
1185 }
1186 }
1187
1188 /* no matching target found */
1189 if (!found)
1190 {
1191 ERROR("target '%s' not found", args[0]);
1192 exit(-1);
1193 }
1194
1195 return ERROR_OK;
1196 }
1197
1198 /* usage: target_script <target#> <event> <script_file> */
1199 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1200 {
1201 target_t *target = NULL;
1202
1203 if (argc < 3)
1204 {
1205 ERROR("incomplete target_script command");
1206 exit(-1);
1207 }
1208
1209 target = get_target_by_num(strtoul(args[0], NULL, 0));
1210
1211 if (!target)
1212 {
1213 ERROR("target number '%s' not defined", args[0]);
1214 exit(-1);
1215 }
1216
1217 if (strcmp(args[1], "reset") == 0)
1218 {
1219 if (target->reset_script)
1220 free(target->reset_script);
1221 target->reset_script = strdup(args[2]);
1222 }
1223 else if (strcmp(args[1], "post_halt") == 0)
1224 {
1225 if (target->post_halt_script)
1226 free(target->post_halt_script);
1227 target->post_halt_script = strdup(args[2]);
1228 }
1229 else if (strcmp(args[1], "pre_resume") == 0)
1230 {
1231 if (target->pre_resume_script)
1232 free(target->pre_resume_script);
1233 target->pre_resume_script = strdup(args[2]);
1234 }
1235 else if (strcmp(args[1], "gdb_program_config") == 0)
1236 {
1237 if (target->gdb_program_script)
1238 free(target->gdb_program_script);
1239 target->gdb_program_script = strdup(args[2]);
1240 }
1241 else
1242 {
1243 ERROR("unknown event type: '%s", args[1]);
1244 exit(-1);
1245 }
1246
1247 return ERROR_OK;
1248 }
1249
1250 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1251 {
1252 target_t *target = NULL;
1253
1254 if (argc < 2)
1255 {
1256 ERROR("incomplete run_and_halt_time command");
1257 exit(-1);
1258 }
1259
1260 target = get_target_by_num(strtoul(args[0], NULL, 0));
1261
1262 if (!target)
1263 {
1264 ERROR("target number '%s' not defined", args[0]);
1265 exit(-1);
1266 }
1267
1268 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1269
1270 return ERROR_OK;
1271 }
1272
1273 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1274 {
1275 target_t *target = NULL;
1276
1277 if ((argc < 4) || (argc > 5))
1278 {
1279 return ERROR_COMMAND_SYNTAX_ERROR;
1280 }
1281
1282 target = get_target_by_num(strtoul(args[0], NULL, 0));
1283
1284 if (!target)
1285 {
1286 ERROR("target number '%s' not defined", args[0]);
1287 exit(-1);
1288 }
1289 target_free_all_working_areas(target);
1290
1291 target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
1292 if (argc == 5)
1293 {
1294 target->working_area_virt = strtoul(args[4], NULL, 0);
1295 }
1296 target->working_area_size = strtoul(args[2], NULL, 0);
1297
1298 if (strcmp(args[3], "backup") == 0)
1299 {
1300 target->backup_working_area = 1;
1301 }
1302 else if (strcmp(args[3], "nobackup") == 0)
1303 {
1304 target->backup_working_area = 0;
1305 }
1306 else
1307 {
1308 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1309 return ERROR_COMMAND_SYNTAX_ERROR;
1310 }
1311
1312 return ERROR_OK;
1313 }
1314
1315
1316 /* process target state changes */
1317 int handle_target(void *priv)
1318 {
1319 int retval;
1320 target_t *target = targets;
1321
1322 while (target)
1323 {
1324 /* only poll if target isn't already halted */
1325 if (target->state != TARGET_HALTED)
1326 {
1327 if (target_continous_poll)
1328 if ((retval = target->type->poll(target)) < 0)
1329 {
1330 ERROR("couldn't poll target. It's due for a reset.");
1331 }
1332 }
1333
1334 target = target->next;
1335 }
1336
1337 return ERROR_OK;
1338 }
1339
1340 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1341 {
1342 target_t *target;
1343 reg_t *reg = NULL;
1344 int count = 0;
1345 char *value;
1346
1347 DEBUG("-");
1348
1349 target = get_current_target(cmd_ctx);
1350
1351 /* list all available registers for the current target */
1352 if (argc == 0)
1353 {
1354 reg_cache_t *cache = target->reg_cache;
1355
1356 count = 0;
1357 while(cache)
1358 {
1359 int i;
1360 for (i = 0; i < cache->num_regs; i++)
1361 {
1362 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1363 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);
1364 free(value);
1365 }
1366 cache = cache->next;
1367 }
1368
1369 return ERROR_OK;
1370 }
1371
1372 /* access a single register by its ordinal number */
1373 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1374 {
1375 int num = strtoul(args[0], NULL, 0);
1376 reg_cache_t *cache = target->reg_cache;
1377
1378 count = 0;
1379 while(cache)
1380 {
1381 int i;
1382 for (i = 0; i < cache->num_regs; i++)
1383 {
1384 if (count++ == num)
1385 {
1386 reg = &cache->reg_list[i];
1387 break;
1388 }
1389 }
1390 if (reg)
1391 break;
1392 cache = cache->next;
1393 }
1394
1395 if (!reg)
1396 {
1397 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1398 return ERROR_OK;
1399 }
1400 } else /* access a single register by its name */
1401 {
1402 reg = register_get_by_name(target->reg_cache, args[0], 1);
1403
1404 if (!reg)
1405 {
1406 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1407 return ERROR_OK;
1408 }
1409 }
1410
1411 /* display a register */
1412 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1413 {
1414 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1415 reg->valid = 0;
1416
1417 if (reg->valid == 0)
1418 {
1419 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1420 if (arch_type == NULL)
1421 {
1422 ERROR("BUG: encountered unregistered arch type");
1423 return ERROR_OK;
1424 }
1425 arch_type->get(reg);
1426 }
1427 value = buf_to_str(reg->value, reg->size, 16);
1428 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1429 free(value);
1430 return ERROR_OK;
1431 }
1432
1433 /* set register value */
1434 if (argc == 2)
1435 {
1436 u8 *buf = malloc(CEIL(reg->size, 8));
1437 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1438
1439 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1440 if (arch_type == NULL)
1441 {
1442 ERROR("BUG: encountered unregistered arch type");
1443 return ERROR_OK;
1444 }
1445
1446 arch_type->set(reg, buf);
1447
1448 value = buf_to_str(reg->value, reg->size, 16);
1449 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1450 free(value);
1451
1452 free(buf);
1453
1454 return ERROR_OK;
1455 }
1456
1457 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1458
1459 return ERROR_OK;
1460 }
1461
1462 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1463
1464 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1465 {
1466 target_t *target = get_current_target(cmd_ctx);
1467 char buffer[512];
1468
1469 if (argc == 0)
1470 {
1471 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1472 if (target->state == TARGET_HALTED)
1473 {
1474 target->type->arch_state(target, buffer, 512);
1475 buffer[511] = 0;
1476 command_print(cmd_ctx, "%s", buffer);
1477 }
1478 }
1479 else
1480 {
1481 if (strcmp(args[0], "on") == 0)
1482 {
1483 target_continous_poll = 1;
1484 }
1485 else if (strcmp(args[0], "off") == 0)
1486 {
1487 target_continous_poll = 0;
1488 }
1489 else
1490 {
1491 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1492 }
1493 }
1494
1495
1496 return ERROR_OK;
1497 }
1498
1499 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1500 {
1501 int ms = 5000;
1502
1503 if (argc > 0)
1504 {
1505 char *end;
1506
1507 ms = strtoul(args[0], &end, 0) * 1000;
1508 if (*end)
1509 {
1510 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1511 return ERROR_OK;
1512 }
1513 }
1514
1515 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1516 }
1517
1518 static void target_process_events(struct command_context_s *cmd_ctx)
1519 {
1520 target_t *target = get_current_target(cmd_ctx);
1521 target->type->poll(target);
1522 target_call_timer_callbacks();
1523 }
1524
1525 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1526 {
1527 struct timeval timeout, now;
1528
1529 gettimeofday(&timeout, NULL);
1530 timeval_add_time(&timeout, 0, ms * 1000);
1531 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1532
1533 target_t *target = get_current_target(cmd_ctx);
1534 while (target->type->poll(target))
1535 {
1536 target_call_timer_callbacks();
1537 if (target->state == state)
1538 {
1539 command_print(cmd_ctx, "target %s", target_state_strings[state]);
1540 break;
1541 }
1542
1543 gettimeofday(&now, NULL);
1544 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1545 {
1546 command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
1547 ERROR("timed out while waiting for target %s", target_state_strings[state]);
1548 break;
1549 }
1550 }
1551
1552 return ERROR_OK;
1553 }
1554
1555 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1556 {
1557 int retval;
1558 target_t *target = get_current_target(cmd_ctx);
1559
1560 DEBUG("-");
1561
1562 command_print(cmd_ctx, "requesting target halt...");
1563
1564 if ((retval = target->type->halt(target)) != ERROR_OK)
1565 {
1566 switch (retval)
1567 {
1568 case ERROR_TARGET_ALREADY_HALTED:
1569 command_print(cmd_ctx, "target already halted");
1570 break;
1571 case ERROR_TARGET_TIMEOUT:
1572 command_print(cmd_ctx, "target timed out... shutting down");
1573 return retval;
1574 default:
1575 command_print(cmd_ctx, "unknown error... shutting down");
1576 return retval;
1577 }
1578 }
1579
1580 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1581 }
1582
1583 /* what to do on daemon startup */
1584 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1585 {
1586 if (argc == 1)
1587 {
1588 if (strcmp(args[0], "attach") == 0)
1589 {
1590 startup_mode = DAEMON_ATTACH;
1591 return ERROR_OK;
1592 }
1593 else if (strcmp(args[0], "reset") == 0)
1594 {
1595 startup_mode = DAEMON_RESET;
1596 return ERROR_OK;
1597 }
1598 }
1599
1600 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1601 return ERROR_OK;
1602
1603 }
1604
1605 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1606 {
1607 target_t *target = get_current_target(cmd_ctx);
1608 int retval;
1609
1610 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1611
1612 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1613 {
1614 switch (retval)
1615 {
1616 case ERROR_TARGET_TIMEOUT:
1617 command_print(cmd_ctx, "target timed out... shutting down");
1618 exit(-1);
1619 default:
1620 command_print(cmd_ctx, "unknown error... shutting down");
1621 exit(-1);
1622 }
1623 }
1624
1625 return ERROR_OK;
1626 }
1627
1628 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1629 {
1630 target_t *target = get_current_target(cmd_ctx);
1631 enum target_reset_mode reset_mode = target->reset_mode;
1632 enum target_reset_mode save = target->reset_mode;
1633
1634 DEBUG("-");
1635
1636 if (argc >= 1)
1637 {
1638 if (strcmp("run", args[0]) == 0)
1639 reset_mode = RESET_RUN;
1640 else if (strcmp("halt", args[0]) == 0)
1641 reset_mode = RESET_HALT;
1642 else if (strcmp("init", args[0]) == 0)
1643 reset_mode = RESET_INIT;
1644 else if (strcmp("run_and_halt", args[0]) == 0)
1645 {
1646 reset_mode = RESET_RUN_AND_HALT;
1647 if (argc >= 2)
1648 {
1649 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1650 }
1651 }
1652 else if (strcmp("run_and_init", args[0]) == 0)
1653 {
1654 reset_mode = RESET_RUN_AND_INIT;
1655 if (argc >= 2)
1656 {
1657 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1658 }
1659 }
1660 else
1661 {
1662 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1663 return ERROR_OK;
1664 }
1665 }
1666
1667 /* temporarily modify mode of current reset target */
1668 target->reset_mode = reset_mode;
1669
1670 /* reset *all* targets */
1671 target_process_reset(cmd_ctx);
1672
1673 /* Restore default reset mode for this target */
1674 target->reset_mode = save;
1675
1676 return ERROR_OK;
1677 }
1678
1679 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1680 {
1681 int retval;
1682 target_t *target = get_current_target(cmd_ctx);
1683
1684 DEBUG("-");
1685
1686 if (argc == 0)
1687 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1688 else if (argc == 1)
1689 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1690 else
1691 {
1692 command_print(cmd_ctx, "usage: resume [address]");
1693 return ERROR_OK;
1694 }
1695
1696 if (retval != ERROR_OK)
1697 {
1698 switch (retval)
1699 {
1700 case ERROR_TARGET_NOT_HALTED:
1701 command_print(cmd_ctx, "target not halted");
1702 break;
1703 default:
1704 command_print(cmd_ctx, "unknown error... shutting down");
1705 exit(-1);
1706 }
1707 }
1708
1709 target_process_events(cmd_ctx);
1710
1711 return ERROR_OK;
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)