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->driver->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 */
140 * Function prototypes
143 static void set_tv_freq(struct i2c_client
*c
, unsigned int freq
);
144 static void set_radio_freq(struct i2c_client
*c
, unsigned int freq
);
147 * tuner attach/detach logic
150 /* This macro allows us to probe dynamically, avoiding static links */
151 #ifdef CONFIG_MEDIA_ATTACH
152 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
154 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
156 __r = (int) __a(ARGS); \
157 symbol_put(FUNCTION); \
159 printk(KERN_ERR "TUNER: Unable to find " \
160 "symbol "#FUNCTION"()\n"); \
165 static void tuner_detach(struct dvb_frontend
*fe
)
167 if (fe
->ops
.tuner_ops
.release
) {
168 fe
->ops
.tuner_ops
.release(fe
);
169 symbol_put_addr(fe
->ops
.tuner_ops
.release
);
171 if (fe
->ops
.analog_ops
.release
) {
172 fe
->ops
.analog_ops
.release(fe
);
173 symbol_put_addr(fe
->ops
.analog_ops
.release
);
177 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
181 static void tuner_detach(struct dvb_frontend
*fe
)
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
);
191 static inline struct tuner
*to_tuner(struct v4l2_subdev
*sd
)
193 return container_of(sd
, struct tuner
, sd
);
197 * struct analog_demod_ops callbacks
200 static void fe_set_params(struct dvb_frontend
*fe
,
201 struct analog_parameters
*params
)
203 struct dvb_tuner_ops
*fe_tuner_ops
= &fe
->ops
.tuner_ops
;
204 struct tuner
*t
= fe
->analog_demod_priv
;
206 if (NULL
== fe_tuner_ops
->set_analog_params
) {
207 tuner_warn("Tuner frontend module has no way to set freq\n");
210 fe_tuner_ops
->set_analog_params(fe
, params
);
213 static void fe_standby(struct dvb_frontend
*fe
)
215 struct dvb_tuner_ops
*fe_tuner_ops
= &fe
->ops
.tuner_ops
;
217 if (fe_tuner_ops
->sleep
)
218 fe_tuner_ops
->sleep(fe
);
221 static int fe_has_signal(struct dvb_frontend
*fe
)
225 if (fe
->ops
.tuner_ops
.get_rf_strength
)
226 fe
->ops
.tuner_ops
.get_rf_strength(fe
, &strength
);
231 static int fe_get_afc(struct dvb_frontend
*fe
)
235 if (fe
->ops
.tuner_ops
.get_afc
)
236 fe
->ops
.tuner_ops
.get_afc(fe
, &afc
);
241 static int fe_set_config(struct dvb_frontend
*fe
, void *priv_cfg
)
243 struct dvb_tuner_ops
*fe_tuner_ops
= &fe
->ops
.tuner_ops
;
244 struct tuner
*t
= fe
->analog_demod_priv
;
246 if (fe_tuner_ops
->set_config
)
247 return fe_tuner_ops
->set_config(fe
, priv_cfg
);
249 tuner_warn("Tuner frontend module has no way to set config\n");
254 static void tuner_status(struct dvb_frontend
*fe
);
256 static struct analog_demod_ops tuner_analog_ops
= {
257 .set_params
= fe_set_params
,
258 .standby
= fe_standby
,
259 .has_signal
= fe_has_signal
,
260 .get_afc
= fe_get_afc
,
261 .set_config
= fe_set_config
,
262 .tuner_status
= tuner_status
266 * Functions to select between radio and TV and tuner probe/remove functions
270 * set_type - Sets the tuner type for a given device
272 * @c: i2c_client descriptoy
273 * @type: type of the tuner (e. g. tuner number)
274 * @new_mode_mask: Indicates if tuner supports TV and/or Radio
275 * @new_config: an optional parameter ranging from 0-255 used by
276 a few tuners to adjust an internal parameter,
278 * @tuner_callback: an optional function to be called when switching
281 * This function applys the tuner config to tuner specified
282 * by tun_setup structure. It contains several per-tuner initialization "magic"
284 static void set_type(struct i2c_client
*c
, unsigned int type
,
285 unsigned int new_mode_mask
, unsigned int new_config
,
286 int (*tuner_callback
) (void *dev
, int component
, int cmd
, int arg
))
288 struct tuner
*t
= to_tuner(i2c_get_clientdata(c
));
289 struct dvb_tuner_ops
*fe_tuner_ops
= &t
->fe
.ops
.tuner_ops
;
290 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
291 unsigned char buffer
[4];
294 if (type
== UNSET
|| type
== TUNER_ABSENT
) {
295 tuner_dbg("tuner 0x%02x: Tuner type absent\n", c
->addr
);
300 /* prevent invalid config values */
301 t
->config
= new_config
< 256 ? new_config
: 0;
302 if (tuner_callback
!= NULL
) {
303 tuner_dbg("defining GPIO callback\n");
304 t
->fe
.callback
= tuner_callback
;
307 /* discard private data, in case set_type() was previously called */
308 tuner_detach(&t
->fe
);
309 t
->fe
.analog_demod_priv
= NULL
;
313 if (!dvb_attach(microtune_attach
,
314 &t
->fe
, t
->i2c
->adapter
, t
->i2c
->addr
))
317 case TUNER_PHILIPS_TDA8290
:
319 struct tda829x_config cfg
= {
320 .lna_cfg
= t
->config
,
322 if (!dvb_attach(tda829x_attach
, &t
->fe
, t
->i2c
->adapter
,
328 if (!dvb_attach(tea5767_attach
, &t
->fe
,
329 t
->i2c
->adapter
, t
->i2c
->addr
))
331 t
->mode_mask
= T_RADIO
;
334 if (!dvb_attach(tea5761_attach
, &t
->fe
,
335 t
->i2c
->adapter
, t
->i2c
->addr
))
337 t
->mode_mask
= T_RADIO
;
339 case TUNER_PHILIPS_FMD1216ME_MK3
:
340 case TUNER_PHILIPS_FMD1216MEX_MK3
:
345 i2c_master_send(c
, buffer
, 4);
349 i2c_master_send(c
, buffer
, 4);
350 if (!dvb_attach(simple_tuner_attach
, &t
->fe
,
351 t
->i2c
->adapter
, t
->i2c
->addr
, t
->type
))
354 case TUNER_PHILIPS_TD1316
:
359 i2c_master_send(c
, buffer
, 4);
360 if (!dvb_attach(simple_tuner_attach
, &t
->fe
,
361 t
->i2c
->adapter
, t
->i2c
->addr
, t
->type
))
366 struct xc2028_config cfg
= {
367 .i2c_adap
= t
->i2c
->adapter
,
368 .i2c_addr
= t
->i2c
->addr
,
370 if (!dvb_attach(xc2028_attach
, &t
->fe
, &cfg
))
376 if (!dvb_attach(tda9887_attach
,
377 &t
->fe
, t
->i2c
->adapter
, t
->i2c
->addr
))
382 struct xc5000_config xc5000_cfg
= {
383 .i2c_address
= t
->i2c
->addr
,
384 /* if_khz will be set at dvb_attach() */
388 if (!dvb_attach(xc5000_attach
,
389 &t
->fe
, t
->i2c
->adapter
, &xc5000_cfg
))
396 struct xc5000_config xc5000c_cfg
= {
397 .i2c_address
= t
->i2c
->addr
,
398 /* if_khz will be set at dvb_attach() */
403 if (!dvb_attach(xc5000_attach
,
404 &t
->fe
, t
->i2c
->adapter
, &xc5000c_cfg
))
409 case TUNER_NXP_TDA18271
:
411 struct tda18271_config cfg
= {
413 .small_i2c
= TDA18271_03_BYTE_CHUNK_INIT
,
416 if (!dvb_attach(tda18271_attach
, &t
->fe
, t
->i2c
->addr
,
417 t
->i2c
->adapter
, &cfg
))
424 struct xc4000_config xc4000_cfg
= {
425 .i2c_address
= t
->i2c
->addr
,
426 /* FIXME: the correct parameters will be set */
427 /* only when the digital dvb_attach() occurs */
430 .set_smoothedcvbs
= 0,
433 if (!dvb_attach(xc4000_attach
,
434 &t
->fe
, t
->i2c
->adapter
, &xc4000_cfg
))
440 if (!dvb_attach(simple_tuner_attach
, &t
->fe
,
441 t
->i2c
->adapter
, t
->i2c
->addr
, t
->type
))
447 if ((NULL
== analog_ops
->set_params
) &&
448 (fe_tuner_ops
->set_analog_params
)) {
450 t
->name
= fe_tuner_ops
->info
.name
;
452 t
->fe
.analog_demod_priv
= t
;
453 memcpy(analog_ops
, &tuner_analog_ops
,
454 sizeof(struct analog_demod_ops
));
457 t
->name
= analog_ops
->info
.name
;
460 tuner_dbg("type set to %s\n", t
->name
);
462 t
->mode_mask
= new_mode_mask
;
464 /* Some tuners require more initialization setup before use,
465 such as firmware download or device calibration.
466 trying to set a frequency here will just fail
467 FIXME: better to move set_freq to the tuner code. This is needed
468 on analog tuners for PLL to properly work
471 if (V4L2_TUNER_RADIO
== t
->mode
)
472 set_radio_freq(c
, t
->radio_freq
);
474 set_tv_freq(c
, t
->tv_freq
);
477 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
478 c
->adapter
->name
, c
->driver
->driver
.name
, c
->addr
<< 1, type
,
483 tuner_dbg("Tuner attach for type = %d failed.\n", t
->type
);
484 t
->type
= TUNER_ABSENT
;
490 * tuner_s_type_addr - Sets the tuner type for a device
492 * @sd: subdev descriptor
493 * @tun_setup: type to be associated to a given tuner i2c address
495 * This function applys the tuner config to tuner specified
496 * by tun_setup structure.
497 * If tuner I2C address is UNSET, then it will only set the device
498 * if the tuner supports the mode specified in the call.
499 * If the address is specified, the change will be applied only if
500 * tuner I2C address matches.
501 * The call can change the tuner number and the tuner mode.
503 static int tuner_s_type_addr(struct v4l2_subdev
*sd
,
504 struct tuner_setup
*tun_setup
)
506 struct tuner
*t
= to_tuner(sd
);
507 struct i2c_client
*c
= v4l2_get_subdevdata(sd
);
509 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
512 tun_setup
->mode_mask
,
515 if ((t
->type
== UNSET
&& ((tun_setup
->addr
== ADDR_UNSET
) &&
516 (t
->mode_mask
& tun_setup
->mode_mask
))) ||
517 (tun_setup
->addr
== c
->addr
)) {
518 set_type(c
, tun_setup
->type
, tun_setup
->mode_mask
,
519 tun_setup
->config
, tun_setup
->tuner_callback
);
521 tuner_dbg("set addr discarded for type %i, mask %x. "
522 "Asked to change tuner at addr 0x%02x, with mask %x\n",
523 t
->type
, t
->mode_mask
,
524 tun_setup
->addr
, tun_setup
->mode_mask
);
530 * tuner_s_config - Sets tuner configuration
532 * @sd: subdev descriptor
533 * @cfg: tuner configuration
535 * Calls tuner set_config() private function to set some tuner-internal
538 static int tuner_s_config(struct v4l2_subdev
*sd
,
539 const struct v4l2_priv_tun_config
*cfg
)
541 struct tuner
*t
= to_tuner(sd
);
542 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
544 if (t
->type
!= cfg
->tuner
)
547 if (analog_ops
->set_config
) {
548 analog_ops
->set_config(&t
->fe
, cfg
->priv
);
552 tuner_dbg("Tuner frontend module has no way to set config\n");
557 * tuner_lookup - Seek for tuner adapters
559 * @adap: i2c_adapter struct
560 * @radio: pointer to be filled if the adapter is radio
561 * @tv: pointer to be filled if the adapter is TV
563 * Search for existing radio and/or TV tuners on the given I2C adapter,
564 * discarding demod-only adapters (tda9887).
566 * Note that when this function is called from tuner_probe you can be
567 * certain no other devices will be added/deleted at the same time, I2C
568 * core protects against that.
570 static void tuner_lookup(struct i2c_adapter
*adap
,
571 struct tuner
**radio
, struct tuner
**tv
)
578 list_for_each_entry(pos
, &tuner_list
, list
) {
581 if (pos
->i2c
->adapter
!= adap
||
582 strcmp(pos
->i2c
->driver
->driver
.name
, "tuner"))
585 mode_mask
= pos
->mode_mask
;
586 if (*radio
== NULL
&& mode_mask
== T_RADIO
)
588 /* Note: currently TDA9887 is the only demod-only
589 device. If other devices appear then we need to
590 make this test more general. */
591 else if (*tv
== NULL
&& pos
->type
!= TUNER_TDA9887
&&
592 (pos
->mode_mask
& T_ANALOG_TV
))
598 *tuner_probe - Probes the existing tuners on an I2C bus
600 * @client: i2c_client descriptor
603 * This routine probes for tuners at the expected I2C addresses. On most
604 * cases, if a device answers to a given I2C address, it assumes that the
605 * device is a tuner. On a few cases, however, an additional logic is needed
606 * to double check if the device is really a tuner, or to identify the tuner
607 * type, like on tea5767/5761 devices.
609 * During client attach, set_type is called by adapter's attach_inform callback.
610 * set_type must then be completed by tuner_probe.
612 static int tuner_probe(struct i2c_client
*client
,
613 const struct i2c_device_id
*id
)
619 t
= kzalloc(sizeof(struct tuner
), GFP_KERNEL
);
622 v4l2_i2c_subdev_init(&t
->sd
, client
, &tuner_ops
);
624 t
->name
= "(tuner unset)";
626 t
->audmode
= V4L2_TUNER_MODE_STEREO
;
628 t
->radio_freq
= 87.5 * 16000; /* Initial freq range */
629 t
->tv_freq
= 400 * 16; /* Sets freq to VHF High - needed for some PLL's to properly start */
632 unsigned char buffer
[16];
635 memset(buffer
, 0, sizeof(buffer
));
636 rc
= i2c_master_recv(client
, buffer
, sizeof(buffer
));
637 tuner_info("I2C RECV = ");
638 for (i
= 0; i
< rc
; i
++)
639 printk(KERN_CONT
"%02x ", buffer
[i
]);
643 /* autodetection code based on the i2c addr */
644 if (!no_autodetect
) {
645 switch (client
->addr
) {
647 if (tuner_symbol_probe(tea5761_autodetection
,
649 t
->i2c
->addr
) >= 0) {
650 t
->type
= TUNER_TEA5761
;
651 t
->mode_mask
= T_RADIO
;
652 tuner_lookup(t
->i2c
->adapter
, &radio
, &tv
);
654 tv
->mode_mask
&= ~T_RADIO
;
656 goto register_client
;
664 /* If chip is not tda8290, don't register.
665 since it can be tda9887*/
666 if (tuner_symbol_probe(tda829x_probe
, t
->i2c
->adapter
,
667 t
->i2c
->addr
) >= 0) {
668 tuner_dbg("tda829x detected\n");
670 /* Default is being tda9887 */
671 t
->type
= TUNER_TDA9887
;
672 t
->mode_mask
= T_RADIO
| T_ANALOG_TV
;
673 goto register_client
;
677 if (tuner_symbol_probe(tea5767_autodetection
,
678 t
->i2c
->adapter
, t
->i2c
->addr
)
680 t
->type
= TUNER_TEA5767
;
681 t
->mode_mask
= T_RADIO
;
682 /* Sets freq to FM range */
683 tuner_lookup(t
->i2c
->adapter
, &radio
, &tv
);
685 tv
->mode_mask
&= ~T_RADIO
;
687 goto register_client
;
693 /* Initializes only the first TV tuner on this adapter. Why only the
694 first? Because there are some devices (notably the ones with TI
695 tuners) that have more than one i2c address for the *same* device.
696 Experience shows that, except for just one case, the first
697 address is the right one. The exception is a Russian tuner
698 (ACORP_Y878F). So, the desired behavior is just to enable the
699 first found TV tuner. */
700 tuner_lookup(t
->i2c
->adapter
, &radio
, &tv
);
702 t
->mode_mask
= T_ANALOG_TV
;
704 t
->mode_mask
|= T_RADIO
;
705 tuner_dbg("Setting mode_mask to 0x%02x\n", t
->mode_mask
);
708 /* Should be just before return */
710 /* Sets a default mode */
711 if (t
->mode_mask
& T_ANALOG_TV
)
712 t
->mode
= V4L2_TUNER_ANALOG_TV
;
714 t
->mode
= V4L2_TUNER_RADIO
;
715 set_type(client
, t
->type
, t
->mode_mask
, t
->config
, t
->fe
.callback
);
716 list_add_tail(&t
->list
, &tuner_list
);
718 tuner_info("Tuner %d found with type(s)%s%s.\n",
720 t
->mode_mask
& T_RADIO
? " Radio" : "",
721 t
->mode_mask
& T_ANALOG_TV
? " TV" : "");
726 * tuner_remove - detaches a tuner
728 * @client: i2c_client descriptor
731 static int tuner_remove(struct i2c_client
*client
)
733 struct tuner
*t
= to_tuner(i2c_get_clientdata(client
));
735 v4l2_device_unregister_subdev(&t
->sd
);
736 tuner_detach(&t
->fe
);
737 t
->fe
.analog_demod_priv
= NULL
;
745 * Functions to switch between Radio and TV
747 * A few cards have a separate I2C tuner for radio. Those routines
748 * take care of switching between TV/Radio mode, filtering only the
749 * commands that apply to the Radio or TV tuner.
753 * check_mode - Verify if tuner supports the requested mode
754 * @t: a pointer to the module's internal struct_tuner
756 * This function checks if the tuner is capable of tuning analog TV,
757 * digital TV or radio, depending on what the caller wants. If the
758 * tuner can't support that mode, it returns -EINVAL. Otherwise, it
760 * This function is needed for boards that have a separate tuner for
761 * radio (like devices with tea5767).
762 * NOTE: mt20xx uses V4L2_TUNER_DIGITAL_TV and calls set_tv_freq to
763 * select a TV frequency. So, t_mode = T_ANALOG_TV could actually
764 * be used to represent a Digital TV too.
766 static inline int check_mode(struct tuner
*t
, enum v4l2_tuner_type mode
)
769 if (mode
== V4L2_TUNER_RADIO
)
772 t_mode
= T_ANALOG_TV
;
774 if ((t_mode
& t
->mode_mask
) == 0)
781 * set_mode - Switch tuner to other mode.
782 * @t: a pointer to the module's internal struct_tuner
783 * @mode: enum v4l2_type (radio or TV)
785 * If tuner doesn't support the needed mode (radio or TV), prints a
786 * debug message and returns -EINVAL, changing its state to standby.
787 * Otherwise, changes the mode and returns 0.
789 static int set_mode(struct tuner
*t
, enum v4l2_tuner_type mode
)
791 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
793 if (mode
!= t
->mode
) {
794 if (check_mode(t
, mode
) == -EINVAL
) {
795 tuner_dbg("Tuner doesn't support mode %d. "
796 "Putting tuner to sleep\n", mode
);
798 if (analog_ops
->standby
)
799 analog_ops
->standby(&t
->fe
);
803 tuner_dbg("Changing to mode %d\n", mode
);
809 * set_freq - Set the tuner to the desired frequency.
810 * @t: a pointer to the module's internal struct_tuner
811 * @freq: frequency to set (0 means to use the current frequency)
813 static void set_freq(struct tuner
*t
, unsigned int freq
)
815 struct i2c_client
*client
= v4l2_get_subdevdata(&t
->sd
);
817 if (t
->mode
== V4L2_TUNER_RADIO
) {
819 freq
= t
->radio_freq
;
820 set_radio_freq(client
, freq
);
824 set_tv_freq(client
, freq
);
829 * Functions that are specific for TV mode
833 * set_tv_freq - Set tuner frequency, freq in Units of 62.5 kHz = 1/16MHz
835 * @c: i2c_client descriptor
838 static void set_tv_freq(struct i2c_client
*c
, unsigned int freq
)
840 struct tuner
*t
= to_tuner(i2c_get_clientdata(c
));
841 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
843 struct analog_parameters params
= {
845 .audmode
= t
->audmode
,
849 if (t
->type
== UNSET
) {
850 tuner_warn("tuner type not set\n");
853 if (NULL
== analog_ops
->set_params
) {
854 tuner_warn("Tuner has no way to set tv freq\n");
857 if (freq
< tv_range
[0] * 16 || freq
> tv_range
[1] * 16) {
858 tuner_dbg("TV freq (%d.%02d) out of range (%d-%d)\n",
859 freq
/ 16, freq
% 16 * 100 / 16, tv_range
[0],
861 /* V4L2 spec: if the freq is not possible then the closest
862 possible value should be selected */
863 if (freq
< tv_range
[0] * 16)
864 freq
= tv_range
[0] * 16;
866 freq
= tv_range
[1] * 16;
868 params
.frequency
= freq
;
869 tuner_dbg("tv freq set to %d.%02d\n",
870 freq
/ 16, freq
% 16 * 100 / 16);
874 analog_ops
->set_params(&t
->fe
, ¶ms
);
878 * tuner_fixup_std - force a given video standard variant
880 * @t: tuner internal struct
883 * A few devices or drivers have problem to detect some standard variations.
884 * On other operational systems, the drivers generally have a per-country
885 * code, and some logic to apply per-country hacks. V4L2 API doesn't provide
886 * such hacks. Instead, it relies on a proper video standard selection from
887 * the userspace application. However, as some apps are buggy, not allowing
888 * to distinguish all video standard variations, a modprobe parameter can
889 * be used to force a video standard match.
891 static v4l2_std_id
tuner_fixup_std(struct tuner
*t
, v4l2_std_id std
)
893 if (pal
[0] != '-' && (std
& V4L2_STD_PAL
) == V4L2_STD_PAL
) {
896 return V4L2_STD_PAL_60
;
901 return V4L2_STD_PAL_BG
;
904 return V4L2_STD_PAL_I
;
909 return V4L2_STD_PAL_DK
;
912 return V4L2_STD_PAL_M
;
915 if (pal
[1] == 'c' || pal
[1] == 'C')
916 return V4L2_STD_PAL_Nc
;
917 return V4L2_STD_PAL_N
;
919 tuner_warn("pal= argument not recognised\n");
923 if (secam
[0] != '-' && (std
& V4L2_STD_SECAM
) == V4L2_STD_SECAM
) {
931 return V4L2_STD_SECAM_B
|
938 return V4L2_STD_SECAM_DK
;
941 if ((secam
[1] == 'C') || (secam
[1] == 'c'))
942 return V4L2_STD_SECAM_LC
;
943 return V4L2_STD_SECAM_L
;
945 tuner_warn("secam= argument not recognised\n");
950 if (ntsc
[0] != '-' && (std
& V4L2_STD_NTSC
) == V4L2_STD_NTSC
) {
954 return V4L2_STD_NTSC_M
;
957 return V4L2_STD_NTSC_M_JP
;
960 return V4L2_STD_NTSC_M_KR
;
962 tuner_info("ntsc= argument not recognised\n");
970 * Functions that are specific for Radio mode
974 * set_radio_freq - Set tuner frequency, freq in Units of 62.5 Hz = 1/16kHz
976 * @c: i2c_client descriptor
979 static void set_radio_freq(struct i2c_client
*c
, unsigned int freq
)
981 struct tuner
*t
= to_tuner(i2c_get_clientdata(c
));
982 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
984 struct analog_parameters params
= {
986 .audmode
= t
->audmode
,
990 if (t
->type
== UNSET
) {
991 tuner_warn("tuner type not set\n");
994 if (NULL
== analog_ops
->set_params
) {
995 tuner_warn("tuner has no way to set radio frequency\n");
998 if (freq
< radio_range
[0] * 16000 || freq
> radio_range
[1] * 16000) {
999 tuner_dbg("radio freq (%d.%02d) out of range (%d-%d)\n",
1000 freq
/ 16000, freq
% 16000 * 100 / 16000,
1001 radio_range
[0], radio_range
[1]);
1002 /* V4L2 spec: if the freq is not possible then the closest
1003 possible value should be selected */
1004 if (freq
< radio_range
[0] * 16000)
1005 freq
= radio_range
[0] * 16000;
1007 freq
= radio_range
[1] * 16000;
1009 params
.frequency
= freq
;
1010 tuner_dbg("radio freq set to %d.%02d\n",
1011 freq
/ 16000, freq
% 16000 * 100 / 16000);
1012 t
->radio_freq
= freq
;
1015 analog_ops
->set_params(&t
->fe
, ¶ms
);
1019 * Debug function for reporting tuner status to userspace
1023 * tuner_status - Dumps the current tuner status at dmesg
1024 * @fe: pointer to struct dvb_frontend
1026 * This callback is used only for driver debug purposes, answering to
1027 * VIDIOC_LOG_STATUS. No changes should happen on this call.
1029 static void tuner_status(struct dvb_frontend
*fe
)
1031 struct tuner
*t
= fe
->analog_demod_priv
;
1032 unsigned long freq
, freq_fraction
;
1033 struct dvb_tuner_ops
*fe_tuner_ops
= &fe
->ops
.tuner_ops
;
1034 struct analog_demod_ops
*analog_ops
= &fe
->ops
.analog_ops
;
1038 case V4L2_TUNER_RADIO
:
1041 case V4L2_TUNER_DIGITAL_TV
: /* Used by mt20xx */
1044 case V4L2_TUNER_ANALOG_TV
:
1049 if (t
->mode
== V4L2_TUNER_RADIO
) {
1050 freq
= t
->radio_freq
/ 16000;
1051 freq_fraction
= (t
->radio_freq
% 16000) * 100 / 16000;
1053 freq
= t
->tv_freq
/ 16;
1054 freq_fraction
= (t
->tv_freq
% 16) * 100 / 16;
1056 tuner_info("Tuner mode: %s%s\n", p
,
1057 t
->standby
? " on standby mode" : "");
1058 tuner_info("Frequency: %lu.%02lu MHz\n", freq
, freq_fraction
);
1059 tuner_info("Standard: 0x%08lx\n", (unsigned long)t
->std
);
1060 if (t
->mode
!= V4L2_TUNER_RADIO
)
1062 if (fe_tuner_ops
->get_status
) {
1065 fe_tuner_ops
->get_status(&t
->fe
, &tuner_status
);
1066 if (tuner_status
& TUNER_STATUS_LOCKED
)
1067 tuner_info("Tuner is locked.\n");
1068 if (tuner_status
& TUNER_STATUS_STEREO
)
1069 tuner_info("Stereo: yes\n");
1071 if (analog_ops
->has_signal
)
1072 tuner_info("Signal strength: %d\n",
1073 analog_ops
->has_signal(fe
));
1077 * Function to splicitly change mode to radio. Probably not needed anymore
1080 static int tuner_s_radio(struct v4l2_subdev
*sd
)
1082 struct tuner
*t
= to_tuner(sd
);
1084 if (set_mode(t
, V4L2_TUNER_RADIO
) == 0)
1090 * Tuner callbacks to handle userspace ioctl's
1094 * tuner_s_power - controls the power state of the tuner
1095 * @sd: pointer to struct v4l2_subdev
1096 * @on: a zero value puts the tuner to sleep, non-zero wakes it up
1098 static int tuner_s_power(struct v4l2_subdev
*sd
, int on
)
1100 struct tuner
*t
= to_tuner(sd
);
1101 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
1104 if (t
->standby
&& set_mode(t
, t
->mode
) == 0) {
1105 tuner_dbg("Waking up tuner\n");
1111 tuner_dbg("Putting tuner to sleep\n");
1113 if (analog_ops
->standby
)
1114 analog_ops
->standby(&t
->fe
);
1118 static int tuner_s_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
1120 struct tuner
*t
= to_tuner(sd
);
1122 if (set_mode(t
, V4L2_TUNER_ANALOG_TV
))
1125 t
->std
= tuner_fixup_std(t
, std
);
1127 tuner_dbg("Fixup standard %llx to %llx\n", std
, t
->std
);
1132 static int tuner_s_frequency(struct v4l2_subdev
*sd
, struct v4l2_frequency
*f
)
1134 struct tuner
*t
= to_tuner(sd
);
1136 if (set_mode(t
, f
->type
) == 0)
1137 set_freq(t
, f
->frequency
);
1142 * tuner_g_frequency - Get the tuned frequency for the tuner
1143 * @sd: pointer to struct v4l2_subdev
1144 * @f: pointer to struct v4l2_frequency
1146 * At return, the structure f will be filled with tuner frequency
1147 * if the tuner matches the f->type.
1148 * Note: f->type should be initialized before calling it.
1149 * This is done by either video_ioctl2 or by the bridge driver.
1151 static int tuner_g_frequency(struct v4l2_subdev
*sd
, struct v4l2_frequency
*f
)
1153 struct tuner
*t
= to_tuner(sd
);
1154 struct dvb_tuner_ops
*fe_tuner_ops
= &t
->fe
.ops
.tuner_ops
;
1156 if (check_mode(t
, f
->type
) == -EINVAL
)
1158 if (f
->type
== t
->mode
&& fe_tuner_ops
->get_frequency
&& !t
->standby
) {
1161 fe_tuner_ops
->get_frequency(&t
->fe
, &abs_freq
);
1162 f
->frequency
= (V4L2_TUNER_RADIO
== t
->mode
) ?
1163 DIV_ROUND_CLOSEST(abs_freq
* 2, 125) :
1164 DIV_ROUND_CLOSEST(abs_freq
, 62500);
1166 f
->frequency
= (V4L2_TUNER_RADIO
== f
->type
) ?
1167 t
->radio_freq
: t
->tv_freq
;
1173 * tuner_g_tuner - Fill in tuner information
1174 * @sd: pointer to struct v4l2_subdev
1175 * @vt: pointer to struct v4l2_tuner
1177 * At return, the structure vt will be filled with tuner information
1178 * if the tuner matches vt->type.
1179 * Note: vt->type should be initialized before calling it.
1180 * This is done by either video_ioctl2 or by the bridge driver.
1182 static int tuner_g_tuner(struct v4l2_subdev
*sd
, struct v4l2_tuner
*vt
)
1184 struct tuner
*t
= to_tuner(sd
);
1185 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
1186 struct dvb_tuner_ops
*fe_tuner_ops
= &t
->fe
.ops
.tuner_ops
;
1188 if (check_mode(t
, vt
->type
) == -EINVAL
)
1190 if (vt
->type
== t
->mode
&& analog_ops
->get_afc
)
1191 vt
->afc
= analog_ops
->get_afc(&t
->fe
);
1192 if (analog_ops
->has_signal
)
1193 vt
->signal
= analog_ops
->has_signal(&t
->fe
);
1194 if (vt
->type
!= V4L2_TUNER_RADIO
) {
1195 vt
->capability
|= V4L2_TUNER_CAP_NORM
;
1196 vt
->rangelow
= tv_range
[0] * 16;
1197 vt
->rangehigh
= tv_range
[1] * 16;
1202 if (vt
->type
== t
->mode
) {
1203 vt
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_STEREO
;
1204 if (fe_tuner_ops
->get_status
) {
1207 fe_tuner_ops
->get_status(&t
->fe
, &tuner_status
);
1209 (tuner_status
& TUNER_STATUS_STEREO
) ?
1210 V4L2_TUNER_SUB_STEREO
:
1211 V4L2_TUNER_SUB_MONO
;
1213 vt
->audmode
= t
->audmode
;
1215 vt
->capability
|= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_STEREO
;
1216 vt
->rangelow
= radio_range
[0] * 16000;
1217 vt
->rangehigh
= radio_range
[1] * 16000;
1223 * tuner_s_tuner - Set the tuner's audio mode
1224 * @sd: pointer to struct v4l2_subdev
1225 * @vt: pointer to struct v4l2_tuner
1227 * Sets the audio mode if the tuner matches vt->type.
1228 * Note: vt->type should be initialized before calling it.
1229 * This is done by either video_ioctl2 or by the bridge driver.
1231 static int tuner_s_tuner(struct v4l2_subdev
*sd
, struct v4l2_tuner
*vt
)
1233 struct tuner
*t
= to_tuner(sd
);
1235 if (set_mode(t
, vt
->type
))
1238 if (t
->mode
== V4L2_TUNER_RADIO
)
1239 t
->audmode
= vt
->audmode
;
1245 static int tuner_log_status(struct v4l2_subdev
*sd
)
1247 struct tuner
*t
= to_tuner(sd
);
1248 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
1250 if (analog_ops
->tuner_status
)
1251 analog_ops
->tuner_status(&t
->fe
);
1255 #ifdef CONFIG_PM_SLEEP
1256 static int tuner_suspend(struct device
*dev
)
1258 struct i2c_client
*c
= to_i2c_client(dev
);
1259 struct tuner
*t
= to_tuner(i2c_get_clientdata(c
));
1260 struct analog_demod_ops
*analog_ops
= &t
->fe
.ops
.analog_ops
;
1262 tuner_dbg("suspend\n");
1264 if (!t
->standby
&& analog_ops
->standby
)
1265 analog_ops
->standby(&t
->fe
);
1270 static int tuner_resume(struct device
*dev
)
1272 struct i2c_client
*c
= to_i2c_client(dev
);
1273 struct tuner
*t
= to_tuner(i2c_get_clientdata(c
));
1275 tuner_dbg("resume\n");
1278 if (set_mode(t
, t
->mode
) == 0)
1285 static int tuner_command(struct i2c_client
*client
, unsigned cmd
, void *arg
)
1287 struct v4l2_subdev
*sd
= i2c_get_clientdata(client
);
1289 /* TUNER_SET_CONFIG is still called by tuner-simple.c, so we have
1291 There must be a better way of doing this... */
1293 case TUNER_SET_CONFIG
:
1294 return tuner_s_config(sd
, arg
);
1296 return -ENOIOCTLCMD
;
1303 static const struct v4l2_subdev_core_ops tuner_core_ops
= {
1304 .log_status
= tuner_log_status
,
1305 .s_std
= tuner_s_std
,
1306 .s_power
= tuner_s_power
,
1309 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops
= {
1310 .s_radio
= tuner_s_radio
,
1311 .g_tuner
= tuner_g_tuner
,
1312 .s_tuner
= tuner_s_tuner
,
1313 .s_frequency
= tuner_s_frequency
,
1314 .g_frequency
= tuner_g_frequency
,
1315 .s_type_addr
= tuner_s_type_addr
,
1316 .s_config
= tuner_s_config
,
1319 static const struct v4l2_subdev_ops tuner_ops
= {
1320 .core
= &tuner_core_ops
,
1321 .tuner
= &tuner_tuner_ops
,
1325 * I2C structs and module init functions
1328 static const struct dev_pm_ops tuner_pm_ops
= {
1329 SET_SYSTEM_SLEEP_PM_OPS(tuner_suspend
, tuner_resume
)
1332 static const struct i2c_device_id tuner_id
[] = {
1333 { "tuner", }, /* autodetect */
1336 MODULE_DEVICE_TABLE(i2c
, tuner_id
);
1338 static struct i2c_driver tuner_driver
= {
1340 .owner
= THIS_MODULE
,
1342 .pm
= &tuner_pm_ops
,
1344 .probe
= tuner_probe
,
1345 .remove
= tuner_remove
,
1346 .command
= tuner_command
,
1347 .id_table
= tuner_id
,
1350 module_i2c_driver(tuner_driver
);
1352 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
1353 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
1354 MODULE_LICENSE("GPL");