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 void attach_tda829x(struct tuner *t)
322 struct tda829x_config cfg = {
323 .lna_cfg = t->config,
324 .tuner_callback = t->tuner_callback,
326 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
329 static struct xc5000_config xc5000_cfg;
331 static void set_type(struct i2c_client *c, unsigned int type,
332 unsigned int new_mode_mask, unsigned int new_config,
333 int (*tuner_callback) (void *dev, int command,int arg))
335 struct tuner *t = i2c_get_clientdata(c);
336 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
337 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
338 unsigned char buffer[4];
340 if (type == UNSET || type == TUNER_ABSENT) {
341 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
346 t->config = new_config;
347 if (tuner_callback != NULL) {
348 tuner_dbg("defining GPIO callback\n");
349 t->tuner_callback = tuner_callback;
352 if (t->mode == T_UNINITIALIZED) {
353 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
358 /* discard private data, in case set_type() was previously called */
359 if (analog_ops->release)
360 analog_ops->release(&t->fe);
364 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
366 case TUNER_PHILIPS_TDA8290:
372 if (!tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
374 t->mode_mask = T_RADIO;
377 if (!tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr))
379 t->mode_mask = T_RADIO;
381 case TUNER_PHILIPS_FMD1216ME_MK3:
386 i2c_master_send(c, buffer, 4);
390 i2c_master_send(c, buffer, 4);
391 if (!simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr,
395 case TUNER_PHILIPS_TD1316:
400 i2c_master_send(c,buffer,4);
401 if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
402 t->i2c->addr, t->type))
407 struct xc2028_config cfg = {
408 .i2c_adap = t->i2c->adapter,
409 .i2c_addr = t->i2c->addr,
410 .callback = t->tuner_callback,
412 if (!xc2028_attach(&t->fe, &cfg))
417 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
421 struct dvb_tuner_ops *xc_tuner_ops;
423 xc5000_cfg.i2c_address = t->i2c->addr;
424 xc5000_cfg.if_khz = 5380;
425 xc5000_cfg.priv = c->adapter->algo_data;
426 xc5000_cfg.tuner_callback = t->tuner_callback;
427 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg))
430 xc_tuner_ops = &t->fe.ops.tuner_ops;
431 if (xc_tuner_ops->init)
432 xc_tuner_ops->init(&t->fe);
436 if (!simple_tuner_attach(&t->fe, t->i2c->adapter,
437 t->i2c->addr, t->type))
443 if ((NULL == analog_ops->set_params) &&
444 (fe_tuner_ops->set_analog_params)) {
445 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
446 sizeof(t->i2c->name));
448 t->fe.analog_demod_priv = t;
449 memcpy(analog_ops, &tuner_core_ops,
450 sizeof(struct analog_demod_ops));
452 strlcpy(t->i2c->name, analog_ops->info.name,
453 sizeof(t->i2c->name));
456 tuner_dbg("type set to %s\n", t->i2c->name);
458 if (t->mode_mask == T_UNINITIALIZED)
459 t->mode_mask = new_mode_mask;
461 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
462 trying to set a frequency here will just fail
463 FIXME: better to move set_freq to the tuner code. This is needed
464 on analog tuners for PLL to properly work
466 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
467 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
468 t->radio_freq : t->tv_freq);
470 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
471 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
473 tuner_i2c_address_check(t);
477 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
478 t->type = TUNER_ABSENT;
479 t->mode_mask = T_UNINITIALIZED;
485 * This function apply tuner config to tuner specified
486 * by tun_setup structure. I addr is unset, then admin status
487 * and tun addr status is more precise then current status,
488 * it's applied. Otherwise status and type are applied only to
489 * tuner with exactly the same addr.
492 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
494 struct tuner *t = i2c_get_clientdata(c);
496 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
497 (t->mode_mask & tun_setup->mode_mask))) ||
498 (tun_setup->addr == c->addr)) {
499 set_type(c, tun_setup->type, tun_setup->mode_mask,
500 tun_setup->config, tun_setup->tuner_callback);
502 tuner_dbg("set addr discarded for type %i, mask %x. "
503 "Asked to change tuner at addr 0x%02x, with mask %x\n",
504 t->type, t->mode_mask,
505 tun_setup->addr, tun_setup->mode_mask);
508 static inline int check_mode(struct tuner *t, char *cmd)
510 if ((1 << t->mode & t->mode_mask) == 0) {
515 case V4L2_TUNER_RADIO:
516 tuner_dbg("Cmd %s accepted for radio\n", cmd);
518 case V4L2_TUNER_ANALOG_TV:
519 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
521 case V4L2_TUNER_DIGITAL_TV:
522 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
528 /* get more precise norm info from insmod option */
529 static int tuner_fixup_std(struct tuner *t)
531 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
534 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
535 t->std = V4L2_STD_PAL_60;
541 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
542 t->std = V4L2_STD_PAL_BG;
546 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
547 t->std = V4L2_STD_PAL_I;
553 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
554 t->std = V4L2_STD_PAL_DK;
558 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
559 t->std = V4L2_STD_PAL_M;
563 if (pal[1] == 'c' || pal[1] == 'C') {
564 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
565 t->std = V4L2_STD_PAL_Nc;
567 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
568 t->std = V4L2_STD_PAL_N;
572 /* default parameter, do nothing */
575 tuner_warn ("pal= argument not recognised\n");
579 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
587 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
588 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
594 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
595 t->std = V4L2_STD_SECAM_DK;
599 if ((secam[1]=='C')||(secam[1]=='c')) {
600 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
601 t->std = V4L2_STD_SECAM_LC;
603 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
604 t->std = V4L2_STD_SECAM_L;
608 /* default parameter, do nothing */
611 tuner_warn ("secam= argument not recognised\n");
616 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
620 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
621 t->std = V4L2_STD_NTSC_M;
625 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
626 t->std = V4L2_STD_NTSC_M_JP;
630 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
631 t->std = V4L2_STD_NTSC_M_KR;
634 /* default parameter, do nothing */
637 tuner_info("ntsc= argument not recognised\n");
644 static void tuner_status(struct dvb_frontend *fe)
646 struct tuner *t = fe->analog_demod_priv;
647 unsigned long freq, freq_fraction;
648 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
649 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
653 case V4L2_TUNER_RADIO: p = "radio"; break;
654 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
655 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
656 default: p = "undefined"; break;
658 if (t->mode == V4L2_TUNER_RADIO) {
659 freq = t->radio_freq / 16000;
660 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
662 freq = t->tv_freq / 16;
663 freq_fraction = (t->tv_freq % 16) * 100 / 16;
665 tuner_info("Tuner mode: %s\n", p);
666 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
667 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
668 if (t->mode != V4L2_TUNER_RADIO)
670 if (fe_tuner_ops->get_status) {
673 fe_tuner_ops->get_status(&t->fe, &tuner_status);
674 if (tuner_status & TUNER_STATUS_LOCKED)
675 tuner_info("Tuner is locked.\n");
676 if (tuner_status & TUNER_STATUS_STEREO)
677 tuner_info("Stereo: yes\n");
679 if (analog_ops->has_signal)
680 tuner_info("Signal strength: %d\n",
681 analog_ops->has_signal(fe));
682 if (analog_ops->is_stereo)
683 tuner_info("Stereo: %s\n",
684 analog_ops->is_stereo(fe) ? "yes" : "no");
687 /* ---------------------------------------------------------------------- */
690 * Switch tuner to other mode. If tuner support both tv and radio,
691 * set another frequency to some value (This is needed for some pal
692 * tuners to avoid locking). Otherwise, just put second tuner in
696 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
698 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
705 if (check_mode(t, cmd) == EINVAL) {
707 if (analog_ops->standby)
708 analog_ops->standby(&t->fe);
714 #define switch_v4l2() if (!t->using_v4l2) \
715 tuner_dbg("switching to v4l2\n"); \
718 static inline int check_v4l2(struct tuner *t)
720 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
721 TV, v4l1 for radio), until that is fixed this code is disabled.
722 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
727 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
729 struct tuner *t = i2c_get_clientdata(client);
730 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
731 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
733 if (tuner_debug > 1) {
734 v4l_i2c_print_ioctl(client,cmd);
739 /* --- configuration --- */
740 case TUNER_SET_TYPE_ADDR:
741 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
742 ((struct tuner_setup *)arg)->type,
743 ((struct tuner_setup *)arg)->addr,
744 ((struct tuner_setup *)arg)->mode_mask,
745 ((struct tuner_setup *)arg)->config);
747 set_addr(client, (struct tuner_setup *)arg);
750 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
754 set_freq(client, t->radio_freq);
756 case TUNER_SET_STANDBY:
757 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
760 if (analog_ops->standby)
761 analog_ops->standby(&t->fe);
763 #ifdef CONFIG_VIDEO_ALLOW_V4L1
765 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
767 if (check_v4l2(t) == EINVAL)
770 /* Should be implemented, since bttv calls it */
771 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
775 static const v4l2_std_id map[] = {
776 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
777 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
778 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
779 [4 /* bttv */ ] = V4L2_STD_PAL_M,
780 [5 /* bttv */ ] = V4L2_STD_PAL_N,
781 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
783 struct video_channel *vc = arg;
785 if (check_v4l2(t) == EINVAL)
788 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
791 if (vc->norm < ARRAY_SIZE(map))
792 t->std = map[vc->norm];
795 set_tv_freq(client, t->tv_freq);
800 unsigned long *v = arg;
802 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
804 if (check_v4l2(t) == EINVAL)
807 set_freq(client, *v);
812 struct video_tuner *vt = arg;
814 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
816 if (check_v4l2(t) == EINVAL)
819 if (V4L2_TUNER_RADIO == t->mode) {
820 if (fe_tuner_ops->get_status) {
823 fe_tuner_ops->get_status(&t->fe, &tuner_status);
824 if (tuner_status & TUNER_STATUS_STEREO)
825 vt->flags |= VIDEO_TUNER_STEREO_ON;
827 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
829 if (analog_ops->is_stereo) {
830 if (analog_ops->is_stereo(&t->fe))
832 VIDEO_TUNER_STEREO_ON;
835 ~VIDEO_TUNER_STEREO_ON;
838 if (analog_ops->has_signal)
840 analog_ops->has_signal(&t->fe);
842 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
844 vt->rangelow = radio_range[0] * 16000;
845 vt->rangehigh = radio_range[1] * 16000;
848 vt->rangelow = tv_range[0] * 16;
849 vt->rangehigh = tv_range[1] * 16;
856 struct video_audio *va = arg;
858 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
860 if (check_v4l2(t) == EINVAL)
863 if (V4L2_TUNER_RADIO == t->mode) {
864 if (fe_tuner_ops->get_status) {
867 fe_tuner_ops->get_status(&t->fe, &tuner_status);
868 va->mode = (tuner_status & TUNER_STATUS_STEREO)
869 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
870 } else if (analog_ops->is_stereo)
871 va->mode = analog_ops->is_stereo(&t->fe)
872 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
877 case TUNER_SET_CONFIG:
879 struct v4l2_priv_tun_config *cfg = arg;
881 if (t->type != cfg->tuner)
884 if (analog_ops->set_config) {
885 analog_ops->set_config(&t->fe, cfg->priv);
889 tuner_dbg("Tuner frontend module has no way to set config\n");
892 /* --- v4l ioctls --- */
893 /* take care: bttv does userspace copying, we'll get a
894 kernel pointer here... */
897 v4l2_std_id *id = arg;
899 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
908 set_freq(client, t->tv_freq);
911 case VIDIOC_S_FREQUENCY:
913 struct v4l2_frequency *f = arg;
915 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
919 set_freq(client,f->frequency);
923 case VIDIOC_G_FREQUENCY:
925 struct v4l2_frequency *f = arg;
927 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
931 if (fe_tuner_ops->get_frequency) {
934 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
935 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
936 (abs_freq * 2 + 125/2) / 125 :
937 (abs_freq + 62500/2) / 62500;
940 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
941 t->radio_freq : t->tv_freq;
946 struct v4l2_tuner *tuner = arg;
948 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
952 tuner->type = t->mode;
953 if (analog_ops->get_afc)
954 tuner->afc = analog_ops->get_afc(&t->fe);
955 if (t->mode == V4L2_TUNER_ANALOG_TV)
956 tuner->capability |= V4L2_TUNER_CAP_NORM;
957 if (t->mode != V4L2_TUNER_RADIO) {
958 tuner->rangelow = tv_range[0] * 16;
959 tuner->rangehigh = tv_range[1] * 16;
965 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
966 if (fe_tuner_ops->get_status) {
969 fe_tuner_ops->get_status(&t->fe, &tuner_status);
971 (tuner_status & TUNER_STATUS_STEREO) ?
972 V4L2_TUNER_SUB_STEREO :
975 if (analog_ops->is_stereo) {
977 analog_ops->is_stereo(&t->fe) ?
978 V4L2_TUNER_SUB_STEREO :
982 if (analog_ops->has_signal)
983 tuner->signal = analog_ops->has_signal(&t->fe);
985 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
986 tuner->audmode = t->audmode;
987 tuner->rangelow = radio_range[0] * 16000;
988 tuner->rangehigh = radio_range[1] * 16000;
993 struct v4l2_tuner *tuner = arg;
995 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1000 /* do nothing unless we're a radio tuner */
1001 if (t->mode != V4L2_TUNER_RADIO)
1003 t->audmode = tuner->audmode;
1004 set_radio_freq(client, t->radio_freq);
1007 case VIDIOC_LOG_STATUS:
1008 if (analog_ops->tuner_status)
1009 analog_ops->tuner_status(&t->fe);
1016 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1018 struct tuner *t = i2c_get_clientdata(c);
1020 tuner_dbg("suspend\n");
1021 /* FIXME: power down ??? */
1025 static int tuner_resume(struct i2c_client *c)
1027 struct tuner *t = i2c_get_clientdata(c);
1029 tuner_dbg("resume\n");
1030 if (V4L2_TUNER_RADIO == t->mode) {
1032 set_freq(c, t->radio_freq);
1035 set_freq(c, t->tv_freq);
1040 /* ---------------------------------------------------------------------- */
1042 static LIST_HEAD(tuner_list);
1044 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1045 Note that when this function is called from tuner_probe you can be
1046 certain no other devices will be added/deleted at the same time, I2C
1047 core protects against that. */
1048 static void tuner_lookup(struct i2c_adapter *adap,
1049 struct tuner **radio, struct tuner **tv)
1056 list_for_each_entry(pos, &tuner_list, list) {
1059 if (pos->i2c->adapter != adap ||
1060 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1063 mode_mask = pos->mode_mask & ~T_STANDBY;
1064 if (*radio == NULL && mode_mask == T_RADIO)
1066 /* Note: currently TDA9887 is the only demod-only
1067 device. If other devices appear then we need to
1068 make this test more general. */
1069 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1070 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1075 /* During client attach, set_type is called by adapter's attach_inform callback.
1076 set_type must then be completed by tuner_probe.
1078 static int tuner_probe(struct i2c_client *client)
1081 struct tuner *radio;
1084 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1088 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1089 i2c_set_clientdata(client, t);
1091 t->audmode = V4L2_TUNER_MODE_STEREO;
1092 t->mode_mask = T_UNINITIALIZED;
1095 unsigned char buffer[16];
1098 memset(buffer, 0, sizeof(buffer));
1099 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1100 tuner_info("I2C RECV = ");
1101 for (i = 0; i < rc; i++)
1102 printk(KERN_CONT "%02x ", buffer[i]);
1105 /* HACK: This test was added to avoid tuner to probe tda9840 and
1106 tea6415c on the MXB card */
1107 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1112 /* autodetection code based on the i2c addr */
1113 if (!no_autodetect) {
1114 switch (client->addr) {
1116 if (tea5761_autodetection(t->i2c->adapter,
1117 t->i2c->addr) >= 0) {
1118 t->type = TUNER_TEA5761;
1119 t->mode_mask = T_RADIO;
1120 t->mode = T_STANDBY;
1121 /* Sets freq to FM range */
1122 t->radio_freq = 87.5 * 16000;
1123 tuner_lookup(t->i2c->adapter, &radio, &tv);
1125 tv->mode_mask &= ~T_RADIO;
1127 goto register_client;
1134 /* If chip is not tda8290, don't register.
1135 since it can be tda9887*/
1136 if (tda829x_probe(t->i2c->adapter,
1137 t->i2c->addr) == 0) {
1138 tuner_dbg("tda829x detected\n");
1140 /* Default is being tda9887 */
1141 t->type = TUNER_TDA9887;
1142 t->mode_mask = T_RADIO | T_ANALOG_TV |
1144 t->mode = T_STANDBY;
1145 goto register_client;
1149 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1151 t->type = TUNER_TEA5767;
1152 t->mode_mask = T_RADIO;
1153 t->mode = T_STANDBY;
1154 /* Sets freq to FM range */
1155 t->radio_freq = 87.5 * 16000;
1156 tuner_lookup(t->i2c->adapter, &radio, &tv);
1158 tv->mode_mask &= ~T_RADIO;
1160 goto register_client;
1166 /* Initializes only the first TV tuner on this adapter. Why only the
1167 first? Because there are some devices (notably the ones with TI
1168 tuners) that have more than one i2c address for the *same* device.
1169 Experience shows that, except for just one case, the first
1170 address is the right one. The exception is a Russian tuner
1171 (ACORP_Y878F). So, the desired behavior is just to enable the
1172 first found TV tuner. */
1173 tuner_lookup(t->i2c->adapter, &radio, &tv);
1175 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1177 t->mode_mask |= T_RADIO;
1178 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1179 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1180 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1183 /* Should be just before return */
1185 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1186 client->adapter->name);
1188 /* Sets a default mode */
1189 if (t->mode_mask & T_ANALOG_TV) {
1190 t->mode = V4L2_TUNER_ANALOG_TV;
1191 } else if (t->mode_mask & T_RADIO) {
1192 t->mode = V4L2_TUNER_RADIO;
1194 t->mode = V4L2_TUNER_DIGITAL_TV;
1196 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1197 list_add_tail(&t->list, &tuner_list);
1201 static int tuner_legacy_probe(struct i2c_adapter *adap)
1204 normal_i2c[0] = addr;
1205 normal_i2c[1] = I2C_CLIENT_END;
1208 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1211 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1212 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1213 * and an RTC at 0x6f which can get corrupted if probed.
1215 if ((adap->id == I2C_HW_B_CX2388x) ||
1216 (adap->id == I2C_HW_B_CX23885)) {
1219 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1221 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1222 ignore[i+0] = adap->nr;
1224 ignore[i+2] = adap->nr;
1226 ignore[i+4] = I2C_CLIENT_END;
1228 printk(KERN_WARNING "tuner: "
1229 "too many options specified "
1230 "in i2c probe ignore list!\n");
1235 static int tuner_remove(struct i2c_client *client)
1237 struct tuner *t = i2c_get_clientdata(client);
1238 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1240 if (analog_ops->release)
1241 analog_ops->release(&t->fe);
1248 /* ----------------------------------------------------------------------- */
1250 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1252 .driverid = I2C_DRIVERID_TUNER,
1253 .command = tuner_command,
1254 .probe = tuner_probe,
1255 .remove = tuner_remove,
1256 .suspend = tuner_suspend,
1257 .resume = tuner_resume,
1258 .legacy_probe = tuner_legacy_probe,
1263 * Overrides for Emacs so that we follow Linus's tabbing style.
1264 * ---------------------------------------------------------------------------