[linux-2.6-block.git] / drivers / media / platform / vivid / vivid-radio-rx.c

/*
 * vivid-radio-rx.c - radio receiver support functions.
 *
 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 *
 * This program is free software; you may redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/videodev2.h>
#include <linux/v4l2-dv-timings.h>
#include <linux/sched/signal.h>

#include <media/v4l2-common.h>
#include <media/v4l2-event.h>
#include <media/v4l2-dv-timings.h>

#include "vivid-core.h"
#include "vivid-ctrls.h"
#include "vivid-radio-common.h"
#include "vivid-rds-gen.h"
#include "vivid-radio-rx.h"

ssize_t vivid_radio_rx_read(struct file *file, char __user *buf,
			 size_t size, loff_t *offset)
{
	struct vivid_dev *dev = video_drvdata(file);
	struct v4l2_rds_data *data = dev->rds_gen.data;
	bool use_alternates;
	ktime_t timestamp;
	unsigned blk;
	int perc;
	int i;

	if (dev->radio_rx_rds_controls)
		return -EINVAL;
	if (size < sizeof(*data))
		return 0;
	size = sizeof(*data) * (size / sizeof(*data));

	if (mutex_lock_interruptible(&dev->mutex))
		return -ERESTARTSYS;
	if (dev->radio_rx_rds_owner &&
	    file->private_data != dev->radio_rx_rds_owner) {
		mutex_unlock(&dev->mutex);
		return -EBUSY;
	}
	if (dev->radio_rx_rds_owner == NULL) {
		vivid_radio_rds_init(dev);
		dev->radio_rx_rds_owner = file->private_data;
	}

retry:
	timestamp = ktime_sub(ktime_get(), dev->radio_rds_init_time);
	blk = ktime_divns(timestamp, VIVID_RDS_NSEC_PER_BLK);
	use_alternates = (blk % VIVID_RDS_GEN_BLOCKS) & 1;

	if (dev->radio_rx_rds_last_block == 0 ||
	    dev->radio_rx_rds_use_alternates != use_alternates) {
		dev->radio_rx_rds_use_alternates = use_alternates;
		/* Re-init the RDS generator */
		vivid_radio_rds_init(dev);
	}
	if (blk >= dev->radio_rx_rds_last_block + VIVID_RDS_GEN_BLOCKS)
		dev->radio_rx_rds_last_block = blk - VIVID_RDS_GEN_BLOCKS + 1;

	/*
	 * No data is available if there hasn't been time to get new data,
	 * or if the RDS receiver has been disabled, or if we use the data
	 * from the RDS transmitter and that RDS transmitter has been disabled,
	 * or if the signal quality is too weak.
	 */
	if (blk == dev->radio_rx_rds_last_block || !dev->radio_rx_rds_enabled ||
	    (dev->radio_rds_loop && !(dev->radio_tx_subchans & V4L2_TUNER_SUB_RDS)) ||
	    abs(dev->radio_rx_sig_qual) > 200) {
		mutex_unlock(&dev->mutex);
		if (file->f_flags & O_NONBLOCK)
			return -EWOULDBLOCK;
		if (msleep_interruptible(20) && signal_pending(current))
			return -EINTR;
		if (mutex_lock_interruptible(&dev->mutex))
			return -ERESTARTSYS;
		goto retry;
	}

	/* abs(dev->radio_rx_sig_qual) <= 200, map that to a 0-50% range */
	perc = abs(dev->radio_rx_sig_qual) / 4;

	for (i = 0; i < size && blk > dev->radio_rx_rds_last_block;
			dev->radio_rx_rds_last_block++) {
		unsigned data_blk = dev->radio_rx_rds_last_block % VIVID_RDS_GEN_BLOCKS;
		struct v4l2_rds_data rds = data[data_blk];

		if (data_blk == 0 && dev->radio_rds_loop)
			vivid_radio_rds_init(dev);
		if (perc && prandom_u32_max(100) < perc) {
			switch (prandom_u32_max(4)) {
			case 0:
				rds.block |= V4L2_RDS_BLOCK_CORRECTED;
				break;
			case 1:
				rds.block |= V4L2_RDS_BLOCK_INVALID;
				break;
			case 2:
				rds.block |= V4L2_RDS_BLOCK_ERROR;
				rds.lsb = prandom_u32_max(256);
				rds.msb = prandom_u32_max(256);
				break;
			case 3: /* Skip block altogether */
				if (i)
					continue;
				/*
				 * Must make sure at least one block is
				 * returned, otherwise the application
				 * might think that end-of-file occurred.
				 */
				break;
			}
		}
		if (copy_to_user(buf + i, &rds, sizeof(rds))) {
			i = -EFAULT;
			break;
		}
		i += sizeof(rds);
	}
	mutex_unlock(&dev->mutex);
	return i;
}

