Code Review / openocd.git / blob
? search:


94be87777439f13d40693e2d7548d1ee055e1101
[openocd.git] / src / jtag / usbprog.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Benedikt Sauter sauter@ixbat.de *
3 * based on Dominic Rath's amt_jtagaccel.c *
4 * *
5 * usbprog is a free programming adapter. You can easily install *
6 * different firmware versions from an "online pool" over USB. *
7 * The adapter can be used for programming and debugging AVR and ARM *
8 * processors, as USB to RS232 converter, as JTAG interface or as *
9 * simple I/O interface (5 lines). *
10 * *
11 * http://www.embedded-projects.net/usbprog *
12 * *
13 * This program is free software; you can redistribute it and/or modify *
14 * it under the terms of the GNU General Public License as published by *
15 * the Free Software Foundation; either version 2 of the License, or *
16 * (at your option) any later version. *
17 * *
18 * This program is distributed in the hope that it will be useful, *
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
21 * GNU General Public License for more details. *
22 * *
23 * You should have received a copy of the GNU General Public License *
24 * along with this program; if not, write to the *
25 * Free Software Foundation, Inc., *
26 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
27 ***************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "replacements.h"
34
35 #include "jtag.h"
36 #include <usb.h>
37
38 /* system includes */
39
40 #include "log.h"
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 int usbprog_execute_queue(void);
52 int usbprog_speed(int speed);
53 int usbprog_register_commands(struct command_context_s *cmd_ctx);
54 int usbprog_init(void);
55 int usbprog_quit(void);
56
57
58 void usbprog_end_state(enum tap_state state);
59 void usbprog_state_move(void);
60 void usbprog_path_move(pathmove_command_t *cmd);
61 void usbprog_runtest(int num_cycles);
62 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size);
63
64 jtag_interface_t usbprog_interface =
65 {
66 .name = "usbprog",
67 .execute_queue = usbprog_execute_queue,
68 .support_pathmove = 0,
69 .speed = usbprog_speed,
70 .register_commands = usbprog_register_commands,
71 .init = usbprog_init,
72 .quit = usbprog_quit
73 };
74
75 #define UNKOWN_COMMAND 0x00
76 #define PORT_DIRECTION 0x01
77 #define PORT_SET 0x02
78 #define PORT_GET 0x03
79 #define PORT_SETBIT 0x04
80 #define PORT_GETBIT 0x05
81 #define WRITE_TDI 0x06
82 #define READ_TDO 0x07
83 #define WRITE_AND_READ 0x08
84 #define WRITE_TMS 0x09
85 #define WRITE_TMS_CHAIN 0x0A
86
87 struct usbprog_jtag
88 {
89 struct usb_dev_handle* usb_handle;
90 };
91
92 struct usbprog_jtag * usbprog_jtag_handle;
93
94 struct usbprog_jtag* usbprog_jtag_open();
95 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
96 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
97 unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
98
99
100 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
101 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
102 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
103 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan);
104
105 char tms_chain[64];
106 int tms_chain_index;
107 void usbprog_jtag_tms_collect(char tms_scan);
108 void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag);
109
110 void usbprog_write(int tck, int tms, int tdi);
111 void usbprog_reset(int trst, int srst);
112
113 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction);
114 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value);
115 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
116 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value);
117 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
118
119 int usbprog_speed(int speed)
120 {
121 return ERROR_OK;
122 }
123
124 int usbprog_register_commands(struct command_context_s *cmd_ctx)
125 {
126 return ERROR_OK;
127 }
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 cmd = cmd->next;
206 }
207
208 return ERROR_OK;
209 }
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 ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
219 return ERROR_JTAG_INIT_FAILED;
220 }
221
222 INFO("USB JTAG Interface ready!");
223
224 usbprog_jtag_init(usbprog_jtag_handle);
225 usbprog_reset(0, 0);
226 usbprog_write(0, 0, 0);
227
228 return ERROR_OK;
229 }
230
231 int usbprog_quit(void)
232 {
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
250 void usbprog_state_move(void) {
251
252 int i=0, tms=0;
253 u8 tms_scan = TAP_MOVE(cur_state, end_state);
254
255 usbprog_jtag_write_tms(usbprog_jtag_handle,(char)tms_scan);
256 for (i = 0; i < 7; i++)
257 {
258 tms = (tms_scan >> i) & 1;
259 }
260
261 cur_state = end_state;
262 }
263
264
265 void usbprog_path_move(pathmove_command_t *cmd)
266 {
267 int num_states = cmd->num_states;
268 int state_count;
269
270 state_count = 0;
271 while (num_states)
272 {
273 if (tap_transitions[cur_state].low == cmd->path[state_count])
274 {
275 //INFO("1");
276 usbprog_write(0, 0, 0);
277 usbprog_write(1, 0, 0);
278 }
279 else if (tap_transitions[cur_state].high == cmd->path[state_count])
280 {
281 //INFO("2");
282 usbprog_write(0, 1, 0);
283 usbprog_write(1, 1, 0);
284 }
285 else
286 {
287 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
288 exit(-1);
289 }
290
291 cur_state = cmd->path[state_count];
292 state_count++;
293 num_states--;
294 }
295
296 end_state = cur_state;
297 }
298
299
300 void usbprog_runtest(int num_cycles)
301 {
302 int i;
303
304 enum tap_state saved_end_state = end_state;
305
306
307 /* only do a state_move when we're not already in RTI */
308 if (cur_state != TAP_RTI)
309 {
310 usbprog_end_state(TAP_RTI);
311 usbprog_state_move();
312 }
313
314 /* execute num_cycles */
315 if(num_cycles>0)
316 {
317 usbprog_jtag_tms_send(usbprog_jtag_handle);
318 usbprog_write(0, 0, 0);
319 }
320 else {
321 usbprog_jtag_tms_send(usbprog_jtag_handle);
322 //INFO("NUM CYCLES %i",num_cycles);
323 }
324
325 for (i = 0; i < num_cycles; i++)
326 {
327 usbprog_write(1, 0, 0);
328 usbprog_write(0, 0, 0);
329 }
330
331 /* finish in end_state */
332 /*
333 usbprog_end_state(saved_end_state);
334 if (cur_state != end_state)
335 usbprog_state_move();
336 */
337 }
338
339
340
341 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
342 {
343 enum tap_state saved_end_state = end_state;
344 int bit_cnt;
345
346 if (ir_scan)
347 usbprog_end_state(TAP_SI);
348 else
349 usbprog_end_state(TAP_SD);
350
351 //usbprog_jtag_tms_send(usbprog_jtag_handle);
352
353 usbprog_state_move();
354 usbprog_end_state(saved_end_state);
355
356 usbprog_jtag_tms_send(usbprog_jtag_handle);
357
358 if (type == SCAN_OUT) {
359 usbprog_jtag_write_tdi(usbprog_jtag_handle,buffer, scan_size);
360 }
361 if (type == SCAN_IN) {
362 usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
363 }
364 if (type == SCAN_IO) {
365 usbprog_jtag_write_and_read(usbprog_jtag_handle,buffer, scan_size);
366 }
367
368 if (ir_scan)
369 cur_state = TAP_PI;
370 else
371 cur_state = TAP_PD;
372
373 if (cur_state != end_state)
374 usbprog_state_move();
375 }
376
377 /*************** jtag wrapper functions *********************/
378
379 void usbprog_write(int tck, int tms, int tdi)
380 {
381 unsigned char output_value=0x00;
382
383 if (tms)
384 output_value |= (1<<TMS_BIT);
385 if (tdi)
386 output_value |= (1<<TDI_BIT);
387 if (tck)
388 output_value |= (1<<TCK_BIT);
389
390 usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
391 }
392
393 /* (1) assert or (0) deassert reset lines */
394 void usbprog_reset(int trst, int srst)
395 {
396 DEBUG("trst: %i, srst: %i", trst, srst);
397
398 if(trst)
399 usbprog_jtag_set_bit(usbprog_jtag_handle,5,0);
400 else
401 usbprog_jtag_set_bit(usbprog_jtag_handle,5,1);
402
403 if(srst)
404 usbprog_jtag_set_bit(usbprog_jtag_handle,4,0);
405 else
406 usbprog_jtag_set_bit(usbprog_jtag_handle,4,1);
407 }
408
409
410
411 /*************** jtag lowlevel functions ********************/
412
413
414 struct usb_bus *busses;
415 struct usbprog_jtag* usbprog_jtag_open()
416 {
417 struct usb_dev_handle* usb_handle;
418 struct usb_bus *bus;
419 struct usb_device *dev;
420
421 struct usbprog_jtag * tmp;
422
423 tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
424
425 usb_set_debug(10);
426 usb_init();
427 usb_find_busses();
428 usb_find_devices();
429
430
431 busses = usb_get_busses();
432
433 /* find usbprog_jtag device in usb bus */
434
435 for (bus = busses; bus; bus = bus->next){
436 for (dev = bus->devices; dev; dev = dev->next){
437 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
438 if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
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
451 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
452 {
453 usb_close(usbprog_jtag->usb_handle);
454 free(usbprog_jtag);
455 }
456
457
458 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||msg[0]==6||msg[0]==0x0A||msg[0]==9)
462 return 1;
463 if(res == msglen) {
464 //INFO("HALLLLOOO %i",(int)msg[0]);
465 res = usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
466 if (res > 0)
467 return (unsigned char)msg[1];
468 else
469 return -1;
470 }
471 else
472 return -1;
473 return 0;
474 }
475
476 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
477 {
478 usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
479 }
480
481
482 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
483 {
484 char tmp[64]; // fastes packet size for usb controller
485 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
486
487 char swap;
488 // 61 byte can be transfered (488 bit)
489
490 while(size > 0) {
491 if(size > 488) {
492 send_bits = 488;
493 size = size - 488;
494 loops = 61;
495 } else {
496 send_bits = size;
497 loops = size/8;
498 loops++;
499 size = 0;
500 }
501 tmp[0] = WRITE_AND_READ;
502 tmp[1] = (char)(send_bits>>8); // high
503 tmp[2] = (char)(send_bits); // low
504 i=0;
505
506 for(i=0;i < loops ;i++) {
507 tmp[3+i]=buffer[bufindex];
508 bufindex++;
509 }
510
511 if(usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000)==64)
512 {
513 //INFO("HALLLLOOO2 %i",(int)tmp[0]);
514 usleep(1);
515 int timeout=0;
516 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1){
517 timeout++;
518 if(timeout>10)
519 break;
520 }
521
522 for(i=0;i<loops ;i++) {
523 swap = tmp[3+i];
524 buffer[fillindex++] = swap;
525 }
526 }
527 }
528 }
529
530
531 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
532 {
533 char tmp[64]; // fastes packet size for usb controller
534 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
535
536 char swap;
537 // 61 byte can be transfered (488 bit)
538
539 while(size > 0) {
540 if(size > 488) {
541 send_bits = 488;
542 size = size - 488;
543 loops = 61;
544 } else {
545 send_bits = size;
546 loops = size/8;
547 loops++;
548 size = 0;
549 }
550 tmp[0] = WRITE_AND_READ;
551 tmp[1] = (char)(send_bits>>8); // high
552 tmp[2] = (char)(send_bits); // low
553
554 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
555
556 //INFO("HALLLLOOO3 %i",(int)tmp[0]);
557 int timeout=0;
558 usleep(1);
559 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1){
560 timeout++;
561 if(timeout>10)
562 break;
563 }
564
565 for(i=0;i<loops ;i++) {
566 swap = tmp[3+i];
567 buffer[fillindex++] = swap;
568 }
569 }
570 }
571
572 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
573 {
574 char tmp[64]; // fastes packet size for usb controller
575 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
576 char swap;
577 // 61 byte can be transfered (488 bit)
578 while(size > 0) {
579 if(size > 488) {
580 send_bits = 488;
581 size = size - 488;
582 loops = 61;
583 } else {
584 send_bits = size;
585 loops = size/8;
586 //if(loops==0)
587 loops++;
588 size = 0;
589 }
590 tmp[0] = WRITE_TDI;
591 tmp[1] = (char)(send_bits>>8); // high
592 tmp[2] = (char)(send_bits); // low
593 i=0;
594
595 for(i=0;i < loops ;i++) {
596 tmp[3+i]=buffer[bufindex];
597 bufindex++;
598 }
599 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
600 }
601 }
602
603
604 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
605 {
606 usbprog_jtag_tms_collect(tms_scan);
607 }
608
609
610 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
611 {
612 char tmp[2];
613 tmp[0] = PORT_DIRECTION;
614 tmp[1] = (char)direction;
615 usbprog_jtag_message(usbprog_jtag,tmp,2);
616 }
617
618 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
619 {
620 char tmp[2];
621 tmp[0] = PORT_SET;
622 tmp[1] = (char)value;
623 usbprog_jtag_message(usbprog_jtag,tmp,2);
624 }
625
626 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
627 {
628 char tmp[2];
629 tmp[0] = PORT_GET;
630 tmp[1] = 0x00;
631 return usbprog_jtag_message(usbprog_jtag,tmp,2);
632 }
633
634
635 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
636 {
637 char tmp[3];
638 tmp[0] = PORT_SETBIT;
639 tmp[1] = (char)bit;
640 if(value==1)
641 tmp[2] = 0x01;
642 else
643 tmp[2] = 0x00;
644 usbprog_jtag_message(usbprog_jtag,tmp,3);
645 }
646
647 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
648 {
649 char tmp[2];
650 tmp[0] = PORT_GETBIT;
651 tmp[1] = (char)bit;
652
653 if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)
654 return 1;
655 else
656 return 0;
657 }
658
659 void usbprog_jtag_tms_collect(char tms_scan){
660 tms_chain[tms_chain_index]=tms_scan;
661 tms_chain_index++;
662 }
663
664 void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag){
665 int i;
666 //INFO("TMS SEND");
667 if(tms_chain_index>0) {
668 char tmp[tms_chain_index+2];
669 tmp[0] = WRITE_TMS_CHAIN;
670 tmp[1] = (char)(tms_chain_index);
671 for(i=0;i<tms_chain_index+1;i++)
672 tmp[2+i] = tms_chain[i];
673 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,tms_chain_index+2,1000);
674 tms_chain_index=0;
675 }
676 }
677
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)