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