bap.h

Go to the documentation of this file.

 
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_
#define ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_
 
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/audio/audio.h>
 
#if defined(CONFIG_BT_BAP_SCAN_DELEGATOR)
#define BT_BAP_SCAN_DELEGATOR_MAX_METADATA_LEN CONFIG_BT_BAP_SCAN_DELEGATOR_MAX_METADATA_LEN
#define BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS    CONFIG_BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS
#else
#define BT_BAP_SCAN_DELEGATOR_MAX_METADATA_LEN 0
#define BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS    0
#endif
 
#define BT_BAP_BASE_MIN_SIZE 16
 
#define BT_BAP_BASE_BIS_DATA_MIN_SIZE 2 /* index and length */
 
enum bt_bap_pa_state {
        BT_BAP_PA_STATE_NOT_SYNCED = 0x00,
 
        BT_BAP_PA_STATE_INFO_REQ = 0x01,
 
        BT_BAP_PA_STATE_SYNCED = 0x02,
 
        BT_BAP_PA_STATE_FAILED = 0x03,
 
        BT_BAP_PA_STATE_NO_PAST = 0x04,
};
 
enum bt_bap_big_enc_state {
        BT_BAP_BIG_ENC_STATE_NO_ENC = 0x00,
 
        BT_BAP_BIG_ENC_STATE_BCODE_REQ = 0x01,
 
        BT_BAP_BIG_ENC_STATE_DEC = 0x02,
 
        BT_BAP_BIG_ENC_STATE_BAD_CODE = 0x03,
};
 
enum bt_bap_bass_att_err {
        BT_BAP_BASS_ERR_OPCODE_NOT_SUPPORTED = 0x80,
 
        BT_BAP_BASS_ERR_INVALID_SRC_ID = 0x81,
};
 
#define BT_BAP_PA_INTERVAL_UNKNOWN             0xFFFF
 
#define BT_BAP_BIS_SYNC_NO_PREF                0xFFFFFFFF
 
#if defined(CONFIG_BT_BAP_BROADCAST_SINK)
/* TODO: Since these are also used for the broadcast assistant,
 * they should not be tied to the broadcast sink
 */
#define BROADCAST_SNK_STREAM_CNT   CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT
#define BROADCAST_SNK_SUBGROUP_CNT CONFIG_BT_BAP_BROADCAST_SNK_SUBGROUP_COUNT
#else /* !CONFIG_BT_BAP_BROADCAST_SINK */
#define BROADCAST_SNK_STREAM_CNT   0
#define BROADCAST_SNK_SUBGROUP_CNT 0
#endif /* CONFIG_BT_BAP_BROADCAST_SINK*/
 
enum bt_bap_ep_state {
        BT_BAP_EP_STATE_IDLE = 0x00,
 
        BT_BAP_EP_STATE_CODEC_CONFIGURED = 0x01,
 
        BT_BAP_EP_STATE_QOS_CONFIGURED = 0x02,
 
        BT_BAP_EP_STATE_ENABLING = 0x03,
 
        BT_BAP_EP_STATE_STREAMING = 0x04,
 
        BT_BAP_EP_STATE_DISABLING = 0x05,
 
        BT_BAP_EP_STATE_RELEASING = 0x06,
};
 
enum bt_bap_ascs_rsp_code {
        BT_BAP_ASCS_RSP_CODE_SUCCESS = 0x00,
        BT_BAP_ASCS_RSP_CODE_NOT_SUPPORTED = 0x01,
        BT_BAP_ASCS_RSP_CODE_INVALID_LENGTH = 0x02,
        BT_BAP_ASCS_RSP_CODE_INVALID_ASE = 0x03,
        BT_BAP_ASCS_RSP_CODE_INVALID_ASE_STATE = 0x04,
        BT_BAP_ASCS_RSP_CODE_INVALID_DIR = 0x05,
        BT_BAP_ASCS_RSP_CODE_CAP_UNSUPPORTED = 0x06,
        BT_BAP_ASCS_RSP_CODE_CONF_UNSUPPORTED = 0x07,
        BT_BAP_ASCS_RSP_CODE_CONF_REJECTED = 0x08,
        BT_BAP_ASCS_RSP_CODE_CONF_INVALID = 0x09,
        BT_BAP_ASCS_RSP_CODE_METADATA_UNSUPPORTED = 0x0a,
        BT_BAP_ASCS_RSP_CODE_METADATA_REJECTED = 0x0b,
        BT_BAP_ASCS_RSP_CODE_METADATA_INVALID = 0x0c,
        BT_BAP_ASCS_RSP_CODE_NO_MEM = 0x0d,
        BT_BAP_ASCS_RSP_CODE_UNSPECIFIED = 0x0e,
};
 
