1 /*****************************************************************************/
4 * es1370.c -- Ensoniq ES1370/Asahi Kasei AK4531 audio driver.
6 * Copyright (C) 1998-1999 Thomas Sailer (sailer@ife.ee.ethz.ch)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 * Special thanks to David C. Niemi
25 * Module command line parameters:
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.98 0.1 Initial release
56 * 31.03.98 0.2 Fix bug in GETOSPACE
57 * 04.04.98 0.3 Make it work (again) under 2.0.33
58 * Fix mixer write operation not returning the actual
60 * 05.04.98 0.4 First attempt at using the new PCI stuff
61 * 29.04.98 0.5 Fix hang when ^C is pressed on amp
62 * 07.05.98 0.6 Don't double lock around stop_*() in *_release()
63 * 10.05.98 0.7 First stab at a simple midi interface (no bells&whistles)
64 * 14.05.98 0.8 Don't allow excessive interrupt rates
65 * 08.06.98 0.9 First release using Alan Cox' soundcore instead of
67 * 05.07.98 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.98 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.98 0.12 Mixer registers actually have 5 instead of 4 bits
78 * pointed out by Itai Nahshon
79 * 31.08.98 0.13 Fix realplayer problems - dac.count issues
80 * 08.10.98 0.14 Joystick support fixed
81 * -- Oliver Neukum <c188@org.chemie.uni-muenchen.de>
82 * 10.12.98 0.15 Fix drain_dac trying to wait on not yet initialized DMA
83 * 16.12.98 0.16 Don't wake up app until there are fragsize bytes to read/write
84 * 06.01.99 0.17 remove the silly SA_INTERRUPT flag.
85 * hopefully killed the egcs section type conflict
86 * 12.03.99 0.18 cinfo.blocks should be reset after GETxPTR ioctl.
87 * reported by Johan Maes <joma@telindus.be>
88 * 22.03.99 0.19 return EAGAIN instead of EBUSY when O_NONBLOCK
89 * read/write cannot be executed
90 * 07.04.99 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.99 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.99 0.22 Implemented the IMIX call to mute recording monitor.
100 * Guenter Geiger <geiger@epy.co.at>
101 * 15.06.99 0.23 Fix bad allocation bug.
102 * Thanks to Deti Fliegl <fliegl@in.tum.de>
103 * 28.06.99 0.24 Add pci_set_master
104 * 02.08.99 0.25 Added workaround for the "phantom write" bug first
105 * documented by Dave Sharpless from Anchor Games
106 * 03.08.99 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.99 0.27 module_init/__setup fixes
110 * 19.08.99 0.28 SOUND_MIXER_IMIX fixes, reported by Gianluca <gialluca@mail.tiscalinet.it>
111 * 31.08.99 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.99 0.30 change read semantics for MIDI to match
115 * OSS more closely; remove possible wakeup race
117 * some important things missing in Ensoniq documentation:
119 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
120 * and vary PCLKDIV to obtain zero beat.
123 * seems to be fs = 1411200/(PCLKDIV+2)
125 * should find out when curr_sample_ct is cleared and
126 * where exactly the CCB fetches data
128 * The card uses a 22.5792 MHz crystal.
129 * The LINEIN jack may be converted to an AOUT jack by
130 * setting pin 47 (XCTL0) of the ES1370 to high.
131 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
136 /*****************************************************************************/
138 #include <linux/version.h>
139 #include <linux/module.h>
140 #include <linux/string.h>
141 #include <linux/ioport.h>
142 #include <linux/sched.h>
143 #include <linux/delay.h>
144 #include <linux/sound.h>
145 #include <linux/malloc.h>
146 #include <linux/soundcard.h>
147 #include <linux/pci.h>
150 #include <linux/init.h>
151 #include <linux/poll.h>
152 #include <linux/spinlock.h>
153 #include <asm/uaccess.h>
154 #include <asm/hardirq.h>
156 /* --------------------------------------------------------------------- */
158 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
160 /*#define DBG(x) {x}*/
162 /* --------------------------------------------------------------------- */
164 #ifndef PCI_VENDOR_ID_ENSONIQ
165 #define PCI_VENDOR_ID_ENSONIQ 0x1274
167 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
168 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
171 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
173 #define ES1370_EXTENT 0x40
176 #define ES1370_REG_CONTROL 0x00
177 #define ES1370_REG_STATUS 0x04
178 #define ES1370_REG_UART_DATA 0x08
179 #define ES1370_REG_UART_STATUS 0x09
180 #define ES1370_REG_UART_CONTROL 0x09
181 #define ES1370_REG_UART_TEST 0x0a
182 #define ES1370_REG_MEMPAGE 0x0c
183 #define ES1370_REG_CODEC 0x10
184 #define ES1370_REG_SERIAL_CONTROL 0x20
185 #define ES1370_REG_DAC1_SCOUNT 0x24
186 #define ES1370_REG_DAC2_SCOUNT 0x28
187 #define ES1370_REG_ADC_SCOUNT 0x2c
189 #define ES1370_REG_DAC1_FRAMEADR 0xc30
190 #define ES1370_REG_DAC1_FRAMECNT 0xc34
191 #define ES1370_REG_DAC2_FRAMEADR 0xc38
192 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
193 #define ES1370_REG_ADC_FRAMEADR 0xd30
194 #define ES1370_REG_ADC_FRAMECNT 0xd34
195 #define ES1370_REG_PHANTOM_FRAMEADR 0xd38
196 #define ES1370_REG_PHANTOM_FRAMECNT 0xd3c
198 #define ES1370_FMT_U8_MONO 0
199 #define ES1370_FMT_U8_STEREO 1
200 #define ES1370_FMT_S16_MONO 2
201 #define ES1370_FMT_S16_STEREO 3
202 #define ES1370_FMT_STEREO 1
203 #define ES1370_FMT_S16 2
204 #define ES1370_FMT_MASK 3
206 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
207 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
209 static const unsigned dac1_samplerate
[] = { 5512, 11025, 22050, 44100 };
211 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
212 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
214 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
215 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
216 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
217 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
218 #define CTRL_SH_PCLKDIV 16
219 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
220 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
221 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
222 #define CTRL_SH_WTSRSEL 12
223 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
224 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
225 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
226 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
227 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
228 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
229 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
230 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
231 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
232 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
233 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
234 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
236 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
237 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
238 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
239 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
240 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
242 #define STAT_MCCB 0x00000010 /* CCB int pending */
243 #define STAT_UART 0x00000008 /* UART int pending */
244 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
245 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
246 #define STAT_ADC 0x00000001 /* ADC int pending */
248 #define USTAT_RXINT 0x80 /* UART rx int pending */
249 #define USTAT_TXINT 0x04 /* UART tx int pending */
250 #define USTAT_TXRDY 0x02 /* UART tx ready */
251 #define USTAT_RXRDY 0x01 /* UART rx ready */
253 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
254 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
255 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
256 #define UCTRL_CNTRL 0x03 /* control field */
257 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
259 #define SCTRL_P2ENDINC 0x00380000 /* */
260 #define SCTRL_SH_P2ENDINC 19
261 #define SCTRL_P2STINC 0x00070000 /* */
262 #define SCTRL_SH_P2STINC 16
263 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
264 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
265 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
266 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
267 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
268 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
269 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
270 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
271 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
272 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
273 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
274 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
275 #define SCTRL_R1FMT 0x00000030 /* format mask */
276 #define SCTRL_SH_R1FMT 4
277 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
278 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
279 #define SCTRL_P2FMT 0x0000000c /* format mask */
280 #define SCTRL_SH_P2FMT 2
281 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
282 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
283 #define SCTRL_P1FMT 0x00000003 /* format mask */
284 #define SCTRL_SH_P1FMT 0
288 #define FMODE_DAC 4 /* slight misuse of mode_t */
290 /* MIDI buffer sizes */
292 #define MIDIINBUF 256
293 #define MIDIOUTBUF 256
295 #define FMODE_MIDI_SHIFT 3
296 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
297 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
299 #define SND_DEV_DSP16 5
301 /* --------------------------------------------------------------------- */
303 struct es1370_state
{
307 /* we keep sb cards in a linked list */
308 struct es1370_state
*next
;
310 /* soundcore stuff */
316 /* hardware resources */
317 unsigned long io
; /* long for SPARC */
320 /* mixer registers; there is no HW readback */
322 unsigned short vol
[10];
325 unsigned short micpreamp
;
334 struct semaphore open_sem
;
336 wait_queue_head_t open_wait
;
343 unsigned hwptr
, swptr
;
344 unsigned total_bytes
;
346 unsigned error
; /* over/underrun */
347 wait_queue_head_t wait
;
348 /* redundant, but makes calculations easier */
351 unsigned fragsamples
;
355 unsigned endcleared
:1;
356 unsigned ossfragshift
;
358 unsigned subdivision
;
359 } dma_dac1
, dma_dac2
, dma_adc
;
363 unsigned ird
, iwr
, icnt
;
364 unsigned ord
, owr
, ocnt
;
365 wait_queue_head_t iwait
;
366 wait_queue_head_t owait
;
367 unsigned char ibuf
[MIDIINBUF
];
368 unsigned char obuf
[MIDIOUTBUF
];
372 /* --------------------------------------------------------------------- */
374 static struct es1370_state
*devs
= NULL
;
377 * The following buffer is used to point the phantom write channel to,
378 * so that it cannot wreak havoc. The attribute makes sure it doesn't
379 * cross a page boundary and ensures dword alignment for the DMA engine
381 static unsigned char bugbuf
[16] __attribute__ ((aligned (16)));
383 /* --------------------------------------------------------------------- */
385 extern inline unsigned ld2(unsigned int x
)
410 /* --------------------------------------------------------------------- */
412 static void wrcodec(struct es1370_state
*s
, unsigned char idx
, unsigned char data
)
414 unsigned long tmo
= jiffies
+ HZ
/10;
417 if (!(inl(s
->io
+ES1370_REG_STATUS
) & STAT_CSTAT
)) {
418 outw((((unsigned short)idx
)<<8)|data
, s
->io
+ES1370_REG_CODEC
);
422 } while ((signed)(tmo
-jiffies
) > 0);
423 printk(KERN_ERR
"es1370: write to codec register timeout\n");
426 /* --------------------------------------------------------------------- */
428 extern inline void stop_adc(struct es1370_state
*s
)
432 spin_lock_irqsave(&s
->lock
, flags
);
433 s
->ctrl
&= ~CTRL_ADC_EN
;
434 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
435 spin_unlock_irqrestore(&s
->lock
, flags
);
438 extern inline void stop_dac1(struct es1370_state
*s
)
442 spin_lock_irqsave(&s
->lock
, flags
);
443 s
->ctrl
&= ~CTRL_DAC1_EN
;
444 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
445 spin_unlock_irqrestore(&s
->lock
, flags
);
448 extern inline void stop_dac2(struct es1370_state
*s
)
452 spin_lock_irqsave(&s
->lock
, flags
);
453 s
->ctrl
&= ~CTRL_DAC2_EN
;
454 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
455 spin_unlock_irqrestore(&s
->lock
, flags
);
458 static void start_dac1(struct es1370_state
*s
)
461 unsigned fragremain
, fshift
;
463 spin_lock_irqsave(&s
->lock
, flags
);
464 if (!(s
->ctrl
& CTRL_DAC1_EN
) && (s
->dma_dac1
.mapped
|| s
->dma_dac1
.count
> 0)
465 && s
->dma_dac1
.ready
) {
466 s
->ctrl
|= CTRL_DAC1_EN
;
467 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P1LOOPSEL
| SCTRL_P1PAUSE
| SCTRL_P1SCTRLD
)) | SCTRL_P1INTEN
;
468 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
469 fragremain
= ((- s
->dma_dac1
.hwptr
) & (s
->dma_dac1
.fragsize
-1));
470 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
471 if (fragremain
< 2*fshift
)
472 fragremain
= s
->dma_dac1
.fragsize
;
473 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
474 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
475 outl((s
->dma_dac1
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
477 spin_unlock_irqrestore(&s
->lock
, flags
);
480 static void start_dac2(struct es1370_state
*s
)
483 unsigned fragremain
, fshift
;
485 spin_lock_irqsave(&s
->lock
, flags
);
486 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (s
->dma_dac2
.mapped
|| s
->dma_dac2
.count
> 0)
487 && s
->dma_dac2
.ready
) {
488 s
->ctrl
|= CTRL_DAC2_EN
;
489 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P2LOOPSEL
| SCTRL_P2PAUSE
| SCTRL_P2DACSEN
|
490 SCTRL_P2ENDINC
| SCTRL_P2STINC
)) | SCTRL_P2INTEN
|
491 (((s
->sctrl
& SCTRL_P2FMT
) ? 2 : 1) << SCTRL_SH_P2ENDINC
) |
492 (0 << SCTRL_SH_P2STINC
);
493 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
494 fragremain
= ((- s
->dma_dac2
.hwptr
) & (s
->dma_dac2
.fragsize
-1));
495 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
496 if (fragremain
< 2*fshift
)
497 fragremain
= s
->dma_dac2
.fragsize
;
498 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
499 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
500 outl((s
->dma_dac2
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
502 spin_unlock_irqrestore(&s
->lock
, flags
);
505 static void start_adc(struct es1370_state
*s
)
508 unsigned fragremain
, fshift
;
510 spin_lock_irqsave(&s
->lock
, flags
);
511 if (!(s
->ctrl
& CTRL_ADC_EN
) && (s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
512 && s
->dma_adc
.ready
) {
513 s
->ctrl
|= CTRL_ADC_EN
;
514 s
->sctrl
= (s
->sctrl
& ~SCTRL_R1LOOPSEL
) | SCTRL_R1INTEN
;
515 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
516 fragremain
= ((- s
->dma_adc
.hwptr
) & (s
->dma_adc
.fragsize
-1));
517 fshift
= sample_shift
[(s
->sctrl
& SCTRL_R1FMT
) >> SCTRL_SH_R1FMT
];
518 if (fragremain
< 2*fshift
)
519 fragremain
= s
->dma_adc
.fragsize
;
520 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
521 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
522 outl((s
->dma_adc
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
524 spin_unlock_irqrestore(&s
->lock
, flags
);
527 /* --------------------------------------------------------------------- */
529 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
530 #define DMABUF_MINORDER 1
532 extern inline void dealloc_dmabuf(struct dmabuf
*db
)
534 unsigned long map
, mapend
;
537 /* undo marking the pages as reserved */
538 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
539 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
540 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
541 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
544 db
->mapped
= db
->ready
= 0;
547 static int prog_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
, unsigned rate
, unsigned fmt
, unsigned reg
)
552 unsigned long map
, mapend
;
554 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
556 db
->ready
= db
->mapped
= 0;
557 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
558 if ((db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
, order
)))
562 db
->buforder
= order
;
563 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
564 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
565 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
566 set_bit(PG_reserved
, &mem_map
[map
].flags
);
568 fmt
&= ES1370_FMT_MASK
;
569 bytepersec
= rate
<< sample_shift
[fmt
];
570 bufs
= PAGE_SIZE
<< db
->buforder
;
571 if (db
->ossfragshift
) {
572 if ((1000 << db
->ossfragshift
) < bytepersec
)
573 db
->fragshift
= ld2(bytepersec
/1000);
575 db
->fragshift
= db
->ossfragshift
;
577 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
578 if (db
->fragshift
< 3)
581 db
->numfrag
= bufs
>> db
->fragshift
;
582 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
584 db
->numfrag
= bufs
>> db
->fragshift
;
586 db
->fragsize
= 1 << db
->fragshift
;
587 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
588 db
->numfrag
= db
->ossmaxfrags
;
589 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
590 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
591 memset(db
->rawbuf
, (fmt
& ES1370_FMT_S16
) ? 0 : 0x80, db
->dmasize
);
592 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
593 outl(virt_to_bus(db
->rawbuf
), s
->io
+(reg
& 0xff));
594 outl((db
->dmasize
>> 2)-1, s
->io
+((reg
+ 4) & 0xff));
599 extern inline int prog_dmabuf_adc(struct es1370_state
*s
)
602 return prog_dmabuf(s
, &s
->dma_adc
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
603 (s
->sctrl
>> SCTRL_SH_R1FMT
) & ES1370_FMT_MASK
, ES1370_REG_ADC_FRAMEADR
);
606 extern inline int prog_dmabuf_dac2(struct es1370_state
*s
)
609 return prog_dmabuf(s
, &s
->dma_dac2
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
610 (s
->sctrl
>> SCTRL_SH_P2FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC2_FRAMEADR
);
613 extern inline int prog_dmabuf_dac1(struct es1370_state
*s
)
616 return prog_dmabuf(s
, &s
->dma_dac1
, dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
],
617 (s
->sctrl
>> SCTRL_SH_P1FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC1_FRAMEADR
);
620 extern inline unsigned get_hwptr(struct es1370_state
*s
, struct dmabuf
*db
, unsigned reg
)
622 unsigned hwptr
, diff
;
624 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
625 hwptr
= (inl(s
->io
+(reg
& 0xff)) >> 14) & 0x3fffc;
626 diff
= (db
->dmasize
+ hwptr
- db
->hwptr
) % db
->dmasize
;
631 extern inline void clear_advance(void *buf
, unsigned bsize
, unsigned bptr
, unsigned len
, unsigned char c
)
633 if (bptr
+ len
> bsize
) {
634 unsigned x
= bsize
- bptr
;
635 memset(((char *)buf
) + bptr
, c
, x
);
639 memset(((char *)buf
) + bptr
, c
, len
);
642 /* call with spinlock held! */
643 static void es1370_update_ptr(struct es1370_state
*s
)
647 /* update ADC pointer */
648 if (s
->ctrl
& CTRL_ADC_EN
) {
649 diff
= get_hwptr(s
, &s
->dma_adc
, ES1370_REG_ADC_FRAMECNT
);
650 s
->dma_adc
.total_bytes
+= diff
;
651 s
->dma_adc
.count
+= diff
;
652 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
653 wake_up(&s
->dma_adc
.wait
);
654 if (!s
->dma_adc
.mapped
) {
655 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
656 s
->ctrl
&= ~CTRL_ADC_EN
;
657 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
662 /* update DAC1 pointer */
663 if (s
->ctrl
& CTRL_DAC1_EN
) {
664 diff
= get_hwptr(s
, &s
->dma_dac1
, ES1370_REG_DAC1_FRAMECNT
);
665 s
->dma_dac1
.total_bytes
+= diff
;
666 if (s
->dma_dac1
.mapped
) {
667 s
->dma_dac1
.count
+= diff
;
668 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
669 wake_up(&s
->dma_dac1
.wait
);
671 s
->dma_dac1
.count
-= diff
;
672 if (s
->dma_dac1
.count
<= 0) {
673 s
->ctrl
&= ~CTRL_DAC1_EN
;
674 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
676 } else if (s
->dma_dac1
.count
<= (signed)s
->dma_dac1
.fragsize
&& !s
->dma_dac1
.endcleared
) {
677 clear_advance(s
->dma_dac1
.rawbuf
, s
->dma_dac1
.dmasize
, s
->dma_dac1
.swptr
,
678 s
->dma_dac1
.fragsize
, (s
->sctrl
& SCTRL_P1SEB
) ? 0 : 0x80);
679 s
->dma_dac1
.endcleared
= 1;
681 if (s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
<= (signed)s
->dma_dac1
.dmasize
)
682 wake_up(&s
->dma_dac1
.wait
);
685 /* update DAC2 pointer */
686 if (s
->ctrl
& CTRL_DAC2_EN
) {
687 diff
= get_hwptr(s
, &s
->dma_dac2
, ES1370_REG_DAC2_FRAMECNT
);
688 s
->dma_dac2
.total_bytes
+= diff
;
689 if (s
->dma_dac2
.mapped
) {
690 s
->dma_dac2
.count
+= diff
;
691 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
692 wake_up(&s
->dma_dac2
.wait
);
694 s
->dma_dac2
.count
-= diff
;
695 if (s
->dma_dac2
.count
<= 0) {
696 s
->ctrl
&= ~CTRL_DAC2_EN
;
697 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
699 } else if (s
->dma_dac2
.count
<= (signed)s
->dma_dac2
.fragsize
&& !s
->dma_dac2
.endcleared
) {
700 clear_advance(s
->dma_dac2
.rawbuf
, s
->dma_dac2
.dmasize
, s
->dma_dac2
.swptr
,
701 s
->dma_dac2
.fragsize
, (s
->sctrl
& SCTRL_P2SEB
) ? 0 : 0x80);
702 s
->dma_dac2
.endcleared
= 1;
704 if (s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
<= (signed)s
->dma_dac2
.dmasize
)
705 wake_up(&s
->dma_dac2
.wait
);
710 /* hold spinlock for the following! */
711 static void es1370_handle_midi(struct es1370_state
*s
)
716 if (!(s
->ctrl
& CTRL_UART_EN
))
719 while (inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_RXRDY
) {
720 ch
= inb(s
->io
+ES1370_REG_UART_DATA
);
721 if (s
->midi
.icnt
< MIDIINBUF
) {
722 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
723 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
729 wake_up(&s
->midi
.iwait
);
731 while ((inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_TXRDY
) && s
->midi
.ocnt
> 0) {
732 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->io
+ES1370_REG_UART_DATA
);
733 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
735 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
739 wake_up(&s
->midi
.owait
);
740 outb((s
->midi
.ocnt
> 0) ? UCTRL_RXINTEN
| UCTRL_ENA_TXINT
: UCTRL_RXINTEN
, s
->io
+ES1370_REG_UART_CONTROL
);
743 static void es1370_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
745 struct es1370_state
*s
= (struct es1370_state
*)dev_id
;
746 unsigned int intsrc
, sctl
;
748 /* fastpath out, to ease interrupt sharing */
749 intsrc
= inl(s
->io
+ES1370_REG_STATUS
);
750 if (!(intsrc
& 0x80000000))
753 /* clear audio interrupts first */
755 if (intsrc
& STAT_ADC
)
756 sctl
&= ~SCTRL_R1INTEN
;
757 if (intsrc
& STAT_DAC1
)
758 sctl
&= ~SCTRL_P1INTEN
;
759 if (intsrc
& STAT_DAC2
)
760 sctl
&= ~SCTRL_P2INTEN
;
761 outl(sctl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
762 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
763 es1370_update_ptr(s
);
764 es1370_handle_midi(s
);
765 spin_unlock(&s
->lock
);
768 /* --------------------------------------------------------------------- */
770 static const char invalid_magic
[] = KERN_CRIT
"es1370: invalid magic value\n";
772 #define VALIDATE_STATE(s) \
774 if (!(s) || (s)->magic != ES1370_MAGIC) { \
775 printk(invalid_magic); \
780 /* --------------------------------------------------------------------- */
782 static const struct {
789 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
790 [SOUND_MIXER_VOLUME
] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
791 [SOUND_MIXER_PCM
] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
792 [SOUND_MIXER_SYNTH
] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
793 [SOUND_MIXER_CD
] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
794 [SOUND_MIXER_LINE
] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
795 [SOUND_MIXER_LINE1
] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
796 [SOUND_MIXER_LINE2
] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
797 [SOUND_MIXER_LINE3
] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
798 [SOUND_MIXER_MIC
] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
799 [SOUND_MIXER_OGAIN
] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
802 static void set_recsrc(struct es1370_state
*s
, unsigned int val
)
806 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
807 if (!(val
& (1 << i
)))
809 if (!mixtable
[i
].recmask
) {
813 j
|= mixtable
[i
].recmask
;
816 wrcodec(s
, 0x12, j
& 0xd5);
817 wrcodec(s
, 0x13, j
& 0xaa);
818 wrcodec(s
, 0x14, (j
>> 8) & 0x17);
819 wrcodec(s
, 0x15, (j
>> 8) & 0x0f);
820 i
= (j
& 0x37f) | ((j
<< 1) & 0x3000) | 0xc60;
822 i
&= 0xff60; /* mute record and line monitor */
825 wrcodec(s
, 0x11, i
>> 8);
828 static int mixer_ioctl(struct es1370_state
*s
, unsigned int cmd
, unsigned long arg
)
832 unsigned char l
, r
, rl
, rr
;
835 if (cmd
== SOUND_MIXER_PRIVATE1
) {
836 /* enable/disable/query mixer preamp */
837 get_user_ret(val
, (int *)arg
, -EFAULT
);
839 s
->mix
.micpreamp
= !!val
;
840 wrcodec(s
, 0x19, s
->mix
.micpreamp
);
842 return put_user(s
->mix
.micpreamp
, (int *)arg
);
844 if (cmd
== SOUND_MIXER_PRIVATE2
) {
845 /* enable/disable/query use of linein as second lineout */
846 get_user_ret(val
, (int *)arg
, -EFAULT
);
848 spin_lock_irqsave(&s
->lock
, flags
);
850 s
->ctrl
|= CTRL_XCTL0
;
852 s
->ctrl
&= ~CTRL_XCTL0
;
853 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
854 spin_unlock_irqrestore(&s
->lock
, flags
);
856 return put_user((s
->ctrl
& CTRL_XCTL0
) ? 1 : 0, (int *)arg
);
858 if (cmd
== SOUND_MIXER_PRIVATE3
) {
859 /* enable/disable/query microphone impedance setting */
860 get_user_ret(val
, (int *)arg
, -EFAULT
);
862 spin_lock_irqsave(&s
->lock
, flags
);
864 s
->ctrl
|= CTRL_XCTL1
;
866 s
->ctrl
&= ~CTRL_XCTL1
;
867 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
868 spin_unlock_irqrestore(&s
->lock
, flags
);
870 return put_user((s
->ctrl
& CTRL_XCTL1
) ? 1 : 0, (int *)arg
);
872 if (cmd
== SOUND_MIXER_INFO
) {
874 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
875 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
876 info
.modify_counter
= s
->mix
.modcnt
;
877 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
881 if (cmd
== SOUND_OLD_MIXER_INFO
) {
882 _old_mixer_info info
;
883 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
884 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
885 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
889 if (cmd
== OSS_GETVERSION
)
890 return put_user(SOUND_VERSION
, (int *)arg
);
891 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
893 if (_IOC_DIR(cmd
) == _IOC_READ
) {
894 switch (_IOC_NR(cmd
)) {
895 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
896 return put_user(s
->mix
.recsrc
, (int *)arg
);
898 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
899 val
= SOUND_MASK_IMIX
;
900 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
901 if (mixtable
[i
].avail
)
903 return put_user(val
, (int *)arg
);
905 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
906 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
907 if (mixtable
[i
].recmask
)
909 return put_user(val
, (int *)arg
);
911 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
912 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
913 if (mixtable
[i
].stereo
)
915 return put_user(val
, (int *)arg
);
917 case SOUND_MIXER_CAPS
:
918 return put_user(0, (int *)arg
);
920 case SOUND_MIXER_IMIX
:
921 return put_user(s
->mix
.imix
, (int *)arg
);
925 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
927 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
930 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
933 switch (_IOC_NR(cmd
)) {
935 case SOUND_MIXER_IMIX
:
936 get_user_ret(s
->mix
.imix
, (int *)arg
, -EFAULT
);
937 set_recsrc(s
, s
->mix
.recsrc
);
940 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
941 get_user_ret(val
, (int *)arg
, -EFAULT
);
947 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
949 get_user_ret(val
, (int *)arg
, -EFAULT
);
953 if (mixtable
[i
].stereo
) {
954 r
= (val
>> 8) & 0xff;
961 rl
= 31 - ((l
- 7) / 3);
962 l
= (31 - rl
) * 3 + 7;
968 rr
= 31 - ((r
- 7) / 3);
969 r
= (31 - rr
) * 3 + 7;
971 wrcodec(s
, mixtable
[i
].right
, rr
);
973 if (mixtable
[i
].left
== 15) {
978 rl
= 7 - ((l
- 2) / 14);
979 r
= l
= (7 - rl
) * 14 + 2;
986 rl
= 31 - ((l
- 7) / 3);
987 r
= l
= (31 - rl
) * 3 + 7;
991 wrcodec(s
, mixtable
[i
].left
, rl
);
992 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
993 s
->mix
.vol
[mixtable
[i
].volidx
] = ((unsigned int)r
<< 8) | l
;
995 s
->mix
.vol
[mixtable
[i
].volidx
] = val
;
997 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
1001 /* --------------------------------------------------------------------- */
1003 static loff_t
es1370_llseek(struct file
*file
, loff_t offset
, int origin
)
1008 /* --------------------------------------------------------------------- */
1010 static int es1370_open_mixdev(struct inode
*inode
, struct file
*file
)
1012 int minor
= MINOR(inode
->i_rdev
);
1013 struct es1370_state
*s
= devs
;
1015 while (s
&& s
->dev_mixer
!= minor
)
1020 file
->private_data
= s
;
1025 static int es1370_release_mixdev(struct inode
*inode
, struct file
*file
)
1027 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1034 static int es1370_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1036 return mixer_ioctl((struct es1370_state
*)file
->private_data
, cmd
, arg
);
1039 static /*const*/ struct file_operations es1370_mixer_fops
= {
1045 &es1370_ioctl_mixdev
,
1047 &es1370_open_mixdev
,
1049 &es1370_release_mixdev
,
1052 NULL
, /* check_media_change */
1053 NULL
, /* revalidate */
1057 /* --------------------------------------------------------------------- */
1059 static int drain_dac1(struct es1370_state
*s
, int nonblock
)
1061 DECLARE_WAITQUEUE(wait
, current
);
1062 unsigned long flags
;
1065 if (s
->dma_dac1
.mapped
|| !s
->dma_dac1
.ready
)
1067 __set_current_state(TASK_INTERRUPTIBLE
);
1068 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1070 spin_lock_irqsave(&s
->lock
, flags
);
1071 count
= s
->dma_dac1
.count
;
1072 spin_unlock_irqrestore(&s
->lock
, flags
);
1075 if (signal_pending(current
))
1078 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1079 set_current_state(TASK_RUNNING
);
1082 tmo
= 3 * HZ
* (count
+ s
->dma_dac1
.fragsize
) / 2
1083 / dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
];
1084 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
1085 if (!schedule_timeout(tmo
+ 1))
1086 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1088 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1089 set_current_state(TASK_RUNNING
);
1090 if (signal_pending(current
))
1091 return -ERESTARTSYS
;
1095 static int drain_dac2(struct es1370_state
*s
, int nonblock
)
1097 DECLARE_WAITQUEUE(wait
, current
);
1098 unsigned long flags
;
1101 if (s
->dma_dac2
.mapped
|| !s
->dma_dac2
.ready
)
1103 __set_current_state(TASK_INTERRUPTIBLE
);
1104 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1106 spin_lock_irqsave(&s
->lock
, flags
);
1107 count
= s
->dma_dac2
.count
;
1108 spin_unlock_irqrestore(&s
->lock
, flags
);
1111 if (signal_pending(current
))
1114 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1115 set_current_state(TASK_RUNNING
);
1118 tmo
= 3 * HZ
* (count
+ s
->dma_dac2
.fragsize
) / 2
1119 / DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
);
1120 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
1121 if (!schedule_timeout(tmo
+ 1))
1122 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1124 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1125 set_current_state(TASK_RUNNING
);
1126 if (signal_pending(current
))
1127 return -ERESTARTSYS
;
1131 /* --------------------------------------------------------------------- */
1133 static ssize_t
es1370_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1135 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1137 unsigned long flags
;
1142 if (ppos
!= &file
->f_pos
)
1144 if (s
->dma_adc
.mapped
)
1146 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1148 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1152 spin_lock_irqsave(&s
->lock
, flags
);
1153 swptr
= s
->dma_adc
.swptr
;
1154 cnt
= s
->dma_adc
.dmasize
-swptr
;
1155 if (s
->dma_adc
.count
< cnt
)
1156 cnt
= s
->dma_adc
.count
;
1157 spin_unlock_irqrestore(&s
->lock
, flags
);
1162 if (file
->f_flags
& O_NONBLOCK
)
1163 return ret
? ret
: -EAGAIN
;
1164 interruptible_sleep_on(&s
->dma_adc
.wait
);
1165 if (signal_pending(current
))
1166 return ret
? ret
: -ERESTARTSYS
;
1169 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1170 return ret
? ret
: -EFAULT
;
1171 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1172 spin_lock_irqsave(&s
->lock
, flags
);
1173 s
->dma_adc
.swptr
= swptr
;
1174 s
->dma_adc
.count
-= cnt
;
1175 spin_unlock_irqrestore(&s
->lock
, flags
);
1184 static ssize_t
es1370_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1186 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1188 unsigned long flags
;
1193 if (ppos
!= &file
->f_pos
)
1195 if (s
->dma_dac2
.mapped
)
1197 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1199 if (!access_ok(VERIFY_READ
, buffer
, count
))
1203 spin_lock_irqsave(&s
->lock
, flags
);
1204 if (s
->dma_dac2
.count
< 0) {
1205 s
->dma_dac2
.count
= 0;
1206 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
;
1208 swptr
= s
->dma_dac2
.swptr
;
1209 cnt
= s
->dma_dac2
.dmasize
-swptr
;
1210 if (s
->dma_dac2
.count
+ cnt
> s
->dma_dac2
.dmasize
)
1211 cnt
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1212 spin_unlock_irqrestore(&s
->lock
, flags
);
1217 if (file
->f_flags
& O_NONBLOCK
)
1218 return ret
? ret
: -EAGAIN
;
1219 interruptible_sleep_on(&s
->dma_dac2
.wait
);
1220 if (signal_pending(current
))
1221 return ret
? ret
: -ERESTARTSYS
;
1224 if (copy_from_user(s
->dma_dac2
.rawbuf
+ swptr
, buffer
, cnt
))
1225 return ret
? ret
: -EFAULT
;
1226 swptr
= (swptr
+ cnt
) % s
->dma_dac2
.dmasize
;
1227 spin_lock_irqsave(&s
->lock
, flags
);
1228 s
->dma_dac2
.swptr
= swptr
;
1229 s
->dma_dac2
.count
+= cnt
;
1230 s
->dma_dac2
.endcleared
= 0;
1231 spin_unlock_irqrestore(&s
->lock
, flags
);
1240 static unsigned int es1370_poll(struct file
*file
, struct poll_table_struct
*wait
)
1242 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1243 unsigned long flags
;
1244 unsigned int mask
= 0;
1247 if (file
->f_mode
& FMODE_WRITE
)
1248 poll_wait(file
, &s
->dma_dac2
.wait
, wait
);
1249 if (file
->f_mode
& FMODE_READ
)
1250 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1251 spin_lock_irqsave(&s
->lock
, flags
);
1252 es1370_update_ptr(s
);
1253 if (file
->f_mode
& FMODE_READ
) {
1254 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1255 mask
|= POLLIN
| POLLRDNORM
;
1257 if (file
->f_mode
& FMODE_WRITE
) {
1258 if (s
->dma_dac2
.mapped
) {
1259 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
1260 mask
|= POLLOUT
| POLLWRNORM
;
1262 if ((signed)s
->dma_dac2
.dmasize
>= s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
)
1263 mask
|= POLLOUT
| POLLWRNORM
;
1266 spin_unlock_irqrestore(&s
->lock
, flags
);
1270 static int es1370_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1272 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1278 if (vma
->vm_flags
& VM_WRITE
) {
1279 if ((ret
= prog_dmabuf_dac2(s
)) != 0)
1282 } else if (vma
->vm_flags
& VM_READ
) {
1283 if ((ret
= prog_dmabuf_adc(s
)) != 0)
1288 if (vma
->vm_offset
!= 0)
1290 size
= vma
->vm_end
- vma
->vm_start
;
1291 if (size
> (PAGE_SIZE
<< db
->buforder
))
1293 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1299 static int es1370_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1301 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1302 unsigned long flags
;
1303 audio_buf_info abinfo
;
1305 int val
, mapped
, ret
;
1308 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac2
.mapped
) ||
1309 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1311 case OSS_GETVERSION
:
1312 return put_user(SOUND_VERSION
, (int *)arg
);
1314 case SNDCTL_DSP_SYNC
:
1315 if (file
->f_mode
& FMODE_WRITE
)
1316 return drain_dac2(s
, 0/*file->f_flags & O_NONBLOCK*/);
1319 case SNDCTL_DSP_SETDUPLEX
:
1322 case SNDCTL_DSP_GETCAPS
:
1323 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1325 case SNDCTL_DSP_RESET
:
1326 if (file
->f_mode
& FMODE_WRITE
) {
1329 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
= s
->dma_dac2
.count
= s
->dma_dac2
.total_bytes
= 0;
1331 if (file
->f_mode
& FMODE_READ
) {
1334 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1338 case SNDCTL_DSP_SPEED
:
1339 get_user_ret(val
, (int *)arg
, -EFAULT
);
1341 if (s
->open_mode
& (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
))
1349 s
->dma_adc
.ready
= s
->dma_dac2
.ready
= 0;
1350 spin_lock_irqsave(&s
->lock
, flags
);
1351 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(val
) << CTRL_SH_PCLKDIV
);
1352 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1353 spin_unlock_irqrestore(&s
->lock
, flags
);
1355 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1357 case SNDCTL_DSP_STEREO
:
1358 get_user_ret(val
, (int *)arg
, -EFAULT
);
1359 if (file
->f_mode
& FMODE_READ
) {
1361 s
->dma_adc
.ready
= 0;
1362 spin_lock_irqsave(&s
->lock
, flags
);
1364 s
->sctrl
|= SCTRL_R1SMB
;
1366 s
->sctrl
&= ~SCTRL_R1SMB
;
1367 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1368 spin_unlock_irqrestore(&s
->lock
, flags
);
1370 if (file
->f_mode
& FMODE_WRITE
) {
1372 s
->dma_dac2
.ready
= 0;
1373 spin_lock_irqsave(&s
->lock
, flags
);
1375 s
->sctrl
|= SCTRL_P2SMB
;
1377 s
->sctrl
&= ~SCTRL_P2SMB
;
1378 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1379 spin_unlock_irqrestore(&s
->lock
, flags
);
1383 case SNDCTL_DSP_CHANNELS
:
1384 get_user_ret(val
, (int *)arg
, -EFAULT
);
1386 if (file
->f_mode
& FMODE_READ
) {
1388 s
->dma_adc
.ready
= 0;
1389 spin_lock_irqsave(&s
->lock
, flags
);
1391 s
->sctrl
|= SCTRL_R1SMB
;
1393 s
->sctrl
&= ~SCTRL_R1SMB
;
1394 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1395 spin_unlock_irqrestore(&s
->lock
, flags
);
1397 if (file
->f_mode
& FMODE_WRITE
) {
1399 s
->dma_dac2
.ready
= 0;
1400 spin_lock_irqsave(&s
->lock
, flags
);
1402 s
->sctrl
|= SCTRL_P2SMB
;
1404 s
->sctrl
&= ~SCTRL_P2SMB
;
1405 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1406 spin_unlock_irqrestore(&s
->lock
, flags
);
1409 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ? 2 : 1, (int *)arg
);
1411 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1412 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1414 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1415 get_user_ret(val
, (int *)arg
, -EFAULT
);
1416 if (val
!= AFMT_QUERY
) {
1417 if (file
->f_mode
& FMODE_READ
) {
1419 s
->dma_adc
.ready
= 0;
1420 spin_lock_irqsave(&s
->lock
, flags
);
1421 if (val
== AFMT_S16_LE
)
1422 s
->sctrl
|= SCTRL_R1SEB
;
1424 s
->sctrl
&= ~SCTRL_R1SEB
;
1425 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1426 spin_unlock_irqrestore(&s
->lock
, flags
);
1428 if (file
->f_mode
& FMODE_WRITE
) {
1430 s
->dma_dac2
.ready
= 0;
1431 spin_lock_irqsave(&s
->lock
, flags
);
1432 if (val
== AFMT_S16_LE
)
1433 s
->sctrl
|= SCTRL_P2SEB
;
1435 s
->sctrl
&= ~SCTRL_P2SEB
;
1436 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1437 spin_unlock_irqrestore(&s
->lock
, flags
);
1440 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1441 AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1443 case SNDCTL_DSP_POST
:
1446 case SNDCTL_DSP_GETTRIGGER
:
1448 if (file
->f_mode
& FMODE_READ
&& s
->ctrl
& CTRL_ADC_EN
)
1449 val
|= PCM_ENABLE_INPUT
;
1450 if (file
->f_mode
& FMODE_WRITE
&& s
->ctrl
& CTRL_DAC2_EN
)
1451 val
|= PCM_ENABLE_OUTPUT
;
1452 return put_user(val
, (int *)arg
);
1454 case SNDCTL_DSP_SETTRIGGER
:
1455 get_user_ret(val
, (int *)arg
, -EFAULT
);
1456 if (file
->f_mode
& FMODE_READ
) {
1457 if (val
& PCM_ENABLE_INPUT
) {
1458 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1464 if (file
->f_mode
& FMODE_WRITE
) {
1465 if (val
& PCM_ENABLE_OUTPUT
) {
1466 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1474 case SNDCTL_DSP_GETOSPACE
:
1475 if (!(file
->f_mode
& FMODE_WRITE
))
1477 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac2(s
)) != 0)
1479 spin_lock_irqsave(&s
->lock
, flags
);
1480 es1370_update_ptr(s
);
1481 abinfo
.fragsize
= s
->dma_dac2
.fragsize
;
1482 abinfo
.bytes
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1483 abinfo
.fragstotal
= s
->dma_dac2
.numfrag
;
1484 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac2
.fragshift
;
1485 spin_unlock_irqrestore(&s
->lock
, flags
);
1486 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1488 case SNDCTL_DSP_GETISPACE
:
1489 if (!(file
->f_mode
& FMODE_READ
))
1491 if (!(s
->ctrl
& CTRL_ADC_EN
) && (val
= prog_dmabuf_adc(s
)) != 0)
1493 spin_lock_irqsave(&s
->lock
, flags
);
1494 es1370_update_ptr(s
);
1495 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1496 abinfo
.bytes
= s
->dma_adc
.count
;
1497 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1498 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1499 spin_unlock_irqrestore(&s
->lock
, flags
);
1500 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1502 case SNDCTL_DSP_NONBLOCK
:
1503 file
->f_flags
|= O_NONBLOCK
;
1506 case SNDCTL_DSP_GETODELAY
:
1507 if (!(file
->f_mode
& FMODE_WRITE
))
1509 spin_lock_irqsave(&s
->lock
, flags
);
1510 es1370_update_ptr(s
);
1511 val
= s
->dma_dac2
.count
;
1512 spin_unlock_irqrestore(&s
->lock
, flags
);
1513 return put_user(val
, (int *)arg
);
1515 case SNDCTL_DSP_GETIPTR
:
1516 if (!(file
->f_mode
& FMODE_READ
))
1518 spin_lock_irqsave(&s
->lock
, flags
);
1519 es1370_update_ptr(s
);
1520 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1521 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1522 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1523 if (s
->dma_adc
.mapped
)
1524 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1525 spin_unlock_irqrestore(&s
->lock
, flags
);
1526 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1528 case SNDCTL_DSP_GETOPTR
:
1529 if (!(file
->f_mode
& FMODE_WRITE
))
1531 spin_lock_irqsave(&s
->lock
, flags
);
1532 es1370_update_ptr(s
);
1533 cinfo
.bytes
= s
->dma_dac2
.total_bytes
;
1534 cinfo
.blocks
= s
->dma_dac2
.count
>> s
->dma_dac2
.fragshift
;
1535 cinfo
.ptr
= s
->dma_dac2
.hwptr
;
1536 if (s
->dma_dac2
.mapped
)
1537 s
->dma_dac2
.count
&= s
->dma_dac2
.fragsize
-1;
1538 spin_unlock_irqrestore(&s
->lock
, flags
);
1539 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1541 case SNDCTL_DSP_GETBLKSIZE
:
1542 if (file
->f_mode
& FMODE_WRITE
) {
1543 if ((val
= prog_dmabuf_dac2(s
)))
1545 return put_user(s
->dma_dac2
.fragsize
, (int *)arg
);
1547 if ((val
= prog_dmabuf_adc(s
)))
1549 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1551 case SNDCTL_DSP_SETFRAGMENT
:
1552 get_user_ret(val
, (int *)arg
, -EFAULT
);
1553 if (file
->f_mode
& FMODE_READ
) {
1554 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1555 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1556 if (s
->dma_adc
.ossfragshift
< 4)
1557 s
->dma_adc
.ossfragshift
= 4;
1558 if (s
->dma_adc
.ossfragshift
> 15)
1559 s
->dma_adc
.ossfragshift
= 15;
1560 if (s
->dma_adc
.ossmaxfrags
< 4)
1561 s
->dma_adc
.ossmaxfrags
= 4;
1563 if (file
->f_mode
& FMODE_WRITE
) {
1564 s
->dma_dac2
.ossfragshift
= val
& 0xffff;
1565 s
->dma_dac2
.ossmaxfrags
= (val
>> 16) & 0xffff;
1566 if (s
->dma_dac2
.ossfragshift
< 4)
1567 s
->dma_dac2
.ossfragshift
= 4;
1568 if (s
->dma_dac2
.ossfragshift
> 15)
1569 s
->dma_dac2
.ossfragshift
= 15;
1570 if (s
->dma_dac2
.ossmaxfrags
< 4)
1571 s
->dma_dac2
.ossmaxfrags
= 4;
1575 case SNDCTL_DSP_SUBDIVIDE
:
1576 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1577 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac2
.subdivision
))
1579 get_user_ret(val
, (int *)arg
, -EFAULT
);
1580 if (val
!= 1 && val
!= 2 && val
!= 4)
1582 if (file
->f_mode
& FMODE_READ
)
1583 s
->dma_adc
.subdivision
= val
;
1584 if (file
->f_mode
& FMODE_WRITE
)
1585 s
->dma_dac2
.subdivision
= val
;
1588 case SOUND_PCM_READ_RATE
:
1589 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1591 case SOUND_PCM_READ_CHANNELS
:
1592 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ?
1595 case SOUND_PCM_READ_BITS
:
1596 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1597 16 : 8, (int *)arg
);
1599 case SOUND_PCM_WRITE_FILTER
:
1600 case SNDCTL_DSP_SETSYNCRO
:
1601 case SOUND_PCM_READ_FILTER
:
1605 return mixer_ioctl(s
, cmd
, arg
);
1608 static int es1370_open(struct inode
*inode
, struct file
*file
)
1610 int minor
= MINOR(inode
->i_rdev
);
1611 struct es1370_state
*s
= devs
;
1612 unsigned long flags
;
1614 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1619 file
->private_data
= s
;
1620 /* wait for device to become free */
1622 while (s
->open_mode
& file
->f_mode
) {
1623 if (file
->f_flags
& O_NONBLOCK
) {
1628 interruptible_sleep_on(&s
->open_wait
);
1629 if (signal_pending(current
))
1630 return -ERESTARTSYS
;
1633 spin_lock_irqsave(&s
->lock
, flags
);
1634 if (!(s
->open_mode
& (FMODE_READ
|FMODE_WRITE
)))
1635 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
);
1636 if (file
->f_mode
& FMODE_READ
) {
1637 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1638 s
->sctrl
&= ~SCTRL_R1FMT
;
1639 if ((minor
& 0xf) == SND_DEV_DSP16
)
1640 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_R1FMT
;
1642 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_R1FMT
;
1644 if (file
->f_mode
& FMODE_WRITE
) {
1645 s
->dma_dac2
.ossfragshift
= s
->dma_dac2
.ossmaxfrags
= s
->dma_dac2
.subdivision
= 0;
1646 s
->sctrl
&= ~SCTRL_P2FMT
;
1647 if ((minor
& 0xf) == SND_DEV_DSP16
)
1648 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P2FMT
;
1650 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P2FMT
;
1652 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1653 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1654 spin_unlock_irqrestore(&s
->lock
, flags
);
1655 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1661 static int es1370_release(struct inode
*inode
, struct file
*file
)
1663 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1666 if (file
->f_mode
& FMODE_WRITE
)
1667 drain_dac2(s
, file
->f_flags
& O_NONBLOCK
);
1669 if (file
->f_mode
& FMODE_WRITE
) {
1672 dealloc_dmabuf(&s
->dma_dac2
);
1674 if (file
->f_mode
& FMODE_READ
) {
1676 dealloc_dmabuf(&s
->dma_adc
);
1678 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1680 wake_up(&s
->open_wait
);
1685 static /*const*/ struct file_operations es1370_audio_fops
= {
1698 NULL
, /* check_media_change */
1699 NULL
, /* revalidate */
1703 /* --------------------------------------------------------------------- */
1705 static ssize_t
es1370_write_dac(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1707 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1709 unsigned long flags
;
1714 if (ppos
!= &file
->f_pos
)
1716 if (s
->dma_dac1
.mapped
)
1718 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1720 if (!access_ok(VERIFY_READ
, buffer
, count
))
1723 spin_lock_irqsave(&s
->lock
, flags
);
1724 if (s
->dma_dac1
.count
< 0) {
1725 s
->dma_dac1
.count
= 0;
1726 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
;
1728 swptr
= s
->dma_dac1
.swptr
;
1729 cnt
= s
->dma_dac1
.dmasize
-swptr
;
1730 if (s
->dma_dac1
.count
+ cnt
> s
->dma_dac1
.dmasize
)
1731 cnt
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1732 spin_unlock_irqrestore(&s
->lock
, flags
);
1737 if (file
->f_flags
& O_NONBLOCK
)
1738 return ret
? ret
: -EAGAIN
;
1739 interruptible_sleep_on(&s
->dma_dac1
.wait
);
1740 if (signal_pending(current
))
1741 return ret
? ret
: -ERESTARTSYS
;
1744 if (copy_from_user(s
->dma_dac1
.rawbuf
+ swptr
, buffer
, cnt
))
1745 return ret
? ret
: -EFAULT
;
1746 swptr
= (swptr
+ cnt
) % s
->dma_dac1
.dmasize
;
1747 spin_lock_irqsave(&s
->lock
, flags
);
1748 s
->dma_dac1
.swptr
= swptr
;
1749 s
->dma_dac1
.count
+= cnt
;
1750 s
->dma_dac1
.endcleared
= 0;
1751 spin_unlock_irqrestore(&s
->lock
, flags
);
1760 static unsigned int es1370_poll_dac(struct file
*file
, struct poll_table_struct
*wait
)
1762 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1763 unsigned long flags
;
1764 unsigned int mask
= 0;
1767 poll_wait(file
, &s
->dma_dac1
.wait
, wait
);
1768 spin_lock_irqsave(&s
->lock
, flags
);
1769 es1370_update_ptr(s
);
1770 if (s
->dma_dac1
.mapped
) {
1771 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
1772 mask
|= POLLOUT
| POLLWRNORM
;
1774 if ((signed)s
->dma_dac1
.dmasize
>= s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
)
1775 mask
|= POLLOUT
| POLLWRNORM
;
1777 spin_unlock_irqrestore(&s
->lock
, flags
);
1781 static int es1370_mmap_dac(struct file
*file
, struct vm_area_struct
*vma
)
1783 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1788 if (!(vma
->vm_flags
& VM_WRITE
))
1790 if ((ret
= prog_dmabuf_dac1(s
)) != 0)
1792 if (vma
->vm_offset
!= 0)
1794 size
= vma
->vm_end
- vma
->vm_start
;
1795 if (size
> (PAGE_SIZE
<< s
->dma_dac1
.buforder
))
1797 if (remap_page_range(vma
->vm_start
, virt_to_phys(s
->dma_dac1
.rawbuf
), size
, vma
->vm_page_prot
))
1799 s
->dma_dac1
.mapped
= 1;
1803 static int es1370_ioctl_dac(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1805 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1806 unsigned long flags
;
1807 audio_buf_info abinfo
;
1814 case OSS_GETVERSION
:
1815 return put_user(SOUND_VERSION
, (int *)arg
);
1817 case SNDCTL_DSP_SYNC
:
1818 return drain_dac1(s
, 0/*file->f_flags & O_NONBLOCK*/);
1820 case SNDCTL_DSP_SETDUPLEX
:
1823 case SNDCTL_DSP_GETCAPS
:
1824 return put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1826 case SNDCTL_DSP_RESET
:
1829 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
= s
->dma_dac1
.count
= s
->dma_dac1
.total_bytes
= 0;
1832 case SNDCTL_DSP_SPEED
:
1833 get_user_ret(val
, (int *)arg
, -EFAULT
);
1836 s
->dma_dac1
.ready
= 0;
1837 for (ctrl
= 0; ctrl
<= 2; ctrl
++)
1838 if (val
< (dac1_samplerate
[ctrl
] + dac1_samplerate
[ctrl
+1]) / 2)
1840 spin_lock_irqsave(&s
->lock
, flags
);
1841 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (ctrl
<< CTRL_SH_WTSRSEL
);
1842 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1843 spin_unlock_irqrestore(&s
->lock
, flags
);
1845 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1847 case SNDCTL_DSP_STEREO
:
1848 get_user_ret(val
, (int *)arg
, -EFAULT
);
1850 s
->dma_dac1
.ready
= 0;
1851 spin_lock_irqsave(&s
->lock
, flags
);
1853 s
->sctrl
|= SCTRL_P1SMB
;
1855 s
->sctrl
&= ~SCTRL_P1SMB
;
1856 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1857 spin_unlock_irqrestore(&s
->lock
, flags
);
1860 case SNDCTL_DSP_CHANNELS
:
1861 get_user_ret(val
, (int *)arg
, -EFAULT
);
1863 if (s
->dma_dac1
.mapped
)
1866 s
->dma_dac1
.ready
= 0;
1867 spin_lock_irqsave(&s
->lock
, flags
);
1869 s
->sctrl
|= SCTRL_P1SMB
;
1871 s
->sctrl
&= ~SCTRL_P1SMB
;
1872 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1873 spin_unlock_irqrestore(&s
->lock
, flags
);
1875 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1877 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1878 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1880 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1881 get_user_ret(val
, (int *)arg
, -EFAULT
);
1882 if (val
!= AFMT_QUERY
) {
1884 s
->dma_dac1
.ready
= 0;
1885 spin_lock_irqsave(&s
->lock
, flags
);
1886 if (val
== AFMT_S16_LE
)
1887 s
->sctrl
|= SCTRL_P1SEB
;
1889 s
->sctrl
&= ~SCTRL_P1SEB
;
1890 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1891 spin_unlock_irqrestore(&s
->lock
, flags
);
1893 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1895 case SNDCTL_DSP_POST
:
1898 case SNDCTL_DSP_GETTRIGGER
:
1899 return put_user((s
->ctrl
& CTRL_DAC1_EN
) ? PCM_ENABLE_OUTPUT
: 0, (int *)arg
);
1901 case SNDCTL_DSP_SETTRIGGER
:
1902 get_user_ret(val
, (int *)arg
, -EFAULT
);
1903 if (val
& PCM_ENABLE_OUTPUT
) {
1904 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1911 case SNDCTL_DSP_GETOSPACE
:
1912 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac1(s
)) != 0)
1914 spin_lock_irqsave(&s
->lock
, flags
);
1915 es1370_update_ptr(s
);
1916 abinfo
.fragsize
= s
->dma_dac1
.fragsize
;
1917 abinfo
.bytes
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1918 abinfo
.fragstotal
= s
->dma_dac1
.numfrag
;
1919 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac1
.fragshift
;
1920 spin_unlock_irqrestore(&s
->lock
, flags
);
1921 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1923 case SNDCTL_DSP_NONBLOCK
:
1924 file
->f_flags
|= O_NONBLOCK
;
1927 case SNDCTL_DSP_GETODELAY
:
1928 spin_lock_irqsave(&s
->lock
, flags
);
1929 es1370_update_ptr(s
);
1930 val
= s
->dma_dac1
.count
;
1931 spin_unlock_irqrestore(&s
->lock
, flags
);
1932 return put_user(val
, (int *)arg
);
1934 case SNDCTL_DSP_GETOPTR
:
1935 if (!(file
->f_mode
& FMODE_WRITE
))
1937 spin_lock_irqsave(&s
->lock
, flags
);
1938 es1370_update_ptr(s
);
1939 cinfo
.bytes
= s
->dma_dac1
.total_bytes
;
1940 cinfo
.blocks
= s
->dma_dac1
.count
>> s
->dma_dac1
.fragshift
;
1941 cinfo
.ptr
= s
->dma_dac1
.hwptr
;
1942 if (s
->dma_dac1
.mapped
)
1943 s
->dma_dac1
.count
&= s
->dma_dac1
.fragsize
-1;
1944 spin_unlock_irqrestore(&s
->lock
, flags
);
1945 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1947 case SNDCTL_DSP_GETBLKSIZE
:
1948 if ((val
= prog_dmabuf_dac1(s
)))
1950 return put_user(s
->dma_dac1
.fragsize
, (int *)arg
);
1952 case SNDCTL_DSP_SETFRAGMENT
:
1953 get_user_ret(val
, (int *)arg
, -EFAULT
);
1954 s
->dma_dac1
.ossfragshift
= val
& 0xffff;
1955 s
->dma_dac1
.ossmaxfrags
= (val
>> 16) & 0xffff;
1956 if (s
->dma_dac1
.ossfragshift
< 4)
1957 s
->dma_dac1
.ossfragshift
= 4;
1958 if (s
->dma_dac1
.ossfragshift
> 15)
1959 s
->dma_dac1
.ossfragshift
= 15;
1960 if (s
->dma_dac1
.ossmaxfrags
< 4)
1961 s
->dma_dac1
.ossmaxfrags
= 4;
1964 case SNDCTL_DSP_SUBDIVIDE
:
1965 if (s
->dma_dac1
.subdivision
)
1967 get_user_ret(val
, (int *)arg
, -EFAULT
);
1968 if (val
!= 1 && val
!= 2 && val
!= 4)
1970 s
->dma_dac1
.subdivision
= val
;
1973 case SOUND_PCM_READ_RATE
:
1974 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1976 case SOUND_PCM_READ_CHANNELS
:
1977 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1979 case SOUND_PCM_READ_BITS
:
1980 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? 16 : 8, (int *)arg
);
1982 case SOUND_PCM_WRITE_FILTER
:
1983 case SNDCTL_DSP_SETSYNCRO
:
1984 case SOUND_PCM_READ_FILTER
:
1988 return mixer_ioctl(s
, cmd
, arg
);
1991 static int es1370_open_dac(struct inode
*inode
, struct file
*file
)
1993 int minor
= MINOR(inode
->i_rdev
);
1994 struct es1370_state
*s
= devs
;
1995 unsigned long flags
;
1997 while (s
&& ((s
->dev_dac
^ minor
) & ~0xf))
2002 /* we allow opening with O_RDWR, most programs do it although they will only write */
2004 if (file
->f_mode
& FMODE_READ
)
2007 if (!(file
->f_mode
& FMODE_WRITE
))
2009 file
->private_data
= s
;
2010 /* wait for device to become free */
2012 while (s
->open_mode
& FMODE_DAC
) {
2013 if (file
->f_flags
& O_NONBLOCK
) {
2018 interruptible_sleep_on(&s
->open_wait
);
2019 if (signal_pending(current
))
2020 return -ERESTARTSYS
;
2023 s
->dma_dac1
.ossfragshift
= s
->dma_dac1
.ossmaxfrags
= s
->dma_dac1
.subdivision
= 0;
2024 spin_lock_irqsave(&s
->lock
, flags
);
2025 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (1 << CTRL_SH_WTSRSEL
);
2026 s
->sctrl
&= ~SCTRL_P1FMT
;
2027 if ((minor
& 0xf) == SND_DEV_DSP16
)
2028 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P1FMT
;
2030 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P1FMT
;
2031 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2032 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2033 spin_unlock_irqrestore(&s
->lock
, flags
);
2034 s
->open_mode
|= FMODE_DAC
;
2040 static int es1370_release_dac(struct inode
*inode
, struct file
*file
)
2042 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2045 drain_dac1(s
, file
->f_flags
& O_NONBLOCK
);
2048 dealloc_dmabuf(&s
->dma_dac1
);
2049 s
->open_mode
&= ~FMODE_DAC
;
2051 wake_up(&s
->open_wait
);
2056 static /*const*/ struct file_operations es1370_dac_fops
= {
2066 &es1370_release_dac
,
2069 NULL
, /* check_media_change */
2070 NULL
, /* revalidate */
2074 /* --------------------------------------------------------------------- */
2076 static ssize_t
es1370_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
2078 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2079 DECLARE_WAITQUEUE(wait
, current
);
2081 unsigned long flags
;
2086 if (ppos
!= &file
->f_pos
)
2088 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2093 add_wait_queue(&s
->midi
.iwait
, &wait
);
2095 spin_lock_irqsave(&s
->lock
, flags
);
2097 cnt
= MIDIINBUF
- ptr
;
2098 if (s
->midi
.icnt
< cnt
)
2100 spin_unlock_irqrestore(&s
->lock
, flags
);
2104 if (file
->f_flags
& O_NONBLOCK
) {
2109 __set_current_state(TASK_INTERRUPTIBLE
);
2111 if (signal_pending(current
)) {
2118 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
)) {
2123 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
2124 spin_lock_irqsave(&s
->lock
, flags
);
2126 s
->midi
.icnt
-= cnt
;
2127 spin_unlock_irqrestore(&s
->lock
, flags
);
2133 __set_current_state(TASK_RUNNING
);
2134 remove_wait_queue(&s
->midi
.iwait
, &wait
);
2138 static ssize_t
es1370_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
2140 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2141 DECLARE_WAITQUEUE(wait
, current
);
2143 unsigned long flags
;
2148 if (ppos
!= &file
->f_pos
)
2150 if (!access_ok(VERIFY_READ
, buffer
, count
))
2155 add_wait_queue(&s
->midi
.owait
, &wait
);
2157 spin_lock_irqsave(&s
->lock
, flags
);
2159 cnt
= MIDIOUTBUF
- ptr
;
2160 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
2161 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
2163 es1370_handle_midi(s
);
2164 spin_unlock_irqrestore(&s
->lock
, flags
);
2168 if (file
->f_flags
& O_NONBLOCK
) {
2173 __set_current_state(TASK_INTERRUPTIBLE
);
2175 if (signal_pending(current
)) {
2182 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
)) {
2187 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
2188 spin_lock_irqsave(&s
->lock
, flags
);
2190 s
->midi
.ocnt
+= cnt
;
2191 spin_unlock_irqrestore(&s
->lock
, flags
);
2195 spin_lock_irqsave(&s
->lock
, flags
);
2196 es1370_handle_midi(s
);
2197 spin_unlock_irqrestore(&s
->lock
, flags
);
2199 __set_current_state(TASK_RUNNING
);
2200 remove_wait_queue(&s
->midi
.owait
, &wait
);
2204 static unsigned int es1370_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2206 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2207 unsigned long flags
;
2208 unsigned int mask
= 0;
2211 if (file
->f_mode
& FMODE_WRITE
)
2212 poll_wait(file
, &s
->midi
.owait
, wait
);
2213 if (file
->f_mode
& FMODE_READ
)
2214 poll_wait(file
, &s
->midi
.iwait
, wait
);
2215 spin_lock_irqsave(&s
->lock
, flags
);
2216 if (file
->f_mode
& FMODE_READ
) {
2217 if (s
->midi
.icnt
> 0)
2218 mask
|= POLLIN
| POLLRDNORM
;
2220 if (file
->f_mode
& FMODE_WRITE
) {
2221 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2222 mask
|= POLLOUT
| POLLWRNORM
;
2224 spin_unlock_irqrestore(&s
->lock
, flags
);
2228 static int es1370_midi_open(struct inode
*inode
, struct file
*file
)
2230 int minor
= MINOR(inode
->i_rdev
);
2231 struct es1370_state
*s
= devs
;
2232 unsigned long flags
;
2234 while (s
&& s
->dev_midi
!= minor
)
2239 file
->private_data
= s
;
2240 /* wait for device to become free */
2242 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2243 if (file
->f_flags
& O_NONBLOCK
) {
2248 interruptible_sleep_on(&s
->open_wait
);
2249 if (signal_pending(current
))
2250 return -ERESTARTSYS
;
2253 spin_lock_irqsave(&s
->lock
, flags
);
2254 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2255 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2256 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2257 outb(UCTRL_CNTRL_SWR
, s
->io
+ES1370_REG_UART_CONTROL
);
2258 outb(0, s
->io
+ES1370_REG_UART_CONTROL
);
2259 outb(0, s
->io
+ES1370_REG_UART_TEST
);
2261 if (file
->f_mode
& FMODE_READ
) {
2262 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2264 if (file
->f_mode
& FMODE_WRITE
) {
2265 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2267 s
->ctrl
|= CTRL_UART_EN
;
2268 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2269 es1370_handle_midi(s
);
2270 spin_unlock_irqrestore(&s
->lock
, flags
);
2271 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2277 static int es1370_midi_release(struct inode
*inode
, struct file
*file
)
2279 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2280 DECLARE_WAITQUEUE(wait
, current
);
2281 unsigned long flags
;
2282 unsigned count
, tmo
;
2286 if (file
->f_mode
& FMODE_WRITE
) {
2287 __set_current_state(TASK_INTERRUPTIBLE
);
2288 add_wait_queue(&s
->midi
.owait
, &wait
);
2290 spin_lock_irqsave(&s
->lock
, flags
);
2291 count
= s
->midi
.ocnt
;
2292 spin_unlock_irqrestore(&s
->lock
, flags
);
2295 if (signal_pending(current
))
2297 if (file
->f_flags
& O_NONBLOCK
) {
2298 remove_wait_queue(&s
->midi
.owait
, &wait
);
2299 set_current_state(TASK_RUNNING
);
2302 tmo
= (count
* HZ
) / 3100;
2303 if (!schedule_timeout(tmo
? : 1) && tmo
)
2304 DBG(printk(KERN_DEBUG
"es1370: midi timed out??\n");)
2306 remove_wait_queue(&s
->midi
.owait
, &wait
);
2307 set_current_state(TASK_RUNNING
);
2310 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2311 spin_lock_irqsave(&s
->lock
, flags
);
2312 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2313 s
->ctrl
&= ~CTRL_UART_EN
;
2314 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2316 spin_unlock_irqrestore(&s
->lock
, flags
);
2318 wake_up(&s
->open_wait
);
2323 static /*const*/ struct file_operations es1370_midi_fops
= {
2333 &es1370_midi_release
,
2336 NULL
, /* check_media_change */
2337 NULL
, /* revalidate */
2341 /* --------------------------------------------------------------------- */
2343 /* maximum number of devices */
2346 static int joystick
[NR_DEVICE
] = { 0, };
2347 static int lineout
[NR_DEVICE
] = { 0, };
2348 static int micbias
[NR_DEVICE
] = { 0, };
2350 MODULE_PARM(joystick
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2351 MODULE_PARM_DESC(joystick
, "if 1 enables joystick interface (still need separate driver)");
2352 MODULE_PARM(lineout
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2353 MODULE_PARM_DESC(lineout
, "if 1 the LINE input is converted to LINE out");
2354 MODULE_PARM(micbias
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2355 MODULE_PARM_DESC(micbias
, "sets the +5V bias for an electret microphone");
2357 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2358 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2360 /* --------------------------------------------------------------------- */
2362 static struct initvol
{
2365 } initvol
[] __initdata
= {
2366 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2367 { SOUND_MIXER_WRITE_PCM
, 0x4040 },
2368 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2369 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2370 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2371 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2372 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2373 { SOUND_MIXER_WRITE_LINE3
, 0x4040 },
2374 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2375 { SOUND_MIXER_WRITE_OGAIN
, 0x4040 }
2378 #define RSRCISIOREGION(dev,num) ((dev)->resource[(num)].start != 0 && \
2379 ((dev)->resource[(num)].flags & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
2380 #define RSRCADDRESS(dev,num) ((dev)->resource[(num)].start)
2383 static int __init
init_es1370(void)
2385 struct es1370_state
*s
;
2386 struct pci_dev
*pcidev
= NULL
;
2388 int i
, val
, index
= 0;
2390 if (!pci_present()) /* No PCI bus in this machine! */
2392 printk(KERN_INFO
"es1370: version v0.29 time " __TIME__
" " __DATE__
"\n");
2393 while (index
< NR_DEVICE
&&
2394 (pcidev
= pci_find_device(PCI_VENDOR_ID_ENSONIQ
, PCI_DEVICE_ID_ENSONIQ_ES1370
, pcidev
))) {
2395 if (!RSRCISIOREGION(pcidev
, 0))
2397 if (pcidev
->irq
== 0)
2399 if (!(s
= kmalloc(sizeof(struct es1370_state
), GFP_KERNEL
))) {
2400 printk(KERN_WARNING
"es1370: out of memory\n");
2403 memset(s
, 0, sizeof(struct es1370_state
));
2404 init_waitqueue_head(&s
->dma_adc
.wait
);
2405 init_waitqueue_head(&s
->dma_dac1
.wait
);
2406 init_waitqueue_head(&s
->dma_dac2
.wait
);
2407 init_waitqueue_head(&s
->open_wait
);
2408 init_waitqueue_head(&s
->midi
.iwait
);
2409 init_waitqueue_head(&s
->midi
.owait
);
2410 init_MUTEX(&s
->open_sem
);
2411 spin_lock_init(&s
->lock
);
2412 s
->magic
= ES1370_MAGIC
;
2413 s
->io
= RSRCADDRESS(pcidev
, 0);
2414 s
->irq
= pcidev
->irq
;
2415 if (check_region(s
->io
, ES1370_EXTENT
)) {
2416 printk(KERN_ERR
"es1370: io ports %#lx-%#lx in use\n", s
->io
, s
->io
+ES1370_EXTENT
-1);
2419 request_region(s
->io
, ES1370_EXTENT
, "es1370");
2420 if (request_irq(s
->irq
, es1370_interrupt
, SA_SHIRQ
, "es1370", s
)) {
2421 printk(KERN_ERR
"es1370: irq %u in use\n", s
->irq
);
2424 /* initialize codec registers */
2425 /* note: setting CTRL_SERR_DIS is reported to break
2426 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2427 s
->ctrl
= CTRL_CDC_EN
| (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
) | (1 << CTRL_SH_WTSRSEL
);
2428 if (joystick
[index
]) {
2429 if (check_region(0x200, JOY_EXTENT
))
2430 printk(KERN_ERR
"es1370: io port 0x200 in use\n");
2432 s
->ctrl
|= CTRL_JYSTK_EN
;
2435 s
->ctrl
|= CTRL_XCTL0
;
2437 s
->ctrl
|= CTRL_XCTL1
;
2439 printk(KERN_INFO
"es1370: found adapter at io %#lx irq %u\n"
2440 KERN_INFO
"es1370: features: joystick %s, line %s, mic impedance %s\n",
2441 s
->io
, s
->irq
, (s
->ctrl
& CTRL_JYSTK_EN
) ? "on" : "off",
2442 (s
->ctrl
& CTRL_XCTL0
) ? "out" : "in",
2443 (s
->ctrl
& CTRL_XCTL1
) ? "1" : "0");
2444 /* register devices */
2445 if ((s
->dev_audio
= register_sound_dsp(&es1370_audio_fops
, -1)) < 0)
2447 if ((s
->dev_mixer
= register_sound_mixer(&es1370_mixer_fops
, -1)) < 0)
2449 if ((s
->dev_dac
= register_sound_dsp(&es1370_dac_fops
, -1)) < 0)
2451 if ((s
->dev_midi
= register_sound_midi(&es1370_midi_fops
, -1)) < 0)
2453 /* initialize the chips */
2454 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2455 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2456 /* point phantom write channel to "bugbuf" */
2457 outl((ES1370_REG_PHANTOM_FRAMEADR
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
2458 outl(virt_to_bus(bugbuf
), s
->io
+(ES1370_REG_PHANTOM_FRAMEADR
& 0xff));
2459 outl(0, s
->io
+(ES1370_REG_PHANTOM_FRAMECNT
& 0xff));
2460 pci_set_master(pcidev
); /* enable bus mastering */
2461 wrcodec(s
, 0x16, 3); /* no RST, PD */
2462 wrcodec(s
, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2463 wrcodec(s
, 0x18, 0); /* recording source is mixer */
2464 wrcodec(s
, 0x19, s
->mix
.micpreamp
= 1); /* turn on MIC preamp */
2468 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
;
2469 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2470 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2471 val
= initvol
[i
].vol
;
2472 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2475 /* queue it for later freeing */
2482 unregister_sound_dsp(s
->dev_dac
);
2484 unregister_sound_mixer(s
->dev_mixer
);
2486 unregister_sound_dsp(s
->dev_audio
);
2488 printk(KERN_ERR
"es1370: cannot register misc device\n");
2489 free_irq(s
->irq
, s
);
2491 release_region(s
->io
, ES1370_EXTENT
);
2493 kfree_s(s
, sizeof(struct es1370_state
));
2500 static void __exit
cleanup_es1370(void)
2502 struct es1370_state
*s
;
2504 while ((s
= devs
)) {
2506 outl(CTRL_SERR_DIS
| (1 << CTRL_SH_WTSRSEL
), s
->io
+ES1370_REG_CONTROL
); /* switch everything off */
2507 outl(0, s
->io
+ES1370_REG_SERIAL_CONTROL
); /* clear serial interrupts */
2509 free_irq(s
->irq
, s
);
2510 release_region(s
->io
, ES1370_EXTENT
);
2511 unregister_sound_dsp(s
->dev_audio
);
2512 unregister_sound_mixer(s
->dev_mixer
);
2513 unregister_sound_dsp(s
->dev_dac
);
2514 unregister_sound_midi(s
->dev_midi
);
2515 kfree_s(s
, sizeof(struct es1370_state
));
2517 printk(KERN_INFO
"es1370: unloading\n");
2520 module_init(init_es1370
);
2521 module_exit(cleanup_es1370
);
2523 /* --------------------------------------------------------------------- */
2527 /* format is: es1370=[joystick[,lineout[,micbias]]] */
2529 static int __init
es1370_setup(char *str
)
2531 static unsigned __initlocaldata nr_dev
= 0;
2533 if (nr_dev
>= NR_DEVICE
)
2537 ( (get_option(&str
,&joystick
[nr_dev
]) == 2)
2538 && (get_option(&str
,&lineout
[nr_dev
]) == 2)
2539 && get_option(&str
,&micbias
[nr_dev
])
2546 __setup("es1370=", es1370_setup
);