path: root/src/bt_vendor_brcm_a2dp.c

/******************************************************************************
 *
 *  Copyright (C) 2015 Motorola Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *  This is the stream state machine for the BRCM offloaded advanced audio.
 *
 ******************************************************************************/

#define LOG_TAG "bt_vnd_a2dp"
#define LOG_NDEBUG 0

#include <string.h>
#include <pthread.h>
#include <utils/Log.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <dirent.h>
#include <ctype.h>
#include <cutils/properties.h>
#include <stdlib.h>
#include "bt_hci_bdroid.h"
#include "bt_vendor_brcm_a2dp.h"
#include "a2d_api.h"
#include "a2d_sbc.h"

#if (BTA2DP_DEBUG == TRUE)
#define BTA2DPDBG(param, ...) {ALOGD(param, ## __VA_ARGS__);}
#else
#define BTA2DPDBG(param, ...) {}
#endif

/*****************************************************************************
** Constants and types
*****************************************************************************/

typedef void (*hci_cback)(void *);

typedef enum
{
    BRCM_VND_A2DP_OFFLOAD_INIT_REQ,
    BRCM_VND_A2DP_OFFLOAD_START_REQ,
    BRCM_VND_A2DP_OFFLOAD_STOP_REQ,
    BRCM_VND_UIPC_OPEN_RSP,
    BRCM_VND_L2C_SYNC_TO_LITE_RSP,
    BRCM_VND_SYNC_TO_BTC_LITE_RSP,
    BRCM_VND_AUDIO_CODEC_CONFIG_RSP,
    BRCM_VND_AUDIO_ROUTE_CONFIG_RSP,
    BRCM_VND_UIPC_CLOSE_RSP,
    BRCM_VND_L2C_REMOVE_TO_LITE_RSP,
    BRCM_VND_A2DP_START_RSP,
    BRCM_VND_A2DP_SUSPEND_RSP,
    BRCM_VND_STREAM_STOP_RSP,
    BRCM_VND_A2DP_CLEANUP_RSP,
    BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT,
} tBRCM_VND_A2DP_EVENT;

/* state machine states */
typedef enum
{
    BRCM_VND_A2DP_INVALID_SST = -1,
    BRCM_VND_A2DP_IDLE_SST,
    BRCM_VND_A2DP_STARTING_SST,
    BRCM_VND_A2DP_STREAM_SST,
}
tBRCM_VND_A2DP_SST_STATES;

static uint8_t brcm_vnd_a2dp_offload_cleanup();
static uint8_t brcm_vnd_a2dp_offload_suspend();
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_idle_enter(tBRCM_VND_A2DP_EVENT event);
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_starting_enter(tBRCM_VND_A2DP_EVENT event);
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_stream_enter(tBRCM_VND_A2DP_EVENT event);
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_idle_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data);
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_starting_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data);
static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_stream_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data);
static void brcm_vnd_a2dp_hci_uipc_cback(void *pmem);

typedef struct {
    uint8_t        fcn;
    uint32_t    pad_conf;
}
tBRCM_VND_PCM_CONF;

typedef struct {
    tBRCM_VND_A2DP_SST_STATES state;
    tCODEC_INFO_SBC codec_info;
    tBRCM_VND_PCM_CONF pcmi2s_pinmux;
    bt_vendor_op_a2dp_offload_t offload_params;
}
tBRCM_VND_A2DP_PDATA;

typedef struct {
    tBRCM_VND_A2DP_SST_STATES (*enter)(tBRCM_VND_A2DP_EVENT event);
    tBRCM_VND_A2DP_SST_STATES (*process_event)(tBRCM_VND_A2DP_EVENT event, void *ev_data);
}
tBRCM_VND_A2DP_SST_STATE;

/* state table */
static tBRCM_VND_A2DP_SST_STATE brcm_vnd_a2dp_sst_tbl[] =
{
    {brcm_vnd_a2dp_sm_idle_enter,     brcm_vnd_a2dp_sm_idle_process_ev},
    {brcm_vnd_a2dp_sm_starting_enter, brcm_vnd_a2dp_sm_starting_process_ev},
    {brcm_vnd_a2dp_sm_stream_enter,   brcm_vnd_a2dp_sm_stream_process_ev},
};

