michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Audio: Rename bt_csip to bt_csip_set_member

Browse source 
Renamed remaining structs and functions that are not
for the set coordinator to use the set member CSIP
role name.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2022-10-11 15:13:09 +02:00 • committed by Carles Cufí
commit 87f86cebe2
26 changed files with 151 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

6
doc/connectivity/bluetooth/api/shell/csip.rst
View file

@ -141,8 +141,8 @@ Using the Set Member
.. code-block:: console
csip --help
csip - Bluetooth CSIP shell commands
csip_set_member --help
csip_set_member - Bluetooth CSIP set member shell commands
Subcommands:
register :Initialize the service and register callbacks [size <int>]
[rank <int>] [not-lockable] [sirk <data>]
@ -162,4 +162,4 @@ Setup
.. code-block:: console
uart:~$ bt init
uart:~$ csip register
uart:~$ csip_set_member register

2
doc/connectivity/bluetooth/bluetooth-audio-arch.rst
View file

@ -132,7 +132,7 @@ Coordinated Sets is implemented by the Coordinated Sets Identification Profile
The CSIP implementation supports the following roles
* Coordinated Set Identification Service (CSIP) Server
* Coordinated Set Identification Service (CSIP) Set Member
* Coordinated Set Identification Service (CSIP) Set Coordinator
The API reference for media control can be found in

2
include/zephyr/bluetooth/audio/cap.h
View file

