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

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2014 Google, Inc.
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18 #include <string.h>
  19 #include "common/bt_defs.h"
  20 #include "common/bt_trace.h"
  21 #include "stack/bt_types.h"
  22 #include "hci/buffer_allocator.h"
  23 #include "osi/fixed_queue.h"
  24 #include "hci/hci_hal.h"
  25 #include "hci/hci_internals.h"
  26 #include "hci/hci_layer.h"
  27 #include "osi/thread.h"
  28 #include "esp_bt.h"
  29
  30 #if (C2H_FLOW_CONTROL_INCLUDED == TRUE)
  31 #include "l2c_int.h"
  32 #include "stack/hcimsgs.h"
  33 #endif ///C2H_FLOW_CONTROL_INCLUDED == TRUE
  34
  35 #define HCI_HAL_SERIAL_BUFFER_SIZE 1026
  36 #define HCI_BLE_EVENT 0x3e
  37 #define PACKET_TYPE_TO_INBOUND_INDEX(type) ((type) - 2)
  38 #define PACKET_TYPE_TO_INDEX(type) ((type) - 1)
  39
  40
  41 static const uint8_t preamble_sizes[] = {
  42     HCI_COMMAND_PREAMBLE_SIZE,
  43     HCI_ACL_PREAMBLE_SIZE,
  44     HCI_SCO_PREAMBLE_SIZE,
  45     HCI_EVENT_PREAMBLE_SIZE
  46 };
  47
  48 static const uint16_t outbound_event_types[] = {
  49     MSG_HC_TO_STACK_HCI_ERR,
  50     MSG_HC_TO_STACK_HCI_ACL,
  51     MSG_HC_TO_STACK_HCI_SCO,
  52     MSG_HC_TO_STACK_HCI_EVT
  53 };
  54
  55 typedef struct {
  56     const allocator_t *allocator;
  57     size_t buffer_size;
  58     fixed_queue_t *rx_q;
  59 } hci_hal_env_t;
  60
  61
  62 static hci_hal_env_t hci_hal_env;
  63 static const hci_hal_t interface;
  64 static const hci_hal_callbacks_t *callbacks;
  65 static const esp_vhci_host_callback_t vhci_host_cb;
  66
  67 static xTaskHandle xHciH4TaskHandle;
  68 static xQueueHandle xHciH4Queue;
  69
  70 static void host_send_pkt_available_cb(void);
  71 static int host_recv_pkt_cb(uint8_t *data, uint16_t len);
  72
  73 static void hci_hal_h4_rx_handler(void *arg);
  74 static void event_uart_has_bytes(fixed_queue_t *queue);
  75
  76
  77 static void hci_hal_env_init(
  78     size_t buffer_size,
  79     size_t max_buffer_count)
  80 {
  81     assert(buffer_size > 0);
  82     assert(max_buffer_count > 0);
  83
  84     hci_hal_env.allocator = buffer_allocator_get_interface();
  85     hci_hal_env.buffer_size = buffer_size;
  86
  87     hci_hal_env.rx_q = fixed_queue_new(max_buffer_count);
  88     if (hci_hal_env.rx_q) {
  89         fixed_queue_register_dequeue(hci_hal_env.rx_q, event_uart_has_bytes);
  90     } else {
  91         HCI_TRACE_ERROR("%s unable to create rx queue.\n", __func__);
  92     }
  93
  94     return;
  95 }
  96
  97 static void hci_hal_env_deinit(void)
  98 {
  99     fixed_queue_free(hci_hal_env.rx_q, hci_hal_env.allocator->free);
 100 }
 101
 102 static bool hal_open(const hci_hal_callbacks_t *upper_callbacks)
 103 {
 104     assert(upper_callbacks != NULL);
 105     callbacks = upper_callbacks;
 106
 107     hci_hal_env_init(HCI_HAL_SERIAL_BUFFER_SIZE, SIZE_MAX);
 108
 109     xHciH4Queue = xQueueCreate(HCI_H4_QUEUE_LEN, sizeof(BtTaskEvt_t));
 110     xTaskCreatePinnedToCore(hci_hal_h4_rx_handler, HCI_H4_TASK_NAME, HCI_H4_TASK_STACK_SIZE, NULL, HCI_H4_TASK_PRIO, &xHciH4TaskHandle, HCI_H4_TASK_PINNED_TO_CORE);
 111
 112     //register vhci host cb
 113     esp_vhci_host_register_callback(&vhci_host_cb);
 114
 115
 116     return true;
 117 }
 118
 119 static void hal_close()
 120 {
 121     hci_hal_env_deinit();
 122
 123     /* delete task and queue */
 124     vTaskDelete(xHciH4TaskHandle);
 125     vQueueDelete(xHciH4Queue);
 126 }
 127
 128 /**
 129  * Function: transmit_data -TX data to low-layer
 130  * It is ported from Bluedroid source code, so it is not
 131  * needed to use write() to send data.
 132  * TODO: Just use firmware API to send data.
 133  */
 134 static uint16_t transmit_data(serial_data_type_t type,
 135                               uint8_t *data, uint16_t length)
 136 {
 137     uint8_t previous_byte;
 138
 139     assert(data != NULL);
 140     assert(length > 0);
 141
 142     if (type < DATA_TYPE_COMMAND || type > DATA_TYPE_SCO) {
 143         HCI_TRACE_ERROR("%s invalid data type: %d", __func__, type);
 144         return 0;
 145     }
 146
 147     // Write the signal byte right before the data
 148     --data;
 149     previous_byte = *data;
 150     *(data) = type;
 151     ++length;
 152
 153     BTTRC_DUMP_BUFFER("Transmit Pkt", data, length);
 154
 155     // TX Data to target
 156     esp_vhci_host_send_packet(data, length);
 157
 158     // Be nice and restore the old value of that byte
 159     *(data) = previous_byte;
 160
 161     return length - 1;
 162 }
 163
 164 // Internal functions
 165 static void hci_hal_h4_rx_handler(void *arg)
 166 {
 167     BtTaskEvt_t e;
 168
 169     for (;;) {
 170         if (pdTRUE == xQueueReceive(xHciH4Queue, &e, (portTickType)portMAX_DELAY)) {
 171             if (e.sig == SIG_HCI_HAL_RECV_PACKET) {
 172                 fixed_queue_process(hci_hal_env.rx_q);
 173
 174             }
 175         }
 176     }
 177 }
 178
 179 task_post_status_t hci_hal_h4_task_post(task_post_t timeout)
 180 {
 181     BtTaskEvt_t evt;
 182
 183     evt.sig = SIG_HCI_HAL_RECV_PACKET;
 184     evt.par = 0;
 185
 186     if (xQueueSend(xHciH4Queue, &evt, timeout) != pdTRUE) {
 187         HCI_TRACE_ERROR("xHciH4Queue failed\n");
 188         return TASK_POST_SUCCESS;
 189     }
 190
 191     return TASK_POST_FAIL;
 192 }
 193
 194 #if (C2H_FLOW_CONTROL_INCLUDED == TRUE)
 195 static void hci_packet_complete(BT_HDR *packet){
 196     uint8_t type, num_handle;
 197     uint16_t handle;
 198     uint16_t handles[MAX_L2CAP_LINKS + 4];
 199     uint16_t num_packets[MAX_L2CAP_LINKS + 4];
 200     uint8_t *stream = packet->data + packet->offset;
 201     tL2C_LCB  *p_lcb = NULL;
 202
 203     STREAM_TO_UINT8(type, stream);
 204     if (type == DATA_TYPE_ACL/* || type == DATA_TYPE_SCO*/) {
 205         STREAM_TO_UINT16(handle, stream);
 206         handle = handle & HCI_DATA_HANDLE_MASK;
 207         p_lcb = l2cu_find_lcb_by_handle(handle);
 208         if (p_lcb) {
 209             p_lcb->completed_packets++;
 210         }
 211         if (esp_vhci_host_check_send_available()){
 212             num_handle = l2cu_find_completed_packets(handles, num_packets);
 213             if (num_handle > 0){
 214                 btsnd_hcic_host_num_xmitted_pkts (num_handle, handles, num_packets);
 215             }
 216         } else {
 217             //Send HCI_Host_Number_of_Completed_Packets next time.
 218         }
 219
 220     }
 221 }
 222 #endif ///C2H_FLOW_CONTROL_INCLUDED == TRUE
 223
 224
 225 static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
 226 {
 227     uint8_t type, hdr_size;
 228     uint16_t length;
 229     uint8_t *stream = packet->data + packet->offset;
 230
 231     if (!packet) {
 232         return;
 233     }
 234
 235 #if (C2H_FLOW_CONTROL_INCLUDED == TRUE)
 236     hci_packet_complete(packet);
 237 #endif ///C2H_FLOW_CONTROL_INCLUDED == TRUE
 238
 239     STREAM_TO_UINT8(type, stream);
 240     packet->offset++;
 241     packet->len--;
 242     if (type == HCI_BLE_EVENT) {
 243         uint8_t len = 0;
 244         STREAM_TO_UINT8(len, stream);
 245         HCI_TRACE_ERROR("Workround stream corrupted during LE SCAN: pkt_len=%d ble_event_len=%d\n",
 246                   packet->len, len);
 247         hci_hal_env.allocator->free(packet);
 248         return;
 249     }
 250     if (type < DATA_TYPE_ACL || type > DATA_TYPE_EVENT) {
 251         HCI_TRACE_ERROR("%s Unknown HCI message type. Dropping this byte 0x%x,"
 252                   " min %x, max %x\n", __func__, type,
 253                   DATA_TYPE_ACL, DATA_TYPE_EVENT);
 254         hci_hal_env.allocator->free(packet);
 255         return;
 256     }
 257     hdr_size = preamble_sizes[type - 1];
 258     if (packet->len < hdr_size) {
 259         HCI_TRACE_ERROR("Wrong packet length type=%d pkt_len=%d hdr_len=%d",
 260                   type, packet->len, hdr_size);
 261         hci_hal_env.allocator->free(packet);
 262         return;
 263     }
 264     if (type == DATA_TYPE_ACL) {
 265         stream += hdr_size - 2;
 266         STREAM_TO_UINT16(length, stream);
 267     } else {
 268         stream += hdr_size - 1;
 269         STREAM_TO_UINT8(length, stream);
 270     }
 271
 272     if ((length + hdr_size) != packet->len) {
 273         HCI_TRACE_ERROR("Wrong packet length type=%d hdr_len=%d pd_len=%d "
 274                   "pkt_len=%d", type, hdr_size, length, packet->len);
 275         hci_hal_env.allocator->free(packet);
 276         return;
 277     }
 278
 279     packet->event = outbound_event_types[PACKET_TYPE_TO_INDEX(type)];
 280     callbacks->packet_ready(packet);
 281 }
 282
 283 static void event_uart_has_bytes(fixed_queue_t *queue)
 284 {
 285     BT_HDR *packet;
 286     while (!fixed_queue_is_empty(queue)) {
 287         packet = fixed_queue_dequeue(queue);
 288         hci_hal_h4_hdl_rx_packet(packet);
 289     }
 290 }
 291
 292 static void host_send_pkt_available_cb(void)
 293 {
 294     //Controller rx cache buffer is ready for receiving new host packet
 295     //Just Call Host main thread task to process pending packets.
 296     hci_host_task_post(TASK_POST_BLOCKING);
 297 }
 298
 299 static int host_recv_pkt_cb(uint8_t *data, uint16_t len)
 300 {
 301     //Target has packet to host, malloc new buffer for packet
 302     BT_HDR *pkt;
 303     size_t pkt_size;
 304
 305     pkt_size = BT_HDR_SIZE + len;
 306     pkt = (BT_HDR *)hci_hal_env.allocator->alloc(pkt_size);
 307     if (!pkt) {
 308         HCI_TRACE_ERROR("%s couldn't aquire memory for inbound data buffer.\n", __func__);
 309         return -1;
 310     }
 311     pkt->offset = 0;
 312     pkt->len = len;
 313     pkt->layer_specific = 0;
 314     memcpy(pkt->data, data, len);
 315     fixed_queue_enqueue(hci_hal_env.rx_q, pkt);
 316     hci_hal_h4_task_post(TASK_POST_BLOCKING);
 317
 318     BTTRC_DUMP_BUFFER("Recv Pkt", pkt->data, len);
 319
 320     return 0;
 321 }
 322
 323 static const esp_vhci_host_callback_t vhci_host_cb = {
 324     .notify_host_send_available = host_send_pkt_available_cb,
 325     .notify_host_recv = host_recv_pkt_cb,
 326 };
 327
 328 static const hci_hal_t interface = {
 329     hal_open,
 330     hal_close,
 331     transmit_data,
 332 };
 333
 334 const hci_hal_t *hci_hal_h4_get_interface()
 335 {
 336     return &interface;
 337 }
 338