drivers/media/radio/bcm4343s/fmdrv_rx.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License version 2 as
   4  * published by the Free Software Foundation.
   5
   6  * You should have received a copy of the GNU General Public License
   7  * along with this program; if not, write to the Free Software
   8  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   9
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14
  15
  16  *  Copyright (C) 2009-2014 Broadcom Corporation
  17  */
  18
  19 /*******************************************************************************
  20  *
  21  *  Filename:      fmdrv_rx.c
  22  *
  23  *  Description:   This sub-module of FM driver implements FM RX functionality.
  24  *
  25  ***********************************************************************************/
  26
  27 #include "fmdrv.h"
  28 #include "fmdrv_main.h"
  29 #include "fmdrv_rx.h"
  30 #include "fmdrv_config.h"
  31 #include <linux/fm_public.h>
  32
  33 /*******************************************************************************
  34 **  Constants & Macros
  35 *******************************************************************************/
  36
  37 #ifndef DEBUG
  38 #ifdef pr_info
  39 #undef pr_info
  40 #define pr_info(fmt, arg...)
  41 #endif
  42 #endif
  43
  44 const unsigned short fm_sch_step_size[] =     /* darrel issue_06 : 50Khz scan step add. */
  45 {
  46     50,
  47     100,
  48     200
  49 };
  50
  51 /************************************************************************************
  52 **  Functions
  53 ************************************************************************************/
  54 /************************************************************************************
  55 **  Helper functions
  56 *******************************************************************************/
  57
  58 /* Configures Alternate Frequency switch mode */
  59 int fm_rx_set_af_switch(struct fmdrv_ops *fmdev, u8 af_mode)
  60 {
  61     u16 payload;
  62     int ret;
  63
  64     if (fmdev->curr_fmmode != FM_MODE_RX)
  65         return -EPERM;
  66
  67     if (af_mode != FM_RX_RDS_AF_SWITCH_MODE_ON &&
  68         af_mode != FM_RX_RDS_AF_SWITCH_MODE_OFF) {
  69         pr_err("(fmdrv) %s(): Invalid af mode 0x%x\n", __func__, af_mode);
  70         return -EINVAL;
  71     }
  72     /* Enable/disable low RSSI interrupt based on af_mode */
  73     if (af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
  74         fmdev->rx.fm_rds_mask |= I2C_MASK_RSSI_LOW_BIT;
  75     else
  76         fmdev->rx.fm_rds_mask &= ~I2C_MASK_RSSI_LOW_BIT;
  77
  78     payload = fmdev->rx.fm_rds_mask;
  79
  80     ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &fmdev->rx.fm_rds_mask,
  81                             2, REG_WR,&fmdev->maintask_completion, NULL, NULL);
  82
  83     if (ret < 0)
  84         return ret;
  85
  86     fmdev->rx.af_mode = af_mode;
  87
  88     return 0;
  89 }
  90
  91
  92 /*
  93  * Sets the signal strength level that once reached
  94  * will stop the auto search process
  95  */
  96 int fm_rx_set_rssi_threshold(struct fmdrv_ops *fmdev, short rssi_lvl_toset)
  97 {
  98     pr_info("(fmdrv) %s(): fm_rx_set_rssi_threshold to set is %d\n",
  99                                                 __func__,rssi_lvl_toset);
 100
 101     if (rssi_lvl_toset < FM_RX_RSSI_THRESHOLD_MIN ||
 102         rssi_lvl_toset > FM_RX_RSSI_THRESHOLD_MAX) {
 103         pr_err("(fmdrv) %s(): Invalid RSSI threshold level\n",
 104             __func__);
 105         return -EINVAL;
 106     }
 107
 108     fmdev->rx.curr_rssi_threshold = rssi_lvl_toset;
 109
 110     return 0;
 111 }
 112
 113
 114 /*
 115  * Sets the signal strength level that once reached
 116  * will stop the auto search process
 117  */
 118 int fm_rx_set_snr_threshold(struct fmdrv_ops *fmdev, short snr_lvl_toset)
 119 {
 120     u16 payload;
 121     int ret;
 122
 123     if (snr_lvl_toset < FM_RX_SNR_THRESHOLD_MIN ||
 124         snr_lvl_toset > FM_RX_SNR_THRESHOLD_MAX) {
 125         pr_err("(fmdrv) %s(): Invalid SNR threshold level, %d\n",
 126             __func__, snr_lvl_toset);
 127         return -EINVAL;
 128     }
 129     payload = (u16) snr_lvl_toset;
 130     ret = fmc_send_cmd(fmdev, FM_SEARCH_SNR, &payload, sizeof(payload),
 131             REG_WR, &fmdev->maintask_completion, NULL,NULL);
 132
 133     if (ret < 0)
 134         return ret;
 135
 136     fmdev->rx.curr_snr_threshold= snr_lvl_toset;
 137
 138     return 0;
 139 }
 140
 141 /*
 142  * Sets the Carrier Offset Slop
 143  */
 144 int fm_rx_set_cos_threshold(struct fmdrv_ops *fmdev, short cos_toset)
 145 {
 146     u16 payload;
 147     int ret;
 148
 149     if (cos_toset < FM_RX_COS_MIN||
 150         cos_toset > FM_RX_COS_MAX) {
 151         pr_err("(fmdrv) %s(): Invalid COS threshold value, %d\n",
 152             __func__, cos_toset);
 153         return -EINVAL;
 154     }
 155     payload = (u16) cos_toset;
 156     ret = fmc_send_cmd(fmdev, FM_RES_PRESCAN_QUALITY, &payload, sizeof(payload),
 157             REG_WR, &fmdev->maintask_completion, NULL,NULL);
 158
 159     if (ret < 0)
 160         return ret;
 161
 162     fmdev->rx.curr_cos_threshold= cos_toset;
 163
 164     return 0;
 165 }
 166
 167
 168 /*
 169 * Function to validate if the tuned/scanned frequency is valid
 170 * or not
 171 */
 172 int check_if_valid_freq(struct fmdrv_ops *fmdev, unsigned short frequency)
 173 {
 174 /* darrel issue_01 : 87.50 Mhz, 87.55 Mhz , 107.95 Mhz, 108.00Mhz  is valid frequency */
 175     if(frequency < fmdev->rx.region.low_bound ||
 176             frequency > fmdev->rx.region.high_bound)
 177     {
 178         pr_info("(fmdrv) %s(): %d - Literally out of range",
 179                                 __func__, FM_SET_FREQ(frequency));
 180         return FALSE;
 181     }
 182     else
 183     {
 184         pr_info("(fmdrv) %s(): %d - Freq in range",
 185                                 __func__, FM_SET_FREQ(frequency));
 186         return TRUE;
 187     }
 188 }
 189
 190 /*
 191 * Function to read the FM_RDS_FLAG registry
 192 */
 193 int read_fm_rds_flag(struct fmdrv_ops *fmdev, unsigned short *value)
 194 {
 195     unsigned char read_length;
 196     int ret;
 197     int resp_len;
 198     unsigned char resp_buf [2];
 199
 200     read_length = FM_READ_2_BYTE_DATA;
 201     ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_FLAG, &read_length, sizeof(read_length), REG_RD,
 202                     &fmdev->maintask_completion, &resp_buf, &resp_len);
 203     *value = (unsigned short)resp_buf[0] +
 204                 ((unsigned short)resp_buf[1] << 8);
 205     pr_info("(fmdrv) %s: FM Mask : 0x%x ", __func__, *value);
 206     return 0;
 207 }
 208
 209 /*
 210 * Function to read the FM_RDS_FLAG registry
 211 */
 212 int fm_rx_set_mask(struct fmdrv_ops *fmdev, unsigned short mask)
 213 {
 214     int ret;
 215     unsigned short flag;
 216
 217     fmdev->rx.fm_rds_flag|= FM_RDS_FLAG_CLEAN_BIT; /* clean FM_RDS_FLAG */
 218     ret = read_fm_rds_flag(fmdev, &flag);
 219     FM_CHECK_SEND_CMD_STATUS(ret);
 220
 221     ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &mask, sizeof(mask), REG_WR,
 222             &fmdev->maintask_completion, NULL, NULL);
 223     FM_CHECK_SEND_CMD_STATUS(ret);
 224     return ret;
 225 }
 226
 227 /*
 228 * Helper Function to initialize and start a search operation
 229 * (SEEK or TUNE). This method is internally called by fm_rx_set_frequency()
 230 * and fm_rx_seek_station().
 231 */
 232 int init_start_search(struct fmdrv_ops *fmdev, unsigned short start_freq, unsigned char mode)
 233 {
 234     unsigned char payload;
 235     unsigned short tmp_fm_rds_mask;
 236     int ret;
 237
 238     if(mode == FM_TUNER_SEEK_MODE)
 239     {
 240         /* Set Scan mode */
 241         payload = FM_TUNER_NORMAL_SCAN_MODE;
 242         ret = fmc_send_cmd(fmdev, FM_SEARCH_METHOD, &payload, 1, REG_WR,
 243                 &fmdev->maintask_completion, NULL, NULL);
 244         FM_CHECK_SEND_CMD_STATUS(ret);
 245 #if V4L2_FM_DEBUG
 246         pr_info("(fmdev) %s(): FM_SEARCH_METHOD set to 0x%x\n", __func__, payload);
 247 #endif
 248
 249         /* Set Preset stations number to 0 */
 250         payload = 0;
 251         ret = fmc_send_cmd(fmdev, FM_REG_PRESET_MAX, &payload, 1, REG_WR,
 252                 &fmdev->maintask_completion, NULL, NULL);
 253         FM_CHECK_SEND_CMD_STATUS(ret);
 254 #if V4L2_FM_DEBUG
 255         pr_info("(fmdev) %s(): FM_REG_PRESET_MAX set to 0x%x\n", __func__, payload);
 256 #endif
 257
 258         /* Set FM Search control params to controller */
 259         payload = fmdev->rx.curr_rssi_threshold | (fmdev->rx.curr_sch_mode & FM_SCAN_DIRECT_MASK);
 260         ret = fmc_send_cmd(fmdev, FM_REG_SCH_CTL0, &payload, 1, REG_WR,
 261                 &fmdev->maintask_completion, NULL, NULL);
 262         FM_CHECK_SEND_CMD_STATUS(ret);
 263 #if V4L2_FM_DEBUG
 264         pr_info("(fmdev) %s(): FM_REG_SCH_CTL0 set to 0x%x\n", __func__, payload);
 265 #endif
 266     }
 267
 268     /* freeze interrupt event before SCH_TUNE is commanded */
 269     fmdev->rx.fm_rds_flag |= FM_RDS_FLAG_SCH_FRZ_BIT;
 270     /* set sch_tune pending bit */
 271     fmdev->rx.fm_rds_flag |= FM_RDS_FLAG_SCH_BIT;
 272
 273     /* Write Frequency */
 274     /* Write FM_REG_FM_FREQ (0x0a) register first */
 275     ret = fmc_send_cmd(fmdev, FM_REG_FM_FREQ, &start_freq,
 276             sizeof(start_freq), REG_WR, &fmdev->maintask_completion, NULL, NULL);
 277     FM_CHECK_SEND_CMD_STATUS(ret);
 278 #if V4L2_FM_DEBUG
 279     pr_info("(fmdev) %s(): FM_REG_FM_FREQ set to 0x%x\n", __func__, FM_SET_FREQ(start_freq));
 280 #endif
 281
 282     /* Set the mask flag to Register FM_REG_FM_RDS_MSK(0x10)
 283     & FM_REG_FM_RDS_MSK1(0x11) */
 284     tmp_fm_rds_mask= I2C_MASK_SRH_TUNE_CMPL_BIT | I2C_MASK_SRH_TUNE_FAIL_BIT;
 285     ret = fm_rx_set_mask(fmdev, tmp_fm_rds_mask);
 286     FM_CHECK_SEND_CMD_STATUS(ret);
 287
 288     /* Reset the fm_rds_flag here as for the first time we dont get
 289     any interrupt during ENABLE to cleanup the bit */
 290     fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_CLEAN_BIT;
 291
 292     /* Write FM_REG_SCH_TUNE (0x09) register */
 293     /*payload = FM_TUNER_SEEK_MODE;*/ /* Scan parameter (0x02) */
 294     payload = mode;
 295     ret = fmc_send_cmd(fmdev, FM_REG_SCH_TUNE, &payload, sizeof(payload),
 296             REG_WR, &fmdev->maintask_completion, NULL, NULL);
 297     FM_CHECK_SEND_CMD_STATUS(ret);
 298     fmdev->rx.curr_search_state = (mode == FM_TUNER_SEEK_MODE)?FM_STATE_SEEKING:FM_STATE_TUNING;
 299
 300     fmc_reset_rds_cache(fmdev);
 301
 302     return 0;
 303 }
 304
 305 /*
 306 * Function to process a SEEK complete event. This function determines
 307 * whether to wrap the search, or stop the search or return error
 308 * to user-space. This is called internally by fm_rx_seek_station() function.
 309 */
 310 int process_seek_event(struct fmdrv_ops *fmdev)
 311 {
 312     unsigned short tmp_freq, start_freq;
 313     int ret = -EINVAL;
 314     bool is_valid_freq;
 315
 316     tmp_freq = fmdev->rx.curr_freq;
 317     is_valid_freq = check_if_valid_freq(fmdev, tmp_freq);
 318
 319 /* darrel issue_01 : to check boundary frequency    */
 320     if(((FM_SET_FREQ(tmp_freq) - 5) <= FM_SET_FREQ(fmdev->rx.region.low_bound)) ||
 321        ((FM_SET_FREQ(tmp_freq) + 5)  >= FM_SET_FREQ(fmdev->rx.region.high_bound)))
 322     {
 323         is_valid_freq = FALSE;
 324     }
 325
 326 #if V4L2_FM_DEBUG
 327     pr_info("(fmdrv) %s(): tmp:%d low:%d high:%d\n", __func__,
 328         tmp_freq, fmdev->rx.region.low_bound, fmdev->rx.region.high_bound);
 329 #endif
 330     /* First check if Scan suceeded or not */
 331     if(fmdev->rx.curr_search_state == FM_STATE_SEEK_ERR)
 332     {
 333         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 334         if(!fmdev->rx.seek_wrap && !is_valid_freq)
 335         {
 336             fmdev->rx.curr_search_state = FM_STATE_SEEK_ERR;
 337             pr_err("(fmdrv) %s(): Seek ended with out of bound frequency %d.\n",
 338                                                 __func__, FM_SET_FREQ(tmp_freq));
 339            return FALSE;
 340         }
 341         else if(fmdev->rx.seek_wrap && !is_valid_freq)
 342         {
 343             pr_err("(fmdrv) %s(): Scan ended with out of bound frequency. Wrapping search again..\n",
 344                                         __func__);
 345
 346             start_freq = (fmdev->rx.seek_direction==FM_SCAN_DOWN)?
 347                 (fmdev->rx.region.high_bound):(fmdev->rx.region.low_bound);
 348             pr_info("(fmdev) %s(): Current scanned frequency is out of bounds. Resetting to freq (%d)\n",
 349                         __func__, FM_SET_FREQ(start_freq));
 350
 351             ret = init_start_search(fmdev, start_freq, FM_TUNER_SEEK_MODE);
 352             if(ret < 0)
 353             {
 354                 fmdev->rx.curr_search_state = FM_STATE_SEEK_ERR;
 355                 fmdev->rx.curr_freq = 0;
 356                 pr_err ("(fmdrv) %s(): Error starting search for Seek operation\n", __func__);
 357                 return FALSE;
 358             }
 359
 360             fmdev->rx.curr_search_state = FM_STATE_SEEKING;
 361             pr_info ("(fmdrv) %s(): Started wrapped-up Seek operation\n",
 362                                                                 __func__);
 363             return TRUE;
 364         }
 365         else
 366         {
 367             fmdev->rx.curr_search_state = FM_STATE_SEEK_ERR;
 368             pr_err("(fmdrv) %s(): *** ERROR :: Seek failed for %d frequency ***\n",
 369                                         __func__, FM_SET_FREQ(tmp_freq));
 370             return FALSE;
 371         }
 372     }
 373     else
 374     {
 375         pr_info("(fmdrv) %s(): Seek success!\n", __func__);
 376         fmdev->rx.curr_search_state = FM_STATE_SEEK_CMPL;
 377         return TRUE;
 378     }
 379 }
 380
 381 /************************************************************************************
 382 **  Main functions - Called by fmdrv_main and fmdrv_v4l2.
 383 ************************************************************************************/
 384
 385 /*
 386 * Function to read current RSSI and tuned frequency
 387 */
 388 int fm_rx_read_curr_rssi_freq(struct fmdrv_ops *fmdev, unsigned char rssi_only)
 389 {
 390     int ret = 0, resp_len;
 391     unsigned char payload;
 392     unsigned short tmp_frq;
 393     unsigned char resp_buf[2];
 394
 395     /* Read current RSSI */
 396     payload = FM_READ_1_BYTE_DATA;
 397     ret = fmc_send_cmd(fmdev, FM_REG_RSSI, &payload, 1,
 398             REG_RD, &fmdev->maintask_completion, &resp_buf[0], &resp_len);
 399     FM_CHECK_SEND_CMD_STATUS(ret);
 400     /* Calculating 2's compliment number into an absolute value number */
 401     fmdev->rx.curr_rssi = (unsigned char) ((0x80 - resp_buf[0]) & (~0x80));
 402     pr_info("(fmdev) %s(): FM_REG_RSSI : %d\n", __func__, fmdev->rx.curr_rssi);
 403
 404     if(rssi_only)
 405         return 0;
 406
 407     /* Read current frequency */
 408     payload = FM_READ_2_BYTE_DATA;
 409     tmp_frq = 0;
 410     ret = fmc_send_cmd(fmdev, FM_REG_FM_FREQ, &payload, 1,
 411             REG_RD, &fmdev->maintask_completion, &tmp_frq, &resp_len);
 412     FM_CHECK_SEND_CMD_STATUS(ret);
 413     pr_info("(fmdev) %s(): FM_REG_FM_FREQ : %d\n", __func__, FM_SET_FREQ(tmp_frq));
 414
 415     fmdev->rx.curr_freq = tmp_frq;
 416
 417     return ret;
 418 }
 419
 420 /*
 421 * Function for FM TUNE frequency implementation
 422 *   * Set the other registries such as Search method, search
 423 *    direction, etc.
 424 *   * Start preset search.
 425 *   * Based on interrupt received, read the current tuned freq
 426 *     and validate the search.
 427 *   * If search frequency out of bound, return error code -EAGAIN
 428 *   * If not, read RSSI, reset RDS cache and set RDS MASK to the earlier value.
 429 */
 430 int fm_rx_set_frequency(struct fmdrv_ops *fmdev, unsigned int freq_to_set)
 431 {
 432     unsigned short tmp_frq;
 433     int ret = -EINVAL;
 434     unsigned long timeleft;
 435
 436     if (fmdev->curr_fmmode != FM_MODE_RX)
 437         return -EPERM;
 438     tmp_frq = FM_GET_FREQ(freq_to_set);
 439     if(!check_if_valid_freq(fmdev, tmp_frq))
 440     {
 441         pr_err("(fmdrv): %s(): called with %d - out of bound range (%d-%d)\n",
 442             __func__, freq_to_set, FM_SET_FREQ(fmdev->rx.region.low_bound),
 443             FM_SET_FREQ(fmdev->rx.region.high_bound));
 444         return -EINVAL;
 445     }
 446
 447     ret = init_start_search(fmdev, tmp_frq, FM_TUNER_PRESET_MODE);
 448     if(ret < 0)
 449     {
 450         pr_err ("(fmdrv) %s(): Error starting search for Seek operation\n",
 451                                         __func__);
 452         return ret;
 453     }
 454
 455     /* Wait for tune ended interrupt */
 456     init_completion(&fmdev->maintask_completion);
 457     timeleft = wait_for_completion_timeout(&fmdev->maintask_completion,
 458                            FM_DRV_TX_TIMEOUT);
 459     if (!timeleft)
 460     {
 461         pr_err("(fmdrv) %s(): Timeout(%d sec), didn't get tune ended interrupt\n",
 462                __func__, jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
 463         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 464         return -ETIMEDOUT;
 465     }
 466 #if 0
 467     else {
 468         pr_info("(fmdrv) %s(): Seek %u ms\n", __func__,
 469                         jiffies_to_msecs(FM_DRV_TX_TIMEOUT - timeleft));
 470     }
 471 #endif
 472
 473     /* First check if Tune suceeded or not */
 474     if(fmdev->rx.curr_search_state == FM_STATE_TUNE_ERR)
 475     {
 476         pr_err("(fmdrv) %s(): failed for %d MHz frequency\n",
 477                                 __func__, FM_SET_FREQ(tmp_frq));
 478         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 479         return -EAGAIN;
 480     }
 481     pr_info("(fmdrv) %s(): Set frequency done!\n", __func__);
 482     fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 483
 484     fm_rx_read_curr_rssi_freq(fmdev, FALSE);
 485     /* Reset RDS Cache */
 486     fmc_reset_rds_cache(fmdev);
 487
 488     if(fmdev->rx.fm_rds_mask)
 489     {
 490         /* Update the FM_RDS_MASK to set the earlier bits */
 491         pr_info("(fmdrv) %s(): Update FM_RDS_MASK : 0x%x\n",
 492                                 __func__, fmdev->rx.fm_rds_mask);
 493         ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &fmdev->rx.fm_rds_mask,
 494             sizeof(fmdev->rx.fm_rds_mask), REG_WR,
 495             &fmdev->maintask_completion, NULL, NULL);
 496     }
 497
 498     return 0;
 499 }
 500
 501 /*
 502 * Function to get the current tuned frequency
 503 * This function will query controller by reading the FM_REG_FM_FREQ(0x0a)
 504 * to determine the current tuned frequency.
 505 */
 506 int fm_rx_get_frequency(struct fmdrv_ops *fmdev, unsigned int *curr_freq)
 507 {
 508     unsigned char payload;
 509     unsigned short tmp_frq;
 510     int ret;
 511     int resp_len;
 512
 513     payload = 2;
 514     ret = fmc_send_cmd(fmdev, FM_REG_FM_FREQ, &payload, 1, REG_RD,
 515             &fmdev->maintask_completion, &tmp_frq, &resp_len);
 516     FM_CHECK_SEND_CMD_STATUS(ret);
 517     pr_info("(fmdev) %s(): FM_REG_FM_FREQ - %d\n", __func__, FM_SET_FREQ(tmp_frq));
 518
 519     *curr_freq = FM_SET_FREQ(tmp_frq);
 520
 521     return ret;
 522 }
 523
 524 /*
 525 * Function to get the current SNR
 526 * This function will query controller by reading the FM_REG_SNR(0xdf)
 527 * to read current SNR.
 528 */
 529 int fm_rx_get_snr(struct fmdrv_ops *fmdev, unsigned int *curr_snr)
 530 {
 531     unsigned char payload;
 532
 533     int ret;
 534     int resp_len;
 535
 536     payload = 2;
 537     ret = fmc_send_cmd(fmdev, FM_REG_SNR, &payload, 1, REG_RD,
 538             &fmdev->maintask_completion, curr_snr, &resp_len);
 539     FM_CHECK_SEND_CMD_STATUS(ret);
 540     pr_info("(fmdev) %s(): FM_REG_SNR : %d\n", __func__, *curr_snr);
 541
 542     return ret;
 543 }
 544
 545
 546 /*
 547 * Function to start a FM SEEK Operation.
 548 *   * Set the start frequency.
 549 *   * Set the other registries such as Search method, search
 550 *    direction, etc.
 551 *   * Start search.
 552 *   * Based on interrupt received, read the current tuned freq
 553 *     and validate the search.
 554 *   * If search frequency out of bound and no wrap_around needed,
 555 *    end the search and return error code -EINVAL
 556 *   * If not, start the search again and check for interrupt.
 557 *   * If no interrupt is received by 20 sec, timeout the seek operation
 558 */
 559 int fm_rx_seek_station(struct fmdrv_ops *fmdev, unsigned char direction_upward,
 560                             unsigned char wrap_around)
 561 {
 562     int ret = 0, freq;
 563     unsigned short tmp_freq, start_freq;
 564     unsigned long timeleft;
 565
 566     fmdev->rx.seek_direction = (direction_upward)?FM_SCAN_UP:FM_SCAN_DOWN;
 567     fmdev->rx.curr_sch_mode = ((FM_TUNER_NORMAL_SCAN_MODE & 0x01) |
 568                                                 (fmdev->rx.seek_direction & 0x80));
 569     if( !wrap_around )
 570         wrap_around = 1;
 571     fmdev->rx.seek_wrap = wrap_around;
 572 #if V4L2_FM_DEBUG
 573     pr_info("(fmdrv) %s(): seek_direction:0x%x curr_sch_mode:0x%x seek_wrap:0x%x\n", __func__,
 574                     fmdev->rx.seek_direction, fmdev->rx.curr_sch_mode, fmdev->rx.seek_wrap);
 575 #endif
 576     ret = fm_rx_get_frequency(fmdev, &freq);
 577     tmp_freq = FM_GET_FREQ(freq);
 578
 579     if(!check_if_valid_freq(fmdev, tmp_freq))
 580     {
 581         start_freq = (direction_upward)?(fmdev->rx.region.low_bound+ fm_sch_step_size[fmdev->rx.sch_step])    /* darrel issue_06  */
 582                             :(fmdev->rx.region.high_bound - fm_sch_step_size[fmdev->rx.sch_step]);
 583         pr_info("(fmdev) %s(): Current frequency is out of bounds. Resetting to freq (%d)\n",
 584                         __func__, FM_SET_FREQ(start_freq));
 585     }
 586     else
 587     {
 588         start_freq = (direction_upward)?(tmp_freq + fm_sch_step_size[fmdev->rx.sch_step])    /* darrel issue_06  */
 589             :(tmp_freq - fm_sch_step_size[fmdev->rx.sch_step]);
 590         if(start_freq >= fmdev->rx.region.high_bound ||
 591             start_freq <= fmdev->rx.region.low_bound)
 592                 start_freq =  (direction_upward)?
 593                 (fmdev->rx.region.low_bound):(fmdev->rx.region.high_bound);
 594     }
 595     pr_info("(fmdrv) %s(): Starting FM seek (%s) from %d..\n",
 596                 __func__, (direction_upward?"SEEKUP":"SEEKDOWN"), FM_SET_FREQ(start_freq));
 597
 598
 599
 600     ret = init_start_search(fmdev, start_freq, FM_TUNER_SEEK_MODE);
 601     if(ret < 0)
 602     {
 603         pr_err ("(fmdrv) %s(): Error starting search for Seek operation\n",
 604                                                                 __func__);
 605         return -EINVAL;
 606     }
 607
 608     /* Wait for tune ended interrupt */
 609     init_completion(&fmdev->seektask_completion);
 610     timeleft = wait_for_completion_timeout(&fmdev->seektask_completion,
 611                            FM_DRV_RX_SEEK_TIMEOUT);
 612     if (!timeleft)
 613     {
 614         pr_err("(fmdrv) %s(): Timeout(%d sec),didn't get seek ended interrupt\n",
 615                __func__, jiffies_to_msecs(FM_DRV_RX_SEEK_TIMEOUT) / 1000);
 616         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 617         return -ETIMEDOUT;
 618     }
 619
 620     fm_rx_read_curr_rssi_freq(fmdev, FALSE);
 621     tmp_freq = fmdev->rx.curr_freq;
 622     ret = process_seek_event(fmdev);
 623     if(ret && fmdev->rx.curr_search_state == FM_STATE_SEEK_CMPL)
 624     {
 625         /* Reset RDS Cache */
 626         fmc_reset_rds_cache(fmdev);
 627         if(fmdev->rx.fm_rds_mask)
 628         /* Update the FM_RDS_MASK to set the earlier bits */
 629         ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &fmdev->rx.fm_rds_mask,
 630             sizeof(fmdev->rx.fm_rds_mask), REG_WR,
 631             &fmdev->maintask_completion, NULL, NULL);
 632         return 0;
 633     }
 634     if(!ret)
 635     {
 636         pr_err("(fmdrv) %s(): Error during Seek. Try again!\n", __func__);
 637         return -EINVAL;
 638     }
 639     else if(ret && fmdev->rx.curr_search_state == FM_STATE_SEEKING)
 640     {
 641
 642         /* Wait for tune ended interrupt */
 643         init_completion(&fmdev->seektask_completion);
 644         timeleft = wait_for_completion_timeout(&fmdev->seektask_completion,
 645                                FM_DRV_RX_SEEK_TIMEOUT);
 646
 647         fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_SCH_FRZ_BIT;
 648         if (!timeleft)
 649         {
 650             pr_err("(fmdrv) %s(): Timeout(%d sec),didn't get Seek ended interrupt\n",
 651                    __func__, jiffies_to_msecs(FM_DRV_RX_SEEK_TIMEOUT) / 1000);
 652             return -ETIMEDOUT;
 653         }
 654
 655         fm_rx_read_curr_rssi_freq(fmdev, FALSE);
 656
 657         /* First check if Scan suceeded or not */
 658         if(fmdev->rx.curr_search_state == FM_STATE_SEEK_ERR)
 659         {
 660             pr_err("(fmdrv) %s(): Wrap Seek failed for %d frequency\n",
 661                         __func__,  FM_SET_FREQ(fmdev->rx.curr_freq));
 662             return -EAGAIN;
 663         }
 664         pr_info("(fmdrv) %s(): Wrap Seek done!\n", __func__);
 665         /* Reset RDS Cache */
 666         fmc_reset_rds_cache(fmdev);
 667         /* Update the FM_RDS_MASK to set the earlier bits */
 668         ret = fmc_send_cmd(fmdev, FM_REG_FM_RDS_MSK, &fmdev->rx.fm_rds_mask,
 669             sizeof(fmdev->rx.fm_rds_mask), REG_WR,
 670             &fmdev->maintask_completion, NULL, NULL);
 671         return 0;
 672     }
 673
 674     pr_err("(fmdrv) %s(): Unhandled case in Seek\n", __func__);
 675     return -EINVAL;
 676 }
 677
 678 /*
 679 * Function to Abort on-going scanning operation.
 680 */
 681 int fm_rx_seek_station_abort(struct fmdrv_ops *fmdev)
 682 {
 683     unsigned char payload;
 684     int ret;
 685
 686     payload = FM_TUNER_NORMAL_SCAN_MODE;
 687
 688     ret = fmc_send_cmd(fmdev, FM_REG_SCH_TUNE, &payload, sizeof(payload),
 689             REG_WR, &fmdev->maintask_completion, NULL, NULL);
 690
 691     pr_info("(fmdrv) %s(): ret %d\n", __func__, ret);
 692
 693     if (ret < 0)
 694         return ret;
 695
 696     return 0;
 697 }
 698
 699
 700 /*
 701 *Function to set band's high and low frequencies
 702 */
 703 int fm_rx_set_band_frequencies(struct fmdrv_ops *fmdev, unsigned int low_freq,
 704     unsigned int high_freq)
 705 {
 706     if((fmdev->rx.region.high_bound == FM_GET_FREQ(high_freq)) &&
 707         (fmdev->rx.region.low_bound = FM_GET_FREQ(low_freq)))
 708     {
 709         pr_err("(fmdrv) %s(): Ignoring setting the same band frequencies\n",
 710                                                         __func__);
 711         return 0;
 712     }
 713     fmdev->rx.region.high_bound = FM_GET_FREQ(high_freq);
 714     fmdev->rx.region.low_bound = FM_GET_FREQ(low_freq);
 715     return 0;
 716 }
 717
 718 /*
 719 *Function to get the current band's high and low frequencies
 720 */
 721 int fm_rx_get_band_frequencies(struct fmdrv_ops *fmdev, unsigned int *low_freq,
 722     unsigned int *high_freq)
 723 {
 724     *high_freq= FM_SET_FREQ(fmdev->rx.region.high_bound);
 725     *low_freq= FM_SET_FREQ(fmdev->rx.region.low_bound) ;
 726     return 0;
 727 }
 728
 729 /*
 730 * Function to set the volume
 731 */
 732 int fm_rx_set_volume(struct fmdrv_ops *fmdev, unsigned short vol_to_set)
 733 {
 734
 735     /* darrel issue_04 : FM_REG_VOLUME_CTRL use UINT16 (0 - 256) */
 736     /*payload type changed unsigned char=> unsigned short*/
 737     /* unsigned char payload; */
 738     unsigned short payload;
 739
 740     int ret;
 741     unsigned char read_length;
 742     unsigned short actual_volume;
 743
 744     if(vol_to_set > FM_RX_VOLUME_MAX)
 745         actual_volume = (vol_to_set/FM_RX_VOLUME_RATIO);
 746     else
 747         actual_volume = vol_to_set;
 748     pr_info("(fmdrv) %s() Actual volume to set  : %d\n",
 749                 __func__,actual_volume);
 750
 751     if (fmdev->curr_fmmode != FM_MODE_RX)
 752         return -EPERM;
 753
 754     if (actual_volume > FM_RX_VOLUME_MAX)
 755     {
 756         pr_err("(fmdrv) %s(): Volume %d is not within(%d-%d) range\n",
 757                         __func__, vol_to_set, FM_RX_VOLUME_MIN, FM_RX_VOLUME_MAX);
 758         actual_volume = 0xFF;
 759     }
 760
 761     payload = actual_volume & 0x1ff;
 762     ret = fmc_send_cmd(fmdev, FM_REG_VOLUME_CTRL, &payload, sizeof(payload),
 763         REG_WR, &fmdev->maintask_completion, NULL, NULL);
 764     FM_CHECK_SEND_CMD_STATUS(ret);
 765
 766     fmdev->rx.curr_volume = vol_to_set;
 767     /* Read current volume */
 768     read_length = FM_READ_1_BYTE_DATA;
 769     ret = fm_rx_get_volume(fmdev, &(fmdev->rx.curr_volume));
 770     pr_info("(fmdrv) %s(): Volume read : %d\n", __func__, fmdev->rx.curr_volume);
 771     if(ret == -ETIMEDOUT)
 772         return -EBUSY;
 773     return ret;
 774 }
 775
 776 /*
 777 *Function to Get volume
 778 */
 779 int fm_rx_get_volume(struct fmdrv_ops *fmdev, unsigned short *curr_vol)
 780 {
 781     int ret, resp_len;
 782
 783     /* darrel issue_04 : FM_REG_VOLUME_CTRL use UINT16 (0 - 256) */
 784     //unsigned char resp_buf[2];
 785     unsigned short resp_buf;
 786
 787     unsigned char read_length;
 788
 789     if (fmdev->curr_fmmode != FM_MODE_RX)
 790         return -EPERM;
 791
 792     if (curr_vol == NULL)
 793     {
 794         pr_err("(fmdrv) %s(): Invalid memory\n", __func__);
 795         return -ENOMEM;
 796     }
 797
 798     /* Read current volume */
 799     read_length = FM_READ_2_BYTE_DATA;
 800     ret = fmc_send_cmd(fmdev, FM_REG_VOLUME_CTRL, &read_length, 1, REG_RD,
 801                         &fmdev->maintask_completion, &resp_buf, &resp_len);
 802     FM_CHECK_SEND_CMD_STATUS(ret);
 803     pr_info("(fmdrv) %s(): fm_rx_get_volume ret : %d\n", __func__, ret);
 804
 805     *curr_vol = fmdev->rx.curr_volume = resp_buf;
 806     pr_info("(fmdrv) %s(): Volume read : 0x%x\n",
 807                         __func__, fmdev->rx.curr_volume);
 808     return ret;
 809 }
 810
 811 /* Sets band (0-US; 1-Europe; 2-Japan) */
 812 int fm_rx_set_region(struct fmdrv_ops *fmdev,
 813             unsigned char region_to_set)
 814 {
 815     unsigned char payload = FM_STEREO_AUTO|FM_BAND_REG_WEST;
 816
 817     int ret = -EPERM;
 818
 819     if (fmdev->curr_fmmode != FM_MODE_RX)
 820         return ret;
 821
 822     if (region_to_set != FM_REGION_NA &&
 823             region_to_set != FM_REGION_EUR &&
 824                     region_to_set != FM_REGION_JP)
 825     {
 826         pr_err("(fmdrv) %s(): Invalid band\n", __func__);
 827         ret = -EINVAL;
 828         return ret;
 829     }
 830     if (region_to_set == FM_REGION_JP)/* set japan region */
 831     {
 832         payload |= FM_BAND_REG_EAST;
 833     }
 834
 835     /* Send cmd to set the band  */
 836     ret = fmc_send_cmd(fmdev, FM_REG_FM_CTRL, &payload, sizeof(payload), REG_WR,
 837         &fmdev->maintask_completion, NULL, NULL);
 838     FM_CHECK_SEND_CMD_STATUS(ret);
 839
 840     fmc_update_region_info(fmdev, region_to_set);
 841
 842     return ret;
 843 }
 844
 845 /*
 846 * Function to retrieve audio control param
 847 * from controller
 848 */
 849 int fm_rx_get_audio_ctrl(struct fmdrv_ops *fmdev, uint16_t *audio_ctrl)
 850 {
 851     uint16_t payload = FM_READ_2_BYTE_DATA;
 852     int ret = -EINVAL, resp_len;
 853
 854     if (fmdev->curr_fmmode != FM_MODE_RX)
 855         return ret;
 856
 857     /* Send cmd to set the band  */
 858     ret = fmc_send_cmd(fmdev, FM_REG_AUD_CTL0, &payload, sizeof(payload), REG_RD,
 859                 &fmdev->maintask_completion, audio_ctrl, &resp_len);
 860     FM_CHECK_SEND_CMD_STATUS(ret);
 861     fmdev->aud_ctrl = fmdev->rx.aud_ctrl = *audio_ctrl;
 862     if(ret == -ETIMEDOUT)
 863         return -EBUSY;
 864     return ret;
 865 }
 866
 867 /*
 868 * Function to set the audio control param
 869 * to controller
 870 */
 871 int fm_rx_set_audio_ctrl(struct fmdrv_ops *fmdev,uint16_t audio_ctrl)
 872 {
 873     uint16_t payload = audio_ctrl;
 874     int ret = -EINVAL;
 875
 876     if (fmdev->curr_fmmode != FM_MODE_RX)
 877         return ret;
 878
 879     /* Send cmd to set the band  */
 880     ret = fmc_send_cmd(fmdev, FM_REG_AUD_CTL0, &payload, sizeof(payload), REG_WR,
 881                 &fmdev->maintask_completion, NULL, NULL);
 882     FM_CHECK_SEND_CMD_STATUS(ret);
 883     fmdev->aud_ctrl = fmdev->rx.aud_ctrl = audio_ctrl;
 884     if(ret == -ETIMEDOUT)
 885         return -EBUSY;
 886     return ret;
 887 }
 888
 889 /*
 890 * Function to Read current mute mode (Mute Off/On)
 891 */
 892 int fm_rx_get_mute_mode(struct fmdrv_ops *fmdev,
 893             unsigned char *curr_mute_mode)
 894 {
 895     uint16_t tmp;
 896     int ret = -EINVAL;
 897     if (fmdev->curr_fmmode != FM_MODE_RX)
 898         return -EPERM;
 899
 900     if (curr_mute_mode == NULL) {
 901         pr_err("(fmdrv) %s(): Invalid memory\n", __func__);
 902         return -ENOMEM;
 903     }
 904     ret = fm_rx_get_audio_ctrl(fmdev, &tmp);
 905     *curr_mute_mode = fmdev->rx.curr_mute_mode = tmp & FM_MANUAL_MUTE;
 906     pr_info("(fmdrv) %s(): Mute is %s\n", __func__, ((*curr_mute_mode)?"ON":"OFF"));
 907     return 0;
 908 }
 909
 910 /*
 911 * Configures mute mode (Mute Off/On)
 912 */
 913 int fm_rx_set_mute_mode(struct fmdrv_ops *fmdev,
 914             unsigned char mute_mode_toset)
 915 {
 916     int ret;
 917     uint16_t aud_ctrl;
 918
 919     if (fmdev->curr_fmmode != FM_MODE_RX)
 920         return -EPERM;
 921     /* First read the aud_ctrl*/
 922     ret = fm_rx_get_audio_ctrl(fmdev, &aud_ctrl);
 923     /* turn on MUTE */
 924     if (mute_mode_toset)
 925     {
 926         aud_ctrl|= FM_MANUAL_MUTE;
 927     }
 928     else /* unmute */
 929     {
 930         aud_ctrl &= (~FM_MANUAL_MUTE);
 931     }
 932     ret = fm_rx_set_audio_ctrl (fmdev, aud_ctrl);
 933     FM_CHECK_SEND_CMD_STATUS(ret);
 934     if (mute_mode_toset)
 935        msleep(300);
 936     pr_info("(fmdrv) %s(): Current mute state : %d\n", __func__, mute_mode_toset);
 937     fmdev->rx.curr_mute_mode = mute_mode_toset;
 938     return ret;
 939 }
 940
 941 /* Sets RX stereo/mono modes */
 942 int fm_rx_set_audio_mode(struct fmdrv_ops *fmdev, unsigned char mode)
 943 {
 944     unsigned char audio_ctrl = FM_STEREO_SWITCH|FM_STEREO_AUTO;
 945     int ret;
 946
 947     if (fmdev->curr_fmmode != FM_MODE_RX)
 948      return -EPERM;
 949
 950     if (mode != FM_STEREO_MODE && mode != FM_MONO_MODE &&
 951         mode != FM_AUTO_MODE && mode != FM_SWITCH_MODE)
 952     {
 953         pr_err("(fmdrv) %s(): Invalid mode :%d\n", __func__, mode);
 954         return -EINVAL;
 955     }
 956
 957     if (fmdev->rx.audio_mode == mode)
 958     {
 959         pr_info ("(fmdrv) %s(): no change in audio mode\n", __func__);
 960         return 0;
 961     }
 962     switch (mode)
 963     {
 964         case FM_SWITCH_MODE: /* stereo witch in auto mode */
 965             /* as default */;
 966             break;
 967         case FM_MONO_MODE: /* manually set to mono, bit2 OFF is mono */
 968             audio_ctrl &= ~FM_STEREO_AUTO;/* set to manual mono */
 969             break;
 970         case FM_STEREO_MODE: /* manually set to stereo */
 971             audio_ctrl  &= ~FM_STEREO_AUTO; /* set to manual */
 972             audio_ctrl |= FM_STEREO_MANUAL; /* set to stereo in manual mode */
 973             break;
 974         case FM_AUTO_MODE:/* auto blend as default,  */
 975             audio_ctrl  &= ~FM_STEREO_SWITCH; /* turn OFF bit3 to activate blend */
 976             break;
 977         default:
 978             break;
 979     }
 980     /* set the region bit */
 981     audio_ctrl |= (fmdev->rx.curr_region == FM_REGION_JP) ? \
 982                                 FM_BAND_REG_EAST : FM_BAND_REG_WEST;
 983
 984     /* Set stereo/mono mode */
 985     ret = fmc_send_cmd(fmdev, FM_REG_FM_CTRL, &audio_ctrl, sizeof(audio_ctrl),
 986             REG_WR, &fmdev->maintask_completion, NULL, NULL);
 987     FM_CHECK_SEND_CMD_STATUS(ret);
 988     fmdev->rx.audio_mode = mode;
 989     if(mode == FM_MONO_MODE)
 990     {
 991         fmdev->device_info.rxsubchans |= V4L2_TUNER_SUB_MONO;
 992         fmdev->device_info.rxsubchans &= ~V4L2_TUNER_SUB_STEREO;
 993     }
 994     if(mode == FM_STEREO_MODE)
 995     {
 996         fmdev->device_info.rxsubchans |= V4L2_TUNER_SUB_STEREO;
 997         fmdev->device_info.rxsubchans &= ~V4L2_TUNER_SUB_MONO;
 998     }
 999     return 0;
1000 }
1001
1002 /* Gets current RX stereo/mono mode */
1003 int fm_rx_get_audio_mode(struct fmdrv_ops *fmdev, unsigned char *mode)
1004 {
1005     int ret, len;
1006     unsigned char payload = FM_READ_1_BYTE_DATA, resp;
1007     if (fmdev->curr_fmmode != FM_MODE_RX)
1008     return -EPERM;
1009
1010     if (mode == NULL)
1011     {
1012         pr_err("(fmdrv) %s(): Invalid memory\n", __func__);
1013         return -ENOMEM;
1014     }
1015     ret = fmc_send_cmd(fmdev, FM_REG_FM_CTRL, &payload, sizeof(payload),
1016             REG_RD, &fmdev->maintask_completion, &resp, &len);
1017     if((resp & FM_STEREO_SWITCH) && (resp & FM_STEREO_AUTO))
1018         *mode = FM_SWITCH_MODE;
1019     else if(!(resp & FM_STEREO_AUTO))
1020             *mode = FM_MONO_MODE;
1021     else if(!(resp & FM_STEREO_AUTO) && (resp & FM_STEREO_MANUAL))
1022             *mode = FM_STEREO_MODE;
1023     else if(!(resp & FM_STEREO_SWITCH))
1024             *mode = FM_AUTO_MODE;
1025     fmdev->rx.audio_mode = resp;
1026     return ret;
1027 }
1028
1029 /* Sets RX stereo/mono modes */
1030 int fm_rx_config_audio_path(struct fmdrv_ops *fmdev, unsigned char path)
1031 {
1032     int ret;
1033
1034     if (fmdev->curr_fmmode != FM_MODE_RX)
1035         return -EPERM;
1036
1037     if (fmdev->rx.audio_path == path)
1038     {
1039         pr_info ("(fmdrv) %s(): no change in audio path\n", __func__);
1040         return 0;
1041     }
1042     /* if FM is on SCO and request to turn off FM over SCO */
1043     if (!(path & FM_AUDIO_BT_MONO) &&
1044                 (fmdev->rx.pcm_reg & FM_PCM_ROUTE_ON_BIT))
1045     {
1046         /* disable pcm_reg CB value FM routing bit */
1047         fmdev->rx.pcm_reg &= ~FM_PCM_ROUTE_ON_BIT;
1048     }
1049     else if((path & FM_AUDIO_BT_MONO) &&
1050                 !(fmdev->rx.pcm_reg & FM_PCM_ROUTE_ON_BIT)) /* turn on FM via SCO */
1051     {
1052         /* when FM to SCO active, FM enforce I2S output */
1053         path |= FM_AUDIO_I2S;
1054         /* turn on pcm_reg CB value FM routing bit */
1055         fmdev->rx.pcm_reg |= FM_PCM_ROUTE_ON_BIT;
1056     }
1057
1058     /* write to PCM_ROUTE register */
1059     ret = fmc_send_cmd(fmdev, FM_REG_PCM_ROUTE,
1060             &fmdev->rx.pcm_reg, sizeof(fmdev->rx.pcm_reg), REG_WR,
1061             &fmdev->maintask_completion, NULL, NULL);
1062
1063     FM_CHECK_SEND_CMD_STATUS(ret);
1064
1065     if (path & FM_AUDIO_I2S)
1066         fmdev->rx.aud_ctrl |= FM_AUDIO_I2S_ON;
1067     else
1068         fmdev->rx.aud_ctrl &= ~((unsigned short)FM_AUDIO_I2S_ON);
1069
1070     if (path & FM_AUDIO_DAC)
1071         fmdev->rx.aud_ctrl |= FM_AUDIO_DAC_ON;
1072     else
1073         fmdev->rx.aud_ctrl &= ~((unsigned short)FM_AUDIO_DAC_ON);
1074
1075     ret = fm_rx_set_audio_ctrl (fmdev, fmdev->rx.aud_ctrl);
1076
1077     FM_CHECK_SEND_CMD_STATUS(ret);
1078     fmdev->rx.audio_path = path;
1079
1080     return 0;
1081 }
1082
1083 /* Choose RX de-emphasis filter mode (50us/75us) */
1084 int fm_rx_config_deemphasis(struct fmdrv_ops *fmdev, unsigned char mode)
1085 {
1086     int ret;
1087
1088     if (fmdev->curr_fmmode != FM_MODE_RX)
1089         return -EPERM;
1090
1091     if (mode != FM_DEEMPHA_50U &&
1092         mode != FM_DEEMPHA_75U)
1093     {
1094         pr_err("(fmdrv) %s(): Invalid rx de-emphasis mode\n", __func__);
1095         return -EINVAL;
1096     }
1097
1098     if (mode == FM_DEEMPHA_50U )
1099         /* set to 50us by turning off 6th bit */
1100         fmdev->rx.aud_ctrl &=  (~FM_DEEMPHA_75_ON);
1101     else
1102         /* set to 75us by turning on 6th bit */
1103         fmdev->rx.aud_ctrl |=  FM_DEEMPHA_75_ON;
1104
1105     ret = fm_rx_set_audio_ctrl (fmdev, fmdev->rx.aud_ctrl);
1106
1107     FM_CHECK_SEND_CMD_STATUS(ret);
1108
1109     return 0;
1110 }
1111
1112 /*
1113 * Function to get the current scan step.
1114 * Returns FM_STEP_100KHZ or FM_STEP_200KHZ
1115 */
1116 int fm_rx_get_scan_step(struct fmdrv_ops *fmdev,
1117             unsigned char *step_type)
1118 {
1119     if (fmdev->curr_fmmode != FM_MODE_RX)
1120         return -EPERM;
1121
1122     if (step_type == NULL)
1123     {
1124         pr_err("(fmdrv) %s(): Invalid memory\n", __func__);
1125         return -ENOMEM;
1126     }
1127     *step_type = fmdev->rx.sch_step;
1128     return 0;
1129 }
1130
1131 /*
1132 * Sets scan step to 100 or 200 KHz based on step type :
1133 * FM_STEP_100KHZ or FM_STEP_200KHZ
1134 */
1135 int fm_rx_set_scan_step(struct fmdrv_ops *fmdev,
1136             unsigned char step_type)
1137 {
1138     int ret;
1139     unsigned short payload;
1140     if (fmdev->curr_fmmode != FM_MODE_RX)
1141         return -EPERM;
1142
1143        /* turn on MUTE */
1144     if (fmdev->rx.sch_step == step_type)
1145     {
1146         pr_info ("(fmdrv) %s(): no change in scan step size\n", __func__);
1147         return 0;
1148     }
1149     payload = fm_sch_step_size[step_type];    /* darrel issue_06  */
1150     ret = fmc_send_cmd(fmdev, FM_REG_SCH_STEP, &payload, sizeof(payload),
1151             REG_WR, &fmdev->maintask_completion, NULL, NULL);
1152     FM_CHECK_SEND_CMD_STATUS(ret);
1153
1154     fmdev->rx.sch_step = step_type;
1155     return ret;
1156 }
1157
1158 /************************************************************************************
1159 ** RDS functions
1160 ************************************************************************************/
1161
1162 /* Sets RDS operation mode (RDS/RDBS) */
1163 int fm_rx_set_rds_system(struct fmdrv_ops *fmdev, unsigned char rdbs_en_dis)
1164 {
1165     unsigned char payload;
1166     int ret;
1167     pr_debug("(fmdrv) %s()\n", __func__);
1168     if (fmdev->curr_fmmode != FM_MODE_RX)
1169         return -EPERM;
1170
1171     /* Set RDS control */
1172     if (rdbs_en_dis == FM_RDBS_ENABLE)
1173         payload = (FM_RDS_CTRL_RBDS|FM_RDS_CTRL_FIFO_FLUSH);
1174     else
1175         payload = FM_RDS_CTRL_FIFO_FLUSH;
1176
1177     ret = fmc_send_cmd(fmdev, FM_REG_RDS_CTL0, &payload, sizeof(payload),
1178                         REG_WR, &fmdev->maintask_completion, NULL, NULL);
1179     FM_CHECK_SEND_CMD_STATUS(ret);
1180
1181     return 0;
1182 }
1183
1184 /*
1185 * Function to enable RDS. Called during FM enable.
1186 */
1187 void fm_rx_enable_rds(struct fmdrv_ops *fmdev)
1188 {
1189     unsigned char payload;
1190     int ret = 0;
1191     if(fmdev->rx.fm_func_mask & (FM_RDS_BIT | FM_RBDS_BIT))
1192     {
1193         payload = FM_RDS_UPD_TUPLE;
1194         /* write RDS FIFO waterline in depth of RDS tuples */
1195         ret = fmc_send_cmd(fmdev, FM_REG_RDS_WLINE, &payload, sizeof(payload),
1196                             REG_WR, &fmdev->maintask_completion, NULL, NULL);
1197         if(ret<0)
1198             pr_err("(fmdrv) %s(): Error writing to RDS FIFO waterline register\n",
1199                                                                         __func__);
1200         /* drain RDS FIFO */
1201         payload = FM_RDS_FIFO_MAX;
1202         ret = fmc_send_cmd(fmdev, FM_REG_RDS_DATA, &payload, 1,
1203                             REG_RD, &fmdev->maintask_completion, NULL, NULL);
1204
1205         /* set new FM_RDS mask so that RDS read */
1206         fmdev->rx.fm_rds_mask |= I2C_MASK_RDS_FIFO_WLINE_BIT;
1207     }
1208     else
1209     {
1210         pr_err("(fmdrv) %s(): RDS not enabled during FM enable\n", __func__);
1211         fmdev->rx.fm_rds_mask &= ~I2C_MASK_RDS_FIFO_WLINE_BIT;
1212     }
1213     fm_rx_set_mask(fmdev, fmdev->rx.fm_rds_mask);
1214     /* Reset the fm_rds_flag here as for the first time we dont get
1215     any interrupt during ENABLE to cleanup the bit */
1216     fmdev->rx.fm_rds_flag &= ~FM_RDS_FLAG_CLEAN_BIT;
1217
1218 }
1219
1220 /*
1221 * Returns availability of RDS data in internel buffer.
1222 * If data is present in RDS buffer, return 0. Else, return -EAGAIN.
1223 * The V4L2 driver's poll() uses this method to determine RDS data availability.
1224 */
1225 int fm_rx_is_rds_data_available(struct fmdrv_ops *fmdev, struct file *file,
1226                   struct poll_table_struct *pts)
1227 {
1228     poll_wait(file, &fmdev->rx.rds.read_queue, pts);
1229     if (fmdev->rx.rds.rd_index != fmdev->rx.rds.wr_index) {
1230         pr_info("(fmdrv) %s(): Poll success. RDS data is available in buffer\n",
1231                                                         __func__);
1232         return 0;
1233     }
1234     pr_err("(fmdev) %s(): RDS Buffer is empty\n", __func__);
1235     return -EAGAIN;
1236 }
1237
1238
1239
1240 /*
1241  * Sets the signal strength level that once reached
1242  * will stop the auto search process
1243  */
1244 int fm_rx_set_cfg_blnd_mute(struct fmdrv_ops *fmdev, unsigned char set_blndmute)
1245 {
1246     int ret;
1247
1248     ret = fmc_send_cmd(fmdev, FM_REG_BLEND_MUTE, &(fmdev->softmute_blend_config), sizeof(fmdev->softmute_blend_config),
1249             REG_WR, &fmdev->maintask_completion, NULL,NULL);
1250
1251     if (ret < 0)
1252         return ret;
1253
1254     fmdev->set_blndmute = set_blndmute;
1255
1256     return 0;
1257 }