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 if (ret
!= bytes_to_send
+ 3) {
612 LOG_ERROR("error reading");
615 in_buf
= (uint8_t *)(&tmp
[3]);
617 /* parse the scans */
618 for (i
= 0; i
< tap_pending_scans_num
; i
++) {
619 uint8_t *buffer
= tap_pending_scans
[i
].buffer
;
620 int length
= tap_pending_scans
[i
].length
;
621 int first
= tap_pending_scans
[i
].first
;
622 struct scan_command
*command
= tap_pending_scans
[i
].command
;
624 /* copy bits from buffer */
625 buf_set_buf(in_buf
, first
, buffer
, 0, length
);
627 /* return buffer to higher level */
628 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
629 buspirate_tap_init();
630 return ERROR_JTAG_QUEUE_FAILED
;
635 tap_pending_scans_num
= 0;
640 static void buspirate_tap_make_space(int scans
, int bits
)
642 int have_scans
= BUSPIRATE_MAX_PENDING_SCANS
- tap_pending_scans_num
;
643 int have_bits
= BUSPIRATE_BUFFER_SIZE
* 8 - tap_chain_index
;
645 if ((have_scans
< scans
) || (have_bits
< bits
))
646 buspirate_tap_execute();
649 static void buspirate_tap_append(int tms
, int tdi
)
653 buspirate_tap_make_space(0, 1);
654 chain_index
= tap_chain_index
/ 8;
656 if (chain_index
< BUSPIRATE_BUFFER_SIZE
) {
657 int bit_index
= tap_chain_index
% 8;
658 uint8_t bit
= 1 << bit_index
;
661 tms_chain
[chain_index
] |= bit
;
663 tms_chain
[chain_index
] &= ~bit
;
666 tdi_chain
[chain_index
] |= bit
;
668 tdi_chain
[chain_index
] &= ~bit
;
672 LOG_ERROR("tap_chain overflow, bad things will happen");
676 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
677 struct scan_command
*command
)
680 tap_pending_scans
[tap_pending_scans_num
].length
= length
;
681 tap_pending_scans
[tap_pending_scans_num
].buffer
= buffer
;
682 tap_pending_scans
[tap_pending_scans_num
].command
= command
;
683 tap_pending_scans
[tap_pending_scans_num
].first
= tap_chain_index
;
685 for (i
= 0; i
< length
; i
++) {
686 int tms
= (i
< length
-1 ? 0 : 1);
687 int tdi
= (buffer
[i
/8] >> (i
%8)) & 1;
688 buspirate_tap_append(tms
, tdi
);
690 tap_pending_scans_num
++;
693 /*************** jtag wrapper functions *********************/
695 /* (1) assert or (0) deassert reset lines */
696 static void buspirate_reset(int trst
, int srst
)
698 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
701 buspirate_jtag_set_feature(buspirate_fd
,
702 FEATURE_TRST
, ACTION_DISABLE
);
704 buspirate_jtag_set_feature(buspirate_fd
,
705 FEATURE_TRST
, ACTION_ENABLE
);
708 buspirate_jtag_set_feature(buspirate_fd
,
709 FEATURE_SRST
, ACTION_DISABLE
);
711 buspirate_jtag_set_feature(buspirate_fd
,
712 FEATURE_SRST
, ACTION_ENABLE
);
715 /*************** jtag lowlevel functions ********************/
716 static void buspirate_jtag_enable(int fd
)
719 char tmp
[21] = { [0 ... 20] = 0x00 };
723 LOG_DEBUG("Entering binary mode");
724 buspirate_serial_write(fd
, tmp
, 20);
727 /* reads 1 to n "BBIO1"s and one "OCD1" */
729 ret
= buspirate_serial_read(fd
, tmp
, 4);
731 LOG_ERROR("Buspirate error. Is binary"
732 "/OpenOCD support enabled?");
735 if (strncmp(tmp
, "BBIO", 4) == 0) {
736 ret
= buspirate_serial_read(fd
, tmp
, 1);
738 LOG_ERROR("Buspirate did not answer correctly! "
739 "Do you have correct firmware?");
743 LOG_ERROR("Unsupported binary protocol");
748 tmp
[0] = CMD_ENTER_OOCD
;
749 ret
= buspirate_serial_write(fd
, tmp
, 1);
751 LOG_ERROR("error reading");
755 } else if (strncmp(tmp
, "OCD1", 4) == 0)
758 LOG_ERROR("Buspirate did not answer correctly! "
759 "Do you have correct firmware?");
766 static void buspirate_jtag_reset(int fd
)
770 tmp
[0] = 0x00; /* exit OCD1 mode */
771 buspirate_serial_write(fd
, tmp
, 1);
773 /* We ignore the return value here purposly, nothing we can do */
774 buspirate_serial_read(fd
, tmp
, 5);
775 if (strncmp(tmp
, "BBIO1", 5) == 0) {
776 tmp
[0] = 0x0F; /* reset BP */
777 buspirate_serial_write(fd
, tmp
, 1);
779 LOG_ERROR("Unable to restart buspirate!");
782 static void buspirate_jtag_set_speed(int fd
, char speed
)
791 tmp
[0] = CMD_UART_SPEED
;
793 buspirate_jtag_command(fd
, tmp
, 2);
795 /* here the adapter changes speed, we need follow */
796 buspirate_serial_setspeed(fd
, speed
);
798 buspirate_serial_write(fd
, ack
, 2);
799 ret
= buspirate_serial_read(fd
, tmp
, 2);
801 LOG_ERROR("Buspirate did not ack speed change");
804 if ((tmp
[0] != CMD_UART_SPEED
) || (tmp
[1] != speed
)) {
805 LOG_ERROR("Buspirate did not reply as expected");
808 LOG_INFO("Buspirate switched to %s mode",
809 (speed
== SERIAL_NORMAL
) ? "normal" : "FAST");
813 static void buspirate_jtag_set_mode(int fd
, char mode
)
816 tmp
[0] = CMD_PORT_MODE
;
818 buspirate_jtag_command(fd
, tmp
, 2);
821 static void buspirate_jtag_set_feature(int fd
, char feat
, char action
)
824 tmp
[0] = CMD_FEATURE
;
825 tmp
[1] = feat
; /* what */
826 tmp
[2] = action
; /* action */
827 buspirate_jtag_command(fd
, tmp
, 3);
830 static void buspirate_jtag_get_adcs(int fd
)
834 tmp
[0] = CMD_READ_ADCS
;
835 buspirate_jtag_command(fd
, (char *)tmp
, 1);
836 a
= tmp
[2] << 8 | tmp
[3];
837 b
= tmp
[4] << 8 | tmp
[5];
838 c
= tmp
[6] << 8 | tmp
[7];
839 d
= tmp
[8] << 8 | tmp
[9];
841 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
843 ((float)a
)/155.1515, ((float)b
)/155.1515,
844 ((float)c
)/155.1515, ((float)d
)/155.1515);
847 static unsigned char buspirate_jtag_command(int fd
,
848 char *cmd
, int cmdlen
)
853 res
= buspirate_serial_write(fd
, cmd
, cmdlen
);
855 if ((cmd
[0] == CMD_UART_SPEED
)
856 || (cmd
[0] == CMD_PORT_MODE
)
857 || (cmd
[0] == CMD_FEATURE
)
858 || (cmd
[0] == CMD_JTAG_SPEED
))
864 len
= 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
872 res
= buspirate_serial_read(fd
, cmd
, len
);
874 return (unsigned char)cmd
[1];
882 /* low level serial port */
883 /* TODO add support for WIN32 and others ! */
884 static int buspirate_serial_open(char *port
)
887 fd
= open(buspirate_port
, O_RDWR
| O_NOCTTY
| O_NDELAY
);
891 static int buspirate_serial_setspeed(int fd
, char speed
)
893 struct termios t_opt
;
894 speed_t baud
= (speed
== SERIAL_FAST
) ? B1000000
: B115200
;
896 /* set the serial port parameters */
897 fcntl(fd
, F_SETFL
, 0);
898 tcgetattr(fd
, &t_opt
);
899 cfsetispeed(&t_opt
, baud
);
900 cfsetospeed(&t_opt
, baud
);
901 t_opt
.c_cflag
|= (CLOCAL
| CREAD
);
902 t_opt
.c_cflag
&= ~PARENB
;
903 t_opt
.c_cflag
&= ~CSTOPB
;
904 t_opt
.c_cflag
&= ~CSIZE
;
905 t_opt
.c_cflag
|= CS8
;
906 t_opt
.c_lflag
&= ~(ICANON
| ECHO
| ECHOE
| ISIG
);
907 t_opt
.c_iflag
&= ~(IXON
| IXOFF
| IXANY
);
908 t_opt
.c_oflag
&= ~OPOST
;
909 t_opt
.c_cc
[VMIN
] = 0;
910 t_opt
.c_cc
[VTIME
] = 10;
911 tcflush(fd
, TCIFLUSH
);
912 tcsetattr(fd
, TCSANOW
, &t_opt
);
917 static int buspirate_serial_write(int fd
, char *buf
, int size
)
921 ret
= write(fd
, buf
, size
);
923 LOG_DEBUG("size = %d ret = %d", size
, ret
);
924 buspirate_print_buffer(buf
, size
);
927 LOG_ERROR("Error sending data");
932 static int buspirate_serial_read(int fd
, char *buf
, int size
)
939 ret
= read(fd
, buf
+len
, size
-len
);
955 LOG_DEBUG("should have read = %d actual size = %d", size
, len
);
956 buspirate_print_buffer(buf
, len
);
959 LOG_ERROR("Error reading data");
964 static void buspirate_serial_close(int fd
)
970 #define BYTES_PER_LINE 16
971 static void buspirate_print_buffer(char *buf
, int size
)
973 char line
[LINE_SIZE
];
978 while (offset
< size
) {
979 snprintf(tmp
, 5, "%02x ", (uint8_t)buf
[offset
]);
984 if (offset
% BYTES_PER_LINE
== 0) {
985 LOG_DEBUG("%s", line
);
991 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)