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 * @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 */
tuner_probe(struct i2c_client * client,const struct i2c_device_id * id)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
tuner_remove(struct i2c_client * client)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 */
check_mode(struct tuner * t,enum v4l2_tuner_type mode)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 */
set_mode(struct tuner * t,enum v4l2_tuner_type mode)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 */
set_freq(struct tuner * t,unsigned int freq)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 */
set_tv_freq(struct i2c_client * c,unsigned int freq)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, ¶ms);
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 */
tuner_fixup_std(struct tuner * t,v4l2_std_id std)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 */
set_radio_freq(struct i2c_client * c,unsigned int freq)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, ¶ms);
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 */
tuner_status(struct dvb_frontend * fe)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 = 0;
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
tuner_s_radio(struct v4l2_subdev * sd)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 */
tuner_standby(struct v4l2_subdev * sd)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
tuner_s_std(struct v4l2_subdev * sd,v4l2_std_id std)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
tuner_s_frequency(struct v4l2_subdev * sd,const struct v4l2_frequency * f)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 */
tuner_g_frequency(struct v4l2_subdev * sd,struct v4l2_frequency * f)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 */
tuner_g_tuner(struct v4l2_subdev * sd,struct v4l2_tuner * vt)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 = 0;
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 */
tuner_s_tuner(struct v4l2_subdev * sd,const struct v4l2_tuner * vt)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
tuner_log_status(struct v4l2_subdev * sd)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
tuner_suspend(struct device * dev)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
tuner_resume(struct device * dev)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
tuner_command(struct i2c_client * client,unsigned cmd,void * arg)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