Code Review / openocd.git / blob
? search:


548ea0c39c529ae3049f83ae9e9216e5c137afd3
[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
27 #include "log.h"
28 #include "configuration.h"
29 #include "binarybuffer.h"
30 #include "jtag.h"
31
32 #include <string.h>
33 #include <stdlib.h>
34
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38 #include <errno.h>
39
40 #include <sys/time.h>
41 #include <time.h>
42
43 #include <time_support.h>
44
45 #include <fileio.h>
46
47 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
48
49 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52
53 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56
57 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
60 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73
74 /* targets
75 */
76 extern target_type_t arm7tdmi_target;
77 extern target_type_t arm720t_target;
78 extern target_type_t arm9tdmi_target;
79 extern target_type_t arm920t_target;
80 extern target_type_t arm966e_target;
81 extern target_type_t arm926ejs_target;
82 extern target_type_t xscale_target;
83
84 target_type_t *target_types[] =
85 {
86 &arm7tdmi_target,
87 &arm9tdmi_target,
88 &arm920t_target,
89 &arm720t_target,
90 &arm966e_target,
91 &arm926ejs_target,
92 &xscale_target,
93 NULL,
94 };
95
96 target_t *targets = NULL;
97 target_event_callback_t *target_event_callbacks = NULL;
98 target_timer_callback_t *target_timer_callbacks = NULL;
99
100 char *target_state_strings[] =
101 {
102 "unknown",
103 "running",
104 "halted",
105 "reset",
106 "debug_running",
107 };
108
109 char *target_debug_reason_strings[] =
110 {
111 "debug request", "breakpoint", "watchpoint",
112 "watchpoint and breakpoint", "single step",
113 "target not halted"
114 };
115
116 char *target_endianess_strings[] =
117 {
118 "big endian",
119 "little endian",
120 };
121
122 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
123
124 static int target_continous_poll = 1;
125
126 /* read a u32 from a buffer in target memory endianness */
127 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
128 {
129 if (target->endianness == TARGET_LITTLE_ENDIAN)
130 return le_to_h_u32(buffer);
131 else
132 return be_to_h_u32(buffer);
133 }
134
135 /* read a u16 from a buffer in target memory endianness */
136 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
137 {
138 if (target->endianness == TARGET_LITTLE_ENDIAN)
139 return le_to_h_u16(buffer);
140 else
141 return be_to_h_u16(buffer);
142 }
143
144 /* write a u32 to a buffer in target memory endianness */
145 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
146 {
147 if (target->endianness == TARGET_LITTLE_ENDIAN)
148 h_u32_to_le(buffer, value);
149 else
150 h_u32_to_be(buffer, value);
151 }
152
153 /* write a u16 to a buffer in target memory endianness */
154 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
155 {
156 if (target->endianness == TARGET_LITTLE_ENDIAN)
157 h_u16_to_le(buffer, value);
158 else
159 h_u16_to_be(buffer, value);
160 }
161
162 /* returns a pointer to the n-th configured target */
163 target_t* get_target_by_num(int num)
164 {
165 target_t *target = targets;
166 int i = 0;
167
168 while (target)
169 {
170 if (num == i)
171 return target;
172 target = target->next;
173 i++;
174 }
175
176 return NULL;
177 }
178
179 int get_num_by_target(target_t *query_target)
180 {
181 target_t *target = targets;
182 int i = 0;
183
184 while (target)
185 {
186 if (target == query_target)
187 return i;
188 target = target->next;
189 i++;
190 }
191
192 return -1;
193 }
194
195 target_t* get_current_target(command_context_t *cmd_ctx)
196 {
197 target_t *target = get_target_by_num(cmd_ctx->current_target);
198
199 if (target == NULL)
200 {
201 ERROR("BUG: current_target out of bounds");
202 exit(-1);
203 }
204
205 return target;
206 }
207
208 /* Process target initialization, when target entered debug out of reset
209 * the handler is unregistered at the end of this function, so it's only called once
210 */
211 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
212 {
213 FILE *script;
214 struct command_context_s *cmd_ctx = priv;
215
216 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
217 {
218 target_unregister_event_callback(target_init_handler, priv);
219
220 script = fopen(target->reset_script, "r");
221 if (!script)
222 {
223 ERROR("couldn't open script file %s", target->reset_script);
224 return ERROR_OK;
225 }
226
227 INFO("executing reset script '%s'", target->reset_script);
228 command_run_file(cmd_ctx, script, COMMAND_EXEC);
229 fclose(script);
230
231 jtag_execute_queue();
232 }
233
234 return ERROR_OK;
235 }
236
237 int target_run_and_halt_handler(void *priv)
238 {
239 target_t *target = priv;
240
241 target->type->halt(target);
242
243 return ERROR_OK;
244 }
245
246 int target_process_reset(struct command_context_s *cmd_ctx)
247 {
248 int retval = ERROR_OK;
249 target_t *target;
250
251 target = targets;
252 while (target)
253 {
254 target->type->assert_reset(target);
255 target = target->next;
256 }
257 jtag_execute_queue();
258
259 /* request target halt if necessary, and schedule further action */
260 target = targets;
261 while (target)
262 {
263 switch (target->reset_mode)
264 {
265 case RESET_RUN:
266 /* nothing to do if target just wants to be run */
267 break;
268 case RESET_RUN_AND_HALT:
269 /* schedule halt */
270 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
271 break;
272 case RESET_RUN_AND_INIT:
273 /* schedule halt */
274 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
275 target_register_event_callback(target_init_handler, cmd_ctx);
276 break;
277 case RESET_HALT:
278 target->type->halt(target);
279 break;
280 case RESET_INIT:
281 target->type->halt(target);
282 target_register_event_callback(target_init_handler, cmd_ctx);
283 break;
284 default:
285 ERROR("BUG: unknown target->reset_mode");
286 }
287 target = target->next;
288 }
289
290 target = targets;
291 while (target)
292 {
293 target->type->deassert_reset(target);
294 target = target->next;
295 }
296 jtag_execute_queue();
297
298 return retval;
299 }
300
301 int target_init(struct command_context_s *cmd_ctx)
302 {
303 target_t *target = targets;
304
305 while (target)
306 {
307 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
308 {
309 ERROR("target '%s' init failed", target->type->name);
310 exit(-1);
311 }
312 target = target->next;
313 }
314
315 if (targets)
316 {
317 target_register_user_commands(cmd_ctx);
318 target_register_timer_callback(handle_target, 100, 1, NULL);
319 }
320
321 if (startup_mode == DAEMON_RESET)
322 target_process_reset(cmd_ctx);
323
324 return ERROR_OK;
325 }
326
327 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
328 {
329 target_event_callback_t **callbacks_p = &target_event_callbacks;
330
331 if (callback == NULL)
332 {
333 return ERROR_INVALID_ARGUMENTS;
334 }
335
336 if (*callbacks_p)
337 {
338 while ((*callbacks_p)->next)
339 callbacks_p = &((*callbacks_p)->next);
340 callbacks_p = &((*callbacks_p)->next);
341 }
342
343 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
344 (*callbacks_p)->callback = callback;
345 (*callbacks_p)->priv = priv;
346 (*callbacks_p)->next = NULL;
347
348 return ERROR_OK;
349 }
350
351 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
352 {
353 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
354 struct timeval now;
355
356 if (callback == NULL)
357 {
358 return ERROR_INVALID_ARGUMENTS;
359 }
360
361 if (*callbacks_p)
362 {
363 while ((*callbacks_p)->next)
364 callbacks_p = &((*callbacks_p)->next);
365 callbacks_p = &((*callbacks_p)->next);
366 }
367
368 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
369 (*callbacks_p)->callback = callback;
370 (*callbacks_p)->periodic = periodic;
371 (*callbacks_p)->time_ms = time_ms;
372
373 gettimeofday(&now, NULL);
374 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
375 time_ms -= (time_ms % 1000);
376 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
377 if ((*callbacks_p)->when.tv_usec > 1000000)
378 {
379 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
380 (*callbacks_p)->when.tv_sec += 1;
381 }
382
383 (*callbacks_p)->priv = priv;
384 (*callbacks_p)->next = NULL;
385
386 return ERROR_OK;
387 }
388
389 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
390 {
391 target_event_callback_t **p = &target_event_callbacks;
392 target_event_callback_t *c = target_event_callbacks;
393
394 if (callback == NULL)
395 {
396 return ERROR_INVALID_ARGUMENTS;
397 }
398
399 while (c)
400 {
401 target_event_callback_t *next = c->next;
402 if ((c->callback == callback) && (c->priv == priv))
403 {
404 *p = next;
405 free(c);
406 return ERROR_OK;
407 }
408 else
409 p = &(c->next);
410 c = next;
411 }
412
413 return ERROR_OK;
414 }
415
416 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
417 {
418 target_timer_callback_t **p = &target_timer_callbacks;
419 target_timer_callback_t *c = target_timer_callbacks;
420
421 if (callback == NULL)
422 {
423 return ERROR_INVALID_ARGUMENTS;
424 }
425
426 while (c)
427 {
428 target_timer_callback_t *next = c->next;
429 if ((c->callback == callback) && (c->priv == priv))
430 {
431 *p = next;
432 free(c);
433 return ERROR_OK;
434 }
435 else
436 p = &(c->next);
437 c = next;
438 }
439
440 return ERROR_OK;
441 }
442
443 int target_call_event_callbacks(target_t *target, enum target_event event)
444 {
445 target_event_callback_t *callback = target_event_callbacks;
446 target_event_callback_t *next_callback;
447
448 DEBUG("target event %i", event);
449
450 while (callback)
451 {
452 next_callback = callback->next;
453 callback->callback(target, event, callback->priv);
454 callback = next_callback;
455 }
456
457 return ERROR_OK;
458 }
459
460 int target_call_timer_callbacks()
461 {
462 target_timer_callback_t *callback = target_timer_callbacks;
463 target_timer_callback_t *next_callback;
464 struct timeval now;
465
466 gettimeofday(&now, NULL);
467
468 while (callback)
469 {
470 next_callback = callback->next;
471
472 if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
473 || (now.tv_sec > callback->when.tv_sec))
474 {
475 callback->callback(callback->priv);
476 if (callback->periodic)
477 {
478 int time_ms = callback->time_ms;
479 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
480 time_ms -= (time_ms % 1000);
481 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
482 if (callback->when.tv_usec > 1000000)
483 {
484 callback->when.tv_usec = callback->when.tv_usec - 1000000;
485 callback->when.tv_sec += 1;
486 }
487 }
488 else
489 target_unregister_timer_callback(callback->callback, callback->priv);
490 }
491
492 callback = next_callback;
493 }
494
495 return ERROR_OK;
496 }
497
498 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
499 {
500 working_area_t *c = target->working_areas;
501 working_area_t *new_wa = NULL;
502
503 /* only allocate multiples of 4 byte */
504 if (size % 4)
505 {
506 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
507 size = CEIL(size, 4);
508 }
509
510 /* see if there's already a matching working area */
511 while (c)
512 {
513 if ((c->free) && (c->size == size))
514 {
515 new_wa = c;
516 break;
517 }
518 c = c->next;
519 }
520
521 /* if not, allocate a new one */
522 if (!new_wa)
523 {
524 working_area_t **p = &target->working_areas;
525 u32 first_free = target->working_area;
526 u32 free_size = target->working_area_size;
527
528 DEBUG("allocating new working area");
529
530 c = target->working_areas;
531 while (c)
532 {
533 first_free += c->size;
534 free_size -= c->size;
535 p = &c->next;
536 c = c->next;
537 }
538
539 if (free_size < size)
540 {
541 WARNING("not enough working area available");
542 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
543 }
544
545 new_wa = malloc(sizeof(working_area_t));
546 new_wa->next = NULL;
547 new_wa->size = size;
548 new_wa->address = first_free;
549
550 if (target->backup_working_area)
551 {
552 new_wa->backup = malloc(new_wa->size);
553 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
554 }
555 else
556 {
557 new_wa->backup = NULL;
558 }
559
560 /* put new entry in list */
561 *p = new_wa;
562 }
563
564 /* mark as used, and return the new (reused) area */
565 new_wa->free = 0;
566 *area = new_wa;
567
568 /* user pointer */
569 new_wa->user = area;
570
571 return ERROR_OK;
572 }
573
574 int target_free_working_area(struct target_s *target, working_area_t *area)
575 {
576 if (area->free)
577 return ERROR_OK;
578
579 if (target->backup_working_area)
580 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
581
582 area->free = 1;
583
584 /* mark user pointer invalid */
585 *area->user = NULL;
586 area->user = NULL;
587
588 return ERROR_OK;
589 }
590
591 int target_free_all_working_areas(struct target_s *target)
592 {
593 working_area_t *c = target->working_areas;
594
595 while (c)
596 {
597 working_area_t *next = c->next;
598 target_free_working_area(target, c);
599
600 if (c->backup)
601 free(c->backup);
602
603 free(c);
604
605 c = next;
606 }
607
608 target->working_areas = NULL;
609
610 return ERROR_OK;
611 }
612
613 int target_register_commands(struct command_context_s *cmd_ctx)
614 {
615 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL);
616 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
617 register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
618 register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
619 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
620 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
621
622 return ERROR_OK;
623 }
624
625 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
626 {
627 int retval;
628
629 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
630
631 /* handle writes of less than 4 byte */
632 if (size < 4)
633 {
634 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
635 return retval;
636 }
637
638 /* handle unaligned head bytes */
639 if (address % 4)
640 {
641 int unaligned = 4 - (address % 4);
642
643 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
644 return retval;
645
646 buffer += unaligned;
647 address += unaligned;
648 size -= unaligned;
649 }
650
651 /* handle aligned words */
652 if (size >= 4)
653 {
654 int aligned = size - (size % 4);
655
656 /* use bulk writes above a certain limit. This may have to be changed */
657 if (aligned > 128)
658 {
659 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
660 return retval;
661 }
662 else
663 {
664 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
665 return retval;
666 }
667
668 buffer += aligned;
669 address += aligned;
670 size -= aligned;
671 }
672
673 /* handle tail writes of less than 4 bytes */
674 if (size > 0)
675 {
676 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
677 return retval;
678 }
679
680 return ERROR_OK;
681 }
682
683 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
684 {
685 int retval;
686
687 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
688
689 /* handle reads of less than 4 byte */
690 if (size < 4)
691 {
692 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
693 return retval;
694 }
695
696 /* handle unaligned head bytes */
697 if (address % 4)
698 {
699 int unaligned = 4 - (address % 4);
700
701 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
702 return retval;
703
704 buffer += unaligned;
705 address += unaligned;
706 size -= unaligned;
707 }
708
709 /* handle aligned words */
710 if (size >= 4)
711 {
712 int aligned = size - (size % 4);
713
714 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
715 return retval;
716
717 buffer += aligned;
718 address += aligned;
719 size -= aligned;
720 }
721
722 /* handle tail writes of less than 4 bytes */
723 if (size > 0)
724 {
725 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
726 return retval;
727 }
728
729 return ERROR_OK;
730 }
731
732 int target_read_u32(struct target_s *target, u32 address, u32 *value)
733 {
734 u8 value_buf[4];
735
736 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
737
738 if (retval == ERROR_OK)
739 {
740 *value = target_buffer_get_u32(target, value_buf);
741 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
742 }
743 else
744 {
745 *value = 0x0;
746 DEBUG("address: 0x%8.8x failed", address);
747 }
748
749 return retval;
750 }
751
752 int target_read_u16(struct target_s *target, u32 address, u16 *value)
753 {
754 u8 value_buf[2];
755
756 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
757
758 if (retval == ERROR_OK)
759 {
760 *value = target_buffer_get_u16(target, value_buf);
761 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
762 }
763 else
764 {
765 *value = 0x0;
766 DEBUG("address: 0x%8.8x failed", address);
767 }
768
769 return retval;
770 }
771
772 int target_read_u8(struct target_s *target, u32 address, u8 *value)
773 {
774 int retval = target->type->read_memory(target, address, 1, 1, value);
775
776 if (retval == ERROR_OK)
777 {
778 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
779 }
780 else
781 {
782 *value = 0x0;
783 DEBUG("address: 0x%8.8x failed", address);
784 }
785
786 return retval;
787 }
788
789 int target_write_u32(struct target_s *target, u32 address, u32 value)
790 {
791 int retval;
792 u8 value_buf[4];
793
794 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
795
796 target_buffer_set_u32(target, value_buf, value);
797 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
798 {
799 DEBUG("failed: %i", retval);
800 }
801
802 return retval;
803 }
804
805 int target_write_u16(struct target_s *target, u32 address, u16 value)
806 {
807 int retval;
808 u8 value_buf[2];
809
810 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
811
812 target_buffer_set_u16(target, value_buf, value);
813 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
814 {
815 DEBUG("failed: %i", retval);
816 }
817
818 return retval;
819 }
820
821 int target_write_u8(struct target_s *target, u32 address, u8 value)
822 {
823 int retval;
824
825 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
826
827 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
828 {
829 DEBUG("failed: %i", retval);
830 }
831
832 return retval;
833 }
834
835 int target_register_user_commands(struct command_context_s *cmd_ctx)
836 {
837 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
838 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
839 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
840 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
841 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
842 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction");
843 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
844 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
845
846 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
847 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
848 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
849
850 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
851 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
852 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
853
854 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
855 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
856 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
857 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
858
859 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex']");
860 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
861 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
862 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
863
864 return ERROR_OK;
865 }
866
867 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
868 {
869 target_t *target = targets;
870 int count = 0;
871
872 if (argc == 1)
873 {
874 int num = strtoul(args[0], NULL, 0);
875
876 while (target)
877 {
878 count++;
879 target = target->next;
880 }
881
882 if (num < count)
883 cmd_ctx->current_target = num;
884 else
885 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
886
887 return ERROR_OK;
888 }
889
890 while (target)
891 {
892 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
893 target = target->next;
894 }
895
896 return ERROR_OK;
897 }
898
899 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
900 {
901 int i;
902 int found = 0;
903
904 if (argc < 3)
905 {
906 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
907 exit(-1);
908 }
909
910 /* search for the specified target */
911 if (args[0] && (args[0][0] != 0))
912 {
913 for (i = 0; target_types[i]; i++)
914 {
915 if (strcmp(args[0], target_types[i]->name) == 0)
916 {
917 target_t **last_target_p = &targets;
918
919 /* register target specific commands */
920 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
921 {
922 ERROR("couldn't register '%s' commands", args[0]);
923 exit(-1);
924 }
925
926 if (*last_target_p)
927 {
928 while ((*last_target_p)->next)
929 last_target_p = &((*last_target_p)->next);
930 last_target_p = &((*last_target_p)->next);
931 }
932
933 *last_target_p = malloc(sizeof(target_t));
934
935 (*last_target_p)->type = target_types[i];
936
937 if (strcmp(args[1], "big") == 0)
938 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
939 else if (strcmp(args[1], "little") == 0)
940 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
941 else
942 {
943 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
944 exit(-1);
945 }
946
947 /* what to do on a target reset */
948 if (strcmp(args[2], "reset_halt") == 0)
949 (*last_target_p)->reset_mode = RESET_HALT;
950 else if (strcmp(args[2], "reset_run") == 0)
951 (*last_target_p)->reset_mode = RESET_RUN;
952 else if (strcmp(args[2], "reset_init") == 0)
953 (*last_target_p)->reset_mode = RESET_INIT;
954 else if (strcmp(args[2], "run_and_halt") == 0)
955 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
956 else if (strcmp(args[2], "run_and_init") == 0)
957 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
958 else
959 {
960 ERROR("unknown target startup mode %s", args[2]);
961 exit(-1);
962 }
963 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
964
965 (*last_target_p)->reset_script = NULL;
966 (*last_target_p)->post_halt_script = NULL;
967 (*last_target_p)->pre_resume_script = NULL;
968
969 (*last_target_p)->working_area = 0x0;
970 (*last_target_p)->working_area_size = 0x0;
971 (*last_target_p)->working_areas = NULL;
972 (*last_target_p)->backup_working_area = 0;
973
974 (*last_target_p)->state = TARGET_UNKNOWN;
975 (*last_target_p)->reg_cache = NULL;
976 (*last_target_p)->breakpoints = NULL;
977 (*last_target_p)->watchpoints = NULL;
978 (*last_target_p)->next = NULL;
979 (*last_target_p)->arch_info = NULL;
980
981 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
982
983 found = 1;
984 break;
985 }
986 }
987 }
988
989 /* no matching target found */
990 if (!found)
991 {
992 ERROR("target '%s' not found", args[0]);
993 exit(-1);
994 }
995
996 return ERROR_OK;
997 }
998
999 /* usage: target_script <target#> <event> <script_file> */
1000 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1001 {
1002 target_t *target = NULL;
1003
1004 if (argc < 3)
1005 {
1006 ERROR("incomplete target_script command");
1007 exit(-1);
1008 }
1009
1010 target = get_target_by_num(strtoul(args[0], NULL, 0));
1011
1012 if (!target)
1013 {
1014 ERROR("target number '%s' not defined", args[0]);
1015 exit(-1);
1016 }
1017
1018 if (strcmp(args[1], "reset") == 0)
1019 {
1020 if (target->reset_script)
1021 free(target->reset_script);
1022 target->reset_script = strdup(args[2]);
1023 }
1024 else if (strcmp(args[1], "post_halt") == 0)
1025 {
1026 if (target->post_halt_script)
1027 free(target->post_halt_script);
1028 target->post_halt_script = strdup(args[2]);
1029 }
1030 else if (strcmp(args[1], "pre_resume") == 0)
1031 {
1032 if (target->pre_resume_script)
1033 free(target->pre_resume_script);
1034 target->pre_resume_script = strdup(args[2]);
1035 }
1036 else
1037 {
1038 ERROR("unknown event type: '%s", args[1]);
1039 exit(-1);
1040 }
1041
1042 return ERROR_OK;
1043 }
1044
1045 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1046 {
1047 target_t *target = NULL;
1048
1049 if (argc < 2)
1050 {
1051 ERROR("incomplete run_and_halt_time command");
1052 exit(-1);
1053 }
1054
1055 target = get_target_by_num(strtoul(args[0], NULL, 0));
1056
1057 if (!target)
1058 {
1059 ERROR("target number '%s' not defined", args[0]);
1060 exit(-1);
1061 }
1062
1063 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1064
1065 return ERROR_OK;
1066 }
1067
1068 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1069 {
1070 target_t *target = NULL;
1071
1072 if (argc < 4)
1073 {
1074 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1075 exit(-1);
1076 }
1077
1078 target = get_target_by_num(strtoul(args[0], NULL, 0));
1079
1080 if (!target)
1081 {
1082 ERROR("target number '%s' not defined", args[0]);
1083 exit(-1);
1084 }
1085
1086 target->working_area = strtoul(args[1], NULL, 0);
1087 target->working_area_size = strtoul(args[2], NULL, 0);
1088
1089 if (strcmp(args[3], "backup") == 0)
1090 {
1091 target->backup_working_area = 1;
1092 }
1093 else if (strcmp(args[3], "nobackup") == 0)
1094 {
1095 target->backup_working_area = 0;
1096 }
1097 else
1098 {
1099 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1100 exit(-1);
1101 }
1102
1103 return ERROR_OK;
1104 }
1105
1106
1107 /* process target state changes */
1108 int handle_target(void *priv)
1109 {
1110 int retval;
1111 target_t *target = targets;
1112
1113 while (target)
1114 {
1115 /* only poll if target isn't already halted */
1116 if (target->state != TARGET_HALTED)
1117 {
1118 if (target_continous_poll)
1119 if ((retval = target->type->poll(target)) < 0)
1120 {
1121 ERROR("couldn't poll target, exiting");
1122 exit(-1);
1123 }
1124 }
1125
1126 target = target->next;
1127 }
1128
1129 return ERROR_OK;
1130 }
1131
1132 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1133 {
1134 target_t *target;
1135 reg_t *reg = NULL;
1136 int count = 0;
1137 char *value;
1138
1139 DEBUG("-");
1140
1141 target = get_current_target(cmd_ctx);
1142
1143 /* list all available registers for the current target */
1144 if (argc == 0)
1145 {
1146 reg_cache_t *cache = target->reg_cache;
1147
1148 count = 0;
1149 while(cache)
1150 {
1151 int i;
1152 for (i = 0; i < cache->num_regs; i++)
1153 {
1154 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1155 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);
1156 free(value);
1157 }
1158 cache = cache->next;
1159 }
1160
1161 return ERROR_OK;
1162 }
1163
1164 /* access a single register by its ordinal number */
1165 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1166 {
1167 int num = strtoul(args[0], NULL, 0);
1168 reg_cache_t *cache = target->reg_cache;
1169
1170 count = 0;
1171 while(cache)
1172 {
1173 int i;
1174 for (i = 0; i < cache->num_regs; i++)
1175 {
1176 if (count++ == num)
1177 {
1178 reg = &cache->reg_list[i];
1179 break;
1180 }
1181 }
1182 if (reg)
1183 break;
1184 cache = cache->next;
1185 }
1186
1187 if (!reg)
1188 {
1189 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1190 return ERROR_OK;
1191 }
1192 } else /* access a single register by its name */
1193 {
1194 reg = register_get_by_name(target->reg_cache, args[0], 1);
1195
1196 if (!reg)
1197 {
1198 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1199 return ERROR_OK;
1200 }
1201 }
1202
1203 /* display a register */
1204 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1205 {
1206 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1207 reg->valid = 0;
1208
1209 if (reg->valid == 0)
1210 {
1211 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1212 if (arch_type == NULL)
1213 {
1214 ERROR("BUG: encountered unregistered arch type");
1215 return ERROR_OK;
1216 }
1217 arch_type->get(reg);
1218 }
1219 value = buf_to_str(reg->value, reg->size, 16);
1220 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1221 free(value);
1222 return ERROR_OK;
1223 }
1224
1225 /* set register value */
1226 if (argc == 2)
1227 {
1228 u8 *buf = malloc(CEIL(reg->size, 8));
1229 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1230
1231 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1232 if (arch_type == NULL)
1233 {
1234 ERROR("BUG: encountered unregistered arch type");
1235 return ERROR_OK;
1236 }
1237
1238 arch_type->set(reg, buf);
1239
1240 value = buf_to_str(reg->value, reg->size, 16);
1241 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1242 free(value);
1243
1244 free(buf);
1245
1246 return ERROR_OK;
1247 }
1248
1249 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1250
1251 return ERROR_OK;
1252 }
1253
1254 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1255 {
1256 target_t *target = get_current_target(cmd_ctx);
1257 char buffer[512];
1258
1259 if (argc == 0)
1260 {
1261 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1262 if (target->state == TARGET_HALTED)
1263 {
1264 target->type->arch_state(target, buffer, 512);
1265 buffer[511] = 0;
1266 command_print(cmd_ctx, "%s", buffer);
1267 }
1268 }
1269 else
1270 {
1271 if (strcmp(args[0], "on") == 0)
1272 {
1273 target_continous_poll = 1;
1274 }
1275 else if (strcmp(args[0], "off") == 0)
1276 {
1277 target_continous_poll = 0;
1278 }
1279 }
1280
1281
1282 return ERROR_OK;
1283 }
1284
1285 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1286 {
1287 target_t *target = get_current_target(cmd_ctx);
1288 struct timeval timeout, now;
1289
1290 gettimeofday(&timeout, NULL);
1291 if (!argc)
1292 timeval_add_time(&timeout, 5, 0);
1293 else {
1294 char *end;
1295
1296 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1297 if (*end) {
1298 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1299 return ERROR_OK;
1300 }
1301 }
1302
1303 command_print(cmd_ctx, "waiting for target halted...");
1304
1305 while(target->type->poll(target))
1306 {
1307 if (target->state == TARGET_HALTED)
1308 {
1309 command_print(cmd_ctx, "target halted");
1310 break;
1311 }
1312 target_call_timer_callbacks();
1313
1314 gettimeofday(&now, NULL);
1315 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1316 {
1317 command_print(cmd_ctx, "timed out while waiting for target halt");
1318 ERROR("timed out while waiting for target halt");
1319 break;
1320 }
1321 }
1322
1323 return ERROR_OK;
1324 }
1325
1326 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1327 {
1328 int retval;
1329 target_t *target = get_current_target(cmd_ctx);
1330
1331 DEBUG("-");
1332
1333 command_print(cmd_ctx, "requesting target halt...");
1334
1335 if ((retval = target->type->halt(target)) != ERROR_OK)
1336 {
1337 switch (retval)
1338 {
1339 case ERROR_TARGET_ALREADY_HALTED:
1340 command_print(cmd_ctx, "target already halted");
1341 break;
1342 case ERROR_TARGET_TIMEOUT:
1343 command_print(cmd_ctx, "target timed out... shutting down");
1344 exit(-1);
1345 default:
1346 command_print(cmd_ctx, "unknown error... shutting down");
1347 exit(-1);
1348 }
1349 }
1350
1351 return ERROR_OK;
1352
1353 }
1354
1355 /* what to do on daemon startup */
1356 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1357 {
1358 if (argc == 1)
1359 {
1360 if (strcmp(args[0], "attach") == 0)
1361 {
1362 startup_mode = DAEMON_ATTACH;
1363 return ERROR_OK;
1364 }
1365 else if (strcmp(args[0], "reset") == 0)
1366 {
1367 startup_mode = DAEMON_RESET;
1368 return ERROR_OK;
1369 }
1370 }
1371
1372 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1373 return ERROR_OK;
1374
1375 }
1376
1377 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1378 {
1379 target_t *target = get_current_target(cmd_ctx);
1380 int retval;
1381
1382 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1383
1384 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1385 {
1386 switch (retval)
1387 {
1388 case ERROR_TARGET_TIMEOUT:
1389 command_print(cmd_ctx, "target timed out... shutting down");
1390 exit(-1);
1391 default:
1392 command_print(cmd_ctx, "unknown error... shutting down");
1393 exit(-1);
1394 }
1395 }
1396
1397 return ERROR_OK;
1398 }
1399
1400 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1401 {
1402 target_t *target = get_current_target(cmd_ctx);
1403 enum target_reset_mode reset_mode = RESET_RUN;
1404
1405 DEBUG("-");
1406
1407 if (argc >= 1)
1408 {
1409 if (strcmp("run", args[0]) == 0)
1410 reset_mode = RESET_RUN;
1411 else if (strcmp("halt", args[0]) == 0)
1412 reset_mode = RESET_HALT;
1413 else if (strcmp("init", args[0]) == 0)
1414 reset_mode = RESET_INIT;
1415 else if (strcmp("run_and_halt", args[0]) == 0)
1416 {
1417 reset_mode = RESET_RUN_AND_HALT;
1418 if (argc >= 2)
1419 {
1420 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1421 }
1422 }
1423 else if (strcmp("run_and_init", args[0]) == 0)
1424 {
1425 reset_mode = RESET_RUN_AND_INIT;
1426 if (argc >= 2)
1427 {
1428 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1429 }
1430 }
1431 else
1432 {
1433 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1434 return ERROR_OK;
1435 }
1436 target->reset_mode = reset_mode;
1437 }
1438
1439 target_process_reset(cmd_ctx);
1440
1441 return ERROR_OK;
1442 }
1443
1444 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1445 {
1446 int retval;
1447 target_t *target = get_current_target(cmd_ctx);
1448
1449 DEBUG("-");
1450
1451 if (argc == 0)
1452 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1453 else if (argc == 1)
1454 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1455 else
1456 {
1457 command_print(cmd_ctx, "usage: resume [address]");
1458 return ERROR_OK;
1459 }
1460
1461 if (retval != ERROR_OK)
1462 {
1463 switch (retval)
1464 {
1465 case ERROR_TARGET_NOT_HALTED:
1466 command_print(cmd_ctx, "target not halted");
1467 break;
1468 default:
1469 command_print(cmd_ctx, "unknown error... shutting down");
1470 exit(-1);
1471 }
1472 }
1473
1474 return ERROR_OK;
1475 }
1476
1477 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1478 {
1479 target_t *target = get_current_target(cmd_ctx);
1480
1481 DEBUG("-");
1482
1483 if (argc == 0)
1484 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1485
1486 if (argc == 1)
1487 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1488
1489 return ERROR_OK;
1490 }
1491
1492 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1493 {
1494 int count = 1;
1495 int size = 4;
1496 u32 address = 0;
1497 int i;
1498
1499 char output[128];
1500 int output_len;
1501
1502 int retval;
1503
1504 u8 *buffer;
1505 target_t *target = get_current_target(cmd_ctx);
1506
1507 if (argc < 1)
1508 return ERROR_OK;
1509
1510 if (argc == 2)
1511 count = strtoul(args[1], NULL, 0);
1512
1513 address = strtoul(args[0], NULL, 0);
1514
1515
1516 switch (cmd[2])
1517 {
1518 case 'w':
1519 size = 4;
1520 break;
1521 case 'h':
1522 size = 2;
1523 break;
1524 case 'b':
1525 size = 1;
1526 break;
1527 default:
1528 return ERROR_OK;
1529 }
1530
1531 buffer = calloc(count, size);
1532 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1533 {
1534 switch (retval)
1535 {
1536 case ERROR_TARGET_UNALIGNED_ACCESS:
1537 command_print(cmd_ctx, "error: address not aligned");
1538 break;
1539 case ERROR_TARGET_NOT_HALTED:
1540 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1541 break;
1542 case ERROR_TARGET_DATA_ABORT:
1543 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1544 break;
1545 default:
1546 command_print(cmd_ctx, "error: unknown error");
1547 break;
1548 }
1549 return ERROR_OK;
1550 }
1551
1552 output_len = 0;
1553
1554 for (i = 0; i < count; i++)
1555 {
1556 if (i%8 == 0)
1557 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1558
1559 switch (size)
1560 {
1561 case 4:
1562 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1563 break;
1564 case 2:
1565 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1566 break;
1567 case 1:
1568 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1569 break;
1570 }
1571
1572 if ((i%8 == 7) || (i == count - 1))
1573 {
1574 command_print(cmd_ctx, output);
1575 output_len = 0;
1576 }
1577 }
1578
1579 free(buffer);
1580
1581 return ERROR_OK;
1582 }
1583
1584 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1585 {
1586 u32 address = 0;
1587 u32 value = 0;
1588 int retval;
1589 target_t *target = get_current_target(cmd_ctx);
1590 u8 value_buf[4];
1591
1592 if (argc < 2)
1593 return ERROR_OK;
1594
1595 address = strtoul(args[0], NULL, 0);
1596 value = strtoul(args[1], NULL, 0);
1597
1598 switch (cmd[2])
1599 {
1600 case 'w':
1601 target_buffer_set_u32(target, value_buf, value);
1602 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1603 break;
1604 case 'h':
1605 target_buffer_set_u16(target, value_buf, value);
1606 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1607 break;
1608 case 'b':
1609 value_buf[0] = value;
1610 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1611 break;
1612 default:
1613 return ERROR_OK;
1614 }
1615
1616 switch (retval)
1617 {
1618 case ERROR_TARGET_UNALIGNED_ACCESS:
1619 command_print(cmd_ctx, "error: address not aligned");
1620 break;
1621 case ERROR_TARGET_DATA_ABORT:
1622 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1623 break;
1624 case ERROR_TARGET_NOT_HALTED:
1625 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1626 break;
1627 case ERROR_OK:
1628 break;
1629 default:
1630 command_print(cmd_ctx, "error: unknown error");
1631 break;
1632 }
1633
1634 return ERROR_OK;
1635
1636 }
1637
1638 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1639 {
1640 u32 address;
1641 u8 *buffer;
1642 u32 buf_cnt;
1643 u32 binary_size;
1644
1645 fileio_t file;
1646 enum fileio_pri_type pri_type = FILEIO_IMAGE;
1647 fileio_image_t image_info;
1648 enum fileio_sec_type sec_type;
1649
1650 duration_t duration;
1651 char *duration_text;
1652
1653 target_t *target = get_current_target(cmd_ctx);
1654
1655 if (argc < 2)
1656 {
1657 command_print(cmd_ctx, "usage: load_image <filename> <address> [type]");
1658 return ERROR_OK;
1659 }
1660
1661 memset(&file, 0, sizeof(fileio_t));
1662 fileio_identify_image_type(&sec_type, (argc == 3) ? args[2] : NULL);
1663
1664 image_info.base_address = strtoul(args[1], NULL, 0);
1665 image_info.has_start_address = 0;
1666
1667 buffer = malloc(128 * 1024);
1668
1669 duration_start_measure(&duration);
1670
1671 if (fileio_open(&file, args[0], FILEIO_READ,
1672 pri_type, &image_info, sec_type) != ERROR_OK)
1673 {
1674 command_print(cmd_ctx, "load_image error: %s", file.error_str);
1675 return ERROR_OK;
1676 }
1677
1678 binary_size = file.size;
1679 address = image_info.base_address;
1680 while ((binary_size > 0) &&
1681 (fileio_read(&file, 128 * 1024, buffer, &buf_cnt) == ERROR_OK))
1682 {
1683 target_write_buffer(target, address, buf_cnt, buffer);
1684 address += buf_cnt;
1685 binary_size -= buf_cnt;
1686 }
1687
1688 free(buffer);
1689
1690 duration_stop_measure(&duration, &duration_text);
1691 command_print(cmd_ctx, "downloaded %lli byte in %s", file.size, duration_text);
1692 free(duration_text);
1693
1694 fileio_close(&file);
1695
1696 return ERROR_OK;
1697
1698 }
1699
1700 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1701 {
1702 fileio_t file;
1703 fileio_image_t image_info;
1704
1705 u32 address;
1706 u32 size;
1707 u8 buffer[560];
1708
1709 duration_t duration;
1710 char *duration_text;
1711
1712 target_t *target = get_current_target(cmd_ctx);
1713
1714 if (argc != 3)
1715 {
1716 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1717 return ERROR_OK;
1718 }
1719
1720 address = strtoul(args[1], NULL, 0);
1721 size = strtoul(args[2], NULL, 0);
1722
1723 if ((address & 3) || (size & 3))
1724 {
1725 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1726 return ERROR_OK;
1727 }
1728
1729 image_info.base_address = address;
1730 image_info.has_start_address = 0;
1731
1732 if (fileio_open(&file, args[0], FILEIO_WRITE,
1733 FILEIO_IMAGE, &image_info, FILEIO_PLAIN) != ERROR_OK)
1734 {
1735 command_print(cmd_ctx, "dump_image error: %s", file.error_str);
1736 return ERROR_OK;
1737 }
1738
1739 duration_start_measure(&duration);
1740
1741 while (size > 0)
1742 {
1743 u32 size_written;
1744 u32 this_run_size = (size > 560) ? 560 : size;
1745
1746 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1747 fileio_write(&file, this_run_size, buffer, &size_written);
1748
1749 size -= this_run_size;
1750 address += this_run_size;
1751 }
1752
1753 fileio_close(&file);
1754
1755 duration_stop_measure(&duration, &duration_text);
1756 command_print(cmd_ctx, "dumped %lli byte in %s", file.size, duration_text);
1757 free(duration_text);
1758
1759 return ERROR_OK;
1760
1761 }
1762
1763 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1764 {
1765 int retval;
1766 target_t *target = get_current_target(cmd_ctx);
1767
1768 if (argc == 0)
1769 {
1770 breakpoint_t *breakpoint = target->breakpoints;
1771
1772 while (breakpoint)
1773 {
1774 if (breakpoint->type == BKPT_SOFT)
1775 {
1776 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1777 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1778 free(buf);
1779 }
1780 else
1781 {
1782 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1783 }
1784 breakpoint = breakpoint->next;
1785 }
1786 }
1787 else if (argc >= 2)
1788 {
1789 int hw = BKPT_SOFT;
1790 u32 length = 0;
1791
1792 length = strtoul(args[1], NULL, 0);
1793
1794 if (argc >= 3)
1795 if (strcmp(args[2], "hw") == 0)
1796 hw = BKPT_HARD;
1797
1798 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1799 {
1800 switch (retval)
1801 {
1802 case ERROR_TARGET_NOT_HALTED:
1803 command_print(cmd_ctx, "target must be halted to set breakpoints");
1804 break;
1805 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1806 command_print(cmd_ctx, "no more breakpoints available");
1807 break;
1808 default:
1809 command_print(cmd_ctx, "unknown error, breakpoint not set");
1810 break;
1811 }
1812 }
1813 else
1814 {
1815 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1816 }
1817 }
1818 else
1819 {
1820 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1821 }
1822
1823 return ERROR_OK;
1824 }
1825
1826 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1827 {
1828 target_t *target = get_current_target(cmd_ctx);
1829
1830 if (argc > 0)
1831 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1832
1833 return ERROR_OK;
1834 }
1835
1836 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1837 {
1838 target_t *target = get_current_target(cmd_ctx);
1839
1840 if (argc == 0)
1841 {
1842 watchpoint_t *watchpoint = target->watchpoints;
1843
1844 while (watchpoint)
1845 {
1846 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);
1847 watchpoint = watchpoint->next;
1848 }
1849 }
1850 else if (argc >= 2)
1851 {
1852 enum watchpoint_rw type = WPT_ACCESS;
1853 u32 data_value = 0x0;
1854 u32 data_mask = 0xffffffff;
1855
1856 if (argc >= 3)
1857 {
1858 switch(args[2][0])
1859 {
1860 case 'r':
1861 type = WPT_READ;
1862 break;
1863 case 'w':
1864 type = WPT_WRITE;
1865 break;
1866 case 'a':
1867 type = WPT_ACCESS;
1868 break;
1869 default:
1870 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1871 return ERROR_OK;
1872 }
1873 }
1874 if (argc >= 4)
1875 {
1876 data_value = strtoul(args[3], NULL, 0);
1877 }
1878 if (argc >= 5)
1879 {
1880 data_mask = strtoul(args[4], NULL, 0);
1881 }
1882 watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask);
1883 }
1884 else
1885 {
1886 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1887 }
1888
1889 return ERROR_OK;
1890 }
1891
1892 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1893 {
1894 target_t *target = get_current_target(cmd_ctx);
1895
1896 if (argc > 0)
1897 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1898
1899 return ERROR_OK;
1900 }
1901
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)