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