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