classic.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015-2016 Intel Corporation
 * Copyright 2024 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_H_

 
#include <stdbool.h>
#include <string.h>
 
#include <zephyr/sys/util.h>
#include <zephyr/net_buf.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/hci_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct bt_br_discovery_priv {
        uint16_t clock_offset;
        uint8_t pscan_rep_mode;
        uint8_t resolve_state;
};

#define BT_BR_EIR_SIZE_MAX 240

struct bt_br_discovery_result {
        struct bt_br_discovery_priv _priv;

        bt_addr_t addr;

        int8_t rssi;

        uint8_t cod[3];

        uint8_t eir[BT_BR_EIR_SIZE_MAX];
};

struct bt_br_discovery_param {
        uint8_t length;

        bool limited;
};

int bt_br_discovery_start(const struct bt_br_discovery_param *param,
                          struct bt_br_discovery_result *results, size_t count);

int bt_br_discovery_stop(void);
 
struct bt_br_discovery_cb {

        void (*recv)(const struct bt_br_discovery_result *result);

        void (*timeout)(const struct bt_br_discovery_result *results,
                                  size_t count);
 
        sys_snode_t node;
};

void bt_br_discovery_cb_register(struct bt_br_discovery_cb *cb);

void bt_br_discovery_cb_unregister(struct bt_br_discovery_cb *cb);
 
struct bt_br_oob {
        bt_addr_t addr;
};

int bt_br_oob_get_local(struct bt_br_oob *oob);

int bt_br_set_discoverable(bool enable, bool limited);

enum bt_br_conn_req_rsp {
        BT_BR_CONN_REQ_ACCEPT_CENTRAL      = BT_HCI_ROLE_CENTRAL,
        BT_BR_CONN_REQ_ACCEPT_PERIPHERAL   = BT_HCI_ROLE_PERIPHERAL,
        BT_BR_CONN_REQ_REJECT_NO_RESOURCES = BT_HCI_ERR_INSUFFICIENT_RESOURCES,
        BT_BR_CONN_REQ_REJECT_SECURITY     = BT_HCI_ERR_INSUFFICIENT_SECURITY,
        BT_BR_CONN_REQ_REJECT_ADDR         = BT_HCI_ERR_BD_ADDR_UNACCEPTABLE,
};

typedef enum bt_br_conn_req_rsp (*bt_br_conn_req_func_t)(const bt_addr_t *addr, uint32_t cod);

int bt_br_set_connectable(bool enable, bt_br_conn_req_func_t func);

#define BT_BR_SCAN_INTERVAL_MIN 0x0012
#define BT_BR_SCAN_INTERVAL_MAX 0x1000

#define BT_BR_SCAN_WINDOW_MIN 0x0011
#define BT_BR_SCAN_WINDOW_MAX 0x1000


#define BT_BR_PAGE_SCAN_INTERVAL_R0 0x0800
#define BT_BR_PAGE_SCAN_WINDOW_R0   0x0800

#define BT_BR_PAGE_SCAN_FAST_INTERVAL_R1 0x00a0
#define BT_BR_PAGE_SCAN_FAST_WINDOW_R1   0x0011

#define BT_BR_PAGE_SCAN_MEDIUM_INTERVAL_R1 0x0800
#define BT_BR_PAGE_SCAN_MEDIUM_WINDOW_R1   0x0011

#define BT_BR_PAGE_SCAN_SLOW_INTERVAL_R1 0x0800
#define BT_BR_PAGE_SCAN_SLOW_WINDOW_R1   0x0011

#define BT_BR_PAGE_SCAN_FAST_INTERVAL_R2 0x1000
#define BT_BR_PAGE_SCAN_FAST_WINDOW_R2   0x0011

#define BT_BR_PAGE_SCAN_SLOW_INTERVAL_R2 0x1000
#define BT_BR_PAGE_SCAN_SLOW_WINDOW_R2   0x0011


enum bt_br_scan_type {
        BT_BR_SCAN_TYPE_STANDARD = 0,

        BT_BR_SCAN_TYPE_INTERLACED = 1,
};

struct bt_br_page_scan_param {
        uint16_t interval;

        uint16_t window;

