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