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
);
47 #define CMD_UNKNOWN 0x00
48 #define CMD_PORT_MODE 0x01
49 #define CMD_FEATURE 0x02
50 #define CMD_READ_ADCS 0x03
51 /*#define CMD_TAP_SHIFT 0x04 // old protocol */
52 #define CMD_TAP_SHIFT 0x05
53 #define CMD_ENTER_OOCD 0x06
54 #define CMD_UART_SPEED 0x07
55 #define CMD_JTAG_SPEED 0x08
57 /* Not all OSes have this speed defined */
58 #if !defined(B1000000)
59 #define B1000000 0010010
64 MODE_JTAG
= 1, /* push-pull outputs */
65 MODE_JTAG_OD
= 2, /* open-drain outputs */
86 static int buspirate_fd
= -1;
87 static int buspirate_pinmode
= MODE_JTAG_OD
;
88 static int buspirate_baudrate
= SERIAL_NORMAL
;
89 static int buspirate_vreg
;
90 static int buspirate_pullup
;
91 static char *buspirate_port
;
94 static void buspirate_tap_init(void);
95 static int buspirate_tap_execute(void);
96 static void buspirate_tap_append(int tms
, int tdi
);
97 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
98 struct scan_command
*command
);
99 static void buspirate_tap_make_space(int scan
, int bits
);
101 static void buspirate_reset(int trst
, int srst
);
103 /* low level interface */
104 static void buspirate_jtag_reset(int);
105 static void buspirate_jtag_enable(int);
106 static unsigned char buspirate_jtag_command(int, char *, int);
107 static void buspirate_jtag_set_speed(int, char);
108 static void buspirate_jtag_set_mode(int, char);
109 static void buspirate_jtag_set_feature(int, char, char);
110 static void buspirate_jtag_get_adcs(int);
112 /* low level HW communication interface */
113 static int buspirate_serial_open(char *port
);
114 static int buspirate_serial_setspeed(int fd
, char speed
);
115 static int buspirate_serial_write(int fd
, char *buf
, int size
);
116 static int buspirate_serial_read(int fd
, char *buf
, int size
);
117 static void buspirate_serial_close(int fd
);
118 static void buspirate_print_buffer(char *buf
, int size
);
120 static int buspirate_speed(int speed
)
123 LOG_INFO("Want to set speed to %dkHz, but not implemented yet", speed
);
127 static int buspirate_khz(int khz
, int *jtag_speed
)
133 static int buspirate_execute_queue(void)
135 /* currently processed command */
136 struct jtag_command
*cmd
= jtag_command_queue
;
144 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
145 cmd
->cmd
.runtest
->num_cycles
,
146 tap_state_name(cmd
->cmd
.runtest
148 buspirate_end_state(cmd
->cmd
.runtest
150 buspirate_runtest(cmd
->cmd
.runtest
154 DEBUG_JTAG_IO("statemove end in %s",
155 tap_state_name(cmd
->cmd
.statemove
157 buspirate_end_state(cmd
->cmd
.statemove
159 buspirate_state_move();
162 DEBUG_JTAG_IO("pathmove: %i states, end in %s",
163 cmd
->cmd
.pathmove
->num_states
,
164 tap_state_name(cmd
->cmd
.pathmove
165 ->path
[cmd
->cmd
.pathmove
167 buspirate_path_move(cmd
->cmd
.pathmove
169 cmd
->cmd
.pathmove
->path
);
172 DEBUG_JTAG_IO("scan end in %s",
173 tap_state_name(cmd
->cmd
.scan
176 buspirate_end_state(cmd
->cmd
.scan
179 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
,
181 type
= jtag_scan_type(cmd
->cmd
.scan
);
182 buspirate_scan(cmd
->cmd
.scan
->ir_scan
, type
,
183 buffer
, scan_size
, cmd
->cmd
.scan
);
187 DEBUG_JTAG_IO("reset trst: %i srst %i",
188 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
190 /* flush buffers, so we can reset */
191 buspirate_tap_execute();
193 if (cmd
->cmd
.reset
->trst
== 1)
194 tap_set_state(TAP_RESET
);
195 buspirate_reset(cmd
->cmd
.reset
->trst
,
196 cmd
->cmd
.reset
->srst
);
199 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
200 buspirate_tap_execute();
201 jtag_sleep(cmd
->cmd
.sleep
->us
);
204 LOG_ERROR("BUG: unknown JTAG command type encountered");
211 return buspirate_tap_execute();
214 static int buspirate_init(void)
216 if (buspirate_port
== NULL
) {
217 LOG_ERROR("You need to specify the serial port!");
218 return ERROR_JTAG_INIT_FAILED
;
221 buspirate_fd
= buspirate_serial_open(buspirate_port
);
222 if (buspirate_fd
== -1) {
223 LOG_ERROR("Could not open serial port");
224 return ERROR_JTAG_INIT_FAILED
;
227 buspirate_serial_setspeed(buspirate_fd
, SERIAL_NORMAL
);
229 buspirate_jtag_enable(buspirate_fd
);
231 if (buspirate_baudrate
!= SERIAL_NORMAL
)
232 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_FAST
);
234 LOG_INFO("Buspirate Interface ready!");
236 buspirate_tap_init();
237 buspirate_jtag_set_mode(buspirate_fd
, buspirate_pinmode
);
238 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_VREG
,
239 (buspirate_vreg
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
240 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_PULLUP
,
241 (buspirate_pullup
== 1) ? ACTION_ENABLE
: ACTION_DISABLE
);
242 buspirate_reset(0, 0);
247 static int buspirate_quit(void)
249 LOG_INFO("Shutting down buspirate.");
250 buspirate_jtag_set_mode(buspirate_fd
, MODE_HIZ
);
252 buspirate_jtag_set_speed(buspirate_fd
, SERIAL_NORMAL
);
253 buspirate_jtag_reset(buspirate_fd
);
255 buspirate_serial_close(buspirate_fd
);
257 if (buspirate_port
) {
258 free(buspirate_port
);
259 buspirate_port
= NULL
;
264 /* openocd command interface */
265 COMMAND_HANDLER(buspirate_handle_adc_command
)
267 if (buspirate_fd
== -1)
270 /* send the command */
271 buspirate_jtag_get_adcs(buspirate_fd
);
277 COMMAND_HANDLER(buspirate_handle_vreg_command
)
280 return ERROR_COMMAND_SYNTAX_ERROR
;
282 if (atoi(CMD_ARGV
[0]) == 1)
284 else if (atoi(CMD_ARGV
[0]) == 0)
287 LOG_ERROR("usage: buspirate_vreg <1|0>");
293 COMMAND_HANDLER(buspirate_handle_pullup_command
)
296 return ERROR_COMMAND_SYNTAX_ERROR
;
298 if (atoi(CMD_ARGV
[0]) == 1)
299 buspirate_pullup
= 1;
300 else if (atoi(CMD_ARGV
[0]) == 0)
301 buspirate_pullup
= 0;
303 LOG_ERROR("usage: buspirate_pullup <1|0>");
309 COMMAND_HANDLER(buspirate_handle_led_command
)
312 return ERROR_COMMAND_SYNTAX_ERROR
;
314 if (atoi(CMD_ARGV
[0]) == 1) {
316 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
318 } else if (atoi(CMD_ARGV
[0]) == 0) {
320 buspirate_jtag_set_feature(buspirate_fd
, FEATURE_LED
,
323 LOG_ERROR("usage: buspirate_led <1|0>");
330 COMMAND_HANDLER(buspirate_handle_mode_command
)
333 return ERROR_COMMAND_SYNTAX_ERROR
;
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 return ERROR_COMMAND_SYNTAX_ERROR
;
351 if (CMD_ARGV
[0][0] == 'n')
352 buspirate_baudrate
= SERIAL_NORMAL
;
353 else if (CMD_ARGV
[0][0] == 'f')
354 buspirate_baudrate
= SERIAL_FAST
;
356 LOG_ERROR("usage: buspirate_speed <normal|fast>");
362 COMMAND_HANDLER(buspirate_handle_port_command
)
365 return ERROR_COMMAND_SYNTAX_ERROR
;
367 if (buspirate_port
== NULL
)
368 buspirate_port
= strdup(CMD_ARGV
[0]);
374 static const struct command_registration buspirate_command_handlers
[] = {
376 .name
= "buspirate_adc",
377 .handler
= &buspirate_handle_adc_command
,
378 .mode
= COMMAND_EXEC
,
379 .help
= "reads voltages on adc pins",
382 .name
= "buspirate_vreg",
384 .handler
= &buspirate_handle_vreg_command
,
385 .mode
= COMMAND_CONFIG
,
386 .help
= "changes the state of voltage regulators",
389 .name
= "buspirate_pullup",
391 .handler
= &buspirate_handle_pullup_command
,
392 .mode
= COMMAND_CONFIG
,
393 .help
= "changes the state of pullup",
396 .name
= "buspirate_led",
398 .handler
= &buspirate_handle_led_command
,
399 .mode
= COMMAND_EXEC
,
400 .help
= "changes the state of led",
403 .name
= "buspirate_speed",
404 .usage
= "<normal|fast>",
405 .handler
= &buspirate_handle_speed_command
,
406 .mode
= COMMAND_CONFIG
,
407 .help
= "speed of the interface",
410 .name
= "buspirate_mode",
411 .usage
= "<normal|open-drain>",
412 .handler
= &buspirate_handle_mode_command
,
413 .mode
= COMMAND_CONFIG
,
414 .help
= "pin mode of the interface",
417 .name
= "buspirate_port",
418 .usage
= "/dev/ttyUSB0",
419 .handler
= &buspirate_handle_port_command
,
420 .mode
= COMMAND_CONFIG
,
421 .help
= "name of the serial port to open",
423 COMMAND_REGISTRATION_DONE
426 struct jtag_interface buspirate_interface
= {
428 .execute_queue
= buspirate_execute_queue
,
429 .speed
= buspirate_speed
,
430 .khz
= buspirate_khz
,
431 .commands
= buspirate_command_handlers
,
432 .init
= buspirate_init
,
433 .quit
= buspirate_quit
436 /*************** jtag execute commands **********************/
437 static void buspirate_end_state(tap_state_t state
)
439 if (tap_is_state_stable(state
))
440 tap_set_end_state(state
);
442 LOG_ERROR("BUG: %i is not a valid end state", state
);
447 static void buspirate_state_move(void)
450 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(),
451 tap_get_end_state());
452 int tms_count
= tap_get_tms_path_len(tap_get_state(),
453 tap_get_end_state());
455 for (i
= 0; i
< tms_count
; i
++) {
456 tms
= (tms_scan
>> i
) & 1;
457 buspirate_tap_append(tms
, 0);
460 tap_set_state(tap_get_end_state());
463 static void buspirate_path_move(int num_states
, tap_state_t
*path
)
467 for (i
= 0; i
< num_states
; i
++) {
468 if (tap_state_transition(tap_get_state(), false) == path
[i
]) {
469 buspirate_tap_append(0, 0);
470 } else if (tap_state_transition(tap_get_state(), true)
472 buspirate_tap_append(1, 0);
474 LOG_ERROR("BUG: %s -> %s isn't a valid "
476 tap_state_name(tap_get_state()),
477 tap_state_name(path
[i
]));
481 tap_set_state(path
[i
]);
484 tap_set_end_state(tap_get_state());
487 static void buspirate_runtest(int num_cycles
)
491 tap_state_t saved_end_state
= tap_get_end_state();
493 /* only do a state_move when we're not already in IDLE */
494 if (tap_get_state() != TAP_IDLE
) {
495 buspirate_end_state(TAP_IDLE
);
496 buspirate_state_move();
499 for (i
= 0; i
< num_cycles
; i
++)
500 buspirate_tap_append(0, 0);
502 DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
503 tap_state_name(tap_get_state()),
504 tap_state_name(tap_get_end_state()));
506 /* finish in end_state */
507 buspirate_end_state(saved_end_state
);
508 if (tap_get_state() != tap_get_end_state())
509 buspirate_state_move();
512 static void buspirate_scan(bool ir_scan
, enum scan_type type
,
513 uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
515 tap_state_t saved_end_state
;
517 buspirate_tap_make_space(1, scan_size
+8);
518 /* is 8 correct ? (2 moves = 16) */
520 saved_end_state
= tap_get_end_state();
522 buspirate_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
523 buspirate_state_move();
525 buspirate_tap_append_scan(scan_size
, buffer
, command
);
528 buspirate_tap_append(0, 0);
530 /* restore the saved state */
531 buspirate_end_state(saved_end_state
);
532 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
534 if (tap_get_state() != tap_get_end_state())
535 buspirate_state_move();
539 /************************* TAP related stuff **********/
541 #define BUSPIRATE_BUFFER_SIZE 1024
542 #define BUSPIRATE_MAX_PENDING_SCANS 32
544 static char tms_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
545 static char tdi_chain
[BUSPIRATE_BUFFER_SIZE
]; /* send */
546 static int tap_chain_index
;
548 struct pending_scan_result
/* this was stolen from arm-jtag-ew */
550 int first
; /* First bit position in tdo_buffer to read */
551 int length
; /* Number of bits to read */
552 struct scan_command
*command
; /* Corresponding scan command */
556 static struct pending_scan_result
557 tap_pending_scans
[BUSPIRATE_MAX_PENDING_SCANS
];
558 static int tap_pending_scans_num
;
560 static void buspirate_tap_init(void)
563 tap_pending_scans_num
= 0;
566 static int buspirate_tap_execute(void)
575 if (tap_chain_index
<= 0)
578 LOG_DEBUG("executing tap num bits = %i scans = %i",
579 tap_chain_index
, tap_pending_scans_num
);
581 bytes_to_send
= (tap_chain_index
+7) / 8;
583 tmp
[0] = CMD_TAP_SHIFT
; /* this command expects number of bits */
584 tmp
[1] = (char)(tap_chain_index
>> 8); /* high */
585 tmp
[2] = (char)(tap_chain_index
); /* low */
588 for (i
= 0; i
< bytes_to_send
; i
++) {
589 tmp
[fill_index
] = tdi_chain
[i
];
591 tmp
[fill_index
] = tms_chain
[i
];
595 ret
= buspirate_serial_write(buspirate_fd
, tmp
, 3 + bytes_to_send
*2);
596 if (ret
!= bytes_to_send
*2+3) {
597 LOG_ERROR("error writing :(");
598 return ERROR_JTAG_DEVICE_ERROR
;
601 ret
= buspirate_serial_read(buspirate_fd
, tmp
, bytes_to_send
+ 3);
602 if (ret
!= bytes_to_send
+ 3) {
603 LOG_ERROR("error reading");
606 in_buf
= (uint8_t *)(&tmp
[3]);
608 /* parse the scans */
609 for (i
= 0; i
< tap_pending_scans_num
; i
++) {
610 uint8_t *buffer
= tap_pending_scans
[i
].buffer
;
611 int length
= tap_pending_scans
[i
].length
;
612 int first
= tap_pending_scans
[i
].first
;
613 struct scan_command
*command
= tap_pending_scans
[i
].command
;
615 /* copy bits from buffer */
616 buf_set_buf(in_buf
, first
, buffer
, 0, length
);
618 /* return buffer to higher level */
619 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
620 buspirate_tap_init();
621 return ERROR_JTAG_QUEUE_FAILED
;
626 tap_pending_scans_num
= 0;
631 static void buspirate_tap_make_space(int scans
, int bits
)
633 int have_scans
= BUSPIRATE_MAX_PENDING_SCANS
- tap_pending_scans_num
;
634 int have_bits
= BUSPIRATE_BUFFER_SIZE
* 8 - tap_chain_index
;
636 if ((have_scans
< scans
) || (have_bits
< bits
))
637 buspirate_tap_execute();
640 static void buspirate_tap_append(int tms
, int tdi
)
644 buspirate_tap_make_space(0, 1);
645 chain_index
= tap_chain_index
/ 8;
647 if (chain_index
< BUSPIRATE_BUFFER_SIZE
) {
648 int bit_index
= tap_chain_index
% 8;
649 uint8_t bit
= 1 << bit_index
;
652 tms_chain
[chain_index
] |= bit
;
654 tms_chain
[chain_index
] &= ~bit
;
657 tdi_chain
[chain_index
] |= bit
;
659 tdi_chain
[chain_index
] &= ~bit
;
663 LOG_ERROR("tap_chain overflow, bad things will happen");
667 static void buspirate_tap_append_scan(int length
, uint8_t *buffer
,
668 struct scan_command
*command
)
671 tap_pending_scans
[tap_pending_scans_num
].length
= length
;
672 tap_pending_scans
[tap_pending_scans_num
].buffer
= buffer
;
673 tap_pending_scans
[tap_pending_scans_num
].command
= command
;
674 tap_pending_scans
[tap_pending_scans_num
].first
= tap_chain_index
;
676 for (i
= 0; i
< length
; i
++) {
677 int tms
= (i
< length
-1 ? 0 : 1);
678 int tdi
= (buffer
[i
/8] >> (i
%8)) & 1;
679 buspirate_tap_append(tms
, tdi
);
681 tap_pending_scans_num
++;
684 /*************** jtag wrapper functions *********************/
686 /* (1) assert or (0) deassert reset lines */
687 static void buspirate_reset(int trst
, int srst
)
689 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
692 buspirate_jtag_set_feature(buspirate_fd
,
693 FEATURE_TRST
, ACTION_DISABLE
);
695 buspirate_jtag_set_feature(buspirate_fd
,
696 FEATURE_TRST
, ACTION_ENABLE
);
699 buspirate_jtag_set_feature(buspirate_fd
,
700 FEATURE_SRST
, ACTION_DISABLE
);
702 buspirate_jtag_set_feature(buspirate_fd
,
703 FEATURE_SRST
, ACTION_ENABLE
);
706 /*************** jtag lowlevel functions ********************/
707 static void buspirate_jtag_enable(int fd
)
710 char tmp
[21] = { [0 ... 20] = 0x00 };
714 LOG_DEBUG("Entering binary mode");
715 buspirate_serial_write(fd
, tmp
, 20);
718 /* reads 1 to n "BBIO1"s and one "OCD1" */
720 ret
= buspirate_serial_read(fd
, tmp
, 4);
722 LOG_ERROR("Buspirate error. Is binary"
723 "/OpenOCD support enabled?");
726 if (strncmp(tmp
, "BBIO", 4) == 0) {
727 ret
= buspirate_serial_read(fd
, tmp
, 1);
729 LOG_ERROR("Buspirate did not answer correctly! "
730 "Do you have correct firmware?");
734 LOG_ERROR("Unsupported binary protocol");
739 tmp
[0] = CMD_ENTER_OOCD
;
740 ret
= buspirate_serial_write(fd
, tmp
, 1);
742 LOG_ERROR("error reading");
746 } else if (strncmp(tmp
, "OCD1", 4) == 0)
749 LOG_ERROR("Buspirate did not answer correctly! "
750 "Do you have correct firmware?");
757 static void buspirate_jtag_reset(int fd
)
761 tmp
[0] = 0x00; /* exit OCD1 mode */
762 buspirate_serial_write(fd
, tmp
, 1);
764 /* We ignore the return value here purposly, nothing we can do */
765 buspirate_serial_read(fd
, tmp
, 5);
766 if (strncmp(tmp
, "BBIO1", 5) == 0) {
767 tmp
[0] = 0x0F; /* reset BP */
768 buspirate_serial_write(fd
, tmp
, 1);
770 LOG_ERROR("Unable to restart buspirate!");
773 static void buspirate_jtag_set_speed(int fd
, char speed
)
782 tmp
[0] = CMD_UART_SPEED
;
784 buspirate_jtag_command(fd
, tmp
, 2);
786 /* here the adapter changes speed, we need follow */
787 buspirate_serial_setspeed(fd
, speed
);
789 buspirate_serial_write(fd
, ack
, 2);
790 ret
= buspirate_serial_read(fd
, tmp
, 2);
792 LOG_ERROR("Buspirate did not ack speed change");
795 if ((tmp
[0] != CMD_UART_SPEED
) || (tmp
[1] != speed
)) {
796 LOG_ERROR("Buspirate did not reply as expected");
799 LOG_INFO("Buspirate switched to %s mode",
800 (speed
== SERIAL_NORMAL
) ? "normal" : "FAST");
804 static void buspirate_jtag_set_mode(int fd
, char mode
)
807 tmp
[0] = CMD_PORT_MODE
;
809 buspirate_jtag_command(fd
, tmp
, 2);
812 static void buspirate_jtag_set_feature(int fd
, char feat
, char action
)
815 tmp
[0] = CMD_FEATURE
;
816 tmp
[1] = feat
; /* what */
817 tmp
[2] = action
; /* action */
818 buspirate_jtag_command(fd
, tmp
, 3);
821 static void buspirate_jtag_get_adcs(int fd
)
825 tmp
[0] = CMD_READ_ADCS
;
826 buspirate_jtag_command(fd
, (char *)tmp
, 1);
827 a
= tmp
[2] << 8 | tmp
[3];
828 b
= tmp
[4] << 8 | tmp
[5];
829 c
= tmp
[6] << 8 | tmp
[7];
830 d
= tmp
[8] << 8 | tmp
[9];
832 LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
834 ((float)a
)/155.1515, ((float)b
)/155.1515,
835 ((float)c
)/155.1515, ((float)d
)/155.1515);
838 static unsigned char buspirate_jtag_command(int fd
,
839 char *cmd
, int cmdlen
)
844 res
= buspirate_serial_write(fd
, cmd
, cmdlen
);
846 if ((cmd
[0] == CMD_UART_SPEED
)
847 || (cmd
[0] == CMD_PORT_MODE
)
848 || (cmd
[0] == CMD_FEATURE
)
849 || (cmd
[0] == CMD_JTAG_SPEED
))
855 len
= 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
863 res
= buspirate_serial_read(fd
, cmd
, len
);
865 return (unsigned char)cmd
[1];
873 /* low level serial port */
874 /* TODO add support for WIN32 and others ! */
875 static int buspirate_serial_open(char *port
)
878 fd
= open(buspirate_port
, O_RDWR
| O_NOCTTY
| O_NDELAY
);
882 static int buspirate_serial_setspeed(int fd
, char speed
)
884 struct termios t_opt
;
885 speed_t baud
= (speed
== SERIAL_FAST
) ? B1000000
: B115200
;
887 /* set the serial port parameters */
888 fcntl(fd
, F_SETFL
, 0);
889 tcgetattr(fd
, &t_opt
);
890 cfsetispeed(&t_opt
, baud
);
891 cfsetospeed(&t_opt
, baud
);
892 t_opt
.c_cflag
|= (CLOCAL
| CREAD
);
893 t_opt
.c_cflag
&= ~PARENB
;
894 t_opt
.c_cflag
&= ~CSTOPB
;
895 t_opt
.c_cflag
&= ~CSIZE
;
896 t_opt
.c_cflag
|= CS8
;
897 t_opt
.c_lflag
&= ~(ICANON
| ECHO
| ECHOE
| ISIG
);
898 t_opt
.c_iflag
&= ~(IXON
| IXOFF
| IXANY
);
899 t_opt
.c_oflag
&= ~OPOST
;
900 t_opt
.c_cc
[VMIN
] = 0;
901 t_opt
.c_cc
[VTIME
] = 10;
902 tcflush(fd
, TCIFLUSH
);
903 tcsetattr(fd
, TCSANOW
, &t_opt
);
908 static int buspirate_serial_write(int fd
, char *buf
, int size
)
912 ret
= write(fd
, buf
, size
);
914 LOG_DEBUG("size = %d ret = %d", size
, ret
);
915 buspirate_print_buffer(buf
, size
);
918 LOG_ERROR("Error sending data");
923 static int buspirate_serial_read(int fd
, char *buf
, int size
)
930 ret
= read(fd
, buf
+len
, size
-len
);
946 LOG_DEBUG("should have read = %d actual size = %d", size
, len
);
947 buspirate_print_buffer(buf
, len
);
950 LOG_ERROR("Error reading data");
955 static void buspirate_serial_close(int fd
)
961 #define BYTES_PER_LINE 16
962 static void buspirate_print_buffer(char *buf
, int size
)
964 char line
[LINE_SIZE
];
969 while (offset
< size
) {
970 snprintf(tmp
, 5, "%02x ", (uint8_t)buf
[offset
]);
975 if (offset
% BYTES_PER_LINE
== 0) {
976 LOG_DEBUG("%s", line
);
982 LOG_DEBUG("%s", line
);