mirror of
https://github.com/bluekitchen/btstack.git
synced 2025-02-26 18:41:12 +00:00
hci_transport_h5: new implementation based on btstack_uart driver with SLIP support
This commit is contained in:
Matthias Ringwald
parent
dd90474ba4
commit
a48f52afac
@ -145,6 +145,12 @@ const hci_transport_t * hci_transport_h4_instance(const btstack_uart_block_t * u
|
||||
*/
|
||||
const hci_transport_t * hci_transport_h5_instance(const btstack_uart_block_t * uart_driver);
|
||||
|
||||
/*
|
||||
* @brief Setup H5 instance with btstack_uart implementation that supports SLIP frames
|
||||
* @param uart_driver to use
|
||||
*/
|
||||
const hci_transport_t * hci_transport_h5_instance(const btstack_uart_t * uart_driver);
|
||||
|
||||
/*
|
||||
* @brief Setup H4 over SPI instance for EM9304 with em9304_spi_driver
|
||||
* @param em9304_spi_driver to use
|
||||
|
||||
@ -35,23 +35,26 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#define BTSTACK_FILE__ "hci_transport_h5.c"
|
||||
#define __BTSTACK_FILE__ "hci_transport_h5.c"
|
||||
|
||||
/*
|
||||
* hci_transport_h5.c
|
||||
*
|
||||
* HCI Transport API implementation for basic H5 protocol
|
||||
*
|
||||
* Created by Matthias Ringw ald on 4/29/09.
|
||||
* HCI Transport API implementation for basic H5 protocol based on UART driver with SLIP support
|
||||
*/
|
||||
|
||||
// #define ENABLE_LOG_DEBUG
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#include "hci.h"
|
||||
#include "btstack_slip.h"
|
||||
#include "btstack_debug.h"
|
||||
#include "hci.h"
|
||||
#include "hci_transport.h"
|
||||
#include "btstack_uart_block.h"
|
||||
|
||||
// assert pre-buffer for packet type is available
|
||||
#if !defined(HCI_OUTGOING_PRE_BUFFER_SIZE) || (HCI_OUTGOING_PRE_BUFFER_SIZE < 4)
|
||||
#error HCI_OUTGOING_PRE_BUFFER_SIZE not defined or smaller than 4. Please update hci.h
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
LINK_UNINITIALIZED,
|
||||
@ -71,6 +74,7 @@ typedef enum {
|
||||
HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET = 1 << 8,
|
||||
HCI_TRANSPORT_LINK_SEND_ACK_PACKET = 1 << 9,
|
||||
HCI_TRANSPORT_LINK_ENTER_SLEEP = 1 << 10,
|
||||
HCI_TRANSPORT_LINK_SET_BAUDRATE = 1 << 11,
|
||||
|
||||
} hci_transport_link_actions_t;
|
||||
|
||||
@ -91,14 +95,14 @@ typedef enum {
|
||||
#define LINK_ACKNOWLEDGEMENT_TYPE 0x00
|
||||
#define LINK_CONTROL_PACKET_TYPE 0x0f
|
||||
|
||||
// max size of write requests
|
||||
#define LINK_SLIP_TX_CHUNK_LEN 64
|
||||
|
||||
// ---
|
||||
static const uint8_t link_control_sync[] = { 0x01, 0x7e};
|
||||
static const uint8_t link_control_sync_response[] = { 0x02, 0x7d};
|
||||
static const uint8_t link_control_config[] = { 0x03, 0xfc, LINK_CONFIG_FIELD};
|
||||
static const uint8_t link_control_config_prefix_len = 2;
|
||||
static const uint8_t link_control_config_response_empty[] = { 0x04, 0x7b};
|
||||
static const uint8_t link_control_config_response[] = { 0x04, 0x7b, LINK_CONFIG_FIELD};
|
||||
static const uint8_t link_control_config_response_prefix_len = 2;
|
||||
static const uint8_t link_control_wakeup[] = { 0x05, 0xfa};
|
||||
static const uint8_t link_control_woken[] = { 0x06, 0xf9};
|
||||
static const uint8_t link_control_sleep[] = { 0x07, 0x78};
|
||||
@ -110,9 +114,6 @@ static const uint8_t link_control_sleep[] = { 0x07, 0x78};
|
||||
static uint8_t hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 6 + HCI_INCOMING_PACKET_BUFFER_SIZE];
|
||||
|
||||
// outgoing slip encoded buffer. +4 to assert that DIC fits in buffer. +1 to assert that last SOF fits in buffer.
|
||||
static uint8_t slip_outgoing_buffer[LINK_SLIP_TX_CHUNK_LEN+4+1];
|
||||
static uint16_t slip_outgoing_dic;
|
||||
static uint16_t slip_outgoing_dic_present;
|
||||
static int slip_write_active;
|
||||
|
||||
// H5 Link State
|
||||
@ -123,6 +124,7 @@ static uint8_t link_ack_nr;
|
||||
static uint16_t link_resend_timeout_ms;
|
||||
static uint8_t link_peer_asleep;
|
||||
static uint8_t link_peer_supports_data_integrity_check;
|
||||
static uint32_t link_new_baudrate;
|
||||
|
||||
// auto sleep-mode
|
||||
static btstack_timer_source_t inactivity_timer;
|
||||
@ -133,41 +135,44 @@ static uint8_t hci_packet_type;
|
||||
static uint16_t hci_packet_size;
|
||||
static uint8_t * hci_packet;
|
||||
|
||||
// restore 2 bytes temp overwritten by DIC
|
||||
static uint8_t * hci_packet_restore_dic_address;
|
||||
static uint16_t hci_packet_restore_dic_data;
|
||||
|
||||
// hci packet handler
|
||||
static void (*packet_handler)(uint8_t packet_type, uint8_t *packet, uint16_t size);
|
||||
|
||||
static int hci_transport_link_actions;
|
||||
|
||||
// UART Driver + Config
|
||||
static const btstack_uart_block_t * btstack_uart;
|
||||
static const btstack_uart_t * btstack_uart;
|
||||
static btstack_uart_config_t uart_config;
|
||||
static btstack_uart_sleep_mode_t btstack_uart_sleep_mode;
|
||||
static int hci_transport_bcsp_mode;
|
||||
|
||||
// Prototypes
|
||||
static void hci_transport_h5_process_frame(uint16_t frame_size);
|
||||
static int hci_transport_link_have_outgoing_packet(void);
|
||||
static void hci_transport_h5_frame_sent(void);
|
||||
static void hci_transport_h5_process_frame(uint16_t frame_size);
|
||||
static void hci_transport_link_run(void);
|
||||
static void hci_transport_link_send_queued_packet(void);
|
||||
static void hci_transport_link_set_timer(uint16_t timeout_ms);
|
||||
static void hci_transport_link_timeout_handler(btstack_timer_source_t * timer);
|
||||
static void hci_transport_link_run(void);
|
||||
static void hci_transport_slip_init(void);
|
||||
|
||||
// -----------------------------
|
||||
// CRC16-CCITT Calculation - compromise: use 32 byte table - 512 byte table would be faster, but that's too large
|
||||
|
||||
static const uint16_t crc16_ccitt_table[] ={
|
||||
0x0000, 0x1081, 0x2102, 0x3183,
|
||||
0x4204, 0x5285, 0x6306, 0x7387,
|
||||
0x8408, 0x9489, 0xa50a, 0xb58b,
|
||||
0xc60c, 0xd68d, 0xe70e, 0xf78f
|
||||
};
|
||||
|
||||
static uint16_t crc16_ccitt_update (uint16_t crc, uint8_t ch){
|
||||
|
||||
static const uint16_t crc16_ccitt_table[] ={
|
||||
0x0000, 0x1081, 0x2102, 0x3183,
|
||||
0x4204, 0x5285, 0x6306, 0x7387,
|
||||
0x8408, 0x9489, 0xa50a, 0xb58b,
|
||||
0xc60c, 0xd68d, 0xe70e, 0xf78f
|
||||
};
|
||||
|
||||
crc = (crc >> 4u) ^ crc16_ccitt_table[(crc ^ ch) & 0x000fu];
|
||||
crc = (crc >> 4u) ^ crc16_ccitt_table[(crc ^ (ch >> 4u)) & 0x000fu];
|
||||
crc = (crc >> 4) ^ crc16_ccitt_table[(crc ^ ch) & 0x000f];
|
||||
crc = (crc >> 4) ^ crc16_ccitt_table[(crc ^ (ch >> 4)) & 0x000f];
|
||||
return crc;
|
||||
}
|
||||
|
||||
@ -176,27 +181,23 @@ static uint16_t btstack_reverse_bits_16(uint16_t value){
|
||||
int i;
|
||||
for (i = 0; i < 16; i++) {
|
||||
reverse = reverse << 1;
|
||||
reverse |= value & 1u;
|
||||
reverse |= value & 1;
|
||||
value = value >> 1;
|
||||
}
|
||||
return reverse;
|
||||
}
|
||||
|
||||
static uint16_t crc16_calc_for_slip_frame(const uint8_t * header, const uint8_t * payload, uint16_t len){
|
||||
static uint16_t crc16_calc_for_slip_frame(const uint8_t * data, uint16_t len){
|
||||
int i;
|
||||
uint16_t crc = 0xffff;
|
||||
for (i=0 ; i < 4 ; i++){
|
||||
crc = crc16_ccitt_update(crc, header[i]);
|
||||
}
|
||||
for (i=0 ; i < len ; i++){
|
||||
crc = crc16_ccitt_update(crc, payload[i]);
|
||||
crc = crc16_ccitt_update(crc, data[i]);
|
||||
}
|
||||
return btstack_reverse_bits_16(crc);
|
||||
}
|
||||
|
||||
// -----------------------------
|
||||
static void hci_transport_inactivity_timeout_handler(btstack_timer_source_t * ts){
|
||||
UNUSED(ts);
|
||||
log_info("inactivity timeout. link state %d, peer asleep %u, actions 0x%02x, outgoing packet %u",
|
||||
link_state, link_peer_asleep, hci_transport_link_actions, hci_transport_link_have_outgoing_packet());
|
||||
if (hci_transport_link_have_outgoing_packet()) return;
|
||||
@ -215,68 +216,8 @@ static void hci_transport_inactivity_timer_set(void){
|
||||
btstack_run_loop_add_timer(&inactivity_timer);
|
||||
}
|
||||
|
||||
// -----------------------------
|
||||
// SLIP Outgoing
|
||||
|
||||
// Fill chunk and write
|
||||
static void hci_transport_slip_encode_chunk_and_send(int pos){
|
||||
while (btstack_slip_encoder_has_data() & (pos < LINK_SLIP_TX_CHUNK_LEN)) {
|
||||
slip_outgoing_buffer[pos++] = btstack_slip_encoder_get_byte();
|
||||
}
|
||||
|
||||
if (!btstack_slip_encoder_has_data()){
|
||||
// Payload encoded, append DIC if present.
|
||||
// note: slip_outgoing_buffer is guaranteed to be big enough to add DIC + SOF after LINK_SLIP_TX_CHUNK_LEN
|
||||
if (slip_outgoing_dic_present){
|
||||
uint8_t dic_buffer[2];
|
||||
big_endian_store_16(dic_buffer, 0, slip_outgoing_dic);
|
||||
btstack_slip_encoder_start(dic_buffer, 2);
|
||||
while (btstack_slip_encoder_has_data()){
|
||||
slip_outgoing_buffer[pos++] = btstack_slip_encoder_get_byte();
|
||||
}
|
||||
}
|
||||
// Start of Frame
|
||||
slip_outgoing_buffer[pos++] = BTSTACK_SLIP_SOF;
|
||||
}
|
||||
slip_write_active = 1;
|
||||
log_debug("slip: send %d bytes", pos);
|
||||
btstack_uart->send_block(slip_outgoing_buffer, pos);
|
||||
}
|
||||
|
||||
static inline void hci_transport_slip_send_next_chunk(void){
|
||||
hci_transport_slip_encode_chunk_and_send(0);
|
||||
}
|
||||
|
||||
// format: 0xc0 HEADER PACKET [DIC] 0xc0
|
||||
// @param uint8_t header[4]
|
||||
static void hci_transport_slip_send_frame(const uint8_t * header, const uint8_t * packet, uint16_t packet_size, uint16_t data_integrity_check){
|
||||
|
||||
int pos = 0;
|
||||
|
||||
// store data integrity check info
|
||||
slip_outgoing_dic = data_integrity_check;
|
||||
slip_outgoing_dic_present = header[0] & 0x40u;
|
||||
|
||||
// Start of Frame
|
||||
slip_outgoing_buffer[pos++] = BTSTACK_SLIP_SOF;
|
||||
|
||||
// Header
|
||||
btstack_slip_encoder_start(header, 4);
|
||||
while (btstack_slip_encoder_has_data()){
|
||||
slip_outgoing_buffer[pos++] = btstack_slip_encoder_get_byte();
|
||||
}
|
||||
|
||||
// Packet
|
||||
btstack_slip_encoder_start(packet, packet_size);
|
||||
|
||||
// Fill rest of chunk from packet and send
|
||||
hci_transport_slip_encode_chunk_and_send(pos);
|
||||
}
|
||||
|
||||
// SLIP Incoming
|
||||
|
||||
static void hci_transport_slip_init(void){
|
||||
btstack_slip_decoder_init(&hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE], 6 + HCI_INCOMING_PACKET_BUFFER_SIZE);
|
||||
btstack_uart->receive_frame(&hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE], 6 + HCI_INCOMING_PACKET_BUFFER_SIZE);
|
||||
}
|
||||
|
||||
// H5 Three-Wire Implementation
|
||||
@ -289,22 +230,74 @@ static void hci_transport_link_calc_header(uint8_t * header,
|
||||
uint8_t packet_type,
|
||||
uint16_t payload_length){
|
||||
|
||||
// unreliable packets have seq_nr = 0
|
||||
if (reliable_packet == 0) {
|
||||
sequence_nr = 0;
|
||||
}
|
||||
|
||||
header[0] = sequence_nr | (acknowledgement_nr << 3) | (data_integrity_check_present << 6) | (reliable_packet << 7);
|
||||
header[1] = packet_type | ((payload_length & 0x0fu) << 4u);
|
||||
header[1] = packet_type | ((payload_length & 0x0f) << 4);
|
||||
header[2] = payload_length >> 4;
|
||||
header[3] = 0xffu - (header[0u] + header[1u] + header[2u]);
|
||||
header[3] = 0xff - (header[0] + header[1] + header[2]);
|
||||
}
|
||||
|
||||
// Store DIC after packet, assuming 2 bytes in buffer - keep track of overwritten bytes - relevant for fragmented packets
|
||||
static void hci_transport_slip_send_frame_with_dic(uint8_t * frame, uint16_t frame_size){
|
||||
int slip_outgoing_dic_present = frame[0] & 0x40;
|
||||
if (slip_outgoing_dic_present){
|
||||
// preserved data at DIC location
|
||||
hci_packet_restore_dic_address = &frame[frame_size];
|
||||
hci_packet_restore_dic_data = little_endian_read_16(hci_packet_restore_dic_address, 0);
|
||||
// calc and set DIC
|
||||
uint16_t data_integrity_check = crc16_calc_for_slip_frame(frame, frame_size);
|
||||
big_endian_store_16(frame, frame_size, data_integrity_check);
|
||||
frame_size += 2;
|
||||
}
|
||||
|
||||
// set slip send active and go
|
||||
slip_write_active = 1;
|
||||
btstack_uart->send_frame(frame, frame_size);
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_queued_packet(void){
|
||||
uint8_t * buffer = hci_packet - 4;
|
||||
uint16_t buffer_size = hci_packet_size + 4;
|
||||
|
||||
// setup header
|
||||
int reliable = hci_packet_type == HCI_SCO_DATA_PACKET ? 0 : 1;
|
||||
hci_transport_link_calc_header(buffer, link_seq_nr, link_ack_nr, link_peer_supports_data_integrity_check, reliable, hci_packet_type, hci_packet_size);
|
||||
|
||||
// send frame with dic
|
||||
log_debug("send queued packet: seq %u, ack %u, size %u, append dic %u", link_seq_nr, link_ack_nr, hci_packet_size, link_peer_supports_data_integrity_check);
|
||||
log_debug_hexdump(hci_packet, hci_packet_size);
|
||||
hci_transport_slip_send_frame_with_dic(buffer, buffer_size);
|
||||
|
||||
// reset inactvitiy timer
|
||||
hci_transport_inactivity_timer_set();
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_control(const uint8_t * message, int message_len){
|
||||
uint8_t header[4];
|
||||
hci_transport_link_calc_header(header, 0, 0, link_peer_supports_data_integrity_check, 0, LINK_CONTROL_PACKET_TYPE, message_len);
|
||||
uint16_t data_integrity_check = 0;
|
||||
if (link_peer_supports_data_integrity_check){
|
||||
data_integrity_check = crc16_calc_for_slip_frame(header, message, message_len);
|
||||
}
|
||||
log_debug("hci_transport_link_send_control: size %u, append dic %u", message_len, link_peer_supports_data_integrity_check);
|
||||
uint8_t buffer[4 + LINK_CONTROL_MAX_LEN + 2];
|
||||
uint16_t buffer_size = 4 + message_len;
|
||||
|
||||
// setup header
|
||||
hci_transport_link_calc_header(buffer, 0, 0, link_peer_supports_data_integrity_check, 0, LINK_CONTROL_PACKET_TYPE, message_len);
|
||||
|
||||
// setup payload
|
||||
memcpy(&buffer[4], message, message_len);
|
||||
|
||||
// send frame with dic
|
||||
log_debug("send control: size %u, append dic %u", message_len, link_peer_supports_data_integrity_check);
|
||||
log_debug_hexdump(message, message_len);
|
||||
hci_transport_slip_send_frame(header, message, message_len, data_integrity_check);
|
||||
hci_transport_slip_send_frame_with_dic(buffer, buffer_size);
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_ack_packet(void){
|
||||
// Pure ACK package is without DIC as there is no payload either
|
||||
log_debug("send ack %u", link_ack_nr);
|
||||
uint8_t header[4];
|
||||
hci_transport_link_calc_header(header, 0, link_ack_nr, 0, 0, LINK_ACKNOWLEDGEMENT_TYPE, 0);
|
||||
hci_transport_slip_send_frame_with_dic(header, sizeof(header));
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_sync(void){
|
||||
@ -329,7 +322,6 @@ static void hci_transport_link_send_config_response(void){
|
||||
|
||||
static void hci_transport_link_send_config_response_empty(void){
|
||||
log_debug("link send config response empty");
|
||||
static const uint8_t link_control_config_response_empty[] = { 0x04, 0x7b};
|
||||
hci_transport_link_send_control(link_control_config_response_empty, sizeof(link_control_config_response_empty));
|
||||
}
|
||||
|
||||
@ -348,32 +340,6 @@ static void hci_transport_link_send_sleep(void){
|
||||
hci_transport_link_send_control(link_control_sleep, sizeof(link_control_sleep));
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_queued_packet(void){
|
||||
|
||||
uint8_t header[4];
|
||||
hci_transport_link_calc_header(header, link_seq_nr, link_ack_nr, link_peer_supports_data_integrity_check, 1, hci_packet_type, hci_packet_size);
|
||||
|
||||
uint16_t data_integrity_check = 0;
|
||||
if (link_peer_supports_data_integrity_check){
|
||||
data_integrity_check = crc16_calc_for_slip_frame(header, hci_packet, hci_packet_size);
|
||||
}
|
||||
log_debug("hci_transport_link_send_queued_packet: seq %u, ack %u, size %u. Append dic %u, dic = 0x%04x", link_seq_nr, link_ack_nr, hci_packet_size, link_peer_supports_data_integrity_check, data_integrity_check);
|
||||
log_debug_hexdump(hci_packet, hci_packet_size);
|
||||
|
||||
hci_transport_slip_send_frame(header, hci_packet, hci_packet_size, data_integrity_check);
|
||||
|
||||
// reset inactvitiy timer
|
||||
hci_transport_inactivity_timer_set();
|
||||
}
|
||||
|
||||
static void hci_transport_link_send_ack_packet(void){
|
||||
// Pure ACK package is without DIC as there is no payload either
|
||||
log_debug("send ack %u", link_ack_nr);
|
||||
uint8_t header[4];
|
||||
hci_transport_link_calc_header(header, 0, link_ack_nr, 0, 0, LINK_ACKNOWLEDGEMENT_TYPE, 0);
|
||||
hci_transport_slip_send_frame(header, NULL, 0, 0);
|
||||
}
|
||||
|
||||
static void hci_transport_link_run(void){
|
||||
// exit if outgoing active
|
||||
if (slip_write_active) return;
|
||||
@ -436,12 +402,12 @@ static void hci_transport_link_run(void){
|
||||
}
|
||||
|
||||
static void hci_transport_link_set_timer(uint16_t timeout_ms){
|
||||
btstack_run_loop_set_timer_handler(&link_timer, &hci_transport_link_timeout_handler);
|
||||
btstack_run_loop_set_timer(&link_timer, timeout_ms);
|
||||
btstack_run_loop_add_timer(&link_timer);
|
||||
}
|
||||
|
||||
static void hci_transport_link_timeout_handler(btstack_timer_source_t * ts){
|
||||
UNUSED(ts);
|
||||
static void hci_transport_link_timeout_handler(btstack_timer_source_t * timer){
|
||||
switch (link_state){
|
||||
case LINK_UNINITIALIZED:
|
||||
hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC;
|
||||
@ -479,7 +445,6 @@ static void hci_transport_link_init(void){
|
||||
|
||||
// get started
|
||||
hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC;
|
||||
btstack_run_loop_set_timer_handler(&link_timer, &hci_transport_link_timeout_handler);
|
||||
hci_transport_link_set_timer(LINK_PERIOD_MS);
|
||||
hci_transport_link_run();
|
||||
}
|
||||
@ -489,7 +454,7 @@ static int hci_transport_link_inc_seq_nr(int seq_nr){
|
||||
}
|
||||
|
||||
static int hci_transport_link_have_outgoing_packet(void){
|
||||
return hci_packet != NULL;
|
||||
return hci_packet != 0;
|
||||
}
|
||||
|
||||
static void hci_transport_link_clear_queue(void){
|
||||
@ -511,27 +476,24 @@ static void hci_transport_h5_emit_sleep_state(int sleep_active){
|
||||
log_info("emit_sleep_state: %u", sleep_active);
|
||||
uint8_t event[3];
|
||||
event[0] = HCI_EVENT_TRANSPORT_SLEEP_MODE;
|
||||
event[1] = sizeof(event) - 2u;
|
||||
event[1] = sizeof(event) - 2;
|
||||
event[2] = sleep_active;
|
||||
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
|
||||
}
|
||||
|
||||
static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
|
||||
static const uint8_t link_control_config_prefix_len = 2;
|
||||
static const uint8_t link_control_config_response_prefix_len = 2;
|
||||
|
||||
if (frame_size < 4u) return;
|
||||
if (frame_size < 4) return;
|
||||
|
||||
uint8_t * slip_header = &hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE];
|
||||
uint8_t * slip_payload = &hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 4];
|
||||
int frame_size_without_header = frame_size - 4u;
|
||||
int frame_size_without_header = frame_size - 4;
|
||||
|
||||
uint8_t seq_nr = slip_header[0u] & 0x07u;
|
||||
uint8_t ack_nr = (slip_header[0u] >> 3u) & 0x07u;
|
||||
uint8_t data_integrity_check_present = (slip_header[0u] & 0x40u) != 0u;
|
||||
uint8_t reliable_packet = (slip_header[0u] & 0x80u) != 0u;
|
||||
uint8_t link_packet_type = slip_header[1u] & 0x0fu;
|
||||
uint8_t seq_nr = slip_header[0] & 0x07;
|
||||
uint8_t ack_nr = (slip_header[0] >> 3) & 0x07;
|
||||
uint8_t data_integrity_check_present = (slip_header[0] & 0x40) != 0;
|
||||
uint8_t reliable_packet = (slip_header[0] & 0x80) != 0;
|
||||
uint8_t link_packet_type = slip_header[1] & 0x0f;
|
||||
uint16_t link_payload_len = (slip_header[1] >> 4) | (slip_header[2] << 4);
|
||||
|
||||
log_debug("process_frame, reliable %u, packet type %u, seq_nr %u, ack_nr %u , dic %u, payload 0x%04x bytes", reliable_packet, link_packet_type, seq_nr, ack_nr, data_integrity_check_present, frame_size_without_header);
|
||||
@ -543,13 +505,13 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
const uint8_t sync_response_bcsp[] = {0x01, 0x7a, 0x06, 0x10};
|
||||
if (memcmp(sync_response_bcsp, slip_header, 4) == 0){
|
||||
log_info("detected BSCP SYNC sent with Even Parity -> discard frame and enable Even Parity");
|
||||
btstack_uart->set_parity(1);
|
||||
btstack_uart->set_parity(BTSTACK_UART_PARITY_EVEN);
|
||||
return;
|
||||
}
|
||||
|
||||
// validate header checksum
|
||||
uint8_t header_checksum = slip_header[0] + slip_header[1] + slip_header[2] + slip_header[3];
|
||||
if (header_checksum != 0xffu){
|
||||
if (header_checksum != 0xff){
|
||||
log_info("header checksum 0x%02x (instead of 0xff)", header_checksum);
|
||||
return;
|
||||
}
|
||||
@ -565,7 +527,7 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
// validate data integrity check
|
||||
if (data_integrity_check_present){
|
||||
uint16_t dic_packet = big_endian_read_16(slip_payload, received_payload_len);
|
||||
uint16_t dic_calculate = crc16_calc_for_slip_frame(slip_header, slip_payload, received_payload_len);
|
||||
uint16_t dic_calculate = crc16_calc_for_slip_frame(slip_header, 4 + received_payload_len);
|
||||
if (dic_packet != dic_calculate){
|
||||
log_info("expected dic value 0x%04x but got 0x%04x", dic_calculate, dic_packet);
|
||||
return;
|
||||
@ -610,7 +572,7 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
}
|
||||
if (memcmp(slip_payload, link_control_config_response, link_control_config_response_prefix_len) == 0){
|
||||
uint8_t config = slip_payload[2];
|
||||
link_peer_supports_data_integrity_check = (config & 0x10u) != 0u;
|
||||
link_peer_supports_data_integrity_check = (config & 0x10) != 0;
|
||||
log_info("link received config response 0x%02x, data integrity check supported %u", config, link_peer_supports_data_integrity_check);
|
||||
link_state = LINK_ACTIVE;
|
||||
btstack_run_loop_remove_timer(&link_timer);
|
||||
@ -639,10 +601,10 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
}
|
||||
|
||||
// Process ACKs in reliable packet and explicit ack packets
|
||||
if (reliable_packet || (link_packet_type == LINK_ACKNOWLEDGEMENT_TYPE)){
|
||||
if (reliable_packet || link_packet_type == LINK_ACKNOWLEDGEMENT_TYPE){
|
||||
// our packet is good if the remote expects our seq nr + 1
|
||||
int next_seq_nr = hci_transport_link_inc_seq_nr(link_seq_nr);
|
||||
if (hci_transport_link_have_outgoing_packet() && (next_seq_nr == ack_nr)){
|
||||
if (hci_transport_link_have_outgoing_packet() && next_seq_nr == ack_nr){
|
||||
log_debug("outoing packet with seq %u ack'ed", link_seq_nr);
|
||||
link_seq_nr = next_seq_nr;
|
||||
hci_transport_link_clear_queue();
|
||||
@ -704,9 +666,6 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
// reset inactvitiy timer
|
||||
hci_transport_inactivity_timer_set();
|
||||
break;
|
||||
default:
|
||||
// invalid packet type, ignore
|
||||
break;
|
||||
}
|
||||
|
||||
break;
|
||||
@ -717,13 +676,13 @@ static void hci_transport_h5_process_frame(uint16_t frame_size){
|
||||
hci_transport_link_run();
|
||||
}
|
||||
|
||||
// recommendet time until resend: 3 * time of largest packet
|
||||
// recommended time until resend: 3 * time of largest packet
|
||||
static uint16_t hci_transport_link_calc_resend_timeout(uint32_t baudrate){
|
||||
uint32_t max_packet_size_in_bit = (HCI_INCOMING_PACKET_BUFFER_SIZE + 6) << 3;
|
||||
uint32_t t_max_x3_ms = max_packet_size_in_bit * 3000u / baudrate;
|
||||
uint32_t t_max_x3_ms = max_packet_size_in_bit * 3000 / baudrate;
|
||||
|
||||
// allow for BTstack logging and other delays
|
||||
t_max_x3_ms += 50u;
|
||||
t_max_x3_ms += 50;
|
||||
|
||||
log_info("resend timeout for %"PRIu32" baud: %u ms", baudrate, (int) t_max_x3_ms);
|
||||
return t_max_x3_ms;
|
||||
@ -735,52 +694,29 @@ static void hci_transport_link_update_resend_timeout(uint32_t baudrate){
|
||||
|
||||
/// H5 Interface
|
||||
|
||||
static uint8_t hci_transport_link_read_byte;
|
||||
static int hci_transport_h5_active;
|
||||
|
||||
static void hci_transport_h5_read_next_byte(void){
|
||||
btstack_uart->receive_block(&hci_transport_link_read_byte, 1);
|
||||
static void hci_transport_h5_frame_received(uint16_t frame_size){
|
||||
hci_transport_h5_process_frame(frame_size);
|
||||
hci_transport_slip_init();
|
||||
}
|
||||
|
||||
// track time receiving SLIP frame
|
||||
static uint32_t hci_transport_h5_receive_start;
|
||||
static void hci_transport_h5_block_received(void){
|
||||
if (hci_transport_h5_active == 0) return;
|
||||
static void hci_transport_h5_frame_sent(void){
|
||||
|
||||
// track start time when receiving first byte // a bit hackish
|
||||
if ((hci_transport_h5_receive_start == 0u) && (hci_transport_link_read_byte != BTSTACK_SLIP_SOF)){
|
||||
hci_transport_h5_receive_start = btstack_run_loop_get_time_ms();
|
||||
}
|
||||
btstack_slip_decoder_process(hci_transport_link_read_byte);
|
||||
uint16_t frame_size = btstack_slip_decoder_frame_size();
|
||||
if (frame_size) {
|
||||
// track time
|
||||
uint32_t packet_receive_time = btstack_run_loop_get_time_ms() - hci_transport_h5_receive_start;
|
||||
uint32_t nominal_time = (frame_size + 6u) * 10u * 1000u / uart_config.baudrate;
|
||||
UNUSED(nominal_time);
|
||||
UNUSED(packet_receive_time);
|
||||
log_info("slip frame time %u ms for %u decoded bytes. nomimal time %u ms", (int) packet_receive_time, frame_size, (int) nominal_time);
|
||||
// reset state
|
||||
hci_transport_h5_receive_start = 0;
|
||||
//
|
||||
hci_transport_h5_process_frame(frame_size);
|
||||
hci_transport_slip_init();
|
||||
}
|
||||
hci_transport_h5_read_next_byte();
|
||||
}
|
||||
|
||||
static void hci_transport_h5_block_sent(void){
|
||||
if (hci_transport_h5_active == 0) return;
|
||||
|
||||
// check if more data to send
|
||||
if (btstack_slip_encoder_has_data()){
|
||||
hci_transport_slip_send_next_chunk();
|
||||
return;
|
||||
// restore DIC and clear flag
|
||||
if (hci_packet_restore_dic_address){
|
||||
little_endian_store_16(hci_packet_restore_dic_address, 0, hci_packet_restore_dic_data);
|
||||
hci_packet_restore_dic_address = NULL;
|
||||
}
|
||||
|
||||
// done
|
||||
slip_write_active = 0;
|
||||
|
||||
// baudrate change pending?
|
||||
if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SET_BAUDRATE){
|
||||
hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SET_BAUDRATE;
|
||||
btstack_uart->set_baudrate(link_new_baudrate);
|
||||
hci_transport_link_update_resend_timeout(link_new_baudrate);
|
||||
}
|
||||
|
||||
// enter sleep mode after sending sleep message
|
||||
if (hci_transport_link_actions & HCI_TRANSPORT_LINK_ENTER_SLEEP){
|
||||
hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_ENTER_SLEEP;
|
||||
@ -793,6 +729,14 @@ static void hci_transport_h5_block_sent(void){
|
||||
hci_transport_h5_emit_sleep_state(1);
|
||||
}
|
||||
|
||||
// SCO packets are sent as unreliable, so we're done now
|
||||
if (hci_packet_type == HCI_SCO_DATA_PACKET){
|
||||
hci_transport_link_clear_queue();
|
||||
// notify upper stack that it can send again
|
||||
uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0};
|
||||
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
|
||||
}
|
||||
|
||||
hci_transport_link_run();
|
||||
}
|
||||
|
||||
@ -807,8 +751,6 @@ static void hci_transport_h5_init(const void * transport_config){
|
||||
return;
|
||||
}
|
||||
|
||||
hci_transport_h5_active = 0;
|
||||
|
||||
// extract UART config from transport config
|
||||
hci_transport_config_uart_t * hci_transport_config_uart = (hci_transport_config_uart_t*) transport_config;
|
||||
uart_config.baudrate = hci_transport_config_uart->baudrate_init;
|
||||
@ -817,8 +759,8 @@ static void hci_transport_h5_init(const void * transport_config){
|
||||
|
||||
// setup UART driver
|
||||
btstack_uart->init(&uart_config);
|
||||
btstack_uart->set_block_received(&hci_transport_h5_block_received);
|
||||
btstack_uart->set_block_sent(&hci_transport_h5_block_sent);
|
||||
btstack_uart->set_frame_received(&hci_transport_h5_frame_received);
|
||||
btstack_uart->set_frame_sent(&hci_transport_h5_frame_sent);
|
||||
}
|
||||
|
||||
static int hci_transport_h5_open(void){
|
||||
@ -830,7 +772,7 @@ static int hci_transport_h5_open(void){
|
||||
//
|
||||
if (hci_transport_bcsp_mode){
|
||||
log_info("enable even parity for BCSP mode");
|
||||
btstack_uart->set_parity(1);
|
||||
btstack_uart->set_parity(BTSTACK_UART_PARITY_EVEN);
|
||||
}
|
||||
|
||||
// check if wake on RX can be used
|
||||
@ -849,21 +791,16 @@ static int hci_transport_h5_open(void){
|
||||
// setup resend timeout
|
||||
hci_transport_link_update_resend_timeout(uart_config.baudrate);
|
||||
|
||||
// init slip parser state machine
|
||||
hci_transport_slip_init();
|
||||
|
||||
// init link management - already starts syncing
|
||||
hci_transport_link_init();
|
||||
|
||||
// start receiving
|
||||
hci_transport_h5_active = 1;
|
||||
hci_transport_h5_read_next_byte();
|
||||
hci_transport_slip_init();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int hci_transport_h5_close(void){
|
||||
hci_transport_h5_active = 0;
|
||||
return btstack_uart->close();
|
||||
}
|
||||
|
||||
@ -872,7 +809,7 @@ static void hci_transport_h5_register_packet_handler(void (*handler)(uint8_t pac
|
||||
}
|
||||
|
||||
static int hci_transport_h5_can_send_packet_now(uint8_t packet_type){
|
||||
int res = !hci_transport_link_have_outgoing_packet() && (link_state == LINK_ACTIVE);
|
||||
int res = !hci_transport_link_have_outgoing_packet() && link_state == LINK_ACTIVE;
|
||||
// log_info("can_send_packet_now: %u", res);
|
||||
return res;
|
||||
}
|
||||
@ -905,11 +842,19 @@ static int hci_transport_h5_send_packet(uint8_t packet_type, uint8_t *packet, in
|
||||
|
||||
static int hci_transport_h5_set_baudrate(uint32_t baudrate){
|
||||
|
||||
log_info("set_baudrate %"PRIu32, baudrate);
|
||||
log_info("set_baudrate %"PRIu32", h5 actions %x", baudrate, hci_transport_link_actions);
|
||||
// Baudrate is changed after an HCI Baudrate Change Command, which usually causes an HCI Event Commmand Complete
|
||||
// Before changing the baudrate, the HCI Command Complete needs to get acknowledged
|
||||
if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_ACK_PACKET){
|
||||
hci_transport_link_actions |= HCI_TRANSPORT_LINK_SET_BAUDRATE;
|
||||
link_new_baudrate = baudrate;
|
||||
hci_transport_link_run();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int res = btstack_uart->set_baudrate(baudrate);
|
||||
|
||||
if (res) return res;
|
||||
uart_config.baudrate = baudrate;
|
||||
hci_transport_link_update_resend_timeout(baudrate);
|
||||
return 0;
|
||||
}
|
||||
@ -928,22 +873,21 @@ static void hci_transport_h5_reset_link(void){
|
||||
hci_transport_link_init();
|
||||
}
|
||||
|
||||
static const hci_transport_t hci_transport_h5 = {
|
||||
/* const char * name; */ "H5",
|
||||
/* void (*init) (const void *transport_config); */ &hci_transport_h5_init,
|
||||
/* int (*open)(void); */ &hci_transport_h5_open,
|
||||
/* int (*close)(void); */ &hci_transport_h5_close,
|
||||
/* void (*register_packet_handler)(void (*handler)(...); */ &hci_transport_h5_register_packet_handler,
|
||||
/* int (*can_send_packet_now)(uint8_t packet_type); */ &hci_transport_h5_can_send_packet_now,
|
||||
/* int (*send_packet)(...); */ &hci_transport_h5_send_packet,
|
||||
/* int (*set_baudrate)(uint32_t baudrate); */ &hci_transport_h5_set_baudrate,
|
||||
/* void (*reset_link)(void); */ &hci_transport_h5_reset_link,
|
||||
/* void (*set_sco_config)(uint16_t voice_setting, int num_connections); */ NULL,
|
||||
};
|
||||
|
||||
// configure and return h5 singleton
|
||||
const hci_transport_t * hci_transport_h5_instance(const btstack_uart_block_t * uart_driver) {
|
||||
|
||||
static const hci_transport_t hci_transport_h5 = {
|
||||
/* const char * name; */ "H5",
|
||||
/* void (*init) (const void *transport_config); */ &hci_transport_h5_init,
|
||||
/* int (*open)(void); */ &hci_transport_h5_open,
|
||||
/* int (*close)(void); */ &hci_transport_h5_close,
|
||||
/* void (*register_packet_handler)(void (*handler)(...); */ &hci_transport_h5_register_packet_handler,
|
||||
/* int (*can_send_packet_now)(uint8_t packet_type); */ &hci_transport_h5_can_send_packet_now,
|
||||
/* int (*send_packet)(...); */ &hci_transport_h5_send_packet,
|
||||
/* int (*set_baudrate)(uint32_t baudrate); */ &hci_transport_h5_set_baudrate,
|
||||
/* void (*reset_link)(void); */ &hci_transport_h5_reset_link,
|
||||
/* void (*set_sco_config)(uint16_t voice_setting, int num_connections); */ NULL,
|
||||
};
|
||||
|
||||
const hci_transport_t * hci_transport_h5_instance(const btstack_uart_t * uart_driver) {
|
||||
btstack_uart = uart_driver;
|
||||
return &hci_transport_h5;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user