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