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-ioctl.h>
23 #include <media/v4l2-i2c-drv-legacy.h>
28 #include "tuner-xc2028.h"
29 #include "tuner-simple.h"
35 #define PREFIX t->i2c->driver->driver.name
37 /** This macro allows us to probe dynamically, avoiding static links */
38 #ifdef CONFIG_MEDIA_ATTACH
39 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
41 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
43 __r = (int) __a(ARGS); \
44 symbol_put(FUNCTION); \
46 printk(KERN_ERR "TUNER: Unable to find " \
47 "symbol "#FUNCTION"()\n"); \
52 static void tuner_detach(struct dvb_frontend *fe)
54 if (fe->ops.tuner_ops.release) {
55 fe->ops.tuner_ops.release(fe);
56 symbol_put_addr(fe->ops.tuner_ops.release);
58 if (fe->ops.analog_ops.release) {
59 fe->ops.analog_ops.release(fe);
60 symbol_put_addr(fe->ops.analog_ops.release);
64 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
68 static void tuner_detach(struct dvb_frontend *fe)
70 if (fe->ops.tuner_ops.release)
71 fe->ops.tuner_ops.release(fe);
72 if (fe->ops.analog_ops.release)
73 fe->ops.analog_ops.release(fe);
79 struct dvb_frontend fe;
80 struct i2c_client *i2c;
81 struct list_head list;
82 unsigned int using_v4l2:1;
84 /* keep track of the current settings */
87 unsigned int radio_freq;
91 unsigned int mode_mask; /* Combination of allowable modes */
93 unsigned int type; /* chip type id */
95 int (*tuner_callback) (void *dev, int command, int arg);
99 /* standard i2c insmod options */
100 static unsigned short normal_i2c[] = {
101 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
104 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
105 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
106 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
112 /* insmod options used at init time => read/only */
113 static unsigned int addr;
114 static unsigned int no_autodetect;
115 static unsigned int show_i2c;
117 /* insmod options used at runtime => read/write */
118 static int tuner_debug;
120 #define tuner_warn(fmt, arg...) do { \
121 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
122 i2c_adapter_id(t->i2c->adapter), \
123 t->i2c->addr, ##arg); \
126 #define tuner_info(fmt, arg...) do { \
127 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
128 i2c_adapter_id(t->i2c->adapter), \
129 t->i2c->addr, ##arg); \
132 #define tuner_err(fmt, arg...) do { \
133 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
134 i2c_adapter_id(t->i2c->adapter), \
135 t->i2c->addr, ##arg); \
138 #define tuner_dbg(fmt, arg...) do { \
140 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
141 i2c_adapter_id(t->i2c->adapter), \
142 t->i2c->addr, ##arg); \
145 /* ------------------------------------------------------------------------ */
147 static unsigned int tv_range[2] = { 44, 958 };
148 static unsigned int radio_range[2] = { 65, 108 };
150 static char pal[] = "--";
151 static char secam[] = "--";
152 static char ntsc[] = "-";
155 module_param(addr, int, 0444);
156 module_param(no_autodetect, int, 0444);
157 module_param(show_i2c, int, 0444);
158 module_param_named(debug,tuner_debug, int, 0644);
159 module_param_string(pal, pal, sizeof(pal), 0644);
160 module_param_string(secam, secam, sizeof(secam), 0644);
161 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
162 module_param_array(tv_range, int, NULL, 0644);
163 module_param_array(radio_range, int, NULL, 0644);
165 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
166 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
167 MODULE_LICENSE("GPL");
169 /* ---------------------------------------------------------------------- */
171 static void fe_set_params(struct dvb_frontend *fe,
172 struct analog_parameters *params)
174 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
175 struct tuner *t = fe->analog_demod_priv;
177 if (NULL == fe_tuner_ops->set_analog_params) {
178 tuner_warn("Tuner frontend module has no way to set freq\n");
181 fe_tuner_ops->set_analog_params(fe, params);
184 static void fe_standby(struct dvb_frontend *fe)
186 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
188 if (fe_tuner_ops->sleep)
189 fe_tuner_ops->sleep(fe);
192 static int fe_has_signal(struct dvb_frontend *fe)
196 if (fe->ops.tuner_ops.get_rf_strength)
197 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
202 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
204 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
205 struct tuner *t = fe->analog_demod_priv;
207 if (fe_tuner_ops->set_config)
208 return fe_tuner_ops->set_config(fe, priv_cfg);
210 tuner_warn("Tuner frontend module has no way to set config\n");
215 static void tuner_status(struct dvb_frontend *fe);
217 static struct analog_demod_ops tuner_core_ops = {
218 .set_params = fe_set_params,
219 .standby = fe_standby,
220 .has_signal = fe_has_signal,
221 .set_config = fe_set_config,
222 .tuner_status = tuner_status
225 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
226 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
228 struct tuner *t = i2c_get_clientdata(c);
229 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
231 struct analog_parameters params = {
233 .audmode = t->audmode,
237 if (t->type == UNSET) {
238 tuner_warn ("tuner type not set\n");
241 if (NULL == analog_ops->set_params) {
242 tuner_warn ("Tuner has no way to set tv freq\n");
245 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
246 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
247 freq / 16, freq % 16 * 100 / 16, tv_range[0],
249 /* V4L2 spec: if the freq is not possible then the closest
250 possible value should be selected */
251 if (freq < tv_range[0] * 16)
252 freq = tv_range[0] * 16;
254 freq = tv_range[1] * 16;
256 params.frequency = freq;
258 analog_ops->set_params(&t->fe, ¶ms);
261 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
263 struct tuner *t = i2c_get_clientdata(c);
264 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
266 struct analog_parameters params = {
268 .audmode = t->audmode,
272 if (t->type == UNSET) {
273 tuner_warn ("tuner type not set\n");
276 if (NULL == analog_ops->set_params) {
277 tuner_warn ("tuner has no way to set radio frequency\n");
280 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
281 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
282 freq / 16000, freq % 16000 * 100 / 16000,
283 radio_range[0], radio_range[1]);
284 /* V4L2 spec: if the freq is not possible then the closest
285 possible value should be selected */
286 if (freq < radio_range[0] * 16000)
287 freq = radio_range[0] * 16000;
289 freq = radio_range[1] * 16000;
291 params.frequency = freq;
293 analog_ops->set_params(&t->fe, ¶ms);
296 static void set_freq(struct i2c_client *c, unsigned long freq)
298 struct tuner *t = i2c_get_clientdata(c);
301 case V4L2_TUNER_RADIO:
302 tuner_dbg("radio freq set to %lu.%02lu\n",
303 freq / 16000, freq % 16000 * 100 / 16000);
304 set_radio_freq(c, freq);
305 t->radio_freq = freq;
307 case V4L2_TUNER_ANALOG_TV:
308 case V4L2_TUNER_DIGITAL_TV:
309 tuner_dbg("tv freq set to %lu.%02lu\n",
310 freq / 16, freq % 16 * 100 / 16);
311 set_tv_freq(c, freq);
315 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
319 static void tuner_i2c_address_check(struct tuner *t)
321 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
322 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
325 /* We already know that the XC5000 can only be located at
326 * i2c address 0x61, 0x62, 0x63 or 0x64 */
327 if ((t->type == TUNER_XC5000) &&
328 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
331 tuner_warn("====================== WARNING! ======================\n");
332 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
333 tuner_warn("will soon be dropped. This message indicates that your\n");
334 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
335 t->name, t->i2c->addr);
336 tuner_warn("To ensure continued support for your device, please\n");
337 tuner_warn("send a copy of this message, along with full dmesg\n");
338 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
339 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
340 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
341 t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
342 tuner_warn("====================== WARNING! ======================\n");
345 static struct xc5000_config xc5000_cfg;
347 static void set_type(struct i2c_client *c, unsigned int type,
348 unsigned int new_mode_mask, unsigned int new_config,
349 int (*tuner_callback) (void *dev, int command,int arg))
351 struct tuner *t = i2c_get_clientdata(c);
352 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
353 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
354 unsigned char buffer[4];
356 if (type == UNSET || type == TUNER_ABSENT) {
357 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
362 t->config = new_config;
363 if (tuner_callback != NULL) {
364 tuner_dbg("defining GPIO callback\n");
365 t->tuner_callback = tuner_callback;
368 if (t->mode == T_UNINITIALIZED) {
369 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
374 /* discard private data, in case set_type() was previously called */
375 tuner_detach(&t->fe);
376 t->fe.analog_demod_priv = NULL;
380 if (!dvb_attach(microtune_attach,
381 &t->fe, t->i2c->adapter, t->i2c->addr))
384 case TUNER_PHILIPS_TDA8290:
386 struct tda829x_config cfg = {
387 .lna_cfg = t->config,
388 .tuner_callback = t->tuner_callback,
390 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
396 if (!dvb_attach(tea5767_attach, &t->fe,
397 t->i2c->adapter, t->i2c->addr))
399 t->mode_mask = T_RADIO;
402 if (!dvb_attach(tea5761_attach, &t->fe,
403 t->i2c->adapter, t->i2c->addr))
405 t->mode_mask = T_RADIO;
407 case TUNER_PHILIPS_FMD1216ME_MK3:
412 i2c_master_send(c, buffer, 4);
416 i2c_master_send(c, buffer, 4);
417 if (!dvb_attach(simple_tuner_attach, &t->fe,
418 t->i2c->adapter, t->i2c->addr, t->type))
421 case TUNER_PHILIPS_TD1316:
426 i2c_master_send(c, buffer, 4);
427 if (!dvb_attach(simple_tuner_attach, &t->fe,
428 t->i2c->adapter, t->i2c->addr, t->type))
433 struct xc2028_config cfg = {
434 .i2c_adap = t->i2c->adapter,
435 .i2c_addr = t->i2c->addr,
436 .callback = t->tuner_callback,
438 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
443 if (!dvb_attach(tda9887_attach,
444 &t->fe, t->i2c->adapter, t->i2c->addr))
449 struct dvb_tuner_ops *xc_tuner_ops;
451 xc5000_cfg.i2c_address = t->i2c->addr;
452 xc5000_cfg.if_khz = 5380;
453 xc5000_cfg.tuner_callback = t->tuner_callback;
454 if (!dvb_attach(xc5000_attach,
455 &t->fe, t->i2c->adapter, &xc5000_cfg))
458 xc_tuner_ops = &t->fe.ops.tuner_ops;
459 if (xc_tuner_ops->init)
460 xc_tuner_ops->init(&t->fe);
464 if (!dvb_attach(simple_tuner_attach, &t->fe,
465 t->i2c->adapter, t->i2c->addr, t->type))
471 if ((NULL == analog_ops->set_params) &&
472 (fe_tuner_ops->set_analog_params)) {
474 t->name = fe_tuner_ops->info.name;
476 t->fe.analog_demod_priv = t;
477 memcpy(analog_ops, &tuner_core_ops,
478 sizeof(struct analog_demod_ops));
481 t->name = analog_ops->info.name;
484 tuner_dbg("type set to %s\n", t->name);
486 if (t->mode_mask == T_UNINITIALIZED)
487 t->mode_mask = new_mode_mask;
489 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
490 trying to set a frequency here will just fail
491 FIXME: better to move set_freq to the tuner code. This is needed
492 on analog tuners for PLL to properly work
494 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
495 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
496 t->radio_freq : t->tv_freq);
498 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
499 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
501 tuner_i2c_address_check(t);
505 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
506 t->type = TUNER_ABSENT;
507 t->mode_mask = T_UNINITIALIZED;
513 * This function apply tuner config to tuner specified
514 * by tun_setup structure. I addr is unset, then admin status
515 * and tun addr status is more precise then current status,
516 * it's applied. Otherwise status and type are applied only to
517 * tuner with exactly the same addr.
520 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
522 struct tuner *t = i2c_get_clientdata(c);
524 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
525 (t->mode_mask & tun_setup->mode_mask))) ||
526 (tun_setup->addr == c->addr)) {
527 set_type(c, tun_setup->type, tun_setup->mode_mask,
528 tun_setup->config, tun_setup->tuner_callback);
530 tuner_dbg("set addr discarded for type %i, mask %x. "
531 "Asked to change tuner at addr 0x%02x, with mask %x\n",
532 t->type, t->mode_mask,
533 tun_setup->addr, tun_setup->mode_mask);
536 static inline int check_mode(struct tuner *t, char *cmd)
538 if ((1 << t->mode & t->mode_mask) == 0) {
543 case V4L2_TUNER_RADIO:
544 tuner_dbg("Cmd %s accepted for radio\n", cmd);
546 case V4L2_TUNER_ANALOG_TV:
547 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
549 case V4L2_TUNER_DIGITAL_TV:
550 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
556 /* get more precise norm info from insmod option */
557 static int tuner_fixup_std(struct tuner *t)
559 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
562 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
563 t->std = V4L2_STD_PAL_60;
569 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
570 t->std = V4L2_STD_PAL_BG;
574 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
575 t->std = V4L2_STD_PAL_I;
581 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
582 t->std = V4L2_STD_PAL_DK;
586 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
587 t->std = V4L2_STD_PAL_M;
591 if (pal[1] == 'c' || pal[1] == 'C') {
592 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
593 t->std = V4L2_STD_PAL_Nc;
595 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
596 t->std = V4L2_STD_PAL_N;
600 /* default parameter, do nothing */
603 tuner_warn ("pal= argument not recognised\n");
607 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
615 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
616 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
622 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
623 t->std = V4L2_STD_SECAM_DK;
627 if ((secam[1]=='C')||(secam[1]=='c')) {
628 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
629 t->std = V4L2_STD_SECAM_LC;
631 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
632 t->std = V4L2_STD_SECAM_L;
636 /* default parameter, do nothing */
639 tuner_warn ("secam= argument not recognised\n");
644 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
648 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
649 t->std = V4L2_STD_NTSC_M;
653 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
654 t->std = V4L2_STD_NTSC_M_JP;
658 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
659 t->std = V4L2_STD_NTSC_M_KR;
662 /* default parameter, do nothing */
665 tuner_info("ntsc= argument not recognised\n");
672 static void tuner_status(struct dvb_frontend *fe)
674 struct tuner *t = fe->analog_demod_priv;
675 unsigned long freq, freq_fraction;
676 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
677 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
681 case V4L2_TUNER_RADIO: p = "radio"; break;
682 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
683 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
684 default: p = "undefined"; break;
686 if (t->mode == V4L2_TUNER_RADIO) {
687 freq = t->radio_freq / 16000;
688 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
690 freq = t->tv_freq / 16;
691 freq_fraction = (t->tv_freq % 16) * 100 / 16;
693 tuner_info("Tuner mode: %s\n", p);
694 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
695 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
696 if (t->mode != V4L2_TUNER_RADIO)
698 if (fe_tuner_ops->get_status) {
701 fe_tuner_ops->get_status(&t->fe, &tuner_status);
702 if (tuner_status & TUNER_STATUS_LOCKED)
703 tuner_info("Tuner is locked.\n");
704 if (tuner_status & TUNER_STATUS_STEREO)
705 tuner_info("Stereo: yes\n");
707 if (analog_ops->has_signal)
708 tuner_info("Signal strength: %d\n",
709 analog_ops->has_signal(fe));
710 if (analog_ops->is_stereo)
711 tuner_info("Stereo: %s\n",
712 analog_ops->is_stereo(fe) ? "yes" : "no");
715 /* ---------------------------------------------------------------------- */
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)
726 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
733 if (check_mode(t, cmd) == -EINVAL) {
735 if (analog_ops->standby)
736 analog_ops->standby(&t->fe);
742 #define switch_v4l2() if (!t->using_v4l2) \
743 tuner_dbg("switching to v4l2\n"); \
746 static inline int check_v4l2(struct tuner *t)
748 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
749 TV, v4l1 for radio), until that is fixed this code is disabled.
750 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
755 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
757 struct tuner *t = i2c_get_clientdata(client);
758 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
759 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
761 if (tuner_debug > 1) {
762 v4l_i2c_print_ioctl(client,cmd);
767 /* --- configuration --- */
768 case TUNER_SET_TYPE_ADDR:
769 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
770 ((struct tuner_setup *)arg)->type,
771 ((struct tuner_setup *)arg)->addr,
772 ((struct tuner_setup *)arg)->mode_mask,
773 ((struct tuner_setup *)arg)->config);
775 set_addr(client, (struct tuner_setup *)arg);
778 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
782 set_freq(client, t->radio_freq);
784 case TUNER_SET_STANDBY:
785 if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
788 if (analog_ops->standby)
789 analog_ops->standby(&t->fe);
791 #ifdef CONFIG_VIDEO_ALLOW_V4L1
793 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
795 if (check_v4l2(t) == -EINVAL)
798 /* Should be implemented, since bttv calls it */
799 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
803 static const v4l2_std_id map[] = {
804 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
805 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
806 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
807 [4 /* bttv */ ] = V4L2_STD_PAL_M,
808 [5 /* bttv */ ] = V4L2_STD_PAL_N,
809 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
811 struct video_channel *vc = arg;
813 if (check_v4l2(t) == -EINVAL)
816 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
819 if (vc->norm < ARRAY_SIZE(map))
820 t->std = map[vc->norm];
823 set_tv_freq(client, t->tv_freq);
828 unsigned long *v = arg;
830 if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
832 if (check_v4l2(t) == -EINVAL)
835 set_freq(client, *v);
840 struct video_tuner *vt = arg;
842 if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
844 if (check_v4l2(t) == -EINVAL)
847 if (V4L2_TUNER_RADIO == t->mode) {
848 if (fe_tuner_ops->get_status) {
851 fe_tuner_ops->get_status(&t->fe, &tuner_status);
852 if (tuner_status & TUNER_STATUS_STEREO)
853 vt->flags |= VIDEO_TUNER_STEREO_ON;
855 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
857 if (analog_ops->is_stereo) {
858 if (analog_ops->is_stereo(&t->fe))
860 VIDEO_TUNER_STEREO_ON;
863 ~VIDEO_TUNER_STEREO_ON;
866 if (analog_ops->has_signal)
868 analog_ops->has_signal(&t->fe);
870 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
872 vt->rangelow = radio_range[0] * 16000;
873 vt->rangehigh = radio_range[1] * 16000;
876 vt->rangelow = tv_range[0] * 16;
877 vt->rangehigh = tv_range[1] * 16;
884 struct video_audio *va = arg;
886 if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
888 if (check_v4l2(t) == -EINVAL)
891 if (V4L2_TUNER_RADIO == t->mode) {
892 if (fe_tuner_ops->get_status) {
895 fe_tuner_ops->get_status(&t->fe, &tuner_status);
896 va->mode = (tuner_status & TUNER_STATUS_STEREO)
897 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
898 } else if (analog_ops->is_stereo)
899 va->mode = analog_ops->is_stereo(&t->fe)
900 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
905 case TUNER_SET_CONFIG:
907 struct v4l2_priv_tun_config *cfg = arg;
909 if (t->type != cfg->tuner)
912 if (analog_ops->set_config) {
913 analog_ops->set_config(&t->fe, cfg->priv);
917 tuner_dbg("Tuner frontend module has no way to set config\n");
920 /* --- v4l ioctls --- */
921 /* take care: bttv does userspace copying, we'll get a
922 kernel pointer here... */
925 v4l2_std_id *id = arg;
927 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
936 set_freq(client, t->tv_freq);
939 case VIDIOC_S_FREQUENCY:
941 struct v4l2_frequency *f = arg;
943 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
947 set_freq(client,f->frequency);
951 case VIDIOC_G_FREQUENCY:
953 struct v4l2_frequency *f = arg;
955 if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
959 if (fe_tuner_ops->get_frequency) {
962 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
963 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
964 (abs_freq * 2 + 125/2) / 125 :
965 (abs_freq + 62500/2) / 62500;
968 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
969 t->radio_freq : t->tv_freq;
974 struct v4l2_tuner *tuner = arg;
976 if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
980 tuner->type = t->mode;
981 if (analog_ops->get_afc)
982 tuner->afc = analog_ops->get_afc(&t->fe);
983 if (t->mode == V4L2_TUNER_ANALOG_TV)
984 tuner->capability |= V4L2_TUNER_CAP_NORM;
985 if (t->mode != V4L2_TUNER_RADIO) {
986 tuner->rangelow = tv_range[0] * 16;
987 tuner->rangehigh = tv_range[1] * 16;
993 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
994 if (fe_tuner_ops->get_status) {
997 fe_tuner_ops->get_status(&t->fe, &tuner_status);
999 (tuner_status & TUNER_STATUS_STEREO) ?
1000 V4L2_TUNER_SUB_STEREO :
1001 V4L2_TUNER_SUB_MONO;
1003 if (analog_ops->is_stereo) {
1005 analog_ops->is_stereo(&t->fe) ?
1006 V4L2_TUNER_SUB_STEREO :
1007 V4L2_TUNER_SUB_MONO;
1010 if (analog_ops->has_signal)
1011 tuner->signal = analog_ops->has_signal(&t->fe);
1012 tuner->capability |=
1013 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1014 tuner->audmode = t->audmode;
1015 tuner->rangelow = radio_range[0] * 16000;
1016 tuner->rangehigh = radio_range[1] * 16000;
1019 case VIDIOC_S_TUNER:
1021 struct v4l2_tuner *tuner = arg;
1023 if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1028 /* do nothing unless we're a radio tuner */
1029 if (t->mode != V4L2_TUNER_RADIO)
1031 t->audmode = tuner->audmode;
1032 set_radio_freq(client, t->radio_freq);
1035 case VIDIOC_LOG_STATUS:
1036 if (analog_ops->tuner_status)
1037 analog_ops->tuner_status(&t->fe);
1044 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1046 struct tuner *t = i2c_get_clientdata(c);
1048 tuner_dbg("suspend\n");
1049 /* FIXME: power down ??? */
1053 static int tuner_resume(struct i2c_client *c)
1055 struct tuner *t = i2c_get_clientdata(c);
1057 tuner_dbg("resume\n");
1058 if (V4L2_TUNER_RADIO == t->mode) {
1060 set_freq(c, t->radio_freq);
1063 set_freq(c, t->tv_freq);
1068 /* ---------------------------------------------------------------------- */
1070 static LIST_HEAD(tuner_list);
1072 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1073 Note that when this function is called from tuner_probe you can be
1074 certain no other devices will be added/deleted at the same time, I2C
1075 core protects against that. */
1076 static void tuner_lookup(struct i2c_adapter *adap,
1077 struct tuner **radio, struct tuner **tv)
1084 list_for_each_entry(pos, &tuner_list, list) {
1087 if (pos->i2c->adapter != adap ||
1088 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1091 mode_mask = pos->mode_mask & ~T_STANDBY;
1092 if (*radio == NULL && mode_mask == T_RADIO)
1094 /* Note: currently TDA9887 is the only demod-only
1095 device. If other devices appear then we need to
1096 make this test more general. */
1097 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1098 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1103 /* During client attach, set_type is called by adapter's attach_inform callback.
1104 set_type must then be completed by tuner_probe.
1106 static int tuner_probe(struct i2c_client *client,
1107 const struct i2c_device_id *id)
1110 struct tuner *radio;
1113 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1117 t->name = "(tuner unset)";
1118 i2c_set_clientdata(client, t);
1120 t->audmode = V4L2_TUNER_MODE_STEREO;
1121 t->mode_mask = T_UNINITIALIZED;
1124 unsigned char buffer[16];
1127 memset(buffer, 0, sizeof(buffer));
1128 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1129 tuner_info("I2C RECV = ");
1130 for (i = 0; i < rc; i++)
1131 printk(KERN_CONT "%02x ", buffer[i]);
1134 /* HACK: This test was added to avoid tuner to probe tda9840 and
1135 tea6415c on the MXB card */
1136 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1141 /* autodetection code based on the i2c addr */
1142 if (!no_autodetect) {
1143 switch (client->addr) {
1145 if (tuner_symbol_probe(tea5761_autodetection,
1147 t->i2c->addr) >= 0) {
1148 t->type = TUNER_TEA5761;
1149 t->mode_mask = T_RADIO;
1150 t->mode = T_STANDBY;
1151 /* Sets freq to FM range */
1152 t->radio_freq = 87.5 * 16000;
1153 tuner_lookup(t->i2c->adapter, &radio, &tv);
1155 tv->mode_mask &= ~T_RADIO;
1157 goto register_client;
1164 /* If chip is not tda8290, don't register.
1165 since it can be tda9887*/
1166 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1167 t->i2c->addr) >= 0) {
1168 tuner_dbg("tda829x detected\n");
1170 /* Default is being tda9887 */
1171 t->type = TUNER_TDA9887;
1172 t->mode_mask = T_RADIO | T_ANALOG_TV |
1174 t->mode = T_STANDBY;
1175 goto register_client;
1179 if (tuner_symbol_probe(tea5767_autodetection,
1180 t->i2c->adapter, t->i2c->addr)
1182 t->type = TUNER_TEA5767;
1183 t->mode_mask = T_RADIO;
1184 t->mode = T_STANDBY;
1185 /* Sets freq to FM range */
1186 t->radio_freq = 87.5 * 16000;
1187 tuner_lookup(t->i2c->adapter, &radio, &tv);
1189 tv->mode_mask &= ~T_RADIO;
1191 goto register_client;
1197 /* Initializes only the first TV tuner on this adapter. Why only the
1198 first? Because there are some devices (notably the ones with TI
1199 tuners) that have more than one i2c address for the *same* device.
1200 Experience shows that, except for just one case, the first
1201 address is the right one. The exception is a Russian tuner
1202 (ACORP_Y878F). So, the desired behavior is just to enable the
1203 first found TV tuner. */
1204 tuner_lookup(t->i2c->adapter, &radio, &tv);
1206 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1208 t->mode_mask |= T_RADIO;
1209 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1210 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1211 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1214 /* Should be just before return */
1216 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1217 client->adapter->name);
1219 /* Sets a default mode */
1220 if (t->mode_mask & T_ANALOG_TV) {
1221 t->mode = V4L2_TUNER_ANALOG_TV;
1222 } else if (t->mode_mask & T_RADIO) {
1223 t->mode = V4L2_TUNER_RADIO;
1225 t->mode = V4L2_TUNER_DIGITAL_TV;
1227 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1228 list_add_tail(&t->list, &tuner_list);
1232 static int tuner_legacy_probe(struct i2c_adapter *adap)
1235 normal_i2c[0] = addr;
1236 normal_i2c[1] = I2C_CLIENT_END;
1239 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1242 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1243 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1244 * and an RTC at 0x6f which can get corrupted if probed.
1246 if ((adap->id == I2C_HW_B_CX2388x) ||
1247 (adap->id == I2C_HW_B_CX23885)) {
1250 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1252 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1253 ignore[i+0] = adap->nr;
1255 ignore[i+2] = adap->nr;
1257 ignore[i+4] = I2C_CLIENT_END;
1259 printk(KERN_WARNING "tuner: "
1260 "too many options specified "
1261 "in i2c probe ignore list!\n");
1266 static int tuner_remove(struct i2c_client *client)
1268 struct tuner *t = i2c_get_clientdata(client);
1270 tuner_detach(&t->fe);
1271 t->fe.analog_demod_priv = NULL;
1278 /* ----------------------------------------------------------------------- */
1280 /* This driver supports many devices and the idea is to let the driver
1281 detect which device is present. So rather than listing all supported
1282 devices here, we pretend to support a single, fake device type. */
1283 static const struct i2c_device_id tuner_id[] = {
1284 { "tuner", }, /* autodetect */
1287 MODULE_DEVICE_TABLE(i2c, tuner_id);
1289 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1291 .driverid = I2C_DRIVERID_TUNER,
1292 .command = tuner_command,
1293 .probe = tuner_probe,
1294 .remove = tuner_remove,
1295 .suspend = tuner_suspend,
1296 .resume = tuner_resume,
1297 .legacy_probe = tuner_legacy_probe,
1298 .id_table = tuner_id,
1302 * Overrides for Emacs so that we follow Linus's tabbing style.
1303 * ---------------------------------------------------------------------------