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