1 /*****************************************************************************/
4 * cmpci.c -- C-Media PCI audio driver.
6 * Copyright (C) 1999 ChenLi Tien (cltien@home.com)
8 * Based on the PCI drivers by Thomas Sailer (sailer@ife.ee.ethz.ch)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Special thanks to David C. Niemi, Jan Pfeifer
27 * Module command line parameters:
32 * /dev/dsp standard /dev/dsp device, (mostly) OSS compatible
33 * /dev/mixer standard /dev/mixer device, (mostly) OSS compatible
34 * /dev/midi simple MIDI UART interface, no ioctl
36 * The card has both an FM and a Wavetable synth, but I have to figure
37 * out first how to drive them...
40 * 06.05.98 0.1 Initial release
41 * 10.05.98 0.2 Fixed many bugs, esp. ADC rate calculation
42 * First stab at a simple midi interface (no bells&whistles)
43 * 13.05.98 0.3 Fix stupid cut&paste error: set_adc_rate was called instead of
44 * set_dac_rate in the FMODE_WRITE case in cm_open
45 * Fix hwptr out of bounds (now mpg123 works)
46 * 14.05.98 0.4 Don't allow excessive interrupt rates
47 * 08.06.98 0.5 First release using Alan Cox' soundcore instead of miscdevice
48 * 03.08.98 0.6 Do not include modversions.h
49 * Now mixer behaviour can basically be selected between
50 * "OSS documented" and "OSS actual" behaviour
51 * 31.08.98 0.7 Fix realplayer problems - dac.count issues
52 * 10.12.98 0.8 Fix drain_dac trying to wait on not yet initialized DMA
53 * 16.12.98 0.9 Fix a few f_file & FMODE_ bugs
54 * 06.01.99 0.10 remove the silly SA_INTERRUPT flag.
55 * hopefully killed the egcs section type conflict
56 * 12.03.99 0.11 cinfo.blocks should be reset after GETxPTR ioctl.
57 * reported by Johan Maes <joma@telindus.be>
58 * 22.03.99 0.12 return EAGAIN instead of EBUSY when O_NONBLOCK
59 * read/write cannot be executed
60 * 20 09 99 0.13 merged the generic changes in sonicvibes since this
62 * 18.08.99 1.5 Only deallocate DMA buffer when unloading.
63 * 02.09.99 1.6 Enable SPDIF LOOP
64 * Change the mixer read back
65 * 21.09.99 2.33 Use RCS version as driver version.
66 * Add support for modem, S/PDIF loop and 4 channels.
68 * Fix bug cause x11amp cannot play.
70 * Revision 2.41 1999/10/27 02:00:05 cltien
71 * Now the fragsize for modem is activated by parameter.
73 * Revision 2.40 1999/10/26 23:38:26 cltien
74 * Remove debugging message in cm_write which may cause module counter not 0.
76 * Revision 2.39 1999/10/26 21:52:50 cltien
77 * I forgor too adjust mic recording volume, as it should be moved to 5MUTEMONO.
78 * Change the DYNAMIC macro to FIXEDDMA, which means static DMA buffer.
80 * Revision 2.38 1999/10/08 21:59:03 cltien
81 * Set FLINKON and reset FLINKOFF for modem.
83 * Revision 2.37 1999/09/28 02:57:04 cltien
84 * Add set_bus_master() to make sure bus master enabled.
86 * Revision 2.36 1999/09/22 14:15:03 cltien
87 * Use open_sem to avoid multiple access to open_mode.
88 * Use wakeup in IntrClose to activate process in waiting queue.
90 * Revision 2.35 1999/09/22 13:20:53 cltien
91 * Use open_mode to check if DAC in used. Also more check in IntrWrite and IntrClose. Now the modem can access DAC safely.
93 * Revision 2.34 1999/09/22 03:29:57 cltien
94 * Use module count to decide which one to access the dac.
99 /*****************************************************************************/
101 #include <linux/config.h>
102 #include <linux/version.h>
103 #include <linux/module.h>
104 #include <linux/string.h>
105 #include <linux/ioport.h>
106 #include <linux/sched.h>
107 #include <linux/delay.h>
108 #include <linux/sound.h>
109 #include <linux/malloc.h>
110 #include <linux/soundcard.h>
111 #include <linux/pci.h>
112 #include <linux/wrapper.h>
115 #include <linux/init.h>
116 #include <linux/poll.h>
117 #include <linux/spinlock.h>
118 #include <linux/smp_lock.h>
119 #include <asm/uaccess.h>
120 #include <asm/hardirq.h>
124 /* --------------------------------------------------------------------- */
126 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
128 /* --------------------------------------------------------------------- */
130 #ifndef PCI_VENDOR_ID_CMEDIA
131 #define PCI_VENDOR_ID_CMEDIA 0x13F6
133 #ifndef PCI_DEVICE_ID_CMEDIA_CM8338A
134 #define PCI_DEVICE_ID_CMEDIA_CM8338A 0x0100
136 #ifndef PCI_DEVICE_ID_CMEDIA_CM8338B
137 #define PCI_DEVICE_ID_CMEDIA_CM8338B 0x0101
139 #ifndef PCI_DEVICE_ID_CMEDIA_CM8738
140 #define PCI_DEVICE_ID_CMEDIA_CM8738 0x0111
143 #define CM_MAGIC ((PCI_VENDOR_ID_CMEDIA<<16)|PCI_DEVICE_ID_CMEDIA_CM8338A)
146 * CM8338 registers definition
149 #define CODEC_CMI_FUNCTRL0 (0x00)
150 #define CODEC_CMI_FUNCTRL1 (0x04)
151 #define CODEC_CMI_CHFORMAT (0x08)
152 #define CODEC_CMI_INT_HLDCLR (0x0C)
153 #define CODEC_CMI_INT_STATUS (0x10)
154 #define CODEC_CMI_LEGACY_CTRL (0x14)
155 #define CODEC_CMI_MISC_CTRL (0x18)
156 #define CODEC_CMI_TDMA_POS (0x1C)
157 #define CODEC_CMI_MIXER (0x20)
158 #define CODEC_SB16_DATA (0x22)
159 #define CODEC_SB16_ADDR (0x23)
160 #define CODEC_CMI_MIXER1 (0x24)
161 #define CODEC_CMI_MIXER2 (0x25)
162 #define CODEC_CMI_AUX_VOL (0x26)
163 #define CODEC_CMI_MISC (0x27)
164 #define CODEC_CMI_AC97 (0x28)
166 #define CODEC_CMI_CH0_FRAME1 (0x80)
167 #define CODEC_CMI_CH0_FRAME2 (0x84)
168 #define CODEC_CMI_CH1_FRAME1 (0x88)
169 #define CODEC_CMI_CH1_FRAME2 (0x8C)
171 #define CODEC_CMI_EXT_REG (0xF0)
172 #define UCHAR unsigned char
174 ** Mixer registers for SB16
177 #define DSP_MIX_DATARESETIDX ((UCHAR)(0x00))
179 #define DSP_MIX_MASTERVOLIDX_L ((UCHAR)(0x30))
180 #define DSP_MIX_MASTERVOLIDX_R ((UCHAR)(0x31))
181 #define DSP_MIX_VOICEVOLIDX_L ((UCHAR)(0x32))
182 #define DSP_MIX_VOICEVOLIDX_R ((UCHAR)(0x33))
183 #define DSP_MIX_FMVOLIDX_L ((UCHAR)(0x34))
184 #define DSP_MIX_FMVOLIDX_R ((UCHAR)(0x35))
185 #define DSP_MIX_CDVOLIDX_L ((UCHAR)(0x36))
186 #define DSP_MIX_CDVOLIDX_R ((UCHAR)(0x37))
187 #define DSP_MIX_LINEVOLIDX_L ((UCHAR)(0x38))
188 #define DSP_MIX_LINEVOLIDX_R ((UCHAR)(0x39))
190 #define DSP_MIX_MICVOLIDX ((UCHAR)(0x3A))
191 #define DSP_MIX_SPKRVOLIDX ((UCHAR)(0x3B))
193 #define DSP_MIX_OUTMIXIDX ((UCHAR)(0x3C))
195 #define DSP_MIX_ADCMIXIDX_L ((UCHAR)(0x3D))
196 #define DSP_MIX_ADCMIXIDX_R ((UCHAR)(0x3E))
198 #define DSP_MIX_INGAINIDX_L ((UCHAR)(0x3F))
199 #define DSP_MIX_INGAINIDX_R ((UCHAR)(0x40))
200 #define DSP_MIX_OUTGAINIDX_L ((UCHAR)(0x41))
201 #define DSP_MIX_OUTGAINIDX_R ((UCHAR)(0x42))
203 #define DSP_MIX_AGCIDX ((UCHAR)(0x43))
205 #define DSP_MIX_TREBLEIDX_L ((UCHAR)(0x44))
206 #define DSP_MIX_TREBLEIDX_R ((UCHAR)(0x45))
207 #define DSP_MIX_BASSIDX_L ((UCHAR)(0x46))
208 #define DSP_MIX_BASSIDX_R ((UCHAR)(0x47))
209 #define CM_CH0_RESET 0x04
210 #define CM_CH1_RESET 0x08
211 #define CM_EXTENT_CODEC 0x100
212 #define CM_EXTENT_MIDI 0x2
213 #define CM_EXTENT_SYNTH 0x4
217 #define CM_CFMT_STEREO 0x01
218 #define CM_CFMT_16BIT 0x02
219 #define CM_CFMT_MASK 0x03
220 #define CM_CFMT_DACSHIFT 0
221 #define CM_CFMT_ADCSHIFT 2
223 static const unsigned sample_size
[] = { 1, 2, 2, 4 };
224 static const unsigned sample_shift
[] = { 0, 1, 1, 2 };
226 #define CM_CENABLE_RE 0x2
227 #define CM_CENABLE_PE 0x1
230 /* MIDI buffer sizes */
232 #define MIDIINBUF 256
233 #define MIDIOUTBUF 256
235 #define FMODE_MIDI_SHIFT 2
236 #define FMODE_MIDI_READ (FMODE_READ << FMODE_MIDI_SHIFT)
237 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
239 #define FMODE_DMFM 0x10
241 /* --------------------------------------------------------------------- */
247 /* we keep cm cards in a linked list */
248 struct cm_state
*next
;
250 /* soundcore stuff */
256 /* hardware resources */
257 unsigned int iosb
, iobase
, iosynth
, iomidi
, iogame
, irq
;
262 #ifndef OSS_DOCUMENTED_MIXER_SEMANTICS
263 unsigned short vol
[13];
264 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
268 unsigned int rateadc
, ratedac
;
269 unsigned char fmt
, enable
;
272 struct semaphore open_sem
;
274 wait_queue_head_t open_wait
;
281 unsigned hwptr
, swptr
;
282 unsigned total_bytes
;
284 unsigned error
; /* over/underrun */
285 wait_queue_head_t wait
;
286 /* redundant, but makes calculations easier */
289 unsigned fragsamples
;
294 unsigned endcleared
:1;
295 unsigned ossfragshift
;
297 unsigned subdivision
;
302 unsigned ird
, iwr
, icnt
;
303 unsigned ord
, owr
, ocnt
;
304 wait_queue_head_t iwait
;
305 wait_queue_head_t owait
;
306 struct timer_list timer
;
307 unsigned char ibuf
[MIDIINBUF
];
308 unsigned char obuf
[MIDIOUTBUF
];
312 /* --------------------------------------------------------------------- */
314 static struct cm_state
*devs
= NULL
;
315 static unsigned long wavetable_mem
= 0;
317 /* --------------------------------------------------------------------- */
319 extern __inline__
unsigned ld2(unsigned int x
)
345 * hweightN: returns the hamming weight (i.e. the number
346 * of bits set) of a N-bit word
353 extern __inline__
unsigned int hweight32(unsigned int w
)
355 unsigned int res
= (w
& 0x55555555) + ((w
>> 1) & 0x55555555);
356 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
357 res
= (res
& 0x0F0F0F0F) + ((res
>> 4) & 0x0F0F0F0F);
358 res
= (res
& 0x00FF00FF) + ((res
>> 8) & 0x00FF00FF);
359 return (res
& 0x0000FFFF) + ((res
>> 16) & 0x0000FFFF);
362 /* --------------------------------------------------------------------- */
364 static void set_dmadac(struct cm_state
*s
, unsigned int addr
, unsigned int count
)
367 outl(addr
, s
->iobase
+ CODEC_CMI_CH0_FRAME1
);
368 outw(count
, s
->iobase
+ CODEC_CMI_CH0_FRAME2
);
369 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL0
) & ~1, s
->iobase
+ CODEC_CMI_FUNCTRL0
);
370 // outb(inb(s->iobase + CODEC_CMI_FUNCTRL0 + 2) | 1, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
373 static void set_dmaadc(struct cm_state
*s
, unsigned int addr
, unsigned int count
)
376 outl(addr
, s
->iobase
+ CODEC_CMI_CH1_FRAME1
);
377 outw(count
, s
->iobase
+ CODEC_CMI_CH1_FRAME2
);
378 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL0
) | 2, s
->iobase
+ CODEC_CMI_FUNCTRL0
);
379 // outb(inb(s->iobase + CODEC_CMI_FUNCTRL0 + 2) | 2, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
382 extern __inline__
unsigned get_dmadac(struct cm_state
*s
)
384 unsigned int curr_addr
;
386 if (!s
->dma_dac
.dmasize
|| !(s
->enable
& CM_CENABLE_PE
))
389 curr_addr
= inl(s
->iobase
+ CODEC_CMI_CH0_FRAME1
);
390 curr_addr
-= virt_to_bus(s
->dma_dac
.rawbuf
);
391 curr_addr
= s
->dma_dac
.dmasize
- curr_addr
;
392 curr_addr
&= ~(sample_size
[(s
->fmt
>> CM_CFMT_DACSHIFT
) & CM_CFMT_MASK
]-1);
396 extern __inline__
unsigned get_dmaadc(struct cm_state
*s
)
398 unsigned int curr_addr
;
400 if (!s
->dma_adc
.dmasize
|| !(s
->enable
& CM_CENABLE_RE
))
403 curr_addr
= inl(s
->iobase
+ CODEC_CMI_CH1_FRAME1
);
404 curr_addr
-= virt_to_bus(s
->dma_adc
.rawbuf
);
405 curr_addr
= s
->dma_adc
.dmasize
- curr_addr
;
406 curr_addr
&= ~(sample_size
[(s
->fmt
>> CM_CFMT_ADCSHIFT
) & CM_CFMT_MASK
]-1);
410 static void wrmixer(struct cm_state
*s
, unsigned char idx
, unsigned char data
)
412 outb(idx
, s
->iobase
+ CODEC_SB16_ADDR
);
414 outb(data
, s
->iobase
+ CODEC_SB16_DATA
);
418 static unsigned char rdmixer(struct cm_state
*s
, unsigned char idx
)
422 outb(idx
, s
->iobase
+ CODEC_SB16_ADDR
);
424 v
= inb(s
->iobase
+ CODEC_SB16_DATA
);
429 static void set_fmt(struct cm_state
*s
, unsigned char mask
, unsigned char data
)
433 spin_lock_irqsave(&s
->lock
, flags
);
435 s
->fmt
= inb(s
->iobase
+ CODEC_CMI_CHFORMAT
);
438 s
->fmt
= (s
->fmt
& mask
) | data
;
439 outb(s
->fmt
, s
->iobase
+ CODEC_CMI_CHFORMAT
);
440 spin_unlock_irqrestore(&s
->lock
, flags
);
444 static void frobindir(struct cm_state
*s
, unsigned char idx
, unsigned char mask
, unsigned char data
)
446 outb(idx
, s
->iobase
+ CODEC_SB16_ADDR
);
448 outb((inb(s
->iobase
+ CODEC_SB16_DATA
) & mask
) | data
, s
->iobase
+ CODEC_SB16_DATA
);
459 { 5512, (0 + 5512) / 2, (5512 + 8000) / 2, 0 },
460 { 8000, (5512 + 8000) / 2, (8000 + 11025) / 2, 4 },
461 { 11025, (8000 + 11025) / 2, (11025 + 16000) / 2, 1 },
462 { 16000, (11025 + 16000) / 2, (16000 + 22050) / 2, 5 },
463 { 22050, (16000 + 22050) / 2, (22050 + 32000) / 2, 2 },
464 { 32000, (22050 + 32000) / 2, (32000 + 44100) / 2, 6 },
465 { 44100, (32000 + 44100) / 2, (44100 + 48000) / 2, 3 },
466 { 48000, (44100 + 48000) /2, 48000, 7 }
469 static void set_dac_rate(struct cm_state
*s
, unsigned rate
)
472 unsigned char freq
= 4, val
;
479 for (i
= 0; i
< sizeof(rate_lookup
) / sizeof(rate_lookup
[0]); i
++)
481 if (rate
> rate_lookup
[i
].lower
&& rate
<= rate_lookup
[i
].upper
)
483 rate
= rate_lookup
[i
].rate
;
484 freq
= rate_lookup
[i
].freq
;
490 spin_lock_irqsave(&s
->lock
, flags
);
491 val
= inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
+ 1) & ~0x1c;
492 outb(val
| freq
, s
->iobase
+ CODEC_CMI_FUNCTRL1
+ 1);
493 spin_unlock_irqrestore(&s
->lock
, flags
);
496 static void set_adc_rate(struct cm_state
*s
, unsigned rate
)
499 unsigned char freq
= 4, val
;
506 for (i
= 0; i
< sizeof(rate_lookup
) / sizeof(rate_lookup
[0]); i
++)
508 if (rate
> rate_lookup
[i
].lower
&& rate
<= rate_lookup
[i
].upper
)
510 rate
= rate_lookup
[i
].rate
;
511 freq
= rate_lookup
[i
].freq
;
517 spin_lock_irqsave(&s
->lock
, flags
);
518 val
= inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
+ 1) & ~0xe0;
519 outb(val
| freq
, s
->iobase
+ CODEC_CMI_FUNCTRL1
+ 1);
520 spin_unlock_irqrestore(&s
->lock
, flags
);
523 /* --------------------------------------------------------------------- */
525 extern inline void stop_adc(struct cm_state
*s
)
529 spin_lock_irqsave(&s
->lock
, flags
);
530 /* disable channel */
531 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
532 s
->enable
&= ~CM_CENABLE_RE
;
533 /* disable interrupt */
534 outb(inb(s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2) & ~2, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
536 outb(s
->enable
| CM_CH1_RESET
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
538 outb(s
->enable
& ~CM_CH1_RESET
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
539 spin_unlock_irqrestore(&s
->lock
, flags
);
542 extern inline void stop_dac(struct cm_state
*s
)
546 spin_lock_irqsave(&s
->lock
, flags
);
547 /* disable channel */
548 s
->enable
&= ~CM_CENABLE_PE
;
549 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
550 /* disable interrupt */
551 outb(inb(s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2) & ~1, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
553 outb(s
->enable
| CM_CH0_RESET
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
555 outb(s
->enable
& ~CM_CH0_RESET
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
556 spin_unlock_irqrestore(&s
->lock
, flags
);
559 static void start_dac(struct cm_state
*s
)
563 spin_lock_irqsave(&s
->lock
, flags
);
564 if ((s
->dma_dac
.mapped
|| s
->dma_dac
.count
> 0) && s
->dma_dac
.ready
) {
565 outb(inb(s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2) | 1, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
566 s
->enable
|= CM_CENABLE_PE
;
567 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
569 spin_unlock_irqrestore(&s
->lock
, flags
);
572 static void start_adc(struct cm_state
*s
)
576 spin_lock_irqsave(&s
->lock
, flags
);
577 if ((s
->dma_adc
.mapped
|| s
->dma_adc
.count
< (signed)(s
->dma_adc
.dmasize
- 2*s
->dma_adc
.fragsize
))
578 && s
->dma_adc
.ready
) {
579 outb(inb(s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2) | 2, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
580 s
->enable
|= CM_CENABLE_RE
;
581 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
583 spin_unlock_irqrestore(&s
->lock
, flags
);
586 /* --------------------------------------------------------------------- */
588 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
589 #define DMABUF_MINORDER 1
591 static void dealloc_dmabuf(struct dmabuf
*db
)
593 struct page
*pstart
, *pend
;
596 /* undo marking the pages as reserved */
597 pend
= virt_to_page(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
598 for (pstart
= virt_to_page(db
->rawbuf
); pstart
<= pend
; pstart
++)
599 mem_map_unreserve(pstart
);
600 free_pages((unsigned long)db
->rawbuf
, db
->buforder
);
603 db
->mapped
= db
->ready
= 0;
607 /* Ch0 is used for playback, Ch1 is used for recording */
609 static int prog_dmabuf(struct cm_state
*s
, unsigned rec
)
611 struct dmabuf
*db
= rec
? &s
->dma_adc
: &s
->dma_dac
;
612 unsigned rate
= rec
? s
->rateadc
: s
->ratedac
;
616 struct page
*pstart
, *pend
;
620 spin_lock_irqsave(&s
->lock
, flags
);
623 s
->enable
&= ~CM_CENABLE_RE
;
624 fmt
>>= CM_CFMT_ADCSHIFT
;
626 s
->enable
&= ~CM_CENABLE_PE
;
627 fmt
>>= CM_CFMT_DACSHIFT
;
629 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
630 spin_unlock_irqrestore(&s
->lock
, flags
);
632 db
->hwptr
= db
->swptr
= db
->total_bytes
= db
->count
= db
->error
= db
->endcleared
= 0;
634 db
->ready
= db
->mapped
= 0;
635 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--)
636 if ((db
->rawbuf
= (void *)__get_free_pages(GFP_KERNEL
| GFP_DMA
, order
)))
640 db
->buforder
= order
;
641 if ((virt_to_bus(db
->rawbuf
) ^ (virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1)) & ~0xffff)
642 printk(KERN_DEBUG
"cmpci: DMA buffer crosses 64k boundary: busaddr 0x%lx size %ld\n",
643 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
644 if ((virt_to_bus(db
->rawbuf
) + (PAGE_SIZE
<< db
->buforder
) - 1) & ~0xffffff)
645 printk(KERN_DEBUG
"cmpci: DMA buffer beyond 16MB: busaddr 0x%lx size %ld\n",
646 virt_to_bus(db
->rawbuf
), PAGE_SIZE
<< db
->buforder
);
647 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
648 pend
= virt_to_page(db
->rawbuf
+ (PAGE_SIZE
<< db
->buforder
) - 1);
649 for (pstart
= virt_to_page(db
->rawbuf
); pstart
<= pend
; pstart
++)
650 mem_map_reserve(pstart
);
652 bytepersec
= rate
<< sample_shift
[fmt
];
653 bufs
= PAGE_SIZE
<< db
->buforder
;
654 if (db
->ossfragshift
) {
655 if ((1000 << db
->ossfragshift
) < bytepersec
)
656 db
->fragshift
= ld2(bytepersec
/1000);
658 db
->fragshift
= db
->ossfragshift
;
660 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
661 if (db
->fragshift
< 3)
664 db
->numfrag
= bufs
>> db
->fragshift
;
665 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
667 db
->numfrag
= bufs
>> db
->fragshift
;
669 db
->fragsize
= 1 << db
->fragshift
;
670 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
671 db
->numfrag
= db
->ossmaxfrags
;
672 /* to make fragsize >= 4096 */
676 while (db
->fragsize
< 4096 && db
->numfrag
>= 4)
684 db
->fragsamples
= db
->fragsize
>> sample_shift
[fmt
];
685 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
686 db
->dmasamples
= db
->dmasize
>> sample_shift
[fmt
];
687 memset(db
->rawbuf
, (fmt
& CM_CFMT_16BIT
) ? 0 : 0x80, db
->dmasize
);
688 spin_lock_irqsave(&s
->lock
, flags
);
690 set_dmaadc(s
, virt_to_bus(db
->rawbuf
), db
->dmasize
>> sample_shift
[fmt
]);
691 /* program sample counts */
692 outw(db
->fragsamples
-1, s
->iobase
+ CODEC_CMI_CH1_FRAME2
+ 2);
694 set_dmadac(s
, virt_to_bus(db
->rawbuf
), db
->dmasize
>> sample_shift
[fmt
]);
695 /* program sample counts */
696 outw(db
->fragsamples
-1, s
->iobase
+ CODEC_CMI_CH0_FRAME2
+ 2);
698 spin_unlock_irqrestore(&s
->lock
, flags
);
703 extern __inline__
void clear_advance(struct cm_state
*s
)
705 unsigned char c
= (s
->fmt
& (CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
)) ? 0 : 0x80;
706 unsigned char *buf
= s
->dma_dac
.rawbuf
;
707 unsigned bsize
= s
->dma_dac
.dmasize
;
708 unsigned bptr
= s
->dma_dac
.swptr
;
709 unsigned len
= s
->dma_dac
.fragsize
;
711 if (bptr
+ len
> bsize
) {
712 unsigned x
= bsize
- bptr
;
713 memset(buf
+ bptr
, c
, x
);
717 memset(buf
+ bptr
, c
, len
);
718 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
721 /* call with spinlock held! */
722 static void cm_update_ptr(struct cm_state
*s
)
727 /* update ADC pointer */
728 if (s
->dma_adc
.ready
) {
729 hwptr
= (s
->dma_adc
.dmasize
- get_dmaadc(s
)) % s
->dma_adc
.dmasize
;
730 diff
= (s
->dma_adc
.dmasize
+ hwptr
- s
->dma_adc
.hwptr
) % s
->dma_adc
.dmasize
;
731 s
->dma_adc
.hwptr
= hwptr
;
732 s
->dma_adc
.total_bytes
+= diff
;
733 s
->dma_adc
.count
+= diff
;
734 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
735 wake_up(&s
->dma_adc
.wait
);
736 if (!s
->dma_adc
.mapped
) {
737 if (s
->dma_adc
.count
> (signed)(s
->dma_adc
.dmasize
- ((3 * s
->dma_adc
.fragsize
) >> 1))) {
738 s
->enable
&= ~CM_CENABLE_RE
;
739 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
744 /* update DAC pointer */
745 if (s
->dma_dac
.ready
) {
746 hwptr
= (s
->dma_dac
.dmasize
- get_dmadac(s
)) % s
->dma_dac
.dmasize
;
747 diff
= (s
->dma_dac
.dmasize
+ hwptr
- s
->dma_dac
.hwptr
) % s
->dma_dac
.dmasize
;
748 s
->dma_dac
.hwptr
= hwptr
;
749 s
->dma_dac
.total_bytes
+= diff
;
750 if (s
->dma_dac
.mapped
) {
751 s
->dma_dac
.count
+= diff
;
752 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
753 wake_up(&s
->dma_dac
.wait
);
755 s
->dma_dac
.count
-= diff
;
756 if (s
->dma_dac
.count
<= 0) {
757 s
->enable
&= ~CM_CENABLE_PE
;
758 outb(s
->enable
, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2);
760 } else if (s
->dma_dac
.count
<= (signed)s
->dma_dac
.fragsize
&& !s
->dma_dac
.endcleared
) {
762 s
->dma_dac
.endcleared
= 1;
764 if (s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
<= (signed)s
->dma_dac
.dmasize
)
765 wake_up(&s
->dma_dac
.wait
);
770 /* hold spinlock for the following! */
771 static void cm_handle_midi(struct cm_state
*s
)
777 while (!(inb(s
->iomidi
+1) & 0x80)) {
779 if (s
->midi
.icnt
< MIDIINBUF
) {
780 s
->midi
.ibuf
[s
->midi
.iwr
] = ch
;
781 s
->midi
.iwr
= (s
->midi
.iwr
+ 1) % MIDIINBUF
;
787 wake_up(&s
->midi
.iwait
);
789 while (!(inb(s
->iomidi
+1) & 0x40) && s
->midi
.ocnt
> 0) {
790 outb(s
->midi
.obuf
[s
->midi
.ord
], s
->iomidi
);
791 s
->midi
.ord
= (s
->midi
.ord
+ 1) % MIDIOUTBUF
;
793 if (s
->midi
.ocnt
< MIDIOUTBUF
-16)
797 wake_up(&s
->midi
.owait
);
800 static void cm_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
802 struct cm_state
*s
= (struct cm_state
*)dev_id
;
803 unsigned int intsrc
, intstat
;
805 /* fastpath out, to ease interrupt sharing */
806 intsrc
= inl(s
->iobase
+ CODEC_CMI_INT_STATUS
);
807 if (!(intsrc
& 0x80000000))
810 intstat
= inb(s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
811 /* acknowledge interrupt */
812 if (intsrc
& CM_INT_CH0
)
814 outb(intstat
& ~1, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
816 outb(intstat
| 1, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
818 if (intsrc
& CM_INT_CH1
)
820 outb(intstat
& ~2, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
822 outb(intstat
| 2, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2);
826 spin_unlock(&s
->lock
);
829 static void cm_midi_timer(unsigned long data
)
831 struct cm_state
*s
= (struct cm_state
*)data
;
834 spin_lock_irqsave(&s
->lock
, flags
);
836 spin_unlock_irqrestore(&s
->lock
, flags
);
837 s
->midi
.timer
.expires
= jiffies
+1;
838 add_timer(&s
->midi
.timer
);
841 /* --------------------------------------------------------------------- */
843 static const char invalid_magic
[] = KERN_CRIT
"cmpci: invalid magic value\n";
845 #ifdef CONFIG_SOUND_CMPCI /* support multiple chips */
846 #define VALIDATE_STATE(s)
848 #define VALIDATE_STATE(s) \
850 if (!(s) || (s)->magic != CM_MAGIC) { \
851 printk(invalid_magic); \
857 /* --------------------------------------------------------------------- */
861 #define MT_4MUTEMONO 3
863 #define MT_5MUTEMONO 5
865 static const struct {
871 } mixtable
[SOUND_MIXER_NRDEVICES
] = {
872 [SOUND_MIXER_CD
] = { DSP_MIX_CDVOLIDX_L
, DSP_MIX_CDVOLIDX_R
, MT_5MUTE
, 0x04, 0x02 },
873 [SOUND_MIXER_LINE
] = { DSP_MIX_LINEVOLIDX_L
, DSP_MIX_LINEVOLIDX_R
, MT_5MUTE
, 0x10, 0x08 },
874 [SOUND_MIXER_MIC
] = { DSP_MIX_MICVOLIDX
, DSP_MIX_MICVOLIDX
, MT_5MUTEMONO
, 0x01, 0x01 },
875 [SOUND_MIXER_SYNTH
] = { DSP_MIX_FMVOLIDX_L
, DSP_MIX_FMVOLIDX_R
, MT_5MUTE
, 0x40, 0x00 },
876 [SOUND_MIXER_VOLUME
] = { DSP_MIX_MASTERVOLIDX_L
, DSP_MIX_MASTERVOLIDX_R
, MT_5MUTE
, 0x00, 0x00 },
877 [SOUND_MIXER_PCM
] = { DSP_MIX_VOICEVOLIDX_L
, DSP_MIX_VOICEVOLIDX_R
, MT_5MUTE
, 0x00, 0x00 }
880 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
882 static int return_mixval(struct cm_state
*s
, unsigned i
, int *arg
)
885 unsigned char l
, r
, rl
, rr
;
887 spin_lock_irqsave(&s
->lock
, flags
);
888 l
= rdmixer(s
, mixtable
[i
].left
);
889 r
= rdmixer(s
, mixtable
[i
].right
);
890 spin_unlock_irqrestore(&s
->lock
, flags
);
891 switch (mixtable
[i
].type
) {
895 rl
= 10 + 6 * (l
& 15);
896 rr
= 10 + 6 * (r
& 15);
900 rl
= 55 - 3 * (l
& 15);
909 rl
= 100 - 3 * ((l
>> 3) & 31);
915 rl
= 100 - 3 * ((l
>> 3) & 31);
916 rr
= 100 - 3 * ((r
>> 3) & 31);
920 rl
= 100 - 3 * (l
& 63) / 2;
921 rr
= 100 - 3 * (r
& 63) / 2;
928 return put_user((rr
<< 8) | rl
, arg
);
931 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
933 static const unsigned char volidx
[SOUND_MIXER_NRDEVICES
] =
935 [SOUND_MIXER_CD
] = 1,
936 [SOUND_MIXER_LINE
] = 2,
937 [SOUND_MIXER_MIC
] = 3,
938 [SOUND_MIXER_SYNTH
] = 4,
939 [SOUND_MIXER_VOLUME
] = 5,
940 [SOUND_MIXER_PCM
] = 6
943 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
945 static unsigned mixer_recmask(struct cm_state
*s
)
950 spin_lock_irqsave(&s
->lock
, flags
);
951 j
= rdmixer(s
, DSP_MIX_ADCMIXIDX_L
);
952 spin_unlock_irqrestore(&s
->lock
, flags
);
954 for (k
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
955 if (j
& mixtable
[i
].rec
)
960 static int mixer_ioctl(struct cm_state
*s
, unsigned int cmd
, unsigned long arg
)
964 unsigned char l
, r
, rl
, rr
;
967 if (cmd
== SOUND_MIXER_INFO
) {
969 strncpy(info
.id
, "cmpci", sizeof(info
.id
));
970 strncpy(info
.name
, "C-Media PCI", sizeof(info
.name
));
971 info
.modify_counter
= s
->mix
.modcnt
;
972 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
976 if (cmd
== SOUND_OLD_MIXER_INFO
) {
977 _old_mixer_info info
;
978 strncpy(info
.id
, "cmpci", sizeof(info
.id
));
979 strncpy(info
.name
, "C-Media cmpci", sizeof(info
.name
));
980 if (copy_to_user((void *)arg
, &info
, sizeof(info
)))
984 if (cmd
== OSS_GETVERSION
)
985 return put_user(SOUND_VERSION
, (int *)arg
);
986 if (_IOC_TYPE(cmd
) != 'M' || _SIOC_SIZE(cmd
) != sizeof(int))
988 if (_SIOC_DIR(cmd
) == _SIOC_READ
) {
989 switch (_IOC_NR(cmd
)) {
990 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
991 return put_user(mixer_recmask(s
), (int *)arg
);
993 case SOUND_MIXER_OUTSRC
: /* Arg contains a bit for each recording source */
994 return put_user(mixer_recmask(s
), (int *)arg
);//need fix
996 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
997 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
998 if (mixtable
[i
].type
)
1000 return put_user(val
, (int *)arg
);
1002 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
1003 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1004 if (mixtable
[i
].rec
)
1006 return put_user(val
, (int *)arg
);
1008 case SOUND_MIXER_OUTMASK
: /* Arg contains a bit for each supported recording source */
1009 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1010 if (mixtable
[i
].play
)
1012 return put_user(val
, (int *)arg
);
1014 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
1015 for (val
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++)
1016 if (mixtable
[i
].type
&& mixtable
[i
].type
!= MT_4MUTEMONO
)
1018 return put_user(val
, (int *)arg
);
1020 case SOUND_MIXER_CAPS
:
1021 return put_user(0, (int *)arg
);
1025 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1027 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1028 return return_mixval(s
, i
, (int *)arg
);
1029 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1032 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1033 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1036 if (_SIOC_DIR(cmd
) != (_SIOC_READ
|_SIOC_WRITE
))
1039 switch (_IOC_NR(cmd
)) {
1040 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
1041 if (get_user(val
, (int *)arg
))
1044 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
1045 if (!(val
& (1 << i
)))
1047 if (!mixtable
[i
].rec
) {
1051 j
|= mixtable
[i
].rec
;
1053 spin_lock_irqsave(&s
->lock
, flags
);
1054 wrmixer(s
, DSP_MIX_ADCMIXIDX_L
, j
);
1055 wrmixer(s
, DSP_MIX_ADCMIXIDX_R
, (j
& 1) | (j
>>1));
1056 spin_unlock_irqrestore(&s
->lock
, flags
);
1059 case SOUND_MIXER_OUTSRC
: /* Arg contains a bit for each recording source */
1060 if (get_user(val
, (int *)arg
))
1062 for (j
= i
= 0; i
< SOUND_MIXER_NRDEVICES
; i
++) {
1063 if (!(val
& (1 << i
)))
1065 if (!mixtable
[i
].play
) {
1069 j
|= mixtable
[i
].play
;
1071 spin_lock_irqsave(&s
->lock
, flags
);
1072 frobindir(s
, DSP_MIX_OUTMIXIDX
, 0x1f, j
);
1073 spin_unlock_irqrestore(&s
->lock
, flags
);
1078 if (i
>= SOUND_MIXER_NRDEVICES
|| !mixtable
[i
].type
)
1080 if (get_user(val
, (int *)arg
))
1083 r
= (val
>> 8) & 0xff;
1088 spin_lock_irqsave(&s
->lock
, flags
);
1089 switch (mixtable
[i
].type
) {
1095 frobindir(s
, mixtable
[i
].left
, 0xf0, l
/ 6);
1096 frobindir(s
, mixtable
[i
].right
, 0xf0, l
/ 6);
1100 rl
= (l
< 4 ? 0 : (l
- 5) / 3) & 31;
1102 wrmixer(s
, mixtable
[i
].left
, rl
<<3);
1103 outb((inb(s
->iobase
+ CODEC_CMI_MIXER2
) & ~0x0e) | rr
<<1, s
->iobase
+ CODEC_CMI_MIXER2
);
1108 rl
= l
< 4 ? 0 : (l
- 5) / 3;
1110 wrmixer(s
, mixtable
[i
].left
, rl
<<3);
1111 outb((inb(s
->iobase
+ CODEC_CMI_MIXER2
) & ~0x0e) | rr
<<1, s
->iobase
+ CODEC_CMI_MIXER2
);
1115 rl
= l
< 4 ? 0 : (l
- 5) / 3;
1116 rr
= r
< 4 ? 0 : (r
- 5) / 3;
1117 wrmixer(s
, mixtable
[i
].left
, rl
<<3);
1118 wrmixer(s
, mixtable
[i
].right
, rr
<<3);
1130 wrmixer(s
, mixtable
[i
].left
, rl
);
1131 wrmixer(s
, mixtable
[i
].right
, rr
);
1134 spin_unlock_irqrestore(&s
->lock
, flags
);
1135 #ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
1136 return return_mixval(s
, i
, (int *)arg
);
1137 #else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1140 s
->mix
.vol
[volidx
[i
]-1] = val
;
1141 return put_user(s
->mix
.vol
[volidx
[i
]-1], (int *)arg
);
1142 #endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
1146 /* --------------------------------------------------------------------- */
1148 static loff_t
cm_llseek(struct file
*file
, loff_t offset
, int origin
)
1153 /* --------------------------------------------------------------------- */
1155 static int cm_open_mixdev(struct inode
*inode
, struct file
*file
)
1157 int minor
= MINOR(inode
->i_rdev
);
1158 struct cm_state
*s
= devs
;
1160 while (s
&& s
->dev_mixer
!= minor
)
1165 file
->private_data
= s
;
1169 static int cm_release_mixdev(struct inode
*inode
, struct file
*file
)
1171 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1177 static int cm_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1179 return mixer_ioctl((struct cm_state
*)file
->private_data
, cmd
, arg
);
1182 static /*const*/ struct file_operations cm_mixer_fops
= {
1185 ioctl
: cm_ioctl_mixdev
,
1186 open
: cm_open_mixdev
,
1187 release
: cm_release_mixdev
,
1190 /* --------------------------------------------------------------------- */
1192 static int drain_dac(struct cm_state
*s
, int nonblock
)
1194 DECLARE_WAITQUEUE(wait
, current
);
1195 unsigned long flags
;
1198 if (s
->dma_dac
.mapped
|| !s
->dma_dac
.ready
)
1200 add_wait_queue(&s
->dma_dac
.wait
, &wait
);
1202 set_current_state(TASK_INTERRUPTIBLE
);
1203 spin_lock_irqsave(&s
->lock
, flags
);
1204 count
= s
->dma_dac
.count
;
1205 spin_unlock_irqrestore(&s
->lock
, flags
);
1208 if (signal_pending(current
))
1211 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1212 current
->state
= TASK_RUNNING
;
1215 tmo
= (count
* HZ
) / s
->ratedac
;
1216 tmo
>>= sample_shift
[(s
->fmt
>> CM_CFMT_DACSHIFT
) & CM_CFMT_MASK
];
1217 if (!schedule_timeout(tmo
? : 1) && tmo
)
1218 printk(KERN_DEBUG
"cmpci: dma timed out??\n");
1220 remove_wait_queue(&s
->dma_dac
.wait
, &wait
);
1221 current
->state
= TASK_RUNNING
;
1222 if (signal_pending(current
))
1223 return -ERESTARTSYS
;
1227 /* --------------------------------------------------------------------- */
1229 static ssize_t
cm_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1231 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1233 unsigned long flags
;
1238 if (ppos
!= &file
->f_pos
)
1240 if (s
->dma_adc
.mapped
)
1242 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1244 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1248 spin_lock_irqsave(&s
->lock
, flags
);
1250 spin_unlock_irqrestore(&s
->lock
, flags
);
1253 spin_lock_irqsave(&s
->lock
, flags
);
1254 swptr
= s
->dma_adc
.swptr
;
1255 cnt
= s
->dma_adc
.dmasize
-swptr
;
1256 if (s
->dma_adc
.count
< cnt
)
1257 cnt
= s
->dma_adc
.count
;
1258 spin_unlock_irqrestore(&s
->lock
, flags
);
1263 if (file
->f_flags
& O_NONBLOCK
)
1264 return ret
? ret
: -EAGAIN
;
1265 if (!interruptible_sleep_on_timeout(&s
->dma_adc
.wait
, HZ
)) {
1266 printk(KERN_DEBUG
"cmpci: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1267 s
->dma_adc
.dmasize
, s
->dma_adc
.fragsize
, s
->dma_adc
.count
,
1268 s
->dma_adc
.hwptr
, s
->dma_adc
.swptr
);
1270 spin_lock_irqsave(&s
->lock
, flags
);
1271 set_dmaadc(s
, virt_to_bus(s
->dma_adc
.rawbuf
), s
->dma_adc
.dmasamples
);
1272 /* program sample counts */
1273 outw(s
->dma_adc
.fragsamples
-1, s
->iobase
+ CODEC_CMI_CH1_FRAME2
+ 2);
1274 s
->dma_adc
.count
= s
->dma_adc
.hwptr
= s
->dma_adc
.swptr
= 0;
1275 spin_unlock_irqrestore(&s
->lock
, flags
);
1277 if (signal_pending(current
))
1278 return ret
? ret
: -ERESTARTSYS
;
1281 if (copy_to_user(buffer
, s
->dma_adc
.rawbuf
+ swptr
, cnt
))
1282 return ret
? ret
: -EFAULT
;
1283 swptr
= (swptr
+ cnt
) % s
->dma_adc
.dmasize
;
1284 spin_lock_irqsave(&s
->lock
, flags
);
1285 s
->dma_adc
.swptr
= swptr
;
1286 s
->dma_adc
.count
-= cnt
;
1287 spin_unlock_irqrestore(&s
->lock
, flags
);
1296 static ssize_t
cm_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1298 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1300 unsigned long flags
;
1305 if (ppos
!= &file
->f_pos
)
1307 if (s
->dma_dac
.mapped
)
1309 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1311 if (!access_ok(VERIFY_READ
, buffer
, count
))
1315 spin_lock_irqsave(&s
->lock
, flags
);
1317 spin_unlock_irqrestore(&s
->lock
, flags
);
1320 spin_lock_irqsave(&s
->lock
, flags
);
1321 if (s
->dma_dac
.count
< 0) {
1322 s
->dma_dac
.count
= 0;
1323 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
;
1325 swptr
= s
->dma_dac
.swptr
;
1326 cnt
= s
->dma_dac
.dmasize
-swptr
;
1327 if (s
->dma_dac
.count
+ cnt
> s
->dma_dac
.dmasize
)
1328 cnt
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1329 spin_unlock_irqrestore(&s
->lock
, flags
);
1334 if (file
->f_flags
& O_NONBLOCK
)
1335 return ret
? ret
: -EAGAIN
;
1336 if (!interruptible_sleep_on_timeout(&s
->dma_dac
.wait
, HZ
)) {
1337 printk(KERN_DEBUG
"cmpci: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1338 s
->dma_dac
.dmasize
, s
->dma_dac
.fragsize
, s
->dma_dac
.count
,
1339 s
->dma_dac
.hwptr
, s
->dma_dac
.swptr
);
1341 spin_lock_irqsave(&s
->lock
, flags
);
1342 set_dmadac(s
, virt_to_bus(s
->dma_dac
.rawbuf
), s
->dma_dac
.dmasamples
);
1343 /* program sample counts */
1344 outw(s
->dma_dac
.fragsamples
-1, s
->iobase
+ CODEC_CMI_CH0_FRAME2
+ 2);
1345 s
->dma_dac
.count
= s
->dma_dac
.hwptr
= s
->dma_dac
.swptr
= 0;
1346 spin_unlock_irqrestore(&s
->lock
, flags
);
1348 if (signal_pending(current
))
1349 return ret
? ret
: -ERESTARTSYS
;
1352 if (copy_from_user(s
->dma_dac
.rawbuf
+ swptr
, buffer
, cnt
))
1353 return ret
? ret
: -EFAULT
;
1354 swptr
= (swptr
+ cnt
) % s
->dma_dac
.dmasize
;
1355 spin_lock_irqsave(&s
->lock
, flags
);
1356 s
->dma_dac
.swptr
= swptr
;
1357 s
->dma_dac
.count
+= cnt
;
1358 s
->dma_dac
.endcleared
= 0;
1359 spin_unlock_irqrestore(&s
->lock
, flags
);
1368 /* No kernel lock - fine (we have our own spinlock) */
1369 static unsigned int cm_poll(struct file
*file
, struct poll_table_struct
*wait
)
1371 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1372 unsigned long flags
;
1373 unsigned int mask
= 0;
1376 if (file
->f_mode
& FMODE_WRITE
) {
1377 if (!s
->dma_dac
.ready
&& prog_dmabuf(s
, 0))
1379 poll_wait(file
, &s
->dma_dac
.wait
, wait
);
1381 if (file
->f_mode
& FMODE_READ
) {
1382 if (!s
->dma_adc
.ready
&& prog_dmabuf(s
, 1))
1384 poll_wait(file
, &s
->dma_adc
.wait
, wait
);
1387 spin_lock_irqsave(&s
->lock
, flags
);
1389 if (file
->f_mode
& FMODE_READ
) {
1390 if (s
->dma_adc
.count
>= (signed)s
->dma_adc
.fragsize
)
1391 mask
|= POLLIN
| POLLRDNORM
;
1393 if (file
->f_mode
& FMODE_WRITE
) {
1394 if (s
->dma_dac
.mapped
) {
1395 if (s
->dma_dac
.count
>= (signed)s
->dma_dac
.fragsize
)
1396 mask
|= POLLOUT
| POLLWRNORM
;
1398 if ((signed)s
->dma_dac
.dmasize
>= s
->dma_dac
.count
+ (signed)s
->dma_dac
.fragsize
)
1399 mask
|= POLLOUT
| POLLWRNORM
;
1402 spin_unlock_irqrestore(&s
->lock
, flags
);
1406 static int cm_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1408 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1415 if (vma
->vm_flags
& VM_WRITE
) {
1416 if ((ret
= prog_dmabuf(s
, 1)) != 0)
1419 } else if (vma
->vm_flags
& VM_READ
) {
1420 if ((ret
= prog_dmabuf(s
, 0)) != 0)
1426 if (vma
->vm_pgoff
!= 0)
1428 size
= vma
->vm_end
- vma
->vm_start
;
1429 if (size
> (PAGE_SIZE
<< db
->buforder
))
1432 if (remap_page_range(vma
->vm_start
, virt_to_phys(db
->rawbuf
), size
, vma
->vm_page_prot
))
1441 static int cm_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1443 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1444 unsigned long flags
;
1445 audio_buf_info abinfo
;
1447 int val
, mapped
, ret
;
1448 unsigned char fmtm
, fmtd
;
1451 mapped
= ((file
->f_mode
& FMODE_WRITE
) && s
->dma_dac
.mapped
) ||
1452 ((file
->f_mode
& FMODE_READ
) && s
->dma_adc
.mapped
);
1454 case OSS_GETVERSION
:
1455 return put_user(SOUND_VERSION
, (int *)arg
);
1457 case SNDCTL_DSP_SYNC
:
1458 if (file
->f_mode
& FMODE_WRITE
)
1459 return drain_dac(s
, 0/*file->f_flags & O_NONBLOCK*/);
1462 case SNDCTL_DSP_SETDUPLEX
:
1465 case SNDCTL_DSP_GETCAPS
:
1466 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
| DSP_CAP_MMAP
, (int *)arg
);
1468 case SNDCTL_DSP_RESET
:
1469 if (file
->f_mode
& FMODE_WRITE
) {
1472 s
->dma_dac
.swptr
= s
->dma_dac
.hwptr
= s
->dma_dac
.count
= s
->dma_dac
.total_bytes
= 0;
1474 if (file
->f_mode
& FMODE_READ
) {
1477 s
->dma_adc
.swptr
= s
->dma_adc
.hwptr
= s
->dma_adc
.count
= s
->dma_adc
.total_bytes
= 0;
1481 case SNDCTL_DSP_SPEED
:
1482 if (get_user(val
, (int *)arg
))
1485 if (file
->f_mode
& FMODE_READ
) {
1487 s
->dma_adc
.ready
= 0;
1488 set_adc_rate(s
, val
);
1490 if (file
->f_mode
& FMODE_WRITE
) {
1492 s
->dma_dac
.ready
= 0;
1493 set_dac_rate(s
, val
);
1496 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1498 case SNDCTL_DSP_STEREO
:
1499 if (get_user(val
, (int *)arg
))
1503 if (file
->f_mode
& FMODE_READ
) {
1505 s
->dma_adc
.ready
= 0;
1507 fmtd
|= CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
;
1509 fmtm
&= ~(CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
);
1511 if (file
->f_mode
& FMODE_WRITE
) {
1513 s
->dma_dac
.ready
= 0;
1515 fmtd
|= CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
;
1517 fmtm
&= ~(CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
);
1519 set_fmt(s
, fmtm
, fmtd
);
1522 case SNDCTL_DSP_CHANNELS
:
1523 if (get_user(val
, (int *)arg
))
1528 if (file
->f_mode
& FMODE_READ
) {
1530 s
->dma_adc
.ready
= 0;
1532 fmtd
|= CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
;
1534 fmtm
&= ~(CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
);
1536 if (file
->f_mode
& FMODE_WRITE
) {
1538 s
->dma_dac
.ready
= 0;
1540 fmtd
|= CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
;
1542 fmtm
&= ~(CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
);
1544 set_fmt(s
, fmtm
, fmtd
);
1546 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
)
1547 : (CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
))) ? 2 : 1, (int *)arg
);
1549 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
1550 return put_user(AFMT_S16_LE
|AFMT_U8
, (int *)arg
);
1552 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
1553 if (get_user(val
, (int *)arg
))
1555 if (val
!= AFMT_QUERY
) {
1558 if (file
->f_mode
& FMODE_READ
) {
1560 s
->dma_adc
.ready
= 0;
1561 if (val
== AFMT_S16_LE
)
1562 fmtd
|= CM_CFMT_16BIT
<< CM_CFMT_ADCSHIFT
;
1564 fmtm
&= ~(CM_CFMT_16BIT
<< CM_CFMT_ADCSHIFT
);
1566 if (file
->f_mode
& FMODE_WRITE
) {
1568 s
->dma_dac
.ready
= 0;
1569 if (val
== AFMT_S16_LE
)
1570 fmtd
|= CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
;
1572 fmtm
&= ~(CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
);
1574 set_fmt(s
, fmtm
, fmtd
);
1576 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (CM_CFMT_16BIT
<< CM_CFMT_ADCSHIFT
)
1577 : (CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
))) ? AFMT_S16_LE
: AFMT_U8
, (int *)arg
);
1579 case SNDCTL_DSP_POST
:
1582 case SNDCTL_DSP_GETTRIGGER
:
1584 if (file
->f_mode
& FMODE_READ
&& s
->enable
& CM_CENABLE_RE
)
1585 val
|= PCM_ENABLE_INPUT
;
1586 if (file
->f_mode
& FMODE_WRITE
&& s
->enable
& CM_CENABLE_PE
)
1587 val
|= PCM_ENABLE_OUTPUT
;
1588 return put_user(val
, (int *)arg
);
1590 case SNDCTL_DSP_SETTRIGGER
:
1591 if (get_user(val
, (int *)arg
))
1593 if (file
->f_mode
& FMODE_READ
) {
1594 if (val
& PCM_ENABLE_INPUT
) {
1595 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1601 if (file
->f_mode
& FMODE_WRITE
) {
1602 if (val
& PCM_ENABLE_OUTPUT
) {
1603 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1611 case SNDCTL_DSP_GETOSPACE
:
1612 if (!(file
->f_mode
& FMODE_WRITE
))
1614 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1616 spin_lock_irqsave(&s
->lock
, flags
);
1618 abinfo
.fragsize
= s
->dma_dac
.fragsize
;
1619 abinfo
.bytes
= s
->dma_dac
.dmasize
- s
->dma_dac
.count
;
1620 abinfo
.fragstotal
= s
->dma_dac
.numfrag
;
1621 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_dac
.fragshift
;
1622 spin_unlock_irqrestore(&s
->lock
, flags
);
1623 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1625 case SNDCTL_DSP_GETISPACE
:
1626 if (!(file
->f_mode
& FMODE_READ
))
1628 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1630 spin_lock_irqsave(&s
->lock
, flags
);
1632 abinfo
.fragsize
= s
->dma_adc
.fragsize
;
1633 abinfo
.bytes
= s
->dma_adc
.count
;
1634 abinfo
.fragstotal
= s
->dma_adc
.numfrag
;
1635 abinfo
.fragments
= abinfo
.bytes
>> s
->dma_adc
.fragshift
;
1636 spin_unlock_irqrestore(&s
->lock
, flags
);
1637 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1639 case SNDCTL_DSP_NONBLOCK
:
1640 file
->f_flags
|= O_NONBLOCK
;
1643 case SNDCTL_DSP_GETODELAY
:
1644 if (!(file
->f_mode
& FMODE_WRITE
))
1646 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1648 spin_lock_irqsave(&s
->lock
, flags
);
1650 val
= s
->dma_dac
.count
;
1651 spin_unlock_irqrestore(&s
->lock
, flags
);
1652 return put_user(val
, (int *)arg
);
1654 case SNDCTL_DSP_GETIPTR
:
1655 if (!(file
->f_mode
& FMODE_READ
))
1657 if (!s
->dma_adc
.ready
&& (ret
= prog_dmabuf(s
, 1)))
1659 spin_lock_irqsave(&s
->lock
, flags
);
1661 cinfo
.bytes
= s
->dma_adc
.total_bytes
;
1662 cinfo
.blocks
= s
->dma_adc
.count
>> s
->dma_adc
.fragshift
;
1663 cinfo
.ptr
= s
->dma_adc
.hwptr
;
1664 if (s
->dma_adc
.mapped
)
1665 s
->dma_adc
.count
&= s
->dma_adc
.fragsize
-1;
1666 spin_unlock_irqrestore(&s
->lock
, flags
);
1667 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1669 case SNDCTL_DSP_GETOPTR
:
1670 if (!(file
->f_mode
& FMODE_WRITE
))
1672 if (!s
->dma_dac
.ready
&& (ret
= prog_dmabuf(s
, 0)))
1674 spin_lock_irqsave(&s
->lock
, flags
);
1676 cinfo
.bytes
= s
->dma_dac
.total_bytes
;
1677 cinfo
.blocks
= s
->dma_dac
.count
>> s
->dma_dac
.fragshift
;
1678 cinfo
.ptr
= s
->dma_dac
.hwptr
;
1679 if (s
->dma_dac
.mapped
)
1680 s
->dma_dac
.count
&= s
->dma_dac
.fragsize
-1;
1681 spin_unlock_irqrestore(&s
->lock
, flags
);
1682 return copy_to_user((void *)arg
, &cinfo
, sizeof(cinfo
));
1684 case SNDCTL_DSP_GETBLKSIZE
:
1685 if (file
->f_mode
& FMODE_WRITE
) {
1686 if ((val
= prog_dmabuf(s
, 0)))
1688 return put_user(s
->dma_dac
.fragsize
, (int *)arg
);
1690 if ((val
= prog_dmabuf(s
, 1)))
1692 return put_user(s
->dma_adc
.fragsize
, (int *)arg
);
1694 case SNDCTL_DSP_SETFRAGMENT
:
1695 if (get_user(val
, (int *)arg
))
1697 if (file
->f_mode
& FMODE_READ
) {
1698 s
->dma_adc
.ossfragshift
= val
& 0xffff;
1699 s
->dma_adc
.ossmaxfrags
= (val
>> 16) & 0xffff;
1700 if (s
->dma_adc
.ossfragshift
< 4)
1701 s
->dma_adc
.ossfragshift
= 4;
1702 if (s
->dma_adc
.ossfragshift
> 15)
1703 s
->dma_adc
.ossfragshift
= 15;
1704 if (s
->dma_adc
.ossmaxfrags
< 4)
1705 s
->dma_adc
.ossmaxfrags
= 4;
1707 if (file
->f_mode
& FMODE_WRITE
) {
1708 s
->dma_dac
.ossfragshift
= val
& 0xffff;
1709 s
->dma_dac
.ossmaxfrags
= (val
>> 16) & 0xffff;
1710 if (s
->dma_dac
.ossfragshift
< 4)
1711 s
->dma_dac
.ossfragshift
= 4;
1712 if (s
->dma_dac
.ossfragshift
> 15)
1713 s
->dma_dac
.ossfragshift
= 15;
1714 if (s
->dma_dac
.ossmaxfrags
< 4)
1715 s
->dma_dac
.ossmaxfrags
= 4;
1719 case SNDCTL_DSP_SUBDIVIDE
:
1720 if ((file
->f_mode
& FMODE_READ
&& s
->dma_adc
.subdivision
) ||
1721 (file
->f_mode
& FMODE_WRITE
&& s
->dma_dac
.subdivision
))
1723 if (get_user(val
, (int *)arg
))
1725 if (val
!= 1 && val
!= 2 && val
!= 4)
1727 if (file
->f_mode
& FMODE_READ
)
1728 s
->dma_adc
.subdivision
= val
;
1729 if (file
->f_mode
& FMODE_WRITE
)
1730 s
->dma_dac
.subdivision
= val
;
1733 case SOUND_PCM_READ_RATE
:
1734 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1736 case SOUND_PCM_READ_CHANNELS
:
1737 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (CM_CFMT_STEREO
<< CM_CFMT_ADCSHIFT
) : (CM_CFMT_STEREO
<< CM_CFMT_DACSHIFT
))) ? 2 : 1, (int *)arg
);
1739 case SOUND_PCM_READ_BITS
:
1740 return put_user((s
->fmt
& ((file
->f_mode
& FMODE_READ
) ? (CM_CFMT_16BIT
<< CM_CFMT_ADCSHIFT
) : (CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
))) ? 16 : 8, (int *)arg
);
1742 case SOUND_PCM_READ_FILTER
:
1743 return put_user((file
->f_mode
& FMODE_READ
) ? s
->rateadc
: s
->ratedac
, (int *)arg
);
1745 case SOUND_PCM_WRITE_FILTER
:
1746 case SNDCTL_DSP_SETSYNCRO
:
1750 return mixer_ioctl(s
, cmd
, arg
);
1753 static int cm_open(struct inode
*inode
, struct file
*file
)
1755 int minor
= MINOR(inode
->i_rdev
);
1756 struct cm_state
*s
= devs
;
1757 unsigned char fmtm
= ~0, fmts
= 0;
1759 while (s
&& ((s
->dev_audio
^ minor
) & ~0xf))
1764 file
->private_data
= s
;
1765 /* wait for device to become free */
1767 while (s
->open_mode
& file
->f_mode
) {
1768 if (file
->f_flags
& O_NONBLOCK
) {
1773 interruptible_sleep_on(&s
->open_wait
);
1774 if (signal_pending(current
))
1775 return -ERESTARTSYS
;
1778 if (file
->f_mode
& FMODE_READ
) {
1779 fmtm
&= ~((CM_CFMT_STEREO
| CM_CFMT_16BIT
) << CM_CFMT_ADCSHIFT
);
1780 if ((minor
& 0xf) == SND_DEV_DSP16
)
1781 fmts
|= CM_CFMT_16BIT
<< CM_CFMT_ADCSHIFT
;
1782 s
->dma_adc
.ossfragshift
= s
->dma_adc
.ossmaxfrags
= s
->dma_adc
.subdivision
= 0;
1783 set_adc_rate(s
, 8000);
1785 if (file
->f_mode
& FMODE_WRITE
) {
1786 fmtm
&= ~((CM_CFMT_STEREO
| CM_CFMT_16BIT
) << CM_CFMT_DACSHIFT
);
1787 if ((minor
& 0xf) == SND_DEV_DSP16
)
1788 fmts
|= CM_CFMT_16BIT
<< CM_CFMT_DACSHIFT
;
1789 s
->dma_dac
.ossfragshift
= s
->dma_dac
.ossmaxfrags
= s
->dma_dac
.subdivision
= 0;
1790 set_dac_rate(s
, 8000);
1792 set_fmt(s
, fmtm
, fmts
);
1793 s
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
1798 static int cm_release(struct inode
*inode
, struct file
*file
)
1800 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1804 if (file
->f_mode
& FMODE_WRITE
)
1805 drain_dac(s
, file
->f_flags
& O_NONBLOCK
);
1807 if (file
->f_mode
& FMODE_WRITE
) {
1809 dealloc_dmabuf(&s
->dma_dac
);
1811 if (file
->f_mode
& FMODE_READ
) {
1813 dealloc_dmabuf(&s
->dma_adc
);
1815 s
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
1817 wake_up(&s
->open_wait
);
1822 static /*const*/ struct file_operations cm_audio_fops
= {
1831 release
: cm_release
,
1834 /* --------------------------------------------------------------------- */
1836 static ssize_t
cm_midi_read(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
1838 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1839 DECLARE_WAITQUEUE(wait
, current
);
1841 unsigned long flags
;
1846 if (ppos
!= &file
->f_pos
)
1848 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
1853 add_wait_queue(&s
->midi
.iwait
, &wait
);
1855 set_current_state(TASK_INTERRUPTIBLE
);
1856 spin_lock_irqsave(&s
->lock
, flags
);
1858 cnt
= MIDIINBUF
- ptr
;
1859 if (s
->midi
.icnt
< cnt
)
1861 spin_unlock_irqrestore(&s
->lock
, flags
);
1865 if (file
->f_flags
& O_NONBLOCK
)
1872 if (signal_pending(current
))
1880 if (copy_to_user(buffer
, s
->midi
.ibuf
+ ptr
, cnt
)) {
1885 ptr
= (ptr
+ cnt
) % MIDIINBUF
;
1886 spin_lock_irqsave(&s
->lock
, flags
);
1888 s
->midi
.icnt
-= cnt
;
1889 spin_unlock_irqrestore(&s
->lock
, flags
);
1895 __set_current_state(TASK_RUNNING
);
1896 remove_wait_queue(&s
->midi
.iwait
, &wait
);
1900 static ssize_t
cm_midi_write(struct file
*file
, const char *buffer
, size_t count
, loff_t
*ppos
)
1902 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1903 DECLARE_WAITQUEUE(wait
, current
);
1905 unsigned long flags
;
1910 if (ppos
!= &file
->f_pos
)
1912 if (!access_ok(VERIFY_READ
, buffer
, count
))
1917 add_wait_queue(&s
->midi
.owait
, &wait
);
1919 set_current_state(TASK_INTERRUPTIBLE
);
1920 spin_lock_irqsave(&s
->lock
, flags
);
1922 cnt
= MIDIOUTBUF
- ptr
;
1923 if (s
->midi
.ocnt
+ cnt
> MIDIOUTBUF
)
1924 cnt
= MIDIOUTBUF
- s
->midi
.ocnt
;
1927 spin_unlock_irqrestore(&s
->lock
, flags
);
1931 if (file
->f_flags
& O_NONBLOCK
) {
1937 if (signal_pending(current
)) {
1944 if (copy_from_user(s
->midi
.obuf
+ ptr
, buffer
, cnt
)) {
1949 ptr
= (ptr
+ cnt
) % MIDIOUTBUF
;
1950 spin_lock_irqsave(&s
->lock
, flags
);
1952 s
->midi
.ocnt
+= cnt
;
1953 spin_unlock_irqrestore(&s
->lock
, flags
);
1957 spin_lock_irqsave(&s
->lock
, flags
);
1959 spin_unlock_irqrestore(&s
->lock
, flags
);
1961 __set_current_state(TASK_RUNNING
);
1962 remove_wait_queue(&s
->midi
.owait
, &wait
);
1966 static unsigned int cm_midi_poll(struct file
*file
, struct poll_table_struct
*wait
)
1968 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
1969 unsigned long flags
;
1970 unsigned int mask
= 0;
1973 if (file
->f_mode
& FMODE_WRITE
)
1974 poll_wait(file
, &s
->midi
.owait
, wait
);
1975 if (file
->f_mode
& FMODE_READ
)
1976 poll_wait(file
, &s
->midi
.iwait
, wait
);
1977 spin_lock_irqsave(&s
->lock
, flags
);
1978 if (file
->f_mode
& FMODE_READ
) {
1979 if (s
->midi
.icnt
> 0)
1980 mask
|= POLLIN
| POLLRDNORM
;
1982 if (file
->f_mode
& FMODE_WRITE
) {
1983 if (s
->midi
.ocnt
< MIDIOUTBUF
)
1984 mask
|= POLLOUT
| POLLWRNORM
;
1986 spin_unlock_irqrestore(&s
->lock
, flags
);
1990 static int cm_midi_open(struct inode
*inode
, struct file
*file
)
1992 int minor
= MINOR(inode
->i_rdev
);
1993 struct cm_state
*s
= devs
;
1994 unsigned long flags
;
1996 while (s
&& s
->dev_midi
!= minor
)
2001 file
->private_data
= s
;
2002 /* wait for device to become free */
2004 while (s
->open_mode
& (file
->f_mode
<< FMODE_MIDI_SHIFT
)) {
2005 if (file
->f_flags
& O_NONBLOCK
) {
2010 interruptible_sleep_on(&s
->open_wait
);
2011 if (signal_pending(current
))
2012 return -ERESTARTSYS
;
2015 spin_lock_irqsave(&s
->lock
, flags
);
2016 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2017 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2018 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2019 /* enable MPU-401 */
2020 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
) | 4, s
->iobase
+ CODEC_CMI_FUNCTRL1
);
2021 outb(0xff, s
->iomidi
+1); /* reset command */
2022 if (!(inb(s
->iomidi
+1) & 0x80))
2024 outb(0x3f, s
->iomidi
+1); /* uart command */
2025 if (!(inb(s
->iomidi
+1) & 0x80))
2027 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2028 init_timer(&s
->midi
.timer
);
2029 s
->midi
.timer
.expires
= jiffies
+1;
2030 s
->midi
.timer
.data
= (unsigned long)s
;
2031 s
->midi
.timer
.function
= cm_midi_timer
;
2032 add_timer(&s
->midi
.timer
);
2034 if (file
->f_mode
& FMODE_READ
) {
2035 s
->midi
.ird
= s
->midi
.iwr
= s
->midi
.icnt
= 0;
2037 if (file
->f_mode
& FMODE_WRITE
) {
2038 s
->midi
.ord
= s
->midi
.owr
= s
->midi
.ocnt
= 0;
2040 spin_unlock_irqrestore(&s
->lock
, flags
);
2041 s
->open_mode
|= (file
->f_mode
<< FMODE_MIDI_SHIFT
) & (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
);
2046 static int cm_midi_release(struct inode
*inode
, struct file
*file
)
2048 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
2049 DECLARE_WAITQUEUE(wait
, current
);
2050 unsigned long flags
;
2051 unsigned count
, tmo
;
2056 if (file
->f_mode
& FMODE_WRITE
) {
2057 add_wait_queue(&s
->midi
.owait
, &wait
);
2059 set_current_state(TASK_INTERRUPTIBLE
);
2060 spin_lock_irqsave(&s
->lock
, flags
);
2061 count
= s
->midi
.ocnt
;
2062 spin_unlock_irqrestore(&s
->lock
, flags
);
2065 if (signal_pending(current
))
2067 if (file
->f_flags
& O_NONBLOCK
) {
2068 remove_wait_queue(&s
->midi
.owait
, &wait
);
2069 set_current_state(TASK_RUNNING
);
2072 tmo
= (count
* HZ
) / 3100;
2073 if (!schedule_timeout(tmo
? : 1) && tmo
)
2074 printk(KERN_DEBUG
"cmpci: midi timed out??\n");
2076 remove_wait_queue(&s
->midi
.owait
, &wait
);
2077 set_current_state(TASK_RUNNING
);
2080 s
->open_mode
&= (~(file
->f_mode
<< FMODE_MIDI_SHIFT
)) & (FMODE_MIDI_READ
|FMODE_MIDI_WRITE
);
2081 spin_lock_irqsave(&s
->lock
, flags
);
2082 if (!(s
->open_mode
& (FMODE_MIDI_READ
| FMODE_MIDI_WRITE
))) {
2083 del_timer(&s
->midi
.timer
);
2084 outb(0xff, s
->iomidi
+1); /* reset command */
2085 if (!(inb(s
->iomidi
+1) & 0x80))
2087 /* disable MPU-401 */
2088 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
) & ~4, s
->iobase
+ CODEC_CMI_FUNCTRL1
);
2090 spin_unlock_irqrestore(&s
->lock
, flags
);
2092 wake_up(&s
->open_wait
);
2097 static /*const*/ struct file_operations cm_midi_fops
= {
2101 write
: cm_midi_write
,
2104 release
: cm_midi_release
,
2107 /* --------------------------------------------------------------------- */
2109 static int cm_dmfm_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
2111 static const unsigned char op_offset
[18] = {
2112 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2113 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
2114 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
2116 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
2117 struct dm_fm_voice v
;
2118 struct dm_fm_note n
;
2119 struct dm_fm_params p
;
2124 case FM_IOCTL_RESET
:
2125 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2126 outb(regb
, s
->iosynth
);
2127 outb(0, s
->iosynth
+1);
2128 outb(regb
, s
->iosynth
+2);
2129 outb(0, s
->iosynth
+3);
2133 case FM_IOCTL_PLAY_NOTE
:
2134 if (copy_from_user(&n
, (void *)arg
, sizeof(n
)))
2145 outb(0xa0 + regb
, io
);
2146 outb(n
.fnum
& 0xff, io
+1);
2147 outb(0xb0 + regb
, io
);
2148 outb(((n
.fnum
>> 8) & 3) | ((n
.octave
& 7) << 2) | ((n
.key_on
& 1) << 5), io
+1);
2151 case FM_IOCTL_SET_VOICE
:
2152 if (copy_from_user(&v
, (void *)arg
, sizeof(v
)))
2156 regb
= op_offset
[v
.voice
];
2157 io
= s
->iosynth
+ ((v
.op
& 1) << 1);
2158 outb(0x20 + regb
, io
);
2159 outb(((v
.am
& 1) << 7) | ((v
.vibrato
& 1) << 6) | ((v
.do_sustain
& 1) << 5) |
2160 ((v
.kbd_scale
& 1) << 4) | (v
.harmonic
& 0xf), io
+1);
2161 outb(0x40 + regb
, io
);
2162 outb(((v
.scale_level
& 0x3) << 6) | (v
.volume
& 0x3f), io
+1);
2163 outb(0x60 + regb
, io
);
2164 outb(((v
.attack
& 0xf) << 4) | (v
.decay
& 0xf), io
+1);
2165 outb(0x80 + regb
, io
);
2166 outb(((v
.sustain
& 0xf) << 4) | (v
.release
& 0xf), io
+1);
2167 outb(0xe0 + regb
, io
);
2168 outb(v
.waveform
& 0x7, io
+1);
2176 outb(0xc0 + regb
, io
);
2177 outb(((v
.right
& 1) << 5) | ((v
.left
& 1) << 4) | ((v
.feedback
& 7) << 1) |
2178 (v
.connection
& 1), io
+1);
2181 case FM_IOCTL_SET_PARAMS
:
2182 if (copy_from_user(&p
, (void *)arg
, sizeof(p
)))
2184 outb(0x08, s
->iosynth
);
2185 outb((p
.kbd_split
& 1) << 6, s
->iosynth
+1);
2186 outb(0xbd, s
->iosynth
);
2187 outb(((p
.am_depth
& 1) << 7) | ((p
.vib_depth
& 1) << 6) | ((p
.rhythm
& 1) << 5) | ((p
.bass
& 1) << 4) |
2188 ((p
.snare
& 1) << 3) | ((p
.tomtom
& 1) << 2) | ((p
.cymbal
& 1) << 1) | (p
.hihat
& 1), s
->iosynth
+1);
2191 case FM_IOCTL_SET_OPL
:
2192 outb(4, s
->iosynth
+2);
2193 outb(arg
, s
->iosynth
+3);
2196 case FM_IOCTL_SET_MODE
:
2197 outb(5, s
->iosynth
+2);
2198 outb(arg
& 1, s
->iosynth
+3);
2206 static int cm_dmfm_open(struct inode
*inode
, struct file
*file
)
2208 int minor
= MINOR(inode
->i_rdev
);
2209 struct cm_state
*s
= devs
;
2211 while (s
&& s
->dev_dmfm
!= minor
)
2216 file
->private_data
= s
;
2217 /* wait for device to become free */
2219 while (s
->open_mode
& FMODE_DMFM
) {
2220 if (file
->f_flags
& O_NONBLOCK
) {
2225 interruptible_sleep_on(&s
->open_wait
);
2226 if (signal_pending(current
))
2227 return -ERESTARTSYS
;
2230 /* init the stuff */
2231 outb(1, s
->iosynth
);
2232 outb(0x20, s
->iosynth
+1); /* enable waveforms */
2233 outb(4, s
->iosynth
+2);
2234 outb(0, s
->iosynth
+3); /* no 4op enabled */
2235 outb(5, s
->iosynth
+2);
2236 outb(1, s
->iosynth
+3); /* enable OPL3 */
2237 s
->open_mode
|= FMODE_DMFM
;
2242 static int cm_dmfm_release(struct inode
*inode
, struct file
*file
)
2244 struct cm_state
*s
= (struct cm_state
*)file
->private_data
;
2250 s
->open_mode
&= ~FMODE_DMFM
;
2251 for (regb
= 0xb0; regb
< 0xb9; regb
++) {
2252 outb(regb
, s
->iosynth
);
2253 outb(0, s
->iosynth
+1);
2254 outb(regb
, s
->iosynth
+2);
2255 outb(0, s
->iosynth
+3);
2258 wake_up(&s
->open_wait
);
2263 static /*const*/ struct file_operations cm_dmfm_fops
= {
2266 ioctl
: cm_dmfm_ioctl
,
2268 release
: cm_dmfm_release
,
2271 /* --------------------------------------------------------------------- */
2273 /* maximum number of devices */
2277 static int reverb
[NR_DEVICE
] = { 0, };
2279 static int wavetable
[NR_DEVICE
] = { 0, };
2282 /* --------------------------------------------------------------------- */
2284 static struct initvol
{
2287 } initvol
[] __initdata
= {
2288 { SOUND_MIXER_WRITE_CD
, 0x4040 },
2289 { SOUND_MIXER_WRITE_LINE
, 0x4040 },
2290 { SOUND_MIXER_WRITE_MIC
, 0x4040 },
2291 { SOUND_MIXER_WRITE_SYNTH
, 0x4040 },
2292 { SOUND_MIXER_WRITE_VOLUME
, 0x4040 },
2293 { SOUND_MIXER_WRITE_PCM
, 0x4040 }
2297 static int spdif_loop
= 0;
2298 static int four_ch
= 0;
2299 static int rear_out
= 0;
2300 MODULE_PARM(spdif_loop
, "i");
2301 MODULE_PARM(four_ch
, "i");
2302 MODULE_PARM(rear_out
, "i");
2304 #ifdef CONFIG_SOUND_CMPCI_SPDIFLOOP
2305 static int spdif_loop
= 1;
2307 static int spdif_loop
= 0;
2309 #ifdef CONFIG_SOUND_CMPCI_4CH
2310 static int four_ch
= 1;
2312 static int four_ch
= 0;
2314 #ifdef CONFIG_SOUND_CMPCI_REAR
2315 static int rear_out
= 1;
2317 static int rear_out
= 0;
2321 static int __init
init_cmpci(void)
2324 struct pci_dev
*pcidev
= NULL
;
2326 int i
, val
, index
= 0;
2329 unsigned short deviceid
;
2333 { PCI_DEVICE_ID_CMEDIA_CM8338A
, "CM8338A" },
2334 { PCI_DEVICE_ID_CMEDIA_CM8338B
, "CM8338B" },
2335 { PCI_DEVICE_ID_CMEDIA_CM8738
, "CM8738" },
2337 char *devicename
= "unknown";
2340 if (!pci_present()) /* No PCI bus in this machine! */
2343 printk(KERN_INFO
"cmpci: version v2.41-nomodem time " __TIME__
" " __DATE__
"\n");
2345 if (!(wavetable_mem
= __get_free_pages(GFP_KERNEL
, 20-PAGE_SHIFT
)))
2346 printk(KERN_INFO
"cmpci: cannot allocate 1MB of contiguous nonpageable memory for wavetable data\n");
2348 while (index
< NR_DEVICE
&& pcidev
== NULL
&& (
2349 (pcidev
= pci_find_device(PCI_VENDOR_ID_CMEDIA
, PCI_DEVICE_ID_CMEDIA_CM8338A
, pcidev
)) ||
2350 (pcidev
= pci_find_device(PCI_VENDOR_ID_CMEDIA
, PCI_DEVICE_ID_CMEDIA_CM8338B
, pcidev
)) ||
2351 (pcidev
= pci_find_device(PCI_VENDOR_ID_CMEDIA
, PCI_DEVICE_ID_CMEDIA_CM8738
, pcidev
)))) {
2352 if (pci_enable_device(pcidev
))
2354 if (pcidev
->irq
== 0)
2356 if (!(s
= kmalloc(sizeof(struct cm_state
), GFP_KERNEL
))) {
2357 printk(KERN_WARNING
"cmpci: out of memory\n");
2360 /* search device name */
2361 for (i
= 0; i
< sizeof(devicetable
) / sizeof(devicetable
[0]); i
++)
2363 if (devicetable
[i
].deviceid
== pcidev
->device
)
2365 devicename
= devicetable
[i
].devicename
;
2369 memset(s
, 0, sizeof(struct cm_state
));
2370 init_waitqueue_head(&s
->dma_adc
.wait
);
2371 init_waitqueue_head(&s
->dma_dac
.wait
);
2372 init_waitqueue_head(&s
->open_wait
);
2373 init_waitqueue_head(&s
->midi
.iwait
);
2374 init_waitqueue_head(&s
->midi
.owait
);
2375 init_MUTEX(&s
->open_sem
);
2376 spin_lock_init(&s
->lock
);
2377 s
->magic
= CM_MAGIC
;
2378 s
->iobase
= pci_resource_start(pcidev
, 0);
2381 spin_lock_init(&s
->lock
);
2384 s
->irq
= pcidev
->irq
;
2386 if (!request_region(s
->iobase
, CM_EXTENT_CODEC
, "cmpci")) {
2387 printk(KERN_ERR
"cmpci: io ports %#x-%#x in use\n", s
->iobase
, s
->iobase
+CM_EXTENT_CODEC
-1);
2390 if (!request_region(s
->iomidi
, CM_EXTENT_MIDI
, "cmpci Midi")) {
2391 printk(KERN_WARNING
"cmpci: io ports %#x-%#x in use, midi disabled.\n", s
->iomidi
, s
->iomidi
+CM_EXTENT_MIDI
-1);
2396 /* set IO based at 0x330 */
2397 outb(inb(s
->iobase
+ CODEC_CMI_LEGACY_CTRL
+ 3) & ~0x60, s
->iobase
+ CODEC_CMI_LEGACY_CTRL
+ 3);
2399 if (!request_region(s
->iosynth
, CM_EXTENT_SYNTH
, "cmpci FM")) {
2400 printk(KERN_WARNING
"cmpci: io ports %#x-%#x in use, synth disabled.\n", s
->iosynth
, s
->iosynth
+CM_EXTENT_SYNTH
-1);
2406 outb(inb(s
->iobase
+ CODEC_CMI_MISC_CTRL
+ 2) | 8, s
->iobase
+ CODEC_CMI_MISC_CTRL
);
2408 /* initialize codec registers */
2409 outb(0, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2); /* disable ints */
2410 outb(0, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2); /* disable channels */
2412 wrmixer(s
, DSP_MIX_DATARESETIDX
, 0);
2415 if (request_irq(s
->irq
, cm_interrupt
, SA_SHIRQ
, "cmpci", s
)) {
2416 printk(KERN_ERR
"cmpci: irq %u in use\n", s
->irq
);
2419 printk(KERN_INFO
"cmpci: found %s adapter at io %#06x irq %u\n",
2420 devicename
, s
->iobase
, s
->irq
);
2421 /* register devices */
2422 if ((s
->dev_audio
= register_sound_dsp(&cm_audio_fops
, -1)) < 0)
2424 if ((s
->dev_mixer
= register_sound_mixer(&cm_mixer_fops
, -1)) < 0)
2426 if (s
->iomidi
&& (s
->dev_midi
= register_sound_midi(&cm_midi_fops
, -1)) < 0)
2428 if (s
->iosynth
&& (s
->dev_dmfm
= register_sound_special(&cm_dmfm_fops
, 15 /* ?? */)) < 0)
2430 pci_set_master(pcidev
);
2431 /* initialize the chips */
2434 /* set mixer output */
2435 frobindir(s
, DSP_MIX_OUTMIXIDX
, 0x1f, 0x1f);
2436 /* set mixer input */
2437 val
= SOUND_MASK_LINE
|SOUND_MASK_SYNTH
|SOUND_MASK_CD
|SOUND_MASK_MIC
;
2438 mixer_ioctl(s
, SOUND_MIXER_WRITE_RECSRC
, (unsigned long)&val
);
2439 for (i
= 0; i
< sizeof(initvol
)/sizeof(initvol
[0]); i
++) {
2440 val
= initvol
[i
].vol
;
2441 mixer_ioctl(s
, initvol
[i
].mixch
, (unsigned long)&val
);
2444 if (pcidev
->device
== PCI_DEVICE_ID_CMEDIA_CM8738
)
2446 /* enable SPDIF loop */
2449 /* turn on spdif-in to spdif-out */
2450 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
) | 0x80, s
->iobase
+ CODEC_CMI_FUNCTRL1
);
2451 printk(KERN_INFO
"cmpci: Enable SPDIF loop\n");
2454 outb(inb(s
->iobase
+ CODEC_CMI_FUNCTRL1
) & ~0x80, s
->iobase
+ CODEC_CMI_FUNCTRL1
);
2455 /* enable 4 channels mode */
2458 /* 4 channel mode (analog duplicate) */
2459 outb(inb(s
->iobase
+ CODEC_CMI_MISC_CTRL
+ 3) | 0x04, s
->iobase
+ CODEC_CMI_MISC_CTRL
+ 3);
2460 printk(KERN_INFO
"cmpci: Enable 4 channels mode\n");
2461 /* has separate rear-out jack ? */
2464 /* has separate rear out jack */
2465 outb(inb(s
->iobase
+ CODEC_CMI_MIXER1
) & ~0x20, s
->iobase
+ CODEC_CMI_MIXER1
);
2469 outb(inb(s
->iobase
+ CODEC_CMI_MIXER1
) | 0x20, s
->iobase
+ CODEC_CMI_MIXER1
);
2470 printk(KERN_INFO
"cmpci: line-in routed as rear-out\n");
2474 outb(inb(s
->iobase
+ CODEC_CMI_MISC_CTRL
+ 3) & ~0x04, s
->iobase
+ CODEC_CMI_MISC_CTRL
+ 3);
2476 /* queue it for later freeing */
2483 unregister_sound_midi(s
->dev_midi
);
2485 unregister_sound_mixer(s
->dev_mixer
);
2487 unregister_sound_dsp(s
->dev_audio
);
2489 printk(KERN_ERR
"cmpci: cannot register misc device\n");
2490 free_irq(s
->irq
, s
);
2493 release_region(s
->iosynth
, CM_EXTENT_SYNTH
);
2495 release_region(s
->iomidi
, CM_EXTENT_MIDI
);
2496 release_region(s
->iobase
, CM_EXTENT_CODEC
);
2502 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2508 /* --------------------------------------------------------------------- */
2510 MODULE_AUTHOR("ChenLi Tien, cltien@home.com");
2511 MODULE_DESCRIPTION("CMPCI Audio Driver");
2513 static void __exit
cleanup_cmpci(void)
2517 while ((s
= devs
)) {
2519 outb(0, s
->iobase
+ CODEC_CMI_INT_HLDCLR
+ 2); /* disable ints */
2521 outb(0, s
->iobase
+ CODEC_CMI_FUNCTRL0
+ 2); /* disable channels */
2522 free_irq(s
->irq
, s
);
2525 wrmixer(s
, DSP_MIX_DATARESETIDX
, 0);
2527 release_region(s
->iobase
, CM_EXTENT_CODEC
);
2530 release_region(s
->iomidi
, CM_EXTENT_MIDI
);
2531 unregister_sound_midi(s
->dev_midi
);
2535 release_region(s
->iosynth
, CM_EXTENT_SYNTH
);
2536 unregister_sound_special(s
->dev_dmfm
);
2538 unregister_sound_dsp(s
->dev_audio
);
2539 unregister_sound_mixer(s
->dev_mixer
);
2543 free_pages(wavetable_mem
, 20-PAGE_SHIFT
);
2544 printk(KERN_INFO
"cmpci: unloading\n");
2547 module_init(init_cmpci
);
2548 module_exit(cleanup_cmpci
);