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