1/****************************************************************************** 2 * 3 * Copyright (C) 2016 The Android Open Source Project 4 * Copyright (C) 2009-2012 Broadcom Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at: 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 ******************************************************************************/ 19 20#define LOG_TAG "bt_btif_a2dp_control" 21 22#include <base/logging.h> 23#include <stdbool.h> 24#include <stdint.h> 25 26#include "audio_a2dp_hw/include/audio_a2dp_hw.h" 27#include "bt_common.h" 28#include "btif_a2dp.h" 29#include "btif_a2dp_control.h" 30#include "btif_a2dp_sink.h" 31#include "btif_a2dp_source.h" 32#include "btif_av.h" 33#include "btif_av_co.h" 34#include "btif_hf.h" 35#include "osi/include/osi.h" 36#include "uipc.h" 37 38#define A2DP_DATA_READ_POLL_MS 10 39 40static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); 41static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event); 42 43/* We can have max one command pending */ 44static tA2DP_CTRL_CMD a2dp_cmd_pending = A2DP_CTRL_CMD_NONE; 45 46void btif_a2dp_control_init(void) { 47 UIPC_Init(NULL); 48 UIPC_Open(UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb); 49} 50 51void btif_a2dp_control_cleanup(void) { 52 /* This calls blocks until UIPC is fully closed */ 53 UIPC_Close(UIPC_CH_ID_ALL); 54} 55 56static void btif_a2dp_recv_ctrl_data(void) { 57 tA2DP_CTRL_CMD cmd = A2DP_CTRL_CMD_NONE; 58 int n; 59 60 uint8_t read_cmd = 0; /* The read command size is one octet */ 61 n = UIPC_Read(UIPC_CH_ID_AV_CTRL, NULL, &read_cmd, 1); 62 cmd = static_cast<tA2DP_CTRL_CMD>(read_cmd); 63 64 /* detach on ctrl channel means audioflinger process was terminated */ 65 if (n == 0) { 66 APPL_TRACE_EVENT("CTRL CH DETACHED"); 67 UIPC_Close(UIPC_CH_ID_AV_CTRL); 68 return; 69 } 70 71 APPL_TRACE_DEBUG("a2dp-ctrl-cmd : %s", audio_a2dp_hw_dump_ctrl_event(cmd)); 72 a2dp_cmd_pending = cmd; 73 74 switch (cmd) { 75 case A2DP_CTRL_CMD_CHECK_READY: 76 if (btif_a2dp_source_media_task_is_shutting_down()) { 77 APPL_TRACE_WARNING("%s: A2DP command %s while media task shutting down", 78 __func__, audio_a2dp_hw_dump_ctrl_event(cmd)); 79 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 80 return; 81 } 82 83 /* check whether AV is ready to setup A2DP datapath */ 84 if (btif_av_stream_ready() || btif_av_stream_started_ready()) { 85 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 86 } else { 87 APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready", 88 __func__, audio_a2dp_hw_dump_ctrl_event(cmd)); 89 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 90 } 91 break; 92 93 case A2DP_CTRL_CMD_START: 94 /* 95 * Don't send START request to stack while we are in a call. 96 * Some headsets such as "Sony MW600", don't allow AVDTP START 97 * while in a call, and respond with BAD_STATE. 98 */ 99 if (!btif_hf_is_call_idle()) { 100 btif_a2dp_command_ack(A2DP_CTRL_ACK_INCALL_FAILURE); 101 break; 102 } 103 104 if (btif_a2dp_source_is_streaming()) { 105 APPL_TRACE_WARNING("%s: A2DP command %s while source is streaming", 106 __func__, audio_a2dp_hw_dump_ctrl_event(cmd)); 107 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 108 break; 109 } 110 111 if (btif_av_stream_ready()) { 112 /* Setup audio data channel listener */ 113 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb); 114 115 /* 116 * Post start event and wait for audio path to open. 117 * If we are the source, the ACK will be sent after the start 118 * procedure is completed, othewise send it now. 119 */ 120 btif_dispatch_sm_event(BTIF_AV_START_STREAM_REQ_EVT, NULL, 0); 121 if (btif_av_get_peer_sep() == AVDT_TSEP_SRC) 122 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 123 break; 124 } 125 126 if (btif_av_stream_started_ready()) { 127 /* 128 * Already started, setup audio data channel listener and ACK 129 * back immediately. 130 */ 131 UIPC_Open(UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb); 132 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 133 break; 134 } 135 APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready", 136 __func__, audio_a2dp_hw_dump_ctrl_event(cmd)); 137 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 138 break; 139 140 case A2DP_CTRL_CMD_STOP: 141 if (btif_av_get_peer_sep() == AVDT_TSEP_SNK && 142 !btif_a2dp_source_is_streaming()) { 143 /* We are already stopped, just ack back */ 144 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 145 break; 146 } 147 148 btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0); 149 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 150 break; 151 152 case A2DP_CTRL_CMD_SUSPEND: 153 /* Local suspend */ 154 if (btif_av_stream_started_ready()) { 155 btif_dispatch_sm_event(BTIF_AV_SUSPEND_STREAM_REQ_EVT, NULL, 0); 156 break; 157 } 158 /* If we are not in started state, just ack back ok and let 159 * audioflinger close the channel. This can happen if we are 160 * remotely suspended, clear REMOTE SUSPEND flag. 161 */ 162 btif_av_clear_remote_suspend_flag(); 163 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 164 break; 165 166 case A2DP_CTRL_GET_INPUT_AUDIO_CONFIG: { 167 tA2DP_SAMPLE_RATE sample_rate = btif_a2dp_sink_get_sample_rate(); 168 tA2DP_CHANNEL_COUNT channel_count = btif_a2dp_sink_get_channel_count(); 169 170 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 171 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<uint8_t*>(&sample_rate), 172 sizeof(tA2DP_SAMPLE_RATE)); 173 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &channel_count, 174 sizeof(tA2DP_CHANNEL_COUNT)); 175 break; 176 } 177 178 case A2DP_CTRL_GET_OUTPUT_AUDIO_CONFIG: { 179 btav_a2dp_codec_config_t codec_config; 180 btav_a2dp_codec_config_t codec_capability; 181 codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 182 codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 183 codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 184 codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 185 codec_capability.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 186 codec_capability.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 187 188 A2dpCodecConfig* current_codec = bta_av_get_a2dp_current_codec(); 189 if (current_codec != nullptr) { 190 codec_config = current_codec->getCodecConfig(); 191 codec_capability = current_codec->getCodecCapability(); 192 } 193 194 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 195 // Send the current codec config 196 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, 197 reinterpret_cast<const uint8_t*>(&codec_config.sample_rate), 198 sizeof(btav_a2dp_codec_sample_rate_t)); 199 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, 200 reinterpret_cast<const uint8_t*>(&codec_config.bits_per_sample), 201 sizeof(btav_a2dp_codec_bits_per_sample_t)); 202 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, 203 reinterpret_cast<const uint8_t*>(&codec_config.channel_mode), 204 sizeof(btav_a2dp_codec_channel_mode_t)); 205 // Send the current codec capability 206 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, 207 reinterpret_cast<const uint8_t*>(&codec_capability.sample_rate), 208 sizeof(btav_a2dp_codec_sample_rate_t)); 209 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<const uint8_t*>( 210 &codec_capability.bits_per_sample), 211 sizeof(btav_a2dp_codec_bits_per_sample_t)); 212 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, reinterpret_cast<const uint8_t*>( 213 &codec_capability.channel_mode), 214 sizeof(btav_a2dp_codec_channel_mode_t)); 215 break; 216 } 217 218 case A2DP_CTRL_SET_OUTPUT_AUDIO_CONFIG: { 219 btav_a2dp_codec_config_t codec_config; 220 codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE; 221 codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE; 222 codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE; 223 224 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 225 // Send the current codec config 226 if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0, 227 reinterpret_cast<uint8_t*>(&codec_config.sample_rate), 228 sizeof(btav_a2dp_codec_sample_rate_t)) != 229 sizeof(btav_a2dp_codec_sample_rate_t)) { 230 APPL_TRACE_ERROR("Error reading sample rate from audio HAL"); 231 break; 232 } 233 if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0, 234 reinterpret_cast<uint8_t*>(&codec_config.bits_per_sample), 235 sizeof(btav_a2dp_codec_bits_per_sample_t)) != 236 sizeof(btav_a2dp_codec_bits_per_sample_t)) { 237 APPL_TRACE_ERROR("Error reading bits per sample from audio HAL"); 238 break; 239 } 240 if (UIPC_Read(UIPC_CH_ID_AV_CTRL, 0, 241 reinterpret_cast<uint8_t*>(&codec_config.channel_mode), 242 sizeof(btav_a2dp_codec_channel_mode_t)) != 243 sizeof(btav_a2dp_codec_channel_mode_t)) { 244 APPL_TRACE_ERROR("Error reading channel mode from audio HAL"); 245 break; 246 } 247 APPL_TRACE_DEBUG( 248 "%s: A2DP_CTRL_SET_OUTPUT_AUDIO_CONFIG: " 249 "sample_rate=0x%x bits_per_sample=0x%x " 250 "channel_mode=0x%x", 251 __func__, codec_config.sample_rate, codec_config.bits_per_sample, 252 codec_config.channel_mode); 253 btif_a2dp_source_feeding_update_req(codec_config); 254 break; 255 } 256 257 case A2DP_CTRL_CMD_OFFLOAD_START: 258 btif_dispatch_sm_event(BTIF_AV_OFFLOAD_START_REQ_EVT, NULL, 0); 259 break; 260 261 default: 262 APPL_TRACE_ERROR("UNSUPPORTED CMD (%d)", cmd); 263 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 264 break; 265 } 266 APPL_TRACE_DEBUG("a2dp-ctrl-cmd : %s DONE", 267 audio_a2dp_hw_dump_ctrl_event(cmd)); 268} 269 270static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, 271 tUIPC_EVENT event) { 272 APPL_TRACE_DEBUG("A2DP-CTRL-CHANNEL EVENT %s", dump_uipc_event(event)); 273 274 switch (event) { 275 case UIPC_OPEN_EVT: 276 break; 277 278 case UIPC_CLOSE_EVT: 279 /* restart ctrl server unless we are shutting down */ 280 if (btif_a2dp_source_media_task_is_running()) 281 UIPC_Open(UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb); 282 break; 283 284 case UIPC_RX_DATA_READY_EVT: 285 btif_a2dp_recv_ctrl_data(); 286 break; 287 288 default: 289 APPL_TRACE_ERROR("### A2DP-CTRL-CHANNEL EVENT %d NOT HANDLED ###", event); 290 break; 291 } 292} 293 294static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id, 295 tUIPC_EVENT event) { 296 APPL_TRACE_DEBUG("BTIF MEDIA (A2DP-DATA) EVENT %s", dump_uipc_event(event)); 297 298 switch (event) { 299 case UIPC_OPEN_EVT: 300 /* 301 * Read directly from media task from here on (keep callback for 302 * connection events. 303 */ 304 UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_REMOVE_ACTIVE_READSET, NULL); 305 UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO, 306 reinterpret_cast<void*>(A2DP_DATA_READ_POLL_MS)); 307 308 if (btif_av_get_peer_sep() == AVDT_TSEP_SNK) { 309 /* Start the media task to encode the audio */ 310 btif_a2dp_source_start_audio_req(); 311 } 312 313 /* ACK back when media task is fully started */ 314 break; 315 316 case UIPC_CLOSE_EVT: 317 APPL_TRACE_EVENT("## AUDIO PATH DETACHED ##"); 318 btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS); 319 /* 320 * Send stop request only if we are actively streaming and haven't 321 * received a stop request. Potentially, the audioflinger detached 322 * abnormally. 323 */ 324 if (btif_a2dp_source_is_streaming()) { 325 /* Post stop event and wait for audio path to stop */ 326 btif_dispatch_sm_event(BTIF_AV_STOP_STREAM_REQ_EVT, NULL, 0); 327 } 328 break; 329 330 default: 331 APPL_TRACE_ERROR("### A2DP-DATA EVENT %d NOT HANDLED ###", event); 332 break; 333 } 334} 335 336void btif_a2dp_command_ack(tA2DP_CTRL_ACK status) { 337 uint8_t ack = status; 338 339 APPL_TRACE_EVENT("## a2dp ack : %s, status %d ##", 340 audio_a2dp_hw_dump_ctrl_event(a2dp_cmd_pending), status); 341 342 /* Sanity check */ 343 if (a2dp_cmd_pending == A2DP_CTRL_CMD_NONE) { 344 APPL_TRACE_ERROR("warning : no command pending, ignore ack"); 345 return; 346 } 347 348 /* Clear pending */ 349 a2dp_cmd_pending = A2DP_CTRL_CMD_NONE; 350 351 /* Acknowledge start request */ 352 UIPC_Send(UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack)); 353} 354