CoCalc -- trident

GitHub Repository: torvalds/linux
Path: blob/master/sound/pci/trident/trident_main.c
²⁹²⁶⁹ views
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
/*
3
 *  Maintained by Jaroslav Kysela <[email protected]>
4
 *  Originated by [email protected]
5
 *  Fri Feb 19 15:55:28 MST 1999
6
 *  Routines for control of Trident 4DWave (DX and NX) chip
7
 *
8
 *  BUGS:
9
 *
10
 *  TODO:
11
 *    ---
12
 *
13
 *  SiS7018 S/PDIF support by Thomas Winischhofer <[email protected]>
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 void snd_trident_free(struct snd_card *card);
46

47
/*
48
 *  common I/O routines
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 {		// TRIDENT_DEVICE_ID_NX
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
   unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
96
  
97
   Description: This routine will do all of the reading from the external
98
                CODEC (AC97).
99
  
100
   Parameters:  ac97 - ac97 codec structure
101
                reg - CODEC register index, from AC97 Hal.
102
 
103
   returns:     16 bit value read from the AC97.
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
	struct snd_trident *trident = ac97->private_data;
111

112
	guard(spinlock_irqsave)(&trident->reg_lock);
113
	if (trident->device == TRIDENT_DEVICE_ID_DX) {
114
		data = (DX_AC97_BUSY_READ | (reg & 0x000000ff));
115
		outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
116
		do {
117
			data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
118
			if ((data & DX_AC97_BUSY_READ) == 0)
119
				break;
120
		} while (--count);
121
	} else if (trident->device == TRIDENT_DEVICE_ID_NX) {
122
		data = (NX_AC97_BUSY_READ | (reg & 0x000000ff));
123
		treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY;
124
		outl(data, TRID_REG(trident, treg));
125
		do {
126
			data = inl(TRID_REG(trident, treg));
127
			if ((data & 0x00000C00) == 0)
128
				break;
129
		} while (--count);
130
	} else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
131
		data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
132
		if (ac97->num == 1)
133
			data |= SI_AC97_SECONDARY;
134
		outl(data, TRID_REG(trident, SI_AC97_READ));
135
		do {
136
			data = inl(TRID_REG(trident, SI_AC97_READ));
137
			if ((data & (SI_AC97_BUSY_READ)) == 0)
138
				break;
139
		} while (--count);
140
	}
141

142
	if (count == 0 && !trident->ac97_detect) {
143
		dev_err(trident->card->dev,
144
			"ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
145
			   reg, data);
146
		data = 0;
147
	}
148

149
	return ((unsigned short) (data >> 16));
150
}
151

152
/*---------------------------------------------------------------------------
153
   void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
154
   unsigned short wdata)
155
  
156
   Description: This routine will do all of the writing to the external
157
                CODEC (AC97).
158
  
159
   Parameters:	ac97 - ac97 codec structure
160
   	        reg - CODEC register index, from AC97 Hal.
161
                data  - Lower 16 bits are the data to write to CODEC.
162
  
163
   returns:     TRUE if everything went ok, else FALSE.
164
  
165
  ---------------------------------------------------------------------------*/
166
static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
167
				    unsigned short wdata)
168
{
169
	unsigned int address, data;
170
	unsigned short count = 0xffff;
171
	struct snd_trident *trident = ac97->private_data;
172

173
	data = ((unsigned long) wdata) << 16;
174

175
	guard(spinlock_irqsave)(&trident->reg_lock);
176
	if (trident->device == TRIDENT_DEVICE_ID_DX) {
177
		address = DX_ACR0_AC97_W;
178

179
		/* read AC-97 write register status */
180
		do {
181
			if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
182
				break;
183
		} while (--count);
184

185
		data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff));
186
	} else if (trident->device == TRIDENT_DEVICE_ID_NX) {
187
		address = NX_ACR1_AC97_W;
188

189
		/* read AC-97 write register status */
190
		do {
191
			if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
192
				break;
193
		} while (--count);
194

195
		data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff));
196
	} else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
197
		address = SI_AC97_WRITE;
198

199
		/* read AC-97 write register status */
200
		do {
201
			if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
202
				break;
203
		} while (--count);
204

205
		data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
206
		if (ac97->num == 1)
207
			data |= SI_AC97_SECONDARY;
208
	} else {
209
		address = 0;	/* keep GCC happy */
210
		count = 0;	/* return */
211
	}
212

213
	if (count == 0)
214
		return;
215
	outl(data, TRID_REG(trident, address));
216
}
217

218
/*---------------------------------------------------------------------------
219
   void snd_trident_enable_eso(struct snd_trident *trident)
220
  
221
   Description: This routine will enable end of loop interrupts.
222
                End of loop interrupts will occur when a running
223
                channel reaches ESO.
224
                Also enables middle of loop interrupts.
225
  
226
   Parameters:  trident - pointer to target device class for 4DWave.
227
  
228
  ---------------------------------------------------------------------------*/
229

230
static void snd_trident_enable_eso(struct snd_trident * trident)
231
{
232
	unsigned int val;
233

234
	val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
235
	val |= ENDLP_IE;
236
	val |= MIDLP_IE;
237
	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
238
		val |= BANK_B_EN;
239
	outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
240
}
241

242
/*---------------------------------------------------------------------------
243
   void snd_trident_disable_eso(struct snd_trident *trident)
244
  
245
   Description: This routine will disable end of loop interrupts.
246
                End of loop interrupts will occur when a running
247
                channel reaches ESO.
248
                Also disables middle of loop interrupts.
249
  
250
   Parameters:  
251
                trident - pointer to target device class for 4DWave.
252
  
253
   returns:     TRUE if everything went ok, else FALSE.
254
  
255
  ---------------------------------------------------------------------------*/
256

257
static void snd_trident_disable_eso(struct snd_trident * trident)
258
{
259
	unsigned int tmp;
260

261
	tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
262
	tmp &= ~ENDLP_IE;
263
	tmp &= ~MIDLP_IE;
264
	outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
265
}
266

267
/*---------------------------------------------------------------------------
268
   void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
269

270
    Description: Start a voice, any channel 0 thru 63.
271
                 This routine automatically handles the fact that there are
272
                 more than 32 channels available.
273

274
    Parameters : voice - Voice number 0 thru n.
275
                 trident - pointer to target device class for 4DWave.
276

277
    Return Value: None.
278

279
  ---------------------------------------------------------------------------*/
280

281
void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
282
{
283
	unsigned int mask = 1 << (voice & 0x1f);
284
	unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
285

286
	outl(mask, TRID_REG(trident, reg));
287
}
288

289
EXPORT_SYMBOL(snd_trident_start_voice);
290

291
/*---------------------------------------------------------------------------
292
   void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
293

294
    Description: Stop a voice, any channel 0 thru 63.
295
                 This routine automatically handles the fact that there are
296
                 more than 32 channels available.
297

298
    Parameters : voice - Voice number 0 thru n.
299
                 trident - pointer to target device class for 4DWave.
300

301
    Return Value: None.
302

303
  ---------------------------------------------------------------------------*/
304

305
void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
306
{
307
	unsigned int mask = 1 << (voice & 0x1f);
308
	unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
309

310
	outl(mask, TRID_REG(trident, reg));
311
}
312

313
EXPORT_SYMBOL(snd_trident_stop_voice);
314

315
/*---------------------------------------------------------------------------
316
    int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
317
  
318
    Description: Allocate hardware channel in Bank B (32-63).
319
  
320
    Parameters :  trident - pointer to target device class for 4DWave.
321
  
322
    Return Value: hardware channel - 32-63 or -1 when no channel is available
323
  
324
  ---------------------------------------------------------------------------*/
325

326
static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
327
{
328
	int idx;
329

330
	if (trident->ChanPCMcnt >= trident->ChanPCM)
331
		return -1;
332
	for (idx = 31; idx >= 0; idx--) {
333
		if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
334
			trident->ChanMap[T4D_BANK_B] |= 1 << idx;
335
			trident->ChanPCMcnt++;
336
			return idx + 32;
337
		}
338
	}
339
	return -1;
340
}
341

342
/*---------------------------------------------------------------------------
343
    void snd_trident_free_pcm_channel(int channel)
344
  
345
    Description: Free hardware channel in Bank B (32-63)
346
  
347
    Parameters :  trident - pointer to target device class for 4DWave.
348
	          channel - hardware channel number 0-63
349
  
350
    Return Value: none
351
  
352
  ---------------------------------------------------------------------------*/
353

354
static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
355
{
356
	if (channel < 32 || channel > 63)
357
		return;
358
	channel &= 0x1f;
359
	if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
360
		trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
361
		trident->ChanPCMcnt--;
362
	}
363
}
364

365
/*---------------------------------------------------------------------------
366
    unsigned int snd_trident_allocate_synth_channel(void)
367
  
368
    Description: Allocate hardware channel in Bank A (0-31).
369
  
370
    Parameters :  trident - pointer to target device class for 4DWave.
371
  
372
    Return Value: hardware channel - 0-31 or -1 when no channel is available
373
  
374
  ---------------------------------------------------------------------------*/
375

376
static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
377
{
378
	int idx;
379

380
	for (idx = 31; idx >= 0; idx--) {
381
		if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
382
			trident->ChanMap[T4D_BANK_A] |= 1 << idx;
383
			trident->synth.ChanSynthCount++;
384
			return idx;
385
		}
386
	}
387
	return -1;
388
}
389

390
/*---------------------------------------------------------------------------
391
    void snd_trident_free_synth_channel( int channel )
392
  
393
    Description: Free hardware channel in Bank B (0-31).
394
  
395
    Parameters :  trident - pointer to target device class for 4DWave.
396
	          channel - hardware channel number 0-63
397
  
398
    Return Value: none
399
  
400
  ---------------------------------------------------------------------------*/
401

402
static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
403
{
404
	if (channel < 0 || channel > 31)
405
		return;
406
	channel &= 0x1f;
407
	if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
408
		trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
409
		trident->synth.ChanSynthCount--;
410
	}
411
}
412

413
/*---------------------------------------------------------------------------
414
   snd_trident_write_voice_regs
415
  
416
   Description: This routine will complete and write the 5 hardware channel
417
                registers to hardware.
418
  
419
   Parameters:  trident - pointer to target device class for 4DWave.
420
                voice - synthesizer voice structure
421
                Each register field.
422
  
423
  ---------------------------------------------------------------------------*/
424

425
void snd_trident_write_voice_regs(struct snd_trident * trident,
426
				  struct snd_trident_voice * voice)
