libfm_jni/FmRadioController.cpp

/*
Copyright (c) 2015, The Linux Foundation. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above
      copyright notice, this list of conditions and the following
      disclaimer in the documentation and/or other materials provided
      with the distribution.
    * Neither the name of The Linux Foundation nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <utils/Log.h>
#include <cutils/properties.h>
#include <sys/ioctl.h>
#include <math.h>
#include "FmRadioController.h"
#include "FmIoctlsInterface.h"
#include "ConfigFmThs.h"
#include <linux/videodev2.h>

//Reset all variables to default value
static FmIoctlsInterface * FmIoct;
FmRadioController :: FmRadioController
(
)
{
    cur_fm_state = FM_OFF;
    prev_freq = -1;
    seek_scan_canceled = false;
    af_enabled = 0;
    rds_enabled = 0;
    event_listener_canceled = false;
    is_rds_support = false;
    is_ps_event_received = false;
    is_rt_event_received = false;
    is_af_jump_received = false;
    mutex_fm_state = PTHREAD_MUTEX_INITIALIZER;
    mutex_seek_compl_cond = PTHREAD_MUTEX_INITIALIZER;
    mutex_scan_compl_cond = PTHREAD_MUTEX_INITIALIZER;
    mutex_tune_compl_cond = PTHREAD_MUTEX_INITIALIZER;
    mutex_turn_on_cond = PTHREAD_MUTEX_INITIALIZER;
    turn_on_cond = PTHREAD_COND_INITIALIZER;
    seek_compl_cond = PTHREAD_COND_INITIALIZER;
    scan_compl_cond = PTHREAD_COND_INITIALIZER;
    tune_compl_cond = PTHREAD_COND_INITIALIZER;
    event_listener_thread = 0;
    fd_driver = -1;
    FmIoct = new FmIoctlsInterface();
}

/* Turn off FM */
FmRadioController :: ~FmRadioController
(
)
{
    if((cur_fm_state != FM_OFF)) {
        Stop_Scan_Seek();
        set_fm_state(FM_OFF_IN_PROGRESS);
        FmIoctlsInterface::set_control(fd_driver,
                        V4L2_CID_PRV_STATE, FM_DEV_NONE);
    }
    if(event_listener_thread != 0) {
        event_listener_canceled = true;
        pthread_join(event_listener_thread, NULL);
    }
}

int FmRadioController ::open_dev()
{
    int ret = FM_SUCCESS;

    fd_driver = open(FM_DEVICE_PATH, O_RDONLY, O_NONBLOCK);

    if (fd_driver < 0) {
        ALOGE("%s failed, [fd=%d] %s\n", __func__, fd_driver, FM_DEVICE_PATH);
        return FM_FAILURE;
    }

    ALOGD("%s, [fd=%d] \n", __func__, fd_driver);
    return ret;
}

int FmRadioController ::close_dev()
{
    int ret = 0;

    if (fd_driver > 0) {
        close(fd_driver);
        fd_driver = -1;
    }
    ALOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd_driver, ret);
    return ret;
}

struct timespec FmRadioController :: set_time_out
(
    int secs
)
{
    struct timespec ts;
    struct timeval tp;

    gettimeofday(&tp, NULL);
    ts.tv_sec = tp.tv_sec;
    ts.tv_nsec = tp.tv_usec * 1000;
    ts.tv_sec += secs;

    return ts;
}

//Get current tuned frequency
//Return -1 if failed to get freq
long FmRadioController :: GetChannel
(
    void
)
{
    long freq = -1;
    int ret;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
       ret = FmIoctlsInterface::get_cur_freq(fd_driver, freq);
       if(ret == FM_SUCCESS) {
          ALOGI("FM get freq is successfull, freq is: %ld\n", freq);
       }else {
          ALOGE("FM get frequency failed, freq is: %ld\n", freq);
       }
    }else {
       ALOGE("FM get freq is not valid in current state\n");
    }
    return freq;
}

