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