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