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>
23 #include "tuner-driver.h"
28 #include "tuner-xc2028.h"
29 #include "tuner-simple.h"
34 #define PREFIX t->i2c->driver->driver.name
36 /* standard i2c insmod options */
37 static unsigned short normal_i2c[] = {
38 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
41 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
42 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
43 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
49 /* insmod options used at init time => read/only */
50 static unsigned int addr = 0;
51 static unsigned int no_autodetect = 0;
52 static unsigned int show_i2c = 0;
54 /* insmod options used at runtime => read/write */
55 static int tuner_debug;
57 #define tuner_warn(fmt, arg...) do { \
58 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
59 i2c_adapter_id(t->i2c->adapter), \
60 t->i2c->addr, ##arg); \
63 #define tuner_info(fmt, arg...) do { \
64 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
65 i2c_adapter_id(t->i2c->adapter), \
66 t->i2c->addr, ##arg); \
69 #define tuner_err(fmt, arg...) do { \
70 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
71 i2c_adapter_id(t->i2c->adapter), \
72 t->i2c->addr, ##arg); \
75 #define tuner_dbg(fmt, arg...) do { \
77 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
78 i2c_adapter_id(t->i2c->adapter), \
79 t->i2c->addr, ##arg); \
82 /* ------------------------------------------------------------------------ */
84 static unsigned int tv_range[2] = { 44, 958 };
85 static unsigned int radio_range[2] = { 65, 108 };
87 static char pal[] = "--";
88 static char secam[] = "--";
89 static char ntsc[] = "-";
92 module_param(addr, int, 0444);
93 module_param(no_autodetect, int, 0444);
94 module_param(show_i2c, int, 0444);
95 module_param_named(debug,tuner_debug, int, 0644);
96 module_param_string(pal, pal, sizeof(pal), 0644);
97 module_param_string(secam, secam, sizeof(secam), 0644);
98 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
99 module_param_array(tv_range, int, NULL, 0644);
100 module_param_array(radio_range, int, NULL, 0644);
102 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
103 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
104 MODULE_LICENSE("GPL");
106 /* ---------------------------------------------------------------------- */
108 static void fe_set_params(struct dvb_frontend *fe,
109 struct analog_parameters *params)
111 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
112 struct tuner *t = fe->analog_demod_priv;
114 if (NULL == fe_tuner_ops->set_analog_params) {
115 tuner_warn("Tuner frontend module has no way to set freq\n");
118 fe_tuner_ops->set_analog_params(fe, params);
121 static void fe_release(struct dvb_frontend *fe)
123 if (fe->ops.tuner_ops.release)
124 fe->ops.tuner_ops.release(fe);
126 fe->ops.analog_demod_ops = NULL;
128 /* DO NOT kfree(fe->analog_demod_priv)
130 * If we are in this function, analog_demod_priv contains a pointer
131 * to struct tuner *t. This will be kfree'd in tuner_detach().
133 * Otherwise, fe->ops.analog_demod_ops->release will
134 * handle the cleanup for analog demodulator modules.
136 fe->analog_demod_priv = NULL;
139 static void fe_standby(struct dvb_frontend *fe)
141 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
143 if (fe_tuner_ops->sleep)
144 fe_tuner_ops->sleep(fe);
147 static int fe_has_signal(struct dvb_frontend *fe)
151 if (fe->ops.tuner_ops.get_rf_strength)
152 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
157 static void tuner_status(struct dvb_frontend *fe);
159 static struct analog_tuner_ops tuner_core_ops = {
160 .set_params = fe_set_params,
161 .standby = fe_standby,
162 .release = fe_release,
163 .has_signal = fe_has_signal,
164 .tuner_status = tuner_status
167 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
168 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
170 struct tuner *t = i2c_get_clientdata(c);
171 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
173 struct analog_parameters params = {
175 .audmode = t->audmode,
179 if (t->type == UNSET) {
180 tuner_warn ("tuner type not set\n");
183 if ((NULL == ops) || (NULL == ops->set_params)) {
184 tuner_warn ("Tuner has no way to set tv freq\n");
187 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
188 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
189 freq / 16, freq % 16 * 100 / 16, tv_range[0],
191 /* V4L2 spec: if the freq is not possible then the closest
192 possible value should be selected */
193 if (freq < tv_range[0] * 16)
194 freq = tv_range[0] * 16;
196 freq = tv_range[1] * 16;
198 params.frequency = freq;
200 ops->set_params(&t->fe, ¶ms);
203 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
205 struct tuner *t = i2c_get_clientdata(c);
206 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
208 struct analog_parameters params = {
210 .audmode = t->audmode,
214 if (t->type == UNSET) {
215 tuner_warn ("tuner type not set\n");
218 if ((NULL == ops) || (NULL == ops->set_params)) {
219 tuner_warn ("tuner has no way to set radio frequency\n");
222 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
223 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
224 freq / 16000, freq % 16000 * 100 / 16000,
225 radio_range[0], radio_range[1]);
226 /* V4L2 spec: if the freq is not possible then the closest
227 possible value should be selected */
228 if (freq < radio_range[0] * 16000)
229 freq = radio_range[0] * 16000;
231 freq = radio_range[1] * 16000;
233 params.frequency = freq;
235 ops->set_params(&t->fe, ¶ms);
238 static void set_freq(struct i2c_client *c, unsigned long freq)
240 struct tuner *t = i2c_get_clientdata(c);
243 case V4L2_TUNER_RADIO:
244 tuner_dbg("radio freq set to %lu.%02lu\n",
245 freq / 16000, freq % 16000 * 100 / 16000);
246 set_radio_freq(c, freq);
247 t->radio_freq = freq;
249 case V4L2_TUNER_ANALOG_TV:
250 case V4L2_TUNER_DIGITAL_TV:
251 tuner_dbg("tv freq set to %lu.%02lu\n",
252 freq / 16, freq % 16 * 100 / 16);
253 set_tv_freq(c, freq);
257 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
261 static void tuner_i2c_address_check(struct tuner *t)
263 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
264 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
267 tuner_warn("====================== WARNING! ======================\n");
268 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
269 tuner_warn("will soon be dropped. This message indicates that your\n");
270 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
271 t->i2c->name, t->i2c->addr);
272 tuner_warn("To ensure continued support for your device, please\n");
273 tuner_warn("send a copy of this message, along with full dmesg\n");
274 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
275 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
276 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
277 t->i2c->adapter->name, t->i2c->addr, t->type,
278 tuners[t->type].name);
279 tuner_warn("====================== WARNING! ======================\n");
282 static void attach_simple_tuner(struct tuner *t)
284 struct simple_tuner_config cfg = {
286 .tun = &tuners[t->type]
288 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
291 static void attach_tda829x(struct tuner *t)
293 struct tda829x_config cfg = {
294 .lna_cfg = &t->config,
295 .tuner_callback = t->tuner_callback,
297 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
300 static void set_type(struct i2c_client *c, unsigned int type,
301 unsigned int new_mode_mask, unsigned int new_config,
302 int (*tuner_callback) (void *dev, int command,int arg))
304 struct tuner *t = i2c_get_clientdata(c);
305 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
306 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
307 unsigned char buffer[4];
309 if (type == UNSET || type == TUNER_ABSENT) {
310 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
314 if (type >= tuner_count) {
315 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
320 t->config = new_config;
321 if (tuner_callback != NULL) {
322 tuner_dbg("defining GPIO callback\n");
323 t->tuner_callback = tuner_callback;
326 if (t->mode == T_UNINITIALIZED) {
327 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
332 /* discard private data, in case set_type() was previously called */
333 if (ops && ops->release)
334 ops->release(&t->fe);
338 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
340 case TUNER_PHILIPS_TDA8290:
346 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
347 t->type = TUNER_ABSENT;
348 t->mode_mask = T_UNINITIALIZED;
351 t->mode_mask = T_RADIO;
354 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
355 t->type = TUNER_ABSENT;
356 t->mode_mask = T_UNINITIALIZED;
359 t->mode_mask = T_RADIO;
361 case TUNER_PHILIPS_FMD1216ME_MK3:
366 i2c_master_send(c, buffer, 4);
370 i2c_master_send(c, buffer, 4);
371 attach_simple_tuner(t);
373 case TUNER_PHILIPS_TD1316:
378 i2c_master_send(c,buffer,4);
379 attach_simple_tuner(t);
383 struct xc2028_config cfg = {
384 .i2c_adap = t->i2c->adapter,
385 .i2c_addr = t->i2c->addr,
386 .video_dev = c->adapter->algo_data,
387 .callback = t->tuner_callback,
389 if (!xc2028_attach(&t->fe, &cfg)) {
390 t->type = TUNER_ABSENT;
391 t->mode_mask = T_UNINITIALIZED;
400 attach_simple_tuner(t);
404 ops = t->fe.ops.analog_demod_ops;
406 if (((NULL == ops) || (NULL == ops->set_params)) &&
407 (fe_tuner_ops->set_analog_params)) {
408 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
409 sizeof(t->i2c->name));
411 t->fe.ops.analog_demod_ops = &tuner_core_ops;
412 t->fe.analog_demod_priv = t;
414 strlcpy(t->i2c->name, ops->info.name,
415 sizeof(t->i2c->name));
418 tuner_dbg("type set to %s\n", t->i2c->name);
420 if (t->mode_mask == T_UNINITIALIZED)
421 t->mode_mask = new_mode_mask;
423 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
424 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
425 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
427 tuner_i2c_address_check(t);
431 * This function apply tuner config to tuner specified
432 * by tun_setup structure. I addr is unset, then admin status
433 * and tun addr status is more precise then current status,
434 * it's applied. Otherwise status and type are applied only to
435 * tuner with exactly the same addr.
438 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
440 struct tuner *t = i2c_get_clientdata(c);
442 tuner_dbg("set addr for type %i\n", t->type);
444 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
445 (t->mode_mask & tun_setup->mode_mask))) ||
446 (tun_setup->addr == c->addr)) {
447 set_type(c, tun_setup->type, tun_setup->mode_mask,
448 tun_setup->config, tun_setup->tuner_callback);
452 static inline int check_mode(struct tuner *t, char *cmd)
454 if ((1 << t->mode & t->mode_mask) == 0) {
459 case V4L2_TUNER_RADIO:
460 tuner_dbg("Cmd %s accepted for radio\n", cmd);
462 case V4L2_TUNER_ANALOG_TV:
463 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
465 case V4L2_TUNER_DIGITAL_TV:
466 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
472 /* get more precise norm info from insmod option */
473 static int tuner_fixup_std(struct tuner *t)
475 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
478 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
479 t->std = V4L2_STD_PAL_60;
485 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
486 t->std = V4L2_STD_PAL_BG;
490 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
491 t->std = V4L2_STD_PAL_I;
497 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
498 t->std = V4L2_STD_PAL_DK;
502 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
503 t->std = V4L2_STD_PAL_M;
507 if (pal[1] == 'c' || pal[1] == 'C') {
508 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
509 t->std = V4L2_STD_PAL_Nc;
511 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
512 t->std = V4L2_STD_PAL_N;
516 /* default parameter, do nothing */
519 tuner_warn ("pal= argument not recognised\n");
523 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
531 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
532 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
538 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
539 t->std = V4L2_STD_SECAM_DK;
543 if ((secam[1]=='C')||(secam[1]=='c')) {
544 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
545 t->std = V4L2_STD_SECAM_LC;
547 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
548 t->std = V4L2_STD_SECAM_L;
552 /* default parameter, do nothing */
555 tuner_warn ("secam= argument not recognised\n");
560 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
564 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
565 t->std = V4L2_STD_NTSC_M;
569 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
570 t->std = V4L2_STD_NTSC_M_JP;
574 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
575 t->std = V4L2_STD_NTSC_M_KR;
578 /* default parameter, do nothing */
581 tuner_info("ntsc= argument not recognised\n");
588 static void tuner_status(struct dvb_frontend *fe)
590 struct tuner *t = fe->analog_demod_priv;
591 unsigned long freq, freq_fraction;
592 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
593 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
597 case V4L2_TUNER_RADIO: p = "radio"; break;
598 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
599 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
600 default: p = "undefined"; break;
602 if (t->mode == V4L2_TUNER_RADIO) {
603 freq = t->radio_freq / 16000;
604 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
606 freq = t->tv_freq / 16;
607 freq_fraction = (t->tv_freq % 16) * 100 / 16;
609 tuner_info("Tuner mode: %s\n", p);
610 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
611 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
612 if (t->mode != V4L2_TUNER_RADIO)
614 if (fe_tuner_ops->get_status) {
617 fe_tuner_ops->get_status(&t->fe, &tuner_status);
618 if (tuner_status & TUNER_STATUS_LOCKED)
619 tuner_info("Tuner is locked.\n");
620 if (tuner_status & TUNER_STATUS_STEREO)
621 tuner_info("Stereo: yes\n");
625 tuner_info("Signal strength: %d\n",
626 ops->has_signal(fe));
628 tuner_info("Stereo: %s\n",
629 ops->is_stereo(fe) ? "yes" : "no");
633 /* ---------------------------------------------------------------------- */
636 * Switch tuner to other mode. If tuner support both tv and radio,
637 * set another frequency to some value (This is needed for some pal
638 * tuners to avoid locking). Otherwise, just put second tuner in
642 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
644 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
651 if (check_mode(t, cmd) == EINVAL) {
653 if (ops && ops->standby)
654 ops->standby(&t->fe);
660 #define switch_v4l2() if (!t->using_v4l2) \
661 tuner_dbg("switching to v4l2\n"); \
664 static inline int check_v4l2(struct tuner *t)
666 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
667 TV, v4l1 for radio), until that is fixed this code is disabled.
668 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
673 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
675 struct tuner *t = i2c_get_clientdata(client);
676 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
677 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
680 v4l_i2c_print_ioctl(client,cmd);
683 /* --- configuration --- */
684 case TUNER_SET_TYPE_ADDR:
685 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
686 ((struct tuner_setup *)arg)->type,
687 ((struct tuner_setup *)arg)->addr,
688 ((struct tuner_setup *)arg)->mode_mask,
689 ((struct tuner_setup *)arg)->config);
691 set_addr(client, (struct tuner_setup *)arg);
694 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
698 set_freq(client, t->radio_freq);
700 case TUNER_SET_STANDBY:
701 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
704 if (ops && ops->standby)
705 ops->standby(&t->fe);
707 #ifdef CONFIG_VIDEO_V4L1
709 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
711 if (check_v4l2(t) == EINVAL)
714 /* Should be implemented, since bttv calls it */
715 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
719 static const v4l2_std_id map[] = {
720 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
721 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
722 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
723 [4 /* bttv */ ] = V4L2_STD_PAL_M,
724 [5 /* bttv */ ] = V4L2_STD_PAL_N,
725 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
727 struct video_channel *vc = arg;
729 if (check_v4l2(t) == EINVAL)
732 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
735 if (vc->norm < ARRAY_SIZE(map))
736 t->std = map[vc->norm];
739 set_tv_freq(client, t->tv_freq);
744 unsigned long *v = arg;
746 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
748 if (check_v4l2(t) == EINVAL)
751 set_freq(client, *v);
756 struct video_tuner *vt = arg;
758 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
760 if (check_v4l2(t) == EINVAL)
763 if (V4L2_TUNER_RADIO == t->mode) {
764 if (fe_tuner_ops->get_status) {
767 fe_tuner_ops->get_status(&t->fe, &tuner_status);
768 if (tuner_status & TUNER_STATUS_STEREO)
769 vt->flags |= VIDEO_TUNER_STEREO_ON;
771 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
773 if (ops && ops->is_stereo) {
774 if (ops->is_stereo(&t->fe))
776 VIDEO_TUNER_STEREO_ON;
779 ~VIDEO_TUNER_STEREO_ON;
782 if (ops && ops->has_signal)
783 vt->signal = ops->has_signal(&t->fe);
785 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
787 vt->rangelow = radio_range[0] * 16000;
788 vt->rangehigh = radio_range[1] * 16000;
791 vt->rangelow = tv_range[0] * 16;
792 vt->rangehigh = tv_range[1] * 16;
799 struct video_audio *va = arg;
801 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
803 if (check_v4l2(t) == EINVAL)
806 if (V4L2_TUNER_RADIO == t->mode) {
807 if (fe_tuner_ops->get_status) {
810 fe_tuner_ops->get_status(&t->fe, &tuner_status);
811 va->mode = (tuner_status & TUNER_STATUS_STEREO)
812 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
813 } else if (ops && ops->is_stereo)
814 va->mode = ops->is_stereo(&t->fe)
815 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
820 case TUNER_SET_CONFIG:
822 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
823 struct v4l2_priv_tun_config *cfg = arg;
825 if (t->type != cfg->tuner)
828 if (t->type == TUNER_TDA9887) {
829 t->tda9887_config = *(unsigned int *)cfg->priv;
830 set_freq(client, t->tv_freq);
834 if (NULL == fe_tuner_ops->set_config) {
835 tuner_warn("Tuner frontend module has no way to "
839 fe_tuner_ops->set_config(&t->fe, cfg->priv);
843 /* --- v4l ioctls --- */
844 /* take care: bttv does userspace copying, we'll get a
845 kernel pointer here... */
848 v4l2_std_id *id = arg;
850 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
859 set_freq(client, t->tv_freq);
862 case VIDIOC_S_FREQUENCY:
864 struct v4l2_frequency *f = arg;
866 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
870 set_freq(client,f->frequency);
874 case VIDIOC_G_FREQUENCY:
876 struct v4l2_frequency *f = arg;
878 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
882 if (fe_tuner_ops->get_frequency) {
885 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
886 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
887 (abs_freq * 2 + 125/2) / 125 :
888 (abs_freq + 62500/2) / 62500;
891 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
892 t->radio_freq : t->tv_freq;
897 struct v4l2_tuner *tuner = arg;
899 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
903 tuner->type = t->mode;
904 if (ops && ops->get_afc)
905 tuner->afc = ops->get_afc(&t->fe);
906 if (t->mode == V4L2_TUNER_ANALOG_TV)
907 tuner->capability |= V4L2_TUNER_CAP_NORM;
908 if (t->mode != V4L2_TUNER_RADIO) {
909 tuner->rangelow = tv_range[0] * 16;
910 tuner->rangehigh = tv_range[1] * 16;
916 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
917 if (fe_tuner_ops->get_status) {
920 fe_tuner_ops->get_status(&t->fe, &tuner_status);
922 (tuner_status & TUNER_STATUS_STEREO) ?
923 V4L2_TUNER_SUB_STEREO :
926 if (ops && ops->is_stereo) {
928 ops->is_stereo(&t->fe) ?
929 V4L2_TUNER_SUB_STEREO :
933 if (ops && ops->has_signal)
934 tuner->signal = ops->has_signal(&t->fe);
936 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
937 tuner->audmode = t->audmode;
938 tuner->rangelow = radio_range[0] * 16000;
939 tuner->rangehigh = radio_range[1] * 16000;
944 struct v4l2_tuner *tuner = arg;
946 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
951 /* do nothing unless we're a radio tuner */
952 if (t->mode != V4L2_TUNER_RADIO)
954 t->audmode = tuner->audmode;
955 set_radio_freq(client, t->radio_freq);
958 case VIDIOC_LOG_STATUS:
959 if (ops && ops->tuner_status)
960 ops->tuner_status(&t->fe);
967 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
969 struct tuner *t = i2c_get_clientdata(c);
971 tuner_dbg("suspend\n");
972 /* FIXME: power down ??? */
976 static int tuner_resume(struct i2c_client *c)
978 struct tuner *t = i2c_get_clientdata(c);
980 tuner_dbg("resume\n");
981 if (V4L2_TUNER_RADIO == t->mode) {
983 set_freq(c, t->radio_freq);
986 set_freq(c, t->tv_freq);
991 /* ---------------------------------------------------------------------- */
993 LIST_HEAD(tuner_list);
995 /* Search for existing radio and/or TV tuners on the given I2C adapter.
996 Note that when this function is called from tuner_probe you can be
997 certain no other devices will be added/deleted at the same time, I2C
998 core protects against that. */
999 static void tuner_lookup(struct i2c_adapter *adap,
1000 struct tuner **radio, struct tuner **tv)
1007 list_for_each_entry(pos, &tuner_list, list) {
1010 if (pos->i2c->adapter != adap ||
1011 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1014 mode_mask = pos->mode_mask & ~T_STANDBY;
1015 if (*radio == NULL && mode_mask == T_RADIO)
1017 /* Note: currently TDA9887 is the only demod-only
1018 device. If other devices appear then we need to
1019 make this test more general. */
1020 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1021 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1026 /* During client attach, set_type is called by adapter's attach_inform callback.
1027 set_type must then be completed by tuner_probe.
1029 static int tuner_probe(struct i2c_client *client)
1032 struct tuner *radio;
1035 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1039 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1040 i2c_set_clientdata(client, t);
1042 t->audmode = V4L2_TUNER_MODE_STEREO;
1043 t->mode_mask = T_UNINITIALIZED;
1046 unsigned char buffer[16];
1049 memset(buffer, 0, sizeof(buffer));
1050 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1051 tuner_info("I2C RECV = ");
1052 for (i = 0; i < rc; i++)
1053 printk(KERN_CONT "%02x ", buffer[i]);
1056 /* HACK: This test was added to avoid tuner to probe tda9840 and
1057 tea6415c on the MXB card */
1058 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1063 /* autodetection code based on the i2c addr */
1064 if (!no_autodetect) {
1065 switch (client->addr) {
1067 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1069 t->type = TUNER_TEA5761;
1070 t->mode_mask = T_RADIO;
1071 t->mode = T_STANDBY;
1072 /* Sets freq to FM range */
1073 t->radio_freq = 87.5 * 16000;
1074 tuner_lookup(t->i2c->adapter, &radio, &tv);
1076 tv->mode_mask &= ~T_RADIO;
1078 goto register_client;
1085 /* If chip is not tda8290, don't register.
1086 since it can be tda9887*/
1087 if (tda829x_probe(t->i2c->adapter,
1088 t->i2c->addr) == 0) {
1089 tuner_dbg("tda829x detected\n");
1091 /* Default is being tda9887 */
1092 t->type = TUNER_TDA9887;
1093 t->mode_mask = T_RADIO | T_ANALOG_TV |
1095 t->mode = T_STANDBY;
1096 goto register_client;
1100 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1102 t->type = TUNER_TEA5767;
1103 t->mode_mask = T_RADIO;
1104 t->mode = T_STANDBY;
1105 /* Sets freq to FM range */
1106 t->radio_freq = 87.5 * 16000;
1107 tuner_lookup(t->i2c->adapter, &radio, &tv);
1109 tv->mode_mask &= ~T_RADIO;
1111 goto register_client;
1117 /* Initializes only the first TV tuner on this adapter. Why only the
1118 first? Because there are some devices (notably the ones with TI
1119 tuners) that have more than one i2c address for the *same* device.
1120 Experience shows that, except for just one case, the first
1121 address is the right one. The exception is a Russian tuner
1122 (ACORP_Y878F). So, the desired behavior is just to enable the
1123 first found TV tuner. */
1124 tuner_lookup(t->i2c->adapter, &radio, &tv);
1126 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1128 t->mode_mask |= T_RADIO;
1129 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1130 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1131 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1134 /* Should be just before return */
1136 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1137 client->adapter->name);
1139 /* Sets a default mode */
1140 if (t->mode_mask & T_ANALOG_TV) {
1141 t->mode = V4L2_TUNER_ANALOG_TV;
1142 } else if (t->mode_mask & T_RADIO) {
1143 t->mode = V4L2_TUNER_RADIO;
1145 t->mode = V4L2_TUNER_DIGITAL_TV;
1147 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1148 list_add_tail(&t->list, &tuner_list);
1152 static int tuner_legacy_probe(struct i2c_adapter *adap)
1155 normal_i2c[0] = addr;
1156 normal_i2c[1] = I2C_CLIENT_END;
1159 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1162 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1163 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1164 * and an RTC at 0x6f which can get corrupted if probed.
1166 if ((adap->id == I2C_HW_B_CX2388x) ||
1167 (adap->id == I2C_HW_B_CX23885)) {
1170 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1172 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1173 ignore[i+0] = adap->nr;
1175 ignore[i+2] = adap->nr;
1177 ignore[i+4] = I2C_CLIENT_END;
1179 printk(KERN_WARNING "tuner: "
1180 "too many options specified "
1181 "in i2c probe ignore list!\n");
1186 static int tuner_remove(struct i2c_client *client)
1188 struct tuner *t = i2c_get_clientdata(client);
1189 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1191 if (ops && ops->release)
1192 ops->release(&t->fe);
1199 /* ----------------------------------------------------------------------- */
1201 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1203 .driverid = I2C_DRIVERID_TUNER,
1204 .command = tuner_command,
1205 .probe = tuner_probe,
1206 .remove = tuner_remove,
1207 .suspend = tuner_suspend,
1208 .resume = tuner_resume,
1209 .legacy_probe = tuner_legacy_probe,
1214 * Overrides for Emacs so that we follow Linus's tabbing style.
1215 * ---------------------------------------------------------------------------