1 /*****************************************************************************/
4 * sonicvibes.c -- S3 Sonic Vibes audio driver.
6 * Copyright (C) 1998 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
61 /*****************************************************************************/
63 #include <linux/version.h>
64 #include <linux/module.h>
65 #include <linux/string.h>
66 #include <linux/ioport.h>
67 #include <linux/sched.h>
68 #include <linux/delay.h>
69 #include <linux/sound.h>
70 #include <linux/malloc.h>
71 #include <linux/soundcard.h>
72 #include <linux/pci.h>
75 #include <linux/init.h>
76 #include <linux/poll.h>
77 #include <asm/spinlock.h>
78 #include <asm/uaccess.h>
79 #include <asm/hardirq.h>
83 /* --------------------------------------------------------------------- */
85 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
87 /* --------------------------------------------------------------------- */
89 #ifndef PCI_VENDOR_ID_S3
90 #define PCI_VENDOR_ID_S3 0x5333
92 #ifndef PCI_DEVICE_ID_S3_SONICVIBES
93 #define PCI_DEVICE_ID_S3_SONICVIBES 0xca00
96 #define SV_MAGIC ((PCI_VENDOR_ID_S3<<16)|PCI_DEVICE_ID_S3_SONICVIBES)
98 #define SV_EXTENT_SB 0x10
99 #define SV_EXTENT_ENH 0x10
100 #define SV_EXTENT_SYNTH 0x4
101 #define SV_EXTENT_MIDI 0x4
102 #define SV_EXTENT_GAME 0x8
103 #define SV_EXTENT_DMA 0x10
106 #define SV_MIDI_DATA 0
107 #define SV_MIDI_COMMAND 1
108 #define SV_MIDI_STATUS 1
110 #define SV_DMA_ADDR0 0
111 #define SV_DMA_ADDR1 1
112 #define SV_DMA_ADDR2 2
113 #define SV_DMA_ADDR3 3
114 #define SV_DMA_COUNT0 4
115 #define SV_DMA_COUNT1 5
116 #define SV_DMA_COUNT2 6
117 #define SV_DMA_MODE 0xb
118 #define SV_DMA_RESET 0xd
119 #define SV_DMA_MASK 0xf
122 * DONT reset the DMA controllers unless you understand
123 * the reset semantics. Assuming reset semantics as in
124 * the 8237 does not work.
127 #define DMA_MODE_AUTOINIT 0x10
128 #define DMA_MODE_READ 0x44 /* I/O to memory, no autoinit, increment, single mode */
129 #define DMA_MODE_WRITE 0x48 /* memory to I/O, no autoinit, increment, single mode */
131 #define SV_CODEC_CONTROL 0
132 #define SV_CODEC_INTMASK 1
133 #define SV_CODEC_STATUS 2
134 #define SV_CODEC_IADDR 4
135 #define SV_CODEC_IDATA 5
137 #define SV_CCTRL_RESET 0x80
138 #define SV_CCTRL_INTADRIVE 0x20
139 #define SV_CCTRL_WAVETABLE 0x08
140 #define SV_CCTRL_REVERB 0x04
141 #define SV_CCTRL_ENHANCED 0x01
143 #define SV_CINTMASK_DMAA 0x01
144 #define SV_CINTMASK_DMAC 0x04
145 #define SV_CINTMASK_SPECIAL 0x08
146 #define SV_CINTMASK_UPDOWN 0x40
147 #define SV_CINTMASK_MIDI 0x80
149 #define SV_CSTAT_DMAA 0x01
150 #define SV_CSTAT_DMAC 0x04
151 #define SV_CSTAT_SPECIAL 0x08
152 #define SV_CSTAT_UPDOWN 0x40
153 #define SV_CSTAT_MIDI 0x80
155 #define SV_CIADDR_TRD 0x80
156 #define SV_CIADDR_MCE 0x40
158 /* codec indirect registers */
159 #define SV_CIMIX_ADCINL 0x00
160 #define SV_CIMIX_ADCINR 0x01
161 #define SV_CIMIX_AUX1INL 0x02
162 #define SV_CIMIX_AUX1INR 0x03
163 #define SV_CIMIX_CDINL 0x04
164 #define SV_CIMIX_CDINR 0x05
165 #define SV_CIMIX_LINEINL 0x06
166 #define SV_CIMIX_LINEINR 0x07
167 #define SV_CIMIX_MICIN 0x08
168 #define SV_CIMIX_SYNTHINL 0x0A
169 #define SV_CIMIX_SYNTHINR 0x0B
170 #define SV_CIMIX_AUX2INL 0x0C
171 #define SV_CIMIX_AUX2INR 0x0D
172 #define SV_CIMIX_ANALOGINL 0x0E
173 #define SV_CIMIX_ANALOGINR 0x0F
174 #define SV_CIMIX_PCMINL 0x10
175 #define SV_CIMIX_PCMINR 0x11
177 #define SV_CIGAMECONTROL 0x09
178 #define SV_CIDATAFMT 0x12
179 #define SV_CIENABLE 0x13
180 #define SV_CIUPDOWN 0x14
181 #define SV_CIREVISION 0x15
182 #define SV_CIADCOUTPUT 0x16
183 #define SV_CIDMAABASECOUNT1 0x18
184 #define SV_CIDMAABASECOUNT0 0x19
185 #define SV_CIDMACBASECOUNT1 0x1c
186 #define SV_CIDMACBASECOUNT0 0x1d
187 #define SV_CIPCMSR0 0x1e
188 #define SV_CIPCMSR1 0x1f
189 #define SV_CISYNTHSR0 0x20
190 #define SV_CISYNTHSR1 0x21
191 #define SV_CIADCCLKSOURCE 0x22
192 #define SV_CIADCALTSR 0x23
193 #define SV_CIADCPLLM 0x24
194 #define SV_CIADCPLLN 0x25
195 #define SV_CISYNTHPLLM 0x26
196 #define SV_CISYNTHPLLN 0x27
197 #define SV_CIUARTCONTROL 0x2a
198 #define SV_CIDRIVECONTROL 0x2b
199 #define SV_CISRSSPACE 0x2c
200 #define SV_CISRSCENTER 0x2d
201 #define SV_CIWAVETABLESRC 0x2e
202 #define SV_CIANALOGPWRDOWN 0x30
203 #define SV_CIDIGITALPWRDOWN 0x31
206 #define SV_CIMIX_ADCSRC_CD 0x20
207 #define SV_CIMIX_ADCSRC_DAC 0x40
208 #define SV_CIMIX_ADCSRC_AUX2 0x60
209 #define SV_CIMIX_ADCSRC_LINE 0x80
210 #define SV_CIMIX_ADCSRC_AUX1 0xa0
211 #define SV_CIMIX_ADCSRC_MIC 0xc0
212 #define SV_CIMIX_ADCSRC_MIXOUT 0xe0
213 #define SV_CIMIX_ADCSRC_MASK 0xe0
215 #define SV_CFMT_STEREO 0x01
216 #define SV_CFMT_16BIT 0x02
217 #define SV_CFMT_MASK 0x03
218 #define SV_CFMT_ASHIFT 0
219 #define SV_CFMT_CSHIFT 4
221 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
222 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
224 #define SV_CENABLE_PPE 0x4
225 #define SV_CENABLE_RE 0x2
226 #define SV_CENABLE_PE 0x1
229 /* MIDI buffer sizes */
231 #define MIDIINBUF 256
232 #define MIDIOUTBUF 256
234 #define FMODE_MIDI_SHIFT 2
235 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
236 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
238 #define FMODE_DMFM 0x10
240 #define SND_DEV_DSP16 5
242 /* --------------------------------------------------------------------- */
248 /* we keep sv cards in a linked list */
249 struct sv_state
*next
;
251 /* soundcore stuff */
257 /* hardware resources */
258 unsigned int iosb
, ioenh
, iosynth
, iomidi
, iogame
, iodmaa
, iodmac
, irq
;
263 #ifndef OSS_DOCUMENTED_MIXER_SEMANTICS
264 unsigned short vol
[13];
265 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
269 unsigned int rateadc
, ratedac
;
270 unsigned char fmt
, enable
;
273 struct semaphore open_sem
;
275 struct wait_queue
*open_wait
;
282 unsigned hwptr
, swptr
;
283 unsigned total_bytes
;
285 unsigned error
; /* over/underrun */
286 struct wait_queue
*wait
;
287 /* redundant, but makes calculations easier */
290 unsigned fragsamples
;
294 unsigned endcleared
:1;
295 unsigned ossfragshift
;
297 unsigned subdivision
;
302 unsigned ird
, iwr
, icnt
;
303 unsigned ord
, owr
, ocnt
;
304 struct wait_queue
*iwait
;
305 struct wait_queue
*owait
;
306 struct timer_list timer
;
307 unsigned char ibuf
[MIDIINBUF
];
308 unsigned char obuf
[MIDIOUTBUF
];
312 /* --------------------------------------------------------------------- */
314 static struct sv_state
*devs
= NULL
;
315 static unsigned long wavetable_mem
= 0;
317 /* --------------------------------------------------------------------- */
319 extern __inline__
unsigned ld2(unsigned int x
)
345 * hweightN: returns the hamming weight (i.e. the number
346 * of bits set) of a N-bit word
353 extern __inline__
unsigned int hweight32(unsigned int w
)
355 unsigned int res
= (w
& 0x55555555) + ((w
>> 1) & 0x55555555);
356 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
357 res
= (res
& 0x0F0F0F0F) + ((res
>> 4) & 0x0F0F0F0F);
358 res
= (res
& 0x00FF00FF) + ((res
>> 8) & 0x00FF00FF);
359 return (res
& 0x0000FFFF) + ((res
>> 16) & 0x0000FFFF);
362 /* --------------------------------------------------------------------- */
365 * Why use byte IO? Nobody knows, but S3 does it also in their Windows driver.
370 static void set_dmaa(struct sv_state
*s
, unsigned int addr
, unsigned int count
)
373 unsigned io
= s
->iodmaa
, u
;
376 for (u
= 4; u
> 0; u
--, addr
>>= 8, io
++)
377 outb(addr
& 0xff, io
);
378 for (u
= 3; u
> 0; u
--, count
>>= 8, io
++)
379 outb(count
& 0xff, io
);
380 #else /* DMABYTEIO */
382 outl(addr
, s
->iodmaa
+ SV_DMA_ADDR0
);
383 outl(count
, s
->iodmaa
+ SV_DMA_COUNT0
);
384 #endif /* DMABYTEIO */
385 outb(0x18, s
->iodmaa
+ SV_DMA_MODE
);
388 static void set_dmac(struct sv_state
*s
, unsigned int addr
, unsigned int count
)
391 unsigned io
= s
->iodmac
, u
;
395 for (u
= 4; u
> 0; u
--, addr
>>= 8, io
++)
396 outb(addr
& 0xff, io
);
397 for (u
= 3; u
> 0; u
--, count
>>= 8, io
++)
398 outb(count
& 0xff, io
);
399 #else /* DMABYTEIO */
402 outl(addr
, s
->iodmac
+ SV_DMA_ADDR0
);
403 outl(count
, s
->iodmac
+ SV_DMA_COUNT0
);
404 #endif /* DMABYTEIO */
405 outb(0x14, s
->iodmac
+ SV_DMA_MODE
);
408 extern __inline__
unsigned get_dmaa(struct sv_state
*s
)
411 unsigned io
= s
->iodmaa
+6, v
= 0, u
;
413 for (u
= 3; u
> 0; u
--, io
--) {
418 #else /* DMABYTEIO */
419 return (inl(s
->iodmaa
+ SV_DMA_COUNT0
) & 0xffffff) + 1;
420 #endif /* DMABYTEIO */
423 extern __inline__
unsigned get_dmac(struct sv_state
*s
)
426 unsigned io
= s
->iodmac
+6, v
= 0, u
;
428 for (u
= 3; u
> 0; u
--, io
--) {
433 #else /* DMABYTEIO */
434 return ((inl(s
->iodmac
+ SV_DMA_COUNT0
) & 0xffffff) + 1) << 1;
435 #endif /* DMABYTEIO */
438 static void wrindir(struct sv_state
*s
, unsigned char idx
, unsigned char data
)
440 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
442 outb(data
, s
->ioenh
+ SV_CODEC_IDATA
);
446 static unsigned char rdindir(struct sv_state
*s
, unsigned char idx
)
450 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
452 v
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
457 static void set_fmt(struct sv_state
*s
, unsigned char mask
, unsigned char data
)
461 spin_lock_irqsave(&s
->lock
, flags
);
462 outb(SV_CIDATAFMT
| SV_CIADDR_MCE
, s
->ioenh
+ SV_CODEC_IADDR
);
464 s
->fmt
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
467 s
->fmt
= (s
->fmt
& mask
) | data
;
468 outb(s
->fmt
, s
->ioenh
+ SV_CODEC_IDATA
);
470 outb(0, s
->ioenh
+ SV_CODEC_IADDR
);
471 spin_unlock_irqrestore(&s
->lock
, flags
);
475 static void frobindir(struct sv_state
*s
, unsigned char idx
, unsigned char mask
, unsigned char data
)
477 outb(idx
& 0x3f, s
->ioenh
+ SV_CODEC_IADDR
);
479 outb((inb(s
->ioenh
+ SV_CODEC_IDATA
) & mask
) ^ data
, s
->ioenh
+ SV_CODEC_IDATA
);
483 #define REFFREQUENCY 24576000
485 #define FULLRATE 48000
487 static unsigned setpll(struct sv_state
*s
, unsigned char reg
, unsigned rate
)
490 unsigned char r
, m
, n
;
491 unsigned xm
, xn
, xr
, xd
, metric
= ~0U;
492 /* the warnings about m and n used uninitialized are bogus and may safely be ignored */
494 if (rate
< 625000/ADCMULT
)
495 rate
= 625000/ADCMULT
;
496 if (rate
> 150000000/ADCMULT
)
497 rate
= 150000000/ADCMULT
;
498 /* slight violation of specs, needed for continuous sampling rates */
499 for (r
= 0; rate
< 75000000/ADCMULT
; r
+= 0x20, rate
<<= 1);
500 for (xn
= 3; xn
< 35; xn
++)
501 for (xm
= 3; xm
< 130; xm
++) {
502 xr
= REFFREQUENCY
/ADCMULT
* xm
/ xn
;
503 xd
= abs((signed)(xr
- rate
));
511 spin_lock_irqsave(&s
->lock
, flags
);
512 outb(reg
, s
->ioenh
+ SV_CODEC_IADDR
);
514 outb(m
, s
->ioenh
+ SV_CODEC_IDATA
);
516 outb(reg
+1, s
->ioenh
+ SV_CODEC_IADDR
);
518 outb(r
| n
, s
->ioenh
+ SV_CODEC_IDATA
);
519 spin_unlock_irqrestore(&s
->lock
, flags
);
521 return (REFFREQUENCY
/ADCMULT
* (m
+ 2) / (n
+ 2)) >> ((r
>> 5) & 7);
526 static unsigned getpll(struct sv_state
*s
, unsigned char reg
)
532 spin_lock_irqsave(&s
->lock
, flags
);
533 outb(reg
, s
->ioenh
+ SV_CODEC_IADDR
);
535 m
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
537 outb(reg
+1, s
->ioenh
+ SV_CODEC_IADDR
);
539 n
= inb(s
->ioenh
+ SV_CODEC_IDATA
);
540 spin_unlock_irqrestore(&s
->lock
, flags
);
542 return (REFFREQUENCY
/ADCMULT
* (m
+ 2) / ((n
& 0x1f) + 2)) >> ((n
>> 5) & 7);
547 static void set_dac_rate(struct sv_state
*s
, unsigned rate
)
556 div
= (rate
* 65536 + FULLRATE
/2) / FULLRATE
;
559 spin_lock_irqsave(&s
->lock
, flags
);
560 wrindir(s
, SV_CIPCMSR1
, div
>> 8);
561 wrindir(s
, SV_CIPCMSR0
, div
);
562 spin_unlock_irqrestore(&s
->lock
, flags
);
563 s
->ratedac
= (div
* FULLRATE
+ 32768) / 65536;
566 static void set_adc_rate(struct sv_state
*s
, unsigned rate
)
569 unsigned rate1
, rate2
, div
;
575 rate1
= setpll(s
, SV_CIADCPLLM
, rate
);
576 div
= (48000 + rate
/2) / rate
;
579 rate2
= (48000 + div
/2) / div
;
580 spin_lock_irqsave(&s
->lock
, flags
);
581 wrindir(s
, SV_CIADCALTSR
, (div
-1) << 4);
582 if (abs((signed)(rate
-rate2
)) <= abs((signed)(rate
-rate1
))) {
583 wrindir(s
, SV_CIADCCLKSOURCE
, 0x10);
586 wrindir(s
, SV_CIADCCLKSOURCE
, 0x00);
589 spin_unlock_irqrestore(&s
->lock
, flags
);
592 /* --------------------------------------------------------------------- */
594 extern inline void stop_adc(struct sv_state
*s
)
598 spin_lock_irqsave(&s
->lock
, flags
);
599 s
->enable
&= ~SV_CENABLE_RE
;
600 wrindir(s
, SV_CIENABLE
, s
->enable
);
601 spin_unlock_irqrestore(&s
->lock
, flags
);
604 extern inline void stop_dac(struct sv_state
*s
)
608 spin_lock_irqsave(&s
->lock
, flags
);
609 s
->enable
&= ~(SV_CENABLE_PPE
| SV_CENABLE_PE
);
610 wrindir(s
, SV_CIENABLE
, s
->enable
);
611 spin_unlock_irqrestore(&s
->lock
, flags
);
614 static void start_dac(struct sv_state
*s
)
618 spin_lock_irqsave(&s
->lock
, flags
);
619 if ((s
->dma_dac
.mapped
|| s
->dma_dac
.count
> 0) && s
->dma_dac
.ready
) {
620 s
->enable
= (s
->enable
& ~SV_CENABLE_PPE
) | SV_CENABLE_PE
;
621 wrindir(s
, SV_CIENABLE
, s
->enable
);
623 spin_unlock_irqrestore(&s
->lock
, flags
);
626 static void start_adc(struct sv_state
*s
)
630 spin_lock_irqsave(&s
->lock
, flags
);
631 if ((s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
632 && s
->dma_adc
.ready
) {
633 s
->enable
|= SV_CENABLE_RE
;
634 wrindir(s
, SV_CIENABLE
, s
->enable
);
636 spin_unlock_irqrestore(&s
->lock
, flags
);
639 /* --------------------------------------------------------------------- */
641 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
642 #define DMABUF_MINORDER 1
644 static void dealloc_dmabuf(struct dmabuf
*db
)
646 unsigned long map
, mapend
;
649 /* undo marking the pages as reserved */
650 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
651 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
652 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
653 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
656 db
->mapped
= db
->ready
= 0;
660 /* DMAA is used for playback, DMAC is used for recording */
662 static int prog_dmabuf(struct sv_state
*s
, unsigned rec
)
664 struct dmabuf
*db
= rec
? &s
->dma_adc
: &s
->dma_dac
;
665 unsigned rate
= rec
? s
->rateadc
: s
->ratedac
;
669 unsigned long map
, mapend
;
673 spin_lock_irqsave(&s
->lock
, flags
);
676 s
->enable
&= ~SV_CENABLE_RE
;
677 fmt
>>= SV_CFMT_CSHIFT
;
679 s
->enable
&= ~SV_CENABLE_PE
;
680 fmt
>>= SV_CFMT_ASHIFT
;
682 wrindir(s
, SV_CIENABLE
, s
->enable
);
683 spin_unlock_irqrestore(&s
->lock
, flags
);
685 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
687 db
->ready
= db
->mapped
= 0;
688 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
&& !db
->rawbuf
; order
--)
689 db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
| GFP_DMA
, order
);
692 db
->buforder
= order
;
693 if ((virt_to_bus(db
->rawbuf
) ^ (virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1)) & ~0xffff)
694 printk(KERN_DEBUG
"sv: DMA buffer crosses 64k boundary: busaddr 0x%lx size %ld\n",
695 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
696 if ((virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1) & ~0xffffff)
697 printk(KERN_DEBUG
"sv: DMA buffer beyond 16MB: busaddr 0x%lx size %ld\n",
698 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
699 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
700 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
701 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
702 set_bit(PG_reserved
, &mem_map
[map
].flags
);
704 bytepersec
= rate
<< sample_shift
[fmt
];
705 bufs
= PAGE_SIZE
<< db
->buforder
;
706 if (db
->ossfragshift
) {
707 if ((1000 << db
->ossfragshift
) < bytepersec
)
708 db
->fragshift
= ld2(bytepersec
/1000);
710 db
->fragshift
= db
->ossfragshift
;
712 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
713 if (db
->fragshift
< 3)
716 db
->numfrag
= bufs
>> db
->fragshift
;
717 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
719 db
->numfrag
= bufs
>> db
->fragshift
;
721 db
->fragsize
= 1 << db
->fragshift
;
722 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
723 db
->numfrag
= db
->ossmaxfrags
;
724 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
725 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
726 memset(db
->rawbuf
, (fmt
& SV_CFMT_16BIT
) ? 0 : 0x80, db
->dmasize
);
727 spin_lock_irqsave(&s
->lock
, flags
);
729 set_dmac(s
, virt_to_bus(db
->rawbuf
), db
->numfrag
<< db
->fragshift
);
730 /* program enhanced mode registers */
731 wrindir(s
, SV_CIDMACBASECOUNT1
, (db
->fragsamples
-1) >> 8);
732 wrindir(s
, SV_CIDMACBASECOUNT0
, db
->fragsamples
-1);
734 set_dmaa(s
, virt_to_bus(db
->rawbuf
), db
->numfrag
<< db
->fragshift
);
735 /* program enhanced mode registers */
736 wrindir(s
, SV_CIDMAABASECOUNT1
, (db
->fragsamples
-1) >> 8);
737 wrindir(s
, SV_CIDMAABASECOUNT0
, db
->fragsamples
-1);
739 spin_unlock_irqrestore(&s
->lock
, flags
);
744 extern __inline__
void clear_advance(struct sv_state
*s
)
746 unsigned char c
= (s
->fmt
& (SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
)) ? 0 : 0x80;
747 unsigned char *buf
= s
->dma_dac
.rawbuf
;
748 unsigned bsize
= s
->dma_dac
.dmasize
;
749 unsigned bptr
= s
->dma_dac
.swptr
;
750 unsigned len
= s
->dma_dac
.fragsize
;
752 if (bptr
+ len
> bsize
) {
753 unsigned x
= bsize
- bptr
;
754 memset(buf
+ bptr
, c
, x
);
758 memset(buf
+ bptr
, c
, len
);
761 /* call with spinlock held! */
762 static void sv_update_ptr(struct sv_state
*s
)
767 /* update ADC pointer */
768 if (s
->dma_adc
.ready
) {
769 hwptr
= (s
->dma_adc
.dmasize
- get_dmac(s
)) % s
->dma_adc
.dmasize
;
770 diff
= (s
->dma_adc
.dmasize
+ hwptr
- s
->dma_adc
.hwptr
) % s
->dma_adc
.dmasize
;
771 s
->dma_adc
.hwptr
= hwptr
;
772 s
->dma_adc
.total_bytes
+= diff
;
773 s
->dma_adc
.count
+= diff
;
774 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
775 wake_up(&s
->dma_adc
.wait
);
776 if (!s
->dma_adc
.mapped
) {
777 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
778 s
->enable
&= ~SV_CENABLE_RE
;
779 wrindir(s
, SV_CIENABLE
, s
->enable
);
784 /* update DAC pointer */
785 if (s
->dma_dac
.ready
) {
786 hwptr
= (s
->dma_dac
.dmasize
- get_dmaa(s
)) % s
->dma_dac
.dmasize
;
787 diff
= (s
->dma_dac
.dmasize
+ hwptr
- s
->dma_dac
.hwptr
) % s
->dma_dac
.dmasize
;
788 s
->dma_dac
.hwptr
= hwptr
;
789 s
->dma_dac
.total_bytes
+= diff
;
790 if (s
->dma_dac
.mapped
) {
791 s
->dma_dac
.count
+= diff
;
792 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
793 wake_up(&s
->dma_dac
.wait
);
795 s
->dma_dac
.count
-= diff
;
796 if (s
->dma_dac
.count
<= 0) {
797 s
->enable
&= ~SV_CENABLE_PE
;
798 wrindir(s
, SV_CIENABLE
, s
->enable
);
800 } else if (s
->dma_dac
.count
<= (signed)s
->dma_dac
.fragsize
&& !s
->dma_dac
.endcleared
) {
802 s
->dma_dac
.endcleared
= 1;
804 if (s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
<= (signed)s
->dma_dac
.dmasize
)
805 wake_up(&s
->dma_dac
.wait
);
810 /* hold spinlock for the following! */
811 static void sv_handle_midi(struct sv_state
*s
)
817 while (!(inb(s
->iomidi
+1) & 0x80)) {
819 if (s
->midi
.icnt
< MIDIINBUF
) {
820 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
821 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
827 wake_up(&s
->midi
.iwait
);
829 while (!(inb(s
->iomidi
+1) & 0x40) && s
->midi
.ocnt
> 0) {
830 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->iomidi
);
831 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
833 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
837 wake_up(&s
->midi
.owait
);
840 static void sv_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
842 struct sv_state
*s
= (struct sv_state
*)dev_id
;
845 /* fastpath out, to ease interrupt sharing */
846 intsrc
= inb(s
->ioenh
+ SV_CODEC_STATUS
);
847 if (!(intsrc
& (SV_CSTAT_DMAA
| SV_CSTAT_DMAC
| SV_CSTAT_MIDI
)))
852 spin_unlock(&s
->lock
);
855 static void sv_midi_timer(unsigned long data
)
857 struct sv_state
*s
= (struct sv_state
*)data
;
860 spin_lock_irqsave(&s
->lock
, flags
);
862 spin_unlock_irqrestore(&s
->lock
, flags
);
863 s
->midi
.timer
.expires
= jiffies
+1;
864 add_timer(&s
->midi
.timer
);
867 /* --------------------------------------------------------------------- */
869 static const char invalid_magic
[] = KERN_CRIT
"sv: invalid magic value\n";
871 #define VALIDATE_STATE(s) \
873 if (!(s) || (s)->magic != SV_MAGIC) { \
874 printk(invalid_magic); \
879 /* --------------------------------------------------------------------- */
883 #define MT_4MUTEMONO 3
886 static const struct {
891 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
892 [SOUND_MIXER_RECLEV
] = { SV_CIMIX_ADCINL
, SV_CIMIX_ADCINR
, MT_4
, 0 },
893 [SOUND_MIXER_LINE1
] = { SV_CIMIX_AUX1INL
, SV_CIMIX_AUX1INR
, MT_5MUTE
, 5 },
894 [SOUND_MIXER_CD
] = { SV_CIMIX_CDINL
, SV_CIMIX_CDINR
, MT_5MUTE
, 1 },
895 [SOUND_MIXER_LINE
] = { SV_CIMIX_LINEINL
, SV_CIMIX_LINEINR
, MT_5MUTE
, 4 },
896 [SOUND_MIXER_MIC
] = { SV_CIMIX_MICIN
, SV_CIMIX_ADCINL
, MT_4MUTEMONO
, 6 },
897 [SOUND_MIXER_SYNTH
] = { SV_CIMIX_SYNTHINL
, SV_CIMIX_SYNTHINR
, MT_5MUTE
, 2 },
898 [SOUND_MIXER_LINE2
] = { SV_CIMIX_AUX2INL
, SV_CIMIX_AUX2INR
, MT_5MUTE
, 3 },
899 [SOUND_MIXER_VOLUME
] = { SV_CIMIX_ANALOGINL
, SV_CIMIX_ANALOGINR
, MT_5MUTE
, 7 },
900 [SOUND_MIXER_PCM
] = { SV_CIMIX_PCMINL
, SV_CIMIX_PCMINR
, MT_6MUTE
, 0 }
903 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
905 static int return_mixval(struct sv_state
*s
, unsigned i
, int *arg
)
908 unsigned char l
, r
, rl
, rr
;
910 spin_lock_irqsave(&s
->lock
, flags
);
911 l
= rdindir(s
, mixtable
[i
].left
);
912 r
= rdindir(s
, mixtable
[i
].right
);
913 spin_unlock_irqrestore(&s
->lock
, flags
);
914 switch (mixtable
[i
].type
) {
918 rl
= 10 + 6 * (l
& 15);
919 rr
= 10 + 6 * (r
& 15);
923 rl
= 55 - 3 * (l
& 15);
932 rl
= 100 - 3 * (l
& 31);
933 rr
= 100 - 3 * (r
& 31);
937 rl
= 100 - 3 * (l
& 63) / 2;
938 rr
= 100 - 3 * (r
& 63) / 2;
945 return put_user((rr
<< 8) | rl
, arg
);
948 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
950 static const unsigned char volidx
[SOUND_MIXER_NRDEVICES
] =
952 [SOUND_MIXER_RECLEV
] = 1,
953 [SOUND_MIXER_LINE1
] = 2,
954 [SOUND_MIXER_CD
] = 3,
955 [SOUND_MIXER_LINE
] = 4,
956 [SOUND_MIXER_MIC
] = 5,
957 [SOUND_MIXER_SYNTH
] = 6,
958 [SOUND_MIXER_LINE2
] = 7,
959 [SOUND_MIXER_VOLUME
] = 8,
960 [SOUND_MIXER_PCM
] = 9
963 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
965 static unsigned mixer_recmask(struct sv_state
*s
)
970 spin_lock_irqsave(&s
->lock
, flags
);
971 j
= rdindir(s
, SV_CIMIX_ADCINL
) >> 5;
972 spin_unlock_irqrestore(&s
->lock
, flags
);
974 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
&& mixtable
[i
].rec
!= j
; i
++);
978 static int mixer_ioctl(struct sv_state
*s
, unsigned int cmd
, unsigned long arg
)
982 unsigned char l
, r
, rl
, rr
;
985 if (cmd
== SOUND_MIXER_INFO
) {
987 strncpy(info
.id
, "SonicVibes", sizeof(info
.id
));
988 strncpy(info
.name
, "S3 SonicVibes", sizeof(info
.name
));
989 info
.modify_counter
= s
->mix
.modcnt
;
990 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
994 if (cmd
== SOUND_OLD_MIXER_INFO
) {
995 _old_mixer_info info
;
996 strncpy(info
.id
, "SonicVibes", sizeof(info
.id
));
997 strncpy(info
.name
, "S3 SonicVibes", sizeof(info
.name
));
998 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
1002 if (cmd
== OSS_GETVERSION
)
1003 return put_user(SOUND_VERSION
, (int *)arg
);
1004 if (cmd
== SOUND_MIXER_PRIVATE1
) { /* SRS settings */
1005 get_user_ret(val
, (int *)arg
, -EFAULT
);
1006 spin_lock_irqsave(&s
->lock
, flags
);
1009 l
= 4 - ((val
>> 2) & 7);
1012 r
= 4 - ((val
>> 5) & 7);
1015 wrindir(s
, SV_CISRSSPACE
, l
);
1016 wrindir(s
, SV_CISRSCENTER
, r
);
1018 wrindir(s
, SV_CISRSSPACE
, 0x80);
1020 l
= rdindir(s
, SV_CISRSSPACE
);
1021 r
= rdindir(s
, SV_CISRSCENTER
);
1022 spin_unlock_irqrestore(&s
->lock
, flags
);
1024 return put_user(0, (int *)arg
);
1025 return put_user(((4 - (l
& 7)) << 2) | ((4 - (r
& 7)) << 5) | 2, (int *)arg
);
1027 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
1029 if (_IOC_DIR(cmd
) == _IOC_READ
) {
1030 switch (_IOC_NR(cmd
)) {
1031 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
1032 return put_user(mixer_recmask(s
), (int *)arg
);
1034 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
1035 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1036 if (mixtable
[i
].type
)
1038 return put_user(val
, (int *)arg
);
1040 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
1041 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1042 if (mixtable
[i
].rec
)
1044 return put_user(val
, (int *)arg
);
1046 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
1047 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1048 if (mixtable
[i
].type
&& mixtable
[i
].type
!= MT_4MUTEMONO
)
1050 return put_user(val
, (int *)arg
);
1052 case SOUND_MIXER_CAPS
:
1053 return put_user(SOUND_CAP_EXCL_INPUT
, (int *)arg
);
1057 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1059 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1060 return return_mixval(s
, i
, (int *)arg
);
1061 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1064 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1065 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1068 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
1071 switch (_IOC_NR(cmd
)) {
1072 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
1073 get_user_ret(val
, (int *)arg
, -EFAULT
);
1076 return 0; /*val = mixer_recmask(s);*/
1078 val
&= ~mixer_recmask(s
);
1079 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
1080 if (!(val
& (1 << i
)))
1082 if (mixtable
[i
].rec
)
1085 if (!mixtable
[i
].rec
)
1087 spin_lock_irqsave(&s
->lock
, flags
);
1088 frobindir(s
, SV_CIMIX_ADCINL
, 0x1f, mixtable
[i
].rec
<< 5);
1089 frobindir(s
, SV_CIMIX_ADCINR
, 0x1f, mixtable
[i
].rec
<< 5);
1090 spin_unlock_irqrestore(&s
->lock
, flags
);
1095 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1097 get_user_ret(val
, (int *)arg
, -EFAULT
);
1099 r
= (val
>> 8) & 0xff;
1100 if (mixtable
[i
].type
== MT_4MUTEMONO
)
1106 spin_lock_irqsave(&s
->lock
, flags
);
1107 switch (mixtable
[i
].type
) {
1113 frobindir(s
, mixtable
[i
].left
, 0xf0, l
/ 6);
1114 frobindir(s
, mixtable
[i
].right
, 0xf0, l
/ 6);
1128 wrindir(s
, mixtable
[i
].left
, rl
);
1129 frobindir(s
, mixtable
[i
].right
, ~0x10, rr
);
1141 wrindir(s
, mixtable
[i
].left
, rl
);
1142 wrindir(s
, mixtable
[i
].right
, rr
);
1149 rl
= (100 - l
) * 2 / 3;
1153 rr
= (100 - r
) * 2 / 3;
1154 wrindir(s
, mixtable
[i
].left
, rl
);
1155 wrindir(s
, mixtable
[i
].right
, rr
);
1158 spin_unlock_irqrestore(&s
->lock
, flags
);
1159 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1160 return return_mixval(s
, i
, (int *)arg
);
1161 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1164 s
->mix
.vol
[volidx
[i
]-1] = val
;
1165 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1166 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1170 /* --------------------------------------------------------------------- */
1172 static loff_t
sv_llseek(struct file
*file
, loff_t offset
, int origin
)
1177 /* --------------------------------------------------------------------- */
1179 static int sv_open_mixdev(struct inode
*inode
, struct file
*file
)
1181 int minor
= MINOR(inode
->i_rdev
);
1182 struct sv_state
*s
= devs
;
1184 while (s
&& s
->dev_mixer
!= minor
)
1189 file
->private_data
= s
;
1194 static int sv_release_mixdev(struct inode
*inode
, struct file
*file
)
1196 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1203 static int sv_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1205 return mixer_ioctl((struct sv_state
*)file
->private_data
, cmd
, arg
);
1208 static /*const*/ struct file_operations sv_mixer_fops
= {
1221 NULL
, /* check_media_change */
1222 NULL
, /* revalidate */
1226 /* --------------------------------------------------------------------- */
1228 static int drain_dac(struct sv_state
*s
, int nonblock
)
1230 struct wait_queue wait
= { current
, NULL
};
1231 unsigned long flags
;
1234 if (s
->dma_dac
.mapped
|| !s
->dma_dac
.ready
)
1236 current
->state
= TASK_INTERRUPTIBLE
;
1237 add_wait_queue(&s
->dma_dac
.wait
, &wait
);
1239 spin_lock_irqsave(&s
->lock
, flags
);
1240 count
= s
->dma_dac
.count
;
1241 spin_unlock_irqrestore(&s
->lock
, flags
);
1244 if (signal_pending(current
))
1247 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1248 current
->state
= TASK_RUNNING
;
1251 tmo
= (count
* HZ
) / s
->ratedac
;
1252 tmo
>>= sample_shift
[(s
->fmt
>> SV_CFMT_ASHIFT
) & SV_CFMT_MASK
];
1253 if (!schedule_timeout(tmo
? : 1) && tmo
)
1254 printk(KERN_DEBUG
"sv: dma timed out??\n");
1256 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1257 current
->state
= TASK_RUNNING
;
1258 if (signal_pending(current
))
1259 return -ERESTARTSYS
;
1263 /* --------------------------------------------------------------------- */
1265 static ssize_t
sv_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1267 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1269 unsigned long flags
;
1274 if (ppos
!= &file
->f_pos
)
1276 if (s
->dma_adc
.mapped
)
1278 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1280 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1284 spin_lock_irqsave(&s
->lock
, flags
);
1286 spin_unlock_irqrestore(&s
->lock
, flags
);
1289 spin_lock_irqsave(&s
->lock
, flags
);
1290 swptr
= s
->dma_adc
.swptr
;
1291 cnt
= s
->dma_adc
.dmasize
-swptr
;
1292 if (s
->dma_adc
.count
< cnt
)
1293 cnt
= s
->dma_adc
.count
;
1294 spin_unlock_irqrestore(&s
->lock
, flags
);
1299 if (file
->f_flags
& O_NONBLOCK
)
1300 return ret
? ret
: -EAGAIN
;
1301 interruptible_sleep_on(&s
->dma_adc
.wait
);
1302 if (signal_pending(current
))
1303 return ret
? ret
: -ERESTARTSYS
;
1306 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1307 return ret
? ret
: -EFAULT
;
1308 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1309 spin_lock_irqsave(&s
->lock
, flags
);
1310 s
->dma_adc
.swptr
= swptr
;
1311 s
->dma_adc
.count
-= cnt
;
1312 spin_unlock_irqrestore(&s
->lock
, flags
);
1321 static ssize_t
sv_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1323 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1325 unsigned long flags
;
1330 if (ppos
!= &file
->f_pos
)
1332 if (s
->dma_dac
.mapped
)
1334 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1336 if (!access_ok(VERIFY_READ
, buffer
, count
))
1340 spin_lock_irqsave(&s
->lock
, flags
);
1342 spin_unlock_irqrestore(&s
->lock
, flags
);
1345 spin_lock_irqsave(&s
->lock
, flags
);
1346 if (s
->dma_dac
.count
< 0) {
1347 s
->dma_dac
.count
= 0;
1348 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
;
1350 swptr
= s
->dma_dac
.swptr
;
1351 cnt
= s
->dma_dac
.dmasize
-swptr
;
1352 if (s
->dma_dac
.count
+ cnt
> s
->dma_dac
.dmasize
)
1353 cnt
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1354 spin_unlock_irqrestore(&s
->lock
, flags
);
1359 if (file
->f_flags
& O_NONBLOCK
)
1360 return ret
? ret
: -EAGAIN
;
1361 interruptible_sleep_on(&s
->dma_dac
.wait
);
1362 if (signal_pending(current
))
1363 return ret
? ret
: -ERESTARTSYS
;
1366 if (copy_from_user(s
->dma_dac
.rawbuf
+ swptr
, buffer
, cnt
))
1367 return ret
? ret
: -EFAULT
;
1368 swptr
= (swptr
+ cnt
) % s
->dma_dac
.dmasize
;
1369 spin_lock_irqsave(&s
->lock
, flags
);
1370 s
->dma_dac
.swptr
= swptr
;
1371 s
->dma_dac
.count
+= cnt
;
1372 s
->dma_dac
.endcleared
= 0;
1373 spin_unlock_irqrestore(&s
->lock
, flags
);
1382 static unsigned int sv_poll(struct file
*file
, struct poll_table_struct
*wait
)
1384 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1385 unsigned long flags
;
1386 unsigned int mask
= 0;
1389 if (file
->f_mode
& FMODE_WRITE
)
1390 poll_wait(file
, &s
->dma_dac
.wait
, wait
);
1391 if (file
->f_mode
& FMODE_READ
)
1392 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1393 spin_lock_irqsave(&s
->lock
, flags
);
1395 if (file
->f_mode
& FMODE_READ
) {
1396 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1397 mask
|= POLLIN
| POLLRDNORM
;
1399 if (file
->f_mode
& FMODE_WRITE
) {
1400 if (s
->dma_dac
.mapped
) {
1401 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
1402 mask
|= POLLOUT
| POLLWRNORM
;
1404 if ((signed)s
->dma_dac
.dmasize
>= s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
)
1405 mask
|= POLLOUT
| POLLWRNORM
;
1408 spin_unlock_irqrestore(&s
->lock
, flags
);
1412 static int sv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1414 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1420 if (vma
->vm_flags
& VM_WRITE
) {
1421 if ((ret
= prog_dmabuf(s
, 1)) != 0)
1424 } else if (vma
->vm_flags
& VM_READ
) {
1425 if ((ret
= prog_dmabuf(s
, 0)) != 0)
1430 if (vma
->vm_offset
!= 0)
1432 size
= vma
->vm_end
- vma
->vm_start
;
1433 if (size
> (PAGE_SIZE
<< db
->buforder
))
1435 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1441 static int sv_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1443 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1444 unsigned long flags
;
1445 audio_buf_info abinfo
;
1447 int val
, mapped
, ret
;
1448 unsigned char fmtm
, fmtd
;
1451 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac
.mapped
) ||
1452 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1454 case OSS_GETVERSION
:
1455 return put_user(SOUND_VERSION
, (int *)arg
);
1457 case SNDCTL_DSP_SYNC
:
1458 if (file
->f_mode
& FMODE_WRITE
)
1459 return drain_dac(s
, 0/*file->f_flags & O_NONBLOCK*/);
1462 case SNDCTL_DSP_SETDUPLEX
:
1465 case SNDCTL_DSP_GETCAPS
:
1466 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1468 case SNDCTL_DSP_RESET
:
1469 if (file
->f_mode
& FMODE_WRITE
) {
1472 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
= s
->dma_dac
.count
= s
->dma_dac
.total_bytes
= 0;
1474 if (file
->f_mode
& FMODE_READ
) {
1477 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1481 case SNDCTL_DSP_SPEED
:
1482 get_user_ret(val
, (int *)arg
, -EFAULT
);
1484 if (file
->f_mode
& FMODE_READ
) {
1486 s
->dma_adc
.ready
= 0;
1487 set_adc_rate(s
, val
);
1489 if (file
->f_mode
& FMODE_WRITE
) {
1491 s
->dma_dac
.ready
= 0;
1492 set_dac_rate(s
, val
);
1495 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1497 case SNDCTL_DSP_STEREO
:
1498 get_user_ret(val
, (int *)arg
, -EFAULT
);
1501 if (file
->f_mode
& FMODE_READ
) {
1503 s
->dma_adc
.ready
= 0;
1505 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
;
1507 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
);
1509 if (file
->f_mode
& FMODE_WRITE
) {
1511 s
->dma_dac
.ready
= 0;
1513 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
;
1515 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
);
1517 set_fmt(s
, fmtm
, fmtd
);
1520 case SNDCTL_DSP_CHANNELS
:
1521 get_user_ret(val
, (int *)arg
, -EFAULT
);
1525 if (file
->f_mode
& FMODE_READ
) {
1527 s
->dma_adc
.ready
= 0;
1529 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
;
1531 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
);
1533 if (file
->f_mode
& FMODE_WRITE
) {
1535 s
->dma_dac
.ready
= 0;
1537 fmtd
|= SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
;
1539 fmtm
&= ~(SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
);
1541 set_fmt(s
, fmtm
, fmtd
);
1543 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_STEREO
<< SV_CFMT_CSHIFT
)
1544 : (SV_CFMT_STEREO
<< SV_CFMT_ASHIFT
))) ? 2 : 1, (int *)arg
);
1546 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1547 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1549 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1550 get_user_ret(val
, (int *)arg
, -EFAULT
);
1551 if (val
!= AFMT_QUERY
) {
1554 if (file
->f_mode
& FMODE_READ
) {
1556 s
->dma_adc
.ready
= 0;
1557 if (val
== AFMT_S16_LE
)
1558 fmtd
|= SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
;
1560 fmtm
&= ~(SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
);
1562 if (file
->f_mode
& FMODE_WRITE
) {
1564 s
->dma_dac
.ready
= 0;
1565 if (val
== AFMT_S16_LE
)
1566 fmtd
|= SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
;
1568 fmtm
&= ~(SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
);
1570 set_fmt(s
, fmtm
, fmtd
);
1572 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
)
1573 : (SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
))) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1575 case SNDCTL_DSP_POST
:
1578 case SNDCTL_DSP_GETTRIGGER
:
1580 if (file
->f_mode
& FMODE_READ
&& s
->enable
& SV_CENABLE_RE
)
1581 val
|= PCM_ENABLE_INPUT
;
1582 if (file
->f_mode
& FMODE_WRITE
&& s
->enable
& SV_CENABLE_PE
)
1583 val
|= PCM_ENABLE_OUTPUT
;
1584 return put_user(val
, (int *)arg
);
1586 case SNDCTL_DSP_SETTRIGGER
:
1587 get_user_ret(val
, (int *)arg
, -EFAULT
);
1588 if (file
->f_mode
& FMODE_READ
) {
1589 if (val
& PCM_ENABLE_INPUT
) {
1590 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1596 if (file
->f_mode
& FMODE_WRITE
) {
1597 if (val
& PCM_ENABLE_OUTPUT
) {
1598 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1606 case SNDCTL_DSP_GETOSPACE
:
1607 if (!(file
->f_mode
& FMODE_WRITE
))
1609 if (!(s
->enable
& SV_CENABLE_PE
) && (val
= prog_dmabuf(s
, 0)) != 0)
1611 spin_lock_irqsave(&s
->lock
, flags
);
1613 abinfo
.fragsize
= s
->dma_dac
.fragsize
;
1614 abinfo
.bytes
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1615 abinfo
.fragstotal
= s
->dma_dac
.numfrag
;
1616 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac
.fragshift
;
1617 spin_unlock_irqrestore(&s
->lock
, flags
);
1618 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1620 case SNDCTL_DSP_GETISPACE
:
1621 if (!(file
->f_mode
& FMODE_READ
))
1623 if (!(s
->enable
& SV_CENABLE_RE
) && (val
= prog_dmabuf(s
, 1)) != 0)
1625 spin_lock_irqsave(&s
->lock
, flags
);
1627 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1628 abinfo
.bytes
= s
->dma_adc
.count
;
1629 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1630 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1631 spin_unlock_irqrestore(&s
->lock
, flags
);
1632 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1634 case SNDCTL_DSP_NONBLOCK
:
1635 file
->f_flags
|= O_NONBLOCK
;
1638 case SNDCTL_DSP_GETODELAY
:
1639 if (!(file
->f_mode
& FMODE_WRITE
))
1641 spin_lock_irqsave(&s
->lock
, flags
);
1643 val
= s
->dma_dac
.count
;
1644 spin_unlock_irqrestore(&s
->lock
, flags
);
1645 return put_user(val
, (int *)arg
);
1647 case SNDCTL_DSP_GETIPTR
:
1648 if (!(file
->f_mode
& FMODE_READ
))
1650 spin_lock_irqsave(&s
->lock
, flags
);
1652 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1653 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1654 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1655 if (s
->dma_adc
.mapped
)
1656 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1657 spin_unlock_irqrestore(&s
->lock
, flags
);
1658 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1660 case SNDCTL_DSP_GETOPTR
:
1661 if (!(file
->f_mode
& FMODE_WRITE
))
1663 spin_lock_irqsave(&s
->lock
, flags
);
1665 cinfo
.bytes
= s
->dma_dac
.total_bytes
;
1666 cinfo
.blocks
= s
->dma_dac
.count
>> s
->dma_dac
.fragshift
;
1667 cinfo
.ptr
= s
->dma_dac
.hwptr
;
1668 if (s
->dma_dac
.mapped
)
1669 s
->dma_dac
.count
&= s
->dma_dac
.fragsize
-1;
1670 spin_unlock_irqrestore(&s
->lock
, flags
);
1671 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1673 case SNDCTL_DSP_GETBLKSIZE
:
1674 if (file
->f_mode
& FMODE_WRITE
) {
1675 if ((val
= prog_dmabuf(s
, 0)))
1677 return put_user(s
->dma_dac
.fragsize
, (int *)arg
);
1679 if ((val
= prog_dmabuf(s
, 1)))
1681 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1683 case SNDCTL_DSP_SETFRAGMENT
:
1684 get_user_ret(val
, (int *)arg
, -EFAULT
);
1685 if (file
->f_mode
& FMODE_READ
) {
1686 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1687 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1688 if (s
->dma_adc
.ossfragshift
< 4)
1689 s
->dma_adc
.ossfragshift
= 4;
1690 if (s
->dma_adc
.ossfragshift
> 15)
1691 s
->dma_adc
.ossfragshift
= 15;
1692 if (s
->dma_adc
.ossmaxfrags
< 4)
1693 s
->dma_adc
.ossmaxfrags
= 4;
1695 if (file
->f_mode
& FMODE_WRITE
) {
1696 s
->dma_dac
.ossfragshift
= val
& 0xffff;
1697 s
->dma_dac
.ossmaxfrags
= (val
>> 16) & 0xffff;
1698 if (s
->dma_dac
.ossfragshift
< 4)
1699 s
->dma_dac
.ossfragshift
= 4;
1700 if (s
->dma_dac
.ossfragshift
> 15)
1701 s
->dma_dac
.ossfragshift
= 15;
1702 if (s
->dma_dac
.ossmaxfrags
< 4)
1703 s
->dma_dac
.ossmaxfrags
= 4;
1707 case SNDCTL_DSP_SUBDIVIDE
:
1708 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1709 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac
.subdivision
))
1711 get_user_ret(val
, (int *)arg
, -EFAULT
);
1712 if (val
!= 1 && val
!= 2 && val
!= 4)
1714 if (file
->f_mode
& FMODE_READ
)
1715 s
->dma_adc
.subdivision
= val
;
1716 if (file
->f_mode
& FMODE_WRITE
)
1717 s
->dma_dac
.subdivision
= val
;
1720 case SOUND_PCM_WRITE_FILTER
:
1721 case SNDCTL_DSP_SETSYNCRO
:
1722 case SOUND_PCM_READ_RATE
:
1723 case SOUND_PCM_READ_CHANNELS
:
1724 case SOUND_PCM_READ_BITS
:
1725 case SOUND_PCM_READ_FILTER
:
1729 return mixer_ioctl(s
, cmd
, arg
);
1732 static int sv_open(struct inode
*inode
, struct file
*file
)
1734 int minor
= MINOR(inode
->i_rdev
);
1735 struct sv_state
*s
= devs
;
1736 unsigned char fmtm
= ~0, fmts
= 0;
1738 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1743 file
->private_data
= s
;
1744 /* wait for device to become free */
1746 while (s
->open_mode
& file
->f_mode
) {
1747 if (file
->f_flags
& O_NONBLOCK
) {
1752 interruptible_sleep_on(&s
->open_wait
);
1753 if (signal_pending(current
))
1754 return -ERESTARTSYS
;
1757 if (file
->f_mode
& FMODE_READ
) {
1758 fmtm
&= ~((SV_CFMT_STEREO
| SV_CFMT_16BIT
) << SV_CFMT_CSHIFT
);
1759 if ((minor
& 0xf) == SND_DEV_DSP16
)
1760 fmts
|= SV_CFMT_16BIT
<< SV_CFMT_CSHIFT
;
1761 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1762 set_adc_rate(s
, 8000);
1764 if (file
->f_mode
& FMODE_WRITE
) {
1765 fmtm
&= ~((SV_CFMT_STEREO
| SV_CFMT_16BIT
) << SV_CFMT_ASHIFT
);
1766 if ((minor
& 0xf) == SND_DEV_DSP16
)
1767 fmts
|= SV_CFMT_16BIT
<< SV_CFMT_ASHIFT
;
1768 s
->dma_dac
.ossfragshift
= s
->dma_dac
.ossmaxfrags
= s
->dma_dac
.subdivision
= 0;
1769 set_dac_rate(s
, 8000);
1771 set_fmt(s
, fmtm
, fmts
);
1772 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1778 static int sv_release(struct inode
*inode
, struct file
*file
)
1780 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1783 if (file
->f_mode
& FMODE_WRITE
)
1784 drain_dac(s
, file
->f_flags
& O_NONBLOCK
);
1786 if (file
->f_mode
& FMODE_WRITE
) {
1788 dealloc_dmabuf(&s
->dma_dac
);
1790 if (file
->f_mode
& FMODE_READ
) {
1792 dealloc_dmabuf(&s
->dma_adc
);
1794 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1796 wake_up(&s
->open_wait
);
1801 static /*const*/ struct file_operations sv_audio_fops
= {
1814 NULL
, /* check_media_change */
1815 NULL
, /* revalidate */
1819 /* --------------------------------------------------------------------- */
1821 static ssize_t
sv_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1823 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1825 unsigned long flags
;
1830 if (ppos
!= &file
->f_pos
)
1832 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1836 spin_lock_irqsave(&s
->lock
, flags
);
1838 cnt
= MIDIINBUF
- ptr
;
1839 if (s
->midi
.icnt
< cnt
)
1841 spin_unlock_irqrestore(&s
->lock
, flags
);
1845 if (file
->f_flags
& O_NONBLOCK
)
1846 return ret
? ret
: -EAGAIN
;
1847 interruptible_sleep_on(&s
->midi
.iwait
);
1848 if (signal_pending(current
))
1849 return ret
? ret
: -ERESTARTSYS
;
1852 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
))
1853 return ret
? ret
: -EFAULT
;
1854 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
1855 spin_lock_irqsave(&s
->lock
, flags
);
1857 s
->midi
.icnt
-= cnt
;
1858 spin_unlock_irqrestore(&s
->lock
, flags
);
1866 static ssize_t
sv_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1868 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1870 unsigned long flags
;
1875 if (ppos
!= &file
->f_pos
)
1877 if (!access_ok(VERIFY_READ
, buffer
, count
))
1881 spin_lock_irqsave(&s
->lock
, flags
);
1883 cnt
= MIDIOUTBUF
- ptr
;
1884 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
1885 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
1888 spin_unlock_irqrestore(&s
->lock
, flags
);
1892 if (file
->f_flags
& O_NONBLOCK
)
1893 return ret
? ret
: -EAGAIN
;
1894 interruptible_sleep_on(&s
->midi
.owait
);
1895 if (signal_pending(current
))
1896 return ret
? ret
: -ERESTARTSYS
;
1899 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
))
1900 return ret
? ret
: -EFAULT
;
1901 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
1902 spin_lock_irqsave(&s
->lock
, flags
);
1904 s
->midi
.ocnt
+= cnt
;
1905 spin_unlock_irqrestore(&s
->lock
, flags
);
1909 spin_lock_irqsave(&s
->lock
, flags
);
1911 spin_unlock_irqrestore(&s
->lock
, flags
);
1916 static unsigned int sv_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
1918 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
1919 unsigned long flags
;
1920 unsigned int mask
= 0;
1923 if (file
->f_mode
& FMODE_WRITE
)
1924 poll_wait(file
, &s
->midi
.owait
, wait
);
1925 if (file
->f_mode
& FMODE_READ
)
1926 poll_wait(file
, &s
->midi
.iwait
, wait
);
1927 spin_lock_irqsave(&s
->lock
, flags
);
1928 if (file
->f_mode
& FMODE_READ
) {
1929 if (s
->midi
.icnt
> 0)
1930 mask
|= POLLIN
| POLLRDNORM
;
1932 if (file
->f_mode
& FMODE_WRITE
) {
1933 if (s
->midi
.ocnt
< MIDIOUTBUF
)
1934 mask
|= POLLOUT
| POLLWRNORM
;
1936 spin_unlock_irqrestore(&s
->lock
, flags
);
1940 static int sv_midi_open(struct inode
*inode
, struct file
*file
)
1942 int minor
= MINOR(inode
->i_rdev
);
1943 struct sv_state
*s
= devs
;
1944 unsigned long flags
;
1946 while (s
&& s
->dev_midi
!= minor
)
1951 file
->private_data
= s
;
1952 /* wait for device to become free */
1954 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
1955 if (file
->f_flags
& O_NONBLOCK
) {
1960 interruptible_sleep_on(&s
->open_wait
);
1961 if (signal_pending(current
))
1962 return -ERESTARTSYS
;
1965 spin_lock_irqsave(&s
->lock
, flags
);
1966 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
1967 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
1968 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
1969 //outb(inb(s->ioenh + SV_CODEC_CONTROL) | SV_CCTRL_WAVETABLE, s->ioenh + SV_CODEC_CONTROL);
1970 outb(inb(s
->ioenh
+ SV_CODEC_INTMASK
) | SV_CINTMASK_MIDI
, s
->ioenh
+ SV_CODEC_INTMASK
);
1971 wrindir(s
, SV_CIUARTCONTROL
, 5); /* output MIDI data to external and internal synth */
1972 wrindir(s
, SV_CIWAVETABLESRC
, 1); /* Wavetable in PC RAM */
1973 outb(0xff, s
->iomidi
+1); /* reset command */
1974 outb(0x3f, s
->iomidi
+1); /* uart command */
1975 if (!(inb(s
->iomidi
+1) & 0x80))
1977 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
1978 init_timer(&s
->midi
.timer
);
1979 s
->midi
.timer
.expires
= jiffies
+1;
1980 s
->midi
.timer
.data
= (unsigned long)s
;
1981 s
->midi
.timer
.function
= sv_midi_timer
;
1982 add_timer(&s
->midi
.timer
);
1984 if (file
->f_mode
& FMODE_READ
) {
1985 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
1987 if (file
->f_mode
& FMODE_WRITE
) {
1988 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
1990 spin_unlock_irqrestore(&s
->lock
, flags
);
1991 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
1997 static int sv_midi_release(struct inode
*inode
, struct file
*file
)
1999 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2000 struct wait_queue wait
= { current
, NULL
};
2001 unsigned long flags
;
2002 unsigned count
, tmo
;
2006 if (file
->f_mode
& FMODE_WRITE
) {
2007 current
->state
= TASK_INTERRUPTIBLE
;
2008 add_wait_queue(&s
->midi
.owait
, &wait
);
2010 spin_lock_irqsave(&s
->lock
, flags
);
2011 count
= s
->midi
.ocnt
;
2012 spin_unlock_irqrestore(&s
->lock
, flags
);
2015 if (signal_pending(current
))
2017 if (file
->f_flags
& O_NONBLOCK
) {
2018 remove_wait_queue(&s
->midi
.owait
, &wait
);
2019 current
->state
= TASK_RUNNING
;
2022 tmo
= (count
* HZ
) / 3100;
2023 if (!schedule_timeout(tmo
? : 1) && tmo
)
2024 printk(KERN_DEBUG
"sv: midi timed out??\n");
2026 remove_wait_queue(&s
->midi
.owait
, &wait
);
2027 current
->state
= TASK_RUNNING
;
2030 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2031 spin_lock_irqsave(&s
->lock
, flags
);
2032 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2033 outb(inb(s
->ioenh
+ SV_CODEC_INTMASK
) & ~SV_CINTMASK_MIDI
, s
->ioenh
+ SV_CODEC_INTMASK
);
2034 del_timer(&s
->midi
.timer
);
2036 spin_unlock_irqrestore(&s
->lock
, flags
);
2038 wake_up(&s
->open_wait
);
2043 static /*const*/ struct file_operations sv_midi_fops
= {
2056 NULL
, /* check_media_change */
2057 NULL
, /* revalidate */
2061 /* --------------------------------------------------------------------- */
2063 static int sv_dmfm_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
2065 static const unsigned char op_offset
[18] = {
2066 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2067 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
2068 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
2070 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2071 struct dm_fm_voice v
;
2072 struct dm_fm_note n
;
2073 struct dm_fm_params p
;
2078 case FM_IOCTL_RESET
:
2079 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2080 outb(regb
, s
->iosynth
);
2081 outb(0, s
->iosynth
+1);
2082 outb(regb
, s
->iosynth
+2);
2083 outb(0, s
->iosynth
+3);
2087 case FM_IOCTL_PLAY_NOTE
:
2088 if (copy_from_user(&n
, (void *)arg
, sizeof(n
)))
2099 outb(0xa0 + regb
, io
);
2100 outb(n
.fnum
& 0xff, io
+1);
2101 outb(0xb0 + regb
, io
);
2102 outb(((n
.fnum
>> 8) & 3) | ((n
.octave
& 7) << 2) | ((n
.key_on
& 1) << 5), io
+1);
2105 case FM_IOCTL_SET_VOICE
:
2106 if (copy_from_user(&v
, (void *)arg
, sizeof(v
)))
2110 regb
= op_offset
[v
.voice
];
2111 io
= s
->iosynth
+ ((v
.op
& 1) << 1);
2112 outb(0x20 + regb
, io
);
2113 outb(((v
.am
& 1) << 7) | ((v
.vibrato
& 1) << 6) | ((v
.do_sustain
& 1) << 5) |
2114 ((v
.kbd_scale
& 1) << 4) | (v
.harmonic
& 0xf), io
+1);
2115 outb(0x40 + regb
, io
);
2116 outb(((v
.scale_level
& 0x3) << 6) | (v
.volume
& 0x3f), io
+1);
2117 outb(0x60 + regb
, io
);
2118 outb(((v
.attack
& 0xf) << 4) | (v
.decay
& 0xf), io
+1);
2119 outb(0x80 + regb
, io
);
2120 outb(((v
.sustain
& 0xf) << 4) | (v
.release
& 0xf), io
+1);
2121 outb(0xe0 + regb
, io
);
2122 outb(v
.waveform
& 0x7, io
+1);
2130 outb(0xc0 + regb
, io
);
2131 outb(((v
.right
& 1) << 5) | ((v
.left
& 1) << 4) | ((v
.feedback
& 7) << 1) |
2132 (v
.connection
& 1), io
+1);
2135 case FM_IOCTL_SET_PARAMS
:
2136 if (copy_from_user(&p
, (void *)arg
, sizeof(p
)))
2138 outb(0x08, s
->iosynth
);
2139 outb((p
.kbd_split
& 1) << 6, s
->iosynth
+1);
2140 outb(0xbd, s
->iosynth
);
2141 outb(((p
.am_depth
& 1) << 7) | ((p
.vib_depth
& 1) << 6) | ((p
.rhythm
& 1) << 5) | ((p
.bass
& 1) << 4) |
2142 ((p
.snare
& 1) << 3) | ((p
.tomtom
& 1) << 2) | ((p
.cymbal
& 1) << 1) | (p
.hihat
& 1), s
->iosynth
+1);
2145 case FM_IOCTL_SET_OPL
:
2146 outb(4, s
->iosynth
+2);
2147 outb(arg
, s
->iosynth
+3);
2150 case FM_IOCTL_SET_MODE
:
2151 outb(5, s
->iosynth
+2);
2152 outb(arg
& 1, s
->iosynth
+3);
2160 static int sv_dmfm_open(struct inode
*inode
, struct file
*file
)
2162 int minor
= MINOR(inode
->i_rdev
);
2163 struct sv_state
*s
= devs
;
2165 while (s
&& s
->dev_dmfm
!= minor
)
2170 file
->private_data
= s
;
2171 /* wait for device to become free */
2173 while (s
->open_mode
& FMODE_DMFM
) {
2174 if (file
->f_flags
& O_NONBLOCK
) {
2179 interruptible_sleep_on(&s
->open_wait
);
2180 if (signal_pending(current
))
2181 return -ERESTARTSYS
;
2184 /* init the stuff */
2185 outb(1, s
->iosynth
);
2186 outb(0x20, s
->iosynth
+1); /* enable waveforms */
2187 outb(4, s
->iosynth
+2);
2188 outb(0, s
->iosynth
+3); /* no 4op enabled */
2189 outb(5, s
->iosynth
+2);
2190 outb(1, s
->iosynth
+3); /* enable OPL3 */
2191 s
->open_mode
|= FMODE_DMFM
;
2197 static int sv_dmfm_release(struct inode
*inode
, struct file
*file
)
2199 struct sv_state
*s
= (struct sv_state
*)file
->private_data
;
2204 s
->open_mode
&= ~FMODE_DMFM
;
2205 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2206 outb(regb
, s
->iosynth
);
2207 outb(0, s
->iosynth
+1);
2208 outb(regb
, s
->iosynth
+2);
2209 outb(0, s
->iosynth
+3);
2212 wake_up(&s
->open_wait
);
2217 static /*const*/ struct file_operations sv_dmfm_fops
= {
2230 NULL
, /* check_media_change */
2231 NULL
, /* revalidate */
2235 /* --------------------------------------------------------------------- */
2237 /* maximum number of devices */
2240 static int reverb
[NR_DEVICE
] = { 0, };
2243 static int wavetable
[NR_DEVICE
] = { 0, };
2246 static unsigned dmaio
= 0xac00;
2248 /* --------------------------------------------------------------------- */
2250 static struct initvol
{
2253 } initvol
[] __initdata
= {
2254 { SOUND_MIXER_WRITE_RECLEV
, 0x4040 },
2255 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2256 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2257 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2258 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2259 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2260 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2261 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2262 { SOUND_MIXER_WRITE_PCM
, 0x4040 }
2266 __initfunc(int init_module(void))
2268 __initfunc(int init_sonicvibes(void))
2272 struct pci_dev
*pcidev
= NULL
;
2274 int i
, val
, index
= 0;
2276 if (!pci_present()) /* No PCI bus in this machine! */
2278 printk(KERN_INFO
"sv: version v0.12 time " __TIME__
" " __DATE__
"\n");
2280 if (!(wavetable_mem
= __get_free_pages(GFP_KERNEL
, 20-PAGE_SHIFT
)))
2281 printk(KERN_INFO
"sv: cannot allocate 1MB of contiguous nonpageable memory for wavetable data\n");
2283 while (index
< NR_DEVICE
&&
2284 (pcidev
= pci_find_device(PCI_VENDOR_ID_S3
, PCI_DEVICE_ID_S3_SONICVIBES
, pcidev
))) {
2285 if (pcidev
->base_address
[1] == 0 ||
2286 (pcidev
->base_address
[1] & PCI_BASE_ADDRESS_SPACE
) != PCI_BASE_ADDRESS_SPACE_IO
)
2288 if (pcidev
->base_address
[2] == 0 ||
2289 (pcidev
->base_address
[2] & PCI_BASE_ADDRESS_SPACE
) != PCI_BASE_ADDRESS_SPACE_IO
)
2291 if (pcidev
->base_address
[3] == 0 ||
2292 (pcidev
->base_address
[3] & PCI_BASE_ADDRESS_SPACE
) != PCI_BASE_ADDRESS_SPACE_IO
)
2294 if (pcidev
->irq
== 0)
2296 if (!(s
= kmalloc(sizeof(struct sv_state
), GFP_KERNEL
))) {
2297 printk(KERN_WARNING
"sv: out of memory\n");
2300 memset(s
, 0, sizeof(struct sv_state
));
2301 init_waitqueue(&s
->dma_adc
.wait
);
2302 init_waitqueue(&s
->dma_dac
.wait
);
2303 init_waitqueue(&s
->open_wait
);
2304 init_waitqueue(&s
->midi
.iwait
);
2305 init_waitqueue(&s
->midi
.owait
);
2306 s
->open_sem
= MUTEX
;
2307 s
->magic
= SV_MAGIC
;
2308 s
->iosb
= pcidev
->base_address
[0] & PCI_BASE_ADDRESS_IO_MASK
;
2309 s
->ioenh
= pcidev
->base_address
[1] & PCI_BASE_ADDRESS_IO_MASK
;
2310 s
->iosynth
= pcidev
->base_address
[2] & PCI_BASE_ADDRESS_IO_MASK
;
2311 s
->iomidi
= pcidev
->base_address
[3] & PCI_BASE_ADDRESS_IO_MASK
;
2312 s
->iogame
= pcidev
->base_address
[4] & PCI_BASE_ADDRESS_IO_MASK
;
2313 pci_read_config_dword(pcidev
, 0x40, &s
->iodmaa
);
2314 pci_read_config_dword(pcidev
, 0x48, &s
->iodmac
);
2315 dmaio
&= ~(SV_EXTENT_DMA
-1);
2316 s
->iodmaa
&= ~(SV_EXTENT_DMA
-1);
2317 s
->iodmac
&= ~(SV_EXTENT_DMA
-1);
2320 dmaio
+= SV_EXTENT_DMA
;
2321 printk(KERN_INFO
"sv: BIOS did not allocate DDMA channel A io, allocated at %#x\n",
2326 dmaio
+= SV_EXTENT_DMA
;
2327 printk(KERN_INFO
"sv: BIOS did not allocate DDMA channel C io, allocated at %#x\n",
2330 pci_write_config_dword(pcidev
, 0x40, s
->iodmaa
| 9); /* enable and use extended mode */
2331 pci_write_config_dword(pcidev
, 0x48, s
->iodmac
| 9); /* enable */
2332 printk(KERN_DEBUG
"sv: io ports: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
2333 s
->iosb
, s
->ioenh
, s
->iosynth
, s
->iomidi
, s
->iogame
, s
->iodmaa
, s
->iodmac
);
2334 if (s
->ioenh
== 0 || s
->iodmaa
== 0 || s
->iodmac
== 0)
2336 s
->irq
= pcidev
->irq
;
2339 pci_write_config_dword(pcidev
, 0x60, wavetable_mem
>> 12); /* wavetable base address */
2341 if (check_region(s
->ioenh
, SV_EXTENT_ENH
)) {
2342 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->ioenh
, s
->ioenh
+SV_EXTENT_ENH
-1);
2345 request_region(s
->ioenh
, SV_EXTENT_ENH
, "S3 SonicVibes PCM");
2346 if (check_region(s
->iodmaa
, SV_EXTENT_DMA
)) {
2347 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iodmaa
, s
->iodmaa
+SV_EXTENT_DMA
-1);
2350 request_region(s
->iodmaa
, SV_EXTENT_DMA
, "S3 SonicVibes DMAA");
2351 if (check_region(s
->iodmac
, SV_EXTENT_DMA
)) {
2352 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iodmac
, s
->iodmac
+SV_EXTENT_DMA
-1);
2355 request_region(s
->iodmac
, SV_EXTENT_DMA
, "S3 SonicVibes DMAC");
2356 if (check_region(s
->iomidi
, SV_EXTENT_MIDI
)) {
2357 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iomidi
, s
->iomidi
+SV_EXTENT_MIDI
-1);
2360 request_region(s
->iomidi
, SV_EXTENT_MIDI
, "S3 SonicVibes Midi");
2361 if (check_region(s
->iosynth
, SV_EXTENT_SYNTH
)) {
2362 printk(KERN_ERR
"sv: io ports %#x-%#x in use\n", s
->iosynth
, s
->iosynth
+SV_EXTENT_SYNTH
-1);
2365 request_region(s
->iosynth
, SV_EXTENT_SYNTH
, "S3 SonicVibes Synth");
2366 /* initialize codec registers */
2367 outb(0x80, s
->ioenh
+ SV_CODEC_CONTROL
); /* assert reset */
2369 outb(0x00, s
->ioenh
+ SV_CODEC_CONTROL
); /* deassert reset */
2371 outb(SV_CCTRL_INTADRIVE
| SV_CCTRL_ENHANCED
/*| SV_CCTRL_WAVETABLE */
2372 | (reverb
[index
] ? SV_CCTRL_REVERB
: 0), s
->ioenh
+ SV_CODEC_CONTROL
);
2373 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* clear ints */
2374 wrindir(s
, SV_CIDRIVECONTROL
, 0); /* drive current 16mA */
2375 wrindir(s
, SV_CIENABLE
, s
->enable
= 0); /* disable DMAA and DMAC */
2376 outb(~(SV_CINTMASK_DMAA
| SV_CINTMASK_DMAC
), s
->ioenh
+ SV_CODEC_INTMASK
);
2377 //outb(0xff, s->iodmaa + SV_DMA_RESET);
2378 //outb(0xff, s->iodmac + SV_DMA_RESET);
2379 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* ack interrupts */
2380 wrindir(s
, SV_CIADCCLKSOURCE
, 0); /* use pll as ADC clock source */
2381 wrindir(s
, SV_CIANALOGPWRDOWN
, 0); /* power up the analog parts of the device */
2382 wrindir(s
, SV_CIDIGITALPWRDOWN
, 0); /* power up the digital parts of the device */
2383 setpll(s
, SV_CIADCPLLM
, 8000);
2384 wrindir(s
, SV_CISRSSPACE
, 0x80); /* SRS off */
2385 wrindir(s
, SV_CIPCMSR0
, (8000 * 65536 / FULLRATE
) & 0xff);
2386 wrindir(s
, SV_CIPCMSR1
, ((8000 * 65536 / FULLRATE
) >> 8) & 0xff);
2387 wrindir(s
, SV_CIADCOUTPUT
, 0);
2389 if (request_irq(s
->irq
, sv_interrupt
, SA_SHIRQ
, "S3 SonicVibes", s
)) {
2390 printk(KERN_ERR
"sv: irq %u in use\n", s
->irq
);
2393 printk(KERN_INFO
"sv: found adapter at io %#06x irq %u dmaa %#06x dmac %#06x revision %u\n",
2394 s
->ioenh
, s
->irq
, s
->iodmaa
, s
->iodmac
, rdindir(s
, SV_CIREVISION
));
2395 /* register devices */
2396 if ((s
->dev_audio
= register_sound_dsp(&sv_audio_fops
, -1)) < 0)
2398 if ((s
->dev_mixer
= register_sound_mixer(&sv_mixer_fops
, -1)) < 0)
2400 if ((s
->dev_midi
= register_sound_midi(&sv_midi_fops
, -1)) < 0)
2402 if ((s
->dev_dmfm
= register_sound_special(&sv_dmfm_fops
, 15 /* ?? */)) < 0)
2404 /* initialize the chips */
2407 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
;
2408 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2409 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2410 val
= initvol
[i
].vol
;
2411 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2414 /* queue it for later freeing */
2421 unregister_sound_midi(s
->dev_midi
);
2423 unregister_sound_mixer(s
->dev_mixer
);
2425 unregister_sound_dsp(s
->dev_audio
);
2427 printk(KERN_ERR
"sv: cannot register misc device\n");
2428 free_irq(s
->irq
, s
);
2430 release_region(s
->iosynth
, SV_EXTENT_SYNTH
);
2432 release_region(s
->iomidi
, SV_EXTENT_MIDI
);
2434 release_region(s
->iodmac
, SV_EXTENT_DMA
);
2436 release_region(s
->iodmaa
, SV_EXTENT_DMA
);
2438 release_region(s
->ioenh
, SV_EXTENT_ENH
);
2440 kfree_s(s
, sizeof(struct sv_state
));
2444 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2450 /* --------------------------------------------------------------------- */
2454 MODULE_PARM(reverb
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2455 MODULE_PARM_DESC(reverb
, "if 1 enables the reverb circuitry. NOTE: your card must have the reverb RAM");
2457 MODULE_PARM(wavetable
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2458 MODULE_PARM_DESC(wavetable
, "if 1 the wavetable synth is enabled");
2461 MODULE_PARM(dmaio
, "i");
2462 MODULE_PARM_DESC(dmaio
, "if the motherboard BIOS did not allocate DDMA io, allocate them starting at this address");
2464 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2465 MODULE_DESCRIPTION("S3 SonicVibes Driver");
2467 void cleanup_module(void)
2471 while ((s
= devs
)) {
2473 outb(~0, s
->ioenh
+ SV_CODEC_INTMASK
); /* disable ints */
2475 inb(s
->ioenh
+ SV_CODEC_STATUS
); /* ack interrupts */
2476 wrindir(s
, SV_CIENABLE
, 0); /* disable DMAA and DMAC */
2477 //outb(0, s->iodmaa + SV_DMA_RESET);
2478 //outb(0, s->iodmac + SV_DMA_RESET);
2479 free_irq(s
->irq
, s
);
2480 release_region(s
->iodmac
, SV_EXTENT_DMA
);
2481 release_region(s
->iodmaa
, SV_EXTENT_DMA
);
2482 release_region(s
->ioenh
, SV_EXTENT_ENH
);
2483 release_region(s
->iomidi
, SV_EXTENT_MIDI
);
2484 release_region(s
->iosynth
, SV_EXTENT_SYNTH
);
2485 unregister_sound_dsp(s
->dev_audio
);
2486 unregister_sound_mixer(s
->dev_mixer
);
2487 unregister_sound_midi(s
->dev_midi
);
2488 unregister_sound_special(s
->dev_dmfm
);
2489 kfree_s(s
, sizeof(struct sv_state
));
2492 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2493 printk(KERN_INFO
"sv: unloading\n");