Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- endianess fixes everywhere but in the flash code. flashing might still be broken...
[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 script = fopen(target->reset_script, "r");
213 if (!script)
214 {
215 ERROR("couldn't open script file %s", target->reset_script);
216 return ERROR_OK;
217 }
218
219 INFO("executing reset script '%s'", target->reset_script);
220 command_run_file(cmd_ctx, script, COMMAND_EXEC);
221 fclose(script);
222
223 jtag_execute_queue();
224
225 target_unregister_event_callback(target_init_handler, priv);
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)->endianness = TARGET_LITTLE_ENDIAN;
908 (*last_target_p)->state = TARGET_UNKNOWN;
909 (*last_target_p)->reg_cache = NULL;
910 (*last_target_p)->breakpoints = NULL;
911 (*last_target_p)->watchpoints = NULL;
912 (*last_target_p)->next = NULL;
913 (*last_target_p)->arch_info = NULL;
914
915 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
916
917 found = 1;
918 break;
919 }
920 }
921 }
922
923 /* no matching target found */
924 if (!found)
925 {
926 ERROR("target '%s' not found", args[0]);
927 exit(-1);
928 }
929
930 return ERROR_OK;
931 }
932
933 /* usage: target_script <target#> <event> <script_file> */
934 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
935 {
936 target_t *target = NULL;
937
938 if (argc < 3)
939 {
940 ERROR("incomplete target_script command");
941 exit(-1);
942 }
943
944 target = get_target_by_num(strtoul(args[0], NULL, 0));
945
946 if (!target)
947 {
948 ERROR("target number '%s' not defined", args[0]);
949 exit(-1);
950 }
951
952 if (strcmp(args[1], "reset") == 0)
953 {
954 if (target->reset_script)
955 free(target->reset_script);
956 target->reset_script = strdup(args[2]);
957 }
958 else if (strcmp(args[1], "post_halt") == 0)
959 {
960 if (target->post_halt_script)
961 free(target->post_halt_script);
962 target->post_halt_script = strdup(args[2]);
963 }
964 else if (strcmp(args[1], "pre_resume") == 0)
965 {
966 if (target->pre_resume_script)
967 free(target->pre_resume_script);
968 target->pre_resume_script = strdup(args[2]);
969 }
970 else
971 {
972 ERROR("unknown event type: '%s", args[1]);
973 exit(-1);
974 }
975
976 return ERROR_OK;
977 }
978
979 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
980 {
981 target_t *target = NULL;
982
983 if (argc < 2)
984 {
985 ERROR("incomplete run_and_halt_time command");
986 exit(-1);
987 }
988
989 target = get_target_by_num(strtoul(args[0], NULL, 0));
990
991 if (!target)
992 {
993 ERROR("target number '%s' not defined", args[0]);
994 exit(-1);
995 }
996
997 target->run_and_halt_time = strtoul(args[1], NULL, 0);
998
999 return ERROR_OK;
1000 }
1001
1002 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1003 {
1004 target_t *target = NULL;
1005
1006 if (argc < 4)
1007 {
1008 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1009 exit(-1);
1010 }
1011
1012 target = get_target_by_num(strtoul(args[0], NULL, 0));
1013
1014 if (!target)
1015 {
1016 ERROR("target number '%s' not defined", args[0]);
1017 exit(-1);
1018 }
1019
1020 target->working_area = strtoul(args[1], NULL, 0);
1021 target->working_area_size = strtoul(args[2], NULL, 0);
1022
1023 if (strcmp(args[3], "backup") == 0)
1024 {
1025 target->backup_working_area = 1;
1026 }
1027 else if (strcmp(args[3], "nobackup") == 0)
1028 {
1029 target->backup_working_area = 0;
1030 }
1031 else
1032 {
1033 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1034 exit(-1);
1035 }
1036
1037 return ERROR_OK;
1038 }
1039
1040
1041 /* process target state changes */
1042 int handle_target(void *priv)
1043 {
1044 int retval;
1045 target_t *target = targets;
1046
1047 while (target)
1048 {
1049 /* only poll if target isn't already halted */
1050 if (target->state != TARGET_HALTED)
1051 {
1052 if (target_continous_poll)
1053 if ((retval = target->type->poll(target)) < 0)
1054 {
1055 ERROR("couldn't poll target, exiting");
1056 exit(-1);
1057 }
1058 }
1059
1060 target = target->next;
1061 }
1062
1063 return ERROR_OK;
1064 }
1065
1066 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1067 {
1068 target_t *target;
1069 reg_t *reg = NULL;
1070 int count = 0;
1071 char *value;
1072
1073 DEBUG("");
1074
1075 target = get_current_target(cmd_ctx);
1076
1077 /* list all available registers for the current target */
1078 if (argc == 0)
1079 {
1080 reg_cache_t *cache = target->reg_cache;
1081
1082 count = 0;
1083 while(cache)
1084 {
1085 int i;
1086 for (i = 0; i < cache->num_regs; i++)
1087 {
1088 value = buf_to_char(cache->reg_list[i].value, cache->reg_list[i].size);
1089 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);
1090 free(value);
1091 }
1092 cache = cache->next;
1093 }
1094
1095 return ERROR_OK;
1096 }
1097
1098 /* access a single register by its ordinal number */
1099 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1100 {
1101 int num = strtoul(args[0], NULL, 0);
1102 reg_cache_t *cache = target->reg_cache;
1103
1104 count = 0;
1105 while(cache)
1106 {
1107 int i;
1108 for (i = 0; i < cache->num_regs; i++)
1109 {
1110 if (count++ == num)
1111 {
1112 reg = &cache->reg_list[i];
1113 break;
1114 }
1115 }
1116 if (reg)
1117 break;
1118 cache = cache->next;
1119 }
1120
1121 if (!reg)
1122 {
1123 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1124 return ERROR_OK;
1125 }
1126 } else /* access a single register by its name */
1127 {
1128 reg = register_get_by_name(target->reg_cache, args[0], 1);
1129
1130 if (!reg)
1131 {
1132 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1133 return ERROR_OK;
1134 }
1135 }
1136
1137 /* display a register */
1138 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1139 {
1140 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1141 reg->valid = 0;
1142
1143 if (reg->valid == 0)
1144 {
1145 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1146 if (arch_type == NULL)
1147 {
1148 ERROR("BUG: encountered unregistered arch type");
1149 return ERROR_OK;
1150 }
1151 arch_type->get(reg);
1152 }
1153 value = buf_to_char(reg->value, reg->size);
1154 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1155 free(value);
1156 return ERROR_OK;
1157 }
1158
1159 /* set register value */
1160 if (argc == 2)
1161 {
1162 u32 new_value = strtoul(args[1], NULL, 0);
1163 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1164 if (arch_type == NULL)
1165 {
1166 ERROR("BUG: encountered unregistered arch type");
1167 return ERROR_OK;
1168 }
1169
1170 arch_type->set(reg, new_value);
1171 value = buf_to_char(reg->value, reg->size);
1172 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1173 free(value);
1174
1175 return ERROR_OK;
1176 }
1177
1178 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1179
1180 return ERROR_OK;
1181 }
1182
1183 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1184 {
1185 target_t *target = get_current_target(cmd_ctx);
1186 char buffer[512];
1187
1188 if (argc == 0)
1189 {
1190 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1191 if (target->state == TARGET_HALTED)
1192 {
1193 target->type->arch_state(target, buffer, 512);
1194 buffer[511] = 0;
1195 command_print(cmd_ctx, "%s", buffer);
1196 }
1197 }
1198 else
1199 {
1200 if (strcmp(args[0], "on") == 0)
1201 {
1202 target_continous_poll = 1;
1203 }
1204 else if (strcmp(args[0], "off") == 0)
1205 {
1206 target_continous_poll = 0;
1207 }
1208 }
1209
1210
1211 return ERROR_OK;
1212 }
1213
1214 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1215 {
1216 target_t *target = get_current_target(cmd_ctx);
1217 struct timeval timeout, now;
1218
1219 gettimeofday(&timeout, NULL);
1220 timeval_add_time(&timeout, 5, 0);
1221
1222 command_print(cmd_ctx, "waiting for target halted...");
1223
1224 while(target->type->poll(target))
1225 {
1226 if (target->state == TARGET_HALTED)
1227 {
1228 command_print(cmd_ctx, "target halted");
1229 break;
1230 }
1231 target_call_timer_callbacks();
1232
1233 gettimeofday(&now, NULL);
1234 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1235 {
1236 command_print(cmd_ctx, "timed out while waiting for target halt");
1237 ERROR("timed out while waiting for target halt");
1238 break;
1239 }
1240 }
1241
1242 return ERROR_OK;
1243 }
1244
1245 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1246 {
1247 int retval;
1248 target_t *target = get_current_target(cmd_ctx);
1249
1250 DEBUG("");
1251
1252 command_print(cmd_ctx, "requesting target halt...");
1253
1254 if ((retval = target->type->halt(target)) != ERROR_OK)
1255 {
1256 switch (retval)
1257 {
1258 case ERROR_TARGET_ALREADY_HALTED:
1259 command_print(cmd_ctx, "target already halted");
1260 break;
1261 case ERROR_TARGET_TIMEOUT:
1262 command_print(cmd_ctx, "target timed out... shutting down");
1263 exit(-1);
1264 default:
1265 command_print(cmd_ctx, "unknown error... shutting down");
1266 exit(-1);
1267 }
1268 }
1269
1270 return ERROR_OK;
1271
1272 }
1273
1274 /* what to do on daemon startup */
1275 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1276 {
1277 if (argc == 1)
1278 {
1279 if (strcmp(args[0], "attach") == 0)
1280 {
1281 startup_mode = DAEMON_ATTACH;
1282 return ERROR_OK;
1283 }
1284 else if (strcmp(args[0], "reset") == 0)
1285 {
1286 startup_mode = DAEMON_RESET;
1287 return ERROR_OK;
1288 }
1289 }
1290
1291 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1292 return ERROR_OK;
1293
1294 }
1295
1296 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1297 {
1298 target_t *target = get_current_target(cmd_ctx);
1299 int retval;
1300
1301 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1302
1303 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1304 {
1305 switch (retval)
1306 {
1307 case ERROR_TARGET_TIMEOUT:
1308 command_print(cmd_ctx, "target timed out... shutting down");
1309 exit(-1);
1310 default:
1311 command_print(cmd_ctx, "unknown error... shutting down");
1312 exit(-1);
1313 }
1314 }
1315
1316 return ERROR_OK;
1317 }
1318
1319 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1320 {
1321 target_t *target = get_current_target(cmd_ctx);
1322 enum target_reset_mode reset_mode = RESET_RUN;
1323
1324 DEBUG("");
1325
1326 if (argc >= 1)
1327 {
1328 if (strcmp("run", args[0]) == 0)
1329 reset_mode = RESET_RUN;
1330 else if (strcmp("halt", args[0]) == 0)
1331 reset_mode = RESET_HALT;
1332 else if (strcmp("init", args[0]) == 0)
1333 reset_mode = RESET_INIT;
1334 else if (strcmp("run_and_halt", args[0]) == 0)
1335 {
1336 reset_mode = RESET_RUN_AND_HALT;
1337 if (argc >= 2)
1338 {
1339 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1340 }
1341 }
1342 else if (strcmp("run_and_init", args[0]) == 0)
1343 {
1344 reset_mode = RESET_RUN_AND_INIT;
1345 if (argc >= 2)
1346 {
1347 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1348 }
1349 }
1350 else
1351 {
1352 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1353 return ERROR_OK;
1354 }
1355 target->reset_mode = reset_mode;
1356 }
1357
1358 target_process_reset(cmd_ctx);
1359
1360 return ERROR_OK;
1361 }
1362
1363 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1364 {
1365 int retval;
1366 target_t *target = get_current_target(cmd_ctx);
1367
1368 DEBUG("");
1369
1370 if (argc == 0)
1371 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1372 else if (argc == 1)
1373 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1374 else
1375 {
1376 command_print(cmd_ctx, "usage: resume [address]");
1377 return ERROR_OK;
1378 }
1379
1380 if (retval != ERROR_OK)
1381 {
1382 switch (retval)
1383 {
1384 case ERROR_TARGET_NOT_HALTED:
1385 command_print(cmd_ctx, "target not halted");
1386 break;
1387 default:
1388 command_print(cmd_ctx, "unknown error... shutting down");
1389 exit(-1);
1390 }
1391 }
1392
1393 return ERROR_OK;
1394 }
1395
1396 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1397 {
1398 target_t *target = get_current_target(cmd_ctx);
1399
1400 DEBUG("");
1401
1402 if (argc == 0)
1403 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1404
1405 if (argc == 1)
1406 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1407
1408 return ERROR_OK;
1409 }
1410
1411 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1412 {
1413 int count = 1;
1414 int size = 4;
1415 u32 address = 0;
1416 int i;
1417
1418 char output[128];
1419 int output_len;
1420
1421 int retval;
1422
1423 u8 *buffer;
1424 target_t *target = get_current_target(cmd_ctx);
1425
1426 if (argc < 1)
1427 return ERROR_OK;
1428
1429 if (argc == 2)
1430 count = strtoul(args[1], NULL, 0);
1431
1432 address = strtoul(args[0], NULL, 0);
1433
1434
1435 switch (cmd[2])
1436 {
1437 case 'w':
1438 size = 4;
1439 break;
1440 case 'h':
1441 size = 2;
1442 break;
1443 case 'b':
1444 size = 1;
1445 break;
1446 default:
1447 return ERROR_OK;
1448 }
1449
1450 buffer = calloc(count, size);
1451 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1452 {
1453 switch (retval)
1454 {
1455 case ERROR_TARGET_UNALIGNED_ACCESS:
1456 command_print(cmd_ctx, "error: address not aligned");
1457 break;
1458 case ERROR_TARGET_NOT_HALTED:
1459 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1460 break;
1461 case ERROR_TARGET_DATA_ABORT:
1462 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1463 break;
1464 default:
1465 command_print(cmd_ctx, "error: unknown error");
1466 break;
1467 }
1468 return ERROR_OK;
1469 }
1470
1471 output_len = 0;
1472
1473 for (i = 0; i < count; i++)
1474 {
1475 if (i%8 == 0)
1476 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1477
1478 switch (size)
1479 {
1480 case 4:
1481 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1482 break;
1483 case 2:
1484 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1485 break;
1486 case 1:
1487 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1488 break;
1489 }
1490
1491 if ((i%8 == 7) || (i == count - 1))
1492 {
1493 command_print(cmd_ctx, output);
1494 output_len = 0;
1495 }
1496 }
1497
1498 free(buffer);
1499
1500 return ERROR_OK;
1501 }
1502
1503 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1504 {
1505 u32 address = 0;
1506 u32 value = 0;
1507 int retval;
1508 target_t *target = get_current_target(cmd_ctx);
1509 u8 value_buf[4];
1510
1511 if (argc < 2)
1512 return ERROR_OK;
1513
1514 address = strtoul(args[0], NULL, 0);
1515 value = strtoul(args[1], NULL, 0);
1516
1517 switch (cmd[2])
1518 {
1519 case 'w':
1520 target_buffer_set_u32(target, value_buf, value);
1521 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1522 break;
1523 case 'h':
1524 target_buffer_set_u16(target, value_buf, value);
1525 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1526 break;
1527 case 'b':
1528 value_buf[0] = value;
1529 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1530 break;
1531 default:
1532 return ERROR_OK;
1533 }
1534
1535 switch (retval)
1536 {
1537 case ERROR_TARGET_UNALIGNED_ACCESS:
1538 command_print(cmd_ctx, "error: address not aligned");
1539 break;
1540 case ERROR_TARGET_DATA_ABORT:
1541 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1542 break;
1543 case ERROR_TARGET_NOT_HALTED:
1544 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1545 break;
1546 case ERROR_OK:
1547 break;
1548 default:
1549 command_print(cmd_ctx, "error: unknown error");
1550 break;
1551 }
1552
1553 return ERROR_OK;
1554
1555 }
1556
1557 int handle_load_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1558 {
1559 FILE *binary;
1560 u32 address;
1561 struct stat binary_stat;
1562 u32 binary_size;
1563
1564 u8 *buffer;
1565 u32 buf_cnt;
1566
1567 struct timeval start, end, duration;
1568
1569 target_t *target = get_current_target(cmd_ctx);
1570
1571 if (argc != 2)
1572 {
1573 command_print(cmd_ctx, "usage: load_binary <filename> <address>");
1574 return ERROR_OK;
1575 }
1576
1577 address = strtoul(args[1], NULL, 0);
1578
1579 if (stat(args[0], &binary_stat) == -1)
1580 {
1581 ERROR("couldn't stat() %s: %s", args[0], strerror(errno));
1582 command_print(cmd_ctx, "error accessing file %s", args[0]);
1583 return ERROR_OK;
1584 }
1585
1586 if (!(binary = fopen(args[0], "rb")))
1587 {
1588 ERROR("couldn't open %s: %s", args[0], strerror(errno));
1589 command_print(cmd_ctx, "error accessing file %s", args[0]);
1590 return ERROR_OK;
1591 }
1592
1593 buffer = malloc(128 * 1024);
1594
1595 gettimeofday(&start, NULL);
1596
1597 binary_size = binary_stat.st_size;
1598 while (binary_size > 0)
1599 {
1600 buf_cnt = fread(buffer, 1, 128*1024, binary);
1601 target_write_buffer(target, address, buf_cnt, buffer);
1602 address += buf_cnt;
1603 binary_size -= buf_cnt;
1604 }
1605
1606 gettimeofday(&end, NULL);
1607
1608 free(buffer);
1609
1610 timeval_subtract(&duration, &end, &start);
1611 command_print(cmd_ctx, "downloaded %lli byte in %is %ius", (long long) binary_stat.st_size, duration.tv_sec, duration.tv_usec);
1612
1613 fclose(binary);
1614
1615 return ERROR_OK;
1616
1617 }
1618
1619 int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1620 {
1621 FILE *binary;
1622 u32 address;
1623 u32 size;
1624 u8 buffer[560];
1625
1626 struct timeval start, end, duration;
1627
1628 target_t *target = get_current_target(cmd_ctx);
1629
1630 if (argc != 3)
1631 {
1632 command_print(cmd_ctx, "usage: dump_binary <filename> <address> <size>");
1633 return ERROR_OK;
1634 }
1635
1636 address = strtoul(args[1], NULL, 0);
1637 size = strtoul(args[2], NULL, 0);
1638
1639 if (!(binary = fopen(args[0], "wb")))
1640 {
1641 ERROR("couldn't open %s for writing: %s", args[0], strerror(errno));
1642 command_print(cmd_ctx, "error accessing file %s", args[0]);
1643 return ERROR_OK;
1644 }
1645
1646 if ((address & 3) || (size & 3))
1647 {
1648 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1649 return ERROR_OK;
1650 }
1651
1652 gettimeofday(&start, NULL);
1653
1654 while (size > 0)
1655 {
1656 u32 this_run_size = (size > 560) ? 560 : size;
1657 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1658 fwrite(buffer, 1, this_run_size, binary);
1659 size -= this_run_size;
1660 address += this_run_size;
1661 }
1662
1663 fclose(binary);
1664
1665 gettimeofday(&end, NULL);
1666
1667 timeval_subtract(&duration, &end, &start);
1668 command_print(cmd_ctx, "dumped %i byte in %is %ius", strtoul(args[2], NULL, 0), duration.tv_sec, duration.tv_usec);
1669
1670 return ERROR_OK;
1671
1672 }
1673
1674 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1675 {
1676 int retval;
1677 target_t *target = get_current_target(cmd_ctx);
1678
1679 if (argc == 0)
1680 {
1681 breakpoint_t *breakpoint = target->breakpoints;
1682
1683 while (breakpoint)
1684 {
1685 if (breakpoint->type == BKPT_SOFT)
1686 {
1687 char* buf = buf_to_char(breakpoint->orig_instr, breakpoint->length);
1688 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1689 free(buf);
1690 }
1691 else
1692 {
1693 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1694 }
1695 breakpoint = breakpoint->next;
1696 }
1697 }
1698 else if (argc >= 2)
1699 {
1700 int hw = BKPT_SOFT;
1701 u32 length = 0;
1702
1703 length = strtoul(args[1], NULL, 0);
1704
1705 if (argc >= 3)
1706 if (strcmp(args[2], "hw") == 0)
1707 hw = BKPT_HARD;
1708
1709 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1710 {
1711 switch (retval)
1712 {
1713 case ERROR_TARGET_NOT_HALTED:
1714 command_print(cmd_ctx, "target must be halted to set breakpoints");
1715 break;
1716 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1717 command_print(cmd_ctx, "no more breakpoints available");
1718 break;
1719 default:
1720 command_print(cmd_ctx, "unknown error, breakpoint not set");
1721 break;
1722 }
1723 }
1724 else
1725 {
1726 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1727 }
1728 }
1729 else
1730 {
1731 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1732 }
1733
1734 return ERROR_OK;
1735 }
1736
1737 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1738 {
1739 target_t *target = get_current_target(cmd_ctx);
1740
1741 if (argc > 0)
1742 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1743
1744 return ERROR_OK;
1745 }
1746
1747 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1748 {
1749 target_t *target = get_current_target(cmd_ctx);
1750
1751 if (argc == 0)
1752 {
1753 watchpoint_t *watchpoint = target->watchpoints;
1754
1755 while (watchpoint)
1756 {
1757 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);
1758 watchpoint = watchpoint->next;
1759 }
1760 }
1761 else if (argc >= 2)
1762 {
1763 enum watchpoint_rw type = WPT_ACCESS;
1764 u32 data_value = 0x0;
1765 u32 data_mask = 0xffffffff;
1766
1767 if (argc >= 3)
1768 {
1769 switch(args[2][0])
1770 {
1771 case 'r':
1772 type = WPT_READ;
1773 break;
1774 case 'w':
1775 type = WPT_WRITE;
1776 break;
1777 case 'a':
1778 type = WPT_ACCESS;
1779 break;
1780 default:
1781 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1782 return ERROR_OK;
1783 }
1784 }
1785 if (argc >= 4)
1786 {
1787 data_value = strtoul(args[3], NULL, 0);
1788 }
1789 if (argc >= 5)
1790 {
1791 data_mask = strtoul(args[4], NULL, 0);
1792 }
1793 watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask);
1794 }
1795 else
1796 {
1797 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1798 }
1799
1800 return ERROR_OK;
1801 }
1802
1803 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1804 {
1805 target_t *target = get_current_target(cmd_ctx);
1806
1807 if (argc > 0)
1808 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1809
1810 return ERROR_OK;
1811 }
1812
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)