1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * i2c tv tuner chip device driver
4  * core core, i.e. kernel interfaces, registering and so on
5  *
6  * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
7  *
8  * Copyright(c) 2005-2011 by Mauro Carvalho Chehab
9  *	- Added support for a separate Radio tuner
10  *	- Major rework and cleanups at the code
11  *
12  * This driver supports many devices and the idea is to let the driver
13  * detect which device is present. So rather than listing all supported
14  * devices here, we pretend to support a single, fake device type that will
15  * handle both radio and analog TV tuning.
16  */
17 
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/timer.h>
22 #include <linux/delay.h>
23 #include <linux/errno.h>
24 #include <linux/slab.h>
25 #include <linux/poll.h>
26 #include <linux/i2c.h>
27 #include <linux/types.h>
28 #include <linux/init.h>
29 #include <linux/videodev2.h>
30 #include <media/tuner.h>
31 #include <media/tuner-types.h>
32 #include <media/v4l2-device.h>
33 #include <media/v4l2-ioctl.h>
34 #include "mt20xx.h"
35 #include "tda8290.h"
36 #include "tea5761.h"
37 #include "tea5767.h"
38 #include "xc2028.h"
39 #include "tuner-simple.h"
40 #include "tda9887.h"
41 #include "xc5000.h"
42 #include "tda18271.h"
43 #include "xc4000.h"
44 
45 #define UNSET (-1U)
46 
47 /*
48  * Driver modprobe parameters
49  */
50 
51 /* insmod options used at init time => read/only */
52 static unsigned int addr;
53 static unsigned int no_autodetect;
54 static unsigned int show_i2c;
55 
56 module_param(addr, int, 0444);
57 module_param(no_autodetect, int, 0444);
58 module_param(show_i2c, int, 0444);
59 
60 /* insmod options used at runtime => read/write */
61 static int tuner_debug;
62 static unsigned int tv_range[2] = { 44, 958 };
63 static unsigned int radio_range[2] = { 65, 108 };
64 static char pal[] = "--";
65 static char secam[] = "--";
66 static char ntsc[] = "-";
67 
68 module_param_named(debug, tuner_debug, int, 0644);
69 module_param_array(tv_range, int, NULL, 0644);
70 module_param_array(radio_range, int, NULL, 0644);
71 module_param_string(pal, pal, sizeof(pal), 0644);
72 module_param_string(secam, secam, sizeof(secam), 0644);
73 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
74 
75 /*
76  * Static vars
77  */
78 
79 static LIST_HEAD(tuner_list);
80 static const struct v4l2_subdev_ops tuner_ops;
81 
82 /*
83  * Debug macros
84  */
85 
86 #undef pr_fmt
87 
88 #define pr_fmt(fmt) KBUILD_MODNAME ": %d-%04x: " fmt,		\
89 	i2c_adapter_id(t->i2c->adapter), t->i2c->addr
90 
91 
92 #define dprintk(fmt, arg...) do {					\
93 	if (tuner_debug)						\
94 		printk(KERN_DEBUG pr_fmt("%s: " fmt), __func__, ##arg);	\
95 } while (0)
96 
97 /*
98  * Internal enums/struct used inside the driver
99  */
100 
101 /**
102  * enum tuner_pad_index - tuner pad index for MEDIA_ENT_F_TUNER
103  *
104  * @TUNER_PAD_RF_INPUT:
105  *	Radiofrequency (RF) sink pad, usually linked to a RF connector entity.
106  * @TUNER_PAD_OUTPUT:
107  *	tuner video output source pad. Contains the video chrominance
108  *	and luminance or the hole bandwidth of the signal converted to
109  *	an Intermediate Frequency (IF) or to baseband (on zero-IF tuners).
110  * @TUNER_PAD_AUD_OUT:
111  *	Tuner audio output source pad. Tuners used to decode analog TV
112  *	signals have an extra pad for audio output. Old tuners use an
113  *	analog stage with a saw filter for the audio IF frequency. The
114  *	output of the pad is, in this case, the audio IF, with should be
115  *	decoded either by the bridge chipset (that's the case of cx2388x
116  *	chipsets) or may require an external IF sound processor, like
117  *	msp34xx. On modern silicon tuners, the audio IF decoder is usually
118  *	incorporated at the tuner. On such case, the output of this pad
119  *	is an audio sampled data.
120  * @TUNER_NUM_PADS:
121  *	Number of pads of the tuner.
122  */
123 enum tuner_pad_index {
124 	TUNER_PAD_RF_INPUT,
125 	TUNER_PAD_OUTPUT,
126 	TUNER_PAD_AUD_OUT,
127 	TUNER_NUM_PADS
128 };
129 
130 /**
131  * enum if_vid_dec_pad_index - video IF-PLL pad index
132  *	for MEDIA_ENT_F_IF_VID_DECODER
133  *
134  * @IF_VID_DEC_PAD_IF_INPUT:
135  *	video Intermediate Frequency (IF) sink pad
136  * @IF_VID_DEC_PAD_OUT:
137  *	IF-PLL video output source pad. Contains the video chrominance
138  *	and luminance IF signals.
139  * @IF_VID_DEC_PAD_NUM_PADS:
140  *	Number of pads of the video IF-PLL.
141  */
142 enum if_vid_dec_pad_index {
143 	IF_VID_DEC_PAD_IF_INPUT,
144 	IF_VID_DEC_PAD_OUT,
145 	IF_VID_DEC_PAD_NUM_PADS
146 };
147 
148 struct tuner {
149 	/* device */
150 	struct dvb_frontend fe;
151 	struct i2c_client   *i2c;
152 	struct v4l2_subdev  sd;
153 	struct list_head    list;
154 
155 	/* keep track of the current settings */
156 	v4l2_std_id         std;
157 	unsigned int        tv_freq;
158 	unsigned int        radio_freq;
159 	unsigned int        audmode;
160 
161 	enum v4l2_tuner_type mode;
162 	unsigned int        mode_mask; /* Combination of allowable modes */
163 
164 	bool                standby;	/* Standby mode */
165 
166 	unsigned int        type; /* chip type id */
167 	void                *config;
168 	const char          *name;
169 
170 #if defined(CONFIG_MEDIA_CONTROLLER)
171 	struct media_pad	pad[TUNER_NUM_PADS];
172 #endif
173 };
174 
175 /*
176  * Function prototypes
177  */
178 
179 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
180 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
181 
182 /*
183  * tuner attach/detach logic
184  */
185 
186 /* This macro allows us to probe dynamically, avoiding static links */
187 #ifdef CONFIG_MEDIA_ATTACH
188 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
189 	int __r = -EINVAL; \
190 	typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
191 	if (__a) { \
192 		__r = (int) __a(ARGS); \
193 		symbol_put(FUNCTION); \
194 	} else { \
195 		printk(KERN_ERR "TUNER: Unable to find " \
196 				"symbol "#FUNCTION"()\n"); \
197 	} \
198 	__r; \
199 })
200 
201 static void tuner_detach(struct dvb_frontend *fe)
202 {
203 	if (fe->ops.tuner_ops.release) {
204 		fe->ops.tuner_ops.release(fe);
205 		symbol_put_addr(fe->ops.tuner_ops.release);
206 	}
207 	if (fe->ops.analog_ops.release) {
208 		fe->ops.analog_ops.release(fe);
209 		symbol_put_addr(fe->ops.analog_ops.release);
210 	}
211 }
212 #else
213 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
214 	FUNCTION(ARGS); \
215 })
216 
217 static void tuner_detach(struct dvb_frontend *fe)
218 {
219 	if (fe->ops.tuner_ops.release)
220 		fe->ops.tuner_ops.release(fe);
221 	if (fe->ops.analog_ops.release)
222 		fe->ops.analog_ops.release(fe);
223 }
224 #endif
225 
226 
227 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
228 {
229 	return container_of(sd, struct tuner, sd);
230 }
231 
232 /*
233  * struct analog_demod_ops callbacks
234  */
235 
236 static void fe_set_params(struct dvb_frontend *fe,
237 			  struct analog_parameters *params)
238 {
239 	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
240 	struct tuner *t = fe->analog_demod_priv;
241 
242 	if (NULL == fe_tuner_ops->set_analog_params) {
243 		pr_warn("Tuner frontend module has no way to set freq\n");
244 		return;
245 	}
246 	fe_tuner_ops->set_analog_params(fe, params);
247 }
248 
249 static void fe_standby(struct dvb_frontend *fe)
250 {
251 	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
252 
253 	if (fe_tuner_ops->sleep)
254 		fe_tuner_ops->sleep(fe);
255 }
256 
257 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
258 {
259 	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
260 	struct tuner *t = fe->analog_demod_priv;
261 
262 	if (fe_tuner_ops->set_config)
263 		return fe_tuner_ops->set_config(fe, priv_cfg);
264 
265 	pr_warn("Tuner frontend module has no way to set config\n");
266 
267 	return 0;
268 }
269 
270 static void tuner_status(struct dvb_frontend *fe);
271 
272 static const struct analog_demod_ops tuner_analog_ops = {
273 	.set_params     = fe_set_params,
274 	.standby        = fe_standby,
275 	.set_config     = fe_set_config,
276 	.tuner_status   = tuner_status
277 };
278 
279 /*
280  * Functions to select between radio and TV and tuner probe/remove functions
281  */
282 
283 /**
284  * set_type - Sets the tuner type for a given device
285  *
286  * @c:			i2c_client descriptor
287  * @type:		type of the tuner (e. g. tuner number)
288  * @new_mode_mask:	Indicates if tuner supports TV and/or Radio
289  * @new_config:		an optional parameter used by a few tuners to adjust
290  *			internal parameters, like LNA mode
291  * @tuner_callback:	an optional function to be called when switching
292  *			to analog mode
293  *
294  * This function applies the tuner config to tuner specified
295  * by tun_setup structure. It contains several per-tuner initialization "magic"
296  */
297 static void set_type(struct i2c_client *c, unsigned int type,
298 		     unsigned int new_mode_mask, void *new_config,
299 		     int (*tuner_callback) (void *dev, int component, int cmd, int arg))
300 {
301 	struct tuner *t = to_tuner(i2c_get_clientdata(c));
302 	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
303 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
304 	unsigned char buffer[4];
305 	int tune_now = 1;
306 
307 	if (type == UNSET || type == TUNER_ABSENT) {
308 		dprintk("tuner 0x%02x: Tuner type absent\n", c->addr);
309 		return;
310 	}
311 
312 	t->type = type;
313 	t->config = new_config;
314 	if (tuner_callback != NULL) {
315 		dprintk("defining GPIO callback\n");
316 		t->fe.callback = tuner_callback;
317 	}
318 
319 	/* discard private data, in case set_type() was previously called */
320 	tuner_detach(&t->fe);
321 	t->fe.analog_demod_priv = NULL;
322 
323 	switch (t->type) {
324 	case TUNER_MT2032:
325 		if (!dvb_attach(microtune_attach,
326 			   &t->fe, t->i2c->adapter, t->i2c->addr))
327 			goto attach_failed;
328 		break;
329 	case TUNER_PHILIPS_TDA8290:
330 	{
331 		if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
332 				t->i2c->addr, t->config))
333 			goto attach_failed;
334 		break;
335 	}
336 	case TUNER_TEA5767:
337 		if (!dvb_attach(tea5767_attach, &t->fe,
338 				t->i2c->adapter, t->i2c->addr))
339 			goto attach_failed;
340 		t->mode_mask = T_RADIO;
341 		break;
342 	case TUNER_TEA5761:
343 		if (!dvb_attach(tea5761_attach, &t->fe,
344 				t->i2c->adapter, t->i2c->addr))
345 			goto attach_failed;
346 		t->mode_mask = T_RADIO;
347 		break;
348 	case TUNER_PHILIPS_FMD1216ME_MK3:
349 	case TUNER_PHILIPS_FMD1216MEX_MK3:
350 		buffer[0] = 0x0b;
351 		buffer[1] = 0xdc;
352 		buffer[2] = 0x9c;
353 		buffer[3] = 0x60;
354 		i2c_master_send(c, buffer, 4);
355 		mdelay(1);
356 		buffer[2] = 0x86;
357 		buffer[3] = 0x54;
358 		i2c_master_send(c, buffer, 4);
359 		if (!dvb_attach(simple_tuner_attach, &t->fe,
360 				t->i2c->adapter, t->i2c->addr, t->type))
361 			goto attach_failed;
362 		break;
363 	case TUNER_PHILIPS_TD1316:
364 		buffer[0] = 0x0b;
365 		buffer[1] = 0xdc;
366 		buffer[2] = 0x86;
367 		buffer[3] = 0xa4;
368 		i2c_master_send(c, buffer, 4);
369 		if (!dvb_attach(simple_tuner_attach, &t->fe,
370 				t->i2c->adapter, t->i2c->addr, t->type))
371 			goto attach_failed;
372 		break;
373 	case TUNER_XC2028:
374 	{
375 		struct xc2028_config cfg = {
376 			.i2c_adap  = t->i2c->adapter,
377 			.i2c_addr  = t->i2c->addr,
378 		};
379 		if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
380 			goto attach_failed;
381 		tune_now = 0;
382 		break;
383 	}
384 	case TUNER_TDA9887:
385 		if (!dvb_attach(tda9887_attach,
386 			   &t->fe, t->i2c->adapter, t->i2c->addr))
387 			goto attach_failed;
388 		break;
389 	case TUNER_XC5000:
390 	{
391 		struct xc5000_config xc5000_cfg = {
392 			.i2c_address = t->i2c->addr,
393 			/* if_khz will be set at dvb_attach() */
394 			.if_khz	  = 0,
395 		};
396 
397 		if (!dvb_attach(xc5000_attach,
398 				&t->fe, t->i2c->adapter, &xc5000_cfg))
399 			goto attach_failed;
400 		tune_now = 0;
401 		break;
402 	}
403 	case TUNER_XC5000C:
404 	{
405 		struct xc5000_config xc5000c_cfg = {
406 			.i2c_address = t->i2c->addr,
407 			/* if_khz will be set at dvb_attach() */
408 			.if_khz	  = 0,
409 			.chip_id  = XC5000C,
410 		};
411 
412 		if (!dvb_attach(xc5000_attach,
413 				&t->fe, t->i2c->adapter, &xc5000c_cfg))
414 			goto attach_failed;
415 		tune_now = 0;
416 		break;
417 	}
418 	case TUNER_NXP_TDA18271:
419 	{
420 		struct tda18271_config cfg = {
421 			.small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
422 		};
423 
424 		if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
425 				t->i2c->adapter, &cfg))
426 			goto attach_failed;
427 		tune_now = 0;
428 		break;
429 	}
430 	case TUNER_XC4000:
431 	{
432 		struct xc4000_config xc4000_cfg = {
433 			.i2c_address	  = t->i2c->addr,
434 			/* FIXME: the correct parameters will be set */
435 			/* only when the digital dvb_attach() occurs */
436 			.default_pm	  = 0,
437 			.dvb_amplitude	  = 0,
438 			.set_smoothedcvbs = 0,
439 			.if_khz		  = 0
440 		};
441 		if (!dvb_attach(xc4000_attach,
442 				&t->fe, t->i2c->adapter, &xc4000_cfg))
443 			goto attach_failed;
444 		tune_now = 0;
445 		break;
446 	}
447 	default:
448 		if (!dvb_attach(simple_tuner_attach, &t->fe,
449 				t->i2c->adapter, t->i2c->addr, t->type))
450 			goto attach_failed;
451 
452 		break;
453 	}
454 
455 	if ((NULL == analog_ops->set_params) &&
456 	    (fe_tuner_ops->set_analog_params)) {
457 
458 		t->name = fe_tuner_ops->info.name;
459 
460 		t->fe.analog_demod_priv = t;
461 		memcpy(analog_ops, &tuner_analog_ops,
462 		       sizeof(struct analog_demod_ops));
463 
464 		if (fe_tuner_ops->get_rf_strength)
465 			analog_ops->has_signal = fe_tuner_ops->get_rf_strength;
466 		if (fe_tuner_ops->get_afc)
467 			analog_ops->get_afc = fe_tuner_ops->get_afc;
468 
469 	} else {
470 		t->name = analog_ops->info.name;
471 	}
472 
473 #ifdef CONFIG_MEDIA_CONTROLLER
474 	t->sd.entity.name = t->name;
475 #endif
476 
477 	dprintk("type set to %s\n", t->name);
478 
479 	t->mode_mask = new_mode_mask;
480 
481 	/* Some tuners require more initialization setup before use,
482 	   such as firmware download or device calibration.
483 	   trying to set a frequency here will just fail
484 	   FIXME: better to move set_freq to the tuner code. This is needed
485 	   on analog tuners for PLL to properly work
486 	 */
487 	if (tune_now) {
488 		if (V4L2_TUNER_RADIO == t->mode)
489 			set_radio_freq(c, t->radio_freq);
490 		else
491 			set_tv_freq(c, t->tv_freq);
492 	}
493 
494 	dprintk("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
495 		  c->adapter->name, c->dev.driver->name, c->addr << 1, type,
496 		  t->mode_mask);
497 	return;
498 
499 attach_failed:
500 	dprintk("Tuner attach for type = %d failed.\n", t->type);
501 	t->type = TUNER_ABSENT;
502 
503 	return;
504 }
505 
506 /**
507  * tuner_s_type_addr - Sets the tuner type for a device
508  *
509  * @sd:		subdev descriptor
510  * @tun_setup:	type to be associated to a given tuner i2c address
511  *
512  * This function applies the tuner config to tuner specified
513  * by tun_setup structure.
514  * If tuner I2C address is UNSET, then it will only set the device
515  * if the tuner supports the mode specified in the call.
516  * If the address is specified, the change will be applied only if
517  * tuner I2C address matches.
518  * The call can change the tuner number and the tuner mode.
519  */
520 static int tuner_s_type_addr(struct v4l2_subdev *sd,
521 			     struct tuner_setup *tun_setup)
522 {
523 	struct tuner *t = to_tuner(sd);
524 	struct i2c_client *c = v4l2_get_subdevdata(sd);
525 
526 	dprintk("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n",
527 			tun_setup->type,
528 			tun_setup->addr,
529 			tun_setup->mode_mask,
530 			tun_setup->config);
531 
532 	if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
533 	    (t->mode_mask & tun_setup->mode_mask))) ||
534 	    (tun_setup->addr == c->addr)) {
535 		set_type(c, tun_setup->type, tun_setup->mode_mask,
536 			 tun_setup->config, tun_setup->tuner_callback);
537 	} else
538 		dprintk("set addr discarded for type %i, mask %x. Asked to change tuner at addr 0x%02x, with mask %x\n",
539 			  t->type, t->mode_mask,
540 			  tun_setup->addr, tun_setup->mode_mask);
541 
542 	return 0;
543 }
544 
545 /**
546  * tuner_s_config - Sets tuner configuration
547  *
548  * @sd:		subdev descriptor
549  * @cfg:	tuner configuration
550  *
551  * Calls tuner set_config() private function to set some tuner-internal
552  * parameters
553  */
554 static int tuner_s_config(struct v4l2_subdev *sd,
555 			  const struct v4l2_priv_tun_config *cfg)
556 {
557 	struct tuner *t = to_tuner(sd);
558 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
559 
560 	if (t->type != cfg->tuner)
561 		return 0;
562 
563 	if (analog_ops->set_config) {
564 		analog_ops->set_config(&t->fe, cfg->priv);
565 		return 0;
566 	}
567 
568 	dprintk("Tuner frontend module has no way to set config\n");
569 	return 0;
570 }
571 
572 /**
573  * tuner_lookup - Seek for tuner adapters
574  *
575  * @adap:	i2c_adapter struct
576  * @radio:	pointer to be filled if the adapter is radio
577  * @tv:		pointer to be filled if the adapter is TV
578  *
579  * Search for existing radio and/or TV tuners on the given I2C adapter,
580  * discarding demod-only adapters (tda9887).
581  *
582  * Note that when this function is called from tuner_probe you can be
583  * certain no other devices will be added/deleted at the same time, I2C
584  * core protects against that.
585  */
586 static void tuner_lookup(struct i2c_adapter *adap,
587 		struct tuner **radio, struct tuner **tv)
588 {
589 	struct tuner *pos;
590 
591 	*radio = NULL;
592 	*tv = NULL;
593 
594 	list_for_each_entry(pos, &tuner_list, list) {
595 		int mode_mask;
596 
597 		if (pos->i2c->adapter != adap ||
598 		    strcmp(pos->i2c->dev.driver->name, "tuner"))
599 			continue;
600 
601 		mode_mask = pos->mode_mask;
602 		if (*radio == NULL && mode_mask == T_RADIO)
603 			*radio = pos;
604 		/* Note: currently TDA9887 is the only demod-only
605 		   device. If other devices appear then we need to
606 		   make this test more general. */
607 		else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
608 			 (pos->mode_mask & T_ANALOG_TV))
609 			*tv = pos;
610 	}
611 }
612 
613 /**
614  *tuner_probe - Probes the existing tuners on an I2C bus
615  *
616  * @client:	i2c_client descriptor
617  * @id:		not used
618  *
619  * This routine probes for tuners at the expected I2C addresses. On most
620  * cases, if a device answers to a given I2C address, it assumes that the
621  * device is a tuner. On a few cases, however, an additional logic is needed
622  * to double check if the device is really a tuner, or to identify the tuner
623  * type, like on tea5767/5761 devices.
624  *
625  * During client attach, set_type is called by adapter's attach_inform callback.
626  * set_type must then be completed by tuner_probe.
627  */
628 static int tuner_probe(struct i2c_client *client,
629 		       const struct i2c_device_id *id)
630 {
631 	struct tuner *t;
632 	struct tuner *radio;
633 	struct tuner *tv;
634 #ifdef CONFIG_MEDIA_CONTROLLER
635 	int ret;
636 #endif
637 
638 	t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
639 	if (NULL == t)
640 		return -ENOMEM;
641 	v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
642 	t->i2c = client;
643 	t->name = "(tuner unset)";
644 	t->type = UNSET;
645 	t->audmode = V4L2_TUNER_MODE_STEREO;
646 	t->standby = true;
647 	t->radio_freq = 87.5 * 16000;	/* Initial freq range */
648 	t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
649 
650 	if (show_i2c) {
651 		unsigned char buffer[16];
652 		int rc;
653 
654 		memset(buffer, 0, sizeof(buffer));
655 		rc = i2c_master_recv(client, buffer, sizeof(buffer));
656 		if (rc >= 0)
657 			pr_info("I2C RECV = %*ph\n", rc, buffer);
658 	}
659 
660 	/* autodetection code based on the i2c addr */
661 	if (!no_autodetect) {
662 		switch (client->addr) {
663 		case 0x10:
664 			if (tuner_symbol_probe(tea5761_autodetection,
665 					       t->i2c->adapter,
666 					       t->i2c->addr) >= 0) {
667 				t->type = TUNER_TEA5761;
668 				t->mode_mask = T_RADIO;
669 				tuner_lookup(t->i2c->adapter, &radio, &tv);
670 				if (tv)
671 					tv->mode_mask &= ~T_RADIO;
672 
673 				goto register_client;
674 			}
675 			kfree(t);
676 			return -ENODEV;
677 		case 0x42:
678 		case 0x43:
679 		case 0x4a:
680 		case 0x4b:
681 			/* If chip is not tda8290, don't register.
682 			   since it can be tda9887*/
683 			if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
684 					       t->i2c->addr) >= 0) {
685 				dprintk("tda829x detected\n");
686 			} else {
687 				/* Default is being tda9887 */
688 				t->type = TUNER_TDA9887;
689 				t->mode_mask = T_RADIO | T_ANALOG_TV;
690 				goto register_client;
691 			}
692 			break;
693 		case 0x60:
694 			if (tuner_symbol_probe(tea5767_autodetection,
695 					       t->i2c->adapter, t->i2c->addr)
696 					>= 0) {
697 				t->type = TUNER_TEA5767;
698 				t->mode_mask = T_RADIO;
699 				/* Sets freq to FM range */
700 				tuner_lookup(t->i2c->adapter, &radio, &tv);
701 				if (tv)
702 					tv->mode_mask &= ~T_RADIO;
703 
704 				goto register_client;
705 			}
706 			break;
707 		}
708 	}
709 
710 	/* Initializes only the first TV tuner on this adapter. Why only the
711 	   first? Because there are some devices (notably the ones with TI
712 	   tuners) that have more than one i2c address for the *same* device.
713 	   Experience shows that, except for just one case, the first
714 	   address is the right one. The exception is a Russian tuner
715 	   (ACORP_Y878F). So, the desired behavior is just to enable the
716 	   first found TV tuner. */
717 	tuner_lookup(t->i2c->adapter, &radio, &tv);
718 	if (tv == NULL) {
719 		t->mode_mask = T_ANALOG_TV;
720 		if (radio == NULL)
721 			t->mode_mask |= T_RADIO;
722 		dprintk("Setting mode_mask to 0x%02x\n", t->mode_mask);
723 	}
724 
725 	/* Should be just before return */
726 register_client:
727 #if defined(CONFIG_MEDIA_CONTROLLER)
728 	t->sd.entity.name = t->name;
729 	/*
730 	 * Handle the special case where the tuner has actually
731 	 * two stages: the PLL to tune into a frequency and the
732 	 * IF-PLL demodulator (tda988x).
733 	 */
734 	if (t->type == TUNER_TDA9887) {
735 		t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
736 		t->pad[IF_VID_DEC_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
737 		t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
738 		t->pad[IF_VID_DEC_PAD_OUT].sig_type = PAD_SIGNAL_ANALOG;
739 		ret = media_entity_pads_init(&t->sd.entity,
740 					     IF_VID_DEC_PAD_NUM_PADS,
741 					     &t->pad[0]);
742 		t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
743 	} else {
744 		t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
745 		t->pad[TUNER_PAD_RF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
746 		t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
747 		t->pad[TUNER_PAD_OUTPUT].sig_type = PAD_SIGNAL_ANALOG;
748 		t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
749 		t->pad[TUNER_PAD_AUD_OUT].sig_type = PAD_SIGNAL_AUDIO;
750 		ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
751 					     &t->pad[0]);
752 		t->sd.entity.function = MEDIA_ENT_F_TUNER;
753 	}
754 
755 	if (ret < 0) {
756 		pr_err("failed to initialize media entity!\n");
757 		kfree(t);
758 		return ret;
759 	}
760 #endif
761 	/* Sets a default mode */
762 	if (t->mode_mask & T_ANALOG_TV)
763 		t->mode = V4L2_TUNER_ANALOG_TV;
764 	else
765 		t->mode = V4L2_TUNER_RADIO;
766 	set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
767 	list_add_tail(&t->list, &tuner_list);
768 
769 	pr_info("Tuner %d found with type(s)%s%s.\n",
770 		   t->type,
771 		   t->mode_mask & T_RADIO ? " Radio" : "",
772 		   t->mode_mask & T_ANALOG_TV ? " TV" : "");
773 	return 0;
774 }
775 
776 /**
777  * tuner_remove - detaches a tuner
778  *
779  * @client:	i2c_client descriptor
780  */
781 
782 static int tuner_remove(struct i2c_client *client)
783 {
784 	struct tuner *t = to_tuner(i2c_get_clientdata(client));
785 
786 	v4l2_device_unregister_subdev(&t->sd);
787 	tuner_detach(&t->fe);
788 	t->fe.analog_demod_priv = NULL;
789 
790 	list_del(&t->list);
791 	kfree(t);
792 	return 0;
793 }
794 
795 /*
796  * Functions to switch between Radio and TV
797  *
798  * A few cards have a separate I2C tuner for radio. Those routines
799  * take care of switching between TV/Radio mode, filtering only the
800  * commands that apply to the Radio or TV tuner.
801  */
802 
803 /**
804  * check_mode - Verify if tuner supports the requested mode
805  * @t: a pointer to the module's internal struct_tuner
806  * @mode: mode of the tuner, as defined by &enum v4l2_tuner_type.
807  *
808  * This function checks if the tuner is capable of tuning analog TV,
809  * digital TV or radio, depending on what the caller wants. If the
810  * tuner can't support that mode, it returns -EINVAL. Otherwise, it
811  * returns 0.
812  * This function is needed for boards that have a separate tuner for
813  * radio (like devices with tea5767).
814  *
815  * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
816  *       select a TV frequency. So, t_mode = T_ANALOG_TV could actually
817  *	 be used to represent a Digital TV too.
818  */
819 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
820 {
821 	int t_mode;
822 	if (mode == V4L2_TUNER_RADIO)
823 		t_mode = T_RADIO;
824 	else
825 		t_mode = T_ANALOG_TV;
826 
827 	if ((t_mode & t->mode_mask) == 0)
828 		return -EINVAL;
829 
830 	return 0;
831 }
832 
833 /**
834  * set_mode - Switch tuner to other mode.
835  * @t:		a pointer to the module's internal struct_tuner
836  * @mode:	enum v4l2_type (radio or TV)
837  *
838  * If tuner doesn't support the needed mode (radio or TV), prints a
839  * debug message and returns -EINVAL, changing its state to standby.
840  * Otherwise, changes the mode and returns 0.
841  */
842 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
843 {
844 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
845 
846 	if (mode != t->mode) {
847 		if (check_mode(t, mode) == -EINVAL) {
848 			dprintk("Tuner doesn't support mode %d. Putting tuner to sleep\n",
849 				  mode);
850 			t->standby = true;
851 			if (analog_ops->standby)
852 				analog_ops->standby(&t->fe);
853 			return -EINVAL;
854 		}
855 		t->mode = mode;
856 		dprintk("Changing to mode %d\n", mode);
857 	}
858 	return 0;
859 }
860 
861 /**
862  * set_freq - Set the tuner to the desired frequency.
863  * @t:		a pointer to the module's internal struct_tuner
864  * @freq:	frequency to set (0 means to use the current frequency)
865  */
866 static void set_freq(struct tuner *t, unsigned int freq)
867 {
868 	struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
869 
870 	if (t->mode == V4L2_TUNER_RADIO) {
871 		if (!freq)
872 			freq = t->radio_freq;
873 		set_radio_freq(client, freq);
874 	} else {
875 		if (!freq)
876 			freq = t->tv_freq;
877 		set_tv_freq(client, freq);
878 	}
879 }
880 
881 /*
882  * Functions that are specific for TV mode
883  */
884 
885 /**
886  * set_tv_freq - Set tuner frequency,  freq in Units of 62.5 kHz = 1/16MHz
887  *
888  * @c:	i2c_client descriptor
889  * @freq: frequency
890  */
891 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
892 {
893 	struct tuner *t = to_tuner(i2c_get_clientdata(c));
894 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
895 
896 	struct analog_parameters params = {
897 		.mode      = t->mode,
898 		.audmode   = t->audmode,
899 		.std       = t->std
900 	};
901 
902 	if (t->type == UNSET) {
903 		pr_warn("tuner type not set\n");
904 		return;
905 	}
906 	if (NULL == analog_ops->set_params) {
907 		pr_warn("Tuner has no way to set tv freq\n");
908 		return;
909 	}
910 	if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
911 		dprintk("TV freq (%d.%02d) out of range (%d-%d)\n",
912 			   freq / 16, freq % 16 * 100 / 16, tv_range[0],
913 			   tv_range[1]);
914 		/* V4L2 spec: if the freq is not possible then the closest
915 		   possible value should be selected */
916 		if (freq < tv_range[0] * 16)
917 			freq = tv_range[0] * 16;
918 		else
919 			freq = tv_range[1] * 16;
920 	}
921 	params.frequency = freq;
922 	dprintk("tv freq set to %d.%02d\n",
923 			freq / 16, freq % 16 * 100 / 16);
924 	t->tv_freq = freq;
925 	t->standby = false;
926 
927 	analog_ops->set_params(&t->fe, &params);
928 }
929 
930 /**
931  * tuner_fixup_std - force a given video standard variant
932  *
933  * @t: tuner internal struct
934  * @std:	TV standard
935  *
936  * A few devices or drivers have problem to detect some standard variations.
937  * On other operational systems, the drivers generally have a per-country
938  * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
939  * such hacks. Instead, it relies on a proper video standard selection from
940  * the userspace application. However, as some apps are buggy, not allowing
941  * to distinguish all video standard variations, a modprobe parameter can
942  * be used to force a video standard match.
943  */
944 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
945 {
946 	if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
947 		switch (pal[0]) {
948 		case '6':
949 			return V4L2_STD_PAL_60;
950 		case 'b':
951 		case 'B':
952 		case 'g':
953 		case 'G':
954 			return V4L2_STD_PAL_BG;
955 		case 'i':
956 		case 'I':
957 			return V4L2_STD_PAL_I;
958 		case 'd':
959 		case 'D':
960 		case 'k':
961 		case 'K':
962 			return V4L2_STD_PAL_DK;
963 		case 'M':
964 		case 'm':
965 			return V4L2_STD_PAL_M;
966 		case 'N':
967 		case 'n':
968 			if (pal[1] == 'c' || pal[1] == 'C')
969 				return V4L2_STD_PAL_Nc;
970 			return V4L2_STD_PAL_N;
971 		default:
972 			pr_warn("pal= argument not recognised\n");
973 			break;
974 		}
975 	}
976 	if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
977 		switch (secam[0]) {
978 		case 'b':
979 		case 'B':
980 		case 'g':
981 		case 'G':
982 		case 'h':
983 		case 'H':
984 			return V4L2_STD_SECAM_B |
985 			       V4L2_STD_SECAM_G |
986 			       V4L2_STD_SECAM_H;
987 		case 'd':
988 		case 'D':
989 		case 'k':
990 		case 'K':
991 			return V4L2_STD_SECAM_DK;
992 		case 'l':
993 		case 'L':
994 			if ((secam[1] == 'C') || (secam[1] == 'c'))
995 				return V4L2_STD_SECAM_LC;
996 			return V4L2_STD_SECAM_L;
997 		default:
998 			pr_warn("secam= argument not recognised\n");
999 			break;
1000 		}
1001 	}
1002 
1003 	if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1004 		switch (ntsc[0]) {
1005 		case 'm':
1006 		case 'M':
1007 			return V4L2_STD_NTSC_M;
1008 		case 'j':
1009 		case 'J':
1010 			return V4L2_STD_NTSC_M_JP;
1011 		case 'k':
1012 		case 'K':
1013 			return V4L2_STD_NTSC_M_KR;
1014 		default:
1015 			pr_info("ntsc= argument not recognised\n");
1016 			break;
1017 		}
1018 	}
1019 	return std;
1020 }
1021 
1022 /*
1023  * Functions that are specific for Radio mode
1024  */
1025 
1026 /**
1027  * set_radio_freq - Set tuner frequency,  freq in Units of 62.5 Hz  = 1/16kHz
1028  *
1029  * @c:	i2c_client descriptor
1030  * @freq: frequency
1031  */
1032 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
1033 {
1034 	struct tuner *t = to_tuner(i2c_get_clientdata(c));
1035 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1036 
1037 	struct analog_parameters params = {
1038 		.mode      = t->mode,
1039 		.audmode   = t->audmode,
1040 		.std       = t->std
1041 	};
1042 
1043 	if (t->type == UNSET) {
1044 		pr_warn("tuner type not set\n");
1045 		return;
1046 	}
1047 	if (NULL == analog_ops->set_params) {
1048 		pr_warn("tuner has no way to set radio frequency\n");
1049 		return;
1050 	}
1051 	if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1052 		dprintk("radio freq (%d.%02d) out of range (%d-%d)\n",
1053 			   freq / 16000, freq % 16000 * 100 / 16000,
1054 			   radio_range[0], radio_range[1]);
1055 		/* V4L2 spec: if the freq is not possible then the closest
1056 		   possible value should be selected */
1057 		if (freq < radio_range[0] * 16000)
1058 			freq = radio_range[0] * 16000;
1059 		else
1060 			freq = radio_range[1] * 16000;
1061 	}
1062 	params.frequency = freq;
1063 	dprintk("radio freq set to %d.%02d\n",
1064 			freq / 16000, freq % 16000 * 100 / 16000);
1065 	t->radio_freq = freq;
1066 	t->standby = false;
1067 
1068 	analog_ops->set_params(&t->fe, &params);
1069 	/*
1070 	 * The tuner driver might decide to change the audmode if it only
1071 	 * supports stereo, so update t->audmode.
1072 	 */
1073 	t->audmode = params.audmode;
1074 }
1075 
1076 /*
1077  * Debug function for reporting tuner status to userspace
1078  */
1079 
1080 /**
1081  * tuner_status - Dumps the current tuner status at dmesg
1082  * @fe: pointer to struct dvb_frontend
1083  *
1084  * This callback is used only for driver debug purposes, answering to
1085  * VIDIOC_LOG_STATUS. No changes should happen on this call.
1086  */
1087 static void tuner_status(struct dvb_frontend *fe)
1088 {
1089 	struct tuner *t = fe->analog_demod_priv;
1090 	unsigned long freq, freq_fraction;
1091 	struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1092 	struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1093 	const char *p;
1094 
1095 	switch (t->mode) {
1096 	case V4L2_TUNER_RADIO:
1097 		p = "radio";
1098 		break;
1099 	case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1100 		p = "digital TV";
1101 		break;
1102 	case V4L2_TUNER_ANALOG_TV:
1103 	default:
1104 		p = "analog TV";
1105 		break;
1106 	}
1107 	if (t->mode == V4L2_TUNER_RADIO) {
1108 		freq = t->radio_freq / 16000;
1109 		freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1110 	} else {
1111 		freq = t->tv_freq / 16;
1112 		freq_fraction = (t->tv_freq % 16) * 100 / 16;
1113 	}
1114 	pr_info("Tuner mode:      %s%s\n", p,
1115 		   t->standby ? " on standby mode" : "");
1116 	pr_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
1117 	pr_info("Standard:        0x%08lx\n", (unsigned long)t->std);
1118 	if (t->mode != V4L2_TUNER_RADIO)
1119 		return;
1120 	if (fe_tuner_ops->get_status) {
1121 		u32 tuner_status;
1122 
1123 		fe_tuner_ops->get_status(&t->fe, &tuner_status);
1124 		if (tuner_status & TUNER_STATUS_LOCKED)
1125 			pr_info("Tuner is locked.\n");
1126 		if (tuner_status & TUNER_STATUS_STEREO)
1127 			pr_info("Stereo:          yes\n");
1128 	}
1129 	if (analog_ops->has_signal) {
1130 		u16 signal;
1131 
1132 		if (!analog_ops->has_signal(fe, &signal))
1133 			pr_info("Signal strength: %hu\n", signal);
1134 	}
1135 }
1136 
1137 /*
1138  * Function to splicitly change mode to radio. Probably not needed anymore
1139  */
1140 
1141 static int tuner_s_radio(struct v4l2_subdev *sd)
1142 {
1143 	struct tuner *t = to_tuner(sd);
1144 
1145 	if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1146 		set_freq(t, 0);
1147 	return 0;
1148 }
1149 
1150 /*
1151  * Tuner callbacks to handle userspace ioctl's
1152  */
1153 
1154 /**
1155  * tuner_standby - places the tuner in standby mode
1156  * @sd: pointer to struct v4l2_subdev
1157  */
1158 static int tuner_standby(struct v4l2_subdev *sd)
1159 {
1160 	struct tuner *t = to_tuner(sd);
1161 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1162 
1163 	dprintk("Putting tuner to sleep\n");
1164 	t->standby = true;
1165 	if (analog_ops->standby)
1166 		analog_ops->standby(&t->fe);
1167 	return 0;
1168 }
1169 
1170 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1171 {
1172 	struct tuner *t = to_tuner(sd);
1173 
1174 	if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1175 		return 0;
1176 
1177 	t->std = tuner_fixup_std(t, std);
1178 	if (t->std != std)
1179 		dprintk("Fixup standard %llx to %llx\n", std, t->std);
1180 	set_freq(t, 0);
1181 	return 0;
1182 }
1183 
1184 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1185 {
1186 	struct tuner *t = to_tuner(sd);
1187 
1188 	if (set_mode(t, f->type) == 0)
1189 		set_freq(t, f->frequency);
1190 	return 0;
1191 }
1192 
1193 /**
1194  * tuner_g_frequency - Get the tuned frequency for the tuner
1195  * @sd: pointer to struct v4l2_subdev
1196  * @f: pointer to struct v4l2_frequency
1197  *
1198  * At return, the structure f will be filled with tuner frequency
1199  * if the tuner matches the f->type.
1200  * Note: f->type should be initialized before calling it.
1201  * This is done by either video_ioctl2 or by the bridge driver.
1202  */
1203 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1204 {
1205 	struct tuner *t = to_tuner(sd);
1206 	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1207 
1208 	if (check_mode(t, f->type) == -EINVAL)
1209 		return 0;
1210 	if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1211 		u32 abs_freq;
1212 
1213 		fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1214 		f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1215 			DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1216 			DIV_ROUND_CLOSEST(abs_freq, 62500);
1217 	} else {
1218 		f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1219 			t->radio_freq : t->tv_freq;
1220 	}
1221 	return 0;
1222 }
1223 
1224 /**
1225  * tuner_g_tuner - Fill in tuner information
1226  * @sd: pointer to struct v4l2_subdev
1227  * @vt: pointer to struct v4l2_tuner
1228  *
1229  * At return, the structure vt will be filled with tuner information
1230  * if the tuner matches vt->type.
1231  * Note: vt->type should be initialized before calling it.
1232  * This is done by either video_ioctl2 or by the bridge driver.
1233  */
1234 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1235 {
1236 	struct tuner *t = to_tuner(sd);
1237 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1238 	struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1239 
1240 	if (check_mode(t, vt->type) == -EINVAL)
1241 		return 0;
1242 	if (vt->type == t->mode && analog_ops->get_afc)
1243 		analog_ops->get_afc(&t->fe, &vt->afc);
1244 	if (vt->type == t->mode && analog_ops->has_signal) {
1245 		u16 signal = (u16)vt->signal;
1246 
1247 		if (!analog_ops->has_signal(&t->fe, &signal))
1248 			vt->signal = signal;
1249 	}
1250 	if (vt->type != V4L2_TUNER_RADIO) {
1251 		vt->capability |= V4L2_TUNER_CAP_NORM;
1252 		vt->rangelow = tv_range[0] * 16;
1253 		vt->rangehigh = tv_range[1] * 16;
1254 		return 0;
1255 	}
1256 
1257 	/* radio mode */
1258 	if (vt->type == t->mode) {
1259 		vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1260 		if (fe_tuner_ops->get_status) {
1261 			u32 tuner_status;
1262 
1263 			fe_tuner_ops->get_status(&t->fe, &tuner_status);
1264 			vt->rxsubchans =
1265 				(tuner_status & TUNER_STATUS_STEREO) ?
1266 				V4L2_TUNER_SUB_STEREO :
1267 				V4L2_TUNER_SUB_MONO;
1268 		}
1269 		vt->audmode = t->audmode;
1270 	}
1271 	vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1272 	vt->rangelow = radio_range[0] * 16000;
1273 	vt->rangehigh = radio_range[1] * 16000;
1274 
1275 	return 0;
1276 }
1277 
1278 /**
1279  * tuner_s_tuner - Set the tuner's audio mode
1280  * @sd: pointer to struct v4l2_subdev
1281  * @vt: pointer to struct v4l2_tuner
1282  *
1283  * Sets the audio mode if the tuner matches vt->type.
1284  * Note: vt->type should be initialized before calling it.
1285  * This is done by either video_ioctl2 or by the bridge driver.
1286  */
1287 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1288 {
1289 	struct tuner *t = to_tuner(sd);
1290 
1291 	if (set_mode(t, vt->type))
1292 		return 0;
1293 
1294 	if (t->mode == V4L2_TUNER_RADIO) {
1295 		t->audmode = vt->audmode;
1296 		/*
1297 		 * For radio audmode can only be mono or stereo. Map any
1298 		 * other values to stereo. The actual tuner driver that is
1299 		 * called in set_radio_freq can decide to limit the audmode to
1300 		 * mono if only mono is supported.
1301 		 */
1302 		if (t->audmode != V4L2_TUNER_MODE_MONO &&
1303 		    t->audmode != V4L2_TUNER_MODE_STEREO)
1304 			t->audmode = V4L2_TUNER_MODE_STEREO;
1305 	}
1306 	set_freq(t, 0);
1307 
1308 	return 0;
1309 }
1310 
1311 static int tuner_log_status(struct v4l2_subdev *sd)
1312 {
1313 	struct tuner *t = to_tuner(sd);
1314 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1315 
1316 	if (analog_ops->tuner_status)
1317 		analog_ops->tuner_status(&t->fe);
1318 	return 0;
1319 }
1320 
1321 #ifdef CONFIG_PM_SLEEP
1322 static int tuner_suspend(struct device *dev)
1323 {
1324 	struct i2c_client *c = to_i2c_client(dev);
1325 	struct tuner *t = to_tuner(i2c_get_clientdata(c));
1326 	struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1327 
1328 	dprintk("suspend\n");
1329 
1330 	if (t->fe.ops.tuner_ops.suspend)
1331 		t->fe.ops.tuner_ops.suspend(&t->fe);
1332 	else if (!t->standby && analog_ops->standby)
1333 		analog_ops->standby(&t->fe);
1334 
1335 	return 0;
1336 }
1337 
1338 static int tuner_resume(struct device *dev)
1339 {
1340 	struct i2c_client *c = to_i2c_client(dev);
1341 	struct tuner *t = to_tuner(i2c_get_clientdata(c));
1342 
1343 	dprintk("resume\n");
1344 
1345 	if (t->fe.ops.tuner_ops.resume)
1346 		t->fe.ops.tuner_ops.resume(&t->fe);
1347 	else if (!t->standby)
1348 		if (set_mode(t, t->mode) == 0)
1349 			set_freq(t, 0);
1350 
1351 	return 0;
1352 }
1353 #endif
1354 
1355 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1356 {
1357 	struct v4l2_subdev *sd = i2c_get_clientdata(client);
1358 
1359 	/* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1360 	   to handle it here.
1361 	   There must be a better way of doing this... */
1362 	switch (cmd) {
1363 	case TUNER_SET_CONFIG:
1364 		return tuner_s_config(sd, arg);
1365 	}
1366 	return -ENOIOCTLCMD;
1367 }
1368 
1369 /*
1370  * Callback structs
1371  */
1372 
1373 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1374 	.log_status = tuner_log_status,
1375 };
1376 
1377 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1378 	.standby = tuner_standby,
1379 	.s_radio = tuner_s_radio,
1380 	.g_tuner = tuner_g_tuner,
1381 	.s_tuner = tuner_s_tuner,
1382 	.s_frequency = tuner_s_frequency,
1383 	.g_frequency = tuner_g_frequency,
1384 	.s_type_addr = tuner_s_type_addr,
1385 	.s_config = tuner_s_config,
1386 };
1387 
1388 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1389 	.s_std = tuner_s_std,
1390 };
1391 
1392 static const struct v4l2_subdev_ops tuner_ops = {
1393 	.core = &tuner_core_ops,
1394 	.tuner = &tuner_tuner_ops,
1395 	.video = &tuner_video_ops,
1396 };
1397 
1398 /*
1399  * I2C structs and module init functions
1400  */
1401 
1402 static const struct dev_pm_ops tuner_pm_ops = {
1403 	SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1404 };
1405 
1406 static const struct i2c_device_id tuner_id[] = {
1407 	{ "tuner", }, /* autodetect */
1408 	{ }
1409 };
1410 MODULE_DEVICE_TABLE(i2c, tuner_id);
1411 
1412 static struct i2c_driver tuner_driver = {
1413 	.driver = {
1414 		.name	= "tuner",
1415 		.pm	= &tuner_pm_ops,
1416 	},
1417 	.probe		= tuner_probe,
1418 	.remove		= tuner_remove,
1419 	.command	= tuner_command,
1420 	.id_table	= tuner_id,
1421 };
1422 
1423 module_i2c_driver(tuner_driver);
1424 
1425 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1426 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1427 MODULE_LICENSE("GPL");
1428