mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-02-10 15:40:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

posix-h5: implement slip encoder/decoder

Browse Source
This commit is contained in:
Matthias Ringwald 2016-02-21 22:40:27 +01:00
parent 8257e5f9e1
commit 5cfc685701
1 changed files with 224 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

421
platform/posix/hci_transport_h5_posix.c
View File

@ -53,99 +53,226 @@
#include "hci_transport.h" #include "hci_transport.h"
#ifdef HAVE_EHCILL #ifdef HAVE_EHCILL
#error "HCI Transport H5 POSIX does not support eHCILL yet. Please remove HAVE_EHCILL from your btstack-config.h" #error "HCI Transport H5 POSIX does not support eHCILL. Please either use HAVE_EHCILL or H5 Transport"
#endif #endif
typedef struct hci_transport_h5 { /// newer
hci_transport_t transport;
btstack_data_source_t *ds;
} hci_transport_h5_t;
// h5 slip state machine // h5 slip state machine
typedef enum { typedef enum {
unknown = 1, SLIP_UNKNOWN = 1,
decoding, SLIP_DECODING,
x_c0, SLIP_X_C0,
x_db SLIP_X_DB
} H5_STATE; } hci_transport_slip_state_t;
typedef struct h5_slip { static const uint8_t slip_c0_encoded[] = { 0xdb, 0xdc };
state_t state; static const uint8_t slip_db_encoded[] = { 0xdb, 0xdd };
uint16_t length;
uint8_t data[HCI_ACL_BUFFER_SIZE];
} h5_slip_t;
// Global State static uint8_t hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 1 + HCI_PACKET_BUFFER_SIZE]; // packet type + max(acl header + acl payload, event header + event data)
static h5_slip_t read_sm;
static h5_slip_t write_sm;
static int bt_filedesc = 0;
// single instance static hci_transport_slip_state_t slip_state;
static hci_transport_h5_t * hci_transport_h5 = NULL; static uint8_t * slip_payload = &hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE];
static int slip_payload_pos;
static uint8_t slip_header[4];
static int slip_header_pos;
static int h5_process(struct btstack_data_source *ds); static hci_transport_config_uart_t * hci_transport_config_uart;
static void dummy_handler(uint8_t packet_type, uint8_t *packet, int size); static hci_transport_t * h5_hci_transport;
static btstack_data_source_t * h5_data_source;
static void (*packet_handler)(uint8_t packet_type, uint8_t *packet, int size) = dummy_handler; // Prototypes
static void hci_transport_h5_process_frame(void);
static void h5_init(const void * transport_config){ // Generic helper
static void hci_transport_h5_send_really(uint8_t * data, int size){
while (size > 0) {
int bytes_written = write(hci_transport_h5_data_source->fd, data, size);
if (bytes_written < 0) {
usleep(5000);
continue;
}
data += bytes_written;
size -= bytes_written;
}
}
// SLIP
static inline void hci_transport_slip_send_eof(void){
uint8_t data = 0xc0;
hci_transport_h5_send_really(&data, 1);
}
static inline void hci_transport_slip_send_byte(uint8_t data){
switch (data){
case 0xc0:
hci_transport_h5_send_really(slip_c0_encoded, sizeof(slip_c0_encoded));
break;
case 0xdb:
hci_transport_h5_send_really(slip_db_encoded, sizeof(slip_db_encoded));
break;
default:
hci_transport_h5_send_really(&data, 1);
break;
}
}
static inline void hci_transport_slip_send_block(uint8_t * data, uint16_t size){
uint16_t i;
for (i=0;i<size;i++){
hci_transport_slip_send_byte(data++);
}
}
// format: 0xc0 HEADER PACKER 0xc0
static void hci_transport_slip_send_frame(uint32_t header, uint8_t * packet, uint16_t packet_size){
// reset data integrity flag
if (header & 0x040){
log_error("hci_transport_slip_send_frame: data integrity not supported, dropping flag");
header &= ~0x40;
}
// Start of Frame
hci_transport_slip_send_eof();
// Header
uint8_t header_buffer[4];
little_endian_store_32(header_buffer, 0, header);
hci_transport_slip_send_block(header_buffer, sizeof(header_buffer));
// Packet
hci_transport_slip_send_block(packet, packet_size);
// Endo of frame
hci_transport_slip_send_eof();
}
static void hci_transport_h5_slip_reset(void){
slip_header_pos = 0;
slip_payload_pos = 0;
}
static void hci_transport_h5_slip_init(void){
slip_state = SLIP_UNKNOWN;
hci_transport_h5_slip_reset();
}
static void hci_transport_h5_slip_store_byte(uint8_t input){
if (slip_header_pos < 4){
slip_header[slip_header_pos++] = input;
return;
}
if (slip_packet_pos < HCI_PACKET_BUFFER_SIZE){
slip_packet[slip_packet_pos++] = input;
}
log_error("hci_transport_h5_slip_store_byte: packet to long");
hci_transport_h5_slip_init();
}
static void hci_transport_slip_process(uint8_t input){
switch(slip_state){
case SLIP_UNKNOWN:
if (input != 0xc0) break;
hci_transport_h5_slip_reset();
slip_state = SLIP_X_C0;
break;
case SLIP_X_C0:
switch(input){
case 0xc0:
break;
case 0xdb:
slip_state = SLIP_X_DB;
break;
default:
hci_transport_h5_slip_store_byte(input);
slip_state = SLIP_DECODING;
break;
}
break;
case SLIP_X_DB:
switch(input){
case 0xdc:
hci_transport_h5_slip_store_byte(0xc0);
slip_state = SLIP_DECODING;
break;
case 0xdd;
hci_transport_h5_slip_store_byte(0xdb);
slip_state = SLIP_DECODING;
break;
default:
hci_transport_h5_slip_init();
break;
}
break;
case SLIP_DECODING:
switch(input){
case 0xc0:
if (slip_payload_pos){
hci_transport_h5_process_frame();
}
hci_transport_h5_slip_init();
break;
case 0xdb:
slip_state = SLIP_X_DB;
break;
default:
hci_transport_h5_slip_store_byte(input);
break;
}
break;
}
}
// Three-Wire Implementation
static void hci_transport_h5_process_frame(void){
// TODO...
}
///
static int hci_transport_h5_send_packet(uint8_t packet_type, uint8_t *packet, int size){
// TODO...
}
/// H5 Interface
static void hci_transport_h5_register_packet_handler(void (*handler)(uint8_t packet_type, uint8_t *packet, int size)){
packet_handler = handler;
}
static void hci_transport_h5_init(const void * transport_config){
// check for hci_transport_config_uart_t // check for hci_transport_config_uart_t
if (!transport_config) { if (!transport_config) {
log_error("hci_transport_h4_posix: no config!"); log_error("hci_transport_h5_posix: no config!");
return; return;
} }
if (((hci_transport_config_t*)transport_config)->type != HCI_TRANSPORT_CONFIG_UART) { if (((hci_transport_config_t*)transport_config)->type != HCI_TRANSPORT_CONFIG_UART) {
log_error("hci_transport_h4_posix: config not of type != HCI_TRANSPORT_CONFIG_UART!"); log_error("hci_transport_h5_posix: config not of type != HCI_TRANSPORT_CONFIG_UART!");
return; return;
} }
hci_transport_config_uart = (hci_transport_config_uart_t*) transport_config; hci_transport_config_uart = (hci_transport_config_uart_t*) transport_config;
} }
static int h5_open(const void *transport_config){ static int hci_transport_h5_open(void){
// check for hci_transport_config_uart_t
if (!transport_config) {
log_error("hci_transport_h5_posix: no config!");
return -1;
}
if (((hci_transport_config_t*)transport_config)->type != HCI_TRANSPORT_CONFIG_UART) {
log_error("hci_transport_h5_posix: config not of type != HCI_TRANSPORT_CONFIG_UART!");
return -1;
}
hci_transport_config_uart = (hci_transport_config_uart_t*) transport_config;
struct termios toptions; struct termios toptions;
int fd = open(hci_transport_config_uart->device_name, O_RDWR | O_NOCTTY | O_NDELAY); int flags = O_RDWR | O_NOCTTY | O_NONBLOCK;
int fd = open(hci_transport_config_uart->device_name, flags);
if (fd == -1) { if (fd == -1) {
perror("init_serialport: Unable to open port "); perror("h5_open: Unable to open port ");
perror(hci_transport_config_uart->device_name); perror(hci_transport_config_uart->device_name);
return -1; return -1;
} }
if (tcgetattr(fd, &toptions) < 0) { if (tcgetattr(fd, &toptions) < 0) {
perror("init_serialport: Couldn't get term attributes"); perror("h5_open: Couldn't get term attributes");
return -1; return -1;
} }
speed_t brate = hci_transport_config_uart->baudrate; // let you override switch below if needed
switch(hci_transport_config_uart->baudrate) { cfmakeraw(&toptions); // make raw
case 57600: brate=B57600; break;
case 115200: brate=B115200; break;
#ifdef B230400
case 230400: brate=B230400; break;
#endif
#ifdef B460800
case 460800: brate=B460800; break;
#endif
#ifdef B921600
case 921600: brate=B921600; break;
#endif
}
cfsetispeed(&toptions, brate);
cfsetospeed(&toptions, brate);
// 8N1 // 8N1
toptions.c_cflag &= ~PARENB;
toptions.c_cflag &= ~CSTOPB; toptions.c_cflag &= ~CSTOPB;
toptions.c_cflag &= ~CSIZE;
toptions.c_cflag |= CS8; toptions.c_cflag |= CS8;
if (hci_transport_config_uart->flowcontrol) { if (hci_transport_config_uart->flowcontrol) {
@ -159,9 +286,6 @@ static int h5_open(const void *transport_config){
toptions.c_cflag |= CREAD | CLOCAL; // turn on READ & ignore ctrl lines toptions.c_cflag |= CREAD | CLOCAL; // turn on READ & ignore ctrl lines
toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl toptions.c_iflag &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl
toptions.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
toptions.c_oflag &= ~OPOST; // make raw
// see: http://unixwiz.net/techtips/termios-vmin-vtime.html // see: http://unixwiz.net/techtips/termios-vmin-vtime.html
toptions.c_cc[VMIN] = 1; toptions.c_cc[VMIN] = 1;
toptions.c_cc[VTIME] = 0; toptions.c_cc[VTIME] = 0;
@ -172,165 +296,56 @@ static int h5_open(const void *transport_config){
} }
// set up data_source // set up data_source
hci_transport_h5->ds = malloc(sizeof(btstack_data_source_t)); hci_transport_h5_data_source->fd = fd;
if (!hci_transport_h5) return -1; hci_transport_h5_data_source->process = h4_process;
hci_transport_h5->ds->fd = fd; btstack_run_loop_add_data_source(&h5_data_source);
hci_transport_h5->ds->process = h5_process;
btstack_run_loop_add_data_source(hci_transport_h5->ds);
// init state machine // also set baudrate
h5_slip_init( &read_sm); if (h5_set_baudrate(hci_transport_config_uart->baudrate_init) < 0){
h5_slip_init( &write_sm); return -1;
}
// init slip parser state machine
hci_transport_h5_slip_init();
// h5 link layer
return 0; return 0;
} }
static int h5_close(const void *transport_config){ static int hci_transport_h5_close(const void *transport_config){
// first remove run loop handler // first remove run loop handler
btstack_run_loop_remove_data_source(hci_transport_h5->ds); btstack_run_loop_remove_data_source(h5_data_source);
// close device // then close device
close(hci_transport_h5->ds->fd); close(hci_transport_h5_data_source->fd);
free(hci_transport_h5->ds);
// free struct
hci_transport_h5->ds = NULL;
return 0; return 0;
} }
static int h5_send_packet(uint8_t packet_type, uint8_t *packet, int size){ static int hci_transport_h5_process(struct btstack_data_source *ds) {
if (hci_transport_h5->ds == NULL) return -1; if (hci_transport_h5_data_source->fd) return -1;
if (hci_transport_h5->ds->fd == 0) return -1;
char *data = (char*) packet;
write(hci_transport_h5->ds->fd, &packet_type, 1);
while (size > 0) {
int bytes_written = write(hci_transport_h5->ds->fd, data, size);
if (bytes_written < 0) {
usleep(5000);
continue;
}
data += bytes_written;
size -= bytes_written;
}
return 0;
}
static void h5_register_packet_handler(void (*handler)(uint8_t packet_type, uint8_t *packet, int size)){
packet_handler = handler;
}
static void h5_slip_init( h5_slip_t * sm){
sm->state = unknown;
}
static void h5_slip_process( h5_slip_t * sm, uint8_t input, uint8_t in){
uint8_t type;
switch (sm->state) {
case unknown:
if (input == 0xc0){
sm->length = 0;
sm->state = x_c0;
}
break;
case x_c0:
switch (input ){
case 0xc0:
break;
case 0xdb:
sm->state = x_db;
break;
default:
sm->data[sm->length] = input;
++sm->length;
sm->state = decoding;
break;
}
break;
case decoding:
switch (input ){
case 0xc0:
sm->state = unknown;
// packet done - check if valid HCI packet
if (sm->length < 6) break;
type = sm->data[1] & 0x0f;
if (type < 1 || type > 4) break;
switch (type) {
case HCI_ACL_DATA_PACKET:
acl_packet_handler( &sm->data[4], sm->length-4-2);
break;
case HCI_EVENT_PACKET:
event_packet_handler( &sm->data[4], sm->length-4-2);
break;
default:
break;
}
break;
case 0xdb:
sm->state = x_db;
break;
default:
sm->data[sm->length] = input;
++sm->length;
break;
}
break;
case x_db:
switch (input) {
case 0xdc:
sm->data[sm->length] = 0xc0;
++sm->length;
sm->state = decoding;
break;
case 0xdd:
sm->data[sm->length] = 0xdb;
++sm->length;
sm->state = decoding;
break;
default:
sm->state = unknown;
break;
}
break;
default:
break;
}
}
static int h5_process(struct btstack_data_source *ds) {
if (hci_transport_h5->ds->fd == 0) return -1;
// read up to bytes_to_read data in // read up to bytes_to_read data in
uint8_t data; uint8_t data;
while (1) { while (1) {
int bytes_read = read(hci_transport_h5->ds->fd, &data, 1); int bytes_read = read(hci_transport_h5_data_source->fd, &data, 1);
if (bytes_read < 1) break; if (bytes_read < 1) break;
h5_slip_process( &read_sm, data, 1); hci_transport_slip_process(data);
}; };
return 0; return 0;
} }
static const char * h5_get_transport_name(void){
return "H5";
}
static void dummy_handler(uint8_t *packet, int size){
}
// get h5 singleton // get h5 singleton
const hci_transport_t * hci_transport_h5_instance() { const hci_transport_t * hci_transport_h5_instance() {
if (hci_transport_h4 == NULL) { if (hci_transport_h5 == NULL) {
hci_transport_h4 = (hci_transport_h4_t*)malloc( sizeof(hci_transport_h4_t)); hci_transport_h5 = (hci_transport_h5_t*)malloc( sizeof(hci_transport_t));
memset(hci_transport_h4, 0, sizeof(hci_transport_h4_t)); memset(hci_transport_h5, 0, sizeof(hci_transport_t));
hci_transport_h4->ds = NULL; hci_transport_h5->name = "H5_POSIX";
hci_transport_h4->transport.name = "H5_POSIX"; hci_transport_h5->init = hci_transport_h5_init;
hci_transport_h4->transport.init = h4_init; hci_transport_h5->open = hci_transport_h5_open;
hci_transport_h4->transport.open = h4_open; hci_transport_h5->close = hci_transport_h5_close;
hci_transport_h4->transport.close = h4_close; hci_transport_h5->register_packet_handler = hci_transport_h5_register_packet_handler;
hci_transport_h4->transport.register_packet_handler = h4_register_packet_handler; hci_transport_h5->can_send_packet_now = NULL;
hci_transport_h4->transport.can_send_packet_now = NULL; hci_transport_h5->send_packet = hci_transport_h5_send_packet;
hci_transport_h4->transport.send_packet = h4_send_packet; hci_transport_h5->set_baudrate = hci_transport_h5_set_baudrate;
hci_transport_h4->transport.set_baudrate = h4_set_baudrate;
} }
return (const hci_transport_t *) hci_transport_h4; return (const hci_transport_t *) hci_transport_h5;
} }