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