1 /***************************************************************************
2 * Copyright (C) 2010 by Michal Demin *
3 * based on usbprog.c and arm-jtag-ew.c *
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. *
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. *
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 ***************************************************************************/
25 #include <jtag/interface.h>
26 #include <jtag/commands.h>
30 #include <sys/ioctl.h>
33 /*#define DEBUG_SERIAL */
34 static int buspirate_execute_queue(void);
35 static int buspirate_speed(int speed
);
36 static int buspirate_khz(int khz
, int *jtag_speed
);
37 static int buspirate_init(void);
38 static int buspirate_quit(void);
40 static void buspirate_end_state(tap_state_t state
);
41 static void buspirate_state_move(void);
42 static void buspirate_path_move(int num_states
, tap_state_t
*path
);
43 static void buspirate_runtest(int num_cycles
);
44 static void buspirate_scan(bool ir_scan
, enum scan_type type
,
45 uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
48 #define CMD_UNKOWN 0x00
49 #define CMD_PORT_MODE 0x01
50 #define CMD_FEATURE 0x02
51 #define CMD_READ_ADCS 0x03
52 /*#define CMD_TAP_SHIFT 0x04 // old protocol */
53 #define CMD_TAP_SHIFT 0x05
54 #define CMD_ENTER_OOCD 0x06
55 #define CMD_UART_SPEED 0x07
56 #define CMD_JTAG_SPEED 0x08
60 MODE_JTAG
= 1, /* push-pull outputs */
61 MODE_JTAG_OD
= 2, /* open-drain outputs */
83 static int buspirate_fd
= -1;
84 static int buspirate_pinmode
= MODE_JTAG_OD
;
85 static int buspirate_baudrate
= SERIAL_NORMAL
;
86 static int buspirate_vreg
;
87 static int buspirate_pullup
;
88 static char *buspirate_port
;
92 static void buspirate_tap_init(void);
93 static int buspirate_tap_execute(void);
94 static void buspirate_tap_append(int tms
, int tdi
);
95 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
96 struct scan_command
*command
);
97 static void buspirate_tap_make_space(int scan
, int bits
);
99 static void buspirate_reset(int trst
, int srst
);
101 /* low level interface */
102 static void buspirate_jtag_reset(int);
103 static void buspirate_jtag_enable(int);
104 static unsigned char buspirate_jtag_command(int, char *, int);
105 static void buspirate_jtag_set_speed(int, char);
106 static void buspirate_jtag_set_mode(int, char);
107 static void buspirate_jtag_set_feature(int, char, char);
108 static void buspirate_jtag_get_adcs(int);
110 /* low level HW communication interface */
111 static int buspirate_serial_setspeed(int fd
, speed_t speed
);
112 static int buspirate_serial_write(int fd
, char *buf
, int size
);
113 static int buspirate_serial_read(int fd
, char *buf
, int size
);
114 static void buspirate_print_buffer(char *buf
, int size
);
116 static int buspirate_speed(int speed
)
119 LOG_INFO("Want to set speed to %dkHz, but not implemented yet", speed
);
123 static int buspirate_khz(int khz
, int *jtag_speed
)
129 static int buspirate_execute_queue(void)
131 /* currently processed command */
132 struct jtag_command
*cmd
= jtag_command_queue
;
140 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
141 cmd
->cmd
.runtest
->num_cycles
,
142 tap_state_name(cmd
->cmd
.runtest
144 buspirate_end_state(cmd
->cmd
.runtest
146 buspirate_runtest(cmd
->cmd
.runtest
150 DEBUG_JTAG_IO("statemove end in %s",
151 tap_state_name(cmd
->cmd
.statemove
153 buspirate_end_state(cmd
->cmd
.statemove
155 buspirate_state_move();
158 DEBUG_JTAG_IO("pathmove: %i states, end in %s",
159 cmd
->cmd
.pathmove
->num_states
,
160 tap_state_name(cmd
->cmd
.pathmove
161 ->path
[cmd
->cmd
.pathmove
163 buspirate_path_move(cmd
->cmd
.pathmove
165 cmd
->cmd
.pathmove
->path
);
168 DEBUG_JTAG_IO("scan end in %s",
169 tap_state_name(cmd
->cmd
.scan
172 buspirate_end_state(cmd
->cmd
.scan
175 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
,
177 type
= jtag_scan_type(cmd
->cmd
.scan
);
178 buspirate_scan(cmd
->cmd
.scan
->ir_scan
, type
,
179 buffer
, scan_size
, cmd
->cmd
.scan
);
183 DEBUG_JTAG_IO("reset trst: %i srst %i",
184 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
186 /* flush buffers, so we can reset */
187 buspirate_tap_execute();
189 if (cmd
->cmd
.reset
->trst
== 1)
190 tap_set_state(TAP_RESET
);
191 buspirate_reset(cmd
->cmd
.reset
->trst
,
192 cmd
->cmd
.reset
->srst
);
195 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
196 buspirate_tap_execute();
197 jtag_sleep(cmd
->cmd
.sleep
->us
);
200 LOG_ERROR("BUG: unknown JTAG command type encountered");
207 return buspirate_tap_execute();
210 static int buspirate_init(void)
212 if (buspirate_port
== NULL
) {
213 LOG_ERROR("You need to specify port !");
214 return ERROR_JTAG_INIT_FAILED
;
217 buspirate_fd
= open(buspirate_port
, O_RDWR
| O_NOCTTY
);
218 if (buspirate_fd
== -1) {
219 LOG_ERROR("Could not open serial port.");
220 return ERROR_JTAG_INIT_FAILED
;
223 buspirate_serial_setspeed(buspirate_fd
, B115200
);
225 buspirate_jtag_enable(buspirate_fd
);
227 if (buspirate_baudrate
!= SERIAL_NORMAL
)
228 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_FAST
);
230 LOG_INFO("Buspirate Interface ready!");
232 buspirate_tap_init();
233 buspirate_jtag_set_mode(buspirate_fd
, buspirate_pinmode
);
234 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_VREG
,
235 (buspirate_vreg
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
236 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_PULLUP
,
237 (buspirate_pullup
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
238 buspirate_reset(0, 0);
243 static int buspirate_quit(void)
245 LOG_INFO("Shuting down buspirate ");
246 buspirate_jtag_set_mode(buspirate_fd
, MODE_HIZ
);
248 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_NORMAL
);
249 buspirate_jtag_reset(buspirate_fd
);
250 if (buspirate_port
) {
251 free(buspirate_port
);
252 buspirate_port
= NULL
;
257 /* openocd command interface */
258 COMMAND_HANDLER(buspirate_handle_adc_command
)
261 LOG_ERROR("usage: buspirate_adc");
265 if (buspirate_fd
== -1)
268 /* send the command */
269 buspirate_jtag_get_adcs(buspirate_fd
);
275 COMMAND_HANDLER(buspirate_handle_vreg_command
)
278 LOG_ERROR("usage: buspirate_vreg <1|0>");
282 if (atoi(CMD_ARGV
[0]) == 1)
291 COMMAND_HANDLER(buspirate_handle_pullup_command
)
294 LOG_ERROR("usage: buspirate_pullup <1|0>");
298 if (atoi(CMD_ARGV
[0]) == 1)
299 buspirate_pullup
= 1;
301 buspirate_pullup
= 0;
307 COMMAND_HANDLER(buspirate_handle_led_command
)
310 LOG_ERROR("usage: buspirate_led <1|0>");
314 if (atoi(CMD_ARGV
[0]) == 1) {
316 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
320 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
328 COMMAND_HANDLER(buspirate_handle_mode_command
)
331 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
335 if (CMD_ARGV
[0][0] == 'n')
336 buspirate_pinmode
= MODE_JTAG
;
337 else if (CMD_ARGV
[0][0] == 'o')
338 buspirate_pinmode
= MODE_JTAG_OD
;
340 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
346 COMMAND_HANDLER(buspirate_handle_speed_command
)
349 LOG_ERROR("usage: buspirate_speed <normal|fast>");
353 if (CMD_ARGV
[0][0] == 'n')
354 buspirate_baudrate
= SERIAL_NORMAL
;
355 else if (CMD_ARGV
[0][0] == 'f')
356 buspirate_baudrate
= SERIAL_FAST
;
358 LOG_ERROR("usage: buspirate_speed <normal|fast>");
364 COMMAND_HANDLER(buspirate_handle_port_command
)
367 LOG_ERROR("usage: buspirate_port /dev/ttyUSB0");
371 if (buspirate_port
== 0)
372 buspirate_port
= strdup(CMD_ARGV
[0]);
378 static const struct command_registration buspirate_command_handlers
[] = {
380 .name
= "buspirate_adc",
381 .handler
= &buspirate_handle_adc_command
,
382 .mode
= COMMAND_EXEC
,
383 .help
= "reads voltages on adc pins",
386 .name
= "buspirate_vreg",
387 .handler
= &buspirate_handle_vreg_command
,
388 .mode
= COMMAND_CONFIG
,
389 .help
= "changes the state of voltage regulators",
392 .name
= "buspirate_pullup",
393 .handler
= &buspirate_handle_pullup_command
,
394 .mode
= COMMAND_CONFIG
,
395 .help
= "changes the state of pullup",
398 .name
= "buspirate_led",
399 .handler
= &buspirate_handle_led_command
,
400 .mode
= COMMAND_EXEC
,
401 .help
= "changes the state of led",
404 .name
= "buspirate_speed",
405 .handler
= &buspirate_handle_speed_command
,
406 .mode
= COMMAND_CONFIG
,
407 .help
= "speed of the interface",
410 .name
= "buspirate_mode",
411 .handler
= &buspirate_handle_mode_command
,
412 .mode
= COMMAND_CONFIG
,
413 .help
= "pin mode of the interface",
416 .name
= "buspirate_port",
417 .handler
= &buspirate_handle_port_command
,
418 .mode
= COMMAND_CONFIG
,
419 .help
= "name of the serial port to open",
421 COMMAND_REGISTRATION_DONE
424 struct jtag_interface buspirate_interface
= {
426 .execute_queue
= buspirate_execute_queue
,
427 .speed
= buspirate_speed
,
428 .khz
= buspirate_khz
,
429 .commands
= buspirate_command_handlers
,
430 .init
= buspirate_init
,
431 .quit
= buspirate_quit
434 /*************** jtag execute commands **********************/
435 static void buspirate_end_state(tap_state_t state
)
437 if (tap_is_state_stable(state
))
438 tap_set_end_state(state
);
440 LOG_ERROR("BUG: %i is not a valid end state", state
);
445 static void buspirate_state_move(void)
448 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(),
449 tap_get_end_state());
450 int tms_count
= tap_get_tms_path_len(tap_get_state(),
451 tap_get_end_state());
453 for (i
= 0; i
< tms_count
; i
++) {
454 tms
= (tms_scan
>> i
) & 1;
455 buspirate_tap_append(tms
, 0);
458 tap_set_state(tap_get_end_state());
461 static void buspirate_path_move(int num_states
, tap_state_t
*path
)
465 for (i
= 0; i
< num_states
; i
++) {
466 if (tap_state_transition(tap_get_state(), false) == path
[i
]) {
467 buspirate_tap_append(0, 0);
468 } else if (tap_state_transition(tap_get_state(), true)
470 buspirate_tap_append(1, 0);
472 LOG_ERROR("BUG: %s -> %s isn't a valid "
474 tap_state_name(tap_get_state()),
475 tap_state_name(path
[i
]));
479 tap_set_state(path
[i
]);
482 tap_set_end_state(tap_get_state());
485 static void buspirate_runtest(int num_cycles
)
489 tap_state_t saved_end_state
= tap_get_end_state();
491 /* only do a state_move when we're not already in IDLE */
492 if (tap_get_state() != TAP_IDLE
) {
493 buspirate_end_state(TAP_IDLE
);
494 buspirate_state_move();
497 for (i
= 0; i
< num_cycles
; i
++)
498 buspirate_tap_append(0, 0);
500 DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
501 tap_state_name(tap_get_state()),
502 tap_state_name(tap_get_end_state()));
504 /* finish in end_state */
505 buspirate_end_state(saved_end_state
);
506 if (tap_get_state() != tap_get_end_state())
507 buspirate_state_move();
510 static void buspirate_scan(bool ir_scan
, enum scan_type type
,
511 uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
513 tap_state_t saved_end_state
;
515 buspirate_tap_make_space(1, scan_size
+8);
516 /* is 8 correct ? (2 moves = 16) */
518 saved_end_state
= tap_get_end_state();
520 buspirate_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
521 buspirate_state_move();
523 buspirate_tap_append_scan(scan_size
, buffer
, command
);
526 buspirate_tap_append(0, 0);
528 /* restore the saved state */
529 buspirate_end_state(saved_end_state
);
530 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
532 if (tap_get_state() != tap_get_end_state())
533 buspirate_state_move();
537 /************************* TAP related stuff **********/
539 #define BUSPIRATE_BUFFER_SIZE 1024
540 #define BUSPIRATE_MAX_PENDING_SCANS 32
542 static char tms_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
543 static char tdi_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
544 static int tap_chain_index
;
546 struct pending_scan_result
/* this was stolen from arm-jtag-ew */
548 int first
; /* First bit position in tdo_buffer to read */
549 int length
; /* Number of bits to read */
550 struct scan_command
*command
; /* Corresponding scan command */
554 static struct pending_scan_result
555 tap_pending_scans
[BUSPIRATE_MAX_PENDING_SCANS
];
556 static int tap_pending_scans_num
;
558 static void buspirate_tap_init(void)
561 tap_pending_scans_num
= 0;
564 static int buspirate_tap_execute(void)
573 if (tap_chain_index
<= 0)
576 LOG_DEBUG("executing tap num bits = %i scans = %i",
577 tap_chain_index
, tap_pending_scans_num
);
579 bytes_to_send
= (tap_chain_index
+7) / 8;
581 tmp
[0] = CMD_TAP_SHIFT
; /* this command expects number of bits */
582 tmp
[1] = (char)(tap_chain_index
>> 8); /* high */
583 tmp
[2] = (char)(tap_chain_index
); /* low */
586 for (i
= 0; i
< bytes_to_send
; i
++) {
587 tmp
[fill_index
] = tdi_chain
[i
];
589 tmp
[fill_index
] = tms_chain
[i
];
593 ret
= buspirate_serial_write(buspirate_fd
, tmp
, 3 + bytes_to_send
*2);
594 if (ret
!= bytes_to_send
*2+3) {
595 LOG_ERROR("error writing :(");
596 return ERROR_JTAG_DEVICE_ERROR
;
599 ret
= buspirate_serial_read(buspirate_fd
, tmp
, bytes_to_send
+ 3);
600 in_buf
= (uint8_t *)(&tmp
[3]);
602 /* parse the scans */
603 for (i
= 0; i
< tap_pending_scans_num
; i
++) {
604 uint8_t *buffer
= tap_pending_scans
[i
].buffer
;
605 int length
= tap_pending_scans
[i
].length
;
606 int first
= tap_pending_scans
[i
].first
;
607 struct scan_command
*command
= tap_pending_scans
[i
].command
;
609 /* copy bits from buffer */
610 buf_set_buf(in_buf
, first
, buffer
, 0, length
);
612 /* return buffer to higher level */
613 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
614 buspirate_tap_init();
615 return ERROR_JTAG_QUEUE_FAILED
;
620 tap_pending_scans_num
= 0;
625 static void buspirate_tap_make_space(int scans
, int bits
)
627 int have_scans
= BUSPIRATE_MAX_PENDING_SCANS
- tap_pending_scans_num
;
628 int have_bits
= BUSPIRATE_BUFFER_SIZE
* 8 - tap_chain_index
;
630 if ((have_scans
< scans
) || (have_bits
< bits
))
631 buspirate_tap_execute();
634 static void buspirate_tap_append(int tms
, int tdi
)
638 buspirate_tap_make_space(0, 1);
639 index
= tap_chain_index
/ 8;
641 if (index
< BUSPIRATE_BUFFER_SIZE
) {
642 int bit_index
= tap_chain_index
% 8;
643 uint8_t bit
= 1 << bit_index
;
646 tms_chain
[index
] |= bit
;
648 tms_chain
[index
] &= ~bit
;
651 tdi_chain
[index
] |= bit
;
653 tdi_chain
[index
] &= ~bit
;
657 LOG_ERROR("tap_chain overflow, Bad things will happen");
661 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
662 struct scan_command
*command
)
665 tap_pending_scans
[tap_pending_scans_num
].length
= length
;
666 tap_pending_scans
[tap_pending_scans_num
].buffer
= buffer
;
667 tap_pending_scans
[tap_pending_scans_num
].command
= command
;
668 tap_pending_scans
[tap_pending_scans_num
].first
= tap_chain_index
;
670 for (i
= 0; i
< length
; i
++) {
671 int tms
= (i
< length
-1 ? 0 : 1);
672 int tdi
= (buffer
[i
/8] >> (i
%8)) & 1;
673 buspirate_tap_append(tms
, tdi
);
675 tap_pending_scans_num
++;
678 /*************** jtag wrapper functions *********************/
680 /* (1) assert or (0) deassert reset lines */
681 static void buspirate_reset(int trst
, int srst
)
683 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
686 buspirate_jtag_set_feature(buspirate_fd
,
687 FEATURE_TRST
, ACTION_DISABLE
);
689 buspirate_jtag_set_feature(buspirate_fd
,
690 FEATURE_TRST
, ACTION_ENABLE
);
693 buspirate_jtag_set_feature(buspirate_fd
,
694 FEATURE_SRST
, ACTION_DISABLE
);
696 buspirate_jtag_set_feature(buspirate_fd
,
697 FEATURE_SRST
, ACTION_ENABLE
);
700 /*************** jtag lowlevel functions ********************/
701 static void buspirate_jtag_enable(int fd
)
704 char tmp
[21] = { [0 ... 20] = 0x00 };
708 LOG_DEBUG("Entering binary mode");
709 buspirate_serial_write(fd
, tmp
, 20);
712 /* reads 1 to n "BBIO1"s and one "OCD1" */
714 ret
= buspirate_serial_read(fd
, tmp
, 4);
716 LOG_ERROR("Buspirate did not respond :"
717 "( restart everything");
721 if (strncmp(tmp
, "BBIO", 4) == 0) {
722 ret
= buspirate_serial_read(fd
, tmp
, 1);
724 LOG_ERROR("Buspirate did not respond well :"
725 "( restart everything");
729 LOG_ERROR("Unsupported binary protocol ");
734 tmp
[0] = CMD_ENTER_OOCD
;
735 ret
= buspirate_serial_write(fd
, tmp
, 1);
737 } else if (strncmp(tmp
, "OCD1", 4) == 0)
740 LOG_ERROR("Buspirate did not respond :"
741 "( restart everything");
748 static void buspirate_jtag_reset(int fd
)
753 tmp
[0] = 0x00; /* exit OCD1 mode */
754 buspirate_serial_write(fd
, tmp
, 1);
756 ret
= buspirate_serial_read(fd
, tmp
, 5);
757 if (strncmp(tmp
, "BBIO1", 5) == 0) {
758 tmp
[0] = 0x0F; /* reset BP */
759 buspirate_serial_write(fd
, tmp
, 1);
761 LOG_ERROR("Bad reply :( Please restart manually");
764 static void buspirate_jtag_set_speed(int fd
, char speed
)
769 speed_t baudrate
= B115200
;
774 tmp
[0] = CMD_UART_SPEED
;
776 buspirate_jtag_command(fd
, tmp
, 2);
778 /* here the adapter changes speed, we need follow */
779 if (speed
== SERIAL_FAST
)
782 buspirate_serial_setspeed(fd
, baudrate
);
784 buspirate_serial_write(fd
, ack
, 2);
785 ret
= buspirate_serial_read(fd
, tmp
, 2);
787 LOG_ERROR("Buspirate did not respond :"
788 "( restart everything");
791 if ((tmp
[0] != CMD_UART_SPEED
) || (tmp
[1] != speed
)) {
792 LOG_ERROR("Buspirate didn't reply as expected :"
793 "( restart everything");
796 LOG_INFO("Buspirate switched to %s mode",
797 (speed
== SERIAL_NORMAL
) ? "normal" : "FAST");
801 static void buspirate_jtag_set_mode(int fd
, char mode
)
804 tmp
[0] = CMD_PORT_MODE
;
806 buspirate_jtag_command(fd
, tmp
, 2);
809 static void buspirate_jtag_set_feature(int fd
, char feat
, char action
)
812 tmp
[0] = CMD_FEATURE
;
813 tmp
[1] = feat
; /* what */
814 tmp
[2] = action
; /* action */
815 buspirate_jtag_command(fd
, tmp
, 3);
818 static void buspirate_jtag_get_adcs(int fd
)
822 tmp
[0] = CMD_READ_ADCS
;
823 buspirate_jtag_command(fd
, (char *)tmp
, 1);
824 a
= tmp
[2] << 8 | tmp
[3];
825 b
= tmp
[4] << 8 | tmp
[5];
826 c
= tmp
[6] << 8 | tmp
[7];
827 d
= tmp
[8] << 8 | tmp
[9];
829 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
831 ((float)a
)/155.1515, ((float)b
)/155.1515,
832 ((float)c
)/155.1515, ((float)d
)/155.1515);
835 static unsigned char buspirate_jtag_command(int buspirate_fd
,
836 char *cmd
, int cmdlen
)
841 res
= buspirate_serial_write(buspirate_fd
, cmd
, cmdlen
);
843 if ((cmd
[0] == CMD_UART_SPEED
)
844 || (cmd
[0] == CMD_PORT_MODE
)
845 || (cmd
[0] == CMD_FEATURE
)
846 || (cmd
[0] == CMD_JTAG_SPEED
))
852 len
= 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
860 res
= buspirate_serial_read(buspirate_fd
, cmd
, len
);
862 return (unsigned char)cmd
[1];
870 /* low level serial port */
871 /* TODO add support for WIN32 and others ! */
872 static int buspirate_serial_setspeed(int fd
, speed_t speed
)
874 struct termios t_opt
;
876 /* set the serial port parameters */
877 fcntl(buspirate_fd
, F_SETFL
, 0);
878 tcgetattr(buspirate_fd
, &t_opt
);
879 cfsetispeed(&t_opt
, speed
);
880 cfsetospeed(&t_opt
, speed
);
881 t_opt
.c_cflag
|= (CLOCAL
| CREAD
);
882 t_opt
.c_cflag
&= ~PARENB
;
883 t_opt
.c_cflag
&= ~CSTOPB
;
884 t_opt
.c_cflag
&= ~CSIZE
;
885 t_opt
.c_cflag
|= CS8
;
886 t_opt
.c_lflag
&= ~(ICANON
| ECHO
| ECHOE
| ISIG
);
887 t_opt
.c_iflag
&= ~(IXON
| IXOFF
| IXANY
);
888 t_opt
.c_oflag
&= ~OPOST
;
889 t_opt
.c_cc
[VMIN
] = 0;
890 t_opt
.c_cc
[VTIME
] = 10;
891 tcflush(buspirate_fd
, TCIFLUSH
);
892 tcsetattr(buspirate_fd
, TCSANOW
, &t_opt
);
897 static int buspirate_serial_write(int fd
, char *buf
, int size
)
901 ret
= write(fd
, buf
, size
);
903 LOG_DEBUG("size = %d ret = %d", size
, ret
);
904 buspirate_print_buffer(buf
, size
);
907 LOG_ERROR("Error sending data");
912 static int buspirate_serial_read(int fd
, char *buf
, int size
)
919 ret
= read(fd
, buf
+len
, size
-len
);
935 LOG_DEBUG("should have read = %d actual size = %d", size
, len
);
936 buspirate_print_buffer(buf
, len
);
939 LOG_ERROR("Error sending data");
945 #define BYTES_PER_LINE 16
946 static void buspirate_print_buffer(char *buf
, int size
)
948 char line
[LINE_SIZE
];
953 while (offset
< size
) {
954 snprintf(tmp
, 5, "%02x ", (uint8_t)buf
[offset
]);
959 if (offset
% BYTES_PER_LINE
== 0) {
960 LOG_DEBUG("%s", line
);
966 LOG_DEBUG("%s", line
);
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)