Code Review / openocd.git / blob
? search:


2794e175effa46627b753fa170222a528cf3f59b
[openocd.git] / src / jtag / usbprog.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Benedikt Sauter *
3 * sauter@ixbat.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
21 /*
22 * This file is based on Dominic Rath's amt_jtagaccel.c.
23 *
24 * usbprog is a free programming adapter. You can easily install
25 * different firmware versions from an "online pool" over USB.
26 * The adapter can be used for programming and debugging AVR and ARM
27 * processors, as USB to RS232 converter, as JTAG interface or as
28 * simple I/O interface (5 lines).
29 *
30 * http://www.embedded-projects.net/usbprog
31 */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #include "jtag.h"
38
39 #include <usb.h>
40
41
42 #define VID 0x1781
43 #define PID 0x0c63
44
45 /* Pins at usbprog */
46 #define TDO_BIT 0
47 #define TDI_BIT 3
48 #define TCK_BIT 2
49 #define TMS_BIT 1
50
51 static int usbprog_execute_queue(void);
52 static int usbprog_speed(int speed);
53 static int usbprog_register_commands(struct command_context_s *cmd_ctx);
54 static int usbprog_init(void);
55 static int usbprog_quit(void);
56
57 static void usbprog_end_state(tap_state_t state);
58 static void usbprog_state_move(void);
59 static void usbprog_path_move(pathmove_command_t *cmd);
60 static void usbprog_runtest(int num_cycles);
61 static void usbprog_scan(bool ir_scan, enum scan_type type, u8 *buffer, int scan_size);
62
63 jtag_interface_t usbprog_interface =
64 {
65 .name = "usbprog",
66 .execute_queue = usbprog_execute_queue,
67 .speed = usbprog_speed,
68 .register_commands = usbprog_register_commands,
69 .init = usbprog_init,
70 .quit = usbprog_quit
71 };
72
73 #define UNKOWN_COMMAND 0x00
74 #define PORT_DIRECTION 0x01
75 #define PORT_SET 0x02
76 #define PORT_GET 0x03
77 #define PORT_SETBIT 0x04
78 #define PORT_GETBIT 0x05
79 #define WRITE_TDI 0x06
80 #define READ_TDO 0x07
81 #define WRITE_AND_READ 0x08
82 #define WRITE_TMS 0x09
83 #define WRITE_TMS_CHAIN 0x0A
84
85 struct usbprog_jtag
86 {
87 struct usb_dev_handle* usb_handle;
88 };
89
90 static struct usbprog_jtag * usbprog_jtag_handle;
91
92 static struct usbprog_jtag* usbprog_jtag_open(void);
93 //static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
94 static void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
95 static unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
96
97 static void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
98 static void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
99 static void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
100 static void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan);
101
102 static char tms_chain[64];
103 static int tms_chain_index;
104
105 static void usbprog_jtag_tms_collect(char tms_scan);
106 static void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag);
107
108 static void usbprog_write(int tck, int tms, int tdi);
109 static void usbprog_reset(int trst, int srst);
110
111 static void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction);
112 static void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value);
113 //static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
114 static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value);
115 //static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
116
117 static int usbprog_speed(int speed)
118 {
119 return ERROR_OK;
120 }
121
122 static int usbprog_register_commands(struct command_context_s *cmd_ctx)
123 {
124 return ERROR_OK;
125 }
126
127 static int usbprog_execute_queue(void)
128 {
129 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
130 int scan_size;
131 enum scan_type type;
132 u8 *buffer;
133
134 while (cmd)
135 {
136 switch (cmd->type)
137 {
138 case JTAG_END_STATE:
139 #ifdef _DEBUG_JTAG_IO_
140 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
141 #endif
142 if (cmd->cmd.end_state->end_state != TAP_INVALID)
143 usbprog_end_state(cmd->cmd.end_state->end_state);
144 break;
145 case JTAG_RESET:
146 #ifdef _DEBUG_JTAG_IO_
147 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
148 #endif
149 if (cmd->cmd.reset->trst == 1)
150 {
151 tap_set_state(TAP_RESET);
152 }
153 usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
154 break;
155 case JTAG_RUNTEST:
156 #ifdef _DEBUG_JTAG_IO_
157 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
158 #endif
159 if (cmd->cmd.runtest->end_state != TAP_INVALID)
160 usbprog_end_state(cmd->cmd.runtest->end_state);
161 usbprog_runtest(cmd->cmd.runtest->num_cycles);
162 break;
163 case JTAG_STATEMOVE:
164 #ifdef _DEBUG_JTAG_IO_
165 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
166 #endif
167 if (cmd->cmd.statemove->end_state != TAP_INVALID)
168 usbprog_end_state(cmd->cmd.statemove->end_state);
169 usbprog_state_move();
170 break;
171 case JTAG_PATHMOVE:
172 #ifdef _DEBUG_JTAG_IO_
173 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
174 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
175 #endif
176 usbprog_path_move(cmd->cmd.pathmove);
177 break;
178 case JTAG_SCAN:
179 #ifdef _DEBUG_JTAG_IO_
180 LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state);
181 #endif
182 if (cmd->cmd.scan->end_state != TAP_INVALID)
183 usbprog_end_state(cmd->cmd.scan->end_state);
184 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
185 type = jtag_scan_type(cmd->cmd.scan);
186 usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
187 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
188 return ERROR_JTAG_QUEUE_FAILED;
189 if (buffer)
190 free(buffer);
191 break;
192 case JTAG_SLEEP:
193 #ifdef _DEBUG_JTAG_IO_
194 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
195 #endif
196 jtag_sleep(cmd->cmd.sleep->us);
197 break;
198 default:
199 LOG_ERROR("BUG: unknown JTAG command type encountered");
200 exit(-1);
201 }
202
203 cmd = cmd->next;
204 }
205
206 return ERROR_OK;
207 }
208
209 static int usbprog_init(void)
210 {
211 usbprog_jtag_handle = usbprog_jtag_open();
212
213 tms_chain_index = 0;
214 if (usbprog_jtag_handle == 0)
215 {
216 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
217 return ERROR_JTAG_INIT_FAILED;
218 }
219
220 LOG_INFO("USB JTAG Interface ready!");
221
222 usbprog_jtag_init(usbprog_jtag_handle);
223 usbprog_reset(0, 0);
224 usbprog_write(0, 0, 0);
225
226 return ERROR_OK;
227 }
228
229 static int usbprog_quit(void)
230 {
231 return ERROR_OK;
232 }
233
234 /*************** jtag execute commands **********************/
235 static void usbprog_end_state(tap_state_t state)
236 {
237 if (tap_is_state_stable(state))
238 tap_set_end_state(state);
239 else
240 {
241 LOG_ERROR("BUG: %i is not a valid end state", state);
242 exit(-1);
243 }
244 }
245
246 static void usbprog_state_move(void)
247 {
248 int i = 0, tms = 0;
249 u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
250 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
251
252 usbprog_jtag_write_tms(usbprog_jtag_handle, (char)tms_scan);
253 for (i = 0; i < tms_count; i++)
254 {
255 tms = (tms_scan >> i) & 1;
256 }
257
258 tap_set_state(tap_get_end_state());
259 }
260
261 static void usbprog_path_move(pathmove_command_t *cmd)
262 {
263 int num_states = cmd->num_states;
264 int state_count;
265
266 /* There may be queued transitions, and before following a specified
267 path, we must flush those queued transitions */
268 usbprog_jtag_tms_send(usbprog_jtag_handle);
269
270 state_count = 0;
271 while (num_states)
272 {
273 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
274 {
275 /* LOG_INFO("1"); */
276 usbprog_write(0, 0, 0);
277 usbprog_write(1, 0, 0);
278 }
279 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
280 {
281 /* LOG_INFO("2"); */
282 usbprog_write(0, 1, 0);
283 usbprog_write(1, 1, 0);
284 }
285 else
286 {
287 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
288 exit(-1);
289 }
290
291 tap_set_state(cmd->path[state_count]);
292 state_count++;
293 num_states--;
294 }
295
296 tap_set_end_state(tap_get_state());
297 }
298
299 static void usbprog_runtest(int num_cycles)
300 {
301 int i;
302
303 /* only do a state_move when we're not already in IDLE */
304 if (tap_get_state() != TAP_IDLE)
305 {
306 usbprog_end_state(TAP_IDLE);
307 usbprog_state_move();
308 }
309
310 /* execute num_cycles */
311 if (num_cycles > 0)
312 {
313 usbprog_jtag_tms_send(usbprog_jtag_handle);
314 usbprog_write(0, 0, 0);
315 }
316 else
317 {
318 usbprog_jtag_tms_send(usbprog_jtag_handle);
319 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
320 }
321
322 for (i = 0; i < num_cycles; i++)
323 {
324 usbprog_write(1, 0, 0);
325 usbprog_write(0, 0, 0);
326 }
327
328 #ifdef _DEBUG_JTAG_IO_
329 LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()));
330 #endif
331
332 /* finish in end_state */
333 /*
334 usbprog_end_state(saved_end_state);
335 if (tap_get_state() != tap_get_end_state())
336 usbprog_state_move();
337 */
338 }
339
340 static void usbprog_scan(bool ir_scan, enum scan_type type, u8 *buffer, int scan_size)
341 {
342 tap_state_t saved_end_state = tap_get_end_state();
343
344 if (ir_scan)
345 usbprog_end_state(TAP_IRSHIFT);
346 else
347 usbprog_end_state(TAP_DRSHIFT);
348
349 /* Only move if we're not already there */
350 if (tap_get_state() != tap_get_end_state())
351 usbprog_state_move();
352
353 usbprog_end_state(saved_end_state);
354
355 usbprog_jtag_tms_send(usbprog_jtag_handle);
356
357 void (*f)(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
358 switch (type) {
359 case SCAN_OUT: f = &usbprog_jtag_write_tdi; break;
360 case SCAN_IN: f = &usbprog_jtag_read_tdo; break;
361 case SCAN_IO: f = &usbprog_jtag_write_and_read; break;
362 default:
363 LOG_ERROR("unknown scan type: %i", type);
364 exit(-1);
365 }
366 f(usbprog_jtag_handle, (char *)buffer, scan_size);
367
368 /* The adapter does the transition to PAUSE internally */
369 if (ir_scan)
370 tap_set_state(TAP_IRPAUSE);
371 else
372 tap_set_state(TAP_DRPAUSE);
373
374 if (tap_get_state() != tap_get_end_state())
375 usbprog_state_move();
376 }
377
378 /*************** jtag wrapper functions *********************/
379
380 static void usbprog_write(int tck, int tms, int tdi)
381 {
382 unsigned char output_value=0x00;
383
384 if (tms)
385 output_value |= (1<<TMS_BIT);
386 if (tdi)
387 output_value |= (1<<TDI_BIT);
388 if (tck)
389 output_value |= (1<<TCK_BIT);
390
391 usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
392 }
393
394 /* (1) assert or (0) deassert reset lines */
395 static void usbprog_reset(int trst, int srst)
396 {
397 LOG_DEBUG("trst: %i, srst: %i", trst, srst);
398
399 if (trst)
400 usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 0);
401 else
402 usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 1);
403
404 if (srst)
405 usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 0);
406 else
407 usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 1);
408 }
409
410 /*************** jtag lowlevel functions ********************/
411
412 struct usb_bus *busses;
413
414 struct usbprog_jtag* usbprog_jtag_open(void)
415 {
416 struct usb_bus *bus;
417 struct usb_device *dev;
418
419 struct usbprog_jtag *tmp;
420
421 tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
422
423 usb_set_debug(10);
424 usb_init();
425 usb_find_busses();
426 usb_find_devices();
427
428 busses = usb_get_busses();
429
430 /* find usbprog_jtag device in usb bus */
431
432 for (bus = busses; bus; bus = bus->next)
433 {
434 for (dev = bus->devices; dev; dev = dev->next)
435 {
436 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
437 if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID)
438 {
439 tmp->usb_handle = usb_open(dev);
440 usb_set_configuration(tmp->usb_handle, 1);
441 usb_claim_interface(tmp->usb_handle, 0);
442 usb_set_altinterface(tmp->usb_handle, 0);
443 return tmp;
444 }
445 }
446 }
447 return 0;
448 }
449
450 #if 0
451 static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
452 {
453 usb_close(usbprog_jtag->usb_handle);
454 free(usbprog_jtag);
455 }
456 #endif
457
458 static unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
459 {
460 int res = usb_bulk_write(usbprog_jtag->usb_handle, 3, msg,msglen, 100);
461 if ((msg[0] == 2) || (msg[0] == 1) || (msg[0] == 4) || (msg[0] == 0) || \
462 (msg[0] == 6) || (msg[0] == 0x0A) || (msg[0] == 9))
463 return 1;
464 if (res == msglen)
465 {
466 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
467 res = usb_bulk_read(usbprog_jtag->usb_handle, 0x82, msg, 2, 100);
468 if (res > 0)
469 return (unsigned char)msg[1];
470 else
471 return -1;
472 }
473 else
474 return -1;
475 return 0;
476 }
477
478 static void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
479 {
480 usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
481 }
482
483 static void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
484 {
485 char tmp[64]; /* fastes packet size for usb controller */
486 int send_bits, bufindex = 0, fillindex = 0, i, loops;
487
488 char swap;
489 /* 61 byte can be transfered (488 bit) */
490
491 while (size > 0)
492 {
493 if (size > 488)
494 {
495 send_bits = 488;
496 size = size - 488;
497 loops = 61;
498 }
499 else
500 {
501 send_bits = size;
502 loops = size / 8;
503 loops++;
504 size = 0;
505 }
506 tmp[0] = WRITE_AND_READ;
507 tmp[1] = (char)(send_bits >> 8); /* high */
508 tmp[2] = (char)(send_bits); /* low */
509 i = 0;
510
511 for (i = 0; i < loops; i++)
512 {
513 tmp[3 + i] = buffer[bufindex];
514 bufindex++;
515 }
516
517 if (usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000) == 64)
518 {
519 /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
520 usleep(1);
521 int timeout = 0;
522 while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 1000) < 1)
523 {
524 timeout++;
525 if (timeout > 10)
526 break;
527 }
528
529 for (i = 0; i < loops; i++)
530 {
531 swap = tmp[3 + i];
532 buffer[fillindex++] = swap;
533 }
534 }
535 }
536 }
537
538 static void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
539 {
540 char tmp[64]; /* fastes packet size for usb controller */
541 int send_bits, fillindex = 0, i, loops;
542
543 char swap;
544 /* 61 byte can be transfered (488 bit) */
545
546 while (size > 0)
547 {
548 if (size > 488)
549 {
550 send_bits = 488;
551 size = size - 488;
552 loops = 61;
553 }
554 else
555 {
556 send_bits = size;
557 loops = size / 8;
558 loops++;
559 size = 0;
560 }
561 tmp[0] = WRITE_AND_READ;
562 tmp[1] = (char)(send_bits >> 8); /* high */
563 tmp[2] = (char)(send_bits); /* low */
564
565 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 3, 1000);
566
567 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
568 int timeout = 0;
569 usleep(1);
570 while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 10) < 1)
571 {
572 timeout++;
573 if (timeout > 10)
574 break;
575 }
576
577 for (i = 0; i < loops; i++)
578 {
579 swap = tmp[3 + i];
580 buffer[fillindex++] = swap;
581 }
582 }
583 }
584
585 static void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
586 {
587 char tmp[64]; /* fastes packet size for usb controller */
588 int send_bits, bufindex = 0, i, loops;
589
590 /* 61 byte can be transfered (488 bit) */
591 while (size > 0)
592 {
593 if (size > 488)
594 {
595 send_bits = 488;
596 size = size - 488;
597 loops = 61;
598 }
599 else
600 {
601 send_bits = size;
602 loops = size/8;
603 /* if(loops==0) */
604 loops++;
605 size = 0;
606 }
607 tmp[0] = WRITE_TDI;
608 tmp[1] = (char)(send_bits >> 8); /* high */
609 tmp[2] = (char)(send_bits); /* low */
610 i = 0;
611
612 for (i = 0; i < loops; i++)
613 {
614 tmp[3 + i] = buffer[bufindex];
615 bufindex++;
616 }
617 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000);
618 }
619 }
620
621 static void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
622 {
623 usbprog_jtag_tms_collect(tms_scan);
624 }
625
626 static void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
627 {
628 char tmp[2];
629 tmp[0] = PORT_DIRECTION;
630 tmp[1] = (char)direction;
631 usbprog_jtag_message(usbprog_jtag, tmp, 2);
632 }
633
634 static void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
635 {
636 char tmp[2];
637 tmp[0] = PORT_SET;
638 tmp[1] = (char)value;
639 usbprog_jtag_message(usbprog_jtag, tmp, 2);
640 }
641
642 #if 0
643 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
644 {
645 char tmp[2];
646 tmp[0] = PORT_GET;
647 tmp[1] = 0x00;
648 return usbprog_jtag_message(usbprog_jtag, tmp, 2);
649 }
650 #endif
651
652 static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
653 {
654 char tmp[3];
655 tmp[0] = PORT_SETBIT;
656 tmp[1] = (char)bit;
657 if (value == 1)
658 tmp[2] = 0x01;
659 else
660 tmp[2] = 0x00;
661 usbprog_jtag_message(usbprog_jtag, tmp, 3);
662 }
663
664 #if 0
665 static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
666 {
667 char tmp[2];
668 tmp[0] = PORT_GETBIT;
669 tmp[1] = (char)bit;
670
671 if (usbprog_jtag_message(usbprog_jtag, tmp, 2) > 0)
672 return 1;
673 else
674 return 0;
675 }
676 #endif
677
678 static void usbprog_jtag_tms_collect(char tms_scan)
679 {
680 tms_chain[tms_chain_index] = tms_scan;
681 tms_chain_index++;
682 }
683
684 static void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag)
685 {
686 int i;
687 /* LOG_INFO("TMS SEND"); */
688 if (tms_chain_index > 0)
689 {
690 char tmp[tms_chain_index + 2];
691 tmp[0] = WRITE_TMS_CHAIN;
692 tmp[1] = (char)(tms_chain_index);
693 for (i = 0; i < tms_chain_index + 1; i++)
694 tmp[2 + i] = tms_chain[i];
695 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, tms_chain_index + 2, 1000);
696 tms_chain_index = 0;
697 }
698 }
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)