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