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 <media/v4l2-i2c-drv.h>
24#include "mt20xx.h"
25#include "tda8290.h"
26#include "tea5761.h"
27#include "tea5767.h"
28#include "tuner-xc2028.h"
29#include "tuner-simple.h"
30#include "tda9887.h"
31#include "xc5000.h"
32#include "tda18271.h"
33
34#define UNSET (-1U)
35
36#define PREFIX t->i2c->driver->driver.name
37
38
39#ifdef CONFIG_MEDIA_ATTACH
40#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
41 int __r = -EINVAL; \
42 typeof(&FUNCTION) __a = symbol_request(FUNCTION); \
43 if (__a) { \
44 __r = (int) __a(ARGS); \
45 symbol_put(FUNCTION); \
46 } else { \
47 printk(KERN_ERR "TUNER: Unable to find " \
48 "symbol "#FUNCTION"()\n"); \
49 } \
50 __r; \
51})
52
53static void tuner_detach(struct dvb_frontend *fe)
54{
55 if (fe->ops.tuner_ops.release) {
56 fe->ops.tuner_ops.release(fe);
57 symbol_put_addr(fe->ops.tuner_ops.release);
58 }
59 if (fe->ops.analog_ops.release) {
60 fe->ops.analog_ops.release(fe);
61 symbol_put_addr(fe->ops.analog_ops.release);
62 }
63}
64#else
65#define tuner_symbol_probe(FUNCTION, ARGS...) ({ \
66 FUNCTION(ARGS); \
67})
68
69static void tuner_detach(struct dvb_frontend *fe)
70{
71 if (fe->ops.tuner_ops.release)
72 fe->ops.tuner_ops.release(fe);
73 if (fe->ops.analog_ops.release)
74 fe->ops.analog_ops.release(fe);
75}
76#endif
77
78struct tuner {
79
80 struct dvb_frontend fe;
81 struct i2c_client *i2c;
82 struct v4l2_subdev sd;
83 struct list_head list;
84 unsigned int using_v4l2:1;
85
86
87 v4l2_std_id std;
88 unsigned int tv_freq;
89 unsigned int radio_freq;
90 unsigned int audmode;
91
92 unsigned int mode;
93 unsigned int mode_mask;
94
95 unsigned int type;
96 unsigned int config;
97 const char *name;
98};
99
100static inline struct tuner *to_tuner(struct v4l2_subdev *sd)
101{
102 return container_of(sd, struct tuner, sd);
103}
104
105
106
107static unsigned int addr;
108static unsigned int no_autodetect;
109static unsigned int show_i2c;
110
111
112static int tuner_debug;
113
114#define tuner_warn(fmt, arg...) do { \
115 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
116 i2c_adapter_id(t->i2c->adapter), \
117 t->i2c->addr, ##arg); \
118 } while (0)
119
120#define tuner_info(fmt, arg...) do { \
121 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
122 i2c_adapter_id(t->i2c->adapter), \
123 t->i2c->addr, ##arg); \
124 } while (0)
125
126#define tuner_err(fmt, arg...) do { \
127 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
128 i2c_adapter_id(t->i2c->adapter), \
129 t->i2c->addr, ##arg); \
130 } while (0)
131
132#define tuner_dbg(fmt, arg...) do { \
133 if (tuner_debug) \
134 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
135 i2c_adapter_id(t->i2c->adapter), \
136 t->i2c->addr, ##arg); \
137 } while (0)
138
139
140
141static unsigned int tv_range[2] = { 44, 958 };
142static unsigned int radio_range[2] = { 65, 108 };
143
144static char pal[] = "--";
145static char secam[] = "--";
146static char ntsc[] = "-";
147
148
149module_param(addr, int, 0444);
150module_param(no_autodetect, int, 0444);
151module_param(show_i2c, int, 0444);
152module_param_named(debug,tuner_debug, int, 0644);
153module_param_string(pal, pal, sizeof(pal), 0644);
154module_param_string(secam, secam, sizeof(secam), 0644);
155module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
156module_param_array(tv_range, int, NULL, 0644);
157module_param_array(radio_range, int, NULL, 0644);
158
159MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
160MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
161MODULE_LICENSE("GPL");
162
163
164
165static void fe_set_params(struct dvb_frontend *fe,
166 struct analog_parameters *params)
167{
168 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
169 struct tuner *t = fe->analog_demod_priv;
170
171 if (NULL == fe_tuner_ops->set_analog_params) {
172 tuner_warn("Tuner frontend module has no way to set freq\n");
173 return;
174 }
175 fe_tuner_ops->set_analog_params(fe, params);
176}
177
178static void fe_standby(struct dvb_frontend *fe)
179{
180 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
181
182 if (fe_tuner_ops->sleep)
183 fe_tuner_ops->sleep(fe);
184}
185
186static int fe_has_signal(struct dvb_frontend *fe)
187{
188 u16 strength = 0;
189
190 if (fe->ops.tuner_ops.get_rf_strength)
191 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
192
193 return strength;
194}
195
196static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
197{
198 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
199 struct tuner *t = fe->analog_demod_priv;
200
201 if (fe_tuner_ops->set_config)
202 return fe_tuner_ops->set_config(fe, priv_cfg);
203
204 tuner_warn("Tuner frontend module has no way to set config\n");
205
206 return 0;
207}
208
209static void tuner_status(struct dvb_frontend *fe);
210
211static struct analog_demod_ops tuner_analog_ops = {
212 .set_params = fe_set_params,
213 .standby = fe_standby,
214 .has_signal = fe_has_signal,
215 .set_config = fe_set_config,
216 .tuner_status = tuner_status
217};
218
219
220static void set_tv_freq(struct i2c_client *c, unsigned int freq)
221{
222 struct tuner *t = to_tuner(i2c_get_clientdata(c));
223 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
224
225 struct analog_parameters params = {
226 .mode = t->mode,
227 .audmode = t->audmode,
228 .std = t->std
229 };
230
231 if (t->type == UNSET) {
232 tuner_warn ("tuner type not set\n");
233 return;
234 }
235 if (NULL == analog_ops->set_params) {
236 tuner_warn ("Tuner has no way to set tv freq\n");
237 return;
238 }
239 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
240 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
241 freq / 16, freq % 16 * 100 / 16, tv_range[0],
242 tv_range[1]);
243
244
245 if (freq < tv_range[0] * 16)
246 freq = tv_range[0] * 16;
247 else
248 freq = tv_range[1] * 16;
249 }
250 params.frequency = freq;
251
252 analog_ops->set_params(&t->fe, ¶ms);
253}
254
255static void set_radio_freq(struct i2c_client *c, unsigned int freq)
256{
257 struct tuner *t = to_tuner(i2c_get_clientdata(c));
258 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
259
260 struct analog_parameters params = {
261 .mode = t->mode,
262 .audmode = t->audmode,
263 .std = t->std
264 };
265
266 if (t->type == UNSET) {
267 tuner_warn ("tuner type not set\n");
268 return;
269 }
270 if (NULL == analog_ops->set_params) {
271 tuner_warn ("tuner has no way to set radio frequency\n");
272 return;
273 }
274 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
275 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
276 freq / 16000, freq % 16000 * 100 / 16000,
277 radio_range[0], radio_range[1]);
278
279
280 if (freq < radio_range[0] * 16000)
281 freq = radio_range[0] * 16000;
282 else
283 freq = radio_range[1] * 16000;
284 }
285 params.frequency = freq;
286
287 analog_ops->set_params(&t->fe, ¶ms);
288}
289
290static void set_freq(struct i2c_client *c, unsigned long freq)
291{
292 struct tuner *t = to_tuner(i2c_get_clientdata(c));
293
294 switch (t->mode) {
295 case V4L2_TUNER_RADIO:
296 tuner_dbg("radio freq set to %lu.%02lu\n",
297 freq / 16000, freq % 16000 * 100 / 16000);
298 set_radio_freq(c, freq);
299 t->radio_freq = freq;
300 break;
301 case V4L2_TUNER_ANALOG_TV:
302 case V4L2_TUNER_DIGITAL_TV:
303 tuner_dbg("tv freq set to %lu.%02lu\n",
304 freq / 16, freq % 16 * 100 / 16);
305 set_tv_freq(c, freq);
306 t->tv_freq = freq;
307 break;
308 default:
309 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
310 }
311}
312
313static struct xc5000_config xc5000_cfg;
314
315static void set_type(struct i2c_client *c, unsigned int type,
316 unsigned int new_mode_mask, unsigned int new_config,
317 int (*tuner_callback) (void *dev, int component, int cmd, int arg))
318{
319 struct tuner *t = to_tuner(i2c_get_clientdata(c));
320 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
321 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
322 unsigned char buffer[4];
323
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 >= 0) && (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 break;
408 }
409 case TUNER_TDA9887:
410 if (!dvb_attach(tda9887_attach,
411 &t->fe, t->i2c->adapter, t->i2c->addr))
412 goto attach_failed;
413 break;
414 case TUNER_XC5000:
415 {
416 xc5000_cfg.i2c_address = t->i2c->addr;
417
418 xc5000_cfg.if_khz = 0;
419 if (!dvb_attach(xc5000_attach,
420 &t->fe, t->i2c->adapter, &xc5000_cfg))
421 goto attach_failed;
422 break;
423 }
424 case TUNER_NXP_TDA18271:
425 {
426 struct tda18271_config cfg = {
427 .config = t->config,
428 };
429
430 if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
431 t->i2c->adapter, &cfg))
432 goto attach_failed;
433 break;
434 }
435 default:
436 if (!dvb_attach(simple_tuner_attach, &t->fe,
437 t->i2c->adapter, t->i2c->addr, t->type))
438 goto attach_failed;
439
440 break;
441 }
442
443 if ((NULL == analog_ops->set_params) &&
444 (fe_tuner_ops->set_analog_params)) {
445
446 t->name = fe_tuner_ops->info.name;
447
448 t->fe.analog_demod_priv = t;
449 memcpy(analog_ops, &tuner_analog_ops,
450 sizeof(struct analog_demod_ops));
451
452 } else {
453 t->name = analog_ops->info.name;
454 }
455
456 tuner_dbg("type set to %s\n", t->name);
457
458 if (t->mode_mask == T_UNINITIALIZED)
459 t->mode_mask = new_mode_mask;
460
461
462
463
464
465
466 if (t->type != TUNER_XC2028 && t->type != TUNER_XC5000)
467 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ?
468 t->radio_freq : t->tv_freq);
469
470 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
471 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
472 t->mode_mask);
473 return;
474
475attach_failed:
476 tuner_dbg("Tuner attach for type = %d failed.\n", t->type);
477 t->type = TUNER_ABSENT;
478 t->mode_mask = T_UNINITIALIZED;
479
480 return;
481}
482
483
484
485
486
487
488
489
490
491static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
492{
493 struct tuner *t = to_tuner(i2c_get_clientdata(c));
494
495 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
496 (t->mode_mask & tun_setup->mode_mask))) ||
497 (tun_setup->addr == c->addr)) {
498 set_type(c, tun_setup->type, tun_setup->mode_mask,
499 tun_setup->config, tun_setup->tuner_callback);
500 } else
501 tuner_dbg("set addr discarded for type %i, mask %x. "
502 "Asked to change tuner at addr 0x%02x, with mask %x\n",
503 t->type, t->mode_mask,
504 tun_setup->addr, tun_setup->mode_mask);
505}
506
507static inline int check_mode(struct tuner *t, char *cmd)
508{
509 if ((1 << t->mode & t->mode_mask) == 0) {
510 return -EINVAL;
511 }
512
513 switch (t->mode) {
514 case V4L2_TUNER_RADIO:
515 tuner_dbg("Cmd %s accepted for radio\n", cmd);
516 break;
517 case V4L2_TUNER_ANALOG_TV:
518 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
519 break;
520 case V4L2_TUNER_DIGITAL_TV:
521 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
522 break;
523 }
524 return 0;
525}
526
527
528static int tuner_fixup_std(struct tuner *t)
529{
530 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
531 switch (pal[0]) {
532 case '6':
533 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
534 t->std = V4L2_STD_PAL_60;
535 break;
536 case 'b':
537 case 'B':
538 case 'g':
539 case 'G':
540 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
541 t->std = V4L2_STD_PAL_BG;
542 break;
543 case 'i':
544 case 'I':
545 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
546 t->std = V4L2_STD_PAL_I;
547 break;
548 case 'd':
549 case 'D':
550 case 'k':
551 case 'K':
552 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
553 t->std = V4L2_STD_PAL_DK;
554 break;
555 case 'M':
556 case 'm':
557 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
558 t->std = V4L2_STD_PAL_M;
559 break;
560 case 'N':
561 case 'n':
562 if (pal[1] == 'c' || pal[1] == 'C') {
563 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
564 t->std = V4L2_STD_PAL_Nc;
565 } else {
566 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
567 t->std = V4L2_STD_PAL_N;
568 }
569 break;
570 case '-':
571
572 break;
573 default:
574 tuner_warn ("pal= argument not recognised\n");
575 break;
576 }
577 }
578 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
579 switch (secam[0]) {
580 case 'b':
581 case 'B':
582 case 'g':
583 case 'G':
584 case 'h':
585 case 'H':
586 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
587 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
588 break;
589 case 'd':
590 case 'D':
591 case 'k':
592 case 'K':
593 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
594 t->std = V4L2_STD_SECAM_DK;
595 break;
596 case 'l':
597 case 'L':
598 if ((secam[1]=='C')||(secam[1]=='c')) {
599 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
600 t->std = V4L2_STD_SECAM_LC;
601 } else {
602 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
603 t->std = V4L2_STD_SECAM_L;
604 }
605 break;
606 case '-':
607
608 break;
609 default:
610 tuner_warn ("secam= argument not recognised\n");
611 break;
612 }
613 }
614
615 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
616 switch (ntsc[0]) {
617 case 'm':
618 case 'M':
619 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
620 t->std = V4L2_STD_NTSC_M;
621 break;
622 case 'j':
623 case 'J':
624 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
625 t->std = V4L2_STD_NTSC_M_JP;
626 break;
627 case 'k':
628 case 'K':
629 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
630 t->std = V4L2_STD_NTSC_M_KR;
631 break;
632 case '-':
633
634 break;
635 default:
636 tuner_info("ntsc= argument not recognised\n");
637 break;
638 }
639 }
640 return 0;
641}
642
643static void tuner_status(struct dvb_frontend *fe)
644{
645 struct tuner *t = fe->analog_demod_priv;
646 unsigned long freq, freq_fraction;
647 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
648 struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
649 const char *p;
650
651 switch (t->mode) {
652 case V4L2_TUNER_RADIO: p = "radio"; break;
653 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
654 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
655 default: p = "undefined"; break;
656 }
657 if (t->mode == V4L2_TUNER_RADIO) {
658 freq = t->radio_freq / 16000;
659 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
660 } else {
661 freq = t->tv_freq / 16;
662 freq_fraction = (t->tv_freq % 16) * 100 / 16;
663 }
664 tuner_info("Tuner mode: %s\n", p);
665 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
666 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
667 if (t->mode != V4L2_TUNER_RADIO)
668 return;
669 if (fe_tuner_ops->get_status) {
670 u32 tuner_status;
671
672 fe_tuner_ops->get_status(&t->fe, &tuner_status);
673 if (tuner_status & TUNER_STATUS_LOCKED)
674 tuner_info("Tuner is locked.\n");
675 if (tuner_status & TUNER_STATUS_STEREO)
676 tuner_info("Stereo: yes\n");
677 }
678 if (analog_ops->has_signal)
679 tuner_info("Signal strength: %d\n",
680 analog_ops->has_signal(fe));
681 if (analog_ops->is_stereo)
682 tuner_info("Stereo: %s\n",
683 analog_ops->is_stereo(fe) ? "yes" : "no");
684}
685
686
687
688
689
690
691
692
693
694
695static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
696{
697 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
698
699 if (mode == t->mode)
700 return 0;
701
702 t->mode = mode;
703
704 if (check_mode(t, cmd) == -EINVAL) {
705 tuner_dbg("Tuner doesn't support this mode. "
706 "Putting tuner to sleep\n");
707 t->mode = T_STANDBY;
708 if (analog_ops->standby)
709 analog_ops->standby(&t->fe);
710 return -EINVAL;
711 }
712 return 0;
713}
714
715#define switch_v4l2() if (!t->using_v4l2) \
716 tuner_dbg("switching to v4l2\n"); \
717 t->using_v4l2 = 1;
718
719static inline int check_v4l2(struct tuner *t)
720{
721
722
723
724
725 return 0;
726}
727
728static int tuner_s_type_addr(struct v4l2_subdev *sd, struct tuner_setup *type)
729{
730 struct tuner *t = to_tuner(sd);
731 struct i2c_client *client = v4l2_get_subdevdata(sd);
732
733 tuner_dbg("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
734 type->type,
735 type->addr,
736 type->mode_mask,
737 type->config);
738
739 set_addr(client, type);
740 return 0;
741}
742
743static int tuner_s_radio(struct v4l2_subdev *sd)
744{
745 struct tuner *t = to_tuner(sd);
746 struct i2c_client *client = v4l2_get_subdevdata(sd);
747
748 if (set_mode(client, t, V4L2_TUNER_RADIO, "s_radio") == -EINVAL)
749 return 0;
750 if (t->radio_freq)
751 set_freq(client, t->radio_freq);
752 return 0;
753}
754
755static int tuner_s_standby(struct v4l2_subdev *sd)
756{
757 struct tuner *t = to_tuner(sd);
758 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
759
760 tuner_dbg("Putting tuner to sleep\n");
761
762 if (check_mode(t, "s_standby") == -EINVAL)
763 return 0;
764 t->mode = T_STANDBY;
765 if (analog_ops->standby)
766 analog_ops->standby(&t->fe);
767 return 0;
768}
769
770static int tuner_s_config(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *cfg)
771{
772 struct tuner *t = to_tuner(sd);
773 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
774
775 if (t->type != cfg->tuner)
776 return 0;
777
778 if (analog_ops->set_config) {
779 analog_ops->set_config(&t->fe, cfg->priv);
780 return 0;
781 }
782
783 tuner_dbg("Tuner frontend module has no way to set config\n");
784 return 0;
785}
786
787
788
789
790static int tuner_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
791{
792 struct tuner *t = to_tuner(sd);
793 struct i2c_client *client = v4l2_get_subdevdata(sd);
794
795 if (set_mode(client, t, V4L2_TUNER_ANALOG_TV, "s_std") == -EINVAL)
796 return 0;
797
798 switch_v4l2();
799
800 t->std = std;
801 tuner_fixup_std(t);
802 if (t->tv_freq)
803 set_freq(client, t->tv_freq);
804 return 0;
805}
806
807static int tuner_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
808{
809 struct tuner *t = to_tuner(sd);
810 struct i2c_client *client = v4l2_get_subdevdata(sd);
811
812 if (set_mode(client, t, f->type, "s_frequency") == -EINVAL)
813 return 0;
814 switch_v4l2();
815 set_freq(client, f->frequency);
816
817 return 0;
818}
819
820static int tuner_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
821{
822 struct tuner *t = to_tuner(sd);
823 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
824
825 if (check_mode(t, "g_frequency") == -EINVAL)
826 return 0;
827 switch_v4l2();
828 f->type = t->mode;
829 if (fe_tuner_ops->get_frequency) {
830 u32 abs_freq;
831
832 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
833 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
834 DIV_ROUND_CLOSEST(abs_freq * 2, 125) :
835 DIV_ROUND_CLOSEST(abs_freq, 62500);
836 return 0;
837 }
838 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
839 t->radio_freq : t->tv_freq;
840 return 0;
841}
842
843static int tuner_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
844{
845 struct tuner *t = to_tuner(sd);
846 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
847 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
848
849 if (check_mode(t, "g_tuner") == -EINVAL)
850 return 0;
851 switch_v4l2();
852
853 vt->type = t->mode;
854 if (analog_ops->get_afc)
855 vt->afc = analog_ops->get_afc(&t->fe);
856 if (t->mode == V4L2_TUNER_ANALOG_TV)
857 vt->capability |= V4L2_TUNER_CAP_NORM;
858 if (t->mode != V4L2_TUNER_RADIO) {
859 vt->rangelow = tv_range[0] * 16;
860 vt->rangehigh = tv_range[1] * 16;
861 return 0;
862 }
863
864
865 vt->rxsubchans =
866 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
867 if (fe_tuner_ops->get_status) {
868 u32 tuner_status;
869
870 fe_tuner_ops->get_status(&t->fe, &tuner_status);
871 vt->rxsubchans =
872 (tuner_status & TUNER_STATUS_STEREO) ?
873 V4L2_TUNER_SUB_STEREO :
874 V4L2_TUNER_SUB_MONO;
875 } else {
876 if (analog_ops->is_stereo) {
877 vt->rxsubchans =
878 analog_ops->is_stereo(&t->fe) ?
879 V4L2_TUNER_SUB_STEREO :
880 V4L2_TUNER_SUB_MONO;
881 }
882 }
883 if (analog_ops->has_signal)
884 vt->signal = analog_ops->has_signal(&t->fe);
885 vt->capability |=
886 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
887 vt->audmode = t->audmode;
888 vt->rangelow = radio_range[0] * 16000;
889 vt->rangehigh = radio_range[1] * 16000;
890 return 0;
891}
892
893static int tuner_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
894{
895 struct tuner *t = to_tuner(sd);
896 struct i2c_client *client = v4l2_get_subdevdata(sd);
897
898 if (check_mode(t, "s_tuner") == -EINVAL)
899 return 0;
900
901 switch_v4l2();
902
903
904 if (t->mode != V4L2_TUNER_RADIO)
905 return 0;
906 t->audmode = vt->audmode;
907 set_radio_freq(client, t->radio_freq);
908 return 0;
909}
910
911static int tuner_log_status(struct v4l2_subdev *sd)
912{
913 struct tuner *t = to_tuner(sd);
914 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
915
916 if (analog_ops->tuner_status)
917 analog_ops->tuner_status(&t->fe);
918 return 0;
919}
920
921static int tuner_suspend(struct i2c_client *c, pm_message_t state)
922{
923 struct tuner *t = to_tuner(i2c_get_clientdata(c));
924
925 tuner_dbg("suspend\n");
926
927 return 0;
928}
929
930static int tuner_resume(struct i2c_client *c)
931{
932 struct tuner *t = to_tuner(i2c_get_clientdata(c));
933
934 tuner_dbg("resume\n");
935 if (V4L2_TUNER_RADIO == t->mode) {
936 if (t->radio_freq)
937 set_freq(c, t->radio_freq);
938 } else {
939 if (t->tv_freq)
940 set_freq(c, t->tv_freq);
941 }
942 return 0;
943}
944
945static int tuner_command(struct i2c_client *client, unsigned cmd, void *arg)
946{
947 struct v4l2_subdev *sd = i2c_get_clientdata(client);
948
949
950
951
952 switch (cmd) {
953 case TUNER_SET_CONFIG:
954 return tuner_s_config(sd, arg);
955 }
956 return -ENOIOCTLCMD;
957}
958
959
960
961static const struct v4l2_subdev_core_ops tuner_core_ops = {
962 .log_status = tuner_log_status,
963 .s_std = tuner_s_std,
964};
965
966static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
967 .s_radio = tuner_s_radio,
968 .g_tuner = tuner_g_tuner,
969 .s_tuner = tuner_s_tuner,
970 .s_frequency = tuner_s_frequency,
971 .g_frequency = tuner_g_frequency,
972 .s_type_addr = tuner_s_type_addr,
973 .s_config = tuner_s_config,
974 .s_standby = tuner_s_standby,
975};
976
977static const struct v4l2_subdev_ops tuner_ops = {
978 .core = &tuner_core_ops,
979 .tuner = &tuner_tuner_ops,
980};
981
982
983
984static LIST_HEAD(tuner_list);
985
986
987
988
989
990static void tuner_lookup(struct i2c_adapter *adap,
991 struct tuner **radio, struct tuner **tv)
992{
993 struct tuner *pos;
994
995 *radio = NULL;
996 *tv = NULL;
997
998 list_for_each_entry(pos, &tuner_list, list) {
999 int mode_mask;
1000
1001 if (pos->i2c->adapter != adap ||
1002 strcmp(pos->i2c->driver->driver.name, "tuner"))
1003 continue;
1004
1005 mode_mask = pos->mode_mask & ~T_STANDBY;
1006 if (*radio == NULL && mode_mask == T_RADIO)
1007 *radio = pos;
1008
1009
1010
1011 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1012 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1013 *tv = pos;
1014 }
1015}
1016
1017
1018
1019
1020static int tuner_probe(struct i2c_client *client,
1021 const struct i2c_device_id *id)
1022{
1023 struct tuner *t;
1024 struct tuner *radio;
1025 struct tuner *tv;
1026
1027 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1028 if (NULL == t)
1029 return -ENOMEM;
1030 v4l2_i2c_subdev_init(&t->sd, client, &tuner_ops);
1031 t->i2c = client;
1032 t->name = "(tuner unset)";
1033 t->type = UNSET;
1034 t->audmode = V4L2_TUNER_MODE_STEREO;
1035 t->mode_mask = T_UNINITIALIZED;
1036
1037 if (show_i2c) {
1038 unsigned char buffer[16];
1039 int i, rc;
1040
1041 memset(buffer, 0, sizeof(buffer));
1042 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1043 tuner_info("I2C RECV = ");
1044 for (i = 0; i < rc; i++)
1045 printk(KERN_CONT "%02x ", buffer[i]);
1046 printk("\n");
1047 }
1048
1049
1050 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1051 kfree(t);
1052 return -ENODEV;
1053 }
1054
1055
1056 if (!no_autodetect) {
1057 switch (client->addr) {
1058 case 0x10:
1059 if (tuner_symbol_probe(tea5761_autodetection,
1060 t->i2c->adapter,
1061 t->i2c->addr) >= 0) {
1062 t->type = TUNER_TEA5761;
1063 t->mode_mask = T_RADIO;
1064 t->mode = T_STANDBY;
1065
1066 t->radio_freq = 87.5 * 16000;
1067 tuner_lookup(t->i2c->adapter, &radio, &tv);
1068 if (tv)
1069 tv->mode_mask &= ~T_RADIO;
1070
1071 goto register_client;
1072 }
1073 return -ENODEV;
1074 case 0x42:
1075 case 0x43:
1076 case 0x4a:
1077 case 0x4b:
1078
1079
1080 if (tuner_symbol_probe(tda829x_probe, t->i2c->adapter,
1081 t->i2c->addr) >= 0) {
1082 tuner_dbg("tda829x detected\n");
1083 } else {
1084
1085 t->type = TUNER_TDA9887;
1086 t->mode_mask = T_RADIO | T_ANALOG_TV |
1087 T_DIGITAL_TV;
1088 t->mode = T_STANDBY;
1089 goto register_client;
1090 }
1091 break;
1092 case 0x60:
1093 if (tuner_symbol_probe(tea5767_autodetection,
1094 t->i2c->adapter, t->i2c->addr)
1095 >= 0) {
1096 t->type = TUNER_TEA5767;
1097 t->mode_mask = T_RADIO;
1098 t->mode = T_STANDBY;
1099
1100 t->radio_freq = 87.5 * 16000;
1101 tuner_lookup(t->i2c->adapter, &radio, &tv);
1102 if (tv)
1103 tv->mode_mask &= ~T_RADIO;
1104
1105 goto register_client;
1106 }
1107 break;
1108 }
1109 }
1110
1111
1112
1113
1114
1115
1116
1117
1118 tuner_lookup(t->i2c->adapter, &radio, &tv);
1119 if (tv == NULL) {
1120 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1121 if (radio == NULL)
1122 t->mode_mask |= T_RADIO;
1123 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1124 t->tv_freq = 400 * 16;
1125 t->radio_freq = 87.5 * 16000;
1126 }
1127
1128
1129register_client:
1130 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1131 client->adapter->name);
1132
1133
1134 if (t->mode_mask & T_ANALOG_TV) {
1135 t->mode = V4L2_TUNER_ANALOG_TV;
1136 } else if (t->mode_mask & T_RADIO) {
1137 t->mode = V4L2_TUNER_RADIO;
1138 } else {
1139 t->mode = V4L2_TUNER_DIGITAL_TV;
1140 }
1141 set_type(client, t->type, t->mode_mask, t->config, t->fe.callback);
1142 list_add_tail(&t->list, &tuner_list);
1143 return 0;
1144}
1145
1146static int tuner_remove(struct i2c_client *client)
1147{
1148 struct tuner *t = to_tuner(i2c_get_clientdata(client));
1149
1150 v4l2_device_unregister_subdev(&t->sd);
1151 tuner_detach(&t->fe);
1152 t->fe.analog_demod_priv = NULL;
1153
1154 list_del(&t->list);
1155 kfree(t);
1156 return 0;
1157}
1158
1159
1160
1161
1162
1163
1164static const struct i2c_device_id tuner_id[] = {
1165 { "tuner", },
1166 { }
1167};
1168MODULE_DEVICE_TABLE(i2c, tuner_id);
1169
1170static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1171 .name = "tuner",
1172 .probe = tuner_probe,
1173 .remove = tuner_remove,
1174 .command = tuner_command,
1175 .suspend = tuner_suspend,
1176 .resume = tuner_resume,
1177 .id_table = tuner_id,
1178};
1179
1180
1181
1182
1183
1184
1185
1186
1187