1 /* 2 * Copyright (C) 2017 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__ "adv_bearer.c" 39 40 #define ENABLE_LOG_DEBUG 41 42 #include <string.h> 43 44 #include "mesh/adv_bearer.h" 45 #include "ble/core.h" 46 #include "bluetooth.h" 47 #include "bluetooth_data_types.h" 48 #include "btstack_debug.h" 49 #include "btstack_util.h" 50 #include "btstack_run_loop.h" 51 #include "btstack_event.h" 52 #include "gap.h" 53 54 // issue: gap adv control in hci might be slow to update advertisements fast enough. for now add 10 ms extra to ADVERTISING_INTERVAL_CONNECTABLE_MIN_MS 55 // todo: track adv enable/disable events before next step 56 57 // min advertising interval 20 ms for connectable advertisements 58 #define ADVERTISING_INTERVAL_CONNECTABLE_MIN 0x30 59 #define ADVERTISING_INTERVAL_CONNECTABLE_MIN_MS (ADVERTISING_INTERVAL_CONNECTABLE_MIN * 625 / 1000) 60 61 // min advertising interval 100 ms for non-connectable advertisements (pre 5.0 controllers) 62 #define ADVERTISING_INTERVAL_NONCONNECTABLE_MIN 0xa0 63 #define ADVERTISING_INTERVAL_NONCONNECTABLE_MIN_MS (ADVERTISING_INTERVAL_NONCONNECTABLE_MIN * 625 / 1000) 64 65 // num adv bearer message types 66 #define NUM_TYPES 3 67 68 typedef enum { 69 MESH_NETWORK_ID, 70 MESH_BEACON_ID, 71 PB_ADV_ID, 72 INVALID_ID, 73 } message_type_id_t; 74 75 typedef enum { 76 STATE_IDLE, 77 STATE_BEARER, 78 STATE_GAP, 79 } state_t; 80 81 82 // prototypes 83 static void adv_bearer_run(void); 84 85 // globals 86 87 static btstack_packet_callback_registration_t hci_event_callback_registration; 88 static btstack_timer_source_t adv_timer; 89 static int adv_timer_active; 90 static bd_addr_t null_addr; 91 92 static btstack_packet_handler_t client_callbacks[NUM_TYPES]; 93 static int request_can_send_now[NUM_TYPES]; 94 static int last_sender; 95 96 // scheduler 97 static state_t adv_bearer_state; 98 static uint32_t gap_adv_next_ms; 99 100 // adv bearer packets 101 static uint8_t adv_bearer_buffer[31]; 102 static uint8_t adv_bearer_buffer_length; 103 static uint8_t adv_bearer_count; 104 static uint16_t adv_bearer_interval; 105 106 // gap advertising 107 static int gap_advertising_enabled; 108 static uint16_t gap_adv_int_min = 0x30; 109 static uint16_t gap_adv_int_ms; 110 static uint16_t gap_adv_int_max = 0x30; 111 static uint8_t gap_adv_type = 0; 112 static uint8_t gap_direct_address_typ; 113 static bd_addr_t gap_direct_address; 114 static uint8_t gap_channel_map = 0x07; 115 static uint8_t gap_filter_policy = 0; 116 117 static btstack_linked_list_t gap_connectable_advertisements; 118 119 // dispatch advertising events 120 static void adv_bearer_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 121 const uint8_t * data; 122 int data_len; 123 message_type_id_t type_id; 124 125 switch (packet_type){ 126 case HCI_EVENT_PACKET: 127 switch(packet[0]){ 128 case BTSTACK_EVENT_STATE: 129 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break; 130 adv_bearer_run(); 131 break; 132 case GAP_EVENT_ADVERTISING_REPORT: 133 // only non-connectable ind 134 if (gap_event_advertising_report_get_advertising_event_type(packet) != 0x03) break; 135 data = gap_event_advertising_report_get_data(packet); 136 data_len = gap_event_advertising_report_get_data_length(packet); 137 138 switch(data[1]){ 139 case BLUETOOTH_DATA_TYPE_MESH_MESSAGE: 140 type_id = MESH_NETWORK_ID; 141 break; 142 case BLUETOOTH_DATA_TYPE_MESH_BEACON: 143 type_id = MESH_BEACON_ID; 144 break; 145 case BLUETOOTH_DATA_TYPE_PB_ADV: 146 type_id = PB_ADV_ID; 147 break; 148 default: 149 return; 150 } 151 if (client_callbacks[type_id]){ 152 switch (type_id){ 153 case PB_ADV_ID: 154 (*client_callbacks[type_id])(packet_type, channel, packet, size); 155 break; 156 case MESH_NETWORK_ID: 157 (*client_callbacks[type_id])(MESH_NETWORK_PACKET, 0, (uint8_t*) &data[2], data_len-2); 158 break; 159 case MESH_BEACON_ID: 160 (*client_callbacks[type_id])(MESH_BEACON_PACKET, 0, (uint8_t*) &data[2], data_len-2); 161 break; 162 default: 163 break; 164 } 165 } 166 break; 167 default: 168 break; 169 } 170 break; 171 default: 172 break; 173 } 174 } 175 176 // round-robin 177 static void adv_bearer_emit_can_send_now(void){ 178 179 if (adv_bearer_count > 0) return; 180 181 int countdown = NUM_TYPES; 182 while (countdown--) { 183 last_sender++; 184 if (last_sender == NUM_TYPES) { 185 last_sender = 0; 186 } 187 if (request_can_send_now[last_sender]){ 188 request_can_send_now[last_sender] = 0; 189 // emit can send now 190 log_debug("can send now"); 191 uint8_t event[3]; 192 event[0] = HCI_EVENT_MESH_META; 193 event[1] = 1; 194 event[2] = MESH_SUBEVENT_CAN_SEND_NOW; 195 (*client_callbacks[last_sender])(HCI_EVENT_PACKET, 0, &event[0], sizeof(event)); 196 return; 197 } 198 } 199 } 200 201 static void adv_bearer_timeout_handler(btstack_timer_source_t * ts){ 202 UNUSED(ts); 203 adv_timer_active = 0; 204 uint32_t now = btstack_run_loop_get_time_ms(); 205 switch (adv_bearer_state){ 206 case STATE_GAP: 207 log_debug("Timeout (state gap)"); 208 gap_advertisements_enable(0); 209 if (gap_advertising_enabled){ 210 gap_adv_next_ms = now + gap_adv_int_ms - ADVERTISING_INTERVAL_CONNECTABLE_MIN_MS; 211 log_debug("Next adv: %u", gap_adv_next_ms); 212 } 213 adv_bearer_state = STATE_IDLE; 214 break; 215 case STATE_BEARER: 216 log_debug("Timeout (state bearer)"); 217 gap_advertisements_enable(0); 218 adv_bearer_count--; 219 if (adv_bearer_count == 0){ 220 adv_bearer_emit_can_send_now(); 221 } 222 adv_bearer_state = STATE_IDLE; 223 break; 224 default: 225 break; 226 } 227 adv_bearer_run(); 228 } 229 230 static void adv_bearer_set_timeout(uint32_t time_ms){ 231 btstack_run_loop_set_timer_handler(&adv_timer, &adv_bearer_timeout_handler); 232 btstack_run_loop_set_timer(&adv_timer, time_ms); // compile time constants 233 btstack_run_loop_add_timer(&adv_timer); 234 adv_timer_active = 1; 235 } 236 237 // scheduler 238 static void adv_bearer_run(void){ 239 240 if (hci_get_state() != HCI_STATE_WORKING) return; 241 if (adv_timer_active) return; 242 243 uint32_t now = btstack_run_loop_get_time_ms(); 244 switch (adv_bearer_state){ 245 case STATE_IDLE: 246 if (gap_advertising_enabled){ 247 if ((int32_t)(now - gap_adv_next_ms) >= 0){ 248 adv_bearer_connectable_advertisement_data_item_t * item = (adv_bearer_connectable_advertisement_data_item_t *) btstack_linked_list_pop(&gap_connectable_advertisements); 249 if (item == NULL){ 250 gap_adv_next_ms += gap_adv_int_ms; 251 log_debug("Next adv: %u", gap_adv_next_ms); 252 } else { 253 // queue again 254 btstack_linked_list_add_tail(&gap_connectable_advertisements, (void*) item); 255 // time to advertise again 256 log_debug("Start GAP ADV, %p", item); 257 gap_advertisements_set_params(ADVERTISING_INTERVAL_CONNECTABLE_MIN, ADVERTISING_INTERVAL_CONNECTABLE_MIN, gap_adv_type, gap_direct_address_typ, gap_direct_address, gap_channel_map, gap_filter_policy); 258 gap_advertisements_set_data(item->adv_length, item->adv_data); 259 gap_advertisements_enable(1); 260 adv_bearer_state = STATE_GAP; 261 adv_bearer_set_timeout(ADVERTISING_INTERVAL_CONNECTABLE_MIN_MS); 262 break; 263 } 264 } 265 } 266 if (adv_bearer_count > 0){ 267 // schedule adv bearer message if enough time 268 // if ((gap_advertising_enabled) == 0 || ((int32_t)(gap_adv_next_ms - now) >= ADVERTISING_INTERVAL_NONCONNECTABLE_MIN_MS)){ 269 log_debug("Send ADV Bearer message"); 270 // configure LE advertisments: non-conn ind 271 gap_advertisements_set_params(ADVERTISING_INTERVAL_NONCONNECTABLE_MIN, ADVERTISING_INTERVAL_NONCONNECTABLE_MIN, 3, 0, null_addr, 0x07, 0); 272 gap_advertisements_set_data(adv_bearer_buffer_length, adv_bearer_buffer); 273 gap_advertisements_enable(1); 274 adv_bearer_state = STATE_BEARER; 275 adv_bearer_set_timeout(ADVERTISING_INTERVAL_NONCONNECTABLE_MIN_MS); 276 break; 277 // } 278 } 279 if (gap_advertising_enabled){ 280 // use timer to wait for next adv 281 adv_bearer_set_timeout(gap_adv_next_ms - now); 282 } 283 break; 284 default: 285 break; 286 } 287 } 288 289 // 290 static void adv_bearer_prepare_message(const uint8_t * data, uint16_t data_len, uint8_t type, uint8_t count, uint16_t interval){ 291 btstack_assert(data_len <= (sizeof(adv_bearer_buffer)-2)); 292 log_debug("adv bearer message, type 0x%x\n", type); 293 // prepare message 294 adv_bearer_buffer[0] = data_len+1; 295 adv_bearer_buffer[1] = type; 296 memcpy(&adv_bearer_buffer[2], data, data_len); 297 adv_bearer_buffer_length = data_len + 2; 298 299 // setup trasmission schedule 300 adv_bearer_count = count; 301 adv_bearer_interval = interval; 302 } 303 304 ////// 305 306 static void adv_bearer_request(message_type_id_t type_id){ 307 request_can_send_now[type_id] = 1; 308 adv_bearer_emit_can_send_now(); 309 } 310 311 void adv_bearer_init(void){ 312 // register for HCI Events 313 hci_event_callback_registration.callback = &adv_bearer_packet_handler; 314 hci_add_event_handler(&hci_event_callback_registration); 315 // idle 316 adv_bearer_state = STATE_IDLE; 317 memset(null_addr, 0, 6); 318 } 319 320 // adv bearer packet handler regisration 321 322 void adv_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handler){ 323 client_callbacks[MESH_NETWORK_ID] = packet_handler; 324 } 325 void adv_bearer_register_for_beacon(btstack_packet_handler_t packet_handler){ 326 client_callbacks[MESH_BEACON_ID] = packet_handler; 327 } 328 void adv_bearer_register_for_provisioning_pdu(btstack_packet_handler_t packet_handler){ 329 client_callbacks[PB_ADV_ID] = packet_handler; 330 } 331 332 // adv bearer request to send 333 334 void adv_bearer_request_can_send_now_for_network_pdu(void){ 335 adv_bearer_request(MESH_NETWORK_ID); 336 } 337 void adv_bearer_request_can_send_now_for_beacon(void){ 338 adv_bearer_request(MESH_BEACON_ID); 339 } 340 void adv_bearer_request_can_send_now_for_provisioning_pdu(void){ 341 adv_bearer_request(PB_ADV_ID); 342 } 343 344 // adv bearer send message 345 346 void adv_bearer_send_network_pdu(const uint8_t * data, uint16_t data_len, uint8_t count, uint16_t interval){ 347 btstack_assert(data_len <= (sizeof(adv_bearer_buffer)-2)); 348 adv_bearer_prepare_message(data, data_len, BLUETOOTH_DATA_TYPE_MESH_MESSAGE, count, interval); 349 adv_bearer_run(); 350 } 351 void adv_bearer_send_beacon(const uint8_t * data, uint16_t data_len){ 352 btstack_assert(data_len <= (sizeof(adv_bearer_buffer)-2)); 353 adv_bearer_prepare_message(data, data_len, BLUETOOTH_DATA_TYPE_MESH_BEACON, 3, 100); 354 adv_bearer_run(); 355 } 356 void adv_bearer_send_provisioning_pdu(const uint8_t * data, uint16_t data_len){ 357 btstack_assert(data_len <= (sizeof(adv_bearer_buffer)-2)); 358 adv_bearer_prepare_message(data, data_len, BLUETOOTH_DATA_TYPE_PB_ADV, 3, 100); 359 adv_bearer_run(); 360 } 361 362 // gap advertising 363 364 void adv_bearer_advertisements_enable(int enabled){ 365 gap_advertising_enabled = enabled; 366 if (!gap_advertising_enabled) return; 367 368 // start right away 369 gap_adv_next_ms = btstack_run_loop_get_time_ms(); 370 adv_bearer_run(); 371 } 372 373 void adv_bearer_advertisements_add_item(adv_bearer_connectable_advertisement_data_item_t * item){ 374 btstack_linked_list_add(&gap_connectable_advertisements, (void*) item); 375 } 376 377 void adv_bearer_advertisements_remove_item(adv_bearer_connectable_advertisement_data_item_t * item){ 378 btstack_linked_list_remove(&gap_connectable_advertisements, (void*) item); 379 } 380 381 void adv_bearer_advertisements_set_params(uint16_t adv_int_min, uint16_t adv_int_max, uint8_t adv_type, 382 uint8_t direct_address_typ, bd_addr_t direct_address, uint8_t channel_map, uint8_t filter_policy){ 383 384 // assert adv_int_min/max >= 2 * ADVERTISING_INTERVAL_MIN 385 386 gap_adv_int_min = btstack_max(adv_int_min, 2 * ADVERTISING_INTERVAL_CONNECTABLE_MIN); 387 gap_adv_int_max = btstack_max(adv_int_max, 2 * ADVERTISING_INTERVAL_CONNECTABLE_MIN); 388 gap_adv_int_ms = gap_adv_int_min * 625 / 1000; 389 gap_adv_type = adv_type; 390 gap_direct_address_typ = direct_address_typ; 391 memcpy(gap_direct_address, &direct_address, 6); 392 gap_channel_map = channel_map; 393 gap_filter_policy = filter_policy; 394 395 log_info("GAP Adv interval %u ms", gap_adv_int_ms); 396 } 397