root/drivers/media/radio/si4713/si4713.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. usecs_to_dev
  2. si4713_handler
  3. si4713_send_command
  4. si4713_read_property
  5. si4713_write_property
  6. si4713_powerup
  7. si4713_powerdown
  8. si4713_checkrev
  9. si4713_wait_stc
  10. si4713_tx_tune_freq
  11. si4713_tx_tune_power
  12. si4713_tx_tune_measure
  13. si4713_tx_tune_status
  14. si4713_tx_rds_buff
  15. si4713_tx_rds_ps
  16. si4713_set_power_state
  17. si4713_set_mute
  18. si4713_set_rds_ps_name
  19. si4713_set_rds_radio_text
  20. si4713_update_tune_status
  21. si4713_choose_econtrol_action
  22. si4713_setup
  23. si4713_initialize
  24. si4713_s_ctrl
  25. si4713_ioctl
  26. si4713_g_modulator
  27. si4713_s_modulator
  28. si4713_g_frequency
  29. si4713_s_frequency
  30. si4713_probe
  31. si4713_remove

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

/* [<][>][^][v][top][bottom][index][help] */