drivers/media/radio/wl128x/fmdrv_rx.c

   1 /*
   2  *  FM Driver for Connectivity chip of Texas Instruments.
   3  *  This sub-module of FM driver implements FM RX functionality.
   4  *
   5  *  Copyright (C) 2011 Texas Instruments
   6  *  Author: Raja Mani <raja_mani@ti.com>
   7  *  Author: Manjunatha Halli <manjunatha_halli@ti.com>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License version 2 as
  11  *  published by the Free Software Foundation.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include "fmdrv.h"
  25 #include "fmdrv_common.h"
  26 #include "fmdrv_rx.h"
  27
  28 void fm_rx_reset_rds_cache(struct fmdev *fmdev)
  29 {
  30         fmdev->rx.rds.flag = FM_RDS_DISABLE;
  31         fmdev->rx.rds.last_blk_idx = 0;
  32         fmdev->rx.rds.wr_idx = 0;
  33         fmdev->rx.rds.rd_idx = 0;
  34
  35         if (fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
  36                 fmdev->irq_info.mask |= FM_LEV_EVENT;
  37 }
  38
  39 void fm_rx_reset_station_info(struct fmdev *fmdev)
  40 {
  41         fmdev->rx.stat_info.picode = FM_NO_PI_CODE;
  42         fmdev->rx.stat_info.afcache_size = 0;
  43         fmdev->rx.stat_info.af_list_max = 0;
  44 }
  45
  46 int fm_rx_set_freq(struct fmdev *fmdev, u32 freq)
  47 {
  48         unsigned long timeleft;
  49         u16 payload, curr_frq, intr_flag;
  50         u32 curr_frq_in_khz;
  51         u32 resp_len;
  52         int ret;
  53
  54         if (freq < fmdev->rx.region.bot_freq || freq > fmdev->rx.region.top_freq) {
  55                 fmerr("Invalid frequency %d\n", freq);
  56                 return -EINVAL;
  57         }
  58
  59         /* Set audio enable */
  60         payload = FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG;
  61
  62         ret = fmc_send_cmd(fmdev, AUDIO_ENABLE_SET, REG_WR, &payload,
  63                         sizeof(payload), NULL, NULL);
  64         if (ret < 0)
  65                 return ret;
  66
  67         /* Set hilo to automatic selection */
  68         payload = FM_RX_IFFREQ_HILO_AUTOMATIC;
  69         ret = fmc_send_cmd(fmdev, HILO_SET, REG_WR, &payload,
  70                         sizeof(payload), NULL, NULL);
  71         if (ret < 0)
  72                 return ret;
  73
  74         /* Calculate frequency index and set*/
  75         payload = (freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
  76
  77         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
  78                         sizeof(payload), NULL, NULL);
  79         if (ret < 0)
  80                 return ret;
  81
  82         /* Read flags - just to clear any pending interrupts if we had */
  83         ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
  84         if (ret < 0)
  85                 return ret;
  86
  87         /* Enable FR, BL interrupts */
  88         intr_flag = fmdev->irq_info.mask;
  89         fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
  90         payload = fmdev->irq_info.mask;
  91         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
  92                         sizeof(payload), NULL, NULL);
  93         if (ret < 0)
  94                 return ret;
  95
  96         /* Start tune */
  97         payload = FM_TUNER_PRESET_MODE;
  98         ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
  99                         sizeof(payload), NULL, NULL);
 100         if (ret < 0)
 101                 goto exit;
 102
 103         /* Wait for tune ended interrupt */
 104         init_completion(&fmdev->maintask_comp);
 105         timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
 106                         FM_DRV_TX_TIMEOUT);
 107         if (!timeleft) {
 108                 fmerr("Timeout(%d sec),didn't get tune ended int\n",
 109                            jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
 110                 ret = -ETIMEDOUT;
 111                 goto exit;
 112         }
 113
 114         /* Read freq back to confirm */
 115         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2, &curr_frq, &resp_len);
 116         if (ret < 0)
 117                 goto exit;
 118
 119         curr_frq = be16_to_cpu((__force __be16)curr_frq);
 120         curr_frq_in_khz = (fmdev->rx.region.bot_freq + ((u32)curr_frq * FM_FREQ_MUL));
 121
 122         if (curr_frq_in_khz != freq) {
 123                 pr_info("Frequency is set to (%d) but "
 124                            "requested freq is (%d)\n", curr_frq_in_khz, freq);
 125         }
 126
 127         /* Update local cache  */
 128         fmdev->rx.freq = curr_frq_in_khz;
 129 exit:
 130         /* Re-enable default FM interrupts */
 131         fmdev->irq_info.mask = intr_flag;
 132         payload = fmdev->irq_info.mask;
 133         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
 134                         sizeof(payload), NULL, NULL);
 135         if (ret < 0)
 136                 return ret;
 137
 138         /* Reset RDS cache and current station pointers */
 139         fm_rx_reset_rds_cache(fmdev);
 140         fm_rx_reset_station_info(fmdev);
 141
 142         return ret;
 143 }
 144
 145 static int fm_rx_set_channel_spacing(struct fmdev *fmdev, u32 spacing)
 146 {
 147         u16 payload;
 148         int ret;
 149
 150         if (spacing > 0 && spacing <= 50000)
 151                 spacing = FM_CHANNEL_SPACING_50KHZ;
 152         else if (spacing > 50000 && spacing <= 100000)
 153                 spacing = FM_CHANNEL_SPACING_100KHZ;
 154         else
 155                 spacing = FM_CHANNEL_SPACING_200KHZ;
 156
 157         /* set channel spacing */
 158         payload = spacing;
 159         ret = fmc_send_cmd(fmdev, CHANL_BW_SET, REG_WR, &payload,
 160                         sizeof(payload), NULL, NULL);
 161         if (ret < 0)
 162                 return ret;
 163
 164         fmdev->rx.region.chanl_space = spacing * FM_FREQ_MUL;
 165
 166         return ret;
 167 }
 168
 169 int fm_rx_seek(struct fmdev *fmdev, u32 seek_upward,
 170                 u32 wrap_around, u32 spacing)
 171 {
 172         u32 resp_len;
 173         u16 curr_frq, next_frq, last_frq;
 174         u16 payload, int_reason, intr_flag;
 175         u16 offset, space_idx;
 176         unsigned long timeleft;
 177         int ret;
 178
 179         /* Set channel spacing */
 180         ret = fm_rx_set_channel_spacing(fmdev, spacing);
 181         if (ret < 0) {
 182                 fmerr("Failed to set channel spacing\n");
 183                 return ret;
 184         }
 185
 186         /* Read the current frequency from chip */
 187         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL,
 188                         sizeof(curr_frq), &curr_frq, &resp_len);
 189         if (ret < 0)
 190                 return ret;
 191
 192         curr_frq = be16_to_cpu((__force __be16)curr_frq);
 193         last_frq = (fmdev->rx.region.top_freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
 194
 195         /* Check the offset in order to be aligned to the channel spacing*/
 196         space_idx = fmdev->rx.region.chanl_space / FM_FREQ_MUL;
 197         offset = curr_frq % space_idx;
 198
 199         next_frq = seek_upward ? curr_frq + space_idx /* Seek Up */ :
 200                                 curr_frq - space_idx /* Seek Down */ ;
 201
 202         /*
 203          * Add or subtract offset in order to stay aligned to the channel
 204          * spacing.
 205          */
 206         if ((short)next_frq < 0)
 207                 next_frq = last_frq - offset;
 208         else if (next_frq > last_frq)
 209                 next_frq = 0 + offset;
 210
 211 again:
 212         /* Set calculated next frequency to perform seek */
 213         payload = next_frq;
 214         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
 215                         sizeof(payload), NULL, NULL);
 216         if (ret < 0)
 217                 return ret;
 218
 219         /* Set search direction (0:Seek Down, 1:Seek Up) */
 220         payload = (seek_upward ? FM_SEARCH_DIRECTION_UP : FM_SEARCH_DIRECTION_DOWN);
 221         ret = fmc_send_cmd(fmdev, SEARCH_DIR_SET, REG_WR, &payload,
 222                         sizeof(payload), NULL, NULL);
 223         if (ret < 0)
 224                 return ret;
 225
 226         /* Read flags - just to clear any pending interrupts if we had */
 227         ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
 228         if (ret < 0)
 229                 return ret;
 230
 231         /* Enable FR, BL interrupts */
 232         intr_flag = fmdev->irq_info.mask;
 233         fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
 234         payload = fmdev->irq_info.mask;
 235         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
 236                         sizeof(payload), NULL, NULL);
 237         if (ret < 0)
 238                 return ret;
 239
 240         /* Start seek */
 241         payload = FM_TUNER_AUTONOMOUS_SEARCH_MODE;
 242         ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
 243                         sizeof(payload), NULL, NULL);
 244         if (ret < 0)
 245                 return ret;
 246
 247         /* Wait for tune ended/band limit reached interrupt */
 248         init_completion(&fmdev->maintask_comp);
 249         timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
 250                         FM_DRV_RX_SEEK_TIMEOUT);
 251         if (!timeleft) {
 252                 fmerr("Timeout(%d sec),didn't get tune ended int\n",
 253                            jiffies_to_msecs(FM_DRV_RX_SEEK_TIMEOUT) / 1000);
 254                 return -ENODATA;
 255         }
 256
 257         int_reason = fmdev->irq_info.flag & (FM_TUNE_COMPLETE | FM_BAND_LIMIT);
 258
 259         /* Re-enable default FM interrupts */
 260         fmdev->irq_info.mask = intr_flag;
 261         payload = fmdev->irq_info.mask;
 262         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
 263                         sizeof(payload), NULL, NULL);
 264         if (ret < 0)
 265                 return ret;
 266
 267         if (int_reason & FM_BL_EVENT) {
 268                 if (wrap_around == 0) {
 269                         fmdev->rx.freq = seek_upward ?
 270                                 fmdev->rx.region.top_freq :
 271                                 fmdev->rx.region.bot_freq;
 272                 } else {
 273                         fmdev->rx.freq = seek_upward ?
 274                                 fmdev->rx.region.bot_freq :
 275                                 fmdev->rx.region.top_freq;
 276                         /* Calculate frequency index to write */
 277                         next_frq = (fmdev->rx.freq -
 278                                         fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
 279                         goto again;
 280                 }
 281         } else {
 282                 /* Read freq to know where operation tune operation stopped */
 283                 ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2,
 284                                 &curr_frq, &resp_len);
 285                 if (ret < 0)
 286                         return ret;
 287
 288                 curr_frq = be16_to_cpu((__force __be16)curr_frq);
 289                 fmdev->rx.freq = (fmdev->rx.region.bot_freq +
 290                                 ((u32)curr_frq * FM_FREQ_MUL));
 291
 292         }
 293         /* Reset RDS cache and current station pointers */
 294         fm_rx_reset_rds_cache(fmdev);
 295         fm_rx_reset_station_info(fmdev);
 296
 297         return ret;
 298 }
 299
 300 int fm_rx_set_volume(struct fmdev *fmdev, u16 vol_to_set)
 301 {
 302         u16 payload;
 303         int ret;
 304
 305         if (fmdev->curr_fmmode != FM_MODE_RX)
 306                 return -EPERM;
 307
 308         if (vol_to_set > FM_RX_VOLUME_MAX) {
 309                 fmerr("Volume is not within(%d-%d) range\n",
 310                            FM_RX_VOLUME_MIN, FM_RX_VOLUME_MAX);
 311                 return -EINVAL;
 312         }
 313         vol_to_set *= FM_RX_VOLUME_GAIN_STEP;
 314
 315         payload = vol_to_set;
 316         ret = fmc_send_cmd(fmdev, VOLUME_SET, REG_WR, &payload,
 317                         sizeof(payload), NULL, NULL);
 318         if (ret < 0)
 319                 return ret;
 320
 321         fmdev->rx.volume = vol_to_set;
 322         return ret;
 323 }
 324
 325 /* Get volume */
 326 int fm_rx_get_volume(struct fmdev *fmdev, u16 *curr_vol)
 327 {
 328         if (fmdev->curr_fmmode != FM_MODE_RX)
 329                 return -EPERM;
 330
 331         if (curr_vol == NULL) {
 332                 fmerr("Invalid memory\n");
 333                 return -ENOMEM;
 334         }
 335
 336         *curr_vol = fmdev->rx.volume / FM_RX_VOLUME_GAIN_STEP;
 337
 338         return 0;
 339 }
 340
 341 /* To get current band's bottom and top frequency */
 342 int fm_rx_get_band_freq_range(struct fmdev *fmdev, u32 *bot_freq, u32 *top_freq)
 343 {
 344         if (bot_freq != NULL)
 345                 *bot_freq = fmdev->rx.region.bot_freq;
 346
 347         if (top_freq != NULL)
 348                 *top_freq = fmdev->rx.region.top_freq;
 349
 350         return 0;
 351 }
 352
 353 /* Returns current band index (0-Europe/US; 1-Japan) */
 354 void fm_rx_get_region(struct fmdev *fmdev, u8 *region)
 355 {
 356         *region = fmdev->rx.region.fm_band;
 357 }
 358
 359 /* Sets band (0-Europe/US; 1-Japan) */
 360 int fm_rx_set_region(struct fmdev *fmdev, u8 region_to_set)
 361 {
 362         u16 payload;
 363         u32 new_frq = 0;
 364         int ret;
 365
 366         if (region_to_set != FM_BAND_EUROPE_US &&
 367             region_to_set != FM_BAND_JAPAN) {
 368                 fmerr("Invalid band\n");
 369                 return -EINVAL;
 370         }
 371
 372         if (fmdev->rx.region.fm_band == region_to_set) {
 373                 fmerr("Requested band is already configured\n");
 374                 return 0;
 375         }
 376
 377         /* Send cmd to set the band  */
 378         payload = (u16)region_to_set;
 379         ret = fmc_send_cmd(fmdev, BAND_SET, REG_WR, &payload,
 380                         sizeof(payload), NULL, NULL);
 381         if (ret < 0)
 382                 return ret;
 383
 384         fmc_update_region_info(fmdev, region_to_set);
 385
 386         /* Check whether current RX frequency is within band boundary */
 387         if (fmdev->rx.freq < fmdev->rx.region.bot_freq)
 388                 new_frq = fmdev->rx.region.bot_freq;
 389         else if (fmdev->rx.freq > fmdev->rx.region.top_freq)
 390                 new_frq = fmdev->rx.region.top_freq;
 391
 392         if (new_frq) {
 393                 fmdbg("Current freq is not within band limit boundary,"
 394                                 "switching to %d KHz\n", new_frq);
 395                  /* Current RX frequency is not in range. So, update it */
 396                 ret = fm_rx_set_freq(fmdev, new_frq);
 397         }
 398
 399         return ret;
 400 }
 401
 402 /* Reads current mute mode (Mute Off/On/Attenuate)*/
 403 int fm_rx_get_mute_mode(struct fmdev *fmdev, u8 *curr_mute_mode)
 404 {
 405         if (fmdev->curr_fmmode != FM_MODE_RX)
 406                 return -EPERM;
 407
 408         if (curr_mute_mode == NULL) {
 409                 fmerr("Invalid memory\n");
 410                 return -ENOMEM;
 411         }
 412
 413         *curr_mute_mode = fmdev->rx.mute_mode;
 414
 415         return 0;
 416 }
 417
 418 static int fm_config_rx_mute_reg(struct fmdev *fmdev)
 419 {
 420         u16 payload, muteval;
 421         int ret;
 422
 423         muteval = 0;
 424         switch (fmdev->rx.mute_mode) {
 425         case FM_MUTE_ON:
 426                 muteval = FM_RX_AC_MUTE_MODE;
 427                 break;
 428
 429         case FM_MUTE_OFF:
 430                 muteval = FM_RX_UNMUTE_MODE;
 431                 break;
 432
 433         case FM_MUTE_ATTENUATE:
 434                 muteval = FM_RX_SOFT_MUTE_FORCE_MODE;
 435                 break;
 436         }
 437         if (fmdev->rx.rf_depend_mute == FM_RX_RF_DEPENDENT_MUTE_ON)
 438                 muteval |= FM_RX_RF_DEP_MODE;
 439         else
 440                 muteval &= ~FM_RX_RF_DEP_MODE;
 441
 442         payload = muteval;
 443         ret = fmc_send_cmd(fmdev, MUTE_STATUS_SET, REG_WR, &payload,
 444                         sizeof(payload), NULL, NULL);
 445         if (ret < 0)
 446                 return ret;
 447
 448         return 0;
 449 }
 450
 451 /* Configures mute mode (Mute Off/On/Attenuate) */
 452 int fm_rx_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset)
 453 {
 454         u8 org_state;
 455         int ret;
 456
 457         if (fmdev->rx.mute_mode == mute_mode_toset)
 458                 return 0;
 459
 460         org_state = fmdev->rx.mute_mode;
 461         fmdev->rx.mute_mode = mute_mode_toset;
 462
 463         ret = fm_config_rx_mute_reg(fmdev);
 464         if (ret < 0) {
 465                 fmdev->rx.mute_mode = org_state;
 466                 return ret;
 467         }
 468
 469         return 0;
 470 }
 471
 472 /* Gets RF dependent soft mute mode enable/disable status */
 473 int fm_rx_get_rfdepend_softmute(struct fmdev *fmdev, u8 *curr_mute_mode)
 474 {
 475         if (fmdev->curr_fmmode != FM_MODE_RX)
 476                 return -EPERM;
 477
 478         if (curr_mute_mode == NULL) {
 479                 fmerr("Invalid memory\n");
 480                 return -ENOMEM;
 481         }
 482
 483         *curr_mute_mode = fmdev->rx.rf_depend_mute;
 484
 485         return 0;
 486 }
 487
 488 /* Sets RF dependent soft mute mode */
 489 int fm_rx_set_rfdepend_softmute(struct fmdev *fmdev, u8 rfdepend_mute)
 490 {
 491         u8 org_state;
 492         int ret;
 493
 494         if (fmdev->curr_fmmode != FM_MODE_RX)
 495                 return -EPERM;
 496
 497         if (rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_ON &&
 498             rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_OFF) {
 499                 fmerr("Invalid RF dependent soft mute\n");
 500                 return -EINVAL;
 501         }
 502         if (fmdev->rx.rf_depend_mute == rfdepend_mute)
 503                 return 0;
 504
 505         org_state = fmdev->rx.rf_depend_mute;
 506         fmdev->rx.rf_depend_mute = rfdepend_mute;
 507
 508         ret = fm_config_rx_mute_reg(fmdev);
 509         if (ret < 0) {
 510                 fmdev->rx.rf_depend_mute = org_state;
 511                 return ret;
 512         }
 513
 514         return 0;
 515 }
 516
 517 /* Returns the signal strength level of current channel */
 518 int fm_rx_get_rssi_level(struct fmdev *fmdev, u16 *rssilvl)
 519 {
 520         __be16 curr_rssi_lel;
 521         u32 resp_len;
 522         int ret;
 523
 524         if (rssilvl == NULL) {
 525                 fmerr("Invalid memory\n");
 526                 return -ENOMEM;
 527         }
 528         /* Read current RSSI level */
 529         ret = fmc_send_cmd(fmdev, RSSI_LVL_GET, REG_RD, NULL, 2,
 530                         &curr_rssi_lel, &resp_len);
 531         if (ret < 0)
 532                 return ret;
 533
 534         *rssilvl = be16_to_cpu(curr_rssi_lel);
 535
 536         return 0;
 537 }
 538
 539 /*
 540  * Sets the signal strength level that once reached
 541  * will stop the auto search process
 542  */
 543 int fm_rx_set_rssi_threshold(struct fmdev *fmdev, short rssi_lvl_toset)
 544 {
 545         u16 payload;
 546         int ret;
 547
 548         if (rssi_lvl_toset < FM_RX_RSSI_THRESHOLD_MIN ||
 549                         rssi_lvl_toset > FM_RX_RSSI_THRESHOLD_MAX) {
 550                 fmerr("Invalid RSSI threshold level\n");
 551                 return -EINVAL;
 552         }
 553         payload = (u16)rssi_lvl_toset;
 554         ret = fmc_send_cmd(fmdev, SEARCH_LVL_SET, REG_WR, &payload,
 555                         sizeof(payload), NULL, NULL);
 556         if (ret < 0)
 557                 return ret;
 558
 559         fmdev->rx.rssi_threshold = rssi_lvl_toset;
 560
 561         return 0;
 562 }
 563
 564 /* Returns current RX RSSI threshold value */
 565 int fm_rx_get_rssi_threshold(struct fmdev *fmdev, short *curr_rssi_lvl)
 566 {
 567         if (fmdev->curr_fmmode != FM_MODE_RX)
 568                 return -EPERM;
 569
 570         if (curr_rssi_lvl == NULL) {
 571                 fmerr("Invalid memory\n");
 572                 return -ENOMEM;
 573         }
 574
 575         *curr_rssi_lvl = fmdev->rx.rssi_threshold;
 576
 577         return 0;
 578 }
 579
 580 /* Sets RX stereo/mono modes */
 581 int fm_rx_set_stereo_mono(struct fmdev *fmdev, u16 mode)
 582 {
 583         u16 payload;
 584         int ret;
 585
 586         if (mode != FM_STEREO_MODE && mode != FM_MONO_MODE) {
 587                 fmerr("Invalid mode\n");
 588                 return -EINVAL;
 589         }
 590
 591         /* Set stereo/mono mode */
 592         payload = (u16)mode;
 593         ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_WR, &payload,
 594                         sizeof(payload), NULL, NULL);
 595         if (ret < 0)
 596                 return ret;
 597
 598         /* Set stereo blending mode */
 599         payload = FM_STEREO_SOFT_BLEND;
 600         ret = fmc_send_cmd(fmdev, MOST_BLEND_SET, REG_WR, &payload,
 601                         sizeof(payload), NULL, NULL);
 602         if (ret < 0)
 603                 return ret;
 604
 605         return 0;
 606 }
 607
 608 /* Gets current RX stereo/mono mode */
 609 int fm_rx_get_stereo_mono(struct fmdev *fmdev, u16 *mode)
 610 {
 611         __be16 curr_mode;
 612         u32 resp_len;
 613         int ret;
 614
 615         if (mode == NULL) {
 616                 fmerr("Invalid memory\n");
 617                 return -ENOMEM;
 618         }
 619
 620         ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_RD, NULL, 2,
 621                         &curr_mode, &resp_len);
 622         if (ret < 0)
 623                 return ret;
 624
 625         *mode = be16_to_cpu(curr_mode);
 626
 627         return 0;
 628 }
 629
 630 /* Choose RX de-emphasis filter mode (50us/75us) */
 631 int fm_rx_set_deemphasis_mode(struct fmdev *fmdev, u16 mode)
 632 {
 633         u16 payload;
 634         int ret;
 635
 636         if (fmdev->curr_fmmode != FM_MODE_RX)
 637                 return -EPERM;
 638
 639         if (mode != FM_RX_EMPHASIS_FILTER_50_USEC &&
 640                         mode != FM_RX_EMPHASIS_FILTER_75_USEC) {
 641                 fmerr("Invalid rx de-emphasis mode (%d)\n", mode);
 642                 return -EINVAL;
 643         }
 644
 645         payload = mode;
 646         ret = fmc_send_cmd(fmdev, DEMPH_MODE_SET, REG_WR, &payload,
 647                         sizeof(payload), NULL, NULL);
 648         if (ret < 0)
 649                 return ret;
 650
 651         fmdev->rx.deemphasis_mode = mode;
 652
 653         return 0;
 654 }
 655
 656 /* Gets current RX de-emphasis filter mode */
 657 int fm_rx_get_deemph_mode(struct fmdev *fmdev, u16 *curr_deemphasis_mode)
 658 {
 659         if (fmdev->curr_fmmode != FM_MODE_RX)
 660                 return -EPERM;
 661
 662         if (curr_deemphasis_mode == NULL) {
 663                 fmerr("Invalid memory\n");
 664                 return -ENOMEM;
 665         }
 666
 667         *curr_deemphasis_mode = fmdev->rx.deemphasis_mode;
 668
 669         return 0;
 670 }
 671
 672 /* Enable/Disable RX RDS */
 673 int fm_rx_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis)
 674 {
 675         u16 payload;
 676         int ret;
 677
 678         if (rds_en_dis != FM_RDS_ENABLE && rds_en_dis != FM_RDS_DISABLE) {
 679                 fmerr("Invalid rds option\n");
 680                 return -EINVAL;
 681         }
 682
 683         if (rds_en_dis == FM_RDS_ENABLE
 684             && fmdev->rx.rds.flag == FM_RDS_DISABLE) {
 685                 /* Turn on RX RDS and RDS circuit */
 686                 payload = FM_RX_PWR_SET_FM_AND_RDS_BLK_ON;
 687                 ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
 688                                 sizeof(payload), NULL, NULL);
 689                 if (ret < 0)
 690                         return ret;
 691
 692                 /* Clear and reset RDS FIFO */
 693                 payload = FM_RX_RDS_FLUSH_FIFO;
 694                 ret = fmc_send_cmd(fmdev, RDS_CNTRL_SET, REG_WR, &payload,
 695                 sizeof(payload), NULL, NULL);
 696                 if (ret < 0)
 697                         return ret;
 698
 699                 /* Read flags - just to clear any pending interrupts. */
 700                 ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2,
 701                                 NULL, NULL);
 702                 if (ret < 0)
 703                         return ret;
 704
 705                 /* Set RDS FIFO threshold value */
 706                 payload = FM_RX_RDS_FIFO_THRESHOLD;
 707                 ret = fmc_send_cmd(fmdev, RDS_MEM_SET, REG_WR, &payload,
 708                 sizeof(payload), NULL, NULL);
 709                 if (ret < 0)
 710                         return ret;
 711
 712                 /* Enable RDS interrupt */
 713                 fmdev->irq_info.mask |= FM_RDS_EVENT;
 714                 payload = fmdev->irq_info.mask;
 715                 ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
 716                                 sizeof(payload), NULL, NULL);
 717                 if (ret < 0) {
 718                         fmdev->irq_info.mask &= ~FM_RDS_EVENT;
 719                         return ret;
 720                 }
 721
 722                 /* Update our local flag */
 723                 fmdev->rx.rds.flag = FM_RDS_ENABLE;
 724         } else if (rds_en_dis == FM_RDS_DISABLE
 725                    && fmdev->rx.rds.flag == FM_RDS_ENABLE) {
 726                 /* Turn off RX RDS */
 727                 payload = FM_RX_PWR_SET_FM_ON_RDS_OFF;
 728                 ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
 729                                 sizeof(payload), NULL, NULL);
 730                 if (ret < 0)
 731                         return ret;
 732
 733                 /* Reset RDS pointers */
 734                 fmdev->rx.rds.last_blk_idx = 0;
 735                 fmdev->rx.rds.wr_idx = 0;
 736                 fmdev->rx.rds.rd_idx = 0;
 737                 fm_rx_reset_station_info(fmdev);
 738
 739                 /* Update RDS local cache */
 740                 fmdev->irq_info.mask &= ~(FM_RDS_EVENT);
 741                 fmdev->rx.rds.flag = FM_RDS_DISABLE;
 742         }
 743
 744         return 0;
 745 }
 746
 747 /* Returns current RX RDS enable/disable status */
 748 int fm_rx_get_rds_mode(struct fmdev *fmdev, u8 *curr_rds_en_dis)
 749 {
 750         if (fmdev->curr_fmmode != FM_MODE_RX)
 751                 return -EPERM;
 752
 753         if (curr_rds_en_dis == NULL) {
 754                 fmerr("Invalid memory\n");
 755                 return -ENOMEM;
 756         }
 757
 758         *curr_rds_en_dis = fmdev->rx.rds.flag;
 759
 760         return 0;
 761 }
 762
 763 /* Sets RDS operation mode (RDS/RDBS) */
 764 int fm_rx_set_rds_system(struct fmdev *fmdev, u8 rds_mode)
 765 {
 766         u16 payload;
 767         int ret;
 768
 769         if (fmdev->curr_fmmode != FM_MODE_RX)
 770                 return -EPERM;
 771
 772         if (rds_mode != FM_RDS_SYSTEM_RDS && rds_mode != FM_RDS_SYSTEM_RBDS) {
 773                 fmerr("Invalid rds mode\n");
 774                 return -EINVAL;
 775         }
 776         /* Set RDS operation mode */
 777         payload = (u16)rds_mode;
 778         ret = fmc_send_cmd(fmdev, RDS_SYSTEM_SET, REG_WR, &payload,
 779                         sizeof(payload), NULL, NULL);
 780         if (ret < 0)
 781                 return ret;
 782
 783         fmdev->rx.rds_mode = rds_mode;
 784
 785         return 0;
 786 }
 787
 788 /* Configures Alternate Frequency switch mode */
 789 int fm_rx_set_af_switch(struct fmdev *fmdev, u8 af_mode)
 790 {
 791         u16 payload;
 792         int ret;
 793
 794         if (fmdev->curr_fmmode != FM_MODE_RX)
 795                 return -EPERM;
 796
 797         if (af_mode != FM_RX_RDS_AF_SWITCH_MODE_ON &&
 798             af_mode != FM_RX_RDS_AF_SWITCH_MODE_OFF) {
 799                 fmerr("Invalid af mode\n");
 800                 return -EINVAL;
 801         }
 802         /* Enable/disable low RSSI interrupt based on af_mode */
 803         if (af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
 804                 fmdev->irq_info.mask |= FM_LEV_EVENT;
 805         else
 806                 fmdev->irq_info.mask &= ~FM_LEV_EVENT;
 807
 808         payload = fmdev->irq_info.mask;
 809         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
 810                         sizeof(payload), NULL, NULL);
 811         if (ret < 0)
 812                 return ret;
 813
 814         fmdev->rx.af_mode = af_mode;
 815
 816         return 0;
 817 }
 818
 819 /* Returns Alternate Frequency switch status */
 820 int fm_rx_get_af_switch(struct fmdev *fmdev, u8 *af_mode)
 821 {
 822         if (fmdev->curr_fmmode != FM_MODE_RX)
 823                 return -EPERM;
 824
 825         if (af_mode == NULL) {
 826                 fmerr("Invalid memory\n");
 827                 return -ENOMEM;
 828         }
 829
 830         *af_mode = fmdev->rx.af_mode;
 831
 832         return 0;
 833 }