drivers/media/radio/radio-wl1273.c

   1 /*
   2  * Driver for the Texas Instruments WL1273 FM radio.
   3  *
   4  * Copyright (C) 2011 Nokia Corporation
   5  * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * version 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  */
  20
  21 #include <linux/delay.h>
  22 #include <linux/firmware.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/mfd/wl1273-core.h>
  25 #include <linux/slab.h>
  26 #include <media/v4l2-common.h>
  27 #include <media/v4l2-ctrls.h>
  28 #include <media/v4l2-device.h>
  29 #include <media/v4l2-ioctl.h>
  30
  31 #define DRIVER_DESC "Wl1273 FM Radio"
  32
  33 #define WL1273_POWER_SET_OFF            0
  34 #define WL1273_POWER_SET_FM             BIT(0)
  35 #define WL1273_POWER_SET_RDS            BIT(1)
  36 #define WL1273_POWER_SET_RETENTION      BIT(4)
  37
  38 #define WL1273_PUPD_SET_OFF             0x00
  39 #define WL1273_PUPD_SET_ON              0x01
  40 #define WL1273_PUPD_SET_RETENTION       0x10
  41
  42 #define WL1273_FREQ(x)          (x * 10000 / 625)
  43 #define WL1273_INV_FREQ(x)      (x * 625 / 10000)
  44
  45 /*
  46  * static int radio_nr - The number of the radio device
  47  *
  48  * The default is 0.
  49  */
  50 static int radio_nr;
  51 module_param(radio_nr, int, 0);
  52 MODULE_PARM_DESC(radio_nr, "The number of the radio device. Default = 0");
  53
  54 struct wl1273_device {
  55         char *bus_type;
  56
  57         u8 forbidden;
  58         unsigned int preemphasis;
  59         unsigned int spacing;
  60         unsigned int tx_power;
  61         unsigned int rx_frequency;
  62         unsigned int tx_frequency;
  63         unsigned int rangelow;
  64         unsigned int rangehigh;
  65         unsigned int band;
  66         bool stereo;
  67
  68         /* RDS */
  69         unsigned int rds_on;
  70
  71         wait_queue_head_t read_queue;
  72         struct mutex lock; /* for serializing fm radio operations */
  73         struct completion busy;
  74
  75         unsigned char *buffer;
  76         unsigned int buf_size;
  77         unsigned int rd_index;
  78         unsigned int wr_index;
  79
  80         /* Selected interrupts */
  81         u16 irq_flags;
  82         u16 irq_received;
  83
  84         struct v4l2_ctrl_handler ctrl_handler;
  85         struct v4l2_device v4l2dev;
  86         struct video_device videodev;
  87         struct device *dev;
  88         struct wl1273_core *core;
  89         struct file *owner;
  90         char *write_buf;
  91         unsigned int rds_users;
  92 };
  93
  94 #define WL1273_IRQ_MASK  (WL1273_FR_EVENT               |       \
  95                           WL1273_POW_ENB_EVENT)
  96
  97 /*
  98  * static unsigned int rds_buf - the number of RDS buffer blocks used.
  99  *
 100  * The default number is 100.
 101  */
 102 static unsigned int rds_buf = 100;
 103 module_param(rds_buf, uint, 0);
 104 MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100");
 105
 106 static int wl1273_fm_write_fw(struct wl1273_core *core,
 107                               __u8 *fw, int len)
 108 {
 109         struct i2c_client *client = core->client;
 110         struct i2c_msg msg;
 111         int i, r = 0;
 112
 113         msg.addr = client->addr;
 114         msg.flags = 0;
 115
 116         for (i = 0; i <= len; i++) {
 117                 msg.len = fw[0];
 118                 msg.buf = fw + 1;
 119
 120                 fw += msg.len + 1;
 121                 dev_dbg(&client->dev, "%s:len[%d]: %d\n", __func__, i, msg.len);
 122
 123                 r = i2c_transfer(client->adapter, &msg, 1);
 124                 if (r < 0 && i < len + 1)
 125                         break;
 126         }
 127
 128         dev_dbg(&client->dev, "%s: i: %d\n", __func__, i);
 129         dev_dbg(&client->dev, "%s: len + 1: %d\n", __func__, len + 1);
 130
 131         /* Last transfer always fails. */
 132         if (i == len || r == 1)
 133                 r = 0;
 134
 135         return r;
 136 }
 137
 138 #define WL1273_FIFO_HAS_DATA(status)    (1 << 5 & status)
 139 #define WL1273_RDS_CORRECTABLE_ERROR    (1 << 3)
 140 #define WL1273_RDS_UNCORRECTABLE_ERROR  (1 << 4)
 141
 142 static int wl1273_fm_rds(struct wl1273_device *radio)
 143 {
 144         struct wl1273_core *core = radio->core;
 145         struct i2c_client *client = core->client;
 146         u16 val;
 147         u8 b0 = WL1273_RDS_DATA_GET, status;
 148         struct v4l2_rds_data rds = { 0, 0, 0 };
 149         struct i2c_msg msg[] = {
 150                 {
 151                         .addr = client->addr,
 152                         .flags = 0,
 153                         .buf = &b0,
 154                         .len = 1,
 155                 },
 156                 {
 157                         .addr = client->addr,
 158                         .flags = I2C_M_RD,
 159                         .buf = (u8 *) &rds,
 160                         .len = sizeof(rds),
 161                 }
 162         };
 163         int r;
 164
 165         if (core->mode != WL1273_MODE_RX)
 166                 return 0;
 167
 168         r = core->read(core, WL1273_RDS_SYNC_GET, &val);
 169         if (r)
 170                 return r;
 171
 172         if ((val & 0x01) == 0) {
 173                 /* RDS decoder not synchronized */
 174                 return -EAGAIN;
 175         }
 176
 177         /* copy all four RDS blocks to internal buffer */
 178         do {
 179                 r = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
 180                 if (r != ARRAY_SIZE(msg)) {
 181                         dev_err(radio->dev, WL1273_FM_DRIVER_NAME
 182                                 ": %s: read_rds error r == %i)\n",
 183                                 __func__, r);
 184                 }
 185
 186                 status = rds.block;
 187
 188                 if (!WL1273_FIFO_HAS_DATA(status))
 189                         break;
 190
 191                 /* copy bits 0-2 (the block ID) to bits 3-5 */
 192                 rds.block = V4L2_RDS_BLOCK_MSK & status;
 193                 rds.block |= rds.block << 3;
 194
 195                 /* copy the error bits to standard positions */
 196                 if (WL1273_RDS_UNCORRECTABLE_ERROR & status) {
 197                         rds.block |= V4L2_RDS_BLOCK_ERROR;
 198                         rds.block &= ~V4L2_RDS_BLOCK_CORRECTED;
 199                 } else if  (WL1273_RDS_CORRECTABLE_ERROR & status) {
 200                         rds.block &= ~V4L2_RDS_BLOCK_ERROR;
 201                         rds.block |= V4L2_RDS_BLOCK_CORRECTED;
 202                 }
 203
 204                 /* copy RDS block to internal buffer */
 205                 memcpy(&radio->buffer[radio->wr_index], &rds, RDS_BLOCK_SIZE);
 206                 radio->wr_index += 3;
 207
 208                 /* wrap write pointer */
 209                 if (radio->wr_index >= radio->buf_size)
 210                         radio->wr_index = 0;
 211
 212                 /* check for overflow & start over */
 213                 if (radio->wr_index == radio->rd_index) {
 214                         dev_dbg(radio->dev, "RDS OVERFLOW");
 215
 216                         radio->rd_index = 0;
 217                         radio->wr_index = 0;
 218                         break;
 219                 }
 220         } while (WL1273_FIFO_HAS_DATA(status));
 221
 222         /* wake up read queue */
 223         if (radio->wr_index != radio->rd_index)
 224                 wake_up_interruptible(&radio->read_queue);
 225
 226         return 0;
 227 }
 228
 229 static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id)
 230 {
 231         struct wl1273_device *radio = dev_id;
 232         struct wl1273_core *core = radio->core;
 233         u16 flags;
 234         int r;
 235
 236         r = core->read(core, WL1273_FLAG_GET, &flags);
 237         if (r)
 238                 goto out;
 239
 240         if (flags & WL1273_BL_EVENT) {
 241                 radio->irq_received = flags;
 242                 dev_dbg(radio->dev, "IRQ: BL\n");
 243         }
 244
 245         if (flags & WL1273_RDS_EVENT) {
 246                 msleep(200);
 247
 248                 wl1273_fm_rds(radio);
 249         }
 250
 251         if (flags & WL1273_BBLK_EVENT)
 252                 dev_dbg(radio->dev, "IRQ: BBLK\n");
 253
 254         if (flags & WL1273_LSYNC_EVENT)
 255                 dev_dbg(radio->dev, "IRQ: LSYNC\n");
 256
 257         if (flags & WL1273_LEV_EVENT) {
 258                 u16 level;
 259
 260                 r = core->read(core, WL1273_RSSI_LVL_GET, &level);
 261                 if (r)
 262                         goto out;
 263
 264                 if (level > 14)
 265                         dev_dbg(radio->dev, "IRQ: LEV: 0x%x04\n", level);
 266         }
 267
 268         if (flags & WL1273_IFFR_EVENT)
 269                 dev_dbg(radio->dev, "IRQ: IFFR\n");
 270
 271         if (flags & WL1273_PI_EVENT)
 272                 dev_dbg(radio->dev, "IRQ: PI\n");
 273
 274         if (flags & WL1273_PD_EVENT)
 275                 dev_dbg(radio->dev, "IRQ: PD\n");
 276
 277         if (flags & WL1273_STIC_EVENT)
 278                 dev_dbg(radio->dev, "IRQ: STIC\n");
 279
 280         if (flags & WL1273_MAL_EVENT)
 281                 dev_dbg(radio->dev, "IRQ: MAL\n");
 282
 283         if (flags & WL1273_POW_ENB_EVENT) {
 284                 complete(&radio->busy);
 285                 dev_dbg(radio->dev, "NOT BUSY\n");
 286                 dev_dbg(radio->dev, "IRQ: POW_ENB\n");
 287         }
 288
 289         if (flags & WL1273_SCAN_OVER_EVENT)
 290                 dev_dbg(radio->dev, "IRQ: SCAN_OVER\n");
 291
 292         if (flags & WL1273_ERROR_EVENT)
 293                 dev_dbg(radio->dev, "IRQ: ERROR\n");
 294
 295         if (flags & WL1273_FR_EVENT) {
 296                 u16 freq;
 297
 298                 dev_dbg(radio->dev, "IRQ: FR:\n");
 299
 300                 if (core->mode == WL1273_MODE_RX) {
 301                         r = core->write(core, WL1273_TUNER_MODE_SET,
 302                                         TUNER_MODE_STOP_SEARCH);
 303                         if (r) {
 304                                 dev_err(radio->dev,
 305                                         "%s: TUNER_MODE_SET fails: %d\n",
 306                                         __func__, r);
 307                                 goto out;
 308                         }
 309
 310                         r = core->read(core, WL1273_FREQ_SET, &freq);
 311                         if (r)
 312                                 goto out;
 313
 314                         if (radio->band == WL1273_BAND_JAPAN)
 315                                 radio->rx_frequency = WL1273_BAND_JAPAN_LOW +
 316                                         freq * 50;
 317                         else
 318                                 radio->rx_frequency = WL1273_BAND_OTHER_LOW +
 319                                         freq * 50;
 320                         /*
 321                          *  The driver works better with this msleep,
 322                          *  the documentation doesn't mention it.
 323                          */
 324                         usleep_range(10000, 15000);
 325
 326                         dev_dbg(radio->dev, "%dkHz\n", radio->rx_frequency);
 327
 328                 } else {
 329                         r = core->read(core, WL1273_CHANL_SET, &freq);
 330                         if (r)
 331                                 goto out;
 332
 333                         dev_dbg(radio->dev, "%dkHz\n", freq);
 334                 }
 335                 dev_dbg(radio->dev, "%s: NOT BUSY\n", __func__);
 336         }
 337
 338 out:
 339         core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
 340         complete(&radio->busy);
 341
 342         return IRQ_HANDLED;
 343 }
 344
 345 static int wl1273_fm_set_tx_freq(struct wl1273_device *radio, unsigned int freq)
 346 {
 347         struct wl1273_core *core = radio->core;
 348         int r = 0;
 349
 350         if (freq < WL1273_BAND_TX_LOW) {
 351                 dev_err(radio->dev,
 352                         "Frequency out of range: %d < %d\n", freq,
 353                         WL1273_BAND_TX_LOW);
 354                 return -ERANGE;
 355         }
 356
 357         if (freq > WL1273_BAND_TX_HIGH) {
 358                 dev_err(radio->dev,
 359                         "Frequency out of range: %d > %d\n", freq,
 360                         WL1273_BAND_TX_HIGH);
 361                 return -ERANGE;
 362         }
 363
 364         /*
 365          *  The driver works better with this sleep,
 366          *  the documentation doesn't mention it.
 367          */
 368         usleep_range(5000, 10000);
 369
 370         dev_dbg(radio->dev, "%s: freq: %d kHz\n", __func__, freq);
 371
 372         /* Set the current tx channel */
 373         r = core->write(core, WL1273_CHANL_SET, freq / 10);
 374         if (r)
 375                 return r;
 376
 377         INIT_COMPLETION(radio->busy);
 378
 379         /* wait for the FR IRQ */
 380         r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
 381         if (!r)
 382                 return -ETIMEDOUT;
 383
 384         dev_dbg(radio->dev, "WL1273_CHANL_SET: %d\n", r);
 385
 386         /* Enable the output power */
 387         r = core->write(core, WL1273_POWER_ENB_SET, 1);
 388         if (r)
 389                 return r;
 390
 391         INIT_COMPLETION(radio->busy);
 392
 393         /* wait for the POWER_ENB IRQ */
 394         r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
 395         if (!r)
 396                 return -ETIMEDOUT;
 397
 398         radio->tx_frequency = freq;
 399         dev_dbg(radio->dev, "WL1273_POWER_ENB_SET: %d\n", r);
 400
 401         return  0;
 402 }
 403
 404 static int wl1273_fm_set_rx_freq(struct wl1273_device *radio, unsigned int freq)
 405 {
 406         struct wl1273_core *core = radio->core;
 407         int r, f;
 408
 409         if (freq < radio->rangelow) {
 410                 dev_err(radio->dev,
 411                         "Frequency out of range: %d < %d\n", freq,
 412                         radio->rangelow);
 413                 r = -ERANGE;
 414                 goto err;
 415         }
 416
 417         if (freq > radio->rangehigh) {
 418                 dev_err(radio->dev,
 419                         "Frequency out of range: %d > %d\n", freq,
 420                         radio->rangehigh);
 421                 r = -ERANGE;
 422                 goto err;
 423         }
 424
 425         dev_dbg(radio->dev, "%s: %dkHz\n", __func__, freq);
 426
 427         core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
 428
 429         if (radio->band == WL1273_BAND_JAPAN)
 430                 f = (freq - WL1273_BAND_JAPAN_LOW) / 50;
 431         else
 432                 f = (freq - WL1273_BAND_OTHER_LOW) / 50;
 433
 434         r = core->write(core, WL1273_FREQ_SET, f);
 435         if (r) {
 436                 dev_err(radio->dev, "FREQ_SET fails\n");
 437                 goto err;
 438         }
 439
 440         r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET);
 441         if (r) {
 442                 dev_err(radio->dev, "TUNER_MODE_SET fails\n");
 443                 goto err;
 444         }
 445
 446         INIT_COMPLETION(radio->busy);
 447
 448         r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
 449         if (!r) {
 450                 dev_err(radio->dev, "%s: TIMEOUT\n", __func__);
 451                 return -ETIMEDOUT;
 452         }
 453
 454         radio->rd_index = 0;
 455         radio->wr_index = 0;
 456         radio->rx_frequency = freq;
 457         return 0;
 458 err:
 459         return r;
 460 }
 461
 462 static int wl1273_fm_get_freq(struct wl1273_device *radio)
 463 {
 464         struct wl1273_core *core = radio->core;
 465         unsigned int freq;
 466         u16 f;
 467         int r;
 468
 469         if (core->mode == WL1273_MODE_RX) {
 470                 r = core->read(core, WL1273_FREQ_SET, &f);
 471                 if (r)
 472                         return r;
 473
 474                 dev_dbg(radio->dev, "Freq get: 0x%04x\n", f);
 475                 if (radio->band == WL1273_BAND_JAPAN)
 476                         freq = WL1273_BAND_JAPAN_LOW + 50 * f;
 477                 else
 478                         freq = WL1273_BAND_OTHER_LOW + 50 * f;
 479         } else {
 480                 r = core->read(core, WL1273_CHANL_SET, &f);
 481                 if (r)
 482                         return r;
 483
 484                 freq = f * 10;
 485         }
 486
 487         return freq;
 488 }
 489
 490 /**
 491  * wl1273_fm_upload_firmware_patch() -  Upload the firmware.
 492  * @radio:                              A pointer to the device struct.
 493  *
 494  * The firmware file consists of arrays of bytes where the first byte
 495  * gives the array length. The first byte in the file gives the
 496  * number of these arrays.
 497  */
 498 static int wl1273_fm_upload_firmware_patch(struct wl1273_device *radio)
 499 {
 500         struct wl1273_core *core = radio->core;
 501         unsigned int packet_num;
 502         const struct firmware *fw_p;
 503         const char *fw_name = "radio-wl1273-fw.bin";
 504         struct device *dev = radio->dev;
 505         __u8 *ptr;
 506         int r;
 507
 508         dev_dbg(dev, "%s:\n", __func__);
 509
 510         /*
 511          * Uploading the firmware patch is not always necessary,
 512          * so we only print an info message.
 513          */
 514         if (request_firmware(&fw_p, fw_name, dev)) {
 515                 dev_info(dev, "%s - %s not found\n", __func__, fw_name);
 516
 517                 return 0;
 518         }
 519
 520         ptr = (__u8 *) fw_p->data;
 521         packet_num = ptr[0];
 522         dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num);
 523
 524         r = wl1273_fm_write_fw(core, ptr + 1, packet_num);
 525         if (r) {
 526                 dev_err(dev, "FW upload error: %d\n", r);
 527                 goto out;
 528         }
 529
 530         /* ignore possible error here */
 531         core->write(core, WL1273_RESET, 0);
 532
 533         dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r);
 534 out:
 535         release_firmware(fw_p);
 536         return r;
 537 }
 538
 539 static int wl1273_fm_stop(struct wl1273_device *radio)
 540 {
 541         struct wl1273_core *core = radio->core;
 542
 543         if (core->mode == WL1273_MODE_RX) {
 544                 int r = core->write(core, WL1273_POWER_SET,
 545                                     WL1273_POWER_SET_OFF);
 546                 if (r)
 547                         dev_err(radio->dev, "%s: POWER_SET fails: %d\n",
 548                                 __func__, r);
 549         } else if (core->mode == WL1273_MODE_TX) {
 550                 int r = core->write(core, WL1273_PUPD_SET,
 551                                     WL1273_PUPD_SET_OFF);
 552                 if (r)
 553                         dev_err(radio->dev,
 554                                 "%s: PUPD_SET fails: %d\n", __func__, r);
 555         }
 556
 557         if (core->pdata->disable) {
 558                 core->pdata->disable();
 559                 dev_dbg(radio->dev, "Back to reset\n");
 560         }
 561
 562         return 0;
 563 }
 564
 565 static int wl1273_fm_start(struct wl1273_device *radio, int new_mode)
 566 {
 567         struct wl1273_core *core = radio->core;
 568         struct wl1273_fm_platform_data *pdata = core->pdata;
 569         struct device *dev = radio->dev;
 570         int r = -EINVAL;
 571
 572         if (pdata->enable && core->mode == WL1273_MODE_OFF) {
 573                 dev_dbg(radio->dev, "Out of reset\n");
 574
 575                 pdata->enable();
 576                 msleep(250);
 577         }
 578
 579         if (new_mode == WL1273_MODE_RX) {
 580                 u16 val = WL1273_POWER_SET_FM;
 581
 582                 if (radio->rds_on)
 583                         val |= WL1273_POWER_SET_RDS;
 584
 585                 /* If this fails try again */
 586                 r = core->write(core, WL1273_POWER_SET, val);
 587                 if (r) {
 588                         msleep(100);
 589
 590                         r = core->write(core, WL1273_POWER_SET, val);
 591                         if (r) {
 592                                 dev_err(dev, "%s: POWER_SET fails\n", __func__);
 593                                 goto fail;
 594                         }
 595                 }
 596
 597                 /* rds buffer configuration */
 598                 radio->wr_index = 0;
 599                 radio->rd_index = 0;
 600
 601         } else if (new_mode == WL1273_MODE_TX) {
 602                 /* If this fails try again once */
 603                 r = core->write(core, WL1273_PUPD_SET, WL1273_PUPD_SET_ON);
 604                 if (r) {
 605                         msleep(100);
 606                         r = core->write(core, WL1273_PUPD_SET,
 607                                         WL1273_PUPD_SET_ON);
 608                         if (r) {
 609                                 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
 610                                 goto fail;
 611                         }
 612                 }
 613
 614                 if (radio->rds_on)
 615                         r = core->write(core, WL1273_RDS_DATA_ENB, 1);
 616                 else
 617                         r = core->write(core, WL1273_RDS_DATA_ENB, 0);
 618         } else {
 619                 dev_warn(dev, "%s: Illegal mode.\n", __func__);
 620         }
 621
 622         if (core->mode == WL1273_MODE_OFF) {
 623                 r = wl1273_fm_upload_firmware_patch(radio);
 624                 if (r)
 625                         dev_warn(dev, "Firmware upload failed.\n");
 626
 627                 /*
 628                  * Sometimes the chip is in a wrong power state at this point.
 629                  * So we set the power once again.
 630                  */
 631                 if (new_mode == WL1273_MODE_RX) {
 632                         u16 val = WL1273_POWER_SET_FM;
 633
 634                         if (radio->rds_on)
 635                                 val |= WL1273_POWER_SET_RDS;
 636
 637                         r = core->write(core, WL1273_POWER_SET, val);
 638                         if (r) {
 639                                 dev_err(dev, "%s: POWER_SET fails\n", __func__);
 640                                 goto fail;
 641                         }
 642                 } else if (new_mode == WL1273_MODE_TX) {
 643                         r = core->write(core, WL1273_PUPD_SET,
 644                                         WL1273_PUPD_SET_ON);
 645                         if (r) {
 646                                 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
 647                                 goto fail;
 648                         }
 649                 }
 650         }
 651
 652         return 0;
 653 fail:
 654         if (pdata->disable)
 655                 pdata->disable();
 656
 657         dev_dbg(dev, "%s: return: %d\n", __func__, r);
 658         return r;
 659 }
 660
 661 static int wl1273_fm_suspend(struct wl1273_device *radio)
 662 {
 663         struct wl1273_core *core = radio->core;
 664         int r = 0;
 665
 666         /* Cannot go from OFF to SUSPENDED */
 667         if (core->mode == WL1273_MODE_RX)
 668                 r = core->write(core, WL1273_POWER_SET,
 669                                 WL1273_POWER_SET_RETENTION);
 670         else if (core->mode == WL1273_MODE_TX)
 671                 r = core->write(core, WL1273_PUPD_SET,
 672                                 WL1273_PUPD_SET_RETENTION);
 673         else
 674                 r = -EINVAL;
 675
 676         if (r) {
 677                 dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r);
 678                 goto out;
 679         }
 680
 681 out:
 682         return r;
 683 }
 684
 685 static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode)
 686 {
 687         struct wl1273_core *core = radio->core;
 688         struct device *dev = radio->dev;
 689         int old_mode;
 690         int r;
 691
 692         dev_dbg(dev, "%s\n", __func__);
 693         dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden);
 694
 695         old_mode = core->mode;
 696         if (mode & radio->forbidden) {
 697                 r = -EPERM;
 698                 goto out;
 699         }
 700
 701         switch (mode) {
 702         case WL1273_MODE_RX:
 703         case WL1273_MODE_TX:
 704                 r = wl1273_fm_start(radio, mode);
 705                 if (r) {
 706                         dev_err(dev, "%s: Cannot start.\n", __func__);
 707                         wl1273_fm_stop(radio);
 708                         goto out;
 709                 }
 710
 711                 core->mode = mode;
 712                 r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
 713                 if (r) {
 714                         dev_err(dev, "INT_MASK_SET fails.\n");
 715                         goto out;
 716                 }
 717
 718                 /* remember previous settings */
 719                 if (mode == WL1273_MODE_RX) {
 720                         r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
 721                         if (r) {
 722                                 dev_err(dev, "set freq fails: %d.\n", r);
 723                                 goto out;
 724                         }
 725
 726                         r = core->set_volume(core, core->volume);
 727                         if (r) {
 728                                 dev_err(dev, "set volume fails: %d.\n", r);
 729                                 goto out;
 730                         }
 731
 732                         dev_dbg(dev, "%s: Set vol: %d.\n", __func__,
 733                                 core->volume);
 734                 } else {
 735                         r = wl1273_fm_set_tx_freq(radio, radio->tx_frequency);
 736                         if (r) {
 737                                 dev_err(dev, "set freq fails: %d.\n", r);
 738                                 goto out;
 739                         }
 740                 }
 741
 742                 dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__);
 743
 744                 r = core->set_audio(core, core->audio_mode);
 745                 if (r)
 746                         dev_err(dev, "Cannot set audio mode.\n");
 747                 break;
 748
 749         case WL1273_MODE_OFF:
 750                 r = wl1273_fm_stop(radio);
 751                 if (r)
 752                         dev_err(dev, "%s: Off fails: %d\n", __func__, r);
 753                 else
 754                         core->mode = WL1273_MODE_OFF;
 755
 756                 break;
 757
 758         case WL1273_MODE_SUSPENDED:
 759                 r = wl1273_fm_suspend(radio);
 760                 if (r)
 761                         dev_err(dev, "%s: Suspend fails: %d\n", __func__, r);
 762                 else
 763                         core->mode = WL1273_MODE_SUSPENDED;
 764
 765                 break;
 766
 767         default:
 768                 dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode);
 769                 r = -EINVAL;
 770                 break;
 771         }
 772 out:
 773         if (r)
 774                 core->mode = old_mode;
 775
 776         return r;
 777 }
 778
 779 static int wl1273_fm_set_seek(struct wl1273_device *radio,
 780                               unsigned int wrap_around,
 781                               unsigned int seek_upward,
 782                               int level)
 783 {
 784         struct wl1273_core *core = radio->core;
 785         int r = 0;
 786         unsigned int dir = (seek_upward == 0) ? 0 : 1;
 787         unsigned int f;
 788
 789         f = radio->rx_frequency;
 790         dev_dbg(radio->dev, "rx_frequency: %d\n", f);
 791
 792         if (dir && f + radio->spacing <= radio->rangehigh)
 793                 r = wl1273_fm_set_rx_freq(radio, f + radio->spacing);
 794         else if (dir && wrap_around)
 795                 r = wl1273_fm_set_rx_freq(radio, radio->rangelow);
 796         else if (f - radio->spacing >= radio->rangelow)
 797                 r = wl1273_fm_set_rx_freq(radio, f - radio->spacing);
 798         else if (wrap_around)
 799                 r = wl1273_fm_set_rx_freq(radio, radio->rangehigh);
 800
 801         if (r)
 802                 goto out;
 803
 804         if (level < SCHAR_MIN || level > SCHAR_MAX)
 805                 return -EINVAL;
 806
 807         INIT_COMPLETION(radio->busy);
 808         dev_dbg(radio->dev, "%s: BUSY\n", __func__);
 809
 810         r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
 811         if (r)
 812                 goto out;
 813
 814         dev_dbg(radio->dev, "%s\n", __func__);
 815
 816         r = core->write(core, WL1273_SEARCH_LVL_SET, level);
 817         if (r)
 818                 goto out;
 819
 820         r = core->write(core, WL1273_SEARCH_DIR_SET, dir);
 821         if (r)
 822                 goto out;
 823
 824         r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
 825         if (r)
 826                 goto out;
 827
 828         wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
 829         if (!(radio->irq_received & WL1273_BL_EVENT))
 830                 goto out;
 831
 832         radio->irq_received &= ~WL1273_BL_EVENT;
 833
 834         if (!wrap_around)
 835                 goto out;
 836
 837         /* Wrap around */
 838         dev_dbg(radio->dev, "Wrap around in HW seek.\n");
 839
 840         if (seek_upward)
 841                 f = radio->rangelow;
 842         else
 843                 f = radio->rangehigh;
 844
 845         r = wl1273_fm_set_rx_freq(radio, f);
 846         if (r)
 847                 goto out;
 848
 849         INIT_COMPLETION(radio->busy);
 850         dev_dbg(radio->dev, "%s: BUSY\n", __func__);
 851
 852         r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK);
 853         if (r)
 854                 goto out;
 855
 856         wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
 857 out:
 858         dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r);
 859         return r;
 860 }
 861
 862 /**
 863  * wl1273_fm_get_tx_ctune() -   Get the TX tuning capacitor value.
 864  * @radio:                      A pointer to the device struct.
 865  */
 866 static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio)
 867 {
 868         struct wl1273_core *core = radio->core;
 869         struct device *dev = radio->dev;
 870         u16 val;
 871         int r;
 872
 873         if (core->mode == WL1273_MODE_OFF ||
 874             core->mode == WL1273_MODE_SUSPENDED)
 875                 return -EPERM;
 876
 877         r = core->read(core, WL1273_READ_FMANT_TUNE_VALUE, &val);
 878         if (r) {
 879                 dev_err(dev, "%s: read error: %d\n", __func__, r);
 880                 goto out;
 881         }
 882
 883 out:
 884         return val;
 885 }
 886
 887 /**
 888  * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
 889  * @radio:                       A pointer to the device struct.
 890  * @preemphasis:                 The new pre-amphasis value.
 891  *
 892  * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
 893  * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
 894  */
 895 static int wl1273_fm_set_preemphasis(struct wl1273_device *radio,
 896                                      unsigned int preemphasis)
 897 {
 898         struct wl1273_core *core = radio->core;
 899         int r;
 900         u16 em;
 901
 902         if (core->mode == WL1273_MODE_OFF ||
 903             core->mode == WL1273_MODE_SUSPENDED)
 904                 return -EPERM;
 905
 906         mutex_lock(&core->lock);
 907
 908         switch (preemphasis) {
 909         case V4L2_PREEMPHASIS_DISABLED:
 910                 em = 1;
 911                 break;
 912         case V4L2_PREEMPHASIS_50_uS:
 913                 em = 0;
 914                 break;
 915         case V4L2_PREEMPHASIS_75_uS:
 916                 em = 2;
 917                 break;
 918         default:
 919                 r = -EINVAL;
 920                 goto out;
 921         }
 922
 923         r = core->write(core, WL1273_PREMPH_SET, em);
 924         if (r)
 925                 goto out;
 926
 927         radio->preemphasis = preemphasis;
 928
 929 out:
 930         mutex_unlock(&core->lock);
 931         return r;
 932 }
 933
 934 static int wl1273_fm_rds_on(struct wl1273_device *radio)
 935 {
 936         struct wl1273_core *core = radio->core;
 937         int r;
 938
 939         dev_dbg(radio->dev, "%s\n", __func__);
 940         if (radio->rds_on)
 941                 return 0;
 942
 943         r = core->write(core, WL1273_POWER_SET,
 944                         WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS);
 945         if (r)
 946                 goto out;
 947
 948         r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
 949         if (r)
 950                 dev_err(radio->dev, "set freq fails: %d.\n", r);
 951 out:
 952         return r;
 953 }
 954
 955 static int wl1273_fm_rds_off(struct wl1273_device *radio)
 956 {
 957         struct wl1273_core *core = radio->core;
 958         int r;
 959
 960         if (!radio->rds_on)
 961                 return 0;
 962
 963         radio->irq_flags &= ~WL1273_RDS_EVENT;
 964
 965         r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags);
 966         if (r)
 967                 goto out;
 968
 969         /* Service pending read */
 970         wake_up_interruptible(&radio->read_queue);
 971
 972         dev_dbg(radio->dev, "%s\n", __func__);
 973
 974         r = core->write(core, WL1273_POWER_SET, WL1273_POWER_SET_FM);
 975         if (r)
 976                 goto out;
 977
 978         r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
 979         if (r)
 980                 dev_err(radio->dev, "set freq fails: %d.\n", r);
 981 out:
 982         dev_dbg(radio->dev, "%s: exiting...\n", __func__);
 983
 984         return r;
 985 }
 986
 987 static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode)
 988 {
 989         int r = 0;
 990         struct wl1273_core *core = radio->core;
 991
 992         if (core->mode == WL1273_MODE_OFF ||
 993             core->mode == WL1273_MODE_SUSPENDED)
 994                 return -EPERM;
 995
 996         if (new_mode == WL1273_RDS_RESET) {
 997                 r = core->write(core, WL1273_RDS_CNTRL_SET, 1);
 998                 return r;
 999         }
1000
1001         if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) {
1002                 r = core->write(core, WL1273_RDS_DATA_ENB, 0);
1003         } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) {
1004                 r = core->write(core, WL1273_RDS_DATA_ENB, 1);
1005         } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) {
1006                 r = wl1273_fm_rds_off(radio);
1007         } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) {
1008                 r = wl1273_fm_rds_on(radio);
1009         } else {
1010                 dev_err(radio->dev, "%s: Unknown mode: %d\n",
1011                         __func__, new_mode);
1012                 r = -EINVAL;
1013         }
1014
1015         if (!r)
1016                 radio->rds_on = (new_mode == WL1273_RDS_ON) ? true : false;
1017
1018         return r;
1019 }
1020
1021 static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf,
1022                                     size_t count, loff_t *ppos)
1023 {
1024         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1025         struct wl1273_core *core = radio->core;
1026         u16 val;
1027         int r;
1028
1029         dev_dbg(radio->dev, "%s\n", __func__);
1030
1031         if (core->mode != WL1273_MODE_TX)
1032                 return count;
1033
1034         if (radio->rds_users == 0) {
1035                 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1036                 return 0;
1037         }
1038
1039         if (mutex_lock_interruptible(&core->lock))
1040                 return -EINTR;
1041         /*
1042          * Multiple processes can open the device, but only
1043          * one gets to write to it.
1044          */
1045         if (radio->owner && radio->owner != file) {
1046                 r = -EBUSY;
1047                 goto out;
1048         }
1049         radio->owner = file;
1050
1051         /* Manual Mode */
1052         if (count > 255)
1053                 val = 255;
1054         else
1055                 val = count;
1056
1057         core->write(core, WL1273_RDS_CONFIG_DATA_SET, val);
1058
1059         if (copy_from_user(radio->write_buf + 1, buf, val)) {
1060                 r = -EFAULT;
1061                 goto out;
1062         }
1063
1064         dev_dbg(radio->dev, "Count: %d\n", val);
1065         dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf);
1066
1067         radio->write_buf[0] = WL1273_RDS_DATA_SET;
1068         core->write_data(core, radio->write_buf, val + 1);
1069
1070         r = val;
1071 out:
1072         mutex_unlock(&core->lock);
1073
1074         return r;
1075 }
1076
1077 static unsigned int wl1273_fm_fops_poll(struct file *file,
1078                                         struct poll_table_struct *pts)
1079 {
1080         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1081         struct wl1273_core *core = radio->core;
1082
1083         if (radio->owner && radio->owner != file)
1084                 return -EBUSY;
1085
1086         radio->owner = file;
1087
1088         if (core->mode == WL1273_MODE_RX) {
1089                 poll_wait(file, &radio->read_queue, pts);
1090
1091                 if (radio->rd_index != radio->wr_index)
1092                         return POLLIN | POLLRDNORM;
1093
1094         } else if (core->mode == WL1273_MODE_TX) {
1095                 return POLLOUT | POLLWRNORM;
1096         }
1097
1098         return 0;
1099 }
1100
1101 static int wl1273_fm_fops_open(struct file *file)
1102 {
1103         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1104         struct wl1273_core *core = radio->core;
1105         int r = 0;
1106
1107         dev_dbg(radio->dev, "%s\n", __func__);
1108
1109         if (core->mode == WL1273_MODE_RX && radio->rds_on &&
1110             !radio->rds_users) {
1111                 dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode);
1112
1113                 if (mutex_lock_interruptible(&core->lock))
1114                         return -EINTR;
1115
1116                 radio->irq_flags |= WL1273_RDS_EVENT;
1117
1118                 r = core->write(core, WL1273_INT_MASK_SET,
1119                                 radio->irq_flags);
1120                 if (r) {
1121                         mutex_unlock(&core->lock);
1122                         goto out;
1123                 }
1124
1125                 radio->rds_users++;
1126
1127                 mutex_unlock(&core->lock);
1128         }
1129 out:
1130         return r;
1131 }
1132
1133 static int wl1273_fm_fops_release(struct file *file)
1134 {
1135         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1136         struct wl1273_core *core = radio->core;
1137         int r = 0;
1138
1139         dev_dbg(radio->dev, "%s\n", __func__);
1140
1141         if (radio->rds_users > 0) {
1142                 radio->rds_users--;
1143                 if (radio->rds_users == 0) {
1144                         if (mutex_lock_interruptible(&core->lock))
1145                                 return -EINTR;
1146
1147                         radio->irq_flags &= ~WL1273_RDS_EVENT;
1148
1149                         if (core->mode == WL1273_MODE_RX) {
1150                                 r = core->write(core,
1151                                                 WL1273_INT_MASK_SET,
1152                                                 radio->irq_flags);
1153                                 if (r) {
1154                                         mutex_unlock(&core->lock);
1155                                         goto out;
1156                                 }
1157                         }
1158                         mutex_unlock(&core->lock);
1159                 }
1160         }
1161
1162         if (file == radio->owner)
1163                 radio->owner = NULL;
1164 out:
1165         return r;
1166 }
1167
1168 static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf,
1169                                    size_t count, loff_t *ppos)
1170 {
1171         int r = 0;
1172         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1173         struct wl1273_core *core = radio->core;
1174         unsigned int block_count = 0;
1175         u16 val;
1176
1177         dev_dbg(radio->dev, "%s\n", __func__);
1178
1179         if (core->mode != WL1273_MODE_RX)
1180                 return 0;
1181
1182         if (radio->rds_users == 0) {
1183                 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1184                 return 0;
1185         }
1186
1187         if (mutex_lock_interruptible(&core->lock))
1188                 return -EINTR;
1189
1190         /*
1191          * Multiple processes can open the device, but only
1192          * one at a time gets read access.
1193          */
1194         if (radio->owner && radio->owner != file) {
1195                 r = -EBUSY;
1196                 goto out;
1197         }
1198         radio->owner = file;
1199
1200         r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1201         if (r) {
1202                 dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__);
1203                 goto out;
1204         } else if (val == 0) {
1205                 dev_info(radio->dev, "RDS_SYNC: Not synchronized\n");
1206                 r = -ENODATA;
1207                 goto out;
1208         }
1209
1210         /* block if no new data available */
1211         while (radio->wr_index == radio->rd_index) {
1212                 if (file->f_flags & O_NONBLOCK) {
1213                         r = -EWOULDBLOCK;
1214                         goto out;
1215                 }
1216
1217                 dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__);
1218                 if (wait_event_interruptible(radio->read_queue,
1219                                              radio->wr_index !=
1220                                              radio->rd_index) < 0) {
1221                         r = -EINTR;
1222                         goto out;
1223                 }
1224         }
1225
1226         /* calculate block count from byte count */
1227         count /= RDS_BLOCK_SIZE;
1228
1229         /* copy RDS blocks from the internal buffer and to user buffer */
1230         while (block_count < count) {
1231                 if (radio->rd_index == radio->wr_index)
1232                         break;
1233
1234                 /* always transfer complete RDS blocks */
1235                 if (copy_to_user(buf, &radio->buffer[radio->rd_index],
1236                                  RDS_BLOCK_SIZE))
1237                         break;
1238
1239                 /* increment and wrap the read pointer */
1240                 radio->rd_index += RDS_BLOCK_SIZE;
1241                 if (radio->rd_index >= radio->buf_size)
1242                         radio->rd_index = 0;
1243
1244                 /* increment counters */
1245                 block_count++;
1246                 buf += RDS_BLOCK_SIZE;
1247                 r += RDS_BLOCK_SIZE;
1248         }
1249
1250 out:
1251         dev_dbg(radio->dev, "%s: exit\n", __func__);
1252         mutex_unlock(&core->lock);
1253
1254         return r;
1255 }
1256
1257 static const struct v4l2_file_operations wl1273_fops = {
1258         .owner          = THIS_MODULE,
1259         .read           = wl1273_fm_fops_read,
1260         .write          = wl1273_fm_fops_write,
1261         .poll           = wl1273_fm_fops_poll,
1262         .unlocked_ioctl = video_ioctl2,
1263         .open           = wl1273_fm_fops_open,
1264         .release        = wl1273_fm_fops_release,
1265 };
1266
1267 static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
1268                                      struct v4l2_capability *capability)
1269 {
1270         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1271
1272         dev_dbg(radio->dev, "%s\n", __func__);
1273
1274         strlcpy(capability->driver, WL1273_FM_DRIVER_NAME,
1275                 sizeof(capability->driver));
1276         strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio",
1277                 sizeof(capability->card));
1278         strlcpy(capability->bus_info, radio->bus_type,
1279                 sizeof(capability->bus_info));
1280
1281         capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
1282                 V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
1283                 V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
1284                 V4L2_CAP_RDS_OUTPUT;
1285
1286         return 0;
1287 }
1288
1289 static int wl1273_fm_vidioc_g_input(struct file *file, void *priv,
1290                                     unsigned int *i)
1291 {
1292         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1293
1294         dev_dbg(radio->dev, "%s\n", __func__);
1295
1296         *i = 0;
1297
1298         return 0;
1299 }
1300
1301 static int wl1273_fm_vidioc_s_input(struct file *file, void *priv,
1302                                     unsigned int i)
1303 {
1304         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1305
1306         dev_dbg(radio->dev, "%s\n", __func__);
1307
1308         if (i != 0)
1309                 return -EINVAL;
1310
1311         return 0;
1312 }
1313
1314 /**
1315  * wl1273_fm_set_tx_power() -   Set the transmission power value.
1316  * @core:                       A pointer to the device struct.
1317  * @power:                      The new power value.
1318  */
1319 static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power)
1320 {
1321         struct wl1273_core *core = radio->core;
1322         int r;
1323
1324         if (core->mode == WL1273_MODE_OFF ||
1325             core->mode == WL1273_MODE_SUSPENDED)
1326                 return -EPERM;
1327
1328         mutex_lock(&core->lock);
1329
1330         /* Convert the dBuV value to chip presentation */
1331         r = core->write(core, WL1273_POWER_LEV_SET, 122 - power);
1332         if (r)
1333                 goto out;
1334
1335         radio->tx_power = power;
1336
1337 out:
1338         mutex_unlock(&core->lock);
1339         return r;
1340 }
1341
1342 #define WL1273_SPACING_50kHz    1
1343 #define WL1273_SPACING_100kHz   2
1344 #define WL1273_SPACING_200kHz   4
1345
1346 static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio,
1347                                     unsigned int spacing)
1348 {
1349         struct wl1273_core *core = radio->core;
1350         int r;
1351
1352         if (spacing == 0) {
1353                 r = core->write(core, WL1273_SCAN_SPACING_SET,
1354                                 WL1273_SPACING_100kHz);
1355                 radio->spacing = 100;
1356         } else if (spacing - 50000 < 25000) {
1357                 r = core->write(core, WL1273_SCAN_SPACING_SET,
1358                                 WL1273_SPACING_50kHz);
1359                 radio->spacing = 50;
1360         } else if (spacing - 100000 < 50000) {
1361                 r = core->write(core, WL1273_SCAN_SPACING_SET,
1362                                 WL1273_SPACING_100kHz);
1363                 radio->spacing = 100;
1364         } else {
1365                 r = core->write(core, WL1273_SCAN_SPACING_SET,
1366                                 WL1273_SPACING_200kHz);
1367                 radio->spacing = 200;
1368         }
1369
1370         return r;
1371 }
1372
1373 static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1374 {
1375         struct wl1273_device *radio = ctrl->priv;
1376         struct wl1273_core *core = radio->core;
1377
1378         dev_dbg(radio->dev, "%s\n", __func__);
1379
1380         if (mutex_lock_interruptible(&core->lock))
1381                 return -EINTR;
1382
1383         switch (ctrl->id) {
1384         case  V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1385                 ctrl->val = wl1273_fm_get_tx_ctune(radio);
1386                 break;
1387
1388         default:
1389                 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1390                          __func__, ctrl->id);
1391                 break;
1392         }
1393
1394         mutex_unlock(&core->lock);
1395
1396         return 0;
1397 }
1398
1399 #define WL1273_MUTE_SOFT_ENABLE    (1 << 0)
1400 #define WL1273_MUTE_AC             (1 << 1)
1401 #define WL1273_MUTE_HARD_LEFT      (1 << 2)
1402 #define WL1273_MUTE_HARD_RIGHT     (1 << 3)
1403 #define WL1273_MUTE_SOFT_FORCE     (1 << 4)
1404
1405 static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
1406 {
1407         return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
1408 }
1409
1410 static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl)
1411 {
1412         struct wl1273_device *radio = to_radio(ctrl);
1413         struct wl1273_core *core = radio->core;
1414         int r = 0;
1415
1416         dev_dbg(radio->dev, "%s\n", __func__);
1417
1418         switch (ctrl->id) {
1419         case V4L2_CID_AUDIO_MUTE:
1420                 if (mutex_lock_interruptible(&core->lock))
1421                         return -EINTR;
1422
1423                 if (core->mode == WL1273_MODE_RX && ctrl->val)
1424                         r = core->write(core,
1425                                         WL1273_MUTE_STATUS_SET,
1426                                         WL1273_MUTE_HARD_LEFT |
1427                                         WL1273_MUTE_HARD_RIGHT);
1428                 else if (core->mode == WL1273_MODE_RX)
1429                         r = core->write(core,
1430                                         WL1273_MUTE_STATUS_SET, 0x0);
1431                 else if (core->mode == WL1273_MODE_TX && ctrl->val)
1432                         r = core->write(core, WL1273_MUTE, 1);
1433                 else if (core->mode == WL1273_MODE_TX)
1434                         r = core->write(core, WL1273_MUTE, 0);
1435
1436                 mutex_unlock(&core->lock);
1437                 break;
1438
1439         case V4L2_CID_AUDIO_VOLUME:
1440                 if (ctrl->val == 0)
1441                         r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF);
1442                 else
1443                         r =  core->set_volume(core, core->volume);
1444                 break;
1445
1446         case V4L2_CID_TUNE_PREEMPHASIS:
1447                 r = wl1273_fm_set_preemphasis(radio, ctrl->val);
1448                 break;
1449
1450         case V4L2_CID_TUNE_POWER_LEVEL:
1451                 r = wl1273_fm_set_tx_power(radio, ctrl->val);
1452                 break;
1453
1454         default:
1455                 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1456                          __func__, ctrl->id);
1457                 break;
1458         }
1459
1460         dev_dbg(radio->dev, "%s\n", __func__);
1461         return r;
1462 }
1463
1464 static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv,
1465                                     struct v4l2_audio *audio)
1466 {
1467         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1468
1469         dev_dbg(radio->dev, "%s\n", __func__);
1470
1471         if (audio->index > 1)
1472                 return -EINVAL;
1473
1474         strlcpy(audio->name, "Radio", sizeof(audio->name));
1475         audio->capability = V4L2_AUDCAP_STEREO;
1476
1477         return 0;
1478 }
1479
1480 static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv,
1481                                     struct v4l2_audio *audio)
1482 {
1483         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1484
1485         dev_dbg(radio->dev, "%s\n", __func__);
1486
1487         if (audio->index != 0)
1488                 return -EINVAL;
1489
1490         return 0;
1491 }
1492
1493 #define WL1273_RDS_NOT_SYNCHRONIZED 0
1494 #define WL1273_RDS_SYNCHRONIZED 1
1495
1496 static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv,
1497                                     struct v4l2_tuner *tuner)
1498 {
1499         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1500         struct wl1273_core *core = radio->core;
1501         u16 val;
1502         int r;
1503
1504         dev_dbg(radio->dev, "%s\n", __func__);
1505
1506         if (tuner->index > 0)
1507                 return -EINVAL;
1508
1509         strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name));
1510         tuner->type = V4L2_TUNER_RADIO;
1511
1512         tuner->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1513         tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1514
1515         tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1516                 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1517
1518         if (radio->stereo)
1519                 tuner->audmode = V4L2_TUNER_MODE_STEREO;
1520         else
1521                 tuner->audmode = V4L2_TUNER_MODE_MONO;
1522
1523         if (core->mode != WL1273_MODE_RX)
1524                 return 0;
1525
1526         if (mutex_lock_interruptible(&core->lock))
1527                 return -EINTR;
1528
1529         r = core->read(core, WL1273_STEREO_GET, &val);
1530         if (r)
1531                 goto out;
1532
1533         if (val == 1)
1534                 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
1535         else
1536                 tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
1537
1538         r = core->read(core, WL1273_RSSI_LVL_GET, &val);
1539         if (r)
1540                 goto out;
1541
1542         tuner->signal = (s16) val;
1543         dev_dbg(radio->dev, "Signal: %d\n", tuner->signal);
1544
1545         tuner->afc = 0;
1546
1547         r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1548         if (r)
1549                 goto out;
1550
1551         if (val == WL1273_RDS_SYNCHRONIZED)
1552                 tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
1553 out:
1554         mutex_unlock(&core->lock);
1555
1556         return r;
1557 }
1558
1559 static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv,
1560                                     struct v4l2_tuner *tuner)
1561 {
1562         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1563         struct wl1273_core *core = radio->core;
1564         int r = 0;
1565
1566         dev_dbg(radio->dev, "%s\n", __func__);
1567         dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index);
1568         dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name);
1569         dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability);
1570         dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans);
1571         dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow);
1572         dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh);
1573
1574         if (tuner->index > 0)
1575                 return -EINVAL;
1576
1577         if (mutex_lock_interruptible(&core->lock))
1578                 return -EINTR;
1579
1580         r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1581         if (r)
1582                 goto out;
1583
1584         if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS)
1585                 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1586         else
1587                 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1588
1589         if (r)
1590                 dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r);
1591
1592         if (tuner->audmode == V4L2_TUNER_MODE_MONO) {
1593                 r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_MONO);
1594                 if (r < 0) {
1595                         dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1596                                  __func__, r);
1597                         goto out;
1598                 }
1599                 radio->stereo = false;
1600         } else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) {
1601                 r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_STEREO);
1602                 if (r < 0) {
1603                         dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1604                                  __func__, r);
1605                         goto out;
1606                 }
1607                 radio->stereo = true;
1608         } else {
1609                 dev_err(radio->dev, "%s: tuner->audmode: %d\n",
1610                          __func__, tuner->audmode);
1611                 r = -EINVAL;
1612                 goto out;
1613         }
1614
1615 out:
1616         mutex_unlock(&core->lock);
1617
1618         return r;
1619 }
1620
1621 static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv,
1622                                         struct v4l2_frequency *freq)
1623 {
1624         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1625         struct wl1273_core *core = radio->core;
1626
1627         dev_dbg(radio->dev, "%s\n", __func__);
1628
1629         if (mutex_lock_interruptible(&core->lock))
1630                 return -EINTR;
1631
1632         freq->type = V4L2_TUNER_RADIO;
1633         freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio));
1634
1635         mutex_unlock(&core->lock);
1636
1637         return 0;
1638 }
1639
1640 static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv,
1641                                         struct v4l2_frequency *freq)
1642 {
1643         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1644         struct wl1273_core *core = radio->core;
1645         int r;
1646
1647         dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency);
1648
1649         if (freq->type != V4L2_TUNER_RADIO) {
1650                 dev_dbg(radio->dev,
1651                         "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type);
1652                 return -EINVAL;
1653         }
1654
1655         if (mutex_lock_interruptible(&core->lock))
1656                 return -EINTR;
1657
1658         if (core->mode == WL1273_MODE_RX) {
1659                 dev_dbg(radio->dev, "freq: %d\n", freq->frequency);
1660
1661                 r = wl1273_fm_set_rx_freq(radio,
1662                                           WL1273_INV_FREQ(freq->frequency));
1663                 if (r)
1664                         dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1665                                  ": set frequency failed with %d\n", r);
1666         } else {
1667                 r = wl1273_fm_set_tx_freq(radio,
1668                                           WL1273_INV_FREQ(freq->frequency));
1669                 if (r)
1670                         dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1671                                  ": set frequency failed with %d\n", r);
1672         }
1673
1674         mutex_unlock(&core->lock);
1675
1676         dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n");
1677         return r;
1678 }
1679
1680 #define WL1273_DEFAULT_SEEK_LEVEL       7
1681
1682 static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv,
1683                                            struct v4l2_hw_freq_seek *seek)
1684 {
1685         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1686         struct wl1273_core *core = radio->core;
1687         int r;
1688
1689         dev_dbg(radio->dev, "%s\n", __func__);
1690
1691         if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO)
1692                 return -EINVAL;
1693
1694         if (mutex_lock_interruptible(&core->lock))
1695                 return -EINTR;
1696
1697         r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1698         if (r)
1699                 goto out;
1700
1701         r = wl1273_fm_tx_set_spacing(radio, seek->spacing);
1702         if (r)
1703                 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1704
1705         r = wl1273_fm_set_seek(radio, seek->wrap_around, seek->seek_upward,
1706                                WL1273_DEFAULT_SEEK_LEVEL);
1707         if (r)
1708                 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1709
1710 out:
1711         mutex_unlock(&core->lock);
1712         return r;
1713 }
1714
1715 static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv,
1716                                         struct v4l2_modulator *modulator)
1717 {
1718         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1719         struct wl1273_core *core = radio->core;
1720         int r = 0;
1721
1722         dev_dbg(radio->dev, "%s\n", __func__);
1723
1724         if (modulator->index > 0)
1725                 return -EINVAL;
1726
1727         if (mutex_lock_interruptible(&core->lock))
1728                 return -EINTR;
1729
1730         r = wl1273_fm_set_mode(radio, WL1273_MODE_TX);
1731         if (r)
1732                 goto out;
1733
1734         if (modulator->txsubchans & V4L2_TUNER_SUB_RDS)
1735                 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1736         else
1737                 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1738
1739         if (modulator->txsubchans & V4L2_TUNER_SUB_MONO)
1740                 r = core->write(core, WL1273_MONO_SET, WL1273_TX_MONO);
1741         else
1742                 r = core->write(core, WL1273_MONO_SET,
1743                                 WL1273_RX_STEREO);
1744         if (r < 0)
1745                 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1746                          "MONO_SET fails: %d\n", r);
1747 out:
1748         mutex_unlock(&core->lock);
1749
1750         return r;
1751 }
1752
1753 static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv,
1754                                         struct v4l2_modulator *modulator)
1755 {
1756         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1757         struct wl1273_core *core = radio->core;
1758         u16 val;
1759         int r;
1760
1761         dev_dbg(radio->dev, "%s\n", __func__);
1762
1763         strlcpy(modulator->name, WL1273_FM_DRIVER_NAME,
1764                 sizeof(modulator->name));
1765
1766         modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1767         modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1768
1769         modulator->capability =  V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1770                 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1771
1772         if (core->mode != WL1273_MODE_TX)
1773                 return 0;
1774
1775         if (mutex_lock_interruptible(&core->lock))
1776                 return -EINTR;
1777
1778         r = core->read(core, WL1273_MONO_SET, &val);
1779         if (r)
1780                 goto out;
1781
1782         if (val == WL1273_TX_STEREO)
1783                 modulator->txsubchans = V4L2_TUNER_SUB_STEREO;
1784         else
1785                 modulator->txsubchans = V4L2_TUNER_SUB_MONO;
1786
1787         if (radio->rds_on)
1788                 modulator->txsubchans |= V4L2_TUNER_SUB_RDS;
1789 out:
1790         mutex_unlock(&core->lock);
1791
1792         return 0;
1793 }
1794
1795 static int wl1273_fm_vidioc_log_status(struct file *file, void *priv)
1796 {
1797         struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1798         struct wl1273_core *core = radio->core;
1799         struct device *dev = radio->dev;
1800         u16 val;
1801         int r;
1802
1803         dev_info(dev, DRIVER_DESC);
1804
1805         if (core->mode == WL1273_MODE_OFF) {
1806                 dev_info(dev, "Mode: Off\n");
1807                 return 0;
1808         }
1809
1810         if (core->mode == WL1273_MODE_SUSPENDED) {
1811                 dev_info(dev, "Mode: Suspended\n");
1812                 return 0;
1813         }
1814
1815         r = core->read(core, WL1273_ASIC_ID_GET, &val);
1816         if (r)
1817                 dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__);
1818         else
1819                 dev_info(dev, "ASIC_ID: 0x%04x\n", val);
1820
1821         r = core->read(core, WL1273_ASIC_VER_GET, &val);
1822         if (r)
1823                 dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__);
1824         else
1825                 dev_info(dev, "ASIC Version: 0x%04x\n", val);
1826
1827         r = core->read(core, WL1273_FIRM_VER_GET, &val);
1828         if (r)
1829                 dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__);
1830         else
1831                 dev_info(dev, "FW version: %d(0x%04x)\n", val, val);
1832
1833         r = core->read(core, WL1273_BAND_SET, &val);
1834         if (r)
1835                 dev_err(dev, "%s: Get BAND fails.\n", __func__);
1836         else
1837                 dev_info(dev, "BAND: %d\n", val);
1838
1839         if (core->mode == WL1273_MODE_TX) {
1840                 r = core->read(core, WL1273_PUPD_SET, &val);
1841                 if (r)
1842                         dev_err(dev, "%s: Get PUPD fails.\n", __func__);
1843                 else
1844                         dev_info(dev, "PUPD: 0x%04x\n", val);
1845
1846                 r = core->read(core, WL1273_CHANL_SET, &val);
1847                 if (r)
1848                         dev_err(dev, "%s: Get CHANL fails.\n", __func__);
1849                 else
1850                         dev_info(dev, "Tx frequency: %dkHz\n", val*10);
1851         } else if (core->mode == WL1273_MODE_RX) {
1852                 int bf = radio->rangelow;
1853
1854                 r = core->read(core, WL1273_FREQ_SET, &val);
1855                 if (r)
1856                         dev_err(dev, "%s: Get FREQ fails.\n", __func__);
1857                 else
1858                         dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50);
1859
1860                 r = core->read(core, WL1273_MOST_MODE_SET, &val);
1861                 if (r)
1862                         dev_err(dev, "%s: Get MOST_MODE fails.\n",
1863                                 __func__);
1864                 else if (val == 0)
1865                         dev_info(dev, "MOST_MODE: Stereo according to blend\n");
1866                 else if (val == 1)
1867                         dev_info(dev, "MOST_MODE: Force mono output\n");
1868                 else
1869                         dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val);
1870
1871                 r = core->read(core, WL1273_MOST_BLEND_SET, &val);
1872                 if (r)
1873                         dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__);
1874                 else if (val == 0)
1875                         dev_info(dev,
1876                                  "MOST_BLEND: Switched blend & hysteresis.\n");
1877                 else if (val == 1)
1878                         dev_info(dev, "MOST_BLEND: Soft blend.\n");
1879                 else
1880                         dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val);
1881
1882                 r = core->read(core, WL1273_STEREO_GET, &val);
1883                 if (r)
1884                         dev_err(dev, "%s: Get STEREO fails.\n", __func__);
1885                 else if (val == 0)
1886                         dev_info(dev, "STEREO: Not detected\n");
1887                 else if (val == 1)
1888                         dev_info(dev, "STEREO: Detected\n");
1889                 else
1890                         dev_info(dev, "STEREO: Unexpected value: %d\n", val);
1891
1892                 r = core->read(core, WL1273_RSSI_LVL_GET, &val);
1893                 if (r)
1894                         dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__);
1895                 else
1896                         dev_info(dev, "RX signal strength: %d\n", (s16) val);
1897
1898                 r = core->read(core, WL1273_POWER_SET, &val);
1899                 if (r)
1900                         dev_err(dev, "%s: Get POWER fails.\n", __func__);
1901                 else
1902                         dev_info(dev, "POWER: 0x%04x\n", val);
1903
1904                 r = core->read(core, WL1273_INT_MASK_SET, &val);
1905                 if (r)
1906                         dev_err(dev, "%s: Get INT_MASK fails.\n", __func__);
1907                 else
1908                         dev_info(dev, "INT_MASK: 0x%04x\n", val);
1909
1910                 r = core->read(core, WL1273_RDS_SYNC_GET, &val);
1911                 if (r)
1912                         dev_err(dev, "%s: Get RDS_SYNC fails.\n",
1913                                 __func__);
1914                 else if (val == 0)
1915                         dev_info(dev, "RDS_SYNC: Not synchronized\n");
1916
1917                 else if (val == 1)
1918                         dev_info(dev, "RDS_SYNC: Synchronized\n");
1919                 else
1920                         dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val);
1921
1922                 r = core->read(core, WL1273_I2S_MODE_CONFIG_SET, &val);
1923                 if (r)
1924                         dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n",
1925                                 __func__);
1926                 else
1927                         dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val);
1928
1929                 r = core->read(core, WL1273_VOLUME_SET, &val);
1930                 if (r)
1931                         dev_err(dev, "%s: Get VOLUME fails.\n", __func__);
1932                 else
1933                         dev_info(dev, "VOLUME: 0x%04x\n", val);
1934         }
1935
1936         return 0;
1937 }
1938
1939 static void wl1273_vdev_release(struct video_device *dev)
1940 {
1941 }
1942
1943 static const struct v4l2_ctrl_ops wl1273_ctrl_ops = {
1944         .s_ctrl = wl1273_fm_vidioc_s_ctrl,
1945         .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl,
1946 };
1947
1948 static const struct v4l2_ioctl_ops wl1273_ioctl_ops = {
1949         .vidioc_querycap        = wl1273_fm_vidioc_querycap,
1950         .vidioc_g_input         = wl1273_fm_vidioc_g_input,
1951         .vidioc_s_input         = wl1273_fm_vidioc_s_input,
1952         .vidioc_g_audio         = wl1273_fm_vidioc_g_audio,
1953         .vidioc_s_audio         = wl1273_fm_vidioc_s_audio,
1954         .vidioc_g_tuner         = wl1273_fm_vidioc_g_tuner,
1955         .vidioc_s_tuner         = wl1273_fm_vidioc_s_tuner,
1956         .vidioc_g_frequency     = wl1273_fm_vidioc_g_frequency,
1957         .vidioc_s_frequency     = wl1273_fm_vidioc_s_frequency,
1958         .vidioc_s_hw_freq_seek  = wl1273_fm_vidioc_s_hw_freq_seek,
1959         .vidioc_g_modulator     = wl1273_fm_vidioc_g_modulator,
1960         .vidioc_s_modulator     = wl1273_fm_vidioc_s_modulator,
1961         .vidioc_log_status      = wl1273_fm_vidioc_log_status,
1962 };
1963
1964 static struct video_device wl1273_viddev_template = {
1965         .fops                   = &wl1273_fops,
1966         .ioctl_ops              = &wl1273_ioctl_ops,
1967         .name                   = WL1273_FM_DRIVER_NAME,
1968         .release                = wl1273_vdev_release,
1969 };
1970
1971 static int wl1273_fm_radio_remove(struct platform_device *pdev)
1972 {
1973         struct wl1273_device *radio = platform_get_drvdata(pdev);
1974         struct wl1273_core *core = radio->core;
1975
1976         dev_info(&pdev->dev, "%s.\n", __func__);
1977
1978         free_irq(core->client->irq, radio);
1979         core->pdata->free_resources();
1980
1981         v4l2_ctrl_handler_free(&radio->ctrl_handler);
1982         video_unregister_device(&radio->videodev);
1983         v4l2_device_unregister(&radio->v4l2dev);
1984         kfree(radio->buffer);
1985         kfree(radio->write_buf);
1986         kfree(radio);
1987
1988         return 0;
1989 }
1990
1991 static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev)
1992 {
1993         struct wl1273_core **core = pdev->dev.platform_data;
1994         struct wl1273_device *radio;
1995         struct v4l2_ctrl *ctrl;
1996         int r = 0;
1997
1998         pr_debug("%s\n", __func__);
1999
2000         if (!core) {
2001                 dev_err(&pdev->dev, "No platform data.\n");
2002                 r = -EINVAL;
2003                 goto pdata_err;
2004         }
2005
2006         radio = kzalloc(sizeof(*radio), GFP_KERNEL);
2007         if (!radio) {
2008                 r = -ENOMEM;
2009                 goto pdata_err;
2010         }
2011
2012         /* RDS buffer allocation */
2013         radio->buf_size = rds_buf * RDS_BLOCK_SIZE;
2014         radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
2015         if (!radio->buffer) {
2016                 pr_err("Cannot allocate memory for RDS buffer.\n");
2017                 r = -ENOMEM;
2018                 goto err_kmalloc;
2019         }
2020
2021         radio->core = *core;
2022         radio->irq_flags = WL1273_IRQ_MASK;
2023         radio->dev = &radio->core->client->dev;
2024         radio->rds_on = false;
2025         radio->core->mode = WL1273_MODE_OFF;
2026         radio->tx_power = 118;
2027         radio->core->audio_mode = WL1273_AUDIO_ANALOG;
2028         radio->band = WL1273_BAND_OTHER;
2029         radio->core->i2s_mode = WL1273_I2S_DEF_MODE;
2030         radio->core->channel_number = 2;
2031         radio->core->volume = WL1273_DEFAULT_VOLUME;
2032         radio->rx_frequency = WL1273_BAND_OTHER_LOW;
2033         radio->tx_frequency = WL1273_BAND_OTHER_HIGH;
2034         radio->rangelow = WL1273_BAND_OTHER_LOW;
2035         radio->rangehigh = WL1273_BAND_OTHER_HIGH;
2036         radio->stereo = true;
2037         radio->bus_type = "I2C";
2038
2039         if (radio->core->pdata->request_resources) {
2040                 r = radio->core->pdata->request_resources(radio->core->client);
2041                 if (r) {
2042                         dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2043                                 ": Cannot get platform data\n");
2044                         goto err_resources;
2045                 }
2046
2047                 dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq);
2048
2049                 r = request_threaded_irq(radio->core->client->irq, NULL,
2050                                          wl1273_fm_irq_thread_handler,
2051                                          IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
2052                                          "wl1273-fm", radio);
2053                 if (r < 0) {
2054                         dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2055                                 ": Unable to register IRQ handler: %d\n", r);
2056                         goto err_request_irq;
2057                 }
2058         } else {
2059                 dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ"
2060                         " not configured");
2061                 r = -EINVAL;
2062                 goto err_resources;
2063         }
2064
2065         init_completion(&radio->busy);
2066         init_waitqueue_head(&radio->read_queue);
2067
2068         radio->write_buf = kmalloc(256, GFP_KERNEL);
2069         if (!radio->write_buf) {
2070                 r = -ENOMEM;
2071                 goto write_buf_err;
2072         }
2073
2074         radio->dev = &pdev->dev;
2075         radio->v4l2dev.ctrl_handler = &radio->ctrl_handler;
2076         radio->rds_users = 0;
2077
2078         r = v4l2_device_register(&pdev->dev, &radio->v4l2dev);
2079         if (r) {
2080                 dev_err(&pdev->dev, "Cannot register v4l2_device.\n");
2081                 goto device_register_err;
2082         }
2083
2084         /* V4L2 configuration */
2085         memcpy(&radio->videodev, &wl1273_viddev_template,
2086                sizeof(wl1273_viddev_template));
2087
2088         radio->videodev.v4l2_dev = &radio->v4l2dev;
2089
2090         v4l2_ctrl_handler_init(&radio->ctrl_handler, 6);
2091
2092         /* add in ascending ID order */
2093         v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2094                           V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1,
2095                           WL1273_DEFAULT_VOLUME);
2096
2097         v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2098                           V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2099
2100         v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops,
2101                                V4L2_CID_TUNE_PREEMPHASIS,
2102                                V4L2_PREEMPHASIS_75_uS, 0x03,
2103                                V4L2_PREEMPHASIS_50_uS);
2104
2105         v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2106                           V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118);
2107
2108         ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2109                                  V4L2_CID_TUNE_ANTENNA_CAPACITOR,
2110                                  0, 255, 1, 255);
2111         if (ctrl)
2112                 ctrl->is_volatile = 1;
2113
2114         if (radio->ctrl_handler.error) {
2115                 r = radio->ctrl_handler.error;
2116                 dev_err(&pdev->dev, "Ctrl handler error: %d\n", r);
2117                 goto handler_init_err;
2118         }
2119
2120         video_set_drvdata(&radio->videodev, radio);
2121         platform_set_drvdata(pdev, radio);
2122
2123         /* register video device */
2124         r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
2125         if (r) {
2126                 dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME
2127                         ": Could not register video device\n");
2128                 goto handler_init_err;
2129         }
2130
2131         return 0;
2132
2133 handler_init_err:
2134         v4l2_ctrl_handler_free(&radio->ctrl_handler);
2135         v4l2_device_unregister(&radio->v4l2dev);
2136 device_register_err:
2137         kfree(radio->write_buf);
2138 write_buf_err:
2139         free_irq(radio->core->client->irq, radio);
2140 err_request_irq:
2141         radio->core->pdata->free_resources();
2142 err_resources:
2143         kfree(radio->buffer);
2144 err_kmalloc:
2145         kfree(radio);
2146 pdata_err:
2147         return r;
2148 }
2149
2150 MODULE_ALIAS("platform:wl1273_fm_radio");
2151
2152 static struct platform_driver wl1273_fm_radio_driver = {
2153         .probe          = wl1273_fm_radio_probe,
2154         .remove         = __devexit_p(wl1273_fm_radio_remove),
2155         .driver         = {
2156                 .name   = "wl1273_fm_radio",
2157                 .owner  = THIS_MODULE,
2158         },
2159 };
2160
2161 static int __init wl1273_fm_module_init(void)
2162 {
2163         pr_info("%s\n", __func__);
2164         return platform_driver_register(&wl1273_fm_radio_driver);
2165 }
2166 module_init(wl1273_fm_module_init);
2167
2168 static void __exit wl1273_fm_module_exit(void)
2169 {
2170         platform_driver_unregister(&wl1273_fm_radio_driver);
2171         pr_info(DRIVER_DESC ", Exiting.\n");
2172 }
2173 module_exit(wl1273_fm_module_exit);
2174
2175 MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");
2176 MODULE_DESCRIPTION(DRIVER_DESC);
2177 MODULE_LICENSE("GPL");