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