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"
33 /* standard i2c insmod options */
34 static unsigned short normal_i2c[] = {
35 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
38 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
39 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
40 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
46 /* insmod options used at init time => read/only */
47 static unsigned int addr = 0;
48 static unsigned int no_autodetect = 0;
49 static unsigned int show_i2c = 0;
51 /* insmod options used at runtime => read/write */
54 static unsigned int tv_range[2] = { 44, 958 };
55 static unsigned int radio_range[2] = { 65, 108 };
57 static char pal[] = "--";
58 static char secam[] = "--";
59 static char ntsc[] = "-";
62 module_param(addr, int, 0444);
63 module_param(no_autodetect, int, 0444);
64 module_param(show_i2c, int, 0444);
65 module_param_named(debug,tuner_debug, int, 0644);
66 module_param_string(pal, pal, sizeof(pal), 0644);
67 module_param_string(secam, secam, sizeof(secam), 0644);
68 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
69 module_param_array(tv_range, int, NULL, 0644);
70 module_param_array(radio_range, int, NULL, 0644);
72 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
73 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
74 MODULE_LICENSE("GPL");
76 static struct i2c_driver driver;
77 static struct i2c_client client_template;
79 /* ---------------------------------------------------------------------- */
81 static void fe_set_freq(struct dvb_frontend *fe, unsigned int freq)
83 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
84 struct tuner *t = fe->analog_demod_priv;
86 struct analog_parameters params = {
89 .audmode = t->audmode,
93 if (NULL == fe_tuner_ops->set_analog_params) {
94 tuner_warn("Tuner frontend module has no way to set freq\n");
97 fe_tuner_ops->set_analog_params(fe, ¶ms);
100 static void fe_release(struct dvb_frontend *fe)
102 if (fe->ops.tuner_ops.release)
103 fe->ops.tuner_ops.release(fe);
105 fe->ops.analog_demod_ops = NULL;
106 /* DO NOT kfree(t->fe.analog_demod_priv) */
107 fe->analog_demod_priv = NULL;
110 static void fe_standby(struct dvb_frontend *fe)
112 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
114 if (fe_tuner_ops->sleep)
115 fe_tuner_ops->sleep(fe);
118 static int fe_has_signal(struct dvb_frontend *fe)
122 if (fe->ops.tuner_ops.get_rf_strength)
123 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
128 static void tuner_status(struct dvb_frontend *fe);
130 static struct analog_tuner_ops tuner_core_ops = {
131 .set_tv_freq = fe_set_freq,
132 .set_radio_freq = fe_set_freq,
133 .standby = fe_standby,
134 .release = fe_release,
135 .has_signal = fe_has_signal,
136 .tuner_status = tuner_status
139 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
140 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
142 struct tuner *t = i2c_get_clientdata(c);
143 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
145 if (t->type == UNSET) {
146 tuner_warn ("tuner type not set\n");
149 if ((NULL == ops) || (NULL == ops->set_tv_freq)) {
150 tuner_warn ("Tuner has no way to set tv freq\n");
153 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
154 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
155 freq / 16, freq % 16 * 100 / 16, tv_range[0],
157 /* V4L2 spec: if the freq is not possible then the closest
158 possible value should be selected */
159 if (freq < tv_range[0] * 16)
160 freq = tv_range[0] * 16;
162 freq = tv_range[1] * 16;
164 ops->set_tv_freq(&t->fe, freq);
167 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
169 struct tuner *t = i2c_get_clientdata(c);
170 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
172 if (t->type == UNSET) {
173 tuner_warn ("tuner type not set\n");
176 if ((NULL == ops) || (NULL == ops->set_radio_freq)) {
177 tuner_warn ("tuner has no way to set radio frequency\n");
180 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
181 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
182 freq / 16000, freq % 16000 * 100 / 16000,
183 radio_range[0], radio_range[1]);
184 /* V4L2 spec: if the freq is not possible then the closest
185 possible value should be selected */
186 if (freq < radio_range[0] * 16000)
187 freq = radio_range[0] * 16000;
189 freq = radio_range[1] * 16000;
192 ops->set_radio_freq(&t->fe, freq);
195 static void set_freq(struct i2c_client *c, unsigned long freq)
197 struct tuner *t = i2c_get_clientdata(c);
200 case V4L2_TUNER_RADIO:
201 tuner_dbg("radio freq set to %lu.%02lu\n",
202 freq / 16000, freq % 16000 * 100 / 16000);
203 set_radio_freq(c, freq);
204 t->radio_freq = freq;
206 case V4L2_TUNER_ANALOG_TV:
207 case V4L2_TUNER_DIGITAL_TV:
208 tuner_dbg("tv freq set to %lu.%02lu\n",
209 freq / 16, freq % 16 * 100 / 16);
210 set_tv_freq(c, freq);
214 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
218 static void tuner_i2c_address_check(struct tuner *t)
220 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
221 ((t->i2c.addr < 0x64) || (t->i2c.addr > 0x6f)))
224 tuner_warn("====================== WARNING! ======================\n");
225 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
226 tuner_warn("will soon be dropped. This message indicates that your\n");
227 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
228 t->i2c.name, t->i2c.addr);
229 tuner_warn("To ensure continued support for your device, please\n");
230 tuner_warn("send a copy of this message, along with full dmesg\n");
231 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
232 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
233 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
234 t->i2c.adapter->name, t->i2c.addr, t->type,
235 tuners[t->type].name);
236 tuner_warn("====================== WARNING! ======================\n");
239 static void attach_simple_tuner(struct tuner *t)
241 struct simple_tuner_config cfg = {
243 .tun = &tuners[t->type]
245 simple_tuner_attach(&t->fe, t->i2c.adapter, t->i2c.addr, &cfg);
248 static void set_type(struct i2c_client *c, unsigned int type,
249 unsigned int new_mode_mask, unsigned int new_config,
250 int (*tuner_callback) (void *dev, int command,int arg))
252 struct tuner *t = i2c_get_clientdata(c);
253 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
254 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
255 unsigned char buffer[4];
257 if (type == UNSET || type == TUNER_ABSENT) {
258 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
262 if (type >= tuner_count) {
263 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
268 t->config = new_config;
269 if (tuner_callback != NULL) {
270 tuner_dbg("defining GPIO callback\n");
271 t->tuner_callback = tuner_callback;
274 /* This code detects calls by card attach_inform */
275 if (NULL == t->i2c.dev.driver) {
276 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
281 /* discard private data, in case set_type() was previously called */
282 if (ops && ops->release)
283 ops->release(&t->fe);
287 microtune_attach(&t->fe, t->i2c.adapter, t->i2c.addr);
289 case TUNER_PHILIPS_TDA8290:
294 case TUNER_PHILIPS_TDA8295:
300 if (tea5767_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
301 t->type = TUNER_ABSENT;
302 t->mode_mask = T_UNINITIALIZED;
305 t->mode_mask = T_RADIO;
308 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
309 t->type = TUNER_ABSENT;
310 t->mode_mask = T_UNINITIALIZED;
313 t->mode_mask = T_RADIO;
315 case TUNER_PHILIPS_FMD1216ME_MK3:
320 i2c_master_send(c, buffer, 4);
324 i2c_master_send(c, buffer, 4);
325 attach_simple_tuner(t);
327 case TUNER_PHILIPS_TD1316:
332 i2c_master_send(c,buffer,4);
333 attach_simple_tuner(t);
337 int rc=xc2028_attach(&t->fe, t->i2c.adapter, t->i2c.addr,
338 &c->dev, c->adapter->algo_data,
341 t->type = TUNER_ABSENT;
342 t->mode_mask = T_UNINITIALIZED;
351 attach_simple_tuner(t);
355 ops = t->fe.ops.analog_demod_ops;
357 if (((NULL == ops) ||
358 ((NULL == ops->set_tv_freq) && (NULL == ops->set_radio_freq))) &&
359 (fe_tuner_ops->set_analog_params)) {
360 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
362 t->fe.ops.analog_demod_ops = &tuner_core_ops;
363 t->fe.analog_demod_priv = t;
366 tuner_info("type set to %s\n", t->i2c.name);
368 if (t->mode_mask == T_UNINITIALIZED)
369 t->mode_mask = new_mode_mask;
371 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
372 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
373 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
375 tuner_i2c_address_check(t);
379 * This function apply tuner config to tuner specified
380 * by tun_setup structure. I addr is unset, then admin status
381 * and tun addr status is more precise then current status,
382 * it's applied. Otherwise status and type are applied only to
383 * tuner with exactly the same addr.
386 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
388 struct tuner *t = i2c_get_clientdata(c);
390 tuner_dbg("set addr for type %i\n", t->type);
392 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
393 (t->mode_mask & tun_setup->mode_mask))) ||
394 (tun_setup->addr == c->addr)) {
395 set_type(c, tun_setup->type, tun_setup->mode_mask,
396 tun_setup->config, tun_setup->tuner_callback);
400 static inline int check_mode(struct tuner *t, char *cmd)
402 if ((1 << t->mode & t->mode_mask) == 0) {
407 case V4L2_TUNER_RADIO:
408 tuner_dbg("Cmd %s accepted for radio\n", cmd);
410 case V4L2_TUNER_ANALOG_TV:
411 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
413 case V4L2_TUNER_DIGITAL_TV:
414 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
420 /* get more precise norm info from insmod option */
421 static int tuner_fixup_std(struct tuner *t)
423 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
426 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
427 t->std = V4L2_STD_PAL_60;
433 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
434 t->std = V4L2_STD_PAL_BG;
438 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
439 t->std = V4L2_STD_PAL_I;
445 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
446 t->std = V4L2_STD_PAL_DK;
450 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
451 t->std = V4L2_STD_PAL_M;
455 if (pal[1] == 'c' || pal[1] == 'C') {
456 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
457 t->std = V4L2_STD_PAL_Nc;
459 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
460 t->std = V4L2_STD_PAL_N;
464 /* default parameter, do nothing */
467 tuner_warn ("pal= argument not recognised\n");
471 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
479 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
480 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
486 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
487 t->std = V4L2_STD_SECAM_DK;
491 if ((secam[1]=='C')||(secam[1]=='c')) {
492 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
493 t->std = V4L2_STD_SECAM_LC;
495 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
496 t->std = V4L2_STD_SECAM_L;
500 /* default parameter, do nothing */
503 tuner_warn ("secam= argument not recognised\n");
508 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
512 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
513 t->std = V4L2_STD_NTSC_M;
517 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
518 t->std = V4L2_STD_NTSC_M_JP;
522 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
523 t->std = V4L2_STD_NTSC_M_KR;
526 /* default parameter, do nothing */
529 tuner_info("ntsc= argument not recognised\n");
536 static void tuner_status(struct dvb_frontend *fe)
538 struct tuner *t = fe->analog_demod_priv;
539 unsigned long freq, freq_fraction;
540 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
541 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
545 case V4L2_TUNER_RADIO: p = "radio"; break;
546 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
547 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
548 default: p = "undefined"; break;
550 if (t->mode == V4L2_TUNER_RADIO) {
551 freq = t->radio_freq / 16000;
552 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
554 freq = t->tv_freq / 16;
555 freq_fraction = (t->tv_freq % 16) * 100 / 16;
557 tuner_info("Tuner mode: %s\n", p);
558 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
559 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
560 if (t->mode != V4L2_TUNER_RADIO)
562 if (fe_tuner_ops->get_status) {
565 fe_tuner_ops->get_status(&t->fe, &tuner_status);
566 if (tuner_status & TUNER_STATUS_LOCKED)
567 tuner_info("Tuner is locked.\n");
568 if (tuner_status & TUNER_STATUS_STEREO)
569 tuner_info("Stereo: yes\n");
573 tuner_info("Signal strength: %d\n",
574 ops->has_signal(fe));
576 tuner_info("Stereo: %s\n",
577 ops->is_stereo(fe) ? "yes" : "no");
581 /* ---------------------------------------------------------------------- */
583 /* static vars: used only in tuner_attach and tuner_probe */
584 static unsigned default_mode_mask;
586 /* During client attach, set_type is called by adapter's attach_inform callback.
587 set_type must then be completed by tuner_attach.
589 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
593 client_template.adapter = adap;
594 client_template.addr = addr;
596 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
599 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
600 i2c_set_clientdata(&t->i2c, t);
602 t->audmode = V4L2_TUNER_MODE_STEREO;
603 t->mode_mask = T_UNINITIALIZED;
606 unsigned char buffer[16];
609 memset(buffer, 0, sizeof(buffer));
610 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
611 tuner_info("I2C RECV = ");
613 printk("%02x ",buffer[i]);
616 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
617 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
620 /* autodetection code based on the i2c addr */
621 if (!no_autodetect) {
624 if (tea5761_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
625 t->type = TUNER_TEA5761;
626 t->mode_mask = T_RADIO;
628 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
629 default_mode_mask &= ~T_RADIO;
631 goto register_client;
638 /* If chip is not tda8290, don't register.
639 since it can be tda9887*/
640 if (tda8290_probe(t) == 0) {
641 tuner_dbg("chip at addr %x is a tda8290\n", addr);
643 /* Default is being tda9887 */
644 t->type = TUNER_TDA9887;
645 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
647 goto register_client;
651 if (tea5767_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
652 t->type = TUNER_TEA5767;
653 t->mode_mask = T_RADIO;
655 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
656 default_mode_mask &= ~T_RADIO;
658 goto register_client;
664 /* Initializes only the first adapter found */
665 if (default_mode_mask != T_UNINITIALIZED) {
666 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
667 t->mode_mask = default_mode_mask;
668 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
669 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
670 default_mode_mask = T_UNINITIALIZED;
673 /* Should be just before return */
675 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
676 i2c_attach_client (&t->i2c);
677 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
681 static int tuner_probe(struct i2c_adapter *adap)
684 normal_i2c[0] = addr;
685 normal_i2c[1] = I2C_CLIENT_END;
688 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
689 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
690 * and an RTC at 0x6f which can get corrupted if probed.
692 if ((adap->id == I2C_HW_B_CX2388x) ||
693 (adap->id == I2C_HW_B_CX23885)) {
696 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
698 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
699 ignore[i+0] = adap->nr;
701 ignore[i+2] = adap->nr;
703 ignore[i+4] = I2C_CLIENT_END;
705 printk(KERN_WARNING "tuner: "
706 "too many options specified "
707 "in i2c probe ignore list!\n");
710 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
712 if (adap->class & I2C_CLASS_TV_ANALOG)
713 return i2c_probe(adap, &addr_data, tuner_attach);
717 static int tuner_detach(struct i2c_client *client)
719 struct tuner *t = i2c_get_clientdata(client);
720 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
723 err = i2c_detach_client(&t->i2c);
726 ("Client deregistration failed, client not detached.\n");
730 if (ops && ops->release)
731 ops->release(&t->fe);
738 * Switch tuner to other mode. If tuner support both tv and radio,
739 * set another frequency to some value (This is needed for some pal
740 * tuners to avoid locking). Otherwise, just put second tuner in
744 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
746 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
753 if (check_mode(t, cmd) == EINVAL) {
755 if (ops && ops->standby)
756 ops->standby(&t->fe);
762 #define switch_v4l2() if (!t->using_v4l2) \
763 tuner_dbg("switching to v4l2\n"); \
766 static inline int check_v4l2(struct tuner *t)
768 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
769 TV, v4l1 for radio), until that is fixed this code is disabled.
770 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
775 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
777 struct tuner *t = i2c_get_clientdata(client);
778 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
779 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
782 v4l_i2c_print_ioctl(&(t->i2c),cmd);
785 /* --- configuration --- */
786 case TUNER_SET_TYPE_ADDR:
787 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
788 ((struct tuner_setup *)arg)->type,
789 ((struct tuner_setup *)arg)->addr,
790 ((struct tuner_setup *)arg)->mode_mask,
791 ((struct tuner_setup *)arg)->config);
793 set_addr(client, (struct tuner_setup *)arg);
796 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
800 set_freq(client, t->radio_freq);
802 case TUNER_SET_STANDBY:
803 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
806 if (ops && ops->standby)
807 ops->standby(&t->fe);
809 #ifdef CONFIG_VIDEO_V4L1
811 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
813 if (check_v4l2(t) == EINVAL)
816 /* Should be implemented, since bttv calls it */
817 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
821 static const v4l2_std_id map[] = {
822 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
823 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
824 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
825 [4 /* bttv */ ] = V4L2_STD_PAL_M,
826 [5 /* bttv */ ] = V4L2_STD_PAL_N,
827 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
829 struct video_channel *vc = arg;
831 if (check_v4l2(t) == EINVAL)
834 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
837 if (vc->norm < ARRAY_SIZE(map))
838 t->std = map[vc->norm];
841 set_tv_freq(client, t->tv_freq);
846 unsigned long *v = arg;
848 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
850 if (check_v4l2(t) == EINVAL)
853 set_freq(client, *v);
858 struct video_tuner *vt = arg;
860 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
862 if (check_v4l2(t) == EINVAL)
865 if (V4L2_TUNER_RADIO == t->mode) {
866 if (fe_tuner_ops->get_status) {
869 fe_tuner_ops->get_status(&t->fe, &tuner_status);
870 if (tuner_status & TUNER_STATUS_STEREO)
871 vt->flags |= VIDEO_TUNER_STEREO_ON;
873 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
875 if (ops && ops->is_stereo) {
876 if (ops->is_stereo(&t->fe))
878 VIDEO_TUNER_STEREO_ON;
881 ~VIDEO_TUNER_STEREO_ON;
884 if (ops && ops->has_signal)
885 vt->signal = ops->has_signal(&t->fe);
887 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
889 vt->rangelow = radio_range[0] * 16000;
890 vt->rangehigh = radio_range[1] * 16000;
893 vt->rangelow = tv_range[0] * 16;
894 vt->rangehigh = tv_range[1] * 16;
901 struct video_audio *va = arg;
903 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
905 if (check_v4l2(t) == EINVAL)
908 if (V4L2_TUNER_RADIO == t->mode) {
909 if (fe_tuner_ops->get_status) {
912 fe_tuner_ops->get_status(&t->fe, &tuner_status);
913 va->mode = (tuner_status & TUNER_STATUS_STEREO)
914 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
915 } else if (ops && ops->is_stereo)
916 va->mode = ops->is_stereo(&t->fe)
917 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
922 case TUNER_SET_CONFIG:
924 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
925 struct v4l2_priv_tun_config *cfg = arg;
927 if (t->type != cfg->tuner)
930 if (t->type == TUNER_TDA9887) {
931 t->tda9887_config = *(unsigned int *)cfg->priv;
932 set_freq(client, t->tv_freq);
936 if (NULL == fe_tuner_ops->set_config) {
937 tuner_warn("Tuner frontend module has no way to "
941 fe_tuner_ops->set_config(&t->fe, cfg->priv);
945 /* --- v4l ioctls --- */
946 /* take care: bttv does userspace copying, we'll get a
947 kernel pointer here... */
950 v4l2_std_id *id = arg;
952 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
961 set_freq(client, t->tv_freq);
964 case VIDIOC_S_FREQUENCY:
966 struct v4l2_frequency *f = arg;
968 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
972 set_freq(client,f->frequency);
976 case VIDIOC_G_FREQUENCY:
978 struct v4l2_frequency *f = arg;
980 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
984 if (fe_tuner_ops->get_frequency) {
987 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
988 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
989 (abs_freq * 2 + 125/2) / 125 :
990 (abs_freq + 62500/2) / 62500;
993 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
994 t->radio_freq : t->tv_freq;
999 struct v4l2_tuner *tuner = arg;
1001 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
1005 tuner->type = t->mode;
1006 if (ops && ops->get_afc)
1007 tuner->afc = ops->get_afc(&t->fe);
1008 if (t->mode == V4L2_TUNER_ANALOG_TV)
1009 tuner->capability |= V4L2_TUNER_CAP_NORM;
1010 if (t->mode != V4L2_TUNER_RADIO) {
1011 tuner->rangelow = tv_range[0] * 16;
1012 tuner->rangehigh = tv_range[1] * 16;
1018 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1019 if (fe_tuner_ops->get_status) {
1022 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1024 (tuner_status & TUNER_STATUS_STEREO) ?
1025 V4L2_TUNER_SUB_STEREO :
1026 V4L2_TUNER_SUB_MONO;
1028 if (ops && ops->is_stereo) {
1030 ops->is_stereo(&t->fe) ?
1031 V4L2_TUNER_SUB_STEREO :
1032 V4L2_TUNER_SUB_MONO;
1035 if (ops && ops->has_signal)
1036 tuner->signal = ops->has_signal(&t->fe);
1037 tuner->capability |=
1038 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1039 tuner->audmode = t->audmode;
1040 tuner->rangelow = radio_range[0] * 16000;
1041 tuner->rangehigh = radio_range[1] * 16000;
1044 case VIDIOC_S_TUNER:
1046 struct v4l2_tuner *tuner = arg;
1048 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1053 /* do nothing unless we're a radio tuner */
1054 if (t->mode != V4L2_TUNER_RADIO)
1056 t->audmode = tuner->audmode;
1057 set_radio_freq(client, t->radio_freq);
1060 case VIDIOC_LOG_STATUS:
1061 if (ops && ops->tuner_status)
1062 ops->tuner_status(&t->fe);
1069 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1071 struct tuner *t = i2c_get_clientdata (c);
1073 tuner_dbg ("suspend\n");
1074 /* FIXME: power down ??? */
1078 static int tuner_resume(struct i2c_client *c)
1080 struct tuner *t = i2c_get_clientdata (c);
1082 tuner_dbg ("resume\n");
1083 if (V4L2_TUNER_RADIO == t->mode) {
1085 set_freq(c, t->radio_freq);
1088 set_freq(c, t->tv_freq);
1093 /* ----------------------------------------------------------------------- */
1095 static struct i2c_driver driver = {
1096 .id = I2C_DRIVERID_TUNER,
1097 .attach_adapter = tuner_probe,
1098 .detach_client = tuner_detach,
1099 .command = tuner_command,
1100 .suspend = tuner_suspend,
1101 .resume = tuner_resume,
1106 static struct i2c_client client_template = {
1107 .name = "(tuner unset)",
1111 static int __init tuner_init_module(void)
1113 return i2c_add_driver(&driver);
1116 static void __exit tuner_cleanup_module(void)
1118 i2c_del_driver(&driver);
1121 module_init(tuner_init_module);
1122 module_exit(tuner_cleanup_module);
1125 * Overrides for Emacs so that we follow Linus's tabbing style.
1126 * ---------------------------------------------------------------------------