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/trident.h> 44 #include <sound/asoundef.h> 45 46 #include <asm/io.h> 47 48 static int snd_trident_pcm_mixer_build(struct snd_trident *trident, 49 struct snd_trident_voice * voice, 50 struct snd_pcm_substream *substream); 51 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, 52 struct snd_trident_voice * voice, 53 struct snd_pcm_substream *substream); 54 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, 55 struct pt_regs *regs); 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 int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol, 2631 struct snd_ctl_elem_value *ucontrol) 2632 { 2633 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2634 unsigned int val; 2635 int change = 0; 2636 2637 spin_lock_irq(&trident->reg_lock); 2638 val = trident->musicvol_wavevol; 2639 val &= ~(0xffff << kcontrol->private_value); 2640 val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) | 2641 ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value; 2642 change = val != trident->musicvol_wavevol; 2643 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 2644 spin_unlock_irq(&trident->reg_lock); 2645 return change; 2646 } 2647 2648 static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata = 2649 { 2650 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2651 .name = "Music Playback Volume", 2652 .info = snd_trident_vol_control_info, 2653 .get = snd_trident_vol_control_get, 2654 .put = snd_trident_vol_control_put, 2655 .private_value = 16, 2656 }; 2657 2658 static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata = 2659 { 2660 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2661 .name = "Wave Playback Volume", 2662 .info = snd_trident_vol_control_info, 2663 .get = snd_trident_vol_control_get, 2664 .put = snd_trident_vol_control_put, 2665 .private_value = 0, 2666 }; 2667 2668 /*--------------------------------------------------------------------------- 2669 snd_trident_pcm_vol_control 2670 2671 Description: PCM front volume control 2672 ---------------------------------------------------------------------------*/ 2673 2674 static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol, 2675 struct snd_ctl_elem_info *uinfo) 2676 { 2677 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2678 2679 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2680 uinfo->count = 1; 2681 uinfo->value.integer.min = 0; 2682 uinfo->value.integer.max = 255; 2683 if (trident->device == TRIDENT_DEVICE_ID_SI7018) 2684 uinfo->value.integer.max = 1023; 2685 return 0; 2686 } 2687 2688 static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol, 2689 struct snd_ctl_elem_value *ucontrol) 2690 { 2691 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2692 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2693 2694 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 2695 ucontrol->value.integer.value[0] = 1023 - mix->vol; 2696 } else { 2697 ucontrol->value.integer.value[0] = 255 - (mix->vol>>2); 2698 } 2699 return 0; 2700 } 2701 2702 static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol, 2703 struct snd_ctl_elem_value *ucontrol) 2704 { 2705 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2706 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2707 unsigned int val; 2708 int change = 0; 2709 2710 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 2711 val = 1023 - (ucontrol->value.integer.value[0] & 1023); 2712 } else { 2713 val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2; 2714 } 2715 spin_lock_irq(&trident->reg_lock); 2716 change = val != mix->vol; 2717 mix->vol = val; 2718 if (mix->voice != NULL) 2719 snd_trident_write_vol_reg(trident, mix->voice, val); 2720 spin_unlock_irq(&trident->reg_lock); 2721 return change; 2722 } 2723 2724 static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata = 2725 { 2726 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2727 .name = "PCM Front Playback Volume", 2728 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2729 .count = 32, 2730 .info = snd_trident_pcm_vol_control_info, 2731 .get = snd_trident_pcm_vol_control_get, 2732 .put = snd_trident_pcm_vol_control_put, 2733 }; 2734 2735 /*--------------------------------------------------------------------------- 2736 snd_trident_pcm_pan_control 2737 2738 Description: PCM front pan control 2739 ---------------------------------------------------------------------------*/ 2740 2741 static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol, 2742 struct snd_ctl_elem_info *uinfo) 2743 { 2744 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2745 uinfo->count = 1; 2746 uinfo->value.integer.min = 0; 2747 uinfo->value.integer.max = 127; 2748 return 0; 2749 } 2750 2751 static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol, 2752 struct snd_ctl_elem_value *ucontrol) 2753 { 2754 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2755 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2756 2757 ucontrol->value.integer.value[0] = mix->pan; 2758 if (ucontrol->value.integer.value[0] & 0x40) { 2759 ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)); 2760 } else { 2761 ucontrol->value.integer.value[0] |= 0x40; 2762 } 2763 return 0; 2764 } 2765 2766 static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol, 2767 struct snd_ctl_elem_value *ucontrol) 2768 { 2769 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2770 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2771 unsigned char val; 2772 int change = 0; 2773 2774 if (ucontrol->value.integer.value[0] & 0x40) 2775 val = ucontrol->value.integer.value[0] & 0x3f; 2776 else 2777 val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40; 2778 spin_lock_irq(&trident->reg_lock); 2779 change = val != mix->pan; 2780 mix->pan = val; 2781 if (mix->voice != NULL) 2782 snd_trident_write_pan_reg(trident, mix->voice, val); 2783 spin_unlock_irq(&trident->reg_lock); 2784 return change; 2785 } 2786 2787 static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata = 2788 { 2789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2790 .name = "PCM Pan Playback Control", 2791 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2792 .count = 32, 2793 .info = snd_trident_pcm_pan_control_info, 2794 .get = snd_trident_pcm_pan_control_get, 2795 .put = snd_trident_pcm_pan_control_put, 2796 }; 2797 2798 /*--------------------------------------------------------------------------- 2799 snd_trident_pcm_rvol_control 2800 2801 Description: PCM reverb volume control 2802 ---------------------------------------------------------------------------*/ 2803 2804 static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol, 2805 struct snd_ctl_elem_info *uinfo) 2806 { 2807 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2808 uinfo->count = 1; 2809 uinfo->value.integer.min = 0; 2810 uinfo->value.integer.max = 127; 2811 return 0; 2812 } 2813 2814 static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol, 2815 struct snd_ctl_elem_value *ucontrol) 2816 { 2817 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2818 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2819 2820 ucontrol->value.integer.value[0] = 127 - mix->rvol; 2821 return 0; 2822 } 2823 2824 static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol, 2825 struct snd_ctl_elem_value *ucontrol) 2826 { 2827 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2828 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2829 unsigned short val; 2830 int change = 0; 2831 2832 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); 2833 spin_lock_irq(&trident->reg_lock); 2834 change = val != mix->rvol; 2835 mix->rvol = val; 2836 if (mix->voice != NULL) 2837 snd_trident_write_rvol_reg(trident, mix->voice, val); 2838 spin_unlock_irq(&trident->reg_lock); 2839 return change; 2840 } 2841 2842 static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata = 2843 { 2844 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2845 .name = "PCM Reverb Playback Volume", 2846 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2847 .count = 32, 2848 .info = snd_trident_pcm_rvol_control_info, 2849 .get = snd_trident_pcm_rvol_control_get, 2850 .put = snd_trident_pcm_rvol_control_put, 2851 }; 2852 2853 /*--------------------------------------------------------------------------- 2854 snd_trident_pcm_cvol_control 2855 2856 Description: PCM chorus volume control 2857 ---------------------------------------------------------------------------*/ 2858 2859 static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol, 2860 struct snd_ctl_elem_info *uinfo) 2861 { 2862 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2863 uinfo->count = 1; 2864 uinfo->value.integer.min = 0; 2865 uinfo->value.integer.max = 127; 2866 return 0; 2867 } 2868 2869 static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol, 2870 struct snd_ctl_elem_value *ucontrol) 2871 { 2872 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2873 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2874 2875 ucontrol->value.integer.value[0] = 127 - mix->cvol; 2876 return 0; 2877 } 2878 2879 static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol, 2880 struct snd_ctl_elem_value *ucontrol) 2881 { 2882 struct snd_trident *trident = snd_kcontrol_chip(kcontrol); 2883 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; 2884 unsigned short val; 2885 int change = 0; 2886 2887 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); 2888 spin_lock_irq(&trident->reg_lock); 2889 change = val != mix->cvol; 2890 mix->cvol = val; 2891 if (mix->voice != NULL) 2892 snd_trident_write_cvol_reg(trident, mix->voice, val); 2893 spin_unlock_irq(&trident->reg_lock); 2894 return change; 2895 } 2896 2897 static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata = 2898 { 2899 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2900 .name = "PCM Chorus Playback Volume", 2901 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, 2902 .count = 32, 2903 .info = snd_trident_pcm_cvol_control_info, 2904 .get = snd_trident_pcm_cvol_control_get, 2905 .put = snd_trident_pcm_cvol_control_put, 2906 }; 2907 2908 static void snd_trident_notify_pcm_change1(struct snd_card *card, 2909 struct snd_kcontrol *kctl, 2910 int num, int activate) 2911 { 2912 struct snd_ctl_elem_id id; 2913 2914 if (! kctl) 2915 return; 2916 if (activate) 2917 kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 2918 else 2919 kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; 2920 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | 2921 SNDRV_CTL_EVENT_MASK_INFO, 2922 snd_ctl_build_ioff(&id, kctl, num)); 2923 } 2924 2925 static void snd_trident_notify_pcm_change(struct snd_trident *trident, 2926 struct snd_trident_pcm_mixer *tmix, 2927 int num, int activate) 2928 { 2929 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate); 2930 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate); 2931 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate); 2932 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate); 2933 } 2934 2935 static int snd_trident_pcm_mixer_build(struct snd_trident *trident, 2936 struct snd_trident_voice *voice, 2937 struct snd_pcm_substream *substream) 2938 { 2939 struct snd_trident_pcm_mixer *tmix; 2940 2941 snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL); 2942 tmix = &trident->pcm_mixer[substream->number]; 2943 tmix->voice = voice; 2944 tmix->vol = T4D_DEFAULT_PCM_VOL; 2945 tmix->pan = T4D_DEFAULT_PCM_PAN; 2946 tmix->rvol = T4D_DEFAULT_PCM_RVOL; 2947 tmix->cvol = T4D_DEFAULT_PCM_CVOL; 2948 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1); 2949 return 0; 2950 } 2951 2952 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream) 2953 { 2954 struct snd_trident_pcm_mixer *tmix; 2955 2956 snd_assert(trident != NULL && substream != NULL, return -EINVAL); 2957 tmix = &trident->pcm_mixer[substream->number]; 2958 tmix->voice = NULL; 2959 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0); 2960 return 0; 2961 } 2962 2963 /*--------------------------------------------------------------------------- 2964 snd_trident_mixer 2965 2966 Description: This routine registers the 4DWave device for mixer support. 2967 2968 Paramters: trident - pointer to target device class for 4DWave. 2969 2970 Returns: None 2971 2972 ---------------------------------------------------------------------------*/ 2973 2974 static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device) 2975 { 2976 struct snd_ac97_template _ac97; 2977 struct snd_card *card = trident->card; 2978 struct snd_kcontrol *kctl; 2979 struct snd_ctl_elem_value *uctl; 2980 int idx, err, retries = 2; 2981 static struct snd_ac97_bus_ops ops = { 2982 .write = snd_trident_codec_write, 2983 .read = snd_trident_codec_read, 2984 }; 2985 2986 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 2987 if (!uctl) 2988 return -ENOMEM; 2989 2990 if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0) 2991 goto __out; 2992 2993 memset(&_ac97, 0, sizeof(_ac97)); 2994 _ac97.private_data = trident; 2995 trident->ac97_detect = 1; 2996 2997 __again: 2998 if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) { 2999 if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 3000 if ((err = snd_trident_sis_reset(trident)) < 0) 3001 goto __out; 3002 if (retries-- > 0) 3003 goto __again; 3004 err = -EIO; 3005 } 3006 goto __out; 3007 } 3008 3009 /* secondary codec? */ 3010 if (trident->device == TRIDENT_DEVICE_ID_SI7018 && 3011 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) { 3012 _ac97.num = 1; 3013 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec); 3014 if (err < 0) 3015 snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n"); 3016 #if 0 // only for my testing purpose --jk 3017 { 3018 struct snd_ac97 *mc97; 3019 err = snd_ac97_modem(trident->card, &_ac97, &mc97); 3020 if (err < 0) 3021 snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err); 3022 } 3023 #endif 3024 } 3025 3026 trident->ac97_detect = 0; 3027 3028 if (trident->device != TRIDENT_DEVICE_ID_SI7018) { 3029 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0) 3030 goto __out; 3031 kctl->put(kctl, uctl); 3032 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0) 3033 goto __out; 3034 kctl->put(kctl, uctl); 3035 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3036 } else { 3037 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3038 } 3039 3040 for (idx = 0; idx < 32; idx++) { 3041 struct snd_trident_pcm_mixer *tmix; 3042 3043 tmix = &trident->pcm_mixer[idx]; 3044 tmix->voice = NULL; 3045 } 3046 if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL) 3047 goto __nomem; 3048 if ((err = snd_ctl_add(card, trident->ctl_vol))) 3049 goto __out; 3050 3051 if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL) 3052 goto __nomem; 3053 if ((err = snd_ctl_add(card, trident->ctl_pan))) 3054 goto __out; 3055 3056 if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL) 3057 goto __nomem; 3058 if ((err = snd_ctl_add(card, trident->ctl_rvol))) 3059 goto __out; 3060 3061 if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL) 3062 goto __nomem; 3063 if ((err = snd_ctl_add(card, trident->ctl_cvol))) 3064 goto __out; 3065 3066 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3067 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0) 3068 goto __out; 3069 kctl->put(kctl, uctl); 3070 } 3071 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) { 3072 3073 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident); 3074 if (kctl == NULL) { 3075 err = -ENOMEM; 3076 goto __out; 3077 } 3078 if (trident->ac97->ext_id & AC97_EI_SPDIF) 3079 kctl->id.index++; 3080 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF)) 3081 kctl->id.index++; 3082 idx = kctl->id.index; 3083 if ((err = snd_ctl_add(card, kctl)) < 0) 3084 goto __out; 3085 kctl->put(kctl, uctl); 3086 3087 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident); 3088 if (kctl == NULL) { 3089 err = -ENOMEM; 3090 goto __out; 3091 } 3092 kctl->id.index = idx; 3093 kctl->id.device = pcm_spdif_device; 3094 if ((err = snd_ctl_add(card, kctl)) < 0) 3095 goto __out; 3096 3097 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident); 3098 if (kctl == NULL) { 3099 err = -ENOMEM; 3100 goto __out; 3101 } 3102 kctl->id.index = idx; 3103 kctl->id.device = pcm_spdif_device; 3104 if ((err = snd_ctl_add(card, kctl)) < 0) 3105 goto __out; 3106 3107 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident); 3108 if (kctl == NULL) { 3109 err = -ENOMEM; 3110 goto __out; 3111 } 3112 kctl->id.index = idx; 3113 kctl->id.device = pcm_spdif_device; 3114 if ((err = snd_ctl_add(card, kctl)) < 0) 3115 goto __out; 3116 trident->spdif_pcm_ctl = kctl; 3117 } 3118 3119 err = 0; 3120 goto __out; 3121 3122 __nomem: 3123 err = -ENOMEM; 3124 3125 __out: 3126 kfree(uctl); 3127 3128 return err; 3129 } 3130 3131 /* 3132 * gameport interface 3133 */ 3134 3135 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE)) 3136 3137 static unsigned char snd_trident_gameport_read(struct gameport *gameport) 3138 { 3139 struct snd_trident *chip = gameport_get_port_data(gameport); 3140 3141 snd_assert(chip, return 0); 3142 return inb(TRID_REG(chip, GAMEPORT_LEGACY)); 3143 } 3144 3145 static void snd_trident_gameport_trigger(struct gameport *gameport) 3146 { 3147 struct snd_trident *chip = gameport_get_port_data(gameport); 3148 3149 snd_assert(chip, return); 3150 outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY)); 3151 } 3152 3153 static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) 3154 { 3155 struct snd_trident *chip = gameport_get_port_data(gameport); 3156 int i; 3157 3158 snd_assert(chip, return 0); 3159 3160 *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf; 3161 3162 for (i = 0; i < 4; i++) { 3163 axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2)); 3164 if (axes[i] == 0xffff) axes[i] = -1; 3165 } 3166 3167 return 0; 3168 } 3169 3170 static int snd_trident_gameport_open(struct gameport *gameport, int mode) 3171 { 3172 struct snd_trident *chip = gameport_get_port_data(gameport); 3173 3174 snd_assert(chip, return 0); 3175 3176 switch (mode) { 3177 case GAMEPORT_MODE_COOKED: 3178 outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR)); 3179 msleep(20); 3180 return 0; 3181 case GAMEPORT_MODE_RAW: 3182 outb(0, TRID_REG(chip, GAMEPORT_GCR)); 3183 return 0; 3184 default: 3185 return -1; 3186 } 3187 } 3188 3189 int __devinit snd_trident_create_gameport(struct snd_trident *chip) 3190 { 3191 struct gameport *gp; 3192 3193 chip->gameport = gp = gameport_allocate_port(); 3194 if (!gp) { 3195 printk(KERN_ERR "trident: cannot allocate memory for gameport\n"); 3196 return -ENOMEM; 3197 } 3198 3199 gameport_set_name(gp, "Trident 4DWave"); 3200 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 3201 gameport_set_dev_parent(gp, &chip->pci->dev); 3202 3203 gameport_set_port_data(gp, chip); 3204 gp->fuzz = 64; 3205 gp->read = snd_trident_gameport_read; 3206 gp->trigger = snd_trident_gameport_trigger; 3207 gp->cooked_read = snd_trident_gameport_cooked_read; 3208 gp->open = snd_trident_gameport_open; 3209 3210 gameport_register_port(gp); 3211 3212 return 0; 3213 } 3214 3215 static inline void snd_trident_free_gameport(struct snd_trident *chip) 3216 { 3217 if (chip->gameport) { 3218 gameport_unregister_port(chip->gameport); 3219 chip->gameport = NULL; 3220 } 3221 } 3222 #else 3223 int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; } 3224 static inline void snd_trident_free_gameport(struct snd_trident *chip) { } 3225 #endif /* CONFIG_GAMEPORT */ 3226 3227 /* 3228 * delay for 1 tick 3229 */ 3230 static inline void do_delay(struct snd_trident *chip) 3231 { 3232 schedule_timeout_uninterruptible(1); 3233 } 3234 3235 /* 3236 * SiS reset routine 3237 */ 3238 3239 static int snd_trident_sis_reset(struct snd_trident *trident) 3240 { 3241 unsigned long end_time; 3242 unsigned int i; 3243 int r; 3244 3245 r = trident->in_suspend ? 0 : 2; /* count of retries */ 3246 __si7018_retry: 3247 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */ 3248 udelay(100); 3249 pci_write_config_byte(trident->pci, 0x46, 0x00); 3250 udelay(100); 3251 /* disable AC97 GPIO interrupt */ 3252 outb(0x00, TRID_REG(trident, SI_AC97_GPIO)); 3253 /* initialize serial interface, force cold reset */ 3254 i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET; 3255 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3256 udelay(1000); 3257 /* remove cold reset */ 3258 i &= ~COLD_RESET; 3259 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3260 udelay(2000); 3261 /* wait, until the codec is ready */ 3262 end_time = (jiffies + (HZ * 3) / 4) + 1; 3263 do { 3264 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) 3265 goto __si7018_ok; 3266 do_delay(trident); 3267 } while (time_after_eq(end_time, jiffies)); 3268 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL))); 3269 if (r-- > 0) { 3270 end_time = jiffies + HZ; 3271 do { 3272 do_delay(trident); 3273 } while (time_after_eq(end_time, jiffies)); 3274 goto __si7018_retry; 3275 } 3276 __si7018_ok: 3277 /* wait for the second codec */ 3278 do { 3279 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0) 3280 break; 3281 do_delay(trident); 3282 } while (time_after_eq(end_time, jiffies)); 3283 /* enable 64 channel mode */ 3284 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR)); 3285 return 0; 3286 } 3287 3288 /* 3289 * /proc interface 3290 */ 3291 3292 static void snd_trident_proc_read(struct snd_info_entry *entry, 3293 struct snd_info_buffer *buffer) 3294 { 3295 struct snd_trident *trident = entry->private_data; 3296 char *s; 3297 3298 switch (trident->device) { 3299 case TRIDENT_DEVICE_ID_SI7018: 3300 s = "SiS 7018 Audio"; 3301 break; 3302 case TRIDENT_DEVICE_ID_DX: 3303 s = "Trident 4DWave PCI DX"; 3304 break; 3305 case TRIDENT_DEVICE_ID_NX: 3306 s = "Trident 4DWave PCI NX"; 3307 break; 3308 default: 3309 s = "???"; 3310 } 3311 snd_iprintf(buffer, "%s\n\n", s); 3312 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count); 3313 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta); 3314 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) 3315 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off"); 3316 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3317 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off"); 3318 if (trident->tlb.entries) { 3319 snd_iprintf(buffer,"\nVirtual Memory\n"); 3320 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size); 3321 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used); 3322 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr)); 3323 } 3324 } 3325 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) 3326 snd_iprintf(buffer,"\nWavetable Synth\n"); 3327 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->synth.max_size); 3328 snd_iprintf(buffer, "Memory Used : %d\n", trident->synth.current_size); 3329 snd_iprintf(buffer, "Memory Free : %d\n", (trident->synth.max_size-trident->synth.current_size)); 3330 #endif 3331 } 3332 3333 static void __devinit snd_trident_proc_init(struct snd_trident * trident) 3334 { 3335 struct snd_info_entry *entry; 3336 const char *s = "trident"; 3337 3338 if (trident->device == TRIDENT_DEVICE_ID_SI7018) 3339 s = "sis7018"; 3340 if (! snd_card_proc_new(trident->card, s, &entry)) 3341 snd_info_set_text_ops(entry, trident, snd_trident_proc_read); 3342 } 3343 3344 static int snd_trident_dev_free(struct snd_device *device) 3345 { 3346 struct snd_trident *trident = device->device_data; 3347 return snd_trident_free(trident); 3348 } 3349 3350 /*--------------------------------------------------------------------------- 3351 snd_trident_tlb_alloc 3352 3353 Description: Allocate and set up the TLB page table on 4D NX. 3354 Each entry has 4 bytes (physical PCI address). 3355 3356 Paramters: trident - pointer to target device class for 4DWave. 3357 3358 Returns: 0 or negative error code 3359 3360 ---------------------------------------------------------------------------*/ 3361 3362 static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) 3363 { 3364 int i; 3365 3366 /* TLB array must be aligned to 16kB !!! so we allocate 3367 32kB region and correct offset when necessary */ 3368 3369 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 3370 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) { 3371 snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n"); 3372 return -ENOMEM; 3373 } 3374 trident->tlb.entries = (unsigned int*)(((unsigned long)trident->tlb.buffer.area + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1)); 3375 trident->tlb.entries_dmaaddr = (trident->tlb.buffer.addr + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1); 3376 /* allocate shadow TLB page table (virtual addresses) */ 3377 trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); 3378 if (trident->tlb.shadow_entries == NULL) { 3379 snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n"); 3380 return -ENOMEM; 3381 } 3382 /* allocate and setup silent page and initialise TLB entries */ 3383 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 3384 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) { 3385 snd_printk(KERN_ERR "trident: unable to allocate silent page\n"); 3386 return -ENOMEM; 3387 } 3388 memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE); 3389 for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) { 3390 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1)); 3391 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area; 3392 } 3393 3394 /* use emu memory block manager code to manage tlb page allocation */ 3395 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES); 3396 if (trident->tlb.memhdr == NULL) 3397 return -ENOMEM; 3398 3399 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg); 3400 return 0; 3401 } 3402 3403 /* 3404 * initialize 4D DX chip 3405 */ 3406 3407 static void snd_trident_stop_all_voices(struct snd_trident *trident) 3408 { 3409 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A)); 3410 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B)); 3411 outl(0, TRID_REG(trident, T4D_AINTEN_A)); 3412 outl(0, TRID_REG(trident, T4D_AINTEN_B)); 3413 } 3414 3415 static int snd_trident_4d_dx_init(struct snd_trident *trident) 3416 { 3417 struct pci_dev *pci = trident->pci; 3418 unsigned long end_time; 3419 3420 /* reset the legacy configuration and whole audio/wavetable block */ 3421 pci_write_config_dword(pci, 0x40, 0); /* DDMA */ 3422 pci_write_config_byte(pci, 0x44, 0); /* ports */ 3423 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ 3424 pci_write_config_byte(pci, 0x46, 4); /* reset */ 3425 udelay(100); 3426 pci_write_config_byte(pci, 0x46, 0); /* release reset */ 3427 udelay(100); 3428 3429 /* warm reset of the AC'97 codec */ 3430 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3431 udelay(100); 3432 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3433 /* DAC on, disable SB IRQ and try to force ADC valid signal */ 3434 trident->ac97_ctrl = 0x0000004a; 3435 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); 3436 /* wait, until the codec is ready */ 3437 end_time = (jiffies + (HZ * 3) / 4) + 1; 3438 do { 3439 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0) 3440 goto __dx_ok; 3441 do_delay(trident); 3442 } while (time_after_eq(end_time, jiffies)); 3443 snd_printk(KERN_ERR "AC'97 codec ready error\n"); 3444 return -EIO; 3445 3446 __dx_ok: 3447 snd_trident_stop_all_voices(trident); 3448 3449 return 0; 3450 } 3451 3452 /* 3453 * initialize 4D NX chip 3454 */ 3455 static int snd_trident_4d_nx_init(struct snd_trident *trident) 3456 { 3457 struct pci_dev *pci = trident->pci; 3458 unsigned long end_time; 3459 3460 /* reset the legacy configuration and whole audio/wavetable block */ 3461 pci_write_config_dword(pci, 0x40, 0); /* DDMA */ 3462 pci_write_config_byte(pci, 0x44, 0); /* ports */ 3463 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ 3464 3465 pci_write_config_byte(pci, 0x46, 1); /* reset */ 3466 udelay(100); 3467 pci_write_config_byte(pci, 0x46, 0); /* release reset */ 3468 udelay(100); 3469 3470 /* warm reset of the AC'97 codec */ 3471 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3472 udelay(100); 3473 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3474 /* wait, until the codec is ready */ 3475 end_time = (jiffies + (HZ * 3) / 4) + 1; 3476 do { 3477 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0) 3478 goto __nx_ok; 3479 do_delay(trident); 3480 } while (time_after_eq(end_time, jiffies)); 3481 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT))); 3482 return -EIO; 3483 3484 __nx_ok: 3485 /* DAC on */ 3486 trident->ac97_ctrl = 0x00000002; 3487 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); 3488 /* disable SB IRQ */ 3489 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT)); 3490 3491 snd_trident_stop_all_voices(trident); 3492 3493 if (trident->tlb.entries != NULL) { 3494 unsigned int i; 3495 /* enable virtual addressing via TLB */ 3496 i = trident->tlb.entries_dmaaddr; 3497 i |= 0x00000001; 3498 outl(i, TRID_REG(trident, NX_TLBC)); 3499 } else { 3500 outl(0, TRID_REG(trident, NX_TLBC)); 3501 } 3502 /* initialize S/PDIF */ 3503 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); 3504 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 3505 3506 return 0; 3507 } 3508 3509 /* 3510 * initialize sis7018 chip 3511 */ 3512 static int snd_trident_sis_init(struct snd_trident *trident) 3513 { 3514 int err; 3515 3516 if ((err = snd_trident_sis_reset(trident)) < 0) 3517 return err; 3518 3519 snd_trident_stop_all_voices(trident); 3520 3521 /* initialize S/PDIF */ 3522 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); 3523 3524 return 0; 3525 } 3526 3527 /*--------------------------------------------------------------------------- 3528 snd_trident_create 3529 3530 Description: This routine will create the device specific class for 3531 the 4DWave card. It will also perform basic initialization. 3532 3533 Paramters: card - which card to create 3534 pci - interface to PCI bus resource info 3535 dma1ptr - playback dma buffer 3536 dma2ptr - capture dma buffer 3537 irqptr - interrupt resource info 3538 3539 Returns: 4DWave device class private data 3540 3541 ---------------------------------------------------------------------------*/ 3542 3543 int __devinit snd_trident_create(struct snd_card *card, 3544 struct pci_dev *pci, 3545 int pcm_streams, 3546 int pcm_spdif_device, 3547 int max_wavetable_size, 3548 struct snd_trident ** rtrident) 3549 { 3550 struct snd_trident *trident; 3551 int i, err; 3552 struct snd_trident_voice *voice; 3553 struct snd_trident_pcm_mixer *tmix; 3554 static struct snd_device_ops ops = { 3555 .dev_free = snd_trident_dev_free, 3556 }; 3557 3558 *rtrident = NULL; 3559 3560 /* enable PCI device */ 3561 if ((err = pci_enable_device(pci)) < 0) 3562 return err; 3563 /* check, if we can restrict PCI DMA transfers to 30 bits */ 3564 if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0 || 3565 pci_set_consistent_dma_mask(pci, DMA_30BIT_MASK) < 0) { 3566 snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n"); 3567 pci_disable_device(pci); 3568 return -ENXIO; 3569 } 3570 3571 trident = kzalloc(sizeof(*trident), GFP_KERNEL); 3572 if (trident == NULL) { 3573 pci_disable_device(pci); 3574 return -ENOMEM; 3575 } 3576 trident->device = (pci->vendor << 16) | pci->device; 3577 trident->card = card; 3578 trident->pci = pci; 3579 spin_lock_init(&trident->reg_lock); 3580 spin_lock_init(&trident->event_lock); 3581 spin_lock_init(&trident->voice_alloc); 3582 if (pcm_streams < 1) 3583 pcm_streams = 1; 3584 if (pcm_streams > 32) 3585 pcm_streams = 32; 3586 trident->ChanPCM = pcm_streams; 3587 if (max_wavetable_size < 0 ) 3588 max_wavetable_size = 0; 3589 trident->synth.max_size = max_wavetable_size * 1024; 3590 trident->irq = -1; 3591 3592 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE); 3593 pci_set_master(pci); 3594 3595 if ((err = pci_request_regions(pci, "Trident Audio")) < 0) { 3596 kfree(trident); 3597 pci_disable_device(pci); 3598 return err; 3599 } 3600 trident->port = pci_resource_start(pci, 0); 3601 3602 if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, 3603 "Trident Audio", trident)) { 3604 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 3605 snd_trident_free(trident); 3606 return -EBUSY; 3607 } 3608 trident->irq = pci->irq; 3609 3610 /* allocate 16k-aligned TLB for NX cards */ 3611 trident->tlb.entries = NULL; 3612 trident->tlb.buffer.area = NULL; 3613 if (trident->device == TRIDENT_DEVICE_ID_NX) { 3614 if ((err = snd_trident_tlb_alloc(trident)) < 0) { 3615 snd_trident_free(trident); 3616 return err; 3617 } 3618 } 3619 3620 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF; 3621 3622 /* initialize chip */ 3623 switch (trident->device) { 3624 case TRIDENT_DEVICE_ID_DX: 3625 err = snd_trident_4d_dx_init(trident); 3626 break; 3627 case TRIDENT_DEVICE_ID_NX: 3628 err = snd_trident_4d_nx_init(trident); 3629 break; 3630 case TRIDENT_DEVICE_ID_SI7018: 3631 err = snd_trident_sis_init(trident); 3632 break; 3633 default: 3634 snd_BUG(); 3635 break; 3636 } 3637 if (err < 0) { 3638 snd_trident_free(trident); 3639 return err; 3640 } 3641 3642 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) { 3643 snd_trident_free(trident); 3644 return err; 3645 } 3646 3647 if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0) 3648 return err; 3649 3650 /* initialise synth voices */ 3651 for (i = 0; i < 64; i++) { 3652 voice = &trident->synth.voices[i]; 3653 voice->number = i; 3654 voice->trident = trident; 3655 } 3656 /* initialize pcm mixer entries */ 3657 for (i = 0; i < 32; i++) { 3658 tmix = &trident->pcm_mixer[i]; 3659 tmix->vol = T4D_DEFAULT_PCM_VOL; 3660 tmix->pan = T4D_DEFAULT_PCM_PAN; 3661 tmix->rvol = T4D_DEFAULT_PCM_RVOL; 3662 tmix->cvol = T4D_DEFAULT_PCM_CVOL; 3663 } 3664 3665 snd_trident_enable_eso(trident); 3666 3667 snd_trident_proc_init(trident); 3668 snd_card_set_dev(card, &pci->dev); 3669 *rtrident = trident; 3670 return 0; 3671 } 3672 3673 /*--------------------------------------------------------------------------- 3674 snd_trident_free 3675 3676 Description: This routine will free the device specific class for 3677 the 4DWave card. 3678 3679 Paramters: trident - device specific private data for 4DWave card 3680 3681 Returns: None. 3682 3683 ---------------------------------------------------------------------------*/ 3684 3685 static int snd_trident_free(struct snd_trident *trident) 3686 { 3687 snd_trident_free_gameport(trident); 3688 snd_trident_disable_eso(trident); 3689 // Disable S/PDIF out 3690 if (trident->device == TRIDENT_DEVICE_ID_NX) 3691 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); 3692 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) { 3693 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); 3694 } 3695 if (trident->tlb.buffer.area) { 3696 outl(0, TRID_REG(trident, NX_TLBC)); 3697 if (trident->tlb.memhdr) 3698 snd_util_memhdr_free(trident->tlb.memhdr); 3699 if (trident->tlb.silent_page.area) 3700 snd_dma_free_pages(&trident->tlb.silent_page); 3701 vfree(trident->tlb.shadow_entries); 3702 snd_dma_free_pages(&trident->tlb.buffer); 3703 } 3704 if (trident->irq >= 0) 3705 free_irq(trident->irq, trident); 3706 pci_release_regions(trident->pci); 3707 pci_disable_device(trident->pci); 3708 kfree(trident); 3709 return 0; 3710 } 3711 3712 /*--------------------------------------------------------------------------- 3713 snd_trident_interrupt 3714 3715 Description: ISR for Trident 4DWave device 3716 3717 Paramters: trident - device specific private data for 4DWave card 3718 3719 Problems: It seems that Trident chips generates interrupts more than 3720 one time in special cases. The spurious interrupts are 3721 detected via sample timer (T4D_STIMER) and computing 3722 corresponding delta value. The limits are detected with 3723 the method try & fail so it is possible that it won't 3724 work on all computers. [jaroslav] 3725 3726 Returns: None. 3727 3728 ---------------------------------------------------------------------------*/ 3729 3730 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs) 3731 { 3732 struct snd_trident *trident = dev_id; 3733 unsigned int audio_int, chn_int, stimer, channel, mask, tmp; 3734 int delta; 3735 struct snd_trident_voice *voice; 3736 3737 audio_int = inl(TRID_REG(trident, T4D_MISCINT)); 3738 if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0) 3739 return IRQ_NONE; 3740 if (audio_int & ADDRESS_IRQ) { 3741 // get interrupt status for all channels 3742 spin_lock(&trident->reg_lock); 3743 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; 3744 chn_int = inl(TRID_REG(trident, T4D_AINT_A)); 3745 if (chn_int == 0) 3746 goto __skip1; 3747 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */ 3748 __skip1: 3749 chn_int = inl(TRID_REG(trident, T4D_AINT_B)); 3750 if (chn_int == 0) 3751 goto __skip2; 3752 for (channel = 63; channel >= 32; channel--) { 3753 mask = 1 << (channel&0x1f); 3754 if ((chn_int & mask) == 0) 3755 continue; 3756 voice = &trident->synth.voices[channel]; 3757 if (!voice->pcm || voice->substream == NULL) { 3758 outl(mask, TRID_REG(trident, T4D_STOP_B)); 3759 continue; 3760 } 3761 delta = (int)stimer - (int)voice->stimer; 3762 if (delta < 0) 3763 delta = -delta; 3764 if ((unsigned int)delta < voice->spurious_threshold) { 3765 /* do some statistics here */ 3766 trident->spurious_irq_count++; 3767 if (trident->spurious_irq_max_delta < (unsigned int)delta) 3768 trident->spurious_irq_max_delta = delta; 3769 continue; 3770 } 3771 voice->stimer = stimer; 3772 if (voice->isync) { 3773 if (!voice->isync3) { 3774 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL)); 3775 if (trident->bDMAStart & 0x40) 3776 tmp >>= 1; 3777 if (tmp > 0) 3778 tmp = voice->isync_max - tmp; 3779 } else { 3780 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff; 3781 } 3782 if (tmp < voice->isync_mark) { 3783 if (tmp > 0x10) 3784 tmp = voice->isync_ESO - 7; 3785 else 3786 tmp = voice->isync_ESO + 2; 3787 /* update ESO for IRQ voice to preserve sync */ 3788 snd_trident_stop_voice(trident, voice->number); 3789 snd_trident_write_eso_reg(trident, voice, tmp); 3790 snd_trident_start_voice(trident, voice->number); 3791 } 3792 } else if (voice->isync2) { 3793 voice->isync2 = 0; 3794 /* write original ESO and update CSO for IRQ voice to preserve sync */ 3795 snd_trident_stop_voice(trident, voice->number); 3796 snd_trident_write_cso_reg(trident, voice, voice->isync_mark); 3797 snd_trident_write_eso_reg(trident, voice, voice->ESO); 3798 snd_trident_start_voice(trident, voice->number); 3799 } 3800 #if 0 3801 if (voice->extra) { 3802 /* update CSO for extra voice to preserve sync */ 3803 snd_trident_stop_voice(trident, voice->extra->number); 3804 snd_trident_write_cso_reg(trident, voice->extra, 0); 3805 snd_trident_start_voice(trident, voice->extra->number); 3806 } 3807 #endif 3808 spin_unlock(&trident->reg_lock); 3809 snd_pcm_period_elapsed(voice->substream); 3810 spin_lock(&trident->reg_lock); 3811 } 3812 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */ 3813 __skip2: 3814 spin_unlock(&trident->reg_lock); 3815 } 3816 if (audio_int & MPU401_IRQ) { 3817 if (trident->rmidi) { 3818 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data, regs); 3819 } else { 3820 inb(TRID_REG(trident, T4D_MPUR0)); 3821 } 3822 } 3823 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT)); 3824 return IRQ_HANDLED; 3825 } 3826 3827 /*--------------------------------------------------------------------------- 3828 snd_trident_attach_synthesizer 3829 3830 Description: Attach synthesizer hooks 3831 3832 Paramters: trident - device specific private data for 4DWave card 3833 3834 Returns: None. 3835 3836 ---------------------------------------------------------------------------*/ 3837 int snd_trident_attach_synthesizer(struct snd_trident *trident) 3838 { 3839 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) 3840 if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT, 3841 sizeof(struct snd_trident *), &trident->seq_dev) >= 0) { 3842 strcpy(trident->seq_dev->name, "4DWave"); 3843 *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident; 3844 } 3845 #endif 3846 return 0; 3847 } 3848 3849 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port) 3850 { 3851 struct snd_trident_voice *pvoice; 3852 unsigned long flags; 3853 int idx; 3854 3855 spin_lock_irqsave(&trident->voice_alloc, flags); 3856 if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) { 3857 idx = snd_trident_allocate_pcm_channel(trident); 3858 if(idx < 0) { 3859 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3860 return NULL; 3861 } 3862 pvoice = &trident->synth.voices[idx]; 3863 pvoice->use = 1; 3864 pvoice->pcm = 1; 3865 pvoice->capture = 0; 3866 pvoice->spdif = 0; 3867 pvoice->memblk = NULL; 3868 pvoice->substream = NULL; 3869 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3870 return pvoice; 3871 } 3872 if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) { 3873 idx = snd_trident_allocate_synth_channel(trident); 3874 if(idx < 0) { 3875 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3876 return NULL; 3877 } 3878 pvoice = &trident->synth.voices[idx]; 3879 pvoice->use = 1; 3880 pvoice->synth = 1; 3881 pvoice->client = client; 3882 pvoice->port = port; 3883 pvoice->memblk = NULL; 3884 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3885 return pvoice; 3886 } 3887 if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) { 3888 } 3889 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3890 return NULL; 3891 } 3892 3893 EXPORT_SYMBOL(snd_trident_alloc_voice); 3894 3895 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice) 3896 { 3897 unsigned long flags; 3898 void (*private_free)(struct snd_trident_voice *); 3899 void *private_data; 3900 3901 if (voice == NULL || !voice->use) 3902 return; 3903 snd_trident_clear_voices(trident, voice->number, voice->number); 3904 spin_lock_irqsave(&trident->voice_alloc, flags); 3905 private_free = voice->private_free; 3906 private_data = voice->private_data; 3907 voice->private_free = NULL; 3908 voice->private_data = NULL; 3909 if (voice->pcm) 3910 snd_trident_free_pcm_channel(trident, voice->number); 3911 if (voice->synth) 3912 snd_trident_free_synth_channel(trident, voice->number); 3913 voice->use = voice->pcm = voice->synth = voice->midi = 0; 3914 voice->capture = voice->spdif = 0; 3915 voice->sample_ops = NULL; 3916 voice->substream = NULL; 3917 voice->extra = NULL; 3918 spin_unlock_irqrestore(&trident->voice_alloc, flags); 3919 if (private_free) 3920 private_free(voice); 3921 } 3922 3923 EXPORT_SYMBOL(snd_trident_free_voice); 3924 3925 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max) 3926 { 3927 unsigned int i, val, mask[2] = { 0, 0 }; 3928 3929 snd_assert(v_min <= 63, return); 3930 snd_assert(v_max <= 63, return); 3931 for (i = v_min; i <= v_max; i++) 3932 mask[i >> 5] |= 1 << (i & 0x1f); 3933 if (mask[0]) { 3934 outl(mask[0], TRID_REG(trident, T4D_STOP_A)); 3935 val = inl(TRID_REG(trident, T4D_AINTEN_A)); 3936 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A)); 3937 } 3938 if (mask[1]) { 3939 outl(mask[1], TRID_REG(trident, T4D_STOP_B)); 3940 val = inl(TRID_REG(trident, T4D_AINTEN_B)); 3941 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B)); 3942 } 3943 } 3944 3945 #ifdef CONFIG_PM 3946 int snd_trident_suspend(struct pci_dev *pci, pm_message_t state) 3947 { 3948 struct snd_card *card = pci_get_drvdata(pci); 3949 struct snd_trident *trident = card->private_data; 3950 3951 trident->in_suspend = 1; 3952 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 3953 snd_pcm_suspend_all(trident->pcm); 3954 snd_pcm_suspend_all(trident->foldback); 3955 snd_pcm_suspend_all(trident->spdif); 3956 3957 snd_ac97_suspend(trident->ac97); 3958 snd_ac97_suspend(trident->ac97_sec); 3959 3960 switch (trident->device) { 3961 case TRIDENT_DEVICE_ID_DX: 3962 case TRIDENT_DEVICE_ID_NX: 3963 break; /* TODO */ 3964 case TRIDENT_DEVICE_ID_SI7018: 3965 break; 3966 } 3967 pci_disable_device(pci); 3968 pci_save_state(pci); 3969 return 0; 3970 } 3971 3972 int snd_trident_resume(struct pci_dev *pci) 3973 { 3974 struct snd_card *card = pci_get_drvdata(pci); 3975 struct snd_trident *trident = card->private_data; 3976 3977 pci_restore_state(pci); 3978 pci_enable_device(pci); 3979 pci_set_master(pci); /* to be sure */ 3980 3981 switch (trident->device) { 3982 case TRIDENT_DEVICE_ID_DX: 3983 snd_trident_4d_dx_init(trident); 3984 break; 3985 case TRIDENT_DEVICE_ID_NX: 3986 snd_trident_4d_nx_init(trident); 3987 break; 3988 case TRIDENT_DEVICE_ID_SI7018: 3989 snd_trident_sis_init(trident); 3990 break; 3991 } 3992 3993 snd_ac97_resume(trident->ac97); 3994 snd_ac97_resume(trident->ac97_sec); 3995 3996 /* restore some registers */ 3997 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); 3998 3999 snd_trident_enable_eso(trident); 4000 4001 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 4002 trident->in_suspend = 0; 4003 return 0; 4004 } 4005 #endif /* CONFIG_PM */ 4006