1 /* 2 * Copyright (C) 2020 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 MATTHIAS 24 * RINGWALD 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__ "ll_sx1280.c" 39 40 #define DEBUG 41 42 #include <string.h> 43 44 #include "ll.h" 45 46 #include "hw.h" 47 #include "radio.h" 48 #include "sx1280.h" 49 #include "debug.h" 50 #include "btstack_config.h" 51 #include "btstack_debug.h" 52 #include "btstack_memory.h" 53 #include "btstack_memory_pool.h" 54 #include "btstack_linked_queue.h" 55 #include "bluetooth_company_id.h" 56 #include "hal_cpu.h" 57 #include "hci_event.h" 58 #include "hopping.h" 59 #include "hal_timer.h" 60 61 62 // 63 // configuration 64 // 65 66 #define AUTO_RX_TX_TIME_US 86 67 68 #define TX_PARAMS_RAMP_TIME RADIO_RAMP_02_US 69 70 // set output power in dBM, range [-18..+13] dBm - Bluetooth LE max is 10 dBM 71 #define TX_PARAMS_OUTPUT_POWER 10 72 73 74 75 #define ACL_LE_MAX_PAYLOAD 31 76 #define ADV_MAX_PAYLOAD (6+6+22) 77 #define LL_MAX_PAYLOAD 37 78 79 // split 256 bytes data buffer into 2 rx and 2 tx buffers 80 #define SX1280_RX0_OFFSET 0 81 #define SX1280_RX1_OFFSET 64 82 #define SX1280_TX0_OFFSET 128 83 #define SX1280_TX1_OFFSET 192 84 85 86 // Mask of IRQs to listen in tx and rx mode 87 #define RX_TX_IRQ_MASK (IRQ_RX_DONE | IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR) 88 89 // sync hop delay - time we prepare for next connection event 90 #define SYNC_HOP_DELAY_US 600 91 92 // num tx buffers for use by link layer 93 #define HCI_NUM_TX_BUFFERS_LL 4 94 95 // num rx buffers 96 #define HCI_NUM_RX_BUFFERS 16 97 98 // total number PDU buffers 99 #define MAX_NUM_LL_PDUS (HCI_NUM_TX_BUFFERS_STACK + HCI_NUM_TX_BUFFERS_LL + HCI_NUM_RX_BUFFERS) 100 101 // HCI Connection Handle used for all HCI events/connections 102 #define HCI_CON_HANDLE 0x0001 103 104 // convert us to ticks, rounding to the closest tick count 105 // @note us must be <= 1000000 us = 1 s 106 #define US_TO_TICKS(US) (((((uint32_t)(US)) * 4096) + 6125) / 125000L) 107 108 // ADV PDU Types 109 enum pdu_adv_type { 110 PDU_ADV_TYPE_ADV_IND = 0x00, 111 PDU_ADV_TYPE_DIRECT_IND = 0x01, 112 PDU_ADV_TYPE_NONCONN_IND = 0x02, 113 PDU_ADV_TYPE_SCAN_REQ = 0x03, 114 PDU_ADV_TYPE_AUX_SCAN_REQ = PDU_ADV_TYPE_SCAN_REQ, 115 PDU_ADV_TYPE_SCAN_RSP = 0x04, 116 PDU_ADV_TYPE_CONNECT_IND = 0x05, 117 PDU_ADV_TYPE_AUX_CONNECT_REQ = PDU_ADV_TYPE_CONNECT_IND, 118 PDU_ADV_TYPE_SCAN_IND = 0x06, 119 PDU_ADV_TYPE_EXT_IND = 0x07, 120 PDU_ADV_TYPE_AUX_ADV_IND = PDU_ADV_TYPE_EXT_IND, 121 PDU_ADV_TYPE_AUX_SCAN_RSP = PDU_ADV_TYPE_EXT_IND, 122 PDU_ADV_TYPE_AUX_SYNC_IND = PDU_ADV_TYPE_EXT_IND, 123 PDU_ADV_TYPE_AUX_CHAIN_IND = PDU_ADV_TYPE_EXT_IND, 124 PDU_ADV_TYPE_AUX_CONNECT_RSP = 0x08, 125 }; 126 127 // DATA PDU Types 128 enum pdu_data_llid { 129 PDU_DATA_LLID_RESV = 0x00, 130 PDU_DATA_LLID_DATA_CONTINUE = 0x01, 131 PDU_DATA_LLID_DATA_START = 0x02, 132 PDU_DATA_LLID_CTRL = 0x03, 133 }; 134 135 // DATA Link Layer Control Types 136 enum pdu_data_llctrl_type { 137 PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND = 0x00, 138 PDU_DATA_LLCTRL_TYPE_CHAN_MAP_IND = 0x01, 139 PDU_DATA_LLCTRL_TYPE_TERMINATE_IND = 0x02, 140 PDU_DATA_LLCTRL_TYPE_ENC_REQ = 0x03, 141 PDU_DATA_LLCTRL_TYPE_ENC_RSP = 0x04, 142 PDU_DATA_LLCTRL_TYPE_START_ENC_REQ = 0x05, 143 PDU_DATA_LLCTRL_TYPE_START_ENC_RSP = 0x06, 144 PDU_DATA_LLCTRL_TYPE_UNKNOWN_RSP = 0x07, 145 PDU_DATA_LLCTRL_TYPE_FEATURE_REQ = 0x08, 146 PDU_DATA_LLCTRL_TYPE_FEATURE_RSP = 0x09, 147 PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_REQ = 0x0A, 148 PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_RSP = 0x0B, 149 PDU_DATA_LLCTRL_TYPE_VERSION_IND = 0x0C, 150 PDU_DATA_LLCTRL_TYPE_REJECT_IND = 0x0D, 151 PDU_DATA_LLCTRL_TYPE_SLAVE_FEATURE_REQ = 0x0E, 152 PDU_DATA_LLCTRL_TYPE_CONN_PARAM_REQ = 0x0F, 153 PDU_DATA_LLCTRL_TYPE_CONN_PARAM_RSP = 0x10, 154 PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND = 0x11, 155 PDU_DATA_LLCTRL_TYPE_PING_REQ = 0x12, 156 PDU_DATA_LLCTRL_TYPE_PING_RSP = 0x13, 157 PDU_DATA_LLCTRL_TYPE_LENGTH_REQ = 0x14, 158 PDU_DATA_LLCTRL_TYPE_LENGTH_RSP = 0x15, 159 PDU_DATA_LLCTRL_TYPE_PHY_REQ = 0x16, 160 PDU_DATA_LLCTRL_TYPE_PHY_RSP = 0x17, 161 PDU_DATA_LLCTRL_TYPE_PHY_UPD_IND = 0x18, 162 PDU_DATA_LLCTRL_TYPE_MIN_USED_CHAN_IND = 0x19, 163 }; 164 165 // Radio State 166 typedef enum { 167 RADIO_LOWPOWER, 168 RADIO_RX_ERROR, 169 RADIO_TX_TIMEOUT, 170 RADIO_W4_TX_DONE_TO_RX, 171 RADIO_W4_TIMER, 172 } radio_state_t; 173 174 // Link Layer State 175 typedef enum { 176 LL_STATE_STANDBY, 177 LL_STATE_SCANNING, 178 LL_STATE_ADVERTISING, 179 LL_STATE_INITIATING, 180 LL_STATE_CONNECTED 181 } ll_state_t; 182 183 // Link Layer PDU Flags 184 typedef enum { 185 LL_PDU_FLAG_DATA_PDU = 1, 186 } ll_pdu_flags; 187 188 // Link Layer PDU, used in linked list 189 typedef struct { 190 // header 191 void * item; 192 hci_con_handle_t con_handle; 193 uint8_t flags; 194 // over the air data 195 uint8_t header; 196 uint8_t len; 197 uint8_t payload[LL_MAX_PAYLOAD]; 198 } ll_pdu_t; 199 200 // channel table: freq in hertz and whitening seed 201 static const struct { 202 uint32_t freq_hz; 203 uint8_t whitening; 204 } channel_table[] = { 205 { 2404000000, 0x01 /* 00000001 */ }, 206 { 2406000000, 0x41 /* 01000001 */ }, 207 { 2408000000, 0x21 /* 00100001 */ }, 208 { 2410000000, 0x61 /* 01100001 */ }, 209 { 2412000000, 0x11 /* 00010001 */ }, 210 { 2414000000, 0x51 /* 01010001 */ }, 211 { 2416000000, 0x31 /* 00110001 */ }, 212 { 2418000000, 0x71 /* 01110001 */ }, 213 { 2420000000, 0x09 /* 00001001 */ }, 214 { 2422000000, 0x49 /* 01001001 */ }, 215 { 2424000000, 0x29 /* 00101001 */ }, 216 { 2428000000, 0x69 /* 01101001 */ }, 217 { 2430000000, 0x19 /* 00011001 */ }, 218 { 2432000000, 0x59 /* 01011001 */ }, 219 { 2434000000, 0x39 /* 00111001 */ }, 220 { 2436000000, 0x79 /* 01111001 */ }, 221 { 2438000000, 0x05 /* 00000101 */ }, 222 { 2440000000, 0x45 /* 01000101 */ }, 223 { 2442000000, 0x25 /* 00100101 */ }, 224 { 2444000000, 0x65 /* 01100101 */ }, 225 { 2446000000, 0x15 /* 00010101 */ }, 226 { 2448000000, 0x55 /* 01010101 */ }, 227 { 2450000000, 0x35 /* 00110101 */ }, 228 { 2452000000, 0x75 /* 01110101 */ }, 229 { 2454000000, 0x0d /* 00001101 */ }, 230 { 2456000000, 0x4d /* 01001101 */ }, 231 { 2458000000, 0x2d /* 00101101 */ }, 232 { 2460000000, 0x6d /* 01101101 */ }, 233 { 2462000000, 0x1d /* 00011101 */ }, 234 { 2464000000, 0x5d /* 01011101 */ }, 235 { 2466000000, 0x3d /* 00111101 */ }, 236 { 2468000000, 0x7d /* 01111101 */ }, 237 { 2470000000, 0x03 /* 00000011 */ }, 238 { 2472000000, 0x43 /* 01000011 */ }, 239 { 2474000000, 0x23 /* 00100011 */ }, 240 { 2476000000, 0x63 /* 01100011 */ }, 241 { 2478000000, 0x13 /* 00010011 */ }, 242 { 2402000000, 0x53 /* 01010011 */ }, 243 { 2426000000, 0x33 /* 00110011 */ }, 244 { 2480000000, 0x73 /* 01110011 */ }, 245 }; 246 247 // hopping context 248 static hopping_t h; 249 250 static struct { 251 252 volatile bool synced; 253 254 volatile uint16_t packet_nr_in_connection_event; 255 256 volatile uint16_t conn_interval_1250us; 257 volatile uint32_t conn_interval_us; 258 259 volatile uint16_t conn_latency; 260 261 volatile uint16_t supervision_timeout_10ms; 262 volatile uint32_t supervision_timeout_us; 263 264 // 265 volatile uint32_t time_without_any_packets_us; 266 267 // access address 268 volatile uint32_t aa; 269 270 // start of current connection event 271 volatile uint16_t anchor_ticks; 272 273 // current channel 274 volatile uint8_t channel; 275 276 // CSA #2 supported 277 uint8_t csa2_support; 278 279 // channels selection algorithm index (1 for csa #2) 280 volatile uint8_t channel_selection_algorithm; 281 282 // current connection event, first one starts with 0 283 // - needed for connection param and channel map updates as well as encryption 284 volatile uint16_t connection_event; 285 286 // pending channel map update 287 volatile bool channel_map_update_pending; 288 volatile uint16_t channel_map_update_instant; 289 volatile uint8_t channel_map_update_map[5]; 290 291 // pending connection param update 292 volatile bool conn_param_update_pending; 293 volatile uint16_t conn_param_update_instant; 294 volatile uint8_t conn_param_update_win_size; 295 volatile uint16_t conn_param_update_win_offset; 296 volatile uint32_t conn_param_update_interval_us; 297 volatile uint16_t conn_param_update_latency; 298 volatile uint32_t conn_param_update_timeout_us; 299 300 // our bd_addr as little endian 301 uint8_t bd_addr_le[6]; 302 303 // peer addr 304 uint8_t peer_addr_type; 305 uint8_t peer_addr[6]; 306 307 // adv data 308 uint8_t adv_len; 309 uint8_t adv_data[31]; 310 311 // adv param 312 uint8_t adv_map; 313 uint32_t adv_interval_us; 314 315 // next expected sequence number 316 volatile uint8_t next_expected_sequence_number; 317 318 // transmit sequence number 319 volatile uint8_t transmit_sequence_number; 320 321 // num queued tx buffers 322 volatile uint8_t num_tx_queued; 323 324 // num completed packets 325 volatile uint8_t num_completed; 326 327 // current outgoing packet 328 ll_pdu_t * tx_pdu; 329 330 // current incomoing packet 331 ll_pdu_t * rx_pdu; 332 333 // tx queue 334 btstack_linked_queue_t tx_queue; 335 336 // rx queue 337 btstack_linked_queue_t rx_queue; 338 339 } ctx; 340 341 static radio_state_t radio_state = RADIO_LOWPOWER; 342 343 // Buffer pool 344 static ll_pdu_t ll_pdu_pool_storage[MAX_NUM_LL_PDUS]; 345 static btstack_memory_pool_t ll_pdu_pool; 346 347 // single ll control response 348 static ll_pdu_t ll_tx_packet; 349 350 // Link Layer State 351 static ll_state_t ll_state; 352 static uint32_t ll_scan_interval_us; 353 static uint32_t ll_scan_window_us; 354 355 static ll_pdu_t * ll_reserved_acl_buffer; 356 static void (*controller_packet_handler)(uint8_t packet_type, uint8_t * packet, uint16_t size); 357 358 static uint8_t empty_packet[2]; 359 static uint8_t ll_outgoing_hci_event[258]; 360 static bool ll_send_disconnected; 361 static bool ll_send_connection_complete; 362 363 // prototypes 364 static void radio_set_timer_ticks(uint32_t anchor_offset_ticks); 365 366 367 // memory pool for acl-le pdus 368 static ll_pdu_t * btstack_memory_ll_pdu_get(void){ 369 void * buffer = btstack_memory_pool_get(&ll_pdu_pool); 370 if (buffer){ 371 memset(buffer, 0, sizeof(ll_pdu_t)); 372 } 373 return (ll_pdu_t *) buffer; 374 } 375 376 static void btstack_memory_ll_pdu_free(ll_pdu_t *acl_le_pdu){ 377 btstack_memory_pool_free(&ll_pdu_pool, acl_le_pdu); 378 } 379 380 381 static bool receive_prepare_rx_bufffer(void){ 382 if (ctx.rx_pdu == NULL){ 383 ctx.rx_pdu = btstack_memory_ll_pdu_get(); 384 } 385 if (ctx.rx_pdu == NULL){ 386 printf("No free RX buffer\n"); 387 return false; 388 } else { 389 return true; 390 } 391 } 392 393 static void receive_adv_response(void){ 394 if (receive_prepare_rx_bufffer()) { 395 Radio.SetRx( ( TickTime_t ) { RADIO_TICK_SIZE_0015_US, 10 } ); // 220 us 396 } 397 } 398 399 static void receive_first_master(void){ 400 if (receive_prepare_rx_bufffer()){ 401 Radio.SetRx( ( TickTime_t ) { RADIO_TICK_SIZE_1000_US, 1000 } ); 402 } 403 } 404 405 static void receive_master(void){ 406 if (receive_prepare_rx_bufffer()) { 407 Radio.SetRx((TickTime_t) {RADIO_TICK_SIZE_1000_US, 1}); 408 } 409 } 410 411 412 static void send_adv(void){ 413 // setup advertisement: header (2) + addr (6) + data (31) 414 uint8_t adv_buffer[39]; 415 adv_buffer[0] = PDU_ADV_TYPE_ADV_IND; // TODO: also set private address bits 416 adv_buffer[1] = 6 + ctx.adv_len; 417 memcpy(&adv_buffer[2], ctx.bd_addr_le, 6); 418 memcpy(&adv_buffer[8], ctx.adv_data, ctx.adv_len); 419 uint16_t packet_size = 2 + adv_buffer[1]; 420 SX1280HalWriteBuffer( SX1280_TX0_OFFSET, adv_buffer, packet_size ); 421 SX1280SetTx( ( TickTime_t ){ RADIO_TICK_SIZE_1000_US, 1 } ); 422 } 423 424 425 static void select_channel(uint8_t channel){ 426 // Set Whitening seed 427 Radio.SetWhiteningSeed( channel_table[channel].whitening ); 428 429 // Sel Frequency 430 Radio.SetRfFrequency( channel_table[channel].freq_hz ); 431 } 432 433 static void next_channel(void){ 434 switch (ctx.channel_selection_algorithm){ 435 case 0: 436 ctx.channel = hopping_csa1_get_next_channel( &h ); 437 break; 438 case 1: 439 ctx.channel = hopping_csa2_get_channel_for_counter( &h, ctx.connection_event); 440 break; 441 default: 442 break; 443 } 444 select_channel(ctx.channel); 445 } 446 447 static void ll_advertising_statemachine(void){ 448 switch ( radio_state) { 449 case RADIO_RX_ERROR: 450 case RADIO_LOWPOWER: 451 // find next channel 452 while (ctx.channel < 40){ 453 ctx.channel++; 454 if ((ctx.adv_map & (1 << (ctx.channel - 37))) != 0) { 455 // Set Channel 456 select_channel(ctx.channel); 457 radio_state = RADIO_W4_TX_DONE_TO_RX; 458 send_adv(); 459 break; 460 } 461 if (ctx.channel >= 40){ 462 // Set timer 463 radio_state = RADIO_W4_TIMER; 464 uint32_t adv_interval_ticks = US_TO_TICKS(ctx.adv_interval_us); 465 radio_set_timer_ticks(adv_interval_ticks); 466 } 467 } 468 break; 469 default: 470 break; 471 } 472 } 473 474 static void start_advertising(void){ 475 476 Radio.StopAutoTx(); 477 478 PacketParams_t packetParams; 479 packetParams.PacketType = PACKET_TYPE_BLE; 480 packetParams.Params.Ble.BlePacketType = BLE_EYELONG_1_0; 481 packetParams.Params.Ble.ConnectionState = BLE_PAYLOAD_LENGTH_MAX_37_BYTES; 482 packetParams.Params.Ble.CrcField = BLE_CRC_3B; 483 packetParams.Params.Ble.Whitening = RADIO_WHITENING_ON; 484 Radio.SetPacketParams( &packetParams ); 485 486 // Set CRC init value 0x555555 487 Radio.WriteRegister(0x9c7, 0x55 ); 488 Radio.WriteRegister(0x9c8, 0x55 ); 489 Radio.WriteRegister(0x9c9, 0x55 ); 490 491 // Set AccessAddress for ADV packets 492 Radio.SetBleAdvertizerAccessAddress( ); 493 494 radio_state = RADIO_LOWPOWER; 495 ll_state = LL_STATE_ADVERTISING; 496 497 // prepare 498 ctx.channel = 36; 499 ctx.anchor_ticks = hal_timer_get_ticks(); 500 501 // and get started 502 ll_advertising_statemachine(); 503 } 504 505 static void start_hopping(void){ 506 PacketParams_t packetParams; 507 packetParams.PacketType = PACKET_TYPE_BLE; 508 packetParams.Params.Ble.BlePacketType = BLE_EYELONG_1_0; 509 packetParams.Params.Ble.ConnectionState = BLE_PAYLOAD_LENGTH_MAX_31_BYTES; 510 packetParams.Params.Ble.CrcField = BLE_CRC_3B; 511 packetParams.Params.Ble.Whitening = RADIO_WHITENING_ON; 512 Radio.SetPacketParams( &packetParams ); 513 514 } 515 516 static void radio_stop_timer(void){ 517 hal_timer_stop(); 518 } 519 520 static void radio_set_timer_ticks(uint32_t anchor_offset_ticks){ 521 radio_stop_timer(); 522 // set timer for next radio event relative to anchor 523 uint16_t timeout_ticks = (uint16_t) (ctx.anchor_ticks + anchor_offset_ticks); 524 hal_timer_start(timeout_ticks); 525 } 526 527 static void ll_terminate(void){ 528 ll_state = LL_STATE_STANDBY; 529 ctx.conn_param_update_pending = false; 530 ctx.channel_map_update_pending = false; 531 // stop sync hop timer 532 radio_stop_timer(); 533 // free outgoing tx packet 534 if ((ctx.tx_pdu != NULL) && (ctx.tx_pdu != &ll_tx_packet)){ 535 btstack_memory_ll_pdu_free(ctx.tx_pdu); 536 ctx.tx_pdu = NULL; 537 } 538 // free queued tx packets 539 while (true){ 540 ll_pdu_t * tx_packet = (ll_pdu_t *) btstack_linked_queue_dequeue(&ctx.tx_queue); 541 if (tx_packet != NULL) { 542 btstack_memory_ll_pdu_free(tx_packet); 543 } else { 544 break; 545 } 546 } 547 // disable auto tx 548 Radio.StopAutoTx(); 549 // notify host stack 550 ll_send_disconnected = true; 551 } 552 553 static void radio_timer_handler(void){ 554 555 uint16_t t0 = hal_timer_get_ticks(); 556 557 switch (ll_state){ 558 case LL_STATE_CONNECTED: 559 // check supervision timeout 560 ctx.time_without_any_packets_us += ctx.conn_interval_us; 561 if (ctx.time_without_any_packets_us > ctx.supervision_timeout_us) { 562 printf("Supervision timeout\n\n"); 563 ll_terminate(); 564 return; 565 } 566 567 // prepare next connection event 568 ctx.connection_event++; 569 ctx.anchor_ticks += US_TO_TICKS(ctx.conn_interval_us); 570 571 ctx.packet_nr_in_connection_event = 0; 572 next_channel(); 573 574 if (ctx.channel_map_update_pending && (ctx.channel_map_update_instant == ctx.connection_event)) { 575 hopping_set_channel_map( &h, (const uint8_t *) &ctx.channel_map_update_map ); 576 ctx.channel_map_update_pending = false; 577 } 578 579 if (ctx.conn_param_update_pending && ((ctx.conn_param_update_instant) == ctx.connection_event) ) { 580 ctx.conn_interval_us = ctx.conn_param_update_interval_us; 581 ctx.conn_latency = ctx.conn_param_update_latency; 582 ctx.supervision_timeout_us = ctx.conn_param_update_timeout_us; 583 ctx.conn_param_update_pending = false; 584 585 log_info("Conn param update now"); 586 587 radio_stop_timer(); 588 ctx.synced = false; 589 } 590 591 if (ctx.synced){ 592 // restart radio timer (might get overwritten by first packet) 593 uint32_t conn_interval_ticks = US_TO_TICKS(ctx.conn_interval_us - SYNC_HOP_DELAY_US); 594 radio_set_timer_ticks(conn_interval_ticks); 595 596 receive_master(); 597 } else { 598 // just wait longer 599 receive_first_master(); 600 } 601 602 printf("--SYNC-Ch %02u-Event %04u - t %08u--\n", ctx.channel, ctx.connection_event, t0); 603 break; 604 case LL_STATE_ADVERTISING: 605 // send adv on all configured channels 606 ctx.channel = 36; 607 ctx.anchor_ticks = t0; 608 radio_stop_timer(); 609 ll_advertising_statemachine(); 610 radio_state = RADIO_LOWPOWER; 611 break; 612 default: 613 break; 614 } 615 616 } 617 618 /** Radio IRQ handlers */ 619 static void radio_on_tx_done(void ){ 620 switch (radio_state){ 621 case RADIO_W4_TX_DONE_TO_RX: 622 receive_adv_response(); 623 break; 624 default: 625 break; 626 } 627 } 628 629 static void radio_on_rx_done(void ){ 630 uint16_t packet_end_ticks = hal_timer_get_ticks(); 631 ll_pdu_t * rx_packet; 632 bool tx_acked; 633 634 uint8_t sequence_number; 635 uint8_t next_expected_sequence_number; 636 // uint8_t more_data; 637 638 // fetch reserved rx pdu 639 rx_packet = ctx.rx_pdu; 640 btstack_assert(rx_packet != NULL); 641 ctx.rx_pdu = NULL; 642 643 // Read complete buffer 644 uint16_t max_packet_len; 645 if (ll_state == LL_STATE_CONNECTED){ 646 // mark as data packet 647 rx_packet->flags |= LL_PDU_FLAG_DATA_PDU; 648 max_packet_len = 2 + 27; 649 } else { 650 rx_packet->flags = 0; 651 max_packet_len = 2 + LL_MAX_PAYLOAD; 652 } 653 SX1280HalReadBuffer( SX1280_RX0_OFFSET, &rx_packet->header, max_packet_len); 654 655 // queue received packet 656 btstack_linked_queue_enqueue(&ctx.rx_queue, (btstack_linked_item_t *) rx_packet); 657 658 if (ll_state == LL_STATE_CONNECTED){ 659 // parse header 660 next_expected_sequence_number = (rx_packet->header >> 2) & 1; 661 sequence_number = (rx_packet->header >> 3) & 1; 662 // more_data = (rx_packet->header >> 4) & 1; 663 664 // update state 665 ctx.next_expected_sequence_number = 1 - sequence_number; 666 667 // tx packet ack'ed? 668 tx_acked = ctx.transmit_sequence_number != next_expected_sequence_number; 669 if (tx_acked){ 670 if ((ctx.tx_pdu != NULL) && (ctx.tx_pdu != &ll_tx_packet)){ 671 btstack_memory_ll_pdu_free(ctx.tx_pdu); 672 ctx.num_completed++; 673 } 674 ctx.tx_pdu = (ll_pdu_t *) btstack_linked_queue_dequeue(&ctx.tx_queue); 675 ctx.transmit_sequence_number = next_expected_sequence_number; 676 } 677 // refill 678 if (ctx.tx_pdu == NULL){ 679 ctx.tx_pdu = (ll_pdu_t *) btstack_linked_queue_dequeue(&ctx.tx_queue); 680 } 681 682 // restart supervision timeout 683 ctx.time_without_any_packets_us = 0; 684 685 // check clock if we can sent a full packet before sync hop 686 int16_t event_time = packet_end_ticks - ctx.anchor_ticks; 687 uint16_t max_packet_time_incl_ifs_us = 500; 688 if (event_time > (ctx.conn_interval_us - SYNC_HOP_DELAY_US - max_packet_time_incl_ifs_us)){ 689 // abort sending of next packet / AutoTx 690 Radio.SetFs(); 691 printf("Close to Sync hop\n"); 692 return; 693 } 694 695 // tx packet ready? 696 if (ctx.tx_pdu == NULL){ 697 empty_packet[0] = (ctx.transmit_sequence_number << 3) | (ctx.next_expected_sequence_number << 2) | PDU_DATA_LLID_DATA_CONTINUE; 698 empty_packet[1] = 0; 699 SX1280HalWriteBuffer( SX1280_TX0_OFFSET, empty_packet, 2 ); 700 } else { 701 uint8_t md = btstack_linked_queue_empty(&ctx.tx_queue) ? 0 : 1; 702 ctx.tx_pdu->header |= (md << 4) | (ctx.transmit_sequence_number << 3) | (ctx.next_expected_sequence_number << 2); 703 SX1280HalWriteBuffer( SX1280_TX0_OFFSET, (uint8_t *) &ctx.tx_pdu->header, 2 + ctx.tx_pdu->len ); 704 } 705 706 // update operating state 707 SX1280AutoTxWillStart(); 708 709 // set anchor on first packet in connection event 710 if (ctx.packet_nr_in_connection_event == 0){ 711 712 // preamble (1) + aa (4) + header (1) + len (1) + payload (len) + crc (3) -- ISR handler ca. 35 us 713 uint16_t timestamp_delay = (10 + rx_packet->len) * 8 - 35; 714 uint16_t packet_start_ticks = packet_end_ticks - US_TO_TICKS(timestamp_delay); 715 716 ctx.anchor_ticks = packet_start_ticks; 717 ctx.synced = true; 718 uint32_t sync_hop_timeout_ticks = US_TO_TICKS(ctx.conn_interval_us - SYNC_HOP_DELAY_US); 719 radio_set_timer_ticks(sync_hop_timeout_ticks); 720 } 721 722 ctx.packet_nr_in_connection_event++; 723 724 printf("RX %02x\n", rx_packet->header); 725 } 726 } 727 728 static void radio_on_tx_timeout(void ){ 729 radio_state = RADIO_TX_TIMEOUT; 730 printf( "<>>>>>>>>TXE\n\r" ); 731 } 732 733 static void radio_on_rx_timeout(void ){ 734 switch (ll_state){ 735 case LL_STATE_ADVERTISING: 736 radio_state = RADIO_RX_ERROR; 737 break; 738 default: 739 break; 740 } 741 } 742 743 static void radio_on_rx_error(IrqErrorCode_t errorCode ){ 744 switch (ll_state){ 745 case LL_STATE_ADVERTISING: 746 radio_state = RADIO_RX_ERROR; 747 break; 748 default: 749 break; 750 } 751 } 752 753 const static RadioCallbacks_t Callbacks = 754 { 755 &radio_on_tx_done, // txDone 756 &radio_on_rx_done, // rxDone 757 NULL, // syncWordDone 758 NULL, // headerDone 759 &radio_on_tx_timeout, // txTimeout 760 &radio_on_rx_timeout, // rxTimeout 761 &radio_on_rx_error, // rxError 762 NULL, // rangingDone 763 NULL, // cadDone 764 }; 765 766 // Link Layer 767 768 static void ll_emit_hci_event(const hci_event_t * event, ...){ 769 va_list argptr; 770 va_start(argptr, event); 771 uint16_t length = hci_event_create_from_template_and_arglist(ll_outgoing_hci_event, event, argptr); 772 va_end(argptr); 773 controller_packet_handler(HCI_EVENT_PACKET, ll_outgoing_hci_event, length); 774 } 775 776 void ll_init(void){ 777 778 // setup memory pools 779 btstack_memory_pool_create(&ll_pdu_pool, ll_pdu_pool_storage, MAX_NUM_LL_PDUS, sizeof(ll_pdu_t)); 780 781 // set test bd addr 33:33:33:33:33:33 782 memset(ctx.bd_addr_le, 0x33, 6); 783 784 // default channels, advertising interval 785 ctx.adv_map = 0x7; 786 ctx.adv_interval_us = 1280000; 787 788 // init timer 789 hal_timer_init(); 790 hal_timer_set_callback(&radio_timer_handler); 791 } 792 793 void ll_radio_on(void){ 794 Radio.Init( (RadioCallbacks_t *) &Callbacks ); 795 Radio.SetRegulatorMode( USE_DCDC ); // Can also be set in LDO mode but consume more power 796 Radio.SetInterruptMode( ); 797 Radio.SetDioIrqParams( RX_TX_IRQ_MASK, RX_TX_IRQ_MASK, IRQ_RADIO_NONE, IRQ_RADIO_NONE ); 798 799 ModulationParams_t modulationParams; 800 modulationParams.PacketType = PACKET_TYPE_BLE; 801 modulationParams.Params.Ble.BitrateBandwidth = GFSK_BLE_BR_1_000_BW_1_2; 802 modulationParams.Params.Ble.ModulationIndex = GFSK_BLE_MOD_IND_0_50; 803 modulationParams.Params.Ble.ModulationShaping = RADIO_MOD_SHAPING_BT_0_5; 804 805 Radio.SetStandby( STDBY_RC ); 806 Radio.SetPacketType( modulationParams.PacketType ); 807 Radio.SetModulationParams( &modulationParams ); 808 Radio.SetBufferBaseAddresses( SX1280_TX0_OFFSET, SX1280_RX0_OFFSET ); 809 Radio.SetTxParams( TX_PARAMS_OUTPUT_POWER, TX_PARAMS_RAMP_TIME ); 810 811 // Go back to Frequcency Synthesis Mode, reduces transition time between Rx<->TX 812 Radio.SetAutoFS(1); 813 814 ll_state = LL_STATE_STANDBY; 815 } 816 817 static void ll_handle_conn_ind(ll_pdu_t * rx_packet){ 818 printf("Connect Req: "); 819 printf_hexdump(&rx_packet->header, rx_packet->len + 2); 820 821 uint8_t * init_addr = &rx_packet->payload[0]; 822 uint8_t * adv_addr = &rx_packet->payload[6]; 823 uint8_t chan_sel = (rx_packet->header >> 5) & 1; 824 825 // verify AdvA 826 if (memcmp(ctx.bd_addr_le, adv_addr, 6) != 0){ 827 // differs, go back to adv sending 828 radio_state = RADIO_LOWPOWER; 829 return; 830 } 831 832 // TODO: get remote addr type 833 ctx.peer_addr_type = 0; 834 memcpy(ctx.peer_addr, init_addr, 6); 835 836 // get params for HCI event 837 const uint8_t * ll_data = &rx_packet->payload[12]; 838 839 ctx.aa = little_endian_read_32(ll_data, 0); 840 uint8_t crc_init_0 = ll_data[4]; 841 uint8_t crc_init_1 = ll_data[5]; 842 uint8_t crc_init_2 = ll_data[6]; 843 uint8_t win_size = ll_data[7]; 844 uint16_t win_offset = little_endian_read_16(ll_data, 8); 845 ctx.conn_interval_1250us = little_endian_read_16(ll_data, 10); 846 ctx.conn_latency = little_endian_read_16(ll_data, 12); 847 ctx.supervision_timeout_10ms = little_endian_read_16(ll_data, 14); 848 const uint8_t * channel_map = &ll_data[16]; 849 uint8_t hop = ll_data[21] & 0x1f; 850 uint8_t sca = ll_data[21] >> 5; 851 852 UNUSED(sca); 853 UNUSED(win_offset); 854 UNUSED(win_size); 855 856 // convert to us 857 ctx.conn_interval_us = ctx.conn_interval_1250us * 1250; 858 ctx.supervision_timeout_us = ctx.supervision_timeout_10ms * 10000; 859 ctx.connection_event = 0; 860 ctx.packet_nr_in_connection_event = 0; 861 ctx.next_expected_sequence_number = 0; 862 ctx.transmit_sequence_number = 0; 863 864 // set AA 865 Radio.SetBleAccessAddress(ctx.aa); 866 867 // set CRC init value 868 Radio.WriteRegister(0x9c7, crc_init_2); 869 Radio.WriteRegister(0x9c8, crc_init_1); 870 Radio.WriteRegister(0x9c9, crc_init_0); 871 872 printf("Connection interval %u us\n", ctx.conn_interval_us); 873 printf("Connection timeout %u us\n", ctx.supervision_timeout_us); 874 printf("AA %08x\n", ctx.aa); 875 printf("CRC Init 0x%02x%02x%02x\n", crc_init_2, crc_init_1, crc_init_0); 876 877 // init hopping 878 hopping_init( &h ); 879 hopping_set_channel_map( &h, channel_map); 880 ctx.channel_selection_algorithm = ctx.csa2_support & chan_sel; 881 switch (ctx.channel_selection_algorithm){ 882 case 0: 883 hopping_csa1_set_hop_increment( &h, hop ); 884 break; 885 case 1: 886 hopping_csa2_set_access_address( &h, ctx.aa); 887 break; 888 default: 889 break; 890 } 891 next_channel(); 892 893 start_hopping(); 894 895 // Enable Rx->Tx in 150 us for BLE 896 // Note: Driver subtracts AUTO_RX_TX_OFFSET (33) from it and 150 should be correct, Raccoon reports 181 us then, so -31 897 // Radio.SetAutoTx(119); 898 899 // SetAutoTX(100) - direct write / ignore compensation 900 uint8_t buf[2]; 901 big_endian_store_16(buf, 0, AUTO_RX_TX_TIME_US); 902 SX1280HalWriteCommand( RADIO_SET_AUTOTX, buf, 2 ); 903 904 // get next packet 905 ll_state = LL_STATE_CONNECTED; 906 907 receive_first_master(); 908 ll_send_connection_complete = true; 909 } 910 911 static void ll_handle_control(ll_pdu_t * rx_packet){ 912 ll_pdu_t * tx_packet = &ll_tx_packet; 913 uint8_t opcode = rx_packet->payload[0]; 914 switch (opcode){ 915 case PDU_DATA_LLCTRL_TYPE_VERSION_IND: 916 tx_packet->len = 6; 917 tx_packet->header = PDU_DATA_LLID_CTRL; 918 tx_packet->payload[0] = PDU_DATA_LLCTRL_TYPE_VERSION_IND; 919 tx_packet->payload[1] = 0x06; // VersNr = Bluetooth Core V4.0 920 little_endian_store_16(tx_packet->payload, 2, BLUETOOTH_COMPANY_ID_BLUEKITCHEN_GMBH); 921 little_endian_store_16(tx_packet->payload, 4, 0); 922 btstack_linked_queue_enqueue(&ctx.tx_queue, (btstack_linked_item_t *) tx_packet); 923 printf("Queue Version Ind\n"); 924 break; 925 case PDU_DATA_LLCTRL_TYPE_FEATURE_REQ: 926 tx_packet->len = 9; 927 tx_packet->header = PDU_DATA_LLID_CTRL; 928 tx_packet->payload[0] = PDU_DATA_LLCTRL_TYPE_FEATURE_RSP; 929 // TODO: set features of our controller 930 memset(&tx_packet->payload[1], 0, 8); 931 btstack_linked_queue_enqueue(&ctx.tx_queue, (btstack_linked_item_t *) tx_packet); 932 printf("Queue Feature Rsp\n"); 933 break; 934 case PDU_DATA_LLCTRL_TYPE_CHAN_MAP_IND: 935 memcpy((uint8_t *) ctx.channel_map_update_map, &rx_packet->payload[1], 5); 936 ctx.channel_map_update_instant = little_endian_read_16(rx_packet->payload, 6); 937 ctx.channel_map_update_pending = true; 938 break; 939 case PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND: 940 ctx.conn_param_update_win_size = tx_packet->payload[1]; 941 ctx.conn_param_update_win_offset = little_endian_read_16(rx_packet->payload, 2); 942 ctx.conn_param_update_interval_us = little_endian_read_16(rx_packet->payload, 4) * 1250; 943 ctx.conn_param_update_latency = little_endian_read_16(rx_packet->payload, 6); 944 ctx.conn_param_update_timeout_us = little_endian_read_16(rx_packet->payload, 8) * 10000; 945 ctx.conn_param_update_instant = little_endian_read_16(rx_packet->payload, 10); 946 ctx.conn_param_update_pending = true; 947 log_info("PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND, conn interval %u us at instant %u", 948 (unsigned int) ctx.conn_param_update_interval_us, ctx.conn_param_update_instant); 949 break; 950 case PDU_DATA_LLCTRL_TYPE_TERMINATE_IND: 951 printf("Terminate!\n"); 952 ll_terminate(); 953 break; 954 default: 955 break; 956 } 957 } 958 959 static void ll_handle_data(ll_pdu_t * rx_packet){ 960 if (ll_state != LL_STATE_CONNECTED) return; 961 uint8_t acl_packet[40]; 962 // ACL Header 963 uint8_t ll_id = rx_packet->header & 3; 964 acl_packet[0] = 0x01; 965 acl_packet[1] = ll_id << 4; 966 little_endian_store_16(acl_packet, 2, rx_packet->len); 967 memcpy(&acl_packet[4], rx_packet->payload, rx_packet->len); 968 (*controller_packet_handler)(HCI_ACL_DATA_PACKET, acl_packet, rx_packet->len + 4); 969 } 970 971 void ll_set_scan_parameters(uint8_t le_scan_type, uint16_t le_scan_interval, uint16_t le_scan_window, uint8_t own_address_type, uint8_t scanning_filter_policy){ 972 // TODO .. store other params 973 ll_scan_interval_us = ((uint32_t) le_scan_interval) * 625; 974 ll_scan_window_us = ((uint32_t) le_scan_window) * 625; 975 log_info("LE Scan Params: window %lu, interval %lu ms", ll_scan_interval_us, ll_scan_window_us); 976 } 977 978 static uint8_t ll_start_scanning(uint8_t filter_duplicates){ 979 #if 0 980 // COMMAND DISALLOWED if wrong state. 981 if (ll_state != LL_STATE_STANDBY) return 0x0c; 982 983 ll_state = LL_STATE_SCANNING; 984 985 log_info("LE Scan Start: window %lu, interval %lu ms", ll_scan_interval_us, ll_scan_window_us); 986 987 // reset timer and capature events 988 NRF_TIMER0->TASKS_CLEAR = 1; 989 NRF_TIMER0->TASKS_STOP = 1; 990 NRF_TIMER0->EVENTS_COMPARE[0] = 0; 991 NRF_TIMER0->EVENTS_COMPARE[1] = 0; 992 993 // limit scanning 994 if (ll_scan_window_us < ll_scan_interval_us){ 995 // setup PPI to disable radio after end of scan_window 996 NRF_TIMER0->CC[1] = ll_scan_window_us; 997 NRF_PPI->CHENSET = 1 << 22; // TIMER0->EVENTS_COMPARE[1] -> RADIO->TASKS_DISABLE 998 } 999 1000 // set timer to trigger IRQ for next scan interval 1001 NRF_TIMER0->CC[0] = ll_scan_interval_us; 1002 NRF_TIMER0->INTENSET = TIMER_INTENSET_COMPARE0_Enabled << TIMER_INTENSET_COMPARE0_Pos; 1003 1004 // next channel to scan 1005 int adv_channel = (random_generator_next() % 3) + 37; 1006 log_debug("LE Scan Channel: %u", adv_channel); 1007 1008 // start receiving 1009 NRF_TIMER0->TASKS_START = 1; 1010 radio_receive_on_channel(adv_channel); 1011 #endif 1012 return 0; 1013 } 1014 1015 static uint8_t ll_stop_scanning(void){ 1016 #if 0 1017 // COMMAND DISALLOWED if wrong state. 1018 if (ll_state != LL_STATE_SCANNING) return 0x0c; 1019 1020 log_info("LE Scan Stop"); 1021 1022 ll_state = LL_STATE_STANDBY; 1023 1024 // stop radio 1025 radio_disable(); 1026 1027 #endif 1028 return 0; 1029 } 1030 1031 uint8_t ll_set_scan_enable(uint8_t le_scan_enable, uint8_t filter_duplicates){ 1032 if (le_scan_enable){ 1033 return ll_start_scanning(filter_duplicates); 1034 } else { 1035 return ll_stop_scanning(); 1036 } 1037 } 1038 1039 static uint8_t ll_start_advertising(void){ 1040 // COMMAND DISALLOWED if wrong state. 1041 if (ll_state != LL_STATE_STANDBY) return ERROR_CODE_COMMAND_DISALLOWED; 1042 log_info("Start Advertising on channels 0x%0x, interval %lu us", ctx.adv_map, ctx.adv_interval_us); 1043 start_advertising(); 1044 return ERROR_CODE_SUCCESS; 1045 } 1046 1047 static uint8_t ll_stop_advertising(void){ 1048 // COMMAND DISALLOWED if wrong state. 1049 if (ll_state != LL_STATE_ADVERTISING) return ERROR_CODE_COMMAND_DISALLOWED; 1050 1051 // TODO: 1052 return ERROR_CODE_SUCCESS; 1053 } 1054 1055 uint8_t ll_set_advertise_enable(uint8_t le_adv_enable){ 1056 if (le_adv_enable){ 1057 return ll_start_advertising(); 1058 } else { 1059 return ll_stop_advertising(); 1060 } 1061 } 1062 1063 uint8_t ll_set_advertising_parameters(uint16_t advertising_interval_min, uint16_t advertising_interval_max, 1064 uint8_t advertising_type, uint8_t own_address_type, uint8_t peer_address_types, uint8_t * peer_address, 1065 uint8_t advertising_channel_map, uint8_t advertising_filter_policy){ 1066 1067 // validate channel map 1068 if (advertising_channel_map == 0) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1069 if ((advertising_channel_map & 0xf8) != 0) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1070 1071 // validate advertising interval 1072 if (advertising_interval_min < 0x20) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1073 if (advertising_interval_min > 0x4000) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1074 if (advertising_interval_max < 0x20) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1075 if (advertising_interval_max > 0x4000) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1076 if (advertising_interval_min > advertising_interval_max) return ERROR_CODE_INVALID_HCI_COMMAND_PARAMETERS; 1077 1078 ctx.adv_map = advertising_channel_map; 1079 ctx.adv_interval_us = advertising_interval_max * 625; 1080 1081 // TODO: validate other params 1082 // TODO: process other params 1083 1084 return ERROR_CODE_SUCCESS; 1085 } 1086 1087 uint8_t ll_set_advertising_data(uint8_t adv_len, const uint8_t * adv_data){ 1088 // COMMAND DISALLOWED if wrong state. 1089 if (ll_state == LL_STATE_ADVERTISING) return ERROR_CODE_COMMAND_DISALLOWED; 1090 if (adv_len > 31) return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE; 1091 ctx.adv_len = adv_len; 1092 memcpy(ctx.adv_data, adv_data, adv_len); 1093 1094 // TODO: 1095 return ERROR_CODE_SUCCESS; 1096 } 1097 1098 void ll_execute_once(void){ 1099 // process received packets 1100 while (1){ 1101 ll_pdu_t * rx_packet = (ll_pdu_t *) btstack_linked_queue_dequeue(&ctx.rx_queue); 1102 if (rx_packet == NULL) break; 1103 if (rx_packet->len > 0){ 1104 if ((rx_packet->flags & LL_PDU_FLAG_DATA_PDU) == 0){ 1105 // ADV PDU 1106 // connect ind? 1107 if ((rx_packet->header & 0x0f) == PDU_ADV_TYPE_CONNECT_IND){ 1108 ll_handle_conn_ind(rx_packet); 1109 } 1110 else { 1111 radio_state = RADIO_LOWPOWER; 1112 } 1113 } else { 1114 // DATA PDU 1115 uint8_t ll_id = rx_packet->header & 3; 1116 if (ll_id == PDU_DATA_LLID_CTRL) { 1117 ll_handle_control(rx_packet); 1118 } else { 1119 ll_handle_data(rx_packet); 1120 } 1121 } 1122 } 1123 // free packet 1124 btstack_memory_ll_pdu_free(rx_packet); 1125 } 1126 1127 switch ( ll_state ){ 1128 case LL_STATE_ADVERTISING: 1129 ll_advertising_statemachine(); 1130 break; 1131 default: 1132 break; 1133 } 1134 1135 // generate HCI events 1136 1137 // report num complete packets 1138 /** critical section start */ 1139 hal_cpu_disable_irqs(); 1140 uint8_t num_completed = ctx.num_completed; 1141 ctx.num_completed = 0; 1142 hal_cpu_enable_irqs(); 1143 /** critical section end */ 1144 if (num_completed > 0){ 1145 ll_emit_hci_event(&hci_event_number_of_completed_packets_1, 1, HCI_CON_HANDLE, num_completed); 1146 } 1147 1148 // report connection event 1149 if (ll_send_connection_complete){ 1150 ll_send_connection_complete = false; 1151 ll_emit_hci_event(&hci_subevent_le_connection_complete, 1152 ERROR_CODE_SUCCESS, HCI_CON_HANDLE, 0x01 /* slave */, ctx.peer_addr_type, ctx.peer_addr, 1153 ctx.conn_interval_1250us, ctx.conn_latency, ctx.supervision_timeout_10ms, 0 /* master clock accuracy */); 1154 } 1155 1156 // report disconnection event 1157 if (ll_send_disconnected){ 1158 ll_send_disconnected = false; 1159 ll_emit_hci_event(&hci_event_disconnection_complete, ERROR_CODE_SUCCESS, HCI_CON_HANDLE, 0); 1160 } 1161 } 1162 bool ll_reserve_acl_packet(void){ 1163 if (ll_reserved_acl_buffer == NULL){ 1164 ll_reserved_acl_buffer = btstack_memory_ll_pdu_get(); 1165 } 1166 return ll_reserved_acl_buffer != NULL; 1167 } 1168 1169 void ll_queue_acl_packet(const uint8_t * packet, uint16_t size){ 1170 btstack_assert(ll_reserved_acl_buffer != NULL); 1171 1172 ll_pdu_t * tx_packet = ll_reserved_acl_buffer; 1173 ll_reserved_acl_buffer = NULL; 1174 1175 switch ((packet[1] >> 4) & 0x03){ 1176 case 0: 1177 case 2: 1178 tx_packet->header = PDU_DATA_LLID_DATA_START; 1179 break; 1180 case 1: 1181 tx_packet->header = PDU_DATA_LLID_DATA_CONTINUE; 1182 break; 1183 case 3: 1184 while(1); 1185 break; 1186 default: 1187 break; 1188 } 1189 tx_packet->len = size - 4; 1190 memcpy(tx_packet->payload, &packet[4], size - 4); 1191 btstack_linked_queue_enqueue(&ctx.tx_queue, (btstack_linked_item_t *) tx_packet); 1192 } 1193 1194 void ll_register_packet_handler(void (*packet_handler)(uint8_t packet_type, uint8_t * packet, uint16_t size)){ 1195 controller_packet_handler = packet_handler; 1196 } 1197