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