1 /*****************************************************************************/
4 * es1370.c -- Ensoniq ES1370/Asahi Kasei AK4531 audio driver.
6 * Copyright (C) 1998-2000 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:
26 * joystick if 1 enables the joystick interface on the card; but it still
27 * needs a driver for joysticks connected to a standard IBM-PC
28 * joyport. It is tested with the joy-analog driver. This
29 * module must be loaded before the joystick driver. Kmod will
31 * lineout if 1 the LINE jack is used as an output instead of an input.
32 * LINE then contains the unmixed dsp output. This can be used
33 * to make the card a four channel one: use dsp to output two
34 * channels to LINE and dac to output the other two channels to
35 * SPKR. Set the mixer to only output synth to SPKR.
36 * micbias sets the +5V bias to the mic if using an electretmic.
39 * Note: sync mode is not yet supported (i.e. running dsp and dac from the same
43 * /dev/dsp standard /dev/dsp device, (mostly) OSS compatible
44 * /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
45 * /dev/dsp1 additional DAC, like /dev/dsp, but output only,
46 * only 5512, 11025, 22050 and 44100 samples/s,
47 * outputs to mixer "SYNTH" setting
48 * /dev/midi simple MIDI UART interface, no ioctl
50 * NOTE: the card does not have any FM/Wavetable synthesizer, it is supposed
51 * to be done in software. That is what /dev/dac is for. By now (Q2 1998)
52 * there are several MIDI to PCM (WAV) packages, one of them is timidity.
55 * 26.03.1998 0.1 Initial release
56 * 31.03.1998 0.2 Fix bug in GETOSPACE
57 * 04.04.1998 0.3 Make it work (again) under 2.0.33
58 * Fix mixer write operation not returning the actual
60 * 05.04.1998 0.4 First attempt at using the new PCI stuff
61 * 29.04.1998 0.5 Fix hang when ^C is pressed on amp
62 * 07.05.1998 0.6 Don't double lock around stop_*() in *_release()
63 * 10.05.1998 0.7 First stab at a simple midi interface (no bells&whistles)
64 * 14.05.1998 0.8 Don't allow excessive interrupt rates
65 * 08.06.1998 0.9 First release using Alan Cox' soundcore instead of
67 * 05.07.1998 0.10 Fixed the driver to correctly maintin OSS style volume
68 * settings (not sure if this should be standard)
69 * Fixed many references: f_flags should be f_mode
70 * -- Gerald Britton <gbritton@mit.edu>
71 * 03.08.1998 0.11 Now mixer behaviour can basically be selected between
72 * "OSS documented" and "OSS actual" behaviour
73 * Fixed mixer table thanks to Hakan.Lennestal@lu.erisoft.se
74 * On module startup, set DAC2 to 11kSPS instead of 5.5kSPS,
75 * as it produces an annoying ssssh in the lower sampling rate
76 * Do not include modversions.h
77 * 22.08.1998 0.12 Mixer registers actually have 5 instead of 4 bits
78 * pointed out by Itai Nahshon
79 * 31.08.1998 0.13 Fix realplayer problems - dac.count issues
80 * 08.10.1998 0.14 Joystick support fixed
81 * -- Oliver Neukum <c188@org.chemie.uni-muenchen.de>
82 * 10.12.1998 0.15 Fix drain_dac trying to wait on not yet initialized DMA
83 * 16.12.1998 0.16 Don't wake up app until there are fragsize bytes to read/write
84 * 06.01.1999 0.17 remove the silly SA_INTERRUPT flag.
85 * hopefully killed the egcs section type conflict
86 * 12.03.1999 0.18 cinfo.blocks should be reset after GETxPTR ioctl.
87 * reported by Johan Maes <joma@telindus.be>
88 * 22.03.1999 0.19 return EAGAIN instead of EBUSY when O_NONBLOCK
89 * read/write cannot be executed
90 * 07.04.1999 0.20 implemented the following ioctl's: SOUND_PCM_READ_RATE,
91 * SOUND_PCM_READ_CHANNELS, SOUND_PCM_READ_BITS;
92 * Alpha fixes reported by Peter Jones <pjones@redhat.com>
93 * Note: joystick address handling might still be wrong on archs
95 * 10.05.1999 0.21 Added support for an electret mic for SB PCI64
96 * to the Linux kernel sound driver. This mod also straighten
97 * out the question marks around the mic impedance setting
98 * (micz). From Kim.Berts@fisub.mail.abb.com
99 * 11.05.1999 0.22 Implemented the IMIX call to mute recording monitor.
100 * Guenter Geiger <geiger@epy.co.at>
101 * 15.06.1999 0.23 Fix bad allocation bug.
102 * Thanks to Deti Fliegl <fliegl@in.tum.de>
103 * 28.06.1999 0.24 Add pci_set_master
104 * 02.08.1999 0.25 Added workaround for the "phantom write" bug first
105 * documented by Dave Sharpless from Anchor Games
106 * 03.08.1999 0.26 adapt to Linus' new __setup/__initcall
107 * added kernel command line option "es1370=joystick[,lineout[,micbias]]"
108 * removed CONFIG_SOUND_ES1370_JOYPORT_BOOT kludge
109 * 12.08.1999 0.27 module_init/__setup fixes
110 * 19.08.1999 0.28 SOUND_MIXER_IMIX fixes, reported by Gianluca <gialluca@mail.tiscalinet.it>
111 * 31.08.1999 0.29 add spin_lock_init
112 * __initlocaldata to fix gcc 2.7.x problems
113 * replaced current->state = x with set_current_state(x)
114 * 03.09.1999 0.30 change read semantics for MIDI to match
115 * OSS more closely; remove possible wakeup race
116 * 28.10.1999 0.31 More waitqueue races fixed
117 * 08.01.2000 0.32 Prevent some ioctl's from returning bad count values on underrun/overrun;
118 * Tim Janik's BSE (Bedevilled Sound Engine) found this
119 * 07.02.2000 0.33 Use pci_alloc_consistent and pci_register_driver
121 * some important things missing in Ensoniq documentation:
123 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
124 * and vary PCLKDIV to obtain zero beat.
127 * seems to be fs = 1411200/(PCLKDIV+2)
129 * should find out when curr_sample_ct is cleared and
130 * where exactly the CCB fetches data
132 * The card uses a 22.5792 MHz crystal.
133 * The LINEIN jack may be converted to an AOUT jack by
134 * setting pin 47 (XCTL0) of the ES1370 to high.
135 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
140 /*****************************************************************************/
142 #include <linux/version.h>
143 #include <linux/module.h>
144 #include <linux/string.h>
145 #include <linux/ioport.h>
146 #include <linux/sched.h>
147 #include <linux/delay.h>
148 #include <linux/sound.h>
149 #include <linux/malloc.h>
150 #include <linux/soundcard.h>
151 #include <linux/pci.h>
154 #include <linux/init.h>
155 #include <linux/poll.h>
156 #include <linux/spinlock.h>
157 #include <asm/uaccess.h>
158 #include <asm/hardirq.h>
160 /* --------------------------------------------------------------------- */
162 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
164 /*#define DBG(x) {x}*/
166 /* --------------------------------------------------------------------- */
168 #ifndef PCI_VENDOR_ID_ENSONIQ
169 #define PCI_VENDOR_ID_ENSONIQ 0x1274
171 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
172 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
175 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
177 #define ES1370_EXTENT 0x40
180 #define ES1370_REG_CONTROL 0x00
181 #define ES1370_REG_STATUS 0x04
182 #define ES1370_REG_UART_DATA 0x08
183 #define ES1370_REG_UART_STATUS 0x09
184 #define ES1370_REG_UART_CONTROL 0x09
185 #define ES1370_REG_UART_TEST 0x0a
186 #define ES1370_REG_MEMPAGE 0x0c
187 #define ES1370_REG_CODEC 0x10
188 #define ES1370_REG_SERIAL_CONTROL 0x20
189 #define ES1370_REG_DAC1_SCOUNT 0x24
190 #define ES1370_REG_DAC2_SCOUNT 0x28
191 #define ES1370_REG_ADC_SCOUNT 0x2c
193 #define ES1370_REG_DAC1_FRAMEADR 0xc30
194 #define ES1370_REG_DAC1_FRAMECNT 0xc34
195 #define ES1370_REG_DAC2_FRAMEADR 0xc38
196 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
197 #define ES1370_REG_ADC_FRAMEADR 0xd30
198 #define ES1370_REG_ADC_FRAMECNT 0xd34
199 #define ES1370_REG_PHANTOM_FRAMEADR 0xd38
200 #define ES1370_REG_PHANTOM_FRAMECNT 0xd3c
202 #define ES1370_FMT_U8_MONO 0
203 #define ES1370_FMT_U8_STEREO 1
204 #define ES1370_FMT_S16_MONO 2
205 #define ES1370_FMT_S16_STEREO 3
206 #define ES1370_FMT_STEREO 1
207 #define ES1370_FMT_S16 2
208 #define ES1370_FMT_MASK 3
210 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
211 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
213 static const unsigned dac1_samplerate
[] = { 5512, 11025, 22050, 44100 };
215 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
216 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
218 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
219 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
220 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
221 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
222 #define CTRL_SH_PCLKDIV 16
223 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
224 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
225 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
226 #define CTRL_SH_WTSRSEL 12
227 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
228 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
229 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
230 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
231 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
232 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
233 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
234 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
235 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
236 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
237 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
238 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
240 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
241 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
242 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
243 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
244 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
246 #define STAT_MCCB 0x00000010 /* CCB int pending */
247 #define STAT_UART 0x00000008 /* UART int pending */
248 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
249 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
250 #define STAT_ADC 0x00000001 /* ADC int pending */
252 #define USTAT_RXINT 0x80 /* UART rx int pending */
253 #define USTAT_TXINT 0x04 /* UART tx int pending */
254 #define USTAT_TXRDY 0x02 /* UART tx ready */
255 #define USTAT_RXRDY 0x01 /* UART rx ready */
257 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
258 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
259 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
260 #define UCTRL_CNTRL 0x03 /* control field */
261 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
263 #define SCTRL_P2ENDINC 0x00380000 /* */
264 #define SCTRL_SH_P2ENDINC 19
265 #define SCTRL_P2STINC 0x00070000 /* */
266 #define SCTRL_SH_P2STINC 16
267 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
268 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
269 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
270 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
271 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
272 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
273 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
274 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
275 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
276 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
277 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
278 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
279 #define SCTRL_R1FMT 0x00000030 /* format mask */
280 #define SCTRL_SH_R1FMT 4
281 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
282 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
283 #define SCTRL_P2FMT 0x0000000c /* format mask */
284 #define SCTRL_SH_P2FMT 2
285 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
286 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
287 #define SCTRL_P1FMT 0x00000003 /* format mask */
288 #define SCTRL_SH_P1FMT 0
292 #define FMODE_DAC 4 /* slight misuse of mode_t */
294 /* MIDI buffer sizes */
296 #define MIDIINBUF 256
297 #define MIDIOUTBUF 256
299 #define FMODE_MIDI_SHIFT 3
300 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
301 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
303 #define SND_DEV_DSP16 5
305 /* --------------------------------------------------------------------- */
307 struct es1370_state
{
311 /* list of es1370 devices */
312 struct list_head devs
;
314 /* the corresponding pci_dev structure */
317 /* soundcore stuff */
323 /* hardware resources */
324 unsigned long io
; /* long for SPARC */
327 /* mixer registers; there is no HW readback */
329 unsigned short vol
[10];
332 unsigned short micpreamp
;
341 struct semaphore open_sem
;
343 wait_queue_head_t open_wait
;
351 unsigned hwptr
, swptr
;
352 unsigned total_bytes
;
354 unsigned error
; /* over/underrun */
355 wait_queue_head_t wait
;
356 /* redundant, but makes calculations easier */
359 unsigned fragsamples
;
363 unsigned endcleared
:1;
364 unsigned ossfragshift
;
366 unsigned subdivision
;
367 } dma_dac1
, dma_dac2
, dma_adc
;
371 unsigned ird
, iwr
, icnt
;
372 unsigned ord
, owr
, ocnt
;
373 wait_queue_head_t iwait
;
374 wait_queue_head_t owait
;
375 unsigned char ibuf
[MIDIINBUF
];
376 unsigned char obuf
[MIDIOUTBUF
];
380 /* --------------------------------------------------------------------- */
382 static LIST_HEAD(devs
);
385 * The following buffer is used to point the phantom write channel to,
386 * so that it cannot wreak havoc. The attribute makes sure it doesn't
387 * cross a page boundary and ensures dword alignment for the DMA engine
389 static unsigned char bugbuf
[16] __attribute__ ((aligned (16)));
391 /* --------------------------------------------------------------------- */
393 extern inline unsigned ld2(unsigned int x
)
418 /* --------------------------------------------------------------------- */
420 static void wrcodec(struct es1370_state
*s
, unsigned char idx
, unsigned char data
)
422 unsigned long tmo
= jiffies
+ HZ
/10;
425 if (!(inl(s
->io
+ES1370_REG_STATUS
) & STAT_CSTAT
)) {
426 outw((((unsigned short)idx
)<<8)|data
, s
->io
+ES1370_REG_CODEC
);
430 } while ((signed)(tmo
-jiffies
) > 0);
431 printk(KERN_ERR
"es1370: write to codec register timeout\n");
434 /* --------------------------------------------------------------------- */
436 extern inline void stop_adc(struct es1370_state
*s
)
440 spin_lock_irqsave(&s
->lock
, flags
);
441 s
->ctrl
&= ~CTRL_ADC_EN
;
442 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
443 spin_unlock_irqrestore(&s
->lock
, flags
);
446 extern inline void stop_dac1(struct es1370_state
*s
)
450 spin_lock_irqsave(&s
->lock
, flags
);
451 s
->ctrl
&= ~CTRL_DAC1_EN
;
452 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
453 spin_unlock_irqrestore(&s
->lock
, flags
);
456 extern inline void stop_dac2(struct es1370_state
*s
)
460 spin_lock_irqsave(&s
->lock
, flags
);
461 s
->ctrl
&= ~CTRL_DAC2_EN
;
462 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
463 spin_unlock_irqrestore(&s
->lock
, flags
);
466 static void start_dac1(struct es1370_state
*s
)
469 unsigned fragremain
, fshift
;
471 spin_lock_irqsave(&s
->lock
, flags
);
472 if (!(s
->ctrl
& CTRL_DAC1_EN
) && (s
->dma_dac1
.mapped
|| s
->dma_dac1
.count
> 0)
473 && s
->dma_dac1
.ready
) {
474 s
->ctrl
|= CTRL_DAC1_EN
;
475 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P1LOOPSEL
| SCTRL_P1PAUSE
| SCTRL_P1SCTRLD
)) | SCTRL_P1INTEN
;
476 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
477 fragremain
= ((- s
->dma_dac1
.hwptr
) & (s
->dma_dac1
.fragsize
-1));
478 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
479 if (fragremain
< 2*fshift
)
480 fragremain
= s
->dma_dac1
.fragsize
;
481 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
482 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
483 outl((s
->dma_dac1
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
485 spin_unlock_irqrestore(&s
->lock
, flags
);
488 static void start_dac2(struct es1370_state
*s
)
491 unsigned fragremain
, fshift
;
493 spin_lock_irqsave(&s
->lock
, flags
);
494 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (s
->dma_dac2
.mapped
|| s
->dma_dac2
.count
> 0)
495 && s
->dma_dac2
.ready
) {
496 s
->ctrl
|= CTRL_DAC2_EN
;
497 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P2LOOPSEL
| SCTRL_P2PAUSE
| SCTRL_P2DACSEN
|
498 SCTRL_P2ENDINC
| SCTRL_P2STINC
)) | SCTRL_P2INTEN
|
499 (((s
->sctrl
& SCTRL_P2FMT
) ? 2 : 1) << SCTRL_SH_P2ENDINC
) |
500 (0 << SCTRL_SH_P2STINC
);
501 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
502 fragremain
= ((- s
->dma_dac2
.hwptr
) & (s
->dma_dac2
.fragsize
-1));
503 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
504 if (fragremain
< 2*fshift
)
505 fragremain
= s
->dma_dac2
.fragsize
;
506 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
507 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
508 outl((s
->dma_dac2
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
510 spin_unlock_irqrestore(&s
->lock
, flags
);
513 static void start_adc(struct es1370_state
*s
)
516 unsigned fragremain
, fshift
;
518 spin_lock_irqsave(&s
->lock
, flags
);
519 if (!(s
->ctrl
& CTRL_ADC_EN
) && (s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
520 && s
->dma_adc
.ready
) {
521 s
->ctrl
|= CTRL_ADC_EN
;
522 s
->sctrl
= (s
->sctrl
& ~SCTRL_R1LOOPSEL
) | SCTRL_R1INTEN
;
523 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
524 fragremain
= ((- s
->dma_adc
.hwptr
) & (s
->dma_adc
.fragsize
-1));
525 fshift
= sample_shift
[(s
->sctrl
& SCTRL_R1FMT
) >> SCTRL_SH_R1FMT
];
526 if (fragremain
< 2*fshift
)
527 fragremain
= s
->dma_adc
.fragsize
;
528 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
529 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
530 outl((s
->dma_adc
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
532 spin_unlock_irqrestore(&s
->lock
, flags
);
535 /* --------------------------------------------------------------------- */
537 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
538 #define DMABUF_MINORDER 1
540 extern inline void dealloc_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
)
542 unsigned long map
, mapend
;
545 /* undo marking the pages as reserved */
546 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
547 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
548 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
549 pci_free_consistent(s
->dev
, PAGE_SIZE
<< db
->buforder
, db
->rawbuf
, db
->dmaaddr
);
552 db
->mapped
= db
->ready
= 0;
555 static int prog_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
, unsigned rate
, unsigned fmt
, unsigned reg
)
560 unsigned long map
, mapend
;
562 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
564 db
->ready
= db
->mapped
= 0;
565 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
566 if ((db
->rawbuf
= pci_alloc_consistent(s
->dev
, PAGE_SIZE
<< order
, &db
->dmaaddr
)))
570 db
->buforder
= order
;
571 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
572 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
573 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
574 set_bit(PG_reserved
, &mem_map
[map
].flags
);
576 fmt
&= ES1370_FMT_MASK
;
577 bytepersec
= rate
<< sample_shift
[fmt
];
578 bufs
= PAGE_SIZE
<< db
->buforder
;
579 if (db
->ossfragshift
) {
580 if ((1000 << db
->ossfragshift
) < bytepersec
)
581 db
->fragshift
= ld2(bytepersec
/1000);
583 db
->fragshift
= db
->ossfragshift
;
585 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
586 if (db
->fragshift
< 3)
589 db
->numfrag
= bufs
>> db
->fragshift
;
590 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
592 db
->numfrag
= bufs
>> db
->fragshift
;
594 db
->fragsize
= 1 << db
->fragshift
;
595 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
596 db
->numfrag
= db
->ossmaxfrags
;
597 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
598 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
599 memset(db
->rawbuf
, (fmt
& ES1370_FMT_S16
) ? 0 : 0x80, db
->dmasize
);
600 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
601 outl(db
->dmaaddr
, s
->io
+(reg
& 0xff));
602 outl((db
->dmasize
>> 2)-1, s
->io
+((reg
+ 4) & 0xff));
607 extern inline int prog_dmabuf_adc(struct es1370_state
*s
)
610 return prog_dmabuf(s
, &s
->dma_adc
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
611 (s
->sctrl
>> SCTRL_SH_R1FMT
) & ES1370_FMT_MASK
, ES1370_REG_ADC_FRAMEADR
);
614 extern inline int prog_dmabuf_dac2(struct es1370_state
*s
)
617 return prog_dmabuf(s
, &s
->dma_dac2
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
618 (s
->sctrl
>> SCTRL_SH_P2FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC2_FRAMEADR
);
621 extern inline int prog_dmabuf_dac1(struct es1370_state
*s
)
624 return prog_dmabuf(s
, &s
->dma_dac1
, dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
],
625 (s
->sctrl
>> SCTRL_SH_P1FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC1_FRAMEADR
);
628 extern inline unsigned get_hwptr(struct es1370_state
*s
, struct dmabuf
*db
, unsigned reg
)
630 unsigned hwptr
, diff
;
632 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
633 hwptr
= (inl(s
->io
+(reg
& 0xff)) >> 14) & 0x3fffc;
634 diff
= (db
->dmasize
+ hwptr
- db
->hwptr
) % db
->dmasize
;
639 extern inline void clear_advance(void *buf
, unsigned bsize
, unsigned bptr
, unsigned len
, unsigned char c
)
641 if (bptr
+ len
> bsize
) {
642 unsigned x
= bsize
- bptr
;
643 memset(((char *)buf
) + bptr
, c
, x
);
647 memset(((char *)buf
) + bptr
, c
, len
);
650 /* call with spinlock held! */
651 static void es1370_update_ptr(struct es1370_state
*s
)
655 /* update ADC pointer */
656 if (s
->ctrl
& CTRL_ADC_EN
) {
657 diff
= get_hwptr(s
, &s
->dma_adc
, ES1370_REG_ADC_FRAMECNT
);
658 s
->dma_adc
.total_bytes
+= diff
;
659 s
->dma_adc
.count
+= diff
;
660 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
661 wake_up(&s
->dma_adc
.wait
);
662 if (!s
->dma_adc
.mapped
) {
663 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
664 s
->ctrl
&= ~CTRL_ADC_EN
;
665 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
670 /* update DAC1 pointer */
671 if (s
->ctrl
& CTRL_DAC1_EN
) {
672 diff
= get_hwptr(s
, &s
->dma_dac1
, ES1370_REG_DAC1_FRAMECNT
);
673 s
->dma_dac1
.total_bytes
+= diff
;
674 if (s
->dma_dac1
.mapped
) {
675 s
->dma_dac1
.count
+= diff
;
676 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
677 wake_up(&s
->dma_dac1
.wait
);
679 s
->dma_dac1
.count
-= diff
;
680 if (s
->dma_dac1
.count
<= 0) {
681 s
->ctrl
&= ~CTRL_DAC1_EN
;
682 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
684 } else if (s
->dma_dac1
.count
<= (signed)s
->dma_dac1
.fragsize
&& !s
->dma_dac1
.endcleared
) {
685 clear_advance(s
->dma_dac1
.rawbuf
, s
->dma_dac1
.dmasize
, s
->dma_dac1
.swptr
,
686 s
->dma_dac1
.fragsize
, (s
->sctrl
& SCTRL_P1SEB
) ? 0 : 0x80);
687 s
->dma_dac1
.endcleared
= 1;
689 if (s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
<= (signed)s
->dma_dac1
.dmasize
)
690 wake_up(&s
->dma_dac1
.wait
);
693 /* update DAC2 pointer */
694 if (s
->ctrl
& CTRL_DAC2_EN
) {
695 diff
= get_hwptr(s
, &s
->dma_dac2
, ES1370_REG_DAC2_FRAMECNT
);
696 s
->dma_dac2
.total_bytes
+= diff
;
697 if (s
->dma_dac2
.mapped
) {
698 s
->dma_dac2
.count
+= diff
;
699 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
700 wake_up(&s
->dma_dac2
.wait
);
702 s
->dma_dac2
.count
-= diff
;
703 if (s
->dma_dac2
.count
<= 0) {
704 s
->ctrl
&= ~CTRL_DAC2_EN
;
705 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
707 } else if (s
->dma_dac2
.count
<= (signed)s
->dma_dac2
.fragsize
&& !s
->dma_dac2
.endcleared
) {
708 clear_advance(s
->dma_dac2
.rawbuf
, s
->dma_dac2
.dmasize
, s
->dma_dac2
.swptr
,
709 s
->dma_dac2
.fragsize
, (s
->sctrl
& SCTRL_P2SEB
) ? 0 : 0x80);
710 s
->dma_dac2
.endcleared
= 1;
712 if (s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
<= (signed)s
->dma_dac2
.dmasize
)
713 wake_up(&s
->dma_dac2
.wait
);
718 /* hold spinlock for the following! */
719 static void es1370_handle_midi(struct es1370_state
*s
)
724 if (!(s
->ctrl
& CTRL_UART_EN
))
727 while (inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_RXRDY
) {
728 ch
= inb(s
->io
+ES1370_REG_UART_DATA
);
729 if (s
->midi
.icnt
< MIDIINBUF
) {
730 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
731 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
737 wake_up(&s
->midi
.iwait
);
739 while ((inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_TXRDY
) && s
->midi
.ocnt
> 0) {
740 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->io
+ES1370_REG_UART_DATA
);
741 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
743 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
747 wake_up(&s
->midi
.owait
);
748 outb((s
->midi
.ocnt
> 0) ? UCTRL_RXINTEN
| UCTRL_ENA_TXINT
: UCTRL_RXINTEN
, s
->io
+ES1370_REG_UART_CONTROL
);
751 static void es1370_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
753 struct es1370_state
*s
= (struct es1370_state
*)dev_id
;
754 unsigned int intsrc
, sctl
;
756 /* fastpath out, to ease interrupt sharing */
757 intsrc
= inl(s
->io
+ES1370_REG_STATUS
);
758 if (!(intsrc
& 0x80000000))
761 /* clear audio interrupts first */
763 if (intsrc
& STAT_ADC
)
764 sctl
&= ~SCTRL_R1INTEN
;
765 if (intsrc
& STAT_DAC1
)
766 sctl
&= ~SCTRL_P1INTEN
;
767 if (intsrc
& STAT_DAC2
)
768 sctl
&= ~SCTRL_P2INTEN
;
769 outl(sctl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
770 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
771 es1370_update_ptr(s
);
772 es1370_handle_midi(s
);
773 spin_unlock(&s
->lock
);
776 /* --------------------------------------------------------------------- */
778 static const char invalid_magic
[] = KERN_CRIT
"es1370: invalid magic value\n";
780 #define VALIDATE_STATE(s) \
782 if (!(s) || (s)->magic != ES1370_MAGIC) { \
783 printk(invalid_magic); \
788 /* --------------------------------------------------------------------- */
790 static const struct {
797 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
798 [SOUND_MIXER_VOLUME
] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
799 [SOUND_MIXER_PCM
] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
800 [SOUND_MIXER_SYNTH
] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
801 [SOUND_MIXER_CD
] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
802 [SOUND_MIXER_LINE
] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
803 [SOUND_MIXER_LINE1
] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
804 [SOUND_MIXER_LINE2
] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
805 [SOUND_MIXER_LINE3
] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
806 [SOUND_MIXER_MIC
] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
807 [SOUND_MIXER_OGAIN
] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
810 static void set_recsrc(struct es1370_state
*s
, unsigned int val
)
814 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
815 if (!(val
& (1 << i
)))
817 if (!mixtable
[i
].recmask
) {
821 j
|= mixtable
[i
].recmask
;
824 wrcodec(s
, 0x12, j
& 0xd5);
825 wrcodec(s
, 0x13, j
& 0xaa);
826 wrcodec(s
, 0x14, (j
>> 8) & 0x17);
827 wrcodec(s
, 0x15, (j
>> 8) & 0x0f);
828 i
= (j
& 0x37f) | ((j
<< 1) & 0x3000) | 0xc60;
830 i
&= 0xff60; /* mute record and line monitor */
833 wrcodec(s
, 0x11, i
>> 8);
836 static int mixer_ioctl(struct es1370_state
*s
, unsigned int cmd
, unsigned long arg
)
840 unsigned char l
, r
, rl
, rr
;
843 if (cmd
== SOUND_MIXER_PRIVATE1
) {
844 /* enable/disable/query mixer preamp */
845 get_user_ret(val
, (int *)arg
, -EFAULT
);
847 s
->mix
.micpreamp
= !!val
;
848 wrcodec(s
, 0x19, s
->mix
.micpreamp
);
850 return put_user(s
->mix
.micpreamp
, (int *)arg
);
852 if (cmd
== SOUND_MIXER_PRIVATE2
) {
853 /* enable/disable/query use of linein as second lineout */
854 get_user_ret(val
, (int *)arg
, -EFAULT
);
856 spin_lock_irqsave(&s
->lock
, flags
);
858 s
->ctrl
|= CTRL_XCTL0
;
860 s
->ctrl
&= ~CTRL_XCTL0
;
861 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
862 spin_unlock_irqrestore(&s
->lock
, flags
);
864 return put_user((s
->ctrl
& CTRL_XCTL0
) ? 1 : 0, (int *)arg
);
866 if (cmd
== SOUND_MIXER_PRIVATE3
) {
867 /* enable/disable/query microphone impedance setting */
868 get_user_ret(val
, (int *)arg
, -EFAULT
);
870 spin_lock_irqsave(&s
->lock
, flags
);
872 s
->ctrl
|= CTRL_XCTL1
;
874 s
->ctrl
&= ~CTRL_XCTL1
;
875 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
876 spin_unlock_irqrestore(&s
->lock
, flags
);
878 return put_user((s
->ctrl
& CTRL_XCTL1
) ? 1 : 0, (int *)arg
);
880 if (cmd
== SOUND_MIXER_INFO
) {
882 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
883 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
884 info
.modify_counter
= s
->mix
.modcnt
;
885 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
889 if (cmd
== SOUND_OLD_MIXER_INFO
) {
890 _old_mixer_info info
;
891 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
892 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
893 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
897 if (cmd
== OSS_GETVERSION
)
898 return put_user(SOUND_VERSION
, (int *)arg
);
899 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
901 if (_IOC_DIR(cmd
) == _IOC_READ
) {
902 switch (_IOC_NR(cmd
)) {
903 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
904 return put_user(s
->mix
.recsrc
, (int *)arg
);
906 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
907 val
= SOUND_MASK_IMIX
;
908 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
909 if (mixtable
[i
].avail
)
911 return put_user(val
, (int *)arg
);
913 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
914 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
915 if (mixtable
[i
].recmask
)
917 return put_user(val
, (int *)arg
);
919 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
920 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
921 if (mixtable
[i
].stereo
)
923 return put_user(val
, (int *)arg
);
925 case SOUND_MIXER_CAPS
:
926 return put_user(0, (int *)arg
);
928 case SOUND_MIXER_IMIX
:
929 return put_user(s
->mix
.imix
, (int *)arg
);
933 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
935 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
938 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
941 switch (_IOC_NR(cmd
)) {
943 case SOUND_MIXER_IMIX
:
944 get_user_ret(s
->mix
.imix
, (int *)arg
, -EFAULT
);
945 set_recsrc(s
, s
->mix
.recsrc
);
948 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
949 get_user_ret(val
, (int *)arg
, -EFAULT
);
955 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
957 get_user_ret(val
, (int *)arg
, -EFAULT
);
961 if (mixtable
[i
].stereo
) {
962 r
= (val
>> 8) & 0xff;
969 rl
= 31 - ((l
- 7) / 3);
970 l
= (31 - rl
) * 3 + 7;
976 rr
= 31 - ((r
- 7) / 3);
977 r
= (31 - rr
) * 3 + 7;
979 wrcodec(s
, mixtable
[i
].right
, rr
);
981 if (mixtable
[i
].left
== 15) {
986 rl
= 7 - ((l
- 2) / 14);
987 r
= l
= (7 - rl
) * 14 + 2;
994 rl
= 31 - ((l
- 7) / 3);
995 r
= l
= (31 - rl
) * 3 + 7;
999 wrcodec(s
, mixtable
[i
].left
, rl
);
1000 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1001 s
->mix
.vol
[mixtable
[i
].volidx
] = ((unsigned int)r
<< 8) | l
;
1003 s
->mix
.vol
[mixtable
[i
].volidx
] = val
;
1005 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
1009 /* --------------------------------------------------------------------- */
1011 static loff_t
es1370_llseek(struct file
*file
, loff_t offset
, int origin
)
1016 /* --------------------------------------------------------------------- */
1018 static int es1370_open_mixdev(struct inode
*inode
, struct file
*file
)
1020 int minor
= MINOR(inode
->i_rdev
);
1021 struct list_head
*list
;
1022 struct es1370_state
*s
;
1024 for (list
= devs
.next
; ; list
= list
->next
) {
1027 s
= list_entry(list
, struct es1370_state
, devs
);
1028 if (s
->dev_mixer
== minor
)
1032 file
->private_data
= s
;
1037 static int es1370_release_mixdev(struct inode
*inode
, struct file
*file
)
1039 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1046 static int es1370_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1048 return mixer_ioctl((struct es1370_state
*)file
->private_data
, cmd
, arg
);
1051 static /*const*/ struct file_operations es1370_mixer_fops
= {
1052 llseek
: es1370_llseek
,
1053 ioctl
: es1370_ioctl_mixdev
,
1054 open
: es1370_open_mixdev
,
1055 release
: es1370_release_mixdev
,
1058 /* --------------------------------------------------------------------- */
1060 static int drain_dac1(struct es1370_state
*s
, int nonblock
)
1062 DECLARE_WAITQUEUE(wait
, current
);
1063 unsigned long flags
;
1066 if (s
->dma_dac1
.mapped
|| !s
->dma_dac1
.ready
)
1068 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1070 __set_current_state(TASK_INTERRUPTIBLE
);
1071 spin_lock_irqsave(&s
->lock
, flags
);
1072 count
= s
->dma_dac1
.count
;
1073 spin_unlock_irqrestore(&s
->lock
, flags
);
1076 if (signal_pending(current
))
1079 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1080 set_current_state(TASK_RUNNING
);
1083 tmo
= 3 * HZ
* (count
+ s
->dma_dac1
.fragsize
) / 2
1084 / dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
];
1085 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
1086 if (!schedule_timeout(tmo
+ 1))
1087 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1089 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1090 set_current_state(TASK_RUNNING
);
1091 if (signal_pending(current
))
1092 return -ERESTARTSYS
;
1096 static int drain_dac2(struct es1370_state
*s
, int nonblock
)
1098 DECLARE_WAITQUEUE(wait
, current
);
1099 unsigned long flags
;
1102 if (s
->dma_dac2
.mapped
|| !s
->dma_dac2
.ready
)
1104 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1106 __set_current_state(TASK_INTERRUPTIBLE
);
1107 spin_lock_irqsave(&s
->lock
, flags
);
1108 count
= s
->dma_dac2
.count
;
1109 spin_unlock_irqrestore(&s
->lock
, flags
);
1112 if (signal_pending(current
))
1115 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1116 set_current_state(TASK_RUNNING
);
1119 tmo
= 3 * HZ
* (count
+ s
->dma_dac2
.fragsize
) / 2
1120 / DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
);
1121 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
1122 if (!schedule_timeout(tmo
+ 1))
1123 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1125 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1126 set_current_state(TASK_RUNNING
);
1127 if (signal_pending(current
))
1128 return -ERESTARTSYS
;
1132 /* --------------------------------------------------------------------- */
1134 static ssize_t
es1370_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1136 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1137 DECLARE_WAITQUEUE(wait
, current
);
1139 unsigned long flags
;
1144 if (ppos
!= &file
->f_pos
)
1146 if (s
->dma_adc
.mapped
)
1148 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1150 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1153 add_wait_queue(&s
->dma_adc
.wait
, &wait
);
1155 spin_lock_irqsave(&s
->lock
, flags
);
1156 swptr
= s
->dma_adc
.swptr
;
1157 cnt
= s
->dma_adc
.dmasize
-swptr
;
1158 if (s
->dma_adc
.count
< cnt
)
1159 cnt
= s
->dma_adc
.count
;
1161 __set_current_state(TASK_INTERRUPTIBLE
);
1162 spin_unlock_irqrestore(&s
->lock
, flags
);
1167 if (file
->f_flags
& O_NONBLOCK
) {
1173 if (signal_pending(current
)) {
1180 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
)) {
1185 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1186 spin_lock_irqsave(&s
->lock
, flags
);
1187 s
->dma_adc
.swptr
= swptr
;
1188 s
->dma_adc
.count
-= cnt
;
1189 spin_unlock_irqrestore(&s
->lock
, flags
);
1195 remove_wait_queue(&s
->dma_adc
.wait
, &wait
);
1196 set_current_state(TASK_RUNNING
);
1200 static ssize_t
es1370_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1202 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1203 DECLARE_WAITQUEUE(wait
, current
);
1205 unsigned long flags
;
1210 if (ppos
!= &file
->f_pos
)
1212 if (s
->dma_dac2
.mapped
)
1214 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1216 if (!access_ok(VERIFY_READ
, buffer
, count
))
1219 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1221 spin_lock_irqsave(&s
->lock
, flags
);
1222 if (s
->dma_dac2
.count
< 0) {
1223 s
->dma_dac2
.count
= 0;
1224 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
;
1226 swptr
= s
->dma_dac2
.swptr
;
1227 cnt
= s
->dma_dac2
.dmasize
-swptr
;
1228 if (s
->dma_dac2
.count
+ cnt
> s
->dma_dac2
.dmasize
)
1229 cnt
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1231 __set_current_state(TASK_INTERRUPTIBLE
);
1232 spin_unlock_irqrestore(&s
->lock
, flags
);
1237 if (file
->f_flags
& O_NONBLOCK
) {
1243 if (signal_pending(current
)) {
1250 if (copy_from_user(s
->dma_dac2
.rawbuf
+ swptr
, buffer
, cnt
)) {
1255 swptr
= (swptr
+ cnt
) % s
->dma_dac2
.dmasize
;
1256 spin_lock_irqsave(&s
->lock
, flags
);
1257 s
->dma_dac2
.swptr
= swptr
;
1258 s
->dma_dac2
.count
+= cnt
;
1259 s
->dma_dac2
.endcleared
= 0;
1260 spin_unlock_irqrestore(&s
->lock
, flags
);
1266 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1267 set_current_state(TASK_RUNNING
);
1271 /* No kernel lock - we have our own spinlock */
1272 static unsigned int es1370_poll(struct file
*file
, struct poll_table_struct
*wait
)
1274 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1275 unsigned long flags
;
1276 unsigned int mask
= 0;
1279 if (file
->f_mode
& FMODE_WRITE
)
1280 poll_wait(file
, &s
->dma_dac2
.wait
, wait
);
1281 if (file
->f_mode
& FMODE_READ
)
1282 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1283 spin_lock_irqsave(&s
->lock
, flags
);
1284 es1370_update_ptr(s
);
1285 if (file
->f_mode
& FMODE_READ
) {
1286 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1287 mask
|= POLLIN
| POLLRDNORM
;
1289 if (file
->f_mode
& FMODE_WRITE
) {
1290 if (s
->dma_dac2
.mapped
) {
1291 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
1292 mask
|= POLLOUT
| POLLWRNORM
;
1294 if ((signed)s
->dma_dac2
.dmasize
>= s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
)
1295 mask
|= POLLOUT
| POLLWRNORM
;
1298 spin_unlock_irqrestore(&s
->lock
, flags
);
1302 static int es1370_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1304 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1310 if (vma
->vm_flags
& VM_WRITE
) {
1311 if ((ret
= prog_dmabuf_dac2(s
)) != 0)
1314 } else if (vma
->vm_flags
& VM_READ
) {
1315 if ((ret
= prog_dmabuf_adc(s
)) != 0)
1320 if (vma
->vm_pgoff
!= 0)
1322 size
= vma
->vm_end
- vma
->vm_start
;
1323 if (size
> (PAGE_SIZE
<< db
->buforder
))
1325 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1331 static int es1370_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1333 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1334 unsigned long flags
;
1335 audio_buf_info abinfo
;
1338 int val
, mapped
, ret
;
1341 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac2
.mapped
) ||
1342 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1344 case OSS_GETVERSION
:
1345 return put_user(SOUND_VERSION
, (int *)arg
);
1347 case SNDCTL_DSP_SYNC
:
1348 if (file
->f_mode
& FMODE_WRITE
)
1349 return drain_dac2(s
, 0/*file->f_flags & O_NONBLOCK*/);
1352 case SNDCTL_DSP_SETDUPLEX
:
1355 case SNDCTL_DSP_GETCAPS
:
1356 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1358 case SNDCTL_DSP_RESET
:
1359 if (file
->f_mode
& FMODE_WRITE
) {
1362 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
= s
->dma_dac2
.count
= s
->dma_dac2
.total_bytes
= 0;
1364 if (file
->f_mode
& FMODE_READ
) {
1367 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1371 case SNDCTL_DSP_SPEED
:
1372 get_user_ret(val
, (int *)arg
, -EFAULT
);
1374 if (s
->open_mode
& (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
))
1382 s
->dma_adc
.ready
= s
->dma_dac2
.ready
= 0;
1383 spin_lock_irqsave(&s
->lock
, flags
);
1384 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(val
) << CTRL_SH_PCLKDIV
);
1385 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1386 spin_unlock_irqrestore(&s
->lock
, flags
);
1388 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1390 case SNDCTL_DSP_STEREO
:
1391 get_user_ret(val
, (int *)arg
, -EFAULT
);
1392 if (file
->f_mode
& FMODE_READ
) {
1394 s
->dma_adc
.ready
= 0;
1395 spin_lock_irqsave(&s
->lock
, flags
);
1397 s
->sctrl
|= SCTRL_R1SMB
;
1399 s
->sctrl
&= ~SCTRL_R1SMB
;
1400 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1401 spin_unlock_irqrestore(&s
->lock
, flags
);
1403 if (file
->f_mode
& FMODE_WRITE
) {
1405 s
->dma_dac2
.ready
= 0;
1406 spin_lock_irqsave(&s
->lock
, flags
);
1408 s
->sctrl
|= SCTRL_P2SMB
;
1410 s
->sctrl
&= ~SCTRL_P2SMB
;
1411 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1412 spin_unlock_irqrestore(&s
->lock
, flags
);
1416 case SNDCTL_DSP_CHANNELS
:
1417 get_user_ret(val
, (int *)arg
, -EFAULT
);
1419 if (file
->f_mode
& FMODE_READ
) {
1421 s
->dma_adc
.ready
= 0;
1422 spin_lock_irqsave(&s
->lock
, flags
);
1424 s
->sctrl
|= SCTRL_R1SMB
;
1426 s
->sctrl
&= ~SCTRL_R1SMB
;
1427 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1428 spin_unlock_irqrestore(&s
->lock
, flags
);
1430 if (file
->f_mode
& FMODE_WRITE
) {
1432 s
->dma_dac2
.ready
= 0;
1433 spin_lock_irqsave(&s
->lock
, flags
);
1435 s
->sctrl
|= SCTRL_P2SMB
;
1437 s
->sctrl
&= ~SCTRL_P2SMB
;
1438 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1439 spin_unlock_irqrestore(&s
->lock
, flags
);
1442 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ? 2 : 1, (int *)arg
);
1444 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1445 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1447 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1448 get_user_ret(val
, (int *)arg
, -EFAULT
);
1449 if (val
!= AFMT_QUERY
) {
1450 if (file
->f_mode
& FMODE_READ
) {
1452 s
->dma_adc
.ready
= 0;
1453 spin_lock_irqsave(&s
->lock
, flags
);
1454 if (val
== AFMT_S16_LE
)
1455 s
->sctrl
|= SCTRL_R1SEB
;
1457 s
->sctrl
&= ~SCTRL_R1SEB
;
1458 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1459 spin_unlock_irqrestore(&s
->lock
, flags
);
1461 if (file
->f_mode
& FMODE_WRITE
) {
1463 s
->dma_dac2
.ready
= 0;
1464 spin_lock_irqsave(&s
->lock
, flags
);
1465 if (val
== AFMT_S16_LE
)
1466 s
->sctrl
|= SCTRL_P2SEB
;
1468 s
->sctrl
&= ~SCTRL_P2SEB
;
1469 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1470 spin_unlock_irqrestore(&s
->lock
, flags
);
1473 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1474 AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1476 case SNDCTL_DSP_POST
:
1479 case SNDCTL_DSP_GETTRIGGER
:
1481 if (file
->f_mode
& FMODE_READ
&& s
->ctrl
& CTRL_ADC_EN
)
1482 val
|= PCM_ENABLE_INPUT
;
1483 if (file
->f_mode
& FMODE_WRITE
&& s
->ctrl
& CTRL_DAC2_EN
)
1484 val
|= PCM_ENABLE_OUTPUT
;
1485 return put_user(val
, (int *)arg
);
1487 case SNDCTL_DSP_SETTRIGGER
:
1488 get_user_ret(val
, (int *)arg
, -EFAULT
);
1489 if (file
->f_mode
& FMODE_READ
) {
1490 if (val
& PCM_ENABLE_INPUT
) {
1491 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1497 if (file
->f_mode
& FMODE_WRITE
) {
1498 if (val
& PCM_ENABLE_OUTPUT
) {
1499 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1507 case SNDCTL_DSP_GETOSPACE
:
1508 if (!(file
->f_mode
& FMODE_WRITE
))
1510 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac2(s
)) != 0)
1512 spin_lock_irqsave(&s
->lock
, flags
);
1513 es1370_update_ptr(s
);
1514 abinfo
.fragsize
= s
->dma_dac2
.fragsize
;
1515 count
= s
->dma_dac2
.count
;
1518 abinfo
.bytes
= s
->dma_dac2
.dmasize
- count
;
1519 abinfo
.fragstotal
= s
->dma_dac2
.numfrag
;
1520 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac2
.fragshift
;
1521 spin_unlock_irqrestore(&s
->lock
, flags
);
1522 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1524 case SNDCTL_DSP_GETISPACE
:
1525 if (!(file
->f_mode
& FMODE_READ
))
1527 if (!(s
->ctrl
& CTRL_ADC_EN
) && (val
= prog_dmabuf_adc(s
)) != 0)
1529 spin_lock_irqsave(&s
->lock
, flags
);
1530 es1370_update_ptr(s
);
1531 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1532 count
= s
->dma_adc
.count
;
1535 abinfo
.bytes
= count
;
1536 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1537 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1538 spin_unlock_irqrestore(&s
->lock
, flags
);
1539 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1541 case SNDCTL_DSP_NONBLOCK
:
1542 file
->f_flags
|= O_NONBLOCK
;
1545 case SNDCTL_DSP_GETODELAY
:
1546 if (!(file
->f_mode
& FMODE_WRITE
))
1548 spin_lock_irqsave(&s
->lock
, flags
);
1549 es1370_update_ptr(s
);
1550 count
= s
->dma_dac2
.count
;
1551 spin_unlock_irqrestore(&s
->lock
, flags
);
1554 return put_user(count
, (int *)arg
);
1556 case SNDCTL_DSP_GETIPTR
:
1557 if (!(file
->f_mode
& FMODE_READ
))
1559 spin_lock_irqsave(&s
->lock
, flags
);
1560 es1370_update_ptr(s
);
1561 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1562 count
= s
->dma_adc
.count
;
1565 cinfo
.blocks
= count
>> s
->dma_adc
.fragshift
;
1566 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1567 if (s
->dma_adc
.mapped
)
1568 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1569 spin_unlock_irqrestore(&s
->lock
, flags
);
1570 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1572 case SNDCTL_DSP_GETOPTR
:
1573 if (!(file
->f_mode
& FMODE_WRITE
))
1575 spin_lock_irqsave(&s
->lock
, flags
);
1576 es1370_update_ptr(s
);
1577 cinfo
.bytes
= s
->dma_dac2
.total_bytes
;
1578 count
= s
->dma_dac2
.count
;
1581 cinfo
.blocks
= count
>> s
->dma_dac2
.fragshift
;
1582 cinfo
.ptr
= s
->dma_dac2
.hwptr
;
1583 if (s
->dma_dac2
.mapped
)
1584 s
->dma_dac2
.count
&= s
->dma_dac2
.fragsize
-1;
1585 spin_unlock_irqrestore(&s
->lock
, flags
);
1586 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1588 case SNDCTL_DSP_GETBLKSIZE
:
1589 if (file
->f_mode
& FMODE_WRITE
) {
1590 if ((val
= prog_dmabuf_dac2(s
)))
1592 return put_user(s
->dma_dac2
.fragsize
, (int *)arg
);
1594 if ((val
= prog_dmabuf_adc(s
)))
1596 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1598 case SNDCTL_DSP_SETFRAGMENT
:
1599 get_user_ret(val
, (int *)arg
, -EFAULT
);
1600 if (file
->f_mode
& FMODE_READ
) {
1601 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1602 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1603 if (s
->dma_adc
.ossfragshift
< 4)
1604 s
->dma_adc
.ossfragshift
= 4;
1605 if (s
->dma_adc
.ossfragshift
> 15)
1606 s
->dma_adc
.ossfragshift
= 15;
1607 if (s
->dma_adc
.ossmaxfrags
< 4)
1608 s
->dma_adc
.ossmaxfrags
= 4;
1610 if (file
->f_mode
& FMODE_WRITE
) {
1611 s
->dma_dac2
.ossfragshift
= val
& 0xffff;
1612 s
->dma_dac2
.ossmaxfrags
= (val
>> 16) & 0xffff;
1613 if (s
->dma_dac2
.ossfragshift
< 4)
1614 s
->dma_dac2
.ossfragshift
= 4;
1615 if (s
->dma_dac2
.ossfragshift
> 15)
1616 s
->dma_dac2
.ossfragshift
= 15;
1617 if (s
->dma_dac2
.ossmaxfrags
< 4)
1618 s
->dma_dac2
.ossmaxfrags
= 4;
1622 case SNDCTL_DSP_SUBDIVIDE
:
1623 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1624 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac2
.subdivision
))
1626 get_user_ret(val
, (int *)arg
, -EFAULT
);
1627 if (val
!= 1 && val
!= 2 && val
!= 4)
1629 if (file
->f_mode
& FMODE_READ
)
1630 s
->dma_adc
.subdivision
= val
;
1631 if (file
->f_mode
& FMODE_WRITE
)
1632 s
->dma_dac2
.subdivision
= val
;
1635 case SOUND_PCM_READ_RATE
:
1636 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1638 case SOUND_PCM_READ_CHANNELS
:
1639 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ?
1642 case SOUND_PCM_READ_BITS
:
1643 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1644 16 : 8, (int *)arg
);
1646 case SOUND_PCM_WRITE_FILTER
:
1647 case SNDCTL_DSP_SETSYNCRO
:
1648 case SOUND_PCM_READ_FILTER
:
1652 return mixer_ioctl(s
, cmd
, arg
);
1655 static int es1370_open(struct inode
*inode
, struct file
*file
)
1657 int minor
= MINOR(inode
->i_rdev
);
1658 DECLARE_WAITQUEUE(wait
, current
);
1659 unsigned long flags
;
1660 struct list_head
*list
;
1661 struct es1370_state
*s
;
1663 for (list
= devs
.next
; ; list
= list
->next
) {
1666 s
= list_entry(list
, struct es1370_state
, devs
);
1667 if (!((s
->dev_audio
^ minor
) & ~0xf))
1671 file
->private_data
= s
;
1672 /* wait for device to become free */
1674 while (s
->open_mode
& file
->f_mode
) {
1675 if (file
->f_flags
& O_NONBLOCK
) {
1679 add_wait_queue(&s
->open_wait
, &wait
);
1680 __set_current_state(TASK_INTERRUPTIBLE
);
1683 remove_wait_queue(&s
->open_wait
, &wait
);
1684 set_current_state(TASK_RUNNING
);
1685 if (signal_pending(current
))
1686 return -ERESTARTSYS
;
1689 spin_lock_irqsave(&s
->lock
, flags
);
1690 if (!(s
->open_mode
& (FMODE_READ
|FMODE_WRITE
)))
1691 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
);
1692 if (file
->f_mode
& FMODE_READ
) {
1693 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1694 s
->sctrl
&= ~SCTRL_R1FMT
;
1695 if ((minor
& 0xf) == SND_DEV_DSP16
)
1696 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_R1FMT
;
1698 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_R1FMT
;
1700 if (file
->f_mode
& FMODE_WRITE
) {
1701 s
->dma_dac2
.ossfragshift
= s
->dma_dac2
.ossmaxfrags
= s
->dma_dac2
.subdivision
= 0;
1702 s
->sctrl
&= ~SCTRL_P2FMT
;
1703 if ((minor
& 0xf) == SND_DEV_DSP16
)
1704 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P2FMT
;
1706 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P2FMT
;
1708 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1709 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1710 spin_unlock_irqrestore(&s
->lock
, flags
);
1711 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1717 static int es1370_release(struct inode
*inode
, struct file
*file
)
1719 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1722 if (file
->f_mode
& FMODE_WRITE
)
1723 drain_dac2(s
, file
->f_flags
& O_NONBLOCK
);
1725 if (file
->f_mode
& FMODE_WRITE
) {
1728 dealloc_dmabuf(s
, &s
->dma_dac2
);
1730 if (file
->f_mode
& FMODE_READ
) {
1732 dealloc_dmabuf(s
, &s
->dma_adc
);
1734 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1735 wake_up(&s
->open_wait
);
1741 static /*const*/ struct file_operations es1370_audio_fops
= {
1742 llseek
: es1370_llseek
,
1744 write
: es1370_write
,
1746 ioctl
: es1370_ioctl
,
1749 release
: es1370_release
,
1752 /* --------------------------------------------------------------------- */
1754 static ssize_t
es1370_write_dac(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1756 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1757 DECLARE_WAITQUEUE(wait
, current
);
1759 unsigned long flags
;
1764 if (ppos
!= &file
->f_pos
)
1766 if (s
->dma_dac1
.mapped
)
1768 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1770 if (!access_ok(VERIFY_READ
, buffer
, count
))
1772 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1774 spin_lock_irqsave(&s
->lock
, flags
);
1775 if (s
->dma_dac1
.count
< 0) {
1776 s
->dma_dac1
.count
= 0;
1777 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
;
1779 swptr
= s
->dma_dac1
.swptr
;
1780 cnt
= s
->dma_dac1
.dmasize
-swptr
;
1781 if (s
->dma_dac1
.count
+ cnt
> s
->dma_dac1
.dmasize
)
1782 cnt
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1784 __set_current_state(TASK_INTERRUPTIBLE
);
1785 spin_unlock_irqrestore(&s
->lock
, flags
);
1790 if (file
->f_flags
& O_NONBLOCK
) {
1796 if (signal_pending(current
)) {
1803 if (copy_from_user(s
->dma_dac1
.rawbuf
+ swptr
, buffer
, cnt
)) {
1808 swptr
= (swptr
+ cnt
) % s
->dma_dac1
.dmasize
;
1809 spin_lock_irqsave(&s
->lock
, flags
);
1810 s
->dma_dac1
.swptr
= swptr
;
1811 s
->dma_dac1
.count
+= cnt
;
1812 s
->dma_dac1
.endcleared
= 0;
1813 spin_unlock_irqrestore(&s
->lock
, flags
);
1819 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1820 set_current_state(TASK_RUNNING
);
1824 /* No kernel lock - we have our own spinlock */
1825 static unsigned int es1370_poll_dac(struct file
*file
, struct poll_table_struct
*wait
)
1827 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1828 unsigned long flags
;
1829 unsigned int mask
= 0;
1832 poll_wait(file
, &s
->dma_dac1
.wait
, wait
);
1833 spin_lock_irqsave(&s
->lock
, flags
);
1834 es1370_update_ptr(s
);
1835 if (s
->dma_dac1
.mapped
) {
1836 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
1837 mask
|= POLLOUT
| POLLWRNORM
;
1839 if ((signed)s
->dma_dac1
.dmasize
>= s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
)
1840 mask
|= POLLOUT
| POLLWRNORM
;
1842 spin_unlock_irqrestore(&s
->lock
, flags
);
1846 static int es1370_mmap_dac(struct file
*file
, struct vm_area_struct
*vma
)
1848 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1853 if (!(vma
->vm_flags
& VM_WRITE
))
1855 if ((ret
= prog_dmabuf_dac1(s
)) != 0)
1857 if (vma
->vm_pgoff
!= 0)
1859 size
= vma
->vm_end
- vma
->vm_start
;
1860 if (size
> (PAGE_SIZE
<< s
->dma_dac1
.buforder
))
1862 if (remap_page_range(vma
->vm_start
, virt_to_phys(s
->dma_dac1
.rawbuf
), size
, vma
->vm_page_prot
))
1864 s
->dma_dac1
.mapped
= 1;
1868 static int es1370_ioctl_dac(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1870 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1871 unsigned long flags
;
1872 audio_buf_info abinfo
;
1880 case OSS_GETVERSION
:
1881 return put_user(SOUND_VERSION
, (int *)arg
);
1883 case SNDCTL_DSP_SYNC
:
1884 return drain_dac1(s
, 0/*file->f_flags & O_NONBLOCK*/);
1886 case SNDCTL_DSP_SETDUPLEX
:
1889 case SNDCTL_DSP_GETCAPS
:
1890 return put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1892 case SNDCTL_DSP_RESET
:
1895 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
= s
->dma_dac1
.count
= s
->dma_dac1
.total_bytes
= 0;
1898 case SNDCTL_DSP_SPEED
:
1899 get_user_ret(val
, (int *)arg
, -EFAULT
);
1902 s
->dma_dac1
.ready
= 0;
1903 for (ctrl
= 0; ctrl
<= 2; ctrl
++)
1904 if (val
< (dac1_samplerate
[ctrl
] + dac1_samplerate
[ctrl
+1]) / 2)
1906 spin_lock_irqsave(&s
->lock
, flags
);
1907 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (ctrl
<< CTRL_SH_WTSRSEL
);
1908 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1909 spin_unlock_irqrestore(&s
->lock
, flags
);
1911 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1913 case SNDCTL_DSP_STEREO
:
1914 get_user_ret(val
, (int *)arg
, -EFAULT
);
1916 s
->dma_dac1
.ready
= 0;
1917 spin_lock_irqsave(&s
->lock
, flags
);
1919 s
->sctrl
|= SCTRL_P1SMB
;
1921 s
->sctrl
&= ~SCTRL_P1SMB
;
1922 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1923 spin_unlock_irqrestore(&s
->lock
, flags
);
1926 case SNDCTL_DSP_CHANNELS
:
1927 get_user_ret(val
, (int *)arg
, -EFAULT
);
1929 if (s
->dma_dac1
.mapped
)
1932 s
->dma_dac1
.ready
= 0;
1933 spin_lock_irqsave(&s
->lock
, flags
);
1935 s
->sctrl
|= SCTRL_P1SMB
;
1937 s
->sctrl
&= ~SCTRL_P1SMB
;
1938 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1939 spin_unlock_irqrestore(&s
->lock
, flags
);
1941 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1943 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1944 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1946 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1947 get_user_ret(val
, (int *)arg
, -EFAULT
);
1948 if (val
!= AFMT_QUERY
) {
1950 s
->dma_dac1
.ready
= 0;
1951 spin_lock_irqsave(&s
->lock
, flags
);
1952 if (val
== AFMT_S16_LE
)
1953 s
->sctrl
|= SCTRL_P1SEB
;
1955 s
->sctrl
&= ~SCTRL_P1SEB
;
1956 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1957 spin_unlock_irqrestore(&s
->lock
, flags
);
1959 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1961 case SNDCTL_DSP_POST
:
1964 case SNDCTL_DSP_GETTRIGGER
:
1965 return put_user((s
->ctrl
& CTRL_DAC1_EN
) ? PCM_ENABLE_OUTPUT
: 0, (int *)arg
);
1967 case SNDCTL_DSP_SETTRIGGER
:
1968 get_user_ret(val
, (int *)arg
, -EFAULT
);
1969 if (val
& PCM_ENABLE_OUTPUT
) {
1970 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1977 case SNDCTL_DSP_GETOSPACE
:
1978 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac1(s
)) != 0)
1980 spin_lock_irqsave(&s
->lock
, flags
);
1981 es1370_update_ptr(s
);
1982 abinfo
.fragsize
= s
->dma_dac1
.fragsize
;
1983 count
= s
->dma_dac1
.count
;
1986 abinfo
.bytes
= s
->dma_dac1
.dmasize
- count
;
1987 abinfo
.fragstotal
= s
->dma_dac1
.numfrag
;
1988 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac1
.fragshift
;
1989 spin_unlock_irqrestore(&s
->lock
, flags
);
1990 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1992 case SNDCTL_DSP_NONBLOCK
:
1993 file
->f_flags
|= O_NONBLOCK
;
1996 case SNDCTL_DSP_GETODELAY
:
1997 spin_lock_irqsave(&s
->lock
, flags
);
1998 es1370_update_ptr(s
);
1999 count
= s
->dma_dac1
.count
;
2000 spin_unlock_irqrestore(&s
->lock
, flags
);
2003 return put_user(count
, (int *)arg
);
2005 case SNDCTL_DSP_GETOPTR
:
2006 if (!(file
->f_mode
& FMODE_WRITE
))
2008 spin_lock_irqsave(&s
->lock
, flags
);
2009 es1370_update_ptr(s
);
2010 cinfo
.bytes
= s
->dma_dac1
.total_bytes
;
2011 count
= s
->dma_dac1
.count
;
2014 cinfo
.blocks
= count
>> s
->dma_dac1
.fragshift
;
2015 cinfo
.ptr
= s
->dma_dac1
.hwptr
;
2016 if (s
->dma_dac1
.mapped
)
2017 s
->dma_dac1
.count
&= s
->dma_dac1
.fragsize
-1;
2018 spin_unlock_irqrestore(&s
->lock
, flags
);
2019 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
2021 case SNDCTL_DSP_GETBLKSIZE
:
2022 if ((val
= prog_dmabuf_dac1(s
)))
2024 return put_user(s
->dma_dac1
.fragsize
, (int *)arg
);
2026 case SNDCTL_DSP_SETFRAGMENT
:
2027 get_user_ret(val
, (int *)arg
, -EFAULT
);
2028 s
->dma_dac1
.ossfragshift
= val
& 0xffff;
2029 s
->dma_dac1
.ossmaxfrags
= (val
>> 16) & 0xffff;
2030 if (s
->dma_dac1
.ossfragshift
< 4)
2031 s
->dma_dac1
.ossfragshift
= 4;
2032 if (s
->dma_dac1
.ossfragshift
> 15)
2033 s
->dma_dac1
.ossfragshift
= 15;
2034 if (s
->dma_dac1
.ossmaxfrags
< 4)
2035 s
->dma_dac1
.ossmaxfrags
= 4;
2038 case SNDCTL_DSP_SUBDIVIDE
:
2039 if (s
->dma_dac1
.subdivision
)
2041 get_user_ret(val
, (int *)arg
, -EFAULT
);
2042 if (val
!= 1 && val
!= 2 && val
!= 4)
2044 s
->dma_dac1
.subdivision
= val
;
2047 case SOUND_PCM_READ_RATE
:
2048 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
2050 case SOUND_PCM_READ_CHANNELS
:
2051 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
2053 case SOUND_PCM_READ_BITS
:
2054 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? 16 : 8, (int *)arg
);
2056 case SOUND_PCM_WRITE_FILTER
:
2057 case SNDCTL_DSP_SETSYNCRO
:
2058 case SOUND_PCM_READ_FILTER
:
2062 return mixer_ioctl(s
, cmd
, arg
);
2065 static int es1370_open_dac(struct inode
*inode
, struct file
*file
)
2067 int minor
= MINOR(inode
->i_rdev
);
2068 DECLARE_WAITQUEUE(wait
, current
);
2069 unsigned long flags
;
2070 struct list_head
*list
;
2071 struct es1370_state
*s
;
2073 for (list
= devs
.next
; ; list
= list
->next
) {
2076 s
= list_entry(list
, struct es1370_state
, devs
);
2077 if (!((s
->dev_dac
^ minor
) & ~0xf))
2081 /* we allow opening with O_RDWR, most programs do it although they will only write */
2083 if (file
->f_mode
& FMODE_READ
)
2086 if (!(file
->f_mode
& FMODE_WRITE
))
2088 file
->private_data
= s
;
2089 /* wait for device to become free */
2091 while (s
->open_mode
& FMODE_DAC
) {
2092 if (file
->f_flags
& O_NONBLOCK
) {
2096 add_wait_queue(&s
->open_wait
, &wait
);
2097 __set_current_state(TASK_INTERRUPTIBLE
);
2100 remove_wait_queue(&s
->open_wait
, &wait
);
2101 set_current_state(TASK_RUNNING
);
2102 if (signal_pending(current
))
2103 return -ERESTARTSYS
;
2106 s
->dma_dac1
.ossfragshift
= s
->dma_dac1
.ossmaxfrags
= s
->dma_dac1
.subdivision
= 0;
2107 spin_lock_irqsave(&s
->lock
, flags
);
2108 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (1 << CTRL_SH_WTSRSEL
);
2109 s
->sctrl
&= ~SCTRL_P1FMT
;
2110 if ((minor
& 0xf) == SND_DEV_DSP16
)
2111 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P1FMT
;
2113 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P1FMT
;
2114 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2115 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2116 spin_unlock_irqrestore(&s
->lock
, flags
);
2117 s
->open_mode
|= FMODE_DAC
;
2123 static int es1370_release_dac(struct inode
*inode
, struct file
*file
)
2125 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2128 drain_dac1(s
, file
->f_flags
& O_NONBLOCK
);
2131 dealloc_dmabuf(s
, &s
->dma_dac1
);
2132 s
->open_mode
&= ~FMODE_DAC
;
2133 wake_up(&s
->open_wait
);
2139 static /*const*/ struct file_operations es1370_dac_fops
= {
2140 llseek
: es1370_llseek
,
2141 write
: es1370_write_dac
,
2142 poll
: es1370_poll_dac
,
2143 ioctl
: es1370_ioctl_dac
,
2144 mmap
: es1370_mmap_dac
,
2145 open
: es1370_open_dac
,
2146 release
: es1370_release_dac
,
2149 /* --------------------------------------------------------------------- */
2151 static ssize_t
es1370_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
2153 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2154 DECLARE_WAITQUEUE(wait
, current
);
2156 unsigned long flags
;
2161 if (ppos
!= &file
->f_pos
)
2163 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2168 add_wait_queue(&s
->midi
.iwait
, &wait
);
2170 spin_lock_irqsave(&s
->lock
, flags
);
2172 cnt
= MIDIINBUF
- ptr
;
2173 if (s
->midi
.icnt
< cnt
)
2176 __set_current_state(TASK_INTERRUPTIBLE
);
2177 spin_unlock_irqrestore(&s
->lock
, flags
);
2181 if (file
->f_flags
& O_NONBLOCK
) {
2187 if (signal_pending(current
)) {
2194 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
)) {
2199 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
2200 spin_lock_irqsave(&s
->lock
, flags
);
2202 s
->midi
.icnt
-= cnt
;
2203 spin_unlock_irqrestore(&s
->lock
, flags
);
2209 __set_current_state(TASK_RUNNING
);
2210 remove_wait_queue(&s
->midi
.iwait
, &wait
);
2214 static ssize_t
es1370_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
2216 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2217 DECLARE_WAITQUEUE(wait
, current
);
2219 unsigned long flags
;
2224 if (ppos
!= &file
->f_pos
)
2226 if (!access_ok(VERIFY_READ
, buffer
, count
))
2231 add_wait_queue(&s
->midi
.owait
, &wait
);
2233 spin_lock_irqsave(&s
->lock
, flags
);
2235 cnt
= MIDIOUTBUF
- ptr
;
2236 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
2237 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
2239 __set_current_state(TASK_INTERRUPTIBLE
);
2240 es1370_handle_midi(s
);
2242 spin_unlock_irqrestore(&s
->lock
, flags
);
2246 if (file
->f_flags
& O_NONBLOCK
) {
2252 if (signal_pending(current
)) {
2259 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
)) {
2264 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
2265 spin_lock_irqsave(&s
->lock
, flags
);
2267 s
->midi
.ocnt
+= cnt
;
2268 spin_unlock_irqrestore(&s
->lock
, flags
);
2272 spin_lock_irqsave(&s
->lock
, flags
);
2273 es1370_handle_midi(s
);
2274 spin_unlock_irqrestore(&s
->lock
, flags
);
2276 __set_current_state(TASK_RUNNING
);
2277 remove_wait_queue(&s
->midi
.owait
, &wait
);
2281 /* No kernel lock - we have our own spinlock */
2282 static unsigned int es1370_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2284 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2285 unsigned long flags
;
2286 unsigned int mask
= 0;
2289 if (file
->f_mode
& FMODE_WRITE
)
2290 poll_wait(file
, &s
->midi
.owait
, wait
);
2291 if (file
->f_mode
& FMODE_READ
)
2292 poll_wait(file
, &s
->midi
.iwait
, wait
);
2293 spin_lock_irqsave(&s
->lock
, flags
);
2294 if (file
->f_mode
& FMODE_READ
) {
2295 if (s
->midi
.icnt
> 0)
2296 mask
|= POLLIN
| POLLRDNORM
;
2298 if (file
->f_mode
& FMODE_WRITE
) {
2299 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2300 mask
|= POLLOUT
| POLLWRNORM
;
2302 spin_unlock_irqrestore(&s
->lock
, flags
);
2306 static int es1370_midi_open(struct inode
*inode
, struct file
*file
)
2308 int minor
= MINOR(inode
->i_rdev
);
2309 DECLARE_WAITQUEUE(wait
, current
);
2310 unsigned long flags
;
2311 struct list_head
*list
;
2312 struct es1370_state
*s
;
2314 for (list
= devs
.next
; ; list
= list
->next
) {
2317 s
= list_entry(list
, struct es1370_state
, devs
);
2318 if (s
->dev_midi
== minor
)
2322 file
->private_data
= s
;
2323 /* wait for device to become free */
2325 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2326 if (file
->f_flags
& O_NONBLOCK
) {
2330 add_wait_queue(&s
->open_wait
, &wait
);
2331 __set_current_state(TASK_INTERRUPTIBLE
);
2334 remove_wait_queue(&s
->open_wait
, &wait
);
2335 set_current_state(TASK_RUNNING
);
2336 if (signal_pending(current
))
2337 return -ERESTARTSYS
;
2340 spin_lock_irqsave(&s
->lock
, flags
);
2341 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2342 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2343 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2344 outb(UCTRL_CNTRL_SWR
, s
->io
+ES1370_REG_UART_CONTROL
);
2345 outb(0, s
->io
+ES1370_REG_UART_CONTROL
);
2346 outb(0, s
->io
+ES1370_REG_UART_TEST
);
2348 if (file
->f_mode
& FMODE_READ
) {
2349 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2351 if (file
->f_mode
& FMODE_WRITE
) {
2352 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2354 s
->ctrl
|= CTRL_UART_EN
;
2355 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2356 es1370_handle_midi(s
);
2357 spin_unlock_irqrestore(&s
->lock
, flags
);
2358 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2364 static int es1370_midi_release(struct inode
*inode
, struct file
*file
)
2366 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2367 DECLARE_WAITQUEUE(wait
, current
);
2368 unsigned long flags
;
2369 unsigned count
, tmo
;
2373 if (file
->f_mode
& FMODE_WRITE
) {
2374 add_wait_queue(&s
->midi
.owait
, &wait
);
2376 __set_current_state(TASK_INTERRUPTIBLE
);
2377 spin_lock_irqsave(&s
->lock
, flags
);
2378 count
= s
->midi
.ocnt
;
2379 spin_unlock_irqrestore(&s
->lock
, flags
);
2382 if (signal_pending(current
))
2384 if (file
->f_flags
& O_NONBLOCK
) {
2385 remove_wait_queue(&s
->midi
.owait
, &wait
);
2386 set_current_state(TASK_RUNNING
);
2389 tmo
= (count
* HZ
) / 3100;
2390 if (!schedule_timeout(tmo
? : 1) && tmo
)
2391 DBG(printk(KERN_DEBUG
"es1370: midi timed out??\n");)
2393 remove_wait_queue(&s
->midi
.owait
, &wait
);
2394 set_current_state(TASK_RUNNING
);
2397 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2398 spin_lock_irqsave(&s
->lock
, flags
);
2399 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2400 s
->ctrl
&= ~CTRL_UART_EN
;
2401 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2403 spin_unlock_irqrestore(&s
->lock
, flags
);
2404 wake_up(&s
->open_wait
);
2410 static /*const*/ struct file_operations es1370_midi_fops
= {
2411 llseek
: es1370_llseek
,
2412 read
: es1370_midi_read
,
2413 write
: es1370_midi_write
,
2414 poll
: es1370_midi_poll
,
2415 open
: es1370_midi_open
,
2416 release
: es1370_midi_release
,
2419 /* --------------------------------------------------------------------- */
2421 /* maximum number of devices; only used for command line params */
2424 static int joystick
[NR_DEVICE
] = { 0, };
2425 static int lineout
[NR_DEVICE
] = { 0, };
2426 static int micbias
[NR_DEVICE
] = { 0, };
2428 static unsigned int devindex
= 0;
2430 MODULE_PARM(joystick
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2431 MODULE_PARM_DESC(joystick
, "if 1 enables joystick interface (still need separate driver)");
2432 MODULE_PARM(lineout
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2433 MODULE_PARM_DESC(lineout
, "if 1 the LINE input is converted to LINE out");
2434 MODULE_PARM(micbias
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2435 MODULE_PARM_DESC(micbias
, "sets the +5V bias for an electret microphone");
2437 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2438 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2440 /* --------------------------------------------------------------------- */
2442 static struct initvol
{
2445 } initvol
[] __initdata
= {
2446 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2447 { SOUND_MIXER_WRITE_PCM
, 0x4040 },
2448 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2449 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2450 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2451 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2452 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2453 { SOUND_MIXER_WRITE_LINE3
, 0x4040 },
2454 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2455 { SOUND_MIXER_WRITE_OGAIN
, 0x4040 }
2458 #define RSRCISIOREGION(dev,num) ((dev)->resource[(num)].start != 0 && \
2459 ((dev)->resource[(num)].flags & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
2460 #define RSRCADDRESS(dev,num) ((dev)->resource[(num)].start)
2462 static int __devinit
es1370_probe(struct pci_dev
*pcidev
, const struct pci_device_id
*pciid
)
2464 struct es1370_state
*s
;
2468 if (!RSRCISIOREGION(pcidev
, 0))
2470 if (pcidev
->irq
== 0)
2472 if (!pci_dma_supported(pcidev
, 0xffffffff)) {
2473 printk(KERN_WARNING
"es1370: architecture does not support 32bit PCI busmaster DMA\n");
2476 if (!(s
= kmalloc(sizeof(struct es1370_state
), GFP_KERNEL
))) {
2477 printk(KERN_WARNING
"es1370: out of memory\n");
2480 memset(s
, 0, sizeof(struct es1370_state
));
2481 init_waitqueue_head(&s
->dma_adc
.wait
);
2482 init_waitqueue_head(&s
->dma_dac1
.wait
);
2483 init_waitqueue_head(&s
->dma_dac2
.wait
);
2484 init_waitqueue_head(&s
->open_wait
);
2485 init_waitqueue_head(&s
->midi
.iwait
);
2486 init_waitqueue_head(&s
->midi
.owait
);
2487 init_MUTEX(&s
->open_sem
);
2488 spin_lock_init(&s
->lock
);
2489 s
->magic
= ES1370_MAGIC
;
2491 s
->io
= RSRCADDRESS(pcidev
, 0);
2492 s
->irq
= pcidev
->irq
;
2493 if (!request_region(s
->io
, ES1370_EXTENT
, "es1370")) {
2494 printk(KERN_ERR
"es1370: io ports %#lx-%#lx in use\n", s
->io
, s
->io
+ES1370_EXTENT
-1);
2497 if (pci_enable_device(pcidev
))
2499 if (request_irq(s
->irq
, es1370_interrupt
, SA_SHIRQ
, "es1370", s
)) {
2500 printk(KERN_ERR
"es1370: irq %u in use\n", s
->irq
);
2503 /* initialize codec registers */
2504 /* note: setting CTRL_SERR_DIS is reported to break
2505 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2506 s
->ctrl
= CTRL_CDC_EN
| (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
) | (1 << CTRL_SH_WTSRSEL
);
2507 if (joystick
[devindex
]) {
2508 if (check_region(0x200, JOY_EXTENT
))
2509 printk(KERN_ERR
"es1370: io port 0x200 in use\n");
2511 s
->ctrl
|= CTRL_JYSTK_EN
;
2513 if (lineout
[devindex
])
2514 s
->ctrl
|= CTRL_XCTL0
;
2515 if (micbias
[devindex
])
2516 s
->ctrl
|= CTRL_XCTL1
;
2518 printk(KERN_INFO
"es1370: found adapter at io %#lx irq %u\n"
2519 KERN_INFO
"es1370: features: joystick %s, line %s, mic impedance %s\n",
2520 s
->io
, s
->irq
, (s
->ctrl
& CTRL_JYSTK_EN
) ? "on" : "off",
2521 (s
->ctrl
& CTRL_XCTL0
) ? "out" : "in",
2522 (s
->ctrl
& CTRL_XCTL1
) ? "1" : "0");
2523 /* register devices */
2524 if ((s
->dev_audio
= register_sound_dsp(&es1370_audio_fops
, -1)) < 0)
2526 if ((s
->dev_mixer
= register_sound_mixer(&es1370_mixer_fops
, -1)) < 0)
2528 if ((s
->dev_dac
= register_sound_dsp(&es1370_dac_fops
, -1)) < 0)
2530 if ((s
->dev_midi
= register_sound_midi(&es1370_midi_fops
, -1)) < 0)
2532 /* initialize the chips */
2533 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2534 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2535 /* point phantom write channel to "bugbuf" */
2536 outl((ES1370_REG_PHANTOM_FRAMEADR
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
2537 outl(virt_to_bus(bugbuf
), s
->io
+(ES1370_REG_PHANTOM_FRAMEADR
& 0xff));
2538 outl(0, s
->io
+(ES1370_REG_PHANTOM_FRAMECNT
& 0xff));
2539 pci_set_master(pcidev
); /* enable bus mastering */
2540 wrcodec(s
, 0x16, 3); /* no RST, PD */
2541 wrcodec(s
, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2542 wrcodec(s
, 0x18, 0); /* recording source is mixer */
2543 wrcodec(s
, 0x19, s
->mix
.micpreamp
= 1); /* turn on MIC preamp */
2547 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
;
2548 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2549 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2550 val
= initvol
[i
].vol
;
2551 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2554 /* store it in the driver field */
2555 pcidev
->driver_data
= s
;
2556 pcidev
->dma_mask
= 0xffffffff;
2557 /* put it into driver list */
2558 list_add_tail(&s
->devs
, &devs
);
2559 /* increment devindex */
2560 if (devindex
< NR_DEVICE
-1)
2565 unregister_sound_dsp(s
->dev_dac
);
2567 unregister_sound_mixer(s
->dev_mixer
);
2569 unregister_sound_dsp(s
->dev_audio
);
2571 printk(KERN_ERR
"es1370: cannot register misc device\n");
2572 free_irq(s
->irq
, s
);
2574 release_region(s
->io
, ES1370_EXTENT
);
2576 kfree_s(s
, sizeof(struct es1370_state
));
2580 static void __devinit
es1370_remove(struct pci_dev
*dev
)
2582 struct es1370_state
*s
= (struct es1370_state
*)dev
->driver_data
;
2587 outl(CTRL_SERR_DIS
| (1 << CTRL_SH_WTSRSEL
), s
->io
+ES1370_REG_CONTROL
); /* switch everything off */
2588 outl(0, s
->io
+ES1370_REG_SERIAL_CONTROL
); /* clear serial interrupts */
2590 free_irq(s
->irq
, s
);
2591 release_region(s
->io
, ES1370_EXTENT
);
2592 unregister_sound_dsp(s
->dev_audio
);
2593 unregister_sound_mixer(s
->dev_mixer
);
2594 unregister_sound_dsp(s
->dev_dac
);
2595 unregister_sound_midi(s
->dev_midi
);
2596 kfree_s(s
, sizeof(struct es1370_state
));
2597 dev
->driver_data
= NULL
;
2600 static struct pci_device_id id_table
[] __devinitdata
= {
2601 { PCI_VENDOR_ID_ENSONIQ
, PCI_DEVICE_ID_ENSONIQ_ES1370
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
2605 MODULE_DEVICE_TABLE(pci
, id_table
);
2607 static struct pci_driver es1370_driver
= {
2610 probe
: es1370_probe
,
2611 remove
: es1370_remove
2614 static int __init
init_es1370(void)
2616 if (!pci_present()) /* No PCI bus in this machine! */
2618 printk(KERN_INFO
"es1370: version v0.33 time " __TIME__
" " __DATE__
"\n");
2619 if (!pci_register_driver(&es1370_driver
)) {
2620 pci_unregister_driver(&es1370_driver
);
2627 static void __exit
cleanup_es1370(void)
2629 printk(KERN_INFO
"es1370: unloading\n");
2630 pci_unregister_driver(&es1370_driver
);
2633 module_init(init_es1370
);
2634 module_exit(cleanup_es1370
);
2636 /* --------------------------------------------------------------------- */
2640 /* format is: es1370=[joystick[,lineout[,micbias]]] */
2642 static int __init
es1370_setup(char *str
)
2644 static unsigned __initlocaldata nr_dev
= 0;
2646 if (nr_dev
>= NR_DEVICE
)
2650 ( (get_option(&str
,&joystick
[nr_dev
]) == 2)
2651 && (get_option(&str
,&lineout
[nr_dev
]) == 2)
2652 && get_option(&str
,&micbias
[nr_dev
])
2659 __setup("es1370=", es1370_setup
);