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