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