xref: /openbmc/linux/sound/pci/sonicvibes.c (revision 0d456bad)
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/module.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 
44 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
45 MODULE_DESCRIPTION("S3 SonicVibes PCI");
46 MODULE_LICENSE("GPL");
47 MODULE_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 
53 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
54 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;	/* ID for this card */
55 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;	/* Enable this card */
56 static bool reverb[SNDRV_CARDS];
57 static bool mge[SNDRV_CARDS];
58 static unsigned int dmaio = 0x7a00;	/* DDMA i/o address */
59 
60 module_param_array(index, int, NULL, 0444);
61 MODULE_PARM_DESC(index, "Index value for S3 SonicVibes soundcard.");
62 module_param_array(id, charp, NULL, 0444);
63 MODULE_PARM_DESC(id, "ID string for S3 SonicVibes soundcard.");
64 module_param_array(enable, bool, NULL, 0444);
65 MODULE_PARM_DESC(enable, "Enable S3 SonicVibes soundcard.");
66 module_param_array(reverb, bool, NULL, 0444);
67 MODULE_PARM_DESC(reverb, "Enable reverb (SRAM is present) for S3 SonicVibes soundcard.");
68 module_param_array(mge, bool, NULL, 0444);
69 MODULE_PARM_DESC(mge, "MIC Gain Enable for S3 SonicVibes soundcard.");
70 module_param(dmaio, uint, 0444);
71 MODULE_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 
198 struct 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 
245 static DEFINE_PCI_DEVICE_TABLE(snd_sonic_ids) = {
246 	{ PCI_VDEVICE(S3, 0xca00), 0, },
247         { 0, }
248 };
249 
250 MODULE_DEVICE_TABLE(pci, snd_sonic_ids);
251 
252 static struct snd_ratden sonicvibes_adc_clock = {
253 	.num_min = 4000 * 65536,
254 	.num_max = 48000UL * 65536,
255 	.num_step = 1,
256 	.den = 65536,
257 };
258 static 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 
267 static 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 #if 0
276 	printk(KERN_DEBUG "program dmaa: addr = 0x%x, paddr = 0x%x\n",
277 	       addr, inl(sonic->dmaa_port + SV_DMA_ADDR0));
278 #endif
279 }
280 
281 static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic,
282 					  unsigned int addr,
283 					  unsigned int count)
284 {
285 	/* note: dmac is working in word mode!!! */
286 	count >>= 1;
287 	count--;
288 	outl(addr, sonic->dmac_port + SV_DMA_ADDR0);
289 	outl(count, sonic->dmac_port + SV_DMA_COUNT0);
290 	outb(0x14, sonic->dmac_port + SV_DMA_MODE);
291 #if 0
292 	printk(KERN_DEBUG "program dmac: addr = 0x%x, paddr = 0x%x\n",
293 	       addr, inl(sonic->dmac_port + SV_DMA_ADDR0));
294 #endif
295 }
296 
297 static inline unsigned int snd_sonicvibes_getdmaa(struct sonicvibes * sonic)
298 {
299 	return (inl(sonic->dmaa_port + SV_DMA_COUNT0) & 0xffffff) + 1;
300 }
301 
302 static inline unsigned int snd_sonicvibes_getdmac(struct sonicvibes * sonic)
303 {
304 	/* note: dmac is working in word mode!!! */
305 	return ((inl(sonic->dmac_port + SV_DMA_COUNT0) & 0xffffff) + 1) << 1;
306 }
307 
308 static void snd_sonicvibes_out1(struct sonicvibes * sonic,
309 				unsigned char reg,
310 				unsigned char value)
311 {
312 	outb(reg, SV_REG(sonic, INDEX));
313 	udelay(10);
314 	outb(value, SV_REG(sonic, DATA));
315 	udelay(10);
316 }
317 
318 static void snd_sonicvibes_out(struct sonicvibes * sonic,
319 			       unsigned char reg,
320 			       unsigned char value)
321 {
322 	unsigned long flags;
323 
324 	spin_lock_irqsave(&sonic->reg_lock, flags);
325 	outb(reg, SV_REG(sonic, INDEX));
326 	udelay(10);
327 	outb(value, SV_REG(sonic, DATA));
328 	udelay(10);
329 	spin_unlock_irqrestore(&sonic->reg_lock, flags);
330 }
331 
332 static unsigned char snd_sonicvibes_in1(struct sonicvibes * sonic, unsigned char reg)
333 {
334 	unsigned char value;
335 
336 	outb(reg, SV_REG(sonic, INDEX));
337 	udelay(10);
338 	value = inb(SV_REG(sonic, DATA));
339 	udelay(10);
340 	return value;
341 }
342 
343 static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char reg)
344 {
345 	unsigned long flags;
346 	unsigned char value;
347 
348 	spin_lock_irqsave(&sonic->reg_lock, flags);
349 	outb(reg, SV_REG(sonic, INDEX));
350 	udelay(10);
351 	value = inb(SV_REG(sonic, DATA));
352 	udelay(10);
353 	spin_unlock_irqrestore(&sonic->reg_lock, flags);
354 	return value;
355 }
356 
357 #if 0
358 static void snd_sonicvibes_debug(struct sonicvibes * sonic)
359 {
360 	printk(KERN_DEBUG
361 	       "SV REGS:          INDEX = 0x%02x  ", inb(SV_REG(sonic, INDEX)));
362 	printk("                 STATUS = 0x%02x\n", inb(SV_REG(sonic, STATUS)));
363 	printk(KERN_DEBUG
364 	       "  0x00: left input      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x00));
365 	printk("  0x20: synth rate low  = 0x%02x\n", snd_sonicvibes_in(sonic, 0x20));
366 	printk(KERN_DEBUG
367 	       "  0x01: right input     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x01));
368 	printk("  0x21: synth rate high = 0x%02x\n", snd_sonicvibes_in(sonic, 0x21));
369 	printk(KERN_DEBUG
370 	       "  0x02: left AUX1       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x02));
371 	printk("  0x22: ADC clock       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x22));
372 	printk(KERN_DEBUG
373 	       "  0x03: right AUX1      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x03));
374 	printk("  0x23: ADC alt rate    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x23));
375 	printk(KERN_DEBUG
376 	       "  0x04: left CD         = 0x%02x  ", snd_sonicvibes_in(sonic, 0x04));
377 	printk("  0x24: ADC pll M       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x24));
378 	printk(KERN_DEBUG
379 	       "  0x05: right CD        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x05));
380 	printk("  0x25: ADC pll N       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x25));
381 	printk(KERN_DEBUG
382 	       "  0x06: left line       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x06));
383 	printk("  0x26: Synth pll M     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x26));
384 	printk(KERN_DEBUG
385 	       "  0x07: right line      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x07));
386 	printk("  0x27: Synth pll N     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x27));
387 	printk(KERN_DEBUG
388 	       "  0x08: MIC             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x08));
389 	printk("  0x28: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x28));
390 	printk(KERN_DEBUG
391 	       "  0x09: Game port       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x09));
392 	printk("  0x29: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x29));
393 	printk(KERN_DEBUG
394 	       "  0x0a: left synth      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0a));
395 	printk("  0x2a: MPU401          = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2a));
396 	printk(KERN_DEBUG
397 	       "  0x0b: right synth     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0b));
398 	printk("  0x2b: drive ctrl      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2b));
399 	printk(KERN_DEBUG
400 	       "  0x0c: left AUX2       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0c));
401 	printk("  0x2c: SRS space       = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2c));
402 	printk(KERN_DEBUG
403 	       "  0x0d: right AUX2      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0d));
404 	printk("  0x2d: SRS center      = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2d));
405 	printk(KERN_DEBUG
406 	       "  0x0e: left analog     = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0e));
407 	printk("  0x2e: wave source     = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2e));
408 	printk(KERN_DEBUG
409 	       "  0x0f: right analog    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x0f));
410 	printk("  0x2f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x2f));
411 	printk(KERN_DEBUG
412 	       "  0x10: left PCM        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x10));
413 	printk("  0x30: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x30));
414 	printk(KERN_DEBUG
415 	       "  0x11: right PCM       = 0x%02x  ", snd_sonicvibes_in(sonic, 0x11));
416 	printk("  0x31: analog power    = 0x%02x\n", snd_sonicvibes_in(sonic, 0x31));
417 	printk(KERN_DEBUG
418 	       "  0x12: DMA data format = 0x%02x  ", snd_sonicvibes_in(sonic, 0x12));
419 	printk("  0x32: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x32));
420 	printk(KERN_DEBUG
421 	       "  0x13: P/C enable      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x13));
422 	printk("  0x33: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x33));
423 	printk(KERN_DEBUG
424 	       "  0x14: U/D button      = 0x%02x  ", snd_sonicvibes_in(sonic, 0x14));
425 	printk("  0x34: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x34));
426 	printk(KERN_DEBUG
427 	       "  0x15: revision        = 0x%02x  ", snd_sonicvibes_in(sonic, 0x15));
428 	printk("  0x35: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x35));
429 	printk(KERN_DEBUG
430 	       "  0x16: ADC output ctrl = 0x%02x  ", snd_sonicvibes_in(sonic, 0x16));
431 	printk("  0x36: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x36));
432 	printk(KERN_DEBUG
433 	       "  0x17: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x17));
434 	printk("  0x37: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x37));
435 	printk(KERN_DEBUG
436 	       "  0x18: DMA A upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x18));
437 	printk("  0x38: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x38));
438 	printk(KERN_DEBUG
439 	       "  0x19: DMA A lower cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x19));
440 	printk("  0x39: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x39));
441 	printk(KERN_DEBUG
442 	       "  0x1a: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1a));
443 	printk("  0x3a: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3a));
444 	printk(KERN_DEBUG
445 	       "  0x1b: ---             = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1b));
446 	printk("  0x3b: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3b));
447 	printk(KERN_DEBUG
448 	       "  0x1c: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1c));
449 	printk("  0x3c: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3c));
450 	printk(KERN_DEBUG
451 	       "  0x1d: DMA C upper cnt = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1d));
452 	printk("  0x3d: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3d));
453 	printk(KERN_DEBUG
454 	       "  0x1e: PCM rate low    = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1e));
455 	printk("  0x3e: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3e));
456 	printk(KERN_DEBUG
457 	       "  0x1f: PCM rate high   = 0x%02x  ", snd_sonicvibes_in(sonic, 0x1f));
458 	printk("  0x3f: ---             = 0x%02x\n", snd_sonicvibes_in(sonic, 0x3f));
459 }
460 
461 #endif
462 
463 static void snd_sonicvibes_setfmt(struct sonicvibes * sonic,
464                                   unsigned char mask,
465                                   unsigned char value)
466 {
467 	unsigned long flags;
468 
469 	spin_lock_irqsave(&sonic->reg_lock, flags);
470 	outb(SV_MCE | SV_IREG_DMA_DATA_FMT, SV_REG(sonic, INDEX));
471 	if (mask) {
472 		sonic->format = inb(SV_REG(sonic, DATA));
473 		udelay(10);
474 	}
475 	sonic->format = (sonic->format & mask) | value;
476 	outb(sonic->format, SV_REG(sonic, DATA));
477 	udelay(10);
478 	outb(0, SV_REG(sonic, INDEX));
479 	udelay(10);
480 	spin_unlock_irqrestore(&sonic->reg_lock, flags);
481 }
482 
483 static void snd_sonicvibes_pll(unsigned int rate,
484 			       unsigned int *res_r,
485 			       unsigned int *res_m,
486 			       unsigned int *res_n)
487 {
488 	unsigned int r, m = 0, n = 0;
489 	unsigned int xm, xn, xr, xd, metric = ~0U;
490 
491 	if (rate < 625000 / SV_ADCMULT)
492 		rate = 625000 / SV_ADCMULT;
493 	if (rate > 150000000 / SV_ADCMULT)
494 		rate = 150000000 / SV_ADCMULT;
495 	/* slight violation of specs, needed for continuous sampling rates */
496 	for (r = 0; rate < 75000000 / SV_ADCMULT; r += 0x20, rate <<= 1);
497 	for (xn = 3; xn < 33; xn++)	/* 35 */
498 		for (xm = 3; xm < 257; xm++) {
499 			xr = ((SV_REFFREQUENCY / SV_ADCMULT) * xm) / xn;
500 			if (xr >= rate)
501 				xd = xr - rate;
502 			else
503 				xd = rate - xr;
504 			if (xd < metric) {
505 				metric = xd;
506 				m = xm - 2;
507 				n = xn - 2;
508 			}
509 		}
510 	*res_r = r;
511 	*res_m = m;
512 	*res_n = n;
513 #if 0
514 	printk(KERN_DEBUG "metric = %i, xm = %i, xn = %i\n", metric, xm, xn);
515 	printk(KERN_DEBUG "pll: m = 0x%x, r = 0x%x, n = 0x%x\n", reg, m, r, n);
516 #endif
517 }
518 
519 static void snd_sonicvibes_setpll(struct sonicvibes * sonic,
520                                   unsigned char reg,
521                                   unsigned int rate)
522 {
523 	unsigned long flags;
524 	unsigned int r, m, n;
525 
526 	snd_sonicvibes_pll(rate, &r, &m, &n);
527 	if (sonic != NULL) {
528 		spin_lock_irqsave(&sonic->reg_lock, flags);
529 		snd_sonicvibes_out1(sonic, reg, m);
530 		snd_sonicvibes_out1(sonic, reg + 1, r | n);
531 		spin_unlock_irqrestore(&sonic->reg_lock, flags);
532 	}
533 }
534 
535 static void snd_sonicvibes_set_adc_rate(struct sonicvibes * sonic, unsigned int rate)
536 {
537 	unsigned long flags;
538 	unsigned int div;
539 	unsigned char clock;
540 
541 	div = 48000 / rate;
542 	if (div > 8)
543 		div = 8;
544 	if ((48000 / div) == rate) {	/* use the alternate clock */
545 		clock = 0x10;
546 	} else {			/* use the PLL source */
547 		clock = 0x00;
548 		snd_sonicvibes_setpll(sonic, SV_IREG_ADC_PLL, rate);
549 	}
550 	spin_lock_irqsave(&sonic->reg_lock, flags);
551 	snd_sonicvibes_out1(sonic, SV_IREG_ADC_ALT_RATE, (div - 1) << 4);
552 	snd_sonicvibes_out1(sonic, SV_IREG_ADC_CLOCK, clock);
553 	spin_unlock_irqrestore(&sonic->reg_lock, flags);
554 }
555 
556 static int snd_sonicvibes_hw_constraint_dac_rate(struct snd_pcm_hw_params *params,
557 						 struct snd_pcm_hw_rule *rule)
558 {
559 	unsigned int rate, div, r, m, n;
560 
561 	if (hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min ==
562 	    hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max) {
563 		rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min;
564 		div = 48000 / rate;
565 		if (div > 8)
566 			div = 8;
567 		if ((48000 / div) == rate) {
568 			params->rate_num = rate;
569 			params->rate_den = 1;
570 		} else {
571 			snd_sonicvibes_pll(rate, &r, &m, &n);
572 			snd_BUG_ON(SV_REFFREQUENCY % 16);
573 			snd_BUG_ON(SV_ADCMULT % 512);
574 			params->rate_num = (SV_REFFREQUENCY/16) * (n+2) * r;
575 			params->rate_den = (SV_ADCMULT/512) * (m+2);
576 		}
577 	}
578 	return 0;
579 }
580 
581 static void snd_sonicvibes_set_dac_rate(struct sonicvibes * sonic, unsigned int rate)
582 {
583 	unsigned int div;
584 	unsigned long flags;
585 
586 	div = (rate * 65536 + SV_FULLRATE / 2) / SV_FULLRATE;
587 	if (div > 65535)
588 		div = 65535;
589 	spin_lock_irqsave(&sonic->reg_lock, flags);
590 	snd_sonicvibes_out1(sonic, SV_IREG_PCM_RATE_HIGH, div >> 8);
591 	snd_sonicvibes_out1(sonic, SV_IREG_PCM_RATE_LOW, div);
592 	spin_unlock_irqrestore(&sonic->reg_lock, flags);
593 }
594 
595 static int snd_sonicvibes_trigger(struct sonicvibes * sonic, int what, int cmd)
596 {
597 	int result = 0;
598 
599 	spin_lock(&sonic->reg_lock);
600 	if (cmd == SNDRV_PCM_TRIGGER_START) {
601 		if (!(sonic->enable & what)) {
602 			sonic->enable |= what;
603 			snd_sonicvibes_out1(sonic, SV_IREG_PC_ENABLE, sonic->enable);
604 		}
605 	} else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
606 		if (sonic->enable & what) {
607 			sonic->enable &= ~what;
608 			snd_sonicvibes_out1(sonic, SV_IREG_PC_ENABLE, sonic->enable);
609 		}
610 	} else {
611 		result = -EINVAL;
612 	}
613 	spin_unlock(&sonic->reg_lock);
614 	return result;
615 }
616 
617 static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id)
618 {
619 	struct sonicvibes *sonic = dev_id;
620 	unsigned char status;
621 
622 	status = inb(SV_REG(sonic, STATUS));
623 	if (!(status & (SV_DMAA_IRQ | SV_DMAC_IRQ | SV_MIDI_IRQ)))
624 		return IRQ_NONE;
625 	if (status == 0xff) {	/* failure */
626 		outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK));
627 		snd_printk(KERN_ERR "IRQ failure - interrupts disabled!!\n");
628 		return IRQ_HANDLED;
629 	}
630 	if (sonic->pcm) {
631 		if (status & SV_DMAA_IRQ)
632 			snd_pcm_period_elapsed(sonic->playback_substream);
633 		if (status & SV_DMAC_IRQ)
634 			snd_pcm_period_elapsed(sonic->capture_substream);
635 	}
636 	if (sonic->rmidi) {
637 		if (status & SV_MIDI_IRQ)
638 			snd_mpu401_uart_interrupt(irq, sonic->rmidi->private_data);
639 	}
640 	if (status & SV_UD_IRQ) {
641 		unsigned char udreg;
642 		int vol, oleft, oright, mleft, mright;
643 
644 		spin_lock(&sonic->reg_lock);
645 		udreg = snd_sonicvibes_in1(sonic, SV_IREG_UD_BUTTON);
646 		vol = udreg & 0x3f;
647 		if (!(udreg & 0x40))
648 			vol = -vol;
649 		oleft = mleft = snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ANALOG);
650 		oright = mright = snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ANALOG);
651 		oleft &= 0x1f;
652 		oright &= 0x1f;
653 		oleft += vol;
654 		if (oleft < 0)
655 			oleft = 0;
656 		if (oleft > 0x1f)
657 			oleft = 0x1f;
658 		oright += vol;
659 		if (oright < 0)
660 			oright = 0;
661 		if (oright > 0x1f)
662 			oright = 0x1f;
663 		if (udreg & 0x80) {
664 			mleft ^= 0x80;
665 			mright ^= 0x80;
666 		}
667 		oleft |= mleft & 0x80;
668 		oright |= mright & 0x80;
669 		snd_sonicvibes_out1(sonic, SV_IREG_LEFT_ANALOG, oleft);
670 		snd_sonicvibes_out1(sonic, SV_IREG_RIGHT_ANALOG, oright);
671 		spin_unlock(&sonic->reg_lock);
672 		snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_mute->id);
673 		snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_volume->id);
674 	}
675 	return IRQ_HANDLED;
676 }
677 
678 /*
679  *  PCM part
680  */
681 
682 static int snd_sonicvibes_playback_trigger(struct snd_pcm_substream *substream,
683 					   int cmd)
684 {
685 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
686 	return snd_sonicvibes_trigger(sonic, 1, cmd);
687 }
688 
689 static int snd_sonicvibes_capture_trigger(struct snd_pcm_substream *substream,
690 					  int cmd)
691 {
692 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
693 	return snd_sonicvibes_trigger(sonic, 2, cmd);
694 }
695 
696 static int snd_sonicvibes_hw_params(struct snd_pcm_substream *substream,
697 				    struct snd_pcm_hw_params *hw_params)
698 {
699 	return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
700 }
701 
702 static int snd_sonicvibes_hw_free(struct snd_pcm_substream *substream)
703 {
704 	return snd_pcm_lib_free_pages(substream);
705 }
706 
707 static int snd_sonicvibes_playback_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->p_dma_size = size;
716 	count--;
717 	if (runtime->channels > 1)
718 		fmt |= 1;
719 	if (snd_pcm_format_width(runtime->format) == 16)
720 		fmt |= 2;
721 	snd_sonicvibes_setfmt(sonic, ~3, fmt);
722 	snd_sonicvibes_set_dac_rate(sonic, runtime->rate);
723 	spin_lock_irq(&sonic->reg_lock);
724 	snd_sonicvibes_setdmaa(sonic, runtime->dma_addr, size);
725 	snd_sonicvibes_out1(sonic, SV_IREG_DMA_A_UPPER, count >> 8);
726 	snd_sonicvibes_out1(sonic, SV_IREG_DMA_A_LOWER, count);
727 	spin_unlock_irq(&sonic->reg_lock);
728 	return 0;
729 }
730 
731 static int snd_sonicvibes_capture_prepare(struct snd_pcm_substream *substream)
732 {
733 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
734 	struct snd_pcm_runtime *runtime = substream->runtime;
735 	unsigned char fmt = 0;
736 	unsigned int size = snd_pcm_lib_buffer_bytes(substream);
737 	unsigned int count = snd_pcm_lib_period_bytes(substream);
738 
739 	sonic->c_dma_size = size;
740 	count >>= 1;
741 	count--;
742 	if (runtime->channels > 1)
743 		fmt |= 0x10;
744 	if (snd_pcm_format_width(runtime->format) == 16)
745 		fmt |= 0x20;
746 	snd_sonicvibes_setfmt(sonic, ~0x30, fmt);
747 	snd_sonicvibes_set_adc_rate(sonic, runtime->rate);
748 	spin_lock_irq(&sonic->reg_lock);
749 	snd_sonicvibes_setdmac(sonic, runtime->dma_addr, size);
750 	snd_sonicvibes_out1(sonic, SV_IREG_DMA_C_UPPER, count >> 8);
751 	snd_sonicvibes_out1(sonic, SV_IREG_DMA_C_LOWER, count);
752 	spin_unlock_irq(&sonic->reg_lock);
753 	return 0;
754 }
755 
756 static snd_pcm_uframes_t snd_sonicvibes_playback_pointer(struct snd_pcm_substream *substream)
757 {
758 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
759 	size_t ptr;
760 
761 	if (!(sonic->enable & 1))
762 		return 0;
763 	ptr = sonic->p_dma_size - snd_sonicvibes_getdmaa(sonic);
764 	return bytes_to_frames(substream->runtime, ptr);
765 }
766 
767 static snd_pcm_uframes_t snd_sonicvibes_capture_pointer(struct snd_pcm_substream *substream)
768 {
769 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
770 	size_t ptr;
771 	if (!(sonic->enable & 2))
772 		return 0;
773 	ptr = sonic->c_dma_size - snd_sonicvibes_getdmac(sonic);
774 	return bytes_to_frames(substream->runtime, ptr);
775 }
776 
777 static struct snd_pcm_hardware snd_sonicvibes_playback =
778 {
779 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
780 				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
781 				 SNDRV_PCM_INFO_MMAP_VALID),
782 	.formats =		SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
783 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
784 	.rate_min =		4000,
785 	.rate_max =		48000,
786 	.channels_min =		1,
787 	.channels_max =		2,
788 	.buffer_bytes_max =	(128*1024),
789 	.period_bytes_min =	32,
790 	.period_bytes_max =	(128*1024),
791 	.periods_min =		1,
792 	.periods_max =		1024,
793 	.fifo_size =		0,
794 };
795 
796 static struct snd_pcm_hardware snd_sonicvibes_capture =
797 {
798 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
799 				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
800 				 SNDRV_PCM_INFO_MMAP_VALID),
801 	.formats =		SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
802 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
803 	.rate_min =		4000,
804 	.rate_max =		48000,
805 	.channels_min =		1,
806 	.channels_max =		2,
807 	.buffer_bytes_max =	(128*1024),
808 	.period_bytes_min =	32,
809 	.period_bytes_max =	(128*1024),
810 	.periods_min =		1,
811 	.periods_max =		1024,
812 	.fifo_size =		0,
813 };
814 
815 static int snd_sonicvibes_playback_open(struct snd_pcm_substream *substream)
816 {
817 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
818 	struct snd_pcm_runtime *runtime = substream->runtime;
819 
820 	sonic->mode |= SV_MODE_PLAY;
821 	sonic->playback_substream = substream;
822 	runtime->hw = snd_sonicvibes_playback;
823 	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);
824 	return 0;
825 }
826 
827 static int snd_sonicvibes_capture_open(struct snd_pcm_substream *substream)
828 {
829 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
830 	struct snd_pcm_runtime *runtime = substream->runtime;
831 
832 	sonic->mode |= SV_MODE_CAPTURE;
833 	sonic->capture_substream = substream;
834 	runtime->hw = snd_sonicvibes_capture;
835 	snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
836 				      &snd_sonicvibes_hw_constraints_adc_clock);
837 	return 0;
838 }
839 
840 static int snd_sonicvibes_playback_close(struct snd_pcm_substream *substream)
841 {
842 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
843 
844 	sonic->playback_substream = NULL;
845 	sonic->mode &= ~SV_MODE_PLAY;
846 	return 0;
847 }
848 
849 static int snd_sonicvibes_capture_close(struct snd_pcm_substream *substream)
850 {
851 	struct sonicvibes *sonic = snd_pcm_substream_chip(substream);
852 
853 	sonic->capture_substream = NULL;
854 	sonic->mode &= ~SV_MODE_CAPTURE;
855 	return 0;
856 }
857 
858 static struct snd_pcm_ops snd_sonicvibes_playback_ops = {
859 	.open =		snd_sonicvibes_playback_open,
860 	.close =	snd_sonicvibes_playback_close,
861 	.ioctl =	snd_pcm_lib_ioctl,
862 	.hw_params =	snd_sonicvibes_hw_params,
863 	.hw_free =	snd_sonicvibes_hw_free,
864 	.prepare =	snd_sonicvibes_playback_prepare,
865 	.trigger =	snd_sonicvibes_playback_trigger,
866 	.pointer =	snd_sonicvibes_playback_pointer,
867 };
868 
869 static struct snd_pcm_ops snd_sonicvibes_capture_ops = {
870 	.open =		snd_sonicvibes_capture_open,
871 	.close =	snd_sonicvibes_capture_close,
872 	.ioctl =	snd_pcm_lib_ioctl,
873 	.hw_params =	snd_sonicvibes_hw_params,
874 	.hw_free =	snd_sonicvibes_hw_free,
875 	.prepare =	snd_sonicvibes_capture_prepare,
876 	.trigger =	snd_sonicvibes_capture_trigger,
877 	.pointer =	snd_sonicvibes_capture_pointer,
878 };
879 
880 static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device,
881 			      struct snd_pcm **rpcm)
882 {
883 	struct snd_pcm *pcm;
884 	int err;
885 
886 	if ((err = snd_pcm_new(sonic->card, "s3_86c617", device, 1, 1, &pcm)) < 0)
887 		return err;
888 	if (snd_BUG_ON(!pcm))
889 		return -EINVAL;
890 
891 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sonicvibes_playback_ops);
892 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sonicvibes_capture_ops);
893 
894 	pcm->private_data = sonic;
895 	pcm->info_flags = 0;
896 	strcpy(pcm->name, "S3 SonicVibes");
897 	sonic->pcm = pcm;
898 
899 	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
900 					      snd_dma_pci_data(sonic->pci), 64*1024, 128*1024);
901 
902 	if (rpcm)
903 		*rpcm = pcm;
904 	return 0;
905 }
906 
907 /*
908  *  Mixer part
909  */
910 
911 #define SONICVIBES_MUX(xname, xindex) \
912 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
913   .info = snd_sonicvibes_info_mux, \
914   .get = snd_sonicvibes_get_mux, .put = snd_sonicvibes_put_mux }
915 
916 static int snd_sonicvibes_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
917 {
918 	static char *texts[7] = {
919 		"CD", "PCM", "Aux1", "Line", "Aux0", "Mic", "Mix"
920 	};
921 
922 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
923 	uinfo->count = 2;
924 	uinfo->value.enumerated.items = 7;
925 	if (uinfo->value.enumerated.item >= 7)
926 		uinfo->value.enumerated.item = 6;
927 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
928 	return 0;
929 }
930 
931 static int snd_sonicvibes_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
932 {
933 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
934 
935 	spin_lock_irq(&sonic->reg_lock);
936 	ucontrol->value.enumerated.item[0] = ((snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ADC) & SV_RECSRC_OUT) >> 5) - 1;
937 	ucontrol->value.enumerated.item[1] = ((snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ADC) & SV_RECSRC_OUT) >> 5) - 1;
938 	spin_unlock_irq(&sonic->reg_lock);
939 	return 0;
940 }
941 
942 static int snd_sonicvibes_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
943 {
944 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
945 	unsigned short left, right, oval1, oval2;
946 	int change;
947 
948 	if (ucontrol->value.enumerated.item[0] >= 7 ||
949 	    ucontrol->value.enumerated.item[1] >= 7)
950 		return -EINVAL;
951 	left = (ucontrol->value.enumerated.item[0] + 1) << 5;
952 	right = (ucontrol->value.enumerated.item[1] + 1) << 5;
953 	spin_lock_irq(&sonic->reg_lock);
954 	oval1 = snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ADC);
955 	oval2 = snd_sonicvibes_in1(sonic, SV_IREG_RIGHT_ADC);
956 	left = (oval1 & ~SV_RECSRC_OUT) | left;
957 	right = (oval2 & ~SV_RECSRC_OUT) | right;
958 	change = left != oval1 || right != oval2;
959 	snd_sonicvibes_out1(sonic, SV_IREG_LEFT_ADC, left);
960 	snd_sonicvibes_out1(sonic, SV_IREG_RIGHT_ADC, right);
961 	spin_unlock_irq(&sonic->reg_lock);
962 	return change;
963 }
964 
965 #define SONICVIBES_SINGLE(xname, xindex, reg, shift, mask, invert) \
966 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
967   .info = snd_sonicvibes_info_single, \
968   .get = snd_sonicvibes_get_single, .put = snd_sonicvibes_put_single, \
969   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
970 
971 static int snd_sonicvibes_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
972 {
973 	int mask = (kcontrol->private_value >> 16) & 0xff;
974 
975 	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
976 	uinfo->count = 1;
977 	uinfo->value.integer.min = 0;
978 	uinfo->value.integer.max = mask;
979 	return 0;
980 }
981 
982 static int snd_sonicvibes_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
983 {
984 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
985 	int reg = kcontrol->private_value & 0xff;
986 	int shift = (kcontrol->private_value >> 8) & 0xff;
987 	int mask = (kcontrol->private_value >> 16) & 0xff;
988 	int invert = (kcontrol->private_value >> 24) & 0xff;
989 
990 	spin_lock_irq(&sonic->reg_lock);
991 	ucontrol->value.integer.value[0] = (snd_sonicvibes_in1(sonic, reg)>> shift) & mask;
992 	spin_unlock_irq(&sonic->reg_lock);
993 	if (invert)
994 		ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
995 	return 0;
996 }
997 
998 static int snd_sonicvibes_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
999 {
1000 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
1001 	int reg = kcontrol->private_value & 0xff;
1002 	int shift = (kcontrol->private_value >> 8) & 0xff;
1003 	int mask = (kcontrol->private_value >> 16) & 0xff;
1004 	int invert = (kcontrol->private_value >> 24) & 0xff;
1005 	int change;
1006 	unsigned short val, oval;
1007 
1008 	val = (ucontrol->value.integer.value[0] & mask);
1009 	if (invert)
1010 		val = mask - val;
1011 	val <<= shift;
1012 	spin_lock_irq(&sonic->reg_lock);
1013 	oval = snd_sonicvibes_in1(sonic, reg);
1014 	val = (oval & ~(mask << shift)) | val;
1015 	change = val != oval;
1016 	snd_sonicvibes_out1(sonic, reg, val);
1017 	spin_unlock_irq(&sonic->reg_lock);
1018 	return change;
1019 }
1020 
1021 #define SONICVIBES_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1022 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1023   .info = snd_sonicvibes_info_double, \
1024   .get = snd_sonicvibes_get_double, .put = snd_sonicvibes_put_double, \
1025   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1026 
1027 static int snd_sonicvibes_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1028 {
1029 	int mask = (kcontrol->private_value >> 24) & 0xff;
1030 
1031 	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1032 	uinfo->count = 2;
1033 	uinfo->value.integer.min = 0;
1034 	uinfo->value.integer.max = mask;
1035 	return 0;
1036 }
1037 
1038 static int snd_sonicvibes_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1039 {
1040 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
1041 	int left_reg = kcontrol->private_value & 0xff;
1042 	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1043 	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1044 	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1045 	int mask = (kcontrol->private_value >> 24) & 0xff;
1046 	int invert = (kcontrol->private_value >> 22) & 1;
1047 
1048 	spin_lock_irq(&sonic->reg_lock);
1049 	ucontrol->value.integer.value[0] = (snd_sonicvibes_in1(sonic, left_reg) >> shift_left) & mask;
1050 	ucontrol->value.integer.value[1] = (snd_sonicvibes_in1(sonic, right_reg) >> shift_right) & mask;
1051 	spin_unlock_irq(&sonic->reg_lock);
1052 	if (invert) {
1053 		ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1054 		ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1055 	}
1056 	return 0;
1057 }
1058 
1059 static int snd_sonicvibes_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1060 {
1061 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
1062 	int left_reg = kcontrol->private_value & 0xff;
1063 	int right_reg = (kcontrol->private_value >> 8) & 0xff;
1064 	int shift_left = (kcontrol->private_value >> 16) & 0x07;
1065 	int shift_right = (kcontrol->private_value >> 19) & 0x07;
1066 	int mask = (kcontrol->private_value >> 24) & 0xff;
1067 	int invert = (kcontrol->private_value >> 22) & 1;
1068 	int change;
1069 	unsigned short val1, val2, oval1, oval2;
1070 
1071 	val1 = ucontrol->value.integer.value[0] & mask;
1072 	val2 = ucontrol->value.integer.value[1] & mask;
1073 	if (invert) {
1074 		val1 = mask - val1;
1075 		val2 = mask - val2;
1076 	}
1077 	val1 <<= shift_left;
1078 	val2 <<= shift_right;
1079 	spin_lock_irq(&sonic->reg_lock);
1080 	oval1 = snd_sonicvibes_in1(sonic, left_reg);
1081 	oval2 = snd_sonicvibes_in1(sonic, right_reg);
1082 	val1 = (oval1 & ~(mask << shift_left)) | val1;
1083 	val2 = (oval2 & ~(mask << shift_right)) | val2;
1084 	change = val1 != oval1 || val2 != oval2;
1085 	snd_sonicvibes_out1(sonic, left_reg, val1);
1086 	snd_sonicvibes_out1(sonic, right_reg, val2);
1087 	spin_unlock_irq(&sonic->reg_lock);
1088 	return change;
1089 }
1090 
1091 static struct snd_kcontrol_new snd_sonicvibes_controls[] = {
1092 SONICVIBES_DOUBLE("Capture Volume", 0, SV_IREG_LEFT_ADC, SV_IREG_RIGHT_ADC, 0, 0, 15, 0),
1093 SONICVIBES_DOUBLE("Aux Playback Switch", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 7, 7, 1, 1),
1094 SONICVIBES_DOUBLE("Aux Playback Volume", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 0, 0, 31, 1),
1095 SONICVIBES_DOUBLE("CD Playback Switch", 0, SV_IREG_LEFT_CD, SV_IREG_RIGHT_CD, 7, 7, 1, 1),
1096 SONICVIBES_DOUBLE("CD Playback Volume", 0, SV_IREG_LEFT_CD, SV_IREG_RIGHT_CD, 0, 0, 31, 1),
1097 SONICVIBES_DOUBLE("Line Playback Switch", 0, SV_IREG_LEFT_LINE, SV_IREG_RIGHT_LINE, 7, 7, 1, 1),
1098 SONICVIBES_DOUBLE("Line Playback Volume", 0, SV_IREG_LEFT_LINE, SV_IREG_RIGHT_LINE, 0, 0, 31, 1),
1099 SONICVIBES_SINGLE("Mic Playback Switch", 0, SV_IREG_MIC, 7, 1, 1),
1100 SONICVIBES_SINGLE("Mic Playback Volume", 0, SV_IREG_MIC, 0, 15, 1),
1101 SONICVIBES_SINGLE("Mic Boost", 0, SV_IREG_LEFT_ADC, 4, 1, 0),
1102 SONICVIBES_DOUBLE("Synth Playback Switch", 0, SV_IREG_LEFT_SYNTH, SV_IREG_RIGHT_SYNTH, 7, 7, 1, 1),
1103 SONICVIBES_DOUBLE("Synth Playback Volume", 0, SV_IREG_LEFT_SYNTH, SV_IREG_RIGHT_SYNTH, 0, 0, 31, 1),
1104 SONICVIBES_DOUBLE("Aux Playback Switch", 1, SV_IREG_LEFT_AUX2, SV_IREG_RIGHT_AUX2, 7, 7, 1, 1),
1105 SONICVIBES_DOUBLE("Aux Playback Volume", 1, SV_IREG_LEFT_AUX2, SV_IREG_RIGHT_AUX2, 0, 0, 31, 1),
1106 SONICVIBES_DOUBLE("Master Playback Switch", 0, SV_IREG_LEFT_ANALOG, SV_IREG_RIGHT_ANALOG, 7, 7, 1, 1),
1107 SONICVIBES_DOUBLE("Master Playback Volume", 0, SV_IREG_LEFT_ANALOG, SV_IREG_RIGHT_ANALOG, 0, 0, 31, 1),
1108 SONICVIBES_DOUBLE("PCM Playback Switch", 0, SV_IREG_LEFT_PCM, SV_IREG_RIGHT_PCM, 7, 7, 1, 1),
1109 SONICVIBES_DOUBLE("PCM Playback Volume", 0, SV_IREG_LEFT_PCM, SV_IREG_RIGHT_PCM, 0, 0, 63, 1),
1110 SONICVIBES_SINGLE("Loopback Capture Switch", 0, SV_IREG_ADC_OUTPUT_CTRL, 0, 1, 0),
1111 SONICVIBES_SINGLE("Loopback Capture Volume", 0, SV_IREG_ADC_OUTPUT_CTRL, 2, 63, 1),
1112 SONICVIBES_MUX("Capture Source", 0)
1113 };
1114 
1115 static void snd_sonicvibes_master_free(struct snd_kcontrol *kcontrol)
1116 {
1117 	struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol);
1118 	sonic->master_mute = NULL;
1119 	sonic->master_volume = NULL;
1120 }
1121 
1122 static int snd_sonicvibes_mixer(struct sonicvibes *sonic)
1123 {
1124 	struct snd_card *card;
1125 	struct snd_kcontrol *kctl;
1126 	unsigned int idx;
1127 	int err;
1128 
1129 	if (snd_BUG_ON(!sonic || !sonic->card))
1130 		return -EINVAL;
1131 	card = sonic->card;
1132 	strcpy(card->mixername, "S3 SonicVibes");
1133 
1134 	for (idx = 0; idx < ARRAY_SIZE(snd_sonicvibes_controls); idx++) {
1135 		if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_sonicvibes_controls[idx], sonic))) < 0)
1136 			return err;
1137 		switch (idx) {
1138 		case 0:
1139 		case 1: kctl->private_free = snd_sonicvibes_master_free; break;
1140 		}
1141 	}
1142 	return 0;
1143 }
1144 
1145 /*
1146 
1147  */
1148 
1149 static void snd_sonicvibes_proc_read(struct snd_info_entry *entry,
1150 				     struct snd_info_buffer *buffer)
1151 {
1152 	struct sonicvibes *sonic = entry->private_data;
1153 	unsigned char tmp;
1154 
1155 	tmp = sonic->srs_space & 0x0f;
1156 	snd_iprintf(buffer, "SRS 3D           : %s\n",
1157 		    sonic->srs_space & 0x80 ? "off" : "on");
1158 	snd_iprintf(buffer, "SRS Space        : %s\n",
1159 		    tmp == 0x00 ? "100%" :
1160 		    tmp == 0x01 ? "75%" :
1161 		    tmp == 0x02 ? "50%" :
1162 		    tmp == 0x03 ? "25%" : "0%");
1163 	tmp = sonic->srs_center & 0x0f;
1164 	snd_iprintf(buffer, "SRS Center       : %s\n",
1165 		    tmp == 0x00 ? "100%" :
1166 		    tmp == 0x01 ? "75%" :
1167 		    tmp == 0x02 ? "50%" :
1168 		    tmp == 0x03 ? "25%" : "0%");
1169 	tmp = sonic->wave_source & 0x03;
1170 	snd_iprintf(buffer, "WaveTable Source : %s\n",
1171 		    tmp == 0x00 ? "on-board ROM" :
1172 		    tmp == 0x01 ? "PCI bus" : "on-board ROM + PCI bus");
1173 	tmp = sonic->mpu_switch;
1174 	snd_iprintf(buffer, "Onboard synth    : %s\n", tmp & 0x01 ? "on" : "off");
1175 	snd_iprintf(buffer, "Ext. Rx to synth : %s\n", tmp & 0x02 ? "on" : "off");
1176 	snd_iprintf(buffer, "MIDI to ext. Tx  : %s\n", tmp & 0x04 ? "on" : "off");
1177 }
1178 
1179 static void snd_sonicvibes_proc_init(struct sonicvibes *sonic)
1180 {
1181 	struct snd_info_entry *entry;
1182 
1183 	if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
1184 		snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
1185 }
1186 
1187 /*
1188 
1189  */
1190 
1191 #ifdef SUPPORT_JOYSTICK
1192 static struct snd_kcontrol_new snd_sonicvibes_game_control =
1193 SONICVIBES_SINGLE("Joystick Speed", 0, SV_IREG_GAME_PORT, 1, 15, 0);
1194 
1195 static int snd_sonicvibes_create_gameport(struct sonicvibes *sonic)
1196 {
1197 	struct gameport *gp;
1198 
1199 	sonic->gameport = gp = gameport_allocate_port();
1200 	if (!gp) {
1201 		printk(KERN_ERR "sonicvibes: cannot allocate memory for gameport\n");
1202 		return -ENOMEM;
1203 	}
1204 
1205 	gameport_set_name(gp, "SonicVibes Gameport");
1206 	gameport_set_phys(gp, "pci%s/gameport0", pci_name(sonic->pci));
1207 	gameport_set_dev_parent(gp, &sonic->pci->dev);
1208 	gp->io = sonic->game_port;
1209 
1210 	gameport_register_port(gp);
1211 
1212 	snd_ctl_add(sonic->card, snd_ctl_new1(&snd_sonicvibes_game_control, sonic));
1213 
1214 	return 0;
1215 }
1216 
1217 static void snd_sonicvibes_free_gameport(struct sonicvibes *sonic)
1218 {
1219 	if (sonic->gameport) {
1220 		gameport_unregister_port(sonic->gameport);
1221 		sonic->gameport = NULL;
1222 	}
1223 }
1224 #else
1225 static inline int snd_sonicvibes_create_gameport(struct sonicvibes *sonic) { return -ENOSYS; }
1226 static inline void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) { }
1227 #endif
1228 
1229 static int snd_sonicvibes_free(struct sonicvibes *sonic)
1230 {
1231 	snd_sonicvibes_free_gameport(sonic);
1232 	pci_write_config_dword(sonic->pci, 0x40, sonic->dmaa_port);
1233 	pci_write_config_dword(sonic->pci, 0x48, sonic->dmac_port);
1234 	if (sonic->irq >= 0)
1235 		free_irq(sonic->irq, sonic);
1236 	release_and_free_resource(sonic->res_dmaa);
1237 	release_and_free_resource(sonic->res_dmac);
1238 	pci_release_regions(sonic->pci);
1239 	pci_disable_device(sonic->pci);
1240 	kfree(sonic);
1241 	return 0;
1242 }
1243 
1244 static int snd_sonicvibes_dev_free(struct snd_device *device)
1245 {
1246 	struct sonicvibes *sonic = device->device_data;
1247 	return snd_sonicvibes_free(sonic);
1248 }
1249 
1250 static int snd_sonicvibes_create(struct snd_card *card,
1251 				 struct pci_dev *pci,
1252 				 int reverb,
1253 				 int mge,
1254 				 struct sonicvibes **rsonic)
1255 {
1256 	struct sonicvibes *sonic;
1257 	unsigned int dmaa, dmac;
1258 	int err;
1259 	static struct snd_device_ops ops = {
1260 		.dev_free =	snd_sonicvibes_dev_free,
1261 	};
1262 
1263 	*rsonic = NULL;
1264 	/* enable PCI device */
1265 	if ((err = pci_enable_device(pci)) < 0)
1266 		return err;
1267 	/* check, if we can restrict PCI DMA transfers to 24 bits */
1268         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
1269 	    pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
1270 		snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
1271 		pci_disable_device(pci);
1272                 return -ENXIO;
1273         }
1274 
1275 	sonic = kzalloc(sizeof(*sonic), GFP_KERNEL);
1276 	if (sonic == NULL) {
1277 		pci_disable_device(pci);
1278 		return -ENOMEM;
1279 	}
1280 	spin_lock_init(&sonic->reg_lock);
1281 	sonic->card = card;
1282 	sonic->pci = pci;
1283 	sonic->irq = -1;
1284 
1285 	if ((err = pci_request_regions(pci, "S3 SonicVibes")) < 0) {
1286 		kfree(sonic);
1287 		pci_disable_device(pci);
1288 		return err;
1289 	}
1290 
1291 	sonic->sb_port = pci_resource_start(pci, 0);
1292 	sonic->enh_port = pci_resource_start(pci, 1);
1293 	sonic->synth_port = pci_resource_start(pci, 2);
1294 	sonic->midi_port = pci_resource_start(pci, 3);
1295 	sonic->game_port = pci_resource_start(pci, 4);
1296 
1297 	if (request_irq(pci->irq, snd_sonicvibes_interrupt, IRQF_SHARED,
1298 			KBUILD_MODNAME, sonic)) {
1299 		snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1300 		snd_sonicvibes_free(sonic);
1301 		return -EBUSY;
1302 	}
1303 	sonic->irq = pci->irq;
1304 
1305 	pci_read_config_dword(pci, 0x40, &dmaa);
1306 	pci_read_config_dword(pci, 0x48, &dmac);
1307 	dmaio &= ~0x0f;
1308 	dmaa &= ~0x0f;
1309 	dmac &= ~0x0f;
1310 	if (!dmaa) {
1311 		dmaa = dmaio;
1312 		dmaio += 0x10;
1313 		snd_printk(KERN_INFO "BIOS did not allocate DDMA channel A i/o, allocated at 0x%x\n", dmaa);
1314 	}
1315 	if (!dmac) {
1316 		dmac = dmaio;
1317 		dmaio += 0x10;
1318 		snd_printk(KERN_INFO "BIOS did not allocate DDMA channel C i/o, allocated at 0x%x\n", dmac);
1319 	}
1320 	pci_write_config_dword(pci, 0x40, dmaa);
1321 	pci_write_config_dword(pci, 0x48, dmac);
1322 
1323 	if ((sonic->res_dmaa = request_region(dmaa, 0x10, "S3 SonicVibes DDMA-A")) == NULL) {
1324 		snd_sonicvibes_free(sonic);
1325 		snd_printk(KERN_ERR "unable to grab DDMA-A port at 0x%x-0x%x\n", dmaa, dmaa + 0x10 - 1);
1326 		return -EBUSY;
1327 	}
1328 	if ((sonic->res_dmac = request_region(dmac, 0x10, "S3 SonicVibes DDMA-C")) == NULL) {
1329 		snd_sonicvibes_free(sonic);
1330 		snd_printk(KERN_ERR "unable to grab DDMA-C port at 0x%x-0x%x\n", dmac, dmac + 0x10 - 1);
1331 		return -EBUSY;
1332 	}
1333 
1334 	pci_read_config_dword(pci, 0x40, &sonic->dmaa_port);
1335 	pci_read_config_dword(pci, 0x48, &sonic->dmac_port);
1336 	sonic->dmaa_port &= ~0x0f;
1337 	sonic->dmac_port &= ~0x0f;
1338 	pci_write_config_dword(pci, 0x40, sonic->dmaa_port | 9);	/* enable + enhanced */
1339 	pci_write_config_dword(pci, 0x48, sonic->dmac_port | 9);	/* enable */
1340 	/* ok.. initialize S3 SonicVibes chip */
1341 	outb(SV_RESET, SV_REG(sonic, CONTROL));		/* reset chip */
1342 	udelay(100);
1343 	outb(0, SV_REG(sonic, CONTROL));	/* release reset */
1344 	udelay(100);
1345 	outb(SV_ENHANCED | SV_INTA | (reverb ? SV_REVERB : 0), SV_REG(sonic, CONTROL));
1346 	inb(SV_REG(sonic, STATUS));	/* clear IRQs */
1347 #if 1
1348 	snd_sonicvibes_out(sonic, SV_IREG_DRIVE_CTRL, 0);	/* drive current 16mA */
1349 #else
1350 	snd_sonicvibes_out(sonic, SV_IREG_DRIVE_CTRL, 0x40);	/* drive current 8mA */
1351 #endif
1352 	snd_sonicvibes_out(sonic, SV_IREG_PC_ENABLE, sonic->enable = 0);	/* disable playback & capture */
1353 	outb(sonic->irqmask = ~(SV_DMAA_MASK | SV_DMAC_MASK | SV_UD_MASK), SV_REG(sonic, IRQMASK));
1354 	inb(SV_REG(sonic, STATUS));	/* clear IRQs */
1355 	snd_sonicvibes_out(sonic, SV_IREG_ADC_CLOCK, 0);	/* use PLL as clock source */
1356 	snd_sonicvibes_out(sonic, SV_IREG_ANALOG_POWER, 0);	/* power up analog parts */
1357 	snd_sonicvibes_out(sonic, SV_IREG_DIGITAL_POWER, 0);	/* power up digital parts */
1358 	snd_sonicvibes_setpll(sonic, SV_IREG_ADC_PLL, 8000);
1359 	snd_sonicvibes_out(sonic, SV_IREG_SRS_SPACE, sonic->srs_space = 0x80);	/* SRS space off */
1360 	snd_sonicvibes_out(sonic, SV_IREG_SRS_CENTER, sonic->srs_center = 0x00);/* SRS center off */
1361 	snd_sonicvibes_out(sonic, SV_IREG_MPU401, sonic->mpu_switch = 0x05);	/* MPU-401 switch */
1362 	snd_sonicvibes_out(sonic, SV_IREG_WAVE_SOURCE, sonic->wave_source = 0x00);	/* onboard ROM */
1363 	snd_sonicvibes_out(sonic, SV_IREG_PCM_RATE_LOW, (8000 * 65536 / SV_FULLRATE) & 0xff);
1364 	snd_sonicvibes_out(sonic, SV_IREG_PCM_RATE_HIGH, ((8000 * 65536 / SV_FULLRATE) >> 8) & 0xff);
1365 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_ADC, mge ? 0xd0 : 0xc0);
1366 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_ADC, 0xc0);
1367 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_AUX1, 0x9f);
1368 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_AUX1, 0x9f);
1369 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_CD, 0x9f);
1370 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_CD, 0x9f);
1371 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_LINE, 0x9f);
1372 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_LINE, 0x9f);
1373 	snd_sonicvibes_out(sonic, SV_IREG_MIC, 0x8f);
1374 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_SYNTH, 0x9f);
1375 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_SYNTH, 0x9f);
1376 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_AUX2, 0x9f);
1377 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_AUX2, 0x9f);
1378 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_ANALOG, 0x9f);
1379 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_ANALOG, 0x9f);
1380 	snd_sonicvibes_out(sonic, SV_IREG_LEFT_PCM, 0xbf);
1381 	snd_sonicvibes_out(sonic, SV_IREG_RIGHT_PCM, 0xbf);
1382 	snd_sonicvibes_out(sonic, SV_IREG_ADC_OUTPUT_CTRL, 0xfc);
1383 #if 0
1384 	snd_sonicvibes_debug(sonic);
1385 #endif
1386 	sonic->revision = snd_sonicvibes_in(sonic, SV_IREG_REVISION);
1387 
1388 	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, sonic, &ops)) < 0) {
1389 		snd_sonicvibes_free(sonic);
1390 		return err;
1391 	}
1392 
1393 	snd_sonicvibes_proc_init(sonic);
1394 
1395 	snd_card_set_dev(card, &pci->dev);
1396 
1397 	*rsonic = sonic;
1398 	return 0;
1399 }
1400 
1401 /*
1402  *  MIDI section
1403  */
1404 
1405 static struct snd_kcontrol_new snd_sonicvibes_midi_controls[] = {
1406 SONICVIBES_SINGLE("SonicVibes Wave Source RAM", 0, SV_IREG_WAVE_SOURCE, 0, 1, 0),
1407 SONICVIBES_SINGLE("SonicVibes Wave Source RAM+ROM", 0, SV_IREG_WAVE_SOURCE, 1, 1, 0),
1408 SONICVIBES_SINGLE("SonicVibes Onboard Synth", 0, SV_IREG_MPU401, 0, 1, 0),
1409 SONICVIBES_SINGLE("SonicVibes External Rx to Synth", 0, SV_IREG_MPU401, 1, 1, 0),
1410 SONICVIBES_SINGLE("SonicVibes External Tx", 0, SV_IREG_MPU401, 2, 1, 0)
1411 };
1412 
1413 static int snd_sonicvibes_midi_input_open(struct snd_mpu401 * mpu)
1414 {
1415 	struct sonicvibes *sonic = mpu->private_data;
1416 	outb(sonic->irqmask &= ~SV_MIDI_MASK, SV_REG(sonic, IRQMASK));
1417 	return 0;
1418 }
1419 
1420 static void snd_sonicvibes_midi_input_close(struct snd_mpu401 * mpu)
1421 {
1422 	struct sonicvibes *sonic = mpu->private_data;
1423 	outb(sonic->irqmask |= SV_MIDI_MASK, SV_REG(sonic, IRQMASK));
1424 }
1425 
1426 static int snd_sonicvibes_midi(struct sonicvibes *sonic,
1427 			       struct snd_rawmidi *rmidi)
1428 {
1429 	struct snd_mpu401 * mpu = rmidi->private_data;
1430 	struct snd_card *card = sonic->card;
1431 	struct snd_rawmidi_str *dir;
1432 	unsigned int idx;
1433 	int err;
1434 
1435 	mpu->private_data = sonic;
1436 	mpu->open_input = snd_sonicvibes_midi_input_open;
1437 	mpu->close_input = snd_sonicvibes_midi_input_close;
1438 	dir = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
1439 	for (idx = 0; idx < ARRAY_SIZE(snd_sonicvibes_midi_controls); idx++)
1440 		if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_sonicvibes_midi_controls[idx], sonic))) < 0)
1441 			return err;
1442 	return 0;
1443 }
1444 
1445 static int snd_sonic_probe(struct pci_dev *pci,
1446 			   const struct pci_device_id *pci_id)
1447 {
1448 	static int dev;
1449 	struct snd_card *card;
1450 	struct sonicvibes *sonic;
1451 	struct snd_rawmidi *midi_uart;
1452 	struct snd_opl3 *opl3;
1453 	int idx, err;
1454 
1455 	if (dev >= SNDRV_CARDS)
1456 		return -ENODEV;
1457 	if (!enable[dev]) {
1458 		dev++;
1459 		return -ENOENT;
1460 	}
1461 
1462 	err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
1463 	if (err < 0)
1464 		return err;
1465 	for (idx = 0; idx < 5; idx++) {
1466 		if (pci_resource_start(pci, idx) == 0 ||
1467 		    !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1468 			snd_card_free(card);
1469 			return -ENODEV;
1470 		}
1471 	}
1472 	if ((err = snd_sonicvibes_create(card, pci,
1473 					 reverb[dev] ? 1 : 0,
1474 					 mge[dev] ? 1 : 0,
1475 					 &sonic)) < 0) {
1476 		snd_card_free(card);
1477 		return err;
1478 	}
1479 
1480 	strcpy(card->driver, "SonicVibes");
1481 	strcpy(card->shortname, "S3 SonicVibes");
1482 	sprintf(card->longname, "%s rev %i at 0x%llx, irq %i",
1483 		card->shortname,
1484 		sonic->revision,
1485 		(unsigned long long)pci_resource_start(pci, 1),
1486 		sonic->irq);
1487 
1488 	if ((err = snd_sonicvibes_pcm(sonic, 0, NULL)) < 0) {
1489 		snd_card_free(card);
1490 		return err;
1491 	}
1492 	if ((err = snd_sonicvibes_mixer(sonic)) < 0) {
1493 		snd_card_free(card);
1494 		return err;
1495 	}
1496 	if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_SONICVIBES,
1497 				       sonic->midi_port,
1498 				       MPU401_INFO_INTEGRATED |
1499 				       MPU401_INFO_IRQ_HOOK,
1500 				       -1, &midi_uart)) < 0) {
1501 		snd_card_free(card);
1502 		return err;
1503 	}
1504 	snd_sonicvibes_midi(sonic, midi_uart);
1505 	if ((err = snd_opl3_create(card, sonic->synth_port,
1506 				   sonic->synth_port + 2,
1507 				   OPL3_HW_OPL3_SV, 1, &opl3)) < 0) {
1508 		snd_card_free(card);
1509 		return err;
1510 	}
1511 	if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1512 		snd_card_free(card);
1513 		return err;
1514 	}
1515 
1516 	snd_sonicvibes_create_gameport(sonic);
1517 
1518 	if ((err = snd_card_register(card)) < 0) {
1519 		snd_card_free(card);
1520 		return err;
1521 	}
1522 
1523 	pci_set_drvdata(pci, card);
1524 	dev++;
1525 	return 0;
1526 }
1527 
1528 static void snd_sonic_remove(struct pci_dev *pci)
1529 {
1530 	snd_card_free(pci_get_drvdata(pci));
1531 	pci_set_drvdata(pci, NULL);
1532 }
1533 
1534 static struct pci_driver sonicvibes_driver = {
1535 	.name = KBUILD_MODNAME,
1536 	.id_table = snd_sonic_ids,
1537 	.probe = snd_sonic_probe,
1538 	.remove = snd_sonic_remove,
1539 };
1540 
1541 module_pci_driver(sonicvibes_driver);
1542