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