granicus.if.org Git - esp-idf/blob - components/bt/bt.c

   1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <stddef.h>
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19
  20 #include "esp_heap_caps_init.h"
  21 #include "freertos/FreeRTOS.h"
  22 #include "freertos/task.h"
  23 #include "freertos/queue.h"
  24 #include "freertos/semphr.h"
  25 #include "freertos/xtensa_api.h"
  26 #include "freertos/portmacro.h"
  27 #include "esp_types.h"
  28 #include "esp_system.h"
  29 #include "esp_task.h"
  30 #include "esp_intr.h"
  31 #include "esp_attr.h"
  32 #include "esp_phy_init.h"
  33 #include "bt.h"
  34 #include "esp_err.h"
  35 #include "esp_log.h"
  36
  37 #if CONFIG_BT_ENABLED
  38
  39 #define BTDM_LOG_TAG                        "BTDM_INIT"
  40
  41 #define BTDM_INIT_PERIOD                    (5000)    /* ms */
  42
  43 /* Bluetooth system and controller config */
  44 #define BTDM_CFG_BT_EM_RELEASE              (1<<0)
  45 #define BTDM_CFG_BT_DATA_RELEASE            (1<<1)
  46 #define BTDM_CFG_HCI_UART                   (1<<2)
  47 #define BTDM_CFG_CONTROLLER_RUN_APP_CPU     (1<<3)
  48 /* Other reserved for future */
  49
  50 /* not for user call, so don't put to include file */
  51 extern void btdm_osi_funcs_register(void *osi_funcs);
  52 extern int btdm_controller_init(uint32_t config_mask, esp_bt_controller_config_t *config_opts);
  53 extern int btdm_controller_deinit(void);
  54 extern int btdm_controller_enable(esp_bt_mode_t mode);
  55 extern int btdm_controller_disable(esp_bt_mode_t mode);
  56 extern uint8_t btdm_controller_get_mode(void);
  57 extern void btdm_rf_bb_init(void);
  58
  59 /* VHCI function interface */
  60 typedef struct vhci_host_callback {
  61     void (*notify_host_send_available)(void);               /*!< callback used to notify that the host can send packet to controller */
  62     int (*notify_host_recv)(uint8_t *data, uint16_t len);   /*!< callback used to notify that the controller has a packet to send to the host*/
  63 } vhci_host_callback_t;
  64
  65 extern bool API_vhci_host_check_send_available(void);
  66 extern void API_vhci_host_send_packet(uint8_t *data, uint16_t len);
  67 extern void API_vhci_host_register_callback(const vhci_host_callback_t *callback);
  68
  69 extern int ble_txpwr_set(int power_type, int power_level);
  70 extern int ble_txpwr_get(int power_type);
  71
  72 #define BT_DEBUG(...)
  73 #define BT_API_CALL_CHECK(info, api_call, ret) \
  74 do{\
  75     esp_err_t __err = (api_call);\
  76     if ((ret) != __err) {\
  77         BT_DEBUG("%s %d %s ret=%d\n", __FUNCTION__, __LINE__, (info), __err);\
  78         return __err;\
  79     }\
  80 } while(0)
  81
  82 #define OSI_FUNCS_TIME_BLOCKING  0xffffffff
  83
  84 struct osi_funcs_t {
  85     xt_handler (*_set_isr)(int n, xt_handler f, void *arg);
  86     void (*_ints_on)(unsigned int mask);
  87     void (*_interrupt_disable)(void);
  88     void (*_interrupt_restore)(void);
  89     void (*_task_yield)(void);
  90     void (*_task_yield_from_isr)(void);
  91     void *(*_semphr_create)(uint32_t max, uint32_t init);
  92     void (*_semphr_delete)(void *semphr);
  93     int32_t (*_semphr_take_from_isr)(void *semphr, void *hptw);
  94     int32_t (*_semphr_give_from_isr)(void *semphr, void *hptw);
  95     int32_t (*_semphr_take)(void *semphr, uint32_t block_time_ms);
  96     int32_t (*_semphr_give)(void *semphr);
  97     void *(*_mutex_create)(void);
  98     void (*_mutex_delete)(void *mutex);
  99     int32_t (*_mutex_lock)(void *mutex);
 100     int32_t (*_mutex_unlock)(void *mutex);
 101     void *(* _queue_create)(uint32_t queue_len, uint32_t item_size);
 102     void (* _queue_delete)(void *queue);
 103     int32_t (* _queue_send)(void *queue, void *item, uint32_t block_time_ms);
 104     int32_t (* _queue_send_from_isr)(void *queue, void *item, void *hptw);
 105     int32_t (* _queue_recv)(void *queue, void *item, uint32_t block_time_ms);
 106     int32_t (* _queue_recv_from_isr)(void *queue, void *item, void *hptw);
 107     int32_t (* _task_create)(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id);
 108     void (* _task_delete)(void *task_handle);
 109     bool (* _is_in_isr)(void);
 110     void *(* _malloc)(uint32_t size);
 111     void (* _free)(void *p);
 112     int32_t (* _read_efuse_mac)(uint8_t mac[6]);
 113     void (* _srand)(unsigned int seed);
 114     int (* _rand)(void);
 115 };
 116
 117 /* Static variable declare */
 118 static bool btdm_bb_init_flag = false;
 119 static esp_bt_controller_status_t btdm_controller_status = ESP_BT_CONTROLLER_STATUS_IDLE;
 120
 121 static portMUX_TYPE global_int_mux = portMUX_INITIALIZER_UNLOCKED;
 122
 123 static void IRAM_ATTR interrupt_disable(void)
 124 {
 125     portENTER_CRITICAL(&global_int_mux);
 126 }
 127
 128 static void IRAM_ATTR interrupt_restore(void)
 129 {
 130     portEXIT_CRITICAL(&global_int_mux);
 131 }
 132
 133 static void IRAM_ATTR task_yield_from_isr(void)
 134 {
 135     portYIELD_FROM_ISR();
 136 }
 137
 138 static void *IRAM_ATTR semphr_create_wrapper(uint32_t max, uint32_t init)
 139 {
 140     return (void *)xSemaphoreCreateCounting(max, init);
 141 }
 142
 143 static void IRAM_ATTR semphr_delete_wrapper(void *semphr)
 144 {
 145     vSemaphoreDelete(semphr);
 146 }
 147
 148 static int32_t IRAM_ATTR semphr_take_from_isr_wrapper(void *semphr, void *hptw)
 149 {
 150     return (int32_t)xSemaphoreTakeFromISR(semphr, hptw);
 151 }
 152
 153 static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw)
 154 {
 155     return (int32_t)xSemaphoreGiveFromISR(semphr, hptw);
 156 }
 157
 158 static int32_t IRAM_ATTR semphr_take_wrapper(void *semphr, uint32_t block_time_ms)
 159 {
 160     if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
 161         return (int32_t)xSemaphoreTake(semphr, portMAX_DELAY);
 162     } else {
 163         return (int32_t)xSemaphoreTake(semphr, block_time_ms / portTICK_PERIOD_MS);
 164     }
 165 }
 166
 167 static int32_t IRAM_ATTR semphr_give_wrapper(void *semphr)
 168 {
 169     return (int32_t)xSemaphoreGive(semphr);
 170 }
 171
 172 static void *IRAM_ATTR mutex_create_wrapper(void)
 173 {
 174     return (void *)xSemaphoreCreateMutex();
 175 }
 176
 177 static void IRAM_ATTR mutex_delete_wrapper(void *mutex)
 178 {
 179     vSemaphoreDelete(mutex);
 180 }
 181
 182 static int32_t IRAM_ATTR mutex_lock_wrapper(void *mutex)
 183 {
 184     return (int32_t)xSemaphoreTake(mutex, portMAX_DELAY);
 185 }
 186
 187 static int32_t IRAM_ATTR mutex_unlock_wrapper(void *mutex)
 188 {
 189     return (int32_t)xSemaphoreGive(mutex);
 190 }
 191
 192 static void *IRAM_ATTR queue_create_wrapper(uint32_t queue_len, uint32_t item_size)
 193 {
 194     return (void *)xQueueCreate(queue_len, item_size);
 195 }
 196
 197 static void IRAM_ATTR queue_delete_wrapper(void *queue)
 198 {
 199     vQueueDelete(queue);
 200 }
 201
 202 static int32_t IRAM_ATTR queue_send_wrapper(void *queue, void *item, uint32_t block_time_ms)
 203 {
 204     if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
 205         return (int32_t)xQueueSend(queue, item, portMAX_DELAY);
 206     } else {
 207         return (int32_t)xQueueSend(queue, item, block_time_ms / portTICK_PERIOD_MS);
 208     }
 209 }
 210
 211 static int32_t IRAM_ATTR queue_send_from_isr_wrapper(void *queue, void *item, void *hptw)
 212 {
 213     return (int32_t)xQueueSendFromISR(queue, item, hptw);
 214 }
 215
 216 static int32_t IRAM_ATTR queue_recv_wrapper(void *queue, void *item, uint32_t block_time_ms)
 217 {
 218     if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
 219         return (int32_t)xQueueReceive(queue, item, portMAX_DELAY);
 220     } else {
 221         return (int32_t)xQueueReceive(queue, item, block_time_ms / portTICK_PERIOD_MS);
 222     }
 223 }
 224
 225 static int32_t IRAM_ATTR queue_recv_from_isr_wrapper(void *queue, void *item, void *hptw)
 226 {
 227     return (int32_t)xQueueReceiveFromISR(queue, item, hptw);
 228 }
 229
 230 static int32_t IRAM_ATTR task_create_wrapper(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id)
 231 {
 232     return (uint32_t)xTaskCreatePinnedToCore(task_func, name, stack_depth, param, prio, task_handle, (core_id < portNUM_PROCESSORS ? core_id : tskNO_AFFINITY));
 233 }
 234
 235 static void IRAM_ATTR task_delete_wrapper(void *task_handle)
 236 {
 237     vTaskDelete(task_handle);
 238 }
 239
 240 static bool IRAM_ATTR is_in_isr_wrapper(void)
 241 {
 242     return (bool)xPortInIsrContext();
 243 }
 244
 245 static int32_t IRAM_ATTR read_mac_wrapper(uint8_t mac[6])
 246 {
 247     return esp_read_mac(mac, ESP_MAC_BT);
 248 }
 249
 250 static void IRAM_ATTR srand_wrapper(unsigned int seed)
 251 {
 252     /* empty function */
 253 }
 254
 255 static int IRAM_ATTR rand_wrapper(void)
 256 {
 257     return (int)esp_random();
 258 }
 259
 260 static struct osi_funcs_t osi_funcs = {
 261     ._set_isr = xt_set_interrupt_handler,
 262     ._ints_on = xt_ints_on,
 263     ._interrupt_disable = interrupt_disable,
 264     ._interrupt_restore = interrupt_restore,
 265     ._task_yield = vPortYield,
 266     ._task_yield_from_isr = task_yield_from_isr,
 267     ._semphr_create = semphr_create_wrapper,
 268     ._semphr_delete = semphr_delete_wrapper,
 269     ._semphr_take_from_isr = semphr_take_from_isr_wrapper,
 270     ._semphr_give_from_isr = semphr_give_from_isr_wrapper,
 271     ._semphr_take = semphr_take_wrapper,
 272     ._semphr_give = semphr_give_wrapper,
 273     ._mutex_create = mutex_create_wrapper,
 274     ._mutex_delete = mutex_delete_wrapper,
 275     ._mutex_lock = mutex_lock_wrapper,
 276     ._mutex_unlock = mutex_unlock_wrapper,
 277     ._queue_create = queue_create_wrapper,
 278     ._queue_delete = queue_delete_wrapper,
 279     ._queue_send = queue_send_wrapper,
 280     ._queue_send_from_isr = queue_send_from_isr_wrapper,
 281     ._queue_recv = queue_recv_wrapper,
 282     ._queue_recv_from_isr = queue_recv_from_isr_wrapper,
 283     ._task_create = task_create_wrapper,
 284     ._task_delete = task_delete_wrapper,
 285     ._is_in_isr = is_in_isr_wrapper,
 286     ._malloc = malloc,
 287     ._free = free,
 288     ._read_efuse_mac = read_mac_wrapper,
 289     ._srand = srand_wrapper,
 290     ._rand = rand_wrapper,
 291 };
 292
 293 bool esp_vhci_host_check_send_available(void)
 294 {
 295     return API_vhci_host_check_send_available();
 296 }
 297
 298 void esp_vhci_host_send_packet(uint8_t *data, uint16_t len)
 299 {
 300     API_vhci_host_send_packet(data, len);
 301 }
 302
 303 void esp_vhci_host_register_callback(const esp_vhci_host_callback_t *callback)
 304 {
 305     API_vhci_host_register_callback((const vhci_host_callback_t *)callback);
 306 }
 307
 308 static uint32_t btdm_config_mask_load(void)
 309 {
 310     uint32_t mask = 0x0;
 311
 312 #ifdef CONFIG_BT_DRAM_RELEASE
 313     mask |= (BTDM_CFG_BT_EM_RELEASE | BTDM_CFG_BT_DATA_RELEASE);
 314 #endif
 315 #ifdef CONFIG_BT_HCI_UART
 316     mask |= BTDM_CFG_HCI_UART;
 317 #endif
 318 #ifdef CONFIG_BTDM_CONTROLLER_RUN_APP_CPU
 319     mask |= BTDM_CFG_CONTROLLER_RUN_APP_CPU;
 320 #endif
 321     return mask;
 322 }
 323
 324 static void btdm_controller_release_mem(void)
 325 {
 326     uint32_t bt_mem_start, bt_mem_end;
 327 #if CONFIG_BT_DRAM_RELEASE
 328     bt_mem_start = 0x3ffb0000; bt_mem_end = 0x3ffb3000; //Reserve BT data region
 329     ESP_ERROR_CHECK( heap_caps_add_region((intptr_t)bt_mem_start, (intptr_t)bt_mem_end));
 330     bt_mem_start = 0x3ffb8000; bt_mem_end = 0x3ffbbb28; //Reserve BT data region
 331     ESP_ERROR_CHECK( heap_caps_add_region((intptr_t)bt_mem_start, (intptr_t)bt_mem_end));
 332     bt_mem_start = 0x3ffbdb28; bt_mem_end = 0x3ffc0000; //Reserve BT data region
 333     ESP_ERROR_CHECK( heap_caps_add_region((intptr_t)bt_mem_start, (intptr_t)bt_mem_end));
 334 #else
 335     bt_mem_start = 0x3ffb0000; bt_mem_end = 0x3ffc0000; //Reserve BT hardware shared memory & BT data region
 336     ESP_ERROR_CHECK( heap_caps_add_region((intptr_t)bt_mem_start, (intptr_t)bt_mem_end));
 337 #endif
 338     bt_mem_start = 0x3ffae2a0; bt_mem_end = 0x3ffaff10; //Reserve ROM data region
 339     ESP_ERROR_CHECK( heap_caps_add_region((intptr_t)bt_mem_start, (intptr_t)bt_mem_end));
 340 }
 341
 342 esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
 343 {
 344     BaseType_t ret;
 345     uint32_t btdm_cfg_mask = 0;
 346
 347     if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_IDLE) {
 348         return ESP_ERR_INVALID_STATE;
 349     }
 350
 351     if (cfg == NULL) {
 352         return ESP_ERR_INVALID_ARG;
 353     }
 354
 355     if (cfg->controller_task_prio != ESP_TASK_BT_CONTROLLER_PRIO
 356             || cfg->controller_task_stack_size < ESP_TASK_BT_CONTROLLER_STACK) {
 357         return ESP_ERR_INVALID_ARG;
 358     }
 359
 360     btdm_osi_funcs_register(&osi_funcs);
 361
 362     btdm_cfg_mask = btdm_config_mask_load();
 363
 364     ret = btdm_controller_init(btdm_cfg_mask, cfg);
 365     if (ret) {
 366         return ESP_ERR_NO_MEM;
 367     }
 368
 369     btdm_controller_status = ESP_BT_CONTROLLER_STATUS_INITED;
 370     return ESP_OK;
 371 }
 372
 373 esp_err_t esp_bt_controller_deinit(void)
 374 {
 375     if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_INITED) {
 376         return ESP_ERR_INVALID_STATE;
 377     }
 378
 379     if (btdm_controller_deinit() != 0) {
 380         return ESP_ERR_NO_MEM;
 381     }
 382
 383     btdm_controller_release_mem();
 384
 385     btdm_controller_status = ESP_BT_CONTROLLER_STATUS_SHUTDOWN;
 386     return ESP_OK;
 387 }
 388
 389 esp_err_t esp_bt_controller_enable(esp_bt_mode_t mode)
 390 {
 391     int ret;
 392
 393     if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_INITED) {
 394         return ESP_ERR_INVALID_STATE;
 395     }
 396 #if CONFIG_BT_DRAM_RELEASE
 397     if (mode != ESP_BT_MODE_BLE) {
 398 #else
 399     if (mode != ESP_BT_MODE_BLE
 400             && mode != ESP_BT_MODE_CLASSIC_BT
 401             && mode != ESP_BT_MODE_BTDM) {
 402 #endif
 403         return ESP_ERR_INVALID_ARG;
 404     }
 405
 406     esp_phy_load_cal_and_init();
 407
 408     if (btdm_bb_init_flag == false) {
 409         btdm_bb_init_flag = true;
 410         btdm_rf_bb_init();  /* only initialise once */
 411     }
 412
 413     ret = btdm_controller_enable(mode);
 414     if (ret) {
 415         return ESP_ERR_INVALID_STATE;
 416     }
 417
 418     btdm_controller_status = ESP_BT_CONTROLLER_STATUS_ENABLED;
 419
 420     return ESP_OK;
 421 }
 422
 423 esp_err_t esp_bt_controller_disable(esp_bt_mode_t mode)
 424 {
 425     int ret;
 426
 427     if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_ENABLED) {
 428         return ESP_ERR_INVALID_STATE;
 429     }
 430
 431     if (mode != btdm_controller_get_mode()) {
 432         ESP_LOGW(BTDM_LOG_TAG, "The input mode should be equal %d, but ignore error, use %d instead of %d\n",
 433                 btdm_controller_get_mode(), btdm_controller_get_mode(), mode);
 434         mode = btdm_controller_get_mode();
 435     }
 436
 437     ret = btdm_controller_disable(mode);
 438     if (ret < 0) {
 439         return ESP_ERR_INVALID_STATE;
 440     }
 441
 442     if (ret == ESP_BT_MODE_IDLE) {
 443         esp_phy_rf_deinit();
 444         btdm_controller_status = ESP_BT_CONTROLLER_STATUS_INITED;
 445     }
 446
 447     return ESP_OK;
 448 }
 449
 450 esp_bt_controller_status_t esp_bt_controller_get_status(void)
 451 {
 452     return btdm_controller_status;
 453 }
 454
 455
 456 /* extra functions */
 457 esp_err_t esp_ble_tx_power_set(esp_ble_power_type_t power_type, esp_power_level_t power_level)
 458 {
 459     if (ble_txpwr_set(power_type, power_level) != 0) {
 460         return ESP_ERR_INVALID_ARG;
 461     }
 462
 463     return ESP_OK;
 464 }
 465
 466 esp_power_level_t esp_ble_tx_power_get(esp_ble_power_type_t power_type)
 467 {
 468     return (esp_power_level_t)ble_txpwr_get(power_type);
 469 }
 470
 471 #endif /*  CONFIG_BT_ENABLED */