Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- Fixed display of sector sizes in flash.c
[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)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1018
1019 found = 1;
1020 break;
1021 }
1022 }
1023 }
1024
1025 /* no matching target found */
1026 if (!found)
1027 {
1028 ERROR("target '%s' not found", args[0]);
1029 exit(-1);
1030 }
1031
1032 return ERROR_OK;
1033 }
1034
1035 /* usage: target_script <target#> <event> <script_file> */
1036 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1037 {
1038 target_t *target = NULL;
1039
1040 if (argc < 3)
1041 {
1042 ERROR("incomplete target_script command");
1043 exit(-1);
1044 }
1045
1046 target = get_target_by_num(strtoul(args[0], NULL, 0));
1047
1048 if (!target)
1049 {
1050 ERROR("target number '%s' not defined", args[0]);
1051 exit(-1);
1052 }
1053
1054 if (strcmp(args[1], "reset") == 0)
1055 {
1056 if (target->reset_script)
1057 free(target->reset_script);
1058 target->reset_script = strdup(args[2]);
1059 }
1060 else if (strcmp(args[1], "post_halt") == 0)
1061 {
1062 if (target->post_halt_script)
1063 free(target->post_halt_script);
1064 target->post_halt_script = strdup(args[2]);
1065 }
1066 else if (strcmp(args[1], "pre_resume") == 0)
1067 {
1068 if (target->pre_resume_script)
1069 free(target->pre_resume_script);
1070 target->pre_resume_script = strdup(args[2]);
1071 }
1072 else
1073 {
1074 ERROR("unknown event type: '%s", args[1]);
1075 exit(-1);
1076 }
1077
1078 return ERROR_OK;
1079 }
1080
1081 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1082 {
1083 target_t *target = NULL;
1084
1085 if (argc < 2)
1086 {
1087 ERROR("incomplete run_and_halt_time command");
1088 exit(-1);
1089 }
1090
1091 target = get_target_by_num(strtoul(args[0], NULL, 0));
1092
1093 if (!target)
1094 {
1095 ERROR("target number '%s' not defined", args[0]);
1096 exit(-1);
1097 }
1098
1099 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1100
1101 return ERROR_OK;
1102 }
1103
1104 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1105 {
1106 target_t *target = NULL;
1107
1108 if (argc < 4)
1109 {
1110 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1111 exit(-1);
1112 }
1113
1114 target = get_target_by_num(strtoul(args[0], NULL, 0));
1115
1116 if (!target)
1117 {
1118 ERROR("target number '%s' not defined", args[0]);
1119 exit(-1);
1120 }
1121
1122 target->working_area = strtoul(args[1], NULL, 0);
1123 target->working_area_size = strtoul(args[2], NULL, 0);
1124
1125 if (strcmp(args[3], "backup") == 0)
1126 {
1127 target->backup_working_area = 1;
1128 }
1129 else if (strcmp(args[3], "nobackup") == 0)
1130 {
1131 target->backup_working_area = 0;
1132 }
1133 else
1134 {
1135 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1136 exit(-1);
1137 }
1138
1139 return ERROR_OK;
1140 }
1141
1142
1143 /* process target state changes */
1144 int handle_target(void *priv)
1145 {
1146 int retval;
1147 target_t *target = targets;
1148
1149 while (target)
1150 {
1151 /* only poll if target isn't already halted */
1152 if (target->state != TARGET_HALTED)
1153 {
1154 if (target_continous_poll)
1155 if ((retval = target->type->poll(target)) < 0)
1156 {
1157 ERROR("couldn't poll target, exiting");
1158 exit(-1);
1159 }
1160 }
1161
1162 target = target->next;
1163 }
1164
1165 return ERROR_OK;
1166 }
1167
1168 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1169 {
1170 target_t *target;
1171 reg_t *reg = NULL;
1172 int count = 0;
1173 char *value;
1174
1175 DEBUG("-");
1176
1177 target = get_current_target(cmd_ctx);
1178
1179 /* list all available registers for the current target */
1180 if (argc == 0)
1181 {
1182 reg_cache_t *cache = target->reg_cache;
1183
1184 count = 0;
1185 while(cache)
1186 {
1187 int i;
1188 for (i = 0; i < cache->num_regs; i++)
1189 {
1190 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1191 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);
1192 free(value);
1193 }
1194 cache = cache->next;
1195 }
1196
1197 return ERROR_OK;
1198 }
1199
1200 /* access a single register by its ordinal number */
1201 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1202 {
1203 int num = strtoul(args[0], NULL, 0);
1204 reg_cache_t *cache = target->reg_cache;
1205
1206 count = 0;
1207 while(cache)
1208 {
1209 int i;
1210 for (i = 0; i < cache->num_regs; i++)
1211 {
1212 if (count++ == num)
1213 {
1214 reg = &cache->reg_list[i];
1215 break;
1216 }
1217 }
1218 if (reg)
1219 break;
1220 cache = cache->next;
1221 }
1222
1223 if (!reg)
1224 {
1225 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1226 return ERROR_OK;
1227 }
1228 } else /* access a single register by its name */
1229 {
1230 reg = register_get_by_name(target->reg_cache, args[0], 1);
1231
1232 if (!reg)
1233 {
1234 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1235 return ERROR_OK;
1236 }
1237 }
1238
1239 /* display a register */
1240 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1241 {
1242 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1243 reg->valid = 0;
1244
1245 if (reg->valid == 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 arch_type->get(reg);
1254 }
1255 value = buf_to_str(reg->value, reg->size, 16);
1256 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1257 free(value);
1258 return ERROR_OK;
1259 }
1260
1261 /* set register value */
1262 if (argc == 2)
1263 {
1264 u8 *buf = malloc(CEIL(reg->size, 8));
1265 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1266
1267 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1268 if (arch_type == NULL)
1269 {
1270 ERROR("BUG: encountered unregistered arch type");
1271 return ERROR_OK;
1272 }
1273
1274 arch_type->set(reg, buf);
1275
1276 value = buf_to_str(reg->value, reg->size, 16);
1277 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1278 free(value);
1279
1280 free(buf);
1281
1282 return ERROR_OK;
1283 }
1284
1285 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1286
1287 return ERROR_OK;
1288 }
1289
1290 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1291 {
1292 target_t *target = get_current_target(cmd_ctx);
1293 char buffer[512];
1294
1295 if (argc == 0)
1296 {
1297 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1298 if (target->state == TARGET_HALTED)
1299 {
1300 target->type->arch_state(target, buffer, 512);
1301 buffer[511] = 0;
1302 command_print(cmd_ctx, "%s", buffer);
1303 }
1304 }
1305 else
1306 {
1307 if (strcmp(args[0], "on") == 0)
1308 {
1309 target_continous_poll = 1;
1310 }
1311 else if (strcmp(args[0], "off") == 0)
1312 {
1313 target_continous_poll = 0;
1314 }
1315 }
1316
1317
1318 return ERROR_OK;
1319 }
1320
1321 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1322 {
1323 target_t *target = get_current_target(cmd_ctx);
1324 struct timeval timeout, now;
1325
1326 gettimeofday(&timeout, NULL);
1327 if (!argc)
1328 timeval_add_time(&timeout, 5, 0);
1329 else {
1330 char *end;
1331
1332 timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
1333 if (*end) {
1334 command_print(cmd_ctx, "usage: wait_halt [seconds]");
1335 return ERROR_OK;
1336 }
1337 }
1338
1339 command_print(cmd_ctx, "waiting for target halted...");
1340
1341 while(target->type->poll(target))
1342 {
1343 if (target->state == TARGET_HALTED)
1344 {
1345 command_print(cmd_ctx, "target halted");
1346 break;
1347 }
1348 target_call_timer_callbacks();
1349
1350 gettimeofday(&now, NULL);
1351 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1352 {
1353 command_print(cmd_ctx, "timed out while waiting for target halt");
1354 ERROR("timed out while waiting for target halt");
1355 break;
1356 }
1357 }
1358
1359 return ERROR_OK;
1360 }
1361
1362 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1363 {
1364 int retval;
1365 target_t *target = get_current_target(cmd_ctx);
1366
1367 DEBUG("-");
1368
1369 command_print(cmd_ctx, "requesting target halt...");
1370
1371 if ((retval = target->type->halt(target)) != ERROR_OK)
1372 {
1373 switch (retval)
1374 {
1375 case ERROR_TARGET_ALREADY_HALTED:
1376 command_print(cmd_ctx, "target already halted");
1377 break;
1378 case ERROR_TARGET_TIMEOUT:
1379 command_print(cmd_ctx, "target timed out... shutting down");
1380 exit(-1);
1381 default:
1382 command_print(cmd_ctx, "unknown error... shutting down");
1383 exit(-1);
1384 }
1385 }
1386
1387 return ERROR_OK;
1388
1389 }
1390
1391 /* what to do on daemon startup */
1392 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1393 {
1394 if (argc == 1)
1395 {
1396 if (strcmp(args[0], "attach") == 0)
1397 {
1398 startup_mode = DAEMON_ATTACH;
1399 return ERROR_OK;
1400 }
1401 else if (strcmp(args[0], "reset") == 0)
1402 {
1403 startup_mode = DAEMON_RESET;
1404 return ERROR_OK;
1405 }
1406 }
1407
1408 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1409 return ERROR_OK;
1410
1411 }
1412
1413 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1414 {
1415 target_t *target = get_current_target(cmd_ctx);
1416 int retval;
1417
1418 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1419
1420 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1421 {
1422 switch (retval)
1423 {
1424 case ERROR_TARGET_TIMEOUT:
1425 command_print(cmd_ctx, "target timed out... shutting down");
1426 exit(-1);
1427 default:
1428 command_print(cmd_ctx, "unknown error... shutting down");
1429 exit(-1);
1430 }
1431 }
1432
1433 return ERROR_OK;
1434 }
1435
1436 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1437 {
1438 target_t *target = get_current_target(cmd_ctx);
1439 enum target_reset_mode reset_mode = RESET_RUN;
1440
1441 DEBUG("-");
1442
1443 if (argc >= 1)
1444 {
1445 if (strcmp("run", args[0]) == 0)
1446 reset_mode = RESET_RUN;
1447 else if (strcmp("halt", args[0]) == 0)
1448 reset_mode = RESET_HALT;
1449 else if (strcmp("init", args[0]) == 0)
1450 reset_mode = RESET_INIT;
1451 else if (strcmp("run_and_halt", args[0]) == 0)
1452 {
1453 reset_mode = RESET_RUN_AND_HALT;
1454 if (argc >= 2)
1455 {
1456 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1457 }
1458 }
1459 else if (strcmp("run_and_init", args[0]) == 0)
1460 {
1461 reset_mode = RESET_RUN_AND_INIT;
1462 if (argc >= 2)
1463 {
1464 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1465 }
1466 }
1467 else
1468 {
1469 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1470 return ERROR_OK;
1471 }
1472 target->reset_mode = reset_mode;
1473 }
1474
1475 target_process_reset(cmd_ctx);
1476
1477 return ERROR_OK;
1478 }
1479
1480 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1481 {
1482 int retval;
1483 target_t *target = get_current_target(cmd_ctx);
1484
1485 DEBUG("-");
1486
1487 if (argc == 0)
1488 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1489 else if (argc == 1)
1490 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1491 else
1492 {
1493 command_print(cmd_ctx, "usage: resume [address]");
1494 return ERROR_OK;
1495 }
1496
1497 if (retval != ERROR_OK)
1498 {
1499 switch (retval)
1500 {
1501 case ERROR_TARGET_NOT_HALTED:
1502 command_print(cmd_ctx, "target not halted");
1503 break;
1504 default:
1505 command_print(cmd_ctx, "unknown error... shutting down");
1506 exit(-1);
1507 }
1508 }
1509
1510 return ERROR_OK;
1511 }
1512
1513 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1514 {
1515 target_t *target = get_current_target(cmd_ctx);
1516
1517 DEBUG("-");
1518
1519 if (argc == 0)
1520 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1521
1522 if (argc == 1)
1523 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1524
1525 return ERROR_OK;
1526 }
1527
1528 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1529 {
1530 int count = 1;
1531 int size = 4;
1532 u32 address = 0;
1533 int i;
1534
1535 char output[128];
1536 int output_len;
1537
1538 int retval;
1539
1540 u8 *buffer;
1541 target_t *target = get_current_target(cmd_ctx);
1542
1543 if (argc < 1)
1544 return ERROR_OK;
1545
1546 if (argc == 2)
1547 count = strtoul(args[1], NULL, 0);
1548
1549 address = strtoul(args[0], NULL, 0);
1550
1551
1552 switch (cmd[2])
1553 {
1554 case 'w':
1555 size = 4;
1556 break;
1557 case 'h':
1558 size = 2;
1559 break;
1560 case 'b':
1561 size = 1;
1562 break;
1563 default:
1564 return ERROR_OK;
1565 }
1566
1567 buffer = calloc(count, size);
1568 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1569 {
1570 switch (retval)
1571 {
1572 case ERROR_TARGET_UNALIGNED_ACCESS:
1573 command_print(cmd_ctx, "error: address not aligned");
1574 break;
1575 case ERROR_TARGET_NOT_HALTED:
1576 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1577 break;
1578 case ERROR_TARGET_DATA_ABORT:
1579 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1580 break;
1581 default:
1582 command_print(cmd_ctx, "error: unknown error");
1583 break;
1584 }
1585 return ERROR_OK;
1586 }
1587
1588 output_len = 0;
1589
1590 for (i = 0; i < count; i++)
1591 {
1592 if (i%8 == 0)
1593 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1594
1595 switch (size)
1596 {
1597 case 4:
1598 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1599 break;
1600 case 2:
1601 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1602 break;
1603 case 1:
1604 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1605 break;
1606 }
1607
1608 if ((i%8 == 7) || (i == count - 1))
1609 {
1610 command_print(cmd_ctx, output);
1611 output_len = 0;
1612 }
1613 }
1614
1615 free(buffer);
1616
1617 return ERROR_OK;
1618 }
1619
1620 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1621 {
1622 u32 address = 0;
1623 u32 value = 0;
1624 int retval;
1625 target_t *target = get_current_target(cmd_ctx);
1626 u8 value_buf[4];
1627
1628 if (argc < 2)
1629 return ERROR_OK;
1630
1631 address = strtoul(args[0], NULL, 0);
1632 value = strtoul(args[1], NULL, 0);
1633
1634 switch (cmd[2])
1635 {
1636 case 'w':
1637 target_buffer_set_u32(target, value_buf, value);
1638 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1639 break;
1640 case 'h':
1641 target_buffer_set_u16(target, value_buf, value);
1642 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1643 break;
1644 case 'b':
1645 value_buf[0] = value;
1646 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1647 break;
1648 default:
1649 return ERROR_OK;
1650 }
1651
1652 switch (retval)
1653 {
1654 case ERROR_TARGET_UNALIGNED_ACCESS:
1655 command_print(cmd_ctx, "error: address not aligned");
1656 break;
1657 case ERROR_TARGET_DATA_ABORT:
1658 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1659 break;
1660 case ERROR_TARGET_NOT_HALTED:
1661 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1662 break;
1663 case ERROR_OK:
1664 break;
1665 default:
1666 command_print(cmd_ctx, "error: unknown error");
1667 break;
1668 }
1669
1670 return ERROR_OK;
1671
1672 }
1673
1674 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1675 {
1676 u8 *buffer;
1677 u32 buf_cnt;
1678 u32 image_size;
1679 int i;
1680 int retval;
1681
1682 image_t image;
1683
1684 duration_t duration;
1685 char *duration_text;
1686
1687 target_t *target = get_current_target(cmd_ctx);
1688
1689 if (argc < 1)
1690 {
1691 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1692 return ERROR_OK;
1693 }
1694
1695 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1696 if (argc >= 2)
1697 {
1698 image.base_address_set = 1;
1699 image.base_address = strtoul(args[1], NULL, 0);
1700 }
1701 else
1702 {
1703 image.base_address_set = 0;
1704 }
1705
1706 image.start_address_set = 0;
1707
1708 duration_start_measure(&duration);
1709
1710 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1711 {
1712 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1713 return ERROR_OK;
1714 }
1715
1716 image_size = 0x0;
1717 for (i = 0; i < image.num_sections; i++)
1718 {
1719 buffer = malloc(image.sections[i].size);
1720 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1721 {
1722 ERROR("image_read_section failed with error code: %i", retval);
1723 command_print(cmd_ctx, "image reading failed, download aborted");
1724 free(buffer);
1725 image_close(&image);
1726 return ERROR_OK;
1727 }
1728 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1729 image_size += buf_cnt;
1730 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1731
1732 free(buffer);
1733 }
1734
1735 duration_stop_measure(&duration, &duration_text);
1736 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1737 free(duration_text);
1738
1739 image_close(&image);
1740
1741 return ERROR_OK;
1742
1743 }
1744
1745 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1746 {
1747 fileio_t fileio;
1748
1749 u32 address;
1750 u32 size;
1751 u8 buffer[560];
1752
1753 duration_t duration;
1754 char *duration_text;
1755
1756 target_t *target = get_current_target(cmd_ctx);
1757
1758 if (argc != 3)
1759 {
1760 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1761 return ERROR_OK;
1762 }
1763
1764 address = strtoul(args[1], NULL, 0);
1765 size = strtoul(args[2], NULL, 0);
1766
1767 if ((address & 3) || (size & 3))
1768 {
1769 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1770 return ERROR_OK;
1771 }
1772
1773 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1774 {
1775 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1776 return ERROR_OK;
1777 }
1778
1779 duration_start_measure(&duration);
1780
1781 while (size > 0)
1782 {
1783 u32 size_written;
1784 u32 this_run_size = (size > 560) ? 560 : size;
1785
1786 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1787 fileio_write(&fileio, this_run_size, buffer, &size_written);
1788
1789 size -= this_run_size;
1790 address += this_run_size;
1791 }
1792
1793 fileio_close(&fileio);
1794
1795 duration_stop_measure(&duration, &duration_text);
1796 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1797 free(duration_text);
1798
1799 return ERROR_OK;
1800
1801 }
1802
1803 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1804 {
1805 int retval;
1806 target_t *target = get_current_target(cmd_ctx);
1807
1808 if (argc == 0)
1809 {
1810 breakpoint_t *breakpoint = target->breakpoints;
1811
1812 while (breakpoint)
1813 {
1814 if (breakpoint->type == BKPT_SOFT)
1815 {
1816 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1817 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1818 free(buf);
1819 }
1820 else
1821 {
1822 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1823 }
1824 breakpoint = breakpoint->next;
1825 }
1826 }
1827 else if (argc >= 2)
1828 {
1829 int hw = BKPT_SOFT;
1830 u32 length = 0;
1831
1832 length = strtoul(args[1], NULL, 0);
1833
1834 if (argc >= 3)
1835 if (strcmp(args[2], "hw") == 0)
1836 hw = BKPT_HARD;
1837
1838 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1839 {
1840 switch (retval)
1841 {
1842 case ERROR_TARGET_NOT_HALTED:
1843 command_print(cmd_ctx, "target must be halted to set breakpoints");
1844 break;
1845 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1846 command_print(cmd_ctx, "no more breakpoints available");
1847 break;
1848 default:
1849 command_print(cmd_ctx, "unknown error, breakpoint not set");
1850 break;
1851 }
1852 }
1853 else
1854 {
1855 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1856 }
1857 }
1858 else
1859 {
1860 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1861 }
1862
1863 return ERROR_OK;
1864 }
1865
1866 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1867 {
1868 target_t *target = get_current_target(cmd_ctx);
1869
1870 if (argc > 0)
1871 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1872
1873 return ERROR_OK;
1874 }
1875
1876 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1877 {
1878 target_t *target = get_current_target(cmd_ctx);
1879 int retval;
1880
1881 if (argc == 0)
1882 {
1883 watchpoint_t *watchpoint = target->watchpoints;
1884
1885 while (watchpoint)
1886 {
1887 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);
1888 watchpoint = watchpoint->next;
1889 }
1890 }
1891 else if (argc >= 2)
1892 {
1893 enum watchpoint_rw type = WPT_ACCESS;
1894 u32 data_value = 0x0;
1895 u32 data_mask = 0xffffffff;
1896
1897 if (argc >= 3)
1898 {
1899 switch(args[2][0])
1900 {
1901 case 'r':
1902 type = WPT_READ;
1903 break;
1904 case 'w':
1905 type = WPT_WRITE;
1906 break;
1907 case 'a':
1908 type = WPT_ACCESS;
1909 break;
1910 default:
1911 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1912 return ERROR_OK;
1913 }
1914 }
1915 if (argc >= 4)
1916 {
1917 data_value = strtoul(args[3], NULL, 0);
1918 }
1919 if (argc >= 5)
1920 {
1921 data_mask = strtoul(args[4], NULL, 0);
1922 }
1923
1924 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
1925 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
1926 {
1927 switch (retval)
1928 {
1929 case ERROR_TARGET_NOT_HALTED:
1930 command_print(cmd_ctx, "target must be halted to set watchpoints");
1931 break;
1932 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1933 command_print(cmd_ctx, "no more watchpoints available");
1934 break;
1935 default:
1936 command_print(cmd_ctx, "unknown error, watchpoint not set");
1937 break;
1938 }
1939 }
1940 }
1941 else
1942 {
1943 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1944 }
1945
1946 return ERROR_OK;
1947 }
1948
1949 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1950 {
1951 target_t *target = get_current_target(cmd_ctx);
1952
1953 if (argc > 0)
1954 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1955
1956 return ERROR_OK;
1957 }
1958
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)