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