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