Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- made bp command more verbose
[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 int target_register_user_commands(struct command_context_s *cmd_ctx)
727 {
728 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
729 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
730 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt");
731 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
732 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
733 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction");
734 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
735 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
736
737 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
738 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
739 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
740
741 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
742 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
743 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
744
745 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
746 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
747 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
748 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
749
750 register_command(cmd_ctx, NULL, "load_binary", handle_load_binary_command, COMMAND_EXEC, "load binary <file> <address>");
751 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_binary_command, COMMAND_EXEC, "dump binary <file> <address> <size>");
752
753 return ERROR_OK;
754 }
755
756 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
757 {
758 target_t *target = targets;
759 int count = 0;
760
761 if (argc == 1)
762 {
763 int num = strtoul(args[0], NULL, 0);
764
765 while (target)
766 {
767 count++;
768 target = target->next;
769 }
770
771 if (num < count)
772 cmd_ctx->current_target = num;
773 else
774 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
775
776 return ERROR_OK;
777 }
778
779 while (target)
780 {
781 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
782 target = target->next;
783 }
784
785 return ERROR_OK;
786 }
787
788 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
789 {
790 int i;
791 int found = 0;
792
793 if (argc < 3)
794 {
795 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
796 exit(-1);
797 }
798
799 /* search for the specified target */
800 if (args[0] && (args[0][0] != 0))
801 {
802 for (i = 0; target_types[i]; i++)
803 {
804 if (strcmp(args[0], target_types[i]->name) == 0)
805 {
806 target_t **last_target_p = &targets;
807
808 /* register target specific commands */
809 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
810 {
811 ERROR("couldn't register '%s' commands", args[0]);
812 exit(-1);
813 }
814
815 if (*last_target_p)
816 {
817 while ((*last_target_p)->next)
818 last_target_p = &((*last_target_p)->next);
819 last_target_p = &((*last_target_p)->next);
820 }
821
822 *last_target_p = malloc(sizeof(target_t));
823
824 (*last_target_p)->type = target_types[i];
825
826 if (strcmp(args[1], "big") == 0)
827 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
828 else if (strcmp(args[1], "little") == 0)
829 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
830 else
831 {
832 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
833 exit(-1);
834 }
835
836 /* what to do on a target reset */
837 if (strcmp(args[2], "reset_halt") == 0)
838 (*last_target_p)->reset_mode = RESET_HALT;
839 else if (strcmp(args[2], "reset_run") == 0)
840 (*last_target_p)->reset_mode = RESET_RUN;
841 else if (strcmp(args[2], "reset_init") == 0)
842 (*last_target_p)->reset_mode = RESET_INIT;
843 else if (strcmp(args[2], "run_and_halt") == 0)
844 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
845 else if (strcmp(args[2], "run_and_init") == 0)
846 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
847 else
848 {
849 ERROR("unknown target startup mode %s", args[2]);
850 exit(-1);
851 }
852 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
853
854 (*last_target_p)->reset_script = NULL;
855 (*last_target_p)->post_halt_script = NULL;
856 (*last_target_p)->pre_resume_script = NULL;
857
858 (*last_target_p)->working_area = 0x0;
859 (*last_target_p)->working_area_size = 0x0;
860 (*last_target_p)->working_areas = NULL;
861 (*last_target_p)->backup_working_area = 0;
862
863 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
864 (*last_target_p)->state = TARGET_UNKNOWN;
865 (*last_target_p)->reg_cache = NULL;
866 (*last_target_p)->breakpoints = NULL;
867 (*last_target_p)->watchpoints = NULL;
868 (*last_target_p)->next = NULL;
869 (*last_target_p)->arch_info = NULL;
870
871 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
872
873 found = 1;
874 break;
875 }
876 }
877 }
878
879 /* no matching target found */
880 if (!found)
881 {
882 ERROR("target '%s' not found", args[0]);
883 exit(-1);
884 }
885
886 return ERROR_OK;
887 }
888
889 /* usage: target_script <target#> <event> <script_file> */
890 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
891 {
892 target_t *target = NULL;
893
894 if (argc < 3)
895 {
896 ERROR("incomplete target_script command");
897 exit(-1);
898 }
899
900 target = get_target_by_num(strtoul(args[0], NULL, 0));
901
902 if (!target)
903 {
904 ERROR("target number '%s' not defined", args[0]);
905 exit(-1);
906 }
907
908 if (strcmp(args[1], "reset") == 0)
909 {
910 if (target->reset_script)
911 free(target->reset_script);
912 target->reset_script = strdup(args[2]);
913 }
914 else if (strcmp(args[1], "post_halt") == 0)
915 {
916 if (target->post_halt_script)
917 free(target->post_halt_script);
918 target->post_halt_script = strdup(args[2]);
919 }
920 else if (strcmp(args[1], "pre_resume") == 0)
921 {
922 if (target->pre_resume_script)
923 free(target->pre_resume_script);
924 target->pre_resume_script = strdup(args[2]);
925 }
926 else
927 {
928 ERROR("unknown event type: '%s", args[1]);
929 exit(-1);
930 }
931
932 return ERROR_OK;
933 }
934
935 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
936 {
937 target_t *target = NULL;
938
939 if (argc < 2)
940 {
941 ERROR("incomplete run_and_halt_time command");
942 exit(-1);
943 }
944
945 target = get_target_by_num(strtoul(args[0], NULL, 0));
946
947 if (!target)
948 {
949 ERROR("target number '%s' not defined", args[0]);
950 exit(-1);
951 }
952
953 target->run_and_halt_time = strtoul(args[1], NULL, 0);
954
955 return ERROR_OK;
956 }
957
958 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
959 {
960 target_t *target = NULL;
961
962 if (argc < 4)
963 {
964 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
965 exit(-1);
966 }
967
968 target = get_target_by_num(strtoul(args[0], NULL, 0));
969
970 if (!target)
971 {
972 ERROR("target number '%s' not defined", args[0]);
973 exit(-1);
974 }
975
976 target->working_area = strtoul(args[1], NULL, 0);
977 target->working_area_size = strtoul(args[2], NULL, 0);
978
979 if (strcmp(args[3], "backup") == 0)
980 {
981 target->backup_working_area = 1;
982 }
983 else if (strcmp(args[3], "nobackup") == 0)
984 {
985 target->backup_working_area = 0;
986 }
987 else
988 {
989 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
990 exit(-1);
991 }
992
993 return ERROR_OK;
994 }
995
996
997 /* process target state changes */
998 int handle_target(void *priv)
999 {
1000 int retval;
1001 target_t *target = targets;
1002
1003 while (target)
1004 {
1005 /* only poll if target isn't already halted */
1006 if (target->state != TARGET_HALTED)
1007 {
1008 if (target_continous_poll)
1009 if ((retval = target->type->poll(target)) < 0)
1010 {
1011 ERROR("couldn't poll target, exiting");
1012 exit(-1);
1013 }
1014 }
1015
1016 target = target->next;
1017 }
1018
1019 return ERROR_OK;
1020 }
1021
1022 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1023 {
1024 target_t *target;
1025 reg_t *reg = NULL;
1026 int count = 0;
1027 char *value;
1028
1029 DEBUG("");
1030
1031 target = get_current_target(cmd_ctx);
1032
1033 /* list all available registers for the current target */
1034 if (argc == 0)
1035 {
1036 reg_cache_t *cache = target->reg_cache;
1037
1038 count = 0;
1039 while(cache)
1040 {
1041 int i;
1042 for (i = 0; i < cache->num_regs; i++)
1043 {
1044 value = buf_to_char(cache->reg_list[i].value, cache->reg_list[i].size);
1045 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);
1046 free(value);
1047 }
1048 cache = cache->next;
1049 }
1050
1051 return ERROR_OK;
1052 }
1053
1054 /* access a single register by its ordinal number */
1055 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1056 {
1057 int num = strtoul(args[0], NULL, 0);
1058 reg_cache_t *cache = target->reg_cache;
1059
1060 count = 0;
1061 while(cache)
1062 {
1063 int i;
1064 for (i = 0; i < cache->num_regs; i++)
1065 {
1066 if (count++ == num)
1067 {
1068 reg = &cache->reg_list[i];
1069 break;
1070 }
1071 }
1072 if (reg)
1073 break;
1074 cache = cache->next;
1075 }
1076
1077 if (!reg)
1078 {
1079 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1080 return ERROR_OK;
1081 }
1082 } else /* access a single register by its name */
1083 {
1084 reg = register_get_by_name(target->reg_cache, args[0], 1);
1085
1086 if (!reg)
1087 {
1088 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1089 return ERROR_OK;
1090 }
1091 }
1092
1093 /* display a register */
1094 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1095 {
1096 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1097 reg->valid = 0;
1098
1099 if (reg->valid == 0)
1100 {
1101 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1102 if (arch_type == NULL)
1103 {
1104 ERROR("BUG: encountered unregistered arch type");
1105 return ERROR_OK;
1106 }
1107 arch_type->get(reg);
1108 }
1109 value = buf_to_char(reg->value, reg->size);
1110 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1111 free(value);
1112 return ERROR_OK;
1113 }
1114
1115 /* set register value */
1116 if (argc == 2)
1117 {
1118 u32 new_value = strtoul(args[1], NULL, 0);
1119 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1120 if (arch_type == NULL)
1121 {
1122 ERROR("BUG: encountered unregistered arch type");
1123 return ERROR_OK;
1124 }
1125
1126 arch_type->set(reg, new_value);
1127 value = buf_to_char(reg->value, reg->size);
1128 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1129 free(value);
1130
1131 return ERROR_OK;
1132 }
1133
1134 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1135
1136 return ERROR_OK;
1137 }
1138
1139 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1140 {
1141 target_t *target = get_current_target(cmd_ctx);
1142 char buffer[512];
1143
1144 if (argc == 0)
1145 {
1146 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1147 if (target->state == TARGET_HALTED)
1148 {
1149 target->type->arch_state(target, buffer, 512);
1150 buffer[511] = 0;
1151 command_print(cmd_ctx, "%s", buffer);
1152 }
1153 }
1154 else
1155 {
1156 if (strcmp(args[0], "on") == 0)
1157 {
1158 target_continous_poll = 1;
1159 }
1160 else if (strcmp(args[0], "off") == 0)
1161 {
1162 target_continous_poll = 0;
1163 }
1164 }
1165
1166
1167 return ERROR_OK;
1168 }
1169
1170 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1171 {
1172 target_t *target = get_current_target(cmd_ctx);
1173 struct timeval timeout, now;
1174
1175 gettimeofday(&timeout, NULL);
1176 timeval_add_time(&timeout, 5, 0);
1177
1178 command_print(cmd_ctx, "waiting for target halted...");
1179
1180 while(target->type->poll(target))
1181 {
1182 if (target->state == TARGET_HALTED)
1183 {
1184 command_print(cmd_ctx, "target halted");
1185 break;
1186 }
1187 target_call_timer_callbacks();
1188
1189 gettimeofday(&now, NULL);
1190 if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))
1191 {
1192 command_print(cmd_ctx, "timed out while waiting for target halt");
1193 ERROR("timed out while waiting for target halt");
1194 break;
1195 }
1196 }
1197
1198 return ERROR_OK;
1199 }
1200
1201 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1202 {
1203 int retval;
1204 target_t *target = get_current_target(cmd_ctx);
1205
1206 DEBUG("");
1207
1208 command_print(cmd_ctx, "requesting target halt...");
1209
1210 if ((retval = target->type->halt(target)) != ERROR_OK)
1211 {
1212 switch (retval)
1213 {
1214 case ERROR_TARGET_ALREADY_HALTED:
1215 command_print(cmd_ctx, "target already halted");
1216 break;
1217 case ERROR_TARGET_TIMEOUT:
1218 command_print(cmd_ctx, "target timed out... shutting down");
1219 exit(-1);
1220 default:
1221 command_print(cmd_ctx, "unknown error... shutting down");
1222 exit(-1);
1223 }
1224 }
1225
1226 return ERROR_OK;
1227
1228 }
1229
1230 /* what to do on daemon startup */
1231 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1232 {
1233 if (argc == 1)
1234 {
1235 if (strcmp(args[0], "attach") == 0)
1236 {
1237 startup_mode = DAEMON_ATTACH;
1238 return ERROR_OK;
1239 }
1240 else if (strcmp(args[0], "reset") == 0)
1241 {
1242 startup_mode = DAEMON_RESET;
1243 return ERROR_OK;
1244 }
1245 }
1246
1247 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1248 return ERROR_OK;
1249
1250 }
1251
1252 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1253 {
1254 target_t *target = get_current_target(cmd_ctx);
1255 int retval;
1256
1257 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1258
1259 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1260 {
1261 switch (retval)
1262 {
1263 case ERROR_TARGET_TIMEOUT:
1264 command_print(cmd_ctx, "target timed out... shutting down");
1265 exit(-1);
1266 default:
1267 command_print(cmd_ctx, "unknown error... shutting down");
1268 exit(-1);
1269 }
1270 }
1271
1272 return ERROR_OK;
1273 }
1274
1275 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1276 {
1277 target_t *target = get_current_target(cmd_ctx);
1278 enum target_reset_mode reset_mode = RESET_RUN;
1279
1280 DEBUG("");
1281
1282 if (argc >= 1)
1283 {
1284 if (strcmp("run", args[0]) == 0)
1285 reset_mode = RESET_RUN;
1286 else if (strcmp("halt", args[0]) == 0)
1287 reset_mode = RESET_HALT;
1288 else if (strcmp("init", args[0]) == 0)
1289 reset_mode = RESET_INIT;
1290 else if (strcmp("run_and_halt", args[0]) == 0)
1291 {
1292 reset_mode = RESET_RUN_AND_HALT;
1293 if (argc >= 2)
1294 {
1295 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1296 }
1297 }
1298 else if (strcmp("run_and_init", args[0]) == 0)
1299 {
1300 reset_mode = RESET_RUN_AND_INIT;
1301 if (argc >= 2)
1302 {
1303 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1304 }
1305 }
1306 else
1307 {
1308 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1309 return ERROR_OK;
1310 }
1311 target->reset_mode = reset_mode;
1312 }
1313
1314 target_process_reset(cmd_ctx);
1315
1316 return ERROR_OK;
1317 }
1318
1319 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1320 {
1321 int retval;
1322 target_t *target = get_current_target(cmd_ctx);
1323
1324 DEBUG("");
1325
1326 if (argc == 0)
1327 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1328 else if (argc == 1)
1329 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1330 else
1331 {
1332 command_print(cmd_ctx, "usage: resume [address]");
1333 return ERROR_OK;
1334 }
1335
1336 if (retval != ERROR_OK)
1337 {
1338 switch (retval)
1339 {
1340 case ERROR_TARGET_NOT_HALTED:
1341 command_print(cmd_ctx, "target not halted");
1342 break;
1343 default:
1344 command_print(cmd_ctx, "unknown error... shutting down");
1345 exit(-1);
1346 }
1347 }
1348
1349 return ERROR_OK;
1350 }
1351
1352 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1353 {
1354 target_t *target = get_current_target(cmd_ctx);
1355
1356 DEBUG("");
1357
1358 if (argc == 0)
1359 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1360
1361 if (argc == 1)
1362 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1363
1364 return ERROR_OK;
1365 }
1366
1367 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1368 {
1369 int count = 1;
1370 int size = 4;
1371 u32 address = 0;
1372 int i;
1373
1374 char output[128];
1375 int output_len;
1376
1377 int retval;
1378
1379 u8 *buffer;
1380 target_t *target = get_current_target(cmd_ctx);
1381
1382 if (argc < 1)
1383 return ERROR_OK;
1384
1385 if (argc == 2)
1386 count = strtoul(args[1], NULL, 0);
1387
1388 address = strtoul(args[0], NULL, 0);
1389
1390
1391 switch (cmd[2])
1392 {
1393 case 'w':
1394 size = 4;
1395 break;
1396 case 'h':
1397 size = 2;
1398 break;
1399 case 'b':
1400 size = 1;
1401 break;
1402 default:
1403 return ERROR_OK;
1404 }
1405
1406 buffer = calloc(count, size);
1407 if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK)
1408 {
1409 switch (retval)
1410 {
1411 case ERROR_TARGET_UNALIGNED_ACCESS:
1412 command_print(cmd_ctx, "error: address not aligned");
1413 break;
1414 case ERROR_TARGET_NOT_HALTED:
1415 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1416 break;
1417 case ERROR_TARGET_DATA_ABORT:
1418 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1419 break;
1420 default:
1421 command_print(cmd_ctx, "error: unknown error");
1422 break;
1423 }
1424 }
1425
1426 output_len = 0;
1427
1428 for (i = 0; i < count; i++)
1429 {
1430 if (i%8 == 0)
1431 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1432
1433 switch (size)
1434 {
1435 case 4:
1436 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", ((u32*)buffer)[i]);
1437 break;
1438 case 2:
1439 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", ((u16*)buffer)[i]);
1440 break;
1441 case 1:
1442 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", ((u8*)buffer)[i]);
1443 break;
1444 }
1445
1446 if ((i%8 == 7) || (i == count - 1))
1447 {
1448 command_print(cmd_ctx, output);
1449 output_len = 0;
1450 }
1451 }
1452
1453 free(buffer);
1454
1455 return ERROR_OK;
1456 }
1457
1458 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1459 {
1460 u32 address = 0;
1461 u32 value = 0;
1462 int retval;
1463 target_t *target = get_current_target(cmd_ctx);
1464
1465 if (argc < 2)
1466 return ERROR_OK;
1467
1468 address = strtoul(args[0], NULL, 0);
1469 value = strtoul(args[1], NULL, 0);
1470
1471 switch (cmd[2])
1472 {
1473 case 'w':
1474 retval = target->type->write_memory(target, address, 4, 1, (u8*)&value);
1475 break;
1476 case 'h':
1477 retval = target->type->write_memory(target, address, 2, 1, (u8*)&value);
1478 break;
1479 case 'b':
1480 retval = target->type->write_memory(target, address, 1, 1, (u8*)&value);
1481 break;
1482 default:
1483 return ERROR_OK;
1484 }
1485
1486 switch (retval)
1487 {
1488 case ERROR_TARGET_UNALIGNED_ACCESS:
1489 command_print(cmd_ctx, "error: address not aligned");
1490 break;
1491 case ERROR_TARGET_DATA_ABORT:
1492 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1493 break;
1494 case ERROR_TARGET_NOT_HALTED:
1495 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1496 break;
1497 case ERROR_OK:
1498 break;
1499 default:
1500 command_print(cmd_ctx, "error: unknown error");
1501 break;
1502 }
1503
1504 return ERROR_OK;
1505
1506 }
1507
1508 int handle_load_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1509 {
1510 FILE *binary;
1511 u32 address;
1512 struct stat binary_stat;
1513 u32 binary_size;
1514
1515 u8 *buffer;
1516 u32 buf_cnt;
1517
1518 struct timeval start, end, duration;
1519
1520 target_t *target = get_current_target(cmd_ctx);
1521
1522 if (argc != 2)
1523 {
1524 command_print(cmd_ctx, "usage: load_binary <filename> <address>");
1525 return ERROR_OK;
1526 }
1527
1528 address = strtoul(args[1], NULL, 0);
1529
1530 if (stat(args[0], &binary_stat) == -1)
1531 {
1532 ERROR("couldn't stat() %s: %s", args[0], strerror(errno));
1533 command_print(cmd_ctx, "error accessing file %s", args[0]);
1534 return ERROR_OK;
1535 }
1536
1537 if (!(binary = fopen(args[0], "rb")))
1538 {
1539 ERROR("couldn't open %s: %s", args[0], strerror(errno));
1540 command_print(cmd_ctx, "error accessing file %s", args[0]);
1541 return ERROR_OK;
1542 }
1543
1544 buffer = malloc(128 * 1024);
1545
1546 gettimeofday(&start, NULL);
1547
1548 binary_size = binary_stat.st_size;
1549 while (binary_size > 0)
1550 {
1551 buf_cnt = fread(buffer, 1, 128*1024, binary);
1552 target_write_buffer(target, address, buf_cnt, buffer);
1553 address += buf_cnt;
1554 binary_size -= buf_cnt;
1555 }
1556
1557 gettimeofday(&end, NULL);
1558
1559 free(buffer);
1560
1561 timeval_subtract(&duration, &end, &start);
1562 command_print(cmd_ctx, "downloaded %lli byte in %is %ius", (long long) binary_stat.st_size, duration.tv_sec, duration.tv_usec);
1563
1564 fclose(binary);
1565
1566 return ERROR_OK;
1567
1568 }
1569
1570 int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1571 {
1572 FILE *binary;
1573 u32 address;
1574 u32 size;
1575 u8 buffer[560];
1576
1577 target_t *target = get_current_target(cmd_ctx);
1578
1579 if (argc != 3)
1580 {
1581 command_print(cmd_ctx, "usage: dump_binary <filename> <address> <size>");
1582 return ERROR_OK;
1583 }
1584
1585 address = strtoul(args[1], NULL, 0);
1586 size = strtoul(args[2], NULL, 0);
1587
1588 if (!(binary = fopen(args[0], "wb")))
1589 {
1590 ERROR("couldn't open %s for writing: %s", args[0], strerror(errno));
1591 command_print(cmd_ctx, "error accessing file %s", args[0]);
1592 return ERROR_OK;
1593 }
1594
1595 if ((address & 3) || (size & 3))
1596 {
1597 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1598 return ERROR_OK;
1599 }
1600
1601 while (size > 0)
1602 {
1603 u32 this_run_size = (size > 560) ? 560 : size;
1604 target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1605 fwrite(buffer, 1, this_run_size, binary);
1606 size -= this_run_size;
1607 address += this_run_size;
1608 }
1609
1610 fclose(binary);
1611
1612 return ERROR_OK;
1613
1614 }
1615
1616 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1617 {
1618 int retval;
1619 target_t *target = get_current_target(cmd_ctx);
1620
1621 if (argc == 0)
1622 {
1623 breakpoint_t *breakpoint = target->breakpoints;
1624
1625 while (breakpoint)
1626 {
1627 if (breakpoint->type == BKPT_SOFT)
1628 {
1629 char* buf = buf_to_char(breakpoint->orig_instr, breakpoint->length);
1630 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
1631 free(buf);
1632 }
1633 else
1634 {
1635 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
1636 }
1637 breakpoint = breakpoint->next;
1638 }
1639 }
1640 else if (argc >= 2)
1641 {
1642 int hw = BKPT_SOFT;
1643 u32 length = 0;
1644
1645 length = strtoul(args[1], NULL, 0);
1646
1647 if (argc >= 3)
1648 if (strcmp(args[2], "hw") == 0)
1649 hw = BKPT_HARD;
1650
1651 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
1652 {
1653 switch (retval)
1654 {
1655 case ERROR_TARGET_NOT_HALTED:
1656 command_print(cmd_ctx, "target must be halted to set breakpoints");
1657 break;
1658 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
1659 command_print(cmd_ctx, "no more breakpoints available");
1660 break;
1661 default:
1662 command_print(cmd_ctx, "unknown error, breakpoint not set");
1663 break;
1664 }
1665 }
1666 else
1667 {
1668 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
1669 }
1670 }
1671 else
1672 {
1673 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
1674 }
1675
1676 return ERROR_OK;
1677 }
1678
1679 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1680 {
1681 target_t *target = get_current_target(cmd_ctx);
1682
1683 if (argc > 0)
1684 breakpoint_remove(target, strtoul(args[0], NULL, 0));
1685
1686 return ERROR_OK;
1687 }
1688
1689 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1690 {
1691 target_t *target = get_current_target(cmd_ctx);
1692
1693 if (argc == 0)
1694 {
1695 watchpoint_t *watchpoint = target->watchpoints;
1696
1697 while (watchpoint)
1698 {
1699 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);
1700 watchpoint = watchpoint->next;
1701 }
1702 }
1703 else if (argc >= 2)
1704 {
1705 enum watchpoint_rw type = WPT_ACCESS;
1706 u32 data_value = 0x0;
1707 u32 data_mask = 0xffffffff;
1708
1709 if (argc >= 3)
1710 {
1711 switch(args[2][0])
1712 {
1713 case 'r':
1714 type = WPT_READ;
1715 break;
1716 case 'w':
1717 type = WPT_WRITE;
1718 break;
1719 case 'a':
1720 type = WPT_ACCESS;
1721 break;
1722 default:
1723 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1724 return ERROR_OK;
1725 }
1726 }
1727 if (argc >= 4)
1728 {
1729 data_value = strtoul(args[3], NULL, 0);
1730 }
1731 if (argc >= 5)
1732 {
1733 data_mask = strtoul(args[4], NULL, 0);
1734 }
1735 watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask);
1736 }
1737 else
1738 {
1739 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
1740 }
1741
1742 return ERROR_OK;
1743 }
1744
1745 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1746 {
1747 target_t *target = get_current_target(cmd_ctx);
1748
1749 if (argc > 0)
1750 watchpoint_remove(target, strtoul(args[0], NULL, 0));
1751
1752 return ERROR_OK;
1753 }
1754
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)