@ -45,7 +45,7 @@ extern "C" {
*
* @return 0 if success, errno on failure.
*/
int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
int bt_cap_acceptor_register(const struct bt_csip_set_member_register_param *param,
struct bt_csip **csip);
/** Callback structure for CAP procedures */

29
include/zephyr/bluetooth/audio/csip.h
View file

@ -76,13 +76,13 @@ extern "C" {
struct bt_csip;
/** Callback structure for the Coordinated Set Identification Service */
struct bt_csip_cb {
struct bt_csip_set_member_cb {
/**
* @brief Callback whenever the lock changes on the server.
*
* @param conn The connection to the client that changed the lock.
* NULL if server changed it, either by calling
* bt_csip_lock() or by timeout.
* bt_csip_set_member_lock() or by timeout.
* @param csip Pointer to the Coordinated Set Identification Service.
* @param locked Whether the lock was locked or released.
*
@ -106,7 +106,7 @@ struct bt_csip_cb {
};
/** Register structure for Coordinated Set Identification Service */
struct bt_csip_register_param {
struct bt_csip_set_member_register_param {
/**
* @brief Size of the set.
*
@ -139,20 +139,20 @@ struct bt_csip_register_param {
uint8_t rank;
/** Pointer to the callback structure. */
struct bt_csip_cb *cb;
struct bt_csip_set_member_cb *cb;
#if CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1
#if CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1
/**
* @brief Parent service pointer
*
* Mandatory parent service pointer if this CSIS instance is included
* by another service. All CSIS instances when
* @kconfig{CONFIG_BT_CSIP_MAX_INSTANCE_COUNT} is above 1 shall
* be included by another service, as per the
* @kconfig{CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT} is above 1
* shall be included by another service, as per the
* Coordinated Set Identification Profile (CSIP).
*/
const struct bt_gatt_service *parent;
#endif /* CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1 */
#endif /* CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 */
};
/**
@ -164,7 +164,7 @@ struct bt_csip_register_param {
*
* @return The first CSIS attribute instance.
*/
void *bt_csip_svc_decl_get(const struct bt_csip *csip);
void *bt_csip_set_member_svc_decl_get(const struct bt_csip *csip);
/**
* @brief Register a Coordinated Set Identification Service instance.
@ -180,15 +180,15 @@ void *bt_csip_svc_decl_get(const struct bt_csip *csip);
*
* @return 0 if success, errno on failure.
*/
int bt_csip_register(const struct bt_csip_register_param *param,
struct bt_csip **csip);
int bt_csip_set_member_register(const struct bt_csip_set_member_register_param *param,
struct bt_csip **csip);
/**
* @brief Print the SIRK to the debug output
*
* @param csip Pointer to the Coordinated Set Identification Service.
*/
void bt_csip_print_sirk(const struct bt_csip *csip);
void bt_csip_set_member_print_sirk(const struct bt_csip *csip);
/**
* @brief Generate the Resolvable Set Identifier (RSI) value.
@ -200,7 +200,8 @@ void bt_csip_print_sirk(const struct bt_csip *csip);
*
* @return int 0 if on success, errno on error.
*/
int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZE]);
int bt_csip_set_member_generate_rsi(const struct bt_csip *csip,
uint8_t rsi[BT_CSIP_RSI_SIZE]);
/**
* @brief Locks a specific Coordinated Set Identification Service instance on the server.
@ -213,7 +214,7 @@ int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZ
*
* @return 0 on success, GATT error on error.
*/
int bt_csip_lock(struct bt_csip *csip, bool lock, bool force);
int bt_csip_set_member_lock(struct bt_csip *csip, bool lock, bool force);
/** Information about a specific set */
struct bt_csip_set_coordinator_set_info {

2
samples/bluetooth/hap_ha/Kconfig
View file

@ -14,7 +14,7 @@ menu "Hearing Aid"
config HAP_HA_SET_RANK
int "Device rank in set"
depends on BT_CSIP
depends on BT_CSIP_SET_MEMBER
range 1 2
help
Rank of this device in set.

2
samples/bluetooth/hap_ha/binaural.conf
View file

@ -1,3 +1,3 @@
CONFIG_BT_CSIP=y
CONFIG_BT_CSIP_SET_MEMBER=y
CONFIG_BT_HAS_HEARING_AID_BINAURAL=y
CONFIG_BT_CAP_ACCEPTOR_SET_MEMBER=y

6
samples/bluetooth/hap_ha/src/csip_set_member.c
View file

@ -27,14 +27,14 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
return BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
}
static struct bt_csip_cb csip_cb = {
static struct bt_csip_set_member_cb csip_cb = {
.lock_changed = csip_lock_changed_cb,
.sirk_read_req = sirk_read_req_cb,
};
int csip_set_member_init(void)
{
struct bt_csip_register_param param = {
struct bt_csip_set_member_register_param param = {
.set_size = 2,
.rank = CONFIG_HAP_HA_SET_RANK,
.lockable = false,
@ -53,7 +53,7 @@ int csip_generate_rsi(uint8_t *rsi)
return -ENODEV;
}
err = bt_csip_generate_rsi(csip, rsi);
err = bt_csip_set_member_generate_rsi(csip, rsi);
if (err) {
printk("Failed to generate RSI (err %d)\n", err);
return err;

12
samples/bluetooth/hap_ha/src/main.c
View file

@ -44,9 +44,9 @@ static uint8_t csis_rsi_addata[BT_CSIP_RSI_SIZE];
static const struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL)),
#if defined(CONFIG_BT_CSIP)
#if defined(CONFIG_BT_CSIP_SET_MEMBER)
BT_DATA(BT_DATA_CSIS_RSI, csis_rsi_addata, ARRAY_SIZE(csis_rsi_addata)),
#endif /* CONFIG_BT_CSIP */
#endif /* CONFIG_BT_CSIP_SET_MEMBER */
BT_DATA(BT_DATA_SVC_DATA16, unicast_server_addata, ARRAY_SIZE(unicast_server_addata)),
};
@ -63,7 +63,7 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.disconnected = disconnected,
};
#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP)
#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP_SET_MEMBER)
static bool adv_rpa_expired_cb(struct bt_le_ext_adv *adv)
{
char rsi_str[13];
@ -89,12 +89,12 @@ static bool adv_rpa_expired_cb(struct bt_le_ext_adv *adv)
return true;
}
#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP */
#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP_SET_MEMBER */
static const struct bt_le_ext_adv_cb adv_cb = {
#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP)
#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP_SET_MEMBER)
.rpa_expired = adv_rpa_expired_cb,
#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP */
#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP_SET_MEMBER */
};
static void adv_work_handler(struct k_work *work)

4
subsys/bluetooth/audio/CMakeLists.txt
View file

@ -30,9 +30,9 @@ zephyr_library_sources_ifdef(CONFIG_BT_CCID ccid.c)
zephyr_library_link_libraries(subsys__bluetooth)
zephyr_library_sources_ifdef(CONFIG_BT_CSIP csip.c)
zephyr_library_sources_ifdef(CONFIG_BT_CSIP_SET_MEMBER csip_set_member.c)
zephyr_library_sources_ifdef(CONFIG_BT_CSIP_SET_COORDINATOR csip_set_coordinator.c)
if (CONFIG_BT_CSIP OR CONFIG_BT_CSIP_SET_COORDINATOR)
if (CONFIG_BT_CSIP_SET_MEMBER OR CONFIG_BT_CSIP_SET_COORDINATOR)
zephyr_library_sources(csip_crypto.c)
endif()

4
subsys/bluetooth/audio/Kconfig.cap
View file

@ -19,12 +19,12 @@ config BT_CAP_ACCEPTOR
config BT_CAP_ACCEPTOR_SET_MEMBER
bool "Common Audio Profile Acceptor Role Set Member support"
depends on BT_CAP_ACCEPTOR
depends on BT_CSIP
depends on BT_CSIP_SET_MEMBER
help
Enabling this will allow a CAP acceptor to be a set member.
Enabling this will require a manual register of the CAS service.
Enabling will take one of the allocated CSIS instances
(BT_CSIP_MAX_INSTANCE_COUNT).
(BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT).
config BT_DEBUG_CAP_ACCEPTOR
bool "Common Audio Profile debug"

29
subsys/bluetooth/audio/Kconfig.csip
View file

@ -8,17 +8,18 @@
#################### Coordinated Set Identification Service ####################
config BT_CSIP
bool "Coordinated Set Identification Service Support [EXPERIMENTAL]"
config BT_CSIP_SET_MEMBER
bool "Coordinated Set Identification Profile Set Member support [EXPERIMENTAL]"
imply BT_EXT_ADV if BT_PRIVACY
select EXPERIMENTAL
help
This option enables support for Coordinated Set Identification
Profile Set Member role and the Coordinated Set Identification
Service.
if BT_CSIP
if BT_CSIP_SET_MEMBER
config BT_CSIP_TEST_SAMPLE_DATA
config BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA
bool "Coordinated Set Identification Service Test Sample Data"
help
Enable the use of the sample data defined by the CSIS spec SIRK.
@ -28,14 +29,14 @@ config BT_CSIP_TEST_SAMPLE_DATA
(if encrypted) using public sample data.
Should not be used for production builds.
config BT_CSIP_ENC_SIRK_SUPPORT
config BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT
bool "Support for encrypted SIRK"
default y
help
Enables support encrypting the SIRK.
config BT_CSIP_MAX_INSTANCE_COUNT
int "Coordinated Set Identification Service max instance count"
config BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT
int "Coordinated Set Identification Profle max service instance count"
default 1
range 1 255
help
@ -48,13 +49,13 @@ config BT_CSIP_MAX_INSTANCE_COUNT
############### DEBUG ###############
config BT_DEBUG_CSIP
config BT_DEBUG_CSIP_SET_MEMBER
bool "Coordinated Set Identification Service debug"
help
Use this option to enable Coordinated Set Identification Service debug
logs for the Bluetooth Audio functionality.
endif # BT_CSIP
endif # BT_CSIP_SET_MEMBER
#################### Coordinated Set Identification Client ####################
@ -97,16 +98,16 @@ config BT_CSIP_SET_COORDINATOR_ENC_SIRK_SUPPORT
############### DEBUG ###############
config BT_DEBUG_CSIP_SET_COORDINATOR
bool "Coordinated Set Identification Profile debug"
bool "Coordinated Set Identification Profile Set Coordinator debug"
help
Use this option to enable Coordinated Set Identification Profile debug
logs for the Bluetooth Audio functionality.
Use this option to enable Coordinated Set Identification Profile
Set Coordinator debug logs for the Bluetooth Audio functionality.
endif # BT_CSIP_SET_COORDINATOR
config BT_DEBUG_CSIP_CRYPTO
config BT_DEBUG_CSIP_SET_MEMBER_CRYPTO
bool "Coordinated Set Identification Profile crypto functions debug"
depends on BT_CSIP_SET_COORDINATOR || BT_CSIP
depends on BT_CSIP_SET_COORDINATOR || BT_CSIP_SET_MEMBER
help
Use this option to enable Coordinated Set Identification Profile
crypto functions debug logs for the Bluetooth Audio functionality.

2
subsys/bluetooth/audio/Kconfig.has
View file

@ -23,7 +23,7 @@ config BT_HAS_HEARING_AID_MONAURAL
bool "Monaural Hearing Aid"
config BT_HAS_HEARING_AID_BINAURAL
depends on BT_CSIP
depends on BT_CSIP_SET_MEMBER
bool "Binaural Hearing Aid"
config BT_HAS_HEARING_AID_BANDED

6
subsys/bluetooth/audio/cap_acceptor.c
View file

@ -21,13 +21,13 @@ static struct bt_gatt_attr svc_attrs[] = {
BT_GATT_INCLUDE_SERVICE(NULL) /* To be overwritten */
};
int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
int bt_cap_acceptor_register(const struct bt_csip_set_member_register_param *param,
struct bt_csip **csip)
{
static struct bt_gatt_service cas;
int err;
err = bt_csip_register(param, csip);
err = bt_csip_set_member_register(param, csip);
if (err != 0) {
BT_DBG("Failed to register CSIP");
return err;
@ -36,7 +36,7 @@ int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
cas = (struct bt_gatt_service)BT_GATT_SERVICE(svc_attrs);
/* Overwrite the include definition with the CSIP */
cas.attrs[1].user_data = bt_csip_svc_decl_get(*csip);
cas.attrs[1].user_data = bt_csip_set_member_svc_decl_get(*csip);
err = bt_gatt_service_register(&cas);
if (err) {

2
subsys/bluetooth/audio/csip_crypto.c
View file

@ -18,7 +18,7 @@
#include <tinycrypt/ccm_mode.h>
#include <zephyr/sys/byteorder.h>
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_CSIP_CRYPTO)
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_CSIP_SET_MEMBER_CRYPTO)
#define LOG_MODULE_NAME bt_csip_crypto
#include "common/log.h"
#include "common/bt_str.h"

10
subsys/bluetooth/audio/csip_internal.h
View file

@ -59,12 +59,12 @@ struct bt_csip_set_coordinator_svc_inst {
};
/* TODO: Rename to bt_csip_svc_inst */
struct bt_csip_server {
struct bt_csip_set_member_server {
struct bt_csip_set_sirk set_sirk;
uint8_t set_size;
uint8_t set_lock;
uint8_t rank;
struct bt_csip_cb *cb;
struct bt_csip_set_member_cb *cb;
struct k_work_delayable set_lock_timer;
bt_addr_le_t lock_client_addr;
struct bt_gatt_service *service_p;
@ -77,9 +77,9 @@ struct bt_csip_server {
struct bt_csip {
bool client_instance;
union {
#if defined(CONFIG_BT_CSIP)
struct bt_csip_server srv;
#endif /* CONFIG_BT_CSIP */
#if defined(CONFIG_BT_CSIP_SET_MEMBER)
struct bt_csip_set_member_server srv;
#endif /* CONFIG_BT_CSIP_SET_MEMBER */
#if defined(CONFIG_BT_CSIP_SET_COORDINATOR)
struct bt_csip_set_coordinator_svc_inst cli;
#endif /* CONFIG_BT_CSIP_SET_COORDINATOR */

36
subsys/bluetooth/audio/csip.c → subsys/bluetooth/audio/csip_set_member.c
View file

@ -37,7 +37,7 @@
#include "common/log.h"
#include "common/bt_str.h"
static struct bt_csip csip_insts[CONFIG_BT_CSIP_MAX_INSTANCE_COUNT];
static struct bt_csip csip_insts[CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT];
static bt_addr_le_t server_dummy_addr; /* 0'ed address */
struct csip_notify_foreach {
@ -126,7 +126,7 @@ static int sirk_encrypt(struct bt_conn *conn,
int err;
uint8_t *k;
if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
/* test_k is from the sample data from A.2 in the CSIS spec */
static uint8_t test_k[] = {0x67, 0x6e, 0x1b, 0x9b,
0xd4, 0x48, 0x69, 0x6f,
@ -181,13 +181,14 @@ static int generate_prand(uint32_t *dest)
return 0;
}
int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZE])
int bt_csip_set_member_generate_rsi(const struct bt_csip *csip,
uint8_t rsi[BT_CSIP_RSI_SIZE])
{
int res = 0;
uint32_t prand;
uint32_t hash;
if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
/* prand is from the sample data from A.2 in the CSIS spec */
prand = 0x69f563;
} else {
@ -227,7 +228,7 @@ static ssize_t read_set_sirk(struct bt_conn *conn,
if (cb_rsp == BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT) {
sirk = &csip->srv.set_sirk;
} else if (IS_ENABLED(CONFIG_BT_CSIP_ENC_SIRK_SUPPORT) &&
} else if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT) &&
cb_rsp == BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT_ENC) {
int err;
@ -414,11 +415,12 @@ static ssize_t read_rank(struct bt_conn *conn, const struct bt_gatt_attr *attr,
static void set_lock_timer_handler(struct k_work *work)
{
struct k_work_delayable *delayable;
struct bt_csip_server *server;
struct bt_csip_set_member_server *server;
struct bt_csip *csip;
delayable = CONTAINER_OF(work, struct k_work_delayable, work);
server = CONTAINER_OF(delayable, struct bt_csip_server, set_lock_timer);
server = CONTAINER_OF(delayable, struct bt_csip_set_member_server,
set_lock_timer);
csip = CONTAINER_OF(server, struct bt_csip, srv);
BT_DBG("Lock timeout, releasing");
@ -640,16 +642,16 @@ static struct bt_conn_auth_info_cb auth_callbacks = {
}
BT_GATT_SERVICE_INSTANCE_DEFINE(csip_service_list, csip_insts,
CONFIG_BT_CSIP_MAX_INSTANCE_COUNT,
CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT,
BT_CSIP_SERVICE_DEFINITION);
/****************************** Public API ******************************/
void *bt_csip_svc_decl_get(const struct bt_csip *csip)
void *bt_csip_set_member_svc_decl_get(const struct bt_csip *csip)
{
return csip->srv.service_p->attrs;
}
static bool valid_register_param(const struct bt_csip_register_param *param)
static bool valid_register_param(const struct bt_csip_set_member_register_param *param)
{
if (param->lockable && param->rank == 0) {
BT_DBG("Rank cannot be 0 if service is lockable");
@ -662,18 +664,18 @@ static bool valid_register_param(const struct bt_csip_register_param *param)
return false;
}
#if CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1
#if CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1
if (param->parent == NULL) {
BT_DBG("Parent service not provided");
return false;
}
#endif /* CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1 */
#endif /* CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 */
return true;
}
int bt_csip_register(const struct bt_csip_register_param *param,
struct bt_csip **csip)
int bt_csip_set_member_register(const struct bt_csip_set_member_register_param *param,
struct bt_csip **csip)
{
static uint8_t instance_cnt;
struct bt_csip *inst;
@ -714,7 +716,7 @@ int bt_csip_register(const struct bt_csip_register_param *param,
inst->srv.set_sirk.type = BT_CSIP_SIRK_TYPE_PLAIN;
inst->srv.cb = param->cb;
if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
uint8_t test_sirk[] = {
0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45,
@ -732,7 +734,7 @@ int bt_csip_register(const struct bt_csip_register_param *param,
return 0;
}
int bt_csip_lock(struct bt_csip *csip, bool lock, bool force)
int bt_csip_set_member_lock(struct bt_csip *csip, bool lock, bool force)
{
uint8_t lock_val;
int err = 0;
@ -761,7 +763,7 @@ int bt_csip_lock(struct bt_csip *csip, bool lock, bool force)
}
}
void bt_csip_print_sirk(const struct bt_csip *csip)
void bt_csip_set_member_print_sirk(const struct bt_csip *csip)
{
LOG_HEXDUMP_DBG(&csip->srv.set_sirk, sizeof(csip->srv.set_sirk),
"Set SIRK");

4
subsys/bluetooth/shell/CMakeLists.txt
View file

@ -42,8 +42,8 @@ zephyr_library_sources_ifdef(
micp_mic_ctlr.c
)
zephyr_library_sources_ifdef(
CONFIG_BT_CSIP
csip.c
CONFIG_BT_CSIP_SET_MEMBER
csip_set_member.c
)
zephyr_library_sources_ifdef(
CONFIG_BT_CSIP_SET_COORDINATOR

6
subsys/bluetooth/shell/bt.c
View file

@ -1245,7 +1245,9 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
/* A privacy-enabled Set Member should advertise RSI values only when in
* the GAP Limited Discoverable mode.
*/
if (IS_ENABLED(CONFIG_BT_PRIVACY) && IS_ENABLED(CONFIG_BT_CSIP) && csip != NULL) {
if (IS_ENABLED(CONFIG_BT_PRIVACY) &&
IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER) &&
csip != NULL) {
ad_flags |= BT_LE_AD_LIMITED;
} else {
ad_flags |= BT_LE_AD_GENERAL;
@ -1272,7 +1274,7 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
ad_len++;
}
if (IS_ENABLED(CONFIG_BT_CSIP)) {
if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER)) {
ssize_t csis_ad_len;
csis_ad_len = csis_ad_data_add(&data_array[ad_len],

16
subsys/bluetooth/shell/cap_acceptor.c
View file

@ -16,7 +16,7 @@
#include "bt.h"
extern const struct shell *ctx_shell;
static struct bt_csip *cap_csip;
static struct bt_csip *cap_csip_set_member;
static uint8_t sirk_read_rsp = BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
static void locked_cb(struct bt_conn *conn, struct bt_csip *csip, bool locked)
@ -49,7 +49,7 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
return sirk_read_rsp;
}
static struct bt_csip_cb csip_cbs = {
static struct bt_csip_set_member_cb csip_set_member_cbs = {
.lock_changed = locked_cb,
.sirk_read_req = sirk_read_req_cb,
};
@ -58,14 +58,14 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
char **argv)
{
int err;
struct bt_csip_register_param param = {
struct bt_csip_set_member_register_param param = {
.set_size = 2,
.rank = 1,
.lockable = true,
/* Using the CSIS test sample SIRK */
.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
.cb = &csip_cbs
.cb = &csip_set_member_cbs
};
for (size_t argn = 1; argn < argc; argn++) {
@ -95,7 +95,7 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
}
}
err = bt_cap_acceptor_register(&param, &cap_csip);
err = bt_cap_acceptor_register(&param, &cap_csip_set_member);
if (err != 0) {
shell_error(sh, "Could not register CAS: %d", err);
@ -108,7 +108,7 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
static int cmd_cap_acceptor_print_sirk(const struct shell *sh, size_t argc,
char *argv[])
{
bt_csip_print_sirk(cap_csip);
bt_csip_set_member_print_sirk(cap_csip_set_member);
return 0;
}
@ -118,7 +118,7 @@ static int cmd_cap_acceptor_lock(const struct shell *sh, size_t argc,
{
int err;
err = bt_csip_lock(cap_csip, true, false);
err = bt_csip_set_member_lock(cap_csip_set_member, true, false);
if (err != 0) {
shell_error(sh, "Failed to set lock: %d", err);
@ -146,7 +146,7 @@ static int cmd_cap_acceptor_release(const struct shell *sh, size_t argc,
}
}
err = bt_csip_lock(cap_csip, false, force);
err = bt_csip_set_member_lock(cap_csip_set_member, false, force);
if (err != 0) {
shell_error(sh, "Failed to release lock: %d", err);

49
subsys/bluetooth/shell/csip.c → subsys/bluetooth/shell/csip_set_member.c
View file

@ -1,6 +1,6 @@
/**
* @file
* @brief Shell APIs for Bluetooth CSIP
* @brief Shell APIs for Bluetooth CSIP set member
*
* Copyright (c) 2020 Bose Corporation
* Copyright (c) 2021 Nordic Semiconductor ASA
@ -53,22 +53,22 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
return sirk_read_rsp;
}
static struct bt_csip_cb csip_cbs = {
static struct bt_csip_set_member_cb csip_set_member_cbs = {
.lock_changed = locked_cb,
.sirk_read_req = sirk_read_req_cb,
};
static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
static int cm_csip_set_member_register(const struct shell *sh, size_t argc, char **argv)
{
int err;
struct bt_csip_register_param param = {
struct bt_csip_set_member_register_param param = {
.set_size = 2,
.rank = 1,
.lockable = true,
/* Using the CSIS test sample SIRK */
.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
.cb = &csip_cbs
.cb = &csip_set_member_cbs
};
for (size_t argn = 1; argn < argc; argn++) {
@ -96,7 +96,7 @@ static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
}
}
err = bt_csip_register(&param, &csip);
err = bt_csip_set_member_register(&param, &csip);
if (err != 0) {
shell_error(sh, "Could not register CSIP: %d", err);
return err;
@ -105,18 +105,18 @@ static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
return 0;
}
static int cmd_csip_print_sirk(const struct shell *sh, size_t argc,
static int cm_csip_set_member_print_sirk(const struct shell *sh, size_t argc,
char *argv[])
{
bt_csip_print_sirk(csip);
bt_csip_set_member_print_sirk(csip);
return 0;
}
static int cmd_csip_lock(const struct shell *sh, size_t argc, char *argv[])
static int cm_csip_set_member_lock(const struct shell *sh, size_t argc, char *argv[])
{
int err;
err = bt_csip_lock(csip, true, false);
err = bt_csip_set_member_lock(csip, true, false);
if (err != 0) {
shell_error(sh, "Failed to set lock: %d", err);
return -ENOEXEC;
@ -127,7 +127,7 @@ static int cmd_csip_lock(const struct shell *sh, size_t argc, char *argv[])
return 0;
}
static int cmd_csip_release(const struct shell *sh, size_t argc,
static int cm_csip_set_member_release(const struct shell *sh, size_t argc,
char *argv[])
{
bool force = false;
@ -142,7 +142,7 @@ static int cmd_csip_release(const struct shell *sh, size_t argc,
}
}
err = bt_csip_lock(csip, false, force);
err = bt_csip_set_member_lock(csip, false, force);
if (err != 0) {
shell_error(sh, "Failed to release lock: %d", err);
@ -154,7 +154,7 @@ static int cmd_csip_release(const struct shell *sh, size_t argc,
return 0;
}
static int cmd_csip_set_sirk_rsp(const struct shell *sh, size_t argc,
static int cm_csip_set_member_set_sirk_rsp(const struct shell *sh, size_t argc,
char *argv[])
{
if (strcmp(argv[1], "accept") == 0) {
@ -173,36 +173,37 @@ static int cmd_csip_set_sirk_rsp(const struct shell *sh, size_t argc,
return 0;
}
static int cmd_csip(const struct shell *sh, size_t argc, char **argv)
static int cm_csip_set_member(const struct shell *sh, size_t argc, char **argv)
{
shell_error(sh, "%s unknown parameter: %s", argv[0], argv[1]);
return -ENOEXEC;
}
SHELL_STATIC_SUBCMD_SET_CREATE(csip_cmds,
SHELL_STATIC_SUBCMD_SET_CREATE(csip_set_member_cmds,
SHELL_CMD_ARG(register, NULL,
"Initialize the service and register callbacks "
"[size <int>] [rank <int>] [not-lockable] [sirk <data>]",
cmd_csip_register, 1, 4),
cm_csip_set_member_register, 1, 4),
SHELL_CMD_ARG(lock, NULL,
"Lock the set",
cmd_csip_lock, 1, 0),
cm_csip_set_member_lock, 1, 0),
SHELL_CMD_ARG(release, NULL,
"Release the set [force]",
cmd_csip_release, 1, 1),
cm_csip_set_member_release, 1, 1),
SHELL_CMD_ARG(print_sirk, NULL,
"Print the currently used SIRK",
cmd_csip_print_sirk, 1, 0),
cm_csip_set_member_print_sirk, 1, 0),
SHELL_CMD_ARG(set_sirk_rsp, NULL,
"Set the response used in SIRK requests "
"<accept, accept_enc, reject, oob>",
cmd_csip_set_sirk_rsp, 2, 0),
cm_csip_set_member_set_sirk_rsp, 2, 0),
SHELL_SUBCMD_SET_END
);
SHELL_CMD_ARG_REGISTER(csip, &csip_cmds, "Bluetooth CSIP shell commands",
cmd_csip, 1, 1);
SHELL_CMD_ARG_REGISTER(csip_set_member, &csip_set_member_cmds,
"Bluetooth CSIP set member shell commands",
cm_csip_set_member, 1, 1);
ssize_t csis_ad_data_add(struct bt_data *data_array, const size_t data_array_size,
const bool discoverable)
@ -218,11 +219,11 @@ ssize_t csis_ad_data_add(struct bt_data *data_array, const size_t data_array_siz
* from a SIRK that is exposed in encrypted form.
*/
if (IS_ENABLED(CONFIG_BT_PRIVACY) &&
!IS_ENABLED(CONFIG_BT_CSIP_ENC_SIRK_SUPPORT)) {
!IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT)) {
shell_warn(ctx_shell, "RSI derived from unencrypted SIRK");
}
err = bt_csip_generate_rsi(csip, ad_rsi);
err = bt_csip_set_member_generate_rsi(csip, ad_rsi);
if (err != 0) {
shell_error(ctx_shell, "Failed to generate RSI (err %d)", err);
return err;

8
tests/bluetooth/bsim_bt/bsim_test_audio/prj.conf
View file

@ -60,8 +60,8 @@ CONFIG_BT_MICP_MIC_CTLR=y
CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=2
# Coordinated Set Identification
CONFIG_BT_CSIP=y
CONFIG_BT_CSIP_TEST_SAMPLE_DATA=y
CONFIG_BT_CSIP_SET_MEMBER=y
CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA=y
CONFIG_BT_CSIP_SET_COORDINATOR=y
CONFIG_BT_CSIP_SET_COORDINATOR_TEST_SAMPLE_DATA=y
@ -132,9 +132,9 @@ CONFIG_BT_DEBUG_MCC=y
CONFIG_BT_OTS_LOG_LEVEL_DBG=y
CONFIG_BT_DEBUG_OTS_CLIENT=y
CONFIG_MCTL_DEBUG=y
CONFIG_BT_DEBUG_CSIP=y
CONFIG_BT_DEBUG_CSIP_SET_MEMBER=y
CONFIG_BT_DEBUG_CSIP_SET_COORDINATOR=y
CONFIG_BT_DEBUG_CSIP_CRYPTO=y
CONFIG_BT_DEBUG_CSIP_SET_MEMBER_CRYPTO=y
CONFIG_BT_AUDIO_DEBUG_UNICAST_CLIENT=y
CONFIG_BT_AUDIO_DEBUG_UNICAST_SERVER=y
CONFIG_BT_AUDIO_DEBUG_BROADCAST_SINK=y

9
tests/bluetooth/bsim_bt/bsim_test_audio/src/cap_acceptor_test.c
View file

@ -19,7 +19,7 @@ static const struct bt_data cap_acceptor_ad[] = {
BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_CAS_VAL)),
};
static struct bt_csip *csis;
static struct bt_csip *csip_set_member;
CREATE_FLAG(flag_connected);
@ -45,11 +45,11 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
static void init(void)
{
struct bt_csip_register_param csis_param = {
struct bt_csip_set_member_register_param csip_set_member_param = {
.set_size = 3,
.rank = 1,
.lockable = true,
/* Using the CSIS test sample SIRK */
/* Using the CSIP_SET_MEMBER test sample SIRK */
.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
};
@ -64,7 +64,8 @@ static void init(void)
printk("Bluetooth initialized\n");
if (IS_ENABLED(CONFIG_BT_CAP_ACCEPTOR_SET_MEMBER)) {
err = bt_cap_acceptor_register(&csis_param, &csis);
err = bt_cap_acceptor_register(&csip_set_member_param,
&csip_set_member);
if (err != 0) {
FAIL("CAP acceptor failed to register (err %d)\n", err);
return;

24
tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_test.c → tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_set_member_test.c
View file

@ -4,7 +4,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifdef CONFIG_BT_CSIP
#ifdef CONFIG_BT_CSIP_SET_MEMBER
#include <zephyr/bluetooth/audio/csip.h>
#include "common.h"
@ -14,7 +14,7 @@ static struct bt_conn_cb conn_callbacks;
extern enum bst_result_t bst_result;
static volatile bool g_locked;
static uint8_t sirk_read_req_rsp = BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
struct bt_csip_register_param param = {
struct bt_csip_set_member_register_param param = {
.set_size = 3,
.rank = 1,
.lockable = true,
@ -59,7 +59,7 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
return sirk_read_req_rsp;
}
static struct bt_csip_cb csip_cbs = {
static struct bt_csip_set_member_cb csip_cbs = {
.lock_changed = csip_lock_changed_cb,
.sirk_read_req = sirk_read_req_cb,
};
@ -81,13 +81,13 @@ static void bt_ready(int err)
param.cb = &csip_cbs;
err = bt_csip_register(&param, &csip);
err = bt_csip_set_member_register(&param, &csip);
if (err != 0) {
FAIL("Could not register CSIP (err %d)\n", err);
return;
}
err = bt_csip_generate_rsi(csip, rsi);
err = bt_csip_set_member_generate_rsi(csip, rsi);
if (err != 0) {
FAIL("Failed to generate RSI (err %d)\n", err);
return;
@ -133,7 +133,7 @@ static void test_force_release(void)
WAIT_FOR_COND(g_locked);
printk("Force releasing set\n");
bt_csip_lock(csip, false, true);
bt_csip_set_member_lock(csip, false, true);
}
static void test_csip_enc(void)
@ -173,21 +173,21 @@ static void test_args(int argc, char *argv[])
static const struct bst_test_instance test_connect[] = {
{
.test_id = "csip",
.test_id = "csip_set_member",
.test_post_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_main,
.test_args_f = test_args,
},
{
.test_id = "csip_release",
.test_id = "csip_set_member_release",
.test_post_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_force_release,
.test_args_f = test_args,
},
{
.test_id = "csip_enc",
.test_id = "csip_set_member_enc",
.test_post_init_f = test_init,
.test_tick_f = test_tick,
.test_main_f = test_csip_enc,
@ -197,15 +197,15 @@ static const struct bst_test_instance test_connect[] = {
BSTEST_END_MARKER
};
struct bst_test_list *test_csip_install(struct bst_test_list *tests)
struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests)
{
return bst_add_tests(tests, test_connect);
}
#else
struct bst_test_list *test_csip_install(struct bst_test_list *tests)
struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests)
{
return tests;
}
#endif /* CONFIG_BT_CSIP */
#endif /* CONFIG_BT_CSIP_SET_MEMBER */

4
tests/bluetooth/bsim_bt/bsim_test_audio/src/main.c
View file

@ -10,7 +10,7 @@ extern struct bst_test_list *test_vcs_install(struct bst_test_list *tests);
extern struct bst_test_list *test_vcs_client_install(struct bst_test_list *tests);
extern struct bst_test_list *test_micp_install(struct bst_test_list *tests);
extern struct bst_test_list *test_micp_mic_ctlr_install(struct bst_test_list *tests);
extern struct bst_test_list *test_csip_install(struct bst_test_list *tests);
extern struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests);
extern struct bst_test_list *test_csip_set_coordinator_install(struct bst_test_list *tests);
extern struct bst_test_list *test_tbs_install(struct bst_test_list *tests);
extern struct bst_test_list *test_tbs_client_install(struct bst_test_list *tests);
@ -36,7 +36,7 @@ bst_test_install_t test_installers[] = {
test_vcs_client_install,
test_micp_install,
test_micp_mic_ctlr_install,
test_csip_install,
test_csip_set_member_install,
test_csip_set_coordinator_install,
test_tbs_install,
test_tbs_client_install,

18
tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/csip.sh
View file

@ -33,15 +33,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-RealEncryption=1 -rs=1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member \
-RealEncryption=1 -rs=2 -argstest rank 1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member \
-RealEncryption=1 -rs=3 -argstest rank 2
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member \
-RealEncryption=1 -rs=4 -argstest rank 3
# Simulation time should be larger than the WAIT_TIME in common.h
@ -61,15 +61,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-RealEncryption=1 -rs=1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member \
-RealEncryption=1 -rs=2 -argstest rank 1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member \
-RealEncryption=1 -rs=3 -argstest rank 2
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_release \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member_release \
-RealEncryption=1 -rs=4 -argstest rank 3
# Simulation time should be larger than the WAIT_TIME in common.h
@ -87,15 +87,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-RealEncryption=1 -rs=1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_enc \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member_enc \
-RealEncryption=1 -rs=2 -argstest rank 1
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_enc \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member_enc \
-RealEncryption=1 -rs=3 -argstest rank 2
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_enc \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member_enc \
-RealEncryption=1 -rs=4 -argstest rank 3
# Simulation time should be larger than the WAIT_TIME in common.h

2
tests/bluetooth/shell/audio.conf
View file

@ -83,7 +83,7 @@ CONFIG_BT_MICP_MIC_CTLR=y
CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=1
# Coordinated Set Identification
CONFIG_BT_CSIP=y
CONFIG_BT_CSIP_SET_MEMBER=y
CONFIG_BT_CSIP_SET_COORDINATOR=y
CONFIG_BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES=2