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 analog_ops->set_config(&t->fe, cfg->priv);
862 tuner_dbg("Tuner frontend module has no way to set config\n");
865 /* --- v4l ioctls --- */
866 /* take care: bttv does userspace copying, we'll get a
867 kernel pointer here... */
870 v4l2_std_id *id = arg;
872 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
881 set_freq(client, t->tv_freq);
884 case VIDIOC_S_FREQUENCY:
886 struct v4l2_frequency *f = arg;
888 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
892 set_freq(client,f->frequency);
896 case VIDIOC_G_FREQUENCY:
898 struct v4l2_frequency *f = arg;
900 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
904 if (fe_tuner_ops->get_frequency) {
907 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
908 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
909 (abs_freq * 2 + 125/2) / 125 :
910 (abs_freq + 62500/2) / 62500;
913 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
914 t->radio_freq : t->tv_freq;
919 struct v4l2_tuner *tuner = arg;
921 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
925 tuner->type = t->mode;
926 if (analog_ops->get_afc)
927 tuner->afc = analog_ops->get_afc(&t->fe);
928 if (t->mode == V4L2_TUNER_ANALOG_TV)
929 tuner->capability |= V4L2_TUNER_CAP_NORM;
930 if (t->mode != V4L2_TUNER_RADIO) {
931 tuner->rangelow = tv_range[0] * 16;
932 tuner->rangehigh = tv_range[1] * 16;
938 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
939 if (fe_tuner_ops->get_status) {
942 fe_tuner_ops->get_status(&t->fe, &tuner_status);
944 (tuner_status & TUNER_STATUS_STEREO) ?
945 V4L2_TUNER_SUB_STEREO :
948 if (analog_ops->is_stereo) {
950 analog_ops->is_stereo(&t->fe) ?
951 V4L2_TUNER_SUB_STEREO :
955 if (analog_ops->has_signal)
956 tuner->signal = analog_ops->has_signal(&t->fe);
958 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
959 tuner->audmode = t->audmode;
960 tuner->rangelow = radio_range[0] * 16000;
961 tuner->rangehigh = radio_range[1] * 16000;
966 struct v4l2_tuner *tuner = arg;
968 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
973 /* do nothing unless we're a radio tuner */
974 if (t->mode != V4L2_TUNER_RADIO)
976 t->audmode = tuner->audmode;
977 set_radio_freq(client, t->radio_freq);
980 case VIDIOC_LOG_STATUS:
981 if (analog_ops->tuner_status)
982 analog_ops->tuner_status(&t->fe);
989 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
991 struct tuner *t = i2c_get_clientdata(c);
993 tuner_dbg("suspend\n");
994 /* FIXME: power down ??? */
998 static int tuner_resume(struct i2c_client *c)
1000 struct tuner *t = i2c_get_clientdata(c);
1002 tuner_dbg("resume\n");
1003 if (V4L2_TUNER_RADIO == t->mode) {
1005 set_freq(c, t->radio_freq);
1008 set_freq(c, t->tv_freq);
1013 /* ---------------------------------------------------------------------- */
1015 LIST_HEAD(tuner_list);
1017 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1018 Note that when this function is called from tuner_probe you can be
1019 certain no other devices will be added/deleted at the same time, I2C
1020 core protects against that. */
1021 static void tuner_lookup(struct i2c_adapter *adap,
1022 struct tuner **radio, struct tuner **tv)
1029 list_for_each_entry(pos, &tuner_list, list) {
1032 if (pos->i2c->adapter != adap ||
1033 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1036 mode_mask = pos->mode_mask & ~T_STANDBY;
1037 if (*radio == NULL && mode_mask == T_RADIO)
1039 /* Note: currently TDA9887 is the only demod-only
1040 device. If other devices appear then we need to
1041 make this test more general. */
1042 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1043 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1048 /* During client attach, set_type is called by adapter's attach_inform callback.
1049 set_type must then be completed by tuner_probe.
1051 static int tuner_probe(struct i2c_client *client)
1054 struct tuner *radio;
1057 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1061 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1062 i2c_set_clientdata(client, t);
1064 t->audmode = V4L2_TUNER_MODE_STEREO;
1065 t->mode_mask = T_UNINITIALIZED;
1068 unsigned char buffer[16];
1071 memset(buffer, 0, sizeof(buffer));
1072 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1073 tuner_info("I2C RECV = ");
1074 for (i = 0; i < rc; i++)
1075 printk(KERN_CONT "%02x ", buffer[i]);
1078 /* HACK: This test was added to avoid tuner to probe tda9840 and
1079 tea6415c on the MXB card */
1080 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1085 /* autodetection code based on the i2c addr */
1086 if (!no_autodetect) {
1087 switch (client->addr) {
1089 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1091 t->type = TUNER_TEA5761;
1092 t->mode_mask = T_RADIO;
1093 t->mode = T_STANDBY;
1094 /* Sets freq to FM range */
1095 t->radio_freq = 87.5 * 16000;
1096 tuner_lookup(t->i2c->adapter, &radio, &tv);
1098 tv->mode_mask &= ~T_RADIO;
1100 goto register_client;
1107 /* If chip is not tda8290, don't register.
1108 since it can be tda9887*/
1109 if (tda829x_probe(t->i2c->adapter,
1110 t->i2c->addr) == 0) {
1111 tuner_dbg("tda829x detected\n");
1113 /* Default is being tda9887 */
1114 t->type = TUNER_TDA9887;
1115 t->mode_mask = T_RADIO | T_ANALOG_TV |
1117 t->mode = T_STANDBY;
1118 goto register_client;
1122 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1124 t->type = TUNER_TEA5767;
1125 t->mode_mask = T_RADIO;
1126 t->mode = T_STANDBY;
1127 /* Sets freq to FM range */
1128 t->radio_freq = 87.5 * 16000;
1129 tuner_lookup(t->i2c->adapter, &radio, &tv);
1131 tv->mode_mask &= ~T_RADIO;
1133 goto register_client;
1139 /* Initializes only the first TV tuner on this adapter. Why only the
1140 first? Because there are some devices (notably the ones with TI
1141 tuners) that have more than one i2c address for the *same* device.
1142 Experience shows that, except for just one case, the first
1143 address is the right one. The exception is a Russian tuner
1144 (ACORP_Y878F). So, the desired behavior is just to enable the
1145 first found TV tuner. */
1146 tuner_lookup(t->i2c->adapter, &radio, &tv);
1148 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1150 t->mode_mask |= T_RADIO;
1151 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1152 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1153 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1156 /* Should be just before return */
1158 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1159 client->adapter->name);
1161 /* Sets a default mode */
1162 if (t->mode_mask & T_ANALOG_TV) {
1163 t->mode = V4L2_TUNER_ANALOG_TV;
1164 } else if (t->mode_mask & T_RADIO) {
1165 t->mode = V4L2_TUNER_RADIO;
1167 t->mode = V4L2_TUNER_DIGITAL_TV;
1169 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1170 list_add_tail(&t->list, &tuner_list);
1174 static int tuner_legacy_probe(struct i2c_adapter *adap)
1177 normal_i2c[0] = addr;
1178 normal_i2c[1] = I2C_CLIENT_END;
1181 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1184 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1185 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1186 * and an RTC at 0x6f which can get corrupted if probed.
1188 if ((adap->id == I2C_HW_B_CX2388x) ||
1189 (adap->id == I2C_HW_B_CX23885)) {
1192 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1194 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1195 ignore[i+0] = adap->nr;
1197 ignore[i+2] = adap->nr;
1199 ignore[i+4] = I2C_CLIENT_END;
1201 printk(KERN_WARNING "tuner: "
1202 "too many options specified "
1203 "in i2c probe ignore list!\n");
1208 static int tuner_remove(struct i2c_client *client)
1210 struct tuner *t = i2c_get_clientdata(client);
1211 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1213 if (analog_ops->release)
1214 analog_ops->release(&t->fe);
1221 /* ----------------------------------------------------------------------- */
1223 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1225 .driverid = I2C_DRIVERID_TUNER,
1226 .command = tuner_command,
1227 .probe = tuner_probe,
1228 .remove = tuner_remove,
1229 .suspend = tuner_suspend,
1230 .resume = tuner_resume,
1231 .legacy_probe = tuner_legacy_probe,
1236 * Overrides for Emacs so that we follow Linus's tabbing style.
1237 * ---------------------------------------------------------------------------