blob: 9d59d40ea257480d128b5fdb83dcad9050982d5e [file] [log] [blame]
/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <stdint.h>
#include <syslog.h>
#include <sys/socket.h>
#include <unistd.h>
#include "cras_a2dp_endpoint.h"
#include "cras_bt_adapter.h"
#include "cras_bt_constants.h"
#include "cras_bt_log.h"
#include "cras_bt_profile.h"
#include "cras_hfp_ag_profile.h"
#include "cras_hfp_info.h"
#include "cras_hfp_iodev.h"
#include "cras_hfp_alsa_iodev.h"
#include "cras_server_metrics.h"
#include "cras_system_state.h"
#include "cras_iodev_list.h"
#include "cras_observer.h"
#include "utlist.h"
#include "packet_status_logger.h"
#define HFP_AG_PROFILE_NAME "Hands-Free Voice gateway"
#define HFP_AG_PROFILE_PATH "/org/chromium/Cras/Bluetooth/HFPAG"
#define HFP_VERSION 0x0107
#define HSP_AG_PROFILE_NAME "Headset Voice gateway"
#define HSP_AG_PROFILE_PATH "/org/chromium/Cras/Bluetooth/HSPAG"
#define HSP_VERSION_1_2 0x0102
#define HSP_VERSION_1_2_STR "0x0102"
#define HSP_AG_RECORD \
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" \
"<record>" \
" <attribute id=\"0x0001\">" \
" <sequence>" \
" <uuid value=\"" HSP_AG_UUID "\" />" \
" <uuid value=\"" GENERIC_AUDIO_UUID "\" />" \
" </sequence>" \
" </attribute>" \
" <attribute id=\"0x0004\">" \
" <sequence>" \
" <sequence>" \
" <uuid value=\"0x0100\" />" \
" </sequence>" \
" <sequence>" \
" <uuid value=\"0x0003\" />" \
" <uint8 value=\"0x0c\" />" \
" </sequence>" \
" </sequence>" \
" </attribute>" \
" <attribute id=\"0x0005\">" \
" <sequence>" \
" <uuid value=\"0x1002\" />" \
" </sequence>" \
" </attribute>" \
" <attribute id=\"0x0009\">" \
" <sequence>" \
" <sequence>" \
" <uuid value=\"" HSP_HS_UUID "\" />" \
" <uint16 value=\"" HSP_VERSION_1_2_STR "\" />" \
" </sequence>" \
" </sequence>" \
" </attribute>" \
" <attribute id=\"0x0100\">" \
" <text value=\"" HSP_AG_PROFILE_NAME "\" />" \
" </attribute>" \
" <attribute id=\"0x0301\" >" \
" <uint8 value=\"0x01\" />" \
" </attribute>" \
"</record>"
/* The supported features value in +BSRF command response of HFP AG in CRAS */
#define BSRF_SUPPORTED_FEATURES (AG_ENHANCED_CALL_STATUS | AG_HF_INDICATORS)
/* The "SupportedFeatures" attribute value of HFP AG service record in CRAS. */
#define SDP_SUPPORTED_FEATURES FEATURES_AG_WIDE_BAND_SPEECH
/* Object representing the audio gateway role for HFP/HSP.
* Members:
* idev - The input iodev for HFP/HSP.
* odev - The output iodev for HFP/HSP.
* info - The hfp_info object for SCO audio.
* slc_handle - The service level connection.
* device - The bt device associated with this audio gateway.
* a2dp_delay_retries - The number of retries left to delay starting
* the hfp/hsp audio gateway to wait for a2dp connection.
* conn - The dbus connection used to send message to bluetoothd.
* profile - The profile enum of this audio gateway.
*/
struct audio_gateway {
struct cras_iodev *idev;
struct cras_iodev *odev;
struct hfp_info *info;
struct hfp_slc_handle *slc_handle;
struct cras_bt_device *device;
int a2dp_delay_retries;
DBusConnection *conn;
enum cras_bt_device_profile profile;
struct audio_gateway *prev, *next;
};
static struct audio_gateway *connected_ags;
static struct packet_status_logger wbs_logger;
static int need_go_sco_pcm(struct cras_bt_device *device)
{
return cras_iodev_list_get_sco_pcm_iodev(CRAS_STREAM_INPUT) ||
cras_iodev_list_get_sco_pcm_iodev(CRAS_STREAM_OUTPUT);
}
static void destroy_audio_gateway(struct audio_gateway *ag)
{
DL_DELETE(connected_ags, ag);
cras_server_metrics_hfp_battery_indicator(
hfp_slc_get_hf_supports_battery_indicator(ag->slc_handle));
if (need_go_sco_pcm(ag->device)) {
if (ag->idev)
hfp_alsa_iodev_destroy(ag->idev);
if (ag->odev)
hfp_alsa_iodev_destroy(ag->odev);
} else {
if (ag->idev)
hfp_iodev_destroy(ag->idev);
if (ag->odev)
hfp_iodev_destroy(ag->odev);
}
if (ag->info) {
if (hfp_info_running(ag->info))
hfp_info_stop(ag->info);
hfp_info_destroy(ag->info);
}
if (ag->slc_handle)
hfp_slc_destroy(ag->slc_handle);
free(ag);
}
/* Checks if there already a audio gateway connected for device. */
static int has_audio_gateway(struct cras_bt_device *device)
{
struct audio_gateway *ag;
DL_FOREACH (connected_ags, ag) {
if (ag->device == device)
return 1;
}
return 0;
}
static void cras_hfp_ag_release(struct cras_bt_profile *profile)
{
struct audio_gateway *ag;
DL_FOREACH (connected_ags, ag)
destroy_audio_gateway(ag);
}
/* Callback triggered when SLC is initialized. */
static int cras_hfp_ag_slc_initialized(struct hfp_slc_handle *handle)
{
struct audio_gateway *ag;
DL_SEARCH_SCALAR(connected_ags, ag, slc_handle, handle);
if (!ag)
return -EINVAL;
/* Log if the hands-free device supports WBS or not. Assuming the
* codec negotiation feature means the WBS capability on headset.
*/
cras_server_metrics_hfp_wideband_support(
hfp_slc_get_hf_codec_negotiation_supported(handle));
/* Log the final selected codec given that codec negotiation is
* supported.
*/
if (hfp_slc_get_hf_codec_negotiation_supported(handle) &&
hfp_slc_get_ag_codec_negotiation_supported(handle))
cras_server_metrics_hfp_wideband_selected_codec(
hfp_slc_get_selected_codec(handle));
/* Defer the starting of audio gateway to bt_device. */
return cras_bt_device_audio_gateway_initialized(ag->device);
}
static int cras_hfp_ag_slc_disconnected(struct hfp_slc_handle *handle)
{
struct audio_gateway *ag;
DL_SEARCH_SCALAR(connected_ags, ag, slc_handle, handle);
if (!ag)
return -EINVAL;
destroy_audio_gateway(ag);
cras_bt_device_notify_profile_dropped(
ag->device, CRAS_BT_DEVICE_PROFILE_HFP_HANDSFREE);
return 0;
}
static int check_for_conflict_ag(struct cras_bt_device *new_connected)
{
struct audio_gateway *ag;
/* Check if there's already an A2DP/HFP device. */
DL_FOREACH (connected_ags, ag) {
if (cras_bt_device_has_a2dp(ag->device))
return -1;
}
/* Check if there's already an A2DP-only device. */
if (cras_a2dp_connected_device() &&
cras_bt_device_supports_profile(new_connected,
CRAS_BT_DEVICE_PROFILE_A2DP_SINK))
return -1;
return 0;
}
int cras_hfp_ag_remove_conflict(struct cras_bt_device *device)
{
struct audio_gateway *ag;
DL_FOREACH (connected_ags, ag) {
if (ag->device == device)
continue;
cras_bt_device_notify_profile_dropped(
ag->device, CRAS_BT_DEVICE_PROFILE_HFP_HANDSFREE);
destroy_audio_gateway(ag);
}
return 0;
}
static int cras_hfp_ag_new_connection(DBusConnection *conn,
struct cras_bt_profile *profile,
struct cras_bt_device *device,
int rfcomm_fd)
{
struct cras_bt_adapter *adapter;
struct audio_gateway *ag;
int ag_features;
BTLOG(btlog, BT_HFP_NEW_CONNECTION, 0, 0);
if (has_audio_gateway(device)) {
syslog(LOG_ERR,
"Audio gateway exists when %s connects for profile %s",
cras_bt_device_name(device), profile->name);
close(rfcomm_fd);
return 0;
}
if (check_for_conflict_ag(device))
return -1;
ag = (struct audio_gateway *)calloc(1, sizeof(*ag));
ag->device = device;
ag->conn = conn;
ag->profile = cras_bt_device_profile_from_uuid(profile->uuid);
adapter = cras_bt_device_adapter(device);
/*
* If the WBS enabled flag is set and adapter reports wbs capability
* then add codec negotiation feature.
* TODO(hychao): AND the two conditions to let bluetooth daemon
* control whether to turn on WBS feature.
*/
ag_features = BSRF_SUPPORTED_FEATURES;
if (cras_system_get_bt_wbs_enabled() && adapter &&
cras_bt_adapter_wbs_supported(adapter))
ag_features |= AG_CODEC_NEGOTIATION;
ag->slc_handle = hfp_slc_create(rfcomm_fd, 0, ag_features, device,
cras_hfp_ag_slc_initialized,
cras_hfp_ag_slc_disconnected);
DL_APPEND(connected_ags, ag);
return 0;
}
static void cras_hfp_ag_request_disconnection(struct cras_bt_profile *profile,
struct cras_bt_device *device)
{
struct audio_gateway *ag;
BTLOG(btlog, BT_HFP_REQUEST_DISCONNECT, 0, 0);
DL_FOREACH (connected_ags, ag) {
if (ag->slc_handle && ag->device == device) {
cras_bt_device_notify_profile_dropped(
ag->device,
CRAS_BT_DEVICE_PROFILE_HFP_HANDSFREE);
destroy_audio_gateway(ag);
}
}
}
static void cras_hfp_ag_cancel(struct cras_bt_profile *profile)
{
}
static struct cras_bt_profile cras_hfp_ag_profile = {
.name = HFP_AG_PROFILE_NAME,
.object_path = HFP_AG_PROFILE_PATH,
.uuid = HFP_AG_UUID,
.version = HFP_VERSION,
.role = NULL,
.features = SDP_SUPPORTED_FEATURES,
.record = NULL,
.release = cras_hfp_ag_release,
.new_connection = cras_hfp_ag_new_connection,
.request_disconnection = cras_hfp_ag_request_disconnection,
.cancel = cras_hfp_ag_cancel
};
int cras_hfp_ag_profile_create(DBusConnection *conn)
{
return cras_bt_add_profile(conn, &cras_hfp_ag_profile);
}
static int cras_hsp_ag_new_connection(DBusConnection *conn,
struct cras_bt_profile *profile,
struct cras_bt_device *device,
int rfcomm_fd)
{
struct audio_gateway *ag;
BTLOG(btlog, BT_HSP_NEW_CONNECTION, 0, 0);
if (has_audio_gateway(device)) {
syslog(LOG_ERR,
"Audio gateway exists when %s connects for profile %s",
cras_bt_device_name(device), profile->name);
close(rfcomm_fd);
return 0;
}
if (check_for_conflict_ag(device))
return -1;
ag = (struct audio_gateway *)calloc(1, sizeof(*ag));
ag->device = device;
ag->conn = conn;
ag->profile = cras_bt_device_profile_from_uuid(profile->uuid);
ag->slc_handle =
hfp_slc_create(rfcomm_fd, 1, BSRF_SUPPORTED_FEATURES, device,
NULL, cras_hfp_ag_slc_disconnected);
DL_APPEND(connected_ags, ag);
cras_hfp_ag_slc_initialized(ag->slc_handle);
return 0;
}
static void cras_hsp_ag_request_disconnection(struct cras_bt_profile *profile,
struct cras_bt_device *device)
{
struct audio_gateway *ag;
BTLOG(btlog, BT_HSP_REQUEST_DISCONNECT, 0, 0);
DL_FOREACH (connected_ags, ag) {
if (ag->slc_handle && ag->device == device) {
cras_bt_device_notify_profile_dropped(
ag->device, CRAS_BT_DEVICE_PROFILE_HSP_HEADSET);
destroy_audio_gateway(ag);
}
}
}
static struct cras_bt_profile cras_hsp_ag_profile = {
.name = HSP_AG_PROFILE_NAME,
.object_path = HSP_AG_PROFILE_PATH,
.uuid = HSP_AG_UUID,
.version = HSP_VERSION_1_2,
.role = NULL,
.record = HSP_AG_RECORD,
.release = cras_hfp_ag_release,
.new_connection = cras_hsp_ag_new_connection,
.request_disconnection = cras_hsp_ag_request_disconnection,
.cancel = cras_hfp_ag_cancel
};
int cras_hfp_ag_start(struct cras_bt_device *device)
{
struct audio_gateway *ag;
BTLOG(btlog, BT_AUDIO_GATEWAY_START, 0, 0);
DL_SEARCH_SCALAR(connected_ags, ag, device, device);
if (ag == NULL)
return -EEXIST;
/*
* There is chance that bluetooth stack notifies us about remote
* device's capability incrementally in multiple events. That could
* cause hfp_ag_start be called more than once. Check if the input
* HFP iodev is already created so we don't re-create HFP resources.
*/
if (ag->idev)
return 0;
if (need_go_sco_pcm(device)) {
struct cras_iodev *in_aio, *out_aio;
in_aio = cras_iodev_list_get_sco_pcm_iodev(CRAS_STREAM_INPUT);
out_aio = cras_iodev_list_get_sco_pcm_iodev(CRAS_STREAM_OUTPUT);
ag->idev = hfp_alsa_iodev_create(in_aio, ag->device,
ag->slc_handle, ag->profile);
ag->odev = hfp_alsa_iodev_create(out_aio, ag->device,
ag->slc_handle, ag->profile);
} else {
ag->info = hfp_info_create();
hfp_info_set_wbs_logger(ag->info, &wbs_logger);
ag->idev =
hfp_iodev_create(CRAS_STREAM_INPUT, ag->device,
ag->slc_handle, ag->profile, ag->info);
ag->odev =
hfp_iodev_create(CRAS_STREAM_OUTPUT, ag->device,
ag->slc_handle, ag->profile, ag->info);
}
if (!ag->idev && !ag->odev) {
destroy_audio_gateway(ag);
return -ENOMEM;
}
return 0;
}
void cras_hfp_ag_suspend_connected_device(struct cras_bt_device *device)
{
struct audio_gateway *ag;
DL_SEARCH_SCALAR(connected_ags, ag, device, device);
if (ag)
destroy_audio_gateway(ag);
}
struct hfp_slc_handle *cras_hfp_ag_get_active_handle()
{
/* Returns the first handle for HFP qualification. In future we
* might want this to return the HFP device user is selected. */
return connected_ags ? connected_ags->slc_handle : NULL;
}
struct hfp_slc_handle *cras_hfp_ag_get_slc(struct cras_bt_device *device)
{
struct audio_gateway *ag;
DL_FOREACH (connected_ags, ag) {
if (ag->device == device)
return ag->slc_handle;
}
return NULL;
}
struct packet_status_logger *cras_hfp_ag_get_wbs_logger()
{
return &wbs_logger;
}
void cras_hfp_ag_resend_device_battery_level()
{
struct audio_gateway *ag;
int level;
DL_FOREACH (connected_ags, ag) {
level = hfp_slc_get_hf_battery_level(ag->slc_handle);
if (level >= 0 && level <= 100)
cras_observer_notify_bt_battery_changed(
cras_bt_device_address(ag->device),
(uint32_t)(level));
}
}
int cras_hsp_ag_profile_create(DBusConnection *conn)
{
return cras_bt_add_profile(conn, &cras_hsp_ag_profile);
}