1 /* 2 * Copyright (C) 2016 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN 24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define BTSTACK_FILE__ "hci_transport_h5.c" 39 40 /* 41 * hci_transport_h5.c 42 * 43 * HCI Transport API implementation for basic H5 protocol based on UART driver with SLIP support 44 */ 45 46 #include "btstack_config.h" 47 48 #ifdef ENABLE_H5 49 50 #include "hci_transport_h5.h" 51 52 #include "btstack_debug.h" 53 #include "hci.h" 54 #include "hci_transport.h" 55 56 #include <inttypes.h> 57 58 // assert pre-buffer for packet type is available 59 #if !defined(HCI_OUTGOING_PRE_BUFFER_SIZE) || (HCI_OUTGOING_PRE_BUFFER_SIZE < 4) 60 #error HCI_OUTGOING_PRE_BUFFER_SIZE not defined or smaller than 4. Please update hci.h 61 #endif 62 63 typedef enum { 64 LINK_UNINITIALIZED, 65 LINK_INITIALIZED, 66 LINK_ACTIVE 67 } hci_transport_link_state_t; 68 69 typedef enum { 70 HCI_TRANSPORT_LINK_SEND_SYNC = 1 << 0, 71 HCI_TRANSPORT_LINK_SEND_SYNC_RESPONSE = 1 << 1, 72 HCI_TRANSPORT_LINK_SEND_CONFIG = 1 << 2, 73 HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE_EMPTY = 1 << 3, 74 HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE = 1 << 4, 75 HCI_TRANSPORT_LINK_SEND_SLEEP = 1 << 5, 76 HCI_TRANSPORT_LINK_SEND_WOKEN = 1 << 6, 77 HCI_TRANSPORT_LINK_SEND_WAKEUP = 1 << 7, 78 HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET = 1 << 8, 79 HCI_TRANSPORT_LINK_SEND_ACK_PACKET = 1 << 9, 80 HCI_TRANSPORT_LINK_ENTER_SLEEP = 1 << 10, 81 HCI_TRANSPORT_LINK_SET_BAUDRATE = 1 << 11, 82 83 } hci_transport_link_actions_t; 84 85 // Configuration Field. No packet buffers -> sliding window = 1, no OOF flow control, support data integrity check 86 #define LINK_CONFIG_SLIDING_WINDOW_SIZE 1 87 #define LINK_CONFIG_OOF_FLOW_CONTROL 0 88 #define LINK_CONFIG_DATA_INTEGRITY_CHECK 1 89 #define LINK_CONFIG_VERSION_NR 0 90 #define LINK_CONFIG_FIELD (LINK_CONFIG_SLIDING_WINDOW_SIZE | (LINK_CONFIG_OOF_FLOW_CONTROL << 3) | (LINK_CONFIG_DATA_INTEGRITY_CHECK << 4) | (LINK_CONFIG_VERSION_NR << 5)) 91 92 // periodic sending during link establishment 93 #define LINK_PERIOD_MS 250 94 95 // resend wakeup 96 #define LINK_WAKEUP_MS 50 97 98 // additional packet types 99 #define LINK_ACKNOWLEDGEMENT_TYPE 0x00 100 #define LINK_CONTROL_PACKET_TYPE 0x0f 101 102 // --- 103 static const uint8_t link_control_sync[] = { 0x01, 0x7e}; 104 static const uint8_t link_control_sync_response[] = { 0x02, 0x7d}; 105 static const uint8_t link_control_config[] = { 0x03, 0xfc, LINK_CONFIG_FIELD}; 106 static const uint8_t link_control_config_prefix_len = 2; 107 static const uint8_t link_control_config_response_empty[] = { 0x04, 0x7b}; 108 static const uint8_t link_control_config_response[] = { 0x04, 0x7b, LINK_CONFIG_FIELD}; 109 static const uint8_t link_control_config_response_prefix_len = 2; 110 static const uint8_t link_control_wakeup[] = { 0x05, 0xfa}; 111 static const uint8_t link_control_woken[] = { 0x06, 0xf9}; 112 static const uint8_t link_control_sleep[] = { 0x07, 0x78}; 113 114 // max size of link control messages 115 #define LINK_CONTROL_MAX_LEN 3 116 117 // incoming pre-bufffer + 4 bytes H5 header + max(acl header + acl payload, event header + event data) + 2 bytes opt CRC 118 static uint8_t hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 6 + HCI_INCOMING_PACKET_BUFFER_SIZE]; 119 120 // outgoing slip encoded buffer. +4 to assert that DIC fits in buffer. +1 to assert that last SOF fits in buffer. 121 static int slip_write_active; 122 123 // H5 Link State 124 static hci_transport_link_state_t link_state; 125 static btstack_timer_source_t link_timer; 126 static uint8_t link_seq_nr; 127 static uint8_t link_ack_nr; 128 static uint16_t link_resend_timeout_ms; 129 static uint8_t link_peer_asleep; 130 static uint8_t link_peer_supports_data_integrity_check; 131 static uint32_t link_new_baudrate; 132 133 // auto sleep-mode 134 static btstack_timer_source_t inactivity_timer; 135 static uint16_t link_inactivity_timeout_ms; // auto-sleep if set 136 137 // Outgoing packet 138 static uint8_t hci_packet_type; 139 static uint16_t hci_packet_size; 140 static uint8_t * hci_packet; 141 142 // restore 2 bytes temp overwritten by DIC 143 static uint8_t * hci_packet_restore_dic_address; 144 static uint16_t hci_packet_restore_dic_data; 145 146 // hci packet handler 147 static void (*packet_handler)(uint8_t packet_type, uint8_t *packet, uint16_t size); 148 149 static int hci_transport_link_actions; 150 151 // UART Driver + Config 152 static const btstack_uart_t * btstack_uart; 153 static btstack_uart_config_t uart_config; 154 static btstack_uart_sleep_mode_t btstack_uart_sleep_mode; 155 static int hci_transport_bcsp_mode; 156 157 // Prototypes 158 static int hci_transport_link_have_outgoing_packet(void); 159 static void hci_transport_h5_frame_sent(void); 160 static void hci_transport_h5_process_frame(uint16_t frame_size); 161 static void hci_transport_link_run(void); 162 static void hci_transport_link_send_queued_packet(void); 163 static void hci_transport_link_set_timer(uint16_t timeout_ms); 164 static void hci_transport_link_timeout_handler(btstack_timer_source_t * timer); 165 static void hci_transport_slip_init(void); 166 167 // ----------------------------- 168 // CRC16-CCITT Calculation - compromise: use 32 byte table - 512 byte table would be faster, but that's too large 169 170 static const uint16_t crc16_ccitt_table[] ={ 171 0x0000, 0x1081, 0x2102, 0x3183, 172 0x4204, 0x5285, 0x6306, 0x7387, 173 0x8408, 0x9489, 0xa50a, 0xb58b, 174 0xc60c, 0xd68d, 0xe70e, 0xf78f 175 }; 176 177 static uint16_t crc16_ccitt_update (uint16_t crc, uint8_t ch){ 178 crc = (crc >> 4) ^ crc16_ccitt_table[(crc ^ ch) & 0x000f]; 179 crc = (crc >> 4) ^ crc16_ccitt_table[(crc ^ (ch >> 4)) & 0x000f]; 180 return crc; 181 } 182 183 static uint16_t btstack_reverse_bits_16(uint16_t value){ 184 int reverse = 0; 185 int i; 186 for (i = 0; i < 16; i++) { 187 reverse = reverse << 1; 188 reverse |= value & 1; 189 value = value >> 1; 190 } 191 return reverse; 192 } 193 194 static uint16_t crc16_calc_for_slip_frame(const uint8_t * data, uint16_t len){ 195 int i; 196 uint16_t crc = 0xffff; 197 for (i=0 ; i < len ; i++){ 198 crc = crc16_ccitt_update(crc, data[i]); 199 } 200 return btstack_reverse_bits_16(crc); 201 } 202 203 // ----------------------------- 204 static void hci_transport_inactivity_timeout_handler(btstack_timer_source_t * ts){ 205 log_info("inactivity timeout. link state %d, peer asleep %u, actions 0x%02x, outgoing packet %u", 206 link_state, link_peer_asleep, hci_transport_link_actions, hci_transport_link_have_outgoing_packet()); 207 if (hci_transport_link_have_outgoing_packet()) return; 208 if (link_state != LINK_ACTIVE) return; 209 if (hci_transport_link_actions) return; 210 if (link_peer_asleep) return; 211 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SLEEP; 212 hci_transport_link_run(); 213 } 214 215 static void hci_transport_inactivity_timer_set(void){ 216 if (!link_inactivity_timeout_ms) return; 217 btstack_run_loop_set_timer_handler(&inactivity_timer, &hci_transport_inactivity_timeout_handler); 218 btstack_run_loop_set_timer(&inactivity_timer, link_inactivity_timeout_ms); 219 btstack_run_loop_remove_timer(&inactivity_timer); 220 btstack_run_loop_add_timer(&inactivity_timer); 221 } 222 223 static void hci_transport_slip_init(void){ 224 btstack_uart->receive_frame(&hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE], 6 + HCI_INCOMING_PACKET_BUFFER_SIZE); 225 } 226 227 // H5 Three-Wire Implementation 228 229 static void hci_transport_link_calc_header(uint8_t * header, 230 uint8_t sequence_nr, 231 uint8_t acknowledgement_nr, 232 uint8_t data_integrity_check_present, 233 uint8_t reliable_packet, 234 uint8_t packet_type, 235 uint16_t payload_length){ 236 237 // unreliable packets have seq_nr = 0 238 if (reliable_packet == 0) { 239 sequence_nr = 0; 240 } 241 242 header[0] = sequence_nr | (acknowledgement_nr << 3) | (data_integrity_check_present << 6) | (reliable_packet << 7); 243 header[1] = packet_type | ((payload_length & 0x0f) << 4); 244 header[2] = payload_length >> 4; 245 header[3] = 0xff - (header[0] + header[1] + header[2]); 246 } 247 248 // Store DIC after packet, assuming 2 bytes in buffer - keep track of overwritten bytes - relevant for fragmented packets 249 static void hci_transport_slip_send_frame_with_dic(uint8_t * frame, uint16_t frame_size){ 250 int slip_outgoing_dic_present = frame[0] & 0x40; 251 if (slip_outgoing_dic_present){ 252 // preserved data at DIC location 253 hci_packet_restore_dic_address = &frame[frame_size]; 254 hci_packet_restore_dic_data = little_endian_read_16(hci_packet_restore_dic_address, 0); 255 // calc and set DIC 256 uint16_t data_integrity_check = crc16_calc_for_slip_frame(frame, frame_size); 257 big_endian_store_16(frame, frame_size, data_integrity_check); 258 frame_size += 2; 259 } 260 261 // set slip send active and go 262 slip_write_active = 1; 263 btstack_uart->send_frame(frame, frame_size); 264 } 265 266 static void hci_transport_link_send_queued_packet(void){ 267 uint8_t * buffer = hci_packet - 4; 268 uint16_t buffer_size = hci_packet_size + 4; 269 270 // setup header 271 int reliable = hci_packet_type == HCI_SCO_DATA_PACKET ? 0 : 1; 272 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); 273 274 // send frame with dic 275 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); 276 log_debug_hexdump(hci_packet, hci_packet_size); 277 hci_transport_slip_send_frame_with_dic(buffer, buffer_size); 278 279 // reset inactvitiy timer 280 hci_transport_inactivity_timer_set(); 281 } 282 283 static void hci_transport_link_send_control(const uint8_t * message, int message_len){ 284 uint8_t buffer[4 + LINK_CONTROL_MAX_LEN + 2]; 285 uint16_t buffer_size = 4 + message_len; 286 287 // setup header 288 hci_transport_link_calc_header(buffer, 0, 0, link_peer_supports_data_integrity_check, 0, LINK_CONTROL_PACKET_TYPE, message_len); 289 290 // setup payload 291 memcpy(&buffer[4], message, message_len); 292 293 // send frame with dic 294 log_debug("send control: size %u, append dic %u", message_len, link_peer_supports_data_integrity_check); 295 log_debug_hexdump(message, message_len); 296 hci_transport_slip_send_frame_with_dic(buffer, buffer_size); 297 } 298 299 static void hci_transport_link_send_ack_packet(void){ 300 // Pure ACK package is without DIC as there is no payload either 301 log_debug("send ack %u", link_ack_nr); 302 uint8_t header[4]; 303 hci_transport_link_calc_header(header, 0, link_ack_nr, 0, 0, LINK_ACKNOWLEDGEMENT_TYPE, 0); 304 hci_transport_slip_send_frame_with_dic(header, sizeof(header)); 305 } 306 307 static void hci_transport_link_send_sync(void){ 308 log_debug("link send sync"); 309 hci_transport_link_send_control(link_control_sync, sizeof(link_control_sync)); 310 } 311 312 static void hci_transport_link_send_sync_response(void){ 313 log_debug("link send sync response"); 314 hci_transport_link_send_control(link_control_sync_response, sizeof(link_control_sync_response)); 315 } 316 317 static void hci_transport_link_send_config(void){ 318 log_debug("link send config"); 319 hci_transport_link_send_control(link_control_config, sizeof(link_control_config)); 320 } 321 322 static void hci_transport_link_send_config_response(void){ 323 log_debug("link send config response"); 324 hci_transport_link_send_control(link_control_config_response, sizeof(link_control_config_response)); 325 } 326 327 static void hci_transport_link_send_config_response_empty(void){ 328 log_debug("link send config response empty"); 329 hci_transport_link_send_control(link_control_config_response_empty, sizeof(link_control_config_response_empty)); 330 } 331 332 static void hci_transport_link_send_woken(void){ 333 log_debug("link send woken"); 334 hci_transport_link_send_control(link_control_woken, sizeof(link_control_woken)); 335 } 336 337 static void hci_transport_link_send_wakeup(void){ 338 log_debug("link send wakeup"); 339 hci_transport_link_send_control(link_control_wakeup, sizeof(link_control_wakeup)); 340 } 341 342 static void hci_transport_link_send_sleep(void){ 343 log_debug("link send sleep"); 344 hci_transport_link_send_control(link_control_sleep, sizeof(link_control_sleep)); 345 } 346 347 static void hci_transport_link_run(void){ 348 // exit if outgoing active 349 if (slip_write_active) return; 350 351 // process queued requests 352 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_SYNC){ 353 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_SYNC; 354 hci_transport_link_send_sync(); 355 return; 356 } 357 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_SYNC_RESPONSE){ 358 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_SYNC_RESPONSE; 359 hci_transport_link_send_sync_response(); 360 return; 361 } 362 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_CONFIG){ 363 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_CONFIG; 364 hci_transport_link_send_config(); 365 return; 366 } 367 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE){ 368 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE; 369 hci_transport_link_send_config_response(); 370 return; 371 } 372 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE_EMPTY){ 373 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE_EMPTY; 374 hci_transport_link_send_config_response_empty(); 375 return; 376 } 377 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_WOKEN){ 378 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_WOKEN; 379 hci_transport_link_send_woken(); 380 return; 381 } 382 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_WAKEUP){ 383 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_WAKEUP; 384 hci_transport_link_send_wakeup(); 385 return; 386 } 387 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET){ 388 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET; 389 // packet already contains ack, no need to send addtitional one 390 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_ACK_PACKET; 391 hci_transport_link_send_queued_packet(); 392 return; 393 } 394 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_ACK_PACKET){ 395 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_ACK_PACKET; 396 hci_transport_link_send_ack_packet(); 397 return; 398 } 399 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_SLEEP){ 400 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SEND_SLEEP; 401 hci_transport_link_actions |= HCI_TRANSPORT_LINK_ENTER_SLEEP; 402 link_peer_asleep = 1; 403 hci_transport_link_send_sleep(); 404 return; 405 } 406 } 407 408 static void hci_transport_link_set_timer(uint16_t timeout_ms){ 409 btstack_run_loop_set_timer_handler(&link_timer, &hci_transport_link_timeout_handler); 410 btstack_run_loop_set_timer(&link_timer, timeout_ms); 411 btstack_run_loop_add_timer(&link_timer); 412 } 413 414 static void hci_transport_link_timeout_handler(btstack_timer_source_t * timer){ 415 switch (link_state){ 416 case LINK_UNINITIALIZED: 417 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC; 418 hci_transport_link_set_timer(LINK_PERIOD_MS); 419 break; 420 case LINK_INITIALIZED: 421 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG; 422 hci_transport_link_set_timer(LINK_PERIOD_MS); 423 break; 424 case LINK_ACTIVE: 425 if (!hci_transport_link_have_outgoing_packet()){ 426 log_info("h5 timeout while active, but no outgoing packet"); 427 return; 428 } 429 if (link_peer_asleep){ 430 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_WAKEUP; 431 hci_transport_link_set_timer(LINK_WAKEUP_MS); 432 break; 433 } 434 // resend packet 435 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET; 436 hci_transport_link_set_timer(link_resend_timeout_ms); 437 break; 438 default: 439 break; 440 } 441 442 hci_transport_link_run(); 443 } 444 445 static void hci_transport_link_init(void){ 446 link_state = LINK_UNINITIALIZED; 447 link_peer_asleep = 0; 448 link_peer_supports_data_integrity_check = 0; 449 450 // get started 451 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC; 452 hci_transport_link_set_timer(LINK_PERIOD_MS); 453 hci_transport_link_run(); 454 } 455 456 static int hci_transport_link_inc_seq_nr(int seq_nr){ 457 return (seq_nr + 1) & 0x07; 458 } 459 460 static int hci_transport_link_have_outgoing_packet(void){ 461 return hci_packet != 0; 462 } 463 464 static void hci_transport_link_clear_queue(void){ 465 btstack_run_loop_remove_timer(&link_timer); 466 hci_packet = NULL; 467 } 468 469 static void hci_transport_h5_queue_packet(uint8_t packet_type, uint8_t *packet, int size){ 470 hci_packet = packet; 471 hci_packet_type = packet_type; 472 hci_packet_size = size; 473 } 474 475 static void hci_transport_h5_emit_sleep_state(int sleep_active){ 476 static int last_state = 0; 477 if (sleep_active == last_state) return; 478 last_state = sleep_active; 479 480 log_info("emit_sleep_state: %u", sleep_active); 481 uint8_t event[3]; 482 event[0] = HCI_EVENT_TRANSPORT_SLEEP_MODE; 483 event[1] = sizeof(event) - 2; 484 event[2] = sleep_active; 485 packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); 486 } 487 488 static void hci_transport_h5_process_frame(uint16_t frame_size){ 489 490 if (frame_size < 4) return; 491 492 uint8_t * slip_header = &hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE]; 493 uint8_t * slip_payload = &hci_packet_with_pre_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 4]; 494 int frame_size_without_header = frame_size - 4; 495 496 uint8_t seq_nr = slip_header[0] & 0x07; 497 uint8_t ack_nr = (slip_header[0] >> 3) & 0x07; 498 uint8_t data_integrity_check_present = (slip_header[0] & 0x40) != 0; 499 uint8_t reliable_packet = (slip_header[0] & 0x80) != 0; 500 uint8_t link_packet_type = slip_header[1] & 0x0f; 501 uint16_t link_payload_len = (slip_header[1] >> 4) | (slip_header[2] << 4); 502 503 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); 504 log_debug_hexdump(slip_header, 4); 505 log_debug_hexdump(slip_payload, frame_size_without_header); 506 507 // CSR 8811 does not seem to auto-detect H5 mode and sends data with even parity. 508 // if this byte sequence is detected, just enable even parity 509 const uint8_t sync_response_bcsp[] = {0x01, 0x7a, 0x06, 0x10}; 510 if (memcmp(sync_response_bcsp, slip_header, 4) == 0){ 511 log_info("detected BSCP SYNC sent with Even Parity -> discard frame and enable Even Parity"); 512 btstack_uart->set_parity(BTSTACK_UART_PARITY_EVEN); 513 return; 514 } 515 516 // validate header checksum 517 uint8_t header_checksum = slip_header[0] + slip_header[1] + slip_header[2] + slip_header[3]; 518 if (header_checksum != 0xff){ 519 log_info("header checksum 0x%02x (instead of 0xff)", header_checksum); 520 return; 521 } 522 523 // validate payload length 524 int data_integrity_len = data_integrity_check_present ? 2 : 0; 525 uint16_t received_payload_len = frame_size_without_header - data_integrity_len; 526 if (link_payload_len != received_payload_len){ 527 log_info("expected payload len %u but got %u", link_payload_len, received_payload_len); 528 return; 529 } 530 531 // validate data integrity check 532 if (data_integrity_check_present){ 533 uint16_t dic_packet = big_endian_read_16(slip_payload, received_payload_len); 534 uint16_t dic_calculate = crc16_calc_for_slip_frame(slip_header, 4 + received_payload_len); 535 if (dic_packet != dic_calculate){ 536 log_info("expected dic value 0x%04x but got 0x%04x", dic_calculate, dic_packet); 537 return; 538 } 539 } 540 541 switch (link_state){ 542 case LINK_UNINITIALIZED: 543 if (link_packet_type != LINK_CONTROL_PACKET_TYPE) break; 544 if (memcmp(slip_payload, link_control_sync, sizeof(link_control_sync)) == 0){ 545 log_debug("link received sync"); 546 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC_RESPONSE; 547 break; 548 } 549 if (memcmp(slip_payload, link_control_sync_response, sizeof(link_control_sync_response)) == 0){ 550 log_debug("link received sync response"); 551 link_state = LINK_INITIALIZED; 552 btstack_run_loop_remove_timer(&link_timer); 553 log_info("link initialized"); 554 // 555 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG; 556 hci_transport_link_set_timer(LINK_PERIOD_MS); 557 break; 558 } 559 break; 560 case LINK_INITIALIZED: 561 if (link_packet_type != LINK_CONTROL_PACKET_TYPE) break; 562 if (memcmp(slip_payload, link_control_sync, sizeof(link_control_sync)) == 0){ 563 log_debug("link received sync"); 564 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_SYNC_RESPONSE; 565 break; 566 } 567 if (memcmp(slip_payload, link_control_config, link_control_config_prefix_len) == 0){ 568 if (link_payload_len == link_control_config_prefix_len){ 569 log_debug("link received config, no config field"); 570 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE_EMPTY; 571 } else { 572 log_debug("link received config, 0x%02x", slip_payload[2]); 573 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE; 574 } 575 break; 576 } 577 if (memcmp(slip_payload, link_control_config_response, link_control_config_response_prefix_len) == 0){ 578 uint8_t config = slip_payload[2]; 579 link_peer_supports_data_integrity_check = (config & 0x10) != 0; 580 log_info("link received config response 0x%02x, data integrity check supported %u", config, link_peer_supports_data_integrity_check); 581 link_state = LINK_ACTIVE; 582 btstack_run_loop_remove_timer(&link_timer); 583 log_info("link activated"); 584 // 585 link_seq_nr = 0; 586 link_ack_nr = 0; 587 // notify upper stack that it can start 588 uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0}; 589 packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); 590 break; 591 } 592 break; 593 case LINK_ACTIVE: 594 595 // validate packet sequence nr in reliable packets (check for out of sequence error) 596 if (reliable_packet){ 597 if (seq_nr != link_ack_nr){ 598 log_info("expected seq nr %u, but received %u", link_ack_nr, seq_nr); 599 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_ACK_PACKET; 600 break; 601 } 602 // ack packet right away 603 link_ack_nr = hci_transport_link_inc_seq_nr(link_ack_nr); 604 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_ACK_PACKET; 605 } 606 607 // Process ACKs in reliable packet and explicit ack packets 608 if (reliable_packet || link_packet_type == LINK_ACKNOWLEDGEMENT_TYPE){ 609 // our packet is good if the remote expects our seq nr + 1 610 int next_seq_nr = hci_transport_link_inc_seq_nr(link_seq_nr); 611 if (hci_transport_link_have_outgoing_packet() && next_seq_nr == ack_nr){ 612 log_debug("outoing packet with seq %u ack'ed", link_seq_nr); 613 link_seq_nr = next_seq_nr; 614 hci_transport_link_clear_queue(); 615 616 // notify upper stack that it can send again 617 uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0}; 618 packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); 619 } 620 } 621 622 switch (link_packet_type){ 623 case LINK_CONTROL_PACKET_TYPE: 624 if (memcmp(slip_payload, link_control_config, sizeof(link_control_config)) == 0){ 625 if (link_payload_len == link_control_config_prefix_len){ 626 log_debug("link received config, no config field"); 627 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE_EMPTY; 628 } else { 629 log_debug("link received config, 0x%02x", slip_payload[2]); 630 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_CONFIG_RESPONSE; 631 } 632 break; 633 } 634 if (memcmp(slip_payload, link_control_sync, sizeof(link_control_sync)) == 0){ 635 log_debug("link received sync in ACTIVE STATE!"); 636 // TODO sync during active indicates peer reset -> full upper layer reset necessary 637 break; 638 } 639 if (memcmp(slip_payload, link_control_sleep, sizeof(link_control_sleep)) == 0){ 640 if (btstack_uart_sleep_mode){ 641 log_info("link: received sleep message. Enabling UART Sleep."); 642 btstack_uart->set_sleep(btstack_uart_sleep_mode); 643 hci_transport_h5_emit_sleep_state(1); 644 } else { 645 log_info("link: received sleep message. UART Sleep not supported"); 646 } 647 link_peer_asleep = 1; 648 break; 649 } 650 if (memcmp(slip_payload, link_control_wakeup, sizeof(link_control_wakeup)) == 0){ 651 log_info("link: received wakupe message -> send woken"); 652 link_peer_asleep = 0; 653 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_WOKEN; 654 break; 655 } 656 if (memcmp(slip_payload, link_control_woken, sizeof(link_control_woken)) == 0){ 657 log_info("link: received woken message"); 658 link_peer_asleep = 0; 659 // queued packet will be sent in hci_transport_link_run if needed 660 break; 661 } 662 break; 663 case HCI_EVENT_PACKET: 664 case HCI_ACL_DATA_PACKET: 665 case HCI_SCO_DATA_PACKET: 666 case HCI_ISO_DATA_PACKET: 667 // seems like peer is awake 668 link_peer_asleep = 0; 669 // forward packet to stack 670 packet_handler(link_packet_type, slip_payload, link_payload_len); 671 // reset inactvitiy timer 672 hci_transport_inactivity_timer_set(); 673 break; 674 default: 675 // ignore unknown packet type 676 break; 677 } 678 break; 679 default: 680 break; 681 } 682 683 hci_transport_link_run(); 684 } 685 686 // recommended time until resend: 3 * time of largest packet 687 static uint16_t hci_transport_link_calc_resend_timeout(uint32_t baudrate){ 688 uint32_t max_packet_size_in_bit = (HCI_INCOMING_PACKET_BUFFER_SIZE + 6) << 3; 689 uint32_t t_max_x3_ms = max_packet_size_in_bit * 3000 / baudrate; 690 691 // allow for BTstack logging and other delays 692 t_max_x3_ms += 50; 693 694 log_info("resend timeout for %"PRIu32" baud: %u ms", baudrate, (int) t_max_x3_ms); 695 return t_max_x3_ms; 696 } 697 698 static void hci_transport_link_update_resend_timeout(uint32_t baudrate){ 699 link_resend_timeout_ms = hci_transport_link_calc_resend_timeout(baudrate); 700 } 701 702 /// H5 Interface 703 704 static void hci_transport_h5_frame_received(uint16_t frame_size){ 705 hci_transport_h5_process_frame(frame_size); 706 hci_transport_slip_init(); 707 } 708 709 static void hci_transport_h5_frame_sent(void){ 710 711 // restore DIC and clear flag 712 if (hci_packet_restore_dic_address){ 713 little_endian_store_16(hci_packet_restore_dic_address, 0, hci_packet_restore_dic_data); 714 hci_packet_restore_dic_address = NULL; 715 } 716 717 // done 718 slip_write_active = 0; 719 720 // baudrate change pending? 721 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SET_BAUDRATE){ 722 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_SET_BAUDRATE; 723 btstack_uart->set_baudrate(link_new_baudrate); 724 hci_transport_link_update_resend_timeout(link_new_baudrate); 725 } 726 727 // enter sleep mode after sending sleep message 728 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_ENTER_SLEEP){ 729 hci_transport_link_actions &= ~HCI_TRANSPORT_LINK_ENTER_SLEEP; 730 if (btstack_uart_sleep_mode){ 731 log_info("link: sent sleep message. Enabling UART Sleep."); 732 btstack_uart->set_sleep(btstack_uart_sleep_mode); 733 } else { 734 log_info("link: sent sleep message. UART Sleep not supported"); 735 } 736 hci_transport_h5_emit_sleep_state(1); 737 } 738 739 // SCO packets are sent as unreliable, so we're done now 740 if (hci_packet_type == HCI_SCO_DATA_PACKET){ 741 hci_transport_link_clear_queue(); 742 // notify upper stack that it can send again 743 uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0}; 744 packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event)); 745 } 746 747 hci_transport_link_run(); 748 } 749 750 static void hci_transport_h5_init(const void * transport_config){ 751 // check for hci_transport_config_uart_t 752 if (!transport_config) { 753 log_error("hci_transport_h5: no config!"); 754 return; 755 } 756 if (((hci_transport_config_t*)transport_config)->type != HCI_TRANSPORT_CONFIG_UART) { 757 log_error("hci_transport_h5: config not of type != HCI_TRANSPORT_CONFIG_UART!"); 758 return; 759 } 760 761 // extract UART config from transport config 762 hci_transport_config_uart_t * hci_transport_config_uart = (hci_transport_config_uart_t*) transport_config; 763 uart_config.baudrate = hci_transport_config_uart->baudrate_init; 764 uart_config.flowcontrol = hci_transport_config_uart->flowcontrol; 765 uart_config.parity = hci_transport_config_uart->parity; 766 uart_config.device_name = hci_transport_config_uart->device_name; 767 768 // setup UART driver 769 btstack_uart->init(&uart_config); 770 btstack_uart->set_frame_received(&hci_transport_h5_frame_received); 771 btstack_uart->set_frame_sent(&hci_transport_h5_frame_sent); 772 } 773 774 static int hci_transport_h5_open(void){ 775 int res = btstack_uart->open(); 776 if (res){ 777 return res; 778 } 779 780 // 781 if (hci_transport_bcsp_mode){ 782 log_info("enable even parity for BCSP mode"); 783 btstack_uart->set_parity(BTSTACK_UART_PARITY_EVEN); 784 } 785 786 // check if wake on RX can be used 787 btstack_uart_sleep_mode = BTSTACK_UART_SLEEP_OFF; 788 int supported_sleep_modes = 0; 789 if (btstack_uart->get_supported_sleep_modes){ 790 supported_sleep_modes = btstack_uart->get_supported_sleep_modes(); 791 } 792 if (supported_sleep_modes & BTSTACK_UART_SLEEP_MASK_RTS_LOW_WAKE_ON_RX_EDGE){ 793 log_info("using wake on RX"); 794 btstack_uart_sleep_mode = BTSTACK_UART_SLEEP_RTS_LOW_WAKE_ON_RX_EDGE; 795 } else { 796 log_info("UART driver does not provide compatible sleep mode"); 797 } 798 799 // setup resend timeout 800 hci_transport_link_update_resend_timeout(uart_config.baudrate); 801 802 // init link management - already starts syncing 803 hci_transport_link_init(); 804 805 // start receiving 806 hci_transport_slip_init(); 807 808 return 0; 809 } 810 811 static int hci_transport_h5_close(void){ 812 return btstack_uart->close(); 813 } 814 815 static void hci_transport_h5_register_packet_handler(void (*handler)(uint8_t packet_type, uint8_t *packet, uint16_t size)){ 816 packet_handler = handler; 817 } 818 819 static int hci_transport_h5_can_send_packet_now(uint8_t packet_type){ 820 int res = !hci_transport_link_have_outgoing_packet() && link_state == LINK_ACTIVE; 821 // log_info("can_send_packet_now: %u", res); 822 return res; 823 } 824 825 static int hci_transport_h5_send_packet(uint8_t packet_type, uint8_t *packet, int size){ 826 if (!hci_transport_h5_can_send_packet_now(packet_type)){ 827 log_error("hci_transport_h5_send_packet called but in state %d", link_state); 828 return -1; 829 } 830 831 // store request 832 hci_transport_h5_queue_packet(packet_type, packet, size); 833 834 // send wakeup first 835 if (link_peer_asleep){ 836 hci_transport_h5_emit_sleep_state(0); 837 if (btstack_uart_sleep_mode){ 838 log_info("disable UART sleep"); 839 btstack_uart->set_sleep(BTSTACK_UART_SLEEP_OFF); 840 } 841 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_WAKEUP; 842 hci_transport_link_set_timer(LINK_WAKEUP_MS); 843 } else { 844 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SEND_QUEUED_PACKET; 845 hci_transport_link_set_timer(link_resend_timeout_ms); 846 } 847 hci_transport_link_run(); 848 return 0; 849 } 850 851 static int hci_transport_h5_set_baudrate(uint32_t baudrate){ 852 853 log_info("set_baudrate %"PRIu32", h5 actions %x", baudrate, hci_transport_link_actions); 854 // Baudrate is changed after an HCI Baudrate Change Command, which usually causes an HCI Event Commmand Complete 855 // Before changing the baudrate, the HCI Command Complete needs to get acknowledged 856 if (hci_transport_link_actions & HCI_TRANSPORT_LINK_SEND_ACK_PACKET){ 857 hci_transport_link_actions |= HCI_TRANSPORT_LINK_SET_BAUDRATE; 858 link_new_baudrate = baudrate; 859 hci_transport_link_run(); 860 return 0; 861 } 862 863 int res = btstack_uart->set_baudrate(baudrate); 864 865 if (res) return res; 866 hci_transport_link_update_resend_timeout(baudrate); 867 return 0; 868 } 869 870 static void hci_transport_h5_reset_link(void){ 871 872 log_info("reset_link"); 873 874 // clear outgoing queue 875 hci_transport_link_clear_queue(); 876 877 // init slip parser state machine 878 hci_transport_slip_init(); 879 880 // init link management - already starts syncing 881 hci_transport_link_init(); 882 } 883 884 static const hci_transport_t hci_transport_h5 = { 885 /* const char * name; */ "H5", 886 /* void (*init) (const void *transport_config); */ &hci_transport_h5_init, 887 /* int (*open)(void); */ &hci_transport_h5_open, 888 /* int (*close)(void); */ &hci_transport_h5_close, 889 /* void (*register_packet_handler)(void (*handler)(...); */ &hci_transport_h5_register_packet_handler, 890 /* int (*can_send_packet_now)(uint8_t packet_type); */ &hci_transport_h5_can_send_packet_now, 891 /* int (*send_packet)(...); */ &hci_transport_h5_send_packet, 892 /* int (*set_baudrate)(uint32_t baudrate); */ &hci_transport_h5_set_baudrate, 893 /* void (*reset_link)(void); */ &hci_transport_h5_reset_link, 894 /* void (*set_sco_config)(uint16_t voice_setting, int num_connections); */ NULL, 895 }; 896 897 // configure and return h5 singleton 898 const hci_transport_t * hci_transport_h5_instance(const btstack_uart_t * uart_driver) { 899 btstack_uart = uart_driver; 900 return &hci_transport_h5; 901 } 902 903 void hci_transport_h5_set_auto_sleep(uint16_t inactivity_timeout_ms){ 904 link_inactivity_timeout_ms = inactivity_timeout_ms; 905 } 906 907 void hci_transport_h5_enable_bcsp_mode(void){ 908 hci_transport_bcsp_mode = 1; 909 } 910 911 #endif 912