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