2 * Copyright 1999 Jaroslav Kysela <perex@suse.cz>
3 * Copyright 2000 Alan Cox <alan@redhat.com>
4 * Copyright 2001 Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
5 * Copyright 2002 Pete Zaitcev <zaitcev@yahoo.com>
7 * Yamaha YMF7xx driver.
9 * This code is a result of high-speed collision
10 * between ymfpci.c of ALSA and cs46xx.c of Linux.
11 * -- Pete Zaitcev <zaitcev@yahoo.com>; 2000/09/18
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 * - Use P44Slot for 44.1 playback (beware of idle buzzing in P44Slot).
29 * - 96KHz playback for DVD - use pitch of 2.0.
30 * - Retain DMA buffer on close, do not wait the end of frame.
31 * - Resolve XXX tagged questions.
32 * - Cannot play 5133Hz.
33 * - 2001/01/07 Consider if we can remove voice_lock, like so:
34 * : Allocate/deallocate voices in open/close under semafore.
35 * : We access voices in interrupt, that only for pcms that open.
36 * voice_lock around playback_prepare closes interrupts for insane duration.
37 * - Revisit the way voice_alloc is done - too confusing, overcomplicated.
38 * Should support various channel types, however.
39 * - Remove prog_dmabuf from read/write, leave it in open.
40 * - 2001/01/07 Replace the OPL3 part of CONFIG_SOUND_YMFPCI_LEGACY code with
41 * native synthesizer through a playback slot.
42 * - 2001/11/29 ac97_save_state
43 * Talk to Kai to remove ac97_save_state before it's too late!
45 * - Restore S/PDIF - Toshibas have it.
47 * Kai used pci_alloc_consistent for DMA buffer, which sounds a little
48 * unconventional. However, given how small our fragments can be,
49 * a little uncached access is perhaps better than endless flushing.
50 * On i386 and other I/O-coherent architectures pci_alloc_consistent
51 * is entirely harmless.
54 #include <linux/module.h>
55 #include <linux/init.h>
56 #include <linux/interrupt.h>
57 #include <linux/ioport.h>
58 #include <linux/delay.h>
59 #include <linux/pci.h>
60 #include <linux/slab.h>
61 #include <linux/poll.h>
62 #include <linux/soundcard.h>
63 #include <linux/ac97_codec.h>
64 #include <linux/sound.h>
68 #include <asm/uaccess.h>
70 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
71 # include "sound_config.h"
77 * I do not believe in debug levels as I never can guess what
78 * part of the code is going to be problematic in the future.
79 * Don't forget to run your klogd with -c 8.
81 * Example (do not remove):
82 * #define YMFDBG(fmt, arg...) do{ printk(KERN_DEBUG fmt, ##arg); }while(0)
84 #define YMFDBGW(fmt, arg...) /* */ /* write counts */
85 #define YMFDBGI(fmt, arg...) /* */ /* interrupts */
86 #define YMFDBGX(fmt, arg...) /* */ /* ioctl */
88 static int ymf_playback_trigger(ymfpci_t
*unit
, struct ymf_pcm
*ypcm
, int cmd
);
89 static void ymf_capture_trigger(ymfpci_t
*unit
, struct ymf_pcm
*ypcm
, int cmd
);
90 static void ymfpci_voice_free(ymfpci_t
*unit
, ymfpci_voice_t
*pvoice
);
91 static int ymf_capture_alloc(struct ymf_unit
*unit
, int *pbank
);
92 static int ymf_playback_prepare(struct ymf_state
*state
);
93 static int ymf_capture_prepare(struct ymf_state
*state
);
94 static struct ymf_state
*ymf_state_alloc(ymfpci_t
*unit
);
96 static void ymfpci_aclink_reset(struct pci_dev
* pci
);
97 static void ymfpci_disable_dsp(ymfpci_t
*unit
);
98 static void ymfpci_download_image(ymfpci_t
*codec
);
99 static void ymf_memload(ymfpci_t
*unit
);
101 static DEFINE_SPINLOCK(ymf_devs_lock
);
102 static LIST_HEAD(ymf_devs
);
108 static struct pci_device_id ymf_id_tbl
[] = {
109 #define DEV(dev, data) \
110 { PCI_VENDOR_ID_YAMAHA, dev, PCI_ANY_ID, PCI_ANY_ID, 0, 0, \
111 (unsigned long)data }
112 DEV (PCI_DEVICE_ID_YAMAHA_724
, "YMF724"),
113 DEV (PCI_DEVICE_ID_YAMAHA_724F
, "YMF724F"),
114 DEV (PCI_DEVICE_ID_YAMAHA_740
, "YMF740"),
115 DEV (PCI_DEVICE_ID_YAMAHA_740C
, "YMF740C"),
116 DEV (PCI_DEVICE_ID_YAMAHA_744
, "YMF744"),
117 DEV (PCI_DEVICE_ID_YAMAHA_754
, "YMF754"),
121 MODULE_DEVICE_TABLE(pci
, ymf_id_tbl
);
124 * common I/O routines
127 static inline void ymfpci_writeb(ymfpci_t
*codec
, u32 offset
, u8 val
)
129 writeb(val
, codec
->reg_area_virt
+ offset
);
132 static inline u16
ymfpci_readw(ymfpci_t
*codec
, u32 offset
)
134 return readw(codec
->reg_area_virt
+ offset
);
137 static inline void ymfpci_writew(ymfpci_t
*codec
, u32 offset
, u16 val
)
139 writew(val
, codec
->reg_area_virt
+ offset
);
142 static inline u32
ymfpci_readl(ymfpci_t
*codec
, u32 offset
)
144 return readl(codec
->reg_area_virt
+ offset
);
147 static inline void ymfpci_writel(ymfpci_t
*codec
, u32 offset
, u32 val
)
149 writel(val
, codec
->reg_area_virt
+ offset
);
152 static int ymfpci_codec_ready(ymfpci_t
*codec
, int secondary
, int sched
)
154 signed long end_time
;
155 u32 reg
= secondary
? YDSXGR_SECSTATUSADR
: YDSXGR_PRISTATUSADR
;
157 end_time
= jiffies
+ 3 * (HZ
/ 4);
159 if ((ymfpci_readw(codec
, reg
) & 0x8000) == 0)
162 set_current_state(TASK_UNINTERRUPTIBLE
);
165 } while (end_time
- (signed long)jiffies
>= 0);
166 printk(KERN_ERR
"ymfpci_codec_ready: codec %i is not ready [0x%x]\n",
167 secondary
, ymfpci_readw(codec
, reg
));
171 static void ymfpci_codec_write(struct ac97_codec
*dev
, u8 reg
, u16 val
)
173 ymfpci_t
*codec
= dev
->private_data
;
176 spin_lock(&codec
->ac97_lock
);
177 /* XXX Do make use of dev->id */
178 ymfpci_codec_ready(codec
, 0, 0);
179 cmd
= ((YDSXG_AC97WRITECMD
| reg
) << 16) | val
;
180 ymfpci_writel(codec
, YDSXGR_AC97CMDDATA
, cmd
);
181 spin_unlock(&codec
->ac97_lock
);
184 static u16
_ymfpci_codec_read(ymfpci_t
*unit
, u8 reg
)
188 if (ymfpci_codec_ready(unit
, 0, 0))
190 ymfpci_writew(unit
, YDSXGR_AC97CMDADR
, YDSXG_AC97READCMD
| reg
);
191 if (ymfpci_codec_ready(unit
, 0, 0))
193 if (unit
->pci
->device
== PCI_DEVICE_ID_YAMAHA_744
&& unit
->rev
< 2) {
194 for (i
= 0; i
< 600; i
++)
195 ymfpci_readw(unit
, YDSXGR_PRISTATUSDATA
);
197 return ymfpci_readw(unit
, YDSXGR_PRISTATUSDATA
);
200 static u16
ymfpci_codec_read(struct ac97_codec
*dev
, u8 reg
)
202 ymfpci_t
*unit
= dev
->private_data
;
205 spin_lock(&unit
->ac97_lock
);
206 ret
= _ymfpci_codec_read(unit
, reg
);
207 spin_unlock(&unit
->ac97_lock
);
217 * Calculate the actual sampling rate relatetively to the base clock (48kHz).
219 static u32
ymfpci_calc_delta(u32 rate
)
222 case 8000: return 0x02aaab00;
223 case 11025: return 0x03accd00;
224 case 16000: return 0x05555500;
225 case 22050: return 0x07599a00;
226 case 32000: return 0x0aaaab00;
227 case 44100: return 0x0eb33300;
228 default: return ((rate
<< 16) / 48000) << 12;
232 static u32 def_rate
[8] = {
233 100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
236 static u32
ymfpci_calc_lpfK(u32 rate
)
239 static u32 val
[8] = {
240 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
241 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
245 return 0x40000000; /* FIXME: What's the right value? */
246 for (i
= 0; i
< 8; i
++)
247 if (rate
<= def_rate
[i
])
252 static u32
ymfpci_calc_lpfQ(u32 rate
)
255 static u32 val
[8] = {
256 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
257 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
262 for (i
= 0; i
< 8; i
++)
263 if (rate
<= def_rate
[i
])
268 static u32
ymf_calc_lend(u32 rate
)
270 return (rate
* YMF_SAMPF
) / 48000;
274 * We ever allow only a few formats, but let's be generic, for smaller surprise.
276 static int ymf_pcm_format_width(int format
)
278 static int mask16
= AFMT_S16_LE
|AFMT_S16_BE
|AFMT_U16_LE
|AFMT_U16_BE
;
280 if ((format
& (format
-1)) != 0) {
281 printk(KERN_ERR
"ymfpci: format 0x%x is not a power of 2\n", format
);
285 if (format
== AFMT_IMA_ADPCM
) return 4;
286 if ((format
& mask16
) != 0) return 16;
290 static void ymf_pcm_update_shift(struct ymf_pcm_format
*f
)
295 if (ymf_pcm_format_width(f
->format
) == 16)
299 /* Are you sure 32K is not too much? See if mpg123 skips on loaded systems. */
300 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
301 #define DMABUF_MINORDER 1
304 * Allocate DMA buffer
306 static int alloc_dmabuf(ymfpci_t
*unit
, struct ymf_dmabuf
*dmabuf
)
311 struct page
*map
, *mapend
;
313 /* alloc as big a chunk as we can */
314 for (order
= DMABUF_DEFAULTORDER
; order
>= DMABUF_MINORDER
; order
--) {
315 rawbuf
= pci_alloc_consistent(unit
->pci
, PAGE_SIZE
<< order
, &dma_addr
);
323 printk(KERN_DEBUG
"ymfpci: allocated %ld (order = %d) bytes at %p\n",
324 PAGE_SIZE
<< order
, order
, rawbuf
);
327 dmabuf
->ready
= dmabuf
->mapped
= 0;
328 dmabuf
->rawbuf
= rawbuf
;
329 dmabuf
->dma_addr
= dma_addr
;
330 dmabuf
->buforder
= order
;
332 /* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
333 mapend
= virt_to_page(rawbuf
+ (PAGE_SIZE
<< order
) - 1);
334 for (map
= virt_to_page(rawbuf
); map
<= mapend
; map
++)
335 set_bit(PG_reserved
, &map
->flags
);
343 static void dealloc_dmabuf(ymfpci_t
*unit
, struct ymf_dmabuf
*dmabuf
)
345 struct page
*map
, *mapend
;
347 if (dmabuf
->rawbuf
) {
348 /* undo marking the pages as reserved */
349 mapend
= virt_to_page(dmabuf
->rawbuf
+ (PAGE_SIZE
<< dmabuf
->buforder
) - 1);
350 for (map
= virt_to_page(dmabuf
->rawbuf
); map
<= mapend
; map
++)
351 clear_bit(PG_reserved
, &map
->flags
);
353 pci_free_consistent(unit
->pci
, PAGE_SIZE
<< dmabuf
->buforder
,
354 dmabuf
->rawbuf
, dmabuf
->dma_addr
);
356 dmabuf
->rawbuf
= NULL
;
357 dmabuf
->mapped
= dmabuf
->ready
= 0;
360 static int prog_dmabuf(struct ymf_state
*state
, int rec
)
362 struct ymf_dmabuf
*dmabuf
;
366 int redzone
, redfrags
;
369 w_16
= ymf_pcm_format_width(state
->format
.format
) == 16;
370 dmabuf
= rec
? &state
->rpcm
.dmabuf
: &state
->wpcm
.dmabuf
;
372 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
373 dmabuf
->hwptr
= dmabuf
->swptr
= 0;
374 dmabuf
->total_bytes
= 0;
376 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
378 /* allocate DMA buffer if not allocated yet */
380 if ((ret
= alloc_dmabuf(state
->unit
, dmabuf
)))
384 * Create fake fragment sizes and numbers for OSS ioctls.
385 * Import what Doom might have set with SNDCTL_DSP_SETFRAGMENT.
387 bufsize
= PAGE_SIZE
<< dmabuf
->buforder
;
388 /* By default we give 4 big buffers. */
389 dmabuf
->fragshift
= (dmabuf
->buforder
+ PAGE_SHIFT
- 2);
390 if (dmabuf
->ossfragshift
> 3 &&
391 dmabuf
->ossfragshift
< dmabuf
->fragshift
) {
392 /* If OSS set smaller fragments, give more smaller buffers. */
393 dmabuf
->fragshift
= dmabuf
->ossfragshift
;
395 dmabuf
->fragsize
= 1 << dmabuf
->fragshift
;
397 dmabuf
->numfrag
= bufsize
>> dmabuf
->fragshift
;
398 dmabuf
->dmasize
= dmabuf
->numfrag
<< dmabuf
->fragshift
;
400 if (dmabuf
->ossmaxfrags
>= 2) {
401 redzone
= ymf_calc_lend(state
->format
.rate
);
402 redzone
<<= state
->format
.shift
;
404 redfrags
= (redzone
+ dmabuf
->fragsize
-1) >> dmabuf
->fragshift
;
406 if (dmabuf
->ossmaxfrags
+ redfrags
< dmabuf
->numfrag
) {
407 dmabuf
->numfrag
= dmabuf
->ossmaxfrags
+ redfrags
;
408 dmabuf
->dmasize
= dmabuf
->numfrag
<< dmabuf
->fragshift
;
412 memset(dmabuf
->rawbuf
, w_16
? 0 : 0x80, dmabuf
->dmasize
);
415 * Now set up the ring
418 /* XXX ret = rec? cap_pre(): pbk_pre(); */
419 spin_lock_irqsave(&state
->unit
->voice_lock
, flags
);
421 if ((ret
= ymf_capture_prepare(state
)) != 0) {
422 spin_unlock_irqrestore(&state
->unit
->voice_lock
, flags
);
426 if ((ret
= ymf_playback_prepare(state
)) != 0) {
427 spin_unlock_irqrestore(&state
->unit
->voice_lock
, flags
);
431 spin_unlock_irqrestore(&state
->unit
->voice_lock
, flags
);
433 /* set the ready flag for the dma buffer (this comment is not stupid) */
437 printk(KERN_DEBUG
"prog_dmabuf: rate %d format 0x%x,"
438 " numfrag %d fragsize %d dmasize %d\n",
439 state
->format
.rate
, state
->format
.format
, dmabuf
->numfrag
,
440 dmabuf
->fragsize
, dmabuf
->dmasize
);
446 static void ymf_start_dac(struct ymf_state
*state
)
448 ymf_playback_trigger(state
->unit
, &state
->wpcm
, 1);
451 // static void ymf_start_adc(struct ymf_state *state)
453 // ymf_capture_trigger(state->unit, &state->rpcm, 1);
457 * Wait until output is drained.
458 * This does not kill the hardware for the sake of ioctls.
460 static void ymf_wait_dac(struct ymf_state
*state
)
462 struct ymf_unit
*unit
= state
->unit
;
463 struct ymf_pcm
*ypcm
= &state
->wpcm
;
464 DECLARE_WAITQUEUE(waita
, current
);
467 add_wait_queue(&ypcm
->dmabuf
.wait
, &waita
);
469 spin_lock_irqsave(&unit
->reg_lock
, flags
);
470 if (ypcm
->dmabuf
.count
!= 0 && !ypcm
->running
) {
471 ymf_playback_trigger(unit
, ypcm
, 1);
475 if (file
->f_flags
& O_NONBLOCK
) {
477 * XXX Our mistake is to attach DMA buffer to state
478 * rather than to some per-device structure.
479 * Cannot skip waiting, can only make it shorter.
484 set_current_state(TASK_UNINTERRUPTIBLE
);
485 while (ypcm
->running
) {
486 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
488 spin_lock_irqsave(&unit
->reg_lock
, flags
);
489 set_current_state(TASK_UNINTERRUPTIBLE
);
491 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
493 set_current_state(TASK_RUNNING
);
494 remove_wait_queue(&ypcm
->dmabuf
.wait
, &waita
);
497 * This function may take up to 4 seconds to reach this point
498 * (32K circular buffer, 8000 Hz). User notices.
502 /* Can just stop, without wait. Or can we? */
503 static void ymf_stop_adc(struct ymf_state
*state
)
505 struct ymf_unit
*unit
= state
->unit
;
508 spin_lock_irqsave(&unit
->reg_lock
, flags
);
509 ymf_capture_trigger(unit
, &state
->rpcm
, 0);
510 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
514 * Hardware start management
517 static void ymfpci_hw_start(ymfpci_t
*unit
)
521 spin_lock_irqsave(&unit
->reg_lock
, flags
);
522 if (unit
->start_count
++ == 0) {
523 ymfpci_writel(unit
, YDSXGR_MODE
,
524 ymfpci_readl(unit
, YDSXGR_MODE
) | 3);
525 unit
->active_bank
= ymfpci_readl(unit
, YDSXGR_CTRLSELECT
) & 1;
527 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
530 static void ymfpci_hw_stop(ymfpci_t
*unit
)
535 spin_lock_irqsave(&unit
->reg_lock
, flags
);
536 if (--unit
->start_count
== 0) {
537 ymfpci_writel(unit
, YDSXGR_MODE
,
538 ymfpci_readl(unit
, YDSXGR_MODE
) & ~3);
539 while (timeout
-- > 0) {
540 if ((ymfpci_readl(unit
, YDSXGR_STATUS
) & 2) == 0)
544 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
548 * Playback voice management
551 static int voice_alloc(ymfpci_t
*codec
, ymfpci_voice_type_t type
, int pair
, ymfpci_voice_t
*rvoice
[])
553 ymfpci_voice_t
*voice
, *voice2
;
556 for (idx
= 0; idx
< YDSXG_PLAYBACK_VOICES
; idx
+= pair
? 2 : 1) {
557 voice
= &codec
->voices
[idx
];
558 voice2
= pair
? &codec
->voices
[idx
+1] : NULL
;
559 if (voice
->use
|| (voice2
&& voice2
->use
))
577 ymfpci_hw_start(codec
);
580 ymfpci_hw_start(codec
);
585 return -EBUSY
; /* Your audio channel is open by someone else. */
588 static void ymfpci_voice_free(ymfpci_t
*unit
, ymfpci_voice_t
*pvoice
)
590 ymfpci_hw_stop(unit
);
591 pvoice
->use
= pvoice
->pcm
= pvoice
->synth
= pvoice
->midi
= 0;
598 static void ymf_pcm_interrupt(ymfpci_t
*codec
, ymfpci_voice_t
*voice
)
600 struct ymf_pcm
*ypcm
;
602 int pos
, delta
, swptr
;
603 int played
, distance
;
604 struct ymf_state
*state
;
605 struct ymf_dmabuf
*dmabuf
;
608 if ((ypcm
= voice
->ypcm
) == NULL
) {
611 if ((state
= ypcm
->state
) == NULL
) {
612 ypcm
->running
= 0; // lock it
615 dmabuf
= &ypcm
->dmabuf
;
616 spin_lock(&codec
->reg_lock
);
618 YMFDBGI("ymfpci: %d, intr bank %d count %d start 0x%x:%x\n",
619 voice
->number
, codec
->active_bank
, dmabuf
->count
,
620 le32_to_cpu(voice
->bank
[0].start
),
621 le32_to_cpu(voice
->bank
[1].start
));
622 silence
= (ymf_pcm_format_width(state
->format
.format
) == 16) ?
624 /* We need actual left-hand-side redzone size here. */
625 redzone
= ymf_calc_lend(state
->format
.rate
);
626 redzone
<<= (state
->format
.shift
+ 1);
627 swptr
= dmabuf
->swptr
;
629 pos
= le32_to_cpu(voice
->bank
[codec
->active_bank
].start
);
630 pos
<<= state
->format
.shift
;
631 if (pos
< 0 || pos
>= dmabuf
->dmasize
) { /* ucode bug */
632 printk(KERN_ERR
"ymfpci%d: runaway voice %d: hwptr %d=>%d dmasize %d\n",
633 codec
->dev_audio
, voice
->number
,
634 dmabuf
->hwptr
, pos
, dmabuf
->dmasize
);
637 if (pos
< dmabuf
->hwptr
) {
638 delta
= dmabuf
->dmasize
- dmabuf
->hwptr
;
639 memset(dmabuf
->rawbuf
+ dmabuf
->hwptr
, silence
, delta
);
641 memset(dmabuf
->rawbuf
, silence
, pos
);
643 delta
= pos
- dmabuf
->hwptr
;
644 memset(dmabuf
->rawbuf
+ dmabuf
->hwptr
, silence
, delta
);
648 if (dmabuf
->count
== 0) {
649 printk(KERN_ERR
"ymfpci%d: %d: strain: hwptr %d\n",
650 codec
->dev_audio
, voice
->number
, dmabuf
->hwptr
);
651 ymf_playback_trigger(codec
, ypcm
, 0);
655 distance
= pos
- swptr
;
657 distance
= dmabuf
->dmasize
- (swptr
- pos
);
659 if (distance
< redzone
) {
661 * hwptr inside redzone => DMA ran out of samples.
663 if (delta
< dmabuf
->count
) {
665 * Lost interrupt or other screwage.
667 printk(KERN_ERR
"ymfpci%d: %d: lost: delta %d"
668 " hwptr %d swptr %d distance %d count %d\n",
669 codec
->dev_audio
, voice
->number
, delta
,
670 dmabuf
->hwptr
, swptr
, distance
, dmabuf
->count
);
675 YMFDBGI("ymfpci%d: %d: done: delta %d"
676 " hwptr %d swptr %d distance %d count %d\n",
677 codec
->dev_audio
, voice
->number
, delta
,
678 dmabuf
->hwptr
, swptr
, distance
, dmabuf
->count
);
680 played
= dmabuf
->count
;
682 ymf_playback_trigger(codec
, ypcm
, 0);
686 * hwptr is chipping away towards a remote swptr.
687 * Calculate other distance and apply it to count.
690 distance
= swptr
- pos
;
692 distance
= dmabuf
->dmasize
- (pos
- swptr
);
694 if (distance
< dmabuf
->count
) {
695 played
= dmabuf
->count
- distance
;
701 dmabuf
->total_bytes
+= played
;
702 dmabuf
->count
-= played
;
703 if (dmabuf
->count
< dmabuf
->dmasize
/ 2) {
704 wake_up(&dmabuf
->wait
);
707 spin_unlock(&codec
->reg_lock
);
710 static void ymf_cap_interrupt(ymfpci_t
*unit
, struct ymf_capture
*cap
)
712 struct ymf_pcm
*ypcm
;
714 struct ymf_state
*state
;
715 struct ymf_dmabuf
*dmabuf
;
719 if ((ypcm
= cap
->ypcm
) == NULL
) {
722 if ((state
= ypcm
->state
) == NULL
) {
723 ypcm
->running
= 0; // lock it
726 dmabuf
= &ypcm
->dmabuf
;
727 spin_lock(&unit
->reg_lock
);
729 redzone
= ymf_calc_lend(state
->format
.rate
);
730 redzone
<<= (state
->format
.shift
+ 1);
732 pos
= le32_to_cpu(cap
->bank
[unit
->active_bank
].start
);
733 // pos <<= state->format.shift;
734 if (pos
< 0 || pos
>= dmabuf
->dmasize
) { /* ucode bug */
735 printk(KERN_ERR
"ymfpci%d: runaway capture %d: hwptr %d=>%d dmasize %d\n",
736 unit
->dev_audio
, ypcm
->capture_bank_number
,
737 dmabuf
->hwptr
, pos
, dmabuf
->dmasize
);
740 if (pos
< dmabuf
->hwptr
) {
741 delta
= dmabuf
->dmasize
- dmabuf
->hwptr
;
744 delta
= pos
- dmabuf
->hwptr
;
750 if (cnt
+ redzone
> dmabuf
->dmasize
) {
751 /* Overflow - bump swptr */
752 dmabuf
->count
= dmabuf
->dmasize
- redzone
;
753 dmabuf
->swptr
= dmabuf
->hwptr
+ redzone
;
754 if (dmabuf
->swptr
>= dmabuf
->dmasize
) {
755 dmabuf
->swptr
-= dmabuf
->dmasize
;
761 dmabuf
->total_bytes
+= delta
;
762 if (dmabuf
->count
) { /* && is_sleeping XXX */
763 wake_up(&dmabuf
->wait
);
766 spin_unlock(&unit
->reg_lock
);
769 static int ymf_playback_trigger(ymfpci_t
*codec
, struct ymf_pcm
*ypcm
, int cmd
)
772 if (ypcm
->voices
[0] == NULL
) {
776 codec
->ctrl_playback
[ypcm
->voices
[0]->number
+ 1] =
777 cpu_to_le32(ypcm
->voices
[0]->bank_ba
);
778 if (ypcm
->voices
[1] != NULL
)
779 codec
->ctrl_playback
[ypcm
->voices
[1]->number
+ 1] =
780 cpu_to_le32(ypcm
->voices
[1]->bank_ba
);
783 codec
->ctrl_playback
[ypcm
->voices
[0]->number
+ 1] = 0;
784 if (ypcm
->voices
[1] != NULL
)
785 codec
->ctrl_playback
[ypcm
->voices
[1]->number
+ 1] = 0;
791 static void ymf_capture_trigger(ymfpci_t
*codec
, struct ymf_pcm
*ypcm
, int cmd
)
796 tmp
= ymfpci_readl(codec
, YDSXGR_MAPOFREC
) | (1 << ypcm
->capture_bank_number
);
797 ymfpci_writel(codec
, YDSXGR_MAPOFREC
, tmp
);
800 tmp
= ymfpci_readl(codec
, YDSXGR_MAPOFREC
) & ~(1 << ypcm
->capture_bank_number
);
801 ymfpci_writel(codec
, YDSXGR_MAPOFREC
, tmp
);
806 static int ymfpci_pcm_voice_alloc(struct ymf_pcm
*ypcm
, int voices
)
808 struct ymf_unit
*unit
;
811 unit
= ypcm
->state
->unit
;
812 if (ypcm
->voices
[1] != NULL
&& voices
< 2) {
813 ymfpci_voice_free(unit
, ypcm
->voices
[1]);
814 ypcm
->voices
[1] = NULL
;
816 if (voices
== 1 && ypcm
->voices
[0] != NULL
)
817 return 0; /* already allocated */
818 if (voices
== 2 && ypcm
->voices
[0] != NULL
&& ypcm
->voices
[1] != NULL
)
819 return 0; /* already allocated */
821 if (ypcm
->voices
[0] != NULL
&& ypcm
->voices
[1] == NULL
) {
822 ymfpci_voice_free(unit
, ypcm
->voices
[0]);
823 ypcm
->voices
[0] = NULL
;
825 if ((err
= voice_alloc(unit
, YMFPCI_PCM
, 1, ypcm
->voices
)) < 0)
827 ypcm
->voices
[0]->ypcm
= ypcm
;
828 ypcm
->voices
[1]->ypcm
= ypcm
;
830 if ((err
= voice_alloc(unit
, YMFPCI_PCM
, 0, ypcm
->voices
)) < 0)
832 ypcm
->voices
[0]->ypcm
= ypcm
;
837 static void ymf_pcm_init_voice(ymfpci_voice_t
*voice
, int stereo
,
838 int rate
, int w_16
, unsigned long addr
, unsigned int end
, int spdif
)
841 u32 delta
= ymfpci_calc_delta(rate
);
842 u32 lpfQ
= ymfpci_calc_lpfQ(rate
);
843 u32 lpfK
= ymfpci_calc_lpfK(rate
);
844 ymfpci_playback_bank_t
*bank
;
848 * The gain is a floating point number. According to the manual,
849 * bit 31 indicates a sign bit, bit 30 indicates an integer part,
850 * and bits [29:15] indicate a decimal fraction part. Thus,
851 * for a gain of 1.0 the constant of 0x40000000 is loaded.
853 unsigned default_gain
= cpu_to_le32(0x40000000);
855 format
= (stereo
? 0x00010000 : 0) | (w_16
? 0 : 0x80000000);
860 for (nbank
= 0; nbank
< 2; nbank
++) {
861 bank
= &voice
->bank
[nbank
];
862 bank
->format
= cpu_to_le32(format
);
863 bank
->loop_default
= 0; /* 0-loops forever, otherwise count */
864 bank
->base
= cpu_to_le32(addr
);
865 bank
->loop_start
= 0;
866 bank
->loop_end
= cpu_to_le32(end
);
868 bank
->eg_gain_end
= default_gain
;
869 bank
->lpfQ
= cpu_to_le32(lpfQ
);
871 bank
->num_of_frames
= 0;
872 bank
->loop_count
= 0;
874 bank
->start_frac
= 0;
876 bank
->delta_end
= cpu_to_le32(delta
);
878 bank
->lpfK_end
= cpu_to_le32(lpfK
);
879 bank
->eg_gain
= default_gain
;
885 bank
->left_gain_end
=
886 bank
->right_gain_end
=
890 bank
->eff1_gain_end
=
891 bank
->eff2_gain_end
=
892 bank
->eff3_gain_end
= 0;
898 bank
->left_gain_end
=
899 bank
->right_gain_end
= default_gain
;
902 bank
->eff2_gain_end
=
904 bank
->eff3_gain_end
= default_gain
;
908 if ((voice
->number
& 1) == 0) {
910 bank
->left_gain_end
= default_gain
;
912 bank
->format
|= cpu_to_le32(1);
914 bank
->right_gain_end
= default_gain
;
917 if ((voice
->number
& 1) == 0) {
919 bank
->eff2_gain_end
= default_gain
;
921 bank
->format
|= cpu_to_le32(1);
923 bank
->eff3_gain_end
= default_gain
;
931 * XXX Capture channel allocation is entirely fake at the moment.
932 * We use only one channel and mark it busy as required.
934 static int ymf_capture_alloc(struct ymf_unit
*unit
, int *pbank
)
936 struct ymf_capture
*cap
;
939 cbank
= 1; /* Only ADC slot is used for now. */
940 cap
= &unit
->capture
[cbank
];
948 static int ymf_playback_prepare(struct ymf_state
*state
)
950 struct ymf_pcm
*ypcm
= &state
->wpcm
;
953 if ((err
= ymfpci_pcm_voice_alloc(ypcm
, state
->format
.voices
)) < 0) {
954 /* Somebody started 32 mpg123's in parallel? */
955 printk(KERN_INFO
"ymfpci%d: cannot allocate voice\n",
956 state
->unit
->dev_audio
);
960 for (nvoice
= 0; nvoice
< state
->format
.voices
; nvoice
++) {
961 ymf_pcm_init_voice(ypcm
->voices
[nvoice
],
962 state
->format
.voices
== 2, state
->format
.rate
,
963 ymf_pcm_format_width(state
->format
.format
) == 16,
964 ypcm
->dmabuf
.dma_addr
, ypcm
->dmabuf
.dmasize
,
970 static int ymf_capture_prepare(struct ymf_state
*state
)
972 ymfpci_t
*unit
= state
->unit
;
973 struct ymf_pcm
*ypcm
= &state
->rpcm
;
974 ymfpci_capture_bank_t
* bank
;
975 /* XXX This is confusing, gotta rename one of them banks... */
976 int nbank
; /* flip-flop bank */
977 int cbank
; /* input [super-]bank */
978 struct ymf_capture
*cap
;
981 if (ypcm
->capture_bank_number
== -1) {
982 if (ymf_capture_alloc(unit
, &cbank
) != 0)
985 ypcm
->capture_bank_number
= cbank
;
987 cap
= &unit
->capture
[cbank
];
988 cap
->bank
= unit
->bank_capture
[cbank
][0];
990 ymfpci_hw_start(unit
);
993 // ypcm->frag_size = snd_pcm_lib_transfer_fragment(substream);
994 // frag_size is replaced with nonfragged byte-aligned rolling buffer
995 rate
= ((48000 * 4096) / state
->format
.rate
) - 1;
997 if (state
->format
.voices
== 2)
999 if (ymf_pcm_format_width(state
->format
.format
) == 8)
1001 switch (ypcm
->capture_bank_number
) {
1003 ymfpci_writel(unit
, YDSXGR_RECFORMAT
, format
);
1004 ymfpci_writel(unit
, YDSXGR_RECSLOTSR
, rate
);
1007 ymfpci_writel(unit
, YDSXGR_ADCFORMAT
, format
);
1008 ymfpci_writel(unit
, YDSXGR_ADCSLOTSR
, rate
);
1011 for (nbank
= 0; nbank
< 2; nbank
++) {
1012 bank
= unit
->bank_capture
[ypcm
->capture_bank_number
][nbank
];
1013 bank
->base
= cpu_to_le32(ypcm
->dmabuf
.dma_addr
);
1014 // bank->loop_end = ypcm->dmabuf.dmasize >> state->format.shift;
1015 bank
->loop_end
= cpu_to_le32(ypcm
->dmabuf
.dmasize
);
1017 bank
->num_of_loops
= 0;
1020 if (state
->digital
.dig_valid
)
1021 /*state->digital.type == SND_PCM_DIG_AES_IEC958*/
1022 ymfpci_writew(codec
, YDSXGR_SPDIFOUTSTATUS
,
1023 state
->digital
.dig_status
[0] | (state
->digital
.dig_status
[1] << 8));
1028 static irqreturn_t
ymf_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
1030 ymfpci_t
*codec
= dev_id
;
1031 u32 status
, nvoice
, mode
;
1032 struct ymf_voice
*voice
;
1033 struct ymf_capture
*cap
;
1035 status
= ymfpci_readl(codec
, YDSXGR_STATUS
);
1036 if (status
& 0x80000000) {
1037 codec
->active_bank
= ymfpci_readl(codec
, YDSXGR_CTRLSELECT
) & 1;
1038 spin_lock(&codec
->voice_lock
);
1039 for (nvoice
= 0; nvoice
< YDSXG_PLAYBACK_VOICES
; nvoice
++) {
1040 voice
= &codec
->voices
[nvoice
];
1042 ymf_pcm_interrupt(codec
, voice
);
1044 for (nvoice
= 0; nvoice
< YDSXG_CAPTURE_VOICES
; nvoice
++) {
1045 cap
= &codec
->capture
[nvoice
];
1047 ymf_cap_interrupt(codec
, cap
);
1049 spin_unlock(&codec
->voice_lock
);
1050 spin_lock(&codec
->reg_lock
);
1051 ymfpci_writel(codec
, YDSXGR_STATUS
, 0x80000000);
1052 mode
= ymfpci_readl(codec
, YDSXGR_MODE
) | 2;
1053 ymfpci_writel(codec
, YDSXGR_MODE
, mode
);
1054 spin_unlock(&codec
->reg_lock
);
1057 status
= ymfpci_readl(codec
, YDSXGR_INTFLAG
);
1060 ymfpci_writel(codec
, YDSXGR_INTFLAG
, ~0);
1065 static void ymf_pcm_free_substream(struct ymf_pcm
*ypcm
)
1067 unsigned long flags
;
1068 struct ymf_unit
*unit
;
1070 unit
= ypcm
->state
->unit
;
1072 if (ypcm
->type
== PLAYBACK_VOICE
) {
1073 spin_lock_irqsave(&unit
->voice_lock
, flags
);
1074 if (ypcm
->voices
[1])
1075 ymfpci_voice_free(unit
, ypcm
->voices
[1]);
1076 if (ypcm
->voices
[0])
1077 ymfpci_voice_free(unit
, ypcm
->voices
[0]);
1078 spin_unlock_irqrestore(&unit
->voice_lock
, flags
);
1080 if (ypcm
->capture_bank_number
!= -1) {
1081 unit
->capture
[ypcm
->capture_bank_number
].use
= 0;
1082 ypcm
->capture_bank_number
= -1;
1083 ymfpci_hw_stop(unit
);
1088 static struct ymf_state
*ymf_state_alloc(ymfpci_t
*unit
)
1090 struct ymf_pcm
*ypcm
;
1091 struct ymf_state
*state
;
1093 if ((state
= kmalloc(sizeof(struct ymf_state
), GFP_KERNEL
)) == NULL
) {
1096 memset(state
, 0, sizeof(struct ymf_state
));
1098 ypcm
= &state
->wpcm
;
1099 ypcm
->state
= state
;
1100 ypcm
->type
= PLAYBACK_VOICE
;
1101 ypcm
->capture_bank_number
= -1;
1102 init_waitqueue_head(&ypcm
->dmabuf
.wait
);
1104 ypcm
= &state
->rpcm
;
1105 ypcm
->state
= state
;
1106 ypcm
->type
= CAPTURE_AC97
;
1107 ypcm
->capture_bank_number
= -1;
1108 init_waitqueue_head(&ypcm
->dmabuf
.wait
);
1112 state
->format
.format
= AFMT_U8
;
1113 state
->format
.rate
= 8000;
1114 state
->format
.voices
= 1;
1115 ymf_pcm_update_shift(&state
->format
);
1123 /* AES/IEC958 channel status bits */
1124 #define SND_PCM_AES0_PROFESSIONAL (1<<0) /* 0 = consumer, 1 = professional */
1125 #define SND_PCM_AES0_NONAUDIO (1<<1) /* 0 = audio, 1 = non-audio */
1126 #define SND_PCM_AES0_PRO_EMPHASIS (7<<2) /* mask - emphasis */
1127 #define SND_PCM_AES0_PRO_EMPHASIS_NOTID (0<<2) /* emphasis not indicated */
1128 #define SND_PCM_AES0_PRO_EMPHASIS_NONE (1<<2) /* none emphasis */
1129 #define SND_PCM_AES0_PRO_EMPHASIS_5015 (3<<2) /* 50/15us emphasis */
1130 #define SND_PCM_AES0_PRO_EMPHASIS_CCITT (7<<2) /* CCITT J.17 emphasis */
1131 #define SND_PCM_AES0_PRO_FREQ_UNLOCKED (1<<5) /* source sample frequency: 0 = locked, 1 = unlocked */
1132 #define SND_PCM_AES0_PRO_FS (3<<6) /* mask - sample frequency */
1133 #define SND_PCM_AES0_PRO_FS_NOTID (0<<6) /* fs not indicated */
1134 #define SND_PCM_AES0_PRO_FS_44100 (1<<6) /* 44.1kHz */
1135 #define SND_PCM_AES0_PRO_FS_48000 (2<<6) /* 48kHz */
1136 #define SND_PCM_AES0_PRO_FS_32000 (3<<6) /* 32kHz */
1137 #define SND_PCM_AES0_CON_NOT_COPYRIGHT (1<<2) /* 0 = copyright, 1 = not copyright */
1138 #define SND_PCM_AES0_CON_EMPHASIS (7<<3) /* mask - emphasis */
1139 #define SND_PCM_AES0_CON_EMPHASIS_NONE (0<<3) /* none emphasis */
1140 #define SND_PCM_AES0_CON_EMPHASIS_5015 (1<<3) /* 50/15us emphasis */
1141 #define SND_PCM_AES0_CON_MODE (3<<6) /* mask - mode */
1142 #define SND_PCM_AES1_PRO_MODE (15<<0) /* mask - channel mode */
1143 #define SND_PCM_AES1_PRO_MODE_NOTID (0<<0) /* not indicated */
1144 #define SND_PCM_AES1_PRO_MODE_STEREOPHONIC (2<<0) /* stereophonic - ch A is left */
1145 #define SND_PCM_AES1_PRO_MODE_SINGLE (4<<0) /* single channel */
1146 #define SND_PCM_AES1_PRO_MODE_TWO (8<<0) /* two channels */
1147 #define SND_PCM_AES1_PRO_MODE_PRIMARY (12<<0) /* primary/secondary */
1148 #define SND_PCM_AES1_PRO_MODE_BYTE3 (15<<0) /* vector to byte 3 */
1149 #define SND_PCM_AES1_PRO_USERBITS (15<<4) /* mask - user bits */
1150 #define SND_PCM_AES1_PRO_USERBITS_NOTID (0<<4) /* not indicated */
1151 #define SND_PCM_AES1_PRO_USERBITS_192 (8<<4) /* 192-bit structure */
1152 #define SND_PCM_AES1_PRO_USERBITS_UDEF (12<<4) /* user defined application */
1153 #define SND_PCM_AES1_CON_CATEGORY 0x7f
1154 #define SND_PCM_AES1_CON_GENERAL 0x00
1155 #define SND_PCM_AES1_CON_EXPERIMENTAL 0x40
1156 #define SND_PCM_AES1_CON_SOLIDMEM_MASK 0x0f
1157 #define SND_PCM_AES1_CON_SOLIDMEM_ID 0x08
1158 #define SND_PCM_AES1_CON_BROADCAST1_MASK 0x07
1159 #define SND_PCM_AES1_CON_BROADCAST1_ID 0x04
1160 #define SND_PCM_AES1_CON_DIGDIGCONV_MASK 0x07
1161 #define SND_PCM_AES1_CON_DIGDIGCONV_ID 0x02
1162 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_MASK 0x1f
1163 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_ID 0x06
1164 #define SND_PCM_AES1_CON_ADC_MASK 0x1f
1165 #define SND_PCM_AES1_CON_ADC_ID 0x16
1166 #define SND_PCM_AES1_CON_BROADCAST2_MASK 0x0f
1167 #define SND_PCM_AES1_CON_BROADCAST2_ID 0x0e
1168 #define SND_PCM_AES1_CON_LASEROPT_MASK 0x07
1169 #define SND_PCM_AES1_CON_LASEROPT_ID 0x01
1170 #define SND_PCM_AES1_CON_MUSICAL_MASK 0x07
1171 #define SND_PCM_AES1_CON_MUSICAL_ID 0x05
1172 #define SND_PCM_AES1_CON_MAGNETIC_MASK 0x07
1173 #define SND_PCM_AES1_CON_MAGNETIC_ID 0x03
1174 #define SND_PCM_AES1_CON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x00)
1175 #define SND_PCM_AES1_CON_NON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x08)
1176 #define SND_PCM_AES1_CON_PCM_CODER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x00)
1177 #define SND_PCM_AES1_CON_SAMPLER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x20)
1178 #define SND_PCM_AES1_CON_MIXER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x10)
1179 #define SND_PCM_AES1_CON_RATE_CONVERTER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x18)
1180 #define SND_PCM_AES1_CON_SYNTHESIZER (SND_PCM_AES1_CON_MUSICAL_ID|0x00)
1181 #define SND_PCM_AES1_CON_MICROPHONE (SND_PCM_AES1_CON_MUSICAL_ID|0x08)
1182 #define SND_PCM_AES1_CON_DAT (SND_PCM_AES1_CON_MAGNETIC_ID|0x00)
1183 #define SND_PCM_AES1_CON_VCR (SND_PCM_AES1_CON_MAGNETIC_ID|0x08)
1184 #define SND_PCM_AES1_CON_ORIGINAL (1<<7) /* this bits depends on the category code */
1185 #define SND_PCM_AES2_PRO_SBITS (7<<0) /* mask - sample bits */
1186 #define SND_PCM_AES2_PRO_SBITS_20 (2<<0) /* 20-bit - coordination */
1187 #define SND_PCM_AES2_PRO_SBITS_24 (4<<0) /* 24-bit - main audio */
1188 #define SND_PCM_AES2_PRO_SBITS_UDEF (6<<0) /* user defined application */
1189 #define SND_PCM_AES2_PRO_WORDLEN (7<<3) /* mask - source word length */
1190 #define SND_PCM_AES2_PRO_WORDLEN_NOTID (0<<3) /* not indicated */
1191 #define SND_PCM_AES2_PRO_WORDLEN_22_18 (2<<3) /* 22-bit or 18-bit */
1192 #define SND_PCM_AES2_PRO_WORDLEN_23_19 (4<<3) /* 23-bit or 19-bit */
1193 #define SND_PCM_AES2_PRO_WORDLEN_24_20 (5<<3) /* 24-bit or 20-bit */
1194 #define SND_PCM_AES2_PRO_WORDLEN_20_16 (6<<3) /* 20-bit or 16-bit */
1195 #define SND_PCM_AES2_CON_SOURCE (15<<0) /* mask - source number */
1196 #define SND_PCM_AES2_CON_SOURCE_UNSPEC (0<<0) /* unspecified */
1197 #define SND_PCM_AES2_CON_CHANNEL (15<<4) /* mask - channel number */
1198 #define SND_PCM_AES2_CON_CHANNEL_UNSPEC (0<<4) /* unspecified */
1199 #define SND_PCM_AES3_CON_FS (15<<0) /* mask - sample frequency */
1200 #define SND_PCM_AES3_CON_FS_44100 (0<<0) /* 44.1kHz */
1201 #define SND_PCM_AES3_CON_FS_48000 (2<<0) /* 48kHz */
1202 #define SND_PCM_AES3_CON_FS_32000 (3<<0) /* 32kHz */
1203 #define SND_PCM_AES3_CON_CLOCK (3<<4) /* mask - clock accuracy */
1204 #define SND_PCM_AES3_CON_CLOCK_1000PPM (0<<4) /* 1000 ppm */
1205 #define SND_PCM_AES3_CON_CLOCK_50PPM (1<<4) /* 50 ppm */
1206 #define SND_PCM_AES3_CON_CLOCK_VARIABLE (2<<4) /* variable pitch */
1213 * in this loop, dmabuf.count signifies the amount of data that is
1214 * waiting to be copied to the user's buffer. it is filled by the dma
1215 * machine and drained by this loop.
1218 ymf_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
1220 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1221 struct ymf_dmabuf
*dmabuf
= &state
->rpcm
.dmabuf
;
1222 struct ymf_unit
*unit
= state
->unit
;
1223 DECLARE_WAITQUEUE(waita
, current
);
1225 unsigned long flags
;
1227 int cnt
; /* This many to go in this revolution */
1231 if (!dmabuf
->ready
&& (ret
= prog_dmabuf(state
, 1)))
1235 add_wait_queue(&dmabuf
->wait
, &waita
);
1236 set_current_state(TASK_INTERRUPTIBLE
);
1238 spin_lock_irqsave(&unit
->reg_lock
, flags
);
1239 if (unit
->suspended
) {
1240 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1242 set_current_state(TASK_INTERRUPTIBLE
);
1243 if (signal_pending(current
)) {
1244 if (!ret
) ret
= -EAGAIN
;
1249 swptr
= dmabuf
->swptr
;
1250 cnt
= dmabuf
->dmasize
- swptr
;
1251 if (dmabuf
->count
< cnt
)
1252 cnt
= dmabuf
->count
;
1253 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1259 /* buffer is empty, start the dma machine and wait for data to be
1261 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1262 if (!state
->rpcm
.running
) {
1263 ymf_capture_trigger(state
->unit
, &state
->rpcm
, 1);
1265 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1266 if (file
->f_flags
& O_NONBLOCK
) {
1267 if (!ret
) ret
= -EAGAIN
;
1270 /* This isnt strictly right for the 810 but it'll do */
1271 tmo
= (dmabuf
->dmasize
* HZ
) / (state
->format
.rate
* 2);
1272 tmo
>>= state
->format
.shift
;
1273 /* There are two situations when sleep_on_timeout returns, one is when
1274 the interrupt is serviced correctly and the process is waked up by
1275 ISR ON TIME. Another is when timeout is expired, which means that
1276 either interrupt is NOT serviced correctly (pending interrupt) or it
1277 is TOO LATE for the process to be scheduled to run (scheduler latency)
1278 which results in a (potential) buffer overrun. And worse, there is
1279 NOTHING we can do to prevent it. */
1280 tmo
= schedule_timeout(tmo
);
1281 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1282 set_current_state(TASK_INTERRUPTIBLE
);
1283 if (tmo
== 0 && dmabuf
->count
== 0) {
1284 printk(KERN_ERR
"ymfpci%d: recording schedule timeout, "
1285 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1286 state
->unit
->dev_audio
,
1287 dmabuf
->dmasize
, dmabuf
->fragsize
, dmabuf
->count
,
1288 dmabuf
->hwptr
, dmabuf
->swptr
);
1290 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1291 if (signal_pending(current
)) {
1292 if (!ret
) ret
= -ERESTARTSYS
;
1298 if (copy_to_user(buffer
, dmabuf
->rawbuf
+ swptr
, cnt
)) {
1299 if (!ret
) ret
= -EFAULT
;
1303 swptr
= (swptr
+ cnt
) % dmabuf
->dmasize
;
1305 spin_lock_irqsave(&unit
->reg_lock
, flags
);
1306 if (unit
->suspended
) {
1307 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1311 dmabuf
->swptr
= swptr
;
1312 dmabuf
->count
-= cnt
;
1313 // spin_unlock_irqrestore(&unit->reg_lock, flags);
1318 // spin_lock_irqsave(&unit->reg_lock, flags);
1319 if (!state
->rpcm
.running
) {
1320 ymf_capture_trigger(unit
, &state
->rpcm
, 1);
1322 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1324 set_current_state(TASK_RUNNING
);
1325 remove_wait_queue(&dmabuf
->wait
, &waita
);
1331 ymf_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
1333 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1334 struct ymf_dmabuf
*dmabuf
= &state
->wpcm
.dmabuf
;
1335 struct ymf_unit
*unit
= state
->unit
;
1336 DECLARE_WAITQUEUE(waita
, current
);
1338 unsigned long flags
;
1340 int cnt
; /* This many to go in this revolution */
1344 YMFDBGW("ymf_write: count %d\n", count
);
1348 if (!dmabuf
->ready
&& (ret
= prog_dmabuf(state
, 0)))
1353 * Alan's cs46xx works without a red zone - marvel of ingenuity.
1354 * We are not so brilliant... Red zone does two things:
1355 * 1. allows for safe start after a pause as we have no way
1356 * to know what the actual, relentlessly advancing, hwptr is.
1357 * 2. makes computations in ymf_pcm_interrupt simpler.
1359 redzone
= ymf_calc_lend(state
->format
.rate
) << state
->format
.shift
;
1360 redzone
*= 3; /* 2 redzone + 1 possible uncertainty reserve. */
1362 add_wait_queue(&dmabuf
->wait
, &waita
);
1363 set_current_state(TASK_INTERRUPTIBLE
);
1365 spin_lock_irqsave(&unit
->reg_lock
, flags
);
1366 if (unit
->suspended
) {
1367 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1369 set_current_state(TASK_INTERRUPTIBLE
);
1370 if (signal_pending(current
)) {
1371 if (!ret
) ret
= -EAGAIN
;
1376 if (dmabuf
->count
< 0) {
1378 "ymf_write: count %d, was legal in cs46xx\n",
1382 if (dmabuf
->count
== 0) {
1383 swptr
= dmabuf
->hwptr
;
1384 if (state
->wpcm
.running
) {
1386 * Add uncertainty reserve.
1388 cnt
= ymf_calc_lend(state
->format
.rate
);
1389 cnt
<<= state
->format
.shift
;
1390 if ((swptr
+= cnt
) >= dmabuf
->dmasize
) {
1391 swptr
-= dmabuf
->dmasize
;
1394 dmabuf
->swptr
= swptr
;
1397 * XXX This is not right if dmabuf->count is small -
1398 * about 2*x frame size or less. We cannot count on
1399 * on appending and not causing an artefact.
1400 * Should use a variation of the count==0 case above.
1402 swptr
= dmabuf
->swptr
;
1404 cnt
= dmabuf
->dmasize
- swptr
;
1405 if (dmabuf
->count
+ cnt
> dmabuf
->dmasize
- redzone
)
1406 cnt
= (dmabuf
->dmasize
- redzone
) - dmabuf
->count
;
1407 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1412 YMFDBGW("ymf_write: full, count %d swptr %d\n",
1413 dmabuf
->count
, dmabuf
->swptr
);
1415 * buffer is full, start the dma machine and
1416 * wait for data to be played
1418 spin_lock_irqsave(&unit
->reg_lock
, flags
);
1419 if (!state
->wpcm
.running
) {
1420 ymf_playback_trigger(unit
, &state
->wpcm
, 1);
1422 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1423 if (file
->f_flags
& O_NONBLOCK
) {
1424 if (!ret
) ret
= -EAGAIN
;
1428 set_current_state(TASK_INTERRUPTIBLE
);
1429 if (signal_pending(current
)) {
1430 if (!ret
) ret
= -ERESTARTSYS
;
1435 if (copy_from_user(dmabuf
->rawbuf
+ swptr
, buffer
, cnt
)) {
1436 if (!ret
) ret
= -EFAULT
;
1440 if ((swptr
+= cnt
) >= dmabuf
->dmasize
) {
1441 swptr
-= dmabuf
->dmasize
;
1444 spin_lock_irqsave(&unit
->reg_lock
, flags
);
1445 if (unit
->suspended
) {
1446 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1449 dmabuf
->swptr
= swptr
;
1450 dmabuf
->count
+= cnt
;
1453 * Start here is a bad idea - may cause startup click
1454 * in /bin/play when dmabuf is not full yet.
1455 * However, some broken applications do not make
1456 * any use of SNDCTL_DSP_SYNC (Doom is the worst).
1457 * One frame is about 5.3ms, Doom write size is 46ms.
1459 delay
= state
->format
.rate
/ 20; /* 50ms */
1460 delay
<<= state
->format
.shift
;
1461 if (dmabuf
->count
>= delay
&& !state
->wpcm
.running
) {
1462 ymf_playback_trigger(unit
, &state
->wpcm
, 1);
1465 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
1472 set_current_state(TASK_RUNNING
);
1473 remove_wait_queue(&dmabuf
->wait
, &waita
);
1475 YMFDBGW("ymf_write: ret %d dmabuf.count %d\n", ret
, dmabuf
->count
);
1479 static unsigned int ymf_poll(struct file
*file
, struct poll_table_struct
*wait
)
1481 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1482 struct ymf_dmabuf
*dmabuf
;
1484 unsigned long flags
;
1485 unsigned int mask
= 0;
1487 if (file
->f_mode
& FMODE_WRITE
)
1488 poll_wait(file
, &state
->wpcm
.dmabuf
.wait
, wait
);
1489 if (file
->f_mode
& FMODE_READ
)
1490 poll_wait(file
, &state
->rpcm
.dmabuf
.wait
, wait
);
1492 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1493 if (file
->f_mode
& FMODE_READ
) {
1494 dmabuf
= &state
->rpcm
.dmabuf
;
1495 if (dmabuf
->count
>= (signed)dmabuf
->fragsize
)
1496 mask
|= POLLIN
| POLLRDNORM
;
1498 if (file
->f_mode
& FMODE_WRITE
) {
1499 redzone
= ymf_calc_lend(state
->format
.rate
);
1500 redzone
<<= state
->format
.shift
;
1503 dmabuf
= &state
->wpcm
.dmabuf
;
1504 if (dmabuf
->mapped
) {
1505 if (dmabuf
->count
>= (signed)dmabuf
->fragsize
)
1506 mask
|= POLLOUT
| POLLWRNORM
;
1509 * Don't select unless a full fragment is available.
1510 * Otherwise artsd does GETOSPACE, sees 0, and loops.
1512 if (dmabuf
->count
+ redzone
+ dmabuf
->fragsize
1514 mask
|= POLLOUT
| POLLWRNORM
;
1517 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1522 static int ymf_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1524 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1525 struct ymf_dmabuf
*dmabuf
= &state
->wpcm
.dmabuf
;
1529 if (vma
->vm_flags
& VM_WRITE
) {
1530 if ((ret
= prog_dmabuf(state
, 0)) != 0)
1532 } else if (vma
->vm_flags
& VM_READ
) {
1533 if ((ret
= prog_dmabuf(state
, 1)) != 0)
1538 if (vma
->vm_pgoff
!= 0)
1540 size
= vma
->vm_end
- vma
->vm_start
;
1541 if (size
> (PAGE_SIZE
<< dmabuf
->buforder
))
1543 if (remap_pfn_range(vma
, vma
->vm_start
,
1544 virt_to_phys(dmabuf
->rawbuf
) >> PAGE_SHIFT
,
1545 size
, vma
->vm_page_prot
))
1549 /* P3 */ printk(KERN_INFO
"ymfpci: using memory mapped sound, untested!\n");
1553 static int ymf_ioctl(struct inode
*inode
, struct file
*file
,
1554 unsigned int cmd
, unsigned long arg
)
1556 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1557 struct ymf_dmabuf
*dmabuf
;
1558 unsigned long flags
;
1559 audio_buf_info abinfo
;
1563 void __user
*argp
= (void __user
*)arg
;
1564 int __user
*p
= argp
;
1567 case OSS_GETVERSION
:
1568 YMFDBGX("ymf_ioctl: cmd 0x%x(GETVER) arg 0x%lx\n", cmd
, arg
);
1569 return put_user(SOUND_VERSION
, p
);
1571 case SNDCTL_DSP_RESET
:
1572 YMFDBGX("ymf_ioctl: cmd 0x%x(RESET)\n", cmd
);
1573 if (file
->f_mode
& FMODE_WRITE
) {
1574 ymf_wait_dac(state
);
1575 dmabuf
= &state
->wpcm
.dmabuf
;
1576 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1578 dmabuf
->swptr
= dmabuf
->hwptr
;
1579 dmabuf
->count
= dmabuf
->total_bytes
= 0;
1580 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1582 if (file
->f_mode
& FMODE_READ
) {
1583 ymf_stop_adc(state
);
1584 dmabuf
= &state
->rpcm
.dmabuf
;
1585 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1587 dmabuf
->swptr
= dmabuf
->hwptr
;
1588 dmabuf
->count
= dmabuf
->total_bytes
= 0;
1589 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1593 case SNDCTL_DSP_SYNC
:
1594 YMFDBGX("ymf_ioctl: cmd 0x%x(SYNC)\n", cmd
);
1595 if (file
->f_mode
& FMODE_WRITE
) {
1596 dmabuf
= &state
->wpcm
.dmabuf
;
1597 if (file
->f_flags
& O_NONBLOCK
) {
1598 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1599 if (dmabuf
->count
!= 0 && !state
->wpcm
.running
) {
1600 ymf_start_dac(state
);
1602 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1604 ymf_wait_dac(state
);
1607 /* XXX What does this do for reading? dmabuf->count=0; ? */
1610 case SNDCTL_DSP_SPEED
: /* set smaple rate */
1611 if (get_user(val
, p
))
1613 YMFDBGX("ymf_ioctl: cmd 0x%x(SPEED) sp %d\n", cmd
, val
);
1614 if (val
>= 8000 && val
<= 48000) {
1615 if (file
->f_mode
& FMODE_WRITE
) {
1616 ymf_wait_dac(state
);
1617 dmabuf
= &state
->wpcm
.dmabuf
;
1618 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1620 state
->format
.rate
= val
;
1621 ymf_pcm_update_shift(&state
->format
);
1622 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1624 if (file
->f_mode
& FMODE_READ
) {
1625 ymf_stop_adc(state
);
1626 dmabuf
= &state
->rpcm
.dmabuf
;
1627 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1629 state
->format
.rate
= val
;
1630 ymf_pcm_update_shift(&state
->format
);
1631 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1634 return put_user(state
->format
.rate
, p
);
1637 * OSS manual does not mention SNDCTL_DSP_STEREO at all.
1638 * All channels are mono and if you want stereo, you
1639 * play into two channels with SNDCTL_DSP_CHANNELS.
1640 * However, mpg123 calls it. I wonder, why Michael Hipp used it.
1642 case SNDCTL_DSP_STEREO
: /* set stereo or mono channel */
1643 if (get_user(val
, p
))
1645 YMFDBGX("ymf_ioctl: cmd 0x%x(STEREO) st %d\n", cmd
, val
);
1646 if (file
->f_mode
& FMODE_WRITE
) {
1647 ymf_wait_dac(state
);
1648 dmabuf
= &state
->wpcm
.dmabuf
;
1649 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1651 state
->format
.voices
= val
? 2 : 1;
1652 ymf_pcm_update_shift(&state
->format
);
1653 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1655 if (file
->f_mode
& FMODE_READ
) {
1656 ymf_stop_adc(state
);
1657 dmabuf
= &state
->rpcm
.dmabuf
;
1658 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1660 state
->format
.voices
= val
? 2 : 1;
1661 ymf_pcm_update_shift(&state
->format
);
1662 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1666 case SNDCTL_DSP_GETBLKSIZE
:
1667 YMFDBGX("ymf_ioctl: cmd 0x%x(GETBLK)\n", cmd
);
1668 if (file
->f_mode
& FMODE_WRITE
) {
1669 if ((val
= prog_dmabuf(state
, 0)))
1671 val
= state
->wpcm
.dmabuf
.fragsize
;
1672 YMFDBGX("ymf_ioctl: GETBLK w %d\n", val
);
1673 return put_user(val
, p
);
1675 if (file
->f_mode
& FMODE_READ
) {
1676 if ((val
= prog_dmabuf(state
, 1)))
1678 val
= state
->rpcm
.dmabuf
.fragsize
;
1679 YMFDBGX("ymf_ioctl: GETBLK r %d\n", val
);
1680 return put_user(val
, p
);
1684 case SNDCTL_DSP_GETFMTS
: /* Returns a mask of supported sample format*/
1685 YMFDBGX("ymf_ioctl: cmd 0x%x(GETFMTS)\n", cmd
);
1686 return put_user(AFMT_S16_LE
|AFMT_U8
, p
);
1688 case SNDCTL_DSP_SETFMT
: /* Select sample format */
1689 if (get_user(val
, p
))
1691 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFMT) fmt %d\n", cmd
, val
);
1692 if (val
== AFMT_S16_LE
|| val
== AFMT_U8
) {
1693 if (file
->f_mode
& FMODE_WRITE
) {
1694 ymf_wait_dac(state
);
1695 dmabuf
= &state
->wpcm
.dmabuf
;
1696 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1698 state
->format
.format
= val
;
1699 ymf_pcm_update_shift(&state
->format
);
1700 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1702 if (file
->f_mode
& FMODE_READ
) {
1703 ymf_stop_adc(state
);
1704 dmabuf
= &state
->rpcm
.dmabuf
;
1705 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1707 state
->format
.format
= val
;
1708 ymf_pcm_update_shift(&state
->format
);
1709 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1712 return put_user(state
->format
.format
, p
);
1714 case SNDCTL_DSP_CHANNELS
:
1715 if (get_user(val
, p
))
1717 YMFDBGX("ymf_ioctl: cmd 0x%x(CHAN) ch %d\n", cmd
, val
);
1719 if (file
->f_mode
& FMODE_WRITE
) {
1720 ymf_wait_dac(state
);
1721 if (val
== 1 || val
== 2) {
1722 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1723 dmabuf
= &state
->wpcm
.dmabuf
;
1725 state
->format
.voices
= val
;
1726 ymf_pcm_update_shift(&state
->format
);
1727 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1730 if (file
->f_mode
& FMODE_READ
) {
1731 ymf_stop_adc(state
);
1732 if (val
== 1 || val
== 2) {
1733 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1734 dmabuf
= &state
->rpcm
.dmabuf
;
1736 state
->format
.voices
= val
;
1737 ymf_pcm_update_shift(&state
->format
);
1738 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1742 return put_user(state
->format
.voices
, p
);
1744 case SNDCTL_DSP_POST
:
1745 YMFDBGX("ymf_ioctl: cmd 0x%x(POST)\n", cmd
);
1748 * The ioctl SNDCTL_DSP_POST is a lightweight version of
1749 * SNDCTL_DSP_SYNC. It just tells to the driver that there
1750 * is likely to be a pause in the output. This makes it
1751 * possible for the device to handle the pause more
1752 * intelligently. This ioctl doesn't block the application.
1754 * The paragraph above is a clumsy way to say "flush ioctl".
1755 * This ioctl is used by mpg123.
1757 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1758 if (state
->wpcm
.dmabuf
.count
!= 0 && !state
->wpcm
.running
) {
1759 ymf_start_dac(state
);
1761 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1764 case SNDCTL_DSP_SETFRAGMENT
:
1765 if (get_user(val
, p
))
1767 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFRAG) fr 0x%04x:%04x(%d:%d)\n",
1769 (val
>> 16) & 0xFFFF, val
& 0xFFFF,
1770 (val
>> 16) & 0xFFFF, val
& 0xFFFF);
1771 dmabuf
= &state
->wpcm
.dmabuf
;
1772 dmabuf
->ossfragshift
= val
& 0xffff;
1773 dmabuf
->ossmaxfrags
= (val
>> 16) & 0xffff;
1774 if (dmabuf
->ossfragshift
< 4)
1775 dmabuf
->ossfragshift
= 4;
1776 if (dmabuf
->ossfragshift
> 15)
1777 dmabuf
->ossfragshift
= 15;
1780 case SNDCTL_DSP_GETOSPACE
:
1781 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOSPACE)\n", cmd
);
1782 if (!(file
->f_mode
& FMODE_WRITE
))
1784 dmabuf
= &state
->wpcm
.dmabuf
;
1785 if (!dmabuf
->ready
&& (val
= prog_dmabuf(state
, 0)) != 0)
1787 redzone
= ymf_calc_lend(state
->format
.rate
);
1788 redzone
<<= state
->format
.shift
;
1790 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1791 abinfo
.fragsize
= dmabuf
->fragsize
;
1792 abinfo
.bytes
= dmabuf
->dmasize
- dmabuf
->count
- redzone
;
1793 abinfo
.fragstotal
= dmabuf
->numfrag
;
1794 abinfo
.fragments
= abinfo
.bytes
>> dmabuf
->fragshift
;
1795 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1796 return copy_to_user(argp
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1798 case SNDCTL_DSP_GETISPACE
:
1799 YMFDBGX("ymf_ioctl: cmd 0x%x(GETISPACE)\n", cmd
);
1800 if (!(file
->f_mode
& FMODE_READ
))
1802 dmabuf
= &state
->rpcm
.dmabuf
;
1803 if (!dmabuf
->ready
&& (val
= prog_dmabuf(state
, 1)) != 0)
1805 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1806 abinfo
.fragsize
= dmabuf
->fragsize
;
1807 abinfo
.bytes
= dmabuf
->count
;
1808 abinfo
.fragstotal
= dmabuf
->numfrag
;
1809 abinfo
.fragments
= abinfo
.bytes
>> dmabuf
->fragshift
;
1810 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1811 return copy_to_user(argp
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
1813 case SNDCTL_DSP_NONBLOCK
:
1814 YMFDBGX("ymf_ioctl: cmd 0x%x(NONBLOCK)\n", cmd
);
1815 file
->f_flags
|= O_NONBLOCK
;
1818 case SNDCTL_DSP_GETCAPS
:
1819 YMFDBGX("ymf_ioctl: cmd 0x%x(GETCAPS)\n", cmd
);
1820 /* return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
1822 return put_user(0, p
);
1824 case SNDCTL_DSP_GETIPTR
:
1825 YMFDBGX("ymf_ioctl: cmd 0x%x(GETIPTR)\n", cmd
);
1826 if (!(file
->f_mode
& FMODE_READ
))
1828 dmabuf
= &state
->rpcm
.dmabuf
;
1829 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1830 cinfo
.bytes
= dmabuf
->total_bytes
;
1831 cinfo
.blocks
= dmabuf
->count
>> dmabuf
->fragshift
;
1832 cinfo
.ptr
= dmabuf
->hwptr
;
1833 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1834 YMFDBGX("ymf_ioctl: GETIPTR ptr %d bytes %d\n",
1835 cinfo
.ptr
, cinfo
.bytes
);
1836 return copy_to_user(argp
, &cinfo
, sizeof(cinfo
)) ? -EFAULT
: 0;
1838 case SNDCTL_DSP_GETOPTR
:
1839 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOPTR)\n", cmd
);
1840 if (!(file
->f_mode
& FMODE_WRITE
))
1842 dmabuf
= &state
->wpcm
.dmabuf
;
1843 spin_lock_irqsave(&state
->unit
->reg_lock
, flags
);
1844 cinfo
.bytes
= dmabuf
->total_bytes
;
1845 cinfo
.blocks
= dmabuf
->count
>> dmabuf
->fragshift
;
1846 cinfo
.ptr
= dmabuf
->hwptr
;
1847 spin_unlock_irqrestore(&state
->unit
->reg_lock
, flags
);
1848 YMFDBGX("ymf_ioctl: GETOPTR ptr %d bytes %d\n",
1849 cinfo
.ptr
, cinfo
.bytes
);
1850 return copy_to_user(argp
, &cinfo
, sizeof(cinfo
)) ? -EFAULT
: 0;
1852 case SNDCTL_DSP_SETDUPLEX
:
1853 YMFDBGX("ymf_ioctl: cmd 0x%x(SETDUPLEX)\n", cmd
);
1854 return 0; /* Always duplex */
1856 case SOUND_PCM_READ_RATE
:
1857 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_RATE)\n", cmd
);
1858 return put_user(state
->format
.rate
, p
);
1860 case SOUND_PCM_READ_CHANNELS
:
1861 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_CH)\n", cmd
);
1862 return put_user(state
->format
.voices
, p
);
1864 case SOUND_PCM_READ_BITS
:
1865 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_BITS)\n", cmd
);
1866 return put_user(AFMT_S16_LE
, p
);
1868 case SNDCTL_DSP_MAPINBUF
:
1869 case SNDCTL_DSP_MAPOUTBUF
:
1870 case SNDCTL_DSP_SETSYNCRO
:
1871 case SOUND_PCM_WRITE_FILTER
:
1872 case SOUND_PCM_READ_FILTER
:
1873 YMFDBGX("ymf_ioctl: cmd 0x%x unsupported\n", cmd
);
1878 * Some programs mix up audio devices and ioctls
1879 * or perhaps they expect "universal" ioctls,
1880 * for instance we get SNDCTL_TMR_CONTINUE here.
1881 * (mpg123 -g 100 ends here too - to be fixed.)
1883 YMFDBGX("ymf_ioctl: cmd 0x%x unknown\n", cmd
);
1891 * We use upper part of the minor to distinguish between soundcards.
1892 * Channels are opened with a clone open.
1894 static int ymf_open(struct inode
*inode
, struct file
*file
)
1896 struct list_head
*list
;
1897 ymfpci_t
*unit
= NULL
;
1899 struct ymf_state
*state
;
1902 minor
= iminor(inode
);
1903 if ((minor
& 0x0F) == 3) { /* /dev/dspN */
1909 unit
= NULL
; /* gcc warns */
1910 spin_lock(&ymf_devs_lock
);
1911 list_for_each(list
, &ymf_devs
) {
1912 unit
= list_entry(list
, ymfpci_t
, ymf_devs
);
1913 if (((unit
->dev_audio
^ minor
) & ~0x0F) == 0)
1916 spin_unlock(&ymf_devs_lock
);
1920 mutex_lock(&unit
->open_mutex
);
1922 if ((state
= ymf_state_alloc(unit
)) == NULL
) {
1923 mutex_unlock(&unit
->open_mutex
);
1926 list_add_tail(&state
->chain
, &unit
->states
);
1928 file
->private_data
= state
;
1931 * ymf_read and ymf_write that we borrowed from cs46xx
1932 * allocate buffers with prog_dmabuf(). We call prog_dmabuf
1933 * here so that in case of DMA memory exhaustion open
1934 * fails rather than write.
1936 * XXX prog_dmabuf allocates voice. Should allocate explicitly, above.
1938 if (file
->f_mode
& FMODE_WRITE
) {
1939 if (!state
->wpcm
.dmabuf
.ready
) {
1940 if ((err
= prog_dmabuf(state
, 0)) != 0) {
1945 if (file
->f_mode
& FMODE_READ
) {
1946 if (!state
->rpcm
.dmabuf
.ready
) {
1947 if ((err
= prog_dmabuf(state
, 1)) != 0) {
1953 #if 0 /* test if interrupts work */
1954 ymfpci_writew(unit
, YDSXGR_TIMERCOUNT
, 0xfffe); /* ~ 680ms */
1955 ymfpci_writeb(unit
, YDSXGR_TIMERCTRL
,
1956 (YDSXGR_TIMERCTRL_TEN
|YDSXGR_TIMERCTRL_TIEN
));
1958 mutex_unlock(&unit
->open_mutex
);
1960 return nonseekable_open(inode
, file
);
1964 * XXX Broken custom: "goto out_xxx" in other place is
1965 * a nestable exception, but here it is not nestable due to semaphore.
1966 * XXX Doubtful technique of self-describing objects....
1968 dealloc_dmabuf(unit
, &state
->wpcm
.dmabuf
);
1969 dealloc_dmabuf(unit
, &state
->rpcm
.dmabuf
);
1970 ymf_pcm_free_substream(&state
->wpcm
);
1971 ymf_pcm_free_substream(&state
->rpcm
);
1973 list_del(&state
->chain
);
1976 mutex_unlock(&unit
->open_mutex
);
1980 static int ymf_release(struct inode
*inode
, struct file
*file
)
1982 struct ymf_state
*state
= (struct ymf_state
*)file
->private_data
;
1983 ymfpci_t
*unit
= state
->unit
;
1985 #if 0 /* test if interrupts work */
1986 ymfpci_writeb(unit
, YDSXGR_TIMERCTRL
, 0);
1989 mutex_lock(&unit
->open_mutex
);
1992 * XXX Solve the case of O_NONBLOCK close - don't deallocate here.
1993 * Deallocate when unloading the driver and we can wait.
1995 ymf_wait_dac(state
);
1996 ymf_stop_adc(state
); /* fortunately, it's immediate */
1997 dealloc_dmabuf(unit
, &state
->wpcm
.dmabuf
);
1998 dealloc_dmabuf(unit
, &state
->rpcm
.dmabuf
);
1999 ymf_pcm_free_substream(&state
->wpcm
);
2000 ymf_pcm_free_substream(&state
->rpcm
);
2002 list_del(&state
->chain
);
2003 file
->private_data
= NULL
; /* Can you tell I programmed Solaris */
2006 mutex_unlock(&unit
->open_mutex
);
2012 * Mixer operations are based on cs46xx.
2014 static int ymf_open_mixdev(struct inode
*inode
, struct file
*file
)
2016 int minor
= iminor(inode
);
2017 struct list_head
*list
;
2021 spin_lock(&ymf_devs_lock
);
2022 list_for_each(list
, &ymf_devs
) {
2023 unit
= list_entry(list
, ymfpci_t
, ymf_devs
);
2024 for (i
= 0; i
< NR_AC97
; i
++) {
2025 if (unit
->ac97_codec
[i
] != NULL
&&
2026 unit
->ac97_codec
[i
]->dev_mixer
== minor
) {
2027 spin_unlock(&ymf_devs_lock
);
2032 spin_unlock(&ymf_devs_lock
);
2036 file
->private_data
= unit
->ac97_codec
[i
];
2038 return nonseekable_open(inode
, file
);
2041 static int ymf_ioctl_mixdev(struct inode
*inode
, struct file
*file
,
2042 unsigned int cmd
, unsigned long arg
)
2044 struct ac97_codec
*codec
= (struct ac97_codec
*)file
->private_data
;
2046 return codec
->mixer_ioctl(codec
, cmd
, arg
);
2049 static int ymf_release_mixdev(struct inode
*inode
, struct file
*file
)
2054 static /*const*/ struct file_operations ymf_fops
= {
2055 .owner
= THIS_MODULE
,
2056 .llseek
= no_llseek
,
2063 .release
= ymf_release
,
2066 static /*const*/ struct file_operations ymf_mixer_fops
= {
2067 .owner
= THIS_MODULE
,
2068 .llseek
= no_llseek
,
2069 .ioctl
= ymf_ioctl_mixdev
,
2070 .open
= ymf_open_mixdev
,
2071 .release
= ymf_release_mixdev
,
2077 static int ymf_suspend(struct pci_dev
*pcidev
, pm_message_t unused
)
2079 struct ymf_unit
*unit
= pci_get_drvdata(pcidev
);
2080 unsigned long flags
;
2081 struct ymf_dmabuf
*dmabuf
;
2082 struct list_head
*p
;
2083 struct ymf_state
*state
;
2084 struct ac97_codec
*codec
;
2087 spin_lock_irqsave(&unit
->reg_lock
, flags
);
2089 unit
->suspended
= 1;
2091 for (i
= 0; i
< NR_AC97
; i
++) {
2092 if ((codec
= unit
->ac97_codec
[i
]) != NULL
)
2093 ac97_save_state(codec
);
2096 list_for_each(p
, &unit
->states
) {
2097 state
= list_entry(p
, struct ymf_state
, chain
);
2099 dmabuf
= &state
->wpcm
.dmabuf
;
2100 dmabuf
->hwptr
= dmabuf
->swptr
= 0;
2101 dmabuf
->total_bytes
= 0;
2104 dmabuf
= &state
->rpcm
.dmabuf
;
2105 dmabuf
->hwptr
= dmabuf
->swptr
= 0;
2106 dmabuf
->total_bytes
= 0;
2110 ymfpci_writel(unit
, YDSXGR_NATIVEDACOUTVOL
, 0);
2111 ymfpci_disable_dsp(unit
);
2113 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
2118 static int ymf_resume(struct pci_dev
*pcidev
)
2120 struct ymf_unit
*unit
= pci_get_drvdata(pcidev
);
2121 unsigned long flags
;
2122 struct list_head
*p
;
2123 struct ymf_state
*state
;
2124 struct ac97_codec
*codec
;
2127 ymfpci_aclink_reset(unit
->pci
);
2128 ymfpci_codec_ready(unit
, 0, 1); /* prints diag if not ready. */
2130 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2131 /* XXX At this time the legacy registers are probably deprogrammed. */
2134 ymfpci_download_image(unit
);
2138 spin_lock_irqsave(&unit
->reg_lock
, flags
);
2140 if (unit
->start_count
) {
2141 ymfpci_writel(unit
, YDSXGR_MODE
, 3);
2142 unit
->active_bank
= ymfpci_readl(unit
, YDSXGR_CTRLSELECT
) & 1;
2145 for (i
= 0; i
< NR_AC97
; i
++) {
2146 if ((codec
= unit
->ac97_codec
[i
]) != NULL
)
2147 ac97_restore_state(codec
);
2150 unit
->suspended
= 0;
2151 list_for_each(p
, &unit
->states
) {
2152 state
= list_entry(p
, struct ymf_state
, chain
);
2153 wake_up(&state
->wpcm
.dmabuf
.wait
);
2154 wake_up(&state
->rpcm
.dmabuf
.wait
);
2157 spin_unlock_irqrestore(&unit
->reg_lock
, flags
);
2162 * initialization routines
2165 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2167 static int ymfpci_setup_legacy(ymfpci_t
*unit
, struct pci_dev
*pcidev
)
2170 int mpuio
= -1, oplio
= -1;
2172 switch (unit
->iomidi
) {
2188 switch (unit
->iosynth
) {
2204 if (mpuio
>= 0 || oplio
>= 0) {
2205 /* 0x0020: 1 - 10 bits of I/O address decoded, 0 - 16 bits. */
2207 pci_write_config_word(pcidev
, PCIR_LEGCTRL
, v
);
2209 switch (pcidev
->device
) {
2210 case PCI_DEVICE_ID_YAMAHA_724
:
2211 case PCI_DEVICE_ID_YAMAHA_740
:
2212 case PCI_DEVICE_ID_YAMAHA_724F
:
2213 case PCI_DEVICE_ID_YAMAHA_740C
:
2215 if (mpuio
>= 0) { v
|= mpuio
<<4; }
2216 if (oplio
>= 0) { v
|= oplio
; }
2217 pci_write_config_word(pcidev
, PCIR_ELEGCTRL
, v
);
2220 case PCI_DEVICE_ID_YAMAHA_744
:
2221 case PCI_DEVICE_ID_YAMAHA_754
:
2223 pci_write_config_word(pcidev
, PCIR_ELEGCTRL
, v
);
2225 pci_write_config_word(pcidev
, PCIR_OPLADR
, unit
->iosynth
);
2228 pci_write_config_word(pcidev
, PCIR_MPUADR
, unit
->iomidi
);
2233 printk(KERN_ERR
"ymfpci: Unknown device ID: 0x%x\n",
2241 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2243 static void ymfpci_aclink_reset(struct pci_dev
* pci
)
2248 * In the 744, 754 only 0x01 exists, 0x02 is undefined.
2249 * It does not seem to hurt to trip both regardless of revision.
2251 pci_read_config_byte(pci
, PCIR_DSXGCTRL
, &cmd
);
2252 pci_write_config_byte(pci
, PCIR_DSXGCTRL
, cmd
& 0xfc);
2253 pci_write_config_byte(pci
, PCIR_DSXGCTRL
, cmd
| 0x03);
2254 pci_write_config_byte(pci
, PCIR_DSXGCTRL
, cmd
& 0xfc);
2256 pci_write_config_word(pci
, PCIR_DSXPWRCTRL1
, 0);
2257 pci_write_config_word(pci
, PCIR_DSXPWRCTRL2
, 0);
2260 static void ymfpci_enable_dsp(ymfpci_t
*codec
)
2262 ymfpci_writel(codec
, YDSXGR_CONFIG
, 0x00000001);
2265 static void ymfpci_disable_dsp(ymfpci_t
*codec
)
2270 val
= ymfpci_readl(codec
, YDSXGR_CONFIG
);
2272 ymfpci_writel(codec
, YDSXGR_CONFIG
, 0x00000000);
2273 while (timeout
-- > 0) {
2274 val
= ymfpci_readl(codec
, YDSXGR_STATUS
);
2275 if ((val
& 0x00000002) == 0)
2280 #include "ymfpci_image.h"
2282 static void ymfpci_download_image(ymfpci_t
*codec
)
2287 ymfpci_writel(codec
, YDSXGR_NATIVEDACOUTVOL
, 0x00000000);
2288 ymfpci_disable_dsp(codec
);
2289 ymfpci_writel(codec
, YDSXGR_MODE
, 0x00010000);
2290 ymfpci_writel(codec
, YDSXGR_MODE
, 0x00000000);
2291 ymfpci_writel(codec
, YDSXGR_MAPOFREC
, 0x00000000);
2292 ymfpci_writel(codec
, YDSXGR_MAPOFEFFECT
, 0x00000000);
2293 ymfpci_writel(codec
, YDSXGR_PLAYCTRLBASE
, 0x00000000);
2294 ymfpci_writel(codec
, YDSXGR_RECCTRLBASE
, 0x00000000);
2295 ymfpci_writel(codec
, YDSXGR_EFFCTRLBASE
, 0x00000000);
2296 ctrl
= ymfpci_readw(codec
, YDSXGR_GLOBALCTRL
);
2297 ymfpci_writew(codec
, YDSXGR_GLOBALCTRL
, ctrl
& ~0x0007);
2299 /* setup DSP instruction code */
2300 for (i
= 0; i
< YDSXG_DSPLENGTH
/ 4; i
++)
2301 ymfpci_writel(codec
, YDSXGR_DSPINSTRAM
+ (i
<< 2), DspInst
[i
]);
2303 switch (codec
->pci
->device
) {
2304 case PCI_DEVICE_ID_YAMAHA_724F
:
2305 case PCI_DEVICE_ID_YAMAHA_740C
:
2306 case PCI_DEVICE_ID_YAMAHA_744
:
2307 case PCI_DEVICE_ID_YAMAHA_754
:
2315 /* setup control instruction code */
2316 for (i
= 0; i
< YDSXG_CTRLLENGTH
/ 4; i
++)
2317 ymfpci_writel(codec
, YDSXGR_CTRLINSTRAM
+ (i
<< 2), CntrlInst1E
[i
]);
2319 for (i
= 0; i
< YDSXG_CTRLLENGTH
/ 4; i
++)
2320 ymfpci_writel(codec
, YDSXGR_CTRLINSTRAM
+ (i
<< 2), CntrlInst
[i
]);
2323 ymfpci_enable_dsp(codec
);
2325 /* 0.02s sounds not too bad, we may do schedule_timeout() later. */
2326 mdelay(20); /* seems we need some delay after downloading image.. */
2329 static int ymfpci_memalloc(ymfpci_t
*codec
)
2331 unsigned int playback_ctrl_size
;
2332 unsigned int bank_size_playback
;
2333 unsigned int bank_size_capture
;
2334 unsigned int bank_size_effect
;
2341 playback_ctrl_size
= 4 + 4 * YDSXG_PLAYBACK_VOICES
;
2342 bank_size_playback
= ymfpci_readl(codec
, YDSXGR_PLAYCTRLSIZE
) << 2;
2343 bank_size_capture
= ymfpci_readl(codec
, YDSXGR_RECCTRLSIZE
) << 2;
2344 bank_size_effect
= ymfpci_readl(codec
, YDSXGR_EFFCTRLSIZE
) << 2;
2345 codec
->work_size
= YDSXG_DEFAULT_WORK_SIZE
;
2347 size
= ((playback_ctrl_size
+ 0x00ff) & ~0x00ff) +
2348 ((bank_size_playback
* 2 * YDSXG_PLAYBACK_VOICES
+ 0xff) & ~0xff) +
2349 ((bank_size_capture
* 2 * YDSXG_CAPTURE_VOICES
+ 0xff) & ~0xff) +
2350 ((bank_size_effect
* 2 * YDSXG_EFFECT_VOICES
+ 0xff) & ~0xff) +
2353 ptr
= pci_alloc_consistent(codec
->pci
, size
+ 0xff, &pba
);
2356 codec
->dma_area_va
= ptr
;
2357 codec
->dma_area_ba
= pba
;
2358 codec
->dma_area_size
= size
+ 0xff;
2360 off
= (unsigned long)ptr
& 0xff;
2367 * Hardware requires only ptr[playback_ctrl_size] zeroed,
2368 * but in our judgement it is a wrong kind of savings, so clear it all.
2370 memset(ptr
, 0, size
);
2372 codec
->ctrl_playback
= (u32
*)ptr
;
2373 codec
->ctrl_playback_ba
= pba
;
2374 codec
->ctrl_playback
[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES
);
2375 ptr
+= (playback_ctrl_size
+ 0x00ff) & ~0x00ff;
2376 pba
+= (playback_ctrl_size
+ 0x00ff) & ~0x00ff;
2379 for (voice
= 0; voice
< YDSXG_PLAYBACK_VOICES
; voice
++) {
2380 codec
->voices
[voice
].number
= voice
;
2381 codec
->voices
[voice
].bank
=
2382 (ymfpci_playback_bank_t
*) (ptr
+ off
);
2383 codec
->voices
[voice
].bank_ba
= pba
+ off
;
2384 off
+= 2 * bank_size_playback
; /* 2 banks */
2386 off
= (off
+ 0xff) & ~0xff;
2391 codec
->bank_base_capture
= pba
;
2392 for (voice
= 0; voice
< YDSXG_CAPTURE_VOICES
; voice
++)
2393 for (bank
= 0; bank
< 2; bank
++) {
2394 codec
->bank_capture
[voice
][bank
] =
2395 (ymfpci_capture_bank_t
*) (ptr
+ off
);
2396 off
+= bank_size_capture
;
2398 off
= (off
+ 0xff) & ~0xff;
2403 codec
->bank_base_effect
= pba
;
2404 for (voice
= 0; voice
< YDSXG_EFFECT_VOICES
; voice
++)
2405 for (bank
= 0; bank
< 2; bank
++) {
2406 codec
->bank_effect
[voice
][bank
] =
2407 (ymfpci_effect_bank_t
*) (ptr
+ off
);
2408 off
+= bank_size_effect
;
2410 off
= (off
+ 0xff) & ~0xff;
2414 codec
->work_base
= pba
;
2419 static void ymfpci_memfree(ymfpci_t
*codec
)
2421 ymfpci_writel(codec
, YDSXGR_PLAYCTRLBASE
, 0);
2422 ymfpci_writel(codec
, YDSXGR_RECCTRLBASE
, 0);
2423 ymfpci_writel(codec
, YDSXGR_EFFCTRLBASE
, 0);
2424 ymfpci_writel(codec
, YDSXGR_WORKBASE
, 0);
2425 ymfpci_writel(codec
, YDSXGR_WORKSIZE
, 0);
2426 pci_free_consistent(codec
->pci
,
2427 codec
->dma_area_size
, codec
->dma_area_va
, codec
->dma_area_ba
);
2430 static void ymf_memload(ymfpci_t
*unit
)
2433 ymfpci_writel(unit
, YDSXGR_PLAYCTRLBASE
, unit
->ctrl_playback_ba
);
2434 ymfpci_writel(unit
, YDSXGR_RECCTRLBASE
, unit
->bank_base_capture
);
2435 ymfpci_writel(unit
, YDSXGR_EFFCTRLBASE
, unit
->bank_base_effect
);
2436 ymfpci_writel(unit
, YDSXGR_WORKBASE
, unit
->work_base
);
2437 ymfpci_writel(unit
, YDSXGR_WORKSIZE
, unit
->work_size
>> 2);
2439 /* S/PDIF output initialization */
2440 ymfpci_writew(unit
, YDSXGR_SPDIFOUTCTRL
, 0);
2441 ymfpci_writew(unit
, YDSXGR_SPDIFOUTSTATUS
,
2442 SND_PCM_AES0_CON_EMPHASIS_NONE
|
2443 (SND_PCM_AES1_CON_ORIGINAL
<< 8) |
2444 (SND_PCM_AES1_CON_PCM_CODER
<< 8));
2446 /* S/PDIF input initialization */
2447 ymfpci_writew(unit
, YDSXGR_SPDIFINCTRL
, 0);
2449 /* move this volume setup to mixer */
2450 ymfpci_writel(unit
, YDSXGR_NATIVEDACOUTVOL
, 0x3fff3fff);
2451 ymfpci_writel(unit
, YDSXGR_BUF441OUTVOL
, 0);
2452 ymfpci_writel(unit
, YDSXGR_NATIVEADCINVOL
, 0x3fff3fff);
2453 ymfpci_writel(unit
, YDSXGR_NATIVEDACINVOL
, 0x3fff3fff);
2456 static int ymf_ac97_init(ymfpci_t
*unit
, int num_ac97
)
2458 struct ac97_codec
*codec
;
2461 if ((codec
= ac97_alloc_codec()) == NULL
)
2464 /* initialize some basic codec information, other fields will be filled
2465 in ac97_probe_codec */
2466 codec
->private_data
= unit
;
2467 codec
->id
= num_ac97
;
2469 codec
->codec_read
= ymfpci_codec_read
;
2470 codec
->codec_write
= ymfpci_codec_write
;
2472 if (ac97_probe_codec(codec
) == 0) {
2473 printk(KERN_ERR
"ymfpci: ac97_probe_codec failed\n");
2477 eid
= ymfpci_codec_read(codec
, AC97_EXTENDED_ID
);
2479 printk(KERN_WARNING
"ymfpci: no codec attached ?\n");
2483 unit
->ac97_features
= eid
;
2485 if ((codec
->dev_mixer
= register_sound_mixer(&ymf_mixer_fops
, -1)) < 0) {
2486 printk(KERN_ERR
"ymfpci: couldn't register mixer!\n");
2490 unit
->ac97_codec
[num_ac97
] = codec
;
2494 ac97_release_codec(codec
);
2498 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2501 static int synth_io
;
2502 module_param(mpu_io
, int, 0);
2503 module_param(synth_io
, int, 0);
2505 static int mpu_io
= 0x330;
2506 static int synth_io
= 0x388;
2508 static int assigned
;
2509 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2511 static int __devinit
ymf_probe_one(struct pci_dev
*pcidev
, const struct pci_device_id
*ent
)
2519 if ((err
= pci_enable_device(pcidev
)) != 0) {
2520 printk(KERN_ERR
"ymfpci: pci_enable_device failed\n");
2523 base
= pci_resource_start(pcidev
, 0);
2525 if ((codec
= kmalloc(sizeof(ymfpci_t
), GFP_KERNEL
)) == NULL
) {
2526 printk(KERN_ERR
"ymfpci: no core\n");
2529 memset(codec
, 0, sizeof(*codec
));
2531 spin_lock_init(&codec
->reg_lock
);
2532 spin_lock_init(&codec
->voice_lock
);
2533 spin_lock_init(&codec
->ac97_lock
);
2534 mutex_init(&codec
->open_mutex
);
2535 INIT_LIST_HEAD(&codec
->states
);
2536 codec
->pci
= pcidev
;
2538 pci_read_config_byte(pcidev
, PCI_REVISION_ID
, &codec
->rev
);
2540 if (request_mem_region(base
, 0x8000, "ymfpci") == NULL
) {
2541 printk(KERN_ERR
"ymfpci: unable to request mem region\n");
2545 if ((codec
->reg_area_virt
= ioremap(base
, 0x8000)) == NULL
) {
2546 printk(KERN_ERR
"ymfpci: unable to map registers\n");
2547 goto out_release_region
;
2550 pci_set_master(pcidev
);
2552 printk(KERN_INFO
"ymfpci: %s at 0x%lx IRQ %d\n",
2553 (char *)ent
->driver_data
, base
, pcidev
->irq
);
2555 ymfpci_aclink_reset(pcidev
);
2556 if (ymfpci_codec_ready(codec
, 0, 1) < 0)
2559 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2560 if (assigned
== 0) {
2561 codec
->iomidi
= mpu_io
;
2562 codec
->iosynth
= synth_io
;
2563 if (ymfpci_setup_legacy(codec
, pcidev
) < 0)
2569 ymfpci_download_image(codec
);
2571 if (ymfpci_memalloc(codec
) < 0)
2572 goto out_disable_dsp
;
2575 if (request_irq(pcidev
->irq
, ymf_interrupt
, IRQF_SHARED
, "ymfpci", codec
) != 0) {
2576 printk(KERN_ERR
"ymfpci: unable to request IRQ %d\n",
2581 /* register /dev/dsp */
2582 if ((codec
->dev_audio
= register_sound_dsp(&ymf_fops
, -1)) < 0) {
2583 printk(KERN_ERR
"ymfpci: unable to register dsp\n");
2588 * Poke just the primary for the moment.
2590 if ((err
= ymf_ac97_init(codec
, 0)) != 0)
2591 goto out_unregister_sound_dsp
;
2593 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2594 codec
->opl3_data
.name
= "ymfpci";
2595 codec
->mpu_data
.name
= "ymfpci";
2597 codec
->opl3_data
.io_base
= codec
->iosynth
;
2598 codec
->opl3_data
.irq
= -1;
2600 codec
->mpu_data
.io_base
= codec
->iomidi
;
2601 codec
->mpu_data
.irq
= -1; /* May be different from our PCI IRQ. */
2603 if (codec
->iomidi
) {
2604 if (!probe_uart401(&codec
->mpu_data
, THIS_MODULE
)) {
2605 codec
->iomidi
= 0; /* XXX kludge */
2608 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2610 /* put it into driver list */
2611 spin_lock(&ymf_devs_lock
);
2612 list_add_tail(&codec
->ymf_devs
, &ymf_devs
);
2613 spin_unlock(&ymf_devs_lock
);
2614 pci_set_drvdata(pcidev
, codec
);
2618 out_unregister_sound_dsp
:
2619 unregister_sound_dsp(codec
->dev_audio
);
2621 free_irq(pcidev
->irq
, codec
);
2623 ymfpci_memfree(codec
);
2625 ymfpci_disable_dsp(codec
);
2626 ctrl
= ymfpci_readw(codec
, YDSXGR_GLOBALCTRL
);
2627 ymfpci_writew(codec
, YDSXGR_GLOBALCTRL
, ctrl
& ~0x0007);
2628 ymfpci_writel(codec
, YDSXGR_STATUS
, ~0);
2630 iounmap(codec
->reg_area_virt
);
2632 release_mem_region(pci_resource_start(pcidev
, 0), 0x8000);
2634 if (codec
->ac97_codec
[0])
2635 ac97_release_codec(codec
->ac97_codec
[0]);
2639 static void __devexit
ymf_remove_one(struct pci_dev
*pcidev
)
2642 ymfpci_t
*codec
= pci_get_drvdata(pcidev
);
2644 /* remove from list of devices */
2645 spin_lock(&ymf_devs_lock
);
2646 list_del(&codec
->ymf_devs
);
2647 spin_unlock(&ymf_devs_lock
);
2649 unregister_sound_mixer(codec
->ac97_codec
[0]->dev_mixer
);
2650 ac97_release_codec(codec
->ac97_codec
[0]);
2651 unregister_sound_dsp(codec
->dev_audio
);
2652 free_irq(pcidev
->irq
, codec
);
2653 ymfpci_memfree(codec
);
2654 ymfpci_writel(codec
, YDSXGR_STATUS
, ~0);
2655 ymfpci_disable_dsp(codec
);
2656 ctrl
= ymfpci_readw(codec
, YDSXGR_GLOBALCTRL
);
2657 ymfpci_writew(codec
, YDSXGR_GLOBALCTRL
, ctrl
& ~0x0007);
2658 iounmap(codec
->reg_area_virt
);
2659 release_mem_region(pci_resource_start(pcidev
, 0), 0x8000);
2660 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2661 if (codec
->iomidi
) {
2662 unload_uart401(&codec
->mpu_data
);
2664 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2667 MODULE_AUTHOR("Jaroslav Kysela");
2668 MODULE_DESCRIPTION("Yamaha YMF7xx PCI Audio");
2669 MODULE_LICENSE("GPL");
2671 static struct pci_driver ymfpci_driver
= {
2673 .id_table
= ymf_id_tbl
,
2674 .probe
= ymf_probe_one
,
2675 .remove
= __devexit_p(ymf_remove_one
),
2676 .suspend
= ymf_suspend
,
2677 .resume
= ymf_resume
2680 static int __init
ymf_init_module(void)
2682 return pci_register_driver(&ymfpci_driver
);
2685 static void __exit
ymf_cleanup_module (void)
2687 pci_unregister_driver(&ymfpci_driver
);
2690 module_init(ymf_init_module
);
2691 module_exit(ymf_cleanup_module
);