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
105 * some important things missing in Ensoniq documentation:
107 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
108 * and vary PCLKDIV to obtain zero beat.
111 * seems to be fs = 1411200/(PCLKDIV+2)
113 * should find out when curr_sample_ct is cleared and
114 * where exactly the CCB fetches data
116 * The card uses a 22.5792 MHz crystal.
117 * The LINEIN jack may be converted to an AOUT jack by
118 * setting pin 47 (XCTL0) of the ES1370 to high.
119 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
124 /*****************************************************************************/
126 #include <linux/config.h>
127 #include <linux/version.h>
128 #include <linux/module.h>
129 #include <linux/string.h>
130 #include <linux/ioport.h>
131 #include <linux/sched.h>
132 #include <linux/delay.h>
133 #include <linux/sound.h>
134 #include <linux/malloc.h>
135 #include <linux/soundcard.h>
136 #include <linux/pci.h>
139 #include <linux/init.h>
140 #include <linux/poll.h>
141 #include <asm/spinlock.h>
142 #include <asm/uaccess.h>
143 #include <asm/hardirq.h>
145 /* --------------------------------------------------------------------- */
147 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
149 /*#define DBG(x) {x}*/
151 /* --------------------------------------------------------------------- */
153 #ifndef PCI_VENDOR_ID_ENSONIQ
154 #define PCI_VENDOR_ID_ENSONIQ 0x1274
156 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
157 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
160 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
162 #define ES1370_EXTENT 0x40
165 #define ES1370_REG_CONTROL 0x00
166 #define ES1370_REG_STATUS 0x04
167 #define ES1370_REG_UART_DATA 0x08
168 #define ES1370_REG_UART_STATUS 0x09
169 #define ES1370_REG_UART_CONTROL 0x09
170 #define ES1370_REG_UART_TEST 0x0a
171 #define ES1370_REG_MEMPAGE 0x0c
172 #define ES1370_REG_CODEC 0x10
173 #define ES1370_REG_SERIAL_CONTROL 0x20
174 #define ES1370_REG_DAC1_SCOUNT 0x24
175 #define ES1370_REG_DAC2_SCOUNT 0x28
176 #define ES1370_REG_ADC_SCOUNT 0x2c
178 #define ES1370_REG_DAC1_FRAMEADR 0xc30
179 #define ES1370_REG_DAC1_FRAMECNT 0xc34
180 #define ES1370_REG_DAC2_FRAMEADR 0xc38
181 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
182 #define ES1370_REG_ADC_FRAMEADR 0xd30
183 #define ES1370_REG_ADC_FRAMECNT 0xd34
185 #define ES1370_FMT_U8_MONO 0
186 #define ES1370_FMT_U8_STEREO 1
187 #define ES1370_FMT_S16_MONO 2
188 #define ES1370_FMT_S16_STEREO 3
189 #define ES1370_FMT_STEREO 1
190 #define ES1370_FMT_S16 2
191 #define ES1370_FMT_MASK 3
193 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
194 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
196 static const unsigned dac1_samplerate
[] = { 5512, 11025, 22050, 44100 };
198 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
199 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
201 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
202 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
203 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
204 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
205 #define CTRL_SH_PCLKDIV 16
206 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
207 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
208 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
209 #define CTRL_SH_WTSRSEL 12
210 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
211 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
212 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
213 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
214 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
215 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
216 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
217 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
218 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
219 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
220 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
221 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
223 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
224 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
225 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
226 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
227 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
229 #define STAT_MCCB 0x00000010 /* CCB int pending */
230 #define STAT_UART 0x00000008 /* UART int pending */
231 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
232 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
233 #define STAT_ADC 0x00000001 /* ADC int pending */
235 #define USTAT_RXINT 0x80 /* UART rx int pending */
236 #define USTAT_TXINT 0x04 /* UART tx int pending */
237 #define USTAT_TXRDY 0x02 /* UART tx ready */
238 #define USTAT_RXRDY 0x01 /* UART rx ready */
240 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
241 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
242 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
243 #define UCTRL_CNTRL 0x03 /* control field */
244 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
246 #define SCTRL_P2ENDINC 0x00380000 /* */
247 #define SCTRL_SH_P2ENDINC 19
248 #define SCTRL_P2STINC 0x00070000 /* */
249 #define SCTRL_SH_P2STINC 16
250 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
251 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
252 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
253 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
254 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
255 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
256 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
257 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
258 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
259 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
260 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
261 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
262 #define SCTRL_R1FMT 0x00000030 /* format mask */
263 #define SCTRL_SH_R1FMT 4
264 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
265 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
266 #define SCTRL_P2FMT 0x0000000c /* format mask */
267 #define SCTRL_SH_P2FMT 2
268 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
269 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
270 #define SCTRL_P1FMT 0x00000003 /* format mask */
271 #define SCTRL_SH_P1FMT 0
275 #define FMODE_DAC 4 /* slight misuse of mode_t */
277 /* MIDI buffer sizes */
279 #define MIDIINBUF 256
280 #define MIDIOUTBUF 256
282 #define FMODE_MIDI_SHIFT 3
283 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
284 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
286 #define SND_DEV_DSP16 5
288 /* --------------------------------------------------------------------- */
290 struct es1370_state
{
294 /* we keep sb cards in a linked list */
295 struct es1370_state
*next
;
297 /* soundcore stuff */
303 /* hardware resources */
304 unsigned long io
; /* long for SPARC */
307 /* mixer registers; there is no HW readback */
309 unsigned short vol
[10];
312 unsigned short micpreamp
;
321 struct semaphore open_sem
;
323 wait_queue_head_t open_wait
;
330 unsigned hwptr
, swptr
;
331 unsigned total_bytes
;
333 unsigned error
; /* over/underrun */
334 wait_queue_head_t wait
;
335 /* redundant, but makes calculations easier */
338 unsigned fragsamples
;
342 unsigned endcleared
:1;
343 unsigned ossfragshift
;
345 unsigned subdivision
;
346 } dma_dac1
, dma_dac2
, dma_adc
;
350 unsigned ird
, iwr
, icnt
;
351 unsigned ord
, owr
, ocnt
;
352 wait_queue_head_t iwait
;
353 wait_queue_head_t owait
;
354 unsigned char ibuf
[MIDIINBUF
];
355 unsigned char obuf
[MIDIOUTBUF
];
359 /* --------------------------------------------------------------------- */
361 static struct es1370_state
*devs
= NULL
;
363 /* --------------------------------------------------------------------- */
365 extern inline unsigned ld2(unsigned int x
)
390 /* --------------------------------------------------------------------- */
392 static void wrcodec(struct es1370_state
*s
, unsigned char idx
, unsigned char data
)
394 unsigned long tmo
= jiffies
+ HZ
/10;
397 if (!(inl(s
->io
+ES1370_REG_STATUS
) & STAT_CSTAT
)) {
398 outw((((unsigned short)idx
)<<8)|data
, s
->io
+ES1370_REG_CODEC
);
402 } while ((signed)(tmo
-jiffies
) > 0);
403 printk(KERN_ERR
"es1370: write to codec register timeout\n");
406 /* --------------------------------------------------------------------- */
408 extern inline void stop_adc(struct es1370_state
*s
)
412 spin_lock_irqsave(&s
->lock
, flags
);
413 s
->ctrl
&= ~CTRL_ADC_EN
;
414 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
415 spin_unlock_irqrestore(&s
->lock
, flags
);
418 extern inline void stop_dac1(struct es1370_state
*s
)
422 spin_lock_irqsave(&s
->lock
, flags
);
423 s
->ctrl
&= ~CTRL_DAC1_EN
;
424 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
425 spin_unlock_irqrestore(&s
->lock
, flags
);
428 extern inline void stop_dac2(struct es1370_state
*s
)
432 spin_lock_irqsave(&s
->lock
, flags
);
433 s
->ctrl
&= ~CTRL_DAC2_EN
;
434 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
435 spin_unlock_irqrestore(&s
->lock
, flags
);
438 static void start_dac1(struct es1370_state
*s
)
441 unsigned fragremain
, fshift
;
443 spin_lock_irqsave(&s
->lock
, flags
);
444 if (!(s
->ctrl
& CTRL_DAC1_EN
) && (s
->dma_dac1
.mapped
|| s
->dma_dac1
.count
> 0)
445 && s
->dma_dac1
.ready
) {
446 s
->ctrl
|= CTRL_DAC1_EN
;
447 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P1LOOPSEL
| SCTRL_P1PAUSE
| SCTRL_P1SCTRLD
)) | SCTRL_P1INTEN
;
448 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
449 fragremain
= ((- s
->dma_dac1
.hwptr
) & (s
->dma_dac1
.fragsize
-1));
450 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
451 if (fragremain
< 2*fshift
)
452 fragremain
= s
->dma_dac1
.fragsize
;
453 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
454 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
455 outl((s
->dma_dac1
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC1_SCOUNT
);
457 spin_unlock_irqrestore(&s
->lock
, flags
);
460 static void start_dac2(struct es1370_state
*s
)
463 unsigned fragremain
, fshift
;
465 spin_lock_irqsave(&s
->lock
, flags
);
466 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (s
->dma_dac2
.mapped
|| s
->dma_dac2
.count
> 0)
467 && s
->dma_dac2
.ready
) {
468 s
->ctrl
|= CTRL_DAC2_EN
;
469 s
->sctrl
= (s
->sctrl
& ~(SCTRL_P2LOOPSEL
| SCTRL_P2PAUSE
| SCTRL_P2DACSEN
|
470 SCTRL_P2ENDINC
| SCTRL_P2STINC
)) | SCTRL_P2INTEN
|
471 (((s
->sctrl
& SCTRL_P2FMT
) ? 2 : 1) << SCTRL_SH_P2ENDINC
) |
472 (0 << SCTRL_SH_P2STINC
);
473 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
474 fragremain
= ((- s
->dma_dac2
.hwptr
) & (s
->dma_dac2
.fragsize
-1));
475 fshift
= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
476 if (fragremain
< 2*fshift
)
477 fragremain
= s
->dma_dac2
.fragsize
;
478 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
479 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
480 outl((s
->dma_dac2
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_DAC2_SCOUNT
);
482 spin_unlock_irqrestore(&s
->lock
, flags
);
485 static void start_adc(struct es1370_state
*s
)
488 unsigned fragremain
, fshift
;
490 spin_lock_irqsave(&s
->lock
, flags
);
491 if (!(s
->ctrl
& CTRL_ADC_EN
) && (s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
492 && s
->dma_adc
.ready
) {
493 s
->ctrl
|= CTRL_ADC_EN
;
494 s
->sctrl
= (s
->sctrl
& ~SCTRL_R1LOOPSEL
) | SCTRL_R1INTEN
;
495 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
496 fragremain
= ((- s
->dma_adc
.hwptr
) & (s
->dma_adc
.fragsize
-1));
497 fshift
= sample_shift
[(s
->sctrl
& SCTRL_R1FMT
) >> SCTRL_SH_R1FMT
];
498 if (fragremain
< 2*fshift
)
499 fragremain
= s
->dma_adc
.fragsize
;
500 outl((fragremain
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
501 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
502 outl((s
->dma_adc
.fragsize
>> fshift
) - 1, s
->io
+ES1370_REG_ADC_SCOUNT
);
504 spin_unlock_irqrestore(&s
->lock
, flags
);
507 /* --------------------------------------------------------------------- */
509 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
510 #define DMABUF_MINORDER 1
512 extern inline void dealloc_dmabuf(struct dmabuf
*db
)
514 unsigned long map
, mapend
;
517 /* undo marking the pages as reserved */
518 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
519 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
520 clear_bit(PG_reserved
, &mem_map
[map
].flags
);
521 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
524 db
->mapped
= db
->ready
= 0;
527 static int prog_dmabuf(struct es1370_state
*s
, struct dmabuf
*db
, unsigned rate
, unsigned fmt
, unsigned reg
)
532 unsigned long map
, mapend
;
534 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
536 db
->ready
= db
->mapped
= 0;
537 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
538 if ((db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
, order
)))
542 db
->buforder
= order
;
543 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
544 mapend
= MAP_NR(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
545 for (map
= MAP_NR(db
->rawbuf
); map
<= mapend
; map
++)
546 set_bit(PG_reserved
, &mem_map
[map
].flags
);
548 fmt
&= ES1370_FMT_MASK
;
549 bytepersec
= rate
<< sample_shift
[fmt
];
550 bufs
= PAGE_SIZE
<< db
->buforder
;
551 if (db
->ossfragshift
) {
552 if ((1000 << db
->ossfragshift
) < bytepersec
)
553 db
->fragshift
= ld2(bytepersec
/1000);
555 db
->fragshift
= db
->ossfragshift
;
557 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
558 if (db
->fragshift
< 3)
561 db
->numfrag
= bufs
>> db
->fragshift
;
562 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
564 db
->numfrag
= bufs
>> db
->fragshift
;
566 db
->fragsize
= 1 << db
->fragshift
;
567 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
568 db
->numfrag
= db
->ossmaxfrags
;
569 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
570 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
571 memset(db
->rawbuf
, (fmt
& ES1370_FMT_S16
) ? 0 : 0x80, db
->dmasize
);
572 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
573 outl(virt_to_bus(db
->rawbuf
), s
->io
+(reg
& 0xff));
574 outl((db
->dmasize
>> 2)-1, s
->io
+((reg
+ 4) & 0xff));
579 extern inline int prog_dmabuf_adc(struct es1370_state
*s
)
582 return prog_dmabuf(s
, &s
->dma_adc
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
583 (s
->sctrl
>> SCTRL_SH_R1FMT
) & ES1370_FMT_MASK
, ES1370_REG_ADC_FRAMEADR
);
586 extern inline int prog_dmabuf_dac2(struct es1370_state
*s
)
589 return prog_dmabuf(s
, &s
->dma_dac2
, DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
),
590 (s
->sctrl
>> SCTRL_SH_P2FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC2_FRAMEADR
);
593 extern inline int prog_dmabuf_dac1(struct es1370_state
*s
)
596 return prog_dmabuf(s
, &s
->dma_dac1
, dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
],
597 (s
->sctrl
>> SCTRL_SH_P1FMT
) & ES1370_FMT_MASK
, ES1370_REG_DAC1_FRAMEADR
);
600 extern inline unsigned get_hwptr(struct es1370_state
*s
, struct dmabuf
*db
, unsigned reg
)
602 unsigned hwptr
, diff
;
604 outl((reg
>> 8) & 15, s
->io
+ES1370_REG_MEMPAGE
);
605 hwptr
= (inl(s
->io
+(reg
& 0xff)) >> 14) & 0x3fffc;
606 diff
= (db
->dmasize
+ hwptr
- db
->hwptr
) % db
->dmasize
;
611 extern inline void clear_advance(void *buf
, unsigned bsize
, unsigned bptr
, unsigned len
, unsigned char c
)
613 if (bptr
+ len
> bsize
) {
614 unsigned x
= bsize
- bptr
;
615 memset(((char *)buf
) + bptr
, c
, x
);
619 memset(((char *)buf
) + bptr
, c
, len
);
622 /* call with spinlock held! */
623 static void es1370_update_ptr(struct es1370_state
*s
)
627 /* update ADC pointer */
628 if (s
->ctrl
& CTRL_ADC_EN
) {
629 diff
= get_hwptr(s
, &s
->dma_adc
, ES1370_REG_ADC_FRAMECNT
);
630 s
->dma_adc
.total_bytes
+= diff
;
631 s
->dma_adc
.count
+= diff
;
632 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
633 wake_up(&s
->dma_adc
.wait
);
634 if (!s
->dma_adc
.mapped
) {
635 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
636 s
->ctrl
&= ~CTRL_ADC_EN
;
637 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
642 /* update DAC1 pointer */
643 if (s
->ctrl
& CTRL_DAC1_EN
) {
644 diff
= get_hwptr(s
, &s
->dma_dac1
, ES1370_REG_DAC1_FRAMECNT
);
645 s
->dma_dac1
.total_bytes
+= diff
;
646 if (s
->dma_dac1
.mapped
) {
647 s
->dma_dac1
.count
+= diff
;
648 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
649 wake_up(&s
->dma_dac1
.wait
);
651 s
->dma_dac1
.count
-= diff
;
652 if (s
->dma_dac1
.count
<= 0) {
653 s
->ctrl
&= ~CTRL_DAC1_EN
;
654 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
656 } else if (s
->dma_dac1
.count
<= (signed)s
->dma_dac1
.fragsize
&& !s
->dma_dac1
.endcleared
) {
657 clear_advance(s
->dma_dac1
.rawbuf
, s
->dma_dac1
.dmasize
, s
->dma_dac1
.swptr
,
658 s
->dma_dac1
.fragsize
, (s
->sctrl
& SCTRL_P1SEB
) ? 0 : 0x80);
659 s
->dma_dac1
.endcleared
= 1;
661 if (s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
<= (signed)s
->dma_dac1
.dmasize
)
662 wake_up(&s
->dma_dac1
.wait
);
665 /* update DAC2 pointer */
666 if (s
->ctrl
& CTRL_DAC2_EN
) {
667 diff
= get_hwptr(s
, &s
->dma_dac2
, ES1370_REG_DAC2_FRAMECNT
);
668 s
->dma_dac2
.total_bytes
+= diff
;
669 if (s
->dma_dac2
.mapped
) {
670 s
->dma_dac2
.count
+= diff
;
671 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
672 wake_up(&s
->dma_dac2
.wait
);
674 s
->dma_dac2
.count
-= diff
;
675 if (s
->dma_dac2
.count
<= 0) {
676 s
->ctrl
&= ~CTRL_DAC2_EN
;
677 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
679 } else if (s
->dma_dac2
.count
<= (signed)s
->dma_dac2
.fragsize
&& !s
->dma_dac2
.endcleared
) {
680 clear_advance(s
->dma_dac2
.rawbuf
, s
->dma_dac2
.dmasize
, s
->dma_dac2
.swptr
,
681 s
->dma_dac2
.fragsize
, (s
->sctrl
& SCTRL_P2SEB
) ? 0 : 0x80);
682 s
->dma_dac2
.endcleared
= 1;
684 if (s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
<= (signed)s
->dma_dac2
.dmasize
)
685 wake_up(&s
->dma_dac2
.wait
);
690 /* hold spinlock for the following! */
691 static void es1370_handle_midi(struct es1370_state
*s
)
696 if (!(s
->ctrl
& CTRL_UART_EN
))
699 while (inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_RXRDY
) {
700 ch
= inb(s
->io
+ES1370_REG_UART_DATA
);
701 if (s
->midi
.icnt
< MIDIINBUF
) {
702 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
703 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
709 wake_up(&s
->midi
.iwait
);
711 while ((inb(s
->io
+ES1370_REG_UART_STATUS
) & USTAT_TXRDY
) && s
->midi
.ocnt
> 0) {
712 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->io
+ES1370_REG_UART_DATA
);
713 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
715 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
719 wake_up(&s
->midi
.owait
);
720 outb((s
->midi
.ocnt
> 0) ? UCTRL_RXINTEN
| UCTRL_ENA_TXINT
: UCTRL_RXINTEN
, s
->io
+ES1370_REG_UART_CONTROL
);
723 static void es1370_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
725 struct es1370_state
*s
= (struct es1370_state
*)dev_id
;
726 unsigned int intsrc
, sctl
;
728 /* fastpath out, to ease interrupt sharing */
729 intsrc
= inl(s
->io
+ES1370_REG_STATUS
);
730 if (!(intsrc
& 0x80000000))
733 /* clear audio interrupts first */
735 if (intsrc
& STAT_ADC
)
736 sctl
&= ~SCTRL_R1INTEN
;
737 if (intsrc
& STAT_DAC1
)
738 sctl
&= ~SCTRL_P1INTEN
;
739 if (intsrc
& STAT_DAC2
)
740 sctl
&= ~SCTRL_P2INTEN
;
741 outl(sctl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
742 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
743 es1370_update_ptr(s
);
744 es1370_handle_midi(s
);
745 spin_unlock(&s
->lock
);
748 /* --------------------------------------------------------------------- */
750 static const char invalid_magic
[] = KERN_CRIT
"es1370: invalid magic value\n";
752 #define VALIDATE_STATE(s) \
754 if (!(s) || (s)->magic != ES1370_MAGIC) { \
755 printk(invalid_magic); \
760 /* --------------------------------------------------------------------- */
762 static const struct {
769 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
770 [SOUND_MIXER_VOLUME
] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
771 [SOUND_MIXER_PCM
] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
772 [SOUND_MIXER_SYNTH
] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
773 [SOUND_MIXER_CD
] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
774 [SOUND_MIXER_LINE
] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
775 [SOUND_MIXER_LINE1
] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
776 [SOUND_MIXER_LINE2
] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
777 [SOUND_MIXER_LINE3
] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
778 [SOUND_MIXER_MIC
] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
779 [SOUND_MIXER_OGAIN
] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
782 static int mixer_ioctl(struct es1370_state
*s
, unsigned int cmd
, unsigned long arg
)
786 unsigned char l
, r
, rl
, rr
;
789 if (cmd
== SOUND_MIXER_PRIVATE1
) {
790 /* enable/disable/query mixer preamp */
791 get_user_ret(val
, (int *)arg
, -EFAULT
);
793 s
->mix
.micpreamp
= !!val
;
794 wrcodec(s
, 0x19, s
->mix
.micpreamp
);
796 return put_user(s
->mix
.micpreamp
, (int *)arg
);
798 if (cmd
== SOUND_MIXER_PRIVATE2
) {
799 /* enable/disable/query use of linein as second lineout */
800 get_user_ret(val
, (int *)arg
, -EFAULT
);
802 spin_lock_irqsave(&s
->lock
, flags
);
804 s
->ctrl
|= CTRL_XCTL0
;
806 s
->ctrl
&= ~CTRL_XCTL0
;
807 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
808 spin_unlock_irqrestore(&s
->lock
, flags
);
810 return put_user((s
->ctrl
& CTRL_XCTL0
) ? 1 : 0, (int *)arg
);
812 if (cmd
== SOUND_MIXER_PRIVATE3
) {
813 /* enable/disable/query microphone impedance setting */
814 get_user_ret(val
, (int *)arg
, -EFAULT
);
816 spin_lock_irqsave(&s
->lock
, flags
);
818 s
->ctrl
|= CTRL_XCTL1
;
820 s
->ctrl
&= ~CTRL_XCTL1
;
821 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
822 spin_unlock_irqrestore(&s
->lock
, flags
);
824 return put_user((s
->ctrl
& CTRL_XCTL1
) ? 1 : 0, (int *)arg
);
826 if (cmd
== SOUND_MIXER_INFO
) {
828 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
829 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
830 info
.modify_counter
= s
->mix
.modcnt
;
831 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
835 if (cmd
== SOUND_OLD_MIXER_INFO
) {
836 _old_mixer_info info
;
837 strncpy(info
.id
, "ES1370", sizeof(info
.id
));
838 strncpy(info
.name
, "Ensoniq ES1370", sizeof(info
.name
));
839 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
843 if (cmd
== OSS_GETVERSION
)
844 return put_user(SOUND_VERSION
, (int *)arg
);
845 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
847 if (_IOC_DIR(cmd
) == _IOC_READ
) {
848 switch (_IOC_NR(cmd
)) {
849 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
850 return put_user(s
->mix
.recsrc
, (int *)arg
);
852 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
853 val
= SOUND_MASK_IMIX
;
854 for (i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
855 if (mixtable
[i
].avail
)
857 return put_user(val
, (int *)arg
);
859 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
860 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
861 if (mixtable
[i
].recmask
)
863 return put_user(val
, (int *)arg
);
865 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
866 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
867 if (mixtable
[i
].stereo
)
869 return put_user(val
, (int *)arg
);
871 case SOUND_MIXER_CAPS
:
872 return put_user(0, (int *)arg
);
874 case SOUND_MIXER_IMIX
:
875 return put_user(s
->mix
.imix
, (int *)arg
);
879 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
881 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
884 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
887 switch (_IOC_NR(cmd
)) {
889 case SOUND_MIXER_IMIX
:
892 get_user_ret(s
->mix
.imix
,(int *)arg
, -EFAULT
);
896 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
897 get_user_ret(val
, (int *)arg
, -EFAULT
);
898 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
899 if (!(val
& (1 << i
)))
901 if (!mixtable
[i
].recmask
) {
905 j
|= mixtable
[i
].recmask
;
908 wrcodec(s
, 0x12, j
& 0xd5);
909 wrcodec(s
, 0x13, j
& 0xaa);
910 wrcodec(s
, 0x14, (j
>> 8) & 0x17);
911 wrcodec(s
, 0x15, (j
>> 8) & 0x0f);
912 i
= (j
& 0x37f) | ((j
<< 1) & 0x3000) | 0xc60;
914 i
&= 0xff60; /* mute record and line monitor */
917 wrcodec(s
, 0x11, i
>> 8);
922 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].avail
)
924 get_user_ret(val
, (int *)arg
, -EFAULT
);
928 if (mixtable
[i
].stereo
) {
929 r
= (val
>> 8) & 0xff;
936 rl
= 31 - ((l
- 7) / 3);
937 l
= (31 - rl
) * 3 + 7;
943 rr
= 31 - ((r
- 7) / 3);
944 r
= (31 - rr
) * 3 + 7;
946 wrcodec(s
, mixtable
[i
].right
, rr
);
948 if (mixtable
[i
].left
== 15) {
953 rl
= 7 - ((l
- 2) / 14);
954 r
= l
= (7 - rl
) * 14 + 2;
961 rl
= 31 - ((l
- 7) / 3);
962 r
= l
= (31 - rl
) * 3 + 7;
966 wrcodec(s
, mixtable
[i
].left
, rl
);
967 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
968 s
->mix
.vol
[mixtable
[i
].volidx
] = ((unsigned int)r
<< 8) | l
;
970 s
->mix
.vol
[mixtable
[i
].volidx
] = val
;
972 return put_user(s
->mix
.vol
[mixtable
[i
].volidx
], (int *)arg
);
976 /* --------------------------------------------------------------------- */
978 static loff_t
es1370_llseek(struct file
*file
, loff_t offset
, int origin
)
983 /* --------------------------------------------------------------------- */
985 static int es1370_open_mixdev(struct inode
*inode
, struct file
*file
)
987 int minor
= MINOR(inode
->i_rdev
);
988 struct es1370_state
*s
= devs
;
990 while (s
&& s
->dev_mixer
!= minor
)
995 file
->private_data
= s
;
1000 static int es1370_release_mixdev(struct inode
*inode
, struct file
*file
)
1002 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1009 static int es1370_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1011 return mixer_ioctl((struct es1370_state
*)file
->private_data
, cmd
, arg
);
1014 static /*const*/ struct file_operations es1370_mixer_fops
= {
1020 &es1370_ioctl_mixdev
,
1022 &es1370_open_mixdev
,
1024 &es1370_release_mixdev
,
1027 NULL
, /* check_media_change */
1028 NULL
, /* revalidate */
1032 /* --------------------------------------------------------------------- */
1034 static int drain_dac1(struct es1370_state
*s
, int nonblock
)
1036 DECLARE_WAITQUEUE(wait
, current
);
1037 unsigned long flags
;
1040 if (s
->dma_dac1
.mapped
|| !s
->dma_dac1
.ready
)
1042 current
->state
= TASK_INTERRUPTIBLE
;
1043 add_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1045 spin_lock_irqsave(&s
->lock
, flags
);
1046 count
= s
->dma_dac1
.count
;
1047 spin_unlock_irqrestore(&s
->lock
, flags
);
1050 if (signal_pending(current
))
1053 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1054 current
->state
= TASK_RUNNING
;
1057 tmo
= (count
* HZ
) / dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
];
1058 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P1FMT
) >> SCTRL_SH_P1FMT
];
1059 if (!schedule_timeout(tmo
? : 1) && tmo
)
1060 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1062 remove_wait_queue(&s
->dma_dac1
.wait
, &wait
);
1063 current
->state
= TASK_RUNNING
;
1064 if (signal_pending(current
))
1065 return -ERESTARTSYS
;
1069 static int drain_dac2(struct es1370_state
*s
, int nonblock
)
1071 DECLARE_WAITQUEUE(wait
, current
);
1072 unsigned long flags
;
1075 if (s
->dma_dac2
.mapped
|| !s
->dma_dac2
.ready
)
1077 current
->state
= TASK_INTERRUPTIBLE
;
1078 add_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1080 spin_lock_irqsave(&s
->lock
, flags
);
1081 count
= s
->dma_dac2
.count
;
1082 spin_unlock_irqrestore(&s
->lock
, flags
);
1085 if (signal_pending(current
))
1088 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1089 current
->state
= TASK_RUNNING
;
1092 tmo
= (count
* HZ
) / DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
);
1093 tmo
>>= sample_shift
[(s
->sctrl
& SCTRL_P2FMT
) >> SCTRL_SH_P2FMT
];
1094 if (!schedule_timeout(tmo
? : 1) && tmo
)
1095 DBG(printk(KERN_DEBUG
"es1370: dma timed out??\n");)
1097 remove_wait_queue(&s
->dma_dac2
.wait
, &wait
);
1098 current
->state
= TASK_RUNNING
;
1099 if (signal_pending(current
))
1100 return -ERESTARTSYS
;
1104 /* --------------------------------------------------------------------- */
1106 static ssize_t
es1370_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1108 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1110 unsigned long flags
;
1115 if (ppos
!= &file
->f_pos
)
1117 if (s
->dma_adc
.mapped
)
1119 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1121 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1125 spin_lock_irqsave(&s
->lock
, flags
);
1126 swptr
= s
->dma_adc
.swptr
;
1127 cnt
= s
->dma_adc
.dmasize
-swptr
;
1128 if (s
->dma_adc
.count
< cnt
)
1129 cnt
= s
->dma_adc
.count
;
1130 spin_unlock_irqrestore(&s
->lock
, flags
);
1135 if (file
->f_flags
& O_NONBLOCK
)
1136 return ret
? ret
: -EAGAIN
;
1137 interruptible_sleep_on(&s
->dma_adc
.wait
);
1138 if (signal_pending(current
))
1139 return ret
? ret
: -ERESTARTSYS
;
1142 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1143 return ret
? ret
: -EFAULT
;
1144 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1145 spin_lock_irqsave(&s
->lock
, flags
);
1146 s
->dma_adc
.swptr
= swptr
;
1147 s
->dma_adc
.count
-= cnt
;
1148 spin_unlock_irqrestore(&s
->lock
, flags
);
1157 static ssize_t
es1370_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1159 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1161 unsigned long flags
;
1166 if (ppos
!= &file
->f_pos
)
1168 if (s
->dma_dac2
.mapped
)
1170 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1172 if (!access_ok(VERIFY_READ
, buffer
, count
))
1176 spin_lock_irqsave(&s
->lock
, flags
);
1177 if (s
->dma_dac2
.count
< 0) {
1178 s
->dma_dac2
.count
= 0;
1179 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
;
1181 swptr
= s
->dma_dac2
.swptr
;
1182 cnt
= s
->dma_dac2
.dmasize
-swptr
;
1183 if (s
->dma_dac2
.count
+ cnt
> s
->dma_dac2
.dmasize
)
1184 cnt
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1185 spin_unlock_irqrestore(&s
->lock
, flags
);
1190 if (file
->f_flags
& O_NONBLOCK
)
1191 return ret
? ret
: -EAGAIN
;
1192 interruptible_sleep_on(&s
->dma_dac2
.wait
);
1193 if (signal_pending(current
))
1194 return ret
? ret
: -ERESTARTSYS
;
1197 if (copy_from_user(s
->dma_dac2
.rawbuf
+ swptr
, buffer
, cnt
))
1198 return ret
? ret
: -EFAULT
;
1199 swptr
= (swptr
+ cnt
) % s
->dma_dac2
.dmasize
;
1200 spin_lock_irqsave(&s
->lock
, flags
);
1201 s
->dma_dac2
.swptr
= swptr
;
1202 s
->dma_dac2
.count
+= cnt
;
1203 s
->dma_dac2
.endcleared
= 0;
1204 spin_unlock_irqrestore(&s
->lock
, flags
);
1213 static unsigned int es1370_poll(struct file
*file
, struct poll_table_struct
*wait
)
1215 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1216 unsigned long flags
;
1217 unsigned int mask
= 0;
1220 if (file
->f_mode
& FMODE_WRITE
)
1221 poll_wait(file
, &s
->dma_dac2
.wait
, wait
);
1222 if (file
->f_mode
& FMODE_READ
)
1223 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1224 spin_lock_irqsave(&s
->lock
, flags
);
1225 es1370_update_ptr(s
);
1226 if (file
->f_mode
& FMODE_READ
) {
1227 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1228 mask
|= POLLIN
| POLLRDNORM
;
1230 if (file
->f_mode
& FMODE_WRITE
) {
1231 if (s
->dma_dac2
.mapped
) {
1232 if (s
->dma_dac2
.count
>= (signed)s
->dma_dac2
.fragsize
)
1233 mask
|= POLLOUT
| POLLWRNORM
;
1235 if ((signed)s
->dma_dac2
.dmasize
>= s
->dma_dac2
.count
+ (signed)s
->dma_dac2
.fragsize
)
1236 mask
|= POLLOUT
| POLLWRNORM
;
1239 spin_unlock_irqrestore(&s
->lock
, flags
);
1243 static int es1370_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1245 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1251 if (vma
->vm_flags
& VM_WRITE
) {
1252 if ((ret
= prog_dmabuf_dac2(s
)) != 0)
1255 } else if (vma
->vm_flags
& VM_READ
) {
1256 if ((ret
= prog_dmabuf_adc(s
)) != 0)
1261 if (vma
->vm_offset
!= 0)
1263 size
= vma
->vm_end
- vma
->vm_start
;
1264 if (size
> (PAGE_SIZE
<< db
->buforder
))
1266 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1272 static int es1370_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1274 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1275 unsigned long flags
;
1276 audio_buf_info abinfo
;
1278 int val
, mapped
, ret
;
1281 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac2
.mapped
) ||
1282 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1284 case OSS_GETVERSION
:
1285 return put_user(SOUND_VERSION
, (int *)arg
);
1287 case SNDCTL_DSP_SYNC
:
1288 if (file
->f_mode
& FMODE_WRITE
)
1289 return drain_dac2(s
, 0/*file->f_flags & O_NONBLOCK*/);
1292 case SNDCTL_DSP_SETDUPLEX
:
1295 case SNDCTL_DSP_GETCAPS
:
1296 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1298 case SNDCTL_DSP_RESET
:
1299 if (file
->f_mode
& FMODE_WRITE
) {
1302 s
->dma_dac2
.swptr
= s
->dma_dac2
.hwptr
= s
->dma_dac2
.count
= s
->dma_dac2
.total_bytes
= 0;
1304 if (file
->f_mode
& FMODE_READ
) {
1307 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1311 case SNDCTL_DSP_SPEED
:
1312 get_user_ret(val
, (int *)arg
, -EFAULT
);
1314 if (s
->open_mode
& (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
))
1322 s
->dma_adc
.ready
= s
->dma_dac2
.ready
= 0;
1323 spin_lock_irqsave(&s
->lock
, flags
);
1324 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(val
) << CTRL_SH_PCLKDIV
);
1325 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1326 spin_unlock_irqrestore(&s
->lock
, flags
);
1328 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1330 case SNDCTL_DSP_STEREO
:
1331 get_user_ret(val
, (int *)arg
, -EFAULT
);
1332 if (file
->f_mode
& FMODE_READ
) {
1334 s
->dma_adc
.ready
= 0;
1335 spin_lock_irqsave(&s
->lock
, flags
);
1337 s
->sctrl
|= SCTRL_R1SMB
;
1339 s
->sctrl
&= ~SCTRL_R1SMB
;
1340 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1341 spin_unlock_irqrestore(&s
->lock
, flags
);
1343 if (file
->f_mode
& FMODE_WRITE
) {
1345 s
->dma_dac2
.ready
= 0;
1346 spin_lock_irqsave(&s
->lock
, flags
);
1348 s
->sctrl
|= SCTRL_P2SMB
;
1350 s
->sctrl
&= ~SCTRL_P2SMB
;
1351 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1352 spin_unlock_irqrestore(&s
->lock
, flags
);
1356 case SNDCTL_DSP_CHANNELS
:
1357 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
);
1382 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ? 2 : 1, (int *)arg
);
1384 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1385 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1387 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1388 get_user_ret(val
, (int *)arg
, -EFAULT
);
1389 if (val
!= AFMT_QUERY
) {
1390 if (file
->f_mode
& FMODE_READ
) {
1392 s
->dma_adc
.ready
= 0;
1393 spin_lock_irqsave(&s
->lock
, flags
);
1394 if (val
== AFMT_S16_LE
)
1395 s
->sctrl
|= SCTRL_R1SEB
;
1397 s
->sctrl
&= ~SCTRL_R1SEB
;
1398 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1399 spin_unlock_irqrestore(&s
->lock
, flags
);
1401 if (file
->f_mode
& FMODE_WRITE
) {
1403 s
->dma_dac2
.ready
= 0;
1404 spin_lock_irqsave(&s
->lock
, flags
);
1405 if (val
== AFMT_S16_LE
)
1406 s
->sctrl
|= SCTRL_P2SEB
;
1408 s
->sctrl
&= ~SCTRL_P2SEB
;
1409 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1410 spin_unlock_irqrestore(&s
->lock
, flags
);
1413 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1414 AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1416 case SNDCTL_DSP_POST
:
1419 case SNDCTL_DSP_GETTRIGGER
:
1421 if (file
->f_mode
& FMODE_READ
&& s
->ctrl
& CTRL_ADC_EN
)
1422 val
|= PCM_ENABLE_INPUT
;
1423 if (file
->f_mode
& FMODE_WRITE
&& s
->ctrl
& CTRL_DAC2_EN
)
1424 val
|= PCM_ENABLE_OUTPUT
;
1425 return put_user(val
, (int *)arg
);
1427 case SNDCTL_DSP_SETTRIGGER
:
1428 get_user_ret(val
, (int *)arg
, -EFAULT
);
1429 if (file
->f_mode
& FMODE_READ
) {
1430 if (val
& PCM_ENABLE_INPUT
) {
1431 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf_adc(s
)))
1437 if (file
->f_mode
& FMODE_WRITE
) {
1438 if (val
& PCM_ENABLE_OUTPUT
) {
1439 if (!s
->dma_dac2
.ready
&& (ret
= prog_dmabuf_dac2(s
)))
1447 case SNDCTL_DSP_GETOSPACE
:
1448 if (!(file
->f_mode
& FMODE_WRITE
))
1450 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac2(s
)) != 0)
1452 spin_lock_irqsave(&s
->lock
, flags
);
1453 es1370_update_ptr(s
);
1454 abinfo
.fragsize
= s
->dma_dac2
.fragsize
;
1455 abinfo
.bytes
= s
->dma_dac2
.dmasize
- s
->dma_dac2
.count
;
1456 abinfo
.fragstotal
= s
->dma_dac2
.numfrag
;
1457 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac2
.fragshift
;
1458 spin_unlock_irqrestore(&s
->lock
, flags
);
1459 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1461 case SNDCTL_DSP_GETISPACE
:
1462 if (!(file
->f_mode
& FMODE_READ
))
1464 if (!(s
->ctrl
& CTRL_ADC_EN
) && (val
= prog_dmabuf_adc(s
)) != 0)
1466 spin_lock_irqsave(&s
->lock
, flags
);
1467 es1370_update_ptr(s
);
1468 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1469 abinfo
.bytes
= s
->dma_adc
.count
;
1470 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1471 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1472 spin_unlock_irqrestore(&s
->lock
, flags
);
1473 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1475 case SNDCTL_DSP_NONBLOCK
:
1476 file
->f_flags
|= O_NONBLOCK
;
1479 case SNDCTL_DSP_GETODELAY
:
1480 if (!(file
->f_mode
& FMODE_WRITE
))
1482 spin_lock_irqsave(&s
->lock
, flags
);
1483 es1370_update_ptr(s
);
1484 val
= s
->dma_dac2
.count
;
1485 spin_unlock_irqrestore(&s
->lock
, flags
);
1486 return put_user(val
, (int *)arg
);
1488 case SNDCTL_DSP_GETIPTR
:
1489 if (!(file
->f_mode
& FMODE_READ
))
1491 spin_lock_irqsave(&s
->lock
, flags
);
1492 es1370_update_ptr(s
);
1493 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1494 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1495 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1496 if (s
->dma_adc
.mapped
)
1497 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1498 spin_unlock_irqrestore(&s
->lock
, flags
);
1499 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1501 case SNDCTL_DSP_GETOPTR
:
1502 if (!(file
->f_mode
& FMODE_WRITE
))
1504 spin_lock_irqsave(&s
->lock
, flags
);
1505 es1370_update_ptr(s
);
1506 cinfo
.bytes
= s
->dma_dac2
.total_bytes
;
1507 cinfo
.blocks
= s
->dma_dac2
.count
>> s
->dma_dac2
.fragshift
;
1508 cinfo
.ptr
= s
->dma_dac2
.hwptr
;
1509 if (s
->dma_dac2
.mapped
)
1510 s
->dma_dac2
.count
&= s
->dma_dac2
.fragsize
-1;
1511 spin_unlock_irqrestore(&s
->lock
, flags
);
1512 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1514 case SNDCTL_DSP_GETBLKSIZE
:
1515 if (file
->f_mode
& FMODE_WRITE
) {
1516 if ((val
= prog_dmabuf_dac2(s
)))
1518 return put_user(s
->dma_dac2
.fragsize
, (int *)arg
);
1520 if ((val
= prog_dmabuf_adc(s
)))
1522 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1524 case SNDCTL_DSP_SETFRAGMENT
:
1525 get_user_ret(val
, (int *)arg
, -EFAULT
);
1526 if (file
->f_mode
& FMODE_READ
) {
1527 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1528 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1529 if (s
->dma_adc
.ossfragshift
< 4)
1530 s
->dma_adc
.ossfragshift
= 4;
1531 if (s
->dma_adc
.ossfragshift
> 15)
1532 s
->dma_adc
.ossfragshift
= 15;
1533 if (s
->dma_adc
.ossmaxfrags
< 4)
1534 s
->dma_adc
.ossmaxfrags
= 4;
1536 if (file
->f_mode
& FMODE_WRITE
) {
1537 s
->dma_dac2
.ossfragshift
= val
& 0xffff;
1538 s
->dma_dac2
.ossmaxfrags
= (val
>> 16) & 0xffff;
1539 if (s
->dma_dac2
.ossfragshift
< 4)
1540 s
->dma_dac2
.ossfragshift
= 4;
1541 if (s
->dma_dac2
.ossfragshift
> 15)
1542 s
->dma_dac2
.ossfragshift
= 15;
1543 if (s
->dma_dac2
.ossmaxfrags
< 4)
1544 s
->dma_dac2
.ossmaxfrags
= 4;
1548 case SNDCTL_DSP_SUBDIVIDE
:
1549 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1550 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac2
.subdivision
))
1552 get_user_ret(val
, (int *)arg
, -EFAULT
);
1553 if (val
!= 1 && val
!= 2 && val
!= 4)
1555 if (file
->f_mode
& FMODE_READ
)
1556 s
->dma_adc
.subdivision
= val
;
1557 if (file
->f_mode
& FMODE_WRITE
)
1558 s
->dma_dac2
.subdivision
= val
;
1561 case SOUND_PCM_READ_RATE
:
1562 return put_user(DAC2_DIVTOSR((s
->ctrl
& CTRL_PCLKDIV
) >> CTRL_SH_PCLKDIV
), (int *)arg
);
1564 case SOUND_PCM_READ_CHANNELS
:
1565 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SMB
: SCTRL_P2SMB
)) ?
1568 case SOUND_PCM_READ_BITS
:
1569 return put_user((s
->sctrl
& ((file
->f_mode
& FMODE_READ
) ? SCTRL_R1SEB
: SCTRL_P2SEB
)) ?
1570 16 : 8, (int *)arg
);
1572 case SOUND_PCM_WRITE_FILTER
:
1573 case SNDCTL_DSP_SETSYNCRO
:
1574 case SOUND_PCM_READ_FILTER
:
1578 return mixer_ioctl(s
, cmd
, arg
);
1581 static int es1370_open(struct inode
*inode
, struct file
*file
)
1583 int minor
= MINOR(inode
->i_rdev
);
1584 struct es1370_state
*s
= devs
;
1585 unsigned long flags
;
1587 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1592 file
->private_data
= s
;
1593 /* wait for device to become free */
1595 while (s
->open_mode
& file
->f_mode
) {
1596 if (file
->f_flags
& O_NONBLOCK
) {
1601 interruptible_sleep_on(&s
->open_wait
);
1602 if (signal_pending(current
))
1603 return -ERESTARTSYS
;
1606 spin_lock_irqsave(&s
->lock
, flags
);
1607 if (!(s
->open_mode
& (FMODE_READ
|FMODE_WRITE
)))
1608 s
->ctrl
= (s
->ctrl
& ~CTRL_PCLKDIV
) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
);
1609 if (file
->f_mode
& FMODE_READ
) {
1610 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1611 s
->sctrl
&= ~SCTRL_R1FMT
;
1612 if ((minor
& 0xf) == SND_DEV_DSP16
)
1613 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_R1FMT
;
1615 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_R1FMT
;
1617 if (file
->f_mode
& FMODE_WRITE
) {
1618 s
->dma_dac2
.ossfragshift
= s
->dma_dac2
.ossmaxfrags
= s
->dma_dac2
.subdivision
= 0;
1619 s
->sctrl
&= ~SCTRL_P2FMT
;
1620 if ((minor
& 0xf) == SND_DEV_DSP16
)
1621 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P2FMT
;
1623 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P2FMT
;
1625 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1626 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1627 spin_unlock_irqrestore(&s
->lock
, flags
);
1628 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1634 static int es1370_release(struct inode
*inode
, struct file
*file
)
1636 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1639 if (file
->f_mode
& FMODE_WRITE
)
1640 drain_dac2(s
, file
->f_flags
& O_NONBLOCK
);
1642 if (file
->f_mode
& FMODE_WRITE
) {
1645 dealloc_dmabuf(&s
->dma_dac2
);
1647 if (file
->f_mode
& FMODE_READ
) {
1649 dealloc_dmabuf(&s
->dma_adc
);
1651 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1653 wake_up(&s
->open_wait
);
1658 static /*const*/ struct file_operations es1370_audio_fops
= {
1671 NULL
, /* check_media_change */
1672 NULL
, /* revalidate */
1676 /* --------------------------------------------------------------------- */
1678 static ssize_t
es1370_write_dac(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1680 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1682 unsigned long flags
;
1687 if (ppos
!= &file
->f_pos
)
1689 if (s
->dma_dac1
.mapped
)
1691 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1693 if (!access_ok(VERIFY_READ
, buffer
, count
))
1696 spin_lock_irqsave(&s
->lock
, flags
);
1697 if (s
->dma_dac1
.count
< 0) {
1698 s
->dma_dac1
.count
= 0;
1699 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
;
1701 swptr
= s
->dma_dac1
.swptr
;
1702 cnt
= s
->dma_dac1
.dmasize
-swptr
;
1703 if (s
->dma_dac1
.count
+ cnt
> s
->dma_dac1
.dmasize
)
1704 cnt
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1705 spin_unlock_irqrestore(&s
->lock
, flags
);
1710 if (file
->f_flags
& O_NONBLOCK
)
1711 return ret
? ret
: -EAGAIN
;
1712 interruptible_sleep_on(&s
->dma_dac1
.wait
);
1713 if (signal_pending(current
))
1714 return ret
? ret
: -ERESTARTSYS
;
1717 if (copy_from_user(s
->dma_dac1
.rawbuf
+ swptr
, buffer
, cnt
))
1718 return ret
? ret
: -EFAULT
;
1719 swptr
= (swptr
+ cnt
) % s
->dma_dac1
.dmasize
;
1720 spin_lock_irqsave(&s
->lock
, flags
);
1721 s
->dma_dac1
.swptr
= swptr
;
1722 s
->dma_dac1
.count
+= cnt
;
1723 s
->dma_dac1
.endcleared
= 0;
1724 spin_unlock_irqrestore(&s
->lock
, flags
);
1733 static unsigned int es1370_poll_dac(struct file
*file
, struct poll_table_struct
*wait
)
1735 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1736 unsigned long flags
;
1737 unsigned int mask
= 0;
1740 poll_wait(file
, &s
->dma_dac1
.wait
, wait
);
1741 spin_lock_irqsave(&s
->lock
, flags
);
1742 es1370_update_ptr(s
);
1743 if (s
->dma_dac1
.mapped
) {
1744 if (s
->dma_dac1
.count
>= (signed)s
->dma_dac1
.fragsize
)
1745 mask
|= POLLOUT
| POLLWRNORM
;
1747 if ((signed)s
->dma_dac1
.dmasize
>= s
->dma_dac1
.count
+ (signed)s
->dma_dac1
.fragsize
)
1748 mask
|= POLLOUT
| POLLWRNORM
;
1750 spin_unlock_irqrestore(&s
->lock
, flags
);
1754 static int es1370_mmap_dac(struct file
*file
, struct vm_area_struct
*vma
)
1756 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1761 if (!(vma
->vm_flags
& VM_WRITE
))
1763 if ((ret
= prog_dmabuf_dac1(s
)) != 0)
1765 if (vma
->vm_offset
!= 0)
1767 size
= vma
->vm_end
- vma
->vm_start
;
1768 if (size
> (PAGE_SIZE
<< s
->dma_dac1
.buforder
))
1770 if (remap_page_range(vma
->vm_start
, virt_to_phys(s
->dma_dac1
.rawbuf
), size
, vma
->vm_page_prot
))
1772 s
->dma_dac1
.mapped
= 1;
1776 static int es1370_ioctl_dac(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1778 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
1779 unsigned long flags
;
1780 audio_buf_info abinfo
;
1787 case OSS_GETVERSION
:
1788 return put_user(SOUND_VERSION
, (int *)arg
);
1790 case SNDCTL_DSP_SYNC
:
1791 return drain_dac1(s
, 0/*file->f_flags & O_NONBLOCK*/);
1793 case SNDCTL_DSP_SETDUPLEX
:
1796 case SNDCTL_DSP_GETCAPS
:
1797 return put_user(DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1799 case SNDCTL_DSP_RESET
:
1802 s
->dma_dac1
.swptr
= s
->dma_dac1
.hwptr
= s
->dma_dac1
.count
= s
->dma_dac1
.total_bytes
= 0;
1805 case SNDCTL_DSP_SPEED
:
1806 get_user_ret(val
, (int *)arg
, -EFAULT
);
1809 s
->dma_dac1
.ready
= 0;
1810 for (ctrl
= 0; ctrl
<= 2; ctrl
++)
1811 if (val
< (dac1_samplerate
[ctrl
] + dac1_samplerate
[ctrl
+1]) / 2)
1813 spin_lock_irqsave(&s
->lock
, flags
);
1814 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (ctrl
<< CTRL_SH_WTSRSEL
);
1815 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
1816 spin_unlock_irqrestore(&s
->lock
, flags
);
1818 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1820 case SNDCTL_DSP_STEREO
:
1821 get_user_ret(val
, (int *)arg
, -EFAULT
);
1823 s
->dma_dac1
.ready
= 0;
1824 spin_lock_irqsave(&s
->lock
, flags
);
1826 s
->sctrl
|= SCTRL_P1SMB
;
1828 s
->sctrl
&= ~SCTRL_P1SMB
;
1829 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1830 spin_unlock_irqrestore(&s
->lock
, flags
);
1833 case SNDCTL_DSP_CHANNELS
:
1834 get_user_ret(val
, (int *)arg
, -EFAULT
);
1836 if (s
->dma_dac1
.mapped
)
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
);
1848 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1850 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1851 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1853 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1854 get_user_ret(val
, (int *)arg
, -EFAULT
);
1855 if (val
!= AFMT_QUERY
) {
1857 s
->dma_dac1
.ready
= 0;
1858 spin_lock_irqsave(&s
->lock
, flags
);
1859 if (val
== AFMT_S16_LE
)
1860 s
->sctrl
|= SCTRL_P1SEB
;
1862 s
->sctrl
&= ~SCTRL_P1SEB
;
1863 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
1864 spin_unlock_irqrestore(&s
->lock
, flags
);
1866 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1868 case SNDCTL_DSP_POST
:
1871 case SNDCTL_DSP_GETTRIGGER
:
1872 return put_user((s
->ctrl
& CTRL_DAC1_EN
) ? PCM_ENABLE_OUTPUT
: 0, (int *)arg
);
1874 case SNDCTL_DSP_SETTRIGGER
:
1875 get_user_ret(val
, (int *)arg
, -EFAULT
);
1876 if (val
& PCM_ENABLE_OUTPUT
) {
1877 if (!s
->dma_dac1
.ready
&& (ret
= prog_dmabuf_dac1(s
)))
1884 case SNDCTL_DSP_GETOSPACE
:
1885 if (!(s
->ctrl
& CTRL_DAC2_EN
) && (val
= prog_dmabuf_dac1(s
)) != 0)
1887 spin_lock_irqsave(&s
->lock
, flags
);
1888 es1370_update_ptr(s
);
1889 abinfo
.fragsize
= s
->dma_dac1
.fragsize
;
1890 abinfo
.bytes
= s
->dma_dac1
.dmasize
- s
->dma_dac1
.count
;
1891 abinfo
.fragstotal
= s
->dma_dac1
.numfrag
;
1892 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac1
.fragshift
;
1893 spin_unlock_irqrestore(&s
->lock
, flags
);
1894 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1896 case SNDCTL_DSP_NONBLOCK
:
1897 file
->f_flags
|= O_NONBLOCK
;
1900 case SNDCTL_DSP_GETODELAY
:
1901 spin_lock_irqsave(&s
->lock
, flags
);
1902 es1370_update_ptr(s
);
1903 val
= s
->dma_dac1
.count
;
1904 spin_unlock_irqrestore(&s
->lock
, flags
);
1905 return put_user(val
, (int *)arg
);
1907 case SNDCTL_DSP_GETOPTR
:
1908 if (!(file
->f_mode
& FMODE_WRITE
))
1910 spin_lock_irqsave(&s
->lock
, flags
);
1911 es1370_update_ptr(s
);
1912 cinfo
.bytes
= s
->dma_dac1
.total_bytes
;
1913 cinfo
.blocks
= s
->dma_dac1
.count
>> s
->dma_dac1
.fragshift
;
1914 cinfo
.ptr
= s
->dma_dac1
.hwptr
;
1915 if (s
->dma_dac1
.mapped
)
1916 s
->dma_dac1
.count
&= s
->dma_dac1
.fragsize
-1;
1917 spin_unlock_irqrestore(&s
->lock
, flags
);
1918 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1920 case SNDCTL_DSP_GETBLKSIZE
:
1921 if ((val
= prog_dmabuf_dac1(s
)))
1923 return put_user(s
->dma_dac1
.fragsize
, (int *)arg
);
1925 case SNDCTL_DSP_SETFRAGMENT
:
1926 get_user_ret(val
, (int *)arg
, -EFAULT
);
1927 s
->dma_dac1
.ossfragshift
= val
& 0xffff;
1928 s
->dma_dac1
.ossmaxfrags
= (val
>> 16) & 0xffff;
1929 if (s
->dma_dac1
.ossfragshift
< 4)
1930 s
->dma_dac1
.ossfragshift
= 4;
1931 if (s
->dma_dac1
.ossfragshift
> 15)
1932 s
->dma_dac1
.ossfragshift
= 15;
1933 if (s
->dma_dac1
.ossmaxfrags
< 4)
1934 s
->dma_dac1
.ossmaxfrags
= 4;
1937 case SNDCTL_DSP_SUBDIVIDE
:
1938 if (s
->dma_dac1
.subdivision
)
1940 get_user_ret(val
, (int *)arg
, -EFAULT
);
1941 if (val
!= 1 && val
!= 2 && val
!= 4)
1943 s
->dma_dac1
.subdivision
= val
;
1946 case SOUND_PCM_READ_RATE
:
1947 return put_user(dac1_samplerate
[(s
->ctrl
& CTRL_WTSRSEL
) >> CTRL_SH_WTSRSEL
], (int *)arg
);
1949 case SOUND_PCM_READ_CHANNELS
:
1950 return put_user((s
->sctrl
& SCTRL_P1SMB
) ? 2 : 1, (int *)arg
);
1952 case SOUND_PCM_READ_BITS
:
1953 return put_user((s
->sctrl
& SCTRL_P1SEB
) ? 16 : 8, (int *)arg
);
1955 case SOUND_PCM_WRITE_FILTER
:
1956 case SNDCTL_DSP_SETSYNCRO
:
1957 case SOUND_PCM_READ_FILTER
:
1961 return mixer_ioctl(s
, cmd
, arg
);
1964 static int es1370_open_dac(struct inode
*inode
, struct file
*file
)
1966 int minor
= MINOR(inode
->i_rdev
);
1967 struct es1370_state
*s
= devs
;
1968 unsigned long flags
;
1970 while (s
&& ((s
->dev_dac
^ minor
) & ~0xf))
1975 /* we allow opening with O_RDWR, most programs do it although they will only write */
1977 if (file
->f_mode
& FMODE_READ
)
1980 if (!(file
->f_mode
& FMODE_WRITE
))
1982 file
->private_data
= s
;
1983 /* wait for device to become free */
1985 while (s
->open_mode
& FMODE_DAC
) {
1986 if (file
->f_flags
& O_NONBLOCK
) {
1991 interruptible_sleep_on(&s
->open_wait
);
1992 if (signal_pending(current
))
1993 return -ERESTARTSYS
;
1996 s
->dma_dac1
.ossfragshift
= s
->dma_dac1
.ossmaxfrags
= s
->dma_dac1
.subdivision
= 0;
1997 spin_lock_irqsave(&s
->lock
, flags
);
1998 s
->ctrl
= (s
->ctrl
& ~CTRL_WTSRSEL
) | (1 << CTRL_SH_WTSRSEL
);
1999 s
->sctrl
&= ~SCTRL_P1FMT
;
2000 if ((minor
& 0xf) == SND_DEV_DSP16
)
2001 s
->sctrl
|= ES1370_FMT_S16_MONO
<< SCTRL_SH_P1FMT
;
2003 s
->sctrl
|= ES1370_FMT_U8_MONO
<< SCTRL_SH_P1FMT
;
2004 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2005 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2006 spin_unlock_irqrestore(&s
->lock
, flags
);
2007 s
->open_mode
|= FMODE_DAC
;
2013 static int es1370_release_dac(struct inode
*inode
, struct file
*file
)
2015 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2018 drain_dac1(s
, file
->f_flags
& O_NONBLOCK
);
2021 dealloc_dmabuf(&s
->dma_dac1
);
2022 s
->open_mode
&= ~FMODE_DAC
;
2024 wake_up(&s
->open_wait
);
2029 static /*const*/ struct file_operations es1370_dac_fops
= {
2039 &es1370_release_dac
,
2042 NULL
, /* check_media_change */
2043 NULL
, /* revalidate */
2047 /* --------------------------------------------------------------------- */
2049 static ssize_t
es1370_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
2051 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2053 unsigned long flags
;
2058 if (ppos
!= &file
->f_pos
)
2060 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2064 spin_lock_irqsave(&s
->lock
, flags
);
2066 cnt
= MIDIINBUF
- ptr
;
2067 if (s
->midi
.icnt
< cnt
)
2069 spin_unlock_irqrestore(&s
->lock
, flags
);
2073 if (file
->f_flags
& O_NONBLOCK
)
2074 return ret
? ret
: -EAGAIN
;
2075 interruptible_sleep_on(&s
->midi
.iwait
);
2076 if (signal_pending(current
))
2077 return ret
? ret
: -ERESTARTSYS
;
2080 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
))
2081 return ret
? ret
: -EFAULT
;
2082 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
2083 spin_lock_irqsave(&s
->lock
, flags
);
2085 s
->midi
.icnt
-= cnt
;
2086 spin_unlock_irqrestore(&s
->lock
, flags
);
2094 static ssize_t
es1370_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
2096 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2098 unsigned long flags
;
2103 if (ppos
!= &file
->f_pos
)
2105 if (!access_ok(VERIFY_READ
, buffer
, count
))
2109 spin_lock_irqsave(&s
->lock
, flags
);
2111 cnt
= MIDIOUTBUF
- ptr
;
2112 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
2113 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
2115 es1370_handle_midi(s
);
2116 spin_unlock_irqrestore(&s
->lock
, flags
);
2120 if (file
->f_flags
& O_NONBLOCK
)
2121 return ret
? ret
: -EAGAIN
;
2122 interruptible_sleep_on(&s
->midi
.owait
);
2123 if (signal_pending(current
))
2124 return ret
? ret
: -ERESTARTSYS
;
2127 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
))
2128 return ret
? ret
: -EFAULT
;
2129 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
2130 spin_lock_irqsave(&s
->lock
, flags
);
2132 s
->midi
.ocnt
+= cnt
;
2133 spin_unlock_irqrestore(&s
->lock
, flags
);
2137 spin_lock_irqsave(&s
->lock
, flags
);
2138 es1370_handle_midi(s
);
2139 spin_unlock_irqrestore(&s
->lock
, flags
);
2144 static unsigned int es1370_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
2146 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2147 unsigned long flags
;
2148 unsigned int mask
= 0;
2151 if (file
->f_mode
& FMODE_WRITE
)
2152 poll_wait(file
, &s
->midi
.owait
, wait
);
2153 if (file
->f_mode
& FMODE_READ
)
2154 poll_wait(file
, &s
->midi
.iwait
, wait
);
2155 spin_lock_irqsave(&s
->lock
, flags
);
2156 if (file
->f_mode
& FMODE_READ
) {
2157 if (s
->midi
.icnt
> 0)
2158 mask
|= POLLIN
| POLLRDNORM
;
2160 if (file
->f_mode
& FMODE_WRITE
) {
2161 if (s
->midi
.ocnt
< MIDIOUTBUF
)
2162 mask
|= POLLOUT
| POLLWRNORM
;
2164 spin_unlock_irqrestore(&s
->lock
, flags
);
2168 static int es1370_midi_open(struct inode
*inode
, struct file
*file
)
2170 int minor
= MINOR(inode
->i_rdev
);
2171 struct es1370_state
*s
= devs
;
2172 unsigned long flags
;
2174 while (s
&& s
->dev_midi
!= minor
)
2179 file
->private_data
= s
;
2180 /* wait for device to become free */
2182 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2183 if (file
->f_flags
& O_NONBLOCK
) {
2188 interruptible_sleep_on(&s
->open_wait
);
2189 if (signal_pending(current
))
2190 return -ERESTARTSYS
;
2193 spin_lock_irqsave(&s
->lock
, flags
);
2194 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2195 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2196 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2197 outb(UCTRL_CNTRL_SWR
, s
->io
+ES1370_REG_UART_CONTROL
);
2198 outb(0, s
->io
+ES1370_REG_UART_CONTROL
);
2199 outb(0, s
->io
+ES1370_REG_UART_TEST
);
2201 if (file
->f_mode
& FMODE_READ
) {
2202 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2204 if (file
->f_mode
& FMODE_WRITE
) {
2205 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2207 s
->ctrl
|= CTRL_UART_EN
;
2208 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2209 es1370_handle_midi(s
);
2210 spin_unlock_irqrestore(&s
->lock
, flags
);
2211 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2217 static int es1370_midi_release(struct inode
*inode
, struct file
*file
)
2219 struct es1370_state
*s
= (struct es1370_state
*)file
->private_data
;
2220 DECLARE_WAITQUEUE(wait
, current
);
2221 unsigned long flags
;
2222 unsigned count
, tmo
;
2226 if (file
->f_mode
& FMODE_WRITE
) {
2227 current
->state
= TASK_INTERRUPTIBLE
;
2228 add_wait_queue(&s
->midi
.owait
, &wait
);
2230 spin_lock_irqsave(&s
->lock
, flags
);
2231 count
= s
->midi
.ocnt
;
2232 spin_unlock_irqrestore(&s
->lock
, flags
);
2235 if (signal_pending(current
))
2237 if (file
->f_flags
& O_NONBLOCK
) {
2238 remove_wait_queue(&s
->midi
.owait
, &wait
);
2239 current
->state
= TASK_RUNNING
;
2242 tmo
= (count
* HZ
) / 3100;
2243 if (!schedule_timeout(tmo
? : 1) && tmo
)
2244 DBG(printk(KERN_DEBUG
"es1370: midi timed out??\n");)
2246 remove_wait_queue(&s
->midi
.owait
, &wait
);
2247 current
->state
= TASK_RUNNING
;
2250 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2251 spin_lock_irqsave(&s
->lock
, flags
);
2252 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2253 s
->ctrl
&= ~CTRL_UART_EN
;
2254 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2256 spin_unlock_irqrestore(&s
->lock
, flags
);
2258 wake_up(&s
->open_wait
);
2263 static /*const*/ struct file_operations es1370_midi_fops
= {
2273 &es1370_midi_release
,
2276 NULL
, /* check_media_change */
2277 NULL
, /* revalidate */
2281 /* --------------------------------------------------------------------- */
2283 /* maximum number of devices */
2285 #ifdef CONFIG_SOUND_ES1370_JOYPORT_BOOT
2286 static int joystick
[NR_DEVICE
] = { 1, 0, };
2288 static int joystick
[NR_DEVICE
] = { 0, };
2290 static int lineout
[NR_DEVICE
] = { 0, };
2291 static int micbias
[NR_DEVICE
] = { 0, };
2293 /* --------------------------------------------------------------------- */
2295 static struct initvol
{
2298 } initvol
[] __initdata
= {
2299 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2300 { SOUND_MIXER_WRITE_PCM
, 0x4040 },
2301 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2302 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2303 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2304 { SOUND_MIXER_WRITE_LINE1
, 0x4040 },
2305 { SOUND_MIXER_WRITE_LINE2
, 0x4040 },
2306 { SOUND_MIXER_WRITE_LINE3
, 0x4040 },
2307 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2308 { SOUND_MIXER_WRITE_OGAIN
, 0x4040 }
2312 int __init
init_module(void)
2314 int __init
init_es1370(void)
2317 struct es1370_state
*s
;
2318 struct pci_dev
*pcidev
= NULL
;
2320 int i
, val
, index
= 0;
2322 if (!pci_present()) /* No PCI bus in this machine! */
2324 printk(KERN_INFO
"es1370: version v0.24 time " __TIME__
" " __DATE__
"\n");
2325 while (index
< NR_DEVICE
&&
2326 (pcidev
= pci_find_device(PCI_VENDOR_ID_ENSONIQ
, PCI_DEVICE_ID_ENSONIQ_ES1370
, pcidev
))) {
2327 if (pcidev
->base_address
[0] == 0 ||
2328 (pcidev
->base_address
[0] & PCI_BASE_ADDRESS_SPACE
) != PCI_BASE_ADDRESS_SPACE_IO
)
2330 if (pcidev
->irq
== 0)
2332 if (!(s
= kmalloc(sizeof(struct es1370_state
), GFP_KERNEL
))) {
2333 printk(KERN_WARNING
"es1370: out of memory\n");
2336 memset(s
, 0, sizeof(struct es1370_state
));
2337 init_waitqueue_head(&s
->dma_adc
.wait
);
2338 init_waitqueue_head(&s
->dma_dac1
.wait
);
2339 init_waitqueue_head(&s
->dma_dac2
.wait
);
2340 init_waitqueue_head(&s
->open_wait
);
2341 init_waitqueue_head(&s
->midi
.iwait
);
2342 init_waitqueue_head(&s
->midi
.owait
);
2343 init_MUTEX(&s
->open_sem
);
2344 s
->magic
= ES1370_MAGIC
;
2345 s
->io
= pcidev
->base_address
[0] & PCI_BASE_ADDRESS_IO_MASK
;
2346 s
->irq
= pcidev
->irq
;
2347 if (check_region(s
->io
, ES1370_EXTENT
)) {
2348 printk(KERN_ERR
"es1370: io ports %#lx-%#lx in use\n", s
->io
, s
->io
+ES1370_EXTENT
-1);
2351 request_region(s
->io
, ES1370_EXTENT
, "es1370");
2352 if (request_irq(s
->irq
, es1370_interrupt
, SA_SHIRQ
, "es1370", s
)) {
2353 printk(KERN_ERR
"es1370: irq %u in use\n", s
->irq
);
2356 /* initialize codec registers */
2357 /* note: setting CTRL_SERR_DIS is reported to break
2358 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2359 s
->ctrl
= CTRL_CDC_EN
| (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV
) | (1 << CTRL_SH_WTSRSEL
);
2360 if (joystick
[index
]) {
2361 if (check_region(0x200, JOY_EXTENT
))
2362 printk(KERN_ERR
"es1370: io port 0x200 in use\n");
2364 s
->ctrl
|= CTRL_JYSTK_EN
;
2367 s
->ctrl
|= CTRL_XCTL0
;
2369 s
->ctrl
|= CTRL_XCTL1
;
2371 printk(KERN_INFO
"es1370: found adapter at io %#lx irq %u\n"
2372 KERN_INFO
"es1370: features: joystick %s, line %s, mic impedance %s\n",
2373 s
->io
, s
->irq
, (s
->ctrl
& CTRL_JYSTK_EN
) ? "on" : "off",
2374 (s
->ctrl
& CTRL_XCTL0
) ? "out" : "in",
2375 (s
->ctrl
& CTRL_XCTL1
) ? "1" : "0");
2376 /* register devices */
2377 if ((s
->dev_audio
= register_sound_dsp(&es1370_audio_fops
, -1)) < 0)
2379 if ((s
->dev_mixer
= register_sound_mixer(&es1370_mixer_fops
, -1)) < 0)
2381 if ((s
->dev_dac
= register_sound_dsp(&es1370_dac_fops
, -1)) < 0)
2383 if ((s
->dev_midi
= register_sound_midi(&es1370_midi_fops
, -1)) < 0)
2385 /* initialize the chips */
2386 outl(s
->ctrl
, s
->io
+ES1370_REG_CONTROL
);
2387 outl(s
->sctrl
, s
->io
+ES1370_REG_SERIAL_CONTROL
);
2388 pci_set_master(pcidev
); /* enable bus mastering */
2389 wrcodec(s
, 0x16, 3); /* no RST, PD */
2390 wrcodec(s
, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2391 wrcodec(s
, 0x18, 0); /* recording source is mixer */
2392 wrcodec(s
, 0x19, s
->mix
.micpreamp
= 1); /* turn on MIC preamp */
2396 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
;
2397 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2398 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2399 val
= initvol
[i
].vol
;
2400 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2403 /* queue it for later freeing */
2410 unregister_sound_dsp(s
->dev_dac
);
2412 unregister_sound_mixer(s
->dev_mixer
);
2414 unregister_sound_dsp(s
->dev_audio
);
2416 printk(KERN_ERR
"es1370: cannot register misc device\n");
2417 free_irq(s
->irq
, s
);
2419 release_region(s
->io
, ES1370_EXTENT
);
2421 kfree_s(s
, sizeof(struct es1370_state
));
2428 /* --------------------------------------------------------------------- */
2432 MODULE_PARM(joystick
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2433 MODULE_PARM_DESC(joystick
, "if 1 enables joystick interface (still need separate driver)");
2434 MODULE_PARM(lineout
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2435 MODULE_PARM_DESC(lineout
, "if 1 the LINE input is converted to LINE out");
2436 MODULE_PARM(micbias
, "1-" __MODULE_STRING(NR_DEVICE
) "i");
2437 MODULE_PARM_DESC(micbias
, "sets the +5V bias for an electret microphone");
2439 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2440 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2442 void cleanup_module(void)
2444 struct es1370_state
*s
;
2446 while ((s
= devs
)) {
2448 outl(CTRL_SERR_DIS
| (1 << CTRL_SH_WTSRSEL
), s
->io
+ES1370_REG_CONTROL
); /* switch everything off */
2449 outl(0, s
->io
+ES1370_REG_SERIAL_CONTROL
); /* clear serial interrupts */
2451 free_irq(s
->irq
, s
);
2452 release_region(s
->io
, ES1370_EXTENT
);
2453 unregister_sound_dsp(s
->dev_audio
);
2454 unregister_sound_mixer(s
->dev_mixer
);
2455 unregister_sound_dsp(s
->dev_dac
);
2456 unregister_sound_midi(s
->dev_midi
);
2457 kfree_s(s
, sizeof(struct es1370_state
));
2459 printk(KERN_INFO
"es1370: unloading\n");