__poll_t vivid_radio_rx_poll(struct file *file, struct poll_table_struct *wait)
{
	return EPOLLIN | EPOLLRDNORM | v4l2_ctrl_poll(file, wait);
}

int vivid_radio_rx_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
{
	if (band->tuner != 0)
		return -EINVAL;

	if (band->index >= TOT_BANDS)
		return -EINVAL;

	*band = vivid_radio_bands[band->index];
	return 0;
}

int vivid_radio_rx_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a)
{
	struct vivid_dev *dev = video_drvdata(file);
	unsigned low, high;
	unsigned freq;
	unsigned spacing;
	unsigned band;

	if (a->tuner)
		return -EINVAL;
	if (a->wrap_around && dev->radio_rx_hw_seek_mode == VIVID_HW_SEEK_BOUNDED)
		return -EINVAL;

	if (!a->wrap_around && dev->radio_rx_hw_seek_mode == VIVID_HW_SEEK_WRAP)
		return -EINVAL;
	if (!a->rangelow ^ !a->rangehigh)
		return -EINVAL;

	if (file->f_flags & O_NONBLOCK)
		return -EWOULDBLOCK;

	if (a->rangelow) {
		for (band = 0; band < TOT_BANDS; band++)
			if (a->rangelow >= vivid_radio_bands[band].rangelow &&
			    a->rangehigh <= vivid_radio_bands[band].rangehigh)
				break;
		if (band == TOT_BANDS)
			return -EINVAL;
		if (!dev->radio_rx_hw_seek_prog_lim &&
		    (a->rangelow != vivid_radio_bands[band].rangelow ||
		     a->rangehigh != vivid_radio_bands[band].rangehigh))
			return -EINVAL;
		low = a->rangelow;
		high = a->rangehigh;
	} else {
		for (band = 0; band < TOT_BANDS; band++)
			if (dev->radio_rx_freq >= vivid_radio_bands[band].rangelow &&
			    dev->radio_rx_freq <= vivid_radio_bands[band].rangehigh)
				break;
		if (band == TOT_BANDS)
			return -EINVAL;
		low = vivid_radio_bands[band].rangelow;
		high = vivid_radio_bands[band].rangehigh;
	}
	spacing = band == BAND_AM ? 1600 : 16000;
	freq = clamp(dev->radio_rx_freq, low, high);

	if (a->seek_upward) {
		freq = spacing * (freq / spacing) + spacing;
		if (freq > high) {
			if (!a->wrap_around)
				return -ENODATA;
			freq = spacing * (low / spacing) + spacing;
			if (freq >= dev->radio_rx_freq)
				return -ENODATA;
		}
	} else {
		freq = spacing * ((freq + spacing - 1) / spacing) - spacing;
		if (freq < low) {
			if (!a->wrap_around)
				return -ENODATA;
			freq = spacing * ((high + spacing - 1) / spacing) - spacing;
			if (freq <= dev->radio_rx_freq)
				return -ENODATA;
		}
	}
	return 0;
}

