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