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