bluetooth.h

Go to the documentation of this file.

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_BLUETOOTH_H_
#define ZEPHYR_INCLUDE_DRIVERS_BLUETOOTH_H_

 
#include <stdbool.h>
#include <stdint.h>
#include <zephyr/net_buf.h>
#include <zephyr/bluetooth/buf.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/hci_vs.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct bt_hci_setup_params {
        bt_addr_t public_addr;
};
 
enum {
        /* The host should never send HCI_Reset */
        BT_HCI_QUIRK_NO_RESET = BIT(0),
        /* The controller does not auto-initiate a DLE procedure when the
         * initial connection data length parameters are not equal to the
         * default data length parameters. Therefore the host should initiate
         * the DLE procedure after connection establishment.
         *
         * That requirement is stated in Core Spec v5.4 Vol 6 Part B. 4.5.10
         * Data PDU length management:
         *
         * > For a new connection:
         * > - ... If either value is not 27, then the Controller should
         * >   initiate the Data Length Update procedure at the earliest
         * >   practical opportunity.
         */
        BT_HCI_QUIRK_NO_AUTO_DLE = BIT(1),
        BT_HCI_QUIRK_NO_FLOW_CONTROL = BIT(2),
        BT_HCI_QUIRK_NO_ADV_TERM_ON_DIR_TIMEOUT = BIT(3),
};
 
#define BT_DT_HCI_QUIRK_OR(node_id, prop, idx) \
        UTIL_CAT(BT_HCI_QUIRK_, DT_STRING_UPPER_TOKEN_BY_IDX(node_id, prop, idx))
#define BT_DT_HCI_QUIRKS_GET(node_id) (COND_CODE_1(DT_NODE_HAS_PROP(node_id, bt_hci_quirks), \
                                                   (DT_FOREACH_PROP_ELEM_SEP(node_id, \
                                                                             bt_hci_quirks, \
                                                                             BT_DT_HCI_QUIRK_OR, \
                                                                             (|))), \
                                                   (0)))
#define BT_DT_HCI_QUIRKS_INST_GET(inst) BT_DT_HCI_QUIRKS_GET(DT_DRV_INST(inst))
 
#define BT_DT_HCI_NAME_GET(node_id) DT_PROP_OR(node_id, bt_hci_name, "HCI")
#define BT_DT_HCI_NAME_INST_GET(inst) BT_DT_HCI_NAME_GET(DT_DRV_INST(inst))
 
/* Fallback default when there's no property, same as "virtual" */
#define BT_PRIV_HCI_BUS_DEFAULT (0)
#define BT_DT_HCI_BUS_GET(node_id) DT_ENUM_IDX_OR(node_id, bt_hci_bus, BT_PRIV_HCI_BUS_DEFAULT)
 
#define BT_DT_HCI_BUS_INST_GET(inst) BT_DT_HCI_BUS_GET(DT_DRV_INST(inst))

struct bt_hci_driver_config {
        uint32_t quirks;
};

#define BT_DT_HCI_DRIVER_CONFIG_GET(node_id)                                                    \
        {                                                                                       \
                .quirks = (uint32_t)BT_DT_HCI_QUIRKS_GET(node_id),                                \
        }

 
#define BT_DT_HCI_DRIVER_CONFIG_INST_GET(inst)                                                  \
        BT_DT_HCI_DRIVER_CONFIG_GET(DT_DRV_INST(inst))


typedef int (*bt_hci_recv_t)(const struct device *dev, struct net_buf *buf);

struct bt_hci_driver_data {
        bt_hci_recv_t recv;
#if defined(CONFIG_BT_HCI_SET_PUBLIC_ADDR) || defined(__DOXYGEN__)
        bt_addr_t public_addr;
#endif /* CONFIG_BT_HCI_SET_PUBLIC_ADDR */
};

typedef int (*bt_hci_api_open_t)(const struct device *dev);

typedef int (*bt_hci_api_close_t)(const struct device *dev);

typedef int (*bt_hci_api_send_t)(const struct device *dev, struct net_buf *buf);

typedef int (*bt_hci_api_setup_t)(const struct device *dev,
                                  const struct bt_hci_setup_params *param);

__subsystem struct bt_hci_driver_api {
        bt_hci_api_open_t open;
        bt_hci_api_close_t close;
        bt_hci_api_send_t send;
#if defined(CONFIG_BT_HCI_SETUP) || defined(__DOXYGEN__)
        bt_hci_api_setup_t setup;
#endif /* CONFIG_BT_HCI_SETUP */
};


static inline int bt_hci_recv_err(const struct device *dev, struct net_buf *buf)
{
        struct bt_hci_driver_data *data = dev->data;
 
        if (data->recv == NULL) {
                return -ENOTCONN;
        }
 
        return data->recv(dev, buf);
}

static inline void bt_hci_recv(const struct device *dev, struct net_buf *buf)
{
        int err;
 
        err = bt_hci_recv_err(dev, buf);
        if (err != 0) {
                net_buf_unref(buf);
        }
}

static inline int bt_hci_open(const struct device *dev, bt_hci_recv_t recv)
{
        struct bt_hci_driver_data *data = dev->data;
        int err;
 
        if (data->recv != NULL) {
                return -EALREADY;
        }
 
        data->recv = recv;
 
        err = DEVICE_API_GET(bt_hci, dev)->open(dev);
        if (err != 0) {
                data->recv = NULL;
        }
 
        return err;
}

static inline bool bt_hci_can_close(const struct device *dev)
{
        return DEVICE_API_GET(bt_hci, dev)->close != NULL;
}

static inline int bt_hci_close(const struct device *dev)
{
        struct bt_hci_driver_data *data = dev->data;
        int err = 0;
 
        if (!bt_hci_can_close(dev)) {
                return -ENOSYS;
        }
 
        err = DEVICE_API_GET(bt_hci, dev)->close(dev);
        if (err == 0) {
                data->recv = NULL;
        }
 
        return err;
}

static inline int bt_hci_send(const struct device *dev, struct net_buf *buf)
{
        return DEVICE_API_GET(bt_hci, dev)->send(dev, buf);
}
 
#if defined(CONFIG_BT_HCI_SETUP) || defined(__DOXYGEN__)
static inline int bt_hci_setup(const struct device *dev, struct bt_hci_setup_params *params)
{
        const struct bt_hci_driver_api *api = DEVICE_API_GET(bt_hci, dev);
 
        if (api->setup == NULL) {
                return -ENOSYS;
        }
 
        return api->setup(dev, params);
}
#endif

void bt_hci_set_public_addr(const struct device *dev, const bt_addr_t *addr);

const bt_addr_t *bt_hci_get_public_addr(const struct device *dev);

 
/* The following functions are not strictly part of the HCI driver API, in that
 * they do not take as input a struct device which implements the HCI driver API.
 */

int bt_hci_transport_setup(const struct device *dev);

int bt_hci_transport_teardown(const struct device *dev);

struct net_buf *bt_hci_evt_create(uint8_t evt, uint8_t len);

struct net_buf *bt_hci_cmd_complete_create(uint16_t op, uint8_t plen);

struct net_buf *bt_hci_cmd_status_create(uint16_t op, uint8_t status);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_BLUETOOTH_H_ */