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