michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: audio: vocs: Refactor bt_vocs object

Browse source 
This adds refactor of bt_vocs object that is common interface for client
and server commands. As the bt_vocs_client is significantly larger than
bt_vocs_server the memory usage is not optimized when bt_vocs has an
union of those. Thus RAM consumption has been minimized by using
CONTAINER_OF macro to reference either to bt_vocs_client or
bt_vocs_server instance that bt_vocs is a member of.

Signed-off-by: Mariusz Skamra <mariusz.skamra@codecoup.pl>
This commit is contained in:
Mariusz Skamra 2023-07-27 10:59:02 +02:00 • committed by Fabio Baltieri
commit 76e17857e8
3 changed files with 324 additions and 292 deletions
Download patch file Download diff file Expand all files Collapse all files

192
subsys/bluetooth/audio/vocs.c
View file

@ -38,11 +38,11 @@ static void offset_state_cfg_changed(const struct bt_gatt_attr *attr, uint16_t v
static ssize_t read_offset_state(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t read_offset_state(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset) void *buf, uint16_t len, uint16_t offset)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
LOG_DBG("offset %d, counter %u", inst->srv.state.offset, inst->srv.state.change_counter); LOG_DBG("offset %d, counter %u", inst->state.offset, inst->state.change_counter);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->srv.state, return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->state,
sizeof(inst->srv.state)); sizeof(inst->state));
} }
static void location_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value) static void location_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value)
@ -55,14 +55,14 @@ static void location_cfg_changed(const struct bt_gatt_attr *attr, uint16_t value
static ssize_t write_location(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t write_location(struct bt_conn *conn, const struct bt_gatt_attr *attr,
const void *buf, uint16_t len, uint16_t offset, uint8_t flags) const void *buf, uint16_t len, uint16_t offset, uint8_t flags)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
enum bt_audio_location new_location; enum bt_audio_location new_location;
if (offset) { if (offset) {
return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET); return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
} }
if (len != sizeof(inst->srv.location)) { if (len != sizeof(inst->location)) {
return BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN); return BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} }
@ -74,15 +74,15 @@ static ssize_t write_location(struct bt_conn *conn, const struct bt_gatt_attr *a
return BT_GATT_ERR(BT_ATT_ERR_VALUE_NOT_ALLOWED); return BT_GATT_ERR(BT_ATT_ERR_VALUE_NOT_ALLOWED);
} }
if (new_location != inst->srv.location) { if (new_location != inst->location) {
inst->srv.location = new_location; inst->location = new_location;
(void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_LOCATION, (void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_LOCATION,
inst->srv.service_p->attrs, inst->service_p->attrs,
&inst->srv.location, &inst->location,
sizeof(inst->srv.location)); sizeof(inst->location));
if (inst->srv.cb && inst->srv.cb->location) { if (inst->cb && inst->cb->location) {
inst->srv.cb->location(inst, 0, inst->srv.location); inst->cb->location(&inst->vocs, 0, inst->location);
} }
} }
@ -93,18 +93,18 @@ static ssize_t write_location(struct bt_conn *conn, const struct bt_gatt_attr *a
static ssize_t read_location(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t read_location(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset) void *buf, uint16_t len, uint16_t offset)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
LOG_DBG("0x%08x", inst->srv.location); LOG_DBG("0x%08x", inst->location);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->srv.location, return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->location,
sizeof(inst->srv.location)); sizeof(inst->location));
} }
#endif /* CONFIG_BT_VOCS */ #endif /* CONFIG_BT_VOCS */
static ssize_t write_vocs_control(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t write_vocs_control(struct bt_conn *conn, const struct bt_gatt_attr *attr,
const void *buf, uint16_t len, uint16_t offset, uint8_t flags) const void *buf, uint16_t len, uint16_t offset, uint8_t flags)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
const struct bt_vocs_control *cp = buf; const struct bt_vocs_control *cp = buf;
bool notify = false; bool notify = false;
@ -129,7 +129,7 @@ static ssize_t write_vocs_control(struct bt_conn *conn, const struct bt_gatt_att
LOG_DBG("Opcode %u, counter %u", cp->opcode, cp->counter); LOG_DBG("Opcode %u, counter %u", cp->opcode, cp->counter);
if (cp->counter != inst->srv.state.change_counter) { if (cp->counter != inst->state.change_counter) {
return BT_GATT_ERR(BT_VOCS_ERR_INVALID_COUNTER); return BT_GATT_ERR(BT_VOCS_ERR_INVALID_COUNTER);
} }
@ -140,8 +140,8 @@ static ssize_t write_vocs_control(struct bt_conn *conn, const struct bt_gatt_att
return BT_GATT_ERR(BT_VOCS_ERR_OUT_OF_RANGE); return BT_GATT_ERR(BT_VOCS_ERR_OUT_OF_RANGE);
} }
if (inst->srv.state.offset != sys_le16_to_cpu(cp->offset)) { if (inst->state.offset != sys_le16_to_cpu(cp->offset)) {
inst->srv.state.offset = sys_le16_to_cpu(cp->offset); inst->state.offset = sys_le16_to_cpu(cp->offset);
notify = true; notify = true;
} }
break; break;
@ -150,15 +150,15 @@ static ssize_t write_vocs_control(struct bt_conn *conn, const struct bt_gatt_att
} }
if (notify) { if (notify) {
inst->srv.state.change_counter++; inst->state.change_counter++;
LOG_DBG("New state: offset %d, counter %u", inst->srv.state.offset, LOG_DBG("New state: offset %d, counter %u", inst->state.offset,
inst->srv.state.change_counter); inst->state.change_counter);
(void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_STATE, (void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_STATE,
inst->srv.service_p->attrs, inst->service_p->attrs,
&inst->srv.state, sizeof(inst->srv.state)); &inst->state, sizeof(inst->state));
if (inst->srv.cb && inst->srv.cb->state) { if (inst->cb && inst->cb->state) {
inst->srv.cb->state(inst, 0, inst->srv.state.offset); inst->cb->state(&inst->vocs, 0, inst->state.offset);
} }
} }
@ -176,39 +176,39 @@ static void output_desc_cfg_changed(const struct bt_gatt_attr *attr, uint16_t va
static ssize_t write_output_desc(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t write_output_desc(struct bt_conn *conn, const struct bt_gatt_attr *attr,
const void *buf, uint16_t len, uint16_t offset, uint8_t flags) const void *buf, uint16_t len, uint16_t offset, uint8_t flags)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
if (offset) { if (offset) {
return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET); return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);
} }
if (len >= sizeof(inst->srv.output_desc)) { if (len >= sizeof(inst->output_desc)) {
LOG_DBG("Output desc was clipped from length %u to %zu", len, LOG_DBG("Output desc was clipped from length %u to %zu", len,
sizeof(inst->srv.output_desc) - 1); sizeof(inst->output_desc) - 1);
/* We just clip the string value if it's too long */ /* We just clip the string value if it's too long */
len = (uint16_t)sizeof(inst->srv.output_desc) - 1; len = (uint16_t)sizeof(inst->output_desc) - 1;
} }
if (len != strlen(inst->srv.output_desc) || memcmp(buf, inst->srv.output_desc, len)) { if (len != strlen(inst->output_desc) || memcmp(buf, inst->output_desc, len)) {
memcpy(inst->srv.output_desc, buf, len); memcpy(inst->output_desc, buf, len);
inst->srv.output_desc[len] = '\0'; inst->output_desc[len] = '\0';
(void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_DESCRIPTION, (void)bt_gatt_notify_uuid(NULL, BT_UUID_VOCS_DESCRIPTION,
inst->srv.service_p->attrs, inst->service_p->attrs,
&inst->srv.output_desc, &inst->output_desc,
strlen(inst->srv.output_desc)); strlen(inst->output_desc));
if (inst->srv.cb && inst->srv.cb->description) { if (inst->cb && inst->cb->description) {
inst->srv.cb->description(inst, 0, inst->srv.output_desc); inst->cb->description(&inst->vocs, 0, inst->output_desc);
} }
} }
LOG_DBG("%s", inst->srv.output_desc); LOG_DBG("%s", inst->output_desc);
return len; return len;
} }
static int vocs_write(struct bt_vocs *inst, static int vocs_write(struct bt_vocs_server *inst,
ssize_t (*write)(struct bt_conn *conn, ssize_t (*write)(struct bt_conn *conn,
const struct bt_gatt_attr *attr, const struct bt_gatt_attr *attr,
const void *buf, uint16_t len, const void *buf, uint16_t len,
@ -235,11 +235,11 @@ static int vocs_write(struct bt_vocs *inst,
static ssize_t read_output_desc(struct bt_conn *conn, const struct bt_gatt_attr *attr, static ssize_t read_output_desc(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset) void *buf, uint16_t len, uint16_t offset)
{ {
struct bt_vocs *inst = BT_AUDIO_CHRC_USER_DATA(attr); struct bt_vocs_server *inst = BT_AUDIO_CHRC_USER_DATA(attr);
LOG_DBG("%s", inst->srv.output_desc); LOG_DBG("%s", inst->output_desc);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->srv.output_desc, return bt_gatt_attr_read(conn, attr, buf, len, offset, &inst->output_desc,
strlen(inst->srv.output_desc)); strlen(inst->output_desc));
} }
#define BT_VOCS_SERVICE_DEFINITION(_vocs) { \ #define BT_VOCS_SERVICE_DEFINITION(_vocs) { \
@ -265,7 +265,7 @@ static ssize_t read_output_desc(struct bt_conn *conn, const struct bt_gatt_attr
BT_AUDIO_CCC(output_desc_cfg_changed) \ BT_AUDIO_CCC(output_desc_cfg_changed) \
} }
static struct bt_vocs vocs_insts[CONFIG_BT_VOCS_MAX_INSTANCE_COUNT]; static struct bt_vocs_server vocs_insts[CONFIG_BT_VOCS_MAX_INSTANCE_COUNT];
BT_GATT_SERVICE_INSTANCE_DEFINE(vocs_service_list, vocs_insts, CONFIG_BT_VOCS_MAX_INSTANCE_COUNT, BT_GATT_SERVICE_INSTANCE_DEFINE(vocs_service_list, vocs_insts, CONFIG_BT_VOCS_MAX_INSTANCE_COUNT,
BT_VOCS_SERVICE_DEFINITION); BT_VOCS_SERVICE_DEFINITION);
@ -277,11 +277,13 @@ struct bt_vocs *bt_vocs_free_instance_get(void)
return NULL; return NULL;
} }
return &vocs_insts[instance_cnt++]; return &vocs_insts[instance_cnt++].vocs;
} }
void *bt_vocs_svc_decl_get(struct bt_vocs *vocs) void *bt_vocs_svc_decl_get(struct bt_vocs *vocs)
{ {
struct bt_vocs_server *inst;
CHECKIF(!vocs) { CHECKIF(!vocs) {
LOG_DBG("Null VOCS pointer"); LOG_DBG("Null VOCS pointer");
return NULL; return NULL;
@ -292,19 +294,22 @@ void *bt_vocs_svc_decl_get(struct bt_vocs *vocs)
return NULL; return NULL;
} }
return vocs->srv.service_p->attrs; inst = CONTAINER_OF(vocs, struct bt_vocs_server, vocs);
return inst->service_p->attrs;
} }
static void prepare_vocs_instances(void) static void prepare_vocs_instances(void)
{ {
for (int i = 0; i < ARRAY_SIZE(vocs_insts); i++) { for (int i = 0; i < ARRAY_SIZE(vocs_insts); i++) {
vocs_insts[i].srv.service_p = &vocs_service_list[i]; vocs_insts[i].service_p = &vocs_service_list[i];
} }
} }
int bt_vocs_register(struct bt_vocs *vocs, int bt_vocs_register(struct bt_vocs *vocs,
const struct bt_vocs_register_param *param) const struct bt_vocs_register_param *param)
{ {
struct bt_vocs_server *inst;
int err; int err;
struct bt_gatt_attr *attr; struct bt_gatt_attr *attr;
struct bt_gatt_chrc *chrc; struct bt_gatt_chrc *chrc;
@ -320,6 +325,8 @@ int bt_vocs_register(struct bt_vocs *vocs,
return -EINVAL; return -EINVAL;
} }
inst = CONTAINER_OF(vocs, struct bt_vocs_server, vocs);
CHECKIF(!param) { CHECKIF(!param) {
LOG_DBG("NULL params pointer"); LOG_DBG("NULL params pointer");
return -EINVAL; return -EINVAL;
@ -330,7 +337,7 @@ int bt_vocs_register(struct bt_vocs *vocs,
instances_prepared = true; instances_prepared = true;
} }
CHECKIF(vocs->srv.initialized) { CHECKIF(inst->initialized) {
LOG_DBG("Already initialized VOCS instance"); LOG_DBG("Already initialized VOCS instance");
return -EALREADY; return -EALREADY;
} }
@ -340,18 +347,18 @@ int bt_vocs_register(struct bt_vocs *vocs,
return -EINVAL; return -EINVAL;
} }
vocs->srv.location = param->location; inst->location = param->location;
vocs->srv.state.offset = param->offset; inst->state.offset = param->offset;
vocs->srv.cb = param->cb; inst->cb = param->cb;
if (param->output_desc) { if (param->output_desc) {
strncpy(vocs->srv.output_desc, param->output_desc, strncpy(inst->output_desc, param->output_desc,
sizeof(vocs->srv.output_desc) - 1); sizeof(inst->output_desc) - 1);
/* strncpy may not always null-terminate */ /* strncpy may not always null-terminate */
vocs->srv.output_desc[sizeof(vocs->srv.output_desc) - 1] = '\0'; inst->output_desc[sizeof(inst->output_desc) - 1] = '\0';
if (IS_ENABLED(CONFIG_BT_VOCS_LOG_LEVEL_DBG) && if (IS_ENABLED(CONFIG_BT_VOCS_LOG_LEVEL_DBG) &&
strcmp(vocs->srv.output_desc, param->output_desc)) { strcmp(inst->output_desc, param->output_desc)) {
LOG_DBG("Output desc clipped to %s", vocs->srv.output_desc); LOG_DBG("Output desc clipped to %s", inst->output_desc);
} }
} }
@ -361,30 +368,30 @@ int bt_vocs_register(struct bt_vocs *vocs,
* also update the characteristic declaration (always found at [i - 1]) with the * also update the characteristic declaration (always found at [i - 1]) with the
* BT_GATT_CHRC_WRITE_WITHOUT_RESP property. * BT_GATT_CHRC_WRITE_WITHOUT_RESP property.
*/ */
for (int i = 1; i < vocs->srv.service_p->attr_count; i++) { for (int i = 1; i < inst->service_p->attr_count; i++) {
attr = &vocs->srv.service_p->attrs[i]; attr = &inst->service_p->attrs[i];
if (param->location_writable && !bt_uuid_cmp(attr->uuid, BT_UUID_VOCS_LOCATION)) { if (param->location_writable && !bt_uuid_cmp(attr->uuid, BT_UUID_VOCS_LOCATION)) {
/* Update attr and chrc to be writable */ /* Update attr and chrc to be writable */
chrc = vocs->srv.service_p->attrs[i - 1].user_data; chrc = inst->service_p->attrs[i - 1].user_data;
attr->perm |= BT_GATT_PERM_WRITE_ENCRYPT; attr->perm |= BT_GATT_PERM_WRITE_ENCRYPT;
chrc->properties |= BT_GATT_CHRC_WRITE_WITHOUT_RESP; chrc->properties |= BT_GATT_CHRC_WRITE_WITHOUT_RESP;
} else if (param->desc_writable && } else if (param->desc_writable &&
!bt_uuid_cmp(attr->uuid, BT_UUID_VOCS_DESCRIPTION)) { !bt_uuid_cmp(attr->uuid, BT_UUID_VOCS_DESCRIPTION)) {
/* Update attr and chrc to be writable */ /* Update attr and chrc to be writable */
chrc = vocs->srv.service_p->attrs[i - 1].user_data; chrc = inst->service_p->attrs[i - 1].user_data;
attr->perm |= BT_GATT_PERM_WRITE_ENCRYPT; attr->perm |= BT_GATT_PERM_WRITE_ENCRYPT;
chrc->properties |= BT_GATT_CHRC_WRITE_WITHOUT_RESP; chrc->properties |= BT_GATT_CHRC_WRITE_WITHOUT_RESP;
} }
} }
err = bt_gatt_service_register(vocs->srv.service_p); err = bt_gatt_service_register(inst->service_p);
if (err) { if (err) {
LOG_DBG("Could not register VOCS service"); LOG_DBG("Could not register VOCS service");
return err; return err;
} }
vocs->srv.initialized = true; inst->initialized = true;
return 0; return 0;
} }
#endif /* CONFIG_BT_VOCS */ #endif /* CONFIG_BT_VOCS */
@ -397,10 +404,14 @@ int bt_vocs_state_get(struct bt_vocs *inst)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_state_get(inst); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_state_get(cli);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
if (inst->srv.cb && inst->srv.cb->state) { struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
inst->srv.cb->state(inst, 0, inst->srv.state.offset);
if (srv->cb && srv->cb->state) {
srv->cb->state(inst, 0, srv->state.offset);
} }
return 0; return 0;
} }
@ -416,10 +427,14 @@ int bt_vocs_location_get(struct bt_vocs *inst)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_location_get(inst); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_location_get(cli);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
if (inst->srv.cb && inst->srv.cb->location) { struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
inst->srv.cb->location(inst, 0, inst->srv.location);
if (srv->cb && srv->cb->location) {
srv->cb->location(inst, 0, srv->location);
} }
return 0; return 0;
} }
@ -435,9 +450,13 @@ int bt_vocs_location_set(struct bt_vocs *inst, uint32_t location)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_location_set(inst, location); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_location_set(cli, location);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
return vocs_write(inst, write_location, &location, sizeof(location)); struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
return vocs_write(srv, write_location, &location, sizeof(location));
} }
return -ENOTSUP; return -ENOTSUP;
@ -451,15 +470,18 @@ int bt_vocs_state_set(struct bt_vocs *inst, int16_t offset)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_state_set(inst, offset); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_state_set(cli, offset);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
struct bt_vocs_control cp; struct bt_vocs_control cp;
cp.opcode = BT_VOCS_OPCODE_SET_OFFSET; cp.opcode = BT_VOCS_OPCODE_SET_OFFSET;
cp.counter = inst->srv.state.change_counter; cp.counter = srv->state.change_counter;
cp.offset = sys_cpu_to_le16(offset); cp.offset = sys_cpu_to_le16(offset);
return vocs_write(inst, write_vocs_control, &cp, sizeof(cp)); return vocs_write(srv, write_vocs_control, &cp, sizeof(cp));
} }
return -ENOTSUP; return -ENOTSUP;
@ -473,10 +495,14 @@ int bt_vocs_description_get(struct bt_vocs *inst)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_description_get(inst); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_description_get(cli);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
if (inst->srv.cb && inst->srv.cb->description) { struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
inst->srv.cb->description(inst, 0, inst->srv.output_desc);
if (srv->cb && srv->cb->description) {
srv->cb->description(inst, 0, srv->output_desc);
} }
return 0; return 0;
} }
@ -497,9 +523,13 @@ int bt_vocs_description_set(struct bt_vocs *inst, const char *description)
} }
if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) { if (IS_ENABLED(CONFIG_BT_VOCS_CLIENT) && inst->client_instance) {
return bt_vocs_client_description_set(inst, description); struct bt_vocs_client *cli = CONTAINER_OF(inst, struct bt_vocs_client, vocs);
return bt_vocs_client_description_set(cli, description);
} else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) { } else if (IS_ENABLED(CONFIG_BT_VOCS) && !inst->client_instance) {
return vocs_write(inst, write_output_desc, description, strlen(description)); struct bt_vocs_server *srv = CONTAINER_OF(inst, struct bt_vocs_server, vocs);
return vocs_write(srv, write_output_desc, description, strlen(description));
} }
return -ENOTSUP; return -ENOTSUP;

