path: root/hal/audio_extn/usb.c

/*
 * Copyright (c) 2013, The Linux Foundation. All rights reserved.
 * Not a Contribution.
 *
 * Copyright (C) 2013 The Android Open Source Project
 *
 * 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.
 */

#define LOG_TAG "audio_hw_usb"
#define LOG_NDEBUG 0
#define LOG_NDDEBUG 0

#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <cutils/log.h>
#include <cutils/str_parms.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/stat.h>

#include <system/audio.h>
#include <tinyalsa/asoundlib.h>

#ifdef USB_HEADSET_ENABLED
#define USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE   512
#define USB_LOW_LATENCY_OUTPUT_PERIOD_COUNT  8
#define USB_DEFAULT_OUTPUT_SAMPLING_RATE     48000

#define USB_PROXY_DEFAULT_SAMPLING_RATE      48000
#define USB_PROXY_OPEN_RETRY_COUNT           100
#define USB_PROXY_OPEN_WAIT_TIME             20
#define USB_PROXY_PERIOD_SIZE                3072
#define USB_PROXY_RATE_8000                  8000
#define USB_PROXY_RATE_16000                 16000
#define USB_PROXY_RATE_48000                 48000
#define USB_PERIOD_SIZE                      2048
#define USB_BUFF_SIZE                        2048
#define AFE_PROXY_PERIOD_COUNT               32
#define AFE_PROXY_PLAYBACK_DEVICE            8
#define AFE_PROXY_CAPTURE_DEVICE             7

struct usb_module {
    uint32_t usb_card;
    uint32_t proxy_card;
    uint32_t usb_device_id;
    uint32_t proxy_device_id;

    int32_t channels_playback;
    int32_t sample_rate_playback;
    int32_t channels_record;
    int32_t sample_rate_record;

    bool is_playback_running;
    bool is_record_running;

    pthread_t usb_playback_thr;
    pthread_t usb_record_thr;
    pthread_mutex_t usb_playback_lock;
    pthread_mutex_t usb_record_lock;

    struct pcm *proxy_pcm_playback_handle;
    struct pcm *usb_pcm_playback_handle;
    struct pcm *proxy_pcm_record_handle;
    struct pcm *usb_pcm_record_handle;
    struct audio_device *adev;
};

static struct usb_module *usbmod = NULL;
static pthread_once_t alloc_usbmod_once_ctl = PTHREAD_ONCE_INIT;

struct pcm_config pcm_config_usbmod = {
    .channels = 2,
    .rate = USB_DEFAULT_OUTPUT_SAMPLING_RATE,
    .period_size = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE,
    .period_count = USB_LOW_LATENCY_OUTPUT_PERIOD_COUNT,
    .format = PCM_FORMAT_S16_LE,
    .start_threshold = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
    .stop_threshold = INT_MAX,
    .avail_min = USB_LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4,
};

static void usb_alloc()
{
    usbmod = calloc(1, sizeof(struct usb_module));
}

// Some USB audio accessories have a really low default volume set. Look for a suitable
// volume control and set the volume to default volume level.
static void initPlaybackVolume() {
    ALOGD("initPlaybackVolume");
    struct mixer *usbMixer = mixer_open(1);

    if (usbMixer) {
         struct mixer_ctl *ctl = NULL;
         unsigned int usbPlaybackVolume;
         unsigned int i;
         unsigned int num_ctls = mixer_get_num_ctls(usbMixer);

         // Look for the first control named ".*Playback Volume" that isn't for a microphone
         for (i = 0; i < num_ctls; i++) {
             ctl = mixer_get_ctl(usbMixer, i);
             if (strstr((const char *)mixer_ctl_get_name(ctl), "Playback Volume") &&
                 !strstr((const char *)mixer_ctl_get_name(ctl), "Mic")) {
                   break;
             }
         }
         if (ctl != NULL) {
            ALOGD("Found a volume control for USB: %s", mixer_ctl_get_name(ctl) );
            usbPlaybackVolume = mixer_ctl_get_value(ctl, 0);
            ALOGD("Value got from mixer_ctl_get is:%u", usbPlaybackVolume);
            if (mixer_ctl_set_value(ctl,0,usbPlaybackVolume) < 0) {
               ALOGE("Failed to set volume; default volume might be used");
            }
         } else {
            ALOGE("No playback volume control found; default volume will be used");
         }
         mixer_close(usbMixer);
    } else {
         ALOGE("Failed to open mixer for card 1");
    }
}

