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_TEA5761
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 */
192 case TUNER_PHILIPS_TDA8290:
196 if (tea5767_tuner_init(c) == EINVAL) {
197 t->type = TUNER_ABSENT;
198 t->mode_mask = T_UNINITIALIZED;
201 t->mode_mask = T_RADIO;
203 #ifdef CONFIG_TUNER_TEA5761
205 if (tea5761_tuner_init(c) == EINVAL) {
206 t->type = TUNER_ABSENT;
207 t->mode_mask = T_UNINITIALIZED;
210 t->mode_mask = T_RADIO;
213 case TUNER_PHILIPS_FMD1216ME_MK3:
218 i2c_master_send(c, buffer, 4);
222 i2c_master_send(c, buffer, 4);
223 default_tuner_init(c);
225 case TUNER_PHILIPS_TD1316:
230 i2c_master_send(c,buffer,4);
231 default_tuner_init(c);
234 tda9887_tuner_init(c);
237 default_tuner_init(c);
241 if (t->mode_mask == T_UNINITIALIZED)
242 t->mode_mask = new_mode_mask;
244 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
245 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
246 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
251 * This function apply tuner config to tuner specified
252 * by tun_setup structure. I addr is unset, then admin status
253 * and tun addr status is more precise then current status,
254 * it's applied. Otherwise status and type are applied only to
255 * tuner with exactly the same addr.
258 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
260 struct tuner *t = i2c_get_clientdata(c);
262 tuner_dbg("set addr for type %i\n", t->type);
264 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
265 (t->mode_mask & tun_setup->mode_mask))) ||
266 (tun_setup->addr == c->addr)) {
267 set_type(c, tun_setup->type, tun_setup->mode_mask,
268 tun_setup->config, tun_setup->tuner_callback);
272 static inline int check_mode(struct tuner *t, char *cmd)
274 if ((1 << t->mode & t->mode_mask) == 0) {
279 case V4L2_TUNER_RADIO:
280 tuner_dbg("Cmd %s accepted for radio\n", cmd);
282 case V4L2_TUNER_ANALOG_TV:
283 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
285 case V4L2_TUNER_DIGITAL_TV:
286 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
292 /* get more precise norm info from insmod option */
293 static int tuner_fixup_std(struct tuner *t)
295 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
298 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
299 t->std = V4L2_STD_PAL_60;
305 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
306 t->std = V4L2_STD_PAL_BG;
310 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
311 t->std = V4L2_STD_PAL_I;
317 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
318 t->std = V4L2_STD_PAL_DK;
322 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
323 t->std = V4L2_STD_PAL_M;
327 if (pal[1] == 'c' || pal[1] == 'C') {
328 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
329 t->std = V4L2_STD_PAL_Nc;
331 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
332 t->std = V4L2_STD_PAL_N;
336 /* default parameter, do nothing */
339 tuner_warn ("pal= argument not recognised\n");
343 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
351 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
352 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
358 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
359 t->std = V4L2_STD_SECAM_DK;
363 if ((secam[1]=='C')||(secam[1]=='c')) {
364 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
365 t->std = V4L2_STD_SECAM_LC;
367 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
368 t->std = V4L2_STD_SECAM_L;
372 /* default parameter, do nothing */
375 tuner_warn ("secam= argument not recognised\n");
380 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
384 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
385 t->std = V4L2_STD_NTSC_M;
389 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
390 t->std = V4L2_STD_NTSC_M_JP;
394 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
395 t->std = V4L2_STD_NTSC_M_KR;
398 /* default parameter, do nothing */
401 tuner_info("ntsc= argument not recognised\n");
408 static void tuner_status(struct i2c_client *client)
410 struct tuner *t = i2c_get_clientdata(client);
411 unsigned long freq, freq_fraction;
415 case V4L2_TUNER_RADIO: p = "radio"; break;
416 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
417 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
418 default: p = "undefined"; break;
420 if (t->mode == V4L2_TUNER_RADIO) {
421 freq = t->radio_freq / 16000;
422 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
424 freq = t->tv_freq / 16;
425 freq_fraction = (t->tv_freq % 16) * 100 / 16;
427 tuner_info("Tuner mode: %s\n", p);
428 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
429 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
430 if (t->mode != V4L2_TUNER_RADIO)
433 tuner_info("Signal strength: %d\n", t->has_signal(client));
436 tuner_info("Stereo: %s\n", t->is_stereo(client) ? "yes" : "no");
440 /* ---------------------------------------------------------------------- */
442 /* static vars: used only in tuner_attach and tuner_probe */
443 static unsigned default_mode_mask;
445 /* During client attach, set_type is called by adapter's attach_inform callback.
446 set_type must then be completed by tuner_attach.
448 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
452 client_template.adapter = adap;
453 client_template.addr = addr;
455 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
458 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
459 i2c_set_clientdata(&t->i2c, t);
461 t->audmode = V4L2_TUNER_MODE_STEREO;
462 t->mode_mask = T_UNINITIALIZED;
463 t->tuner_status = tuner_status;
466 unsigned char buffer[16];
469 memset(buffer, 0, sizeof(buffer));
470 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
471 tuner_info("I2C RECV = ");
473 printk("%02x ",buffer[i]);
476 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
477 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
480 /* autodetection code based on the i2c addr */
481 if (!no_autodetect) {
483 #ifdef CONFIG_TUNER_TEA5761
485 if (tea5761_autodetection(&t->i2c) != EINVAL) {
486 t->type = TUNER_TEA5761;
487 t->mode_mask = T_RADIO;
489 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
490 default_mode_mask &= ~T_RADIO;
492 goto register_client;
500 /* If chip is not tda8290, don't register.
501 since it can be tda9887*/
502 if (tda8290_probe(&t->i2c) == 0) {
503 tuner_dbg("chip at addr %x is a tda8290\n", addr);
505 /* Default is being tda9887 */
506 t->type = TUNER_TDA9887;
507 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
509 goto register_client;
513 if (tea5767_autodetection(&t->i2c) != EINVAL) {
514 t->type = TUNER_TEA5767;
515 t->mode_mask = T_RADIO;
517 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
518 default_mode_mask &= ~T_RADIO;
520 goto register_client;
526 /* Initializes only the first adapter found */
527 if (default_mode_mask != T_UNINITIALIZED) {
528 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
529 t->mode_mask = default_mode_mask;
530 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
531 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
532 default_mode_mask = T_UNINITIALIZED;
535 /* Should be just before return */
537 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
538 i2c_attach_client (&t->i2c);
539 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
543 static int tuner_probe(struct i2c_adapter *adap)
546 normal_i2c[0] = addr;
547 normal_i2c[1] = I2C_CLIENT_END;
550 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
552 if (adap->class & I2C_CLASS_TV_ANALOG)
553 return i2c_probe(adap, &addr_data, tuner_attach);
557 static int tuner_detach(struct i2c_client *client)
559 struct tuner *t = i2c_get_clientdata(client);
562 err = i2c_detach_client(&t->i2c);
565 ("Client deregistration failed, client not detached.\n");
579 * Switch tuner to other mode. If tuner support both tv and radio,
580 * set another frequency to some value (This is needed for some pal
581 * tuners to avoid locking). Otherwise, just put second tuner in
585 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
592 if (check_mode(t, cmd) == EINVAL) {
601 #define switch_v4l2() if (!t->using_v4l2) \
602 tuner_dbg("switching to v4l2\n"); \
605 static inline int check_v4l2(struct tuner *t)
607 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
608 TV, v4l1 for radio), until that is fixed this code is disabled.
609 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
614 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
616 struct tuner *t = i2c_get_clientdata(client);
619 v4l_i2c_print_ioctl(&(t->i2c),cmd);
622 /* --- configuration --- */
623 case TUNER_SET_TYPE_ADDR:
624 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
625 ((struct tuner_setup *)arg)->type,
626 ((struct tuner_setup *)arg)->addr,
627 ((struct tuner_setup *)arg)->mode_mask,
628 ((struct tuner_setup *)arg)->config);
630 set_addr(client, (struct tuner_setup *)arg);
633 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
637 set_freq(client, t->radio_freq);
639 case TUNER_SET_STANDBY:
640 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
646 #ifdef CONFIG_VIDEO_V4L1
648 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
650 if (check_v4l2(t) == EINVAL)
653 /* Should be implemented, since bttv calls it */
654 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
658 static const v4l2_std_id map[] = {
659 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
660 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
661 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
662 [4 /* bttv */ ] = V4L2_STD_PAL_M,
663 [5 /* bttv */ ] = V4L2_STD_PAL_N,
664 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
666 struct video_channel *vc = arg;
668 if (check_v4l2(t) == EINVAL)
671 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
674 if (vc->norm < ARRAY_SIZE(map))
675 t->std = map[vc->norm];
678 set_tv_freq(client, t->tv_freq);
683 unsigned long *v = arg;
685 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
687 if (check_v4l2(t) == EINVAL)
690 set_freq(client, *v);
695 struct video_tuner *vt = arg;
697 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
699 if (check_v4l2(t) == EINVAL)
702 if (V4L2_TUNER_RADIO == t->mode) {
704 vt->signal = t->has_signal(client);
706 if (t->is_stereo(client))
708 VIDEO_TUNER_STEREO_ON;
711 ~VIDEO_TUNER_STEREO_ON;
713 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
715 vt->rangelow = radio_range[0] * 16000;
716 vt->rangehigh = radio_range[1] * 16000;
719 vt->rangelow = tv_range[0] * 16;
720 vt->rangehigh = tv_range[1] * 16;
727 struct video_audio *va = arg;
729 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
731 if (check_v4l2(t) == EINVAL)
734 if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
735 va->mode = t->is_stereo(client)
736 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
740 case TDA9887_SET_CONFIG:
741 if (t->type == TUNER_TDA9887) {
744 t->tda9887_config = *i;
745 set_freq(client, t->tv_freq);
748 /* --- v4l ioctls --- */
749 /* take care: bttv does userspace copying, we'll get a
750 kernel pointer here... */
753 v4l2_std_id *id = arg;
755 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
764 set_freq(client, t->tv_freq);
767 case VIDIOC_S_FREQUENCY:
769 struct v4l2_frequency *f = arg;
771 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
775 set_freq(client,f->frequency);
779 case VIDIOC_G_FREQUENCY:
781 struct v4l2_frequency *f = arg;
783 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
787 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
788 t->radio_freq : t->tv_freq;
793 struct v4l2_tuner *tuner = arg;
795 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
799 tuner->type = t->mode;
801 tuner->afc=t->get_afc(client);
802 if (t->mode == V4L2_TUNER_ANALOG_TV)
803 tuner->capability |= V4L2_TUNER_CAP_NORM;
804 if (t->mode != V4L2_TUNER_RADIO) {
805 tuner->rangelow = tv_range[0] * 16;
806 tuner->rangehigh = tv_range[1] * 16;
812 tuner->signal = t->has_signal(client);
815 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
817 tuner->rxsubchans = t->is_stereo(client) ?
818 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
822 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
823 tuner->audmode = t->audmode;
824 tuner->rangelow = radio_range[0] * 16000;
825 tuner->rangehigh = radio_range[1] * 16000;
830 struct v4l2_tuner *tuner = arg;
832 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
837 /* do nothing unless we're a radio tuner */
838 if (t->mode != V4L2_TUNER_RADIO)
840 t->audmode = tuner->audmode;
841 set_radio_freq(client, t->radio_freq);
844 case VIDIOC_LOG_STATUS:
846 t->tuner_status(client);
853 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
855 struct tuner *t = i2c_get_clientdata (c);
857 tuner_dbg ("suspend\n");
858 /* FIXME: power down ??? */
862 static int tuner_resume(struct i2c_client *c)
864 struct tuner *t = i2c_get_clientdata (c);
866 tuner_dbg ("resume\n");
867 if (V4L2_TUNER_RADIO == t->mode) {
869 set_freq(c, t->radio_freq);
872 set_freq(c, t->tv_freq);
877 /* ----------------------------------------------------------------------- */
879 static struct i2c_driver driver = {
880 .id = I2C_DRIVERID_TUNER,
881 .attach_adapter = tuner_probe,
882 .detach_client = tuner_detach,
883 .command = tuner_command,
884 .suspend = tuner_suspend,
885 .resume = tuner_resume,
890 static struct i2c_client client_template = {
891 .name = "(tuner unset)",
895 static int __init tuner_init_module(void)
897 return i2c_add_driver(&driver);
900 static void __exit tuner_cleanup_module(void)
902 i2c_del_driver(&driver);
905 module_init(tuner_init_module);
906 module_exit(tuner_cleanup_module);
909 * Overrides for Emacs so that we follow Linus's tabbing style.
910 * ---------------------------------------------------------------------------