int vivid_radio_rx_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
{
	struct vivid_dev *dev = video_drvdata(file);
	int delta = 800;
	int sig_qual;

	if (vt->index > 0)
		return -EINVAL;

	strlcpy(vt->name, "AM/FM/SW Receiver", sizeof(vt->name));
	vt->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
			 V4L2_TUNER_CAP_FREQ_BANDS | V4L2_TUNER_CAP_RDS |
			 (dev->radio_rx_rds_controls ?
				V4L2_TUNER_CAP_RDS_CONTROLS :
				V4L2_TUNER_CAP_RDS_BLOCK_IO) |
			 (dev->radio_rx_hw_seek_prog_lim ?
				V4L2_TUNER_CAP_HWSEEK_PROG_LIM : 0);
	switch (dev->radio_rx_hw_seek_mode) {
	case VIVID_HW_SEEK_BOUNDED:
		vt->capability |= V4L2_TUNER_CAP_HWSEEK_BOUNDED;
		break;
	case VIVID_HW_SEEK_WRAP:
		vt->capability |= V4L2_TUNER_CAP_HWSEEK_WRAP;
		break;
	case VIVID_HW_SEEK_BOTH:
		vt->capability |= V4L2_TUNER_CAP_HWSEEK_WRAP |
				  V4L2_TUNER_CAP_HWSEEK_BOUNDED;
		break;
	}
	vt->rangelow = AM_FREQ_RANGE_LOW;
	vt->rangehigh = FM_FREQ_RANGE_HIGH;
	sig_qual = dev->radio_rx_sig_qual;
	vt->signal = abs(sig_qual) > delta ? 0 :
		     0xffff - (abs(sig_qual) * 0xffff) / delta;
	vt->afc = sig_qual > delta ? 0 : sig_qual;
	if (abs(sig_qual) > delta)
		vt->rxsubchans = 0;
	else if (dev->radio_rx_freq < FM_FREQ_RANGE_LOW || vt->signal < 0x8000)
		vt->rxsubchans = V4L2_TUNER_SUB_MONO;
	else if (dev->radio_rds_loop && !(dev->radio_tx_subchans & V4L2_TUNER_SUB_STEREO))
		vt->rxsubchans = V4L2_TUNER_SUB_MONO;
	else
		vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
	if (dev->radio_rx_rds_enabled &&
	    (!dev->radio_rds_loop || (dev->radio_tx_subchans & V4L2_TUNER_SUB_RDS)) &&
	    dev->radio_rx_freq >= FM_FREQ_RANGE_LOW && vt->signal >= 0xc000)
		vt->rxsubchans |= V4L2_TUNER_SUB_RDS;
	if (dev->radio_rx_rds_controls)
		vivid_radio_rds_init(dev);
	vt->audmode = dev->radio_rx_audmode;
	return 0;
}

int vivid_radio_rx_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
{
	struct vivid_dev *dev = video_drvdata(file);

	if (vt->index)
		return -EINVAL;
	dev->radio_rx_audmode = vt->audmode >= V4L2_TUNER_MODE_STEREO;
	return 0;
}
Commit	Line	Data
55d58e98 HV	1	/*
	2	* vivid-radio-rx.c - radio receiver support functions.
	3	*
	4	* Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
	5	*
	6	* This program is free software; you may redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; version 2 of the License.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	11	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	12	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	13	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	14	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	15	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	16	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	17	* SOFTWARE.
	18	*/
	19
	20	#include <linux/errno.h>
	21	#include <linux/kernel.h>
	22	#include <linux/delay.h>
	23	#include <linux/videodev2.h>
	24	#include <linux/v4l2-dv-timings.h>
