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