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

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;