1
2
3
4
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 "mt20xx.h"
24#include "tda8290.h"
25#include "tea5761.h"
26#include "tea5767.h"
27#include "tuner-xc2028.h"
28#include "tuner-simple.h"
29#include "tda9887.h"
30#include "xc5000.h"
31#include "tda18271.h"
32
33#define UNSET (-1U)
34
35#define PREFIX t->i2c->driver->driver.name
36
37
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
52static 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
68static 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
77struct tuner {
78
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
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;
93
94 unsigned int type;
95 unsigned int config;
96 const char *name;
97};
98
99static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
100{
101 return container_of(sd, struct tuner, sd);
102}
103
104
105
106static unsigned int addr;
107static unsigned int no_autodetect;
108static unsigned int show_i2c;
109
110
111static 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
140static unsigned int tv_range[2] = { 44, 958 };
141static unsigned int radio_range[2] = { 65, 108 };
142
143static char pal[] = "--";
144static char secam[] = "--";
145static char ntsc[] = "-";
146
147
148module_param(addr, int, 0444);
149module_param(no_autodetect, int, 0444);
150module_param(show_i2c, int, 0444);
151module_param_named(debug,tuner_debug, int, 0644);
152module_param_string(pal, pal, sizeof(pal), 0644);
153module_param_string(secam, secam, sizeof(secam), 0644);
154module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
155module_param_array(tv_range, int, NULL, 0644);
156module_param_array(radio_range, int, NULL, 0644);
157
158MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
159MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
160MODULE_LICENSE("GPL");
161
162
163
164static 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
177static 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
185static 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
195static 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
208static void tuner_status(struct dvb_frontend *fe);
209
210static 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
219static 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
243
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, ¶ms);
252}
253
254static 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
278
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, ¶ms);
287}
288
289static 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
312static struct xc5000_config xc5000_cfg;
313
314static 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 int tune_now = 1;
323
324 if (type == UNSET || type == TUNER_ABSENT) {
325 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
326 return;
327 }
328
329 t->type = type;
330
331 t->config = new_config < 256 ? new_config : 0;
332 if (tuner_callback != NULL) {
333 tuner_dbg("defining GPIO callback\n");
334 t->fe.callback = tuner_callback;
335 }
336
337 if (t->mode == T_UNINITIALIZED) {
338 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
339
340 return;
341 }
342
343
344 tuner_detach(&t->fe);
345 t->fe.analog_demod_priv = NULL;
346
347 switch (t->type) {
348 case TUNER_MT2032:
349 if (!dvb_attach(microtune_attach,
350 &t->fe, t->i2c->adapter, t->i2c->addr))
351 goto attach_failed;
352 break;
353 case TUNER_PHILIPS_TDA8290:
354 {
355 struct tda829x_config cfg = {
356 .lna_cfg = t->config,
357 };
358 if (!dvb_attach(tda829x_attach, &t->fe, t->i2c->adapter,
359 t->i2c->addr, &cfg))
360 goto attach_failed;
361 break;
362 }
363 case TUNER_TEA5767:
364 if (!dvb_attach(tea5767_attach, &t->fe,
365 t->i2c->adapter, t->i2c->addr))
366 goto attach_failed;
367 t->mode_mask = T_RADIO;
368 break;
369 case TUNER_TEA5761:
370 if (!dvb_attach(tea5761_attach, &t->fe,
371 t->i2c->adapter, t->i2c->addr))
372 goto attach_failed;
373 t->mode_mask = T_RADIO;
374 break;
375 case TUNER_PHILIPS_FMD1216ME_MK3:
376 buffer[0] = 0x0b;
377 buffer[1] = 0xdc;
378 buffer[2] = 0x9c;
379 buffer[3] = 0x60;
380 i2c_master_send(c, buffer, 4);
381 mdelay(1);
382 buffer[2] = 0x86;
383 buffer[3] = 0x54;
384 i2c_master_send(c, buffer, 4);
385 if (!dvb_attach(simple_tuner_attach, &t->fe,
386 t->i2c->adapter, t->i2c->addr, t->type))
387 goto attach_failed;
388 break;
389 case TUNER_PHILIPS_TD1316:
390 buffer[0] = 0x0b;
391 buffer[1] = 0xdc;
392 buffer[2] = 0x86;
393 buffer[3] = 0xa4;
394 i2c_master_send(c, buffer, 4);
395 if (!dvb_attach(simple_tuner_attach, &t->fe,
396 t->i2c->adapter, t->i2c->addr, t->type))
397 goto attach_failed;
398 break;
399 case TUNER_XC2028:
400 {
401 struct xc2028_config cfg = {
402 .i2c_adap = t->i2c->adapter,
403 .i2c_addr = t->i2c->addr,
404 };
405 if (!dvb_attach(xc2028_attach, &t->fe, &cfg))
406 goto attach_failed;
407 tune_now = 0;
408 break;
409 }
410 case TUNER_TDA9887:
411 if (!dvb_attach(tda9887_attach,
412 &t->fe, t->i2c->adapter, t->i2c->addr))
413 goto attach_failed;
414 break;
415 case TUNER_XC5000:
416 {
417 xc5000_cfg.i2c_address = t->i2c->addr;
418
419 xc5000_cfg.if_khz = 0;
420 if (!dvb_attach(xc5000_attach,
421 &t->fe, t->i2c->adapter, &xc5000_cfg))
422 goto attach_failed;
423 tune_now = 0;
424 break;
425 }
426 case TUNER_NXP_TDA18271:
427 {
428 struct tda18271_config cfg = {
429 .config = t->config,
430 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
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
466
467
468
469
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
480attach_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
490
491
492
493
494
495
496static 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
512static 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
533static 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
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
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
639 break;
640 default:
641 tuner_info("ntsc= argument not recognised\n");
642 break;
643 }
644 }
645 return 0;
646}
647
648static 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
695
696
697
698
699
700static 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
724static inline int check_v4l2(struct tuner *t)
725{
726
727
728
729
730 return 0;
731}
732
733static 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
748static 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
760static 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
778static 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
796
797
798static 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
815static 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
828static 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
851static 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
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
901static 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
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
919static 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
929static 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
935 return 0;
936}
937
938static 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
953static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
954{
955 struct v4l2_subdev *sd = i2c_get_clientdata(client);
956
957
958
959
960 switch (cmd) {
961 case TUNER_SET_CONFIG:
962 return tuner_s_config(sd, arg);
963 }
964 return -ENOIOCTLCMD;
965}
966
967
968
969static 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
975static 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
985static const struct v4l2_subdev_ops tuner_ops = {
986 .core = &tuner_core_ops,
987 .tuner = &tuner_tuner_ops,
988};
989
990
991
992static LIST_HEAD(tuner_list);
993
994
995
996
997
998static 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
1017
1018
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
1026
1027
1028static 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
1057
1058 if (!no_autodetect) {
1059 switch (client->addr) {
1060 case 0x10:
1061 if (tuner_symbol_probe(tea5761_autodetection,
1062 t->i2c->adapter,
1063 t->i2c->addr) >= 0) {
1064 t->type = TUNER_TEA5761;
1065 t->mode_mask = T_RADIO;
1066 t->mode = T_STANDBY;
1067
1068 t->radio_freq = 87.5 * 16000;
1069 tuner_lookup(t->i2c->adapter, &radio, &tv);
1070 if (tv)
1071 tv->mode_mask &= ~T_RADIO;
1072
1073 goto register_client;
1074 }
1075 kfree(t);
1076 return -ENODEV;
1077 case 0x42:
1078 case 0x43:
1079 case 0x4a:
1080 case 0x4b:
1081
1082
1083 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1084 t->i2c->addr) >= 0) {
1085 tuner_dbg("tda829x detected\n");
1086 } else {
1087
1088 t->type = TUNER_TDA9887;
1089 t->mode_mask = T_RADIO | T_ANALOG_TV |
1090 T_DIGITAL_TV;
1091 t->mode = T_STANDBY;
1092 goto register_client;
1093 }
1094 break;
1095 case 0x60:
1096 if (tuner_symbol_probe(tea5767_autodetection,
1097 t->i2c->adapter, t->i2c->addr)
1098 >= 0) {
1099 t->type = TUNER_TEA5767;
1100 t->mode_mask = T_RADIO;
1101 t->mode = T_STANDBY;
1102
1103 t->radio_freq = 87.5 * 16000;
1104 tuner_lookup(t->i2c->adapter, &radio, &tv);
1105 if (tv)
1106 tv->mode_mask &= ~T_RADIO;
1107
1108 goto register_client;
1109 }
1110 break;
1111 }
1112 }
1113
1114
1115
1116
1117
1118
1119
1120
1121 tuner_lookup(t->i2c->adapter, &radio, &tv);
1122 if (tv == NULL) {
1123 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1124 if (radio == NULL)
1125 t->mode_mask |= T_RADIO;
1126 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1127 t->tv_freq = 400 * 16;
1128 t->radio_freq = 87.5 * 16000;
1129 }
1130
1131
1132register_client:
1133 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1134 client->adapter->name);
1135
1136
1137 if (t->mode_mask & T_ANALOG_TV) {
1138 t->mode = V4L2_TUNER_ANALOG_TV;
1139 } else if (t->mode_mask & T_RADIO) {
1140 t->mode = V4L2_TUNER_RADIO;
1141 } else {
1142 t->mode = V4L2_TUNER_DIGITAL_TV;
1143 }
1144 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1145 list_add_tail(&t->list, &tuner_list);
1146 return 0;
1147}
1148
1149static int tuner_remove(struct i2c_client *client)
1150{
1151 struct tuner *t = to_tuner(i2c_get_clientdata(client));
1152
1153 v4l2_device_unregister_subdev(&t->sd);
1154 tuner_detach(&t->fe);
1155 t->fe.analog_demod_priv = NULL;
1156
1157 list_del(&t->list);
1158 kfree(t);
1159 return 0;
1160}
1161
1162
1163
1164
1165
1166
1167static const struct i2c_device_id tuner_id[] = {
1168 { "tuner", },
1169 { }
1170};
1171MODULE_DEVICE_TABLE(i2c, tuner_id);
1172
1173static struct i2c_driver tuner_driver = {
1174 .driver = {
1175 .owner = THIS_MODULE,
1176 .name = "tuner",
1177 },
1178 .probe = tuner_probe,
1179 .remove = tuner_remove,
1180 .command = tuner_command,
1181 .suspend = tuner_suspend,
1182 .resume = tuner_resume,
1183 .id_table = tuner_id,
1184};
1185
1186static __init int init_tuner(void)
1187{
1188 return i2c_add_driver(&tuner_driver);
1189}
1190
1191static __exit void exit_tuner(void)
1192{
1193 i2c_del_driver(&tuner_driver);
1194}
1195
1196module_init(init_tuner);
1197module_exit(exit_tuner);
1198
1199
1200
1201
1202
1203
1204
1205
1206