int FmRadioController ::Pwr_Up(int freq)
{
    int ret = FM_SUCCESS;
    struct timespec ts;
    ConfigFmThs thsObj;
    char value[PROPERTY_VALUE_MAX] = {'\0'};

    ALOGI("%s,[freq=%d]\n", __func__, freq);
    property_get("qcom.bluetooth.soc", value, NULL);
    ALOGD("BT soc is %s\n", value);
    if (fd_driver < 0) {
        ret = open_dev();
        if (ret != FM_SUCCESS) {
            ALOGE("Dev open failed\n");
            return FM_FAILURE;
        }
    }

    if (cur_fm_state == FM_OFF) {
        ALOGE("cur_fm_state = %d\n",cur_fm_state);
        if (strcmp(value, "rome") != 0) {
            ret = FmIoctlsInterface::start_fm_patch_dl(fd_driver);
            if (ret != FM_SUCCESS) {
                ALOGE("FM patch downloader failed: %d\n", ret);
                close_dev();
                set_fm_state(FM_OFF);
                return FM_FAILURE;
            }
        }
        if (event_listener_thread == 0) {
            ret = pthread_create(&event_listener_thread, NULL,
                                              handle_events, this);
            if (ret == 0) {
                ALOGI("Lock the mutex for FM turn on cond\n");
                pthread_mutex_lock(&mutex_turn_on_cond);
                ts = set_time_out(READY_EVENT_TIMEOUT);
                ret = FmIoctlsInterface::set_control(fd_driver,
                                             V4L2_CID_PRV_STATE, FM_RX);
                if (ret == FM_SUCCESS) {
                    ALOGI("Waiting for timedout or FM on\n");
                    pthread_cond_timedwait(&turn_on_cond,
                                       &mutex_turn_on_cond, &ts);
                    ALOGI("Unlocked mutex & timedout or condition satisfied\n");
                    pthread_mutex_unlock(&mutex_turn_on_cond);
                    if (cur_fm_state == FM_ON) {//after READY event
                        ret = SetBand(BAND_87500_108000);
                        if (ret != FM_SUCCESS) {
                            ALOGE("set band failed\n");
                            ret = FM_FAILURE;
                            goto exit;
                        }
                        ret = SetChannelSpacing(CHAN_SPACE_100);
                        if (ret != FM_SUCCESS) {
                            ALOGE("set channel spacing failed\n");
                            ret = FM_FAILURE;
                            goto exit;
                        }
                        ret = SetDeConstant(DE_EMP50);
                        if (ret != FM_SUCCESS) {
                            ALOGE("set Emphasis failed\n");
                            ret = FM_FAILURE;
                            goto exit;
                        }
                        thsObj.SetRxSearchAfThs(FM_PERFORMANCE_PARAMS, fd_driver);
                        SetStereo();
                        ret = TuneChannel(freq);
                        if (ret != FM_SUCCESS) {
                            ALOGI("FM set freq command failed\n");
                            ret = FM_FAILURE;
                            goto exit;
                        }
                        return FM_SUCCESS;
                    } else { //if time out
                        ret = FM_FAILURE;
                        goto exit;
                    }
                } else {
                    ALOGE("Set FM on control failed\n");
                    pthread_mutex_unlock(&mutex_turn_on_cond);
                    ALOGI("Unlocked the FM on cond mutex\n");
                    ret = FM_FAILURE;
                    goto close_fd;
                }
            } else {
                ALOGE("FM event listener thread failed: %d\n", ret);
                set_fm_state(FM_OFF);
                return FM_FAILURE;
            }
        } else {
            ALOGE("FM event listener threadi existed\n");
            return FM_SUCCESS;
        }
    } else if(cur_fm_state != FM_ON_IN_PROGRESS) {
        return FM_SUCCESS;
    } else {
        return FM_FAILURE;
    }

exit:
    FmIoctlsInterface::set_control(fd_driver,
                                     V4L2_CID_PRV_STATE, FM_DEV_NONE);
close_fd:
    event_listener_canceled = true;
    pthread_join(event_listener_thread, NULL);
    close(fd_driver);
    fd_driver = -1;
    set_fm_state(FM_OFF);

    ALOGD("%s, [ret=%d]\n", __func__, ret);
    return ret;
}

