?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / media / video / saa7134 / saa7134-tvaudio.c
blobbce58a247c9e7446428dc82fb20334b082bf7d81
1 /*
2 * device driver for philips saa7134 based TV cards
3 * tv audio decoder (fm stereo, nicam, ...)
4 *
5 * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include <linux/init.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h>
28 #include <linux/smp_lock.h>
29 #include <asm/div64.h>
30
31 #include "saa7134-reg.h"
32 #include "saa7134.h"
33
34 /* ------------------------------------------------------------------ */
35
36 static unsigned int audio_debug = 0;
37 MODULE_PARM(audio_debug,"i");
38 MODULE_PARM_DESC(audio_debug,"enable debug messages [tv audio]");
39
40 static unsigned int audio_ddep = 0;
41 MODULE_PARM(audio_ddep,"i");
42 MODULE_PARM_DESC(audio_ddep,"audio ddep overwrite");
43
44 static int audio_clock_override = UNSET;
45 MODULE_PARM(audio_clock_override, "i");
46
47 static int audio_clock_tweak = 0;
48 MODULE_PARM(audio_clock_tweak, "i");
49 MODULE_PARM_DESC(audio_clock_tweak, "Audio clock tick fine tuning for cards with audio crystal that's slightly off (range [-1024 .. 1024])");
50
51 #define dprintk(fmt, arg...) if (audio_debug) \
52 printk(KERN_DEBUG "%s/audio: " fmt, dev->name , ## arg)
53 #define d2printk(fmt, arg...) if (audio_debug > 1) \
54 printk(KERN_DEBUG "%s/audio: " fmt, dev->name, ## arg)
55
56 #define print_regb(reg) printk("%s: reg 0x%03x [%-16s]: 0x%02x\n", \
57 dev->name,(SAA7134_##reg),(#reg),saa_readb((SAA7134_##reg)))
58
59 #define SCAN_INITIAL_DELAY (HZ)
60 #define SCAN_SAMPLE_DELAY (HZ/5)
61 #define SCAN_SUBCARRIER_DELAY (HZ*2)
62
63 /* ------------------------------------------------------------------ */
64 /* saa7134 code */
65
66 static struct mainscan {
67 char *name;
68 v4l2_std_id std;
69 int carr;
70 } mainscan[] = {
71 {
72 .name = "M",
73 .std = V4L2_STD_NTSC | V4L2_STD_PAL_M,
74 .carr = 4500,
75 },{
76 .name = "BG",
77 .std = V4L2_STD_PAL_BG,
78 .carr = 5500,
79 },{
80 .name = "I",
81 .std = V4L2_STD_PAL_I,
82 .carr = 6000,
83 },{
84 .name = "DKL",
85 .std = V4L2_STD_PAL_DK | V4L2_STD_SECAM,
86 .carr = 6500,
87 }
88 };
89
90 static struct saa7134_tvaudio tvaudio[] = {
91 {
92 .name = "PAL-B/G FM-stereo",
93 .std = V4L2_STD_PAL,
94 .mode = TVAUDIO_FM_BG_STEREO,
95 .carr1 = 5500,
96 .carr2 = 5742,
97 },{
98 .name = "PAL-D/K1 FM-stereo",
99 .std = V4L2_STD_PAL,
100 .carr1 = 6500,
101 .carr2 = 6258,
102 .mode = TVAUDIO_FM_BG_STEREO,
103 },{
104 .name = "PAL-D/K2 FM-stereo",
105 .std = V4L2_STD_PAL,
106 .carr1 = 6500,
107 .carr2 = 6742,
108 .mode = TVAUDIO_FM_BG_STEREO,
109 },{
110 .name = "PAL-D/K3 FM-stereo",
111 .std = V4L2_STD_PAL,
112 .carr1 = 6500,
113 .carr2 = 5742,
114 .mode = TVAUDIO_FM_BG_STEREO,
115 },{
116 .name = "PAL-B/G NICAM",
117 .std = V4L2_STD_PAL,
118 .carr1 = 5500,
119 .carr2 = 5850,
120 .mode = TVAUDIO_NICAM_FM,
121 },{
122 .name = "PAL-I NICAM",
123 .std = V4L2_STD_PAL,
124 .carr1 = 6000,
125 .carr2 = 6552,
126 .mode = TVAUDIO_NICAM_FM,
127 },{
128 .name = "PAL-D/K NICAM",
129 .std = V4L2_STD_PAL,
130 .carr1 = 6500,
131 .carr2 = 5850,
132 .mode = TVAUDIO_NICAM_FM,
133 },{
134 .name = "SECAM-L NICAM",
135 .std = V4L2_STD_SECAM,
136 .carr1 = 6500,
137 .carr2 = 5850,
138 .mode = TVAUDIO_NICAM_AM,
139 },{
140 .name = "SECAM-D/K",
141 .std = V4L2_STD_SECAM,
142 .carr1 = 6500,
143 .carr2 = -1,
144 .mode = TVAUDIO_FM_MONO,
145 },{
146 .name = "NTSC-M",
147 .std = V4L2_STD_NTSC,
148 .carr1 = 4500,
149 .carr2 = -1,
150 .mode = TVAUDIO_FM_MONO,
151 },{
152 .name = "NTSC-A2 FM-stereo",
153 .std = V4L2_STD_NTSC,
154 .carr1 = 4500,
155 .carr2 = 4724,
156 .mode = TVAUDIO_FM_K_STEREO,
157 }
158 };
159 #define TVAUDIO (sizeof(tvaudio)/sizeof(struct saa7134_tvaudio))
160
161 /* ------------------------------------------------------------------ */
162
163 static void tvaudio_init(struct saa7134_dev *dev)
164 {
165 int clock = saa7134_boards[dev->board].audio_clock;
166
167 if (UNSET != audio_clock_override)
168 clock = audio_clock_override;
169
170 /* init all audio registers */
171 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x00);
172 if (need_resched())
173 schedule();
174 else
175 udelay(10);
176
177 saa_writeb(SAA7134_AUDIO_CLOCK0, clock & 0xff);
178 saa_writeb(SAA7134_AUDIO_CLOCK1, (clock >> 8) & 0xff);
179 saa_writeb(SAA7134_AUDIO_CLOCK2, (clock >> 16) & 0xff);
180 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x01);
181
182 saa_writeb(SAA7134_NICAM_ERROR_LOW, 0x14);
183 saa_writeb(SAA7134_NICAM_ERROR_HIGH, 0x50);
184 saa_writeb(SAA7134_MONITOR_SELECT, 0xa0);
185 saa_writeb(SAA7134_FM_DEMATRIX, 0x80);
186 }
187
188 static u32 tvaudio_carr2reg(u32 carrier)
189 {
190 u64 a = carrier;
191
192 a <<= 24;
193 do_div(a,12288);
194 return a;
195 }
196
197 static void tvaudio_setcarrier(struct saa7134_dev *dev,
198 int primary, int secondary)
199 {
200 if (-1 == secondary)
201 secondary = primary;
202 saa_writel(SAA7134_CARRIER1_FREQ0 >> 2, tvaudio_carr2reg(primary));
203 saa_writel(SAA7134_CARRIER2_FREQ0 >> 2, tvaudio_carr2reg(secondary));
204 }
205
206 static void mute_input_7134(struct saa7134_dev *dev)
207 {
208 unsigned int mute;
209 struct saa7134_input *in;
210 int ausel=0, ics=0, ocs=0;
211 int mask;
212
213 /* look what is to do ... */
214 in = dev->input;
215 mute = (dev->ctl_mute ||
216 (dev->automute && (&card(dev).radio) != in));
217 if (PCI_DEVICE_ID_PHILIPS_SAA7130 == dev->pci->device &&
218 card(dev).mute.name) {
219 /* 7130 - we'll mute using some unconnected audio input */
220 if (mute)
221 in = &card(dev).mute;
222 }
223 if (dev->hw_mute == mute &&
224 dev->hw_input == in) {
225 dprintk("mute/input: nothing to do [mute=%d,input=%s]\n",
226 mute,in->name);
227 return;
228 }
229
230 dprintk("ctl_mute=%d automute=%d input=%s => mute=%d input=%s\n",
231 dev->ctl_mute,dev->automute,dev->input->name,mute,in->name);
232 dev->hw_mute = mute;
233 dev->hw_input = in;
234
235 if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device)
236 /* 7134 mute */
237 saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 0xff : 0xbb);
238
239 /* switch internal audio mux */
240 switch (in->amux) {
241 case TV: ausel=0xc0; ics=0x00; ocs=0x02; break;
242 case LINE1: ausel=0x80; ics=0x00; ocs=0x00; break;
243 case LINE2: ausel=0x80; ics=0x08; ocs=0x01; break;
244 }
245 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel);
246 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics);
247 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, ocs);
248
249 /* switch gpio-connected external audio mux */
250 if (0 == card(dev).gpiomask)
251 return;
252 mask = card(dev).gpiomask;
253 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, mask, mask);
254 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio);
255 saa7134_track_gpio(dev,in->name);
256 }
257
258 static void tvaudio_setmode(struct saa7134_dev *dev,
259 struct saa7134_tvaudio *audio,
260 char *note)
261 {
262 int acpf, tweak = 0;
263
264 if (dev->tvnorm->id == V4L2_STD_NTSC) {
265 acpf = 0x19066;
266 } else {
267 acpf = 0x1e000;
268 }
269 if (audio_clock_tweak > -1024 && audio_clock_tweak < 1024)
270 tweak = audio_clock_tweak;
271
272 if (note)
273 dprintk("tvaudio_setmode: %s %s [%d.%03d/%d.%03d MHz] acpf=%d%+d\n",
274 note,audio->name,
275 audio->carr1 / 1000, audio->carr1 % 1000,
276 audio->carr2 / 1000, audio->carr2 % 1000,
277 acpf, tweak);
278
279 acpf += tweak;
280 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD0, (acpf & 0x0000ff) >> 0);
281 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD1, (acpf & 0x00ff00) >> 8);
282 saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD2, (acpf & 0x030000) >> 16);
283 tvaudio_setcarrier(dev,audio->carr1,audio->carr2);
284
285 switch (audio->mode) {
286 case TVAUDIO_FM_MONO:
287 case TVAUDIO_FM_BG_STEREO:
288 saa_writeb(SAA7134_DEMODULATOR, 0x00);
289 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00);
290 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x22);
291 saa_writeb(SAA7134_FM_DEMATRIX, 0x80);
292 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa0);
293 break;
294 case TVAUDIO_FM_K_STEREO:
295 saa_writeb(SAA7134_DEMODULATOR, 0x00);
296 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x01);
297 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x22);
298 saa_writeb(SAA7134_FM_DEMATRIX, 0x80);
299 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa0);
300 break;
301 case TVAUDIO_NICAM_FM:
302 saa_writeb(SAA7134_DEMODULATOR, 0x10);
303 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00);
304 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x44);
305 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa1);
306 saa_writeb(SAA7134_NICAM_CONFIG, 0x00);
307 break;
308 case TVAUDIO_NICAM_AM:
309 saa_writeb(SAA7134_DEMODULATOR, 0x12);
310 saa_writeb(SAA7134_DCXO_IDENT_CTRL, 0x00);
311 saa_writeb(SAA7134_FM_DEEMPHASIS, 0x44);
312 saa_writeb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0xa1);
313 saa_writeb(SAA7134_NICAM_CONFIG, 0x00);
314 break;
315 case TVAUDIO_FM_SAT_STEREO:
316 /* not implemented (yet) */
317 break;
318 }
319 }
320
321 static int tvaudio_sleep(struct saa7134_dev *dev, int timeout)
322 {
323 DECLARE_WAITQUEUE(wait, current);
324
325 add_wait_queue(&dev->thread.wq, &wait);
326 if (dev->thread.scan1 == dev->thread.scan2 && !dev->thread.shutdown) {
327 set_current_state(TASK_INTERRUPTIBLE);
328 if (timeout < 0)
329 schedule();
330 else
331 schedule_timeout(timeout);
332 }
333 remove_wait_queue(&dev->thread.wq, &wait);
334 return dev->thread.scan1 != dev->thread.scan2;
335 }
336
337 static int tvaudio_checkcarrier(struct saa7134_dev *dev, struct mainscan *scan)
338 {
339 __s32 left,right,value;
340
341 if (audio_debug > 1) {
342 int i;
343 dprintk("debug %d:",scan->carr);
344 for (i = -150; i <= 150; i += 30) {
345 tvaudio_setcarrier(dev,scan->carr+i,scan->carr+i);
346 saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
347 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
348 return -1;
349 value = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
350 if (0 == i)
351 printk(" # %6d # ",value >> 16);
352 else
353 printk(" %6d",value >> 16);
354 }
355 printk("\n");
356 }
357
358 if (dev->tvnorm->id & scan->std) {
359 tvaudio_setcarrier(dev,scan->carr-90,scan->carr-90);
360 saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
361 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
362 return -1;
363 left = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
364
365 tvaudio_setcarrier(dev,scan->carr+90,scan->carr+90);
366 saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
367 if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
368 return -1;
369 right = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
370
371 left >>= 16;
372 right >>= 16;
373 value = left > right ? left - right : right - left;
374 dprintk("scanning %d.%03d MHz [%4s] => dc is %5d [%d/%d]\n",
375 scan->carr / 1000, scan->carr % 1000,
376 scan->name, value, left, right);
377 } else {
378 value = 0;
379 dprintk("skipping %d.%03d MHz [%4s]\n",
380 scan->carr / 1000, scan->carr % 1000, scan->name);
381 }
382 return value;
383 }
384
385 #if 0
386 static void sifdebug_dump_regs(struct saa7134_dev *dev)
387 {
388 print_regb(AUDIO_STATUS);
389 print_regb(IDENT_SIF);
390 print_regb(LEVEL_READOUT1);
391 print_regb(LEVEL_READOUT2);
392 print_regb(DCXO_IDENT_CTRL);
393 print_regb(DEMODULATOR);
394 print_regb(AGC_GAIN_SELECT);
395 print_regb(MONITOR_SELECT);
396 print_regb(FM_DEEMPHASIS);
397 print_regb(FM_DEMATRIX);
398 print_regb(SIF_SAMPLE_FREQ);
399 print_regb(ANALOG_IO_SELECT);
400 }
401 #endif
402
403 static int tvaudio_getstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio)
404 {
405 __u32 idp,nicam;
406 int retval = -1;
407
408 switch (audio->mode) {
409 case TVAUDIO_FM_MONO:
410 return V4L2_TUNER_SUB_MONO;
411 case TVAUDIO_FM_K_STEREO:
412 case TVAUDIO_FM_BG_STEREO:
413 idp = (saa_readb(SAA7134_IDENT_SIF) & 0xe0) >> 5;
414 dprintk("getstereo: fm/stereo: idp=0x%x\n",idp);
415 if (0x03 == (idp & 0x03))
416 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
417 else if (0x05 == (idp & 0x05))
418 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
419 else if (0x01 == (idp & 0x01))
420 retval = V4L2_TUNER_SUB_MONO;
421 break;
422 case TVAUDIO_FM_SAT_STEREO:
423 /* not implemented (yet) */
424 break;
425 case TVAUDIO_NICAM_FM:
426 case TVAUDIO_NICAM_AM:
427 nicam = saa_readb(SAA7134_NICAM_STATUS);
428 dprintk("getstereo: nicam=0x%x\n",nicam);
429 switch (nicam & 0x0b) {
430 case 0x08:
431 retval = V4L2_TUNER_SUB_MONO;
432 break;
433 case 0x09:
434 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
435 break;
436 case 0x0a:
437 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
438 break;
439 }
440 break;
441 }
442 if (retval != -1)
443 dprintk("found audio subchannels:%s%s%s%s\n",
444 (retval & V4L2_TUNER_SUB_MONO) ? " mono" : "",
445 (retval & V4L2_TUNER_SUB_STEREO) ? " stereo" : "",
446 (retval & V4L2_TUNER_SUB_LANG1) ? " lang1" : "",
447 (retval & V4L2_TUNER_SUB_LANG2) ? " lang2" : "");
448 return retval;
449 }
450
451 static int tvaudio_setstereo(struct saa7134_dev *dev, struct saa7134_tvaudio *audio,
452 u32 mode)
453 {
454 static char *name[] = {
455 [ V4L2_TUNER_MODE_MONO ] = "mono",
456 [ V4L2_TUNER_MODE_STEREO ] = "stereo",
457 [ V4L2_TUNER_MODE_LANG1 ] = "lang1",
458 [ V4L2_TUNER_MODE_LANG2 ] = "lang2",
459 };
460 static u32 fm[] = {
461 [ V4L2_TUNER_MODE_MONO ] = 0x00, /* ch1 */
462 [ V4L2_TUNER_MODE_STEREO ] = 0x80, /* auto */
463 [ V4L2_TUNER_MODE_LANG1 ] = 0x00, /* ch1 */
464 [ V4L2_TUNER_MODE_LANG2 ] = 0x01, /* ch2 */
465 };
466 u32 reg;
467
468 switch (audio->mode) {
469 case TVAUDIO_FM_MONO:
470 /* nothing to do ... */
471 break;
472 case TVAUDIO_FM_K_STEREO:
473 case TVAUDIO_FM_BG_STEREO:
474 dprintk("setstereo [fm] => %s\n",
475 name[ mode % ARRAY_SIZE(name) ]);
476 reg = fm[ mode % ARRAY_SIZE(fm) ];
477 saa_writeb(SAA7134_FM_DEMATRIX, reg);
478 break;
479 case TVAUDIO_FM_SAT_STEREO:
480 case TVAUDIO_NICAM_AM:
481 case TVAUDIO_NICAM_FM:
482 /* FIXME */
483 break;
484 }
485 return 0;
486 }
487
488 static int tvaudio_thread(void *data)
489 {
490 struct saa7134_dev *dev = data;
491 int carr_vals[ARRAY_SIZE(mainscan)];
492 unsigned int i, audio, nscan;
493 int max1,max2,carrier,rx,mode,lastmode,default_carrier;
494
495 daemonize("%s", dev->name);
496 allow_signal(SIGTERM);
497 for (;;) {
498 tvaudio_sleep(dev,-1);
499 if (dev->thread.shutdown || signal_pending(current))
500 goto done;
501
502 restart:
503 dev->thread.scan1 = dev->thread.scan2;
504 dprintk("tvaudio thread scan start [%d]\n",dev->thread.scan1);
505 dev->tvaudio = NULL;
506 tvaudio_init(dev);
507 if (dev->ctl_automute)
508 dev->automute = 1;
509 mute_input_7134(dev);
510
511 /* give the tuner some time */
512 if (tvaudio_sleep(dev,SCAN_INITIAL_DELAY))
513 goto restart;
514
515 max1 = 0;
516 max2 = 0;
517 nscan = 0;
518 carrier = 0;
519 default_carrier = 0;
520 for (i = 0; i < ARRAY_SIZE(mainscan); i++) {
521 if (!(dev->tvnorm->id & mainscan[i].std))
522 continue;
523 if (!default_carrier)
524 default_carrier = mainscan[i].carr;
525 nscan++;
526 }
527
528 if (1 == nscan) {
529 /* only one candidate -- skip scan ;) */
530 max1 = 12345;
531 carrier = default_carrier;
532 } else {
533 /* scan for the main carrier */
534 saa_writeb(SAA7134_MONITOR_SELECT,0x00);
535 tvaudio_setmode(dev,&tvaudio[0],NULL);
536 for (i = 0; i < ARRAY_SIZE(mainscan); i++) {
537 carr_vals[i] = tvaudio_checkcarrier(dev, mainscan+i);
538 if (dev->thread.scan1 != dev->thread.scan2)
539 goto restart;
540 }
541 for (max1 = 0, max2 = 0, i = 0; i < ARRAY_SIZE(mainscan); i++) {
542 if (max1 < carr_vals[i]) {
543 max2 = max1;
544 max1 = carr_vals[i];
545 carrier = mainscan[i].carr;
546 } else if (max2 < carr_vals[i]) {
547 max2 = carr_vals[i];
548 }
549 }
550 }
551
552 if (0 != carrier && max1 > 2000 && max1 > max2*3) {
553 /* found good carrier */
554 dprintk("found %s main sound carrier @ %d.%03d MHz [%d/%d]\n",
555 dev->tvnorm->name, carrier/1000, carrier%1000,
556 max1, max2);
557 dev->last_carrier = carrier;
558
559 } else if (0 != dev->last_carrier) {
560 /* no carrier -- try last detected one as fallback */
561 carrier = dev->last_carrier;
562 printk(KERN_WARNING "%s/audio: audio carrier scan failed, "
563 "using %d.%03d MHz [last detected]\n",
564 dev->name, carrier/1000, carrier%1000);
565
566 } else {
567 /* no carrier + no fallback -- use default */
568 carrier = default_carrier;
569 printk(KERN_WARNING "%s/audio: audio carrier scan failed, "
570 "using %d.%03d MHz [default]\n",
571 dev->name, carrier/1000, carrier%1000);
572 }
573 tvaudio_setcarrier(dev,carrier,carrier);
574 dev->automute = 0;
575 saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x00);
576 saa7134_tvaudio_setmute(dev);
577
578 /* find the exact tv audio norm */
579 for (audio = UNSET, i = 0; i < TVAUDIO; i++) {
580 if (dev->tvnorm->id != UNSET &&
581 !(dev->tvnorm->id & tvaudio[i].std))
582 continue;
583 if (tvaudio[i].carr1 != carrier)
584 continue;
585
586 if (UNSET == audio)
587 audio = i;
588 tvaudio_setmode(dev,&tvaudio[i],"trying");
589 if (tvaudio_sleep(dev,SCAN_SUBCARRIER_DELAY))
590 goto restart;
591 if (-1 != tvaudio_getstereo(dev,&tvaudio[i])) {
592 audio = i;
593 break;
594 }
595 }
596 saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x30);
597 if (UNSET == audio)
598 continue;
599 tvaudio_setmode(dev,&tvaudio[audio],"using");
600 tvaudio_setstereo(dev,&tvaudio[audio],V4L2_TUNER_MODE_MONO);
601 dev->tvaudio = &tvaudio[audio];
602
603 lastmode = 42;
604 for (;;) {
605 if (tvaudio_sleep(dev,5*HZ))
606 goto restart;
607 if (dev->thread.shutdown || signal_pending(current))
608 break;
609 if (UNSET == dev->thread.mode) {
610 rx = tvaudio_getstereo(dev,&tvaudio[i]);
611 mode = saa7134_tvaudio_rx2mode(rx);
612 } else {
613 mode = dev->thread.mode;
614 }
615 if (lastmode != mode) {
616 tvaudio_setstereo(dev,&tvaudio[audio],mode);
617 lastmode = mode;
618 }
619 }
620 }
621
622 done:
623 complete_and_exit(&dev->thread.exit, 0);
624 return 0;
625 }
626
627 /* ------------------------------------------------------------------ */
628 /* saa7133 / saa7135 code */
629
630 static char *stdres[0x20] = {
631 [0x00] = "no standard detected",
632 [0x01] = "B/G (in progress)",
633 [0x02] = "D/K (in progress)",
634 [0x03] = "M (in progress)",
635
636 [0x04] = "B/G A2",
637 [0x05] = "B/G NICAM",
638 [0x06] = "D/K A2 (1)",
639 [0x07] = "D/K A2 (2)",
640 [0x08] = "D/K A2 (3)",
641 [0x09] = "D/K NICAM",
642 [0x0a] = "L NICAM",
643 [0x0b] = "I NICAM",
644
645 [0x0c] = "M Korea",
646 [0x0d] = "M BTSC ",
647 [0x0e] = "M EIAJ",
648
649 [0x0f] = "FM radio / IF 10.7 / 50 deemp",
650 [0x10] = "FM radio / IF 10.7 / 75 deemp",
651 [0x11] = "FM radio / IF sel / 50 deemp",
652 [0x12] = "FM radio / IF sel / 75 deemp",
653
654 [0x13 ... 0x1e ] = "unknown",
655 [0x1f] = "??? [in progress]",
656 };
657
658 #define DSP_RETRY 32
659 #define DSP_DELAY 16
660
661 static inline int saa_dsp_wait_bit(struct saa7134_dev *dev, int bit)
662 {
663 int state, count = DSP_RETRY;
664
665 state = saa_readb(SAA7135_DSP_RWSTATE);
666 if (unlikely(state & SAA7135_DSP_RWSTATE_ERR)) {
667 printk("%s: dsp access error\n",dev->name);
668 /* FIXME: send ack ... */
669 return -EIO;
670 }
671 while (0 == (state & bit)) {
672 if (unlikely(0 == count)) {
673 printk("%s: dsp access wait timeout [bit=%s]\n",
674 dev->name,
675 (bit & SAA7135_DSP_RWSTATE_WRR) ? "WRR" :
676 (bit & SAA7135_DSP_RWSTATE_RDB) ? "RDB" :
677 (bit & SAA7135_DSP_RWSTATE_IDA) ? "IDA" :
678 "???");
679 return -EIO;
680 }
681 saa_wait(DSP_DELAY);
682 state = saa_readb(SAA7135_DSP_RWSTATE);
683 count--;
684 }
685 return 0;
686 }
687
688 #if 0
689 static int saa_dsp_readl(struct saa7134_dev *dev, int reg, u32 *value)
690 {
691 int err;
692
693 d2printk("dsp read reg 0x%x\n", reg<<2);
694 saa_readl(reg);
695 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_RDB);
696 if (err < 0)
697 return err;
698 *value = saa_readl(reg);
699 d2printk("dsp read => 0x%06x\n", *value & 0xffffff);
700 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_IDA);
701 if (err < 0)
702 return err;
703 return 0;
704 }
705 #endif
706
707 int saa_dsp_writel(struct saa7134_dev *dev, int reg, u32 value)
708 {
709 int err;
710
711 d2printk("dsp write reg 0x%x = 0x%06x\n",reg<<2,value);
712 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
713 if (err < 0)
714 return err;
715 saa_writel(reg,value);
716 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
717 if (err < 0)
718 return err;
719 return 0;
720 }
721
722 static int getstereo_7133(struct saa7134_dev *dev)
723 {
724 int retval = V4L2_TUNER_SUB_MONO;
725 u32 value;
726
727 value = saa_readl(0x528 >> 2);
728 if (value & 0x20)
729 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
730 if (value & 0x40)
731 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
732 return retval;
733 }
734
735 static int mute_input_7133(struct saa7134_dev *dev)
736 {
737 u32 reg = 0;
738
739 switch (dev->input->amux) {
740 case TV: reg = 0x02; break;
741 case LINE1: reg = 0x00; break;
742 case LINE2: reg = 0x01; break;
743 }
744 if (dev->ctl_mute)
745 reg = 0x07;
746 saa_writel(0x594 >> 2, reg);
747 return 0;
748 }
749
750 static int tvaudio_thread_ddep(void *data)
751 {
752 struct saa7134_dev *dev = data;
753 u32 value, norms, clock;
754
755 daemonize("%s", dev->name);
756 allow_signal(SIGTERM);
757
758 clock = saa7134_boards[dev->board].audio_clock;
759 if (UNSET != audio_clock_override)
760 clock = audio_clock_override;
761 saa_writel(0x598 >> 2, clock);
762
763 /* unmute */
764 saa_dsp_writel(dev, 0x474 >> 2, 0x00);
765 saa_dsp_writel(dev, 0x450 >> 2, 0x00);
766
767 for (;;) {
768 tvaudio_sleep(dev,-1);
769 if (dev->thread.shutdown || signal_pending(current))
770 goto done;
771
772 restart:
773 dev->thread.scan1 = dev->thread.scan2;
774 dprintk("tvaudio thread scan start [%d]\n",dev->thread.scan1);
775
776 if (audio_ddep >= 0x04 && audio_ddep <= 0x0e) {
777 /* insmod option override */
778 norms = (audio_ddep << 2) | 0x01;
779 dprintk("ddep override: %s\n",stdres[audio_ddep]);
780 } else{
781 /* (let chip) scan for sound carrier */
782 norms = 0;
783 if (dev->tvnorm->id & V4L2_STD_PAL) {
784 dprintk("PAL scan\n");
785 norms |= 0x2c; /* B/G + D/K + I */
786 }
787 if (dev->tvnorm->id & V4L2_STD_NTSC) {
788 dprintk("NTSC scan\n");
789 norms |= 0x40; /* M */
790 }
791 if (dev->tvnorm->id & V4L2_STD_SECAM) {
792 dprintk("SECAM scan\n");
793 norms |= 0x18; /* L + D/K */
794 }
795 if (0 == norms)
796 norms = 0x7c; /* all */
797 dprintk("scanning:%s%s%s%s%s\n",
798 (norms & 0x04) ? " B/G" : "",
799 (norms & 0x08) ? " D/K" : "",
800 (norms & 0x10) ? " L/L'" : "",
801 (norms & 0x20) ? " I" : "",
802 (norms & 0x40) ? " M" : "");
803 }
804
805 /* kick automatic standard detection */
806 saa_dsp_writel(dev, 0x454 >> 2, 0);
807 saa_dsp_writel(dev, 0x454 >> 2, norms | 0x80);
808
809 /* setup crossbars */
810 saa_dsp_writel(dev, 0x464 >> 2, 0x000000);
811 saa_dsp_writel(dev, 0x470 >> 2, 0x101010);
812
813 if (tvaudio_sleep(dev,3*HZ))
814 goto restart;
815 value = saa_readl(0x528 >> 2) & 0xffffff;
816
817 dprintk("tvaudio thread status: 0x%x [%s%s%s]\n",
818 value, stdres[value & 0x1f],
819 (value & 0x000020) ? ",stereo" : "",
820 (value & 0x000040) ? ",dual" : "");
821 dprintk("detailed status: "
822 "%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n",
823 (value & 0x000080) ? " A2/EIAJ pilot tone " : "",
824 (value & 0x000100) ? " A2/EIAJ dual " : "",
825 (value & 0x000200) ? " A2/EIAJ stereo " : "",
826 (value & 0x000400) ? " A2/EIAJ noise mute " : "",
827
828 (value & 0x000800) ? " BTSC/FM radio pilot " : "",
829 (value & 0x001000) ? " SAP carrier " : "",
830 (value & 0x002000) ? " BTSC stereo noise mute " : "",
831 (value & 0x004000) ? " SAP noise mute " : "",
832 (value & 0x008000) ? " VDSP " : "",
833
834 (value & 0x010000) ? " NICST " : "",
835 (value & 0x020000) ? " NICDU " : "",
836 (value & 0x040000) ? " NICAM muted " : "",
837 (value & 0x080000) ? " NICAM reserve sound " : "",
838
839 (value & 0x100000) ? " init done " : "");
840 }
841
842 done:
843 complete_and_exit(&dev->thread.exit, 0);
844 return 0;
845 }
846
847 /* ------------------------------------------------------------------ */
848 /* common stuff + external entry points */
849
850 int saa7134_tvaudio_rx2mode(u32 rx)
851 {
852 u32 mode;
853
854 mode = V4L2_TUNER_MODE_MONO;
855 if (rx & V4L2_TUNER_SUB_STEREO)
856 mode = V4L2_TUNER_MODE_STEREO;
857 else if (rx & V4L2_TUNER_SUB_LANG1)
858 mode = V4L2_TUNER_MODE_LANG1;
859 else if (rx & V4L2_TUNER_SUB_LANG2)
860 mode = V4L2_TUNER_MODE_LANG2;
861 return mode;
862 }
863
864 void saa7134_tvaudio_setmute(struct saa7134_dev *dev)
865 {
866 switch (dev->pci->device) {
867 case PCI_DEVICE_ID_PHILIPS_SAA7130:
868 case PCI_DEVICE_ID_PHILIPS_SAA7134:
869 mute_input_7134(dev);
870 break;
871 case PCI_DEVICE_ID_PHILIPS_SAA7133:
872 case PCI_DEVICE_ID_PHILIPS_SAA7135:
873 mute_input_7133(dev);
874 break;
875 }
876 }
877
878 void saa7134_tvaudio_setinput(struct saa7134_dev *dev,
879 struct saa7134_input *in)
880 {
881 dev->input = in;
882 switch (dev->pci->device) {
883 case PCI_DEVICE_ID_PHILIPS_SAA7130:
884 case PCI_DEVICE_ID_PHILIPS_SAA7134:
885 mute_input_7134(dev);
886 break;
887 case PCI_DEVICE_ID_PHILIPS_SAA7133:
888 case PCI_DEVICE_ID_PHILIPS_SAA7135:
889 mute_input_7133(dev);
890 break;
891 }
892 }
893
894 void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)
895 {
896 switch (dev->pci->device) {
897 case PCI_DEVICE_ID_PHILIPS_SAA7134:
898 saa_writeb(SAA7134_CHANNEL1_LEVEL, level & 0x1f);
899 saa_writeb(SAA7134_CHANNEL2_LEVEL, level & 0x1f);
900 saa_writeb(SAA7134_NICAM_LEVEL_ADJUST, level & 0x1f);
901 break;
902 }
903 }
904
905 int saa7134_tvaudio_getstereo(struct saa7134_dev *dev)
906 {
907 int retval = V4L2_TUNER_SUB_MONO;
908
909 switch (dev->pci->device) {
910 case PCI_DEVICE_ID_PHILIPS_SAA7134:
911 if (dev->tvaudio)
912 retval = tvaudio_getstereo(dev,dev->tvaudio);
913 break;
914 case PCI_DEVICE_ID_PHILIPS_SAA7133:
915 case PCI_DEVICE_ID_PHILIPS_SAA7135:
916 retval = getstereo_7133(dev);
917 break;
918 }
919 return retval;
920 }
921
922 int saa7134_tvaudio_init2(struct saa7134_dev *dev)
923 {
924 DECLARE_MUTEX_LOCKED(sem);
925 int (*my_thread)(void *data) = NULL;
926
927 /* enable I2S audio output */
928 if (saa7134_boards[dev->board].has_ts) {
929 int i2sform = (48000 == dev->oss.rate)
930 ? 0x01 : 0x00;
931
932 /* enable I2S output */
933 saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80);
934 saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2sform);
935 saa_writeb(SAA7134_I2S_OUTPUT_LEVEL, 0x0F);
936 saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x01);
937 }
938
939 switch (dev->pci->device) {
940 case PCI_DEVICE_ID_PHILIPS_SAA7134:
941 my_thread = tvaudio_thread;
942 break;
943 case PCI_DEVICE_ID_PHILIPS_SAA7133:
944 case PCI_DEVICE_ID_PHILIPS_SAA7135:
945 my_thread = tvaudio_thread_ddep;
946 break;
947 }
948
949 dev->thread.pid = -1;
950 if (my_thread) {
951 /* start tvaudio thread */
952 init_waitqueue_head(&dev->thread.wq);
953 init_completion(&dev->thread.exit);
954 dev->thread.pid = kernel_thread(my_thread,dev,0);
955 if (dev->thread.pid < 0)
956 printk(KERN_WARNING "%s: kernel_thread() failed\n",
957 dev->name);
958 wake_up_interruptible(&dev->thread.wq);
959 }
960
961 return 0;
962 }
963
964 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
965 {
966 /* shutdown tvaudio thread */
967 if (dev->thread.pid >= 0) {
968 dev->thread.shutdown = 1;
969 wake_up_interruptible(&dev->thread.wq);
970 wait_for_completion(&dev->thread.exit);
971 }
972 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, 0x00); /* LINE1 */
973 return 0;
974 }
975
976 int saa7134_tvaudio_do_scan(struct saa7134_dev *dev)
977 {
978 if (dev->thread.pid >= 0) {
979 dev->thread.mode = UNSET;
980 dev->thread.scan2++;
981 wake_up_interruptible(&dev->thread.wq);
982 } else {
983 dev->automute = 0;
984 saa7134_tvaudio_setmute(dev);
985 }
986 return 0;
987 }
988
989 /* ----------------------------------------------------------- */
990 /*
991 * Local variables:
992 * c-basic-offset: 8
993 * End:
994 */
MOXA 2.6.9 from sdlinux-moxaart.tgz