enum bt_bap_ascs_reason {
        BT_BAP_ASCS_REASON_NONE = 0x00,
        BT_BAP_ASCS_REASON_CODEC = 0x01,
        BT_BAP_ASCS_REASON_CODEC_DATA = 0x02,
        BT_BAP_ASCS_REASON_INTERVAL = 0x03,
        BT_BAP_ASCS_REASON_FRAMING = 0x04,
        BT_BAP_ASCS_REASON_PHY = 0x05,
        BT_BAP_ASCS_REASON_SDU = 0x06,
        BT_BAP_ASCS_REASON_RTN = 0x07,
        BT_BAP_ASCS_REASON_LATENCY = 0x08,
        BT_BAP_ASCS_REASON_PD = 0x09,
        BT_BAP_ASCS_REASON_CIS = 0x0a,
};
 
struct bt_bap_ascs_rsp {
        enum bt_bap_ascs_rsp_code code;
 
        union {
                enum bt_bap_ascs_reason reason;
 
                enum bt_audio_metadata_type metadata_type;
        };
};
 
#define BT_BAP_ASCS_RSP(c, r) (struct bt_bap_ascs_rsp) { .code = c, .reason = r }
 
struct bt_bap_broadcast_source;
 
struct bt_bap_broadcast_sink;
 
struct bt_bap_unicast_group;
 
struct bt_bap_ep;
 
/* TODO: Replace with struct bt_bap_base_subgroup */
struct bt_bap_scan_delegator_subgroup {
        uint32_t bis_sync;
 
        uint8_t metadata_len;
 
        uint8_t metadata[BT_BAP_SCAN_DELEGATOR_MAX_METADATA_LEN];
};
 
struct bt_bap_scan_delegator_recv_state {
        uint8_t src_id;
 
        bt_addr_le_t addr;
 
        uint8_t adv_sid;
 
        enum bt_bap_pa_state pa_sync_state;
 
        enum bt_bap_big_enc_state encrypt_state;
 
        uint32_t broadcast_id;
 
        uint8_t bad_code[BT_AUDIO_BROADCAST_CODE_SIZE];
 
        uint8_t num_subgroups;
 
        struct bt_bap_scan_delegator_subgroup subgroups[BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS];
};
 
struct bt_bap_scan_delegator_cb {
        void (*recv_state_updated)(struct bt_conn *conn,
                                   const struct bt_bap_scan_delegator_recv_state *recv_state);
 
        int (*pa_sync_req)(struct bt_conn *conn,
                           const struct bt_bap_scan_delegator_recv_state *recv_state,
                           bool past_avail, uint16_t pa_interval);
 
        int (*pa_sync_term_req)(struct bt_conn *conn,
                                const struct bt_bap_scan_delegator_recv_state *recv_state);
 
        void (*broadcast_code)(struct bt_conn *conn,
                               const struct bt_bap_scan_delegator_recv_state *recv_state,
                               const uint8_t broadcast_code[BT_AUDIO_BROADCAST_CODE_SIZE]);
 
        int (*bis_sync_req)(struct bt_conn *conn,
                            const struct bt_bap_scan_delegator_recv_state *recv_state,
                            const uint32_t bis_sync_req[BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS]);
};
 
struct bt_bap_ep_info {
        uint8_t id;
 
        enum bt_bap_ep_state state;
 
        enum bt_audio_dir dir;
 
        struct bt_bap_ep *paired_ep;
};
 
int bt_bap_ep_get_info(const struct bt_bap_ep *ep, struct bt_bap_ep_info *info);
 
struct bt_bap_stream {
        enum bt_audio_dir dir;
 
        struct bt_conn *conn;
 
        struct bt_bap_ep *ep;
 
        struct bt_codec *codec;
 
        struct bt_codec_qos *qos;
 
