1 /*****************************************************************************/
4 * es1370.c -- Ensoniq ES1370/Asahi Kasei AK4531 audio driver.
6 * Copyright (C) 1998-2001, 2003 Thomas Sailer (t.sailer@alumni.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 * lineout if 1 the LINE jack is used as an output instead of an input.
27 * LINE then contains the unmixed dsp output. This can be used
28 * to make the card a four channel one: use dsp to output two
29 * channels to LINE and dac to output the other two channels to
30 * SPKR. Set the mixer to only output synth to SPKR.
31 * micbias sets the +5V bias to the mic if using an electretmic.
34 * Note: sync mode is not yet supported (i.e. running dsp and dac from the same
38 * /dev/dsp standard /dev/dsp device, (mostly) OSS compatible
39 * /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
40 * /dev/dsp1 additional DAC, like /dev/dsp, but output only,
41 * only 5512, 11025, 22050 and 44100 samples/s,
42 * outputs to mixer "SYNTH" setting
43 * /dev/midi simple MIDI UART interface, no ioctl
45 * NOTE: the card does not have any FM/Wavetable synthesizer, it is supposed
46 * to be done in software. That is what /dev/dac is for. By now (Q2 1998)
47 * there are several MIDI to PCM (WAV) packages, one of them is timidity.
50 * 26.03.1998 0.1 Initial release
51 * 31.03.1998 0.2 Fix bug in GETOSPACE
52 * 04.04.1998 0.3 Make it work (again) under 2.0.33
53 * Fix mixer write operation not returning the actual
55 * 05.04.1998 0.4 First attempt at using the new PCI stuff
56 * 29.04.1998 0.5 Fix hang when ^C is pressed on amp
57 * 07.05.1998 0.6 Don't double lock around stop_*() in *_release()
58 * 10.05.1998 0.7 First stab at a simple midi interface (no bells&whistles)
59 * 14.05.1998 0.8 Don't allow excessive interrupt rates
60 * 08.06.1998 0.9 First release using Alan Cox' soundcore instead of
62 * 05.07.1998 0.10 Fixed the driver to correctly maintin OSS style volume
63 * settings (not sure if this should be standard)
64 * Fixed many references: f_flags should be f_mode
65 * -- Gerald Britton <gbritton@mit.edu>
66 * 03.08.1998 0.11 Now mixer behaviour can basically be selected between
67 * "OSS documented" and "OSS actual" behaviour
68 * Fixed mixer table thanks to Hakan.Lennestal@lu.erisoft.se
69 * On module startup, set DAC2 to 11kSPS instead of 5.5kSPS,
70 * as it produces an annoying ssssh in the lower sampling rate
71 * Do not include modversions.h
72 * 22.08.1998 0.12 Mixer registers actually have 5 instead of 4 bits
73 * pointed out by Itai Nahshon
74 * 31.08.1998 0.13 Fix realplayer problems - dac.count issues
75 * 08.10.1998 0.14 Joystick support fixed
76 * -- Oliver Neukum <c188@org.chemie.uni-muenchen.de>
77 * 10.12.1998 0.15 Fix drain_dac trying to wait on not yet initialized DMA
78 * 16.12.1998 0.16 Don't wake up app until there are fragsize bytes to read/write
79 * 06.01.1999 0.17 remove the silly SA_INTERRUPT flag.
80 * hopefully killed the egcs section type conflict
81 * 12.03.1999 0.18 cinfo.blocks should be reset after GETxPTR ioctl.
82 * reported by Johan Maes <joma@telindus.be>
83 * 22.03.1999 0.19 return EAGAIN instead of EBUSY when O_NONBLOCK
84 * read/write cannot be executed
85 * 07.04.1999 0.20 implemented the following ioctl's: SOUND_PCM_READ_RATE,
86 * SOUND_PCM_READ_CHANNELS, SOUND_PCM_READ_BITS;
87 * Alpha fixes reported by Peter Jones <pjones@redhat.com>
88 * Note: joystick address handling might still be wrong on archs
90 * 10.05.1999 0.21 Added support for an electret mic for SB PCI64
91 * to the Linux kernel sound driver. This mod also straighten
92 * out the question marks around the mic impedance setting
93 * (micz). From Kim.Berts@fisub.mail.abb.com
94 * 11.05.1999 0.22 Implemented the IMIX call to mute recording monitor.
95 * Guenter Geiger <geiger@epy.co.at>
96 * 15.06.1999 0.23 Fix bad allocation bug.
97 * Thanks to Deti Fliegl <fliegl@in.tum.de>
98 * 28.06.1999 0.24 Add pci_set_master
99 * 02.08.1999 0.25 Added workaround for the "phantom write" bug first
100 * documented by Dave Sharpless from Anchor Games
101 * 03.08.1999 0.26 adapt to Linus' new __setup/__initcall
102 * added kernel command line option "es1370=joystick[,lineout[,micbias]]"
103 * removed CONFIG_SOUND_ES1370_JOYPORT_BOOT kludge
104 * 12.08.1999 0.27 module_init/__setup fixes
105 * 19.08.1999 0.28 SOUND_MIXER_IMIX fixes, reported by Gianluca <gialluca@mail.tiscalinet.it>
106 * 31.08.1999 0.29 add spin_lock_init
107 * replaced current->state = x with set_current_state(x)
108 * 03.09.1999 0.30 change read semantics for MIDI to match
109 * OSS more closely; remove possible wakeup race
110 * 28.10.1999 0.31 More waitqueue races fixed
111 * 08.01.2000 0.32 Prevent some ioctl's from returning bad count values on underrun/overrun;
112 * Tim Janik's BSE (Bedevilled Sound Engine) found this
113 * 07.02.2000 0.33 Use pci_alloc_consistent and pci_register_driver
114 * 21.11.2000 0.34 Initialize dma buffers in poll, otherwise poll may return a bogus mask
115 * 12.12.2000 0.35 More dma buffer initializations, patch from
116 * Tjeerd Mulder <tjeerd.mulder@fujitsu-siemens.com>
117 * 07.01.2001 0.36 Timeout change in wrcodec as requested by Frank Klemm <pfk@fuchs.offl.uni-jena.de>
118 * 31.01.2001 0.37 Register/Unregister gameport
119 * Fix SETTRIGGER non OSS API conformity
120 * 03.01.2003 0.38 open_mode fixes from Georg Acher <acher@in.tum.de>
122 * some important things missing in Ensoniq documentation:
124 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
125 * and vary PCLKDIV to obtain zero beat.
128 * seems to be fs = 1411200/(PCLKDIV+2)
130 * should find out when curr_sample_ct is cleared and
131 * where exactly the CCB fetches data
133 * The card uses a 22.5792 MHz crystal.
134 * The LINEIN jack may be converted to an AOUT jack by
135 * setting pin 47 (XCTL0) of the ES1370 to high.
136 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
141 /*****************************************************************************/
143 #include <linux/interrupt.h>
144 #include <linux/module.h>
145 #include <linux/string.h>
146 #include <linux/ioport.h>
147 #include <linux/sched.h>
148 #include <linux/delay.h>
149 #include <linux/sound.h>
150 #include <linux/slab.h>
151 #include <linux/soundcard.h>
152 #include <linux/pci.h>
153 #include <linux/smp_lock.h>
154 #include <linux/init.h>
155 #include <linux/poll.h>
156 #include <linux/spinlock.h>
157 #include <linux/gameport.h>
158 #include <linux/wait.h>
159 #include <linux/dma-mapping.h>
162 #include <asm/page.h>
163 #include <asm/uaccess.h>
165 /* --------------------------------------------------------------------- */
167 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
169 /*#define DBG(x) {x}*/
171 /* --------------------------------------------------------------------- */
173 #ifndef PCI_VENDOR_ID_ENSONIQ
174 #define PCI_VENDOR_ID_ENSONIQ 0x1274
177 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
178 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
181 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
183 #define ES1370_EXTENT 0x40
186 #define ES1370_REG_CONTROL 0x00
187 #define ES1370_REG_STATUS 0x04
188 #define ES1370_REG_UART_DATA 0x08
189 #define ES1370_REG_UART_STATUS 0x09
190 #define ES1370_REG_UART_CONTROL 0x09
191 #define ES1370_REG_UART_TEST 0x0a
192 #define ES1370_REG_MEMPAGE 0x0c
193 #define ES1370_REG_CODEC 0x10
194 #define ES1370_REG_SERIAL_CONTROL 0x20
195 #define ES1370_REG_DAC1_SCOUNT 0x24
196 #define ES1370_REG_DAC2_SCOUNT 0x28
197 #define ES1370_REG_ADC_SCOUNT 0x2c
199 #define ES1370_REG_DAC1_FRAMEADR 0xc30
200 #define ES1370_REG_DAC1_FRAMECNT 0xc34
201 #define ES1370_REG_DAC2_FRAMEADR 0xc38
202 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
203 #define ES1370_REG_ADC_FRAMEADR 0xd30
204 #define ES1370_REG_ADC_FRAMECNT 0xd34
205 #define ES1370_REG_PHANTOM_FRAMEADR 0xd38
206 #define ES1370_REG_PHANTOM_FRAMECNT 0xd3c
208 #define ES1370_FMT_U8_MONO 0
209 #define ES1370_FMT_U8_STEREO 1
210 #define ES1370_FMT_S16_MONO 2
211 #define ES1370_FMT_S16_STEREO 3
212 #define ES1370_FMT_STEREO 1
213 #define ES1370_FMT_S16 2
214 #define ES1370_FMT_MASK 3
216 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
217 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
219 static const unsigned dac1_samplerate
[] = { 5512, 11025, 22050, 44100 };
221 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
222 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
224 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
225 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
226 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
227 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
228 #define CTRL_SH_PCLKDIV 16
229 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
230 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
231 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
232 #define CTRL_SH_WTSRSEL 12
233 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
234 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
235 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
236 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
237 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
238 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
239 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
240 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
241 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
242 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
243 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
244 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
246 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
247 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
248 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
249 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
250 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
252 #define STAT_MCCB 0x00000010 /* CCB int pending */
253 #define STAT_UART 0x00000008 /* UART int pending */
254 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
255 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
256 #define STAT_ADC 0x00000001 /* ADC int pending */
258 #define USTAT_RXINT 0x80 /* UART rx int pending */
259 #define USTAT_TXINT 0x04 /* UART tx int pending */
260 #define USTAT_TXRDY 0x02 /* UART tx ready */
261 #define USTAT_RXRDY 0x01 /* UART rx ready */
263 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
264 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
265 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
266 #define UCTRL_CNTRL 0x03 /* control field */
267 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
269 #define SCTRL_P2ENDINC 0x00380000 /* */
270 #define SCTRL_SH_P2ENDINC 19
271 #define SCTRL_P2STINC 0x00070000 /* */
272 #define SCTRL_SH_P2STINC 16
273 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
274 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
275 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
276 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
277 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
278 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
279 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
280 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
281 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
282 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
283 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
284 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
285 #define SCTRL_R1FMT 0x00000030 /* format mask */
286 #define SCTRL_SH_R1FMT 4
287 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
288 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
289 #define SCTRL_P2FMT 0x0000000c /* format mask */
290 #define SCTRL_SH_P2FMT 2
291 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
292 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
293 #define SCTRL_P1FMT 0x00000003 /* format mask */
294 #define SCTRL_SH_P1FMT 0
298 #define FMODE_DAC 4 /* slight misuse of mode_t */
300 /* MIDI buffer sizes */
302 #define MIDIINBUF 256
303 #define MIDIOUTBUF 256
305 #define FMODE_MIDI_SHIFT 3
306 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
307 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
309 /* --------------------------------------------------------------------- */
311 struct es1370_state
{
315 /* list of es1370 devices */
316 struct list_head devs
;
318 /* the corresponding pci_dev structure */
321 /* soundcore stuff */
327 /* hardware resources */
328 unsigned long io
; /* long for SPARC */
331 /* mixer registers; there is no HW readback */
333 unsigned short vol
[10];
336 unsigned short micpreamp
;
345 struct semaphore open_sem
;
347 wait_queue_head_t open_wait
;
355 unsigned hwptr
, swptr
;
356 unsigned total_bytes
;
358 unsigned error
; /* over/underrun */
359 wait_queue_head_t wait
;
360 /* redundant, but makes calculations easier */
363 unsigned fragsamples
;
367 unsigned endcleared
:1;
369 unsigned ossfragshift
;
371 unsigned subdivision
;
372 } dma_dac1
, dma_dac2
, dma_adc
;
374 /* The following buffer is used to point the phantom write channel to. */
375 unsigned char *bugbuf_cpu
;
376 dma_addr_t bugbuf_dma
;
380 unsigned ird
, iwr
, icnt
;
381 unsigned ord
, owr
, ocnt
;
382 wait_queue_head_t iwait
;
383 wait_queue_head_t owait
;
384 unsigned char ibuf
[MIDIINBUF
];
385 unsigned char obuf
[MIDIOUTBUF
];
388 struct gameport
*gameport
;
389 struct semaphore sem
;
392 /* --------------------------------------------------------------------- */
394 static LIST_HEAD(devs
);
396 /* --------------------------------------------------------------------- */
398 static inline unsigned ld2(unsigned int x
)
423 /* --------------------------------------------------------------------- */
425 static void wrcodec(struct es1370_state
*s
, unsigned char idx
, unsigned char data
)
427 unsigned long tmo
= jiffies
+ HZ
/10, j
;
431 if (!(inl(s
->io
+ES1370_REG_STATUS
) & STAT_CSTAT
)) {
432 outw((((unsigned short)idx
)<<8)|data
, s
->io
+ES1370_REG_CODEC
);
436 } while ((signed)(tmo
-j
) > 0);
437 printk(KERN_ERR
"es1370: write to codec register timeout\n");
440 /* --------------------------------------------------------------------- */
442 static inline void stop_adc(struct es1370_state
*s
)
446 spin_lock_irqsave(&s
->lock
, flags
);
447 s
->ctrl
&= ~CTRL_ADC_EN
;
448 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
449 spin_unlock_irqrestore(&s
->lock
, flags
);
452 static inline void stop_dac1(struct es1370_state
*s
)
456 spin_lock_irqsave(&s
->lock
, flags
);
457 s
->ctrl
&= ~CTRL_DAC1_EN
;
458 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
459 spin_unlock_irqrestore(&s
->lock
, flags
);
462 static inline void stop_dac2(struct es1370_state
*s
)
466 spin_lock_irqsave(&s
->lock
, flags
);
467 s
->ctrl
&= ~CTRL_DAC2_EN
;
468 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
469 spin_unlock_irqrestore(&s
->lock
, flags
);
472 static void start_dac1(struct es1370_state
*s
)
475 unsigned fragremain
, fshift
;
477 spin_lock_irqsave(&s
->lock
, flags
);
478 if (!(s
->ctrl
& CTRL_DAC1_EN
) && (s
->dma_dac1
.mapped
|| s
->dma_dac1
.count
> 0)
479 && s
->dma_dac1
.ready
) {
480 s
->ctrl
|= CTRL_DAC1_EN
;
481 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P1LOOPSEL
| SCTRL_P1PAUSE
| SCTRL_P1SCTRLD
)) | SCTRL_P1INTEN
;
482 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
483 fragremain
= ((- s
->dma_dac1
.hwptr
) & (s
->dma_dac1
.fragsize
-1));
484 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
485 if (fragremain
< 2*fshift
)
486 fragremain
= s
->dma_dac1
.fragsize
;
487 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
488 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
489 outl((s
->dma_dac1
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
491 spin_unlock_irqrestore(&s
->lock
, flags
);
494 static void start_dac2(struct es1370_state
*s
)
497 unsigned fragremain
, fshift
;
499 spin_lock_irqsave(&s
->lock
, flags
);
500 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (s
->dma_dac2
.mapped
|| s
->dma_dac2
.count
> 0)
501 && s
->dma_dac2
.ready
) {
502 s
->ctrl
|= CTRL_DAC2_EN
;
503 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P2LOOPSEL
| SCTRL_P2PAUSE
| SCTRL_P2DACSEN
|
504 SCTRL_P2ENDINC
| SCTRL_P2STINC
)) | SCTRL_P2INTEN
|
505 (((s
->sctrl
& SCTRL_P2FMT
) ? 2 : 1) << SCTRL_SH_P2ENDINC
) |
506 (0 << SCTRL_SH_P2STINC
);
507 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
508 fragremain
= ((- s
->dma_dac2
.hwptr
) & (s
->dma_dac2
.fragsize
-1));
509 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
510 if (fragremain
< 2*fshift
)
511 fragremain
= s
->dma_dac2
.fragsize
;
512 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
513 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
514 outl((s
->dma_dac2
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
516 spin_unlock_irqrestore(&s
->lock
, flags
);
519 static void start_adc(struct es1370_state
*s
)
522 unsigned fragremain
, fshift
;
524 spin_lock_irqsave(&s
->lock
, flags
);
525 if (!(s
->ctrl
& CTRL_ADC_EN
) && (s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
526 && s
->dma_adc
.ready
) {
527 s
->ctrl
|= CTRL_ADC_EN
;
528 s
->sctrl
= (s
->sctrl
& ~SCTRL_R1LOOPSEL
) | SCTRL_R1INTEN
;
529 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
530 fragremain
= ((- s
->dma_adc
.hwptr
) & (s
->dma_adc
.fragsize
-1));
531 fshift
= sample_shift
[(s
->sctrl
& SCTRL_R1FMT
) >> SCTRL_SH_R1FMT
];
532 if (fragremain
< 2*fshift
)
533 fragremain
= s
->dma_adc
.fragsize
;
534 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
535 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
536 outl((s
->dma_adc
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
538 spin_unlock_irqrestore(&s
->lock
, flags
);
541 /* --------------------------------------------------------------------- */
543 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
544 #define DMABUF_MINORDER 1
546 static inline void dealloc_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
)
548 struct page
*page
, *pend
;
551 /* undo marking the pages as reserved */
552 pend
= virt_to_page(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
553 for (page
= virt_to_page(db
->rawbuf
); page
<= pend
; page
++)
554 ClearPageReserved(page
);
555 pci_free_consistent(s
->dev
, PAGE_SIZE
<< db
->buforder
, db
->rawbuf
, db
->dmaaddr
);
558 db
->mapped
= db
->ready
= 0;
561 static int prog_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
, unsigned rate
, unsigned fmt
, unsigned reg
)
566 struct page
*page
, *pend
;
568 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
570 db
->ready
= db
->mapped
= 0;
571 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
572 if ((db
->rawbuf
= pci_alloc_consistent(s
->dev
, PAGE_SIZE
<< order
, &db
->dmaaddr
)))
576 db
->buforder
= order
;
577 /* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
578 pend
= virt_to_page(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
579 for (page
= virt_to_page(db
->rawbuf
); page
<= pend
; page
++)
580 SetPageReserved(page
);
582 fmt
&= ES1370_FMT_MASK
;
583 bytepersec
= rate
<< sample_shift
[fmt
];
584 bufs
= PAGE_SIZE
<< db
->buforder
;
585 if (db
->ossfragshift
) {
586 if ((1000 << db
->ossfragshift
) < bytepersec
)
587 db
->fragshift
= ld2(bytepersec
/1000);
589 db
->fragshift
= db
->ossfragshift
;
591 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
592 if (db
->fragshift
< 3)
595 db
->numfrag
= bufs
>> db
->fragshift
;
596 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
598 db
->numfrag
= bufs
>> db
->fragshift
;
600 db
->fragsize
= 1 << db
->fragshift
;
601 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
602 db
->numfrag
= db
->ossmaxfrags
;
603 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
604 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
605 memset(db
->rawbuf
, (fmt
& ES1370_FMT_S16
) ? 0 : 0x80, db
->dmasize
);
606 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
607 outl(db
->dmaaddr
, s
->io
+(reg
& 0xff));
608 outl((db
->dmasize
>> 2)-1, s
->io
+((reg
+ 4) & 0xff));
614 static inline int prog_dmabuf_adc(struct es1370_state
*s
)
617 return prog_dmabuf(s
, &s
->dma_adc
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
618 (s
->sctrl
>> SCTRL_SH_R1FMT
) & ES1370_FMT_MASK
, ES1370_REG_ADC_FRAMEADR
);
621 static inline int prog_dmabuf_dac2(struct es1370_state
*s
)
624 return prog_dmabuf(s
, &s
->dma_dac2
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
625 (s
->sctrl
>> SCTRL_SH_P2FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC2_FRAMEADR
);
628 static inline int prog_dmabuf_dac1(struct es1370_state
*s
)
631 return prog_dmabuf(s
, &s
->dma_dac1
, dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
],
632 (s
->sctrl
>> SCTRL_SH_P1FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC1_FRAMEADR
);
635 static inline unsigned get_hwptr(struct es1370_state
*s
, struct dmabuf
*db
, unsigned reg
)
637 unsigned hwptr
, diff
;
639 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
640 hwptr
= (inl(s
->io
+(reg
& 0xff)) >> 14) & 0x3fffc;
641 diff
= (db
->dmasize
+ hwptr
- db
->hwptr
) % db
->dmasize
;
646 static inline void clear_advance(void *buf
, unsigned bsize
, unsigned bptr
, unsigned len
, unsigned char c
)
648 if (bptr
+ len
> bsize
) {
649 unsigned x
= bsize
- bptr
;
650 memset(((char *)buf
) + bptr
, c
, x
);
654 memset(((char *)buf
) + bptr
, c
, len
);
657 /* call with spinlock held! */
658 static void es1370_update_ptr(struct es1370_state
*s
)
662 /* update ADC pointer */
663 if (s
->ctrl
& CTRL_ADC_EN
) {
664 diff
= get_hwptr(s
, &s
->dma_adc
, ES1370_REG_ADC_FRAMECNT
);
665 s
->dma_adc
.total_bytes
+= diff
;
666 s
->dma_adc
.count
+= diff
;
667 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
668 wake_up(&s
->dma_adc
.wait
);
669 if (!s
->dma_adc
.mapped
) {
670 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
671 s
->ctrl
&= ~CTRL_ADC_EN
;
672 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
677 /* update DAC1 pointer */
678 if (s
->ctrl
& CTRL_DAC1_EN
) {
679 diff
= get_hwptr(s
, &s
->dma_dac1
, ES1370_REG_DAC1_FRAMECNT
);
680 s
->dma_dac1
.total_bytes
+= diff
;
681 if (s
->dma_dac1
.mapped
) {
682 s
->dma_dac1
.count
+= diff
;
683 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
684 wake_up(&s
->dma_dac1
.wait
);
686 s
->dma_dac1
.count
-= diff
;
687 if (s
->dma_dac1
.count
<= 0) {
688 s
->ctrl
&= ~CTRL_DAC1_EN
;
689 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
691 } else if (s
->dma_dac1
.count
<= (signed)s
->dma_dac1
.fragsize
&& !s
->dma_dac1
.endcleared
) {
692 clear_advance(s
->dma_dac1
.rawbuf
, s
->dma_dac1
.dmasize
, s
->dma_dac1
.swptr
,
693 s
->dma_dac1
.fragsize
, (s
->sctrl
& SCTRL_P1SEB
) ? 0 : 0x80);
694 s
->dma_dac1
.endcleared
= 1;
696 if (s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
<= (signed)s
->dma_dac1
.dmasize
)
697 wake_up(&s
->dma_dac1
.wait
);
700 /* update DAC2 pointer */
701 if (s
->ctrl
& CTRL_DAC2_EN
) {
702 diff
= get_hwptr(s
, &s
->dma_dac2
, ES1370_REG_DAC2_FRAMECNT
);
703 s
->dma_dac2
.total_bytes
+= diff
;
704 if (s
->dma_dac2
.mapped
) {
705 s
->dma_dac2
.count
+= diff
;
706 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
707 wake_up(&s
->dma_dac2
.wait
);
709 s
->dma_dac2
.count
-= diff
;
710 if (s
->dma_dac2
.count
<= 0) {
711 s
->ctrl
&= ~CTRL_DAC2_EN
;
712 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
714 } else if (s
->dma_dac2
.count
<= (signed)s
->dma_dac2
.fragsize
&& !s
->dma_dac2
.endcleared
) {
715 clear_advance(s
->dma_dac2
.rawbuf
, s
->dma_dac2
.dmasize
, s
->dma_dac2
.swptr
,
716 s
->dma_dac2
.fragsize
, (s
->sctrl
& SCTRL_P2SEB
) ? 0 : 0x80);
717 s
->dma_dac2
.endcleared
= 1;
719 if (s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
<= (signed)s
->dma_dac2
.dmasize
)
720 wake_up(&s
->dma_dac2
.wait
);
725 /* hold spinlock for the following! */
726 static void es1370_handle_midi(struct es1370_state
*s
)
731 if (!(s
->ctrl
& CTRL_UART_EN
))
734 while (inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_RXRDY
) {
735 ch
= inb(s
->io
+ES1370_REG_UART_DATA
);
736 if (s
->midi
.icnt
< MIDIINBUF
) {
737 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
738 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
744 wake_up(&s
->midi
.iwait
);
746 while ((inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_TXRDY
) && s
->midi
.ocnt
> 0) {
747 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->io
+ES1370_REG_UART_DATA
);
748 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
750 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
754 wake_up(&s
->midi
.owait
);
755 outb((s
->midi
.ocnt
> 0) ? UCTRL_RXINTEN
| UCTRL_ENA_TXINT
: UCTRL_RXINTEN
, s
->io
+ES1370_REG_UART_CONTROL
);
758 static irqreturn_t
es1370_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
760 struct es1370_state
*s
= (struct es1370_state
*)dev_id
;
761 unsigned int intsrc
, sctl
;
763 /* fastpath out, to ease interrupt sharing */
764 intsrc
= inl(s
->io
+ES1370_REG_STATUS
);
765 if (!(intsrc
& 0x80000000))
768 /* clear audio interrupts first */
770 if (intsrc
& STAT_ADC
)
771 sctl
&= ~SCTRL_R1INTEN
;
772 if (intsrc
& STAT_DAC1
)
773 sctl
&= ~SCTRL_P1INTEN
;
774 if (intsrc
& STAT_DAC2
)
775 sctl
&= ~SCTRL_P2INTEN
;
776 outl(sctl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
777 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
778 es1370_update_ptr(s
);
779 es1370_handle_midi(s
);
780 spin_unlock(&s
->lock
);
784 /* --------------------------------------------------------------------- */
786 static const char invalid_magic
[] = KERN_CRIT
"es1370: invalid magic value\n";
788 #define VALIDATE_STATE(s) \
790 if (!(s) || (s)->magic != ES1370_MAGIC) { \
791 printk(invalid_magic); \
796 /* --------------------------------------------------------------------- */
798 static const struct {
805 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
806 [SOUND_MIXER_VOLUME
] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
807 [SOUND_MIXER_PCM
] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
808 [SOUND_MIXER_SYNTH
] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
809 [SOUND_MIXER_CD
] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
810 [SOUND_MIXER_LINE
] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
811 [SOUND_MIXER_LINE1
] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
812 [SOUND_MIXER_LINE2
] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
813 [SOUND_MIXER_LINE3
] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
814 [SOUND_MIXER_MIC
] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
815 [SOUND_MIXER_OGAIN
] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
818 static void set_recsrc(struct es1370_state
*s
, unsigned int val
)
822 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
823 if (!(val
& (1 << i
)))
825 if (!mixtable
[i
].recmask
) {
829 j
|= mixtable
[i
].recmask
;
832 wrcodec(s
, 0x12, j
& 0xd5);
833 wrcodec(s
, 0x13, j
& 0xaa);
834 wrcodec(s
, 0x14, (j
>> 8) & 0x17);
835 wrcodec(s
, 0x15, (j
>> 8) & 0x0f);
836 i
= (j
& 0x37f) | ((j
<< 1) & 0x3000) | 0xc60;
838 i
&= 0xff60; /* mute record and line monitor */
841 wrcodec(s
, 0x11, i
>> 8);
844 static int mixer_ioctl(struct es1370_state
*s
, unsigned int cmd
, unsigned long arg
)
848 unsigned char l
, r
, rl
, rr
;
849 int __user
*p
= (int __user
*)arg
;
852 if (cmd
== SOUND_MIXER_PRIVATE1
) {
853 /* enable/disable/query mixer preamp */
854 if (get_user(val
, p
))
857 s
->mix
.micpreamp
= !!val
;
858 wrcodec(s
, 0x19, s
->mix
.micpreamp
);
860 return put_user(s
->mix
.micpreamp
, p
);
862 if (cmd
== SOUND_MIXER_PRIVATE2
) {
863 /* enable/disable/query use of linein as second lineout */
864 if (get_user(val
, p
))
867 spin_lock_irqsave(&s
->lock
, flags
);
869 s
->ctrl
|= CTRL_XCTL0
;
871 s
->ctrl
&= ~CTRL_XCTL0
;
872 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
873 spin_unlock_irqrestore(&s
->lock
, flags
);
875 return put_user((s
->ctrl
& CTRL_XCTL0
) ? 1 : 0, p
);
877 if (cmd
== SOUND_MIXER_PRIVATE3
) {
878 /* enable/disable/query microphone impedance setting */
879 if (get_user(val
, p
))
882 spin_lock_irqsave(&s
->lock
, flags
);
884 s
->ctrl
|= CTRL_XCTL1
;
886 s
->ctrl
&= ~CTRL_XCTL1
;
887 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
888 spin_unlock_irqrestore(&s
->lock
, flags
);
890 return put_user((s
->ctrl
& CTRL_XCTL1
) ? 1 : 0, p
);
892 if (cmd
== SOUND_MIXER_INFO
) {
894 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
895 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
896 info
.modify_counter
= s
->mix
.modcnt
;
897 if (copy_to_user((void __user
*)arg
, &info
, sizeof(info
)))
901 if (cmd
== SOUND_OLD_MIXER_INFO
) {
902 _old_mixer_info info
;
903 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
904 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
905 if (copy_to_user((void __user
*)arg
, &info
, sizeof(info
)))
909 if (cmd
== OSS_GETVERSION
)
910 return put_user(SOUND_VERSION
, p
);
911 if (_IOC_TYPE(cmd
) != 'M' || _SIOC_SIZE(cmd
) != sizeof(int))
913 if (_SIOC_DIR(cmd
) == _SIOC_READ
) {
914 switch (_IOC_NR(cmd
)) {
915 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
916 return put_user(s
->mix
.recsrc
, p
);
918 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
919 val
= SOUND_MASK_IMIX
;
920 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
921 if (mixtable
[i
].avail
)
923 return put_user(val
, p
);
925 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
926 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
927 if (mixtable
[i
].recmask
)
929 return put_user(val
, p
);
931 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
932 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
933 if (mixtable
[i
].stereo
)
935 return put_user(val
, p
);
937 case SOUND_MIXER_CAPS
:
938 return put_user(0, p
);
940 case SOUND_MIXER_IMIX
:
941 return put_user(s
->mix
.imix
, p
);
945 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
947 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], p
);
950 if (_SIOC_DIR(cmd
) != (_SIOC_READ
|_SIOC_WRITE
))
953 switch (_IOC_NR(cmd
)) {
955 case SOUND_MIXER_IMIX
:
956 if (get_user(s
->mix
.imix
, p
))
958 set_recsrc(s
, s
->mix
.recsrc
);
961 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
962 if (get_user(val
, p
))
969 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
971 if (get_user(val
, p
))
976 if (mixtable
[i
].stereo
) {
977 r
= (val
>> 8) & 0xff;
984 rl
= 31 - ((l
- 7) / 3);
985 l
= (31 - rl
) * 3 + 7;
991 rr
= 31 - ((r
- 7) / 3);
992 r
= (31 - rr
) * 3 + 7;
994 wrcodec(s
, mixtable
[i
].right
, rr
);
996 if (mixtable
[i
].left
== 15) {
1001 rl
= 7 - ((l
- 2) / 14);
1002 r
= l
= (7 - rl
) * 14 + 2;
1009 rl
= 31 - ((l
- 7) / 3);
1010 r
= l
= (31 - rl
) * 3 + 7;
1014 wrcodec(s
, mixtable
[i
].left
, rl
);
1015 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1016 s
->mix
.vol
[mixtable
[i
].volidx
] = ((unsigned int)r
<< 8) | l
;
1018 s
->mix
.vol
[mixtable
[i
].volidx
] = val
;
1020 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], p
);
1024 /* --------------------------------------------------------------------- */
1026 static int es1370_open_mixdev(struct inode
*inode
, struct file
*file
)
1028 unsigned int minor
= iminor(inode
);
1029 struct list_head
*list
;
1030 struct es1370_state
*s
;
1032 for (list
= devs
.next
; ; list
= list
->next
) {
1035 s
= list_entry(list
, struct es1370_state
, devs
);
1036 if (s
->dev_mixer
== minor
)
1040 file
->private_data
= s
;
1041 return nonseekable_open(inode
, file
);
1044 static int es1370_release_mixdev(struct inode
*inode
, struct file
*file
)
1046 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1052 static int es1370_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1054 return mixer_ioctl((struct es1370_state
*)file
->private_data
, cmd
, arg
);
1057 static /*const*/ struct file_operations es1370_mixer_fops
= {
1058 .owner
= THIS_MODULE
,
1059 .llseek
= no_llseek
,
1060 .ioctl
= es1370_ioctl_mixdev
,
1061 .open
= es1370_open_mixdev
,
1062 .release
= es1370_release_mixdev
,
1065 /* --------------------------------------------------------------------- */
1067 static int drain_dac1(struct es1370_state
*s
, int nonblock
)
1069 DECLARE_WAITQUEUE(wait
, current
);
1070 unsigned long flags
;
1073 if (s
->dma_dac1
.mapped
|| !s
->dma_dac1
.ready
)
1075 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1077 __set_current_state(TASK_INTERRUPTIBLE
);
1078 spin_lock_irqsave(&s
->lock
, flags
);
1079 count
= s
->dma_dac1
.count
;
1080 spin_unlock_irqrestore(&s
->lock
, flags
);
1083 if (signal_pending(current
))
1086 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1087 set_current_state(TASK_RUNNING
);
1090 tmo
= 3 * HZ
* (count
+ s
->dma_dac1
.fragsize
) / 2
1091 / dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
];
1092 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
1093 if (!schedule_timeout(tmo
+ 1))
1094 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1096 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1097 set_current_state(TASK_RUNNING
);
1098 if (signal_pending(current
))
1099 return -ERESTARTSYS
;
1103 static int drain_dac2(struct es1370_state
*s
, int nonblock
)
1105 DECLARE_WAITQUEUE(wait
, current
);
1106 unsigned long flags
;
1109 if (s
->dma_dac2
.mapped
|| !s
->dma_dac2
.ready
)
1111 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1113 __set_current_state(TASK_INTERRUPTIBLE
);
1114 spin_lock_irqsave(&s
->lock
, flags
);
1115 count
= s
->dma_dac2
.count
;
1116 spin_unlock_irqrestore(&s
->lock
, flags
);
1119 if (signal_pending(current
))
1122 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1123 set_current_state(TASK_RUNNING
);
1126 tmo
= 3 * HZ
* (count
+ s
->dma_dac2
.fragsize
) / 2
1127 / DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
);
1128 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
1129 if (!schedule_timeout(tmo
+ 1))
1130 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1132 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1133 set_current_state(TASK_RUNNING
);
1134 if (signal_pending(current
))
1135 return -ERESTARTSYS
;
1139 /* --------------------------------------------------------------------- */
1141 static ssize_t
es1370_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
1143 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1144 DECLARE_WAITQUEUE(wait
, current
);
1146 unsigned long flags
;
1151 if (s
->dma_adc
.mapped
)
1153 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1156 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1159 add_wait_queue(&s
->dma_adc
.wait
, &wait
);
1161 spin_lock_irqsave(&s
->lock
, flags
);
1162 swptr
= s
->dma_adc
.swptr
;
1163 cnt
= s
->dma_adc
.dmasize
-swptr
;
1164 if (s
->dma_adc
.count
< cnt
)
1165 cnt
= s
->dma_adc
.count
;
1167 __set_current_state(TASK_INTERRUPTIBLE
);
1168 spin_unlock_irqrestore(&s
->lock
, flags
);
1172 if (s
->dma_adc
.enabled
)
1174 if (file
->f_flags
& O_NONBLOCK
) {
1181 if (signal_pending(current
)) {
1187 if (s
->dma_adc
.mapped
)
1194 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
)) {
1199 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1200 spin_lock_irqsave(&s
->lock
, flags
);
1201 s
->dma_adc
.swptr
= swptr
;
1202 s
->dma_adc
.count
-= cnt
;
1203 spin_unlock_irqrestore(&s
->lock
, flags
);
1207 if (s
->dma_adc
.enabled
)
1212 remove_wait_queue(&s
->dma_adc
.wait
, &wait
);
1213 set_current_state(TASK_RUNNING
);
1217 static ssize_t
es1370_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
1219 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1220 DECLARE_WAITQUEUE(wait
, current
);
1222 unsigned long flags
;
1227 if (s
->dma_dac2
.mapped
)
1229 if (!access_ok(VERIFY_READ
, buffer
, count
))
1232 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1235 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1237 spin_lock_irqsave(&s
->lock
, flags
);
1238 if (s
->dma_dac2
.count
< 0) {
1239 s
->dma_dac2
.count
= 0;
1240 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
;
1242 swptr
= s
->dma_dac2
.swptr
;
1243 cnt
= s
->dma_dac2
.dmasize
-swptr
;
1244 if (s
->dma_dac2
.count
+ cnt
> s
->dma_dac2
.dmasize
)
1245 cnt
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1247 __set_current_state(TASK_INTERRUPTIBLE
);
1248 spin_unlock_irqrestore(&s
->lock
, flags
);
1252 if (s
->dma_dac2
.enabled
)
1254 if (file
->f_flags
& O_NONBLOCK
) {
1261 if (signal_pending(current
)) {
1267 if (s
->dma_dac2
.mapped
)
1274 if (copy_from_user(s
->dma_dac2
.rawbuf
+ swptr
, buffer
, cnt
)) {
1279 swptr
= (swptr
+ cnt
) % s
->dma_dac2
.dmasize
;
1280 spin_lock_irqsave(&s
->lock
, flags
);
1281 s
->dma_dac2
.swptr
= swptr
;
1282 s
->dma_dac2
.count
+= cnt
;
1283 s
->dma_dac2
.endcleared
= 0;
1284 spin_unlock_irqrestore(&s
->lock
, flags
);
1288 if (s
->dma_dac2
.enabled
)
1293 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1294 set_current_state(TASK_RUNNING
);
1298 /* No kernel lock - we have our own spinlock */
1299 static unsigned int es1370_poll(struct file
*file
, struct poll_table_struct
*wait
)
1301 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1302 unsigned long flags
;
1303 unsigned int mask
= 0;
1306 if (file
->f_mode
& FMODE_WRITE
) {
1307 if (!s
->dma_dac2
.ready
&& prog_dmabuf_dac2(s
))
1309 poll_wait(file
, &s
->dma_dac2
.wait
, wait
);
1311 if (file
->f_mode
& FMODE_READ
) {
1312 if (!s
->dma_adc
.ready
&& prog_dmabuf_adc(s
))
1314 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1316 spin_lock_irqsave(&s
->lock
, flags
);
1317 es1370_update_ptr(s
);
1318 if (file
->f_mode
& FMODE_READ
) {
1319 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1320 mask
|= POLLIN
| POLLRDNORM
;
1322 if (file
->f_mode
& FMODE_WRITE
) {
1323 if (s
->dma_dac2
.mapped
) {
1324 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
1325 mask
|= POLLOUT
| POLLWRNORM
;
1327 if ((signed)s
->dma_dac2
.dmasize
>= s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
)
1328 mask
|= POLLOUT
| POLLWRNORM
;
1331 spin_unlock_irqrestore(&s
->lock
, flags
);
1335 static int es1370_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1337 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1345 if (vma
->vm_flags
& VM_WRITE
) {
1346 if ((ret
= prog_dmabuf_dac2(s
)) != 0) {
1350 } else if (vma
->vm_flags
& VM_READ
) {
1351 if ((ret
= prog_dmabuf_adc(s
)) != 0) {
1359 if (vma
->vm_pgoff
!= 0) {
1363 size
= vma
->vm_end
- vma
->vm_start
;
1364 if (size
> (PAGE_SIZE
<< db
->buforder
)) {
1368 if (remap_pfn_range(vma
, vma
->vm_start
,
1369 virt_to_phys(db
->rawbuf
) >> PAGE_SHIFT
,
1370 size
, vma
->vm_page_prot
)) {
1381 static int es1370_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1383 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1384 unsigned long flags
;
1385 audio_buf_info abinfo
;
1388 int val
, mapped
, ret
;
1389 void __user
*argp
= (void __user
*)arg
;
1390 int __user
*p
= argp
;
1393 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac2
.mapped
) ||
1394 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1396 case OSS_GETVERSION
:
1397 return put_user(SOUND_VERSION
, p
);
1399 case SNDCTL_DSP_SYNC
:
1400 if (file
->f_mode
& FMODE_WRITE
)
1401 return drain_dac2(s
, 0/*file->f_flags & O_NONBLOCK*/);
1404 case SNDCTL_DSP_SETDUPLEX
:
1407 case SNDCTL_DSP_GETCAPS
:
1408 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, p
);
1410 case SNDCTL_DSP_RESET
:
1411 if (file
->f_mode
& FMODE_WRITE
) {
1413 synchronize_irq(s
->irq
);
1414 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
= s
->dma_dac2
.count
= s
->dma_dac2
.total_bytes
= 0;
1416 if (file
->f_mode
& FMODE_READ
) {
1418 synchronize_irq(s
->irq
);
1419 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1423 case SNDCTL_DSP_SPEED
:
1424 if (get_user(val
, p
))
1427 if (s
->open_mode
& (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
))
1435 s
->dma_adc
.ready
= s
->dma_dac2
.ready
= 0;
1436 spin_lock_irqsave(&s
->lock
, flags
);
1437 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(val
) << CTRL_SH_PCLKDIV
);
1438 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1439 spin_unlock_irqrestore(&s
->lock
, flags
);
1441 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), p
);
1443 case SNDCTL_DSP_STEREO
:
1444 if (get_user(val
, p
))
1446 if (file
->f_mode
& FMODE_READ
) {
1448 s
->dma_adc
.ready
= 0;
1449 spin_lock_irqsave(&s
->lock
, flags
);
1451 s
->sctrl
|= SCTRL_R1SMB
;
1453 s
->sctrl
&= ~SCTRL_R1SMB
;
1454 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1455 spin_unlock_irqrestore(&s
->lock
, flags
);
1457 if (file
->f_mode
& FMODE_WRITE
) {
1459 s
->dma_dac2
.ready
= 0;
1460 spin_lock_irqsave(&s
->lock
, flags
);
1462 s
->sctrl
|= SCTRL_P2SMB
;
1464 s
->sctrl
&= ~SCTRL_P2SMB
;
1465 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1466 spin_unlock_irqrestore(&s
->lock
, flags
);
1470 case SNDCTL_DSP_CHANNELS
:
1471 if (get_user(val
, p
))
1474 if (file
->f_mode
& FMODE_READ
) {
1476 s
->dma_adc
.ready
= 0;
1477 spin_lock_irqsave(&s
->lock
, flags
);
1479 s
->sctrl
|= SCTRL_R1SMB
;
1481 s
->sctrl
&= ~SCTRL_R1SMB
;
1482 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1483 spin_unlock_irqrestore(&s
->lock
, flags
);
1485 if (file
->f_mode
& FMODE_WRITE
) {
1487 s
->dma_dac2
.ready
= 0;
1488 spin_lock_irqsave(&s
->lock
, flags
);
1490 s
->sctrl
|= SCTRL_P2SMB
;
1492 s
->sctrl
&= ~SCTRL_P2SMB
;
1493 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1494 spin_unlock_irqrestore(&s
->lock
, flags
);
1497 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ? 2 : 1, p
);
1499 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1500 return put_user(AFMT_S16_LE
|AFMT_U8
, p
);
1502 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1503 if (get_user(val
, p
))
1505 if (val
!= AFMT_QUERY
) {
1506 if (file
->f_mode
& FMODE_READ
) {
1508 s
->dma_adc
.ready
= 0;
1509 spin_lock_irqsave(&s
->lock
, flags
);
1510 if (val
== AFMT_S16_LE
)
1511 s
->sctrl
|= SCTRL_R1SEB
;
1513 s
->sctrl
&= ~SCTRL_R1SEB
;
1514 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1515 spin_unlock_irqrestore(&s
->lock
, flags
);
1517 if (file
->f_mode
& FMODE_WRITE
) {
1519 s
->dma_dac2
.ready
= 0;
1520 spin_lock_irqsave(&s
->lock
, flags
);
1521 if (val
== AFMT_S16_LE
)
1522 s
->sctrl
|= SCTRL_P2SEB
;
1524 s
->sctrl
&= ~SCTRL_P2SEB
;
1525 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1526 spin_unlock_irqrestore(&s
->lock
, flags
);
1529 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1530 AFMT_S16_LE
: AFMT_U8
, p
);
1532 case SNDCTL_DSP_POST
:
1535 case SNDCTL_DSP_GETTRIGGER
:
1537 if (file
->f_mode
& FMODE_READ
&& s
->ctrl
& CTRL_ADC_EN
)
1538 val
|= PCM_ENABLE_INPUT
;
1539 if (file
->f_mode
& FMODE_WRITE
&& s
->ctrl
& CTRL_DAC2_EN
)
1540 val
|= PCM_ENABLE_OUTPUT
;
1541 return put_user(val
, p
);
1543 case SNDCTL_DSP_SETTRIGGER
:
1544 if (get_user(val
, p
))
1546 if (file
->f_mode
& FMODE_READ
) {
1547 if (val
& PCM_ENABLE_INPUT
) {
1548 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1550 s
->dma_adc
.enabled
= 1;
1553 s
->dma_adc
.enabled
= 0;
1557 if (file
->f_mode
& FMODE_WRITE
) {
1558 if (val
& PCM_ENABLE_OUTPUT
) {
1559 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1561 s
->dma_dac2
.enabled
= 1;
1564 s
->dma_dac2
.enabled
= 0;
1570 case SNDCTL_DSP_GETOSPACE
:
1571 if (!(file
->f_mode
& FMODE_WRITE
))
1573 if (!s
->dma_dac2
.ready
&& (val
= prog_dmabuf_dac2(s
)) != 0)
1575 spin_lock_irqsave(&s
->lock
, flags
);
1576 es1370_update_ptr(s
);
1577 abinfo
.fragsize
= s
->dma_dac2
.fragsize
;
1578 count
= s
->dma_dac2
.count
;
1581 abinfo
.bytes
= s
->dma_dac2
.dmasize
- count
;
1582 abinfo
.fragstotal
= s
->dma_dac2
.numfrag
;
1583 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac2
.fragshift
;
1584 spin_unlock_irqrestore(&s
->lock
, flags
);
1585 return copy_to_user(argp
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1587 case SNDCTL_DSP_GETISPACE
:
1588 if (!(file
->f_mode
& FMODE_READ
))
1590 if (!s
->dma_adc
.ready
&& (val
= prog_dmabuf_adc(s
)) != 0)
1592 spin_lock_irqsave(&s
->lock
, flags
);
1593 es1370_update_ptr(s
);
1594 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1595 count
= s
->dma_adc
.count
;
1598 abinfo
.bytes
= count
;
1599 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1600 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1601 spin_unlock_irqrestore(&s
->lock
, flags
);
1602 return copy_to_user(argp
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1604 case SNDCTL_DSP_NONBLOCK
:
1605 file
->f_flags
|= O_NONBLOCK
;
1608 case SNDCTL_DSP_GETODELAY
:
1609 if (!(file
->f_mode
& FMODE_WRITE
))
1611 if (!s
->dma_dac2
.ready
&& (val
= prog_dmabuf_dac2(s
)) != 0)
1613 spin_lock_irqsave(&s
->lock
, flags
);
1614 es1370_update_ptr(s
);
1615 count
= s
->dma_dac2
.count
;
1616 spin_unlock_irqrestore(&s
->lock
, flags
);
1619 return put_user(count
, p
);
1621 case SNDCTL_DSP_GETIPTR
:
1622 if (!(file
->f_mode
& FMODE_READ
))
1624 if (!s
->dma_adc
.ready
&& (val
= prog_dmabuf_adc(s
)) != 0)
1626 spin_lock_irqsave(&s
->lock
, flags
);
1627 es1370_update_ptr(s
);
1628 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1629 count
= s
->dma_adc
.count
;
1632 cinfo
.blocks
= count
>> s
->dma_adc
.fragshift
;
1633 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1634 if (s
->dma_adc
.mapped
)
1635 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1636 spin_unlock_irqrestore(&s
->lock
, flags
);
1637 if (copy_to_user(argp
, &cinfo
, sizeof(cinfo
)))
1641 case SNDCTL_DSP_GETOPTR
:
1642 if (!(file
->f_mode
& FMODE_WRITE
))
1644 if (!s
->dma_dac2
.ready
&& (val
= prog_dmabuf_dac2(s
)) != 0)
1646 spin_lock_irqsave(&s
->lock
, flags
);
1647 es1370_update_ptr(s
);
1648 cinfo
.bytes
= s
->dma_dac2
.total_bytes
;
1649 count
= s
->dma_dac2
.count
;
1652 cinfo
.blocks
= count
>> s
->dma_dac2
.fragshift
;
1653 cinfo
.ptr
= s
->dma_dac2
.hwptr
;
1654 if (s
->dma_dac2
.mapped
)
1655 s
->dma_dac2
.count
&= s
->dma_dac2
.fragsize
-1;
1656 spin_unlock_irqrestore(&s
->lock
, flags
);
1657 if (copy_to_user(argp
, &cinfo
, sizeof(cinfo
)))
1661 case SNDCTL_DSP_GETBLKSIZE
:
1662 if (file
->f_mode
& FMODE_WRITE
) {
1663 if ((val
= prog_dmabuf_dac2(s
)))
1665 return put_user(s
->dma_dac2
.fragsize
, p
);
1667 if ((val
= prog_dmabuf_adc(s
)))
1669 return put_user(s
->dma_adc
.fragsize
, p
);
1671 case SNDCTL_DSP_SETFRAGMENT
:
1672 if (get_user(val
, p
))
1674 if (file
->f_mode
& FMODE_READ
) {
1675 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1676 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1677 if (s
->dma_adc
.ossfragshift
< 4)
1678 s
->dma_adc
.ossfragshift
= 4;
1679 if (s
->dma_adc
.ossfragshift
> 15)
1680 s
->dma_adc
.ossfragshift
= 15;
1681 if (s
->dma_adc
.ossmaxfrags
< 4)
1682 s
->dma_adc
.ossmaxfrags
= 4;
1684 if (file
->f_mode
& FMODE_WRITE
) {
1685 s
->dma_dac2
.ossfragshift
= val
& 0xffff;
1686 s
->dma_dac2
.ossmaxfrags
= (val
>> 16) & 0xffff;
1687 if (s
->dma_dac2
.ossfragshift
< 4)
1688 s
->dma_dac2
.ossfragshift
= 4;
1689 if (s
->dma_dac2
.ossfragshift
> 15)
1690 s
->dma_dac2
.ossfragshift
= 15;
1691 if (s
->dma_dac2
.ossmaxfrags
< 4)
1692 s
->dma_dac2
.ossmaxfrags
= 4;
1696 case SNDCTL_DSP_SUBDIVIDE
:
1697 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1698 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac2
.subdivision
))
1700 if (get_user(val
, p
))
1702 if (val
!= 1 && val
!= 2 && val
!= 4)
1704 if (file
->f_mode
& FMODE_READ
)
1705 s
->dma_adc
.subdivision
= val
;
1706 if (file
->f_mode
& FMODE_WRITE
)
1707 s
->dma_dac2
.subdivision
= val
;
1710 case SOUND_PCM_READ_RATE
:
1711 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), p
);
1713 case SOUND_PCM_READ_CHANNELS
:
1714 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ?
1717 case SOUND_PCM_READ_BITS
:
1718 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1721 case SOUND_PCM_WRITE_FILTER
:
1722 case SNDCTL_DSP_SETSYNCRO
:
1723 case SOUND_PCM_READ_FILTER
:
1727 return mixer_ioctl(s
, cmd
, arg
);
1730 static int es1370_open(struct inode
*inode
, struct file
*file
)
1732 unsigned int minor
= iminor(inode
);
1733 DECLARE_WAITQUEUE(wait
, current
);
1734 unsigned long flags
;
1735 struct list_head
*list
;
1736 struct es1370_state
*s
;
1738 for (list
= devs
.next
; ; list
= list
->next
) {
1741 s
= list_entry(list
, struct es1370_state
, devs
);
1742 if (!((s
->dev_audio
^ minor
) & ~0xf))
1746 file
->private_data
= s
;
1747 /* wait for device to become free */
1749 while (s
->open_mode
& file
->f_mode
) {
1750 if (file
->f_flags
& O_NONBLOCK
) {
1754 add_wait_queue(&s
->open_wait
, &wait
);
1755 __set_current_state(TASK_INTERRUPTIBLE
);
1758 remove_wait_queue(&s
->open_wait
, &wait
);
1759 set_current_state(TASK_RUNNING
);
1760 if (signal_pending(current
))
1761 return -ERESTARTSYS
;
1764 spin_lock_irqsave(&s
->lock
, flags
);
1765 if (!(s
->open_mode
& (FMODE_READ
|FMODE_WRITE
)))
1766 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
);
1767 if (file
->f_mode
& FMODE_READ
) {
1768 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1769 s
->dma_adc
.enabled
= 1;
1770 s
->sctrl
&= ~SCTRL_R1FMT
;
1771 if ((minor
& 0xf) == SND_DEV_DSP16
)
1772 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_R1FMT
;
1774 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_R1FMT
;
1776 if (file
->f_mode
& FMODE_WRITE
) {
1777 s
->dma_dac2
.ossfragshift
= s
->dma_dac2
.ossmaxfrags
= s
->dma_dac2
.subdivision
= 0;
1778 s
->dma_dac2
.enabled
= 1;
1779 s
->sctrl
&= ~SCTRL_P2FMT
;
1780 if ((minor
& 0xf) == SND_DEV_DSP16
)
1781 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P2FMT
;
1783 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P2FMT
;
1785 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1786 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1787 spin_unlock_irqrestore(&s
->lock
, flags
);
1788 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1790 init_MUTEX(&s
->sem
);
1791 return nonseekable_open(inode
, file
);
1794 static int es1370_release(struct inode
*inode
, struct file
*file
)
1796 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1800 if (file
->f_mode
& FMODE_WRITE
)
1801 drain_dac2(s
, file
->f_flags
& O_NONBLOCK
);
1803 if (file
->f_mode
& FMODE_WRITE
) {
1805 synchronize_irq(s
->irq
);
1806 dealloc_dmabuf(s
, &s
->dma_dac2
);
1808 if (file
->f_mode
& FMODE_READ
) {
1810 dealloc_dmabuf(s
, &s
->dma_adc
);
1812 s
->open_mode
&= ~(file
->f_mode
& (FMODE_READ
|FMODE_WRITE
));
1813 wake_up(&s
->open_wait
);
1819 static /*const*/ struct file_operations es1370_audio_fops
= {
1820 .owner
= THIS_MODULE
,
1821 .llseek
= no_llseek
,
1822 .read
= es1370_read
,
1823 .write
= es1370_write
,
1824 .poll
= es1370_poll
,
1825 .ioctl
= es1370_ioctl
,
1826 .mmap
= es1370_mmap
,
1827 .open
= es1370_open
,
1828 .release
= es1370_release
,
1831 /* --------------------------------------------------------------------- */
1833 static ssize_t
es1370_write_dac(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
1835 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1836 DECLARE_WAITQUEUE(wait
, current
);
1838 unsigned long flags
;
1843 if (s
->dma_dac1
.mapped
)
1845 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1847 if (!access_ok(VERIFY_READ
, buffer
, count
))
1849 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1851 spin_lock_irqsave(&s
->lock
, flags
);
1852 if (s
->dma_dac1
.count
< 0) {
1853 s
->dma_dac1
.count
= 0;
1854 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
;
1856 swptr
= s
->dma_dac1
.swptr
;
1857 cnt
= s
->dma_dac1
.dmasize
-swptr
;
1858 if (s
->dma_dac1
.count
+ cnt
> s
->dma_dac1
.dmasize
)
1859 cnt
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1861 __set_current_state(TASK_INTERRUPTIBLE
);
1862 spin_unlock_irqrestore(&s
->lock
, flags
);
1866 if (s
->dma_dac1
.enabled
)
1868 if (file
->f_flags
& O_NONBLOCK
) {
1874 if (signal_pending(current
)) {
1881 if (copy_from_user(s
->dma_dac1
.rawbuf
+ swptr
, buffer
, cnt
)) {
1886 swptr
= (swptr
+ cnt
) % s
->dma_dac1
.dmasize
;
1887 spin_lock_irqsave(&s
->lock
, flags
);
1888 s
->dma_dac1
.swptr
= swptr
;
1889 s
->dma_dac1
.count
+= cnt
;
1890 s
->dma_dac1
.endcleared
= 0;
1891 spin_unlock_irqrestore(&s
->lock
, flags
);
1895 if (s
->dma_dac1
.enabled
)
1898 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1899 set_current_state(TASK_RUNNING
);
1903 /* No kernel lock - we have our own spinlock */
1904 static unsigned int es1370_poll_dac(struct file
*file
, struct poll_table_struct
*wait
)
1906 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1907 unsigned long flags
;
1908 unsigned int mask
= 0;
1911 if (!s
->dma_dac1
.ready
&& prog_dmabuf_dac1(s
))
1913 poll_wait(file
, &s
->dma_dac1
.wait
, wait
);
1914 spin_lock_irqsave(&s
->lock
, flags
);
1915 es1370_update_ptr(s
);
1916 if (s
->dma_dac1
.mapped
) {
1917 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
1918 mask
|= POLLOUT
| POLLWRNORM
;
1920 if ((signed)s
->dma_dac1
.dmasize
>= s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
)
1921 mask
|= POLLOUT
| POLLWRNORM
;
1923 spin_unlock_irqrestore(&s
->lock
, flags
);
1927 static int es1370_mmap_dac(struct file
*file
, struct vm_area_struct
*vma
)
1929 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1934 if (!(vma
->vm_flags
& VM_WRITE
))
1937 if ((ret
= prog_dmabuf_dac1(s
)) != 0)
1940 if (vma
->vm_pgoff
!= 0)
1942 size
= vma
->vm_end
- vma
->vm_start
;
1943 if (size
> (PAGE_SIZE
<< s
->dma_dac1
.buforder
))
1946 if (remap_pfn_range(vma
, vma
->vm_start
,
1947 virt_to_phys(s
->dma_dac1
.rawbuf
) >> PAGE_SHIFT
,
1948 size
, vma
->vm_page_prot
))
1950 s
->dma_dac1
.mapped
= 1;
1957 static int es1370_ioctl_dac(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1959 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1960 unsigned long flags
;
1961 audio_buf_info abinfo
;
1966 int __user
*p
= (int __user
*)arg
;
1970 case OSS_GETVERSION
:
1971 return put_user(SOUND_VERSION
, p
);
1973 case SNDCTL_DSP_SYNC
:
1974 return drain_dac1(s
, 0/*file->f_flags & O_NONBLOCK*/);
1976 case SNDCTL_DSP_SETDUPLEX
:
1979 case SNDCTL_DSP_GETCAPS
:
1980 return put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, p
);
1982 case SNDCTL_DSP_RESET
:
1984 synchronize_irq(s
->irq
);
1985 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
= s
->dma_dac1
.count
= s
->dma_dac1
.total_bytes
= 0;
1988 case SNDCTL_DSP_SPEED
:
1989 if (get_user(val
, p
))
1993 s
->dma_dac1
.ready
= 0;
1994 for (ctrl
= 0; ctrl
<= 2; ctrl
++)
1995 if (val
< (dac1_samplerate
[ctrl
] + dac1_samplerate
[ctrl
+1]) / 2)
1997 spin_lock_irqsave(&s
->lock
, flags
);
1998 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (ctrl
<< CTRL_SH_WTSRSEL
);
1999 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2000 spin_unlock_irqrestore(&s
->lock
, flags
);
2002 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], p
);
2004 case SNDCTL_DSP_STEREO
:
2005 if (get_user(val
, p
))
2008 s
->dma_dac1
.ready
= 0;
2009 spin_lock_irqsave(&s
->lock
, flags
);
2011 s
->sctrl
|= SCTRL_P1SMB
;
2013 s
->sctrl
&= ~SCTRL_P1SMB
;
2014 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2015 spin_unlock_irqrestore(&s
->lock
, flags
);
2018 case SNDCTL_DSP_CHANNELS
:
2019 if (get_user(val
, p
))
2022 if (s
->dma_dac1
.mapped
)
2025 s
->dma_dac1
.ready
= 0;
2026 spin_lock_irqsave(&s
->lock
, flags
);
2028 s
->sctrl
|= SCTRL_P1SMB
;
2030 s
->sctrl
&= ~SCTRL_P1SMB
;
2031 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2032 spin_unlock_irqrestore(&s
->lock
, flags
);
2034 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, p
);
2036 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
2037 return put_user(AFMT_S16_LE
|AFMT_U8
, p
);
2039 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
2040 if (get_user(val
, p
))
2042 if (val
!= AFMT_QUERY
) {
2044 s
->dma_dac1
.ready
= 0;
2045 spin_lock_irqsave(&s
->lock
, flags
);
2046 if (val
== AFMT_S16_LE
)
2047 s
->sctrl
|= SCTRL_P1SEB
;
2049 s
->sctrl
&= ~SCTRL_P1SEB
;
2050 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2051 spin_unlock_irqrestore(&s
->lock
, flags
);
2053 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? AFMT_S16_LE
: AFMT_U8
, p
);
2055 case SNDCTL_DSP_POST
:
2058 case SNDCTL_DSP_GETTRIGGER
:
2059 return put_user((s
->ctrl
& CTRL_DAC1_EN
) ? PCM_ENABLE_OUTPUT
: 0, p
);
2061 case SNDCTL_DSP_SETTRIGGER
:
2062 if (get_user(val
, p
))
2064 if (val
& PCM_ENABLE_OUTPUT
) {
2065 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
2067 s
->dma_dac1
.enabled
= 1;
2070 s
->dma_dac1
.enabled
= 0;
2075 case SNDCTL_DSP_GETOSPACE
:
2076 if (!s
->dma_dac1
.ready
&& (val
= prog_dmabuf_dac1(s
)) != 0)
2078 spin_lock_irqsave(&s
->lock
, flags
);
2079 es1370_update_ptr(s
);
2080 abinfo
.fragsize
= s
->dma_dac1
.fragsize
;
2081 count
= s
->dma_dac1
.count
;
2084 abinfo
.bytes
= s
->dma_dac1
.dmasize
- count
;
2085 abinfo
.fragstotal
= s
->dma_dac1
.numfrag
;
2086 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac1
.fragshift
;
2087 spin_unlock_irqrestore(&s
->lock
, flags
);
2088 return copy_to_user((void __user
*)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
2090 case SNDCTL_DSP_NONBLOCK
:
2091 file
->f_flags
|= O_NONBLOCK
;
2094 case SNDCTL_DSP_GETODELAY
:
2095 if (!s
->dma_dac1
.ready
&& (val
= prog_dmabuf_dac1(s
)) != 0)
2097 spin_lock_irqsave(&s
->lock
, flags
);
2098 es1370_update_ptr(s
);
2099 count
= s
->dma_dac1
.count
;
2100 spin_unlock_irqrestore(&s
->lock
, flags
);
2103 return put_user(count
, p
);
2105 case SNDCTL_DSP_GETOPTR
:
2106 if (!s
->dma_dac1
.ready
&& (val
= prog_dmabuf_dac1(s
)) != 0)
2108 spin_lock_irqsave(&s
->lock
, flags
);
2109 es1370_update_ptr(s
);
2110 cinfo
.bytes
= s
->dma_dac1
.total_bytes
;
2111 count
= s
->dma_dac1
.count
;
2114 cinfo
.blocks
= count
>> s
->dma_dac1
.fragshift
;
2115 cinfo
.ptr
= s
->dma_dac1
.hwptr
;
2116 if (s
->dma_dac1
.mapped
)
2117 s
->dma_dac1
.count
&= s
->dma_dac1
.fragsize
-1;
2118 spin_unlock_irqrestore(&s
->lock
, flags
);
2119 if (copy_to_user((void __user
*)arg
, &cinfo
, sizeof(cinfo
)))
2123 case SNDCTL_DSP_GETBLKSIZE
:
2124 if ((val
= prog_dmabuf_dac1(s
)))
2126 return put_user(s
->dma_dac1
.fragsize
, p
);
2128 case SNDCTL_DSP_SETFRAGMENT
:
2129 if (get_user(val
, p
))
2131 s
->dma_dac1
.ossfragshift
= val
& 0xffff;
2132 s
->dma_dac1
.ossmaxfrags
= (val
>> 16) & 0xffff;
2133 if (s
->dma_dac1
.ossfragshift
< 4)
2134 s
->dma_dac1
.ossfragshift
= 4;
2135 if (s
->dma_dac1
.ossfragshift
> 15)
2136 s
->dma_dac1
.ossfragshift
= 15;
2137 if (s
->dma_dac1
.ossmaxfrags
< 4)
2138 s
->dma_dac1
.ossmaxfrags
= 4;
2141 case SNDCTL_DSP_SUBDIVIDE
:
2142 if (s
->dma_dac1
.subdivision
)
2144 if (get_user(val
, p
))
2146 if (val
!= 1 && val
!= 2 && val
!= 4)
2148 s
->dma_dac1
.subdivision
= val
;
2151 case SOUND_PCM_READ_RATE
:
2152 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], p
);
2154 case SOUND_PCM_READ_CHANNELS
:
2155 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, p
);
2157 case SOUND_PCM_READ_BITS
:
2158 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? 16 : 8, p
);
2160 case SOUND_PCM_WRITE_FILTER
:
2161 case SNDCTL_DSP_SETSYNCRO
:
2162 case SOUND_PCM_READ_FILTER
:
2166 return mixer_ioctl(s
, cmd
, arg
);
2169 static int es1370_open_dac(struct inode
*inode
, struct file
*file
)
2171 unsigned int minor
= iminor(inode
);
2172 DECLARE_WAITQUEUE(wait
, current
);
2173 unsigned long flags
;
2174 struct list_head
*list
;
2175 struct es1370_state
*s
;
2177 for (list
= devs
.next
; ; list
= list
->next
) {
2180 s
= list_entry(list
, struct es1370_state
, devs
);
2181 if (!((s
->dev_dac
^ minor
) & ~0xf))
2185 /* we allow opening with O_RDWR, most programs do it although they will only write */
2187 if (file
->f_mode
& FMODE_READ
)
2190 if (!(file
->f_mode
& FMODE_WRITE
))
2192 file
->private_data
= s
;
2193 /* wait for device to become free */
2195 while (s
->open_mode
& FMODE_DAC
) {
2196 if (file
->f_flags
& O_NONBLOCK
) {
2200 add_wait_queue(&s
->open_wait
, &wait
);
2201 __set_current_state(TASK_INTERRUPTIBLE
);
2204 remove_wait_queue(&s
->open_wait
, &wait
);
2205 set_current_state(TASK_RUNNING
);
2206 if (signal_pending(current
))
2207 return -ERESTARTSYS
;
2210 s
->dma_dac1
.ossfragshift
= s
->dma_dac1
.ossmaxfrags
= s
->dma_dac1
.subdivision
= 0;
2211 s
->dma_dac1
.enabled
= 1;
2212 spin_lock_irqsave(&s
->lock
, flags
);
2213 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (1 << CTRL_SH_WTSRSEL
);
2214 s
->sctrl
&= ~SCTRL_P1FMT
;
2215 if ((minor
& 0xf) == SND_DEV_DSP16
)
2216 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P1FMT
;
2218 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P1FMT
;
2219 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2220 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2221 spin_unlock_irqrestore(&s
->lock
, flags
);
2222 s
->open_mode
|= FMODE_DAC
;
2224 return nonseekable_open(inode
, file
);
2227 static int es1370_release_dac(struct inode
*inode
, struct file
*file
)
2229 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2233 drain_dac1(s
, file
->f_flags
& O_NONBLOCK
);
2236 dealloc_dmabuf(s
, &s
->dma_dac1
);
2237 s
->open_mode
&= ~FMODE_DAC
;
2238 wake_up(&s
->open_wait
);
2244 static /*const*/ struct file_operations es1370_dac_fops
= {
2245 .owner
= THIS_MODULE
,
2246 .llseek
= no_llseek
,
2247 .write
= es1370_write_dac
,
2248 .poll
= es1370_poll_dac
,
2249 .ioctl
= es1370_ioctl_dac
,
2250 .mmap
= es1370_mmap_dac
,
2251 .open
= es1370_open_dac
,
2252 .release
= es1370_release_dac
,
2255 /* --------------------------------------------------------------------- */
2257 static ssize_t
es1370_midi_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
2259 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2260 DECLARE_WAITQUEUE(wait
, current
);
2262 unsigned long flags
;
2267 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2272 add_wait_queue(&s
->midi
.iwait
, &wait
);
2274 spin_lock_irqsave(&s
->lock
, flags
);
2276 cnt
= MIDIINBUF
- ptr
;
2277 if (s
->midi
.icnt
< cnt
)
2280 __set_current_state(TASK_INTERRUPTIBLE
);
2281 spin_unlock_irqrestore(&s
->lock
, flags
);
2285 if (file
->f_flags
& O_NONBLOCK
) {
2291 if (signal_pending(current
)) {
2298 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
)) {
2303 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
2304 spin_lock_irqsave(&s
->lock
, flags
);
2306 s
->midi
.icnt
-= cnt
;
2307 spin_unlock_irqrestore(&s
->lock
, flags
);
2313 __set_current_state(TASK_RUNNING
);
2314 remove_wait_queue(&s
->midi
.iwait
, &wait
);
2318 static ssize_t
es1370_midi_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
2320 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2321 DECLARE_WAITQUEUE(wait
, current
);
2323 unsigned long flags
;
2328 if (!access_ok(VERIFY_READ
, buffer
, count
))
2333 add_wait_queue(&s
->midi
.owait
, &wait
);
2335 spin_lock_irqsave(&s
->lock
, flags
);
2337 cnt
= MIDIOUTBUF
- ptr
;
2338 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
2339 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
2341 __set_current_state(TASK_INTERRUPTIBLE
);
2342 es1370_handle_midi(s
);
2344 spin_unlock_irqrestore(&s
->lock
, flags
);
2348 if (file
->f_flags
& O_NONBLOCK
) {
2354 if (signal_pending(current
)) {
2361 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
)) {
2366 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
2367 spin_lock_irqsave(&s
->lock
, flags
);
2369 s
->midi
.ocnt
+= cnt
;
2370 spin_unlock_irqrestore(&s
->lock
, flags
);
2374 spin_lock_irqsave(&s
->lock
, flags
);
2375 es1370_handle_midi(s
);
2376 spin_unlock_irqrestore(&s
->lock
, flags
);
2378 __set_current_state(TASK_RUNNING
);
2379 remove_wait_queue(&s
->midi
.owait
, &wait
);
2383 /* No kernel lock - we have our own spinlock */
2384 static unsigned int es1370_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2386 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2387 unsigned long flags
;
2388 unsigned int mask
= 0;
2391 if (file
->f_mode
& FMODE_WRITE
)
2392 poll_wait(file
, &s
->midi
.owait
, wait
);
2393 if (file
->f_mode
& FMODE_READ
)
2394 poll_wait(file
, &s
->midi
.iwait
, wait
);
2395 spin_lock_irqsave(&s
->lock
, flags
);
2396 if (file
->f_mode
& FMODE_READ
) {
2397 if (s
->midi
.icnt
> 0)
2398 mask
|= POLLIN
| POLLRDNORM
;
2400 if (file
->f_mode
& FMODE_WRITE
) {
2401 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2402 mask
|= POLLOUT
| POLLWRNORM
;
2404 spin_unlock_irqrestore(&s
->lock
, flags
);
2408 static int es1370_midi_open(struct inode
*inode
, struct file
*file
)
2410 unsigned int minor
= iminor(inode
);
2411 DECLARE_WAITQUEUE(wait
, current
);
2412 unsigned long flags
;
2413 struct list_head
*list
;
2414 struct es1370_state
*s
;
2416 for (list
= devs
.next
; ; list
= list
->next
) {
2419 s
= list_entry(list
, struct es1370_state
, devs
);
2420 if (s
->dev_midi
== minor
)
2424 file
->private_data
= s
;
2425 /* wait for device to become free */
2427 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2428 if (file
->f_flags
& O_NONBLOCK
) {
2432 add_wait_queue(&s
->open_wait
, &wait
);
2433 __set_current_state(TASK_INTERRUPTIBLE
);
2436 remove_wait_queue(&s
->open_wait
, &wait
);
2437 set_current_state(TASK_RUNNING
);
2438 if (signal_pending(current
))
2439 return -ERESTARTSYS
;
2442 spin_lock_irqsave(&s
->lock
, flags
);
2443 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2444 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2445 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2446 outb(UCTRL_CNTRL_SWR
, s
->io
+ES1370_REG_UART_CONTROL
);
2447 outb(0, s
->io
+ES1370_REG_UART_CONTROL
);
2448 outb(0, s
->io
+ES1370_REG_UART_TEST
);
2450 if (file
->f_mode
& FMODE_READ
) {
2451 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2453 if (file
->f_mode
& FMODE_WRITE
) {
2454 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2456 s
->ctrl
|= CTRL_UART_EN
;
2457 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2458 es1370_handle_midi(s
);
2459 spin_unlock_irqrestore(&s
->lock
, flags
);
2460 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2462 return nonseekable_open(inode
, file
);
2465 static int es1370_midi_release(struct inode
*inode
, struct file
*file
)
2467 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2468 DECLARE_WAITQUEUE(wait
, current
);
2469 unsigned long flags
;
2470 unsigned count
, tmo
;
2475 if (file
->f_mode
& FMODE_WRITE
) {
2476 add_wait_queue(&s
->midi
.owait
, &wait
);
2478 __set_current_state(TASK_INTERRUPTIBLE
);
2479 spin_lock_irqsave(&s
->lock
, flags
);
2480 count
= s
->midi
.ocnt
;
2481 spin_unlock_irqrestore(&s
->lock
, flags
);
2484 if (signal_pending(current
))
2486 if (file
->f_flags
& O_NONBLOCK
)
2488 tmo
= (count
* HZ
) / 3100;
2489 if (!schedule_timeout(tmo
? : 1) && tmo
)
2490 DBG(printk(KERN_DEBUG
"es1370: midi timed out??\n");)
2492 remove_wait_queue(&s
->midi
.owait
, &wait
);
2493 set_current_state(TASK_RUNNING
);
2496 s
->open_mode
&= ~((file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
));
2497 spin_lock_irqsave(&s
->lock
, flags
);
2498 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2499 s
->ctrl
&= ~CTRL_UART_EN
;
2500 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2502 spin_unlock_irqrestore(&s
->lock
, flags
);
2503 wake_up(&s
->open_wait
);
2509 static /*const*/ struct file_operations es1370_midi_fops
= {
2510 .owner
= THIS_MODULE
,
2511 .llseek
= no_llseek
,
2512 .read
= es1370_midi_read
,
2513 .write
= es1370_midi_write
,
2514 .poll
= es1370_midi_poll
,
2515 .open
= es1370_midi_open
,
2516 .release
= es1370_midi_release
,
2519 /* --------------------------------------------------------------------- */
2521 /* maximum number of devices; only used for command line params */
2524 static int lineout
[NR_DEVICE
];
2525 static int micbias
[NR_DEVICE
];
2527 static unsigned int devindex
;
2529 module_param_array(lineout
, bool, NULL
, 0);
2530 MODULE_PARM_DESC(lineout
, "if 1 the LINE input is converted to LINE out");
2531 module_param_array(micbias
, bool, NULL
, 0);
2532 MODULE_PARM_DESC(micbias
, "sets the +5V bias for an electret microphone");
2534 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2535 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2536 MODULE_LICENSE("GPL");
2539 /* --------------------------------------------------------------------- */
2541 static struct initvol
{
2544 } initvol
[] __devinitdata
= {
2545 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2546 { SOUND_MIXER_WRITE_PCM
, 0x4040 },
2547 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2548 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2549 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2550 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2551 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2552 { SOUND_MIXER_WRITE_LINE3
, 0x4040 },
2553 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2554 { SOUND_MIXER_WRITE_OGAIN
, 0x4040 }
2557 static int __devinit
es1370_probe(struct pci_dev
*pcidev
, const struct pci_device_id
*pciid
)
2559 struct es1370_state
*s
;
2560 struct gameport
*gp
= NULL
;
2564 if ((ret
=pci_enable_device(pcidev
)))
2567 if ( !(pci_resource_flags(pcidev
, 0) & IORESOURCE_IO
) ||
2568 !pci_resource_start(pcidev
, 0)
2571 if (pcidev
->irq
== 0)
2573 i
= pci_set_dma_mask(pcidev
, DMA_32BIT_MASK
);
2575 printk(KERN_WARNING
"es1370: architecture does not support 32bit PCI busmaster DMA\n");
2578 if (!(s
= kmalloc(sizeof(struct es1370_state
), GFP_KERNEL
))) {
2579 printk(KERN_WARNING
"es1370: out of memory\n");
2582 memset(s
, 0, sizeof(struct es1370_state
));
2583 init_waitqueue_head(&s
->dma_adc
.wait
);
2584 init_waitqueue_head(&s
->dma_dac1
.wait
);
2585 init_waitqueue_head(&s
->dma_dac2
.wait
);
2586 init_waitqueue_head(&s
->open_wait
);
2587 init_waitqueue_head(&s
->midi
.iwait
);
2588 init_waitqueue_head(&s
->midi
.owait
);
2589 init_MUTEX(&s
->open_sem
);
2590 spin_lock_init(&s
->lock
);
2591 s
->magic
= ES1370_MAGIC
;
2593 s
->io
= pci_resource_start(pcidev
, 0);
2594 s
->irq
= pcidev
->irq
;
2595 if (!request_region(s
->io
, ES1370_EXTENT
, "es1370")) {
2596 printk(KERN_ERR
"es1370: io ports %#lx-%#lx in use\n", s
->io
, s
->io
+ES1370_EXTENT
-1);
2600 if ((ret
=request_irq(s
->irq
, es1370_interrupt
, SA_SHIRQ
, "es1370",s
))) {
2601 printk(KERN_ERR
"es1370: irq %u in use\n", s
->irq
);
2605 /* initialize codec registers */
2606 /* note: setting CTRL_SERR_DIS is reported to break
2607 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2608 s
->ctrl
= CTRL_CDC_EN
| (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
) | (1 << CTRL_SH_WTSRSEL
);
2609 if (!request_region(0x200, JOY_EXTENT
, "es1370")) {
2610 printk(KERN_ERR
"es1370: joystick io port 0x200 in use\n");
2611 } else if (!(s
->gameport
= gp
= gameport_allocate_port())) {
2612 printk(KERN_ERR
"es1370: can not allocate memory for gameport\n");
2613 release_region(0x200, JOY_EXTENT
);
2615 gameport_set_name(gp
, "ESS1370");
2616 gameport_set_phys(gp
, "pci%s/gameport0", pci_name(s
->dev
));
2617 gp
->dev
.parent
= &s
->dev
->dev
;
2619 s
->ctrl
|= CTRL_JYSTK_EN
;
2621 if (lineout
[devindex
])
2622 s
->ctrl
|= CTRL_XCTL0
;
2623 if (micbias
[devindex
])
2624 s
->ctrl
|= CTRL_XCTL1
;
2626 printk(KERN_INFO
"es1370: found adapter at io %#lx irq %u\n"
2627 KERN_INFO
"es1370: features: joystick %s, line %s, mic impedance %s\n",
2628 s
->io
, s
->irq
, (s
->ctrl
& CTRL_JYSTK_EN
) ? "on" : "off",
2629 (s
->ctrl
& CTRL_XCTL0
) ? "out" : "in",
2630 (s
->ctrl
& CTRL_XCTL1
) ? "1" : "0");
2631 /* register devices */
2632 if ((s
->dev_audio
= register_sound_dsp(&es1370_audio_fops
, -1)) < 0) {
2636 if ((s
->dev_mixer
= register_sound_mixer(&es1370_mixer_fops
, -1)) < 0) {
2640 if ((s
->dev_dac
= register_sound_dsp(&es1370_dac_fops
, -1)) < 0) {
2644 if ((s
->dev_midi
= register_sound_midi(&es1370_midi_fops
, -1)) < 0) {
2648 /* initialize the chips */
2649 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2650 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2651 /* point phantom write channel to "bugbuf" */
2652 s
->bugbuf_cpu
= pci_alloc_consistent(pcidev
,16,&s
->bugbuf_dma
);
2653 if (!s
->bugbuf_cpu
) {
2657 outl((ES1370_REG_PHANTOM_FRAMEADR
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
2658 outl(s
->bugbuf_dma
, s
->io
+(ES1370_REG_PHANTOM_FRAMEADR
& 0xff));
2659 outl(0, s
->io
+(ES1370_REG_PHANTOM_FRAMECNT
& 0xff));
2660 pci_set_master(pcidev
); /* enable bus mastering */
2661 wrcodec(s
, 0x16, 3); /* no RST, PD */
2662 wrcodec(s
, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2663 wrcodec(s
, 0x18, 0); /* recording source is mixer */
2664 wrcodec(s
, 0x19, s
->mix
.micpreamp
= 1); /* turn on MIC preamp */
2668 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
;
2669 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2670 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2671 val
= initvol
[i
].vol
;
2672 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2676 /* register gameport */
2678 gameport_register_port(gp
);
2680 /* store it in the driver field */
2681 pci_set_drvdata(pcidev
, s
);
2682 /* put it into driver list */
2683 list_add_tail(&s
->devs
, &devs
);
2684 /* increment devindex */
2685 if (devindex
< NR_DEVICE
-1)
2690 unregister_sound_midi(s
->dev_midi
);
2692 unregister_sound_dsp(s
->dev_dac
);
2694 unregister_sound_mixer(s
->dev_mixer
);
2696 unregister_sound_dsp(s
->dev_audio
);
2698 printk(KERN_ERR
"es1370: cannot register misc device\n");
2699 free_irq(s
->irq
, s
);
2701 release_region(s
->gameport
->io
, JOY_EXTENT
);
2702 gameport_free_port(s
->gameport
);
2705 release_region(s
->io
, ES1370_EXTENT
);
2711 static void __devexit
es1370_remove(struct pci_dev
*dev
)
2713 struct es1370_state
*s
= pci_get_drvdata(dev
);
2718 outl(CTRL_SERR_DIS
| (1 << CTRL_SH_WTSRSEL
), s
->io
+ES1370_REG_CONTROL
); /* switch everything off */
2719 outl(0, s
->io
+ES1370_REG_SERIAL_CONTROL
); /* clear serial interrupts */
2720 synchronize_irq(s
->irq
);
2721 free_irq(s
->irq
, s
);
2723 int gpio
= s
->gameport
->io
;
2724 gameport_unregister_port(s
->gameport
);
2725 release_region(gpio
, JOY_EXTENT
);
2727 release_region(s
->io
, ES1370_EXTENT
);
2728 unregister_sound_dsp(s
->dev_audio
);
2729 unregister_sound_mixer(s
->dev_mixer
);
2730 unregister_sound_dsp(s
->dev_dac
);
2731 unregister_sound_midi(s
->dev_midi
);
2732 pci_free_consistent(dev
, 16, s
->bugbuf_cpu
, s
->bugbuf_dma
);
2734 pci_set_drvdata(dev
, NULL
);
2737 static struct pci_device_id id_table
[] = {
2738 { PCI_VENDOR_ID_ENSONIQ
, PCI_DEVICE_ID_ENSONIQ_ES1370
, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
2742 MODULE_DEVICE_TABLE(pci
, id_table
);
2744 static struct pci_driver es1370_driver
= {
2746 .id_table
= id_table
,
2747 .probe
= es1370_probe
,
2748 .remove
= __devexit_p(es1370_remove
),
2751 static int __init
init_es1370(void)
2753 printk(KERN_INFO
"es1370: version v0.38 time " __TIME__
" " __DATE__
"\n");
2754 return pci_module_init(&es1370_driver
);
2757 static void __exit
cleanup_es1370(void)
2759 printk(KERN_INFO
"es1370: unloading\n");
2760 pci_unregister_driver(&es1370_driver
);
2763 module_init(init_es1370
);
2764 module_exit(cleanup_es1370
);
2766 /* --------------------------------------------------------------------- */
2770 /* format is: es1370=lineout[,micbias]] */
2772 static int __init
es1370_setup(char *str
)
2774 static unsigned __initdata nr_dev
= 0;
2776 if (nr_dev
>= NR_DEVICE
)
2780 ((get_option(&str
,&lineout
[nr_dev
]) == 2)
2781 && get_option(&str
,&micbias
[nr_dev
])
2788 __setup("es1370=", es1370_setup
);