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/sched.h>
11 #include <linux/string.h>
12 #include <linux/timer.h>
13 #include <linux/delay.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/poll.h>
17 #include <linux/i2c.h>
18 #include <linux/types.h>
19 #include <linux/videodev.h>
20 #include <linux/init.h>
22 #include <media/tuner.h>
23 #include <media/v4l2-common.h>
27 /* standard i2c insmod options */
28 static unsigned short normal_i2c[] = {
29 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
30 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
31 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
37 /* insmod options used at init time => read/only */
38 static unsigned int addr = 0;
39 static unsigned int no_autodetect = 0;
40 static unsigned int show_i2c = 0;
42 /* insmod options used at runtime => read/write */
43 static unsigned int tuner_debug_old = 0;
46 static unsigned int tv_range[2] = { 44, 958 };
47 static unsigned int radio_range[2] = { 65, 108 };
49 static char pal[] = "--";
50 static char secam[] = "--";
51 static char ntsc[] = "-";
54 module_param(addr, int, 0444);
55 module_param(no_autodetect, int, 0444);
56 module_param(show_i2c, int, 0444);
57 /* Note: tuner_debug is deprecated and will be removed in 2.6.17 */
58 module_param_named(tuner_debug,tuner_debug_old, int, 0444);
59 module_param_named(debug,tuner_debug, int, 0644);
60 module_param_string(pal, pal, sizeof(pal), 0644);
61 module_param_string(secam, secam, sizeof(secam), 0644);
62 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
63 module_param_array(tv_range, int, NULL, 0644);
64 module_param_array(radio_range, int, NULL, 0644);
66 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
67 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
68 MODULE_LICENSE("GPL");
70 static struct i2c_driver driver;
71 static struct i2c_client client_template;
73 /* ---------------------------------------------------------------------- */
75 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
76 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
78 struct tuner *t = i2c_get_clientdata(c);
80 if (t->type == UNSET) {
81 tuner_warn ("tuner type not set\n");
84 if (NULL == t->set_tv_freq) {
85 tuner_warn ("Tuner has no way to set tv freq\n");
88 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
89 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
90 freq / 16, freq % 16 * 100 / 16, tv_range[0],
92 /* V4L2 spec: if the freq is not possible then the closest
93 possible value should be selected */
94 if (freq < tv_range[0] * 16)
95 freq = tv_range[0] * 16;
97 freq = tv_range[1] * 16;
99 t->set_tv_freq(c, freq);
102 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
104 struct tuner *t = i2c_get_clientdata(c);
106 if (t->type == UNSET) {
107 tuner_warn ("tuner type not set\n");
110 if (NULL == t->set_radio_freq) {
111 tuner_warn ("tuner has no way to set radio frequency\n");
114 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
115 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
116 freq / 16000, freq % 16000 * 100 / 16000,
117 radio_range[0], radio_range[1]);
118 /* V4L2 spec: if the freq is not possible then the closest
119 possible value should be selected */
120 if (freq < radio_range[0] * 16000)
121 freq = radio_range[0] * 16000;
123 freq = radio_range[1] * 16000;
126 t->set_radio_freq(c, freq);
129 static void set_freq(struct i2c_client *c, unsigned long freq)
131 struct tuner *t = i2c_get_clientdata(c);
134 case V4L2_TUNER_RADIO:
135 tuner_dbg("radio freq set to %lu.%02lu\n",
136 freq / 16000, freq % 16000 * 100 / 16000);
137 set_radio_freq(c, freq);
138 t->radio_freq = freq;
140 case V4L2_TUNER_ANALOG_TV:
141 case V4L2_TUNER_DIGITAL_TV:
142 tuner_dbg("tv freq set to %lu.%02lu\n",
143 freq / 16, freq % 16 * 100 / 16);
144 set_tv_freq(c, freq);
150 static void set_type(struct i2c_client *c, unsigned int type,
151 unsigned int new_mode_mask)
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);
166 /* This code detects calls by card attach_inform */
167 if (NULL == t->i2c.dev.driver) {
168 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
179 case TUNER_PHILIPS_TDA8290:
183 if (tea5767_tuner_init(c) == EINVAL) {
184 t->type = TUNER_ABSENT;
185 t->mode_mask = T_UNINITIALIZED;
188 t->mode_mask = T_RADIO;
190 case TUNER_PHILIPS_FMD1216ME_MK3:
195 i2c_master_send(c, buffer, 4);
199 i2c_master_send(c, buffer, 4);
200 default_tuner_init(c);
202 case TUNER_LG_TDVS_H06XF:
203 /* Set the Auxiliary Byte. */
207 i2c_master_send(c, buffer, 4);
208 default_tuner_init(c);
210 case TUNER_PHILIPS_TD1316:
215 i2c_master_send(c,buffer,4);
216 default_tuner_init(c);
219 tda9887_tuner_init(c);
222 default_tuner_init(c);
226 if (t->mode_mask == T_UNINITIALIZED)
227 t->mode_mask = new_mode_mask;
229 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
230 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
231 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
236 * This function apply tuner config to tuner specified
237 * by tun_setup structure. I addr is unset, then admin status
238 * and tun addr status is more precise then current status,
239 * it's applied. Otherwise status and type are applied only to
240 * tuner with exactly the same addr.
243 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
245 struct tuner *t = i2c_get_clientdata(c);
247 tuner_dbg("set addr for type %i\n", t->type);
249 if ( t->type == UNSET && ((tun_setup->addr == ADDR_UNSET &&
250 (t->mode_mask & tun_setup->mode_mask)) ||
251 tun_setup->addr == c->addr)) {
252 set_type(c, tun_setup->type, tun_setup->mode_mask);
256 static inline int check_mode(struct tuner *t, char *cmd)
258 if ((1 << t->mode & t->mode_mask) == 0) {
263 case V4L2_TUNER_RADIO:
264 tuner_dbg("Cmd %s accepted for radio\n", cmd);
266 case V4L2_TUNER_ANALOG_TV:
267 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
269 case V4L2_TUNER_DIGITAL_TV:
270 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
276 /* get more precise norm info from insmod option */
277 static int tuner_fixup_std(struct tuner *t)
279 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
285 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
286 t->std = V4L2_STD_PAL_BG;
290 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
291 t->std = V4L2_STD_PAL_I;
297 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
298 t->std = V4L2_STD_PAL_DK;
302 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
303 t->std = V4L2_STD_PAL_M;
307 if (pal[1] == 'c' || pal[1] == 'C') {
308 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
309 t->std = V4L2_STD_PAL_Nc;
311 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
312 t->std = V4L2_STD_PAL_N;
316 /* default parameter, do nothing */
319 tuner_warn ("pal= argument not recognised\n");
323 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
331 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
332 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
338 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
339 t->std = V4L2_STD_SECAM_DK;
343 if ((secam[1]=='C')||(secam[1]=='c')) {
344 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
345 t->std = V4L2_STD_SECAM_LC;
347 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
348 t->std = V4L2_STD_SECAM_L;
352 /* default parameter, do nothing */
355 tuner_warn ("secam= argument not recognised\n");
360 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
364 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
365 t->std = V4L2_STD_NTSC_M;
369 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
370 t->std = V4L2_STD_NTSC_M_JP;
374 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
375 t->std = V4L2_STD_NTSC_M_KR;
378 /* default parameter, do nothing */
381 tuner_info("ntsc= argument not recognised\n");
388 static void tuner_status(struct i2c_client *client)
390 struct tuner *t = i2c_get_clientdata(client);
391 unsigned long freq, freq_fraction;
395 case V4L2_TUNER_RADIO: p = "radio"; break;
396 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
397 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
398 default: p = "undefined"; break;
400 if (t->mode == V4L2_TUNER_RADIO) {
401 freq = t->radio_freq / 16000;
402 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
404 freq = t->tv_freq / 16;
405 freq_fraction = (t->tv_freq % 16) * 100 / 16;
407 tuner_info("Tuner mode: %s\n", p);
408 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
409 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
410 if (t->mode != V4L2_TUNER_RADIO)
413 tuner_info("Signal strength: %d\n", t->has_signal(client));
416 tuner_info("Stereo: %s\n", t->is_stereo(client) ? "yes" : "no");
420 /* ---------------------------------------------------------------------- */
422 /* static var Used only in tuner_attach and tuner_probe */
423 static unsigned default_mode_mask;
425 /* During client attach, set_type is called by adapter's attach_inform callback.
426 set_type must then be completed by tuner_attach.
428 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
432 client_template.adapter = adap;
433 client_template.addr = addr;
435 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
438 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
439 i2c_set_clientdata(&t->i2c, t);
441 t->radio_if2 = 10700 * 1000; /* 10.7MHz - FM radio */
442 t->audmode = V4L2_TUNER_MODE_STEREO;
443 t->mode_mask = T_UNINITIALIZED;
444 t->tuner_status = tuner_status;
445 if (tuner_debug_old) {
446 tuner_debug = tuner_debug_old;
447 printk(KERN_ERR "tuner: tuner_debug is deprecated and will be removed in 2.6.17.\n");
448 printk(KERN_ERR "tuner: use the debug option instead.\n");
452 unsigned char buffer[16];
455 memset(buffer, 0, sizeof(buffer));
456 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
457 tuner_info("I2C RECV = ");
459 printk("%02x ",buffer[i]);
462 /* autodetection code based on the i2c addr */
463 if (!no_autodetect) {
469 /* If chip is not tda8290, don't register.
470 since it can be tda9887*/
471 if (tda8290_probe(&t->i2c) == 0) {
472 tuner_dbg("chip at addr %x is a tda8290\n", addr);
474 /* Default is being tda9887 */
475 t->type = TUNER_TDA9887;
476 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
478 goto register_client;
482 if (tea5767_autodetection(&t->i2c) != EINVAL) {
483 t->type = TUNER_TEA5767;
484 t->mode_mask = T_RADIO;
486 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
487 default_mode_mask &= ~T_RADIO;
489 goto register_client;
495 /* Initializes only the first adapter found */
496 if (default_mode_mask != T_UNINITIALIZED) {
497 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
498 t->mode_mask = default_mode_mask;
499 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
500 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
501 default_mode_mask = T_UNINITIALIZED;
504 /* Should be just before return */
506 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
507 i2c_attach_client (&t->i2c);
508 set_type (&t->i2c,t->type, t->mode_mask);
512 static int tuner_probe(struct i2c_adapter *adap)
515 normal_i2c[0] = addr;
516 normal_i2c[1] = I2C_CLIENT_END;
519 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
521 if (adap->class & I2C_CLASS_TV_ANALOG)
522 return i2c_probe(adap, &addr_data, tuner_attach);
526 static int tuner_detach(struct i2c_client *client)
528 struct tuner *t = i2c_get_clientdata(client);
531 err = i2c_detach_client(&t->i2c);
534 ("Client deregistration failed, client not detached.\n");
543 * Switch tuner to other mode. If tuner support both tv and radio,
544 * set another frequency to some value (This is needed for some pal
545 * tuners to avoid locking). Otherwise, just put second tuner in
549 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
556 if (check_mode(t, cmd) == EINVAL) {
565 #define switch_v4l2() if (!t->using_v4l2) \
566 tuner_dbg("switching to v4l2\n"); \
569 static inline int check_v4l2(struct tuner *t)
571 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
572 TV, v4l1 for radio), until that is fixed this code is disabled.
573 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
578 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
580 struct tuner *t = i2c_get_clientdata(client);
583 v4l_i2c_print_ioctl(&(t->i2c),cmd);
586 /* --- configuration --- */
587 case TUNER_SET_TYPE_ADDR:
588 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x\n",
589 ((struct tuner_setup *)arg)->type,
590 ((struct tuner_setup *)arg)->addr,
591 ((struct tuner_setup *)arg)->mode_mask);
593 set_addr(client, (struct tuner_setup *)arg);
596 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
600 set_freq(client, t->radio_freq);
602 case TUNER_SET_STANDBY:
603 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
610 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
612 if (check_v4l2(t) == EINVAL)
615 /* Should be implemented, since bttv calls it */
616 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
618 case TDA9887_SET_CONFIG:
622 t->tda9887_config = *i;
623 set_freq(client, t->tv_freq);
626 /* --- v4l ioctls --- */
627 /* take care: bttv does userspace copying, we'll get a
628 kernel pointer here... */
631 static const v4l2_std_id map[] = {
632 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
633 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
634 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
635 [4 /* bttv */ ] = V4L2_STD_PAL_M,
636 [5 /* bttv */ ] = V4L2_STD_PAL_N,
637 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
639 struct video_channel *vc = arg;
641 if (check_v4l2(t) == EINVAL)
644 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
647 if (vc->norm < ARRAY_SIZE(map))
648 t->std = map[vc->norm];
651 set_tv_freq(client, t->tv_freq);
656 unsigned long *v = arg;
658 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
660 if (check_v4l2(t) == EINVAL)
663 set_freq(client, *v);
668 struct video_tuner *vt = arg;
670 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
672 if (check_v4l2(t) == EINVAL)
675 if (V4L2_TUNER_RADIO == t->mode) {
677 vt->signal = t->has_signal(client);
679 if (t->is_stereo(client))
681 VIDEO_TUNER_STEREO_ON;
684 ~VIDEO_TUNER_STEREO_ON;
686 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
688 vt->rangelow = radio_range[0] * 16000;
689 vt->rangehigh = radio_range[1] * 16000;
692 vt->rangelow = tv_range[0] * 16;
693 vt->rangehigh = tv_range[1] * 16;
700 struct video_audio *va = arg;
702 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
704 if (check_v4l2(t) == EINVAL)
707 if (V4L2_TUNER_RADIO == t->mode && t->is_stereo)
708 va->mode = t->is_stereo(client)
709 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
715 v4l2_std_id *id = arg;
717 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
726 set_freq(client, t->tv_freq);
729 case VIDIOC_S_FREQUENCY:
731 struct v4l2_frequency *f = arg;
733 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
737 set_freq(client,f->frequency);
741 case VIDIOC_G_FREQUENCY:
743 struct v4l2_frequency *f = arg;
745 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
749 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
750 t->radio_freq : t->tv_freq;
755 struct v4l2_tuner *tuner = arg;
757 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
761 tuner->type = t->mode;
763 tuner->afc=t->get_afc(client);
764 if (t->mode == V4L2_TUNER_ANALOG_TV)
765 tuner->capability |= V4L2_TUNER_CAP_NORM;
766 if (t->mode != V4L2_TUNER_RADIO) {
767 tuner->rangelow = tv_range[0] * 16;
768 tuner->rangehigh = tv_range[1] * 16;
774 tuner->signal = t->has_signal(client);
777 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
779 tuner->rxsubchans = t->is_stereo(client) ?
780 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
784 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
785 tuner->audmode = t->audmode;
786 tuner->rangelow = radio_range[0] * 16000;
787 tuner->rangehigh = radio_range[1] * 16000;
792 struct v4l2_tuner *tuner = arg;
794 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
799 /* do nothing unless we're a radio tuner */
800 if (t->mode != V4L2_TUNER_RADIO)
802 t->audmode = tuner->audmode;
803 set_radio_freq(client, t->radio_freq);
806 case VIDIOC_LOG_STATUS:
808 t->tuner_status(client);
815 static int tuner_suspend(struct device *dev, pm_message_t state)
817 struct i2c_client *c = container_of (dev, struct i2c_client, dev);
818 struct tuner *t = i2c_get_clientdata (c);
820 tuner_dbg ("suspend\n");
821 /* FIXME: power down ??? */
825 static int tuner_resume(struct device *dev)
827 struct i2c_client *c = container_of (dev, struct i2c_client, dev);
828 struct tuner *t = i2c_get_clientdata (c);
830 tuner_dbg ("resume\n");
831 if (V4L2_TUNER_RADIO == t->mode) {
833 set_freq(c, t->radio_freq);
836 set_freq(c, t->tv_freq);
841 /* ----------------------------------------------------------------------- */
843 static struct i2c_driver driver = {
844 .id = I2C_DRIVERID_TUNER,
845 .attach_adapter = tuner_probe,
846 .detach_client = tuner_detach,
847 .command = tuner_command,
850 .suspend = tuner_suspend,
851 .resume = tuner_resume,
854 static struct i2c_client client_template = {
855 .name = "(tuner unset)",
859 static int __init tuner_init_module(void)
861 return i2c_add_driver(&driver);
864 static void __exit tuner_cleanup_module(void)
866 i2c_del_driver(&driver);
869 module_init(tuner_init_module);
870 module_exit(tuner_cleanup_module);
873 * Overrides for Emacs so that we follow Linus's tabbing style.
874 * ---------------------------------------------------------------------------