michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Audio: Rename struct bt_micp and cleanup

Browse source 
Rename struct bt_micp to bt_mic_ctlr as it is only
used ofr microphone controller now.

This also allow cleanup of the bt_micp struct, thus
removing the common internal micp_internal.h header file
and reducing the size of the implementation by not
using a union of the structs.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2022-06-21 19:49:13 +02:00 • committed by Carles Cufí
commit 28f6e37ba8
6 changed files with 299 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -20,8 +20,6 @@
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/audio/micp.h>
#include "micp_internal.h"
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_MICP_MIC_CTLR)
#define LOG_MODULE_NAME bt_micp_mic_ctlr
#include "common/log.h"
@ -29,7 +27,25 @@
/* Callback functions */
static struct bt_micp_mic_ctlr_cb *micp_mic_ctlr_cb;
static struct bt_micp micp_insts[CONFIG_BT_MAX_CONN];
struct bt_micp_mic_ctlr {
uint16_t start_handle;
uint16_t end_handle;
uint16_t mute_handle;
struct bt_gatt_subscribe_params mute_sub_params;
struct bt_gatt_discover_params mute_sub_disc_params;
bool busy;
uint8_t mute_val_buf[1]; /* Mute value is a single octet */
struct bt_gatt_write_params write_params;
struct bt_gatt_read_params read_params;
struct bt_gatt_discover_params discover_params;
struct bt_conn *conn;
uint8_t aics_inst_cnt;
struct bt_aics *aics[CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST];
};
static struct bt_micp_mic_ctlr mic_ctlrs[CONFIG_BT_MAX_CONN];
static struct bt_uuid *mics_uuid = BT_UUID_MICS;
static uint8_t mute_notify_handler(struct bt_conn *conn,
@ -37,13 +53,13 @@ static uint8_t mute_notify_handler(struct bt_conn *conn,
const void *data, uint16_t length)
{
uint8_t *mute_val;
struct bt_micp *micp_inst;
struct bt_micp_mic_ctlr *mic_ctlr;
if (conn == NULL) {
return BT_GATT_ITER_CONTINUE;
}
micp_inst = &micp_insts[bt_conn_index(conn)];
mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
if (data != NULL) {
if (length == sizeof(*mute_val)) {
@ -51,7 +67,7 @@ static uint8_t mute_notify_handler(struct bt_conn *conn,
BT_DBG("Mute %u", *mute_val);
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->mute != NULL) {
micp_mic_ctlr_cb->mute(micp_inst, 0, *mute_val);
micp_mic_ctlr_cb->mute(mic_ctlr, 0, *mute_val);
}
} else {
BT_DBG("Invalid length %u (expected %zu)",
@ -69,9 +85,9 @@ static uint8_t micp_mic_ctlr_read_mute_cb(struct bt_conn *conn, uint8_t err,
{
uint8_t cb_err = err;
uint8_t mute_val = 0;
struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
micp_inst->cli.busy = false;
mic_ctlr->busy = false;
if (err > 0) {
BT_DBG("err: 0x%02X", err);
@ -87,7 +103,7 @@ static uint8_t micp_mic_ctlr_read_mute_cb(struct bt_conn *conn, uint8_t err,
}
if (micp_mic_ctlr_cb != NULL && micp_mic_ctlr_cb->mute != NULL) {
micp_mic_ctlr_cb->mute(micp_inst, cb_err, mute_val);
micp_mic_ctlr_cb->mute(mic_ctlr, cb_err, mute_val);
}
return BT_GATT_ITER_STOP;
@ -96,36 +112,36 @@ static uint8_t micp_mic_ctlr_read_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_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
uint8_t mute_val = micp_inst->cli.mute_val_buf[0];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
uint8_t mute_val = mic_ctlr->mute_val_buf[0];
BT_DBG("Write %s (0x%02X)", err ? "failed" : "successful", err);
micp_inst->cli.busy = false;
mic_ctlr->busy = false;
if (mute_val == BT_MICP_MUTE_UNMUTED) {
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->unmute_written != NULL) {
micp_mic_ctlr_cb->unmute_written(micp_inst, err);
micp_mic_ctlr_cb->unmute_written(mic_ctlr, err);
}
} else {
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->mute_written != NULL) {
micp_mic_ctlr_cb->mute_written(micp_inst, err);
micp_mic_ctlr_cb->mute_written(mic_ctlr, err);
}
}
}
#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_mic_ctlr *lookup_micp_by_aics(const struct bt_aics *aics)
{
__ASSERT(aics != NULL, "AICS pointer cannot be NULL");
for (int i = 0; i < ARRAY_SIZE(micp_insts); i++) {
for (int j = 0; j < ARRAY_SIZE(micp_insts[i].cli.aics); j++) {
if (micp_insts[i].cli.aics[j] == aics) {
return &micp_insts[i];
for (int i = 0; i < ARRAY_SIZE(mic_ctlrs); i++) {
for (int j = 0; j < ARRAY_SIZE(mic_ctlrs[i].aics); j++) {
if (mic_ctlrs[i].aics[j] == aics) {
return &mic_ctlrs[i];
}
}
}
@ -135,19 +151,19 @@ static struct bt_micp *lookup_micp_by_aics(const struct bt_aics *aics)
static void aics_discover_cb(struct bt_aics *inst, int err)
{
struct bt_micp *micp_inst = lookup_micp_by_aics(inst);
struct bt_micp_mic_ctlr *mic_ctlr = lookup_micp_by_aics(inst);
if (err == 0) {
/* Continue discovery of included services */
err = bt_gatt_discover(micp_inst->cli.conn,
&micp_inst->cli.discover_params);
err = bt_gatt_discover(mic_ctlr->conn,
&mic_ctlr->discover_params);
}
if (err != 0) {
BT_DBG("Discover failed (err %d)", err);
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, err, 0);
micp_mic_ctlr_cb->discover(mic_ctlr, err, 0);
}
}
}
@ -157,17 +173,17 @@ static uint8_t micp_discover_include_func(
struct bt_conn *conn, const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
if (attr == NULL) {
BT_DBG("Discover include complete for MICP: %u AICS",
micp_inst->cli.aics_inst_cnt);
BT_DBG("Discover include complete for MICS: %u AICS",
mic_ctlr->aics_inst_cnt);
(void)memset(params, 0, sizeof(*params));
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, 0,
micp_inst->cli.aics_inst_cnt);
micp_mic_ctlr_cb->discover(mic_ctlr, 0,
mic_ctlr->aics_inst_cnt);
}
return BT_GATT_ITER_STOP;
@ -181,7 +197,7 @@ static uint8_t micp_discover_include_func(
BT_DBG("Include UUID %s", bt_uuid_str(include->uuid));
if (bt_uuid_cmp(include->uuid, BT_UUID_AICS) == 0 &&
micp_inst->cli.aics_inst_cnt < CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST) {
mic_ctlr->aics_inst_cnt < CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST) {
uint8_t inst_idx;
int err;
struct bt_aics_discover_param param = {
@ -192,16 +208,16 @@ static uint8_t micp_discover_include_func(
/* Update discover params so we can continue where we
* left off after bt_aics_discover
*/
micp_inst->cli.discover_params.start_handle = attr->handle + 1;
mic_ctlr->discover_params.start_handle = attr->handle + 1;
inst_idx = micp_inst->cli.aics_inst_cnt++;
err = bt_aics_discover(conn, micp_inst->cli.aics[inst_idx],
inst_idx = mic_ctlr->aics_inst_cnt++;
err = bt_aics_discover(conn, mic_ctlr->aics[inst_idx],
&param);
if (err != 0) {
BT_DBG("AICS Discover failed (err %d)", err);
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, err,
micp_mic_ctlr_cb->discover(mic_ctlr, err,
0);
}
}
@ -221,33 +237,33 @@ static uint8_t micp_discover_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
if (attr == NULL) {
int err = 0;
BT_DBG("Setup complete for MICP");
BT_DBG("Discovery complete");
(void)memset(params, 0, sizeof(*params));
if (CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST > 0) {
/* Discover included services */
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.type = BT_GATT_DISCOVER_INCLUDE;
micp_inst->cli.discover_params.func = micp_discover_include_func;
mic_ctlr->discover_params.start_handle = mic_ctlr->start_handle;
mic_ctlr->discover_params.end_handle = mic_ctlr->end_handle;
mic_ctlr->discover_params.type = BT_GATT_DISCOVER_INCLUDE;
mic_ctlr->discover_params.func = micp_discover_include_func;
err = bt_gatt_discover(conn,
&micp_inst->cli.discover_params);
&mic_ctlr->discover_params);
if (err != 0) {
BT_DBG("Discover failed (err %d)", err);
BT_DBG("Discover AICS failed (err %d)", err);
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, err, 0);
micp_mic_ctlr_cb->discover(mic_ctlr, err, 0);
}
}
} else {
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, err, 0);
micp_mic_ctlr_cb->discover(mic_ctlr, err, 0);
}
}
return BT_GATT_ITER_STOP;
@ -261,9 +277,9 @@ static uint8_t micp_discover_func(struct bt_conn *conn,
if (bt_uuid_cmp(chrc->uuid, BT_UUID_MICS_MUTE) == 0) {
BT_DBG("Mute");
micp_inst->cli.mute_handle = chrc->value_handle;
sub_params = &micp_inst->cli.mute_sub_params;
sub_params->disc_params = &micp_inst->cli.mute_sub_disc_params;
mic_ctlr->mute_handle = chrc->value_handle;
sub_params = &mic_ctlr->mute_sub_params;
sub_params->disc_params = &mic_ctlr->mute_sub_disc_params;
}
if (sub_params != NULL) {
@ -271,7 +287,7 @@ static uint8_t micp_discover_func(struct bt_conn *conn,
/* With ccc_handle == 0 it will use auto discovery */
sub_params->ccc_handle = 0;
sub_params->end_handle = micp_inst->cli.end_handle;
sub_params->end_handle = mic_ctlr->end_handle;
sub_params->value = BT_GATT_CCC_NOTIFY;
sub_params->value_handle = chrc->value_handle;
sub_params->notify = mute_notify_handler;
@ -294,13 +310,13 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_micp *micp_inst = &micp_insts[bt_conn_index(conn)];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
if (attr == NULL) {
BT_DBG("Could not find a MICS instance on the server");
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, -ENODATA, 0);
micp_mic_ctlr_cb->discover(mic_ctlr, -ENODATA, 0);
}
return BT_GATT_ITER_STOP;
}
@ -313,22 +329,22 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
int err;
BT_DBG("Primary discover complete");
micp_inst->cli.start_handle = attr->handle + 1;
micp_inst->cli.end_handle = prim_service->end_handle;
mic_ctlr->start_handle = attr->handle + 1;
mic_ctlr->end_handle = prim_service->end_handle;
/* Discover characteristics */
micp_inst->cli.discover_params.uuid = NULL;
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.type = BT_GATT_DISCOVER_CHARACTERISTIC;
micp_inst->cli.discover_params.func = micp_discover_func;
mic_ctlr->discover_params.uuid = NULL;
mic_ctlr->discover_params.start_handle = mic_ctlr->start_handle;
mic_ctlr->discover_params.end_handle = mic_ctlr->end_handle;
mic_ctlr->discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
mic_ctlr->discover_params.func = micp_discover_func;
err = bt_gatt_discover(conn, &micp_inst->cli.discover_params);
err = bt_gatt_discover(conn, &mic_ctlr->discover_params);
if (err != 0) {
BT_DBG("Discover failed (err %d)", err);
if (micp_mic_ctlr_cb != NULL &&
micp_mic_ctlr_cb->discover != NULL) {
micp_mic_ctlr_cb->discover(micp_inst, err, 0);
micp_mic_ctlr_cb->discover(mic_ctlr, err, 0);
}
}
@ -338,15 +354,15 @@ static uint8_t primary_discover_func(struct bt_conn *conn,
return BT_GATT_ITER_CONTINUE;
}
static void micp_mic_ctlr_reset(struct bt_micp *micp)
static void micp_mic_ctlr_reset(struct bt_micp_mic_ctlr *mic_ctlr)
{
micp->cli.start_handle = 0;
micp->cli.end_handle = 0;
micp->cli.mute_handle = 0;
micp->cli.aics_inst_cnt = 0;
mic_ctlr->start_handle = 0;
mic_ctlr->end_handle = 0;
mic_ctlr->mute_handle = 0;
mic_ctlr->aics_inst_cnt = 0;
if (micp->cli.conn != NULL) {
struct bt_conn *conn = micp->cli.conn;
if (mic_ctlr->conn != NULL) {
struct bt_conn *conn = mic_ctlr->conn;
/* It's okay if this fails. In case of disconnect, we can't
* unsubscribe and it will just fail.
@ -354,19 +370,19 @@ static void micp_mic_ctlr_reset(struct bt_micp *micp)
* function, we will unsubscribe (regardless of bonding state)
* to accommodate the new discovery values.
*/
(void)bt_gatt_unsubscribe(conn, &micp->cli.mute_sub_params);
(void)bt_gatt_unsubscribe(conn, &mic_ctlr->mute_sub_params);
bt_conn_unref(conn);
micp->cli.conn = NULL;
mic_ctlr->conn = NULL;
}
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
struct bt_micp *micp = &micp_insts[bt_conn_index(conn)];
struct bt_micp_mic_ctlr *mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
if (micp->cli.conn == conn) {
micp_mic_ctlr_reset(micp);
if (mic_ctlr->conn == conn) {
micp_mic_ctlr_reset(mic_ctlr);
}
}
@ -374,9 +390,9 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
.disconnected = disconnected,
};
int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp **micp)
int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp_mic_ctlr **mic_ctlr_out)
{
struct bt_micp *micp_inst;
struct bt_micp_mic_ctlr *mic_ctlr;
int err;
/*
@ -394,24 +410,24 @@ int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp **micp)
return -EINVAL;
}
micp_inst = &micp_insts[bt_conn_index(conn)];
mic_ctlr = &mic_ctlrs[bt_conn_index(conn)];
(void)memset(&micp_inst->cli.discover_params, 0,
sizeof(micp_inst->cli.discover_params));
micp_mic_ctlr_reset(micp_inst);
(void)memset(&mic_ctlr->discover_params, 0,
sizeof(mic_ctlr->discover_params));
micp_mic_ctlr_reset(mic_ctlr);
#if defined(CONFIG_BT_MICP_MIC_CTLR_AICS)
static bool initialized;
if (!initialized) {
for (int i = 0; i < ARRAY_SIZE(micp_inst->cli.aics); i++) {
micp_inst->cli.aics[i] = bt_aics_client_free_instance_get();
for (int i = 0; i < ARRAY_SIZE(mic_ctlr->aics); i++) {
mic_ctlr->aics[i] = bt_aics_client_free_instance_get();
if (micp_inst->cli.aics[i] == NULL) {
if (mic_ctlr->aics[i] == NULL) {
return -ENOMEM;
}
bt_aics_client_cb_register(micp_inst->cli.aics[i],
bt_aics_client_cb_register(mic_ctlr->aics[i],
&micp_mic_ctlr_cb->aics_cb);
}
}
@ -419,17 +435,16 @@ int bt_micp_mic_ctlr_discover(struct bt_conn *conn, struct bt_micp **micp)
initialized = true;
#endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
micp_inst->cli.conn = bt_conn_ref(conn);
micp_inst->client_instance = true;
micp_inst->cli.discover_params.func = primary_discover_func;
micp_inst->cli.discover_params.uuid = mics_uuid;
micp_inst->cli.discover_params.type = BT_GATT_DISCOVER_PRIMARY;
micp_inst->cli.discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
micp_inst->cli.discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
mic_ctlr->conn = bt_conn_ref(conn);
mic_ctlr->discover_params.func = primary_discover_func;
mic_ctlr->discover_params.uuid = mics_uuid;
mic_ctlr->discover_params.type = BT_GATT_DISCOVER_PRIMARY;
mic_ctlr->discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
mic_ctlr->discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
err = bt_gatt_discover(conn, &micp_inst->cli.discover_params);
err = bt_gatt_discover(conn, &mic_ctlr->discover_params);
if (err == 0) {
*micp = micp_inst;
*mic_ctlr_out = mic_ctlr;
}
return err;
@ -450,9 +465,9 @@ int bt_micp_mic_ctlr_cb_register(struct bt_micp_mic_ctlr_cb *cb)
aics_cb = &cb->aics_cb;
}
for (int i = 0; i < ARRAY_SIZE(micp_insts); i++) {
for (int j = 0; j < ARRAY_SIZE(micp_insts[i].cli.aics); j++) {
struct bt_aics *aics = micp_insts[i].cli.aics[j];
for (int i = 0; i < ARRAY_SIZE(mic_ctlrs); i++) {
for (int j = 0; j < ARRAY_SIZE(mic_ctlrs[i].aics); j++) {
struct bt_aics *aics = mic_ctlrs[i].aics[j];
if (aics != NULL) {
bt_aics_client_cb_register(aics, aics_cb);
@ -466,11 +481,11 @@ int bt_micp_mic_ctlr_cb_register(struct bt_micp_mic_ctlr_cb *cb)
return 0;
}
int bt_micp_mic_ctlr_included_get(struct bt_micp *micp,
int bt_micp_mic_ctlr_included_get(struct bt_micp_mic_ctlr *mic_ctlr,
struct bt_micp_included *included)
{
CHECKIF(micp == NULL) {
BT_DBG("NULL micp");
CHECKIF(mic_ctlr == NULL) {
BT_DBG("NULL mic_ctlr");
return -EINVAL;
}
@ -478,100 +493,95 @@ int bt_micp_mic_ctlr_included_get(struct bt_micp *micp,
return -EINVAL;
}
included->aics_cnt = micp->cli.aics_inst_cnt;
included->aics = micp->cli.aics;
included->aics_cnt = mic_ctlr->aics_inst_cnt;
included->aics = mic_ctlr->aics;
return 0;
}
int bt_micp_mic_ctlr_conn_get(const struct bt_micp *micp, struct bt_conn **conn)
int bt_micp_mic_ctlr_conn_get(const struct bt_micp_mic_ctlr *mic_ctlr, struct bt_conn **conn)
{
CHECKIF(micp == NULL) {
BT_DBG("NULL micp pointer");
CHECKIF(mic_ctlr == NULL) {
BT_DBG("NULL mic_ctlr pointer");
return -EINVAL;
}
if (!micp->client_instance) {
BT_DBG("micp pointer shall be client instance");
return -EINVAL;
}
if (micp->cli.conn == NULL) {
BT_DBG("micp pointer not associated with a connection. "
if (mic_ctlr->conn == NULL) {
BT_DBG("mic_ctlr pointer not associated with a connection. "
"Do discovery first");
return -ENOTCONN;
}
*conn = micp->cli.conn;
*conn = mic_ctlr->conn;
return 0;
}
int bt_micp_mic_ctlr_mute_get(struct bt_micp *micp)
int bt_micp_mic_ctlr_mute_get(struct bt_micp_mic_ctlr *mic_ctlr)
{
int err;
CHECKIF(micp == NULL) {
BT_DBG("NULL micp");
CHECKIF(mic_ctlr == NULL) {
BT_DBG("NULL mic_ctlr");
return -EINVAL;
}
if (micp->cli.mute_handle == 0) {
if (mic_ctlr->mute_handle == 0) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (micp->cli.busy) {
} else if (mic_ctlr->busy) {
return -EBUSY;
}
micp->cli.read_params.func = micp_mic_ctlr_read_mute_cb;
micp->cli.read_params.handle_count = 1;
micp->cli.read_params.single.handle = micp->cli.mute_handle;
micp->cli.read_params.single.offset = 0U;
mic_ctlr->read_params.func = micp_mic_ctlr_read_mute_cb;
mic_ctlr->read_params.handle_count = 1;
mic_ctlr->read_params.single.handle = mic_ctlr->mute_handle;
mic_ctlr->read_params.single.offset = 0U;
err = bt_gatt_read(micp->cli.conn, &micp->cli.read_params);
err = bt_gatt_read(mic_ctlr->conn, &mic_ctlr->read_params);
if (err == 0) {
micp->cli.busy = true;
mic_ctlr->busy = true;
}
return err;
}
int bt_micp_mic_ctlr_write_mute(struct bt_micp *micp, bool mute)
int bt_micp_mic_ctlr_write_mute(struct bt_micp_mic_ctlr *mic_ctlr, bool mute)
{
int err;
CHECKIF(micp == NULL) {
BT_DBG("NULL micp");
CHECKIF(mic_ctlr == NULL) {
BT_DBG("NULL mic_ctlr");
return -EINVAL;
}
if (micp->cli.mute_handle == 0) {
if (mic_ctlr->mute_handle == 0) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (micp->cli.busy) {
} else if (mic_ctlr->busy) {
return -EBUSY;
}
micp->cli.mute_val_buf[0] = mute;
micp->cli.write_params.offset = 0;
micp->cli.write_params.data = micp->cli.mute_val_buf;
micp->cli.write_params.length = sizeof(mute);
micp->cli.write_params.handle = micp->cli.mute_handle;
micp->cli.write_params.func = micp_mic_ctlr_write_mics_mute_cb;
mic_ctlr->mute_val_buf[0] = mute;
mic_ctlr->write_params.offset = 0;
mic_ctlr->write_params.data = mic_ctlr->mute_val_buf;
mic_ctlr->write_params.length = sizeof(mute);
mic_ctlr->write_params.handle = mic_ctlr->mute_handle;
mic_ctlr->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(mic_ctlr->conn, &mic_ctlr->write_params);
if (err == 0) {
micp->cli.busy = true;
mic_ctlr->busy = true;
}
return err;
}
int bt_micp_mic_ctlr_mute(struct bt_micp *micp)
int bt_micp_mic_ctlr_mute(struct bt_micp_mic_ctlr *mic_ctlr)
{
return bt_micp_mic_ctlr_write_mute(micp, true);
return bt_micp_mic_ctlr_write_mute(mic_ctlr, true);
}
int bt_micp_mic_ctlr_unmute(struct bt_micp *micp)
int bt_micp_mic_ctlr_unmute(struct bt_micp_mic_ctlr *mic_ctlr)
{
return bt_micp_mic_ctlr_write_mute(micp, false);
return bt_micp_mic_ctlr_write_mute(mic_ctlr, false);
}