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