f2a5aa942c08620da0b86e56e7f3f5bde655cba1
[openocd.git] / src / jtag / zy1000 / zy1000.c
1 /***************************************************************************
2 * Copyright (C) 2007-2008 by √ėyvind Harboe *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
18 ***************************************************************************/
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "embeddedice.h"
24 #include "minidriver.h"
25 #include "interface.h"
26 #include "zy1000_version.h"
27
28 #include <cyg/hal/hal_io.h> // low level i/o
29 #include <cyg/hal/hal_diag.h>
30
31 #define ZYLIN_VERSION GIT_ZY1000_VERSION
32 #define ZYLIN_DATE __DATE__
33 #define ZYLIN_TIME __TIME__
34 #define ZYLIN_OPENOCD GIT_OPENOCD_VERSION
35 #define ZYLIN_OPENOCD_VERSION "ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE
36
37 /* low level command set
38 */
39 void zy1000_reset(int trst, int srst);
40
41
42 int zy1000_speed(int speed);
43 int zy1000_register_commands(struct command_context *cmd_ctx);
44 int zy1000_init(void);
45 int zy1000_quit(void);
46
47 /* interface commands */
48 int zy1000_handle_zy1000_port_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc);
49
50 static int zy1000_khz(int khz, int *jtag_speed)
51 {
52 if (khz == 0)
53 {
54 *jtag_speed = 0;
55 }
56 else
57 {
58 *jtag_speed = 64000/khz;
59 }
60 return ERROR_OK;
61 }
62
63 static int zy1000_speed_div(int speed, int *khz)
64 {
65 if (speed == 0)
66 {
67 *khz = 0;
68 }
69 else
70 {
71 *khz = 64000/speed;
72 }
73
74 return ERROR_OK;
75 }
76
77 static bool readPowerDropout(void)
78 {
79 cyg_uint32 state;
80 // sample and clear power dropout
81 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x80);
82 HAL_READ_UINT32(ZY1000_JTAG_BASE + 0x10, state);
83 bool powerDropout;
84 powerDropout = (state & 0x80) != 0;
85 return powerDropout;
86 }
87
88
89 static bool readSRST(void)
90 {
91 cyg_uint32 state;
92 // sample and clear SRST sensing
93 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x00000040);
94 HAL_READ_UINT32(ZY1000_JTAG_BASE + 0x10, state);
95 bool srstAsserted;
96 srstAsserted = (state & 0x40) != 0;
97 return srstAsserted;
98 }
99
100 static int zy1000_srst_asserted(int *srst_asserted)
101 {
102 *srst_asserted = readSRST();
103 return ERROR_OK;
104 }
105
106 static int zy1000_power_dropout(int *dropout)
107 {
108 *dropout = readPowerDropout();
109 return ERROR_OK;
110 }
111
112
113 struct jtag_interface zy1000_interface =
114 {
115 .name = "ZY1000",
116 .execute_queue = NULL,
117 .speed = zy1000_speed,
118 .register_commands = zy1000_register_commands,
119 .init = zy1000_init,
120 .quit = zy1000_quit,
121 .khz = zy1000_khz,
122 .speed_div = zy1000_speed_div,
123 .power_dropout = zy1000_power_dropout,
124 .srst_asserted = zy1000_srst_asserted,
125 };
126
127 void zy1000_reset(int trst, int srst)
128 {
129 LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);
130 if (!srst)
131 {
132 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x00000001);
133 }
134 else
135 {
136 /* Danger!!! if clk != 0 when in
137 * idle in TAP_IDLE, reset halt on str912 will fail.
138 */
139 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x00000001);
140 }
141
142 if (!trst)
143 {
144 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x00000002);
145 }
146 else
147 {
148 /* assert reset */
149 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x00000002);
150 }
151
152 if (trst||(srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
153 {
154 waitIdle();
155 /* we're now in the RESET state until trst is deasserted */
156 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, TAP_RESET);
157 } else
158 {
159 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
160 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
161 }
162
163 /* wait for srst to float back up */
164 if (!srst)
165 {
166 int i;
167 for (i = 0; i < 1000; i++)
168 {
169 // We don't want to sense our own reset, so we clear here.
170 // There is of course a timing hole where we could loose
171 // a "real" reset.
172 if (!readSRST())
173 break;
174
175 /* wait 1ms */
176 alive_sleep(1);
177 }
178
179 if (i == 1000)
180 {
181 LOG_USER("SRST didn't deassert after %dms", i);
182 } else if (i > 1)
183 {
184 LOG_USER("SRST took %dms to deassert", i);
185 }
186 }
187 }
188
189 int zy1000_speed(int speed)
190 {
191 if (speed == 0)
192 {
193 /*0 means RCLK*/
194 speed = 0;
195 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x100);
196 LOG_DEBUG("jtag_speed using RCLK");
197 }
198 else
199 {
200 if (speed > 8190 || speed < 2)
201 {
202 LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
203 return ERROR_INVALID_ARGUMENTS;
204 }
205
206 LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
207 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x100);
208 ZY1000_POKE(ZY1000_JTAG_BASE + 0x1c, speed&~1);
209 }
210 return ERROR_OK;
211 }
212
213 static bool savePower;
214
215
216 static void setPower(bool power)
217 {
218 savePower = power;
219 if (power)
220 {
221 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x14, 0x8);
222 } else
223 {
224 HAL_WRITE_UINT32(ZY1000_JTAG_BASE + 0x10, 0x8);
225 }
226 }
227
228 int handle_power_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc)
229 {
230 if (argc > 1)
231 {
232 return ERROR_INVALID_ARGUMENTS;
233 }
234
235 if (argc == 1)
236 {
237 if (strcmp(args[0], "on") == 0)
238 {
239 setPower(1);
240 }
241 else if (strcmp(args[0], "off") == 0)
242 {
243 setPower(0);
244 } else
245 {
246 command_print(cmd_ctx, "arg is \"on\" or \"off\"");
247 return ERROR_INVALID_ARGUMENTS;
248 }
249 }
250
251 command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
252
253 return ERROR_OK;
254 }
255
256
257 /* Give TELNET a way to find out what version this is */
258 static int jim_zy1000_version(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
259 {
260 if ((argc < 1) || (argc > 2))
261 return JIM_ERR;
262 char buff[128];
263 const char *version_str = NULL;
264
265 if (argc == 1)
266 {
267 version_str = ZYLIN_OPENOCD_VERSION;
268 } else
269 {
270 const char *str = Jim_GetString(argv[1], NULL);
271 if (strcmp("openocd", str) == 0)
272 {
273 version_str = ZYLIN_OPENOCD;
274 }
275 else if (strcmp("zy1000", str) == 0)
276 {
277 version_str = ZYLIN_VERSION;
278 }
279 else if (strcmp("date", str) == 0)
280 {
281 version_str = ZYLIN_DATE;
282 }
283 else if (strcmp("time", str) == 0)
284 {
285 version_str = ZYLIN_TIME;
286 }
287 else if (strcmp("pcb", str) == 0)
288 {
289 #ifdef CYGPKG_HAL_NIOS2
290 version_str="c";
291 #else
292 version_str="b";
293 #endif
294 }
295 else
296 {
297 return JIM_ERR;
298 }
299 }
300
301 Jim_SetResult(interp, Jim_NewStringObj(interp, version_str, -1));
302
303 return JIM_OK;
304 }
305
306
307 #ifdef CYGPKG_HAL_NIOS2
308 static int jim_zy1000_writefirmware(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
309 {
310 if (argc != 2)
311 return JIM_ERR;
312
313 int length;
314 int stat;
315 const char *str = Jim_GetString(argv[1], &length);
316
317 /* BUG!!!! skip header! */
318 void *firmware_address=0x4000000;
319 int firmware_length=0x100000;
320
321 if (length>firmware_length)
322 return JIM_ERR;
323
324 void *err_addr;
325
326 if ((stat = flash_erase((void *)firmware_address, firmware_length, (void **)&err_addr)) != 0)
327 {
328 return JIM_ERR;
329 }
330
331 if ((stat = flash_program(firmware_address, str, length, (void **)&err_addr)) != 0)
332 return JIM_ERR;
333
334 return JIM_OK;
335 }
336 #endif
337
338 static int
339 zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp,
340 int argc,
341 Jim_Obj * const *argv)
342 {
343 if (argc != 1)
344 {
345 Jim_WrongNumArgs(interp, 1, argv, "powerstatus");
346 return JIM_ERR;
347 }
348
349 cyg_uint32 status;
350 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, status);
351
352 Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80) != 0));
353
354 return JIM_OK;
355 }
356
357 int zy1000_register_commands(struct command_context *cmd_ctx)
358 {
359 register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
360 "power <on/off> - turn power switch to target on/off. No arguments - print status.");
361
362 Jim_CreateCommand(interp, "zy1000_version", jim_zy1000_version, NULL, NULL);
363
364
365 Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL);
366
367 #ifdef CYGPKG_HAL_NIOS2
368 Jim_CreateCommand(interp, "updatezy1000firmware", jim_zy1000_writefirmware, NULL, NULL);
369 #endif
370
371
372 return ERROR_OK;
373 }
374
375
376
377
378 int zy1000_init(void)
379 {
380 LOG_USER("%s", ZYLIN_OPENOCD_VERSION);
381
382 ZY1000_POKE(ZY1000_JTAG_BASE + 0x10, 0x30); // Turn on LED1 & LED2
383
384 setPower(true); // on by default
385
386
387 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
388 zy1000_reset(0, 0);
389 zy1000_speed(jtag_get_speed());
390
391 return ERROR_OK;
392 }
393
394 int zy1000_quit(void)
395 {
396
397 return ERROR_OK;
398 }
399
400
401
402 int interface_jtag_execute_queue(void)
403 {
404 cyg_uint32 empty;
405
406 waitIdle();
407 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x10, empty);
408 /* clear JTAG error register */
409 ZY1000_POKE(ZY1000_JTAG_BASE + 0x14, 0x400);
410
411 if ((empty&0x400) != 0)
412 {
413 LOG_WARNING("RCLK timeout");
414 /* the error is informative only as we don't want to break the firmware if there
415 * is a false positive.
416 */
417 // return ERROR_FAIL;
418 }
419 return ERROR_OK;
420 }
421
422
423
424
425
426 static cyg_uint32 getShiftValue(void)
427 {
428 cyg_uint32 value;
429 waitIdle();
430 ZY1000_PEEK(ZY1000_JTAG_BASE + 0xc, value);
431 VERBOSE(LOG_INFO("getShiftValue %08x", value));
432 return value;
433 }
434 #if 0
435 static cyg_uint32 getShiftValueFlip(void)
436 {
437 cyg_uint32 value;
438 waitIdle();
439 ZY1000_PEEK(ZY1000_JTAG_BASE + 0x18, value);
440 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
441 return value;
442 }
443 #endif
444
445 #if 0
446 static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value)
447 {
448 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
449 cyg_uint32 a,b;
450 a = state;
451 b = endState;
452 ZY1000_POKE(ZY1000_JTAG_BASE + 0xc, value);
453 ZY1000_POKE(ZY1000_JTAG_BASE + 0x8, (1 << 15) | (repeat << 8) | (a << 4) | b);
454 VERBOSE(getShiftValueFlip());
455 }
456 #endif
457
458 static void gotoEndState(tap_state_t end_state)
459 {
460 setCurrentState(end_state);
461 }
462
463 static __inline void scanFields(int num_fields, const struct scan_field *fields, tap_state_t shiftState, int pause)
464 {
465 int i;
466 int j;
467 int k;
468
469 for (i = 0; i < num_fields; i++)
470 {
471 cyg_uint32 value;
472
473 uint8_t *inBuffer = NULL;
474
475
476 // figure out where to store the input data
477 int num_bits = fields[i].num_bits;
478 if (fields[i].in_value != NULL)
479 {
480 inBuffer = fields[i].in_value;
481 }
482
483 // here we shuffle N bits out/in
484 j = 0;
485 while (j < num_bits)
486 {
487 tap_state_t pause_state;
488 int l;
489 k = num_bits-j;
490 pause_state = (shiftState == TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
491 if (k > 32)
492 {
493 k = 32;
494 /* we have more to shift out */
495 } else if (pause&&(i == num_fields-1))
496 {
497 /* this was the last to shift out this time */
498 pause_state = (shiftState==TAP_DRSHIFT)?TAP_DRPAUSE:TAP_IRPAUSE;
499 }
500
501 // we have (num_bits + 7)/8 bytes of bits to toggle out.
502 // bits are pushed out LSB to MSB
503 value = 0;
504 if (fields[i].out_value != NULL)
505 {
506 for (l = 0; l < k; l += 8)
507 {
508 value|=fields[i].out_value[(j + l)/8]<<l;
509 }
510 }
511 /* mask away unused bits for easier debugging */
512 if (k < 32)
513 {
514 value&=~(((uint32_t)0xffffffff) << k);
515 } else
516 {
517 /* Shifting by >= 32 is not defined by the C standard
518 * and will in fact shift by &0x1f bits on nios */
519 }
520
521 shiftValueInner(shiftState, pause_state, k, value);
522
523 if (inBuffer != NULL)
524 {
525 // data in, LSB to MSB
526 value = getShiftValue();
527 // we're shifting in data to MSB, shift data to be aligned for returning the value
528 value >>= 32-k;
529
530 for (l = 0; l < k; l += 8)
531 {
532 inBuffer[(j + l)/8]=(value >> l)&0xff;
533 }
534 }
535 j += k;
536 }
537 }
538 }
539
540 int interface_jtag_add_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
541 {
542
543 int j;
544 int scan_size = 0;
545 struct jtag_tap *tap, *nextTap;
546 for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
547 {
548 nextTap = jtag_tap_next_enabled(tap);
549 int pause = (nextTap==NULL);
550
551 int found = 0;
552
553 scan_size = tap->ir_length;
554
555 /* search the list */
556 for (j = 0; j < num_fields; j++)
557 {
558 if (tap == fields[j].tap)
559 {
560 found = 1;
561
562 scanFields(1, fields + j, TAP_IRSHIFT, pause);
563 /* update device information */
564 buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
565
566 tap->bypass = 0;
567 break;
568 }
569 }
570
571 if (!found)
572 {
573 /* if a device isn't listed, set it to BYPASS */
574 uint8_t ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
575
576 struct scan_field tmp;
577 memset(&tmp, 0, sizeof(tmp));
578 tmp.out_value = ones;
579 tmp.num_bits = scan_size;
580 scanFields(1, &tmp, TAP_IRSHIFT, pause);
581 /* update device information */
582 buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
583 tap->bypass = 1;
584 }
585 }
586 gotoEndState(state);
587
588 return ERROR_OK;
589 }
590
591
592
593
594
595 int interface_jtag_add_plain_ir_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
596 {
597 scanFields(num_fields, fields, TAP_IRSHIFT, 1);
598 gotoEndState(state);
599
600 return ERROR_OK;
601 }
602
603 int interface_jtag_add_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
604 {
605
606 int j;
607 struct jtag_tap *tap, *nextTap;
608 for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap = nextTap)
609 {
610 nextTap = jtag_tap_next_enabled(tap);
611 int found = 0;
612 int pause = (nextTap==NULL);
613
614 for (j = 0; j < num_fields; j++)
615 {
616 if (tap == fields[j].tap)
617 {
618 found = 1;
619
620 scanFields(1, fields+j, TAP_DRSHIFT, pause);
621 }
622 }
623 if (!found)
624 {
625 struct scan_field tmp;
626 /* program the scan field to 1 bit length, and ignore it's value */
627 tmp.num_bits = 1;
628 tmp.out_value = NULL;
629 tmp.in_value = NULL;
630
631 scanFields(1, &tmp, TAP_DRSHIFT, pause);
632 }
633 else
634 {
635 }
636 }
637 gotoEndState(state);
638 return ERROR_OK;
639 }
640
641 int interface_jtag_add_plain_dr_scan(int num_fields, const struct scan_field *fields, tap_state_t state)
642 {
643 scanFields(num_fields, fields, TAP_DRSHIFT, 1);
644 gotoEndState(state);
645 return ERROR_OK;
646 }
647
648
649 int interface_jtag_add_tlr()
650 {
651 setCurrentState(TAP_RESET);
652 return ERROR_OK;
653 }
654
655
656
657
658 int interface_jtag_add_reset(int req_trst, int req_srst)
659 {
660 zy1000_reset(req_trst, req_srst);
661 return ERROR_OK;
662 }
663
664 static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate)
665 {
666 /* num_cycles can be 0 */
667 setCurrentState(clockstate);
668
669 /* execute num_cycles, 32 at the time. */
670 int i;
671 for (i = 0; i < num_cycles; i += 32)
672 {
673 int num;
674 num = 32;
675 if (num_cycles-i < num)
676 {
677 num = num_cycles-i;
678 }
679 shiftValueInner(clockstate, clockstate, num, 0);
680 }
681
682 #if !TEST_MANUAL()
683 /* finish in end_state */
684 setCurrentState(state);
685 #else
686 tap_state_t t = TAP_IDLE;
687 /* test manual drive code on any target */
688 int tms;
689 uint8_t tms_scan = tap_get_tms_path(t, state);
690 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
691
692 for (i = 0; i < tms_count; i++)
693 {
694 tms = (tms_scan >> i) & 1;
695 waitIdle();
696 ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
697 }
698 waitIdle();
699 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, state);
700 #endif
701
702
703 return ERROR_OK;
704 }
705
706 int interface_jtag_add_runtest(int num_cycles, tap_state_t state)
707 {
708 return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE);
709 }
710
711 int interface_jtag_add_clocks(int num_cycles)
712 {
713 return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
714 }
715
716 int interface_jtag_add_sleep(uint32_t us)
717 {
718 jtag_sleep(us);
719 return ERROR_OK;
720 }
721
722 int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
723 {
724 int state_count;
725 int tms = 0;
726
727 /*wait for the fifo to be empty*/
728 waitIdle();
729
730 state_count = 0;
731
732 tap_state_t cur_state = cmd_queue_cur_state;
733
734 while (num_states)
735 {
736 if (tap_state_transition(cur_state, false) == path[state_count])
737 {
738 tms = 0;
739 }
740 else if (tap_state_transition(cur_state, true) == path[state_count])
741 {
742 tms = 1;
743 }
744 else
745 {
746 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count]));
747 exit(-1);
748 }
749
750 waitIdle();
751 ZY1000_POKE(ZY1000_JTAG_BASE + 0x28, tms);
752
753 cur_state = path[state_count];
754 state_count++;
755 num_states--;
756 }
757
758 waitIdle();
759 ZY1000_POKE(ZY1000_JTAG_BASE + 0x20, cur_state);
760 return ERROR_OK;
761 }
762
763
764
765 void embeddedice_write_dcc(struct jtag_tap *tap, int reg_addr, uint8_t *buffer, int little, int count)
766 {
767 // static int const reg_addr = 0x5;
768 tap_state_t end_state = jtag_get_end_state();
769 if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL)) == NULL)
770 {
771 /* better performance via code duplication */
772 if (little)
773 {
774 int i;
775 for (i = 0; i < count; i++)
776 {
777 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
778 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
779 buffer += 4;
780 }
781 } else
782 {
783 int i;
784 for (i = 0; i < count; i++)
785 {
786 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
787 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr | (1 << 5));
788 buffer += 4;
789 }
790 }
791 }
792 else
793 {
794 int i;
795 for (i = 0; i < count; i++)
796 {
797 embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
798 buffer += 4;
799 }
800 }
801 }
802
803

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)