int FmRadioController ::Pwr_Down()
{
    int ret = 0;

    if((cur_fm_state != FM_OFF)) {
        Stop_Scan_Seek();
        set_fm_state(FM_OFF_IN_PROGRESS);
        FmIoctlsInterface::set_control(fd_driver,
                        V4L2_CID_PRV_STATE, FM_DEV_NONE);
    }
    if(event_listener_thread != 0) {
        ALOGD("%s, event_listener_thread canceeled\n", __func__);
        event_listener_canceled = true;
        pthread_join(event_listener_thread, NULL);
    }
    ALOGD("%s, [ret=%d]\n", __func__, ret);
    return ret;
}
//Tune to a Freq
//Return FM_SUCCESS on success FM_FAILURE
//on failure
int FmRadioController :: TuneChannel
(
    long freq
)
{
    int ret = FM_SUCCESS;
    struct timespec ts;

    if((cur_fm_state == FM_ON) &&
        (freq > 0)) {
        set_fm_state(FM_TUNE_IN_PROGRESS);
        ret = FmIoctlsInterface::set_freq(fd_driver,
                                             freq);
        if(ret == FM_SUCCESS) {
           ALOGI("FM set frequency command set successfully\n");
           pthread_mutex_lock(&mutex_tune_compl_cond);
           ts = set_time_out(TUNE_EVENT_TIMEOUT);
           ret = pthread_cond_timedwait(&tune_compl_cond, &mutex_tune_compl_cond, &ts);
           pthread_mutex_unlock(&mutex_tune_compl_cond);
        }else {
           if((cur_fm_state != FM_OFF)) {
              set_fm_state(FM_ON);
           }
           ALOGE("FM set freq command failed\n");
        }
    }else {
        ALOGE("Fm is not in proper state for tuning to a freq\n");
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: Seek(int dir)
{
    int ret = 0;
    int freq = -1;
    struct timespec ts;

    if (cur_fm_state != FM_ON) {
        ALOGE("%s error Fm state: %d\n", __func__,cur_fm_state);
        return FM_FAILURE;
    }

    ALOGI("FM seek started\n");
    set_fm_state(SEEK_IN_PROGRESS);
    ret = FmIoctlsInterface::set_control(fd_driver,
                                  V4L2_CID_PRV_SRCHMODE, SEEK_MODE);
    if (ret != FM_SUCCESS) {
        set_fm_state(FM_ON);
        return FM_FAILURE;
    }

    ret = FmIoctlsInterface::set_control(fd_driver,
                           V4L2_CID_PRV_SCANDWELL, SEEK_DWELL_TIME);
    if (ret != FM_SUCCESS) {
        set_fm_state(FM_ON);
        return FM_FAILURE;
    }

    if (dir == 1) {
        ret = FmIoctlsInterface::start_search(fd_driver,
                                                     SEARCH_UP);
    } else {
        ret = FmIoctlsInterface::start_search(fd_driver,
                                            SEARCH_DOWN);
    }

    if (ret != FM_SUCCESS) {
        set_fm_state(FM_ON);
        return FM_FAILURE;
    }
    pthread_mutex_lock(&mutex_seek_compl_cond);
    ts = set_time_out(SEEK_COMPL_TIMEOUT);
    ret = pthread_cond_timedwait(&seek_compl_cond, &mutex_seek_compl_cond, &ts);
    pthread_mutex_unlock(&mutex_seek_compl_cond);
    if ((cur_fm_state != SEEK_IN_PROGRESS) && !seek_scan_canceled) {
        ALOGI("Seek completed without timeout\n");
        freq = GetChannel();
    }
    seek_scan_canceled = false;
    return freq;
}

bool FmRadioController ::IsRds_support
(
    void
)
{
   is_rds_support = true;
   ALOGI("is_rds_support: \n", is_rds_support);
   return is_rds_support;
}

//HardMute both audio channels
int FmRadioController ::MuteOn()
{
    int ret;

    ALOGE("cur_fm_state = %d\n", cur_fm_state);
    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
       ret = FmIoctlsInterface::set_control(fd_driver,
                       V4L2_CID_AUDIO_MUTE, MUTE_L_R_CHAN);
       ALOGE("CMD executed mute\n");
    }else {
       ret = FM_FAILURE;
    }
    return ret;
}

//Unmute both audio channel
int FmRadioController ::MuteOff()
{
    int ret;

    ALOGE("cur_fm_state = %d\n", cur_fm_state);
    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_AUDIO_MUTE, UNMUTE_L_R_CHAN);
        ALOGE("CMD executed for unmute\n");
    }else {
        ret = FM_FAILURE;
    }
    return ret;
}

