From 86007550e226fd810135558c2aa08acbdc602e95 Mon Sep 17 00:00:00 2001 From: Roshan Bangar Date: Mon, 26 Dec 2022 20:56:55 +0530 Subject: [PATCH] Nimble: Migration changes for nimble-1.5 --- nimble/host/mesh/include/mesh/glue.h | 2 +- nimble/host/mesh/src/adv_legacy.c | 8 + nimble/host/mesh/src/prov_device.c | 2 + nimble/host/mesh/src/proxy_srv.c | 8 + nimble/host/src/ble_hs.c | 7 + nimble/host/src/ble_hs_flow.c | 12 +- nimble/host/src/ble_hs_hci.c | 2 + nimble/host/src/ble_hs_hci_cmd.c | 4 +- nimble/host/src/ble_hs_hci_evt.c | 2 +- nimble/transport/include/nimble/transport.h | 302 +++++++++++++++++- .../transport/include/nimble/transport_impl.h | 3 + nimble/transport/src/transport.c | 19 ++ porting/nimble/src/nimble_port.c | 6 +- porting/npl/freertos/src/npl_os_freertos.c | 4 +- 14 files changed, 365 insertions(+), 16 deletions(-) diff --git a/nimble/host/mesh/include/mesh/glue.h b/nimble/host/mesh/include/mesh/glue.h index c4d058849..66722fe99 100644 --- a/nimble/host/mesh/include/mesh/glue.h +++ b/nimble/host/mesh/include/mesh/glue.h @@ -438,7 +438,7 @@ int bt_le_adv_start(const struct ble_gap_adv_params *param, const struct bt_data *ad, size_t ad_len, const struct bt_data *sd, size_t sd_len); -int bt_le_adv_stop(); +int bt_le_adv_stop(void); struct k_work_delayable { struct ble_npl_callout work; diff --git a/nimble/host/mesh/src/adv_legacy.c b/nimble/host/mesh/src/adv_legacy.c index e495dd614..c3a526e03 100644 --- a/nimble/host/mesh/src/adv_legacy.c +++ b/nimble/host/mesh/src/adv_legacy.c @@ -18,6 +18,14 @@ #include "mesh/glue.h" #include "pb_gatt_srv.h" +#ifndef min +#define min(a, b) ((a) < (b) ? (a) : (b)) +#endif + +#ifndef max +#define max(a, b) ((a) > (b) ? (a) : (b)) +#endif + #if MYNEWT_VAL(BLE_MESH_ADV_LEGACY) /* Convert from ms to 0.625ms units */ #define ADV_SCAN_UNIT(_ms) ((_ms) * 8 / 5) diff --git a/nimble/host/mesh/src/prov_device.c b/nimble/host/mesh/src/prov_device.c index e9e2d2b12..01b1eac36 100644 --- a/nimble/host/mesh/src/prov_device.c +++ b/nimble/host/mesh/src/prov_device.c @@ -300,6 +300,7 @@ static void prov_dh_key_gen(void) uint8_t remote_pk_le[BT_PUB_KEY_LEN]; remote_pk = bt_mesh_prov_link.conf_inputs.pub_key_provisioner; +#if !CONFIG_BT_NIMBLE_CRYPTO_STACK_MBEDTLS if (MYNEWT_VAL(BLE_MESH_PROV_OOB_PUBLIC_KEY) && atomic_test_bit(bt_mesh_prov_link.flags, OOB_PUB_KEY)) { if (uECC_valid_public_key(remote_pk, &curve_secp256r1)) { @@ -316,6 +317,7 @@ static void prov_dh_key_gen(void) prov_fail(PROV_ERR_UNEXP_ERR); return; } +#endif /* Copy remote key in little-endian for bt_dh_key_gen(). * X and Y halves are swapped independently. The bt_dh_key_gen() diff --git a/nimble/host/mesh/src/proxy_srv.c b/nimble/host/mesh/src/proxy_srv.c index 65a5af78d..9beb34a28 100644 --- a/nimble/host/mesh/src/proxy_srv.c +++ b/nimble/host/mesh/src/proxy_srv.c @@ -27,6 +27,14 @@ #include "proxy_msg.h" #include "pb_gatt_srv.h" +#ifndef min +#define min(a, b) ((a) < (b) ? (a) : (b)) +#endif + +#ifndef max +#define max(a, b) ((a) > (b) ? (a) : (b)) +#endif + #if defined(CONFIG_BT_MESH_PROXY_USE_DEVICE_NAME) #define ADV_OPT_USE_NAME BT_LE_ADV_OPT_USE_NAME #else diff --git a/nimble/host/src/ble_hs.c b/nimble/host/src/ble_hs.c index cd181f725..b314bf9f1 100644 --- a/nimble/host/src/ble_hs.c +++ b/nimble/host/src/ble_hs.c @@ -799,6 +799,11 @@ ble_hs_init(void) ble_hs_evq_set(nimble_port_get_dflt_eventq()); #endif +#if SOC_ESP_NIMBLE_CONTROLLER + /* Configure the HCI transport to communicate with a host. */ + ble_hci_trans_cfg_hs(ble_hs_hci_rx_evt, NULL, ble_hs_rx_data, NULL); +#endif + /* Enqueue the start event to the default event queue. Using the default * queue ensures the event won't run until the end of main(). This allows * the application to configure this package in the meantime. @@ -844,7 +849,9 @@ ble_hs_deinit(void) ble_monitor_deinit(); #endif +#if SOC_ESP_NIMBLE_CONTROLLER ble_hci_trans_cfg_hs(NULL, NULL, NULL, NULL); +#endif ble_npl_mutex_deinit(&ble_hs_mutex); diff --git a/nimble/host/src/ble_hs_flow.c b/nimble/host/src/ble_hs_flow.c index 8b8430dae..6cb70b861 100644 --- a/nimble/host/src/ble_hs_flow.c +++ b/nimble/host/src/ble_hs_flow.c @@ -40,7 +40,7 @@ static ble_npl_event_fn ble_hs_flow_event_cb; static struct ble_npl_event ble_hs_flow_ev; /* Connection handle associated with each mbuf in ACL pool */ -static uint16_t ble_hs_flow_mbuf_conn_handle[ MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_LL_COUNT) ]; +static uint16_t ble_hs_flow_mbuf_conn_handle[ MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_HS_COUNT) ]; static inline int ble_hs_flow_mbuf_index(const struct os_mbuf *om) @@ -135,7 +135,7 @@ ble_hs_flow_inc_completed_pkts(struct ble_hs_conn *conn) conn->bhc_completed_pkts++; ble_hs_flow_num_completed_pkts++; - if (ble_hs_flow_num_completed_pkts > MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_LL_COUNT)) { + if (ble_hs_flow_num_completed_pkts > MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_HS_COUNT)) { ble_hs_sched_reset(BLE_HS_ECONTROLLER); return; } @@ -143,7 +143,7 @@ ble_hs_flow_inc_completed_pkts(struct ble_hs_conn *conn) /* If the number of free buffers is at or below the configured threshold, * send an immediate number-of-copmleted-packets event. */ - num_free = MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_LL_COUNT) - + num_free = MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_HS_COUNT) - ble_hs_flow_num_completed_pkts; if (num_free <= MYNEWT_VAL(BLE_HS_FLOW_CTRL_THRESH)) { ble_npl_eventq_put(ble_hs_evq_get(), &ble_hs_flow_ev); @@ -231,7 +231,7 @@ ble_hs_flow_startup(void) struct ble_hci_cb_ctlr_to_host_fc_cp enable_cmd; struct ble_hci_cb_host_buf_size_cp buf_size_cmd = { .acl_data_len = htole16(MYNEWT_VAL(BLE_TRANSPORT_ACL_SIZE)), - .acl_num = htole16(MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_LL_COUNT)), + .acl_num = htole16(MYNEWT_VAL(BLE_TRANSPORT_ACL_FROM_HS_COUNT)), }; int rc; @@ -265,7 +265,11 @@ ble_hs_flow_startup(void) /* Flow control successfully enabled. */ ble_hs_flow_num_completed_pkts = 0; +#if SOC_ESP_NIMBLE_CONTROLLER + ble_hci_trans_set_acl_free_cb(ble_hs_flow_acl_free, NULL); +#else ble_transport_register_put_acl_from_ll_cb(ble_hs_flow_acl_free); +#endif ble_npl_callout_init(&ble_hs_flow_timer, ble_hs_evq_get(), ble_hs_flow_event_cb, NULL); #endif diff --git a/nimble/host/src/ble_hs_hci.c b/nimble/host/src/ble_hs_hci.c index 0f0de25c2..083740bff 100644 --- a/nimble/host/src/ble_hs_hci.c +++ b/nimble/host/src/ble_hs_hci.c @@ -24,6 +24,8 @@ #include "mem/mem.h" #include "ble_hs_priv.h" +#include "nimble/transport.h" + #define BLE_HCI_CMD_TIMEOUT_MS 2000 static struct ble_npl_mutex ble_hs_hci_mutex; diff --git a/nimble/host/src/ble_hs_hci_cmd.c b/nimble/host/src/ble_hs_hci_cmd.c index 69fa16702..3ab9ea088 100644 --- a/nimble/host/src/ble_hs_hci_cmd.c +++ b/nimble/host/src/ble_hs_hci_cmd.c @@ -41,7 +41,7 @@ ble_hs_hci_cmd_transport(struct ble_hci_cmd *cmd) { int rc; - rc = ble_transport_to_ll_cmd(cmd); + rc = ble_transport_to_ll_cmd((uint8_t *)cmd); switch (rc) { case 0: return 0; @@ -61,7 +61,7 @@ ble_hs_hci_cmd_send(uint16_t opcode, uint8_t len, const void *cmddata) uint8_t *buf; int rc; - cmd = ble_transport_alloc_cmd(); + cmd = (struct ble_hci_cmd *)ble_transport_alloc_cmd(); BLE_HS_DBG_ASSERT(cmd != NULL); buf = (uint8_t *)cmd; diff --git a/nimble/host/src/ble_hs_hci_evt.c b/nimble/host/src/ble_hs_hci_evt.c index bcdee219a..acd9eb5a8 100644 --- a/nimble/host/src/ble_hs_hci_evt.c +++ b/nimble/host/src/ble_hs_hci_evt.c @@ -980,7 +980,7 @@ ble_hs_hci_evt_process(struct ble_hci_ev *ev) rc = entry->cb(ev->opcode, ev->data, ev->length); } - ble_transport_free(ev); + ble_transport_free((uint8_t *)ev); return rc; } diff --git a/nimble/transport/include/nimble/transport.h b/nimble/transport/include/nimble/transport.h index 9e0eb6695..069b709d4 100644 --- a/nimble/transport/include/nimble/transport.h +++ b/nimble/transport/include/nimble/transport.h @@ -26,10 +26,306 @@ extern "C" { #include #include +#include +#include "os/os_mempool.h" +#define BLE_HCI_TRANS_CMD_SZ 260 +/*** Type of buffers for holding commands and events. */ +/** + * Controller-to-host event buffers. Events have one of two priorities: + * o Low-priority (BLE_HCI_TRANS_BUF_EVT_LO) + * o High-priority (BLE_HCI_TRANS_BUF_EVT_HI) + * + * Low-priority event buffers are only used for advertising reports. If there + * are no free low-priority event buffers, then an incoming advertising report + * will get dropped. + * + * High-priority event buffers are for everything except advertising reports. + * If there are no free high-priority event buffers, a request to allocate one + * will try to allocate a low-priority buffer instead. + * + * If you want all events to be given equal treatment, then you should allocate + * low-priority events only. + * + * Event priorities solve the problem of critical events getting dropped due to + * a flood of advertising reports. This solution is likely temporary: when + * HCI flow control is added, event priorities may become obsolete. + * + * Not all transports distinguish between low and high priority events. If the + * transport does not have separate settings for low and high buffer counts, + * then it treats all events with equal priority. + */ +#define BLE_HCI_TRANS_BUF_EVT_LO 1 +#define BLE_HCI_TRANS_BUF_EVT_HI 2 + +/* Host-to-controller command. */ +#define BLE_HCI_TRANS_BUF_CMD 3 + +/** Callback function types; executed when HCI packets are received. */ +typedef int ble_hci_trans_rx_cmd_fn(uint8_t *cmd, void *arg); +typedef int ble_hci_trans_rx_acl_fn(struct os_mbuf *om, void *arg); + +#if SOC_ESP_NIMBLE_CONTROLLER +#define ble_transport_alloc_cmd() ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_CMD) +#define ble_transport_alloc_event(X) ble_hci_trans_buf_alloc(X ? BLE_HCI_TRANS_BUF_EVT_LO : BLE_HCI_TRANS_BUF_EVT_HI) +#define ble_transport_free ble_hci_trans_buf_free + +struct ble_hci_trans_funcs_t { + int(*_ble_hci_trans_hs_acl_tx)(struct os_mbuf *om); + int(*_ble_hci_trans_hs_cmd_tx)(uint8_t *cmd); + int(*_ble_hci_trans_ll_acl_tx)(struct os_mbuf *om); + int(*_ble_hci_trans_ll_evt_tx)(uint8_t *hci_ev); + int(*_ble_hci_trans_reset)(void); + int(*_ble_hci_trans_set_acl_free_cb)(os_mempool_put_fn *cb,void *arg); +}; + +extern struct ble_hci_trans_funcs_t *ble_hci_trans_funcs_ptr; + +/** + * Sends an HCI event from the controller to the host. + * + * @param cmd The HCI event to send. This buffer must be + * allocated via ble_hci_trans_buf_alloc(). + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +extern int r_ble_hci_trans_ll_evt_tx(uint8_t *hci_ev); +#define ble_hci_trans_ll_evt_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_ll_evt_tx + +/** + * Sends ACL data from controller to host. + * + * @param om The ACL data packet to send. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +extern int r_ble_hci_trans_ll_acl_tx(struct os_mbuf *om); +#define ble_hci_trans_ll_acl_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_ll_acl_tx + +/** + * Sends an HCI command from the host to the controller. + * + * @param cmd The HCI command to send. This buffer must be + * allocated via ble_hci_trans_buf_alloc(). + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +extern int r_ble_hci_trans_hs_cmd_tx(uint8_t *cmd); +#define ble_hci_trans_hs_cmd_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_hs_cmd_tx + +/** + * Sends ACL data from host to controller. + * + * @param om The ACL data packet to send. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +extern int r_ble_hci_trans_hs_acl_tx(struct os_mbuf *om); +#define ble_hci_trans_hs_acl_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_hs_acl_tx + +/** + * Allocates a flat buffer of the specified type. + * + * @param type The type of buffer to allocate; one of the + * BLE_HCI_TRANS_BUF_[...] constants. + * + * @return The allocated buffer on success; + * NULL on buffer exhaustion. + */ +extern uint8_t *r_ble_hci_trans_buf_alloc(int type); +#define ble_hci_trans_buf_alloc r_ble_hci_trans_buf_alloc + +/** + * Frees the specified flat buffer. The buffer must have been allocated via + * ble_hci_trans_buf_alloc(). + * + * @param buf The buffer to free. + */ +extern void r_ble_hci_trans_buf_free(uint8_t *buf); +#define ble_hci_trans_buf_free r_ble_hci_trans_buf_free + +/** + * Configures a callback to get executed whenever an ACL data packet is freed. + * The function is called immediately before the free occurs. + * + * @param cb The callback to configure. + * @param arg An optional argument to pass to the callback. + * + * @return 0 on success; + * BLE_ERR_UNSUPPORTED if the transport does not + * support this operation. + */ +extern int r_ble_hci_trans_set_acl_free_cb(os_mempool_put_fn *cb, void *arg); +#define ble_hci_trans_set_acl_free_cb ble_hci_trans_funcs_ptr->_ble_hci_trans_set_acl_free_cb + +/** + * Configures the HCI transport to operate with a controller. The transport + * will execute specified callbacks upon receiving HCI packets from the host. + * + * @param cmd_cb The callback to execute upon receiving an HCI + * command. + * @param cmd_arg Optional argument to pass to the command + * callback. + * @param acl_cb The callback to execute upon receiving ACL + * data. + * @param acl_arg Optional argument to pass to the ACL + * callback. + */ +extern void r_ble_hci_trans_cfg_ll(ble_hci_trans_rx_cmd_fn *cmd_cb, + void *cmd_arg, + ble_hci_trans_rx_acl_fn *acl_cb, + void *acl_arg); +#define ble_hci_trans_cfg_ll r_ble_hci_trans_cfg_ll + +/** + * Configures the HCI transport to operate with a host. The transport will + * execute specified callbacks upon receiving HCI packets from the controller. + * + * @param evt_cb The callback to execute upon receiving an HCI + * event. + * @param evt_arg Optional argument to pass to the event + * callback. + * @param acl_cb The callback to execute upon receiving ACL + * data. + * @param acl_arg Optional argument to pass to the ACL + * callback. + */ +extern void r_ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *evt_cb, + void *evt_arg, + ble_hci_trans_rx_acl_fn *acl_cb, + void *acl_arg); +#define ble_hci_trans_cfg_hs r_ble_hci_trans_cfg_hs + +/** + * Resets the HCI module to a clean state. Frees all buffers and reinitializes + * the underlying transport. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +extern int r_ble_hci_trans_reset(void); +#define ble_hci_trans_reset ble_hci_trans_funcs_ptr->_ble_hci_trans_reset + +void esp_ble_hci_trans_init(uint8_t); + +#else +/** + * Sends an HCI event from the controller to the host. + * + * @param cmd The HCI event to send. This buffer must be + * allocated via ble_hci_trans_buf_alloc(). + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int ble_hci_trans_ll_evt_tx(uint8_t *hci_ev); + +/** + * Sends ACL data from controller to host. + * + * @param om The ACL data packet to send. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int ble_hci_trans_ll_acl_tx(struct os_mbuf *om); + +/** + * Sends an HCI command from the host to the controller. + * + * @param cmd The HCI command to send. This buffer must be + * allocated via ble_hci_trans_buf_alloc(). + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int ble_hci_trans_hs_cmd_tx(uint8_t *cmd); + +/** + * Sends ACL data from host to controller. + * + * @param om The ACL data packet to send. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int ble_hci_trans_hs_acl_tx(struct os_mbuf *om); + +/** + * Allocates a flat buffer of the specified type. + * + * @param type The type of buffer to allocate; one of the + * BLE_HCI_TRANS_BUF_[...] constants. + * + * @return The allocated buffer on success; + * NULL on buffer exhaustion. + */ +int esp_ble_hci_trans_hs_cmd_tx(uint8_t *cmd); + +/** + * Sends ACL data from host to controller. + * + * @param om The ACL data packet to send. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int esp_ble_hci_trans_hs_acl_tx(struct os_mbuf *om); + +/** + * Allocates a flat buffer of the specified type. + * + * @param type The type of buffer to allocate; one of the + * BLE_HCI_TRANS_BUF_[...] constants. + * + * @return The allocated buffer on success; + * NULL on buffer exhaustion. + */ +uint8_t *esp_ble_hci_trans_buf_alloc(int type); + +/** + * Frees the specified flat buffer. The buffer must have been allocated via + * ble_hci_trans_buf_alloc(). + * + * @param buf The buffer to free. + */ +void esp_ble_hci_trans_buf_free(uint8_t *buf); + +/** + * Configures the HCI transport to operate with a host. The transport will + * execute specified callbacks upon receiving HCI packets from the controller. + * + * @param evt_cb The callback to execute upon receiving an HCI + * event. + * @param evt_arg Optional argument to pass to the event + * callback. + * @param acl_cb The callback to execute upon receiving ACL + * data. + * @param acl_arg Optional argument to pass to the ACL + * callback. + */ +void esp_ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *evt_cb, + void *evt_arg, + ble_hci_trans_rx_acl_fn *acl_cb, + void *acl_arg); + +/** + * Resets the HCI module to a clean state. Frees all buffers and reinitializes + * the underlying transport. + * + * @return 0 on success; + * A BLE_ERR_[...] error code on failure. + */ +int esp_ble_hci_trans_reset(void); +#endif struct os_mbuf; /* Allocators for supported data types */ +#if !SOC_ESP_NIMBLE_CONTROLLER void *ble_transport_alloc_cmd(void); void *ble_transport_alloc_evt(int discardable); struct os_mbuf *ble_transport_alloc_acl_from_hs(void); @@ -37,13 +333,15 @@ struct os_mbuf *ble_transport_alloc_acl_from_ll(void); /* Generic deallocator for cmd/evt buffers */ void ble_transport_free(void *buf); +#endif /* Register put callback on acl_from_ll mbufs (for ll-hs flow control) */ int ble_transport_register_put_acl_from_ll_cb(os_mempool_put_fn *cb); /* Send data to hs/ll side */ -int ble_transport_to_ll_cmd(void *buf); -int ble_transport_to_ll_acl(struct os_mbuf *om); +#define ble_transport_to_ll_acl ble_hci_trans_hs_acl_tx +#define ble_transport_to_ll_cmd ble_hci_trans_hs_cmd_tx + int ble_transport_to_hs_evt(void *buf); int ble_transport_to_hs_acl(struct os_mbuf *om); diff --git a/nimble/transport/include/nimble/transport_impl.h b/nimble/transport/include/nimble/transport_impl.h index 61d8cd68a..4a316c218 100644 --- a/nimble/transport/include/nimble/transport_impl.h +++ b/nimble/transport/include/nimble/transport_impl.h @@ -24,6 +24,9 @@ extern "C" { #endif +#include "os/os_mempool.h" +#include "syscfg/syscfg.h" + /* Init functions to be implemented for transport acting as HS/LL side */ extern void ble_transport_ll_init(void); extern void ble_transport_hs_init(void); diff --git a/nimble/transport/src/transport.c b/nimble/transport/src/transport.c index 0a641a807..c960a4dad 100644 --- a/nimble/transport/src/transport.c +++ b/nimble/transport/src/transport.c @@ -58,6 +58,7 @@ BLE_MBUF_MEMBLOCK_OVERHEAD + \ BLE_HCI_DATA_HDR_SZ, OS_ALIGNMENT)) +#if !SOC_ESP_NIMBLE_CONTROLLER static uint8_t pool_cmd_buf[ OS_MEMPOOL_BYTES(POOL_CMD_COUNT, POOL_CMD_SIZE) ]; static struct os_mempool pool_cmd; @@ -162,6 +163,7 @@ ble_transport_acl_put(struct os_mempool_ext *mpe, void *data, void *arg) do_put = true; from_ll = (pkthdr->omp_flags & OMP_FLAG_FROM_MASK) == OMP_FLAG_FROM_LL; err = 0; + from_ll = true; if (from_ll && transport_put_acl_from_ll_cb) { err = transport_put_acl_from_ll_cb(mpe, data, arg); @@ -211,6 +213,22 @@ ble_transport_init(void) pool_acl.mpe_put_cb = ble_transport_acl_put; } +void +ble_transport_deinit(void) +{ + int rc = 0; + rc = os_mempool_ext_clear(&pool_acl); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mempool_clear(&pool_evt_lo); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mempool_clear(&pool_evt); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mempool_clear(&pool_cmd); + SYSINIT_PANIC_ASSERT(rc == 0); +} int ble_transport_register_put_acl_from_ll_cb(os_mempool_put_fn (*cb)) { @@ -218,3 +236,4 @@ ble_transport_register_put_acl_from_ll_cb(os_mempool_put_fn (*cb)) return 0; } +#endif diff --git a/porting/nimble/src/nimble_port.c b/porting/nimble/src/nimble_port.c index 402a77782..1aeb000d3 100644 --- a/porting/nimble/src/nimble_port.c +++ b/porting/nimble/src/nimble_port.c @@ -39,7 +39,6 @@ #endif -#include "nimble/ble_hci_trans.h" #include "esp_intr_alloc.h" #include "freertos/FreeRTOS.h" @@ -105,9 +104,8 @@ esp_err_t esp_nimble_init(void) /* Initialize the global memory pool */ os_mempool_module_init(); os_msys_init(); - /* Initialize transport */ - ble_transport_init(); -#endif + +#endif /* Initialize the host */ ble_transport_hs_init(); diff --git a/porting/npl/freertos/src/npl_os_freertos.c b/porting/npl/freertos/src/npl_os_freertos.c index 4c3e68bd8..d3cd19587 100644 --- a/porting/npl/freertos/src/npl_os_freertos.c +++ b/porting/npl/freertos/src/npl_os_freertos.c @@ -45,8 +45,8 @@ static const char *TAG = "Timer"; #define OS_MEM_ALLOC (1) #if CONFIG_BT_NIMBLE_ENABLED -#define BT_LE_HCI_EVT_HI_BUF_COUNT MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT) -#define BT_LE_HCI_EVT_LO_BUF_COUNT MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT) +#define BT_LE_HCI_EVT_HI_BUF_COUNT MYNEWT_VAL(BLE_TRANSPORT_EVT_COUNT) +#define BT_LE_HCI_EVT_LO_BUF_COUNT MYNEWT_VAL(BLE_TRANSPORT_EVT_DISCARDABLE_COUNT) #define BT_LE_MAX_EXT_ADV_INSTANCES MYNEWT_VAL(BLE_MULTI_ADV_INSTANCES) #define BT_LE_MAX_CONNECTIONS MYNEWT_VAL(BLE_MAX_CONNECTIONS) #else