c49fc215ed
This change will send bearer response instead of transport failed indications. Update correct codeid and smaple rate for seamles transitions Change-Id: I4b91f5e158c02d4f2dc1852cc58cec959d028497 Signed-off-by: Balakrishna Godavarthi <quic_bgodavar@quicinc.com>
328 lines
10 KiB
C
328 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (c) 202333 Qualcomm Innovation Center, Inc. All rights reserved.
|
|
*/
|
|
|
|
#include "btfm_codec.h"
|
|
#include "btfm_codec_pkt.h"
|
|
#include "btfm_codec_btadv_interface.h"
|
|
|
|
void btfmcodec_initiate_hwep_shutdown(struct btfmcodec_char_device *btfmcodec_dev)
|
|
{
|
|
wait_queue_head_t *rsp_wait_q =
|
|
&btfmcodec_dev->rsp_wait_q[BTM_PKT_TYPE_HWEP_SHUTDOWN];
|
|
int ret;
|
|
uint8_t *status = &btfmcodec_dev->status[BTM_PKT_TYPE_HWEP_SHUTDOWN];
|
|
|
|
*status = BTM_WAITING_RSP;
|
|
BTFMCODEC_INFO("queuing work to shutdown");
|
|
schedule_work(&btfmcodec_dev->wq_hwep_shutdown);
|
|
BTFMCODEC_INFO("waiting here for shutdown");
|
|
ret = wait_event_interruptible_timeout(*rsp_wait_q,
|
|
*status != BTM_WAITING_RSP,
|
|
msecs_to_jiffies(BTM_MASTER_CONFIG_RSP_TIMEOUT));
|
|
|
|
/* Rethink of having a new packet to notify transport switch error */
|
|
if (ret == 0) {
|
|
BTFMCODEC_ERR("failed to recevie to complete hwep_shutdown");
|
|
flush_work(&btfmcodec_dev->wq_hwep_shutdown);
|
|
} else {
|
|
if (*status == BTM_RSP_RECV) {
|
|
BTFMCODEC_ERR("sucessfully closed hwep");
|
|
return;
|
|
} else if (*status == BTM_FAIL_RESP_RECV ||
|
|
*status == BTM_RSP_NOT_RECV_CLIENT_KILLED) {
|
|
BTFMCODEC_ERR("Failed to close hwep");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void btfmcodec_move_to_next_state(struct btfmcodec_state_machine *state)
|
|
{
|
|
mutex_lock(&state->state_machine_lock);
|
|
if (state->current_state == BT_Connecting ||
|
|
state->current_state == BTADV_AUDIO_Connecting) {
|
|
state->current_state += 1;
|
|
BTFMCODEC_INFO("moving from %s to %s",
|
|
coverttostring(state->current_state -1 ),
|
|
coverttostring(state->current_state));
|
|
} else {
|
|
BTFMCODEC_ERR("State machine might have gone bad. reseting to default");
|
|
state->current_state = IDLE;
|
|
}
|
|
|
|
state->prev_state = IDLE;
|
|
mutex_unlock(&state->state_machine_lock);
|
|
}
|
|
|
|
void btfmcodec_revert_current_state(struct btfmcodec_state_machine *state)
|
|
{
|
|
mutex_lock(&state->state_machine_lock);
|
|
BTFMCODEC_INFO("reverting from %s to %s", coverttostring(state->current_state),
|
|
coverttostring(state->prev_state));
|
|
state->current_state = state->prev_state;
|
|
state->prev_state = IDLE;
|
|
mutex_unlock(&state->state_machine_lock);
|
|
}
|
|
|
|
void btfmcodec_set_current_state(struct btfmcodec_state_machine *state,
|
|
btfmcodec_state current_state)
|
|
{
|
|
mutex_lock(&state->state_machine_lock);
|
|
BTFMCODEC_INFO("moving from %s to %s", coverttostring(state->current_state),
|
|
coverttostring(current_state));
|
|
state->prev_state = state->current_state;
|
|
state->current_state = current_state;
|
|
mutex_unlock(&state->state_machine_lock);
|
|
}
|
|
|
|
btfmcodec_state btfmcodec_get_current_transport(struct
|
|
btfmcodec_state_machine *state)
|
|
{
|
|
btfmcodec_state current_state;
|
|
|
|
mutex_lock(&state->state_machine_lock);
|
|
current_state = state->current_state;
|
|
mutex_unlock(&state->state_machine_lock);
|
|
return current_state;
|
|
}
|
|
|
|
int btfmcodec_frame_transport_switch_ind_pkt(struct btfmcodec_char_device *btfmcodec_dev,
|
|
uint8_t active_transport,
|
|
uint8_t status)
|
|
{
|
|
struct btm_ctrl_pkt rsp;
|
|
|
|
rsp.opcode = BTM_BTFMCODEC_TRANSPORT_SWITCH_FAILED_IND;
|
|
rsp.len = BTM_PREPARE_AUDIO_BEARER_SWITCH_RSP_LEN;
|
|
rsp.active_transport = active_transport;
|
|
rsp.status = status;
|
|
return btfmcodec_dev_enqueue_pkt(btfmcodec_dev, &rsp, (rsp.len +
|
|
BTM_HEADER_LEN));
|
|
}
|
|
|
|
int btfmcodec_frame_prepare_bearer_rsp_pkt(struct btfmcodec_char_device *btfmcodec_dev,
|
|
uint8_t active_transport,
|
|
uint8_t status)
|
|
{
|
|
struct btm_ctrl_pkt rsp;
|
|
|
|
rsp.opcode = BTM_BTFMCODEC_PREPARE_AUDIO_BEARER_SWITCH_RSP;
|
|
rsp.len =BTM_PREPARE_AUDIO_BEARER_SWITCH_RSP_LEN;
|
|
rsp.active_transport = active_transport;
|
|
rsp.status = status;
|
|
return btfmcodec_dev_enqueue_pkt(btfmcodec_dev, &rsp, (rsp.len +
|
|
BTM_HEADER_LEN));
|
|
}
|
|
|
|
int btfmcodec_wait_for_bearer_ind(struct btfmcodec_char_device *btfmcodec_dev)
|
|
{
|
|
wait_queue_head_t *rsp_wait_q =
|
|
&btfmcodec_dev->rsp_wait_q[BTM_PKT_TYPE_BEARER_SWITCH_IND];
|
|
int ret;
|
|
uint8_t *status = &btfmcodec_dev->status[BTM_PKT_TYPE_BEARER_SWITCH_IND];
|
|
|
|
*status = BTM_WAITING_RSP;
|
|
ret = wait_event_interruptible_timeout(*rsp_wait_q,
|
|
*status != BTM_WAITING_RSP,
|
|
msecs_to_jiffies(BTM_MASTER_CONFIG_RSP_TIMEOUT));
|
|
|
|
if (ret == 0) {
|
|
BTFMCODEC_ERR("failed to recevie BTM_BEARER_SWITCH_IND");
|
|
ret = -MSG_INTERNAL_TIMEOUT;
|
|
} else {
|
|
if (*status == BTM_RSP_RECV) {
|
|
ret = 0;
|
|
} else if (*status == BTM_FAIL_RESP_RECV) {
|
|
BTFMCODEC_ERR("Rx BTM_BEARER_SWITCH_IND with failure status");
|
|
ret = -1;
|
|
} else if (*status == BTM_RSP_NOT_RECV_CLIENT_KILLED) {
|
|
BTFMCODEC_ERR("client killed so moving further");
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int btfmcodec_initiate_hwep_configuration(struct btfmcodec_char_device *btfmcodec_dev)
|
|
{
|
|
wait_queue_head_t *rsp_wait_q =
|
|
&btfmcodec_dev->rsp_wait_q[BTM_PKT_TYPE_HWEP_CONFIG];
|
|
uint8_t *status = &btfmcodec_dev->status[BTM_PKT_TYPE_HWEP_CONFIG];
|
|
int ret;
|
|
|
|
schedule_work(&btfmcodec_dev->wq_hwep_configure);
|
|
|
|
*status = BTM_WAITING_RSP;
|
|
ret = wait_event_interruptible_timeout(*rsp_wait_q,
|
|
*status != BTM_WAITING_RSP,
|
|
msecs_to_jiffies(BTM_MASTER_CONFIG_RSP_TIMEOUT));
|
|
|
|
if (ret == 0) {
|
|
BTFMCODEC_ERR("failed to recevie complete hwep configure");
|
|
flush_work(&btfmcodec_dev->wq_hwep_configure);
|
|
ret = -1;
|
|
} else {
|
|
if (*status == BTM_RSP_RECV) {
|
|
ret = 0;
|
|
} else if (*status == BTM_FAIL_RESP_RECV ||
|
|
*status == BTM_RSP_NOT_RECV_CLIENT_KILLED) {
|
|
BTFMCODEC_ERR("Failed to close hwep moving back to previous state");
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void btfmcodec_configure_hwep(struct btfmcodec_char_device *btfmcodec_dev)
|
|
{
|
|
struct btfmcodec_data *btfmcodec = (struct btfmcodec_data *)btfmcodec_dev->btfmcodec;
|
|
struct btfmcodec_state_machine *state = &btfmcodec->states;
|
|
int ret;
|
|
uint8_t status = MSG_SUCCESS;
|
|
|
|
ret = btfmcodec_initiate_hwep_configuration(btfmcodec_dev);
|
|
if (ret < 0) {
|
|
status = MSG_FAILED_TO_CONFIGURE_HWEP;
|
|
/* Move back to BTADV_AUDIO_Connected from BT_Connecting */
|
|
btfmcodec_revert_current_state(state);
|
|
}
|
|
|
|
ret = btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
btfmcodec_get_current_transport(state), status);
|
|
|
|
if (status != MSG_SUCCESS)
|
|
return;
|
|
|
|
if (ret < 0) {
|
|
ret = btfmcodec_wait_for_bearer_ind(btfmcodec_dev);
|
|
if (ret < 0) {
|
|
/* Move back to BTADV_AUDIO_Connected for failure cases*/
|
|
BTFMCODEC_ERR("moving back to previous state");
|
|
btfmcodec_revert_current_state(state);
|
|
/* close HWEP */
|
|
btfmcodec_initiate_hwep_shutdown(btfmcodec_dev);
|
|
if (ret == -MSG_INTERNAL_TIMEOUT) {
|
|
btfmcodec_frame_transport_switch_ind_pkt(btfmcodec_dev, BT,
|
|
MSG_INTERNAL_TIMEOUT);
|
|
}
|
|
} else {
|
|
/* move from BT_Connecting to BT_Connected */
|
|
btfmcodec_move_to_next_state(state);
|
|
}
|
|
} else {
|
|
/* add code to handle packet errors */
|
|
}
|
|
}
|
|
|
|
void btfmcodec_prepare_bearer(struct btfmcodec_char_device *btfmcodec_dev,
|
|
enum transport_type new_transport)
|
|
{
|
|
struct btfmcodec_data *btfmcodec = (struct btfmcodec_data *)btfmcodec_dev->btfmcodec;
|
|
struct btfmcodec_state_machine *state = &btfmcodec->states;
|
|
btfmcodec_state current_state;
|
|
int ret = -1;
|
|
|
|
if (new_transport > (ARRAY_SIZE(transport_type_text))) {
|
|
btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
(uint8_t) btfmcodec_get_current_transport(state),
|
|
MSG_WRONG_TRANSPORT_TYPE);
|
|
return;
|
|
}
|
|
|
|
BTFMCODEC_INFO("Rx to switch from transport type %s to %s",
|
|
coverttostring(btfmcodec_get_current_transport(state)),
|
|
transport_type_text[new_transport - 1]);
|
|
|
|
current_state = btfmcodec_get_current_transport(state);
|
|
if (new_transport == BT) {
|
|
/* If BT is already active. send +ve ack to BTADV Audio Manager */
|
|
if (current_state == BT_Connected ||
|
|
current_state == BT_Connecting) {
|
|
btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
(uint8_t)current_state, MSG_SUCCESS);
|
|
return;
|
|
} else if (current_state == BTADV_AUDIO_Connected ||
|
|
current_state == BTADV_AUDIO_Connecting||
|
|
current_state == IDLE) {
|
|
if (btfmcodec_is_valid_cache_avb(btfmcodec)) {
|
|
BTFMCODEC_INFO("detected BTADV audio Gaming usecase to BT usecase");
|
|
btfmcodec_set_current_state(state, BT_Connecting);
|
|
btfmcodec_configure_hwep(btfmcodec_dev);
|
|
} else {
|
|
if (current_state != IDLE)
|
|
BTFMCODEC_INFO("detected BTADV Audio lossless to IDLE");
|
|
BTFMCODEC_INFO("moving to IDLE as no config available");
|
|
btfmcodec_set_current_state(state, IDLE);
|
|
btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
btfmcodec_get_current_transport(state),
|
|
MSG_SUCCESS);
|
|
/* No need wait for bearer switch indications as BTFMCODEC
|
|
* driver doesn't have configs to configure
|
|
*/
|
|
}
|
|
}
|
|
} else if(new_transport == BTADV) {
|
|
/* If BTADV audio is already active. send +ve ack to BTADV audio Manager */
|
|
if (current_state == BTADV_AUDIO_Connecting ||
|
|
current_state == BTADV_AUDIO_Connected) {
|
|
btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
(uint8_t)current_state, MSG_SUCCESS);
|
|
return;
|
|
} else {
|
|
btfmcodec_set_current_state(state, BTADV_AUDIO_Connecting);
|
|
if (btfmcodec_is_valid_cache_avb(btfmcodec)) {
|
|
BTFMCODEC_INFO("detected BT to BTADV audio Gaming usecase");
|
|
} else {
|
|
BTFMCODEC_INFO("detected IDLE to BTADV audio lossless usecase");
|
|
}
|
|
|
|
ret = btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev,
|
|
BTADV_AUDIO_Connecting, MSG_SUCCESS);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
/* Wait here to get Bearer switch indication */
|
|
ret = btfmcodec_wait_for_bearer_ind(btfmcodec_dev);
|
|
if (ret < 0) {
|
|
BTFMCODEC_ERR("moving back to previous state");
|
|
btfmcodec_revert_current_state(state);
|
|
if (ret == -MSG_INTERNAL_TIMEOUT) {
|
|
btfmcodec_frame_transport_switch_ind_pkt(
|
|
btfmcodec_dev, BTADV,
|
|
MSG_INTERNAL_TIMEOUT);
|
|
}
|
|
} else {
|
|
btfmcodec_move_to_next_state(state);
|
|
}
|
|
if (ret < 0)
|
|
return;
|
|
|
|
if (btfmcodec_is_valid_cache_avb(btfmcodec)) {
|
|
BTFMCODEC_INFO("Initiating BT port close...");
|
|
btfmcodec_initiate_hwep_shutdown(btfmcodec_dev);
|
|
}
|
|
}
|
|
} else if (new_transport == NONE) {
|
|
/* Let ALSA handles the transport close for BT */
|
|
if (current_state != BT_Connecting && current_state != BT_Connected)
|
|
btfmcodec_set_current_state(state, IDLE);
|
|
btfmcodec_frame_prepare_bearer_rsp_pkt(btfmcodec_dev, (uint8_t)current_state,
|
|
MSG_SUCCESS);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void btfmcodec_wq_prepare_bearer(struct work_struct *work)
|
|
{
|
|
struct btfmcodec_char_device *btfmcodec_dev = container_of(work,
|
|
struct btfmcodec_char_device,
|
|
wq_prepare_bearer);
|
|
int idx = BTM_PKT_TYPE_PREPARE_REQ;
|
|
BTFMCODEC_INFO(": with new transport:%d", btfmcodec_dev->status[idx]);
|
|
btfmcodec_prepare_bearer(btfmcodec_dev, btfmcodec_dev->status[idx]);
|
|
}
|