Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- str9x flash support (Thanks to Spencer Oliver)
[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_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
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_str(reg->value, reg->size, 16);
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 u8 *buf = malloc(CEIL(reg->size, 8));
1163 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1164
1165 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1166 if (arch_type == NULL)
1167 {
1168 ERROR("BUG: encountered unregistered arch type");
1169 return ERROR_OK;
1170 }
1171
1172 arch_type->set(reg, buf);
1173
1174 value = buf_to_str(reg->value, reg->size, 16);
1175 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1176 free(value);
1177
1178 free(buf);
1179
1180 return ERROR_OK;
1181 }
1182
1183 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1184
1185 return ERROR_OK;
1186 }
1187
1188 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1189 {
1190 target_t *target = get_current_target(cmd_ctx);
1191 char buffer[512];
1192
1193 if (argc == 0)
1194 {
1195 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1196 if (target->state == TARGET_HALTED)
1197 {
1198 target->type->arch_state(target, buffer, 512);
1199 buffer[511] = 0;
1200 command_print(cmd_ctx, "%s", buffer);
1201 }
1202 }
1203 else
1204 {
1205 if (strcmp(args[0], "on") == 0)
1206 {
1207 target_continous_poll = 1;
1208 }
1209 else if (strcmp(args[0], "off") == 0)
1210 {
1211 target_continous_poll = 0;
1212 }
1213 }
1214
1215
1216 return ERROR_OK;
1217 }
1218
1219 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1220 {
1221 target_t *target = get_current_target(cmd_ctx);
1222 struct timeval timeout, now;
1223
1224 gettimeofday(&timeout, NULL);
1225 timeval_add_time(&timeout, 5, 0);
1226
1227 command_print(cmd_ctx, "waiting for target halted...");
1228
1229 while(target->type->poll(target))
1230 {
1231 if (target->state == TARGET_HALTED)
1232 {
1233 command_print(cmd_ctx, "target halted");
1234 break;
1235 }
1236 target_call_timer_callbacks();
1237
1238 gettimeofday(&now, NULL);
1239 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1240 {
1241 command_print(cmd_ctx, "timed out while waiting for target halt");
1242 ERROR("timed out while waiting for target halt");
1243 break;
1244 }
1245 }
1246
1247 return ERROR_OK;
1248 }
1249
1250 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1251 {
1252 int retval;
1253 target_t *target = get_current_target(cmd_ctx);
1254
1255 DEBUG("");
1256
1257 command_print(cmd_ctx, "requesting target halt...");
1258
1259 if ((retval = target->type->halt(target)) != ERROR_OK)
1260 {
1261 switch (retval)
1262 {
1263 case ERROR_TARGET_ALREADY_HALTED:
1264 command_print(cmd_ctx, "target already halted");
1265 break;
1266 case ERROR_TARGET_TIMEOUT:
1267 command_print(cmd_ctx, "target timed out... shutting down");
1268 exit(-1);
1269 default:
1270 command_print(cmd_ctx, "unknown error... shutting down");
1271 exit(-1);
1272 }
1273 }
1274
1275 return ERROR_OK;
1276
1277 }
1278
1279 /* what to do on daemon startup */
1280 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1281 {
1282 if (argc == 1)
1283 {
1284 if (strcmp(args[0], "attach") == 0)
1285 {
1286 startup_mode = DAEMON_ATTACH;
1287 return ERROR_OK;
1288 }
1289 else if (strcmp(args[0], "reset") == 0)
1290 {
1291 startup_mode = DAEMON_RESET;
1292 return ERROR_OK;
1293 }
1294 }
1295
1296 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1297 return ERROR_OK;
1298
1299 }
1300
1301 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1302 {
1303 target_t *target = get_current_target(cmd_ctx);
1304 int retval;
1305
1306 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1307
1308 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1309 {
1310 switch (retval)
1311 {
1312 case ERROR_TARGET_TIMEOUT:
1313 command_print(cmd_ctx, "target timed out... shutting down");
1314 exit(-1);
1315 default:
1316 command_print(cmd_ctx, "unknown error... shutting down");
1317 exit(-1);
1318 }
1319 }
1320
1321 return ERROR_OK;
1322 }
1323
1324 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1325 {
1326 target_t *target = get_current_target(cmd_ctx);
1327 enum target_reset_mode reset_mode = RESET_RUN;
1328
1329 DEBUG("");
1330
1331 if (argc >= 1)
1332 {
1333 if (strcmp("run", args[0]) == 0)
1334 reset_mode = RESET_RUN;
1335 else if (strcmp("halt", args[0]) == 0)
1336 reset_mode = RESET_HALT;
1337 else if (strcmp("init", args[0]) == 0)
1338 reset_mode = RESET_INIT;
1339 else if (strcmp("run_and_halt", args[0]) == 0)
1340 {
1341 reset_mode = RESET_RUN_AND_HALT;
1342 if (argc >= 2)
1343 {
1344 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1345 }
1346 }
1347 else if (strcmp("run_and_init", args[0]) == 0)
1348 {
1349 reset_mode = RESET_RUN_AND_INIT;
1350 if (argc >= 2)
1351 {
1352 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1353 }
1354 }
1355 else
1356 {
1357 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1358 return ERROR_OK;
1359 }
1360 target->reset_mode = reset_mode;
1361 }
1362
1363 target_process_reset(cmd_ctx);
1364
1365 return ERROR_OK;
1366 }
1367
1368 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1369 {
1370 int retval;
1371 target_t *target = get_current_target(cmd_ctx);
1372
1373 DEBUG("");
1374
1375 if (argc == 0)
1376 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1377 else if (argc == 1)
1378 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1379 else
1380 {
1381 command_print(cmd_ctx, "usage: resume [address]");
1382 return ERROR_OK;
1383 }
1384
1385 if (retval != ERROR_OK)
1386 {
1387 switch (retval)
1388 {
1389 case ERROR_TARGET_NOT_HALTED:
1390 command_print(cmd_ctx, "target not halted");
1391 break;
1392 default:
1393 command_print(cmd_ctx, "unknown error... shutting down");
1394 exit(-1);
1395 }
1396 }
1397
1398 return ERROR_OK;
1399 }
1400
1401 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1402 {
1403 target_t *target = get_current_target(cmd_ctx);
1404
1405 DEBUG("");
1406
1407 if (argc == 0)
1408 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1409
1410 if (argc == 1)
1411 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1412
1413 return ERROR_OK;
1414 }
1415
1416 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1417 {
1418 int count = 1;
1419 int size = 4;
1420 u32 address = 0;
1421 int i;
1422
1423 char output[128];
1424 int output_len;
1425
1426 int retval;
1427
1428 u8 *buffer;
1429 target_t *target = get_current_target(cmd_ctx);
1430
1431 if (argc < 1)
1432 return ERROR_OK;
1433
1434 if (argc == 2)
1435 count = strtoul(args[1], NULL, 0);
1436
1437 address = strtoul(args[0], NULL, 0);
1438
1439
1440 switch (cmd[2])
1441 {
1442 case 'w':
1443 size = 4;
1444 break;
1445 case 'h':
1446 size = 2;
1447 break;
1448 case 'b':
1449 size = 1;
1450 break;
1451 default:
1452 return ERROR_OK;
1453 }
1454
1455 buffer = calloc(count, size);
1456 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1457 {
1458 switch (retval)
1459 {
1460 case ERROR_TARGET_UNALIGNED_ACCESS:
1461 command_print(cmd_ctx, "error: address not aligned");
1462 break;
1463 case ERROR_TARGET_NOT_HALTED:
1464 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1465 break;
1466 case ERROR_TARGET_DATA_ABORT:
1467 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1468 break;
1469 default:
1470 command_print(cmd_ctx, "error: unknown error");
1471 break;
1472 }
1473 return ERROR_OK;
1474 }
1475
1476 output_len = 0;
1477
1478 for (i = 0; i < count; i++)
1479 {
1480 if (i%8 == 0)
1481 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1482
1483 switch (size)
1484 {
1485 case 4:
1486 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1487 break;
1488 case 2:
1489 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1490 break;
1491 case 1:
1492 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1493 break;
1494 }
1495
1496 if ((i%8 == 7) || (i == count - 1))
1497 {
1498 command_print(cmd_ctx, output);
1499 output_len = 0;
1500 }
1501 }
1502
1503 free(buffer);
1504
1505 return ERROR_OK;
1506 }
1507
1508 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1509 {
1510 u32 address = 0;
1511 u32 value = 0;
1512 int retval;
1513 target_t *target = get_current_target(cmd_ctx);
1514 u8 value_buf[4];
1515
1516 if (argc < 2)
1517 return ERROR_OK;
1518
1519 address = strtoul(args[0], NULL, 0);
1520 value = strtoul(args[1], NULL, 0);
1521
1522 switch (cmd[2])
1523 {
1524 case 'w':
1525 target_buffer_set_u32(target, value_buf, value);
1526 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1527 break;
1528 case 'h':
1529 target_buffer_set_u16(target, value_buf, value);
1530 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1531 break;
1532 case 'b':
1533 value_buf[0] = value;
1534 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1535 break;
1536 default:
1537 return ERROR_OK;
1538 }
1539
1540 switch (retval)
1541 {
1542 case ERROR_TARGET_UNALIGNED_ACCESS:
1543 command_print(cmd_ctx, "error: address not aligned");
1544 break;
1545 case ERROR_TARGET_DATA_ABORT:
1546 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1547 break;
1548 case ERROR_TARGET_NOT_HALTED:
1549 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1550 break;
1551 case ERROR_OK:
1552 break;
1553 default:
1554 command_print(cmd_ctx, "error: unknown error");
1555 break;
1556 }
1557
1558 return ERROR_OK;
1559
1560 }
1561
1562 int handle_load_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1563 {
1564 FILE *binary;
1565 u32 address;
1566 struct stat binary_stat;
1567 u32 binary_size;
1568
1569 u8 *buffer;
1570 u32 buf_cnt;
1571
1572 struct timeval start, end, duration;
1573
1574 target_t *target = get_current_target(cmd_ctx);
1575
1576 if (argc != 2)
1577 {
1578 command_print(cmd_ctx, "usage: load_binary <filename> <address>");
1579 return ERROR_OK;
1580 }
1581
1582 address = strtoul(args[1], NULL, 0);
1583
1584 if (stat(args[0], &binary_stat) == -1)
1585 {
1586 ERROR("couldn't stat() %s: %s", args[0], strerror(errno));
1587 command_print(cmd_ctx, "error accessing file %s", args[0]);
1588 return ERROR_OK;
1589 }
1590
1591 if (!(binary = fopen(args[0], "rb")))
1592 {
1593 ERROR("couldn't open %s: %s", args[0], strerror(errno));
1594 command_print(cmd_ctx, "error accessing file %s", args[0]);
1595 return ERROR_OK;
1596 }
1597
1598 buffer = malloc(128 * 1024);
1599
1600 gettimeofday(&start, NULL);
1601
1602 binary_size = binary_stat.st_size;
1603 while (binary_size > 0)
1604 {
1605 buf_cnt = fread(buffer, 1, 128*1024, binary);
1606 target_write_buffer(target, address, buf_cnt, buffer);
1607 address += buf_cnt;
1608 binary_size -= buf_cnt;
1609 }
1610
1611 gettimeofday(&end, NULL);
1612
1613 free(buffer);
1614
1615 timeval_subtract(&duration, &end, &start);
1616 command_print(cmd_ctx, "downloaded %lli byte in %is %ius", (long long) binary_stat.st_size, duration.tv_sec, duration.tv_usec);
1617
1618 fclose(binary);
1619
1620 return ERROR_OK;
1621
1622 }
1623
1624 int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1625 {
1626 FILE *binary;
1627 u32 address;
1628 u32 size;
1629 u8 buffer[560];
1630
1631 struct timeval start, end, duration;
1632
1633 target_t *target = get_current_target(cmd_ctx);
1634
1635 if (argc != 3)
1636 {
1637 command_print(cmd_ctx, "usage: dump_binary <filename> <address> <size>");
1638 return ERROR_OK;
1639 }
1640
1641 address = strtoul(args[1], NULL, 0);
1642 size = strtoul(args[2], NULL, 0);
1643
1644 if (!(binary = fopen(args[0], "wb")))
1645 {
1646 ERROR("couldn't open %s for writing: %s", args[0], strerror(errno));
1647 command_print(cmd_ctx, "error accessing file %s", args[0]);
1648 return ERROR_OK;
1649 }
1650
1651 if ((address & 3) || (size & 3))
1652 {
1653 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1654 return ERROR_OK;
1655 }
1656
1657 gettimeofday(&start, NULL);
1658
1659 while (size > 0)
1660 {
1661 u32 this_run_size = (size > 560) ? 560 : size;
1662 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1663 fwrite(buffer, 1, this_run_size, binary);
1664 size -= this_run_size;
1665 address += this_run_size;
1666 }
1667
1668 fclose(binary);
1669
1670 gettimeofday(&end, NULL);
1671
1672 timeval_subtract(&duration, &end, &start);
1673 command_print(cmd_ctx, "dumped %i byte in %is %ius", strtoul(args[2], NULL, 0), duration.tv_sec, duration.tv_usec);
1674
1675 return ERROR_OK;
1676
1677 }
1678
1679 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1680 {
1681 int retval;
1682 target_t *target = get_current_target(cmd_ctx);
1683
1684 if (argc == 0)
1685 {
1686 breakpoint_t *breakpoint = target->breakpoints;
1687
1688 while (breakpoint)
1689 {
1690 if (breakpoint->type == BKPT_SOFT)
1691 {
1692 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
1693 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1694 free(buf);
1695 }
1696 else
1697 {
1698 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1699 }
1700 breakpoint = breakpoint->next;
1701 }
1702 }
1703 else if (argc >= 2)
1704 {
1705 int hw = BKPT_SOFT;
1706 u32 length = 0;
1707
1708 length = strtoul(args[1], NULL, 0);
1709
1710 if (argc >= 3)
1711 if (strcmp(args[2], "hw") == 0)
1712 hw = BKPT_HARD;
1713
1714 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1715 {
1716 switch (retval)
1717 {
1718 case ERROR_TARGET_NOT_HALTED:
1719 command_print(cmd_ctx, "target must be halted to set breakpoints");
1720 break;
1721 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1722 command_print(cmd_ctx, "no more breakpoints available");
1723 break;
1724 default:
1725 command_print(cmd_ctx, "unknown error, breakpoint not set");
1726 break;
1727 }
1728 }
1729 else
1730 {
1731 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1732 }
1733 }
1734 else
1735 {
1736 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1737 }
1738
1739 return ERROR_OK;
1740 }
1741
1742 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1743 {
1744 target_t *target = get_current_target(cmd_ctx);
1745
1746 if (argc > 0)
1747 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1748
1749 return ERROR_OK;
1750 }
1751
1752 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1753 {
1754 target_t *target = get_current_target(cmd_ctx);
1755
1756 if (argc == 0)
1757 {
1758 watchpoint_t *watchpoint = target->watchpoints;
1759
1760 while (watchpoint)
1761 {
1762 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);
1763 watchpoint = watchpoint->next;
1764 }
1765 }
1766 else if (argc >= 2)
1767 {
1768 enum watchpoint_rw type = WPT_ACCESS;
1769 u32 data_value = 0x0;
1770 u32 data_mask = 0xffffffff;
1771
1772 if (argc >= 3)
1773 {
1774 switch(args[2][0])
1775 {
1776 case 'r':
1777 type = WPT_READ;
1778 break;
1779 case 'w':
1780 type = WPT_WRITE;
1781 break;
1782 case 'a':
1783 type = WPT_ACCESS;
1784 break;
1785 default:
1786 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1787 return ERROR_OK;
1788 }
1789 }
1790 if (argc >= 4)
1791 {
1792 data_value = strtoul(args[3], NULL, 0);
1793 }
1794 if (argc >= 5)
1795 {
1796 data_mask = strtoul(args[4], NULL, 0);
1797 }
1798 watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask);
1799 }
1800 else
1801 {
1802 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1803 }
1804
1805 return ERROR_OK;
1806 }
1807
1808 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1809 {
1810 target_t *target = get_current_target(cmd_ctx);
1811
1812 if (argc > 0)
1813 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1814
1815 return ERROR_OK;
1816 }
1817
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)