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