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