static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
static tBRCM_VND_A2DP_PDATA brcm_vnd_a2dp_pdata = { .state = BRCM_VND_A2DP_INVALID_SST };


/*******************************************************************************
** Local Utility Functions
*******************************************************************************/

static void log_bin_to_hexstr(uint8_t *bin, uint8_t binsz, const char *log_tag)
{
#if (BTA2DP_DEBUG == TRUE)
  char     *str, hex_str[]= "0123456789abcdef";
  uint8_t  i;

  str = (char *)malloc(binsz * 3);
  if (!binsz) {
    ALOGE("%s alloc failed", __FUNCTION__);
    return;
  }

  for (i = 0; i < binsz; i++) {
      str[(i * 3) + 0] = hex_str[(bin[i] >> 4) & 0x0F];
      str[(i * 3) + 1] = hex_str[(bin[i]     ) & 0x0F];
      str[(i * 3) + 2] = ' ';
  }
  str[(binsz * 3) - 1] = 0x00;
  BTA2DPDBG("%s %s", log_tag, str);
#endif
}

static uint8_t brcm_vnd_a2dp_send_hci_vsc(uint16_t cmd, uint8_t *payload, uint8_t len, hci_cback cback)
{
    HC_BT_HDR   *p_buf;
    uint8_t     *p, status;
    uint16_t    opcode;

    // Perform Opening configure cmds. //
    if (bt_vendor_cbacks) {
        p_buf = (HC_BT_HDR *)bt_vendor_cbacks->alloc(
            BT_HC_HDR_SIZE + HCI_CMD_PREAMBLE_SIZE + len);
        if (p_buf)
        {
            p_buf->event = MSG_STACK_TO_HC_HCI_CMD;
            p_buf->offset = 0;
            p_buf->layer_specific = 0;
            p_buf->len = HCI_CMD_PREAMBLE_SIZE + len;
            p = (uint8_t *)(p_buf + 1);

            UINT16_TO_STREAM(p, cmd);
            *p++ = len;
            memcpy(p, payload, len);

            //BTA2DPDBG("%s Cmd %04x UIPC Event %02x%02x UIPC Op %02x Len %d", __FUNCTION__, cmd, event, payload[1], payload[0], payload[2], len);    
            log_bin_to_hexstr((uint8_t *)(p_buf + 1), HCI_CMD_PREAMBLE_SIZE + len, __FUNCTION__);

            if (bt_vendor_cbacks->xmit_cb(cmd, p_buf, cback))
            {
                return BT_VND_OP_RESULT_SUCCESS;
            }
            bt_vendor_cbacks->dealloc(p_buf);
        }
    }
    return BT_VND_OP_RESULT_FAIL;
}

