?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / media / video / tuner-core.c
blob8cdbdd000e9d3587fd40f0ed9629ade029dd34b3
1 /*
2 *
3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
5 */
6
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/string.h>
10 #include <linux/timer.h>
11 #include <linux/delay.h>
12 #include <linux/errno.h>
13 #include <linux/slab.h>
14 #include <linux/poll.h>
15 #include <linux/i2c.h>
16 #include <linux/types.h>
17 #include <linux/init.h>
18 #include <linux/videodev.h>
19 #include <media/tuner.h>
20 #include <media/tuner-types.h>
21 #include <media/v4l2-common.h>
22 #include <media/v4l2-i2c-drv-legacy.h>
23 #include "mt20xx.h"
24 #include "tda8290.h"
25 #include "tea5761.h"
26 #include "tea5767.h"
27 #include "tuner-xc2028.h"
28 #include "tuner-simple.h"
29 #include "tda9887.h"
30 #include "xc5000.h"
31
32 #define UNSET (-1U)
33
34 #define PREFIX t->i2c->driver->driver.name
35
36 struct tuner {
37 /* device */
38 struct dvb_frontend fe;
39 struct i2c_client *i2c;
40 struct list_head list;
41 unsigned int using_v4l2:1;
42
43 /* keep track of the current settings */
44 v4l2_std_id std;
45 unsigned int tv_freq;
46 unsigned int radio_freq;
47 unsigned int audmode;
48
49 unsigned int mode;
50 unsigned int mode_mask; /* Combination of allowable modes */
51
52 unsigned int type; /* chip type id */
53 unsigned int config;
54 int (*tuner_callback) (void *dev, int command, int arg);
55 };
56
57 /* standard i2c insmod options */
58 static unsigned short normal_i2c[] = {
59 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
60 0x10,
61 #endif
62 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
63 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
64 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
65 I2C_CLIENT_END
66 };
67
68 I2C_CLIENT_INSMOD;
69
70 /* insmod options used at init time => read/only */
71 static unsigned int addr = 0;
72 static unsigned int no_autodetect = 0;
73 static unsigned int show_i2c = 0;
74
75 /* insmod options used at runtime => read/write */
76 static int tuner_debug;
77
78 #define tuner_warn(fmt, arg...) do { \
79 printk(KERN_WARNING "%s %d-%04x: " fmt, PREFIX, \
80 i2c_adapter_id(t->i2c->adapter), \
81 t->i2c->addr, ##arg); \
82 } while (0)
83
84 #define tuner_info(fmt, arg...) do { \
85 printk(KERN_INFO "%s %d-%04x: " fmt, PREFIX, \
86 i2c_adapter_id(t->i2c->adapter), \
87 t->i2c->addr, ##arg); \
88 } while (0)
89
90 #define tuner_err(fmt, arg...) do { \
91 printk(KERN_ERR "%s %d-%04x: " fmt, PREFIX, \
92 i2c_adapter_id(t->i2c->adapter), \
93 t->i2c->addr, ##arg); \
94 } while (0)
95
96 #define tuner_dbg(fmt, arg...) do { \
97 if (tuner_debug) \
98 printk(KERN_DEBUG "%s %d-%04x: " fmt, PREFIX, \
99 i2c_adapter_id(t->i2c->adapter), \
100 t->i2c->addr, ##arg); \
101 } while (0)
102
103 /* ------------------------------------------------------------------------ */
104
105 static unsigned int tv_range[2] = { 44, 958 };
106 static unsigned int radio_range[2] = { 65, 108 };
107
108 static char pal[] = "--";
109 static char secam[] = "--";
110 static char ntsc[] = "-";
111
112
113 module_param(addr, int, 0444);
114 module_param(no_autodetect, int, 0444);
115 module_param(show_i2c, int, 0444);
116 module_param_named(debug,tuner_debug, int, 0644);
117 module_param_string(pal, pal, sizeof(pal), 0644);
118 module_param_string(secam, secam, sizeof(secam), 0644);
119 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
120 module_param_array(tv_range, int, NULL, 0644);
121 module_param_array(radio_range, int, NULL, 0644);
122
123 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
124 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
125 MODULE_LICENSE("GPL");
126
127 /* ---------------------------------------------------------------------- */
128
129 static void fe_set_params(struct dvb_frontend *fe,
130 struct analog_parameters *params)
131 {
132 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
133 struct tuner *t = fe->analog_demod_priv;
134
135 if (NULL == fe_tuner_ops->set_analog_params) {
136 tuner_warn("Tuner frontend module has no way to set freq\n");
137 return;
138 }
139 fe_tuner_ops->set_analog_params(fe, params);
140 }
141
142 static void fe_release(struct dvb_frontend *fe)
143 {
144 if (fe->ops.tuner_ops.release)
145 fe->ops.tuner_ops.release(fe);
146
147 /* DO NOT kfree(fe->analog_demod_priv)
148 *
149 * If we are in this function, analog_demod_priv contains a pointer
150 * to struct tuner *t. This will be kfree'd in tuner_detach().
151 *
152 * Otherwise, fe->ops.analog_demod_ops->release will
153 * handle the cleanup for analog demodulator modules.
154 */
155 fe->analog_demod_priv = NULL;
156 }
157
158 static void fe_standby(struct dvb_frontend *fe)
159 {
160 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
161
162 if (fe_tuner_ops->sleep)
163 fe_tuner_ops->sleep(fe);
164 }
165
166 static int fe_has_signal(struct dvb_frontend *fe)
167 {
168 u16 strength = 0;
169
170 if (fe->ops.tuner_ops.get_rf_strength)
171 fe->ops.tuner_ops.get_rf_strength(fe, &strength);
172
173 return strength;
174 }
175
176 static int fe_set_config(struct dvb_frontend *fe, void *priv_cfg)
177 {
178 struct dvb_tuner_ops *fe_tuner_ops = &fe->ops.tuner_ops;
179 struct tuner *t = fe->analog_demod_priv;
180
181 if (fe_tuner_ops->set_config)
182 return fe_tuner_ops->set_config(fe, priv_cfg);
183
184 tuner_warn("Tuner frontend module has no way to set config\n");
185
186 return 0;
187 }
188
189 static void tuner_status(struct dvb_frontend *fe);
190
191 static struct analog_demod_ops tuner_core_ops = {
192 .set_params = fe_set_params,
193 .standby = fe_standby,
194 .release = fe_release,
195 .has_signal = fe_has_signal,
196 .set_config = fe_set_config,
197 .tuner_status = tuner_status
198 };
199
200 /* Set tuner frequency, freq in Units of 62.5kHz = 1/16MHz */
201 static void set_tv_freq(struct i2c_client *c, unsigned int freq)
202 {
203 struct tuner *t = i2c_get_clientdata(c);
204 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
205
206 struct analog_parameters params = {
207 .mode = t->mode,
208 .audmode = t->audmode,
209 .std = t->std
210 };
211
212 if (t->type == UNSET) {
213 tuner_warn ("tuner type not set\n");
214 return;
215 }
216 if (NULL == analog_ops->set_params) {
217 tuner_warn ("Tuner has no way to set tv freq\n");
218 return;
219 }
220 if (freq < tv_range[0] * 16 || freq > tv_range[1] * 16) {
221 tuner_dbg ("TV freq (%d.%02d) out of range (%d-%d)\n",
222 freq / 16, freq % 16 * 100 / 16, tv_range[0],
223 tv_range[1]);
224 /* V4L2 spec: if the freq is not possible then the closest
225 possible value should be selected */
226 if (freq < tv_range[0] * 16)
227 freq = tv_range[0] * 16;
228 else
229 freq = tv_range[1] * 16;
230 }
231 params.frequency = freq;
232
233 analog_ops->set_params(&t->fe, &params);
234 }
235
236 static void set_radio_freq(struct i2c_client *c, unsigned int freq)
237 {
238 struct tuner *t = i2c_get_clientdata(c);
239 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
240
241 struct analog_parameters params = {
242 .mode = t->mode,
243 .audmode = t->audmode,
244 .std = t->std
245 };
246
247 if (t->type == UNSET) {
248 tuner_warn ("tuner type not set\n");
249 return;
250 }
251 if (NULL == analog_ops->set_params) {
252 tuner_warn ("tuner has no way to set radio frequency\n");
253 return;
254 }
255 if (freq < radio_range[0] * 16000 || freq > radio_range[1] * 16000) {
256 tuner_dbg ("radio freq (%d.%02d) out of range (%d-%d)\n",
257 freq / 16000, freq % 16000 * 100 / 16000,
258 radio_range[0], radio_range[1]);
259 /* V4L2 spec: if the freq is not possible then the closest
260 possible value should be selected */
261 if (freq < radio_range[0] * 16000)
262 freq = radio_range[0] * 16000;
263 else
264 freq = radio_range[1] * 16000;
265 }
266 params.frequency = freq;
267
268 analog_ops->set_params(&t->fe, &params);
269 }
270
271 static void set_freq(struct i2c_client *c, unsigned long freq)
272 {
273 struct tuner *t = i2c_get_clientdata(c);
274
275 switch (t->mode) {
276 case V4L2_TUNER_RADIO:
277 tuner_dbg("radio freq set to %lu.%02lu\n",
278 freq / 16000, freq % 16000 * 100 / 16000);
279 set_radio_freq(c, freq);
280 t->radio_freq = freq;
281 break;
282 case V4L2_TUNER_ANALOG_TV:
283 case V4L2_TUNER_DIGITAL_TV:
284 tuner_dbg("tv freq set to %lu.%02lu\n",
285 freq / 16, freq % 16 * 100 / 16);
286 set_tv_freq(c, freq);
287 t->tv_freq = freq;
288 break;
289 default:
290 tuner_dbg("freq set: unknown mode: 0x%04x!\n",t->mode);
291 }
292 }
293
294 static void tuner_i2c_address_check(struct tuner *t)
295 {
296 if ((t->type == UNSET || t->type == TUNER_ABSENT) ||
297 ((t->i2c->addr < 0x64) || (t->i2c->addr > 0x6f)))
298 return;
299
300 /* We already know that the XC5000 can only be located at
301 * i2c address 0x61, 0x62, 0x63 or 0x64 */
302 if ((t->type == TUNER_XC5000) &&
303 ((t->i2c->addr <= 0x64)) && (t->i2c->addr >= 0x61))
304 return;
305
306 tuner_warn("====================== WARNING! ======================\n");
307 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
308 tuner_warn("will soon be dropped. This message indicates that your\n");
309 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
310 t->i2c->name, t->i2c->addr);
311 tuner_warn("To ensure continued support for your device, please\n");
312 tuner_warn("send a copy of this message, along with full dmesg\n");
313 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
314 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
315 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
316 t->i2c->adapter->name, t->i2c->addr, t->type,
317 tuners[t->type].name);
318 tuner_warn("====================== WARNING! ======================\n");
319 }
320
321 static void attach_simple_tuner(struct tuner *t)
322 {
323 struct simple_tuner_config cfg = {
324 .type = t->type,
325 .tun = &tuners[t->type]
326 };
327 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
328 }
329
330 static void attach_tda829x(struct tuner *t)
331 {
332 struct tda829x_config cfg = {
333 .lna_cfg = &t->config,
334 .tuner_callback = t->tuner_callback,
335 };
336 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
337 }
338
339 static struct xc5000_config xc5000_cfg;
340
341 static void set_type(struct i2c_client *c, unsigned int type,
342 unsigned int new_mode_mask, unsigned int new_config,
343 int (*tuner_callback) (void *dev, int command,int arg))
344 {
345 struct tuner *t = i2c_get_clientdata(c);
346 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
347 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
348 unsigned char buffer[4];
349
350 if (type == UNSET || type == TUNER_ABSENT) {
351 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
352 return;
353 }
354
355 if (type >= tuner_count) {
356 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
357 return;
358 }
359
360 t->type = type;
361 t->config = new_config;
362 if (tuner_callback != NULL) {
363 tuner_dbg("defining GPIO callback\n");
364 t->tuner_callback = tuner_callback;
365 }
366
367 if (t->mode == T_UNINITIALIZED) {
368 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
369
370 return;
371 }
372
373 /* discard private data, in case set_type() was previously called */
374 if (analog_ops->release)
375 analog_ops->release(&t->fe);
376
377 switch (t->type) {
378 case TUNER_MT2032:
379 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
380 break;
381 case TUNER_PHILIPS_TDA8290:
382 {
383 attach_tda829x(t);
384 break;
385 }
386 case TUNER_TEA5767:
387 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
388 t->type = TUNER_ABSENT;
389 t->mode_mask = T_UNINITIALIZED;
390 return;
391 }
392 t->mode_mask = T_RADIO;
393 break;
394 case TUNER_TEA5761:
395 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
396 t->type = TUNER_ABSENT;
397 t->mode_mask = T_UNINITIALIZED;
398 return;
399 }
400 t->mode_mask = T_RADIO;
401 break;
402 case TUNER_PHILIPS_FMD1216ME_MK3:
403 buffer[0] = 0x0b;
404 buffer[1] = 0xdc;
405 buffer[2] = 0x9c;
406 buffer[3] = 0x60;
407 i2c_master_send(c, buffer, 4);
408 mdelay(1);
409 buffer[2] = 0x86;
410 buffer[3] = 0x54;
411 i2c_master_send(c, buffer, 4);
412 attach_simple_tuner(t);
413 break;
414 case TUNER_PHILIPS_TD1316:
415 buffer[0] = 0x0b;
416 buffer[1] = 0xdc;
417 buffer[2] = 0x86;
418 buffer[3] = 0xa4;
419 i2c_master_send(c,buffer,4);
420 attach_simple_tuner(t);
421 break;
422 case TUNER_XC2028:
423 {
424 struct xc2028_config cfg = {
425 .i2c_adap = t->i2c->adapter,
426 .i2c_addr = t->i2c->addr,
427 .video_dev = c->adapter->algo_data,
428 .callback = t->tuner_callback,
429 };
430 if (!xc2028_attach(&t->fe, &cfg)) {
431 t->type = TUNER_ABSENT;
432 t->mode_mask = T_UNINITIALIZED;
433 return;
434 }
435 break;
436 }
437 case TUNER_TDA9887:
438 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
439 break;
440 case TUNER_XC5000:
441 xc5000_cfg.i2c_address = t->i2c->addr;
442 xc5000_cfg.if_khz = 5380;
443 xc5000_cfg.priv = c->adapter->algo_data;
444 xc5000_cfg.tuner_callback = t->tuner_callback;
445 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg)) {
446 t->type = TUNER_ABSENT;
447 t->mode_mask = T_UNINITIALIZED;
448 return;
449 }
450 {
451 struct dvb_tuner_ops *xc_tuner_ops;
452 xc_tuner_ops = &t->fe.ops.tuner_ops;
453 if(xc_tuner_ops->init != NULL)
454 xc_tuner_ops->init(&t->fe);
455 }
456 break;
457 default:
458 attach_simple_tuner(t);
459 break;
460 }
461
462 if ((NULL == analog_ops->set_params) &&
463 (fe_tuner_ops->set_analog_params)) {
464 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
465 sizeof(t->i2c->name));
466
467 t->fe.analog_demod_priv = t;
468 memcpy(analog_ops, &tuner_core_ops,
469 sizeof(struct analog_demod_ops));
470 } else {
471 strlcpy(t->i2c->name, analog_ops->info.name,
472 sizeof(t->i2c->name));
473 }
474
475 tuner_dbg("type set to %s\n", t->i2c->name);
476
477 if (t->mode_mask == T_UNINITIALIZED)
478 t->mode_mask = new_mode_mask;
479
480 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
481 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
482 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
483 t->mode_mask);
484 tuner_i2c_address_check(t);
485 }
486
487 /*
488 * This function apply tuner config to tuner specified
489 * by tun_setup structure. I addr is unset, then admin status
490 * and tun addr status is more precise then current status,
491 * it's applied. Otherwise status and type are applied only to
492 * tuner with exactly the same addr.
493 */
494
495 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
496 {
497 struct tuner *t = i2c_get_clientdata(c);
498
499 tuner_dbg("set addr for type %i\n", t->type);
500
501 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
502 (t->mode_mask & tun_setup->mode_mask))) ||
503 (tun_setup->addr == c->addr)) {
504 set_type(c, tun_setup->type, tun_setup->mode_mask,
505 tun_setup->config, tun_setup->tuner_callback);
506 }
507 }
508
509 static inline int check_mode(struct tuner *t, char *cmd)
510 {
511 if ((1 << t->mode & t->mode_mask) == 0) {
512 return EINVAL;
513 }
514
515 switch (t->mode) {
516 case V4L2_TUNER_RADIO:
517 tuner_dbg("Cmd %s accepted for radio\n", cmd);
518 break;
519 case V4L2_TUNER_ANALOG_TV:
520 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
521 break;
522 case V4L2_TUNER_DIGITAL_TV:
523 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
524 break;
525 }
526 return 0;
527 }
528
529 /* get more precise norm info from insmod option */
530 static int tuner_fixup_std(struct tuner *t)
531 {
532 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
533 switch (pal[0]) {
534 case '6':
535 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
536 t->std = V4L2_STD_PAL_60;
537 break;
538 case 'b':
539 case 'B':
540 case 'g':
541 case 'G':
542 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
543 t->std = V4L2_STD_PAL_BG;
544 break;
545 case 'i':
546 case 'I':
547 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
548 t->std = V4L2_STD_PAL_I;
549 break;
550 case 'd':
551 case 'D':
552 case 'k':
553 case 'K':
554 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
555 t->std = V4L2_STD_PAL_DK;
556 break;
557 case 'M':
558 case 'm':
559 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
560 t->std = V4L2_STD_PAL_M;
561 break;
562 case 'N':
563 case 'n':
564 if (pal[1] == 'c' || pal[1] == 'C') {
565 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
566 t->std = V4L2_STD_PAL_Nc;
567 } else {
568 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
569 t->std = V4L2_STD_PAL_N;
570 }
571 break;
572 case '-':
573 /* default parameter, do nothing */
574 break;
575 default:
576 tuner_warn ("pal= argument not recognised\n");
577 break;
578 }
579 }
580 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
581 switch (secam[0]) {
582 case 'b':
583 case 'B':
584 case 'g':
585 case 'G':
586 case 'h':
587 case 'H':
588 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
589 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
590 break;
591 case 'd':
592 case 'D':
593 case 'k':
594 case 'K':
595 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
596 t->std = V4L2_STD_SECAM_DK;
597 break;
598 case 'l':
599 case 'L':
600 if ((secam[1]=='C')||(secam[1]=='c')) {
601 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
602 t->std = V4L2_STD_SECAM_LC;
603 } else {
604 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
605 t->std = V4L2_STD_SECAM_L;
606 }
607 break;
608 case '-':
609 /* default parameter, do nothing */
610 break;
611 default:
612 tuner_warn ("secam= argument not recognised\n");
613 break;
614 }
615 }
616
617 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
618 switch (ntsc[0]) {
619 case 'm':
620 case 'M':
621 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
622 t->std = V4L2_STD_NTSC_M;
623 break;
624 case 'j':
625 case 'J':
626 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
627 t->std = V4L2_STD_NTSC_M_JP;
628 break;
629 case 'k':
630 case 'K':
631 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
632 t->std = V4L2_STD_NTSC_M_KR;
633 break;
634 case '-':
635 /* default parameter, do nothing */
636 break;
637 default:
638 tuner_info("ntsc= argument not recognised\n");
639 break;
640 }
641 }
642 return 0;
643 }
644
645 static void tuner_status(struct dvb_frontend *fe)
646 {
647 struct tuner *t = fe->analog_demod_priv;
648 unsigned long freq, freq_fraction;
649 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
650 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
651 const char *p;
652
653 switch (t->mode) {
654 case V4L2_TUNER_RADIO: p = "radio"; break;
655 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
656 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
657 default: p = "undefined"; break;
658 }
659 if (t->mode == V4L2_TUNER_RADIO) {
660 freq = t->radio_freq / 16000;
661 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
662 } else {
663 freq = t->tv_freq / 16;
664 freq_fraction = (t->tv_freq % 16) * 100 / 16;
665 }
666 tuner_info("Tuner mode: %s\n", p);
667 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
668 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
669 if (t->mode != V4L2_TUNER_RADIO)
670 return;
671 if (fe_tuner_ops->get_status) {
672 u32 tuner_status;
673
674 fe_tuner_ops->get_status(&t->fe, &tuner_status);
675 if (tuner_status & TUNER_STATUS_LOCKED)
676 tuner_info("Tuner is locked.\n");
677 if (tuner_status & TUNER_STATUS_STEREO)
678 tuner_info("Stereo: yes\n");
679 }
680 if (analog_ops->has_signal)
681 tuner_info("Signal strength: %d\n",
682 analog_ops->has_signal(fe));
683 if (analog_ops->is_stereo)
684 tuner_info("Stereo: %s\n",
685 analog_ops->is_stereo(fe) ? "yes" : "no");
686 }
687
688 /* ---------------------------------------------------------------------- */
689
690 /*
691 * Switch tuner to other mode. If tuner support both tv and radio,
692 * set another frequency to some value (This is needed for some pal
693 * tuners to avoid locking). Otherwise, just put second tuner in
694 * standby mode.
695 */
696
697 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
698 {
699 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
700
701 if (mode == t->mode)
702 return 0;
703
704 t->mode = mode;
705
706 if (check_mode(t, cmd) == EINVAL) {
707 t->mode = T_STANDBY;
708 if (analog_ops->standby)
709 analog_ops->standby(&t->fe);
710 return EINVAL;
711 }
712 return 0;
713 }
714
715 #define switch_v4l2() if (!t->using_v4l2) \
716 tuner_dbg("switching to v4l2\n"); \
717 t->using_v4l2 = 1;
718
719 static inline int check_v4l2(struct tuner *t)
720 {
721 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
722 TV, v4l1 for radio), until that is fixed this code is disabled.
723 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
724 first. */
725 return 0;
726 }
727
728 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
729 {
730 struct tuner *t = i2c_get_clientdata(client);
731 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
732 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
733
734 if (tuner_debug>1)
735 v4l_i2c_print_ioctl(client,cmd);
736
737 switch (cmd) {
738 /* --- configuration --- */
739 case TUNER_SET_TYPE_ADDR:
740 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
741 ((struct tuner_setup *)arg)->type,
742 ((struct tuner_setup *)arg)->addr,
743 ((struct tuner_setup *)arg)->mode_mask,
744 ((struct tuner_setup *)arg)->config);
745
746 set_addr(client, (struct tuner_setup *)arg);
747 break;
748 case AUDC_SET_RADIO:
749 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
750 == EINVAL)
751 return 0;
752 if (t->radio_freq)
753 set_freq(client, t->radio_freq);
754 break;
755 case TUNER_SET_STANDBY:
756 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
757 return 0;
758 t->mode = T_STANDBY;
759 if (analog_ops->standby)
760 analog_ops->standby(&t->fe);
761 break;
762 #ifdef CONFIG_VIDEO_V4L1
763 case VIDIOCSAUDIO:
764 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
765 return 0;
766 if (check_v4l2(t) == EINVAL)
767 return 0;
768
769 /* Should be implemented, since bttv calls it */
770 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
771 break;
772 case VIDIOCSCHAN:
773 {
774 static const v4l2_std_id map[] = {
775 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
776 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
777 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
778 [4 /* bttv */ ] = V4L2_STD_PAL_M,
779 [5 /* bttv */ ] = V4L2_STD_PAL_N,
780 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
781 };
782 struct video_channel *vc = arg;
783
784 if (check_v4l2(t) == EINVAL)
785 return 0;
786
787 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
788 return 0;
789
790 if (vc->norm < ARRAY_SIZE(map))
791 t->std = map[vc->norm];
792 tuner_fixup_std(t);
793 if (t->tv_freq)
794 set_tv_freq(client, t->tv_freq);
795 return 0;
796 }
797 case VIDIOCSFREQ:
798 {
799 unsigned long *v = arg;
800
801 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
802 return 0;
803 if (check_v4l2(t) == EINVAL)
804 return 0;
805
806 set_freq(client, *v);
807 return 0;
808 }
809 case VIDIOCGTUNER:
810 {
811 struct video_tuner *vt = arg;
812
813 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
814 return 0;
815 if (check_v4l2(t) == EINVAL)
816 return 0;
817
818 if (V4L2_TUNER_RADIO == t->mode) {
819 if (fe_tuner_ops->get_status) {
820 u32 tuner_status;
821
822 fe_tuner_ops->get_status(&t->fe, &tuner_status);
823 if (tuner_status & TUNER_STATUS_STEREO)
824 vt->flags |= VIDEO_TUNER_STEREO_ON;
825 else
826 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
827 } else {
828 if (analog_ops->is_stereo) {
829 if (analog_ops->is_stereo(&t->fe))
830 vt->flags |=
831 VIDEO_TUNER_STEREO_ON;
832 else
833 vt->flags &=
834 ~VIDEO_TUNER_STEREO_ON;
835 }
836 }
837 if (analog_ops->has_signal)
838 vt->signal =
839 analog_ops->has_signal(&t->fe);
840
841 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
842
843 vt->rangelow = radio_range[0] * 16000;
844 vt->rangehigh = radio_range[1] * 16000;
845
846 } else {
847 vt->rangelow = tv_range[0] * 16;
848 vt->rangehigh = tv_range[1] * 16;
849 }
850
851 return 0;
852 }
853 case VIDIOCGAUDIO:
854 {
855 struct video_audio *va = arg;
856
857 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
858 return 0;
859 if (check_v4l2(t) == EINVAL)
860 return 0;
861
862 if (V4L2_TUNER_RADIO == t->mode) {
863 if (fe_tuner_ops->get_status) {
864 u32 tuner_status;
865
866 fe_tuner_ops->get_status(&t->fe, &tuner_status);
867 va->mode = (tuner_status & TUNER_STATUS_STEREO)
868 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
869 } else if (analog_ops->is_stereo)
870 va->mode = analog_ops->is_stereo(&t->fe)
871 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
872 }
873 return 0;
874 }
875 #endif
876 case TUNER_SET_CONFIG:
877 {
878 struct v4l2_priv_tun_config *cfg = arg;
879
880 if (t->type != cfg->tuner)
881 break;
882
883 if (analog_ops->set_config) {
884 analog_ops->set_config(&t->fe, cfg->priv);
885 break;
886 }
887
888 tuner_dbg("Tuner frontend module has no way to set config\n");
889 break;
890 }
891 /* --- v4l ioctls --- */
892 /* take care: bttv does userspace copying, we'll get a
893 kernel pointer here... */
894 case VIDIOC_S_STD:
895 {
896 v4l2_std_id *id = arg;
897
898 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
899 == EINVAL)
900 return 0;
901
902 switch_v4l2();
903
904 t->std = *id;
905 tuner_fixup_std(t);
906 if (t->tv_freq)
907 set_freq(client, t->tv_freq);
908 break;
909 }
910 case VIDIOC_S_FREQUENCY:
911 {
912 struct v4l2_frequency *f = arg;
913
914 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
915 == EINVAL)
916 return 0;
917 switch_v4l2();
918 set_freq(client,f->frequency);
919
920 break;
921 }
922 case VIDIOC_G_FREQUENCY:
923 {
924 struct v4l2_frequency *f = arg;
925
926 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
927 return 0;
928 switch_v4l2();
929 f->type = t->mode;
930 if (fe_tuner_ops->get_frequency) {
931 u32 abs_freq;
932
933 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
934 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
935 (abs_freq * 2 + 125/2) / 125 :
936 (abs_freq + 62500/2) / 62500;
937 break;
938 }
939 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
940 t->radio_freq : t->tv_freq;
941 break;
942 }
943 case VIDIOC_G_TUNER:
944 {
945 struct v4l2_tuner *tuner = arg;
946
947 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
948 return 0;
949 switch_v4l2();
950
951 tuner->type = t->mode;
952 if (analog_ops->get_afc)
953 tuner->afc = analog_ops->get_afc(&t->fe);
954 if (t->mode == V4L2_TUNER_ANALOG_TV)
955 tuner->capability |= V4L2_TUNER_CAP_NORM;
956 if (t->mode != V4L2_TUNER_RADIO) {
957 tuner->rangelow = tv_range[0] * 16;
958 tuner->rangehigh = tv_range[1] * 16;
959 break;
960 }
961
962 /* radio mode */
963 tuner->rxsubchans =
964 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
965 if (fe_tuner_ops->get_status) {
966 u32 tuner_status;
967
968 fe_tuner_ops->get_status(&t->fe, &tuner_status);
969 tuner->rxsubchans =
970 (tuner_status & TUNER_STATUS_STEREO) ?
971 V4L2_TUNER_SUB_STEREO :
972 V4L2_TUNER_SUB_MONO;
973 } else {
974 if (analog_ops->is_stereo) {
975 tuner->rxsubchans =
976 analog_ops->is_stereo(&t->fe) ?
977 V4L2_TUNER_SUB_STEREO :
978 V4L2_TUNER_SUB_MONO;
979 }
980 }
981 if (analog_ops->has_signal)
982 tuner->signal = analog_ops->has_signal(&t->fe);
983 tuner->capability |=
984 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
985 tuner->audmode = t->audmode;
986 tuner->rangelow = radio_range[0] * 16000;
987 tuner->rangehigh = radio_range[1] * 16000;
988 break;
989 }
990 case VIDIOC_S_TUNER:
991 {
992 struct v4l2_tuner *tuner = arg;
993
994 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
995 return 0;
996
997 switch_v4l2();
998
999 /* do nothing unless we're a radio tuner */
1000 if (t->mode != V4L2_TUNER_RADIO)
1001 break;
1002 t->audmode = tuner->audmode;
1003 set_radio_freq(client, t->radio_freq);
1004 break;
1005 }
1006 case VIDIOC_LOG_STATUS:
1007 if (analog_ops->tuner_status)
1008 analog_ops->tuner_status(&t->fe);
1009 break;
1010 }
1011
1012 return 0;
1013 }
1014
1015 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1016 {
1017 struct tuner *t = i2c_get_clientdata(c);
1018
1019 tuner_dbg("suspend\n");
1020 /* FIXME: power down ??? */
1021 return 0;
1022 }
1023
1024 static int tuner_resume(struct i2c_client *c)
1025 {
1026 struct tuner *t = i2c_get_clientdata(c);
1027
1028 tuner_dbg("resume\n");
1029 if (V4L2_TUNER_RADIO == t->mode) {
1030 if (t->radio_freq)
1031 set_freq(c, t->radio_freq);
1032 } else {
1033 if (t->tv_freq)
1034 set_freq(c, t->tv_freq);
1035 }
1036 return 0;
1037 }
1038
1039 /* ---------------------------------------------------------------------- */
1040
1041 static LIST_HEAD(tuner_list);
1042
1043 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1044 Note that when this function is called from tuner_probe you can be
1045 certain no other devices will be added/deleted at the same time, I2C
1046 core protects against that. */
1047 static void tuner_lookup(struct i2c_adapter *adap,
1048 struct tuner **radio, struct tuner **tv)
1049 {
1050 struct tuner *pos;
1051
1052 *radio = NULL;
1053 *tv = NULL;
1054
1055 list_for_each_entry(pos, &tuner_list, list) {
1056 int mode_mask;
1057
1058 if (pos->i2c->adapter != adap ||
1059 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1060 continue;
1061
1062 mode_mask = pos->mode_mask & ~T_STANDBY;
1063 if (*radio == NULL && mode_mask == T_RADIO)
1064 *radio = pos;
1065 /* Note: currently TDA9887 is the only demod-only
1066 device. If other devices appear then we need to
1067 make this test more general. */
1068 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1069 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1070 *tv = pos;
1071 }
1072 }
1073
1074 /* During client attach, set_type is called by adapter's attach_inform callback.
1075 set_type must then be completed by tuner_probe.
1076 */
1077 static int tuner_probe(struct i2c_client *client)
1078 {
1079 struct tuner *t;
1080 struct tuner *radio;
1081 struct tuner *tv;
1082
1083 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1084 if (NULL == t)
1085 return -ENOMEM;
1086 t->i2c = client;
1087 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1088 i2c_set_clientdata(client, t);
1089 t->type = UNSET;
1090 t->audmode = V4L2_TUNER_MODE_STEREO;
1091 t->mode_mask = T_UNINITIALIZED;
1092
1093 if (show_i2c) {
1094 unsigned char buffer[16];
1095 int i, rc;
1096
1097 memset(buffer, 0, sizeof(buffer));
1098 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1099 tuner_info("I2C RECV = ");
1100 for (i = 0; i < rc; i++)
1101 printk(KERN_CONT "%02x ", buffer[i]);
1102 printk("\n");
1103 }
1104 /* HACK: This test was added to avoid tuner to probe tda9840 and
1105 tea6415c on the MXB card */
1106 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1107 kfree(t);
1108 return -ENODEV;
1109 }
1110
1111 /* autodetection code based on the i2c addr */
1112 if (!no_autodetect) {
1113 switch (client->addr) {
1114 case 0x10:
1115 if (tea5761_autodetection(t->i2c->adapter,
1116 t->i2c->addr) >= 0) {
1117 t->type = TUNER_TEA5761;
1118 t->mode_mask = T_RADIO;
1119 t->mode = T_STANDBY;
1120 /* Sets freq to FM range */
1121 t->radio_freq = 87.5 * 16000;
1122 tuner_lookup(t->i2c->adapter, &radio, &tv);
1123 if (tv)
1124 tv->mode_mask &= ~T_RADIO;
1125
1126 goto register_client;
1127 }
1128 return -ENODEV;
1129 case 0x42:
1130 case 0x43:
1131 case 0x4a:
1132 case 0x4b:
1133 /* If chip is not tda8290, don't register.
1134 since it can be tda9887*/
1135 if (tda829x_probe(t->i2c->adapter,
1136 t->i2c->addr) == 0) {
1137 tuner_dbg("tda829x detected\n");
1138 } else {
1139 /* Default is being tda9887 */
1140 t->type = TUNER_TDA9887;
1141 t->mode_mask = T_RADIO | T_ANALOG_TV |
1142 T_DIGITAL_TV;
1143 t->mode = T_STANDBY;
1144 goto register_client;
1145 }
1146 break;
1147 case 0x60:
1148 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1149 != EINVAL) {
1150 t->type = TUNER_TEA5767;
1151 t->mode_mask = T_RADIO;
1152 t->mode = T_STANDBY;
1153 /* Sets freq to FM range */
1154 t->radio_freq = 87.5 * 16000;
1155 tuner_lookup(t->i2c->adapter, &radio, &tv);
1156 if (tv)
1157 tv->mode_mask &= ~T_RADIO;
1158
1159 goto register_client;
1160 }
1161 break;
1162 }
1163 }
1164
1165 /* Initializes only the first TV tuner on this adapter. Why only the
1166 first? Because there are some devices (notably the ones with TI
1167 tuners) that have more than one i2c address for the *same* device.
1168 Experience shows that, except for just one case, the first
1169 address is the right one. The exception is a Russian tuner
1170 (ACORP_Y878F). So, the desired behavior is just to enable the
1171 first found TV tuner. */
1172 tuner_lookup(t->i2c->adapter, &radio, &tv);
1173 if (tv == NULL) {
1174 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1175 if (radio == NULL)
1176 t->mode_mask |= T_RADIO;
1177 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1178 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1179 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1180 }
1181
1182 /* Should be just before return */
1183 register_client:
1184 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1185 client->adapter->name);
1186
1187 /* Sets a default mode */
1188 if (t->mode_mask & T_ANALOG_TV) {
1189 t->mode = V4L2_TUNER_ANALOG_TV;
1190 } else if (t->mode_mask & T_RADIO) {
1191 t->mode = V4L2_TUNER_RADIO;
1192 } else {
1193 t->mode = V4L2_TUNER_DIGITAL_TV;
1194 }
1195 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1196 list_add_tail(&t->list, &tuner_list);
1197 return 0;
1198 }
1199
1200 static int tuner_legacy_probe(struct i2c_adapter *adap)
1201 {
1202 if (0 != addr) {
1203 normal_i2c[0] = addr;
1204 normal_i2c[1] = I2C_CLIENT_END;
1205 }
1206
1207 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1208 return 0;
1209
1210 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1211 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1212 * and an RTC at 0x6f which can get corrupted if probed.
1213 */
1214 if ((adap->id == I2C_HW_B_CX2388x) ||
1215 (adap->id == I2C_HW_B_CX23885)) {
1216 unsigned int i = 0;
1217
1218 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1219 i += 2;
1220 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1221 ignore[i+0] = adap->nr;
1222 ignore[i+1] = 0x6b;
1223 ignore[i+2] = adap->nr;
1224 ignore[i+3] = 0x6f;
1225 ignore[i+4] = I2C_CLIENT_END;
1226 } else
1227 printk(KERN_WARNING "tuner: "
1228 "too many options specified "
1229 "in i2c probe ignore list!\n");
1230 }
1231 return 1;
1232 }
1233
1234 static int tuner_remove(struct i2c_client *client)
1235 {
1236 struct tuner *t = i2c_get_clientdata(client);
1237 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1238
1239 if (analog_ops->release)
1240 analog_ops->release(&t->fe);
1241
1242 list_del(&t->list);
1243 kfree(t);
1244 return 0;
1245 }
1246
1247 /* ----------------------------------------------------------------------- */
1248
1249 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1250 .name = "tuner",
1251 .driverid = I2C_DRIVERID_TUNER,
1252 .command = tuner_command,
1253 .probe = tuner_probe,
1254 .remove = tuner_remove,
1255 .suspend = tuner_suspend,
1256 .resume = tuner_resume,
1257 .legacy_probe = tuner_legacy_probe,
1258 };
1259
1260
1261 /*
1262 * Overrides for Emacs so that we follow Linus's tabbing style.
1263 * ---------------------------------------------------------------------------
1264 * Local variables:
1265 * c-basic-offset: 8
1266 * End:
1267 */
mah project overlay