Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- Added a "User:" debug level. These are messages that are intended for the user...
[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_ANY, NULL);
704
705 return ERROR_OK;
706 }
707
708 /* Single aligned words are guaranteed to use 16 or 32 bit access
709 * mode respectively, otherwise data is handled as quickly as
710 * possible
711 */
712 int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
713 {
714 int retval;
715
716 DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
717
718 if (((address % 2) == 0) && (size == 2))
719 {
720 return target->type->write_memory(target, address, 2, 1, buffer);
721 }
722
723 /* handle unaligned head bytes */
724 if (address % 4)
725 {
726 int unaligned = 4 - (address % 4);
727
728 if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
729 return retval;
730
731 buffer += unaligned;
732 address += unaligned;
733 size -= unaligned;
734 }
735
736 /* handle aligned words */
737 if (size >= 4)
738 {
739 int aligned = size - (size % 4);
740
741 /* use bulk writes above a certain limit. This may have to be changed */
742 if (aligned > 128)
743 {
744 if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
745 return retval;
746 }
747 else
748 {
749 if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
750 return retval;
751 }
752
753 buffer += aligned;
754 address += aligned;
755 size -= aligned;
756 }
757
758 /* handle tail writes of less than 4 bytes */
759 if (size > 0)
760 {
761 if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
762 return retval;
763 }
764
765 return ERROR_OK;
766 }
767
768
769 /* Single aligned words are guaranteed to use 16 or 32 bit access
770 * mode respectively, otherwise data is handled as quickly as
771 * possible
772 */
773 int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
774 {
775 int retval;
776
777 DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
778
779 if (((address % 2) == 0) && (size == 2))
780 {
781 return target->type->read_memory(target, address, 2, 1, buffer);
782 }
783
784 /* handle unaligned head bytes */
785 if (address % 4)
786 {
787 int unaligned = 4 - (address % 4);
788
789 if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
790 return retval;
791
792 buffer += unaligned;
793 address += unaligned;
794 size -= unaligned;
795 }
796
797 /* handle aligned words */
798 if (size >= 4)
799 {
800 int aligned = size - (size % 4);
801
802 if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
803 return retval;
804
805 buffer += aligned;
806 address += aligned;
807 size -= aligned;
808 }
809
810 /* handle tail writes of less than 4 bytes */
811 if (size > 0)
812 {
813 if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
814 return retval;
815 }
816
817 return ERROR_OK;
818 }
819
820 int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
821 {
822 u8 *buffer;
823 int retval;
824 int i;
825 u32 checksum = 0;
826
827 if ((retval = target->type->checksum_memory(target, address,
828 size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
829 {
830 buffer = malloc(size);
831 if (buffer == NULL)
832 {
833 ERROR("error allocating buffer for section (%d bytes)", size);
834 return ERROR_INVALID_ARGUMENTS;
835 }
836 retval = target_read_buffer(target, address, size, buffer);
837 if (retval != ERROR_OK)
838 {
839 free(buffer);
840 return retval;
841 }
842
843 /* convert to target endianess */
844 for (i = 0; i < (size/sizeof(u32)); i++)
845 {
846 u32 target_data;
847 target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
848 target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
849 }
850
851 retval = image_calculate_checksum( buffer, size, &checksum );
852 free(buffer);
853 }
854
855 *crc = checksum;
856
857 return retval;
858 }
859
860 int target_read_u32(struct target_s *target, u32 address, u32 *value)
861 {
862 u8 value_buf[4];
863
864 int retval = target->type->read_memory(target, address, 4, 1, value_buf);
865
866 if (retval == ERROR_OK)
867 {
868 *value = target_buffer_get_u32(target, value_buf);
869 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value);
870 }
871 else
872 {
873 *value = 0x0;
874 DEBUG("address: 0x%8.8x failed", address);
875 }
876
877 return retval;
878 }
879
880 int target_read_u16(struct target_s *target, u32 address, u16 *value)
881 {
882 u8 value_buf[2];
883
884 int retval = target->type->read_memory(target, address, 2, 1, value_buf);
885
886 if (retval == ERROR_OK)
887 {
888 *value = target_buffer_get_u16(target, value_buf);
889 DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value);
890 }
891 else
892 {
893 *value = 0x0;
894 DEBUG("address: 0x%8.8x failed", address);
895 }
896
897 return retval;
898 }
899
900 int target_read_u8(struct target_s *target, u32 address, u8 *value)
901 {
902 int retval = target->type->read_memory(target, address, 1, 1, value);
903
904 if (retval == ERROR_OK)
905 {
906 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value);
907 }
908 else
909 {
910 *value = 0x0;
911 DEBUG("address: 0x%8.8x failed", address);
912 }
913
914 return retval;
915 }
916
917 int target_write_u32(struct target_s *target, u32 address, u32 value)
918 {
919 int retval;
920 u8 value_buf[4];
921
922 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
923
924 target_buffer_set_u32(target, value_buf, value);
925 if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
926 {
927 DEBUG("failed: %i", retval);
928 }
929
930 return retval;
931 }
932
933 int target_write_u16(struct target_s *target, u32 address, u16 value)
934 {
935 int retval;
936 u8 value_buf[2];
937
938 DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
939
940 target_buffer_set_u16(target, value_buf, value);
941 if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
942 {
943 DEBUG("failed: %i", retval);
944 }
945
946 return retval;
947 }
948
949 int target_write_u8(struct target_s *target, u32 address, u8 value)
950 {
951 int retval;
952
953 DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
954
955 if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK)
956 {
957 DEBUG("failed: %i", retval);
958 }
959
960 return retval;
961 }
962
963 int target_register_user_commands(struct command_context_s *cmd_ctx)
964 {
965 register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
966 register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
967 register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
968 register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
969 register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
970 register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
971 register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
972 register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
973
974 register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
975 register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
976 register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
977
978 register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value>");
979 register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value>");
980 register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value>");
981
982 register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
983 register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
984 register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
985 register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
986
987 register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19']");
988 register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
989 register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
990 register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary <file> <address>");
991 register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary <file> <address> <size>");
992
993 target_request_register_commands(cmd_ctx);
994 trace_register_commands(cmd_ctx);
995
996 return ERROR_OK;
997 }
998
999 int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1000 {
1001 target_t *target = targets;
1002 int count = 0;
1003
1004 if (argc == 1)
1005 {
1006 int num = strtoul(args[0], NULL, 0);
1007
1008 while (target)
1009 {
1010 count++;
1011 target = target->next;
1012 }
1013
1014 if (num < count)
1015 cmd_ctx->current_target = num;
1016 else
1017 command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
1018
1019 return ERROR_OK;
1020 }
1021
1022 while (target)
1023 {
1024 command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
1025 target = target->next;
1026 }
1027
1028 return ERROR_OK;
1029 }
1030
1031 int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1032 {
1033 int i;
1034 int found = 0;
1035
1036 if (argc < 3)
1037 {
1038 ERROR("target command requires at least three arguments: <type> <endianess> <reset_mode>");
1039 exit(-1);
1040 }
1041
1042 /* search for the specified target */
1043 if (args[0] && (args[0][0] != 0))
1044 {
1045 for (i = 0; target_types[i]; i++)
1046 {
1047 if (strcmp(args[0], target_types[i]->name) == 0)
1048 {
1049 target_t **last_target_p = &targets;
1050
1051 /* register target specific commands */
1052 if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
1053 {
1054 ERROR("couldn't register '%s' commands", args[0]);
1055 exit(-1);
1056 }
1057
1058 if (*last_target_p)
1059 {
1060 while ((*last_target_p)->next)
1061 last_target_p = &((*last_target_p)->next);
1062 last_target_p = &((*last_target_p)->next);
1063 }
1064
1065 *last_target_p = malloc(sizeof(target_t));
1066
1067 (*last_target_p)->type = target_types[i];
1068
1069 if (strcmp(args[1], "big") == 0)
1070 (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
1071 else if (strcmp(args[1], "little") == 0)
1072 (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN;
1073 else
1074 {
1075 ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
1076 exit(-1);
1077 }
1078
1079 /* what to do on a target reset */
1080 if (strcmp(args[2], "reset_halt") == 0)
1081 (*last_target_p)->reset_mode = RESET_HALT;
1082 else if (strcmp(args[2], "reset_run") == 0)
1083 (*last_target_p)->reset_mode = RESET_RUN;
1084 else if (strcmp(args[2], "reset_init") == 0)
1085 (*last_target_p)->reset_mode = RESET_INIT;
1086 else if (strcmp(args[2], "run_and_halt") == 0)
1087 (*last_target_p)->reset_mode = RESET_RUN_AND_HALT;
1088 else if (strcmp(args[2], "run_and_init") == 0)
1089 (*last_target_p)->reset_mode = RESET_RUN_AND_INIT;
1090 else
1091 {
1092 ERROR("unknown target startup mode %s", args[2]);
1093 exit(-1);
1094 }
1095 (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
1096
1097 (*last_target_p)->reset_script = NULL;
1098 (*last_target_p)->post_halt_script = NULL;
1099 (*last_target_p)->pre_resume_script = NULL;
1100 (*last_target_p)->gdb_program_script = NULL;
1101
1102 (*last_target_p)->working_area = 0x0;
1103 (*last_target_p)->working_area_size = 0x0;
1104 (*last_target_p)->working_areas = NULL;
1105 (*last_target_p)->backup_working_area = 0;
1106
1107 (*last_target_p)->state = TARGET_UNKNOWN;
1108 (*last_target_p)->reg_cache = NULL;
1109 (*last_target_p)->breakpoints = NULL;
1110 (*last_target_p)->watchpoints = NULL;
1111 (*last_target_p)->next = NULL;
1112 (*last_target_p)->arch_info = NULL;
1113
1114 /* initialize trace information */
1115 (*last_target_p)->trace_info = malloc(sizeof(trace_t));
1116 (*last_target_p)->trace_info->num_trace_points = 0;
1117 (*last_target_p)->trace_info->trace_points_size = 0;
1118 (*last_target_p)->trace_info->trace_points = NULL;
1119 (*last_target_p)->trace_info->trace_history_size = 0;
1120 (*last_target_p)->trace_info->trace_history = NULL;
1121 (*last_target_p)->trace_info->trace_history_pos = 0;
1122 (*last_target_p)->trace_info->trace_history_overflowed = 0;
1123
1124 (*last_target_p)->dbgmsg = NULL;
1125 (*last_target_p)->dbg_msg_enabled = 0;
1126
1127 (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p);
1128
1129 found = 1;
1130 break;
1131 }
1132 }
1133 }
1134
1135 /* no matching target found */
1136 if (!found)
1137 {
1138 ERROR("target '%s' not found", args[0]);
1139 exit(-1);
1140 }
1141
1142 return ERROR_OK;
1143 }
1144
1145 /* usage: target_script <target#> <event> <script_file> */
1146 int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1147 {
1148 target_t *target = NULL;
1149
1150 if (argc < 3)
1151 {
1152 ERROR("incomplete target_script command");
1153 exit(-1);
1154 }
1155
1156 target = get_target_by_num(strtoul(args[0], NULL, 0));
1157
1158 if (!target)
1159 {
1160 ERROR("target number '%s' not defined", args[0]);
1161 exit(-1);
1162 }
1163
1164 if (strcmp(args[1], "reset") == 0)
1165 {
1166 if (target->reset_script)
1167 free(target->reset_script);
1168 target->reset_script = strdup(args[2]);
1169 }
1170 else if (strcmp(args[1], "post_halt") == 0)
1171 {
1172 if (target->post_halt_script)
1173 free(target->post_halt_script);
1174 target->post_halt_script = strdup(args[2]);
1175 }
1176 else if (strcmp(args[1], "pre_resume") == 0)
1177 {
1178 if (target->pre_resume_script)
1179 free(target->pre_resume_script);
1180 target->pre_resume_script = strdup(args[2]);
1181 }
1182 else if (strcmp(args[1], "gdb_program_config") == 0)
1183 {
1184 if (target->gdb_program_script)
1185 free(target->gdb_program_script);
1186 target->gdb_program_script = strdup(args[2]);
1187 }
1188 else
1189 {
1190 ERROR("unknown event type: '%s", args[1]);
1191 exit(-1);
1192 }
1193
1194 return ERROR_OK;
1195 }
1196
1197 int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1198 {
1199 target_t *target = NULL;
1200
1201 if (argc < 2)
1202 {
1203 ERROR("incomplete run_and_halt_time command");
1204 exit(-1);
1205 }
1206
1207 target = get_target_by_num(strtoul(args[0], NULL, 0));
1208
1209 if (!target)
1210 {
1211 ERROR("target number '%s' not defined", args[0]);
1212 exit(-1);
1213 }
1214
1215 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1216
1217 return ERROR_OK;
1218 }
1219
1220 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1221 {
1222 target_t *target = NULL;
1223
1224 if (argc < 4)
1225 {
1226 ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
1227 exit(-1);
1228 }
1229
1230 target = get_target_by_num(strtoul(args[0], NULL, 0));
1231
1232 if (!target)
1233 {
1234 ERROR("target number '%s' not defined", args[0]);
1235 exit(-1);
1236 }
1237 target_free_all_working_areas(target);
1238
1239 target->working_area = strtoul(args[1], NULL, 0);
1240 target->working_area_size = strtoul(args[2], NULL, 0);
1241
1242 if (strcmp(args[3], "backup") == 0)
1243 {
1244 target->backup_working_area = 1;
1245 }
1246 else if (strcmp(args[3], "nobackup") == 0)
1247 {
1248 target->backup_working_area = 0;
1249 }
1250 else
1251 {
1252 ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
1253 exit(-1);
1254 }
1255
1256 return ERROR_OK;
1257 }
1258
1259
1260 /* process target state changes */
1261 int handle_target(void *priv)
1262 {
1263 int retval;
1264 target_t *target = targets;
1265
1266 while (target)
1267 {
1268 /* only poll if target isn't already halted */
1269 if (target->state != TARGET_HALTED)
1270 {
1271 if (target_continous_poll)
1272 if ((retval = target->type->poll(target)) < 0)
1273 {
1274 ERROR("couldn't poll target. It's due for a reset.");
1275 }
1276 }
1277
1278 target = target->next;
1279 }
1280
1281 return ERROR_OK;
1282 }
1283
1284 int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1285 {
1286 target_t *target;
1287 reg_t *reg = NULL;
1288 int count = 0;
1289 char *value;
1290
1291 DEBUG("-");
1292
1293 target = get_current_target(cmd_ctx);
1294
1295 /* list all available registers for the current target */
1296 if (argc == 0)
1297 {
1298 reg_cache_t *cache = target->reg_cache;
1299
1300 count = 0;
1301 while(cache)
1302 {
1303 int i;
1304 for (i = 0; i < cache->num_regs; i++)
1305 {
1306 value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
1307 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);
1308 free(value);
1309 }
1310 cache = cache->next;
1311 }
1312
1313 return ERROR_OK;
1314 }
1315
1316 /* access a single register by its ordinal number */
1317 if ((args[0][0] >= '0') && (args[0][0] <= '9'))
1318 {
1319 int num = strtoul(args[0], NULL, 0);
1320 reg_cache_t *cache = target->reg_cache;
1321
1322 count = 0;
1323 while(cache)
1324 {
1325 int i;
1326 for (i = 0; i < cache->num_regs; i++)
1327 {
1328 if (count++ == num)
1329 {
1330 reg = &cache->reg_list[i];
1331 break;
1332 }
1333 }
1334 if (reg)
1335 break;
1336 cache = cache->next;
1337 }
1338
1339 if (!reg)
1340 {
1341 command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
1342 return ERROR_OK;
1343 }
1344 } else /* access a single register by its name */
1345 {
1346 reg = register_get_by_name(target->reg_cache, args[0], 1);
1347
1348 if (!reg)
1349 {
1350 command_print(cmd_ctx, "register %s not found in current target", args[0]);
1351 return ERROR_OK;
1352 }
1353 }
1354
1355 /* display a register */
1356 if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
1357 {
1358 if ((argc == 2) && (strcmp(args[1], "force") == 0))
1359 reg->valid = 0;
1360
1361 if (reg->valid == 0)
1362 {
1363 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1364 if (arch_type == NULL)
1365 {
1366 ERROR("BUG: encountered unregistered arch type");
1367 return ERROR_OK;
1368 }
1369 arch_type->get(reg);
1370 }
1371 value = buf_to_str(reg->value, reg->size, 16);
1372 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1373 free(value);
1374 return ERROR_OK;
1375 }
1376
1377 /* set register value */
1378 if (argc == 2)
1379 {
1380 u8 *buf = malloc(CEIL(reg->size, 8));
1381 str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
1382
1383 reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
1384 if (arch_type == NULL)
1385 {
1386 ERROR("BUG: encountered unregistered arch type");
1387 return ERROR_OK;
1388 }
1389
1390 arch_type->set(reg, buf);
1391
1392 value = buf_to_str(reg->value, reg->size, 16);
1393 command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
1394 free(value);
1395
1396 free(buf);
1397
1398 return ERROR_OK;
1399 }
1400
1401 command_print(cmd_ctx, "usage: reg <#|name> [value]");
1402
1403 return ERROR_OK;
1404 }
1405
1406 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms);
1407
1408 int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1409 {
1410 target_t *target = get_current_target(cmd_ctx);
1411 char buffer[512];
1412
1413 if (argc == 0)
1414 {
1415 command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
1416 if (target->state == TARGET_HALTED)
1417 {
1418 target->type->arch_state(target, buffer, 512);
1419 buffer[511] = 0;
1420 command_print(cmd_ctx, "%s", buffer);
1421 }
1422 }
1423 else
1424 {
1425 if (strcmp(args[0], "on") == 0)
1426 {
1427 target_continous_poll = 1;
1428 }
1429 else if (strcmp(args[0], "off") == 0)
1430 {
1431 target_continous_poll = 0;
1432 }
1433 else
1434 {
1435 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
1436 }
1437 }
1438
1439
1440 return ERROR_OK;
1441 }
1442
1443 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1444 {
1445 int ms = 5000;
1446
1447 if (argc > 0)
1448 {
1449 char *end;
1450
1451 ms = strtoul(args[0], &end, 0) * 1000;
1452 if (*end)
1453 {
1454 command_print(cmd_ctx, "usage: %s [seconds]", cmd);
1455 return ERROR_OK;
1456 }
1457 }
1458
1459 return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
1460 }
1461
1462 static void target_process_events(struct command_context_s *cmd_ctx)
1463 {
1464 target_t *target = get_current_target(cmd_ctx);
1465 target->type->poll(target);
1466 target_call_timer_callbacks();
1467 }
1468
1469 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
1470 {
1471 struct timeval timeout, now;
1472
1473 gettimeofday(&timeout, NULL);
1474 timeval_add_time(&timeout, 0, ms * 1000);
1475 command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
1476
1477 target_t *target = get_current_target(cmd_ctx);
1478 while (target->type->poll(target))
1479 {
1480 target_call_timer_callbacks();
1481 if (target->state == state)
1482 {
1483 command_print(cmd_ctx, "target %s", target_state_strings[state]);
1484 break;
1485 }
1486
1487 gettimeofday(&now, NULL);
1488 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
1489 {
1490 command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
1491 ERROR("timed out while waiting for target %s", target_state_strings[state]);
1492 break;
1493 }
1494 }
1495
1496 return ERROR_OK;
1497 }
1498
1499 int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1500 {
1501 int retval;
1502 target_t *target = get_current_target(cmd_ctx);
1503
1504 DEBUG("-");
1505
1506 command_print(cmd_ctx, "requesting target halt...");
1507
1508 if ((retval = target->type->halt(target)) != ERROR_OK)
1509 {
1510 switch (retval)
1511 {
1512 case ERROR_TARGET_ALREADY_HALTED:
1513 command_print(cmd_ctx, "target already halted");
1514 break;
1515 case ERROR_TARGET_TIMEOUT:
1516 command_print(cmd_ctx, "target timed out... shutting down");
1517 return retval;
1518 default:
1519 command_print(cmd_ctx, "unknown error... shutting down");
1520 return retval;
1521 }
1522 }
1523
1524 return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
1525 }
1526
1527 /* what to do on daemon startup */
1528 int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1529 {
1530 if (argc == 1)
1531 {
1532 if (strcmp(args[0], "attach") == 0)
1533 {
1534 startup_mode = DAEMON_ATTACH;
1535 return ERROR_OK;
1536 }
1537 else if (strcmp(args[0], "reset") == 0)
1538 {
1539 startup_mode = DAEMON_RESET;
1540 return ERROR_OK;
1541 }
1542 }
1543
1544 WARNING("invalid daemon_startup configuration directive: %s", args[0]);
1545 return ERROR_OK;
1546
1547 }
1548
1549 int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1550 {
1551 target_t *target = get_current_target(cmd_ctx);
1552 int retval;
1553
1554 command_print(cmd_ctx, "requesting target halt and executing a soft reset");
1555
1556 if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK)
1557 {
1558 switch (retval)
1559 {
1560 case ERROR_TARGET_TIMEOUT:
1561 command_print(cmd_ctx, "target timed out... shutting down");
1562 exit(-1);
1563 default:
1564 command_print(cmd_ctx, "unknown error... shutting down");
1565 exit(-1);
1566 }
1567 }
1568
1569 return ERROR_OK;
1570 }
1571
1572 int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1573 {
1574 target_t *target = get_current_target(cmd_ctx);
1575 enum target_reset_mode reset_mode = target->reset_mode;
1576 enum target_reset_mode save = target->reset_mode;
1577
1578 DEBUG("-");
1579
1580 if (argc >= 1)
1581 {
1582 if (strcmp("run", args[0]) == 0)
1583 reset_mode = RESET_RUN;
1584 else if (strcmp("halt", args[0]) == 0)
1585 reset_mode = RESET_HALT;
1586 else if (strcmp("init", args[0]) == 0)
1587 reset_mode = RESET_INIT;
1588 else if (strcmp("run_and_halt", args[0]) == 0)
1589 {
1590 reset_mode = RESET_RUN_AND_HALT;
1591 if (argc >= 2)
1592 {
1593 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1594 }
1595 }
1596 else if (strcmp("run_and_init", args[0]) == 0)
1597 {
1598 reset_mode = RESET_RUN_AND_INIT;
1599 if (argc >= 2)
1600 {
1601 target->run_and_halt_time = strtoul(args[1], NULL, 0);
1602 }
1603 }
1604 else
1605 {
1606 command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
1607 return ERROR_OK;
1608 }
1609 }
1610
1611 /* temporarily modify mode of current reset target */
1612 target->reset_mode = reset_mode;
1613
1614 /* reset *all* targets */
1615 target_process_reset(cmd_ctx);
1616
1617 /* Restore default reset mode for this target */
1618 target->reset_mode = save;
1619
1620 return ERROR_OK;
1621 }
1622
1623 int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1624 {
1625 int retval;
1626 target_t *target = get_current_target(cmd_ctx);
1627
1628 DEBUG("-");
1629
1630 if (argc == 0)
1631 retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
1632 else if (argc == 1)
1633 retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
1634 else
1635 {
1636 command_print(cmd_ctx, "usage: resume [address]");
1637 return ERROR_OK;
1638 }
1639
1640 if (retval != ERROR_OK)
1641 {
1642 switch (retval)
1643 {
1644 case ERROR_TARGET_NOT_HALTED:
1645 command_print(cmd_ctx, "target not halted");
1646 break;
1647 default:
1648 command_print(cmd_ctx, "unknown error... shutting down");
1649 exit(-1);
1650 }
1651 }
1652
1653 target_process_events(cmd_ctx);
1654
1655 return ERROR_OK;
1656 }
1657
1658 int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1659 {
1660 target_t *target = get_current_target(cmd_ctx);
1661
1662 DEBUG("-");
1663
1664 if (argc == 0)
1665 target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
1666
1667 if (argc == 1)
1668 target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
1669
1670 return ERROR_OK;
1671 }
1672
1673 int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1674 {
1675 const int line_bytecnt = 32;
1676 int count = 1;
1677 int size = 4;
1678 u32 address = 0;
1679 int line_modulo;
1680 int i;
1681
1682 char output[128];
1683 int output_len;
1684
1685 int retval;
1686
1687 u8 *buffer;
1688 target_t *target = get_current_target(cmd_ctx);
1689
1690 if (argc < 1)
1691 return ERROR_OK;
1692
1693 if (argc == 2)
1694 count = strtoul(args[1], NULL, 0);
1695
1696 address = strtoul(args[0], NULL, 0);
1697
1698
1699 switch (cmd[2])
1700 {
1701 case 'w':
1702 size = 4; line_modulo = line_bytecnt / 4;
1703 break;
1704 case 'h':
1705 size = 2; line_modulo = line_bytecnt / 2;
1706 break;
1707 case 'b':
1708 size = 1; line_modulo = line_bytecnt / 1;
1709 break;
1710 default:
1711 return ERROR_OK;
1712 }
1713
1714 buffer = calloc(count, size);
1715 retval = target->type->read_memory(target, address, size, count, buffer);
1716 if (retval != ERROR_OK)
1717 {
1718 switch (retval)
1719 {
1720 case ERROR_TARGET_UNALIGNED_ACCESS:
1721 command_print(cmd_ctx, "error: address not aligned");
1722 break;
1723 case ERROR_TARGET_NOT_HALTED:
1724 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1725 break;
1726 case ERROR_TARGET_DATA_ABORT:
1727 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1728 break;
1729 default:
1730 command_print(cmd_ctx, "error: unknown error");
1731 break;
1732 }
1733 return ERROR_OK;
1734 }
1735
1736 output_len = 0;
1737
1738 for (i = 0; i < count; i++)
1739 {
1740 if (i%line_modulo == 0)
1741 output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
1742
1743 switch (size)
1744 {
1745 case 4:
1746 output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
1747 break;
1748 case 2:
1749 output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
1750 break;
1751 case 1:
1752 output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
1753 break;
1754 }
1755
1756 if ((i%line_modulo == line_modulo-1) || (i == count - 1))
1757 {
1758 command_print(cmd_ctx, output);
1759 output_len = 0;
1760 }
1761 }
1762
1763 free(buffer);
1764
1765 return ERROR_OK;
1766 }
1767
1768 int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1769 {
1770 u32 address = 0;
1771 u32 value = 0;
1772 int retval;
1773 target_t *target = get_current_target(cmd_ctx);
1774 u8 value_buf[4];
1775
1776 if (argc < 2)
1777 return ERROR_OK;
1778
1779 address = strtoul(args[0], NULL, 0);
1780 value = strtoul(args[1], NULL, 0);
1781
1782 switch (cmd[2])
1783 {
1784 case 'w':
1785 target_buffer_set_u32(target, value_buf, value);
1786 retval = target->type->write_memory(target, address, 4, 1, value_buf);
1787 break;
1788 case 'h':
1789 target_buffer_set_u16(target, value_buf, value);
1790 retval = target->type->write_memory(target, address, 2, 1, value_buf);
1791 break;
1792 case 'b':
1793 value_buf[0] = value;
1794 retval = target->type->write_memory(target, address, 1, 1, value_buf);
1795 break;
1796 default:
1797 return ERROR_OK;
1798 }
1799
1800 switch (retval)
1801 {
1802 case ERROR_TARGET_UNALIGNED_ACCESS:
1803 command_print(cmd_ctx, "error: address not aligned");
1804 break;
1805 case ERROR_TARGET_DATA_ABORT:
1806 command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
1807 break;
1808 case ERROR_TARGET_NOT_HALTED:
1809 command_print(cmd_ctx, "error: target must be halted for memory accesses");
1810 break;
1811 case ERROR_OK:
1812 break;
1813 default:
1814 command_print(cmd_ctx, "error: unknown error");
1815 break;
1816 }
1817
1818 return ERROR_OK;
1819
1820 }
1821
1822 int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1823 {
1824 u8 *buffer;
1825 u32 buf_cnt;
1826 u32 image_size;
1827 int i;
1828 int retval;
1829
1830 image_t image;
1831
1832 duration_t duration;
1833 char *duration_text;
1834
1835 target_t *target = get_current_target(cmd_ctx);
1836
1837 if (argc < 1)
1838 {
1839 command_print(cmd_ctx, "usage: load_image <filename> [address] [type]");
1840 return ERROR_OK;
1841 }
1842
1843 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1844 if (argc >= 2)
1845 {
1846 image.base_address_set = 1;
1847 image.base_address = strtoul(args[1], NULL, 0);
1848 }
1849 else
1850 {
1851 image.base_address_set = 0;
1852 }
1853
1854 image.start_address_set = 0;
1855
1856 duration_start_measure(&duration);
1857
1858 if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1859 {
1860 command_print(cmd_ctx, "load_image error: %s", image.error_str);
1861 return ERROR_OK;
1862 }
1863
1864 image_size = 0x0;
1865 for (i = 0; i < image.num_sections; i++)
1866 {
1867 buffer = malloc(image.sections[i].size);
1868 if (buffer == NULL)
1869 {
1870 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
1871 break;
1872 }
1873
1874 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
1875 {
1876 ERROR("image_read_section failed with error code: %i", retval);
1877 command_print(cmd_ctx, "image reading failed, download aborted");
1878 free(buffer);
1879 image_close(&image);
1880 return ERROR_OK;
1881 }
1882 target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer);
1883 image_size += buf_cnt;
1884 command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address);
1885
1886 free(buffer);
1887 }
1888
1889 duration_stop_measure(&duration, &duration_text);
1890 command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
1891 free(duration_text);
1892
1893 image_close(&image);
1894
1895 return ERROR_OK;
1896
1897 }
1898
1899 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1900 {
1901 fileio_t fileio;
1902
1903 u32 address;
1904 u32 size;
1905 u8 buffer[560];
1906 int retval;
1907
1908 duration_t duration;
1909 char *duration_text;
1910
1911 target_t *target = get_current_target(cmd_ctx);
1912
1913 if (argc != 3)
1914 {
1915 command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
1916 return ERROR_OK;
1917 }
1918
1919 address = strtoul(args[1], NULL, 0);
1920 size = strtoul(args[2], NULL, 0);
1921
1922 if ((address & 3) || (size & 3))
1923 {
1924 command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
1925 return ERROR_OK;
1926 }
1927
1928 if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1929 {
1930 command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
1931 return ERROR_OK;
1932 }
1933
1934 duration_start_measure(&duration);
1935
1936 while (size > 0)
1937 {
1938 u32 size_written;
1939 u32 this_run_size = (size > 560) ? 560 : size;
1940
1941 retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
1942 if (retval != ERROR_OK)
1943 {
1944 command_print(cmd_ctx, "Reading memory failed %d", retval);
1945 break;
1946 }
1947
1948 fileio_write(&fileio, this_run_size, buffer, &size_written);
1949
1950 size -= this_run_size;
1951 address += this_run_size;
1952 }
1953
1954 fileio_close(&fileio);
1955
1956 duration_stop_measure(&duration, &duration_text);
1957 command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
1958 free(duration_text);
1959
1960 return ERROR_OK;
1961 }
1962
1963 int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1964 {
1965 u8 *buffer;
1966 u32 buf_cnt;
1967 u32 image_size;
1968 int i;
1969 int retval;
1970 u32 checksum = 0;
1971 u32 mem_checksum = 0;
1972
1973 image_t image;
1974
1975 duration_t duration;
1976 char *duration_text;
1977
1978 target_t *target = get_current_target(cmd_ctx);
1979
1980 if (argc < 1)
1981 {
1982 command_print(cmd_ctx, "usage: verify_image <file> [offset] [type]");
1983 return ERROR_OK;
1984 }
1985
1986 if (!target)
1987 {
1988 ERROR("no target selected");
1989 return ERROR_OK;
1990 }
1991
1992 duration_start_measure(&duration);
1993
1994 if (argc >= 2)
1995 {
1996 image.base_address_set = 1;
1997 image.base_address = strtoul(args[1], NULL, 0);
1998 }
1999 else
2000 {
2001 image.base_address_set = 0;
2002 image.base_address = 0x0;
2003 }
2004
2005 image.start_address_set = 0;
2006
2007 if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
2008 {
2009 command_print(cmd_ctx, "verify_image error: %s", image.error_str);
2010 return ERROR_OK;
2011 }
2012
2013 image_size = 0x0;
2014 for (i = 0; i < image.num_sections; i++)
2015 {
2016 buffer = malloc(image.sections[i].size);
2017 if (buffer == NULL)
2018 {
2019 command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size);
2020 break;
2021 }
2022 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
2023 {
2024 ERROR("image_read_section failed with error code: %i", retval);
2025 command_print(cmd_ctx, "image reading failed, verify aborted");
2026 free(buffer);
2027 image_close(&image);
2028 return ERROR_OK;
2029 }
2030
2031 /* calculate checksum of image */
2032 image_calculate_checksum( buffer, buf_cnt, &checksum );
2033
2034 retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
2035
2036 if( retval != ERROR_OK )
2037 {
2038 command_print(cmd_ctx, "could not calculate checksum, verify aborted");
2039 free(buffer);
2040 image_close(&image);
2041 return ERROR_OK;
2042 }
2043
2044 if( checksum != mem_checksum )
2045 {
2046 /* failed crc checksum, fall back to a binary compare */
2047 u8 *data;
2048
2049 command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
2050
2051 data = (u8*)malloc(buf_cnt);
2052
2053 /* Can we use 32bit word accesses? */
2054 int size = 1;
2055 int count = buf_cnt;
2056 if ((count % 4) == 0)
2057 {
2058 size *= 4;
2059 count /= 4;
2060 }
2061 retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
2062
2063 if (retval == ERROR_OK)
2064 {
2065 int t;
2066 for (t = 0; t < buf_cnt; t++)
2067 {
2068 if (data[t] != buffer[t])
2069 {
2070 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]);
2071 free(data);
2072 free(buffer);
2073 image_close(&image);
2074 return ERROR_OK;
2075 }
2076 }
2077 }
2078
2079 free(data);
2080 }
2081
2082 free(buffer);
2083 image_size += buf_cnt;
2084 }
2085
2086 duration_stop_measure(&duration, &duration_text);
2087 command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
2088 free(duration_text);
2089
2090 image_close(&image);
2091
2092 return ERROR_OK;
2093 }
2094
2095 int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2096 {
2097 int retval;
2098 target_t *target = get_current_target(cmd_ctx);
2099
2100 if (argc == 0)
2101 {
2102 breakpoint_t *breakpoint = target->breakpoints;
2103
2104 while (breakpoint)
2105 {
2106 if (breakpoint->type == BKPT_SOFT)
2107 {
2108 char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
2109 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
2110 free(buf);
2111 }
2112 else
2113 {
2114 command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
2115 }
2116 breakpoint = breakpoint->next;
2117 }
2118 }
2119 else if (argc >= 2)
2120 {
2121 int hw = BKPT_SOFT;
2122 u32 length = 0;
2123
2124 length = strtoul(args[1], NULL, 0);
2125
2126 if (argc >= 3)
2127 if (strcmp(args[2], "hw") == 0)
2128 hw = BKPT_HARD;
2129
2130 if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
2131 {
2132 switch (retval)
2133 {
2134 case ERROR_TARGET_NOT_HALTED:
2135 command_print(cmd_ctx, "target must be halted to set breakpoints");
2136 break;
2137 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2138 command_print(cmd_ctx, "no more breakpoints available");
2139 break;
2140 default:
2141 command_print(cmd_ctx, "unknown error, breakpoint not set");
2142 break;
2143 }
2144 }
2145 else
2146 {
2147 command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
2148 }
2149 }
2150 else
2151 {
2152 command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
2153 }
2154
2155 return ERROR_OK;
2156 }
2157
2158 int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2159 {
2160 target_t *target = get_current_target(cmd_ctx);
2161
2162 if (argc > 0)
2163 breakpoint_remove(target, strtoul(args[0], NULL, 0));
2164
2165 return ERROR_OK;
2166 }
2167
2168 int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2169 {
2170 target_t *target = get_current_target(cmd_ctx);
2171 int retval;
2172
2173 if (argc == 0)
2174 {
2175 watchpoint_t *watchpoint = target->watchpoints;
2176
2177 while (watchpoint)
2178 {
2179 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);
2180 watchpoint = watchpoint->next;
2181 }
2182 }
2183 else if (argc >= 2)
2184 {
2185 enum watchpoint_rw type = WPT_ACCESS;
2186 u32 data_value = 0x0;
2187 u32 data_mask = 0xffffffff;
2188
2189 if (argc >= 3)
2190 {
2191 switch(args[2][0])
2192 {
2193 case 'r':
2194 type = WPT_READ;
2195 break;
2196 case 'w':
2197 type = WPT_WRITE;
2198 break;
2199 case 'a':
2200 type = WPT_ACCESS;
2201 break;
2202 default:
2203 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2204 return ERROR_OK;
2205 }
2206 }
2207 if (argc >= 4)
2208 {
2209 data_value = strtoul(args[3], NULL, 0);
2210 }
2211 if (argc >= 5)
2212 {
2213 data_mask = strtoul(args[4], NULL, 0);
2214 }
2215
2216 if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
2217 strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
2218 {
2219 switch (retval)
2220 {
2221 case ERROR_TARGET_NOT_HALTED:
2222 command_print(cmd_ctx, "target must be halted to set watchpoints");
2223 break;
2224 case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
2225 command_print(cmd_ctx, "no more watchpoints available");
2226 break;
2227 default:
2228 command_print(cmd_ctx, "unknown error, watchpoint not set");
2229 break;
2230 }
2231 }
2232 }
2233 else
2234 {
2235 command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
2236 }
2237
2238 return ERROR_OK;
2239 }
2240
2241 int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2242 {
2243 target_t *target = get_current_target(cmd_ctx);
2244
2245 if (argc > 0)
2246 watchpoint_remove(target, strtoul(args[0], NULL, 0));
2247
2248 return ERROR_OK;
2249 }
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)