Home | History | Annotate | Download | only in libaudio-qsd8k
      1 /*
      2 ** Copyright 2008, The Android Open-Source Project
      3 **
      4 ** Licensed under the Apache License, Version 2.0 (the "License");
      5 ** you may not use this file except in compliance with the License.
      6 ** You may obtain a copy of the License at
      7 **
      8 **     http://www.apache.org/licenses/LICENSE-2.0
      9 **
     10 ** Unless required by applicable law or agreed to in writing, software
     11 ** distributed under the License is distributed on an "AS IS" BASIS,
     12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 ** See the License for the specific language governing permissions and
     14 ** limitations under the License.
     15 */
     16 
     17 #include <math.h>
     18 
     19 //#define LOG_NDEBUG 0
     20 #define LOG_TAG "AudioHardwareQSD"
     21 #include <utils/Log.h>
     22 #include <utils/String8.h>
     23 #include <hardware_legacy/power.h>
     24 
     25 #include <stdio.h>
     26 #include <unistd.h>
     27 #include <sys/ioctl.h>
     28 #include <sys/types.h>
     29 #include <sys/stat.h>
     30 #include <dlfcn.h>
     31 #include <fcntl.h>
     32 
     33 #include <cutils/properties.h> // for property_get for the voice recognition mode switch
     34 
     35 // hardware specific functions
     36 
     37 #include "AudioHardware.h"
     38 #include <media/AudioRecord.h>
     39 #include <media/mediarecorder.h>
     40 
     41 extern "C" {
     42 #include "msm_audio.h"
     43 #include <linux/a1026.h>
     44 #include <linux/tpa2018d1.h>
     45 }
     46 
     47 #define LOG_SND_RPC 0  // Set to 1 to log sound RPC's
     48 #define TX_PATH (1)
     49 
     50 static const uint32_t SND_DEVICE_CURRENT = 256;
     51 static const uint32_t SND_DEVICE_HANDSET = 0;
     52 static const uint32_t SND_DEVICE_SPEAKER = 1;
     53 static const uint32_t SND_DEVICE_BT = 3;
     54 static const uint32_t SND_DEVICE_CARKIT = 4;
     55 static const uint32_t SND_DEVICE_BT_EC_OFF = 45;
     56 static const uint32_t SND_DEVICE_HEADSET = 2;
     57 static const uint32_t SND_DEVICE_HEADSET_AND_SPEAKER = 10;
     58 static const uint32_t SND_DEVICE_FM_HEADSET = 9;
     59 static const uint32_t SND_DEVICE_FM_SPEAKER = 11;
     60 static const uint32_t SND_DEVICE_NO_MIC_HEADSET = 8;
     61 static const uint32_t SND_DEVICE_TTY_FULL = 5;
     62 static const uint32_t SND_DEVICE_TTY_VCO = 6;
     63 static const uint32_t SND_DEVICE_TTY_HCO = 7;
     64 static const uint32_t SND_DEVICE_HANDSET_BACK_MIC = 20;
     65 static const uint32_t SND_DEVICE_SPEAKER_BACK_MIC = 21;
     66 static const uint32_t SND_DEVICE_NO_MIC_HEADSET_BACK_MIC = 28;
     67 static const uint32_t SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC = 30;
     68 namespace android {
     69 static int support_a1026 = 1;
     70 static bool support_tpa2018d1 = true;
     71 static int fd_a1026 = -1;
     72 static int old_pathid = -1;
     73 static int new_pathid = -1;
     74 static int curr_out_device = -1;
     75 static int curr_mic_device = -1;
     76 static int voice_started = 0;
     77 static int fd_fm_device = -1;
     78 static int stream_volume = -300;
     79 // use VR mode on inputs: 1 == VR mode enabled when selected, 0 = VR mode disabled when selected
     80 static int vr_mode_enabled;
     81 static bool vr_mode_change = false;
     82 static int vr_uses_ns = 0;
     83 static int alt_enable = 0;
     84 static int hac_enable = 0;
     85 // enable or disable 2-mic noise suppression in call on receiver mode
     86 static int enable1026 = 1;
     87 //FIXME add new settings in A1026 driver for an incall no ns mode, based on the current vr no ns
     88 #define A1026_PATH_INCALL_NO_NS_RECEIVER A1026_PATH_VR_NO_NS_RECEIVER
     89 
     90 int errCount = 0;
     91 static void * acoustic;
     92 const uint32_t AudioHardware::inputSamplingRates[] = {
     93         8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000
     94 };
     95 
     96 // ID string for audio wakelock
     97 static const char kOutputWakelockStr[] = "AudioHardwareQSDOut";
     98 static const char kInputWakelockStr[] = "AudioHardwareQSDIn";
     99 
    100 // ----------------------------------------------------------------------------
    101 
    102 AudioHardware::AudioHardware() :
    103     mA1026Init(false), mInit(false), mMicMute(true),
    104     mBluetoothNrec(true),
    105     mHACSetting(false),
    106     mBluetoothIdTx(0), mBluetoothIdRx(0),
    107     mOutput(0),
    108     mNoiseSuppressionState(A1026_NS_STATE_AUTO),
    109     mVoiceVolume(VOICE_VOLUME_MAX), mTTYMode(TTY_MODE_OFF)
    110 {
    111     int (*snd_get_num)();
    112     int (*snd_get_bt_endpoint)(msm_bt_endpoint *);
    113     int (*set_acoustic_parameters)();
    114     int (*set_tpa2018d1_parameters)();
    115 
    116     struct msm_bt_endpoint *ept;
    117 
    118     doA1026_init();
    119 
    120     acoustic =:: dlopen("/system/lib/libhtc_acoustic.so", RTLD_NOW);
    121     if (acoustic == NULL ) {
    122         ALOGD("Could not open libhtc_acoustic.so");
    123         /* this is not really an error on non-htc devices... */
    124         mNumBTEndpoints = 0;
    125         mInit = true;
    126         return;
    127     }
    128     set_acoustic_parameters = (int (*)(void))::dlsym(acoustic, "set_acoustic_parameters");
    129     if ((*set_acoustic_parameters) == 0 ) {
    130         ALOGE("Could not open set_acoustic_parameters()");
    131         return;
    132     }
    133 
    134     set_tpa2018d1_parameters = (int (*)(void))::dlsym(acoustic, "set_tpa2018d1_parameters");
    135     if ((*set_tpa2018d1_parameters) == 0) {
    136         ALOGD("set_tpa2018d1_parameters() not present");
    137         support_tpa2018d1 = false;
    138     }
    139 
    140     int rc = set_acoustic_parameters();
    141     if (rc < 0) {
    142         ALOGD("Could not set acoustic parameters to share memory: %d", rc);
    143     }
    144 
    145     if (support_tpa2018d1) {
    146        rc = set_tpa2018d1_parameters();
    147        if (rc < 0) {
    148            support_tpa2018d1 = false;
    149            ALOGD("speaker amplifier tpa2018 is not supported\n");
    150        }
    151     }
    152 
    153     snd_get_num = (int (*)(void))::dlsym(acoustic, "snd_get_num");
    154     if ((*snd_get_num) == 0 ) {
    155         ALOGD("Could not open snd_get_num()");
    156     }
    157 
    158     mNumBTEndpoints = snd_get_num();
    159     ALOGV("mNumBTEndpoints = %d", mNumBTEndpoints);
    160     mBTEndpoints = new msm_bt_endpoint[mNumBTEndpoints];
    161     mInit = true;
    162     ALOGV("constructed %d SND endpoints)", mNumBTEndpoints);
    163     ept = mBTEndpoints;
    164     snd_get_bt_endpoint = (int (*)(msm_bt_endpoint *))::dlsym(acoustic, "snd_get_bt_endpoint");
    165     if ((*snd_get_bt_endpoint) == 0 ) {
    166         ALOGE("Could not open snd_get_bt_endpoint()");
    167         return;
    168     }
    169     snd_get_bt_endpoint(mBTEndpoints);
    170 
    171     for (int i = 0; i < mNumBTEndpoints; i++) {
    172         ALOGV("BT name %s (tx,rx)=(%d,%d)", mBTEndpoints[i].name, mBTEndpoints[i].tx, mBTEndpoints[i].rx);
    173     }
    174 
    175     // reset voice mode in case media_server crashed and restarted while in call
    176     int fd = open("/dev/msm_audio_ctl", O_RDWR);
    177     if (fd >= 0) {
    178         ioctl(fd, AUDIO_STOP_VOICE, NULL);
    179         close(fd);
    180     }
    181 
    182     vr_mode_change = false;
    183     vr_mode_enabled = 0;
    184     enable1026 = 1;
    185     char value[PROPERTY_VALUE_MAX];
    186     // Check the system property to enable or not the special recording modes
    187     property_get("media.a1026.enableA1026", value, "1");
    188     enable1026 = atoi(value);
    189     ALOGV("Enable mode selection for A1026 is %d", enable1026);
    190     // Check the system property for which VR mode to use
    191     property_get("media.a1026.nsForVoiceRec", value, "0");
    192     vr_uses_ns = atoi(value);
    193     ALOGV("Using Noise Suppression for Voice Rec is %d", vr_uses_ns);
    194 
    195     // Check the system property for enable or not the ALT function
    196     property_get("htc.audio.alt.enable", value, "0");
    197     alt_enable = atoi(value);
    198     ALOGV("Enable ALT function: %d", alt_enable);
    199 
    200     // Check the system property for enable or not the HAC function
    201     property_get("htc.audio.hac.enable", value, "0");
    202     hac_enable = atoi(value);
    203     ALOGV("Enable HAC function: %d", hac_enable);
    204 
    205     mInit = true;
    206 }
    207 
    208 AudioHardware::~AudioHardware()
    209 {
    210     for (size_t index = 0; index < mInputs.size(); index++) {
    211         closeInputStream((AudioStreamIn*)mInputs[index]);
    212     }
    213     mInputs.clear();
    214     closeOutputStream((AudioStreamOut*)mOutput);
    215     mInit = false;
    216 }
    217 
    218 status_t AudioHardware::initCheck()
    219 {
    220     return mInit ? NO_ERROR : NO_INIT;
    221 }
    222 
    223 AudioStreamOut* AudioHardware::openOutputStream(
    224         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
    225 {
    226     { // scope for the lock
    227         Mutex::Autolock lock(mLock);
    228 
    229         // only one output stream allowed
    230         if (mOutput) {
    231             if (status) {
    232                 *status = INVALID_OPERATION;
    233             }
    234             return 0;
    235         }
    236 
    237         // create new output stream
    238         AudioStreamOutMSM72xx* out = new AudioStreamOutMSM72xx();
    239         status_t lStatus = out->set(this, devices, format, channels, sampleRate);
    240         if (status) {
    241             *status = lStatus;
    242         }
    243         if (lStatus == NO_ERROR) {
    244             mOutput = out;
    245         } else {
    246             delete out;
    247         }
    248     }
    249     return mOutput;
    250 }
    251 
    252 void AudioHardware::closeOutputStream(AudioStreamOut* out) {
    253     Mutex::Autolock lock(mLock);
    254     if (mOutput == 0 || mOutput != out) {
    255         ALOGW("Attempt to close invalid output stream");
    256     }
    257     else {
    258         delete mOutput;
    259         mOutput = 0;
    260     }
    261 }
    262 
    263 AudioStreamIn* AudioHardware::openInputStream(
    264         uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status,
    265         AudioSystem::audio_in_acoustics acoustic_flags)
    266 {
    267     // check for valid input source
    268     if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
    269         return 0;
    270     }
    271 
    272     mLock.lock();
    273 
    274     AudioStreamInMSM72xx* in = new AudioStreamInMSM72xx();
    275     status_t lStatus = in->set(this, devices, format, channels, sampleRate, acoustic_flags);
    276     if (status) {
    277         *status = lStatus;
    278     }
    279     if (lStatus != NO_ERROR) {
    280         mLock.unlock();
    281         delete in;
    282         return 0;
    283     }
    284 
    285     mInputs.add(in);
    286     mLock.unlock();
    287 
    288     return in;
    289 }
    290 
    291 void AudioHardware::closeInputStream(AudioStreamIn* in) {
    292     Mutex::Autolock lock(mLock);
    293 
    294     ssize_t index = mInputs.indexOf((AudioStreamInMSM72xx *)in);
    295     if (index < 0) {
    296         ALOGW("Attempt to close invalid input stream");
    297     } else {
    298         mLock.unlock();
    299         delete mInputs[index];
    300         mLock.lock();
    301         mInputs.removeAt(index);
    302     }
    303 }
    304 
    305 status_t AudioHardware::setMode(int mode)
    306 {
    307     // VR mode is never used in a call and must be cleared when entering the IN_CALL mode
    308     if (mode == AudioSystem::MODE_IN_CALL) {
    309         vr_mode_enabled = 0;
    310     }
    311 
    312     if (support_tpa2018d1)
    313         do_tpa2018_control(mode);
    314 
    315     int prevMode = mMode;
    316     status_t status = AudioHardwareBase::setMode(mode);
    317     if (status == NO_ERROR) {
    318         // make sure that doAudioRouteOrMute() is called by doRouting()
    319         // when entering or exiting in call mode even if the new device
    320         // selected is the same as current one.
    321         if (((prevMode != AudioSystem::MODE_IN_CALL) && (mMode == AudioSystem::MODE_IN_CALL)) ||
    322             ((prevMode == AudioSystem::MODE_IN_CALL) && (mMode != AudioSystem::MODE_IN_CALL))) {
    323             clearCurDevice();
    324         }
    325     }
    326 
    327     return status;
    328 }
    329 
    330 bool AudioHardware::checkOutputStandby()
    331 {
    332     if (mOutput)
    333         if (!mOutput->checkStandby())
    334             return false;
    335 
    336     return true;
    337 }
    338 static status_t set_mic_mute(bool _mute)
    339 {
    340     uint32_t mute = _mute;
    341     int fd = -1;
    342     fd = open("/dev/msm_audio_ctl", O_RDWR);
    343     if (fd < 0) {
    344         ALOGE("Cannot open msm_audio_ctl device\n");
    345         return -1;
    346     }
    347     ALOGD("Setting mic mute to %d\n", mute);
    348     if (ioctl(fd, AUDIO_SET_MUTE, &mute)) {
    349         ALOGE("Cannot set mic mute on current device\n");
    350         close(fd);
    351         return -1;
    352     }
    353     close(fd);
    354     return NO_ERROR;
    355 }
    356 
    357 status_t AudioHardware::setMicMute(bool state)
    358 {
    359     Mutex::Autolock lock(mLock);
    360     return setMicMute_nosync(state);
    361 }
    362 
    363 // always call with mutex held
    364 status_t AudioHardware::setMicMute_nosync(bool state)
    365 {
    366     if (mMicMute != state) {
    367         mMicMute = state;
    368         return set_mic_mute(mMicMute); //always set current TX device
    369     }
    370     return NO_ERROR;
    371 }
    372 
    373 status_t AudioHardware::getMicMute(bool* state)
    374 {
    375     *state = mMicMute;
    376     return NO_ERROR;
    377 }
    378 
    379 status_t AudioHardware::setParameters(const String8& keyValuePairs)
    380 {
    381     AudioParameter param = AudioParameter(keyValuePairs);
    382     String8 value;
    383     String8 key;
    384     const char BT_NREC_KEY[] = "bt_headset_nrec";
    385     const char BT_NAME_KEY[] = "bt_headset_name";
    386     const char HAC_KEY[] = "HACSetting";
    387     const char BT_NREC_VALUE_ON[] = "on";
    388     const char HAC_VALUE_ON[] = "ON";
    389 
    390 
    391     ALOGV("setParameters() %s", keyValuePairs.string());
    392 
    393     if (keyValuePairs.length() == 0) return BAD_VALUE;
    394 
    395     if(hac_enable) {
    396         key = String8(HAC_KEY);
    397         if (param.get(key, value) == NO_ERROR) {
    398             if (value == HAC_VALUE_ON) {
    399                 mHACSetting = true;
    400                 ALOGD("Enable HAC");
    401             } else {
    402                 mHACSetting = false;
    403                 ALOGD("Disable HAC");
    404             }
    405         }
    406     }
    407 
    408     key = String8(BT_NREC_KEY);
    409     if (param.get(key, value) == NO_ERROR) {
    410         if (value == BT_NREC_VALUE_ON) {
    411             mBluetoothNrec = true;
    412         } else {
    413             mBluetoothNrec = false;
    414             ALOGD("Turning noise reduction and echo cancellation off for BT "
    415                  "headset");
    416         }
    417     }
    418     key = String8(BT_NAME_KEY);
    419     if (param.get(key, value) == NO_ERROR) {
    420         mBluetoothIdTx = 0;
    421         mBluetoothIdRx = 0;
    422         for (int i = 0; i < mNumBTEndpoints; i++) {
    423             if (!strcasecmp(value.string(), mBTEndpoints[i].name)) {
    424                 mBluetoothIdTx = mBTEndpoints[i].tx;
    425                 mBluetoothIdRx = mBTEndpoints[i].rx;
    426                 ALOGD("Using custom acoustic parameters for %s", value.string());
    427                 break;
    428             }
    429         }
    430         if (mBluetoothIdTx == 0) {
    431             ALOGD("Using default acoustic parameters "
    432                  "(%s not in acoustic database)", value.string());
    433         }
    434         doRouting();
    435     }
    436     key = String8("noise_suppression");
    437     if (param.get(key, value) == NO_ERROR) {
    438         if (support_a1026 == 1) {
    439             int noiseSuppressionState;
    440             if (value == "off") {
    441                 noiseSuppressionState = A1026_NS_STATE_OFF;
    442             } else if (value == "auto") {
    443                 noiseSuppressionState = A1026_NS_STATE_AUTO;
    444             } else if (value == "far_talk") {
    445                 noiseSuppressionState = A1026_NS_STATE_FT;
    446             } else if (value == "close_talk") {
    447                 noiseSuppressionState = A1026_NS_STATE_CT;
    448             } else {
    449                 return BAD_VALUE;
    450             }
    451 
    452             if (noiseSuppressionState != mNoiseSuppressionState) {
    453                 if (!mA1026Init) {
    454                     ALOGW("Audience A1026 not initialized.\n");
    455                     return INVALID_OPERATION;
    456                 }
    457 
    458                 mA1026Lock.lock();
    459                 if (fd_a1026 < 0) {
    460                     fd_a1026 = open("/dev/audience_a1026", O_RDWR);
    461                     if (fd_a1026 < 0) {
    462                         ALOGE("Cannot open audience_a1026 device (%d)\n", fd_a1026);
    463                         mA1026Lock.unlock();
    464                         return -1;
    465                     }
    466                 }
    467                 ALOGV("Setting noise suppression %s", value.string());
    468 
    469                 int rc = ioctl(fd_a1026, A1026_SET_NS_STATE, &noiseSuppressionState);
    470                 if (!rc) {
    471                     mNoiseSuppressionState = noiseSuppressionState;
    472                 } else {
    473                     ALOGE("Failed to set noise suppression %s", value.string());
    474                 }
    475                 close(fd_a1026);
    476                 fd_a1026 = -1;
    477                 mA1026Lock.unlock();
    478             }
    479         } else {
    480             return INVALID_OPERATION;
    481         }
    482      }
    483 
    484     key = String8("tty_mode");
    485     if (param.get(key, value) == NO_ERROR) {
    486         int ttyMode;
    487         if (value == "tty_off") {
    488             ttyMode = TTY_MODE_OFF;
    489         } else if (value == "tty_full") {
    490             ttyMode = TTY_MODE_FULL;
    491         } else if (value == "tty_vco") {
    492             ttyMode = TTY_MODE_VCO;
    493         } else if (value == "tty_hco") {
    494             ttyMode = TTY_MODE_HCO;
    495         } else {
    496             return BAD_VALUE;
    497         }
    498 
    499         if (ttyMode != mTTYMode) {
    500             ALOGV("new tty mode %d", ttyMode);
    501             mTTYMode = ttyMode;
    502             doRouting();
    503         }
    504      }
    505 
    506     return NO_ERROR;
    507 }
    508 
    509 String8 AudioHardware::getParameters(const String8& keys)
    510 {
    511     AudioParameter request = AudioParameter(keys);
    512     AudioParameter reply = AudioParameter();
    513     String8 value;
    514     String8 key;
    515 
    516     ALOGV("getParameters() %s", keys.string());
    517 
    518     key = "noise_suppression";
    519     if (request.get(key, value) == NO_ERROR) {
    520         switch(mNoiseSuppressionState) {
    521         case A1026_NS_STATE_OFF:
    522             value = "off";
    523             break;
    524         case A1026_NS_STATE_AUTO:
    525             value = "auto";
    526             break;
    527         case A1026_NS_STATE_FT:
    528             value = "far_talk";
    529             break;
    530         case A1026_NS_STATE_CT:
    531             value = "close_talk";
    532             break;
    533         }
    534         reply.add(key, value);
    535     }
    536 
    537     return reply.toString();
    538 }
    539 
    540 
    541 static unsigned calculate_audpre_table_index(unsigned index)
    542 {
    543     switch (index) {
    544         case 48000:    return SAMP_RATE_INDX_48000;
    545         case 44100:    return SAMP_RATE_INDX_44100;
    546         case 32000:    return SAMP_RATE_INDX_32000;
    547         case 24000:    return SAMP_RATE_INDX_24000;
    548         case 22050:    return SAMP_RATE_INDX_22050;
    549         case 16000:    return SAMP_RATE_INDX_16000;
    550         case 12000:    return SAMP_RATE_INDX_12000;
    551         case 11025:    return SAMP_RATE_INDX_11025;
    552         case 8000:    return SAMP_RATE_INDX_8000;
    553         default:     return -1;
    554     }
    555 }
    556 
    557 size_t AudioHardware::getBufferSize(uint32_t sampleRate, int channelCount)
    558 {
    559     size_t bufSize;
    560 
    561     if (sampleRate < 11025) {
    562         bufSize = 256;
    563     } else if (sampleRate < 22050) {
    564         bufSize = 512;
    565     } else if (sampleRate < 32000) {
    566         bufSize = 768;
    567     } else if (sampleRate < 44100) {
    568         bufSize = 1024;
    569     } else {
    570         bufSize = 1536;
    571     }
    572 
    573     return bufSize*channelCount;
    574 }
    575 
    576 
    577 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
    578 {
    579     if (format != AudioSystem::PCM_16_BIT) {
    580         ALOGW("getInputBufferSize bad format: %d", format);
    581         return 0;
    582     }
    583     if (channelCount < 1 || channelCount > 2) {
    584         ALOGW("getInputBufferSize bad channel count: %d", channelCount);
    585         return 0;
    586     }
    587     if (sampleRate < 8000 || sampleRate > 48000) {
    588         ALOGW("getInputBufferSize bad sample rate: %d", sampleRate);
    589         return 0;
    590     }
    591 
    592     return getBufferSize(sampleRate, channelCount);
    593 }
    594 
    595 static status_t set_volume_rpc(uint32_t volume)
    596 {
    597     int fd = -1;
    598     fd = open("/dev/msm_audio_ctl", O_RDWR);
    599     if (fd < 0) {
    600         ALOGE("Cannot open msm_audio_ctl device\n");
    601         return -1;
    602     }
    603     volume *= 20; //percentage
    604     ALOGD("Setting in-call volume to %d\n", volume);
    605     if (ioctl(fd, AUDIO_SET_VOLUME, &volume)) {
    606         ALOGW("Cannot set volume on current device\n");
    607     }
    608     close(fd);
    609     return NO_ERROR;
    610 }
    611 
    612 status_t AudioHardware::setVoiceVolume(float v)
    613 {
    614     if (v < 0.0) {
    615         ALOGW("setVoiceVolume(%f) under 0.0, assuming 0.0", v);
    616         v = 0.0;
    617     } else if (v > 1.0) {
    618         ALOGW("setVoiceVolume(%f) over 1.0, assuming 1.0", v);
    619         v = 1.0;
    620     }
    621 
    622     int vol = lrint(v * VOICE_VOLUME_MAX);
    623 
    624     Mutex::Autolock lock(mLock);
    625     if (mHACSetting && hac_enable && mCurSndDevice == (int) SND_DEVICE_HANDSET) {
    626         ALOGD("HAC enable: Setting in-call volume to maximum.\n");
    627         set_volume_rpc(VOICE_VOLUME_MAX);
    628     } else {
    629         ALOGI("voice volume %d (range is 0 to %d)", vol, VOICE_VOLUME_MAX);
    630         set_volume_rpc(vol); //always set current device
    631     }
    632     mVoiceVolume = vol;
    633     return NO_ERROR;
    634 }
    635 
    636 status_t AudioHardware::setMasterVolume(float v)
    637 {
    638     ALOGI("Set master volume to %f", v);
    639     // We return an error code here to let the audioflinger do in-software
    640     // volume on top of the maximum volume that we set through the SND API.
    641     // return error - software mixer will handle it
    642     return -1;
    643 }
    644 
    645 static status_t do_route_audio_dev_ctrl(uint32_t device, bool inCall, uint32_t rx_acdb_id, uint32_t tx_acdb_id)
    646 {
    647     uint32_t out_device = 0, mic_device = 0;
    648     uint32_t path[2];
    649     int fd = 0;
    650 
    651     if (device == SND_DEVICE_CURRENT)
    652         goto Incall;
    653 
    654     // hack -- kernel needs to put these in include file
    655     ALOGD("Switching audio device to ");
    656     if (device == SND_DEVICE_HANDSET) {
    657            out_device = HANDSET_SPKR;
    658            mic_device = HANDSET_MIC;
    659            ALOGD("Handset");
    660     } else if ((device  == SND_DEVICE_BT) || (device == SND_DEVICE_BT_EC_OFF)) {
    661            out_device = BT_SCO_SPKR;
    662            mic_device = BT_SCO_MIC;
    663            ALOGD("BT Headset");
    664     } else if (device == SND_DEVICE_SPEAKER ||
    665                device == SND_DEVICE_SPEAKER_BACK_MIC) {
    666            out_device = SPKR_PHONE_MONO;
    667            mic_device = SPKR_PHONE_MIC;
    668            ALOGD("Speakerphone");
    669     } else if (device == SND_DEVICE_HEADSET) {
    670            out_device = HEADSET_SPKR_STEREO;
    671            mic_device = HEADSET_MIC;
    672            ALOGD("Stereo Headset");
    673     } else if (device == SND_DEVICE_HEADSET_AND_SPEAKER) {
    674            out_device = SPKR_PHONE_HEADSET_STEREO;
    675            mic_device = HEADSET_MIC;
    676            ALOGD("Stereo Headset + Speaker");
    677     } else if (device == SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC) {
    678            out_device = SPKR_PHONE_HEADSET_STEREO;
    679            mic_device = SPKR_PHONE_MIC;
    680            ALOGD("Stereo Headset + Speaker and back mic");
    681     } else if (device == SND_DEVICE_NO_MIC_HEADSET) {
    682            out_device = HEADSET_SPKR_STEREO;
    683            mic_device = HANDSET_MIC;
    684            ALOGD("No microphone Wired Headset");
    685     } else if (device == SND_DEVICE_NO_MIC_HEADSET_BACK_MIC) {
    686            out_device = HEADSET_SPKR_STEREO;
    687            mic_device = SPKR_PHONE_MIC;
    688            ALOGD("No microphone Wired Headset and back mic");
    689     } else if (device == SND_DEVICE_HANDSET_BACK_MIC) {
    690            out_device = HANDSET_SPKR;
    691            mic_device = SPKR_PHONE_MIC;
    692            ALOGD("Handset and back mic");
    693     } else if (device == SND_DEVICE_FM_HEADSET) {
    694            out_device = FM_HEADSET;
    695            mic_device = HEADSET_MIC;
    696            ALOGD("Stereo FM headset");
    697     } else if (device == SND_DEVICE_FM_SPEAKER) {
    698            out_device = FM_SPKR;
    699            mic_device = HEADSET_MIC;
    700            ALOGD("Stereo FM speaker");
    701     } else if (device == SND_DEVICE_CARKIT) {
    702            out_device = BT_SCO_SPKR;
    703            mic_device = BT_SCO_MIC;
    704            ALOGD("Carkit");
    705     } else if (device == SND_DEVICE_TTY_FULL) {
    706         out_device = TTY_HEADSET_SPKR;
    707         mic_device = TTY_HEADSET_MIC;
    708         ALOGD("TTY FULL headset");
    709     } else if (device == SND_DEVICE_TTY_VCO) {
    710         out_device = TTY_HEADSET_SPKR;
    711         mic_device = SPKR_PHONE_MIC;
    712         ALOGD("TTY VCO headset");
    713     } else if (device == SND_DEVICE_TTY_HCO) {
    714         out_device = SPKR_PHONE_MONO;
    715         mic_device = TTY_HEADSET_MIC;
    716         ALOGD("TTY HCO headset");
    717     } else {
    718         ALOGE("unknown device %d", device);
    719         return -1;
    720     }
    721 
    722 #if 0 //Add for FM support
    723     if (out_device == FM_HEADSET ||
    724         out_device == FM_SPKR) {
    725         if (fd_fm_device < 0) {
    726             fd_fm_device = open("/dev/msm_htc_fm", O_RDWR);
    727             if (fd_fm_device < 0) {
    728                 ALOGE("Cannot open msm_htc_fm device");
    729                 return -1;
    730             }
    731             ALOGD("Opened msm_htc_fm for FM radio");
    732         }
    733     } else if (fd_fm_device >= 0) {
    734         close(fd_fm_device);
    735         fd_fm_device = -1;
    736         ALOGD("Closed msm_htc_fm after FM radio");
    737     }
    738 #endif
    739 
    740     fd = open("/dev/msm_audio_ctl", O_RDWR);
    741     if (fd < 0)        {
    742        ALOGE("Cannot open msm_audio_ctl");
    743        return -1;
    744     }
    745     path[0] = out_device;
    746     path[1] = rx_acdb_id;
    747     if (ioctl(fd, AUDIO_SWITCH_DEVICE, &path)) {
    748        ALOGE("Cannot switch audio device");
    749        close(fd);
    750        return -1;
    751     }
    752     path[0] = mic_device;
    753     path[1] = tx_acdb_id;
    754     if (ioctl(fd, AUDIO_SWITCH_DEVICE, &path)) {
    755        ALOGE("Cannot switch mic device");
    756        close(fd);
    757        return -1;
    758     }
    759     curr_out_device = out_device;
    760     curr_mic_device = mic_device;
    761 
    762 Incall:
    763     if (inCall == true && !voice_started) {
    764         if (fd < 0) {
    765             fd = open("/dev/msm_audio_ctl", O_RDWR);
    766 
    767             if (fd < 0) {
    768                 ALOGE("Cannot open msm_audio_ctl");
    769                 return -1;
    770             }
    771         }
    772         path[0] = rx_acdb_id;
    773         path[1] = tx_acdb_id;
    774         if (ioctl(fd, AUDIO_START_VOICE, &path)) {
    775             ALOGE("Cannot start voice");
    776             close(fd);
    777             return -1;
    778         }
    779         ALOGD("Voice Started!!");
    780         voice_started = 1;
    781     }
    782     else if (inCall == false && voice_started) {
    783         if (fd < 0) {
    784             fd = open("/dev/msm_audio_ctl", O_RDWR);
    785 
    786             if (fd < 0) {
    787                 ALOGE("Cannot open msm_audio_ctl");
    788                 return -1;
    789             }
    790         }
    791         if (ioctl(fd, AUDIO_STOP_VOICE, NULL)) {
    792                ALOGE("Cannot stop voice");
    793                close(fd);
    794                return -1;
    795         }
    796         ALOGD("Voice Stopped!!");
    797         voice_started = 0;
    798     }
    799 
    800     close(fd);
    801     return NO_ERROR;
    802 }
    803 
    804 
    805 // always call with mutex held
    806 status_t AudioHardware::doAudioRouteOrMute(uint32_t device)
    807 {
    808     uint32_t rx_acdb_id = 0;
    809     uint32_t tx_acdb_id = 0;
    810 
    811     if (support_a1026 == 1)
    812             doAudience_A1026_Control(mMode, mRecordState, device);
    813 
    814     if (device == (uint32_t)SND_DEVICE_BT) {
    815         if (!mBluetoothNrec) {
    816             device = SND_DEVICE_BT_EC_OFF;
    817         }
    818     }
    819 
    820 
    821     if (device == (int) SND_DEVICE_BT) {
    822         if (mBluetoothIdTx != 0) {
    823             rx_acdb_id = mBluetoothIdRx;
    824             tx_acdb_id = mBluetoothIdTx;
    825         } else {
    826             /* use default BT entry defined in AudioBTID.csv */
    827             rx_acdb_id = mBTEndpoints[0].rx;
    828             tx_acdb_id = mBTEndpoints[0].tx;
    829             ALOGD("Update ACDB ID to default BT setting\n");
    830         }
    831     }  else if (device == (int) SND_DEVICE_CARKIT
    832                 || device == (int) SND_DEVICE_BT_EC_OFF) {
    833         if (mBluetoothIdTx != 0) {
    834             rx_acdb_id = mBluetoothIdRx;
    835             tx_acdb_id = mBluetoothIdTx;
    836         } else {
    837             /* use default carkit entry defined in AudioBTID.csv */
    838             rx_acdb_id = mBTEndpoints[1].rx;
    839             tx_acdb_id = mBTEndpoints[1].tx;
    840             ALOGD("Update ACDB ID to default carkit setting");
    841         }
    842     } else if (mMode == AudioSystem::MODE_IN_CALL
    843                && hac_enable && mHACSetting &&
    844                device == (int) SND_DEVICE_HANDSET) {
    845         ALOGD("Update acdb id to hac profile.");
    846         rx_acdb_id = ACDB_ID_HAC_HANDSET_SPKR;
    847         tx_acdb_id = ACDB_ID_HAC_HANDSET_MIC;
    848     } else {
    849         if (!checkOutputStandby() || mMode != AudioSystem::MODE_IN_CALL)
    850             rx_acdb_id = getACDB(MOD_PLAY, device);
    851         if (mRecordState)
    852             tx_acdb_id = getACDB(MOD_REC, device);
    853     }
    854     ALOGV("doAudioRouteOrMute: rx acdb %d, tx acdb %d\n", rx_acdb_id, tx_acdb_id);
    855 
    856     return do_route_audio_dev_ctrl(device, mMode == AudioSystem::MODE_IN_CALL, rx_acdb_id, tx_acdb_id);
    857 }
    858 
    859 status_t AudioHardware::get_mMode(void)
    860 {
    861     return mMode;
    862 }
    863 
    864 status_t AudioHardware::get_mRoutes(void)
    865 {
    866     return mRoutes[mMode];
    867 }
    868 
    869 status_t AudioHardware::set_mRecordState(bool onoff)
    870 {
    871     mRecordState = onoff;
    872     return 0;
    873 }
    874 
    875 status_t AudioHardware::get_batt_temp(int *batt_temp)
    876 {
    877     int fd, len;
    878     const char *fn =
    879             "/sys/devices/platform/ds2784-battery/power_supply/battery/temp";
    880     char get_batt_temp[6] = { 0 };
    881 
    882     if ((fd = open(fn, O_RDONLY)) < 0) {
    883         ALOGE("%s: cannot open %s: %s\n", __FUNCTION__, fn, strerror(errno));
    884         return UNKNOWN_ERROR;
    885     }
    886 
    887     if ((len = read(fd, get_batt_temp, sizeof(get_batt_temp))) <= 1) {
    888         ALOGE("read battery temp fail: %s\n", strerror(errno));
    889         close(fd);
    890         return BAD_VALUE;
    891     }
    892 
    893     *batt_temp = strtol(get_batt_temp, NULL, 10);
    894     close(fd);
    895     return NO_ERROR;
    896 }
    897 
    898 /*
    899  * Note: upon exiting doA1026_init(), fd_a1026 will be -1
    900  */
    901 status_t AudioHardware::doA1026_init(void)
    902 {
    903     struct a1026img fwimg;
    904     char char_tmp = 0;
    905     unsigned char local_vpimg_buf[A1026_MAX_FW_SIZE], *ptr = local_vpimg_buf;
    906     int rc = 0, fw_fd = -1;
    907     ssize_t nr;
    908     size_t remaining;
    909     struct stat fw_stat;
    910 
    911     static const char *const fn = "/system/etc/vpimg";
    912     static const char *const path = "/dev/audience_a1026";
    913 
    914     if (fd_a1026 < 0)
    915         fd_a1026 = open(path, O_RDWR | O_NONBLOCK, 0);
    916 
    917     if (fd_a1026 < 0) {
    918         ALOGE("Cannot open %s %d\n", path, fd_a1026);
    919         support_a1026 = 0;
    920         goto open_drv_err;
    921     }
    922 
    923     fw_fd = open(fn, O_RDONLY);
    924     if (fw_fd < 0) {
    925         ALOGE("Fail to open %s\n", fn);
    926         goto ld_img_error;
    927     } else {
    928         ALOGD("open %s success\n", fn);
    929     }
    930 
    931     rc = fstat(fw_fd, &fw_stat);
    932     if (rc < 0) {
    933         ALOGE("Cannot stat file %s: %s\n", fn, strerror(errno));
    934         goto ld_img_error;
    935     }
    936 
    937     remaining = (int)fw_stat.st_size;
    938 
    939     ALOGD("Firmware %s size %d\n", fn, remaining);
    940 
    941     if (remaining > sizeof(local_vpimg_buf)) {
    942         ALOGE("File %s size %d exceeds internal limit %d\n",
    943              fn, remaining, sizeof(local_vpimg_buf));
    944         goto ld_img_error;
    945     }
    946 
    947     while (remaining) {
    948         nr = read(fw_fd, ptr, remaining);
    949         if (nr < 0) {
    950             ALOGE("Error reading firmware: %s\n", strerror(errno));
    951             goto ld_img_error;
    952         }
    953         else if (!nr) {
    954             if (remaining)
    955                 ALOGW("EOF reading firmware %s while %d bytes remain\n",
    956                      fn, remaining);
    957             break;
    958         }
    959         remaining -= nr;
    960         ptr += nr;
    961     }
    962 
    963     close (fw_fd);
    964     fw_fd = -1;
    965 
    966     fwimg.buf = local_vpimg_buf;
    967     fwimg.img_size = (int)(fw_stat.st_size - remaining);
    968     ALOGD("Total %d bytes put to user space buffer.\n", fwimg.img_size);
    969 
    970     rc = ioctl(fd_a1026, A1026_BOOTUP_INIT, &fwimg);
    971     if (!rc) {
    972         ALOGD("audience_a1026 init OK\n");
    973         mA1026Init = 1;
    974     } else
    975         ALOGE("audience_a1026 init failed\n");
    976 
    977 ld_img_error:
    978     if (fw_fd >= 0)
    979         close(fw_fd);
    980     close(fd_a1026);
    981 open_drv_err:
    982     fd_a1026 = -1;
    983     return rc;
    984 }
    985 
    986 status_t AudioHardware::get_snd_dev(void)
    987 {
    988     Mutex::Autolock lock(mLock);
    989     return mCurSndDevice;
    990 }
    991 
    992 uint32_t AudioHardware::getACDB(int mode, int device)
    993 {
    994     uint32_t acdb_id = 0;
    995     int batt_temp = 0;
    996     if (mMode == AudioSystem::MODE_IN_CALL) {
    997         ALOGD("skip update ACDB due to in-call");
    998         return 0;
    999     }
   1000 
   1001     if (mode == MOD_PLAY) {
   1002         switch (device) {
   1003             case SND_DEVICE_HEADSET:
   1004             case SND_DEVICE_NO_MIC_HEADSET:
   1005             case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
   1006             case SND_DEVICE_FM_HEADSET:
   1007                 acdb_id = ACDB_ID_HEADSET_PLAYBACK;
   1008                 break;
   1009             case SND_DEVICE_SPEAKER:
   1010             case SND_DEVICE_FM_SPEAKER:
   1011             case SND_DEVICE_SPEAKER_BACK_MIC:
   1012                 acdb_id = ACDB_ID_SPKR_PLAYBACK;
   1013                 if(alt_enable) {
   1014                     ALOGD("Enable ALT for speaker\n");
   1015                     if (get_batt_temp(&batt_temp) == NO_ERROR) {
   1016                         if (batt_temp < 50)
   1017                             acdb_id = ACDB_ID_ALT_SPKR_PLAYBACK;
   1018                         ALOGD("ALT batt temp = %d\n", batt_temp);
   1019                     }
   1020                 }
   1021                 break;
   1022             case SND_DEVICE_HEADSET_AND_SPEAKER:
   1023             case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
   1024                 acdb_id = ACDB_ID_HEADSET_RINGTONE_PLAYBACK;
   1025                 break;
   1026             default:
   1027                 break;
   1028         }
   1029     } else if (mode == MOD_REC) {
   1030         switch (device) {
   1031             case SND_DEVICE_HEADSET:
   1032             case SND_DEVICE_FM_HEADSET:
   1033             case SND_DEVICE_FM_SPEAKER:
   1034             case SND_DEVICE_HEADSET_AND_SPEAKER:
   1035                 acdb_id = ACDB_ID_EXT_MIC_REC;
   1036                 break;
   1037             case SND_DEVICE_HANDSET:
   1038             case SND_DEVICE_NO_MIC_HEADSET:
   1039             case SND_DEVICE_SPEAKER:
   1040                 if (vr_mode_enabled == 0) {
   1041                     acdb_id = ACDB_ID_INT_MIC_REC;
   1042                 } else {
   1043                     acdb_id = ACDB_ID_INT_MIC_VR;
   1044                 }
   1045                 break;
   1046             case SND_DEVICE_SPEAKER_BACK_MIC:
   1047             case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
   1048             case SND_DEVICE_HANDSET_BACK_MIC:
   1049             case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
   1050                 acdb_id = ACDB_ID_CAMCORDER;
   1051                 break;
   1052             default:
   1053                 break;
   1054         }
   1055     }
   1056     ALOGV("getACDB, return ID %d\n", acdb_id);
   1057     return acdb_id;
   1058 }
   1059 
   1060 status_t AudioHardware::do_tpa2018_control(int mode)
   1061 {
   1062     if (curr_out_device == HANDSET_SPKR ||
   1063         curr_out_device == SPKR_PHONE_MONO ||
   1064         curr_out_device == HEADSET_SPKR_STEREO ||
   1065         curr_out_device == SPKR_PHONE_HEADSET_STEREO ||
   1066         curr_out_device == FM_SPKR) {
   1067 
   1068 	int fd, rc;
   1069         int retry = 3;
   1070 
   1071         switch (mode) {
   1072         case AudioSystem::MODE_NORMAL:
   1073             mode = TPA2018_MODE_PLAYBACK;
   1074             break;
   1075         case AudioSystem::MODE_RINGTONE:
   1076             mode = TPA2018_MODE_RINGTONE;
   1077             break;
   1078         case AudioSystem::MODE_IN_CALL:
   1079             mode = TPA2018_MODE_VOICE_CALL;
   1080             break;
   1081         default:
   1082             return 0;
   1083         }
   1084 
   1085         fd = open("/dev/tpa2018d1", O_RDWR);
   1086         if (fd < 0) {
   1087             ALOGE("can't open /dev/tpa2018d1 %d", fd);
   1088             return -1;
   1089         }
   1090 
   1091         do {
   1092             rc = ioctl(fd, TPA2018_SET_MODE, &mode);
   1093             if (!rc)
   1094                 break;
   1095         } while (--retry);
   1096 
   1097         if (rc < 0) {
   1098             ALOGE("ioctl TPA2018_SET_MODE failed: %s", strerror(errno));
   1099         } else
   1100             ALOGD("Update TPA2018_SET_MODE to mode %d success", mode);
   1101 
   1102         close(fd);
   1103     }
   1104     return 0;
   1105 }
   1106 
   1107 status_t AudioHardware::doAudience_A1026_Control(int Mode, bool Record, uint32_t Routes)
   1108 {
   1109     int rc = 0;
   1110     int retry = 4;
   1111 
   1112     if (!mA1026Init) {
   1113         ALOGW("Audience A1026 not initialized.\n");
   1114         return NO_INIT;
   1115     }
   1116 
   1117     mA1026Lock.lock();
   1118     if (fd_a1026 < 0) {
   1119         fd_a1026 = open("/dev/audience_a1026", O_RDWR);
   1120         if (fd_a1026 < 0) {
   1121             ALOGE("Cannot open audience_a1026 device (%d)\n", fd_a1026);
   1122             mA1026Lock.unlock();
   1123             return -1;
   1124         }
   1125     }
   1126 
   1127     if ((Mode < AudioSystem::MODE_CURRENT) || (Mode >= AudioSystem::NUM_MODES)) {
   1128         ALOGW("Illegal value: doAudience_A1026_Control(%d, %u, %u)", Mode, Record, Routes);
   1129         mA1026Lock.unlock();
   1130         return BAD_VALUE;
   1131     }
   1132 
   1133     if (Mode == AudioSystem::MODE_IN_CALL) {
   1134         if (Record == 1) {
   1135 	    switch (Routes) {
   1136 	        case SND_DEVICE_HANDSET:
   1137 	        case SND_DEVICE_NO_MIC_HEADSET:
   1138 	            //TODO: what do we do for camcorder when in call?
   1139 	        case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
   1140 	        case SND_DEVICE_HANDSET_BACK_MIC:
   1141 	        case SND_DEVICE_TTY_VCO:
   1142 	            if (enable1026) {
   1143                     new_pathid = A1026_PATH_INCALL_RECEIVER;
   1144                     ALOGV("A1026 control: new path is A1026_PATH_INCALL_RECEIVER");
   1145 	            } else {
   1146 	                new_pathid = A1026_PATH_INCALL_NO_NS_RECEIVER;
   1147 	                ALOGV("A1026 control: new path is A1026_PATH_INCALL_NO_NS_RECEIVER");
   1148 	            }
   1149 	            break;
   1150 	        case SND_DEVICE_HEADSET:
   1151 	        case SND_DEVICE_HEADSET_AND_SPEAKER:
   1152 	        case SND_DEVICE_FM_HEADSET:
   1153 	        case SND_DEVICE_FM_SPEAKER:
   1154 	        case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
   1155 	            new_pathid = A1026_PATH_INCALL_HEADSET;
   1156 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_HEADSET");
   1157 	            break;
   1158 	        case SND_DEVICE_SPEAKER:
   1159 	            //TODO: what do we do for camcorder when in call?
   1160 	        case SND_DEVICE_SPEAKER_BACK_MIC:
   1161 	            new_pathid = A1026_PATH_INCALL_SPEAKER;
   1162 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_SPEAKER");
   1163 	            break;
   1164 	        case SND_DEVICE_BT:
   1165 	        case SND_DEVICE_BT_EC_OFF:
   1166 	        case SND_DEVICE_CARKIT:
   1167 	            new_pathid = A1026_PATH_INCALL_BT;
   1168 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_BT");
   1169 	            break;
   1170 	        case SND_DEVICE_TTY_HCO:
   1171 	        case SND_DEVICE_TTY_FULL:
   1172 	            new_pathid = A1026_PATH_INCALL_TTY;
   1173 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_TTY");
   1174 	            break;
   1175 	        default:
   1176 	            break;
   1177             }
   1178        } else {
   1179            switch (Routes) {
   1180 	        case SND_DEVICE_HANDSET:
   1181 	        case SND_DEVICE_NO_MIC_HEADSET:
   1182 	        case SND_DEVICE_TTY_VCO:
   1183 	            if (enable1026) {
   1184 	                new_pathid = A1026_PATH_INCALL_RECEIVER; /* NS CT mode, Dual MIC */
   1185                     ALOGV("A1026 control: new path is A1026_PATH_INCALL_RECEIVER");
   1186 	            } else {
   1187 	                new_pathid = A1026_PATH_INCALL_NO_NS_RECEIVER;
   1188 	                ALOGV("A1026 control: new path is A1026_PATH_INCALL_NO_NS_RECEIVER");
   1189 	            }
   1190 	            break;
   1191 	        case SND_DEVICE_HEADSET:
   1192 	        case SND_DEVICE_HEADSET_AND_SPEAKER:
   1193 	        case SND_DEVICE_FM_HEADSET:
   1194 	        case SND_DEVICE_FM_SPEAKER:
   1195 	            new_pathid = A1026_PATH_INCALL_HEADSET; /* NS disable, Headset MIC */
   1196 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_HEADSET");
   1197 	            break;
   1198 	        case SND_DEVICE_SPEAKER:
   1199 	            new_pathid = A1026_PATH_INCALL_SPEAKER; /* NS FT mode, Main MIC */
   1200 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_SPEAKER");
   1201 	            break;
   1202 	        case SND_DEVICE_BT:
   1203 	        case SND_DEVICE_BT_EC_OFF:
   1204 	        case SND_DEVICE_CARKIT:
   1205 	            new_pathid = A1026_PATH_INCALL_BT; /* QCOM NS, BT MIC */
   1206 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_BT");
   1207 	            break;
   1208 	        case SND_DEVICE_TTY_HCO:
   1209 	        case SND_DEVICE_TTY_FULL:
   1210 	            new_pathid = A1026_PATH_INCALL_TTY;
   1211 	            ALOGV("A1026 control: new path is A1026_PATH_INCALL_TTY");
   1212 	            break;
   1213 	        default:
   1214 	            break;
   1215             }
   1216        }
   1217     } else if (Record == 1) {
   1218         switch (Routes) {
   1219         case SND_DEVICE_SPEAKER:
   1220             // default output is speaker, recording from phone mic, user RECEIVER configuration
   1221         case SND_DEVICE_HANDSET:
   1222         case SND_DEVICE_NO_MIC_HEADSET:
   1223 	        if (vr_mode_enabled) {
   1224 	            if (vr_uses_ns) {
   1225 	                new_pathid = A1026_PATH_VR_NS_RECEIVER;
   1226 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NS_RECEIVER");
   1227 	            } else {
   1228 	                new_pathid = A1026_PATH_VR_NO_NS_RECEIVER;
   1229 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NO_NS_RECEIVER");
   1230 	            }
   1231 	        } else {
   1232 	            new_pathid = A1026_PATH_RECORD_RECEIVER; /* INT-MIC Recording: NS disable, Main MIC */
   1233                 ALOGV("A1026 control: new path is A1026_PATH_RECORD_RECEIVER");
   1234 	        }
   1235 	        break;
   1236         case SND_DEVICE_HEADSET:
   1237         case SND_DEVICE_HEADSET_AND_SPEAKER:
   1238         case SND_DEVICE_FM_HEADSET:
   1239         case SND_DEVICE_FM_SPEAKER:
   1240 	        if (vr_mode_enabled) {
   1241 	            if (vr_uses_ns) {
   1242 	                new_pathid = A1026_PATH_VR_NS_HEADSET;
   1243 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NS_HEADSET");
   1244 	            } else {
   1245 	                new_pathid = A1026_PATH_VR_NO_NS_HEADSET;
   1246 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NO_NS_HEADSET");
   1247 	            }
   1248 	        } else {
   1249 	            new_pathid = A1026_PATH_RECORD_HEADSET; /* EXT-MIC Recording: NS disable, Headset MIC */
   1250 	            ALOGV("A1026 control: new path is A1026_PATH_RECORD_HEADSET");
   1251 	        }
   1252 	        break;
   1253         case SND_DEVICE_SPEAKER_BACK_MIC:
   1254         case SND_DEVICE_NO_MIC_HEADSET_BACK_MIC:
   1255         case SND_DEVICE_HANDSET_BACK_MIC:
   1256         case SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC:
   1257 	        new_pathid = A1026_PATH_CAMCORDER; /* CAM-Coder: NS FT mode, Back MIC */
   1258 	        ALOGV("A1026 control: new path is A1026_PATH_CAMCORDER");
   1259 	        break;
   1260         case SND_DEVICE_BT:
   1261         case SND_DEVICE_BT_EC_OFF:
   1262         case SND_DEVICE_CARKIT:
   1263 	        if (vr_mode_enabled) {
   1264 	            if (vr_uses_ns) {
   1265 	                new_pathid = A1026_PATH_VR_NS_BT;
   1266 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NS_BT");
   1267 	            } else {
   1268 	                new_pathid = A1026_PATH_VR_NO_NS_BT;
   1269 	                ALOGV("A1026 control: new path is A1026_PATH_VR_NO_NS_BT");
   1270 	            }
   1271 	        } else {
   1272 	            new_pathid = A1026_PATH_RECORD_BT; /* BT MIC */
   1273 	            ALOGV("A1026 control: new path is A1026_PATH_RECORD_BT");
   1274 	        }
   1275 	        break;
   1276         default:
   1277 	        break;
   1278         }
   1279     }
   1280     else {
   1281         switch (Routes) {
   1282         case SND_DEVICE_BT:
   1283         case SND_DEVICE_BT_EC_OFF:
   1284         case SND_DEVICE_CARKIT:
   1285             new_pathid = A1026_PATH_RECORD_BT; /* BT MIC */
   1286             ALOGV("A1026 control: new path is A1026_PATH_RECORD_BT");
   1287             break;
   1288         default:
   1289             new_pathid = A1026_PATH_SUSPEND;
   1290             break;
   1291         }
   1292     }
   1293 
   1294     if (old_pathid != new_pathid) {
   1295         //ALOGI("A1026: do ioctl(A1026_SET_CONFIG) to %d\n", new_pathid);
   1296         do {
   1297             rc = ioctl(fd_a1026, A1026_SET_CONFIG, &new_pathid);
   1298             if (!rc) {
   1299                 old_pathid = new_pathid;
   1300                 break;
   1301             }
   1302         } while (--retry);
   1303 
   1304         if (rc < 0) {
   1305             ALOGW("A1026 do hard reset to recover from error!\n");
   1306             rc = doA1026_init(); /* A1026 needs to do hard reset! */
   1307             if (!rc) {
   1308                 /* after doA1026_init(), fd_a1026 is -1*/
   1309                 fd_a1026 = open("/dev/audience_a1026", O_RDWR);
   1310                 if (fd_a1026 < 0) {
   1311                     ALOGE("A1026 Fatal Error: unable to open A1026 after hard reset\n");
   1312                 } else {
   1313                     rc = ioctl(fd_a1026, A1026_SET_CONFIG, &new_pathid);
   1314                     if (!rc) {
   1315                         old_pathid = new_pathid;
   1316                     } else {
   1317                         ALOGE("A1026 Fatal Error: unable to A1026_SET_CONFIG after hard reset\n");
   1318                     }
   1319                 }
   1320             } else
   1321                 ALOGE("A1026 Fatal Error: Re-init A1026 Failed\n");
   1322         }
   1323     }
   1324 
   1325     if (fd_a1026 >= 0) {
   1326         close(fd_a1026);
   1327     }
   1328     fd_a1026 = -1;
   1329     mA1026Lock.unlock();
   1330 
   1331     return rc;
   1332 }
   1333 
   1334 
   1335 status_t AudioHardware::doRouting()
   1336 {
   1337     Mutex::Autolock lock(mLock);
   1338     uint32_t outputDevices = mOutput->devices();
   1339     status_t ret = NO_ERROR;
   1340     AudioStreamInMSM72xx *input = getActiveInput_l();
   1341     uint32_t inputDevice = (input == NULL) ? 0 : input->devices();
   1342     int sndDevice = -1;
   1343 
   1344     if (mMode == AudioSystem::MODE_IN_CALL && mTTYMode != TTY_MODE_OFF) {
   1345         if ((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) ||
   1346             (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE)) {
   1347             switch (mTTYMode) {
   1348             case TTY_MODE_FULL:
   1349                 sndDevice = SND_DEVICE_TTY_FULL;
   1350                 break;
   1351             case TTY_MODE_VCO:
   1352                 sndDevice = SND_DEVICE_TTY_VCO;
   1353                 break;
   1354             case TTY_MODE_HCO:
   1355                 sndDevice = SND_DEVICE_TTY_HCO;
   1356                 break;
   1357             }
   1358         }
   1359     }
   1360 
   1361     if (sndDevice == -1 && inputDevice != 0) {
   1362         ALOGI("do input routing device %x\n", inputDevice);
   1363         if (inputDevice & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
   1364             ALOGI("Routing audio to Bluetooth PCM\n");
   1365             sndDevice = SND_DEVICE_BT;
   1366         } else if (inputDevice & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
   1367             ALOGI("Routing audio to Bluetooth car kit\n");
   1368             sndDevice = SND_DEVICE_CARKIT;
   1369         } else if (inputDevice & AudioSystem::DEVICE_IN_WIRED_HEADSET) {
   1370             if ((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) &&
   1371                     (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER)) {
   1372                         ALOGI("Routing audio to Wired Headset and Speaker\n");
   1373                         sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER;
   1374             } else {
   1375                 ALOGI("Routing audio to Wired Headset\n");
   1376                 sndDevice = SND_DEVICE_HEADSET;
   1377             }
   1378         } else if (inputDevice & AudioSystem::DEVICE_IN_BACK_MIC) {
   1379             if (outputDevices & (AudioSystem:: DEVICE_OUT_WIRED_HEADSET) &&
   1380                    (outputDevices & AudioSystem:: DEVICE_OUT_SPEAKER)) {
   1381                 ALOGI("Routing audio to Wired Headset and Speaker with back mic\n");
   1382                 sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER_BACK_MIC;
   1383             } else if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
   1384                 ALOGI("Routing audio to Speakerphone with back mic\n");
   1385                 sndDevice = SND_DEVICE_SPEAKER_BACK_MIC;
   1386             } else if (outputDevices == AudioSystem::DEVICE_OUT_EARPIECE) {
   1387                 ALOGI("Routing audio to Handset with back mic\n");
   1388                 sndDevice = SND_DEVICE_HANDSET_BACK_MIC;
   1389             } else {
   1390                 ALOGI("Routing audio to Headset with back mic\n");
   1391                 sndDevice = SND_DEVICE_NO_MIC_HEADSET_BACK_MIC;
   1392             }
   1393         } else {
   1394             if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
   1395                 ALOGI("Routing audio to Speakerphone\n");
   1396                 sndDevice = SND_DEVICE_SPEAKER;
   1397             } else if (outputDevices == AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
   1398                 ALOGI("Routing audio to Speakerphone\n");
   1399                 sndDevice = SND_DEVICE_NO_MIC_HEADSET;
   1400             } else {
   1401                 ALOGI("Routing audio to Handset\n");
   1402                 sndDevice = SND_DEVICE_HANDSET;
   1403             }
   1404         }
   1405     }
   1406     // if inputDevice == 0, restore output routing
   1407 
   1408     if (sndDevice == -1) {
   1409         if (outputDevices & (outputDevices - 1)) {
   1410             if ((outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) == 0) {
   1411                 ALOGW("Hardware does not support requested route combination (%#X),"
   1412                         " picking closest possible route...", outputDevices);
   1413             }
   1414         }
   1415 
   1416         if (outputDevices &
   1417                 (AudioSystem::DEVICE_OUT_BLUETOOTH_SCO | AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET)) {
   1418                     ALOGI("Routing audio to Bluetooth PCM\n");
   1419                     sndDevice = SND_DEVICE_BT;
   1420         } else if (outputDevices & AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
   1421             ALOGI("Routing audio to Bluetooth PCM\n");
   1422             sndDevice = SND_DEVICE_CARKIT;
   1423         } else if ((outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) &&
   1424                 (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER)) {
   1425                     ALOGI("Routing audio to Wired Headset and Speaker\n");
   1426                     sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER;
   1427         } else if (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
   1428             if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
   1429                 ALOGI("Routing audio to No microphone Wired Headset and Speaker (%d,%x)\n", mMode, outputDevices);
   1430                 sndDevice = SND_DEVICE_HEADSET_AND_SPEAKER;
   1431             } else {
   1432                 ALOGI("Routing audio to No microphone Wired Headset (%d,%x)\n", mMode, outputDevices);
   1433                 sndDevice = SND_DEVICE_NO_MIC_HEADSET;
   1434             }
   1435         } else if (outputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
   1436             ALOGI("Routing audio to Wired Headset\n");
   1437             sndDevice = SND_DEVICE_HEADSET;
   1438         } else if (outputDevices & AudioSystem::DEVICE_OUT_SPEAKER) {
   1439             ALOGI("Routing audio to Speakerphone\n");
   1440             sndDevice = SND_DEVICE_SPEAKER;
   1441         } else {
   1442             ALOGI("Routing audio to Handset\n");
   1443             sndDevice = SND_DEVICE_HANDSET;
   1444         }
   1445     }
   1446 
   1447     if ((vr_mode_change) || (sndDevice != -1 && sndDevice != mCurSndDevice)) {
   1448         ret = doAudioRouteOrMute(sndDevice);
   1449         mCurSndDevice = sndDevice;
   1450         if (mMode == AudioSystem::MODE_IN_CALL) {
   1451             if (mHACSetting && hac_enable && mCurSndDevice == (int) SND_DEVICE_HANDSET) {
   1452                 ALOGD("HAC enable: Setting in-call volume to maximum.\n");
   1453                 set_volume_rpc(VOICE_VOLUME_MAX);
   1454             } else {
   1455                 set_volume_rpc(mVoiceVolume);
   1456             }
   1457         }
   1458     }
   1459 
   1460     return ret;
   1461 }
   1462 
   1463 status_t AudioHardware::checkMicMute()
   1464 {
   1465     Mutex::Autolock lock(mLock);
   1466     if (mMode != AudioSystem::MODE_IN_CALL) {
   1467         setMicMute_nosync(true);
   1468     }
   1469 
   1470     return NO_ERROR;
   1471 }
   1472 
   1473 status_t AudioHardware::dumpInternals(int fd, const Vector<String16>& args)
   1474 {
   1475     const size_t SIZE = 256;
   1476     char buffer[SIZE];
   1477     String8 result;
   1478     result.append("AudioHardware::dumpInternals\n");
   1479     snprintf(buffer, SIZE, "\tmInit: %s\n", mInit? "true": "false");
   1480     result.append(buffer);
   1481     snprintf(buffer, SIZE, "\tmMicMute: %s\n", mMicMute? "true": "false");
   1482     result.append(buffer);
   1483     snprintf(buffer, SIZE, "\tmBluetoothNrec: %s\n", mBluetoothNrec? "true": "false");
   1484     result.append(buffer);
   1485     snprintf(buffer, SIZE, "\tmBluetoothIdtx: %d\n", mBluetoothIdTx);
   1486     result.append(buffer);
   1487     snprintf(buffer, SIZE, "\tmBluetoothIdrx: %d\n", mBluetoothIdRx);
   1488     result.append(buffer);
   1489     ::write(fd, result.string(), result.size());
   1490     return NO_ERROR;
   1491 }
   1492 
   1493 status_t AudioHardware::dump(int fd, const Vector<String16>& args)
   1494 {
   1495     dumpInternals(fd, args);
   1496     for (size_t index = 0; index < mInputs.size(); index++) {
   1497         mInputs[index]->dump(fd, args);
   1498     }
   1499 
   1500     if (mOutput) {
   1501         mOutput->dump(fd, args);
   1502     }
   1503     return NO_ERROR;
   1504 }
   1505 
   1506 uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate)
   1507 {
   1508     uint32_t i;
   1509     uint32_t prevDelta;
   1510     uint32_t delta;
   1511 
   1512     for (i = 0, prevDelta = 0xFFFFFFFF; i < sizeof(inputSamplingRates)/sizeof(uint32_t); i++, prevDelta = delta) {
   1513         delta = abs(sampleRate - inputSamplingRates[i]);
   1514         if (delta > prevDelta) break;
   1515     }
   1516     // i is always > 0 here
   1517     return inputSamplingRates[i-1];
   1518 }
   1519 
   1520 // getActiveInput_l() must be called with mLock held
   1521 AudioHardware::AudioStreamInMSM72xx *AudioHardware::getActiveInput_l()
   1522 {
   1523     for (size_t i = 0; i < mInputs.size(); i++) {
   1524         // return first input found not being in standby mode
   1525         // as only one input can be in this state
   1526         if (!mInputs[i]->checkStandby()) {
   1527             return mInputs[i];
   1528         }
   1529     }
   1530 
   1531     return NULL;
   1532 }
   1533 // ----------------------------------------------------------------------------
   1534 
   1535 AudioHardware::AudioStreamOutMSM72xx::AudioStreamOutMSM72xx() :
   1536     mHardware(0), mFd(-1), mStartCount(0), mRetryCount(0), mStandby(true),
   1537     mDevices(0), mChannels(AUDIO_HW_OUT_CHANNELS), mSampleRate(AUDIO_HW_OUT_SAMPLERATE),
   1538     mBufferSize(AUDIO_HW_OUT_BUFSZ)
   1539 {
   1540 }
   1541 
   1542 status_t AudioHardware::AudioStreamOutMSM72xx::set(
   1543         AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate)
   1544 {
   1545     int lFormat = pFormat ? *pFormat : 0;
   1546     uint32_t lChannels = pChannels ? *pChannels : 0;
   1547     uint32_t lRate = pRate ? *pRate : 0;
   1548 
   1549     mHardware = hw;
   1550     mDevices = devices;
   1551 
   1552     // fix up defaults
   1553     if (lFormat == 0) lFormat = format();
   1554     if (lChannels == 0) lChannels = channels();
   1555     if (lRate == 0) lRate = sampleRate();
   1556 
   1557     // check values
   1558     if ((lFormat != format()) ||
   1559         (lChannels != channels()) ||
   1560         (lRate != sampleRate())) {
   1561         if (pFormat) *pFormat = format();
   1562         if (pChannels) *pChannels = channels();
   1563         if (pRate) *pRate = sampleRate();
   1564         return BAD_VALUE;
   1565     }
   1566 
   1567     if (pFormat) *pFormat = lFormat;
   1568     if (pChannels) *pChannels = lChannels;
   1569     if (pRate) *pRate = lRate;
   1570 
   1571     mChannels = lChannels;
   1572     mSampleRate = lRate;
   1573     mBufferSize = hw->getBufferSize(lRate, AudioSystem::popCount(lChannels));
   1574 
   1575     return NO_ERROR;
   1576 }
   1577 
   1578 AudioHardware::AudioStreamOutMSM72xx::~AudioStreamOutMSM72xx()
   1579 {
   1580     standby();
   1581 }
   1582 
   1583 ssize_t AudioHardware::AudioStreamOutMSM72xx::write(const void* buffer, size_t bytes)
   1584 {
   1585     // ALOGD("AudioStreamOutMSM72xx::write(%p, %u)", buffer, bytes);
   1586     status_t status = NO_INIT;
   1587     size_t count = bytes;
   1588     const uint8_t* p = static_cast<const uint8_t*>(buffer);
   1589 
   1590     if (mStandby) {
   1591 
   1592         ALOGV("acquire output wakelock");
   1593         acquire_wake_lock(PARTIAL_WAKE_LOCK, kOutputWakelockStr);
   1594 
   1595         // open driver
   1596         ALOGV("open pcm_out driver");
   1597         status = ::open("/dev/msm_pcm_out", O_RDWR);
   1598         if (status < 0) {
   1599             if (errCount++ < 10) {
   1600                 ALOGE("Cannot open /dev/msm_pcm_out errno: %d", errno);
   1601             }
   1602             release_wake_lock(kOutputWakelockStr);
   1603             goto Error;
   1604         }
   1605         mFd = status;
   1606         mStandby = false;
   1607 
   1608         // configuration
   1609         ALOGV("get config");
   1610         struct msm_audio_config config;
   1611         status = ioctl(mFd, AUDIO_GET_CONFIG, &config);
   1612         if (status < 0) {
   1613             ALOGE("Cannot read pcm_out config");
   1614             goto Error;
   1615         }
   1616 
   1617         ALOGV("set pcm_out config");
   1618         config.channel_count = AudioSystem::popCount(channels());
   1619         config.sample_rate = mSampleRate;
   1620         config.buffer_size = mBufferSize;
   1621         config.buffer_count = AUDIO_HW_NUM_OUT_BUF;
   1622         config.codec_type = CODEC_TYPE_PCM;
   1623         status = ioctl(mFd, AUDIO_SET_CONFIG, &config);
   1624         if (status < 0) {
   1625             ALOGE("Cannot set config");
   1626             goto Error;
   1627         }
   1628 
   1629         ALOGV("buffer_size: %u", config.buffer_size);
   1630         ALOGV("buffer_count: %u", config.buffer_count);
   1631         ALOGV("channel_count: %u", config.channel_count);
   1632         ALOGV("sample_rate: %u", config.sample_rate);
   1633 
   1634         uint32_t acdb_id = mHardware->getACDB(MOD_PLAY, mHardware->get_snd_dev());
   1635         status = ioctl(mFd, AUDIO_START, &acdb_id);
   1636         if (status < 0) {
   1637             ALOGE("Cannot start pcm playback");
   1638             goto Error;
   1639         }
   1640 
   1641         status = ioctl(mFd, AUDIO_SET_VOLUME, &stream_volume);
   1642         if (status < 0) {
   1643             ALOGE("Cannot start pcm playback");
   1644             goto Error;
   1645         }
   1646     }
   1647 
   1648     while (count) {
   1649         ssize_t written = ::write(mFd, p, count);
   1650         if (written >= 0) {
   1651             count -= written;
   1652             p += written;
   1653         } else {
   1654             if (errno != EAGAIN) {
   1655                 status = written;
   1656                 goto Error;
   1657             }
   1658             mRetryCount++;
   1659             ALOGD("EAGAIN - retry");
   1660         }
   1661     }
   1662 
   1663     return bytes;
   1664 
   1665 Error:
   1666 
   1667     standby();
   1668 
   1669     // Simulate audio output timing in case of error
   1670     usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate());
   1671     return status;
   1672 }
   1673 
   1674 status_t AudioHardware::AudioStreamOutMSM72xx::standby()
   1675 {
   1676     if (!mStandby) {
   1677         ALOGD("AudioHardware pcm playback is going to standby.");
   1678         if (mFd >= 0) {
   1679             ::close(mFd);
   1680             mFd = -1;
   1681         }
   1682         ALOGV("release output wakelock");
   1683         release_wake_lock(kOutputWakelockStr);
   1684         mStandby = true;
   1685     }
   1686     return NO_ERROR;
   1687 }
   1688 
   1689 status_t AudioHardware::AudioStreamOutMSM72xx::dump(int fd, const Vector<String16>& args)
   1690 {
   1691     const size_t SIZE = 256;
   1692     char buffer[SIZE];
   1693     String8 result;
   1694     result.append("AudioStreamOutMSM72xx::dump\n");
   1695     snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
   1696     result.append(buffer);
   1697     snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
   1698     result.append(buffer);
   1699     snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
   1700     result.append(buffer);
   1701     snprintf(buffer, SIZE, "\tformat: %d\n", format());
   1702     result.append(buffer);
   1703     snprintf(buffer, SIZE, "\tmHardware: %p\n", mHardware);
   1704     result.append(buffer);
   1705     snprintf(buffer, SIZE, "\tmFd: %d\n", mFd);
   1706     result.append(buffer);
   1707     snprintf(buffer, SIZE, "\tmStartCount: %d\n", mStartCount);
   1708     result.append(buffer);
   1709     snprintf(buffer, SIZE, "\tmRetryCount: %d\n", mRetryCount);
   1710     result.append(buffer);
   1711     snprintf(buffer, SIZE, "\tmStandby: %s\n", mStandby? "true": "false");
   1712     result.append(buffer);
   1713     ::write(fd, result.string(), result.size());
   1714     return NO_ERROR;
   1715 }
   1716 
   1717 
   1718 bool AudioHardware::AudioStreamOutMSM72xx::checkStandby()
   1719 {
   1720     return mStandby;
   1721 }
   1722 
   1723 
   1724 status_t AudioHardware::AudioStreamOutMSM72xx::setParameters(const String8& keyValuePairs)
   1725 {
   1726     AudioParameter param = AudioParameter(keyValuePairs);
   1727     String8 key = String8(AudioParameter::keyRouting);
   1728     status_t status = NO_ERROR;
   1729     int device;
   1730     ALOGV("AudioStreamOutMSM72xx::setParameters() %s", keyValuePairs.string());
   1731 
   1732     if (param.getInt(key, device) == NO_ERROR) {
   1733         mDevices = device;
   1734         ALOGV("set output routing %x", mDevices);
   1735         status = mHardware->doRouting();
   1736         param.remove(key);
   1737     }
   1738 
   1739     if (param.size()) {
   1740         status = BAD_VALUE;
   1741     }
   1742     return status;
   1743 }
   1744 
   1745 String8 AudioHardware::AudioStreamOutMSM72xx::getParameters(const String8& keys)
   1746 {
   1747     AudioParameter param = AudioParameter(keys);
   1748     String8 value;
   1749     String8 key = String8(AudioParameter::keyRouting);
   1750 
   1751     if (param.get(key, value) == NO_ERROR) {
   1752         ALOGV("get routing %x", mDevices);
   1753         param.addInt(key, (int)mDevices);
   1754     }
   1755 
   1756     ALOGV("AudioStreamOutMSM72xx::getParameters() %s", param.toString().string());
   1757     return param.toString();
   1758 }
   1759 
   1760 status_t AudioHardware::AudioStreamOutMSM72xx::getRenderPosition(uint32_t *dspFrames)
   1761 {
   1762     //TODO: enable when supported by driver
   1763     return INVALID_OPERATION;
   1764 }
   1765 
   1766 // ----------------------------------------------------------------------------
   1767 
   1768 AudioHardware::AudioStreamInMSM72xx::AudioStreamInMSM72xx() :
   1769     mHardware(0), mFd(-1), mStandby(true), mRetryCount(0),
   1770     mFormat(AUDIO_HW_IN_FORMAT), mChannels(AUDIO_HW_IN_CHANNELS),
   1771     mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_BUFSZ),
   1772     mAcoustics((AudioSystem::audio_in_acoustics)0), mDevices(0)
   1773 {
   1774 }
   1775 
   1776 status_t AudioHardware::AudioStreamInMSM72xx::set(
   1777         AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate,
   1778         AudioSystem::audio_in_acoustics acoustic_flags)
   1779 {
   1780     if (pFormat == 0 || *pFormat != AUDIO_HW_IN_FORMAT) {
   1781         *pFormat = AUDIO_HW_IN_FORMAT;
   1782         return BAD_VALUE;
   1783     }
   1784     if (pRate == 0) {
   1785         return BAD_VALUE;
   1786     }
   1787     uint32_t rate = hw->getInputSampleRate(*pRate);
   1788     if (rate != *pRate) {
   1789         *pRate = rate;
   1790         return BAD_VALUE;
   1791     }
   1792 
   1793     if (pChannels == 0 || (*pChannels != AudioSystem::CHANNEL_IN_MONO &&
   1794         *pChannels != AudioSystem::CHANNEL_IN_STEREO)) {
   1795         *pChannels = AUDIO_HW_IN_CHANNELS;
   1796         return BAD_VALUE;
   1797     }
   1798 
   1799     mHardware = hw;
   1800 
   1801     ALOGV("AudioStreamInMSM72xx::set(%d, %d, %u)", *pFormat, *pChannels, *pRate);
   1802     if (mFd >= 0) {
   1803         ALOGE("Audio record already open");
   1804         return -EPERM;
   1805     }
   1806 
   1807     mBufferSize = hw->getBufferSize(*pRate, AudioSystem::popCount(*pChannels));
   1808     mDevices = devices;
   1809     mFormat = AUDIO_HW_IN_FORMAT;
   1810     mChannels = *pChannels;
   1811     mSampleRate = *pRate;
   1812 
   1813     return NO_ERROR;
   1814 
   1815 }
   1816 
   1817 AudioHardware::AudioStreamInMSM72xx::~AudioStreamInMSM72xx()
   1818 {
   1819     ALOGV("AudioStreamInMSM72xx destructor");
   1820     standby();
   1821 }
   1822 
   1823 ssize_t AudioHardware::AudioStreamInMSM72xx::read( void* buffer, ssize_t bytes)
   1824 {
   1825 //    ALOGV("AudioStreamInMSM72xx::read(%p, %ld)", buffer, bytes);
   1826     if (!mHardware) return -1;
   1827 
   1828     size_t count = bytes;
   1829     uint8_t* p = static_cast<uint8_t*>(buffer);
   1830     status_t status = NO_ERROR;
   1831 
   1832     if (mStandby) {
   1833         {   // scope for the lock
   1834             Mutex::Autolock lock(mHardware->mLock);
   1835             ALOGV("acquire input wakelock");
   1836             acquire_wake_lock(PARTIAL_WAKE_LOCK, kInputWakelockStr);
   1837             // open audio input device
   1838             status = ::open("/dev/msm_pcm_in", O_RDWR);
   1839             if (status < 0) {
   1840                 ALOGE("Cannot open /dev/msm_pcm_in errno: %d", errno);
   1841                 ALOGV("release input wakelock");
   1842                 release_wake_lock(kInputWakelockStr);
   1843                 goto Error;
   1844             }
   1845             mFd = status;
   1846             mStandby = false;
   1847 
   1848             // configuration
   1849             ALOGV("get config");
   1850             struct msm_audio_config config;
   1851             status = ioctl(mFd, AUDIO_GET_CONFIG, &config);
   1852             if (status < 0) {
   1853                 ALOGE("Cannot read config");
   1854                 goto Error;
   1855             }
   1856 
   1857             ALOGV("set config");
   1858             config.channel_count = AudioSystem::popCount(mChannels);
   1859             config.sample_rate = mSampleRate;
   1860             config.buffer_size = mBufferSize;
   1861             config.buffer_count = 2;
   1862             config.codec_type = CODEC_TYPE_PCM;
   1863             status = ioctl(mFd, AUDIO_SET_CONFIG, &config);
   1864             if (status < 0) {
   1865                 ALOGE("Cannot set config");
   1866                 goto Error;
   1867             }
   1868 
   1869             ALOGV("buffer_size: %u", config.buffer_size);
   1870             ALOGV("buffer_count: %u", config.buffer_count);
   1871             ALOGV("channel_count: %u", config.channel_count);
   1872             ALOGV("sample_rate: %u", config.sample_rate);
   1873         }
   1874 
   1875         mHardware->set_mRecordState(1);
   1876         // make sure a1026 config is re-applied even is input device is not changed
   1877         mHardware->clearCurDevice();
   1878         mHardware->doRouting();
   1879 
   1880         uint32_t acdb_id = mHardware->getACDB(MOD_REC, mHardware->get_snd_dev());
   1881         if (ioctl(mFd, AUDIO_START, &acdb_id)) {
   1882             ALOGE("Error starting record");
   1883             goto Error;
   1884         }
   1885     }
   1886 
   1887     while (count) {
   1888         ssize_t bytesRead = ::read(mFd, buffer, count);
   1889         if (bytesRead >= 0) {
   1890             count -= bytesRead;
   1891             p += bytesRead;
   1892         } else {
   1893             if (errno != EAGAIN) {
   1894                 status = bytesRead;
   1895                 goto Error;
   1896             }
   1897             mRetryCount++;
   1898             ALOGD("EAGAIN - retrying");
   1899         }
   1900     }
   1901     return bytes;
   1902 
   1903 Error:
   1904     standby();
   1905 
   1906     // Simulate audio input timing in case of error
   1907     usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate());
   1908 
   1909     return status;
   1910 }
   1911 
   1912 status_t AudioHardware::AudioStreamInMSM72xx::standby()
   1913 {
   1914     if (!mStandby) {
   1915         ALOGD("AudioHardware PCM record is going to standby.");
   1916         if (mFd >= 0) {
   1917             ::close(mFd);
   1918             mFd = -1;
   1919         }
   1920         ALOGV("release input wakelock");
   1921         release_wake_lock(kInputWakelockStr);
   1922 
   1923         mStandby = true;
   1924 
   1925         if (!mHardware) return -1;
   1926 
   1927         mHardware->set_mRecordState(0);
   1928         // make sure a1026 config is re-applied even is input device is not changed
   1929         mHardware->clearCurDevice();
   1930         mHardware->doRouting();
   1931     }
   1932 
   1933     return NO_ERROR;
   1934 }
   1935 
   1936 bool AudioHardware::AudioStreamInMSM72xx::checkStandby()
   1937 {
   1938     return mStandby;
   1939 }
   1940 
   1941 status_t AudioHardware::AudioStreamInMSM72xx::dump(int fd, const Vector<String16>& args)
   1942 {
   1943     const size_t SIZE = 256;
   1944     char buffer[SIZE];
   1945     String8 result;
   1946     result.append("AudioStreamInMSM72xx::dump\n");
   1947     snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
   1948     result.append(buffer);
   1949     snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
   1950     result.append(buffer);
   1951     snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
   1952     result.append(buffer);
   1953     snprintf(buffer, SIZE, "\tformat: %d\n", format());
   1954     result.append(buffer);
   1955     snprintf(buffer, SIZE, "\tmHardware: %p\n", mHardware);
   1956     result.append(buffer);
   1957     snprintf(buffer, SIZE, "\tmFd count: %d\n", mFd);
   1958     result.append(buffer);
   1959     snprintf(buffer, SIZE, "\tmStandby: %d\n", mStandby);
   1960     result.append(buffer);
   1961     snprintf(buffer, SIZE, "\tmRetryCount: %d\n", mRetryCount);
   1962     result.append(buffer);
   1963     ::write(fd, result.string(), result.size());
   1964     return NO_ERROR;
   1965 }
   1966 
   1967 status_t AudioHardware::AudioStreamInMSM72xx::setParameters(const String8& keyValuePairs)
   1968 {
   1969     AudioParameter param = AudioParameter(keyValuePairs);
   1970     status_t status = NO_ERROR;
   1971     int device;
   1972     String8 key = String8(AudioParameter::keyInputSource);
   1973     int source;
   1974     ALOGV("AudioStreamInMSM72xx::setParameters() %s", keyValuePairs.string());
   1975 
   1976     // reading input source for voice recognition mode parameter
   1977     if (param.getInt(key, source) == NO_ERROR) {
   1978         ALOGV("set input source %d", source);
   1979         int uses_vr = (source == AUDIO_SOURCE_VOICE_RECOGNITION);
   1980         vr_mode_change = (vr_mode_enabled != uses_vr);
   1981         vr_mode_enabled = uses_vr;
   1982         param.remove(key);
   1983     }
   1984 
   1985     // reading routing parameter
   1986     key = String8(AudioParameter::keyRouting);
   1987     if (param.getInt(key, device) == NO_ERROR) {
   1988         ALOGV("set input routing %x", device);
   1989         if (device & (device - 1)) {
   1990             status = BAD_VALUE;
   1991         } else {
   1992             mDevices = device;
   1993             status = mHardware->doRouting();
   1994         }
   1995         param.remove(key);
   1996     }
   1997 
   1998     if (param.size()) {
   1999         status = BAD_VALUE;
   2000     }
   2001     return status;
   2002 }
   2003 
   2004 String8 AudioHardware::AudioStreamInMSM72xx::getParameters(const String8& keys)
   2005 {
   2006     AudioParameter param = AudioParameter(keys);
   2007     String8 value;
   2008     String8 key = String8(AudioParameter::keyRouting);
   2009 
   2010     if (param.get(key, value) == NO_ERROR) {
   2011         ALOGV("get routing %x", mDevices);
   2012         param.addInt(key, (int)mDevices);
   2013     }
   2014 
   2015     ALOGV("AudioStreamInMSM72xx::getParameters() %s", param.toString().string());
   2016     return param.toString();
   2017 }
   2018 
   2019 // ----------------------------------------------------------------------------
   2020 
   2021 extern "C" AudioHardwareInterface* createAudioHardware(void) {
   2022     return new AudioHardware();
   2023 }
   2024 
   2025 }; // namespace android
   2026