csip.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2021-2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_SUBSYS_BLUETOOTH_AUDIO_CSIP_H_
#define ZEPHYR_SUBSYS_BLUETOOTH_AUDIO_CSIP_H_

 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/assigned_numbers.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/data.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define BT_CSIP_SET_COORDINATOR_DISCOVER_TIMER_VALUE        K_SECONDS(10)

#if defined(CONFIG_BT_CSIP_SET_COORDINATOR)
#define BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES CONFIG_BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES
#else
#define BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES 0
#endif /* CONFIG_BT_CSIP_SET_COORDINATOR */

#define BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT        0x00
#define BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT_ENC    0x01
#define BT_CSIP_READ_SIRK_REQ_RSP_REJECT        0x02
#define BT_CSIP_READ_SIRK_REQ_RSP_OOB_ONLY      0x03

#define BT_CSIP_SIRK_SIZE 16

#define BT_CSIP_RSI_SIZE                        6
 
/* Coordinate Set Identification Service Error codes */
#define BT_CSIP_ERROR_LOCK_DENIED               0x80
#define BT_CSIP_ERROR_LOCK_RELEASE_DENIED       0x81
#define BT_CSIP_ERROR_LOCK_INVAL_VALUE          0x82
#define BT_CSIP_ERROR_SIRK_OOB_ONLY             0x83
#define BT_CSIP_ERROR_LOCK_ALREADY_GRANTED      0x84

#define BT_CSIP_DATA_RSI(_rsi) BT_DATA(BT_DATA_CSIS_RSI, _rsi, BT_CSIP_RSI_SIZE)

struct bt_csip_set_member_svc_inst;

struct bt_csip_set_member_cb {
        void (*lock_changed)(struct bt_conn *conn,
                             struct bt_csip_set_member_svc_inst *svc_inst,
                             bool locked);

        uint8_t (*sirk_read_req)(struct bt_conn *conn,
                                 struct bt_csip_set_member_svc_inst *svc_inst);
};

struct bt_csip_set_member_register_param {
        uint8_t set_size;

        uint8_t sirk[BT_CSIP_SIRK_SIZE];

        bool lockable;

        uint8_t rank;

        struct bt_csip_set_member_cb *cb;
 
#if CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 || defined(__DOXYGEN__)
        const struct bt_gatt_service *parent;
#endif /* CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 */
};

void *bt_csip_set_member_svc_decl_get(const struct bt_csip_set_member_svc_inst *svc_inst);

int bt_csip_set_member_register(const struct bt_csip_set_member_register_param *param,
                                struct bt_csip_set_member_svc_inst **svc_inst);

int bt_csip_set_member_unregister(struct bt_csip_set_member_svc_inst *svc_inst);

int bt_csip_set_member_sirk(struct bt_csip_set_member_svc_inst *svc_inst,
                            const uint8_t sirk[BT_CSIP_SIRK_SIZE]);

int bt_csip_set_member_set_size_and_rank(struct bt_csip_set_member_svc_inst *svc_inst, uint8_t size,
                                         uint8_t rank);

struct bt_csip_set_member_set_info {
        uint8_t sirk[BT_CSIP_SIRK_SIZE];

        uint8_t set_size;

        uint8_t rank;

        bool lockable: 1;

        bool locked: 1;

        bt_addr_le_t lock_client_addr;
};

int bt_csip_set_member_get_info(const struct bt_csip_set_member_svc_inst *svc_inst,
                                struct bt_csip_set_member_set_info *info);

int bt_csip_set_member_generate_rsi(const struct bt_csip_set_member_svc_inst *svc_inst,
                                    uint8_t rsi[BT_CSIP_RSI_SIZE]);

int bt_csip_set_member_lock(struct bt_csip_set_member_svc_inst *svc_inst,
                            bool lock, bool force);

struct bt_csip_set_coordinator_set_info {
        uint8_t sirk[BT_CSIP_SIRK_SIZE];

        uint8_t set_size;

        uint8_t rank;

        bool lockable;
};

struct bt_csip_set_coordinator_csis_inst {
        struct bt_csip_set_coordinator_set_info info;

        void *svc_inst;
};

struct bt_csip_set_coordinator_set_member {
        struct bt_csip_set_coordinator_csis_inst insts[BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES];
};

typedef void (*bt_csip_set_coordinator_discover_cb)(
        struct bt_conn *conn,
        const struct bt_csip_set_coordinator_set_member *member,
        int err, size_t set_count);

int bt_csip_set_coordinator_discover(struct bt_conn *conn);

struct bt_csip_set_coordinator_set_member *
bt_csip_set_coordinator_set_member_by_conn(const struct bt_conn *conn);

typedef void (*bt_csip_set_coordinator_lock_set_cb)(int err);

typedef void (*bt_csip_set_coordinator_lock_changed_cb)(
        struct bt_csip_set_coordinator_csis_inst *inst, bool locked);

typedef void (*bt_csip_set_coordinator_sirk_changed_cb)(
        struct bt_csip_set_coordinator_csis_inst *inst);

typedef void (*bt_csip_set_coordinator_size_changed_cb)(
        struct bt_conn *conn, const struct bt_csip_set_coordinator_csis_inst *inst);

typedef void (*bt_csip_set_coordinator_ordered_access_cb_t)(
        const struct bt_csip_set_coordinator_set_info *set_info,
        int err, bool locked,
        struct bt_csip_set_coordinator_set_member *member);

struct bt_csip_set_coordinator_cb {
        bt_csip_set_coordinator_discover_cb discover;
        bt_csip_set_coordinator_lock_set_cb lock_set;
        bt_csip_set_coordinator_lock_set_cb release_set;
        bt_csip_set_coordinator_lock_changed_cb lock_changed;
        bt_csip_set_coordinator_sirk_changed_cb sirk_changed;
        bt_csip_set_coordinator_size_changed_cb size_changed;
        bt_csip_set_coordinator_ordered_access_cb_t ordered_access;

        sys_snode_t _node;
};

bool bt_csip_set_coordinator_is_set_member(const uint8_t sirk[BT_CSIP_SIRK_SIZE],
                                           struct bt_data *data);

int bt_csip_set_coordinator_register_cb(struct bt_csip_set_coordinator_cb *cb);

typedef bool (*bt_csip_set_coordinator_ordered_access_t)(
        const struct bt_csip_set_coordinator_set_info *set_info,
        struct bt_csip_set_coordinator_set_member *members[],
        size_t count);

int bt_csip_set_coordinator_ordered_access(
        const struct bt_csip_set_coordinator_set_member *members[],
        uint8_t count,
        const struct bt_csip_set_coordinator_set_info *set_info,
        bt_csip_set_coordinator_ordered_access_t cb);

int bt_csip_set_coordinator_lock(const struct bt_csip_set_coordinator_set_member **members,
                                 uint8_t count,
                                 const struct bt_csip_set_coordinator_set_info *set_info);

int bt_csip_set_coordinator_release(const struct bt_csip_set_coordinator_set_member **members,
                                    uint8_t count,
                                    const struct bt_csip_set_coordinator_set_info *set_info);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_SUBSYS_BLUETOOTH_AUDIO_CSIP_H_ */