V4L/DVB (11110): au8522/au0828: Fix Kconfig dependencies
[linux-2.6] / drivers / media / video / tuner-core.c
1 /*
2  *
3  * i2c tv tuner chip device driver
4  * core core, i.e. kernel interfaces, registering and so on
5  */
6
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-device.h>
22 #include <media/v4l2-ioctl.h>
23 #include <media/v4l2-i2c-drv-legacy.h>
24 #include "mt20xx.h"
25 #include "tda8290.h"
26 #include "tea5761.h"
27 #include "tea5767.h"
28 #include "tuner-xc2028.h"
29 #include "tuner-simple.h"
30 #include "tda9887.h"
31 #include "xc5000.h"
32
33 #define UNSET (-1U)
34
35 #define PREFIX t->i2c->driver->driver.name
36
37 /** This macro allows us to probe dynamically, avoiding static links */
38 #ifdef CONFIG_MEDIA_ATTACH
39 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
40         int __r = -EINVAL; \
41         typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
42         if (__a) { \
43                 __r = (int) __a(ARGS); \
44                 symbol_put(FUNCTION); \
45         } else { \
46                 printk(KERN_ERR "TUNER: Unable to find " \
47                                 "symbol "#FUNCTION"()\n"); \
48         } \
49         __r; \
50 })
51
52 static void tuner_detach(struct dvb_frontend *fe)
53 {
54         if (fe->ops.tuner_ops.release) {
55                 fe->ops.tuner_ops.release(fe);
56                 symbol_put_addr(fe->ops.tuner_ops.release);
57         }
58         if (fe->ops.analog_ops.release) {
59                 fe->ops.analog_ops.release(fe);
60                 symbol_put_addr(fe->ops.analog_ops.release);
61         }
62 }
63 #else
64 #define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
65         FUNCTION(ARGS); \
66 })
67
68 static void tuner_detach(struct dvb_frontend *fe)
69 {
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);
74 }
75 #endif
76
77 struct tuner {
78         /* device */
79         struct dvb_frontend fe;
80         struct i2c_client   *i2c;
81         struct v4l2_subdev  sd;
82         struct list_head    list;
83         unsigned int        using_v4l2:1;
84
85         /* keep track of the current settings */
86         v4l2_std_id         std;
87         unsigned int        tv_freq;
88         unsigned int        radio_freq;
89         unsigned int        audmode;
90
91         unsigned int        mode;
92         unsigned int        mode_mask; /* Combination of allowable modes */
93
94         unsigned int        type; /* chip type id */
95         unsigned int        config;
96         const char          *name;
97 };
98
99 static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
100 {
101         return container_of(sd, struct tuner, sd);
102 }
103
104 /* standard i2c insmod options */
105 static unsigned short normal_i2c[] = {
106 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || (defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE) && defined(MODULE))
107         0x10,
108 #endif
109         0x42, 0x43, 0x4a, 0x4b,                 /* tda8290 */
110         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
111         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
112         I2C_CLIENT_END
113 };
114
115 I2C_CLIENT_INSMOD;
116
117 /* insmod options used at init time => read/only */
118 static unsigned int addr;
119 static unsigned int no_autodetect;
120 static unsigned int show_i2c;
121
122 /* insmod options used at runtime => read/write */
123 static int tuner_debug;
124
125 #define tuner_warn(fmt, arg...) do {                    \
126         printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
127                i2c_adapter_id(t->i2c->adapter),         \
128                t->i2c->addr, ##arg);                    \
129          } while (0)
130
131 #define tuner_info(fmt, arg...) do {                    \
132         printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX,    \
133                i2c_adapter_id(t->i2c->adapter),         \
134                t->i2c->addr, ##arg);                    \
135          } while (0)
136
137 #define tuner_err(fmt, arg...) do {                     \
138         printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX,     \
139                i2c_adapter_id(t->i2c->adapter),         \
140                t->i2c->addr, ##arg);                    \
141          } while (0)
142
143 #define tuner_dbg(fmt, arg...) do {                             \
144         if (tuner_debug)                                        \
145                 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX,   \
146                        i2c_adapter_id(t->i2c->adapter),         \
147                        t->i2c->addr, ##arg);                    \
148          } while (0)
149
150 /* ------------------------------------------------------------------------ */
151
152 static unsigned int tv_range[2] = { 44, 958 };
153 static unsigned int radio_range[2] = { 65, 108 };
154
155 static char pal[] = "--";
156 static char secam[] = "--";
157 static char ntsc[] = "-";
158
159
160 module_param(addr, int, 0444);
161 module_param(no_autodetect, int, 0444);
162 module_param(show_i2c, int, 0444);
163 module_param_named(debug,tuner_debug, int, 0644);
164 module_param_string(pal, pal, sizeof(pal), 0644);
165 module_param_string(secam, secam, sizeof(secam), 0644);
166 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
167 module_param_array(tv_range, int, NULL, 0644);
168 module_param_array(radio_range, int, NULL, 0644);
169
170 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
171 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
172 MODULE_LICENSE("GPL");
173
174 /* ---------------------------------------------------------------------- */
175
176 static void fe_set_params(struct dvb_frontend *fe,
177                           struct analog_parameters *params)
178 {
179         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
180         struct tuner *t = fe->analog_demod_priv;
181
182         if (NULL == fe_tuner_ops->set_analog_params) {
183                 tuner_warn("Tuner frontend module has no way to set freq\n");
184                 return;
185         }
186         fe_tuner_ops->set_analog_params(fe, params);
187 }
188
189 static void fe_standby(struct dvb_frontend *fe)
190 {
191         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
192
193         if (fe_tuner_ops->sleep)
194                 fe_tuner_ops->sleep(fe);
195 }
196
197 static int fe_has_signal(struct dvb_frontend *fe)
198 {
199         u16 strength = 0;
200
201         if (fe->ops.tuner_ops.get_rf_strength)
202                 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
203
204         return strength;
205 }
206
207 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
208 {
209         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
210         struct tuner *t = fe->analog_demod_priv;
211
212         if (fe_tuner_ops->set_config)
213                 return fe_tuner_ops->set_config(fe, priv_cfg);
214
215         tuner_warn("Tuner frontend module has no way to set config\n");
216
217         return 0;
218 }
219
220 static void tuner_status(struct dvb_frontend *fe);
221
222 static struct analog_demod_ops tuner_analog_ops = {
223         .set_params     = fe_set_params,
224         .standby        = fe_standby,
225         .has_signal     = fe_has_signal,
226         .set_config     = fe_set_config,
227         .tuner_status   = tuner_status
228 };
229
230 /* Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz */
231 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
232 {
233         struct tuner *t = to_tuner(i2c_get_clientdata(c));
234         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
235
236         struct analog_parameters params = {
237                 .mode      = t->mode,
238                 .audmode   = t->audmode,
239                 .std       = t->std
240         };
241
242         if (t->type == UNSET) {
243                 tuner_warn ("tuner type not set\n");
244                 return;
245         }
246         if (NULL == analog_ops->set_params) {
247                 tuner_warn ("Tuner has no way to set tv freq\n");
248                 return;
249         }
250         if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
251                 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
252                            freq / 16, freq % 16 * 100 / 16, tv_range[0],
253                            tv_range[1]);
254                 /* V4L2 spec: if the freq is not possible then the closest
255                    possible value should be selected */
256                 if (freq < tv_range[0] * 16)
257                         freq = tv_range[0] * 16;
258                 else
259                         freq = tv_range[1] * 16;
260         }
261         params.frequency = freq;
262
263         analog_ops->set_params(&t->fe, &params);
264 }
265
266 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
267 {
268         struct tuner *t = to_tuner(i2c_get_clientdata(c));
269         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
270
271         struct analog_parameters params = {
272                 .mode      = t->mode,
273                 .audmode   = t->audmode,
274                 .std       = t->std
275         };
276
277         if (t->type == UNSET) {
278                 tuner_warn ("tuner type not set\n");
279                 return;
280         }
281         if (NULL == analog_ops->set_params) {
282                 tuner_warn ("tuner has no way to set radio frequency\n");
283                 return;
284         }
285         if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
286                 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
287                            freq / 16000, freq % 16000 * 100 / 16000,
288                            radio_range[0], radio_range[1]);
289                 /* V4L2 spec: if the freq is not possible then the closest
290                    possible value should be selected */
291                 if (freq < radio_range[0] * 16000)
292                         freq = radio_range[0] * 16000;
293                 else
294                         freq = radio_range[1] * 16000;
295         }
296         params.frequency = freq;
297
298         analog_ops->set_params(&t->fe, &params);
299 }
300
301 static void set_freq(struct i2c_client *c, unsigned long freq)
302 {
303         struct tuner *t = to_tuner(i2c_get_clientdata(c));
304
305         switch (t->mode) {
306         case V4L2_TUNER_RADIO:
307                 tuner_dbg("radio freq set to %lu.%02lu\n",
308                           freq / 16000, freq % 16000 * 100 / 16000);
309                 set_radio_freq(c, freq);
310                 t->radio_freq = freq;
311                 break;
312         case V4L2_TUNER_ANALOG_TV:
313         case V4L2_TUNER_DIGITAL_TV:
314                 tuner_dbg("tv freq set to %lu.%02lu\n",
315                           freq / 16, freq % 16 * 100 / 16);
316                 set_tv_freq(c, freq);
317                 t->tv_freq = freq;
318                 break;
319         default:
320                 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
321         }
322 }
323
324 static void tuner_i2c_address_check(struct tuner *t)
325 {
326         if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
327             ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
328                 return;
329
330         /* We already know that the XC5000 can only be located at
331          * i2c address 0x61, 0x62, 0x63 or 0x64 */
332         if ((t->type == TUNER_XC5000) &&
333             ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
334                 return;
335
336         tuner_warn("====================== WARNING! ======================\n");
337         tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
338         tuner_warn("will soon be dropped. This message indicates that your\n");
339         tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
340                    t->name, t->i2c->addr);
341         tuner_warn("To ensure continued support for your device, please\n");
342         tuner_warn("send a copy of this message, along with full dmesg\n");
343         tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
344         tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
345         tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
346                    t->i2c->adapter->name, t->i2c->addr, t->type, t->name);
347         tuner_warn("====================== WARNING! ======================\n");
348 }
349
350 static struct xc5000_config xc5000_cfg;
351
352 static void set_type(struct i2c_client *c, unsigned int type,
353                      unsigned int new_mode_mask, unsigned int new_config,
354                      int (*tuner_callback) (void *dev, int component, int cmd, int arg))
355 {
356         struct tuner *t = to_tuner(i2c_get_clientdata(c));
357         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
358         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
359         unsigned char buffer[4];
360
361         if (type == UNSET || type == TUNER_ABSENT) {
362                 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
363                 return;
364         }
365
366         t->type = type;
367         t->config = new_config;
368         if (tuner_callback != NULL) {
369                 tuner_dbg("defining GPIO callback\n");
370                 t->fe.callback = tuner_callback;
371         }
372
373         if (t->mode == T_UNINITIALIZED) {
374                 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
375
376                 return;
377         }
378
379         /* discard private data, in case set_type() was previously called */
380         tuner_detach(&t->fe);
381         t->fe.analog_demod_priv = NULL;
382
383         switch (t->type) {
384         case TUNER_MT2032:
385                 if (!dvb_attach(microtune_attach,
386                            &t->fe, t->i2c->adapter, t->i2c->addr))
387                         goto attach_failed;
388                 break;
389         case TUNER_PHILIPS_TDA8290:
390         {
391                 struct tda829x_config cfg = {
392                         .lna_cfg        = t->config,
393                 };
394                 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
395                                 t->i2c->addr, &cfg))
396                         goto attach_failed;
397                 break;
398         }
399         case TUNER_TEA5767:
400                 if (!dvb_attach(tea5767_attach, &t->fe,
401                                 t->i2c->adapter, t->i2c->addr))
402                         goto attach_failed;
403                 t->mode_mask = T_RADIO;
404                 break;
405         case TUNER_TEA5761:
406                 if (!dvb_attach(tea5761_attach, &t->fe,
407                                 t->i2c->adapter, t->i2c->addr))
408                         goto attach_failed;
409                 t->mode_mask = T_RADIO;
410                 break;
411         case TUNER_PHILIPS_FMD1216ME_MK3:
412                 buffer[0] = 0x0b;
413                 buffer[1] = 0xdc;
414                 buffer[2] = 0x9c;
415                 buffer[3] = 0x60;
416                 i2c_master_send(c, buffer, 4);
417                 mdelay(1);
418                 buffer[2] = 0x86;
419                 buffer[3] = 0x54;
420                 i2c_master_send(c, buffer, 4);
421                 if (!dvb_attach(simple_tuner_attach, &t->fe,
422                                 t->i2c->adapter, t->i2c->addr, t->type))
423                         goto attach_failed;
424                 break;
425         case TUNER_PHILIPS_TD1316:
426                 buffer[0] = 0x0b;
427                 buffer[1] = 0xdc;
428                 buffer[2] = 0x86;
429                 buffer[3] = 0xa4;
430                 i2c_master_send(c, buffer, 4);
431                 if (!dvb_attach(simple_tuner_attach, &t->fe,
432                                 t->i2c->adapter, t->i2c->addr, t->type))
433                         goto attach_failed;
434                 break;
435         case TUNER_XC2028:
436         {
437                 struct xc2028_config cfg = {
438                         .i2c_adap  = t->i2c->adapter,
439                         .i2c_addr  = t->i2c->addr,
440                 };
441                 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
442                         goto attach_failed;
443                 break;
444         }
445         case TUNER_TDA9887:
446                 if (!dvb_attach(tda9887_attach,
447                            &t->fe, t->i2c->adapter, t->i2c->addr))
448                         goto attach_failed;
449                 break;
450         case TUNER_XC5000:
451         {
452                 struct dvb_tuner_ops *xc_tuner_ops;
453
454                 xc5000_cfg.i2c_address    = t->i2c->addr;
455                 /* if_khz will be set when the digital dvb_attach() occurs */
456                 xc5000_cfg.if_khz         = 0;
457                 if (!dvb_attach(xc5000_attach,
458                                 &t->fe, t->i2c->adapter, &xc5000_cfg))
459                         goto attach_failed;
460
461                 xc_tuner_ops = &t->fe.ops.tuner_ops;
462                 if (xc_tuner_ops->init)
463                         xc_tuner_ops->init(&t->fe);
464                 break;
465         }
466         default:
467                 if (!dvb_attach(simple_tuner_attach, &t->fe,
468                                 t->i2c->adapter, t->i2c->addr, t->type))
469                         goto attach_failed;
470
471                 break;
472         }
473
474         if ((NULL == analog_ops->set_params) &&
475             (fe_tuner_ops->set_analog_params)) {
476
477                 t->name = fe_tuner_ops->info.name;
478
479                 t->fe.analog_demod_priv = t;
480                 memcpy(analog_ops, &tuner_analog_ops,
481                        sizeof(struct analog_demod_ops));
482
483         } else {
484                 t->name = analog_ops->info.name;
485         }
486
487         tuner_dbg("type set to %s\n", t->name);
488
489         if (t->mode_mask == T_UNINITIALIZED)
490                 t->mode_mask = new_mode_mask;
491
492         /* xc2028/3028 and xc5000 requires a firmware to be set-up later
493            trying to set a frequency here will just fail
494            FIXME: better to move set_freq to the tuner code. This is needed
495            on analog tuners for PLL to properly work
496          */
497         if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
498                 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
499                             t->radio_freq : t->tv_freq);
500
501         tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
502                   c->adapter->name, c->driver->driver.name, c->addr << 1, type,
503                   t->mode_mask);
504         tuner_i2c_address_check(t);
505         return;
506
507 attach_failed:
508         tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
509         t->type = TUNER_ABSENT;
510         t->mode_mask = T_UNINITIALIZED;
511
512         return;
513 }
514
515 /*
516  * This function apply tuner config to tuner specified
517  * by tun_setup structure. I addr is unset, then admin status
518  * and tun addr status is more precise then current status,
519  * it's applied. Otherwise status and type are applied only to
520  * tuner with exactly the same addr.
521 */
522
523 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
524 {
525         struct tuner *t = to_tuner(i2c_get_clientdata(c));
526
527         if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
528                 (t->mode_mask & tun_setup->mode_mask))) ||
529                 (tun_setup->addr == c->addr)) {
530                         set_type(c, tun_setup->type, tun_setup->mode_mask,
531                                  tun_setup->config, tun_setup->tuner_callback);
532         } else
533                 tuner_dbg("set addr discarded for type %i, mask %x. "
534                           "Asked to change tuner at addr 0x%02x, with mask %x\n",
535                           t->type, t->mode_mask,
536                           tun_setup->addr, tun_setup->mode_mask);
537 }
538
539 static inline int check_mode(struct tuner *t, char *cmd)
540 {
541         if ((1 << t->mode & t->mode_mask) == 0) {
542                 return -EINVAL;
543         }
544
545         switch (t->mode) {
546         case V4L2_TUNER_RADIO:
547                 tuner_dbg("Cmd %s accepted for radio\n", cmd);
548                 break;
549         case V4L2_TUNER_ANALOG_TV:
550                 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
551                 break;
552         case V4L2_TUNER_DIGITAL_TV:
553                 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
554                 break;
555         }
556         return 0;
557 }
558
559 /* get more precise norm info from insmod option */
560 static int tuner_fixup_std(struct tuner *t)
561 {
562         if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
563                 switch (pal[0]) {
564                 case '6':
565                         tuner_dbg ("insmod fixup: PAL => PAL-60\n");
566                         t->std = V4L2_STD_PAL_60;
567                         break;
568                 case 'b':
569                 case 'B':
570                 case 'g':
571                 case 'G':
572                         tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
573                         t->std = V4L2_STD_PAL_BG;
574                         break;
575                 case 'i':
576                 case 'I':
577                         tuner_dbg ("insmod fixup: PAL => PAL-I\n");
578                         t->std = V4L2_STD_PAL_I;
579                         break;
580                 case 'd':
581                 case 'D':
582                 case 'k':
583                 case 'K':
584                         tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
585                         t->std = V4L2_STD_PAL_DK;
586                         break;
587                 case 'M':
588                 case 'm':
589                         tuner_dbg ("insmod fixup: PAL => PAL-M\n");
590                         t->std = V4L2_STD_PAL_M;
591                         break;
592                 case 'N':
593                 case 'n':
594                         if (pal[1] == 'c' || pal[1] == 'C') {
595                                 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
596                                 t->std = V4L2_STD_PAL_Nc;
597                         } else {
598                                 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
599                                 t->std = V4L2_STD_PAL_N;
600                         }
601                         break;
602                 case '-':
603                         /* default parameter, do nothing */
604                         break;
605                 default:
606                         tuner_warn ("pal= argument not recognised\n");
607                         break;
608                 }
609         }
610         if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
611                 switch (secam[0]) {
612                 case 'b':
613                 case 'B':
614                 case 'g':
615                 case 'G':
616                 case 'h':
617                 case 'H':
618                         tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
619                         t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
620                         break;
621                 case 'd':
622                 case 'D':
623                 case 'k':
624                 case 'K':
625                         tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
626                         t->std = V4L2_STD_SECAM_DK;
627                         break;
628                 case 'l':
629                 case 'L':
630                         if ((secam[1]=='C')||(secam[1]=='c')) {
631                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
632                                 t->std = V4L2_STD_SECAM_LC;
633                         } else {
634                                 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
635                                 t->std = V4L2_STD_SECAM_L;
636                         }
637                         break;
638                 case '-':
639                         /* default parameter, do nothing */
640                         break;
641                 default:
642                         tuner_warn ("secam= argument not recognised\n");
643                         break;
644                 }
645         }
646
647         if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
648                 switch (ntsc[0]) {
649                 case 'm':
650                 case 'M':
651                         tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
652                         t->std = V4L2_STD_NTSC_M;
653                         break;
654                 case 'j':
655                 case 'J':
656                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
657                         t->std = V4L2_STD_NTSC_M_JP;
658                         break;
659                 case 'k':
660                 case 'K':
661                         tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
662                         t->std = V4L2_STD_NTSC_M_KR;
663                         break;
664                 case '-':
665                         /* default parameter, do nothing */
666                         break;
667                 default:
668                         tuner_info("ntsc= argument not recognised\n");
669                         break;
670                 }
671         }
672         return 0;
673 }
674
675 static void tuner_status(struct dvb_frontend *fe)
676 {
677         struct tuner *t = fe->analog_demod_priv;
678         unsigned long freq, freq_fraction;
679         struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
680         struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
681         const char *p;
682
683         switch (t->mode) {
684                 case V4L2_TUNER_RADIO:      p = "radio"; break;
685                 case V4L2_TUNER_ANALOG_TV:  p = "analog TV"; break;
686                 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
687                 default: p = "undefined"; break;
688         }
689         if (t->mode == V4L2_TUNER_RADIO) {
690                 freq = t->radio_freq / 16000;
691                 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
692         } else {
693                 freq = t->tv_freq / 16;
694                 freq_fraction = (t->tv_freq % 16) * 100 / 16;
695         }
696         tuner_info("Tuner mode:      %s\n", p);
697         tuner_info("Frequency:       %lu.%02lu MHz\n", freq, freq_fraction);
698         tuner_info("Standard:        0x%08lx\n", (unsigned long)t->std);
699         if (t->mode != V4L2_TUNER_RADIO)
700                return;
701         if (fe_tuner_ops->get_status) {
702                 u32 tuner_status;
703
704                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
705                 if (tuner_status & TUNER_STATUS_LOCKED)
706                         tuner_info("Tuner is locked.\n");
707                 if (tuner_status & TUNER_STATUS_STEREO)
708                         tuner_info("Stereo:          yes\n");
709         }
710         if (analog_ops->has_signal)
711                 tuner_info("Signal strength: %d\n",
712                            analog_ops->has_signal(fe));
713         if (analog_ops->is_stereo)
714                 tuner_info("Stereo:          %s\n",
715                            analog_ops->is_stereo(fe) ? "yes" : "no");
716 }
717
718 /* ---------------------------------------------------------------------- */
719
720 /*
721  * Switch tuner to other mode. If tuner support both tv and radio,
722  * set another frequency to some value (This is needed for some pal
723  * tuners to avoid locking). Otherwise, just put second tuner in
724  * standby mode.
725  */
726
727 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
728 {
729         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
730
731         if (mode == t->mode)
732                 return 0;
733
734         t->mode = mode;
735
736         if (check_mode(t, cmd) == -EINVAL) {
737                 tuner_dbg("Tuner doesn't support this mode. "
738                           "Putting tuner to sleep\n");
739                 t->mode = T_STANDBY;
740                 if (analog_ops->standby)
741                         analog_ops->standby(&t->fe);
742                 return -EINVAL;
743         }
744         return 0;
745 }
746
747 #define switch_v4l2()   if (!t->using_v4l2) \
748                             tuner_dbg("switching to v4l2\n"); \
749                         t->using_v4l2 = 1;
750
751 static inline int check_v4l2(struct tuner *t)
752 {
753         /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
754            TV, v4l1 for radio), until that is fixed this code is disabled.
755            Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
756            first. */
757         return 0;
758 }
759
760 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
761 {
762         struct tuner *t = to_tuner(sd);
763         struct i2c_client *client = v4l2_get_subdevdata(sd);
764
765         tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
766                         type->type,
767                         type->addr,
768                         type->mode_mask,
769                         type->config);
770
771         set_addr(client, type);
772         return 0;
773 }
774
775 static int tuner_s_radio(struct v4l2_subdev *sd)
776 {
777         struct tuner *t = to_tuner(sd);
778         struct i2c_client *client = v4l2_get_subdevdata(sd);
779
780         if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
781                         == -EINVAL)
782                 return 0;
783         if (t->radio_freq)
784                 set_freq(client, t->radio_freq);
785         return 0;
786 }
787
788 static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
789 {
790         struct tuner *t = to_tuner(sd);
791         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
792
793         tuner_dbg("Putting tuner to sleep\n");
794
795         if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
796                 return 0;
797         t->mode = T_STANDBY;
798         if (analog_ops->standby)
799                 analog_ops->standby(&t->fe);
800         return 0;
801 }
802
803 #ifdef CONFIG_VIDEO_ALLOW_V4L1
804 static long tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
805 {
806         struct tuner *t = to_tuner(sd);
807         struct i2c_client *client = v4l2_get_subdevdata(sd);
808         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
809         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
810
811         switch (cmd) {
812         case VIDIOCSAUDIO:
813                 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
814                         return 0;
815                 if (check_v4l2(t) == -EINVAL)
816                         return 0;
817
818                 /* Should be implemented, since bttv calls it */
819                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
820                 break;
821         case VIDIOCSCHAN:
822                 {
823                         static const v4l2_std_id map[] = {
824                                 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
825                                 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
826                                 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
827                                 [4 /* bttv */ ] = V4L2_STD_PAL_M,
828                                 [5 /* bttv */ ] = V4L2_STD_PAL_N,
829                                 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
830                         };
831                         struct video_channel *vc = arg;
832
833                         if (check_v4l2(t) == -EINVAL)
834                                 return 0;
835
836                         if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
837                                 return 0;
838
839                         if (vc->norm < ARRAY_SIZE(map))
840                                 t->std = map[vc->norm];
841                         tuner_fixup_std(t);
842                         if (t->tv_freq)
843                                 set_tv_freq(client, t->tv_freq);
844                         return 0;
845                 }
846         case VIDIOCSFREQ:
847                 {
848                         unsigned long *v = arg;
849
850                         if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
851                                 return 0;
852                         if (check_v4l2(t) == -EINVAL)
853                                 return 0;
854
855                         set_freq(client, *v);
856                         return 0;
857                 }
858         case VIDIOCGTUNER:
859                 {
860                         struct video_tuner *vt = arg;
861
862                         if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
863                                 return 0;
864                         if (check_v4l2(t) == -EINVAL)
865                                 return 0;
866
867                         if (V4L2_TUNER_RADIO == t->mode) {
868                                 if (fe_tuner_ops->get_status) {
869                                         u32 tuner_status;
870
871                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
872                                         if (tuner_status & TUNER_STATUS_STEREO)
873                                                 vt->flags |= VIDEO_TUNER_STEREO_ON;
874                                         else
875                                                 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
876                                 } else {
877                                         if (analog_ops->is_stereo) {
878                                                 if (analog_ops->is_stereo(&t->fe))
879                                                         vt->flags |=
880                                                                 VIDEO_TUNER_STEREO_ON;
881                                                 else
882                                                         vt->flags &=
883                                                                 ~VIDEO_TUNER_STEREO_ON;
884                                         }
885                                 }
886                                 if (analog_ops->has_signal)
887                                         vt->signal =
888                                                 analog_ops->has_signal(&t->fe);
889
890                                 vt->flags |= VIDEO_TUNER_LOW;   /* Allow freqs at 62.5 Hz */
891
892                                 vt->rangelow = radio_range[0] * 16000;
893                                 vt->rangehigh = radio_range[1] * 16000;
894
895                         } else {
896                                 vt->rangelow = tv_range[0] * 16;
897                                 vt->rangehigh = tv_range[1] * 16;
898                         }
899
900                         return 0;
901                 }
902         case VIDIOCGAUDIO:
903                 {
904                         struct video_audio *va = arg;
905
906                         if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
907                                 return 0;
908                         if (check_v4l2(t) == -EINVAL)
909                                 return 0;
910
911                         if (V4L2_TUNER_RADIO == t->mode) {
912                                 if (fe_tuner_ops->get_status) {
913                                         u32 tuner_status;
914
915                                         fe_tuner_ops->get_status(&t->fe, &tuner_status);
916                                         va->mode = (tuner_status & TUNER_STATUS_STEREO)
917                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
918                                 } else if (analog_ops->is_stereo)
919                                         va->mode = analog_ops->is_stereo(&t->fe)
920                                             ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
921                         }
922                         return 0;
923                 }
924         }
925         return -ENOIOCTLCMD;
926 }
927 #endif
928
929 static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
930 {
931         struct tuner *t = to_tuner(sd);
932         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
933
934         if (t->type != cfg->tuner)
935                 return 0;
936
937         if (analog_ops->set_config) {
938                 analog_ops->set_config(&t->fe, cfg->priv);
939                 return 0;
940         }
941
942         tuner_dbg("Tuner frontend module has no way to set config\n");
943         return 0;
944 }
945
946 /* --- v4l ioctls --- */
947 /* take care: bttv does userspace copying, we'll get a
948    kernel pointer here... */
949 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
950 {
951         struct tuner *t = to_tuner(sd);
952         struct i2c_client *client = v4l2_get_subdevdata(sd);
953
954         if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
955                         == -EINVAL)
956                 return 0;
957
958         switch_v4l2();
959
960         t->std = std;
961         tuner_fixup_std(t);
962         if (t->tv_freq)
963                 set_freq(client, t->tv_freq);
964         return 0;
965 }
966
967 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
968 {
969         struct tuner *t = to_tuner(sd);
970         struct i2c_client *client = v4l2_get_subdevdata(sd);
971
972         if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
973                         == -EINVAL)
974                 return 0;
975         switch_v4l2();
976         set_freq(client, f->frequency);
977
978         return 0;
979 }
980
981 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
982 {
983         struct tuner *t = to_tuner(sd);
984         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
985
986         if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
987                 return 0;
988         switch_v4l2();
989         f->type = t->mode;
990         if (fe_tuner_ops->get_frequency) {
991                 u32 abs_freq;
992
993                 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
994                 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
995                         (abs_freq * 2 + 125/2) / 125 :
996                         (abs_freq + 62500/2) / 62500;
997                 return 0;
998         }
999         f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
1000                 t->radio_freq : t->tv_freq;
1001         return 0;
1002 }
1003
1004 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1005 {
1006         struct tuner *t = to_tuner(sd);
1007         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1008         struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1009
1010         if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1011                 return 0;
1012         switch_v4l2();
1013
1014         vt->type = t->mode;
1015         if (analog_ops->get_afc)
1016                 vt->afc = analog_ops->get_afc(&t->fe);
1017         if (t->mode == V4L2_TUNER_ANALOG_TV)
1018                 vt->capability |= V4L2_TUNER_CAP_NORM;
1019         if (t->mode != V4L2_TUNER_RADIO) {
1020                 vt->rangelow = tv_range[0] * 16;
1021                 vt->rangehigh = tv_range[1] * 16;
1022                 return 0;
1023         }
1024
1025         /* radio mode */
1026         vt->rxsubchans =
1027                 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1028         if (fe_tuner_ops->get_status) {
1029                 u32 tuner_status;
1030
1031                 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1032                 vt->rxsubchans =
1033                         (tuner_status & TUNER_STATUS_STEREO) ?
1034                         V4L2_TUNER_SUB_STEREO :
1035                         V4L2_TUNER_SUB_MONO;
1036         } else {
1037                 if (analog_ops->is_stereo) {
1038                         vt->rxsubchans =
1039                                 analog_ops->is_stereo(&t->fe) ?
1040                                 V4L2_TUNER_SUB_STEREO :
1041                                 V4L2_TUNER_SUB_MONO;
1042                 }
1043         }
1044         if (analog_ops->has_signal)
1045                 vt->signal = analog_ops->has_signal(&t->fe);
1046         vt->capability |=
1047                 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1048         vt->audmode = t->audmode;
1049         vt->rangelow = radio_range[0] * 16000;
1050         vt->rangehigh = radio_range[1] * 16000;
1051         return 0;
1052 }
1053
1054 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1055 {
1056         struct tuner *t = to_tuner(sd);
1057         struct i2c_client *client = v4l2_get_subdevdata(sd);
1058
1059         if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1060                 return 0;
1061
1062         switch_v4l2();
1063
1064         /* do nothing unless we're a radio tuner */
1065         if (t->mode != V4L2_TUNER_RADIO)
1066                 return 0;
1067         t->audmode = vt->audmode;
1068         set_radio_freq(client, t->radio_freq);
1069         return 0;
1070 }
1071
1072 static int tuner_log_status(struct v4l2_subdev *sd)
1073 {
1074         struct tuner *t = to_tuner(sd);
1075         struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1076
1077         if (analog_ops->tuner_status)
1078                 analog_ops->tuner_status(&t->fe);
1079         return 0;
1080 }
1081
1082 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1083 {
1084         return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1085 }
1086
1087 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1088 {
1089         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1090
1091         tuner_dbg("suspend\n");
1092         /* FIXME: power down ??? */
1093         return 0;
1094 }
1095
1096 static int tuner_resume(struct i2c_client *c)
1097 {
1098         struct tuner *t = to_tuner(i2c_get_clientdata(c));
1099
1100         tuner_dbg("resume\n");
1101         if (V4L2_TUNER_RADIO == t->mode) {
1102                 if (t->radio_freq)
1103                         set_freq(c, t->radio_freq);
1104         } else {
1105                 if (t->tv_freq)
1106                         set_freq(c, t->tv_freq);
1107         }
1108         return 0;
1109 }
1110
1111 /* ----------------------------------------------------------------------- */
1112
1113 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1114         .log_status = tuner_log_status,
1115         .s_standby = tuner_s_standby,
1116 #ifdef CONFIG_VIDEO_ALLOW_V4L1
1117         .ioctl = tuner_ioctl,
1118 #endif
1119 };
1120
1121 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1122         .s_std = tuner_s_std,
1123         .s_radio = tuner_s_radio,
1124         .g_tuner = tuner_g_tuner,
1125         .s_tuner = tuner_s_tuner,
1126         .s_frequency = tuner_s_frequency,
1127         .g_frequency = tuner_g_frequency,
1128         .s_type_addr = tuner_s_type_addr,
1129         .s_config = tuner_s_config,
1130 };
1131
1132 static const struct v4l2_subdev_ops tuner_ops = {
1133         .core = &tuner_core_ops,
1134         .tuner = &tuner_tuner_ops,
1135 };
1136
1137 /* ---------------------------------------------------------------------- */
1138
1139 static LIST_HEAD(tuner_list);
1140
1141 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1142    Note that when this function is called from tuner_probe you can be
1143    certain no other devices will be added/deleted at the same time, I2C
1144    core protects against that. */
1145 static void tuner_lookup(struct i2c_adapter *adap,
1146                 struct tuner **radio, struct tuner **tv)
1147 {
1148         struct tuner *pos;
1149
1150         *radio = NULL;
1151         *tv = NULL;
1152
1153         list_for_each_entry(pos, &tuner_list, list) {
1154                 int mode_mask;
1155
1156                 if (pos->i2c->adapter != adap ||
1157                     pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1158                         continue;
1159
1160                 mode_mask = pos->mode_mask & ~T_STANDBY;
1161                 if (*radio == NULL && mode_mask == T_RADIO)
1162                         *radio = pos;
1163                 /* Note: currently TDA9887 is the only demod-only
1164                    device. If other devices appear then we need to
1165                    make this test more general. */
1166                 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1167                          (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1168                         *tv = pos;
1169         }
1170 }
1171
1172 /* During client attach, set_type is called by adapter's attach_inform callback.
1173    set_type must then be completed by tuner_probe.
1174  */
1175 static int tuner_probe(struct i2c_client *client,
1176                        const struct i2c_device_id *id)
1177 {
1178         struct tuner *t;
1179         struct tuner *radio;
1180         struct tuner *tv;
1181
1182         t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1183         if (NULL == t)
1184                 return -ENOMEM;
1185         v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1186         t->i2c = client;
1187         t->name = "(tuner unset)";
1188         t->type = UNSET;
1189         t->audmode = V4L2_TUNER_MODE_STEREO;
1190         t->mode_mask = T_UNINITIALIZED;
1191
1192         if (show_i2c) {
1193                 unsigned char buffer[16];
1194                 int i, rc;
1195
1196                 memset(buffer, 0, sizeof(buffer));
1197                 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1198                 tuner_info("I2C RECV = ");
1199                 for (i = 0; i < rc; i++)
1200                         printk(KERN_CONT "%02x ", buffer[i]);
1201                 printk("\n");
1202         }
1203         /* HACK: This test was added to avoid tuner to probe tda9840 and
1204            tea6415c on the MXB card */
1205         if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1206                 kfree(t);
1207                 return -ENODEV;
1208         }
1209
1210         /* autodetection code based on the i2c addr */
1211         if (!no_autodetect) {
1212                 switch (client->addr) {
1213                 case 0x10:
1214                         if (tuner_symbol_probe(tea5761_autodetection,
1215                                                t->i2c->adapter,
1216                                                t->i2c->addr) >= 0) {
1217                                 t->type = TUNER_TEA5761;
1218                                 t->mode_mask = T_RADIO;
1219                                 t->mode = T_STANDBY;
1220                                 /* Sets freq to FM range */
1221                                 t->radio_freq = 87.5 * 16000;
1222                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1223                                 if (tv)
1224                                         tv->mode_mask &= ~T_RADIO;
1225
1226                                 goto register_client;
1227                         }
1228                         return -ENODEV;
1229                 case 0x42:
1230                 case 0x43:
1231                 case 0x4a:
1232                 case 0x4b:
1233                         /* If chip is not tda8290, don't register.
1234                            since it can be tda9887*/
1235                         if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1236                                                t->i2c->addr) >= 0) {
1237                                 tuner_dbg("tda829x detected\n");
1238                         } else {
1239                                 /* Default is being tda9887 */
1240                                 t->type = TUNER_TDA9887;
1241                                 t->mode_mask = T_RADIO | T_ANALOG_TV |
1242                                                T_DIGITAL_TV;
1243                                 t->mode = T_STANDBY;
1244                                 goto register_client;
1245                         }
1246                         break;
1247                 case 0x60:
1248                         if (tuner_symbol_probe(tea5767_autodetection,
1249                                                t->i2c->adapter, t->i2c->addr)
1250                                         >= 0) {
1251                                 t->type = TUNER_TEA5767;
1252                                 t->mode_mask = T_RADIO;
1253                                 t->mode = T_STANDBY;
1254                                 /* Sets freq to FM range */
1255                                 t->radio_freq = 87.5 * 16000;
1256                                 tuner_lookup(t->i2c->adapter, &radio, &tv);
1257                                 if (tv)
1258                                         tv->mode_mask &= ~T_RADIO;
1259
1260                                 goto register_client;
1261                         }
1262                         break;
1263                 }
1264         }
1265
1266         /* Initializes only the first TV tuner on this adapter. Why only the
1267            first? Because there are some devices (notably the ones with TI
1268            tuners) that have more than one i2c address for the *same* device.
1269            Experience shows that, except for just one case, the first
1270            address is the right one. The exception is a Russian tuner
1271            (ACORP_Y878F). So, the desired behavior is just to enable the
1272            first found TV tuner. */
1273         tuner_lookup(t->i2c->adapter, &radio, &tv);
1274         if (tv == NULL) {
1275                 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1276                 if (radio == NULL)
1277                         t->mode_mask |= T_RADIO;
1278                 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1279                 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1280                 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1281         }
1282
1283         /* Should be just before return */
1284 register_client:
1285         tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1286                        client->adapter->name);
1287
1288         /* Sets a default mode */
1289         if (t->mode_mask & T_ANALOG_TV) {
1290                 t->mode = V4L2_TUNER_ANALOG_TV;
1291         } else  if (t->mode_mask & T_RADIO) {
1292                 t->mode = V4L2_TUNER_RADIO;
1293         } else {
1294                 t->mode = V4L2_TUNER_DIGITAL_TV;
1295         }
1296         set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1297         list_add_tail(&t->list, &tuner_list);
1298         return 0;
1299 }
1300
1301 static int tuner_legacy_probe(struct i2c_adapter *adap)
1302 {
1303         if (0 != addr) {
1304                 normal_i2c[0] = addr;
1305                 normal_i2c[1] = I2C_CLIENT_END;
1306         }
1307
1308         if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1309                 return 0;
1310
1311         /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1312          * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1313          * and an RTC at 0x6f which can get corrupted if probed.
1314          */
1315         if ((adap->id == I2C_HW_B_CX2388x) ||
1316             (adap->id == I2C_HW_B_CX23885)) {
1317                 unsigned int i = 0;
1318
1319                 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1320                         i += 2;
1321                 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1322                         ignore[i+0] = adap->nr;
1323                         ignore[i+1] = 0x6b;
1324                         ignore[i+2] = adap->nr;
1325                         ignore[i+3] = 0x6f;
1326                         ignore[i+4] = I2C_CLIENT_END;
1327                 } else
1328                         printk(KERN_WARNING "tuner: "
1329                                "too many options specified "
1330                                "in i2c probe ignore list!\n");
1331         }
1332         return 1;
1333 }
1334
1335 static int tuner_remove(struct i2c_client *client)
1336 {
1337         struct tuner *t = to_tuner(i2c_get_clientdata(client));
1338
1339         v4l2_device_unregister_subdev(&t->sd);
1340         tuner_detach(&t->fe);
1341         t->fe.analog_demod_priv = NULL;
1342
1343         list_del(&t->list);
1344         kfree(t);
1345         return 0;
1346 }
1347
1348 /* ----------------------------------------------------------------------- */
1349
1350 /* This driver supports many devices and the idea is to let the driver
1351    detect which device is present. So rather than listing all supported
1352    devices here, we pretend to support a single, fake device type. */
1353 static const struct i2c_device_id tuner_id[] = {
1354         { "tuner", }, /* autodetect */
1355         { }
1356 };
1357 MODULE_DEVICE_TABLE(i2c, tuner_id);
1358
1359 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1360         .name = "tuner",
1361         .driverid = I2C_DRIVERID_TUNER,
1362         .command = tuner_command,
1363         .probe = tuner_probe,
1364         .remove = tuner_remove,
1365         .suspend = tuner_suspend,
1366         .resume = tuner_resume,
1367         .legacy_probe = tuner_legacy_probe,
1368         .id_table = tuner_id,
1369 };
1370
1371 /*
1372  * Overrides for Emacs so that we follow Linus's tabbing style.
1373  * ---------------------------------------------------------------------------
1374  * Local variables:
1375  * c-basic-offset: 8
1376  * End:
1377  */