int bt_gatt_attr_read_service(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
struct bt_uuid *uuid = attr->user_data;
if (uuid->type == BT_UUID_TYPE_16) {
uint16_t uuid16 = sys_cpu_to_le16(BT_UUID_16(uuid)->val);
return bt_gatt_attr_read(conn, attr, buf, len, offset,
&uuid16, 2);
}
return bt_gatt_attr_read(conn, attr, buf, len, offset,
BT_UUID_128(uuid)->val, 16);
}
static ssize_t read_stepcadence_feature(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len,
uint16_t offset)
{
uint16_t rsc_feature = 0;
if (on_ble_rscs_get_stride_lenth() >= 0) {
rsc_feature |= 1;
}
if (on_ble_rscs_get_total_distance() >= 0) {
rsc_feature |= 2;
}
if (on_ble_rscs_get_walk_run() >= 0) {
rsc_feature |= 4;
}
#ifdef CONFIG_BLE_RSCS_MULTIPLE_SENSOR_LOCATION_SUPPORT
rsc_feature |= 10;
#endif
/* other optional elements not yet implemented
* - calibration procedure supported:
* rsc_feature |= 8;
*/
rsc_feature = sys_cpu_to_le16(rsc_feature);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &rsc_feature,
sizeof(rsc_feature));
}
int bt_gatt_attr_read_ccc(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
struct _bt_gatt_ccc *ccc = attr->user_data;
uint16_t value;
size_t i;
for (i = 0; i < ccc->cfg_len; i++) {
if (bt_addr_le_cmp(&ccc->cfg[i].peer, &conn->le.dst)) {
continue;
}
value = sys_cpu_to_le16(ccc->cfg[i].value);
break;
}
/* Default to disable if there is no cfg for the peer */
if (i == ccc->cfg_len) {
value = 0x0000;
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
sizeof(value));
}
int bt_gatt_attr_read_service(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint8_t len, uint16_t offset)
{
struct bt_uuid *uuid = attr->user_data;
if (uuid->type == BT_UUID_16) {
uint16_t uuid16 = sys_cpu_to_le16(uuid->u16);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &uuid16,
sizeof(uuid16));
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, uuid->u128,
sizeof(uuid->u128));
}
static ssize_t read_name(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
const char *name = attr->user_data;
return bt_gatt_attr_read(conn, attr, buf, len, offset, name,
strlen(name));
}
static ssize_t read_temperature(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
const char *value = attr->user_data;
return bt_gatt_attr_read(conn, attr, buf, len, offset, value,
sizeof(*value));
}
static int read_blvl(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
const uint8_t *value = attr->user_data;
return bt_gatt_attr_read(conn, attr, buf, len, offset, value,
sizeof(*value));
}
int bt_gatt_attr_read_cud(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
char *value = attr->user_data;
return bt_gatt_attr_read(conn, attr, buf, len, offset, value, strlen(value));
}
static ssize_t read_blsc(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
uint8_t value = 0x01;
return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
sizeof(value));
}
static ssize_t read_csc_feature(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
uint16_t csc_feature = CSC_FEATURE;
return bt_gatt_attr_read(conn, attr, buf, len, offset,
&csc_feature, sizeof(csc_feature));
}
static ssize_t read_appearance(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
uint16_t appearance = sys_cpu_to_le16(gap_appearance);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &appearance,
sizeof(appearance));
}
int bt_gatt_attr_read_cpf(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
struct bt_gatt_cpf *value = attr->user_data;
return bt_gatt_attr_read(conn, attr, buf, len, offset, value,
sizeof(*value));
}
static ssize_t read_u32(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
const uint32_t *u32 = attr->user_data;
uint32_t value = sys_cpu_to_le32(*u32);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
sizeof(value));
}
int bt_gatt_attr_read_cep(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
struct bt_gatt_cep *value = attr->user_data;
uint16_t props = sys_cpu_to_le16(value->properties);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &props,
sizeof(props));
}
ssize_t on_gap_rd_appearance(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len,
uint16_t offset)
{
uint16_t appearance = BLE_APP_APPEARANCE;
return bt_gatt_attr_read(conn, attr, buf, len, offset, &appearance,
sizeof(appearance));
}
static ssize_t read_body_sensor_location(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len,
uint16_t offset)
{
uint8_t value = ble_hrs_sensor_location;
return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
sizeof(value));
}
static ssize_t read_rgb(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
memcpy(rgb, attr->user_data, sizeof(rgb));
printk("read_rgb: %x %x %x\n", rgb[0], rgb[1], rgb[2]);
return bt_gatt_attr_read(conn, attr, buf, len, offset, rgb,
sizeof(rgb));
}
/** Helper function. */
static ssize_t read_string(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t buf_len,
uint16_t offset,
const char *value)
{
size_t str_len = strlen(value);
return bt_gatt_attr_read(conn, attr, buf, buf_len, offset, value,
str_len);
}
static ssize_t read_sensor_location(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len,
uint16_t offset)
{
uint8_t sensor_location = 0;
sensor_location = on_ble_rscs_get_sensor_location();
return bt_gatt_attr_read(conn, attr, buf, len, offset, &sensor_location,
sizeof(sensor_location));
}
// GATT Server Only
ssize_t profile_read_process(bt_conn_t *conn,
const bt_gatt_attr_t *attr,
void *buf, uint16_t len,
uint16_t offset)
{
const unsigned char *pvalue;
BLEAttribute *bleattr = (BLEAttribute *)attr->user_data;
BLEAttributeType type = bleattr->type();
if (BLETypeCharacteristic == type)
{
BLECharacteristicImp* blecharacteritic = (BLECharacteristicImp*)bleattr;
pvalue = blecharacteritic->value();
return bt_gatt_attr_read(conn, attr, buf, len, offset, pvalue,
blecharacteritic->valueLength());
}
else if (BLETypeDescriptor == type)
{
BLEDescriptorImp* bledescriptor = (BLEDescriptorImp*)bleattr;
pvalue = bledescriptor->value();
return bt_gatt_attr_read(conn, attr, buf, len, offset, pvalue, bledescriptor->valueLength());
}
return 0;
}
ssize_t on_gap_rd_ppcp(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len,
uint16_t offset)
{
/* Default values */
struct gap_ppcp ppcp;
ppcp.interval_min = sys_cpu_to_le16(MIN_CONN_INTERVAL);
ppcp.interval_max = sys_cpu_to_le16(MAX_CONN_INTERVAL);
ppcp.slave_latency = sys_cpu_to_le16(SLAVE_LATENCY);
ppcp.link_sup_to = sys_cpu_to_le16(CONN_SUP_TIMEOUT);
return bt_gatt_attr_read(conn, attr, buf, len, offset, &ppcp,
sizeof(ppcp));
}
ssize_t on_dis_rd_serial(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
uint8_t sn[32];
uint8_t sn_len;
/* Check if the factory data contains a serial number otherwise return BD Address */
if (!memcmp(global_factory_data->oem_data.magic, FACTORY_DATA_MAGIC,
4)) {
struct oem_data *p_oem =
(struct oem_data *)&global_factory_data->oem_data;
uint8buf_to_ascii(sn, p_oem->uuid, sizeof(p_oem->uuid));
sn_len = sizeof(sn);
} else {
uint8buf_to_ascii(sn, _ble_app_cb.my_bd_addr.val, 6);
sn_len = 12;
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, sn, sn_len);
}
int bt_gatt_attr_read_include(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint8_t len, uint16_t offset)
{
struct bt_gatt_include *incl = attr->user_data;
struct gatt_incl pdu;
uint8_t value_len;
pdu.start_handle = sys_cpu_to_le16(incl->start_handle);
pdu.end_handle = sys_cpu_to_le16(incl->end_handle);
value_len = sizeof(pdu.start_handle) + sizeof(pdu.end_handle);
if (incl->uuid->type == BT_UUID_16) {
pdu.uuid16 = sys_cpu_to_le16(incl->uuid->u16);
value_len += sizeof(pdu.uuid16);
} else {
memcpy(pdu.uuid, incl->uuid->u128, sizeof(incl->uuid->u128));
value_len += sizeof(incl->uuid->u128);
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, &pdu, value_len);
}
int bt_gatt_attr_read_chrc(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint8_t len, uint16_t offset)
{
struct bt_gatt_chrc *chrc = attr->user_data;
struct gatt_chrc pdu;
uint8_t value_len;
pdu.properties = chrc->properties;
pdu.value_handle = sys_cpu_to_le16(chrc->value_handle);
value_len = sizeof(pdu.properties) + sizeof(pdu.value_handle);
if (chrc->uuid->type == BT_UUID_16) {
pdu.uuid16 = sys_cpu_to_le16(chrc->uuid->u16);
value_len += sizeof(pdu.uuid16);
} else {
memcpy(pdu.uuid, chrc->uuid->u128, sizeof(chrc->uuid->u128));
value_len += sizeof(chrc->uuid->u128);
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, &pdu, value_len);
}
int bt_gatt_attr_read_chrc(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
uint16_t len, uint16_t offset)
{
struct bt_gatt_chrc *chrc = attr->user_data;
struct gatt_chrc pdu;
const struct bt_gatt_attr *next;
uint8_t value_len;
pdu.properties = chrc->properties;
/* BLUETOOTH SPECIFICATION Version 4.2 [Vol 3, Part G] page 534:
* 3.3.2 Characteristic Value Declaration
* The Characteristic Value declaration contains the value of the
* characteristic. It is the first Attribute after the characteristic
* declaration. All characteristic definitions shall have a
* Characteristic Value declaration.
*/
next = bt_gatt_attr_next(attr);
if (!next) {
BT_WARN("No value for characteristic at 0x%04x", attr->handle);
pdu.value_handle = 0x0000;
} else {
pdu.value_handle = sys_cpu_to_le16(next->handle);
}
value_len = sizeof(pdu.properties) + sizeof(pdu.value_handle);
if (chrc->uuid->type == BT_UUID_TYPE_16) {
pdu.uuid16 = sys_cpu_to_le16(BT_UUID_16(chrc->uuid)->val);
value_len += 2;
} else {
memcpy(pdu.uuid, BT_UUID_128(chrc->uuid)->val, 16);
value_len += 16;
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, &pdu, value_len);
}
int bt_gatt_attr_read_included(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
struct bt_gatt_include *incl = attr->user_data;
struct gatt_incl pdu;
uint8_t value_len;
pdu.start_handle = sys_cpu_to_le16(incl->start_handle);
pdu.end_handle = sys_cpu_to_le16(incl->end_handle);
value_len = sizeof(pdu.start_handle) + sizeof(pdu.end_handle);
/*
* Core 4.2, Vol 3, Part G, 3.2,
* The Service UUID shall only be present when the UUID is a 16-bit
* Bluetooth UUID.
*/
if (incl->uuid->type == BT_UUID_TYPE_16) {
pdu.uuid16 = sys_cpu_to_le16(BT_UUID_16(incl->uuid)->val);
value_len += sizeof(pdu.uuid16);
}
return bt_gatt_attr_read(conn, attr, buf, len, offset, &pdu, value_len);
}
static ssize_t read_name(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, uint16_t len, uint16_t offset)
{
return bt_gatt_attr_read(conn, attr, buf, len, offset, gap_name,
strlen(gap_name));
}