        struct bt_bap_stream_ops *ops;
 
#if defined(CONFIG_BT_BAP_UNICAST_CLIENT)
        struct bt_bap_iso *bap_iso;
#endif /* CONFIG_BT_BAP_UNICAST_CLIENT */
 
        void *group;
 
        void *user_data;
 
        /* Internally used list node */
        sys_snode_t _node;
};
 
struct bt_bap_stream_ops {
#if defined(CONFIG_BT_BAP_UNICAST)
        void (*configured)(struct bt_bap_stream *stream, const struct bt_codec_qos_pref *pref);
 
        void (*qos_set)(struct bt_bap_stream *stream);
 
        void (*enabled)(struct bt_bap_stream *stream);
 
        void (*metadata_updated)(struct bt_bap_stream *stream);
 
        void (*disabled)(struct bt_bap_stream *stream);
 
        void (*released)(struct bt_bap_stream *stream);
#endif /* CONFIG_BT_BAP_UNICAST */
 
        void (*started)(struct bt_bap_stream *stream);
 
        void (*stopped)(struct bt_bap_stream *stream, uint8_t reason);
 
#if defined(CONFIG_BT_AUDIO_RX)
        void (*recv)(struct bt_bap_stream *stream, const struct bt_iso_recv_info *info,
                     struct net_buf *buf);
#endif /* CONFIG_BT_AUDIO_RX */
 
#if defined(CONFIG_BT_AUDIO_TX)
        void (*sent)(struct bt_bap_stream *stream);
#endif /* CONFIG_BT_AUDIO_TX */
};
 
void bt_bap_stream_cb_register(struct bt_bap_stream *stream, struct bt_bap_stream_ops *ops);
 
int bt_bap_stream_config(struct bt_conn *conn, struct bt_bap_stream *stream, struct bt_bap_ep *ep,
                         struct bt_codec *codec);
 
int bt_bap_stream_reconfig(struct bt_bap_stream *stream, struct bt_codec *codec);
 
int bt_bap_stream_qos(struct bt_conn *conn, struct bt_bap_unicast_group *group);
 
int bt_bap_stream_enable(struct bt_bap_stream *stream, struct bt_codec_data *meta,
                         size_t meta_count);
 
int bt_bap_stream_metadata(struct bt_bap_stream *stream, struct bt_codec_data *meta,
                           size_t meta_count);
 
int bt_bap_stream_disable(struct bt_bap_stream *stream);
 
int bt_bap_stream_start(struct bt_bap_stream *stream);
 
int bt_bap_stream_stop(struct bt_bap_stream *stream);
 
int bt_bap_stream_release(struct bt_bap_stream *stream);
 
int bt_bap_stream_send(struct bt_bap_stream *stream, struct net_buf *buf, uint16_t seq_num,
                       uint32_t ts);
 
struct bt_bap_unicast_server_cb {
        int (*config)(struct bt_conn *conn, const struct bt_bap_ep *ep, enum bt_audio_dir dir,
                      const struct bt_codec *codec, struct bt_bap_stream **stream,
                      struct bt_codec_qos_pref *const pref, struct bt_bap_ascs_rsp *rsp);
 
        int (*reconfig)(struct bt_bap_stream *stream, enum bt_audio_dir dir,
                        const struct bt_codec *codec, struct bt_codec_qos_pref *const pref,
                        struct bt_bap_ascs_rsp *rsp);
 
        int (*qos)(struct bt_bap_stream *stream, const struct bt_codec_qos *qos,
                   struct bt_bap_ascs_rsp *rsp);
 
        int (*enable)(struct bt_bap_stream *stream, const struct bt_codec_data *meta,
                      size_t meta_count, struct bt_bap_ascs_rsp *rsp);
 
        int (*start)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);
 
        int (*metadata)(struct bt_bap_stream *stream, const struct bt_codec_data *meta,
                        size_t meta_count, struct bt_bap_ascs_rsp *rsp);
 
        int (*disable)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);
 
        int (*stop)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);
 
        int (*release)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);
};
 
int bt_bap_unicast_server_register_cb(const struct bt_bap_unicast_server_cb *cb);
 
int bt_bap_unicast_server_unregister_cb(const struct bt_bap_unicast_server_cb *cb);
 
typedef void (*bt_bap_ep_func_t)(struct bt_bap_ep *ep, void *user_data);
 
