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
111 * some important things missing in Ensoniq documentation:
113 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
114 * and vary PCLKDIV to obtain zero beat.
117 * seems to be fs = 1411200/(PCLKDIV+2)
119 * should find out when curr_sample_ct is cleared and
120 * where exactly the CCB fetches data
122 * The card uses a 22.5792 MHz crystal.
123 * The LINEIN jack may be converted to an AOUT jack by
124 * setting pin 47 (XCTL0) of the ES1370 to high.
125 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
130 /*****************************************************************************/
132 #include <linux/version.h>
133 #include <linux/module.h>
134 #include <linux/string.h>
135 #include <linux/ioport.h>
136 #include <linux/sched.h>
137 #include <linux/delay.h>
138 #include <linux/sound.h>
139 #include <linux/malloc.h>
140 #include <linux/soundcard.h>
141 #include <linux/pci.h>
144 #include <linux/init.h>
145 #include <linux/poll.h>
146 #include <asm/spinlock.h>
147 #include <asm/uaccess.h>
148 #include <asm/hardirq.h>
150 /* --------------------------------------------------------------------- */
152 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
154 /*#define DBG(x) {x}*/
156 /* --------------------------------------------------------------------- */
158 #ifndef PCI_VENDOR_ID_ENSONIQ
159 #define PCI_VENDOR_ID_ENSONIQ 0x1274
161 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
162 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
165 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
167 #define ES1370_EXTENT 0x40
170 #define ES1370_REG_CONTROL 0x00
171 #define ES1370_REG_STATUS 0x04
172 #define ES1370_REG_UART_DATA 0x08
173 #define ES1370_REG_UART_STATUS 0x09
174 #define ES1370_REG_UART_CONTROL 0x09
175 #define ES1370_REG_UART_TEST 0x0a
176 #define ES1370_REG_MEMPAGE 0x0c
177 #define ES1370_REG_CODEC 0x10
178 #define ES1370_REG_SERIAL_CONTROL 0x20
179 #define ES1370_REG_DAC1_SCOUNT 0x24
180 #define ES1370_REG_DAC2_SCOUNT 0x28
181 #define ES1370_REG_ADC_SCOUNT 0x2c
183 #define ES1370_REG_DAC1_FRAMEADR 0xc30
184 #define ES1370_REG_DAC1_FRAMECNT 0xc34
185 #define ES1370_REG_DAC2_FRAMEADR 0xc38
186 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
187 #define ES1370_REG_ADC_FRAMEADR 0xd30
188 #define ES1370_REG_ADC_FRAMECNT 0xd34
189 #define ES1370_REG_PHANTOM_FRAMEADR 0xd38
190 #define ES1370_REG_PHANTOM_FRAMECNT 0xd3c
192 #define ES1370_FMT_U8_MONO 0
193 #define ES1370_FMT_U8_STEREO 1
194 #define ES1370_FMT_S16_MONO 2
195 #define ES1370_FMT_S16_STEREO 3
196 #define ES1370_FMT_STEREO 1
197 #define ES1370_FMT_S16 2
198 #define ES1370_FMT_MASK 3
200 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
201 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
203 static const unsigned dac1_samplerate
[] = { 5512, 11025, 22050, 44100 };
205 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
206 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
208 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
209 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
210 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
211 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
212 #define CTRL_SH_PCLKDIV 16
213 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
214 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
215 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
216 #define CTRL_SH_WTSRSEL 12
217 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
218 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
219 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
220 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
221 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
222 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
223 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
224 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
225 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
226 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
227 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
228 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
230 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
231 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
232 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
233 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
234 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
236 #define STAT_MCCB 0x00000010 /* CCB int pending */
237 #define STAT_UART 0x00000008 /* UART int pending */
238 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
239 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
240 #define STAT_ADC 0x00000001 /* ADC int pending */
242 #define USTAT_RXINT 0x80 /* UART rx int pending */
243 #define USTAT_TXINT 0x04 /* UART tx int pending */
244 #define USTAT_TXRDY 0x02 /* UART tx ready */
245 #define USTAT_RXRDY 0x01 /* UART rx ready */
247 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
248 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
249 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
250 #define UCTRL_CNTRL 0x03 /* control field */
251 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
253 #define SCTRL_P2ENDINC 0x00380000 /* */
254 #define SCTRL_SH_P2ENDINC 19
255 #define SCTRL_P2STINC 0x00070000 /* */
256 #define SCTRL_SH_P2STINC 16
257 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
258 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
259 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
260 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
261 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
262 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
263 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
264 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
265 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
266 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
267 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
268 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
269 #define SCTRL_R1FMT 0x00000030 /* format mask */
270 #define SCTRL_SH_R1FMT 4
271 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
272 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
273 #define SCTRL_P2FMT 0x0000000c /* format mask */
274 #define SCTRL_SH_P2FMT 2
275 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
276 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
277 #define SCTRL_P1FMT 0x00000003 /* format mask */
278 #define SCTRL_SH_P1FMT 0
282 #define FMODE_DAC 4 /* slight misuse of mode_t */
284 /* MIDI buffer sizes */
286 #define MIDIINBUF 256
287 #define MIDIOUTBUF 256
289 #define FMODE_MIDI_SHIFT 3
290 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
291 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
293 #define SND_DEV_DSP16 5
295 /* --------------------------------------------------------------------- */
297 struct es1370_state
{
301 /* we keep sb cards in a linked list */
302 struct es1370_state
*next
;
304 /* soundcore stuff */
310 /* hardware resources */
311 unsigned long io
; /* long for SPARC */
314 /* mixer registers; there is no HW readback */
316 unsigned short vol
[10];
319 unsigned short micpreamp
;
328 struct semaphore open_sem
;
330 wait_queue_head_t open_wait
;
337 unsigned hwptr
, swptr
;
338 unsigned total_bytes
;
340 unsigned error
; /* over/underrun */
341 wait_queue_head_t wait
;
342 /* redundant, but makes calculations easier */
345 unsigned fragsamples
;
349 unsigned endcleared
:1;
350 unsigned ossfragshift
;
352 unsigned subdivision
;
353 } dma_dac1
, dma_dac2
, dma_adc
;
357 unsigned ird
, iwr
, icnt
;
358 unsigned ord
, owr
, ocnt
;
359 wait_queue_head_t iwait
;
360 wait_queue_head_t owait
;
361 unsigned char ibuf
[MIDIINBUF
];
362 unsigned char obuf
[MIDIOUTBUF
];
366 /* --------------------------------------------------------------------- */
368 static struct es1370_state
*devs
= NULL
;
371 * The following buffer is used to point the phantom write channel to,
372 * so that it cannot wreak havoc. The attribute makes sure it doesn't
373 * cross a page boundary and ensures dword alignment for the DMA engine
375 static unsigned char bugbuf
[16] __attribute__ ((aligned (16)));
377 /* --------------------------------------------------------------------- */
379 extern inline unsigned ld2(unsigned int x
)
404 /* --------------------------------------------------------------------- */
406 static void wrcodec(struct es1370_state
*s
, unsigned char idx
, unsigned char data
)
408 unsigned long tmo
= jiffies
+ HZ
/10;
411 if (!(inl(s
->io
+ES1370_REG_STATUS
) & STAT_CSTAT
)) {
412 outw((((unsigned short)idx
)<<8)|data
, s
->io
+ES1370_REG_CODEC
);
416 } while ((signed)(tmo
-jiffies
) > 0);
417 printk(KERN_ERR
"es1370: write to codec register timeout\n");
420 /* --------------------------------------------------------------------- */
422 extern inline void stop_adc(struct es1370_state
*s
)
426 spin_lock_irqsave(&s
->lock
, flags
);
427 s
->ctrl
&= ~CTRL_ADC_EN
;
428 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
429 spin_unlock_irqrestore(&s
->lock
, flags
);
432 extern inline void stop_dac1(struct es1370_state
*s
)
436 spin_lock_irqsave(&s
->lock
, flags
);
437 s
->ctrl
&= ~CTRL_DAC1_EN
;
438 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
439 spin_unlock_irqrestore(&s
->lock
, flags
);
442 extern inline void stop_dac2(struct es1370_state
*s
)
446 spin_lock_irqsave(&s
->lock
, flags
);
447 s
->ctrl
&= ~CTRL_DAC2_EN
;
448 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
449 spin_unlock_irqrestore(&s
->lock
, flags
);
452 static void start_dac1(struct es1370_state
*s
)
455 unsigned fragremain
, fshift
;
457 spin_lock_irqsave(&s
->lock
, flags
);
458 if (!(s
->ctrl
& CTRL_DAC1_EN
) && (s
->dma_dac1
.mapped
|| s
->dma_dac1
.count
> 0)
459 && s
->dma_dac1
.ready
) {
460 s
->ctrl
|= CTRL_DAC1_EN
;
461 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P1LOOPSEL
| SCTRL_P1PAUSE
| SCTRL_P1SCTRLD
)) | SCTRL_P1INTEN
;
462 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
463 fragremain
= ((- s
->dma_dac1
.hwptr
) & (s
->dma_dac1
.fragsize
-1));
464 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
465 if (fragremain
< 2*fshift
)
466 fragremain
= s
->dma_dac1
.fragsize
;
467 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
468 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
469 outl((s
->dma_dac1
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
471 spin_unlock_irqrestore(&s
->lock
, flags
);
474 static void start_dac2(struct es1370_state
*s
)
477 unsigned fragremain
, fshift
;
479 spin_lock_irqsave(&s
->lock
, flags
);
480 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (s
->dma_dac2
.mapped
|| s
->dma_dac2
.count
> 0)
481 && s
->dma_dac2
.ready
) {
482 s
->ctrl
|= CTRL_DAC2_EN
;
483 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P2LOOPSEL
| SCTRL_P2PAUSE
| SCTRL_P2DACSEN
|
484 SCTRL_P2ENDINC
| SCTRL_P2STINC
)) | SCTRL_P2INTEN
|
485 (((s
->sctrl
& SCTRL_P2FMT
) ? 2 : 1) << SCTRL_SH_P2ENDINC
) |
486 (0 << SCTRL_SH_P2STINC
);
487 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
488 fragremain
= ((- s
->dma_dac2
.hwptr
) & (s
->dma_dac2
.fragsize
-1));
489 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
490 if (fragremain
< 2*fshift
)
491 fragremain
= s
->dma_dac2
.fragsize
;
492 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
493 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
494 outl((s
->dma_dac2
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
496 spin_unlock_irqrestore(&s
->lock
, flags
);
499 static void start_adc(struct es1370_state
*s
)
502 unsigned fragremain
, fshift
;
504 spin_lock_irqsave(&s
->lock
, flags
);
505 if (!(s
->ctrl
& CTRL_ADC_EN
) && (s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
506 && s
->dma_adc
.ready
) {
507 s
->ctrl
|= CTRL_ADC_EN
;
508 s
->sctrl
= (s
->sctrl
& ~SCTRL_R1LOOPSEL
) | SCTRL_R1INTEN
;
509 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
510 fragremain
= ((- s
->dma_adc
.hwptr
) & (s
->dma_adc
.fragsize
-1));
511 fshift
= sample_shift
[(s
->sctrl
& SCTRL_R1FMT
) >> SCTRL_SH_R1FMT
];
512 if (fragremain
< 2*fshift
)
513 fragremain
= s
->dma_adc
.fragsize
;
514 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
515 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
516 outl((s
->dma_adc
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
518 spin_unlock_irqrestore(&s
->lock
, flags
);
521 /* --------------------------------------------------------------------- */
523 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
524 #define DMABUF_MINORDER 1
526 extern inline void dealloc_dmabuf(struct dmabuf
*db
)
528 unsigned long map
, mapend
;
531 /* undo marking the pages as reserved */
532 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
533 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
534 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
535 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
538 db
->mapped
= db
->ready
= 0;
541 static int prog_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
, unsigned rate
, unsigned fmt
, unsigned reg
)
546 unsigned long map
, mapend
;
548 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
550 db
->ready
= db
->mapped
= 0;
551 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
552 if ((db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
, order
)))
556 db
->buforder
= order
;
557 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
558 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
559 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
560 set_bit(PG_reserved
, &mem_map
[map
].flags
);
562 fmt
&= ES1370_FMT_MASK
;
563 bytepersec
= rate
<< sample_shift
[fmt
];
564 bufs
= PAGE_SIZE
<< db
->buforder
;
565 if (db
->ossfragshift
) {
566 if ((1000 << db
->ossfragshift
) < bytepersec
)
567 db
->fragshift
= ld2(bytepersec
/1000);
569 db
->fragshift
= db
->ossfragshift
;
571 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
572 if (db
->fragshift
< 3)
575 db
->numfrag
= bufs
>> db
->fragshift
;
576 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
578 db
->numfrag
= bufs
>> db
->fragshift
;
580 db
->fragsize
= 1 << db
->fragshift
;
581 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
582 db
->numfrag
= db
->ossmaxfrags
;
583 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
584 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
585 memset(db
->rawbuf
, (fmt
& ES1370_FMT_S16
) ? 0 : 0x80, db
->dmasize
);
586 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
587 outl(virt_to_bus(db
->rawbuf
), s
->io
+(reg
& 0xff));
588 outl((db
->dmasize
>> 2)-1, s
->io
+((reg
+ 4) & 0xff));
593 extern inline int prog_dmabuf_adc(struct es1370_state
*s
)
596 return prog_dmabuf(s
, &s
->dma_adc
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
597 (s
->sctrl
>> SCTRL_SH_R1FMT
) & ES1370_FMT_MASK
, ES1370_REG_ADC_FRAMEADR
);
600 extern inline int prog_dmabuf_dac2(struct es1370_state
*s
)
603 return prog_dmabuf(s
, &s
->dma_dac2
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
604 (s
->sctrl
>> SCTRL_SH_P2FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC2_FRAMEADR
);
607 extern inline int prog_dmabuf_dac1(struct es1370_state
*s
)
610 return prog_dmabuf(s
, &s
->dma_dac1
, dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
],
611 (s
->sctrl
>> SCTRL_SH_P1FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC1_FRAMEADR
);
614 extern inline unsigned get_hwptr(struct es1370_state
*s
, struct dmabuf
*db
, unsigned reg
)
616 unsigned hwptr
, diff
;
618 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
619 hwptr
= (inl(s
->io
+(reg
& 0xff)) >> 14) & 0x3fffc;
620 diff
= (db
->dmasize
+ hwptr
- db
->hwptr
) % db
->dmasize
;
625 extern inline void clear_advance(void *buf
, unsigned bsize
, unsigned bptr
, unsigned len
, unsigned char c
)
627 if (bptr
+ len
> bsize
) {
628 unsigned x
= bsize
- bptr
;
629 memset(((char *)buf
) + bptr
, c
, x
);
633 memset(((char *)buf
) + bptr
, c
, len
);
636 /* call with spinlock held! */
637 static void es1370_update_ptr(struct es1370_state
*s
)
641 /* update ADC pointer */
642 if (s
->ctrl
& CTRL_ADC_EN
) {
643 diff
= get_hwptr(s
, &s
->dma_adc
, ES1370_REG_ADC_FRAMECNT
);
644 s
->dma_adc
.total_bytes
+= diff
;
645 s
->dma_adc
.count
+= diff
;
646 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
647 wake_up(&s
->dma_adc
.wait
);
648 if (!s
->dma_adc
.mapped
) {
649 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
650 s
->ctrl
&= ~CTRL_ADC_EN
;
651 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
656 /* update DAC1 pointer */
657 if (s
->ctrl
& CTRL_DAC1_EN
) {
658 diff
= get_hwptr(s
, &s
->dma_dac1
, ES1370_REG_DAC1_FRAMECNT
);
659 s
->dma_dac1
.total_bytes
+= diff
;
660 if (s
->dma_dac1
.mapped
) {
661 s
->dma_dac1
.count
+= diff
;
662 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
663 wake_up(&s
->dma_dac1
.wait
);
665 s
->dma_dac1
.count
-= diff
;
666 if (s
->dma_dac1
.count
<= 0) {
667 s
->ctrl
&= ~CTRL_DAC1_EN
;
668 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
670 } else if (s
->dma_dac1
.count
<= (signed)s
->dma_dac1
.fragsize
&& !s
->dma_dac1
.endcleared
) {
671 clear_advance(s
->dma_dac1
.rawbuf
, s
->dma_dac1
.dmasize
, s
->dma_dac1
.swptr
,
672 s
->dma_dac1
.fragsize
, (s
->sctrl
& SCTRL_P1SEB
) ? 0 : 0x80);
673 s
->dma_dac1
.endcleared
= 1;
675 if (s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
<= (signed)s
->dma_dac1
.dmasize
)
676 wake_up(&s
->dma_dac1
.wait
);
679 /* update DAC2 pointer */
680 if (s
->ctrl
& CTRL_DAC2_EN
) {
681 diff
= get_hwptr(s
, &s
->dma_dac2
, ES1370_REG_DAC2_FRAMECNT
);
682 s
->dma_dac2
.total_bytes
+= diff
;
683 if (s
->dma_dac2
.mapped
) {
684 s
->dma_dac2
.count
+= diff
;
685 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
686 wake_up(&s
->dma_dac2
.wait
);
688 s
->dma_dac2
.count
-= diff
;
689 if (s
->dma_dac2
.count
<= 0) {
690 s
->ctrl
&= ~CTRL_DAC2_EN
;
691 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
693 } else if (s
->dma_dac2
.count
<= (signed)s
->dma_dac2
.fragsize
&& !s
->dma_dac2
.endcleared
) {
694 clear_advance(s
->dma_dac2
.rawbuf
, s
->dma_dac2
.dmasize
, s
->dma_dac2
.swptr
,
695 s
->dma_dac2
.fragsize
, (s
->sctrl
& SCTRL_P2SEB
) ? 0 : 0x80);
696 s
->dma_dac2
.endcleared
= 1;
698 if (s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
<= (signed)s
->dma_dac2
.dmasize
)
699 wake_up(&s
->dma_dac2
.wait
);
704 /* hold spinlock for the following! */
705 static void es1370_handle_midi(struct es1370_state
*s
)
710 if (!(s
->ctrl
& CTRL_UART_EN
))
713 while (inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_RXRDY
) {
714 ch
= inb(s
->io
+ES1370_REG_UART_DATA
);
715 if (s
->midi
.icnt
< MIDIINBUF
) {
716 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
717 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
723 wake_up(&s
->midi
.iwait
);
725 while ((inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_TXRDY
) && s
->midi
.ocnt
> 0) {
726 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->io
+ES1370_REG_UART_DATA
);
727 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
729 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
733 wake_up(&s
->midi
.owait
);
734 outb((s
->midi
.ocnt
> 0) ? UCTRL_RXINTEN
| UCTRL_ENA_TXINT
: UCTRL_RXINTEN
, s
->io
+ES1370_REG_UART_CONTROL
);
737 static void es1370_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
739 struct es1370_state
*s
= (struct es1370_state
*)dev_id
;
740 unsigned int intsrc
, sctl
;
742 /* fastpath out, to ease interrupt sharing */
743 intsrc
= inl(s
->io
+ES1370_REG_STATUS
);
744 if (!(intsrc
& 0x80000000))
747 /* clear audio interrupts first */
749 if (intsrc
& STAT_ADC
)
750 sctl
&= ~SCTRL_R1INTEN
;
751 if (intsrc
& STAT_DAC1
)
752 sctl
&= ~SCTRL_P1INTEN
;
753 if (intsrc
& STAT_DAC2
)
754 sctl
&= ~SCTRL_P2INTEN
;
755 outl(sctl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
756 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
757 es1370_update_ptr(s
);
758 es1370_handle_midi(s
);
759 spin_unlock(&s
->lock
);
762 /* --------------------------------------------------------------------- */
764 static const char invalid_magic
[] = KERN_CRIT
"es1370: invalid magic value\n";
766 #define VALIDATE_STATE(s) \
768 if (!(s) || (s)->magic != ES1370_MAGIC) { \
769 printk(invalid_magic); \
774 /* --------------------------------------------------------------------- */
776 static const struct {
783 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
784 [SOUND_MIXER_VOLUME
] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
785 [SOUND_MIXER_PCM
] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
786 [SOUND_MIXER_SYNTH
] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
787 [SOUND_MIXER_CD
] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
788 [SOUND_MIXER_LINE
] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
789 [SOUND_MIXER_LINE1
] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
790 [SOUND_MIXER_LINE2
] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
791 [SOUND_MIXER_LINE3
] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
792 [SOUND_MIXER_MIC
] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
793 [SOUND_MIXER_OGAIN
] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
796 static int mixer_ioctl(struct es1370_state
*s
, unsigned int cmd
, unsigned long arg
)
800 unsigned char l
, r
, rl
, rr
;
803 if (cmd
== SOUND_MIXER_PRIVATE1
) {
804 /* enable/disable/query mixer preamp */
805 get_user_ret(val
, (int *)arg
, -EFAULT
);
807 s
->mix
.micpreamp
= !!val
;
808 wrcodec(s
, 0x19, s
->mix
.micpreamp
);
810 return put_user(s
->mix
.micpreamp
, (int *)arg
);
812 if (cmd
== SOUND_MIXER_PRIVATE2
) {
813 /* enable/disable/query use of linein as second lineout */
814 get_user_ret(val
, (int *)arg
, -EFAULT
);
816 spin_lock_irqsave(&s
->lock
, flags
);
818 s
->ctrl
|= CTRL_XCTL0
;
820 s
->ctrl
&= ~CTRL_XCTL0
;
821 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
822 spin_unlock_irqrestore(&s
->lock
, flags
);
824 return put_user((s
->ctrl
& CTRL_XCTL0
) ? 1 : 0, (int *)arg
);
826 if (cmd
== SOUND_MIXER_PRIVATE3
) {
827 /* enable/disable/query microphone impedance setting */
828 get_user_ret(val
, (int *)arg
, -EFAULT
);
830 spin_lock_irqsave(&s
->lock
, flags
);
832 s
->ctrl
|= CTRL_XCTL1
;
834 s
->ctrl
&= ~CTRL_XCTL1
;
835 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
836 spin_unlock_irqrestore(&s
->lock
, flags
);
838 return put_user((s
->ctrl
& CTRL_XCTL1
) ? 1 : 0, (int *)arg
);
840 if (cmd
== SOUND_MIXER_INFO
) {
842 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
843 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
844 info
.modify_counter
= s
->mix
.modcnt
;
845 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
849 if (cmd
== SOUND_OLD_MIXER_INFO
) {
850 _old_mixer_info info
;
851 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
852 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
853 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
857 if (cmd
== OSS_GETVERSION
)
858 return put_user(SOUND_VERSION
, (int *)arg
);
859 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
861 if (_IOC_DIR(cmd
) == _IOC_READ
) {
862 switch (_IOC_NR(cmd
)) {
863 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
864 return put_user(s
->mix
.recsrc
, (int *)arg
);
866 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
867 val
= SOUND_MASK_IMIX
;
868 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
869 if (mixtable
[i
].avail
)
871 return put_user(val
, (int *)arg
);
873 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
874 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
875 if (mixtable
[i
].recmask
)
877 return put_user(val
, (int *)arg
);
879 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
880 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
881 if (mixtable
[i
].stereo
)
883 return put_user(val
, (int *)arg
);
885 case SOUND_MIXER_CAPS
:
886 return put_user(0, (int *)arg
);
888 case SOUND_MIXER_IMIX
:
889 return put_user(s
->mix
.imix
, (int *)arg
);
893 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
895 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
898 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
901 switch (_IOC_NR(cmd
)) {
903 case SOUND_MIXER_IMIX
:
906 get_user_ret(s
->mix
.imix
,(int *)arg
, -EFAULT
);
910 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
911 get_user_ret(val
, (int *)arg
, -EFAULT
);
912 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
913 if (!(val
& (1 << i
)))
915 if (!mixtable
[i
].recmask
) {
919 j
|= mixtable
[i
].recmask
;
922 wrcodec(s
, 0x12, j
& 0xd5);
923 wrcodec(s
, 0x13, j
& 0xaa);
924 wrcodec(s
, 0x14, (j
>> 8) & 0x17);
925 wrcodec(s
, 0x15, (j
>> 8) & 0x0f);
926 i
= (j
& 0x37f) | ((j
<< 1) & 0x3000) | 0xc60;
928 i
&= 0xff60; /* mute record and line monitor */
931 wrcodec(s
, 0x11, i
>> 8);
936 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
938 get_user_ret(val
, (int *)arg
, -EFAULT
);
942 if (mixtable
[i
].stereo
) {
943 r
= (val
>> 8) & 0xff;
950 rl
= 31 - ((l
- 7) / 3);
951 l
= (31 - rl
) * 3 + 7;
957 rr
= 31 - ((r
- 7) / 3);
958 r
= (31 - rr
) * 3 + 7;
960 wrcodec(s
, mixtable
[i
].right
, rr
);
962 if (mixtable
[i
].left
== 15) {
967 rl
= 7 - ((l
- 2) / 14);
968 r
= l
= (7 - rl
) * 14 + 2;
975 rl
= 31 - ((l
- 7) / 3);
976 r
= l
= (31 - rl
) * 3 + 7;
980 wrcodec(s
, mixtable
[i
].left
, rl
);
981 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
982 s
->mix
.vol
[mixtable
[i
].volidx
] = ((unsigned int)r
<< 8) | l
;
984 s
->mix
.vol
[mixtable
[i
].volidx
] = val
;
986 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
990 /* --------------------------------------------------------------------- */
992 static loff_t
es1370_llseek(struct file
*file
, loff_t offset
, int origin
)
997 /* --------------------------------------------------------------------- */
999 static int es1370_open_mixdev(struct inode
*inode
, struct file
*file
)
1001 int minor
= MINOR(inode
->i_rdev
);
1002 struct es1370_state
*s
= devs
;
1004 while (s
&& s
->dev_mixer
!= minor
)
1009 file
->private_data
= s
;
1014 static int es1370_release_mixdev(struct inode
*inode
, struct file
*file
)
1016 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1023 static int es1370_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1025 return mixer_ioctl((struct es1370_state
*)file
->private_data
, cmd
, arg
);
1028 static /*const*/ struct file_operations es1370_mixer_fops
= {
1034 &es1370_ioctl_mixdev
,
1036 &es1370_open_mixdev
,
1038 &es1370_release_mixdev
,
1041 NULL
, /* check_media_change */
1042 NULL
, /* revalidate */
1046 /* --------------------------------------------------------------------- */
1048 static int drain_dac1(struct es1370_state
*s
, int nonblock
)
1050 DECLARE_WAITQUEUE(wait
, current
);
1051 unsigned long flags
;
1054 if (s
->dma_dac1
.mapped
|| !s
->dma_dac1
.ready
)
1056 current
->state
= TASK_INTERRUPTIBLE
;
1057 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1059 spin_lock_irqsave(&s
->lock
, flags
);
1060 count
= s
->dma_dac1
.count
;
1061 spin_unlock_irqrestore(&s
->lock
, flags
);
1064 if (signal_pending(current
))
1067 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1068 current
->state
= TASK_RUNNING
;
1071 tmo
= 3 * HZ
* (count
+ s
->dma_dac1
.fragsize
) / 2
1072 / dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
];
1073 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
1074 if (!schedule_timeout(tmo
+ 1))
1075 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1077 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1078 current
->state
= TASK_RUNNING
;
1079 if (signal_pending(current
))
1080 return -ERESTARTSYS
;
1084 static int drain_dac2(struct es1370_state
*s
, int nonblock
)
1086 DECLARE_WAITQUEUE(wait
, current
);
1087 unsigned long flags
;
1090 if (s
->dma_dac2
.mapped
|| !s
->dma_dac2
.ready
)
1092 current
->state
= TASK_INTERRUPTIBLE
;
1093 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1095 spin_lock_irqsave(&s
->lock
, flags
);
1096 count
= s
->dma_dac2
.count
;
1097 spin_unlock_irqrestore(&s
->lock
, flags
);
1100 if (signal_pending(current
))
1103 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1104 current
->state
= TASK_RUNNING
;
1107 tmo
= 3 * HZ
* (count
+ s
->dma_dac2
.fragsize
) / 2
1108 / DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
);
1109 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
1110 if (!schedule_timeout(tmo
+ 1))
1111 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1113 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1114 current
->state
= TASK_RUNNING
;
1115 if (signal_pending(current
))
1116 return -ERESTARTSYS
;
1120 /* --------------------------------------------------------------------- */
1122 static ssize_t
es1370_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1124 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1126 unsigned long flags
;
1131 if (ppos
!= &file
->f_pos
)
1133 if (s
->dma_adc
.mapped
)
1135 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1137 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1141 spin_lock_irqsave(&s
->lock
, flags
);
1142 swptr
= s
->dma_adc
.swptr
;
1143 cnt
= s
->dma_adc
.dmasize
-swptr
;
1144 if (s
->dma_adc
.count
< cnt
)
1145 cnt
= s
->dma_adc
.count
;
1146 spin_unlock_irqrestore(&s
->lock
, flags
);
1151 if (file
->f_flags
& O_NONBLOCK
)
1152 return ret
? ret
: -EAGAIN
;
1153 interruptible_sleep_on(&s
->dma_adc
.wait
);
1154 if (signal_pending(current
))
1155 return ret
? ret
: -ERESTARTSYS
;
1158 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1159 return ret
? ret
: -EFAULT
;
1160 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1161 spin_lock_irqsave(&s
->lock
, flags
);
1162 s
->dma_adc
.swptr
= swptr
;
1163 s
->dma_adc
.count
-= cnt
;
1164 spin_unlock_irqrestore(&s
->lock
, flags
);
1173 static ssize_t
es1370_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1175 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1177 unsigned long flags
;
1182 if (ppos
!= &file
->f_pos
)
1184 if (s
->dma_dac2
.mapped
)
1186 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1188 if (!access_ok(VERIFY_READ
, buffer
, count
))
1192 spin_lock_irqsave(&s
->lock
, flags
);
1193 if (s
->dma_dac2
.count
< 0) {
1194 s
->dma_dac2
.count
= 0;
1195 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
;
1197 swptr
= s
->dma_dac2
.swptr
;
1198 cnt
= s
->dma_dac2
.dmasize
-swptr
;
1199 if (s
->dma_dac2
.count
+ cnt
> s
->dma_dac2
.dmasize
)
1200 cnt
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1201 spin_unlock_irqrestore(&s
->lock
, flags
);
1206 if (file
->f_flags
& O_NONBLOCK
)
1207 return ret
? ret
: -EAGAIN
;
1208 interruptible_sleep_on(&s
->dma_dac2
.wait
);
1209 if (signal_pending(current
))
1210 return ret
? ret
: -ERESTARTSYS
;
1213 if (copy_from_user(s
->dma_dac2
.rawbuf
+ swptr
, buffer
, cnt
))
1214 return ret
? ret
: -EFAULT
;
1215 swptr
= (swptr
+ cnt
) % s
->dma_dac2
.dmasize
;
1216 spin_lock_irqsave(&s
->lock
, flags
);
1217 s
->dma_dac2
.swptr
= swptr
;
1218 s
->dma_dac2
.count
+= cnt
;
1219 s
->dma_dac2
.endcleared
= 0;
1220 spin_unlock_irqrestore(&s
->lock
, flags
);
1229 static unsigned int es1370_poll(struct file
*file
, struct poll_table_struct
*wait
)
1231 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1232 unsigned long flags
;
1233 unsigned int mask
= 0;
1236 if (file
->f_mode
& FMODE_WRITE
)
1237 poll_wait(file
, &s
->dma_dac2
.wait
, wait
);
1238 if (file
->f_mode
& FMODE_READ
)
1239 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1240 spin_lock_irqsave(&s
->lock
, flags
);
1241 es1370_update_ptr(s
);
1242 if (file
->f_mode
& FMODE_READ
) {
1243 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1244 mask
|= POLLIN
| POLLRDNORM
;
1246 if (file
->f_mode
& FMODE_WRITE
) {
1247 if (s
->dma_dac2
.mapped
) {
1248 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
1249 mask
|= POLLOUT
| POLLWRNORM
;
1251 if ((signed)s
->dma_dac2
.dmasize
>= s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
)
1252 mask
|= POLLOUT
| POLLWRNORM
;
1255 spin_unlock_irqrestore(&s
->lock
, flags
);
1259 static int es1370_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1261 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1267 if (vma
->vm_flags
& VM_WRITE
) {
1268 if ((ret
= prog_dmabuf_dac2(s
)) != 0)
1271 } else if (vma
->vm_flags
& VM_READ
) {
1272 if ((ret
= prog_dmabuf_adc(s
)) != 0)
1277 if (vma
->vm_offset
!= 0)
1279 size
= vma
->vm_end
- vma
->vm_start
;
1280 if (size
> (PAGE_SIZE
<< db
->buforder
))
1282 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1288 static int es1370_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1290 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1291 unsigned long flags
;
1292 audio_buf_info abinfo
;
1294 int val
, mapped
, ret
;
1297 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac2
.mapped
) ||
1298 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1300 case OSS_GETVERSION
:
1301 return put_user(SOUND_VERSION
, (int *)arg
);
1303 case SNDCTL_DSP_SYNC
:
1304 if (file
->f_mode
& FMODE_WRITE
)
1305 return drain_dac2(s
, 0/*file->f_flags & O_NONBLOCK*/);
1308 case SNDCTL_DSP_SETDUPLEX
:
1311 case SNDCTL_DSP_GETCAPS
:
1312 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1314 case SNDCTL_DSP_RESET
:
1315 if (file
->f_mode
& FMODE_WRITE
) {
1318 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
= s
->dma_dac2
.count
= s
->dma_dac2
.total_bytes
= 0;
1320 if (file
->f_mode
& FMODE_READ
) {
1323 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1327 case SNDCTL_DSP_SPEED
:
1328 get_user_ret(val
, (int *)arg
, -EFAULT
);
1330 if (s
->open_mode
& (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
))
1338 s
->dma_adc
.ready
= s
->dma_dac2
.ready
= 0;
1339 spin_lock_irqsave(&s
->lock
, flags
);
1340 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(val
) << CTRL_SH_PCLKDIV
);
1341 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1342 spin_unlock_irqrestore(&s
->lock
, flags
);
1344 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1346 case SNDCTL_DSP_STEREO
:
1347 get_user_ret(val
, (int *)arg
, -EFAULT
);
1348 if (file
->f_mode
& FMODE_READ
) {
1350 s
->dma_adc
.ready
= 0;
1351 spin_lock_irqsave(&s
->lock
, flags
);
1353 s
->sctrl
|= SCTRL_R1SMB
;
1355 s
->sctrl
&= ~SCTRL_R1SMB
;
1356 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1357 spin_unlock_irqrestore(&s
->lock
, flags
);
1359 if (file
->f_mode
& FMODE_WRITE
) {
1361 s
->dma_dac2
.ready
= 0;
1362 spin_lock_irqsave(&s
->lock
, flags
);
1364 s
->sctrl
|= SCTRL_P2SMB
;
1366 s
->sctrl
&= ~SCTRL_P2SMB
;
1367 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1368 spin_unlock_irqrestore(&s
->lock
, flags
);
1372 case SNDCTL_DSP_CHANNELS
:
1373 get_user_ret(val
, (int *)arg
, -EFAULT
);
1375 if (file
->f_mode
& FMODE_READ
) {
1377 s
->dma_adc
.ready
= 0;
1378 spin_lock_irqsave(&s
->lock
, flags
);
1380 s
->sctrl
|= SCTRL_R1SMB
;
1382 s
->sctrl
&= ~SCTRL_R1SMB
;
1383 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1384 spin_unlock_irqrestore(&s
->lock
, flags
);
1386 if (file
->f_mode
& FMODE_WRITE
) {
1388 s
->dma_dac2
.ready
= 0;
1389 spin_lock_irqsave(&s
->lock
, flags
);
1391 s
->sctrl
|= SCTRL_P2SMB
;
1393 s
->sctrl
&= ~SCTRL_P2SMB
;
1394 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1395 spin_unlock_irqrestore(&s
->lock
, flags
);
1398 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ? 2 : 1, (int *)arg
);
1400 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1401 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1403 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1404 get_user_ret(val
, (int *)arg
, -EFAULT
);
1405 if (val
!= AFMT_QUERY
) {
1406 if (file
->f_mode
& FMODE_READ
) {
1408 s
->dma_adc
.ready
= 0;
1409 spin_lock_irqsave(&s
->lock
, flags
);
1410 if (val
== AFMT_S16_LE
)
1411 s
->sctrl
|= SCTRL_R1SEB
;
1413 s
->sctrl
&= ~SCTRL_R1SEB
;
1414 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1415 spin_unlock_irqrestore(&s
->lock
, flags
);
1417 if (file
->f_mode
& FMODE_WRITE
) {
1419 s
->dma_dac2
.ready
= 0;
1420 spin_lock_irqsave(&s
->lock
, flags
);
1421 if (val
== AFMT_S16_LE
)
1422 s
->sctrl
|= SCTRL_P2SEB
;
1424 s
->sctrl
&= ~SCTRL_P2SEB
;
1425 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1426 spin_unlock_irqrestore(&s
->lock
, flags
);
1429 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1430 AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1432 case SNDCTL_DSP_POST
:
1435 case SNDCTL_DSP_GETTRIGGER
:
1437 if (file
->f_mode
& FMODE_READ
&& s
->ctrl
& CTRL_ADC_EN
)
1438 val
|= PCM_ENABLE_INPUT
;
1439 if (file
->f_mode
& FMODE_WRITE
&& s
->ctrl
& CTRL_DAC2_EN
)
1440 val
|= PCM_ENABLE_OUTPUT
;
1441 return put_user(val
, (int *)arg
);
1443 case SNDCTL_DSP_SETTRIGGER
:
1444 get_user_ret(val
, (int *)arg
, -EFAULT
);
1445 if (file
->f_mode
& FMODE_READ
) {
1446 if (val
& PCM_ENABLE_INPUT
) {
1447 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1453 if (file
->f_mode
& FMODE_WRITE
) {
1454 if (val
& PCM_ENABLE_OUTPUT
) {
1455 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1463 case SNDCTL_DSP_GETOSPACE
:
1464 if (!(file
->f_mode
& FMODE_WRITE
))
1466 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac2(s
)) != 0)
1468 spin_lock_irqsave(&s
->lock
, flags
);
1469 es1370_update_ptr(s
);
1470 abinfo
.fragsize
= s
->dma_dac2
.fragsize
;
1471 abinfo
.bytes
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1472 abinfo
.fragstotal
= s
->dma_dac2
.numfrag
;
1473 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac2
.fragshift
;
1474 spin_unlock_irqrestore(&s
->lock
, flags
);
1475 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1477 case SNDCTL_DSP_GETISPACE
:
1478 if (!(file
->f_mode
& FMODE_READ
))
1480 if (!(s
->ctrl
& CTRL_ADC_EN
) && (val
= prog_dmabuf_adc(s
)) != 0)
1482 spin_lock_irqsave(&s
->lock
, flags
);
1483 es1370_update_ptr(s
);
1484 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1485 abinfo
.bytes
= s
->dma_adc
.count
;
1486 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1487 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1488 spin_unlock_irqrestore(&s
->lock
, flags
);
1489 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1491 case SNDCTL_DSP_NONBLOCK
:
1492 file
->f_flags
|= O_NONBLOCK
;
1495 case SNDCTL_DSP_GETODELAY
:
1496 if (!(file
->f_mode
& FMODE_WRITE
))
1498 spin_lock_irqsave(&s
->lock
, flags
);
1499 es1370_update_ptr(s
);
1500 val
= s
->dma_dac2
.count
;
1501 spin_unlock_irqrestore(&s
->lock
, flags
);
1502 return put_user(val
, (int *)arg
);
1504 case SNDCTL_DSP_GETIPTR
:
1505 if (!(file
->f_mode
& FMODE_READ
))
1507 spin_lock_irqsave(&s
->lock
, flags
);
1508 es1370_update_ptr(s
);
1509 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1510 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1511 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1512 if (s
->dma_adc
.mapped
)
1513 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1514 spin_unlock_irqrestore(&s
->lock
, flags
);
1515 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1517 case SNDCTL_DSP_GETOPTR
:
1518 if (!(file
->f_mode
& FMODE_WRITE
))
1520 spin_lock_irqsave(&s
->lock
, flags
);
1521 es1370_update_ptr(s
);
1522 cinfo
.bytes
= s
->dma_dac2
.total_bytes
;
1523 cinfo
.blocks
= s
->dma_dac2
.count
>> s
->dma_dac2
.fragshift
;
1524 cinfo
.ptr
= s
->dma_dac2
.hwptr
;
1525 if (s
->dma_dac2
.mapped
)
1526 s
->dma_dac2
.count
&= s
->dma_dac2
.fragsize
-1;
1527 spin_unlock_irqrestore(&s
->lock
, flags
);
1528 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1530 case SNDCTL_DSP_GETBLKSIZE
:
1531 if (file
->f_mode
& FMODE_WRITE
) {
1532 if ((val
= prog_dmabuf_dac2(s
)))
1534 return put_user(s
->dma_dac2
.fragsize
, (int *)arg
);
1536 if ((val
= prog_dmabuf_adc(s
)))
1538 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1540 case SNDCTL_DSP_SETFRAGMENT
:
1541 get_user_ret(val
, (int *)arg
, -EFAULT
);
1542 if (file
->f_mode
& FMODE_READ
) {
1543 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1544 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1545 if (s
->dma_adc
.ossfragshift
< 4)
1546 s
->dma_adc
.ossfragshift
= 4;
1547 if (s
->dma_adc
.ossfragshift
> 15)
1548 s
->dma_adc
.ossfragshift
= 15;
1549 if (s
->dma_adc
.ossmaxfrags
< 4)
1550 s
->dma_adc
.ossmaxfrags
= 4;
1552 if (file
->f_mode
& FMODE_WRITE
) {
1553 s
->dma_dac2
.ossfragshift
= val
& 0xffff;
1554 s
->dma_dac2
.ossmaxfrags
= (val
>> 16) & 0xffff;
1555 if (s
->dma_dac2
.ossfragshift
< 4)
1556 s
->dma_dac2
.ossfragshift
= 4;
1557 if (s
->dma_dac2
.ossfragshift
> 15)
1558 s
->dma_dac2
.ossfragshift
= 15;
1559 if (s
->dma_dac2
.ossmaxfrags
< 4)
1560 s
->dma_dac2
.ossmaxfrags
= 4;
1564 case SNDCTL_DSP_SUBDIVIDE
:
1565 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1566 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac2
.subdivision
))
1568 get_user_ret(val
, (int *)arg
, -EFAULT
);
1569 if (val
!= 1 && val
!= 2 && val
!= 4)
1571 if (file
->f_mode
& FMODE_READ
)
1572 s
->dma_adc
.subdivision
= val
;
1573 if (file
->f_mode
& FMODE_WRITE
)
1574 s
->dma_dac2
.subdivision
= val
;
1577 case SOUND_PCM_READ_RATE
:
1578 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1580 case SOUND_PCM_READ_CHANNELS
:
1581 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ?
1584 case SOUND_PCM_READ_BITS
:
1585 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1586 16 : 8, (int *)arg
);
1588 case SOUND_PCM_WRITE_FILTER
:
1589 case SNDCTL_DSP_SETSYNCRO
:
1590 case SOUND_PCM_READ_FILTER
:
1594 return mixer_ioctl(s
, cmd
, arg
);
1597 static int es1370_open(struct inode
*inode
, struct file
*file
)
1599 int minor
= MINOR(inode
->i_rdev
);
1600 struct es1370_state
*s
= devs
;
1601 unsigned long flags
;
1603 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1608 file
->private_data
= s
;
1609 /* wait for device to become free */
1611 while (s
->open_mode
& file
->f_mode
) {
1612 if (file
->f_flags
& O_NONBLOCK
) {
1617 interruptible_sleep_on(&s
->open_wait
);
1618 if (signal_pending(current
))
1619 return -ERESTARTSYS
;
1622 spin_lock_irqsave(&s
->lock
, flags
);
1623 if (!(s
->open_mode
& (FMODE_READ
|FMODE_WRITE
)))
1624 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
);
1625 if (file
->f_mode
& FMODE_READ
) {
1626 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1627 s
->sctrl
&= ~SCTRL_R1FMT
;
1628 if ((minor
& 0xf) == SND_DEV_DSP16
)
1629 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_R1FMT
;
1631 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_R1FMT
;
1633 if (file
->f_mode
& FMODE_WRITE
) {
1634 s
->dma_dac2
.ossfragshift
= s
->dma_dac2
.ossmaxfrags
= s
->dma_dac2
.subdivision
= 0;
1635 s
->sctrl
&= ~SCTRL_P2FMT
;
1636 if ((minor
& 0xf) == SND_DEV_DSP16
)
1637 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P2FMT
;
1639 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P2FMT
;
1641 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1642 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1643 spin_unlock_irqrestore(&s
->lock
, flags
);
1644 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1650 static int es1370_release(struct inode
*inode
, struct file
*file
)
1652 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1655 if (file
->f_mode
& FMODE_WRITE
)
1656 drain_dac2(s
, file
->f_flags
& O_NONBLOCK
);
1658 if (file
->f_mode
& FMODE_WRITE
) {
1661 dealloc_dmabuf(&s
->dma_dac2
);
1663 if (file
->f_mode
& FMODE_READ
) {
1665 dealloc_dmabuf(&s
->dma_adc
);
1667 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1669 wake_up(&s
->open_wait
);
1674 static /*const*/ struct file_operations es1370_audio_fops
= {
1687 NULL
, /* check_media_change */
1688 NULL
, /* revalidate */
1692 /* --------------------------------------------------------------------- */
1694 static ssize_t
es1370_write_dac(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1696 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1698 unsigned long flags
;
1703 if (ppos
!= &file
->f_pos
)
1705 if (s
->dma_dac1
.mapped
)
1707 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1709 if (!access_ok(VERIFY_READ
, buffer
, count
))
1712 spin_lock_irqsave(&s
->lock
, flags
);
1713 if (s
->dma_dac1
.count
< 0) {
1714 s
->dma_dac1
.count
= 0;
1715 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
;
1717 swptr
= s
->dma_dac1
.swptr
;
1718 cnt
= s
->dma_dac1
.dmasize
-swptr
;
1719 if (s
->dma_dac1
.count
+ cnt
> s
->dma_dac1
.dmasize
)
1720 cnt
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1721 spin_unlock_irqrestore(&s
->lock
, flags
);
1726 if (file
->f_flags
& O_NONBLOCK
)
1727 return ret
? ret
: -EAGAIN
;
1728 interruptible_sleep_on(&s
->dma_dac1
.wait
);
1729 if (signal_pending(current
))
1730 return ret
? ret
: -ERESTARTSYS
;
1733 if (copy_from_user(s
->dma_dac1
.rawbuf
+ swptr
, buffer
, cnt
))
1734 return ret
? ret
: -EFAULT
;
1735 swptr
= (swptr
+ cnt
) % s
->dma_dac1
.dmasize
;
1736 spin_lock_irqsave(&s
->lock
, flags
);
1737 s
->dma_dac1
.swptr
= swptr
;
1738 s
->dma_dac1
.count
+= cnt
;
1739 s
->dma_dac1
.endcleared
= 0;
1740 spin_unlock_irqrestore(&s
->lock
, flags
);
1749 static unsigned int es1370_poll_dac(struct file
*file
, struct poll_table_struct
*wait
)
1751 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1752 unsigned long flags
;
1753 unsigned int mask
= 0;
1756 poll_wait(file
, &s
->dma_dac1
.wait
, wait
);
1757 spin_lock_irqsave(&s
->lock
, flags
);
1758 es1370_update_ptr(s
);
1759 if (s
->dma_dac1
.mapped
) {
1760 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
1761 mask
|= POLLOUT
| POLLWRNORM
;
1763 if ((signed)s
->dma_dac1
.dmasize
>= s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
)
1764 mask
|= POLLOUT
| POLLWRNORM
;
1766 spin_unlock_irqrestore(&s
->lock
, flags
);
1770 static int es1370_mmap_dac(struct file
*file
, struct vm_area_struct
*vma
)
1772 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1777 if (!(vma
->vm_flags
& VM_WRITE
))
1779 if ((ret
= prog_dmabuf_dac1(s
)) != 0)
1781 if (vma
->vm_offset
!= 0)
1783 size
= vma
->vm_end
- vma
->vm_start
;
1784 if (size
> (PAGE_SIZE
<< s
->dma_dac1
.buforder
))
1786 if (remap_page_range(vma
->vm_start
, virt_to_phys(s
->dma_dac1
.rawbuf
), size
, vma
->vm_page_prot
))
1788 s
->dma_dac1
.mapped
= 1;
1792 static int es1370_ioctl_dac(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1794 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1795 unsigned long flags
;
1796 audio_buf_info abinfo
;
1803 case OSS_GETVERSION
:
1804 return put_user(SOUND_VERSION
, (int *)arg
);
1806 case SNDCTL_DSP_SYNC
:
1807 return drain_dac1(s
, 0/*file->f_flags & O_NONBLOCK*/);
1809 case SNDCTL_DSP_SETDUPLEX
:
1812 case SNDCTL_DSP_GETCAPS
:
1813 return put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1815 case SNDCTL_DSP_RESET
:
1818 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
= s
->dma_dac1
.count
= s
->dma_dac1
.total_bytes
= 0;
1821 case SNDCTL_DSP_SPEED
:
1822 get_user_ret(val
, (int *)arg
, -EFAULT
);
1825 s
->dma_dac1
.ready
= 0;
1826 for (ctrl
= 0; ctrl
<= 2; ctrl
++)
1827 if (val
< (dac1_samplerate
[ctrl
] + dac1_samplerate
[ctrl
+1]) / 2)
1829 spin_lock_irqsave(&s
->lock
, flags
);
1830 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (ctrl
<< CTRL_SH_WTSRSEL
);
1831 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1832 spin_unlock_irqrestore(&s
->lock
, flags
);
1834 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1836 case SNDCTL_DSP_STEREO
:
1837 get_user_ret(val
, (int *)arg
, -EFAULT
);
1839 s
->dma_dac1
.ready
= 0;
1840 spin_lock_irqsave(&s
->lock
, flags
);
1842 s
->sctrl
|= SCTRL_P1SMB
;
1844 s
->sctrl
&= ~SCTRL_P1SMB
;
1845 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1846 spin_unlock_irqrestore(&s
->lock
, flags
);
1849 case SNDCTL_DSP_CHANNELS
:
1850 get_user_ret(val
, (int *)arg
, -EFAULT
);
1852 if (s
->dma_dac1
.mapped
)
1855 s
->dma_dac1
.ready
= 0;
1856 spin_lock_irqsave(&s
->lock
, flags
);
1858 s
->sctrl
|= SCTRL_P1SMB
;
1860 s
->sctrl
&= ~SCTRL_P1SMB
;
1861 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1862 spin_unlock_irqrestore(&s
->lock
, flags
);
1864 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1866 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1867 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1869 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1870 get_user_ret(val
, (int *)arg
, -EFAULT
);
1871 if (val
!= AFMT_QUERY
) {
1873 s
->dma_dac1
.ready
= 0;
1874 spin_lock_irqsave(&s
->lock
, flags
);
1875 if (val
== AFMT_S16_LE
)
1876 s
->sctrl
|= SCTRL_P1SEB
;
1878 s
->sctrl
&= ~SCTRL_P1SEB
;
1879 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1880 spin_unlock_irqrestore(&s
->lock
, flags
);
1882 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1884 case SNDCTL_DSP_POST
:
1887 case SNDCTL_DSP_GETTRIGGER
:
1888 return put_user((s
->ctrl
& CTRL_DAC1_EN
) ? PCM_ENABLE_OUTPUT
: 0, (int *)arg
);
1890 case SNDCTL_DSP_SETTRIGGER
:
1891 get_user_ret(val
, (int *)arg
, -EFAULT
);
1892 if (val
& PCM_ENABLE_OUTPUT
) {
1893 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1900 case SNDCTL_DSP_GETOSPACE
:
1901 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac1(s
)) != 0)
1903 spin_lock_irqsave(&s
->lock
, flags
);
1904 es1370_update_ptr(s
);
1905 abinfo
.fragsize
= s
->dma_dac1
.fragsize
;
1906 abinfo
.bytes
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1907 abinfo
.fragstotal
= s
->dma_dac1
.numfrag
;
1908 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac1
.fragshift
;
1909 spin_unlock_irqrestore(&s
->lock
, flags
);
1910 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1912 case SNDCTL_DSP_NONBLOCK
:
1913 file
->f_flags
|= O_NONBLOCK
;
1916 case SNDCTL_DSP_GETODELAY
:
1917 spin_lock_irqsave(&s
->lock
, flags
);
1918 es1370_update_ptr(s
);
1919 val
= s
->dma_dac1
.count
;
1920 spin_unlock_irqrestore(&s
->lock
, flags
);
1921 return put_user(val
, (int *)arg
);
1923 case SNDCTL_DSP_GETOPTR
:
1924 if (!(file
->f_mode
& FMODE_WRITE
))
1926 spin_lock_irqsave(&s
->lock
, flags
);
1927 es1370_update_ptr(s
);
1928 cinfo
.bytes
= s
->dma_dac1
.total_bytes
;
1929 cinfo
.blocks
= s
->dma_dac1
.count
>> s
->dma_dac1
.fragshift
;
1930 cinfo
.ptr
= s
->dma_dac1
.hwptr
;
1931 if (s
->dma_dac1
.mapped
)
1932 s
->dma_dac1
.count
&= s
->dma_dac1
.fragsize
-1;
1933 spin_unlock_irqrestore(&s
->lock
, flags
);
1934 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1936 case SNDCTL_DSP_GETBLKSIZE
:
1937 if ((val
= prog_dmabuf_dac1(s
)))
1939 return put_user(s
->dma_dac1
.fragsize
, (int *)arg
);
1941 case SNDCTL_DSP_SETFRAGMENT
:
1942 get_user_ret(val
, (int *)arg
, -EFAULT
);
1943 s
->dma_dac1
.ossfragshift
= val
& 0xffff;
1944 s
->dma_dac1
.ossmaxfrags
= (val
>> 16) & 0xffff;
1945 if (s
->dma_dac1
.ossfragshift
< 4)
1946 s
->dma_dac1
.ossfragshift
= 4;
1947 if (s
->dma_dac1
.ossfragshift
> 15)
1948 s
->dma_dac1
.ossfragshift
= 15;
1949 if (s
->dma_dac1
.ossmaxfrags
< 4)
1950 s
->dma_dac1
.ossmaxfrags
= 4;
1953 case SNDCTL_DSP_SUBDIVIDE
:
1954 if (s
->dma_dac1
.subdivision
)
1956 get_user_ret(val
, (int *)arg
, -EFAULT
);
1957 if (val
!= 1 && val
!= 2 && val
!= 4)
1959 s
->dma_dac1
.subdivision
= val
;
1962 case SOUND_PCM_READ_RATE
:
1963 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1965 case SOUND_PCM_READ_CHANNELS
:
1966 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1968 case SOUND_PCM_READ_BITS
:
1969 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? 16 : 8, (int *)arg
);
1971 case SOUND_PCM_WRITE_FILTER
:
1972 case SNDCTL_DSP_SETSYNCRO
:
1973 case SOUND_PCM_READ_FILTER
:
1977 return mixer_ioctl(s
, cmd
, arg
);
1980 static int es1370_open_dac(struct inode
*inode
, struct file
*file
)
1982 int minor
= MINOR(inode
->i_rdev
);
1983 struct es1370_state
*s
= devs
;
1984 unsigned long flags
;
1986 while (s
&& ((s
->dev_dac
^ minor
) & ~0xf))
1991 /* we allow opening with O_RDWR, most programs do it although they will only write */
1993 if (file
->f_mode
& FMODE_READ
)
1996 if (!(file
->f_mode
& FMODE_WRITE
))
1998 file
->private_data
= s
;
1999 /* wait for device to become free */
2001 while (s
->open_mode
& FMODE_DAC
) {
2002 if (file
->f_flags
& O_NONBLOCK
) {
2007 interruptible_sleep_on(&s
->open_wait
);
2008 if (signal_pending(current
))
2009 return -ERESTARTSYS
;
2012 s
->dma_dac1
.ossfragshift
= s
->dma_dac1
.ossmaxfrags
= s
->dma_dac1
.subdivision
= 0;
2013 spin_lock_irqsave(&s
->lock
, flags
);
2014 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (1 << CTRL_SH_WTSRSEL
);
2015 s
->sctrl
&= ~SCTRL_P1FMT
;
2016 if ((minor
& 0xf) == SND_DEV_DSP16
)
2017 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P1FMT
;
2019 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P1FMT
;
2020 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2021 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2022 spin_unlock_irqrestore(&s
->lock
, flags
);
2023 s
->open_mode
|= FMODE_DAC
;
2029 static int es1370_release_dac(struct inode
*inode
, struct file
*file
)
2031 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2034 drain_dac1(s
, file
->f_flags
& O_NONBLOCK
);
2037 dealloc_dmabuf(&s
->dma_dac1
);
2038 s
->open_mode
&= ~FMODE_DAC
;
2040 wake_up(&s
->open_wait
);
2045 static /*const*/ struct file_operations es1370_dac_fops
= {
2055 &es1370_release_dac
,
2058 NULL
, /* check_media_change */
2059 NULL
, /* revalidate */
2063 /* --------------------------------------------------------------------- */
2065 static ssize_t
es1370_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
2067 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2069 unsigned long flags
;
2074 if (ppos
!= &file
->f_pos
)
2076 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2080 spin_lock_irqsave(&s
->lock
, flags
);
2082 cnt
= MIDIINBUF
- ptr
;
2083 if (s
->midi
.icnt
< cnt
)
2085 spin_unlock_irqrestore(&s
->lock
, flags
);
2089 if (file
->f_flags
& O_NONBLOCK
)
2090 return ret
? ret
: -EAGAIN
;
2091 interruptible_sleep_on(&s
->midi
.iwait
);
2092 if (signal_pending(current
))
2093 return ret
? ret
: -ERESTARTSYS
;
2096 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
))
2097 return ret
? ret
: -EFAULT
;
2098 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
2099 spin_lock_irqsave(&s
->lock
, flags
);
2101 s
->midi
.icnt
-= cnt
;
2102 spin_unlock_irqrestore(&s
->lock
, flags
);
2110 static ssize_t
es1370_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
2112 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2114 unsigned long flags
;
2119 if (ppos
!= &file
->f_pos
)
2121 if (!access_ok(VERIFY_READ
, buffer
, count
))
2125 spin_lock_irqsave(&s
->lock
, flags
);
2127 cnt
= MIDIOUTBUF
- ptr
;
2128 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
2129 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
2131 es1370_handle_midi(s
);
2132 spin_unlock_irqrestore(&s
->lock
, flags
);
2136 if (file
->f_flags
& O_NONBLOCK
)
2137 return ret
? ret
: -EAGAIN
;
2138 interruptible_sleep_on(&s
->midi
.owait
);
2139 if (signal_pending(current
))
2140 return ret
? ret
: -ERESTARTSYS
;
2143 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
))
2144 return ret
? ret
: -EFAULT
;
2145 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
2146 spin_lock_irqsave(&s
->lock
, flags
);
2148 s
->midi
.ocnt
+= cnt
;
2149 spin_unlock_irqrestore(&s
->lock
, flags
);
2153 spin_lock_irqsave(&s
->lock
, flags
);
2154 es1370_handle_midi(s
);
2155 spin_unlock_irqrestore(&s
->lock
, flags
);
2160 static unsigned int es1370_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2162 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2163 unsigned long flags
;
2164 unsigned int mask
= 0;
2167 if (file
->f_mode
& FMODE_WRITE
)
2168 poll_wait(file
, &s
->midi
.owait
, wait
);
2169 if (file
->f_mode
& FMODE_READ
)
2170 poll_wait(file
, &s
->midi
.iwait
, wait
);
2171 spin_lock_irqsave(&s
->lock
, flags
);
2172 if (file
->f_mode
& FMODE_READ
) {
2173 if (s
->midi
.icnt
> 0)
2174 mask
|= POLLIN
| POLLRDNORM
;
2176 if (file
->f_mode
& FMODE_WRITE
) {
2177 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2178 mask
|= POLLOUT
| POLLWRNORM
;
2180 spin_unlock_irqrestore(&s
->lock
, flags
);
2184 static int es1370_midi_open(struct inode
*inode
, struct file
*file
)
2186 int minor
= MINOR(inode
->i_rdev
);
2187 struct es1370_state
*s
= devs
;
2188 unsigned long flags
;
2190 while (s
&& s
->dev_midi
!= minor
)
2195 file
->private_data
= s
;
2196 /* wait for device to become free */
2198 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2199 if (file
->f_flags
& O_NONBLOCK
) {
2204 interruptible_sleep_on(&s
->open_wait
);
2205 if (signal_pending(current
))
2206 return -ERESTARTSYS
;
2209 spin_lock_irqsave(&s
->lock
, flags
);
2210 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2211 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2212 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2213 outb(UCTRL_CNTRL_SWR
, s
->io
+ES1370_REG_UART_CONTROL
);
2214 outb(0, s
->io
+ES1370_REG_UART_CONTROL
);
2215 outb(0, s
->io
+ES1370_REG_UART_TEST
);
2217 if (file
->f_mode
& FMODE_READ
) {
2218 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2220 if (file
->f_mode
& FMODE_WRITE
) {
2221 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2223 s
->ctrl
|= CTRL_UART_EN
;
2224 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2225 es1370_handle_midi(s
);
2226 spin_unlock_irqrestore(&s
->lock
, flags
);
2227 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2233 static int es1370_midi_release(struct inode
*inode
, struct file
*file
)
2235 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2236 DECLARE_WAITQUEUE(wait
, current
);
2237 unsigned long flags
;
2238 unsigned count
, tmo
;
2242 if (file
->f_mode
& FMODE_WRITE
) {
2243 current
->state
= TASK_INTERRUPTIBLE
;
2244 add_wait_queue(&s
->midi
.owait
, &wait
);
2246 spin_lock_irqsave(&s
->lock
, flags
);
2247 count
= s
->midi
.ocnt
;
2248 spin_unlock_irqrestore(&s
->lock
, flags
);
2251 if (signal_pending(current
))
2253 if (file
->f_flags
& O_NONBLOCK
) {
2254 remove_wait_queue(&s
->midi
.owait
, &wait
);
2255 current
->state
= TASK_RUNNING
;
2258 tmo
= (count
* HZ
) / 3100;
2259 if (!schedule_timeout(tmo
? : 1) && tmo
)
2260 DBG(printk(KERN_DEBUG
"es1370: midi timed out??\n");)
2262 remove_wait_queue(&s
->midi
.owait
, &wait
);
2263 current
->state
= TASK_RUNNING
;
2266 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2267 spin_lock_irqsave(&s
->lock
, flags
);
2268 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2269 s
->ctrl
&= ~CTRL_UART_EN
;
2270 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2272 spin_unlock_irqrestore(&s
->lock
, flags
);
2274 wake_up(&s
->open_wait
);
2279 static /*const*/ struct file_operations es1370_midi_fops
= {
2289 &es1370_midi_release
,
2292 NULL
, /* check_media_change */
2293 NULL
, /* revalidate */
2297 /* --------------------------------------------------------------------- */
2299 /* maximum number of devices */
2302 static int joystick
[NR_DEVICE
] = { 0, };
2303 static int lineout
[NR_DEVICE
] = { 0, };
2304 static int micbias
[NR_DEVICE
] = { 0, };
2306 MODULE_PARM(joystick
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2307 MODULE_PARM_DESC(joystick
, "if 1 enables joystick interface (still need separate driver)");
2308 MODULE_PARM(lineout
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2309 MODULE_PARM_DESC(lineout
, "if 1 the LINE input is converted to LINE out");
2310 MODULE_PARM(micbias
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2311 MODULE_PARM_DESC(micbias
, "sets the +5V bias for an electret microphone");
2313 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2314 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2316 /* --------------------------------------------------------------------- */
2318 static struct initvol
{
2321 } initvol
[] __initdata
= {
2322 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2323 { SOUND_MIXER_WRITE_PCM
, 0x4040 },
2324 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2325 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2326 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2327 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2328 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2329 { SOUND_MIXER_WRITE_LINE3
, 0x4040 },
2330 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2331 { SOUND_MIXER_WRITE_OGAIN
, 0x4040 }
2334 static int __init
init_es1370(void)
2336 struct es1370_state
*s
;
2337 struct pci_dev
*pcidev
= NULL
;
2339 int i
, val
, index
= 0;
2341 if (!pci_present()) /* No PCI bus in this machine! */
2343 printk(KERN_INFO
"es1370: version v0.27 time " __TIME__
" " __DATE__
"\n");
2344 while (index
< NR_DEVICE
&&
2345 (pcidev
= pci_find_device(PCI_VENDOR_ID_ENSONIQ
, PCI_DEVICE_ID_ENSONIQ_ES1370
, pcidev
))) {
2346 if (pcidev
->resource
[0].flags
== 0 ||
2347 (pcidev
->resource
[0].flags
& PCI_BASE_ADDRESS_SPACE
) != PCI_BASE_ADDRESS_SPACE_IO
)
2349 if (pcidev
->irq
== 0)
2351 if (!(s
= kmalloc(sizeof(struct es1370_state
), GFP_KERNEL
))) {
2352 printk(KERN_WARNING
"es1370: out of memory\n");
2355 memset(s
, 0, sizeof(struct es1370_state
));
2356 init_waitqueue_head(&s
->dma_adc
.wait
);
2357 init_waitqueue_head(&s
->dma_dac1
.wait
);
2358 init_waitqueue_head(&s
->dma_dac2
.wait
);
2359 init_waitqueue_head(&s
->open_wait
);
2360 init_waitqueue_head(&s
->midi
.iwait
);
2361 init_waitqueue_head(&s
->midi
.owait
);
2362 init_MUTEX(&s
->open_sem
);
2363 s
->magic
= ES1370_MAGIC
;
2364 s
->io
= pcidev
->resource
[0].start
;
2365 s
->irq
= pcidev
->irq
;
2366 if (check_region(s
->io
, ES1370_EXTENT
)) {
2367 printk(KERN_ERR
"es1370: io ports %#lx-%#lx in use\n", s
->io
, s
->io
+ES1370_EXTENT
-1);
2370 request_region(s
->io
, ES1370_EXTENT
, "es1370");
2371 if (request_irq(s
->irq
, es1370_interrupt
, SA_SHIRQ
, "es1370", s
)) {
2372 printk(KERN_ERR
"es1370: irq %u in use\n", s
->irq
);
2375 /* initialize codec registers */
2376 /* note: setting CTRL_SERR_DIS is reported to break
2377 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2378 s
->ctrl
= CTRL_CDC_EN
| (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
) | (1 << CTRL_SH_WTSRSEL
);
2379 if (joystick
[index
]) {
2380 if (check_region(0x200, JOY_EXTENT
))
2381 printk(KERN_ERR
"es1370: io port 0x200 in use\n");
2383 s
->ctrl
|= CTRL_JYSTK_EN
;
2386 s
->ctrl
|= CTRL_XCTL0
;
2388 s
->ctrl
|= CTRL_XCTL1
;
2390 printk(KERN_INFO
"es1370: found adapter at io %#lx irq %u\n"
2391 KERN_INFO
"es1370: features: joystick %s, line %s, mic impedance %s\n",
2392 s
->io
, s
->irq
, (s
->ctrl
& CTRL_JYSTK_EN
) ? "on" : "off",
2393 (s
->ctrl
& CTRL_XCTL0
) ? "out" : "in",
2394 (s
->ctrl
& CTRL_XCTL1
) ? "1" : "0");
2395 /* register devices */
2396 if ((s
->dev_audio
= register_sound_dsp(&es1370_audio_fops
, -1)) < 0)
2398 if ((s
->dev_mixer
= register_sound_mixer(&es1370_mixer_fops
, -1)) < 0)
2400 if ((s
->dev_dac
= register_sound_dsp(&es1370_dac_fops
, -1)) < 0)
2402 if ((s
->dev_midi
= register_sound_midi(&es1370_midi_fops
, -1)) < 0)
2404 /* initialize the chips */
2405 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2406 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2407 /* point phantom write channel to "bugbuf" */
2408 outl((ES1370_REG_PHANTOM_FRAMEADR
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
2409 outl(virt_to_bus(bugbuf
), s
->io
+(ES1370_REG_PHANTOM_FRAMEADR
& 0xff));
2410 outl(0, s
->io
+(ES1370_REG_PHANTOM_FRAMECNT
& 0xff));
2411 pci_set_master(pcidev
); /* enable bus mastering */
2412 wrcodec(s
, 0x16, 3); /* no RST, PD */
2413 wrcodec(s
, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2414 wrcodec(s
, 0x18, 0); /* recording source is mixer */
2415 wrcodec(s
, 0x19, s
->mix
.micpreamp
= 1); /* turn on MIC preamp */
2419 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
;
2420 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2421 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2422 val
= initvol
[i
].vol
;
2423 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2426 /* queue it for later freeing */
2433 unregister_sound_dsp(s
->dev_dac
);
2435 unregister_sound_mixer(s
->dev_mixer
);
2437 unregister_sound_dsp(s
->dev_audio
);
2439 printk(KERN_ERR
"es1370: cannot register misc device\n");
2440 free_irq(s
->irq
, s
);
2442 release_region(s
->io
, ES1370_EXTENT
);
2444 kfree_s(s
, sizeof(struct es1370_state
));
2451 static void __exit
cleanup_es1370(void)
2453 struct es1370_state
*s
;
2455 while ((s
= devs
)) {
2457 outl(CTRL_SERR_DIS
| (1 << CTRL_SH_WTSRSEL
), s
->io
+ES1370_REG_CONTROL
); /* switch everything off */
2458 outl(0, s
->io
+ES1370_REG_SERIAL_CONTROL
); /* clear serial interrupts */
2460 free_irq(s
->irq
, s
);
2461 release_region(s
->io
, ES1370_EXTENT
);
2462 unregister_sound_dsp(s
->dev_audio
);
2463 unregister_sound_mixer(s
->dev_mixer
);
2464 unregister_sound_dsp(s
->dev_dac
);
2465 unregister_sound_midi(s
->dev_midi
);
2466 kfree_s(s
, sizeof(struct es1370_state
));
2468 printk(KERN_INFO
"es1370: unloading\n");
2471 module_init(init_es1370
);
2472 module_exit(cleanup_es1370
);
2474 /* --------------------------------------------------------------------- */
2478 /* format is: es1370=[joystick[,lineout[,micbias]]] */
2480 static int __init
es1370_setup(char *str
)
2482 static unsigned __initdata nr_dev
= 0;
2484 if (nr_dev
>= NR_DEVICE
)
2487 ( (get_option(&str
,&joystick
[nr_dev
]) == 2)
2488 && (get_option(&str
,&lineout
[nr_dev
]) == 2)
2489 && get_option(&str
,&micbias
[nr_dev
])
2496 __setup("es1370=", es1370_setup
);