static void brcm_vnd_map_a2d_uipc_codec_info(tCODEC_INFO_SBC *codec_info)
{
    switch(codec_info->sampling_freq) {
        case A2D_SBC_IE_SAMP_FREQ_16:
            codec_info->sampling_freq = CODEC_INFO_SBC_SF_16K; break;
        case A2D_SBC_IE_SAMP_FREQ_32:
            codec_info->sampling_freq = CODEC_INFO_SBC_SF_32K; break;
        case A2D_SBC_IE_SAMP_FREQ_44:
            codec_info->sampling_freq = CODEC_INFO_SBC_SF_44K; break;
        case A2D_SBC_IE_SAMP_FREQ_48:
            codec_info->sampling_freq = CODEC_INFO_SBC_SF_48K; break;

    }
    switch(codec_info->channel_mode) {
        case A2D_SBC_IE_CH_MD_MONO:
            codec_info->channel_mode = CODEC_INFO_SBC_CH_MONO; break;
        case A2D_SBC_IE_CH_MD_DUAL:
            codec_info->channel_mode = CODEC_INFO_SBC_CH_DUAL; break;
        case A2D_SBC_IE_CH_MD_STEREO:
            codec_info->channel_mode = CODEC_INFO_SBC_CH_STEREO; break;
        case A2D_SBC_IE_CH_MD_JOINT:
            codec_info->channel_mode = CODEC_INFO_SBC_CH_JS; break;
    }
    switch(codec_info->block_length) {
        case A2D_SBC_IE_BLOCKS_4:
            codec_info->block_length = CODEC_INFO_SBC_BLOCK_4; break;
        case A2D_SBC_IE_BLOCKS_8:
            codec_info->block_length = CODEC_INFO_SBC_BLOCK_8; break;
        case A2D_SBC_IE_BLOCKS_12:
            codec_info->block_length = CODEC_INFO_SBC_BLOCK_12; break;
        case A2D_SBC_IE_BLOCKS_16:
            codec_info->block_length = CODEC_INFO_SBC_BLOCK_16; break;
    }
    switch(codec_info->alloc_method) {
        case A2D_SBC_IE_ALLOC_MD_S:
            codec_info->alloc_method = CODEC_INFO_SBC_ALLOC_SNR; break;
        case A2D_SBC_IE_ALLOC_MD_L:
            codec_info->alloc_method = CODEC_INFO_SBC_ALLOC_LOUDNESS; break;
    }
    switch(codec_info->num_subbands) {
        case A2D_SBC_IE_SUBBAND_4:
            codec_info->num_subbands = CODEC_INFO_SBC_SUBBAND_4; break;
        case A2D_SBC_IE_SUBBAND_8:
            codec_info->num_subbands = CODEC_INFO_SBC_SUBBAND_8; break;
    }
}

static tA2D_STATUS bcrm_vnd_a2dp_parse_codec_info(tCODEC_INFO_SBC *parsed_info, uint8_t *codec_info)
{
    tA2D_STATUS status = A2D_SUCCESS;
    UINT8   losc;
    UINT8   mt;

    BTA2DPDBG("%s", __FUNCTION__);

    if( parsed_info == NULL || codec_info == NULL)
        status = A2D_FAIL;
    else
    {
        losc    = *codec_info++;
        mt      = *codec_info++;
        /* If the function is called for the wrong Media Type or Media Codec Type */
        if(losc != A2D_SBC_INFO_LEN || *codec_info != A2D_MEDIA_CT_SBC)
            status = A2D_WRONG_CODEC;
        else
        {
            codec_info++;
            parsed_info->sampling_freq = *codec_info & A2D_SBC_IE_SAMP_FREQ_MSK;
            parsed_info->channel_mode  = *codec_info & A2D_SBC_IE_CH_MD_MSK;
            codec_info++;
            parsed_info->block_length  = *codec_info & A2D_SBC_IE_BLOCKS_MSK;
            parsed_info->num_subbands  = *codec_info & A2D_SBC_IE_SUBBAND_MSK;
            parsed_info->alloc_method  = *codec_info & A2D_SBC_IE_ALLOC_MD_MSK;
            codec_info += 2;
            parsed_info->bitpool_size  = *codec_info; // MAX BITPOOL //

            if(MULTI_BIT_SET(parsed_info->sampling_freq))
                status = A2D_BAD_SAMP_FREQ;
            if(MULTI_BIT_SET(parsed_info->channel_mode))
                status = A2D_BAD_CH_MODE;
            if(MULTI_BIT_SET(parsed_info->block_length))
                status = A2D_BAD_BLOCK_LEN;
            if(MULTI_BIT_SET(parsed_info->num_subbands))
                status = A2D_BAD_SUBBANDS;
            if(MULTI_BIT_SET(parsed_info->alloc_method))
                status = A2D_BAD_ALLOC_MTHD;
            if(parsed_info->bitpool_size < A2D_SBC_IE_MIN_BITPOOL || parsed_info->bitpool_size > A2D_SBC_IE_MAX_BITPOOL )
                status = A2D_BAD_MIN_BITPOOL;

            if(status == A2D_SUCCESS)
                brcm_vnd_map_a2d_uipc_codec_info(parsed_info);

            BTA2DPDBG("%s STATUS %d parsed info : SampF %02x, ChnMode %02x, BlockL %02x, NSubB %02x, alloc %02x, bitpool %02x",
                __FUNCTION__, status, parsed_info->sampling_freq, parsed_info->channel_mode, parsed_info->block_length,
                parsed_info->num_subbands, parsed_info->alloc_method, parsed_info->bitpool_size);

        }
    }
    return status;
}