397
subsys/bluetooth/audio/vocs_client.c
View file

@ -26,19 +26,19 @@
LOG_MODULE_REGISTER(bt_vocs_client, CONFIG_BT_VOCS_CLIENT_LOG_LEVEL); LOG_MODULE_REGISTER(bt_vocs_client, CONFIG_BT_VOCS_CLIENT_LOG_LEVEL);
static struct bt_vocs vocs_insts[CONFIG_BT_MAX_CONN * CONFIG_BT_VOCS_CLIENT_MAX_INSTANCE_COUNT]; static struct bt_vocs_client insts[CONFIG_BT_MAX_CONN * CONFIG_BT_VOCS_CLIENT_MAX_INSTANCE_COUNT];
static struct bt_vocs *lookup_vocs_by_handle(struct bt_conn *conn, uint16_t handle) static struct bt_vocs_client *lookup_vocs_by_handle(struct bt_conn *conn, uint16_t handle)
{ {
__ASSERT(handle != 0, "Handle cannot be 0"); __ASSERT(handle != 0, "Handle cannot be 0");
__ASSERT(conn, "Conn cannot be NULL"); __ASSERT(conn, "Conn cannot be NULL");
for (int i = 0; i < ARRAY_SIZE(vocs_insts); i++) { for (int i = 0; i < ARRAY_SIZE(insts); i++) {
if (vocs_insts[i].cli.conn == conn && if (insts[i].conn == conn &&
vocs_insts[i].cli.active && insts[i].active &&
vocs_insts[i].cli.start_handle <= handle && insts[i].start_handle <= handle &&
vocs_insts[i].cli.end_handle >= handle) { insts[i].end_handle >= handle) {
return &vocs_insts[i]; return &insts[i];
} }
} }
@ -50,7 +50,7 @@ uint8_t vocs_client_notify_handler(struct bt_conn *conn, struct bt_gatt_subscrib
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
uint16_t handle = params->value_handle; uint16_t handle = params->value_handle;
struct bt_vocs *inst; struct bt_vocs_client *inst;
if (conn == NULL) { if (conn == NULL) {
return BT_GATT_ITER_CONTINUE; return BT_GATT_ITER_CONTINUE;
@ -67,18 +67,18 @@ uint8_t vocs_client_notify_handler(struct bt_conn *conn, struct bt_gatt_subscrib
return BT_GATT_ITER_CONTINUE; return BT_GATT_ITER_CONTINUE;
} }
if (handle == inst->cli.state_handle) { if (handle == inst->state_handle) {
if (length == sizeof(inst->cli.state)) { if (length == sizeof(inst->state)) {
memcpy(&inst->cli.state, data, length); memcpy(&inst->state, data, length);
LOG_DBG("Inst %p: Offset %d, counter %u", inst, inst->cli.state.offset, LOG_DBG("Inst %p: Offset %d, counter %u", inst, inst->state.offset,
inst->cli.state.change_counter); inst->state.change_counter);
if (inst->cli.cb && inst->cli.cb->state) { if (inst->cb && inst->cb->state) {
inst->cli.cb->state(inst, 0, inst->cli.state.offset); inst->cb->state(&inst->vocs, 0, inst->state.offset);
} }
} else { } else {
LOG_DBG("Invalid state length %u", length); LOG_DBG("Invalid state length %u", length);
} }
} else if (handle == inst->cli.desc_handle) { } else if (handle == inst->desc_handle) {
char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1]; char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1];
/* Truncate if too large */ /* Truncate if too large */
@ -92,15 +92,15 @@ uint8_t vocs_client_notify_handler(struct bt_conn *conn, struct bt_gatt_subscrib
memcpy(desc, data, length); memcpy(desc, data, length);
desc[length] = '\0'; desc[length] = '\0';
LOG_DBG("Inst %p: Output description: %s", inst, desc); LOG_DBG("Inst %p: Output description: %s", inst, desc);
if (inst->cli.cb && inst->cli.cb->description) { if (inst->cb && inst->cb->description) {
inst->cli.cb->description(inst, 0, desc); inst->cb->description(&inst->vocs, 0, desc);
} }
} else if (handle == inst->cli.location_handle) { } else if (handle == inst->location_handle) {
if (length == sizeof(inst->cli.location)) { if (length == sizeof(inst->location)) {
memcpy(&inst->cli.location, data, length); memcpy(&inst->location, data, length);
LOG_DBG("Inst %p: Location %u", inst, inst->cli.location); LOG_DBG("Inst %p: Location %u", inst, inst->location);
if (inst->cli.cb && inst->cli.cb->location) { if (inst->cb && inst->cb->location) {
inst->cli.cb->location(inst, 0, inst->cli.location); inst->cb->location(&inst->vocs, 0, inst->location);
} }
} else { } else {
LOG_DBG("Invalid location length %u", length); LOG_DBG("Invalid location length %u", length);
@ -115,7 +115,7 @@ static uint8_t vocs_client_read_offset_state_cb(struct bt_conn *conn, uint8_t er
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
int cb_err = err; int cb_err = err;
struct bt_vocs *inst = lookup_vocs_by_handle(conn, params->single.handle); struct bt_vocs_client *inst = lookup_vocs_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params)); memset(params, 0, sizeof(*params));
@ -125,18 +125,18 @@ static uint8_t vocs_client_read_offset_state_cb(struct bt_conn *conn, uint8_t er
} }
LOG_DBG("Inst %p: err: 0x%02X", inst, err); LOG_DBG("Inst %p: err: 0x%02X", inst, err);
inst->cli.busy = false; inst->busy = false;
if (cb_err) { if (cb_err) {
LOG_DBG("Offset state read failed: %d", err); LOG_DBG("Offset state read failed: %d", err);
} else if (data) { } else if (data) {
if (length == sizeof(inst->cli.state)) { if (length == sizeof(inst->state)) {
memcpy(&inst->cli.state, data, length); memcpy(&inst->state, data, length);
LOG_DBG("Offset %d, counter %u", inst->cli.state.offset, LOG_DBG("Offset %d, counter %u", inst->state.offset,
inst->cli.state.change_counter); inst->state.change_counter);
} else { } else {
LOG_DBG("Invalid length %u (expected %zu)", length, LOG_DBG("Invalid length %u (expected %zu)", length,
sizeof(inst->cli.state)); sizeof(inst->state));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN; cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
} }
} else { } else {
@ -144,9 +144,8 @@ static uint8_t vocs_client_read_offset_state_cb(struct bt_conn *conn, uint8_t er
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} }
if (inst->cli.cb && inst->cli.cb->state) { if (inst->cb && inst->cb->state) {
inst->cli.cb->state(inst, cb_err, inst->cb->state(&inst->vocs, cb_err, cb_err ? 0 : inst->state.offset);
cb_err ? 0 : inst->cli.state.offset);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
@ -157,7 +156,7 @@ static uint8_t vocs_client_read_location_cb(struct bt_conn *conn, uint8_t err,
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
int cb_err = err; int cb_err = err;
struct bt_vocs *inst = lookup_vocs_by_handle(conn, params->single.handle); struct bt_vocs_client *inst = lookup_vocs_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params)); memset(params, 0, sizeof(*params));
@ -167,17 +166,17 @@ static uint8_t vocs_client_read_location_cb(struct bt_conn *conn, uint8_t err,
} }
LOG_DBG("Inst %p: err: 0x%02X", inst, err); LOG_DBG("Inst %p: err: 0x%02X", inst, err);
inst->cli.busy = false; inst->busy = false;
if (cb_err) { if (cb_err) {
LOG_DBG("Offset state read failed: %d", err); LOG_DBG("Offset state read failed: %d", err);
} else if (data) { } else if (data) {
if (length == sizeof(inst->cli.location)) { if (length == sizeof(inst->location)) {
memcpy(&inst->cli.location, data, length); memcpy(&inst->location, data, length);
LOG_DBG("Location %u", inst->cli.location); LOG_DBG("Location %u", inst->location);
} else { } else {
LOG_DBG("Invalid length %u (expected %zu)", length, LOG_DBG("Invalid length %u (expected %zu)", length,
sizeof(inst->cli.location)); sizeof(inst->location));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN; cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
} }
} else { } else {
@ -185,9 +184,8 @@ static uint8_t vocs_client_read_location_cb(struct bt_conn *conn, uint8_t err,
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} }
if (inst->cli.cb && inst->cli.cb->location) { if (inst->cb && inst->cb->location) {
inst->cli.cb->location(inst, cb_err, inst->cb->location(&inst->vocs, cb_err, cb_err ? 0 : inst->location);
cb_err ? 0 : inst->cli.location);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
@ -198,7 +196,7 @@ static uint8_t internal_read_volume_offset_state_cb(struct bt_conn *conn, uint8_
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
int cb_err = err; int cb_err = err;
struct bt_vocs *inst = lookup_vocs_by_handle(conn, params->single.handle); struct bt_vocs_client *inst = lookup_vocs_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params)); memset(params, 0, sizeof(*params));
@ -211,22 +209,22 @@ static uint8_t internal_read_volume_offset_state_cb(struct bt_conn *conn, uint8_
LOG_WRN("Volume offset state read failed: %d", err); LOG_WRN("Volume offset state read failed: %d", err);
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} else if (data) { } else if (data) {
if (length == sizeof(inst->cli.state)) { if (length == sizeof(inst->state)) {
int write_err; int write_err;
memcpy(&inst->cli.state, data, length); memcpy(&inst->state, data, length);
LOG_DBG("Offset %d, counter %u", inst->cli.state.offset, LOG_DBG("Offset %d, counter %u", inst->state.offset,
inst->cli.state.change_counter); inst->state.change_counter);
/* clear busy flag to reuse function */ /* clear busy flag to reuse function */
inst->cli.busy = false; inst->busy = false;
write_err = bt_vocs_client_state_set(inst, inst->cli.cp.offset); write_err = bt_vocs_client_state_set(inst, inst->cp.offset);
if (write_err) { if (write_err) {
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} }
} else { } else {
LOG_DBG("Invalid length %u (expected %zu)", length, LOG_DBG("Invalid length %u (expected %zu)", length,
sizeof(inst->cli.state)); sizeof(inst->state));
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} }
} else { } else {
@ -235,10 +233,10 @@ static uint8_t internal_read_volume_offset_state_cb(struct bt_conn *conn, uint8_
} }
if (cb_err) { if (cb_err) {
inst->cli.busy = false; inst->busy = false;
if (inst->cli.cb && inst->cli.cb->set_offset) { if (inst->cb && inst->cb->set_offset) {
inst->cli.cb->set_offset(inst, err); inst->cb->set_offset(&inst->vocs, err);
} }
} }
@ -249,7 +247,7 @@ static void vocs_client_write_vocs_cp_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params) struct bt_gatt_write_params *params)
{ {
int cb_err = err; int cb_err = err;
struct bt_vocs *inst = lookup_vocs_by_handle(conn, params->handle); struct bt_vocs_client *inst = lookup_vocs_by_handle(conn, params->handle);
memset(params, 0, sizeof(*params)); memset(params, 0, sizeof(*params));
@ -265,30 +263,30 @@ static void vocs_client_write_vocs_cp_cb(struct bt_conn *conn, uint8_t err,
* change counter has been read, we restart the applications write request. If it fails * change counter has been read, we restart the applications write request. If it fails
* the second time, we return an error to the application. * the second time, we return an error to the application.
*/ */
if (cb_err == BT_VOCS_ERR_INVALID_COUNTER && inst->cli.cp_retried) { if (cb_err == BT_VOCS_ERR_INVALID_COUNTER && inst->cp_retried) {
cb_err = BT_ATT_ERR_UNLIKELY; cb_err = BT_ATT_ERR_UNLIKELY;
} else if (cb_err == BT_VOCS_ERR_INVALID_COUNTER && inst->cli.state_handle) { } else if (cb_err == BT_VOCS_ERR_INVALID_COUNTER && inst->state_handle) {
LOG_DBG("Invalid change counter. Reading volume offset state from server."); LOG_DBG("Invalid change counter. Reading volume offset state from server.");
inst->cli.read_params.func = internal_read_volume_offset_state_cb; inst->read_params.func = internal_read_volume_offset_state_cb;
inst->cli.read_params.handle_count = 1; inst->read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.state_handle; inst->read_params.single.handle = inst->state_handle;
cb_err = bt_gatt_read(conn, &inst->cli.read_params); cb_err = bt_gatt_read(conn, &inst->read_params);
if (cb_err) { if (cb_err) {
LOG_WRN("Could not read Volume offset state: %d", cb_err); LOG_WRN("Could not read Volume offset state: %d", cb_err);
} else { } else {
inst->cli.cp_retried = true; inst->cp_retried = true;
/* Wait for read callback */ /* Wait for read callback */
return; return;
} }
} }
inst->cli.busy = false; inst->busy = false;
inst->cli.cp_retried = false; inst->cp_retried = false;
if (inst->cli.cb && inst->cli.cb->set_offset) { if (inst->cb && inst->cb->set_offset) {
inst->cli.cb->set_offset(inst, cb_err); inst->cb->set_offset(&inst->vocs, cb_err);
} }
} }
@ -297,7 +295,7 @@ static uint8_t vocs_client_read_output_desc_cb(struct bt_conn *conn, uint8_t err
const void *data, uint16_t length) const void *data, uint16_t length)
{ {
int cb_err = err; int cb_err = err;
struct bt_vocs *inst = lookup_vocs_by_handle(conn, params->single.handle); struct bt_vocs_client *inst = lookup_vocs_by_handle(conn, params->single.handle);
char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1]; char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1];
memset(params, 0, sizeof(*params)); memset(params, 0, sizeof(*params));
@ -308,7 +306,7 @@ static uint8_t vocs_client_read_output_desc_cb(struct bt_conn *conn, uint8_t err
} }
LOG_DBG("Inst %p: err: 0x%02X", inst, err); LOG_DBG("Inst %p: err: 0x%02X", inst, err);
inst->cli.busy = false; inst->busy = false;
if (cb_err) { if (cb_err) {
LOG_DBG("Description read failed: %d", err); LOG_DBG("Description read failed: %d", err);
@ -329,38 +327,35 @@ static uint8_t vocs_client_read_output_desc_cb(struct bt_conn *conn, uint8_t err
LOG_DBG("Output description: %s", desc); LOG_DBG("Output description: %s", desc);
} }
if (inst->cli.cb && inst->cli.cb->description) { if (inst->cb && inst->cb->description) {
inst->cli.cb->description(inst, cb_err, cb_err ? NULL : desc); inst->cb->description(&inst->vocs, cb_err, cb_err ? NULL : desc);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
} }
static bool valid_inst_discovered(struct bt_vocs *inst) static bool valid_inst_discovered(struct bt_vocs_client *inst)
{ {
return inst->cli.state_handle && return inst->state_handle &&
inst->cli.control_handle && inst->control_handle &&
inst->cli.location_handle && inst->location_handle &&
inst->cli.desc_handle; inst->desc_handle;
} }
static uint8_t vocs_discover_func(struct bt_conn *conn, const struct bt_gatt_attr *attr, static uint8_t vocs_discover_func(struct bt_conn *conn, const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params) struct bt_gatt_discover_params *params)
{ {
struct bt_vocs_client *client_inst = CONTAINER_OF(params, struct bt_vocs_client *inst = CONTAINER_OF(params, struct bt_vocs_client, discover_params);
struct bt_vocs_client,
discover_params);
struct bt_vocs *inst = CONTAINER_OF(client_inst, struct bt_vocs, cli);
if (!attr) { if (!attr) {
LOG_DBG("Discovery complete for VOCS %p", inst); LOG_DBG("Discovery complete for VOCS %p", inst);
inst->cli.busy = false; inst->busy = false;
(void)memset(params, 0, sizeof(*params)); (void)memset(params, 0, sizeof(*params));
if (inst->cli.cb && inst->cli.cb->discover) { if (inst->cb && inst->cb->discover) {
int err = valid_inst_discovered(inst) ? 0 : -ENOENT; int err = valid_inst_discovered(inst) ? 0 : -ENOENT;
inst->cli.cb->discover(inst, err); inst->cb->discover(&inst->vocs, err);
} }
return BT_GATT_ITER_STOP; return BT_GATT_ITER_STOP;
@ -373,35 +368,35 @@ static uint8_t vocs_discover_func(struct bt_conn *conn, const struct bt_gatt_att
struct bt_gatt_chrc *chrc; struct bt_gatt_chrc *chrc;
chrc = (struct bt_gatt_chrc *)attr->user_data; chrc = (struct bt_gatt_chrc *)attr->user_data;
if (inst->cli.start_handle == 0) { if (inst->start_handle == 0) {
inst->cli.start_handle = chrc->value_handle; inst->start_handle = chrc->value_handle;
} }
inst->cli.end_handle = chrc->value_handle; inst->end_handle = chrc->value_handle;
if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_STATE)) { if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_STATE)) {
LOG_DBG("Volume offset state"); LOG_DBG("Volume offset state");
inst->cli.state_handle = chrc->value_handle; inst->state_handle = chrc->value_handle;
sub_params = &inst->cli.state_sub_params; sub_params = &inst->state_sub_params;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_LOCATION)) { } else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_LOCATION)) {
LOG_DBG("Location"); LOG_DBG("Location");
inst->cli.location_handle = chrc->value_handle; inst->location_handle = chrc->value_handle;
if (chrc->properties & BT_GATT_CHRC_NOTIFY) { if (chrc->properties & BT_GATT_CHRC_NOTIFY) {
sub_params = &inst->cli.location_sub_params; sub_params = &inst->location_sub_params;
} }
if (chrc->properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP) { if (chrc->properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP) {
inst->cli.location_writable = true; inst->location_writable = true;
} }
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_CONTROL)) { } else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_CONTROL)) {
LOG_DBG("Control point"); LOG_DBG("Control point");
inst->cli.control_handle = chrc->value_handle; inst->control_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_DESCRIPTION)) { } else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_VOCS_DESCRIPTION)) {
LOG_DBG("Description"); LOG_DBG("Description");
inst->cli.desc_handle = chrc->value_handle; inst->desc_handle = chrc->value_handle;
if (chrc->properties & BT_GATT_CHRC_NOTIFY) { if (chrc->properties & BT_GATT_CHRC_NOTIFY) {
sub_params = &inst->cli.desc_sub_params; sub_params = &inst->desc_sub_params;
} }
if (chrc->properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP) { if (chrc->properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP) {
inst->cli.desc_writable = true; inst->desc_writable = true;
} }
} }
@ -426,7 +421,7 @@ static uint8_t vocs_discover_func(struct bt_conn *conn, const struct bt_gatt_att
return BT_GATT_ITER_CONTINUE; return BT_GATT_ITER_CONTINUE;
} }
int bt_vocs_client_state_get(struct bt_vocs *inst) int bt_vocs_client_state_get(struct bt_vocs_client *inst)
{ {
int err; int err;
@ -435,43 +430,42 @@ int bt_vocs_client_state_get(struct bt_vocs *inst)
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.state_handle) { if (!inst->state_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} }
if (inst->cli.busy) { if (inst->busy) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EBUSY; return -EBUSY;
} }
inst->cli.read_params.func = vocs_client_read_offset_state_cb; inst->read_params.func = vocs_client_read_offset_state_cb;
inst->cli.read_params.handle_count = 1; inst->read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.state_handle; inst->read_params.single.handle = inst->state_handle;
inst->cli.read_params.single.offset = 0U; inst->read_params.single.offset = 0U;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params); err = bt_gatt_read(inst->conn, &inst->read_params);
if (!err) { if (!err) {
inst->cli.busy = true; inst->busy = true;
} }
return err; return err;
} }
int bt_vocs_client_location_set(struct bt_vocs *inst, uint32_t location) int bt_vocs_client_location_set(struct bt_vocs_client *inst, uint32_t location)
{ {
CHECKIF(!inst) { CHECKIF(!inst) {
LOG_DBG("NULL instance"); LOG_DBG("NULL instance");
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
@ -481,23 +475,23 @@ int bt_vocs_client_location_set(struct bt_vocs *inst, uint32_t location)
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.location_handle) { if (!inst->location_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} else if (inst->cli.busy) { } else if (inst->busy) {
return -EBUSY; return -EBUSY;
} else if (!inst->cli.location_writable) { } else if (!inst->location_writable) {
LOG_DBG("Location is not writable on peer service instance"); LOG_DBG("Location is not writable on peer service instance");
return -EPERM; return -EPERM;
} }
return bt_gatt_write_without_response(inst->cli.conn, return bt_gatt_write_without_response(inst->conn,
inst->cli.location_handle, inst->location_handle,
&location, sizeof(location), &location, sizeof(location),
false); false);
} }
int bt_vocs_client_location_get(struct bt_vocs *inst) int bt_vocs_client_location_get(struct bt_vocs_client *inst)
{ {
int err; int err;
@ -506,32 +500,32 @@ int bt_vocs_client_location_get(struct bt_vocs *inst)
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.location_handle) { if (!inst->location_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} else if (inst->cli.busy) { } else if (inst->busy) {
return -EBUSY; return -EBUSY;
} }
inst->cli.read_params.func = vocs_client_read_location_cb; inst->read_params.func = vocs_client_read_location_cb;
inst->cli.read_params.handle_count = 1; inst->read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.location_handle; inst->read_params.single.handle = inst->location_handle;
inst->cli.read_params.single.offset = 0U; inst->read_params.single.offset = 0U;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params); err = bt_gatt_read(inst->conn, &inst->read_params);
if (!err) { if (!err) {
inst->cli.busy = true; inst->busy = true;
} }
return err; return err;
} }
int bt_vocs_client_state_set(struct bt_vocs *inst, int16_t offset) int bt_vocs_client_state_set(struct bt_vocs_client *inst, int16_t offset)
{ {
int err; int err;
@ -540,7 +534,7 @@ int bt_vocs_client_state_set(struct bt_vocs *inst, int16_t offset)
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
@ -550,32 +544,32 @@ int bt_vocs_client_state_set(struct bt_vocs *inst, int16_t offset)
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.control_handle) { if (!inst->control_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} else if (inst->cli.busy) { } else if (inst->busy) {
return -EBUSY; return -EBUSY;
} }
inst->cli.cp.opcode = BT_VOCS_OPCODE_SET_OFFSET; inst->cp.opcode = BT_VOCS_OPCODE_SET_OFFSET;
inst->cli.cp.counter = inst->cli.state.change_counter; inst->cp.counter = inst->state.change_counter;
inst->cli.cp.offset = offset; inst->cp.offset = offset;
inst->cli.write_params.offset = 0; inst->write_params.offset = 0;
inst->cli.write_params.data = &inst->cli.cp; inst->write_params.data = &inst->cp;
inst->cli.write_params.length = sizeof(inst->cli.cp); inst->write_params.length = sizeof(inst->cp);
inst->cli.write_params.handle = inst->cli.control_handle; inst->write_params.handle = inst->control_handle;
inst->cli.write_params.func = vocs_client_write_vocs_cp_cb; inst->write_params.func = vocs_client_write_vocs_cp_cb;
err = bt_gatt_write(inst->cli.conn, &inst->cli.write_params); err = bt_gatt_write(inst->conn, &inst->write_params);
if (!err) { if (!err) {
inst->cli.busy = true; inst->busy = true;
} }
return err; return err;
} }
int bt_vocs_client_description_get(struct bt_vocs *inst) int bt_vocs_client_description_get(struct bt_vocs_client *inst)
{ {
int err; int err;
@ -584,32 +578,32 @@ int bt_vocs_client_description_get(struct bt_vocs *inst)
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.desc_handle) { if (!inst->desc_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} else if (inst->cli.busy) { } else if (inst->busy) {
return -EBUSY; return -EBUSY;
} }
inst->cli.read_params.func = vocs_client_read_output_desc_cb; inst->read_params.func = vocs_client_read_output_desc_cb;
inst->cli.read_params.handle_count = 1; inst->read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.desc_handle; inst->read_params.single.handle = inst->desc_handle;
inst->cli.read_params.single.offset = 0U; inst->read_params.single.offset = 0U;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params); err = bt_gatt_read(inst->conn, &inst->read_params);
if (!err) { if (!err) {
inst->cli.busy = true; inst->busy = true;
} }
return err; return err;
} }
int bt_vocs_client_description_set(struct bt_vocs *inst, int bt_vocs_client_description_set(struct bt_vocs_client *inst,
const char *description) const char *description)
{ {
CHECKIF(!inst) { CHECKIF(!inst) {
@ -617,34 +611,34 @@ int bt_vocs_client_description_set(struct bt_vocs *inst,
return -EINVAL; return -EINVAL;
} }
CHECKIF(inst->cli.conn == NULL) { CHECKIF(inst->conn == NULL) {
LOG_DBG("NULL conn"); LOG_DBG("NULL conn");
return -EINVAL; return -EINVAL;
} }
if (!inst->cli.desc_handle) { if (!inst->desc_handle) {
LOG_DBG("Handle not set"); LOG_DBG("Handle not set");
return -EINVAL; return -EINVAL;
} else if (inst->cli.busy) { } else if (inst->busy) {
return -EBUSY; return -EBUSY;
} else if (!inst->cli.desc_writable) { } else if (!inst->desc_writable) {
LOG_DBG("Description is not writable on peer service instance"); LOG_DBG("Description is not writable on peer service instance");
return -EPERM; return -EPERM;
} }
return bt_gatt_write_without_response(inst->cli.conn, return bt_gatt_write_without_response(inst->conn,
inst->cli.desc_handle, inst->desc_handle,
description, description,
strlen(description), false); strlen(description), false);
} }
struct bt_vocs *bt_vocs_client_free_instance_get(void) struct bt_vocs *bt_vocs_client_free_instance_get(void)
{ {
for (int i = 0; i < ARRAY_SIZE(vocs_insts); i++) { for (int i = 0; i < ARRAY_SIZE(insts); i++) {
if (!vocs_insts[i].cli.active) { if (!insts[i].active) {
vocs_insts[i].client_instance = true; insts[i].vocs.client_instance = true;
vocs_insts[i].cli.active = true; insts[i].active = true;
return &vocs_insts[i]; return &insts[i].vocs;
} }
} }
@ -653,41 +647,45 @@ struct bt_vocs *bt_vocs_client_free_instance_get(void)
int bt_vocs_client_conn_get(const struct bt_vocs *vocs, struct bt_conn **conn) int bt_vocs_client_conn_get(const struct bt_vocs *vocs, struct bt_conn **conn)
{ {
struct bt_vocs_client *inst;
CHECKIF(vocs == NULL) { CHECKIF(vocs == NULL) {
LOG_DBG("NULL vocs pointer"); LOG_DBG("NULL vocs pointer");
return -EINVAL; return -EINVAL;
} }
if (!vocs->client_instance) { CHECKIF(!vocs->client_instance) {
LOG_DBG("vocs pointer shall be client instance"); LOG_DBG("vocs pointer shall be client instance");
return -EINVAL; return -EINVAL;
} }
if (vocs->cli.conn == NULL) { inst = CONTAINER_OF(vocs, struct bt_vocs_client, vocs);
if (inst->conn == NULL) {
LOG_DBG("vocs pointer not associated with a connection. " LOG_DBG("vocs pointer not associated with a connection. "
"Do discovery first"); "Do discovery first");
return -ENOTCONN; return -ENOTCONN;
} }
*conn = vocs->cli.conn; *conn = inst->conn;
return 0; return 0;
} }
static void vocs_client_reset(struct bt_vocs *inst) static void vocs_client_reset(struct bt_vocs_client *inst)
{ {
memset(&inst->cli.state, 0, sizeof(inst->cli.state)); memset(&inst->state, 0, sizeof(inst->state));
inst->cli.location_writable = 0; inst->location_writable = 0;
inst->cli.location = 0; inst->location = 0;
inst->cli.desc_writable = 0; inst->desc_writable = 0;
inst->cli.start_handle = 0; inst->start_handle = 0;
inst->cli.end_handle = 0; inst->end_handle = 0;
inst->cli.state_handle = 0; inst->state_handle = 0;
inst->cli.location_handle = 0; inst->location_handle = 0;
inst->cli.control_handle = 0; inst->control_handle = 0;
inst->cli.desc_handle = 0; inst->desc_handle = 0;
if (inst->cli.conn != NULL) { if (inst->conn != NULL) {
struct bt_conn *conn = inst->cli.conn; struct bt_conn *conn = inst->conn;
/* It's okay if these fail. In case of disconnect, we can't /* It's okay if these fail. In case of disconnect, we can't
* unsubscribe and they will just fail. * unsubscribe and they will just fail.
@ -695,28 +693,29 @@ static void vocs_client_reset(struct bt_vocs *inst)
* function, we will unsubscribe (regardless of bonding state) * function, we will unsubscribe (regardless of bonding state)
* to accommodate the new discovery values. * to accommodate the new discovery values.
*/ */
(void)bt_gatt_unsubscribe(conn, &inst->cli.state_sub_params); (void)bt_gatt_unsubscribe(conn, &inst->state_sub_params);
(void)bt_gatt_unsubscribe(conn, &inst->cli.location_sub_params); (void)bt_gatt_unsubscribe(conn, &inst->location_sub_params);
(void)bt_gatt_unsubscribe(conn, &inst->cli.desc_sub_params); (void)bt_gatt_unsubscribe(conn, &inst->desc_sub_params);
bt_conn_unref(conn); bt_conn_unref(conn);
inst->cli.conn = NULL; inst->conn = NULL;
} }
} }
int bt_vocs_discover(struct bt_conn *conn, struct bt_vocs *inst, int bt_vocs_discover(struct bt_conn *conn, struct bt_vocs *vocs,
const struct bt_vocs_discover_param *param) const struct bt_vocs_discover_param *param)
{ {
struct bt_vocs_client *inst;
int err = 0; int err = 0;
CHECKIF(!inst || !conn || !param) { CHECKIF(!vocs || !conn || !param) {
LOG_DBG("%s cannot be NULL", inst == NULL ? "inst" LOG_DBG("%s cannot be NULL", vocs == NULL ? "vocs"
: conn == NULL ? "conn" : conn == NULL ? "conn"
: "param"); : "param");
return -EINVAL; return -EINVAL;
} }
CHECKIF(!inst->client_instance) { CHECKIF(!vocs->client_instance) {
LOG_DBG("vocs pointer shall be client instance"); LOG_DBG("vocs pointer shall be client instance");
return -EINVAL; return -EINVAL;
} }
@ -727,45 +726,51 @@ int bt_vocs_discover(struct bt_conn *conn, struct bt_vocs *inst,
return -EINVAL; return -EINVAL;
} }
CHECKIF(!inst->cli.active) { inst = CONTAINER_OF(vocs, struct bt_vocs_client, vocs);
CHECKIF(!inst->active) {
LOG_DBG("Inactive instance"); LOG_DBG("Inactive instance");
return -EINVAL; return -EINVAL;
} }
if (inst->cli.busy) { if (inst->busy) {
LOG_DBG("Instance is busy"); LOG_DBG("Instance is busy");
return -EBUSY; return -EBUSY;
} }
vocs_client_reset(inst); vocs_client_reset(inst);
inst->cli.conn = bt_conn_ref(conn); inst->conn = bt_conn_ref(conn);
inst->cli.discover_params.start_handle = param->start_handle; inst->discover_params.start_handle = param->start_handle;
inst->cli.discover_params.end_handle = param->end_handle; inst->discover_params.end_handle = param->end_handle;
inst->cli.discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC; inst->discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
inst->cli.discover_params.func = vocs_discover_func; inst->discover_params.func = vocs_discover_func;
err = bt_gatt_discover(conn, &inst->cli.discover_params); err = bt_gatt_discover(conn, &inst->discover_params);
if (err) { if (err) {
LOG_DBG("Discover failed (err %d)", err); LOG_DBG("Discover failed (err %d)", err);
} else { } else {
inst->cli.busy = true; inst->busy = true;
} }
return err; return err;
} }
void bt_vocs_client_cb_register(struct bt_vocs *inst, struct bt_vocs_cb *cb) void bt_vocs_client_cb_register(struct bt_vocs *vocs, struct bt_vocs_cb *cb)
{ {
CHECKIF(!inst) { struct bt_vocs_client *inst;
CHECKIF(!vocs) {
LOG_DBG("inst cannot be NULL"); LOG_DBG("inst cannot be NULL");
return; return;
} }
CHECKIF(!inst->client_instance) { CHECKIF(!vocs->client_instance) {
LOG_DBG("vocs pointer shall be client instance"); LOG_DBG("vocs pointer shall be client instance");
return; return;
} }
inst->cli.cb = cb; inst = CONTAINER_OF(vocs, struct bt_vocs_client, vocs);
inst->cb = cb;
} }

27
subsys/bluetooth/audio/vocs_internal.h
View file

@ -30,7 +30,12 @@ struct bt_vocs_state {
uint8_t change_counter; uint8_t change_counter;
} __packed; } __packed;
struct bt_vocs {
bool client_instance;
};
struct bt_vocs_client { struct bt_vocs_client {
struct bt_vocs vocs;
struct bt_vocs_state state; struct bt_vocs_state state;
bool location_writable; bool location_writable;
uint32_t location; uint32_t location;
@ -58,6 +63,7 @@ struct bt_vocs_client {
}; };
struct bt_vocs_server { struct bt_vocs_server {
struct bt_vocs vocs;
struct bt_vocs_state state; struct bt_vocs_state state;
uint32_t location; uint32_t location;
bool initialized; bool initialized;
@ -67,20 +73,11 @@ struct bt_vocs_server {
struct bt_gatt_service *service_p; struct bt_gatt_service *service_p;
}; };
struct bt_vocs { int bt_vocs_client_state_get(struct bt_vocs_client *inst);
bool client_instance; int bt_vocs_client_state_set(struct bt_vocs_client *inst, int16_t offset);
union { int bt_vocs_client_location_get(struct bt_vocs_client *inst);
struct bt_vocs_server srv; int bt_vocs_client_location_set(struct bt_vocs_client *inst, uint32_t location);
struct bt_vocs_client cli; int bt_vocs_client_description_get(struct bt_vocs_client *inst);
}; int bt_vocs_client_description_set(struct bt_vocs_client *inst, const char *description);
};
int bt_vocs_client_state_get(struct bt_vocs *inst);
int bt_vocs_client_state_set(struct bt_vocs *inst, int16_t offset);
int bt_vocs_client_location_get(struct bt_vocs *inst);
int bt_vocs_client_location_set(struct bt_vocs *inst, uint32_t location);
int bt_vocs_client_description_get(struct bt_vocs *inst);
int bt_vocs_client_description_set(struct bt_vocs *inst,
const char *description);
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_VOCS_INTERNAL_ */ #endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_VOCS_INTERNAL_ */