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