/*******************************************************************************
** State Machine Functions
*******************************************************************************/

/*******************************************************************************
**
** Function         brcm_vnd_a2dp_ssm_execute
**
** Description      Stream state machine event handling function for AV
**
**
** Returns          void
**
*******************************************************************************/
int brcm_vnd_a2dp_ssm_execute(tBRCM_VND_A2DP_EVENT event, void *ev_data)
{
    tBRCM_VND_A2DP_SST_STATE *state_table;
    tBRCM_VND_A2DP_SST_STATES next_state;

    BTA2DPDBG("%s ev %d state %d", __FUNCTION__, event, brcm_vnd_a2dp_pdata.state);

    pthread_mutex_lock(&g_mutex);

    if (brcm_vnd_a2dp_pdata.state != BRCM_VND_A2DP_INVALID_SST) {
        state_table = &brcm_vnd_a2dp_sst_tbl[brcm_vnd_a2dp_pdata.state];
        /* process event */
        next_state = state_table->process_event(event, ev_data);
    } else if (BRCM_VND_A2DP_OFFLOAD_INIT_REQ == event) {
        next_state = BRCM_VND_A2DP_IDLE_SST;
    }
    else {
        pthread_mutex_unlock(&g_mutex);
        return BT_VND_OP_RESULT_FAIL;
    }

    /* transition stae */
    while (next_state != brcm_vnd_a2dp_pdata.state) {
        brcm_vnd_a2dp_pdata.state = next_state;
        state_table = &brcm_vnd_a2dp_sst_tbl[next_state];
        if (state_table->enter)
            next_state = state_table->enter(event);
    }

    pthread_mutex_unlock(&g_mutex);
    return BT_VND_OP_RESULT_SUCCESS;
}

/* state machine actions */

static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_idle_enter(tBRCM_VND_A2DP_EVENT event)
{
    UNUSED(event);
    BTA2DPDBG("%s", __FUNCTION__);
    brcm_vnd_a2dp_pdata.pcmi2s_pinmux.fcn = PCM_PIN_FCN_INVALID;
    return brcm_vnd_a2dp_pdata.state;
}

static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_starting_enter(tBRCM_VND_A2DP_EVENT event)
{
    UNUSED(event);
    uint8_t *p, msg_req[HCI_CMD_MAX_LEN];
    BTA2DPDBG("%s", __FUNCTION__);

    p = msg_req;
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_READ_PCM_PINS, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT8_TO_STREAM(p, BRCM_A2DP_OFFLOAD_PCM_PIN_FCN);
    UINT32_TO_STREAM(p, BRCM_A2DP_OFFLOAD_PCM_PIN_PADCNF);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_WRITE_PCM_PINS, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_MGMT_EVT);
    UINT8_TO_STREAM(p, UIPC_OPEN_REQ);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_L2C_EVT);
    UINT8_TO_STREAM(p, L2C_SYNC_TO_LITE_REQ);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.xmit_quota);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.acl_data_size);
    UINT16_TO_STREAM(p, !(brcm_vnd_a2dp_pdata.offload_params.is_flushable));
    UINT8_TO_STREAM(p, 0x02); //multi_av_data_cong_start
    UINT8_TO_STREAM(p, 0x00); //multi_av_data_cong_end
    UINT8_TO_STREAM(p, 0x04); //multi_av_data_cong_discard
    UINT8_TO_STREAM(p, 1); //num_stream
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.remote_cid);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.stream_mtu);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.lm_handle);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.xmit_quota);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.is_flushable);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_AVDT_EVT);
    UINT8_TO_STREAM(p, AVDT_SYNC_TO_BTC_LITE_REQ);
    UINT8_TO_STREAM(p, 1); //num_stream
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    UINT32_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.stream_source);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_BTM_EVT);
    UINT8_TO_STREAM(p, AUDIO_ROUTE_CONFIG_REQ);
    UINT8_TO_STREAM(p, BRCM_A2DP_OFFLOAD_SRC);
    UINT8_TO_STREAM(p, BRCM_A2DP_OFFLOAD_SRC_SF);
    UINT8_TO_STREAM(p, AUDIO_ROUTE_OUT_BTA2DP);
    UINT8_TO_STREAM(p, BRCM_A2DP_OFFLOAD_SRC_SF);
    UINT8_TO_STREAM(p, AUDIO_ROUTE_SF_NA);
    UINT8_TO_STREAM(p, AUDIO_ROUTE_EQ_BYPASS);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_BTM_EVT);
    UINT8_TO_STREAM(p, AUDIO_CODEC_CONFIG_REQ);
    UINT16_TO_STREAM(p, AUDIO_CODEC_SBC_ENC);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.sampling_freq);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.channel_mode);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.block_length);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.num_subbands);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.alloc_method);
    UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.codec_info.bitpool_size);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_BTM_EVT);
    UINT8_TO_STREAM(p, A2DP_START_REQ);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.stream_mtu);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    return brcm_vnd_a2dp_pdata.state;
}


