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