427
{
428
	unsigned int FmcRvolCvol;
429
	unsigned int regs[5];
430

431
	regs[1] = voice->LBA;
432
	regs[4] = (voice->GVSel << 31) |
433
		  ((voice->Pan & 0x0000007f) << 24) |
434
		  ((voice->CTRL & 0x0000000f) << 12);
435
	FmcRvolCvol = ((voice->FMC & 3) << 14) |
436
	              ((voice->RVol & 0x7f) << 7) |
437
	              (voice->CVol & 0x7f);
438

439
	switch (trident->device) {
440
	case TRIDENT_DEVICE_ID_SI7018:
441
		regs[4] |= voice->number > 31 ?
442
				(voice->Vol & 0x000003ff) :
443
				((voice->Vol & 0x00003fc) << (16-2)) |
444
				(voice->EC & 0x00000fff);
445
		regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
446
			(voice->FMS & 0x0000000f);
447
		regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
448
		regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
449
		break;
450
	case TRIDENT_DEVICE_ID_DX:
451
		regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
452
			   (voice->EC & 0x00000fff);
453
		regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
454
			(voice->FMS & 0x0000000f);
455
		regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
456
		regs[3] = FmcRvolCvol;
457
		break;
458
	case TRIDENT_DEVICE_ID_NX:
459
		regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
460
			   (voice->EC & 0x00000fff);
461
		regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);
462
		regs[2] = ((voice->Delta << 16) & 0xff000000) |
463
			(voice->ESO & 0x00ffffff);
464
		regs[3] = (voice->Alpha << 20) |
465
			((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
466
		break;
467
	default:
468
		snd_BUG();
469
		return;
470
	}
471

472
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
473
	outl(regs[0], TRID_REG(trident, CH_START + 0));
474
	outl(regs[1], TRID_REG(trident, CH_START + 4));
475
	outl(regs[2], TRID_REG(trident, CH_START + 8));
476
	outl(regs[3], TRID_REG(trident, CH_START + 12));
477
	outl(regs[4], TRID_REG(trident, CH_START + 16));
478

479
#if 0
480
	dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
481
	dev_dbg(trident->card->dev, "  regs[0] = 0x%x/0x%x\n",
482
	       regs[0], inl(TRID_REG(trident, CH_START + 0)));
483
	dev_dbg(trident->card->dev, "  regs[1] = 0x%x/0x%x\n",
484
	       regs[1], inl(TRID_REG(trident, CH_START + 4)));
485
	dev_dbg(trident->card->dev, "  regs[2] = 0x%x/0x%x\n",
486
	       regs[2], inl(TRID_REG(trident, CH_START + 8)));
487
	dev_dbg(trident->card->dev, "  regs[3] = 0x%x/0x%x\n",
488
	       regs[3], inl(TRID_REG(trident, CH_START + 12)));
489
	dev_dbg(trident->card->dev, "  regs[4] = 0x%x/0x%x\n",
490
	       regs[4], inl(TRID_REG(trident, CH_START + 16)));
491
#endif
492
}
493

494
EXPORT_SYMBOL(snd_trident_write_voice_regs);
495

496
/*---------------------------------------------------------------------------
497
   snd_trident_write_cso_reg
498
  
499
   Description: This routine will write the new CSO offset
500
                register to hardware.
501
  
502
   Parameters:  trident - pointer to target device class for 4DWave.
503
                voice - synthesizer voice structure
504
                CSO - new CSO value
505
  
506
  ---------------------------------------------------------------------------*/
507

508
static void snd_trident_write_cso_reg(struct snd_trident * trident,
509
				      struct snd_trident_voice * voice,
510
				      unsigned int CSO)
511
{
512
	voice->CSO = CSO;
513
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
514
	if (trident->device != TRIDENT_DEVICE_ID_NX) {
515
		outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
516
	} else {
517
		outl((voice->Delta << 24) |
518
		     (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
519
	}
520
}
521

522
/*---------------------------------------------------------------------------
523
   snd_trident_write_eso_reg
524
  
525
   Description: This routine will write the new ESO offset
526
                register to hardware.
527
  
528
   Parameters:  trident - pointer to target device class for 4DWave.
529
                voice - synthesizer voice structure
530
                ESO - new ESO value
531
  
532
  ---------------------------------------------------------------------------*/
533

534
static void snd_trident_write_eso_reg(struct snd_trident * trident,
535
				      struct snd_trident_voice * voice,
536
				      unsigned int ESO)
537
{
538
	voice->ESO = ESO;
539
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
540
	if (trident->device != TRIDENT_DEVICE_ID_NX) {
541
		outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
542
	} else {
543
		outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
544
		     TRID_REG(trident, CH_NX_DELTA_ESO));
545
	}
546
}
547

548
/*---------------------------------------------------------------------------
549
   snd_trident_write_vol_reg
550
  
551
   Description: This routine will write the new voice volume
552
                register to hardware.
553
  
554
   Parameters:  trident - pointer to target device class for 4DWave.
555
                voice - synthesizer voice structure
556
                Vol - new voice volume
557
  
558
  ---------------------------------------------------------------------------*/
559

560
static void snd_trident_write_vol_reg(struct snd_trident * trident,
561
				      struct snd_trident_voice * voice,
562
				      unsigned int Vol)
563
{
564
	voice->Vol = Vol;
565
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
566
	switch (trident->device) {
567
	case TRIDENT_DEVICE_ID_DX:
568
	case TRIDENT_DEVICE_ID_NX:
569
		outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
570
		break;
571
	case TRIDENT_DEVICE_ID_SI7018:
572
		/* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
573
		outw((voice->CTRL << 12) | voice->Vol,
574
		     TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
575
		break;
576
	}
577
}
578

579
/*---------------------------------------------------------------------------
580
   snd_trident_write_pan_reg
581
  
582
   Description: This routine will write the new voice pan
583
                register to hardware.
584
  
585
   Parameters:  trident - pointer to target device class for 4DWave.
586
                voice - synthesizer voice structure
587
                Pan - new pan value
588
  
589
  ---------------------------------------------------------------------------*/
590

591
static void snd_trident_write_pan_reg(struct snd_trident * trident,
592
				      struct snd_trident_voice * voice,
593
				      unsigned int Pan)
594
{
595
	voice->Pan = Pan;
596
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
597
	outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
598
	     TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
599
}
600

601
/*---------------------------------------------------------------------------
602
   snd_trident_write_rvol_reg
603
  
604
   Description: This routine will write the new reverb volume
605
                register to hardware.
606
  
607
   Parameters:  trident - pointer to target device class for 4DWave.
608
                voice - synthesizer voice structure
609
                RVol - new reverb volume
610
  
611
  ---------------------------------------------------------------------------*/
612

613
static void snd_trident_write_rvol_reg(struct snd_trident * trident,
614
				       struct snd_trident_voice * voice,
615
				       unsigned int RVol)
616
{
617
	voice->RVol = RVol;
618
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
619
	outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
620
	     (voice->CVol & 0x007f),
621
	     TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
622
		      CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
623
}
624

625
/*---------------------------------------------------------------------------
626
   snd_trident_write_cvol_reg
627
  
628
   Description: This routine will write the new chorus volume
629
                register to hardware.
630
  
631
   Parameters:  trident - pointer to target device class for 4DWave.
632
                voice - synthesizer voice structure
633
                CVol - new chorus volume
634
  
635
  ---------------------------------------------------------------------------*/
636

637
static void snd_trident_write_cvol_reg(struct snd_trident * trident,
638
				       struct snd_trident_voice * voice,
639
				       unsigned int CVol)
640
{
641
	voice->CVol = CVol;
642
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
643
	outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
644
	     (voice->CVol & 0x007f),
645
	     TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
646
		      CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
647
}
648

649
/*---------------------------------------------------------------------------
650
   snd_trident_convert_rate
651

652
   Description: This routine converts rate in HZ to hardware delta value.
653
  
654
   Parameters:  trident - pointer to target device class for 4DWave.
655
                rate - Real or Virtual channel number.
656
  
657
   Returns:     Delta value.
658
  
659
  ---------------------------------------------------------------------------*/
660
static unsigned int snd_trident_convert_rate(unsigned int rate)
661
{
662
	unsigned int delta;
663

664
	// We special case 44100 and 8000 since rounding with the equation
665
	// does not give us an accurate enough value. For 11025 and 22050
666
	// the equation gives us the best answer. All other frequencies will
667
	// also use the equation. JDW
668
	if (rate == 44100)
669
		delta = 0xeb3;
670
	else if (rate == 8000)
671
		delta = 0x2ab;
672
	else if (rate == 48000)
673
		delta = 0x1000;
674
	else
675
		delta = DIV_ROUND_CLOSEST(rate << 12, 48000) & 0x0000ffff;
676
	return delta;
677
}
678

679
/*---------------------------------------------------------------------------
680
   snd_trident_convert_adc_rate
681

682
   Description: This routine converts rate in HZ to hardware delta value.
683
  
684
   Parameters:  trident - pointer to target device class for 4DWave.
685
                rate - Real or Virtual channel number.
686
  
687
   Returns:     Delta value.
688
  
689
  ---------------------------------------------------------------------------*/
690
static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
691
{
692
	unsigned int delta;
693

694
	// We special case 44100 and 8000 since rounding with the equation
695
	// does not give us an accurate enough value. For 11025 and 22050
696
	// the equation gives us the best answer. All other frequencies will
697
	// also use the equation. JDW
698
	if (rate == 44100)
699
		delta = 0x116a;
700
	else if (rate == 8000)
701
		delta = 0x6000;
702
	else if (rate == 48000)
703
		delta = 0x1000;
704
	else
705
		delta = ((48000 << 12) / rate) & 0x0000ffff;
706
	return delta;
707
}
708

709
/*---------------------------------------------------------------------------
710
   snd_trident_spurious_threshold
711

712
   Description: This routine converts rate in HZ to spurious threshold.
713
  
714
   Parameters:  trident - pointer to target device class for 4DWave.
715
                rate - Real or Virtual channel number.
716
  
717
   Returns:     Delta value.
718
  
719
  ---------------------------------------------------------------------------*/
720
static unsigned int snd_trident_spurious_threshold(unsigned int rate,
721
						   unsigned int period_size)
722
{
723
	unsigned int res = (rate * period_size) / 48000;
724
	if (res < 64)
725
		res = res / 2;
726
	else
727
		res -= 32;
728
	return res;
729
}
730

731
/*---------------------------------------------------------------------------
732
   snd_trident_control_mode
733

734
   Description: This routine returns a control mode for a PCM channel.
735
  
736
   Parameters:  trident - pointer to target device class for 4DWave.
737
                substream  - PCM substream
738
  
739
   Returns:     Control value.
740
  
741
  ---------------------------------------------------------------------------*/
742
static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
743
{
744
	unsigned int CTRL;
745
	struct snd_pcm_runtime *runtime = substream->runtime;
746

747
	/* set ctrl mode
748
	   CTRL default: 8-bit (unsigned) mono, loop mode enabled
749
	 */
750
	CTRL = 0x00000001;
751
	if (snd_pcm_format_width(runtime->format) == 16)
752
		CTRL |= 0x00000008;	// 16-bit data
753
	if (snd_pcm_format_signed(runtime->format))
754
		CTRL |= 0x00000002;	// signed data
755
	if (runtime->channels > 1)
756
		CTRL |= 0x00000004;	// stereo data
757
	return CTRL;
758
}
759

760
/*
761
 *  PCM part
762
 */
763

764
/*---------------------------------------------------------------------------
765
   snd_trident_allocate_pcm_mem
766
  
767
   Description: Allocate PCM ring buffer for given substream
768
  
769
   Parameters:  substream  - PCM substream class
770
		hw_params  - hardware parameters
771
  
772
   Returns:     Error status
773
  
774
  ---------------------------------------------------------------------------*/
775

776
static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
777
					struct snd_pcm_hw_params *hw_params)
778
{
779
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
780
	struct snd_pcm_runtime *runtime = substream->runtime;
781
	struct snd_trident_voice *voice = runtime->private_data;
782

783
	if (trident->tlb.entries) {
784
		if (runtime->buffer_changed) {
785
			if (voice->memblk)
786
				snd_trident_free_pages(trident, voice->memblk);
787
			voice->memblk = snd_trident_alloc_pages(trident, substream);
788
			if (voice->memblk == NULL)
789
				return -ENOMEM;
790
		}
791
	}
792
	return 0;
793
}
794

795
/*---------------------------------------------------------------------------
796
   snd_trident_allocate_evoice
797
  
798
   Description: Allocate extra voice as interrupt generator
799
  
800
   Parameters:  substream  - PCM substream class
801
		hw_params  - hardware parameters
802
  
803
   Returns:     Error status
804
  
805
  ---------------------------------------------------------------------------*/
806

807
static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
808
				       struct snd_pcm_hw_params *hw_params)
809
{
810
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
811
	struct snd_pcm_runtime *runtime = substream->runtime;
812
	struct snd_trident_voice *voice = runtime->private_data;
813
	struct snd_trident_voice *evoice = voice->extra;
814

815
	/* voice management */
816

817
	if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) {
818
		if (evoice == NULL) {
819
			evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
820
			if (evoice == NULL)
821
				return -ENOMEM;
822
			voice->extra = evoice;
823
			evoice->substream = substream;
824
		}
825
	} else {
826
		if (evoice != NULL) {
827
			snd_trident_free_voice(trident, evoice);
828
			voice->extra = evoice = NULL;
829
		}
830
	}
831

832
	return 0;
833
}
834

835
/*---------------------------------------------------------------------------
836
   snd_trident_hw_params
837
  
838
   Description: Set the hardware parameters for the playback device.
839
  
840
   Parameters:  substream  - PCM substream class
841
		hw_params  - hardware parameters
842
  
843
   Returns:     Error status
844
  
845
  ---------------------------------------------------------------------------*/
846

847
static int snd_trident_hw_params(struct snd_pcm_substream *substream,
848
				 struct snd_pcm_hw_params *hw_params)
849
{
850
	int err;
851

852
	err = snd_trident_allocate_pcm_mem(substream, hw_params);
853
	if (err >= 0)
854
		err = snd_trident_allocate_evoice(substream, hw_params);
855
	return err;
856
}
857

858
/*---------------------------------------------------------------------------
859
   snd_trident_playback_hw_free
860
  
861
   Description: Release the hardware resources for the playback device.
862
  
863
   Parameters:  substream  - PCM substream class
864
  
865
   Returns:     Error status
866
  
867
  ---------------------------------------------------------------------------*/
868

869
static int snd_trident_hw_free(struct snd_pcm_substream *substream)
870
{
871
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
872
	struct snd_pcm_runtime *runtime = substream->runtime;
873
	struct snd_trident_voice *voice = runtime->private_data;
874
	struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
875

876
	if (trident->tlb.entries) {
877
		if (voice && voice->memblk) {
878
			snd_trident_free_pages(trident, voice->memblk);
879
			voice->memblk = NULL;
880
		}
881
	}
882
	if (evoice != NULL) {
883
		snd_trident_free_voice(trident, evoice);
884
		voice->extra = NULL;
885
	}
886
	return 0;
887
}
888

889
/*---------------------------------------------------------------------------
890
   snd_trident_playback_prepare
891
  
892
   Description: Prepare playback device for playback.
893
  
894
   Parameters:  substream  - PCM substream class
895
  
896
   Returns:     Error status
897
  
898
  ---------------------------------------------------------------------------*/
899

900
static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
901
{
902
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
903
	struct snd_pcm_runtime *runtime = substream->runtime;
904
	struct snd_trident_voice *voice = runtime->private_data;
905
	struct snd_trident_voice *evoice = voice->extra;
906
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
907

908
	guard(spinlock_irq)(&trident->reg_lock);
909

910
	/* set delta (rate) value */
911
	voice->Delta = snd_trident_convert_rate(runtime->rate);
912
	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
913

914
	/* set Loop Begin Address */
915
	if (voice->memblk)
916
		voice->LBA = voice->memblk->offset;
917
	else
918
		voice->LBA = runtime->dma_addr;
919
 
920
	voice->CSO = 0;
921
	voice->ESO = runtime->buffer_size - 1;	/* in samples */
922
	voice->CTRL = snd_trident_control_mode(substream);
923
	voice->FMC = 3;
924
	voice->GVSel = 1;
925
	voice->EC = 0;
926
	voice->Alpha = 0;
927
	voice->FMS = 0;
928
	voice->Vol = mix->vol;
929
	voice->RVol = mix->rvol;
930
	voice->CVol = mix->cvol;
931
	voice->Pan = mix->pan;
932
	voice->Attribute = 0;
933
#if 0
934
	voice->Attribute = (1<<(30-16))|(2<<(26-16))|
935
			   (0<<(24-16))|(0x1f<<(19-16));
936
#else
937
	voice->Attribute = 0;
938
#endif
939

940
	snd_trident_write_voice_regs(trident, voice);
941

942
	if (evoice != NULL) {
943
		evoice->Delta = voice->Delta;
944
		evoice->spurious_threshold = voice->spurious_threshold;
945
		evoice->LBA = voice->LBA;
946
		evoice->CSO = 0;
947
		evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
948
		evoice->CTRL = voice->CTRL;
949
		evoice->FMC = 3;
950
		evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
951
		evoice->EC = 0;
952
		evoice->Alpha = 0;
953
		evoice->FMS = 0;
954
		evoice->Vol = 0x3ff;			/* mute */
955
		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
956
		evoice->Pan = 0x7f;			/* mute */
957
#if 0
958
		evoice->Attribute = (1<<(30-16))|(2<<(26-16))|
959
				    (0<<(24-16))|(0x1f<<(19-16));
960
#else
961
		evoice->Attribute = 0;
962
#endif
963
		snd_trident_write_voice_regs(trident, evoice);
964
		evoice->isync2 = 1;
965
		evoice->isync_mark = runtime->period_size;
966
		evoice->ESO = (runtime->period_size * 2) - 1;
967
	}
968

969
	return 0;
970
}
971

972
/*---------------------------------------------------------------------------
973
   snd_trident_capture_hw_params
974
  
975
   Description: Set the hardware parameters for the capture device.
976
  
977
   Parameters:  substream  - PCM substream class
978
		hw_params  - hardware parameters
979
  
980
   Returns:     Error status
981
  
982
  ---------------------------------------------------------------------------*/
983

984
static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
985
					 struct snd_pcm_hw_params *hw_params)
986
{
987
	return snd_trident_allocate_pcm_mem(substream, hw_params);
988
}
989

990
/*---------------------------------------------------------------------------
991
   snd_trident_capture_prepare
992
  
993
   Description: Prepare capture device for playback.
994
  
995
   Parameters:  substream  - PCM substream class
996
  
997
   Returns:     Error status
998
  
999
  ---------------------------------------------------------------------------*/
1000