static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_stream_enter(tBRCM_VND_A2DP_EVENT event)
{
    UNUSED(event);
    ALOGV("%s", __FUNCTION__);

    return brcm_vnd_a2dp_pdata.state;
}

static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_idle_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data)
{
    tBRCM_VND_A2DP_SST_STATES next_state = brcm_vnd_a2dp_pdata.state;

    switch (event) {
        case BRCM_VND_A2DP_OFFLOAD_START_REQ:
            brcm_vnd_a2dp_pdata.offload_params = *(bt_vendor_op_a2dp_offload_t*)ev_data;
            if (A2D_SUCCESS != bcrm_vnd_a2dp_parse_codec_info( &brcm_vnd_a2dp_pdata.codec_info,
                    (uint8_t *)brcm_vnd_a2dp_pdata.offload_params.codec_info)) {
                ALOGE("%s CodecConfig BT_VND_OP_A2DP_OFFLOAD_START FAILED", __FUNCTION__);
            }

            next_state = BRCM_VND_A2DP_STARTING_SST;
            break;

        default:
            ALOGV("%s Unexpected Event %d in State %d, IGNORE", __FUNCTION__, event, brcm_vnd_a2dp_pdata.state);
            break;
    }
    return next_state;
}

static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_starting_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data)
{
    tBRCM_VND_A2DP_SST_STATES next_state = brcm_vnd_a2dp_pdata.state;
    uint8_t status, *p;
    switch (event) {
        case BRCM_VND_A2DP_OFFLOAD_START_REQ:
            brcm_vnd_a2dp_offload_cleanup();
            brcm_vnd_a2dp_pdata.offload_params = *(bt_vendor_op_a2dp_offload_t*)ev_data;
            if (A2D_SUCCESS != bcrm_vnd_a2dp_parse_codec_info(
                    &brcm_vnd_a2dp_pdata.codec_info, (uint8_t *)brcm_vnd_a2dp_pdata.offload_params.codec_info)) {
                ALOGE("%s CodecConfig BT_VND_OP_A2DP_OFFLOAD_START FAILED", __FUNCTION__);
            }

            next_state = BRCM_VND_A2DP_STARTING_SST;
            break;


        case BRCM_VND_A2DP_OFFLOAD_STOP_REQ:
            brcm_vnd_a2dp_offload_cleanup();
            next_state = BRCM_VND_A2DP_IDLE_SST;
            break;

        case BRCM_VND_UIPC_OPEN_RSP: {
                uint8_t num_streams;
                uint16_t maj_ver, min_ver;
                p = (uint8_t*)ev_data + offsetof(tUIPC_OPEN_RSP, status);
                STREAM_TO_UINT8(status,p);
                STREAM_TO_UINT16(maj_ver,p);
                STREAM_TO_UINT16(min_ver,p);
                STREAM_TO_UINT8(num_streams,p);
                // TODO Verify Params //
                if (status) {
                    ALOGE("%s BRCM_VND_UIPC_OPEN_RSP %02x FAILED", __FUNCTION__, status);
                    brcm_vnd_a2dp_offload_cleanup();
                    bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                                      brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
                    next_state = BRCM_VND_A2DP_IDLE_SST;
                }
            }
            break;

        case BRCM_VND_L2C_SYNC_TO_LITE_RSP:
            status = *((uint8_t*)ev_data + offsetof(tL2C_SYNC_TO_LITE_RESP, stream.status));
            if (status) {
                ALOGE("%s L2C_SYNC_TO_LITE_RESP %02x FAILED", __FUNCTION__, status);
                brcm_vnd_a2dp_offload_cleanup();
                bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                                  brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
                next_state = BRCM_VND_A2DP_IDLE_SST;
            }
            break;

        case BRCM_VND_SYNC_TO_BTC_LITE_RSP:
            status = *((uint8_t*)ev_data + offsetof(tAVDT_SYNC_TO_BTC_LITE_RESP, status));
            if (status) {
                ALOGE("%s AVDT_SYNC_TO_BTC_LITE_RESP %02x FAILED", __FUNCTION__, status);
                brcm_vnd_a2dp_offload_cleanup();
                bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                                  brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
                next_state = BRCM_VND_A2DP_IDLE_SST;
            }
            break;

        case BRCM_VND_AUDIO_ROUTE_CONFIG_RSP:
            status = *((uint8_t*)ev_data + offsetof(tAUDIO_ROUTE_CONFIG_RESP, status));
            if (status) {
                ALOGE("%s AUDIO_ROUTE_CONFIG_RESP %02x FAILED", __FUNCTION__, status);
                brcm_vnd_a2dp_offload_cleanup();
                bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                                  brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
                next_state = BRCM_VND_A2DP_IDLE_SST;
            }
            break;

        case BRCM_VND_AUDIO_CODEC_CONFIG_RSP:
            status = *((uint8_t*)ev_data + offsetof(tAUDIO_CODEC_CONFIG_RESP, status));
            if (status) {
                ALOGE("%s BRCM_VND_AUDIO_CODEC_CONFIG_RSP %02x FAILED", __FUNCTION__, status);
                brcm_vnd_a2dp_offload_cleanup();
                bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                                  brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
                next_state = BRCM_VND_A2DP_IDLE_SST;
            }
            break;

        case BRCM_VND_A2DP_START_RSP:
            /* status = *((uint8_t*)ev_data + offsetof(tA2DP_GENERIC_RESP, status)); */
            bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_SUCCESS, BT_VND_OP_A2DP_OFFLOAD_START,
                                              brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
            next_state = BRCM_VND_A2DP_STREAM_SST;
            break;

        case BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT:
            ALOGE("%s BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT", __FUNCTION__);
            brcm_vnd_a2dp_offload_cleanup();
            bt_vendor_cbacks->a2dp_offload_cb(BT_VND_OP_RESULT_FAIL, BT_VND_OP_A2DP_OFFLOAD_START,
                                              brcm_vnd_a2dp_pdata.offload_params.bta_av_handle);
            next_state = BRCM_VND_A2DP_IDLE_SST;
            break;

        default:
            ALOGE("%s Unexpected Event %d in State %d, IGNORE", __FUNCTION__, event, brcm_vnd_a2dp_pdata.state);
            break;
    }
    return next_state;
}

