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 "tuner-driver.h"
27 #include "tuner-xc2028.h"
28 #include "tuner-simple.h"
32 /* standard i2c insmod options */
33 static unsigned short normal_i2c[] = {
34 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
37 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
38 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
39 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
45 /* insmod options used at init time => read/only */
46 static unsigned int addr = 0;
47 static unsigned int no_autodetect = 0;
48 static unsigned int show_i2c = 0;
50 /* insmod options used at runtime => read/write */
53 static unsigned int tv_range[2] = { 44, 958 };
54 static unsigned int radio_range[2] = { 65, 108 };
56 static char pal[] = "--";
57 static char secam[] = "--";
58 static char ntsc[] = "-";
61 module_param(addr, int, 0444);
62 module_param(no_autodetect, int, 0444);
63 module_param(show_i2c, int, 0444);
64 module_param_named(debug,tuner_debug, int, 0644);
65 module_param_string(pal, pal, sizeof(pal), 0644);
66 module_param_string(secam, secam, sizeof(secam), 0644);
67 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
68 module_param_array(tv_range, int, NULL, 0644);
69 module_param_array(radio_range, int, NULL, 0644);
71 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
72 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
73 MODULE_LICENSE("GPL");
75 static struct i2c_driver driver;
76 static struct i2c_client client_template;
78 /* ---------------------------------------------------------------------- */
80 static void fe_set_freq(struct tuner *t, unsigned int freq)
82 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
84 struct analog_parameters params = {
87 .audmode = t->audmode,
91 if (NULL == fe_tuner_ops->set_analog_params) {
92 tuner_warn("Tuner frontend module has no way to set freq\n");
95 fe_tuner_ops->set_analog_params(&t->fe, ¶ms);
98 static void fe_release(struct tuner *t)
100 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
102 if (fe_tuner_ops->release)
103 fe_tuner_ops->release(&t->fe);
106 static void fe_standby(struct tuner *t)
108 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
110 if (fe_tuner_ops->sleep)
111 fe_tuner_ops->sleep(&t->fe);
114 static int fe_has_signal(struct tuner *t)
116 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
119 if (fe_tuner_ops->get_rf_strength)
120 fe_tuner_ops->get_rf_strength(&t->fe, &strength);
125 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
126 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
128 struct tuner *t = i2c_get_clientdata(c);
130 if (t->type == UNSET) {
131 tuner_warn ("tuner type not set\n");
134 if (NULL == t->ops.set_tv_freq) {
135 tuner_warn ("Tuner has no way to set tv freq\n");
138 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
139 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
140 freq / 16, freq % 16 * 100 / 16, tv_range[0],
142 /* V4L2 spec: if the freq is not possible then the closest
143 possible value should be selected */
144 if (freq < tv_range[0] * 16)
145 freq = tv_range[0] * 16;
147 freq = tv_range[1] * 16;
149 t->ops.set_tv_freq(t, freq);
152 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
154 struct tuner *t = i2c_get_clientdata(c);
156 if (t->type == UNSET) {
157 tuner_warn ("tuner type not set\n");
160 if (NULL == t->ops.set_radio_freq) {
161 tuner_warn ("tuner has no way to set radio frequency\n");
164 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
165 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
166 freq / 16000, freq % 16000 * 100 / 16000,
167 radio_range[0], radio_range[1]);
168 /* V4L2 spec: if the freq is not possible then the closest
169 possible value should be selected */
170 if (freq < radio_range[0] * 16000)
171 freq = radio_range[0] * 16000;
173 freq = radio_range[1] * 16000;
176 t->ops.set_radio_freq(t, freq);
179 static void set_freq(struct i2c_client *c, unsigned long freq)
181 struct tuner *t = i2c_get_clientdata(c);
184 case V4L2_TUNER_RADIO:
185 tuner_dbg("radio freq set to %lu.%02lu\n",
186 freq / 16000, freq % 16000 * 100 / 16000);
187 set_radio_freq(c, freq);
188 t->radio_freq = freq;
190 case V4L2_TUNER_ANALOG_TV:
191 case V4L2_TUNER_DIGITAL_TV:
192 tuner_dbg("tv freq set to %lu.%02lu\n",
193 freq / 16, freq % 16 * 100 / 16);
194 set_tv_freq(c, freq);
198 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
202 static void tuner_i2c_address_check(struct tuner *t)
204 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
205 ((t->i2c.addr < 0x64) || (t->i2c.addr > 0x6f)))
208 tuner_warn("====================== WARNING! ======================\n");
209 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
210 tuner_warn("will soon be dropped. This message indicates that your\n");
211 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
212 t->i2c.name, t->i2c.addr);
213 tuner_warn("To ensure continued support for your device, please\n");
214 tuner_warn("send a copy of this message, along with full dmesg\n");
215 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
216 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
217 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
218 t->i2c.adapter->name, t->i2c.addr, t->type,
219 tuners[t->type].name);
220 tuner_warn("====================== WARNING! ======================\n");
223 static void attach_simple_tuner(struct tuner *t)
225 struct simple_tuner_config cfg = {
227 .tun = &tuners[t->type]
229 simple_tuner_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
232 static void set_type(struct i2c_client *c, unsigned int type,
233 unsigned int new_mode_mask, unsigned int new_config,
234 int (*tuner_callback) (void *dev, int command,int arg))
236 struct tuner *t = i2c_get_clientdata(c);
237 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
238 unsigned char buffer[4];
240 if (type == UNSET || type == TUNER_ABSENT) {
241 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
245 if (type >= tuner_count) {
246 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
251 t->config = new_config;
252 if (tuner_callback != NULL) {
253 tuner_dbg("defining GPIO callback\n");
254 t->tuner_callback = tuner_callback;
257 /* This code detects calls by card attach_inform */
258 if (NULL == t->i2c.dev.driver) {
259 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
264 /* discard private data, in case set_type() was previously called */
274 microtune_attach(&t->fe, t->i2c.adapter, t->i2c.addr);
276 case TUNER_PHILIPS_TDA8290:
282 if (tea5767_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
283 t->type = TUNER_ABSENT;
284 t->mode_mask = T_UNINITIALIZED;
287 t->mode_mask = T_RADIO;
290 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
291 t->type = TUNER_ABSENT;
292 t->mode_mask = T_UNINITIALIZED;
295 t->mode_mask = T_RADIO;
297 case TUNER_PHILIPS_FMD1216ME_MK3:
302 i2c_master_send(c, buffer, 4);
306 i2c_master_send(c, buffer, 4);
307 attach_simple_tuner(t);
309 case TUNER_PHILIPS_TD1316:
314 i2c_master_send(c,buffer,4);
315 attach_simple_tuner(t);
319 int rc=xc2028_attach(&t->fe, t->i2c.adapter, t->i2c.addr,
320 &c->dev, c->adapter->algo_data,
323 t->type = TUNER_ABSENT;
324 t->mode_mask = T_UNINITIALIZED;
330 tda9887_tuner_init(t);
333 attach_simple_tuner(t);
337 if ((fe_tuner_ops->set_analog_params) &&
338 ((NULL == t->ops.set_tv_freq) && (NULL == t->ops.set_radio_freq))) {
339 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
341 t->ops.set_tv_freq = fe_set_freq;
342 t->ops.set_radio_freq = fe_set_freq;
343 t->ops.standby = fe_standby;
344 t->ops.release = fe_release;
345 t->ops.has_signal = fe_has_signal;
348 tuner_info("type set to %s\n", t->i2c.name);
350 if (t->mode_mask == T_UNINITIALIZED)
351 t->mode_mask = new_mode_mask;
353 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
354 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
355 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
357 tuner_i2c_address_check(t);
361 * This function apply tuner config to tuner specified
362 * by tun_setup structure. I addr is unset, then admin status
363 * and tun addr status is more precise then current status,
364 * it's applied. Otherwise status and type are applied only to
365 * tuner with exactly the same addr.
368 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
370 struct tuner *t = i2c_get_clientdata(c);
372 tuner_dbg("set addr for type %i\n", t->type);
374 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
375 (t->mode_mask & tun_setup->mode_mask))) ||
376 (tun_setup->addr == c->addr)) {
377 set_type(c, tun_setup->type, tun_setup->mode_mask,
378 tun_setup->config, tun_setup->tuner_callback);
382 static inline int check_mode(struct tuner *t, char *cmd)
384 if ((1 << t->mode & t->mode_mask) == 0) {
389 case V4L2_TUNER_RADIO:
390 tuner_dbg("Cmd %s accepted for radio\n", cmd);
392 case V4L2_TUNER_ANALOG_TV:
393 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
395 case V4L2_TUNER_DIGITAL_TV:
396 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
402 /* get more precise norm info from insmod option */
403 static int tuner_fixup_std(struct tuner *t)
405 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
408 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
409 t->std = V4L2_STD_PAL_60;
415 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
416 t->std = V4L2_STD_PAL_BG;
420 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
421 t->std = V4L2_STD_PAL_I;
427 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
428 t->std = V4L2_STD_PAL_DK;
432 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
433 t->std = V4L2_STD_PAL_M;
437 if (pal[1] == 'c' || pal[1] == 'C') {
438 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
439 t->std = V4L2_STD_PAL_Nc;
441 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
442 t->std = V4L2_STD_PAL_N;
446 /* default parameter, do nothing */
449 tuner_warn ("pal= argument not recognised\n");
453 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
461 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
462 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
468 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
469 t->std = V4L2_STD_SECAM_DK;
473 if ((secam[1]=='C')||(secam[1]=='c')) {
474 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
475 t->std = V4L2_STD_SECAM_LC;
477 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
478 t->std = V4L2_STD_SECAM_L;
482 /* default parameter, do nothing */
485 tuner_warn ("secam= argument not recognised\n");
490 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
494 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
495 t->std = V4L2_STD_NTSC_M;
499 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
500 t->std = V4L2_STD_NTSC_M_JP;
504 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
505 t->std = V4L2_STD_NTSC_M_KR;
508 /* default parameter, do nothing */
511 tuner_info("ntsc= argument not recognised\n");
518 static void tuner_status(struct tuner *t)
520 unsigned long freq, freq_fraction;
521 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
525 case V4L2_TUNER_RADIO: p = "radio"; break;
526 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
527 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
528 default: p = "undefined"; break;
530 if (t->mode == V4L2_TUNER_RADIO) {
531 freq = t->radio_freq / 16000;
532 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
534 freq = t->tv_freq / 16;
535 freq_fraction = (t->tv_freq % 16) * 100 / 16;
537 tuner_info("Tuner mode: %s\n", p);
538 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
539 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
540 if (t->mode != V4L2_TUNER_RADIO)
542 if (fe_tuner_ops->get_status) {
545 fe_tuner_ops->get_status(&t->fe, &tuner_status);
546 if (tuner_status & TUNER_STATUS_LOCKED)
547 tuner_info("Tuner is locked.\n");
548 if (tuner_status & TUNER_STATUS_STEREO)
549 tuner_info("Stereo: yes\n");
551 if (t->ops.has_signal) {
552 tuner_info("Signal strength: %d\n", t->ops.has_signal(t));
554 if (t->ops.is_stereo) {
555 tuner_info("Stereo: %s\n", t->ops.is_stereo(t) ? "yes" : "no");
559 /* ---------------------------------------------------------------------- */
561 /* static vars: used only in tuner_attach and tuner_probe */
562 static unsigned default_mode_mask;
564 /* During client attach, set_type is called by adapter's attach_inform callback.
565 set_type must then be completed by tuner_attach.
567 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
571 client_template.adapter = adap;
572 client_template.addr = addr;
574 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
577 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
578 i2c_set_clientdata(&t->i2c, t);
580 t->audmode = V4L2_TUNER_MODE_STEREO;
581 t->mode_mask = T_UNINITIALIZED;
582 t->ops.tuner_status = tuner_status;
585 unsigned char buffer[16];
588 memset(buffer, 0, sizeof(buffer));
589 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
590 tuner_info("I2C RECV = ");
592 printk("%02x ",buffer[i]);
595 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
596 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
599 /* autodetection code based on the i2c addr */
600 if (!no_autodetect) {
603 if (tea5761_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
604 t->type = TUNER_TEA5761;
605 t->mode_mask = T_RADIO;
607 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
608 default_mode_mask &= ~T_RADIO;
610 goto register_client;
617 /* If chip is not tda8290, don't register.
618 since it can be tda9887*/
619 if (tda8290_probe(t) == 0) {
620 tuner_dbg("chip at addr %x is a tda8290\n", addr);
622 /* Default is being tda9887 */
623 t->type = TUNER_TDA9887;
624 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
626 goto register_client;
630 if (tea5767_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
631 t->type = TUNER_TEA5767;
632 t->mode_mask = T_RADIO;
634 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
635 default_mode_mask &= ~T_RADIO;
637 goto register_client;
643 /* Initializes only the first adapter found */
644 if (default_mode_mask != T_UNINITIALIZED) {
645 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
646 t->mode_mask = default_mode_mask;
647 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
648 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
649 default_mode_mask = T_UNINITIALIZED;
652 /* Should be just before return */
654 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
655 i2c_attach_client (&t->i2c);
656 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
660 static int tuner_probe(struct i2c_adapter *adap)
663 normal_i2c[0] = addr;
664 normal_i2c[1] = I2C_CLIENT_END;
667 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
668 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
669 * and an RTC at 0x6f which can get corrupted if probed.
671 if ((adap->id == I2C_HW_B_CX2388x) ||
672 (adap->id == I2C_HW_B_CX23885)) {
675 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
677 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
678 ignore[i+0] = adap->nr;
680 ignore[i+2] = adap->nr;
682 ignore[i+4] = I2C_CLIENT_END;
684 printk(KERN_WARNING "tuner: "
685 "too many options specified "
686 "in i2c probe ignore list!\n");
689 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
691 if (adap->class & I2C_CLASS_TV_ANALOG)
692 return i2c_probe(adap, &addr_data, tuner_attach);
696 static int tuner_detach(struct i2c_client *client)
698 struct tuner *t = i2c_get_clientdata(client);
701 err = i2c_detach_client(&t->i2c);
704 ("Client deregistration failed, client not detached.\n");
718 * Switch tuner to other mode. If tuner support both tv and radio,
719 * set another frequency to some value (This is needed for some pal
720 * tuners to avoid locking). Otherwise, just put second tuner in
724 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
731 if (check_mode(t, cmd) == EINVAL) {
740 #define switch_v4l2() if (!t->using_v4l2) \
741 tuner_dbg("switching to v4l2\n"); \
744 static inline int check_v4l2(struct tuner *t)
746 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
747 TV, v4l1 for radio), until that is fixed this code is disabled.
748 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
753 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
755 struct tuner *t = i2c_get_clientdata(client);
756 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
759 v4l_i2c_print_ioctl(&(t->i2c),cmd);
762 /* --- configuration --- */
763 case TUNER_SET_TYPE_ADDR:
764 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
765 ((struct tuner_setup *)arg)->type,
766 ((struct tuner_setup *)arg)->addr,
767 ((struct tuner_setup *)arg)->mode_mask,
768 ((struct tuner_setup *)arg)->config);
770 set_addr(client, (struct tuner_setup *)arg);
773 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
777 set_freq(client, t->radio_freq);
779 case TUNER_SET_STANDBY:
780 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
786 #ifdef CONFIG_VIDEO_V4L1
788 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
790 if (check_v4l2(t) == EINVAL)
793 /* Should be implemented, since bttv calls it */
794 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
798 static const v4l2_std_id map[] = {
799 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
800 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
801 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
802 [4 /* bttv */ ] = V4L2_STD_PAL_M,
803 [5 /* bttv */ ] = V4L2_STD_PAL_N,
804 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
806 struct video_channel *vc = arg;
808 if (check_v4l2(t) == EINVAL)
811 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
814 if (vc->norm < ARRAY_SIZE(map))
815 t->std = map[vc->norm];
818 set_tv_freq(client, t->tv_freq);
823 unsigned long *v = arg;
825 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
827 if (check_v4l2(t) == EINVAL)
830 set_freq(client, *v);
835 struct video_tuner *vt = arg;
837 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
839 if (check_v4l2(t) == EINVAL)
842 if (V4L2_TUNER_RADIO == t->mode) {
843 if (fe_tuner_ops->get_status) {
846 fe_tuner_ops->get_status(&t->fe, &tuner_status);
847 if (tuner_status & TUNER_STATUS_STEREO)
848 vt->flags |= VIDEO_TUNER_STEREO_ON;
850 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
852 if (t->ops.is_stereo) {
853 if (t->ops.is_stereo(t))
855 VIDEO_TUNER_STEREO_ON;
858 ~VIDEO_TUNER_STEREO_ON;
861 if (t->ops.has_signal)
862 vt->signal = t->ops.has_signal(t);
864 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
866 vt->rangelow = radio_range[0] * 16000;
867 vt->rangehigh = radio_range[1] * 16000;
870 vt->rangelow = tv_range[0] * 16;
871 vt->rangehigh = tv_range[1] * 16;
878 struct video_audio *va = arg;
880 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
882 if (check_v4l2(t) == EINVAL)
885 if (V4L2_TUNER_RADIO == t->mode) {
886 if (fe_tuner_ops->get_status) {
889 fe_tuner_ops->get_status(&t->fe, &tuner_status);
890 va->mode = (tuner_status & TUNER_STATUS_STEREO)
891 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
892 } else if (t->ops.is_stereo)
893 va->mode = t->ops.is_stereo(t)
894 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
899 case TUNER_SET_CONFIG:
901 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
902 struct v4l2_priv_tun_config *cfg = arg;
904 if (t->type != cfg->tuner)
907 if (t->type == TUNER_TDA9887) {
908 t->tda9887_config = *(unsigned int *)cfg->priv;
909 set_freq(client, t->tv_freq);
913 if (NULL == fe_tuner_ops->set_config) {
914 tuner_warn("Tuner frontend module has no way to "
918 fe_tuner_ops->set_config(&t->fe, cfg->priv);
922 /* --- v4l ioctls --- */
923 /* take care: bttv does userspace copying, we'll get a
924 kernel pointer here... */
927 v4l2_std_id *id = arg;
929 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
938 set_freq(client, t->tv_freq);
941 case VIDIOC_S_FREQUENCY:
943 struct v4l2_frequency *f = arg;
945 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
949 set_freq(client,f->frequency);
953 case VIDIOC_G_FREQUENCY:
955 struct v4l2_frequency *f = arg;
957 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
961 if (fe_tuner_ops->get_frequency) {
964 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
965 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
966 (abs_freq * 2 + 125/2) / 125 :
967 (abs_freq + 62500/2) / 62500;
970 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
971 t->radio_freq : t->tv_freq;
976 struct v4l2_tuner *tuner = arg;
978 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
982 tuner->type = t->mode;
984 tuner->afc=t->ops.get_afc(t);
985 if (t->mode == V4L2_TUNER_ANALOG_TV)
986 tuner->capability |= V4L2_TUNER_CAP_NORM;
987 if (t->mode != V4L2_TUNER_RADIO) {
988 tuner->rangelow = tv_range[0] * 16;
989 tuner->rangehigh = tv_range[1] * 16;
995 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
996 if (fe_tuner_ops->get_status) {
999 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1000 tuner->rxsubchans = (tuner_status & TUNER_STATUS_STEREO) ?
1001 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
1003 if (t->ops.is_stereo) {
1004 tuner->rxsubchans = t->ops.is_stereo(t) ?
1005 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
1008 if (t->ops.has_signal)
1009 tuner->signal = t->ops.has_signal(t);
1010 tuner->capability |=
1011 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1012 tuner->audmode = t->audmode;
1013 tuner->rangelow = radio_range[0] * 16000;
1014 tuner->rangehigh = radio_range[1] * 16000;
1017 case VIDIOC_S_TUNER:
1019 struct v4l2_tuner *tuner = arg;
1021 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1026 /* do nothing unless we're a radio tuner */
1027 if (t->mode != V4L2_TUNER_RADIO)
1029 t->audmode = tuner->audmode;
1030 set_radio_freq(client, t->radio_freq);
1033 case VIDIOC_LOG_STATUS:
1034 if (t->ops.tuner_status)
1035 t->ops.tuner_status(t);
1042 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1044 struct tuner *t = i2c_get_clientdata (c);
1046 tuner_dbg ("suspend\n");
1047 /* FIXME: power down ??? */
1051 static int tuner_resume(struct i2c_client *c)
1053 struct tuner *t = i2c_get_clientdata (c);
1055 tuner_dbg ("resume\n");
1056 if (V4L2_TUNER_RADIO == t->mode) {
1058 set_freq(c, t->radio_freq);
1061 set_freq(c, t->tv_freq);
1066 /* ----------------------------------------------------------------------- */
1068 static struct i2c_driver driver = {
1069 .id = I2C_DRIVERID_TUNER,
1070 .attach_adapter = tuner_probe,
1071 .detach_client = tuner_detach,
1072 .command = tuner_command,
1073 .suspend = tuner_suspend,
1074 .resume = tuner_resume,
1079 static struct i2c_client client_template = {
1080 .name = "(tuner unset)",
1084 static int __init tuner_init_module(void)
1086 return i2c_add_driver(&driver);
1089 static void __exit tuner_cleanup_module(void)
1091 i2c_del_driver(&driver);
1094 module_init(tuner_init_module);
1095 module_exit(tuner_cleanup_module);
1098 * Overrides for Emacs so that we follow Linus's tabbing style.
1099 * ---------------------------------------------------------------------------