1001
static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
1002
{
1003
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1004
	struct snd_pcm_runtime *runtime = substream->runtime;
1005
	struct snd_trident_voice *voice = runtime->private_data;
1006
	unsigned int val, ESO_bytes;
1007

1008
	guard(spinlock_irq)(&trident->reg_lock);
1009

1010
	// Initialize the channel and set channel Mode
1011
	outb(0, TRID_REG(trident, LEGACY_DMAR15));
1012

1013
	// Set DMA channel operation mode register
1014
	outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1015

1016
	// Set channel buffer Address, DMAR0 expects contiguous PCI memory area	
1017
	voice->LBA = runtime->dma_addr;
1018
	outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1019
	if (voice->memblk)
1020
		voice->LBA = voice->memblk->offset;
1021

1022
	// set ESO
1023
	ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1;
1024
	outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1025
	outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1026
	ESO_bytes++;
1027

1028
	// Set channel sample rate, 4.12 format
1029
	val = DIV_ROUND_CLOSEST(48000U << 12, runtime->rate);
1030
	outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1031

1032
	// Set channel interrupt blk length
1033
	if (snd_pcm_format_width(runtime->format) == 16) {
1034
		val = (unsigned short) ((ESO_bytes >> 1) - 1);
1035
	} else {
1036
		val = (unsigned short) (ESO_bytes - 1);
1037
	}
1038

1039
	outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1040

1041
	// Right now, set format and start to run captureing, 
1042
	// continuous run loop enable.
1043
	trident->bDMAStart = 0x19;	// 0001 1001b
1044

1045
	if (snd_pcm_format_width(runtime->format) == 16)
1046
		trident->bDMAStart |= 0x80;
1047
	if (snd_pcm_format_signed(runtime->format))
1048
		trident->bDMAStart |= 0x20;
1049
	if (runtime->channels > 1)
1050
		trident->bDMAStart |= 0x40;
1051

1052
	// Prepare capture intr channel
1053

1054
	voice->Delta = snd_trident_convert_rate(runtime->rate);
1055
	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1056
	voice->isync = 1;
1057
	voice->isync_mark = runtime->period_size;
1058
	voice->isync_max = runtime->buffer_size;
1059

1060
	// Set voice parameters
1061
	voice->CSO = 0;
1062
	voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1063
	voice->CTRL = snd_trident_control_mode(substream);
1064
	voice->FMC = 3;
1065
	voice->RVol = 0x7f;
1066
	voice->CVol = 0x7f;
1067
	voice->GVSel = 1;
1068
	voice->Pan = 0x7f;		/* mute */
1069
	voice->Vol = 0x3ff;		/* mute */
1070
	voice->EC = 0;
1071
	voice->Alpha = 0;
1072
	voice->FMS = 0;
1073
	voice->Attribute = 0;
1074

1075
	snd_trident_write_voice_regs(trident, voice);
1076

1077
	return 0;
1078
}
1079

1080
/*---------------------------------------------------------------------------
1081
   snd_trident_si7018_capture_hw_params
1082
  
1083
   Description: Set the hardware parameters for the capture device.
1084
  
1085
   Parameters:  substream  - PCM substream class
1086
		hw_params  - hardware parameters
1087
  
1088
   Returns:     Error status
1089
  
1090
  ---------------------------------------------------------------------------*/
1091

1092
static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
1093
						struct snd_pcm_hw_params *hw_params)
1094
{
1095
	return snd_trident_allocate_evoice(substream, hw_params);
1096
}
1097

1098
/*---------------------------------------------------------------------------
1099
   snd_trident_si7018_capture_hw_free
1100
  
1101
   Description: Release the hardware resources for the capture device.
1102
  
1103
   Parameters:  substream  - PCM substream class
1104
  
1105
   Returns:     Error status
1106
  
1107
  ---------------------------------------------------------------------------*/
1108

1109
static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
1110
{
1111
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1112
	struct snd_pcm_runtime *runtime = substream->runtime;
1113
	struct snd_trident_voice *voice = runtime->private_data;
1114
	struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
1115

1116
	if (evoice != NULL) {
1117
		snd_trident_free_voice(trident, evoice);
1118
		voice->extra = NULL;
1119
	}
1120
	return 0;
1121
}
1122

1123
/*---------------------------------------------------------------------------
1124
   snd_trident_si7018_capture_prepare
1125
  
1126
   Description: Prepare capture device for playback.
1127
  
1128
   Parameters:  substream  - PCM substream class
1129
  
1130
   Returns:     Error status
1131
  
1132
  ---------------------------------------------------------------------------*/
1133

1134
static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
1135
{
1136
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1137
	struct snd_pcm_runtime *runtime = substream->runtime;
1138
	struct snd_trident_voice *voice = runtime->private_data;
1139
	struct snd_trident_voice *evoice = voice->extra;
1140

1141
	guard(spinlock_irq)(&trident->reg_lock);
1142

1143
	voice->LBA = runtime->dma_addr;
1144
	voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
1145
	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1146

1147
	// Set voice parameters
1148
	voice->CSO = 0;
1149
	voice->ESO = runtime->buffer_size - 1;		/* in samples */
1150
	voice->CTRL = snd_trident_control_mode(substream);
1151
	voice->FMC = 0;
1152
	voice->RVol = 0;
1153
	voice->CVol = 0;
1154
	voice->GVSel = 1;
1155
	voice->Pan = T4D_DEFAULT_PCM_PAN;
1156
	voice->Vol = 0;
1157
	voice->EC = 0;
1158
	voice->Alpha = 0;
1159
	voice->FMS = 0;
1160

1161
	voice->Attribute = (2 << (30-16)) |
1162
			   (2 << (26-16)) |
1163
			   (2 << (24-16)) |
1164
			   (1 << (23-16));
1165

1166
	snd_trident_write_voice_regs(trident, voice);
1167

1168
	if (evoice != NULL) {
1169
		evoice->Delta = snd_trident_convert_rate(runtime->rate);
1170
		evoice->spurious_threshold = voice->spurious_threshold;
1171
		evoice->LBA = voice->LBA;
1172
		evoice->CSO = 0;
1173
		evoice->ESO = (runtime->period_size * 2) + 20 - 1; /* in samples, 20 means correction */
1174
		evoice->CTRL = voice->CTRL;
1175
		evoice->FMC = 3;
1176
		evoice->GVSel = 0;
1177
		evoice->EC = 0;
1178
		evoice->Alpha = 0;
1179
		evoice->FMS = 0;
1180
		evoice->Vol = 0x3ff;			/* mute */
1181
		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
1182
		evoice->Pan = 0x7f;			/* mute */
1183
		evoice->Attribute = 0;
1184
		snd_trident_write_voice_regs(trident, evoice);
1185
		evoice->isync2 = 1;
1186
		evoice->isync_mark = runtime->period_size;
1187
		evoice->ESO = (runtime->period_size * 2) - 1;
1188
	}
1189
	
1190
	return 0;
1191
}
1192

1193
/*---------------------------------------------------------------------------
1194
   snd_trident_foldback_prepare
1195
  
1196
   Description: Prepare foldback capture device for playback.
1197
  
1198
   Parameters:  substream  - PCM substream class
1199
  
1200
   Returns:     Error status
1201
  
1202
  ---------------------------------------------------------------------------*/
1203

1204
static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
1205
{
1206
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1207
	struct snd_pcm_runtime *runtime = substream->runtime;
1208
	struct snd_trident_voice *voice = runtime->private_data;
1209
	struct snd_trident_voice *evoice = voice->extra;
1210

1211
	guard(spinlock_irq)(&trident->reg_lock);
1212

1213
	/* Set channel buffer Address */
1214
	if (voice->memblk)
1215
		voice->LBA = voice->memblk->offset;
1216
	else
1217
		voice->LBA = runtime->dma_addr;
1218

1219
	/* set target ESO for channel */
1220
	voice->ESO = runtime->buffer_size - 1;	/* in samples */
1221

1222
	/* set sample rate */
1223
	voice->Delta = 0x1000;
1224
	voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1225

1226
	voice->CSO = 0;
1227
	voice->CTRL = snd_trident_control_mode(substream);
1228
	voice->FMC = 3;
1229
	voice->RVol = 0x7f;
1230
	voice->CVol = 0x7f;
1231
	voice->GVSel = 1;
1232
	voice->Pan = 0x7f;	/* mute */
1233
	voice->Vol = 0x3ff;	/* mute */
1234
	voice->EC = 0;
1235
	voice->Alpha = 0;
1236
	voice->FMS = 0;
1237
	voice->Attribute = 0;
1238

1239
	/* set up capture channel */
1240
	outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1241

1242
	snd_trident_write_voice_regs(trident, voice);
1243

1244
	if (evoice != NULL) {
1245
		evoice->Delta = voice->Delta;
1246
		evoice->spurious_threshold = voice->spurious_threshold;
1247
		evoice->LBA = voice->LBA;
1248
		evoice->CSO = 0;
1249
		evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1250
		evoice->CTRL = voice->CTRL;
1251
		evoice->FMC = 3;
1252
		evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1253
		evoice->EC = 0;
1254
		evoice->Alpha = 0;
1255
		evoice->FMS = 0;
1256
		evoice->Vol = 0x3ff;			/* mute */
1257
		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
1258
		evoice->Pan = 0x7f;			/* mute */
1259
		evoice->Attribute = 0;
1260
		snd_trident_write_voice_regs(trident, evoice);
1261
		evoice->isync2 = 1;
1262
		evoice->isync_mark = runtime->period_size;
1263
		evoice->ESO = (runtime->period_size * 2) - 1;
1264
	}
1265

1266
	return 0;
1267
}
1268

1269
/*---------------------------------------------------------------------------
1270
   snd_trident_spdif_hw_params
1271
  
1272
   Description: Set the hardware parameters for the spdif device.
1273
  
1274
   Parameters:  substream  - PCM substream class
1275
		hw_params  - hardware parameters
1276
  
1277
   Returns:     Error status
1278
  
1279
  ---------------------------------------------------------------------------*/
1280

1281
static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
1282
				       struct snd_pcm_hw_params *hw_params)
1283
{
1284
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1285
	unsigned int old_bits = 0, change = 0;
1286
	int err;
1287

1288
	err = snd_trident_allocate_pcm_mem(substream, hw_params);
1289
	if (err < 0)
1290
		return err;
1291

1292
	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1293
		err = snd_trident_allocate_evoice(substream, hw_params);
1294
		if (err < 0)
1295
			return err;
1296
	}
1297

1298
	/* prepare SPDIF channel */
1299
	scoped_guard(spinlock_irq, &trident->reg_lock) {
1300
		old_bits = trident->spdif_pcm_bits;
1301
		if (old_bits & IEC958_AES0_PROFESSIONAL)
1302
			trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1303
		else
1304
			trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1305
		if (params_rate(hw_params) >= 48000) {
1306
			trident->spdif_pcm_ctrl = 0x3c;	// 48000 Hz
1307
			trident->spdif_pcm_bits |=
1308
				trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1309
				IEC958_AES0_PRO_FS_48000 :
1310
				(IEC958_AES3_CON_FS_48000 << 24);
1311
		} else if (params_rate(hw_params) >= 44100) {
1312
			trident->spdif_pcm_ctrl = 0x3e;	// 44100 Hz
1313
			trident->spdif_pcm_bits |=
1314
				trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1315
				IEC958_AES0_PRO_FS_44100 :
1316
				(IEC958_AES3_CON_FS_44100 << 24);
1317
		} else {
1318
			trident->spdif_pcm_ctrl = 0x3d;	// 32000 Hz
1319
			trident->spdif_pcm_bits |=
1320
				trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1321
				IEC958_AES0_PRO_FS_32000 :
1322
				(IEC958_AES3_CON_FS_32000 << 24);
1323
		}
1324
		change = old_bits != trident->spdif_pcm_bits;
1325
	}
1326

1327
	if (change)
1328
		snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1329

1330
	return 0;
1331
}
1332

1333
/*---------------------------------------------------------------------------
1334
   snd_trident_spdif_prepare
1335
  
1336
   Description: Prepare SPDIF device for playback.
1337
  
1338
   Parameters:  substream  - PCM substream class
1339
  
1340
   Returns:     Error status
1341
  
1342
  ---------------------------------------------------------------------------*/
1343

1344
static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
1345
{
1346
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1347
	struct snd_pcm_runtime *runtime = substream->runtime;
1348
	struct snd_trident_voice *voice = runtime->private_data;
1349
	struct snd_trident_voice *evoice = voice->extra;
1350
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1351
	unsigned int RESO, LBAO;
1352
	unsigned int temp;
1353

1354
	guard(spinlock_irq)(&trident->reg_lock);
1355

1356
	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1357

1358
		/* set delta (rate) value */
1359
		voice->Delta = snd_trident_convert_rate(runtime->rate);
1360
		voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1361

1362
		/* set Loop Back Address */
1363
		LBAO = runtime->dma_addr;
1364
		if (voice->memblk)
1365
			voice->LBA = voice->memblk->offset;
1366
		else
1367
			voice->LBA = LBAO;
1368

1369
		voice->isync = 1;
1370
		voice->isync3 = 1;
1371
		voice->isync_mark = runtime->period_size;
1372
		voice->isync_max = runtime->buffer_size;
1373

1374
		/* set target ESO for channel */
1375
		RESO = runtime->buffer_size - 1;
1376
		voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1377

1378
		/* set ctrl mode */
1379
		voice->CTRL = snd_trident_control_mode(substream);
1380

1381
		voice->FMC = 3;
1382
		voice->RVol = 0x7f;
1383
		voice->CVol = 0x7f;
1384
		voice->GVSel = 1;
1385
		voice->Pan = 0x7f;
1386
		voice->Vol = 0x3ff;
1387
		voice->EC = 0;
1388
		voice->CSO = 0;
1389
		voice->Alpha = 0;
1390
		voice->FMS = 0;
1391
		voice->Attribute = 0;
1392

1393
		/* prepare surrogate IRQ channel */
1394
		snd_trident_write_voice_regs(trident, voice);
1395

1396
		outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1397
		outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1398
		outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1399
		outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1400
		outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1401

1402
		/* set SPDIF setting */
1403
		outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1404
		outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1405

1406
	} else {	/* SiS */
1407
	
1408
		/* set delta (rate) value */
1409
		voice->Delta = 0x800;
1410
		voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1411

1412
		/* set Loop Begin Address */
1413
		if (voice->memblk)
1414
			voice->LBA = voice->memblk->offset;
1415
		else
1416
			voice->LBA = runtime->dma_addr;
1417

1418
		voice->CSO = 0;
1419
		voice->ESO = runtime->buffer_size - 1;	/* in samples */
1420
		voice->CTRL = snd_trident_control_mode(substream);
1421
		voice->FMC = 3;
1422
		voice->GVSel = 1;
1423
		voice->EC = 0;
1424
		voice->Alpha = 0;
1425
		voice->FMS = 0;
1426
		voice->Vol = mix->vol;
1427
		voice->RVol = mix->rvol;
1428
		voice->CVol = mix->cvol;
1429
		voice->Pan = mix->pan;
1430
		voice->Attribute = (1<<(30-16))|(7<<(26-16))|
1431
				   (0<<(24-16))|(0<<(19-16));
1432

1433
		snd_trident_write_voice_regs(trident, voice);
1434

1435
		if (evoice != NULL) {
1436
			evoice->Delta = voice->Delta;
1437
			evoice->spurious_threshold = voice->spurious_threshold;
1438
			evoice->LBA = voice->LBA;
1439
			evoice->CSO = 0;
1440
			evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1441
			evoice->CTRL = voice->CTRL;
1442
			evoice->FMC = 3;
1443
			evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1444
			evoice->EC = 0;
1445
			evoice->Alpha = 0;
1446
			evoice->FMS = 0;
1447
			evoice->Vol = 0x3ff;			/* mute */
1448
			evoice->RVol = evoice->CVol = 0x7f;	/* mute */
1449
			evoice->Pan = 0x7f;			/* mute */
1450
			evoice->Attribute = 0;
1451
			snd_trident_write_voice_regs(trident, evoice);
1452
			evoice->isync2 = 1;
1453
			evoice->isync_mark = runtime->period_size;
1454
			evoice->ESO = (runtime->period_size * 2) - 1;
1455
		}
1456

1457
		outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1458
		temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1459
		temp &= ~(1<<19);
1460
		outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1461
		temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1462
		temp |= SPDIF_EN;
1463
		outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1464
	}
1465

1466
	return 0;
1467
}
1468

1469
/*---------------------------------------------------------------------------
1470
   snd_trident_trigger
1471
  
1472
   Description: Start/stop devices
1473
  
1474
   Parameters:  substream  - PCM substream class
1475
   		cmd	- trigger command (STOP, GO)
1476
  
1477
   Returns:     Error status
1478
  
1479
  ---------------------------------------------------------------------------*/
