diff --git a/src/hci_transport.h b/src/hci_transport.h index 8767e124a..9927d0740 100644 --- a/src/hci_transport.h +++ b/src/hci_transport.h @@ -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 diff --git a/src/hci_transport_h5.c b/src/hci_transport_h5.c index a8ec2645b..601fce37c 100644 --- a/src/hci_transport_h5.c +++ b/src/hci_transport_h5.c @@ -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 -#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; }