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