1480

1481
static int snd_trident_trigger(struct snd_pcm_substream *substream,
1482
			       int cmd)
1483
				    
1484
{
1485
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1486
	struct snd_pcm_substream *s;
1487
	unsigned int what, whati, capture_flag, spdif_flag;
1488
	struct snd_trident_voice *voice, *evoice;
1489
	unsigned int val, go;
1490

1491
	switch (cmd) {
1492
	case SNDRV_PCM_TRIGGER_START:
1493
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1494
	case SNDRV_PCM_TRIGGER_RESUME:
1495
		go = 1;
1496
		break;
1497
	case SNDRV_PCM_TRIGGER_STOP:
1498
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1499
	case SNDRV_PCM_TRIGGER_SUSPEND:
1500
		go = 0;
1501
		break;
1502
	default:
1503
		return -EINVAL;
1504
	}
1505
	what = whati = capture_flag = spdif_flag = 0;
1506
	guard(spinlock)(&trident->reg_lock);
1507
	val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1508
	snd_pcm_group_for_each_entry(s, substream) {
1509
		if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1510
			voice = s->runtime->private_data;
1511
			evoice = voice->extra;
1512
			what |= 1 << (voice->number & 0x1f);
1513
			if (evoice == NULL) {
1514
				whati |= 1 << (voice->number & 0x1f);
1515
			} else {
1516
				what |= 1 << (evoice->number & 0x1f);
1517
				whati |= 1 << (evoice->number & 0x1f);
1518
				if (go)
1519
					evoice->stimer = val;
1520
			}
1521
			if (go) {
1522
				voice->running = 1;
1523
				voice->stimer = val;
1524
			} else {
1525
				voice->running = 0;
1526
			}
1527
			snd_pcm_trigger_done(s, substream);
1528
			if (voice->capture)
1529
				capture_flag = 1;
1530
			if (voice->spdif)
1531
				spdif_flag = 1;
1532
		}
1533
	}
1534
	if (spdif_flag) {
1535
		if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1536
			outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1537
			val = trident->spdif_pcm_ctrl;
1538
			if (!go)
1539
				val &= ~(0x28);
1540
			outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1541
		} else {
1542
			outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1543
			val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1544
			outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1545
		}
1546
	}
1547
	if (!go)
1548
		outl(what, TRID_REG(trident, T4D_STOP_B));
1549
	val = inl(TRID_REG(trident, T4D_AINTEN_B));
1550
	if (go) {
1551
		val |= whati;
1552
	} else {
1553
		val &= ~whati;
1554
	}
1555
	outl(val, TRID_REG(trident, T4D_AINTEN_B));
1556
	if (go) {
1557
		outl(what, TRID_REG(trident, T4D_START_B));
1558

1559
		if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1560
			outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1561
	} else {
1562
		if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1563
			outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1564
	}
1565
	return 0;
1566
}
1567

1568
/*---------------------------------------------------------------------------
1569
   snd_trident_playback_pointer
1570
  
1571
   Description: This routine return the playback position
1572
                
1573
   Parameters:	substream  - PCM substream class
1574

1575
   Returns:     position of buffer
1576
  
1577
  ---------------------------------------------------------------------------*/
1578

1579
static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
1580
{
1581
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1582
	struct snd_pcm_runtime *runtime = substream->runtime;
1583
	struct snd_trident_voice *voice = runtime->private_data;
1584
	unsigned int cso;
1585

1586
	if (!voice->running)
1587
		return 0;
1588

1589
	guard(spinlock)(&trident->reg_lock);
1590

1591
	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1592

1593
	if (trident->device != TRIDENT_DEVICE_ID_NX) {
1594
		cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1595
	} else {		// ID_4DWAVE_NX
1596
		cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1597
	}
1598

1599
	if (cso >= runtime->buffer_size)
1600
		cso = 0;
1601

1602
	return cso;
1603
}
1604

1605
/*---------------------------------------------------------------------------
1606
   snd_trident_capture_pointer
1607
  
1608
   Description: This routine return the capture position
1609
                
1610
   Parameters:   pcm1    - PCM device class
1611

1612
   Returns:     position of buffer
1613
  
1614
  ---------------------------------------------------------------------------*/
1615

1616
static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
1617
{
1618
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1619
	struct snd_pcm_runtime *runtime = substream->runtime;
1620
	struct snd_trident_voice *voice = runtime->private_data;
1621
	unsigned int result;
1622

1623
	if (!voice->running)
1624
		return 0;
1625

1626
	result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1627
	if (runtime->channels > 1)
1628
		result >>= 1;
1629
	if (result > 0)
1630
		result = runtime->buffer_size - result;
1631

1632
	return result;
1633
}
1634

1635
/*---------------------------------------------------------------------------
1636
   snd_trident_spdif_pointer
1637
  
1638
   Description: This routine return the SPDIF playback position
1639
                
1640
   Parameters:	substream  - PCM substream class
1641

1642
   Returns:     position of buffer
1643
  
1644
  ---------------------------------------------------------------------------*/
1645

1646
static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
1647
{
1648
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1649
	struct snd_pcm_runtime *runtime = substream->runtime;
1650
	struct snd_trident_voice *voice = runtime->private_data;
1651
	unsigned int result;
1652

1653
	if (!voice->running)
1654
		return 0;
1655

1656
	result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1657

1658
	return result;
1659
}
1660

1661
/*
1662
 *  Playback support device description
1663
 */
1664

1665
static const struct snd_pcm_hardware snd_trident_playback =
1666
{
1667
	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1668
				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1669
				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1670
				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1671
	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1672
				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1673
	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1674
	.rate_min =		4000,
1675
	.rate_max =		48000,
1676
	.channels_min =		1,
1677
	.channels_max =		2,
1678
	.buffer_bytes_max =	(256*1024),
1679
	.period_bytes_min =	64,
1680
	.period_bytes_max =	(256*1024),
1681
	.periods_min =		1,
1682
	.periods_max =		1024,
1683
	.fifo_size =		0,
1684
};
1685

1686
/*
1687
 *  Capture support device description
1688
 */
1689

1690
static const struct snd_pcm_hardware snd_trident_capture =
1691
{
1692
	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1693
				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1694
				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1695
				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1696
	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1697
				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1698
	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1699
	.rate_min =		4000,
1700
	.rate_max =		48000,
1701
	.channels_min =		1,
1702
	.channels_max =		2,
1703
	.buffer_bytes_max =	(128*1024),
1704
	.period_bytes_min =	64,
1705
	.period_bytes_max =	(128*1024),
1706
	.periods_min =		1,
1707
	.periods_max =		1024,
1708
	.fifo_size =		0,
1709
};
1710

1711
/*
1712
 *  Foldback capture support device description
1713
 */
1714

1715
static const struct snd_pcm_hardware snd_trident_foldback =
1716
{
1717
	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1718
				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1719
				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1720
				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1721
	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
1722
	.rates =		SNDRV_PCM_RATE_48000,
1723
	.rate_min =		48000,
1724
	.rate_max =		48000,
1725
	.channels_min =		2,
1726
	.channels_max =		2,
1727
	.buffer_bytes_max =	(128*1024),
1728
	.period_bytes_min =	64,
1729
	.period_bytes_max =	(128*1024),
1730
	.periods_min =		1,
1731
	.periods_max =		1024,
1732
	.fifo_size =		0,
1733
};
1734

1735
/*
1736
 *  SPDIF playback support device description
1737
 */
1738

1739
static const struct snd_pcm_hardware snd_trident_spdif =
1740
{
1741
	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1742
				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1743
				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1744
				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1745
	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
1746
	.rates =		(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
1747
				 SNDRV_PCM_RATE_48000),
1748
	.rate_min =		32000,
1749
	.rate_max =		48000,
1750
	.channels_min =		2,
1751
	.channels_max =		2,
1752
	.buffer_bytes_max =	(128*1024),
1753
	.period_bytes_min =	64,
1754
	.period_bytes_max =	(128*1024),
1755
	.periods_min =		1,
1756
	.periods_max =		1024,
1757
	.fifo_size =		0,
1758
};
1759

1760
static const struct snd_pcm_hardware snd_trident_spdif_7018 =
1761
{
1762
	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1763
				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1764
				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1765
				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1766
	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
1767
	.rates =		SNDRV_PCM_RATE_48000,
1768
	.rate_min =		48000,
1769
	.rate_max =		48000,
1770
	.channels_min =		2,
1771
	.channels_max =		2,
1772
	.buffer_bytes_max =	(128*1024),
1773
	.period_bytes_min =	64,
1774
	.period_bytes_max =	(128*1024),
1775
	.periods_min =		1,
1776
	.periods_max =		1024,
1777
	.fifo_size =		0,
1778
};
1779

1780
static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
1781
{
1782
	struct snd_trident_voice *voice = runtime->private_data;
1783
	struct snd_trident *trident;
1784

1785
	if (voice) {
1786
		trident = voice->trident;
1787
		snd_trident_free_voice(trident, voice);
1788
	}
1789
}
1790

1791
static int snd_trident_playback_open(struct snd_pcm_substream *substream)
1792
{
1793
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1794
	struct snd_pcm_runtime *runtime = substream->runtime;
1795
	struct snd_trident_voice *voice;
1796

1797
	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1798
	if (voice == NULL)
1799
		return -EAGAIN;
1800
	snd_trident_pcm_mixer_build(trident, voice, substream);
1801
	voice->substream = substream;
1802
	runtime->private_data = voice;
1803
	runtime->private_free = snd_trident_pcm_free_substream;
1804
	runtime->hw = snd_trident_playback;
1805
	snd_pcm_set_sync(substream);
1806
	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1807
	return 0;
1808
}
1809

1810
/*---------------------------------------------------------------------------
1811
   snd_trident_playback_close
1812
  
1813
   Description: This routine will close the 4DWave playback device. For now 
1814
                we will simply free the dma transfer buffer.
1815
                
1816
   Parameters:	substream  - PCM substream class
1817

1818
  ---------------------------------------------------------------------------*/
1819
static int snd_trident_playback_close(struct snd_pcm_substream *substream)
1820
{
1821
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1822
	struct snd_pcm_runtime *runtime = substream->runtime;
1823
	struct snd_trident_voice *voice = runtime->private_data;
1824

1825
	snd_trident_pcm_mixer_free(trident, voice, substream);
1826
	return 0;
1827
}
1828

1829
/*---------------------------------------------------------------------------
1830
   snd_trident_spdif_open
1831
  
1832
   Description: This routine will open the 4DWave SPDIF device.
1833

1834
   Parameters:	substream  - PCM substream class
1835

1836
   Returns:     status  - success or failure flag
1837
  
1838
  ---------------------------------------------------------------------------*/
1839

1840
static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
1841
{
1842
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1843
	struct snd_trident_voice *voice;
1844
	struct snd_pcm_runtime *runtime = substream->runtime;
1845
	
1846
	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1847
	if (voice == NULL)
1848
		return -EAGAIN;
1849
	voice->spdif = 1;
1850
	voice->substream = substream;
1851
	scoped_guard(spinlock_irq, &trident->reg_lock) {
1852
		trident->spdif_pcm_bits = trident->spdif_bits;
1853
	}
1854

1855
	runtime->private_data = voice;
1856
	runtime->private_free = snd_trident_pcm_free_substream;
1857
	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1858
		runtime->hw = snd_trident_spdif;
1859
	} else {
1860
		runtime->hw = snd_trident_spdif_7018;
1861
	}
1862

1863
	trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1864
	snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1865
		       SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1866

1867
	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1868
	return 0;
1869
}
1870

1871

1872
/*---------------------------------------------------------------------------
1873
   snd_trident_spdif_close
1874
  
1875
   Description: This routine will close the 4DWave SPDIF device.
1876
                
1877
   Parameters:	substream  - PCM substream class
1878

1879
  ---------------------------------------------------------------------------*/
1880

1881
static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
1882
{
1883
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1884
	unsigned int temp;
1885

1886
	scoped_guard(spinlock_irq, &trident->reg_lock) {
1887
		// restore default SPDIF setting
1888
		if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1889
			outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1890
			outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1891
		} else {
1892
			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1893
			temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1894
			if (trident->spdif_ctrl) {
1895
				temp |= SPDIF_EN;
1896
			} else {
1897
				temp &= ~SPDIF_EN;
1898
			}
1899
			outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1900
		}
1901
	}
1902
	trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1903
	snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1904
		       SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1905
	return 0;
1906
}
1907

1908
/*---------------------------------------------------------------------------
1909
   snd_trident_capture_open
1910
  
1911
   Description: This routine will open the 4DWave capture device.
1912

1913
   Parameters:	substream  - PCM substream class
1914

1915
   Returns:     status  - success or failure flag
1916

1917
  ---------------------------------------------------------------------------*/
1918

1919
static int snd_trident_capture_open(struct snd_pcm_substream *substream)
1920
{
1921
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1922
	struct snd_trident_voice *voice;
1923
	struct snd_pcm_runtime *runtime = substream->runtime;
1924

1925
	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1926
	if (voice == NULL)
1927
		return -EAGAIN;
1928
	voice->capture = 1;
1929
	voice->substream = substream;
1930
	runtime->private_data = voice;
1931
	runtime->private_free = snd_trident_pcm_free_substream;
1932
	runtime->hw = snd_trident_capture;
1933
	snd_pcm_set_sync(substream);
1934
	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1935
	return 0;
1936
}
1937

1938
/*---------------------------------------------------------------------------
1939
   snd_trident_capture_close
1940
  
1941
   Description: This routine will close the 4DWave capture device. For now 
1942
                we will simply free the dma transfer buffer.
1943
                
1944
   Parameters:	substream  - PCM substream class
1945

1946
  ---------------------------------------------------------------------------*/
1947
static int snd_trident_capture_close(struct snd_pcm_substream *substream)
1948
{
1949
	return 0;
1950
}
1951

1952
/*---------------------------------------------------------------------------
1953
   snd_trident_foldback_open
1954
  
1955
   Description: This routine will open the 4DWave foldback capture device.
1956

1957
   Parameters:	substream  - PCM substream class
1958

1959
   Returns:     status  - success or failure flag
1960

1961
  ---------------------------------------------------------------------------*/
1962

1963
static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
1964
{
1965
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1966
	struct snd_trident_voice *voice;
1967
	struct snd_pcm_runtime *runtime = substream->runtime;
1968

1969
	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1970
	if (voice == NULL)
1971
		return -EAGAIN;
1972
	voice->foldback_chan = substream->number;
1973
	voice->substream = substream;
1974
	runtime->private_data = voice;
1975
	runtime->private_free = snd_trident_pcm_free_substream;
1976
	runtime->hw = snd_trident_foldback;
1977
	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1978
	return 0;
1979
}
1980

1981
/*---------------------------------------------------------------------------
1982
   snd_trident_foldback_close
1983
  
1984
   Description: This routine will close the 4DWave foldback capture device. 
1985
		For now we will simply free the dma transfer buffer.
1986
                
1987
   Parameters:	substream  - PCM substream class
1988

1989
  ---------------------------------------------------------------------------*/
1990
static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
1991
{
1992
	struct snd_trident *trident = snd_pcm_substream_chip(substream);
1993
	struct snd_trident_voice *voice;
1994
	struct snd_pcm_runtime *runtime = substream->runtime;
1995
	voice = runtime->private_data;
1996
	
1997
	/* stop capture channel */
1998
	guard(spinlock_irq)(&trident->reg_lock);
1999
	outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2000
	return 0;
2001
}
2002

2003
/*---------------------------------------------------------------------------
2004
   PCM operations
2005
  ---------------------------------------------------------------------------*/
2006

2007
static const struct snd_pcm_ops snd_trident_playback_ops = {
2008
	.open =		snd_trident_playback_open,
2009
	.close =	snd_trident_playback_close,
2010
	.hw_params =	snd_trident_hw_params,
2011
	.hw_free =	snd_trident_hw_free,
2012
	.prepare =	snd_trident_playback_prepare,
2013
	.trigger =	snd_trident_trigger,
2014
	.pointer =	snd_trident_playback_pointer,
2015
};
2016

2017
static const struct snd_pcm_ops snd_trident_nx_playback_ops = {
2018
	.open =		snd_trident_playback_open,
2019
	.close =	snd_trident_playback_close,
2020
	.hw_params =	snd_trident_hw_params,
2021
	.hw_free =	snd_trident_hw_free,
2022
	.prepare =	snd_trident_playback_prepare,
2023
	.trigger =	snd_trident_trigger,
2024
	.pointer =	snd_trident_playback_pointer,
2025
};
2026

2027
static const struct snd_pcm_ops snd_trident_capture_ops = {
2028
	.open =		snd_trident_capture_open,
2029
	.close =	snd_trident_capture_close,
2030
	.hw_params =	snd_trident_capture_hw_params,
2031
	.hw_free =	snd_trident_hw_free,
2032
	.prepare =	snd_trident_capture_prepare,
2033
	.trigger =	snd_trident_trigger,
2034
	.pointer =	snd_trident_capture_pointer,
2035
};
2036

2037
static const struct snd_pcm_ops snd_trident_si7018_capture_ops = {
2038
	.open =		snd_trident_capture_open,
2039
	.close =	snd_trident_capture_close,
2040
	.hw_params =	snd_trident_si7018_capture_hw_params,
2041
	.hw_free =	snd_trident_si7018_capture_hw_free,
2042
	.prepare =	snd_trident_si7018_capture_prepare,
2043
	.trigger =	snd_trident_trigger,
2044
	.pointer =	snd_trident_playback_pointer,
2045
};
2046

2047
static const struct snd_pcm_ops snd_trident_foldback_ops = {
2048
	.open =		snd_trident_foldback_open,
2049
	.close =	snd_trident_foldback_close,
2050
	.hw_params =	snd_trident_hw_params,
2051
	.hw_free =	snd_trident_hw_free,
2052
	.prepare =	snd_trident_foldback_prepare,
2053
	.trigger =	snd_trident_trigger,
2054
	.pointer =	snd_trident_playback_pointer,
2055
};
2056

2057
static const struct snd_pcm_ops snd_trident_nx_foldback_ops = {
2058
	.open =		snd_trident_foldback_open,
2059
	.close =	snd_trident_foldback_close,
2060
	.hw_params =	snd_trident_hw_params,
2061
	.hw_free =	snd_trident_hw_free,
2062
	.prepare =	snd_trident_foldback_prepare,
2063
	.trigger =	snd_trident_trigger,
2064
	.pointer =	snd_trident_playback_pointer,
2065
};
2066

2067
static const struct snd_pcm_ops snd_trident_spdif_ops = {
2068
	.open =		snd_trident_spdif_open,
2069
	.close =	snd_trident_spdif_close,
2070
	.hw_params =	snd_trident_spdif_hw_params,
2071
	.hw_free =	snd_trident_hw_free,
2072
	.prepare =	snd_trident_spdif_prepare,
2073
	.trigger =	snd_trident_trigger,
2074
	.pointer =	snd_trident_spdif_pointer,
2075
};
2076

2077
static const struct snd_pcm_ops snd_trident_spdif_7018_ops = {
2078
	.open =		snd_trident_spdif_open,
2079
	.close =	snd_trident_spdif_close,
2080
	.hw_params =	snd_trident_spdif_hw_params,
2081
	.hw_free =	snd_trident_hw_free,
2082
	.prepare =	snd_trident_spdif_prepare,
2083
	.trigger =	snd_trident_trigger,
2084
	.pointer =	snd_trident_playback_pointer,
2085
};
2086

2087
/*---------------------------------------------------------------------------
2088
   snd_trident_pcm
2089
  
2090
   Description: This routine registers the 4DWave device for PCM support.
2091
                
2092
   Parameters:  trident - pointer to target device class for 4DWave.
2093

2094
   Returns:     None
2095
  
2096
  ---------------------------------------------------------------------------*/
2097

2098
int snd_trident_pcm(struct snd_trident *trident, int device)
2099
{
2100
	struct snd_pcm *pcm;
2101
	int err;
2102

2103
	err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm);
2104
	if (err < 0)
2105
		return err;
2106

2107
	pcm->private_data = trident;
2108

2109
	if (trident->tlb.entries) {
2110
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
2111
	} else {
2112
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops);
2113
	}
2114
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
2115
			trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2116
			&snd_trident_capture_ops :
2117
			&snd_trident_si7018_capture_ops);
2118

2119
	pcm->info_flags = 0;
2120
	pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
2121
	strscpy(pcm->name, "Trident 4DWave");
2122
	trident->pcm = pcm;
2123

2124
	if (trident->tlb.entries) {
2125
		struct snd_pcm_substream *substream;
2126
		for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
2127
			snd_pcm_set_managed_buffer(substream, SNDRV_DMA_TYPE_DEV_SG,
2128
						   &trident->pci->dev,
2129
						   64*1024, 128*1024);
2130
		snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
2131
					   SNDRV_DMA_TYPE_DEV,
2132
					   &trident->pci->dev,
2133
					   64*1024, 128*1024);
2134
	} else {
2135
		snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
2136
					       &trident->pci->dev,
2137
					       64*1024, 128*1024);
2138
	}
2139

2140
	return 0;
2141
}
2142

2143
/*---------------------------------------------------------------------------
2144
   snd_trident_foldback_pcm
2145
  
2146
   Description: This routine registers the 4DWave device for foldback PCM support.
2147
                
2148
   Parameters:  trident - pointer to target device class for 4DWave.
2149

2150
   Returns:     None
2151
  
2152
  ---------------------------------------------------------------------------*/
2153

2154
int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
2155
{
2156
	struct snd_pcm *foldback;
2157
	int err;
2158
	int num_chan = 3;
2159
	struct snd_pcm_substream *substream;
2160

2161
	if (trident->device == TRIDENT_DEVICE_ID_NX)
2162
		num_chan = 4;
2163
	err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback);
2164
	if (err < 0)
2165
		return err;
2166

2167
	foldback->private_data = trident;
2168
	if (trident->tlb.entries)
2169
		snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
2170
	else
2171
		snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops);
2172
	foldback->info_flags = 0;
2173
	strscpy(foldback->name, "Trident 4DWave");
2174
	substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
2175
	strscpy(substream->name, "Front Mixer");
2176
	substream = substream->next;
2177
	strscpy(substream->name, "Reverb Mixer");
2178
	substream = substream->next;
2179
	strscpy(substream->name, "Chorus Mixer");
2180
	if (num_chan == 4) {
2181
		substream = substream->next;
2182
		strscpy(substream->name, "Second AC'97 ADC");
2183
	}
2184
	trident->foldback = foldback;
2185

2186
	if (trident->tlb.entries)
2187
		snd_pcm_set_managed_buffer_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
2188
					       &trident->pci->dev,
2189
					       0, 128*1024);
2190
	else
2191
		snd_pcm_set_managed_buffer_all(foldback, SNDRV_DMA_TYPE_DEV,
2192
					       &trident->pci->dev,
2193
					       64*1024, 128*1024);
2194

2195
	return 0;
2196
}
2197

2198
/*---------------------------------------------------------------------------
2199
   snd_trident_spdif
2200
  
2201
   Description: This routine registers the 4DWave-NX device for SPDIF support.
2202
                
2203
   Parameters:  trident - pointer to target device class for 4DWave-NX.
2204

2205
   Returns:     None
2206
  
2207
  ---------------------------------------------------------------------------*/
2208

2209
int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
2210
{
2211
	struct snd_pcm *spdif;
2212
	int err;
2213

2214
	err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif);
2215
	if (err < 0)
2216
		return err;
2217

2218
	spdif->private_data = trident;
2219
	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2220
		snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
2221
	} else {
2222
		snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops);
2223
	}
2224
	spdif->info_flags = 0;
2225
	strscpy(spdif->name, "Trident 4DWave IEC958");
2226
	trident->spdif = spdif;
2227

2228
	snd_pcm_set_managed_buffer_all(spdif, SNDRV_DMA_TYPE_DEV,
2229
				       &trident->pci->dev, 64*1024, 128*1024);
2230

2231
	return 0;
2232
}
2233

2234
/*
2235
 *  Mixer part
2236
 */
2237

2238

2239
/*---------------------------------------------------------------------------
2240
    snd_trident_spdif_control
2241

2242
    Description: enable/disable S/PDIF out from ac97 mixer
2243
  ---------------------------------------------------------------------------*/
2244

2245
#define snd_trident_spdif_control_info	snd_ctl_boolean_mono_info
2246

2247
static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
2248
					 struct snd_ctl_elem_value *ucontrol)
2249
{
2250
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2251
	unsigned char val;
2252

2253
	guard(spinlock_irq)(&trident->reg_lock);
2254
	val = trident->spdif_ctrl;
2255
	ucontrol->value.integer.value[0] = val == kcontrol->private_value;
2256
	return 0;
2257
}
2258

2259
static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
2260
					 struct snd_ctl_elem_value *ucontrol)
2261
{
2262
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2263
	unsigned char val;
2264
	int change;
2265

2266
	val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
2267
	guard(spinlock_irq)(&trident->reg_lock);
2268
	/* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
2269
	change = trident->spdif_ctrl != val;
2270
	trident->spdif_ctrl = val;
2271
	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2272
		if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2273
			outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2274
			outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2275
		}
2276
	} else {
2277
		if (trident->spdif == NULL) {
2278
			unsigned int temp;
2279
			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2280
			temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2281
			if (val)
2282
				temp |= SPDIF_EN;
2283
			outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2284
		}
2285
	}
2286
	return change;
2287
}
2288

2289
static const struct snd_kcontrol_new snd_trident_spdif_control =
2290
{
2291
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2292
	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2293
	.info =		snd_trident_spdif_control_info,
2294
	.get =		snd_trident_spdif_control_get,
2295
	.put =		snd_trident_spdif_control_put,
2296
	.private_value = 0x28,
2297
};
2298

2299
/*---------------------------------------------------------------------------
2300
    snd_trident_spdif_default
2301

2302
    Description: put/get the S/PDIF default settings
2303
  ---------------------------------------------------------------------------*/
2304

2305
static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
2306
					  struct snd_ctl_elem_info *uinfo)
2307
{
2308
	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2309
	uinfo->count = 1;
2310
	return 0;
2311
}
2312

2313
static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
2314
					 struct snd_ctl_elem_value *ucontrol)
2315
{
2316
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2317

2318
	guard(spinlock_irq)(&trident->reg_lock);
2319
	ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2320
	ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2321
	ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2322
	ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2323
	return 0;
2324
}
2325

2326
static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
2327
					 struct snd_ctl_elem_value *ucontrol)
2328
{
2329
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2330
	unsigned int val;
2331
	int change;
2332

2333
	val = (ucontrol->value.iec958.status[0] << 0) |
2334
	      (ucontrol->value.iec958.status[1] << 8) |
2335
	      (ucontrol->value.iec958.status[2] << 16) |
2336
	      (ucontrol->value.iec958.status[3] << 24);
2337
	guard(spinlock_irq)(&trident->reg_lock);
2338
	change = trident->spdif_bits != val;
2339
	trident->spdif_bits = val;
2340
	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2341
		if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2342
			outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2343
	} else {
2344
		if (trident->spdif == NULL)
2345
			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2346
	}
2347
	return change;
2348
}
2349

2350
static const struct snd_kcontrol_new snd_trident_spdif_default =
2351
{
2352
	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
2353
	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2354
	.info =		snd_trident_spdif_default_info,
2355
	.get =		snd_trident_spdif_default_get,
2356
	.put =		snd_trident_spdif_default_put
2357
};
2358

2359
/*---------------------------------------------------------------------------
2360
    snd_trident_spdif_mask
2361

2362
    Description: put/get the S/PDIF mask
2363
  ---------------------------------------------------------------------------*/
2364

2365
static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
2366
				       struct snd_ctl_elem_info *uinfo)
2367
{
2368
	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2369
	uinfo->count = 1;
2370
	return 0;
2371
}
2372

2373
static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
2374
				      struct snd_ctl_elem_value *ucontrol)
2375
{
2376
	ucontrol->value.iec958.status[0] = 0xff;
2377
	ucontrol->value.iec958.status[1] = 0xff;
2378
	ucontrol->value.iec958.status[2] = 0xff;
2379
	ucontrol->value.iec958.status[3] = 0xff;
2380
	return 0;
2381
}
2382

2383
static const struct snd_kcontrol_new snd_trident_spdif_mask =
2384
{
2385
	.access =	SNDRV_CTL_ELEM_ACCESS_READ,
2386
	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
2387
	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
2388
	.info =		snd_trident_spdif_mask_info,
2389
	.get =		snd_trident_spdif_mask_get,
2390
};
2391

2392
/*---------------------------------------------------------------------------
2393
    snd_trident_spdif_stream
2394

2395
    Description: put/get the S/PDIF stream settings
2396
  ---------------------------------------------------------------------------*/
2397

2398
static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
2399
					 struct snd_ctl_elem_info *uinfo)
2400
{
2401
	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2402
	uinfo->count = 1;
2403
	return 0;
2404
}
2405

2406
static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
2407
					struct snd_ctl_elem_value *ucontrol)
2408
{
2409
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2410

2411
	guard(spinlock_irq)(&trident->reg_lock);
2412
	ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2413
	ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2414
	ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2415
	ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2416
	return 0;
2417
}
2418

2419
static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
2420
					struct snd_ctl_elem_value *ucontrol)
2421
{
2422
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2423
	unsigned int val;
2424
	int change;
2425

2426
	val = (ucontrol->value.iec958.status[0] << 0) |
2427
	      (ucontrol->value.iec958.status[1] << 8) |
2428
	      (ucontrol->value.iec958.status[2] << 16) |
2429
	      (ucontrol->value.iec958.status[3] << 24);
2430
	guard(spinlock_irq)(&trident->reg_lock);
2431
	change = trident->spdif_pcm_bits != val;
2432
	trident->spdif_pcm_bits = val;
2433
	if (trident->spdif != NULL) {
2434
		if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2435
			outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2436
		} else {
2437
			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2438
		}
2439
	}
2440
	return change;
2441
}
2442

2443
static const struct snd_kcontrol_new snd_trident_spdif_stream =
2444
{
2445
	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2446
	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
2447
	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
2448
	.info =		snd_trident_spdif_stream_info,
2449
	.get =		snd_trident_spdif_stream_get,
2450
	.put =		snd_trident_spdif_stream_put
2451
};
2452

2453
/*---------------------------------------------------------------------------
2454
    snd_trident_ac97_control
2455

2456
    Description: enable/disable rear path for ac97
2457
  ---------------------------------------------------------------------------*/
2458

2459
#define snd_trident_ac97_control_info	snd_ctl_boolean_mono_info
2460

2461
static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
2462
					struct snd_ctl_elem_value *ucontrol)
2463
{
2464
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2465
	unsigned char val;
2466

2467
	guard(spinlock_irq)(&trident->reg_lock);
2468
	val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2469
	ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
2470
	return 0;
2471
}
2472

2473
static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
2474
					struct snd_ctl_elem_value *ucontrol)
2475
{
2476
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2477
	unsigned char val;
2478
	int change = 0;
2479

2480
	guard(spinlock_irq)(&trident->reg_lock);
2481
	val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2482
	val &= ~(1 << kcontrol->private_value);
2483
	if (ucontrol->value.integer.value[0])
2484
		val |= 1 << kcontrol->private_value;
2485
	change = val != trident->ac97_ctrl;
2486
	trident->ac97_ctrl = val;
2487
	outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2488
	return change;
2489
}
2490

2491
static const struct snd_kcontrol_new snd_trident_ac97_rear_control =
2492
{
2493
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2494
	.name =         "Rear Path",
2495
	.info =		snd_trident_ac97_control_info,
2496
	.get =		snd_trident_ac97_control_get,
2497
	.put =		snd_trident_ac97_control_put,
2498
	.private_value = 4,
2499
};
2500

2501
/*---------------------------------------------------------------------------
2502
    snd_trident_vol_control
2503

2504
    Description: wave & music volume control
2505
  ---------------------------------------------------------------------------*/
2506

2507
static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
2508
					struct snd_ctl_elem_info *uinfo)
2509
{
2510
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2511
	uinfo->count = 2;
2512
	uinfo->value.integer.min = 0;
2513
	uinfo->value.integer.max = 255;
2514
	return 0;
2515
}
2516

2517
static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
2518
				       struct snd_ctl_elem_value *ucontrol)
2519
{
2520
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2521
	unsigned int val;
2522

2523
	val = trident->musicvol_wavevol;
2524
	ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff);
2525
	ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff);
2526
	return 0;
2527
}
2528

2529
static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0);
2530

2531
static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
2532
				       struct snd_ctl_elem_value *ucontrol)
2533
{
2534
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2535
	unsigned int val;
2536
	int change = 0;
2537

2538
	guard(spinlock_irq)(&trident->reg_lock);
2539
	val = trident->musicvol_wavevol;
2540
	val &= ~(0xffff << kcontrol->private_value);
2541
	val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
2542
	        ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
2543
	change = val != trident->musicvol_wavevol;
2544
	outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2545
	return change;
2546
}
2547

2548
static const struct snd_kcontrol_new snd_trident_vol_music_control =
2549
{
2550
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2551
	.name =         "Music Playback Volume",
2552
	.info =		snd_trident_vol_control_info,
2553
	.get =		snd_trident_vol_control_get,
2554
	.put =		snd_trident_vol_control_put,
2555
	.private_value = 16,
2556
	.tlv = { .p = db_scale_gvol },
2557
};
2558

2559
static const struct snd_kcontrol_new snd_trident_vol_wave_control =
2560
{
2561
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2562
	.name =         "Wave Playback Volume",
2563
	.info =		snd_trident_vol_control_info,
2564
	.get =		snd_trident_vol_control_get,
2565
	.put =		snd_trident_vol_control_put,
2566
	.private_value = 0,
2567
	.tlv = { .p = db_scale_gvol },
2568
};
2569

2570
/*---------------------------------------------------------------------------
2571
    snd_trident_pcm_vol_control
2572

2573
    Description: PCM front volume control
2574
  ---------------------------------------------------------------------------*/
2575

2576
static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
2577
					    struct snd_ctl_elem_info *uinfo)
2578
{
2579
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2580

2581
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2582
	uinfo->count = 1;
2583
	uinfo->value.integer.min = 0;
2584
	uinfo->value.integer.max = 255;
2585
	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2586
		uinfo->value.integer.max = 1023;
2587
	return 0;
2588
}
2589

2590
static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
2591
					   struct snd_ctl_elem_value *ucontrol)
2592
{
2593
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2594
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2595

2596
	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2597
		ucontrol->value.integer.value[0] = 1023 - mix->vol;
2598
	} else {
2599
		ucontrol->value.integer.value[0] = 255 - (mix->vol>>2);
2600
	}
2601
	return 0;
2602
}
2603

2604
static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
2605
					   struct snd_ctl_elem_value *ucontrol)
2606
{
2607
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2608
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2609
	unsigned int val;
2610
	int change = 0;
2611

2612
	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2613
		val = 1023 - (ucontrol->value.integer.value[0] & 1023);
2614
	} else {
2615
		val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
2616
	}
2617
	guard(spinlock_irq)(&trident->reg_lock);
2618
	change = val != mix->vol;
2619
	mix->vol = val;
2620
	if (mix->voice != NULL)
2621
		snd_trident_write_vol_reg(trident, mix->voice, val);
2622
	return change;
2623
}
2624

2625
static const struct snd_kcontrol_new snd_trident_pcm_vol_control =
2626
{
2627
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2628
	.name =         "PCM Front Playback Volume",
2629
	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2630
	.count =	32,
2631
	.info =		snd_trident_pcm_vol_control_info,
2632
	.get =		snd_trident_pcm_vol_control_get,
2633
	.put =		snd_trident_pcm_vol_control_put,
2634
	/* FIXME: no tlv yet */
2635
};
2636

2637
/*---------------------------------------------------------------------------
2638
    snd_trident_pcm_pan_control
2639

2640
    Description: PCM front pan control
2641
  ---------------------------------------------------------------------------*/
2642

2643
static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
2644
					    struct snd_ctl_elem_info *uinfo)
2645
{
2646
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2647
	uinfo->count = 1;
2648
	uinfo->value.integer.min = 0;
2649
	uinfo->value.integer.max = 127;
2650
	return 0;
2651
}
2652

2653
static int snd_trident_pcm_pan_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
	ucontrol->value.integer.value[0] = mix->pan;
2660
	if (ucontrol->value.integer.value[0] & 0x40) {
2661
		ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f));
2662
	} else {
2663
		ucontrol->value.integer.value[0] |= 0x40;
2664
	}
2665
	return 0;
2666
}
2667

2668
static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
2669
					   struct snd_ctl_elem_value *ucontrol)
2670
{
2671
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2672
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2673
	unsigned char val;
2674
	int change = 0;
2675

2676
	if (ucontrol->value.integer.value[0] & 0x40)
2677
		val = ucontrol->value.integer.value[0] & 0x3f;
2678
	else
2679
		val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
2680
	guard(spinlock_irq)(&trident->reg_lock);
2681
	change = val != mix->pan;
2682
	mix->pan = val;
2683
	if (mix->voice != NULL)
2684
		snd_trident_write_pan_reg(trident, mix->voice, val);
2685
	return change;
2686
}
2687

2688
static const struct snd_kcontrol_new snd_trident_pcm_pan_control =
2689
{
2690
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2691
	.name =         "PCM Pan Playback Control",
2692
	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2693
	.count =	32,
2694
	.info =		snd_trident_pcm_pan_control_info,
2695
	.get =		snd_trident_pcm_pan_control_get,
2696
	.put =		snd_trident_pcm_pan_control_put,
2697
};
2698

2699
/*---------------------------------------------------------------------------
2700
    snd_trident_pcm_rvol_control
2701

2702
    Description: PCM reverb volume control
2703
  ---------------------------------------------------------------------------*/
2704

2705
static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
2706
					     struct snd_ctl_elem_info *uinfo)
2707
{
2708
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2709
	uinfo->count = 1;
2710
	uinfo->value.integer.min = 0;
2711
	uinfo->value.integer.max = 127;
2712
	return 0;
2713
}
2714

2715
static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
2716
					    struct snd_ctl_elem_value *ucontrol)
2717
{
2718
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2719
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2720

2721
	ucontrol->value.integer.value[0] = 127 - mix->rvol;
2722
	return 0;
2723
}
2724

2725
static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
2726
					    struct snd_ctl_elem_value *ucontrol)
2727
{
2728
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2729
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2730
	unsigned short val;
2731
	int change = 0;
2732

2733
	val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2734
	guard(spinlock_irq)(&trident->reg_lock);
2735
	change = val != mix->rvol;
2736
	mix->rvol = val;
2737
	if (mix->voice != NULL)
2738
		snd_trident_write_rvol_reg(trident, mix->voice, val);
2739
	return change;
2740
}
2741

2742
static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);
2743

2744
static const struct snd_kcontrol_new snd_trident_pcm_rvol_control =
2745
{
2746
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2747
	.name =         "PCM Reverb Playback Volume",
2748
	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2749
	.count = 	32,
2750
	.info =		snd_trident_pcm_rvol_control_info,
2751
	.get =		snd_trident_pcm_rvol_control_get,
2752
	.put =		snd_trident_pcm_rvol_control_put,
2753
	.tlv = { .p = db_scale_crvol },
2754
};
2755

2756
/*---------------------------------------------------------------------------
2757
    snd_trident_pcm_cvol_control
2758

2759
    Description: PCM chorus volume control
2760
  ---------------------------------------------------------------------------*/
2761

2762
static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
2763
					     struct snd_ctl_elem_info *uinfo)
2764
{
2765
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2766
	uinfo->count = 1;
2767
	uinfo->value.integer.min = 0;
2768
	uinfo->value.integer.max = 127;
2769
	return 0;
2770
}
2771

2772
static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
2773
					    struct snd_ctl_elem_value *ucontrol)
2774
{
2775
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2776
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2777

2778
	ucontrol->value.integer.value[0] = 127 - mix->cvol;
2779
	return 0;
2780
}
2781

2782
static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
2783
					    struct snd_ctl_elem_value *ucontrol)
2784
{
2785
	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2786
	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2787
	unsigned short val;
2788
	int change = 0;
2789

2790
	val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2791
	guard(spinlock_irq)(&trident->reg_lock);
2792
	change = val != mix->cvol;
2793
	mix->cvol = val;
2794
	if (mix->voice != NULL)
2795
		snd_trident_write_cvol_reg(trident, mix->voice, val);
2796
	return change;
2797
}
2798

2799
static const struct snd_kcontrol_new snd_trident_pcm_cvol_control =
2800
{
2801
	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
2802
	.name =         "PCM Chorus Playback Volume",
2803
	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2804
	.count =	32,
2805
	.info =		snd_trident_pcm_cvol_control_info,
2806
	.get =		snd_trident_pcm_cvol_control_get,
2807
	.put =		snd_trident_pcm_cvol_control_put,
2808
	.tlv = { .p = db_scale_crvol },
2809
};
2810

2811
static void snd_trident_notify_pcm_change1(struct snd_card *card,
2812
					   struct snd_kcontrol *kctl,
2813
					   int num, int activate)
2814
{
2815
	struct snd_ctl_elem_id id;
2816

2817
	if (! kctl)
2818
		return;
2819
	if (activate)
2820
		kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2821
	else
2822
		kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2823
	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
2824
		       SNDRV_CTL_EVENT_MASK_INFO,
2825
		       snd_ctl_build_ioff(&id, kctl, num));
2826
}
2827

2828
static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2829
					  struct snd_trident_pcm_mixer *tmix,
2830
					  int num, int activate)
2831
{
2832
	snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2833
	snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2834
	snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2835
	snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2836
}
2837

2838
static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2839
				       struct snd_trident_voice *voice,
2840
				       struct snd_pcm_substream *substream)
2841
{
2842
	struct snd_trident_pcm_mixer *tmix;
2843

2844
	if (snd_BUG_ON(!trident || !voice || !substream))
2845
		return -EINVAL;
2846
	tmix = &trident->pcm_mixer[substream->number];
2847
	tmix->voice = voice;
2848
	tmix->vol = T4D_DEFAULT_PCM_VOL;
2849
	tmix->pan = T4D_DEFAULT_PCM_PAN;
2850
	tmix->rvol = T4D_DEFAULT_PCM_RVOL;
2851
	tmix->cvol = T4D_DEFAULT_PCM_CVOL;
2852
	snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2853
	return 0;
2854
}
2855

2856
static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2857
{
2858
	struct snd_trident_pcm_mixer *tmix;
2859

2860
	if (snd_BUG_ON(!trident || !substream))
2861
		return -EINVAL;
2862
	tmix = &trident->pcm_mixer[substream->number];
2863
	tmix->voice = NULL;
2864
	snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2865
	return 0;
2866
}
2867

2868
/*---------------------------------------------------------------------------
2869
   snd_trident_mixer
2870
  
2871
   Description: This routine registers the 4DWave device for mixer support.
2872
                
2873
   Parameters:  trident - pointer to target device class for 4DWave.
2874

2875
   Returns:     None
2876
  
2877
  ---------------------------------------------------------------------------*/
2878

2879
static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
2880
{
2881
	struct snd_ac97_template _ac97;
2882
	struct snd_card *card = trident->card;
2883
	struct snd_kcontrol *kctl;
2884
	struct snd_ctl_elem_value *uctl;
2885
	int idx, err, retries = 2;
2886
	static const struct snd_ac97_bus_ops ops = {
2887
		.write = snd_trident_codec_write,
2888
		.read = snd_trident_codec_read,
2889
	};
2890

2891
	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
2892
	if (!uctl)
2893
		return -ENOMEM;
2894

2895
	err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus);
2896
	if (err < 0)
2897
		goto __out;
2898

2899
	memset(&_ac97, 0, sizeof(_ac97));
2900
	_ac97.private_data = trident;
2901
	trident->ac97_detect = 1;
2902

2903
      __again:
2904
	err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97);
2905
	if (err < 0) {
2906
		if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2907
			err = snd_trident_sis_reset(trident);
2908
			if (err < 0)
2909
				goto __out;
2910
			if (retries-- > 0)
2911
				goto __again;
2912
			err = -EIO;
2913
		}
2914
		goto __out;
2915
	}
2916
	
2917
	/* secondary codec? */
2918
	if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2919
	    (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2920
		_ac97.num = 1;
2921
		err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
2922
		if (err < 0)
2923
			dev_err(trident->card->dev,
2924
				"SI7018: the secondary codec - invalid access\n");
2925
#if 0	// only for my testing purpose --jk
2926
		{
2927
			struct snd_ac97 *mc97;
2928
			err = snd_ac97_modem(trident->card, &_ac97, &mc97);
2929
			if (err < 0)
2930
				dev_err(trident->card->dev,
2931
					"snd_ac97_modem returned error %i\n", err);
2932
		}
2933
#endif
2934
	}
2935
	
2936
	trident->ac97_detect = 0;
2937

2938
	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2939
		kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident);
2940
		err = snd_ctl_add(card, kctl);
2941
		if (err < 0)
2942
			goto __out;
2943
		kctl->put(kctl, uctl);
2944
		kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident);
2945
		err = snd_ctl_add(card, kctl);
2946
		if (err < 0)
2947
			goto __out;
2948
		kctl->put(kctl, uctl);
2949
		outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2950
	} else {
2951
		outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2952
	}
2953

2954
	for (idx = 0; idx < 32; idx++) {
2955
		struct snd_trident_pcm_mixer *tmix;
2956
		
2957
		tmix = &trident->pcm_mixer[idx];
2958
		tmix->voice = NULL;
2959
	}
