1/* 2 * Driver for S3 SonicVibes soundcard 3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 4 * 5 * BUGS: 6 * It looks like 86c617 rev 3 doesn't supports DDMA buffers above 16MB? 7 * Driver sometimes hangs... Nobody knows why at this moment... 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24 25#include <linux/delay.h> 26#include <linux/init.h> 27#include <linux/interrupt.h> 28#include <linux/pci.h> 29#include <linux/slab.h> 30#include <linux/gameport.h> 31#include <linux/moduleparam.h> 32#include <linux/dma-mapping.h> 33 34#include <sound/core.h> 35#include <sound/pcm.h> 36#include <sound/info.h> 37#include <sound/control.h> 38#include <sound/mpu401.h> 39#include <sound/opl3.h> 40#include <sound/initval.h> 41 42#include <asm/io.h> 43 44MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 45MODULE_DESCRIPTION("S3 SonicVibes PCI"); 46MODULE_LICENSE("GPL"); 47MODULE_SUPPORTED_DEVICE("{{S3,SonicVibes PCI}}"); 48 49#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE)) 50#define SUPPORT_JOYSTICK 1 51#endif 52 53static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 54static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 55static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 56static int reverb[SNDRV_CARDS]; 57static int mge[SNDRV_CARDS]; 58static unsigned int dmaio = 0x7a00; /* DDMA i/o address */ 59 60module_param_array(index, int, NULL, 0444); 61MODULE_PARM_DESC(index, "Index value for S3 SonicVibes soundcard."); 62module_param_array(id, charp, NULL, 0444); 63MODULE_PARM_DESC(id, "ID string for S3 SonicVibes soundcard."); 64module_param_array(enable, bool, NULL, 0444); 65MODULE_PARM_DESC(enable, "Enable S3 SonicVibes soundcard."); 66module_param_array(reverb, bool, NULL, 0444); 67MODULE_PARM_DESC(reverb, "Enable reverb (SRAM is present) for S3 SonicVibes soundcard."); 68module_param_array(mge, bool, NULL, 0444); 69MODULE_PARM_DESC(mge, "MIC Gain Enable for S3 SonicVibes soundcard."); 70module_param(dmaio, uint, 0444); 71MODULE_PARM_DESC(dmaio, "DDMA i/o base address for S3 SonicVibes soundcard."); 72 73/* 74 * Enhanced port direct registers 75 */ 76 77#define SV_REG(sonic, x) ((sonic)->enh_port + SV_REG_##x) 78 79#define SV_REG_CONTROL 0x00 /* R/W: CODEC/Mixer control register */ 80#define SV_ENHANCED 0x01 /* audio mode select - enhanced mode */ 81#define SV_TEST 0x02 /* test bit */ 82#define SV_REVERB 0x04 /* reverb enable */ 83#define SV_WAVETABLE 0x08 /* wavetable active / FM active if not set */ 84#define SV_INTA 0x20 /* INTA driving - should be always 1 */ 85#define SV_RESET 0x80 /* reset chip */ 86#define SV_REG_IRQMASK 0x01 /* R/W: CODEC/Mixer interrupt mask register */ 87#define SV_DMAA_MASK 0x01 /* mask DMA-A interrupt */ 88#define SV_DMAC_MASK 0x04 /* mask DMA-C interrupt */ 89#define SV_SPEC_MASK 0x08 /* special interrupt mask - should be always masked */ 90#define SV_UD_MASK 0x40 /* Up/Down button interrupt mask */ 91#define SV_MIDI_MASK 0x80 /* mask MIDI interrupt */ 92#define SV_REG_STATUS 0x02 /* R/O: CODEC/Mixer status register */ 93#define SV_DMAA_IRQ 0x01 /* DMA-A interrupt */ 94#define SV_DMAC_IRQ 0x04 /* DMA-C interrupt */ 95#define SV_SPEC_IRQ 0x08 /* special interrupt */ 96#define SV_UD_IRQ 0x40 /* Up/Down interrupt */ 97#define SV_MIDI_IRQ 0x80 /* MIDI interrupt */ 98#define SV_REG_INDEX 0x04 /* R/W: CODEC/Mixer index address register */ 99#define SV_MCE 0x40 /* mode change enable */ 100#define SV_TRD 0x80 /* DMA transfer request disabled */ 101#define SV_REG_DATA 0x05 /* R/W: CODEC/Mixer index data register */ 102 103/* 104 * Enhanced port indirect registers 105 */ 106 107#define SV_IREG_LEFT_ADC 0x00 /* Left ADC Input Control */ 108#define SV_IREG_RIGHT_ADC 0x01 /* Right ADC Input Control */ 109#define SV_IREG_LEFT_AUX1 0x02 /* Left AUX1 Input Control */ 110#define SV_IREG_RIGHT_AUX1 0x03 /* Right AUX1 Input Control */ 111#define SV_IREG_LEFT_CD 0x04 /* Left CD Input Control */ 112#define SV_IREG_RIGHT_CD 0x05 /* Right CD Input Control */ 113#define SV_IREG_LEFT_LINE 0x06 /* Left Line Input Control */ 114#define SV_IREG_RIGHT_LINE 0x07 /* Right Line Input Control */ 115#define SV_IREG_MIC 0x08 /* MIC Input Control */ 116#define SV_IREG_GAME_PORT 0x09 /* Game Port Control */ 117#define SV_IREG_LEFT_SYNTH 0x0a /* Left Synth Input Control */ 118#define SV_IREG_RIGHT_SYNTH 0x0b /* Right Synth Input Control */ 119#define SV_IREG_LEFT_AUX2 0x0c /* Left AUX2 Input Control */ 120#define SV_IREG_RIGHT_AUX2 0x0d /* Right AUX2 Input Control */ 121#define SV_IREG_LEFT_ANALOG 0x0e /* Left Analog Mixer Output Control */ 122#define SV_IREG_RIGHT_ANALOG 0x0f /* Right Analog Mixer Output Control */ 123#define SV_IREG_LEFT_PCM 0x10 /* Left PCM Input Control */ 124#define SV_IREG_RIGHT_PCM 0x11 /* Right PCM Input Control */ 125#define SV_IREG_DMA_DATA_FMT 0x12 /* DMA Data Format */ 126#define SV_IREG_PC_ENABLE 0x13 /* Playback/Capture Enable Register */ 127#define SV_IREG_UD_BUTTON 0x14 /* Up/Down Button Register */ 128#define SV_IREG_REVISION 0x15 /* Revision */ 129#define SV_IREG_ADC_OUTPUT_CTRL 0x16 /* ADC Output Control */ 130#define SV_IREG_DMA_A_UPPER 0x18 /* DMA A Upper Base Count */ 131#define SV_IREG_DMA_A_LOWER 0x19 /* DMA A Lower Base Count */ 132#define SV_IREG_DMA_C_UPPER 0x1c /* DMA C Upper Base Count */ 133#define SV_IREG_DMA_C_LOWER 0x1d /* DMA C Lower Base Count */ 134#define SV_IREG_PCM_RATE_LOW 0x1e /* PCM Sampling Rate Low Byte */ 135#define SV_IREG_PCM_RATE_HIGH 0x1f /* PCM Sampling Rate High Byte */ 136#define SV_IREG_SYNTH_RATE_LOW 0x20 /* Synthesizer Sampling Rate Low Byte */ 137#define SV_IREG_SYNTH_RATE_HIGH 0x21 /* Synthesizer Sampling Rate High Byte */ 138#define SV_IREG_ADC_CLOCK 0x22 /* ADC Clock Source Selection */ 139#define SV_IREG_ADC_ALT_RATE 0x23 /* ADC Alternative Sampling Rate Selection */ 140#define SV_IREG_ADC_PLL_M 0x24 /* ADC PLL M Register */ 141#define SV_IREG_ADC_PLL_N 0x25 /* ADC PLL N Register */ 142#define SV_IREG_SYNTH_PLL_M 0x26 /* Synthesizer PLL M Register */ 143#define SV_IREG_SYNTH_PLL_N 0x27 /* Synthesizer PLL N Register */ 144#define SV_IREG_MPU401 0x2a /* MPU-401 UART Operation */ 145#define SV_IREG_DRIVE_CTRL 0x2b /* Drive Control */ 146#define SV_IREG_SRS_SPACE 0x2c /* SRS Space Control */ 147#define SV_IREG_SRS_CENTER 0x2d /* SRS Center Control */ 148#define SV_IREG_WAVE_SOURCE 0x2e /* Wavetable Sample Source Select */ 149#define SV_IREG_ANALOG_POWER 0x30 /* Analog Power Down Control */ 150#define SV_IREG_DIGITAL_POWER 0x31 /* Digital Power Down Control */ 151 152#define SV_IREG_ADC_PLL SV_IREG_ADC_PLL_M 153#define SV_IREG_SYNTH_PLL SV_IREG_SYNTH_PLL_M 154 155/* 156 * DMA registers 157 */ 158 159#define SV_DMA_ADDR0 0x00 160#define SV_DMA_ADDR1 0x01 161#define SV_DMA_ADDR2 0x02 162#define SV_DMA_ADDR3 0x03 163#define SV_DMA_COUNT0 0x04 164#define SV_DMA_COUNT1 0x05 165#define SV_DMA_COUNT2 0x06 166#define SV_DMA_MODE 0x0b 167#define SV_DMA_RESET 0x0d 168#define SV_DMA_MASK 0x0f 169 170/* 171 * Record sources 172 */ 173 174#define SV_RECSRC_RESERVED (0x00<<5) 175#define SV_RECSRC_CD (0x01<<5) 176#define SV_RECSRC_DAC (0x02<<5) 177#define SV_RECSRC_AUX2 (0x03<<5) 178#define SV_RECSRC_LINE (0x04<<5) 179#define SV_RECSRC_AUX1 (0x05<<5) 180#define SV_RECSRC_MIC (0x06<<5) 181#define SV_RECSRC_OUT (0x07<<5) 182 183/* 184 * constants 185 */ 186 187#define SV_FULLRATE 48000 188#define SV_REFFREQUENCY 24576000 189#define SV_ADCMULT 512 190 191#define SV_MODE_PLAY 1 192#define SV_MODE_CAPTURE 2 193 194/* 195 196 */ 197 198struct sonicvibes { 199 unsigned long dma1size; 200 unsigned long dma2size; 201 int irq; 202 203 unsigned long sb_port; 204 unsigned long enh_port; 205 unsigned long synth_port; 206 unsigned long midi_port; 207 unsigned long game_port; 208 unsigned int dmaa_port; 209 struct resource *res_dmaa; 210 unsigned int dmac_port; 211 struct resource *res_dmac; 212 213 unsigned char enable; 214 unsigned char irqmask; 215 unsigned char revision; 216 unsigned char format; 217 unsigned char srs_space; 218 unsigned char srs_center; 219 unsigned char mpu_switch; 220 unsigned char wave_source; 221 222 unsigned int mode; 223 224 struct pci_dev *pci; 225 struct snd_card *card; 226 struct snd_pcm *pcm; 227 struct snd_pcm_substream *playback_substream; 228 struct snd_pcm_substream *capture_substream; 229 struct snd_rawmidi *rmidi; 230 struct snd_hwdep *fmsynth; /* S3FM */ 231 232 spinlock_t reg_lock; 233 234 unsigned int p_dma_size; 235 unsigned int c_dma_size; 236 237 struct snd_kcontrol *master_mute; 238 struct snd_kcontrol *master_volume; 239 240#ifdef SUPPORT_JOYSTICK 241 struct gameport *gameport; 242#endif 243}; 244 245static DEFINE_PCI_DEVICE_TABLE(snd_sonic_ids) = { 246 { PCI_VDEVICE(S3, 0xca00), 0, }, 247 { 0, } 248}; 249 250MODULE_DEVICE_TABLE(pci, snd_sonic_ids); 251 252static struct snd_ratden sonicvibes_adc_clock = { 253 .num_min = 4000 * 65536, 254 .num_max = 48000UL * 65536, 255 .num_step = 1, 256 .den = 65536, 257}; 258static struct snd_pcm_hw_constraint_ratdens snd_sonicvibes_hw_constraints_adc_clock = { 259 .nrats = 1, 260 .rats = &sonicvibes_adc_clock, 261}; 262 263/* 264 * common I/O routines 265 */ 266 267static inline void snd_sonicvibes_setdmaa(struct sonicvibes * sonic, 268 unsigned int addr, 269 unsigned int count) 270{ 271 count--; 272 outl(addr, sonic->dmaa_port + SV_DMA_ADDR0); 273 outl(count, sonic->dmaa_port + SV_DMA_COUNT0); 274 outb(0x18, sonic->dmaa_port + SV_DMA_MODE); 275} 276 277static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic, 278 unsigned int addr, 279 unsigned int count) 280{ 281 /* note: dmac is working in word mode!!! */ 282 count >>= 1; 283 count--; 284 outl(addr, sonic->dmac_port + SV_DMA_ADDR0); 285 outl(count, sonic->dmac_port + SV_DMA_COUNT0); 286 outb(0x14, sonic->dmac_port + SV_DMA_MODE); 287} 288 289static inline unsigned int snd_sonicvibes_getdmaa(struct sonicvibes * sonic) 290{ 291 return (inl(sonic->dmaa_port + SV_DMA_COUNT0) & 0xffffff) + 1; 292} 293 294static inline unsigned int snd_sonicvibes_getdmac(struct sonicvibes * sonic) 295{ 296 /* note: dmac is working in word mode!!! */ 297 return ((inl(sonic->dmac_port + SV_DMA_COUNT0) & 0xffffff) + 1) << 1; 298} 299 300static void snd_sonicvibes_out1(struct sonicvibes * sonic, 301 unsigned char reg, 302 unsigned char value) 303{ 304 outb(reg, SV_REG(sonic, INDEX)); 305 udelay(10); 306 outb(value, SV_REG(sonic, DATA)); 307 udelay(10); 308} 309 310static void snd_sonicvibes_out(struct sonicvibes * sonic, 311 unsigned char reg, 312 unsigned char value) 313{ 314 unsigned long flags; 315 316 spin_lock_irqsave(&sonic->reg_lock, flags); 317 outb(reg, SV_REG(sonic, INDEX)); 318 udelay(10); 319 outb(value, SV_REG(sonic, DATA)); 320 udelay(10); 321 spin_unlock_irqrestore(&sonic->reg_lock, flags); 322} 323 324static unsigned char snd_sonicvibes_in1(struct sonicvibes * sonic, unsigned char reg) 325{ 326 unsigned char value; 327 328 outb(reg, SV_REG(sonic, INDEX)); 329 udelay(10); 330 value = inb(SV_REG(sonic, DATA)); 331 udelay(10); 332 return value; 333} 334 335static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char reg) 336{ 337 unsigned long flags; 338 unsigned char value; 339 340 spin_lock_irqsave(&sonic->reg_lock, flags); 341 outb(reg, SV_REG(sonic, INDEX)); 342 udelay(10); 343 value = inb(SV_REG(sonic, DATA)); 344 udelay(10); 345 spin_unlock_irqrestore(&sonic->reg_lock, flags); 346 return value; 347} 348 349 350static void snd_sonicvibes_setfmt(struct sonicvibes * sonic, 351 unsigned char mask, 352 unsigned char value) 353{ 354 unsigned long flags; 355 356 spin_lock_irqsave(&sonic->reg_lock, flags); 357 outb(SV_MCE | SV_IREG_DMA_DATA_FMT, SV_REG(sonic, INDEX)); 358 if (mask) { 359 sonic->format = inb(SV_REG(sonic, DATA)); 360 udelay(10); 361 } 362 sonic->format = (sonic->format & mask) | value; 363 outb(sonic->format, SV_REG(sonic, DATA)); 364 udelay(10); 365 outb(0, SV_REG(sonic, INDEX)); 366 udelay(10); 367 spin_unlock_irqrestore(&sonic->reg_lock, flags); 368} 369 370static void snd_sonicvibes_pll(unsigned int rate, 371 unsigned int *res_r, 372 unsigned int *res_m, 373 unsigned int *res_n) 374{ 375 unsigned int r, m = 0, n = 0; 376 unsigned int xm, xn, xr, xd, metric = ~0U; 377 378 if (rate < 625000 / SV_ADCMULT) 379 rate = 625000 / SV_ADCMULT; 380 if (rate > 150000000 / SV_ADCMULT) 381 rate = 150000000 / SV_ADCMULT; 382 /* slight violation of specs, needed for continuous sampling rates */ 383 for (r = 0; rate < 75000000 / SV_ADCMULT; r += 0x20, rate <<= 1); 384 for (xn = 3; xn < 33; xn++) /* 35 */ 385 for (xm = 3; xm < 257; xm++) { 386 xr = ((SV_REFFREQUENCY / SV_ADCMULT) * xm) / xn; 387 if (xr >= rate) 388 xd = xr - rate; 389 else 390 xd = rate - xr; 391 if (xd < metric) { 392 metric = xd; 393 m = xm - 2; 394 n = xn - 2; 395 } 396 } 397 *res_r = r; 398 *res_m = m; 399 *res_n = n; 400} 401 402static void snd_sonicvibes_setpll(struct sonicvibes * sonic, 403 unsigned char reg, 404 unsigned int rate) 405{ 406 unsigned long flags; 407 unsigned int r, m, n; 408 409 snd_sonicvibes_pll(rate, &r, &m, &n); 410 if (sonic != NULL) { 411 spin_lock_irqsave(&sonic->reg_lock, flags); 412 snd_sonicvibes_out1(sonic, reg, m); 413 snd_sonicvibes_out1(sonic, reg + 1, r | n); 414 spin_unlock_irqrestore(&sonic->reg_lock, flags); 415 } 416} 417 418static void snd_sonicvibes_set_adc_rate(struct sonicvibes * sonic, unsigned int rate) 419{ 420 unsigned long flags; 421 unsigned int div; 422 unsigned char clock; 423 424 div = 48000 / rate; 425 if (div > 8) 426 div = 8; 427 if ((48000 / div) == rate) { /* use the alternate clock */ 428 clock = 0x10; 429 } else { /* use the PLL source */ 430 clock = 0x00; 431 snd_sonicvibes_setpll(sonic, SV_IREG_ADC_PLL, rate); 432 } 433 spin_lock_irqsave(&sonic->reg_lock, flags); 434 snd_sonicvibes_out1(sonic, SV_IREG_ADC_ALT_RATE, (div - 1) << 4); 435 snd_sonicvibes_out1(sonic, SV_IREG_ADC_CLOCK, clock); 436 spin_unlock_irqrestore(&sonic->reg_lock, flags); 437} 438 439static int snd_sonicvibes_hw_constraint_dac_rate(struct snd_pcm_hw_params *params, 440 struct snd_pcm_hw_rule *rule) 441{ 442 unsigned int rate, div, r, m, n; 443 444 if (hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min == 445 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max) { 446 rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min; 447 div = 48000 / rate; 448 if (div > 8) 449 div = 8; 450 if ((48000 / div) == rate) { 451 params->rate_num = rate; 452 params->rate_den = 1; 453 } else { 454 snd_sonicvibes_pll(rate, &r, &m, &n); 455 snd_BUG_ON(SV_REFFREQUENCY % 16); 456 snd_BUG_ON(SV_ADCMULT % 512); 457 params->rate_num = (SV_REFFREQUENCY/16) * (n+2) * r; 458 params->rate_den = (SV_ADCMULT/512) * (m+2); 459 } 460 } 461 return 0; 462} 463 464static void snd_sonicvibes_set_dac_rate(struct sonicvibes * sonic, unsigned int rate) 465{ 466 unsigned int div; 467 unsigned long flags; 468 469 div = (rate * 65536 + SV_FULLRATE / 2) / SV_FULLRATE; 470 if (div > 65535) 471 div = 65535; 472 spin_lock_irqsave(&sonic->reg_lock, flags); 473 snd_sonicvibes_out1(sonic, SV_IREG_PCM_RATE_HIGH, div >> 8); 474 snd_sonicvibes_out1(sonic, SV_IREG_PCM_RATE_LOW, div); 475 spin_unlock_irqrestore(&sonic->reg_lock, flags); 476} 477 478static int snd_sonicvibes_trigger(struct sonicvibes * sonic, int what, int cmd) 479{ 480 int result = 0; 481 482 spin_lock(&sonic->reg_lock); 483 if (cmd == SNDRV_PCM_TRIGGER_START) { 484 if (!(sonic->enable & what)) { 485 sonic->enable |= what; 486 snd_sonicvibes_out1(sonic, SV_IREG_PC_ENABLE, sonic->enable); 487 } 488 } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { 489 if (sonic->enable & what) { 490 sonic->enable &= ~what; 491 snd_sonicvibes_out1(sonic, SV_IREG_PC_ENABLE, sonic->enable); 492 } 493 } else { 494 result = -EINVAL; 495 } 496 spin_unlock(&sonic->reg_lock); 497 return result; 498} 499 500static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id) 501{ 502 struct sonicvibes *sonic = dev_id; 503 unsigned char status; 504 505 status = inb(SV_REG(sonic, STATUS)); 506 if (!(status & (SV_DMAA_IRQ | SV_DMAC_IRQ | SV_MIDI_IRQ))) 507 return IRQ_NONE; 508 if (status == 0xff) { /* failure */ 509 outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK)); 510 snd_printk(KERN_ERR "IRQ failure - interrupts disabled!!\n"); 511 return IRQ_HANDLED; 512 } 513 if (sonic->pcm) { 514 if (status & SV_DMAA_IRQ) 515 snd_pcm_period_elapsed(sonic->playback_substream); 516 if (status & SV_DMAC_IRQ) 517 snd_pcm_period_elapsed(sonic->capture_substream); 518 } 519 if (sonic->rmidi) { 520 if (status & SV_MIDI_IRQ) 521 snd_mpu401_uart_interrupt(irq, sonic->rmidi->private_data); 522 } 523 if (status & SV_UD_IRQ) { 524 unsigned char udreg; 525 int vol, oleft, oright, mleft, mright; 526 527 spin_lock(&sonic->reg_lock); 528 udreg = snd_sonicvibes_in1(sonic, SV_IREG_UD_BUTTON); 529 vol = udreg & 0x3f; 530 if (!(udreg & 0x40)) 531 vol = -vol; 532 oleft = mleft = snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ANALOG); 533 oright = mright = snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ANALOG); 534 oleft &= 0x1f; 535 oright &= 0x1f; 536 oleft += vol; 537 if (oleft < 0) 538 oleft = 0; 539 if (oleft > 0x1f) 540 oleft = 0x1f; 541 oright += vol; 542 if (oright < 0) 543 oright = 0; 544 if (oright > 0x1f) 545 oright = 0x1f; 546 if (udreg & 0x80) { 547 mleft ^= 0x80; 548 mright ^= 0x80; 549 } 550 oleft |= mleft & 0x80; 551 oright |= mright & 0x80; 552 snd_sonicvibes_out1(sonic, SV_IREG_LEFT_ANALOG, oleft); 553 snd_sonicvibes_out1(sonic, SV_IREG_RIGHT_ANALOG, oright); 554 spin_unlock(&sonic->reg_lock); 555 snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_mute->id); 556 snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_volume->id); 557 } 558 return IRQ_HANDLED; 559} 560 561/* 562 * PCM part 563 */ 564 565static int snd_sonicvibes_playback_trigger(struct snd_pcm_substream *substream, 566 int cmd) 567{ 568 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 569 return snd_sonicvibes_trigger(sonic, 1, cmd); 570} 571 572static int snd_sonicvibes_capture_trigger(struct snd_pcm_substream *substream, 573 int cmd) 574{ 575 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 576 return snd_sonicvibes_trigger(sonic, 2, cmd); 577} 578 579static int snd_sonicvibes_hw_params(struct snd_pcm_substream *substream, 580 struct snd_pcm_hw_params *hw_params) 581{ 582 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); 583} 584 585static int snd_sonicvibes_hw_free(struct snd_pcm_substream *substream) 586{ 587 return snd_pcm_lib_free_pages(substream); 588} 589 590static int snd_sonicvibes_playback_prepare(struct snd_pcm_substream *substream) 591{ 592 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 593 struct snd_pcm_runtime *runtime = substream->runtime; 594 unsigned char fmt = 0; 595 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 596 unsigned int count = snd_pcm_lib_period_bytes(substream); 597 598 sonic->p_dma_size = size; 599 count--; 600 if (runtime->channels > 1) 601 fmt |= 1; 602 if (snd_pcm_format_width(runtime->format) == 16) 603 fmt |= 2; 604 snd_sonicvibes_setfmt(sonic, ~3, fmt); 605 snd_sonicvibes_set_dac_rate(sonic, runtime->rate); 606 spin_lock_irq(&sonic->reg_lock); 607 snd_sonicvibes_setdmaa(sonic, runtime->dma_addr, size); 608 snd_sonicvibes_out1(sonic, SV_IREG_DMA_A_UPPER, count >> 8); 609 snd_sonicvibes_out1(sonic, SV_IREG_DMA_A_LOWER, count); 610 spin_unlock_irq(&sonic->reg_lock); 611 return 0; 612} 613 614static int snd_sonicvibes_capture_prepare(struct snd_pcm_substream *substream) 615{ 616 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 617 struct snd_pcm_runtime *runtime = substream->runtime; 618 unsigned char fmt = 0; 619 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 620 unsigned int count = snd_pcm_lib_period_bytes(substream); 621 622 sonic->c_dma_size = size; 623 count >>= 1; 624 count--; 625 if (runtime->channels > 1) 626 fmt |= 0x10; 627 if (snd_pcm_format_width(runtime->format) == 16) 628 fmt |= 0x20; 629 snd_sonicvibes_setfmt(sonic, ~0x30, fmt); 630 snd_sonicvibes_set_adc_rate(sonic, runtime->rate); 631 spin_lock_irq(&sonic->reg_lock); 632 snd_sonicvibes_setdmac(sonic, runtime->dma_addr, size); 633 snd_sonicvibes_out1(sonic, SV_IREG_DMA_C_UPPER, count >> 8); 634 snd_sonicvibes_out1(sonic, SV_IREG_DMA_C_LOWER, count); 635 spin_unlock_irq(&sonic->reg_lock); 636 return 0; 637} 638 639static snd_pcm_uframes_t snd_sonicvibes_playback_pointer(struct snd_pcm_substream *substream) 640{ 641 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 642 size_t ptr; 643 644 if (!(sonic->enable & 1)) 645 return 0; 646 ptr = sonic->p_dma_size - snd_sonicvibes_getdmaa(sonic); 647 return bytes_to_frames(substream->runtime, ptr); 648} 649 650static snd_pcm_uframes_t snd_sonicvibes_capture_pointer(struct snd_pcm_substream *substream) 651{ 652 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 653 size_t ptr; 654 if (!(sonic->enable & 2)) 655 return 0; 656 ptr = sonic->c_dma_size - snd_sonicvibes_getdmac(sonic); 657 return bytes_to_frames(substream->runtime, ptr); 658} 659 660static struct snd_pcm_hardware snd_sonicvibes_playback = 661{ 662 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 663 SNDRV_PCM_INFO_BLOCK_TRANSFER | 664 SNDRV_PCM_INFO_MMAP_VALID), 665 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, 666 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 667 .rate_min = 4000, 668 .rate_max = 48000, 669 .channels_min = 1, 670 .channels_max = 2, 671 .buffer_bytes_max = (128*1024), 672 .period_bytes_min = 32, 673 .period_bytes_max = (128*1024), 674 .periods_min = 1, 675 .periods_max = 1024, 676 .fifo_size = 0, 677}; 678 679static struct snd_pcm_hardware snd_sonicvibes_capture = 680{ 681 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 682 SNDRV_PCM_INFO_BLOCK_TRANSFER | 683 SNDRV_PCM_INFO_MMAP_VALID), 684 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, 685 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 686 .rate_min = 4000, 687 .rate_max = 48000, 688 .channels_min = 1, 689 .channels_max = 2, 690 .buffer_bytes_max = (128*1024), 691 .period_bytes_min = 32, 692 .period_bytes_max = (128*1024), 693 .periods_min = 1, 694 .periods_max = 1024, 695 .fifo_size = 0, 696}; 697 698static int snd_sonicvibes_playback_open(struct snd_pcm_substream *substream) 699{ 700 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 701 struct snd_pcm_runtime *runtime = substream->runtime; 702 703 sonic->mode |= SV_MODE_PLAY; 704 sonic->playback_substream = substream; 705 runtime->hw = snd_sonicvibes_playback; 706 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, snd_sonicvibes_hw_constraint_dac_rate, NULL, SNDRV_PCM_HW_PARAM_RATE, -1); 707 return 0; 708} 709 710static int snd_sonicvibes_capture_open(struct snd_pcm_substream *substream) 711{ 712 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 713 struct snd_pcm_runtime *runtime = substream->runtime; 714 715 sonic->mode |= SV_MODE_CAPTURE; 716 sonic->capture_substream = substream; 717 runtime->hw = snd_sonicvibes_capture; 718 snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 719 &snd_sonicvibes_hw_constraints_adc_clock); 720 return 0; 721} 722 723static int snd_sonicvibes_playback_close(struct snd_pcm_substream *substream) 724{ 725 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 726 727 sonic->playback_substream = NULL; 728 sonic->mode &= ~SV_MODE_PLAY; 729 return 0; 730} 731 732static int snd_sonicvibes_capture_close(struct snd_pcm_substream *substream) 733{ 734 struct sonicvibes *sonic = snd_pcm_substream_chip(substream); 735 736 sonic->capture_substream = NULL; 737 sonic->mode &= ~SV_MODE_CAPTURE; 738 return 0; 739} 740 741static struct snd_pcm_ops snd_sonicvibes_playback_ops = { 742 .open = snd_sonicvibes_playback_open, 743 .close = snd_sonicvibes_playback_close, 744 .ioctl = snd_pcm_lib_ioctl, 745 .hw_params = snd_sonicvibes_hw_params, 746 .hw_free = snd_sonicvibes_hw_free, 747 .prepare = snd_sonicvibes_playback_prepare, 748 .trigger = snd_sonicvibes_playback_trigger, 749 .pointer = snd_sonicvibes_playback_pointer, 750}; 751 752static struct snd_pcm_ops snd_sonicvibes_capture_ops = { 753 .open = snd_sonicvibes_capture_open, 754 .close = snd_sonicvibes_capture_close, 755 .ioctl = snd_pcm_lib_ioctl, 756 .hw_params = snd_sonicvibes_hw_params, 757 .hw_free = snd_sonicvibes_hw_free, 758 .prepare = snd_sonicvibes_capture_prepare, 759 .trigger = snd_sonicvibes_capture_trigger, 760 .pointer = snd_sonicvibes_capture_pointer, 761}; 762 763static int __devinit snd_sonicvibes_pcm(struct sonicvibes * sonic, int device, struct snd_pcm ** rpcm) 764{ 765 struct snd_pcm *pcm; 766 int err; 767 768 if ((err = snd_pcm_new(sonic->card, "s3_86c617", device, 1, 1, &pcm)) < 0) 769 return err; 770 if (snd_BUG_ON(!pcm)) 771 return -EINVAL; 772 773 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sonicvibes_playback_ops); 774 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sonicvibes_capture_ops); 775 776 pcm->private_data = sonic; 777 pcm->info_flags = 0; 778 strcpy(pcm->name, "S3 SonicVibes"); 779 sonic->pcm = pcm; 780 781 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 782 snd_dma_pci_data(sonic->pci), 64*1024, 128*1024); 783 784 if (rpcm) 785 *rpcm = pcm; 786 return 0; 787} 788 789/* 790 * Mixer part 791 */ 792 793#define SONICVIBES_MUX(xname, xindex) \ 794{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 795 .info = snd_sonicvibes_info_mux, \ 796 .get = snd_sonicvibes_get_mux, .put = snd_sonicvibes_put_mux } 797 798static int snd_sonicvibes_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 799{ 800 static char *texts[7] = { 801 "CD", "PCM", "Aux1", "Line", "Aux0", "Mic", "Mix" 802 }; 803 804 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 805 uinfo->count = 2; 806 uinfo->value.enumerated.items = 7; 807 if (uinfo->value.enumerated.item >= 7) 808 uinfo->value.enumerated.item = 6; 809 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 810 return 0; 811} 812 813static int snd_sonicvibes_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 814{ 815 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 816 817 spin_lock_irq(&sonic->reg_lock); 818 ucontrol->value.enumerated.item[0] = ((snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ADC) & SV_RECSRC_OUT) >> 5) - 1; 819 ucontrol->value.enumerated.item[1] = ((snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ADC) & SV_RECSRC_OUT) >> 5) - 1; 820 spin_unlock_irq(&sonic->reg_lock); 821 return 0; 822} 823 824static int snd_sonicvibes_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 825{ 826 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 827 unsigned short left, right, oval1, oval2; 828 int change; 829 830 if (ucontrol->value.enumerated.item[0] >= 7 || 831 ucontrol->value.enumerated.item[1] >= 7) 832 return -EINVAL; 833 left = (ucontrol->value.enumerated.item[0] + 1) << 5; 834 right = (ucontrol->value.enumerated.item[1] + 1) << 5; 835 spin_lock_irq(&sonic->reg_lock); 836 oval1 = snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ADC); 837 oval2 = snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ADC); 838 left = (oval1 & ~SV_RECSRC_OUT) | left; 839 right = (oval2 & ~SV_RECSRC_OUT) | right; 840 change = left != oval1 || right != oval2; 841 snd_sonicvibes_out1(sonic, SV_IREG_LEFT_ADC, left); 842 snd_sonicvibes_out1(sonic, SV_IREG_RIGHT_ADC, right); 843 spin_unlock_irq(&sonic->reg_lock); 844 return change; 845} 846 847#define SONICVIBES_SINGLE(xname, xindex, reg, shift, mask, invert) \ 848{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 849 .info = snd_sonicvibes_info_single, \ 850 .get = snd_sonicvibes_get_single, .put = snd_sonicvibes_put_single, \ 851 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } 852 853static int snd_sonicvibes_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 854{ 855 int mask = (kcontrol->private_value >> 16) & 0xff; 856 857 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 858 uinfo->count = 1; 859 uinfo->value.integer.min = 0; 860 uinfo->value.integer.max = mask; 861 return 0; 862} 863 864static int snd_sonicvibes_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 865{ 866 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 867 int reg = kcontrol->private_value & 0xff; 868 int shift = (kcontrol->private_value >> 8) & 0xff; 869 int mask = (kcontrol->private_value >> 16) & 0xff; 870 int invert = (kcontrol->private_value >> 24) & 0xff; 871 872 spin_lock_irq(&sonic->reg_lock); 873 ucontrol->value.integer.value[0] = (snd_sonicvibes_in1(sonic, reg)>> shift) & mask; 874 spin_unlock_irq(&sonic->reg_lock); 875 if (invert) 876 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 877 return 0; 878} 879 880static int snd_sonicvibes_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 881{ 882 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 883 int reg = kcontrol->private_value & 0xff; 884 int shift = (kcontrol->private_value >> 8) & 0xff; 885 int mask = (kcontrol->private_value >> 16) & 0xff; 886 int invert = (kcontrol->private_value >> 24) & 0xff; 887 int change; 888 unsigned short val, oval; 889 890 val = (ucontrol->value.integer.value[0] & mask); 891 if (invert) 892 val = mask - val; 893 val <<= shift; 894 spin_lock_irq(&sonic->reg_lock); 895 oval = snd_sonicvibes_in1(sonic, reg); 896 val = (oval & ~(mask << shift)) | val; 897 change = val != oval; 898 snd_sonicvibes_out1(sonic, reg, val); 899 spin_unlock_irq(&sonic->reg_lock); 900 return change; 901} 902 903#define SONICVIBES_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ 904{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 905 .info = snd_sonicvibes_info_double, \ 906 .get = snd_sonicvibes_get_double, .put = snd_sonicvibes_put_double, \ 907 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } 908 909static int snd_sonicvibes_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 910{ 911 int mask = (kcontrol->private_value >> 24) & 0xff; 912 913 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 914 uinfo->count = 2; 915 uinfo->value.integer.min = 0; 916 uinfo->value.integer.max = mask; 917 return 0; 918} 919 920static int snd_sonicvibes_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 921{ 922 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 923 int left_reg = kcontrol->private_value & 0xff; 924 int right_reg = (kcontrol->private_value >> 8) & 0xff; 925 int shift_left = (kcontrol->private_value >> 16) & 0x07; 926 int shift_right = (kcontrol->private_value >> 19) & 0x07; 927 int mask = (kcontrol->private_value >> 24) & 0xff; 928 int invert = (kcontrol->private_value >> 22) & 1; 929 930 spin_lock_irq(&sonic->reg_lock); 931 ucontrol->value.integer.value[0] = (snd_sonicvibes_in1(sonic, left_reg) >> shift_left) & mask; 932 ucontrol->value.integer.value[1] = (snd_sonicvibes_in1(sonic, right_reg) >> shift_right) & mask; 933 spin_unlock_irq(&sonic->reg_lock); 934 if (invert) { 935 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 936 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1]; 937 } 938 return 0; 939} 940 941static int snd_sonicvibes_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 942{ 943 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 944 int left_reg = kcontrol->private_value & 0xff; 945 int right_reg = (kcontrol->private_value >> 8) & 0xff; 946 int shift_left = (kcontrol->private_value >> 16) & 0x07; 947 int shift_right = (kcontrol->private_value >> 19) & 0x07; 948 int mask = (kcontrol->private_value >> 24) & 0xff; 949 int invert = (kcontrol->private_value >> 22) & 1; 950 int change; 951 unsigned short val1, val2, oval1, oval2; 952 953 val1 = ucontrol->value.integer.value[0] & mask; 954 val2 = ucontrol->value.integer.value[1] & mask; 955 if (invert) { 956 val1 = mask - val1; 957 val2 = mask - val2; 958 } 959 val1 <<= shift_left; 960 val2 <<= shift_right; 961 spin_lock_irq(&sonic->reg_lock); 962 oval1 = snd_sonicvibes_in1(sonic, left_reg); 963 oval2 = snd_sonicvibes_in1(sonic, right_reg); 964 val1 = (oval1 & ~(mask << shift_left)) | val1; 965 val2 = (oval2 & ~(mask << shift_right)) | val2; 966 change = val1 != oval1 || val2 != oval2; 967 snd_sonicvibes_out1(sonic, left_reg, val1); 968 snd_sonicvibes_out1(sonic, right_reg, val2); 969 spin_unlock_irq(&sonic->reg_lock); 970 return change; 971} 972 973static struct snd_kcontrol_new snd_sonicvibes_controls[] __devinitdata = { 974SONICVIBES_DOUBLE("Capture Volume", 0, SV_IREG_LEFT_ADC, SV_IREG_RIGHT_ADC, 0, 0, 15, 0), 975SONICVIBES_DOUBLE("Aux Playback Switch", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 7, 7, 1, 1), 976SONICVIBES_DOUBLE("Aux Playback Volume", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 0, 0, 31, 1), 977SONICVIBES_DOUBLE("CD Playback Switch", 0, SV_IREG_LEFT_CD, SV_IREG_RIGHT_CD, 7, 7, 1, 1), 978SONICVIBES_DOUBLE("CD Playback Volume", 0, SV_IREG_LEFT_CD, SV_IREG_RIGHT_CD, 0, 0, 31, 1), 979SONICVIBES_DOUBLE("Line Playback Switch", 0, SV_IREG_LEFT_LINE, SV_IREG_RIGHT_LINE, 7, 7, 1, 1), 980SONICVIBES_DOUBLE("Line Playback Volume", 0, SV_IREG_LEFT_LINE, SV_IREG_RIGHT_LINE, 0, 0, 31, 1), 981SONICVIBES_SINGLE("Mic Playback Switch", 0, SV_IREG_MIC, 7, 1, 1), 982SONICVIBES_SINGLE("Mic Playback Volume", 0, SV_IREG_MIC, 0, 15, 1), 983SONICVIBES_SINGLE("Mic Boost", 0, SV_IREG_LEFT_ADC, 4, 1, 0), 984SONICVIBES_DOUBLE("Synth Playback Switch", 0, SV_IREG_LEFT_SYNTH, SV_IREG_RIGHT_SYNTH, 7, 7, 1, 1), 985SONICVIBES_DOUBLE("Synth Playback Volume", 0, SV_IREG_LEFT_SYNTH, SV_IREG_RIGHT_SYNTH, 0, 0, 31, 1), 986SONICVIBES_DOUBLE("Aux Playback Switch", 1, SV_IREG_LEFT_AUX2, SV_IREG_RIGHT_AUX2, 7, 7, 1, 1), 987SONICVIBES_DOUBLE("Aux Playback Volume", 1, SV_IREG_LEFT_AUX2, SV_IREG_RIGHT_AUX2, 0, 0, 31, 1), 988SONICVIBES_DOUBLE("Master Playback Switch", 0, SV_IREG_LEFT_ANALOG, SV_IREG_RIGHT_ANALOG, 7, 7, 1, 1), 989SONICVIBES_DOUBLE("Master Playback Volume", 0, SV_IREG_LEFT_ANALOG, SV_IREG_RIGHT_ANALOG, 0, 0, 31, 1), 990SONICVIBES_DOUBLE("PCM Playback Switch", 0, SV_IREG_LEFT_PCM, SV_IREG_RIGHT_PCM, 7, 7, 1, 1), 991SONICVIBES_DOUBLE("PCM Playback Volume", 0, SV_IREG_LEFT_PCM, SV_IREG_RIGHT_PCM, 0, 0, 63, 1), 992SONICVIBES_SINGLE("Loopback Capture Switch", 0, SV_IREG_ADC_OUTPUT_CTRL, 0, 1, 0), 993SONICVIBES_SINGLE("Loopback Capture Volume", 0, SV_IREG_ADC_OUTPUT_CTRL, 2, 63, 1), 994SONICVIBES_MUX("Capture Source", 0) 995}; 996 997static void snd_sonicvibes_master_free(struct snd_kcontrol *kcontrol) 998{ 999 struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); 1000 sonic->master_mute = NULL; 1001 sonic->master_volume = NULL; 1002} 1003 1004static int __devinit snd_sonicvibes_mixer(struct sonicvibes * sonic) 1005{ 1006 struct snd_card *card; 1007 struct snd_kcontrol *kctl; 1008 unsigned int idx; 1009 int err; 1010 1011 if (snd_BUG_ON(!sonic || !sonic->card)) 1012 return -EINVAL; 1013 card = sonic->card; 1014 strcpy(card->mixername, "S3 SonicVibes"); 1015 1016 for (idx = 0; idx < ARRAY_SIZE(snd_sonicvibes_controls); idx++) { 1017 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_sonicvibes_controls[idx], sonic))) < 0) 1018 return err; 1019 switch (idx) { 1020 case 0: 1021 case 1: kctl->private_free = snd_sonicvibes_master_free; break; 1022 } 1023 } 1024 return 0; 1025} 1026 1027/* 1028 1029 */ 1030 1031static void snd_sonicvibes_proc_read(struct snd_info_entry *entry, 1032 struct snd_info_buffer *buffer) 1033{ 1034 struct sonicvibes *sonic = entry->private_data; 1035 unsigned char tmp; 1036 1037 tmp = sonic->srs_space & 0x0f; 1038 snd_iprintf(buffer, "SRS 3D : %s\n", 1039 sonic->srs_space & 0x80 ? "off" : "on"); 1040 snd_iprintf(buffer, "SRS Space : %s\n", 1041 tmp == 0x00 ? "100%" : 1042 tmp == 0x01 ? "75%" : 1043 tmp == 0x02 ? "50%" : 1044 tmp == 0x03 ? "25%" : "0%"); 1045 tmp = sonic->srs_center & 0x0f; 1046 snd_iprintf(buffer, "SRS Center : %s\n", 1047 tmp == 0x00 ? "100%" : 1048 tmp == 0x01 ? "75%" : 1049 tmp == 0x02 ? "50%" : 1050 tmp == 0x03 ? "25%" : "0%"); 1051 tmp = sonic->wave_source & 0x03; 1052 snd_iprintf(buffer, "WaveTable Source : %s\n", 1053 tmp == 0x00 ? "on-board ROM" : 1054 tmp == 0x01 ? "PCI bus" : "on-board ROM + PCI bus"); 1055 tmp = sonic->mpu_switch; 1056 snd_iprintf(buffer, "Onboard synth : %s\n", tmp & 0x01 ? "on" : "off"); 1057 snd_iprintf(buffer, "Ext. Rx to synth : %s\n", tmp & 0x02 ? "on" : "off"); 1058 snd_iprintf(buffer, "MIDI to ext. Tx : %s\n", tmp & 0x04 ? "on" : "off"); 1059} 1060 1061static void __devinit snd_sonicvibes_proc_init(struct sonicvibes * sonic) 1062{ 1063 struct snd_info_entry *entry; 1064 1065 if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry)) 1066 snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read); 1067} 1068 1069/* 1070 1071 */ 1072 1073#ifdef SUPPORT_JOYSTICK 1074static struct snd_kcontrol_new snd_sonicvibes_game_control __devinitdata = 1075SONICVIBES_SINGLE("Joystick Speed", 0, SV_IREG_GAME_PORT, 1, 15, 0); 1076 1077static int __devinit snd_sonicvibes_create_gameport(struct sonicvibes *sonic) 1078{ 1079 struct gameport *gp; 1080 1081 sonic->gameport = gp = gameport_allocate_port(); 1082 if (!gp) { 1083 printk(KERN_ERR "sonicvibes: cannot allocate memory for gameport\n"); 1084 return -ENOMEM; 1085 } 1086 1087 gameport_set_name(gp, "SonicVibes Gameport"); 1088 gameport_set_phys(gp, "pci%s/gameport0", pci_name(sonic->pci)); 1089 gameport_set_dev_parent(gp, &sonic->pci->dev); 1090 gp->io = sonic->game_port; 1091 1092 gameport_register_port(gp); 1093 1094 snd_ctl_add(sonic->card, snd_ctl_new1(&snd_sonicvibes_game_control, sonic)); 1095 1096 return 0; 1097} 1098 1099static void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) 1100{ 1101 if (sonic->gameport) { 1102 gameport_unregister_port(sonic->gameport); 1103 sonic->gameport = NULL; 1104 } 1105} 1106#else 1107static inline int snd_sonicvibes_create_gameport(struct sonicvibes *sonic) { return -ENOSYS; } 1108static inline void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) { } 1109#endif 1110 1111static int snd_sonicvibes_free(struct sonicvibes *sonic) 1112{ 1113 snd_sonicvibes_free_gameport(sonic); 1114 pci_write_config_dword(sonic->pci, 0x40, sonic->dmaa_port); 1115 pci_write_config_dword(sonic->pci, 0x48, sonic->dmac_port); 1116 if (sonic->irq >= 0) 1117 free_irq(sonic->irq, sonic); 1118 release_and_free_resource(sonic->res_dmaa); 1119 release_and_free_resource(sonic->res_dmac); 1120 pci_release_regions(sonic->pci); 1121 pci_disable_device(sonic->pci); 1122 kfree(sonic); 1123 return 0; 1124} 1125 1126static int snd_sonicvibes_dev_free(struct snd_device *device) 1127{ 1128 struct sonicvibes *sonic = device->device_data; 1129 return snd_sonicvibes_free(sonic); 1130} 1131 1132static int __devinit snd_sonicvibes_create(struct snd_card *card, 1133 struct pci_dev *pci, 1134 int reverb, 1135 int mge, 1136 struct sonicvibes ** rsonic) 1137{ 1138 struct sonicvibes *sonic; 1139 unsigned int dmaa, dmac; 1140 int err; 1141 static struct snd_device_ops ops = { 1142 .dev_free = snd_sonicvibes_dev_free, 1143 }; 1144 1145 *rsonic = NULL; 1146 /* enable PCI device */ 1147 if ((err = pci_enable_device(pci)) < 0) 1148 return err; 1149 /* check, if we can restrict PCI DMA transfers to 24 bits */ 1150 if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 || 1151 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) { 1152 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); 1153 pci_disable_device(pci); 1154 return -ENXIO; 1155 } 1156 1157 sonic = kzalloc(sizeof(*sonic), GFP_KERNEL); 1158 if (sonic == NULL) { 1159 pci_disable_device(pci); 1160 return -ENOMEM; 1161 } 1162 spin_lock_init(&sonic->reg_lock); 1163 sonic->card = card; 1164 sonic->pci = pci; 1165 sonic->irq = -1; 1166 1167 if ((err = pci_request_regions(pci, "S3 SonicVibes")) < 0) { 1168 kfree(sonic); 1169 pci_disable_device(pci); 1170 return err; 1171 } 1172 1173 sonic->sb_port = pci_resource_start(pci, 0); 1174 sonic->enh_port = pci_resource_start(pci, 1); 1175 sonic->synth_port = pci_resource_start(pci, 2); 1176 sonic->midi_port = pci_resource_start(pci, 3); 1177 sonic->game_port = pci_resource_start(pci, 4); 1178 1179 if (request_irq(pci->irq, snd_sonicvibes_interrupt, IRQF_SHARED, 1180 "S3 SonicVibes", sonic)) { 1181 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 1182 snd_sonicvibes_free(sonic); 1183 return -EBUSY; 1184 } 1185 sonic->irq = pci->irq; 1186 1187 pci_read_config_dword(pci, 0x40, &dmaa); 1188 pci_read_config_dword(pci, 0x48, &dmac); 1189 dmaio &= ~0x0f; 1190 dmaa &= ~0x0f; 1191 dmac &= ~0x0f; 1192 if (!dmaa) { 1193 dmaa = dmaio; 1194 dmaio += 0x10; 1195 snd_printk(KERN_INFO "BIOS did not allocate DDMA channel A i/o, allocated at 0x%x\n", dmaa); 1196 } 1197 if (!dmac) { 1198 dmac = dmaio; 1199 dmaio += 0x10; 1200 snd_printk(KERN_INFO "BIOS did not allocate DDMA channel C i/o, allocated at 0x%x\n", dmac); 1201 } 1202 pci_write_config_dword(pci, 0x40, dmaa); 1203 pci_write_config_dword(pci, 0x48, dmac); 1204 1205 if ((sonic->res_dmaa = request_region(dmaa, 0x10, "S3 SonicVibes DDMA-A")) == NULL) { 1206 snd_sonicvibes_free(sonic); 1207 snd_printk(KERN_ERR "unable to grab DDMA-A port at 0x%x-0x%x\n", dmaa, dmaa + 0x10 - 1); 1208 return -EBUSY; 1209 } 1210 if ((sonic->res_dmac = request_region(dmac, 0x10, "S3 SonicVibes DDMA-C")) == NULL) { 1211 snd_sonicvibes_free(sonic); 1212 snd_printk(KERN_ERR "unable to grab DDMA-C port at 0x%x-0x%x\n", dmac, dmac + 0x10 - 1); 1213 return -EBUSY; 1214 } 1215 1216 pci_read_config_dword(pci, 0x40, &sonic->dmaa_port); 1217 pci_read_config_dword(pci, 0x48, &sonic->dmac_port); 1218 sonic->dmaa_port &= ~0x0f; 1219 sonic->dmac_port &= ~0x0f; 1220 pci_write_config_dword(pci, 0x40, sonic->dmaa_port | 9); /* enable + enhanced */ 1221 pci_write_config_dword(pci, 0x48, sonic->dmac_port | 9); /* enable */ 1222 /* ok.. initialize S3 SonicVibes chip */ 1223 outb(SV_RESET, SV_REG(sonic, CONTROL)); /* reset chip */ 1224 udelay(100); 1225 outb(0, SV_REG(sonic, CONTROL)); /* release reset */ 1226 udelay(100); 1227 outb(SV_ENHANCED | SV_INTA | (reverb ? SV_REVERB : 0), SV_REG(sonic, CONTROL)); 1228 inb(SV_REG(sonic, STATUS)); /* clear IRQs */ 1229 snd_sonicvibes_out(sonic, SV_IREG_DRIVE_CTRL, 0); /* drive current 16mA */ 1230 snd_sonicvibes_out(sonic, SV_IREG_PC_ENABLE, sonic->enable = 0); /* disable playback & capture */ 1231 outb(sonic->irqmask = ~(SV_DMAA_MASK | SV_DMAC_MASK | SV_UD_MASK), SV_REG(sonic, IRQMASK)); 1232 inb(SV_REG(sonic, STATUS)); /* clear IRQs */ 1233 snd_sonicvibes_out(sonic, SV_IREG_ADC_CLOCK, 0); /* use PLL as clock source */ 1234 snd_sonicvibes_out(sonic, SV_IREG_ANALOG_POWER, 0); /* power up analog parts */ 1235 snd_sonicvibes_out(sonic, SV_IREG_DIGITAL_POWER, 0); /* power up digital parts */ 1236 snd_sonicvibes_setpll(sonic, SV_IREG_ADC_PLL, 8000); 1237 snd_sonicvibes_out(sonic, SV_IREG_SRS_SPACE, sonic->srs_space = 0x80); /* SRS space off */ 1238 snd_sonicvibes_out(sonic, SV_IREG_SRS_CENTER, sonic->srs_center = 0x00);/* SRS center off */ 1239 snd_sonicvibes_out(sonic, SV_IREG_MPU401, sonic->mpu_switch = 0x05); /* MPU-401 switch */ 1240 snd_sonicvibes_out(sonic, SV_IREG_WAVE_SOURCE, sonic->wave_source = 0x00); /* onboard ROM */ 1241 snd_sonicvibes_out(sonic, SV_IREG_PCM_RATE_LOW, (8000 * 65536 / SV_FULLRATE) & 0xff); 1242 snd_sonicvibes_out(sonic, SV_IREG_PCM_RATE_HIGH, ((8000 * 65536 / SV_FULLRATE) >> 8) & 0xff); 1243 snd_sonicvibes_out(sonic, SV_IREG_LEFT_ADC, mge ? 0xd0 : 0xc0); 1244 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_ADC, 0xc0); 1245 snd_sonicvibes_out(sonic, SV_IREG_LEFT_AUX1, 0x9f); 1246 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_AUX1, 0x9f); 1247 snd_sonicvibes_out(sonic, SV_IREG_LEFT_CD, 0x9f); 1248 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_CD, 0x9f); 1249 snd_sonicvibes_out(sonic, SV_IREG_LEFT_LINE, 0x9f); 1250 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_LINE, 0x9f); 1251 snd_sonicvibes_out(sonic, SV_IREG_MIC, 0x8f); 1252 snd_sonicvibes_out(sonic, SV_IREG_LEFT_SYNTH, 0x9f); 1253 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_SYNTH, 0x9f); 1254 snd_sonicvibes_out(sonic, SV_IREG_LEFT_AUX2, 0x9f); 1255 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_AUX2, 0x9f); 1256 snd_sonicvibes_out(sonic, SV_IREG_LEFT_ANALOG, 0x9f); 1257 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_ANALOG, 0x9f); 1258 snd_sonicvibes_out(sonic, SV_IREG_LEFT_PCM, 0xbf); 1259 snd_sonicvibes_out(sonic, SV_IREG_RIGHT_PCM, 0xbf); 1260 snd_sonicvibes_out(sonic, SV_IREG_ADC_OUTPUT_CTRL, 0xfc); 1261 sonic->revision = snd_sonicvibes_in(sonic, SV_IREG_REVISION); 1262 1263 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, sonic, &ops)) < 0) { 1264 snd_sonicvibes_free(sonic); 1265 return err; 1266 } 1267 1268 snd_sonicvibes_proc_init(sonic); 1269 1270 snd_card_set_dev(card, &pci->dev); 1271 1272 *rsonic = sonic; 1273 return 0; 1274} 1275 1276/* 1277 * MIDI section 1278 */ 1279 1280static struct snd_kcontrol_new snd_sonicvibes_midi_controls[] __devinitdata = { 1281SONICVIBES_SINGLE("SonicVibes Wave Source RAM", 0, SV_IREG_WAVE_SOURCE, 0, 1, 0), 1282SONICVIBES_SINGLE("SonicVibes Wave Source RAM+ROM", 0, SV_IREG_WAVE_SOURCE, 1, 1, 0), 1283SONICVIBES_SINGLE("SonicVibes Onboard Synth", 0, SV_IREG_MPU401, 0, 1, 0), 1284SONICVIBES_SINGLE("SonicVibes External Rx to Synth", 0, SV_IREG_MPU401, 1, 1, 0), 1285SONICVIBES_SINGLE("SonicVibes External Tx", 0, SV_IREG_MPU401, 2, 1, 0) 1286}; 1287 1288static int snd_sonicvibes_midi_input_open(struct snd_mpu401 * mpu) 1289{ 1290 struct sonicvibes *sonic = mpu->private_data; 1291 outb(sonic->irqmask &= ~SV_MIDI_MASK, SV_REG(sonic, IRQMASK)); 1292 return 0; 1293} 1294 1295static void snd_sonicvibes_midi_input_close(struct snd_mpu401 * mpu) 1296{ 1297 struct sonicvibes *sonic = mpu->private_data; 1298 outb(sonic->irqmask |= SV_MIDI_MASK, SV_REG(sonic, IRQMASK)); 1299} 1300 1301static int __devinit snd_sonicvibes_midi(struct sonicvibes * sonic, 1302 struct snd_rawmidi *rmidi) 1303{ 1304 struct snd_mpu401 * mpu = rmidi->private_data; 1305 struct snd_card *card = sonic->card; 1306 struct snd_rawmidi_str *dir; 1307 unsigned int idx; 1308 int err; 1309 1310 mpu->private_data = sonic; 1311 mpu->open_input = snd_sonicvibes_midi_input_open; 1312 mpu->close_input = snd_sonicvibes_midi_input_close; 1313 dir = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]; 1314 for (idx = 0; idx < ARRAY_SIZE(snd_sonicvibes_midi_controls); idx++) 1315 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_sonicvibes_midi_controls[idx], sonic))) < 0) 1316 return err; 1317 return 0; 1318} 1319 1320static int __devinit snd_sonic_probe(struct pci_dev *pci, 1321 const struct pci_device_id *pci_id) 1322{ 1323 static int dev; 1324 struct snd_card *card; 1325 struct sonicvibes *sonic; 1326 struct snd_rawmidi *midi_uart; 1327 struct snd_opl3 *opl3; 1328 int idx, err; 1329 1330 if (dev >= SNDRV_CARDS) 1331 return -ENODEV; 1332 if (!enable[dev]) { 1333 dev++; 1334 return -ENOENT; 1335 } 1336 1337 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); 1338 if (err < 0) 1339 return err; 1340 for (idx = 0; idx < 5; idx++) { 1341 if (pci_resource_start(pci, idx) == 0 || 1342 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) { 1343 snd_card_free(card); 1344 return -ENODEV; 1345 } 1346 } 1347 if ((err = snd_sonicvibes_create(card, pci, 1348 reverb[dev] ? 1 : 0, 1349 mge[dev] ? 1 : 0, 1350 &sonic)) < 0) { 1351 snd_card_free(card); 1352 return err; 1353 } 1354 1355 strcpy(card->driver, "SonicVibes"); 1356 strcpy(card->shortname, "S3 SonicVibes"); 1357 sprintf(card->longname, "%s rev %i at 0x%llx, irq %i", 1358 card->shortname, 1359 sonic->revision, 1360 (unsigned long long)pci_resource_start(pci, 1), 1361 sonic->irq); 1362 1363 if ((err = snd_sonicvibes_pcm(sonic, 0, NULL)) < 0) { 1364 snd_card_free(card); 1365 return err; 1366 } 1367 if ((err = snd_sonicvibes_mixer(sonic)) < 0) { 1368 snd_card_free(card); 1369 return err; 1370 } 1371 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_SONICVIBES, 1372 sonic->midi_port, MPU401_INFO_INTEGRATED, 1373 sonic->irq, 0, 1374 &midi_uart)) < 0) { 1375 snd_card_free(card); 1376 return err; 1377 } 1378 snd_sonicvibes_midi(sonic, midi_uart); 1379 if ((err = snd_opl3_create(card, sonic->synth_port, 1380 sonic->synth_port + 2, 1381 OPL3_HW_OPL3_SV, 1, &opl3)) < 0) { 1382 snd_card_free(card); 1383 return err; 1384 } 1385 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 1386 snd_card_free(card); 1387 return err; 1388 } 1389 1390 snd_sonicvibes_create_gameport(sonic); 1391 1392 if ((err = snd_card_register(card)) < 0) { 1393 snd_card_free(card); 1394 return err; 1395 } 1396 1397 pci_set_drvdata(pci, card); 1398 dev++; 1399 return 0; 1400} 1401 1402static void __devexit snd_sonic_remove(struct pci_dev *pci) 1403{ 1404 snd_card_free(pci_get_drvdata(pci)); 1405 pci_set_drvdata(pci, NULL); 1406} 1407 1408static struct pci_driver driver = { 1409 .name = "S3 SonicVibes", 1410 .id_table = snd_sonic_ids, 1411 .probe = snd_sonic_probe, 1412 .remove = __devexit_p(snd_sonic_remove), 1413}; 1414 1415static int __init alsa_card_sonicvibes_init(void) 1416{ 1417 return pci_register_driver(&driver); 1418} 1419 1420static void __exit alsa_card_sonicvibes_exit(void) 1421{ 1422 pci_unregister_driver(&driver); 1423} 1424 1425module_init(alsa_card_sonicvibes_init) 1426module_exit(alsa_card_sonicvibes_exit) 1427