Add NimBLE HCI driver and transport layers with overrides

This adds the transport and HCI driver layers and the necessary override functions
to allow the NimBLE host to communicate with the controller when bluedroid was enabled in Arduino.

Author: h2zero

src/nimble/esp_port/esp-hci/src/na_hci_driver.c

@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef ESP_PLATFORM
+#include "syscfg/syscfg.h"
+#if CONFIG_BT_LE_CONTROLLER_NPL_OS_PORTING_SUPPORT
+
+#include <string.h>
+#include <stdio.h>
+#include "esp_hci_internal.h"
+#include "esp_hci_driver.h"
+
+typedef struct {
+    hci_driver_forward_fn *forward_cb;
+} hci_driver_vhci_env_t;
+
+static hci_driver_vhci_env_t s_hci_driver_vhci_env;
+
+static int
+hci_driver_vhci_controller_tx(hci_driver_data_type_t data_type, uint8_t *data)
+{
+    /* The length is contained in the data. */
+    return s_hci_driver_vhci_env.forward_cb(data_type, data, 0, HCI_DRIVER_DIR_C2H);
+}
+
+static int
+hci_driver_vhci_host_tx(hci_driver_data_type_t data_type, uint8_t *data, uint32_t length)
+{
+    return s_hci_driver_vhci_env.forward_cb(data_type, data, length, HCI_DRIVER_DIR_H2C);
+}
+
+static int
+hci_driver_vhci_tx(hci_driver_data_type_t data_type, uint8_t *data, uint32_t length,
+                       hci_driver_direction_t dir)
+{
+    int rc;
+
+    if (dir == HCI_DRIVER_DIR_C2H) {
+        rc = hci_driver_vhci_controller_tx(data_type, data);
+    } else {
+        rc = hci_driver_vhci_host_tx(data_type, data, length);
+    }
+    return rc;
+}
+
+static int
+hci_driver_vhci_init(hci_driver_forward_fn *cb)
+{
+    s_hci_driver_vhci_env.forward_cb = cb;
+    return 0;
+}
+
+static void
+hci_driver_vhci_deinit(void)
+{
+    memset(&s_hci_driver_vhci_env, 0, sizeof(hci_driver_vhci_env_t));
+}
+
+hci_driver_ops_t hci_driver_vhci_ops = {
+    .hci_driver_tx = hci_driver_vhci_tx,
+    .hci_driver_init = hci_driver_vhci_init,
+    .hci_driver_deinit = hci_driver_vhci_deinit,
+};
+
+#endif
+#endif

src/nimble/esp_port/esp-hci/src/na_hci_transport.c

