michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Audio: Add separate API for MICP mic ctlr

Browse source 
Add a bt_micp_mic_ctlr API that is used only
for the MICP Microphone Controller (Client).

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2022-06-21 17:45:11 +02:00 • committed by Carles Cufí
commit 3cf59fae72
15 changed files with 353 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -104,7 +104,7 @@ The API reference for volume control can be found in
:ref:`Bluetooth Volume Control <bluetooth_volume>`. :ref:`Bluetooth Volume Control <bluetooth_volume>`.
The API reference for microphone input control can be found in The API reference for microphone input control can be found in
:ref:`Bluetooth Microphone Control <bluetooth_microphone>`. :ref:`Bluetooth Microphone Input Control <bluetooth_microphone>`.
Content Control Content Control

191
include/zephyr/bluetooth/audio/micp.h
View file

@ -93,8 +93,7 @@ int bt_micp_register(struct bt_micp_register_param *param,
* Microphone Input Control Profile included services instances, such as * Microphone Input Control Profile included services instances, such as
* pointers to the Audio Input Control Service instances. * pointers to the Audio Input Control Service instances.
* *
* Requires that @kconfig{CONFIG_BT_MICP_AICS} or * Requires that @kconfig{CONFIG_BT_MICP_AICS}
* @kconfig{CONFIG_BT_MICP_CLIENT_AICS} is enabled.
* *
* @param micp Microphone Input Control Profile instance pointer. * @param micp Microphone Input Control Profile instance pointer.
* @param[out] included Pointer to store the result in. * @param[out] included Pointer to store the result in.
@ -104,32 +103,6 @@ int bt_micp_register(struct bt_micp_register_param *param,
int bt_micp_included_get(struct bt_micp *micp, int bt_micp_included_get(struct bt_micp *micp,
struct bt_micp_included *included); struct bt_micp_included *included);
/**
* @brief Get the connection pointer of a client instance
*
* Get the Bluetooth connection pointer of a Microphone Input Control Profile
* client instance.
*
* @param micp Microphone Input Control Profile client instance pointer.
* @param conn Connection pointer.
*
* @return 0 if success, errno on failure.
*/
int bt_micp_client_conn_get(const struct bt_micp *micp, struct bt_conn **conn);
/**
* @brief Callback function for @ref bt_micp_discover.
*
* This callback is only used for the client.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
* @param aics_count Number of Audio Input Control Service instances on
* peer device.
*/
typedef void (*bt_micp_discover_cb)(struct bt_micp *micp, int err,
uint8_t aics_count);
/** /**
* @brief Callback function for Microphone Input Control Profile mute. * @brief Callback function for Microphone Input Control Profile mute.
* *
@ -144,46 +117,10 @@ typedef void (*bt_micp_discover_cb)(struct bt_micp *micp, int err,
typedef void (*bt_micp_mute_read_cb)(struct bt_micp *micp, int err, typedef void (*bt_micp_mute_read_cb)(struct bt_micp *micp, int err,
uint8_t mute); uint8_t mute);
/**
* @brief Callback function for Microphone Input Control Profile mute/unmute.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
*/
typedef void (*bt_micp_mute_write_cb)(struct bt_micp *micp, int err);
struct bt_micp_cb { struct bt_micp_cb {
bt_micp_mute_read_cb mute; bt_micp_mute_read_cb mute;
#if defined(CONFIG_BT_MICP_CLIENT)
bt_micp_discover_cb discover;
bt_micp_mute_write_cb mute_write;
bt_micp_mute_write_cb unmute_write;
#if defined(CONFIG_BT_MICP_CLIENT_AICS)
/** Audio Input Control Service client callback */
struct bt_aics_cb aics_cb;
#endif /* CONFIG_BT_MICP_CLIENT_AICS */
#endif /* CONFIG_BT_MICP_CLIENT */
}; };
/**
* @brief Discover Microphone Input Control Profile instance
*
* This will start a GATT discovery and setup handles and subscriptions.
* This shall be called once before any other actions can be executed for the
* peer device, and the @ref bt_micp_discover_cb callback will notify when it
* is possible to start remote operations.
*
* This shall only be done as the client.
*
* @param conn The connection to initialize the profile for.
* @param[out] micp Valid remote instance object on success.
*
* @return 0 on success, GATT error value on fail.
*/
int bt_micp_discover(struct bt_conn *conn, struct bt_micp **micp);
/** /**
* @brief Unmute the server. * @brief Unmute the server.
* *
@ -223,6 +160,129 @@ int bt_micp_mute_disable(struct bt_micp *micp);
*/ */
int bt_micp_mute_get(struct bt_micp *micp); int bt_micp_mute_get(struct bt_micp *micp);
struct bt_micp_mic_ctlr_cb {
/**
* @brief Callback function for Microphone Input Control Profile mute.
*
* Called when the value is read,
* or if the value is changed by either the server or client.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
* For notifications, this will always be 0.
* @param mute The mute setting of the Microphone Input Control Profile instance.
*/
void (*mute)(struct bt_micp *micp, int err, uint8_t mute);
/**
* @brief Callback function for bt_micp_mic_ctlr_discover().
*
* This callback is only used for the client.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
* @param aics_count Number of Audio Input Control Service instances on
* peer device.
*/
void (*discover)(struct bt_micp *micp, int err, uint8_t aics_count);
/**
* @brief Callback function for Microphone Input Control Profile mute/unmute.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
*/
void (*mute_written)(struct bt_micp *micp, int err);
/**
* @brief Callback function for Microphone Input Control Profile mute/unmute.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param err Error value. 0 on success, GATT error or errno on fail.
*/
void (*unmute_written)(struct bt_micp *micp, int err);
#if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
/** Audio Input Control Service client callback */
struct bt_aics_cb aics_cb;
#endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
};
/**
* @brief Get Microphone Input Control Profile included services
*
* Returns a pointer to a struct that contains information about the
* Microphone Input Control Profile included services instances, such as
* pointers to the Audio Input Control Service instances.
*
* Requires that @kconfig{CONFIG_BT_MICP_MIC_CTLR_AICS} is enabled.
*
* @param micp Microphone Input Control Profile instance pointer.
* @param[out] included Pointer to store the result in.
*
* @return 0 if success, errno on failure.
*/
int bt_micp_mic_ctlr_included_get(struct bt_micp *micp,
struct bt_micp_included *included);
/**
* @brief Get the connection pointer of a client instance
*
* Get the Bluetooth connection pointer of a Microphone Input Control Profile
* client instance.
*
* @param micp Microphone Input Control Profile client instance pointer.
* @param conn Connection pointer.
*
* @return 0 if success, errno on failure.
*/
int bt_micp_mic_ctlr_conn_get(const struct bt_micp *micp,
struct bt_conn **conn);
/**
* @brief Discover Microphone Input Control Profile instance
*
* This will start a GATT discovery and setup handles and subscriptions.
* This shall be called once before any other actions can be executed for the
* peer device, and the @ref bt_micp_mic_ctlr_cb.discover callback will notify
* when it is possible to start remote operations.
*
* This shall only be done as the client.
*
* @param conn The connection to initialize the profile for.
* @param[out] micp Valid remote instance object on success.
*
* @return 0 on success, GATT error value on fail.
*/
int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp **micp);
/**
* @brief Unmute the server.
*
* @param micp Microphone Input Control Profile instance pointer.
*
* @return 0 on success, GATT error value on fail.
*/
int bt_micp_mic_ctlr_unmute(struct bt_micp *micp);
/**
* @brief Mute the server.
*
* @param micp Microphone Input Control Profile instance pointer.
*
* @return 0 on success, GATT error value on fail.
*/
int bt_micp_mic_ctlr_mute(struct bt_micp *micp);
/**
* @brief Read the mute state of a Microphone Input Control Profile instance.
*
* @param micp Microphone Input Control Profile instance pointer.
*
* @return 0 on success, GATT error value on fail.
*/
int bt_micp_mic_ctlr_mute_get(struct bt_micp *micp);
/** /**
* @brief Registers the callbacks used by Microphone Input Control Profile client. * @brief Registers the callbacks used by Microphone Input Control Profile client.
* *
@ -232,8 +292,7 @@ int bt_micp_mute_get(struct bt_micp *micp);
* *
* @return 0 if success, errno on failure. * @return 0 if success, errno on failure.
*/ */
int bt_micp_client_cb_register(struct bt_micp_cb *cb); int bt_micp_mic_ctlr_cb_register(struct bt_micp_mic_ctlr_cb *cb);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

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

@ -17,10 +17,10 @@ if (CONFIG_BT_VCS OR CONFIG_BT_VCS_CLIENT)
endif() endif()
zephyr_library_sources_ifdef(CONFIG_BT_VCS_CLIENT vcs_client.c) zephyr_library_sources_ifdef(CONFIG_BT_VCS_CLIENT vcs_client.c)
if (CONFIG_BT_MICP OR CONFIG_BT_MICP_CLIENT) if (CONFIG_BT_MICP)
zephyr_library_sources(micp_mic_dev.c) zephyr_library_sources(micp_mic_dev.c)
endif() endif()
zephyr_library_sources_ifdef(CONFIG_BT_MICP_CLIENT micp_mic_ctlr.c) zephyr_library_sources_ifdef(CONFIG_BT_MICP_MIC_CTLR micp_mic_ctlr.c)
zephyr_library_sources_ifdef(CONFIG_BT_CCID ccid.c) zephyr_library_sources_ifdef(CONFIG_BT_CCID ccid.c)

27
subsys/bluetooth/audio/Kconfig.micp
View file

@ -41,19 +41,20 @@ config BT_DEBUG_MICP
endif # BT_MICP endif # BT_MICP
##################### Microphone Control Profile Client ##################### ########### Microphone Input Control Profile Microphone Controller ###########
config BT_MICP_CLIENT config BT_MICP_MIC_CTLR
bool "Microphone Control Profile Support [EXPERIMENTAL]" bool "Microphone Input Control Profile Microphone Controller Support [EXPERIMENTAL]"
select BT_GATT_CLIENT select BT_GATT_CLIENT
select BT_GATT_AUTO_DISCOVER_CCC select BT_GATT_AUTO_DISCOVER_CCC
select EXPERIMENTAL select EXPERIMENTAL
help help
This option enables support for Microphone Control Profile. This option enables support for the Microphone Input Control Profile
Microphone Controller role
if BT_MICP_CLIENT if BT_MICP_MIC_CTLR
config BT_MICP_CLIENT_MAX_AICS_INST config BT_MICP_MIC_CTLR_MAX_AICS_INST
int "Maximum number of Audio Input Control Service instances to setup" int "Maximum number of Audio Input Control Service instances to setup"
default 0 default 0
range 0 BT_AICS_CLIENT_MAX_INSTANCE_COUNT range 0 BT_AICS_CLIENT_MAX_INSTANCE_COUNT
@ -61,19 +62,19 @@ config BT_MICP_CLIENT_MAX_AICS_INST
Sets the maximum number of Audio Input Control Service (AICS) Sets the maximum number of Audio Input Control Service (AICS)
instances to setup and use. instances to setup and use.
config BT_MICP_CLIENT_AICS config BT_MICP_MIC_CTLR_AICS
bool # Hidden bool # Hidden
default y if BT_MICP_CLIENT_MAX_AICS_INST > 0 default y if BT_MICP_MIC_CTLR_MAX_AICS_INST > 0
help help
This hidden option makes it possible to easily check if AICS is This hidden option makes it possible to easily check if AICS is
enabled for MICP client. enabled for MICP client.
############# DEBUG ############# ############# DEBUG #############
config BT_DEBUG_MICP_CLIENT config BT_DEBUG_MICP_MIC_CTLR
bool "Microphone Control Profile debug" bool "Microphone Input Control Profile Microphone Controller debug"
help help
Use this option to enable Microphone Control Profile debug logs for Use this option to enable Microphone Input Control Profile Microphone
the Bluetooth Audio functionality. Controller debug logs for the Bluetooth Audio functionality.
endif # BT_MICP_CLIENT endif # BT_MICP_MIC_CTLR

20
subsys/bluetooth/audio/micp_internal.h
View file

@ -18,8 +18,8 @@ struct bt_micp_server {
}; };
#endif /* CONFIG_BT_MICP */ #endif /* CONFIG_BT_MICP */
#if defined(CONFIG_BT_MICP_CLIENT) #if defined(CONFIG_BT_MICP_MIC_CTLR)
struct bt_micp_client { struct bt_micp_mic_ctlr {
uint16_t start_handle; uint16_t start_handle;
uint16_t end_handle; uint16_t end_handle;
uint16_t mute_handle; uint16_t mute_handle;
@ -34,9 +34,9 @@ struct bt_micp_client {
struct bt_conn *conn; struct bt_conn *conn;
uint8_t aics_inst_cnt; uint8_t aics_inst_cnt;
struct bt_aics *aics[CONFIG_BT_MICP_CLIENT_MAX_AICS_INST]; struct bt_aics *aics[CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST];
}; };
#endif /* CONFIG_BT_MICP_CLIENT */ #endif /* CONFIG_BT_MICP_MIC_CTLR */
/* Struct used as a common type for the api */ /* Struct used as a common type for the api */
struct bt_micp { struct bt_micp {
@ -45,16 +45,10 @@ struct bt_micp {
#if defined(CONFIG_BT_MICP) #if defined(CONFIG_BT_MICP)
struct bt_micp_server srv; struct bt_micp_server srv;
#endif /* CONFIG_BT_MICP */ #endif /* CONFIG_BT_MICP */
#if defined(CONFIG_BT_MICP_CLIENT) #if defined(CONFIG_BT_MICP_MIC_CTLR)
struct bt_micp_client cli; struct bt_micp_mic_ctlr cli;
#endif /* CONFIG_BT_MICP_CLIENT */ #endif /* CONFIG_BT_MICP_MIC_CTLR */
}; };
}; };
int bt_micp_client_included_get(struct bt_micp *micp,
struct bt_micp_included *included);
int bt_micp_client_mute_get(struct bt_micp *micp);
int bt_micp_client_mute(struct bt_micp *micp);
int bt_micp_client_unmute(struct bt_micp *micp);
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_MICS_INTERNAL_ */ #endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_MICS_INTERNAL_ */

