linux/drivers/media/radio/si4713-i2c.c
<<
>>
Prefs
   1/*
   2 * drivers/media/radio/si4713-i2c.c
   3 *
   4 * Silicon Labs Si4713 FM Radio Transmitter I2C commands.
   5 *
   6 * Copyright (c) 2009 Nokia Corporation
   7 * Contact: Eduardo Valentin <eduardo.valentin@nokia.com>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2 of the License, or
  12 * (at your option) any later version.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with this program; if not, write to the Free Software
  21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22 */
  23
  24#include <linux/mutex.h>
  25#include <linux/completion.h>
  26#include <linux/delay.h>
  27#include <linux/interrupt.h>
  28#include <linux/i2c.h>
  29#include <linux/slab.h>
  30#include <media/v4l2-device.h>
  31#include <media/v4l2-ioctl.h>
  32#include <media/v4l2-common.h>
  33
  34#include "si4713-i2c.h"
  35
  36/* module parameters */
  37static int debug;
  38module_param(debug, int, S_IRUGO | S_IWUSR);
  39MODULE_PARM_DESC(debug, "Debug level (0 - 2)");
  40
  41MODULE_LICENSE("GPL");
  42MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
  43MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter");
  44MODULE_VERSION("0.0.1");
  45
  46#define DEFAULT_RDS_PI                  0x00
  47#define DEFAULT_RDS_PTY                 0x00
  48#define DEFAULT_RDS_PS_NAME             ""
  49#define DEFAULT_RDS_RADIO_TEXT          DEFAULT_RDS_PS_NAME
  50#define DEFAULT_RDS_DEVIATION           0x00C8
  51#define DEFAULT_RDS_PS_REPEAT_COUNT     0x0003
  52#define DEFAULT_LIMITER_RTIME           0x1392
  53#define DEFAULT_LIMITER_DEV             0x102CA
  54#define DEFAULT_PILOT_FREQUENCY         0x4A38
  55#define DEFAULT_PILOT_DEVIATION         0x1A5E
  56#define DEFAULT_ACOMP_ATIME             0x0000
  57#define DEFAULT_ACOMP_RTIME             0xF4240L
  58#define DEFAULT_ACOMP_GAIN              0x0F
  59#define DEFAULT_ACOMP_THRESHOLD         (-0x28)
  60#define DEFAULT_MUTE                    0x01
  61#define DEFAULT_POWER_LEVEL             88
  62#define DEFAULT_FREQUENCY               8800
  63#define DEFAULT_PREEMPHASIS             FMPE_EU
  64#define DEFAULT_TUNE_RNL                0xFF
  65
  66#define to_si4713_device(sd)    container_of(sd, struct si4713_device, sd)
  67
  68/* frequency domain transformation (using times 10 to avoid floats) */
  69#define FREQDEV_UNIT    100000
  70#define FREQV4L2_MULTI  625
  71#define si4713_to_v4l2(f)       ((f * FREQDEV_UNIT) / FREQV4L2_MULTI)
  72#define v4l2_to_si4713(f)       ((f * FREQV4L2_MULTI) / FREQDEV_UNIT)
  73#define FREQ_RANGE_LOW                  7600
  74#define FREQ_RANGE_HIGH                 10800
  75
  76#define MAX_ARGS 7
  77
  78#define RDS_BLOCK                       8
  79#define RDS_BLOCK_CLEAR                 0x03
  80#define RDS_BLOCK_LOAD                  0x04
  81#define RDS_RADIOTEXT_2A                0x20
  82#define RDS_RADIOTEXT_BLK_SIZE          4
  83#define RDS_RADIOTEXT_INDEX_MAX         0x0F
  84#define RDS_CARRIAGE_RETURN             0x0D
  85
  86#define rds_ps_nblocks(len)     ((len / RDS_BLOCK) + (len % RDS_BLOCK ? 1 : 0))
  87
  88#define get_status_bit(p, b, m) (((p) & (m)) >> (b))
  89#define set_bits(p, v, b, m)    (((p) & ~(m)) | ((v) << (b)))
  90
  91#define ATTACK_TIME_UNIT        500
  92
  93#define POWER_OFF                       0x00
  94#define POWER_ON                        0x01
  95
  96#define msb(x)                  ((u8)((u16) x >> 8))
  97#define lsb(x)                  ((u8)((u16) x &  0x00FF))
  98#define compose_u16(msb, lsb)   (((u16)msb << 8) | lsb)
  99#define check_command_failed(status)    (!(status & SI4713_CTS) || \
 100                                        (status & SI4713_ERR))
 101/* mute definition */
 102#define set_mute(p)     ((p & 1) | ((p & 1) << 1));
 103#define get_mute(p)     (p & 0x01)
 104
 105#ifdef DEBUG
 106#define DBG_BUFFER(device, message, buffer, size)                       \
 107        {                                                               \
 108                int i;                                                  \
 109                char str[(size)*5];                                     \
 110                for (i = 0; i < size; i++)                              \
 111                        sprintf(str + i * 5, " 0x%02x", buffer[i]);     \
 112                v4l2_dbg(2, debug, device, "%s:%s\n", message, str);    \
 113        }
 114#else
 115#define DBG_BUFFER(device, message, buffer, size)
 116#endif
 117
 118/*
 119 * Values for limiter release time (sorted by second column)
 120 *      device  release
 121 *      value   time (us)
 122 */
 123static long limiter_times[] = {
 124        2000,   250,
 125        1000,   500,
 126        510,    1000,
 127        255,    2000,
 128        170,    3000,
 129        127,    4020,
 130        102,    5010,
 131        85,     6020,
 132        73,     7010,
 133        64,     7990,
 134        57,     8970,
 135        51,     10030,
 136        25,     20470,
 137        17,     30110,
 138        13,     39380,
 139        10,     51190,
 140        8,      63690,
 141        7,      73140,
 142        6,      85330,
 143        5,      102390,
 144};
 145
 146/*
 147 * Values for audio compression release time (sorted by second column)
 148 *      device  release
 149 *      value   time (us)
 150 */
 151static unsigned long acomp_rtimes[] = {
 152        0,      100000,
 153        1,      200000,
 154        2,      350000,
 155        3,      525000,
 156        4,      1000000,
 157};
 158
 159/*
 160 * Values for preemphasis (sorted by second column)
 161 *      device  preemphasis
 162 *      value   value (v4l2)
 163 */
 164static unsigned long preemphasis_values[] = {
 165        FMPE_DISABLED,  V4L2_PREEMPHASIS_DISABLED,
 166        FMPE_EU,        V4L2_PREEMPHASIS_50_uS,
 167        FMPE_USA,       V4L2_PREEMPHASIS_75_uS,
 168};
 169
 170static int usecs_to_dev(unsigned long usecs, unsigned long const array[],
 171                        int size)
 172{
 173        int i;
 174        int rval = -EINVAL;
 175
 176        for (i = 0; i < size / 2; i++)
 177                if (array[(i * 2) + 1] >= usecs) {
 178                        rval = array[i * 2];
 179                        break;
 180                }
 181
 182        return rval;
 183}
 184
 185static unsigned long dev_to_usecs(int value, unsigned long const array[],
 186                        int size)
 187{
 188        int i;
 189        int rval = -EINVAL;
 190
 191        for (i = 0; i < size / 2; i++)
 192                if (array[i * 2] == value) {
 193                        rval = array[(i * 2) + 1];
 194                        break;
 195                }
 196
 197        return rval;
 198}
 199
 200/* si4713_handler: IRQ handler, just complete work */
 201static irqreturn_t si4713_handler(int irq, void *dev)
 202{
 203        struct si4713_device *sdev = dev;
 204
 205        v4l2_dbg(2, debug, &sdev->sd,
 206                        "%s: sending signal to completion work.\n", __func__);
 207        complete(&sdev->work);
 208
 209        return IRQ_HANDLED;
 210}
 211
 212/*
 213 * si4713_send_command - sends a command to si4713 and waits its response
 214 * @sdev: si4713_device structure for the device we are communicating
 215 * @command: command id
 216 * @args: command arguments we are sending (up to 7)
 217 * @argn: actual size of @args
 218 * @response: buffer to place the expected response from the device (up to 15)
 219 * @respn: actual size of @response
 220 * @usecs: amount of time to wait before reading the response (in usecs)
 221 */
 222static int si4713_send_command(struct si4713_device *sdev, const u8 command,
 223                                const u8 args[], const int argn,
 224                                u8 response[], const int respn, const int usecs)
 225{
 226        struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 227        u8 data1[MAX_ARGS + 1];
 228        int err;
 229
 230        if (!client->adapter)
 231                return -ENODEV;
 232
 233        /* First send the command and its arguments */
 234        data1[0] = command;
 235        memcpy(data1 + 1, args, argn);
 236        DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1);
 237
 238        err = i2c_master_send(client, data1, argn + 1);
 239        if (err != argn + 1) {
 240                v4l2_err(&sdev->sd, "Error while sending command 0x%02x\n",
 241                        command);
 242                return (err > 0) ? -EIO : err;
 243        }
 244
 245        /* Wait response from interrupt */
 246        if (!wait_for_completion_timeout(&sdev->work,
 247                                usecs_to_jiffies(usecs) + 1))
 248                v4l2_warn(&sdev->sd,
 249                                "(%s) Device took too much time to answer.\n",
 250                                __func__);
 251
 252        /* Then get the response */
 253        err = i2c_master_recv(client, response, respn);
 254        if (err != respn) {
 255                v4l2_err(&sdev->sd,
 256                        "Error while reading response for command 0x%02x\n",
 257                        command);
 258                return (err > 0) ? -EIO : err;
 259        }
 260
 261        DBG_BUFFER(&sdev->sd, "Response", response, respn);
 262        if (check_command_failed(response[0]))
 263                return -EBUSY;
 264
 265        return 0;
 266}
 267
 268/*
 269 * si4713_read_property - reads a si4713 property
 270 * @sdev: si4713_device structure for the device we are communicating
 271 * @prop: property identification number
 272 * @pv: property value to be returned on success
 273 */
 274static int si4713_read_property(struct si4713_device *sdev, u16 prop, u32 *pv)
 275{
 276        int err;
 277        u8 val[SI4713_GET_PROP_NRESP];
 278        /*
 279         *      .First byte = 0
 280         *      .Second byte = property's MSB
 281         *      .Third byte = property's LSB
 282         */
 283        const u8 args[SI4713_GET_PROP_NARGS] = {
 284                0x00,
 285                msb(prop),
 286                lsb(prop),
 287        };
 288
 289        err = si4713_send_command(sdev, SI4713_CMD_GET_PROPERTY,
 290                                  args, ARRAY_SIZE(args), val,
 291                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 292
 293        if (err < 0)
 294                return err;
 295
 296        *pv = compose_u16(val[2], val[3]);
 297
 298        v4l2_dbg(1, debug, &sdev->sd,
 299                        "%s: property=0x%02x value=0x%02x status=0x%02x\n",
 300                        __func__, prop, *pv, val[0]);
 301
 302        return err;
 303}
 304
 305/*
 306 * si4713_write_property - modifies a si4713 property
 307 * @sdev: si4713_device structure for the device we are communicating
 308 * @prop: property identification number
 309 * @val: new value for that property
 310 */
 311static int si4713_write_property(struct si4713_device *sdev, u16 prop, u16 val)
 312{
 313        int rval;
 314        u8 resp[SI4713_SET_PROP_NRESP];
 315        /*
 316         *      .First byte = 0
 317         *      .Second byte = property's MSB
 318         *      .Third byte = property's LSB
 319         *      .Fourth byte = value's MSB
 320         *      .Fifth byte = value's LSB
 321         */
 322        const u8 args[SI4713_SET_PROP_NARGS] = {
 323                0x00,
 324                msb(prop),
 325                lsb(prop),
 326                msb(val),
 327                lsb(val),
 328        };
 329
 330        rval = si4713_send_command(sdev, SI4713_CMD_SET_PROPERTY,
 331                                        args, ARRAY_SIZE(args),
 332                                        resp, ARRAY_SIZE(resp),
 333                                        DEFAULT_TIMEOUT);
 334
 335        if (rval < 0)
 336                return rval;
 337
 338        v4l2_dbg(1, debug, &sdev->sd,
 339                        "%s: property=0x%02x value=0x%02x status=0x%02x\n",
 340                        __func__, prop, val, resp[0]);
 341
 342        /*
 343         * As there is no command response for SET_PROPERTY,
 344         * wait Tcomp time to finish before proceed, in order
 345         * to have property properly set.
 346         */
 347        msleep(TIMEOUT_SET_PROPERTY);
 348
 349        return rval;
 350}
 351
 352/*
 353 * si4713_powerup - Powers the device up
 354 * @sdev: si4713_device structure for the device we are communicating
 355 */
 356static int si4713_powerup(struct si4713_device *sdev)
 357{
 358        int err;
 359        u8 resp[SI4713_PWUP_NRESP];
 360        /*
 361         *      .First byte = Enabled interrupts and boot function
 362         *      .Second byte = Input operation mode
 363         */
 364        const u8 args[SI4713_PWUP_NARGS] = {
 365                SI4713_PWUP_CTSIEN | SI4713_PWUP_GPO2OEN | SI4713_PWUP_FUNC_TX,
 366                SI4713_PWUP_OPMOD_ANALOG,
 367        };
 368
 369        if (sdev->power_state)
 370                return 0;
 371
 372        sdev->platform_data->set_power(1);
 373        err = si4713_send_command(sdev, SI4713_CMD_POWER_UP,
 374                                        args, ARRAY_SIZE(args),
 375                                        resp, ARRAY_SIZE(resp),
 376                                        TIMEOUT_POWER_UP);
 377
 378        if (!err) {
 379                v4l2_dbg(1, debug, &sdev->sd, "Powerup response: 0x%02x\n",
 380                                resp[0]);
 381                v4l2_dbg(1, debug, &sdev->sd, "Device in power up mode\n");
 382                sdev->power_state = POWER_ON;
 383
 384                err = si4713_write_property(sdev, SI4713_GPO_IEN,
 385                                                SI4713_STC_INT | SI4713_CTS);
 386        } else {
 387                sdev->platform_data->set_power(0);
 388        }
 389
 390        return err;
 391}
 392
 393/*
 394 * si4713_powerdown - Powers the device down
 395 * @sdev: si4713_device structure for the device we are communicating
 396 */
 397static int si4713_powerdown(struct si4713_device *sdev)
 398{
 399        int err;
 400        u8 resp[SI4713_PWDN_NRESP];
 401
 402        if (!sdev->power_state)
 403                return 0;
 404
 405        err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN,
 406                                        NULL, 0,
 407                                        resp, ARRAY_SIZE(resp),
 408                                        DEFAULT_TIMEOUT);
 409
 410        if (!err) {
 411                v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
 412                                resp[0]);
 413                v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
 414                sdev->platform_data->set_power(0);
 415                sdev->power_state = POWER_OFF;
 416        }
 417
 418        return err;
 419}
 420
 421/*
 422 * si4713_checkrev - Checks if we are treating a device with the correct rev.
 423 * @sdev: si4713_device structure for the device we are communicating
 424 */
 425static int si4713_checkrev(struct si4713_device *sdev)
 426{
 427        struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 428        int rval;
 429        u8 resp[SI4713_GETREV_NRESP];
 430
 431        mutex_lock(&sdev->mutex);
 432
 433        rval = si4713_send_command(sdev, SI4713_CMD_GET_REV,
 434                                        NULL, 0,
 435                                        resp, ARRAY_SIZE(resp),
 436                                        DEFAULT_TIMEOUT);
 437
 438        if (rval < 0)
 439                goto unlock;
 440
 441        if (resp[1] == SI4713_PRODUCT_NUMBER) {
 442                v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)\n",
 443                                client->addr << 1, client->adapter->name);
 444        } else {
 445                v4l2_err(&sdev->sd, "Invalid product number\n");
 446                rval = -EINVAL;
 447        }
 448
 449unlock:
 450        mutex_unlock(&sdev->mutex);
 451        return rval;
 452}
 453
 454/*
 455 * si4713_wait_stc - Waits STC interrupt and clears status bits. Usefull
 456 *                   for TX_TUNE_POWER, TX_TUNE_FREQ and TX_TUNE_MEAS
 457 * @sdev: si4713_device structure for the device we are communicating
 458 * @usecs: timeout to wait for STC interrupt signal
 459 */
 460static int si4713_wait_stc(struct si4713_device *sdev, const int usecs)
 461{
 462        int err;
 463        u8 resp[SI4713_GET_STATUS_NRESP];
 464
 465        /* Wait response from STC interrupt */
 466        if (!wait_for_completion_timeout(&sdev->work,
 467                        usecs_to_jiffies(usecs) + 1))
 468                v4l2_warn(&sdev->sd,
 469                        "%s: device took too much time to answer (%d usec).\n",
 470                                __func__, usecs);
 471
 472        /* Clear status bits */
 473        err = si4713_send_command(sdev, SI4713_CMD_GET_INT_STATUS,
 474                                        NULL, 0,
 475                                        resp, ARRAY_SIZE(resp),
 476                                        DEFAULT_TIMEOUT);
 477
 478        if (err < 0)
 479                goto exit;
 480
 481        v4l2_dbg(1, debug, &sdev->sd,
 482                        "%s: status bits: 0x%02x\n", __func__, resp[0]);
 483
 484        if (!(resp[0] & SI4713_STC_INT))
 485                err = -EIO;
 486
 487exit:
 488        return err;
 489}
 490
 491/*
 492 * si4713_tx_tune_freq - Sets the state of the RF carrier and sets the tuning
 493 *                      frequency between 76 and 108 MHz in 10 kHz units and
 494 *                      steps of 50 kHz.
 495 * @sdev: si4713_device structure for the device we are communicating
 496 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
 497 */
 498static int si4713_tx_tune_freq(struct si4713_device *sdev, u16 frequency)
 499{
 500        int err;
 501        u8 val[SI4713_TXFREQ_NRESP];
 502        /*
 503         *      .First byte = 0
 504         *      .Second byte = frequency's MSB
 505         *      .Third byte = frequency's LSB
 506         */
 507        const u8 args[SI4713_TXFREQ_NARGS] = {
 508                0x00,
 509                msb(frequency),
 510                lsb(frequency),
 511        };
 512
 513        err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_FREQ,
 514                                  args, ARRAY_SIZE(args), val,
 515                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 516
 517        if (err < 0)
 518                return err;
 519
 520        v4l2_dbg(1, debug, &sdev->sd,
 521                        "%s: frequency=0x%02x status=0x%02x\n", __func__,
 522                        frequency, val[0]);
 523
 524        err = si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
 525        if (err < 0)
 526                return err;
 527
 528        return compose_u16(args[1], args[2]);
 529}
 530
 531/*
 532 * si4713_tx_tune_power - Sets the RF voltage level between 88 and 115 dBuV in
 533 *                      1 dB units. A value of 0x00 indicates off. The command
 534 *                      also sets the antenna tuning capacitance. A value of 0
 535 *                      indicates autotuning, and a value of 1 - 191 indicates
 536 *                      a manual override, which results in a tuning
 537 *                      capacitance of 0.25 pF x @antcap.
 538 * @sdev: si4713_device structure for the device we are communicating
 539 * @power: tuning power (88 - 115 dBuV, unit/step 1 dB)
 540 * @antcap: value of antenna tuning capacitor (0 - 191)
 541 */
 542static int si4713_tx_tune_power(struct si4713_device *sdev, u8 power,
 543                                u8 antcap)
 544{
 545        int err;
 546        u8 val[SI4713_TXPWR_NRESP];
 547        /*
 548         *      .First byte = 0
 549         *      .Second byte = 0
 550         *      .Third byte = power
 551         *      .Fourth byte = antcap
 552         */
 553        const u8 args[SI4713_TXPWR_NARGS] = {
 554                0x00,
 555                0x00,
 556                power,
 557                antcap,
 558        };
 559
 560        if (((power > 0) && (power < SI4713_MIN_POWER)) ||
 561                power > SI4713_MAX_POWER || antcap > SI4713_MAX_ANTCAP)
 562                return -EDOM;
 563
 564        err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_POWER,
 565                                  args, ARRAY_SIZE(args), val,
 566                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 567
 568        if (err < 0)
 569                return err;
 570
 571        v4l2_dbg(1, debug, &sdev->sd,
 572                        "%s: power=0x%02x antcap=0x%02x status=0x%02x\n",
 573                        __func__, power, antcap, val[0]);
 574
 575        return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE_POWER);
 576}
 577
 578/*
 579 * si4713_tx_tune_measure - Enters receive mode and measures the received noise
 580 *                      level in units of dBuV on the selected frequency.
 581 *                      The Frequency must be between 76 and 108 MHz in 10 kHz
 582 *                      units and steps of 50 kHz. The command also sets the
 583 *                      antenna tuning capacitance. A value of 0 means
 584 *                      autotuning, and a value of 1 to 191 indicates manual
 585 *                      override.
 586 * @sdev: si4713_device structure for the device we are communicating
 587 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
 588 * @antcap: value of antenna tuning capacitor (0 - 191)
 589 */
 590static int si4713_tx_tune_measure(struct si4713_device *sdev, u16 frequency,
 591                                        u8 antcap)
 592{
 593        int err;
 594        u8 val[SI4713_TXMEA_NRESP];
 595        /*
 596         *      .First byte = 0
 597         *      .Second byte = frequency's MSB
 598         *      .Third byte = frequency's LSB
 599         *      .Fourth byte = antcap
 600         */
 601        const u8 args[SI4713_TXMEA_NARGS] = {
 602                0x00,
 603                msb(frequency),
 604                lsb(frequency),
 605                antcap,
 606        };
 607
 608        sdev->tune_rnl = DEFAULT_TUNE_RNL;
 609
 610        if (antcap > SI4713_MAX_ANTCAP)
 611                return -EDOM;
 612
 613        err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_MEASURE,
 614                                  args, ARRAY_SIZE(args), val,
 615                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 616
 617        if (err < 0)
 618                return err;
 619
 620        v4l2_dbg(1, debug, &sdev->sd,
 621                        "%s: frequency=0x%02x antcap=0x%02x status=0x%02x\n",
 622                        __func__, frequency, antcap, val[0]);
 623
 624        return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
 625}
 626
 627/*
 628 * si4713_tx_tune_status- Returns the status of the tx_tune_freq, tx_tune_mea or
 629 *                      tx_tune_power commands. This command return the current
 630 *                      frequency, output voltage in dBuV, the antenna tunning
 631 *                      capacitance value and the received noise level. The
 632 *                      command also clears the stcint interrupt bit when the
 633 *                      first bit of its arguments is high.
 634 * @sdev: si4713_device structure for the device we are communicating
 635 * @intack: 0x01 to clear the seek/tune complete interrupt status indicator.
 636 * @frequency: returned frequency
 637 * @power: returned power
 638 * @antcap: returned antenna capacitance
 639 * @noise: returned noise level
 640 */
 641static int si4713_tx_tune_status(struct si4713_device *sdev, u8 intack,
 642                                        u16 *frequency, u8 *power,
 643                                        u8 *antcap, u8 *noise)
 644{
 645        int err;
 646        u8 val[SI4713_TXSTATUS_NRESP];
 647        /*
 648         *      .First byte = intack bit
 649         */
 650        const u8 args[SI4713_TXSTATUS_NARGS] = {
 651                intack & SI4713_INTACK_MASK,
 652        };
 653
 654        err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_STATUS,
 655                                  args, ARRAY_SIZE(args), val,
 656                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 657
 658        if (!err) {
 659                v4l2_dbg(1, debug, &sdev->sd,
 660                        "%s: status=0x%02x\n", __func__, val[0]);
 661                *frequency = compose_u16(val[2], val[3]);
 662                sdev->frequency = *frequency;
 663                *power = val[5];
 664                *antcap = val[6];
 665                *noise = val[7];
 666                v4l2_dbg(1, debug, &sdev->sd, "%s: response: %d x 10 kHz "
 667                                "(power %d, antcap %d, rnl %d)\n", __func__,
 668                                *frequency, *power, *antcap, *noise);
 669        }
 670
 671        return err;
 672}
 673
 674/*
 675 * si4713_tx_rds_buff - Loads the RDS group buffer FIFO or circular buffer.
 676 * @sdev: si4713_device structure for the device we are communicating
 677 * @mode: the buffer operation mode.
 678 * @rdsb: RDS Block B
 679 * @rdsc: RDS Block C
 680 * @rdsd: RDS Block D
 681 * @cbleft: returns the number of available circular buffer blocks minus the
 682 *          number of used circular buffer blocks.
 683 */
 684static int si4713_tx_rds_buff(struct si4713_device *sdev, u8 mode, u16 rdsb,
 685                                u16 rdsc, u16 rdsd, s8 *cbleft)
 686{
 687        int err;
 688        u8 val[SI4713_RDSBUFF_NRESP];
 689
 690        const u8 args[SI4713_RDSBUFF_NARGS] = {
 691                mode & SI4713_RDSBUFF_MODE_MASK,
 692                msb(rdsb),
 693                lsb(rdsb),
 694                msb(rdsc),
 695                lsb(rdsc),
 696                msb(rdsd),
 697                lsb(rdsd),
 698        };
 699
 700        err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_BUFF,
 701                                  args, ARRAY_SIZE(args), val,
 702                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 703
 704        if (!err) {
 705                v4l2_dbg(1, debug, &sdev->sd,
 706                        "%s: status=0x%02x\n", __func__, val[0]);
 707                *cbleft = (s8)val[2] - val[3];
 708                v4l2_dbg(1, debug, &sdev->sd, "%s: response: interrupts"
 709                                " 0x%02x cb avail: %d cb used %d fifo avail"
 710                                " %d fifo used %d\n", __func__, val[1],
 711                                val[2], val[3], val[4], val[5]);
 712        }
 713
 714        return err;
 715}
 716
 717/*
 718 * si4713_tx_rds_ps - Loads the program service buffer.
 719 * @sdev: si4713_device structure for the device we are communicating
 720 * @psid: program service id to be loaded.
 721 * @pschar: assumed 4 size char array to be loaded into the program service
 722 */
 723static int si4713_tx_rds_ps(struct si4713_device *sdev, u8 psid,
 724                                unsigned char *pschar)
 725{
 726        int err;
 727        u8 val[SI4713_RDSPS_NRESP];
 728
 729        const u8 args[SI4713_RDSPS_NARGS] = {
 730                psid & SI4713_RDSPS_PSID_MASK,
 731                pschar[0],
 732                pschar[1],
 733                pschar[2],
 734                pschar[3],
 735        };
 736
 737        err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_PS,
 738                                  args, ARRAY_SIZE(args), val,
 739                                  ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 740
 741        if (err < 0)
 742                return err;
 743
 744        v4l2_dbg(1, debug, &sdev->sd, "%s: status=0x%02x\n", __func__, val[0]);
 745
 746        return err;
 747}
 748
 749static int si4713_set_power_state(struct si4713_device *sdev, u8 value)
 750{
 751        int rval;
 752
 753        mutex_lock(&sdev->mutex);
 754
 755        if (value)
 756                rval = si4713_powerup(sdev);
 757        else
 758                rval = si4713_powerdown(sdev);
 759
 760        mutex_unlock(&sdev->mutex);
 761        return rval;
 762}
 763
 764static int si4713_set_mute(struct si4713_device *sdev, u16 mute)
 765{
 766        int rval = 0;
 767
 768        mute = set_mute(mute);
 769
 770        mutex_lock(&sdev->mutex);
 771
 772        if (sdev->power_state)
 773                rval = si4713_write_property(sdev,
 774                                SI4713_TX_LINE_INPUT_MUTE, mute);
 775
 776        if (rval >= 0)
 777                sdev->mute = get_mute(mute);
 778
 779        mutex_unlock(&sdev->mutex);
 780
 781        return rval;
 782}
 783
 784static int si4713_set_rds_ps_name(struct si4713_device *sdev, char *ps_name)
 785{
 786        int rval = 0, i;
 787        u8 len = 0;
 788
 789        /* We want to clear the whole thing */
 790        if (!strlen(ps_name))
 791                memset(ps_name, 0, MAX_RDS_PS_NAME + 1);
 792
 793        mutex_lock(&sdev->mutex);
 794
 795        if (sdev->power_state) {
 796                /* Write the new ps name and clear the padding */
 797                for (i = 0; i < MAX_RDS_PS_NAME; i += (RDS_BLOCK / 2)) {
 798                        rval = si4713_tx_rds_ps(sdev, (i / (RDS_BLOCK / 2)),
 799                                                ps_name + i);
 800                        if (rval < 0)
 801                                goto unlock;
 802                }
 803
 804                /* Setup the size to be sent */
 805                if (strlen(ps_name))
 806                        len = strlen(ps_name) - 1;
 807                else
 808                        len = 1;
 809
 810                rval = si4713_write_property(sdev,
 811                                SI4713_TX_RDS_PS_MESSAGE_COUNT,
 812                                rds_ps_nblocks(len));
 813                if (rval < 0)
 814                        goto unlock;
 815
 816                rval = si4713_write_property(sdev,
 817                                SI4713_TX_RDS_PS_REPEAT_COUNT,
 818                                DEFAULT_RDS_PS_REPEAT_COUNT * 2);
 819                if (rval < 0)
 820                        goto unlock;
 821        }
 822
 823        strncpy(sdev->rds_info.ps_name, ps_name, MAX_RDS_PS_NAME);
 824
 825unlock:
 826        mutex_unlock(&sdev->mutex);
 827        return rval;
 828}
 829
 830static int si4713_set_rds_radio_text(struct si4713_device *sdev, char *rt)
 831{
 832        int rval = 0, i;
 833        u16 t_index = 0;
 834        u8 b_index = 0, cr_inserted = 0;
 835        s8 left;
 836
 837        mutex_lock(&sdev->mutex);
 838
 839        if (!sdev->power_state)
 840                goto copy;
 841
 842        rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_CLEAR, 0, 0, 0, &left);
 843        if (rval < 0)
 844                goto unlock;
 845
 846        if (!strlen(rt))
 847                goto copy;
 848
 849        do {
 850                /* RDS spec says that if the last block isn't used,
 851                 * then apply a carriage return
 852                 */
 853                if (t_index < (RDS_RADIOTEXT_INDEX_MAX *
 854                        RDS_RADIOTEXT_BLK_SIZE)) {
 855                        for (i = 0; i < RDS_RADIOTEXT_BLK_SIZE; i++) {
 856                                if (!rt[t_index + i] || rt[t_index + i] ==
 857                                        RDS_CARRIAGE_RETURN) {
 858                                        rt[t_index + i] = RDS_CARRIAGE_RETURN;
 859                                        cr_inserted = 1;
 860                                        break;
 861                                }
 862                        }
 863                }
 864
 865                rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_LOAD,
 866                                compose_u16(RDS_RADIOTEXT_2A, b_index++),
 867                                compose_u16(rt[t_index], rt[t_index + 1]),
 868                                compose_u16(rt[t_index + 2], rt[t_index + 3]),
 869                                &left);
 870                if (rval < 0)
 871                        goto unlock;
 872
 873                t_index += RDS_RADIOTEXT_BLK_SIZE;
 874
 875                if (cr_inserted)
 876                        break;
 877        } while (left > 0);
 878
 879copy:
 880        strncpy(sdev->rds_info.radio_text, rt, MAX_RDS_RADIO_TEXT);
 881
 882unlock:
 883        mutex_unlock(&sdev->mutex);
 884        return rval;
 885}
 886
 887static int si4713_choose_econtrol_action(struct si4713_device *sdev, u32 id,
 888                u32 **shadow, s32 *bit, s32 *mask, u16 *property, int *mul,
 889                unsigned long **table, int *size)
 890{
 891        s32 rval = 0;
 892
 893        switch (id) {
 894        /* FM_TX class controls */
 895        case V4L2_CID_RDS_TX_PI:
 896                *property = SI4713_TX_RDS_PI;
 897                *mul = 1;
 898                *shadow = &sdev->rds_info.pi;
 899                break;
 900        case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
 901                *property = SI4713_TX_ACOMP_THRESHOLD;
 902                *mul = 1;
 903                *shadow = &sdev->acomp_info.threshold;
 904                break;
 905        case V4L2_CID_AUDIO_COMPRESSION_GAIN:
 906                *property = SI4713_TX_ACOMP_GAIN;
 907                *mul = 1;
 908                *shadow = &sdev->acomp_info.gain;
 909                break;
 910        case V4L2_CID_PILOT_TONE_FREQUENCY:
 911                *property = SI4713_TX_PILOT_FREQUENCY;
 912                *mul = 1;
 913                *shadow = &sdev->pilot_info.frequency;
 914                break;
 915        case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
 916                *property = SI4713_TX_ACOMP_ATTACK_TIME;
 917                *mul = ATTACK_TIME_UNIT;
 918                *shadow = &sdev->acomp_info.attack_time;
 919                break;
 920        case V4L2_CID_PILOT_TONE_DEVIATION:
 921                *property = SI4713_TX_PILOT_DEVIATION;
 922                *mul = 10;
 923                *shadow = &sdev->pilot_info.deviation;
 924                break;
 925        case V4L2_CID_AUDIO_LIMITER_DEVIATION:
 926                *property = SI4713_TX_AUDIO_DEVIATION;
 927                *mul = 10;
 928                *shadow = &sdev->limiter_info.deviation;
 929                break;
 930        case V4L2_CID_RDS_TX_DEVIATION:
 931                *property = SI4713_TX_RDS_DEVIATION;
 932                *mul = 1;
 933                *shadow = &sdev->rds_info.deviation;
 934                break;
 935
 936        case V4L2_CID_RDS_TX_PTY:
 937                *property = SI4713_TX_RDS_PS_MISC;
 938                *bit = 5;
 939                *mask = 0x1F << 5;
 940                *shadow = &sdev->rds_info.pty;
 941                break;
 942        case V4L2_CID_AUDIO_LIMITER_ENABLED:
 943                *property = SI4713_TX_ACOMP_ENABLE;
 944                *bit = 1;
 945                *mask = 1 << 1;
 946                *shadow = &sdev->limiter_info.enabled;
 947                break;
 948        case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
 949                *property = SI4713_TX_ACOMP_ENABLE;
 950                *bit = 0;
 951                *mask = 1 << 0;
 952                *shadow = &sdev->acomp_info.enabled;
 953                break;
 954        case V4L2_CID_PILOT_TONE_ENABLED:
 955                *property = SI4713_TX_COMPONENT_ENABLE;
 956                *bit = 0;
 957                *mask = 1 << 0;
 958                *shadow = &sdev->pilot_info.enabled;
 959                break;
 960
 961        case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
 962                *property = SI4713_TX_LIMITER_RELEASE_TIME;
 963                *table = limiter_times;
 964                *size = ARRAY_SIZE(limiter_times);
 965                *shadow = &sdev->limiter_info.release_time;
 966                break;
 967        case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
 968                *property = SI4713_TX_ACOMP_RELEASE_TIME;
 969                *table = acomp_rtimes;
 970                *size = ARRAY_SIZE(acomp_rtimes);
 971                *shadow = &sdev->acomp_info.release_time;
 972                break;
 973        case V4L2_CID_TUNE_PREEMPHASIS:
 974                *property = SI4713_TX_PREEMPHASIS;
 975                *table = preemphasis_values;
 976                *size = ARRAY_SIZE(preemphasis_values);
 977                *shadow = &sdev->preemphasis;
 978                break;
 979
 980        default:
 981                rval = -EINVAL;
 982        };
 983
 984        return rval;
 985}
 986
 987static int si4713_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc);
 988
 989/* write string property */
 990static int si4713_write_econtrol_string(struct si4713_device *sdev,
 991                                struct v4l2_ext_control *control)
 992{
 993        struct v4l2_queryctrl vqc;
 994        int len;
 995        s32 rval = 0;
 996
 997        vqc.id = control->id;
 998        rval = si4713_queryctrl(&sdev->sd, &vqc);
 999        if (rval < 0)
1000                goto exit;
1001
1002        switch (control->id) {
1003        case V4L2_CID_RDS_TX_PS_NAME: {
1004                char ps_name[MAX_RDS_PS_NAME + 1];
1005
1006                len = control->size - 1;
1007                if (len > MAX_RDS_PS_NAME) {
1008                        rval = -ERANGE;
1009                        goto exit;
1010                }
1011                rval = copy_from_user(ps_name, control->string, len);
1012                if (rval < 0)
1013                        goto exit;
1014                ps_name[len] = '\0';
1015
1016                if (strlen(ps_name) % vqc.step) {
1017                        rval = -ERANGE;
1018                        goto exit;
1019                }
1020
1021                rval = si4713_set_rds_ps_name(sdev, ps_name);
1022        }
1023                break;
1024
1025        case V4L2_CID_RDS_TX_RADIO_TEXT: {
1026                char radio_text[MAX_RDS_RADIO_TEXT + 1];
1027
1028                len = control->size - 1;
1029                if (len > MAX_RDS_RADIO_TEXT) {
1030                        rval = -ERANGE;
1031                        goto exit;
1032                }
1033                rval = copy_from_user(radio_text, control->string, len);
1034                if (rval < 0)
1035                        goto exit;
1036                radio_text[len] = '\0';
1037
1038                if (strlen(radio_text) % vqc.step) {
1039                        rval = -ERANGE;
1040                        goto exit;
1041                }
1042
1043                rval = si4713_set_rds_radio_text(sdev, radio_text);
1044        }
1045                break;
1046
1047        default:
1048                rval = -EINVAL;
1049                break;
1050        };
1051
1052exit:
1053        return rval;
1054}
1055
1056static int validate_range(struct v4l2_subdev *sd,
1057                                        struct v4l2_ext_control *control)
1058{
1059        struct v4l2_queryctrl vqc;
1060        int rval;
1061
1062        vqc.id = control->id;
1063        rval = si4713_queryctrl(sd, &vqc);
1064        if (rval < 0)
1065                goto exit;
1066
1067        if (control->value < vqc.minimum || control->value > vqc.maximum)
1068                rval = -ERANGE;
1069
1070exit:
1071        return rval;
1072}
1073
1074/* properties which use tx_tune_power*/
1075static int si4713_write_econtrol_tune(struct si4713_device *sdev,
1076                                struct v4l2_ext_control *control)
1077{
1078        s32 rval = 0;
1079        u8 power, antcap;
1080
1081        rval = validate_range(&sdev->sd, control);
1082        if (rval < 0)
1083                goto exit;
1084
1085        mutex_lock(&sdev->mutex);
1086
1087        switch (control->id) {
1088        case V4L2_CID_TUNE_POWER_LEVEL:
1089                power = control->value;
1090                antcap = sdev->antenna_capacitor;
1091                break;
1092        case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1093                power = sdev->power_level;
1094                antcap = control->value;
1095                break;
1096        default:
1097                rval = -EINVAL;
1098                goto unlock;
1099        };
1100
1101        if (sdev->power_state)
1102                rval = si4713_tx_tune_power(sdev, power, antcap);
1103
1104        if (rval == 0) {
1105                sdev->power_level = power;
1106                sdev->antenna_capacitor = antcap;
1107        }
1108
1109unlock:
1110        mutex_unlock(&sdev->mutex);
1111exit:
1112        return rval;
1113}
1114
1115static int si4713_write_econtrol_integers(struct si4713_device *sdev,
1116                                        struct v4l2_ext_control *control)
1117{
1118        s32 rval;
1119        u32 *shadow = NULL, val = 0;
1120        s32 bit = 0, mask = 0;
1121        u16 property = 0;
1122        int mul = 0;
1123        unsigned long *table = NULL;
1124        int size = 0;
1125
1126        rval = validate_range(&sdev->sd, control);
1127        if (rval < 0)
1128                goto exit;
1129
1130        rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1131                        &mask, &property, &mul, &table, &size);
1132        if (rval < 0)
1133                goto exit;
1134
1135        val = control->value;
1136        if (mul) {
1137                val = control->value / mul;
1138        } else if (table) {
1139                rval = usecs_to_dev(control->value, table, size);
1140                if (rval < 0)
1141                        goto exit;
1142                val = rval;
1143                rval = 0;
1144        }
1145
1146        mutex_lock(&sdev->mutex);
1147
1148        if (sdev->power_state) {
1149                if (mask) {
1150                        rval = si4713_read_property(sdev, property, &val);
1151                        if (rval < 0)
1152                                goto unlock;
1153                        val = set_bits(val, control->value, bit, mask);
1154                }
1155
1156                rval = si4713_write_property(sdev, property, val);
1157                if (rval < 0)
1158                        goto unlock;
1159                if (mask)
1160                        val = control->value;
1161        }
1162
1163        if (mul) {
1164                *shadow = val * mul;
1165        } else if (table) {
1166                rval = dev_to_usecs(val, table, size);
1167                if (rval < 0)
1168                        goto unlock;
1169                *shadow = rval;
1170                rval = 0;
1171        } else {
1172                *shadow = val;
1173        }
1174
1175unlock:
1176        mutex_unlock(&sdev->mutex);
1177exit:
1178        return rval;
1179}
1180
1181static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f);
1182static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *);
1183/*
1184 * si4713_setup - Sets the device up with current configuration.
1185 * @sdev: si4713_device structure for the device we are communicating
1186 */
1187static int si4713_setup(struct si4713_device *sdev)
1188{
1189        struct v4l2_ext_control ctrl;
1190        struct v4l2_frequency f;
1191        struct v4l2_modulator vm;
1192        struct si4713_device *tmp;
1193        int rval = 0;
1194
1195        tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
1196        if (!tmp)
1197                return -ENOMEM;
1198
1199        /* Get a local copy to avoid race */
1200        mutex_lock(&sdev->mutex);
1201        memcpy(tmp, sdev, sizeof(*sdev));
1202        mutex_unlock(&sdev->mutex);
1203
1204        ctrl.id = V4L2_CID_RDS_TX_PI;
1205        ctrl.value = tmp->rds_info.pi;
1206        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1207
1208        ctrl.id = V4L2_CID_AUDIO_COMPRESSION_THRESHOLD;
1209        ctrl.value = tmp->acomp_info.threshold;
1210        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1211
1212        ctrl.id = V4L2_CID_AUDIO_COMPRESSION_GAIN;
1213        ctrl.value = tmp->acomp_info.gain;
1214        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1215
1216        ctrl.id = V4L2_CID_PILOT_TONE_FREQUENCY;
1217        ctrl.value = tmp->pilot_info.frequency;
1218        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1219
1220        ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME;
1221        ctrl.value = tmp->acomp_info.attack_time;
1222        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1223
1224        ctrl.id = V4L2_CID_PILOT_TONE_DEVIATION;
1225        ctrl.value = tmp->pilot_info.deviation;
1226        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1227
1228        ctrl.id = V4L2_CID_AUDIO_LIMITER_DEVIATION;
1229        ctrl.value = tmp->limiter_info.deviation;
1230        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1231
1232        ctrl.id = V4L2_CID_RDS_TX_DEVIATION;
1233        ctrl.value = tmp->rds_info.deviation;
1234        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1235
1236        ctrl.id = V4L2_CID_RDS_TX_PTY;
1237        ctrl.value = tmp->rds_info.pty;
1238        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1239
1240        ctrl.id = V4L2_CID_AUDIO_LIMITER_ENABLED;
1241        ctrl.value = tmp->limiter_info.enabled;
1242        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1243
1244        ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ENABLED;
1245        ctrl.value = tmp->acomp_info.enabled;
1246        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1247
1248        ctrl.id = V4L2_CID_PILOT_TONE_ENABLED;
1249        ctrl.value = tmp->pilot_info.enabled;
1250        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1251
1252        ctrl.id = V4L2_CID_AUDIO_LIMITER_RELEASE_TIME;
1253        ctrl.value = tmp->limiter_info.release_time;
1254        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1255
1256        ctrl.id = V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME;
1257        ctrl.value = tmp->acomp_info.release_time;
1258        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1259
1260        ctrl.id = V4L2_CID_TUNE_PREEMPHASIS;
1261        ctrl.value = tmp->preemphasis;
1262        rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1263
1264        ctrl.id = V4L2_CID_RDS_TX_PS_NAME;
1265        rval |= si4713_set_rds_ps_name(sdev, tmp->rds_info.ps_name);
1266
1267        ctrl.id = V4L2_CID_RDS_TX_RADIO_TEXT;
1268        rval |= si4713_set_rds_radio_text(sdev, tmp->rds_info.radio_text);
1269
1270        /* Device procedure needs to set frequency first */
1271        f.frequency = tmp->frequency ? tmp->frequency : DEFAULT_FREQUENCY;
1272        f.frequency = si4713_to_v4l2(f.frequency);
1273        rval |= si4713_s_frequency(&sdev->sd, &f);
1274
1275        ctrl.id = V4L2_CID_TUNE_POWER_LEVEL;
1276        ctrl.value = tmp->power_level;
1277        rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1278
1279        ctrl.id = V4L2_CID_TUNE_ANTENNA_CAPACITOR;
1280        ctrl.value = tmp->antenna_capacitor;
1281        rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1282
1283        vm.index = 0;
1284        if (tmp->stereo)
1285                vm.txsubchans = V4L2_TUNER_SUB_STEREO;
1286        else
1287                vm.txsubchans = V4L2_TUNER_SUB_MONO;
1288        if (tmp->rds_info.enabled)
1289                vm.txsubchans |= V4L2_TUNER_SUB_RDS;
1290        si4713_s_modulator(&sdev->sd, &vm);
1291
1292        kfree(tmp);
1293
1294        return rval;
1295}
1296
1297/*
1298 * si4713_initialize - Sets the device up with default configuration.
1299 * @sdev: si4713_device structure for the device we are communicating
1300 */
1301static int si4713_initialize(struct si4713_device *sdev)
1302{
1303        int rval;
1304
1305        rval = si4713_set_power_state(sdev, POWER_ON);
1306        if (rval < 0)
1307                goto exit;
1308
1309        rval = si4713_checkrev(sdev);
1310        if (rval < 0)
1311                goto exit;
1312
1313        rval = si4713_set_power_state(sdev, POWER_OFF);
1314        if (rval < 0)
1315                goto exit;
1316
1317        mutex_lock(&sdev->mutex);
1318
1319        sdev->rds_info.pi = DEFAULT_RDS_PI;
1320        sdev->rds_info.pty = DEFAULT_RDS_PTY;
1321        sdev->rds_info.deviation = DEFAULT_RDS_DEVIATION;
1322        strlcpy(sdev->rds_info.ps_name, DEFAULT_RDS_PS_NAME, MAX_RDS_PS_NAME);
1323        strlcpy(sdev->rds_info.radio_text, DEFAULT_RDS_RADIO_TEXT,
1324                                                        MAX_RDS_RADIO_TEXT);
1325        sdev->rds_info.enabled = 1;
1326
1327        sdev->limiter_info.release_time = DEFAULT_LIMITER_RTIME;
1328        sdev->limiter_info.deviation = DEFAULT_LIMITER_DEV;
1329        sdev->limiter_info.enabled = 1;
1330
1331        sdev->pilot_info.deviation = DEFAULT_PILOT_DEVIATION;
1332        sdev->pilot_info.frequency = DEFAULT_PILOT_FREQUENCY;
1333        sdev->pilot_info.enabled = 1;
1334
1335        sdev->acomp_info.release_time = DEFAULT_ACOMP_RTIME;
1336        sdev->acomp_info.attack_time = DEFAULT_ACOMP_ATIME;
1337        sdev->acomp_info.threshold = DEFAULT_ACOMP_THRESHOLD;
1338        sdev->acomp_info.gain = DEFAULT_ACOMP_GAIN;
1339        sdev->acomp_info.enabled = 1;
1340
1341        sdev->frequency = DEFAULT_FREQUENCY;
1342        sdev->preemphasis = DEFAULT_PREEMPHASIS;
1343        sdev->mute = DEFAULT_MUTE;
1344        sdev->power_level = DEFAULT_POWER_LEVEL;
1345        sdev->antenna_capacitor = 0;
1346        sdev->stereo = 1;
1347        sdev->tune_rnl = DEFAULT_TUNE_RNL;
1348
1349        mutex_unlock(&sdev->mutex);
1350
1351exit:
1352        return rval;
1353}
1354
1355/* read string property */
1356static int si4713_read_econtrol_string(struct si4713_device *sdev,
1357                                struct v4l2_ext_control *control)
1358{
1359        s32 rval = 0;
1360
1361        switch (control->id) {
1362        case V4L2_CID_RDS_TX_PS_NAME:
1363                if (strlen(sdev->rds_info.ps_name) + 1 > control->size) {
1364                        control->size = MAX_RDS_PS_NAME + 1;
1365                        rval = -ENOSPC;
1366                        goto exit;
1367                }
1368                rval = copy_to_user(control->string, sdev->rds_info.ps_name,
1369                                        strlen(sdev->rds_info.ps_name) + 1);
1370                break;
1371
1372        case V4L2_CID_RDS_TX_RADIO_TEXT:
1373                if (strlen(sdev->rds_info.radio_text) + 1 > control->size) {
1374                        control->size = MAX_RDS_RADIO_TEXT + 1;
1375                        rval = -ENOSPC;
1376                        goto exit;
1377                }
1378                rval = copy_to_user(control->string, sdev->rds_info.radio_text,
1379                                        strlen(sdev->rds_info.radio_text) + 1);
1380                break;
1381
1382        default:
1383                rval = -EINVAL;
1384                break;
1385        };
1386
1387exit:
1388        return rval;
1389}
1390
1391/*
1392 * si4713_update_tune_status - update properties from tx_tune_status
1393 * command. Must be called with sdev->mutex held.
1394 * @sdev: si4713_device structure for the device we are communicating
1395 */
1396static int si4713_update_tune_status(struct si4713_device *sdev)
1397{
1398        int rval;
1399        u16 f = 0;
1400        u8 p = 0, a = 0, n = 0;
1401
1402        rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n);
1403
1404        if (rval < 0)
1405                goto exit;
1406
1407        sdev->power_level = p;
1408        sdev->antenna_capacitor = a;
1409        sdev->tune_rnl = n;
1410
1411exit:
1412        return rval;
1413}
1414
1415/* properties which use tx_tune_status */
1416static int si4713_read_econtrol_tune(struct si4713_device *sdev,
1417                                struct v4l2_ext_control *control)
1418{
1419        s32 rval = 0;
1420
1421        mutex_lock(&sdev->mutex);
1422
1423        if (sdev->power_state) {
1424                rval = si4713_update_tune_status(sdev);
1425                if (rval < 0)
1426                        goto unlock;
1427        }
1428
1429        switch (control->id) {
1430        case V4L2_CID_TUNE_POWER_LEVEL:
1431                control->value = sdev->power_level;
1432                break;
1433        case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1434                control->value = sdev->antenna_capacitor;
1435                break;
1436        default:
1437                rval = -EINVAL;
1438        };
1439
1440unlock:
1441        mutex_unlock(&sdev->mutex);
1442        return rval;
1443}
1444
1445static int si4713_read_econtrol_integers(struct si4713_device *sdev,
1446                                struct v4l2_ext_control *control)
1447{
1448        s32 rval;
1449        u32 *shadow = NULL, val = 0;
1450        s32 bit = 0, mask = 0;
1451        u16 property = 0;
1452        int mul = 0;
1453        unsigned long *table = NULL;
1454        int size = 0;
1455
1456        rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1457                        &mask, &property, &mul, &table, &size);
1458        if (rval < 0)
1459                goto exit;
1460
1461        mutex_lock(&sdev->mutex);
1462
1463        if (sdev->power_state) {
1464                rval = si4713_read_property(sdev, property, &val);
1465                if (rval < 0)
1466                        goto unlock;
1467
1468                /* Keep negative values for threshold */
1469                if (control->id == V4L2_CID_AUDIO_COMPRESSION_THRESHOLD)
1470                        *shadow = (s16)val;
1471                else if (mask)
1472                        *shadow = get_status_bit(val, bit, mask);
1473                else if (mul)
1474                        *shadow = val * mul;
1475                else
1476                        *shadow = dev_to_usecs(val, table, size);
1477        }
1478
1479        control->value = *shadow;
1480
1481unlock:
1482        mutex_unlock(&sdev->mutex);
1483exit:
1484        return rval;
1485}
1486
1487/*
1488 * Video4Linux Subdev Interface
1489 */
1490/* si4713_s_ext_ctrls - set extended controls value */
1491static int si4713_s_ext_ctrls(struct v4l2_subdev *sd,
1492                                struct v4l2_ext_controls *ctrls)
1493{
1494        struct si4713_device *sdev = to_si4713_device(sd);
1495        int i;
1496
1497        if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1498                return -EINVAL;
1499
1500        for (i = 0; i < ctrls->count; i++) {
1501                int err;
1502
1503                switch ((ctrls->controls + i)->id) {
1504                case V4L2_CID_RDS_TX_PS_NAME:
1505                case V4L2_CID_RDS_TX_RADIO_TEXT:
1506                        err = si4713_write_econtrol_string(sdev,
1507                                                        ctrls->controls + i);
1508                        break;
1509                case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1510                case V4L2_CID_TUNE_POWER_LEVEL:
1511                        err = si4713_write_econtrol_tune(sdev,
1512                                                        ctrls->controls + i);
1513                        break;
1514                default:
1515                        err = si4713_write_econtrol_integers(sdev,
1516                                                        ctrls->controls + i);
1517                }
1518
1519                if (err < 0) {
1520                        ctrls->error_idx = i;
1521                        return err;
1522                }
1523        }
1524
1525        return 0;
1526}
1527
1528/* si4713_g_ext_ctrls - get extended controls value */
1529static int si4713_g_ext_ctrls(struct v4l2_subdev *sd,
1530                                struct v4l2_ext_controls *ctrls)
1531{
1532        struct si4713_device *sdev = to_si4713_device(sd);
1533        int i;
1534
1535        if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1536                return -EINVAL;
1537
1538        for (i = 0; i < ctrls->count; i++) {
1539                int err;
1540
1541                switch ((ctrls->controls + i)->id) {
1542                case V4L2_CID_RDS_TX_PS_NAME:
1543                case V4L2_CID_RDS_TX_RADIO_TEXT:
1544                        err = si4713_read_econtrol_string(sdev,
1545                                                        ctrls->controls + i);
1546                        break;
1547                case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1548                case V4L2_CID_TUNE_POWER_LEVEL:
1549                        err = si4713_read_econtrol_tune(sdev,
1550                                                        ctrls->controls + i);
1551                        break;
1552                default:
1553                        err = si4713_read_econtrol_integers(sdev,
1554                                                        ctrls->controls + i);
1555                }
1556
1557                if (err < 0) {
1558                        ctrls->error_idx = i;
1559                        return err;
1560                }
1561        }
1562
1563        return 0;
1564}
1565
1566/* si4713_queryctrl - enumerate control items */
1567static int si4713_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1568{
1569        int rval = 0;
1570
1571        switch (qc->id) {
1572        /* User class controls */
1573        case V4L2_CID_AUDIO_MUTE:
1574                rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, DEFAULT_MUTE);
1575                break;
1576        /* FM_TX class controls */
1577        case V4L2_CID_RDS_TX_PI:
1578                rval = v4l2_ctrl_query_fill(qc, 0, 0xFFFF, 1, DEFAULT_RDS_PI);
1579                break;
1580        case V4L2_CID_RDS_TX_PTY:
1581                rval = v4l2_ctrl_query_fill(qc, 0, 31, 1, DEFAULT_RDS_PTY);
1582                break;
1583        case V4L2_CID_RDS_TX_DEVIATION:
1584                rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_DEVIATION,
1585                                                10, DEFAULT_RDS_DEVIATION);
1586                break;
1587        case V4L2_CID_RDS_TX_PS_NAME:
1588                /*
1589                 * Report step as 8. From RDS spec, psname
1590                 * should be 8. But there are receivers which scroll strings
1591                 * sized as 8xN.
1592                 */
1593                rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_PS_NAME, 8, 0);
1594                break;
1595        case V4L2_CID_RDS_TX_RADIO_TEXT:
1596                /*
1597                 * Report step as 32 (2A block). From RDS spec,
1598                 * radio text should be 32 for 2A block. But there are receivers
1599                 * which scroll strings sized as 32xN. Setting default to 32.
1600                 */
1601                rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1602                break;
1603
1604        case V4L2_CID_AUDIO_LIMITER_ENABLED:
1605                rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1606                break;
1607        case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1608                rval = v4l2_ctrl_query_fill(qc, 250, MAX_LIMITER_RELEASE_TIME,
1609                                                50, DEFAULT_LIMITER_RTIME);
1610                break;
1611        case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1612                rval = v4l2_ctrl_query_fill(qc, 0, MAX_LIMITER_DEVIATION,
1613                                                10, DEFAULT_LIMITER_DEV);
1614                break;
1615
1616        case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1617                rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1618                break;
1619        case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1620                rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_GAIN, 1,
1621                                                DEFAULT_ACOMP_GAIN);
1622                break;
1623        case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1624                rval = v4l2_ctrl_query_fill(qc, MIN_ACOMP_THRESHOLD,
1625                                                MAX_ACOMP_THRESHOLD, 1,
1626                                                DEFAULT_ACOMP_THRESHOLD);
1627                break;
1628        case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1629                rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_ATTACK_TIME,
1630                                                500, DEFAULT_ACOMP_ATIME);
1631                break;
1632        case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1633                rval = v4l2_ctrl_query_fill(qc, 100000, MAX_ACOMP_RELEASE_TIME,
1634                                                100000, DEFAULT_ACOMP_RTIME);
1635                break;
1636
1637        case V4L2_CID_PILOT_TONE_ENABLED:
1638                rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1639                break;
1640        case V4L2_CID_PILOT_TONE_DEVIATION:
1641                rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_DEVIATION,
1642                                                10, DEFAULT_PILOT_DEVIATION);
1643                break;
1644        case V4L2_CID_PILOT_TONE_FREQUENCY:
1645                rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_FREQUENCY,
1646                                                1, DEFAULT_PILOT_FREQUENCY);
1647                break;
1648
1649        case V4L2_CID_TUNE_PREEMPHASIS:
1650                rval = v4l2_ctrl_query_fill(qc, V4L2_PREEMPHASIS_DISABLED,
1651                                                V4L2_PREEMPHASIS_75_uS, 1,
1652                                                V4L2_PREEMPHASIS_50_uS);
1653                break;
1654        case V4L2_CID_TUNE_POWER_LEVEL:
1655                rval = v4l2_ctrl_query_fill(qc, 0, 120, 1, DEFAULT_POWER_LEVEL);
1656                break;
1657        case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1658                rval = v4l2_ctrl_query_fill(qc, 0, 191, 1, 0);
1659                break;
1660        default:
1661                rval = -EINVAL;
1662                break;
1663        };
1664
1665        return rval;
1666}
1667
1668/* si4713_g_ctrl - get the value of a control */
1669static int si4713_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1670{
1671        struct si4713_device *sdev = to_si4713_device(sd);
1672        int rval = 0;
1673
1674        if (!sdev)
1675                return -ENODEV;
1676
1677        mutex_lock(&sdev->mutex);
1678
1679        if (sdev->power_state) {
1680                rval = si4713_read_property(sdev, SI4713_TX_LINE_INPUT_MUTE,
1681                                                &sdev->mute);
1682
1683                if (rval < 0)
1684                        goto unlock;
1685        }
1686
1687        switch (ctrl->id) {
1688        case V4L2_CID_AUDIO_MUTE:
1689                ctrl->value = get_mute(sdev->mute);
1690                break;
1691        }
1692
1693unlock:
1694        mutex_unlock(&sdev->mutex);
1695        return rval;
1696}
1697
1698/* si4713_s_ctrl - set the value of a control */
1699static int si4713_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1700{
1701        struct si4713_device *sdev = to_si4713_device(sd);
1702        int rval = 0;
1703
1704        if (!sdev)
1705                return -ENODEV;
1706
1707        switch (ctrl->id) {
1708        case V4L2_CID_AUDIO_MUTE:
1709                if (ctrl->value) {
1710                        rval = si4713_set_mute(sdev, ctrl->value);
1711                        if (rval < 0)
1712                                goto exit;
1713
1714                        rval = si4713_set_power_state(sdev, POWER_DOWN);
1715                } else {
1716                        rval = si4713_set_power_state(sdev, POWER_UP);
1717                        if (rval < 0)
1718                                goto exit;
1719
1720                        rval = si4713_setup(sdev);
1721                        if (rval < 0)
1722                                goto exit;
1723
1724                        rval = si4713_set_mute(sdev, ctrl->value);
1725                }
1726                break;
1727        }
1728
1729exit:
1730        return rval;
1731}
1732
1733/* si4713_ioctl - deal with private ioctls (only rnl for now) */
1734long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1735{
1736        struct si4713_device *sdev = to_si4713_device(sd);
1737        struct si4713_rnl *rnl = arg;
1738        u16 frequency;
1739        int rval = 0;
1740
1741        if (!arg)
1742                return -EINVAL;
1743
1744        mutex_lock(&sdev->mutex);
1745        switch (cmd) {
1746        case SI4713_IOC_MEASURE_RNL:
1747                frequency = v4l2_to_si4713(rnl->frequency);
1748
1749                if (sdev->power_state) {
1750                        /* Set desired measurement frequency */
1751                        rval = si4713_tx_tune_measure(sdev, frequency, 0);
1752                        if (rval < 0)
1753                                goto unlock;
1754                        /* get results from tune status */
1755                        rval = si4713_update_tune_status(sdev);
1756                        if (rval < 0)
1757                                goto unlock;
1758                }
1759                rnl->rnl = sdev->tune_rnl;
1760                break;
1761
1762        default:
1763                /* nothing */
1764                rval = -ENOIOCTLCMD;
1765        }
1766
1767unlock:
1768        mutex_unlock(&sdev->mutex);
1769        return rval;
1770}
1771
1772static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1773        .queryctrl      = si4713_queryctrl,
1774        .g_ext_ctrls    = si4713_g_ext_ctrls,
1775        .s_ext_ctrls    = si4713_s_ext_ctrls,
1776        .g_ctrl         = si4713_g_ctrl,
1777        .s_ctrl         = si4713_s_ctrl,
1778        .ioctl          = si4713_ioctl,
1779};
1780
1781/* si4713_g_modulator - get modulator attributes */
1782static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1783{
1784        struct si4713_device *sdev = to_si4713_device(sd);
1785        int rval = 0;
1786
1787        if (!sdev) {
1788                rval = -ENODEV;
1789                goto exit;
1790        }
1791
1792        if (vm->index > 0) {
1793                rval = -EINVAL;
1794                goto exit;
1795        }
1796
1797        strncpy(vm->name, "FM Modulator", 32);
1798        vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1799                                                V4L2_TUNER_CAP_RDS;
1800
1801        /* Report current frequency range limits */
1802        vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1803        vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1804
1805        mutex_lock(&sdev->mutex);
1806
1807        if (sdev->power_state) {
1808                u32 comp_en = 0;
1809
1810                rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1811                                                &comp_en);
1812                if (rval < 0)
1813                        goto unlock;
1814
1815                sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1816                sdev->rds_info.enabled = get_status_bit(comp_en, 2, 1 << 2);
1817        }
1818
1819        /* Report current audio mode: mono or stereo */
1820        if (sdev->stereo)
1821                vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1822        else
1823                vm->txsubchans = V4L2_TUNER_SUB_MONO;
1824
1825        /* Report rds feature status */
1826        if (sdev->rds_info.enabled)
1827                vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1828        else
1829                vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1830
1831unlock:
1832        mutex_unlock(&sdev->mutex);
1833exit:
1834        return rval;
1835}
1836
1837/* si4713_s_modulator - set modulator attributes */
1838static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1839{
1840        struct si4713_device *sdev = to_si4713_device(sd);
1841        int rval = 0;
1842        u16 stereo, rds;
1843        u32 p;
1844
1845        if (!sdev)
1846                return -ENODEV;
1847
1848        if (vm->index > 0)
1849                return -EINVAL;
1850
1851        /* Set audio mode: mono or stereo */
1852        if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1853                stereo = 1;
1854        else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1855                stereo = 0;
1856        else
1857                return -EINVAL;
1858
1859        rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1860
1861        mutex_lock(&sdev->mutex);
1862
1863        if (sdev->power_state) {
1864                rval = si4713_read_property(sdev,
1865                                                SI4713_TX_COMPONENT_ENABLE, &p);
1866                if (rval < 0)
1867                        goto unlock;
1868
1869                p = set_bits(p, stereo, 1, 1 << 1);
1870                p = set_bits(p, rds, 2, 1 << 2);
1871
1872                rval = si4713_write_property(sdev,
1873                                                SI4713_TX_COMPONENT_ENABLE, p);
1874                if (rval < 0)
1875                        goto unlock;
1876        }
1877
1878        sdev->stereo = stereo;
1879        sdev->rds_info.enabled = rds;
1880
1881unlock:
1882        mutex_unlock(&sdev->mutex);
1883        return rval;
1884}
1885
1886/* si4713_g_frequency - get tuner or modulator radio frequency */
1887static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1888{
1889        struct si4713_device *sdev = to_si4713_device(sd);
1890        int rval = 0;
1891
1892        f->type = V4L2_TUNER_RADIO;
1893
1894        mutex_lock(&sdev->mutex);
1895
1896        if (sdev->power_state) {
1897                u16 freq;
1898                u8 p, a, n;
1899
1900                rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1901                if (rval < 0)
1902                        goto unlock;
1903
1904                sdev->frequency = freq;
1905        }
1906
1907        f->frequency = si4713_to_v4l2(sdev->frequency);
1908
1909unlock:
1910        mutex_unlock(&sdev->mutex);
1911        return rval;
1912}
1913
1914/* si4713_s_frequency - set tuner or modulator radio frequency */
1915static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1916{
1917        struct si4713_device *sdev = to_si4713_device(sd);
1918        int rval = 0;
1919        u16 frequency = v4l2_to_si4713(f->frequency);
1920
1921        /* Check frequency range */
1922        if (frequency < FREQ_RANGE_LOW || frequency > FREQ_RANGE_HIGH)
1923                return -EDOM;
1924
1925        mutex_lock(&sdev->mutex);
1926
1927        if (sdev->power_state) {
1928                rval = si4713_tx_tune_freq(sdev, frequency);
1929                if (rval < 0)
1930                        goto unlock;
1931                frequency = rval;
1932                rval = 0;
1933        }
1934        sdev->frequency = frequency;
1935        f->frequency = si4713_to_v4l2(frequency);
1936
1937unlock:
1938        mutex_unlock(&sdev->mutex);
1939        return rval;
1940}
1941
1942static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1943        .g_frequency    = si4713_g_frequency,
1944        .s_frequency    = si4713_s_frequency,
1945        .g_modulator    = si4713_g_modulator,
1946        .s_modulator    = si4713_s_modulator,
1947};
1948
1949static const struct v4l2_subdev_ops si4713_subdev_ops = {
1950        .core           = &si4713_subdev_core_ops,
1951        .tuner          = &si4713_subdev_tuner_ops,
1952};
1953
1954/*
1955 * I2C driver interface
1956 */
1957/* si4713_probe - probe for the device */
1958static int si4713_probe(struct i2c_client *client,
1959                                        const struct i2c_device_id *id)
1960{
1961        struct si4713_device *sdev;
1962        int rval;
1963
1964        sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
1965        if (!sdev) {
1966                dev_err(&client->dev, "Failed to alloc video device.\n");
1967                rval = -ENOMEM;
1968                goto exit;
1969        }
1970
1971        sdev->platform_data = client->dev.platform_data;
1972        if (!sdev->platform_data) {
1973                v4l2_err(&sdev->sd, "No platform data registered.\n");
1974                rval = -ENODEV;
1975                goto free_sdev;
1976        }
1977
1978        v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1979
1980        mutex_init(&sdev->mutex);
1981        init_completion(&sdev->work);
1982
1983        if (client->irq) {
1984                rval = request_irq(client->irq,
1985                        si4713_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED,
1986                        client->name, sdev);
1987                if (rval < 0) {
1988                        v4l2_err(&sdev->sd, "Could not request IRQ\n");
1989                        goto free_sdev;
1990                }
1991                v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1992        } else {
1993                v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1994        }
1995
1996        rval = si4713_initialize(sdev);
1997        if (rval < 0) {
1998                v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1999                goto free_irq;
2000        }
2001
2002        return 0;
2003
2004free_irq:
2005        if (client->irq)
2006                free_irq(client->irq, sdev);
2007free_sdev:
2008        kfree(sdev);
2009exit:
2010        return rval;
2011}
2012
2013/* si4713_remove - remove the device */
2014static int si4713_remove(struct i2c_client *client)
2015{
2016        struct v4l2_subdev *sd = i2c_get_clientdata(client);
2017        struct si4713_device *sdev = to_si4713_device(sd);
2018
2019        if (sdev->power_state)
2020                si4713_set_power_state(sdev, POWER_DOWN);
2021
2022        if (client->irq > 0)
2023                free_irq(client->irq, sdev);
2024
2025        v4l2_device_unregister_subdev(sd);
2026
2027        kfree(sdev);
2028
2029        return 0;
2030}
2031
2032/* si4713_i2c_driver - i2c driver interface */
2033static const struct i2c_device_id si4713_id[] = {
2034        { "si4713" , 0 },
2035        { },
2036};
2037MODULE_DEVICE_TABLE(i2c, si4713_id);
2038
2039static struct i2c_driver si4713_i2c_driver = {
2040        .driver         = {
2041                .name   = "si4713",
2042        },
2043        .probe          = si4713_probe,
2044        .remove         = si4713_remove,
2045        .id_table       = si4713_id,
2046};
2047
2048/* Module Interface */
2049static int __init si4713_module_init(void)
2050{
2051        return i2c_add_driver(&si4713_i2c_driver);
2052}
2053
2054static void __exit si4713_module_exit(void)
2055{
2056        i2c_del_driver(&si4713_i2c_driver);
2057}
2058
2059module_init(si4713_module_init);
2060module_exit(si4713_module_exit);
2061
2062