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