This source file includes following definitions.
- tvaudio_carr2reg
- tvaudio_setcarrier
- mute_input_7134
- tvaudio_setmode
- tvaudio_sleep
- tvaudio_checkcarrier
- tvaudio_getstereo
- tvaudio_setstereo
- tvaudio_thread
- saa_dsp_reset_error_bit
- saa_dsp_wait_bit
- saa_dsp_writel
- getstereo_7133
- mute_input_7133
- tvaudio_thread_ddep
- saa7134_enable_i2s
- saa7134_tvaudio_rx2mode
- saa7134_tvaudio_setmute
- saa7134_tvaudio_setinput
- saa7134_tvaudio_setvolume
- saa7134_tvaudio_getstereo
- saa7134_tvaudio_init
- saa7134_tvaudio_init2
- saa7134_tvaudio_close
- saa7134_tvaudio_fini
- saa7134_tvaudio_do_scan
1
2
3
4
5
6
7
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
45 #define SCAN_INITIAL_DELAY 1000
46 #define SCAN_SAMPLE_DELAY 200
47 #define SCAN_SUBCARRIER_DELAY 2000
48
49
50
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
179 in = dev->input;
180 mute = (dev->ctl_mute ||
181 (dev->automute && (&card(dev).radio) != in));
182 if (card(dev).mute.type) {
183
184
185
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
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
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
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
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
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
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
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,
433 [ V4L2_TUNER_MODE_STEREO ] = 0x80,
434 [ V4L2_TUNER_MODE_LANG1 ] = 0x00,
435 [ V4L2_TUNER_MODE_LANG2 ] = 0x01,
436 [ V4L2_TUNER_MODE_LANG1_LANG2 ] = 0x80,
437 };
438 u32 reg;
439
440 switch (audio->mode) {
441 case TVAUDIO_FM_MONO:
442
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
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
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
509 audio_dbg(1, "only one main carrier candidate - skipping scan\n");
510 max1 = 12345;
511 carrier = default_carrier;
512 } else {
513
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
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
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
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
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
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
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", reg << 2, value);
687 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
688 if (err < 0)
689 return err;
690 saa_writel(reg,value);
691 err = saa_dsp_wait_bit(dev,SAA7135_DSP_RWSTATE_WRR);
692 if (err < 0)
693 return err;
694 return 0;
695 }
696
697 static int getstereo_7133(struct saa7134_dev *dev)
698 {
699 int retval = V4L2_TUNER_SUB_MONO;
700 u32 value;
701
702 value = saa_readl(0x528 >> 2);
703 if (value & 0x20)
704 retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
705 if (value & 0x40)
706 retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
707 return retval;
708 }
709
710 static int mute_input_7133(struct saa7134_dev *dev)
711 {
712 u32 reg = 0;
713 u32 xbarin, xbarout;
714 int mask;
715 struct saa7134_input *in;
716
717 xbarin = 0x03;
718 switch (dev->input->amux) {
719 case TV:
720 reg = 0x02;
721 xbarin = 0;
722 break;
723 case LINE1:
724 reg = 0x00;
725 break;
726 case LINE2:
727 case LINE2_LEFT:
728 reg = 0x09;
729 break;
730 }
731 saa_dsp_writel(dev, 0x464 >> 2, xbarin);
732 if (dev->ctl_mute) {
733 reg = 0x07;
734 xbarout = 0xbbbbbb;
735 } else
736 xbarout = 0xbbbb10;
737 saa_dsp_writel(dev, 0x46c >> 2, xbarout);
738
739 saa_writel(0x594 >> 2, reg);
740
741
742
743 if (0 != card(dev).gpiomask) {
744 mask = card(dev).gpiomask;
745
746 if (card(dev).mute.type && dev->ctl_mute)
747 in = &card(dev).mute;
748 else
749 in = dev->input;
750
751 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, mask, mask);
752 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, mask, in->gpio);
753 saa7134_track_gpio(dev, saa7134_input_name[in->type]);
754 }
755
756 return 0;
757 }
758
759 static int tvaudio_thread_ddep(void *data)
760 {
761 struct saa7134_dev *dev = data;
762 u32 value, norms;
763
764 set_freezable();
765 for (;;) {
766 tvaudio_sleep(dev,-1);
767 if (kthread_should_stop())
768 goto done;
769 restart:
770 try_to_freeze();
771
772 dev->thread.scan1 = dev->thread.scan2;
773 audio_dbg(1, "tvaudio thread scan start [%d]\n",
774 dev->thread.scan1);
775
776 if (audio_ddep >= 0x04 && audio_ddep <= 0x0e) {
777
778 norms = (audio_ddep << 2) | 0x01;
779 audio_dbg(1, "ddep override: %s\n",
780 stdres[audio_ddep]);
781 } else if (&card(dev).radio == dev->input) {
782 audio_dbg(1, "FM Radio\n");
783 if (dev->tuner_type == TUNER_PHILIPS_TDA8290) {
784 norms = (0x11 << 2) | 0x01;
785
786 saa_dsp_writel(dev, 0x42c >> 2, 0x729555);
787 } else {
788 norms = (0x0f << 2) | 0x01;
789 }
790 } else {
791
792 norms = 0;
793 if (dev->tvnorm->id & (V4L2_STD_B | V4L2_STD_GH))
794 norms |= 0x04;
795 if (dev->tvnorm->id & V4L2_STD_PAL_I)
796 norms |= 0x20;
797 if (dev->tvnorm->id & V4L2_STD_DK)
798 norms |= 0x08;
799 if (dev->tvnorm->id & V4L2_STD_MN)
800 norms |= 0x40;
801 if (dev->tvnorm->id & (V4L2_STD_SECAM_L | V4L2_STD_SECAM_LC))
802 norms |= 0x10;
803 if (0 == norms)
804 norms = 0x7c;
805 audio_dbg(1, "scanning:%s%s%s%s%s\n",
806 (norms & 0x04) ? " B/G" : "",
807 (norms & 0x08) ? " D/K" : "",
808 (norms & 0x10) ? " L/L'" : "",
809 (norms & 0x20) ? " I" : "",
810 (norms & 0x40) ? " M" : "");
811 }
812
813
814 saa_dsp_writel(dev, 0x454 >> 2, 0);
815 saa_dsp_writel(dev, 0x454 >> 2, norms | 0x80);
816
817
818 saa_dsp_writel(dev, 0x464 >> 2, 0x000000);
819 saa_dsp_writel(dev, 0x470 >> 2, 0x101010);
820
821 if (tvaudio_sleep(dev,3000))
822 goto restart;
823 value = saa_readl(0x528 >> 2) & 0xffffff;
824
825 audio_dbg(1, "tvaudio thread status: 0x%x [%s%s%s]\n",
826 value, stdres[value & 0x1f],
827 (value & 0x000020) ? ",stereo" : "",
828 (value & 0x000040) ? ",dual" : "");
829 audio_dbg(1, "detailed status: %s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n",
830 (value & 0x000080) ? " A2/EIAJ pilot tone " : "",
831 (value & 0x000100) ? " A2/EIAJ dual " : "",
832 (value & 0x000200) ? " A2/EIAJ stereo " : "",
833 (value & 0x000400) ? " A2/EIAJ noise mute " : "",
834
835 (value & 0x000800) ? " BTSC/FM radio pilot " : "",
836 (value & 0x001000) ? " SAP carrier " : "",
837 (value & 0x002000) ? " BTSC stereo noise mute " : "",
838 (value & 0x004000) ? " SAP noise mute " : "",
839 (value & 0x008000) ? " VDSP " : "",
840
841 (value & 0x010000) ? " NICST " : "",
842 (value & 0x020000) ? " NICDU " : "",
843 (value & 0x040000) ? " NICAM muted " : "",
844 (value & 0x080000) ? " NICAM reserve sound " : "",
845
846 (value & 0x100000) ? " init done " : "");
847 }
848
849 done:
850 dev->thread.stopped = 1;
851 return 0;
852 }
853
854
855
856
857 void saa7134_enable_i2s(struct saa7134_dev *dev)
858 {
859 int i2s_format;
860
861 if (!card_is_empress(dev))
862 return;
863
864 if (dev->pci->device == PCI_DEVICE_ID_PHILIPS_SAA7130)
865 return;
866
867
868 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x0E000000, 0x00000000);
869
870 switch (dev->pci->device) {
871 case PCI_DEVICE_ID_PHILIPS_SAA7133:
872 case PCI_DEVICE_ID_PHILIPS_SAA7135:
873
874 saa_writeb(SAA7133_I2S_AUDIO_CONTROL, 0x00);
875
876 saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x11);
877 break;
878
879 case PCI_DEVICE_ID_PHILIPS_SAA7134:
880 i2s_format = (dev->input->amux == TV) ? 0x00 : 0x01;
881
882
883 saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80);
884 saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2s_format);
885 saa_writeb(SAA7134_I2S_OUTPUT_LEVEL, 0x0F);
886 saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x01);
887
888 default:
889 break;
890 }
891 }
892
893 int saa7134_tvaudio_rx2mode(u32 rx)
894 {
895 u32 mode;
896
897 mode = V4L2_TUNER_MODE_MONO;
898 if (rx & V4L2_TUNER_SUB_STEREO)
899 mode = V4L2_TUNER_MODE_STEREO;
900 else if (rx & V4L2_TUNER_SUB_LANG1)
901 mode = V4L2_TUNER_MODE_LANG1;
902 else if (rx & V4L2_TUNER_SUB_LANG2)
903 mode = V4L2_TUNER_MODE_LANG2;
904 return mode;
905 }
906
907 void saa7134_tvaudio_setmute(struct saa7134_dev *dev)
908 {
909 switch (dev->pci->device) {
910 case PCI_DEVICE_ID_PHILIPS_SAA7130:
911 case PCI_DEVICE_ID_PHILIPS_SAA7134:
912 mute_input_7134(dev);
913 break;
914 case PCI_DEVICE_ID_PHILIPS_SAA7133:
915 case PCI_DEVICE_ID_PHILIPS_SAA7135:
916 mute_input_7133(dev);
917 break;
918 }
919 }
920
921 void saa7134_tvaudio_setinput(struct saa7134_dev *dev,
922 struct saa7134_input *in)
923 {
924 dev->input = in;
925 switch (dev->pci->device) {
926 case PCI_DEVICE_ID_PHILIPS_SAA7130:
927 case PCI_DEVICE_ID_PHILIPS_SAA7134:
928 mute_input_7134(dev);
929 break;
930 case PCI_DEVICE_ID_PHILIPS_SAA7133:
931 case PCI_DEVICE_ID_PHILIPS_SAA7135:
932 mute_input_7133(dev);
933 break;
934 }
935 saa7134_enable_i2s(dev);
936 }
937
938 void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)
939 {
940 switch (dev->pci->device) {
941 case PCI_DEVICE_ID_PHILIPS_SAA7134:
942 saa_writeb(SAA7134_CHANNEL1_LEVEL, level & 0x1f);
943 saa_writeb(SAA7134_CHANNEL2_LEVEL, level & 0x1f);
944 saa_writeb(SAA7134_NICAM_LEVEL_ADJUST, level & 0x1f);
945 break;
946 }
947 }
948
949 int saa7134_tvaudio_getstereo(struct saa7134_dev *dev)
950 {
951 int retval = V4L2_TUNER_SUB_MONO;
952
953 switch (dev->pci->device) {
954 case PCI_DEVICE_ID_PHILIPS_SAA7134:
955 if (dev->tvaudio)
956 retval = tvaudio_getstereo(dev,dev->tvaudio);
957 break;
958 case PCI_DEVICE_ID_PHILIPS_SAA7133:
959 case PCI_DEVICE_ID_PHILIPS_SAA7135:
960 retval = getstereo_7133(dev);
961 break;
962 }
963 return retval;
964 }
965
966 void saa7134_tvaudio_init(struct saa7134_dev *dev)
967 {
968 int clock = saa7134_boards[dev->board].audio_clock;
969
970 if (UNSET != audio_clock_override)
971 clock = audio_clock_override;
972
973 switch (dev->pci->device) {
974 case PCI_DEVICE_ID_PHILIPS_SAA7134:
975
976 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x00);
977 if (need_resched())
978 schedule();
979 else
980 udelay(10);
981
982 saa_writeb(SAA7134_AUDIO_CLOCK0, clock & 0xff);
983 saa_writeb(SAA7134_AUDIO_CLOCK1, (clock >> 8) & 0xff);
984 saa_writeb(SAA7134_AUDIO_CLOCK2, (clock >> 16) & 0xff);
985
986 saa_writeb(SAA7134_AUDIO_PLL_CTRL, 0x01);
987 saa_writeb(SAA7134_NICAM_ERROR_LOW, 0x14);
988 saa_writeb(SAA7134_NICAM_ERROR_HIGH, 0x50);
989 break;
990 case PCI_DEVICE_ID_PHILIPS_SAA7133:
991 case PCI_DEVICE_ID_PHILIPS_SAA7135:
992 saa_writel(0x598 >> 2, clock);
993 saa_dsp_writel(dev, 0x474 >> 2, 0x00);
994 saa_dsp_writel(dev, 0x450 >> 2, 0x00);
995 }
996 }
997
998 int saa7134_tvaudio_init2(struct saa7134_dev *dev)
999 {
1000 int (*my_thread)(void *data) = NULL;
1001
1002 switch (dev->pci->device) {
1003 case PCI_DEVICE_ID_PHILIPS_SAA7134:
1004 my_thread = tvaudio_thread;
1005 break;
1006 case PCI_DEVICE_ID_PHILIPS_SAA7133:
1007 case PCI_DEVICE_ID_PHILIPS_SAA7135:
1008 my_thread = tvaudio_thread_ddep;
1009 break;
1010 }
1011
1012 dev->thread.thread = NULL;
1013 dev->thread.scan1 = dev->thread.scan2 = 0;
1014 if (my_thread) {
1015 saa7134_tvaudio_init(dev);
1016
1017 dev->thread.thread = kthread_run(my_thread, dev, "%s", dev->name);
1018 if (IS_ERR(dev->thread.thread)) {
1019 pr_warn("%s: kernel_thread() failed\n",
1020 dev->name);
1021
1022 }
1023 }
1024
1025 saa7134_enable_i2s(dev);
1026 return 0;
1027 }
1028
1029 int saa7134_tvaudio_close(struct saa7134_dev *dev)
1030 {
1031 dev->automute = 1;
1032
1033 return 0;
1034 }
1035
1036 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
1037 {
1038
1039 if (dev->thread.thread && !dev->thread.stopped)
1040 kthread_stop(dev->thread.thread);
1041
1042 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, 0x00);
1043 return 0;
1044 }
1045
1046 int saa7134_tvaudio_do_scan(struct saa7134_dev *dev)
1047 {
1048 if (dev->input->amux != TV) {
1049 audio_dbg(1, "sound IF not in use, skipping scan\n");
1050 dev->automute = 0;
1051 saa7134_tvaudio_setmute(dev);
1052 } else if (dev->thread.thread) {
1053 dev->thread.mode = UNSET;
1054 dev->thread.scan2++;
1055
1056 if (!dev->insuspend && !dev->thread.stopped)
1057 wake_up_process(dev->thread.thread);
1058 } else {
1059 dev->automute = 0;
1060 saa7134_tvaudio_setmute(dev);
1061 }
1062 return 0;
1063 }
1064
1065 EXPORT_SYMBOL(saa_dsp_writel);
1066 EXPORT_SYMBOL(saa7134_tvaudio_setmute);