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