void bt_bap_unicast_server_foreach_ep(struct bt_conn *conn, bt_bap_ep_func_t func, void *user_data);
 
int bt_bap_unicast_server_config_ase(struct bt_conn *conn, struct bt_bap_stream *stream,
                                     struct bt_codec *codec,
                                     const struct bt_codec_qos_pref *qos_pref);
 /* End of group bt_bap_unicast_server */
 
struct bt_bap_unicast_group_stream_param {
        struct bt_bap_stream *stream;
 
        struct bt_codec_qos *qos;
};
 
struct bt_bap_unicast_group_stream_pair_param {
        struct bt_bap_unicast_group_stream_param *rx_param;
 
        struct bt_bap_unicast_group_stream_param *tx_param;
};
 
struct bt_bap_unicast_group_param {
        size_t params_count;
 
        struct bt_bap_unicast_group_stream_pair_param *params;
 
        uint8_t packing;
};
 
int bt_bap_unicast_group_create(struct bt_bap_unicast_group_param *param,
                                struct bt_bap_unicast_group **unicast_group);
 
int bt_bap_unicast_group_add_streams(struct bt_bap_unicast_group *unicast_group,
                                     struct bt_bap_unicast_group_stream_pair_param params[],
                                     size_t num_param);
 
int bt_bap_unicast_group_delete(struct bt_bap_unicast_group *unicast_group);
 
struct bt_bap_unicast_client_cb {
        void (*location)(struct bt_conn *conn, enum bt_audio_dir dir, enum bt_audio_location loc);
 
        void (*available_contexts)(struct bt_conn *conn, enum bt_audio_context snk_ctx,
                                   enum bt_audio_context src_ctx);
 
        void (*config)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                       enum bt_bap_ascs_reason reason);
 
        void (*qos)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                    enum bt_bap_ascs_reason reason);
 
        void (*enable)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                       enum bt_bap_ascs_reason reason);
 
        void (*start)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                      enum bt_bap_ascs_reason reason);
 
        void (*stop)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                     enum bt_bap_ascs_reason reason);
 
        void (*disable)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                        enum bt_bap_ascs_reason reason);
 
        void (*metadata)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                         enum bt_bap_ascs_reason reason);
 
        void (*release)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                        enum bt_bap_ascs_reason reason);
 
        void (*pac_record)(struct bt_conn *conn, enum bt_audio_dir dir,
                           const struct bt_codec *codec);
 
        void (*endpoint)(struct bt_conn *conn, enum bt_audio_dir dir, struct bt_bap_ep *ep);
 
        void (*discover)(struct bt_conn *conn, int err, enum bt_audio_dir dir);
};
 
int bt_bap_unicast_client_register_cb(const struct bt_bap_unicast_client_cb *cb);
 
int bt_bap_unicast_client_discover(struct bt_conn *conn, enum bt_audio_dir dir);
 /* End of group bt_bap_unicast_client */
struct bt_bap_base_bis_data {
        /* Unique index of the BIS */
        uint8_t index;
#if defined(CONFIG_BT_CODEC_MAX_DATA_COUNT)
        size_t data_count;
        struct bt_codec_data data[CONFIG_BT_CODEC_MAX_DATA_COUNT];
#endif /* CONFIG_BT_CODEC_MAX_DATA_COUNT */
};
 
struct bt_bap_base_subgroup {
        /* Number of BIS in the subgroup */
        size_t bis_count;
        struct bt_codec codec;
        /* Array of BIS specific data for each BIS in the subgroup */
        struct bt_bap_base_bis_data bis_data[BROADCAST_SNK_STREAM_CNT];
};
 
struct bt_bap_base {
        uint32_t pd;
 
        /* Number of subgroups in the BASE */
        size_t subgroup_count;
 
        /* Array of subgroups in the BASE */
        struct bt_bap_base_subgroup subgroups[BROADCAST_SNK_SUBGROUP_CNT];
};
 
int bt_bap_decode_base(struct bt_data *data, struct bt_bap_base *base);
 /* End of group bt_bap_broadcast */
 
struct bt_bap_broadcast_source_stream_param {
        struct bt_bap_stream *stream;
 
#if CONFIG_BT_CODEC_MAX_DATA_COUNT > 0
        size_t data_count;
 
