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_UNKNOWN 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
58 /* Not all OSes have this speed defined */
59 #if !defined(B1000000)
60 #define B1000000 0010010
65 MODE_JTAG
= 1, /* push-pull outputs */
66 MODE_JTAG_OD
= 2, /* open-drain outputs */
88 static int buspirate_fd
= -1;
89 static int buspirate_pinmode
= MODE_JTAG_OD
;
90 static int buspirate_baudrate
= SERIAL_NORMAL
;
91 static int buspirate_vreg
;
92 static int buspirate_pullup
;
93 static char *buspirate_port
;
97 static void buspirate_tap_init(void);
98 static int buspirate_tap_execute(void);
99 static void buspirate_tap_append(int tms
, int tdi
);
100 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
101 struct scan_command
*command
);
102 static void buspirate_tap_make_space(int scan
, int bits
);
104 static void buspirate_reset(int trst
, int srst
);
106 /* low level interface */
107 static void buspirate_jtag_reset(int);
108 static void buspirate_jtag_enable(int);
109 static unsigned char buspirate_jtag_command(int, char *, int);
110 static void buspirate_jtag_set_speed(int, char);
111 static void buspirate_jtag_set_mode(int, char);
112 static void buspirate_jtag_set_feature(int, char, char);
113 static void buspirate_jtag_get_adcs(int);
115 /* low level HW communication interface */
116 static int buspirate_serial_open(char *port
);
117 static int buspirate_serial_setspeed(int fd
, char speed
);
118 static int buspirate_serial_write(int fd
, char *buf
, int size
);
119 static int buspirate_serial_read(int fd
, char *buf
, int size
);
120 static void buspirate_serial_close(int fd
);
121 static void buspirate_print_buffer(char *buf
, int size
);
123 static int buspirate_speed(int speed
)
126 LOG_INFO("Want to set speed to %dkHz, but not implemented yet", speed
);
130 static int buspirate_khz(int khz
, int *jtag_speed
)
136 static int buspirate_execute_queue(void)
138 /* currently processed command */
139 struct jtag_command
*cmd
= jtag_command_queue
;
147 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
148 cmd
->cmd
.runtest
->num_cycles
,
149 tap_state_name(cmd
->cmd
.runtest
151 buspirate_end_state(cmd
->cmd
.runtest
153 buspirate_runtest(cmd
->cmd
.runtest
157 DEBUG_JTAG_IO("statemove end in %s",
158 tap_state_name(cmd
->cmd
.statemove
160 buspirate_end_state(cmd
->cmd
.statemove
162 buspirate_state_move();
165 DEBUG_JTAG_IO("pathmove: %i states, end in %s",
166 cmd
->cmd
.pathmove
->num_states
,
167 tap_state_name(cmd
->cmd
.pathmove
168 ->path
[cmd
->cmd
.pathmove
170 buspirate_path_move(cmd
->cmd
.pathmove
172 cmd
->cmd
.pathmove
->path
);
175 DEBUG_JTAG_IO("scan end in %s",
176 tap_state_name(cmd
->cmd
.scan
179 buspirate_end_state(cmd
->cmd
.scan
182 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
,
184 type
= jtag_scan_type(cmd
->cmd
.scan
);
185 buspirate_scan(cmd
->cmd
.scan
->ir_scan
, type
,
186 buffer
, scan_size
, cmd
->cmd
.scan
);
190 DEBUG_JTAG_IO("reset trst: %i srst %i",
191 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
193 /* flush buffers, so we can reset */
194 buspirate_tap_execute();
196 if (cmd
->cmd
.reset
->trst
== 1)
197 tap_set_state(TAP_RESET
);
198 buspirate_reset(cmd
->cmd
.reset
->trst
,
199 cmd
->cmd
.reset
->srst
);
202 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
203 buspirate_tap_execute();
204 jtag_sleep(cmd
->cmd
.sleep
->us
);
207 LOG_ERROR("BUG: unknown JTAG command type encountered");
214 return buspirate_tap_execute();
217 static int buspirate_init(void)
219 if (buspirate_port
== NULL
) {
220 LOG_ERROR("You need to specify the serial port!");
221 return ERROR_JTAG_INIT_FAILED
;
224 buspirate_fd
= buspirate_serial_open(buspirate_port
);
225 if (buspirate_fd
== -1) {
226 LOG_ERROR("Could not open serial port");
227 return ERROR_JTAG_INIT_FAILED
;
230 buspirate_serial_setspeed(buspirate_fd
, SERIAL_NORMAL
);
232 buspirate_jtag_enable(buspirate_fd
);
234 if (buspirate_baudrate
!= SERIAL_NORMAL
)
235 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_FAST
);
237 LOG_INFO("Buspirate Interface ready!");
239 buspirate_tap_init();
240 buspirate_jtag_set_mode(buspirate_fd
, buspirate_pinmode
);
241 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_VREG
,
242 (buspirate_vreg
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
243 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_PULLUP
,
244 (buspirate_pullup
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
245 buspirate_reset(0, 0);
250 static int buspirate_quit(void)
252 LOG_INFO("Shutting down buspirate.");
253 buspirate_jtag_set_mode(buspirate_fd
, MODE_HIZ
);
255 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_NORMAL
);
256 buspirate_jtag_reset(buspirate_fd
);
258 buspirate_serial_close(buspirate_fd
);
260 if (buspirate_port
) {
261 free(buspirate_port
);
262 buspirate_port
= NULL
;
267 /* openocd command interface */
268 COMMAND_HANDLER(buspirate_handle_adc_command
)
270 if (buspirate_fd
== -1)
273 /* send the command */
274 buspirate_jtag_get_adcs(buspirate_fd
);
280 COMMAND_HANDLER(buspirate_handle_vreg_command
)
283 LOG_ERROR("usage: buspirate_vreg <1|0>");
287 if (atoi(CMD_ARGV
[0]) == 1)
289 else if (atoi(CMD_ARGV
[0]) == 0)
292 LOG_ERROR("usage: buspirate_vreg <1|0>");
298 COMMAND_HANDLER(buspirate_handle_pullup_command
)
301 LOG_ERROR("usage: buspirate_pullup <1|0>");
305 if (atoi(CMD_ARGV
[0]) == 1)
306 buspirate_pullup
= 1;
307 else if (atoi(CMD_ARGV
[0]) == 0)
308 buspirate_pullup
= 0;
310 LOG_ERROR("usage: buspirate_pullup <1|0>");
316 COMMAND_HANDLER(buspirate_handle_led_command
)
319 LOG_ERROR("usage: buspirate_led <1|0>");
323 if (atoi(CMD_ARGV
[0]) == 1) {
325 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
327 } else if (atoi(CMD_ARGV
[0]) == 0) {
329 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
332 LOG_ERROR("usage: buspirate_led <1|0>");
339 COMMAND_HANDLER(buspirate_handle_mode_command
)
342 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
346 if (CMD_ARGV
[0][0] == 'n')
347 buspirate_pinmode
= MODE_JTAG
;
348 else if (CMD_ARGV
[0][0] == 'o')
349 buspirate_pinmode
= MODE_JTAG_OD
;
351 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
357 COMMAND_HANDLER(buspirate_handle_speed_command
)
360 LOG_ERROR("usage: buspirate_speed <normal|fast>");
364 if (CMD_ARGV
[0][0] == 'n')
365 buspirate_baudrate
= SERIAL_NORMAL
;
366 else if (CMD_ARGV
[0][0] == 'f')
367 buspirate_baudrate
= SERIAL_FAST
;
369 LOG_ERROR("usage: buspirate_speed <normal|fast>");
375 COMMAND_HANDLER(buspirate_handle_port_command
)
378 LOG_ERROR("usage: buspirate_port /dev/ttyUSB0");
382 if (buspirate_port
== NULL
)
383 buspirate_port
= strdup(CMD_ARGV
[0]);
389 static const struct command_registration buspirate_command_handlers
[] = {
391 .name
= "buspirate_adc",
392 .handler
= &buspirate_handle_adc_command
,
393 .mode
= COMMAND_EXEC
,
394 .help
= "reads voltages on adc pins",
397 .name
= "buspirate_vreg",
398 .handler
= &buspirate_handle_vreg_command
,
399 .mode
= COMMAND_CONFIG
,
400 .help
= "changes the state of voltage regulators",
403 .name
= "buspirate_pullup",
404 .handler
= &buspirate_handle_pullup_command
,
405 .mode
= COMMAND_CONFIG
,
406 .help
= "changes the state of pullup",
409 .name
= "buspirate_led",
410 .handler
= &buspirate_handle_led_command
,
411 .mode
= COMMAND_EXEC
,
412 .help
= "changes the state of led",
415 .name
= "buspirate_speed",
416 .handler
= &buspirate_handle_speed_command
,
417 .mode
= COMMAND_CONFIG
,
418 .help
= "speed of the interface",
421 .name
= "buspirate_mode",
422 .handler
= &buspirate_handle_mode_command
,
423 .mode
= COMMAND_CONFIG
,
424 .help
= "pin mode of the interface",
427 .name
= "buspirate_port",
428 .handler
= &buspirate_handle_port_command
,
429 .mode
= COMMAND_CONFIG
,
430 .help
= "name of the serial port to open",
432 COMMAND_REGISTRATION_DONE
435 struct jtag_interface buspirate_interface
= {
437 .execute_queue
= buspirate_execute_queue
,
438 .speed
= buspirate_speed
,
439 .khz
= buspirate_khz
,
440 .commands
= buspirate_command_handlers
,
441 .init
= buspirate_init
,
442 .quit
= buspirate_quit
445 /*************** jtag execute commands **********************/
446 static void buspirate_end_state(tap_state_t state
)
448 if (tap_is_state_stable(state
))
449 tap_set_end_state(state
);
451 LOG_ERROR("BUG: %i is not a valid end state", state
);
456 static void buspirate_state_move(void)
459 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(),
460 tap_get_end_state());
461 int tms_count
= tap_get_tms_path_len(tap_get_state(),
462 tap_get_end_state());
464 for (i
= 0; i
< tms_count
; i
++) {
465 tms
= (tms_scan
>> i
) & 1;
466 buspirate_tap_append(tms
, 0);
469 tap_set_state(tap_get_end_state());
472 static void buspirate_path_move(int num_states
, tap_state_t
*path
)
476 for (i
= 0; i
< num_states
; i
++) {
477 if (tap_state_transition(tap_get_state(), false) == path
[i
]) {
478 buspirate_tap_append(0, 0);
479 } else if (tap_state_transition(tap_get_state(), true)
481 buspirate_tap_append(1, 0);
483 LOG_ERROR("BUG: %s -> %s isn't a valid "
485 tap_state_name(tap_get_state()),
486 tap_state_name(path
[i
]));
490 tap_set_state(path
[i
]);
493 tap_set_end_state(tap_get_state());
496 static void buspirate_runtest(int num_cycles
)
500 tap_state_t saved_end_state
= tap_get_end_state();
502 /* only do a state_move when we're not already in IDLE */
503 if (tap_get_state() != TAP_IDLE
) {
504 buspirate_end_state(TAP_IDLE
);
505 buspirate_state_move();
508 for (i
= 0; i
< num_cycles
; i
++)
509 buspirate_tap_append(0, 0);
511 DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
512 tap_state_name(tap_get_state()),
513 tap_state_name(tap_get_end_state()));
515 /* finish in end_state */
516 buspirate_end_state(saved_end_state
);
517 if (tap_get_state() != tap_get_end_state())
518 buspirate_state_move();
521 static void buspirate_scan(bool ir_scan
, enum scan_type type
,
522 uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
524 tap_state_t saved_end_state
;
526 buspirate_tap_make_space(1, scan_size
+8);
527 /* is 8 correct ? (2 moves = 16) */
529 saved_end_state
= tap_get_end_state();
531 buspirate_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
532 buspirate_state_move();
534 buspirate_tap_append_scan(scan_size
, buffer
, command
);
537 buspirate_tap_append(0, 0);
539 /* restore the saved state */
540 buspirate_end_state(saved_end_state
);
541 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
543 if (tap_get_state() != tap_get_end_state())
544 buspirate_state_move();
548 /************************* TAP related stuff **********/
550 #define BUSPIRATE_BUFFER_SIZE 1024
551 #define BUSPIRATE_MAX_PENDING_SCANS 32
553 static char tms_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
554 static char tdi_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
555 static int tap_chain_index
;
557 struct pending_scan_result
/* this was stolen from arm-jtag-ew */
559 int first
; /* First bit position in tdo_buffer to read */
560 int length
; /* Number of bits to read */
561 struct scan_command
*command
; /* Corresponding scan command */
565 static struct pending_scan_result
566 tap_pending_scans
[BUSPIRATE_MAX_PENDING_SCANS
];
567 static int tap_pending_scans_num
;
569 static void buspirate_tap_init(void)
572 tap_pending_scans_num
= 0;
575 static int buspirate_tap_execute(void)
584 if (tap_chain_index
<= 0)
587 LOG_DEBUG("executing tap num bits = %i scans = %i",
588 tap_chain_index
, tap_pending_scans_num
);
590 bytes_to_send
= (tap_chain_index
+7) / 8;
592 tmp
[0] = CMD_TAP_SHIFT
; /* this command expects number of bits */
593 tmp
[1] = (char)(tap_chain_index
>> 8); /* high */
594 tmp
[2] = (char)(tap_chain_index
); /* low */
597 for (i
= 0; i
< bytes_to_send
; i
++) {
598 tmp
[fill_index
] = tdi_chain
[i
];
600 tmp
[fill_index
] = tms_chain
[i
];
604 ret
= buspirate_serial_write(buspirate_fd
, tmp
, 3 + bytes_to_send
*2);
605 if (ret
!= bytes_to_send
*2+3) {
606 LOG_ERROR("error writing :(");
607 return ERROR_JTAG_DEVICE_ERROR
;
610 ret
= buspirate_serial_read(buspirate_fd
, tmp
, bytes_to_send
+ 3);
611 in_buf
= (uint8_t *)(&tmp
[3]);
613 /* parse the scans */
614 for (i
= 0; i
< tap_pending_scans_num
; i
++) {
615 uint8_t *buffer
= tap_pending_scans
[i
].buffer
;
616 int length
= tap_pending_scans
[i
].length
;
617 int first
= tap_pending_scans
[i
].first
;
618 struct scan_command
*command
= tap_pending_scans
[i
].command
;
620 /* copy bits from buffer */
621 buf_set_buf(in_buf
, first
, buffer
, 0, length
);
623 /* return buffer to higher level */
624 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
625 buspirate_tap_init();
626 return ERROR_JTAG_QUEUE_FAILED
;
631 tap_pending_scans_num
= 0;
636 static void buspirate_tap_make_space(int scans
, int bits
)
638 int have_scans
= BUSPIRATE_MAX_PENDING_SCANS
- tap_pending_scans_num
;
639 int have_bits
= BUSPIRATE_BUFFER_SIZE
* 8 - tap_chain_index
;
641 if ((have_scans
< scans
) || (have_bits
< bits
))
642 buspirate_tap_execute();
645 static void buspirate_tap_append(int tms
, int tdi
)
649 buspirate_tap_make_space(0, 1);
650 chain_index
= tap_chain_index
/ 8;
652 if (chain_index
< BUSPIRATE_BUFFER_SIZE
) {
653 int bit_index
= tap_chain_index
% 8;
654 uint8_t bit
= 1 << bit_index
;
657 tms_chain
[chain_index
] |= bit
;
659 tms_chain
[chain_index
] &= ~bit
;
662 tdi_chain
[chain_index
] |= bit
;
664 tdi_chain
[chain_index
] &= ~bit
;
668 LOG_ERROR("tap_chain overflow, bad things will happen");
672 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
673 struct scan_command
*command
)
676 tap_pending_scans
[tap_pending_scans_num
].length
= length
;
677 tap_pending_scans
[tap_pending_scans_num
].buffer
= buffer
;
678 tap_pending_scans
[tap_pending_scans_num
].command
= command
;
679 tap_pending_scans
[tap_pending_scans_num
].first
= tap_chain_index
;
681 for (i
= 0; i
< length
; i
++) {
682 int tms
= (i
< length
-1 ? 0 : 1);
683 int tdi
= (buffer
[i
/8] >> (i
%8)) & 1;
684 buspirate_tap_append(tms
, tdi
);
686 tap_pending_scans_num
++;
689 /*************** jtag wrapper functions *********************/
691 /* (1) assert or (0) deassert reset lines */
692 static void buspirate_reset(int trst
, int srst
)
694 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
697 buspirate_jtag_set_feature(buspirate_fd
,
698 FEATURE_TRST
, ACTION_DISABLE
);
700 buspirate_jtag_set_feature(buspirate_fd
,
701 FEATURE_TRST
, ACTION_ENABLE
);
704 buspirate_jtag_set_feature(buspirate_fd
,
705 FEATURE_SRST
, ACTION_DISABLE
);
707 buspirate_jtag_set_feature(buspirate_fd
,
708 FEATURE_SRST
, ACTION_ENABLE
);
711 /*************** jtag lowlevel functions ********************/
712 static void buspirate_jtag_enable(int fd
)
715 char tmp
[21] = { [0 ... 20] = 0x00 };
719 LOG_DEBUG("Entering binary mode");
720 buspirate_serial_write(fd
, tmp
, 20);
723 /* reads 1 to n "BBIO1"s and one "OCD1" */
725 ret
= buspirate_serial_read(fd
, tmp
, 4);
727 LOG_ERROR("Buspirate error. Is binary"
728 "/OpenOCD support enabled?");
731 if (strncmp(tmp
, "BBIO", 4) == 0) {
732 ret
= buspirate_serial_read(fd
, tmp
, 1);
734 LOG_ERROR("Buspirate did not answer correctly! "
735 "Do you have correct firmware?");
739 LOG_ERROR("Unsupported binary protocol");
744 tmp
[0] = CMD_ENTER_OOCD
;
745 ret
= buspirate_serial_write(fd
, tmp
, 1);
747 } else if (strncmp(tmp
, "OCD1", 4) == 0)
750 LOG_ERROR("Buspirate did not answer correctly! "
751 "Do you have correct firmware?");
758 static void buspirate_jtag_reset(int fd
)
763 tmp
[0] = 0x00; /* exit OCD1 mode */
764 buspirate_serial_write(fd
, tmp
, 1);
766 ret
= buspirate_serial_read(fd
, tmp
, 5);
767 if (strncmp(tmp
, "BBIO1", 5) == 0) {
768 tmp
[0] = 0x0F; /* reset BP */
769 buspirate_serial_write(fd
, tmp
, 1);
771 LOG_ERROR("Unable to restart buspirate!");
774 static void buspirate_jtag_set_speed(int fd
, char speed
)
783 tmp
[0] = CMD_UART_SPEED
;
785 buspirate_jtag_command(fd
, tmp
, 2);
787 /* here the adapter changes speed, we need follow */
788 buspirate_serial_setspeed(fd
, speed
);
790 buspirate_serial_write(fd
, ack
, 2);
791 ret
= buspirate_serial_read(fd
, tmp
, 2);
793 LOG_ERROR("Buspirate did not ack speed change");
796 if ((tmp
[0] != CMD_UART_SPEED
) || (tmp
[1] != speed
)) {
797 LOG_ERROR("Buspirate did not reply as expected");
800 LOG_INFO("Buspirate switched to %s mode",
801 (speed
== SERIAL_NORMAL
) ? "normal" : "FAST");
805 static void buspirate_jtag_set_mode(int fd
, char mode
)
808 tmp
[0] = CMD_PORT_MODE
;
810 buspirate_jtag_command(fd
, tmp
, 2);
813 static void buspirate_jtag_set_feature(int fd
, char feat
, char action
)
816 tmp
[0] = CMD_FEATURE
;
817 tmp
[1] = feat
; /* what */
818 tmp
[2] = action
; /* action */
819 buspirate_jtag_command(fd
, tmp
, 3);
822 static void buspirate_jtag_get_adcs(int fd
)
826 tmp
[0] = CMD_READ_ADCS
;
827 buspirate_jtag_command(fd
, (char *)tmp
, 1);
828 a
= tmp
[2] << 8 | tmp
[3];
829 b
= tmp
[4] << 8 | tmp
[5];
830 c
= tmp
[6] << 8 | tmp
[7];
831 d
= tmp
[8] << 8 | tmp
[9];
833 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
835 ((float)a
)/155.1515, ((float)b
)/155.1515,
836 ((float)c
)/155.1515, ((float)d
)/155.1515);
839 static unsigned char buspirate_jtag_command(int fd
,
840 char *cmd
, int cmdlen
)
845 res
= buspirate_serial_write(fd
, cmd
, cmdlen
);
847 if ((cmd
[0] == CMD_UART_SPEED
)
848 || (cmd
[0] == CMD_PORT_MODE
)
849 || (cmd
[0] == CMD_FEATURE
)
850 || (cmd
[0] == CMD_JTAG_SPEED
))
856 len
= 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
864 res
= buspirate_serial_read(fd
, cmd
, len
);
866 return (unsigned char)cmd
[1];
874 /* low level serial port */
875 /* TODO add support for WIN32 and others ! */
876 static int buspirate_serial_open(char *port
)
879 fd
= open(buspirate_port
, O_RDWR
| O_NOCTTY
| O_NDELAY
);
883 static int buspirate_serial_setspeed(int fd
, char speed
)
885 struct termios t_opt
;
886 speed_t baud
= (speed
== SERIAL_FAST
) ? B1000000
: B115200
;
888 /* set the serial port parameters */
889 fcntl(fd
, F_SETFL
, 0);
890 tcgetattr(fd
, &t_opt
);
891 cfsetispeed(&t_opt
, baud
);
892 cfsetospeed(&t_opt
, baud
);
893 t_opt
.c_cflag
|= (CLOCAL
| CREAD
);
894 t_opt
.c_cflag
&= ~PARENB
;
895 t_opt
.c_cflag
&= ~CSTOPB
;
896 t_opt
.c_cflag
&= ~CSIZE
;
897 t_opt
.c_cflag
|= CS8
;
898 t_opt
.c_lflag
&= ~(ICANON
| ECHO
| ECHOE
| ISIG
);
899 t_opt
.c_iflag
&= ~(IXON
| IXOFF
| IXANY
);
900 t_opt
.c_oflag
&= ~OPOST
;
901 t_opt
.c_cc
[VMIN
] = 0;
902 t_opt
.c_cc
[VTIME
] = 10;
903 tcflush(fd
, TCIFLUSH
);
904 tcsetattr(fd
, TCSANOW
, &t_opt
);
909 static int buspirate_serial_write(int fd
, char *buf
, int size
)
913 ret
= write(fd
, buf
, size
);
915 LOG_DEBUG("size = %d ret = %d", size
, ret
);
916 buspirate_print_buffer(buf
, size
);
919 LOG_ERROR("Error sending data");
924 static int buspirate_serial_read(int fd
, char *buf
, int size
)
931 ret
= read(fd
, buf
+len
, size
-len
);
947 LOG_DEBUG("should have read = %d actual size = %d", size
, len
);
948 buspirate_print_buffer(buf
, len
);
951 LOG_ERROR("Error reading data");
956 static void buspirate_serial_close(int fd
)
962 #define BYTES_PER_LINE 16
963 static void buspirate_print_buffer(char *buf
, int size
)
965 char line
[LINE_SIZE
];
970 while (offset
< size
) {
971 snprintf(tmp
, 5, "%02x ", (uint8_t)buf
[offset
]);
976 if (offset
% BYTES_PER_LINE
== 0) {
977 LOG_DEBUG("%s", line
);
983 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)