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"
46 #define PREFIX (t->i2c->dev.driver->name)
49 * Driver modprobe parameters
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;
57 module_param(addr, int, 0444);
58 module_param(no_autodetect, int, 0444);
59 module_param(show_i2c, int, 0444);
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[] = "-";
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);
80 static LIST_HEAD(tuner_list);
81 static const struct v4l2_subdev_ops tuner_ops;
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); \
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); \
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); \
105 #define tuner_dbg(fmt, arg...) do { \
107 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
108 i2c_adapter_id(t->i2c->adapter), \
109 t->i2c->addr, ##arg); \
113 * Internal struct used inside the driver
118 struct dvb_frontend fe;
119 struct i2c_client *i2c;
120 struct v4l2_subdev sd;
121 struct list_head list;
123 /* keep track of the current settings */
125 unsigned int tv_freq;
126 unsigned int radio_freq;
127 unsigned int audmode;
129 enum v4l2_tuner_type mode;
130 unsigned int mode_mask; /* Combination of allowable modes */
132 bool standby; /* Standby mode */
134 unsigned int type; /* chip type id */
138 #if defined(CONFIG_MEDIA_CONTROLLER)
139 struct media_pad pad[TUNER_NUM_PADS];
144 * Function prototypes
147 static void set_tv_freq(struct i2c_client *c, unsigned int freq);
148 static void set_radio_freq(struct i2c_client *c, unsigned int freq);
151 * tuner attach/detach logic
154 /* This macro allows us to probe dynamically, avoiding static links */
155 #ifdef CONFIG_MEDIA_ATTACH
156 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
158 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
160 __r = (int) __a(ARGS); \
161 symbol_put(FUNCTION); \
163 printk(KERN_ERR "TUNER: Unable to find " \
164 "symbol "#FUNCTION"()\n"); \
169 static void tuner_detach(struct dvb_frontend *fe)
171 if (fe->ops.tuner_ops.release) {
172 fe->ops.tuner_ops.release(fe);
173 symbol_put_addr(fe->ops.tuner_ops.release);
175 if (fe->ops.analog_ops.release) {
176 fe->ops.analog_ops.release(fe);
177 symbol_put_addr(fe->ops.analog_ops.release);
181 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
185 static void tuner_detach(struct dvb_frontend *fe)
187 if (fe->ops.tuner_ops.release)
188 fe->ops.tuner_ops.release(fe);
189 if (fe->ops.analog_ops.release)
190 fe->ops.analog_ops.release(fe);
195 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
197 return container_of(sd, struct tuner, sd);
201 * struct analog_demod_ops callbacks
204 static void fe_set_params(struct dvb_frontend *fe,
205 struct analog_parameters *params)
207 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
208 struct tuner *t = fe->analog_demod_priv;
210 if (NULL == fe_tuner_ops->set_analog_params) {
211 tuner_warn("Tuner frontend module has no way to set freq\n");
214 fe_tuner_ops->set_analog_params(fe, params);
217 static void fe_standby(struct dvb_frontend *fe)
219 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
221 if (fe_tuner_ops->sleep)
222 fe_tuner_ops->sleep(fe);
225 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
227 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
228 struct tuner *t = fe->analog_demod_priv;
230 if (fe_tuner_ops->set_config)
231 return fe_tuner_ops->set_config(fe, priv_cfg);
233 tuner_warn("Tuner frontend module has no way to set config\n");
238 static void tuner_status(struct dvb_frontend *fe);
240 static const struct analog_demod_ops tuner_analog_ops = {
241 .set_params = fe_set_params,
242 .standby = fe_standby,
243 .set_config = fe_set_config,
244 .tuner_status = tuner_status
248 * Functions to select between radio and TV and tuner probe/remove functions
252 * set_type - Sets the tuner type for a given device
254 * @c: i2c_client descriptor
255 * @type: type of the tuner (e. g. tuner number)
256 * @new_mode_mask: Indicates if tuner supports TV and/or Radio
257 * @new_config: an optional parameter used by a few tuners to adjust
258 internal parameters, like LNA mode
259 * @tuner_callback: an optional function to be called when switching
262 * This function applys the tuner config to tuner specified
263 * by tun_setup structure. It contains several per-tuner initialization "magic"
265 static void set_type(struct i2c_client *c, unsigned int type,
266 unsigned int new_mode_mask, void *new_config,
267 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
269 struct tuner *t = to_tuner(i2c_get_clientdata(c));
270 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
271 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
272 unsigned char buffer[4];
275 if (type == UNSET || type == TUNER_ABSENT) {
276 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c->addr);
281 t->config = new_config;
282 if (tuner_callback != NULL) {
283 tuner_dbg("defining GPIO callback\n");
284 t->fe.callback = tuner_callback;
287 /* discard private data, in case set_type() was previously called */
288 tuner_detach(&t->fe);
289 t->fe.analog_demod_priv = NULL;
293 if (!dvb_attach(microtune_attach,
294 &t->fe, t->i2c->adapter, t->i2c->addr))
297 case TUNER_PHILIPS_TDA8290:
299 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
300 t->i2c->addr, t->config))
305 if (!dvb_attach(tea5767_attach, &t->fe,
306 t->i2c->adapter, t->i2c->addr))
308 t->mode_mask = T_RADIO;
311 if (!dvb_attach(tea5761_attach, &t->fe,
312 t->i2c->adapter, t->i2c->addr))
314 t->mode_mask = T_RADIO;
316 case TUNER_PHILIPS_FMD1216ME_MK3:
317 case TUNER_PHILIPS_FMD1216MEX_MK3:
322 i2c_master_send(c, buffer, 4);
326 i2c_master_send(c, buffer, 4);
327 if (!dvb_attach(simple_tuner_attach, &t->fe,
328 t->i2c->adapter, t->i2c->addr, t->type))
331 case TUNER_PHILIPS_TD1316:
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))
343 struct xc2028_config cfg = {
344 .i2c_adap = t->i2c->adapter,
345 .i2c_addr = t->i2c->addr,
347 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
353 if (!dvb_attach(tda9887_attach,
354 &t->fe, t->i2c->adapter, t->i2c->addr))
359 struct xc5000_config xc5000_cfg = {
360 .i2c_address = t->i2c->addr,
361 /* if_khz will be set at dvb_attach() */
365 if (!dvb_attach(xc5000_attach,
366 &t->fe, t->i2c->adapter, &xc5000_cfg))
373 struct xc5000_config xc5000c_cfg = {
374 .i2c_address = t->i2c->addr,
375 /* if_khz will be set at dvb_attach() */
380 if (!dvb_attach(xc5000_attach,
381 &t->fe, t->i2c->adapter, &xc5000c_cfg))
386 case TUNER_NXP_TDA18271:
388 struct tda18271_config cfg = {
389 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
392 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
393 t->i2c->adapter, &cfg))
400 struct xc4000_config xc4000_cfg = {
401 .i2c_address = t->i2c->addr,
402 /* FIXME: the correct parameters will be set */
403 /* only when the digital dvb_attach() occurs */
406 .set_smoothedcvbs = 0,
409 if (!dvb_attach(xc4000_attach,
410 &t->fe, t->i2c->adapter, &xc4000_cfg))
416 if (!dvb_attach(simple_tuner_attach, &t->fe,
417 t->i2c->adapter, t->i2c->addr, t->type))
423 if ((NULL == analog_ops->set_params) &&
424 (fe_tuner_ops->set_analog_params)) {
426 t->name = fe_tuner_ops->info.name;
428 t->fe.analog_demod_priv = t;
429 memcpy(analog_ops, &tuner_analog_ops,
430 sizeof(struct analog_demod_ops));
432 if (fe_tuner_ops->get_rf_strength)
433 analog_ops->has_signal = fe_tuner_ops->get_rf_strength;
434 if (fe_tuner_ops->get_afc)
435 analog_ops->get_afc = fe_tuner_ops->get_afc;
438 t->name = analog_ops->info.name;
441 #ifdef CONFIG_MEDIA_CONTROLLER
442 t->sd.entity.name = t->name;
445 tuner_dbg("type set to %s\n", t->name);
447 t->mode_mask = new_mode_mask;
449 /* Some tuners require more initialization setup before use,
450 such as firmware download or device calibration.
451 trying to set a frequency here will just fail
452 FIXME: better to move set_freq to the tuner code. This is needed
453 on analog tuners for PLL to properly work
456 if (V4L2_TUNER_RADIO == t->mode)
457 set_radio_freq(c, t->radio_freq);
459 set_tv_freq(c, t->tv_freq);
462 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
463 c->adapter->name, c->dev.driver->name, c->addr << 1, type,
468 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
469 t->type = TUNER_ABSENT;
475 * tuner_s_type_addr - Sets the tuner type for a device
477 * @sd: subdev descriptor
478 * @tun_setup: type to be associated to a given tuner i2c address
480 * This function applys the tuner config to tuner specified
481 * by tun_setup structure.
482 * If tuner I2C address is UNSET, then it will only set the device
483 * if the tuner supports the mode specified in the call.
484 * If the address is specified, the change will be applied only if
485 * tuner I2C address matches.
486 * The call can change the tuner number and the tuner mode.
488 static int tuner_s_type_addr(struct v4l2_subdev *sd,
489 struct tuner_setup *tun_setup)
491 struct tuner *t = to_tuner(sd);
492 struct i2c_client *c = v4l2_get_subdevdata(sd);
494 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=%p\n",
497 tun_setup->mode_mask,
500 if ((t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
501 (t->mode_mask & tun_setup->mode_mask))) ||
502 (tun_setup->addr == c->addr)) {
503 set_type(c, tun_setup->type, tun_setup->mode_mask,
504 tun_setup->config, tun_setup->tuner_callback);
506 tuner_dbg("set addr discarded for type %i, mask %x. "
507 "Asked to change tuner at addr 0x%02x, with mask %x\n",
508 t->type, t->mode_mask,
509 tun_setup->addr, tun_setup->mode_mask);
515 * tuner_s_config - Sets tuner configuration
517 * @sd: subdev descriptor
518 * @cfg: tuner configuration
520 * Calls tuner set_config() private function to set some tuner-internal
523 static int tuner_s_config(struct v4l2_subdev *sd,
524 const struct v4l2_priv_tun_config *cfg)
526 struct tuner *t = to_tuner(sd);
527 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
529 if (t->type != cfg->tuner)
532 if (analog_ops->set_config) {
533 analog_ops->set_config(&t->fe, cfg->priv);
537 tuner_dbg("Tuner frontend module has no way to set config\n");
542 * tuner_lookup - Seek for tuner adapters
544 * @adap: i2c_adapter struct
545 * @radio: pointer to be filled if the adapter is radio
546 * @tv: pointer to be filled if the adapter is TV
548 * Search for existing radio and/or TV tuners on the given I2C adapter,
549 * discarding demod-only adapters (tda9887).
551 * Note that when this function is called from tuner_probe you can be
552 * certain no other devices will be added/deleted at the same time, I2C
553 * core protects against that.
555 static void tuner_lookup(struct i2c_adapter *adap,
556 struct tuner **radio, struct tuner **tv)
563 list_for_each_entry(pos, &tuner_list, list) {
566 if (pos->i2c->adapter != adap ||
567 strcmp(pos->i2c->dev.driver->name, "tuner"))
570 mode_mask = pos->mode_mask;
571 if (*radio == NULL && mode_mask == T_RADIO)
573 /* Note: currently TDA9887 is the only demod-only
574 device. If other devices appear then we need to
575 make this test more general. */
576 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
577 (pos->mode_mask & T_ANALOG_TV))
583 *tuner_probe - Probes the existing tuners on an I2C bus
585 * @client: i2c_client descriptor
588 * This routine probes for tuners at the expected I2C addresses. On most
589 * cases, if a device answers to a given I2C address, it assumes that the
590 * device is a tuner. On a few cases, however, an additional logic is needed
591 * to double check if the device is really a tuner, or to identify the tuner
592 * type, like on tea5767/5761 devices.
594 * During client attach, set_type is called by adapter's attach_inform callback.
595 * set_type must then be completed by tuner_probe.
597 static int tuner_probe(struct i2c_client *client,
598 const struct i2c_device_id *id)
603 #ifdef CONFIG_MEDIA_CONTROLLER
607 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
610 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
612 t->name = "(tuner unset)";
614 t->audmode = V4L2_TUNER_MODE_STEREO;
616 t->radio_freq = 87.5 * 16000; /* Initial freq range */
617 t->tv_freq = 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
620 unsigned char buffer[16];
623 memset(buffer, 0, sizeof(buffer));
624 rc = i2c_master_recv(client, buffer, sizeof(buffer));
625 tuner_info("I2C RECV = ");
626 for (i = 0; i < rc; i++)
627 printk(KERN_CONT "%02x ", buffer[i]);
631 /* autodetection code based on the i2c addr */
632 if (!no_autodetect) {
633 switch (client->addr) {
635 if (tuner_symbol_probe(tea5761_autodetection,
637 t->i2c->addr) >= 0) {
638 t->type = TUNER_TEA5761;
639 t->mode_mask = T_RADIO;
640 tuner_lookup(t->i2c->adapter, &radio, &tv);
642 tv->mode_mask &= ~T_RADIO;
644 goto register_client;
652 /* If chip is not tda8290, don't register.
653 since it can be tda9887*/
654 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
655 t->i2c->addr) >= 0) {
656 tuner_dbg("tda829x detected\n");
658 /* Default is being tda9887 */
659 t->type = TUNER_TDA9887;
660 t->mode_mask = T_RADIO | T_ANALOG_TV;
661 goto register_client;
665 if (tuner_symbol_probe(tea5767_autodetection,
666 t->i2c->adapter, t->i2c->addr)
668 t->type = TUNER_TEA5767;
669 t->mode_mask = T_RADIO;
670 /* Sets freq to FM range */
671 tuner_lookup(t->i2c->adapter, &radio, &tv);
673 tv->mode_mask &= ~T_RADIO;
675 goto register_client;
681 /* Initializes only the first TV tuner on this adapter. Why only the
682 first? Because there are some devices (notably the ones with TI
683 tuners) that have more than one i2c address for the *same* device.
684 Experience shows that, except for just one case, the first
685 address is the right one. The exception is a Russian tuner
686 (ACORP_Y878F). So, the desired behavior is just to enable the
687 first found TV tuner. */
688 tuner_lookup(t->i2c->adapter, &radio, &tv);
690 t->mode_mask = T_ANALOG_TV;
692 t->mode_mask |= T_RADIO;
693 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
696 /* Should be just before return */
698 #if defined(CONFIG_MEDIA_CONTROLLER)
699 t->pad[TUNER_PAD_RF_INPUT].flags = MEDIA_PAD_FL_SINK;
700 t->pad[TUNER_PAD_IF_OUTPUT].flags = MEDIA_PAD_FL_SOURCE;
701 t->sd.entity.function = MEDIA_ENT_F_TUNER;
702 t->sd.entity.name = t->name;
704 ret = media_entity_pads_init(&t->sd.entity, TUNER_NUM_PADS, &t->pad[0]);
706 tuner_err("failed to initialize media entity!\n");
711 /* Sets a default mode */
712 if (t->mode_mask & T_ANALOG_TV)
713 t->mode = V4L2_TUNER_ANALOG_TV;
715 t->mode = V4L2_TUNER_RADIO;
716 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
717 list_add_tail(&t->list, &tuner_list);
719 tuner_info("Tuner %d found with type(s)%s%s.\n",
721 t->mode_mask & T_RADIO ? " Radio" : "",
722 t->mode_mask & T_ANALOG_TV ? " TV" : "");
727 * tuner_remove - detaches a tuner
729 * @client: i2c_client descriptor
732 static int tuner_remove(struct i2c_client *client)
734 struct tuner *t = to_tuner(i2c_get_clientdata(client));
736 v4l2_device_unregister_subdev(&t->sd);
737 tuner_detach(&t->fe);
738 t->fe.analog_demod_priv = NULL;
746 * Functions to switch between Radio and TV
748 * A few cards have a separate I2C tuner for radio. Those routines
749 * take care of switching between TV/Radio mode, filtering only the
750 * commands that apply to the Radio or TV tuner.
754 * check_mode - Verify if tuner supports the requested mode
755 * @t: a pointer to the module's internal struct_tuner
757 * This function checks if the tuner is capable of tuning analog TV,
758 * digital TV or radio, depending on what the caller wants. If the
759 * tuner can't support that mode, it returns -EINVAL. Otherwise, it
761 * This function is needed for boards that have a separate tuner for
762 * radio (like devices with tea5767).
763 * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
764 * select a TV frequency. So, t_mode = T_ANALOG_TV could actually
765 * be used to represent a Digital TV too.
767 static inline int check_mode(struct tuner *t, enum v4l2_tuner_type mode)
770 if (mode == V4L2_TUNER_RADIO)
773 t_mode = T_ANALOG_TV;
775 if ((t_mode & t->mode_mask) == 0)
782 * set_mode - Switch tuner to other mode.
783 * @t: a pointer to the module's internal struct_tuner
784 * @mode: enum v4l2_type (radio or TV)
786 * If tuner doesn't support the needed mode (radio or TV), prints a
787 * debug message and returns -EINVAL, changing its state to standby.
788 * Otherwise, changes the mode and returns 0.
790 static int set_mode(struct tuner *t, enum v4l2_tuner_type mode)
792 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
794 if (mode != t->mode) {
795 if (check_mode(t, mode) == -EINVAL) {
796 tuner_dbg("Tuner doesn't support mode %d. "
797 "Putting tuner to sleep\n", mode);
799 if (analog_ops->standby)
800 analog_ops->standby(&t->fe);
804 tuner_dbg("Changing to mode %d\n", mode);
810 * set_freq - Set the tuner to the desired frequency.
811 * @t: a pointer to the module's internal struct_tuner
812 * @freq: frequency to set (0 means to use the current frequency)
814 static void set_freq(struct tuner *t, unsigned int freq)
816 struct i2c_client *client = v4l2_get_subdevdata(&t->sd);
818 if (t->mode == V4L2_TUNER_RADIO) {
820 freq = t->radio_freq;
821 set_radio_freq(client, freq);
825 set_tv_freq(client, freq);
830 * Functions that are specific for TV mode
834 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz
836 * @c: i2c_client descriptor
839 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
841 struct tuner *t = to_tuner(i2c_get_clientdata(c));
842 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
844 struct analog_parameters params = {
846 .audmode = t->audmode,
850 if (t->type == UNSET) {
851 tuner_warn("tuner type not set\n");
854 if (NULL == analog_ops->set_params) {
855 tuner_warn("Tuner has no way to set tv freq\n");
858 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
859 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
860 freq / 16, freq % 16 * 100 / 16, tv_range[0],
862 /* V4L2 spec: if the freq is not possible then the closest
863 possible value should be selected */
864 if (freq < tv_range[0] * 16)
865 freq = tv_range[0] * 16;
867 freq = tv_range[1] * 16;
869 params.frequency = freq;
870 tuner_dbg("tv freq set to %d.%02d\n",
871 freq / 16, freq % 16 * 100 / 16);
875 analog_ops->set_params(&t->fe, ¶ms);
879 * tuner_fixup_std - force a given video standard variant
881 * @t: tuner internal struct
884 * A few devices or drivers have problem to detect some standard variations.
885 * On other operational systems, the drivers generally have a per-country
886 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
887 * such hacks. Instead, it relies on a proper video standard selection from
888 * the userspace application. However, as some apps are buggy, not allowing
889 * to distinguish all video standard variations, a modprobe parameter can
890 * be used to force a video standard match.
892 static v4l2_std_id tuner_fixup_std(struct tuner *t, v4l2_std_id std)
894 if (pal[0] != '-' && (std & V4L2_STD_PAL) == V4L2_STD_PAL) {
897 return V4L2_STD_PAL_60;
902 return V4L2_STD_PAL_BG;
905 return V4L2_STD_PAL_I;
910 return V4L2_STD_PAL_DK;
913 return V4L2_STD_PAL_M;
916 if (pal[1] == 'c' || pal[1] == 'C')
917 return V4L2_STD_PAL_Nc;
918 return V4L2_STD_PAL_N;
920 tuner_warn("pal= argument not recognised\n");
924 if (secam[0] != '-' && (std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
932 return V4L2_STD_SECAM_B |
939 return V4L2_STD_SECAM_DK;
942 if ((secam[1] == 'C') || (secam[1] == 'c'))
943 return V4L2_STD_SECAM_LC;
944 return V4L2_STD_SECAM_L;
946 tuner_warn("secam= argument not recognised\n");
951 if (ntsc[0] != '-' && (std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
955 return V4L2_STD_NTSC_M;
958 return V4L2_STD_NTSC_M_JP;
961 return V4L2_STD_NTSC_M_KR;
963 tuner_info("ntsc= argument not recognised\n");
971 * Functions that are specific for Radio mode
975 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz
977 * @c: i2c_client descriptor
980 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
982 struct tuner *t = to_tuner(i2c_get_clientdata(c));
983 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
985 struct analog_parameters params = {
987 .audmode = t->audmode,
991 if (t->type == UNSET) {
992 tuner_warn("tuner type not set\n");
995 if (NULL == analog_ops->set_params) {
996 tuner_warn("tuner has no way to set radio frequency\n");
999 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
1000 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
1001 freq / 16000, freq % 16000 * 100 / 16000,
1002 radio_range[0], radio_range[1]);
1003 /* V4L2 spec: if the freq is not possible then the closest
1004 possible value should be selected */
1005 if (freq < radio_range[0] * 16000)
1006 freq = radio_range[0] * 16000;
1008 freq = radio_range[1] * 16000;
1010 params.frequency = freq;
1011 tuner_dbg("radio freq set to %d.%02d\n",
1012 freq / 16000, freq % 16000 * 100 / 16000);
1013 t->radio_freq = freq;
1016 analog_ops->set_params(&t->fe, ¶ms);
1018 * The tuner driver might decide to change the audmode if it only
1019 * supports stereo, so update t->audmode.
1021 t->audmode = params.audmode;
1025 * Debug function for reporting tuner status to userspace
1029 * tuner_status - Dumps the current tuner status at dmesg
1030 * @fe: pointer to struct dvb_frontend
1032 * This callback is used only for driver debug purposes, answering to
1033 * VIDIOC_LOG_STATUS. No changes should happen on this call.
1035 static void tuner_status(struct dvb_frontend *fe)
1037 struct tuner *t = fe->analog_demod_priv;
1038 unsigned long freq, freq_fraction;
1039 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
1040 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
1044 case V4L2_TUNER_RADIO:
1047 case V4L2_TUNER_DIGITAL_TV: /* Used by mt20xx */
1050 case V4L2_TUNER_ANALOG_TV:
1055 if (t->mode == V4L2_TUNER_RADIO) {
1056 freq = t->radio_freq / 16000;
1057 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
1059 freq = t->tv_freq / 16;
1060 freq_fraction = (t->tv_freq % 16) * 100 / 16;
1062 tuner_info("Tuner mode: %s%s\n", p,
1063 t->standby ? " on standby mode" : "");
1064 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
1065 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
1066 if (t->mode != V4L2_TUNER_RADIO)
1068 if (fe_tuner_ops->get_status) {
1071 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1072 if (tuner_status & TUNER_STATUS_LOCKED)
1073 tuner_info("Tuner is locked.\n");
1074 if (tuner_status & TUNER_STATUS_STEREO)
1075 tuner_info("Stereo: yes\n");
1077 if (analog_ops->has_signal) {
1080 if (!analog_ops->has_signal(fe, &signal))
1081 tuner_info("Signal strength: %hu\n", signal);
1086 * Function to splicitly change mode to radio. Probably not needed anymore
1089 static int tuner_s_radio(struct v4l2_subdev *sd)
1091 struct tuner *t = to_tuner(sd);
1093 if (set_mode(t, V4L2_TUNER_RADIO) == 0)
1099 * Tuner callbacks to handle userspace ioctl's
1103 * tuner_s_power - controls the power state of the tuner
1104 * @sd: pointer to struct v4l2_subdev
1105 * @on: a zero value puts the tuner to sleep, non-zero wakes it up
1107 static int tuner_s_power(struct v4l2_subdev *sd, int on)
1109 struct tuner *t = to_tuner(sd);
1110 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1113 if (t->standby && set_mode(t, t->mode) == 0) {
1114 tuner_dbg("Waking up tuner\n");
1120 tuner_dbg("Putting tuner to sleep\n");
1122 if (analog_ops->standby)
1123 analog_ops->standby(&t->fe);
1127 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1129 struct tuner *t = to_tuner(sd);
1131 if (set_mode(t, V4L2_TUNER_ANALOG_TV))
1134 t->std = tuner_fixup_std(t, std);
1136 tuner_dbg("Fixup standard %llx to %llx\n", std, t->std);
1141 static int tuner_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1143 struct tuner *t = to_tuner(sd);
1145 if (set_mode(t, f->type) == 0)
1146 set_freq(t, f->frequency);
1151 * tuner_g_frequency - Get the tuned frequency for the tuner
1152 * @sd: pointer to struct v4l2_subdev
1153 * @f: pointer to struct v4l2_frequency
1155 * At return, the structure f will be filled with tuner frequency
1156 * if the tuner matches the f->type.
1157 * Note: f->type should be initialized before calling it.
1158 * This is done by either video_ioctl2 or by the bridge driver.
1160 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1162 struct tuner *t = to_tuner(sd);
1163 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1165 if (check_mode(t, f->type) == -EINVAL)
1167 if (f->type == t->mode && fe_tuner_ops->get_frequency && !t->standby) {
1170 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
1171 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1172 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
1173 DIV_ROUND_CLOSEST(abs_freq, 62500);
1175 f->frequency = (V4L2_TUNER_RADIO == f->type) ?
1176 t->radio_freq : t->tv_freq;
1182 * tuner_g_tuner - Fill in tuner information
1183 * @sd: pointer to struct v4l2_subdev
1184 * @vt: pointer to struct v4l2_tuner
1186 * At return, the structure vt will be filled with tuner information
1187 * if the tuner matches vt->type.
1188 * Note: vt->type should be initialized before calling it.
1189 * This is done by either video_ioctl2 or by the bridge driver.
1191 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1193 struct tuner *t = to_tuner(sd);
1194 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1195 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1197 if (check_mode(t, vt->type) == -EINVAL)
1199 if (vt->type == t->mode && analog_ops->get_afc)
1200 analog_ops->get_afc(&t->fe, &vt->afc);
1201 if (vt->type == t->mode && analog_ops->has_signal) {
1202 u16 signal = (u16)vt->signal;
1204 if (!analog_ops->has_signal(&t->fe, &signal))
1205 vt->signal = signal;
1207 if (vt->type != V4L2_TUNER_RADIO) {
1208 vt->capability |= V4L2_TUNER_CAP_NORM;
1209 vt->rangelow = tv_range[0] * 16;
1210 vt->rangehigh = tv_range[1] * 16;
1215 if (vt->type == t->mode) {
1216 vt->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1217 if (fe_tuner_ops->get_status) {
1220 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1222 (tuner_status & TUNER_STATUS_STEREO) ?
1223 V4L2_TUNER_SUB_STEREO :
1224 V4L2_TUNER_SUB_MONO;
1226 vt->audmode = t->audmode;
1228 vt->capability |= V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1229 vt->rangelow = radio_range[0] * 16000;
1230 vt->rangehigh = radio_range[1] * 16000;
1236 * tuner_s_tuner - Set the tuner's audio mode
1237 * @sd: pointer to struct v4l2_subdev
1238 * @vt: pointer to struct v4l2_tuner
1240 * Sets the audio mode if the tuner matches vt->type.
1241 * Note: vt->type should be initialized before calling it.
1242 * This is done by either video_ioctl2 or by the bridge driver.
1244 static int tuner_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1246 struct tuner *t = to_tuner(sd);
1248 if (set_mode(t, vt->type))
1251 if (t->mode == V4L2_TUNER_RADIO) {
1252 t->audmode = vt->audmode;
1254 * For radio audmode can only be mono or stereo. Map any
1255 * other values to stereo. The actual tuner driver that is
1256 * called in set_radio_freq can decide to limit the audmode to
1257 * mono if only mono is supported.
1259 if (t->audmode != V4L2_TUNER_MODE_MONO &&
1260 t->audmode != V4L2_TUNER_MODE_STEREO)
1261 t->audmode = V4L2_TUNER_MODE_STEREO;
1268 static int tuner_log_status(struct v4l2_subdev *sd)
1270 struct tuner *t = to_tuner(sd);
1271 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1273 if (analog_ops->tuner_status)
1274 analog_ops->tuner_status(&t->fe);
1278 #ifdef CONFIG_PM_SLEEP
1279 static int tuner_suspend(struct device *dev)
1281 struct i2c_client *c = to_i2c_client(dev);
1282 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1283 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1285 tuner_dbg("suspend\n");
1287 if (t->fe.ops.tuner_ops.suspend)
1288 t->fe.ops.tuner_ops.suspend(&t->fe);
1289 else if (!t->standby && analog_ops->standby)
1290 analog_ops->standby(&t->fe);
1295 static int tuner_resume(struct device *dev)
1297 struct i2c_client *c = to_i2c_client(dev);
1298 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1300 tuner_dbg("resume\n");
1302 if (t->fe.ops.tuner_ops.resume)
1303 t->fe.ops.tuner_ops.resume(&t->fe);
1304 else if (!t->standby)
1305 if (set_mode(t, t->mode) == 0)
1312 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1314 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1316 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1318 There must be a better way of doing this... */
1320 case TUNER_SET_CONFIG:
1321 return tuner_s_config(sd, arg);
1323 return -ENOIOCTLCMD;
1330 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1331 .log_status = tuner_log_status,
1332 .s_power = tuner_s_power,
1335 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1336 .s_radio = tuner_s_radio,
1337 .g_tuner = tuner_g_tuner,
1338 .s_tuner = tuner_s_tuner,
1339 .s_frequency = tuner_s_frequency,
1340 .g_frequency = tuner_g_frequency,
1341 .s_type_addr = tuner_s_type_addr,
1342 .s_config = tuner_s_config,
1345 static const struct v4l2_subdev_video_ops tuner_video_ops = {
1346 .s_std = tuner_s_std,
1349 static const struct v4l2_subdev_ops tuner_ops = {
1350 .core = &tuner_core_ops,
1351 .tuner = &tuner_tuner_ops,
1352 .video = &tuner_video_ops,
1356 * I2C structs and module init functions
1359 static const struct dev_pm_ops tuner_pm_ops = {
1360 SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend, tuner_resume)
1363 static const struct i2c_device_id tuner_id[] = {
1364 { "tuner", }, /* autodetect */
1367 MODULE_DEVICE_TABLE(i2c, tuner_id);
1369 static struct i2c_driver tuner_driver = {
1372 .pm = &tuner_pm_ops,
1374 .probe = tuner_probe,
1375 .remove = tuner_remove,
1376 .command = tuner_command,
1377 .id_table = tuner_id,
1380 module_i2c_driver(tuner_driver);
1382 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1383 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1384 MODULE_LICENSE("GPL");