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