2 * i2c tv tuner chip device driver
3 * core core, i.e. kernel interfaces, registering and so on
5 * Copyright(c) by Ralph Metzler, Gerd Knorr, Gunther Mayer
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
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.
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>
37 #include "tuner-xc2028.h"
38 #include "tuner-simple.h"
45 #define PREFIX (t->i2c->driver->driver.name)
48 * Driver modprobe parameters
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;
56 module_param(addr, int, 0444);
57 module_param(no_autodetect, int, 0444);
58 module_param(show_i2c, int, 0444);
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[] = "-";
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);
79 static LIST_HEAD(tuner_list);
80 static const struct v4l2_subdev_ops tuner_ops;
86 #define tuner_warn(fmt, arg...) do { \
87 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
88 i2c_adapter_id(t->i2c->adapter), \
89 t->i2c->addr, ##arg); \
92 #define tuner_info(fmt, arg...) do { \
93 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
94 i2c_adapter_id(t->i2c->adapter), \
95 t->i2c->addr, ##arg); \
98 #define tuner_err(fmt, arg...) do { \
99 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
100 i2c_adapter_id(t->i2c->adapter), \
101 t->i2c->addr, ##arg); \
104 #define tuner_dbg(fmt, arg...) do { \
106 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
107 i2c_adapter_id(t->i2c->adapter), \
108 t->i2c->addr, ##arg); \
112 * Internal struct used inside the driver
117 struct dvb_frontend fe;
118 struct i2c_client *i2c;
119 struct v4l2_subdev sd;
120 struct list_head list;
122 /* keep track of the current settings */
124 unsigned int tv_freq;
125 unsigned int radio_freq;
126 unsigned int audmode;
128 enum v4l2_tuner_type mode;
129 unsigned int mode_mask; /* Combination of allowable modes */
131 bool standby; /* Standby mode */
133 unsigned int type; /* chip type id */
139 * Function prototypes
142 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
143 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
146 * tuner attach/detach logic
149 /* This macro allows us to probe dynamically, avoiding static links */
150 #ifdef CONFIG_MEDIA_ATTACH
151 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
153 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
155 __r = (int) __a(ARGS); \
156 symbol_put(FUNCTION); \
158 printk(KERN_ERR "TUNER: Unable to find " \
159 "symbol "#FUNCTION"()\n"); \
164 static void tuner_detach(struct dvb_frontend *fe)
166 if (fe->ops.tuner_ops.release) {
167 fe->ops.tuner_ops.release(fe);
168 symbol_put_addr(fe->ops.tuner_ops.release);
170 if (fe->ops.analog_ops.release) {
171 fe->ops.analog_ops.release(fe);
172 symbol_put_addr(fe->ops.analog_ops.release);
176 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
180 static void tuner_detach(struct dvb_frontend *fe)
182 if (fe->ops.tuner_ops.release)
183 fe->ops.tuner_ops.release(fe);
184 if (fe->ops.analog_ops.release)
185 fe->ops.analog_ops.release(fe);
190 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
192 return container_of(sd, struct tuner, sd);
196 * struct analog_demod_ops callbacks
199 static void fe_set_params(struct dvb_frontend *fe,
200 struct analog_parameters *params)
202 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
203 struct tuner *t = fe->analog_demod_priv;
205 if (NULL == fe_tuner_ops->set_analog_params) {
206 tuner_warn("Tuner frontend module has no way to set freq\n");
209 fe_tuner_ops->set_analog_params(fe, params);
212 static void fe_standby(struct dvb_frontend *fe)
214 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
216 if (fe_tuner_ops->sleep)
217 fe_tuner_ops->sleep(fe);
220 static int fe_has_signal(struct dvb_frontend *fe)
224 if (fe->ops.tuner_ops.get_rf_strength)
225 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
230 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
232 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
233 struct tuner *t = fe->analog_demod_priv;
235 if (fe_tuner_ops->set_config)
236 return fe_tuner_ops->set_config(fe, priv_cfg);
238 tuner_warn("Tuner frontend module has no way to set config\n");
243 static void tuner_status(struct dvb_frontend *fe);
245 static struct analog_demod_ops tuner_analog_ops = {
246 .set_params = fe_set_params,
247 .standby = fe_standby,
248 .has_signal = fe_has_signal,
249 .set_config = fe_set_config,
250 .tuner_status = tuner_status
254 * Functions to select between radio and TV and tuner probe functions
258 * set_type - Sets the tuner type for a given device
260 * @c: i2c_client descriptoy
261 * @type: type of the tuner (e. g. tuner number)
262 * @new_mode_mask: Indicates if tuner supports TV and/or Radio
263 * @new_config: an optional parameter ranging from 0-255 used by
264 a few tuners to adjust an internal parameter,
266 * @tuner_callback: an optional function to be called when switching
269 * This function applys the tuner config to tuner specified
270 * by tun_setup structure. It contains several per-tuner initialization "magic"
272 static void set_type(struct i2c_client *c, unsigned int type,
273 unsigned int new_mode_mask, unsigned int new_config,
274 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
276 struct tuner *t = to_tuner(i2c_get_clientdata(c));
277 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
278 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
279 unsigned char buffer[4];
282 if (type == UNSET || type == TUNER_ABSENT) {
283 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr);
288 /* prevent invalid config values */
289 t->config = new_config < 256 ? new_config : 0;
290 if (tuner_callback != NULL) {
291 tuner_dbg("defining GPIO callback\n");
292 t->fe.callback = tuner_callback;
295 /* discard private data, in case set_type() was previously called */
296 tuner_detach(&t->fe);
297 t->fe.analog_demod_priv = NULL;
301 if (!dvb_attach(microtune_attach,
302 &t->fe, t->i2c->adapter, t->i2c->addr))
305 case TUNER_PHILIPS_TDA8290:
307 struct tda829x_config cfg = {
308 .lna_cfg = t->config,
310 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
316 if (!dvb_attach(tea5767_attach, &t->fe,
317 t->i2c->adapter, t->i2c->addr))
319 t->mode_mask = T_RADIO;
322 if (!dvb_attach(tea5761_attach, &t->fe,
323 t->i2c->adapter, t->i2c->addr))
325 t->mode_mask = T_RADIO;
327 case TUNER_PHILIPS_FMD1216ME_MK3:
332 i2c_master_send(c, buffer, 4);
336 i2c_master_send(c, buffer, 4);
337 if (!dvb_attach(simple_tuner_attach, &t->fe,
338 t->i2c->adapter, t->i2c->addr, t->type))
341 case TUNER_PHILIPS_TD1316:
346 i2c_master_send(c, buffer, 4);
347 if (!dvb_attach(simple_tuner_attach, &t->fe,
348 t->i2c->adapter, t->i2c->addr, t->type))
353 struct xc2028_config cfg = {
354 .i2c_adap = t->i2c->adapter,
355 .i2c_addr = t->i2c->addr,
357 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
363 if (!dvb_attach(tda9887_attach,
364 &t->fe, t->i2c->adapter, t->i2c->addr))
369 struct xc5000_config xc5000_cfg = {
370 .i2c_address = t->i2c->addr,
371 /* if_khz will be set at dvb_attach() */
375 if (!dvb_attach(xc5000_attach,
376 &t->fe, t->i2c->adapter, &xc5000_cfg))
381 case TUNER_NXP_TDA18271:
383 struct tda18271_config cfg = {
385 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
388 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
389 t->i2c->adapter, &cfg))
395 if (!dvb_attach(simple_tuner_attach, &t->fe,
396 t->i2c->adapter, t->i2c->addr, t->type))
402 if ((NULL == analog_ops->set_params) &&
403 (fe_tuner_ops->set_analog_params)) {
405 t->name = fe_tuner_ops->info.name;
407 t->fe.analog_demod_priv = t;
408 memcpy(analog_ops, &tuner_analog_ops,
409 sizeof(struct analog_demod_ops));
412 t->name = analog_ops->info.name;
415 tuner_dbg("type set to %s\n", t->name);
417 t->mode_mask = new_mode_mask;
419 /* Some tuners require more initialization setup before use,
420 such as firmware download or device calibration.
421 trying to set a frequency here will just fail
422 FIXME: better to move set_freq to the tuner code. This is needed
423 on analog tuners for PLL to properly work
426 if (V4L2_TUNER_RADIO == t->mode)
427 set_radio_freq(c, t->radio_freq);
429 set_tv_freq(c, t->tv_freq);
432 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
433 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
438 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
439 t->type = TUNER_ABSENT;
445 * tuner_s_type_addr - Sets the tuner type for a device
447 * @sd: subdev descriptor
448 * @tun_setup: type to be associated to a given tuner i2c address
450 * This function applys the tuner config to tuner specified
451 * by tun_setup structure.
452 * If tuner I2C address is UNSET, then it will only set the device
453 * if the tuner supports the mode specified in the call.
454 * If the address is specified, the change will be applied only if
455 * tuner I2C address matches.
456 * The call can change the tuner number and the tuner mode.
458 static int tuner_s_type_addr(struct v4l2_subdev *sd,
459 struct tuner_setup *tun_setup)
461 struct tuner *t = to_tuner(sd);
462 struct i2c_client *c = v4l2_get_subdevdata(sd);
464 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
467 tun_setup->mode_mask,
470 if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
471 (t->mode_mask & tun_setup->mode_mask))) ||
472 (tun_setup->addr == c->addr)) {
473 set_type(c, tun_setup->type, tun_setup->mode_mask,
474 tun_setup->config, tun_setup->tuner_callback);
476 tuner_dbg("set addr discarded for type %i, mask %x. "
477 "Asked to change tuner at addr 0x%02x, with mask %x\n",
478 t->type, t->mode_mask,
479 tun_setup->addr, tun_setup->mode_mask);
485 * tuner_s_config - Sets tuner configuration
487 * @sd: subdev descriptor
488 * @cfg: tuner configuration
490 * Calls tuner set_config() private function to set some tuner-internal
493 static int tuner_s_config(struct v4l2_subdev *sd,
494 const struct v4l2_priv_tun_config *cfg)
496 struct tuner *t = to_tuner(sd);
497 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
499 if (t->type != cfg->tuner)
502 if (analog_ops->set_config) {
503 analog_ops->set_config(&t->fe, cfg->priv);
507 tuner_dbg("Tuner frontend module has no way to set config\n");
512 * tuner_lookup - Seek for tuner adapters
514 * @adap: i2c_adapter struct
515 * @radio: pointer to be filled if the adapter is radio
516 * @tv: pointer to be filled if the adapter is TV
518 * Search for existing radio and/or TV tuners on the given I2C adapter,
519 * discarding demod-only adapters (tda9887).
521 * Note that when this function is called from tuner_probe you can be
522 * certain no other devices will be added/deleted at the same time, I2C
523 * core protects against that.
525 static void tuner_lookup(struct i2c_adapter *adap,
526 struct tuner **radio, struct tuner **tv)
533 list_for_each_entry(pos, &tuner_list, list) {
536 if (pos->i2c->adapter != adap ||
537 strcmp(pos->i2c->driver->driver.name, "tuner"))
540 mode_mask = pos->mode_mask;
542 if (*radio == NULL && mode_mask == T_RADIO)
544 /* Note: currently TDA9887 is the only demod-only
545 device. If other devices appear then we need to
546 make this test more general. */
547 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
548 (pos->mode_mask & T_ANALOG_TV))
554 *tuner_probe - Probes the existing tuners on an I2C bus
556 * @client: i2c_client descriptor
559 * This routine probes for tuners at the expected I2C addresses. On most
560 * cases, if a device answers to a given I2C address, it assumes that the
561 * device is a tuner. On a few cases, however, an additional logic is needed
562 * to double check if the device is really a tuner, or to identify the tuner
563 * type, like on tea5767/5761 devices.
565 * During client attach, set_type is called by adapter's attach_inform callback.
566 * set_type must then be completed by tuner_probe.
568 static int tuner_probe(struct i2c_client *client,
569 const struct i2c_device_id *id)
575 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
578 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
580 t->name = "(tuner unset)";
582 t->audmode = V4L2_TUNER_MODE_STEREO;
584 t->radio_freq = 87.5 * 16000; /* Initial freq range */
585 t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
588 unsigned char buffer[16];
591 memset(buffer, 0, sizeof(buffer));
592 rc = i2c_master_recv(client, buffer, sizeof(buffer));
593 tuner_info("I2C RECV = ");
594 for (i = 0; i < rc; i++)
595 printk(KERN_CONT "%02x ", buffer[i]);
599 /* autodetection code based on the i2c addr */
600 if (!no_autodetect) {
601 switch (client->addr) {
603 if (tuner_symbol_probe(tea5761_autodetection,
605 t->i2c->addr) >= 0) {
606 t->type = TUNER_TEA5761;
607 t->mode_mask = T_RADIO;
608 tuner_lookup(t->i2c->adapter, &radio, &tv);
610 tv->mode_mask &= ~T_RADIO;
612 goto register_client;
620 /* If chip is not tda8290, don't register.
621 since it can be tda9887*/
622 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
623 t->i2c->addr) >= 0) {
624 tuner_dbg("tda829x detected\n");
626 /* Default is being tda9887 */
627 t->type = TUNER_TDA9887;
628 t->mode_mask = T_RADIO | T_ANALOG_TV;
629 goto register_client;
633 if (tuner_symbol_probe(tea5767_autodetection,
634 t->i2c->adapter, t->i2c->addr)
636 t->type = TUNER_TEA5767;
637 t->mode_mask = T_RADIO;
638 /* Sets freq to FM range */
639 tuner_lookup(t->i2c->adapter, &radio, &tv);
641 tv->mode_mask &= ~T_RADIO;
643 goto register_client;
649 /* Initializes only the first TV tuner on this adapter. Why only the
650 first? Because there are some devices (notably the ones with TI
651 tuners) that have more than one i2c address for the *same* device.
652 Experience shows that, except for just one case, the first
653 address is the right one. The exception is a Russian tuner
654 (ACORP_Y878F). So, the desired behavior is just to enable the
655 first found TV tuner. */
656 tuner_lookup(t->i2c->adapter, &radio, &tv);
658 t->mode_mask = T_ANALOG_TV;
660 t->mode_mask |= T_RADIO;
661 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
664 /* Should be just before return */
666 /* Sets a default mode */
667 if (t->mode_mask & T_ANALOG_TV)
668 t->mode = V4L2_TUNER_ANALOG_TV;
670 t->mode = V4L2_TUNER_RADIO;
671 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
672 list_add_tail(&t->list, &tuner_list);
674 tuner_info("Tuner %d found with type(s)%s%s.\n",
676 t->mode_mask & T_RADIO ? " Radio" : "",
677 t->mode_mask & T_ANALOG_TV ? " TV" : "");
682 * tuner_remove - detaches a tuner
684 * @client: i2c_client descriptor
687 static int tuner_remove(struct i2c_client *client)
689 struct tuner *t = to_tuner(i2c_get_clientdata(client));
691 v4l2_device_unregister_subdev(&t->sd);
692 tuner_detach(&t->fe);
693 t->fe.analog_demod_priv = NULL;
701 * Functions that are specific for TV mode
705 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz
707 * @c: i2c_client descriptor
710 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
712 struct tuner *t = to_tuner(i2c_get_clientdata(c));
713 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
715 struct analog_parameters params = {
717 .audmode = t->audmode,
721 if (t->type == UNSET) {
722 tuner_warn("tuner type not set\n");
725 if (NULL == analog_ops->set_params) {
726 tuner_warn("Tuner has no way to set tv freq\n");
729 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
730 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
731 freq / 16, freq % 16 * 100 / 16, tv_range[0],
733 /* V4L2 spec: if the freq is not possible then the closest
734 possible value should be selected */
735 if (freq < tv_range[0] * 16)
736 freq = tv_range[0] * 16;
738 freq = tv_range[1] * 16;
740 params.frequency = freq;
741 tuner_dbg("tv freq set to %d.%02d\n",
742 freq / 16, freq % 16 * 100 / 16);
746 analog_ops->set_params(&t->fe, ¶ms);
750 * tuner_fixup_std - force a given video standard variant
752 * @t: tuner internal struct
754 * A few devices or drivers have problem to detect some standard variations.
755 * On other operational systems, the drivers generally have a per-country
756 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
757 * such hacks. Instead, it relies on a proper video standard selection from
758 * the userspace application. However, as some apps are buggy, not allowing
759 * to distinguish all video standard variations, a modprobe parameter can
760 * be used to force a video standard match.
762 static int tuner_fixup_std(struct tuner *t)
764 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
767 tuner_dbg("insmod fixup: PAL => PAL-60\n");
768 t->std = V4L2_STD_PAL_60;
774 tuner_dbg("insmod fixup: PAL => PAL-BG\n");
775 t->std = V4L2_STD_PAL_BG;
779 tuner_dbg("insmod fixup: PAL => PAL-I\n");
780 t->std = V4L2_STD_PAL_I;
786 tuner_dbg("insmod fixup: PAL => PAL-DK\n");
787 t->std = V4L2_STD_PAL_DK;
791 tuner_dbg("insmod fixup: PAL => PAL-M\n");
792 t->std = V4L2_STD_PAL_M;
796 if (pal[1] == 'c' || pal[1] == 'C') {
797 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
798 t->std = V4L2_STD_PAL_Nc;
800 tuner_dbg("insmod fixup: PAL => PAL-N\n");
801 t->std = V4L2_STD_PAL_N;
805 /* default parameter, do nothing */
808 tuner_warn("pal= argument not recognised\n");
812 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
820 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
821 t->std = V4L2_STD_SECAM_B |
829 tuner_dbg("insmod fixup: SECAM => SECAM-DK\n");
830 t->std = V4L2_STD_SECAM_DK;
834 if ((secam[1] == 'C') || (secam[1] == 'c')) {
835 tuner_dbg("insmod fixup: SECAM => SECAM-L'\n");
836 t->std = V4L2_STD_SECAM_LC;
838 tuner_dbg("insmod fixup: SECAM => SECAM-L\n");
839 t->std = V4L2_STD_SECAM_L;
843 /* default parameter, do nothing */
846 tuner_warn("secam= argument not recognised\n");
851 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
855 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
856 t->std = V4L2_STD_NTSC_M;
860 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
861 t->std = V4L2_STD_NTSC_M_JP;
865 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
866 t->std = V4L2_STD_NTSC_M_KR;
869 /* default parameter, do nothing */
872 tuner_info("ntsc= argument not recognised\n");
880 * Functions that are specific for Radio mode
884 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz
886 * @c: i2c_client descriptor
889 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
891 struct tuner *t = to_tuner(i2c_get_clientdata(c));
892 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
894 struct analog_parameters params = {
896 .audmode = t->audmode,
900 if (t->type == UNSET) {
901 tuner_warn("tuner type not set\n");
904 if (NULL == analog_ops->set_params) {
905 tuner_warn("tuner has no way to set radio frequency\n");
908 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
909 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
910 freq / 16000, freq % 16000 * 100 / 16000,
911 radio_range[0], radio_range[1]);
912 /* V4L2 spec: if the freq is not possible then the closest
913 possible value should be selected */
914 if (freq < radio_range[0] * 16000)
915 freq = radio_range[0] * 16000;
917 freq = radio_range[1] * 16000;
919 params.frequency = freq;
920 tuner_dbg("radio freq set to %d.%02d\n",
921 freq / 16000, freq % 16000 * 100 / 16000);
922 t->radio_freq = freq;
925 analog_ops->set_params(&t->fe, ¶ms);
929 * check_mode - Verify if tuner supports the requested mode
930 * @t: a pointer to the module's internal struct_tuner
932 * This function checks if the tuner is capable of tuning analog TV,
933 * digital TV or radio, depending on what the caller wants. If the
934 * tuner can't support that mode, it returns -EINVAL. Otherwise, it
936 * This function is needed for boards that have a separate tuner for
937 * radio (like devices with tea5767).
939 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
941 if ((1 << mode & t->mode_mask) == 0)
948 * set_mode_freq - Switch tuner to other mode.
949 * @client: struct i2c_client pointer
950 * @t: a pointer to the module's internal struct_tuner
951 * @mode: enum v4l2_type (radio or TV)
952 * @freq: frequency to set (0 means to use the previous one)
954 * If tuner doesn't support the needed mode (radio or TV), prints a
955 * debug message and returns -EINVAL, changing internal state to T_STANDBY.
956 * Otherwise, changes the state and sets frequency to the last value, if
957 * the tuner can sleep or if it supports both Radio and TV.
959 static int set_mode_freq(struct i2c_client *client, struct tuner *t,
960 enum v4l2_tuner_type mode, unsigned int freq)
962 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
964 if (mode != t->mode) {
965 if (check_mode(t, mode) == -EINVAL) {
966 tuner_dbg("Tuner doesn't support mode %d. "
967 "Putting tuner to sleep\n", mode);
969 if (analog_ops->standby)
970 analog_ops->standby(&t->fe);
974 tuner_dbg("Changing to mode %d\n", mode);
976 if (t->mode == V4L2_TUNER_RADIO) {
978 t->radio_freq = freq;
979 set_radio_freq(client, t->radio_freq);
983 set_tv_freq(client, t->tv_freq);
990 * tuner_status - Dumps the current tuner status at dmesg
991 * @fe: pointer to struct dvb_frontend
993 * This callback is used only for driver debug purposes, answering to
994 * VIDIOC_LOG_STATUS. No changes should happen on this call.
996 static void tuner_status(struct dvb_frontend *fe)
998 struct tuner *t = fe->analog_demod_priv;
999 unsigned long freq, freq_fraction;
1000 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1001 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1005 case V4L2_TUNER_RADIO:
1008 case V4L2_TUNER_DIGITAL_TV:
1011 case V4L2_TUNER_ANALOG_TV:
1016 if (t->mode == V4L2_TUNER_RADIO) {
1017 freq = t->radio_freq / 16000;
1018 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1020 freq = t->tv_freq / 16;
1021 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1023 tuner_info("Tuner mode: %s%s\n", p,
1024 t->standby ? " on standby mode" : "");
1025 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
1026 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
1027 if (t->mode != V4L2_TUNER_RADIO)
1029 if (fe_tuner_ops->get_status) {
1032 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1033 if (tuner_status & TUNER_STATUS_LOCKED)
1034 tuner_info("Tuner is locked.\n");
1035 if (tuner_status & TUNER_STATUS_STEREO)
1036 tuner_info("Stereo: yes\n");
1038 if (analog_ops->has_signal)
1039 tuner_info("Signal strength: %d\n",
1040 analog_ops->has_signal(fe));
1044 * tuner_s_power - controls the power state of the tuner
1045 * @sd: pointer to struct v4l2_subdev
1046 * @on: a zero value puts the tuner to sleep
1048 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1050 struct tuner *t = to_tuner(sd);
1051 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1053 /* FIXME: Why this function don't wake the tuner if on != 0 ? */
1057 tuner_dbg("Putting tuner to sleep\n");
1059 if (analog_ops->standby)
1060 analog_ops->standby(&t->fe);
1065 * Function to splicitly change mode to radio. Probably not needed anymore
1068 static int tuner_s_radio(struct v4l2_subdev *sd)
1070 struct tuner *t = to_tuner(sd);
1071 struct i2c_client *client = v4l2_get_subdevdata(sd);
1073 if (set_mode_freq(client, t, V4L2_TUNER_RADIO, 0) == -EINVAL)
1079 * Tuner callbacks to handle userspace ioctl's
1082 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1084 struct tuner *t = to_tuner(sd);
1085 struct i2c_client *client = v4l2_get_subdevdata(sd);
1087 if (set_mode_freq(client, t, V4L2_TUNER_ANALOG_TV, 0) == -EINVAL)
1096 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1098 struct tuner *t = to_tuner(sd);
1099 struct i2c_client *client = v4l2_get_subdevdata(sd);
1101 if (set_mode_freq(client, t, f->type, f->frequency) == -EINVAL)
1107 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1109 struct tuner *t = to_tuner(sd);
1110 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1112 if (check_mode(t, f->type) == -EINVAL)
1115 if (fe_tuner_ops->get_frequency && !t->standby) {
1118 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1119 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1120 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1121 DIV_ROUND_CLOSEST(abs_freq, 62500);
1123 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1124 t->radio_freq : t->tv_freq;
1129 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1131 struct tuner *t = to_tuner(sd);
1132 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1133 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1135 if (check_mode(t, vt->type) == -EINVAL)
1138 if (analog_ops->get_afc)
1139 vt->afc = analog_ops->get_afc(&t->fe);
1140 if (t->mode == V4L2_TUNER_ANALOG_TV)
1141 vt->capability |= V4L2_TUNER_CAP_NORM;
1142 if (t->mode != V4L2_TUNER_RADIO) {
1143 vt->rangelow = tv_range[0] * 16;
1144 vt->rangehigh = tv_range[1] * 16;
1149 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1150 if (fe_tuner_ops->get_status) {
1153 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1155 (tuner_status & TUNER_STATUS_STEREO) ?
1156 V4L2_TUNER_SUB_STEREO :
1157 V4L2_TUNER_SUB_MONO;
1159 if (analog_ops->has_signal)
1160 vt->signal = analog_ops->has_signal(&t->fe);
1161 vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1162 vt->audmode = t->audmode;
1163 vt->rangelow = radio_range[0] * 16000;
1164 vt->rangehigh = radio_range[1] * 16000;
1169 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1171 struct tuner *t = to_tuner(sd);
1172 struct i2c_client *client = v4l2_get_subdevdata(sd);
1174 if (set_mode_freq(client, t, vt->type, 0) == -EINVAL)
1177 if (t->mode == V4L2_TUNER_RADIO)
1178 t->audmode = vt->audmode;
1183 static int tuner_log_status(struct v4l2_subdev *sd)
1185 struct tuner *t = to_tuner(sd);
1186 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1188 if (analog_ops->tuner_status)
1189 analog_ops->tuner_status(&t->fe);
1193 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1195 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1196 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1198 tuner_dbg("suspend\n");
1200 if (!t->standby && analog_ops->standby)
1201 analog_ops->standby(&t->fe);
1206 static int tuner_resume(struct i2c_client *c)
1208 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1210 tuner_dbg("resume\n");
1213 set_mode_freq(c, t, t->type, 0);
1218 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1220 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1222 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1224 There must be a better way of doing this... */
1226 case TUNER_SET_CONFIG:
1227 return tuner_s_config(sd, arg);
1229 return -ENOIOCTLCMD;
1236 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1237 .log_status = tuner_log_status,
1238 .s_std = tuner_s_std,
1239 .s_power = tuner_s_power,
1242 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1243 .s_radio = tuner_s_radio,
1244 .g_tuner = tuner_g_tuner,
1245 .s_tuner = tuner_s_tuner,
1246 .s_frequency = tuner_s_frequency,
1247 .g_frequency = tuner_g_frequency,
1248 .s_type_addr = tuner_s_type_addr,
1249 .s_config = tuner_s_config,
1252 static const struct v4l2_subdev_ops tuner_ops = {
1253 .core = &tuner_core_ops,
1254 .tuner = &tuner_tuner_ops,
1258 * I2C structs and module init functions
1261 static const struct i2c_device_id tuner_id[] = {
1262 { "tuner", }, /* autodetect */
1265 MODULE_DEVICE_TABLE(i2c, tuner_id);
1267 static struct i2c_driver tuner_driver = {
1269 .owner = THIS_MODULE,
1272 .probe = tuner_probe,
1273 .remove = tuner_remove,
1274 .command = tuner_command,
1275 .suspend = tuner_suspend,
1276 .resume = tuner_resume,
1277 .id_table = tuner_id,
1280 static __init int init_tuner(void)
1282 return i2c_add_driver(&tuner_driver);
1285 static __exit void exit_tuner(void)
1287 i2c_del_driver(&tuner_driver);
1290 module_init(init_tuner);
1291 module_exit(exit_tuner);
1293 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1294 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1295 MODULE_LICENSE("GPL");