//
int FmRadioController ::SetSoftMute(bool mode)
{
    int ret;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                             V4L2_CID_PRV_SOFT_MUTE, mode);
    }else {
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: Set_mute(bool mute)
{
    int ret = 0;

    if (mute) {
        ret = MuteOn();
    } else {
        ret = MuteOff();
    }

    if (ret)
        ALOGE("%s failed, %d\n", __func__, ret);
    ALOGD("%s, [mute=%d] [ret=%d]\n", __func__, mute, ret);
    return ret;
}

int FmRadioController :: Stop_Scan_Seek
(
)
{
   int ret;

    if((cur_fm_state == SEEK_IN_PROGRESS) ||
       (cur_fm_state == SCAN_IN_PROGRESS)) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                                       V4L2_CID_PRV_SRCHON, 0);
        if (ret == FM_SUCCESS) {
            ALOGI("FM Seek cancel command set successfully\n");
            seek_scan_canceled = true;
        } else {
            ALOGE("FM Seek cancel command sent failed\n");
        }
    } else {
        ALOGE("FM is not in proper state for cancelling Seek operation\n");
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: ReadRDS() //todo define each RDS flag
{
   int ret = 0;

   if (is_ps_event_received)
       ret |= RDS_EVT_PS_UPDATE;
   if (is_rt_event_received)
       ret |= RDS_EVT_RT_UPDATE;
   if (is_af_jump_received)
       ret |= RDS_EVT_AF_JUMP;

   return ret;
}

int FmRadioController :: Get_ps(char *ps, int *ps_len)
{
    int ret = 0;
    int len = 0;
    char raw_rds[STD_BUF_SIZE];

    ret = FmIoctlsInterface::get_buffer(fd_driver,
                                    raw_rds, STD_BUF_SIZE, PS_IND);
    if (ret <= 0) {
        return FM_FAILURE;
    } else {
        if (raw_rds[PS_STR_NUM_IND] > 0) {
            if (ps != NULL) {
                for(int i = 0; i < MAX_PS_LEN; i++) {
                    ps[i] = raw_rds[PS_DATA_OFFSET_IND + i];
                    if (ps[i] == 0) {
                        break;
                    } else if((ps[len] <= LAST_CTRL_CHAR) ||
                              (ps[len] >= FIRST_NON_PRNT_CHAR)) {
                        ps[i] = SPACE_CHAR;
                        continue;
                    }
                    len++;
                }
                if (len < (MAX_PS_LEN - 1)) {
                    ps[len] = '\0';
                    *ps_len = len + 1;
                } else {
                    *ps_len = len;
                }
                ALOGI("PS is: %s\n", ps);
            } else {
                return FM_FAILURE;
            }
        }
    }
    is_ps_event_received = false;
    ALOGD("%s, [ps_len=%d]\n", __func__, *ps_len);
    return FM_SUCCESS;
}

int FmRadioController :: Get_rt(char *rt, int *rt_len)
{
    int ret = 0;
    int len = 0;
    char raw_rds[STD_BUF_SIZE];

    ret = FmIoctlsInterface::get_buffer(fd_driver,
                               raw_rds, STD_BUF_SIZE, RT_IND);
    if (ret <= 0) {
        return FM_FAILURE;
    } else {
        if (rt != NULL) {
            if ((raw_rds[RT_LEN_IND] > 0) &&
                (raw_rds[RT_LEN_IND] <= MAX_RT_LEN)) {
                for(len = 0; len < raw_rds[RT_LEN_IND]; len++) {
                   rt[len] = raw_rds[RT_DATA_OFFSET_IND + len];
                   ALOGI("Rt byte[%d]: %d\n", len, rt[len]);
                   if ((rt[len] <= LAST_CTRL_CHAR) ||
                       (rt[len] >= FIRST_NON_PRNT_CHAR)) {
                       rt[len] = SPACE_CHAR;
                       continue;
                   }
                }
                if (len < (MAX_RT_LEN - 1)) {
                    rt[len] = '\0';
                    *rt_len = len + 1;
                } else {
                    *rt_len = len;
                }
                ALOGI("Rt is: %s\n", rt);
                ALOGI("RT text A / B: %d\n", raw_rds[RT_A_B_FLAG_IND]);
            } else {
                return FM_FAILURE;
            }
        } else {
            return FM_FAILURE;
        }
    }
    is_rt_event_received = false;
    ALOGD("%s, [rt_len=%d]\n", __func__, *rt_len);
    return FM_SUCCESS;
}

int FmRadioController :: Get_AF_freq(uint16_t *ret_freq)
{
    int ret =0;
    ULINT lowBand, highBand;
    float real_freq = 0;

    ALOGI("get_AF_freq\n");
    ret = FmIoctlsInterface::get_lowerband_limit(fd_driver,
                                                         lowBand);
    if (ret != FM_SUCCESS) {
        ALOGE("failed to get lowerband: %d\n", ret);
        return FM_FAILURE;
    }
    ALOGI("lowBand = %ld\n",lowBand);
    ret = FmIoctlsInterface::get_upperband_limit(fd_driver,
                                                      highBand);
    if (ret != FM_SUCCESS) {
        ALOGE("failed to getgherband: %d\n", ret);
        return FM_FAILURE;
    }
    ALOGI("highBand = %ld\n",highBand);
    real_freq = GetChannel();
    if ((real_freq < lowBand ) || (real_freq > highBand)) {
        ALOGE("AF freq is not in band limits\ni");
        return FM_FAILURE;
    } else {
        *ret_freq = real_freq/100;
    }
    is_af_jump_received = false;
    return FM_SUCCESS;
}

//Emphasis:
//75microsec: 0, 50 microsec: 1
//return FM_SUCCESS on success, FM_FAILURE
//on failure
int FmRadioController :: SetDeConstant
(
    long emphasis
)
{
    int ret;

     ALOGE("cur_fm_state: %d, emphasis: %d\n", cur_fm_state, emphasis);
    if(cur_fm_state == FM_ON) {
        switch(emphasis) {
            case DE_EMP75:
            case DE_EMP50:
                ret = FmIoctlsInterface::set_control(fd_driver,
                       V4L2_CID_PRV_EMPHASIS, emphasis);
                break;
            default:
                ALOGE("FM value pass for set Deconstant is invalid\n");
                ret = FM_FAILURE;
                break;
        }
    }else {
        ALOGE("FM is not in proper state to set De constant\n");
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: GetStationList
(
    uint16_t *scan_tbl, int *max_cnt
)
{
    char srch_list[STD_BUF_SIZE];
    int ret;
    ULINT lowBand, highBand;
    int station_num = 0;
    int stationList[FM_RX_SRCHLIST_MAX_STATIONS];
    int tmpFreqByte1=0;
    int tmpFreqByte2=0;
    int freq = 0;
    float real_freq = 0;
    int i = 0, j = 0;

    ALOGI("getstationList\n");
    ret = FmIoctlsInterface::get_lowerband_limit(fd_driver,
                                                         lowBand);
    if (ret != FM_SUCCESS) {
        ALOGE("failed to get lowerband: %d\n", ret);
        return FM_FAILURE;
    }
    ALOGI("lowBand = %ld\n",lowBand);
    ret = FmIoctlsInterface::get_upperband_limit(fd_driver,
                                                      highBand);
    if (ret != FM_SUCCESS) {
        ALOGE("failed to getgherband: %d\n", ret);
        return FM_FAILURE;
    }
    ALOGI("highBand = %ld\n",highBand);
    ret = FmIoctlsInterface::get_buffer(fd_driver,
                          srch_list, STD_BUF_SIZE, STATION_LIST_IND);
    if ((int)srch_list[0] >0) {
        station_num = (int)srch_list[0];
    }
    ALOGI("station_num: %d ", station_num);
    *max_cnt = station_num;
    for (i=0;i<station_num;i++) {
        freq = 0;
        ALOGI(" Byte1 = %d", srch_list[i * NO_OF_BYTES_EACH_FREQ + 1]);
        ALOGI(" Byte2 = %d", srch_list[i * NO_OF_BYTES_EACH_FREQ + 2]);
        tmpFreqByte1 = srch_list[i * NO_OF_BYTES_EACH_FREQ + 1] & 0xFF;
        tmpFreqByte2 = srch_list[i * NO_OF_BYTES_EACH_FREQ + 2] & 0xFF;
        ALOGI(" tmpFreqByte1 = %d", tmpFreqByte1);
        ALOGI(" tmpFreqByte2 = %d", tmpFreqByte2);
        freq = (tmpFreqByte1 & EXTRACT_FIRST_BYTE) << 8;
        freq |= tmpFreqByte2;
        ALOGI(" freq: %d", freq);
        real_freq  = (freq * FREQ_MULTIPLEX) + lowBand;
        ALOGI(" real_freq: %d", real_freq);
        if ( (real_freq < lowBand ) || (real_freq > highBand) ) {
              ALOGI("Frequency out of band limits");
        } else {
            scan_tbl[j] = (real_freq/SRCH_DIV);
            ALOGI(" scan_tbl: %d", scan_tbl[j]);
            j++;
        }
    }
    return FM_SUCCESS;
}

int FmRadioController ::ScanList
(
    uint16_t *scan_tbl, int *max_cnt
)
{
    int ret;
    struct timespec ts;

    /* Check current state of FM device */
    if (cur_fm_state == FM_ON) {
        ALOGI("FM searchlist started\n");
        set_fm_state(SCAN_IN_PROGRESS);
        ret = FmIoctlsInterface::set_control(fd_driver,
                           V4L2_CID_PRV_SRCHMODE, SRCHLIST_MODE_STRONG);
        if (ret != FM_SUCCESS) {
            set_fm_state(FM_ON);
            return FM_FAILURE;
        }
        ret = FmIoctlsInterface::set_control(fd_driver,
                         V4L2_CID_PRV_SRCH_CNT, FM_RX_SRCHLIST_MAX_STATIONS);
        if (ret != FM_SUCCESS) {
            set_fm_state(FM_ON);
            return FM_FAILURE;
        }
        ret = FmIoctlsInterface::start_search(fd_driver,
                                                     SEARCH_UP);
        if (ret != FM_SUCCESS) {
            set_fm_state(FM_ON);
            return FM_FAILURE;
        }
        pthread_mutex_lock(&mutex_scan_compl_cond);
        ts = set_time_out(SCAN_COMPL_TIMEOUT);
        ALOGI("Wait for Scan Timeout or scan complete");
        ret = pthread_cond_timedwait(&scan_compl_cond, &mutex_scan_compl_cond, &ts);
        ALOGI("Scan complete or timedout");
        pthread_mutex_unlock(&mutex_scan_compl_cond);
        if (cur_fm_state == FM_ON && !seek_scan_canceled) {
            GetStationList(scan_tbl, max_cnt);
        } else {
            seek_scan_canceled = false;
            return FM_FAILURE;
        }
    } else {
        ALOGI("Scanlist: not proper state %d\n",cur_fm_state );
        return FM_FAILURE;
    }
    return FM_SUCCESS;
}

long FmRadioController :: GetCurrentRSSI
(
    void
)
{
    int ret;
    long rmssi = -129;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
        ret = FmIoctlsInterface::get_rmssi(fd_driver, rmssi);
    }else {
    }
    return rmssi;
}

//enable, disable value to receive data of a RDS group
//return FM_SUCCESS on success, FM_FAILURE on failure
int FmRadioController :: SetRdsGrpProcessing
(
    int grps
)
{
    int ret;
    long mask;

    if(cur_fm_state == FM_ON) {
       ret = FmIoctlsInterface::get_control(fd_driver,
                     V4L2_CID_PRV_RDSGROUP_PROC, mask);
       if(ret != FM_SUCCESS) {
          return ret;
       }
       mask &= 0xC7;
       mask |= ((grps & 0x07) << 3);
       ret = FmIoctlsInterface::set_control(fd_driver,
                    V4L2_CID_PRV_RDSGROUP_PROC, (int)mask);
    }else {
       ret = FM_FAILURE;
    }
    return ret;
}

//Enable RDS data receiving
//Enable RT, PS, AF Jump, RTPLUS, ERT etc
int FmRadioController :: EnableRDS
(
    void
)
{
    int ret = FM_FAILURE;

    ALOGE("%s:cur_fm_state = %d\n", __func__, cur_fm_state);
    if (cur_fm_state == FM_ON) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_RDSON, 1);
        if (ret != FM_SUCCESS) {
            ALOGE("RDS ON failed\n");
            return ret;
        }
        ret = SetRdsGrpProcessing(FM_RX_RDS_GRP_RT_EBL |
                                  FM_RX_RDS_GRP_PS_EBL |
                                  FM_RX_RDS_GRP_AF_EBL |
                                  FM_RX_RDS_GRP_PS_SIMPLE_EBL);
        if (ret != FM_SUCCESS) {
            ALOGE("Set RDS grp processing\n");
            return ret;
        }
        ret = FM_SUCCESS;
        rds_enabled = 1;
        EnableAF();
    } else {
        ALOGE("%s:not in proper state cur_fm_state = %d\n", cur_fm_state);
        return ret;
    }
    return ret;
}

