1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/delay.h>
31#include <linux/init.h>
32#include <linux/interrupt.h>
33#include <linux/pci.h>
34#include <linux/slab.h>
35#include <linux/vmalloc.h>
36#include <linux/gameport.h>
37#include <linux/dma-mapping.h>
38#include <linux/export.h>
39#include <linux/io.h>
40
41#include <sound/core.h>
42#include <sound/info.h>
43#include <sound/control.h>
44#include <sound/tlv.h>
45#include "trident.h"
46#include <sound/asoundef.h>
47
48static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
49 struct snd_trident_voice * voice,
50 struct snd_pcm_substream *substream);
51static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
52 struct snd_trident_voice * voice,
53 struct snd_pcm_substream *substream);
54static irqreturn_t snd_trident_interrupt(int irq, void *dev_id);
55static int snd_trident_sis_reset(struct snd_trident *trident);
56
57static void snd_trident_clear_voices(struct snd_trident * trident,
58 unsigned short v_min, unsigned short v_max);
59static int snd_trident_free(struct snd_trident *trident);
60
61
62
63
64
65
66#if 0
67static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
68{
69 unsigned int val, tmp;
70
71 dev_dbg(trident->card->dev, "Trident voice %i:\n", voice);
72 outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
73 val = inl(TRID_REG(trident, CH_LBA));
74 dev_dbg(trident->card->dev, "LBA: 0x%x\n", val);
75 val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
76 dev_dbg(trident->card->dev, "GVSel: %i\n", val >> 31);
77 dev_dbg(trident->card->dev, "Pan: 0x%x\n", (val >> 24) & 0x7f);
78 dev_dbg(trident->card->dev, "Vol: 0x%x\n", (val >> 16) & 0xff);
79 dev_dbg(trident->card->dev, "CTRL: 0x%x\n", (val >> 12) & 0x0f);
80 dev_dbg(trident->card->dev, "EC: 0x%x\n", val & 0x0fff);
81 if (trident->device != TRIDENT_DEVICE_ID_NX) {
82 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
83 dev_dbg(trident->card->dev, "CSO: 0x%x\n", val >> 16);
84 dev_dbg(trident->card->dev, "Alpha: 0x%x\n", (val >> 4) & 0x0fff);
85 dev_dbg(trident->card->dev, "FMS: 0x%x\n", val & 0x0f);
86 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
87 dev_dbg(trident->card->dev, "ESO: 0x%x\n", val >> 16);
88 dev_dbg(trident->card->dev, "Delta: 0x%x\n", val & 0xffff);
89 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
90 } else {
91 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
92 tmp = (val >> 24) & 0xff;
93 dev_dbg(trident->card->dev, "CSO: 0x%x\n", val & 0x00ffffff);
94 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
95 tmp |= (val >> 16) & 0xff00;
96 dev_dbg(trident->card->dev, "Delta: 0x%x\n", tmp);
97 dev_dbg(trident->card->dev, "ESO: 0x%x\n", val & 0x00ffffff);
98 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
99 dev_dbg(trident->card->dev, "Alpha: 0x%x\n", val >> 20);
100 dev_dbg(trident->card->dev, "FMS: 0x%x\n", (val >> 16) & 0x0f);
101 }
102 dev_dbg(trident->card->dev, "FMC: 0x%x\n", (val >> 14) & 3);
103 dev_dbg(trident->card->dev, "RVol: 0x%x\n", (val >> 7) & 0x7f);
104 dev_dbg(trident->card->dev, "CVol: 0x%x\n", val & 0x7f);
105}
106#endif
107
108
109
110
111
112
113
114
115
116
117
118
119
120static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
121{
122 unsigned int data = 0, treg;
123 unsigned short count = 0xffff;
124 unsigned long flags;
125 struct snd_trident *trident = ac97->private_data;
126
127 spin_lock_irqsave(&trident->reg_lock, flags);
128 if (trident->device == TRIDENT_DEVICE_ID_DX) {
129 data = (DX_AC97_BUSY_READ | (reg & 0x000000ff));
130 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
131 do {
132 data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
133 if ((data & DX_AC97_BUSY_READ) == 0)
134 break;
135 } while (--count);
136 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
137 data = (NX_AC97_BUSY_READ | (reg & 0x000000ff));
138 treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY;
139 outl(data, TRID_REG(trident, treg));
140 do {
141 data = inl(TRID_REG(trident, treg));
142 if ((data & 0x00000C00) == 0)
143 break;
144 } while (--count);
145 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
146 data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
147 if (ac97->num == 1)
148 data |= SI_AC97_SECONDARY;
149 outl(data, TRID_REG(trident, SI_AC97_READ));
150 do {
151 data = inl(TRID_REG(trident, SI_AC97_READ));
152 if ((data & (SI_AC97_BUSY_READ)) == 0)
153 break;
154 } while (--count);
155 }
156
157 if (count == 0 && !trident->ac97_detect) {
158 dev_err(trident->card->dev,
159 "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
160 reg, data);
161 data = 0;
162 }
163
164 spin_unlock_irqrestore(&trident->reg_lock, flags);
165 return ((unsigned short) (data >> 16));
166}
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
183 unsigned short wdata)
184{
185 unsigned int address, data;
186 unsigned short count = 0xffff;
187 unsigned long flags;
188 struct snd_trident *trident = ac97->private_data;
189
190 data = ((unsigned long) wdata) << 16;
191
192 spin_lock_irqsave(&trident->reg_lock, flags);
193 if (trident->device == TRIDENT_DEVICE_ID_DX) {
194 address = DX_ACR0_AC97_W;
195
196
197 do {
198 if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
199 break;
200 } while (--count);
201
202 data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff));
203 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
204 address = NX_ACR1_AC97_W;
205
206
207 do {
208 if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
209 break;
210 } while (--count);
211
212 data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff));
213 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
214 address = SI_AC97_WRITE;
215
216
217 do {
218 if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
219 break;
220 } while (--count);
221
222 data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
223 if (ac97->num == 1)
224 data |= SI_AC97_SECONDARY;
225 } else {
226 address = 0;
227 count = 0;
228 }
229
230 if (count == 0) {
231 spin_unlock_irqrestore(&trident->reg_lock, flags);
232 return;
233 }
234 outl(data, TRID_REG(trident, address));
235 spin_unlock_irqrestore(&trident->reg_lock, flags);
236}
237
238
239
240
241
242
243
244
245
246
247
248
249
250static void snd_trident_enable_eso(struct snd_trident * trident)
251{
252 unsigned int val;
253
254 val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
255 val |= ENDLP_IE;
256 val |= MIDLP_IE;
257 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
258 val |= BANK_B_EN;
259 outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
260}
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277static void snd_trident_disable_eso(struct snd_trident * trident)
278{
279 unsigned int tmp;
280
281 tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
282 tmp &= ~ENDLP_IE;
283 tmp &= ~MIDLP_IE;
284 outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
285}
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
302{
303 unsigned int mask = 1 << (voice & 0x1f);
304 unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
305
306 outl(mask, TRID_REG(trident, reg));
307}
308
309EXPORT_SYMBOL(snd_trident_start_voice);
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
326{
327 unsigned int mask = 1 << (voice & 0x1f);
328 unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
329
330 outl(mask, TRID_REG(trident, reg));
331}
332
333EXPORT_SYMBOL(snd_trident_stop_voice);
334
335
336
337
338
339
340
341
342
343
344
345
346static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
347{
348 int idx;
349
350 if (trident->ChanPCMcnt >= trident->ChanPCM)
351 return -1;
352 for (idx = 31; idx >= 0; idx--) {
353 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
354 trident->ChanMap[T4D_BANK_B] |= 1 << idx;
355 trident->ChanPCMcnt++;
356 return idx + 32;
357 }
358 }
359 return -1;
360}
361
362
363
364
365
366
367
368
369
370
371
372
373
374static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
375{
376 if (channel < 32 || channel > 63)
377 return;
378 channel &= 0x1f;
379 if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
380 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
381 trident->ChanPCMcnt--;
382 }
383}
384
385
386
387
388
389
390
391
392
393
394
395
396static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
397{
398 int idx;
399
400 for (idx = 31; idx >= 0; idx--) {
401 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
402 trident->ChanMap[T4D_BANK_A] |= 1 << idx;
403 trident->synth.ChanSynthCount++;
404 return idx;
405 }
406 }
407 return -1;
408}
409
410
411
412
413
414
415
416
417
418
419
420
421
422static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
423{
424 if (channel < 0 || channel > 31)
425 return;
426 channel &= 0x1f;
427 if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
428 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
429 trident->synth.ChanSynthCount--;
430 }
431}
432
433
434
435
436
437
438
439
440
441
442
443
444
445void snd_trident_write_voice_regs(struct snd_trident * trident,
446 struct snd_trident_voice * voice)
447{
448 unsigned int FmcRvolCvol;
449 unsigned int regs[5];
450
451 regs[1] = voice->LBA;
452 regs[4] = (voice->GVSel << 31) |
453 ((voice->Pan & 0x0000007f) << 24) |
454 ((voice->CTRL & 0x0000000f) << 12);
455 FmcRvolCvol = ((voice->FMC & 3) << 14) |
456 ((voice->RVol & 0x7f) << 7) |
457 (voice->CVol & 0x7f);
458
459 switch (trident->device) {
460 case TRIDENT_DEVICE_ID_SI7018:
461 regs[4] |= voice->number > 31 ?
462 (voice->Vol & 0x000003ff) :
463 ((voice->Vol & 0x00003fc) << (16-2)) |
464 (voice->EC & 0x00000fff);
465 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
466 (voice->FMS & 0x0000000f);
467 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
468 regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
469 break;
470 case TRIDENT_DEVICE_ID_DX:
471 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
472 (voice->EC & 0x00000fff);
473 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
474 (voice->FMS & 0x0000000f);
475 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
476 regs[3] = FmcRvolCvol;
477 break;
478 case TRIDENT_DEVICE_ID_NX:
479 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
480 (voice->EC & 0x00000fff);
481 regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);
482 regs[2] = ((voice->Delta << 16) & 0xff000000) |
483 (voice->ESO & 0x00ffffff);
484 regs[3] = (voice->Alpha << 20) |
485 ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
486 break;
487 default:
488 snd_BUG();
489 return;
490 }
491
492 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
493 outl(regs[0], TRID_REG(trident, CH_START + 0));
494 outl(regs[1], TRID_REG(trident, CH_START + 4));
495 outl(regs[2], TRID_REG(trident, CH_START + 8));
496 outl(regs[3], TRID_REG(trident, CH_START + 12));
497 outl(regs[4], TRID_REG(trident, CH_START + 16));
498
499#if 0
500 dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
501 dev_dbg(trident->card->dev, " regs[0] = 0x%x/0x%x\n",
502 regs[0], inl(TRID_REG(trident, CH_START + 0)));
503 dev_dbg(trident->card->dev, " regs[1] = 0x%x/0x%x\n",
504 regs[1], inl(TRID_REG(trident, CH_START + 4)));
505 dev_dbg(trident->card->dev, " regs[2] = 0x%x/0x%x\n",
506 regs[2], inl(TRID_REG(trident, CH_START + 8)));
507 dev_dbg(trident->card->dev, " regs[3] = 0x%x/0x%x\n",
508 regs[3], inl(TRID_REG(trident, CH_START + 12)));
509 dev_dbg(trident->card->dev, " regs[4] = 0x%x/0x%x\n",
510 regs[4], inl(TRID_REG(trident, CH_START + 16)));
511#endif
512}
513
514EXPORT_SYMBOL(snd_trident_write_voice_regs);
515
516
517
518
519
520
521
522
523
524
525
526
527
528static void snd_trident_write_cso_reg(struct snd_trident * trident,
529 struct snd_trident_voice * voice,
530 unsigned int CSO)
531{
532 voice->CSO = CSO;
533 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
534 if (trident->device != TRIDENT_DEVICE_ID_NX) {
535 outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
536 } else {
537 outl((voice->Delta << 24) |
538 (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
539 }
540}
541
542
543
544
545
546
547
548
549
550
551
552
553
554static void snd_trident_write_eso_reg(struct snd_trident * trident,
555 struct snd_trident_voice * voice,
556 unsigned int ESO)
557{
558 voice->ESO = ESO;
559 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
560 if (trident->device != TRIDENT_DEVICE_ID_NX) {
561 outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
562 } else {
563 outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
564 TRID_REG(trident, CH_NX_DELTA_ESO));
565 }
566}
567
568
569
570
571
572
573
574
575
576
577
578
579
580static void snd_trident_write_vol_reg(struct snd_trident * trident,
581 struct snd_trident_voice * voice,
582 unsigned int Vol)
583{
584 voice->Vol = Vol;
585 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
586 switch (trident->device) {
587 case TRIDENT_DEVICE_ID_DX:
588 case TRIDENT_DEVICE_ID_NX:
589 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
590 break;
591 case TRIDENT_DEVICE_ID_SI7018:
592
593 outw((voice->CTRL << 12) | voice->Vol,
594 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
595 break;
596 }
597}
598
599
600
601
602
603
604
605
606
607
608
609
610
611static void snd_trident_write_pan_reg(struct snd_trident * trident,
612 struct snd_trident_voice * voice,
613 unsigned int Pan)
614{
615 voice->Pan = Pan;
616 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
617 outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
618 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
619}
620
621
622
623
624
625
626
627
628
629
630
631
632
633static void snd_trident_write_rvol_reg(struct snd_trident * trident,
634 struct snd_trident_voice * voice,
635 unsigned int RVol)
636{
637 voice->RVol = RVol;
638 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
639 outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
640 (voice->CVol & 0x007f),
641 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
642 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
643}
644
645
646
647
648
649
650
651
652
653
654
655
656
657static void snd_trident_write_cvol_reg(struct snd_trident * trident,
658 struct snd_trident_voice * voice,
659 unsigned int CVol)
660{
661 voice->CVol = CVol;
662 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
663 outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
664 (voice->CVol & 0x007f),
665 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
666 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
667}
668
669
670
671
672
673
674
675
676
677
678
679
680static unsigned int snd_trident_convert_rate(unsigned int rate)
681{
682 unsigned int delta;
683
684
685
686
687
688 if (rate == 44100)
689 delta = 0xeb3;
690 else if (rate == 8000)
691 delta = 0x2ab;
692 else if (rate == 48000)
693 delta = 0x1000;
694 else
695 delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff;
696 return delta;
697}
698
699
700
701
702
703
704
705
706
707
708
709
710static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
711{
712 unsigned int delta;
713
714
715
716
717
718 if (rate == 44100)
719 delta = 0x116a;
720 else if (rate == 8000)
721 delta = 0x6000;
722 else if (rate == 48000)
723 delta = 0x1000;
724 else
725 delta = ((48000 << 12) / rate) & 0x0000ffff;
726 return delta;
727}
728
729
730
731
732
733
734
735
736
737
738
739
740static unsigned int snd_trident_spurious_threshold(unsigned int rate,
741 unsigned int period_size)
742{
743 unsigned int res = (rate * period_size) / 48000;
744 if (res < 64)
745 res = res / 2;
746 else
747 res -= 32;
748 return res;
749}
750
751
752
753
754
755
756
757
758
759
760
761
762static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
763{
764 unsigned int CTRL;
765 struct snd_pcm_runtime *runtime = substream->runtime;
766
767
768
769
770 CTRL = 0x00000001;
771 if (snd_pcm_format_width(runtime->format) == 16)
772 CTRL |= 0x00000008;
773 if (snd_pcm_format_signed(runtime->format))
774 CTRL |= 0x00000002;
775 if (runtime->channels > 1)
776 CTRL |= 0x00000004;
777 return CTRL;
778}
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797static int snd_trident_ioctl(struct snd_pcm_substream *substream,
798 unsigned int cmd,
799 void *arg)
800{
801
802
803
804 return snd_pcm_lib_ioctl(substream, cmd, arg);
805}
806
807
808
809
810
811
812
813
814
815
816
817
818
819static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
820 struct snd_pcm_hw_params *hw_params)
821{
822 struct snd_trident *trident = snd_pcm_substream_chip(substream);
823 struct snd_pcm_runtime *runtime = substream->runtime;
824 struct snd_trident_voice *voice = runtime->private_data;
825 int err;
826
827 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
828 return err;
829 if (trident->tlb.entries) {
830 if (err > 0) {
831 if (voice->memblk)
832 snd_trident_free_pages(trident, voice->memblk);
833 voice->memblk = snd_trident_alloc_pages(trident, substream);
834 if (voice->memblk == NULL)
835 return -ENOMEM;
836 }
837 }
838 return 0;
839}
840
841
842
843
844
845
846
847
848
849
850
851
852
853static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
854 struct snd_pcm_hw_params *hw_params)
855{
856 struct snd_trident *trident = snd_pcm_substream_chip(substream);
857 struct snd_pcm_runtime *runtime = substream->runtime;
858 struct snd_trident_voice *voice = runtime->private_data;
859 struct snd_trident_voice *evoice = voice->extra;
860
861
862
863 if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) {
864 if (evoice == NULL) {
865 evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
866 if (evoice == NULL)
867 return -ENOMEM;
868 voice->extra = evoice;
869 evoice->substream = substream;
870 }
871 } else {
872 if (evoice != NULL) {
873 snd_trident_free_voice(trident, evoice);
874 voice->extra = evoice = NULL;
875 }
876 }
877
878 return 0;
879}
880
881
882
883
884
885
886
887
888
889
890
891
892
893static int snd_trident_hw_params(struct snd_pcm_substream *substream,
894 struct snd_pcm_hw_params *hw_params)
895{
896 int err;
897
898 err = snd_trident_allocate_pcm_mem(substream, hw_params);
899 if (err >= 0)
900 err = snd_trident_allocate_evoice(substream, hw_params);
901 return err;
902}
903
904
905
906
907
908
909
910
911
912
913
914
915static int snd_trident_hw_free(struct snd_pcm_substream *substream)
916{
917 struct snd_trident *trident = snd_pcm_substream_chip(substream);
918 struct snd_pcm_runtime *runtime = substream->runtime;
919 struct snd_trident_voice *voice = runtime->private_data;
920 struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
921
922 if (trident->tlb.entries) {
923 if (voice && voice->memblk) {
924 snd_trident_free_pages(trident, voice->memblk);
925 voice->memblk = NULL;
926 }
927 }
928 snd_pcm_lib_free_pages(substream);
929 if (evoice != NULL) {
930 snd_trident_free_voice(trident, evoice);
931 voice->extra = NULL;
932 }
933 return 0;
934}
935
936
937
938
939
940
941
942
943
944
945
946
947static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
948{
949 struct snd_trident *trident = snd_pcm_substream_chip(substream);
950 struct snd_pcm_runtime *runtime = substream->runtime;
951 struct snd_trident_voice *voice = runtime->private_data;
952 struct snd_trident_voice *evoice = voice->extra;
953 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
954
955 spin_lock_irq(&trident->reg_lock);
956
957
958 voice->Delta = snd_trident_convert_rate(runtime->rate);
959 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
960
961
962 if (voice->memblk)
963 voice->LBA = voice->memblk->offset;
964 else
965 voice->LBA = runtime->dma_addr;
966
967 voice->CSO = 0;
968 voice->ESO = runtime->buffer_size - 1;
969 voice->CTRL = snd_trident_control_mode(substream);
970 voice->FMC = 3;
971 voice->GVSel = 1;
972 voice->EC = 0;
973 voice->Alpha = 0;
974 voice->FMS = 0;
975 voice->Vol = mix->vol;
976 voice->RVol = mix->rvol;
977 voice->CVol = mix->cvol;
978 voice->Pan = mix->pan;
979 voice->Attribute = 0;
980#if 0
981 voice->Attribute = (1<<(30-16))|(2<<(26-16))|
982 (0<<(24-16))|(0x1f<<(19-16));
983#else
984 voice->Attribute = 0;
985#endif
986
987 snd_trident_write_voice_regs(trident, voice);
988
989 if (evoice != NULL) {
990 evoice->Delta = voice->Delta;
991 evoice->spurious_threshold = voice->spurious_threshold;
992 evoice->LBA = voice->LBA;
993 evoice->CSO = 0;
994 evoice->ESO = (runtime->period_size * 2) + 4 - 1;
995 evoice->CTRL = voice->CTRL;
996 evoice->FMC = 3;
997 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
998 evoice->EC = 0;
999 evoice->Alpha = 0;
1000 evoice->FMS = 0;
1001 evoice->Vol = 0x3ff;
1002 evoice->RVol = evoice->CVol = 0x7f;
1003 evoice->Pan = 0x7f;
1004#if 0
1005 evoice->Attribute = (1<<(30-16))|(2<<(26-16))|
1006 (0<<(24-16))|(0x1f<<(19-16));
1007#else
1008 evoice->Attribute = 0;
1009#endif
1010 snd_trident_write_voice_regs(trident, evoice);
1011 evoice->isync2 = 1;
1012 evoice->isync_mark = runtime->period_size;
1013 evoice->ESO = (runtime->period_size * 2) - 1;
1014 }
1015
1016 spin_unlock_irq(&trident->reg_lock);
1017
1018 return 0;
1019}
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
1034 struct snd_pcm_hw_params *hw_params)
1035{
1036 return snd_trident_allocate_pcm_mem(substream, hw_params);
1037}
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
1051{
1052 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1053 struct snd_pcm_runtime *runtime = substream->runtime;
1054 struct snd_trident_voice *voice = runtime->private_data;
1055 unsigned int val, ESO_bytes;
1056
1057 spin_lock_irq(&trident->reg_lock);
1058
1059
1060 outb(0, TRID_REG(trident, LEGACY_DMAR15));
1061
1062
1063 outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1064
1065
1066 voice->LBA = runtime->dma_addr;
1067 outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1068 if (voice->memblk)
1069 voice->LBA = voice->memblk->offset;
1070
1071
1072 ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1;
1073 outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1074 outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1075 ESO_bytes++;
1076
1077
1078 val = (((unsigned int) 48000L << 12) + (runtime->rate/2)) / runtime->rate;
1079 outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1080
1081
1082 if (snd_pcm_format_width(runtime->format) == 16) {
1083 val = (unsigned short) ((ESO_bytes >> 1) - 1);
1084 } else {
1085 val = (unsigned short) (ESO_bytes - 1);
1086 }
1087
1088 outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1089
1090
1091
1092 trident->bDMAStart = 0x19;
1093
1094 if (snd_pcm_format_width(runtime->format) == 16)
1095 trident->bDMAStart |= 0x80;
1096 if (snd_pcm_format_signed(runtime->format))
1097 trident->bDMAStart |= 0x20;
1098 if (runtime->channels > 1)
1099 trident->bDMAStart |= 0x40;
1100
1101
1102
1103 voice->Delta = snd_trident_convert_rate(runtime->rate);
1104 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1105 voice->isync = 1;
1106 voice->isync_mark = runtime->period_size;
1107 voice->isync_max = runtime->buffer_size;
1108
1109
1110 voice->CSO = 0;
1111 voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1112 voice->CTRL = snd_trident_control_mode(substream);
1113 voice->FMC = 3;
1114 voice->RVol = 0x7f;
1115 voice->CVol = 0x7f;
1116 voice->GVSel = 1;
1117 voice->Pan = 0x7f;
1118 voice->Vol = 0x3ff;
1119 voice->EC = 0;
1120 voice->Alpha = 0;
1121 voice->FMS = 0;
1122 voice->Attribute = 0;
1123
1124 snd_trident_write_voice_regs(trident, voice);
1125
1126 spin_unlock_irq(&trident->reg_lock);
1127 return 0;
1128}
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
1143 struct snd_pcm_hw_params *hw_params)
1144{
1145 int err;
1146
1147 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
1148 return err;
1149
1150 return snd_trident_allocate_evoice(substream, hw_params);
1151}
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
1165{
1166 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1167 struct snd_pcm_runtime *runtime = substream->runtime;
1168 struct snd_trident_voice *voice = runtime->private_data;
1169 struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
1170
1171 snd_pcm_lib_free_pages(substream);
1172 if (evoice != NULL) {
1173 snd_trident_free_voice(trident, evoice);
1174 voice->extra = NULL;
1175 }
1176 return 0;
1177}
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
1191{
1192 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1193 struct snd_pcm_runtime *runtime = substream->runtime;
1194 struct snd_trident_voice *voice = runtime->private_data;
1195 struct snd_trident_voice *evoice = voice->extra;
1196
1197 spin_lock_irq(&trident->reg_lock);
1198
1199 voice->LBA = runtime->dma_addr;
1200 voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
1201 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1202
1203
1204 voice->CSO = 0;
1205 voice->ESO = runtime->buffer_size - 1;
1206 voice->CTRL = snd_trident_control_mode(substream);
1207 voice->FMC = 0;
1208 voice->RVol = 0;
1209 voice->CVol = 0;
1210 voice->GVSel = 1;
1211 voice->Pan = T4D_DEFAULT_PCM_PAN;
1212 voice->Vol = 0;
1213 voice->EC = 0;
1214 voice->Alpha = 0;
1215 voice->FMS = 0;
1216
1217 voice->Attribute = (2 << (30-16)) |
1218 (2 << (26-16)) |
1219 (2 << (24-16)) |
1220 (1 << (23-16));
1221
1222 snd_trident_write_voice_regs(trident, voice);
1223
1224 if (evoice != NULL) {
1225 evoice->Delta = snd_trident_convert_rate(runtime->rate);
1226 evoice->spurious_threshold = voice->spurious_threshold;
1227 evoice->LBA = voice->LBA;
1228 evoice->CSO = 0;
1229 evoice->ESO = (runtime->period_size * 2) + 20 - 1;
1230 evoice->CTRL = voice->CTRL;
1231 evoice->FMC = 3;
1232 evoice->GVSel = 0;
1233 evoice->EC = 0;
1234 evoice->Alpha = 0;
1235 evoice->FMS = 0;
1236 evoice->Vol = 0x3ff;
1237 evoice->RVol = evoice->CVol = 0x7f;
1238 evoice->Pan = 0x7f;
1239 evoice->Attribute = 0;
1240 snd_trident_write_voice_regs(trident, evoice);
1241 evoice->isync2 = 1;
1242 evoice->isync_mark = runtime->period_size;
1243 evoice->ESO = (runtime->period_size * 2) - 1;
1244 }
1245
1246 spin_unlock_irq(&trident->reg_lock);
1247 return 0;
1248}
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
1262{
1263 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1264 struct snd_pcm_runtime *runtime = substream->runtime;
1265 struct snd_trident_voice *voice = runtime->private_data;
1266 struct snd_trident_voice *evoice = voice->extra;
1267
1268 spin_lock_irq(&trident->reg_lock);
1269
1270
1271 if (voice->memblk)
1272 voice->LBA = voice->memblk->offset;
1273 else
1274 voice->LBA = runtime->dma_addr;
1275
1276
1277 voice->ESO = runtime->buffer_size - 1;
1278
1279
1280 voice->Delta = 0x1000;
1281 voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1282
1283 voice->CSO = 0;
1284 voice->CTRL = snd_trident_control_mode(substream);
1285 voice->FMC = 3;
1286 voice->RVol = 0x7f;
1287 voice->CVol = 0x7f;
1288 voice->GVSel = 1;
1289 voice->Pan = 0x7f;
1290 voice->Vol = 0x3ff;
1291 voice->EC = 0;
1292 voice->Alpha = 0;
1293 voice->FMS = 0;
1294 voice->Attribute = 0;
1295
1296
1297 outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1298
1299 snd_trident_write_voice_regs(trident, voice);
1300
1301 if (evoice != NULL) {
1302 evoice->Delta = voice->Delta;
1303 evoice->spurious_threshold = voice->spurious_threshold;
1304 evoice->LBA = voice->LBA;
1305 evoice->CSO = 0;
1306 evoice->ESO = (runtime->period_size * 2) + 4 - 1;
1307 evoice->CTRL = voice->CTRL;
1308 evoice->FMC = 3;
1309 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1310 evoice->EC = 0;
1311 evoice->Alpha = 0;
1312 evoice->FMS = 0;
1313 evoice->Vol = 0x3ff;
1314 evoice->RVol = evoice->CVol = 0x7f;
1315 evoice->Pan = 0x7f;
1316 evoice->Attribute = 0;
1317 snd_trident_write_voice_regs(trident, evoice);
1318 evoice->isync2 = 1;
1319 evoice->isync_mark = runtime->period_size;
1320 evoice->ESO = (runtime->period_size * 2) - 1;
1321 }
1322
1323 spin_unlock_irq(&trident->reg_lock);
1324 return 0;
1325}
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
1340 struct snd_pcm_hw_params *hw_params)
1341{
1342 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1343 unsigned int old_bits = 0, change = 0;
1344 int err;
1345
1346 err = snd_trident_allocate_pcm_mem(substream, hw_params);
1347 if (err < 0)
1348 return err;
1349
1350 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1351 err = snd_trident_allocate_evoice(substream, hw_params);
1352 if (err < 0)
1353 return err;
1354 }
1355
1356
1357 spin_lock_irq(&trident->reg_lock);
1358 old_bits = trident->spdif_pcm_bits;
1359 if (old_bits & IEC958_AES0_PROFESSIONAL)
1360 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1361 else
1362 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1363 if (params_rate(hw_params) >= 48000) {
1364 trident->spdif_pcm_ctrl = 0x3c;
1365 trident->spdif_pcm_bits |=
1366 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1367 IEC958_AES0_PRO_FS_48000 :
1368 (IEC958_AES3_CON_FS_48000 << 24);
1369 }
1370 else if (params_rate(hw_params) >= 44100) {
1371 trident->spdif_pcm_ctrl = 0x3e;
1372 trident->spdif_pcm_bits |=
1373 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1374 IEC958_AES0_PRO_FS_44100 :
1375 (IEC958_AES3_CON_FS_44100 << 24);
1376 }
1377 else {
1378 trident->spdif_pcm_ctrl = 0x3d;
1379 trident->spdif_pcm_bits |=
1380 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1381 IEC958_AES0_PRO_FS_32000 :
1382 (IEC958_AES3_CON_FS_32000 << 24);
1383 }
1384 change = old_bits != trident->spdif_pcm_bits;
1385 spin_unlock_irq(&trident->reg_lock);
1386
1387 if (change)
1388 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1389
1390 return 0;
1391}
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
1405{
1406 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1407 struct snd_pcm_runtime *runtime = substream->runtime;
1408 struct snd_trident_voice *voice = runtime->private_data;
1409 struct snd_trident_voice *evoice = voice->extra;
1410 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1411 unsigned int RESO, LBAO;
1412 unsigned int temp;
1413
1414 spin_lock_irq(&trident->reg_lock);
1415
1416 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1417
1418
1419 voice->Delta = snd_trident_convert_rate(runtime->rate);
1420 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1421
1422
1423 LBAO = runtime->dma_addr;
1424 if (voice->memblk)
1425 voice->LBA = voice->memblk->offset;
1426 else
1427 voice->LBA = LBAO;
1428
1429 voice->isync = 1;
1430 voice->isync3 = 1;
1431 voice->isync_mark = runtime->period_size;
1432 voice->isync_max = runtime->buffer_size;
1433
1434
1435 RESO = runtime->buffer_size - 1;
1436 voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1437
1438
1439 voice->CTRL = snd_trident_control_mode(substream);
1440
1441 voice->FMC = 3;
1442 voice->RVol = 0x7f;
1443 voice->CVol = 0x7f;
1444 voice->GVSel = 1;
1445 voice->Pan = 0x7f;
1446 voice->Vol = 0x3ff;
1447 voice->EC = 0;
1448 voice->CSO = 0;
1449 voice->Alpha = 0;
1450 voice->FMS = 0;
1451 voice->Attribute = 0;
1452
1453
1454 snd_trident_write_voice_regs(trident, voice);
1455
1456 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1457 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1458 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1459 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1460 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1461
1462
1463 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1464 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1465
1466 } else {
1467
1468
1469 voice->Delta = 0x800;
1470 voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1471
1472
1473 if (voice->memblk)
1474 voice->LBA = voice->memblk->offset;
1475 else
1476 voice->LBA = runtime->dma_addr;
1477
1478 voice->CSO = 0;
1479 voice->ESO = runtime->buffer_size - 1;
1480 voice->CTRL = snd_trident_control_mode(substream);
1481 voice->FMC = 3;
1482 voice->GVSel = 1;
1483 voice->EC = 0;
1484 voice->Alpha = 0;
1485 voice->FMS = 0;
1486 voice->Vol = mix->vol;
1487 voice->RVol = mix->rvol;
1488 voice->CVol = mix->cvol;
1489 voice->Pan = mix->pan;
1490 voice->Attribute = (1<<(30-16))|(7<<(26-16))|
1491 (0<<(24-16))|(0<<(19-16));
1492
1493 snd_trident_write_voice_regs(trident, voice);
1494
1495 if (evoice != NULL) {
1496 evoice->Delta = voice->Delta;
1497 evoice->spurious_threshold = voice->spurious_threshold;
1498 evoice->LBA = voice->LBA;
1499 evoice->CSO = 0;
1500 evoice->ESO = (runtime->period_size * 2) + 4 - 1;
1501 evoice->CTRL = voice->CTRL;
1502 evoice->FMC = 3;
1503 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1504 evoice->EC = 0;
1505 evoice->Alpha = 0;
1506 evoice->FMS = 0;
1507 evoice->Vol = 0x3ff;
1508 evoice->RVol = evoice->CVol = 0x7f;
1509 evoice->Pan = 0x7f;
1510 evoice->Attribute = 0;
1511 snd_trident_write_voice_regs(trident, evoice);
1512 evoice->isync2 = 1;
1513 evoice->isync_mark = runtime->period_size;
1514 evoice->ESO = (runtime->period_size * 2) - 1;
1515 }
1516
1517 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1518 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1519 temp &= ~(1<<19);
1520 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1521 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1522 temp |= SPDIF_EN;
1523 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1524 }
1525
1526 spin_unlock_irq(&trident->reg_lock);
1527
1528 return 0;
1529}
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543static int snd_trident_trigger(struct snd_pcm_substream *substream,
1544 int cmd)
1545
1546{
1547 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1548 struct snd_pcm_substream *s;
1549 unsigned int what, whati, capture_flag, spdif_flag;
1550 struct snd_trident_voice *voice, *evoice;
1551 unsigned int val, go;
1552
1553 switch (cmd) {
1554 case SNDRV_PCM_TRIGGER_START:
1555 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1556 case SNDRV_PCM_TRIGGER_RESUME:
1557 go = 1;
1558 break;
1559 case SNDRV_PCM_TRIGGER_STOP:
1560 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1561 case SNDRV_PCM_TRIGGER_SUSPEND:
1562 go = 0;
1563 break;
1564 default:
1565 return -EINVAL;
1566 }
1567 what = whati = capture_flag = spdif_flag = 0;
1568 spin_lock(&trident->reg_lock);
1569 val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1570 snd_pcm_group_for_each_entry(s, substream) {
1571 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1572 voice = s->runtime->private_data;
1573 evoice = voice->extra;
1574 what |= 1 << (voice->number & 0x1f);
1575 if (evoice == NULL) {
1576 whati |= 1 << (voice->number & 0x1f);
1577 } else {
1578 what |= 1 << (evoice->number & 0x1f);
1579 whati |= 1 << (evoice->number & 0x1f);
1580 if (go)
1581 evoice->stimer = val;
1582 }
1583 if (go) {
1584 voice->running = 1;
1585 voice->stimer = val;
1586 } else {
1587 voice->running = 0;
1588 }
1589 snd_pcm_trigger_done(s, substream);
1590 if (voice->capture)
1591 capture_flag = 1;
1592 if (voice->spdif)
1593 spdif_flag = 1;
1594 }
1595 }
1596 if (spdif_flag) {
1597 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1598 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1599 val = trident->spdif_pcm_ctrl;
1600 if (!go)
1601 val &= ~(0x28);
1602 outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1603 } else {
1604 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1605 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1606 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1607 }
1608 }
1609 if (!go)
1610 outl(what, TRID_REG(trident, T4D_STOP_B));
1611 val = inl(TRID_REG(trident, T4D_AINTEN_B));
1612 if (go) {
1613 val |= whati;
1614 } else {
1615 val &= ~whati;
1616 }
1617 outl(val, TRID_REG(trident, T4D_AINTEN_B));
1618 if (go) {
1619 outl(what, TRID_REG(trident, T4D_START_B));
1620
1621 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1622 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1623 } else {
1624 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1625 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1626 }
1627 spin_unlock(&trident->reg_lock);
1628 return 0;
1629}
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
1643{
1644 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1645 struct snd_pcm_runtime *runtime = substream->runtime;
1646 struct snd_trident_voice *voice = runtime->private_data;
1647 unsigned int cso;
1648
1649 if (!voice->running)
1650 return 0;
1651
1652 spin_lock(&trident->reg_lock);
1653
1654 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1655
1656 if (trident->device != TRIDENT_DEVICE_ID_NX) {
1657 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1658 } else {
1659 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1660 }
1661
1662 spin_unlock(&trident->reg_lock);
1663
1664 if (cso >= runtime->buffer_size)
1665 cso = 0;
1666
1667 return cso;
1668}
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
1682{
1683 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1684 struct snd_pcm_runtime *runtime = substream->runtime;
1685 struct snd_trident_voice *voice = runtime->private_data;
1686 unsigned int result;
1687
1688 if (!voice->running)
1689 return 0;
1690
1691 result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1692 if (runtime->channels > 1)
1693 result >>= 1;
1694 if (result > 0)
1695 result = runtime->buffer_size - result;
1696
1697 return result;
1698}
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
1712{
1713 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1714 struct snd_pcm_runtime *runtime = substream->runtime;
1715 struct snd_trident_voice *voice = runtime->private_data;
1716 unsigned int result;
1717
1718 if (!voice->running)
1719 return 0;
1720
1721 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1722
1723 return result;
1724}
1725
1726
1727
1728
1729
1730static const struct snd_pcm_hardware snd_trident_playback =
1731{
1732 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1733 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1734 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1735 SNDRV_PCM_INFO_PAUSE ),
1736 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1737 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1738 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1739 .rate_min = 4000,
1740 .rate_max = 48000,
1741 .channels_min = 1,
1742 .channels_max = 2,
1743 .buffer_bytes_max = (256*1024),
1744 .period_bytes_min = 64,
1745 .period_bytes_max = (256*1024),
1746 .periods_min = 1,
1747 .periods_max = 1024,
1748 .fifo_size = 0,
1749};
1750
1751
1752
1753
1754
1755static const struct snd_pcm_hardware snd_trident_capture =
1756{
1757 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1758 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1759 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1760 SNDRV_PCM_INFO_PAUSE ),
1761 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1762 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1763 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1764 .rate_min = 4000,
1765 .rate_max = 48000,
1766 .channels_min = 1,
1767 .channels_max = 2,
1768 .buffer_bytes_max = (128*1024),
1769 .period_bytes_min = 64,
1770 .period_bytes_max = (128*1024),
1771 .periods_min = 1,
1772 .periods_max = 1024,
1773 .fifo_size = 0,
1774};
1775
1776
1777
1778
1779
1780static const struct snd_pcm_hardware snd_trident_foldback =
1781{
1782 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1783 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1784 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1785 SNDRV_PCM_INFO_PAUSE ),
1786 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1787 .rates = SNDRV_PCM_RATE_48000,
1788 .rate_min = 48000,
1789 .rate_max = 48000,
1790 .channels_min = 2,
1791 .channels_max = 2,
1792 .buffer_bytes_max = (128*1024),
1793 .period_bytes_min = 64,
1794 .period_bytes_max = (128*1024),
1795 .periods_min = 1,
1796 .periods_max = 1024,
1797 .fifo_size = 0,
1798};
1799
1800
1801
1802
1803
1804static const struct snd_pcm_hardware snd_trident_spdif =
1805{
1806 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1807 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1808 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1809 SNDRV_PCM_INFO_PAUSE ),
1810 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1811 .rates = (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
1812 SNDRV_PCM_RATE_48000),
1813 .rate_min = 32000,
1814 .rate_max = 48000,
1815 .channels_min = 2,
1816 .channels_max = 2,
1817 .buffer_bytes_max = (128*1024),
1818 .period_bytes_min = 64,
1819 .period_bytes_max = (128*1024),
1820 .periods_min = 1,
1821 .periods_max = 1024,
1822 .fifo_size = 0,
1823};
1824
1825static const struct snd_pcm_hardware snd_trident_spdif_7018 =
1826{
1827 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1828 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1829 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1830 SNDRV_PCM_INFO_PAUSE ),
1831 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1832 .rates = SNDRV_PCM_RATE_48000,
1833 .rate_min = 48000,
1834 .rate_max = 48000,
1835 .channels_min = 2,
1836 .channels_max = 2,
1837 .buffer_bytes_max = (128*1024),
1838 .period_bytes_min = 64,
1839 .period_bytes_max = (128*1024),
1840 .periods_min = 1,
1841 .periods_max = 1024,
1842 .fifo_size = 0,
1843};
1844
1845static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
1846{
1847 struct snd_trident_voice *voice = runtime->private_data;
1848 struct snd_trident *trident;
1849
1850 if (voice) {
1851 trident = voice->trident;
1852 snd_trident_free_voice(trident, voice);
1853 }
1854}
1855
1856static int snd_trident_playback_open(struct snd_pcm_substream *substream)
1857{
1858 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1859 struct snd_pcm_runtime *runtime = substream->runtime;
1860 struct snd_trident_voice *voice;
1861
1862 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1863 if (voice == NULL)
1864 return -EAGAIN;
1865 snd_trident_pcm_mixer_build(trident, voice, substream);
1866 voice->substream = substream;
1867 runtime->private_data = voice;
1868 runtime->private_free = snd_trident_pcm_free_substream;
1869 runtime->hw = snd_trident_playback;
1870 snd_pcm_set_sync(substream);
1871 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1872 return 0;
1873}
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884static int snd_trident_playback_close(struct snd_pcm_substream *substream)
1885{
1886 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1887 struct snd_pcm_runtime *runtime = substream->runtime;
1888 struct snd_trident_voice *voice = runtime->private_data;
1889
1890 snd_trident_pcm_mixer_free(trident, voice, substream);
1891 return 0;
1892}
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
1906{
1907 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1908 struct snd_trident_voice *voice;
1909 struct snd_pcm_runtime *runtime = substream->runtime;
1910
1911 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1912 if (voice == NULL)
1913 return -EAGAIN;
1914 voice->spdif = 1;
1915 voice->substream = substream;
1916 spin_lock_irq(&trident->reg_lock);
1917 trident->spdif_pcm_bits = trident->spdif_bits;
1918 spin_unlock_irq(&trident->reg_lock);
1919
1920 runtime->private_data = voice;
1921 runtime->private_free = snd_trident_pcm_free_substream;
1922 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1923 runtime->hw = snd_trident_spdif;
1924 } else {
1925 runtime->hw = snd_trident_spdif_7018;
1926 }
1927
1928 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1929 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1930 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1931
1932 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1933 return 0;
1934}
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
1947{
1948 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1949 unsigned int temp;
1950
1951 spin_lock_irq(&trident->reg_lock);
1952
1953 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1954 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1955 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1956 } else {
1957 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1958 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1959 if (trident->spdif_ctrl) {
1960 temp |= SPDIF_EN;
1961 } else {
1962 temp &= ~SPDIF_EN;
1963 }
1964 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1965 }
1966 spin_unlock_irq(&trident->reg_lock);
1967 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1968 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1969 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1970 return 0;
1971}
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984static int snd_trident_capture_open(struct snd_pcm_substream *substream)
1985{
1986 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1987 struct snd_trident_voice *voice;
1988 struct snd_pcm_runtime *runtime = substream->runtime;
1989
1990 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1991 if (voice == NULL)
1992 return -EAGAIN;
1993 voice->capture = 1;
1994 voice->substream = substream;
1995 runtime->private_data = voice;
1996 runtime->private_free = snd_trident_pcm_free_substream;
1997 runtime->hw = snd_trident_capture;
1998 snd_pcm_set_sync(substream);
1999 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
2000 return 0;
2001}
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012static int snd_trident_capture_close(struct snd_pcm_substream *substream)
2013{
2014 return 0;
2015}
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
2029{
2030 struct snd_trident *trident = snd_pcm_substream_chip(substream);
2031 struct snd_trident_voice *voice;
2032 struct snd_pcm_runtime *runtime = substream->runtime;
2033
2034 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
2035 if (voice == NULL)
2036 return -EAGAIN;
2037 voice->foldback_chan = substream->number;
2038 voice->substream = substream;
2039 runtime->private_data = voice;
2040 runtime->private_free = snd_trident_pcm_free_substream;
2041 runtime->hw = snd_trident_foldback;
2042 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
2043 return 0;
2044}
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
2056{
2057 struct snd_trident *trident = snd_pcm_substream_chip(substream);
2058 struct snd_trident_voice *voice;
2059 struct snd_pcm_runtime *runtime = substream->runtime;
2060 voice = runtime->private_data;
2061
2062
2063 spin_lock_irq(&trident->reg_lock);
2064 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2065 spin_unlock_irq(&trident->reg_lock);
2066 return 0;
2067}
2068
2069
2070
2071
2072
2073static const struct snd_pcm_ops snd_trident_playback_ops = {
2074 .open = snd_trident_playback_open,
2075 .close = snd_trident_playback_close,
2076 .ioctl = snd_trident_ioctl,
2077 .hw_params = snd_trident_hw_params,
2078 .hw_free = snd_trident_hw_free,
2079 .prepare = snd_trident_playback_prepare,
2080 .trigger = snd_trident_trigger,
2081 .pointer = snd_trident_playback_pointer,
2082};
2083
2084static const struct snd_pcm_ops snd_trident_nx_playback_ops = {
2085 .open = snd_trident_playback_open,
2086 .close = snd_trident_playback_close,
2087 .ioctl = snd_trident_ioctl,
2088 .hw_params = snd_trident_hw_params,
2089 .hw_free = snd_trident_hw_free,
2090 .prepare = snd_trident_playback_prepare,
2091 .trigger = snd_trident_trigger,
2092 .pointer = snd_trident_playback_pointer,
2093 .page = snd_pcm_sgbuf_ops_page,
2094};
2095
2096static const struct snd_pcm_ops snd_trident_capture_ops = {
2097 .open = snd_trident_capture_open,
2098 .close = snd_trident_capture_close,
2099 .ioctl = snd_trident_ioctl,
2100 .hw_params = snd_trident_capture_hw_params,
2101 .hw_free = snd_trident_hw_free,
2102 .prepare = snd_trident_capture_prepare,
2103 .trigger = snd_trident_trigger,
2104 .pointer = snd_trident_capture_pointer,
2105};
2106
2107static const struct snd_pcm_ops snd_trident_si7018_capture_ops = {
2108 .open = snd_trident_capture_open,
2109 .close = snd_trident_capture_close,
2110 .ioctl = snd_trident_ioctl,
2111 .hw_params = snd_trident_si7018_capture_hw_params,
2112 .hw_free = snd_trident_si7018_capture_hw_free,
2113 .prepare = snd_trident_si7018_capture_prepare,
2114 .trigger = snd_trident_trigger,
2115 .pointer = snd_trident_playback_pointer,
2116};
2117
2118static const struct snd_pcm_ops snd_trident_foldback_ops = {
2119 .open = snd_trident_foldback_open,
2120 .close = snd_trident_foldback_close,
2121 .ioctl = snd_trident_ioctl,
2122 .hw_params = snd_trident_hw_params,
2123 .hw_free = snd_trident_hw_free,
2124 .prepare = snd_trident_foldback_prepare,
2125 .trigger = snd_trident_trigger,
2126 .pointer = snd_trident_playback_pointer,
2127};
2128
2129static const struct snd_pcm_ops snd_trident_nx_foldback_ops = {
2130 .open = snd_trident_foldback_open,
2131 .close = snd_trident_foldback_close,
2132 .ioctl = snd_trident_ioctl,
2133 .hw_params = snd_trident_hw_params,
2134 .hw_free = snd_trident_hw_free,
2135 .prepare = snd_trident_foldback_prepare,
2136 .trigger = snd_trident_trigger,
2137 .pointer = snd_trident_playback_pointer,
2138 .page = snd_pcm_sgbuf_ops_page,
2139};
2140
2141static const struct snd_pcm_ops snd_trident_spdif_ops = {
2142 .open = snd_trident_spdif_open,
2143 .close = snd_trident_spdif_close,
2144 .ioctl = snd_trident_ioctl,
2145 .hw_params = snd_trident_spdif_hw_params,
2146 .hw_free = snd_trident_hw_free,
2147 .prepare = snd_trident_spdif_prepare,
2148 .trigger = snd_trident_trigger,
2149 .pointer = snd_trident_spdif_pointer,
2150};
2151
2152static const struct snd_pcm_ops snd_trident_spdif_7018_ops = {
2153 .open = snd_trident_spdif_open,
2154 .close = snd_trident_spdif_close,
2155 .ioctl = snd_trident_ioctl,
2156 .hw_params = snd_trident_spdif_hw_params,
2157 .hw_free = snd_trident_hw_free,
2158 .prepare = snd_trident_spdif_prepare,
2159 .trigger = snd_trident_trigger,
2160 .pointer = snd_trident_playback_pointer,
2161};
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174int snd_trident_pcm(struct snd_trident *trident, int device)
2175{
2176 struct snd_pcm *pcm;
2177 int err;
2178
2179 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
2180 return err;
2181
2182 pcm->private_data = trident;
2183
2184 if (trident->tlb.entries) {
2185 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
2186 } else {
2187 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops);
2188 }
2189 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
2190 trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2191 &snd_trident_capture_ops :
2192 &snd_trident_si7018_capture_ops);
2193
2194 pcm->info_flags = 0;
2195 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
2196 strcpy(pcm->name, "Trident 4DWave");
2197 trident->pcm = pcm;
2198
2199 if (trident->tlb.entries) {
2200 struct snd_pcm_substream *substream;
2201 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
2202 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
2203 snd_dma_pci_data(trident->pci),
2204 64*1024, 128*1024);
2205 snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
2206 SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
2207 64*1024, 128*1024);
2208 } else {
2209 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
2210 snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2211 }
2212
2213 return 0;
2214}
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
2228{
2229 struct snd_pcm *foldback;
2230 int err;
2231 int num_chan = 3;
2232 struct snd_pcm_substream *substream;
2233
2234 if (trident->device == TRIDENT_DEVICE_ID_NX)
2235 num_chan = 4;
2236 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
2237 return err;
2238
2239 foldback->private_data = trident;
2240 if (trident->tlb.entries)
2241 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
2242 else
2243 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops);
2244 foldback->info_flags = 0;
2245 strcpy(foldback->name, "Trident 4DWave");
2246 substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
2247 strcpy(substream->name, "Front Mixer");
2248 substream = substream->next;
2249 strcpy(substream->name, "Reverb Mixer");
2250 substream = substream->next;
2251 strcpy(substream->name, "Chorus Mixer");
2252 if (num_chan == 4) {
2253 substream = substream->next;
2254 strcpy(substream->name, "Second AC'97 ADC");
2255 }
2256 trident->foldback = foldback;
2257
2258 if (trident->tlb.entries)
2259 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
2260 snd_dma_pci_data(trident->pci), 0, 128*1024);
2261 else
2262 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
2263 snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2264
2265 return 0;
2266}
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
2280{
2281 struct snd_pcm *spdif;
2282 int err;
2283
2284 if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
2285 return err;
2286
2287 spdif->private_data = trident;
2288 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2289 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
2290 } else {
2291 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops);
2292 }
2293 spdif->info_flags = 0;
2294 strcpy(spdif->name, "Trident 4DWave IEC958");
2295 trident->spdif = spdif;
2296
2297 snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2298
2299 return 0;
2300}
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313#define snd_trident_spdif_control_info snd_ctl_boolean_mono_info
2314
2315static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
2316 struct snd_ctl_elem_value *ucontrol)
2317{
2318 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2319 unsigned char val;
2320
2321 spin_lock_irq(&trident->reg_lock);
2322 val = trident->spdif_ctrl;
2323 ucontrol->value.integer.value[0] = val == kcontrol->private_value;
2324 spin_unlock_irq(&trident->reg_lock);
2325 return 0;
2326}
2327
2328static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
2329 struct snd_ctl_elem_value *ucontrol)
2330{
2331 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2332 unsigned char val;
2333 int change;
2334
2335 val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
2336 spin_lock_irq(&trident->reg_lock);
2337
2338 change = trident->spdif_ctrl != val;
2339 trident->spdif_ctrl = val;
2340 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2341 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2342 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2343 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2344 }
2345 } else {
2346 if (trident->spdif == NULL) {
2347 unsigned int temp;
2348 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2349 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2350 if (val)
2351 temp |= SPDIF_EN;
2352 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2353 }
2354 }
2355 spin_unlock_irq(&trident->reg_lock);
2356 return change;
2357}
2358
2359static const struct snd_kcontrol_new snd_trident_spdif_control =
2360{
2361 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2362 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2363 .info = snd_trident_spdif_control_info,
2364 .get = snd_trident_spdif_control_get,
2365 .put = snd_trident_spdif_control_put,
2366 .private_value = 0x28,
2367};
2368
2369
2370
2371
2372
2373
2374
2375static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
2376 struct snd_ctl_elem_info *uinfo)
2377{
2378 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2379 uinfo->count = 1;
2380 return 0;
2381}
2382
2383static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
2384 struct snd_ctl_elem_value *ucontrol)
2385{
2386 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2387
2388 spin_lock_irq(&trident->reg_lock);
2389 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2390 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2391 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2392 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2393 spin_unlock_irq(&trident->reg_lock);
2394 return 0;
2395}
2396
2397static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
2398 struct snd_ctl_elem_value *ucontrol)
2399{
2400 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2401 unsigned int val;
2402 int change;
2403
2404 val = (ucontrol->value.iec958.status[0] << 0) |
2405 (ucontrol->value.iec958.status[1] << 8) |
2406 (ucontrol->value.iec958.status[2] << 16) |
2407 (ucontrol->value.iec958.status[3] << 24);
2408 spin_lock_irq(&trident->reg_lock);
2409 change = trident->spdif_bits != val;
2410 trident->spdif_bits = val;
2411 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2412 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2413 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2414 } else {
2415 if (trident->spdif == NULL)
2416 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2417 }
2418 spin_unlock_irq(&trident->reg_lock);
2419 return change;
2420}
2421
2422static const struct snd_kcontrol_new snd_trident_spdif_default =
2423{
2424 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2425 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2426 .info = snd_trident_spdif_default_info,
2427 .get = snd_trident_spdif_default_get,
2428 .put = snd_trident_spdif_default_put
2429};
2430
2431
2432
2433
2434
2435
2436
2437static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
2438 struct snd_ctl_elem_info *uinfo)
2439{
2440 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2441 uinfo->count = 1;
2442 return 0;
2443}
2444
2445static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
2446 struct snd_ctl_elem_value *ucontrol)
2447{
2448 ucontrol->value.iec958.status[0] = 0xff;
2449 ucontrol->value.iec958.status[1] = 0xff;
2450 ucontrol->value.iec958.status[2] = 0xff;
2451 ucontrol->value.iec958.status[3] = 0xff;
2452 return 0;
2453}
2454
2455static const struct snd_kcontrol_new snd_trident_spdif_mask =
2456{
2457 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2458 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2459 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
2460 .info = snd_trident_spdif_mask_info,
2461 .get = snd_trident_spdif_mask_get,
2462};
2463
2464
2465
2466
2467
2468
2469
2470static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
2471 struct snd_ctl_elem_info *uinfo)
2472{
2473 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2474 uinfo->count = 1;
2475 return 0;
2476}
2477
2478static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
2479 struct snd_ctl_elem_value *ucontrol)
2480{
2481 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2482
2483 spin_lock_irq(&trident->reg_lock);
2484 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2485 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2486 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2487 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2488 spin_unlock_irq(&trident->reg_lock);
2489 return 0;
2490}
2491
2492static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
2493 struct snd_ctl_elem_value *ucontrol)
2494{
2495 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2496 unsigned int val;
2497 int change;
2498
2499 val = (ucontrol->value.iec958.status[0] << 0) |
2500 (ucontrol->value.iec958.status[1] << 8) |
2501 (ucontrol->value.iec958.status[2] << 16) |
2502 (ucontrol->value.iec958.status[3] << 24);
2503 spin_lock_irq(&trident->reg_lock);
2504 change = trident->spdif_pcm_bits != val;
2505 trident->spdif_pcm_bits = val;
2506 if (trident->spdif != NULL) {
2507 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2508 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2509 } else {
2510 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2511 }
2512 }
2513 spin_unlock_irq(&trident->reg_lock);
2514 return change;
2515}
2516
2517static const struct snd_kcontrol_new snd_trident_spdif_stream =
2518{
2519 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2520 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2521 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
2522 .info = snd_trident_spdif_stream_info,
2523 .get = snd_trident_spdif_stream_get,
2524 .put = snd_trident_spdif_stream_put
2525};
2526
2527
2528
2529
2530
2531
2532
2533#define snd_trident_ac97_control_info snd_ctl_boolean_mono_info
2534
2535static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
2536 struct snd_ctl_elem_value *ucontrol)
2537{
2538 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2539 unsigned char val;
2540
2541 spin_lock_irq(&trident->reg_lock);
2542 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2543 ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
2544 spin_unlock_irq(&trident->reg_lock);
2545 return 0;
2546}
2547
2548static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
2549 struct snd_ctl_elem_value *ucontrol)
2550{
2551 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2552 unsigned char val;
2553 int change = 0;
2554
2555 spin_lock_irq(&trident->reg_lock);
2556 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2557 val &= ~(1 << kcontrol->private_value);
2558 if (ucontrol->value.integer.value[0])
2559 val |= 1 << kcontrol->private_value;
2560 change = val != trident->ac97_ctrl;
2561 trident->ac97_ctrl = val;
2562 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2563 spin_unlock_irq(&trident->reg_lock);
2564 return change;
2565}
2566
2567static const struct snd_kcontrol_new snd_trident_ac97_rear_control =
2568{
2569 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2570 .name = "Rear Path",
2571 .info = snd_trident_ac97_control_info,
2572 .get = snd_trident_ac97_control_get,
2573 .put = snd_trident_ac97_control_put,
2574 .private_value = 4,
2575};
2576
2577
2578
2579
2580
2581
2582
2583static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
2584 struct snd_ctl_elem_info *uinfo)
2585{
2586 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2587 uinfo->count = 2;
2588 uinfo->value.integer.min = 0;
2589 uinfo->value.integer.max = 255;
2590 return 0;
2591}
2592
2593static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
2594 struct snd_ctl_elem_value *ucontrol)
2595{
2596 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2597 unsigned int val;
2598
2599 val = trident->musicvol_wavevol;
2600 ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff);
2601 ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff);
2602 return 0;
2603}
2604
2605static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0);
2606
2607static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
2608 struct snd_ctl_elem_value *ucontrol)
2609{
2610 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2611 unsigned int val;
2612 int change = 0;
2613
2614 spin_lock_irq(&trident->reg_lock);
2615 val = trident->musicvol_wavevol;
2616 val &= ~(0xffff << kcontrol->private_value);
2617 val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
2618 ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
2619 change = val != trident->musicvol_wavevol;
2620 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2621 spin_unlock_irq(&trident->reg_lock);
2622 return change;
2623}
2624
2625static const struct snd_kcontrol_new snd_trident_vol_music_control =
2626{
2627 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2628 .name = "Music Playback Volume",
2629 .info = snd_trident_vol_control_info,
2630 .get = snd_trident_vol_control_get,
2631 .put = snd_trident_vol_control_put,
2632 .private_value = 16,
2633 .tlv = { .p = db_scale_gvol },
2634};
2635
2636static const struct snd_kcontrol_new snd_trident_vol_wave_control =
2637{
2638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2639 .name = "Wave Playback Volume",
2640 .info = snd_trident_vol_control_info,
2641 .get = snd_trident_vol_control_get,
2642 .put = snd_trident_vol_control_put,
2643 .private_value = 0,
2644 .tlv = { .p = db_scale_gvol },
2645};
2646
2647
2648
2649
2650
2651
2652
2653static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
2654 struct snd_ctl_elem_info *uinfo)
2655{
2656 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2657
2658 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2659 uinfo->count = 1;
2660 uinfo->value.integer.min = 0;
2661 uinfo->value.integer.max = 255;
2662 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2663 uinfo->value.integer.max = 1023;
2664 return 0;
2665}
2666
2667static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
2668 struct snd_ctl_elem_value *ucontrol)
2669{
2670 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2671 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2672
2673 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2674 ucontrol->value.integer.value[0] = 1023 - mix->vol;
2675 } else {
2676 ucontrol->value.integer.value[0] = 255 - (mix->vol>>2);
2677 }
2678 return 0;
2679}
2680
2681static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
2682 struct snd_ctl_elem_value *ucontrol)
2683{
2684 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2685 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2686 unsigned int val;
2687 int change = 0;
2688
2689 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2690 val = 1023 - (ucontrol->value.integer.value[0] & 1023);
2691 } else {
2692 val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
2693 }
2694 spin_lock_irq(&trident->reg_lock);
2695 change = val != mix->vol;
2696 mix->vol = val;
2697 if (mix->voice != NULL)
2698 snd_trident_write_vol_reg(trident, mix->voice, val);
2699 spin_unlock_irq(&trident->reg_lock);
2700 return change;
2701}
2702
2703static const struct snd_kcontrol_new snd_trident_pcm_vol_control =
2704{
2705 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2706 .name = "PCM Front Playback Volume",
2707 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2708 .count = 32,
2709 .info = snd_trident_pcm_vol_control_info,
2710 .get = snd_trident_pcm_vol_control_get,
2711 .put = snd_trident_pcm_vol_control_put,
2712
2713};
2714
2715
2716
2717
2718
2719
2720
2721static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
2722 struct snd_ctl_elem_info *uinfo)
2723{
2724 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2725 uinfo->count = 1;
2726 uinfo->value.integer.min = 0;
2727 uinfo->value.integer.max = 127;
2728 return 0;
2729}
2730
2731static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
2732 struct snd_ctl_elem_value *ucontrol)
2733{
2734 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2735 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2736
2737 ucontrol->value.integer.value[0] = mix->pan;
2738 if (ucontrol->value.integer.value[0] & 0x40) {
2739 ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f));
2740 } else {
2741 ucontrol->value.integer.value[0] |= 0x40;
2742 }
2743 return 0;
2744}
2745
2746static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
2747 struct snd_ctl_elem_value *ucontrol)
2748{
2749 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2750 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2751 unsigned char val;
2752 int change = 0;
2753
2754 if (ucontrol->value.integer.value[0] & 0x40)
2755 val = ucontrol->value.integer.value[0] & 0x3f;
2756 else
2757 val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
2758 spin_lock_irq(&trident->reg_lock);
2759 change = val != mix->pan;
2760 mix->pan = val;
2761 if (mix->voice != NULL)
2762 snd_trident_write_pan_reg(trident, mix->voice, val);
2763 spin_unlock_irq(&trident->reg_lock);
2764 return change;
2765}
2766
2767static const struct snd_kcontrol_new snd_trident_pcm_pan_control =
2768{
2769 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2770 .name = "PCM Pan Playback Control",
2771 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2772 .count = 32,
2773 .info = snd_trident_pcm_pan_control_info,
2774 .get = snd_trident_pcm_pan_control_get,
2775 .put = snd_trident_pcm_pan_control_put,
2776};
2777
2778
2779
2780
2781
2782
2783
2784static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
2785 struct snd_ctl_elem_info *uinfo)
2786{
2787 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2788 uinfo->count = 1;
2789 uinfo->value.integer.min = 0;
2790 uinfo->value.integer.max = 127;
2791 return 0;
2792}
2793
2794static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
2795 struct snd_ctl_elem_value *ucontrol)
2796{
2797 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2798 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2799
2800 ucontrol->value.integer.value[0] = 127 - mix->rvol;
2801 return 0;
2802}
2803
2804static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
2805 struct snd_ctl_elem_value *ucontrol)
2806{
2807 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2808 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2809 unsigned short val;
2810 int change = 0;
2811
2812 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2813 spin_lock_irq(&trident->reg_lock);
2814 change = val != mix->rvol;
2815 mix->rvol = val;
2816 if (mix->voice != NULL)
2817 snd_trident_write_rvol_reg(trident, mix->voice, val);
2818 spin_unlock_irq(&trident->reg_lock);
2819 return change;
2820}
2821
2822static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);
2823
2824static const struct snd_kcontrol_new snd_trident_pcm_rvol_control =
2825{
2826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2827 .name = "PCM Reverb Playback Volume",
2828 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2829 .count = 32,
2830 .info = snd_trident_pcm_rvol_control_info,
2831 .get = snd_trident_pcm_rvol_control_get,
2832 .put = snd_trident_pcm_rvol_control_put,
2833 .tlv = { .p = db_scale_crvol },
2834};
2835
2836
2837
2838
2839
2840
2841
2842static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
2843 struct snd_ctl_elem_info *uinfo)
2844{
2845 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2846 uinfo->count = 1;
2847 uinfo->value.integer.min = 0;
2848 uinfo->value.integer.max = 127;
2849 return 0;
2850}
2851
2852static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
2853 struct snd_ctl_elem_value *ucontrol)
2854{
2855 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2856 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2857
2858 ucontrol->value.integer.value[0] = 127 - mix->cvol;
2859 return 0;
2860}
2861
2862static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
2863 struct snd_ctl_elem_value *ucontrol)
2864{
2865 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2866 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2867 unsigned short val;
2868 int change = 0;
2869
2870 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2871 spin_lock_irq(&trident->reg_lock);
2872 change = val != mix->cvol;
2873 mix->cvol = val;
2874 if (mix->voice != NULL)
2875 snd_trident_write_cvol_reg(trident, mix->voice, val);
2876 spin_unlock_irq(&trident->reg_lock);
2877 return change;
2878}
2879
2880static const struct snd_kcontrol_new snd_trident_pcm_cvol_control =
2881{
2882 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2883 .name = "PCM Chorus Playback Volume",
2884 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2885 .count = 32,
2886 .info = snd_trident_pcm_cvol_control_info,
2887 .get = snd_trident_pcm_cvol_control_get,
2888 .put = snd_trident_pcm_cvol_control_put,
2889 .tlv = { .p = db_scale_crvol },
2890};
2891
2892static void snd_trident_notify_pcm_change1(struct snd_card *card,
2893 struct snd_kcontrol *kctl,
2894 int num, int activate)
2895{
2896 struct snd_ctl_elem_id id;
2897
2898 if (! kctl)
2899 return;
2900 if (activate)
2901 kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2902 else
2903 kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2904 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
2905 SNDRV_CTL_EVENT_MASK_INFO,
2906 snd_ctl_build_ioff(&id, kctl, num));
2907}
2908
2909static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2910 struct snd_trident_pcm_mixer *tmix,
2911 int num, int activate)
2912{
2913 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2914 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2915 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2916 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2917}
2918
2919static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2920 struct snd_trident_voice *voice,
2921 struct snd_pcm_substream *substream)
2922{
2923 struct snd_trident_pcm_mixer *tmix;
2924
2925 if (snd_BUG_ON(!trident || !voice || !substream))
2926 return -EINVAL;
2927 tmix = &trident->pcm_mixer[substream->number];
2928 tmix->voice = voice;
2929 tmix->vol = T4D_DEFAULT_PCM_VOL;
2930 tmix->pan = T4D_DEFAULT_PCM_PAN;
2931 tmix->rvol = T4D_DEFAULT_PCM_RVOL;
2932 tmix->cvol = T4D_DEFAULT_PCM_CVOL;
2933 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2934 return 0;
2935}
2936
2937static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2938{
2939 struct snd_trident_pcm_mixer *tmix;
2940
2941 if (snd_BUG_ON(!trident || !substream))
2942 return -EINVAL;
2943 tmix = &trident->pcm_mixer[substream->number];
2944 tmix->voice = NULL;
2945 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2946 return 0;
2947}
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
2961{
2962 struct snd_ac97_template _ac97;
2963 struct snd_card *card = trident->card;
2964 struct snd_kcontrol *kctl;
2965 struct snd_ctl_elem_value *uctl;
2966 int idx, err, retries = 2;
2967 static struct snd_ac97_bus_ops ops = {
2968 .write = snd_trident_codec_write,
2969 .read = snd_trident_codec_read,
2970 };
2971
2972 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
2973 if (!uctl)
2974 return -ENOMEM;
2975
2976 if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
2977 goto __out;
2978
2979 memset(&_ac97, 0, sizeof(_ac97));
2980 _ac97.private_data = trident;
2981 trident->ac97_detect = 1;
2982
2983 __again:
2984 if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) {
2985 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2986 if ((err = snd_trident_sis_reset(trident)) < 0)
2987 goto __out;
2988 if (retries-- > 0)
2989 goto __again;
2990 err = -EIO;
2991 }
2992 goto __out;
2993 }
2994
2995
2996 if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2997 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2998 _ac97.num = 1;
2999 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
3000 if (err < 0)
3001 dev_err(trident->card->dev,
3002 "SI7018: the secondary codec - invalid access\n");
3003#if 0
3004 {
3005 struct snd_ac97 *mc97;
3006 err = snd_ac97_modem(trident->card, &_ac97, &mc97);
3007 if (err < 0)
3008 dev_err(trident->card->dev,
3009 "snd_ac97_modem returned error %i\n", err);
3010 }
3011#endif
3012 }
3013
3014 trident->ac97_detect = 0;
3015
3016 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
3017 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0)
3018 goto __out;
3019 kctl->put(kctl, uctl);
3020 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0)
3021 goto __out;
3022 kctl->put(kctl, uctl);
3023 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3024 } else {
3025 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3026 }
3027
3028 for (idx = 0; idx < 32; idx++) {
3029 struct snd_trident_pcm_mixer *tmix;
3030
3031 tmix = &trident->pcm_mixer[idx];
3032 tmix->voice = NULL;
3033 }
3034 if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL)
3035 goto __nomem;
3036 if ((err = snd_ctl_add(card, trident->ctl_vol)))
3037 goto __out;
3038
3039 if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL)
3040 goto __nomem;
3041 if ((err = snd_ctl_add(card, trident->ctl_pan)))
3042 goto __out;
3043
3044 if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL)
3045 goto __nomem;
3046 if ((err = snd_ctl_add(card, trident->ctl_rvol)))
3047 goto __out;
3048
3049 if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL)
3050 goto __nomem;
3051 if ((err = snd_ctl_add(card, trident->ctl_cvol)))
3052 goto __out;
3053
3054 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3055 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0)
3056 goto __out;
3057 kctl->put(kctl, uctl);
3058 }
3059 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
3060
3061 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3062 if (kctl == NULL) {
3063 err = -ENOMEM;
3064 goto __out;
3065 }
3066 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3067 kctl->id.index++;
3068 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3069 kctl->id.index++;
3070 idx = kctl->id.index;
3071 if ((err = snd_ctl_add(card, kctl)) < 0)
3072 goto __out;
3073 kctl->put(kctl, uctl);
3074
3075 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3076 if (kctl == NULL) {
3077 err = -ENOMEM;
3078 goto __out;
3079 }
3080 kctl->id.index = idx;
3081 kctl->id.device = pcm_spdif_device;
3082 if ((err = snd_ctl_add(card, kctl)) < 0)
3083 goto __out;
3084
3085 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3086 if (kctl == NULL) {
3087 err = -ENOMEM;
3088 goto __out;
3089 }
3090 kctl->id.index = idx;
3091 kctl->id.device = pcm_spdif_device;
3092 if ((err = snd_ctl_add(card, kctl)) < 0)
3093 goto __out;
3094
3095 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3096 if (kctl == NULL) {
3097 err = -ENOMEM;
3098 goto __out;
3099 }
3100 kctl->id.index = idx;
3101 kctl->id.device = pcm_spdif_device;
3102 if ((err = snd_ctl_add(card, kctl)) < 0)
3103 goto __out;
3104 trident->spdif_pcm_ctl = kctl;
3105 }
3106
3107 err = 0;
3108 goto __out;
3109
3110 __nomem:
3111 err = -ENOMEM;
3112
3113 __out:
3114 kfree(uctl);
3115
3116 return err;
3117}
3118
3119
3120
3121
3122
3123#if IS_REACHABLE(CONFIG_GAMEPORT)
3124
3125static unsigned char snd_trident_gameport_read(struct gameport *gameport)
3126{
3127 struct snd_trident *chip = gameport_get_port_data(gameport);
3128
3129 if (snd_BUG_ON(!chip))
3130 return 0;
3131 return inb(TRID_REG(chip, GAMEPORT_LEGACY));
3132}
3133
3134static void snd_trident_gameport_trigger(struct gameport *gameport)
3135{
3136 struct snd_trident *chip = gameport_get_port_data(gameport);
3137
3138 if (snd_BUG_ON(!chip))
3139 return;
3140 outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
3141}
3142
3143static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
3144{
3145 struct snd_trident *chip = gameport_get_port_data(gameport);
3146 int i;
3147
3148 if (snd_BUG_ON(!chip))
3149 return 0;
3150
3151 *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
3152
3153 for (i = 0; i < 4; i++) {
3154 axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2));
3155 if (axes[i] == 0xffff) axes[i] = -1;
3156 }
3157
3158 return 0;
3159}
3160
3161static int snd_trident_gameport_open(struct gameport *gameport, int mode)
3162{
3163 struct snd_trident *chip = gameport_get_port_data(gameport);
3164
3165 if (snd_BUG_ON(!chip))
3166 return 0;
3167
3168 switch (mode) {
3169 case GAMEPORT_MODE_COOKED:
3170 outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR));
3171 msleep(20);
3172 return 0;
3173 case GAMEPORT_MODE_RAW:
3174 outb(0, TRID_REG(chip, GAMEPORT_GCR));
3175 return 0;
3176 default:
3177 return -1;
3178 }
3179}
3180
3181int snd_trident_create_gameport(struct snd_trident *chip)
3182{
3183 struct gameport *gp;
3184
3185 chip->gameport = gp = gameport_allocate_port();
3186 if (!gp) {
3187 dev_err(chip->card->dev,
3188 "cannot allocate memory for gameport\n");
3189 return -ENOMEM;
3190 }
3191
3192 gameport_set_name(gp, "Trident 4DWave");
3193 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
3194 gameport_set_dev_parent(gp, &chip->pci->dev);
3195
3196 gameport_set_port_data(gp, chip);
3197 gp->fuzz = 64;
3198 gp->read = snd_trident_gameport_read;
3199 gp->trigger = snd_trident_gameport_trigger;
3200 gp->cooked_read = snd_trident_gameport_cooked_read;
3201 gp->open = snd_trident_gameport_open;
3202
3203 gameport_register_port(gp);
3204
3205 return 0;
3206}
3207
3208static inline void snd_trident_free_gameport(struct snd_trident *chip)
3209{
3210 if (chip->gameport) {
3211 gameport_unregister_port(chip->gameport);
3212 chip->gameport = NULL;
3213 }
3214}
3215#else
3216int snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
3217static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
3218#endif
3219
3220
3221
3222
3223static inline void do_delay(struct snd_trident *chip)
3224{
3225 schedule_timeout_uninterruptible(1);
3226}
3227
3228
3229
3230
3231
3232static int snd_trident_sis_reset(struct snd_trident *trident)
3233{
3234 unsigned long end_time;
3235 unsigned int i;
3236 int r;
3237
3238 r = trident->in_suspend ? 0 : 2;
3239 __si7018_retry:
3240 pci_write_config_byte(trident->pci, 0x46, 0x04);
3241 udelay(100);
3242 pci_write_config_byte(trident->pci, 0x46, 0x00);
3243 udelay(100);
3244
3245 outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3246
3247 i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET;
3248 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3249 udelay(1000);
3250
3251 i &= ~COLD_RESET;
3252 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3253 udelay(2000);
3254
3255 end_time = (jiffies + (HZ * 3) / 4) + 1;
3256 do {
3257 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3258 goto __si7018_ok;
3259 do_delay(trident);
3260 } while (time_after_eq(end_time, jiffies));
3261 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3262 inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3263 if (r-- > 0) {
3264 end_time = jiffies + HZ;
3265 do {
3266 do_delay(trident);
3267 } while (time_after_eq(end_time, jiffies));
3268 goto __si7018_retry;
3269 }
3270 __si7018_ok:
3271
3272 do {
3273 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3274 break;
3275 do_delay(trident);
3276 } while (time_after_eq(end_time, jiffies));
3277
3278 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3279 return 0;
3280}
3281
3282
3283
3284
3285
3286static void snd_trident_proc_read(struct snd_info_entry *entry,
3287 struct snd_info_buffer *buffer)
3288{
3289 struct snd_trident *trident = entry->private_data;
3290 char *s;
3291
3292 switch (trident->device) {
3293 case TRIDENT_DEVICE_ID_SI7018:
3294 s = "SiS 7018 Audio";
3295 break;
3296 case TRIDENT_DEVICE_ID_DX:
3297 s = "Trident 4DWave PCI DX";
3298 break;
3299 case TRIDENT_DEVICE_ID_NX:
3300 s = "Trident 4DWave PCI NX";
3301 break;
3302 default:
3303 s = "???";
3304 }
3305 snd_iprintf(buffer, "%s\n\n", s);
3306 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count);
3307 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3308 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3309 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off");
3310 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3311 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
3312 if (trident->tlb.entries) {
3313 snd_iprintf(buffer,"\nVirtual Memory\n");
3314 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3315 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used);
3316 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3317 }
3318 }
3319}
3320
3321static void snd_trident_proc_init(struct snd_trident *trident)
3322{
3323 struct snd_info_entry *entry;
3324 const char *s = "trident";
3325
3326 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3327 s = "sis7018";
3328 if (! snd_card_proc_new(trident->card, s, &entry))
3329 snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
3330}
3331
3332static int snd_trident_dev_free(struct snd_device *device)
3333{
3334 struct snd_trident *trident = device->device_data;
3335 return snd_trident_free(trident);
3336}
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350static int snd_trident_tlb_alloc(struct snd_trident *trident)
3351{
3352 int i;
3353
3354
3355
3356
3357 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3358 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
3359 dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
3360 return -ENOMEM;
3361 }
3362 trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
3363 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3364
3365 trident->tlb.shadow_entries =
3366 vmalloc(array_size(SNDRV_TRIDENT_MAX_PAGES,
3367 sizeof(unsigned long)));
3368 if (!trident->tlb.shadow_entries)
3369 return -ENOMEM;
3370
3371
3372 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3373 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
3374 dev_err(trident->card->dev, "unable to allocate silent page\n");
3375 return -ENOMEM;
3376 }
3377 memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3378 for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) {
3379 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3380 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area;
3381 }
3382
3383
3384 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3385 if (trident->tlb.memhdr == NULL)
3386 return -ENOMEM;
3387
3388 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3389 return 0;
3390}
3391
3392
3393
3394
3395
3396static void snd_trident_stop_all_voices(struct snd_trident *trident)
3397{
3398 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3399 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3400 outl(0, TRID_REG(trident, T4D_AINTEN_A));
3401 outl(0, TRID_REG(trident, T4D_AINTEN_B));
3402}
3403
3404static int snd_trident_4d_dx_init(struct snd_trident *trident)
3405{
3406 struct pci_dev *pci = trident->pci;
3407 unsigned long end_time;
3408
3409
3410 pci_write_config_dword(pci, 0x40, 0);
3411 pci_write_config_byte(pci, 0x44, 0);
3412 pci_write_config_byte(pci, 0x45, 0);
3413 pci_write_config_byte(pci, 0x46, 4);
3414 udelay(100);
3415 pci_write_config_byte(pci, 0x46, 0);
3416 udelay(100);
3417
3418
3419 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3420 udelay(100);
3421 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3422
3423 trident->ac97_ctrl = 0x0000004a;
3424 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3425
3426 end_time = (jiffies + (HZ * 3) / 4) + 1;
3427 do {
3428 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3429 goto __dx_ok;
3430 do_delay(trident);
3431 } while (time_after_eq(end_time, jiffies));
3432 dev_err(trident->card->dev, "AC'97 codec ready error\n");
3433 return -EIO;
3434
3435 __dx_ok:
3436 snd_trident_stop_all_voices(trident);
3437
3438 return 0;
3439}
3440
3441
3442
3443
3444static int snd_trident_4d_nx_init(struct snd_trident *trident)
3445{
3446 struct pci_dev *pci = trident->pci;
3447 unsigned long end_time;
3448
3449
3450 pci_write_config_dword(pci, 0x40, 0);
3451 pci_write_config_byte(pci, 0x44, 0);
3452 pci_write_config_byte(pci, 0x45, 0);
3453
3454 pci_write_config_byte(pci, 0x46, 1);
3455 udelay(100);
3456 pci_write_config_byte(pci, 0x46, 0);
3457 udelay(100);
3458
3459
3460 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3461 udelay(100);
3462 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3463
3464 end_time = (jiffies + (HZ * 3) / 4) + 1;
3465 do {
3466 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3467 goto __nx_ok;
3468 do_delay(trident);
3469 } while (time_after_eq(end_time, jiffies));
3470 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3471 inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3472 return -EIO;
3473
3474 __nx_ok:
3475
3476 trident->ac97_ctrl = 0x00000002;
3477 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3478
3479 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3480
3481 snd_trident_stop_all_voices(trident);
3482
3483 if (trident->tlb.entries != NULL) {
3484 unsigned int i;
3485
3486 i = trident->tlb.entries_dmaaddr;
3487 i |= 0x00000001;
3488 outl(i, TRID_REG(trident, NX_TLBC));
3489 } else {
3490 outl(0, TRID_REG(trident, NX_TLBC));
3491 }
3492
3493 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3494 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3495
3496 return 0;
3497}
3498
3499
3500
3501
3502static int snd_trident_sis_init(struct snd_trident *trident)
3503{
3504 int err;
3505
3506 if ((err = snd_trident_sis_reset(trident)) < 0)
3507 return err;
3508
3509 snd_trident_stop_all_voices(trident);
3510
3511
3512 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3513
3514 return 0;
3515}
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533int snd_trident_create(struct snd_card *card,
3534 struct pci_dev *pci,
3535 int pcm_streams,
3536 int pcm_spdif_device,
3537 int max_wavetable_size,
3538 struct snd_trident ** rtrident)
3539{
3540 struct snd_trident *trident;
3541 int i, err;
3542 struct snd_trident_voice *voice;
3543 struct snd_trident_pcm_mixer *tmix;
3544 static struct snd_device_ops ops = {
3545 .dev_free = snd_trident_dev_free,
3546 };
3547
3548 *rtrident = NULL;
3549
3550
3551 if ((err = pci_enable_device(pci)) < 0)
3552 return err;
3553
3554 if (dma_set_mask(&pci->dev, DMA_BIT_MASK(30)) < 0 ||
3555 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(30)) < 0) {
3556 dev_err(card->dev,
3557 "architecture does not support 30bit PCI busmaster DMA\n");
3558 pci_disable_device(pci);
3559 return -ENXIO;
3560 }
3561
3562 trident = kzalloc(sizeof(*trident), GFP_KERNEL);
3563 if (trident == NULL) {
3564 pci_disable_device(pci);
3565 return -ENOMEM;
3566 }
3567 trident->device = (pci->vendor << 16) | pci->device;
3568 trident->card = card;
3569 trident->pci = pci;
3570 spin_lock_init(&trident->reg_lock);
3571 spin_lock_init(&trident->event_lock);
3572 spin_lock_init(&trident->voice_alloc);
3573 if (pcm_streams < 1)
3574 pcm_streams = 1;
3575 if (pcm_streams > 32)
3576 pcm_streams = 32;
3577 trident->ChanPCM = pcm_streams;
3578 if (max_wavetable_size < 0 )
3579 max_wavetable_size = 0;
3580 trident->synth.max_size = max_wavetable_size * 1024;
3581 trident->irq = -1;
3582
3583 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3584 pci_set_master(pci);
3585
3586 if ((err = pci_request_regions(pci, "Trident Audio")) < 0) {
3587 kfree(trident);
3588 pci_disable_device(pci);
3589 return err;
3590 }
3591 trident->port = pci_resource_start(pci, 0);
3592
3593 if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
3594 KBUILD_MODNAME, trident)) {
3595 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
3596 snd_trident_free(trident);
3597 return -EBUSY;
3598 }
3599 trident->irq = pci->irq;
3600
3601
3602 trident->tlb.entries = NULL;
3603 trident->tlb.buffer.area = NULL;
3604 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3605 if ((err = snd_trident_tlb_alloc(trident)) < 0) {
3606 snd_trident_free(trident);
3607 return err;
3608 }
3609 }
3610
3611 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3612
3613
3614 switch (trident->device) {
3615 case TRIDENT_DEVICE_ID_DX:
3616 err = snd_trident_4d_dx_init(trident);
3617 break;
3618 case TRIDENT_DEVICE_ID_NX:
3619 err = snd_trident_4d_nx_init(trident);
3620 break;
3621 case TRIDENT_DEVICE_ID_SI7018:
3622 err = snd_trident_sis_init(trident);
3623 break;
3624 default:
3625 snd_BUG();
3626 break;
3627 }
3628 if (err < 0) {
3629 snd_trident_free(trident);
3630 return err;
3631 }
3632
3633 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
3634 snd_trident_free(trident);
3635 return err;
3636 }
3637
3638 if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0)
3639 return err;
3640
3641
3642 for (i = 0; i < 64; i++) {
3643 voice = &trident->synth.voices[i];
3644 voice->number = i;
3645 voice->trident = trident;
3646 }
3647
3648 for (i = 0; i < 32; i++) {
3649 tmix = &trident->pcm_mixer[i];
3650 tmix->vol = T4D_DEFAULT_PCM_VOL;
3651 tmix->pan = T4D_DEFAULT_PCM_PAN;
3652 tmix->rvol = T4D_DEFAULT_PCM_RVOL;
3653 tmix->cvol = T4D_DEFAULT_PCM_CVOL;
3654 }
3655
3656 snd_trident_enable_eso(trident);
3657
3658 snd_trident_proc_init(trident);
3659 *rtrident = trident;
3660 return 0;
3661}
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675static int snd_trident_free(struct snd_trident *trident)
3676{
3677 snd_trident_free_gameport(trident);
3678 snd_trident_disable_eso(trident);
3679
3680 if (trident->device == TRIDENT_DEVICE_ID_NX)
3681 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3682 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3683 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3684 }
3685 if (trident->irq >= 0)
3686 free_irq(trident->irq, trident);
3687 if (trident->tlb.buffer.area) {
3688 outl(0, TRID_REG(trident, NX_TLBC));
3689 snd_util_memhdr_free(trident->tlb.memhdr);
3690 if (trident->tlb.silent_page.area)
3691 snd_dma_free_pages(&trident->tlb.silent_page);
3692 vfree(trident->tlb.shadow_entries);
3693 snd_dma_free_pages(&trident->tlb.buffer);
3694 }
3695 pci_release_regions(trident->pci);
3696 pci_disable_device(trident->pci);
3697 kfree(trident);
3698 return 0;
3699}
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)
3720{
3721 struct snd_trident *trident = dev_id;
3722 unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
3723 int delta;
3724 struct snd_trident_voice *voice;
3725
3726 audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3727 if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
3728 return IRQ_NONE;
3729 if (audio_int & ADDRESS_IRQ) {
3730
3731 spin_lock(&trident->reg_lock);
3732 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3733 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3734 if (chn_int == 0)
3735 goto __skip1;
3736 outl(chn_int, TRID_REG(trident, T4D_AINT_A));
3737 __skip1:
3738 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3739 if (chn_int == 0)
3740 goto __skip2;
3741 for (channel = 63; channel >= 32; channel--) {
3742 mask = 1 << (channel&0x1f);
3743 if ((chn_int & mask) == 0)
3744 continue;
3745 voice = &trident->synth.voices[channel];
3746 if (!voice->pcm || voice->substream == NULL) {
3747 outl(mask, TRID_REG(trident, T4D_STOP_B));
3748 continue;
3749 }
3750 delta = (int)stimer - (int)voice->stimer;
3751 if (delta < 0)
3752 delta = -delta;
3753 if ((unsigned int)delta < voice->spurious_threshold) {
3754
3755 trident->spurious_irq_count++;
3756 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3757 trident->spurious_irq_max_delta = delta;
3758 continue;
3759 }
3760 voice->stimer = stimer;
3761 if (voice->isync) {
3762 if (!voice->isync3) {
3763 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3764 if (trident->bDMAStart & 0x40)
3765 tmp >>= 1;
3766 if (tmp > 0)
3767 tmp = voice->isync_max - tmp;
3768 } else {
3769 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3770 }
3771 if (tmp < voice->isync_mark) {
3772 if (tmp > 0x10)
3773 tmp = voice->isync_ESO - 7;
3774 else
3775 tmp = voice->isync_ESO + 2;
3776
3777 snd_trident_stop_voice(trident, voice->number);
3778 snd_trident_write_eso_reg(trident, voice, tmp);
3779 snd_trident_start_voice(trident, voice->number);
3780 }
3781 } else if (voice->isync2) {
3782 voice->isync2 = 0;
3783
3784 snd_trident_stop_voice(trident, voice->number);
3785 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3786 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3787 snd_trident_start_voice(trident, voice->number);
3788 }
3789#if 0
3790 if (voice->extra) {
3791
3792 snd_trident_stop_voice(trident, voice->extra->number);
3793 snd_trident_write_cso_reg(trident, voice->extra, 0);
3794 snd_trident_start_voice(trident, voice->extra->number);
3795 }
3796#endif
3797 spin_unlock(&trident->reg_lock);
3798 snd_pcm_period_elapsed(voice->substream);
3799 spin_lock(&trident->reg_lock);
3800 }
3801 outl(chn_int, TRID_REG(trident, T4D_AINT_B));
3802 __skip2:
3803 spin_unlock(&trident->reg_lock);
3804 }
3805 if (audio_int & MPU401_IRQ) {
3806 if (trident->rmidi) {
3807 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3808 } else {
3809 inb(TRID_REG(trident, T4D_MPUR0));
3810 }
3811 }
3812
3813 return IRQ_HANDLED;
3814}
3815
3816struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3817{
3818 struct snd_trident_voice *pvoice;
3819 unsigned long flags;
3820 int idx;
3821
3822 spin_lock_irqsave(&trident->voice_alloc, flags);
3823 if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) {
3824 idx = snd_trident_allocate_pcm_channel(trident);
3825 if(idx < 0) {
3826 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3827 return NULL;
3828 }
3829 pvoice = &trident->synth.voices[idx];
3830 pvoice->use = 1;
3831 pvoice->pcm = 1;
3832 pvoice->capture = 0;
3833 pvoice->spdif = 0;
3834 pvoice->memblk = NULL;
3835 pvoice->substream = NULL;
3836 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3837 return pvoice;
3838 }
3839 if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) {
3840 idx = snd_trident_allocate_synth_channel(trident);
3841 if(idx < 0) {
3842 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3843 return NULL;
3844 }
3845 pvoice = &trident->synth.voices[idx];
3846 pvoice->use = 1;
3847 pvoice->synth = 1;
3848 pvoice->client = client;
3849 pvoice->port = port;
3850 pvoice->memblk = NULL;
3851 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3852 return pvoice;
3853 }
3854 if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) {
3855 }
3856 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3857 return NULL;
3858}
3859
3860EXPORT_SYMBOL(snd_trident_alloc_voice);
3861
3862void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3863{
3864 unsigned long flags;
3865 void (*private_free)(struct snd_trident_voice *);
3866
3867 if (voice == NULL || !voice->use)
3868 return;
3869 snd_trident_clear_voices(trident, voice->number, voice->number);
3870 spin_lock_irqsave(&trident->voice_alloc, flags);
3871 private_free = voice->private_free;
3872 voice->private_free = NULL;
3873 voice->private_data = NULL;
3874 if (voice->pcm)
3875 snd_trident_free_pcm_channel(trident, voice->number);
3876 if (voice->synth)
3877 snd_trident_free_synth_channel(trident, voice->number);
3878 voice->use = voice->pcm = voice->synth = voice->midi = 0;
3879 voice->capture = voice->spdif = 0;
3880 voice->sample_ops = NULL;
3881 voice->substream = NULL;
3882 voice->extra = NULL;
3883 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3884 if (private_free)
3885 private_free(voice);
3886}
3887
3888EXPORT_SYMBOL(snd_trident_free_voice);
3889
3890static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3891{
3892 unsigned int i, val, mask[2] = { 0, 0 };
3893
3894 if (snd_BUG_ON(v_min > 63 || v_max > 63))
3895 return;
3896 for (i = v_min; i <= v_max; i++)
3897 mask[i >> 5] |= 1 << (i & 0x1f);
3898 if (mask[0]) {
3899 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3900 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3901 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3902 }
3903 if (mask[1]) {
3904 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3905 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3906 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3907 }
3908}
3909
3910#ifdef CONFIG_PM_SLEEP
3911static int snd_trident_suspend(struct device *dev)
3912{
3913 struct snd_card *card = dev_get_drvdata(dev);
3914 struct snd_trident *trident = card->private_data;
3915
3916 trident->in_suspend = 1;
3917 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
3918 snd_pcm_suspend_all(trident->pcm);
3919 snd_pcm_suspend_all(trident->foldback);
3920 snd_pcm_suspend_all(trident->spdif);
3921
3922 snd_ac97_suspend(trident->ac97);
3923 snd_ac97_suspend(trident->ac97_sec);
3924 return 0;
3925}
3926
3927static int snd_trident_resume(struct device *dev)
3928{
3929 struct snd_card *card = dev_get_drvdata(dev);
3930 struct snd_trident *trident = card->private_data;
3931
3932 switch (trident->device) {
3933 case TRIDENT_DEVICE_ID_DX:
3934 snd_trident_4d_dx_init(trident);
3935 break;
3936 case TRIDENT_DEVICE_ID_NX:
3937 snd_trident_4d_nx_init(trident);
3938 break;
3939 case TRIDENT_DEVICE_ID_SI7018:
3940 snd_trident_sis_init(trident);
3941 break;
3942 }
3943
3944 snd_ac97_resume(trident->ac97);
3945 snd_ac97_resume(trident->ac97_sec);
3946
3947
3948 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3949
3950 snd_trident_enable_eso(trident);
3951
3952 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
3953 trident->in_suspend = 0;
3954 return 0;
3955}
3956
3957SIMPLE_DEV_PM_OPS(snd_trident_pm, snd_trident_suspend, snd_trident_resume);
3958#endif
3959