129
subsys/bluetooth/audio/micp_mic_ctlr.c
View file

@ -1,4 +1,4 @@
/* Bluetooth MICP client - Microphone Control Profile - Client */ /* Bluetooth MICP - Microphone Input Control Profile - Microphone Controller */
/* /*
* Copyright (c) 2020 Bose Corporation * Copyright (c) 2020 Bose Corporation
@ -22,12 +22,12 @@
#include "micp_internal.h" #include "micp_internal.h"
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_MICP_CLIENT) #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_MICP_MIC_CTLR)
#define LOG_MODULE_NAME bt_micp_client #define LOG_MODULE_NAME bt_micp_mic_ctlr
#include "common/log.h" #include "common/log.h"
/* Callback functions */ /* Callback functions */
static struct bt_micp_cb *micp_client_cb; static struct bt_micp_mic_ctlr_cb *micp_mic_ctlr_cb;
static struct bt_micp micp_insts[CONFIG_BT_MAX_CONN]; static struct bt_micp micp_insts[CONFIG_BT_MAX_CONN];
static struct bt_uuid *mics_uuid = BT_UUID_MICS; static struct bt_uuid *mics_uuid = BT_UUID_MICS;
@ -49,9 +49,9 @@ static uint8_t mute_notify_handler(struct bt_conn *conn,
if (length == sizeof(*mute_val)) { if (length == sizeof(*mute_val)) {
mute_val = (uint8_t *)data; mute_val = (uint8_t *)data;
BT_DBG("Mute %u", *mute_val); BT_DBG("Mute %u", *mute_val);
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->mute != NULL) { micp_mic_ctlr_cb->mute != NULL) {
micp_client_cb->mute(micp_inst, 0, *mute_val); micp_mic_ctlr_cb->mute(micp_inst, 0, *mute_val);
} }
} else { } else {
BT_DBG("Invalid length %u (expected %zu)", BT_DBG("Invalid length %u (expected %zu)",
@ -63,7 +63,7 @@ static uint8_t mute_notify_handler(struct bt_conn *conn,
return BT_GATT_ITER_CONTINUE; return BT_GATT_ITER_CONTINUE;
} }
static uint8_t micp_client_read_mute_cb(struct bt_conn *conn, uint8_t err, static uint8_t micp_mic_ctlr_read_mute_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params, struct bt_gatt_read_params *params,
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
@ -86,14 +86,14 @@ static uint8_t micp_client_read_mute_cb(struct bt_conn *conn, uint8_t err,
} }
} }
if (micp_client_cb != NULL && micp_client_cb->mute != NULL) { if (micp_mic_ctlr_cb != NULL && micp_mic_ctlr_cb->mute != NULL) {
micp_client_cb->mute(micp_inst, cb_err, mute_val); micp_mic_ctlr_cb->mute(micp_inst, cb_err, mute_val);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
} }
static void micp_client_write_mics_mute_cb(struct bt_conn *conn, uint8_t err, static void micp_mic_ctlr_write_mics_mute_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params) struct bt_gatt_write_params *params)
{ {
struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)]; struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
@ -104,20 +104,20 @@ static void micp_client_write_mics_mute_cb(struct bt_conn *conn, uint8_t err,
micp_inst->cli.busy = false; micp_inst->cli.busy = false;
if (mute_val == BT_MICP_MUTE_UNMUTED) { if (mute_val == BT_MICP_MUTE_UNMUTED) {
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->unmute_write != NULL) { micp_mic_ctlr_cb->unmute_written != NULL) {
micp_client_cb->unmute_write(micp_inst, err); micp_mic_ctlr_cb->unmute_written(micp_inst, err);
} }
} else { } else {
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->mute_write != NULL) { micp_mic_ctlr_cb->mute_written != NULL) {
micp_client_cb->mute_write(micp_inst, err); micp_mic_ctlr_cb->mute_written(micp_inst, err);
} }
} }
} }
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static struct bt_micp *lookup_micp_by_aics(const struct bt_aics *aics) static struct bt_micp *lookup_micp_by_aics(const struct bt_aics *aics)
{ {
__ASSERT(aics != NULL, "AICS pointer cannot be NULL"); __ASSERT(aics != NULL, "AICS pointer cannot be NULL");
@ -145,13 +145,13 @@ static void aics_discover_cb(struct bt_aics *inst, int err)
if (err != 0) { if (err != 0) {
BT_DBG("Discover failed (err %d)", err); BT_DBG("Discover failed (err %d)", err);
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, err, 0); micp_mic_ctlr_cb->discover(micp_inst, err, 0);
} }
} }
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
static uint8_t micp_discover_include_func( static uint8_t micp_discover_include_func(
struct bt_conn *conn, const struct bt_gatt_attr *attr, struct bt_conn *conn, const struct bt_gatt_attr *attr,
@ -164,9 +164,10 @@ static uint8_t micp_discover_include_func(
micp_inst->cli.aics_inst_cnt); micp_inst->cli.aics_inst_cnt);
(void)memset(params, 0, sizeof(*params)); (void)memset(params, 0, sizeof(*params));
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, 0, 0); micp_mic_ctlr_cb->discover(micp_inst, 0,
micp_inst->cli.aics_inst_cnt);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
@ -180,7 +181,7 @@ static uint8_t micp_discover_include_func(
BT_DBG("Include UUID %s", bt_uuid_str(include->uuid)); BT_DBG("Include UUID %s", bt_uuid_str(include->uuid));
if (bt_uuid_cmp(include->uuid, BT_UUID_AICS) == 0 && if (bt_uuid_cmp(include->uuid, BT_UUID_AICS) == 0 &&
micp_inst->cli.aics_inst_cnt < CONFIG_BT_MICP_CLIENT_MAX_AICS_INST) { micp_inst->cli.aics_inst_cnt < CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST) {
uint8_t inst_idx; uint8_t inst_idx;
int err; int err;
struct bt_aics_discover_param param = { struct bt_aics_discover_param param = {
@ -198,9 +199,9 @@ static uint8_t micp_discover_include_func(
&param); &param);
if (err != 0) { if (err != 0) {
BT_DBG("AICS Discover failed (err %d)", err); BT_DBG("AICS Discover failed (err %d)", err);
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, err, micp_mic_ctlr_cb->discover(micp_inst, err,
0); 0);
} }
} }
@ -227,7 +228,7 @@ static uint8_t micp_discover_func(struct bt_conn *conn,
BT_DBG("Setup complete for MICP"); BT_DBG("Setup complete for MICP");
(void)memset(params, 0, sizeof(*params)); (void)memset(params, 0, sizeof(*params));
if (CONFIG_BT_MICP_CLIENT_MAX_AICS_INST > 0) { if (CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST > 0) {
/* Discover included services */ /* Discover included services */
micp_inst->cli.discover_params.start_handle = micp_inst->cli.start_handle; micp_inst->cli.discover_params.start_handle = micp_inst->cli.start_handle;
micp_inst->cli.discover_params.end_handle = micp_inst->cli.end_handle; micp_inst->cli.discover_params.end_handle = micp_inst->cli.end_handle;
@ -238,15 +239,15 @@ static uint8_t micp_discover_func(struct bt_conn *conn,
&micp_inst->cli.discover_params); &micp_inst->cli.discover_params);
if (err != 0) { if (err != 0) {
BT_DBG("Discover failed (err %d)", err); BT_DBG("Discover failed (err %d)", err);
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, err, 0); micp_mic_ctlr_cb->discover(micp_inst, err, 0);
} }
} }
} else { } else {
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, err, 0); micp_mic_ctlr_cb->discover(micp_inst, err, 0);
} }
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
@ -297,9 +298,9 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
if (attr == NULL) { if (attr == NULL) {
BT_DBG("Could not find a MICS instance on the server"); BT_DBG("Could not find a MICS instance on the server");
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, -ENODATA, 0); micp_mic_ctlr_cb->discover(micp_inst, -ENODATA, 0);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
} }
@ -325,9 +326,9 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
err = bt_gatt_discover(conn, &micp_inst->cli.discover_params); err = bt_gatt_discover(conn, &micp_inst->cli.discover_params);
if (err != 0) { if (err != 0) {
BT_DBG("Discover failed (err %d)", err); BT_DBG("Discover failed (err %d)", err);
if (micp_client_cb != NULL && if (micp_mic_ctlr_cb != NULL &&
micp_client_cb->discover != NULL) { micp_mic_ctlr_cb->discover != NULL) {
micp_client_cb->discover(micp_inst, err, 0); micp_mic_ctlr_cb->discover(micp_inst, err, 0);
} }
} }
@ -337,7 +338,7 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
return BT_GATT_ITER_CONTINUE; return BT_GATT_ITER_CONTINUE;
} }
static void micp_client_reset(struct bt_micp *micp) static void micp_mic_ctlr_reset(struct bt_micp *micp)
{ {
micp->cli.start_handle = 0; micp->cli.start_handle = 0;
micp->cli.end_handle = 0; micp->cli.end_handle = 0;
@ -365,7 +366,7 @@ static void disconnected(struct bt_conn *conn, uint8_t reason)
struct bt_micp *micp = &micp_insts[bt_conn_index(conn)]; struct bt_micp *micp = &micp_insts[bt_conn_index(conn)];
if (micp->cli.conn == conn) { if (micp->cli.conn == conn) {
micp_client_reset(micp); micp_mic_ctlr_reset(micp);
} }
} }
@ -373,7 +374,7 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.disconnected = disconnected, .disconnected = disconnected,
}; };
int bt_micp_discover(struct bt_conn *conn, struct bt_micp **micp) int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp **micp)
{ {
struct bt_micp *micp_inst; struct bt_micp *micp_inst;
int err; int err;
@ -397,9 +398,9 @@ int bt_micp_discover(struct bt_conn *conn, struct bt_micp **micp)
(void)memset(&micp_inst->cli.discover_params, 0, (void)memset(&micp_inst->cli.discover_params, 0,
sizeof(micp_inst->cli.discover_params)); sizeof(micp_inst->cli.discover_params));
micp_client_reset(micp_inst); micp_mic_ctlr_reset(micp_inst);
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static bool initialized; static bool initialized;
if (!initialized) { if (!initialized) {
@ -411,12 +412,12 @@ int bt_micp_discover(struct bt_conn *conn, struct bt_micp **micp)
} }
bt_aics_client_cb_register(micp_inst->cli.aics[i], bt_aics_client_cb_register(micp_inst->cli.aics[i],
&micp_client_cb->aics_cb); &micp_mic_ctlr_cb->aics_cb);
} }
} }
initialized = true; initialized = true;
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
micp_inst->cli.conn = bt_conn_ref(conn); micp_inst->cli.conn = bt_conn_ref(conn);
micp_inst->client_instance = true; micp_inst->client_instance = true;
@ -434,9 +435,9 @@ int bt_micp_discover(struct bt_conn *conn, struct bt_micp **micp)
return err; return err;
} }
int bt_micp_client_cb_register(struct bt_micp_cb *cb) int bt_micp_mic_ctlr_cb_register(struct bt_micp_mic_ctlr_cb *cb)
{ {
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
struct bt_aics_cb *aics_cb = NULL; struct bt_aics_cb *aics_cb = NULL;
if (cb != NULL) { if (cb != NULL) {
@ -458,15 +459,15 @@ int bt_micp_client_cb_register(struct bt_micp_cb *cb)
} }
} }
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
micp_client_cb = cb; micp_mic_ctlr_cb = cb;
return 0; return 0;
} }
int bt_micp_client_included_get(struct bt_micp *micp, int bt_micp_mic_ctlr_included_get(struct bt_micp *micp,
struct bt_micp_included *included) struct bt_micp_included *included)
{ {
CHECKIF(micp == NULL) { CHECKIF(micp == NULL) {
BT_DBG("NULL micp"); BT_DBG("NULL micp");
@ -483,7 +484,7 @@ int bt_micp_client_included_get(struct bt_micp *micp,
return 0; return 0;
} }
int bt_micp_client_conn_get(const struct bt_micp *micp, struct bt_conn **conn) int bt_micp_mic_ctlr_conn_get(const struct bt_micp *micp, struct bt_conn **conn)
{ {
CHECKIF(micp == NULL) { CHECKIF(micp == NULL) {
BT_DBG("NULL micp pointer"); BT_DBG("NULL micp pointer");
@ -505,7 +506,7 @@ int bt_micp_client_conn_get(const struct bt_micp *micp, struct bt_conn **conn)
return 0; return 0;
} }
int bt_micp_client_mute_get(struct bt_micp *micp) int bt_micp_mic_ctlr_mute_get(struct bt_micp *micp)
{ {
int err; int err;
@ -521,7 +522,7 @@ int bt_micp_client_mute_get(struct bt_micp *micp)
return -EBUSY; return -EBUSY;
} }
micp->cli.read_params.func = micp_client_read_mute_cb; micp->cli.read_params.func = micp_mic_ctlr_read_mute_cb;
micp->cli.read_params.handle_count = 1; micp->cli.read_params.handle_count = 1;
micp->cli.read_params.single.handle = micp->cli.mute_handle; micp->cli.read_params.single.handle = micp->cli.mute_handle;
micp->cli.read_params.single.offset = 0U; micp->cli.read_params.single.offset = 0U;
@ -534,7 +535,7 @@ int bt_micp_client_mute_get(struct bt_micp *micp)
return err; return err;
} }
int bt_micp_client_write_mute(struct bt_micp *micp, bool mute) int bt_micp_mic_ctlr_write_mute(struct bt_micp *micp, bool mute)
{ {
int err; int err;
@ -555,7 +556,7 @@ int bt_micp_client_write_mute(struct bt_micp *micp, bool mute)
micp->cli.write_params.data = micp->cli.mute_val_buf; micp->cli.write_params.data = micp->cli.mute_val_buf;
micp->cli.write_params.length = sizeof(mute); micp->cli.write_params.length = sizeof(mute);
micp->cli.write_params.handle = micp->cli.mute_handle; micp->cli.write_params.handle = micp->cli.mute_handle;
micp->cli.write_params.func = micp_client_write_mics_mute_cb; micp->cli.write_params.func = micp_mic_ctlr_write_mics_mute_cb;
err = bt_gatt_write(micp->cli.conn, &micp->cli.write_params); err = bt_gatt_write(micp->cli.conn, &micp->cli.write_params);
if (err == 0) { if (err == 0) {
@ -565,12 +566,12 @@ int bt_micp_client_write_mute(struct bt_micp *micp, bool mute)
return err; return err;
} }
int bt_micp_client_mute(struct bt_micp *micp) int bt_micp_mic_ctlr_mute(struct bt_micp *micp)
{ {
return bt_micp_client_write_mute(micp, true); return bt_micp_mic_ctlr_write_mute(micp, true);
} }
int bt_micp_client_unmute(struct bt_micp *micp) int bt_micp_mic_ctlr_unmute(struct bt_micp *micp)
{ {
return bt_micp_client_write_mute(micp, false); return bt_micp_mic_ctlr_write_mute(micp, false);
} }

53
subsys/bluetooth/audio/micp_mic_dev.c
View file

@ -25,8 +25,6 @@
#define LOG_MODULE_NAME bt_micp #define LOG_MODULE_NAME bt_micp
#include "common/log.h" #include "common/log.h"
#if defined(CONFIG_BT_MICP)
static struct bt_micp micp_inst; static struct bt_micp micp_inst;
static void mute_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value) static void mute_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
@ -197,8 +195,6 @@ int bt_micp_mute_disable(struct bt_micp *micp)
return err > 0 ? 0 : err; return err > 0 ? 0 : err;
} }
#endif /* CONFIG_BT_MICP */
int bt_micp_included_get(struct bt_micp *micp, int bt_micp_included_get(struct bt_micp *micp,
struct bt_micp_included *included) struct bt_micp_included *included)
{ {
@ -212,63 +208,42 @@ int bt_micp_included_get(struct bt_micp *micp,
return -EINVAL; return -EINVAL;
} }
#if defined(CONFIG_BT_MICP_AICS)
if (IS_ENABLED(CONFIG_BT_MICP_CLIENT) &&
IS_ENABLED(CONFIG_BT_MICP_CLIENT_AICS) &&
micp->client_instance) {
return bt_micp_client_included_get(micp, included);
}
#if defined(CONFIG_BT_MICP) && defined(CONFIG_BT_MICP_AICS)
included->aics_cnt = ARRAY_SIZE(micp_inst.srv.aics_insts); included->aics_cnt = ARRAY_SIZE(micp_inst.srv.aics_insts);
included->aics = micp_inst.srv.aics_insts; included->aics = micp_inst.srv.aics_insts;
#endif /* CONFIG_BT_MICP_AICS */
return 0; return 0;
#else
return -EOPNOTSUPP;
#endif /* CONFIG_BT_MICP && CONFIG_BT_MICP_AICS */
} }
int bt_micp_unmute(struct bt_micp *micp) int bt_micp_unmute(struct bt_micp *micp)
{ {
const uint8_t val = BT_MICP_MUTE_UNMUTED;
int err;
CHECKIF(micp == NULL) { CHECKIF(micp == NULL) {
BT_DBG("NULL micp pointer"); BT_DBG("NULL micp pointer");
return -EINVAL; return -EINVAL;
} }
if (IS_ENABLED(CONFIG_BT_MICP_CLIENT) && micp->client_instance) { err = write_mute(NULL, NULL, &val, sizeof(val), 0, 0);
return bt_micp_client_unmute(micp);
}
#if defined(CONFIG_BT_MICP)
uint8_t val = BT_MICP_MUTE_UNMUTED;
int err = write_mute(NULL, NULL, &val, sizeof(val), 0, 0);
return err > 0 ? 0 : err; return err > 0 ? 0 : err;
#else
return -EOPNOTSUPP;
#endif /* CONFIG_BT_MICP */
} }
int bt_micp_mute(struct bt_micp *micp) int bt_micp_mute(struct bt_micp *micp)
{ {
const uint8_t val = BT_MICP_MUTE_MUTED;
int err;
CHECKIF(micp == NULL) { CHECKIF(micp == NULL) {
BT_DBG("NULL micp pointer"); BT_DBG("NULL micp pointer");
return -EINVAL; return -EINVAL;
} }
if (IS_ENABLED(CONFIG_BT_MICP_CLIENT) && micp->client_instance) { err = write_mute(NULL, NULL, &val, sizeof(val), 0, 0);
return bt_micp_client_mute(micp);
}
#if defined(CONFIG_BT_MICP)
uint8_t val = BT_MICP_MUTE_MUTED;
int err = write_mute(NULL, NULL, &val, sizeof(val), 0, 0);
return err > 0 ? 0 : err; return err > 0 ? 0 : err;
#else
return -EOPNOTSUPP;
#endif /* CONFIG_BT_MICP */
} }
int bt_micp_mute_get(struct bt_micp *micp) int bt_micp_mute_get(struct bt_micp *micp)
@ -278,17 +253,9 @@ int bt_micp_mute_get(struct bt_micp *micp)
return -EINVAL; return -EINVAL;
} }
if (IS_ENABLED(CONFIG_BT_MICP_CLIENT) && micp->client_instance) {
return bt_micp_client_mute_get(micp);
}
#if defined(CONFIG_BT_MICP)
if (micp_inst.srv.cb && micp_inst.srv.cb->mute) { if (micp_inst.srv.cb && micp_inst.srv.cb->mute) {
micp_inst.srv.cb->mute(NULL, 0, micp_inst.srv.mute); micp_inst.srv.cb->mute(NULL, 0, micp_inst.srv.mute);
} }
return 0; return 0;
#else
return -EOPNOTSUPP;
#endif /* CONFIG_BT_MICP */
} }

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

