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