projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
V4L/DVB (7045): xc5000: Small amount of cleanup and commenting
[deliverable/linux.git] / drivers / media / video / tuner-core.c
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 tuner_warn("====================== WARNING! ======================\n");
301 tuner_warn("Support for tuners in i2c address range 0x64 thru 0x6f\n");
302 tuner_warn("will soon be dropped. This message indicates that your\n");
303 tuner_warn("hardware has a %s tuner at i2c address 0x%02x.\n",
304 t->i2c->name, t->i2c->addr);
305 tuner_warn("To ensure continued support for your device, please\n");
306 tuner_warn("send a copy of this message, along with full dmesg\n");
307 tuner_warn("output to v4l-dvb-maintainer@linuxtv.org\n");
308 tuner_warn("Please use subject line: \"obsolete tuner i2c address.\"\n");
309 tuner_warn("driver: %s, addr: 0x%02x, type: %d (%s)\n",
310 t->i2c->adapter->name, t->i2c->addr, t->type,
311 tuners[t->type].name);
312 tuner_warn("====================== WARNING! ======================\n");
313 }
314
315 static void attach_simple_tuner(struct tuner *t)
316 {
317 struct simple_tuner_config cfg = {
318 .type = t->type,
319 .tun = &tuners[t->type]
320 };
321 simple_tuner_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
322 }
323
324 static void attach_tda829x(struct tuner *t)
325 {
326 struct tda829x_config cfg = {
327 .lna_cfg = &t->config,
328 .tuner_callback = t->tuner_callback,
329 };
330 tda829x_attach(&t->fe, t->i2c->adapter, t->i2c->addr, &cfg);
331 }
332
333 static struct xc5000_config xc5000_cfg;
334
335 static void set_type(struct i2c_client *c, unsigned int type,
336 unsigned int new_mode_mask, unsigned int new_config,
337 int (*tuner_callback) (void *dev, int command,int arg))
338 {
339 struct tuner *t = i2c_get_clientdata(c);
340 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
341 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
342 unsigned char buffer[4];
343
344 if (type == UNSET || type == TUNER_ABSENT) {
345 tuner_dbg ("tuner 0x%02x: Tuner type absent\n",c->addr);
346 return;
347 }
348
349 if (type >= tuner_count) {
350 tuner_warn ("tuner 0x%02x: Tuner count greater than %d\n",c->addr,tuner_count);
351 return;
352 }
353
354 t->type = type;
355 t->config = new_config;
356 if (tuner_callback != NULL) {
357 tuner_dbg("defining GPIO callback\n");
358 t->tuner_callback = tuner_callback;
359 }
360
361 if (t->mode == T_UNINITIALIZED) {
362 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
363
364 return;
365 }
366
367 /* discard private data, in case set_type() was previously called */
368 if (analog_ops->release)
369 analog_ops->release(&t->fe);
370
371 switch (t->type) {
372 case TUNER_MT2032:
373 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
374 break;
375 case TUNER_PHILIPS_TDA8290:
376 {
377 attach_tda829x(t);
378 break;
379 }
380 case TUNER_TEA5767:
381 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
382 t->type = TUNER_ABSENT;
383 t->mode_mask = T_UNINITIALIZED;
384 return;
385 }
386 t->mode_mask = T_RADIO;
387 break;
388 case TUNER_TEA5761:
389 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
390 t->type = TUNER_ABSENT;
391 t->mode_mask = T_UNINITIALIZED;
392 return;
393 }
394 t->mode_mask = T_RADIO;
395 break;
396 case TUNER_PHILIPS_FMD1216ME_MK3:
397 buffer[0] = 0x0b;
398 buffer[1] = 0xdc;
399 buffer[2] = 0x9c;
400 buffer[3] = 0x60;
401 i2c_master_send(c, buffer, 4);
402 mdelay(1);
403 buffer[2] = 0x86;
404 buffer[3] = 0x54;
405 i2c_master_send(c, buffer, 4);
406 attach_simple_tuner(t);
407 break;
408 case TUNER_PHILIPS_TD1316:
409 buffer[0] = 0x0b;
410 buffer[1] = 0xdc;
411 buffer[2] = 0x86;
412 buffer[3] = 0xa4;
413 i2c_master_send(c,buffer,4);
414 attach_simple_tuner(t);
415 break;
416 case TUNER_XC2028:
417 {
418 struct xc2028_config cfg = {
419 .i2c_adap = t->i2c->adapter,
420 .i2c_addr = t->i2c->addr,
421 .video_dev = c->adapter->algo_data,
422 .callback = t->tuner_callback,
423 };
424 if (!xc2028_attach(&t->fe, &cfg)) {
425 t->type = TUNER_ABSENT;
426 t->mode_mask = T_UNINITIALIZED;
427 return;
428 }
429 break;
430 }
431 case TUNER_TDA9887:
432 tda9887_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
433 break;
434 case TUNER_XC5000:
435 xc5000_cfg.i2c_address = t->i2c->addr;
436 xc5000_cfg.if_khz = 5380;
437 xc5000_cfg.priv = c->adapter->algo_data;
438 xc5000_cfg.tuner_callback = t->tuner_callback;
439 if (!xc5000_attach(&t->fe, t->i2c->adapter, &xc5000_cfg)) {
440 t->type = TUNER_ABSENT;
441 t->mode_mask = T_UNINITIALIZED;
442 return;
443 }
444 {
445 struct dvb_tuner_ops *xc_tuner_ops;
446 xc_tuner_ops = &t->fe.ops.tuner_ops;
447 if(xc_tuner_ops->init != NULL)
448 xc_tuner_ops->init(&t->fe);
449 }
450 break;
451 default:
452 attach_simple_tuner(t);
453 break;
454 }
455
456 if ((NULL == analog_ops->set_params) &&
457 (fe_tuner_ops->set_analog_params)) {
458 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
459 sizeof(t->i2c->name));
460
461 t->fe.analog_demod_priv = t;
462 memcpy(analog_ops, &tuner_core_ops,
463 sizeof(struct analog_demod_ops));
464 } else {
465 strlcpy(t->i2c->name, analog_ops->info.name,
466 sizeof(t->i2c->name));
467 }
468
469 tuner_dbg("type set to %s\n", t->i2c->name);
470
471 if (t->mode_mask == T_UNINITIALIZED)
472 t->mode_mask = new_mode_mask;
473
474 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
475 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
476 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
477 t->mode_mask);
478 tuner_i2c_address_check(t);
479 }
480
481 /*
482 * This function apply tuner config to tuner specified
483 * by tun_setup structure. I addr is unset, then admin status
484 * and tun addr status is more precise then current status,
485 * it's applied. Otherwise status and type are applied only to
486 * tuner with exactly the same addr.
487 */
488
489 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
490 {
491 struct tuner *t = i2c_get_clientdata(c);
492
493 tuner_dbg("set addr for type %i\n", t->type);
494
495 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
496 (t->mode_mask & tun_setup->mode_mask))) ||
497 (tun_setup->addr == c->addr)) {
498 set_type(c, tun_setup->type, tun_setup->mode_mask,
499 tun_setup->config, tun_setup->tuner_callback);
500 }
501 }
502
503 static inline int check_mode(struct tuner *t, char *cmd)
504 {
505 if ((1 << t->mode & t->mode_mask) == 0) {
506 return EINVAL;
507 }
508
509 switch (t->mode) {
510 case V4L2_TUNER_RADIO:
511 tuner_dbg("Cmd %s accepted for radio\n", cmd);
512 break;
513 case V4L2_TUNER_ANALOG_TV:
514 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
515 break;
516 case V4L2_TUNER_DIGITAL_TV:
517 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
518 break;
519 }
520 return 0;
521 }
522
523 /* get more precise norm info from insmod option */
524 static int tuner_fixup_std(struct tuner *t)
525 {
526 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
527 switch (pal[0]) {
528 case '6':
529 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
530 t->std = V4L2_STD_PAL_60;
531 break;
532 case 'b':
533 case 'B':
534 case 'g':
535 case 'G':
536 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
537 t->std = V4L2_STD_PAL_BG;
538 break;
539 case 'i':
540 case 'I':
541 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
542 t->std = V4L2_STD_PAL_I;
543 break;
544 case 'd':
545 case 'D':
546 case 'k':
547 case 'K':
548 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
549 t->std = V4L2_STD_PAL_DK;
550 break;
551 case 'M':
552 case 'm':
553 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
554 t->std = V4L2_STD_PAL_M;
555 break;
556 case 'N':
557 case 'n':
558 if (pal[1] == 'c' || pal[1] == 'C') {
559 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
560 t->std = V4L2_STD_PAL_Nc;
561 } else {
562 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
563 t->std = V4L2_STD_PAL_N;
564 }
565 break;
566 case '-':
567 /* default parameter, do nothing */
568 break;
569 default:
570 tuner_warn ("pal= argument not recognised\n");
571 break;
572 }
573 }
574 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
575 switch (secam[0]) {
576 case 'b':
577 case 'B':
578 case 'g':
579 case 'G':
580 case 'h':
581 case 'H':
582 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
583 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
584 break;
585 case 'd':
586 case 'D':
587 case 'k':
588 case 'K':
589 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
590 t->std = V4L2_STD_SECAM_DK;
591 break;
592 case 'l':
593 case 'L':
594 if ((secam[1]=='C')||(secam[1]=='c')) {
595 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
596 t->std = V4L2_STD_SECAM_LC;
597 } else {
598 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
599 t->std = V4L2_STD_SECAM_L;
600 }
601 break;
602 case '-':
603 /* default parameter, do nothing */
604 break;
605 default:
606 tuner_warn ("secam= argument not recognised\n");
607 break;
608 }
609 }
610
611 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
612 switch (ntsc[0]) {
613 case 'm':
614 case 'M':
615 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
616 t->std = V4L2_STD_NTSC_M;
617 break;
618 case 'j':
619 case 'J':
620 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
621 t->std = V4L2_STD_NTSC_M_JP;
622 break;
623 case 'k':
624 case 'K':
625 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
626 t->std = V4L2_STD_NTSC_M_KR;
627 break;
628 case '-':
629 /* default parameter, do nothing */
630 break;
631 default:
632 tuner_info("ntsc= argument not recognised\n");
633 break;
634 }
635 }
636 return 0;
637 }
638
639 static void tuner_status(struct dvb_frontend *fe)
640 {
641 struct tuner *t = fe->analog_demod_priv;
642 unsigned long freq, freq_fraction;
643 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
644 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
645 const char *p;
646
647 switch (t->mode) {
648 case V4L2_TUNER_RADIO: p = "radio"; break;
649 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
650 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
651 default: p = "undefined"; break;
652 }
653 if (t->mode == V4L2_TUNER_RADIO) {
654 freq = t->radio_freq / 16000;
655 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
656 } else {
657 freq = t->tv_freq / 16;
658 freq_fraction = (t->tv_freq % 16) * 100 / 16;
659 }
660 tuner_info("Tuner mode: %s\n", p);
661 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
662 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
663 if (t->mode != V4L2_TUNER_RADIO)
664 return;
665 if (fe_tuner_ops->get_status) {
666 u32 tuner_status;
667
668 fe_tuner_ops->get_status(&t->fe, &tuner_status);
669 if (tuner_status & TUNER_STATUS_LOCKED)
670 tuner_info("Tuner is locked.\n");
671 if (tuner_status & TUNER_STATUS_STEREO)
672 tuner_info("Stereo: yes\n");
673 }
674 if (analog_ops->has_signal)
675 tuner_info("Signal strength: %d\n",
676 analog_ops->has_signal(fe));
677 if (analog_ops->is_stereo)
678 tuner_info("Stereo: %s\n",
679 analog_ops->is_stereo(fe) ? "yes" : "no");
680 }
681
682 /* ---------------------------------------------------------------------- */
683
684 /*
685 * Switch tuner to other mode. If tuner support both tv and radio,
686 * set another frequency to some value (This is needed for some pal
687 * tuners to avoid locking). Otherwise, just put second tuner in
688 * standby mode.
689 */
690
691 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
692 {
693 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
694
695 if (mode == t->mode)
696 return 0;
697
698 t->mode = mode;
699
700 if (check_mode(t, cmd) == EINVAL) {
701 t->mode = T_STANDBY;
702 if (analog_ops->standby)
703 analog_ops->standby(&t->fe);
704 return EINVAL;
705 }
706 return 0;
707 }
708
709 #define switch_v4l2() if (!t->using_v4l2) \
710 tuner_dbg("switching to v4l2\n"); \
711 t->using_v4l2 = 1;
712
713 static inline int check_v4l2(struct tuner *t)
714 {
715 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
716 TV, v4l1 for radio), until that is fixed this code is disabled.
717 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
718 first. */
719 return 0;
720 }
721
722 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
723 {
724 struct tuner *t = i2c_get_clientdata(client);
725 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
726 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
727
728 if (tuner_debug>1)
729 v4l_i2c_print_ioctl(client,cmd);
730
731 switch (cmd) {
732 /* --- configuration --- */
733 case TUNER_SET_TYPE_ADDR:
734 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
735 ((struct tuner_setup *)arg)->type,
736 ((struct tuner_setup *)arg)->addr,
737 ((struct tuner_setup *)arg)->mode_mask,
738 ((struct tuner_setup *)arg)->config);
739
740 set_addr(client, (struct tuner_setup *)arg);
741 break;
742 case AUDC_SET_RADIO:
743 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
744 == EINVAL)
745 return 0;
746 if (t->radio_freq)
747 set_freq(client, t->radio_freq);
748 break;
749 case TUNER_SET_STANDBY:
750 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
751 return 0;
752 t->mode = T_STANDBY;
753 if (analog_ops->standby)
754 analog_ops->standby(&t->fe);
755 break;
756 #ifdef CONFIG_VIDEO_V4L1
757 case VIDIOCSAUDIO:
758 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
759 return 0;
760 if (check_v4l2(t) == EINVAL)
761 return 0;
762
763 /* Should be implemented, since bttv calls it */
764 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
765 break;
766 case VIDIOCSCHAN:
767 {
768 static const v4l2_std_id map[] = {
769 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
770 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
771 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
772 [4 /* bttv */ ] = V4L2_STD_PAL_M,
773 [5 /* bttv */ ] = V4L2_STD_PAL_N,
774 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
775 };
776 struct video_channel *vc = arg;
777
778 if (check_v4l2(t) == EINVAL)
779 return 0;
780
781 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
782 return 0;
783
784 if (vc->norm < ARRAY_SIZE(map))
785 t->std = map[vc->norm];
786 tuner_fixup_std(t);
787 if (t->tv_freq)
788 set_tv_freq(client, t->tv_freq);
789 return 0;
790 }
791 case VIDIOCSFREQ:
792 {
793 unsigned long *v = arg;
794
795 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
796 return 0;
797 if (check_v4l2(t) == EINVAL)
798 return 0;
799
800 set_freq(client, *v);
801 return 0;
802 }
803 case VIDIOCGTUNER:
804 {
805 struct video_tuner *vt = arg;
806
807 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
808 return 0;
809 if (check_v4l2(t) == EINVAL)
810 return 0;
811
812 if (V4L2_TUNER_RADIO == t->mode) {
813 if (fe_tuner_ops->get_status) {
814 u32 tuner_status;
815
816 fe_tuner_ops->get_status(&t->fe, &tuner_status);
817 if (tuner_status & TUNER_STATUS_STEREO)
818 vt->flags |= VIDEO_TUNER_STEREO_ON;
819 else
820 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
821 } else {
822 if (analog_ops->is_stereo) {
823 if (analog_ops->is_stereo(&t->fe))
824 vt->flags |=
825 VIDEO_TUNER_STEREO_ON;
826 else
827 vt->flags &=
828 ~VIDEO_TUNER_STEREO_ON;
829 }
830 }
831 if (analog_ops->has_signal)
832 vt->signal =
833 analog_ops->has_signal(&t->fe);
834
835 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
836
837 vt->rangelow = radio_range[0] * 16000;
838 vt->rangehigh = radio_range[1] * 16000;
839
840 } else {
841 vt->rangelow = tv_range[0] * 16;
842 vt->rangehigh = tv_range[1] * 16;
843 }
844
845 return 0;
846 }
847 case VIDIOCGAUDIO:
848 {
849 struct video_audio *va = arg;
850
851 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
852 return 0;
853 if (check_v4l2(t) == EINVAL)
854 return 0;
855
856 if (V4L2_TUNER_RADIO == t->mode) {
857 if (fe_tuner_ops->get_status) {
858 u32 tuner_status;
859
860 fe_tuner_ops->get_status(&t->fe, &tuner_status);
861 va->mode = (tuner_status & TUNER_STATUS_STEREO)
862 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
863 } else if (analog_ops->is_stereo)
864 va->mode = analog_ops->is_stereo(&t->fe)
865 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
866 }
867 return 0;
868 }
869 #endif
870 case TUNER_SET_CONFIG:
871 {
872 struct v4l2_priv_tun_config *cfg = arg;
873
874 if (t->type != cfg->tuner)
875 break;
876
877 if (analog_ops->set_config) {
878 analog_ops->set_config(&t->fe, cfg->priv);
879 break;
880 }
881
882 tuner_dbg("Tuner frontend module has no way to set config\n");
883 break;
884 }
885 /* --- v4l ioctls --- */
886 /* take care: bttv does userspace copying, we'll get a
887 kernel pointer here... */
888 case VIDIOC_S_STD:
889 {
890 v4l2_std_id *id = arg;
891
892 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
893 == EINVAL)
894 return 0;
895
896 switch_v4l2();
897
898 t->std = *id;
899 tuner_fixup_std(t);
900 if (t->tv_freq)
901 set_freq(client, t->tv_freq);
902 break;
903 }
904 case VIDIOC_S_FREQUENCY:
905 {
906 struct v4l2_frequency *f = arg;
907
908 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
909 == EINVAL)
910 return 0;
911 switch_v4l2();
912 set_freq(client,f->frequency);
913
914 break;
915 }
916 case VIDIOC_G_FREQUENCY:
917 {
918 struct v4l2_frequency *f = arg;
919
920 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
921 return 0;
922 switch_v4l2();
923 f->type = t->mode;
924 if (fe_tuner_ops->get_frequency) {
925 u32 abs_freq;
926
927 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
928 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
929 (abs_freq * 2 + 125/2) / 125 :
930 (abs_freq + 62500/2) / 62500;
931 break;
932 }
933 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
934 t->radio_freq : t->tv_freq;
935 break;
936 }
937 case VIDIOC_G_TUNER:
938 {
939 struct v4l2_tuner *tuner = arg;
940
941 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
942 return 0;
943 switch_v4l2();
944
945 tuner->type = t->mode;
946 if (analog_ops->get_afc)
947 tuner->afc = analog_ops->get_afc(&t->fe);
948 if (t->mode == V4L2_TUNER_ANALOG_TV)
949 tuner->capability |= V4L2_TUNER_CAP_NORM;
950 if (t->mode != V4L2_TUNER_RADIO) {
951 tuner->rangelow = tv_range[0] * 16;
952 tuner->rangehigh = tv_range[1] * 16;
953 break;
954 }
955
956 /* radio mode */
957 tuner->rxsubchans =
958 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
959 if (fe_tuner_ops->get_status) {
960 u32 tuner_status;
961
962 fe_tuner_ops->get_status(&t->fe, &tuner_status);
963 tuner->rxsubchans =
964 (tuner_status & TUNER_STATUS_STEREO) ?
965 V4L2_TUNER_SUB_STEREO :
966 V4L2_TUNER_SUB_MONO;
967 } else {
968 if (analog_ops->is_stereo) {
969 tuner->rxsubchans =
970 analog_ops->is_stereo(&t->fe) ?
971 V4L2_TUNER_SUB_STEREO :
972 V4L2_TUNER_SUB_MONO;
973 }
974 }
975 if (analog_ops->has_signal)
976 tuner->signal = analog_ops->has_signal(&t->fe);
977 tuner->capability |=
978 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
979 tuner->audmode = t->audmode;
980 tuner->rangelow = radio_range[0] * 16000;
981 tuner->rangehigh = radio_range[1] * 16000;
982 break;
983 }
984 case VIDIOC_S_TUNER:
985 {
986 struct v4l2_tuner *tuner = arg;
987
988 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
989 return 0;
990
991 switch_v4l2();
992
993 /* do nothing unless we're a radio tuner */
994 if (t->mode != V4L2_TUNER_RADIO)
995 break;
996 t->audmode = tuner->audmode;
997 set_radio_freq(client, t->radio_freq);
998 break;
999 }
1000 case VIDIOC_LOG_STATUS:
1001 if (analog_ops->tuner_status)
1002 analog_ops->tuner_status(&t->fe);
1003 break;
1004 }
1005
1006 return 0;
1007 }
1008
1009 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1010 {
1011 struct tuner *t = i2c_get_clientdata(c);
1012
1013 tuner_dbg("suspend\n");
1014 /* FIXME: power down ??? */
1015 return 0;
1016 }
1017
1018 static int tuner_resume(struct i2c_client *c)
1019 {
1020 struct tuner *t = i2c_get_clientdata(c);
1021
1022 tuner_dbg("resume\n");
1023 if (V4L2_TUNER_RADIO == t->mode) {
1024 if (t->radio_freq)
1025 set_freq(c, t->radio_freq);
1026 } else {
1027 if (t->tv_freq)
1028 set_freq(c, t->tv_freq);
1029 }
1030 return 0;
1031 }
1032
1033 /* ---------------------------------------------------------------------- */
1034
1035 LIST_HEAD(tuner_list);
1036
1037 /* Search for existing radio and/or TV tuners on the given I2C adapter.
1038 Note that when this function is called from tuner_probe you can be
1039 certain no other devices will be added/deleted at the same time, I2C
1040 core protects against that. */
1041 static void tuner_lookup(struct i2c_adapter *adap,
1042 struct tuner **radio, struct tuner **tv)
1043 {
1044 struct tuner *pos;
1045
1046 *radio = NULL;
1047 *tv = NULL;
1048
1049 list_for_each_entry(pos, &tuner_list, list) {
1050 int mode_mask;
1051
1052 if (pos->i2c->adapter != adap ||
1053 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
1054 continue;
1055
1056 mode_mask = pos->mode_mask & ~T_STANDBY;
1057 if (*radio == NULL && mode_mask == T_RADIO)
1058 *radio = pos;
1059 /* Note: currently TDA9887 is the only demod-only
1060 device. If other devices appear then we need to
1061 make this test more general. */
1062 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
1063 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
1064 *tv = pos;
1065 }
1066 }
1067
1068 /* During client attach, set_type is called by adapter's attach_inform callback.
1069 set_type must then be completed by tuner_probe.
1070 */
1071 static int tuner_probe(struct i2c_client *client)
1072 {
1073 struct tuner *t;
1074 struct tuner *radio;
1075 struct tuner *tv;
1076
1077 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
1078 if (NULL == t)
1079 return -ENOMEM;
1080 t->i2c = client;
1081 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
1082 i2c_set_clientdata(client, t);
1083 t->type = UNSET;
1084 t->audmode = V4L2_TUNER_MODE_STEREO;
1085 t->mode_mask = T_UNINITIALIZED;
1086
1087 if (show_i2c) {
1088 unsigned char buffer[16];
1089 int i, rc;
1090
1091 memset(buffer, 0, sizeof(buffer));
1092 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1093 tuner_info("I2C RECV = ");
1094 for (i = 0; i < rc; i++)
1095 printk(KERN_CONT "%02x ", buffer[i]);
1096 printk("\n");
1097 }
1098 /* HACK: This test was added to avoid tuner to probe tda9840 and
1099 tea6415c on the MXB card */
1100 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1101 kfree(t);
1102 return -ENODEV;
1103 }
1104
1105 /* autodetection code based on the i2c addr */
1106 if (!no_autodetect) {
1107 switch (client->addr) {
1108 case 0x10:
1109 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1110 != EINVAL) {
1111 t->type = TUNER_TEA5761;
1112 t->mode_mask = T_RADIO;
1113 t->mode = T_STANDBY;
1114 /* Sets freq to FM range */
1115 t->radio_freq = 87.5 * 16000;
1116 tuner_lookup(t->i2c->adapter, &radio, &tv);
1117 if (tv)
1118 tv->mode_mask &= ~T_RADIO;
1119
1120 goto register_client;
1121 }
1122 break;
1123 case 0x42:
1124 case 0x43:
1125 case 0x4a:
1126 case 0x4b:
1127 /* If chip is not tda8290, don't register.
1128 since it can be tda9887*/
1129 if (tda829x_probe(t->i2c->adapter,
1130 t->i2c->addr) == 0) {
1131 tuner_dbg("tda829x detected\n");
1132 } else {
1133 /* Default is being tda9887 */
1134 t->type = TUNER_TDA9887;
1135 t->mode_mask = T_RADIO | T_ANALOG_TV |
1136 T_DIGITAL_TV;
1137 t->mode = T_STANDBY;
1138 goto register_client;
1139 }
1140 break;
1141 case 0x60:
1142 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1143 != EINVAL) {
1144 t->type = TUNER_TEA5767;
1145 t->mode_mask = T_RADIO;
1146 t->mode = T_STANDBY;
1147 /* Sets freq to FM range */
1148 t->radio_freq = 87.5 * 16000;
1149 tuner_lookup(t->i2c->adapter, &radio, &tv);
1150 if (tv)
1151 tv->mode_mask &= ~T_RADIO;
1152
1153 goto register_client;
1154 }
1155 break;
1156 }
1157 }
1158
1159 /* Initializes only the first TV tuner on this adapter. Why only the
1160 first? Because there are some devices (notably the ones with TI
1161 tuners) that have more than one i2c address for the *same* device.
1162 Experience shows that, except for just one case, the first
1163 address is the right one. The exception is a Russian tuner
1164 (ACORP_Y878F). So, the desired behavior is just to enable the
1165 first found TV tuner. */
1166 tuner_lookup(t->i2c->adapter, &radio, &tv);
1167 if (tv == NULL) {
1168 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1169 if (radio == NULL)
1170 t->mode_mask |= T_RADIO;
1171 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1172 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1173 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1174 }
1175
1176 /* Should be just before return */
1177 register_client:
1178 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1179 client->adapter->name);
1180
1181 /* Sets a default mode */
1182 if (t->mode_mask & T_ANALOG_TV) {
1183 t->mode = V4L2_TUNER_ANALOG_TV;
1184 } else if (t->mode_mask & T_RADIO) {
1185 t->mode = V4L2_TUNER_RADIO;
1186 } else {
1187 t->mode = V4L2_TUNER_DIGITAL_TV;
1188 }
1189 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1190 list_add_tail(&t->list, &tuner_list);
1191 return 0;
1192 }
1193
1194 static int tuner_legacy_probe(struct i2c_adapter *adap)
1195 {
1196 if (0 != addr) {
1197 normal_i2c[0] = addr;
1198 normal_i2c[1] = I2C_CLIENT_END;
1199 }
1200
1201 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1202 return 0;
1203
1204 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1205 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1206 * and an RTC at 0x6f which can get corrupted if probed.
1207 */
1208 if ((adap->id == I2C_HW_B_CX2388x) ||
1209 (adap->id == I2C_HW_B_CX23885)) {
1210 unsigned int i = 0;
1211
1212 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1213 i += 2;
1214 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1215 ignore[i+0] = adap->nr;
1216 ignore[i+1] = 0x6b;
1217 ignore[i+2] = adap->nr;
1218 ignore[i+3] = 0x6f;
1219 ignore[i+4] = I2C_CLIENT_END;
1220 } else
1221 printk(KERN_WARNING "tuner: "
1222 "too many options specified "
1223 "in i2c probe ignore list!\n");
1224 }
1225 return 1;
1226 }
1227
1228 static int tuner_remove(struct i2c_client *client)
1229 {
1230 struct tuner *t = i2c_get_clientdata(client);
1231 struct analog_demod_ops *analog_ops = &t->fe.ops.analog_ops;
1232
1233 if (analog_ops->release)
1234 analog_ops->release(&t->fe);
1235
1236 list_del(&t->list);
1237 kfree(t);
1238 return 0;
1239 }
1240
1241 /* ----------------------------------------------------------------------- */
1242
1243 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1244 .name = "tuner",
1245 .driverid = I2C_DRIVERID_TUNER,
1246 .command = tuner_command,
1247 .probe = tuner_probe,
1248 .remove = tuner_remove,
1249 .suspend = tuner_suspend,
1250 .resume = tuner_resume,
1251 .legacy_probe = tuner_legacy_probe,
1252 };
1253
1254
1255 /*
1256 * Overrides for Emacs so that we follow Linus's tabbing style.
1257 * ---------------------------------------------------------------------------
1258 * Local variables:
1259 * c-basic-offset: 8
1260 * End:
1261 */
Linux kernel - Deliverables
This page took 0.060513 seconds and 6 git commands to generate.