@@ -0,0 +1,185 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef ESP_PLATFORM
+#include "syscfg/syscfg.h"
+#if CONFIG_BT_LE_CONTROLLER_NPL_OS_PORTING_SUPPORT
+
+#include <stdio.h>
+#include <string.h>
+#include "esp_log.h"
+#include "nimble/esp_port/port/transport/include/esp_hci_transport.h"
+#include "esp_hci_internal.h"
+#include "esp_bt.h"
+
+typedef struct hci_transport_env
+{
+    hci_transport_host_recv_fn *host_recv_cb;
+    hci_driver_ops_t *driver_ops;
+} hci_transport_env_t;
+
+static hci_transport_env_t s_hci_transport_env;
+
+/* Functions for packets Rx. */
+static int
+hci_transport_controller_packet_rx(hci_driver_data_type_t data_type, uint8_t *data)
+{
+    if (data_type == HCI_DRIVER_TYPE_CMD) {
+        r_ble_hci_trans_hs_cmd_tx(data);
+    }
+
+    if (data_type == HCI_DRIVER_TYPE_ACL) {
+        r_ble_hci_trans_hs_acl_tx((struct os_mbuf *) data);
+    }
+    return 0;
+}
+
+static int
+hci_transport_host_packet_rx(hci_driver_data_type_t data_type, uint8_t *data, uint32_t length)
+{
+    if (!s_hci_transport_env.host_recv_cb) {
+        return -1;
+    }
+    return s_hci_transport_env.host_recv_cb((hci_trans_pkt_ind_t)data_type, data, length);
+}
+
+static int
+hci_transport_packet_rx(hci_driver_data_type_t data_type, uint8_t *data, uint32_t length,
+                        hci_driver_direction_t dir)
+{
+    int rc;
+    if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
+        return -1;
+    }
+
+    if (dir == HCI_DRIVER_DIR_C2H) {
+        rc = hci_transport_host_packet_rx(data_type, data, length);
+    } else {
+        rc = hci_transport_controller_packet_rx(data_type, data);
+    }
+
+    return rc;
+}
+
+/* Functions for controller Tx. */
+static int
+hci_transport_controller_tx_dummy(void *data, void *arg)
+{
+    return -1;
+}
+
+static int
+hci_transport_controller_evt_tx(uint8_t *hci_ev, void *arg)
+{
+    uint32_t len;
+
+    if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
+        r_ble_hci_trans_buf_free(hci_ev);
+        return -1;
+    }
+
+    len = hci_ev[1] + 2;
+    return s_hci_transport_env.driver_ops->hci_driver_tx(HCI_DRIVER_TYPE_EVT, hci_ev, len,
+                                                         HCI_DRIVER_DIR_C2H);
+}
+
+static int
+hci_transport_controller_acl_tx(struct os_mbuf *om, void *arg)
+{
+    uint16_t len;
+    if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
+        os_mbuf_free_chain(om);
+        return -1;
+    }
+
+    len = OS_MBUF_PKTHDR(om)->omp_len;
+    return s_hci_transport_env.driver_ops->hci_driver_tx(HCI_DRIVER_TYPE_ACL, (uint8_t *)om, len,
+                                                         HCI_DRIVER_DIR_C2H);
+}
+
+/* Functions for host Tx. */
+int
+na_hci_transport_host_cmd_tx(uint8_t *data, uint32_t length)
+{
+    return s_hci_transport_env.driver_ops->hci_driver_tx(HCI_DRIVER_TYPE_CMD, data, length,
+                                                         HCI_DRIVER_DIR_H2C);
+}
+
+int
+na_hci_transport_host_acl_tx(uint8_t *data, uint32_t length)
+{
+    return s_hci_transport_env.driver_ops->hci_driver_tx(HCI_DRIVER_TYPE_ACL, data, length,
+                                                         HCI_DRIVER_DIR_H2C);
+}
+
+int
+na_hci_transport_host_callback_register(hci_transport_host_recv_fn *callback)
+{
+    s_hci_transport_env.host_recv_cb = callback;
+    return 0;
+}
+
+int
+na_hci_transport_init(uint8_t hci_transport_mode)
+{
+    int rc;
+    hci_driver_ops_t *ops;
+
+    memset(&s_hci_transport_env, 0, sizeof(hci_transport_env_t));
+
+    switch(hci_transport_mode) {
+#if CONFIG_BT_LE_HCI_INTERFACE_USE_RAM
+        case HCI_TRANSPORT_VHCI:
+            ops = &hci_driver_vhci_ops;
+            break;
+#endif // CONFIG_BT_LE_HCI_INTERFACE_USE_RAM
+#if CONFIG_BT_LE_HCI_INTERFACE_USE_UART
+#if CONFIG_BT_LE_UART_HCI_DMA_MODE
+        case HCI_TRANSPORT_UART_UHCI:
+            ops = &hci_driver_uart_dma_ops;
+            break;
+#else
+        case HCI_TRANSPORT_UART_NO_DMA:
+            ops = &hci_driver_uart_ops;
+            break;
+#endif // CONFIG_BT_LE_UART_HCI_DMA_MODE
+#endif // CONFIG_BT_LE_HCI_INTERFACE_USE_UART
+        default:
+            assert(0);
+    }
+
+    rc = ops->hci_driver_init(hci_transport_packet_rx);
+    if (rc) {
+        goto error;
+    }
+
+    s_hci_transport_env.driver_ops = ops;
+    r_ble_hci_trans_cfg_hs(hci_transport_controller_evt_tx, NULL, hci_transport_controller_acl_tx, NULL);
+
+    return 0;
+
+error:
+    na_hci_transport_deinit();
+    return rc;
+}
+
+void
+na_hci_transport_deinit(void)
+{
+    hci_driver_ops_t *ops;
+
+    r_ble_hci_trans_cfg_hs((esp_hci_internal_rx_cmd_fn *)hci_transport_controller_tx_dummy, NULL,
+                           (esp_hci_internal_rx_acl_fn *)hci_transport_controller_tx_dummy, NULL);
+
+    ops = s_hci_transport_env.driver_ops;
+    if (ops) {
+        ops->hci_driver_deinit();
+    }
+    memset(&s_hci_transport_env, 0, sizeof(hci_transport_env_t));
+}
+
+#endif
+#endif

src/nimble/esp_port/port/transport/include/esp_hci_transport.h

