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