OrgZephyr/zephyr
OrgZephyr
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr.git
1
0
Fork 0
Code Issues Releases Wiki Activity
zephyr/subsys/bluetooth/audio/aics_client.c

1067 lines
27 KiB
C
Raw Blame History

/* Bluetooth AICS client */
/*
* Copyright (c) 2020 Bose Corporation
* Copyright (c) 2020 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/audio/aics.h>
#include <zephyr/bluetooth/att.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/l2cap.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/sys/check.h>
#include <zephyr/sys/util.h>
#include <zephyr/types.h>
#include "aics_internal.h"
LOG_MODULE_REGISTER(bt_aics_client, CONFIG_BT_AICS_CLIENT_LOG_LEVEL);
static struct bt_aics aics_insts[CONFIG_BT_MAX_CONN * CONFIG_BT_AICS_CLIENT_MAX_INSTANCE_COUNT];
static int aics_client_common_control(uint8_t opcode, struct bt_aics *inst);
static struct bt_aics *lookup_aics_by_handle(struct bt_conn *conn, uint16_t handle)
{
for (int i = 0; i < ARRAY_SIZE(aics_insts); i++) {
if (aics_insts[i].cli.conn == conn &&
atomic_test_bit(aics_insts[i].cli.flags, BT_AICS_CLIENT_FLAG_ACTIVE) &&
aics_insts[i].cli.start_handle <= handle &&
aics_insts[i].cli.end_handle >= handle) {
return &aics_insts[i];
}
}
LOG_DBG("Could not find AICS instance with handle 0x%04x", handle);
return NULL;
}
uint8_t aics_client_notify_handler(struct bt_conn *conn, struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length)
{
uint16_t handle = params->value_handle;
struct bt_aics *inst;
struct bt_aics_state *state;
uint8_t *status;
if (conn == NULL) {
return BT_GATT_ITER_CONTINUE;
}
inst = lookup_aics_by_handle(conn, handle);
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
if (!data || !length) {
return BT_GATT_ITER_CONTINUE;
}
if (handle == inst->cli.state_handle) {
if (length == sizeof(*state)) {
state = (struct bt_aics_state *)data;
LOG_DBG("Inst %p: Gain %d, mute %u, gain_mode %u, counter %u", inst,
state->gain, state->mute, state->gain_mode, state->change_counter);
inst->cli.change_counter = state->change_counter;
if (inst->cli.cb && inst->cli.cb->state) {
inst->cli.cb->state(inst, 0, state->gain,
state->mute,
state->gain_mode);
}
}
} else if (handle == inst->cli.status_handle) {
if (length == sizeof(*status)) {
status = (uint8_t *)data;
LOG_DBG("Inst %p: Status %u", inst, *status);
if (inst->cli.cb && inst->cli.cb->status) {
inst->cli.cb->status(inst, 0, *status);
}
}
} else if (handle == inst->cli.desc_handle) {
char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1];
/* Truncate if too large */
if (length > sizeof(desc) - 1) {
LOG_DBG("Description truncated from %u to %zu octets", length,
sizeof(desc) - 1);
}
length = MIN(sizeof(desc) - 1, length);
memcpy(desc, data, length);
desc[length] = '\0';
LOG_DBG("Inst %p: Input description: %s", inst, desc);
if (inst->cli.cb && inst->cli.cb->description) {
inst->cli.cb->description(inst, 0, desc);
}
}
return BT_GATT_ITER_CONTINUE;
}
static uint8_t aics_client_read_state_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
struct bt_aics_state *state = (struct bt_aics_state *)data;
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
LOG_DBG("Inst %p: err: 0x%02X", inst, err);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (cb_err) {
LOG_DBG("State read failed: %d", err);
if (inst->cli.cb && inst->cli.cb->state) {
inst->cli.cb->state(inst, cb_err, 0, 0, 0);
}
return BT_GATT_ITER_STOP;
}
if (data) {
if (length == sizeof(*state)) {
LOG_DBG("Gain %d, mute %u, gain_mode %u, counter %u", state->gain,
state->mute, state->gain_mode, state->change_counter);
inst->cli.change_counter = state->change_counter;
} else {
LOG_DBG("Invalid length %u (expected %zu)", length, sizeof(*state));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
}
} else {
LOG_DBG("Invalid state");
cb_err = BT_ATT_ERR_UNLIKELY;
}
if (inst->cli.cb && inst->cli.cb->state) {
inst->cli.cb->state(inst, cb_err, state->gain,
state->mute, state->gain_mode);
}
return BT_GATT_ITER_STOP;
}
static uint8_t aics_client_read_gain_settings_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
struct bt_aics_gain_settings *gain_settings = (struct bt_aics_gain_settings *)data;
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
LOG_DBG("Inst %p: err: 0x%02X", inst, err);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (cb_err) {
LOG_DBG("Gain settings read failed: %d", err);
if (inst->cli.cb && inst->cli.cb->gain_setting) {
inst->cli.cb->gain_setting(inst, cb_err, 0, 0, 0);
}
return BT_GATT_ITER_STOP;
}
if (data) {
if (length == sizeof(*gain_settings)) {
LOG_DBG("Units %u, Max %d, Min %d", gain_settings->units,
gain_settings->maximum, gain_settings->minimum);
} else {
LOG_DBG("Invalid length %u (expected %zu)", length, sizeof(*gain_settings));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
}
} else {
LOG_DBG("Invalid gain settings");
cb_err = BT_ATT_ERR_UNLIKELY;
}
if (inst->cli.cb && inst->cli.cb->gain_setting) {
inst->cli.cb->gain_setting(inst, cb_err, gain_settings->units,
gain_settings->minimum,
gain_settings->maximum);
}
return BT_GATT_ITER_STOP;
}
static uint8_t aics_client_read_type_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *type = (uint8_t *)data;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
LOG_DBG("Inst %p: err: 0x%02X", inst, err);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (cb_err) {
LOG_DBG("Type read failed: %d", err);
if (inst->cli.cb && inst->cli.cb->type) {
inst->cli.cb->type(inst, cb_err, 0);
}
return BT_GATT_ITER_STOP;
}
if (data) {
if (length == sizeof(*type)) {
LOG_DBG("Type %u", *type);
} else {
LOG_DBG("Invalid length %u (expected %zu)", length, sizeof(*type));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
}
} else {
LOG_DBG("Invalid type");
cb_err = BT_ATT_ERR_UNLIKELY;
}
if (inst->cli.cb && inst->cli.cb->type) {
inst->cli.cb->type(inst, cb_err, *type);
}
return BT_GATT_ITER_STOP;
}
static uint8_t aics_client_read_status_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *status = (uint8_t *)data;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
LOG_DBG("Inst %p: err: 0x%02X", inst, err);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (cb_err) {
LOG_DBG("Status read failed: %d", err);
if (inst->cli.cb && inst->cli.cb->status) {
inst->cli.cb->status(inst, cb_err, 0);
}
return BT_GATT_ITER_STOP;
}
if (data) {
if (length == sizeof(*status)) {
LOG_DBG("Status %u", *status);
} else {
LOG_DBG("Invalid length %u (expected %zu)", length, sizeof(*status));
cb_err = BT_ATT_ERR_INVALID_ATTRIBUTE_LEN;
}
} else {
LOG_DBG("Invalid status");
cb_err = BT_ATT_ERR_UNLIKELY;
}
if (inst->cli.cb && inst->cli.cb->status) {
inst->cli.cb->status(inst, cb_err, *status);
}
return BT_GATT_ITER_STOP;
}
static void aics_cp_notify_app(struct bt_aics *inst, uint8_t err)
{
if (!inst->cli.cb) {
return;
}
switch (inst->cli.cp_val.cp.opcode) {
case BT_AICS_OPCODE_SET_GAIN:
if (inst->cli.cb->set_gain) {
inst->cli.cb->set_gain(inst, err);
}
break;
case BT_AICS_OPCODE_UNMUTE:
if (inst->cli.cb->unmute) {
inst->cli.cb->unmute(inst, err);
}
break;
case BT_AICS_OPCODE_MUTE:
if (inst->cli.cb->mute) {
inst->cli.cb->mute(inst, err);
}
break;
case BT_AICS_OPCODE_SET_MANUAL:
if (inst->cli.cb->set_manual_mode) {
inst->cli.cb->set_manual_mode(inst, err);
}
break;
case BT_AICS_OPCODE_SET_AUTO:
if (inst->cli.cb->set_auto_mode) {
inst->cli.cb->set_auto_mode(inst, err);
}
break;
default:
LOG_DBG("Unknown opcode 0x%02x", inst->cli.cp_val.cp.opcode);
break;
}
}
static uint8_t internal_read_state_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
struct bt_aics_state *state = (struct bt_aics_state *)data;
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_ERR("Instance not found");
return BT_GATT_ITER_STOP;
}
if (err) {
LOG_WRN("State read failed: %d", err);
} else if (data) {
if (length == sizeof(*state)) {
int write_err;
LOG_DBG("Gain %d, mute %u, gain_mode %u, counter %u", state->gain,
state->mute, state->gain_mode, state->change_counter);
inst->cli.change_counter = state->change_counter;
/* clear busy flag to reuse function */
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (inst->cli.cp_val.cp.opcode == BT_AICS_OPCODE_SET_GAIN) {
write_err = bt_aics_client_gain_set(inst,
inst->cli.cp_val.gain_setting);
} else {
write_err = aics_client_common_control(inst->cli.cp_val.cp.opcode,
inst);
}
if (write_err) {
cb_err = BT_ATT_ERR_UNLIKELY;
}
} else {
LOG_DBG("Invalid length %u (expected %zu)", length, sizeof(*state));
cb_err = BT_ATT_ERR_UNLIKELY;
}
}
if (cb_err) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
aics_cp_notify_app(inst, cb_err);
}
return BT_GATT_ITER_STOP;
}
static void aics_client_write_aics_cp_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
struct bt_aics *inst = lookup_aics_by_handle(conn, params->handle);
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return;
}
LOG_DBG("Inst %p: err: %d", inst, cb_err);
/* If the change counter is out of data when a write was attempted from
* the application, we automatically initiate a read to get the newest
* state and try again. Once the change counter has been read, we
* restart the applications write request. If it fails
* the second time, we return an error to the application.
*/
if (cb_err == BT_AICS_ERR_INVALID_COUNTER &&
atomic_test_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_CP_RETRIED)) {
cb_err = BT_ATT_ERR_UNLIKELY;
} else if (cb_err == BT_AICS_ERR_INVALID_COUNTER && inst->cli.state_handle) {
inst->cli.read_params.func = internal_read_state_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.state_handle;
inst->cli.read_params.single.offset = 0U;
atomic_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_CP_RETRIED);
cb_err = bt_gatt_read(conn, &inst->cli.read_params);
if (cb_err != 0) {
LOG_WRN("Could not read state: %d", cb_err);
} else {
/* Wait for read callback */
return;
}
}
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_CP_RETRIED);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
aics_cp_notify_app(inst, cb_err);
}
static int aics_client_common_control(uint8_t opcode, struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.control_handle) {
LOG_DBG("Handle not set for opcode %u", opcode);
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.cp_val.cp.opcode = opcode;
inst->cli.cp_val.cp.counter = inst->cli.change_counter;
inst->cli.write_params.offset = 0;
inst->cli.write_params.data = &inst->cli.cp_val.cp;
inst->cli.write_params.length = sizeof(inst->cli.cp_val.cp);
inst->cli.write_params.handle = inst->cli.control_handle;
inst->cli.write_params.func = aics_client_write_aics_cp_cb;
err = bt_gatt_write(inst->cli.conn, &inst->cli.write_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
static uint8_t aics_client_read_desc_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
char desc[MIN(BT_L2CAP_RX_MTU, BT_ATT_MAX_ATTRIBUTE_LEN) + 1];
struct bt_aics *inst = lookup_aics_by_handle(conn, params->single.handle);
memset(params, 0, sizeof(*params));
if (!inst) {
LOG_DBG("Instance not found");
return BT_GATT_ITER_STOP;
}
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (cb_err) {
LOG_DBG("Description read failed: %d", err);
if (inst->cli.cb && inst->cli.cb->description) {
inst->cli.cb->description(inst, cb_err, NULL);
}
return BT_GATT_ITER_STOP;
}
if (data) {
LOG_HEXDUMP_DBG(data, length, "Input description read");
/* Truncate if too large */
if (length > sizeof(desc) - 1) {
LOG_DBG("Description truncated from %u to %zu octets", length,
sizeof(desc) - 1);
}
length = MIN(sizeof(desc) - 1, length);
/* TODO: Handle long reads */
memcpy(desc, data, length);
}
desc[length] = '\0';
LOG_DBG("Input description: %s", desc);
if (inst->cli.cb && inst->cli.cb->description) {
inst->cli.cb->description(inst, cb_err, desc);
}
return BT_GATT_ITER_STOP;
}
static bool valid_inst_discovered(struct bt_aics *inst)
{
return inst->cli.state_handle &&
inst->cli.gain_handle &&
inst->cli.type_handle &&
inst->cli.status_handle &&
inst->cli.control_handle &&
inst->cli.desc_handle;
}
static uint8_t aics_discover_func(struct bt_conn *conn, const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_aics_client *client_inst = CONTAINER_OF(params,
struct bt_aics_client,
discover_params);
struct bt_aics *inst = CONTAINER_OF(client_inst, struct bt_aics, cli);
if (!attr) {
LOG_DBG("Discovery complete for AICS %p", inst);
memset(params, 0, sizeof(*params));
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
if (inst->cli.cb && inst->cli.cb->discover) {
int err = valid_inst_discovered(inst) ? 0 : -ENOENT;
inst->cli.cb->discover(inst, err);
}
return BT_GATT_ITER_STOP;
}
LOG_DBG("[ATTRIBUTE] handle 0x%04X", attr->handle);
if (params->type == BT_GATT_DISCOVER_CHARACTERISTIC) {
struct bt_gatt_subscribe_params *sub_params = NULL;
struct bt_gatt_chrc *chrc;
chrc = (struct bt_gatt_chrc *)attr->user_data;
if (inst->cli.start_handle == 0) {
inst->cli.start_handle = chrc->value_handle;
}
inst->cli.end_handle = chrc->value_handle;
if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_STATE)) {
LOG_DBG("Audio Input state");
inst->cli.state_handle = chrc->value_handle;
sub_params = &inst->cli.state_sub_params;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_GAIN_SETTINGS)) {
LOG_DBG("Gain settings");
inst->cli.gain_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_INPUT_TYPE)) {
LOG_DBG("Input type");
inst->cli.type_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_INPUT_STATUS)) {
LOG_DBG("Input status");
inst->cli.status_handle = chrc->value_handle;
sub_params = &inst->cli.status_sub_params;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_CONTROL)) {
LOG_DBG("Control point");
inst->cli.control_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_AICS_DESCRIPTION)) {
LOG_DBG("Description");
inst->cli.desc_handle = chrc->value_handle;
if (chrc->properties & BT_GATT_CHRC_NOTIFY) {
sub_params = &inst->cli.desc_sub_params;
}
if (chrc->properties & BT_GATT_CHRC_WRITE_WITHOUT_RESP) {
atomic_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_DESC_WRITABLE);
}
}
if (sub_params) {
int err;
sub_params->value = BT_GATT_CCC_NOTIFY;
sub_params->value_handle = chrc->value_handle;
/*
* TODO: Don't assume that CCC is at handle + 2;
* do proper discovery;
*/
sub_params->ccc_handle = attr->handle + 2;
sub_params->notify = aics_client_notify_handler;
atomic_set_bit(sub_params->flags, BT_GATT_SUBSCRIBE_FLAG_VOLATILE);
err = bt_gatt_subscribe(conn, sub_params);
if (err != 0 && err != -EALREADY) {
LOG_ERR("Failed to subscribe: %d", err);
if (inst->cli.cb && inst->cli.cb->discover) {
inst->cli.cb->discover(inst, err);
}
return BT_GATT_ITER_STOP;
}
}
}
return BT_GATT_ITER_CONTINUE;
}
static void aics_client_reset(struct bt_aics *inst)
{
inst->cli.change_counter = 0;
inst->cli.gain_mode = 0;
inst->cli.start_handle = 0;
inst->cli.end_handle = 0;
inst->cli.state_handle = 0;
inst->cli.gain_handle = 0;
inst->cli.type_handle = 0;
inst->cli.status_handle = 0;
inst->cli.control_handle = 0;
inst->cli.desc_handle = 0;
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_DESC_WRITABLE);
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_CP_RETRIED);
if (inst->cli.conn != NULL) {
struct bt_conn *conn = inst->cli.conn;
bt_conn_unref(conn);
inst->cli.conn = NULL;
}
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
for (size_t i = 0; i < ARRAY_SIZE(aics_insts); i++) {
if (aics_insts[i].cli.conn == conn) {
aics_client_reset(&aics_insts[i]);
}
}
}
BT_CONN_CB_DEFINE(conn_callbacks) = {
.disconnected = disconnected,
};
int bt_aics_discover(struct bt_conn *conn, struct bt_aics *inst,
const struct bt_aics_discover_param *param)
{
int err = 0;
CHECKIF(!inst || !conn || !param) {
LOG_DBG("%s cannot be NULL", inst == NULL ? "inst"
: conn == NULL ? "conn"
: "param");
return -EINVAL;
}
CHECKIF(param->end_handle <= param->start_handle) {
LOG_DBG("start_handle (%u) shall be less than end_handle (%u)", param->start_handle,
param->end_handle);
return -EINVAL;
}
CHECKIF(!atomic_test_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_ACTIVE)) {
LOG_DBG("Inactive instance");
return -EINVAL;
}
if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
LOG_DBG("Instance is busy");
return -EBUSY;
}
aics_client_reset(inst);
(void)memset(&inst->cli.discover_params, 0, sizeof(inst->cli.discover_params));
inst->cli.discover_params.start_handle = param->start_handle;
inst->cli.discover_params.end_handle = param->end_handle;
inst->cli.discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
inst->cli.discover_params.func = aics_discover_func;
err = bt_gatt_discover(conn, &inst->cli.discover_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
LOG_DBG("Discover failed (err %d)", err);
} else {
inst->cli.conn = bt_conn_ref(conn);
}
return err;
}
struct bt_aics *bt_aics_client_free_instance_get(void)
{
for (int i = 0; i < ARRAY_SIZE(aics_insts); i++) {
if (!atomic_test_and_set_bit(aics_insts[i].cli.flags, BT_AICS_CLIENT_FLAG_ACTIVE)) {
aics_insts[i].client_instance = true;
return &aics_insts[i];
}
}
return NULL;
}
int bt_aics_client_conn_get(const struct bt_aics *aics, struct bt_conn **conn)
{
CHECKIF(aics == NULL) {
LOG_DBG("NULL aics pointer");
return -EINVAL;
}
if (!aics->client_instance) {
LOG_DBG("aics pointer shall be client instance");
return -EINVAL;
}
if (aics->cli.conn == NULL) {
LOG_DBG("aics pointer not associated with a connection. "
"Do discovery first");
return -ENOTCONN;
}
*conn = aics->cli.conn;
return 0;
}
int bt_aics_client_state_get(struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.state_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.read_params.func = aics_client_read_state_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.state_handle;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_gain_setting_get(struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.gain_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.read_params.func = aics_client_read_gain_settings_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.gain_handle;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_type_get(struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.type_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.read_params.func = aics_client_read_type_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.type_handle;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_status_get(struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.status_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.read_params.func = aics_client_read_status_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.status_handle;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_unmute(struct bt_aics *inst)
{
return aics_client_common_control(BT_AICS_OPCODE_UNMUTE, inst);
}
int bt_aics_client_mute(struct bt_aics *inst)
{
return aics_client_common_control(BT_AICS_OPCODE_MUTE, inst);
}
int bt_aics_client_manual_gain_set(struct bt_aics *inst)
{
return aics_client_common_control(BT_AICS_OPCODE_SET_MANUAL, inst);
}
int bt_aics_client_automatic_gain_set(struct bt_aics *inst)
{
return aics_client_common_control(BT_AICS_OPCODE_SET_AUTO, inst);
}
int bt_aics_client_gain_set(struct bt_aics *inst, int8_t gain)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.control_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.cp_val.cp.opcode = BT_AICS_OPCODE_SET_GAIN;
inst->cli.cp_val.cp.counter = inst->cli.change_counter;
inst->cli.cp_val.gain_setting = gain;
inst->cli.write_params.data = &inst->cli.cp_val;
inst->cli.write_params.length = sizeof(inst->cli.cp_val);
inst->cli.write_params.handle = inst->cli.control_handle;
inst->cli.write_params.func = aics_client_write_aics_cp_cb;
err = bt_gatt_write(inst->cli.conn, &inst->cli.write_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_description_get(struct bt_aics *inst)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.desc_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
inst->cli.read_params.func = aics_client_read_desc_cb;
inst->cli.read_params.handle_count = 1;
inst->cli.read_params.single.handle = inst->cli.desc_handle;
err = bt_gatt_read(inst->cli.conn, &inst->cli.read_params);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
int bt_aics_client_description_set(struct bt_aics *inst,
const char *description)
{
int err;
CHECKIF(!inst) {
LOG_DBG("NULL instance");
return -EINVAL;
}
CHECKIF(!inst->client_instance) {
LOG_DBG("Not a client instance instance");
return -EINVAL;
}
CHECKIF(inst->cli.conn == NULL) {
LOG_DBG("NULL conn");
return -EINVAL;
}
if (!inst->cli.desc_handle) {
LOG_DBG("Handle not set");
return -EINVAL;
} else if (!atomic_test_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_DESC_WRITABLE)) {
LOG_DBG("Description is not writable on peer service instance");
return -EPERM;
} else if (atomic_test_and_set_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY)) {
return -EBUSY;
}
err = bt_gatt_write_without_response(inst->cli.conn, inst->cli.desc_handle, description,
strlen(description), false);
if (err != 0) {
atomic_clear_bit(inst->cli.flags, BT_AICS_CLIENT_FLAG_BUSY);
}
return err;
}
void bt_aics_client_cb_register(struct bt_aics *inst, struct bt_aics_cb *cb)
{
CHECKIF(!inst) {
LOG_DBG("inst cannot be NULL");
return;
}
inst->cli.cb = cb;
}
Reference in New Issue View Git Blame Copy Permalink