@@ -48,18 +48,22 @@ typedef int hci_transport_host_recv_fn(hci_trans_pkt_ind_t type, uint8_t *data,
  * @return int    Returns 0 on success, or a non-zero error code on failure.
  */
 int hci_transport_init(uint8_t hci_transport_mode);
+int na_hci_transport_init(uint8_t hci_transport_mode);
+
 
 /**
  * @brief Deinitialize the HCI transport layer for releasing any allocated resources.
  */
 void hci_transport_deinit(void);
+void na_hci_transport_deinit(void);
 
 /**
  * @brief Set the host's HCI callback which will be invoked when receiving ACL/Events from controller.
  * @param callback  hci_transport_host_recv_fn type variable
  * @return int 0 on success, non-zero error code on failure.
  */
 int hci_transport_host_callback_register(hci_transport_host_recv_fn *callback);
+int na_hci_transport_host_callback_register(hci_transport_host_recv_fn *callback);
 
 /**
  * @brief Called to send HCI commands form host to controller.
@@ -68,6 +72,7 @@ int hci_transport_host_callback_register(hci_transport_host_recv_fn *callback);
  * @return int 0 on success, non-zero error code on failure.
  */
 int hci_transport_host_cmd_tx(uint8_t *data, uint32_t length);
+int na_hci_transport_host_cmd_tx(uint8_t *data, uint32_t length);
 
 /**
  * @brief Called to send HCI ACL form host to controller.
@@ -76,6 +81,7 @@ int hci_transport_host_cmd_tx(uint8_t *data, uint32_t length);
  * @return int 0 on success, non-zero error code on failure.
  */
 int hci_transport_host_acl_tx(uint8_t *data, uint32_t length);
+int na_hci_transport_host_acl_tx(uint8_t *data, uint32_t length);
 
 #ifdef __cplusplus
 }

src/nimble/nimble/transport/esp_ipc/src/hci_esp_ipc.c

@@ -41,25 +41,25 @@ ble_transport_host_recv_cb(hci_trans_pkt_ind_t type, uint8_t *data, uint16_t len
 int
 ble_transport_to_ll_cmd_impl(void *buf)
 {
-    return hci_transport_host_cmd_tx(buf, 0);
+    return na_hci_transport_host_cmd_tx(buf, 0);
 }
 
 int
 ble_transport_to_ll_acl_impl(struct os_mbuf *om)
 {
-    return hci_transport_host_acl_tx((uint8_t *)om, 0);
+    return na_hci_transport_host_acl_tx((uint8_t *)om, 0);
 }
 
 void
 ble_transport_ll_init(void)
 {
-    hci_transport_host_callback_register(ble_transport_host_recv_cb);
+    na_hci_transport_host_callback_register(ble_transport_host_recv_cb);
 }
 
 void
 ble_transport_ll_deinit(void)
 {
-    hci_transport_host_callback_register(ble_transport_dummy_host_recv_cb);
+    na_hci_transport_host_callback_register(ble_transport_dummy_host_recv_cb);
 }
 
 void *

src/nimble/porting/nimble/src/nimble_port.c

@@ -42,6 +42,9 @@
 #if !CONFIG_BT_CONTROLLER_ENABLED
 #include "nimble/nimble/transport/include/nimble/transport.h"
 #endif
+#if CONFIG_BT_LE_CONTROLLER_NPL_OS_PORTING_SUPPORT
+#include "nimble/esp_port/port/transport/include/esp_hci_transport.h"
+#endif
 // #if (BT_HCI_LOG_INCLUDED == TRUE)
 // #include "hci_log/bt_hci_log.h"
 // #endif // (BT_HCI_LOG_INCLUDED == TRUE)
@@ -120,6 +123,9 @@ esp_err_t esp_nimble_init(void)
     os_mempool_module_init();
     os_msys_init();
 
+#elif CONFIG_BT_LE_CONTROLLER_NPL_OS_PORTING_SUPPORT
+    hci_transport_deinit();
+    na_hci_transport_init(HCI_TRANSPORT_VHCI);
 #endif
 
     ble_transport_ll_init();
@@ -253,6 +259,10 @@ nimble_port_deinit(void)
     }
 #endif
 
+#if CONFIG_BT_LE_CONTROLLER_NPL_OS_PORTING_SUPPORT
+    na_hci_transport_deinit();
+#endif
+
 #if (BT_HCI_LOG_INCLUDED == TRUE)
     //bt_hci_log_deinit();
 #endif // (BT_HCI_LOG_INCLUDED == TRUE)