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