static tBRCM_VND_A2DP_SST_STATES brcm_vnd_a2dp_sm_stream_process_ev(tBRCM_VND_A2DP_EVENT event, void *ev_data)
{
    tBRCM_VND_A2DP_SST_STATES next_state = brcm_vnd_a2dp_pdata.state;
    switch (event) {
        case BRCM_VND_A2DP_OFFLOAD_START_REQ:
            brcm_vnd_a2dp_offload_cleanup();
            brcm_vnd_a2dp_pdata.offload_params = *(bt_vendor_op_a2dp_offload_t*)ev_data;
            if (A2D_SUCCESS != bcrm_vnd_a2dp_parse_codec_info(
                    &brcm_vnd_a2dp_pdata.codec_info, (uint8_t *)brcm_vnd_a2dp_pdata.offload_params.codec_info)) {
                ALOGE("%s CodecConfig BT_VND_OP_A2DP_OFFLOAD_START FAILED", __FUNCTION__);
            }
            next_state = BRCM_VND_A2DP_STARTING_SST;
            break;

        case BRCM_VND_A2DP_OFFLOAD_STOP_REQ:
        case BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT:
            ALOGE("%s BRCM_VND_A2DP_OFFLOAD_STOP ABORT %d.", __FUNCTION__,
                  (event == BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT));
            brcm_vnd_a2dp_offload_cleanup();
            next_state = BRCM_VND_A2DP_IDLE_SST;
            break;

        default:
            ALOGE("%s Unexpected Event %d in State %d, IGNORE", __FUNCTION__, event, brcm_vnd_a2dp_pdata.state);
            break;
    }
    return next_state;
}

