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