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 			fallthrough;
1161 		case V4L2_CID_TUNE_POWER_LEVEL:
1162 			ret = si4713_tx_tune_power(sdev,
1163 				sdev->tune_pwr_level->val, sdev->tune_ant_cap->val);
1164 			if (!ret) {
1165 				/* Make sure we don't set this twice */
1166 				sdev->tune_ant_cap->is_new = false;
1167 				sdev->tune_pwr_level->is_new = false;
1168 			}
1169 			break;
1170 
1171 		case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1172 		case V4L2_CID_RDS_TX_ALT_FREQS:
1173 			if (sdev->rds_alt_freqs_enable->val) {
1174 				val = sdev->rds_alt_freqs->p_new.p_u32[0];
1175 				val = val / 100 - 876 + 0xe101;
1176 			} else {
1177 				val = 0xe0e0;
1178 			}
1179 			ret = si4713_write_property(sdev, SI4713_TX_RDS_PS_AF, val);
1180 			break;
1181 
1182 		default:
1183 			ret = si4713_choose_econtrol_action(sdev, ctrl->id, &bit,
1184 					&mask, &property, &mul, &table, &size);
1185 			if (ret < 0)
1186 				break;
1187 
1188 			val = ctrl->val;
1189 			if (mul) {
1190 				val = val / mul;
1191 			} else if (table) {
1192 				ret = usecs_to_dev(val, table, size);
1193 				if (ret < 0)
1194 					break;
1195 				val = ret;
1196 				ret = 0;
1197 			}
1198 
1199 			if (mask) {
1200 				ret = si4713_read_property(sdev, property, &val);
1201 				if (ret < 0)
1202 					break;
1203 				val = set_bits(val, ctrl->val, bit, mask);
1204 			}
1205 
1206 			ret = si4713_write_property(sdev, property, val);
1207 			if (ret < 0)
1208 				break;
1209 			if (mask)
1210 				val = ctrl->val;
1211 			break;
1212 		}
1213 	}
1214 
1215 	return ret;
1216 }
1217 
1218 /* si4713_ioctl - deal with private ioctls (only rnl for now) */
1219 static long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1220 {
1221 	struct si4713_device *sdev = to_si4713_device(sd);
1222 	struct si4713_rnl *rnl = arg;
1223 	u16 frequency;
1224 	int rval = 0;
1225 
1226 	if (!arg)
1227 		return -EINVAL;
1228 
1229 	switch (cmd) {
1230 	case SI4713_IOC_MEASURE_RNL:
1231 		frequency = v4l2_to_si4713(rnl->frequency);
1232 
1233 		if (sdev->power_state) {
1234 			/* Set desired measurement frequency */
1235 			rval = si4713_tx_tune_measure(sdev, frequency, 0);
1236 			if (rval < 0)
1237 				return rval;
1238 			/* get results from tune status */
1239 			rval = si4713_update_tune_status(sdev);
1240 			if (rval < 0)
1241 				return rval;
1242 		}
1243 		rnl->rnl = sdev->tune_rnl;
1244 		break;
1245 
1246 	default:
1247 		/* nothing */
1248 		rval = -ENOIOCTLCMD;
1249 	}
1250 
1251 	return rval;
1252 }
1253 
1254 /* si4713_g_modulator - get modulator attributes */
1255 static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1256 {
1257 	struct si4713_device *sdev = to_si4713_device(sd);
1258 	int rval = 0;
1259 
1260 	if (!sdev)
1261 		return -ENODEV;
1262 
1263 	if (vm->index > 0)
1264 		return -EINVAL;
1265 
1266 	strscpy(vm->name, "FM Modulator", sizeof(vm->name));
1267 	vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1268 		V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_CONTROLS;
1269 
1270 	/* Report current frequency range limits */
1271 	vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1272 	vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1273 
1274 	if (sdev->power_state) {
1275 		u32 comp_en = 0;
1276 
1277 		rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1278 						&comp_en);
1279 		if (rval < 0)
1280 			return rval;
1281 
1282 		sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1283 	}
1284 
1285 	/* Report current audio mode: mono or stereo */
1286 	if (sdev->stereo)
1287 		vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1288 	else
1289 		vm->txsubchans = V4L2_TUNER_SUB_MONO;
1290 
1291 	/* Report rds feature status */
1292 	if (sdev->rds_enabled)
1293 		vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1294 	else
1295 		vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1296 
1297 	return rval;
1298 }
1299 
1300 /* si4713_s_modulator - set modulator attributes */
1301 static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *vm)
1302 {
1303 	struct si4713_device *sdev = to_si4713_device(sd);
1304 	int rval = 0;
1305 	u16 stereo, rds;
1306 	u32 p;
1307 
1308 	if (!sdev)
1309 		return -ENODEV;
1310 
1311 	if (vm->index > 0)
1312 		return -EINVAL;
1313 
1314 	/* Set audio mode: mono or stereo */
1315 	if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1316 		stereo = 1;
1317 	else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1318 		stereo = 0;
1319 	else
1320 		return -EINVAL;
1321 
1322 	rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1323 
1324 	if (sdev->power_state) {
1325 		rval = si4713_read_property(sdev,
1326 						SI4713_TX_COMPONENT_ENABLE, &p);
1327 		if (rval < 0)
1328 			return rval;
1329 
1330 		p = set_bits(p, stereo, 1, 1 << 1);
1331 		p = set_bits(p, rds, 2, 1 << 2);
1332 
1333 		rval = si4713_write_property(sdev,
1334 						SI4713_TX_COMPONENT_ENABLE, p);
1335 		if (rval < 0)
1336 			return rval;
1337 	}
1338 
1339 	sdev->stereo = stereo;
1340 	sdev->rds_enabled = rds;
1341 
1342 	return rval;
1343 }
1344 
1345 /* si4713_g_frequency - get tuner or modulator radio frequency */
1346 static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1347 {
1348 	struct si4713_device *sdev = to_si4713_device(sd);
1349 	int rval = 0;
1350 
1351 	if (f->tuner)
1352 		return -EINVAL;
1353 
1354 	if (sdev->power_state) {
1355 		u16 freq;
1356 		u8 p, a, n;
1357 
1358 		rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1359 		if (rval < 0)
1360 			return rval;
1361 
1362 		sdev->frequency = freq;
1363 	}
1364 
1365 	f->frequency = si4713_to_v4l2(sdev->frequency);
1366 
1367 	return rval;
1368 }
1369 
1370 /* si4713_s_frequency - set tuner or modulator radio frequency */
1371 static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1372 {
1373 	struct si4713_device *sdev = to_si4713_device(sd);
1374 	int rval = 0;
1375 	u16 frequency = v4l2_to_si4713(f->frequency);
1376 
1377 	if (f->tuner)
1378 		return -EINVAL;
1379 
1380 	/* Check frequency range */
1381 	frequency = clamp_t(u16, frequency, FREQ_RANGE_LOW, FREQ_RANGE_HIGH);
1382 
1383 	if (sdev->power_state) {
1384 		rval = si4713_tx_tune_freq(sdev, frequency);
1385 		if (rval < 0)
1386 			return rval;
1387 		frequency = rval;
1388 		rval = 0;
1389 	}
1390 	sdev->frequency = frequency;
1391 
1392 	return rval;
1393 }
1394 
1395 static const struct v4l2_ctrl_ops si4713_ctrl_ops = {
1396 	.s_ctrl = si4713_s_ctrl,
1397 };
1398 
1399 static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1400 	.ioctl		= si4713_ioctl,
1401 };
1402 
1403 static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1404 	.g_frequency	= si4713_g_frequency,
1405 	.s_frequency	= si4713_s_frequency,
1406 	.g_modulator	= si4713_g_modulator,
1407 	.s_modulator	= si4713_s_modulator,
1408 };
1409 
1410 static const struct v4l2_subdev_ops si4713_subdev_ops = {
1411 	.core		= &si4713_subdev_core_ops,
1412 	.tuner		= &si4713_subdev_tuner_ops,
1413 };
1414 
1415 static const struct v4l2_ctrl_config si4713_alt_freqs_ctrl = {
1416 	.id = V4L2_CID_RDS_TX_ALT_FREQS,
1417 	.type = V4L2_CTRL_TYPE_U32,
1418 	.min = 87600,
1419 	.max = 107900,
1420 	.step = 100,
1421 	.def = 87600,
1422 	.dims = { 1 },
1423 	.elem_size = sizeof(u32),
1424 };
1425 
1426 /*
1427  * I2C driver interface
1428  */
1429 /* si4713_probe - probe for the device */
1430 static int si4713_probe(struct i2c_client *client)
1431 {
1432 	struct si4713_device *sdev;
1433 	struct v4l2_ctrl_handler *hdl;
1434 	struct si4713_platform_data *pdata = client->dev.platform_data;
1435 	struct device_node *np = client->dev.of_node;
1436 	struct radio_si4713_platform_data si4713_pdev_pdata;
1437 	struct platform_device *si4713_pdev;
1438 	int rval;
1439 
1440 	sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
1441 	if (!sdev) {
1442 		dev_err(&client->dev, "Failed to alloc video device.\n");
1443 		rval = -ENOMEM;
1444 		goto exit;
1445 	}
1446 
1447 	sdev->gpio_reset = devm_gpiod_get_optional(&client->dev, "reset",
1448 						   GPIOD_OUT_LOW);
1449 	if (IS_ERR(sdev->gpio_reset)) {
1450 		rval = PTR_ERR(sdev->gpio_reset);
1451 		dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
1452 		goto exit;
1453 	}
1454 
1455 	sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
1456 	if (IS_ERR(sdev->vdd)) {
1457 		rval = PTR_ERR(sdev->vdd);
1458 		if (rval == -EPROBE_DEFER)
1459 			goto exit;
1460 
1461 		dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
1462 		sdev->vdd = NULL;
1463 	}
1464 
1465 	sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
1466 	if (IS_ERR(sdev->vio)) {
1467 		rval = PTR_ERR(sdev->vio);
1468 		if (rval == -EPROBE_DEFER)
1469 			goto exit;
1470 
1471 		dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
1472 		sdev->vio = NULL;
1473 	}
1474 
1475 	v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1476 
1477 	init_completion(&sdev->work);
1478 
1479 	hdl = &sdev->ctrl_handler;
1480 	v4l2_ctrl_handler_init(hdl, 20);
1481 	sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1482 			V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
1483 
1484 	sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1485 			V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
1486 	sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1487 			V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
1488 	sdev->rds_compressed = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1489 			V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1490 	sdev->rds_art_head = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1491 			V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1492 	sdev->rds_stereo = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1493 			V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1494 	sdev->rds_tp = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1495 			V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1496 	sdev->rds_ta = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1497 			V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1498 	sdev->rds_ms = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1499 			V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1500 	sdev->rds_dyn_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1501 			V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1502 	sdev->rds_alt_freqs_enable = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1503 			V4L2_CID_RDS_TX_ALT_FREQS_ENABLE, 0, 1, 1, 0);
1504 	sdev->rds_alt_freqs = v4l2_ctrl_new_custom(hdl, &si4713_alt_freqs_ctrl, NULL);
1505 	sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1506 			V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
1507 			10, DEFAULT_RDS_DEVIATION);
1508 	/*
1509 	 * Report step as 8. From RDS spec, psname
1510 	 * should be 8. But there are receivers which scroll strings
1511 	 * sized as 8xN.
1512 	 */
1513 	sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1514 			V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
1515 	/*
1516 	 * Report step as 32 (2A block). From RDS spec,
1517 	 * radio text should be 32 for 2A block. But there are receivers
1518 	 * which scroll strings sized as 32xN. Setting default to 32.
1519 	 */
1520 	sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1521 			V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1522 
1523 	sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1524 			V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
1525 	sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1526 			V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
1527 			MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
1528 	sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1529 			V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
1530 			MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
1531 
1532 	sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1533 			V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
1534 	sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1535 			V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
1536 			DEFAULT_ACOMP_GAIN);
1537 	sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1538 			V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
1539 			MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1,
1540 			DEFAULT_ACOMP_THRESHOLD);
1541 	sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1542 			V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
1543 			MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
1544 	sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1545 			V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
1546 			MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
1547 
1548 	sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1549 			V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
1550 	sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1551 			V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
1552 			10, DEFAULT_PILOT_DEVIATION);
1553 	sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1554 			V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1555 			1, DEFAULT_PILOT_FREQUENCY);
1556 
1557 	sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
1558 			V4L2_CID_TUNE_PREEMPHASIS,
1559 			V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
1560 	sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1561 			V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER,
1562 			1, DEFAULT_POWER_LEVEL);
1563 	sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1564 			V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP,
1565 			1, 0);
1566 
1567 	if (hdl->error) {
1568 		rval = hdl->error;
1569 		goto free_ctrls;
1570 	}
1571 	v4l2_ctrl_cluster(29, &sdev->mute);
1572 	sdev->sd.ctrl_handler = hdl;
1573 
1574 	if (client->irq) {
1575 		rval = devm_request_irq(&client->dev, client->irq,
1576 			si4713_handler, IRQF_TRIGGER_FALLING,
1577 			client->name, sdev);
1578 		if (rval < 0) {
1579 			v4l2_err(&sdev->sd, "Could not request IRQ\n");
1580 			goto free_ctrls;
1581 		}
1582 		v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1583 	} else {
1584 		v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1585 	}
1586 
1587 	rval = si4713_initialize(sdev);
1588 	if (rval < 0) {
1589 		v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1590 		goto free_ctrls;
1591 	}
1592 
1593 	if (!np && (!pdata || !pdata->is_platform_device))
1594 		return 0;
1595 
1596 	si4713_pdev = platform_device_alloc("radio-si4713", -1);
1597 	if (!si4713_pdev) {
1598 		rval = -ENOMEM;
1599 		goto put_main_pdev;
1600 	}
1601 
1602 	si4713_pdev_pdata.subdev = client;
1603 	rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
1604 					sizeof(si4713_pdev_pdata));
1605 	if (rval)
1606 		goto put_main_pdev;
1607 
1608 	rval = platform_device_add(si4713_pdev);
1609 	if (rval)
1610 		goto put_main_pdev;
1611 
1612 	sdev->pd = si4713_pdev;
1613 
1614 	return 0;
1615 
1616 put_main_pdev:
1617 	platform_device_put(si4713_pdev);
1618 	v4l2_device_unregister_subdev(&sdev->sd);
1619 free_ctrls:
1620 	v4l2_ctrl_handler_free(hdl);
1621 exit:
1622 	return rval;
1623 }
1624 
1625 /* si4713_remove - remove the device */
1626 static int si4713_remove(struct i2c_client *client)
1627 {
1628 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
1629 	struct si4713_device *sdev = to_si4713_device(sd);
1630 
1631 	platform_device_unregister(sdev->pd);
1632 
1633 	if (sdev->power_state)
1634 		si4713_set_power_state(sdev, POWER_DOWN);
1635 
1636 	v4l2_device_unregister_subdev(sd);
1637 	v4l2_ctrl_handler_free(sd->ctrl_handler);
1638 
1639 	return 0;
1640 }
1641 
1642 /* si4713_i2c_driver - i2c driver interface */
1643 static const struct i2c_device_id si4713_id[] = {
1644 	{ "si4713" , 0 },
1645 	{ },
1646 };
1647 MODULE_DEVICE_TABLE(i2c, si4713_id);
1648 
1649 #if IS_ENABLED(CONFIG_OF)
1650 static const struct of_device_id si4713_of_match[] = {
1651 	{ .compatible = "silabs,si4713" },
1652 	{ },
1653 };
1654 MODULE_DEVICE_TABLE(of, si4713_of_match);
1655 #endif
1656 
1657 static struct i2c_driver si4713_i2c_driver = {
1658 	.driver		= {
1659 		.name	= "si4713",
1660 		.of_match_table = of_match_ptr(si4713_of_match),
1661 	},
1662 	.probe_new	= si4713_probe,
1663 	.remove         = si4713_remove,
1664 	.id_table       = si4713_id,
1665 };
1666 
1667 module_i2c_driver(si4713_i2c_driver);
1668