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