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