static uint8_t brcm_vnd_a2dp_offload_cleanup()
{
    uint8_t *p, msg_req[HCI_CMD_MAX_LEN];

    BTA2DPDBG("%s", __FUNCTION__);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_BTM_EVT);
    UINT8_TO_STREAM(p, A2DP_CLEANUP_REQ);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.stream_mtu);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_L2C_EVT);
    UINT8_TO_STREAM(p, L2C_REMOVE_TO_LITE_REQ);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.xmit_quota);
    UINT8_TO_STREAM(p, 1); //num_stream
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_MGMT_EVT);
    UINT8_TO_STREAM(p, UIPC_CLOSE_REQ);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    if (PCM_PIN_FCN_INVALID != brcm_vnd_a2dp_pdata.pcmi2s_pinmux.fcn) {
        p = msg_req;
        UINT8_TO_STREAM(p, brcm_vnd_a2dp_pdata.pcmi2s_pinmux.fcn);
        UINT32_TO_STREAM(p, brcm_vnd_a2dp_pdata.pcmi2s_pinmux.pad_conf);
        brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_WRITE_PCM_PINS, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);
    }

    return 0;
}

static uint8_t brcm_vnd_a2dp_offload_suspend()
{
    uint8_t *p, msg_req[HCI_CMD_MAX_LEN];

    BTA2DPDBG("%s", __FUNCTION__);

    p = msg_req;
    UINT16_TO_STREAM(p, BT_EVT_BTU_IPC_BTM_EVT);
    UINT8_TO_STREAM(p, A2DP_SUSPEND_REQ);
    UINT16_TO_STREAM(p, brcm_vnd_a2dp_pdata.offload_params.local_cid);
    brcm_vnd_a2dp_send_hci_vsc(HCI_VSC_UIPC_OVER_HCI, msg_req, (uint8_t)(p - msg_req), brcm_vnd_a2dp_hci_uipc_cback);

    return 0;
}

void brcm_vnd_a2dp_hci_uipc_cback(void *pmem)
{
    HC_BT_HDR    *p_evt_buf = (HC_BT_HDR *)pmem;
    uint8_t     *p, len, vsc_result, uipc_opcode;
    uint16_t    vsc_opcode, uipc_event;
    HC_BT_HDR    *p_buf = NULL;
    bt_vendor_op_result_t status = BT_VND_OP_RESULT_SUCCESS;
    tBRCM_VND_A2DP_EVENT   ssm_event;

    p = (uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_LEN;
    len = *p;
    p = (uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_VSC;
    STREAM_TO_UINT16(vsc_opcode,p);
    vsc_result = *p++;

    log_bin_to_hexstr(((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_VSC), len-1, __FUNCTION__);

    if (vsc_result != 0) {
        ALOGE("%s Failed VSC Op %04x", __FUNCTION__, vsc_opcode);
        status = BT_VND_OP_RESULT_FAIL;
    }
    else if (vsc_opcode == HCI_VSC_UIPC_OVER_HCI) {
        STREAM_TO_UINT16(uipc_event,p);
        uipc_opcode = *p;
        BTA2DPDBG("%s UIPC Event %04x UIPC Op %02x", __FUNCTION__, uipc_event, uipc_opcode);

        switch (uipc_event) {
            case BT_EVT_BTU_IPC_MGMT_EVT :
                switch (uipc_opcode) {
                    case UIPC_OPEN_RSP    : ssm_event = BRCM_VND_UIPC_OPEN_RSP; break;
                    case UIPC_CLOSE_RSP    : ssm_event = BRCM_VND_UIPC_CLOSE_RSP; break;
                    default: status = BT_VND_OP_RESULT_FAIL;
                }
                break;

            case BT_EVT_BTU_IPC_BTM_EVT     :
                switch (uipc_opcode) {
                    case A2DP_START_RESP:   ssm_event = BRCM_VND_A2DP_START_RSP; break;
                    case A2DP_SUSPEND_RESP: ssm_event = BRCM_VND_A2DP_SUSPEND_RSP; break;
                    case A2DP_CLEANUP_RESP: ssm_event = BRCM_VND_A2DP_CLEANUP_RSP; break;
                    case AUDIO_CODEC_CONFIG_RESP: ssm_event = BRCM_VND_AUDIO_CODEC_CONFIG_RSP; break;
                    case AUDIO_ROUTE_CONFIG_RESP: ssm_event = BRCM_VND_AUDIO_ROUTE_CONFIG_RSP; break;
                    default: status = BT_VND_OP_RESULT_FAIL;
                }
                break;

            case BT_EVT_BTU_IPC_L2C_EVT  :
                switch (uipc_opcode) {
                    case L2C_REMOVE_TO_LITE_RESP: ssm_event = BRCM_VND_L2C_REMOVE_TO_LITE_RSP; break;
                    case L2C_SYNC_TO_LITE_RESP:   ssm_event = BRCM_VND_L2C_SYNC_TO_LITE_RSP; break;
                    default: status = BT_VND_OP_RESULT_FAIL;
                }
                break;

            case BT_EVT_BTU_IPC_AVDT_EVT :
                if (uipc_opcode == AVDT_SYNC_TO_BTC_LITE_RESP) {
                    ssm_event = BRCM_VND_SYNC_TO_BTC_LITE_RSP;
                    break;
                }

            default:
                status = BT_VND_OP_RESULT_FAIL;
                break;
        }
        if (status == BT_VND_OP_RESULT_SUCCESS)
            brcm_vnd_a2dp_ssm_execute(ssm_event, p);
    }
    else if (vsc_opcode == HCI_VSC_READ_PCM_PINS) {
        STREAM_TO_UINT8(brcm_vnd_a2dp_pdata.pcmi2s_pinmux.fcn, p);
        STREAM_TO_UINT32(brcm_vnd_a2dp_pdata.pcmi2s_pinmux.pad_conf, p);
        BTA2DPDBG("%s HCI_VSC_READ_PCM_PINS %02x %08x", __FUNCTION__,
                  brcm_vnd_a2dp_pdata.pcmi2s_pinmux.fcn, brcm_vnd_a2dp_pdata.pcmi2s_pinmux.pad_conf);
    }

    if (status != BT_VND_OP_RESULT_SUCCESS)
        brcm_vnd_a2dp_ssm_execute(BRCM_VND_A2DP_OFFLOAD_FAILED_ABORT, NULL);

    /* Free the RX event buffer */
    bt_vendor_cbacks->dealloc(p_evt_buf);
}

void brcm_vnd_a2dp_init()
{
    if (!bt_vendor_cbacks)
        return;

    ALOGD("%s ", __FUNCTION__);
    brcm_vnd_a2dp_ssm_execute(BRCM_VND_A2DP_OFFLOAD_INIT_REQ, NULL);
}

int brcm_vnd_a2dp_execute(bt_vendor_opcode_t opcode, void *ev_data)
{
    tBRCM_VND_A2DP_EVENT ssm_event = (opcode == BT_VND_OP_A2DP_OFFLOAD_START)?
        BRCM_VND_A2DP_OFFLOAD_START_REQ:BRCM_VND_A2DP_OFFLOAD_STOP_REQ;

    ALOGD("%s opcode %d ", __FUNCTION__, opcode);

    return brcm_vnd_a2dp_ssm_execute(ssm_event, ev_data);
}