@ -38,7 +38,7 @@ zephyr_library_sources_ifdef(
micp_mic_dev.c micp_mic_dev.c
) )
zephyr_library_sources_ifdef( zephyr_library_sources_ifdef(
CONFIG_BT_MICP_CLIENT CONFIG_BT_MICP_MIC_CTLR
micp_mic_ctlr.c micp_mic_ctlr.c
) )
zephyr_library_sources_ifdef( zephyr_library_sources_ifdef(

173
subsys/bluetooth/shell/micp_mic_ctlr.c
View file

@ -17,11 +17,11 @@
#include "bt.h" #include "bt.h"
static struct bt_micp *micp; static struct bt_micp *micp;
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static struct bt_micp_included micp_included; static struct bt_micp_included micp_included;
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
static void micp_discover_cb(struct bt_micp *micp, int err, uint8_t aics_count) static void micp_mic_ctlr_discover_cb(struct bt_micp *micp, int err, uint8_t aics_count)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "MICP discover failed (%d)", err); shell_error(ctx_shell, "MICP discover failed (%d)", err);
@ -29,15 +29,15 @@ static void micp_discover_cb(struct bt_micp *micp, int err, uint8_t aics_count)
shell_print(ctx_shell, "MICP discover done with %u AICS", shell_print(ctx_shell, "MICP discover done with %u AICS",
aics_count); aics_count);
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
if (bt_micp_included_get(micp, &micp_included) != 0) { if (bt_micp_mic_ctlr_included_get(micp, &micp_included) != 0) {
shell_error(ctx_shell, "Could not get MICP context"); shell_error(ctx_shell, "Could not get MICP context");
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
} }
} }
static void micp_mute_write_cb(struct bt_micp *micp, int err) static void micp_mic_ctlr_mute_written_cb(struct bt_micp *micp, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Mute write failed (%d)", err); shell_error(ctx_shell, "Mute write failed (%d)", err);
@ -46,7 +46,7 @@ static void micp_mute_write_cb(struct bt_micp *micp, int err)
} }
} }
static void micp_unmute_write_cb(struct bt_micp *micp, int err) static void micp_mic_ctlr_unmute_written_cb(struct bt_micp *micp, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Unmute write failed (%d)", err); shell_error(ctx_shell, "Unmute write failed (%d)", err);
@ -55,7 +55,7 @@ static void micp_unmute_write_cb(struct bt_micp *micp, int err)
} }
} }
static void micp_mute_cb(struct bt_micp *micp, int err, uint8_t mute) static void micp_mic_ctlr_mute_cb(struct bt_micp *micp, int err, uint8_t mute)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Mute get failed (%d)", err); shell_error(ctx_shell, "Mute get failed (%d)", err);
@ -64,10 +64,10 @@ static void micp_mute_cb(struct bt_micp *micp, int err, uint8_t mute)
} }
} }
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static struct bt_micp_included micp_included; static struct bt_micp_included micp_included;
static void micp_aics_set_gain_cb(struct bt_aics *inst, int err) static void micp_mic_ctlr_aics_set_gain_cb(struct bt_aics *inst, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Set gain failed (%d) for inst %p", shell_error(ctx_shell, "Set gain failed (%d) for inst %p",
@ -77,7 +77,7 @@ static void micp_aics_set_gain_cb(struct bt_aics *inst, int err)
} }
} }
static void micp_aics_unmute_cb(struct bt_aics *inst, int err) static void micp_mic_ctlr_aics_unmute_cb(struct bt_aics *inst, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Unmute failed (%d) for inst %p", shell_error(ctx_shell, "Unmute failed (%d) for inst %p",
@ -87,7 +87,7 @@ static void micp_aics_unmute_cb(struct bt_aics *inst, int err)
} }
} }
static void micp_aics_mute_cb(struct bt_aics *inst, int err) static void micp_mic_ctlr_aics_mute_cb(struct bt_aics *inst, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "Mute failed (%d) for inst %p", shell_error(ctx_shell, "Mute failed (%d) for inst %p",
@ -97,7 +97,7 @@ static void micp_aics_mute_cb(struct bt_aics *inst, int err)
} }
} }
static void micp_aics_set_manual_mode_cb(struct bt_aics *inst, int err) static void micp_mic_ctlr_aics_set_manual_mode_cb(struct bt_aics *inst, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, shell_error(ctx_shell,
@ -108,7 +108,7 @@ static void micp_aics_set_manual_mode_cb(struct bt_aics *inst, int err)
} }
} }
static void micp_aics_automatic_mode_cb(struct bt_aics *inst, int err) static void micp_mic_ctlr_aics_automatic_mode_cb(struct bt_aics *inst, int err)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, shell_error(ctx_shell,
@ -120,8 +120,8 @@ static void micp_aics_automatic_mode_cb(struct bt_aics *inst, int err)
} }
} }
static void micp_aics_state_cb(struct bt_aics *inst, int err, int8_t gain, static void micp_mic_ctlr_aics_state_cb(struct bt_aics *inst, int err,
uint8_t mute, uint8_t mode) int8_t gain, uint8_t mute, uint8_t mode)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "AICS state get failed (%d) for " shell_error(ctx_shell, "AICS state get failed (%d) for "
@ -133,9 +133,9 @@ static void micp_aics_state_cb(struct bt_aics *inst, int err, int8_t gain,
} }
static void micp_aics_gain_setting_cb(struct bt_aics *inst, int err, static void micp_mic_ctlr_aics_gain_setting_cb(struct bt_aics *inst, int err,
uint8_t units, int8_t minimum, uint8_t units, int8_t minimum,
int8_t maximum) int8_t maximum)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "AICS gain settings get failed (%d) for " shell_error(ctx_shell, "AICS gain settings get failed (%d) for "
@ -148,8 +148,8 @@ static void micp_aics_gain_setting_cb(struct bt_aics *inst, int err,
} }
static void micp_aics_input_type_cb(struct bt_aics *inst, int err, static void micp_mic_ctlr_aics_input_type_cb(struct bt_aics *inst, int err,
uint8_t input_type) uint8_t input_type)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "AICS input type get failed (%d) for " shell_error(ctx_shell, "AICS input type get failed (%d) for "
@ -161,7 +161,8 @@ static void micp_aics_input_type_cb(struct bt_aics *inst, int err,
} }
static void micp_aics_status_cb(struct bt_aics *inst, int err, bool active) static void micp_mic_ctlr_aics_status_cb(struct bt_aics *inst, int err,
bool active)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "AICS status get failed (%d) for " shell_error(ctx_shell, "AICS status get failed (%d) for "
@ -173,8 +174,8 @@ static void micp_aics_status_cb(struct bt_aics *inst, int err, bool active)
} }
static void micp_aics_description_cb(struct bt_aics *inst, int err, static void micp_mic_ctlr_aics_description_cb(struct bt_aics *inst, int err,
char *description) char *description)
{ {
if (err != 0) { if (err != 0) {
shell_error(ctx_shell, "AICS description get failed (%d) for " shell_error(ctx_shell, "AICS description get failed (%d) for "
@ -184,32 +185,32 @@ static void micp_aics_description_cb(struct bt_aics *inst, int err,
inst, description); inst, description);
} }
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
static struct bt_micp_cb micp_cbs = { static struct bt_micp_mic_ctlr_cb micp_cbs = {
.discover = micp_discover_cb, .discover = micp_mic_ctlr_discover_cb,
.mute_write = micp_mute_write_cb, .mute_written = micp_mic_ctlr_mute_written_cb,
.unmute_write = micp_unmute_write_cb, .unmute_written = micp_mic_ctlr_unmute_written_cb,
.mute = micp_mute_cb, .mute = micp_mic_ctlr_mute_cb,
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
/* Audio Input Control Service */ /* Audio Input Control Service */
.aics_cb = { .aics_cb = {
.state = micp_aics_state_cb, .state = micp_mic_ctlr_aics_state_cb,
.gain_setting = micp_aics_gain_setting_cb, .gain_setting = micp_mic_ctlr_aics_gain_setting_cb,
.type = micp_aics_input_type_cb, .type = micp_mic_ctlr_aics_input_type_cb,
.status = micp_aics_status_cb, .status = micp_mic_ctlr_aics_status_cb,
.description = micp_aics_description_cb, .description = micp_mic_ctlr_aics_description_cb,
.set_gain = micp_aics_set_gain_cb, .set_gain = micp_mic_ctlr_aics_set_gain_cb,
.unmute = micp_aics_unmute_cb, .unmute = micp_mic_ctlr_aics_unmute_cb,
.mute = micp_aics_mute_cb, .mute = micp_mic_ctlr_aics_mute_cb,
.set_manual_mode = micp_aics_set_manual_mode_cb, .set_manual_mode = micp_mic_ctlr_aics_set_manual_mode_cb,
.set_auto_mode = micp_aics_automatic_mode_cb, .set_auto_mode = micp_mic_ctlr_aics_automatic_mode_cb,
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
}; };
static int cmd_micp_client_discover(const struct shell *sh, size_t argc, static int cmd_micp_mic_ctlr_discover(const struct shell *sh, size_t argc,
char **argv) char **argv)
{ {
int result; int result;
@ -218,7 +219,7 @@ static int cmd_micp_client_discover(const struct shell *sh, size_t argc,
ctx_shell = sh; ctx_shell = sh;
} }
result = bt_micp_client_cb_register(&micp_cbs); result = bt_micp_mic_ctlr_cb_register(&micp_cbs);
if (result != 0) { if (result != 0) {
shell_print(sh, "Failed to register callbacks: %d", result); shell_print(sh, "Failed to register callbacks: %d", result);
} }
@ -227,7 +228,7 @@ static int cmd_micp_client_discover(const struct shell *sh, size_t argc,
return -ENOTCONN; return -ENOTCONN;
} }
result = bt_micp_discover(default_conn, &micp); result = bt_micp_mic_ctlr_discover(default_conn, &micp);
if (result != 0) { if (result != 0) {
shell_print(sh, "Fail: %d", result); shell_print(sh, "Fail: %d", result);
} }
@ -235,7 +236,7 @@ static int cmd_micp_client_discover(const struct shell *sh, size_t argc,
return result; return result;
} }
static int cmd_micp_client_mute_get(const struct shell *sh, size_t argc, static int cmd_micp_mic_ctlr_mute_get(const struct shell *sh, size_t argc,
char **argv) char **argv)
{ {
int result; int result;
@ -244,7 +245,7 @@ static int cmd_micp_client_mute_get(const struct shell *sh, size_t argc,
return -ENOENT; return -ENOENT;
} }
result = bt_micp_mute_get(micp); result = bt_micp_mic_ctlr_mute_get(micp);
if (result != 0) { if (result != 0) {
shell_print(sh, "Fail: %d", result); shell_print(sh, "Fail: %d", result);
@ -253,7 +254,7 @@ static int cmd_micp_client_mute_get(const struct shell *sh, size_t argc,
return result; return result;
} }
static int cmd_micp_client_mute(const struct shell *sh, size_t argc, static int cmd_micp_mic_ctlr_mute(const struct shell *sh, size_t argc,
char **argv) char **argv)
{ {
int result; int result;
@ -262,7 +263,7 @@ static int cmd_micp_client_mute(const struct shell *sh, size_t argc,
return -ENOENT; return -ENOENT;
} }
result = bt_micp_mute(micp); result = bt_micp_mic_ctlr_mute(micp);
if (result != 0) { if (result != 0) {
shell_print(sh, "Fail: %d", result); shell_print(sh, "Fail: %d", result);
@ -271,7 +272,7 @@ static int cmd_micp_client_mute(const struct shell *sh, size_t argc,
return result; return result;
} }
static int cmd_micp_client_unmute(const struct shell *sh, size_t argc, static int cmd_micp_mic_ctlr_unmute(const struct shell *sh, size_t argc,
char **argv) char **argv)
{ {
int result; int result;
@ -280,7 +281,7 @@ static int cmd_micp_client_unmute(const struct shell *sh, size_t argc,
return -ENOENT; return -ENOENT;
} }
result = bt_micp_unmute(micp); result = bt_micp_mic_ctlr_unmute(micp);
if (result != 0) { if (result != 0) {
shell_print(sh, "Fail: %d", result); shell_print(sh, "Fail: %d", result);
@ -289,8 +290,8 @@ static int cmd_micp_client_unmute(const struct shell *sh, size_t argc,
return result; return result;
} }
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static int cmd_micp_client_aics_input_state_get(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_state_get(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -314,7 +315,7 @@ static int cmd_micp_client_aics_input_state_get(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_gain_setting_get(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_gain_setting_get(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -338,7 +339,7 @@ static int cmd_micp_client_aics_gain_setting_get(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_input_type_get(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_type_get(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -362,7 +363,7 @@ static int cmd_micp_client_aics_input_type_get(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_input_status_get(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_status_get(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -386,7 +387,7 @@ static int cmd_micp_client_aics_input_status_get(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_input_unmute(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_unmute(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -410,7 +411,7 @@ static int cmd_micp_client_aics_input_unmute(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_input_mute(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_mute(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -434,7 +435,7 @@ static int cmd_micp_client_aics_input_mute(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_manual_input_gain_set(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_manual_input_gain_set(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -458,7 +459,7 @@ static int cmd_micp_client_aics_manual_input_gain_set(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_automatic_input_gain_set(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_automatic_input_gain_set(const struct shell *sh,
size_t argc, size_t argc,
char **argv) char **argv)
{ {
@ -483,7 +484,7 @@ static int cmd_micp_client_aics_automatic_input_gain_set(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_gain_set(const struct shell *sh, size_t argc, static int cmd_micp_mic_ctlr_aics_gain_set(const struct shell *sh, size_t argc,
char **argv) char **argv)
{ {
int result; int result;
@ -514,7 +515,7 @@ static int cmd_micp_client_aics_gain_set(const struct shell *sh, size_t argc,
return result; return result;
} }
static int cmd_micp_client_aics_input_description_get(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_description_get(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -538,7 +539,7 @@ static int cmd_micp_client_aics_input_description_get(const struct shell *sh,
return result; return result;
} }
static int cmd_micp_client_aics_input_description_set(const struct shell *sh, static int cmd_micp_mic_ctlr_aics_input_description_set(const struct shell *sh,
size_t argc, char **argv) size_t argc, char **argv)
{ {
int result; int result;
@ -563,9 +564,9 @@ static int cmd_micp_client_aics_input_description_set(const struct shell *sh,
return result; return result;
} }
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
static int cmd_micp_client(const struct shell *sh, size_t argc, char **argv) static int cmd_micp_mic_ctlr(const struct shell *sh, size_t argc, char **argv)
{ {
if (argc > 1) { if (argc > 1) {
shell_error(sh, "%s unknown parameter: %s", shell_error(sh, "%s unknown parameter: %s",
@ -577,61 +578,61 @@ static int cmd_micp_client(const struct shell *sh, size_t argc, char **argv)
return -ENOEXEC; return -ENOEXEC;
} }
SHELL_STATIC_SUBCMD_SET_CREATE(micp_client_cmds, SHELL_STATIC_SUBCMD_SET_CREATE(micp_mic_ctlr_cmds,
SHELL_CMD_ARG(discover, NULL, SHELL_CMD_ARG(discover, NULL,
"Discover MICS on remote device", "Discover MICS on remote device",
cmd_micp_client_discover, 1, 0), cmd_micp_mic_ctlr_discover, 1, 0),
SHELL_CMD_ARG(mute_get, NULL, SHELL_CMD_ARG(mute_get, NULL,
"Read the mute state of the MICP server.", "Read the mute state of the MICP server.",
cmd_micp_client_mute_get, 1, 0), cmd_micp_mic_ctlr_mute_get, 1, 0),
SHELL_CMD_ARG(mute, NULL, SHELL_CMD_ARG(mute, NULL,
"Mute the MICP server", "Mute the MICP server",
cmd_micp_client_mute, 1, 0), cmd_micp_mic_ctlr_mute, 1, 0),
SHELL_CMD_ARG(unmute, NULL, SHELL_CMD_ARG(unmute, NULL,
"Unmute the MICP server", "Unmute the MICP server",
cmd_micp_client_unmute, 1, 0), cmd_micp_mic_ctlr_unmute, 1, 0),
#if defined(CONFIG_BT_MICP_CLIENT_AICS) #if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
SHELL_CMD_ARG(aics_input_state_get, NULL, SHELL_CMD_ARG(aics_input_state_get, NULL,
"Read the input state of a AICS instance <inst_index>", "Read the input state of a AICS instance <inst_index>",
cmd_micp_client_aics_input_state_get, 2, 0), cmd_micp_mic_ctlr_aics_input_state_get, 2, 0),
SHELL_CMD_ARG(aics_gain_setting_get, NULL, SHELL_CMD_ARG(aics_gain_setting_get, NULL,
"Read the gain settings of a AICS instance <inst_index>", "Read the gain settings of a AICS instance <inst_index>",
cmd_micp_client_aics_gain_setting_get, 2, 0), cmd_micp_mic_ctlr_aics_gain_setting_get, 2, 0),
SHELL_CMD_ARG(aics_input_type_get, NULL, SHELL_CMD_ARG(aics_input_type_get, NULL,
"Read the input type of a AICS instance <inst_index>", "Read the input type of a AICS instance <inst_index>",
cmd_micp_client_aics_input_type_get, 2, 0), cmd_micp_mic_ctlr_aics_input_type_get, 2, 0),
SHELL_CMD_ARG(aics_input_status_get, NULL, SHELL_CMD_ARG(aics_input_status_get, NULL,
"Read the input status of a AICS instance <inst_index>", "Read the input status of a AICS instance <inst_index>",
cmd_micp_client_aics_input_status_get, 2, 0), cmd_micp_mic_ctlr_aics_input_status_get, 2, 0),
SHELL_CMD_ARG(aics_input_unmute, NULL, SHELL_CMD_ARG(aics_input_unmute, NULL,
"Unmute the input of a AICS instance <inst_index>", "Unmute the input of a AICS instance <inst_index>",
cmd_micp_client_aics_input_unmute, 2, 0), cmd_micp_mic_ctlr_aics_input_unmute, 2, 0),
SHELL_CMD_ARG(aics_input_mute, NULL, SHELL_CMD_ARG(aics_input_mute, NULL,
"Mute the input of a AICS instance <inst_index>", "Mute the input of a AICS instance <inst_index>",
cmd_micp_client_aics_input_mute, 2, 0), cmd_micp_mic_ctlr_aics_input_mute, 2, 0),
SHELL_CMD_ARG(aics_manual_input_gain_set, NULL, SHELL_CMD_ARG(aics_manual_input_gain_set, NULL,
"Set the gain mode of a AICS instance to manual " "Set the gain mode of a AICS instance to manual "
"<inst_index>", "<inst_index>",
cmd_micp_client_aics_manual_input_gain_set, 2, 0), cmd_micp_mic_ctlr_aics_manual_input_gain_set, 2, 0),
SHELL_CMD_ARG(aics_automatic_input_gain_set, NULL, SHELL_CMD_ARG(aics_automatic_input_gain_set, NULL,
"Set the gain mode of a AICS instance to automatic " "Set the gain mode of a AICS instance to automatic "
"<inst_index>", "<inst_index>",
cmd_micp_client_aics_automatic_input_gain_set, 2, 0), cmd_micp_mic_ctlr_aics_automatic_input_gain_set, 2, 0),
SHELL_CMD_ARG(aics_gain_set, NULL, SHELL_CMD_ARG(aics_gain_set, NULL,
"Set the gain of a AICS instance <inst_index> <gain>", "Set the gain of a AICS instance <inst_index> <gain>",
cmd_micp_client_aics_gain_set, 3, 0), cmd_micp_mic_ctlr_aics_gain_set, 3, 0),
SHELL_CMD_ARG(aics_input_description_get, NULL, SHELL_CMD_ARG(aics_input_description_get, NULL,
"Read the input description of a AICS instance " "Read the input description of a AICS instance "
"<inst_index>", "<inst_index>",
cmd_micp_client_aics_input_description_get, 2, 0), cmd_micp_mic_ctlr_aics_input_description_get, 2, 0),
SHELL_CMD_ARG(aics_input_description_set, NULL, SHELL_CMD_ARG(aics_input_description_set, NULL,
"Set the input description of a AICS instance " "Set the input description of a AICS instance "
"<inst_index> <description>", "<inst_index> <description>",
cmd_micp_client_aics_input_description_set, 3, 0), cmd_micp_mic_ctlr_aics_input_description_set, 3, 0),
#endif /* CONFIG_BT_MICP_CLIENT_AICS */ #endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
SHELL_SUBCMD_SET_END SHELL_SUBCMD_SET_END
); );
SHELL_CMD_ARG_REGISTER(micp_client, &micp_client_cmds, SHELL_CMD_ARG_REGISTER(micp_mic_ctlr, &micp_mic_ctlr_cmds,
"Bluetooth MICP client shell commands", "Bluetooth MICP client shell commands",
cmd_micp_client, 1, 1); cmd_micp_mic_ctlr, 1, 1);

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

@ -49,8 +49,8 @@ CONFIG_BT_VCS_CLIENT_MAX_AICS_INST=2
CONFIG_BT_MICP=y CONFIG_BT_MICP=y
CONFIG_BT_MICP_AICS_INSTANCE_COUNT=2 CONFIG_BT_MICP_AICS_INSTANCE_COUNT=2
CONFIG_BT_MICP_CLIENT=y CONFIG_BT_MICP_MIC_CTLR=y
CONFIG_BT_MICP_CLIENT_MAX_AICS_INST=2 CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=2
# Coordinated Set Identification # Coordinated Set Identification
CONFIG_BT_CSIS=y CONFIG_BT_CSIS=y
@ -109,7 +109,7 @@ CONFIG_BT_DEBUG_AICS_CLIENT=y
CONFIG_BT_DEBUG_VOCS=y CONFIG_BT_DEBUG_VOCS=y
CONFIG_BT_DEBUG_VOCS_CLIENT=y CONFIG_BT_DEBUG_VOCS_CLIENT=y
CONFIG_BT_DEBUG_MICP=y CONFIG_BT_DEBUG_MICP=y
CONFIG_BT_DEBUG_MICP_CLIENT=y CONFIG_BT_DEBUG_MICP_MIC_CTLR=y
CONFIG_BT_DEBUG_MPL=y CONFIG_BT_DEBUG_MPL=y
CONFIG_BT_DEBUG_TBS=y CONFIG_BT_DEBUG_TBS=y
CONFIG_BT_DEBUG_TBS_CLIENT=y CONFIG_BT_DEBUG_TBS_CLIENT=y

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

@ -9,7 +9,7 @@
extern struct bst_test_list *test_vcs_install(struct bst_test_list *tests); 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_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_install(struct bst_test_list *tests);
extern struct bst_test_list *test_micp_client_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_csis_install(struct bst_test_list *tests); extern struct bst_test_list *test_csis_install(struct bst_test_list *tests);
extern struct bst_test_list *test_csis_client_install(struct bst_test_list *tests); extern struct bst_test_list *test_csis_client_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_install(struct bst_test_list *tests);
@ -31,7 +31,7 @@ bst_test_install_t test_installers[] = {
test_vcs_install, test_vcs_install,
test_vcs_client_install, test_vcs_client_install,
test_micp_install, test_micp_install,
test_micp_client_install, test_micp_mic_ctlr_install,
test_csis_install, test_csis_install,
test_csis_client_install, test_csis_client_install,
test_tbs_install, test_tbs_install,

52
tests/bluetooth/bsim_bt/bsim_test_audio/src/micp_mic_ctlr_test.c
View file

@ -4,15 +4,13 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
#ifdef CONFIG_BT_MICP_CLIENT #ifdef CONFIG_BT_MICP_MIC_CTLR
#include <zephyr/bluetooth/bluetooth.h> #include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/audio/micp.h> #include <zephyr/bluetooth/audio/micp.h>
#include "common.h" #include "common.h"
#define VOCS_DESC_SIZE 64
#define AICS_DESC_SIZE 64 #define AICS_DESC_SIZE 64
extern enum bst_result_t bst_result; extern enum bst_result_t bst_result;
@ -121,7 +119,8 @@ static void aics_write_cb(struct bt_aics *inst, int err)
g_write_complete = true; g_write_complete = true;
} }
static void micp_discover_cb(struct bt_micp *micp, int err, uint8_t aics_count) static void micp_mic_ctlr_discover_cb(struct bt_micp *micp, int err,
uint8_t aics_count)
{ {
if (err != 0) { if (err != 0) {
FAIL("MICP could not be discovered (%d)\n", err); FAIL("MICP could not be discovered (%d)\n", err);
@ -132,7 +131,7 @@ static void micp_discover_cb(struct bt_micp *micp, int err, uint8_t aics_count)
g_discovery_complete = true; g_discovery_complete = true;
} }
static void micp_mute_write_cb(struct bt_micp *micp, int err) static void micp_mic_ctlr_mute_written_cb(struct bt_micp *micp, int err)
{ {
if (err != 0) { if (err != 0) {
FAIL("MICP mute write failed (%d)\n", err); FAIL("MICP mute write failed (%d)\n", err);
@ -142,7 +141,7 @@ static void micp_mute_write_cb(struct bt_micp *micp, int err)
g_write_complete = true; g_write_complete = true;
} }
static void micp_unmute_write_cb(struct bt_micp *micp, int err) static void micp_mic_ctlr_unmute_written_cb(struct bt_micp *micp, int err)
{ {
if (err != 0) { if (err != 0) {
FAIL("MICP unmute write failed (%d)\n", err); FAIL("MICP unmute write failed (%d)\n", err);
@ -152,7 +151,7 @@ static void micp_unmute_write_cb(struct bt_micp *micp, int err)
g_write_complete = true; g_write_complete = true;
} }
static void micp_mute_cb(struct bt_micp *micp, int err, uint8_t mute) static void micp_mic_ctlr_mute_cb(struct bt_micp *micp, int err, uint8_t mute)
{ {
if (err != 0) { if (err != 0) {
FAIL("MICP mute read failed (%d)\n", err); FAIL("MICP mute read failed (%d)\n", err);
@ -163,11 +162,11 @@ static void micp_mute_cb(struct bt_micp *micp, int err, uint8_t mute)
g_cb = true; g_cb = true;
} }
static struct bt_micp_cb micp_cbs = { static struct bt_micp_mic_ctlr_cb micp_mic_ctlr_cbs = {
.discover = micp_discover_cb, .discover = micp_mic_ctlr_discover_cb,
.mute = micp_mute_cb, .mute = micp_mic_ctlr_mute_cb,
.mute_write = micp_mute_write_cb, .mute_written = micp_mic_ctlr_mute_written_cb,
.unmute_write = micp_unmute_write_cb, .unmute_written = micp_mic_ctlr_unmute_written_cb,
.aics_cb = { .aics_cb = {
.state = aics_state_cb, .state = aics_state_cb,
.gain_setting = aics_gain_setting_cb, .gain_setting = aics_gain_setting_cb,
@ -256,7 +255,7 @@ static int test_aics(void)
printk("AICS gain setting get\n"); printk("AICS gain setting get\n");
printk("Getting AICS input type\n"); printk("Getting AICS input type\n");
expected_input_type = BT_AICS_INPUT_TYPE_DIGITAL; expected_input_type = BT_AICS_INPUT_TYPE_UNSPECIFIED;
g_cb = false; g_cb = false;
err = bt_aics_type_get(micp_included.aics[0]); err = bt_aics_type_get(micp_included.aics[0]);
if (err != 0) { if (err != 0) {
@ -356,7 +355,8 @@ static int test_aics(void)
return err; return err;
} }
WAIT_FOR_COND(g_cb && WAIT_FOR_COND(g_cb &&
strncmp(expected_aics_desc, g_aics_desc, sizeof(expected_aics_desc) == 0)); (strncmp(expected_aics_desc, g_aics_desc,
sizeof(expected_aics_desc)) == 0));
printk("AICS Description set\n"); printk("AICS Description set\n");
printk("AICS passed\n"); printk("AICS passed\n");
@ -376,7 +376,7 @@ static void test_main(void)
return; return;
} }
bt_micp_client_cb_register(&micp_cbs); bt_micp_mic_ctlr_cb_register(&micp_mic_ctlr_cbs);
WAIT_FOR_COND(g_bt_init); WAIT_FOR_COND(g_bt_init);
@ -388,20 +388,20 @@ static void test_main(void)
printk("Scanning successfully started\n"); printk("Scanning successfully started\n");
WAIT_FOR_COND(g_is_connected); WAIT_FOR_COND(g_is_connected);
err = bt_micp_discover(default_conn, &micp); err = bt_micp_mic_ctlr_discover(default_conn, &micp);
if (err != 0) { if (err != 0) {
FAIL("Failed to discover MICP %d", err); FAIL("Failed to discover MICP %d", err);
} }
WAIT_FOR_COND(g_discovery_complete); WAIT_FOR_COND(g_discovery_complete);
err = bt_micp_included_get(micp, &micp_included); err = bt_micp_mic_ctlr_included_get(micp, &micp_included);
if (err != 0) { if (err != 0) {
FAIL("Failed to get MICP context (err %d)\n", err); FAIL("Failed to get MICP context (err %d)\n", err);
return; return;
} }
printk("Getting MICP client conn\n"); printk("Getting MICP client conn\n");
err = bt_micp_client_conn_get(micp, &cached_conn); err = bt_micp_mic_ctlr_conn_get(micp, &cached_conn);
if (err != 0) { if (err != 0) {
FAIL("Failed to get MICP client conn (err %d)\n", err); FAIL("Failed to get MICP client conn (err %d)\n", err);
return; return;
@ -413,7 +413,7 @@ static void test_main(void)
printk("Getting MICP mute state\n"); printk("Getting MICP mute state\n");
g_cb = false; g_cb = false;
err = bt_micp_mute_get(micp); err = bt_micp_mic_ctlr_mute_get(micp);
if (err != 0) { if (err != 0) {
FAIL("Could not get MICP mute state (err %d)\n", err); FAIL("Could not get MICP mute state (err %d)\n", err);
return; return;
@ -424,7 +424,7 @@ static void test_main(void)
printk("Muting MICP\n"); printk("Muting MICP\n");
expected_mute = 1; expected_mute = 1;
g_write_complete = g_cb = false; g_write_complete = g_cb = false;
err = bt_micp_mute(micp); err = bt_micp_mic_ctlr_mute(micp);
if (err != 0) { if (err != 0) {
FAIL("Could not mute MICP (err %d)\n", err); FAIL("Could not mute MICP (err %d)\n", err);
return; return;
@ -435,7 +435,7 @@ static void test_main(void)
printk("Unmuting MICP\n"); printk("Unmuting MICP\n");
expected_mute = 0; expected_mute = 0;
g_write_complete = g_cb = false; g_write_complete = g_cb = false;
err = bt_micp_unmute(micp); err = bt_micp_mic_ctlr_unmute(micp);
if (err != 0) { if (err != 0) {
FAIL("Could not unmute MICP (err %d)\n", err); FAIL("Could not unmute MICP (err %d)\n", err);
return; return;
@ -443,7 +443,7 @@ static void test_main(void)
WAIT_FOR_COND(g_mute == expected_mute && g_cb && g_write_complete); WAIT_FOR_COND(g_mute == expected_mute && g_cb && g_write_complete);
printk("MICP unmuted\n"); printk("MICP unmuted\n");
if (CONFIG_BT_MICP_CLIENT_MAX_AICS_INST > 0 && g_aics_count > 0) { if (CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST > 0 && g_aics_count > 0) {
if (test_aics()) { if (test_aics()) {
return; return;
} }
@ -454,7 +454,7 @@ static void test_main(void)
static const struct bst_test_instance test_micp[] = { static const struct bst_test_instance test_micp[] = {
{ {
.test_id = "micp_client", .test_id = "micp_mic_ctlr",
.test_post_init_f = test_init, .test_post_init_f = test_init,
.test_tick_f = test_tick, .test_tick_f = test_tick,
.test_main_f = test_main .test_main_f = test_main
@ -462,16 +462,16 @@ static const struct bst_test_instance test_micp[] = {
BSTEST_END_MARKER BSTEST_END_MARKER
}; };
struct bst_test_list *test_micp_client_install(struct bst_test_list *tests) struct bst_test_list *test_micp_mic_ctlr_install(struct bst_test_list *tests)
{ {
return bst_add_tests(tests, test_micp); return bst_add_tests(tests, test_micp);
} }
#else #else
struct bst_test_list *test_micp_client_install(struct bst_test_list *tests) struct bst_test_list *test_micp_mic_ctlr_install(struct bst_test_list *tests)
{ {
return tests; return tests;
} }
#endif /* CONFIG_BT_MICP_CLIENT */ #endif /* CONFIG_BT_MICP_MIC_CTLR */

4
tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/micp.sh
View file

@ -1,6 +1,6 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# #
# Copyright (c) 2020-2021 Nordic Semiconductor ASA # Copyright (c) 2020-2022 Nordic Semiconductor ASA
# #
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
@ -43,7 +43,7 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=0 -testid=micp -rs=23 -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=0 -testid=micp -rs=23
Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=micp_client -rs=46 -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=micp_mic_ctlr -rs=46
# Simulation time should be larger than the WAIT_TIME in common.h # Simulation time should be larger than the WAIT_TIME in common.h
Execute ./bs_2G4_phy_v1 -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} \ Execute ./bs_2G4_phy_v1 -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} \

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

@ -56,8 +56,8 @@ CONFIG_BT_VCS_CLIENT_MAX_AICS_INST=1
CONFIG_BT_MICP=y CONFIG_BT_MICP=y
CONFIG_BT_MICP_AICS_INSTANCE_COUNT=1 CONFIG_BT_MICP_AICS_INSTANCE_COUNT=1
CONFIG_BT_MICP_CLIENT=y CONFIG_BT_MICP_MIC_CTLR=y
CONFIG_BT_MICP_CLIENT_MAX_AICS_INST=1 CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=1
# Coordinated Set Identification # Coordinated Set Identification
CONFIG_BT_CSIS=y CONFIG_BT_CSIS=y

12
tests/bluetooth/shell/testcase.yaml
View file

@ -107,27 +107,27 @@ tests:
extra_configs: extra_configs:
- CONFIG_BT_MICP=n - CONFIG_BT_MICP=n
tags: bluetooth tags: bluetooth
bluetooth.shell.audio.no_micp_client: bluetooth.shell.audio.no_micp_mic_ctlr:
extra_args: CONF_FILE="audio.conf" extra_args: CONF_FILE="audio.conf"
build_only: true build_only: true
platform_allow: native_posix platform_allow: native_posix
extra_configs: extra_configs:
- CONFIG_BT_MICP_CLIENT=n - CONFIG_BT_MICP_MIC_CTLR=n
tags: bluetooth tags: bluetooth
bluetooth.shell.audio.no_micp_micp_client: bluetooth.shell.audio.no_micp_micp_mic_ctlr:
extra_args: CONF_FILE="audio.conf" extra_args: CONF_FILE="audio.conf"
build_only: true build_only: true
platform_allow: native_posix platform_allow: native_posix
extra_configs: extra_configs:
- CONFIG_BT_MICP=n - CONFIG_BT_MICP=n
- CONFIG_BT_MICP_CLIENT=n - CONFIG_BT_MICP_MIC_CTLR=n
tags: bluetooth tags: bluetooth
bluetooth.shell.audio.micp_client_no_aics_client: bluetooth.shell.audio.micp_mic_ctlr_no_aics_client:
extra_args: CONF_FILE="audio.conf" extra_args: CONF_FILE="audio.conf"
build_only: true build_only: true
platform_allow: native_posix platform_allow: native_posix
extra_configs: extra_configs:
- CONFIG_BT_MICP_CLIENT_MAX_AICS_INST=0 - CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=0
tags: bluetooth tags: bluetooth
bluetooth.shell.audio.no_mcs: bluetooth.shell.audio.no_mcs:
extra_args: CONF_FILE="audio.conf" extra_args: CONF_FILE="audio.conf"