//Disable all RDS data processing
//RT, ERT, RT PLUS, PS
int FmRadioController :: DisableRDS
(
    void
)
{
    int ret = FM_FAILURE;

    ALOGE("%s:cur_fm_state = %d\n", __func__, cur_fm_state);
    if (cur_fm_state == FM_ON) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_RDSON, 2);
        if (ret != FM_SUCCESS) {
            ALOGE("Disable RDS failed\n");
            return ret;
        }
        ret = FM_SUCCESS;
        rds_enabled = 0;
        DisableAF();
    } else {
        ALOGE("%s:not in proper state cur_fm_state = %d\n", cur_fm_state);
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: Turn_On_Off_Rds(bool onoff)
{
    int ret = 0;

    if (onoff) {
        ret = EnableRDS();
    } else {
        ret = DisableRDS();
    }

    if (ret) {
        ALOGE("%s, failed\n", __func__);
    }
    ALOGD("%s, [onoff=%d] [ret=%d]\n", __func__, onoff, ret);
    return ret;
}

//Enables Alternate Frequency switching
int FmRadioController :: EnableAF
(
    void
)
{
    int ret;
    long rdsgrps;

    if(cur_fm_state == FM_ON) {
        ret = FmIoctlsInterface::get_control(fd_driver,
                      V4L2_CID_PRV_RDSGROUP_PROC, rdsgrps);
        ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_RDSON, 1);
        if(ret == FM_SUCCESS) {
            ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_AF_JUMP, 1);
            if(ret == FM_SUCCESS) {
               af_enabled = 1;
            }
        } else {
        }
    } else {
        ret = FM_FAILURE;
    }
    return ret;
}

