1 /*****************************************************************************/
4 * sonicvibes.c -- S3 Sonic Vibes audio driver.
6 * Copyright (C) 1998-1999 Thomas Sailer (sailer@ife.ee.ethz.ch)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 * Special thanks to David C. Niemi
25 * Module command line parameters:
30 * /dev/dsp standard /dev/dsp device, (mostly) OSS compatible
31 * /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
32 * /dev/midi simple MIDI UART interface, no ioctl
34 * The card has both an FM and a Wavetable synth, but I have to figure
35 * out first how to drive them...
38 * 06.05.98 0.1 Initial release
39 * 10.05.98 0.2 Fixed many bugs, esp. ADC rate calculation
40 * First stab at a simple midi interface (no bells&whistles)
41 * 13.05.98 0.3 Fix stupid cut&paste error: set_adc_rate was called instead of
42 * set_dac_rate in the FMODE_WRITE case in sv_open
43 * Fix hwptr out of bounds (now mpg123 works)
44 * 14.05.98 0.4 Don't allow excessive interrupt rates
45 * 08.06.98 0.5 First release using Alan Cox' soundcore instead of miscdevice
46 * 03.08.98 0.6 Do not include modversions.h
47 * Now mixer behaviour can basically be selected between
48 * "OSS documented" and "OSS actual" behaviour
49 * 31.08.98 0.7 Fix realplayer problems - dac.count issues
50 * 10.12.98 0.8 Fix drain_dac trying to wait on not yet initialized DMA
51 * 16.12.98 0.9 Fix a few f_file & FMODE_ bugs
52 * 06.01.99 0.10 remove the silly SA_INTERRUPT flag.
53 * hopefully killed the egcs section type conflict
54 * 12.03.99 0.11 cinfo.blocks should be reset after GETxPTR ioctl.
55 * reported by Johan Maes <joma@telindus.be>
56 * 22.03.99 0.12 return EAGAIN instead of EBUSY when O_NONBLOCK
57 * read/write cannot be executed
58 * 05.04.99 0.13 added code to sv_read and sv_write which should detect
59 * lockups of the sound chip and revive it. This is basically
60 * an ugly hack, but at least applications using this driver
61 * won't hang forever. I don't know why these lockups happen,
62 * it might well be the motherboard chipset (an early 486 PCI
63 * board with ALI chipset), since every busmastering 100MB
64 * ethernet card I've tried (Realtek 8139 and Macronix tulip clone)
65 * exhibit similar behaviour (they work for a couple of packets
66 * and then lock up and can be revived by ifconfig down/up).
67 * 07.04.99 0.14 implemented the following ioctl's: SOUND_PCM_READ_RATE,
68 * SOUND_PCM_READ_CHANNELS, SOUND_PCM_READ_BITS;
69 * Alpha fixes reported by Peter Jones <pjones@redhat.com>
70 * Note: dmaio hack might still be wrong on archs other than i386
71 * 15.06.99 0.15 Fix bad allocation bug.
72 * Thanks to Deti Fliegl <fliegl@in.tum.de>
73 * 28.06.99 0.16 Add pci_set_master
74 * 03.08.99 0.17 adapt to Linus' new __setup/__initcall
75 * added kernel command line options "sonicvibes=reverb" and "sonicvibesdmaio=dmaioaddr"
76 * 12.08.99 0.18 module_init/__setup fixes
77 * 24.08.99 0.19 get rid of the dmaio kludge, replace with allocate_resource
78 * 31.08.99 0.20 add spin_lock_init
79 * __initlocaldata to fix gcc 2.7.x problems
80 * use new resource allocation to allocate DDMA IO space
81 * replaced current->state = x with set_current_state(x)
82 * 03.09.99 0.21 change read semantics for MIDI to match
83 * OSS more closely; remove possible wakeup race
87 /*****************************************************************************/
89 #include <linux/version.h>
90 #include <linux/module.h>
91 #include <linux/string.h>
92 #include <linux/ioport.h>
93 #include <linux/sched.h>
94 #include <linux/delay.h>
95 #include <linux/sound.h>
96 #include <linux/malloc.h>
97 #include <linux/soundcard.h>
98 #include <linux/pci.h>
101 #include <linux/init.h>
102 #include <linux/poll.h>
103 #include <linux/spinlock.h>
104 #include <asm/uaccess.h>
105 #include <asm/hardirq.h>
109 /* --------------------------------------------------------------------- */
111 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
113 /* --------------------------------------------------------------------- */
115 #ifndef PCI_VENDOR_ID_S3
116 #define PCI_VENDOR_ID_S3 0x5333
118 #ifndef PCI_DEVICE_ID_S3_SONICVIBES
119 #define PCI_DEVICE_ID_S3_SONICVIBES 0xca00
122 #define SV_MAGIC ((PCI_VENDOR_ID_S3<<16)|PCI_DEVICE_ID_S3_SONICVIBES)
124 #define SV_EXTENT_SB 0x10
125 #define SV_EXTENT_ENH 0x10
126 #define SV_EXTENT_SYNTH 0x4
127 #define SV_EXTENT_MIDI 0x4
128 #define SV_EXTENT_GAME 0x8
129 #define SV_EXTENT_DMA 0x10
131 #define RESOURCE_SB 0
132 #define RESOURCE_ENH 1
133 #define RESOURCE_SYNTH 2
134 #define RESOURCE_MIDI 3
135 #define RESOURCE_GAME 4
136 #define RESOURCE_DDMA 7
138 #define SV_MIDI_DATA 0
139 #define SV_MIDI_COMMAND 1
140 #define SV_MIDI_STATUS 1
142 #define SV_DMA_ADDR0 0
143 #define SV_DMA_ADDR1 1
144 #define SV_DMA_ADDR2 2
145 #define SV_DMA_ADDR3 3
146 #define SV_DMA_COUNT0 4
147 #define SV_DMA_COUNT1 5
148 #define SV_DMA_COUNT2 6
149 #define SV_DMA_MODE 0xb
150 #define SV_DMA_RESET 0xd
151 #define SV_DMA_MASK 0xf
154 * DONT reset the DMA controllers unless you understand
155 * the reset semantics. Assuming reset semantics as in
156 * the 8237 does not work.
159 #define DMA_MODE_AUTOINIT 0x10
160 #define DMA_MODE_READ 0x44 /* I/O to memory, no autoinit, increment, single mode */
161 #define DMA_MODE_WRITE 0x48 /* memory to I/O, no autoinit, increment, single mode */
163 #define SV_CODEC_CONTROL 0
164 #define SV_CODEC_INTMASK 1
165 #define SV_CODEC_STATUS 2
166 #define SV_CODEC_IADDR 4
167 #define SV_CODEC_IDATA 5
169 #define SV_CCTRL_RESET 0x80
170 #define SV_CCTRL_INTADRIVE 0x20
171 #define SV_CCTRL_WAVETABLE 0x08
172 #define SV_CCTRL_REVERB 0x04
173 #define SV_CCTRL_ENHANCED 0x01
175 #define SV_CINTMASK_DMAA 0x01
176 #define SV_CINTMASK_DMAC 0x04
177 #define SV_CINTMASK_SPECIAL 0x08
178 #define SV_CINTMASK_UPDOWN 0x40
179 #define SV_CINTMASK_MIDI 0x80
181 #define SV_CSTAT_DMAA 0x01
182 #define SV_CSTAT_DMAC 0x04
183 #define SV_CSTAT_SPECIAL 0x08
184 #define SV_CSTAT_UPDOWN 0x40
185 #define SV_CSTAT_MIDI 0x80
187 #define SV_CIADDR_TRD 0x80
188 #define SV_CIADDR_MCE 0x40
190 /* codec indirect registers */
191 #define SV_CIMIX_ADCINL 0x00
192 #define SV_CIMIX_ADCINR 0x01
193 #define SV_CIMIX_AUX1INL 0x02
194 #define SV_CIMIX_AUX1INR 0x03
195 #define SV_CIMIX_CDINL 0x04
196 #define SV_CIMIX_CDINR 0x05
197 #define SV_CIMIX_LINEINL 0x06
198 #define SV_CIMIX_LINEINR 0x07
199 #define SV_CIMIX_MICIN 0x08
200 #define SV_CIMIX_SYNTHINL 0x0A
201 #define SV_CIMIX_SYNTHINR 0x0B
202 #define SV_CIMIX_AUX2INL 0x0C
203 #define SV_CIMIX_AUX2INR 0x0D
204 #define SV_CIMIX_ANALOGINL 0x0E
205 #define SV_CIMIX_ANALOGINR 0x0F
206 #define SV_CIMIX_PCMINL 0x10
207 #define SV_CIMIX_PCMINR 0x11
209 #define SV_CIGAMECONTROL 0x09
210 #define SV_CIDATAFMT 0x12
211 #define SV_CIENABLE 0x13
212 #define SV_CIUPDOWN 0x14
213 #define SV_CIREVISION 0x15
214 #define SV_CIADCOUTPUT 0x16
215 #define SV_CIDMAABASECOUNT1 0x18
216 #define SV_CIDMAABASECOUNT0 0x19
217 #define SV_CIDMACBASECOUNT1 0x1c
218 #define SV_CIDMACBASECOUNT0 0x1d
219 #define SV_CIPCMSR0 0x1e
220 #define SV_CIPCMSR1 0x1f
221 #define SV_CISYNTHSR0 0x20
222 #define SV_CISYNTHSR1 0x21
223 #define SV_CIADCCLKSOURCE 0x22
224 #define SV_CIADCALTSR 0x23
225 #define SV_CIADCPLLM 0x24
226 #define SV_CIADCPLLN 0x25
227 #define SV_CISYNTHPLLM 0x26
228 #define SV_CISYNTHPLLN 0x27
229 #define SV_CIUARTCONTROL 0x2a
230 #define SV_CIDRIVECONTROL 0x2b
231 #define SV_CISRSSPACE 0x2c
232 #define SV_CISRSCENTER 0x2d
233 #define SV_CIWAVETABLESRC 0x2e
234 #define SV_CIANALOGPWRDOWN 0x30
235 #define SV_CIDIGITALPWRDOWN 0x31
238 #define SV_CIMIX_ADCSRC_CD 0x20
239 #define SV_CIMIX_ADCSRC_DAC 0x40
240 #define SV_CIMIX_ADCSRC_AUX2 0x60
241 #define SV_CIMIX_ADCSRC_LINE 0x80
242 #define SV_CIMIX_ADCSRC_AUX1 0xa0
243 #define SV_CIMIX_ADCSRC_MIC 0xc0
244 #define SV_CIMIX_ADCSRC_MIXOUT 0xe0
245 #define SV_CIMIX_ADCSRC_MASK 0xe0
247 #define SV_CFMT_STEREO 0x01
248 #define SV_CFMT_16BIT 0x02
249 #define SV_CFMT_MASK 0x03
250 #define SV_CFMT_ASHIFT 0
251 #define SV_CFMT_CSHIFT 4
253 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
254 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
256 #define SV_CENABLE_PPE 0x4
257 #define SV_CENABLE_RE 0x2
258 #define SV_CENABLE_PE 0x1
261 /* MIDI buffer sizes */
263 #define MIDIINBUF 256
264 #define MIDIOUTBUF 256
266 #define FMODE_MIDI_SHIFT 2
267 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
268 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
270 #define FMODE_DMFM 0x10
272 #define SND_DEV_DSP16 5
274 /* --------------------------------------------------------------------- */
280 /* we keep sv cards in a linked list */
281 struct sv_state
*next
;
283 /* soundcore stuff */
289 /* hardware resources */
290 unsigned long iosb
, ioenh
, iosynth
, iomidi
, iogame
; /* long for SPARC */
291 unsigned int iodmaa
, iodmac
, irq
;
296 #ifndef OSS_DOCUMENTED_MIXER_SEMANTICS
297 unsigned short vol
[13];
298 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
302 unsigned int rateadc
, ratedac
;
303 unsigned char fmt
, enable
;
306 struct semaphore open_sem
;
308 wait_queue_head_t open_wait
;
315 unsigned hwptr
, swptr
;
316 unsigned total_bytes
;
318 unsigned error
; /* over/underrun */
319 wait_queue_head_t wait
;
320 /* redundant, but makes calculations easier */
323 unsigned fragsamples
;
327 unsigned endcleared
:1;
328 unsigned ossfragshift
;
330 unsigned subdivision
;
335 unsigned ird
, iwr
, icnt
;
336 unsigned ord
, owr
, ocnt
;
337 wait_queue_head_t iwait
;
338 wait_queue_head_t owait
;
339 struct timer_list timer
;
340 unsigned char ibuf
[MIDIINBUF
];
341 unsigned char obuf
[MIDIOUTBUF
];
345 /* --------------------------------------------------------------------- */
347 static struct sv_state
*devs
= NULL
;
348 static unsigned long wavetable_mem
= 0;
350 /* --------------------------------------------------------------------- */
352 extern __inline__
unsigned ld2(unsigned int x
)
378 * hweightN: returns the hamming weight (i.e. the number
379 * of bits set) of a N-bit word
386 extern __inline__
unsigned int hweight32(unsigned int w
)
388 unsigned int res
= (w
& 0x55555555) + ((w
>> 1) & 0x55555555);
389 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
390 res
= (res
& 0x0F0F0F0F) + ((res
>> 4) & 0x0F0F0F0F);
391 res
= (res
& 0x00FF00FF) + ((res
>> 8) & 0x00FF00FF);
392 return (res
& 0x0000FFFF) + ((res
>> 16) & 0x0000FFFF);
395 /* --------------------------------------------------------------------- */
398 * Why use byte IO? Nobody knows, but S3 does it also in their Windows driver.
403 static void set_dmaa(struct sv_state
*s
, unsigned int addr
, unsigned int count
)
406 unsigned io
= s
->iodmaa
, u
;
409 for (u
= 4; u
> 0; u
--, addr
>>= 8, io
++)
410 outb(addr
& 0xff, io
);
411 for (u
= 3; u
> 0; u
--, count
>>= 8, io
++)
412 outb(count
& 0xff, io
);
413 #else /* DMABYTEIO */
415 outl(addr
, s
->iodmaa
+ SV_DMA_ADDR0
);
416 outl(count
, s
->iodmaa
+ SV_DMA_COUNT0
);
417 #endif /* DMABYTEIO */
418 outb(0x18, s
->iodmaa
+ SV_DMA_MODE
);
421 static void set_dmac(struct sv_state
*s
, unsigned int addr
, unsigned int count
)
424 unsigned io
= s
->iodmac
, u
;
428 for (u
= 4; u
> 0; u
--, addr
>>= 8, io
++)
429 outb(addr
& 0xff, io
);
430 for (u
= 3; u
> 0; u
--, count
>>= 8, io
++)
431 outb(count
& 0xff, io
);
432 #else /* DMABYTEIO */
435 outl(addr
, s
->iodmac
+ SV_DMA_ADDR0
);
436 outl(count
, s
->iodmac
+ SV_DMA_COUNT0
);
437 #endif /* DMABYTEIO */
438 outb(0x14, s
->iodmac
+ SV_DMA_MODE
);
441 extern __inline__
unsigned get_dmaa(struct sv_state
*s
)
444 unsigned io
= s
->iodmaa
+6, v
= 0, u
;
446 for (u
= 3; u
> 0; u
--, io
--) {
451 #else /* DMABYTEIO */
452 return (inl(s
->iodmaa
+ SV_DMA_COUNT0
) & 0xffffff) + 1;
453 #endif /* DMABYTEIO */
456 extern __inline__
unsigned get_dmac(struct sv_state
*s
)
459 unsigned io
= s
->iodmac
+6, v
= 0, u
;
461 for (u
= 3; u
> 0; u
--, io
--) {
466 #else /* DMABYTEIO */
467 return ((inl(s
->iodmac
+ SV_DMA_COUNT0
) & 0xffffff) + 1) << 1;
468 #endif /* DMABYTEIO */
471 static void wrindir(struct sv_state
*s
, unsigned char idx
, unsigned char data
)
473 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
475 outb(data
, s
->ioenh
+ SV_CODEC_IDATA
);
479 static unsigned char rdindir(struct sv_state
*s
, unsigned char idx
)
483 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
485 v
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
490 static void set_fmt(struct sv_state
*s
, unsigned char mask
, unsigned char data
)
494 spin_lock_irqsave(&s
->lock
, flags
);
495 outb(SV_CIDATAFMT
| SV_CIADDR_MCE
, s
->ioenh
+ SV_CODEC_IADDR
);
497 s
->fmt
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
500 s
->fmt
= (s
->fmt
& mask
) | data
;
501 outb(s
->fmt
, s
->ioenh
+ SV_CODEC_IDATA
);
503 outb(0, s
->ioenh
+ SV_CODEC_IADDR
);
504 spin_unlock_irqrestore(&s
->lock
, flags
);
508 static void frobindir(struct sv_state
*s
, unsigned char idx
, unsigned char mask
, unsigned char data
)
510 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
512 outb((inb(s
->ioenh
+ SV_CODEC_IDATA
) & mask
) ^ data
, s
->ioenh
+ SV_CODEC_IDATA
);
516 #define REFFREQUENCY 24576000
518 #define FULLRATE 48000
520 static unsigned setpll(struct sv_state
*s
, unsigned char reg
, unsigned rate
)
523 unsigned char r
, m
, n
;
524 unsigned xm
, xn
, xr
, xd
, metric
= ~0U;
525 /* the warnings about m and n used uninitialized are bogus and may safely be ignored */
527 if (rate
< 625000/ADCMULT
)
528 rate
= 625000/ADCMULT
;
529 if (rate
> 150000000/ADCMULT
)
530 rate
= 150000000/ADCMULT
;
531 /* slight violation of specs, needed for continuous sampling rates */
532 for (r
= 0; rate
< 75000000/ADCMULT
; r
+= 0x20, rate
<<= 1);
533 for (xn
= 3; xn
< 35; xn
++)
534 for (xm
= 3; xm
< 130; xm
++) {
535 xr
= REFFREQUENCY
/ADCMULT
* xm
/ xn
;
536 xd
= abs((signed)(xr
- rate
));
544 spin_lock_irqsave(&s
->lock
, flags
);
545 outb(reg
, s
->ioenh
+ SV_CODEC_IADDR
);
547 outb(m
, s
->ioenh
+ SV_CODEC_IDATA
);
549 outb(reg
+1, s
->ioenh
+ SV_CODEC_IADDR
);
551 outb(r
| n
, s
->ioenh
+ SV_CODEC_IDATA
);
552 spin_unlock_irqrestore(&s
->lock
, flags
);
554 return (REFFREQUENCY
/ADCMULT
* (m
+ 2) / (n
+ 2)) >> ((r
>> 5) & 7);
559 static unsigned getpll(struct sv_state
*s
, unsigned char reg
)
565 spin_lock_irqsave(&s
->lock
, flags
);
566 outb(reg
, s
->ioenh
+ SV_CODEC_IADDR
);
568 m
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
570 outb(reg
+1, s
->ioenh
+ SV_CODEC_IADDR
);
572 n
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
573 spin_unlock_irqrestore(&s
->lock
, flags
);
575 return (REFFREQUENCY
/ADCMULT
* (m
+ 2) / ((n
& 0x1f) + 2)) >> ((n
>> 5) & 7);
580 static void set_dac_rate(struct sv_state
*s
, unsigned rate
)
589 div
= (rate
* 65536 + FULLRATE
/2) / FULLRATE
;
592 spin_lock_irqsave(&s
->lock
, flags
);
593 wrindir(s
, SV_CIPCMSR1
, div
>> 8);
594 wrindir(s
, SV_CIPCMSR0
, div
);
595 spin_unlock_irqrestore(&s
->lock
, flags
);
596 s
->ratedac
= (div
* FULLRATE
+ 32768) / 65536;
599 static void set_adc_rate(struct sv_state
*s
, unsigned rate
)
602 unsigned rate1
, rate2
, div
;
608 rate1
= setpll(s
, SV_CIADCPLLM
, rate
);
609 div
= (48000 + rate
/2) / rate
;
612 rate2
= (48000 + div
/2) / div
;
613 spin_lock_irqsave(&s
->lock
, flags
);
614 wrindir(s
, SV_CIADCALTSR
, (div
-1) << 4);
615 if (abs((signed)(rate
-rate2
)) <= abs((signed)(rate
-rate1
))) {
616 wrindir(s
, SV_CIADCCLKSOURCE
, 0x10);
619 wrindir(s
, SV_CIADCCLKSOURCE
, 0x00);
622 spin_unlock_irqrestore(&s
->lock
, flags
);
625 /* --------------------------------------------------------------------- */
627 extern inline void stop_adc(struct sv_state
*s
)
631 spin_lock_irqsave(&s
->lock
, flags
);
632 s
->enable
&= ~SV_CENABLE_RE
;
633 wrindir(s
, SV_CIENABLE
, s
->enable
);
634 spin_unlock_irqrestore(&s
->lock
, flags
);
637 extern inline void stop_dac(struct sv_state
*s
)
641 spin_lock_irqsave(&s
->lock
, flags
);
642 s
->enable
&= ~(SV_CENABLE_PPE
| SV_CENABLE_PE
);
643 wrindir(s
, SV_CIENABLE
, s
->enable
);
644 spin_unlock_irqrestore(&s
->lock
, flags
);
647 static void start_dac(struct sv_state
*s
)
651 spin_lock_irqsave(&s
->lock
, flags
);
652 if ((s
->dma_dac
.mapped
|| s
->dma_dac
.count
> 0) && s
->dma_dac
.ready
) {
653 s
->enable
= (s
->enable
& ~SV_CENABLE_PPE
) | SV_CENABLE_PE
;
654 wrindir(s
, SV_CIENABLE
, s
->enable
);
656 spin_unlock_irqrestore(&s
->lock
, flags
);
659 static void start_adc(struct sv_state
*s
)
663 spin_lock_irqsave(&s
->lock
, flags
);
664 if ((s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
665 && s
->dma_adc
.ready
) {
666 s
->enable
|= SV_CENABLE_RE
;
667 wrindir(s
, SV_CIENABLE
, s
->enable
);
669 spin_unlock_irqrestore(&s
->lock
, flags
);
672 /* --------------------------------------------------------------------- */
674 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
675 #define DMABUF_MINORDER 1
677 static void dealloc_dmabuf(struct dmabuf
*db
)
679 unsigned long map
, mapend
;
682 /* undo marking the pages as reserved */
683 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
684 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
685 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
686 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
689 db
->mapped
= db
->ready
= 0;
693 /* DMAA is used for playback, DMAC is used for recording */
695 static int prog_dmabuf(struct sv_state
*s
, unsigned rec
)
697 struct dmabuf
*db
= rec
? &s
->dma_adc
: &s
->dma_dac
;
698 unsigned rate
= rec
? s
->rateadc
: s
->ratedac
;
702 unsigned long map
, mapend
;
706 spin_lock_irqsave(&s
->lock
, flags
);
709 s
->enable
&= ~SV_CENABLE_RE
;
710 fmt
>>= SV_CFMT_CSHIFT
;
712 s
->enable
&= ~SV_CENABLE_PE
;
713 fmt
>>= SV_CFMT_ASHIFT
;
715 wrindir(s
, SV_CIENABLE
, s
->enable
);
716 spin_unlock_irqrestore(&s
->lock
, flags
);
718 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
720 db
->ready
= db
->mapped
= 0;
721 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
722 if ((db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
| GFP_DMA
, order
)))
726 db
->buforder
= order
;
727 if ((virt_to_bus(db
->rawbuf
) ^ (virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1)) & ~0xffff)
728 printk(KERN_DEBUG
"sv: DMA buffer crosses 64k boundary: busaddr 0x%lx size %ld\n",
729 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
730 if ((virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1) & ~0xffffff)
731 printk(KERN_DEBUG
"sv: DMA buffer beyond 16MB: busaddr 0x%lx size %ld\n",
732 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
733 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
734 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
735 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
736 set_bit(PG_reserved
, &mem_map
[map
].flags
);
738 bytepersec
= rate
<< sample_shift
[fmt
];
739 bufs
= PAGE_SIZE
<< db
->buforder
;
740 if (db
->ossfragshift
) {
741 if ((1000 << db
->ossfragshift
) < bytepersec
)
742 db
->fragshift
= ld2(bytepersec
/1000);
744 db
->fragshift
= db
->ossfragshift
;
746 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
747 if (db
->fragshift
< 3)
750 db
->numfrag
= bufs
>> db
->fragshift
;
751 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
753 db
->numfrag
= bufs
>> db
->fragshift
;
755 db
->fragsize
= 1 << db
->fragshift
;
756 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
757 db
->numfrag
= db
->ossmaxfrags
;
758 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
759 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
760 memset(db
->rawbuf
, (fmt
& SV_CFMT_16BIT
) ? 0 : 0x80, db
->dmasize
);
761 spin_lock_irqsave(&s
->lock
, flags
);
763 set_dmac(s
, virt_to_bus(db
->rawbuf
), db
->numfrag
<< db
->fragshift
);
764 /* program enhanced mode registers */
765 wrindir(s
, SV_CIDMACBASECOUNT1
, (db
->fragsamples
-1) >> 8);
766 wrindir(s
, SV_CIDMACBASECOUNT0
, db
->fragsamples
-1);
768 set_dmaa(s
, virt_to_bus(db
->rawbuf
), db
->numfrag
<< db
->fragshift
);
769 /* program enhanced mode registers */
770 wrindir(s
, SV_CIDMAABASECOUNT1
, (db
->fragsamples
-1) >> 8);
771 wrindir(s
, SV_CIDMAABASECOUNT0
, db
->fragsamples
-1);
773 spin_unlock_irqrestore(&s
->lock
, flags
);
778 extern __inline__
void clear_advance(struct sv_state
*s
)
780 unsigned char c
= (s
->fmt
& (SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
)) ? 0 : 0x80;
781 unsigned char *buf
= s
->dma_dac
.rawbuf
;
782 unsigned bsize
= s
->dma_dac
.dmasize
;
783 unsigned bptr
= s
->dma_dac
.swptr
;
784 unsigned len
= s
->dma_dac
.fragsize
;
786 if (bptr
+ len
> bsize
) {
787 unsigned x
= bsize
- bptr
;
788 memset(buf
+ bptr
, c
, x
);
792 memset(buf
+ bptr
, c
, len
);
795 /* call with spinlock held! */
796 static void sv_update_ptr(struct sv_state
*s
)
801 /* update ADC pointer */
802 if (s
->dma_adc
.ready
) {
803 hwptr
= (s
->dma_adc
.dmasize
- get_dmac(s
)) % s
->dma_adc
.dmasize
;
804 diff
= (s
->dma_adc
.dmasize
+ hwptr
- s
->dma_adc
.hwptr
) % s
->dma_adc
.dmasize
;
805 s
->dma_adc
.hwptr
= hwptr
;
806 s
->dma_adc
.total_bytes
+= diff
;
807 s
->dma_adc
.count
+= diff
;
808 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
809 wake_up(&s
->dma_adc
.wait
);
810 if (!s
->dma_adc
.mapped
) {
811 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
812 s
->enable
&= ~SV_CENABLE_RE
;
813 wrindir(s
, SV_CIENABLE
, s
->enable
);
818 /* update DAC pointer */
819 if (s
->dma_dac
.ready
) {
820 hwptr
= (s
->dma_dac
.dmasize
- get_dmaa(s
)) % s
->dma_dac
.dmasize
;
821 diff
= (s
->dma_dac
.dmasize
+ hwptr
- s
->dma_dac
.hwptr
) % s
->dma_dac
.dmasize
;
822 s
->dma_dac
.hwptr
= hwptr
;
823 s
->dma_dac
.total_bytes
+= diff
;
824 if (s
->dma_dac
.mapped
) {
825 s
->dma_dac
.count
+= diff
;
826 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
827 wake_up(&s
->dma_dac
.wait
);
829 s
->dma_dac
.count
-= diff
;
830 if (s
->dma_dac
.count
<= 0) {
831 s
->enable
&= ~SV_CENABLE_PE
;
832 wrindir(s
, SV_CIENABLE
, s
->enable
);
834 } else if (s
->dma_dac
.count
<= (signed)s
->dma_dac
.fragsize
&& !s
->dma_dac
.endcleared
) {
836 s
->dma_dac
.endcleared
= 1;
838 if (s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
<= (signed)s
->dma_dac
.dmasize
)
839 wake_up(&s
->dma_dac
.wait
);
844 /* hold spinlock for the following! */
845 static void sv_handle_midi(struct sv_state
*s
)
851 while (!(inb(s
->iomidi
+1) & 0x80)) {
853 if (s
->midi
.icnt
< MIDIINBUF
) {
854 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
855 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
861 wake_up(&s
->midi
.iwait
);
863 while (!(inb(s
->iomidi
+1) & 0x40) && s
->midi
.ocnt
> 0) {
864 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->iomidi
);
865 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
867 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
871 wake_up(&s
->midi
.owait
);
874 static void sv_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
876 struct sv_state
*s
= (struct sv_state
*)dev_id
;
879 /* fastpath out, to ease interrupt sharing */
880 intsrc
= inb(s
->ioenh
+ SV_CODEC_STATUS
);
881 if (!(intsrc
& (SV_CSTAT_DMAA
| SV_CSTAT_DMAC
| SV_CSTAT_MIDI
)))
886 spin_unlock(&s
->lock
);
889 static void sv_midi_timer(unsigned long data
)
891 struct sv_state
*s
= (struct sv_state
*)data
;
894 spin_lock_irqsave(&s
->lock
, flags
);
896 spin_unlock_irqrestore(&s
->lock
, flags
);
897 s
->midi
.timer
.expires
= jiffies
+1;
898 add_timer(&s
->midi
.timer
);
901 /* --------------------------------------------------------------------- */
903 static const char invalid_magic
[] = KERN_CRIT
"sv: invalid magic value\n";
905 #define VALIDATE_STATE(s) \
907 if (!(s) || (s)->magic != SV_MAGIC) { \
908 printk(invalid_magic); \
913 /* --------------------------------------------------------------------- */
917 #define MT_4MUTEMONO 3
920 static const struct {
925 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
926 [SOUND_MIXER_RECLEV
] = { SV_CIMIX_ADCINL
, SV_CIMIX_ADCINR
, MT_4
, 0 },
927 [SOUND_MIXER_LINE1
] = { SV_CIMIX_AUX1INL
, SV_CIMIX_AUX1INR
, MT_5MUTE
, 5 },
928 [SOUND_MIXER_CD
] = { SV_CIMIX_CDINL
, SV_CIMIX_CDINR
, MT_5MUTE
, 1 },
929 [SOUND_MIXER_LINE
] = { SV_CIMIX_LINEINL
, SV_CIMIX_LINEINR
, MT_5MUTE
, 4 },
930 [SOUND_MIXER_MIC
] = { SV_CIMIX_MICIN
, SV_CIMIX_ADCINL
, MT_4MUTEMONO
, 6 },
931 [SOUND_MIXER_SYNTH
] = { SV_CIMIX_SYNTHINL
, SV_CIMIX_SYNTHINR
, MT_5MUTE
, 2 },
932 [SOUND_MIXER_LINE2
] = { SV_CIMIX_AUX2INL
, SV_CIMIX_AUX2INR
, MT_5MUTE
, 3 },
933 [SOUND_MIXER_VOLUME
] = { SV_CIMIX_ANALOGINL
, SV_CIMIX_ANALOGINR
, MT_5MUTE
, 7 },
934 [SOUND_MIXER_PCM
] = { SV_CIMIX_PCMINL
, SV_CIMIX_PCMINR
, MT_6MUTE
, 0 }
937 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
939 static int return_mixval(struct sv_state
*s
, unsigned i
, int *arg
)
942 unsigned char l
, r
, rl
, rr
;
944 spin_lock_irqsave(&s
->lock
, flags
);
945 l
= rdindir(s
, mixtable
[i
].left
);
946 r
= rdindir(s
, mixtable
[i
].right
);
947 spin_unlock_irqrestore(&s
->lock
, flags
);
948 switch (mixtable
[i
].type
) {
952 rl
= 10 + 6 * (l
& 15);
953 rr
= 10 + 6 * (r
& 15);
957 rl
= 55 - 3 * (l
& 15);
966 rl
= 100 - 3 * (l
& 31);
967 rr
= 100 - 3 * (r
& 31);
971 rl
= 100 - 3 * (l
& 63) / 2;
972 rr
= 100 - 3 * (r
& 63) / 2;
979 return put_user((rr
<< 8) | rl
, arg
);
982 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
984 static const unsigned char volidx
[SOUND_MIXER_NRDEVICES
] =
986 [SOUND_MIXER_RECLEV
] = 1,
987 [SOUND_MIXER_LINE1
] = 2,
988 [SOUND_MIXER_CD
] = 3,
989 [SOUND_MIXER_LINE
] = 4,
990 [SOUND_MIXER_MIC
] = 5,
991 [SOUND_MIXER_SYNTH
] = 6,
992 [SOUND_MIXER_LINE2
] = 7,
993 [SOUND_MIXER_VOLUME
] = 8,
994 [SOUND_MIXER_PCM
] = 9
997 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
999 static unsigned mixer_recmask(struct sv_state
*s
)
1001 unsigned long flags
;
1004 spin_lock_irqsave(&s
->lock
, flags
);
1005 j
= rdindir(s
, SV_CIMIX_ADCINL
) >> 5;
1006 spin_unlock_irqrestore(&s
->lock
, flags
);
1008 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
&& mixtable
[i
].rec
!= j
; i
++);
1012 static int mixer_ioctl(struct sv_state
*s
, unsigned int cmd
, unsigned long arg
)
1014 unsigned long flags
;
1016 unsigned char l
, r
, rl
, rr
;
1019 if (cmd
== SOUND_MIXER_INFO
) {
1021 strncpy(info
.id
, "SonicVibes", sizeof(info
.id
));
1022 strncpy(info
.name
, "S3 SonicVibes", sizeof(info
.name
));
1023 info
.modify_counter
= s
->mix
.modcnt
;
1024 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
1028 if (cmd
== SOUND_OLD_MIXER_INFO
) {
1029 _old_mixer_info info
;
1030 strncpy(info
.id
, "SonicVibes", sizeof(info
.id
));
1031 strncpy(info
.name
, "S3 SonicVibes", sizeof(info
.name
));
1032 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
1036 if (cmd
== OSS_GETVERSION
)
1037 return put_user(SOUND_VERSION
, (int *)arg
);
1038 if (cmd
== SOUND_MIXER_PRIVATE1
) { /* SRS settings */
1039 get_user_ret(val
, (int *)arg
, -EFAULT
);
1040 spin_lock_irqsave(&s
->lock
, flags
);
1043 l
= 4 - ((val
>> 2) & 7);
1046 r
= 4 - ((val
>> 5) & 7);
1049 wrindir(s
, SV_CISRSSPACE
, l
);
1050 wrindir(s
, SV_CISRSCENTER
, r
);
1052 wrindir(s
, SV_CISRSSPACE
, 0x80);
1054 l
= rdindir(s
, SV_CISRSSPACE
);
1055 r
= rdindir(s
, SV_CISRSCENTER
);
1056 spin_unlock_irqrestore(&s
->lock
, flags
);
1058 return put_user(0, (int *)arg
);
1059 return put_user(((4 - (l
& 7)) << 2) | ((4 - (r
& 7)) << 5) | 2, (int *)arg
);
1061 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
1063 if (_IOC_DIR(cmd
) == _IOC_READ
) {
1064 switch (_IOC_NR(cmd
)) {
1065 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
1066 return put_user(mixer_recmask(s
), (int *)arg
);
1068 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
1069 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1070 if (mixtable
[i
].type
)
1072 return put_user(val
, (int *)arg
);
1074 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
1075 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1076 if (mixtable
[i
].rec
)
1078 return put_user(val
, (int *)arg
);
1080 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
1081 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1082 if (mixtable
[i
].type
&& mixtable
[i
].type
!= MT_4MUTEMONO
)
1084 return put_user(val
, (int *)arg
);
1086 case SOUND_MIXER_CAPS
:
1087 return put_user(SOUND_CAP_EXCL_INPUT
, (int *)arg
);
1091 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1093 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1094 return return_mixval(s
, i
, (int *)arg
);
1095 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1098 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1099 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1102 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
1105 switch (_IOC_NR(cmd
)) {
1106 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
1107 get_user_ret(val
, (int *)arg
, -EFAULT
);
1110 return 0; /*val = mixer_recmask(s);*/
1112 val
&= ~mixer_recmask(s
);
1113 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
1114 if (!(val
& (1 << i
)))
1116 if (mixtable
[i
].rec
)
1119 if (!mixtable
[i
].rec
)
1121 spin_lock_irqsave(&s
->lock
, flags
);
1122 frobindir(s
, SV_CIMIX_ADCINL
, 0x1f, mixtable
[i
].rec
<< 5);
1123 frobindir(s
, SV_CIMIX_ADCINR
, 0x1f, mixtable
[i
].rec
<< 5);
1124 spin_unlock_irqrestore(&s
->lock
, flags
);
1129 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1131 get_user_ret(val
, (int *)arg
, -EFAULT
);
1133 r
= (val
>> 8) & 0xff;
1134 if (mixtable
[i
].type
== MT_4MUTEMONO
)
1140 spin_lock_irqsave(&s
->lock
, flags
);
1141 switch (mixtable
[i
].type
) {
1147 frobindir(s
, mixtable
[i
].left
, 0xf0, l
/ 6);
1148 frobindir(s
, mixtable
[i
].right
, 0xf0, l
/ 6);
1162 wrindir(s
, mixtable
[i
].left
, rl
);
1163 frobindir(s
, mixtable
[i
].right
, ~0x10, rr
);
1175 wrindir(s
, mixtable
[i
].left
, rl
);
1176 wrindir(s
, mixtable
[i
].right
, rr
);
1183 rl
= (100 - l
) * 2 / 3;
1187 rr
= (100 - r
) * 2 / 3;
1188 wrindir(s
, mixtable
[i
].left
, rl
);
1189 wrindir(s
, mixtable
[i
].right
, rr
);
1192 spin_unlock_irqrestore(&s
->lock
, flags
);
1193 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1194 return return_mixval(s
, i
, (int *)arg
);
1195 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1198 s
->mix
.vol
[volidx
[i
]-1] = val
;
1199 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1200 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1204 /* --------------------------------------------------------------------- */
1206 static loff_t
sv_llseek(struct file
*file
, loff_t offset
, int origin
)
1211 /* --------------------------------------------------------------------- */
1213 static int sv_open_mixdev(struct inode
*inode
, struct file
*file
)
1215 int minor
= MINOR(inode
->i_rdev
);
1216 struct sv_state
*s
= devs
;
1218 while (s
&& s
->dev_mixer
!= minor
)
1223 file
->private_data
= s
;
1228 static int sv_release_mixdev(struct inode
*inode
, struct file
*file
)
1230 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1237 static int sv_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1239 return mixer_ioctl((struct sv_state
*)file
->private_data
, cmd
, arg
);
1242 static /*const*/ struct file_operations sv_mixer_fops
= {
1255 NULL
, /* check_media_change */
1256 NULL
, /* revalidate */
1260 /* --------------------------------------------------------------------- */
1262 static int drain_dac(struct sv_state
*s
, int nonblock
)
1264 DECLARE_WAITQUEUE(wait
, current
);
1265 unsigned long flags
;
1268 if (s
->dma_dac
.mapped
|| !s
->dma_dac
.ready
)
1270 __set_current_state(TASK_INTERRUPTIBLE
);
1271 add_wait_queue(&s
->dma_dac
.wait
, &wait
);
1273 spin_lock_irqsave(&s
->lock
, flags
);
1274 count
= s
->dma_dac
.count
;
1275 spin_unlock_irqrestore(&s
->lock
, flags
);
1278 if (signal_pending(current
))
1281 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1282 set_current_state(TASK_RUNNING
);
1285 tmo
= 3 * HZ
* (count
+ s
->dma_dac
.fragsize
) / 2 / s
->ratedac
;
1286 tmo
>>= sample_shift
[(s
->fmt
>> SV_CFMT_ASHIFT
) & SV_CFMT_MASK
];
1287 if (!schedule_timeout(tmo
+ 1))
1288 printk(KERN_DEBUG
"sv: dma timed out??\n");
1290 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1291 set_current_state(TASK_RUNNING
);
1292 if (signal_pending(current
))
1293 return -ERESTARTSYS
;
1297 /* --------------------------------------------------------------------- */
1299 static ssize_t
sv_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1301 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1303 unsigned long flags
;
1308 if (ppos
!= &file
->f_pos
)
1310 if (s
->dma_adc
.mapped
)
1312 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1314 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1318 spin_lock_irqsave(&s
->lock
, flags
);
1320 spin_unlock_irqrestore(&s
->lock
, flags
);
1323 spin_lock_irqsave(&s
->lock
, flags
);
1324 swptr
= s
->dma_adc
.swptr
;
1325 cnt
= s
->dma_adc
.dmasize
-swptr
;
1326 if (s
->dma_adc
.count
< cnt
)
1327 cnt
= s
->dma_adc
.count
;
1328 spin_unlock_irqrestore(&s
->lock
, flags
);
1333 if (file
->f_flags
& O_NONBLOCK
)
1334 return ret
? ret
: -EAGAIN
;
1335 if (!interruptible_sleep_on_timeout(&s
->dma_adc
.wait
, HZ
)) {
1336 printk(KERN_DEBUG
"sv: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1337 s
->dma_adc
.dmasize
, s
->dma_adc
.fragsize
, s
->dma_adc
.count
,
1338 s
->dma_adc
.hwptr
, s
->dma_adc
.swptr
);
1340 spin_lock_irqsave(&s
->lock
, flags
);
1341 set_dmac(s
, virt_to_bus(s
->dma_adc
.rawbuf
), s
->dma_adc
.numfrag
<< s
->dma_adc
.fragshift
);
1342 /* program enhanced mode registers */
1343 wrindir(s
, SV_CIDMACBASECOUNT1
, (s
->dma_adc
.fragsamples
-1) >> 8);
1344 wrindir(s
, SV_CIDMACBASECOUNT0
, s
->dma_adc
.fragsamples
-1);
1345 s
->dma_adc
.count
= s
->dma_adc
.hwptr
= s
->dma_adc
.swptr
= 0;
1346 spin_unlock_irqrestore(&s
->lock
, flags
);
1348 if (signal_pending(current
))
1349 return ret
? ret
: -ERESTARTSYS
;
1352 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1353 return ret
? ret
: -EFAULT
;
1354 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1355 spin_lock_irqsave(&s
->lock
, flags
);
1356 s
->dma_adc
.swptr
= swptr
;
1357 s
->dma_adc
.count
-= cnt
;
1358 spin_unlock_irqrestore(&s
->lock
, flags
);
1367 static ssize_t
sv_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1369 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1371 unsigned long flags
;
1376 if (ppos
!= &file
->f_pos
)
1378 if (s
->dma_dac
.mapped
)
1380 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1382 if (!access_ok(VERIFY_READ
, buffer
, count
))
1386 spin_lock_irqsave(&s
->lock
, flags
);
1388 spin_unlock_irqrestore(&s
->lock
, flags
);
1391 spin_lock_irqsave(&s
->lock
, flags
);
1392 if (s
->dma_dac
.count
< 0) {
1393 s
->dma_dac
.count
= 0;
1394 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
;
1396 swptr
= s
->dma_dac
.swptr
;
1397 cnt
= s
->dma_dac
.dmasize
-swptr
;
1398 if (s
->dma_dac
.count
+ cnt
> s
->dma_dac
.dmasize
)
1399 cnt
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1400 spin_unlock_irqrestore(&s
->lock
, flags
);
1405 if (file
->f_flags
& O_NONBLOCK
)
1406 return ret
? ret
: -EAGAIN
;
1407 if (!interruptible_sleep_on_timeout(&s
->dma_dac
.wait
, HZ
)) {
1408 printk(KERN_DEBUG
"sv: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1409 s
->dma_dac
.dmasize
, s
->dma_dac
.fragsize
, s
->dma_dac
.count
,
1410 s
->dma_dac
.hwptr
, s
->dma_dac
.swptr
);
1412 spin_lock_irqsave(&s
->lock
, flags
);
1413 set_dmaa(s
, virt_to_bus(s
->dma_dac
.rawbuf
), s
->dma_dac
.numfrag
<< s
->dma_dac
.fragshift
);
1414 /* program enhanced mode registers */
1415 wrindir(s
, SV_CIDMAABASECOUNT1
, (s
->dma_dac
.fragsamples
-1) >> 8);
1416 wrindir(s
, SV_CIDMAABASECOUNT0
, s
->dma_dac
.fragsamples
-1);
1417 s
->dma_dac
.count
= s
->dma_dac
.hwptr
= s
->dma_dac
.swptr
= 0;
1418 spin_unlock_irqrestore(&s
->lock
, flags
);
1420 if (signal_pending(current
))
1421 return ret
? ret
: -ERESTARTSYS
;
1424 if (copy_from_user(s
->dma_dac
.rawbuf
+ swptr
, buffer
, cnt
))
1425 return ret
? ret
: -EFAULT
;
1426 swptr
= (swptr
+ cnt
) % s
->dma_dac
.dmasize
;
1427 spin_lock_irqsave(&s
->lock
, flags
);
1428 s
->dma_dac
.swptr
= swptr
;
1429 s
->dma_dac
.count
+= cnt
;
1430 s
->dma_dac
.endcleared
= 0;
1431 spin_unlock_irqrestore(&s
->lock
, flags
);
1440 static unsigned int sv_poll(struct file
*file
, struct poll_table_struct
*wait
)
1442 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1443 unsigned long flags
;
1444 unsigned int mask
= 0;
1447 if (file
->f_mode
& FMODE_WRITE
)
1448 poll_wait(file
, &s
->dma_dac
.wait
, wait
);
1449 if (file
->f_mode
& FMODE_READ
)
1450 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1451 spin_lock_irqsave(&s
->lock
, flags
);
1453 if (file
->f_mode
& FMODE_READ
) {
1454 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1455 mask
|= POLLIN
| POLLRDNORM
;
1457 if (file
->f_mode
& FMODE_WRITE
) {
1458 if (s
->dma_dac
.mapped
) {
1459 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
1460 mask
|= POLLOUT
| POLLWRNORM
;
1462 if ((signed)s
->dma_dac
.dmasize
>= s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
)
1463 mask
|= POLLOUT
| POLLWRNORM
;
1466 spin_unlock_irqrestore(&s
->lock
, flags
);
1470 static int sv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1472 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1478 if (vma
->vm_flags
& VM_WRITE
) {
1479 if ((ret
= prog_dmabuf(s
, 1)) != 0)
1482 } else if (vma
->vm_flags
& VM_READ
) {
1483 if ((ret
= prog_dmabuf(s
, 0)) != 0)
1488 if (vma
->vm_offset
!= 0)
1490 size
= vma
->vm_end
- vma
->vm_start
;
1491 if (size
> (PAGE_SIZE
<< db
->buforder
))
1493 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1499 static int sv_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1501 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1502 unsigned long flags
;
1503 audio_buf_info abinfo
;
1505 int val
, mapped
, ret
;
1506 unsigned char fmtm
, fmtd
;
1509 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac
.mapped
) ||
1510 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1512 case OSS_GETVERSION
:
1513 return put_user(SOUND_VERSION
, (int *)arg
);
1515 case SNDCTL_DSP_SYNC
:
1516 if (file
->f_mode
& FMODE_WRITE
)
1517 return drain_dac(s
, 0/*file->f_flags & O_NONBLOCK*/);
1520 case SNDCTL_DSP_SETDUPLEX
:
1523 case SNDCTL_DSP_GETCAPS
:
1524 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1526 case SNDCTL_DSP_RESET
:
1527 if (file
->f_mode
& FMODE_WRITE
) {
1530 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
= s
->dma_dac
.count
= s
->dma_dac
.total_bytes
= 0;
1532 if (file
->f_mode
& FMODE_READ
) {
1535 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1539 case SNDCTL_DSP_SPEED
:
1540 get_user_ret(val
, (int *)arg
, -EFAULT
);
1542 if (file
->f_mode
& FMODE_READ
) {
1544 s
->dma_adc
.ready
= 0;
1545 set_adc_rate(s
, val
);
1547 if (file
->f_mode
& FMODE_WRITE
) {
1549 s
->dma_dac
.ready
= 0;
1550 set_dac_rate(s
, val
);
1553 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1555 case SNDCTL_DSP_STEREO
:
1556 get_user_ret(val
, (int *)arg
, -EFAULT
);
1559 if (file
->f_mode
& FMODE_READ
) {
1561 s
->dma_adc
.ready
= 0;
1563 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
;
1565 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
);
1567 if (file
->f_mode
& FMODE_WRITE
) {
1569 s
->dma_dac
.ready
= 0;
1571 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
;
1573 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
);
1575 set_fmt(s
, fmtm
, fmtd
);
1578 case SNDCTL_DSP_CHANNELS
:
1579 get_user_ret(val
, (int *)arg
, -EFAULT
);
1583 if (file
->f_mode
& FMODE_READ
) {
1585 s
->dma_adc
.ready
= 0;
1587 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
;
1589 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
);
1591 if (file
->f_mode
& FMODE_WRITE
) {
1593 s
->dma_dac
.ready
= 0;
1595 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
;
1597 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
);
1599 set_fmt(s
, fmtm
, fmtd
);
1601 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
)
1602 : (SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
))) ? 2 : 1, (int *)arg
);
1604 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1605 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1607 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1608 get_user_ret(val
, (int *)arg
, -EFAULT
);
1609 if (val
!= AFMT_QUERY
) {
1612 if (file
->f_mode
& FMODE_READ
) {
1614 s
->dma_adc
.ready
= 0;
1615 if (val
== AFMT_S16_LE
)
1616 fmtd
|= SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
;
1618 fmtm
&= ~(SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
);
1620 if (file
->f_mode
& FMODE_WRITE
) {
1622 s
->dma_dac
.ready
= 0;
1623 if (val
== AFMT_S16_LE
)
1624 fmtd
|= SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
;
1626 fmtm
&= ~(SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
);
1628 set_fmt(s
, fmtm
, fmtd
);
1630 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
)
1631 : (SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
))) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1633 case SNDCTL_DSP_POST
:
1636 case SNDCTL_DSP_GETTRIGGER
:
1638 if (file
->f_mode
& FMODE_READ
&& s
->enable
& SV_CENABLE_RE
)
1639 val
|= PCM_ENABLE_INPUT
;
1640 if (file
->f_mode
& FMODE_WRITE
&& s
->enable
& SV_CENABLE_PE
)
1641 val
|= PCM_ENABLE_OUTPUT
;
1642 return put_user(val
, (int *)arg
);
1644 case SNDCTL_DSP_SETTRIGGER
:
1645 get_user_ret(val
, (int *)arg
, -EFAULT
);
1646 if (file
->f_mode
& FMODE_READ
) {
1647 if (val
& PCM_ENABLE_INPUT
) {
1648 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1654 if (file
->f_mode
& FMODE_WRITE
) {
1655 if (val
& PCM_ENABLE_OUTPUT
) {
1656 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1664 case SNDCTL_DSP_GETOSPACE
:
1665 if (!(file
->f_mode
& FMODE_WRITE
))
1667 if (!(s
->enable
& SV_CENABLE_PE
) && (val
= prog_dmabuf(s
, 0)) != 0)
1669 spin_lock_irqsave(&s
->lock
, flags
);
1671 abinfo
.fragsize
= s
->dma_dac
.fragsize
;
1672 abinfo
.bytes
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1673 abinfo
.fragstotal
= s
->dma_dac
.numfrag
;
1674 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac
.fragshift
;
1675 spin_unlock_irqrestore(&s
->lock
, flags
);
1676 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1678 case SNDCTL_DSP_GETISPACE
:
1679 if (!(file
->f_mode
& FMODE_READ
))
1681 if (!(s
->enable
& SV_CENABLE_RE
) && (val
= prog_dmabuf(s
, 1)) != 0)
1683 spin_lock_irqsave(&s
->lock
, flags
);
1685 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1686 abinfo
.bytes
= s
->dma_adc
.count
;
1687 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1688 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1689 spin_unlock_irqrestore(&s
->lock
, flags
);
1690 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1692 case SNDCTL_DSP_NONBLOCK
:
1693 file
->f_flags
|= O_NONBLOCK
;
1696 case SNDCTL_DSP_GETODELAY
:
1697 if (!(file
->f_mode
& FMODE_WRITE
))
1699 spin_lock_irqsave(&s
->lock
, flags
);
1701 val
= s
->dma_dac
.count
;
1702 spin_unlock_irqrestore(&s
->lock
, flags
);
1703 return put_user(val
, (int *)arg
);
1705 case SNDCTL_DSP_GETIPTR
:
1706 if (!(file
->f_mode
& FMODE_READ
))
1708 spin_lock_irqsave(&s
->lock
, flags
);
1710 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1711 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1712 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1713 if (s
->dma_adc
.mapped
)
1714 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1715 spin_unlock_irqrestore(&s
->lock
, flags
);
1716 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1718 case SNDCTL_DSP_GETOPTR
:
1719 if (!(file
->f_mode
& FMODE_WRITE
))
1721 spin_lock_irqsave(&s
->lock
, flags
);
1723 cinfo
.bytes
= s
->dma_dac
.total_bytes
;
1724 cinfo
.blocks
= s
->dma_dac
.count
>> s
->dma_dac
.fragshift
;
1725 cinfo
.ptr
= s
->dma_dac
.hwptr
;
1726 if (s
->dma_dac
.mapped
)
1727 s
->dma_dac
.count
&= s
->dma_dac
.fragsize
-1;
1728 spin_unlock_irqrestore(&s
->lock
, flags
);
1729 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1731 case SNDCTL_DSP_GETBLKSIZE
:
1732 if (file
->f_mode
& FMODE_WRITE
) {
1733 if ((val
= prog_dmabuf(s
, 0)))
1735 return put_user(s
->dma_dac
.fragsize
, (int *)arg
);
1737 if ((val
= prog_dmabuf(s
, 1)))
1739 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1741 case SNDCTL_DSP_SETFRAGMENT
:
1742 get_user_ret(val
, (int *)arg
, -EFAULT
);
1743 if (file
->f_mode
& FMODE_READ
) {
1744 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1745 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1746 if (s
->dma_adc
.ossfragshift
< 4)
1747 s
->dma_adc
.ossfragshift
= 4;
1748 if (s
->dma_adc
.ossfragshift
> 15)
1749 s
->dma_adc
.ossfragshift
= 15;
1750 if (s
->dma_adc
.ossmaxfrags
< 4)
1751 s
->dma_adc
.ossmaxfrags
= 4;
1753 if (file
->f_mode
& FMODE_WRITE
) {
1754 s
->dma_dac
.ossfragshift
= val
& 0xffff;
1755 s
->dma_dac
.ossmaxfrags
= (val
>> 16) & 0xffff;
1756 if (s
->dma_dac
.ossfragshift
< 4)
1757 s
->dma_dac
.ossfragshift
= 4;
1758 if (s
->dma_dac
.ossfragshift
> 15)
1759 s
->dma_dac
.ossfragshift
= 15;
1760 if (s
->dma_dac
.ossmaxfrags
< 4)
1761 s
->dma_dac
.ossmaxfrags
= 4;
1765 case SNDCTL_DSP_SUBDIVIDE
:
1766 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1767 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac
.subdivision
))
1769 get_user_ret(val
, (int *)arg
, -EFAULT
);
1770 if (val
!= 1 && val
!= 2 && val
!= 4)
1772 if (file
->f_mode
& FMODE_READ
)
1773 s
->dma_adc
.subdivision
= val
;
1774 if (file
->f_mode
& FMODE_WRITE
)
1775 s
->dma_dac
.subdivision
= val
;
1778 case SOUND_PCM_READ_RATE
:
1779 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1781 case SOUND_PCM_READ_CHANNELS
:
1782 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
)
1783 : (SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
))) ? 2 : 1, (int *)arg
);
1785 case SOUND_PCM_READ_BITS
:
1786 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
)
1787 : (SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
))) ? 16 : 8, (int *)arg
);
1789 case SOUND_PCM_WRITE_FILTER
:
1790 case SNDCTL_DSP_SETSYNCRO
:
1791 case SOUND_PCM_READ_FILTER
:
1795 return mixer_ioctl(s
, cmd
, arg
);
1798 static int sv_open(struct inode
*inode
, struct file
*file
)
1800 int minor
= MINOR(inode
->i_rdev
);
1801 struct sv_state
*s
= devs
;
1802 unsigned char fmtm
= ~0, fmts
= 0;
1804 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1809 file
->private_data
= s
;
1810 /* wait for device to become free */
1812 while (s
->open_mode
& file
->f_mode
) {
1813 if (file
->f_flags
& O_NONBLOCK
) {
1818 interruptible_sleep_on(&s
->open_wait
);
1819 if (signal_pending(current
))
1820 return -ERESTARTSYS
;
1823 if (file
->f_mode
& FMODE_READ
) {
1824 fmtm
&= ~((SV_CFMT_STEREO
| SV_CFMT_16BIT
) << SV_CFMT_CSHIFT
);
1825 if ((minor
& 0xf) == SND_DEV_DSP16
)
1826 fmts
|= SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
;
1827 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1828 set_adc_rate(s
, 8000);
1830 if (file
->f_mode
& FMODE_WRITE
) {
1831 fmtm
&= ~((SV_CFMT_STEREO
| SV_CFMT_16BIT
) << SV_CFMT_ASHIFT
);
1832 if ((minor
& 0xf) == SND_DEV_DSP16
)
1833 fmts
|= SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
;
1834 s
->dma_dac
.ossfragshift
= s
->dma_dac
.ossmaxfrags
= s
->dma_dac
.subdivision
= 0;
1835 set_dac_rate(s
, 8000);
1837 set_fmt(s
, fmtm
, fmts
);
1838 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1844 static int sv_release(struct inode
*inode
, struct file
*file
)
1846 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1849 if (file
->f_mode
& FMODE_WRITE
)
1850 drain_dac(s
, file
->f_flags
& O_NONBLOCK
);
1852 if (file
->f_mode
& FMODE_WRITE
) {
1854 dealloc_dmabuf(&s
->dma_dac
);
1856 if (file
->f_mode
& FMODE_READ
) {
1858 dealloc_dmabuf(&s
->dma_adc
);
1860 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1862 wake_up(&s
->open_wait
);
1867 static /*const*/ struct file_operations sv_audio_fops
= {
1880 NULL
, /* check_media_change */
1881 NULL
, /* revalidate */
1885 /* --------------------------------------------------------------------- */
1887 static ssize_t
sv_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1889 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1890 DECLARE_WAITQUEUE(wait
, current
);
1892 unsigned long flags
;
1897 if (ppos
!= &file
->f_pos
)
1899 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1904 add_wait_queue(&s
->midi
.iwait
, &wait
);
1906 spin_lock_irqsave(&s
->lock
, flags
);
1908 cnt
= MIDIINBUF
- ptr
;
1909 if (s
->midi
.icnt
< cnt
)
1911 spin_unlock_irqrestore(&s
->lock
, flags
);
1915 if (file
->f_flags
& O_NONBLOCK
) {
1920 __set_current_state(TASK_INTERRUPTIBLE
);
1922 if (signal_pending(current
)) {
1929 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
)) {
1934 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
1935 spin_lock_irqsave(&s
->lock
, flags
);
1937 s
->midi
.icnt
-= cnt
;
1938 spin_unlock_irqrestore(&s
->lock
, flags
);
1944 __set_current_state(TASK_RUNNING
);
1945 remove_wait_queue(&s
->midi
.iwait
, &wait
);
1949 static ssize_t
sv_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1951 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1952 DECLARE_WAITQUEUE(wait
, current
);
1954 unsigned long flags
;
1959 if (ppos
!= &file
->f_pos
)
1961 if (!access_ok(VERIFY_READ
, buffer
, count
))
1966 add_wait_queue(&s
->midi
.owait
, &wait
);
1968 spin_lock_irqsave(&s
->lock
, flags
);
1970 cnt
= MIDIOUTBUF
- ptr
;
1971 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
1972 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
1975 spin_unlock_irqrestore(&s
->lock
, flags
);
1979 if (file
->f_flags
& O_NONBLOCK
) {
1984 __set_current_state(TASK_INTERRUPTIBLE
);
1986 if (signal_pending(current
)) {
1993 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
)) {
1998 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
1999 spin_lock_irqsave(&s
->lock
, flags
);
2001 s
->midi
.ocnt
+= cnt
;
2002 spin_unlock_irqrestore(&s
->lock
, flags
);
2006 spin_lock_irqsave(&s
->lock
, flags
);
2008 spin_unlock_irqrestore(&s
->lock
, flags
);
2010 __set_current_state(TASK_RUNNING
);
2011 remove_wait_queue(&s
->midi
.owait
, &wait
);
2015 static unsigned int sv_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2017 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2018 unsigned long flags
;
2019 unsigned int mask
= 0;
2022 if (file
->f_mode
& FMODE_WRITE
)
2023 poll_wait(file
, &s
->midi
.owait
, wait
);
2024 if (file
->f_mode
& FMODE_READ
)
2025 poll_wait(file
, &s
->midi
.iwait
, wait
);
2026 spin_lock_irqsave(&s
->lock
, flags
);
2027 if (file
->f_mode
& FMODE_READ
) {
2028 if (s
->midi
.icnt
> 0)
2029 mask
|= POLLIN
| POLLRDNORM
;
2031 if (file
->f_mode
& FMODE_WRITE
) {
2032 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2033 mask
|= POLLOUT
| POLLWRNORM
;
2035 spin_unlock_irqrestore(&s
->lock
, flags
);
2039 static int sv_midi_open(struct inode
*inode
, struct file
*file
)
2041 int minor
= MINOR(inode
->i_rdev
);
2042 struct sv_state
*s
= devs
;
2043 unsigned long flags
;
2045 while (s
&& s
->dev_midi
!= minor
)
2050 file
->private_data
= s
;
2051 /* wait for device to become free */
2053 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2054 if (file
->f_flags
& O_NONBLOCK
) {
2059 interruptible_sleep_on(&s
->open_wait
);
2060 if (signal_pending(current
))
2061 return -ERESTARTSYS
;
2064 spin_lock_irqsave(&s
->lock
, flags
);
2065 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2066 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2067 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2068 //outb(inb(s->ioenh + SV_CODEC_CONTROL) | SV_CCTRL_WAVETABLE, s->ioenh + SV_CODEC_CONTROL);
2069 outb(inb(s
->ioenh
+ SV_CODEC_INTMASK
) | SV_CINTMASK_MIDI
, s
->ioenh
+ SV_CODEC_INTMASK
);
2070 wrindir(s
, SV_CIUARTCONTROL
, 5); /* output MIDI data to external and internal synth */
2071 wrindir(s
, SV_CIWAVETABLESRC
, 1); /* Wavetable in PC RAM */
2072 outb(0xff, s
->iomidi
+1); /* reset command */
2073 outb(0x3f, s
->iomidi
+1); /* uart command */
2074 if (!(inb(s
->iomidi
+1) & 0x80))
2076 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2077 init_timer(&s
->midi
.timer
);
2078 s
->midi
.timer
.expires
= jiffies
+1;
2079 s
->midi
.timer
.data
= (unsigned long)s
;
2080 s
->midi
.timer
.function
= sv_midi_timer
;
2081 add_timer(&s
->midi
.timer
);
2083 if (file
->f_mode
& FMODE_READ
) {
2084 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2086 if (file
->f_mode
& FMODE_WRITE
) {
2087 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2089 spin_unlock_irqrestore(&s
->lock
, flags
);
2090 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2096 static int sv_midi_release(struct inode
*inode
, struct file
*file
)
2098 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2099 DECLARE_WAITQUEUE(wait
, current
);
2100 unsigned long flags
;
2101 unsigned count
, tmo
;
2105 if (file
->f_mode
& FMODE_WRITE
) {
2106 __set_current_state(TASK_INTERRUPTIBLE
);
2107 add_wait_queue(&s
->midi
.owait
, &wait
);
2109 spin_lock_irqsave(&s
->lock
, flags
);
2110 count
= s
->midi
.ocnt
;
2111 spin_unlock_irqrestore(&s
->lock
, flags
);
2114 if (signal_pending(current
))
2116 if (file
->f_flags
& O_NONBLOCK
) {
2117 remove_wait_queue(&s
->midi
.owait
, &wait
);
2118 set_current_state(TASK_RUNNING
);
2121 tmo
= (count
* HZ
) / 3100;
2122 if (!schedule_timeout(tmo
? : 1) && tmo
)
2123 printk(KERN_DEBUG
"sv: midi timed out??\n");
2125 remove_wait_queue(&s
->midi
.owait
, &wait
);
2126 set_current_state(TASK_RUNNING
);
2129 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2130 spin_lock_irqsave(&s
->lock
, flags
);
2131 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2132 outb(inb(s
->ioenh
+ SV_CODEC_INTMASK
) & ~SV_CINTMASK_MIDI
, s
->ioenh
+ SV_CODEC_INTMASK
);
2133 del_timer(&s
->midi
.timer
);
2135 spin_unlock_irqrestore(&s
->lock
, flags
);
2137 wake_up(&s
->open_wait
);
2142 static /*const*/ struct file_operations sv_midi_fops
= {
2155 NULL
, /* check_media_change */
2156 NULL
, /* revalidate */
2160 /* --------------------------------------------------------------------- */
2162 static int sv_dmfm_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
2164 static const unsigned char op_offset
[18] = {
2165 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2166 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
2167 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
2169 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2170 struct dm_fm_voice v
;
2171 struct dm_fm_note n
;
2172 struct dm_fm_params p
;
2177 case FM_IOCTL_RESET
:
2178 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2179 outb(regb
, s
->iosynth
);
2180 outb(0, s
->iosynth
+1);
2181 outb(regb
, s
->iosynth
+2);
2182 outb(0, s
->iosynth
+3);
2186 case FM_IOCTL_PLAY_NOTE
:
2187 if (copy_from_user(&n
, (void *)arg
, sizeof(n
)))
2198 outb(0xa0 + regb
, io
);
2199 outb(n
.fnum
& 0xff, io
+1);
2200 outb(0xb0 + regb
, io
);
2201 outb(((n
.fnum
>> 8) & 3) | ((n
.octave
& 7) << 2) | ((n
.key_on
& 1) << 5), io
+1);
2204 case FM_IOCTL_SET_VOICE
:
2205 if (copy_from_user(&v
, (void *)arg
, sizeof(v
)))
2209 regb
= op_offset
[v
.voice
];
2210 io
= s
->iosynth
+ ((v
.op
& 1) << 1);
2211 outb(0x20 + regb
, io
);
2212 outb(((v
.am
& 1) << 7) | ((v
.vibrato
& 1) << 6) | ((v
.do_sustain
& 1) << 5) |
2213 ((v
.kbd_scale
& 1) << 4) | (v
.harmonic
& 0xf), io
+1);
2214 outb(0x40 + regb
, io
);
2215 outb(((v
.scale_level
& 0x3) << 6) | (v
.volume
& 0x3f), io
+1);
2216 outb(0x60 + regb
, io
);
2217 outb(((v
.attack
& 0xf) << 4) | (v
.decay
& 0xf), io
+1);
2218 outb(0x80 + regb
, io
);
2219 outb(((v
.sustain
& 0xf) << 4) | (v
.release
& 0xf), io
+1);
2220 outb(0xe0 + regb
, io
);
2221 outb(v
.waveform
& 0x7, io
+1);
2229 outb(0xc0 + regb
, io
);
2230 outb(((v
.right
& 1) << 5) | ((v
.left
& 1) << 4) | ((v
.feedback
& 7) << 1) |
2231 (v
.connection
& 1), io
+1);
2234 case FM_IOCTL_SET_PARAMS
:
2235 if (copy_from_user(&p
, (void *)arg
, sizeof(p
)))
2237 outb(0x08, s
->iosynth
);
2238 outb((p
.kbd_split
& 1) << 6, s
->iosynth
+1);
2239 outb(0xbd, s
->iosynth
);
2240 outb(((p
.am_depth
& 1) << 7) | ((p
.vib_depth
& 1) << 6) | ((p
.rhythm
& 1) << 5) | ((p
.bass
& 1) << 4) |
2241 ((p
.snare
& 1) << 3) | ((p
.tomtom
& 1) << 2) | ((p
.cymbal
& 1) << 1) | (p
.hihat
& 1), s
->iosynth
+1);
2244 case FM_IOCTL_SET_OPL
:
2245 outb(4, s
->iosynth
+2);
2246 outb(arg
, s
->iosynth
+3);
2249 case FM_IOCTL_SET_MODE
:
2250 outb(5, s
->iosynth
+2);
2251 outb(arg
& 1, s
->iosynth
+3);
2259 static int sv_dmfm_open(struct inode
*inode
, struct file
*file
)
2261 int minor
= MINOR(inode
->i_rdev
);
2262 struct sv_state
*s
= devs
;
2264 while (s
&& s
->dev_dmfm
!= minor
)
2269 file
->private_data
= s
;
2270 /* wait for device to become free */
2272 while (s
->open_mode
& FMODE_DMFM
) {
2273 if (file
->f_flags
& O_NONBLOCK
) {
2278 interruptible_sleep_on(&s
->open_wait
);
2279 if (signal_pending(current
))
2280 return -ERESTARTSYS
;
2283 /* init the stuff */
2284 outb(1, s
->iosynth
);
2285 outb(0x20, s
->iosynth
+1); /* enable waveforms */
2286 outb(4, s
->iosynth
+2);
2287 outb(0, s
->iosynth
+3); /* no 4op enabled */
2288 outb(5, s
->iosynth
+2);
2289 outb(1, s
->iosynth
+3); /* enable OPL3 */
2290 s
->open_mode
|= FMODE_DMFM
;
2296 static int sv_dmfm_release(struct inode
*inode
, struct file
*file
)
2298 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2303 s
->open_mode
&= ~FMODE_DMFM
;
2304 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2305 outb(regb
, s
->iosynth
);
2306 outb(0, s
->iosynth
+1);
2307 outb(regb
, s
->iosynth
+2);
2308 outb(0, s
->iosynth
+3);
2311 wake_up(&s
->open_wait
);
2316 static /*const*/ struct file_operations sv_dmfm_fops
= {
2329 NULL
, /* check_media_change */
2330 NULL
, /* revalidate */
2334 /* --------------------------------------------------------------------- */
2336 /* maximum number of devices */
2339 static int reverb
[NR_DEVICE
] = { 0, };
2342 static int wavetable
[NR_DEVICE
] = { 0, };
2345 MODULE_PARM(reverb
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2346 MODULE_PARM_DESC(reverb
, "if 1 enables the reverb circuitry. NOTE: your card must have the reverb RAM");
2348 MODULE_PARM(wavetable
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2349 MODULE_PARM_DESC(wavetable
, "if 1 the wavetable synth is enabled");
2352 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2353 MODULE_DESCRIPTION("S3 SonicVibes Driver");
2355 /* --------------------------------------------------------------------- */
2357 static struct initvol
{
2360 } initvol
[] __initdata
= {
2361 { SOUND_MIXER_WRITE_RECLEV
, 0x4040 },
2362 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2363 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2364 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2365 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2366 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2367 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2368 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2369 { SOUND_MIXER_WRITE_PCM
, 0x4040 }
2372 #define RSRCISIOREGION(dev,num) ((dev)->resource[(num)].start != 0 && \
2373 ((dev)->resource[(num)].flags & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
2374 #define RSRCADDRESS(dev,num) ((dev)->resource[(num)].start)
2376 static int __init
init_sonicvibes(void)
2378 static const char __initlocaldata sv_ddma_name
[] = "S3 Inc. SonicVibes DDMA Controller";
2380 struct pci_dev
*pcidev
= NULL
;
2382 int i
, val
, index
= 0;
2384 unsigned ddmanamelen
;
2386 if (!pci_present()) /* No PCI bus in this machine! */
2388 printk(KERN_INFO
"sv: version v0.20 time " __TIME__
" " __DATE__
"\n");
2390 if (!(wavetable_mem
= __get_free_pages(GFP_KERNEL
, 20-PAGE_SHIFT
)))
2391 printk(KERN_INFO
"sv: cannot allocate 1MB of contiguous nonpageable memory for wavetable data\n");
2393 while (index
< NR_DEVICE
&&
2394 (pcidev
= pci_find_device(PCI_VENDOR_ID_S3
, PCI_DEVICE_ID_S3_SONICVIBES
, pcidev
))) {
2395 if (!RSRCISIOREGION(pcidev
, RESOURCE_SB
) ||
2396 !RSRCISIOREGION(pcidev
, RESOURCE_ENH
) ||
2397 !RSRCISIOREGION(pcidev
, RESOURCE_SYNTH
) ||
2398 !RSRCISIOREGION(pcidev
, RESOURCE_MIDI
) ||
2399 !RSRCISIOREGION(pcidev
, RESOURCE_GAME
))
2401 if (pcidev
->irq
== 0)
2403 /* try to allocate a DDMA resource if not already available */
2404 if (!RSRCISIOREGION(pcidev
, RESOURCE_DDMA
)) {
2405 /* take care of ISA aliases */
2406 ddmanamelen
= strlen(sv_ddma_name
)+1;
2407 if (!(ddmaname
= kmalloc(ddmanamelen
, GFP_KERNEL
)))
2409 memcpy(ddmaname
, sv_ddma_name
, ddmanamelen
);
2410 pcidev
->resource
[RESOURCE_DDMA
].name
= ddmaname
;
2411 if (allocate_resource(&ioport_resource
, pcidev
->resource
+RESOURCE_DDMA
,
2412 2*SV_EXTENT_DMA
, 0x1000, 0x10000-2*SV_EXTENT_DMA
, 1024)) {
2413 pcidev
->resource
[RESOURCE_DDMA
].name
= NULL
;
2415 printk(KERN_ERR
"sv: cannot allocate DDMA controller io ports\n");
2418 pcidev
->resource
[RESOURCE_DDMA
].flags
= PCI_BASE_ADDRESS_SPACE_IO
| IORESOURCE_IO
;
2420 if (!(s
= kmalloc(sizeof(struct sv_state
), GFP_KERNEL
))) {
2421 printk(KERN_WARNING
"sv: out of memory\n");
2424 memset(s
, 0, sizeof(struct sv_state
));
2425 init_waitqueue_head(&s
->dma_adc
.wait
);
2426 init_waitqueue_head(&s
->dma_dac
.wait
);
2427 init_waitqueue_head(&s
->open_wait
);
2428 init_waitqueue_head(&s
->midi
.iwait
);
2429 init_waitqueue_head(&s
->midi
.owait
);
2430 init_MUTEX(&s
->open_sem
);
2431 spin_lock_init(&s
->lock
);
2432 s
->magic
= SV_MAGIC
;
2433 s
->iosb
= RSRCADDRESS(pcidev
, RESOURCE_SB
);
2434 s
->ioenh
= RSRCADDRESS(pcidev
, RESOURCE_ENH
);
2435 s
->iosynth
= RSRCADDRESS(pcidev
, RESOURCE_SYNTH
);
2436 s
->iomidi
= RSRCADDRESS(pcidev
, RESOURCE_MIDI
);
2437 s
->iogame
= RSRCADDRESS(pcidev
, RESOURCE_GAME
);
2438 s
->iodmaa
= RSRCADDRESS(pcidev
, RESOURCE_DDMA
);
2439 s
->iodmac
= RSRCADDRESS(pcidev
, RESOURCE_DDMA
) + SV_EXTENT_DMA
;
2440 pci_write_config_dword(pcidev
, 0x40, s
->iodmaa
| 9); /* enable and use extended mode */
2441 pci_write_config_dword(pcidev
, 0x48, s
->iodmac
| 9); /* enable */
2442 printk(KERN_DEBUG
"sv: io ports: %#lx %#lx %#lx %#lx %#lx %#x %#x\n",
2443 s
->iosb
, s
->ioenh
, s
->iosynth
, s
->iomidi
, s
->iogame
, s
->iodmaa
, s
->iodmac
);
2444 s
->irq
= pcidev
->irq
;
2447 pci_write_config_dword(pcidev
, 0x60, wavetable_mem
>> 12); /* wavetable base address */
2449 if (check_region(s
->ioenh
, SV_EXTENT_ENH
)) {
2450 printk(KERN_ERR
"sv: io ports %#lx-%#lx in use\n", s
->ioenh
, s
->ioenh
+SV_EXTENT_ENH
-1);
2453 request_region(s
->ioenh
, SV_EXTENT_ENH
, "S3 SonicVibes PCM");
2454 if (check_region(s
->iodmaa
, SV_EXTENT_DMA
)) {
2455 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iodmaa
, s
->iodmaa
+SV_EXTENT_DMA
-1);
2458 request_region(s
->iodmaa
, SV_EXTENT_DMA
, "S3 SonicVibes DMAA");
2459 if (check_region(s
->iodmac
, SV_EXTENT_DMA
)) {
2460 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iodmac
, s
->iodmac
+SV_EXTENT_DMA
-1);
2463 request_region(s
->iodmac
, SV_EXTENT_DMA
, "S3 SonicVibes DMAC");
2464 if (check_region(s
->iomidi
, SV_EXTENT_MIDI
)) {
2465 printk(KERN_ERR
"sv: io ports %#lx-%#lx in use\n", s
->iomidi
, s
->iomidi
+SV_EXTENT_MIDI
-1);
2468 request_region(s
->iomidi
, SV_EXTENT_MIDI
, "S3 SonicVibes Midi");
2469 if (check_region(s
->iosynth
, SV_EXTENT_SYNTH
)) {
2470 printk(KERN_ERR
"sv: io ports %#lx-%#lx in use\n", s
->iosynth
, s
->iosynth
+SV_EXTENT_SYNTH
-1);
2473 request_region(s
->iosynth
, SV_EXTENT_SYNTH
, "S3 SonicVibes Synth");
2474 /* initialize codec registers */
2475 outb(0x80, s
->ioenh
+ SV_CODEC_CONTROL
); /* assert reset */
2477 outb(0x00, s
->ioenh
+ SV_CODEC_CONTROL
); /* deassert reset */
2479 outb(SV_CCTRL_INTADRIVE
| SV_CCTRL_ENHANCED
/*| SV_CCTRL_WAVETABLE */
2480 | (reverb
[index
] ? SV_CCTRL_REVERB
: 0), s
->ioenh
+ SV_CODEC_CONTROL
);
2481 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* clear ints */
2482 wrindir(s
, SV_CIDRIVECONTROL
, 0); /* drive current 16mA */
2483 wrindir(s
, SV_CIENABLE
, s
->enable
= 0); /* disable DMAA and DMAC */
2484 outb(~(SV_CINTMASK_DMAA
| SV_CINTMASK_DMAC
), s
->ioenh
+ SV_CODEC_INTMASK
);
2485 /* outb(0xff, s->iodmaa + SV_DMA_RESET); */
2486 /* outb(0xff, s->iodmac + SV_DMA_RESET); */
2487 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* ack interrupts */
2488 wrindir(s
, SV_CIADCCLKSOURCE
, 0); /* use pll as ADC clock source */
2489 wrindir(s
, SV_CIANALOGPWRDOWN
, 0); /* power up the analog parts of the device */
2490 wrindir(s
, SV_CIDIGITALPWRDOWN
, 0); /* power up the digital parts of the device */
2491 setpll(s
, SV_CIADCPLLM
, 8000);
2492 wrindir(s
, SV_CISRSSPACE
, 0x80); /* SRS off */
2493 wrindir(s
, SV_CIPCMSR0
, (8000 * 65536 / FULLRATE
) & 0xff);
2494 wrindir(s
, SV_CIPCMSR1
, ((8000 * 65536 / FULLRATE
) >> 8) & 0xff);
2495 wrindir(s
, SV_CIADCOUTPUT
, 0);
2497 if (request_irq(s
->irq
, sv_interrupt
, SA_SHIRQ
, "S3 SonicVibes", s
)) {
2498 printk(KERN_ERR
"sv: irq %u in use\n", s
->irq
);
2501 printk(KERN_INFO
"sv: found adapter at io %#lx irq %u dmaa %#06x dmac %#06x revision %u\n",
2502 s
->ioenh
, s
->irq
, s
->iodmaa
, s
->iodmac
, rdindir(s
, SV_CIREVISION
));
2503 /* register devices */
2504 if ((s
->dev_audio
= register_sound_dsp(&sv_audio_fops
, -1)) < 0)
2506 if ((s
->dev_mixer
= register_sound_mixer(&sv_mixer_fops
, -1)) < 0)
2508 if ((s
->dev_midi
= register_sound_midi(&sv_midi_fops
, -1)) < 0)
2510 if ((s
->dev_dmfm
= register_sound_special(&sv_dmfm_fops
, 15 /* ?? */)) < 0)
2512 pci_set_master(pcidev
); /* enable bus mastering */
2513 /* initialize the chips */
2516 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
;
2517 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2518 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2519 val
= initvol
[i
].vol
;
2520 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2523 /* queue it for later freeing */
2530 unregister_sound_midi(s
->dev_midi
);
2532 unregister_sound_mixer(s
->dev_mixer
);
2534 unregister_sound_dsp(s
->dev_audio
);
2536 printk(KERN_ERR
"sv: cannot register misc device\n");
2537 free_irq(s
->irq
, s
);
2539 release_region(s
->iosynth
, SV_EXTENT_SYNTH
);
2541 release_region(s
->iomidi
, SV_EXTENT_MIDI
);
2543 release_region(s
->iodmac
, SV_EXTENT_DMA
);
2545 release_region(s
->iodmaa
, SV_EXTENT_DMA
);
2547 release_region(s
->ioenh
, SV_EXTENT_ENH
);
2549 kfree_s(s
, sizeof(struct sv_state
));
2553 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2559 static void __exit
cleanup_sonicvibes(void)
2563 while ((s
= devs
)) {
2565 outb(~0, s
->ioenh
+ SV_CODEC_INTMASK
); /* disable ints */
2567 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* ack interrupts */
2568 wrindir(s
, SV_CIENABLE
, 0); /* disable DMAA and DMAC */
2569 /*outb(0, s->iodmaa + SV_DMA_RESET);*/
2570 /*outb(0, s->iodmac + SV_DMA_RESET);*/
2571 free_irq(s
->irq
, s
);
2572 release_region(s
->iodmac
, SV_EXTENT_DMA
);
2573 release_region(s
->iodmaa
, SV_EXTENT_DMA
);
2574 release_region(s
->ioenh
, SV_EXTENT_ENH
);
2575 release_region(s
->iomidi
, SV_EXTENT_MIDI
);
2576 release_region(s
->iosynth
, SV_EXTENT_SYNTH
);
2577 unregister_sound_dsp(s
->dev_audio
);
2578 unregister_sound_mixer(s
->dev_mixer
);
2579 unregister_sound_midi(s
->dev_midi
);
2580 unregister_sound_special(s
->dev_dmfm
);
2581 kfree_s(s
, sizeof(struct sv_state
));
2584 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2585 printk(KERN_INFO
"sv: unloading\n");
2588 module_init(init_sonicvibes
);
2589 module_exit(cleanup_sonicvibes
);
2591 /* --------------------------------------------------------------------- */
2595 /* format is: sonicvibes=[reverb] sonicvibesdmaio=dmaioaddr */
2597 static int __init
sonicvibes_setup(char *str
)
2599 static unsigned __initlocaldata nr_dev
= 0;
2601 if (nr_dev
>= NR_DEVICE
)
2604 if (get_option(&str
, &reverb
[nr_dev
]) == 2)
2605 (void)get_option(&str
, &wavetable
[nr_dev
]);
2607 (void)get_option(&str
, &reverb
[nr_dev
]);
2614 __setup("sonicvibes=", sonicvibes_setup
);