Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- motorola s19 file loader added
[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 return ERROR_OK;
657 }
658
659 /* handle unaligned head bytes */
660 if (address % 4)
661 {
662 int unaligned = 4 - (address % 4);
663
664 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
665 return retval;
666
667 buffer += unaligned;
668 address += unaligned;
669 size -= unaligned;
670 }
671
672 /* handle aligned words */
673 if (size >= 4)
674 {
675 int aligned = size - (size % 4);
676
677 /* use bulk writes above a certain limit. This may have to be changed */
678 if (aligned > 128)
679 {
680 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
681 return retval;
682 }
683 else
684 {
685 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
686 return retval;
687 }
688
689 buffer += aligned;
690 address += aligned;
691 size -= aligned;
692 }
693
694 /* handle tail writes of less than 4 bytes */
695 if (size > 0)
696 {
697 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
698 return retval;
699 }
700
701 return ERROR_OK;
702 }
703
704 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
705 {
706 int retval;
707
708 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
709
710 /* handle reads of less than 4 byte */
711 if (size < 4)
712 {
713 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
714 return retval;
715 return ERROR_OK;
716 }
717
718 /* handle unaligned head bytes */
719 if (address % 4)
720 {
721 int unaligned = 4 - (address % 4);
722
723 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
724 return retval;
725
726 buffer += unaligned;
727 address += unaligned;
728 size -= unaligned;
729 }
730
731 /* handle aligned words */
732 if (size >= 4)
733 {
734 int aligned = size - (size % 4);
735
736 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
737 return retval;
738
739 buffer += aligned;
740 address += aligned;
741 size -= aligned;
742 }
743
744 /* handle tail writes of less than 4 bytes */
745 if (size > 0)
746 {
747 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
748 return retval;
749 }
750
751 return ERROR_OK;
752 }
753
754 int target_read_u32(struct target_s *target, u32 address, u32 *value)
755 {
756 u8 value_buf[4];
757
758 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
759
760 if (retval == ERROR_OK)
761 {
762 *value = target_buffer_get_u32(target, value_buf);
763 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
764 }
765 else
766 {
767 *value = 0x0;
768 DEBUG("address: 0x%8.8x failed", address);
769 }
770
771 return retval;
772 }
773
774 int target_read_u16(struct target_s *target, u32 address, u16 *value)
775 {
776 u8 value_buf[2];
777
778 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
779
780 if (retval == ERROR_OK)
781 {
782 *value = target_buffer_get_u16(target, value_buf);
783 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
784 }
785 else
786 {
787 *value = 0x0;
788 DEBUG("address: 0x%8.8x failed", address);
789 }
790
791 return retval;
792 }
793
794 int target_read_u8(struct target_s *target, u32 address, u8 *value)
795 {
796 int retval = target->type->read_memory(target, address, 1, 1, value);
797
798 if (retval == ERROR_OK)
799 {
800 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
801 }
802 else
803 {
804 *value = 0x0;
805 DEBUG("address: 0x%8.8x failed", address);
806 }
807
808 return retval;
809 }
810
811 int target_write_u32(struct target_s *target, u32 address, u32 value)
812 {
813 int retval;
814 u8 value_buf[4];
815
816 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
817
818 target_buffer_set_u32(target, value_buf, value);
819 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
820 {
821 DEBUG("failed: %i", retval);
822 }
823
824 return retval;
825 }
826
827 int target_write_u16(struct target_s *target, u32 address, u16 value)
828 {
829 int retval;
830 u8 value_buf[2];
831
832 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
833
834 target_buffer_set_u16(target, value_buf, value);
835 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
836 {
837 DEBUG("failed: %i", retval);
838 }
839
840 return retval;
841 }
842
843 int target_write_u8(struct target_s *target, u32 address, u8 value)
844 {
845 int retval;
846
847 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
848
849 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
850 {
851 DEBUG("failed: %i", retval);
852 }
853
854 return retval;
855 }
856
857 int target_register_user_commands(struct command_context_s *cmd_ctx)
858 {
859 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
860 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
861 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
862 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
863 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
864 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction");
865 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
866 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
867
868 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
869 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
870 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
871
872 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
873 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
874 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
875
876 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
877 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
878 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
879 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
880
881 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
882 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
883 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
884 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
885
886 return ERROR_OK;
887 }
888
889 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
890 {
891 target_t *target = targets;
892 int count = 0;
893
894 if (argc == 1)
895 {
896 int num = strtoul(args[0], NULL, 0);
897
898 while (target)
899 {
900 count++;
901 target = target->next;
902 }
903
904 if (num < count)
905 cmd_ctx->current_target = num;
906 else
907 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
908
909 return ERROR_OK;
910 }
911
912 while (target)
913 {
914 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
915 target = target->next;
916 }
917
918 return ERROR_OK;
919 }
920
921 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
922 {
923 int i;
924 int found = 0;
925
926 if (argc < 3)
927 {
928 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
929 exit(-1);
930 }
931
932 /* search for the specified target */
933 if (args[0] && (args[0][0] != 0))
934 {
935 for (i = 0; target_types[i]; i++)
936 {
937 if (strcmp(args[0], target_types[i]->name) == 0)
938 {
939 target_t **last_target_p = &targets;
940
941 /* register target specific commands */
942 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
943 {
944 ERROR("couldn't register '%s' commands", args[0]);
945 exit(-1);
946 }
947
948 if (*last_target_p)
949 {
950 while ((*last_target_p)->next)
951 last_target_p = &((*last_target_p)->next);
952 last_target_p = &((*last_target_p)->next);
953 }
954
955 *last_target_p = malloc(sizeof(target_t));
956
957 (*last_target_p)->type = target_types[i];
958
959 if (strcmp(args[1], "big") == 0)
960 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
961 else if (strcmp(args[1], "little") == 0)
962 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
963 else
964 {
965 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
966 exit(-1);
967 }
968
969 /* what to do on a target reset */
970 if (strcmp(args[2], "reset_halt") == 0)
971 (*last_target_p)->reset_mode = RESET_HALT;
972 else if (strcmp(args[2], "reset_run") == 0)
973 (*last_target_p)->reset_mode = RESET_RUN;
974 else if (strcmp(args[2], "reset_init") == 0)
975 (*last_target_p)->reset_mode = RESET_INIT;
976 else if (strcmp(args[2], "run_and_halt") == 0)
977 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
978 else if (strcmp(args[2], "run_and_init") == 0)
979 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
980 else
981 {
982 ERROR("unknown target startup mode %s", args[2]);
983 exit(-1);
984 }
985 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
986
987 (*last_target_p)->reset_script = NULL;
988 (*last_target_p)->post_halt_script = NULL;
989 (*last_target_p)->pre_resume_script = NULL;
990
991 (*last_target_p)->working_area = 0x0;
992 (*last_target_p)->working_area_size = 0x0;
993 (*last_target_p)->working_areas = NULL;
994 (*last_target_p)->backup_working_area = 0;
995
996 (*last_target_p)->state = TARGET_UNKNOWN;
997 (*last_target_p)->reg_cache = NULL;
998 (*last_target_p)->breakpoints = NULL;
999 (*last_target_p)->watchpoints = NULL;
1000 (*last_target_p)->next = NULL;
1001 (*last_target_p)->arch_info = NULL;
1002
1003 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1004
1005 found = 1;
1006 break;
1007 }
1008 }
1009 }
1010
1011 /* no matching target found */
1012 if (!found)
1013 {
1014 ERROR("target '%s' not found", args[0]);
1015 exit(-1);
1016 }
1017
1018 return ERROR_OK;
1019 }
1020
1021 /* usage: target_script <target#> <event> <script_file> */
1022 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1023 {
1024 target_t *target = NULL;
1025
1026 if (argc < 3)
1027 {
1028 ERROR("incomplete target_script command");
1029 exit(-1);
1030 }
1031
1032 target = get_target_by_num(strtoul(args[0], NULL, 0));
1033
1034 if (!target)
1035 {
1036 ERROR("target number '%s' not defined", args[0]);
1037 exit(-1);
1038 }
1039
1040 if (strcmp(args[1], "reset") == 0)
1041 {
1042 if (target->reset_script)
1043 free(target->reset_script);
1044 target->reset_script = strdup(args[2]);
1045 }
1046 else if (strcmp(args[1], "post_halt") == 0)
1047 {
1048 if (target->post_halt_script)
1049 free(target->post_halt_script);
1050 target->post_halt_script = strdup(args[2]);
1051 }
1052 else if (strcmp(args[1], "pre_resume") == 0)
1053 {
1054 if (target->pre_resume_script)
1055 free(target->pre_resume_script);
1056 target->pre_resume_script = strdup(args[2]);
1057 }
1058 else
1059 {
1060 ERROR("unknown event type: '%s", args[1]);
1061 exit(-1);
1062 }
1063
1064 return ERROR_OK;
1065 }
1066
1067 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1068 {
1069 target_t *target = NULL;
1070
1071 if (argc < 2)
1072 {
1073 ERROR("incomplete run_and_halt_time command");
1074 exit(-1);
1075 }
1076
1077 target = get_target_by_num(strtoul(args[0], NULL, 0));
1078
1079 if (!target)
1080 {
1081 ERROR("target number '%s' not defined", args[0]);
1082 exit(-1);
1083 }
1084
1085 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1086
1087 return ERROR_OK;
1088 }
1089
1090 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1091 {
1092 target_t *target = NULL;
1093
1094 if (argc < 4)
1095 {
1096 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1097 exit(-1);
1098 }
1099
1100 target = get_target_by_num(strtoul(args[0], NULL, 0));
1101
1102 if (!target)
1103 {
1104 ERROR("target number '%s' not defined", args[0]);
1105 exit(-1);
1106 }
1107
1108 target->working_area = strtoul(args[1], NULL, 0);
1109 target->working_area_size = strtoul(args[2], NULL, 0);
1110
1111 if (strcmp(args[3], "backup") == 0)
1112 {
1113 target->backup_working_area = 1;
1114 }
1115 else if (strcmp(args[3], "nobackup") == 0)
1116 {
1117 target->backup_working_area = 0;
1118 }
1119 else
1120 {
1121 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1122 exit(-1);
1123 }
1124
1125 return ERROR_OK;
1126 }
1127
1128
1129 /* process target state changes */
1130 int handle_target(void *priv)
1131 {
1132 int retval;
1133 target_t *target = targets;
1134
1135 while (target)
1136 {
1137 /* only poll if target isn't already halted */
1138 if (target->state != TARGET_HALTED)
1139 {
1140 if (target_continous_poll)
1141 if ((retval = target->type->poll(target)) < 0)
1142 {
1143 ERROR("couldn't poll target, exiting");
1144 exit(-1);
1145 }
1146 }
1147
1148 target = target->next;
1149 }
1150
1151 return ERROR_OK;
1152 }
1153
1154 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1155 {
1156 target_t *target;
1157 reg_t *reg = NULL;
1158 int count = 0;
1159 char *value;
1160
1161 DEBUG("-");
1162
1163 target = get_current_target(cmd_ctx);
1164
1165 /* list all available registers for the current target */
1166 if (argc == 0)
1167 {
1168 reg_cache_t *cache = target->reg_cache;
1169
1170 count = 0;
1171 while(cache)
1172 {
1173 int i;
1174 for (i = 0; i < cache->num_regs; i++)
1175 {
1176 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1177 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);
1178 free(value);
1179 }
1180 cache = cache->next;
1181 }
1182
1183 return ERROR_OK;
1184 }
1185
1186 /* access a single register by its ordinal number */
1187 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1188 {
1189 int num = strtoul(args[0], NULL, 0);
1190 reg_cache_t *cache = target->reg_cache;
1191
1192 count = 0;
1193 while(cache)
1194 {
1195 int i;
1196 for (i = 0; i < cache->num_regs; i++)
1197 {
1198 if (count++ == num)
1199 {
1200 reg = &cache->reg_list[i];
1201 break;
1202 }
1203 }
1204 if (reg)
1205 break;
1206 cache = cache->next;
1207 }
1208
1209 if (!reg)
1210 {
1211 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1212 return ERROR_OK;
1213 }
1214 } else /* access a single register by its name */
1215 {
1216 reg = register_get_by_name(target->reg_cache, args[0], 1);
1217
1218 if (!reg)
1219 {
1220 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1221 return ERROR_OK;
1222 }
1223 }
1224
1225 /* display a register */
1226 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1227 {
1228 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1229 reg->valid = 0;
1230
1231 if (reg->valid == 0)
1232 {
1233 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1234 if (arch_type == NULL)
1235 {
1236 ERROR("BUG: encountered unregistered arch type");
1237 return ERROR_OK;
1238 }
1239 arch_type->get(reg);
1240 }
1241 value = buf_to_str(reg->value, reg->size, 16);
1242 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1243 free(value);
1244 return ERROR_OK;
1245 }
1246
1247 /* set register value */
1248 if (argc == 2)
1249 {
1250 u8 *buf = malloc(CEIL(reg->size, 8));
1251 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1252
1253 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1254 if (arch_type == NULL)
1255 {
1256 ERROR("BUG: encountered unregistered arch type");
1257 return ERROR_OK;
1258 }
1259
1260 arch_type->set(reg, buf);
1261
1262 value = buf_to_str(reg->value, reg->size, 16);
1263 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1264 free(value);
1265
1266 free(buf);
1267
1268 return ERROR_OK;
1269 }
1270
1271 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1272
1273 return ERROR_OK;
1274 }
1275
1276 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1277 {
1278 target_t *target = get_current_target(cmd_ctx);
1279 char buffer[512];
1280
1281 if (argc == 0)
1282 {
1283 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1284 if (target->state == TARGET_HALTED)
1285 {
1286 target->type->arch_state(target, buffer, 512);
1287 buffer[511] = 0;
1288 command_print(cmd_ctx, "%s", buffer);
1289 }
1290 }
1291 else
1292 {
1293 if (strcmp(args[0], "on") == 0)
1294 {
1295 target_continous_poll = 1;
1296 }
1297 else if (strcmp(args[0], "off") == 0)
1298 {
1299 target_continous_poll = 0;
1300 }
1301 }
1302
1303
1304 return ERROR_OK;
1305 }
1306
1307 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1308 {
1309 target_t *target = get_current_target(cmd_ctx);
1310 struct timeval timeout, now;
1311
1312 gettimeofday(&timeout, NULL);
1313 if (!argc)
1314 timeval_add_time(&timeout, 5, 0);
1315 else {
1316 char *end;
1317
1318 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1319 if (*end) {
1320 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1321 return ERROR_OK;
1322 }
1323 }
1324
1325 command_print(cmd_ctx, "waiting for target halted...");
1326
1327 while(target->type->poll(target))
1328 {
1329 if (target->state == TARGET_HALTED)
1330 {
1331 command_print(cmd_ctx, "target halted");
1332 break;
1333 }
1334 target_call_timer_callbacks();
1335
1336 gettimeofday(&now, NULL);
1337 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1338 {
1339 command_print(cmd_ctx, "timed out while waiting for target halt");
1340 ERROR("timed out while waiting for target halt");
1341 break;
1342 }
1343 }
1344
1345 return ERROR_OK;
1346 }
1347
1348 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1349 {
1350 int retval;
1351 target_t *target = get_current_target(cmd_ctx);
1352
1353 DEBUG("-");
1354
1355 command_print(cmd_ctx, "requesting target halt...");
1356
1357 if ((retval = target->type->halt(target)) != ERROR_OK)
1358 {
1359 switch (retval)
1360 {
1361 case ERROR_TARGET_ALREADY_HALTED:
1362 command_print(cmd_ctx, "target already halted");
1363 break;
1364 case ERROR_TARGET_TIMEOUT:
1365 command_print(cmd_ctx, "target timed out... shutting down");
1366 exit(-1);
1367 default:
1368 command_print(cmd_ctx, "unknown error... shutting down");
1369 exit(-1);
1370 }
1371 }
1372
1373 return ERROR_OK;
1374
1375 }
1376
1377 /* what to do on daemon startup */
1378 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1379 {
1380 if (argc == 1)
1381 {
1382 if (strcmp(args[0], "attach") == 0)
1383 {
1384 startup_mode = DAEMON_ATTACH;
1385 return ERROR_OK;
1386 }
1387 else if (strcmp(args[0], "reset") == 0)
1388 {
1389 startup_mode = DAEMON_RESET;
1390 return ERROR_OK;
1391 }
1392 }
1393
1394 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1395 return ERROR_OK;
1396
1397 }
1398
1399 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1400 {
1401 target_t *target = get_current_target(cmd_ctx);
1402 int retval;
1403
1404 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1405
1406 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1407 {
1408 switch (retval)
1409 {
1410 case ERROR_TARGET_TIMEOUT:
1411 command_print(cmd_ctx, "target timed out... shutting down");
1412 exit(-1);
1413 default:
1414 command_print(cmd_ctx, "unknown error... shutting down");
1415 exit(-1);
1416 }
1417 }
1418
1419 return ERROR_OK;
1420 }
1421
1422 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1423 {
1424 target_t *target = get_current_target(cmd_ctx);
1425 enum target_reset_mode reset_mode = RESET_RUN;
1426
1427 DEBUG("-");
1428
1429 if (argc >= 1)
1430 {
1431 if (strcmp("run", args[0]) == 0)
1432 reset_mode = RESET_RUN;
1433 else if (strcmp("halt", args[0]) == 0)
1434 reset_mode = RESET_HALT;
1435 else if (strcmp("init", args[0]) == 0)
1436 reset_mode = RESET_INIT;
1437 else if (strcmp("run_and_halt", args[0]) == 0)
1438 {
1439 reset_mode = RESET_RUN_AND_HALT;
1440 if (argc >= 2)
1441 {
1442 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1443 }
1444 }
1445 else if (strcmp("run_and_init", args[0]) == 0)
1446 {
1447 reset_mode = RESET_RUN_AND_INIT;
1448 if (argc >= 2)
1449 {
1450 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1451 }
1452 }
1453 else
1454 {
1455 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1456 return ERROR_OK;
1457 }
1458 target->reset_mode = reset_mode;
1459 }
1460
1461 target_process_reset(cmd_ctx);
1462
1463 return ERROR_OK;
1464 }
1465
1466 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1467 {
1468 int retval;
1469 target_t *target = get_current_target(cmd_ctx);
1470
1471 DEBUG("-");
1472
1473 if (argc == 0)
1474 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1475 else if (argc == 1)
1476 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1477 else
1478 {
1479 command_print(cmd_ctx, "usage: resume [address]");
1480 return ERROR_OK;
1481 }
1482
1483 if (retval != ERROR_OK)
1484 {
1485 switch (retval)
1486 {
1487 case ERROR_TARGET_NOT_HALTED:
1488 command_print(cmd_ctx, "target not halted");
1489 break;
1490 default:
1491 command_print(cmd_ctx, "unknown error... shutting down");
1492 exit(-1);
1493 }
1494 }
1495
1496 return ERROR_OK;
1497 }
1498
1499 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1500 {
1501 target_t *target = get_current_target(cmd_ctx);
1502
1503 DEBUG("-");
1504
1505 if (argc == 0)
1506 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1507
1508 if (argc == 1)
1509 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1510
1511 return ERROR_OK;
1512 }
1513
1514 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1515 {
1516 int count = 1;
1517 int size = 4;
1518 u32 address = 0;
1519 int i;
1520
1521 char output[128];
1522 int output_len;
1523
1524 int retval;
1525
1526 u8 *buffer;
1527 target_t *target = get_current_target(cmd_ctx);
1528
1529 if (argc < 1)
1530 return ERROR_OK;
1531
1532 if (argc == 2)
1533 count = strtoul(args[1], NULL, 0);
1534
1535 address = strtoul(args[0], NULL, 0);
1536
1537
1538 switch (cmd[2])
1539 {
1540 case 'w':
1541 size = 4;
1542 break;
1543 case 'h':
1544 size = 2;
1545 break;
1546 case 'b':
1547 size = 1;
1548 break;
1549 default:
1550 return ERROR_OK;
1551 }
1552
1553 buffer = calloc(count, size);
1554 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1555 {
1556 switch (retval)
1557 {
1558 case ERROR_TARGET_UNALIGNED_ACCESS:
1559 command_print(cmd_ctx, "error: address not aligned");
1560 break;
1561 case ERROR_TARGET_NOT_HALTED:
1562 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1563 break;
1564 case ERROR_TARGET_DATA_ABORT:
1565 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1566 break;
1567 default:
1568 command_print(cmd_ctx, "error: unknown error");
1569 break;
1570 }
1571 return ERROR_OK;
1572 }
1573
1574 output_len = 0;
1575
1576 for (i = 0; i < count; i++)
1577 {
1578 if (i%8 == 0)
1579 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1580
1581 switch (size)
1582 {
1583 case 4:
1584 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1585 break;
1586 case 2:
1587 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1588 break;
1589 case 1:
1590 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1591 break;
1592 }
1593
1594 if ((i%8 == 7) || (i == count - 1))
1595 {
1596 command_print(cmd_ctx, output);
1597 output_len = 0;
1598 }
1599 }
1600
1601 free(buffer);
1602
1603 return ERROR_OK;
1604 }
1605
1606 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1607 {
1608 u32 address = 0;
1609 u32 value = 0;
1610 int retval;
1611 target_t *target = get_current_target(cmd_ctx);
1612 u8 value_buf[4];
1613
1614 if (argc < 2)
1615 return ERROR_OK;
1616
1617 address = strtoul(args[0], NULL, 0);
1618 value = strtoul(args[1], NULL, 0);
1619
1620 switch (cmd[2])
1621 {
1622 case 'w':
1623 target_buffer_set_u32(target, value_buf, value);
1624 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1625 break;
1626 case 'h':
1627 target_buffer_set_u16(target, value_buf, value);
1628 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1629 break;
1630 case 'b':
1631 value_buf[0] = value;
1632 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1633 break;
1634 default:
1635 return ERROR_OK;
1636 }
1637
1638 switch (retval)
1639 {
1640 case ERROR_TARGET_UNALIGNED_ACCESS:
1641 command_print(cmd_ctx, "error: address not aligned");
1642 break;
1643 case ERROR_TARGET_DATA_ABORT:
1644 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1645 break;
1646 case ERROR_TARGET_NOT_HALTED:
1647 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1648 break;
1649 case ERROR_OK:
1650 break;
1651 default:
1652 command_print(cmd_ctx, "error: unknown error");
1653 break;
1654 }
1655
1656 return ERROR_OK;
1657
1658 }
1659
1660 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1661 {
1662 u8 *buffer;
1663 u32 buf_cnt;
1664 u32 image_size;
1665 int i;
1666 int retval;
1667
1668 image_t image;
1669
1670 duration_t duration;
1671 char *duration_text;
1672
1673 target_t *target = get_current_target(cmd_ctx);
1674
1675 if (argc < 1)
1676 {
1677 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1678 return ERROR_OK;
1679 }
1680
1681 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1682 if (argc >= 2)
1683 {
1684 image.base_address_set = 1;
1685 image.base_address = strtoul(args[1], NULL, 0);
1686 }
1687 else
1688 {
1689 image.base_address_set = 0;
1690 }
1691
1692 image.start_address_set = 0;
1693
1694 duration_start_measure(&duration);
1695
1696 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1697 {
1698 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1699 return ERROR_OK;
1700 }
1701
1702 image_size = 0x0;
1703 for (i = 0; i < image.num_sections; i++)
1704 {
1705 buffer = malloc(image.sections[i].size);
1706 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1707 {
1708 ERROR("image_read_section failed with error code: %i", retval);
1709 command_print(cmd_ctx, "image reading failed, download aborted");
1710 free(buffer);
1711 image_close(&image);
1712 return ERROR_OK;
1713 }
1714 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1715 image_size += buf_cnt;
1716 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1717
1718 free(buffer);
1719 }
1720
1721 duration_stop_measure(&duration, &duration_text);
1722 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1723 free(duration_text);
1724
1725 image_close(&image);
1726
1727 return ERROR_OK;
1728
1729 }
1730
1731 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1732 {
1733 fileio_t fileio;
1734
1735 u32 address;
1736 u32 size;
1737 u8 buffer[560];
1738
1739 duration_t duration;
1740 char *duration_text;
1741
1742 target_t *target = get_current_target(cmd_ctx);
1743
1744 if (argc != 3)
1745 {
1746 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1747 return ERROR_OK;
1748 }
1749
1750 address = strtoul(args[1], NULL, 0);
1751 size = strtoul(args[2], NULL, 0);
1752
1753 if ((address & 3) || (size & 3))
1754 {
1755 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1756 return ERROR_OK;
1757 }
1758
1759 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1760 {
1761 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1762 return ERROR_OK;
1763 }
1764
1765 duration_start_measure(&duration);
1766
1767 while (size > 0)
1768 {
1769 u32 size_written;
1770 u32 this_run_size = (size > 560) ? 560 : size;
1771
1772 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1773 fileio_write(&fileio, this_run_size, buffer, &size_written);
1774
1775 size -= this_run_size;
1776 address += this_run_size;
1777 }
1778
1779 fileio_close(&fileio);
1780
1781 duration_stop_measure(&duration, &duration_text);
1782 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1783 free(duration_text);
1784
1785 return ERROR_OK;
1786
1787 }
1788
1789 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1790 {
1791 int retval;
1792 target_t *target = get_current_target(cmd_ctx);
1793
1794 if (argc == 0)
1795 {
1796 breakpoint_t *breakpoint = target->breakpoints;
1797
1798 while (breakpoint)
1799 {
1800 if (breakpoint->type == BKPT_SOFT)
1801 {
1802 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1803 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1804 free(buf);
1805 }
1806 else
1807 {
1808 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1809 }
1810 breakpoint = breakpoint->next;
1811 }
1812 }
1813 else if (argc >= 2)
1814 {
1815 int hw = BKPT_SOFT;
1816 u32 length = 0;
1817
1818 length = strtoul(args[1], NULL, 0);
1819
1820 if (argc >= 3)
1821 if (strcmp(args[2], "hw") == 0)
1822 hw = BKPT_HARD;
1823
1824 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1825 {
1826 switch (retval)
1827 {
1828 case ERROR_TARGET_NOT_HALTED:
1829 command_print(cmd_ctx, "target must be halted to set breakpoints");
1830 break;
1831 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1832 command_print(cmd_ctx, "no more breakpoints available");
1833 break;
1834 default:
1835 command_print(cmd_ctx, "unknown error, breakpoint not set");
1836 break;
1837 }
1838 }
1839 else
1840 {
1841 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1842 }
1843 }
1844 else
1845 {
1846 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1847 }
1848
1849 return ERROR_OK;
1850 }
1851
1852 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1853 {
1854 target_t *target = get_current_target(cmd_ctx);
1855
1856 if (argc > 0)
1857 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1858
1859 return ERROR_OK;
1860 }
1861
1862 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1863 {
1864 target_t *target = get_current_target(cmd_ctx);
1865 int retval;
1866
1867 if (argc == 0)
1868 {
1869 watchpoint_t *watchpoint = target->watchpoints;
1870
1871 while (watchpoint)
1872 {
1873 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);
1874 watchpoint = watchpoint->next;
1875 }
1876 }
1877 else if (argc >= 2)
1878 {
1879 enum watchpoint_rw type = WPT_ACCESS;
1880 u32 data_value = 0x0;
1881 u32 data_mask = 0xffffffff;
1882
1883 if (argc >= 3)
1884 {
1885 switch(args[2][0])
1886 {
1887 case 'r':
1888 type = WPT_READ;
1889 break;
1890 case 'w':
1891 type = WPT_WRITE;
1892 break;
1893 case 'a':
1894 type = WPT_ACCESS;
1895 break;
1896 default:
1897 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1898 return ERROR_OK;
1899 }
1900 }
1901 if (argc >= 4)
1902 {
1903 data_value = strtoul(args[3], NULL, 0);
1904 }
1905 if (argc >= 5)
1906 {
1907 data_mask = strtoul(args[4], NULL, 0);
1908 }
1909
1910 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
1911 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
1912 {
1913 switch (retval)
1914 {
1915 case ERROR_TARGET_NOT_HALTED:
1916 command_print(cmd_ctx, "target must be halted to set watchpoints");
1917 break;
1918 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1919 command_print(cmd_ctx, "no more watchpoints available");
1920 break;
1921 default:
1922 command_print(cmd_ctx, "unknown error, watchpoint not set");
1923 break;
1924 }
1925 }
1926 }
1927 else
1928 {
1929 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1930 }
1931
1932 return ERROR_OK;
1933 }
1934
1935 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1936 {
1937 target_t *target = get_current_target(cmd_ctx);
1938
1939 if (argc > 0)
1940 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1941
1942 return ERROR_OK;
1943 }
1944
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)