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