kernel/drivers/media/radio/si4713/si4713.c

   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/completion.h>
  25 #include <linux/delay.h>
  26 #include <linux/err.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/i2c.h>
  29 #include <linux/slab.h>
  30 #include <linux/gpio.h>
  31 #include <linux/module.h>
  32 #include <media/v4l2-device.h>
  33 #include <media/v4l2-ioctl.h>
  34 #include <media/v4l2-common.h>
  35
  36 #include "si4713.h"
  37
  38 /* module parameters */
  39 static int debug;
  40 module_param(debug, int, S_IRUGO | S_IWUSR);
  41 MODULE_PARM_DESC(debug, "Debug level (0 - 2)");
  42
  43 MODULE_LICENSE("GPL");
  44 MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
  45 MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter");
  46 MODULE_VERSION("0.0.1");
  47
  48 #define DEFAULT_RDS_PI                  0x00
  49 #define DEFAULT_RDS_PTY                 0x00
  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
 104 #ifdef DEBUG
 105 #define DBG_BUFFER(device, message, buffer, size)                       \
 106         {                                                               \
 107                 int i;                                                  \
 108                 char str[(size)*5];                                     \
 109                 for (i = 0; i < size; i++)                              \
 110                         sprintf(str + i * 5, " 0x%02x", buffer[i]);     \
 111                 v4l2_dbg(2, debug, device, "%s:%s\n", message, str);    \
 112         }
 113 #else
 114 #define DBG_BUFFER(device, message, buffer, size)
 115 #endif
 116
 117 /*
 118  * Values for limiter release time (sorted by second column)
 119  *      device  release
 120  *      value   time (us)
 121  */
 122 static long limiter_times[] = {
 123         2000,   250,
 124         1000,   500,
 125         510,    1000,
 126         255,    2000,
 127         170,    3000,
 128         127,    4020,
 129         102,    5010,
 130         85,     6020,
 131         73,     7010,
 132         64,     7990,
 133         57,     8970,
 134         51,     10030,
 135         25,     20470,
 136         17,     30110,
 137         13,     39380,
 138         10,     51190,
 139         8,      63690,
 140         7,      73140,
 141         6,      85330,
 142         5,      102390,
 143 };
 144
 145 /*
 146  * Values for audio compression release time (sorted by second column)
 147  *      device  release
 148  *      value   time (us)
 149  */
 150 static unsigned long acomp_rtimes[] = {
 151         0,      100000,
 152         1,      200000,
 153         2,      350000,
 154         3,      525000,
 155         4,      1000000,
 156 };
 157
 158 /*
 159  * Values for preemphasis (sorted by second column)
 160  *      device  preemphasis
 161  *      value   value (v4l2)
 162  */
 163 static unsigned long preemphasis_values[] = {
 164         FMPE_DISABLED,  V4L2_PREEMPHASIS_DISABLED,
 165         FMPE_EU,        V4L2_PREEMPHASIS_50_uS,
 166         FMPE_USA,       V4L2_PREEMPHASIS_75_uS,
 167 };
 168
 169 static int usecs_to_dev(unsigned long usecs, unsigned long const array[],
 170                         int size)
 171 {
 172         int i;
 173         int rval = -EINVAL;
 174
 175         for (i = 0; i < size / 2; i++)
 176                 if (array[(i * 2) + 1] >= usecs) {
 177                         rval = array[i * 2];
 178                         break;
 179                 }
 180
 181         return rval;
 182 }
 183
 184 /* si4713_handler: IRQ handler, just complete work */
 185 static irqreturn_t si4713_handler(int irq, void *dev)
 186 {
 187         struct si4713_device *sdev = dev;
 188
 189         v4l2_dbg(2, debug, &sdev->sd,
 190                         "%s: sending signal to completion work.\n", __func__);
 191         complete(&sdev->work);
 192
 193         return IRQ_HANDLED;
 194 }
 195
 196 /*
 197  * si4713_send_command - sends a command to si4713 and waits its response
 198  * @sdev: si4713_device structure for the device we are communicating
 199  * @command: command id
 200  * @args: command arguments we are sending (up to 7)
 201  * @argn: actual size of @args
 202  * @response: buffer to place the expected response from the device (up to 15)
 203  * @respn: actual size of @response
 204  * @usecs: amount of time to wait before reading the response (in usecs)
 205  */
 206 static int si4713_send_command(struct si4713_device *sdev, const u8 command,
 207                                 const u8 args[], const int argn,
 208                                 u8 response[], const int respn, const int usecs)
 209 {
 210         struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 211         unsigned long until_jiffies;
 212         u8 data1[MAX_ARGS + 1];
 213         int err;
 214
 215         if (!client->adapter)
 216                 return -ENODEV;
 217
 218         /* First send the command and its arguments */
 219         data1[0] = command;
 220         memcpy(data1 + 1, args, argn);
 221         DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1);
 222
 223         err = i2c_master_send(client, data1, argn + 1);
 224         if (err != argn + 1) {
 225                 v4l2_err(&sdev->sd, "Error while sending command 0x%02x\n",
 226                         command);
 227                 return err < 0 ? err : -EIO;
 228         }
 229
 230         until_jiffies = jiffies + usecs_to_jiffies(usecs) + 1;
 231
 232         /* Wait response from interrupt */
 233         if (client->irq) {
 234                 if (!wait_for_completion_timeout(&sdev->work,
 235                                 usecs_to_jiffies(usecs) + 1))
 236                         v4l2_warn(&sdev->sd,
 237                                 "(%s) Device took too much time to answer.\n",
 238                                 __func__);
 239         }
 240
 241         do {
 242                 err = i2c_master_recv(client, response, respn);
 243                 if (err != respn) {
 244                         v4l2_err(&sdev->sd,
 245                                 "Error %d while reading response for command 0x%02x\n",
 246                                 err, command);
 247                         return err < 0 ? err : -EIO;
 248                 }
 249
 250                 DBG_BUFFER(&sdev->sd, "Response", response, respn);
 251                 if (!check_command_failed(response[0]))
 252                         return 0;
 253
 254                 if (client->irq)
 255                         return -EBUSY;
 256                 if (usecs <= 1000)
 257                         usleep_range(usecs, 1000);
 258                 else
 259                         usleep_range(1000, 2000);
 260         } while (time_is_after_jiffies(until_jiffies));
 261
 262         return -EBUSY;
 263 }
 264
 265 /*
 266  * si4713_read_property - reads a si4713 property
 267  * @sdev: si4713_device structure for the device we are communicating
 268  * @prop: property identification number
 269  * @pv: property value to be returned on success
 270  */
 271 static int si4713_read_property(struct si4713_device *sdev, u16 prop, u32 *pv)
 272 {
 273         int err;
 274         u8 val[SI4713_GET_PROP_NRESP];
 275         /*
 276          *      .First byte = 0
 277          *      .Second byte = property's MSB
 278          *      .Third byte = property's LSB
 279          */
 280         const u8 args[SI4713_GET_PROP_NARGS] = {
 281                 0x00,
 282                 msb(prop),
 283                 lsb(prop),
 284         };
 285
 286         err = si4713_send_command(sdev, SI4713_CMD_GET_PROPERTY,
 287                                   args, ARRAY_SIZE(args), val,
 288                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 289
 290         if (err < 0)
 291                 return err;
 292
 293         *pv = compose_u16(val[2], val[3]);
 294
 295         v4l2_dbg(1, debug, &sdev->sd,
 296                         "%s: property=0x%02x value=0x%02x status=0x%02x\n",
 297                         __func__, prop, *pv, val[0]);
 298
 299         return err;
 300 }
 301
 302 /*
 303  * si4713_write_property - modifies a si4713 property
 304  * @sdev: si4713_device structure for the device we are communicating
 305  * @prop: property identification number
 306  * @val: new value for that property
 307  */
 308 static int si4713_write_property(struct si4713_device *sdev, u16 prop, u16 val)
 309 {
 310         int rval;
 311         u8 resp[SI4713_SET_PROP_NRESP];
 312         /*
 313          *      .First byte = 0
 314          *      .Second byte = property's MSB
 315          *      .Third byte = property's LSB
 316          *      .Fourth byte = value's MSB
 317          *      .Fifth byte = value's LSB
 318          */
 319         const u8 args[SI4713_SET_PROP_NARGS] = {
 320                 0x00,
 321                 msb(prop),
 322                 lsb(prop),
 323                 msb(val),
 324                 lsb(val),
 325         };
 326
 327         rval = si4713_send_command(sdev, SI4713_CMD_SET_PROPERTY,
 328                                         args, ARRAY_SIZE(args),
 329                                         resp, ARRAY_SIZE(resp),
 330                                         DEFAULT_TIMEOUT);
 331
 332         if (rval < 0)
 333                 return rval;
 334
 335         v4l2_dbg(1, debug, &sdev->sd,
 336                         "%s: property=0x%02x value=0x%02x status=0x%02x\n",
 337                         __func__, prop, val, resp[0]);
 338
 339         /*
 340          * As there is no command response for SET_PROPERTY,
 341          * wait Tcomp time to finish before proceed, in order
 342          * to have property properly set.
 343          */
 344         msleep(TIMEOUT_SET_PROPERTY);
 345
 346         return rval;
 347 }
 348
 349 /*
 350  * si4713_powerup - Powers the device up
 351  * @sdev: si4713_device structure for the device we are communicating
 352  */
 353 static int si4713_powerup(struct si4713_device *sdev)
 354 {
 355         struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 356         int err;
 357         u8 resp[SI4713_PWUP_NRESP];
 358         /*
 359          *      .First byte = Enabled interrupts and boot function
 360          *      .Second byte = Input operation mode
 361          */
 362         u8 args[SI4713_PWUP_NARGS] = {
 363                 SI4713_PWUP_GPO2OEN | SI4713_PWUP_FUNC_TX,
 364                 SI4713_PWUP_OPMOD_ANALOG,
 365         };
 366
 367         if (sdev->power_state)
 368                 return 0;
 369
 370         if (sdev->vdd) {
 371                 err = regulator_enable(sdev->vdd);
 372                 if (err) {
 373                         v4l2_err(&sdev->sd, "Failed to enable vdd: %d\n", err);
 374                         return err;
 375                 }
 376         }
 377
 378         if (sdev->vio) {
 379                 err = regulator_enable(sdev->vio);
 380                 if (err) {
 381                         v4l2_err(&sdev->sd, "Failed to enable vio: %d\n", err);
 382                         return err;
 383                 }
 384         }
 385
 386         if (sdev->gpio_reset) {
 387                 udelay(50);
 388                 gpiod_set_value(sdev->gpio_reset, 1);
 389         }
 390
 391         if (client->irq)
 392                 args[0] |= SI4713_PWUP_CTSIEN;
 393
 394         err = si4713_send_command(sdev, SI4713_CMD_POWER_UP,
 395                                         args, ARRAY_SIZE(args),
 396                                         resp, ARRAY_SIZE(resp),
 397                                         TIMEOUT_POWER_UP);
 398
 399         if (!err) {
 400                 v4l2_dbg(1, debug, &sdev->sd, "Powerup response: 0x%02x\n",
 401                                 resp[0]);
 402                 v4l2_dbg(1, debug, &sdev->sd, "Device in power up mode\n");
 403                 sdev->power_state = POWER_ON;
 404
 405                 if (client->irq)
 406                         err = si4713_write_property(sdev, SI4713_GPO_IEN,
 407                                                 SI4713_STC_INT | SI4713_CTS);
 408                 return err;
 409         }
 410         gpiod_set_value(sdev->gpio_reset, 0);
 411
 412
 413         if (sdev->vdd) {
 414                 err = regulator_disable(sdev->vdd);
 415                 if (err)
 416                         v4l2_err(&sdev->sd, "Failed to disable vdd: %d\n", err);
 417         }
 418
 419         if (sdev->vio) {
 420                 err = regulator_disable(sdev->vio);
 421                 if (err)
 422                         v4l2_err(&sdev->sd, "Failed to disable vio: %d\n", err);
 423         }
 424
 425         return err;
 426 }
 427
 428 /*
 429  * si4713_powerdown - Powers the device down
 430  * @sdev: si4713_device structure for the device we are communicating
 431  */
 432 static int si4713_powerdown(struct si4713_device *sdev)
 433 {
 434         int err;
 435         u8 resp[SI4713_PWDN_NRESP];
 436
 437         if (!sdev->power_state)
 438                 return 0;
 439
 440         err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN,
 441                                         NULL, 0,
 442                                         resp, ARRAY_SIZE(resp),
 443                                         DEFAULT_TIMEOUT);
 444
 445         if (!err) {
 446                 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
 447                                 resp[0]);
 448                 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
 449                 if (sdev->gpio_reset)
 450                         gpiod_set_value(sdev->gpio_reset, 0);
 451
 452                 if (sdev->vdd) {
 453                         err = regulator_disable(sdev->vdd);
 454                         if (err) {
 455                                 v4l2_err(&sdev->sd,
 456                                         "Failed to disable vdd: %d\n", err);
 457                         }
 458                 }
 459
 460                 if (sdev->vio) {
 461                         err = regulator_disable(sdev->vio);
 462                         if (err) {
 463                                 v4l2_err(&sdev->sd,
 464                                         "Failed to disable vio: %d\n", err);
 465                         }
 466                 }
 467                 sdev->power_state = POWER_OFF;
 468         }
 469
 470         return err;
 471 }
 472
 473 /*
 474  * si4713_checkrev - Checks if we are treating a device with the correct rev.
 475  * @sdev: si4713_device structure for the device we are communicating
 476  */
 477 static int si4713_checkrev(struct si4713_device *sdev)
 478 {
 479         struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 480         int rval;
 481         u8 resp[SI4713_GETREV_NRESP];
 482
 483         rval = si4713_send_command(sdev, SI4713_CMD_GET_REV,
 484                                         NULL, 0,
 485                                         resp, ARRAY_SIZE(resp),
 486                                         DEFAULT_TIMEOUT);
 487
 488         if (rval < 0)
 489                 return rval;
 490
 491         if (resp[1] == SI4713_PRODUCT_NUMBER) {
 492                 v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)\n",
 493                                 client->addr << 1, client->adapter->name);
 494         } else {
 495                 v4l2_err(&sdev->sd, "Invalid product number 0x%X\n", resp[1]);
 496                 rval = -EINVAL;
 497         }
 498         return rval;
 499 }
 500
 501 /*
 502  * si4713_wait_stc - Waits STC interrupt and clears status bits. Useful
 503  *                   for TX_TUNE_POWER, TX_TUNE_FREQ and TX_TUNE_MEAS
 504  * @sdev: si4713_device structure for the device we are communicating
 505  * @usecs: timeout to wait for STC interrupt signal
 506  */
 507 static int si4713_wait_stc(struct si4713_device *sdev, const int usecs)
 508 {
 509         struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
 510         u8 resp[SI4713_GET_STATUS_NRESP];
 511         unsigned long start_jiffies = jiffies;
 512         int err;
 513
 514         if (client->irq &&
 515             !wait_for_completion_timeout(&sdev->work, usecs_to_jiffies(usecs) + 1))
 516                 v4l2_warn(&sdev->sd,
 517                         "(%s) Device took too much time to answer.\n", __func__);
 518
 519         for (;;) {
 520                 /* Clear status bits */
 521                 err = si4713_send_command(sdev, SI4713_CMD_GET_INT_STATUS,
 522                                 NULL, 0,
 523                                 resp, ARRAY_SIZE(resp),
 524                                 DEFAULT_TIMEOUT);
 525                 /* The USB device returns errors when it waits for the
 526                  * STC bit to be set. Hence polling */
 527                 if (err >= 0) {
 528                         v4l2_dbg(1, debug, &sdev->sd,
 529                                 "%s: status bits: 0x%02x\n", __func__, resp[0]);
 530
 531                         if (resp[0] & SI4713_STC_INT)
 532                                 return 0;
 533                 }
 534                 if (jiffies_to_usecs(jiffies - start_jiffies) > usecs)
 535                         return err < 0 ? err : -EIO;
 536                 /* We sleep here for 3-4 ms in order to avoid flooding the device
 537                  * with USB requests. The si4713 USB driver was developed
 538                  * by reverse engineering the Windows USB driver. The windows
 539                  * driver also has a ~2.5 ms delay between responses. */
 540                 usleep_range(3000, 4000);
 541         }
 542 }
 543
 544 /*
 545  * si4713_tx_tune_freq - Sets the state of the RF carrier and sets the tuning
 546  *                      frequency between 76 and 108 MHz in 10 kHz units and
 547  *                      steps of 50 kHz.
 548  * @sdev: si4713_device structure for the device we are communicating
 549  * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
 550  */
 551 static int si4713_tx_tune_freq(struct si4713_device *sdev, u16 frequency)
 552 {
 553         int err;
 554         u8 val[SI4713_TXFREQ_NRESP];
 555         /*
 556          *      .First byte = 0
 557          *      .Second byte = frequency's MSB
 558          *      .Third byte = frequency's LSB
 559          */
 560         const u8 args[SI4713_TXFREQ_NARGS] = {
 561                 0x00,
 562                 msb(frequency),
 563                 lsb(frequency),
 564         };
 565
 566         err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_FREQ,
 567                                   args, ARRAY_SIZE(args), val,
 568                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 569
 570         if (err < 0)
 571                 return err;
 572
 573         v4l2_dbg(1, debug, &sdev->sd,
 574                         "%s: frequency=0x%02x status=0x%02x\n", __func__,
 575                         frequency, val[0]);
 576
 577         err = si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
 578         if (err < 0)
 579                 return err;
 580
 581         return compose_u16(args[1], args[2]);
 582 }
 583
 584 /*
 585  * si4713_tx_tune_power - Sets the RF voltage level between 88 and 120 dBuV in
 586  *                      1 dB units. A value of 0x00 indicates off. The command
 587  *                      also sets the antenna tuning capacitance. A value of 0
 588  *                      indicates autotuning, and a value of 1 - 191 indicates
 589  *                      a manual override, which results in a tuning
 590  *                      capacitance of 0.25 pF x @antcap.
 591  * @sdev: si4713_device structure for the device we are communicating
 592  * @power: tuning power (88 - 120 dBuV, unit/step 1 dB)
 593  * @antcap: value of antenna tuning capacitor (0 - 191)
 594  */
 595 static int si4713_tx_tune_power(struct si4713_device *sdev, u8 power,
 596                                 u8 antcap)
 597 {
 598         int err;
 599         u8 val[SI4713_TXPWR_NRESP];
 600         /*
 601          *      .First byte = 0
 602          *      .Second byte = 0
 603          *      .Third byte = power
 604          *      .Fourth byte = antcap
 605          */
 606         u8 args[SI4713_TXPWR_NARGS] = {
 607                 0x00,
 608                 0x00,
 609                 power,
 610                 antcap,
 611         };
 612
 613         /* Map power values 1-87 to MIN_POWER (88) */
 614         if (power > 0 && power < SI4713_MIN_POWER)
 615                 args[2] = power = SI4713_MIN_POWER;
 616
 617         err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_POWER,
 618                                   args, ARRAY_SIZE(args), val,
 619                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 620
 621         if (err < 0)
 622                 return err;
 623
 624         v4l2_dbg(1, debug, &sdev->sd,
 625                         "%s: power=0x%02x antcap=0x%02x status=0x%02x\n",
 626                         __func__, power, antcap, val[0]);
 627
 628         return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE_POWER);
 629 }
 630
 631 /*
 632  * si4713_tx_tune_measure - Enters receive mode and measures the received noise
 633  *                      level in units of dBuV on the selected frequency.
 634  *                      The Frequency must be between 76 and 108 MHz in 10 kHz
 635  *                      units and steps of 50 kHz. The command also sets the
 636  *                      antenna tuning capacitance. A value of 0 means
 637  *                      autotuning, and a value of 1 to 191 indicates manual
 638  *                      override.
 639  * @sdev: si4713_device structure for the device we are communicating
 640  * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
 641  * @antcap: value of antenna tuning capacitor (0 - 191)
 642  */
 643 static int si4713_tx_tune_measure(struct si4713_device *sdev, u16 frequency,
 644                                         u8 antcap)
 645 {
 646         int err;
 647         u8 val[SI4713_TXMEA_NRESP];
 648         /*
 649          *      .First byte = 0
 650          *      .Second byte = frequency's MSB
 651          *      .Third byte = frequency's LSB
 652          *      .Fourth byte = antcap
 653          */
 654         const u8 args[SI4713_TXMEA_NARGS] = {
 655                 0x00,
 656                 msb(frequency),
 657                 lsb(frequency),
 658                 antcap,
 659         };
 660
 661         sdev->tune_rnl = DEFAULT_TUNE_RNL;
 662
 663         if (antcap > SI4713_MAX_ANTCAP)
 664                 return -EDOM;
 665
 666         err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_MEASURE,
 667                                   args, ARRAY_SIZE(args), val,
 668                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 669
 670         if (err < 0)
 671                 return err;
 672
 673         v4l2_dbg(1, debug, &sdev->sd,
 674                         "%s: frequency=0x%02x antcap=0x%02x status=0x%02x\n",
 675                         __func__, frequency, antcap, val[0]);
 676
 677         return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
 678 }
 679
 680 /*
 681  * si4713_tx_tune_status- Returns the status of the tx_tune_freq, tx_tune_mea or
 682  *                      tx_tune_power commands. This command return the current
 683  *                      frequency, output voltage in dBuV, the antenna tunning
 684  *                      capacitance value and the received noise level. The
 685  *                      command also clears the stcint interrupt bit when the
 686  *                      first bit of its arguments is high.
 687  * @sdev: si4713_device structure for the device we are communicating
 688  * @intack: 0x01 to clear the seek/tune complete interrupt status indicator.
 689  * @frequency: returned frequency
 690  * @power: returned power
 691  * @antcap: returned antenna capacitance
 692  * @noise: returned noise level
 693  */
 694 static int si4713_tx_tune_status(struct si4713_device *sdev, u8 intack,
 695                                         u16 *frequency, u8 *power,
 696                                         u8 *antcap, u8 *noise)
 697 {
 698         int err;
 699         u8 val[SI4713_TXSTATUS_NRESP];
 700         /*
 701          *      .First byte = intack bit
 702          */
 703         const u8 args[SI4713_TXSTATUS_NARGS] = {
 704                 intack & SI4713_INTACK_MASK,
 705         };
 706
 707         err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_STATUS,
 708                                   args, ARRAY_SIZE(args), val,
 709                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 710
 711         if (!err) {
 712                 v4l2_dbg(1, debug, &sdev->sd,
 713                         "%s: status=0x%02x\n", __func__, val[0]);
 714                 *frequency = compose_u16(val[2], val[3]);
 715                 sdev->frequency = *frequency;
 716                 *power = val[5];
 717                 *antcap = val[6];
 718                 *noise = val[7];
 719                 v4l2_dbg(1, debug, &sdev->sd, "%s: response: %d x 10 kHz "
 720                                 "(power %d, antcap %d, rnl %d)\n", __func__,
 721                                 *frequency, *power, *antcap, *noise);
 722         }
 723
 724         return err;
 725 }
 726
 727 /*
 728  * si4713_tx_rds_buff - Loads the RDS group buffer FIFO or circular buffer.
 729  * @sdev: si4713_device structure for the device we are communicating
 730  * @mode: the buffer operation mode.
 731  * @rdsb: RDS Block B
 732  * @rdsc: RDS Block C
 733  * @rdsd: RDS Block D
 734  * @cbleft: returns the number of available circular buffer blocks minus the
 735  *          number of used circular buffer blocks.
 736  */
 737 static int si4713_tx_rds_buff(struct si4713_device *sdev, u8 mode, u16 rdsb,
 738                                 u16 rdsc, u16 rdsd, s8 *cbleft)
 739 {
 740         int err;
 741         u8 val[SI4713_RDSBUFF_NRESP];
 742
 743         const u8 args[SI4713_RDSBUFF_NARGS] = {
 744                 mode & SI4713_RDSBUFF_MODE_MASK,
 745                 msb(rdsb),
 746                 lsb(rdsb),
 747                 msb(rdsc),
 748                 lsb(rdsc),
 749                 msb(rdsd),
 750                 lsb(rdsd),
 751         };
 752
 753         err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_BUFF,
 754                                   args, ARRAY_SIZE(args), val,
 755                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 756
 757         if (!err) {
 758                 v4l2_dbg(1, debug, &sdev->sd,
 759                         "%s: status=0x%02x\n", __func__, val[0]);
 760                 *cbleft = (s8)val[2] - val[3];
 761                 v4l2_dbg(1, debug, &sdev->sd, "%s: response: interrupts"
 762                                 " 0x%02x cb avail: %d cb used %d fifo avail"
 763                                 " %d fifo used %d\n", __func__, val[1],
 764                                 val[2], val[3], val[4], val[5]);
 765         }
 766
 767         return err;
 768 }
 769
 770 /*
 771  * si4713_tx_rds_ps - Loads the program service buffer.
 772  * @sdev: si4713_device structure for the device we are communicating
 773  * @psid: program service id to be loaded.
 774  * @pschar: assumed 4 size char array to be loaded into the program service
 775  */
 776 static int si4713_tx_rds_ps(struct si4713_device *sdev, u8 psid,
 777                                 unsigned char *pschar)
 778 {
 779         int err;
 780         u8 val[SI4713_RDSPS_NRESP];
 781
 782         const u8 args[SI4713_RDSPS_NARGS] = {
 783                 psid & SI4713_RDSPS_PSID_MASK,
 784                 pschar[0],
 785                 pschar[1],
 786                 pschar[2],
 787                 pschar[3],
 788         };
 789
 790         err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_PS,
 791                                   args, ARRAY_SIZE(args), val,
 792                                   ARRAY_SIZE(val), DEFAULT_TIMEOUT);
 793
 794         if (err < 0)
 795                 return err;
 796
 797         v4l2_dbg(1, debug, &sdev->sd, "%s: status=0x%02x\n", __func__, val[0]);
 798
 799         return err;
 800 }
 801
 802 static int si4713_set_power_state(struct si4713_device *sdev, u8 value)
 803 {
 804         if (value)
 805                 return si4713_powerup(sdev);
 806         return si4713_powerdown(sdev);
 807 }
 808
 809 static int si4713_set_mute(struct si4713_device *sdev, u16 mute)
 810 {
 811         int rval = 0;
 812
 813         mute = set_mute(mute);
 814
 815         if (sdev->power_state)
 816                 rval = si4713_write_property(sdev,
 817                                 SI4713_TX_LINE_INPUT_MUTE, mute);
 818
 819         return rval;
 820 }
 821
 822 static int si4713_set_rds_ps_name(struct si4713_device *sdev, char *ps_name)
 823 {
 824         int rval = 0, i;
 825         u8 len = 0;
 826
 827         /* We want to clear the whole thing */
 828         if (!strlen(ps_name))
 829                 memset(ps_name, 0, MAX_RDS_PS_NAME + 1);
 830
 831         if (sdev->power_state) {
 832                 /* Write the new ps name and clear the padding */
 833                 for (i = 0; i < MAX_RDS_PS_NAME; i += (RDS_BLOCK / 2)) {
 834                         rval = si4713_tx_rds_ps(sdev, (i / (RDS_BLOCK / 2)),
 835                                                 ps_name + i);
 836                         if (rval < 0)
 837                                 return rval;
 838                 }
 839
 840                 /* Setup the size to be sent */
 841                 if (strlen(ps_name))
 842                         len = strlen(ps_name) - 1;
 843                 else
 844                         len = 1;
 845
 846                 rval = si4713_write_property(sdev,
 847                                 SI4713_TX_RDS_PS_MESSAGE_COUNT,
 848                                 rds_ps_nblocks(len));
 849                 if (rval < 0)
 850                         return rval;
 851
 852                 rval = si4713_write_property(sdev,
 853                                 SI4713_TX_RDS_PS_REPEAT_COUNT,
 854                                 DEFAULT_RDS_PS_REPEAT_COUNT * 2);
 855                 if (rval < 0)
 856                         return rval;
 857         }
 858
 859         return rval;
 860 }
 861
 862 static int si4713_set_rds_radio_text(struct si4713_device *sdev, const char *rt)
 863 {
 864         static const char cr[RDS_RADIOTEXT_BLK_SIZE] = { RDS_CARRIAGE_RETURN, 0 };
 865         int rval = 0, i;
 866         u16 t_index = 0;
 867         u8 b_index = 0, cr_inserted = 0;
 868         s8 left;
 869
 870         if (!sdev->power_state)
 871                 return rval;
 872
 873         rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_CLEAR, 0, 0, 0, &left);
 874         if (rval < 0)
 875                 return rval;
 876
 877         if (!strlen(rt))
 878                 return rval;
 879
 880         do {
 881                 /* RDS spec says that if the last block isn't used,
 882                  * then apply a carriage return
 883                  */
 884                 if (t_index < (RDS_RADIOTEXT_INDEX_MAX * RDS_RADIOTEXT_BLK_SIZE)) {
 885                         for (i = 0; i < RDS_RADIOTEXT_BLK_SIZE; i++) {
 886                                 if (!rt[t_index + i] ||
 887                                     rt[t_index + i] == RDS_CARRIAGE_RETURN) {
 888                                         rt = cr;
 889                                         cr_inserted = 1;
 890                                         break;
 891                                 }
 892                         }
 893                 }
 894
 895                 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_LOAD,
 896                                 compose_u16(RDS_RADIOTEXT_2A, b_index++),
 897                                 compose_u16(rt[t_index], rt[t_index + 1]),
 898                                 compose_u16(rt[t_index + 2], rt[t_index + 3]),
 899                                 &left);
 900                 if (rval < 0)
 901                         return rval;
 902
 903                 t_index += RDS_RADIOTEXT_BLK_SIZE;
 904
 905                 if (cr_inserted)
 906                         break;
 907         } while (left > 0);
 908
 909         return rval;
 910 }
 911
 912 /*
 913  * si4713_update_tune_status - update properties from tx_tune_status
 914  * command. Must be called with sdev->mutex held.
 915  * @sdev: si4713_device structure for the device we are communicating
 916  */
 917 static int si4713_update_tune_status(struct si4713_device *sdev)
 918 {
 919         int rval;
 920         u16 f = 0;
 921         u8 p = 0, a = 0, n = 0;
 922
 923         rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n);
 924
 925         if (rval < 0)
 926                 goto exit;
 927
 928 /*      TODO: check that power_level and antenna_capacitor really are not
 929         changed by the hardware. If they are, then these controls should become
 930         volatiles.
 931         sdev->power_level = p;
 932         sdev->antenna_capacitor = a;*/
 933         sdev->tune_rnl = n;
 934
 935 exit:
 936         return rval;
 937 }
 938
 939 static int si4713_choose_econtrol_action(struct si4713_device *sdev, u32 id,
 940                 s32 *bit, s32 *mask, u16 *property, int *mul,
 941                 unsigned long **table, int *size)
 942 {
 943         s32 rval = 0;
 944
 945         switch (id) {
 946         /* FM_TX class controls */
 947         case V4L2_CID_RDS_TX_PI:
 948                 *property = SI4713_TX_RDS_PI;
 949                 *mul = 1;
 950                 break;
 951         case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
 952                 *property = SI4713_TX_ACOMP_THRESHOLD;
 953                 *mul = 1;
 954                 break;
 955         case V4L2_CID_AUDIO_COMPRESSION_GAIN:
 956                 *property = SI4713_TX_ACOMP_GAIN;
 957                 *mul = 1;
 958                 break;
 959         case V4L2_CID_PILOT_TONE_FREQUENCY:
 960                 *property = SI4713_TX_PILOT_FREQUENCY;
 961                 *mul = 1;
 962                 break;
 963         case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
 964                 *property = SI4713_TX_ACOMP_ATTACK_TIME;
 965                 *mul = ATTACK_TIME_UNIT;
 966                 break;
 967         case V4L2_CID_PILOT_TONE_DEVIATION:
 968                 *property = SI4713_TX_PILOT_DEVIATION;
 969                 *mul = 10;
 970                 break;
 971         case V4L2_CID_AUDIO_LIMITER_DEVIATION:
 972                 *property = SI4713_TX_AUDIO_DEVIATION;
 973                 *mul = 10;
 974                 break;
 975         case V4L2_CID_RDS_TX_DEVIATION:
 976                 *property = SI4713_TX_RDS_DEVIATION;
 977                 *mul = 1;
 978                 break;
 979
 980         case V4L2_CID_RDS_TX_PTY:
 981                 *property = SI4713_TX_RDS_PS_MISC;
 982                 *bit = 5;
 983                 *mask = 0x1F << 5;
 984                 break;
 985         case V4L2_CID_RDS_TX_DYNAMIC_PTY:
 986                 *property = SI4713_TX_RDS_PS_MISC;
 987                 *bit = 15;
 988                 *mask = 1 << 15;
 989                 break;
 990         case V4L2_CID_RDS_TX_COMPRESSED:
 991                 *property = SI4713_TX_RDS_PS_MISC;
 992                 *bit = 14;
 993                 *mask = 1 << 14;
 994                 break;
 995         case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
 996                 *property = SI4713_TX_RDS_PS_MISC;
 997                 *bit = 13;
 998                 *mask = 1 << 13;
 999                 break;
1000         case V4L2_CID_RDS_TX_MONO_STEREO:
1001                 *property = SI4713_TX_RDS_PS_MISC;
1002                 *bit = 12;
1003                 *mask = 1 << 12;
1004                 break;
1005         case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1006                 *property = SI4713_TX_RDS_PS_MISC;
1007                 *bit = 10;
1008                 *mask = 1 << 10;
1009                 break;
1010         case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1011                 *property = SI4713_TX_RDS_PS_MISC;
1012                 *bit = 4;
1013                 *mask = 1 << 4;
1014                 break;
1015         case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1016                 *property = SI4713_TX_RDS_PS_MISC;
1017                 *bit = 3;
1018                 *mask = 1 << 3;
1019                 break;
1020         case V4L2_CID_AUDIO_LIMITER_ENABLED:
1021                 *property = SI4713_TX_ACOMP_ENABLE;
1022                 *bit = 1;
1023                 *mask = 1 << 1;
1024                 break;
1025         case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1026                 *property = SI4713_TX_ACOMP_ENABLE;
1027                 *bit = 0;
1028                 *mask = 1 << 0;
1029                 break;
1030         case V4L2_CID_PILOT_TONE_ENABLED:
1031                 *property = SI4713_TX_COMPONENT_ENABLE;
1032                 *bit = 0;
1033                 *mask = 1 << 0;
1034                 break;
1035
1036         case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1037                 *property = SI4713_TX_LIMITER_RELEASE_TIME;
1038                 *table = limiter_times;
1039                 *size = ARRAY_SIZE(limiter_times);
1040                 break;
1041         case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1042                 *property = SI4713_TX_ACOMP_RELEASE_TIME;
1043                 *table = acomp_rtimes;
1044                 *size = ARRAY_SIZE(acomp_rtimes);
1045                 break;
1046         case V4L2_CID_TUNE_PREEMPHASIS:
1047                 *property = SI4713_TX_PREEMPHASIS;
1048                 *table = preemphasis_values;
1049                 *size = ARRAY_SIZE(preemphasis_values);
1050                 break;
1051
1052         default:
1053                 rval = -EINVAL;
1054                 break;
1055         }
1056
1057         return rval;
1058 }
1059
1060 static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f);
1061 static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *);
1062 /*
1063  * si4713_setup - Sets the device up with current configuration.
1064  * @sdev: si4713_device structure for the device we are communicating
1065  */
1066 static int si4713_setup(struct si4713_device *sdev)
1067 {
1068         struct v4l2_frequency f;
1069         struct v4l2_modulator vm;
1070         int rval;
1071
1072         /* Device procedure needs to set frequency first */
1073         f.tuner = 0;
1074         f.frequency = sdev->frequency ? sdev->frequency : DEFAULT_FREQUENCY;
1075         f.frequency = si4713_to_v4l2(f.frequency);
1076         rval = si4713_s_frequency(&sdev->sd, &f);
1077
1078         vm.index = 0;
1079         if (sdev->stereo)
1080                 vm.txsubchans = V4L2_TUNER_SUB_STEREO;
1081         else
1082                 vm.txsubchans = V4L2_TUNER_SUB_MONO;
1083         if (sdev->rds_enabled)
1084                 vm.txsubchans |= V4L2_TUNER_SUB_RDS;
1085         si4713_s_modulator(&sdev->sd, &vm);
1086
1087         return rval;
1088 }
1089
1090 /*
1091  * si4713_initialize - Sets the device up with default configuration.
1092  * @sdev: si4713_device structure for the device we are communicating
1093  */
1094 static int si4713_initialize(struct si4713_device *sdev)
1095 {
1096         int rval;
1097
1098         rval = si4713_set_power_state(sdev, POWER_ON);
1099         if (rval < 0)
1100                 return rval;
1101
1102         rval = si4713_checkrev(sdev);
1103         if (rval < 0)
1104                 return rval;
1105
1106         rval = si4713_set_power_state(sdev, POWER_OFF);
1107         if (rval < 0)
1108                 return rval;
1109
1110         sdev->frequency = DEFAULT_FREQUENCY;
1111         sdev->stereo = 1;
1112         sdev->tune_rnl = DEFAULT_TUNE_RNL;
1113         return 0;
1114 }
1115
1116 /* si4713_s_ctrl - set the value of a control */
1117 static int si4713_s_ctrl(struct v4l2_ctrl *ctrl)
1118 {
1119         struct si4713_device *sdev =
1120                 container_of(ctrl->handler, struct si4713_device, ctrl_handler);
1121         u32 val = 0;
1122         s32 bit = 0, mask = 0;
1123         u16 property = 0;
1124         int mul = 0;
1125         unsigned long *table = NULL;
1126         int size = 0;
1127         bool force = false;
1128         int c;
1129         int ret = 0;
1130
1131         if (ctrl->id != V4L2_CID_AUDIO_MUTE)
1132                 return -EINVAL;
1133         if (ctrl->is_new) {
1134                 if (ctrl->val) {
1135                         ret = si4713_set_mute(sdev, ctrl->val);
1136                         if (!ret)
1137                                 ret = si4713_set_power_state(sdev, POWER_DOWN);
1138                         return ret;
1139                 }
1140                 ret = si4713_set_power_state(sdev, POWER_UP);
1141                 if (!ret)
1142                         ret = si4713_set_mute(sdev, ctrl->val);
1143                 if (!ret)
1144                         ret = si4713_setup(sdev);
1145                 if (ret)
1146                         return ret;
1147                 force = true;
1148         }
1149
1150         if (!sdev->power_state)
1151                 return 0;
1152
1153         for (c = 1; !ret && c < ctrl->ncontrols; c++) {
1154                 ctrl = ctrl->cluster[c];
1155
1156                 if (!force && !ctrl->is_new)
1157                         continue;
1158
1159                 switch (ctrl->id) {
1160                 case V4L2_CID_RDS_TX_PS_NAME:
1161                         ret = si4713_set_rds_ps_name(sdev, ctrl->p_new.p_char);
1162                         break;
1163
1164                 case V4L2_CID_RDS_TX_RADIO_TEXT:
1165                         ret = si4713_set_rds_radio_text(sdev, ctrl->p_new.p_char);
1166                         break;
1167
1168                 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1169                         /* don't handle this control if we force setting all
1170                          * controls since in that case it will be handled by
1171                          * V4L2_CID_TUNE_POWER_LEVEL. */
1172                         if (force)
1173                                 break;
1174                         /* fall through */
1175                 case V4L2_CID_TUNE_POWER_LEVEL:
1176                         ret = si4713_tx_tune_power(sdev,
1177                                 sdev->tune_pwr_level->val, sdev->tune_ant_cap->val);
1178                         if (!ret) {
1179                                 /* Make sure we don't set this twice */
1180                                 sdev->tune_ant_cap->is_new = false;
1181                                 sdev->tune_pwr_level->is_new = false;
1182                         }
1183                         break;
1184
1185                 case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1186                 case V4L2_CID_RDS_TX_ALT_FREQS:
1187                         if (sdev->rds_alt_freqs_enable->val) {
1188                                 val = sdev->rds_alt_freqs->p_new.p_u32[0];
1189                                 val = val / 100 - 876 + 0xe101;
1190                         } else {
1191                                 val = 0xe0e0;
1192                         }
1193                         ret = si4713_write_property(sdev, SI4713_TX_RDS_PS_AF, val);
1194                         break;
1195
1196                 default:
1197                         ret = si4713_choose_econtrol_action(sdev, ctrl->id, &bit,
1198                                         &mask, &property, &mul, &table, &size);
1199                         if (ret < 0)
1200                                 break;
1201
1202                         val = ctrl->val;
1203                         if (mul) {
1204                                 val = val / mul;
1205                         } else if (table) {
1206                                 ret = usecs_to_dev(val, table, size);
1207                                 if (ret < 0)
1208                                         break;
1209                                 val = ret;
1210                                 ret = 0;
1211                         }
1212
1213                         if (mask) {
1214                                 ret = si4713_read_property(sdev, property, &val);
1215                                 if (ret < 0)
1216                                         break;
1217                                 val = set_bits(val, ctrl->val, bit, mask);
1218                         }
1219
1220                         ret = si4713_write_property(sdev, property, val);
1221                         if (ret < 0)
1222                                 break;
1223                         if (mask)
1224                                 val = ctrl->val;
1225                         break;
1226                 }
1227         }
1228
1229         return ret;
1230 }
1231
1232 /* si4713_ioctl - deal with private ioctls (only rnl for now) */
1233 static long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1234 {
1235         struct si4713_device *sdev = to_si4713_device(sd);
1236         struct si4713_rnl *rnl = arg;
1237         u16 frequency;
1238         int rval = 0;
1239
1240         if (!arg)
1241                 return -EINVAL;
1242
1243         switch (cmd) {
1244         case SI4713_IOC_MEASURE_RNL:
1245                 frequency = v4l2_to_si4713(rnl->frequency);
1246
1247                 if (sdev->power_state) {
1248                         /* Set desired measurement frequency */
1249                         rval = si4713_tx_tune_measure(sdev, frequency, 0);
1250                         if (rval < 0)
1251                                 return rval;
1252                         /* get results from tune status */
1253                         rval = si4713_update_tune_status(sdev);
1254                         if (rval < 0)
1255                                 return rval;
1256                 }
1257                 rnl->rnl = sdev->tune_rnl;
1258                 break;
1259
1260         default:
1261                 /* nothing */
1262                 rval = -ENOIOCTLCMD;
1263         }
1264
1265         return rval;
1266 }
1267
1268 /* si4713_g_modulator - get modulator attributes */
1269 static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1270 {
1271         struct si4713_device *sdev = to_si4713_device(sd);
1272         int rval = 0;
1273
1274         if (!sdev)
1275                 return -ENODEV;
1276
1277         if (vm->index > 0)
1278                 return -EINVAL;
1279
1280         strncpy(vm->name, "FM Modulator", 32);
1281         vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1282                 V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_CONTROLS;
1283
1284         /* Report current frequency range limits */
1285         vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1286         vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1287
1288         if (sdev->power_state) {
1289                 u32 comp_en = 0;
1290
1291                 rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1292                                                 &comp_en);
1293                 if (rval < 0)
1294                         return rval;
1295
1296                 sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1297         }
1298
1299         /* Report current audio mode: mono or stereo */
1300         if (sdev->stereo)
1301                 vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1302         else
1303                 vm->txsubchans = V4L2_TUNER_SUB_MONO;
1304
1305         /* Report rds feature status */
1306         if (sdev->rds_enabled)
1307                 vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1308         else
1309                 vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1310
1311         return rval;
1312 }
1313
1314 /* si4713_s_modulator - set modulator attributes */
1315 static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *vm)
1316 {
1317         struct si4713_device *sdev = to_si4713_device(sd);
1318         int rval = 0;
1319         u16 stereo, rds;
1320         u32 p;
1321
1322         if (!sdev)
1323                 return -ENODEV;
1324
1325         if (vm->index > 0)
1326                 return -EINVAL;
1327
1328         /* Set audio mode: mono or stereo */
1329         if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1330                 stereo = 1;
1331         else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1332                 stereo = 0;
1333         else
1334                 return -EINVAL;
1335
1336         rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1337
1338         if (sdev->power_state) {
1339                 rval = si4713_read_property(sdev,
1340                                                 SI4713_TX_COMPONENT_ENABLE, &p);
1341                 if (rval < 0)
1342                         return rval;
1343
1344                 p = set_bits(p, stereo, 1, 1 << 1);
1345                 p = set_bits(p, rds, 2, 1 << 2);
1346
1347                 rval = si4713_write_property(sdev,
1348                                                 SI4713_TX_COMPONENT_ENABLE, p);
1349                 if (rval < 0)
1350                         return rval;
1351         }
1352
1353         sdev->stereo = stereo;
1354         sdev->rds_enabled = rds;
1355
1356         return rval;
1357 }
1358
1359 /* si4713_g_frequency - get tuner or modulator radio frequency */
1360 static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1361 {
1362         struct si4713_device *sdev = to_si4713_device(sd);
1363         int rval = 0;
1364
1365         if (f->tuner)
1366                 return -EINVAL;
1367
1368         if (sdev->power_state) {
1369                 u16 freq;
1370                 u8 p, a, n;
1371
1372                 rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1373                 if (rval < 0)
1374                         return rval;
1375
1376                 sdev->frequency = freq;
1377         }
1378
1379         f->frequency = si4713_to_v4l2(sdev->frequency);
1380
1381         return rval;
1382 }
1383
1384 /* si4713_s_frequency - set tuner or modulator radio frequency */
1385 static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1386 {
1387         struct si4713_device *sdev = to_si4713_device(sd);
1388         int rval = 0;
1389         u16 frequency = v4l2_to_si4713(f->frequency);
1390
1391         if (f->tuner)
1392                 return -EINVAL;
1393
1394         /* Check frequency range */
1395         frequency = clamp_t(u16, frequency, FREQ_RANGE_LOW, FREQ_RANGE_HIGH);
1396
1397         if (sdev->power_state) {
1398                 rval = si4713_tx_tune_freq(sdev, frequency);
1399                 if (rval < 0)
1400                         return rval;
1401                 frequency = rval;
1402                 rval = 0;
1403         }
1404         sdev->frequency = frequency;
1405
1406         return rval;
1407 }
1408
1409 static const struct v4l2_ctrl_ops si4713_ctrl_ops = {
1410         .s_ctrl = si4713_s_ctrl,
1411 };
1412
1413 static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1414         .ioctl          = si4713_ioctl,
1415 };
1416
1417 static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1418         .g_frequency    = si4713_g_frequency,
1419         .s_frequency    = si4713_s_frequency,
1420         .g_modulator    = si4713_g_modulator,
1421         .s_modulator    = si4713_s_modulator,
1422 };
1423
1424 static const struct v4l2_subdev_ops si4713_subdev_ops = {
1425         .core           = &si4713_subdev_core_ops,
1426         .tuner          = &si4713_subdev_tuner_ops,
1427 };
1428
1429 static const struct v4l2_ctrl_config si4713_alt_freqs_ctrl = {
1430         .id = V4L2_CID_RDS_TX_ALT_FREQS,
1431         .type = V4L2_CTRL_TYPE_U32,
1432         .min = 87600,
1433         .max = 107900,
1434         .step = 100,
1435         .def = 87600,
1436         .dims = { 1 },
1437         .elem_size = sizeof(u32),
1438 };
1439
1440 /*
1441  * I2C driver interface
1442  */
1443 /* si4713_probe - probe for the device */
1444 static int si4713_probe(struct i2c_client *client,
1445                                         const struct i2c_device_id *id)
1446 {
1447         struct si4713_device *sdev;
1448         struct v4l2_ctrl_handler *hdl;
1449         struct si4713_platform_data *pdata = client->dev.platform_data;
1450         struct device_node *np = client->dev.of_node;
1451         struct radio_si4713_platform_data si4713_pdev_pdata;
1452         struct platform_device *si4713_pdev;
1453         int rval;
1454
1455         sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
1456         if (!sdev) {
1457                 dev_err(&client->dev, "Failed to alloc video device.\n");
1458                 rval = -ENOMEM;
1459                 goto exit;
1460         }
1461
1462         sdev->gpio_reset = devm_gpiod_get_optional(&client->dev, "reset",
1463                                                    GPIOD_OUT_LOW);
1464         if (IS_ERR(sdev->gpio_reset)) {
1465                 rval = PTR_ERR(sdev->gpio_reset);
1466                 dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
1467                 goto exit;
1468         }
1469
1470         sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
1471         if (IS_ERR(sdev->vdd)) {
1472                 rval = PTR_ERR(sdev->vdd);
1473                 if (rval == -EPROBE_DEFER)
1474                         goto exit;
1475
1476                 dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
1477                 sdev->vdd = NULL;
1478         }
1479
1480         sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
1481         if (IS_ERR(sdev->vio)) {
1482                 rval = PTR_ERR(sdev->vio);
1483                 if (rval == -EPROBE_DEFER)
1484                         goto exit;
1485
1486                 dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
1487                 sdev->vio = NULL;
1488         }
1489
1490         v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1491
1492         init_completion(&sdev->work);
1493
1494         hdl = &sdev->ctrl_handler;
1495         v4l2_ctrl_handler_init(hdl, 20);
1496         sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1497                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
1498
1499         sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1500                         V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
1501         sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1502                         V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
1503         sdev->rds_compressed = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1504                         V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1505         sdev->rds_art_head = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1506                         V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1507         sdev->rds_stereo = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1508                         V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1509         sdev->rds_tp = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1510                         V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1511         sdev->rds_ta = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1512                         V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1513         sdev->rds_ms = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1514                         V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1515         sdev->rds_dyn_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1516                         V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1517         sdev->rds_alt_freqs_enable = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1518                         V4L2_CID_RDS_TX_ALT_FREQS_ENABLE, 0, 1, 1, 0);
1519         sdev->rds_alt_freqs = v4l2_ctrl_new_custom(hdl, &si4713_alt_freqs_ctrl, NULL);
1520         sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1521                         V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
1522                         10, DEFAULT_RDS_DEVIATION);
1523         /*
1524          * Report step as 8. From RDS spec, psname
1525          * should be 8. But there are receivers which scroll strings
1526          * sized as 8xN.
1527          */
1528         sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1529                         V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
1530         /*
1531          * Report step as 32 (2A block). From RDS spec,
1532          * radio text should be 32 for 2A block. But there are receivers
1533          * which scroll strings sized as 32xN. Setting default to 32.
1534          */
1535         sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1536                         V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1537
1538         sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1539                         V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
1540         sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1541                         V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
1542                         MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
1543         sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1544                         V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
1545                         MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
1546
1547         sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1548                         V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
1549         sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1550                         V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
1551                         DEFAULT_ACOMP_GAIN);
1552         sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1553                         V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
1554                         MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1,
1555                         DEFAULT_ACOMP_THRESHOLD);
1556         sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1557                         V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
1558                         MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
1559         sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1560                         V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
1561                         MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
1562
1563         sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1564                         V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
1565         sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1566                         V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
1567                         10, DEFAULT_PILOT_DEVIATION);
1568         sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1569                         V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1570                         1, DEFAULT_PILOT_FREQUENCY);
1571
1572         sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
1573                         V4L2_CID_TUNE_PREEMPHASIS,
1574                         V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
1575         sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1576                         V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER,
1577                         1, DEFAULT_POWER_LEVEL);
1578         sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1579                         V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP,
1580                         1, 0);
1581
1582         if (hdl->error) {
1583                 rval = hdl->error;
1584                 goto free_ctrls;
1585         }
1586         v4l2_ctrl_cluster(29, &sdev->mute);
1587         sdev->sd.ctrl_handler = hdl;
1588
1589         if (client->irq) {
1590                 rval = devm_request_irq(&client->dev, client->irq,
1591                         si4713_handler, IRQF_TRIGGER_FALLING,
1592                         client->name, sdev);
1593                 if (rval < 0) {
1594                         v4l2_err(&sdev->sd, "Could not request IRQ\n");
1595                         goto free_ctrls;
1596                 }
1597                 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1598         } else {
1599                 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1600         }
1601
1602         rval = si4713_initialize(sdev);
1603         if (rval < 0) {
1604                 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1605                 goto free_ctrls;
1606         }
1607
1608         if (!np && (!pdata || !pdata->is_platform_device))
1609                 return 0;
1610
1611         si4713_pdev = platform_device_alloc("radio-si4713", -1);
1612         if (!si4713_pdev)
1613                 goto put_main_pdev;
1614
1615         si4713_pdev_pdata.subdev = client;
1616         rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
1617                                         sizeof(si4713_pdev_pdata));
1618         if (rval)
1619                 goto put_main_pdev;
1620
1621         rval = platform_device_add(si4713_pdev);
1622         if (rval)
1623                 goto put_main_pdev;
1624
1625         sdev->pd = si4713_pdev;
1626
1627         return 0;
1628
1629 put_main_pdev:
1630         platform_device_put(si4713_pdev);
1631         v4l2_device_unregister_subdev(&sdev->sd);
1632 free_ctrls:
1633         v4l2_ctrl_handler_free(hdl);
1634 exit:
1635         return rval;
1636 }
1637
1638 /* si4713_remove - remove the device */
1639 static int si4713_remove(struct i2c_client *client)
1640 {
1641         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1642         struct si4713_device *sdev = to_si4713_device(sd);
1643
1644         platform_device_unregister(sdev->pd);
1645
1646         if (sdev->power_state)
1647                 si4713_set_power_state(sdev, POWER_DOWN);
1648
1649         v4l2_device_unregister_subdev(sd);
1650         v4l2_ctrl_handler_free(sd->ctrl_handler);
1651
1652         return 0;
1653 }
1654
1655 /* si4713_i2c_driver - i2c driver interface */
1656 static const struct i2c_device_id si4713_id[] = {
1657         { "si4713" , 0 },
1658         { },
1659 };
1660 MODULE_DEVICE_TABLE(i2c, si4713_id);
1661
1662 static struct i2c_driver si4713_i2c_driver = {
1663         .driver         = {
1664                 .name   = "si4713",
1665         },
1666         .probe          = si4713_probe,
1667         .remove         = si4713_remove,
1668         .id_table       = si4713_id,
1669 };
1670
1671 module_i2c_driver(si4713_i2c_driver);