3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/string.h>
10 #include <linux/timer.h>
11 #include <linux/delay.h>
12 #include <linux/errno.h>
13 #include <linux/slab.h>
14 #include <linux/poll.h>
15 #include <linux/i2c.h>
16 #include <linux/types.h>
17 #include <linux/init.h>
18 #include <linux/videodev.h>
19 #include <media/tuner.h>
20 #include <media/tuner-types.h>
21 #include <media/v4l2-common.h>
22 #include <media/v4l2-i2c-drv-legacy.h>
27 #include "tuner-xc2028.h"
28 #include "tuner-simple.h"
34 #define PREFIX t->i2c->driver->driver.name
36 /** This macro allows us to probe dynamically, avoiding static links */
37 #ifdef CONFIG_MEDIA_ATTACH
38 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
40 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
42 __r = (int) __a(ARGS); \
43 symbol_put(FUNCTION); \
45 printk(KERN_ERR "TUNER: Unable to find " \
46 "symbol "#FUNCTION"()\n"); \
51 static void tuner_detach(struct dvb_frontend *fe)
53 if (fe->ops.tuner_ops.release) {
54 fe->ops.tuner_ops.release(fe);
55 symbol_put_addr(fe->ops.tuner_ops.release);
57 if (fe->ops.analog_ops.release) {
58 fe->ops.analog_ops.release(fe);
59 symbol_put_addr(fe->ops.analog_ops.release);
63 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
67 static void tuner_detach(struct dvb_frontend *fe)
69 if (fe->ops.tuner_ops.release)
70 fe->ops.tuner_ops.release(fe);
71 if (fe->ops.analog_ops.release)
72 fe->ops.analog_ops.release(fe);
78 struct dvb_frontend fe;
79 struct i2c_client *i2c;
80 struct list_head list;
81 unsigned int using_v4l2:1;
83 /* keep track of the current settings */
86 unsigned int radio_freq;
90 unsigned int mode_mask; /* Combination of allowable modes */
92 unsigned int type; /* chip type id */
94 int (*tuner_callback) (void *dev, int command, int arg);
97 /* standard i2c insmod options */
98 static unsigned short normal_i2c[] = {
99 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
102 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
103 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
104 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
110 /* insmod options used at init time => read/only */
111 static unsigned int addr;
112 static unsigned int no_autodetect;
113 static unsigned int show_i2c;
115 /* insmod options used at runtime => read/write */
116 static int tuner_debug;
118 #define tuner_warn(fmt, arg...) do { \
119 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
120 i2c_adapter_id(t->i2c->adapter), \
121 t->i2c->addr, ##arg); \
124 #define tuner_info(fmt, arg...) do { \
125 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
126 i2c_adapter_id(t->i2c->adapter), \
127 t->i2c->addr, ##arg); \
130 #define tuner_err(fmt, arg...) do { \
131 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
132 i2c_adapter_id(t->i2c->adapter), \
133 t->i2c->addr, ##arg); \
136 #define tuner_dbg(fmt, arg...) do { \
138 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
139 i2c_adapter_id(t->i2c->adapter), \
140 t->i2c->addr, ##arg); \
143 /* ------------------------------------------------------------------------ */
145 static unsigned int tv_range[2] = { 44, 958 };
146 static unsigned int radio_range[2] = { 65, 108 };
148 static char pal[] = "--";
149 static char secam[] = "--";
150 static char ntsc[] = "-";
153 module_param(addr, int, 0444);
154 module_param(no_autodetect, int, 0444);
155 module_param(show_i2c, int, 0444);
156 module_param_named(debug,tuner_debug, int, 0644);
157 module_param_string(pal, pal, sizeof(pal), 0644);
158 module_param_string(secam, secam, sizeof(secam), 0644);
159 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
160 module_param_array(tv_range, int, NULL, 0644);
161 module_param_array(radio_range, int, NULL, 0644);
163 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
164 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
165 MODULE_LICENSE("GPL");
167 /* ---------------------------------------------------------------------- */
169 static void fe_set_params(struct dvb_frontend *fe,
170 struct analog_parameters *params)
172 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
173 struct tuner *t = fe->analog_demod_priv;
175 if (NULL == fe_tuner_ops->set_analog_params) {
176 tuner_warn("Tuner frontend module has no way to set freq\n");
179 fe_tuner_ops->set_analog_params(fe, params);
182 static void fe_standby(struct dvb_frontend *fe)
184 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
186 if (fe_tuner_ops->sleep)
187 fe_tuner_ops->sleep(fe);
190 static int fe_has_signal(struct dvb_frontend *fe)
194 if (fe->ops.tuner_ops.get_rf_strength)
195 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
200 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
202 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
203 struct tuner *t = fe->analog_demod_priv;
205 if (fe_tuner_ops->set_config)
206 return fe_tuner_ops->set_config(fe, priv_cfg);
208 tuner_warn("Tuner frontend module has no way to set config\n");
213 static void tuner_status(struct dvb_frontend *fe);
215 static struct analog_demod_ops tuner_core_ops = {
216 .set_params = fe_set_params,
217 .standby = fe_standby,
218 .has_signal = fe_has_signal,
219 .set_config = fe_set_config,
220 .tuner_status = tuner_status
223 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
224 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
226 struct tuner *t = i2c_get_clientdata(c);
227 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
229 struct analog_parameters params = {
231 .audmode = t->audmode,
235 if (t->type == UNSET) {
236 tuner_warn ("tuner type not set\n");
239 if (NULL == analog_ops->set_params) {
240 tuner_warn ("Tuner has no way to set tv freq\n");
243 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
244 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
245 freq / 16, freq % 16 * 100 / 16, tv_range[0],
247 /* V4L2 spec: if the freq is not possible then the closest
248 possible value should be selected */
249 if (freq < tv_range[0] * 16)
250 freq = tv_range[0] * 16;
252 freq = tv_range[1] * 16;
254 params.frequency = freq;
256 analog_ops->set_params(&t->fe, ¶ms);
259 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
261 struct tuner *t = i2c_get_clientdata(c);
262 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
264 struct analog_parameters params = {
266 .audmode = t->audmode,
270 if (t->type == UNSET) {
271 tuner_warn ("tuner type not set\n");
274 if (NULL == analog_ops->set_params) {
275 tuner_warn ("tuner has no way to set radio frequency\n");
278 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
279 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
280 freq / 16000, freq % 16000 * 100 / 16000,
281 radio_range[0], radio_range[1]);
282 /* V4L2 spec: if the freq is not possible then the closest
283 possible value should be selected */
284 if (freq < radio_range[0] * 16000)
285 freq = radio_range[0] * 16000;
287 freq = radio_range[1] * 16000;
289 params.frequency = freq;
291 analog_ops->set_params(&t->fe, ¶ms);
294 static void set_freq(struct i2c_client *c, unsigned long freq)
296 struct tuner *t = i2c_get_clientdata(c);
299 case V4L2_TUNER_RADIO:
300 tuner_dbg("radio freq set to %lu.%02lu\n",
301 freq / 16000, freq % 16000 * 100 / 16000);
302 set_radio_freq(c, freq);
303 t->radio_freq = freq;
305 case V4L2_TUNER_ANALOG_TV:
306 case V4L2_TUNER_DIGITAL_TV:
307 tuner_dbg("tv freq set to %lu.%02lu\n",
308 freq / 16, freq % 16 * 100 / 16);
309 set_tv_freq(c, freq);
313 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
317 static void tuner_i2c_address_check(struct tuner *t)
319 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
320 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
323 /* We already know that the XC5000 can only be located at
324 * i2c address 0x61, 0x62, 0x63 or 0x64 */
325 if ((t->type == TUNER_XC5000) &&
326 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
329 tuner_warn("====================== WARNING! ======================\n");
330 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
331 tuner_warn("will soon be dropped. This message indicates that your\n");
332 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
333 t->i2c->name, t->i2c->addr);
334 tuner_warn("To ensure continued support for your device, please\n");
335 tuner_warn("send a copy of this message, along with full dmesg\n");
336 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
337 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
338 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
339 t->i2c->adapter->name, t->i2c->addr, t->type, t->i2c->name);
340 tuner_warn("====================== WARNING! ======================\n");
343 static struct xc5000_config xc5000_cfg;
345 static void set_type(struct i2c_client *c, unsigned int type,
346 unsigned int new_mode_mask, unsigned int new_config,
347 int (*tuner_callback) (void *dev, int command,int arg))
349 struct tuner *t = i2c_get_clientdata(c);
350 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
351 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
352 unsigned char buffer[4];
354 if (type == UNSET || type == TUNER_ABSENT) {
355 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
360 t->config = new_config;
361 if (tuner_callback != NULL) {
362 tuner_dbg("defining GPIO callback\n");
363 t->tuner_callback = tuner_callback;
366 if (t->mode == T_UNINITIALIZED) {
367 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
372 /* discard private data, in case set_type() was previously called */
373 tuner_detach(&t->fe);
374 t->fe.analog_demod_priv = NULL;
378 if (!dvb_attach(microtune_attach,
379 &t->fe, t->i2c->adapter, t->i2c->addr))
382 case TUNER_PHILIPS_TDA8290:
384 struct tda829x_config cfg = {
385 .lna_cfg = t->config,
386 .tuner_callback = t->tuner_callback,
388 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
394 if (!dvb_attach(tea5767_attach, &t->fe,
395 t->i2c->adapter, t->i2c->addr))
397 t->mode_mask = T_RADIO;
400 if (!dvb_attach(tea5761_attach, &t->fe,
401 t->i2c->adapter, t->i2c->addr))
403 t->mode_mask = T_RADIO;
405 case TUNER_PHILIPS_FMD1216ME_MK3:
410 i2c_master_send(c, buffer, 4);
414 i2c_master_send(c, buffer, 4);
415 if (!dvb_attach(simple_tuner_attach, &t->fe,
416 t->i2c->adapter, t->i2c->addr, t->type))
419 case TUNER_PHILIPS_TD1316:
424 i2c_master_send(c, buffer, 4);
425 if (!dvb_attach(simple_tuner_attach, &t->fe,
426 t->i2c->adapter, t->i2c->addr, t->type))
431 struct xc2028_config cfg = {
432 .i2c_adap = t->i2c->adapter,
433 .i2c_addr = t->i2c->addr,
434 .callback = t->tuner_callback,
436 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
441 if (!dvb_attach(tda9887_attach,
442 &t->fe, t->i2c->adapter, t->i2c->addr))
447 struct dvb_tuner_ops *xc_tuner_ops;
449 xc5000_cfg.i2c_address = t->i2c->addr;
450 xc5000_cfg.if_khz = 5380;
451 xc5000_cfg.tuner_callback = t->tuner_callback;
452 if (!dvb_attach(xc5000_attach,
453 &t->fe, t->i2c->adapter, &xc5000_cfg,
454 c->adapter->algo_data))
457 xc_tuner_ops = &t->fe.ops.tuner_ops;
458 if (xc_tuner_ops->init)
459 xc_tuner_ops->init(&t->fe);
463 if (!dvb_attach(simple_tuner_attach, &t->fe,
464 t->i2c->adapter, t->i2c->addr, t->type))
470 if ((NULL == analog_ops->set_params) &&
471 (fe_tuner_ops->set_analog_params)) {
473 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
474 sizeof(t->i2c->name));
476 t->fe.analog_demod_priv = t;
477 memcpy(analog_ops, &tuner_core_ops,
478 sizeof(struct analog_demod_ops));
481 strlcpy(t->i2c->name, analog_ops->info.name,
482 sizeof(t->i2c->name));
485 tuner_dbg("type set to %s\n", t->i2c->name);
487 if (t->mode_mask == T_UNINITIALIZED)
488 t->mode_mask = new_mode_mask;
490 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
491 trying to set a frequency here will just fail
492 FIXME: better to move set_freq to the tuner code. This is needed
493 on analog tuners for PLL to properly work
495 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
496 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
497 t->radio_freq : t->tv_freq);
499 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
500 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
502 tuner_i2c_address_check(t);
506 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
507 t->type = TUNER_ABSENT;
508 t->mode_mask = T_UNINITIALIZED;
514 * This function apply tuner config to tuner specified
515 * by tun_setup structure. I addr is unset, then admin status
516 * and tun addr status is more precise then current status,
517 * it's applied. Otherwise status and type are applied only to
518 * tuner with exactly the same addr.
521 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
523 struct tuner *t = i2c_get_clientdata(c);
525 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
526 (t->mode_mask & tun_setup->mode_mask))) ||
527 (tun_setup->addr == c->addr)) {
528 set_type(c, tun_setup->type, tun_setup->mode_mask,
529 tun_setup->config, tun_setup->tuner_callback);
531 tuner_dbg("set addr discarded for type %i, mask %x. "
532 "Asked to change tuner at addr 0x%02x, with mask %x\n",
533 t->type, t->mode_mask,
534 tun_setup->addr, tun_setup->mode_mask);
537 static inline int check_mode(struct tuner *t, char *cmd)
539 if ((1 << t->mode & t->mode_mask) == 0) {
544 case V4L2_TUNER_RADIO:
545 tuner_dbg("Cmd %s accepted for radio\n", cmd);
547 case V4L2_TUNER_ANALOG_TV:
548 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
550 case V4L2_TUNER_DIGITAL_TV:
551 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
557 /* get more precise norm info from insmod option */
558 static int tuner_fixup_std(struct tuner *t)
560 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
563 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
564 t->std = V4L2_STD_PAL_60;
570 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
571 t->std = V4L2_STD_PAL_BG;
575 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
576 t->std = V4L2_STD_PAL_I;
582 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
583 t->std = V4L2_STD_PAL_DK;
587 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
588 t->std = V4L2_STD_PAL_M;
592 if (pal[1] == 'c' || pal[1] == 'C') {
593 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
594 t->std = V4L2_STD_PAL_Nc;
596 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
597 t->std = V4L2_STD_PAL_N;
601 /* default parameter, do nothing */
604 tuner_warn ("pal= argument not recognised\n");
608 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
616 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
617 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
623 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
624 t->std = V4L2_STD_SECAM_DK;
628 if ((secam[1]=='C')||(secam[1]=='c')) {
629 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
630 t->std = V4L2_STD_SECAM_LC;
632 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
633 t->std = V4L2_STD_SECAM_L;
637 /* default parameter, do nothing */
640 tuner_warn ("secam= argument not recognised\n");
645 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
649 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
650 t->std = V4L2_STD_NTSC_M;
654 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
655 t->std = V4L2_STD_NTSC_M_JP;
659 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
660 t->std = V4L2_STD_NTSC_M_KR;
663 /* default parameter, do nothing */
666 tuner_info("ntsc= argument not recognised\n");
673 static void tuner_status(struct dvb_frontend *fe)
675 struct tuner *t = fe->analog_demod_priv;
676 unsigned long freq, freq_fraction;
677 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
678 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
682 case V4L2_TUNER_RADIO: p = "radio"; break;
683 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
684 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
685 default: p = "undefined"; break;
687 if (t->mode == V4L2_TUNER_RADIO) {
688 freq = t->radio_freq / 16000;
689 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
691 freq = t->tv_freq / 16;
692 freq_fraction = (t->tv_freq % 16) * 100 / 16;
694 tuner_info("Tuner mode: %s\n", p);
695 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
696 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
697 if (t->mode != V4L2_TUNER_RADIO)
699 if (fe_tuner_ops->get_status) {
702 fe_tuner_ops->get_status(&t->fe, &tuner_status);
703 if (tuner_status & TUNER_STATUS_LOCKED)
704 tuner_info("Tuner is locked.\n");
705 if (tuner_status & TUNER_STATUS_STEREO)
706 tuner_info("Stereo: yes\n");
708 if (analog_ops->has_signal)
709 tuner_info("Signal strength: %d\n",
710 analog_ops->has_signal(fe));
711 if (analog_ops->is_stereo)
712 tuner_info("Stereo: %s\n",
713 analog_ops->is_stereo(fe) ? "yes" : "no");
716 /* ---------------------------------------------------------------------- */
719 * Switch tuner to other mode. If tuner support both tv and radio,
720 * set another frequency to some value (This is needed for some pal
721 * tuners to avoid locking). Otherwise, just put second tuner in
725 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
727 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
734 if (check_mode(t, cmd) == EINVAL) {
736 if (analog_ops->standby)
737 analog_ops->standby(&t->fe);
743 #define switch_v4l2() if (!t->using_v4l2) \
744 tuner_dbg("switching to v4l2\n"); \
747 static inline int check_v4l2(struct tuner *t)
749 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
750 TV, v4l1 for radio), until that is fixed this code is disabled.
751 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
756 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
758 struct tuner *t = i2c_get_clientdata(client);
759 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
760 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
762 if (tuner_debug > 1) {
763 v4l_i2c_print_ioctl(client,cmd);
768 /* --- configuration --- */
769 case TUNER_SET_TYPE_ADDR:
770 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
771 ((struct tuner_setup *)arg)->type,
772 ((struct tuner_setup *)arg)->addr,
773 ((struct tuner_setup *)arg)->mode_mask,
774 ((struct tuner_setup *)arg)->config);
776 set_addr(client, (struct tuner_setup *)arg);
779 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
783 set_freq(client, t->radio_freq);
785 case TUNER_SET_STANDBY:
786 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
789 if (analog_ops->standby)
790 analog_ops->standby(&t->fe);
792 #ifdef CONFIG_VIDEO_ALLOW_V4L1
794 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
796 if (check_v4l2(t) == EINVAL)
799 /* Should be implemented, since bttv calls it */
800 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
804 static const v4l2_std_id map[] = {
805 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
806 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
807 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
808 [4 /* bttv */ ] = V4L2_STD_PAL_M,
809 [5 /* bttv */ ] = V4L2_STD_PAL_N,
810 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
812 struct video_channel *vc = arg;
814 if (check_v4l2(t) == EINVAL)
817 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
820 if (vc->norm < ARRAY_SIZE(map))
821 t->std = map[vc->norm];
824 set_tv_freq(client, t->tv_freq);
829 unsigned long *v = arg;
831 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
833 if (check_v4l2(t) == EINVAL)
836 set_freq(client, *v);
841 struct video_tuner *vt = arg;
843 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
845 if (check_v4l2(t) == EINVAL)
848 if (V4L2_TUNER_RADIO == t->mode) {
849 if (fe_tuner_ops->get_status) {
852 fe_tuner_ops->get_status(&t->fe, &tuner_status);
853 if (tuner_status & TUNER_STATUS_STEREO)
854 vt->flags |= VIDEO_TUNER_STEREO_ON;
856 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
858 if (analog_ops->is_stereo) {
859 if (analog_ops->is_stereo(&t->fe))
861 VIDEO_TUNER_STEREO_ON;
864 ~VIDEO_TUNER_STEREO_ON;
867 if (analog_ops->has_signal)
869 analog_ops->has_signal(&t->fe);
871 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
873 vt->rangelow = radio_range[0] * 16000;
874 vt->rangehigh = radio_range[1] * 16000;
877 vt->rangelow = tv_range[0] * 16;
878 vt->rangehigh = tv_range[1] * 16;
885 struct video_audio *va = arg;
887 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
889 if (check_v4l2(t) == EINVAL)
892 if (V4L2_TUNER_RADIO == t->mode) {
893 if (fe_tuner_ops->get_status) {
896 fe_tuner_ops->get_status(&t->fe, &tuner_status);
897 va->mode = (tuner_status & TUNER_STATUS_STEREO)
898 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
899 } else if (analog_ops->is_stereo)
900 va->mode = analog_ops->is_stereo(&t->fe)
901 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
906 case TUNER_SET_CONFIG:
908 struct v4l2_priv_tun_config *cfg = arg;
910 if (t->type != cfg->tuner)
913 if (analog_ops->set_config) {
914 analog_ops->set_config(&t->fe, cfg->priv);
918 tuner_dbg("Tuner frontend module has no way to set config\n");
921 /* --- v4l ioctls --- */
922 /* take care: bttv does userspace copying, we'll get a
923 kernel pointer here... */
926 v4l2_std_id *id = arg;
928 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
937 set_freq(client, t->tv_freq);
940 case VIDIOC_S_FREQUENCY:
942 struct v4l2_frequency *f = arg;
944 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
948 set_freq(client,f->frequency);
952 case VIDIOC_G_FREQUENCY:
954 struct v4l2_frequency *f = arg;
956 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
960 if (fe_tuner_ops->get_frequency) {
963 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
964 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
965 (abs_freq * 2 + 125/2) / 125 :
966 (abs_freq + 62500/2) / 62500;
969 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
970 t->radio_freq : t->tv_freq;
975 struct v4l2_tuner *tuner = arg;
977 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
981 tuner->type = t->mode;
982 if (analog_ops->get_afc)
983 tuner->afc = analog_ops->get_afc(&t->fe);
984 if (t->mode == V4L2_TUNER_ANALOG_TV)
985 tuner->capability |= V4L2_TUNER_CAP_NORM;
986 if (t->mode != V4L2_TUNER_RADIO) {
987 tuner->rangelow = tv_range[0] * 16;
988 tuner->rangehigh = tv_range[1] * 16;
994 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
995 if (fe_tuner_ops->get_status) {
998 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1000 (tuner_status & TUNER_STATUS_STEREO) ?
1001 V4L2_TUNER_SUB_STEREO :
1002 V4L2_TUNER_SUB_MONO;
1004 if (analog_ops->is_stereo) {
1006 analog_ops->is_stereo(&t->fe) ?
1007 V4L2_TUNER_SUB_STEREO :
1008 V4L2_TUNER_SUB_MONO;
1011 if (analog_ops->has_signal)
1012 tuner->signal = analog_ops->has_signal(&t->fe);
1013 tuner->capability |=
1014 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1015 tuner->audmode = t->audmode;
1016 tuner->rangelow = radio_range[0] * 16000;
1017 tuner->rangehigh = radio_range[1] * 16000;
1020 case VIDIOC_S_TUNER:
1022 struct v4l2_tuner *tuner = arg;
1024 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1029 /* do nothing unless we're a radio tuner */
1030 if (t->mode != V4L2_TUNER_RADIO)
1032 t->audmode = tuner->audmode;
1033 set_radio_freq(client, t->radio_freq);
1036 case VIDIOC_LOG_STATUS:
1037 if (analog_ops->tuner_status)
1038 analog_ops->tuner_status(&t->fe);
1045 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1047 struct tuner *t = i2c_get_clientdata(c);
1049 tuner_dbg("suspend\n");
1050 /* FIXME: power down ??? */
1054 static int tuner_resume(struct i2c_client *c)
1056 struct tuner *t = i2c_get_clientdata(c);
1058 tuner_dbg("resume\n");
1059 if (V4L2_TUNER_RADIO == t->mode) {
1061 set_freq(c, t->radio_freq);
1064 set_freq(c, t->tv_freq);
1069 /* ---------------------------------------------------------------------- */
1071 static LIST_HEAD(tuner_list);
1073 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1074 Note that when this function is called from tuner_probe you can be
1075 certain no other devices will be added/deleted at the same time, I2C
1076 core protects against that. */
1077 static void tuner_lookup(struct i2c_adapter *adap,
1078 struct tuner **radio, struct tuner **tv)
1085 list_for_each_entry(pos, &tuner_list, list) {
1088 if (pos->i2c->adapter != adap ||
1089 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1092 mode_mask = pos->mode_mask & ~T_STANDBY;
1093 if (*radio == NULL && mode_mask == T_RADIO)
1095 /* Note: currently TDA9887 is the only demod-only
1096 device. If other devices appear then we need to
1097 make this test more general. */
1098 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1099 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1104 /* During client attach, set_type is called by adapter's attach_inform callback.
1105 set_type must then be completed by tuner_probe.
1107 static int tuner_probe(struct i2c_client *client,
1108 const struct i2c_device_id *id)
1111 struct tuner *radio;
1114 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1118 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1119 i2c_set_clientdata(client, t);
1121 t->audmode = V4L2_TUNER_MODE_STEREO;
1122 t->mode_mask = T_UNINITIALIZED;
1125 unsigned char buffer[16];
1128 memset(buffer, 0, sizeof(buffer));
1129 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1130 tuner_info("I2C RECV = ");
1131 for (i = 0; i < rc; i++)
1132 printk(KERN_CONT "%02x ", buffer[i]);
1135 /* HACK: This test was added to avoid tuner to probe tda9840 and
1136 tea6415c on the MXB card */
1137 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1142 /* autodetection code based on the i2c addr */
1143 if (!no_autodetect) {
1144 switch (client->addr) {
1146 if (tuner_symbol_probe(tea5761_autodetection,
1148 t->i2c->addr) >= 0) {
1149 t->type = TUNER_TEA5761;
1150 t->mode_mask = T_RADIO;
1151 t->mode = T_STANDBY;
1152 /* Sets freq to FM range */
1153 t->radio_freq = 87.5 * 16000;
1154 tuner_lookup(t->i2c->adapter, &radio, &tv);
1156 tv->mode_mask &= ~T_RADIO;
1158 goto register_client;
1165 /* If chip is not tda8290, don't register.
1166 since it can be tda9887*/
1167 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1168 t->i2c->addr) >= 0) {
1169 tuner_dbg("tda829x detected\n");
1171 /* Default is being tda9887 */
1172 t->type = TUNER_TDA9887;
1173 t->mode_mask = T_RADIO | T_ANALOG_TV |
1175 t->mode = T_STANDBY;
1176 goto register_client;
1180 if (tuner_symbol_probe(tea5767_autodetection,
1181 t->i2c->adapter, t->i2c->addr)
1183 t->type = TUNER_TEA5767;
1184 t->mode_mask = T_RADIO;
1185 t->mode = T_STANDBY;
1186 /* Sets freq to FM range */
1187 t->radio_freq = 87.5 * 16000;
1188 tuner_lookup(t->i2c->adapter, &radio, &tv);
1190 tv->mode_mask &= ~T_RADIO;
1192 goto register_client;
1198 /* Initializes only the first TV tuner on this adapter. Why only the
1199 first? Because there are some devices (notably the ones with TI
1200 tuners) that have more than one i2c address for the *same* device.
1201 Experience shows that, except for just one case, the first
1202 address is the right one. The exception is a Russian tuner
1203 (ACORP_Y878F). So, the desired behavior is just to enable the
1204 first found TV tuner. */
1205 tuner_lookup(t->i2c->adapter, &radio, &tv);
1207 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1209 t->mode_mask |= T_RADIO;
1210 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1211 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1212 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1215 /* Should be just before return */
1217 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1218 client->adapter->name);
1220 /* Sets a default mode */
1221 if (t->mode_mask & T_ANALOG_TV) {
1222 t->mode = V4L2_TUNER_ANALOG_TV;
1223 } else if (t->mode_mask & T_RADIO) {
1224 t->mode = V4L2_TUNER_RADIO;
1226 t->mode = V4L2_TUNER_DIGITAL_TV;
1228 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1229 list_add_tail(&t->list, &tuner_list);
1233 static int tuner_legacy_probe(struct i2c_adapter *adap)
1236 normal_i2c[0] = addr;
1237 normal_i2c[1] = I2C_CLIENT_END;
1240 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1243 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1244 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1245 * and an RTC at 0x6f which can get corrupted if probed.
1247 if ((adap->id == I2C_HW_B_CX2388x) ||
1248 (adap->id == I2C_HW_B_CX23885)) {
1251 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1253 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1254 ignore[i+0] = adap->nr;
1256 ignore[i+2] = adap->nr;
1258 ignore[i+4] = I2C_CLIENT_END;
1260 printk(KERN_WARNING "tuner: "
1261 "too many options specified "
1262 "in i2c probe ignore list!\n");
1267 static int tuner_remove(struct i2c_client *client)
1269 struct tuner *t = i2c_get_clientdata(client);
1271 tuner_detach(&t->fe);
1272 t->fe.analog_demod_priv = NULL;
1279 /* ----------------------------------------------------------------------- */
1281 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1283 .driverid = I2C_DRIVERID_TUNER,
1284 .command = tuner_command,
1285 .probe = tuner_probe,
1286 .remove = tuner_remove,
1287 .suspend = tuner_suspend,
1288 .resume = tuner_resume,
1289 .legacy_probe = tuner_legacy_probe,
1294 * Overrides for Emacs so that we follow Linus's tabbing style.
1295 * ---------------------------------------------------------------------------