treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / radio / si4713 / si4713.c
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                                         const struct i2c_device_id *id)
1432 {
1433         struct si4713_device *sdev;
1434         struct v4l2_ctrl_handler *hdl;
1435         struct si4713_platform_data *pdata = client->dev.platform_data;
1436         struct device_node *np = client->dev.of_node;
1437         struct radio_si4713_platform_data si4713_pdev_pdata;
1438         struct platform_device *si4713_pdev;
1439         int rval;
1440
1441         sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
1442         if (!sdev) {
1443                 dev_err(&client->dev, "Failed to alloc video device.\n");
1444                 rval = -ENOMEM;
1445                 goto exit;
1446         }
1447
1448         sdev->gpio_reset = devm_gpiod_get_optional(&client->dev, "reset",
1449                                                    GPIOD_OUT_LOW);
1450         if (IS_ERR(sdev->gpio_reset)) {
1451                 rval = PTR_ERR(sdev->gpio_reset);
1452                 dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
1453                 goto exit;
1454         }
1455
1456         sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
1457         if (IS_ERR(sdev->vdd)) {
1458                 rval = PTR_ERR(sdev->vdd);
1459                 if (rval == -EPROBE_DEFER)
1460                         goto exit;
1461
1462                 dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
1463                 sdev->vdd = NULL;
1464         }
1465
1466         sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
1467         if (IS_ERR(sdev->vio)) {
1468                 rval = PTR_ERR(sdev->vio);
1469                 if (rval == -EPROBE_DEFER)
1470                         goto exit;
1471
1472                 dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
1473                 sdev->vio = NULL;
1474         }
1475
1476         v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1477
1478         init_completion(&sdev->work);
1479
1480         hdl = &sdev->ctrl_handler;
1481         v4l2_ctrl_handler_init(hdl, 20);
1482         sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1483                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
1484
1485         sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1486                         V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
1487         sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1488                         V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
1489         sdev->rds_compressed = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1490                         V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1491         sdev->rds_art_head = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1492                         V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1493         sdev->rds_stereo = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1494                         V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1495         sdev->rds_tp = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1496                         V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1497         sdev->rds_ta = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1498                         V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1499         sdev->rds_ms = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1500                         V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1501         sdev->rds_dyn_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1502                         V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1503         sdev->rds_alt_freqs_enable = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1504                         V4L2_CID_RDS_TX_ALT_FREQS_ENABLE, 0, 1, 1, 0);
1505         sdev->rds_alt_freqs = v4l2_ctrl_new_custom(hdl, &si4713_alt_freqs_ctrl, NULL);
1506         sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1507                         V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
1508                         10, DEFAULT_RDS_DEVIATION);
1509         /*
1510          * Report step as 8. From RDS spec, psname
1511          * should be 8. But there are receivers which scroll strings
1512          * sized as 8xN.
1513          */
1514         sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1515                         V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
1516         /*
1517          * Report step as 32 (2A block). From RDS spec,
1518          * radio text should be 32 for 2A block. But there are receivers
1519          * which scroll strings sized as 32xN. Setting default to 32.
1520          */
1521         sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1522                         V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1523
1524         sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1525                         V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
1526         sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1527                         V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
1528                         MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
1529         sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1530                         V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
1531                         MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
1532
1533         sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1534                         V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
1535         sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1536                         V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
1537                         DEFAULT_ACOMP_GAIN);
1538         sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1539                         V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
1540                         MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1,
1541                         DEFAULT_ACOMP_THRESHOLD);
1542         sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1543                         V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
1544                         MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
1545         sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1546                         V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
1547                         MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
1548
1549         sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1550                         V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
1551         sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1552                         V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
1553                         10, DEFAULT_PILOT_DEVIATION);
1554         sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1555                         V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1556                         1, DEFAULT_PILOT_FREQUENCY);
1557
1558         sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
1559                         V4L2_CID_TUNE_PREEMPHASIS,
1560                         V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
1561         sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1562                         V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER,
1563                         1, DEFAULT_POWER_LEVEL);
1564         sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1565                         V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP,
1566                         1, 0);
1567
1568         if (hdl->error) {
1569                 rval = hdl->error;
1570                 goto free_ctrls;
1571         }
1572         v4l2_ctrl_cluster(29, &sdev->mute);
1573         sdev->sd.ctrl_handler = hdl;
1574
1575         if (client->irq) {
1576                 rval = devm_request_irq(&client->dev, client->irq,
1577                         si4713_handler, IRQF_TRIGGER_FALLING,
1578                         client->name, sdev);
1579                 if (rval < 0) {
1580                         v4l2_err(&sdev->sd, "Could not request IRQ\n");
1581                         goto free_ctrls;
1582                 }
1583                 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1584         } else {
1585                 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1586         }
1587
1588         rval = si4713_initialize(sdev);
1589         if (rval < 0) {
1590                 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1591                 goto free_ctrls;
1592         }
1593
1594         if (!np && (!pdata || !pdata->is_platform_device))
1595                 return 0;
1596
1597         si4713_pdev = platform_device_alloc("radio-si4713", -1);
1598         if (!si4713_pdev) {
1599                 rval = -ENOMEM;
1600                 goto put_main_pdev;
1601         }
1602
1603         si4713_pdev_pdata.subdev = client;
1604         rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
1605                                         sizeof(si4713_pdev_pdata));
1606         if (rval)
1607                 goto put_main_pdev;
1608
1609         rval = platform_device_add(si4713_pdev);
1610         if (rval)
1611                 goto put_main_pdev;
1612
1613         sdev->pd = si4713_pdev;
1614
1615         return 0;
1616
1617 put_main_pdev:
1618         platform_device_put(si4713_pdev);
1619         v4l2_device_unregister_subdev(&sdev->sd);
1620 free_ctrls:
1621         v4l2_ctrl_handler_free(hdl);
1622 exit:
1623         return rval;
1624 }
1625
1626 /* si4713_remove - remove the device */
1627 static int si4713_remove(struct i2c_client *client)
1628 {
1629         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1630         struct si4713_device *sdev = to_si4713_device(sd);
1631
1632         platform_device_unregister(sdev->pd);
1633
1634         if (sdev->power_state)
1635                 si4713_set_power_state(sdev, POWER_DOWN);
1636
1637         v4l2_device_unregister_subdev(sd);
1638         v4l2_ctrl_handler_free(sd->ctrl_handler);
1639
1640         return 0;
1641 }
1642
1643 /* si4713_i2c_driver - i2c driver interface */
1644 static const struct i2c_device_id si4713_id[] = {
1645         { "si4713" , 0 },
1646         { },
1647 };
1648 MODULE_DEVICE_TABLE(i2c, si4713_id);
1649
1650 #if IS_ENABLED(CONFIG_OF)
1651 static const struct of_device_id si4713_of_match[] = {
1652         { .compatible = "silabs,si4713" },
1653         { },
1654 };
1655 MODULE_DEVICE_TABLE(of, si4713_of_match);
1656 #endif
1657
1658 static struct i2c_driver si4713_i2c_driver = {
1659         .driver         = {
1660                 .name   = "si4713",
1661                 .of_match_table = of_match_ptr(si4713_of_match),
1662         },
1663         .probe          = si4713_probe,
1664         .remove         = si4713_remove,
1665         .id_table       = si4713_id,
1666 };
1667
1668 module_i2c_driver(si4713_i2c_driver);