//Disables Alternate Frequency switching
int FmRadioController :: DisableAF
(
    void
)
{
    int ret;
    long rdsgrps;

    if(cur_fm_state == FM_ON) {
        ret = FmIoctlsInterface::get_control(fd_driver,
                      V4L2_CID_PRV_RDSGROUP_PROC, rdsgrps);
        if(ret == FM_SUCCESS) {
            ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_AF_JUMP, 0);
            if(ret == FM_SUCCESS) {
               af_enabled = 0;
            }
        }else {
        }
    }else {
        ret = FM_FAILURE;
    }
    return ret;
}

//Set regional band
int FmRadioController :: SetBand
(
    long band
)
{
    int ret;

    if(cur_fm_state == FM_ON) {
        switch(band) {
            case BAND_87500_108000:
                ret = FmIoctlsInterface::set_band(fd_driver,
                               87500, 108000);
                break;
            case BAND_76000_108000:
                ret = FmIoctlsInterface::set_band(fd_driver,
                               76000, 108000);
                break;
            case BAND_76000_90000:
                ret = FmIoctlsInterface::set_band(fd_driver,
                               76000, 90000);
                break;
            default:
                ALOGE("Band type: %ld is invalid\n", band);
                ret = FM_FAILURE;
                break;
        }
    }else {
        ALOGE("FM is not in proper state to set band type\n");
        ret = FM_FAILURE;
    }
    return ret;
}

//set spacing for successive channels
int FmRadioController :: SetChannelSpacing
(
    long spacing
)
{
    int ret;

    if (cur_fm_state == FM_ON) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                               V4L2_CID_PRV_CHAN_SPACING, spacing);
    } else {
        ALOGE("FM is not in proper state to set the channel spacing\n");
        ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: SetStereo
(
)
{
    int ret;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
       ret = FmIoctlsInterface::set_audio_mode(fd_driver,
                                           STEREO);
    }else {
       ret = FM_FAILURE;
    }
    return ret;
}

int FmRadioController :: SetMono
(
)
{
    int ret;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
       ret = FmIoctlsInterface::set_audio_mode(fd_driver,
                                              MONO);
    }else {
       ret = FM_FAILURE;
    }
    return ret;
}

bool FmRadioController :: GetSoftMute
(
)
{
    int ret = FM_SUCCESS;
    long mode = SMUTE_DISABLED;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
       ret = FmIoctlsInterface::get_control(fd_driver,
                            V4L2_CID_PRV_SOFT_MUTE, mode);
       if(ret == FM_SUCCESS) {
          ALOGI("FM Get soft mute is successful: %ld\n", mode);
       }else {
          ALOGE("FM Get soft mute failed");
       }
    }else {
       ALOGE("FM is not in proper state for getting soft mute\n");
       ret = FM_FAILURE;
    }
    return mode;
}

int FmRadioController :: Antenna_Switch(int antenna)
{
    int ret = 0;

    if (antenna) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                                     V4L2_CID_PRV_ANTENNA, 1);
    } else {
        ret = FmIoctlsInterface::set_control(fd_driver,
                                     V4L2_CID_PRV_ANTENNA, 0);
    }
    ALOGD("%s, antenna type = %d [ret=%d]\n", __func__, antenna, ret);
    return ret;
}

int FmRadioController :: get_fm_state
(
)
{
    return cur_fm_state;
}

