?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.7pre7
[davej-history.git] / drivers / sound / es1370.c
blobd7579ffa4f4e1283cd81ddcbed86fbe588144bac
1 /*****************************************************************************/
2
3 /*
4 * es1370.c -- Ensoniq ES1370/Asahi Kasei AK4531 audio driver.
5 *
6 * Copyright (C) 1998-1999 Thomas Sailer (sailer@ife.ee.ethz.ch)
7 *
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.
12 *
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.
17 *
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.
21 *
22 * Special thanks to David C. Niemi
23 *
24 *
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
30 * not ensure that.
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.
37 *
38 *
39 * Note: sync mode is not yet supported (i.e. running dsp and dac from the same
40 * clock source)
41 *
42 * Supported devices:
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
49 *
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.
53 *
54 * Revision history
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
59 * settings
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
66 * miscdevice
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
94 * other than i386
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 *
104 * some important things missing in Ensoniq documentation:
105 *
106 * Experimental PCLKDIV results: play the same waveforms on both DAC1 and DAC2
107 * and vary PCLKDIV to obtain zero beat.
108 * 5512sps: 254
109 * 44100sps: 30
110 * seems to be fs = 1411200/(PCLKDIV+2)
111 *
112 * should find out when curr_sample_ct is cleared and
113 * where exactly the CCB fetches data
114 *
115 * The card uses a 22.5792 MHz crystal.
116 * The LINEIN jack may be converted to an AOUT jack by
117 * setting pin 47 (XCTL0) of the ES1370 to high.
118 * Pin 48 (XCTL1) of the ES1370 sets the +5V bias for an electretmic
119 *
120 *
121 */
122
123 /*****************************************************************************/
124
125 #include <linux/config.h>
126 #include <linux/version.h>
127 #include <linux/module.h>
128 #include <linux/string.h>
129 #include <linux/ioport.h>
130 #include <linux/sched.h>
131 #include <linux/delay.h>
132 #include <linux/sound.h>
133 #include <linux/malloc.h>
134 #include <linux/soundcard.h>
135 #include <linux/pci.h>
136 #include <asm/io.h>
137 #include <asm/dma.h>
138 #include <linux/init.h>
139 #include <linux/poll.h>
140 #include <asm/spinlock.h>
141 #include <asm/uaccess.h>
142 #include <asm/hardirq.h>
143
144 /* --------------------------------------------------------------------- */
145
146 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
147 #define DBG(x) {}
148 /*#define DBG(x) {x}*/
149
150 /* --------------------------------------------------------------------- */
151
152 #ifndef PCI_VENDOR_ID_ENSONIQ
153 #define PCI_VENDOR_ID_ENSONIQ 0x1274
154 #endif
155 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1370
156 #define PCI_DEVICE_ID_ENSONIQ_ES1370 0x5000
157 #endif
158
159 #define ES1370_MAGIC ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1370)
160
161 #define ES1370_EXTENT 0x40
162 #define JOY_EXTENT 8
163
164 #define ES1370_REG_CONTROL 0x00
165 #define ES1370_REG_STATUS 0x04
166 #define ES1370_REG_UART_DATA 0x08
167 #define ES1370_REG_UART_STATUS 0x09
168 #define ES1370_REG_UART_CONTROL 0x09
169 #define ES1370_REG_UART_TEST 0x0a
170 #define ES1370_REG_MEMPAGE 0x0c
171 #define ES1370_REG_CODEC 0x10
172 #define ES1370_REG_SERIAL_CONTROL 0x20
173 #define ES1370_REG_DAC1_SCOUNT 0x24
174 #define ES1370_REG_DAC2_SCOUNT 0x28
175 #define ES1370_REG_ADC_SCOUNT 0x2c
176
177 #define ES1370_REG_DAC1_FRAMEADR 0xc30
178 #define ES1370_REG_DAC1_FRAMECNT 0xc34
179 #define ES1370_REG_DAC2_FRAMEADR 0xc38
180 #define ES1370_REG_DAC2_FRAMECNT 0xc3c
181 #define ES1370_REG_ADC_FRAMEADR 0xd30
182 #define ES1370_REG_ADC_FRAMECNT 0xd34
183
184 #define ES1370_FMT_U8_MONO 0
185 #define ES1370_FMT_U8_STEREO 1
186 #define ES1370_FMT_S16_MONO 2
187 #define ES1370_FMT_S16_STEREO 3
188 #define ES1370_FMT_STEREO 1
189 #define ES1370_FMT_S16 2
190 #define ES1370_FMT_MASK 3
191
192 static const unsigned sample_size[] = { 1, 2, 2, 4 };
193 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
194
195 static const unsigned dac1_samplerate[] = { 5512, 11025, 22050, 44100 };
196
197 #define DAC2_SRTODIV(x) (((1411200+(x)/2)/(x))-2)
198 #define DAC2_DIVTOSR(x) (1411200/((x)+2))
199
200 #define CTRL_ADC_STOP 0x80000000 /* 1 = ADC stopped */
201 #define CTRL_XCTL1 0x40000000 /* electret mic bias */
202 #define CTRL_OPEN 0x20000000 /* no function, can be read and written */
203 #define CTRL_PCLKDIV 0x1fff0000 /* ADC/DAC2 clock divider */
204 #define CTRL_SH_PCLKDIV 16
205 #define CTRL_MSFMTSEL 0x00008000 /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
206 #define CTRL_M_SBB 0x00004000 /* DAC2 clock: 0 = PCLKDIV, 1 = MPEG */
207 #define CTRL_WTSRSEL 0x00003000 /* DAC1 clock freq: 0=5512, 1=11025, 2=22050, 3=44100 */
208 #define CTRL_SH_WTSRSEL 12
209 #define CTRL_DAC_SYNC 0x00000800 /* 1 = DAC2 runs off DAC1 clock */
210 #define CTRL_CCB_INTRM 0x00000400 /* 1 = CCB "voice" ints enabled */
211 #define CTRL_M_CB 0x00000200 /* recording source: 0 = ADC, 1 = MPEG */
212 #define CTRL_XCTL0 0x00000100 /* 0 = Line in, 1 = Line out */
213 #define CTRL_BREQ 0x00000080 /* 1 = test mode (internal mem test) */
214 #define CTRL_DAC1_EN 0x00000040 /* enable DAC1 */
215 #define CTRL_DAC2_EN 0x00000020 /* enable DAC2 */
216 #define CTRL_ADC_EN 0x00000010 /* enable ADC */
217 #define CTRL_UART_EN 0x00000008 /* enable MIDI uart */
218 #define CTRL_JYSTK_EN 0x00000004 /* enable Joystick port (presumably at address 0x200) */
219 #define CTRL_CDC_EN 0x00000002 /* enable serial (CODEC) interface */
220 #define CTRL_SERR_DIS 0x00000001 /* 1 = disable PCI SERR signal */
221
222 #define STAT_INTR 0x80000000 /* wired or of all interrupt bits */
223 #define STAT_CSTAT 0x00000400 /* 1 = codec busy or codec write in progress */
224 #define STAT_CBUSY 0x00000200 /* 1 = codec busy */
225 #define STAT_CWRIP 0x00000100 /* 1 = codec write in progress */
226 #define STAT_VC 0x00000060 /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
227 #define STAT_SH_VC 5
228 #define STAT_MCCB 0x00000010 /* CCB int pending */
229 #define STAT_UART 0x00000008 /* UART int pending */
230 #define STAT_DAC1 0x00000004 /* DAC1 int pending */
231 #define STAT_DAC2 0x00000002 /* DAC2 int pending */
232 #define STAT_ADC 0x00000001 /* ADC int pending */
233
234 #define USTAT_RXINT 0x80 /* UART rx int pending */
235 #define USTAT_TXINT 0x04 /* UART tx int pending */
236 #define USTAT_TXRDY 0x02 /* UART tx ready */
237 #define USTAT_RXRDY 0x01 /* UART rx ready */
238
239 #define UCTRL_RXINTEN 0x80 /* 1 = enable RX ints */
240 #define UCTRL_TXINTEN 0x60 /* TX int enable field mask */
241 #define UCTRL_ENA_TXINT 0x20 /* enable TX int */
242 #define UCTRL_CNTRL 0x03 /* control field */
243 #define UCTRL_CNTRL_SWR 0x03 /* software reset command */
244
245 #define SCTRL_P2ENDINC 0x00380000 /* */
246 #define SCTRL_SH_P2ENDINC 19
247 #define SCTRL_P2STINC 0x00070000 /* */
248 #define SCTRL_SH_P2STINC 16
249 #define SCTRL_R1LOOPSEL 0x00008000 /* 0 = loop mode */
250 #define SCTRL_P2LOOPSEL 0x00004000 /* 0 = loop mode */
251 #define SCTRL_P1LOOPSEL 0x00002000 /* 0 = loop mode */
252 #define SCTRL_P2PAUSE 0x00001000 /* 1 = pause mode */
253 #define SCTRL_P1PAUSE 0x00000800 /* 1 = pause mode */
254 #define SCTRL_R1INTEN 0x00000400 /* enable interrupt */
255 #define SCTRL_P2INTEN 0x00000200 /* enable interrupt */
256 #define SCTRL_P1INTEN 0x00000100 /* enable interrupt */
257 #define SCTRL_P1SCTRLD 0x00000080 /* reload sample count register for DAC1 */
258 #define SCTRL_P2DACSEN 0x00000040 /* 1 = DAC2 play back last sample when disabled */
259 #define SCTRL_R1SEB 0x00000020 /* 1 = 16bit */
260 #define SCTRL_R1SMB 0x00000010 /* 1 = stereo */
261 #define SCTRL_R1FMT 0x00000030 /* format mask */
262 #define SCTRL_SH_R1FMT 4
263 #define SCTRL_P2SEB 0x00000008 /* 1 = 16bit */
264 #define SCTRL_P2SMB 0x00000004 /* 1 = stereo */
265 #define SCTRL_P2FMT 0x0000000c /* format mask */
266 #define SCTRL_SH_P2FMT 2
267 #define SCTRL_P1SEB 0x00000002 /* 1 = 16bit */
268 #define SCTRL_P1SMB 0x00000001 /* 1 = stereo */
269 #define SCTRL_P1FMT 0x00000003 /* format mask */
270 #define SCTRL_SH_P1FMT 0
271
272 /* misc stuff */
273
274 #define FMODE_DAC 4 /* slight misuse of mode_t */
275
276 /* MIDI buffer sizes */
277
278 #define MIDIINBUF 256
279 #define MIDIOUTBUF 256
280
281 #define FMODE_MIDI_SHIFT 3
282 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
283 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
284
285 #define SND_DEV_DSP16 5
286
287 /* --------------------------------------------------------------------- */
288
289 struct es1370_state {
290 /* magic */
291 unsigned int magic;
292
293 /* we keep sb cards in a linked list */
294 struct es1370_state *next;
295
296 /* soundcore stuff */
297 int dev_audio;
298 int dev_mixer;
299 int dev_dac;
300 int dev_midi;
301
302 /* hardware resources */
303 unsigned long io; /* long for SPARC */
304 unsigned int irq;
305
306 /* mixer registers; there is no HW readback */
307 struct {
308 unsigned short vol[10];
309 unsigned int recsrc;
310 unsigned int modcnt;
311 unsigned short micpreamp;
312 unsigned int imix;
313 } mix;
314
315 /* wave stuff */
316 unsigned ctrl;
317 unsigned sctrl;
318
319 spinlock_t lock;
320 struct semaphore open_sem;
321 mode_t open_mode;
322 wait_queue_head_t open_wait;
323
324 struct dmabuf {
325 void *rawbuf;
326 unsigned buforder;
327 unsigned numfrag;
328 unsigned fragshift;
329 unsigned hwptr, swptr;
330 unsigned total_bytes;
331 int count;
332 unsigned error; /* over/underrun */
333 wait_queue_head_t wait;
334 /* redundant, but makes calculations easier */
335 unsigned fragsize;
336 unsigned dmasize;
337 unsigned fragsamples;
338 /* OSS stuff */
339 unsigned mapped:1;
340 unsigned ready:1;
341 unsigned endcleared:1;
342 unsigned ossfragshift;
343 int ossmaxfrags;
344 unsigned subdivision;
345 } dma_dac1, dma_dac2, dma_adc;
346
347 /* midi stuff */
348 struct {
349 unsigned ird, iwr, icnt;
350 unsigned ord, owr, ocnt;
351 wait_queue_head_t iwait;
352 wait_queue_head_t owait;
353 unsigned char ibuf[MIDIINBUF];
354 unsigned char obuf[MIDIOUTBUF];
355 } midi;
356 };
357
358 /* --------------------------------------------------------------------- */
359
360 static struct es1370_state *devs = NULL;
361
362 /* --------------------------------------------------------------------- */
363
364 extern inline unsigned ld2(unsigned int x)
365 {
366 unsigned r = 0;
367
368 if (x >= 0x10000) {
369 x >>= 16;
370 r += 16;
371 }
372 if (x >= 0x100) {
373 x >>= 8;
374 r += 8;
375 }
376 if (x >= 0x10) {
377 x >>= 4;
378 r += 4;
379 }
380 if (x >= 4) {
381 x >>= 2;
382 r += 2;
383 }
384 if (x >= 2)
385 r++;
386 return r;
387 }
388
389 /* --------------------------------------------------------------------- */
390
391 static void wrcodec(struct es1370_state *s, unsigned char idx, unsigned char data)
392 {
393 unsigned long tmo = jiffies + HZ/10;
394
395 do {
396 if (!(inl(s->io+ES1370_REG_STATUS) & STAT_CSTAT)) {
397 outw((((unsigned short)idx)<<8)|data, s->io+ES1370_REG_CODEC);
398 return;
399 }
400 schedule();
401 } while ((signed)(tmo-jiffies) > 0);
402 printk(KERN_ERR "es1370: write to codec register timeout\n");
403 }
404
405 /* --------------------------------------------------------------------- */
406
407 extern inline void stop_adc(struct es1370_state *s)
408 {
409 unsigned long flags;
410
411 spin_lock_irqsave(&s->lock, flags);
412 s->ctrl &= ~CTRL_ADC_EN;
413 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
414 spin_unlock_irqrestore(&s->lock, flags);
415 }
416
417 extern inline void stop_dac1(struct es1370_state *s)
418 {
419 unsigned long flags;
420
421 spin_lock_irqsave(&s->lock, flags);
422 s->ctrl &= ~CTRL_DAC1_EN;
423 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
424 spin_unlock_irqrestore(&s->lock, flags);
425 }
426
427 extern inline void stop_dac2(struct es1370_state *s)
428 {
429 unsigned long flags;
430
431 spin_lock_irqsave(&s->lock, flags);
432 s->ctrl &= ~CTRL_DAC2_EN;
433 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
434 spin_unlock_irqrestore(&s->lock, flags);
435 }
436
437 static void start_dac1(struct es1370_state *s)
438 {
439 unsigned long flags;
440 unsigned fragremain, fshift;
441
442 spin_lock_irqsave(&s->lock, flags);
443 if (!(s->ctrl & CTRL_DAC1_EN) && (s->dma_dac1.mapped || s->dma_dac1.count > 0)
444 && s->dma_dac1.ready) {
445 s->ctrl |= CTRL_DAC1_EN;
446 s->sctrl = (s->sctrl & ~(SCTRL_P1LOOPSEL | SCTRL_P1PAUSE | SCTRL_P1SCTRLD)) | SCTRL_P1INTEN;
447 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
448 fragremain = ((- s->dma_dac1.hwptr) & (s->dma_dac1.fragsize-1));
449 fshift = sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
450 if (fragremain < 2*fshift)
451 fragremain = s->dma_dac1.fragsize;
452 outl((fragremain >> fshift) - 1, s->io+ES1370_REG_DAC1_SCOUNT);
453 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
454 outl((s->dma_dac1.fragsize >> fshift) - 1, s->io+ES1370_REG_DAC1_SCOUNT);
455 }
456 spin_unlock_irqrestore(&s->lock, flags);
457 }
458
459 static void start_dac2(struct es1370_state *s)
460 {
461 unsigned long flags;
462 unsigned fragremain, fshift;
463
464 spin_lock_irqsave(&s->lock, flags);
465 if (!(s->ctrl & CTRL_DAC2_EN) && (s->dma_dac2.mapped || s->dma_dac2.count > 0)
466 && s->dma_dac2.ready) {
467 s->ctrl |= CTRL_DAC2_EN;
468 s->sctrl = (s->sctrl & ~(SCTRL_P2LOOPSEL | SCTRL_P2PAUSE | SCTRL_P2DACSEN |
469 SCTRL_P2ENDINC | SCTRL_P2STINC)) | SCTRL_P2INTEN |
470 (((s->sctrl & SCTRL_P2FMT) ? 2 : 1) << SCTRL_SH_P2ENDINC) |
471 (0 << SCTRL_SH_P2STINC);
472 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
473 fragremain = ((- s->dma_dac2.hwptr) & (s->dma_dac2.fragsize-1));
474 fshift = sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
475 if (fragremain < 2*fshift)
476 fragremain = s->dma_dac2.fragsize;
477 outl((fragremain >> fshift) - 1, s->io+ES1370_REG_DAC2_SCOUNT);
478 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
479 outl((s->dma_dac2.fragsize >> fshift) - 1, s->io+ES1370_REG_DAC2_SCOUNT);
480 }
481 spin_unlock_irqrestore(&s->lock, flags);
482 }
483
484 static void start_adc(struct es1370_state *s)
485 {
486 unsigned long flags;
487 unsigned fragremain, fshift;
488
489 spin_lock_irqsave(&s->lock, flags);
490 if (!(s->ctrl & CTRL_ADC_EN) && (s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize))
491 && s->dma_adc.ready) {
492 s->ctrl |= CTRL_ADC_EN;
493 s->sctrl = (s->sctrl & ~SCTRL_R1LOOPSEL) | SCTRL_R1INTEN;
494 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
495 fragremain = ((- s->dma_adc.hwptr) & (s->dma_adc.fragsize-1));
496 fshift = sample_shift[(s->sctrl & SCTRL_R1FMT) >> SCTRL_SH_R1FMT];
497 if (fragremain < 2*fshift)
498 fragremain = s->dma_adc.fragsize;
499 outl((fragremain >> fshift) - 1, s->io+ES1370_REG_ADC_SCOUNT);
500 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
501 outl((s->dma_adc.fragsize >> fshift) - 1, s->io+ES1370_REG_ADC_SCOUNT);
502 }
503 spin_unlock_irqrestore(&s->lock, flags);
504 }
505
506 /* --------------------------------------------------------------------- */
507
508 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
509 #define DMABUF_MINORDER 1
510
511 extern inline void dealloc_dmabuf(struct dmabuf *db)
512 {
513 unsigned long map, mapend;
514
515 if (db->rawbuf) {
516 /* undo marking the pages as reserved */
517 mapend = MAP_NR(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
518 for (map = MAP_NR(db->rawbuf); map <= mapend; map++)
519 clear_bit(PG_reserved, &mem_map[map].flags);
520 free_pages((unsigned long)db->rawbuf, db->buforder);
521 }
522 db->rawbuf = NULL;
523 db->mapped = db->ready = 0;
524 }
525
526 static int prog_dmabuf(struct es1370_state *s, struct dmabuf *db, unsigned rate, unsigned fmt, unsigned reg)
527 {
528 int order;
529 unsigned bytepersec;
530 unsigned bufs;
531 unsigned long map, mapend;
532
533 db->hwptr = db->swptr = db->total_bytes = db->count = db->error = db->endcleared = 0;
534 if (!db->rawbuf) {
535 db->ready = db->mapped = 0;
536 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--)
537 if ((db->rawbuf = (void *)__get_free_pages(GFP_KERNEL, order)))
538 break;
539 if (!db->rawbuf)
540 return -ENOMEM;
541 db->buforder = order;
542 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
543 mapend = MAP_NR(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
544 for (map = MAP_NR(db->rawbuf); map <= mapend; map++)
545 set_bit(PG_reserved, &mem_map[map].flags);
546 }
547 fmt &= ES1370_FMT_MASK;
548 bytepersec = rate << sample_shift[fmt];
549 bufs = PAGE_SIZE << db->buforder;
550 if (db->ossfragshift) {
551 if ((1000 << db->ossfragshift) < bytepersec)
552 db->fragshift = ld2(bytepersec/1000);
553 else
554 db->fragshift = db->ossfragshift;
555 } else {
556 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
557 if (db->fragshift < 3)
558 db->fragshift = 3;
559 }
560 db->numfrag = bufs >> db->fragshift;
561 while (db->numfrag < 4 && db->fragshift > 3) {
562 db->fragshift--;
563 db->numfrag = bufs >> db->fragshift;
564 }
565 db->fragsize = 1 << db->fragshift;
566 if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
567 db->numfrag = db->ossmaxfrags;
568 db->fragsamples = db->fragsize >> sample_shift[fmt];
569 db->dmasize = db->numfrag << db->fragshift;
570 memset(db->rawbuf, (fmt & ES1370_FMT_S16) ? 0 : 0x80, db->dmasize);
571 outl((reg >> 8) & 15, s->io+ES1370_REG_MEMPAGE);
572 outl(virt_to_bus(db->rawbuf), s->io+(reg & 0xff));
573 outl((db->dmasize >> 2)-1, s->io+((reg + 4) & 0xff));
574 db->ready = 1;
575 return 0;
576 }
577
578 extern inline int prog_dmabuf_adc(struct es1370_state *s)
579 {
580 stop_adc(s);
581 return prog_dmabuf(s, &s->dma_adc, DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV),
582 (s->sctrl >> SCTRL_SH_R1FMT) & ES1370_FMT_MASK, ES1370_REG_ADC_FRAMEADR);
583 }
584
585 extern inline int prog_dmabuf_dac2(struct es1370_state *s)
586 {
587 stop_dac2(s);
588 return prog_dmabuf(s, &s->dma_dac2, DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV),
589 (s->sctrl >> SCTRL_SH_P2FMT) & ES1370_FMT_MASK, ES1370_REG_DAC2_FRAMEADR);
590 }
591
592 extern inline int prog_dmabuf_dac1(struct es1370_state *s)
593 {
594 stop_dac1(s);
595 return prog_dmabuf(s, &s->dma_dac1, dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL],
596 (s->sctrl >> SCTRL_SH_P1FMT) & ES1370_FMT_MASK, ES1370_REG_DAC1_FRAMEADR);
597 }
598
599 extern inline unsigned get_hwptr(struct es1370_state *s, struct dmabuf *db, unsigned reg)
600 {
601 unsigned hwptr, diff;
602
603 outl((reg >> 8) & 15, s->io+ES1370_REG_MEMPAGE);
604 hwptr = (inl(s->io+(reg & 0xff)) >> 14) & 0x3fffc;
605 diff = (db->dmasize + hwptr - db->hwptr) % db->dmasize;
606 db->hwptr = hwptr;
607 return diff;
608 }
609
610 extern inline void clear_advance(void *buf, unsigned bsize, unsigned bptr, unsigned len, unsigned char c)
611 {
612 if (bptr + len > bsize) {
613 unsigned x = bsize - bptr;
614 memset(((char *)buf) + bptr, c, x);
615 bptr = 0;
616 len -= x;
617 }
618 memset(((char *)buf) + bptr, c, len);
619 }
620
621 /* call with spinlock held! */
622 static void es1370_update_ptr(struct es1370_state *s)
623 {
624 int diff;
625
626 /* update ADC pointer */
627 if (s->ctrl & CTRL_ADC_EN) {
628 diff = get_hwptr(s, &s->dma_adc, ES1370_REG_ADC_FRAMECNT);
629 s->dma_adc.total_bytes += diff;
630 s->dma_adc.count += diff;
631 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
632 wake_up(&s->dma_adc.wait);
633 if (!s->dma_adc.mapped) {
634 if (s->dma_adc.count > (signed)(s->dma_adc.dmasize - ((3 * s->dma_adc.fragsize) >> 1))) {
635 s->ctrl &= ~CTRL_ADC_EN;
636 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
637 s->dma_adc.error++;
638 }
639 }
640 }
641 /* update DAC1 pointer */
642 if (s->ctrl & CTRL_DAC1_EN) {
643 diff = get_hwptr(s, &s->dma_dac1, ES1370_REG_DAC1_FRAMECNT);
644 s->dma_dac1.total_bytes += diff;
645 if (s->dma_dac1.mapped) {
646 s->dma_dac1.count += diff;
647 if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
648 wake_up(&s->dma_dac1.wait);
649 } else {
650 s->dma_dac1.count -= diff;
651 if (s->dma_dac1.count <= 0) {
652 s->ctrl &= ~CTRL_DAC1_EN;
653 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
654 s->dma_dac1.error++;
655 } else if (s->dma_dac1.count <= (signed)s->dma_dac1.fragsize && !s->dma_dac1.endcleared) {
656 clear_advance(s->dma_dac1.rawbuf, s->dma_dac1.dmasize, s->dma_dac1.swptr,
657 s->dma_dac1.fragsize, (s->sctrl & SCTRL_P1SEB) ? 0 : 0x80);
658 s->dma_dac1.endcleared = 1;
659 }
660 if (s->dma_dac1.count + (signed)s->dma_dac1.fragsize <= (signed)s->dma_dac1.dmasize)
661 wake_up(&s->dma_dac1.wait);
662 }
663 }
664 /* update DAC2 pointer */
665 if (s->ctrl & CTRL_DAC2_EN) {
666 diff = get_hwptr(s, &s->dma_dac2, ES1370_REG_DAC2_FRAMECNT);
667 s->dma_dac2.total_bytes += diff;
668 if (s->dma_dac2.mapped) {
669 s->dma_dac2.count += diff;
670 if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize)
671 wake_up(&s->dma_dac2.wait);
672 } else {
673 s->dma_dac2.count -= diff;
674 if (s->dma_dac2.count <= 0) {
675 s->ctrl &= ~CTRL_DAC2_EN;
676 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
677 s->dma_dac2.error++;
678 } else if (s->dma_dac2.count <= (signed)s->dma_dac2.fragsize && !s->dma_dac2.endcleared) {
679 clear_advance(s->dma_dac2.rawbuf, s->dma_dac2.dmasize, s->dma_dac2.swptr,
680 s->dma_dac2.fragsize, (s->sctrl & SCTRL_P2SEB) ? 0 : 0x80);
681 s->dma_dac2.endcleared = 1;
682 }
683 if (s->dma_dac2.count + (signed)s->dma_dac2.fragsize <= (signed)s->dma_dac2.dmasize)
684 wake_up(&s->dma_dac2.wait);
685 }
686 }
687 }
688
689 /* hold spinlock for the following! */
690 static void es1370_handle_midi(struct es1370_state *s)
691 {
692 unsigned char ch;
693 int wake;
694
695 if (!(s->ctrl & CTRL_UART_EN))
696 return;
697 wake = 0;
698 while (inb(s->io+ES1370_REG_UART_STATUS) & USTAT_RXRDY) {
699 ch = inb(s->io+ES1370_REG_UART_DATA);
700 if (s->midi.icnt < MIDIINBUF) {
701 s->midi.ibuf[s->midi.iwr] = ch;
702 s->midi.iwr = (s->midi.iwr + 1) % MIDIINBUF;
703 s->midi.icnt++;
704 }
705 wake = 1;
706 }
707 if (wake)
708 wake_up(&s->midi.iwait);
709 wake = 0;
710 while ((inb(s->io+ES1370_REG_UART_STATUS) & USTAT_TXRDY) && s->midi.ocnt > 0) {
711 outb(s->midi.obuf[s->midi.ord], s->io+ES1370_REG_UART_DATA);
712 s->midi.ord = (s->midi.ord + 1) % MIDIOUTBUF;
713 s->midi.ocnt--;
714 if (s->midi.ocnt < MIDIOUTBUF-16)
715 wake = 1;
716 }
717 if (wake)
718 wake_up(&s->midi.owait);
719 outb((s->midi.ocnt > 0) ? UCTRL_RXINTEN | UCTRL_ENA_TXINT : UCTRL_RXINTEN, s->io+ES1370_REG_UART_CONTROL);
720 }
721
722 static void es1370_interrupt(int irq, void *dev_id, struct pt_regs *regs)
723 {
724 struct es1370_state *s = (struct es1370_state *)dev_id;
725 unsigned int intsrc, sctl;
726
727 /* fastpath out, to ease interrupt sharing */
728 intsrc = inl(s->io+ES1370_REG_STATUS);
729 if (!(intsrc & 0x80000000))
730 return;
731 spin_lock(&s->lock);
732 /* clear audio interrupts first */
733 sctl = s->sctrl;
734 if (intsrc & STAT_ADC)
735 sctl &= ~SCTRL_R1INTEN;
736 if (intsrc & STAT_DAC1)
737 sctl &= ~SCTRL_P1INTEN;
738 if (intsrc & STAT_DAC2)
739 sctl &= ~SCTRL_P2INTEN;
740 outl(sctl, s->io+ES1370_REG_SERIAL_CONTROL);
741 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
742 es1370_update_ptr(s);
743 es1370_handle_midi(s);
744 spin_unlock(&s->lock);
745 }
746
747 /* --------------------------------------------------------------------- */
748
749 static const char invalid_magic[] = KERN_CRIT "es1370: invalid magic value\n";
750
751 #define VALIDATE_STATE(s) \
752 ({ \
753 if (!(s) || (s)->magic != ES1370_MAGIC) { \
754 printk(invalid_magic); \
755 return -ENXIO; \
756 } \
757 })
758
759 /* --------------------------------------------------------------------- */
760
761 static const struct {
762 unsigned volidx:4;
763 unsigned left:4;
764 unsigned right:4;
765 unsigned stereo:1;
766 unsigned recmask:13;
767 unsigned avail:1;
768 } mixtable[SOUND_MIXER_NRDEVICES] = {
769 [SOUND_MIXER_VOLUME] = { 0, 0x0, 0x1, 1, 0x0000, 1 }, /* master */
770 [SOUND_MIXER_PCM] = { 1, 0x2, 0x3, 1, 0x0400, 1 }, /* voice */
771 [SOUND_MIXER_SYNTH] = { 2, 0x4, 0x5, 1, 0x0060, 1 }, /* FM */
772 [SOUND_MIXER_CD] = { 3, 0x6, 0x7, 1, 0x0006, 1 }, /* CD */
773 [SOUND_MIXER_LINE] = { 4, 0x8, 0x9, 1, 0x0018, 1 }, /* Line */
774 [SOUND_MIXER_LINE1] = { 5, 0xa, 0xb, 1, 0x1800, 1 }, /* AUX */
775 [SOUND_MIXER_LINE2] = { 6, 0xc, 0x0, 0, 0x0100, 1 }, /* Mono1 */
776 [SOUND_MIXER_LINE3] = { 7, 0xd, 0x0, 0, 0x0200, 1 }, /* Mono2 */
777 [SOUND_MIXER_MIC] = { 8, 0xe, 0x0, 0, 0x0001, 1 }, /* Mic */
778 [SOUND_MIXER_OGAIN] = { 9, 0xf, 0x0, 0, 0x0000, 1 } /* mono out */
779 };
780
781 static int mixer_ioctl(struct es1370_state *s, unsigned int cmd, unsigned long arg)
782 {
783 unsigned long flags;
784 int i, val, j;
785 unsigned char l, r, rl, rr;
786
787 VALIDATE_STATE(s);
788 if (cmd == SOUND_MIXER_PRIVATE1) {
789 /* enable/disable/query mixer preamp */
790 get_user_ret(val, (int *)arg, -EFAULT);
791 if (val != -1) {
792 s->mix.micpreamp = !!val;
793 wrcodec(s, 0x19, s->mix.micpreamp);
794 }
795 return put_user(s->mix.micpreamp, (int *)arg);
796 }
797 if (cmd == SOUND_MIXER_PRIVATE2) {
798 /* enable/disable/query use of linein as second lineout */
799 get_user_ret(val, (int *)arg, -EFAULT);
800 if (val != -1) {
801 spin_lock_irqsave(&s->lock, flags);
802 if (val)
803 s->ctrl |= CTRL_XCTL0;
804 else
805 s->ctrl &= ~CTRL_XCTL0;
806 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
807 spin_unlock_irqrestore(&s->lock, flags);
808 }
809 return put_user((s->ctrl & CTRL_XCTL0) ? 1 : 0, (int *)arg);
810 }
811 if (cmd == SOUND_MIXER_PRIVATE3) {
812 /* enable/disable/query microphone impedance setting */
813 get_user_ret(val, (int *)arg, -EFAULT);
814 if (val != -1) {
815 spin_lock_irqsave(&s->lock, flags);
816 if (val)
817 s->ctrl |= CTRL_XCTL1;
818 else
819 s->ctrl &= ~CTRL_XCTL1;
820 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
821 spin_unlock_irqrestore(&s->lock, flags);
822 }
823 return put_user((s->ctrl & CTRL_XCTL1) ? 1 : 0, (int *)arg);
824 }
825 if (cmd == SOUND_MIXER_INFO) {
826 mixer_info info;
827 strncpy(info.id, "ES1370", sizeof(info.id));
828 strncpy(info.name, "Ensoniq ES1370", sizeof(info.name));
829 info.modify_counter = s->mix.modcnt;
830 if (copy_to_user((void *)arg, &info, sizeof(info)))
831 return -EFAULT;
832 return 0;
833 }
834 if (cmd == SOUND_OLD_MIXER_INFO) {
835 _old_mixer_info info;
836 strncpy(info.id, "ES1370", sizeof(info.id));
837 strncpy(info.name, "Ensoniq ES1370", sizeof(info.name));
838 if (copy_to_user((void *)arg, &info, sizeof(info)))
839 return -EFAULT;
840 return 0;
841 }
842 if (cmd == OSS_GETVERSION)
843 return put_user(SOUND_VERSION, (int *)arg);
844 if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
845 return -EINVAL;
846 if (_IOC_DIR(cmd) == _IOC_READ) {
847 switch (_IOC_NR(cmd)) {
848 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
849 return put_user(s->mix.recsrc, (int *)arg);
850
851 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
852 val = SOUND_MASK_IMIX;
853 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
854 if (mixtable[i].avail)
855 val |= 1 << i;
856 return put_user(val, (int *)arg);
857
858 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
859 for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
860 if (mixtable[i].recmask)
861 val |= 1 << i;
862 return put_user(val, (int *)arg);
863
864 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
865 for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
866 if (mixtable[i].stereo)
867 val |= 1 << i;
868 return put_user(val, (int *)arg);
869
870 case SOUND_MIXER_CAPS:
871 return put_user(0, (int *)arg);
872
873 case SOUND_MIXER_IMIX:
874 return put_user(s->mix.imix, (int *)arg);
875
876 default:
877 i = _IOC_NR(cmd);
878 if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].avail)
879 return -EINVAL;
880 return put_user(s->mix.vol[mixtable[i].volidx], (int *)arg);
881 }
882 }
883 if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
884 return -EINVAL;
885 s->mix.modcnt++;
886 switch (_IOC_NR(cmd)) {
887
888 case SOUND_MIXER_IMIX:
889 if (arg == 0)
890 return -EFAULT;
891 get_user_ret(s->mix.imix,(int *)arg, -EFAULT);
892 val = s->mix.recsrc;
893 /* fall through */
894
895 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
896 get_user_ret(val, (int *)arg, -EFAULT);
897 for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
898 if (!(val & (1 << i)))
899 continue;
900 if (!mixtable[i].recmask) {
901 val &= ~(1 << i);
902 continue;
903 }
904 j |= mixtable[i].recmask;
905 }
906 s->mix.recsrc = val;
907 wrcodec(s, 0x12, j & 0xd5);
908 wrcodec(s, 0x13, j & 0xaa);
909 wrcodec(s, 0x14, (j >> 8) & 0x17);
910 wrcodec(s, 0x15, (j >> 8) & 0x0f);
911 i = (j & 0x37f) | ((j << 1) & 0x3000) | 0xc60;
912 if (!s->mix.imix) {
913 i &= 0xff60; /* mute record and line monitor */
914 }
915 wrcodec(s, 0x10, i);
916 wrcodec(s, 0x11, i >> 8);
917 return 0;
918
919 default:
920 i = _IOC_NR(cmd);
921 if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].avail)
922 return -EINVAL;
923 get_user_ret(val, (int *)arg, -EFAULT);
924 l = val & 0xff;
925 if (l > 100)
926 l = 100;
927 if (mixtable[i].stereo) {
928 r = (val >> 8) & 0xff;
929 if (r > 100)
930 r = 100;
931 if (l < 7) {
932 rl = 0x80;
933 l = 0;
934 } else {
935 rl = 31 - ((l - 7) / 3);
936 l = (31 - rl) * 3 + 7;
937 }
938 if (r < 7) {
939 rr = 0x80;
940 r = 0;
941 } else {
942 rr = 31 - ((r - 7) / 3);
943 r = (31 - rr) * 3 + 7;
944 }
945 wrcodec(s, mixtable[i].right, rr);
946 } else {
947 if (mixtable[i].left == 15) {
948 if (l < 2) {
949 rr = rl = 0x80;
950 r = l = 0;
951 } else {
952 rl = 7 - ((l - 2) / 14);
953 r = l = (7 - rl) * 14 + 2;
954 }
955 } else {
956 if (l < 7) {
957 rl = 0x80;
958 r = l = 0;
959 } else {
960 rl = 31 - ((l - 7) / 3);
961 r = l = (31 - rl) * 3 + 7;
962 }
963 }
964 }
965 wrcodec(s, mixtable[i].left, rl);
966 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
967 s->mix.vol[mixtable[i].volidx] = ((unsigned int)r << 8) | l;
968 #else
969 s->mix.vol[mixtable[i].volidx] = val;
970 #endif
971 return put_user(s->mix.vol[mixtable[i].volidx], (int *)arg);
972 }
973 }
974
975 /* --------------------------------------------------------------------- */
976
977 static loff_t es1370_llseek(struct file *file, loff_t offset, int origin)
978 {
979 return -ESPIPE;
980 }
981
982 /* --------------------------------------------------------------------- */
983
984 static int es1370_open_mixdev(struct inode *inode, struct file *file)
985 {
986 int minor = MINOR(inode->i_rdev);
987 struct es1370_state *s = devs;
988
989 while (s && s->dev_mixer != minor)
990 s = s->next;
991 if (!s)
992 return -ENODEV;
993 VALIDATE_STATE(s);
994 file->private_data = s;
995 MOD_INC_USE_COUNT;
996 return 0;
997 }
998
999 static int es1370_release_mixdev(struct inode *inode, struct file *file)
1000 {
1001 struct es1370_state *s = (struct es1370_state *)file->private_data;
1002
1003 VALIDATE_STATE(s);
1004 MOD_DEC_USE_COUNT;
1005 return 0;
1006 }
1007
1008 static int es1370_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1009 {
1010 return mixer_ioctl((struct es1370_state *)file->private_data, cmd, arg);
1011 }
1012
1013 static /*const*/ struct file_operations es1370_mixer_fops = {
1014 &es1370_llseek,
1015 NULL, /* read */
1016 NULL, /* write */
1017 NULL, /* readdir */
1018 NULL, /* poll */
1019 &es1370_ioctl_mixdev,
1020 NULL, /* mmap */
1021 &es1370_open_mixdev,
1022 NULL, /* flush */
1023 &es1370_release_mixdev,
1024 NULL, /* fsync */
1025 NULL, /* fasync */
1026 NULL, /* check_media_change */
1027 NULL, /* revalidate */
1028 NULL, /* lock */
1029 };
1030
1031 /* --------------------------------------------------------------------- */
1032
1033 static int drain_dac1(struct es1370_state *s, int nonblock)
1034 {
1035 DECLARE_WAITQUEUE(wait, current);
1036 unsigned long flags;
1037 int count, tmo;
1038
1039 if (s->dma_dac1.mapped || !s->dma_dac1.ready)
1040 return 0;
1041 current->state = TASK_INTERRUPTIBLE;
1042 add_wait_queue(&s->dma_dac1.wait, &wait);
1043 for (;;) {
1044 spin_lock_irqsave(&s->lock, flags);
1045 count = s->dma_dac1.count;
1046 spin_unlock_irqrestore(&s->lock, flags);
1047 if (count <= 0)
1048 break;
1049 if (signal_pending(current))
1050 break;
1051 if (nonblock) {
1052 remove_wait_queue(&s->dma_dac1.wait, &wait);
1053 current->state = TASK_RUNNING;
1054 return -EBUSY;
1055 }
1056 tmo = (count * HZ) / dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL];
1057 tmo >>= sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
1058 if (!schedule_timeout(tmo ? : 1) && tmo)
1059 DBG(printk(KERN_DEBUG "es1370: dma timed out??\n");)
1060 }
1061 remove_wait_queue(&s->dma_dac1.wait, &wait);
1062 current->state = TASK_RUNNING;
1063 if (signal_pending(current))
1064 return -ERESTARTSYS;
1065 return 0;
1066 }
1067
1068 static int drain_dac2(struct es1370_state *s, int nonblock)
1069 {
1070 DECLARE_WAITQUEUE(wait, current);
1071 unsigned long flags;
1072 int count, tmo;
1073
1074 if (s->dma_dac2.mapped || !s->dma_dac2.ready)
1075 return 0;
1076 current->state = TASK_INTERRUPTIBLE;
1077 add_wait_queue(&s->dma_dac2.wait, &wait);
1078 for (;;) {
1079 spin_lock_irqsave(&s->lock, flags);
1080 count = s->dma_dac2.count;
1081 spin_unlock_irqrestore(&s->lock, flags);
1082 if (count <= 0)
1083 break;
1084 if (signal_pending(current))
1085 break;
1086 if (nonblock) {
1087 remove_wait_queue(&s->dma_dac2.wait, &wait);
1088 current->state = TASK_RUNNING;
1089 return -EBUSY;
1090 }
1091 tmo = (count * HZ) / DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV);
1092 tmo >>= sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
1093 if (!schedule_timeout(tmo ? : 1) && tmo)
1094 DBG(printk(KERN_DEBUG "es1370: dma timed out??\n");)
1095 }
1096 remove_wait_queue(&s->dma_dac2.wait, &wait);
1097 current->state = TASK_RUNNING;
1098 if (signal_pending(current))
1099 return -ERESTARTSYS;
1100 return 0;
1101 }
1102
1103 /* --------------------------------------------------------------------- */
1104
1105 static ssize_t es1370_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1106 {
1107 struct es1370_state *s = (struct es1370_state *)file->private_data;
1108 ssize_t ret;
1109 unsigned long flags;
1110 unsigned swptr;
1111 int cnt;
1112
1113 VALIDATE_STATE(s);
1114 if (ppos != &file->f_pos)
1115 return -ESPIPE;
1116 if (s->dma_adc.mapped)
1117 return -ENXIO;
1118 if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
1119 return ret;
1120 if (!access_ok(VERIFY_WRITE, buffer, count))
1121 return -EFAULT;
1122 ret = 0;
1123 while (count > 0) {
1124 spin_lock_irqsave(&s->lock, flags);
1125 swptr = s->dma_adc.swptr;
1126 cnt = s->dma_adc.dmasize-swptr;
1127 if (s->dma_adc.count < cnt)
1128 cnt = s->dma_adc.count;
1129 spin_unlock_irqrestore(&s->lock, flags);
1130 if (cnt > count)
1131 cnt = count;
1132 if (cnt <= 0) {
1133 start_adc(s);
1134 if (file->f_flags & O_NONBLOCK)
1135 return ret ? ret : -EAGAIN;
1136 interruptible_sleep_on(&s->dma_adc.wait);
1137 if (signal_pending(current))
1138 return ret ? ret : -ERESTARTSYS;
1139 continue;
1140 }
1141 if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt))
1142 return ret ? ret : -EFAULT;
1143 swptr = (swptr + cnt) % s->dma_adc.dmasize;
1144 spin_lock_irqsave(&s->lock, flags);
1145 s->dma_adc.swptr = swptr;
1146 s->dma_adc.count -= cnt;
1147 spin_unlock_irqrestore(&s->lock, flags);
1148 count -= cnt;
1149 buffer += cnt;
1150 ret += cnt;
1151 start_adc(s);
1152 }
1153 return ret;
1154 }
1155
1156 static ssize_t es1370_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1157 {
1158 struct es1370_state *s = (struct es1370_state *)file->private_data;
1159 ssize_t ret;
1160 unsigned long flags;
1161 unsigned swptr;
1162 int cnt;
1163
1164 VALIDATE_STATE(s);
1165 if (ppos != &file->f_pos)
1166 return -ESPIPE;
1167 if (s->dma_dac2.mapped)
1168 return -ENXIO;
1169 if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
1170 return ret;
1171 if (!access_ok(VERIFY_READ, buffer, count))
1172 return -EFAULT;
1173 ret = 0;
1174 while (count > 0) {
1175 spin_lock_irqsave(&s->lock, flags);
1176 if (s->dma_dac2.count < 0) {
1177 s->dma_dac2.count = 0;
1178 s->dma_dac2.swptr = s->dma_dac2.hwptr;
1179 }
1180 swptr = s->dma_dac2.swptr;
1181 cnt = s->dma_dac2.dmasize-swptr;
1182 if (s->dma_dac2.count + cnt > s->dma_dac2.dmasize)
1183 cnt = s->dma_dac2.dmasize - s->dma_dac2.count;
1184 spin_unlock_irqrestore(&s->lock, flags);
1185 if (cnt > count)
1186 cnt = count;
1187 if (cnt <= 0) {
1188 start_dac2(s);
1189 if (file->f_flags & O_NONBLOCK)
1190 return ret ? ret : -EAGAIN;
1191 interruptible_sleep_on(&s->dma_dac2.wait);
1192 if (signal_pending(current))
1193 return ret ? ret : -ERESTARTSYS;
1194 continue;
1195 }
1196 if (copy_from_user(s->dma_dac2.rawbuf + swptr, buffer, cnt))
1197 return ret ? ret : -EFAULT;
1198 swptr = (swptr + cnt) % s->dma_dac2.dmasize;
1199 spin_lock_irqsave(&s->lock, flags);
1200 s->dma_dac2.swptr = swptr;
1201 s->dma_dac2.count += cnt;
1202 s->dma_dac2.endcleared = 0;
1203 spin_unlock_irqrestore(&s->lock, flags);
1204 count -= cnt;
1205 buffer += cnt;
1206 ret += cnt;
1207 start_dac2(s);
1208 }
1209 return ret;
1210 }
1211
1212 static unsigned int es1370_poll(struct file *file, struct poll_table_struct *wait)
1213 {
1214 struct es1370_state *s = (struct es1370_state *)file->private_data;
1215 unsigned long flags;
1216 unsigned int mask = 0;
1217
1218 VALIDATE_STATE(s);
1219 if (file->f_mode & FMODE_WRITE)
1220 poll_wait(file, &s->dma_dac2.wait, wait);
1221 if (file->f_mode & FMODE_READ)
1222 poll_wait(file, &s->dma_adc.wait, wait);
1223 spin_lock_irqsave(&s->lock, flags);
1224 es1370_update_ptr(s);
1225 if (file->f_mode & FMODE_READ) {
1226 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1227 mask |= POLLIN | POLLRDNORM;
1228 }
1229 if (file->f_mode & FMODE_WRITE) {
1230 if (s->dma_dac2.mapped) {
1231 if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize)
1232 mask |= POLLOUT | POLLWRNORM;
1233 } else {
1234 if ((signed)s->dma_dac2.dmasize >= s->dma_dac2.count + (signed)s->dma_dac2.fragsize)
1235 mask |= POLLOUT | POLLWRNORM;
1236 }
1237 }
1238 spin_unlock_irqrestore(&s->lock, flags);
1239 return mask;
1240 }
1241
1242 static int es1370_mmap(struct file *file, struct vm_area_struct *vma)
1243 {
1244 struct es1370_state *s = (struct es1370_state *)file->private_data;
1245 struct dmabuf *db;
1246 int ret;
1247 unsigned long size;
1248
1249 VALIDATE_STATE(s);
1250 if (vma->vm_flags & VM_WRITE) {
1251 if ((ret = prog_dmabuf_dac2(s)) != 0)
1252 return ret;
1253 db = &s->dma_dac2;
1254 } else if (vma->vm_flags & VM_READ) {
1255 if ((ret = prog_dmabuf_adc(s)) != 0)
1256 return ret;
1257 db = &s->dma_adc;
1258 } else
1259 return -EINVAL;
1260 if (vma->vm_offset != 0)
1261 return -EINVAL;
1262 size = vma->vm_end - vma->vm_start;
1263 if (size > (PAGE_SIZE << db->buforder))
1264 return -EINVAL;
1265 if (remap_page_range(vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot))
1266 return -EAGAIN;
1267 db->mapped = 1;
1268 return 0;
1269 }
1270
1271 static int es1370_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1272 {
1273 struct es1370_state *s = (struct es1370_state *)file->private_data;
1274 unsigned long flags;
1275 audio_buf_info abinfo;
1276 count_info cinfo;
1277 int val, mapped, ret;
1278
1279 VALIDATE_STATE(s);
1280 mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac2.mapped) ||
1281 ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
1282 switch (cmd) {
1283 case OSS_GETVERSION:
1284 return put_user(SOUND_VERSION, (int *)arg);
1285
1286 case SNDCTL_DSP_SYNC:
1287 if (file->f_mode & FMODE_WRITE)
1288 return drain_dac2(s, 0/*file->f_flags & O_NONBLOCK*/);
1289 return 0;
1290
1291 case SNDCTL_DSP_SETDUPLEX:
1292 return 0;
1293
1294 case SNDCTL_DSP_GETCAPS:
1295 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
1296
1297 case SNDCTL_DSP_RESET:
1298 if (file->f_mode & FMODE_WRITE) {
1299 stop_dac2(s);
1300 synchronize_irq();
1301 s->dma_dac2.swptr = s->dma_dac2.hwptr = s->dma_dac2.count = s->dma_dac2.total_bytes = 0;
1302 }
1303 if (file->f_mode & FMODE_READ) {
1304 stop_adc(s);
1305 synchronize_irq();
1306 s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
1307 }
1308 return 0;
1309
1310 case SNDCTL_DSP_SPEED:
1311 get_user_ret(val, (int *)arg, -EFAULT);
1312 if (val >= 0) {
1313 if (s->open_mode & (~file->f_mode) & (FMODE_READ|FMODE_WRITE))
1314 return -EINVAL;
1315 if (val < 4000)
1316 val = 4000;
1317 if (val > 50000)
1318 val = 50000;
1319 stop_adc(s);
1320 stop_dac2(s);
1321 s->dma_adc.ready = s->dma_dac2.ready = 0;
1322 spin_lock_irqsave(&s->lock, flags);
1323 s->ctrl = (s->ctrl & ~CTRL_PCLKDIV) | (DAC2_SRTODIV(val) << CTRL_SH_PCLKDIV);
1324 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
1325 spin_unlock_irqrestore(&s->lock, flags);
1326 }
1327 return put_user(DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV), (int *)arg);
1328
1329 case SNDCTL_DSP_STEREO:
1330 get_user_ret(val, (int *)arg, -EFAULT);
1331 if (file->f_mode & FMODE_READ) {
1332 stop_adc(s);
1333 s->dma_adc.ready = 0;
1334 spin_lock_irqsave(&s->lock, flags);
1335 if (val)
1336 s->sctrl |= SCTRL_R1SMB;
1337 else
1338 s->sctrl &= ~SCTRL_R1SMB;
1339 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1340 spin_unlock_irqrestore(&s->lock, flags);
1341 }
1342 if (file->f_mode & FMODE_WRITE) {
1343 stop_dac2(s);
1344 s->dma_dac2.ready = 0;
1345 spin_lock_irqsave(&s->lock, flags);
1346 if (val)
1347 s->sctrl |= SCTRL_P2SMB;
1348 else
1349 s->sctrl &= ~SCTRL_P2SMB;
1350 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1351 spin_unlock_irqrestore(&s->lock, flags);
1352 }
1353 return 0;
1354
1355 case SNDCTL_DSP_CHANNELS:
1356 get_user_ret(val, (int *)arg, -EFAULT);
1357 if (val != 0) {
1358 if (file->f_mode & FMODE_READ) {
1359 stop_adc(s);
1360 s->dma_adc.ready = 0;
1361 spin_lock_irqsave(&s->lock, flags);
1362 if (val >= 2)
1363 s->sctrl |= SCTRL_R1SMB;
1364 else
1365 s->sctrl &= ~SCTRL_R1SMB;
1366 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1367 spin_unlock_irqrestore(&s->lock, flags);
1368 }
1369 if (file->f_mode & FMODE_WRITE) {
1370 stop_dac2(s);
1371 s->dma_dac2.ready = 0;
1372 spin_lock_irqsave(&s->lock, flags);
1373 if (val >= 2)
1374 s->sctrl |= SCTRL_P2SMB;
1375 else
1376 s->sctrl &= ~SCTRL_P2SMB;
1377 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1378 spin_unlock_irqrestore(&s->lock, flags);
1379 }
1380 }
1381 return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ? 2 : 1, (int *)arg);
1382
1383 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
1384 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
1385
1386 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
1387 get_user_ret(val, (int *)arg, -EFAULT);
1388 if (val != AFMT_QUERY) {
1389 if (file->f_mode & FMODE_READ) {
1390 stop_adc(s);
1391 s->dma_adc.ready = 0;
1392 spin_lock_irqsave(&s->lock, flags);
1393 if (val == AFMT_S16_LE)
1394 s->sctrl |= SCTRL_R1SEB;
1395 else
1396 s->sctrl &= ~SCTRL_R1SEB;
1397 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1398 spin_unlock_irqrestore(&s->lock, flags);
1399 }
1400 if (file->f_mode & FMODE_WRITE) {
1401 stop_dac2(s);
1402 s->dma_dac2.ready = 0;
1403 spin_lock_irqsave(&s->lock, flags);
1404 if (val == AFMT_S16_LE)
1405 s->sctrl |= SCTRL_P2SEB;
1406 else
1407 s->sctrl &= ~SCTRL_P2SEB;
1408 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1409 spin_unlock_irqrestore(&s->lock, flags);
1410 }
1411 }
1412 return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ?
1413 AFMT_S16_LE : AFMT_U8, (int *)arg);
1414
1415 case SNDCTL_DSP_POST:
1416 return 0;
1417
1418 case SNDCTL_DSP_GETTRIGGER:
1419 val = 0;
1420 if (file->f_mode & FMODE_READ && s->ctrl & CTRL_ADC_EN)
1421 val |= PCM_ENABLE_INPUT;
1422 if (file->f_mode & FMODE_WRITE && s->ctrl & CTRL_DAC2_EN)
1423 val |= PCM_ENABLE_OUTPUT;
1424 return put_user(val, (int *)arg);
1425
1426 case SNDCTL_DSP_SETTRIGGER:
1427 get_user_ret(val, (int *)arg, -EFAULT);
1428 if (file->f_mode & FMODE_READ) {
1429 if (val & PCM_ENABLE_INPUT) {
1430 if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
1431 return ret;
1432 start_adc(s);
1433 } else
1434 stop_adc(s);
1435 }
1436 if (file->f_mode & FMODE_WRITE) {
1437 if (val & PCM_ENABLE_OUTPUT) {
1438 if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
1439 return ret;
1440 start_dac2(s);
1441 } else
1442 stop_dac2(s);
1443 }
1444 return 0;
1445
1446 case SNDCTL_DSP_GETOSPACE:
1447 if (!(file->f_mode & FMODE_WRITE))
1448 return -EINVAL;
1449 if (!(s->ctrl & CTRL_DAC2_EN) && (val = prog_dmabuf_dac2(s)) != 0)
1450 return val;
1451 spin_lock_irqsave(&s->lock, flags);
1452 es1370_update_ptr(s);
1453 abinfo.fragsize = s->dma_dac2.fragsize;
1454 abinfo.bytes = s->dma_dac2.dmasize - s->dma_dac2.count;
1455 abinfo.fragstotal = s->dma_dac2.numfrag;
1456 abinfo.fragments = abinfo.bytes >> s->dma_dac2.fragshift;
1457 spin_unlock_irqrestore(&s->lock, flags);
1458 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1459
1460 case SNDCTL_DSP_GETISPACE:
1461 if (!(file->f_mode & FMODE_READ))
1462 return -EINVAL;
1463 if (!(s->ctrl & CTRL_ADC_EN) && (val = prog_dmabuf_adc(s)) != 0)
1464 return val;
1465 spin_lock_irqsave(&s->lock, flags);
1466 es1370_update_ptr(s);
1467 abinfo.fragsize = s->dma_adc.fragsize;
1468 abinfo.bytes = s->dma_adc.count;
1469 abinfo.fragstotal = s->dma_adc.numfrag;
1470 abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;
1471 spin_unlock_irqrestore(&s->lock, flags);
1472 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1473
1474 case SNDCTL_DSP_NONBLOCK:
1475 file->f_flags |= O_NONBLOCK;
1476 return 0;
1477
1478 case SNDCTL_DSP_GETODELAY:
1479 if (!(file->f_mode & FMODE_WRITE))
1480 return -EINVAL;
1481 spin_lock_irqsave(&s->lock, flags);
1482 es1370_update_ptr(s);
1483 val = s->dma_dac2.count;
1484 spin_unlock_irqrestore(&s->lock, flags);
1485 return put_user(val, (int *)arg);
1486
1487 case SNDCTL_DSP_GETIPTR:
1488 if (!(file->f_mode & FMODE_READ))
1489 return -EINVAL;
1490 spin_lock_irqsave(&s->lock, flags);
1491 es1370_update_ptr(s);
1492 cinfo.bytes = s->dma_adc.total_bytes;
1493 cinfo.blocks = s->dma_adc.count >> s->dma_adc.fragshift;
1494 cinfo.ptr = s->dma_adc.hwptr;
1495 if (s->dma_adc.mapped)
1496 s->dma_adc.count &= s->dma_adc.fragsize-1;
1497 spin_unlock_irqrestore(&s->lock, flags);
1498 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
1499
1500 case SNDCTL_DSP_GETOPTR:
1501 if (!(file->f_mode & FMODE_WRITE))
1502 return -EINVAL;
1503 spin_lock_irqsave(&s->lock, flags);
1504 es1370_update_ptr(s);
1505 cinfo.bytes = s->dma_dac2.total_bytes;
1506 cinfo.blocks = s->dma_dac2.count >> s->dma_dac2.fragshift;
1507 cinfo.ptr = s->dma_dac2.hwptr;
1508 if (s->dma_dac2.mapped)
1509 s->dma_dac2.count &= s->dma_dac2.fragsize-1;
1510 spin_unlock_irqrestore(&s->lock, flags);
1511 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
1512
1513 case SNDCTL_DSP_GETBLKSIZE:
1514 if (file->f_mode & FMODE_WRITE) {
1515 if ((val = prog_dmabuf_dac2(s)))
1516 return val;
1517 return put_user(s->dma_dac2.fragsize, (int *)arg);
1518 }
1519 if ((val = prog_dmabuf_adc(s)))
1520 return val;
1521 return put_user(s->dma_adc.fragsize, (int *)arg);
1522
1523 case SNDCTL_DSP_SETFRAGMENT:
1524 get_user_ret(val, (int *)arg, -EFAULT);
1525 if (file->f_mode & FMODE_READ) {
1526 s->dma_adc.ossfragshift = val & 0xffff;
1527 s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
1528 if (s->dma_adc.ossfragshift < 4)
1529 s->dma_adc.ossfragshift = 4;
1530 if (s->dma_adc.ossfragshift > 15)
1531 s->dma_adc.ossfragshift = 15;
1532 if (s->dma_adc.ossmaxfrags < 4)
1533 s->dma_adc.ossmaxfrags = 4;
1534 }
1535 if (file->f_mode & FMODE_WRITE) {
1536 s->dma_dac2.ossfragshift = val & 0xffff;
1537 s->dma_dac2.ossmaxfrags = (val >> 16) & 0xffff;
1538 if (s->dma_dac2.ossfragshift < 4)
1539 s->dma_dac2.ossfragshift = 4;
1540 if (s->dma_dac2.ossfragshift > 15)
1541 s->dma_dac2.ossfragshift = 15;
1542 if (s->dma_dac2.ossmaxfrags < 4)
1543 s->dma_dac2.ossmaxfrags = 4;
1544 }
1545 return 0;
1546
1547 case SNDCTL_DSP_SUBDIVIDE:
1548 if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
1549 (file->f_mode & FMODE_WRITE && s->dma_dac2.subdivision))
1550 return -EINVAL;
1551 get_user_ret(val, (int *)arg, -EFAULT);
1552 if (val != 1 && val != 2 && val != 4)
1553 return -EINVAL;
1554 if (file->f_mode & FMODE_READ)
1555 s->dma_adc.subdivision = val;
1556 if (file->f_mode & FMODE_WRITE)
1557 s->dma_dac2.subdivision = val;
1558 return 0;
1559
1560 case SOUND_PCM_READ_RATE:
1561 return put_user(DAC2_DIVTOSR((s->ctrl & CTRL_PCLKDIV) >> CTRL_SH_PCLKDIV), (int *)arg);
1562
1563 case SOUND_PCM_READ_CHANNELS:
1564 return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ?
1565 2 : 1, (int *)arg);
1566
1567 case SOUND_PCM_READ_BITS:
1568 return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ?
1569 16 : 8, (int *)arg);
1570
1571 case SOUND_PCM_WRITE_FILTER:
1572 case SNDCTL_DSP_SETSYNCRO:
1573 case SOUND_PCM_READ_FILTER:
1574 return -EINVAL;
1575
1576 }
1577 return mixer_ioctl(s, cmd, arg);
1578 }
1579
1580 static int es1370_open(struct inode *inode, struct file *file)
1581 {
1582 int minor = MINOR(inode->i_rdev);
1583 struct es1370_state *s = devs;
1584 unsigned long flags;
1585
1586 while (s && ((s->dev_audio ^ minor) & ~0xf))
1587 s = s->next;
1588 if (!s)
1589 return -ENODEV;
1590 VALIDATE_STATE(s);
1591 file->private_data = s;
1592 /* wait for device to become free */
1593 down(&s->open_sem);
1594 while (s->open_mode & file->f_mode) {
1595 if (file->f_flags & O_NONBLOCK) {
1596 up(&s->open_sem);
1597 return -EBUSY;
1598 }
1599 up(&s->open_sem);
1600 interruptible_sleep_on(&s->open_wait);
1601 if (signal_pending(current))
1602 return -ERESTARTSYS;
1603 down(&s->open_sem);
1604 }
1605 spin_lock_irqsave(&s->lock, flags);
1606 if (!(s->open_mode & (FMODE_READ|FMODE_WRITE)))
1607 s->ctrl = (s->ctrl & ~CTRL_PCLKDIV) | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV);
1608 if (file->f_mode & FMODE_READ) {
1609 s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
1610 s->sctrl &= ~SCTRL_R1FMT;
1611 if ((minor & 0xf) == SND_DEV_DSP16)
1612 s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_R1FMT;
1613 else
1614 s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_R1FMT;
1615 }
1616 if (file->f_mode & FMODE_WRITE) {
1617 s->dma_dac2.ossfragshift = s->dma_dac2.ossmaxfrags = s->dma_dac2.subdivision = 0;
1618 s->sctrl &= ~SCTRL_P2FMT;
1619 if ((minor & 0xf) == SND_DEV_DSP16)
1620 s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_P2FMT;
1621 else
1622 s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_P2FMT;
1623 }
1624 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1625 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
1626 spin_unlock_irqrestore(&s->lock, flags);
1627 s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
1628 up(&s->open_sem);
1629 MOD_INC_USE_COUNT;
1630 return 0;
1631 }
1632
1633 static int es1370_release(struct inode *inode, struct file *file)
1634 {
1635 struct es1370_state *s = (struct es1370_state *)file->private_data;
1636
1637 VALIDATE_STATE(s);
1638 if (file->f_mode & FMODE_WRITE)
1639 drain_dac2(s, file->f_flags & O_NONBLOCK);
1640 down(&s->open_sem);
1641 if (file->f_mode & FMODE_WRITE) {
1642 stop_dac2(s);
1643 synchronize_irq();
1644 dealloc_dmabuf(&s->dma_dac2);
1645 }
1646 if (file->f_mode & FMODE_READ) {
1647 stop_adc(s);
1648 dealloc_dmabuf(&s->dma_adc);
1649 }
1650 s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
1651 up(&s->open_sem);
1652 wake_up(&s->open_wait);
1653 MOD_DEC_USE_COUNT;
1654 return 0;
1655 }
1656
1657 static /*const*/ struct file_operations es1370_audio_fops = {
1658 &es1370_llseek,
1659 &es1370_read,
1660 &es1370_write,
1661 NULL, /* readdir */
1662 &es1370_poll,
1663 &es1370_ioctl,
1664 &es1370_mmap,
1665 &es1370_open,
1666 NULL, /* flush */
1667 &es1370_release,
1668 NULL, /* fsync */
1669 NULL, /* fasync */
1670 NULL, /* check_media_change */
1671 NULL, /* revalidate */
1672 NULL, /* lock */
1673 };
1674
1675 /* --------------------------------------------------------------------- */
1676
1677 static ssize_t es1370_write_dac(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1678 {
1679 struct es1370_state *s = (struct es1370_state *)file->private_data;
1680 ssize_t ret = 0;
1681 unsigned long flags;
1682 unsigned swptr;
1683 int cnt;
1684
1685 VALIDATE_STATE(s);
1686 if (ppos != &file->f_pos)
1687 return -ESPIPE;
1688 if (s->dma_dac1.mapped)
1689 return -ENXIO;
1690 if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
1691 return ret;
1692 if (!access_ok(VERIFY_READ, buffer, count))
1693 return -EFAULT;
1694 while (count > 0) {
1695 spin_lock_irqsave(&s->lock, flags);
1696 if (s->dma_dac1.count < 0) {
1697 s->dma_dac1.count = 0;
1698 s->dma_dac1.swptr = s->dma_dac1.hwptr;
1699 }
1700 swptr = s->dma_dac1.swptr;
1701 cnt = s->dma_dac1.dmasize-swptr;
1702 if (s->dma_dac1.count + cnt > s->dma_dac1.dmasize)
1703 cnt = s->dma_dac1.dmasize - s->dma_dac1.count;
1704 spin_unlock_irqrestore(&s->lock, flags);
1705 if (cnt > count)
1706 cnt = count;
1707 if (cnt <= 0) {
1708 start_dac1(s);
1709 if (file->f_flags & O_NONBLOCK)
1710 return ret ? ret : -EAGAIN;
1711 interruptible_sleep_on(&s->dma_dac1.wait);
1712 if (signal_pending(current))
1713 return ret ? ret : -ERESTARTSYS;
1714 continue;
1715 }
1716 if (copy_from_user(s->dma_dac1.rawbuf + swptr, buffer, cnt))
1717 return ret ? ret : -EFAULT;
1718 swptr = (swptr + cnt) % s->dma_dac1.dmasize;
1719 spin_lock_irqsave(&s->lock, flags);
1720 s->dma_dac1.swptr = swptr;
1721 s->dma_dac1.count += cnt;
1722 s->dma_dac1.endcleared = 0;
1723 spin_unlock_irqrestore(&s->lock, flags);
1724 count -= cnt;
1725 buffer += cnt;
1726 ret += cnt;
1727 start_dac1(s);
1728 }
1729 return ret;
1730 }
1731
1732 static unsigned int es1370_poll_dac(struct file *file, struct poll_table_struct *wait)
1733 {
1734 struct es1370_state *s = (struct es1370_state *)file->private_data;
1735 unsigned long flags;
1736 unsigned int mask = 0;
1737
1738 VALIDATE_STATE(s);
1739 poll_wait(file, &s->dma_dac1.wait, wait);
1740 spin_lock_irqsave(&s->lock, flags);
1741 es1370_update_ptr(s);
1742 if (s->dma_dac1.mapped) {
1743 if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
1744 mask |= POLLOUT | POLLWRNORM;
1745 } else {
1746 if ((signed)s->dma_dac1.dmasize >= s->dma_dac1.count + (signed)s->dma_dac1.fragsize)
1747 mask |= POLLOUT | POLLWRNORM;
1748 }
1749 spin_unlock_irqrestore(&s->lock, flags);
1750 return mask;
1751 }
1752
1753 static int es1370_mmap_dac(struct file *file, struct vm_area_struct *vma)
1754 {
1755 struct es1370_state *s = (struct es1370_state *)file->private_data;
1756 int ret;
1757 unsigned long size;
1758
1759 VALIDATE_STATE(s);
1760 if (!(vma->vm_flags & VM_WRITE))
1761 return -EINVAL;
1762 if ((ret = prog_dmabuf_dac1(s)) != 0)
1763 return ret;
1764 if (vma->vm_offset != 0)
1765 return -EINVAL;
1766 size = vma->vm_end - vma->vm_start;
1767 if (size > (PAGE_SIZE << s->dma_dac1.buforder))
1768 return -EINVAL;
1769 if (remap_page_range(vma->vm_start, virt_to_phys(s->dma_dac1.rawbuf), size, vma->vm_page_prot))
1770 return -EAGAIN;
1771 s->dma_dac1.mapped = 1;
1772 return 0;
1773 }
1774
1775 static int es1370_ioctl_dac(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1776 {
1777 struct es1370_state *s = (struct es1370_state *)file->private_data;
1778 unsigned long flags;
1779 audio_buf_info abinfo;
1780 count_info cinfo;
1781 unsigned ctrl;
1782 int val, ret;
1783
1784 VALIDATE_STATE(s);
1785 switch (cmd) {
1786 case OSS_GETVERSION:
1787 return put_user(SOUND_VERSION, (int *)arg);
1788
1789 case SNDCTL_DSP_SYNC:
1790 return drain_dac1(s, 0/*file->f_flags & O_NONBLOCK*/);
1791
1792 case SNDCTL_DSP_SETDUPLEX:
1793 return -EINVAL;
1794
1795 case SNDCTL_DSP_GETCAPS:
1796 return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
1797
1798 case SNDCTL_DSP_RESET:
1799 stop_dac1(s);
1800 synchronize_irq();
1801 s->dma_dac1.swptr = s->dma_dac1.hwptr = s->dma_dac1.count = s->dma_dac1.total_bytes = 0;
1802 return 0;
1803
1804 case SNDCTL_DSP_SPEED:
1805 get_user_ret(val, (int *)arg, -EFAULT);
1806 if (val >= 0) {
1807 stop_dac1(s);
1808 s->dma_dac1.ready = 0;
1809 for (ctrl = 0; ctrl <= 2; ctrl++)
1810 if (val < (dac1_samplerate[ctrl] + dac1_samplerate[ctrl+1]) / 2)
1811 break;
1812 spin_lock_irqsave(&s->lock, flags);
1813 s->ctrl = (s->ctrl & ~CTRL_WTSRSEL) | (ctrl << CTRL_SH_WTSRSEL);
1814 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
1815 spin_unlock_irqrestore(&s->lock, flags);
1816 }
1817 return put_user(dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL], (int *)arg);
1818
1819 case SNDCTL_DSP_STEREO:
1820 get_user_ret(val, (int *)arg, -EFAULT);
1821 stop_dac1(s);
1822 s->dma_dac1.ready = 0;
1823 spin_lock_irqsave(&s->lock, flags);
1824 if (val)
1825 s->sctrl |= SCTRL_P1SMB;
1826 else
1827 s->sctrl &= ~SCTRL_P1SMB;
1828 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1829 spin_unlock_irqrestore(&s->lock, flags);
1830 return 0;
1831
1832 case SNDCTL_DSP_CHANNELS:
1833 get_user_ret(val, (int *)arg, -EFAULT);
1834 if (val != 0) {
1835 if (s->dma_dac1.mapped)
1836 return -EINVAL;
1837 stop_dac1(s);
1838 s->dma_dac1.ready = 0;
1839 spin_lock_irqsave(&s->lock, flags);
1840 if (val >= 2)
1841 s->sctrl |= SCTRL_P1SMB;
1842 else
1843 s->sctrl &= ~SCTRL_P1SMB;
1844 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1845 spin_unlock_irqrestore(&s->lock, flags);
1846 }
1847 return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, (int *)arg);
1848
1849 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
1850 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
1851
1852 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
1853 get_user_ret(val, (int *)arg, -EFAULT);
1854 if (val != AFMT_QUERY) {
1855 stop_dac1(s);
1856 s->dma_dac1.ready = 0;
1857 spin_lock_irqsave(&s->lock, flags);
1858 if (val == AFMT_S16_LE)
1859 s->sctrl |= SCTRL_P1SEB;
1860 else
1861 s->sctrl &= ~SCTRL_P1SEB;
1862 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
1863 spin_unlock_irqrestore(&s->lock, flags);
1864 }
1865 return put_user((s->sctrl & SCTRL_P1SEB) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
1866
1867 case SNDCTL_DSP_POST:
1868 return 0;
1869
1870 case SNDCTL_DSP_GETTRIGGER:
1871 return put_user((s->ctrl & CTRL_DAC1_EN) ? PCM_ENABLE_OUTPUT : 0, (int *)arg);
1872
1873 case SNDCTL_DSP_SETTRIGGER:
1874 get_user_ret(val, (int *)arg, -EFAULT);
1875 if (val & PCM_ENABLE_OUTPUT) {
1876 if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
1877 return ret;
1878 start_dac1(s);
1879 } else
1880 stop_dac1(s);
1881 return 0;
1882
1883 case SNDCTL_DSP_GETOSPACE:
1884 if (!(s->ctrl & CTRL_DAC2_EN) && (val = prog_dmabuf_dac1(s)) != 0)
1885 return val;
1886 spin_lock_irqsave(&s->lock, flags);
1887 es1370_update_ptr(s);
1888 abinfo.fragsize = s->dma_dac1.fragsize;
1889 abinfo.bytes = s->dma_dac1.dmasize - s->dma_dac1.count;
1890 abinfo.fragstotal = s->dma_dac1.numfrag;
1891 abinfo.fragments = abinfo.bytes >> s->dma_dac1.fragshift;
1892 spin_unlock_irqrestore(&s->lock, flags);
1893 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1894
1895 case SNDCTL_DSP_NONBLOCK:
1896 file->f_flags |= O_NONBLOCK;
1897 return 0;
1898
1899 case SNDCTL_DSP_GETODELAY:
1900 spin_lock_irqsave(&s->lock, flags);
1901 es1370_update_ptr(s);
1902 val = s->dma_dac1.count;
1903 spin_unlock_irqrestore(&s->lock, flags);
1904 return put_user(val, (int *)arg);
1905
1906 case SNDCTL_DSP_GETOPTR:
1907 if (!(file->f_mode & FMODE_WRITE))
1908 return -EINVAL;
1909 spin_lock_irqsave(&s->lock, flags);
1910 es1370_update_ptr(s);
1911 cinfo.bytes = s->dma_dac1.total_bytes;
1912 cinfo.blocks = s->dma_dac1.count >> s->dma_dac1.fragshift;
1913 cinfo.ptr = s->dma_dac1.hwptr;
1914 if (s->dma_dac1.mapped)
1915 s->dma_dac1.count &= s->dma_dac1.fragsize-1;
1916 spin_unlock_irqrestore(&s->lock, flags);
1917 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
1918
1919 case SNDCTL_DSP_GETBLKSIZE:
1920 if ((val = prog_dmabuf_dac1(s)))
1921 return val;
1922 return put_user(s->dma_dac1.fragsize, (int *)arg);
1923
1924 case SNDCTL_DSP_SETFRAGMENT:
1925 get_user_ret(val, (int *)arg, -EFAULT);
1926 s->dma_dac1.ossfragshift = val & 0xffff;
1927 s->dma_dac1.ossmaxfrags = (val >> 16) & 0xffff;
1928 if (s->dma_dac1.ossfragshift < 4)
1929 s->dma_dac1.ossfragshift = 4;
1930 if (s->dma_dac1.ossfragshift > 15)
1931 s->dma_dac1.ossfragshift = 15;
1932 if (s->dma_dac1.ossmaxfrags < 4)
1933 s->dma_dac1.ossmaxfrags = 4;
1934 return 0;
1935
1936 case SNDCTL_DSP_SUBDIVIDE:
1937 if (s->dma_dac1.subdivision)
1938 return -EINVAL;
1939 get_user_ret(val, (int *)arg, -EFAULT);
1940 if (val != 1 && val != 2 && val != 4)
1941 return -EINVAL;
1942 s->dma_dac1.subdivision = val;
1943 return 0;
1944
1945 case SOUND_PCM_READ_RATE:
1946 return put_user(dac1_samplerate[(s->ctrl & CTRL_WTSRSEL) >> CTRL_SH_WTSRSEL], (int *)arg);
1947
1948 case SOUND_PCM_READ_CHANNELS:
1949 return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, (int *)arg);
1950
1951 case SOUND_PCM_READ_BITS:
1952 return put_user((s->sctrl & SCTRL_P1SEB) ? 16 : 8, (int *)arg);
1953
1954 case SOUND_PCM_WRITE_FILTER:
1955 case SNDCTL_DSP_SETSYNCRO:
1956 case SOUND_PCM_READ_FILTER:
1957 return -EINVAL;
1958
1959 }
1960 return mixer_ioctl(s, cmd, arg);
1961 }
1962
1963 static int es1370_open_dac(struct inode *inode, struct file *file)
1964 {
1965 int minor = MINOR(inode->i_rdev);
1966 struct es1370_state *s = devs;
1967 unsigned long flags;
1968
1969 while (s && ((s->dev_dac ^ minor) & ~0xf))
1970 s = s->next;
1971 if (!s)
1972 return -ENODEV;
1973 VALIDATE_STATE(s);
1974 /* we allow opening with O_RDWR, most programs do it although they will only write */
1975 #if 0
1976 if (file->f_mode & FMODE_READ)
1977 return -EPERM;
1978 #endif
1979 if (!(file->f_mode & FMODE_WRITE))
1980 return -EINVAL;
1981 file->private_data = s;
1982 /* wait for device to become free */
1983 down(&s->open_sem);
1984 while (s->open_mode & FMODE_DAC) {
1985 if (file->f_flags & O_NONBLOCK) {
1986 up(&s->open_sem);
1987 return -EBUSY;
1988 }
1989 up(&s->open_sem);
1990 interruptible_sleep_on(&s->open_wait);
1991 if (signal_pending(current))
1992 return -ERESTARTSYS;
1993 down(&s->open_sem);
1994 }
1995 s->dma_dac1.ossfragshift = s->dma_dac1.ossmaxfrags = s->dma_dac1.subdivision = 0;
1996 spin_lock_irqsave(&s->lock, flags);
1997 s->ctrl = (s->ctrl & ~CTRL_WTSRSEL) | (1 << CTRL_SH_WTSRSEL);
1998 s->sctrl &= ~SCTRL_P1FMT;
1999 if ((minor & 0xf) == SND_DEV_DSP16)
2000 s->sctrl |= ES1370_FMT_S16_MONO << SCTRL_SH_P1FMT;
2001 else
2002 s->sctrl |= ES1370_FMT_U8_MONO << SCTRL_SH_P1FMT;
2003 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
2004 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
2005 spin_unlock_irqrestore(&s->lock, flags);
2006 s->open_mode |= FMODE_DAC;
2007 up(&s->open_sem);
2008 MOD_INC_USE_COUNT;
2009 return 0;
2010 }
2011
2012 static int es1370_release_dac(struct inode *inode, struct file *file)
2013 {
2014 struct es1370_state *s = (struct es1370_state *)file->private_data;
2015
2016 VALIDATE_STATE(s);
2017 drain_dac1(s, file->f_flags & O_NONBLOCK);
2018 down(&s->open_sem);
2019 stop_dac1(s);
2020 dealloc_dmabuf(&s->dma_dac1);
2021 s->open_mode &= ~FMODE_DAC;
2022 up(&s->open_sem);
2023 wake_up(&s->open_wait);
2024 MOD_DEC_USE_COUNT;
2025 return 0;
2026 }
2027
2028 static /*const*/ struct file_operations es1370_dac_fops = {
2029 &es1370_llseek,
2030 NULL, /* read */
2031 &es1370_write_dac,
2032 NULL, /* readdir */
2033 &es1370_poll_dac,
2034 &es1370_ioctl_dac,
2035 &es1370_mmap_dac,
2036 &es1370_open_dac,
2037 NULL, /* flush */
2038 &es1370_release_dac,
2039 NULL, /* fsync */
2040 NULL, /* fasync */
2041 NULL, /* check_media_change */
2042 NULL, /* revalidate */
2043 NULL, /* lock */
2044 };
2045
2046 /* --------------------------------------------------------------------- */
2047
2048 static ssize_t es1370_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2049 {
2050 struct es1370_state *s = (struct es1370_state *)file->private_data;
2051 ssize_t ret;
2052 unsigned long flags;
2053 unsigned ptr;
2054 int cnt;
2055
2056 VALIDATE_STATE(s);
2057 if (ppos != &file->f_pos)
2058 return -ESPIPE;
2059 if (!access_ok(VERIFY_WRITE, buffer, count))
2060 return -EFAULT;
2061 ret = 0;
2062 while (count > 0) {
2063 spin_lock_irqsave(&s->lock, flags);
2064 ptr = s->midi.ird;
2065 cnt = MIDIINBUF - ptr;
2066 if (s->midi.icnt < cnt)
2067 cnt = s->midi.icnt;
2068 spin_unlock_irqrestore(&s->lock, flags);
2069 if (cnt > count)
2070 cnt = count;
2071 if (cnt <= 0) {
2072 if (file->f_flags & O_NONBLOCK)
2073 return ret ? ret : -EAGAIN;
2074 interruptible_sleep_on(&s->midi.iwait);
2075 if (signal_pending(current))
2076 return ret ? ret : -ERESTARTSYS;
2077 continue;
2078 }
2079 if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt))
2080 return ret ? ret : -EFAULT;
2081 ptr = (ptr + cnt) % MIDIINBUF;
2082 spin_lock_irqsave(&s->lock, flags);
2083 s->midi.ird = ptr;
2084 s->midi.icnt -= cnt;
2085 spin_unlock_irqrestore(&s->lock, flags);
2086 count -= cnt;
2087 buffer += cnt;
2088 ret += cnt;
2089 }
2090 return ret;
2091 }
2092
2093 static ssize_t es1370_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2094 {
2095 struct es1370_state *s = (struct es1370_state *)file->private_data;
2096 ssize_t ret;
2097 unsigned long flags;
2098 unsigned ptr;
2099 int cnt;
2100
2101 VALIDATE_STATE(s);
2102 if (ppos != &file->f_pos)
2103 return -ESPIPE;
2104 if (!access_ok(VERIFY_READ, buffer, count))
2105 return -EFAULT;
2106 ret = 0;
2107 while (count > 0) {
2108 spin_lock_irqsave(&s->lock, flags);
2109 ptr = s->midi.owr;
2110 cnt = MIDIOUTBUF - ptr;
2111 if (s->midi.ocnt + cnt > MIDIOUTBUF)
2112 cnt = MIDIOUTBUF - s->midi.ocnt;
2113 if (cnt <= 0)
2114 es1370_handle_midi(s);
2115 spin_unlock_irqrestore(&s->lock, flags);
2116 if (cnt > count)
2117 cnt = count;
2118 if (cnt <= 0) {
2119 if (file->f_flags & O_NONBLOCK)
2120 return ret ? ret : -EAGAIN;
2121 interruptible_sleep_on(&s->midi.owait);
2122 if (signal_pending(current))
2123 return ret ? ret : -ERESTARTSYS;
2124 continue;
2125 }
2126 if (copy_from_user(s->midi.obuf + ptr, buffer, cnt))
2127 return ret ? ret : -EFAULT;
2128 ptr = (ptr + cnt) % MIDIOUTBUF;
2129 spin_lock_irqsave(&s->lock, flags);
2130 s->midi.owr = ptr;
2131 s->midi.ocnt += cnt;
2132 spin_unlock_irqrestore(&s->lock, flags);
2133 count -= cnt;
2134 buffer += cnt;
2135 ret += cnt;
2136 spin_lock_irqsave(&s->lock, flags);
2137 es1370_handle_midi(s);
2138 spin_unlock_irqrestore(&s->lock, flags);
2139 }
2140 return ret;
2141 }
2142
2143 static unsigned int es1370_midi_poll(struct file *file, struct poll_table_struct *wait)
2144 {
2145 struct es1370_state *s = (struct es1370_state *)file->private_data;
2146 unsigned long flags;
2147 unsigned int mask = 0;
2148
2149 VALIDATE_STATE(s);
2150 if (file->f_mode & FMODE_WRITE)
2151 poll_wait(file, &s->midi.owait, wait);
2152 if (file->f_mode & FMODE_READ)
2153 poll_wait(file, &s->midi.iwait, wait);
2154 spin_lock_irqsave(&s->lock, flags);
2155 if (file->f_mode & FMODE_READ) {
2156 if (s->midi.icnt > 0)
2157 mask |= POLLIN | POLLRDNORM;
2158 }
2159 if (file->f_mode & FMODE_WRITE) {
2160 if (s->midi.ocnt < MIDIOUTBUF)
2161 mask |= POLLOUT | POLLWRNORM;
2162 }
2163 spin_unlock_irqrestore(&s->lock, flags);
2164 return mask;
2165 }
2166
2167 static int es1370_midi_open(struct inode *inode, struct file *file)
2168 {
2169 int minor = MINOR(inode->i_rdev);
2170 struct es1370_state *s = devs;
2171 unsigned long flags;
2172
2173 while (s && s->dev_midi != minor)
2174 s = s->next;
2175 if (!s)
2176 return -ENODEV;
2177 VALIDATE_STATE(s);
2178 file->private_data = s;
2179 /* wait for device to become free */
2180 down(&s->open_sem);
2181 while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
2182 if (file->f_flags & O_NONBLOCK) {
2183 up(&s->open_sem);
2184 return -EBUSY;
2185 }
2186 up(&s->open_sem);
2187 interruptible_sleep_on(&s->open_wait);
2188 if (signal_pending(current))
2189 return -ERESTARTSYS;
2190 down(&s->open_sem);
2191 }
2192 spin_lock_irqsave(&s->lock, flags);
2193 if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2194 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2195 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2196 outb(UCTRL_CNTRL_SWR, s->io+ES1370_REG_UART_CONTROL);
2197 outb(0, s->io+ES1370_REG_UART_CONTROL);
2198 outb(0, s->io+ES1370_REG_UART_TEST);
2199 }
2200 if (file->f_mode & FMODE_READ) {
2201 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2202 }
2203 if (file->f_mode & FMODE_WRITE) {
2204 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2205 }
2206 s->ctrl |= CTRL_UART_EN;
2207 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
2208 es1370_handle_midi(s);
2209 spin_unlock_irqrestore(&s->lock, flags);
2210 s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
2211 up(&s->open_sem);
2212 MOD_INC_USE_COUNT;
2213 return 0;
2214 }
2215
2216 static int es1370_midi_release(struct inode *inode, struct file *file)
2217 {
2218 struct es1370_state *s = (struct es1370_state *)file->private_data;
2219 DECLARE_WAITQUEUE(wait, current);
2220 unsigned long flags;
2221 unsigned count, tmo;
2222
2223 VALIDATE_STATE(s);
2224
2225 if (file->f_mode & FMODE_WRITE) {
2226 current->state = TASK_INTERRUPTIBLE;
2227 add_wait_queue(&s->midi.owait, &wait);
2228 for (;;) {
2229 spin_lock_irqsave(&s->lock, flags);
2230 count = s->midi.ocnt;
2231 spin_unlock_irqrestore(&s->lock, flags);
2232 if (count <= 0)
2233 break;
2234 if (signal_pending(current))
2235 break;
2236 if (file->f_flags & O_NONBLOCK) {
2237 remove_wait_queue(&s->midi.owait, &wait);
2238 current->state = TASK_RUNNING;
2239 return -EBUSY;
2240 }
2241 tmo = (count * HZ) / 3100;
2242 if (!schedule_timeout(tmo ? : 1) && tmo)
2243 DBG(printk(KERN_DEBUG "es1370: midi timed out??\n");)
2244 }
2245 remove_wait_queue(&s->midi.owait, &wait);
2246 current->state = TASK_RUNNING;
2247 }
2248 down(&s->open_sem);
2249 s->open_mode &= (~(file->f_mode << FMODE_MIDI_SHIFT)) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE);
2250 spin_lock_irqsave(&s->lock, flags);
2251 if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2252 s->ctrl &= ~CTRL_UART_EN;
2253 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
2254 }
2255 spin_unlock_irqrestore(&s->lock, flags);
2256 up(&s->open_sem);
2257 wake_up(&s->open_wait);
2258 MOD_DEC_USE_COUNT;
2259 return 0;
2260 }
2261
2262 static /*const*/ struct file_operations es1370_midi_fops = {
2263 &es1370_llseek,
2264 &es1370_midi_read,
2265 &es1370_midi_write,
2266 NULL, /* readdir */
2267 &es1370_midi_poll,
2268 NULL, /* ioctl */
2269 NULL, /* mmap */
2270 &es1370_midi_open,
2271 NULL, /* flush */
2272 &es1370_midi_release,
2273 NULL, /* fsync */
2274 NULL, /* fasync */
2275 NULL, /* check_media_change */
2276 NULL, /* revalidate */
2277 NULL, /* lock */
2278 };
2279
2280 /* --------------------------------------------------------------------- */
2281
2282 /* maximum number of devices */
2283 #define NR_DEVICE 5
2284 #ifdef CONFIG_SOUND_ES1370_JOYPORT_BOOT
2285 static int joystick[NR_DEVICE] = { 1, 0, };
2286 #else
2287 static int joystick[NR_DEVICE] = { 0, };
2288 #endif
2289 static int lineout[NR_DEVICE] = { 0, };
2290 static int micbias[NR_DEVICE] = { 0, };
2291
2292 /* --------------------------------------------------------------------- */
2293
2294 static struct initvol {
2295 int mixch;
2296 int vol;
2297 } initvol[] __initdata = {
2298 { SOUND_MIXER_WRITE_VOLUME, 0x4040 },
2299 { SOUND_MIXER_WRITE_PCM, 0x4040 },
2300 { SOUND_MIXER_WRITE_SYNTH, 0x4040 },
2301 { SOUND_MIXER_WRITE_CD, 0x4040 },
2302 { SOUND_MIXER_WRITE_LINE, 0x4040 },
2303 { SOUND_MIXER_WRITE_LINE1, 0x4040 },
2304 { SOUND_MIXER_WRITE_LINE2, 0x4040 },
2305 { SOUND_MIXER_WRITE_LINE3, 0x4040 },
2306 { SOUND_MIXER_WRITE_MIC, 0x4040 },
2307 { SOUND_MIXER_WRITE_OGAIN, 0x4040 }
2308 };
2309
2310 #ifdef MODULE
2311 __initfunc(int init_module(void))
2312 #else
2313 __initfunc(int init_es1370(void))
2314 #endif
2315 {
2316 struct es1370_state *s;
2317 struct pci_dev *pcidev = NULL;
2318 mm_segment_t fs;
2319 int i, val, index = 0;
2320
2321 if (!pci_present()) /* No PCI bus in this machine! */
2322 return -ENODEV;
2323 printk(KERN_INFO "es1370: version v0.23 time " __TIME__ " " __DATE__ "\n");
2324 while (index < NR_DEVICE &&
2325 (pcidev = pci_find_device(PCI_VENDOR_ID_ENSONIQ, PCI_DEVICE_ID_ENSONIQ_ES1370, pcidev))) {
2326 if (pcidev->base_address[0] == 0 ||
2327 (pcidev->base_address[0] & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_IO)
2328 continue;
2329 if (pcidev->irq == 0)
2330 continue;
2331 if (!(s = kmalloc(sizeof(struct es1370_state), GFP_KERNEL))) {
2332 printk(KERN_WARNING "es1370: out of memory\n");
2333 continue;
2334 }
2335 memset(s, 0, sizeof(struct es1370_state));
2336 init_waitqueue_head(&s->dma_adc.wait);
2337 init_waitqueue_head(&s->dma_dac1.wait);
2338 init_waitqueue_head(&s->dma_dac2.wait);
2339 init_waitqueue_head(&s->open_wait);
2340 init_waitqueue_head(&s->midi.iwait);
2341 init_waitqueue_head(&s->midi.owait);
2342 init_MUTEX(&s->open_sem);
2343 s->magic = ES1370_MAGIC;
2344 s->io = pcidev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
2345 s->irq = pcidev->irq;
2346 if (check_region(s->io, ES1370_EXTENT)) {
2347 printk(KERN_ERR "es1370: io ports %#lx-%#lx in use\n", s->io, s->io+ES1370_EXTENT-1);
2348 goto err_region;
2349 }
2350 request_region(s->io, ES1370_EXTENT, "es1370");
2351 if (request_irq(s->irq, es1370_interrupt, SA_SHIRQ, "es1370", s)) {
2352 printk(KERN_ERR "es1370: irq %u in use\n", s->irq);
2353 goto err_irq;
2354 }
2355 /* initialize codec registers */
2356 /* note: setting CTRL_SERR_DIS is reported to break
2357 * mic bias setting (by Kim.Berts@fisub.mail.abb.com) */
2358 s->ctrl = CTRL_CDC_EN | (DAC2_SRTODIV(8000) << CTRL_SH_PCLKDIV) | (1 << CTRL_SH_WTSRSEL);
2359 if (joystick[index]) {
2360 if (check_region(0x200, JOY_EXTENT))
2361 printk(KERN_ERR "es1370: io port 0x200 in use\n");
2362 else
2363 s->ctrl |= CTRL_JYSTK_EN;
2364 }
2365 if (lineout[index])
2366 s->ctrl |= CTRL_XCTL0;
2367 if (micbias[index])
2368 s->ctrl |= CTRL_XCTL1;
2369 s->sctrl = 0;
2370 printk(KERN_INFO "es1370: found adapter at io %#lx irq %u\n"
2371 KERN_INFO "es1370: features: joystick %s, line %s, mic impedance %s\n",
2372 s->io, s->irq, (s->ctrl & CTRL_JYSTK_EN) ? "on" : "off",
2373 (s->ctrl & CTRL_XCTL0) ? "out" : "in",
2374 (s->ctrl & CTRL_XCTL1) ? "1" : "0");
2375 /* register devices */
2376 if ((s->dev_audio = register_sound_dsp(&es1370_audio_fops, -1)) < 0)
2377 goto err_dev1;
2378 if ((s->dev_mixer = register_sound_mixer(&es1370_mixer_fops, -1)) < 0)
2379 goto err_dev2;
2380 if ((s->dev_dac = register_sound_dsp(&es1370_dac_fops, -1)) < 0)
2381 goto err_dev3;
2382 if ((s->dev_midi = register_sound_midi(&es1370_midi_fops, -1)) < 0)
2383 goto err_dev4;
2384 /* initialize the chips */
2385 outl(s->ctrl, s->io+ES1370_REG_CONTROL);
2386 outl(s->sctrl, s->io+ES1370_REG_SERIAL_CONTROL);
2387 wrcodec(s, 0x16, 3); /* no RST, PD */
2388 wrcodec(s, 0x17, 0); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off the LRCLK2 PLL; program DAC_SYNC=0!! */
2389 wrcodec(s, 0x18, 0); /* recording source is mixer */
2390 wrcodec(s, 0x19, s->mix.micpreamp = 1); /* turn on MIC preamp */
2391 s->mix.imix = 1;
2392 fs = get_fs();
2393 set_fs(KERNEL_DS);
2394 val = SOUND_MASK_LINE|SOUND_MASK_SYNTH|SOUND_MASK_CD;
2395 mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
2396 for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
2397 val = initvol[i].vol;
2398 mixer_ioctl(s, initvol[i].mixch, (unsigned long)&val);
2399 }
2400 set_fs(fs);
2401 /* queue it for later freeing */
2402 s->next = devs;
2403 devs = s;
2404 index++;
2405 continue;
2406
2407 err_dev4:
2408 unregister_sound_dsp(s->dev_dac);
2409 err_dev3:
2410 unregister_sound_mixer(s->dev_mixer);
2411 err_dev2:
2412 unregister_sound_dsp(s->dev_audio);
2413 err_dev1:
2414 printk(KERN_ERR "es1370: cannot register misc device\n");
2415 free_irq(s->irq, s);
2416 err_irq:
2417 release_region(s->io, ES1370_EXTENT);
2418 err_region:
2419 kfree_s(s, sizeof(struct es1370_state));
2420 }
2421 if (!devs)
2422 return -ENODEV;
2423 return 0;
2424 }
2425
2426 /* --------------------------------------------------------------------- */
2427
2428 #ifdef MODULE
2429
2430 MODULE_PARM(joystick, "1-" __MODULE_STRING(NR_DEVICE) "i");
2431 MODULE_PARM_DESC(joystick, "if 1 enables joystick interface (still need separate driver)");
2432 MODULE_PARM(lineout, "1-" __MODULE_STRING(NR_DEVICE) "i");
2433 MODULE_PARM_DESC(lineout, "if 1 the LINE input is converted to LINE out");
2434 MODULE_PARM(micbias, "1-" __MODULE_STRING(NR_DEVICE) "i");
2435 MODULE_PARM_DESC(micbias, "sets the +5V bias for an electret microphone");
2436
2437 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
2438 MODULE_DESCRIPTION("ES1370 AudioPCI Driver");
2439
2440 void cleanup_module(void)
2441 {
2442 struct es1370_state *s;
2443
2444 while ((s = devs)) {
2445 devs = devs->next;
2446 outl(CTRL_SERR_DIS | (1 << CTRL_SH_WTSRSEL), s->io+ES1370_REG_CONTROL); /* switch everything off */
2447 outl(0, s->io+ES1370_REG_SERIAL_CONTROL); /* clear serial interrupts */
2448 synchronize_irq();
2449 free_irq(s->irq, s);
2450 release_region(s->io, ES1370_EXTENT);
2451 unregister_sound_dsp(s->dev_audio);
2452 unregister_sound_mixer(s->dev_mixer);
2453 unregister_sound_dsp(s->dev_dac);
2454 unregister_sound_midi(s->dev_midi);
2455 kfree_s(s, sizeof(struct es1370_state));
2456 }
2457 printk(KERN_INFO "es1370: unloading\n");
2458 }
2459
2460 #endif /* MODULE */
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux