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