void FmRadioController :: set_fm_state
(
    int state
)
{
    pthread_mutex_lock(&mutex_fm_state);
    cur_fm_state = state;
    pthread_mutex_unlock(&mutex_fm_state);
}

void* FmRadioController :: handle_events
(
    void *arg
)
{
    int bytesread;
    char event_buff[STD_BUF_SIZE];
    bool status = true;
    FmRadioController *obj_p = static_cast<FmRadioController*>(arg);

    while(status && !obj_p->event_listener_canceled) {
        bytesread = FmIoctlsInterface::get_buffer(obj_p->fd_driver,
                      event_buff, STD_BUF_SIZE, EVENT_IND);
        for(int i = 0; i < bytesread; i++) {
            status = obj_p->process_radio_events(event_buff[i]);
            if(status == false) {
                break;
            }
        }
    }
    return NULL;
}

int FmRadioController :: SetRdsGrpMask
(
    int mask
)
{
    int ret;

    if((cur_fm_state != FM_OFF) &&
       (cur_fm_state != FM_OFF_IN_PROGRESS) &&
       (cur_fm_state != FM_ON_IN_PROGRESS)) {
        ret = FmIoctlsInterface::set_control(fd_driver,
                      V4L2_CID_PRV_RDSGROUP_MASK, mask);
    }else {
        ret = FM_FAILURE;
    }
    return ret;
}

void FmRadioController :: handle_enabled_event
(
     void
)
{
     char value[PROPERTY_VALUE_MAX] = {'\0'};

     ALOGI("FM handle ready Event\n");
     FmIoctlsInterface::set_control(fd_driver,
             V4L2_CID_PRV_AUDIO_PATH, AUDIO_DIGITAL_PATH);
     property_get("qcom.bluetooth.soc", value, NULL);
     if (strcmp(value, "rome") != 0) {
         FmIoctlsInterface::set_calibration(fd_driver);
     }
     pthread_mutex_lock(&mutex_turn_on_cond);
     set_fm_state(FM_ON);
     pthread_cond_broadcast(&turn_on_cond);
     pthread_mutex_unlock(&mutex_turn_on_cond);
}

void FmRadioController :: handle_tuned_event
(
     void
)
{
     long freq = -1;

     ALOGI("FM handle Tune event\n");
     freq = GetChannel();
     switch(cur_fm_state) {
         case FM_ON:
            if(af_enabled && (freq != prev_freq)
                && (prev_freq > 0)) {
               ALOGI("AF jump happened\n");
               is_af_jump_received = true;
            }
            break;
         case FM_TUNE_IN_PROGRESS:
            pthread_mutex_lock(&mutex_tune_compl_cond);
            set_fm_state(FM_ON);
            pthread_cond_broadcast(&tune_compl_cond);
            pthread_mutex_unlock(&mutex_tune_compl_cond);
            break;
         case SEEK_IN_PROGRESS:
            pthread_mutex_lock(&mutex_seek_compl_cond);
            set_fm_state(FM_ON);
            pthread_cond_broadcast(&seek_compl_cond);
            pthread_mutex_unlock(&mutex_seek_compl_cond);
            break;
         case SCAN_IN_PROGRESS:
            break;
     }
     prev_freq = freq;
}

void FmRadioController :: handle_seek_next_event
(
     void
)
{
     ALOGI("FM handle seek next event\n");
}

void FmRadioController :: handle_seek_complete_event
(
     void
)
{
     ALOGI("FM handle seek complete event\n");
}

void FmRadioController :: handle_raw_rds_event
(
     void
)
{

}

void FmRadioController :: handle_rt_event
(
     void
)
{
     ALOGI("FM handle RT event\n");
     is_rt_event_received = true;
}

void FmRadioController :: handle_ps_event
(
    void
)
{
    ALOGI("FM handle PS event\n");
    is_ps_event_received = true;
}

void FmRadioController :: handle_error_event
(
   void
)
{

}

void FmRadioController :: handle_below_th_event
(
   void
)
{

}

void FmRadioController :: handle_above_th_event
(
   void
)
{

}

void FmRadioController :: handle_stereo_event
(
   void
)
{

}
void FmRadioController :: handle_mono_event
(
  void
)
{

}

void FmRadioController :: handle_rds_aval_event
(
  void
)
{
    ALOGI("Got rds_aval_event\n");
    is_rds_support = true;
}

void FmRadioController :: handle_rds_not_aval_event
(
  void
)
{
    ALOGI("Got rds_not_aval_event\n");
}

void FmRadioController :: handle_srch_list_event
(
  void
)
{
    ALOGI("Got srch list event\n");
    if (cur_fm_state == SCAN_IN_PROGRESS) {
        pthread_mutex_lock(&mutex_scan_compl_cond);
        set_fm_state(FM_ON);
        pthread_cond_broadcast(&scan_compl_cond);
        pthread_mutex_unlock(&mutex_scan_compl_cond);
    }
}