static int usb_get_numof_rates(char *rates_str)
{
    int i, size = 0;
    char *next_sr_string, *temp_ptr;
    next_sr_string = strtok_r(rates_str, " ,", &temp_ptr);

    if (next_sr_string == NULL) {
        ALOGE("%s: get_numof_rates: could not find rates string", __func__);
        return 0;
    }

    for (i = 1; next_sr_string != NULL; i++) {
        size ++;
        next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
    }
    return size;
}

static int usb_get_capability(char *type, int32_t *channels,
                                    int32_t *sample_rate)
{
    ALOGD("%s: for %s", __func__, type);
    long unsigned file_size;
    FILE *fp;
    char *buffer;
    int32_t err = 1;
    int32_t size = 0;
    int32_t fd, i, channels_playback;
    char *read_buf, *str_start, *channel_start, *rates_str, *rates_str_for_val,
    *rates_str_start, *next_sr_str, *test, *next_sr_string, *temp_ptr;
    struct stat st;
    int *rates_supported;
    char path[128];

    memset(&st, 0x0, sizeof(struct stat));
    *sample_rate = 0;
    snprintf(path, sizeof(path), "/proc/asound/card%u/stream0",
             usbmod->usb_card);

    fd = open(path, O_RDONLY);
    if (fd <0) {
        ALOGE("%s: error failed to open config file %s error: %d\n",
              __func__, path, errno);
        close(fd);
        return -EINVAL;
    }

    if (fstat(fd, &st) < 0) {
        ALOGE("%s: error failed to stat %s error %d\n",
             __func__, path, errno);
        close(fd);
        return -EINVAL;
    }

    file_size = st.st_size;

    read_buf = (char *)calloc(1, USB_BUFF_SIZE + 1);
    err = read(fd, read_buf, USB_BUFF_SIZE);
    str_start = strstr(read_buf, type);
    if (str_start == NULL) {
        ALOGE("%s: error %s section not found in usb config file",
               __func__, type);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    channel_start = strstr(str_start, "Channels:");
    if (channel_start == NULL) {
        ALOGE("%s: error could not find Channels information", __func__);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    channel_start = strstr(channel_start, " ");
    if (channel_start == NULL) {
        ALOGE("%s: error channel section not found in usb config file",
               __func__);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    channels_playback = atoi(channel_start);
    if (channels_playback == 1) {
        *channels = 1;
    } else {
        *channels = 2;
    }

    ALOGD("%s: channels supported by device: %d", __func__, *channels);
    rates_str_start = strstr(str_start, "Rates:");
    if (rates_str_start == NULL) {
        ALOGE("%s: error cant find rates information", __func__);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    rates_str_start = strstr(rates_str_start, " ");
    if (rates_str_start == NULL) {
        ALOGE("%s: error channel section not found in usb config file",
               __func__);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    char *target = strchr(rates_str_start, '\n');
    if (target == NULL) {
        ALOGE("%s: error end of line not found", __func__);
        close(fd);
        free(read_buf);
        return -EINVAL;
    }

    size = target - rates_str_start;
    if ((rates_str = (char *)malloc(size + 1)) == NULL) {
        ALOGE("%s: error unable to allocate memory to hold sample rate strings",
              __func__);
        close(fd);
        free(read_buf);
        return -ENOMEM;
    }

    if ((rates_str_for_val = (char *)malloc(size + 1)) == NULL) {
        ALOGE("%s: error unable to allocate memory to hold sample rate string",
               __func__);
        close(fd);
        free(rates_str);
        free(read_buf);
        return -ENOMEM;
    }

    memcpy(rates_str, rates_str_start, size);
    memcpy(rates_str_for_val, rates_str_start, size);
    rates_str[size] = '\0';
    rates_str_for_val[size] = '\0';

    size = usb_get_numof_rates(rates_str);
    if (!size) {
        ALOGE("%s: error could not get rate size, returning", __func__);
        close(fd);
        free(rates_str_for_val);
        free(rates_str);
        free(read_buf);
        return -EINVAL;
    }

    rates_supported = (int *)malloc(sizeof(int) * size);
    next_sr_string = strtok_r(rates_str_for_val, " ,", &temp_ptr);
    if (next_sr_string == NULL) {
        ALOGE("%s: error could not get first rate val", __func__);
        close(fd);
        free(rates_str_for_val);
        free(rates_str);
        free(rates_supported);
        free(read_buf);
        return -EINVAL;
    }

    rates_supported[0] = atoi(next_sr_string);
    ALOGD("%s: rates_supported[0] for playback: %d",
           __func__, rates_supported[0]);
    for (i = 1; i<size; i++) {
        next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
        rates_supported[i] = atoi(next_sr_string);
        ALOGD("rates_supported[%d] for playback: %d",i, rates_supported[i]);
    }

    for (i = 0; i<size; i++) {
        if ((rates_supported[i] > *sample_rate) &&
            (rates_supported[i] <= 48000)) {
            /* Sample Rate should be one of the proxy supported rates only
               This is because proxy port is used to read from/write to DSP */
            if ((rates_supported[i] == USB_PROXY_RATE_8000) ||
                (rates_supported[i] == USB_PROXY_RATE_16000) ||
                (rates_supported[i] == USB_PROXY_RATE_48000)) {
                *sample_rate = rates_supported[i];
            }
        }
    }
    ALOGD("%s: sample_rate: %d", __func__, *sample_rate);

    close(fd);
    free(rates_str_for_val);
    free(rates_str);
    free(rates_supported);
    free(read_buf);
    return 0;
}

static int32_t usb_playback_entry(void *adev)
{
    unsigned char usbbuf[USB_PROXY_PERIOD_SIZE] = {0};
    int32_t ret, bytes, proxy_open_retry_count;

    ALOGD("%s: entry", __func__);
    /* update audio device pointer */
    usbmod->adev = (struct audio_device*)adev;
    proxy_open_retry_count = USB_PROXY_OPEN_RETRY_COUNT;

    /* get capabilities */
    pthread_mutex_lock(&usbmod->usb_playback_lock);
    ret = usb_get_capability((char *)"Playback:",
            &usbmod->channels_playback, &usbmod->sample_rate_playback);
    if (ret) {
        ALOGE("%s: could not get playback capabilities from usb device",
               __func__);
        pthread_mutex_unlock(&usbmod->usb_playback_lock);
        return -EINVAL;
    }
    /* update config for usb
       1 pcm frame(sample)= 4 bytes since two channels*/
    pcm_config_usbmod.period_size = USB_PERIOD_SIZE/4;
    pcm_config_usbmod.channels = usbmod->channels_playback;
    pcm_config_usbmod.rate = usbmod->sample_rate_playback;
    ALOGV("%s: usb device %u:period %u:channels %u:sample", __func__,
          pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
          pcm_config_usbmod.rate);

    usbmod->usb_pcm_playback_handle = pcm_open(usbmod->usb_card, \
                                    usbmod->usb_device_id, PCM_OUT |
                                    PCM_MMAP | PCM_NOIRQ , &pcm_config_usbmod);

    if ((usbmod->usb_pcm_playback_handle \
        && !pcm_is_ready(usbmod->usb_pcm_playback_handle))
        || (!usbmod->is_playback_running)) {
        ALOGE("%s: failed: %s", __func__,
               pcm_get_error(usbmod->usb_pcm_playback_handle));
        pcm_close(usbmod->usb_pcm_playback_handle);
        usbmod->usb_pcm_playback_handle = NULL;
        pthread_mutex_unlock(&usbmod->usb_playback_lock);
        return -ENOMEM;
    }
    ALOGD("%s: USB configured for playback", __func__);

    /* update config for proxy*/
    pcm_config_usbmod.period_size = USB_PROXY_PERIOD_SIZE/3;
    pcm_config_usbmod.rate = usbmod->sample_rate_playback;
    pcm_config_usbmod.channels = usbmod->channels_playback;
    pcm_config_usbmod.period_count = AFE_PROXY_PERIOD_COUNT;
    usbmod->proxy_device_id = AFE_PROXY_PLAYBACK_DEVICE;
    ALOGD("%s: proxy device %u:period %u:channels %u:sample", __func__,
          pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
          pcm_config_usbmod.rate);

    while(proxy_open_retry_count){
        usbmod->proxy_pcm_playback_handle = pcm_open(usbmod->proxy_card,
                                            usbmod->proxy_device_id, PCM_IN |
                                     PCM_MMAP | PCM_NOIRQ, &pcm_config_usbmod);
        if(usbmod->proxy_pcm_playback_handle
            && !pcm_is_ready(usbmod->proxy_pcm_playback_handle)){
                     pcm_close(usbmod->proxy_pcm_playback_handle);
                     usbmod->proxy_pcm_playback_handle = NULL;
                     proxy_open_retry_count--;
                     usleep(USB_PROXY_OPEN_WAIT_TIME * 1000);
                     ALOGE("%s: pcm_open for proxy failed retrying = %d",
                            __func__, proxy_open_retry_count);
                }
                else{
                  break;
                }
    }

    if ((usbmod->proxy_pcm_playback_handle
        && !pcm_is_ready(usbmod->proxy_pcm_playback_handle))
        || (!usbmod->is_playback_running)) {
        ALOGE("%s: failed: %s", __func__,
               pcm_get_error(usbmod->proxy_pcm_playback_handle));
        pcm_close(usbmod->proxy_pcm_playback_handle);
        usbmod->proxy_pcm_playback_handle = NULL;
        pthread_mutex_unlock(&usbmod->usb_playback_lock);
        return -ENOMEM;
    }
    ALOGD("%s: PROXY configured for playback", __func__);
    pthread_mutex_unlock(&usbmod->usb_playback_lock);

    ALOGD("Init USB volume");
    initPlaybackVolume();
    /* main loop to read from proxy and write to usb */
    while (usbmod->is_playback_running) {
        /* read data from proxy */
        ret = pcm_mmap_read(usbmod->proxy_pcm_playback_handle,
                                 (void *)usbbuf, USB_PROXY_PERIOD_SIZE);
        /* Write to usb */
        ret = pcm_mmap_write(usbmod->usb_pcm_playback_handle,
                                (void *)usbbuf, USB_PROXY_PERIOD_SIZE);
        if(!usbmod->is_playback_running)
            break;

        memset(usbbuf, 0, USB_PROXY_PERIOD_SIZE);
    } /* main loop end */

    ALOGD("%s: exiting USB playback thread",__func__);
    return 0;
}

static void* usb_playback_launcher(void *adev)
{
    int32_t ret;

    usbmod->is_playback_running = true;
    ret = usb_playback_entry(adev);

    if (ret) {
        ALOGE("%s: failed with err:%d", __func__, ret);
        usbmod->is_playback_running = false;
    }
    return NULL;
}

static int32_t usb_record_entry(void *adev)
{
    unsigned char usbbuf[USB_PROXY_PERIOD_SIZE] = {0};
    int32_t ret, bytes, proxy_open_retry_count;
    ALOGD("%s: entry", __func__);

    /* update audio device pointer */
    usbmod->adev = (struct audio_device*)adev;
    proxy_open_retry_count = USB_PROXY_OPEN_RETRY_COUNT;

    /* get capabilities */
    pthread_mutex_lock(&usbmod->usb_record_lock);
    ret = usb_get_capability((char *)"Capture:",
            &usbmod->channels_record, &usbmod->sample_rate_record);
    if (ret) {
        ALOGE("%s: could not get capture capabilities from usb device",
               __func__);
        pthread_mutex_unlock(&usbmod->usb_record_lock);
        return -EINVAL;
    }
    /* update config for usb
       1 pcm frame(sample)= 4 bytes since two channels*/
    pcm_config_usbmod.period_size = USB_PERIOD_SIZE/4;
    pcm_config_usbmod.channels = usbmod->channels_record;
    pcm_config_usbmod.rate = usbmod->sample_rate_record;
    ALOGV("%s: usb device %u:period %u:channels %u:sample", __func__,
          pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
          pcm_config_usbmod.rate);

    usbmod->usb_pcm_record_handle = pcm_open(usbmod->usb_card, \
                                    usbmod->usb_device_id, PCM_IN |
                                    PCM_MMAP | PCM_NOIRQ , &pcm_config_usbmod);

    if ((usbmod->usb_pcm_record_handle \
        && !pcm_is_ready(usbmod->usb_pcm_record_handle))
        || (!usbmod->is_record_running)) {
        ALOGE("%s: failed: %s", __func__,
               pcm_get_error(usbmod->usb_pcm_record_handle));
        pcm_close(usbmod->usb_pcm_record_handle);
        usbmod->usb_pcm_record_handle = NULL;
        pthread_mutex_unlock(&usbmod->usb_record_lock);
        return -ENOMEM;
    }
    ALOGD("%s: USB configured for capture", __func__);

    /* update config for proxy*/
    pcm_config_usbmod.period_size = USB_PROXY_PERIOD_SIZE/4;
    pcm_config_usbmod.rate = usbmod->sample_rate_record;
    pcm_config_usbmod.channels = usbmod->channels_record;
    pcm_config_usbmod.period_count = AFE_PROXY_PERIOD_COUNT * 2;
    usbmod->proxy_device_id = AFE_PROXY_CAPTURE_DEVICE;
    ALOGV("%s: proxy device %u:period %u:channels %u:sample", __func__,
          pcm_config_usbmod.period_size, pcm_config_usbmod.channels,
          pcm_config_usbmod.rate);

    while(proxy_open_retry_count){
        usbmod->proxy_pcm_record_handle = pcm_open(usbmod->proxy_card,
                                            usbmod->proxy_device_id, PCM_OUT |
                                     PCM_MMAP | PCM_NOIRQ, &pcm_config_usbmod);
        if(usbmod->proxy_pcm_record_handle
            && !pcm_is_ready(usbmod->proxy_pcm_record_handle)){
                     pcm_close(usbmod->proxy_pcm_record_handle);
                     usbmod->proxy_pcm_record_handle = NULL;
                     proxy_open_retry_count--;
                     usleep(USB_PROXY_OPEN_WAIT_TIME * 1000);
                     ALOGE("%s: pcm_open for proxy(recording) failed retrying = %d",
                            __func__, proxy_open_retry_count);
                }
                else{
                  break;
                }
    }
    if ((usbmod->proxy_pcm_record_handle
        && !pcm_is_ready(usbmod->proxy_pcm_record_handle))
        || (!usbmod->is_record_running)) {
        ALOGE("%s: failed: %s", __func__,
               pcm_get_error(usbmod->proxy_pcm_record_handle));
        pcm_close(usbmod->proxy_pcm_record_handle);
        usbmod->proxy_pcm_record_handle = NULL;
        pthread_mutex_unlock(&usbmod->usb_record_lock);
        return -ENOMEM;
    }
    ALOGD("%s: PROXY configured for capture", __func__);
    pthread_mutex_unlock(&usbmod->usb_record_lock);

    /* main loop to read from usb and write to proxy */
    while (usbmod->is_record_running) {
        /* read data from usb */
        ret = pcm_mmap_read(usbmod->usb_pcm_record_handle,
                                 (void *)usbbuf, USB_PROXY_PERIOD_SIZE);
        /* Write to proxy */
        ret = pcm_mmap_write(usbmod->proxy_pcm_record_handle,
                                (void *)usbbuf, USB_PROXY_PERIOD_SIZE);
        if(!usbmod->is_record_running)
            break;

        memset(usbbuf, 0, USB_PROXY_PERIOD_SIZE);
    } /* main loop end */

    ALOGD("%s: exiting USB capture thread",__func__);
    return 0;
}

static void* usb_capture_launcher(void *adev)
{
    int32_t ret;

    usbmod->is_record_running = true;
    ret = usb_record_entry(adev);

    if (ret) {
        ALOGE("%s: failed with err:%d", __func__, ret);
        usbmod->is_record_running = false;
    }
    return NULL;
}

void audio_extn_usb_init(void *adev)
{
    pthread_once(&alloc_usbmod_once_ctl, usb_alloc);

    usbmod->is_playback_running = false;
    usbmod->is_record_running = false;

    usbmod->usb_pcm_playback_handle = NULL;
    usbmod->proxy_pcm_playback_handle = NULL;

    usbmod->usb_pcm_record_handle = NULL;
    usbmod->proxy_pcm_record_handle = NULL;

    usbmod->usb_card = 1;
    usbmod->usb_device_id = 0;
    usbmod->proxy_card = 0;
    usbmod->proxy_device_id = AFE_PROXY_PLAYBACK_DEVICE;
    usbmod->adev = (struct audio_device*)adev;

     pthread_mutex_init(&usbmod->usb_playback_lock,
                        (const pthread_mutexattr_t *) NULL);
     pthread_mutex_init(&usbmod->usb_record_lock,
                        (const pthread_mutexattr_t *) NULL);
}

void audio_extn_usb_deinit()
{
    if (NULL != usbmod){
        free(usbmod);
        usbmod = NULL;
    }
}

void audio_extn_usb_set_proxy_sound_card(uint32_t sndcard_idx)
{
    /* Proxy port and USB headset are related to two different sound cards */
    if (sndcard_idx == usbmod->usb_card) {
        usbmod->usb_card = usbmod->proxy_card;
    }

    usbmod->proxy_card = sndcard_idx;
}

void audio_extn_usb_start_playback(void *adev)
{
    int32_t ret;

    if (NULL == usbmod){
        ALOGE("%s: USB device object is NULL", __func__);
        return;
    }

    if (usbmod->is_playback_running){
        ALOGE("%s: USB playback thread already running", __func__);
        return;
    }

    ALOGD("%s: creating USB playback thread", __func__);
    ret = pthread_create(&usbmod->usb_playback_thr, NULL,
                         usb_playback_launcher, (void*)adev);
    if (ret)
        ALOGE("%s: failed to create USB playback thread with err:%d",
              __func__, ret);
}

void audio_extn_usb_stop_playback()
{
    int32_t ret;
    ALOGD("%s: entry", __func__);

    usbmod->is_playback_running = false;
    if (NULL != usbmod->proxy_pcm_playback_handle)
        pcm_stop(usbmod->proxy_pcm_playback_handle);

    if (NULL != usbmod->usb_pcm_playback_handle)
        pcm_stop(usbmod->usb_pcm_playback_handle);

    if(usbmod->usb_playback_thr) {
        ret = pthread_join(usbmod->usb_playback_thr,NULL);
        ALOGE("%s: return for pthread_join = %d", __func__, ret);
        usbmod->usb_playback_thr = (pthread_t)NULL;
    }

    pthread_mutex_lock(&usbmod->usb_playback_lock);
    if (NULL != usbmod->usb_pcm_playback_handle){
        pcm_close(usbmod->usb_pcm_playback_handle);
        usbmod->usb_pcm_playback_handle = NULL;
    }

    if (NULL != usbmod->proxy_pcm_playback_handle){
        pcm_close(usbmod->proxy_pcm_playback_handle);
        usbmod->proxy_pcm_playback_handle = NULL;
    }
    pthread_mutex_unlock(&usbmod->usb_playback_lock);

    ALOGD("%s: exiting",__func__);
}

void audio_extn_usb_start_capture(void *adev)
{
    int32_t ret;

    if (NULL == usbmod){
        ALOGE("%s: USB device object is NULL", __func__);
        return;
    }

    if (usbmod->is_record_running){
        ALOGE("%s: USB capture thread already running", __func__);
        return;
    }

    ALOGD("%s: creating USB capture thread", __func__);
    ret = pthread_create(&usbmod->usb_record_thr, NULL,
                         usb_capture_launcher, (void*)adev);
    if (ret)
        ALOGE("%s: failed to create USB capture thread with err:%d",
              __func__, ret);
}

void audio_extn_usb_stop_capture()
{
    int32_t ret;
    ALOGD("%s: entry", __func__);

    usbmod->is_record_running = false;
    if (NULL != usbmod->proxy_pcm_record_handle)
        pcm_stop(usbmod->proxy_pcm_record_handle);

    if (NULL != usbmod->usb_pcm_record_handle)
        pcm_stop(usbmod->usb_pcm_record_handle);

    if(usbmod->usb_record_thr) {
        ret = pthread_join(usbmod->usb_record_thr,NULL);
        ALOGE("%s: return for pthread_join = %d", __func__, ret);
        usbmod->usb_record_thr = (pthread_t)NULL;
    }

    pthread_mutex_lock(&usbmod->usb_record_lock);
    if (NULL != usbmod->usb_pcm_record_handle){
        pcm_close(usbmod->usb_pcm_record_handle);
        usbmod->usb_pcm_record_handle = NULL;
    }

    if (NULL != usbmod->proxy_pcm_record_handle){
        pcm_close(usbmod->proxy_pcm_record_handle);
        usbmod->proxy_pcm_record_handle = NULL;
    }
    pthread_mutex_unlock(&usbmod->usb_record_lock);

    ALOGD("%s: exiting",__func__);
}

bool audio_extn_usb_is_proxy_inuse()
{
    if( usbmod->is_record_running || usbmod->is_playback_running)
        return true;
    else
        return false;
}
#endif /*USB_HEADSET_ENABLED end*/