        struct bt_codec_data *data;
#endif /* CONFIG_BT_CODEC_MAX_DATA_COUNT > 0 */
};
 
struct bt_bap_broadcast_source_subgroup_param {
        size_t params_count;
 
        struct bt_bap_broadcast_source_stream_param *params;
 
        struct bt_codec *codec;
};
 
struct bt_bap_broadcast_source_create_param {
        size_t params_count;
 
        struct bt_bap_broadcast_source_subgroup_param *params;
 
        struct bt_codec_qos *qos;
 
        uint8_t packing;
 
        bool encryption;
 
        uint8_t broadcast_code[BT_AUDIO_BROADCAST_CODE_SIZE];
};
 
int bt_bap_broadcast_source_create(struct bt_bap_broadcast_source_create_param *param,
                                   struct bt_bap_broadcast_source **source);
 
int bt_bap_broadcast_source_reconfig(struct bt_bap_broadcast_source *source, struct bt_codec *codec,
                                     struct bt_codec_qos *qos);
 
int bt_bap_broadcast_source_update_metadata(struct bt_bap_broadcast_source *source,
                                            const struct bt_codec_data meta[], size_t meta_count);
 
int bt_bap_broadcast_source_start(struct bt_bap_broadcast_source *source,
                                  struct bt_le_ext_adv *adv);
 
int bt_bap_broadcast_source_stop(struct bt_bap_broadcast_source *source);
 
int bt_bap_broadcast_source_delete(struct bt_bap_broadcast_source *source);
 
int bt_bap_broadcast_source_get_id(const struct bt_bap_broadcast_source *source,
                                   uint32_t *const broadcast_id);
 
int bt_bap_broadcast_source_get_base(struct bt_bap_broadcast_source *source,
                                     struct net_buf_simple *base_buf);
 /* End of bt_bap_broadcast_source */
 
struct bt_bap_broadcast_sink_cb {
        bool (*scan_recv)(const struct bt_le_scan_recv_info *info, struct net_buf_simple *ad,
                          uint32_t broadcast_id);
 
        void (*pa_synced)(struct bt_bap_broadcast_sink *sink, struct bt_le_per_adv_sync *sync,
                          uint32_t broadcast_id);
 
        void (*base_recv)(struct bt_bap_broadcast_sink *sink, const struct bt_bap_base *base);
 
        void (*syncable)(struct bt_bap_broadcast_sink *sink, bool encrypted);
 
        void (*scan_term)(int err);
 
        void (*pa_sync_lost)(struct bt_bap_broadcast_sink *sink);
 
        /* Internally used list node */
        sys_snode_t _node;
};
 
int bt_bap_broadcast_sink_register_cb(struct bt_bap_broadcast_sink_cb *cb);
 
int bt_bap_broadcast_sink_scan_start(const struct bt_le_scan_param *param);
 
int bt_bap_broadcast_sink_scan_stop(void);
 
int bt_bap_broadcast_sink_create(struct bt_le_per_adv_sync *pa_sync, uint32_t broadcast_id);
 
int bt_bap_broadcast_sink_sync(struct bt_bap_broadcast_sink *sink, uint32_t indexes_bitfield,
                               struct bt_bap_stream *streams[], const uint8_t broadcast_code[16]);
 
int bt_bap_broadcast_sink_stop(struct bt_bap_broadcast_sink *sink);
 
int bt_bap_broadcast_sink_delete(struct bt_bap_broadcast_sink *sink);
 /* End of group bt_bap_broadcast_sink */
 
void bt_bap_scan_delegator_register_cb(struct bt_bap_scan_delegator_cb *cb);
 
int bt_bap_scan_delegator_set_pa_state(uint8_t src_id,
                                       enum bt_bap_pa_state pa_state);
 
int bt_bap_scan_delegator_set_bis_sync_state(
        uint8_t src_id,
        uint32_t bis_synced[BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS]);
 
struct bt_bap_scan_delegator_add_src_param {
        struct bt_le_per_adv_sync *pa_sync;
 
        enum bt_bap_big_enc_state encrypt_state;
 
        uint32_t broadcast_id;
 
        uint8_t num_subgroups;
 
        struct bt_bap_scan_delegator_subgroup subgroups[BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS];
};
 
int bt_bap_scan_delegator_add_src(const struct bt_bap_scan_delegator_add_src_param *param);
 