2960
	trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident);
2961
	if (!trident->ctl_vol)
2962
		goto __nomem;
2963
	err = snd_ctl_add(card, trident->ctl_vol);
2964
	if (err)
2965
		goto __out;
2966
		
2967
	trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident);
2968
	if (!trident->ctl_pan)
2969
		goto __nomem;
2970
	err = snd_ctl_add(card, trident->ctl_pan);
2971
	if (err)
2972
		goto __out;
2973

2974
	trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident);
2975
	if (!trident->ctl_rvol)
2976
		goto __nomem;
2977
	err = snd_ctl_add(card, trident->ctl_rvol);
2978
	if (err)
2979
		goto __out;
2980

2981
	trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident);
2982
	if (!trident->ctl_cvol)
2983
		goto __nomem;
2984
	err = snd_ctl_add(card, trident->ctl_cvol);
2985
	if (err)
2986
		goto __out;
2987

2988
	if (trident->device == TRIDENT_DEVICE_ID_NX) {
2989
		kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident);
2990
		err = snd_ctl_add(card, kctl);
2991
		if (err < 0)
2992
			goto __out;
2993
		kctl->put(kctl, uctl);
2994
	}
2995
	if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
2996

2997
		kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
2998
		if (kctl == NULL) {
2999
			err = -ENOMEM;
3000
			goto __out;
3001
		}
3002
		if (trident->ac97->ext_id & AC97_EI_SPDIF)
3003
			kctl->id.index++;
3004
		if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3005
			kctl->id.index++;
3006
		idx = kctl->id.index;
3007
		err = snd_ctl_add(card, kctl);
3008
		if (err < 0)
3009
			goto __out;
3010
		kctl->put(kctl, uctl);
3011

3012
		kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3013
		if (kctl == NULL) {
3014
			err = -ENOMEM;
3015
			goto __out;
3016
		}
3017
		kctl->id.index = idx;
3018
		kctl->id.device = pcm_spdif_device;
3019
		err = snd_ctl_add(card, kctl);
3020
		if (err < 0)
3021
			goto __out;
3022

3023
		kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3024
		if (kctl == NULL) {
3025
			err = -ENOMEM;
3026
			goto __out;
3027
		}
3028
		kctl->id.index = idx;
3029
		kctl->id.device = pcm_spdif_device;
3030
		err = snd_ctl_add(card, kctl);
3031
		if (err < 0)
3032
			goto __out;
3033

3034
		kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3035
		if (kctl == NULL) {
3036
			err = -ENOMEM;
3037
			goto __out;
3038
		}
3039
		kctl->id.index = idx;
3040
		kctl->id.device = pcm_spdif_device;
3041
		err = snd_ctl_add(card, kctl);
3042
		if (err < 0)
3043
			goto __out;
3044
		trident->spdif_pcm_ctl = kctl;
3045
	}
3046

3047
	err = 0;
3048
	goto __out;
3049

3050
 __nomem:
3051
	err = -ENOMEM;
3052

3053
 __out:
3054
	kfree(uctl);
3055

3056
	return err;
3057
}
3058

3059
/*
3060
 * gameport interface
3061
 */
3062

3063
#if IS_REACHABLE(CONFIG_GAMEPORT)
3064

3065
static unsigned char snd_trident_gameport_read(struct gameport *gameport)
3066
{
3067
	struct snd_trident *chip = gameport_get_port_data(gameport);
3068

3069
	if (snd_BUG_ON(!chip))
3070
		return 0;
3071
	return inb(TRID_REG(chip, GAMEPORT_LEGACY));
3072
}
3073

3074
static void snd_trident_gameport_trigger(struct gameport *gameport)
3075
{
3076
	struct snd_trident *chip = gameport_get_port_data(gameport);
3077

3078
	if (snd_BUG_ON(!chip))
3079
		return;
3080
	outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
3081
}
3082

3083
static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
3084
{
3085
	struct snd_trident *chip = gameport_get_port_data(gameport);
3086
	int i;
3087

3088
	if (snd_BUG_ON(!chip))
3089
		return 0;
3090

3091
	*buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
3092

3093
	for (i = 0; i < 4; i++) {
3094
		axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2));
3095
		if (axes[i] == 0xffff) axes[i] = -1;
3096
	}
3097
        
3098
        return 0;
3099
}
3100

3101
static int snd_trident_gameport_open(struct gameport *gameport, int mode)
3102
{
3103
	struct snd_trident *chip = gameport_get_port_data(gameport);
3104

3105
	if (snd_BUG_ON(!chip))
3106
		return 0;
3107

3108
	switch (mode) {
3109
		case GAMEPORT_MODE_COOKED:
3110
			outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR));
3111
			msleep(20);
3112
			return 0;
3113
		case GAMEPORT_MODE_RAW:
3114
			outb(0, TRID_REG(chip, GAMEPORT_GCR));
3115
			return 0;
3116
		default:
3117
			return -1;
3118
	}
3119
}
3120

3121
int snd_trident_create_gameport(struct snd_trident *chip)
3122
{
3123
	struct gameport *gp;
3124

3125
	chip->gameport = gp = gameport_allocate_port();
3126
	if (!gp) {
3127
		dev_err(chip->card->dev,
3128
			"cannot allocate memory for gameport\n");
3129
		return -ENOMEM;
3130
	}
3131

3132
	gameport_set_name(gp, "Trident 4DWave");
3133
	gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
3134
	gameport_set_dev_parent(gp, &chip->pci->dev);
3135

3136
	gameport_set_port_data(gp, chip);
3137
	gp->fuzz = 64;
3138
	gp->read = snd_trident_gameport_read;
3139
	gp->trigger = snd_trident_gameport_trigger;
3140
	gp->cooked_read = snd_trident_gameport_cooked_read;
3141
	gp->open = snd_trident_gameport_open;
3142

3143
	gameport_register_port(gp);
3144

3145
	return 0;
3146
}
3147

3148
static inline void snd_trident_free_gameport(struct snd_trident *chip)
3149
{
3150
	if (chip->gameport) {
3151
		gameport_unregister_port(chip->gameport);
3152
		chip->gameport = NULL;
3153
	}
3154
}
3155
#else
3156
int snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
3157
static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
3158
#endif /* CONFIG_GAMEPORT */
3159

3160
/*
3161
 * delay for 1 tick
3162
 */
3163
static inline void do_delay(struct snd_trident *chip)
3164
{
3165
	schedule_timeout_uninterruptible(1);
3166
}
3167

3168
/*
3169
 *  SiS reset routine
3170
 */
3171

3172
static int snd_trident_sis_reset(struct snd_trident *trident)
3173
{
3174
	unsigned long end_time;
3175
	unsigned int i;
3176
	int r;
3177

3178
	r = trident->in_suspend ? 0 : 2;	/* count of retries */
3179
      __si7018_retry:
3180
	pci_write_config_byte(trident->pci, 0x46, 0x04);	/* SOFTWARE RESET */
3181
	udelay(100);
3182
	pci_write_config_byte(trident->pci, 0x46, 0x00);
3183
	udelay(100);
3184
	/* disable AC97 GPIO interrupt */
3185
	outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3186
	/* initialize serial interface, force cold reset */
3187
	i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET;
3188
	outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3189
	udelay(1000);
3190
	/* remove cold reset */
3191
	i &= ~COLD_RESET;
3192
	outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3193
	udelay(2000);
3194
	/* wait, until the codec is ready */
3195
	end_time = (jiffies + (HZ * 3) / 4) + 1;
3196
	do {
3197
		if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3198
			goto __si7018_ok;
3199
		do_delay(trident);
3200
	} while (time_after_eq(end_time, jiffies));
3201
	dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3202
		inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3203
	if (r-- > 0) {
3204
		end_time = jiffies + HZ;
3205
		do {
3206
			do_delay(trident);
3207
		} while (time_after_eq(end_time, jiffies));
3208
		goto __si7018_retry;
3209
	}
3210
      __si7018_ok:
3211
	/* wait for the second codec */
3212
	do {
3213
		if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3214
			break;
3215
		do_delay(trident);
3216
	} while (time_after_eq(end_time, jiffies));
3217
	/* enable 64 channel mode */
3218
	outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3219
	return 0;
3220
}
3221

3222
/*  
3223
 *  /proc interface
3224
 */
3225

3226
static void snd_trident_proc_read(struct snd_info_entry *entry, 
3227
				  struct snd_info_buffer *buffer)
3228
{
3229
	struct snd_trident *trident = entry->private_data;
3230
	char *s;
3231

3232
	switch (trident->device) {
3233
	case TRIDENT_DEVICE_ID_SI7018:
3234
		s = "SiS 7018 Audio";
3235
		break;
3236
	case TRIDENT_DEVICE_ID_DX:
3237
		s = "Trident 4DWave PCI DX";
3238
		break;
3239
	case TRIDENT_DEVICE_ID_NX:
3240
		s = "Trident 4DWave PCI NX";
3241
		break;
3242
	default:
3243
		s = "???";
3244
	}
3245
	snd_iprintf(buffer, "%s\n\n", s);
3246
	snd_iprintf(buffer, "Spurious IRQs    : %d\n", trident->spurious_irq_count);
3247
	snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3248
	if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3249
		snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", str_on_off(trident->spdif_ctrl == 0x28));
3250
	if (trident->device == TRIDENT_DEVICE_ID_NX) {
3251
		snd_iprintf(buffer, "Rear Speakers    : %s\n", str_on_off(trident->ac97_ctrl & 0x00000010));
3252
		if (trident->tlb.entries) {
3253
			snd_iprintf(buffer,"\nVirtual Memory\n");
3254
			snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3255
			snd_iprintf(buffer, "Memory Used    : %d\n", trident->tlb.memhdr->used);
3256
			snd_iprintf(buffer, "Memory Free    : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3257
		}
3258
	}
3259
}
3260

3261
static void snd_trident_proc_init(struct snd_trident *trident)
3262
{
3263
	const char *s = "trident";
3264
	
3265
	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3266
		s = "sis7018";
3267
	snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
3268
}
3269

3270
/*---------------------------------------------------------------------------
3271
   snd_trident_tlb_alloc
3272
  
3273
   Description: Allocate and set up the TLB page table on 4D NX.
3274
		Each entry has 4 bytes (physical PCI address).
3275
                
3276
   Parameters:  trident - pointer to target device class for 4DWave.
3277

3278
   Returns:     0 or negative error code
3279
  
3280
  ---------------------------------------------------------------------------*/
3281

3282
static int snd_trident_tlb_alloc(struct snd_trident *trident)
3283
{
3284
	int i;
3285

3286
	/* TLB array must be aligned to 16kB !!! so we allocate
3287
	   32kB region and correct offset when necessary */
3288

3289
	trident->tlb.buffer =
3290
		snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3291
				     2 * SNDRV_TRIDENT_MAX_PAGES * 4);
3292
	if (!trident->tlb.buffer) {
3293
		dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
3294
		return -ENOMEM;
3295
	}
3296
	trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer->area, SNDRV_TRIDENT_MAX_PAGES * 4);
3297
	trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer->addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3298

3299
	/* allocate and setup silent page and initialise TLB entries */
3300
	trident->tlb.silent_page =
3301
		snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3302
				     SNDRV_TRIDENT_PAGE_SIZE);
3303
	if (!trident->tlb.silent_page) {
3304
		dev_err(trident->card->dev, "unable to allocate silent page\n");
3305
		return -ENOMEM;
3306
	}
3307
	memset(trident->tlb.silent_page->area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3308
	for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++)
3309
		trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page->addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3310

3311
	/* use emu memory block manager code to manage tlb page allocation */
3312
	trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3313
	if (trident->tlb.memhdr == NULL)
3314
		return -ENOMEM;
3315

3316
	trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3317
	return 0;
3318
}
3319

3320
/*
3321
 * initialize 4D DX chip
3322
 */
3323

3324
static void snd_trident_stop_all_voices(struct snd_trident *trident)
3325
{
3326
	outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3327
	outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3328
	outl(0, TRID_REG(trident, T4D_AINTEN_A));
3329
	outl(0, TRID_REG(trident, T4D_AINTEN_B));
3330
}
3331

3332
static int snd_trident_4d_dx_init(struct snd_trident *trident)
3333
{
3334
	struct pci_dev *pci = trident->pci;
3335
	unsigned long end_time;
3336

3337
	/* reset the legacy configuration and whole audio/wavetable block */
3338
	pci_write_config_dword(pci, 0x40, 0);	/* DDMA */
3339
	pci_write_config_byte(pci, 0x44, 0);	/* ports */
3340
	pci_write_config_byte(pci, 0x45, 0);	/* Legacy DMA */
3341
	pci_write_config_byte(pci, 0x46, 4); /* reset */
3342
	udelay(100);
3343
	pci_write_config_byte(pci, 0x46, 0); /* release reset */
3344
	udelay(100);
3345
	
3346
	/* warm reset of the AC'97 codec */
3347
	outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3348
	udelay(100);
3349
	outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3350
	/* DAC on, disable SB IRQ and try to force ADC valid signal */
3351
	trident->ac97_ctrl = 0x0000004a;
3352
	outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3353
	/* wait, until the codec is ready */
3354
	end_time = (jiffies + (HZ * 3) / 4) + 1;
3355
	do {
3356
		if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3357
			goto __dx_ok;
3358
		do_delay(trident);
3359
	} while (time_after_eq(end_time, jiffies));
3360
	dev_err(trident->card->dev, "AC'97 codec ready error\n");
3361
	return -EIO;
3362

3363
 __dx_ok:
3364
	snd_trident_stop_all_voices(trident);
3365

3366
	return 0;
3367
}
3368

3369
/*
3370
 * initialize 4D NX chip
3371
 */
3372
static int snd_trident_4d_nx_init(struct snd_trident *trident)
3373
{
3374
	struct pci_dev *pci = trident->pci;
3375
	unsigned long end_time;
3376

3377
	/* reset the legacy configuration and whole audio/wavetable block */
3378
	pci_write_config_dword(pci, 0x40, 0);	/* DDMA */
3379
	pci_write_config_byte(pci, 0x44, 0);	/* ports */
3380
	pci_write_config_byte(pci, 0x45, 0);	/* Legacy DMA */
3381

3382
	pci_write_config_byte(pci, 0x46, 1); /* reset */
3383
	udelay(100);
3384
	pci_write_config_byte(pci, 0x46, 0); /* release reset */
3385
	udelay(100);
3386

3387
	/* warm reset of the AC'97 codec */
3388
	outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3389
	udelay(100);
3390
	outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3391
	/* wait, until the codec is ready */
3392
	end_time = (jiffies + (HZ * 3) / 4) + 1;
3393
	do {
3394
		if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3395
			goto __nx_ok;
3396
		do_delay(trident);
3397
	} while (time_after_eq(end_time, jiffies));
3398
	dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3399
		inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3400
	return -EIO;
3401

3402
 __nx_ok:
3403
	/* DAC on */
3404
	trident->ac97_ctrl = 0x00000002;
3405
	outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3406
	/* disable SB IRQ */
3407
	outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3408

3409
	snd_trident_stop_all_voices(trident);
3410

3411
	if (trident->tlb.entries != NULL) {
3412
		unsigned int i;
3413
		/* enable virtual addressing via TLB */
3414
		i = trident->tlb.entries_dmaaddr;
3415
		i |= 0x00000001;
3416
		outl(i, TRID_REG(trident, NX_TLBC));
3417
	} else {
3418
		outl(0, TRID_REG(trident, NX_TLBC));
3419
	}
3420
	/* initialize S/PDIF */
3421
	outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3422
	outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3423

3424
	return 0;
3425
}
3426

