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