1 /*
2 * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <assert.h>
8 #include "sysinit/sysinit.h"
9 #include "nimble/hci_common.h"
10 #if CONFIG_BT_NIMBLE_ENABLED
11 #include "host/ble_hs.h"
12 #endif //CONFIG_BT_NIMBLE_ENABLED
13 #include "nimble/nimble_port.h"
14 #include "nimble/nimble_port_freertos.h"
15 #include "esp_nimble_hci.h"
16 #include "esp_nimble_mem.h"
17 #include "bt_osi_mem.h"
18 #if CONFIG_BT_CONTROLLER_ENABLED
19 #include "esp_bt.h"
20 #endif
21 #include "freertos/semphr.h"
22 #include "esp_compiler.h"
23 #include "soc/soc_caps.h"
24 #include "bt_common.h"
25 #include "hci_log/bt_hci_log.h"
26
27 #define NIMBLE_VHCI_TIMEOUT_MS 2000
28 #define BLE_HCI_EVENT_HDR_LEN (2)
29 #define BLE_HCI_CMD_HDR_LEN (3)
30
31 static ble_hci_trans_rx_cmd_fn *ble_hci_rx_cmd_hs_cb;
32 static void *ble_hci_rx_cmd_hs_arg;
33
34 static ble_hci_trans_rx_acl_fn *ble_hci_rx_acl_hs_cb;
35 static void *ble_hci_rx_acl_hs_arg;
36
37 /*
38 * The MBUF payload size must accommodate the HCI data header size plus the
39 * maximum ACL data packet length. The ACL block size is the size of the
40 * mbufs we will allocate.
41 */
42 #define ACL_BLOCK_SIZE OS_ALIGN(MYNEWT_VAL(BLE_TRANSPORT_ACL_SIZE) \
43 + BLE_MBUF_MEMBLOCK_OVERHEAD \
44 + BLE_HCI_DATA_HDR_SZ, OS_ALIGNMENT)
45
46
47
48 static SemaphoreHandle_t vhci_send_sem;
49 const static char *TAG = "NimBLE";
50
51 int os_msys_buf_alloc(void);
52 void os_msys_buf_free(void);
53 extern uint8_t ble_hs_enabled_state;
54
ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn * cmd_cb,void * cmd_arg,ble_hci_trans_rx_acl_fn * acl_cb,void * acl_arg)55 void ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *cmd_cb,
56 void *cmd_arg,
57 ble_hci_trans_rx_acl_fn *acl_cb,
58 void *acl_arg)
59 {
60 ble_hci_rx_cmd_hs_cb = cmd_cb;
61 ble_hci_rx_cmd_hs_arg = cmd_arg;
62 ble_hci_rx_acl_hs_cb = acl_cb;
63 ble_hci_rx_acl_hs_arg = acl_arg;
64 }
65
esp_vhci_host_send_packet_wrapper(uint8_t * data,uint16_t len)66 void esp_vhci_host_send_packet_wrapper(uint8_t *data, uint16_t len)
67 {
68 #if (BT_HCI_LOG_INCLUDED == TRUE)
69 bt_hci_log_record_hci_data(data[0], &data[1], len - 1);
70 #endif
71 esp_vhci_host_send_packet(data, len);
72 }
73
ble_hci_trans_hs_cmd_tx(uint8_t * cmd)74 int ble_hci_trans_hs_cmd_tx(uint8_t *cmd)
75 {
76 uint16_t len;
77 uint8_t rc = 0;
78
79 assert(cmd != NULL);
80 *cmd = BLE_HCI_UART_H4_CMD;
81 len = BLE_HCI_CMD_HDR_LEN + cmd[3] + 1;
82 if (!esp_vhci_host_check_send_available()) {
83 ESP_LOGD(TAG, "Controller not ready to receive packets");
84 }
85
86 if (xSemaphoreTake(vhci_send_sem, NIMBLE_VHCI_TIMEOUT_MS / portTICK_PERIOD_MS) == pdTRUE) {
87 esp_vhci_host_send_packet_wrapper(cmd, len);
88 } else {
89 rc = BLE_HS_ETIMEOUT_HCI;
90 }
91
92 ble_transport_free(cmd);
93 return rc;
94 }
95
ble_hci_trans_ll_evt_tx(uint8_t * hci_ev)96 int ble_hci_trans_ll_evt_tx(uint8_t *hci_ev)
97 {
98 int rc = ESP_FAIL;
99
100 rc = ble_transport_to_hs_evt((void *)hci_ev);
101 return rc;
102 }
103
ble_hci_trans_hs_acl_tx(struct os_mbuf * om)104 int ble_hci_trans_hs_acl_tx(struct os_mbuf *om)
105 {
106 uint16_t len = 0;
107 uint8_t data[MYNEWT_VAL(BLE_TRANSPORT_ACL_SIZE) + 1], rc = 0;
108 /* If this packet is zero length, just free it */
109 if (OS_MBUF_PKTLEN(om) == 0) {
110 os_mbuf_free_chain(om);
111 return 0;
112 }
113 data[0] = BLE_HCI_UART_H4_ACL;
114 len++;
115
116 if (!esp_vhci_host_check_send_available()) {
117 ESP_LOGD(TAG, "Controller not ready to receive packets");
118 }
119
120 os_mbuf_copydata(om, 0, OS_MBUF_PKTLEN(om), &data[1]);
121 len += OS_MBUF_PKTLEN(om);
122
123 if (xSemaphoreTake(vhci_send_sem, NIMBLE_VHCI_TIMEOUT_MS / portTICK_PERIOD_MS) == pdTRUE) {
124 esp_vhci_host_send_packet_wrapper(data, len);
125 } else {
126 rc = BLE_HS_ETIMEOUT_HCI;
127 }
128
129 os_mbuf_free_chain(om);
130
131 return rc;
132 }
133
ble_hci_trans_ll_acl_tx(struct os_mbuf * om)134 int ble_hci_trans_ll_acl_tx(struct os_mbuf *om)
135 {
136 int rc = ESP_FAIL;
137
138 rc = ble_transport_to_hs_acl((void *)om);
139 return rc;
140 }
141
142
143
ble_hci_trans_reset(void)144 int ble_hci_trans_reset(void)
145 {
146 /* No work to do. All allocated buffers are owned by the host or
147 * controller, and they will get freed by their owners.
148 */
149 return 0;
150 }
151
152
ble_hci_rx_acl(uint8_t * data,uint16_t len)153 static void ble_hci_rx_acl(uint8_t *data, uint16_t len)
154 {
155 struct os_mbuf *m = NULL;
156 int rc;
157 int sr;
158 if (len < BLE_HCI_DATA_HDR_SZ || len > MYNEWT_VAL(BLE_TRANSPORT_ACL_SIZE)) {
159 return;
160 }
161
162 do {
163 m = ble_transport_alloc_acl_from_ll();
164
165 if (!m) {
166 esp_rom_printf("Failed to allocate buffer, retrying ");
167 /* Give some time to free buffer and try again */
168 vTaskDelay(1);
169 }
170 }while(!m);
171
172 if ((rc = os_mbuf_append(m, data, len)) != 0) {
173 esp_rom_printf("%s failed to os_mbuf_append; rc = %d", __func__, rc);
174 os_mbuf_free_chain(m);
175 return;
176 }
177 OS_ENTER_CRITICAL(sr);
178 ble_transport_to_hs_acl(m);
179 OS_EXIT_CRITICAL(sr);
180 }
181
182 /*
183 * @brief: BT controller callback function, used to notify the upper layer that
184 * controller is ready to receive command
185 */
controller_rcv_pkt_ready(void)186 static void controller_rcv_pkt_ready(void)
187 {
188 if (vhci_send_sem) {
189 xSemaphoreGive(vhci_send_sem);
190 }
191 }
192
dummy_controller_rcv_pkt_ready(void)193 static void dummy_controller_rcv_pkt_ready(void)
194 {
195 /* Dummy function */
196 }
197
bt_record_hci_data(uint8_t * data,uint16_t len)198 void bt_record_hci_data(uint8_t *data, uint16_t len)
199 {
200 #if (BT_HCI_LOG_INCLUDED == TRUE)
201 if ((data[0] == BLE_HCI_UART_H4_EVT) && (data[1] == BLE_HCI_EVCODE_LE_META) && ((data[3] == BLE_HCI_LE_SUBEV_ADV_RPT) || (data[3] == BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT)
202 || (data[3] == BLE_HCI_LE_SUBEV_EXT_ADV_RPT) || (data[3] == BLE_HCI_LE_SUBEV_PERIODIC_ADV_RPT))) {
203 bt_hci_log_record_hci_adv(HCI_LOG_DATA_TYPE_ADV, &data[2], len - 2);
204 } else {
205 uint8_t data_type = ((data[0] == 2) ? HCI_LOG_DATA_TYPE_C2H_ACL : data[0]);
206 bt_hci_log_record_hci_data(data_type, &data[1], len - 1);
207 }
208 #endif // (BT_HCI_LOG_INCLUDED == TRUE)
209 }
210
dummy_host_rcv_pkt(uint8_t * data,uint16_t len)211 static int dummy_host_rcv_pkt(uint8_t *data, uint16_t len)
212 {
213 /* Dummy function */
214 return 0;
215 }
216
217 /*
218 * @brief: BT controller callback function, to transfer data packet to the host
219 */
host_rcv_pkt(uint8_t * data,uint16_t len)220 static int host_rcv_pkt(uint8_t *data, uint16_t len)
221 {
222 bt_record_hci_data(data, len);
223
224 if(!ble_hs_enabled_state) {
225 /* If host is not enabled, drop the packet */
226 esp_rom_printf("Host not enabled. Dropping the packet!");
227 return 0;
228 }
229
230 if (data[0] == BLE_HCI_UART_H4_EVT) {
231 uint8_t *evbuf;
232 int totlen;
233 int rc;
234
235 totlen = BLE_HCI_EVENT_HDR_LEN + data[2];
236 assert(totlen <= UINT8_MAX + BLE_HCI_EVENT_HDR_LEN);
237
238 if (totlen > MYNEWT_VAL(BLE_TRANSPORT_EVT_SIZE)) {
239 esp_rom_printf("Received HCI data length at host (%d) exceeds maximum configured HCI event buffer size (%d).",
240 totlen, MYNEWT_VAL(BLE_TRANSPORT_EVT_SIZE));
241 ble_hs_sched_reset(BLE_HS_ECONTROLLER);
242 return 0;
243 }
244
245 if (data[1] == BLE_HCI_EVCODE_HW_ERROR) {
246 assert(0);
247 }
248
249 /* Allocate LE Advertising Report Event from lo pool only */
250 if ((data[1] == BLE_HCI_EVCODE_LE_META) &&
251 (data[3] == BLE_HCI_LE_SUBEV_ADV_RPT || data[3] == BLE_HCI_LE_SUBEV_EXT_ADV_RPT)) {
252 evbuf = ble_transport_alloc_evt(1);
253 /* Skip advertising report if we're out of memory */
254 if (!evbuf) {
255 return 0;
256 }
257 } else {
258 evbuf = ble_transport_alloc_evt(0);
259 assert(evbuf != NULL);
260 }
261
262 memset(evbuf, 0, sizeof *evbuf);
263 memcpy(evbuf, &data[1], totlen);
264
265 rc = ble_hci_trans_ll_evt_tx(evbuf);
266 assert(rc == 0);
267 } else if (data[0] == BLE_HCI_UART_H4_ACL) {
268 ble_hci_rx_acl(data + 1, len - 1);
269 }
270 return 0;
271 }
272
273 static const esp_vhci_host_callback_t vhci_host_cb = {
274 .notify_host_send_available = controller_rcv_pkt_ready,
275 .notify_host_recv = host_rcv_pkt,
276 };
277
278 static const esp_vhci_host_callback_t dummy_vhci_host_cb = {
279 .notify_host_send_available = dummy_controller_rcv_pkt_ready,
280 .notify_host_recv = dummy_host_rcv_pkt,
281 };
282
283
284 extern void ble_transport_init(void);
285 extern esp_err_t ble_buf_alloc(void);
286 extern void ble_buf_free(void);
esp_nimble_hci_init(void)287 esp_err_t esp_nimble_hci_init(void)
288 {
289 esp_err_t ret;
290
291 ret = ble_buf_alloc();
292 if (ret != ESP_OK) {
293 goto err;
294 }
295 if ((ret = esp_vhci_host_register_callback(&vhci_host_cb)) != ESP_OK) {
296 goto err;
297 }
298
299 ble_transport_init();
300
301 vhci_send_sem = xSemaphoreCreateBinary();
302 if (vhci_send_sem == NULL) {
303 ret = ESP_ERR_NO_MEM;
304 goto err;
305 }
306
307 xSemaphoreGive(vhci_send_sem);
308
309 #if MYNEWT_VAL(BLE_QUEUE_CONG_CHECK)
310 ble_adv_list_init();
311 #endif
312
313 return ret;
314 err:
315 ble_buf_free();
316 return ret;
317
318 }
319
320 extern void ble_transport_deinit(void);
esp_nimble_hci_deinit(void)321 esp_err_t esp_nimble_hci_deinit(void)
322 {
323 if (vhci_send_sem) {
324 /* Dummy take & give semaphore before deleting */
325 xSemaphoreTake(vhci_send_sem, portMAX_DELAY);
326 xSemaphoreGive(vhci_send_sem);
327 vSemaphoreDelete(vhci_send_sem);
328 vhci_send_sem = NULL;
329 }
330 ble_transport_deinit();
331
332 esp_vhci_host_register_callback(&dummy_vhci_host_cb);
333
334 ble_buf_free();
335
336 #if MYNEWT_VAL(BLE_QUEUE_CONG_CHECK)
337 ble_adv_list_deinit();
338 #endif
339
340 return ESP_OK;
341 }
342
