?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (6384): Replace TDA9887_SET_CONFIG by TUNER_SET_CONFIG
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / media / video / tuner-core.c
blobd1d6c664bb09f57ef9024b2bba31e8f207ef15d5
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 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
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 = 0;
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 case TUNER_TEA5761:
296 if (tea5761_attach(&t->fe, t->i2c.adapter, t->i2c.addr) == NULL) {
297 t->type = TUNER_ABSENT;
298 t->mode_mask = T_UNINITIALIZED;
299 return;
300 }
301 t->mode_mask = T_RADIO;
302 break;
303 case TUNER_PHILIPS_FMD1216ME_MK3:
304 buffer[0] = 0x0b;
305 buffer[1] = 0xdc;
306 buffer[2] = 0x9c;
307 buffer[3] = 0x60;
308 i2c_master_send(c, buffer, 4);
309 mdelay(1);
310 buffer[2] = 0x86;
311 buffer[3] = 0x54;
312 i2c_master_send(c, buffer, 4);
313 attach_simple_tuner(t);
314 break;
315 case TUNER_PHILIPS_TD1316:
316 buffer[0] = 0x0b;
317 buffer[1] = 0xdc;
318 buffer[2] = 0x86;
319 buffer[3] = 0xa4;
320 i2c_master_send(c,buffer,4);
321 attach_simple_tuner(t);
322 break;
323 case TUNER_TDA9887:
324 tda9887_tuner_init(t);
325 break;
326 default:
327 attach_simple_tuner(t);
328 break;
329 }
330
331 if (fe_tuner_ops->set_analog_params) {
332 strlcpy(t->i2c.name, fe_tuner_ops->info.name, sizeof(t->i2c.name));
333
334 t->ops.set_tv_freq = fe_set_freq;
335 t->ops.set_radio_freq = fe_set_freq;
336 t->ops.standby = fe_standby;
337 t->ops.release = fe_release;
338 t->ops.has_signal = fe_has_signal;
339 }
340
341 tuner_info("type set to %s\n", t->i2c.name);
342
343 if (t->mode_mask == T_UNINITIALIZED)
344 t->mode_mask = new_mode_mask;
345
346 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
347 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
348 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
349 t->mode_mask);
350 tuner_i2c_address_check(t);
351 }
352
353 /*
354 * This function apply tuner config to tuner specified
355 * by tun_setup structure. I addr is unset, then admin status
356 * and tun addr status is more precise then current status,
357 * it's applied. Otherwise status and type are applied only to
358 * tuner with exactly the same addr.
359 */
360
361 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
362 {
363 struct tuner *t = i2c_get_clientdata(c);
364
365 tuner_dbg("set addr for type %i\n", t->type);
366
367 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
368 (t->mode_mask & tun_setup->mode_mask))) ||
369 (tun_setup->addr == c->addr)) {
370 set_type(c, tun_setup->type, tun_setup->mode_mask,
371 tun_setup->config, tun_setup->tuner_callback);
372 }
373 }
374
375 static inline int check_mode(struct tuner *t, char *cmd)
376 {
377 if ((1 << t->mode & t->mode_mask) == 0) {
378 return EINVAL;
379 }
380
381 switch (t->mode) {
382 case V4L2_TUNER_RADIO:
383 tuner_dbg("Cmd %s accepted for radio\n", cmd);
384 break;
385 case V4L2_TUNER_ANALOG_TV:
386 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
387 break;
388 case V4L2_TUNER_DIGITAL_TV:
389 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
390 break;
391 }
392 return 0;
393 }
394
395 /* get more precise norm info from insmod option */
396 static int tuner_fixup_std(struct tuner *t)
397 {
398 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
399 switch (pal[0]) {
400 case '6':
401 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
402 t->std = V4L2_STD_PAL_60;
403 break;
404 case 'b':
405 case 'B':
406 case 'g':
407 case 'G':
408 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
409 t->std = V4L2_STD_PAL_BG;
410 break;
411 case 'i':
412 case 'I':
413 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
414 t->std = V4L2_STD_PAL_I;
415 break;
416 case 'd':
417 case 'D':
418 case 'k':
419 case 'K':
420 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
421 t->std = V4L2_STD_PAL_DK;
422 break;
423 case 'M':
424 case 'm':
425 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
426 t->std = V4L2_STD_PAL_M;
427 break;
428 case 'N':
429 case 'n':
430 if (pal[1] == 'c' || pal[1] == 'C') {
431 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
432 t->std = V4L2_STD_PAL_Nc;
433 } else {
434 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
435 t->std = V4L2_STD_PAL_N;
436 }
437 break;
438 case '-':
439 /* default parameter, do nothing */
440 break;
441 default:
442 tuner_warn ("pal= argument not recognised\n");
443 break;
444 }
445 }
446 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
447 switch (secam[0]) {
448 case 'b':
449 case 'B':
450 case 'g':
451 case 'G':
452 case 'h':
453 case 'H':
454 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
455 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
456 break;
457 case 'd':
458 case 'D':
459 case 'k':
460 case 'K':
461 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
462 t->std = V4L2_STD_SECAM_DK;
463 break;
464 case 'l':
465 case 'L':
466 if ((secam[1]=='C')||(secam[1]=='c')) {
467 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
468 t->std = V4L2_STD_SECAM_LC;
469 } else {
470 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
471 t->std = V4L2_STD_SECAM_L;
472 }
473 break;
474 case '-':
475 /* default parameter, do nothing */
476 break;
477 default:
478 tuner_warn ("secam= argument not recognised\n");
479 break;
480 }
481 }
482
483 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
484 switch (ntsc[0]) {
485 case 'm':
486 case 'M':
487 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
488 t->std = V4L2_STD_NTSC_M;
489 break;
490 case 'j':
491 case 'J':
492 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
493 t->std = V4L2_STD_NTSC_M_JP;
494 break;
495 case 'k':
496 case 'K':
497 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
498 t->std = V4L2_STD_NTSC_M_KR;
499 break;
500 case '-':
501 /* default parameter, do nothing */
502 break;
503 default:
504 tuner_info("ntsc= argument not recognised\n");
505 break;
506 }
507 }
508 return 0;
509 }
510
511 static void tuner_status(struct tuner *t)
512 {
513 unsigned long freq, freq_fraction;
514 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
515 const char *p;
516
517 switch (t->mode) {
518 case V4L2_TUNER_RADIO: p = "radio"; break;
519 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
520 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
521 default: p = "undefined"; break;
522 }
523 if (t->mode == V4L2_TUNER_RADIO) {
524 freq = t->radio_freq / 16000;
525 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
526 } else {
527 freq = t->tv_freq / 16;
528 freq_fraction = (t->tv_freq % 16) * 100 / 16;
529 }
530 tuner_info("Tuner mode: %s\n", p);
531 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
532 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
533 if (t->mode != V4L2_TUNER_RADIO)
534 return;
535 if (fe_tuner_ops->get_status) {
536 u32 tuner_status;
537
538 fe_tuner_ops->get_status(&t->fe, &tuner_status);
539 if (tuner_status & TUNER_STATUS_LOCKED)
540 tuner_info("Tuner is locked.\n");
541 if (tuner_status & TUNER_STATUS_STEREO)
542 tuner_info("Stereo: yes\n");
543 }
544 if (t->ops.has_signal) {
545 tuner_info("Signal strength: %d\n", t->ops.has_signal(t));
546 }
547 if (t->ops.is_stereo) {
548 tuner_info("Stereo: %s\n", t->ops.is_stereo(t) ? "yes" : "no");
549 }
550 }
551
552 /* ---------------------------------------------------------------------- */
553
554 /* static vars: used only in tuner_attach and tuner_probe */
555 static unsigned default_mode_mask;
556
557 /* During client attach, set_type is called by adapter's attach_inform callback.
558 set_type must then be completed by tuner_attach.
559 */
560 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
561 {
562 struct tuner *t;
563
564 client_template.adapter = adap;
565 client_template.addr = addr;
566
567 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
568 if (NULL == t)
569 return -ENOMEM;
570 memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
571 i2c_set_clientdata(&t->i2c, t);
572 t->type = UNSET;
573 t->audmode = V4L2_TUNER_MODE_STEREO;
574 t->mode_mask = T_UNINITIALIZED;
575 t->ops.tuner_status = tuner_status;
576
577 if (show_i2c) {
578 unsigned char buffer[16];
579 int i,rc;
580
581 memset(buffer, 0, sizeof(buffer));
582 rc = i2c_master_recv(&t->i2c, buffer, sizeof(buffer));
583 tuner_info("I2C RECV = ");
584 for (i=0;i<rc;i++)
585 printk("%02x ",buffer[i]);
586 printk("\n");
587 }
588 /* HACK: This test were added to avoid tuner to probe tda9840 and tea6415c on the MXB card */
589 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
590 return -ENODEV;
591
592 /* autodetection code based on the i2c addr */
593 if (!no_autodetect) {
594 switch (addr) {
595 case 0x10:
596 if (tea5761_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
597 t->type = TUNER_TEA5761;
598 t->mode_mask = T_RADIO;
599 t->mode = T_STANDBY;
600 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
601 default_mode_mask &= ~T_RADIO;
602
603 goto register_client;
604 }
605 break;
606 case 0x42:
607 case 0x43:
608 case 0x4a:
609 case 0x4b:
610 /* If chip is not tda8290, don't register.
611 since it can be tda9887*/
612 if (tda8290_probe(t->i2c.adapter, t->i2c.addr) == 0) {
613 tuner_dbg("chip at addr %x is a tda8290\n", addr);
614 } else {
615 /* Default is being tda9887 */
616 t->type = TUNER_TDA9887;
617 t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
618 t->mode = T_STANDBY;
619 goto register_client;
620 }
621 break;
622 case 0x60:
623 if (tea5767_autodetection(t->i2c.adapter, t->i2c.addr) != EINVAL) {
624 t->type = TUNER_TEA5767;
625 t->mode_mask = T_RADIO;
626 t->mode = T_STANDBY;
627 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
628 default_mode_mask &= ~T_RADIO;
629
630 goto register_client;
631 }
632 break;
633 }
634 }
635
636 /* Initializes only the first adapter found */
637 if (default_mode_mask != T_UNINITIALIZED) {
638 tuner_dbg ("Setting mode_mask to 0x%02x\n", default_mode_mask);
639 t->mode_mask = default_mode_mask;
640 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
641 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
642 default_mode_mask = T_UNINITIALIZED;
643 }
644
645 /* Should be just before return */
646 register_client:
647 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
648 i2c_attach_client (&t->i2c);
649 set_type (&t->i2c,t->type, t->mode_mask, t->config, t->tuner_callback);
650 return 0;
651 }
652
653 static int tuner_probe(struct i2c_adapter *adap)
654 {
655 if (0 != addr) {
656 normal_i2c[0] = addr;
657 normal_i2c[1] = I2C_CLIENT_END;
658 }
659
660 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
661 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
662 * and an RTC at 0x6f which can get corrupted if probed.
663 */
664 if ((adap->id == I2C_HW_B_CX2388x) ||
665 (adap->id == I2C_HW_B_CX23885)) {
666 unsigned int i = 0;
667
668 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
669 i += 2;
670 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
671 ignore[i+0] = adap->nr;
672 ignore[i+1] = 0x6b;
673 ignore[i+2] = adap->nr;
674 ignore[i+3] = 0x6f;
675 ignore[i+4] = I2C_CLIENT_END;
676 } else
677 printk(KERN_WARNING "tuner: "
678 "too many options specified "
679 "in i2c probe ignore list!\n");
680 }
681
682 default_mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
683
684 if (adap->class & I2C_CLASS_TV_ANALOG)
685 return i2c_probe(adap, &addr_data, tuner_attach);
686 return 0;
687 }
688
689 static int tuner_detach(struct i2c_client *client)
690 {
691 struct tuner *t = i2c_get_clientdata(client);
692 int err;
693
694 err = i2c_detach_client(&t->i2c);
695 if (err) {
696 tuner_warn
697 ("Client deregistration failed, client not detached.\n");
698 return err;
699 }
700
701 if (t->ops.release)
702 t->ops.release(t);
703 else {
704 kfree(t->priv);
705 }
706 kfree(t);
707 return 0;
708 }
709
710 /*
711 * Switch tuner to other mode. If tuner support both tv and radio,
712 * set another frequency to some value (This is needed for some pal
713 * tuners to avoid locking). Otherwise, just put second tuner in
714 * standby mode.
715 */
716
717 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
718 {
719 if (mode == t->mode)
720 return 0;
721
722 t->mode = mode;
723
724 if (check_mode(t, cmd) == EINVAL) {
725 t->mode = T_STANDBY;
726 if (t->ops.standby)
727 t->ops.standby(t);
728 return EINVAL;
729 }
730 return 0;
731 }
732
733 #define switch_v4l2() if (!t->using_v4l2) \
734 tuner_dbg("switching to v4l2\n"); \
735 t->using_v4l2 = 1;
736
737 static inline int check_v4l2(struct tuner *t)
738 {
739 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
740 TV, v4l1 for radio), until that is fixed this code is disabled.
741 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
742 first. */
743 return 0;
744 }
745
746 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
747 {
748 struct tuner *t = i2c_get_clientdata(client);
749 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
750
751 if (tuner_debug>1)
752 v4l_i2c_print_ioctl(&(t->i2c),cmd);
753
754 switch (cmd) {
755 /* --- configuration --- */
756 case TUNER_SET_TYPE_ADDR:
757 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
758 ((struct tuner_setup *)arg)->type,
759 ((struct tuner_setup *)arg)->addr,
760 ((struct tuner_setup *)arg)->mode_mask,
761 ((struct tuner_setup *)arg)->config);
762
763 set_addr(client, (struct tuner_setup *)arg);
764 break;
765 case AUDC_SET_RADIO:
766 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
767 == EINVAL)
768 return 0;
769 if (t->radio_freq)
770 set_freq(client, t->radio_freq);
771 break;
772 case TUNER_SET_STANDBY:
773 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
774 return 0;
775 t->mode = T_STANDBY;
776 if (t->ops.standby)
777 t->ops.standby(t);
778 break;
779 #ifdef CONFIG_VIDEO_V4L1
780 case VIDIOCSAUDIO:
781 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
782 return 0;
783 if (check_v4l2(t) == EINVAL)
784 return 0;
785
786 /* Should be implemented, since bttv calls it */
787 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
788 break;
789 case VIDIOCSCHAN:
790 {
791 static const v4l2_std_id map[] = {
792 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
793 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
794 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
795 [4 /* bttv */ ] = V4L2_STD_PAL_M,
796 [5 /* bttv */ ] = V4L2_STD_PAL_N,
797 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
798 };
799 struct video_channel *vc = arg;
800
801 if (check_v4l2(t) == EINVAL)
802 return 0;
803
804 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
805 return 0;
806
807 if (vc->norm < ARRAY_SIZE(map))
808 t->std = map[vc->norm];
809 tuner_fixup_std(t);
810 if (t->tv_freq)
811 set_tv_freq(client, t->tv_freq);
812 return 0;
813 }
814 case VIDIOCSFREQ:
815 {
816 unsigned long *v = arg;
817
818 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
819 return 0;
820 if (check_v4l2(t) == EINVAL)
821 return 0;
822
823 set_freq(client, *v);
824 return 0;
825 }
826 case VIDIOCGTUNER:
827 {
828 struct video_tuner *vt = arg;
829
830 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
831 return 0;
832 if (check_v4l2(t) == EINVAL)
833 return 0;
834
835 if (V4L2_TUNER_RADIO == t->mode) {
836 if (fe_tuner_ops->get_status) {
837 u32 tuner_status;
838
839 fe_tuner_ops->get_status(&t->fe, &tuner_status);
840 if (tuner_status & TUNER_STATUS_STEREO)
841 vt->flags |= VIDEO_TUNER_STEREO_ON;
842 else
843 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
844 } else {
845 if (t->ops.is_stereo) {
846 if (t->ops.is_stereo(t))
847 vt->flags |=
848 VIDEO_TUNER_STEREO_ON;
849 else
850 vt->flags &=
851 ~VIDEO_TUNER_STEREO_ON;
852 }
853 }
854 if (t->ops.has_signal)
855 vt->signal = t->ops.has_signal(t);
856
857 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
858
859 vt->rangelow = radio_range[0] * 16000;
860 vt->rangehigh = radio_range[1] * 16000;
861
862 } else {
863 vt->rangelow = tv_range[0] * 16;
864 vt->rangehigh = tv_range[1] * 16;
865 }
866
867 return 0;
868 }
869 case VIDIOCGAUDIO:
870 {
871 struct video_audio *va = arg;
872
873 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
874 return 0;
875 if (check_v4l2(t) == EINVAL)
876 return 0;
877
878 if (V4L2_TUNER_RADIO == t->mode) {
879 if (fe_tuner_ops->get_status) {
880 u32 tuner_status;
881
882 fe_tuner_ops->get_status(&t->fe, &tuner_status);
883 va->mode = (tuner_status & TUNER_STATUS_STEREO)
884 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
885 } else if (t->ops.is_stereo)
886 va->mode = t->ops.is_stereo(t)
887 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
888 }
889 return 0;
890 }
891 #endif
892 case TUNER_SET_CONFIG:
893 {
894 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
895 struct v4l2_priv_tun_config *cfg = arg;
896
897 if (t->type != cfg->tuner)
898 break;
899
900 if (t->type == TUNER_TDA9887) {
901 t->tda9887_config = *(unsigned int *)cfg->priv;
902 set_freq(client, t->tv_freq);
903 break;
904 }
905
906 if (NULL == fe_tuner_ops->set_config) {
907 tuner_warn("Tuner frontend module has no way to "
908 "set config\n");
909 break;
910 }
911 fe_tuner_ops->set_config(&t->fe, cfg->priv);
912
913 break;
914 }
915 /* --- v4l ioctls --- */
916 /* take care: bttv does userspace copying, we'll get a
917 kernel pointer here... */
918 case VIDIOC_S_STD:
919 {
920 v4l2_std_id *id = arg;
921
922 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
923 == EINVAL)
924 return 0;
925
926 switch_v4l2();
927
928 t->std = *id;
929 tuner_fixup_std(t);
930 if (t->tv_freq)
931 set_freq(client, t->tv_freq);
932 break;
933 }
934 case VIDIOC_S_FREQUENCY:
935 {
936 struct v4l2_frequency *f = arg;
937
938 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
939 == EINVAL)
940 return 0;
941 switch_v4l2();
942 set_freq(client,f->frequency);
943
944 break;
945 }
946 case VIDIOC_G_FREQUENCY:
947 {
948 struct v4l2_frequency *f = arg;
949
950 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
951 return 0;
952 switch_v4l2();
953 f->type = t->mode;
954 if (fe_tuner_ops->get_frequency) {
955 u32 abs_freq;
956
957 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
958 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
959 (abs_freq * 2 + 125/2) / 125 :
960 (abs_freq + 62500/2) / 62500;
961 break;
962 }
963 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
964 t->radio_freq : t->tv_freq;
965 break;
966 }
967 case VIDIOC_G_TUNER:
968 {
969 struct v4l2_tuner *tuner = arg;
970
971 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
972 return 0;
973 switch_v4l2();
974
975 tuner->type = t->mode;
976 if (t->ops.get_afc)
977 tuner->afc=t->ops.get_afc(t);
978 if (t->mode == V4L2_TUNER_ANALOG_TV)
979 tuner->capability |= V4L2_TUNER_CAP_NORM;
980 if (t->mode != V4L2_TUNER_RADIO) {
981 tuner->rangelow = tv_range[0] * 16;
982 tuner->rangehigh = tv_range[1] * 16;
983 break;
984 }
985
986 /* radio mode */
987 tuner->rxsubchans =
988 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
989 if (fe_tuner_ops->get_status) {
990 u32 tuner_status;
991
992 fe_tuner_ops->get_status(&t->fe, &tuner_status);
993 tuner->rxsubchans = (tuner_status & TUNER_STATUS_STEREO) ?
994 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
995 } else {
996 if (t->ops.is_stereo) {
997 tuner->rxsubchans = t->ops.is_stereo(t) ?
998 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
999 }
1000 }
1001 if (t->ops.has_signal)
1002 tuner->signal = t->ops.has_signal(t);
1003 tuner->capability |=
1004 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
1005 tuner->audmode = t->audmode;
1006 tuner->rangelow = radio_range[0] * 16000;
1007 tuner->rangehigh = radio_range[1] * 16000;
1008 break;
1009 }
1010 case VIDIOC_S_TUNER:
1011 {
1012 struct v4l2_tuner *tuner = arg;
1013
1014 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
1015 return 0;
1016
1017 switch_v4l2();
1018
1019 /* do nothing unless we're a radio tuner */
1020 if (t->mode != V4L2_TUNER_RADIO)
1021 break;
1022 t->audmode = tuner->audmode;
1023 set_radio_freq(client, t->radio_freq);
1024 break;
1025 }
1026 case VIDIOC_LOG_STATUS:
1027 if (t->ops.tuner_status)
1028 t->ops.tuner_status(t);
1029 break;
1030 }
1031
1032 return 0;
1033 }
1034
1035 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
1036 {
1037 struct tuner *t = i2c_get_clientdata (c);
1038
1039 tuner_dbg ("suspend\n");
1040 /* FIXME: power down ??? */
1041 return 0;
1042 }
1043
1044 static int tuner_resume(struct i2c_client *c)
1045 {
1046 struct tuner *t = i2c_get_clientdata (c);
1047
1048 tuner_dbg ("resume\n");
1049 if (V4L2_TUNER_RADIO == t->mode) {
1050 if (t->radio_freq)
1051 set_freq(c, t->radio_freq);
1052 } else {
1053 if (t->tv_freq)
1054 set_freq(c, t->tv_freq);
1055 }
1056 return 0;
1057 }
1058
1059 /* ----------------------------------------------------------------------- */
1060
1061 static struct i2c_driver driver = {
1062 .id = I2C_DRIVERID_TUNER,
1063 .attach_adapter = tuner_probe,
1064 .detach_client = tuner_detach,
1065 .command = tuner_command,
1066 .suspend = tuner_suspend,
1067 .resume = tuner_resume,
1068 .driver = {
1069 .name = "tuner",
1070 },
1071 };
1072 static struct i2c_client client_template = {
1073 .name = "(tuner unset)",
1074 .driver = &driver,
1075 };
1076
1077 static int __init tuner_init_module(void)
1078 {
1079 return i2c_add_driver(&driver);
1080 }
1081
1082 static void __exit tuner_cleanup_module(void)
1083 {
1084 i2c_del_driver(&driver);
1085 }
1086
1087 module_init(tuner_init_module);
1088 module_exit(tuner_cleanup_module);
1089
1090 /*
1091 * Overrides for Emacs so that we follow Linus's tabbing style.
1092 * ---------------------------------------------------------------------------
1093 * Local variables:
1094 * c-basic-offset: 8
1095 * End:
1096 */
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree