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 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 1594 } else { 1595 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS)); 1596 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN; 1597 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 1598 } 1599 } 1600 if (!go) 1601 outl(what, TRID_REG(trident, T4D_STOP_B)); 1602 val = inl(TRID_REG(trident, T4D_AINTEN_B)); 1603 if (go) { 1604 val |= whati; 1605 } else { 1606 val &= ~whati; 1607 } 1608 outl(val, TRID_REG(trident, T4D_AINTEN_B)); 1609 if (go) { 1610 outl(what, TRID_REG(trident, T4D_START_B)); 1611 1612 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018) 1613 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD)); 1614 } else { 1615 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018) 1616 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD)); 1617 } 1618 spin_unlock(&trident->reg_lock); 1619 return 0; 1620 } 1621 1622 /*--------------------------------------------------------------------------- 1623 snd_trident_playback_pointer 1624 1625 Description: This routine return the playback position 1626 1627 Parameters: substream - PCM substream class 1628 1629 Returns: position of buffer 1630 1631 ---------------------------------------------------------------------------*/ 1632 1633 static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream) 1634 { 1635 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1636 struct snd_pcm_runtime *runtime = substream->runtime; 1637 struct snd_trident_voice *voice = runtime->private_data; 1638 unsigned int cso; 1639 1640 if (!voice->running) 1641 return 0; 1642 1643 spin_lock(&trident->reg_lock); 1644 1645 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); 1646 1647 if (trident->device != TRIDENT_DEVICE_ID_NX) { 1648 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2)); 1649 } else { // ID_4DWAVE_NX 1650 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff; 1651 } 1652 1653 spin_unlock(&trident->reg_lock); 1654 1655 if (cso >= runtime->buffer_size) 1656 cso = 0; 1657 1658 return cso; 1659 } 1660 1661 /*--------------------------------------------------------------------------- 1662 snd_trident_capture_pointer 1663 1664 Description: This routine return the capture position 1665 1666 Parameters: pcm1 - PCM device class 1667 1668 Returns: position of buffer 1669 1670 ---------------------------------------------------------------------------*/ 1671 1672 static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream) 1673 { 1674 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1675 struct snd_pcm_runtime *runtime = substream->runtime; 1676 struct snd_trident_voice *voice = runtime->private_data; 1677 unsigned int result; 1678 1679 if (!voice->running) 1680 return 0; 1681 1682 result = inw(TRID_REG(trident, T4D_SBBL_SBCL)); 1683 if (runtime->channels > 1) 1684 result >>= 1; 1685 if (result > 0) 1686 result = runtime->buffer_size - result; 1687 1688 return result; 1689 } 1690 1691 /*--------------------------------------------------------------------------- 1692 snd_trident_spdif_pointer 1693 1694 Description: This routine return the SPDIF playback position 1695 1696 Parameters: substream - PCM substream class 1697 1698 Returns: position of buffer 1699 1700 ---------------------------------------------------------------------------*/ 1701 1702 static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream) 1703 { 1704 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1705 struct snd_pcm_runtime *runtime = substream->runtime; 1706 struct snd_trident_voice *voice = runtime->private_data; 1707 unsigned int result; 1708 1709 if (!voice->running) 1710 return 0; 1711 1712 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff; 1713 1714 return result; 1715 } 1716 1717 /* 1718 * Playback support device description 1719 */ 1720 1721 static struct snd_pcm_hardware snd_trident_playback = 1722 { 1723 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1724 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1725 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | 1726 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), 1727 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 1728 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 1729 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1730 .rate_min = 4000, 1731 .rate_max = 48000, 1732 .channels_min = 1, 1733 .channels_max = 2, 1734 .buffer_bytes_max = (256*1024), 1735 .period_bytes_min = 64, 1736 .period_bytes_max = (256*1024), 1737 .periods_min = 1, 1738 .periods_max = 1024, 1739 .fifo_size = 0, 1740 }; 1741 1742 /* 1743 * Capture support device description 1744 */ 1745 1746 static struct snd_pcm_hardware snd_trident_capture = 1747 { 1748 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1749 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1750 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | 1751 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), 1752 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 1753 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 1754 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 1755 .rate_min = 4000, 1756 .rate_max = 48000, 1757 .channels_min = 1, 1758 .channels_max = 2, 1759 .buffer_bytes_max = (128*1024), 1760 .period_bytes_min = 64, 1761 .period_bytes_max = (128*1024), 1762 .periods_min = 1, 1763 .periods_max = 1024, 1764 .fifo_size = 0, 1765 }; 1766 1767 /* 1768 * Foldback capture support device description 1769 */ 1770 1771 static struct snd_pcm_hardware snd_trident_foldback = 1772 { 1773 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1774 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1775 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | 1776 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), 1777 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1778 .rates = SNDRV_PCM_RATE_48000, 1779 .rate_min = 48000, 1780 .rate_max = 48000, 1781 .channels_min = 2, 1782 .channels_max = 2, 1783 .buffer_bytes_max = (128*1024), 1784 .period_bytes_min = 64, 1785 .period_bytes_max = (128*1024), 1786 .periods_min = 1, 1787 .periods_max = 1024, 1788 .fifo_size = 0, 1789 }; 1790 1791 /* 1792 * SPDIF playback support device description 1793 */ 1794 1795 static struct snd_pcm_hardware snd_trident_spdif = 1796 { 1797 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1798 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1799 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | 1800 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), 1801 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1802 .rates = (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | 1803 SNDRV_PCM_RATE_48000), 1804 .rate_min = 32000, 1805 .rate_max = 48000, 1806 .channels_min = 2, 1807 .channels_max = 2, 1808 .buffer_bytes_max = (128*1024), 1809 .period_bytes_min = 64, 1810 .period_bytes_max = (128*1024), 1811 .periods_min = 1, 1812 .periods_max = 1024, 1813 .fifo_size = 0, 1814 }; 1815 1816 static struct snd_pcm_hardware snd_trident_spdif_7018 = 1817 { 1818 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 1819 SNDRV_PCM_INFO_BLOCK_TRANSFER | 1820 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | 1821 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), 1822 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1823 .rates = SNDRV_PCM_RATE_48000, 1824 .rate_min = 48000, 1825 .rate_max = 48000, 1826 .channels_min = 2, 1827 .channels_max = 2, 1828 .buffer_bytes_max = (128*1024), 1829 .period_bytes_min = 64, 1830 .period_bytes_max = (128*1024), 1831 .periods_min = 1, 1832 .periods_max = 1024, 1833 .fifo_size = 0, 1834 }; 1835 1836 static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime) 1837 { 1838 struct snd_trident_voice *voice = runtime->private_data; 1839 struct snd_trident *trident; 1840 1841 if (voice) { 1842 trident = voice->trident; 1843 snd_trident_free_voice(trident, voice); 1844 } 1845 } 1846 1847 static int snd_trident_playback_open(struct snd_pcm_substream *substream) 1848 { 1849 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1850 struct snd_pcm_runtime *runtime = substream->runtime; 1851 struct snd_trident_voice *voice; 1852 1853 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); 1854 if (voice == NULL) 1855 return -EAGAIN; 1856 snd_trident_pcm_mixer_build(trident, voice, substream); 1857 voice->substream = substream; 1858 runtime->private_data = voice; 1859 runtime->private_free = snd_trident_pcm_free_substream; 1860 runtime->hw = snd_trident_playback; 1861 snd_pcm_set_sync(substream); 1862 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); 1863 return 0; 1864 } 1865 1866 /*--------------------------------------------------------------------------- 1867 snd_trident_playback_close 1868 1869 Description: This routine will close the 4DWave playback device. For now 1870 we will simply free the dma transfer buffer. 1871 1872 Parameters: substream - PCM substream class 1873 1874 ---------------------------------------------------------------------------*/ 1875 static int snd_trident_playback_close(struct snd_pcm_substream *substream) 1876 { 1877 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1878 struct snd_pcm_runtime *runtime = substream->runtime; 1879 struct snd_trident_voice *voice = runtime->private_data; 1880 1881 snd_trident_pcm_mixer_free(trident, voice, substream); 1882 return 0; 1883 } 1884 1885 /*--------------------------------------------------------------------------- 1886 snd_trident_spdif_open 1887 1888 Description: This routine will open the 4DWave SPDIF device. 1889 1890 Parameters: substream - PCM substream class 1891 1892 Returns: status - success or failure flag 1893 1894 ---------------------------------------------------------------------------*/ 1895 1896 static int snd_trident_spdif_open(struct snd_pcm_substream *substream) 1897 { 1898 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1899 struct snd_trident_voice *voice; 1900 struct snd_pcm_runtime *runtime = substream->runtime; 1901 1902 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); 1903 if (voice == NULL) 1904 return -EAGAIN; 1905 voice->spdif = 1; 1906 voice->substream = substream; 1907 spin_lock_irq(&trident->reg_lock); 1908 trident->spdif_pcm_bits = trident->spdif_bits; 1909 spin_unlock_irq(&trident->reg_lock); 1910 1911 runtime->private_data = voice; 1912 runtime->private_free = snd_trident_pcm_free_substream; 1913 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 1914 runtime->hw = snd_trident_spdif; 1915 } else { 1916 runtime->hw = snd_trident_spdif_7018; 1917 } 1918 1919 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1920 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE | 1921 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id); 1922 1923 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); 1924 return 0; 1925 } 1926 1927 1928 /*--------------------------------------------------------------------------- 1929 snd_trident_spdif_close 1930 1931 Description: This routine will close the 4DWave SPDIF device. 1932 1933 Parameters: substream - PCM substream class 1934 1935 ---------------------------------------------------------------------------*/ 1936 1937 static int snd_trident_spdif_close(struct snd_pcm_substream *substream) 1938 { 1939 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1940 unsigned int temp; 1941 1942 spin_lock_irq(&trident->reg_lock); 1943 // restore default SPDIF setting 1944 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 1945 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 1946 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); 1947 } else { 1948 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 1949 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 1950 if (trident->spdif_ctrl) { 1951 temp |= SPDIF_EN; 1952 } else { 1953 temp &= ~SPDIF_EN; 1954 } 1955 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 1956 } 1957 spin_unlock_irq(&trident->reg_lock); 1958 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 1959 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE | 1960 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id); 1961 return 0; 1962 } 1963 1964 /*--------------------------------------------------------------------------- 1965 snd_trident_capture_open 1966 1967 Description: This routine will open the 4DWave capture device. 1968 1969 Parameters: substream - PCM substream class 1970 1971 Returns: status - success or failure flag 1972 1973 ---------------------------------------------------------------------------*/ 1974 1975 static int snd_trident_capture_open(struct snd_pcm_substream *substream) 1976 { 1977 struct snd_trident *trident = snd_pcm_substream_chip(substream); 1978 struct snd_trident_voice *voice; 1979 struct snd_pcm_runtime *runtime = substream->runtime; 1980 1981 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); 1982 if (voice == NULL) 1983 return -EAGAIN; 1984 voice->capture = 1; 1985 voice->substream = substream; 1986 runtime->private_data = voice; 1987 runtime->private_free = snd_trident_pcm_free_substream; 1988 runtime->hw = snd_trident_capture; 1989 snd_pcm_set_sync(substream); 1990 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); 1991 return 0; 1992 } 1993 1994 /*--------------------------------------------------------------------------- 1995 snd_trident_capture_close 1996 1997 Description: This routine will close the 4DWave capture device. For now 1998 we will simply free the dma transfer buffer. 1999 2000 Parameters: substream - PCM substream class 2001 2002 ---------------------------------------------------------------------------*/ 2003 static int snd_trident_capture_close(struct snd_pcm_substream *substream) 2004 { 2005 return 0; 2006 } 2007 2008 /*--------------------------------------------------------------------------- 2009 snd_trident_foldback_open 2010 2011 Description: This routine will open the 4DWave foldback capture device. 2012 2013 Parameters: substream - PCM substream class 2014 2015 Returns: status - success or failure flag 2016 2017 ---------------------------------------------------------------------------*/ 2018 2019 static int snd_trident_foldback_open(struct snd_pcm_substream *substream) 2020 { 2021 struct snd_trident *trident = snd_pcm_substream_chip(substream); 2022 struct snd_trident_voice *voice; 2023 struct snd_pcm_runtime *runtime = substream->runtime; 2024 2025 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); 2026 if (voice == NULL) 2027 return -EAGAIN; 2028 voice->foldback_chan = substream->number; 2029 voice->substream = substream; 2030 runtime->private_data = voice; 2031 runtime->private_free = snd_trident_pcm_free_substream; 2032 runtime->hw = snd_trident_foldback; 2033 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); 2034 return 0; 2035 } 2036 2037 /*--------------------------------------------------------------------------- 2038 snd_trident_foldback_close 2039 2040 Description: This routine will close the 4DWave foldback capture device. 2041 For now we will simply free the dma transfer buffer. 2042 2043 Parameters: substream - PCM substream class 2044 2045 ---------------------------------------------------------------------------*/ 2046 static int snd_trident_foldback_close(struct snd_pcm_substream *substream) 2047 { 2048 struct snd_trident *trident = snd_pcm_substream_chip(substream); 2049 struct snd_trident_voice *voice; 2050 struct snd_pcm_runtime *runtime = substream->runtime; 2051 voice = runtime->private_data; 2052 2053 /* stop capture channel */ 2054 spin_lock_irq(&trident->reg_lock); 2055 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan)); 2056 spin_unlock_irq(&trident->reg_lock); 2057 return 0; 2058 } 2059 2060 /*--------------------------------------------------------------------------- 2061 PCM operations 2062 ---------------------------------------------------------------------------*/ 2063 2064 static struct snd_pcm_ops snd_trident_playback_ops = { 2065 .open = snd_trident_playback_open, 2066 .close = snd_trident_playback_close, 2067 .ioctl = snd_trident_ioctl, 2068 .hw_params = snd_trident_hw_params, 2069 .hw_free = snd_trident_hw_free, 2070 .prepare = snd_trident_playback_prepare, 2071 .trigger = snd_trident_trigger, 2072 .pointer = snd_trident_playback_pointer, 2073 }; 2074 2075 static struct snd_pcm_ops snd_trident_nx_playback_ops = { 2076 .open = snd_trident_playback_open, 2077 .close = snd_trident_playback_close, 2078 .ioctl = snd_trident_ioctl, 2079 .hw_params = snd_trident_hw_params, 2080 .hw_free = snd_trident_hw_free, 2081 .prepare = snd_trident_playback_prepare, 2082 .trigger = snd_trident_trigger, 2083 .pointer = snd_trident_playback_pointer, 2084 .page = snd_pcm_sgbuf_ops_page, 2085 }; 2086 2087 static struct snd_pcm_ops snd_trident_capture_ops = { 2088 .open = snd_trident_capture_open, 2089 .close = snd_trident_capture_close, 2090 .ioctl = snd_trident_ioctl, 2091 .hw_params = snd_trident_capture_hw_params, 2092 .hw_free = snd_trident_hw_free, 2093 .prepare = snd_trident_capture_prepare, 2094 .trigger = snd_trident_trigger, 2095 .pointer = snd_trident_capture_pointer, 2096 }; 2097 2098 static struct snd_pcm_ops snd_trident_si7018_capture_ops = { 2099 .open = snd_trident_capture_open, 2100 .close = snd_trident_capture_close, 2101 .ioctl = snd_trident_ioctl, 2102 .hw_params = snd_trident_si7018_capture_hw_params, 2103 .hw_free = snd_trident_si7018_capture_hw_free, 2104 .prepare = snd_trident_si7018_capture_prepare, 2105 .trigger = snd_trident_trigger, 2106 .pointer = snd_trident_playback_pointer, 2107 }; 2108 2109 static struct snd_pcm_ops snd_trident_foldback_ops = { 2110 .open = snd_trident_foldback_open, 2111 .close = snd_trident_foldback_close, 2112 .ioctl = snd_trident_ioctl, 2113 .hw_params = snd_trident_hw_params, 2114 .hw_free = snd_trident_hw_free, 2115 .prepare = snd_trident_foldback_prepare, 2116 .trigger = snd_trident_trigger, 2117 .pointer = snd_trident_playback_pointer, 2118 }; 2119 2120 static struct snd_pcm_ops snd_trident_nx_foldback_ops = { 2121 .open = snd_trident_foldback_open, 2122 .close = snd_trident_foldback_close, 2123 .ioctl = snd_trident_ioctl, 2124 .hw_params = snd_trident_hw_params, 2125 .hw_free = snd_trident_hw_free, 2126 .prepare = snd_trident_foldback_prepare, 2127 .trigger = snd_trident_trigger, 2128 .pointer = snd_trident_playback_pointer, 2129 .page = snd_pcm_sgbuf_ops_page, 2130 }; 2131 2132 static struct snd_pcm_ops snd_trident_spdif_ops = { 2133 .open = snd_trident_spdif_open, 2134 .close = snd_trident_spdif_close, 2135 .ioctl = snd_trident_ioctl, 2136 .hw_params = snd_trident_spdif_hw_params, 2137 .hw_free = snd_trident_hw_free, 2138 .prepare = snd_trident_spdif_prepare, 2139 .trigger = snd_trident_trigger, 2140 .pointer = snd_trident_spdif_pointer, 2141 }; 2142 2143 static struct snd_pcm_ops snd_trident_spdif_7018_ops = { 2144 .open = snd_trident_spdif_open, 2145 .close = snd_trident_spdif_close, 2146 .ioctl = snd_trident_ioctl, 2147 .hw_params = snd_trident_spdif_hw_params, 2148 .hw_free = snd_trident_hw_free, 2149 .prepare = snd_trident_spdif_prepare, 2150 .trigger = snd_trident_trigger, 2151 .pointer = snd_trident_playback_pointer, 2152 }; 2153 2154 /*--------------------------------------------------------------------------- 2155 snd_trident_pcm 2156 2157 Description: This routine registers the 4DWave device for PCM support. 2158 2159 Parameters: trident - pointer to target device class for 4DWave. 2160 2161 Returns: None 2162 2163 ---------------------------------------------------------------------------*/ 2164 2165 int __devinit snd_trident_pcm(struct snd_trident * trident, 2166 int device, struct snd_pcm ** rpcm) 2167 { 2168 struct snd_pcm *pcm; 2169 int err; 2170 2171 if (rpcm) 2172 *rpcm = NULL; 2173 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0) 2174 return err; 2175 2176 pcm->private_data = trident; 2177 2178 if (trident->tlb.entries) { 2179 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops); 2180 } else { 2181 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops); 2182 } 2183 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 2184 trident->device != TRIDENT_DEVICE_ID_SI7018 ? 2185 &snd_trident_capture_ops : 2186 &snd_trident_si7018_capture_ops); 2187 2188 pcm->info_flags = 0; 2189 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; 2190 strcpy(pcm->name, "Trident 4DWave"); 2191 trident->pcm = pcm; 2192 2193 if (trident->tlb.entries) { 2194 struct snd_pcm_substream *substream; 2195 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) 2196 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, 2197 snd_dma_pci_data(trident->pci), 2198 64*1024, 128*1024); 2199 snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, 2200 SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 2201 64*1024, 128*1024); 2202 } else { 2203 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 2204 snd_dma_pci_data(trident->pci), 64*1024, 128*1024); 2205 } 2206 2207 if (rpcm) 2208 *rpcm = pcm; 2209 return 0; 2210 } 2211 2212 /*--------------------------------------------------------------------------- 2213 snd_trident_foldback_pcm 2214 2215 Description: This routine registers the 4DWave device for foldback PCM support. 2216 2217 Parameters: trident - pointer to target device class for 4DWave. 2218 2219 Returns: None 2220 2221 ---------------------------------------------------------------------------*/ 2222 2223 int __devinit snd_trident_foldback_pcm(struct snd_trident * trident, 2224 int device, struct snd_pcm ** rpcm) 2225 { 2226 struct snd_pcm *foldback; 2227 int err; 2228 int num_chan = 3; 2229 struct snd_pcm_substream *substream; 2230 2231 if (rpcm) 2232 *rpcm = NULL; 2233 if (trident->device == TRIDENT_DEVICE_ID_NX) 2234 num_chan = 4; 2235 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0) 2236 return err; 2237 2238 foldback->private_data = trident; 2239 if (trident->tlb.entries) 2240 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops); 2241 else 2242 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops); 2243 foldback->info_flags = 0; 2244 strcpy(foldback->name, "Trident 4DWave"); 2245 substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 2246 strcpy(substream->name, "Front Mixer"); 2247 substream = substream->next; 2248 strcpy(substream->name, "Reverb Mixer"); 2249 substream = substream->next; 2250 strcpy(substream->name, "Chorus Mixer"); 2251 if (num_chan == 4) { 2252 substream = substream->next; 2253 strcpy(substream->name, "Second AC'97 ADC"); 2254 } 2255 trident->foldback = foldback; 2256 2257 if (trident->tlb.entries) 2258 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG, 2259 snd_dma_pci_data(trident->pci), 0, 128*1024); 2260 else 2261 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV, 2262 snd_dma_pci_data(trident->pci), 64*1024, 128*1024); 2263 2264 if (rpcm) 2265 *rpcm = foldback; 2266 return 0; 2267 } 2268 2269 /*--------------------------------------------------------------------------- 2270 snd_trident_spdif 2271 2272 Description: This routine registers the 4DWave-NX device for SPDIF support. 2273 2274 Parameters: trident - pointer to target device class for 4DWave-NX. 2275 2276 Returns: None 2277 2278 ---------------------------------------------------------------------------*/ 2279 2280 int __devinit snd_trident_spdif_pcm(struct snd_trident * trident, 2281 int device, struct snd_pcm ** rpcm) 2282 { 2283 struct snd_pcm *spdif; 2284 int err; 2285 2286 if (rpcm) 2287 *rpcm = NULL; 2288 if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0) 2289 return err; 2290 2291 spdif->private_data = trident; 2292 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 2293 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops); 2294 } else { 2295 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops); 2296 } 2297 spdif->info_flags = 0; 2298 strcpy(spdif->name, "Trident 4DWave IEC958"); 2299 trident->spdif = spdif; 2300 2301 snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024); 2302 2303 if (rpcm) 2304 *rpcm = spdif; 2305 return 0; 2306 } 2307 2308 /* 2309 * Mixer part 2310 */ 2311 2312 2313 /*--------------------------------------------------------------------------- 2314 snd_trident_spdif_control 2315 2316 Description: enable/disable S/PDIF out from ac97 mixer 2317 ---------------------------------------------------------------------------*/ 2318 2319 #define snd_trident_spdif_control_info snd_ctl_boolean_mono_info 2320 2321 static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol, 2322 struct snd_ctl_elem_value *ucontrol) 2323 { 2324 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2325 unsigned char val; 2326 2327 spin_lock_irq(&trident->reg_lock); 2328 val = trident->spdif_ctrl; 2329 ucontrol->value.integer.value[0] = val == kcontrol->private_value; 2330 spin_unlock_irq(&trident->reg_lock); 2331 return 0; 2332 } 2333 2334 static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol, 2335 struct snd_ctl_elem_value *ucontrol) 2336 { 2337 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2338 unsigned char val; 2339 int change; 2340 2341 val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00; 2342 spin_lock_irq(&trident->reg_lock); 2343 /* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */ 2344 change = trident->spdif_ctrl != val; 2345 trident->spdif_ctrl = val; 2346 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 2347 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) { 2348 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); 2349 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 2350 } 2351 } else { 2352 if (trident->spdif == NULL) { 2353 unsigned int temp; 2354 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 2355 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN; 2356 if (val) 2357 temp |= SPDIF_EN; 2358 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 2359 } 2360 } 2361 spin_unlock_irq(&trident->reg_lock); 2362 return change; 2363 } 2364 2365 static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata = 2366 { 2367 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2368 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), 2369 .info = snd_trident_spdif_control_info, 2370 .get = snd_trident_spdif_control_get, 2371 .put = snd_trident_spdif_control_put, 2372 .private_value = 0x28, 2373 }; 2374 2375 /*--------------------------------------------------------------------------- 2376 snd_trident_spdif_default 2377 2378 Description: put/get the S/PDIF default settings 2379 ---------------------------------------------------------------------------*/ 2380 2381 static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol, 2382 struct snd_ctl_elem_info *uinfo) 2383 { 2384 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 2385 uinfo->count = 1; 2386 return 0; 2387 } 2388 2389 static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol, 2390 struct snd_ctl_elem_value *ucontrol) 2391 { 2392 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2393 2394 spin_lock_irq(&trident->reg_lock); 2395 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff; 2396 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff; 2397 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff; 2398 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff; 2399 spin_unlock_irq(&trident->reg_lock); 2400 return 0; 2401 } 2402 2403 static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol, 2404 struct snd_ctl_elem_value *ucontrol) 2405 { 2406 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2407 unsigned int val; 2408 int change; 2409 2410 val = (ucontrol->value.iec958.status[0] << 0) | 2411 (ucontrol->value.iec958.status[1] << 8) | 2412 (ucontrol->value.iec958.status[2] << 16) | 2413 (ucontrol->value.iec958.status[3] << 24); 2414 spin_lock_irq(&trident->reg_lock); 2415 change = trident->spdif_bits != val; 2416 trident->spdif_bits = val; 2417 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 2418 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) 2419 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); 2420 } else { 2421 if (trident->spdif == NULL) 2422 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 2423 } 2424 spin_unlock_irq(&trident->reg_lock); 2425 return change; 2426 } 2427 2428 static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata = 2429 { 2430 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 2431 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 2432 .info = snd_trident_spdif_default_info, 2433 .get = snd_trident_spdif_default_get, 2434 .put = snd_trident_spdif_default_put 2435 }; 2436 2437 /*--------------------------------------------------------------------------- 2438 snd_trident_spdif_mask 2439 2440 Description: put/get the S/PDIF mask 2441 ---------------------------------------------------------------------------*/ 2442 2443 static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol, 2444 struct snd_ctl_elem_info *uinfo) 2445 { 2446 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 2447 uinfo->count = 1; 2448 return 0; 2449 } 2450 2451 static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol, 2452 struct snd_ctl_elem_value *ucontrol) 2453 { 2454 ucontrol->value.iec958.status[0] = 0xff; 2455 ucontrol->value.iec958.status[1] = 0xff; 2456 ucontrol->value.iec958.status[2] = 0xff; 2457 ucontrol->value.iec958.status[3] = 0xff; 2458 return 0; 2459 } 2460 2461 static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata = 2462 { 2463 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2464 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 2465 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 2466 .info = snd_trident_spdif_mask_info, 2467 .get = snd_trident_spdif_mask_get, 2468 }; 2469 2470 /*--------------------------------------------------------------------------- 2471 snd_trident_spdif_stream 2472 2473 Description: put/get the S/PDIF stream settings 2474 ---------------------------------------------------------------------------*/ 2475 2476 static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol, 2477 struct snd_ctl_elem_info *uinfo) 2478 { 2479 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 2480 uinfo->count = 1; 2481 return 0; 2482 } 2483 2484 static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol, 2485 struct snd_ctl_elem_value *ucontrol) 2486 { 2487 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2488 2489 spin_lock_irq(&trident->reg_lock); 2490 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff; 2491 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff; 2492 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff; 2493 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff; 2494 spin_unlock_irq(&trident->reg_lock); 2495 return 0; 2496 } 2497 2498 static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol, 2499 struct snd_ctl_elem_value *ucontrol) 2500 { 2501 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2502 unsigned int val; 2503 int change; 2504 2505 val = (ucontrol->value.iec958.status[0] << 0) | 2506 (ucontrol->value.iec958.status[1] << 8) | 2507 (ucontrol->value.iec958.status[2] << 16) | 2508 (ucontrol->value.iec958.status[3] << 24); 2509 spin_lock_irq(&trident->reg_lock); 2510 change = trident->spdif_pcm_bits != val; 2511 trident->spdif_pcm_bits = val; 2512 if (trident->spdif != NULL) { 2513 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 2514 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS)); 2515 } else { 2516 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 2517 } 2518 } 2519 spin_unlock_irq(&trident->reg_lock); 2520 return change; 2521 } 2522 2523 static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata = 2524 { 2525 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2526 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 2527 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM), 2528 .info = snd_trident_spdif_stream_info, 2529 .get = snd_trident_spdif_stream_get, 2530 .put = snd_trident_spdif_stream_put 2531 }; 2532 2533 /*--------------------------------------------------------------------------- 2534 snd_trident_ac97_control 2535 2536 Description: enable/disable rear path for ac97 2537 ---------------------------------------------------------------------------*/ 2538 2539 #define snd_trident_ac97_control_info snd_ctl_boolean_mono_info 2540 2541 static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol, 2542 struct snd_ctl_elem_value *ucontrol) 2543 { 2544 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2545 unsigned char val; 2546 2547 spin_lock_irq(&trident->reg_lock); 2548 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 2549 ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0; 2550 spin_unlock_irq(&trident->reg_lock); 2551 return 0; 2552 } 2553 2554 static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol, 2555 struct snd_ctl_elem_value *ucontrol) 2556 { 2557 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2558 unsigned char val; 2559 int change = 0; 2560 2561 spin_lock_irq(&trident->reg_lock); 2562 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 2563 val &= ~(1 << kcontrol->private_value); 2564 if (ucontrol->value.integer.value[0]) 2565 val |= 1 << kcontrol->private_value; 2566 change = val != trident->ac97_ctrl; 2567 trident->ac97_ctrl = val; 2568 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 2569 spin_unlock_irq(&trident->reg_lock); 2570 return change; 2571 } 2572 2573 static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata = 2574 { 2575 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2576 .name = "Rear Path", 2577 .info = snd_trident_ac97_control_info, 2578 .get = snd_trident_ac97_control_get, 2579 .put = snd_trident_ac97_control_put, 2580 .private_value = 4, 2581 }; 2582 2583 /*--------------------------------------------------------------------------- 2584 snd_trident_vol_control 2585 2586 Description: wave & music volume control 2587 ---------------------------------------------------------------------------*/ 2588 2589 static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol, 2590 struct snd_ctl_elem_info *uinfo) 2591 { 2592 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2593 uinfo->count = 2; 2594 uinfo->value.integer.min = 0; 2595 uinfo->value.integer.max = 255; 2596 return 0; 2597 } 2598 2599 static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol, 2600 struct snd_ctl_elem_value *ucontrol) 2601 { 2602 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2603 unsigned int val; 2604 2605 val = trident->musicvol_wavevol; 2606 ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff); 2607 ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff); 2608 return 0; 2609 } 2610 2611 static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0); 2612 2613 static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol, 2614 struct snd_ctl_elem_value *ucontrol) 2615 { 2616 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2617 unsigned int val; 2618 int change = 0; 2619 2620 spin_lock_irq(&trident->reg_lock); 2621 val = trident->musicvol_wavevol; 2622 val &= ~(0xffff << kcontrol->private_value); 2623 val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) | 2624 ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value; 2625 change = val != trident->musicvol_wavevol; 2626 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 2627 spin_unlock_irq(&trident->reg_lock); 2628 return change; 2629 } 2630 2631 static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata = 2632 { 2633 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2634 .name = "Music Playback Volume", 2635 .info = snd_trident_vol_control_info, 2636 .get = snd_trident_vol_control_get, 2637 .put = snd_trident_vol_control_put, 2638 .private_value = 16, 2639 .tlv = { .p = db_scale_gvol }, 2640 }; 2641 2642 static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata = 2643 { 2644 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2645 .name = "Wave Playback Volume", 2646 .info = snd_trident_vol_control_info, 2647 .get = snd_trident_vol_control_get, 2648 .put = snd_trident_vol_control_put, 2649 .private_value = 0, 2650 .tlv = { .p = db_scale_gvol }, 2651 }; 2652 2653 /*--------------------------------------------------------------------------- 2654 snd_trident_pcm_vol_control 2655 2656 Description: PCM front volume control 2657 ---------------------------------------------------------------------------*/ 2658 2659 static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol, 2660 struct snd_ctl_elem_info *uinfo) 2661 { 2662 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2663 2664 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2665 uinfo->count = 1; 2666 uinfo->value.integer.min = 0; 2667 uinfo->value.integer.max = 255; 2668 if (trident->device == TRIDENT_DEVICE_ID_SI7018) 2669 uinfo->value.integer.max = 1023; 2670 return 0; 2671 } 2672 2673 static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol, 2674 struct snd_ctl_elem_value *ucontrol) 2675 { 2676 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2677 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2678 2679 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 2680 ucontrol->value.integer.value[0] = 1023 - mix->vol; 2681 } else { 2682 ucontrol->value.integer.value[0] = 255 - (mix->vol>>2); 2683 } 2684 return 0; 2685 } 2686 2687 static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol, 2688 struct snd_ctl_elem_value *ucontrol) 2689 { 2690 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2691 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2692 unsigned int val; 2693 int change = 0; 2694 2695 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 2696 val = 1023 - (ucontrol->value.integer.value[0] & 1023); 2697 } else { 2698 val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2; 2699 } 2700 spin_lock_irq(&trident->reg_lock); 2701 change = val != mix->vol; 2702 mix->vol = val; 2703 if (mix->voice != NULL) 2704 snd_trident_write_vol_reg(trident, mix->voice, val); 2705 spin_unlock_irq(&trident->reg_lock); 2706 return change; 2707 } 2708 2709 static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata = 2710 { 2711 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2712 .name = "PCM Front Playback Volume", 2713 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2714 .count = 32, 2715 .info = snd_trident_pcm_vol_control_info, 2716 .get = snd_trident_pcm_vol_control_get, 2717 .put = snd_trident_pcm_vol_control_put, 2718 /* FIXME: no tlv yet */ 2719 }; 2720 2721 /*--------------------------------------------------------------------------- 2722 snd_trident_pcm_pan_control 2723 2724 Description: PCM front pan control 2725 ---------------------------------------------------------------------------*/ 2726 2727 static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol, 2728 struct snd_ctl_elem_info *uinfo) 2729 { 2730 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2731 uinfo->count = 1; 2732 uinfo->value.integer.min = 0; 2733 uinfo->value.integer.max = 127; 2734 return 0; 2735 } 2736 2737 static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol, 2738 struct snd_ctl_elem_value *ucontrol) 2739 { 2740 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2741 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2742 2743 ucontrol->value.integer.value[0] = mix->pan; 2744 if (ucontrol->value.integer.value[0] & 0x40) { 2745 ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)); 2746 } else { 2747 ucontrol->value.integer.value[0] |= 0x40; 2748 } 2749 return 0; 2750 } 2751 2752 static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol, 2753 struct snd_ctl_elem_value *ucontrol) 2754 { 2755 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2756 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2757 unsigned char val; 2758 int change = 0; 2759 2760 if (ucontrol->value.integer.value[0] & 0x40) 2761 val = ucontrol->value.integer.value[0] & 0x3f; 2762 else 2763 val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40; 2764 spin_lock_irq(&trident->reg_lock); 2765 change = val != mix->pan; 2766 mix->pan = val; 2767 if (mix->voice != NULL) 2768 snd_trident_write_pan_reg(trident, mix->voice, val); 2769 spin_unlock_irq(&trident->reg_lock); 2770 return change; 2771 } 2772 2773 static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata = 2774 { 2775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2776 .name = "PCM Pan Playback Control", 2777 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2778 .count = 32, 2779 .info = snd_trident_pcm_pan_control_info, 2780 .get = snd_trident_pcm_pan_control_get, 2781 .put = snd_trident_pcm_pan_control_put, 2782 }; 2783 2784 /*--------------------------------------------------------------------------- 2785 snd_trident_pcm_rvol_control 2786 2787 Description: PCM reverb volume control 2788 ---------------------------------------------------------------------------*/ 2789 2790 static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol, 2791 struct snd_ctl_elem_info *uinfo) 2792 { 2793 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2794 uinfo->count = 1; 2795 uinfo->value.integer.min = 0; 2796 uinfo->value.integer.max = 127; 2797 return 0; 2798 } 2799 2800 static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol, 2801 struct snd_ctl_elem_value *ucontrol) 2802 { 2803 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2804 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2805 2806 ucontrol->value.integer.value[0] = 127 - mix->rvol; 2807 return 0; 2808 } 2809 2810 static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol, 2811 struct snd_ctl_elem_value *ucontrol) 2812 { 2813 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2814 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2815 unsigned short val; 2816 int change = 0; 2817 2818 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); 2819 spin_lock_irq(&trident->reg_lock); 2820 change = val != mix->rvol; 2821 mix->rvol = val; 2822 if (mix->voice != NULL) 2823 snd_trident_write_rvol_reg(trident, mix->voice, val); 2824 spin_unlock_irq(&trident->reg_lock); 2825 return change; 2826 } 2827 2828 static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1); 2829 2830 static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata = 2831 { 2832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2833 .name = "PCM Reverb Playback Volume", 2834 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2835 .count = 32, 2836 .info = snd_trident_pcm_rvol_control_info, 2837 .get = snd_trident_pcm_rvol_control_get, 2838 .put = snd_trident_pcm_rvol_control_put, 2839 .tlv = { .p = db_scale_crvol }, 2840 }; 2841 2842 /*--------------------------------------------------------------------------- 2843 snd_trident_pcm_cvol_control 2844 2845 Description: PCM chorus volume control 2846 ---------------------------------------------------------------------------*/ 2847 2848 static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol, 2849 struct snd_ctl_elem_info *uinfo) 2850 { 2851 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2852 uinfo->count = 1; 2853 uinfo->value.integer.min = 0; 2854 uinfo->value.integer.max = 127; 2855 return 0; 2856 } 2857 2858 static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol, 2859 struct snd_ctl_elem_value *ucontrol) 2860 { 2861 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2862 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2863 2864 ucontrol->value.integer.value[0] = 127 - mix->cvol; 2865 return 0; 2866 } 2867 2868 static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol, 2869 struct snd_ctl_elem_value *ucontrol) 2870 { 2871 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2872 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2873 unsigned short val; 2874 int change = 0; 2875 2876 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); 2877 spin_lock_irq(&trident->reg_lock); 2878 change = val != mix->cvol; 2879 mix->cvol = val; 2880 if (mix->voice != NULL) 2881 snd_trident_write_cvol_reg(trident, mix->voice, val); 2882 spin_unlock_irq(&trident->reg_lock); 2883 return change; 2884 } 2885 2886 static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata = 2887 { 2888 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2889 .name = "PCM Chorus Playback Volume", 2890 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2891 .count = 32, 2892 .info = snd_trident_pcm_cvol_control_info, 2893 .get = snd_trident_pcm_cvol_control_get, 2894 .put = snd_trident_pcm_cvol_control_put, 2895 .tlv = { .p = db_scale_crvol }, 2896 }; 2897 2898 static void snd_trident_notify_pcm_change1(struct snd_card *card, 2899 struct snd_kcontrol *kctl, 2900 int num, int activate) 2901 { 2902 struct snd_ctl_elem_id id; 2903 2904 if (! kctl) 2905 return; 2906 if (activate) 2907 kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 2908 else 2909 kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 2910 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | 2911 SNDRV_CTL_EVENT_MASK_INFO, 2912 snd_ctl_build_ioff(&id, kctl, num)); 2913 } 2914 2915 static void snd_trident_notify_pcm_change(struct snd_trident *trident, 2916 struct snd_trident_pcm_mixer *tmix, 2917 int num, int activate) 2918 { 2919 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate); 2920 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate); 2921 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate); 2922 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate); 2923 } 2924 2925 static int snd_trident_pcm_mixer_build(struct snd_trident *trident, 2926 struct snd_trident_voice *voice, 2927 struct snd_pcm_substream *substream) 2928 { 2929 struct snd_trident_pcm_mixer *tmix; 2930 2931 snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL); 2932 tmix = &trident->pcm_mixer[substream->number]; 2933 tmix->voice = voice; 2934 tmix->vol = T4D_DEFAULT_PCM_VOL; 2935 tmix->pan = T4D_DEFAULT_PCM_PAN; 2936 tmix->rvol = T4D_DEFAULT_PCM_RVOL; 2937 tmix->cvol = T4D_DEFAULT_PCM_CVOL; 2938 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1); 2939 return 0; 2940 } 2941 2942 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream) 2943 { 2944 struct snd_trident_pcm_mixer *tmix; 2945 2946 snd_assert(trident != NULL && substream != NULL, return -EINVAL); 2947 tmix = &trident->pcm_mixer[substream->number]; 2948 tmix->voice = NULL; 2949 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0); 2950 return 0; 2951 } 2952 2953 /*--------------------------------------------------------------------------- 2954 snd_trident_mixer 2955 2956 Description: This routine registers the 4DWave device for mixer support. 2957 2958 Parameters: trident - pointer to target device class for 4DWave. 2959 2960 Returns: None 2961 2962 ---------------------------------------------------------------------------*/ 2963 2964 static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device) 2965 { 2966 struct snd_ac97_template _ac97; 2967 struct snd_card *card = trident->card; 2968 struct snd_kcontrol *kctl; 2969 struct snd_ctl_elem_value *uctl; 2970 int idx, err, retries = 2; 2971 static struct snd_ac97_bus_ops ops = { 2972 .write = snd_trident_codec_write, 2973 .read = snd_trident_codec_read, 2974 }; 2975 2976 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 2977 if (!uctl) 2978 return -ENOMEM; 2979 2980 if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0) 2981 goto __out; 2982 2983 memset(&_ac97, 0, sizeof(_ac97)); 2984 _ac97.private_data = trident; 2985 trident->ac97_detect = 1; 2986 2987 __again: 2988 if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) { 2989 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 2990 if ((err = snd_trident_sis_reset(trident)) < 0) 2991 goto __out; 2992 if (retries-- > 0) 2993 goto __again; 2994 err = -EIO; 2995 } 2996 goto __out; 2997 } 2998 2999 /* secondary codec? */ 3000 if (trident->device == TRIDENT_DEVICE_ID_SI7018 && 3001 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) { 3002 _ac97.num = 1; 3003 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec); 3004 if (err < 0) 3005 snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n"); 3006 #if 0 // only for my testing purpose --jk 3007 { 3008 struct snd_ac97 *mc97; 3009 err = snd_ac97_modem(trident->card, &_ac97, &mc97); 3010 if (err < 0) 3011 snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err); 3012 } 3013 #endif 3014 } 3015 3016 trident->ac97_detect = 0; 3017 3018 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 3019 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0) 3020 goto __out; 3021 kctl->put(kctl, uctl); 3022 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0) 3023 goto __out; 3024 kctl->put(kctl, uctl); 3025 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3026 } else { 3027 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3028 } 3029 3030 for (idx = 0; idx < 32; idx++) { 3031 struct snd_trident_pcm_mixer *tmix; 3032 3033 tmix = &trident->pcm_mixer[idx]; 3034 tmix->voice = NULL; 3035 } 3036 if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL) 3037 goto __nomem; 3038 if ((err = snd_ctl_add(card, trident->ctl_vol))) 3039 goto __out; 3040 3041 if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL) 3042 goto __nomem; 3043 if ((err = snd_ctl_add(card, trident->ctl_pan))) 3044 goto __out; 3045 3046 if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL) 3047 goto __nomem; 3048 if ((err = snd_ctl_add(card, trident->ctl_rvol))) 3049 goto __out; 3050 3051 if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL) 3052 goto __nomem; 3053 if ((err = snd_ctl_add(card, trident->ctl_cvol))) 3054 goto __out; 3055 3056 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3057 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0) 3058 goto __out; 3059 kctl->put(kctl, uctl); 3060 } 3061 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) { 3062 3063 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident); 3064 if (kctl == NULL) { 3065 err = -ENOMEM; 3066 goto __out; 3067 } 3068 if (trident->ac97->ext_id & AC97_EI_SPDIF) 3069 kctl->id.index++; 3070 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF)) 3071 kctl->id.index++; 3072 idx = kctl->id.index; 3073 if ((err = snd_ctl_add(card, kctl)) < 0) 3074 goto __out; 3075 kctl->put(kctl, uctl); 3076 3077 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident); 3078 if (kctl == NULL) { 3079 err = -ENOMEM; 3080 goto __out; 3081 } 3082 kctl->id.index = idx; 3083 kctl->id.device = pcm_spdif_device; 3084 if ((err = snd_ctl_add(card, kctl)) < 0) 3085 goto __out; 3086 3087 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident); 3088 if (kctl == NULL) { 3089 err = -ENOMEM; 3090 goto __out; 3091 } 3092 kctl->id.index = idx; 3093 kctl->id.device = pcm_spdif_device; 3094 if ((err = snd_ctl_add(card, kctl)) < 0) 3095 goto __out; 3096 3097 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident); 3098 if (kctl == NULL) { 3099 err = -ENOMEM; 3100 goto __out; 3101 } 3102 kctl->id.index = idx; 3103 kctl->id.device = pcm_spdif_device; 3104 if ((err = snd_ctl_add(card, kctl)) < 0) 3105 goto __out; 3106 trident->spdif_pcm_ctl = kctl; 3107 } 3108 3109 err = 0; 3110 goto __out; 3111 3112 __nomem: 3113 err = -ENOMEM; 3114 3115 __out: 3116 kfree(uctl); 3117 3118 return err; 3119 } 3120 3121 /* 3122 * gameport interface 3123 */ 3124 3125 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE)) 3126 3127 static unsigned char snd_trident_gameport_read(struct gameport *gameport) 3128 { 3129 struct snd_trident *chip = gameport_get_port_data(gameport); 3130 3131 snd_assert(chip, return 0); 3132 return inb(TRID_REG(chip, GAMEPORT_LEGACY)); 3133 } 3134 3135 static void snd_trident_gameport_trigger(struct gameport *gameport) 3136 { 3137 struct snd_trident *chip = gameport_get_port_data(gameport); 3138 3139 snd_assert(chip, return); 3140 outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY)); 3141 } 3142 3143 static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) 3144 { 3145 struct snd_trident *chip = gameport_get_port_data(gameport); 3146 int i; 3147 3148 snd_assert(chip, return 0); 3149 3150 *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf; 3151 3152 for (i = 0; i < 4; i++) { 3153 axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2)); 3154 if (axes[i] == 0xffff) axes[i] = -1; 3155 } 3156 3157 return 0; 3158 } 3159 3160 static int snd_trident_gameport_open(struct gameport *gameport, int mode) 3161 { 3162 struct snd_trident *chip = gameport_get_port_data(gameport); 3163 3164 snd_assert(chip, return 0); 3165 3166 switch (mode) { 3167 case GAMEPORT_MODE_COOKED: 3168 outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR)); 3169 msleep(20); 3170 return 0; 3171 case GAMEPORT_MODE_RAW: 3172 outb(0, TRID_REG(chip, GAMEPORT_GCR)); 3173 return 0; 3174 default: 3175 return -1; 3176 } 3177 } 3178 3179 int __devinit snd_trident_create_gameport(struct snd_trident *chip) 3180 { 3181 struct gameport *gp; 3182 3183 chip->gameport = gp = gameport_allocate_port(); 3184 if (!gp) { 3185 printk(KERN_ERR "trident: cannot allocate memory for gameport\n"); 3186 return -ENOMEM; 3187 } 3188 3189 gameport_set_name(gp, "Trident 4DWave"); 3190 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 3191 gameport_set_dev_parent(gp, &chip->pci->dev); 3192 3193 gameport_set_port_data(gp, chip); 3194 gp->fuzz = 64; 3195 gp->read = snd_trident_gameport_read; 3196 gp->trigger = snd_trident_gameport_trigger; 3197 gp->cooked_read = snd_trident_gameport_cooked_read; 3198 gp->open = snd_trident_gameport_open; 3199 3200 gameport_register_port(gp); 3201 3202 return 0; 3203 } 3204 3205 static inline void snd_trident_free_gameport(struct snd_trident *chip) 3206 { 3207 if (chip->gameport) { 3208 gameport_unregister_port(chip->gameport); 3209 chip->gameport = NULL; 3210 } 3211 } 3212 #else 3213 int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; } 3214 static inline void snd_trident_free_gameport(struct snd_trident *chip) { } 3215 #endif /* CONFIG_GAMEPORT */ 3216 3217 /* 3218 * delay for 1 tick 3219 */ 3220 static inline void do_delay(struct snd_trident *chip) 3221 { 3222 schedule_timeout_uninterruptible(1); 3223 } 3224 3225 /* 3226 * SiS reset routine 3227 */ 3228 3229 static int snd_trident_sis_reset(struct snd_trident *trident) 3230 { 3231 unsigned long end_time; 3232 unsigned int i; 3233 int r; 3234 3235 r = trident->in_suspend ? 0 : 2; /* count of retries */ 3236 __si7018_retry: 3237 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */ 3238 udelay(100); 3239 pci_write_config_byte(trident->pci, 0x46, 0x00); 3240 udelay(100); 3241 /* disable AC97 GPIO interrupt */ 3242 outb(0x00, TRID_REG(trident, SI_AC97_GPIO)); 3243 /* initialize serial interface, force cold reset */ 3244 i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET; 3245 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3246 udelay(1000); 3247 /* remove cold reset */ 3248 i &= ~COLD_RESET; 3249 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3250 udelay(2000); 3251 /* wait, until the codec is ready */ 3252 end_time = (jiffies + (HZ * 3) / 4) + 1; 3253 do { 3254 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) 3255 goto __si7018_ok; 3256 do_delay(trident); 3257 } while (time_after_eq(end_time, jiffies)); 3258 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL))); 3259 if (r-- > 0) { 3260 end_time = jiffies + HZ; 3261 do { 3262 do_delay(trident); 3263 } while (time_after_eq(end_time, jiffies)); 3264 goto __si7018_retry; 3265 } 3266 __si7018_ok: 3267 /* wait for the second codec */ 3268 do { 3269 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0) 3270 break; 3271 do_delay(trident); 3272 } while (time_after_eq(end_time, jiffies)); 3273 /* enable 64 channel mode */ 3274 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR)); 3275 return 0; 3276 } 3277 3278 /* 3279 * /proc interface 3280 */ 3281 3282 static void snd_trident_proc_read(struct snd_info_entry *entry, 3283 struct snd_info_buffer *buffer) 3284 { 3285 struct snd_trident *trident = entry->private_data; 3286 char *s; 3287 3288 switch (trident->device) { 3289 case TRIDENT_DEVICE_ID_SI7018: 3290 s = "SiS 7018 Audio"; 3291 break; 3292 case TRIDENT_DEVICE_ID_DX: 3293 s = "Trident 4DWave PCI DX"; 3294 break; 3295 case TRIDENT_DEVICE_ID_NX: 3296 s = "Trident 4DWave PCI NX"; 3297 break; 3298 default: 3299 s = "???"; 3300 } 3301 snd_iprintf(buffer, "%s\n\n", s); 3302 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count); 3303 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta); 3304 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) 3305 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off"); 3306 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3307 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off"); 3308 if (trident->tlb.entries) { 3309 snd_iprintf(buffer,"\nVirtual Memory\n"); 3310 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size); 3311 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used); 3312 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr)); 3313 } 3314 } 3315 } 3316 3317 static void __devinit snd_trident_proc_init(struct snd_trident * trident) 3318 { 3319 struct snd_info_entry *entry; 3320 const char *s = "trident"; 3321 3322 if (trident->device == TRIDENT_DEVICE_ID_SI7018) 3323 s = "sis7018"; 3324 if (! snd_card_proc_new(trident->card, s, &entry)) 3325 snd_info_set_text_ops(entry, trident, snd_trident_proc_read); 3326 } 3327 3328 static int snd_trident_dev_free(struct snd_device *device) 3329 { 3330 struct snd_trident *trident = device->device_data; 3331 return snd_trident_free(trident); 3332 } 3333 3334 /*--------------------------------------------------------------------------- 3335 snd_trident_tlb_alloc 3336 3337 Description: Allocate and set up the TLB page table on 4D NX. 3338 Each entry has 4 bytes (physical PCI address). 3339 3340 Parameters: trident - pointer to target device class for 4DWave. 3341 3342 Returns: 0 or negative error code 3343 3344 ---------------------------------------------------------------------------*/ 3345 3346 static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) 3347 { 3348 int i; 3349 3350 /* TLB array must be aligned to 16kB !!! so we allocate 3351 32kB region and correct offset when necessary */ 3352 3353 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 3354 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) { 3355 snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n"); 3356 return -ENOMEM; 3357 } 3358 trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4); 3359 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4); 3360 /* allocate shadow TLB page table (virtual addresses) */ 3361 trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); 3362 if (trident->tlb.shadow_entries == NULL) { 3363 snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n"); 3364 return -ENOMEM; 3365 } 3366 /* allocate and setup silent page and initialise TLB entries */ 3367 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 3368 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) { 3369 snd_printk(KERN_ERR "trident: unable to allocate silent page\n"); 3370 return -ENOMEM; 3371 } 3372 memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE); 3373 for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) { 3374 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1)); 3375 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area; 3376 } 3377 3378 /* use emu memory block manager code to manage tlb page allocation */ 3379 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES); 3380 if (trident->tlb.memhdr == NULL) 3381 return -ENOMEM; 3382 3383 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg); 3384 return 0; 3385 } 3386 3387 /* 3388 * initialize 4D DX chip 3389 */ 3390 3391 static void snd_trident_stop_all_voices(struct snd_trident *trident) 3392 { 3393 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A)); 3394 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B)); 3395 outl(0, TRID_REG(trident, T4D_AINTEN_A)); 3396 outl(0, TRID_REG(trident, T4D_AINTEN_B)); 3397 } 3398 3399 static int snd_trident_4d_dx_init(struct snd_trident *trident) 3400 { 3401 struct pci_dev *pci = trident->pci; 3402 unsigned long end_time; 3403 3404 /* reset the legacy configuration and whole audio/wavetable block */ 3405 pci_write_config_dword(pci, 0x40, 0); /* DDMA */ 3406 pci_write_config_byte(pci, 0x44, 0); /* ports */ 3407 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ 3408 pci_write_config_byte(pci, 0x46, 4); /* reset */ 3409 udelay(100); 3410 pci_write_config_byte(pci, 0x46, 0); /* release reset */ 3411 udelay(100); 3412 3413 /* warm reset of the AC'97 codec */ 3414 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3415 udelay(100); 3416 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3417 /* DAC on, disable SB IRQ and try to force ADC valid signal */ 3418 trident->ac97_ctrl = 0x0000004a; 3419 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3420 /* wait, until the codec is ready */ 3421 end_time = (jiffies + (HZ * 3) / 4) + 1; 3422 do { 3423 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0) 3424 goto __dx_ok; 3425 do_delay(trident); 3426 } while (time_after_eq(end_time, jiffies)); 3427 snd_printk(KERN_ERR "AC'97 codec ready error\n"); 3428 return -EIO; 3429 3430 __dx_ok: 3431 snd_trident_stop_all_voices(trident); 3432 3433 return 0; 3434 } 3435 3436 /* 3437 * initialize 4D NX chip 3438 */ 3439 static int snd_trident_4d_nx_init(struct snd_trident *trident) 3440 { 3441 struct pci_dev *pci = trident->pci; 3442 unsigned long end_time; 3443 3444 /* reset the legacy configuration and whole audio/wavetable block */ 3445 pci_write_config_dword(pci, 0x40, 0); /* DDMA */ 3446 pci_write_config_byte(pci, 0x44, 0); /* ports */ 3447 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ 3448 3449 pci_write_config_byte(pci, 0x46, 1); /* reset */ 3450 udelay(100); 3451 pci_write_config_byte(pci, 0x46, 0); /* release reset */ 3452 udelay(100); 3453 3454 /* warm reset of the AC'97 codec */ 3455 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3456 udelay(100); 3457 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3458 /* wait, until the codec is ready */ 3459 end_time = (jiffies + (HZ * 3) / 4) + 1; 3460 do { 3461 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0) 3462 goto __nx_ok; 3463 do_delay(trident); 3464 } while (time_after_eq(end_time, jiffies)); 3465 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT))); 3466 return -EIO; 3467 3468 __nx_ok: 3469 /* DAC on */ 3470 trident->ac97_ctrl = 0x00000002; 3471 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3472 /* disable SB IRQ */ 3473 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT)); 3474 3475 snd_trident_stop_all_voices(trident); 3476 3477 if (trident->tlb.entries != NULL) { 3478 unsigned int i; 3479 /* enable virtual addressing via TLB */ 3480 i = trident->tlb.entries_dmaaddr; 3481 i |= 0x00000001; 3482 outl(i, TRID_REG(trident, NX_TLBC)); 3483 } else { 3484 outl(0, TRID_REG(trident, NX_TLBC)); 3485 } 3486 /* initialize S/PDIF */ 3487 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); 3488 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 3489 3490 return 0; 3491 } 3492 3493 /* 3494 * initialize sis7018 chip 3495 */ 3496 static int snd_trident_sis_init(struct snd_trident *trident) 3497 { 3498 int err; 3499 3500 if ((err = snd_trident_sis_reset(trident)) < 0) 3501 return err; 3502 3503 snd_trident_stop_all_voices(trident); 3504 3505 /* initialize S/PDIF */ 3506 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 3507 3508 return 0; 3509 } 3510 3511 /*--------------------------------------------------------------------------- 3512 snd_trident_create 3513 3514 Description: This routine will create the device specific class for 3515 the 4DWave card. It will also perform basic initialization. 3516 3517 Parameters: card - which card to create 3518 pci - interface to PCI bus resource info 3519 dma1ptr - playback dma buffer 3520 dma2ptr - capture dma buffer 3521 irqptr - interrupt resource info 3522 3523 Returns: 4DWave device class private data 3524 3525 ---------------------------------------------------------------------------*/ 3526 3527 int __devinit snd_trident_create(struct snd_card *card, 3528 struct pci_dev *pci, 3529 int pcm_streams, 3530 int pcm_spdif_device, 3531 int max_wavetable_size, 3532 struct snd_trident ** rtrident) 3533 { 3534 struct snd_trident *trident; 3535 int i, err; 3536 struct snd_trident_voice *voice; 3537 struct snd_trident_pcm_mixer *tmix; 3538 static struct snd_device_ops ops = { 3539 .dev_free = snd_trident_dev_free, 3540 }; 3541 3542 *rtrident = NULL; 3543 3544 /* enable PCI device */ 3545 if ((err = pci_enable_device(pci)) < 0) 3546 return err; 3547 /* check, if we can restrict PCI DMA transfers to 30 bits */ 3548 if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0 || 3549 pci_set_consistent_dma_mask(pci, DMA_30BIT_MASK) < 0) { 3550 snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n"); 3551 pci_disable_device(pci); 3552 return -ENXIO; 3553 } 3554 3555 trident = kzalloc(sizeof(*trident), GFP_KERNEL); 3556 if (trident == NULL) { 3557 pci_disable_device(pci); 3558 return -ENOMEM; 3559 } 3560 trident->device = (pci->vendor << 16) | pci->device; 3561 trident->card = card; 3562 trident->pci = pci; 3563 spin_lock_init(&trident->reg_lock); 3564 spin_lock_init(&trident->event_lock); 3565 spin_lock_init(&trident->voice_alloc); 3566 if (pcm_streams < 1) 3567 pcm_streams = 1; 3568 if (pcm_streams > 32) 3569 pcm_streams = 32; 3570 trident->ChanPCM = pcm_streams; 3571 if (max_wavetable_size < 0 ) 3572 max_wavetable_size = 0; 3573 trident->synth.max_size = max_wavetable_size * 1024; 3574 trident->irq = -1; 3575 3576 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE); 3577 pci_set_master(pci); 3578 3579 if ((err = pci_request_regions(pci, "Trident Audio")) < 0) { 3580 kfree(trident); 3581 pci_disable_device(pci); 3582 return err; 3583 } 3584 trident->port = pci_resource_start(pci, 0); 3585 3586 if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED, 3587 "Trident Audio", trident)) { 3588 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 3589 snd_trident_free(trident); 3590 return -EBUSY; 3591 } 3592 trident->irq = pci->irq; 3593 3594 /* allocate 16k-aligned TLB for NX cards */ 3595 trident->tlb.entries = NULL; 3596 trident->tlb.buffer.area = NULL; 3597 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3598 if ((err = snd_trident_tlb_alloc(trident)) < 0) { 3599 snd_trident_free(trident); 3600 return err; 3601 } 3602 } 3603 3604 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF; 3605 3606 /* initialize chip */ 3607 switch (trident->device) { 3608 case TRIDENT_DEVICE_ID_DX: 3609 err = snd_trident_4d_dx_init(trident); 3610 break; 3611 case TRIDENT_DEVICE_ID_NX: 3612 err = snd_trident_4d_nx_init(trident); 3613 break; 3614 case TRIDENT_DEVICE_ID_SI7018: 3615 err = snd_trident_sis_init(trident); 3616 break; 3617 default: 3618 snd_BUG(); 3619 break; 3620 } 3621 if (err < 0) { 3622 snd_trident_free(trident); 3623 return err; 3624 } 3625 3626 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) { 3627 snd_trident_free(trident); 3628 return err; 3629 } 3630 3631 if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0) 3632 return err; 3633 3634 /* initialise synth voices */ 3635 for (i = 0; i < 64; i++) { 3636 voice = &trident->synth.voices[i]; 3637 voice->number = i; 3638 voice->trident = trident; 3639 } 3640 /* initialize pcm mixer entries */ 3641 for (i = 0; i < 32; i++) { 3642 tmix = &trident->pcm_mixer[i]; 3643 tmix->vol = T4D_DEFAULT_PCM_VOL; 3644 tmix->pan = T4D_DEFAULT_PCM_PAN; 3645 tmix->rvol = T4D_DEFAULT_PCM_RVOL; 3646 tmix->cvol = T4D_DEFAULT_PCM_CVOL; 3647 } 3648 3649 snd_trident_enable_eso(trident); 3650 3651 snd_trident_proc_init(trident); 3652 snd_card_set_dev(card, &pci->dev); 3653 *rtrident = trident; 3654 return 0; 3655 } 3656 3657 /*--------------------------------------------------------------------------- 3658 snd_trident_free 3659 3660 Description: This routine will free the device specific class for 3661 the 4DWave card. 3662 3663 Parameters: trident - device specific private data for 4DWave card 3664 3665 Returns: None. 3666 3667 ---------------------------------------------------------------------------*/ 3668 3669 static int snd_trident_free(struct snd_trident *trident) 3670 { 3671 snd_trident_free_gameport(trident); 3672 snd_trident_disable_eso(trident); 3673 // Disable S/PDIF out 3674 if (trident->device == TRIDENT_DEVICE_ID_NX) 3675 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 3676 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 3677 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3678 } 3679 if (trident->tlb.buffer.area) { 3680 outl(0, TRID_REG(trident, NX_TLBC)); 3681 if (trident->tlb.memhdr) 3682 snd_util_memhdr_free(trident->tlb.memhdr); 3683 if (trident->tlb.silent_page.area) 3684 snd_dma_free_pages(&trident->tlb.silent_page); 3685 vfree(trident->tlb.shadow_entries); 3686 snd_dma_free_pages(&trident->tlb.buffer); 3687 } 3688 if (trident->irq >= 0) 3689 free_irq(trident->irq, trident); 3690 pci_release_regions(trident->pci); 3691 pci_disable_device(trident->pci); 3692 kfree(trident); 3693 return 0; 3694 } 3695 3696 /*--------------------------------------------------------------------------- 3697 snd_trident_interrupt 3698 3699 Description: ISR for Trident 4DWave device 3700 3701 Parameters: trident - device specific private data for 4DWave card 3702 3703 Problems: It seems that Trident chips generates interrupts more than 3704 one time in special cases. The spurious interrupts are 3705 detected via sample timer (T4D_STIMER) and computing 3706 corresponding delta value. The limits are detected with 3707 the method try & fail so it is possible that it won't 3708 work on all computers. [jaroslav] 3709 3710 Returns: None. 3711 3712 ---------------------------------------------------------------------------*/ 3713 3714 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id) 3715 { 3716 struct snd_trident *trident = dev_id; 3717 unsigned int audio_int, chn_int, stimer, channel, mask, tmp; 3718 int delta; 3719 struct snd_trident_voice *voice; 3720 3721 audio_int = inl(TRID_REG(trident, T4D_MISCINT)); 3722 if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0) 3723 return IRQ_NONE; 3724 if (audio_int & ADDRESS_IRQ) { 3725 // get interrupt status for all channels 3726 spin_lock(&trident->reg_lock); 3727 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; 3728 chn_int = inl(TRID_REG(trident, T4D_AINT_A)); 3729 if (chn_int == 0) 3730 goto __skip1; 3731 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */ 3732 __skip1: 3733 chn_int = inl(TRID_REG(trident, T4D_AINT_B)); 3734 if (chn_int == 0) 3735 goto __skip2; 3736 for (channel = 63; channel >= 32; channel--) { 3737 mask = 1 << (channel&0x1f); 3738 if ((chn_int & mask) == 0) 3739 continue; 3740 voice = &trident->synth.voices[channel]; 3741 if (!voice->pcm || voice->substream == NULL) { 3742 outl(mask, TRID_REG(trident, T4D_STOP_B)); 3743 continue; 3744 } 3745 delta = (int)stimer - (int)voice->stimer; 3746 if (delta < 0) 3747 delta = -delta; 3748 if ((unsigned int)delta < voice->spurious_threshold) { 3749 /* do some statistics here */ 3750 trident->spurious_irq_count++; 3751 if (trident->spurious_irq_max_delta < (unsigned int)delta) 3752 trident->spurious_irq_max_delta = delta; 3753 continue; 3754 } 3755 voice->stimer = stimer; 3756 if (voice->isync) { 3757 if (!voice->isync3) { 3758 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL)); 3759 if (trident->bDMAStart & 0x40) 3760 tmp >>= 1; 3761 if (tmp > 0) 3762 tmp = voice->isync_max - tmp; 3763 } else { 3764 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff; 3765 } 3766 if (tmp < voice->isync_mark) { 3767 if (tmp > 0x10) 3768 tmp = voice->isync_ESO - 7; 3769 else 3770 tmp = voice->isync_ESO + 2; 3771 /* update ESO for IRQ voice to preserve sync */ 3772 snd_trident_stop_voice(trident, voice->number); 3773 snd_trident_write_eso_reg(trident, voice, tmp); 3774 snd_trident_start_voice(trident, voice->number); 3775 } 3776 } else if (voice->isync2) { 3777 voice->isync2 = 0; 3778 /* write original ESO and update CSO for IRQ voice to preserve sync */ 3779 snd_trident_stop_voice(trident, voice->number); 3780 snd_trident_write_cso_reg(trident, voice, voice->isync_mark); 3781 snd_trident_write_eso_reg(trident, voice, voice->ESO); 3782 snd_trident_start_voice(trident, voice->number); 3783 } 3784 #if 0 3785 if (voice->extra) { 3786 /* update CSO for extra voice to preserve sync */ 3787 snd_trident_stop_voice(trident, voice->extra->number); 3788 snd_trident_write_cso_reg(trident, voice->extra, 0); 3789 snd_trident_start_voice(trident, voice->extra->number); 3790 } 3791 #endif 3792 spin_unlock(&trident->reg_lock); 3793 snd_pcm_period_elapsed(voice->substream); 3794 spin_lock(&trident->reg_lock); 3795 } 3796 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */ 3797 __skip2: 3798 spin_unlock(&trident->reg_lock); 3799 } 3800 if (audio_int & MPU401_IRQ) { 3801 if (trident->rmidi) { 3802 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data); 3803 } else { 3804 inb(TRID_REG(trident, T4D_MPUR0)); 3805 } 3806 } 3807 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT)); 3808 return IRQ_HANDLED; 3809 } 3810 3811 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port) 3812 { 3813 struct snd_trident_voice *pvoice; 3814 unsigned long flags; 3815 int idx; 3816 3817 spin_lock_irqsave(&trident->voice_alloc, flags); 3818 if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) { 3819 idx = snd_trident_allocate_pcm_channel(trident); 3820 if(idx < 0) { 3821 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3822 return NULL; 3823 } 3824 pvoice = &trident->synth.voices[idx]; 3825 pvoice->use = 1; 3826 pvoice->pcm = 1; 3827 pvoice->capture = 0; 3828 pvoice->spdif = 0; 3829 pvoice->memblk = NULL; 3830 pvoice->substream = NULL; 3831 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3832 return pvoice; 3833 } 3834 if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) { 3835 idx = snd_trident_allocate_synth_channel(trident); 3836 if(idx < 0) { 3837 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3838 return NULL; 3839 } 3840 pvoice = &trident->synth.voices[idx]; 3841 pvoice->use = 1; 3842 pvoice->synth = 1; 3843 pvoice->client = client; 3844 pvoice->port = port; 3845 pvoice->memblk = NULL; 3846 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3847 return pvoice; 3848 } 3849 if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) { 3850 } 3851 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3852 return NULL; 3853 } 3854 3855 EXPORT_SYMBOL(snd_trident_alloc_voice); 3856 3857 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice) 3858 { 3859 unsigned long flags; 3860 void (*private_free)(struct snd_trident_voice *); 3861 void *private_data; 3862 3863 if (voice == NULL || !voice->use) 3864 return; 3865 snd_trident_clear_voices(trident, voice->number, voice->number); 3866 spin_lock_irqsave(&trident->voice_alloc, flags); 3867 private_free = voice->private_free; 3868 private_data = voice->private_data; 3869 voice->private_free = NULL; 3870 voice->private_data = NULL; 3871 if (voice->pcm) 3872 snd_trident_free_pcm_channel(trident, voice->number); 3873 if (voice->synth) 3874 snd_trident_free_synth_channel(trident, voice->number); 3875 voice->use = voice->pcm = voice->synth = voice->midi = 0; 3876 voice->capture = voice->spdif = 0; 3877 voice->sample_ops = NULL; 3878 voice->substream = NULL; 3879 voice->extra = NULL; 3880 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3881 if (private_free) 3882 private_free(voice); 3883 } 3884 3885 EXPORT_SYMBOL(snd_trident_free_voice); 3886 3887 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max) 3888 { 3889 unsigned int i, val, mask[2] = { 0, 0 }; 3890 3891 snd_assert(v_min <= 63, return); 3892 snd_assert(v_max <= 63, return); 3893 for (i = v_min; i <= v_max; i++) 3894 mask[i >> 5] |= 1 << (i & 0x1f); 3895 if (mask[0]) { 3896 outl(mask[0], TRID_REG(trident, T4D_STOP_A)); 3897 val = inl(TRID_REG(trident, T4D_AINTEN_A)); 3898 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A)); 3899 } 3900 if (mask[1]) { 3901 outl(mask[1], TRID_REG(trident, T4D_STOP_B)); 3902 val = inl(TRID_REG(trident, T4D_AINTEN_B)); 3903 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B)); 3904 } 3905 } 3906 3907 #ifdef CONFIG_PM 3908 int snd_trident_suspend(struct pci_dev *pci, pm_message_t state) 3909 { 3910 struct snd_card *card = pci_get_drvdata(pci); 3911 struct snd_trident *trident = card->private_data; 3912 3913 trident->in_suspend = 1; 3914 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 3915 snd_pcm_suspend_all(trident->pcm); 3916 snd_pcm_suspend_all(trident->foldback); 3917 snd_pcm_suspend_all(trident->spdif); 3918 3919 snd_ac97_suspend(trident->ac97); 3920 snd_ac97_suspend(trident->ac97_sec); 3921 3922 pci_disable_device(pci); 3923 pci_save_state(pci); 3924 pci_set_power_state(pci, pci_choose_state(pci, state)); 3925 return 0; 3926 } 3927 3928 int snd_trident_resume(struct pci_dev *pci) 3929 { 3930 struct snd_card *card = pci_get_drvdata(pci); 3931 struct snd_trident *trident = card->private_data; 3932 3933 pci_set_power_state(pci, PCI_D0); 3934 pci_restore_state(pci); 3935 if (pci_enable_device(pci) < 0) { 3936 printk(KERN_ERR "trident: pci_enable_device failed, " 3937 "disabling device\n"); 3938 snd_card_disconnect(card); 3939 return -EIO; 3940 } 3941 pci_set_master(pci); 3942 3943 switch (trident->device) { 3944 case TRIDENT_DEVICE_ID_DX: 3945 snd_trident_4d_dx_init(trident); 3946 break; 3947 case TRIDENT_DEVICE_ID_NX: 3948 snd_trident_4d_nx_init(trident); 3949 break; 3950 case TRIDENT_DEVICE_ID_SI7018: 3951 snd_trident_sis_init(trident); 3952 break; 3953 } 3954 3955 snd_ac97_resume(trident->ac97); 3956 snd_ac97_resume(trident->ac97_sec); 3957 3958 /* restore some registers */ 3959 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3960 3961 snd_trident_enable_eso(trident); 3962 3963 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 3964 trident->in_suspend = 0; 3965 return 0; 3966 } 3967 #endif /* CONFIG_PM */ 3968