struct bt_bap_scan_delegator_mod_src_param {
        uint8_t src_id;
 
        enum bt_bap_big_enc_state encrypt_state;
 
        uint32_t broadcast_id;
 
        uint8_t num_subgroups;
 
        struct bt_bap_scan_delegator_subgroup subgroups[BT_BAP_SCAN_DELEGATOR_MAX_SUBGROUPS];
};
 
int bt_bap_scan_delegator_mod_src(const struct bt_bap_scan_delegator_mod_src_param *param);
 
int bt_bap_scan_delegator_rem_src(uint8_t src_id);
 
enum bt_bap_scan_delegator_iter {
        BT_BAP_SCAN_DELEGATOR_ITER_STOP = 0,
        BT_BAP_SCAN_DELEGATOR_ITER_CONTINUE,
};
 
typedef enum bt_bap_scan_delegator_iter (*bt_bap_scan_delegator_state_func_t)(
        const struct bt_bap_scan_delegator_recv_state *recv_state, void *user_data);
 
void bt_bap_scan_delegator_foreach_state(bt_bap_scan_delegator_state_func_t func,
                                         void *user_data);
 
const struct bt_bap_scan_delegator_recv_state *bt_bap_scan_delegator_find_state(
        bt_bap_scan_delegator_state_func_t func, void *user_data);
 
/******************************** CLIENT API ********************************/
 
typedef void (*bt_bap_broadcast_assistant_write_cb)(struct bt_conn *conn,
                                                    int err);
 
struct bt_bap_broadcast_assistant_cb {
        void (*discover)(struct bt_conn *conn, int err,
                         uint8_t recv_state_count);
 
        void (*scan)(const struct bt_le_scan_recv_info *info,
                     uint32_t broadcast_id);
 
        void (*recv_state)(struct bt_conn *conn, int err,
                           const struct bt_bap_scan_delegator_recv_state *state);
 
        void (*recv_state_removed)(struct bt_conn *conn, int err,
                                   uint8_t src_id);
 
        void (*scan_start)(struct bt_conn *conn, int err);
 
        void (*scan_stop)(struct bt_conn *conn, int err);
 
        void (*add_src)(struct bt_conn *conn, int err);
 
        void (*mod_src)(struct bt_conn *conn, int err);
 
        void (*broadcast_code)(struct bt_conn *conn, int err);
 
        void (*rem_src)(struct bt_conn *conn, int err);
};
 
int bt_bap_broadcast_assistant_discover(struct bt_conn *conn);
 
int bt_bap_broadcast_assistant_scan_start(struct bt_conn *conn,
                                          bool start_scan);
 
int bt_bap_broadcast_assistant_scan_stop(struct bt_conn *conn);
 
void bt_bap_broadcast_assistant_register_cb(struct bt_bap_broadcast_assistant_cb *cb);
 
struct bt_bap_broadcast_assistant_add_src_param {
        bt_addr_le_t addr;
 
        uint8_t adv_sid;
 
        bool pa_sync;
 
        uint32_t broadcast_id;
 
        uint16_t pa_interval;
 
        uint8_t num_subgroups;
 
        struct bt_bap_scan_delegator_subgroup *subgroups;
};
 
int bt_bap_broadcast_assistant_add_src(
        struct bt_conn *conn, const struct bt_bap_broadcast_assistant_add_src_param *param);
 
struct bt_bap_broadcast_assistant_mod_src_param {
        uint8_t src_id;
 
        bool pa_sync;
 
        uint16_t pa_interval;
 
        uint8_t num_subgroups;
 
        struct bt_bap_scan_delegator_subgroup *subgroups;
};
 
int bt_bap_broadcast_assistant_mod_src(
        struct bt_conn *conn, const struct bt_bap_broadcast_assistant_mod_src_param *param);
 
int bt_bap_broadcast_assistant_set_broadcast_code(
        struct bt_conn *conn, uint8_t src_id,
        const uint8_t broadcast_code[BT_AUDIO_BROADCAST_CODE_SIZE]);
 
int bt_bap_broadcast_assistant_rem_src(struct bt_conn *conn, uint8_t src_id);
 
int bt_bap_broadcast_assistant_read_recv_state(struct bt_conn *conn,
                                               uint8_t idx);
 /* end of bt_bap */
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_ */