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/v4l2-common.h>
21 #include "tuner-driver.h"
29 /* standard i2c insmod options */
30 static unsigned short normal_i2c[] = {
31 #ifdef CONFIG_TUNER_TEA5761
34 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
35 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
36 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
42 /* insmod options used at init time => read/only */
43 static unsigned int addr = 0;
44 static unsigned int no_autodetect = 0;
45 static unsigned int show_i2c = 0;
47 /* insmod options used at runtime => read/write */
50 static unsigned int tv_range[2] = { 44, 958 };
51 static unsigned int radio_range[2] = { 65, 108 };
53 static char pal[] = "--";
54 static char secam[] = "--";
55 static char ntsc[] = "-";
58 module_param(addr, int, 0444);
59 module_param(no_autodetect, int, 0444);
60 module_param(show_i2c, int, 0444);
61 module_param_named(debug,tuner_debug, int, 0644);
62 module_param_string(pal, pal, sizeof(pal), 0644);
63 module_param_string(secam, secam, sizeof(secam), 0644);
64 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
65 module_param_array(tv_range, int, NULL, 0644);
66 module_param_array(radio_range, int, NULL, 0644);
68 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
69 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
70 MODULE_LICENSE("GPL");
72 static struct i2c_driver driver;
73 static struct i2c_client client_template;
75 /* ---------------------------------------------------------------------- */
77 static void fe_set_freq(struct tuner *t, unsigned int freq)
79 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
81 struct analog_parameters params = {
84 .audmode = t->audmode,
88 if (NULL == fe_tuner_ops->set_analog_params) {
89 tuner_warn("Tuner frontend module has no way to set freq\n");
92 fe_tuner_ops->set_analog_params(&t->fe, ¶ms);
95 static void fe_release(struct tuner *t)
97 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
99 if (fe_tuner_ops->release)
100 fe_tuner_ops->release(&t->fe);
103 static void fe_standby(struct tuner *t)
105 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
107 if (fe_tuner_ops->sleep)
108 fe_tuner_ops->sleep(&t->fe);
111 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
112 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
114 struct tuner *t = i2c_get_clientdata(c);
116 if (t->type == UNSET) {
117 tuner_warn ("tuner type not set\n");
120 if (NULL == t->ops.set_tv_freq) {
121 tuner_warn ("Tuner has no way to set tv freq\n");
124 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
125 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
126 freq / 16, freq % 16 * 100 / 16, tv_range[0],
128 /* V4L2 spec: if the freq is not possible then the closest
129 possible value should be selected */
130 if (freq < tv_range[0] * 16)
131 freq = tv_range[0] * 16;
133 freq = tv_range[1] * 16;
135 t->ops.set_tv_freq(t, freq);
138 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
140 struct tuner *t = i2c_get_clientdata(c);
142 if (t->type == UNSET) {
143 tuner_warn ("tuner type not set\n");
146 if (NULL == t->ops.set_radio_freq) {
147 tuner_warn ("tuner has no way to set radio frequency\n");
150 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
151 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
152 freq / 16000, freq % 16000 * 100 / 16000,
153 radio_range[0], radio_range[1]);
154 /* V4L2 spec: if the freq is not possible then the closest
155 possible value should be selected */
156 if (freq < radio_range[0] * 16000)
157 freq = radio_range[0] * 16000;
159 freq = radio_range[1] * 16000;
162 t->ops.set_radio_freq(t, freq);
165 static void set_freq(struct i2c_client *c, unsigned long freq)
167 struct tuner *t = i2c_get_clientdata(c);
170 case V4L2_TUNER_RADIO:
171 tuner_dbg("radio freq set to %lu.%02lu\n",
172 freq / 16000, freq % 16000 * 100 / 16000);
173 set_radio_freq(c, freq);
174 t->radio_freq = freq;
176 case V4L2_TUNER_ANALOG_TV:
177 case V4L2_TUNER_DIGITAL_TV:
178 tuner_dbg("tv freq set to %lu.%02lu\n",
179 freq / 16, freq % 16 * 100 / 16);
180 set_tv_freq(c, freq);
186 static void tuner_i2c_address_check(struct tuner *t)
188 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
189 ((t->i2c.addr < 0x64) || (t->i2c.addr > 0x6f)))
192 tuner_warn("====================== WARNING! ======================\n");
193 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
194 tuner_warn("will soon be dropped. This message indicates that your\n");
195 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
196 t->i2c.name, t->i2c.addr);
197 tuner_warn("To ensure continued support for your device, please\n");
198 tuner_warn("send a copy of this message, along with full dmesg\n");
199 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
200 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
201 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
202 t->i2c.adapter->name, t->i2c.addr, t->type,
203 tuners[t->type].name);
204 tuner_warn("====================== WARNING! ======================\n");
207 static void attach_tda8290(struct tuner *t)
209 struct tda8290_config cfg = {
210 .lna_cfg = &t->config,
211 .tuner_callback = t->tuner_callback
213 tda8290_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
216 static void set_type(struct i2c_client *c, unsigned int type,
217 unsigned int new_mode_mask, unsigned int new_config,
218 int (*tuner_callback) (void *dev, int command,int arg))
220 struct tuner *t = i2c_get_clientdata(c);
221 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
222 unsigned char buffer[4];
224 if (type == UNSET || type == TUNER_ABSENT) {
225 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
229 if (type >= tuner_count) {
230 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
235 t->config = new_config;
236 if (tuner_callback != NULL) {
237 tuner_dbg("defining GPIO callback\n");
238 t->tuner_callback = tuner_callback;
241 /* This code detects calls by card attach_inform */
242 if (NULL == t->i2c.dev.driver) {
243 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
248 /* discard private data, in case set_type() was previously called */
258 microtune_attach(&t->fe, t->i2c.adapter, t->i2c.addr);
260 case TUNER_PHILIPS_TDA8290:
266 if (tea5767_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
267 t->type = TUNER_ABSENT;
268 t->mode_mask = T_UNINITIALIZED;
271 t->mode_mask = T_RADIO;
273 #ifdef CONFIG_TUNER_TEA5761
275 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
276 t->type = TUNER_ABSENT;
277 t->mode_mask = T_UNINITIALIZED;
280 t->mode_mask = T_RADIO;
283 case TUNER_PHILIPS_FMD1216ME_MK3:
288 i2c_master_send(c, buffer, 4);
292 i2c_master_send(c, buffer, 4);
293 default_tuner_init(t);
295 case TUNER_PHILIPS_TD1316:
300 i2c_master_send(c,buffer,4);
301 default_tuner_init(t);
304 tda9887_tuner_init(t);
307 default_tuner_init(t);
311 if (fe_tuner_ops->set_analog_params) {
312 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
314 t->ops.set_tv_freq = fe_set_freq;
315 t->ops.set_radio_freq = fe_set_freq;
316 t->ops.standby = fe_standby;
317 t->ops.release = fe_release;
320 tuner_info("type set to %s\n", t->i2c.name);
322 if (t->mode_mask == T_UNINITIALIZED)
323 t->mode_mask = new_mode_mask;
325 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
326 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
327 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
329 tuner_i2c_address_check(t);
333 * This function apply tuner config to tuner specified
334 * by tun_setup structure. I addr is unset, then admin status
335 * and tun addr status is more precise then current status,
336 * it's applied. Otherwise status and type are applied only to
337 * tuner with exactly the same addr.
340 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
342 struct tuner *t = i2c_get_clientdata(c);
344 tuner_dbg("set addr for type %i\n", t->type);
346 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
347 (t->mode_mask & tun_setup->mode_mask))) ||
348 (tun_setup->addr == c->addr)) {
349 set_type(c, tun_setup->type, tun_setup->mode_mask,
350 tun_setup->config, tun_setup->tuner_callback);
354 static inline int check_mode(struct tuner *t, char *cmd)
356 if ((1 << t->mode & t->mode_mask) == 0) {
361 case V4L2_TUNER_RADIO:
362 tuner_dbg("Cmd %s accepted for radio\n", cmd);
364 case V4L2_TUNER_ANALOG_TV:
365 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
367 case V4L2_TUNER_DIGITAL_TV:
368 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
374 /* get more precise norm info from insmod option */
375 static int tuner_fixup_std(struct tuner *t)
377 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
380 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
381 t->std = V4L2_STD_PAL_60;
387 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
388 t->std = V4L2_STD_PAL_BG;
392 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
393 t->std = V4L2_STD_PAL_I;
399 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
400 t->std = V4L2_STD_PAL_DK;
404 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
405 t->std = V4L2_STD_PAL_M;
409 if (pal[1] == 'c' || pal[1] == 'C') {
410 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
411 t->std = V4L2_STD_PAL_Nc;
413 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
414 t->std = V4L2_STD_PAL_N;
418 /* default parameter, do nothing */
421 tuner_warn ("pal= argument not recognised\n");
425 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
433 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
434 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
440 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
441 t->std = V4L2_STD_SECAM_DK;
445 if ((secam[1]=='C')||(secam[1]=='c')) {
446 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
447 t->std = V4L2_STD_SECAM_LC;
449 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
450 t->std = V4L2_STD_SECAM_L;
454 /* default parameter, do nothing */
457 tuner_warn ("secam= argument not recognised\n");
462 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
466 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
467 t->std = V4L2_STD_NTSC_M;
471 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
472 t->std = V4L2_STD_NTSC_M_JP;
476 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
477 t->std = V4L2_STD_NTSC_M_KR;
480 /* default parameter, do nothing */
483 tuner_info("ntsc= argument not recognised\n");
490 static void tuner_status(struct tuner *t)
492 unsigned long freq, freq_fraction;
493 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
497 case V4L2_TUNER_RADIO: p = "radio"; break;
498 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
499 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
500 default: p = "undefined"; break;
502 if (t->mode == V4L2_TUNER_RADIO) {
503 freq = t->radio_freq / 16000;
504 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
506 freq = t->tv_freq / 16;
507 freq_fraction = (t->tv_freq % 16) * 100 / 16;
509 tuner_info("Tuner mode: %s\n", p);
510 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
511 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
512 if (t->mode != V4L2_TUNER_RADIO)
514 if (fe_tuner_ops->get_status) {
517 fe_tuner_ops->get_status(&t->fe, &tuner_status);
518 if (tuner_status & TUNER_STATUS_LOCKED)
519 tuner_info("Tuner is locked.\n");
520 if (tuner_status & TUNER_STATUS_STEREO)
521 tuner_info("Stereo: yes\n");
523 if (t->ops.has_signal) {
524 tuner_info("Signal strength: %d\n", t->ops.has_signal(t));
526 if (t->ops.is_stereo) {
527 tuner_info("Stereo: %s\n", t->ops.is_stereo(t) ? "yes" : "no");
531 /* ---------------------------------------------------------------------- */
533 /* static vars: used only in tuner_attach and tuner_probe */
534 static unsigned default_mode_mask;
536 /* During client attach, set_type is called by adapter's attach_inform callback.
537 set_type must then be completed by tuner_attach.
539 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
543 client_template.adapter = adap;
544 client_template.addr = addr;
546 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
549 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
550 i2c_set_clientdata(&t->i2c, t);
552 t->audmode = V4L2_TUNER_MODE_STEREO;
553 t->mode_mask = T_UNINITIALIZED;
554 t->ops.tuner_status = tuner_status;
557 unsigned char buffer[16];
560 memset(buffer, 0, sizeof(buffer));
561 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
562 tuner_info("I2C RECV = ");
564 printk("%02x ",buffer[i]);
567 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
568 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
571 /* autodetection code based on the i2c addr */
572 if (!no_autodetect) {
574 #ifdef CONFIG_TUNER_TEA5761
576 if (tea5761_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
577 t->type = TUNER_TEA5761;
578 t->mode_mask = T_RADIO;
580 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
581 default_mode_mask &= ~T_RADIO;
583 goto register_client;
591 /* If chip is not tda8290, don't register.
592 since it can be tda9887*/
593 if (tda8290_probe(t->i2c.adapter, t->i2c.addr) == 0) {
594 tuner_dbg("chip at addr %x is a tda8290\n", addr);
596 /* Default is being tda9887 */
597 t->type = TUNER_TDA9887;
598 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
600 goto register_client;
604 if (tea5767_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
605 t->type = TUNER_TEA5767;
606 t->mode_mask = T_RADIO;
608 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
609 default_mode_mask &= ~T_RADIO;
611 goto register_client;
617 /* Initializes only the first adapter found */
618 if (default_mode_mask != T_UNINITIALIZED) {
619 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
620 t->mode_mask = default_mode_mask;
621 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
622 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
623 default_mode_mask = T_UNINITIALIZED;
626 /* Should be just before return */
628 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
629 i2c_attach_client (&t->i2c);
630 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
634 static int tuner_probe(struct i2c_adapter *adap)
637 normal_i2c[0] = addr;
638 normal_i2c[1] = I2C_CLIENT_END;
641 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
643 if (adap->class & I2C_CLASS_TV_ANALOG)
644 return i2c_probe(adap, &addr_data, tuner_attach);
648 static int tuner_detach(struct i2c_client *client)
650 struct tuner *t = i2c_get_clientdata(client);
653 err = i2c_detach_client(&t->i2c);
656 ("Client deregistration failed, client not detached.\n");
670 * Switch tuner to other mode. If tuner support both tv and radio,
671 * set another frequency to some value (This is needed for some pal
672 * tuners to avoid locking). Otherwise, just put second tuner in
676 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
683 if (check_mode(t, cmd) == EINVAL) {
692 #define switch_v4l2() if (!t->using_v4l2) \
693 tuner_dbg("switching to v4l2\n"); \
696 static inline int check_v4l2(struct tuner *t)
698 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
699 TV, v4l1 for radio), until that is fixed this code is disabled.
700 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
705 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
707 struct tuner *t = i2c_get_clientdata(client);
708 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
711 v4l_i2c_print_ioctl(&(t->i2c),cmd);
714 /* --- configuration --- */
715 case TUNER_SET_TYPE_ADDR:
716 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
717 ((struct tuner_setup *)arg)->type,
718 ((struct tuner_setup *)arg)->addr,
719 ((struct tuner_setup *)arg)->mode_mask,
720 ((struct tuner_setup *)arg)->config);
722 set_addr(client, (struct tuner_setup *)arg);
725 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
729 set_freq(client, t->radio_freq);
731 case TUNER_SET_STANDBY:
732 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
738 #ifdef CONFIG_VIDEO_V4L1
740 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
742 if (check_v4l2(t) == EINVAL)
745 /* Should be implemented, since bttv calls it */
746 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
750 static const v4l2_std_id map[] = {
751 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
752 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
753 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
754 [4 /* bttv */ ] = V4L2_STD_PAL_M,
755 [5 /* bttv */ ] = V4L2_STD_PAL_N,
756 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
758 struct video_channel *vc = arg;
760 if (check_v4l2(t) == EINVAL)
763 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
766 if (vc->norm < ARRAY_SIZE(map))
767 t->std = map[vc->norm];
770 set_tv_freq(client, t->tv_freq);
775 unsigned long *v = arg;
777 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
779 if (check_v4l2(t) == EINVAL)
782 set_freq(client, *v);
787 struct video_tuner *vt = arg;
789 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
791 if (check_v4l2(t) == EINVAL)
794 if (V4L2_TUNER_RADIO == t->mode) {
795 if (fe_tuner_ops->get_status) {
798 fe_tuner_ops->get_status(&t->fe, &tuner_status);
799 if (tuner_status & TUNER_STATUS_STEREO)
800 vt->flags |= VIDEO_TUNER_STEREO_ON;
802 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
803 vt->signal = tuner_status & TUNER_STATUS_LOCKED
806 if (t->ops.is_stereo) {
807 if (t->ops.is_stereo(t))
809 VIDEO_TUNER_STEREO_ON;
812 ~VIDEO_TUNER_STEREO_ON;
814 if (t->ops.has_signal)
815 vt->signal = t->ops.has_signal(t);
817 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
819 vt->rangelow = radio_range[0] * 16000;
820 vt->rangehigh = radio_range[1] * 16000;
823 vt->rangelow = tv_range[0] * 16;
824 vt->rangehigh = tv_range[1] * 16;
831 struct video_audio *va = arg;
833 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
835 if (check_v4l2(t) == EINVAL)
838 if (V4L2_TUNER_RADIO == t->mode) {
839 if (fe_tuner_ops->get_status) {
842 fe_tuner_ops->get_status(&t->fe, &tuner_status);
843 va->mode = (tuner_status & TUNER_STATUS_STEREO)
844 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
845 } else if (t->ops.is_stereo)
846 va->mode = t->ops.is_stereo(t)
847 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
852 case TDA9887_SET_CONFIG:
853 if (t->type == TUNER_TDA9887) {
856 t->tda9887_config = *i;
857 set_freq(client, t->tv_freq);
860 /* --- v4l ioctls --- */
861 /* take care: bttv does userspace copying, we'll get a
862 kernel pointer here... */
865 v4l2_std_id *id = arg;
867 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
876 set_freq(client, t->tv_freq);
879 case VIDIOC_S_FREQUENCY:
881 struct v4l2_frequency *f = arg;
883 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
887 set_freq(client,f->frequency);
891 case VIDIOC_G_FREQUENCY:
893 struct v4l2_frequency *f = arg;
895 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
899 if (fe_tuner_ops->get_frequency) {
902 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
903 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
904 (abs_freq * 2 + 125/2) / 125 :
905 (abs_freq + 62500/2) / 62500;
908 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
909 t->radio_freq : t->tv_freq;
914 struct v4l2_tuner *tuner = arg;
916 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
920 tuner->type = t->mode;
922 tuner->afc=t->ops.get_afc(t);
923 if (t->mode == V4L2_TUNER_ANALOG_TV)
924 tuner->capability |= V4L2_TUNER_CAP_NORM;
925 if (t->mode != V4L2_TUNER_RADIO) {
926 tuner->rangelow = tv_range[0] * 16;
927 tuner->rangehigh = tv_range[1] * 16;
933 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
934 if (fe_tuner_ops->get_status) {
937 fe_tuner_ops->get_status(&t->fe, &tuner_status);
938 tuner->rxsubchans = (tuner_status & TUNER_STATUS_STEREO) ?
939 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
940 tuner->signal = tuner_status & TUNER_STATUS_LOCKED ? 65535 : 0;
942 if (t->ops.is_stereo) {
943 tuner->rxsubchans = t->ops.is_stereo(t) ?
944 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
946 if (t->ops.has_signal)
947 tuner->signal = t->ops.has_signal(t);
950 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
951 tuner->audmode = t->audmode;
952 tuner->rangelow = radio_range[0] * 16000;
953 tuner->rangehigh = radio_range[1] * 16000;
958 struct v4l2_tuner *tuner = arg;
960 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
965 /* do nothing unless we're a radio tuner */
966 if (t->mode != V4L2_TUNER_RADIO)
968 t->audmode = tuner->audmode;
969 set_radio_freq(client, t->radio_freq);
972 case VIDIOC_LOG_STATUS:
973 if (t->ops.tuner_status)
974 t->ops.tuner_status(t);
981 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
983 struct tuner *t = i2c_get_clientdata (c);
985 tuner_dbg ("suspend\n");
986 /* FIXME: power down ??? */
990 static int tuner_resume(struct i2c_client *c)
992 struct tuner *t = i2c_get_clientdata (c);
994 tuner_dbg ("resume\n");
995 if (V4L2_TUNER_RADIO == t->mode) {
997 set_freq(c, t->radio_freq);
1000 set_freq(c, t->tv_freq);
1005 /* ----------------------------------------------------------------------- */
1007 static struct i2c_driver driver = {
1008 .id = I2C_DRIVERID_TUNER,
1009 .attach_adapter = tuner_probe,
1010 .detach_client = tuner_detach,
1011 .command = tuner_command,
1012 .suspend = tuner_suspend,
1013 .resume = tuner_resume,
1018 static struct i2c_client client_template = {
1019 .name = "(tuner unset)",
1023 static int __init tuner_init_module(void)
1025 return i2c_add_driver(&driver);
1028 static void __exit tuner_cleanup_module(void)
1030 i2c_del_driver(&driver);
1033 module_init(tuner_init_module);
1034 module_exit(tuner_cleanup_module);
1037 * Overrides for Emacs so that we follow Linus's tabbing style.
1038 * ---------------------------------------------------------------------------