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