3427
/*
3428
 * initialize sis7018 chip
3429
 */
3430
static int snd_trident_sis_init(struct snd_trident *trident)
3431
{
3432
	int err;
3433

3434
	err = snd_trident_sis_reset(trident);
3435
	if (err < 0)
3436
		return err;
3437

3438
	snd_trident_stop_all_voices(trident);
3439

3440
	/* initialize S/PDIF */
3441
	outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3442

3443
	return 0;
3444
}
3445

3446
/*---------------------------------------------------------------------------
3447
   snd_trident_create
3448
  
3449
   Description: This routine will create the device specific class for
3450
                the 4DWave card. It will also perform basic initialization.
3451
                
3452
   Parameters:  card  - which card to create
3453
                pci   - interface to PCI bus resource info
3454
                dma1ptr - playback dma buffer
3455
                dma2ptr - capture dma buffer
3456
                irqptr  -  interrupt resource info
3457

3458
   Returns:     4DWave device class private data
3459
  
3460
  ---------------------------------------------------------------------------*/
3461

3462
int snd_trident_create(struct snd_card *card,
3463
		       struct pci_dev *pci,
3464
		       int pcm_streams,
3465
		       int pcm_spdif_device,
3466
		       int max_wavetable_size)
3467
{
3468
	struct snd_trident *trident = card->private_data;
3469
	int i, err;
3470
	struct snd_trident_voice *voice;
3471
	struct snd_trident_pcm_mixer *tmix;
3472

3473
	/* enable PCI device */
3474
	err = pcim_enable_device(pci);
3475
	if (err < 0)
3476
		return err;
3477
	/* check, if we can restrict PCI DMA transfers to 30 bits */
3478
	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(30))) {
3479
		dev_err(card->dev,
3480
			"architecture does not support 30bit PCI busmaster DMA\n");
3481
		return -ENXIO;
3482
	}
3483
	
3484
	trident->device = (pci->vendor << 16) | pci->device;
3485
	trident->card = card;
3486
	trident->pci = pci;
3487
	spin_lock_init(&trident->reg_lock);
3488
	spin_lock_init(&trident->event_lock);
3489
	spin_lock_init(&trident->voice_alloc);
3490
	if (pcm_streams < 1)
3491
		pcm_streams = 1;
3492
	if (pcm_streams > 32)
3493
		pcm_streams = 32;
3494
	trident->ChanPCM = pcm_streams;
3495
	if (max_wavetable_size < 0 )
3496
		max_wavetable_size = 0;
3497
	trident->synth.max_size = max_wavetable_size * 1024;
3498
	trident->irq = -1;
3499
	card->private_free = snd_trident_free;
3500

3501
	trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3502
	pci_set_master(pci);
3503

3504
	err = pcim_request_all_regions(pci, "Trident Audio");
3505
	if (err < 0)
3506
		return err;
3507
	trident->port = pci_resource_start(pci, 0);
3508

3509
	if (devm_request_irq(&pci->dev, pci->irq, snd_trident_interrupt,
3510
			     IRQF_SHARED, KBUILD_MODNAME, trident)) {
3511
		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
3512
		return -EBUSY;
3513
	}
3514
	trident->irq = pci->irq;
3515
	card->sync_irq = trident->irq;
3516

3517
	/* allocate 16k-aligned TLB for NX cards */
3518
	trident->tlb.entries = NULL;
3519
	if (trident->device == TRIDENT_DEVICE_ID_NX) {
3520
		err = snd_trident_tlb_alloc(trident);
3521
		if (err < 0)
3522
			return err;
3523
	}
3524

3525
	trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3526

3527
	/* initialize chip */
3528
	switch (trident->device) {
3529
	case TRIDENT_DEVICE_ID_DX:
3530
		err = snd_trident_4d_dx_init(trident);
3531
		break;
3532
	case TRIDENT_DEVICE_ID_NX:
3533
		err = snd_trident_4d_nx_init(trident);
3534
		break;
3535
	case TRIDENT_DEVICE_ID_SI7018:
3536
		err = snd_trident_sis_init(trident);
3537
		break;
3538
	default:
3539
		snd_BUG();
3540
		break;
3541
	}
3542
	if (err < 0)
3543
		return err;
3544

3545
	err = snd_trident_mixer(trident, pcm_spdif_device);
3546
	if (err < 0)
3547
		return err;
3548
	
3549
	/* initialise synth voices */
3550
	for (i = 0; i < 64; i++) {
3551
		voice = &trident->synth.voices[i];
3552
		voice->number = i;
3553
		voice->trident = trident;
3554
	}
3555
	/* initialize pcm mixer entries */
3556
	for (i = 0; i < 32; i++) {
3557
		tmix = &trident->pcm_mixer[i];
3558
		tmix->vol = T4D_DEFAULT_PCM_VOL;
3559
		tmix->pan = T4D_DEFAULT_PCM_PAN;
3560
		tmix->rvol = T4D_DEFAULT_PCM_RVOL;
3561
		tmix->cvol = T4D_DEFAULT_PCM_CVOL;
3562
	}
3563

3564
	snd_trident_enable_eso(trident);
3565

3566
	snd_trident_proc_init(trident);
3567
	return 0;
3568
}
3569

3570
/*---------------------------------------------------------------------------
3571
   snd_trident_free
3572
  
3573
   Description: This routine will free the device specific class for
3574
                the 4DWave card. 
3575
                
3576
   Parameters:  card - card to release
3577

3578
   Returns:     None.
3579
  
3580
  ---------------------------------------------------------------------------*/
3581

3582
static void snd_trident_free(struct snd_card *card)
3583
{
3584
	struct snd_trident *trident = card->private_data;
3585

3586
	snd_trident_free_gameport(trident);
3587
	snd_trident_disable_eso(trident);
3588
	// Disable S/PDIF out
3589
	if (trident->device == TRIDENT_DEVICE_ID_NX)
3590
		outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3591
	else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3592
		outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3593
	}
3594
	if (trident->tlb.buffer) {
3595
		outl(0, TRID_REG(trident, NX_TLBC));
3596
		snd_util_memhdr_free(trident->tlb.memhdr);
3597
	}
3598
}
3599

3600
/*---------------------------------------------------------------------------
3601
   snd_trident_interrupt
3602
  
3603
   Description: ISR for Trident 4DWave device
3604
                
3605
   Parameters:  trident  - device specific private data for 4DWave card
3606

3607
   Problems:    It seems that Trident chips generates interrupts more than
3608
                one time in special cases. The spurious interrupts are
3609
                detected via sample timer (T4D_STIMER) and computing
3610
                corresponding delta value. The limits are detected with
3611
                the method try & fail so it is possible that it won't
3612
                work on all computers. [jaroslav]
3613

3614
   Returns:     None.
3615
  
3616
  ---------------------------------------------------------------------------*/
3617

3618
static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)
3619
{
3620
	struct snd_trident *trident = dev_id;
3621
	unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
3622
	int delta;
3623
	struct snd_trident_voice *voice;
3624

3625
	audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3626
	if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
3627
		return IRQ_NONE;
3628
	if (audio_int & ADDRESS_IRQ) {
3629
		// get interrupt status for all channels
3630
		scoped_guard(spinlock, &trident->reg_lock) {
3631
			stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3632
			chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3633
			if (chn_int)
3634
				outl(chn_int, TRID_REG(trident, T4D_AINT_A));	/* ack */
3635
			chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3636
			if (chn_int == 0)
3637
				break;
3638
			for (channel = 63; channel >= 32; channel--) {
3639
				mask = 1 << (channel&0x1f);
3640
				if ((chn_int & mask) == 0)
3641
					continue;
3642
				voice = &trident->synth.voices[channel];
3643
				if (!voice->pcm || voice->substream == NULL) {
3644
					outl(mask, TRID_REG(trident, T4D_STOP_B));
3645
					continue;
3646
				}
3647
				delta = (int)stimer - (int)voice->stimer;
3648
				if (delta < 0)
3649
					delta = -delta;
3650
				if ((unsigned int)delta < voice->spurious_threshold) {
3651
					/* do some statistics here */
3652
					trident->spurious_irq_count++;
3653
					if (trident->spurious_irq_max_delta < (unsigned int)delta)
3654
						trident->spurious_irq_max_delta = delta;
3655
					continue;
3656
				}
3657
				voice->stimer = stimer;
3658
				if (voice->isync) {
3659
					if (!voice->isync3) {
3660
						tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3661
						if (trident->bDMAStart & 0x40)
3662
							tmp >>= 1;
3663
						if (tmp > 0)
3664
							tmp = voice->isync_max - tmp;
3665
					} else {
3666
						tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3667
					}
3668
					if (tmp < voice->isync_mark) {
3669
						if (tmp > 0x10)
3670
							tmp = voice->isync_ESO - 7;
3671
						else
3672
							tmp = voice->isync_ESO + 2;
3673
						/* update ESO for IRQ voice to preserve sync */
3674
						snd_trident_stop_voice(trident, voice->number);
3675
						snd_trident_write_eso_reg(trident, voice, tmp);
3676
						snd_trident_start_voice(trident, voice->number);
3677
					}
3678
				} else if (voice->isync2) {
3679
					voice->isync2 = 0;
3680
					/* write original ESO and update CSO for IRQ voice to preserve sync */
3681
					snd_trident_stop_voice(trident, voice->number);
3682
					snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3683
					snd_trident_write_eso_reg(trident, voice, voice->ESO);
3684
					snd_trident_start_voice(trident, voice->number);
3685
				}
3686
#if 0
3687
				if (voice->extra) {
3688
					/* update CSO for extra voice to preserve sync */
3689
					snd_trident_stop_voice(trident, voice->extra->number);
3690
					snd_trident_write_cso_reg(trident, voice->extra, 0);
3691
					snd_trident_start_voice(trident, voice->extra->number);
3692
				}
3693
#endif
3694
				spin_unlock(&trident->reg_lock);
3695
				snd_pcm_period_elapsed(voice->substream);
3696
				spin_lock(&trident->reg_lock);
3697
			}
3698
			outl(chn_int, TRID_REG(trident, T4D_AINT_B));	/* ack */
3699
		}
3700
	}
3701
	if (audio_int & MPU401_IRQ) {
3702
		if (trident->rmidi) {
3703
			snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3704
		} else {
3705
			inb(TRID_REG(trident, T4D_MPUR0));
3706
		}
3707
	}
3708
	// outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3709
	return IRQ_HANDLED;
3710
}
3711

3712
struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3713
{
3714
	struct snd_trident_voice *pvoice;
3715
	int idx;
3716

3717
	guard(spinlock_irqsave)(&trident->voice_alloc);
3718
	if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) {
3719
		idx = snd_trident_allocate_pcm_channel(trident);
3720
		if (idx < 0)
3721
			return NULL;
3722
		pvoice = &trident->synth.voices[idx];
3723
		pvoice->use = 1;
3724
		pvoice->pcm = 1;
3725
		pvoice->capture = 0;
3726
		pvoice->spdif = 0;
3727
		pvoice->memblk = NULL;
3728
		pvoice->substream = NULL;
3729
		return pvoice;
3730
	}
3731
	if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) {
3732
		idx = snd_trident_allocate_synth_channel(trident);
3733
		if (idx < 0)
3734
			return NULL;
3735
		pvoice = &trident->synth.voices[idx];
3736
		pvoice->use = 1;
3737
		pvoice->synth = 1;
3738
		pvoice->client = client;
3739
		pvoice->port = port;
3740
		pvoice->memblk = NULL;
3741
		return pvoice;
3742
	}
3743
	if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) {
3744
	}
3745
	return NULL;
3746
}
3747

3748
EXPORT_SYMBOL(snd_trident_alloc_voice);
3749

3750
void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3751
{
3752
	void (*private_free)(struct snd_trident_voice *);
3753

3754
	if (voice == NULL || !voice->use)
3755
		return;
3756
	snd_trident_clear_voices(trident, voice->number, voice->number);
3757
	scoped_guard(spinlock_irqsave, &trident->voice_alloc) {
3758
		private_free = voice->private_free;
3759
		voice->private_free = NULL;
3760
		voice->private_data = NULL;
3761
		if (voice->pcm)
3762
			snd_trident_free_pcm_channel(trident, voice->number);
3763
		if (voice->synth)
3764
			snd_trident_free_synth_channel(trident, voice->number);
3765
		voice->use = voice->pcm = voice->synth = voice->midi = 0;
3766
		voice->capture = voice->spdif = 0;
3767
		voice->sample_ops = NULL;
3768
		voice->substream = NULL;
3769
		voice->extra = NULL;
3770
	}
3771
	if (private_free)
3772
		private_free(voice);
3773
}
3774

3775
EXPORT_SYMBOL(snd_trident_free_voice);
3776

3777
static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3778
{
3779
	unsigned int i, val, mask[2] = { 0, 0 };
3780

3781
	if (snd_BUG_ON(v_min > 63 || v_max > 63))
3782
		return;
3783
	for (i = v_min; i <= v_max; i++)
3784
		mask[i >> 5] |= 1 << (i & 0x1f);
3785
	if (mask[0]) {
3786
		outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3787
		val = inl(TRID_REG(trident, T4D_AINTEN_A));
3788
		outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3789
	}
3790
	if (mask[1]) {
3791
		outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3792
		val = inl(TRID_REG(trident, T4D_AINTEN_B));
3793
		outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3794
	}
3795
}
3796

3797
#ifdef CONFIG_PM_SLEEP
3798
static int snd_trident_suspend(struct device *dev)
3799
{
3800
	struct snd_card *card = dev_get_drvdata(dev);
3801
	struct snd_trident *trident = card->private_data;
3802

3803
	trident->in_suspend = 1;
3804
	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
3805
	snd_ac97_suspend(trident->ac97);
3806
	snd_ac97_suspend(trident->ac97_sec);
3807
	return 0;
3808
}
3809

3810
static int snd_trident_resume(struct device *dev)
3811
{
3812
	struct snd_card *card = dev_get_drvdata(dev);
3813
	struct snd_trident *trident = card->private_data;
3814

3815
	switch (trident->device) {
3816
	case TRIDENT_DEVICE_ID_DX:
3817
		snd_trident_4d_dx_init(trident);
3818
		break;
3819
	case TRIDENT_DEVICE_ID_NX:
3820
		snd_trident_4d_nx_init(trident);
3821
		break;
3822
	case TRIDENT_DEVICE_ID_SI7018:
3823
		snd_trident_sis_init(trident);
3824
		break;
3825
	}
3826

3827
	snd_ac97_resume(trident->ac97);
3828
	snd_ac97_resume(trident->ac97_sec);
3829

3830
	/* restore some registers */
3831
	outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3832

3833
	snd_trident_enable_eso(trident);
3834

3835
	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
3836
	trident->in_suspend = 0;
3837
	return 0;
3838
}
3839

3840
SIMPLE_DEV_PM_OPS(snd_trident_pm, snd_trident_suspend, snd_trident_resume);
3841
#endif /* CONFIG_PM_SLEEP */
3842

3843
Product

Resources

Company