void FmRadioController :: handle_af_list_event
(
  void
)
{
    char raw_rds[STD_BUF_SIZE];
    int ret;
    int aflist_size;
    ULINT lower_band;
    int AfList[MAX_AF_LIST_SIZE];

    ALOGI("Got af list event\n");
    ret = FmIoctlsInterface::get_buffer(fd_driver,
                     raw_rds, STD_BUF_SIZE, AF_LIST_IND);
    lower_band = FmIoctlsInterface::get_lowerband_limit(fd_driver,
                     lower_band);
    ALOGI("raw_rds[0]: %d\n", (raw_rds[0] & 0xff));
    ALOGI("raw_rds[1]: %d\n", (raw_rds[1] & 0xff));
    ALOGI("raw_rds[2]: %d\n", (raw_rds[2] & 0xff));
    ALOGI("raw_rds[3]: %d\n", (raw_rds[3] & 0xff));
    ALOGI("raw_rds[4]: %d\n", (raw_rds[4] & 0xff));
    ALOGI("raw_rds[5]: %d\n", (raw_rds[5] & 0xff));
    ALOGI("raw_rds[6]: %d\n", (raw_rds[6] & 0xff));

    aflist_size = raw_rds[AF_SIZE_IDX] & 0xff;
    for(int i = 0; i < aflist_size; i++) {
       AfList[i] = (raw_rds[AF_SIZE_IDX + i * NO_OF_BYTES_AF + 1] & 0xFF) |
                   ((raw_rds[AF_SIZE_IDX + i * NO_OF_BYTES_AF + 2] & 0xFF) << 8) |
                   ((raw_rds[AF_SIZE_IDX + i * NO_OF_BYTES_AF + 3] & 0xFF) << 16) |
                   ((raw_rds[AF_SIZE_IDX + i * NO_OF_BYTES_AF + 4] & 0xFF) << 24);
       ALOGI("AF: %d\n", AfList[i]);
    }
}

void FmRadioController :: handle_disabled_event
(
  void
)
{
     //Expected disabled
     if(cur_fm_state == FM_OFF_IN_PROGRESS) {
        ALOGI("Expected disabled event\n");
     }else {//Enexpected disabled
        ALOGI("Unexpected disabled event\n");
     }

     set_fm_state(FM_OFF);
     close(fd_driver);
     fd_driver = -1;

     //allow tune function to exit
     pthread_mutex_lock(&mutex_tune_compl_cond);
     pthread_cond_broadcast(&tune_compl_cond);
     pthread_mutex_unlock(&mutex_tune_compl_cond);
     //allow scan function to exit
     pthread_mutex_lock(&mutex_scan_compl_cond);
     pthread_cond_broadcast(&scan_compl_cond);
     pthread_mutex_unlock(&mutex_scan_compl_cond);
     //Allow seek function to exit
     pthread_mutex_lock(&mutex_seek_compl_cond);
     pthread_cond_broadcast(&seek_compl_cond);
     pthread_mutex_unlock(&mutex_seek_compl_cond);
}

void FmRadioController :: handle_rds_grp_mask_req_event
(
    void
)
{
    SetRdsGrpMask(0);
}

void FmRadioController :: handle_rt_plus_event
(
    void
)
{
    ALOGI("FM handle RT Plus event\n");
}

void FmRadioController :: handle_af_jmp_event
(
    void
)
{
    long freq = -1;

    freq = GetChannel();
    ALOGI("FM handle AF Jumped event\n");
    if(af_enabled && (freq != prev_freq)) {
       ALOGI("AF Jump occured, prevfreq is: %ld, af freq is: %ld\n", prev_freq, freq);
    }
    prev_freq = freq;
}

void FmRadioController :: handle_ert_event
(
    void
)
{
    ALOGI("FM handle ERT event\n");
}

bool FmRadioController :: process_radio_events
(
    int event
)
{
    bool ret = true;

    switch(event) {
        case READY_EVENT:
            handle_enabled_event();
            break;
        case TUNE_EVENT:
            handle_tuned_event();
            break;
        case SEEK_COMPLETE_EVENT:
            handle_seek_complete_event();
            break;
        case SCAN_NEXT_EVENT:
            handle_seek_next_event();
            break;
        case RAW_RDS_EVENT:
            handle_raw_rds_event();
            break;
        case RT_EVENT:
            handle_rt_event();
            break;
        case PS_EVENT:
            handle_ps_event();
            break;
        case ERROR_EVENT:
            handle_error_event();
            break;
        case BELOW_TH_EVENT:
            handle_below_th_event();
            break;
        case ABOVE_TH_EVENT:
            handle_above_th_event();
            break;
        case STEREO_EVENT:
            handle_stereo_event();
            break;
        case MONO_EVENT:
            handle_mono_event();
            break;
        case RDS_AVAL_EVENT:
            handle_rds_aval_event();
            break;
        case RDS_NOT_AVAL_EVENT:
            handle_rds_not_aval_event();
            break;
        case SRCH_LIST_EVENT:
            handle_srch_list_event();
            break;
        case AF_LIST_EVENT:
            handle_af_list_event();
            break;
        case DISABLED_EVENT:
            handle_disabled_event();
            ret = false;
            break;
        case RDS_GRP_MASK_REQ_EVENT:
            handle_rds_grp_mask_req_event();
            break;
        case RT_PLUS_EVENT:
            handle_rt_plus_event();
            break;
        case ERT_EVENT:
            handle_ert_event();
            break;
        case AF_JMP_EVENT:
            handle_af_jmp_event();
            break;
        default:
            break;
    }
    return ret;
}