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"
34 #define PREFIX t->i2c->driver->driver.name
38 struct dvb_frontend fe;
39 struct i2c_client *i2c;
40 struct list_head list;
41 unsigned int using_v4l2:1;
43 /* keep track of the current settings */
46 unsigned int radio_freq;
50 unsigned int mode_mask; /* Combination of allowable modes */
52 unsigned int type; /* chip type id */
54 int (*tuner_callback) (void *dev, int command, int arg);
57 /* standard i2c insmod options */
58 static unsigned short normal_i2c[] = {
59 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
62 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
63 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
64 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
70 /* insmod options used at init time => read/only */
71 static unsigned int addr;
72 static unsigned int no_autodetect;
73 static unsigned int show_i2c;
75 /* insmod options used at runtime => read/write */
76 static int tuner_debug;
78 #define tuner_warn(fmt, arg...) do { \
79 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
80 i2c_adapter_id(t->i2c->adapter), \
81 t->i2c->addr, ##arg); \
84 #define tuner_info(fmt, arg...) do { \
85 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
86 i2c_adapter_id(t->i2c->adapter), \
87 t->i2c->addr, ##arg); \
90 #define tuner_err(fmt, arg...) do { \
91 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
92 i2c_adapter_id(t->i2c->adapter), \
93 t->i2c->addr, ##arg); \
96 #define tuner_dbg(fmt, arg...) do { \
98 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
99 i2c_adapter_id(t->i2c->adapter), \
100 t->i2c->addr, ##arg); \
103 /* ------------------------------------------------------------------------ */
105 static unsigned int tv_range[2] = { 44, 958 };
106 static unsigned int radio_range[2] = { 65, 108 };
108 static char pal[] = "--";
109 static char secam[] = "--";
110 static char ntsc[] = "-";
113 module_param(addr, int, 0444);
114 module_param(no_autodetect, int, 0444);
115 module_param(show_i2c, int, 0444);
116 module_param_named(debug,tuner_debug, int, 0644);
117 module_param_string(pal, pal, sizeof(pal), 0644);
118 module_param_string(secam, secam, sizeof(secam), 0644);
119 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
120 module_param_array(tv_range, int, NULL, 0644);
121 module_param_array(radio_range, int, NULL, 0644);
123 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
124 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
125 MODULE_LICENSE("GPL");
127 /* ---------------------------------------------------------------------- */
129 static void fe_set_params(struct dvb_frontend *fe,
130 struct analog_parameters *params)
132 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
133 struct tuner *t = fe->analog_demod_priv;
135 if (NULL == fe_tuner_ops->set_analog_params) {
136 tuner_warn("Tuner frontend module has no way to set freq\n");
139 fe_tuner_ops->set_analog_params(fe, params);
142 static void fe_release(struct dvb_frontend *fe)
144 if (fe->ops.tuner_ops.release)
145 fe->ops.tuner_ops.release(fe);
147 /* DO NOT kfree(fe->analog_demod_priv)
149 * If we are in this function, analog_demod_priv contains a pointer
150 * to struct tuner *t. This will be kfree'd in tuner_detach().
152 * Otherwise, fe->ops.analog_demod_ops->release will
153 * handle the cleanup for analog demodulator modules.
155 fe->analog_demod_priv = NULL;
158 static void fe_standby(struct dvb_frontend *fe)
160 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
162 if (fe_tuner_ops->sleep)
163 fe_tuner_ops->sleep(fe);
166 static int fe_has_signal(struct dvb_frontend *fe)
170 if (fe->ops.tuner_ops.get_rf_strength)
171 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
176 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
178 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
179 struct tuner *t = fe->analog_demod_priv;
181 if (fe_tuner_ops->set_config)
182 return fe_tuner_ops->set_config(fe, priv_cfg);
184 tuner_warn("Tuner frontend module has no way to set config\n");
189 static void tuner_status(struct dvb_frontend *fe);
191 static struct analog_demod_ops tuner_core_ops = {
192 .set_params = fe_set_params,
193 .standby = fe_standby,
194 .release = fe_release,
195 .has_signal = fe_has_signal,
196 .set_config = fe_set_config,
197 .tuner_status = tuner_status
200 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
201 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
203 struct tuner *t = i2c_get_clientdata(c);
204 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
206 struct analog_parameters params = {
208 .audmode = t->audmode,
212 if (t->type == UNSET) {
213 tuner_warn ("tuner type not set\n");
216 if (NULL == analog_ops->set_params) {
217 tuner_warn ("Tuner has no way to set tv freq\n");
220 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
221 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
222 freq / 16, freq % 16 * 100 / 16, tv_range[0],
224 /* V4L2 spec: if the freq is not possible then the closest
225 possible value should be selected */
226 if (freq < tv_range[0] * 16)
227 freq = tv_range[0] * 16;
229 freq = tv_range[1] * 16;
231 params.frequency = freq;
233 analog_ops->set_params(&t->fe, ¶ms);
236 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
238 struct tuner *t = i2c_get_clientdata(c);
239 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
241 struct analog_parameters params = {
243 .audmode = t->audmode,
247 if (t->type == UNSET) {
248 tuner_warn ("tuner type not set\n");
251 if (NULL == analog_ops->set_params) {
252 tuner_warn ("tuner has no way to set radio frequency\n");
255 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
256 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
257 freq / 16000, freq % 16000 * 100 / 16000,
258 radio_range[0], radio_range[1]);
259 /* V4L2 spec: if the freq is not possible then the closest
260 possible value should be selected */
261 if (freq < radio_range[0] * 16000)
262 freq = radio_range[0] * 16000;
264 freq = radio_range[1] * 16000;
266 params.frequency = freq;
268 analog_ops->set_params(&t->fe, ¶ms);
271 static void set_freq(struct i2c_client *c, unsigned long freq)
273 struct tuner *t = i2c_get_clientdata(c);
276 case V4L2_TUNER_RADIO:
277 tuner_dbg("radio freq set to %lu.%02lu\n",
278 freq / 16000, freq % 16000 * 100 / 16000);
279 set_radio_freq(c, freq);
280 t->radio_freq = freq;
282 case V4L2_TUNER_ANALOG_TV:
283 case V4L2_TUNER_DIGITAL_TV:
284 tuner_dbg("tv freq set to %lu.%02lu\n",
285 freq / 16, freq % 16 * 100 / 16);
286 set_tv_freq(c, freq);
290 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
294 static void tuner_i2c_address_check(struct tuner *t)
296 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
297 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
300 /* We already know that the XC5000 can only be located at
301 * i2c address 0x61, 0x62, 0x63 or 0x64 */
302 if ((t->type == TUNER_XC5000) &&
303 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
306 tuner_warn("====================== WARNING! ======================\n");
307 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
308 tuner_warn("will soon be dropped. This message indicates that your\n");
309 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
310 t->i2c->name, t->i2c->addr);
311 tuner_warn("To ensure continued support for your device, please\n");
312 tuner_warn("send a copy of this message, along with full dmesg\n");
313 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
314 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
315 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
316 t->i2c->adapter->name, t->i2c->addr, t->type, t->i2c->name);
317 tuner_warn("====================== WARNING! ======================\n");
320 static inline void attach_simple_tuner(struct tuner *t)
322 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, t->type);
325 static void attach_tda829x(struct tuner *t)
327 struct tda829x_config cfg = {
328 .lna_cfg = &t->config,
329 .tuner_callback = t->tuner_callback,
331 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
334 static struct xc5000_config xc5000_cfg;
336 static void set_type(struct i2c_client *c, unsigned int type,
337 unsigned int new_mode_mask, unsigned int new_config,
338 int (*tuner_callback) (void *dev, int command,int arg))
340 struct tuner *t = i2c_get_clientdata(c);
341 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
342 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
343 unsigned char buffer[4];
345 if (type == UNSET || type == TUNER_ABSENT) {
346 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
351 t->config = new_config;
352 if (tuner_callback != NULL) {
353 tuner_dbg("defining GPIO callback\n");
354 t->tuner_callback = tuner_callback;
357 if (t->mode == T_UNINITIALIZED) {
358 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
363 /* discard private data, in case set_type() was previously called */
364 if (analog_ops->release)
365 analog_ops->release(&t->fe);
369 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
371 case TUNER_PHILIPS_TDA8290:
377 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
378 t->type = TUNER_ABSENT;
379 t->mode_mask = T_UNINITIALIZED;
382 t->mode_mask = T_RADIO;
385 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
386 t->type = TUNER_ABSENT;
387 t->mode_mask = T_UNINITIALIZED;
390 t->mode_mask = T_RADIO;
392 case TUNER_PHILIPS_FMD1216ME_MK3:
397 i2c_master_send(c, buffer, 4);
401 i2c_master_send(c, buffer, 4);
402 attach_simple_tuner(t);
404 case TUNER_PHILIPS_TD1316:
409 i2c_master_send(c,buffer,4);
410 attach_simple_tuner(t);
414 struct xc2028_config cfg = {
415 .i2c_adap = t->i2c->adapter,
416 .i2c_addr = t->i2c->addr,
417 .video_dev = c->adapter->algo_data,
418 .callback = t->tuner_callback,
420 if (!xc2028_attach(&t->fe, &cfg)) {
421 t->type = TUNER_ABSENT;
422 t->mode_mask = T_UNINITIALIZED;
428 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
431 xc5000_cfg.i2c_address = t->i2c->addr;
432 xc5000_cfg.if_khz = 5380;
433 xc5000_cfg.priv = c->adapter->algo_data;
434 xc5000_cfg.tuner_callback = t->tuner_callback;
435 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg)) {
436 t->type = TUNER_ABSENT;
437 t->mode_mask = T_UNINITIALIZED;
441 struct dvb_tuner_ops *xc_tuner_ops;
442 xc_tuner_ops = &t->fe.ops.tuner_ops;
443 if(xc_tuner_ops->init != NULL)
444 xc_tuner_ops->init(&t->fe);
448 attach_simple_tuner(t);
452 if ((NULL == analog_ops->set_params) &&
453 (fe_tuner_ops->set_analog_params)) {
454 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
455 sizeof(t->i2c->name));
457 t->fe.analog_demod_priv = t;
458 memcpy(analog_ops, &tuner_core_ops,
459 sizeof(struct analog_demod_ops));
461 strlcpy(t->i2c->name, analog_ops->info.name,
462 sizeof(t->i2c->name));
465 tuner_dbg("type set to %s\n", t->i2c->name);
467 if (t->mode_mask == T_UNINITIALIZED)
468 t->mode_mask = new_mode_mask;
470 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
471 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
472 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
474 tuner_i2c_address_check(t);
478 * This function apply tuner config to tuner specified
479 * by tun_setup structure. I addr is unset, then admin status
480 * and tun addr status is more precise then current status,
481 * it's applied. Otherwise status and type are applied only to
482 * tuner with exactly the same addr.
485 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
487 struct tuner *t = i2c_get_clientdata(c);
489 tuner_dbg("set addr for type %i\n", t->type);
491 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
492 (t->mode_mask & tun_setup->mode_mask))) ||
493 (tun_setup->addr == c->addr)) {
494 set_type(c, tun_setup->type, tun_setup->mode_mask,
495 tun_setup->config, tun_setup->tuner_callback);
499 static inline int check_mode(struct tuner *t, char *cmd)
501 if ((1 << t->mode & t->mode_mask) == 0) {
506 case V4L2_TUNER_RADIO:
507 tuner_dbg("Cmd %s accepted for radio\n", cmd);
509 case V4L2_TUNER_ANALOG_TV:
510 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
512 case V4L2_TUNER_DIGITAL_TV:
513 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
519 /* get more precise norm info from insmod option */
520 static int tuner_fixup_std(struct tuner *t)
522 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
525 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
526 t->std = V4L2_STD_PAL_60;
532 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
533 t->std = V4L2_STD_PAL_BG;
537 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
538 t->std = V4L2_STD_PAL_I;
544 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
545 t->std = V4L2_STD_PAL_DK;
549 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
550 t->std = V4L2_STD_PAL_M;
554 if (pal[1] == 'c' || pal[1] == 'C') {
555 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
556 t->std = V4L2_STD_PAL_Nc;
558 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
559 t->std = V4L2_STD_PAL_N;
563 /* default parameter, do nothing */
566 tuner_warn ("pal= argument not recognised\n");
570 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
578 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
579 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
585 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
586 t->std = V4L2_STD_SECAM_DK;
590 if ((secam[1]=='C')||(secam[1]=='c')) {
591 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
592 t->std = V4L2_STD_SECAM_LC;
594 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
595 t->std = V4L2_STD_SECAM_L;
599 /* default parameter, do nothing */
602 tuner_warn ("secam= argument not recognised\n");
607 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
611 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
612 t->std = V4L2_STD_NTSC_M;
616 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
617 t->std = V4L2_STD_NTSC_M_JP;
621 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
622 t->std = V4L2_STD_NTSC_M_KR;
625 /* default parameter, do nothing */
628 tuner_info("ntsc= argument not recognised\n");
635 static void tuner_status(struct dvb_frontend *fe)
637 struct tuner *t = fe->analog_demod_priv;
638 unsigned long freq, freq_fraction;
639 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
640 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
644 case V4L2_TUNER_RADIO: p = "radio"; break;
645 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
646 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
647 default: p = "undefined"; break;
649 if (t->mode == V4L2_TUNER_RADIO) {
650 freq = t->radio_freq / 16000;
651 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
653 freq = t->tv_freq / 16;
654 freq_fraction = (t->tv_freq % 16) * 100 / 16;
656 tuner_info("Tuner mode: %s\n", p);
657 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
658 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
659 if (t->mode != V4L2_TUNER_RADIO)
661 if (fe_tuner_ops->get_status) {
664 fe_tuner_ops->get_status(&t->fe, &tuner_status);
665 if (tuner_status & TUNER_STATUS_LOCKED)
666 tuner_info("Tuner is locked.\n");
667 if (tuner_status & TUNER_STATUS_STEREO)
668 tuner_info("Stereo: yes\n");
670 if (analog_ops->has_signal)
671 tuner_info("Signal strength: %d\n",
672 analog_ops->has_signal(fe));
673 if (analog_ops->is_stereo)
674 tuner_info("Stereo: %s\n",
675 analog_ops->is_stereo(fe) ? "yes" : "no");
678 /* ---------------------------------------------------------------------- */
681 * Switch tuner to other mode. If tuner support both tv and radio,
682 * set another frequency to some value (This is needed for some pal
683 * tuners to avoid locking). Otherwise, just put second tuner in
687 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
689 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
696 if (check_mode(t, cmd) == EINVAL) {
698 if (analog_ops->standby)
699 analog_ops->standby(&t->fe);
705 #define switch_v4l2() if (!t->using_v4l2) \
706 tuner_dbg("switching to v4l2\n"); \
709 static inline int check_v4l2(struct tuner *t)
711 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
712 TV, v4l1 for radio), until that is fixed this code is disabled.
713 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
718 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
720 struct tuner *t = i2c_get_clientdata(client);
721 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
722 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
725 v4l_i2c_print_ioctl(client,cmd);
728 /* --- configuration --- */
729 case TUNER_SET_TYPE_ADDR:
730 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
731 ((struct tuner_setup *)arg)->type,
732 ((struct tuner_setup *)arg)->addr,
733 ((struct tuner_setup *)arg)->mode_mask,
734 ((struct tuner_setup *)arg)->config);
736 set_addr(client, (struct tuner_setup *)arg);
739 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
743 set_freq(client, t->radio_freq);
745 case TUNER_SET_STANDBY:
746 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
749 if (analog_ops->standby)
750 analog_ops->standby(&t->fe);
752 #ifdef CONFIG_VIDEO_V4L1
754 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
756 if (check_v4l2(t) == EINVAL)
759 /* Should be implemented, since bttv calls it */
760 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
764 static const v4l2_std_id map[] = {
765 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
766 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
767 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
768 [4 /* bttv */ ] = V4L2_STD_PAL_M,
769 [5 /* bttv */ ] = V4L2_STD_PAL_N,
770 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
772 struct video_channel *vc = arg;
774 if (check_v4l2(t) == EINVAL)
777 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
780 if (vc->norm < ARRAY_SIZE(map))
781 t->std = map[vc->norm];
784 set_tv_freq(client, t->tv_freq);
789 unsigned long *v = arg;
791 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
793 if (check_v4l2(t) == EINVAL)
796 set_freq(client, *v);
801 struct video_tuner *vt = arg;
803 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
805 if (check_v4l2(t) == EINVAL)
808 if (V4L2_TUNER_RADIO == t->mode) {
809 if (fe_tuner_ops->get_status) {
812 fe_tuner_ops->get_status(&t->fe, &tuner_status);
813 if (tuner_status & TUNER_STATUS_STEREO)
814 vt->flags |= VIDEO_TUNER_STEREO_ON;
816 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
818 if (analog_ops->is_stereo) {
819 if (analog_ops->is_stereo(&t->fe))
821 VIDEO_TUNER_STEREO_ON;
824 ~VIDEO_TUNER_STEREO_ON;
827 if (analog_ops->has_signal)
829 analog_ops->has_signal(&t->fe);
831 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
833 vt->rangelow = radio_range[0] * 16000;
834 vt->rangehigh = radio_range[1] * 16000;
837 vt->rangelow = tv_range[0] * 16;
838 vt->rangehigh = tv_range[1] * 16;
845 struct video_audio *va = arg;
847 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
849 if (check_v4l2(t) == EINVAL)
852 if (V4L2_TUNER_RADIO == t->mode) {
853 if (fe_tuner_ops->get_status) {
856 fe_tuner_ops->get_status(&t->fe, &tuner_status);
857 va->mode = (tuner_status & TUNER_STATUS_STEREO)
858 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
859 } else if (analog_ops->is_stereo)
860 va->mode = analog_ops->is_stereo(&t->fe)
861 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
866 case TUNER_SET_CONFIG:
868 struct v4l2_priv_tun_config *cfg = arg;
870 if (t->type != cfg->tuner)
873 if (analog_ops->set_config) {
874 analog_ops->set_config(&t->fe, cfg->priv);
878 tuner_dbg("Tuner frontend module has no way to set config\n");
881 /* --- v4l ioctls --- */
882 /* take care: bttv does userspace copying, we'll get a
883 kernel pointer here... */
886 v4l2_std_id *id = arg;
888 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
897 set_freq(client, t->tv_freq);
900 case VIDIOC_S_FREQUENCY:
902 struct v4l2_frequency *f = arg;
904 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
908 set_freq(client,f->frequency);
912 case VIDIOC_G_FREQUENCY:
914 struct v4l2_frequency *f = arg;
916 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
920 if (fe_tuner_ops->get_frequency) {
923 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
924 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
925 (abs_freq * 2 + 125/2) / 125 :
926 (abs_freq + 62500/2) / 62500;
929 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
930 t->radio_freq : t->tv_freq;
935 struct v4l2_tuner *tuner = arg;
937 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
941 tuner->type = t->mode;
942 if (analog_ops->get_afc)
943 tuner->afc = analog_ops->get_afc(&t->fe);
944 if (t->mode == V4L2_TUNER_ANALOG_TV)
945 tuner->capability |= V4L2_TUNER_CAP_NORM;
946 if (t->mode != V4L2_TUNER_RADIO) {
947 tuner->rangelow = tv_range[0] * 16;
948 tuner->rangehigh = tv_range[1] * 16;
954 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
955 if (fe_tuner_ops->get_status) {
958 fe_tuner_ops->get_status(&t->fe, &tuner_status);
960 (tuner_status & TUNER_STATUS_STEREO) ?
961 V4L2_TUNER_SUB_STEREO :
964 if (analog_ops->is_stereo) {
966 analog_ops->is_stereo(&t->fe) ?
967 V4L2_TUNER_SUB_STEREO :
971 if (analog_ops->has_signal)
972 tuner->signal = analog_ops->has_signal(&t->fe);
974 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
975 tuner->audmode = t->audmode;
976 tuner->rangelow = radio_range[0] * 16000;
977 tuner->rangehigh = radio_range[1] * 16000;
982 struct v4l2_tuner *tuner = arg;
984 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
989 /* do nothing unless we're a radio tuner */
990 if (t->mode != V4L2_TUNER_RADIO)
992 t->audmode = tuner->audmode;
993 set_radio_freq(client, t->radio_freq);
996 case VIDIOC_LOG_STATUS:
997 if (analog_ops->tuner_status)
998 analog_ops->tuner_status(&t->fe);
1005 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1007 struct tuner *t = i2c_get_clientdata(c);
1009 tuner_dbg("suspend\n");
1010 /* FIXME: power down ??? */
1014 static int tuner_resume(struct i2c_client *c)
1016 struct tuner *t = i2c_get_clientdata(c);
1018 tuner_dbg("resume\n");
1019 if (V4L2_TUNER_RADIO == t->mode) {
1021 set_freq(c, t->radio_freq);
1024 set_freq(c, t->tv_freq);
1029 /* ---------------------------------------------------------------------- */
1031 static LIST_HEAD(tuner_list);
1033 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1034 Note that when this function is called from tuner_probe you can be
1035 certain no other devices will be added/deleted at the same time, I2C
1036 core protects against that. */
1037 static void tuner_lookup(struct i2c_adapter *adap,
1038 struct tuner **radio, struct tuner **tv)
1045 list_for_each_entry(pos, &tuner_list, list) {
1048 if (pos->i2c->adapter != adap ||
1049 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1052 mode_mask = pos->mode_mask & ~T_STANDBY;
1053 if (*radio == NULL && mode_mask == T_RADIO)
1055 /* Note: currently TDA9887 is the only demod-only
1056 device. If other devices appear then we need to
1057 make this test more general. */
1058 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1059 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1064 /* During client attach, set_type is called by adapter's attach_inform callback.
1065 set_type must then be completed by tuner_probe.
1067 static int tuner_probe(struct i2c_client *client)
1070 struct tuner *radio;
1073 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1077 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1078 i2c_set_clientdata(client, t);
1080 t->audmode = V4L2_TUNER_MODE_STEREO;
1081 t->mode_mask = T_UNINITIALIZED;
1084 unsigned char buffer[16];
1087 memset(buffer, 0, sizeof(buffer));
1088 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1089 tuner_info("I2C RECV = ");
1090 for (i = 0; i < rc; i++)
1091 printk(KERN_CONT "%02x ", buffer[i]);
1094 /* HACK: This test was added to avoid tuner to probe tda9840 and
1095 tea6415c on the MXB card */
1096 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1101 /* autodetection code based on the i2c addr */
1102 if (!no_autodetect) {
1103 switch (client->addr) {
1105 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1107 t->type = TUNER_TEA5761;
1108 t->mode_mask = T_RADIO;
1109 t->mode = T_STANDBY;
1110 /* Sets freq to FM range */
1111 t->radio_freq = 87.5 * 16000;
1112 tuner_lookup(t->i2c->adapter, &radio, &tv);
1114 tv->mode_mask &= ~T_RADIO;
1116 goto register_client;
1123 /* If chip is not tda8290, don't register.
1124 since it can be tda9887*/
1125 if (tda829x_probe(t->i2c->adapter,
1126 t->i2c->addr) == 0) {
1127 tuner_dbg("tda829x detected\n");
1129 /* Default is being tda9887 */
1130 t->type = TUNER_TDA9887;
1131 t->mode_mask = T_RADIO | T_ANALOG_TV |
1133 t->mode = T_STANDBY;
1134 goto register_client;
1138 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1140 t->type = TUNER_TEA5767;
1141 t->mode_mask = T_RADIO;
1142 t->mode = T_STANDBY;
1143 /* Sets freq to FM range */
1144 t->radio_freq = 87.5 * 16000;
1145 tuner_lookup(t->i2c->adapter, &radio, &tv);
1147 tv->mode_mask &= ~T_RADIO;
1149 goto register_client;
1155 /* Initializes only the first TV tuner on this adapter. Why only the
1156 first? Because there are some devices (notably the ones with TI
1157 tuners) that have more than one i2c address for the *same* device.
1158 Experience shows that, except for just one case, the first
1159 address is the right one. The exception is a Russian tuner
1160 (ACORP_Y878F). So, the desired behavior is just to enable the
1161 first found TV tuner. */
1162 tuner_lookup(t->i2c->adapter, &radio, &tv);
1164 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1166 t->mode_mask |= T_RADIO;
1167 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1168 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1169 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1172 /* Should be just before return */
1174 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1175 client->adapter->name);
1177 /* Sets a default mode */
1178 if (t->mode_mask & T_ANALOG_TV) {
1179 t->mode = V4L2_TUNER_ANALOG_TV;
1180 } else if (t->mode_mask & T_RADIO) {
1181 t->mode = V4L2_TUNER_RADIO;
1183 t->mode = V4L2_TUNER_DIGITAL_TV;
1185 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1186 list_add_tail(&t->list, &tuner_list);
1190 static int tuner_legacy_probe(struct i2c_adapter *adap)
1193 normal_i2c[0] = addr;
1194 normal_i2c[1] = I2C_CLIENT_END;
1197 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1200 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1201 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1202 * and an RTC at 0x6f which can get corrupted if probed.
1204 if ((adap->id == I2C_HW_B_CX2388x) ||
1205 (adap->id == I2C_HW_B_CX23885)) {
1208 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1210 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1211 ignore[i+0] = adap->nr;
1213 ignore[i+2] = adap->nr;
1215 ignore[i+4] = I2C_CLIENT_END;
1217 printk(KERN_WARNING "tuner: "
1218 "too many options specified "
1219 "in i2c probe ignore list!\n");
1224 static int tuner_remove(struct i2c_client *client)
1226 struct tuner *t = i2c_get_clientdata(client);
1227 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1229 if (analog_ops->release)
1230 analog_ops->release(&t->fe);
1237 /* ----------------------------------------------------------------------- */
1239 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1241 .driverid = I2C_DRIVERID_TUNER,
1242 .command = tuner_command,
1243 .probe = tuner_probe,
1244 .remove = tuner_remove,
1245 .suspend = tuner_suspend,
1246 .resume = tuner_resume,
1247 .legacy_probe = tuner_legacy_probe,
1252 * Overrides for Emacs so that we follow Linus's tabbing style.
1253 * ---------------------------------------------------------------------------