        enum bt_br_scan_type type;
};

 
#define BT_BR_SCAN_INIT(_interval, _window, _type) \
{ \
        .interval = (_interval), \
        .window = (_window), \
        .type = (_type) \
}

 
#define BT_BR_PAGE_SCAN_PARAM(_interval, _window, _type) \
        ((const struct bt_br_page_scan_param[]) { \
                BT_BR_SCAN_INIT(_interval, _window, _type) \
        })

#define BT_BR_PAGE_SCAN_PARAM_R0 BT_BR_PAGE_SCAN_PARAM(BT_BR_PAGE_SCAN_INTERVAL_R0, \
                                                       BT_BR_PAGE_SCAN_WINDOW_R0, \
                                                       BT_BR_SCAN_TYPE_STANDARD)

#define BT_BR_PAGE_SCAN_PARAM_FAST_R1 \
        BT_BR_PAGE_SCAN_PARAM(BT_BR_PAGE_SCAN_FAST_INTERVAL_R1, \
        BT_BR_PAGE_SCAN_FAST_WINDOW_R1, \
        BT_BR_SCAN_TYPE_INTERLACED)

#define BT_BR_PAGE_SCAN_PARAM_MEDIUM_R1 \
        BT_BR_PAGE_SCAN_PARAM( \
        BT_BR_PAGE_SCAN_MEDIUM_INTERVAL_R1, \
        BT_BR_PAGE_SCAN_MEDIUM_WINDOW_R1, \
        BT_BR_SCAN_TYPE_INTERLACED)

#define BT_BR_PAGE_SCAN_PARAM_SLOW_R1 \
        BT_BR_PAGE_SCAN_PARAM( \
        BT_BR_PAGE_SCAN_SLOW_INTERVAL_R1, \
        BT_BR_PAGE_SCAN_SLOW_WINDOW_R1, \
        BT_BR_SCAN_TYPE_STANDARD)

#define BT_BR_PAGE_SCAN_PARAM_FAST_R2 \
        BT_BR_PAGE_SCAN_PARAM( \
        BT_BR_PAGE_SCAN_FAST_INTERVAL_R2, \
        BT_BR_PAGE_SCAN_FAST_WINDOW_R2, \
        BT_BR_SCAN_TYPE_INTERLACED)

#define BT_BR_PAGE_SCAN_PARAM_SLOW_R2 \
        BT_BR_PAGE_SCAN_PARAM( \
        BT_BR_PAGE_SCAN_SLOW_INTERVAL_R2, \
        BT_BR_PAGE_SCAN_SLOW_WINDOW_R2, \
        BT_BR_SCAN_TYPE_STANDARD)

int bt_br_page_scan_update_param(const struct bt_br_page_scan_param *param);

struct bt_br_inquiry_scan_param {
        uint16_t interval;

        uint16_t window;

        enum bt_br_scan_type type;
};


#define BT_BR_INQUIRY_SCAN_INTERVAL_DEFAULT 0x1000
#define BT_BR_INQUIRY_SCAN_WINDOW_DEFAULT   0x0012


#define BT_BR_INQUIRY_SCAN_PARAM(_interval, _window, _type)                                        \
        ((const struct bt_br_inquiry_scan_param[]){BT_BR_SCAN_INIT(_interval, _window, _type)})

#define BT_BR_INQUIRY_SCAN_PARAM_DEFAULT                                                           \
        BT_BR_INQUIRY_SCAN_PARAM(BT_BR_INQUIRY_SCAN_INTERVAL_DEFAULT,                              \
                                 BT_BR_INQUIRY_SCAN_WINDOW_DEFAULT, BT_BR_SCAN_TYPE_STANDARD)

int bt_br_inquiry_scan_update_param(const struct bt_br_inquiry_scan_param *param);

int bt_br_set_class_of_device(uint32_t cod);

int bt_br_get_class_of_device(uint32_t *cod);

bool bt_br_bond_exists(const bt_addr_t *addr);

int bt_br_unpair(const bt_addr_t *addr);

struct bt_br_bond_info {
        bt_addr_t addr;
};

void bt_br_foreach_bond(void (*func)(const struct bt_br_bond_info *info, void *user_data),
                        void *user_data);

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_H_ */