]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/video/tuner-core.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
V4L/DVB (6555): tuner: reorder functions to prepare for i2c conversion
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / tuner-core.c
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 /*
589 * Switch tuner to other mode. If tuner support both tv and radio,
590 * set another frequency to some value (This is needed for some pal
591 * tuners to avoid locking). Otherwise, just put second tuner in
592 * standby mode.
593 */
594
595 static inline int set_mode(struct i2c_client *client, struct tuner *t, int mode, char *cmd)
596 {
597 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
598
599 if (mode == t->mode)
600 return 0;
601
602 t->mode = mode;
603
604 if (check_mode(t, cmd) == EINVAL) {
605 t->mode = T_STANDBY;
606 if (ops && ops->standby)
607 ops->standby(&t->fe);
608 return EINVAL;
609 }
610 return 0;
611 }
612
613 #define switch_v4l2() if (!t->using_v4l2) \
614 tuner_dbg("switching to v4l2\n"); \
615 t->using_v4l2 = 1;
616
617 static inline int check_v4l2(struct tuner *t)
618 {
619 /* bttv still uses both v4l1 and v4l2 calls to the tuner (v4l2 for
620 TV, v4l1 for radio), until that is fixed this code is disabled.
621 Otherwise the radio (v4l1) wouldn't tune after using the TV (v4l2)
622 first. */
623 return 0;
624 }
625
626 static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
627 {
628 struct tuner *t = i2c_get_clientdata(client);
629 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
630 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
631
632 if (tuner_debug>1)
633 v4l_i2c_print_ioctl(client,cmd);
634
635 switch (cmd) {
636 /* --- configuration --- */
637 case TUNER_SET_TYPE_ADDR:
638 tuner_dbg ("Calling set_type_addr for type=%d, addr=0x%02x, mode=0x%02x, config=0x%02x\n",
639 ((struct tuner_setup *)arg)->type,
640 ((struct tuner_setup *)arg)->addr,
641 ((struct tuner_setup *)arg)->mode_mask,
642 ((struct tuner_setup *)arg)->config);
643
644 set_addr(client, (struct tuner_setup *)arg);
645 break;
646 case AUDC_SET_RADIO:
647 if (set_mode(client, t, V4L2_TUNER_RADIO, "AUDC_SET_RADIO")
648 == EINVAL)
649 return 0;
650 if (t->radio_freq)
651 set_freq(client, t->radio_freq);
652 break;
653 case TUNER_SET_STANDBY:
654 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
655 return 0;
656 t->mode = T_STANDBY;
657 if (ops && ops->standby)
658 ops->standby(&t->fe);
659 break;
660 #ifdef CONFIG_VIDEO_V4L1
661 case VIDIOCSAUDIO:
662 if (check_mode(t, "VIDIOCSAUDIO") == EINVAL)
663 return 0;
664 if (check_v4l2(t) == EINVAL)
665 return 0;
666
667 /* Should be implemented, since bttv calls it */
668 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
669 break;
670 case VIDIOCSCHAN:
671 {
672 static const v4l2_std_id map[] = {
673 [VIDEO_MODE_PAL] = V4L2_STD_PAL,
674 [VIDEO_MODE_NTSC] = V4L2_STD_NTSC_M,
675 [VIDEO_MODE_SECAM] = V4L2_STD_SECAM,
676 [4 /* bttv */ ] = V4L2_STD_PAL_M,
677 [5 /* bttv */ ] = V4L2_STD_PAL_N,
678 [6 /* bttv */ ] = V4L2_STD_NTSC_M_JP,
679 };
680 struct video_channel *vc = arg;
681
682 if (check_v4l2(t) == EINVAL)
683 return 0;
684
685 if (set_mode(client,t,V4L2_TUNER_ANALOG_TV, "VIDIOCSCHAN")==EINVAL)
686 return 0;
687
688 if (vc->norm < ARRAY_SIZE(map))
689 t->std = map[vc->norm];
690 tuner_fixup_std(t);
691 if (t->tv_freq)
692 set_tv_freq(client, t->tv_freq);
693 return 0;
694 }
695 case VIDIOCSFREQ:
696 {
697 unsigned long *v = arg;
698
699 if (check_mode(t, "VIDIOCSFREQ") == EINVAL)
700 return 0;
701 if (check_v4l2(t) == EINVAL)
702 return 0;
703
704 set_freq(client, *v);
705 return 0;
706 }
707 case VIDIOCGTUNER:
708 {
709 struct video_tuner *vt = arg;
710
711 if (check_mode(t, "VIDIOCGTUNER") == EINVAL)
712 return 0;
713 if (check_v4l2(t) == EINVAL)
714 return 0;
715
716 if (V4L2_TUNER_RADIO == t->mode) {
717 if (fe_tuner_ops->get_status) {
718 u32 tuner_status;
719
720 fe_tuner_ops->get_status(&t->fe, &tuner_status);
721 if (tuner_status & TUNER_STATUS_STEREO)
722 vt->flags |= VIDEO_TUNER_STEREO_ON;
723 else
724 vt->flags &= ~VIDEO_TUNER_STEREO_ON;
725 } else {
726 if (ops && ops->is_stereo) {
727 if (ops->is_stereo(&t->fe))
728 vt->flags |=
729 VIDEO_TUNER_STEREO_ON;
730 else
731 vt->flags &=
732 ~VIDEO_TUNER_STEREO_ON;
733 }
734 }
735 if (ops && ops->has_signal)
736 vt->signal = ops->has_signal(&t->fe);
737
738 vt->flags |= VIDEO_TUNER_LOW; /* Allow freqs at 62.5 Hz */
739
740 vt->rangelow = radio_range[0] * 16000;
741 vt->rangehigh = radio_range[1] * 16000;
742
743 } else {
744 vt->rangelow = tv_range[0] * 16;
745 vt->rangehigh = tv_range[1] * 16;
746 }
747
748 return 0;
749 }
750 case VIDIOCGAUDIO:
751 {
752 struct video_audio *va = arg;
753
754 if (check_mode(t, "VIDIOCGAUDIO") == EINVAL)
755 return 0;
756 if (check_v4l2(t) == EINVAL)
757 return 0;
758
759 if (V4L2_TUNER_RADIO == t->mode) {
760 if (fe_tuner_ops->get_status) {
761 u32 tuner_status;
762
763 fe_tuner_ops->get_status(&t->fe, &tuner_status);
764 va->mode = (tuner_status & TUNER_STATUS_STEREO)
765 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
766 } else if (ops && ops->is_stereo)
767 va->mode = ops->is_stereo(&t->fe)
768 ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO;
769 }
770 return 0;
771 }
772 #endif
773 case TUNER_SET_CONFIG:
774 {
775 struct dvb_tuner_ops *fe_tuner_ops = &t->fe.ops.tuner_ops;
776 struct v4l2_priv_tun_config *cfg = arg;
777
778 if (t->type != cfg->tuner)
779 break;
780
781 if (t->type == TUNER_TDA9887) {
782 t->tda9887_config = *(unsigned int *)cfg->priv;
783 set_freq(client, t->tv_freq);
784 break;
785 }
786
787 if (NULL == fe_tuner_ops->set_config) {
788 tuner_warn("Tuner frontend module has no way to "
789 "set config\n");
790 break;
791 }
792 fe_tuner_ops->set_config(&t->fe, cfg->priv);
793
794 break;
795 }
796 /* --- v4l ioctls --- */
797 /* take care: bttv does userspace copying, we'll get a
798 kernel pointer here... */
799 case VIDIOC_S_STD:
800 {
801 v4l2_std_id *id = arg;
802
803 if (set_mode (client, t, V4L2_TUNER_ANALOG_TV, "VIDIOC_S_STD")
804 == EINVAL)
805 return 0;
806
807 switch_v4l2();
808
809 t->std = *id;
810 tuner_fixup_std(t);
811 if (t->tv_freq)
812 set_freq(client, t->tv_freq);
813 break;
814 }
815 case VIDIOC_S_FREQUENCY:
816 {
817 struct v4l2_frequency *f = arg;
818
819 if (set_mode (client, t, f->type, "VIDIOC_S_FREQUENCY")
820 == EINVAL)
821 return 0;
822 switch_v4l2();
823 set_freq(client,f->frequency);
824
825 break;
826 }
827 case VIDIOC_G_FREQUENCY:
828 {
829 struct v4l2_frequency *f = arg;
830
831 if (check_mode(t, "VIDIOC_G_FREQUENCY") == EINVAL)
832 return 0;
833 switch_v4l2();
834 f->type = t->mode;
835 if (fe_tuner_ops->get_frequency) {
836 u32 abs_freq;
837
838 fe_tuner_ops->get_frequency(&t->fe, &abs_freq);
839 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
840 (abs_freq * 2 + 125/2) / 125 :
841 (abs_freq + 62500/2) / 62500;
842 break;
843 }
844 f->frequency = (V4L2_TUNER_RADIO == t->mode) ?
845 t->radio_freq : t->tv_freq;
846 break;
847 }
848 case VIDIOC_G_TUNER:
849 {
850 struct v4l2_tuner *tuner = arg;
851
852 if (check_mode(t, "VIDIOC_G_TUNER") == EINVAL)
853 return 0;
854 switch_v4l2();
855
856 tuner->type = t->mode;
857 if (ops && ops->get_afc)
858 tuner->afc = ops->get_afc(&t->fe);
859 if (t->mode == V4L2_TUNER_ANALOG_TV)
860 tuner->capability |= V4L2_TUNER_CAP_NORM;
861 if (t->mode != V4L2_TUNER_RADIO) {
862 tuner->rangelow = tv_range[0] * 16;
863 tuner->rangehigh = tv_range[1] * 16;
864 break;
865 }
866
867 /* radio mode */
868 tuner->rxsubchans =
869 V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
870 if (fe_tuner_ops->get_status) {
871 u32 tuner_status;
872
873 fe_tuner_ops->get_status(&t->fe, &tuner_status);
874 tuner->rxsubchans =
875 (tuner_status & TUNER_STATUS_STEREO) ?
876 V4L2_TUNER_SUB_STEREO :
877 V4L2_TUNER_SUB_MONO;
878 } else {
879 if (ops && ops->is_stereo) {
880 tuner->rxsubchans =
881 ops->is_stereo(&t->fe) ?
882 V4L2_TUNER_SUB_STEREO :
883 V4L2_TUNER_SUB_MONO;
884 }
885 }
886 if (ops && ops->has_signal)
887 tuner->signal = ops->has_signal(&t->fe);
888 tuner->capability |=
889 V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
890 tuner->audmode = t->audmode;
891 tuner->rangelow = radio_range[0] * 16000;
892 tuner->rangehigh = radio_range[1] * 16000;
893 break;
894 }
895 case VIDIOC_S_TUNER:
896 {
897 struct v4l2_tuner *tuner = arg;
898
899 if (check_mode(t, "VIDIOC_S_TUNER") == EINVAL)
900 return 0;
901
902 switch_v4l2();
903
904 /* do nothing unless we're a radio tuner */
905 if (t->mode != V4L2_TUNER_RADIO)
906 break;
907 t->audmode = tuner->audmode;
908 set_radio_freq(client, t->radio_freq);
909 break;
910 }
911 case VIDIOC_LOG_STATUS:
912 if (ops && ops->tuner_status)
913 ops->tuner_status(&t->fe);
914 break;
915 }
916
917 return 0;
918 }
919
920 static int tuner_suspend(struct i2c_client *c, pm_message_t state)
921 {
922 struct tuner *t = i2c_get_clientdata (c);
923
924 tuner_dbg ("suspend\n");
925 /* FIXME: power down ??? */
926 return 0;
927 }
928
929 static int tuner_resume(struct i2c_client *c)
930 {
931 struct tuner *t = i2c_get_clientdata (c);
932
933 tuner_dbg ("resume\n");
934 if (V4L2_TUNER_RADIO == t->mode) {
935 if (t->radio_freq)
936 set_freq(c, t->radio_freq);
937 } else {
938 if (t->tv_freq)
939 set_freq(c, t->tv_freq);
940 }
941 return 0;
942 }
943
944 /* ---------------------------------------------------------------------- */
945
946 LIST_HEAD(tuner_list);
947
948 /* Search for existing radio and/or TV tuners on the given I2C adapter.
949 Note that when this function is called from tuner_attach you can be
950 certain no other devices will be added/deleted at the same time, I2C
951 core protects against that. */
952 static void tuner_lookup(struct i2c_adapter *adap,
953 struct tuner **radio, struct tuner **tv)
954 {
955 struct tuner *pos;
956
957 *radio = NULL;
958 *tv = NULL;
959
960 list_for_each_entry(pos, &tuner_list, list) {
961 int mode_mask;
962
963 if (pos->i2c->adapter != adap ||
964 pos->i2c->driver->id != I2C_DRIVERID_TUNER)
965 continue;
966
967 mode_mask = pos->mode_mask & ~T_STANDBY;
968 if (*radio == NULL && mode_mask == T_RADIO)
969 *radio = pos;
970 /* Note: currently TDA9887 is the only demod-only
971 device. If other devices appear then we need to
972 make this test more general. */
973 else if (*tv == NULL && pos->type != TUNER_TDA9887 &&
974 (pos->mode_mask & (T_ANALOG_TV | T_DIGITAL_TV)))
975 *tv = pos;
976 }
977 }
978
979 /* During client attach, set_type is called by adapter's attach_inform callback.
980 set_type must then be completed by tuner_attach.
981 */
982 static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
983 {
984 struct i2c_client *client;
985 struct tuner *t;
986 struct tuner *radio;
987 struct tuner *tv;
988
989 client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
990 if (NULL == client)
991 return -ENOMEM;
992
993 t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
994 if (NULL == t) {
995 kfree(client);
996 return -ENOMEM;
997 }
998 t->i2c = client;
999 client_template.adapter = adap;
1000 client_template.addr = addr;
1001 memcpy(client, &client_template, sizeof(struct i2c_client));
1002 i2c_set_clientdata(client, t);
1003 t->type = UNSET;
1004 t->audmode = V4L2_TUNER_MODE_STEREO;
1005 t->mode_mask = T_UNINITIALIZED;
1006
1007 if (show_i2c) {
1008 unsigned char buffer[16];
1009 int i, rc;
1010
1011 memset(buffer, 0, sizeof(buffer));
1012 rc = i2c_master_recv(client, buffer, sizeof(buffer));
1013 tuner_info("I2C RECV = ");
1014 for (i = 0; i < rc; i++)
1015 printk(KERN_CONT "%02x ", buffer[i]);
1016 printk("\n");
1017 }
1018 /* HACK: This test were added to avoid tuner to probe tda9840 and
1019 tea6415c on the MXB card */
1020 if (adap->id == I2C_HW_SAA7146 && addr < 0x4a)
1021 return -ENODEV;
1022
1023 /* autodetection code based on the i2c addr */
1024 if (!no_autodetect) {
1025 switch (addr) {
1026 case 0x10:
1027 if (tea5761_autodetection(t->i2c->adapter, t->i2c->addr)
1028 != EINVAL) {
1029 t->type = TUNER_TEA5761;
1030 t->mode_mask = T_RADIO;
1031 t->mode = T_STANDBY;
1032 /* Sets freq to FM range */
1033 t->radio_freq = 87.5 * 16000;
1034 tuner_lookup(t->i2c->adapter, &radio, &tv);
1035 if (tv)
1036 tv->mode_mask &= ~T_RADIO;
1037
1038 goto register_client;
1039 }
1040 break;
1041 case 0x42:
1042 case 0x43:
1043 case 0x4a:
1044 case 0x4b:
1045 /* If chip is not tda8290, don't register.
1046 since it can be tda9887*/
1047 if (tda829x_probe(t) == 0) {
1048 tuner_dbg("tda829x detected\n");
1049 } else {
1050 /* Default is being tda9887 */
1051 t->type = TUNER_TDA9887;
1052 t->mode_mask = T_RADIO | T_ANALOG_TV |
1053 T_DIGITAL_TV;
1054 t->mode = T_STANDBY;
1055 goto register_client;
1056 }
1057 break;
1058 case 0x60:
1059 if (tea5767_autodetection(t->i2c->adapter, t->i2c->addr)
1060 != EINVAL) {
1061 t->type = TUNER_TEA5767;
1062 t->mode_mask = T_RADIO;
1063 t->mode = T_STANDBY;
1064 /* Sets freq to FM range */
1065 t->radio_freq = 87.5 * 16000;
1066 tuner_lookup(t->i2c->adapter, &radio, &tv);
1067 if (tv)
1068 tv->mode_mask &= ~T_RADIO;
1069
1070 goto register_client;
1071 }
1072 break;
1073 }
1074 }
1075
1076 /* Initializes only the first TV tuner on this adapter. Why only the
1077 first? Because there are some devices (notably the ones with TI
1078 tuners) that have more than one i2c address for the *same* device.
1079 Experience shows that, except for just one case, the first
1080 address is the right one. The exception is a Russian tuner
1081 (ACORP_Y878F). So, the desired behavior is just to enable the
1082 first found TV tuner. */
1083 tuner_lookup(t->i2c->adapter, &radio, &tv);
1084 if (tv == NULL) {
1085 t->mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
1086 if (radio == NULL)
1087 t->mode_mask |= T_RADIO;
1088 tuner_dbg("Setting mode_mask to 0x%02x\n", t->mode_mask);
1089 t->tv_freq = 400 * 16; /* Sets freq to VHF High */
1090 t->radio_freq = 87.5 * 16000; /* Sets freq to FM range */
1091 }
1092
1093 /* Should be just before return */
1094 register_client:
1095 tuner_info("chip found @ 0x%x (%s)\n", addr << 1, adap->name);
1096
1097 /* Sets a default mode */
1098 if (t->mode_mask & T_ANALOG_TV) {
1099 t->mode = T_ANALOG_TV;
1100 } else if (t->mode_mask & T_RADIO) {
1101 t->mode = T_RADIO;
1102 } else {
1103 t->mode = T_DIGITAL_TV;
1104 }
1105
1106 i2c_attach_client(client);
1107 set_type(client, t->type, t->mode_mask, t->config, t->tuner_callback);
1108 return 0;
1109 }
1110
1111 static int tuner_probe(struct i2c_adapter *adap)
1112 {
1113 if (0 != addr) {
1114 normal_i2c[0] = addr;
1115 normal_i2c[1] = I2C_CLIENT_END;
1116 }
1117
1118 /* HACK: Ignore 0x6b and 0x6f on cx88 boards.
1119 * FusionHDTV5 RT Gold has an ir receiver at 0x6b
1120 * and an RTC at 0x6f which can get corrupted if probed.
1121 */
1122 if ((adap->id == I2C_HW_B_CX2388x) ||
1123 (adap->id == I2C_HW_B_CX23885)) {
1124 unsigned int i = 0;
1125
1126 while (i < I2C_CLIENT_MAX_OPTS && ignore[i] != I2C_CLIENT_END)
1127 i += 2;
1128 if (i + 4 < I2C_CLIENT_MAX_OPTS) {
1129 ignore[i+0] = adap->nr;
1130 ignore[i+1] = 0x6b;
1131 ignore[i+2] = adap->nr;
1132 ignore[i+3] = 0x6f;
1133 ignore[i+4] = I2C_CLIENT_END;
1134 } else
1135 printk(KERN_WARNING "tuner: "
1136 "too many options specified "
1137 "in i2c probe ignore list!\n");
1138 }
1139
1140 if (adap->class & I2C_CLASS_TV_ANALOG)
1141 return i2c_probe(adap, &addr_data, tuner_attach);
1142 return 0;
1143 }
1144
1145 static int tuner_detach(struct i2c_client *client)
1146 {
1147 struct tuner *t = i2c_get_clientdata(client);
1148 struct analog_tuner_ops *ops = t->fe.ops.analog_demod_ops;
1149 int err;
1150
1151 err = i2c_detach_client(t->i2c);
1152 if (err) {
1153 tuner_warn
1154 ("Client deregistration failed, client not detached.\n");
1155 return err;
1156 }
1157
1158 if (ops && ops->release)
1159 ops->release(&t->fe);
1160
1161 list_del(&t->list);
1162 kfree(t);
1163 kfree(client);
1164 return 0;
1165 }
1166
1167 /* ----------------------------------------------------------------------- */
1168
1169 static struct i2c_driver driver = {
1170 .id = I2C_DRIVERID_TUNER,
1171 .attach_adapter = tuner_probe,
1172 .detach_client = tuner_detach,
1173 .command = tuner_command,
1174 .suspend = tuner_suspend,
1175 .resume = tuner_resume,
1176 .driver = {
1177 .name = "tuner",
1178 },
1179 };
1180 static struct i2c_client client_template = {
1181 .name = "(tuner unset)",
1182 .driver = &driver,
1183 };
1184
1185 static int __init tuner_init_module(void)
1186 {
1187 return i2c_add_driver(&driver);
1188 }
1189
1190 static void __exit tuner_cleanup_module(void)
1191 {
1192 i2c_del_driver(&driver);
1193 }
1194
1195 module_init(tuner_init_module);
1196 module_exit(tuner_cleanup_module);
1197
1198 /*
1199 * Overrides for Emacs so that we follow Linus's tabbing style.
1200 * ---------------------------------------------------------------------------
1201 * Local variables:
1202 * c-basic-offset: 8
1203 * End:
1204 */
Ubuntu Artful kernel mirror