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

#include "fmr.h"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "FMLIB_COM"

static int g_stopscan = 0;

int COM_open_dev(const char *pname, int *fd)
{
    int ret = 0;
    int tmp = -1;

    FMR_ASSERT(pname);
    FMR_ASSERT(fd);

    LOGI("COM_open_dev start\n");
    tmp = open(pname, O_RDWR);
    if (tmp < 0) {
        LOGE("Open %s failed, %s\n", pname, strerror(errno));
        ret = -ERR_INVALID_FD;
    }
    *fd = tmp;
    LOGI("%s, [fd=%d] [ret=%d]\n", __func__, *fd, ret);
    return ret;
}

int COM_close_dev(int fd)
{
    int ret = 0;

    LOGI("COM_close_dev start\n");
    ret = close(fd);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

int COM_pwr_up(int fd, int band, int freq)
{
    int ret = 0;
    struct fm_tune_parm parm;

    LOGI("%s, [freq=%d]\n", __func__, freq);
    bzero(&parm, sizeof(struct fm_tune_parm));

    parm.band = band;
    parm.freq = freq;
    parm.hilo = FM_AUTO_HILO_OFF;
    parm.space = FM_SEEK_SPACE;

    ret = ioctl(fd, FM_IOCTL_POWERUP, &parm);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

int COM_pwr_down(int fd, int type)
{
    int ret = 0;
    LOGI("%s, [type=%d]\n", __func__, type);
    ret = ioctl(fd, FM_IOCTL_POWERDOWN, &type);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

/*0x20: space, 0x7E:~*/
#define ISVALID(c)((c)>=0x20 && (c)<=0x7E)
/*change any char which out of [0x20,0x7E]to space(0x20)*/
void COM_change_string(uint8_t *str, int len)
{
    int i = 0;
    for (i=0; i<len; i++) {
        if (false == ISVALID(str[i])) {
            str[i]= 0x20;
        }
    }
}

int COM_get_ps(int fd, RDSData_Struct *rds, uint8_t **ps, int *ps_len)
{
    int ret = 0;
    char tmp_ps[9] = {0};

    FMR_ASSERT(rds);
    FMR_ASSERT(ps);
    FMR_ASSERT(ps_len);

    if (rds->event_status&RDS_EVENT_PROGRAMNAME) {
        LOGD("%s, Success,[event_status=%d]\n", __func__, rds->event_status);
        *ps = &rds->PS_Data.PS[3][0];
        *ps_len = sizeof(rds->PS_Data.PS[3]);

        COM_change_string(*ps, *ps_len);
        memcpy(tmp_ps, *ps, 8);
        LOGI("PS=%s\n", tmp_ps);
    } else {
        LOGE("%s, Failed,[event_status=%d]\n", __func__, rds->event_status);
        *ps = NULL;
        *ps_len = 0;
        ret = -ERR_RDS_NO_DATA;
    }

    return ret;
}

int COM_get_rt(int fd, RDSData_Struct *rds, uint8_t **rt, int *rt_len)
{
    int ret = 0;
    char tmp_rt[65] = { 0 };

    FMR_ASSERT(rds);
    FMR_ASSERT(rt);
    FMR_ASSERT(rt_len);

    if (rds->event_status&RDS_EVENT_LAST_RADIOTEXT) {
        LOGD("%s, Success,[event_status=%d]\n", __func__, rds->event_status);
        *rt = &rds->RT_Data.TextData[3][0];
        *rt_len = rds->RT_Data.TextLength;

        COM_change_string(*rt, *rt_len);
        memcpy(tmp_rt, *rt, 64);
        LOGI("RT=%s\n", tmp_rt);
    } else {
        LOGE("%s, Failed,[event_status=%d]\n", __func__, rds->event_status);
        *rt = NULL;
        *rt_len = 0;
        ret = -ERR_RDS_NO_DATA;
    }
    return ret;
}

int COM_get_pi(int fd, RDSData_Struct *rds, uint16_t *pi)
{
    int ret = 0;

    FMR_ASSERT(rds);
    FMR_ASSERT(pi);

    if (rds->event_status&RDS_EVENT_PI_CODE) {
        LOGD("%s, Success,[event_status=%d] [PI=%d]\n", __func__, rds->event_status, rds->PI);
        *pi = rds->PI;
    } else {
        LOGI("%s, Failed, there's no pi,[event_status=%d]\n", __func__, rds->event_status);
        *pi = -1;
        ret = -ERR_RDS_NO_DATA;
    }

    return ret;
}

int COM_tune(int fd, int freq, int band)
{
    int ret = 0;

    struct fm_tune_parm parm;

    bzero(&parm, sizeof(struct fm_tune_parm));

    parm.band = band;
    parm.freq = freq;
    parm.hilo = FM_AUTO_HILO_OFF;
    parm.space = FM_SEEK_SPACE;

    ret = ioctl(fd, FM_IOCTL_TUNE, &parm);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [freq=%d] [ret=%d]\n", __func__, fd, freq, ret);
    return ret;
}

int COM_seek(int fd, int *freq, int band, int dir, int lev)
{
    int ret = 0;
    struct fm_seek_parm parm;

    bzero(&parm, sizeof(struct fm_tune_parm));

    parm.band = band;
    parm.freq = *freq;
    parm.hilo = FM_AUTO_HILO_OFF;
    parm.space = FM_SEEK_SPACE;
    if (dir == 1) {
        parm.seekdir = FM_SEEK_UP;
    } else if (dir == 0) {
        parm.seekdir = FM_SEEK_DOWN;
    }
    parm.seekth = lev;

    ret = ioctl(fd, FM_IOCTL_SEEK, &parm);
    if (ret == 0) {
        *freq = parm.freq;
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

int COM_set_mute(int fd, int mute)
{
    int ret = 0;
    int tmp = mute;

    LOGD("%s, start \n", __func__);
    ret = ioctl(fd, FM_IOCTL_MUTE, &tmp);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

int COM_is_fm_pwrup(int fd, int *pwrup)
{
    int ret = 0;

    ret = ioctl(fd, FM_IOCTL_IS_FM_POWERED_UP, pwrup);
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
    return ret;
}

/******************************************
 * Inquiry if RDS is support in driver.
 * Parameter:
 *      None
 *supt Value:
 *      1: support
 *      0: NOT support
 *      -1: error
 ******************************************/
int COM_is_rdsrx_support(int fd, int *supt)
{
    int ret = 0;
    int support = -1;

    if (fd < 0) {
        LOGE("FM isRDSsupport fail, g_fm_fd = %d\n", fd);
        *supt = -1;
        ret = -ERR_INVALID_FD;
        return ret;
    }

    ret = ioctl(fd, FM_IOCTL_RDS_SUPPORT, &support);
    if (ret) {
        LOGE("FM FM_IOCTL_RDS_SUPPORT fail, errno = %d\n", errno);
        //don't support
        *supt = 0;
        return ret;
    }
    LOGI("isRDSsupport Success,[support=%d]\n", support);
    *supt = support;
    return ret;
}

int COM_pre_search(int fd)
{
    fm_s32 ret = 0;
    ret = ioctl(fd, FM_IOCTL_PRE_SEARCH, 0);
    LOGD("COM_pre_search:%d\n",ret);
    return ret;
}

int COM_restore_search(int fd)
{
    fm_s32 ret = 0;
    ret = ioctl(fd, FM_IOCTL_RESTORE_SEARCH, 0);
    LOGD("COM_restore_search:%d\n",ret);
    return ret;
}

/*soft mute tune function, usually for sw scan implement or CQI log tool*/
int COM_Soft_Mute_Tune(int fd, fm_softmute_tune_t *para)
{
    fm_s32 ret = 0;
    //fm_s32 RSSI = 0, PAMD = 0,MR = 0, ATDC = 0;
    //fm_u32 PRX = 0;
    //fm_u16 softmuteGainLvl = 0;
    fm_softmute_tune_t value;

    value.freq = para->freq;
    ret = ioctl(fd, FM_IOCTL_SOFT_MUTE_TUNE, &value);
    if (ret) {
        LOGE("FM soft mute tune faild:%d\n",ret);
        return ret;
    }
#if 0
    LOGD("Raw data of soft mute tune[%d]: RSSI:[%x]PAMD:[%x]MR:[%x]ATDC:[%x]PRX:[%x]SMG:[%x]",para->freq,value.RSSI,value.PAMD,value.MR,value.ATDC,value.PRX,value.SMG);
    RSSI = ((value.RSSI & 0x03FF) >= 512) ? ((value.RSSI & 0x03FF) - 1024) : (value.RSSI & 0x03FF);
    PAMD = ((value.PAMD & 0xFF) >= 128) ? ((value.PAMD & 0x00FF) - 256) : (value.PAMD & 0x00FF);
    MR = ((value.MR & 0x01FF) >= 256) ? ((value.MR & 0x01FF) - 512) : (value.MR & 0x01FF);
    ATDC =((value.ATDC & 0x0FFF) >= 2048) ? ((value.ATDC & 0x0FFF) - 4096) : (value.ATDC & 0x0FFF);
    if (ATDC < 0) {
        ATDC = (~(ATDC)) - 1;//Get abs value of ATDC
    }
    PRX = (value.PRX & 0x00FF);
    softmuteGainLvl = value.SMG;
    //check if the channel is valid according to each CQIs
    if ((RSSI >= RSSI_TH)
     && (PAMD <= PAMD_TH)
     && (ATDC <= ATDC_TH)
     && (MR >= MR_TH)
     && (PRX >= PRX_TH)
     && (softmuteGainLvl <= softMuteGainTH)) {
        para->valid = fm_true;
    } else {
        para->valid = fm_false;
    }
#endif
    para->valid = value.valid;
    para->rssi = value.rssi;
    //LOGI("soft mute tune[%d] valid[%d]: RSSI:[%d]PAMD:[%d]MR:[%d]ATDC:[%d]PRX:[%d]SMG:[%d]",para->freq,para->valid,RSSI,PAMD,MR,ATDC,PRX,softmuteGainLvl);
    return 0;
}

int COM_get_cqi(int fd, int num, char *buf, int buf_len)
{
    int ret;
    struct fm_cqi_req cqi_req;

    //check buf
    num = (num > CQI_CH_NUM_MAX) ? CQI_CH_NUM_MAX : num;
    num = (num < CQI_CH_NUM_MIN) ? CQI_CH_NUM_MIN : num;
    cqi_req.ch_num = (uint16_t)num;
    cqi_req.buf_size = cqi_req.ch_num * sizeof(struct fm_cqi);
    if (!buf || (buf_len < cqi_req.buf_size)) {
        LOGE("get cqi, invalid buf\n");
        return -1;
    }
    cqi_req.cqi_buf = buf;

    //get cqi from driver
    ret = ioctl(fd, FM_IOCTL_CQI_GET, &cqi_req);
    if (ret < 0) {
        LOGE("get cqi, failed %d\n", ret);
        return -1;
    }

    return 0;
}

int COM_turn_on_off_rds(int fd, int onoff)
{
    int ret = 0;
    uint16_t rds_on = -1;

    LOGD("Rdsset start\n");
    if (onoff == FMR_RDS_ON) {
        rds_on = 1;
        ret = ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
        if (ret) {
            LOGE("FM_IOCTL_RDS_ON failed\n");
            return ret;
        }
        LOGD("Rdsset Success,[rds_on=%d]\n", rds_on);
    } else {
        rds_on = 0;
        ret = ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
        if (ret) {
            LOGE("FM_IOCTL_RDS_OFF failed\n");
            return ret;
        }
        LOGD("Rdsset Success,[rds_on=%d]\n", rds_on);
    }
    return ret;
}

int COM_get_chip_id(int fd, int *chipid)
{
    int ret = 0;
    uint16_t tmp = 0;

    FMR_ASSERT(chipid);

    ret = ioctl(fd, FM_IOCTL_GETCHIPID, &tmp);
    *chipid = (int)tmp;
    if (ret) {
        LOGE("%s, failed\n", __func__);
    }
    LOGD("%s, [fd=%d] [chipid=%x] [ret=%d]\n", __func__, fd, *chipid, ret);
    return ret;
}

int COM_read_rds_data(int fd, RDSData_Struct *rds, uint16_t *rds_status)
{
    int ret = 0;
    uint16_t event_status;
    //char tmp_ps[9] = {0};
    //char tmp_rt[65] = { 0 };

    FMR_ASSERT(rds);
    FMR_ASSERT(rds_status);

    if (read(fd, rds, sizeof(RDSData_Struct)) == sizeof(RDSData_Struct)) {
        event_status = rds->event_status;
        //memcpy(tmp_ps, &rds->PS_Data.PS[3][0], 8);
        //memcpy(tmp_rt, &rds->RT_Data.TextData[3][0], 64);
        LOGI("event_status = 0x%x\n", event_status);
        //memset(tmp_ps, 0, 9);
        //memset(tmp_rt, 0, 65);
        *rds_status = event_status;
        return ret;
    } else {
        //LOGE("readrds get no event\n");
        ret = -ERR_RDS_NO_DATA;
    }
    return ret;
}

int COM_active_af(int fd, RDSData_Struct *rds, int band, uint16_t cur_freq, uint16_t *ret_freq)
{
    int ret = 0;
    int i = 0;
    struct fm_tune_parm parm;
    uint16_t rds_on = 0;
    uint16_t set_freq, sw_freq, org_freq, PAMD_Value, AF_PAMD_LBound, AF_PAMD_HBound;
    uint16_t PAMD_Level[25];
    uint16_t PAMD_DB_TBL[5] = {// 5dB, 10dB, 15dB, 20dB, 25dB,
                               //  13, 17, 21, 25, 29};
                                8, 12, 15, 18, 20};
    FMR_ASSERT(rds);
    FMR_ASSERT(ret_freq);

    sw_freq = cur_freq; //current freq
    org_freq = cur_freq;
    parm.band = band;
    parm.freq = sw_freq;
    parm.hilo = FM_AUTO_HILO_OFF;
    parm.space = FM_SPACE_DEFAULT;

    if (!(rds->event_status&RDS_EVENT_AF)) {
        LOGE("activeAF failed\n");
        *ret_freq = 0;
        ret = -ERR_RDS_NO_DATA;
        return ret;
    }

    AF_PAMD_LBound = PAMD_DB_TBL[0]; //5dB
    AF_PAMD_HBound = PAMD_DB_TBL[1]; //15dB
    ioctl(fd, FM_IOCTL_GETCURPAMD, &PAMD_Value);
    LOGI("current_freq=%d,PAMD_Value=%d\n", cur_freq, PAMD_Value);

    if (PAMD_Value < AF_PAMD_LBound) {
        rds_on = 0;
        ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
        //make sure rds->AF_Data.AF_Num is valid
        rds->AF_Data.AF_Num = (rds->AF_Data.AF_Num > 25)? 25 : rds->AF_Data.AF_Num;
        for (i=0; i<rds->AF_Data.AF_Num; i++) {
            set_freq = rds->AF_Data.AF[1][i];  //method A or B
            if (set_freq != org_freq) {
                parm.freq = set_freq;
                ioctl(fd, FM_IOCTL_TUNE, &parm);
                usleep(250*1000);
                ioctl(fd, FM_IOCTL_GETCURPAMD, &PAMD_Level[i]);
                LOGI("next_freq=%d,PAMD_Level=%d\n", parm.freq, PAMD_Level[i]);
                if (PAMD_Level[i] > PAMD_Value) {
                    PAMD_Value = PAMD_Level[i];
                    sw_freq = set_freq;
                }
            }
        }
        LOGI("PAMD_Value=%d, sw_freq=%d\n", PAMD_Value, sw_freq);
        if ((PAMD_Value > AF_PAMD_HBound)&&(sw_freq != 0)) {
            parm.freq = sw_freq;
            ioctl(fd, FM_IOCTL_TUNE, &parm);
            cur_freq = parm.freq;
        } else {
            parm.freq = org_freq;
            ioctl(fd, FM_IOCTL_TUNE, &parm);
            cur_freq = parm.freq;
        }
        rds_on = 1;
        ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
    } else {
        LOGD("RDS_EVENT_AF old freq:%d\n", org_freq);
    }
    *ret_freq = cur_freq;

    return ret;
}

int COM_ana_switch(int fd, int antenna)
{
    int ret = 0;

    ret = ioctl(fd, FM_IOCTL_ANA_SWITCH, &antenna);
    if (ret < 0) {
        LOGE("%s: fail, ret = %d\n", __func__, ret);
    }

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

/*  COM_is_dese_chan -- check if gived channel is a de-sense channel or not
  *  @fd - fd of "dev/fm"
  *  @freq - gived channel
  *  return value: 0, not a dese chan; 1, a dese chan; else error NO.
  */
int COM_is_dese_chan(int fd, int freq)
{
    int ret = 0;
    int tmp = freq;

    ret = ioctl(fd, FM_IOCTL_IS_DESE_CHAN, &freq);
    if (ret < 0) {
        LOGE("%s, failed,ret=%d\n", __func__,ret);
        return ret;
    } else {
        LOGD("[fd=%d] %d --> dese=%d\n", fd, tmp, freq);
        return freq;
    }
}

/*  COM_desense_check -- check if gived channel is a de-sense channel or not
  *  @fd - fd of "dev/fm"
  *  @freq - gived channel
  *  @rssi-freq's rssi
  *  return value: 0, is desense channel and rssi is less than threshold; 1, not desense channel or it is but rssi is more than threshold.
  */
int COM_desense_check(int fd, int freq, int rssi)
{
    int ret = 0;
    fm_desense_check_t parm;

    parm.freq = freq;
    parm.rssi = rssi;
    ret = ioctl(fd, FM_IOCTL_DESENSE_CHECK, &parm);
    if (ret < 0) {
        LOGE("%s, failed,ret=%d\n", __func__,ret);
        return ret;
    } else {
        LOGD("[fd=%d] %d --> dese=%d\n", fd,freq,ret);
        return ret;
    }
}

void FM_interface_init(struct fm_cbk_tbl *cbk_tbl)
{
    //Basic functions.
    cbk_tbl->open_dev = COM_open_dev;
    cbk_tbl->close_dev = COM_close_dev;
    cbk_tbl->pwr_up = COM_pwr_up;
    cbk_tbl->pwr_down = COM_pwr_down;
    cbk_tbl->tune = COM_tune;
    cbk_tbl->set_mute = COM_set_mute;
    cbk_tbl->is_rdsrx_support = COM_is_rdsrx_support;
    cbk_tbl->turn_on_off_rds = COM_turn_on_off_rds;
    cbk_tbl->get_chip_id = COM_get_chip_id;
    //For RDS RX.
    cbk_tbl->read_rds_data = COM_read_rds_data;
    cbk_tbl->get_ps = COM_get_ps;
    cbk_tbl->get_rt = COM_get_rt;
    cbk_tbl->active_af = COM_active_af;
    //FM short antenna
    cbk_tbl->ana_switch = COM_ana_switch;
    cbk_tbl->desense_check = COM_desense_check;
    //soft mute tune
    cbk_tbl->soft_mute_tune = COM_Soft_Mute_Tune;
    cbk_tbl->pre_search = COM_pre_search;
    cbk_tbl->restore_search = COM_restore_search;
    return;
}