?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (6715): ivtv: Remove unnecessary register update
[linux-2.6/verdex.git] / drivers / media / video / tuner-core.c
blobe56a41941489590cd1eb9bdc0daaa6eb39f0f78c
1 /*
2 *
3 * i2c tv tuner chip device driver
4 * core core, i.e. kernel interfaces, registering and so on
5 */
6
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/string.h>
10 #include <linux/timer.h>
11 #include <linux/delay.h>
12 #include <linux/errno.h>
13 #include <linux/slab.h>
14 #include <linux/poll.h>
15 #include <linux/i2c.h>
16 #include <linux/types.h>
17 #include <linux/init.h>
18 #include <linux/videodev.h>
19 #include <media/tuner.h>
20 #include <media/tuner-types.h>
21 #include <media/v4l2-common.h>
22 #include <media/v4l2-i2c-drv-legacy.h>
23 #include "tuner-driver.h"
24 #include "mt20xx.h"
25 #include "tda8290.h"
26 #include "tea5761.h"
27 #include "tea5767.h"
28 #include "tuner-xc2028.h"
29 #include "tuner-simple.h"
30 #include "tda9887.h"
31
32 #define UNSET (-1U)
33
34 #define PREFIX t->i2c->driver->driver.name
35
36 /* standard i2c insmod options */
37 static unsigned short normal_i2c[] = {
38 #if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
39 0x10,
40 #endif
41 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
42 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
43 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
44 I2C_CLIENT_END
45 };
46
47 I2C_CLIENT_INSMOD;
48
49 /* insmod options used at init time => read/only */
50 static unsigned int addr = 0;
51 static unsigned int no_autodetect = 0;
52 static unsigned int show_i2c = 0;
53
54 /* insmod options used at runtime => read/write */
55 int tuner_debug = 0;
56
57 static unsigned int tv_range[2] = { 44, 958 };
58 static unsigned int radio_range[2] = { 65, 108 };
59
60 static char pal[] = "--";
61 static char secam[] = "--";
62 static char ntsc[] = "-";
63
64
65 module_param(addr, int, 0444);
66 module_param(no_autodetect, int, 0444);
67 module_param(show_i2c, int, 0444);
68 module_param_named(debug,tuner_debug, int, 0644);
69 module_param_string(pal, pal, sizeof(pal), 0644);
70 module_param_string(secam, secam, sizeof(secam), 0644);
71 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
72 module_param_array(tv_range, int, NULL, 0644);
73 module_param_array(radio_range, int, NULL, 0644);
74
75 MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
76 MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
77 MODULE_LICENSE("GPL");
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 if (t->mode == T_UNINITIALIZED) {
283 tuner_dbg ("tuner 0x%02x: called during i2c_client register by adapter's attach_inform\n", c->addr);
284
285 return;
286 }
287
288 /* discard private data, in case set_type() was previously called */
289 if (ops && ops->release)
290 ops->release(&t->fe);
291
292 switch (t->type) {
293 case TUNER_MT2032:
294 microtune_attach(&t->fe, t->i2c->adapter, t->i2c->addr);
295 break;
296 case TUNER_PHILIPS_TDA8290:
297 {
298 tda829x_attach(t);
299 break;
300 }
301 case TUNER_TEA5767:
302 if (tea5767_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
303 t->type = TUNER_ABSENT;
304 t->mode_mask = T_UNINITIALIZED;
305 return;
306 }
307 t->mode_mask = T_RADIO;
308 break;
309 case TUNER_TEA5761:
310 if (tea5761_attach(&t->fe, t->i2c->adapter, t->i2c->addr) == NULL) {
311 t->type = TUNER_ABSENT;
312 t->mode_mask = T_UNINITIALIZED;
313 return;
314 }
315 t->mode_mask = T_RADIO;
316 break;
317 case TUNER_PHILIPS_FMD1216ME_MK3:
318 buffer[0] = 0x0b;
319 buffer[1] = 0xdc;
320 buffer[2] = 0x9c;
321 buffer[3] = 0x60;
322 i2c_master_send(c, buffer, 4);
323 mdelay(1);
324 buffer[2] = 0x86;
325 buffer[3] = 0x54;
326 i2c_master_send(c, buffer, 4);
327 attach_simple_tuner(t);
328 break;
329 case TUNER_PHILIPS_TD1316:
330 buffer[0] = 0x0b;
331 buffer[1] = 0xdc;
332 buffer[2] = 0x86;
333 buffer[3] = 0xa4;
334 i2c_master_send(c,buffer,4);
335 attach_simple_tuner(t);
336 break;
337 case TUNER_XC2028:
338 {
339 struct xc2028_config cfg = {
340 .i2c_adap = t->i2c->adapter,
341 .i2c_addr = t->i2c->addr,
342 .video_dev = c->adapter->algo_data,
343 .callback = t->tuner_callback,
344 };
345 if (!xc2028_attach(&t->fe, &cfg)) {
346 t->type = TUNER_ABSENT;
347 t->mode_mask = T_UNINITIALIZED;
348 return;
349 }
350 break;
351 }
352 case TUNER_TDA9887:
353 tda9887_attach(t);
354 break;
355 default:
356 attach_simple_tuner(t);
357 break;
358 }
359
360 ops = t->fe.ops.analog_demod_ops;
361
362 if (((NULL == ops) ||
363 ((NULL == ops->set_tv_freq) && (NULL == ops->set_radio_freq))) &&
364 (fe_tuner_ops->set_analog_params)) {
365 strlcpy(t->i2c->name, fe_tuner_ops->info.name,
366 sizeof(t->i2c->name));
367
368 t->fe.ops.analog_demod_ops = &tuner_core_ops;
369 t->fe.analog_demod_priv = t;
370 }
371
372 tuner_dbg("type set to %s\n", t->i2c->name);
373
374 if (t->mode_mask == T_UNINITIALIZED)
375 t->mode_mask = new_mode_mask;
376
377 set_freq(c, (V4L2_TUNER_RADIO == t->mode) ? t->radio_freq : t->tv_freq);
378 tuner_dbg("%s %s I2C addr 0x%02x with type %d used for 0x%02x\n",
379 c->adapter->name, c->driver->driver.name, c->addr << 1, type,
380 t->mode_mask);
381 tuner_i2c_address_check(t);
382 }
383
384 /*
385 * This function apply tuner config to tuner specified
386 * by tun_setup structure. I addr is unset, then admin status
387 * and tun addr status is more precise then current status,
388 * it's applied. Otherwise status and type are applied only to
389 * tuner with exactly the same addr.
390 */
391
392 static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
393 {
394 struct tuner *t = i2c_get_clientdata(c);
395
396 tuner_dbg("set addr for type %i\n", t->type);
397
398 if ( (t->type == UNSET && ((tun_setup->addr == ADDR_UNSET) &&
399 (t->mode_mask & tun_setup->mode_mask))) ||
400 (tun_setup->addr == c->addr)) {
401 set_type(c, tun_setup->type, tun_setup->mode_mask,
402 tun_setup->config, tun_setup->tuner_callback);
403 }
404 }
405
406 static inline int check_mode(struct tuner *t, char *cmd)
407 {
408 if ((1 << t->mode & t->mode_mask) == 0) {
409 return EINVAL;
410 }
411
412 switch (t->mode) {
413 case V4L2_TUNER_RADIO:
414 tuner_dbg("Cmd %s accepted for radio\n", cmd);
415 break;
416 case V4L2_TUNER_ANALOG_TV:
417 tuner_dbg("Cmd %s accepted for analog TV\n", cmd);
418 break;
419 case V4L2_TUNER_DIGITAL_TV:
420 tuner_dbg("Cmd %s accepted for digital TV\n", cmd);
421 break;
422 }
423 return 0;
424 }
425
426 /* get more precise norm info from insmod option */
427 static int tuner_fixup_std(struct tuner *t)
428 {
429 if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
430 switch (pal[0]) {
431 case '6':
432 tuner_dbg ("insmod fixup: PAL => PAL-60\n");
433 t->std = V4L2_STD_PAL_60;
434 break;
435 case 'b':
436 case 'B':
437 case 'g':
438 case 'G':
439 tuner_dbg ("insmod fixup: PAL => PAL-BG\n");
440 t->std = V4L2_STD_PAL_BG;
441 break;
442 case 'i':
443 case 'I':
444 tuner_dbg ("insmod fixup: PAL => PAL-I\n");
445 t->std = V4L2_STD_PAL_I;
446 break;
447 case 'd':
448 case 'D':
449 case 'k':
450 case 'K':
451 tuner_dbg ("insmod fixup: PAL => PAL-DK\n");
452 t->std = V4L2_STD_PAL_DK;
453 break;
454 case 'M':
455 case 'm':
456 tuner_dbg ("insmod fixup: PAL => PAL-M\n");
457 t->std = V4L2_STD_PAL_M;
458 break;
459 case 'N':
460 case 'n':
461 if (pal[1] == 'c' || pal[1] == 'C') {
462 tuner_dbg("insmod fixup: PAL => PAL-Nc\n");
463 t->std = V4L2_STD_PAL_Nc;
464 } else {
465 tuner_dbg ("insmod fixup: PAL => PAL-N\n");
466 t->std = V4L2_STD_PAL_N;
467 }
468 break;
469 case '-':
470 /* default parameter, do nothing */
471 break;
472 default:
473 tuner_warn ("pal= argument not recognised\n");
474 break;
475 }
476 }
477 if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
478 switch (secam[0]) {
479 case 'b':
480 case 'B':
481 case 'g':
482 case 'G':
483 case 'h':
484 case 'H':
485 tuner_dbg("insmod fixup: SECAM => SECAM-BGH\n");
486 t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
487 break;
488 case 'd':
489 case 'D':
490 case 'k':
491 case 'K':
492 tuner_dbg ("insmod fixup: SECAM => SECAM-DK\n");
493 t->std = V4L2_STD_SECAM_DK;
494 break;
495 case 'l':
496 case 'L':
497 if ((secam[1]=='C')||(secam[1]=='c')) {
498 tuner_dbg ("insmod fixup: SECAM => SECAM-L'\n");
499 t->std = V4L2_STD_SECAM_LC;
500 } else {
501 tuner_dbg ("insmod fixup: SECAM => SECAM-L\n");
502 t->std = V4L2_STD_SECAM_L;
503 }
504 break;
505 case '-':
506 /* default parameter, do nothing */
507 break;
508 default:
509 tuner_warn ("secam= argument not recognised\n");
510 break;
511 }
512 }
513
514 if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
515 switch (ntsc[0]) {
516 case 'm':
517 case 'M':
518 tuner_dbg("insmod fixup: NTSC => NTSC-M\n");
519 t->std = V4L2_STD_NTSC_M;
520 break;
521 case 'j':
522 case 'J':
523 tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
524 t->std = V4L2_STD_NTSC_M_JP;
525 break;
526 case 'k':
527 case 'K':
528 tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
529 t->std = V4L2_STD_NTSC_M_KR;
530 break;
531 case '-':
532 /* default parameter, do nothing */
533 break;
534 default:
535 tuner_info("ntsc= argument not recognised\n");
536 break;
537 }
538 }
539 return 0;
540 }
541
542 static void tuner_status(struct dvb_frontend *fe)
543 {
544 struct tuner *t = fe->analog_demod_priv;
545 unsigned long freq, freq_fraction;
546 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
547 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
548 const char *p;
549
550 switch (t->mode) {
551 case V4L2_TUNER_RADIO: p = "radio"; break;
552 case V4L2_TUNER_ANALOG_TV: p = "analog TV"; break;
553 case V4L2_TUNER_DIGITAL_TV: p = "digital TV"; break;
554 default: p = "undefined"; break;
555 }
556 if (t->mode == V4L2_TUNER_RADIO) {
557 freq = t->radio_freq / 16000;
558 freq_fraction = (t->radio_freq % 16000) * 100 / 16000;
559 } else {
560 freq = t->tv_freq / 16;
561 freq_fraction = (t->tv_freq % 16) * 100 / 16;
562 }
563 tuner_info("Tuner mode: %s\n", p);
564 tuner_info("Frequency: %lu.%02lu MHz\n", freq, freq_fraction);
565 tuner_info("Standard: 0x%08lx\n", (unsigned long)t->std);
566 if (t->mode != V4L2_TUNER_RADIO)
567 return;
568 if (fe_tuner_ops->get_status) {
569 u32 tuner_status;
570
571 fe_tuner_ops->get_status(&t->fe, &tuner_status);
572 if (tuner_status & TUNER_STATUS_LOCKED)
573 tuner_info("Tuner is locked.\n");
574 if (tuner_status & TUNER_STATUS_STEREO)
575 tuner_info("Stereo: yes\n");
576 }
577 if (ops) {
578 if (ops->has_signal)
579 tuner_info("Signal strength: %d\n",
580 ops->has_signal(fe));
581 if (ops->is_stereo)
582 tuner_info("Stereo: %s\n",
583 ops->is_stereo(fe) ? "yes" : "no");
584 }
585 }
586
587 /* ---------------------------------------------------------------------- */
588
589 /*
590 * Switch tuner to other mode. If tuner support both tv and radio,
591 * set another frequency to some value (This is needed for some pal
592 * tuners to avoid locking). Otherwise, just put second tuner in
593 * standby mode.
594 */
595
596 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
597 {
598 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
599
600 if (mode == t->mode)
601 return 0;
602
603 t->mode = mode;
604
605 if (check_mode(t, cmd) == EINVAL) {
606 t->mode = T_STANDBY;
607 if (ops && ops->standby)
608 ops->standby(&t->fe);
609 return EINVAL;
610 }
611 return 0;
612 }
613
614 #define switch_v4l2() if (!t->using_v4l2) \
615 tuner_dbg("switching to v4l2\n"); \
616 t->using_v4l2 = 1;
617
618 static inline int check_v4l2(struct tuner *t)
619 {
620 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
621 TV, v4l1 for radio), until that is fixed this code is disabled.
622 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
623 first. */
624 return 0;
625 }
626
627 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
628 {
629 struct tuner *t = i2c_get_clientdata(client);
630 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
631 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
632
633 if (tuner_debug>1)
634 v4l_i2c_print_ioctl(client,cmd);
635
636 switch (cmd) {
637 /* --- configuration --- */
638 case TUNER_SET_TYPE_ADDR:
639 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
640 ((struct tuner_setup *)arg)->type,
641 ((struct tuner_setup *)arg)->addr,
642 ((struct tuner_setup *)arg)->mode_mask,
643 ((struct tuner_setup *)arg)->config);
644
645 set_addr(client, (struct tuner_setup *)arg);
646 break;
647 case AUDC_SET_RADIO:
648 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
649 == EINVAL)
650 return 0;
651 if (t->radio_freq)
652 set_freq(client, t->radio_freq);
653 break;
654 case TUNER_SET_STANDBY:
655 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
656 return 0;
657 t->mode = T_STANDBY;
658 if (ops && ops->standby)
659 ops->standby(&t->fe);
660 break;
661 #ifdef CONFIG_VIDEO_V4L1
662 case VIDIOCSAUDIO:
663 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
664 return 0;
665 if (check_v4l2(t) == EINVAL)
666 return 0;
667
668 /* Should be implemented, since bttv calls it */
669 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
670 break;
671 case VIDIOCSCHAN:
672 {
673 static const v4l2_std_id map[] = {
674 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
675 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
676 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
677 [4 /* bttv */ ] = V4L2_STD_PAL_M,
678 [5 /* bttv */ ] = V4L2_STD_PAL_N,
679 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
680 };
681 struct video_channel *vc = arg;
682
683 if (check_v4l2(t) == EINVAL)
684 return 0;
685
686 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
687 return 0;
688
689 if (vc->norm < ARRAY_SIZE(map))
690 t->std = map[vc->norm];
691 tuner_fixup_std(t);
692 if (t->tv_freq)
693 set_tv_freq(client, t->tv_freq);
694 return 0;
695 }
696 case VIDIOCSFREQ:
697 {
698 unsigned long *v = arg;
699
700 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
701 return 0;
702 if (check_v4l2(t) == EINVAL)
703 return 0;
704
705 set_freq(client, *v);
706 return 0;
707 }
708 case VIDIOCGTUNER:
709 {
710 struct video_tuner *vt = arg;
711
712 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
713 return 0;
714 if (check_v4l2(t) == EINVAL)
715 return 0;
716
717 if (V4L2_TUNER_RADIO == t->mode) {
718 if (fe_tuner_ops->get_status) {
719 u32 tuner_status;
720
721 fe_tuner_ops->get_status(&t->fe, &tuner_status);
722 if (tuner_status & TUNER_STATUS_STEREO)
723 vt->flags |= VIDEO_TUNER_STEREO_ON;
724 else
725 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
726 } else {
727 if (ops && ops->is_stereo) {
728 if (ops->is_stereo(&t->fe))
729 vt->flags |=
730 VIDEO_TUNER_STEREO_ON;
731 else
732 vt->flags &=
733 ~VIDEO_TUNER_STEREO_ON;
734 }
735 }
736 if (ops && ops->has_signal)
737 vt->signal = ops->has_signal(&t->fe);
738
739 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
740
741 vt->rangelow = radio_range[0] * 16000;
742 vt->rangehigh = radio_range[1] * 16000;
743
744 } else {
745 vt->rangelow = tv_range[0] * 16;
746 vt->rangehigh = tv_range[1] * 16;
747 }
748
749 return 0;
750 }
751 case VIDIOCGAUDIO:
752 {
753 struct video_audio *va = arg;
754
755 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
756 return 0;
757 if (check_v4l2(t) == EINVAL)
758 return 0;
759
760 if (V4L2_TUNER_RADIO == t->mode) {
761 if (fe_tuner_ops->get_status) {
762 u32 tuner_status;
763
764 fe_tuner_ops->get_status(&t->fe, &tuner_status);
765 va->mode = (tuner_status & TUNER_STATUS_STEREO)
766 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
767 } else if (ops && ops->is_stereo)
768 va->mode = ops->is_stereo(&t->fe)
769 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
770 }
771 return 0;
772 }
773 #endif
774 case TUNER_SET_CONFIG:
775 {
776 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
777 struct v4l2_priv_tun_config *cfg = arg;
778
779 if (t->type != cfg->tuner)
780 break;
781
782 if (t->type == TUNER_TDA9887) {
783 t->tda9887_config = *(unsigned int *)cfg->priv;
784 set_freq(client, t->tv_freq);
785 break;
786 }
787
788 if (NULL == fe_tuner_ops->set_config) {
789 tuner_warn("Tuner frontend module has no way to "
790 "set config\n");
791 break;
792 }
793 fe_tuner_ops->set_config(&t->fe, cfg->priv);
794
795 break;
796 }
797 /* --- v4l ioctls --- */
798 /* take care: bttv does userspace copying, we'll get a
799 kernel pointer here... */
800 case VIDIOC_S_STD:
801 {
802 v4l2_std_id *id = arg;
803
804 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
805 == EINVAL)
806 return 0;
807
808 switch_v4l2();
809
810 t->std = *id;
811 tuner_fixup_std(t);
812 if (t->tv_freq)
813 set_freq(client, t->tv_freq);
814 break;
815 }
816 case VIDIOC_S_FREQUENCY:
817 {
818 struct v4l2_frequency *f = arg;
819
820 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
821 == EINVAL)
822 return 0;
823 switch_v4l2();
824 set_freq(client,f->frequency);
825
826 break;
827 }
828 case VIDIOC_G_FREQUENCY:
829 {
830 struct v4l2_frequency *f = arg;
831
832 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
833 return 0;
834 switch_v4l2();
835 f->type = t->mode;
836 if (fe_tuner_ops->get_frequency) {
837 u32 abs_freq;
838
839 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
840 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
841 (abs_freq * 2 + 125/2) / 125 :
842 (abs_freq + 62500/2) / 62500;
843 break;
844 }
845 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
846 t->radio_freq : t->tv_freq;
847 break;
848 }
849 case VIDIOC_G_TUNER:
850 {
851 struct v4l2_tuner *tuner = arg;
852
853 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
854 return 0;
855 switch_v4l2();
856
857 tuner->type = t->mode;
858 if (ops && ops->get_afc)
859 tuner->afc = ops->get_afc(&t->fe);
860 if (t->mode == V4L2_TUNER_ANALOG_TV)
861 tuner->capability |= V4L2_TUNER_CAP_NORM;
862 if (t->mode != V4L2_TUNER_RADIO) {
863 tuner->rangelow = tv_range[0] * 16;
864 tuner->rangehigh = tv_range[1] * 16;
865 break;
866 }
867
868 /* radio mode */
869 tuner->rxsubchans =
870 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
871 if (fe_tuner_ops->get_status) {
872 u32 tuner_status;
873
874 fe_tuner_ops->get_status(&t->fe, &tuner_status);
875 tuner->rxsubchans =
876 (tuner_status & TUNER_STATUS_STEREO) ?
877 V4L2_TUNER_SUB_STEREO :
878 V4L2_TUNER_SUB_MONO;
879 } else {
880 if (ops && ops->is_stereo) {
881 tuner->rxsubchans =
882 ops->is_stereo(&t->fe) ?
883 V4L2_TUNER_SUB_STEREO :
884 V4L2_TUNER_SUB_MONO;
885 }
886 }
887 if (ops && ops->has_signal)
888 tuner->signal = ops->has_signal(&t->fe);
889 tuner->capability |=
890 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
891 tuner->audmode = t->audmode;
892 tuner->rangelow = radio_range[0] * 16000;
893 tuner->rangehigh = radio_range[1] * 16000;
894 break;
895 }
896 case VIDIOC_S_TUNER:
897 {
898 struct v4l2_tuner *tuner = arg;
899
900 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
901 return 0;
902
903 switch_v4l2();
904
905 /* do nothing unless we're a radio tuner */
906 if (t->mode != V4L2_TUNER_RADIO)
907 break;
908 t->audmode = tuner->audmode;
909 set_radio_freq(client, t->radio_freq);
910 break;
911 }
912 case VIDIOC_LOG_STATUS:
913 if (ops && ops->tuner_status)
914 ops->tuner_status(&t->fe);
915 break;
916 }
917
918 return 0;
919 }
920
921 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
922 {
923 struct tuner *t = i2c_get_clientdata(c);
924
925 tuner_dbg("suspend\n");
926 /* FIXME: power down ??? */
927 return 0;
928 }
929
930 static int tuner_resume(struct i2c_client *c)
931 {
932 struct tuner *t = i2c_get_clientdata(c);
933
934 tuner_dbg("resume\n");
935 if (V4L2_TUNER_RADIO == t->mode) {
936 if (t->radio_freq)
937 set_freq(c, t->radio_freq);
938 } else {
939 if (t->tv_freq)
940 set_freq(c, t->tv_freq);
941 }
942 return 0;
943 }
944
945 /* ---------------------------------------------------------------------- */
946
947 LIST_HEAD(tuner_list);
948
949 /* Search for existing radio and/or TV tuners on the given I2C adapter.
950 Note that when this function is called from tuner_probe you can be
951 certain no other devices will be added/deleted at the same time, I2C
952 core protects against that. */
953 static void tuner_lookup(struct i2c_adapter *adap,
954 struct tuner **radio, struct tuner **tv)
955 {
956 struct tuner *pos;
957
958 *radio = NULL;
959 *tv = NULL;
960
961 list_for_each_entry(pos, &tuner_list, list) {
962 int mode_mask;
963
964 if (pos->i2c->adapter != adap ||
965 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
966 continue;
967
968 mode_mask = pos->mode_mask & ~T_STANDBY;
969 if (*radio == NULL && mode_mask == T_RADIO)
970 *radio = pos;
971 /* Note: currently TDA9887 is the only demod-only
972 device. If other devices appear then we need to
973 make this test more general. */
974 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
975 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
976 *tv = pos;
977 }
978 }
979
980 /* During client attach, set_type is called by adapter's attach_inform callback.
981 set_type must then be completed by tuner_probe.
982 */
983 static int tuner_probe(struct i2c_client *client)
984 {
985 struct tuner *t;
986 struct tuner *radio;
987 struct tuner *tv;
988
989 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
990 if (NULL == t)
991 return -ENOMEM;
992 t->i2c = client;
993 strlcpy(client->name, "(tuner unset)", sizeof(client->name));
994 i2c_set_clientdata(client, t);
995 t->type = UNSET;
996 t->audmode = V4L2_TUNER_MODE_STEREO;
997 t->mode_mask = T_UNINITIALIZED;
998
999 if (show_i2c) {
1000 unsigned char buffer[16];
1001 int i, rc;
1002
1003 memset(buffer, 0, sizeof(buffer));
1004 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1005 tuner_info("I2C RECV = ");
1006 for (i = 0; i < rc; i++)
1007 printk(KERN_CONT "%02x ", buffer[i]);
1008 printk("\n");
1009 }
1010 /* HACK: This test was added to avoid tuner to probe tda9840 and
1011 tea6415c on the MXB card */
1012 if (client->adapter->id == I2C_HW_SAA7146 && client->addr < 0x4a) {
1013 kfree(t);
1014 return -ENODEV;
1015 }
1016
1017 /* autodetection code based on the i2c addr */
1018 if (!no_autodetect) {
1019 switch (client->addr) {
1020 case 0x10:
1021 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1022 != EINVAL) {
1023 t->type = TUNER_TEA5761;
1024 t->mode_mask = T_RADIO;
1025 t->mode = T_STANDBY;
1026 /* Sets freq to FM range */
1027 t->radio_freq = 87.5 * 16000;
1028 tuner_lookup(t->i2c->adapter, &radio, &tv);
1029 if (tv)
1030 tv->mode_mask &= ~T_RADIO;
1031
1032 goto register_client;
1033 }
1034 break;
1035 case 0x42:
1036 case 0x43:
1037 case 0x4a:
1038 case 0x4b:
1039 /* If chip is not tda8290, don't register.
1040 since it can be tda9887*/
1041 if (tda829x_probe(t) == 0) {
1042 tuner_dbg("tda829x detected\n");
1043 } else {
1044 /* Default is being tda9887 */
1045 t->type = TUNER_TDA9887;
1046 t->mode_mask = T_RADIO | T_ANALOG_TV |
1047 T_DIGITAL_TV;
1048 t->mode = T_STANDBY;
1049 goto register_client;
1050 }
1051 break;
1052 case 0x60:
1053 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1054 != EINVAL) {
1055 t->type = TUNER_TEA5767;
1056 t->mode_mask = T_RADIO;
1057 t->mode = T_STANDBY;
1058 /* Sets freq to FM range */
1059 t->radio_freq = 87.5 * 16000;
1060 tuner_lookup(t->i2c->adapter, &radio, &tv);
1061 if (tv)
1062 tv->mode_mask &= ~T_RADIO;
1063
1064 goto register_client;
1065 }
1066 break;
1067 }
1068 }
1069
1070 /* Initializes only the first TV tuner on this adapter. Why only the
1071 first? Because there are some devices (notably the ones with TI
1072 tuners) that have more than one i2c address for the *same* device.
1073 Experience shows that, except for just one case, the first
1074 address is the right one. The exception is a Russian tuner
1075 (ACORP_Y878F). So, the desired behavior is just to enable the
1076 first found TV tuner. */
1077 tuner_lookup(t->i2c->adapter, &radio, &tv);
1078 if (tv == NULL) {
1079 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1080 if (radio == NULL)
1081 t->mode_mask |= T_RADIO;
1082 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1083 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1084 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1085 }
1086
1087 /* Should be just before return */
1088 register_client:
1089 tuner_info("chip found @ 0x%x (%s)\n", client->addr << 1,
1090 client->adapter->name);
1091
1092 /* Sets a default mode */
1093 if (t->mode_mask & T_ANALOG_TV) {
1094 t->mode = T_ANALOG_TV;
1095 } else if (t->mode_mask & T_RADIO) {
1096 t->mode = T_RADIO;
1097 } else {
1098 t->mode = T_DIGITAL_TV;
1099 }
1100 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1101 list_add_tail(&t->list, &tuner_list);
1102 return 0;
1103 }
1104
1105 static int tuner_legacy_probe(struct i2c_adapter *adap)
1106 {
1107 if (0 != addr) {
1108 normal_i2c[0] = addr;
1109 normal_i2c[1] = I2C_CLIENT_END;
1110 }
1111
1112 if ((adap->class & I2C_CLASS_TV_ANALOG) == 0)
1113 return 0;
1114
1115 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1116 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1117 * and an RTC at 0x6f which can get corrupted if probed.
1118 */
1119 if ((adap->id == I2C_HW_B_CX2388x) ||
1120 (adap->id == I2C_HW_B_CX23885)) {
1121 unsigned int i = 0;
1122
1123 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1124 i += 2;
1125 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1126 ignore[i+0] = adap->nr;
1127 ignore[i+1] = 0x6b;
1128 ignore[i+2] = adap->nr;
1129 ignore[i+3] = 0x6f;
1130 ignore[i+4] = I2C_CLIENT_END;
1131 } else
1132 printk(KERN_WARNING "tuner: "
1133 "too many options specified "
1134 "in i2c probe ignore list!\n");
1135 }
1136 return 1;
1137 }
1138
1139 static int tuner_remove(struct i2c_client *client)
1140 {
1141 struct tuner *t = i2c_get_clientdata(client);
1142 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1143
1144 if (ops && ops->release)
1145 ops->release(&t->fe);
1146
1147 list_del(&t->list);
1148 kfree(t);
1149 return 0;
1150 }
1151
1152 /* ----------------------------------------------------------------------- */
1153
1154 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1155 .name = "tuner",
1156 .driverid = I2C_DRIVERID_TUNER,
1157 .command = tuner_command,
1158 .probe = tuner_probe,
1159 .remove = tuner_remove,
1160 .suspend = tuner_suspend,
1161 .resume = tuner_resume,
1162 .legacy_probe = tuner_legacy_probe,
1163 };
1164
1165
1166 /*
1167 * Overrides for Emacs so that we follow Linus's tabbing style.
1168 * ---------------------------------------------------------------------------
1169 * Local variables:
1170 * c-basic-offset: 8
1171 * End:
1172 */
Verdex Pro support