Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- added synchronous wait/resume patch. Thanks Øyvind Harboe
[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 #include "target_request.h"
27
28 #include "log.h"
29 #include "configuration.h"
30 #include "binarybuffer.h"
31 #include "jtag.h"
32
33 #include <string.h>
34 #include <stdlib.h>
35 #include <inttypes.h>
36
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <unistd.h>
40 #include <errno.h>
41
42 #include <sys/time.h>
43 #include <time.h>
44
45 #include <time_support.h>
46
47 #include <fileio.h>
48 #include <image.h>
49
50 int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
51
52 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55
56 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
59
60 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
61 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
62 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
63 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
64 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
65 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
66 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
70 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
71 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
72 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
77
78 /* targets
79 */
80 extern target_type_t arm7tdmi_target;
81 extern target_type_t arm720t_target;
82 extern target_type_t arm9tdmi_target;
83 extern target_type_t arm920t_target;
84 extern target_type_t arm966e_target;
85 extern target_type_t arm926ejs_target;
86 extern target_type_t xscale_target;
87 extern target_type_t cortexm3_target;
88
89 target_type_t *target_types[] =
90 {
91 &arm7tdmi_target,
92 &arm9tdmi_target,
93 &arm920t_target,
94 &arm720t_target,
95 &arm966e_target,
96 &arm926ejs_target,
97 &xscale_target,
98 &cortexm3_target,
99 NULL,
100 };
101
102 target_t *targets = NULL;
103 target_event_callback_t *target_event_callbacks = NULL;
104 target_timer_callback_t *target_timer_callbacks = NULL;
105
106 char *target_state_strings[] =
107 {
108 "unknown",
109 "running",
110 "halted",
111 "reset",
112 "debug_running",
113 };
114
115 char *target_debug_reason_strings[] =
116 {
117 "debug request", "breakpoint", "watchpoint",
118 "watchpoint and breakpoint", "single step",
119 "target not halted"
120 };
121
122 char *target_endianess_strings[] =
123 {
124 "big endian",
125 "little endian",
126 };
127
128 enum daemon_startup_mode startup_mode = DAEMON_ATTACH;
129
130 static int target_continous_poll = 1;
131
132 /* read a u32 from a buffer in target memory endianness */
133 u32 target_buffer_get_u32(target_t *target, u8 *buffer)
134 {
135 if (target->endianness == TARGET_LITTLE_ENDIAN)
136 return le_to_h_u32(buffer);
137 else
138 return be_to_h_u32(buffer);
139 }
140
141 /* read a u16 from a buffer in target memory endianness */
142 u16 target_buffer_get_u16(target_t *target, u8 *buffer)
143 {
144 if (target->endianness == TARGET_LITTLE_ENDIAN)
145 return le_to_h_u16(buffer);
146 else
147 return be_to_h_u16(buffer);
148 }
149
150 /* write a u32 to a buffer in target memory endianness */
151 void target_buffer_set_u32(target_t *target, u8 *buffer, u32 value)
152 {
153 if (target->endianness == TARGET_LITTLE_ENDIAN)
154 h_u32_to_le(buffer, value);
155 else
156 h_u32_to_be(buffer, value);
157 }
158
159 /* write a u16 to a buffer in target memory endianness */
160 void target_buffer_set_u16(target_t *target, u8 *buffer, u16 value)
161 {
162 if (target->endianness == TARGET_LITTLE_ENDIAN)
163 h_u16_to_le(buffer, value);
164 else
165 h_u16_to_be(buffer, value);
166 }
167
168 /* returns a pointer to the n-th configured target */
169 target_t* get_target_by_num(int num)
170 {
171 target_t *target = targets;
172 int i = 0;
173
174 while (target)
175 {
176 if (num == i)
177 return target;
178 target = target->next;
179 i++;
180 }
181
182 return NULL;
183 }
184
185 int get_num_by_target(target_t *query_target)
186 {
187 target_t *target = targets;
188 int i = 0;
189
190 while (target)
191 {
192 if (target == query_target)
193 return i;
194 target = target->next;
195 i++;
196 }
197
198 return -1;
199 }
200
201 target_t* get_current_target(command_context_t *cmd_ctx)
202 {
203 target_t *target = get_target_by_num(cmd_ctx->current_target);
204
205 if (target == NULL)
206 {
207 ERROR("BUG: current_target out of bounds");
208 exit(-1);
209 }
210
211 return target;
212 }
213
214 /* Process target initialization, when target entered debug out of reset
215 * the handler is unregistered at the end of this function, so it's only called once
216 */
217 int target_init_handler(struct target_s *target, enum target_event event, void *priv)
218 {
219 FILE *script;
220 struct command_context_s *cmd_ctx = priv;
221
222 if ((event == TARGET_EVENT_HALTED) && (target->reset_script))
223 {
224 target_unregister_event_callback(target_init_handler, priv);
225
226 script = fopen(target->reset_script, "r");
227 if (!script)
228 {
229 ERROR("couldn't open script file %s", target->reset_script);
230 return ERROR_OK;
231 }
232
233 INFO("executing reset script '%s'", target->reset_script);
234 command_run_file(cmd_ctx, script, COMMAND_EXEC);
235 fclose(script);
236
237 jtag_execute_queue();
238 }
239
240 return ERROR_OK;
241 }
242
243 int target_run_and_halt_handler(void *priv)
244 {
245 target_t *target = priv;
246
247 target->type->halt(target);
248
249 return ERROR_OK;
250 }
251
252 int target_process_reset(struct command_context_s *cmd_ctx)
253 {
254 int retval = ERROR_OK;
255 target_t *target;
256 struct timeval timeout, now;
257
258 /* prepare reset_halt where necessary */
259 target = targets;
260 while (target)
261 {
262 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
263 {
264 switch (target->reset_mode)
265 {
266 case RESET_HALT:
267 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
268 target->reset_mode = RESET_RUN_AND_HALT;
269 break;
270 case RESET_INIT:
271 command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
272 target->reset_mode = RESET_RUN_AND_INIT;
273 break;
274 default:
275 break;
276 }
277 }
278 switch (target->reset_mode)
279 {
280 case RESET_HALT:
281 case RESET_INIT:
282 target->type->prepare_reset_halt(target);
283 break;
284 default:
285 break;
286 }
287 target = target->next;
288 }
289
290 target = targets;
291 while (target)
292 {
293 target->type->assert_reset(target);
294 target = target->next;
295 }
296 jtag_execute_queue();
297
298 /* request target halt if necessary, and schedule further action */
299 target = targets;
300 while (target)
301 {
302 switch (target->reset_mode)
303 {
304 case RESET_RUN:
305 /* nothing to do if target just wants to be run */
306 break;
307 case RESET_RUN_AND_HALT:
308 /* schedule halt */
309 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
310 break;
311 case RESET_RUN_AND_INIT:
312 /* schedule halt */
313 target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
314 target_register_event_callback(target_init_handler, cmd_ctx);
315 break;
316 case RESET_HALT:
317 target->type->halt(target);
318 break;
319 case RESET_INIT:
320 target->type->halt(target);
321 target_register_event_callback(target_init_handler, cmd_ctx);
322 break;
323 default:
324 ERROR("BUG: unknown target->reset_mode");
325 }
326 target = target->next;
327 }
328
329 target = targets;
330 while (target)
331 {
332 target->type->deassert_reset(target);
333 target = target->next;
334 }
335 jtag_execute_queue();
336
337 /* Wait for reset to complete, maximum 5 seconds. */
338 gettimeofday(&timeout, NULL);
339 timeval_add_time(&timeout, 5, 0);
340 for(;;)
341 {
342 gettimeofday(&now, NULL);
343
344 target_call_timer_callbacks();
345
346 target = targets;
347 while (target)
348 {
349 target->type->poll(target);
350 if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT))
351 {
352 if (target->state != TARGET_HALTED)
353 {
354 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
355 {
356 command_print(cmd_ctx, "Timed out waiting for reset");
357 goto done;
358 }
359 usleep(100*1000); /* Do not eat all cpu */
360 goto again;
361 }
362 }
363 target = target->next;
364 }
365 /* All targets we're waiting for are halted */
366 break;
367
368 again:;
369 }
370 done:
371
372
373 /* We want any events to be processed before the prompt */
374 target_call_timer_callbacks();
375
376 return retval;
377 }
378
379 int target_init(struct command_context_s *cmd_ctx)
380 {
381 target_t *target = targets;
382
383 while (target)
384 {
385 if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
386 {
387 ERROR("target '%s' init failed", target->type->name);
388 exit(-1);
389 }
390 target = target->next;
391 }
392
393 if (targets)
394 {
395 target_register_user_commands(cmd_ctx);
396 target_register_timer_callback(handle_target, 100, 1, NULL);
397 }
398
399 return ERROR_OK;
400 }
401
402 int target_init_reset(struct command_context_s *cmd_ctx)
403 {
404 if (startup_mode == DAEMON_RESET)
405 target_process_reset(cmd_ctx);
406
407 return ERROR_OK;
408 }
409
410 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
411 {
412 target_event_callback_t **callbacks_p = &target_event_callbacks;
413
414 if (callback == NULL)
415 {
416 return ERROR_INVALID_ARGUMENTS;
417 }
418
419 if (*callbacks_p)
420 {
421 while ((*callbacks_p)->next)
422 callbacks_p = &((*callbacks_p)->next);
423 callbacks_p = &((*callbacks_p)->next);
424 }
425
426 (*callbacks_p) = malloc(sizeof(target_event_callback_t));
427 (*callbacks_p)->callback = callback;
428 (*callbacks_p)->priv = priv;
429 (*callbacks_p)->next = NULL;
430
431 return ERROR_OK;
432 }
433
434 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
435 {
436 target_timer_callback_t **callbacks_p = &target_timer_callbacks;
437 struct timeval now;
438
439 if (callback == NULL)
440 {
441 return ERROR_INVALID_ARGUMENTS;
442 }
443
444 if (*callbacks_p)
445 {
446 while ((*callbacks_p)->next)
447 callbacks_p = &((*callbacks_p)->next);
448 callbacks_p = &((*callbacks_p)->next);
449 }
450
451 (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
452 (*callbacks_p)->callback = callback;
453 (*callbacks_p)->periodic = periodic;
454 (*callbacks_p)->time_ms = time_ms;
455
456 gettimeofday(&now, NULL);
457 (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
458 time_ms -= (time_ms % 1000);
459 (*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
460 if ((*callbacks_p)->when.tv_usec > 1000000)
461 {
462 (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
463 (*callbacks_p)->when.tv_sec += 1;
464 }
465
466 (*callbacks_p)->priv = priv;
467 (*callbacks_p)->next = NULL;
468
469 return ERROR_OK;
470 }
471
472 int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
473 {
474 target_event_callback_t **p = &target_event_callbacks;
475 target_event_callback_t *c = target_event_callbacks;
476
477 if (callback == NULL)
478 {
479 return ERROR_INVALID_ARGUMENTS;
480 }
481
482 while (c)
483 {
484 target_event_callback_t *next = c->next;
485 if ((c->callback == callback) && (c->priv == priv))
486 {
487 *p = next;
488 free(c);
489 return ERROR_OK;
490 }
491 else
492 p = &(c->next);
493 c = next;
494 }
495
496 return ERROR_OK;
497 }
498
499 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
500 {
501 target_timer_callback_t **p = &target_timer_callbacks;
502 target_timer_callback_t *c = target_timer_callbacks;
503
504 if (callback == NULL)
505 {
506 return ERROR_INVALID_ARGUMENTS;
507 }
508
509 while (c)
510 {
511 target_timer_callback_t *next = c->next;
512 if ((c->callback == callback) && (c->priv == priv))
513 {
514 *p = next;
515 free(c);
516 return ERROR_OK;
517 }
518 else
519 p = &(c->next);
520 c = next;
521 }
522
523 return ERROR_OK;
524 }
525
526 int target_call_event_callbacks(target_t *target, enum target_event event)
527 {
528 target_event_callback_t *callback = target_event_callbacks;
529 target_event_callback_t *next_callback;
530
531 DEBUG("target event %i", event);
532
533 while (callback)
534 {
535 next_callback = callback->next;
536 callback->callback(target, event, callback->priv);
537 callback = next_callback;
538 }
539
540 return ERROR_OK;
541 }
542
543 int target_call_timer_callbacks()
544 {
545 target_timer_callback_t *callback = target_timer_callbacks;
546 target_timer_callback_t *next_callback;
547 struct timeval now;
548
549 gettimeofday(&now, NULL);
550
551 while (callback)
552 {
553 next_callback = callback->next;
554
555 if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec))
556 || (now.tv_sec > callback->when.tv_sec))
557 {
558 callback->callback(callback->priv);
559 if (callback->periodic)
560 {
561 int time_ms = callback->time_ms;
562 callback->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
563 time_ms -= (time_ms % 1000);
564 callback->when.tv_sec = now.tv_sec + time_ms / 1000;
565 if (callback->when.tv_usec > 1000000)
566 {
567 callback->when.tv_usec = callback->when.tv_usec - 1000000;
568 callback->when.tv_sec += 1;
569 }
570 }
571 else
572 target_unregister_timer_callback(callback->callback, callback->priv);
573 }
574
575 callback = next_callback;
576 }
577
578 return ERROR_OK;
579 }
580
581 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
582 {
583 working_area_t *c = target->working_areas;
584 working_area_t *new_wa = NULL;
585
586 /* only allocate multiples of 4 byte */
587 if (size % 4)
588 {
589 ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
590 size = CEIL(size, 4);
591 }
592
593 /* see if there's already a matching working area */
594 while (c)
595 {
596 if ((c->free) && (c->size == size))
597 {
598 new_wa = c;
599 break;
600 }
601 c = c->next;
602 }
603
604 /* if not, allocate a new one */
605 if (!new_wa)
606 {
607 working_area_t **p = &target->working_areas;
608 u32 first_free = target->working_area;
609 u32 free_size = target->working_area_size;
610
611 DEBUG("allocating new working area");
612
613 c = target->working_areas;
614 while (c)
615 {
616 first_free += c->size;
617 free_size -= c->size;
618 p = &c->next;
619 c = c->next;
620 }
621
622 if (free_size < size)
623 {
624 WARNING("not enough working area available");
625 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
626 }
627
628 new_wa = malloc(sizeof(working_area_t));
629 new_wa->next = NULL;
630 new_wa->size = size;
631 new_wa->address = first_free;
632
633 if (target->backup_working_area)
634 {
635 new_wa->backup = malloc(new_wa->size);
636 target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
637 }
638 else
639 {
640 new_wa->backup = NULL;
641 }
642
643 /* put new entry in list */
644 *p = new_wa;
645 }
646
647 /* mark as used, and return the new (reused) area */
648 new_wa->free = 0;
649 *area = new_wa;
650
651 /* user pointer */
652 new_wa->user = area;
653
654 return ERROR_OK;
655 }
656
657 int target_free_working_area(struct target_s *target, working_area_t *area)
658 {
659 if (area->free)
660 return ERROR_OK;
661
662 if (target->backup_working_area)
663 target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
664
665 area->free = 1;
666
667 /* mark user pointer invalid */
668 *area->user = NULL;
669 area->user = NULL;
670
671 return ERROR_OK;
672 }
673
674 int target_free_all_working_areas(struct target_s *target)
675 {
676 working_area_t *c = target->working_areas;
677
678 while (c)
679 {
680 working_area_t *next = c->next;
681 target_free_working_area(target, c);
682
683 if (c->backup)
684 free(c->backup);
685
686 free(c);
687
688 c = next;
689 }
690
691 target->working_areas = NULL;
692
693 return ERROR_OK;
694 }
695
696 int target_register_commands(struct command_context_s *cmd_ctx)
697 {
698 register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL);
699 register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
700 register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
701 register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
702 register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
703 register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
704
705 return ERROR_OK;
706 }
707
708 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
709 {
710 int retval;
711
712 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
713
714 /* handle writes of less than 4 byte */
715 if (size < 4)
716 {
717 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
718 return retval;
719 return ERROR_OK;
720 }
721
722 /* handle unaligned head bytes */
723 if (address % 4)
724 {
725 int unaligned = 4 - (address % 4);
726
727 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
728 return retval;
729
730 buffer += unaligned;
731 address += unaligned;
732 size -= unaligned;
733 }
734
735 /* handle aligned words */
736 if (size >= 4)
737 {
738 int aligned = size - (size % 4);
739
740 /* use bulk writes above a certain limit. This may have to be changed */
741 if (aligned > 128)
742 {
743 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
744 return retval;
745 }
746 else
747 {
748 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
749 return retval;
750 }
751
752 buffer += aligned;
753 address += aligned;
754 size -= aligned;
755 }
756
757 /* handle tail writes of less than 4 bytes */
758 if (size > 0)
759 {
760 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
761 return retval;
762 }
763
764 return ERROR_OK;
765 }
766
767 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
768 {
769 int retval;
770
771 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
772
773 /* handle reads of less than 4 byte */
774 if (size < 4)
775 {
776 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
777 return retval;
778 return ERROR_OK;
779 }
780
781 /* handle unaligned head bytes */
782 if (address % 4)
783 {
784 int unaligned = 4 - (address % 4);
785
786 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
787 return retval;
788
789 buffer += unaligned;
790 address += unaligned;
791 size -= unaligned;
792 }
793
794 /* handle aligned words */
795 if (size >= 4)
796 {
797 int aligned = size - (size % 4);
798
799 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
800 return retval;
801
802 buffer += aligned;
803 address += aligned;
804 size -= aligned;
805 }
806
807 /* handle tail writes of less than 4 bytes */
808 if (size > 0)
809 {
810 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
811 return retval;
812 }
813
814 return ERROR_OK;
815 }
816
817 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
818 {
819 u8 *buffer;
820 int retval;
821 int i;
822 u32 checksum = 0;
823
824 if ((retval = target->type->checksum_memory(target, address,
825 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
826 {
827 buffer = malloc(size);
828 if (buffer == NULL)
829 {
830 ERROR("error allocating buffer for section (%d bytes)", size);
831 return ERROR_OK;
832 }
833 target_read_buffer(target, address, size, buffer);
834
835 /* convert to target endianess */
836 for (i = 0; i < (size/sizeof(u32)); i++)
837 {
838 u32 target_data;
839 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
840 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
841 }
842
843 retval = image_calculate_checksum( buffer, size, &checksum );
844 free(buffer);
845 }
846
847 *crc = checksum;
848
849 return retval;
850 }
851
852 int target_read_u32(struct target_s *target, u32 address, u32 *value)
853 {
854 u8 value_buf[4];
855
856 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
857
858 if (retval == ERROR_OK)
859 {
860 *value = target_buffer_get_u32(target, value_buf);
861 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
862 }
863 else
864 {
865 *value = 0x0;
866 DEBUG("address: 0x%8.8x failed", address);
867 }
868
869 return retval;
870 }
871
872 int target_read_u16(struct target_s *target, u32 address, u16 *value)
873 {
874 u8 value_buf[2];
875
876 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
877
878 if (retval == ERROR_OK)
879 {
880 *value = target_buffer_get_u16(target, value_buf);
881 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
882 }
883 else
884 {
885 *value = 0x0;
886 DEBUG("address: 0x%8.8x failed", address);
887 }
888
889 return retval;
890 }
891
892 int target_read_u8(struct target_s *target, u32 address, u8 *value)
893 {
894 int retval = target->type->read_memory(target, address, 1, 1, value);
895
896 if (retval == ERROR_OK)
897 {
898 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
899 }
900 else
901 {
902 *value = 0x0;
903 DEBUG("address: 0x%8.8x failed", address);
904 }
905
906 return retval;
907 }
908
909 int target_write_u32(struct target_s *target, u32 address, u32 value)
910 {
911 int retval;
912 u8 value_buf[4];
913
914 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
915
916 target_buffer_set_u32(target, value_buf, value);
917 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
918 {
919 DEBUG("failed: %i", retval);
920 }
921
922 return retval;
923 }
924
925 int target_write_u16(struct target_s *target, u32 address, u16 value)
926 {
927 int retval;
928 u8 value_buf[2];
929
930 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
931
932 target_buffer_set_u16(target, value_buf, value);
933 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
934 {
935 DEBUG("failed: %i", retval);
936 }
937
938 return retval;
939 }
940
941 int target_write_u8(struct target_s *target, u32 address, u8 value)
942 {
943 int retval;
944
945 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
946
947 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
948 {
949 DEBUG("failed: %i", retval);
950 }
951
952 return retval;
953 }
954
955 int target_register_user_commands(struct command_context_s *cmd_ctx)
956 {
957 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
958 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
959 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
960 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
961 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
962 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
963 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
964 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
965
966 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
967 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
968 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
969
970 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
971 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
972 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
973
974 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
975 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
976 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
977 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
978
979 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
980 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
981 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
982 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
983 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
984
985 target_request_register_commands(cmd_ctx);
986 trace_register_commands(cmd_ctx);
987
988 return ERROR_OK;
989 }
990
991 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
992 {
993 target_t *target = targets;
994 int count = 0;
995
996 if (argc == 1)
997 {
998 int num = strtoul(args[0], NULL, 0);
999
1000 while (target)
1001 {
1002 count++;
1003 target = target->next;
1004 }
1005
1006 if (num < count)
1007 cmd_ctx->current_target = num;
1008 else
1009 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1010
1011 return ERROR_OK;
1012 }
1013
1014 while (target)
1015 {
1016 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1017 target = target->next;
1018 }
1019
1020 return ERROR_OK;
1021 }
1022
1023 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1024 {
1025 int i;
1026 int found = 0;
1027
1028 if (argc < 3)
1029 {
1030 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1031 exit(-1);
1032 }
1033
1034 /* search for the specified target */
1035 if (args[0] && (args[0][0] != 0))
1036 {
1037 for (i = 0; target_types[i]; i++)
1038 {
1039 if (strcmp(args[0], target_types[i]->name) == 0)
1040 {
1041 target_t **last_target_p = &targets;
1042
1043 /* register target specific commands */
1044 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1045 {
1046 ERROR("couldn't register '%s' commands", args[0]);
1047 exit(-1);
1048 }
1049
1050 if (*last_target_p)
1051 {
1052 while ((*last_target_p)->next)
1053 last_target_p = &((*last_target_p)->next);
1054 last_target_p = &((*last_target_p)->next);
1055 }
1056
1057 *last_target_p = malloc(sizeof(target_t));
1058
1059 (*last_target_p)->type = target_types[i];
1060
1061 if (strcmp(args[1], "big") == 0)
1062 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1063 else if (strcmp(args[1], "little") == 0)
1064 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1065 else
1066 {
1067 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1068 exit(-1);
1069 }
1070
1071 /* what to do on a target reset */
1072 if (strcmp(args[2], "reset_halt") == 0)
1073 (*last_target_p)->reset_mode = RESET_HALT;
1074 else if (strcmp(args[2], "reset_run") == 0)
1075 (*last_target_p)->reset_mode = RESET_RUN;
1076 else if (strcmp(args[2], "reset_init") == 0)
1077 (*last_target_p)->reset_mode = RESET_INIT;
1078 else if (strcmp(args[2], "run_and_halt") == 0)
1079 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1080 else if (strcmp(args[2], "run_and_init") == 0)
1081 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1082 else
1083 {
1084 ERROR("unknown target startup mode %s", args[2]);
1085 exit(-1);
1086 }
1087 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1088
1089 (*last_target_p)->reset_script = NULL;
1090 (*last_target_p)->post_halt_script = NULL;
1091 (*last_target_p)->pre_resume_script = NULL;
1092 (*last_target_p)->gdb_program_script = NULL;
1093
1094 (*last_target_p)->working_area = 0x0;
1095 (*last_target_p)->working_area_size = 0x0;
1096 (*last_target_p)->working_areas = NULL;
1097 (*last_target_p)->backup_working_area = 0;
1098
1099 (*last_target_p)->state = TARGET_UNKNOWN;
1100 (*last_target_p)->reg_cache = NULL;
1101 (*last_target_p)->breakpoints = NULL;
1102 (*last_target_p)->watchpoints = NULL;
1103 (*last_target_p)->next = NULL;
1104 (*last_target_p)->arch_info = NULL;
1105
1106 /* initialize trace information */
1107 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1108 (*last_target_p)->trace_info->num_trace_points = 0;
1109 (*last_target_p)->trace_info->trace_points_size = 0;
1110 (*last_target_p)->trace_info->trace_points = NULL;
1111 (*last_target_p)->trace_info->trace_history_size = 0;
1112 (*last_target_p)->trace_info->trace_history = NULL;
1113 (*last_target_p)->trace_info->trace_history_pos = 0;
1114 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1115
1116 (*last_target_p)->dbgmsg = NULL;
1117 (*last_target_p)->dbg_msg_enabled = 0;
1118
1119 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1120
1121 found = 1;
1122 break;
1123 }
1124 }
1125 }
1126
1127 /* no matching target found */
1128 if (!found)
1129 {
1130 ERROR("target '%s' not found", args[0]);
1131 exit(-1);
1132 }
1133
1134 return ERROR_OK;
1135 }
1136
1137 /* usage: target_script <target#> <event> <script_file> */
1138 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1139 {
1140 target_t *target = NULL;
1141
1142 if (argc < 3)
1143 {
1144 ERROR("incomplete target_script command");
1145 exit(-1);
1146 }
1147
1148 target = get_target_by_num(strtoul(args[0], NULL, 0));
1149
1150 if (!target)
1151 {
1152 ERROR("target number '%s' not defined", args[0]);
1153 exit(-1);
1154 }
1155
1156 if (strcmp(args[1], "reset") == 0)
1157 {
1158 if (target->reset_script)
1159 free(target->reset_script);
1160 target->reset_script = strdup(args[2]);
1161 }
1162 else if (strcmp(args[1], "post_halt") == 0)
1163 {
1164 if (target->post_halt_script)
1165 free(target->post_halt_script);
1166 target->post_halt_script = strdup(args[2]);
1167 }
1168 else if (strcmp(args[1], "pre_resume") == 0)
1169 {
1170 if (target->pre_resume_script)
1171 free(target->pre_resume_script);
1172 target->pre_resume_script = strdup(args[2]);
1173 }
1174 else if (strcmp(args[1], "gdb_program_config") == 0)
1175 {
1176 if (target->gdb_program_script)
1177 free(target->gdb_program_script);
1178 target->gdb_program_script = strdup(args[2]);
1179 }
1180 else
1181 {
1182 ERROR("unknown event type: '%s", args[1]);
1183 exit(-1);
1184 }
1185
1186 return ERROR_OK;
1187 }
1188
1189 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1190 {
1191 target_t *target = NULL;
1192
1193 if (argc < 2)
1194 {
1195 ERROR("incomplete run_and_halt_time command");
1196 exit(-1);
1197 }
1198
1199 target = get_target_by_num(strtoul(args[0], NULL, 0));
1200
1201 if (!target)
1202 {
1203 ERROR("target number '%s' not defined", args[0]);
1204 exit(-1);
1205 }
1206
1207 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1208
1209 return ERROR_OK;
1210 }
1211
1212 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1213 {
1214 target_t *target = NULL;
1215
1216 if (argc < 4)
1217 {
1218 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1219 exit(-1);
1220 }
1221
1222 target = get_target_by_num(strtoul(args[0], NULL, 0));
1223
1224 if (!target)
1225 {
1226 ERROR("target number '%s' not defined", args[0]);
1227 exit(-1);
1228 }
1229
1230 target->working_area = strtoul(args[1], NULL, 0);
1231 target->working_area_size = strtoul(args[2], NULL, 0);
1232
1233 if (strcmp(args[3], "backup") == 0)
1234 {
1235 target->backup_working_area = 1;
1236 }
1237 else if (strcmp(args[3], "nobackup") == 0)
1238 {
1239 target->backup_working_area = 0;
1240 }
1241 else
1242 {
1243 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1244 exit(-1);
1245 }
1246
1247 return ERROR_OK;
1248 }
1249
1250
1251 /* process target state changes */
1252 int handle_target(void *priv)
1253 {
1254 int retval;
1255 target_t *target = targets;
1256
1257 while (target)
1258 {
1259 /* only poll if target isn't already halted */
1260 if (target->state != TARGET_HALTED)
1261 {
1262 if (target_continous_poll)
1263 if ((retval = target->type->poll(target)) < 0)
1264 {
1265 ERROR("couldn't poll target. It's due for a reset.");
1266 }
1267 }
1268
1269 target = target->next;
1270 }
1271
1272 return ERROR_OK;
1273 }
1274
1275 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1276 {
1277 target_t *target;
1278 reg_t *reg = NULL;
1279 int count = 0;
1280 char *value;
1281
1282 DEBUG("-");
1283
1284 target = get_current_target(cmd_ctx);
1285
1286 /* list all available registers for the current target */
1287 if (argc == 0)
1288 {
1289 reg_cache_t *cache = target->reg_cache;
1290
1291 count = 0;
1292 while(cache)
1293 {
1294 int i;
1295 for (i = 0; i < cache->num_regs; i++)
1296 {
1297 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1298 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);
1299 free(value);
1300 }
1301 cache = cache->next;
1302 }
1303
1304 return ERROR_OK;
1305 }
1306
1307 /* access a single register by its ordinal number */
1308 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1309 {
1310 int num = strtoul(args[0], NULL, 0);
1311 reg_cache_t *cache = target->reg_cache;
1312
1313 count = 0;
1314 while(cache)
1315 {
1316 int i;
1317 for (i = 0; i < cache->num_regs; i++)
1318 {
1319 if (count++ == num)
1320 {
1321 reg = &cache->reg_list[i];
1322 break;
1323 }
1324 }
1325 if (reg)
1326 break;
1327 cache = cache->next;
1328 }
1329
1330 if (!reg)
1331 {
1332 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1333 return ERROR_OK;
1334 }
1335 } else /* access a single register by its name */
1336 {
1337 reg = register_get_by_name(target->reg_cache, args[0], 1);
1338
1339 if (!reg)
1340 {
1341 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1342 return ERROR_OK;
1343 }
1344 }
1345
1346 /* display a register */
1347 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1348 {
1349 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1350 reg->valid = 0;
1351
1352 if (reg->valid == 0)
1353 {
1354 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1355 if (arch_type == NULL)
1356 {
1357 ERROR("BUG: encountered unregistered arch type");
1358 return ERROR_OK;
1359 }
1360 arch_type->get(reg);
1361 }
1362 value = buf_to_str(reg->value, reg->size, 16);
1363 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1364 free(value);
1365 return ERROR_OK;
1366 }
1367
1368 /* set register value */
1369 if (argc == 2)
1370 {
1371 u8 *buf = malloc(CEIL(reg->size, 8));
1372 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1373
1374 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1375 if (arch_type == NULL)
1376 {
1377 ERROR("BUG: encountered unregistered arch type");
1378 return ERROR_OK;
1379 }
1380
1381 arch_type->set(reg, buf);
1382
1383 value = buf_to_str(reg->value, reg->size, 16);
1384 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1385 free(value);
1386
1387 free(buf);
1388
1389 return ERROR_OK;
1390 }
1391
1392 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1393
1394 return ERROR_OK;
1395 }
1396
1397 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1398
1399 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1400 {
1401 target_t *target = get_current_target(cmd_ctx);
1402 char buffer[512];
1403
1404 if (argc == 0)
1405 {
1406 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1407 if (target->state == TARGET_HALTED)
1408 {
1409 target->type->arch_state(target, buffer, 512);
1410 buffer[511] = 0;
1411 command_print(cmd_ctx, "%s", buffer);
1412 }
1413 }
1414 else
1415 {
1416 if (strcmp(args[0], "on") == 0)
1417 {
1418 target_continous_poll = 1;
1419 }
1420 else if (strcmp(args[0], "off") == 0)
1421 {
1422 target_continous_poll = 0;
1423 }
1424 else
1425 {
1426 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1427 }
1428 }
1429
1430
1431 return ERROR_OK;
1432 }
1433
1434 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1435 {
1436 int ms = 5000;
1437
1438 if (argc > 0)
1439 {
1440 char *end;
1441
1442 ms = strtoul(args[0], &end, 0) * 1000;
1443 if (*end)
1444 {
1445 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1446 return ERROR_OK;
1447 }
1448 }
1449
1450 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1451 }
1452
1453 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1454 {
1455 struct timeval timeout, now;
1456
1457 gettimeofday(&timeout, NULL);
1458 timeval_add_time(&timeout, 0, ms * 1000);
1459 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1460
1461 target_t *target = get_current_target(cmd_ctx);
1462 while (target->type->poll(target))
1463 {
1464 target_call_timer_callbacks();
1465 if (target->state == state)
1466 {
1467 command_print(cmd_ctx, "target %s", target_state_strings[state]);
1468 break;
1469 }
1470
1471 gettimeofday(&now, NULL);
1472 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1473 {
1474 command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
1475 ERROR("timed out while waiting for target %s", target_state_strings[state]);
1476 break;
1477 }
1478 }
1479
1480 return ERROR_OK;
1481 }
1482
1483 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1484 {
1485 int retval;
1486 target_t *target = get_current_target(cmd_ctx);
1487
1488 DEBUG("-");
1489
1490 command_print(cmd_ctx, "requesting target halt...");
1491
1492 if ((retval = target->type->halt(target)) != ERROR_OK)
1493 {
1494 switch (retval)
1495 {
1496 case ERROR_TARGET_ALREADY_HALTED:
1497 command_print(cmd_ctx, "target already halted");
1498 break;
1499 case ERROR_TARGET_TIMEOUT:
1500 command_print(cmd_ctx, "target timed out... shutting down");
1501 return retval;
1502 default:
1503 command_print(cmd_ctx, "unknown error... shutting down");
1504 return retval;
1505 }
1506 }
1507
1508 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1509 }
1510
1511 /* what to do on daemon startup */
1512 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1513 {
1514 if (argc == 1)
1515 {
1516 if (strcmp(args[0], "attach") == 0)
1517 {
1518 startup_mode = DAEMON_ATTACH;
1519 return ERROR_OK;
1520 }
1521 else if (strcmp(args[0], "reset") == 0)
1522 {
1523 startup_mode = DAEMON_RESET;
1524 return ERROR_OK;
1525 }
1526 }
1527
1528 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1529 return ERROR_OK;
1530
1531 }
1532
1533 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1534 {
1535 target_t *target = get_current_target(cmd_ctx);
1536 int retval;
1537
1538 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1539
1540 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1541 {
1542 switch (retval)
1543 {
1544 case ERROR_TARGET_TIMEOUT:
1545 command_print(cmd_ctx, "target timed out... shutting down");
1546 exit(-1);
1547 default:
1548 command_print(cmd_ctx, "unknown error... shutting down");
1549 exit(-1);
1550 }
1551 }
1552
1553 return ERROR_OK;
1554 }
1555
1556 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1557 {
1558 target_t *target = get_current_target(cmd_ctx);
1559 enum target_reset_mode reset_mode = target->reset_mode;
1560 enum target_reset_mode save = target->reset_mode;
1561
1562 DEBUG("-");
1563
1564 if (argc >= 1)
1565 {
1566 if (strcmp("run", args[0]) == 0)
1567 reset_mode = RESET_RUN;
1568 else if (strcmp("halt", args[0]) == 0)
1569 reset_mode = RESET_HALT;
1570 else if (strcmp("init", args[0]) == 0)
1571 reset_mode = RESET_INIT;
1572 else if (strcmp("run_and_halt", args[0]) == 0)
1573 {
1574 reset_mode = RESET_RUN_AND_HALT;
1575 if (argc >= 2)
1576 {
1577 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1578 }
1579 }
1580 else if (strcmp("run_and_init", args[0]) == 0)
1581 {
1582 reset_mode = RESET_RUN_AND_INIT;
1583 if (argc >= 2)
1584 {
1585 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1586 }
1587 }
1588 else
1589 {
1590 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1591 return ERROR_OK;
1592 }
1593 }
1594
1595 /* temporarily modify mode of current reset target */
1596 target->reset_mode = reset_mode;
1597
1598 /* reset *all* targets */
1599 target_process_reset(cmd_ctx);
1600
1601 /* Restore default reset mode for this target */
1602 target->reset_mode = save;
1603
1604 return ERROR_OK;
1605 }
1606
1607 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1608 {
1609 int retval;
1610 target_t *target = get_current_target(cmd_ctx);
1611
1612 DEBUG("-");
1613
1614 if (argc == 0)
1615 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1616 else if (argc == 1)
1617 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1618 else
1619 {
1620 command_print(cmd_ctx, "usage: resume [address]");
1621 return ERROR_OK;
1622 }
1623
1624 if (retval != ERROR_OK)
1625 {
1626 switch (retval)
1627 {
1628 case ERROR_TARGET_NOT_HALTED:
1629 command_print(cmd_ctx, "target not halted");
1630 break;
1631 default:
1632 command_print(cmd_ctx, "unknown error... shutting down");
1633 exit(-1);
1634 }
1635 }
1636
1637 return wait_state(cmd_ctx, cmd, TARGET_RUNNING, 5000);
1638 }
1639
1640 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1641 {
1642 target_t *target = get_current_target(cmd_ctx);
1643
1644 DEBUG("-");
1645
1646 if (argc == 0)
1647 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1648
1649 if (argc == 1)
1650 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1651
1652 return ERROR_OK;
1653 }
1654
1655 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1656 {
1657 const int line_bytecnt = 32;
1658 int count = 1;
1659 int size = 4;
1660 u32 address = 0;
1661 int line_modulo;
1662 int i;
1663
1664 char output[128];
1665 int output_len;
1666
1667 int retval;
1668
1669 u8 *buffer;
1670 target_t *target = get_current_target(cmd_ctx);
1671
1672 if (argc < 1)
1673 return ERROR_OK;
1674
1675 if (argc == 2)
1676 count = strtoul(args[1], NULL, 0);
1677
1678 address = strtoul(args[0], NULL, 0);
1679
1680
1681 switch (cmd[2])
1682 {
1683 case 'w':
1684 size = 4; line_modulo = line_bytecnt / 4;
1685 break;
1686 case 'h':
1687 size = 2; line_modulo = line_bytecnt / 2;
1688 break;
1689 case 'b':
1690 size = 1; line_modulo = line_bytecnt / 1;
1691 break;
1692 default:
1693 return ERROR_OK;
1694 }
1695
1696 buffer = calloc(count, size);
1697 retval = target->type->read_memory(target, address, size, count, buffer);
1698 if (retval != ERROR_OK)
1699 {
1700 switch (retval)
1701 {
1702 case ERROR_TARGET_UNALIGNED_ACCESS:
1703 command_print(cmd_ctx, "error: address not aligned");
1704 break;
1705 case ERROR_TARGET_NOT_HALTED:
1706 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1707 break;
1708 case ERROR_TARGET_DATA_ABORT:
1709 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1710 break;
1711 default:
1712 command_print(cmd_ctx, "error: unknown error");
1713 break;
1714 }
1715 return ERROR_OK;
1716 }
1717
1718 output_len = 0;
1719
1720 for (i = 0; i < count; i++)
1721 {
1722 if (i%line_modulo == 0)
1723 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1724
1725 switch (size)
1726 {
1727 case 4:
1728 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1729 break;
1730 case 2:
1731 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1732 break;
1733 case 1:
1734 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1735 break;
1736 }
1737
1738 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1739 {
1740 command_print(cmd_ctx, output);
1741 output_len = 0;
1742 }
1743 }
1744
1745 free(buffer);
1746
1747 return ERROR_OK;
1748 }
1749
1750 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1751 {
1752 u32 address = 0;
1753 u32 value = 0;
1754 int retval;
1755 target_t *target = get_current_target(cmd_ctx);
1756 u8 value_buf[4];
1757
1758 if (argc < 2)
1759 return ERROR_OK;
1760
1761 address = strtoul(args[0], NULL, 0);
1762 value = strtoul(args[1], NULL, 0);
1763
1764 switch (cmd[2])
1765 {
1766 case 'w':
1767 target_buffer_set_u32(target, value_buf, value);
1768 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1769 break;
1770 case 'h':
1771 target_buffer_set_u16(target, value_buf, value);
1772 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1773 break;
1774 case 'b':
1775 value_buf[0] = value;
1776 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1777 break;
1778 default:
1779 return ERROR_OK;
1780 }
1781
1782 switch (retval)
1783 {
1784 case ERROR_TARGET_UNALIGNED_ACCESS:
1785 command_print(cmd_ctx, "error: address not aligned");
1786 break;
1787 case ERROR_TARGET_DATA_ABORT:
1788 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1789 break;
1790 case ERROR_TARGET_NOT_HALTED:
1791 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1792 break;
1793 case ERROR_OK:
1794 break;
1795 default:
1796 command_print(cmd_ctx, "error: unknown error");
1797 break;
1798 }
1799
1800 return ERROR_OK;
1801
1802 }
1803
1804 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1805 {
1806 u8 *buffer;
1807 u32 buf_cnt;
1808 u32 image_size;
1809 int i;
1810 int retval;
1811
1812 image_t image;
1813
1814 duration_t duration;
1815 char *duration_text;
1816
1817 target_t *target = get_current_target(cmd_ctx);
1818
1819 if (argc < 1)
1820 {
1821 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1822 return ERROR_OK;
1823 }
1824
1825 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1826 if (argc >= 2)
1827 {
1828 image.base_address_set = 1;
1829 image.base_address = strtoul(args[1], NULL, 0);
1830 }
1831 else
1832 {
1833 image.base_address_set = 0;
1834 }
1835
1836 image.start_address_set = 0;
1837
1838 duration_start_measure(&duration);
1839
1840 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1841 {
1842 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1843 return ERROR_OK;
1844 }
1845
1846 image_size = 0x0;
1847 for (i = 0; i < image.num_sections; i++)
1848 {
1849 buffer = malloc(image.sections[i].size);
1850 if (buffer == NULL)
1851 {
1852 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1853 break;
1854 }
1855
1856 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1857 {
1858 ERROR("image_read_section failed with error code: %i", retval);
1859 command_print(cmd_ctx, "image reading failed, download aborted");
1860 free(buffer);
1861 image_close(&image);
1862 return ERROR_OK;
1863 }
1864 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1865 image_size += buf_cnt;
1866 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1867
1868 free(buffer);
1869 }
1870
1871 duration_stop_measure(&duration, &duration_text);
1872 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1873 free(duration_text);
1874
1875 image_close(&image);
1876
1877 return ERROR_OK;
1878
1879 }
1880
1881 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1882 {
1883 fileio_t fileio;
1884
1885 u32 address;
1886 u32 size;
1887 u8 buffer[560];
1888 int retval;
1889
1890 duration_t duration;
1891 char *duration_text;
1892
1893 target_t *target = get_current_target(cmd_ctx);
1894
1895 if (argc != 3)
1896 {
1897 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1898 return ERROR_OK;
1899 }
1900
1901 address = strtoul(args[1], NULL, 0);
1902 size = strtoul(args[2], NULL, 0);
1903
1904 if ((address & 3) || (size & 3))
1905 {
1906 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1907 return ERROR_OK;
1908 }
1909
1910 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1911 {
1912 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1913 return ERROR_OK;
1914 }
1915
1916 duration_start_measure(&duration);
1917
1918 while (size > 0)
1919 {
1920 u32 size_written;
1921 u32 this_run_size = (size > 560) ? 560 : size;
1922
1923 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1924 if (retval != ERROR_OK)
1925 {
1926 command_print(cmd_ctx, "Reading memory failed %d", retval);
1927 break;
1928 }
1929
1930 fileio_write(&fileio, this_run_size, buffer, &size_written);
1931
1932 size -= this_run_size;
1933 address += this_run_size;
1934 }
1935
1936 fileio_close(&fileio);
1937
1938 duration_stop_measure(&duration, &duration_text);
1939 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1940 free(duration_text);
1941
1942 return ERROR_OK;
1943 }
1944
1945 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1946 {
1947 u8 *buffer;
1948 u32 buf_cnt;
1949 u32 image_size;
1950 int i;
1951 int retval;
1952 u32 checksum = 0;
1953 u32 mem_checksum = 0;
1954
1955 image_t image;
1956
1957 duration_t duration;
1958 char *duration_text;
1959
1960 target_t *target = get_current_target(cmd_ctx);
1961
1962 if (argc < 1)
1963 {
1964 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
1965 return ERROR_OK;
1966 }
1967
1968 if (!target)
1969 {
1970 ERROR("no target selected");
1971 return ERROR_OK;
1972 }
1973
1974 duration_start_measure(&duration);
1975
1976 if (argc >= 2)
1977 {
1978 image.base_address_set = 1;
1979 image.base_address = strtoul(args[1], NULL, 0);
1980 }
1981 else
1982 {
1983 image.base_address_set = 0;
1984 image.base_address = 0x0;
1985 }
1986
1987 image.start_address_set = 0;
1988
1989 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
1990 {
1991 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
1992 return ERROR_OK;
1993 }
1994
1995 image_size = 0x0;
1996 for (i = 0; i < image.num_sections; i++)
1997 {
1998 buffer = malloc(image.sections[i].size);
1999 if (buffer == NULL)
2000 {
2001 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2002 break;
2003 }
2004 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2005 {
2006 ERROR("image_read_section failed with error code: %i", retval);
2007 command_print(cmd_ctx, "image reading failed, verify aborted");
2008 free(buffer);
2009 image_close(&image);
2010 return ERROR_OK;
2011 }
2012
2013 /* calculate checksum of image */
2014 image_calculate_checksum( buffer, buf_cnt, &checksum );
2015
2016 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2017
2018 if( retval != ERROR_OK )
2019 {
2020 command_print(cmd_ctx, "image verify failed, verify aborted");
2021 free(buffer);
2022 image_close(&image);
2023 return ERROR_OK;
2024 }
2025
2026 if( checksum != mem_checksum )
2027 {
2028 /* failed crc checksum, fall back to a binary compare */
2029 u8 *data;
2030
2031 command_print(cmd_ctx, "image verify checksum failed - attempting binary compare");
2032
2033 data = (u8*)malloc(buf_cnt);
2034
2035 /* Can we use 32bit word accesses? */
2036 int size = 1;
2037 int count = buf_cnt;
2038 if ((count % 4) == 0)
2039 {
2040 size *= 4;
2041 count /= 4;
2042 }
2043 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2044
2045 if (retval == ERROR_OK)
2046 {
2047 int t;
2048 for (t = 0; t < buf_cnt; t++)
2049 {
2050 if (data[t] != buffer[t])
2051 {
2052 command_print(cmd_ctx, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t + image.sections[i].base_address, data[t], buffer[t]);
2053 free(data);
2054 free(buffer);
2055 image_close(&image);
2056 return ERROR_OK;
2057 }
2058 }
2059 }
2060
2061 free(data);
2062 }
2063
2064 free(buffer);
2065 image_size += buf_cnt;
2066 }
2067
2068 duration_stop_measure(&duration, &duration_text);
2069 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2070 free(duration_text);
2071
2072 image_close(&image);
2073
2074 return ERROR_OK;
2075 }
2076
2077 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2078 {
2079 int retval;
2080 target_t *target = get_current_target(cmd_ctx);
2081
2082 if (argc == 0)
2083 {
2084 breakpoint_t *breakpoint = target->breakpoints;
2085
2086 while (breakpoint)
2087 {
2088 if (breakpoint->type == BKPT_SOFT)
2089 {
2090 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2091 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2092 free(buf);
2093 }
2094 else
2095 {
2096 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2097 }
2098 breakpoint = breakpoint->next;
2099 }
2100 }
2101 else if (argc >= 2)
2102 {
2103 int hw = BKPT_SOFT;
2104 u32 length = 0;
2105
2106 length = strtoul(args[1], NULL, 0);
2107
2108 if (argc >= 3)
2109 if (strcmp(args[2], "hw") == 0)
2110 hw = BKPT_HARD;
2111
2112 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2113 {
2114 switch (retval)
2115 {
2116 case ERROR_TARGET_NOT_HALTED:
2117 command_print(cmd_ctx, "target must be halted to set breakpoints");
2118 break;
2119 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2120 command_print(cmd_ctx, "no more breakpoints available");
2121 break;
2122 default:
2123 command_print(cmd_ctx, "unknown error, breakpoint not set");
2124 break;
2125 }
2126 }
2127 else
2128 {
2129 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2130 }
2131 }
2132 else
2133 {
2134 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2135 }
2136
2137 return ERROR_OK;
2138 }
2139
2140 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2141 {
2142 target_t *target = get_current_target(cmd_ctx);
2143
2144 if (argc > 0)
2145 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2146
2147 return ERROR_OK;
2148 }
2149
2150 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2151 {
2152 target_t *target = get_current_target(cmd_ctx);
2153 int retval;
2154
2155 if (argc == 0)
2156 {
2157 watchpoint_t *watchpoint = target->watchpoints;
2158
2159 while (watchpoint)
2160 {
2161 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);
2162 watchpoint = watchpoint->next;
2163 }
2164 }
2165 else if (argc >= 2)
2166 {
2167 enum watchpoint_rw type = WPT_ACCESS;
2168 u32 data_value = 0x0;
2169 u32 data_mask = 0xffffffff;
2170
2171 if (argc >= 3)
2172 {
2173 switch(args[2][0])
2174 {
2175 case 'r':
2176 type = WPT_READ;
2177 break;
2178 case 'w':
2179 type = WPT_WRITE;
2180 break;
2181 case 'a':
2182 type = WPT_ACCESS;
2183 break;
2184 default:
2185 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2186 return ERROR_OK;
2187 }
2188 }
2189 if (argc >= 4)
2190 {
2191 data_value = strtoul(args[3], NULL, 0);
2192 }
2193 if (argc >= 5)
2194 {
2195 data_mask = strtoul(args[4], NULL, 0);
2196 }
2197
2198 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2199 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2200 {
2201 switch (retval)
2202 {
2203 case ERROR_TARGET_NOT_HALTED:
2204 command_print(cmd_ctx, "target must be halted to set watchpoints");
2205 break;
2206 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2207 command_print(cmd_ctx, "no more watchpoints available");
2208 break;
2209 default:
2210 command_print(cmd_ctx, "unknown error, watchpoint not set");
2211 break;
2212 }
2213 }
2214 }
2215 else
2216 {
2217 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2218 }
2219
2220 return ERROR_OK;
2221 }
2222
2223 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2224 {
2225 target_t *target = get_current_target(cmd_ctx);
2226
2227 if (argc > 0)
2228 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2229
2230 return ERROR_OK;
2231 }
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)