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