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
tuner_detach(struct dvb_frontend * fe)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
tuner_detach(struct dvb_frontend * fe)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
to_tuner(struct v4l2_subdev * sd)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
fe_set_params(struct dvb_frontend * fe,struct analog_parameters * params)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
fe_standby(struct dvb_frontend * fe)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
fe_set_config(struct dvb_frontend * fe,void * priv_cfg)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 */
set_type(struct i2c_client * c,unsigned int type,unsigned int new_mode_mask,void * new_config,int (* tuner_callback)(void * dev,int component,int cmd,int arg))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 */
tuner_s_type_addr(struct v4l2_subdev * sd,struct tuner_setup * tun_setup)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 */
tuner_s_config(struct v4l2_subdev * sd,const struct v4l2_priv_tun_config * cfg)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 */
tuner_lookup(struct i2c_adapter * adap,struct tuner ** radio,struct tuner ** tv)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 *
618 * This routine probes for tuners at the expected I2C addresses. On most
619 * cases, if a device answers to a given I2C address, it assumes that the
620 * device is a tuner. On a few cases, however, an additional logic is needed
621 * to double check if the device is really a tuner, or to identify the tuner
622 * type, like on tea5767/5761 devices.
623 *
624 * During client attach, set_type is called by adapter's attach_inform callback.
625 * set_type must then be completed by tuner_probe.
626 */
tuner_probe(struct i2c_client * client)627 static int tuner_probe(struct i2c_client *client)
628 {
629 struct tuner *t;
630 struct tuner *radio;
631 struct tuner *tv;
632 #ifdef CONFIG_MEDIA_CONTROLLER
633 int ret;
634 #endif
635
636 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
637 if (NULL == t)
638 return -ENOMEM;
639 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
640 t->i2c = client;
641 t->name = "(tuner unset)";
642 t->type = UNSET;
643 t->audmode = V4L2_TUNER_MODE_STEREO;
644 t->standby = true;
645 t->radio_freq = 87.5 * 16000; /* Initial freq range */
646 t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
647
648 if (show_i2c) {
649 unsigned char buffer[16];
650 int rc;
651
652 memset(buffer, 0, sizeof(buffer));
653 rc = i2c_master_recv(client, buffer, sizeof(buffer));
654 if (rc >= 0)
655 pr_info("I2C RECV = %*ph\n", rc, buffer);
656 }
657
658 /* autodetection code based on the i2c addr */
659 if (!no_autodetect) {
660 switch (client->addr) {
661 case 0x10:
662 if (tuner_symbol_probe(tea5761_autodetection,
663 t->i2c->adapter,
664 t->i2c->addr) >= 0) {
665 t->type = TUNER_TEA5761;
666 t->mode_mask = T_RADIO;
667 tuner_lookup(t->i2c->adapter, &radio, &tv);
668 if (tv)
669 tv->mode_mask &= ~T_RADIO;
670
671 goto register_client;
672 }
673 kfree(t);
674 return -ENODEV;
675 case 0x42:
676 case 0x43:
677 case 0x4a:
678 case 0x4b:
679 /* If chip is not tda8290, don't register.
680 since it can be tda9887*/
681 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
682 t->i2c->addr) >= 0) {
683 dprintk("tda829x detected\n");
684 } else {
685 /* Default is being tda9887 */
686 t->type = TUNER_TDA9887;
687 t->mode_mask = T_RADIO | T_ANALOG_TV;
688 goto register_client;
689 }
690 break;
691 case 0x60:
692 if (tuner_symbol_probe(tea5767_autodetection,
693 t->i2c->adapter, t->i2c->addr)
694 >= 0) {
695 t->type = TUNER_TEA5767;
696 t->mode_mask = T_RADIO;
697 /* Sets freq to FM range */
698 tuner_lookup(t->i2c->adapter, &radio, &tv);
699 if (tv)
700 tv->mode_mask &= ~T_RADIO;
701
702 goto register_client;
703 }
704 break;
705 }
706 }
707
708 /* Initializes only the first TV tuner on this adapter. Why only the
709 first? Because there are some devices (notably the ones with TI
710 tuners) that have more than one i2c address for the *same* device.
711 Experience shows that, except for just one case, the first
712 address is the right one. The exception is a Russian tuner
713 (ACORP_Y878F). So, the desired behavior is just to enable the
714 first found TV tuner. */
715 tuner_lookup(t->i2c->adapter, &radio, &tv);
716 if (tv == NULL) {
717 t->mode_mask = T_ANALOG_TV;
718 if (radio == NULL)
719 t->mode_mask |= T_RADIO;
720 dprintk("Setting mode_mask to 0x%02x\n", t->mode_mask);
721 }
722
723 /* Should be just before return */
724 register_client:
725 #if defined(CONFIG_MEDIA_CONTROLLER)
726 t->sd.entity.name = t->name;
727 /*
728 * Handle the special case where the tuner has actually
729 * two stages: the PLL to tune into a frequency and the
730 * IF-PLL demodulator (tda988x).
731 */
732 if (t->type == TUNER_TDA9887) {
733 t->pad[IF_VID_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
734 t->pad[IF_VID_DEC_PAD_IF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
735 t->pad[IF_VID_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE;
736 t->pad[IF_VID_DEC_PAD_OUT].sig_type = PAD_SIGNAL_ANALOG;
737 ret = media_entity_pads_init(&t->sd.entity,
738 IF_VID_DEC_PAD_NUM_PADS,
739 &t->pad[0]);
740 t->sd.entity.function = MEDIA_ENT_F_IF_VID_DECODER;
741 } else {
742 t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
743 t->pad[TUNER_PAD_RF_INPUT].sig_type = PAD_SIGNAL_ANALOG;
744 t->pad[TUNER_PAD_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
745 t->pad[TUNER_PAD_OUTPUT].sig_type = PAD_SIGNAL_ANALOG;
746 t->pad[TUNER_PAD_AUD_OUT].flags = MEDIA_PAD_FL_SOURCE;
747 t->pad[TUNER_PAD_AUD_OUT].sig_type = PAD_SIGNAL_AUDIO;
748 ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS,
749 &t->pad[0]);
750 t->sd.entity.function = MEDIA_ENT_F_TUNER;
751 }
752
753 if (ret < 0) {
754 pr_err("failed to initialize media entity!\n");
755 kfree(t);
756 return ret;
757 }
758 #endif
759 /* Sets a default mode */
760 if (t->mode_mask & T_ANALOG_TV)
761 t->mode = V4L2_TUNER_ANALOG_TV;
762 else
763 t->mode = V4L2_TUNER_RADIO;
764 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
765 list_add_tail(&t->list, &tuner_list);
766
767 pr_info("Tuner %d found with type(s)%s%s.\n",
768 t->type,
769 t->mode_mask & T_RADIO ? " Radio" : "",
770 t->mode_mask & T_ANALOG_TV ? " TV" : "");
771 return 0;
772 }
773
774 /**
775 * tuner_remove - detaches a tuner
776 *
777 * @client: i2c_client descriptor
778 */
779
tuner_remove(struct i2c_client * client)780 static void tuner_remove(struct i2c_client *client)
781 {
782 struct tuner *t = to_tuner(i2c_get_clientdata(client));
783
784 v4l2_device_unregister_subdev(&t->sd);
785 tuner_detach(&t->fe);
786 t->fe.analog_demod_priv = NULL;
787
788 list_del(&t->list);
789 kfree(t);
790 }
791
792 /*
793 * Functions to switch between Radio and TV
794 *
795 * A few cards have a separate I2C tuner for radio. Those routines
796 * take care of switching between TV/Radio mode, filtering only the
797 * commands that apply to the Radio or TV tuner.
798 */
799
800 /**
801 * check_mode - Verify if tuner supports the requested mode
802 * @t: a pointer to the module's internal struct_tuner
803 * @mode: mode of the tuner, as defined by &enum v4l2_tuner_type.
804 *
805 * This function checks if the tuner is capable of tuning analog TV,
806 * digital TV or radio, depending on what the caller wants. If the
807 * tuner can't support that mode, it returns -EINVAL. Otherwise, it
808 * returns 0.
809 * This function is needed for boards that have a separate tuner for
810 * radio (like devices with tea5767).
811 *
812 * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
813 * select a TV frequency. So, t_mode = T_ANALOG_TV could actually
814 * be used to represent a Digital TV too.
815 */
check_mode(struct tuner * t,enum v4l2_tuner_type mode)816 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
817 {
818 int t_mode;
819 if (mode == V4L2_TUNER_RADIO)
820 t_mode = T_RADIO;
821 else
822 t_mode = T_ANALOG_TV;
823
824 if ((t_mode & t->mode_mask) == 0)
825 return -EINVAL;
826
827 return 0;
828 }
829
830 /**
831 * set_mode - Switch tuner to other mode.
832 * @t: a pointer to the module's internal struct_tuner
833 * @mode: enum v4l2_type (radio or TV)
834 *
835 * If tuner doesn't support the needed mode (radio or TV), prints a
836 * debug message and returns -EINVAL, changing its state to standby.
837 * Otherwise, changes the mode and returns 0.
838 */
set_mode(struct tuner * t,enum v4l2_tuner_type mode)839 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
840 {
841 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
842
843 if (mode != t->mode) {
844 if (check_mode(t, mode) == -EINVAL) {
845 dprintk("Tuner doesn't support mode %d. Putting tuner to sleep\n",
846 mode);
847 t->standby = true;
848 if (analog_ops->standby)
849 analog_ops->standby(&t->fe);
850 return -EINVAL;
851 }
852 t->mode = mode;
853 dprintk("Changing to mode %d\n", mode);
854 }
855 return 0;
856 }
857
858 /**
859 * set_freq - Set the tuner to the desired frequency.
860 * @t: a pointer to the module's internal struct_tuner
861 * @freq: frequency to set (0 means to use the current frequency)
862 */
set_freq(struct tuner * t,unsigned int freq)863 static void set_freq(struct tuner *t, unsigned int freq)
864 {
865 struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
866
867 if (t->mode == V4L2_TUNER_RADIO) {
868 if (!freq)
869 freq = t->radio_freq;
870 set_radio_freq(client, freq);
871 } else {
872 if (!freq)
873 freq = t->tv_freq;
874 set_tv_freq(client, freq);
875 }
876 }
877
878 /*
879 * Functions that are specific for TV mode
880 */
881
882 /**
883 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz
884 *
885 * @c: i2c_client descriptor
886 * @freq: frequency
887 */
set_tv_freq(struct i2c_client * c,unsigned int freq)888 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
889 {
890 struct tuner *t = to_tuner(i2c_get_clientdata(c));
891 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
892
893 struct analog_parameters params = {
894 .mode = t->mode,
895 .audmode = t->audmode,
896 .std = t->std
897 };
898
899 if (t->type == UNSET) {
900 pr_warn("tuner type not set\n");
901 return;
902 }
903 if (NULL == analog_ops->set_params) {
904 pr_warn("Tuner has no way to set tv freq\n");
905 return;
906 }
907 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
908 dprintk("TV freq (%d.%02d) out of range (%d-%d)\n",
909 freq / 16, freq % 16 * 100 / 16, tv_range[0],
910 tv_range[1]);
911 /* V4L2 spec: if the freq is not possible then the closest
912 possible value should be selected */
913 if (freq < tv_range[0] * 16)
914 freq = tv_range[0] * 16;
915 else
916 freq = tv_range[1] * 16;
917 }
918 params.frequency = freq;
919 dprintk("tv freq set to %d.%02d\n",
920 freq / 16, freq % 16 * 100 / 16);
921 t->tv_freq = freq;
922 t->standby = false;
923
924 analog_ops->set_params(&t->fe, ¶ms);
925 }
926
927 /**
928 * tuner_fixup_std - force a given video standard variant
929 *
930 * @t: tuner internal struct
931 * @std: TV standard
932 *
933 * A few devices or drivers have problem to detect some standard variations.
934 * On other operational systems, the drivers generally have a per-country
935 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
936 * such hacks. Instead, it relies on a proper video standard selection from
937 * the userspace application. However, as some apps are buggy, not allowing
938 * to distinguish all video standard variations, a modprobe parameter can
939 * be used to force a video standard match.
940 */
tuner_fixup_std(struct tuner * t,v4l2_std_id std)941 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
942 {
943 if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
944 switch (pal[0]) {
945 case '6':
946 return V4L2_STD_PAL_60;
947 case 'b':
948 case 'B':
949 case 'g':
950 case 'G':
951 return V4L2_STD_PAL_BG;
952 case 'i':
953 case 'I':
954 return V4L2_STD_PAL_I;
955 case 'd':
956 case 'D':
957 case 'k':
958 case 'K':
959 return V4L2_STD_PAL_DK;
960 case 'M':
961 case 'm':
962 return V4L2_STD_PAL_M;
963 case 'N':
964 case 'n':
965 if (pal[1] == 'c' || pal[1] == 'C')
966 return V4L2_STD_PAL_Nc;
967 return V4L2_STD_PAL_N;
968 default:
969 pr_warn("pal= argument not recognised\n");
970 break;
971 }
972 }
973 if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
974 switch (secam[0]) {
975 case 'b':
976 case 'B':
977 case 'g':
978 case 'G':
979 case 'h':
980 case 'H':
981 return V4L2_STD_SECAM_B |
982 V4L2_STD_SECAM_G |
983 V4L2_STD_SECAM_H;
984 case 'd':
985 case 'D':
986 case 'k':
987 case 'K':
988 return V4L2_STD_SECAM_DK;
989 case 'l':
990 case 'L':
991 if ((secam[1] == 'C') || (secam[1] == 'c'))
992 return V4L2_STD_SECAM_LC;
993 return V4L2_STD_SECAM_L;
994 default:
995 pr_warn("secam= argument not recognised\n");
996 break;
997 }
998 }
999
1000 if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1001 switch (ntsc[0]) {
1002 case 'm':
1003 case 'M':
1004 return V4L2_STD_NTSC_M;
1005 case 'j':
1006 case 'J':
1007 return V4L2_STD_NTSC_M_JP;
1008 case 'k':
1009 case 'K':
1010 return V4L2_STD_NTSC_M_KR;
1011 default:
1012 pr_info("ntsc= argument not recognised\n");
1013 break;
1014 }
1015 }
1016 return std;
1017 }
1018
1019 /*
1020 * Functions that are specific for Radio mode
1021 */
1022
1023 /**
1024 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz
1025 *
1026 * @c: i2c_client descriptor
1027 * @freq: frequency
1028 */
set_radio_freq(struct i2c_client * c,unsigned int freq)1029 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
1030 {
1031 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1032 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1033
1034 struct analog_parameters params = {
1035 .mode = t->mode,
1036 .audmode = t->audmode,
1037 .std = t->std
1038 };
1039
1040 if (t->type == UNSET) {
1041 pr_warn("tuner type not set\n");
1042 return;
1043 }
1044 if (NULL == analog_ops->set_params) {
1045 pr_warn("tuner has no way to set radio frequency\n");
1046 return;
1047 }
1048 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1049 dprintk("radio freq (%d.%02d) out of range (%d-%d)\n",
1050 freq / 16000, freq % 16000 * 100 / 16000,
1051 radio_range[0], radio_range[1]);
1052 /* V4L2 spec: if the freq is not possible then the closest
1053 possible value should be selected */
1054 if (freq < radio_range[0] * 16000)
1055 freq = radio_range[0] * 16000;
1056 else
1057 freq = radio_range[1] * 16000;
1058 }
1059 params.frequency = freq;
1060 dprintk("radio freq set to %d.%02d\n",
1061 freq / 16000, freq % 16000 * 100 / 16000);
1062 t->radio_freq = freq;
1063 t->standby = false;
1064
1065 analog_ops->set_params(&t->fe, ¶ms);
1066 /*
1067 * The tuner driver might decide to change the audmode if it only
1068 * supports stereo, so update t->audmode.
1069 */
1070 t->audmode = params.audmode;
1071 }
1072
1073 /*
1074 * Debug function for reporting tuner status to userspace
1075 */
1076
1077 /**
1078 * tuner_status - Dumps the current tuner status at dmesg
1079 * @fe: pointer to struct dvb_frontend
1080 *
1081 * This callback is used only for driver debug purposes, answering to
1082 * VIDIOC_LOG_STATUS. No changes should happen on this call.
1083 */
tuner_status(struct dvb_frontend * fe)1084 static void tuner_status(struct dvb_frontend *fe)
1085 {
1086 struct tuner *t = fe->analog_demod_priv;
1087 unsigned long freq, freq_fraction;
1088 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1089 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1090 const char *p;
1091
1092 switch (t->mode) {
1093 case V4L2_TUNER_RADIO:
1094 p = "radio";
1095 break;
1096 case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1097 p = "digital TV";
1098 break;
1099 case V4L2_TUNER_ANALOG_TV:
1100 default:
1101 p = "analog TV";
1102 break;
1103 }
1104 if (t->mode == V4L2_TUNER_RADIO) {
1105 freq = t->radio_freq / 16000;
1106 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1107 } else {
1108 freq = t->tv_freq / 16;
1109 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1110 }
1111 pr_info("Tuner mode: %s%s\n", p,
1112 t->standby ? " on standby mode" : "");
1113 pr_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
1114 pr_info("Standard: 0x%08lx\n", (unsigned long)t->std);
1115 if (t->mode != V4L2_TUNER_RADIO)
1116 return;
1117 if (fe_tuner_ops->get_status) {
1118 u32 tuner_status = 0;
1119
1120 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1121 if (tuner_status & TUNER_STATUS_LOCKED)
1122 pr_info("Tuner is locked.\n");
1123 if (tuner_status & TUNER_STATUS_STEREO)
1124 pr_info("Stereo: yes\n");
1125 }
1126 if (analog_ops->has_signal) {
1127 u16 signal;
1128
1129 if (!analog_ops->has_signal(fe, &signal))
1130 pr_info("Signal strength: %hu\n", signal);
1131 }
1132 }
1133
1134 /*
1135 * Function to splicitly change mode to radio. Probably not needed anymore
1136 */
1137
tuner_s_radio(struct v4l2_subdev * sd)1138 static int tuner_s_radio(struct v4l2_subdev *sd)
1139 {
1140 struct tuner *t = to_tuner(sd);
1141
1142 if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1143 set_freq(t, 0);
1144 return 0;
1145 }
1146
1147 /*
1148 * Tuner callbacks to handle userspace ioctl's
1149 */
1150
1151 /**
1152 * tuner_standby - places the tuner in standby mode
1153 * @sd: pointer to struct v4l2_subdev
1154 */
tuner_standby(struct v4l2_subdev * sd)1155 static int tuner_standby(struct v4l2_subdev *sd)
1156 {
1157 struct tuner *t = to_tuner(sd);
1158 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1159
1160 dprintk("Putting tuner to sleep\n");
1161 t->standby = true;
1162 if (analog_ops->standby)
1163 analog_ops->standby(&t->fe);
1164 return 0;
1165 }
1166
tuner_s_std(struct v4l2_subdev * sd,v4l2_std_id std)1167 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1168 {
1169 struct tuner *t = to_tuner(sd);
1170
1171 if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1172 return 0;
1173
1174 t->std = tuner_fixup_std(t, std);
1175 if (t->std != std)
1176 dprintk("Fixup standard %llx to %llx\n", std, t->std);
1177 set_freq(t, 0);
1178 return 0;
1179 }
1180
tuner_s_frequency(struct v4l2_subdev * sd,const struct v4l2_frequency * f)1181 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1182 {
1183 struct tuner *t = to_tuner(sd);
1184
1185 if (set_mode(t, f->type) == 0)
1186 set_freq(t, f->frequency);
1187 return 0;
1188 }
1189
1190 /**
1191 * tuner_g_frequency - Get the tuned frequency for the tuner
1192 * @sd: pointer to struct v4l2_subdev
1193 * @f: pointer to struct v4l2_frequency
1194 *
1195 * At return, the structure f will be filled with tuner frequency
1196 * if the tuner matches the f->type.
1197 * Note: f->type should be initialized before calling it.
1198 * This is done by either video_ioctl2 or by the bridge driver.
1199 */
tuner_g_frequency(struct v4l2_subdev * sd,struct v4l2_frequency * f)1200 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1201 {
1202 struct tuner *t = to_tuner(sd);
1203 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1204
1205 if (check_mode(t, f->type) == -EINVAL)
1206 return 0;
1207 if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1208 u32 abs_freq;
1209
1210 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1211 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1212 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1213 DIV_ROUND_CLOSEST(abs_freq, 62500);
1214 } else {
1215 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1216 t->radio_freq : t->tv_freq;
1217 }
1218 return 0;
1219 }
1220
1221 /**
1222 * tuner_g_tuner - Fill in tuner information
1223 * @sd: pointer to struct v4l2_subdev
1224 * @vt: pointer to struct v4l2_tuner
1225 *
1226 * At return, the structure vt will be filled with tuner information
1227 * 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 */
tuner_g_tuner(struct v4l2_subdev * sd,struct v4l2_tuner * vt)1231 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1232 {
1233 struct tuner *t = to_tuner(sd);
1234 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1235 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1236
1237 if (check_mode(t, vt->type) == -EINVAL)
1238 return 0;
1239 if (vt->type == t->mode && analog_ops->get_afc)
1240 analog_ops->get_afc(&t->fe, &vt->afc);
1241 if (vt->type == t->mode && analog_ops->has_signal) {
1242 u16 signal = (u16)vt->signal;
1243
1244 if (!analog_ops->has_signal(&t->fe, &signal))
1245 vt->signal = signal;
1246 }
1247 if (vt->type != V4L2_TUNER_RADIO) {
1248 vt->capability |= V4L2_TUNER_CAP_NORM;
1249 vt->rangelow = tv_range[0] * 16;
1250 vt->rangehigh = tv_range[1] * 16;
1251 return 0;
1252 }
1253
1254 /* radio mode */
1255 if (vt->type == t->mode) {
1256 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1257 if (fe_tuner_ops->get_status) {
1258 u32 tuner_status = 0;
1259
1260 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1261 vt->rxsubchans =
1262 (tuner_status & TUNER_STATUS_STEREO) ?
1263 V4L2_TUNER_SUB_STEREO :
1264 V4L2_TUNER_SUB_MONO;
1265 }
1266 vt->audmode = t->audmode;
1267 }
1268 vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1269 vt->rangelow = radio_range[0] * 16000;
1270 vt->rangehigh = radio_range[1] * 16000;
1271
1272 return 0;
1273 }
1274
1275 /**
1276 * tuner_s_tuner - Set the tuner's audio mode
1277 * @sd: pointer to struct v4l2_subdev
1278 * @vt: pointer to struct v4l2_tuner
1279 *
1280 * Sets the audio mode if the tuner matches vt->type.
1281 * Note: vt->type should be initialized before calling it.
1282 * This is done by either video_ioctl2 or by the bridge driver.
1283 */
tuner_s_tuner(struct v4l2_subdev * sd,const struct v4l2_tuner * vt)1284 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1285 {
1286 struct tuner *t = to_tuner(sd);
1287
1288 if (set_mode(t, vt->type))
1289 return 0;
1290
1291 if (t->mode == V4L2_TUNER_RADIO) {
1292 t->audmode = vt->audmode;
1293 /*
1294 * For radio audmode can only be mono or stereo. Map any
1295 * other values to stereo. The actual tuner driver that is
1296 * called in set_radio_freq can decide to limit the audmode to
1297 * mono if only mono is supported.
1298 */
1299 if (t->audmode != V4L2_TUNER_MODE_MONO &&
1300 t->audmode != V4L2_TUNER_MODE_STEREO)
1301 t->audmode = V4L2_TUNER_MODE_STEREO;
1302 }
1303 set_freq(t, 0);
1304
1305 return 0;
1306 }
1307
tuner_log_status(struct v4l2_subdev * sd)1308 static int tuner_log_status(struct v4l2_subdev *sd)
1309 {
1310 struct tuner *t = to_tuner(sd);
1311 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1312
1313 if (analog_ops->tuner_status)
1314 analog_ops->tuner_status(&t->fe);
1315 return 0;
1316 }
1317
1318 #ifdef CONFIG_PM_SLEEP
tuner_suspend(struct device * dev)1319 static int tuner_suspend(struct device *dev)
1320 {
1321 struct i2c_client *c = to_i2c_client(dev);
1322 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1323 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1324
1325 dprintk("suspend\n");
1326
1327 if (t->fe.ops.tuner_ops.suspend)
1328 t->fe.ops.tuner_ops.suspend(&t->fe);
1329 else if (!t->standby && analog_ops->standby)
1330 analog_ops->standby(&t->fe);
1331
1332 return 0;
1333 }
1334
tuner_resume(struct device * dev)1335 static int tuner_resume(struct device *dev)
1336 {
1337 struct i2c_client *c = to_i2c_client(dev);
1338 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1339
1340 dprintk("resume\n");
1341
1342 if (t->fe.ops.tuner_ops.resume)
1343 t->fe.ops.tuner_ops.resume(&t->fe);
1344 else if (!t->standby)
1345 if (set_mode(t, t->mode) == 0)
1346 set_freq(t, 0);
1347
1348 return 0;
1349 }
1350 #endif
1351
tuner_command(struct i2c_client * client,unsigned cmd,void * arg)1352 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1353 {
1354 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1355
1356 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1357 to handle it here.
1358 There must be a better way of doing this... */
1359 switch (cmd) {
1360 case TUNER_SET_CONFIG:
1361 return tuner_s_config(sd, arg);
1362 }
1363 return -ENOIOCTLCMD;
1364 }
1365
1366 /*
1367 * Callback structs
1368 */
1369
1370 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1371 .log_status = tuner_log_status,
1372 };
1373
1374 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1375 .standby = tuner_standby,
1376 .s_radio = tuner_s_radio,
1377 .g_tuner = tuner_g_tuner,
1378 .s_tuner = tuner_s_tuner,
1379 .s_frequency = tuner_s_frequency,
1380 .g_frequency = tuner_g_frequency,
1381 .s_type_addr = tuner_s_type_addr,
1382 .s_config = tuner_s_config,
1383 };
1384
1385 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1386 .s_std = tuner_s_std,
1387 };
1388
1389 static const struct v4l2_subdev_ops tuner_ops = {
1390 .core = &tuner_core_ops,
1391 .tuner = &tuner_tuner_ops,
1392 .video = &tuner_video_ops,
1393 };
1394
1395 /*
1396 * I2C structs and module init functions
1397 */
1398
1399 static const struct dev_pm_ops tuner_pm_ops = {
1400 SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1401 };
1402
1403 static const struct i2c_device_id tuner_id[] = {
1404 { "tuner", }, /* autodetect */
1405 { }
1406 };
1407 MODULE_DEVICE_TABLE(i2c, tuner_id);
1408
1409 static struct i2c_driver tuner_driver = {
1410 .driver = {
1411 .name = "tuner",
1412 .pm = &tuner_pm_ops,
1413 },
1414 .probe = tuner_probe,
1415 .remove = tuner_remove,
1416 .command = tuner_command,
1417 .id_table = tuner_id,
1418 };
1419
1420 module_i2c_driver(tuner_driver);
1421
1422 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1423 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1424 MODULE_LICENSE("GPL");
1425