174cd4b1 IM	25	#include <linux/sched/signal.h>
174cd4b1 IM	26
55d58e98 HV	27	#include <media/v4l2-common.h>
	28	#include <media/v4l2-event.h>
	29	#include <media/v4l2-dv-timings.h>
	30
	31	#include "vivid-core.h"
	32	#include "vivid-ctrls.h"
	33	#include "vivid-radio-common.h"
	34	#include "vivid-rds-gen.h"
	35	#include "vivid-radio-rx.h"
	36
	37	ssize_t vivid_radio_rx_read(struct file file, char __user buf,
	38	size_t size, loff_t *offset)
	39	{
	40	struct vivid_dev *dev = video_drvdata(file);
55d58e98 HV	41	struct v4l2_rds_data *data = dev->rds_gen.data;
55d58e98 HV	42	bool use_alternates;
aad2fa4c	43	ktime_t timestamp;
55d58e98 HV	44	unsigned blk;
	45	int perc;
	46	int i;
	47
	48	if (dev->radio_rx_rds_controls)
	49	return -EINVAL;
	50	if (size < sizeof(*data))
	51	return 0;
	52	size = sizeof(data) (size / sizeof(*data));
	53
	54	if (mutex_lock_interruptible(&dev->mutex))
	55	return -ERESTARTSYS;
	56	if (dev->radio_rx_rds_owner &&
	57	file->private_data != dev->radio_rx_rds_owner) {
	58	mutex_unlock(&dev->mutex);
	59	return -EBUSY;
	60	}
	61	if (dev->radio_rx_rds_owner == NULL) {
	62	vivid_radio_rds_init(dev);
	63	dev->radio_rx_rds_owner = file->private_data;
	64	}
	65
	66	retry:
aad2fa4c AB	67	timestamp = ktime_sub(ktime_get(), dev->radio_rds_init_time);
	68	blk = ktime_divns(timestamp, VIVID_RDS_NSEC_PER_BLK);
	69	use_alternates = (blk % VIVID_RDS_GEN_BLOCKS) & 1;
	70
55d58e98 HV	71	if (dev->radio_rx_rds_last_block == 0 \|\|
	72	dev->radio_rx_rds_use_alternates != use_alternates) {
	73	dev->radio_rx_rds_use_alternates = use_alternates;
	74	/* Re-init the RDS generator */
	75	vivid_radio_rds_init(dev);
	76	}
55d58e98 HV	77	if (blk >= dev->radio_rx_rds_last_block + VIVID_RDS_GEN_BLOCKS)
	78	dev->radio_rx_rds_last_block = blk - VIVID_RDS_GEN_BLOCKS + 1;
	79
	80	/*
	81	* No data is available if there hasn't been time to get new data,
	82	* or if the RDS receiver has been disabled, or if we use the data
	83	* from the RDS transmitter and that RDS transmitter has been disabled,
	84	* or if the signal quality is too weak.
	85	*/
	86	if (blk == dev->radio_rx_rds_last_block \|\| !dev->radio_rx_rds_enabled \|\|
	87	(dev->radio_rds_loop && !(dev->radio_tx_subchans & V4L2_TUNER_SUB_RDS)) \|\|
	88	abs(dev->radio_rx_sig_qual) > 200) {
	89	mutex_unlock(&dev->mutex);
	90	if (file->f_flags & O_NONBLOCK)
	91	return -EWOULDBLOCK;
	92	if (msleep_interruptible(20) && signal_pending(current))
	93	return -EINTR;
	94	if (mutex_lock_interruptible(&dev->mutex))
	95	return -ERESTARTSYS;
	96	goto retry;
	97	}
	98
	99	/* abs(dev->radio_rx_sig_qual) <= 200, map that to a 0-50% range */
	100	perc = abs(dev->radio_rx_sig_qual) / 4;
	101
	102	for (i = 0; i < size && blk > dev->radio_rx_rds_last_block;
	103	dev->radio_rx_rds_last_block++) {
	104	unsigned data_blk = dev->radio_rx_rds_last_block % VIVID_RDS_GEN_BLOCKS;
	105	struct v4l2_rds_data rds = data[data_blk];
	106
	107	if (data_blk == 0 && dev->radio_rds_loop)
	108	vivid_radio_rds_init(dev);
	109	if (perc && prandom_u32_max(100) < perc) {
	110	switch (prandom_u32_max(4)) {
	111	case 0:
	112	rds.block \|= V4L2_RDS_BLOCK_CORRECTED;
	113	break;
	114	case 1:
	115	rds.block \|= V4L2_RDS_BLOCK_INVALID;
	116	break;
	117	case 2:
	118	rds.block \|= V4L2_RDS_BLOCK_ERROR;
	119	rds.lsb = prandom_u32_max(256);
	120	rds.msb = prandom_u32_max(256);
	121	break;
	122	case 3: /* Skip block altogether */
	123	if (i)
	124	continue;
	125	/*
	126	* Must make sure at least one block is
	127	* returned, otherwise the application
	128	* might think that end-of-file occurred.
	129	*/
	130	break;
	131	}
	132	}
	133	if (copy_to_user(buf + i, &rds, sizeof(rds))) {
	134	i = -EFAULT;
	135	break;
	136	}
	137	i += sizeof(rds);
	138	}
	139	mutex_unlock(&dev->mutex);
	140	return i;
141	}
142
c23e0cb8	143	__poll_t vivid_radio_rx_poll(struct file file, struct poll_table_struct wait)
55d58e98	144	{
a9a08845	145	return EPOLLIN \| EPOLLRDNORM \| v4l2_ctrl_poll(file, wait);
55d58e98 HV	146	}
	147
	148	int vivid_radio_rx_enum_freq_bands(struct file file, void fh, struct v4l2_frequency_band *band)
	149	{
	150	if (band->tuner != 0)
	151	return -EINVAL;
	152
	153	if (band->index >= TOT_BANDS)
	154	return -EINVAL;
	155
	156	*band = vivid_radio_bands[band->index];
	157	return 0;
	158	}
	159
	160	int vivid_radio_rx_s_hw_freq_seek(struct file file, void fh, const struct v4l2_hw_freq_seek *a)
	161	{
	162	struct vivid_dev *dev = video_drvdata(file);
	163	unsigned low, high;
	164	unsigned freq;
	165	unsigned spacing;
	166	unsigned band;
	167
	168	if (a->tuner)
	169	return -EINVAL;
	170	if (a->wrap_around && dev->radio_rx_hw_seek_mode == VIVID_HW_SEEK_BOUNDED)
	171	return -EINVAL;
	172
	173	if (!a->wrap_around && dev->radio_rx_hw_seek_mode == VIVID_HW_SEEK_WRAP)
	174	return -EINVAL;
	175	if (!a->rangelow ^ !a->rangehigh)
	176	return -EINVAL;
	177
	178	if (file->f_flags & O_NONBLOCK)
	179	return -EWOULDBLOCK;
	180
	181	if (a->rangelow) {
	182	for (band = 0; band < TOT_BANDS; band++)
	183	if (a->rangelow >= vivid_radio_bands[band].rangelow &&
	184	a->rangehigh <= vivid_radio_bands[band].rangehigh)
	185	break;
	186	if (band == TOT_BANDS)
	187	return -EINVAL;
	188	if (!dev->radio_rx_hw_seek_prog_lim &&
	189	(a->rangelow != vivid_radio_bands[band].rangelow \|\|
	190	a->rangehigh != vivid_radio_bands[band].rangehigh))
	191	return -EINVAL;
	192	low = a->rangelow;
	193	high = a->rangehigh;
	194	} else {
	195	for (band = 0; band < TOT_BANDS; band++)
	196	if (dev->radio_rx_freq >= vivid_radio_bands[band].rangelow &&
	197	dev->radio_rx_freq <= vivid_radio_bands[band].rangehigh)
	198	break;
322583c4 MCC	199	if (band == TOT_BANDS)
322583c4 MCC	200	return -EINVAL;
55d58e98 HV	201	low = vivid_radio_bands[band].rangelow;
	202	high = vivid_radio_bands[band].rangehigh;
	203	}
	204	spacing = band == BAND_AM ? 1600 : 16000;
	205	freq = clamp(dev->radio_rx_freq, low, high);
	206
	207	if (a->seek_upward) {
	208	freq = spacing * (freq / spacing) + spacing;
	209	if (freq > high) {
	210	if (!a->wrap_around)
	211	return -ENODATA;
	212	freq = spacing * (low / spacing) + spacing;
	213	if (freq >= dev->radio_rx_freq)
	214	return -ENODATA;
	215	}
	216	} else {
	217	freq = spacing * ((freq + spacing - 1) / spacing) - spacing;
	218	if (freq < low) {
	219	if (!a->wrap_around)
	220	return -ENODATA;
	221	freq = spacing * ((high + spacing - 1) / spacing) - spacing;
	222	if (freq <= dev->radio_rx_freq)
	223	return -ENODATA;
	224	}
	225	}
	226	return 0;
	227	}
	228
	229	int vivid_radio_rx_g_tuner(struct file file, void fh, struct v4l2_tuner *vt)
	230	{
	231	struct vivid_dev *dev = video_drvdata(file);
	232	int delta = 800;
	233	int sig_qual;
	234
	235	if (vt->index > 0)
	236	return -EINVAL;
	237
	238	strlcpy(vt->name, "AM/FM/SW Receiver", sizeof(vt->name));
	239	vt->capability = V4L2_TUNER_CAP_LOW \| V4L2_TUNER_CAP_STEREO \|
	240	V4L2_TUNER_CAP_FREQ_BANDS \| V4L2_TUNER_CAP_RDS \|
	241	(dev->radio_rx_rds_controls ?
	242	V4L2_TUNER_CAP_RDS_CONTROLS :
	243	V4L2_TUNER_CAP_RDS_BLOCK_IO) \|
	244	(dev->radio_rx_hw_seek_prog_lim ?
	245	V4L2_TUNER_CAP_HWSEEK_PROG_LIM : 0);
	246	switch (dev->radio_rx_hw_seek_mode) {
	247	case VIVID_HW_SEEK_BOUNDED:
	248	vt->capability \|= V4L2_TUNER_CAP_HWSEEK_BOUNDED;
	249	break;
	250	case VIVID_HW_SEEK_WRAP:
	251	vt->capability \|= V4L2_TUNER_CAP_HWSEEK_WRAP;
	252	break;
	253	case VIVID_HW_SEEK_BOTH:
	254	vt->capability \|= V4L2_TUNER_CAP_HWSEEK_WRAP \|
	255	V4L2_TUNER_CAP_HWSEEK_BOUNDED;
	256	break;
	257	}
	258	vt->rangelow = AM_FREQ_RANGE_LOW;
	259	vt->rangehigh = FM_FREQ_RANGE_HIGH;
	260	sig_qual = dev->radio_rx_sig_qual;
	261	vt->signal = abs(sig_qual) > delta ? 0 :
	262	0xffff - (abs(sig_qual) * 0xffff) / delta;
	263	vt->afc = sig_qual > delta ? 0 : sig_qual;
	264	if (abs(sig_qual) > delta)
265	vt->rxsubchans = 0;
266	else if (dev->radio_rx_freq < FM_FREQ_RANGE_LOW \|\| vt->signal < 0x8000)
267	vt->rxsubchans = V4L2_TUNER_SUB_MONO;
268	else if (dev->radio_rds_loop && !(dev->radio_tx_subchans & V4L2_TUNER_SUB_STEREO))
269	vt->rxsubchans = V4L2_TUNER_SUB_MONO;
270	else
271	vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
272	if (dev->radio_rx_rds_enabled &&
273	(!dev->radio_rds_loop \|\| (dev->radio_tx_subchans & V4L2_TUNER_SUB_RDS)) &&
274	dev->radio_rx_freq >= FM_FREQ_RANGE_LOW && vt->signal >= 0xc000)
275	vt->rxsubchans \|= V4L2_TUNER_SUB_RDS;
276	if (dev->radio_rx_rds_controls)
277	vivid_radio_rds_init(dev);
278	vt->audmode = dev->radio_rx_audmode;
279	return 0;
280	}
281
282	int vivid_radio_rx_s_tuner(struct file file, void fh, const struct v4l2_tuner *vt)
283	{
284	struct vivid_dev *dev = video_drvdata(file);
285
286	if (vt->index)
287	return -EINVAL;
288	dev->radio_rx_audmode = vt->audmode >= V4L2_TUNER_MODE_STEREO;
289	return 0;
290	}