?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ftrace: do_each_pid_task() needs rcu lock
[linux-2.6/cjktty.git] / drivers / media / video / tuner-core.c
blob30640fbfd0f921ad0734eb939a533bfea1e7fc0e
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 xc5000_cfg.if_khz = 5380;
456 if (!dvb_attach(xc5000_attach,
457 &t->fe, t->i2c->adapter, &xc5000_cfg))
458 goto attach_failed;
459
460 xc_tuner_ops = &t->fe.ops.tuner_ops;
461 if (xc_tuner_ops->init)
462 xc_tuner_ops->init(&t->fe);
463 break;
464 }
465 default:
466 if (!dvb_attach(simple_tuner_attach, &t->fe,
467 t->i2c->adapter, t->i2c->addr, t->type))
468 goto attach_failed;
469
470 break;
471 }
472
473 if ((NULL == analog_ops->set_params) &&
474 (fe_tuner_ops->set_analog_params)) {
475
476 t->name = fe_tuner_ops->info.name;
477
478 t->fe.analog_demod_priv = t;
479 memcpy(analog_ops, &tuner_analog_ops,
480 sizeof(struct analog_demod_ops));
481
482 } else {
483 t->name = analog_ops->info.name;
484 }
485
486 tuner_dbg("type set to %s\n", t->name);
487
488 if (t->mode_mask == T_UNINITIALIZED)
489 t->mode_mask = new_mode_mask;
490
491 /* xc2028/3028 and xc5000 requires a firmware to be set-up later
492 trying to set a frequency here will just fail
493 FIXME: better to move set_freq to the tuner code. This is needed
494 on analog tuners for PLL to properly work
495 */
496 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
497 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
498 t->radio_freq : t->tv_freq);
499
500 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
501 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
502 t->mode_mask);
503 tuner_i2c_address_check(t);
504 return;
505
506 attach_failed:
507 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
508 t->type = TUNER_ABSENT;
509 t->mode_mask = T_UNINITIALIZED;
510
511 return;
512 }
513
514 /*
515 * This function apply tuner config to tuner specified
516 * by tun_setup structure. I addr is unset, then admin status
517 * and tun addr status is more precise then current status,
518 * it's applied. Otherwise status and type are applied only to
519 * tuner with exactly the same addr.
520 */
521
522 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
523 {
524 struct tuner *t = to_tuner(i2c_get_clientdata(c));
525
526 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
527 (t->mode_mask & tun_setup->mode_mask))) ||
528 (tun_setup->addr == c->addr)) {
529 set_type(c, tun_setup->type, tun_setup->mode_mask,
530 tun_setup->config, tun_setup->tuner_callback);
531 } else
532 tuner_dbg("set addr discarded for type %i, mask %x. "
533 "Asked to change tuner at addr 0x%02x, with mask %x\n",
534 t->type, t->mode_mask,
535 tun_setup->addr, tun_setup->mode_mask);
536 }
537
538 static inline int check_mode(struct tuner *t, char *cmd)
539 {
540 if ((1 << t->mode & t->mode_mask) == 0) {
541 return -EINVAL;
542 }
543
544 switch (t->mode) {
545 case V4L2_TUNER_RADIO:
546 tuner_dbg("Cmd %s accepted for radio\n", cmd);
547 break;
548 case V4L2_TUNER_ANALOG_TV:
549 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
550 break;
551 case V4L2_TUNER_DIGITAL_TV:
552 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
553 break;
554 }
555 return 0;
556 }
557
558 /* get more precise norm info from insmod option */
559 static int tuner_fixup_std(struct tuner *t)
560 {
561 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
562 switch (pal[0]) {
563 case '6':
564 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
565 t->std = V4L2_STD_PAL_60;
566 break;
567 case 'b':
568 case 'B':
569 case 'g':
570 case 'G':
571 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
572 t->std = V4L2_STD_PAL_BG;
573 break;
574 case 'i':
575 case 'I':
576 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
577 t->std = V4L2_STD_PAL_I;
578 break;
579 case 'd':
580 case 'D':
581 case 'k':
582 case 'K':
583 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
584 t->std = V4L2_STD_PAL_DK;
585 break;
586 case 'M':
587 case 'm':
588 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
589 t->std = V4L2_STD_PAL_M;
590 break;
591 case 'N':
592 case 'n':
593 if (pal[1] == 'c' || pal[1] == 'C') {
594 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
595 t->std = V4L2_STD_PAL_Nc;
596 } else {
597 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
598 t->std = V4L2_STD_PAL_N;
599 }
600 break;
601 case '-':
602 /* default parameter, do nothing */
603 break;
604 default:
605 tuner_warn ("pal= argument not recognised\n");
606 break;
607 }
608 }
609 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
610 switch (secam[0]) {
611 case 'b':
612 case 'B':
613 case 'g':
614 case 'G':
615 case 'h':
616 case 'H':
617 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
618 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
619 break;
620 case 'd':
621 case 'D':
622 case 'k':
623 case 'K':
624 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
625 t->std = V4L2_STD_SECAM_DK;
626 break;
627 case 'l':
628 case 'L':
629 if ((secam[1]=='C')||(secam[1]=='c')) {
630 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
631 t->std = V4L2_STD_SECAM_LC;
632 } else {
633 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
634 t->std = V4L2_STD_SECAM_L;
635 }
636 break;
637 case '-':
638 /* default parameter, do nothing */
639 break;
640 default:
641 tuner_warn ("secam= argument not recognised\n");
642 break;
643 }
644 }
645
646 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
647 switch (ntsc[0]) {
648 case 'm':
649 case 'M':
650 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
651 t->std = V4L2_STD_NTSC_M;
652 break;
653 case 'j':
654 case 'J':
655 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
656 t->std = V4L2_STD_NTSC_M_JP;
657 break;
658 case 'k':
659 case 'K':
660 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
661 t->std = V4L2_STD_NTSC_M_KR;
662 break;
663 case '-':
664 /* default parameter, do nothing */
665 break;
666 default:
667 tuner_info("ntsc= argument not recognised\n");
668 break;
669 }
670 }
671 return 0;
672 }
673
674 static void tuner_status(struct dvb_frontend *fe)
675 {
676 struct tuner *t = fe->analog_demod_priv;
677 unsigned long freq, freq_fraction;
678 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
679 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
680 const char *p;
681
682 switch (t->mode) {
683 case V4L2_TUNER_RADIO: p = "radio"; break;
684 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
685 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
686 default: p = "undefined"; break;
687 }
688 if (t->mode == V4L2_TUNER_RADIO) {
689 freq = t->radio_freq / 16000;
690 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
691 } else {
692 freq = t->tv_freq / 16;
693 freq_fraction = (t->tv_freq % 16) * 100 / 16;
694 }
695 tuner_info("Tuner mode: %s\n", p);
696 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
697 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
698 if (t->mode != V4L2_TUNER_RADIO)
699 return;
700 if (fe_tuner_ops->get_status) {
701 u32 tuner_status;
702
703 fe_tuner_ops->get_status(&t->fe, &tuner_status);
704 if (tuner_status & TUNER_STATUS_LOCKED)
705 tuner_info("Tuner is locked.\n");
706 if (tuner_status & TUNER_STATUS_STEREO)
707 tuner_info("Stereo: yes\n");
708 }
709 if (analog_ops->has_signal)
710 tuner_info("Signal strength: %d\n",
711 analog_ops->has_signal(fe));
712 if (analog_ops->is_stereo)
713 tuner_info("Stereo: %s\n",
714 analog_ops->is_stereo(fe) ? "yes" : "no");
715 }
716
717 /* ---------------------------------------------------------------------- */
718
719 /*
720 * Switch tuner to other mode. If tuner support both tv and radio,
721 * set another frequency to some value (This is needed for some pal
722 * tuners to avoid locking). Otherwise, just put second tuner in
723 * standby mode.
724 */
725
726 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
727 {
728 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
729
730 if (mode == t->mode)
731 return 0;
732
733 t->mode = mode;
734
735 if (check_mode(t, cmd) == -EINVAL) {
736 tuner_dbg("Tuner doesn't support this mode. "
737 "Putting tuner to sleep\n");
738 t->mode = T_STANDBY;
739 if (analog_ops->standby)
740 analog_ops->standby(&t->fe);
741 return -EINVAL;
742 }
743 return 0;
744 }
745
746 #define switch_v4l2() if (!t->using_v4l2) \
747 tuner_dbg("switching to v4l2\n"); \
748 t->using_v4l2 = 1;
749
750 static inline int check_v4l2(struct tuner *t)
751 {
752 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
753 TV, v4l1 for radio), until that is fixed this code is disabled.
754 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
755 first. */
756 return 0;
757 }
758
759 static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
760 {
761 struct tuner *t = to_tuner(sd);
762 struct i2c_client *client = v4l2_get_subdevdata(sd);
763
764 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
765 type->type,
766 type->addr,
767 type->mode_mask,
768 type->config);
769
770 set_addr(client, type);
771 return 0;
772 }
773
774 static int tuner_s_radio(struct v4l2_subdev *sd)
775 {
776 struct tuner *t = to_tuner(sd);
777 struct i2c_client *client = v4l2_get_subdevdata(sd);
778
779 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
780 == -EINVAL)
781 return 0;
782 if (t->radio_freq)
783 set_freq(client, t->radio_freq);
784 return 0;
785 }
786
787 static int tuner_s_standby(struct v4l2_subdev *sd, u32 standby)
788 {
789 struct tuner *t = to_tuner(sd);
790 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
791
792 tuner_dbg("Putting tuner to sleep\n");
793
794 if (check_mode(t, "TUNER_SET_STANDBY") == -EINVAL)
795 return 0;
796 t->mode = T_STANDBY;
797 if (analog_ops->standby)
798 analog_ops->standby(&t->fe);
799 return 0;
800 }
801
802 #ifdef CONFIG_VIDEO_ALLOW_V4L1
803 static long tuner_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
804 {
805 struct tuner *t = to_tuner(sd);
806 struct i2c_client *client = v4l2_get_subdevdata(sd);
807 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
808 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
809
810 switch (cmd) {
811 case VIDIOCSAUDIO:
812 if (check_mode(t, "VIDIOCSAUDIO") == -EINVAL)
813 return 0;
814 if (check_v4l2(t) == -EINVAL)
815 return 0;
816
817 /* Should be implemented, since bttv calls it */
818 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
819 break;
820 case VIDIOCSCHAN:
821 {
822 static const v4l2_std_id map[] = {
823 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
824 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
825 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
826 [4 /* bttv */ ] = V4L2_STD_PAL_M,
827 [5 /* bttv */ ] = V4L2_STD_PAL_N,
828 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
829 };
830 struct video_channel *vc = arg;
831
832 if (check_v4l2(t) == -EINVAL)
833 return 0;
834
835 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==-EINVAL)
836 return 0;
837
838 if (vc->norm < ARRAY_SIZE(map))
839 t->std = map[vc->norm];
840 tuner_fixup_std(t);
841 if (t->tv_freq)
842 set_tv_freq(client, t->tv_freq);
843 return 0;
844 }
845 case VIDIOCSFREQ:
846 {
847 unsigned long *v = arg;
848
849 if (check_mode(t, "VIDIOCSFREQ") == -EINVAL)
850 return 0;
851 if (check_v4l2(t) == -EINVAL)
852 return 0;
853
854 set_freq(client, *v);
855 return 0;
856 }
857 case VIDIOCGTUNER:
858 {
859 struct video_tuner *vt = arg;
860
861 if (check_mode(t, "VIDIOCGTUNER") == -EINVAL)
862 return 0;
863 if (check_v4l2(t) == -EINVAL)
864 return 0;
865
866 if (V4L2_TUNER_RADIO == t->mode) {
867 if (fe_tuner_ops->get_status) {
868 u32 tuner_status;
869
870 fe_tuner_ops->get_status(&t->fe, &tuner_status);
871 if (tuner_status & TUNER_STATUS_STEREO)
872 vt->flags |= VIDEO_TUNER_STEREO_ON;
873 else
874 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
875 } else {
876 if (analog_ops->is_stereo) {
877 if (analog_ops->is_stereo(&t->fe))
878 vt->flags |=
879 VIDEO_TUNER_STEREO_ON;
880 else
881 vt->flags &=
882 ~VIDEO_TUNER_STEREO_ON;
883 }
884 }
885 if (analog_ops->has_signal)
886 vt->signal =
887 analog_ops->has_signal(&t->fe);
888
889 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
890
891 vt->rangelow = radio_range[0] * 16000;
892 vt->rangehigh = radio_range[1] * 16000;
893
894 } else {
895 vt->rangelow = tv_range[0] * 16;
896 vt->rangehigh = tv_range[1] * 16;
897 }
898
899 return 0;
900 }
901 case VIDIOCGAUDIO:
902 {
903 struct video_audio *va = arg;
904
905 if (check_mode(t, "VIDIOCGAUDIO") == -EINVAL)
906 return 0;
907 if (check_v4l2(t) == -EINVAL)
908 return 0;
909
910 if (V4L2_TUNER_RADIO == t->mode) {
911 if (fe_tuner_ops->get_status) {
912 u32 tuner_status;
913
914 fe_tuner_ops->get_status(&t->fe, &tuner_status);
915 va->mode = (tuner_status & TUNER_STATUS_STEREO)
916 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
917 } else if (analog_ops->is_stereo)
918 va->mode = analog_ops->is_stereo(&t->fe)
919 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
920 }
921 return 0;
922 }
923 }
924 return -ENOIOCTLCMD;
925 }
926 #endif
927
928 static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
929 {
930 struct tuner *t = to_tuner(sd);
931 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
932
933 if (t->type != cfg->tuner)
934 return 0;
935
936 if (analog_ops->set_config) {
937 analog_ops->set_config(&t->fe, cfg->priv);
938 return 0;
939 }
940
941 tuner_dbg("Tuner frontend module has no way to set config\n");
942 return 0;
943 }
944
945 /* --- v4l ioctls --- */
946 /* take care: bttv does userspace copying, we'll get a
947 kernel pointer here... */
948 static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
949 {
950 struct tuner *t = to_tuner(sd);
951 struct i2c_client *client = v4l2_get_subdevdata(sd);
952
953 if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
954 == -EINVAL)
955 return 0;
956
957 switch_v4l2();
958
959 t->std = std;
960 tuner_fixup_std(t);
961 if (t->tv_freq)
962 set_freq(client, t->tv_freq);
963 return 0;
964 }
965
966 static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
967 {
968 struct tuner *t = to_tuner(sd);
969 struct i2c_client *client = v4l2_get_subdevdata(sd);
970
971 if (set_mode(client, t, f->type, "VIDIOC_S_FREQUENCY")
972 == -EINVAL)
973 return 0;
974 switch_v4l2();
975 set_freq(client, f->frequency);
976
977 return 0;
978 }
979
980 static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
981 {
982 struct tuner *t = to_tuner(sd);
983 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
984
985 if (check_mode(t, "VIDIOC_G_FREQUENCY") == -EINVAL)
986 return 0;
987 switch_v4l2();
988 f->type = t->mode;
989 if (fe_tuner_ops->get_frequency) {
990 u32 abs_freq;
991
992 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
993 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
994 (abs_freq * 2 + 125/2) / 125 :
995 (abs_freq + 62500/2) / 62500;
996 return 0;
997 }
998 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
999 t->radio_freq : t->tv_freq;
1000 return 0;
1001 }
1002
1003 static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1004 {
1005 struct tuner *t = to_tuner(sd);
1006 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1007 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
1008
1009 if (check_mode(t, "VIDIOC_G_TUNER") == -EINVAL)
1010 return 0;
1011 switch_v4l2();
1012
1013 vt->type = t->mode;
1014 if (analog_ops->get_afc)
1015 vt->afc = analog_ops->get_afc(&t->fe);
1016 if (t->mode == V4L2_TUNER_ANALOG_TV)
1017 vt->capability |= V4L2_TUNER_CAP_NORM;
1018 if (t->mode != V4L2_TUNER_RADIO) {
1019 vt->rangelow = tv_range[0] * 16;
1020 vt->rangehigh = tv_range[1] * 16;
1021 return 0;
1022 }
1023
1024 /* radio mode */
1025 vt->rxsubchans =
1026 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
1027 if (fe_tuner_ops->get_status) {
1028 u32 tuner_status;
1029
1030 fe_tuner_ops->get_status(&t->fe, &tuner_status);
1031 vt->rxsubchans =
1032 (tuner_status & TUNER_STATUS_STEREO) ?
1033 V4L2_TUNER_SUB_STEREO :
1034 V4L2_TUNER_SUB_MONO;
1035 } else {
1036 if (analog_ops->is_stereo) {
1037 vt->rxsubchans =
1038 analog_ops->is_stereo(&t->fe) ?
1039 V4L2_TUNER_SUB_STEREO :
1040 V4L2_TUNER_SUB_MONO;
1041 }
1042 }
1043 if (analog_ops->has_signal)
1044 vt->signal = analog_ops->has_signal(&t->fe);
1045 vt->capability |=
1046 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1047 vt->audmode = t->audmode;
1048 vt->rangelow = radio_range[0] * 16000;
1049 vt->rangehigh = radio_range[1] * 16000;
1050 return 0;
1051 }
1052
1053 static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1054 {
1055 struct tuner *t = to_tuner(sd);
1056 struct i2c_client *client = v4l2_get_subdevdata(sd);
1057
1058 if (check_mode(t, "VIDIOC_S_TUNER") == -EINVAL)
1059 return 0;
1060
1061 switch_v4l2();
1062
1063 /* do nothing unless we're a radio tuner */
1064 if (t->mode != V4L2_TUNER_RADIO)
1065 return 0;
1066 t->audmode = vt->audmode;
1067 set_radio_freq(client, t->radio_freq);
1068 return 0;
1069 }
1070
1071 static int tuner_log_status(struct v4l2_subdev *sd)
1072 {
1073 struct tuner *t = to_tuner(sd);
1074 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1075
1076 if (analog_ops->tuner_status)
1077 analog_ops->tuner_status(&t->fe);
1078 return 0;
1079 }
1080
1081 static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
1082 {
1083 return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1084 }
1085
1086 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1087 {
1088 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1089
1090 tuner_dbg("suspend\n");
1091 /* FIXME: power down ??? */
1092 return 0;
1093 }
1094
1095 static int tuner_resume(struct i2c_client *c)
1096 {
1097 struct tuner *t = to_tuner(i2c_get_clientdata(c));
1098
1099 tuner_dbg("resume\n");
1100 if (V4L2_TUNER_RADIO == t->mode) {
1101 if (t->radio_freq)
1102 set_freq(c, t->radio_freq);
1103 } else {
1104 if (t->tv_freq)
1105 set_freq(c, t->tv_freq);
1106 }
1107 return 0;
1108 }
1109
1110 /* ----------------------------------------------------------------------- */
1111
1112 static const struct v4l2_subdev_core_ops tuner_core_ops = {
1113 .log_status = tuner_log_status,
1114 .s_standby = tuner_s_standby,
1115 #ifdef CONFIG_VIDEO_ALLOW_V4L1
1116 .ioctl = tuner_ioctl,
1117 #endif
1118 };
1119
1120 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
1121 .s_std = tuner_s_std,
1122 .s_radio = tuner_s_radio,
1123 .g_tuner = tuner_g_tuner,
1124 .s_tuner = tuner_s_tuner,
1125 .s_frequency = tuner_s_frequency,
1126 .g_frequency = tuner_g_frequency,
1127 .s_type_addr = tuner_s_type_addr,
1128 .s_config = tuner_s_config,
1129 };
1130
1131 static const struct v4l2_subdev_ops tuner_ops = {
1132 .core = &tuner_core_ops,
1133 .tuner = &tuner_tuner_ops,
1134 };
1135
1136 /* ---------------------------------------------------------------------- */
1137
1138 static LIST_HEAD(tuner_list);
1139
1140 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1141 Note that when this function is called from tuner_probe you can be
1142 certain no other devices will be added/deleted at the same time, I2C
1143 core protects against that. */
1144 static void tuner_lookup(struct i2c_adapter *adap,
1145 struct tuner **radio, struct tuner **tv)
1146 {
1147 struct tuner *pos;
1148
1149 *radio = NULL;
1150 *tv = NULL;
1151
1152 list_for_each_entry(pos, &tuner_list, list) {
1153 int mode_mask;
1154
1155 if (pos->i2c->adapter != adap ||
1156 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1157 continue;
1158
1159 mode_mask = pos->mode_mask & ~T_STANDBY;
1160 if (*radio == NULL && mode_mask == T_RADIO)
1161 *radio = pos;
1162 /* Note: currently TDA9887 is the only demod-only
1163 device. If other devices appear then we need to
1164 make this test more general. */
1165 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1166 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1167 *tv = pos;
1168 }
1169 }
1170
1171 /* During client attach, set_type is called by adapter's attach_inform callback.
1172 set_type must then be completed by tuner_probe.
1173 */
1174 static int tuner_probe(struct i2c_client *client,
1175 const struct i2c_device_id *id)
1176 {
1177 struct tuner *t;
1178 struct tuner *radio;
1179 struct tuner *tv;
1180
1181 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1182 if (NULL == t)
1183 return -ENOMEM;
1184 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1185 t->i2c = client;
1186 t->name = "(tuner unset)";
1187 t->type = UNSET;
1188 t->audmode = V4L2_TUNER_MODE_STEREO;
1189 t->mode_mask = T_UNINITIALIZED;
1190
1191 if (show_i2c) {
1192 unsigned char buffer[16];
1193 int i, rc;
1194
1195 memset(buffer, 0, sizeof(buffer));
1196 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1197 tuner_info("I2C RECV = ");
1198 for (i = 0; i < rc; i++)
1199 printk(KERN_CONT "%02x ", buffer[i]);
1200 printk("\n");
1201 }
1202 /* HACK: This test was added to avoid tuner to probe tda9840 and
1203 tea6415c on the MXB card */
1204 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1205 kfree(t);
1206 return -ENODEV;
1207 }
1208
1209 /* autodetection code based on the i2c addr */
1210 if (!no_autodetect) {
1211 switch (client->addr) {
1212 case 0x10:
1213 if (tuner_symbol_probe(tea5761_autodetection,
1214 t->i2c->adapter,
1215 t->i2c->addr) >= 0) {
1216 t->type = TUNER_TEA5761;
1217 t->mode_mask = T_RADIO;
1218 t->mode = T_STANDBY;
1219 /* Sets freq to FM range */
1220 t->radio_freq = 87.5 * 16000;
1221 tuner_lookup(t->i2c->adapter, &radio, &tv);
1222 if (tv)
1223 tv->mode_mask &= ~T_RADIO;
1224
1225 goto register_client;
1226 }
1227 return -ENODEV;
1228 case 0x42:
1229 case 0x43:
1230 case 0x4a:
1231 case 0x4b:
1232 /* If chip is not tda8290, don't register.
1233 since it can be tda9887*/
1234 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1235 t->i2c->addr) >= 0) {
1236 tuner_dbg("tda829x detected\n");
1237 } else {
1238 /* Default is being tda9887 */
1239 t->type = TUNER_TDA9887;
1240 t->mode_mask = T_RADIO | T_ANALOG_TV |
1241 T_DIGITAL_TV;
1242 t->mode = T_STANDBY;
1243 goto register_client;
1244 }
1245 break;
1246 case 0x60:
1247 if (tuner_symbol_probe(tea5767_autodetection,
1248 t->i2c->adapter, t->i2c->addr)
1249 >= 0) {
1250 t->type = TUNER_TEA5767;
1251 t->mode_mask = T_RADIO;
1252 t->mode = T_STANDBY;
1253 /* Sets freq to FM range */
1254 t->radio_freq = 87.5 * 16000;
1255 tuner_lookup(t->i2c->adapter, &radio, &tv);
1256 if (tv)
1257 tv->mode_mask &= ~T_RADIO;
1258
1259 goto register_client;
1260 }
1261 break;
1262 }
1263 }
1264
1265 /* Initializes only the first TV tuner on this adapter. Why only the
1266 first? Because there are some devices (notably the ones with TI
1267 tuners) that have more than one i2c address for the *same* device.
1268 Experience shows that, except for just one case, the first
1269 address is the right one. The exception is a Russian tuner
1270 (ACORP_Y878F). So, the desired behavior is just to enable the
1271 first found TV tuner. */
1272 tuner_lookup(t->i2c->adapter, &radio, &tv);
1273 if (tv == NULL) {
1274 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1275 if (radio == NULL)
1276 t->mode_mask |= T_RADIO;
1277 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1278 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1279 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1280 }
1281
1282 /* Should be just before return */
1283 register_client:
1284 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1285 client->adapter->name);
1286
1287 /* Sets a default mode */
1288 if (t->mode_mask & T_ANALOG_TV) {
1289 t->mode = V4L2_TUNER_ANALOG_TV;
1290 } else if (t->mode_mask & T_RADIO) {
1291 t->mode = V4L2_TUNER_RADIO;
1292 } else {
1293 t->mode = V4L2_TUNER_DIGITAL_TV;
1294 }
1295 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1296 list_add_tail(&t->list, &tuner_list);
1297 return 0;
1298 }
1299
1300 static int tuner_legacy_probe(struct i2c_adapter *adap)
1301 {
1302 if (0 != addr) {
1303 normal_i2c[0] = addr;
1304 normal_i2c[1] = I2C_CLIENT_END;
1305 }
1306
1307 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1308 return 0;
1309
1310 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1311 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1312 * and an RTC at 0x6f which can get corrupted if probed.
1313 */
1314 if ((adap->id == I2C_HW_B_CX2388x) ||
1315 (adap->id == I2C_HW_B_CX23885)) {
1316 unsigned int i = 0;
1317
1318 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1319 i += 2;
1320 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1321 ignore[i+0] = adap->nr;
1322 ignore[i+1] = 0x6b;
1323 ignore[i+2] = adap->nr;
1324 ignore[i+3] = 0x6f;
1325 ignore[i+4] = I2C_CLIENT_END;
1326 } else
1327 printk(KERN_WARNING "tuner: "
1328 "too many options specified "
1329 "in i2c probe ignore list!\n");
1330 }
1331 return 1;
1332 }
1333
1334 static int tuner_remove(struct i2c_client *client)
1335 {
1336 struct tuner *t = to_tuner(i2c_get_clientdata(client));
1337
1338 v4l2_device_unregister_subdev(&t->sd);
1339 tuner_detach(&t->fe);
1340 t->fe.analog_demod_priv = NULL;
1341
1342 list_del(&t->list);
1343 kfree(t);
1344 return 0;
1345 }
1346
1347 /* ----------------------------------------------------------------------- */
1348
1349 /* This driver supports many devices and the idea is to let the driver
1350 detect which device is present. So rather than listing all supported
1351 devices here, we pretend to support a single, fake device type. */
1352 static const struct i2c_device_id tuner_id[] = {
1353 { "tuner", }, /* autodetect */
1354 { }
1355 };
1356 MODULE_DEVICE_TABLE(i2c, tuner_id);
1357
1358 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1359 .name = "tuner",
1360 .driverid = I2C_DRIVERID_TUNER,
1361 .command = tuner_command,
1362 .probe = tuner_probe,
1363 .remove = tuner_remove,
1364 .suspend = tuner_suspend,
1365 .resume = tuner_resume,
1366 .legacy_probe = tuner_legacy_probe,
1367 .id_table = tuner_id,
1368 };
1369
1370 /*
1371 * Overrides for Emacs so that we follow Linus's tabbing style.
1372 * ---------------------------------------------------------------------------
1373 * Local variables:
1374 * c-basic-offset: 8
1375 * End:
1376 */
CJK support for tty framebuffer vt