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/kernel.h>
9 #include <linux/string.h>
10 #include <linux/timer.h>
11 #include <linux/delay.h>
12 #include <linux/errno.h>
13 #include <linux/slab.h>
14 #include <linux/poll.h>
15 #include <linux/i2c.h>
16 #include <linux/types.h>
17 #include <linux/init.h>
18 #include <linux/videodev.h>
19 #include <media/tuner.h>
20 #include <media/tuner-types.h>
21 #include <media/v4l2-common.h>
22 #include <media/v4l2-i2c-drv-legacy.h>
27 #include "tuner-xc2028.h"
28 #include "tuner-simple.h"
33 #define PREFIX t->i2c->driver->driver.name
37 struct dvb_frontend fe;
38 struct i2c_client *i2c;
39 struct list_head list;
40 unsigned int using_v4l2:1;
42 /* keep track of the current settings */
45 unsigned int radio_freq;
49 unsigned int mode_mask; /* Combination of allowable modes */
51 unsigned int type; /* chip type id */
53 int (*tuner_callback) (void *dev, int command, int arg);
56 /* standard i2c insmod options */
57 static unsigned short normal_i2c[] = {
58 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
61 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
62 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
63 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
69 /* insmod options used at init time => read/only */
70 static unsigned int addr = 0;
71 static unsigned int no_autodetect = 0;
72 static unsigned int show_i2c = 0;
74 /* insmod options used at runtime => read/write */
75 static int tuner_debug;
77 #define tuner_warn(fmt, arg...) do { \
78 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
79 i2c_adapter_id(t->i2c->adapter), \
80 t->i2c->addr, ##arg); \
83 #define tuner_info(fmt, arg...) do { \
84 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
85 i2c_adapter_id(t->i2c->adapter), \
86 t->i2c->addr, ##arg); \
89 #define tuner_err(fmt, arg...) do { \
90 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
91 i2c_adapter_id(t->i2c->adapter), \
92 t->i2c->addr, ##arg); \
95 #define tuner_dbg(fmt, arg...) do { \
97 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
98 i2c_adapter_id(t->i2c->adapter), \
99 t->i2c->addr, ##arg); \
102 /* ------------------------------------------------------------------------ */
104 static unsigned int tv_range[2] = { 44, 958 };
105 static unsigned int radio_range[2] = { 65, 108 };
107 static char pal[] = "--";
108 static char secam[] = "--";
109 static char ntsc[] = "-";
112 module_param(addr, int, 0444);
113 module_param(no_autodetect, int, 0444);
114 module_param(show_i2c, int, 0444);
115 module_param_named(debug,tuner_debug, int, 0644);
116 module_param_string(pal, pal, sizeof(pal), 0644);
117 module_param_string(secam, secam, sizeof(secam), 0644);
118 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
119 module_param_array(tv_range, int, NULL, 0644);
120 module_param_array(radio_range, int, NULL, 0644);
122 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
123 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
124 MODULE_LICENSE("GPL");
126 /* ---------------------------------------------------------------------- */
128 static void fe_set_params(struct dvb_frontend *fe,
129 struct analog_parameters *params)
131 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
132 struct tuner *t = fe->analog_demod_priv;
134 if (NULL == fe_tuner_ops->set_analog_params) {
135 tuner_warn("Tuner frontend module has no way to set freq\n");
138 fe_tuner_ops->set_analog_params(fe, params);
141 static void fe_release(struct dvb_frontend *fe)
143 if (fe->ops.tuner_ops.release)
144 fe->ops.tuner_ops.release(fe);
146 /* DO NOT kfree(fe->analog_demod_priv)
148 * If we are in this function, analog_demod_priv contains a pointer
149 * to struct tuner *t. This will be kfree'd in tuner_detach().
151 * Otherwise, fe->ops.analog_demod_ops->release will
152 * handle the cleanup for analog demodulator modules.
154 fe->analog_demod_priv = NULL;
157 static void fe_standby(struct dvb_frontend *fe)
159 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
161 if (fe_tuner_ops->sleep)
162 fe_tuner_ops->sleep(fe);
165 static int fe_has_signal(struct dvb_frontend *fe)
169 if (fe->ops.tuner_ops.get_rf_strength)
170 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
175 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
177 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
178 struct tuner *t = fe->analog_demod_priv;
180 if (fe_tuner_ops->set_config)
181 return fe_tuner_ops->set_config(fe, priv_cfg);
183 tuner_warn("Tuner frontend module has no way to set config\n");
188 static void tuner_status(struct dvb_frontend *fe);
190 static struct analog_demod_ops tuner_core_ops = {
191 .set_params = fe_set_params,
192 .standby = fe_standby,
193 .release = fe_release,
194 .has_signal = fe_has_signal,
195 .set_config = fe_set_config,
196 .tuner_status = tuner_status
199 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
200 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
202 struct tuner *t = i2c_get_clientdata(c);
203 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
205 struct analog_parameters params = {
207 .audmode = t->audmode,
211 if (t->type == UNSET) {
212 tuner_warn ("tuner type not set\n");
215 if (NULL == analog_ops->set_params) {
216 tuner_warn ("Tuner has no way to set tv freq\n");
219 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
220 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
221 freq / 16, freq % 16 * 100 / 16, tv_range[0],
223 /* V4L2 spec: if the freq is not possible then the closest
224 possible value should be selected */
225 if (freq < tv_range[0] * 16)
226 freq = tv_range[0] * 16;
228 freq = tv_range[1] * 16;
230 params.frequency = freq;
232 analog_ops->set_params(&t->fe, ¶ms);
235 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
237 struct tuner *t = i2c_get_clientdata(c);
238 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
240 struct analog_parameters params = {
242 .audmode = t->audmode,
246 if (t->type == UNSET) {
247 tuner_warn ("tuner type not set\n");
250 if (analog_ops->set_params) {
251 tuner_warn ("tuner has no way to set radio frequency\n");
254 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
255 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
256 freq / 16000, freq % 16000 * 100 / 16000,
257 radio_range[0], radio_range[1]);
258 /* V4L2 spec: if the freq is not possible then the closest
259 possible value should be selected */
260 if (freq < radio_range[0] * 16000)
261 freq = radio_range[0] * 16000;
263 freq = radio_range[1] * 16000;
265 params.frequency = freq;
267 analog_ops->set_params(&t->fe, ¶ms);
270 static void set_freq(struct i2c_client *c, unsigned long freq)
272 struct tuner *t = i2c_get_clientdata(c);
275 case V4L2_TUNER_RADIO:
276 tuner_dbg("radio freq set to %lu.%02lu\n",
277 freq / 16000, freq % 16000 * 100 / 16000);
278 set_radio_freq(c, freq);
279 t->radio_freq = freq;
281 case V4L2_TUNER_ANALOG_TV:
282 case V4L2_TUNER_DIGITAL_TV:
283 tuner_dbg("tv freq set to %lu.%02lu\n",
284 freq / 16, freq % 16 * 100 / 16);
285 set_tv_freq(c, freq);
289 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
293 static void tuner_i2c_address_check(struct tuner *t)
295 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
296 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
299 tuner_warn("====================== WARNING! ======================\n");
300 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
301 tuner_warn("will soon be dropped. This message indicates that your\n");
302 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
303 t->i2c->name, t->i2c->addr);
304 tuner_warn("To ensure continued support for your device, please\n");
305 tuner_warn("send a copy of this message, along with full dmesg\n");
306 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
307 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
308 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
309 t->i2c->adapter->name, t->i2c->addr, t->type,
310 tuners[t->type].name);
311 tuner_warn("====================== WARNING! ======================\n");
314 static void attach_simple_tuner(struct tuner *t)
316 struct simple_tuner_config cfg = {
318 .tun = &tuners[t->type]
320 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
323 static void attach_tda829x(struct tuner *t)
325 struct tda829x_config cfg = {
326 .lna_cfg = &t->config,
327 .tuner_callback = t->tuner_callback,
329 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
332 static void set_type(struct i2c_client *c, unsigned int type,
333 unsigned int new_mode_mask, unsigned int new_config,
334 int (*tuner_callback) (void *dev, int command,int arg))
336 struct tuner *t = i2c_get_clientdata(c);
337 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
338 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
339 unsigned char buffer[4];
341 if (type == UNSET || type == TUNER_ABSENT) {
342 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
346 if (type >= tuner_count) {
347 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
352 t->config = new_config;
353 if (tuner_callback != NULL) {
354 tuner_dbg("defining GPIO callback\n");
355 t->tuner_callback = tuner_callback;
358 if (t->mode == T_UNINITIALIZED) {
359 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
364 /* discard private data, in case set_type() was previously called */
365 if (analog_ops->release)
366 analog_ops->release(&t->fe);
370 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
372 case TUNER_PHILIPS_TDA8290:
378 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
379 t->type = TUNER_ABSENT;
380 t->mode_mask = T_UNINITIALIZED;
383 t->mode_mask = T_RADIO;
386 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
387 t->type = TUNER_ABSENT;
388 t->mode_mask = T_UNINITIALIZED;
391 t->mode_mask = T_RADIO;
393 case TUNER_PHILIPS_FMD1216ME_MK3:
398 i2c_master_send(c, buffer, 4);
402 i2c_master_send(c, buffer, 4);
403 attach_simple_tuner(t);
405 case TUNER_PHILIPS_TD1316:
410 i2c_master_send(c,buffer,4);
411 attach_simple_tuner(t);
415 struct xc2028_config cfg = {
416 .i2c_adap = t->i2c->adapter,
417 .i2c_addr = t->i2c->addr,
418 .video_dev = c->adapter->algo_data,
419 .callback = t->tuner_callback,
421 if (!xc2028_attach(&t->fe, &cfg)) {
422 t->type = TUNER_ABSENT;
423 t->mode_mask = T_UNINITIALIZED;
429 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
432 attach_simple_tuner(t);
436 if ((NULL == analog_ops->set_params) &&
437 (fe_tuner_ops->set_analog_params)) {
438 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
439 sizeof(t->i2c->name));
441 t->fe.analog_demod_priv = t;
442 memcpy(analog_ops, &tuner_core_ops,
443 sizeof(struct analog_demod_ops));
445 strlcpy(t->i2c->name, analog_ops->info.name,
446 sizeof(t->i2c->name));
449 tuner_dbg("type set to %s\n", t->i2c->name);
451 if (t->mode_mask == T_UNINITIALIZED)
452 t->mode_mask = new_mode_mask;
454 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
455 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
456 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
458 tuner_i2c_address_check(t);
462 * This function apply tuner config to tuner specified
463 * by tun_setup structure. I addr is unset, then admin status
464 * and tun addr status is more precise then current status,
465 * it's applied. Otherwise status and type are applied only to
466 * tuner with exactly the same addr.
469 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
471 struct tuner *t = i2c_get_clientdata(c);
473 tuner_dbg("set addr for type %i\n", t->type);
475 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
476 (t->mode_mask & tun_setup->mode_mask))) ||
477 (tun_setup->addr == c->addr)) {
478 set_type(c, tun_setup->type, tun_setup->mode_mask,
479 tun_setup->config, tun_setup->tuner_callback);
483 static inline int check_mode(struct tuner *t, char *cmd)
485 if ((1 << t->mode & t->mode_mask) == 0) {
490 case V4L2_TUNER_RADIO:
491 tuner_dbg("Cmd %s accepted for radio\n", cmd);
493 case V4L2_TUNER_ANALOG_TV:
494 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
496 case V4L2_TUNER_DIGITAL_TV:
497 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
503 /* get more precise norm info from insmod option */
504 static int tuner_fixup_std(struct tuner *t)
506 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
509 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
510 t->std = V4L2_STD_PAL_60;
516 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
517 t->std = V4L2_STD_PAL_BG;
521 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
522 t->std = V4L2_STD_PAL_I;
528 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
529 t->std = V4L2_STD_PAL_DK;
533 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
534 t->std = V4L2_STD_PAL_M;
538 if (pal[1] == 'c' || pal[1] == 'C') {
539 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
540 t->std = V4L2_STD_PAL_Nc;
542 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
543 t->std = V4L2_STD_PAL_N;
547 /* default parameter, do nothing */
550 tuner_warn ("pal= argument not recognised\n");
554 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
562 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
563 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
569 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
570 t->std = V4L2_STD_SECAM_DK;
574 if ((secam[1]=='C')||(secam[1]=='c')) {
575 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
576 t->std = V4L2_STD_SECAM_LC;
578 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
579 t->std = V4L2_STD_SECAM_L;
583 /* default parameter, do nothing */
586 tuner_warn ("secam= argument not recognised\n");
591 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
595 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
596 t->std = V4L2_STD_NTSC_M;
600 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
601 t->std = V4L2_STD_NTSC_M_JP;
605 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
606 t->std = V4L2_STD_NTSC_M_KR;
609 /* default parameter, do nothing */
612 tuner_info("ntsc= argument not recognised\n");
619 static void tuner_status(struct dvb_frontend *fe)
621 struct tuner *t = fe->analog_demod_priv;
622 unsigned long freq, freq_fraction;
623 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
624 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
628 case V4L2_TUNER_RADIO: p = "radio"; break;
629 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
630 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
631 default: p = "undefined"; break;
633 if (t->mode == V4L2_TUNER_RADIO) {
634 freq = t->radio_freq / 16000;
635 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
637 freq = t->tv_freq / 16;
638 freq_fraction = (t->tv_freq % 16) * 100 / 16;
640 tuner_info("Tuner mode: %s\n", p);
641 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
642 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
643 if (t->mode != V4L2_TUNER_RADIO)
645 if (fe_tuner_ops->get_status) {
648 fe_tuner_ops->get_status(&t->fe, &tuner_status);
649 if (tuner_status & TUNER_STATUS_LOCKED)
650 tuner_info("Tuner is locked.\n");
651 if (tuner_status & TUNER_STATUS_STEREO)
652 tuner_info("Stereo: yes\n");
654 if (analog_ops->has_signal)
655 tuner_info("Signal strength: %d\n",
656 analog_ops->has_signal(fe));
657 if (analog_ops->is_stereo)
658 tuner_info("Stereo: %s\n",
659 analog_ops->is_stereo(fe) ? "yes" : "no");
662 /* ---------------------------------------------------------------------- */
665 * Switch tuner to other mode. If tuner support both tv and radio,
666 * set another frequency to some value (This is needed for some pal
667 * tuners to avoid locking). Otherwise, just put second tuner in
671 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
673 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
680 if (check_mode(t, cmd) == EINVAL) {
682 if (analog_ops->standby)
683 analog_ops->standby(&t->fe);
689 #define switch_v4l2() if (!t->using_v4l2) \
690 tuner_dbg("switching to v4l2\n"); \
693 static inline int check_v4l2(struct tuner *t)
695 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
696 TV, v4l1 for radio), until that is fixed this code is disabled.
697 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
702 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
704 struct tuner *t = i2c_get_clientdata(client);
705 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
706 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
709 v4l_i2c_print_ioctl(client,cmd);
712 /* --- configuration --- */
713 case TUNER_SET_TYPE_ADDR:
714 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
715 ((struct tuner_setup *)arg)->type,
716 ((struct tuner_setup *)arg)->addr,
717 ((struct tuner_setup *)arg)->mode_mask,
718 ((struct tuner_setup *)arg)->config);
720 set_addr(client, (struct tuner_setup *)arg);
723 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
727 set_freq(client, t->radio_freq);
729 case TUNER_SET_STANDBY:
730 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
733 if (analog_ops->standby)
734 analog_ops->standby(&t->fe);
736 #ifdef CONFIG_VIDEO_V4L1
738 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
740 if (check_v4l2(t) == EINVAL)
743 /* Should be implemented, since bttv calls it */
744 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
748 static const v4l2_std_id map[] = {
749 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
750 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
751 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
752 [4 /* bttv */ ] = V4L2_STD_PAL_M,
753 [5 /* bttv */ ] = V4L2_STD_PAL_N,
754 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
756 struct video_channel *vc = arg;
758 if (check_v4l2(t) == EINVAL)
761 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
764 if (vc->norm < ARRAY_SIZE(map))
765 t->std = map[vc->norm];
768 set_tv_freq(client, t->tv_freq);
773 unsigned long *v = arg;
775 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
777 if (check_v4l2(t) == EINVAL)
780 set_freq(client, *v);
785 struct video_tuner *vt = arg;
787 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
789 if (check_v4l2(t) == EINVAL)
792 if (V4L2_TUNER_RADIO == t->mode) {
793 if (fe_tuner_ops->get_status) {
796 fe_tuner_ops->get_status(&t->fe, &tuner_status);
797 if (tuner_status & TUNER_STATUS_STEREO)
798 vt->flags |= VIDEO_TUNER_STEREO_ON;
800 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
802 if (analog_ops->is_stereo) {
803 if (analog_ops->is_stereo(&t->fe))
805 VIDEO_TUNER_STEREO_ON;
808 ~VIDEO_TUNER_STEREO_ON;
811 if (analog_ops->has_signal)
813 analog_ops->has_signal(&t->fe);
815 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
817 vt->rangelow = radio_range[0] * 16000;
818 vt->rangehigh = radio_range[1] * 16000;
821 vt->rangelow = tv_range[0] * 16;
822 vt->rangehigh = tv_range[1] * 16;
829 struct video_audio *va = arg;
831 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
833 if (check_v4l2(t) == EINVAL)
836 if (V4L2_TUNER_RADIO == t->mode) {
837 if (fe_tuner_ops->get_status) {
840 fe_tuner_ops->get_status(&t->fe, &tuner_status);
841 va->mode = (tuner_status & TUNER_STATUS_STEREO)
842 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
843 } else if (analog_ops->is_stereo)
844 va->mode = analog_ops->is_stereo(&t->fe)
845 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
850 case TUNER_SET_CONFIG:
852 struct v4l2_priv_tun_config *cfg = arg;
854 if (t->type != cfg->tuner)
857 if (analog_ops->set_config) {
858 tuner_warn("Tuner frontend module has no way to "
863 analog_ops->set_config(&t->fe, cfg->priv);
866 /* --- v4l ioctls --- */
867 /* take care: bttv does userspace copying, we'll get a
868 kernel pointer here... */
871 v4l2_std_id *id = arg;
873 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
882 set_freq(client, t->tv_freq);
885 case VIDIOC_S_FREQUENCY:
887 struct v4l2_frequency *f = arg;
889 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
893 set_freq(client,f->frequency);
897 case VIDIOC_G_FREQUENCY:
899 struct v4l2_frequency *f = arg;
901 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
905 if (fe_tuner_ops->get_frequency) {
908 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
909 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
910 (abs_freq * 2 + 125/2) / 125 :
911 (abs_freq + 62500/2) / 62500;
914 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
915 t->radio_freq : t->tv_freq;
920 struct v4l2_tuner *tuner = arg;
922 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
926 tuner->type = t->mode;
927 if (analog_ops->get_afc)
928 tuner->afc = analog_ops->get_afc(&t->fe);
929 if (t->mode == V4L2_TUNER_ANALOG_TV)
930 tuner->capability |= V4L2_TUNER_CAP_NORM;
931 if (t->mode != V4L2_TUNER_RADIO) {
932 tuner->rangelow = tv_range[0] * 16;
933 tuner->rangehigh = tv_range[1] * 16;
939 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
940 if (fe_tuner_ops->get_status) {
943 fe_tuner_ops->get_status(&t->fe, &tuner_status);
945 (tuner_status & TUNER_STATUS_STEREO) ?
946 V4L2_TUNER_SUB_STEREO :
949 if (analog_ops->is_stereo) {
951 analog_ops->is_stereo(&t->fe) ?
952 V4L2_TUNER_SUB_STEREO :
956 if (analog_ops->has_signal)
957 tuner->signal = analog_ops->has_signal(&t->fe);
959 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
960 tuner->audmode = t->audmode;
961 tuner->rangelow = radio_range[0] * 16000;
962 tuner->rangehigh = radio_range[1] * 16000;
967 struct v4l2_tuner *tuner = arg;
969 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
974 /* do nothing unless we're a radio tuner */
975 if (t->mode != V4L2_TUNER_RADIO)
977 t->audmode = tuner->audmode;
978 set_radio_freq(client, t->radio_freq);
981 case VIDIOC_LOG_STATUS:
982 if (analog_ops->tuner_status)
983 analog_ops->tuner_status(&t->fe);
990 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
992 struct tuner *t = i2c_get_clientdata(c);
994 tuner_dbg("suspend\n");
995 /* FIXME: power down ??? */
999 static int tuner_resume(struct i2c_client *c)
1001 struct tuner *t = i2c_get_clientdata(c);
1003 tuner_dbg("resume\n");
1004 if (V4L2_TUNER_RADIO == t->mode) {
1006 set_freq(c, t->radio_freq);
1009 set_freq(c, t->tv_freq);
1014 /* ---------------------------------------------------------------------- */
1016 LIST_HEAD(tuner_list);
1018 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1019 Note that when this function is called from tuner_probe you can be
1020 certain no other devices will be added/deleted at the same time, I2C
1021 core protects against that. */
1022 static void tuner_lookup(struct i2c_adapter *adap,
1023 struct tuner **radio, struct tuner **tv)
1030 list_for_each_entry(pos, &tuner_list, list) {
1033 if (pos->i2c->adapter != adap ||
1034 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1037 mode_mask = pos->mode_mask & ~T_STANDBY;
1038 if (*radio == NULL && mode_mask == T_RADIO)
1040 /* Note: currently TDA9887 is the only demod-only
1041 device. If other devices appear then we need to
1042 make this test more general. */
1043 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1044 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1049 /* During client attach, set_type is called by adapter's attach_inform callback.
1050 set_type must then be completed by tuner_probe.
1052 static int tuner_probe(struct i2c_client *client)
1055 struct tuner *radio;
1058 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1062 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1063 i2c_set_clientdata(client, t);
1065 t->audmode = V4L2_TUNER_MODE_STEREO;
1066 t->mode_mask = T_UNINITIALIZED;
1069 unsigned char buffer[16];
1072 memset(buffer, 0, sizeof(buffer));
1073 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1074 tuner_info("I2C RECV = ");
1075 for (i = 0; i < rc; i++)
1076 printk(KERN_CONT "%02x ", buffer[i]);
1079 /* HACK: This test was added to avoid tuner to probe tda9840 and
1080 tea6415c on the MXB card */
1081 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1086 /* autodetection code based on the i2c addr */
1087 if (!no_autodetect) {
1088 switch (client->addr) {
1090 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1092 t->type = TUNER_TEA5761;
1093 t->mode_mask = T_RADIO;
1094 t->mode = T_STANDBY;
1095 /* Sets freq to FM range */
1096 t->radio_freq = 87.5 * 16000;
1097 tuner_lookup(t->i2c->adapter, &radio, &tv);
1099 tv->mode_mask &= ~T_RADIO;
1101 goto register_client;
1108 /* If chip is not tda8290, don't register.
1109 since it can be tda9887*/
1110 if (tda829x_probe(t->i2c->adapter,
1111 t->i2c->addr) == 0) {
1112 tuner_dbg("tda829x detected\n");
1114 /* Default is being tda9887 */
1115 t->type = TUNER_TDA9887;
1116 t->mode_mask = T_RADIO | T_ANALOG_TV |
1118 t->mode = T_STANDBY;
1119 goto register_client;
1123 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1125 t->type = TUNER_TEA5767;
1126 t->mode_mask = T_RADIO;
1127 t->mode = T_STANDBY;
1128 /* Sets freq to FM range */
1129 t->radio_freq = 87.5 * 16000;
1130 tuner_lookup(t->i2c->adapter, &radio, &tv);
1132 tv->mode_mask &= ~T_RADIO;
1134 goto register_client;
1140 /* Initializes only the first TV tuner on this adapter. Why only the
1141 first? Because there are some devices (notably the ones with TI
1142 tuners) that have more than one i2c address for the *same* device.
1143 Experience shows that, except for just one case, the first
1144 address is the right one. The exception is a Russian tuner
1145 (ACORP_Y878F). So, the desired behavior is just to enable the
1146 first found TV tuner. */
1147 tuner_lookup(t->i2c->adapter, &radio, &tv);
1149 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1151 t->mode_mask |= T_RADIO;
1152 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1153 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1154 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1157 /* Should be just before return */
1159 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1160 client->adapter->name);
1162 /* Sets a default mode */
1163 if (t->mode_mask & T_ANALOG_TV) {
1164 t->mode = V4L2_TUNER_ANALOG_TV;
1165 } else if (t->mode_mask & T_RADIO) {
1166 t->mode = V4L2_TUNER_RADIO;
1168 t->mode = V4L2_TUNER_DIGITAL_TV;
1170 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1171 list_add_tail(&t->list, &tuner_list);
1175 static int tuner_legacy_probe(struct i2c_adapter *adap)
1178 normal_i2c[0] = addr;
1179 normal_i2c[1] = I2C_CLIENT_END;
1182 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1185 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1186 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1187 * and an RTC at 0x6f which can get corrupted if probed.
1189 if ((adap->id == I2C_HW_B_CX2388x) ||
1190 (adap->id == I2C_HW_B_CX23885)) {
1193 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1195 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1196 ignore[i+0] = adap->nr;
1198 ignore[i+2] = adap->nr;
1200 ignore[i+4] = I2C_CLIENT_END;
1202 printk(KERN_WARNING "tuner: "
1203 "too many options specified "
1204 "in i2c probe ignore list!\n");
1209 static int tuner_remove(struct i2c_client *client)
1211 struct tuner *t = i2c_get_clientdata(client);
1212 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1214 if (analog_ops->release)
1215 analog_ops->release(&t->fe);
1222 /* ----------------------------------------------------------------------- */
1224 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1226 .driverid = I2C_DRIVERID_TUNER,
1227 .command = tuner_command,
1228 .probe = tuner_probe,
1229 .remove = tuner_remove,
1230 .suspend = tuner_suspend,
1231 .resume = tuner_resume,
1232 .legacy_probe = tuner_legacy_probe,
1237 * Overrides for Emacs so that we follow Linus's tabbing style.
1238 * ---------------------------------------------------------------------------