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