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