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