3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
7 #include <linux/module.h>
8 #include <linux/moduleparam.h>
9 #include <linux/kernel.h>
10 #include <linux/string.h>
11 #include <linux/timer.h>
12 #include <linux/delay.h>
13 #include <linux/errno.h>
14 #include <linux/slab.h>
15 #include <linux/poll.h>
16 #include <linux/i2c.h>
17 #include <linux/types.h>
18 #include <linux/videodev.h>
19 #include <linux/init.h>
21 #include <media/tuner.h>
22 #include <media/v4l2-common.h>
26 /* standard i2c insmod options */
27 static unsigned short normal_i2c[] = {
28 #ifdef CONFIG_TUNER_5761
31 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
32 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
33 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
39 /* insmod options used at init time => read/only */
40 static unsigned int addr = 0;
41 static unsigned int no_autodetect = 0;
42 static unsigned int show_i2c = 0;
44 /* insmod options used at runtime => read/write */
47 static unsigned int tv_range[2] = { 44, 958 };
48 static unsigned int radio_range[2] = { 65, 108 };
50 static char pal[] = "--";
51 static char secam[] = "--";
52 static char ntsc[] = "-";
55 module_param(addr, int, 0444);
56 module_param(no_autodetect, int, 0444);
57 module_param(show_i2c, int, 0444);
58 module_param_named(debug,tuner_debug, int, 0644);
59 module_param_string(pal, pal, sizeof(pal), 0644);
60 module_param_string(secam, secam, sizeof(secam), 0644);
61 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
62 module_param_array(tv_range, int, NULL, 0644);
63 module_param_array(radio_range, int, NULL, 0644);
65 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
66 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
67 MODULE_LICENSE("GPL");
69 static struct i2c_driver driver;
70 static struct i2c_client client_template;
72 /* ---------------------------------------------------------------------- */
74 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
75 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
77 struct tuner *t = i2c_get_clientdata(c);
79 if (t->type == UNSET) {
80 tuner_warn ("tuner type not set\n");
83 if (NULL == t->set_tv_freq) {
84 tuner_warn ("Tuner has no way to set tv freq\n");
87 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
88 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
89 freq / 16, freq % 16 * 100 / 16, tv_range[0],
91 /* V4L2 spec: if the freq is not possible then the closest
92 possible value should be selected */
93 if (freq < tv_range[0] * 16)
94 freq = tv_range[0] * 16;
96 freq = tv_range[1] * 16;
98 t->set_tv_freq(c, freq);
101 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
103 struct tuner *t = i2c_get_clientdata(c);
105 if (t->type == UNSET) {
106 tuner_warn ("tuner type not set\n");
109 if (NULL == t->set_radio_freq) {
110 tuner_warn ("tuner has no way to set radio frequency\n");
113 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
114 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
115 freq / 16000, freq % 16000 * 100 / 16000,
116 radio_range[0], radio_range[1]);
117 /* V4L2 spec: if the freq is not possible then the closest
118 possible value should be selected */
119 if (freq < radio_range[0] * 16000)
120 freq = radio_range[0] * 16000;
122 freq = radio_range[1] * 16000;
125 t->set_radio_freq(c, freq);
128 static void set_freq(struct i2c_client *c, unsigned long freq)
130 struct tuner *t = i2c_get_clientdata(c);
133 case V4L2_TUNER_RADIO:
134 tuner_dbg("radio freq set to %lu.%02lu\n",
135 freq / 16000, freq % 16000 * 100 / 16000);
136 set_radio_freq(c, freq);
137 t->radio_freq = freq;
139 case V4L2_TUNER_ANALOG_TV:
140 case V4L2_TUNER_DIGITAL_TV:
141 tuner_dbg("tv freq set to %lu.%02lu\n",
142 freq / 16, freq % 16 * 100 / 16);
143 set_tv_freq(c, freq);
149 static void set_type(struct i2c_client *c, unsigned int type,
150 unsigned int new_mode_mask, unsigned int new_config,
151 int (*tuner_callback) (void *dev, int command,int arg))
153 struct tuner *t = i2c_get_clientdata(c);
154 unsigned char buffer[4];
156 if (type == UNSET || type == TUNER_ABSENT) {
157 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
161 if (type >= tuner_count) {
162 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
167 t->config = new_config;
168 if (tuner_callback != NULL) {
169 tuner_dbg("defining GPIO callback\n");
170 t->tuner_callback = tuner_callback;
173 /* This code detects calls by card attach_inform */
174 if (NULL == t->i2c.dev.driver) {
175 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
180 /* discard private data, in case set_type() was previously called */
187 case TUNER_PHILIPS_TDA8290:
191 if (tea5767_tuner_init(c) == EINVAL) {
192 t->type = TUNER_ABSENT;
193 t->mode_mask = T_UNINITIALIZED;
196 t->mode_mask = T_RADIO;
198 #ifdef CONFIG_TUNER_5761
200 if (tea5761_tuner_init(c) == EINVAL) {
201 t->type = TUNER_ABSENT;
202 t->mode_mask = T_UNINITIALIZED;
205 t->mode_mask = T_RADIO;
208 case TUNER_PHILIPS_FMD1216ME_MK3:
213 i2c_master_send(c, buffer, 4);
217 i2c_master_send(c, buffer, 4);
218 default_tuner_init(c);
220 case TUNER_PHILIPS_TD1316:
225 i2c_master_send(c,buffer,4);
226 default_tuner_init(c);
229 tda9887_tuner_init(c);
232 default_tuner_init(c);
236 if (t->mode_mask == T_UNINITIALIZED)
237 t->mode_mask = new_mode_mask;
239 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
240 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
241 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
246 * This function apply tuner config to tuner specified
247 * by tun_setup structure. I addr is unset, then admin status
248 * and tun addr status is more precise then current status,
249 * it's applied. Otherwise status and type are applied only to
250 * tuner with exactly the same addr.
253 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
255 struct tuner *t = i2c_get_clientdata(c);
257 tuner_dbg("set addr for type %i\n", t->type);
259 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
260 (t->mode_mask & tun_setup->mode_mask))) ||
261 (tun_setup->addr == c->addr)) {
262 set_type(c, tun_setup->type, tun_setup->mode_mask,
263 tun_setup->config, tun_setup->tuner_callback);
267 static inline int check_mode(struct tuner *t, char *cmd)
269 if ((1 << t->mode & t->mode_mask) == 0) {
274 case V4L2_TUNER_RADIO:
275 tuner_dbg("Cmd %s accepted for radio\n", cmd);
277 case V4L2_TUNER_ANALOG_TV:
278 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
280 case V4L2_TUNER_DIGITAL_TV:
281 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
287 /* get more precise norm info from insmod option */
288 static int tuner_fixup_std(struct tuner *t)
290 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
293 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
294 t->std = V4L2_STD_PAL_60;
300 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
301 t->std = V4L2_STD_PAL_BG;
305 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
306 t->std = V4L2_STD_PAL_I;
312 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
313 t->std = V4L2_STD_PAL_DK;
317 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
318 t->std = V4L2_STD_PAL_M;
322 if (pal[1] == 'c' || pal[1] == 'C') {
323 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
324 t->std = V4L2_STD_PAL_Nc;
326 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
327 t->std = V4L2_STD_PAL_N;
331 /* default parameter, do nothing */
334 tuner_warn ("pal= argument not recognised\n");
338 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
346 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
347 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
353 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
354 t->std = V4L2_STD_SECAM_DK;
358 if ((secam[1]=='C')||(secam[1]=='c')) {
359 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
360 t->std = V4L2_STD_SECAM_LC;
362 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
363 t->std = V4L2_STD_SECAM_L;
367 /* default parameter, do nothing */
370 tuner_warn ("secam= argument not recognised\n");
375 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
379 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
380 t->std = V4L2_STD_NTSC_M;
384 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
385 t->std = V4L2_STD_NTSC_M_JP;
389 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
390 t->std = V4L2_STD_NTSC_M_KR;
393 /* default parameter, do nothing */
396 tuner_info("ntsc= argument not recognised\n");
403 static void tuner_status(struct i2c_client *client)
405 struct tuner *t = i2c_get_clientdata(client);
406 unsigned long freq, freq_fraction;
410 case V4L2_TUNER_RADIO: p = "radio"; break;
411 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
412 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
413 default: p = "undefined"; break;
415 if (t->mode == V4L2_TUNER_RADIO) {
416 freq = t->radio_freq / 16000;
417 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
419 freq = t->tv_freq / 16;
420 freq_fraction = (t->tv_freq % 16) * 100 / 16;
422 tuner_info("Tuner mode: %s\n", p);
423 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
424 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
425 if (t->mode != V4L2_TUNER_RADIO)
428 tuner_info("Signal strength: %d\n", t->has_signal(client));
431 tuner_info("Stereo: %s\n", t->is_stereo(client) ? "yes" : "no");
435 /* ---------------------------------------------------------------------- */
437 /* static vars: used only in tuner_attach and tuner_probe */
438 static unsigned default_mode_mask;
440 /* During client attach, set_type is called by adapter's attach_inform callback.
441 set_type must then be completed by tuner_attach.
443 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
447 client_template.adapter = adap;
448 client_template.addr = addr;
450 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
453 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
454 i2c_set_clientdata(&t->i2c, t);
456 t->audmode = V4L2_TUNER_MODE_STEREO;
457 t->mode_mask = T_UNINITIALIZED;
458 t->tuner_status = tuner_status;
461 unsigned char buffer[16];
464 memset(buffer, 0, sizeof(buffer));
465 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
466 tuner_info("I2C RECV = ");
468 printk("%02x ",buffer[i]);
471 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
472 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
475 /* autodetection code based on the i2c addr */
476 if (!no_autodetect) {
478 #ifdef CONFIG_TUNER_5761
480 if (tea5761_autodetection(&t->i2c) != EINVAL) {
481 t->type = TUNER_TEA5761;
482 t->mode_mask = T_RADIO;
484 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
485 default_mode_mask &= ~T_RADIO;
487 goto register_client;
495 /* If chip is not tda8290, don't register.
496 since it can be tda9887*/
497 if (tda8290_probe(&t->i2c) == 0) {
498 tuner_dbg("chip at addr %x is a tda8290\n", addr);
500 /* Default is being tda9887 */
501 t->type = TUNER_TDA9887;
502 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
504 goto register_client;
508 if (tea5767_autodetection(&t->i2c) != EINVAL) {
509 t->type = TUNER_TEA5767;
510 t->mode_mask = T_RADIO;
512 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
513 default_mode_mask &= ~T_RADIO;
515 goto register_client;
521 /* Initializes only the first adapter found */
522 if (default_mode_mask != T_UNINITIALIZED) {
523 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
524 t->mode_mask = default_mode_mask;
525 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
526 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
527 default_mode_mask = T_UNINITIALIZED;
530 /* Should be just before return */
532 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
533 i2c_attach_client (&t->i2c);
534 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
538 static int tuner_probe(struct i2c_adapter *adap)
541 normal_i2c[0] = addr;
542 normal_i2c[1] = I2C_CLIENT_END;
545 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
547 if (adap->class & I2C_CLASS_TV_ANALOG)
548 return i2c_probe(adap, &addr_data, tuner_attach);
552 static int tuner_detach(struct i2c_client *client)
554 struct tuner *t = i2c_get_clientdata(client);
557 err = i2c_detach_client(&t->i2c);
560 ("Client deregistration failed, client not detached.\n");
570 * Switch tuner to other mode. If tuner support both tv and radio,
571 * set another frequency to some value (This is needed for some pal
572 * tuners to avoid locking). Otherwise, just put second tuner in
576 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
583 if (check_mode(t, cmd) == EINVAL) {
592 #define switch_v4l2() if (!t->using_v4l2) \
593 tuner_dbg("switching to v4l2\n"); \
596 static inline int check_v4l2(struct tuner *t)
598 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
599 TV, v4l1 for radio), until that is fixed this code is disabled.
600 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
605 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
607 struct tuner *t = i2c_get_clientdata(client);
610 v4l_i2c_print_ioctl(&(t->i2c),cmd);
613 /* --- configuration --- */
614 case TUNER_SET_TYPE_ADDR:
615 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
616 ((struct tuner_setup *)arg)->type,
617 ((struct tuner_setup *)arg)->addr,
618 ((struct tuner_setup *)arg)->mode_mask,
619 ((struct tuner_setup *)arg)->config);
621 set_addr(client, (struct tuner_setup *)arg);
624 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
628 set_freq(client, t->radio_freq);
630 case TUNER_SET_STANDBY:
631 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
637 #ifdef CONFIG_VIDEO_V4L1
639 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
641 if (check_v4l2(t) == EINVAL)
644 /* Should be implemented, since bttv calls it */
645 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
649 static const v4l2_std_id map[] = {
650 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
651 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
652 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
653 [4 /* bttv */ ] = V4L2_STD_PAL_M,
654 [5 /* bttv */ ] = V4L2_STD_PAL_N,
655 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
657 struct video_channel *vc = arg;
659 if (check_v4l2(t) == EINVAL)
662 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
665 if (vc->norm < ARRAY_SIZE(map))
666 t->std = map[vc->norm];
669 set_tv_freq(client, t->tv_freq);
674 unsigned long *v = arg;
676 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
678 if (check_v4l2(t) == EINVAL)
681 set_freq(client, *v);
686 struct video_tuner *vt = arg;
688 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
690 if (check_v4l2(t) == EINVAL)
693 if (V4L2_TUNER_RADIO == t->mode) {
695 vt->signal = t->has_signal(client);
697 if (t->is_stereo(client))
699 VIDEO_TUNER_STEREO_ON;
702 ~VIDEO_TUNER_STEREO_ON;
704 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
706 vt->rangelow = radio_range[0] * 16000;
707 vt->rangehigh = radio_range[1] * 16000;
710 vt->rangelow = tv_range[0] * 16;
711 vt->rangehigh = tv_range[1] * 16;
718 struct video_audio *va = arg;
720 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
722 if (check_v4l2(t) == EINVAL)
725 if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
726 va->mode = t->is_stereo(client)
727 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
731 case TDA9887_SET_CONFIG:
732 if (t->type == TUNER_TDA9887) {
735 t->tda9887_config = *i;
736 set_freq(client, t->tv_freq);
739 /* --- v4l ioctls --- */
740 /* take care: bttv does userspace copying, we'll get a
741 kernel pointer here... */
744 v4l2_std_id *id = arg;
746 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
755 set_freq(client, t->tv_freq);
758 case VIDIOC_S_FREQUENCY:
760 struct v4l2_frequency *f = arg;
762 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
766 set_freq(client,f->frequency);
770 case VIDIOC_G_FREQUENCY:
772 struct v4l2_frequency *f = arg;
774 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
778 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
779 t->radio_freq : t->tv_freq;
784 struct v4l2_tuner *tuner = arg;
786 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
790 tuner->type = t->mode;
792 tuner->afc=t->get_afc(client);
793 if (t->mode == V4L2_TUNER_ANALOG_TV)
794 tuner->capability |= V4L2_TUNER_CAP_NORM;
795 if (t->mode != V4L2_TUNER_RADIO) {
796 tuner->rangelow = tv_range[0] * 16;
797 tuner->rangehigh = tv_range[1] * 16;
803 tuner->signal = t->has_signal(client);
806 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
808 tuner->rxsubchans = t->is_stereo(client) ?
809 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
813 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
814 tuner->audmode = t->audmode;
815 tuner->rangelow = radio_range[0] * 16000;
816 tuner->rangehigh = radio_range[1] * 16000;
821 struct v4l2_tuner *tuner = arg;
823 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
828 /* do nothing unless we're a radio tuner */
829 if (t->mode != V4L2_TUNER_RADIO)
831 t->audmode = tuner->audmode;
832 set_radio_freq(client, t->radio_freq);
835 case VIDIOC_LOG_STATUS:
837 t->tuner_status(client);
844 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
846 struct tuner *t = i2c_get_clientdata (c);
848 tuner_dbg ("suspend\n");
849 /* FIXME: power down ??? */
853 static int tuner_resume(struct i2c_client *c)
855 struct tuner *t = i2c_get_clientdata (c);
857 tuner_dbg ("resume\n");
858 if (V4L2_TUNER_RADIO == t->mode) {
860 set_freq(c, t->radio_freq);
863 set_freq(c, t->tv_freq);
868 /* ----------------------------------------------------------------------- */
870 static struct i2c_driver driver = {
871 .id = I2C_DRIVERID_TUNER,
872 .attach_adapter = tuner_probe,
873 .detach_client = tuner_detach,
874 .command = tuner_command,
875 .suspend = tuner_suspend,
876 .resume = tuner_resume,
881 static struct i2c_client client_template = {
882 .name = "(tuner unset)",
886 static int __init tuner_init_module(void)
888 return i2c_add_driver(&driver);
891 static void __exit tuner_cleanup_module(void)
893 i2c_del_driver(&driver);
896 module_init(tuner_init_module);
897 module_exit(tuner_cleanup_module);
900 * Overrides for Emacs so that we follow Linus's tabbing style.
901 * ---------------------------------------------------------------------------