/* condev might be NULL here */
static void link_loss_change_alert_level(struct link_loss_adapter *la,
struct connected_device *condev,
uint8_t level)
{
attrib_db_update(la->adapter, la->alert_lvl_value_handle,
NULL, &level, sizeof(level), NULL);
if (condev)
condev->alert_level = level;
}
static uint8_t battery_state_read(struct attribute *a, gpointer user_data)
{
struct btd_adapter *adapter = user_data;
uint8_t value;
value = 0x04;
attrib_db_update(adapter, a->handle, NULL, &value, sizeof(value), NULL);
return 0;
}
static void update_new_alert(gpointer data, gpointer user_data)
{
struct alert_adapter *al_adapter = data;
struct btd_adapter *adapter = al_adapter->adapter;
uint8_t *value = user_data;
attrib_db_update(adapter, al_adapter->hnd_value[NOTIFY_NEW_ALERT], NULL,
&value[1], value[0], NULL);
notify_devices(al_adapter, NOTIFY_NEW_ALERT, &value[1], value[0]);
}
static uint8_t current_time_read(struct attribute *a, gpointer user_data)
{
uint8_t value[10];
if (encode_current_time(value) < 0)
return ATT_ECODE_IO;
/* FIXME: Provide the adapter in next function */
attrib_db_update(NULL, a->handle, NULL, value, sizeof(value), NULL);
return 0;
}
static void update_unread_alert(gpointer data, gpointer user_data)
{
struct alert_adapter *al_adapter = data;
struct btd_adapter *adapter = al_adapter->adapter;
uint8_t *value = user_data;
attrib_db_update(adapter,
al_adapter->hnd_value[NOTIFY_UNREAD_ALERT], NULL, value,
2, NULL);
notify_devices(al_adapter, NOTIFY_UNREAD_ALERT, value, 2);
}
static void update_supported_categories(gpointer data, gpointer user_data)
{
struct alert_adapter *al_adapter = data;
struct btd_adapter *adapter = al_adapter->adapter;
uint8_t value[2];
unsigned int i;
memset(value, 0, sizeof(value));
for (i = 0; i < G_N_ELEMENTS(anp_categories); i++) {
if (registered_category(anp_categories[i]))
hci_set_bit(i, value);
}
attrib_db_update(adapter, al_adapter->supp_new_alert_cat_handle, NULL,
value, sizeof(value), NULL);
/* FIXME: For now report all registered categories as supporting unread
* status, until it is known which ones should be supported */
attrib_db_update(adapter, al_adapter->supp_unread_alert_cat_handle,
NULL, value, sizeof(value), NULL);
}
static uint8_t current_time_read(struct attribute *a,
struct btd_device *device, gpointer user_data)
{
struct btd_adapter *adapter = user_data;
uint8_t value[10];
if (encode_current_time(value) < 0)
return ATT_ECODE_IO;
attrib_db_update(adapter, a->handle, NULL, value, sizeof(value), NULL);
return 0;
}
static uint8_t time_with_dst_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct time_with_dst next_time;
struct time_adapter *ta = user_data;
DBG("");
attrib_db_update(ta->adapter, a->handle, NULL, (uint8_t*)&next_dst,
sizeof(next_dst), NULL);
return 0;
}
static void __notify_alert_status(gpointer data, gpointer user_data)
{
struct alert_adapter *aa = data;
uint8_t status = (uint32_t)user_data & 0xff;
if (alert_status != status) {
alert_status = status;
queue_notification(aa->adapter, BDADDR_ALL,
aa->h_alert_status, aa->h_alert_status_ccc,
&alert_status, sizeof(alert_status));
attrib_db_update(aa->adapter, aa->h_alert_status, NULL,
&alert_status, sizeof(alert_status), NULL);
}
}
static uint8_t current_time_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct current_time curtime;
struct time_adapter *ta = user_data;
if (get_current_time(&curtime) < 0)
return ATT_ECODE_IO;
attrib_db_update(ta->adapter, a->handle, NULL, (uint8_t *)&curtime,
sizeof(curtime), NULL);
return 0;
}
static uint8_t ringer_setting_read(struct attribute *a,
struct btd_device *device,
gpointer user_data)
{
struct btd_adapter *adapter = user_data;
DBG("a = %p", a);
if (a->data == NULL || a->data[0] != ringer_setting)
attrib_db_update(adapter, a->handle, NULL, &ringer_setting,
sizeof(ringer_setting), NULL);
return 0;
}
static uint8_t alert_status_read(struct attribute *a,
struct btd_device *device,
gpointer user_data)
{
struct btd_adapter *adapter = user_data;
DBG("a = %p", a);
if (a->data == NULL || a->data[0] != alert_status)
attrib_db_update(adapter, a->handle, NULL, &alert_status,
sizeof(alert_status), NULL);
return 0;
}
static uint8_t supp_unread_alert_cat_read(struct attribute *a,
struct btd_device *device,
gpointer user_data)
{
struct btd_adapter *adapter = user_data;
uint8_t value[] = { 0x00, 0x00 };
DBG("a = %p", a);
if (a->data == NULL)
attrib_db_update(adapter, a->handle, NULL, value, sizeof(value),
NULL);
return 0;
}
static uint8_t time_update_status(struct attribute *a,
struct btd_device *device,
gpointer user_data)
{
struct btd_adapter *adapter = user_data;
uint8_t value[2];
DBG("handle 0x%04x", a->handle);
value[0] = UPDATE_STATE_IDLE;
value[1] = UPDATE_RESULT_SUCCESSFUL;
attrib_db_update(adapter, a->handle, NULL, value, sizeof(value), NULL);
return 0;
}
static void __notify_ringer_setting(gpointer data, gpointer user_data)
{
struct alert_adapter *aa = data;
uint8_t setting = (uint32_t)user_data & 0xff;
if (ringer_setting != setting) {
ringer_setting = setting;
queue_notification(aa->adapter, BDADDR_ALL,
aa->h_ringer_setting,
aa->h_ringer_setting_ccc,
&ringer_setting, sizeof(ringer_setting));
attrib_db_update(aa->adapter, aa->h_ringer_setting, NULL,
&ringer_setting, sizeof(ringer_setting), NULL);
}
}
static uint8_t alert_status_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct alert_adapter *aa = user_data;
if (!initialized) {
error("Uninitialized");
return ATT_ECODE_IO;
}
DBG("Alert state = 0x%X", alert_status);
if (a->data == NULL || a->data[0] != alert_status)
attrib_db_update(aa->adapter, a->handle, NULL, &alert_status,
sizeof(alert_status), NULL);
return 0;
}
static uint8_t ringer_setting_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct alert_adapter *aa = user_data;
if (!initialized) {
error("Uninitialized");
return ATT_ECODE_IO;
}
DBG("Ringer state = 0x%X", ringer_setting);
if (a->data == NULL || a->data[0] != ringer_setting)
attrib_db_update(aa->adapter, a->handle, NULL, &ringer_setting,
sizeof(ringer_setting), NULL);
return 0;
}
static uint8_t supp_new_alert_cat_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct alert_adapter *aa = user_data;
if (!initialized) {
error("Uninitialized");
return ATT_ECODE_IO;
}
DBG("Supported new alert = 0x%X", supp_new_alerts);
if (a->data == NULL || a->data[0] != supp_new_alerts)
attrib_db_update(aa->adapter, a->handle, NULL, &supp_new_alerts,
sizeof(supp_new_alerts), NULL);
return 0;
}
static uint8_t local_time_info_read(struct attribute *a, gpointer user_data)
{
uint8_t value[2];
DBG("a=%p", a);
tzset();
/* FIXME: POSIX "daylight" variable only indicates whether there is DST
* for the local time or not. The offset is unknown. */
value[0] = daylight ? 0xff : 0x00;
/* Convert POSIX "timezone" (seconds West of GMT) to Time Profile
* format (offset from UTC in number of 15 minutes increments). */
value[1] = (uint8_t) (-1 * timezone / (60 * 15));
/* FIXME: Provide the adapter in next function */
attrib_db_update(NULL, a->handle, NULL, value, sizeof(value), NULL);
return 0;
}
static uint8_t local_time_info_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct local_time_information local_time;
struct time_adapter *ta = user_data;
tzset();
local_time.dst_offset.dst_offset = dst_offset.dst_offset;
/* Convert POSIX "timezone" (seconds West of GMT) to Time Profile
* format (offset from UTC in number of 15 minutes increments). */
local_time.time_zone.time_zone = (uint8_t)(-1 * timezone / (60 * 15));
DBG("dst_offset = %d, time_zone = %d",
local_time.dst_offset.dst_offset,
local_time.time_zone.time_zone);
attrib_db_update(ta->adapter, a->handle, NULL, (uint8_t*)&local_time,
sizeof(local_time), NULL);
return 0;
}
static uint8_t link_loss_alert_lvl_read(struct attribute *a, gpointer user_data,
struct btd_device *device)
{
struct link_loss_adapter *adapter = user_data;
struct connected_device *condev;
GSList *l = NULL;
uint8_t alert_level = NO_ALERT;
if (device)
l = g_slist_find_custom(adapter->connected_devices, device,
lldevice_cmp);
if (l) {
condev = l->data;
alert_level = condev->alert_level;
}
DBG("return alert level %d for dev %p", alert_level, device);
/* update the alert level according to the requesting device */
attrib_db_update(adapter->adapter, a->handle, NULL, &alert_level,
sizeof(alert_level), NULL);
return 0;
}
