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/config.h>
55 #include <linux/module.h>
56 #include <linux/init.h>
57 #include <linux/interrupt.h>
58 #include <linux/ioport.h>
59 #include <linux/delay.h>
60 #include <linux/pci.h>
61 #include <linux/slab.h>
62 #include <linux/poll.h>
63 #include <linux/soundcard.h>
64 #include <linux/ac97_codec.h>
65 #include <linux/sound.h>
69 #include <asm/uaccess.h>
71 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
72 # include "sound_config.h"
78 * I do not believe in debug levels as I never can guess what
79 * part of the code is going to be problematic in the future.
80 * Don't forget to run your klogd with -c 8.
82 * Example (do not remove):
83 * #define YMFDBG(fmt, arg...) do{ printk(KERN_DEBUG fmt, ##arg); }while(0)
85 #define YMFDBGW(fmt, arg...) /* */ /* write counts */
86 #define YMFDBGI(fmt, arg...) /* */ /* interrupts */
87 #define YMFDBGX(fmt, arg...) /* */ /* ioctl */
89 static int ymf_playback_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
90 static void ymf_capture_trigger(ymfpci_t *unit, struct ymf_pcm *ypcm, int cmd);
91 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice);
92 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank);
93 static int ymf_playback_prepare(struct ymf_state *state);
94 static int ymf_capture_prepare(struct ymf_state *state);
95 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit);
97 static void ymfpci_aclink_reset(struct pci_dev * pci);
98 static void ymfpci_disable_dsp(ymfpci_t *unit);
99 static void ymfpci_download_image(ymfpci_t *codec);
100 static void ymf_memload(ymfpci_t *unit);
102 static spinlock_t ymf_devs_lock = SPIN_LOCK_UNLOCKED;
103 static LIST_HEAD(ymf_devs);
109 static struct pci_device_id ymf_id_tbl[] = {
110 #define DEV(v, d, data) \
111 { PCI_VENDOR_ID_##v, PCI_DEVICE_ID_##v##_##d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (unsigned long)data }
112 DEV (YAMAHA, 724, "YMF724"),
113 DEV (YAMAHA, 724F, "YMF724F"),
114 DEV (YAMAHA, 740, "YMF740"),
115 DEV (YAMAHA, 740C, "YMF740C"),
116 DEV (YAMAHA, 744, "YMF744"),
117 DEV (YAMAHA, 754, "YMF754"),
121 MODULE_DEVICE_TABLE(pci, ymf_id_tbl);
124 * common I/O routines
127 static inline u8 ymfpci_readb(ymfpci_t *codec, u32 offset)
129 return readb(codec->reg_area_virt + offset);
132 static inline void ymfpci_writeb(ymfpci_t *codec, u32 offset, u8 val)
134 writeb(val, codec->reg_area_virt + offset);
137 static inline u16 ymfpci_readw(ymfpci_t *codec, u32 offset)
139 return readw(codec->reg_area_virt + offset);
142 static inline void ymfpci_writew(ymfpci_t *codec, u32 offset, u16 val)
144 writew(val, codec->reg_area_virt + offset);
147 static inline u32 ymfpci_readl(ymfpci_t *codec, u32 offset)
149 return readl(codec->reg_area_virt + offset);
152 static inline void ymfpci_writel(ymfpci_t *codec, u32 offset, u32 val)
154 writel(val, codec->reg_area_virt + offset);
157 static int ymfpci_codec_ready(ymfpci_t *codec, int secondary, int sched)
159 signed long end_time;
160 u32 reg = secondary ? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR;
162 end_time = jiffies + 3 * (HZ / 4);
164 if ((ymfpci_readw(codec, reg) & 0x8000) == 0)
167 set_current_state(TASK_UNINTERRUPTIBLE);
170 } while (end_time - (signed long)jiffies >= 0);
171 printk(KERN_ERR "ymfpci_codec_ready: codec %i is not ready [0x%x]\n",
172 secondary, ymfpci_readw(codec, reg));
176 static void ymfpci_codec_write(struct ac97_codec *dev, u8 reg, u16 val)
178 ymfpci_t *codec = dev->private_data;
181 spin_lock(&codec->ac97_lock);
182 /* XXX Do make use of dev->id */
183 ymfpci_codec_ready(codec, 0, 0);
184 cmd = ((YDSXG_AC97WRITECMD | reg) << 16) | val;
185 ymfpci_writel(codec, YDSXGR_AC97CMDDATA, cmd);
186 spin_unlock(&codec->ac97_lock);
189 static u16 _ymfpci_codec_read(ymfpci_t *unit, u8 reg)
193 if (ymfpci_codec_ready(unit, 0, 0))
195 ymfpci_writew(unit, YDSXGR_AC97CMDADR, YDSXG_AC97READCMD | reg);
196 if (ymfpci_codec_ready(unit, 0, 0))
198 if (unit->pci->device == PCI_DEVICE_ID_YAMAHA_744 && unit->rev < 2) {
199 for (i = 0; i < 600; i++)
200 ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
202 return ymfpci_readw(unit, YDSXGR_PRISTATUSDATA);
205 static u16 ymfpci_codec_read(struct ac97_codec *dev, u8 reg)
207 ymfpci_t *unit = dev->private_data;
210 spin_lock(&unit->ac97_lock);
211 ret = _ymfpci_codec_read(unit, reg);
212 spin_unlock(&unit->ac97_lock);
222 * Calculate the actual sampling rate relatetively to the base clock (48kHz).
224 static u32 ymfpci_calc_delta(u32 rate)
227 case 8000: return 0x02aaab00;
228 case 11025: return 0x03accd00;
229 case 16000: return 0x05555500;
230 case 22050: return 0x07599a00;
231 case 32000: return 0x0aaaab00;
232 case 44100: return 0x0eb33300;
233 default: return ((rate << 16) / 48000) << 12;
237 static u32 def_rate[8] = {
238 100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
241 static u32 ymfpci_calc_lpfK(u32 rate)
244 static u32 val[8] = {
245 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
246 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
250 return 0x40000000; /* FIXME: What's the right value? */
251 for (i = 0; i < 8; i++)
252 if (rate <= def_rate[i])
257 static u32 ymfpci_calc_lpfQ(u32 rate)
260 static u32 val[8] = {
261 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
262 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
267 for (i = 0; i < 8; i++)
268 if (rate <= def_rate[i])
273 static u32 ymf_calc_lend(u32 rate)
275 return (rate * YMF_SAMPF) / 48000;
279 * We ever allow only a few formats, but let's be generic, for smaller surprise.
281 static int ymf_pcm_format_width(int format)
283 static int mask16 = AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE;
285 if ((format & (format-1)) != 0) {
286 printk(KERN_ERR "ymfpci: format 0x%x is not a power of 2\n", format);
290 if (format == AFMT_IMA_ADPCM) return 4;
291 if ((format & mask16) != 0) return 16;
295 static void ymf_pcm_update_shift(struct ymf_pcm_format *f)
300 if (ymf_pcm_format_width(f->format) == 16)
304 /* Are you sure 32K is not too much? See if mpg123 skips on loaded systems. */
305 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
306 #define DMABUF_MINORDER 1
309 * Allocate DMA buffer
311 static int alloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
316 struct page *map, *mapend;
318 /* alloc as big a chunk as we can */
319 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
320 rawbuf = pci_alloc_consistent(unit->pci, PAGE_SIZE << order, &dma_addr);
328 printk(KERN_DEBUG "ymfpci: allocated %ld (order = %d) bytes at %p\n",
329 PAGE_SIZE << order, order, rawbuf);
332 dmabuf->ready = dmabuf->mapped = 0;
333 dmabuf->rawbuf = rawbuf;
334 dmabuf->dma_addr = dma_addr;
335 dmabuf->buforder = order;
337 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
338 mapend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
339 for (map = virt_to_page(rawbuf); map <= mapend; map++)
340 set_bit(PG_reserved, &map->flags);
348 static void dealloc_dmabuf(ymfpci_t *unit, struct ymf_dmabuf *dmabuf)
350 struct page *map, *mapend;
352 if (dmabuf->rawbuf) {
353 /* undo marking the pages as reserved */
354 mapend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
355 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
356 clear_bit(PG_reserved, &map->flags);
358 pci_free_consistent(unit->pci, PAGE_SIZE << dmabuf->buforder,
359 dmabuf->rawbuf, dmabuf->dma_addr);
361 dmabuf->rawbuf = NULL;
362 dmabuf->mapped = dmabuf->ready = 0;
365 static int prog_dmabuf(struct ymf_state *state, int rec)
367 struct ymf_dmabuf *dmabuf;
371 int redzone, redfrags;
374 w_16 = ymf_pcm_format_width(state->format.format) == 16;
375 dmabuf = rec ? &state->rpcm.dmabuf : &state->wpcm.dmabuf;
377 spin_lock_irqsave(&state->unit->reg_lock, flags);
378 dmabuf->hwptr = dmabuf->swptr = 0;
379 dmabuf->total_bytes = 0;
381 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
383 /* allocate DMA buffer if not allocated yet */
385 if ((ret = alloc_dmabuf(state->unit, dmabuf)))
389 * Create fake fragment sizes and numbers for OSS ioctls.
390 * Import what Doom might have set with SNDCTL_DSP_SETFRAGMENT.
392 bufsize = PAGE_SIZE << dmabuf->buforder;
393 /* By default we give 4 big buffers. */
394 dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
395 if (dmabuf->ossfragshift > 3 &&
396 dmabuf->ossfragshift < dmabuf->fragshift) {
397 /* If OSS set smaller fragments, give more smaller buffers. */
398 dmabuf->fragshift = dmabuf->ossfragshift;
400 dmabuf->fragsize = 1 << dmabuf->fragshift;
402 dmabuf->numfrag = bufsize >> dmabuf->fragshift;
403 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
405 if (dmabuf->ossmaxfrags >= 2) {
406 redzone = ymf_calc_lend(state->format.rate);
407 redzone <<= state->format.shift;
409 redfrags = (redzone + dmabuf->fragsize-1) >> dmabuf->fragshift;
411 if (dmabuf->ossmaxfrags + redfrags < dmabuf->numfrag) {
412 dmabuf->numfrag = dmabuf->ossmaxfrags + redfrags;
413 dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
417 memset(dmabuf->rawbuf, w_16 ? 0 : 0x80, dmabuf->dmasize);
420 * Now set up the ring
423 /* XXX ret = rec? cap_pre(): pbk_pre(); */
424 spin_lock_irqsave(&state->unit->voice_lock, flags);
426 if ((ret = ymf_capture_prepare(state)) != 0) {
427 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
431 if ((ret = ymf_playback_prepare(state)) != 0) {
432 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
436 spin_unlock_irqrestore(&state->unit->voice_lock, flags);
438 /* set the ready flag for the dma buffer (this comment is not stupid) */
442 printk(KERN_DEBUG "prog_dmabuf: rate %d format 0x%x,"
443 " numfrag %d fragsize %d dmasize %d\n",
444 state->format.rate, state->format.format, dmabuf->numfrag,
445 dmabuf->fragsize, dmabuf->dmasize);
451 static void ymf_start_dac(struct ymf_state *state)
453 ymf_playback_trigger(state->unit, &state->wpcm, 1);
456 // static void ymf_start_adc(struct ymf_state *state)
458 // ymf_capture_trigger(state->unit, &state->rpcm, 1);
462 * Wait until output is drained.
463 * This does not kill the hardware for the sake of ioctls.
465 static void ymf_wait_dac(struct ymf_state *state)
467 struct ymf_unit *unit = state->unit;
468 struct ymf_pcm *ypcm = &state->wpcm;
469 DECLARE_WAITQUEUE(waita, current);
472 add_wait_queue(&ypcm->dmabuf.wait, &waita);
474 spin_lock_irqsave(&unit->reg_lock, flags);
475 if (ypcm->dmabuf.count != 0 && !ypcm->running) {
476 ymf_playback_trigger(unit, ypcm, 1);
480 if (file->f_flags & O_NONBLOCK) {
482 * XXX Our mistake is to attach DMA buffer to state
483 * rather than to some per-device structure.
484 * Cannot skip waiting, can only make it shorter.
489 set_current_state(TASK_UNINTERRUPTIBLE);
490 while (ypcm->running) {
491 spin_unlock_irqrestore(&unit->reg_lock, flags);
493 spin_lock_irqsave(&unit->reg_lock, flags);
494 set_current_state(TASK_UNINTERRUPTIBLE);
496 spin_unlock_irqrestore(&unit->reg_lock, flags);
498 set_current_state(TASK_RUNNING);
499 remove_wait_queue(&ypcm->dmabuf.wait, &waita);
502 * This function may take up to 4 seconds to reach this point
503 * (32K circular buffer, 8000 Hz). User notices.
507 /* Can just stop, without wait. Or can we? */
508 static void ymf_stop_adc(struct ymf_state *state)
510 struct ymf_unit *unit = state->unit;
513 spin_lock_irqsave(&unit->reg_lock, flags);
514 ymf_capture_trigger(unit, &state->rpcm, 0);
515 spin_unlock_irqrestore(&unit->reg_lock, flags);
519 * Hardware start management
522 static void ymfpci_hw_start(ymfpci_t *unit)
526 spin_lock_irqsave(&unit->reg_lock, flags);
527 if (unit->start_count++ == 0) {
528 ymfpci_writel(unit, YDSXGR_MODE,
529 ymfpci_readl(unit, YDSXGR_MODE) | 3);
530 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
532 spin_unlock_irqrestore(&unit->reg_lock, flags);
535 static void ymfpci_hw_stop(ymfpci_t *unit)
540 spin_lock_irqsave(&unit->reg_lock, flags);
541 if (--unit->start_count == 0) {
542 ymfpci_writel(unit, YDSXGR_MODE,
543 ymfpci_readl(unit, YDSXGR_MODE) & ~3);
544 while (timeout-- > 0) {
545 if ((ymfpci_readl(unit, YDSXGR_STATUS) & 2) == 0)
549 spin_unlock_irqrestore(&unit->reg_lock, flags);
553 * Playback voice management
556 static int voice_alloc(ymfpci_t *codec, ymfpci_voice_type_t type, int pair, ymfpci_voice_t *rvoice[])
558 ymfpci_voice_t *voice, *voice2;
561 for (idx = 0; idx < YDSXG_PLAYBACK_VOICES; idx += pair ? 2 : 1) {
562 voice = &codec->voices[idx];
563 voice2 = pair ? &codec->voices[idx+1] : NULL;
564 if (voice->use || (voice2 && voice2->use))
582 ymfpci_hw_start(codec);
585 ymfpci_hw_start(codec);
590 return -EBUSY; /* Your audio channel is open by someone else. */
593 static void ymfpci_voice_free(ymfpci_t *unit, ymfpci_voice_t *pvoice)
595 ymfpci_hw_stop(unit);
596 pvoice->use = pvoice->pcm = pvoice->synth = pvoice->midi = 0;
603 static void ymf_pcm_interrupt(ymfpci_t *codec, ymfpci_voice_t *voice)
605 struct ymf_pcm *ypcm;
607 int pos, delta, swptr;
608 int played, distance;
609 struct ymf_state *state;
610 struct ymf_dmabuf *dmabuf;
613 if ((ypcm = voice->ypcm) == NULL) {
616 if ((state = ypcm->state) == NULL) {
617 ypcm->running = 0; // lock it
620 dmabuf = &ypcm->dmabuf;
621 spin_lock(&codec->reg_lock);
623 YMFDBGI("ymfpci: %d, intr bank %d count %d start 0x%x:%x\n",
624 voice->number, codec->active_bank, dmabuf->count,
625 le32_to_cpu(voice->bank[0].start),
626 le32_to_cpu(voice->bank[1].start));
627 silence = (ymf_pcm_format_width(state->format.format) == 16) ?
629 /* We need actual left-hand-side redzone size here. */
630 redzone = ymf_calc_lend(state->format.rate);
631 redzone <<= (state->format.shift + 1);
632 swptr = dmabuf->swptr;
634 pos = le32_to_cpu(voice->bank[codec->active_bank].start);
635 pos <<= state->format.shift;
636 if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
637 printk(KERN_ERR "ymfpci%d: runaway voice %d: hwptr %d=>%d dmasize %d\n",
638 codec->dev_audio, voice->number,
639 dmabuf->hwptr, pos, dmabuf->dmasize);
642 if (pos < dmabuf->hwptr) {
643 delta = dmabuf->dmasize - dmabuf->hwptr;
644 memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
646 memset(dmabuf->rawbuf, silence, pos);
648 delta = pos - dmabuf->hwptr;
649 memset(dmabuf->rawbuf + dmabuf->hwptr, silence, delta);
653 if (dmabuf->count == 0) {
654 printk(KERN_ERR "ymfpci%d: %d: strain: hwptr %d\n",
655 codec->dev_audio, voice->number, dmabuf->hwptr);
656 ymf_playback_trigger(codec, ypcm, 0);
660 distance = pos - swptr;
662 distance = dmabuf->dmasize - (swptr - pos);
664 if (distance < redzone) {
666 * hwptr inside redzone => DMA ran out of samples.
668 if (delta < dmabuf->count) {
670 * Lost interrupt or other screwage.
672 printk(KERN_ERR "ymfpci%d: %d: lost: delta %d"
673 " hwptr %d swptr %d distance %d count %d\n",
674 codec->dev_audio, voice->number, delta,
675 dmabuf->hwptr, swptr, distance, dmabuf->count);
680 YMFDBGI("ymfpci%d: %d: done: delta %d"
681 " hwptr %d swptr %d distance %d count %d\n",
682 codec->dev_audio, voice->number, delta,
683 dmabuf->hwptr, swptr, distance, dmabuf->count);
685 played = dmabuf->count;
687 ymf_playback_trigger(codec, ypcm, 0);
691 * hwptr is chipping away towards a remote swptr.
692 * Calculate other distance and apply it to count.
695 distance = swptr - pos;
697 distance = dmabuf->dmasize - (pos - swptr);
699 if (distance < dmabuf->count) {
700 played = dmabuf->count - distance;
706 dmabuf->total_bytes += played;
707 dmabuf->count -= played;
708 if (dmabuf->count < dmabuf->dmasize / 2) {
709 wake_up(&dmabuf->wait);
712 spin_unlock(&codec->reg_lock);
715 static void ymf_cap_interrupt(ymfpci_t *unit, struct ymf_capture *cap)
717 struct ymf_pcm *ypcm;
719 struct ymf_state *state;
720 struct ymf_dmabuf *dmabuf;
724 if ((ypcm = cap->ypcm) == NULL) {
727 if ((state = ypcm->state) == NULL) {
728 ypcm->running = 0; // lock it
731 dmabuf = &ypcm->dmabuf;
732 spin_lock(&unit->reg_lock);
734 redzone = ymf_calc_lend(state->format.rate);
735 redzone <<= (state->format.shift + 1);
737 pos = le32_to_cpu(cap->bank[unit->active_bank].start);
738 // pos <<= state->format.shift;
739 if (pos < 0 || pos >= dmabuf->dmasize) { /* ucode bug */
740 printk(KERN_ERR "ymfpci%d: runaway capture %d: hwptr %d=>%d dmasize %d\n",
741 unit->dev_audio, ypcm->capture_bank_number,
742 dmabuf->hwptr, pos, dmabuf->dmasize);
745 if (pos < dmabuf->hwptr) {
746 delta = dmabuf->dmasize - dmabuf->hwptr;
749 delta = pos - dmabuf->hwptr;
755 if (cnt + redzone > dmabuf->dmasize) {
756 /* Overflow - bump swptr */
757 dmabuf->count = dmabuf->dmasize - redzone;
758 dmabuf->swptr = dmabuf->hwptr + redzone;
759 if (dmabuf->swptr >= dmabuf->dmasize) {
760 dmabuf->swptr -= dmabuf->dmasize;
766 dmabuf->total_bytes += delta;
767 if (dmabuf->count) { /* && is_sleeping XXX */
768 wake_up(&dmabuf->wait);
771 spin_unlock(&unit->reg_lock);
774 static int ymf_playback_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
777 if (ypcm->voices[0] == NULL) {
781 codec->ctrl_playback[ypcm->voices[0]->number + 1] =
782 cpu_to_le32(ypcm->voices[0]->bank_ba);
783 if (ypcm->voices[1] != NULL)
784 codec->ctrl_playback[ypcm->voices[1]->number + 1] =
785 cpu_to_le32(ypcm->voices[1]->bank_ba);
788 codec->ctrl_playback[ypcm->voices[0]->number + 1] = 0;
789 if (ypcm->voices[1] != NULL)
790 codec->ctrl_playback[ypcm->voices[1]->number + 1] = 0;
796 static void ymf_capture_trigger(ymfpci_t *codec, struct ymf_pcm *ypcm, int cmd)
801 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) | (1 << ypcm->capture_bank_number);
802 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
805 tmp = ymfpci_readl(codec, YDSXGR_MAPOFREC) & ~(1 << ypcm->capture_bank_number);
806 ymfpci_writel(codec, YDSXGR_MAPOFREC, tmp);
811 static int ymfpci_pcm_voice_alloc(struct ymf_pcm *ypcm, int voices)
813 struct ymf_unit *unit;
816 unit = ypcm->state->unit;
817 if (ypcm->voices[1] != NULL && voices < 2) {
818 ymfpci_voice_free(unit, ypcm->voices[1]);
819 ypcm->voices[1] = NULL;
821 if (voices == 1 && ypcm->voices[0] != NULL)
822 return 0; /* already allocated */
823 if (voices == 2 && ypcm->voices[0] != NULL && ypcm->voices[1] != NULL)
824 return 0; /* already allocated */
826 if (ypcm->voices[0] != NULL && ypcm->voices[1] == NULL) {
827 ymfpci_voice_free(unit, ypcm->voices[0]);
828 ypcm->voices[0] = NULL;
830 if ((err = voice_alloc(unit, YMFPCI_PCM, 1, ypcm->voices)) < 0)
832 ypcm->voices[0]->ypcm = ypcm;
833 ypcm->voices[1]->ypcm = ypcm;
835 if ((err = voice_alloc(unit, YMFPCI_PCM, 0, ypcm->voices)) < 0)
837 ypcm->voices[0]->ypcm = ypcm;
842 static void ymf_pcm_init_voice(ymfpci_voice_t *voice, int stereo,
843 int rate, int w_16, unsigned long addr, unsigned int end, int spdif)
846 u32 delta = ymfpci_calc_delta(rate);
847 u32 lpfQ = ymfpci_calc_lpfQ(rate);
848 u32 lpfK = ymfpci_calc_lpfK(rate);
849 ymfpci_playback_bank_t *bank;
853 * The gain is a floating point number. According to the manual,
854 * bit 31 indicates a sign bit, bit 30 indicates an integer part,
855 * and bits [29:15] indicate a decimal fraction part. Thus,
856 * for a gain of 1.0 the constant of 0x40000000 is loaded.
858 unsigned default_gain = cpu_to_le32(0x40000000);
860 format = (stereo ? 0x00010000 : 0) | (w_16 ? 0 : 0x80000000);
865 for (nbank = 0; nbank < 2; nbank++) {
866 bank = &voice->bank[nbank];
867 bank->format = cpu_to_le32(format);
868 bank->loop_default = 0; /* 0-loops forever, otherwise count */
869 bank->base = cpu_to_le32(addr);
870 bank->loop_start = 0;
871 bank->loop_end = cpu_to_le32(end);
873 bank->eg_gain_end = default_gain;
874 bank->lpfQ = cpu_to_le32(lpfQ);
876 bank->num_of_frames = 0;
877 bank->loop_count = 0;
879 bank->start_frac = 0;
881 bank->delta_end = cpu_to_le32(delta);
883 bank->lpfK_end = cpu_to_le32(lpfK);
884 bank->eg_gain = default_gain;
890 bank->left_gain_end =
891 bank->right_gain_end =
895 bank->eff1_gain_end =
896 bank->eff2_gain_end =
897 bank->eff3_gain_end = 0;
903 bank->left_gain_end =
904 bank->right_gain_end = default_gain;
907 bank->eff2_gain_end =
909 bank->eff3_gain_end = default_gain;
913 if ((voice->number & 1) == 0) {
915 bank->left_gain_end = default_gain;
917 bank->format |= cpu_to_le32(1);
919 bank->right_gain_end = default_gain;
922 if ((voice->number & 1) == 0) {
924 bank->eff2_gain_end = default_gain;
926 bank->format |= cpu_to_le32(1);
928 bank->eff3_gain_end = default_gain;
936 * XXX Capture channel allocation is entirely fake at the moment.
937 * We use only one channel and mark it busy as required.
939 static int ymf_capture_alloc(struct ymf_unit *unit, int *pbank)
941 struct ymf_capture *cap;
944 cbank = 1; /* Only ADC slot is used for now. */
945 cap = &unit->capture[cbank];
953 static int ymf_playback_prepare(struct ymf_state *state)
955 struct ymf_pcm *ypcm = &state->wpcm;
958 if ((err = ymfpci_pcm_voice_alloc(ypcm, state->format.voices)) < 0) {
959 /* Somebody started 32 mpg123's in parallel? */
960 printk(KERN_INFO "ymfpci%d: cannot allocate voice\n",
961 state->unit->dev_audio);
965 for (nvoice = 0; nvoice < state->format.voices; nvoice++) {
966 ymf_pcm_init_voice(ypcm->voices[nvoice],
967 state->format.voices == 2, state->format.rate,
968 ymf_pcm_format_width(state->format.format) == 16,
969 ypcm->dmabuf.dma_addr, ypcm->dmabuf.dmasize,
975 static int ymf_capture_prepare(struct ymf_state *state)
977 ymfpci_t *unit = state->unit;
978 struct ymf_pcm *ypcm = &state->rpcm;
979 ymfpci_capture_bank_t * bank;
980 /* XXX This is confusing, gotta rename one of them banks... */
981 int nbank; /* flip-flop bank */
982 int cbank; /* input [super-]bank */
983 struct ymf_capture *cap;
986 if (ypcm->capture_bank_number == -1) {
987 if (ymf_capture_alloc(unit, &cbank) != 0)
990 ypcm->capture_bank_number = cbank;
992 cap = &unit->capture[cbank];
993 cap->bank = unit->bank_capture[cbank][0];
995 ymfpci_hw_start(unit);
998 // ypcm->frag_size = snd_pcm_lib_transfer_fragment(substream);
999 // frag_size is replaced with nonfragged byte-aligned rolling buffer
1000 rate = ((48000 * 4096) / state->format.rate) - 1;
1002 if (state->format.voices == 2)
1004 if (ymf_pcm_format_width(state->format.format) == 8)
1006 switch (ypcm->capture_bank_number) {
1008 ymfpci_writel(unit, YDSXGR_RECFORMAT, format);
1009 ymfpci_writel(unit, YDSXGR_RECSLOTSR, rate);
1012 ymfpci_writel(unit, YDSXGR_ADCFORMAT, format);
1013 ymfpci_writel(unit, YDSXGR_ADCSLOTSR, rate);
1016 for (nbank = 0; nbank < 2; nbank++) {
1017 bank = unit->bank_capture[ypcm->capture_bank_number][nbank];
1018 bank->base = cpu_to_le32(ypcm->dmabuf.dma_addr);
1019 // bank->loop_end = ypcm->dmabuf.dmasize >> state->format.shift;
1020 bank->loop_end = cpu_to_le32(ypcm->dmabuf.dmasize);
1022 bank->num_of_loops = 0;
1025 if (state->digital.dig_valid)
1026 /*state->digital.type == SND_PCM_DIG_AES_IEC958*/
1027 ymfpci_writew(codec, YDSXGR_SPDIFOUTSTATUS,
1028 state->digital.dig_status[0] | (state->digital.dig_status[1] << 8));
1033 static irqreturn_t ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1035 ymfpci_t *codec = dev_id;
1036 u32 status, nvoice, mode;
1037 struct ymf_voice *voice;
1038 struct ymf_capture *cap;
1040 status = ymfpci_readl(codec, YDSXGR_STATUS);
1041 if (status & 0x80000000) {
1042 codec->active_bank = ymfpci_readl(codec, YDSXGR_CTRLSELECT) & 1;
1043 spin_lock(&codec->voice_lock);
1044 for (nvoice = 0; nvoice < YDSXG_PLAYBACK_VOICES; nvoice++) {
1045 voice = &codec->voices[nvoice];
1047 ymf_pcm_interrupt(codec, voice);
1049 for (nvoice = 0; nvoice < YDSXG_CAPTURE_VOICES; nvoice++) {
1050 cap = &codec->capture[nvoice];
1052 ymf_cap_interrupt(codec, cap);
1054 spin_unlock(&codec->voice_lock);
1055 spin_lock(&codec->reg_lock);
1056 ymfpci_writel(codec, YDSXGR_STATUS, 0x80000000);
1057 mode = ymfpci_readl(codec, YDSXGR_MODE) | 2;
1058 ymfpci_writel(codec, YDSXGR_MODE, mode);
1059 spin_unlock(&codec->reg_lock);
1062 status = ymfpci_readl(codec, YDSXGR_INTFLAG);
1065 ymfpci_writel(codec, YDSXGR_INTFLAG, ~0);
1070 static void ymf_pcm_free_substream(struct ymf_pcm *ypcm)
1072 unsigned long flags;
1073 struct ymf_unit *unit;
1075 unit = ypcm->state->unit;
1077 if (ypcm->type == PLAYBACK_VOICE) {
1078 spin_lock_irqsave(&unit->voice_lock, flags);
1079 if (ypcm->voices[1])
1080 ymfpci_voice_free(unit, ypcm->voices[1]);
1081 if (ypcm->voices[0])
1082 ymfpci_voice_free(unit, ypcm->voices[0]);
1083 spin_unlock_irqrestore(&unit->voice_lock, flags);
1085 if (ypcm->capture_bank_number != -1) {
1086 unit->capture[ypcm->capture_bank_number].use = 0;
1087 ypcm->capture_bank_number = -1;
1088 ymfpci_hw_stop(unit);
1093 static struct ymf_state *ymf_state_alloc(ymfpci_t *unit)
1095 struct ymf_pcm *ypcm;
1096 struct ymf_state *state;
1098 if ((state = kmalloc(sizeof(struct ymf_state), GFP_KERNEL)) == NULL) {
1101 memset(state, 0, sizeof(struct ymf_state));
1103 ypcm = &state->wpcm;
1104 ypcm->state = state;
1105 ypcm->type = PLAYBACK_VOICE;
1106 ypcm->capture_bank_number = -1;
1107 init_waitqueue_head(&ypcm->dmabuf.wait);
1109 ypcm = &state->rpcm;
1110 ypcm->state = state;
1111 ypcm->type = CAPTURE_AC97;
1112 ypcm->capture_bank_number = -1;
1113 init_waitqueue_head(&ypcm->dmabuf.wait);
1117 state->format.format = AFMT_U8;
1118 state->format.rate = 8000;
1119 state->format.voices = 1;
1120 ymf_pcm_update_shift(&state->format);
1128 /* AES/IEC958 channel status bits */
1129 #define SND_PCM_AES0_PROFESSIONAL (1<<0) /* 0 = consumer, 1 = professional */
1130 #define SND_PCM_AES0_NONAUDIO (1<<1) /* 0 = audio, 1 = non-audio */
1131 #define SND_PCM_AES0_PRO_EMPHASIS (7<<2) /* mask - emphasis */
1132 #define SND_PCM_AES0_PRO_EMPHASIS_NOTID (0<<2) /* emphasis not indicated */
1133 #define SND_PCM_AES0_PRO_EMPHASIS_NONE (1<<2) /* none emphasis */
1134 #define SND_PCM_AES0_PRO_EMPHASIS_5015 (3<<2) /* 50/15us emphasis */
1135 #define SND_PCM_AES0_PRO_EMPHASIS_CCITT (7<<2) /* CCITT J.17 emphasis */
1136 #define SND_PCM_AES0_PRO_FREQ_UNLOCKED (1<<5) /* source sample frequency: 0 = locked, 1 = unlocked */
1137 #define SND_PCM_AES0_PRO_FS (3<<6) /* mask - sample frequency */
1138 #define SND_PCM_AES0_PRO_FS_NOTID (0<<6) /* fs not indicated */
1139 #define SND_PCM_AES0_PRO_FS_44100 (1<<6) /* 44.1kHz */
1140 #define SND_PCM_AES0_PRO_FS_48000 (2<<6) /* 48kHz */
1141 #define SND_PCM_AES0_PRO_FS_32000 (3<<6) /* 32kHz */
1142 #define SND_PCM_AES0_CON_NOT_COPYRIGHT (1<<2) /* 0 = copyright, 1 = not copyright */
1143 #define SND_PCM_AES0_CON_EMPHASIS (7<<3) /* mask - emphasis */
1144 #define SND_PCM_AES0_CON_EMPHASIS_NONE (0<<3) /* none emphasis */
1145 #define SND_PCM_AES0_CON_EMPHASIS_5015 (1<<3) /* 50/15us emphasis */
1146 #define SND_PCM_AES0_CON_MODE (3<<6) /* mask - mode */
1147 #define SND_PCM_AES1_PRO_MODE (15<<0) /* mask - channel mode */
1148 #define SND_PCM_AES1_PRO_MODE_NOTID (0<<0) /* not indicated */
1149 #define SND_PCM_AES1_PRO_MODE_STEREOPHONIC (2<<0) /* stereophonic - ch A is left */
1150 #define SND_PCM_AES1_PRO_MODE_SINGLE (4<<0) /* single channel */
1151 #define SND_PCM_AES1_PRO_MODE_TWO (8<<0) /* two channels */
1152 #define SND_PCM_AES1_PRO_MODE_PRIMARY (12<<0) /* primary/secondary */
1153 #define SND_PCM_AES1_PRO_MODE_BYTE3 (15<<0) /* vector to byte 3 */
1154 #define SND_PCM_AES1_PRO_USERBITS (15<<4) /* mask - user bits */
1155 #define SND_PCM_AES1_PRO_USERBITS_NOTID (0<<4) /* not indicated */
1156 #define SND_PCM_AES1_PRO_USERBITS_192 (8<<4) /* 192-bit structure */
1157 #define SND_PCM_AES1_PRO_USERBITS_UDEF (12<<4) /* user defined application */
1158 #define SND_PCM_AES1_CON_CATEGORY 0x7f
1159 #define SND_PCM_AES1_CON_GENERAL 0x00
1160 #define SND_PCM_AES1_CON_EXPERIMENTAL 0x40
1161 #define SND_PCM_AES1_CON_SOLIDMEM_MASK 0x0f
1162 #define SND_PCM_AES1_CON_SOLIDMEM_ID 0x08
1163 #define SND_PCM_AES1_CON_BROADCAST1_MASK 0x07
1164 #define SND_PCM_AES1_CON_BROADCAST1_ID 0x04
1165 #define SND_PCM_AES1_CON_DIGDIGCONV_MASK 0x07
1166 #define SND_PCM_AES1_CON_DIGDIGCONV_ID 0x02
1167 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_MASK 0x1f
1168 #define SND_PCM_AES1_CON_ADC_COPYRIGHT_ID 0x06
1169 #define SND_PCM_AES1_CON_ADC_MASK 0x1f
1170 #define SND_PCM_AES1_CON_ADC_ID 0x16
1171 #define SND_PCM_AES1_CON_BROADCAST2_MASK 0x0f
1172 #define SND_PCM_AES1_CON_BROADCAST2_ID 0x0e
1173 #define SND_PCM_AES1_CON_LASEROPT_MASK 0x07
1174 #define SND_PCM_AES1_CON_LASEROPT_ID 0x01
1175 #define SND_PCM_AES1_CON_MUSICAL_MASK 0x07
1176 #define SND_PCM_AES1_CON_MUSICAL_ID 0x05
1177 #define SND_PCM_AES1_CON_MAGNETIC_MASK 0x07
1178 #define SND_PCM_AES1_CON_MAGNETIC_ID 0x03
1179 #define SND_PCM_AES1_CON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x00)
1180 #define SND_PCM_AES1_CON_NON_IEC908_CD (SND_PCM_AES1_CON_LASEROPT_ID|0x08)
1181 #define SND_PCM_AES1_CON_PCM_CODER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x00)
1182 #define SND_PCM_AES1_CON_SAMPLER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x20)
1183 #define SND_PCM_AES1_CON_MIXER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x10)
1184 #define SND_PCM_AES1_CON_RATE_CONVERTER (SND_PCM_AES1_CON_DIGDIGCONV_ID|0x18)
1185 #define SND_PCM_AES1_CON_SYNTHESIZER (SND_PCM_AES1_CON_MUSICAL_ID|0x00)
1186 #define SND_PCM_AES1_CON_MICROPHONE (SND_PCM_AES1_CON_MUSICAL_ID|0x08)
1187 #define SND_PCM_AES1_CON_DAT (SND_PCM_AES1_CON_MAGNETIC_ID|0x00)
1188 #define SND_PCM_AES1_CON_VCR (SND_PCM_AES1_CON_MAGNETIC_ID|0x08)
1189 #define SND_PCM_AES1_CON_ORIGINAL (1<<7) /* this bits depends on the category code */
1190 #define SND_PCM_AES2_PRO_SBITS (7<<0) /* mask - sample bits */
1191 #define SND_PCM_AES2_PRO_SBITS_20 (2<<0) /* 20-bit - coordination */
1192 #define SND_PCM_AES2_PRO_SBITS_24 (4<<0) /* 24-bit - main audio */
1193 #define SND_PCM_AES2_PRO_SBITS_UDEF (6<<0) /* user defined application */
1194 #define SND_PCM_AES2_PRO_WORDLEN (7<<3) /* mask - source word length */
1195 #define SND_PCM_AES2_PRO_WORDLEN_NOTID (0<<3) /* not indicated */
1196 #define SND_PCM_AES2_PRO_WORDLEN_22_18 (2<<3) /* 22-bit or 18-bit */
1197 #define SND_PCM_AES2_PRO_WORDLEN_23_19 (4<<3) /* 23-bit or 19-bit */
1198 #define SND_PCM_AES2_PRO_WORDLEN_24_20 (5<<3) /* 24-bit or 20-bit */
1199 #define SND_PCM_AES2_PRO_WORDLEN_20_16 (6<<3) /* 20-bit or 16-bit */
1200 #define SND_PCM_AES2_CON_SOURCE (15<<0) /* mask - source number */
1201 #define SND_PCM_AES2_CON_SOURCE_UNSPEC (0<<0) /* unspecified */
1202 #define SND_PCM_AES2_CON_CHANNEL (15<<4) /* mask - channel number */
1203 #define SND_PCM_AES2_CON_CHANNEL_UNSPEC (0<<4) /* unspecified */
1204 #define SND_PCM_AES3_CON_FS (15<<0) /* mask - sample frequency */
1205 #define SND_PCM_AES3_CON_FS_44100 (0<<0) /* 44.1kHz */
1206 #define SND_PCM_AES3_CON_FS_48000 (2<<0) /* 48kHz */
1207 #define SND_PCM_AES3_CON_FS_32000 (3<<0) /* 32kHz */
1208 #define SND_PCM_AES3_CON_CLOCK (3<<4) /* mask - clock accuracy */
1209 #define SND_PCM_AES3_CON_CLOCK_1000PPM (0<<4) /* 1000 ppm */
1210 #define SND_PCM_AES3_CON_CLOCK_50PPM (1<<4) /* 50 ppm */
1211 #define SND_PCM_AES3_CON_CLOCK_VARIABLE (2<<4) /* variable pitch */
1218 * in this loop, dmabuf.count signifies the amount of data that is
1219 * waiting to be copied to the user's buffer. it is filled by the dma
1220 * machine and drained by this loop.
1223 ymf_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1225 struct ymf_state *state = (struct ymf_state *)file->private_data;
1226 struct ymf_dmabuf *dmabuf = &state->rpcm.dmabuf;
1227 struct ymf_unit *unit = state->unit;
1228 DECLARE_WAITQUEUE(waita, current);
1230 unsigned long flags;
1232 int cnt; /* This many to go in this revolution */
1236 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1240 add_wait_queue(&dmabuf->wait, &waita);
1241 set_current_state(TASK_INTERRUPTIBLE);
1243 spin_lock_irqsave(&unit->reg_lock, flags);
1244 if (unit->suspended) {
1245 spin_unlock_irqrestore(&unit->reg_lock, flags);
1247 set_current_state(TASK_INTERRUPTIBLE);
1248 if (signal_pending(current)) {
1249 if (!ret) ret = -EAGAIN;
1254 swptr = dmabuf->swptr;
1255 cnt = dmabuf->dmasize - swptr;
1256 if (dmabuf->count < cnt)
1257 cnt = dmabuf->count;
1258 spin_unlock_irqrestore(&unit->reg_lock, flags);
1264 /* buffer is empty, start the dma machine and wait for data to be
1266 spin_lock_irqsave(&state->unit->reg_lock, flags);
1267 if (!state->rpcm.running) {
1268 ymf_capture_trigger(state->unit, &state->rpcm, 1);
1270 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1271 if (file->f_flags & O_NONBLOCK) {
1272 if (!ret) ret = -EAGAIN;
1275 /* This isnt strictly right for the 810 but it'll do */
1276 tmo = (dmabuf->dmasize * HZ) / (state->format.rate * 2);
1277 tmo >>= state->format.shift;
1278 /* There are two situations when sleep_on_timeout returns, one is when
1279 the interrupt is serviced correctly and the process is waked up by
1280 ISR ON TIME. Another is when timeout is expired, which means that
1281 either interrupt is NOT serviced correctly (pending interrupt) or it
1282 is TOO LATE for the process to be scheduled to run (scheduler latency)
1283 which results in a (potential) buffer overrun. And worse, there is
1284 NOTHING we can do to prevent it. */
1285 tmo = schedule_timeout(tmo);
1286 spin_lock_irqsave(&state->unit->reg_lock, flags);
1287 set_current_state(TASK_INTERRUPTIBLE);
1288 if (tmo == 0 && dmabuf->count == 0) {
1289 printk(KERN_ERR "ymfpci%d: recording schedule timeout, "
1290 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1291 state->unit->dev_audio,
1292 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
1293 dmabuf->hwptr, dmabuf->swptr);
1295 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1296 if (signal_pending(current)) {
1297 if (!ret) ret = -ERESTARTSYS;
1303 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1304 if (!ret) ret = -EFAULT;
1308 swptr = (swptr + cnt) % dmabuf->dmasize;
1310 spin_lock_irqsave(&unit->reg_lock, flags);
1311 if (unit->suspended) {
1312 spin_unlock_irqrestore(&unit->reg_lock, flags);
1316 dmabuf->swptr = swptr;
1317 dmabuf->count -= cnt;
1318 // spin_unlock_irqrestore(&unit->reg_lock, flags);
1323 // spin_lock_irqsave(&unit->reg_lock, flags);
1324 if (!state->rpcm.running) {
1325 ymf_capture_trigger(unit, &state->rpcm, 1);
1327 spin_unlock_irqrestore(&unit->reg_lock, flags);
1329 set_current_state(TASK_RUNNING);
1330 remove_wait_queue(&dmabuf->wait, &waita);
1336 ymf_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1338 struct ymf_state *state = (struct ymf_state *)file->private_data;
1339 struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1340 struct ymf_unit *unit = state->unit;
1341 DECLARE_WAITQUEUE(waita, current);
1343 unsigned long flags;
1345 int cnt; /* This many to go in this revolution */
1349 YMFDBGW("ymf_write: count %d\n", count);
1353 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1358 * Alan's cs46xx works without a red zone - marvel of ingenuity.
1359 * We are not so brilliant... Red zone does two things:
1360 * 1. allows for safe start after a pause as we have no way
1361 * to know what the actual, relentlessly advancing, hwptr is.
1362 * 2. makes computations in ymf_pcm_interrupt simpler.
1364 redzone = ymf_calc_lend(state->format.rate) << state->format.shift;
1365 redzone *= 3; /* 2 redzone + 1 possible uncertainty reserve. */
1367 add_wait_queue(&dmabuf->wait, &waita);
1368 set_current_state(TASK_INTERRUPTIBLE);
1370 spin_lock_irqsave(&unit->reg_lock, flags);
1371 if (unit->suspended) {
1372 spin_unlock_irqrestore(&unit->reg_lock, flags);
1374 set_current_state(TASK_INTERRUPTIBLE);
1375 if (signal_pending(current)) {
1376 if (!ret) ret = -EAGAIN;
1381 if (dmabuf->count < 0) {
1383 "ymf_write: count %d, was legal in cs46xx\n",
1387 if (dmabuf->count == 0) {
1388 swptr = dmabuf->hwptr;
1389 if (state->wpcm.running) {
1391 * Add uncertainty reserve.
1393 cnt = ymf_calc_lend(state->format.rate);
1394 cnt <<= state->format.shift;
1395 if ((swptr += cnt) >= dmabuf->dmasize) {
1396 swptr -= dmabuf->dmasize;
1399 dmabuf->swptr = swptr;
1402 * XXX This is not right if dmabuf->count is small -
1403 * about 2*x frame size or less. We cannot count on
1404 * on appending and not causing an artefact.
1405 * Should use a variation of the count==0 case above.
1407 swptr = dmabuf->swptr;
1409 cnt = dmabuf->dmasize - swptr;
1410 if (dmabuf->count + cnt > dmabuf->dmasize - redzone)
1411 cnt = (dmabuf->dmasize - redzone) - dmabuf->count;
1412 spin_unlock_irqrestore(&unit->reg_lock, flags);
1417 YMFDBGW("ymf_write: full, count %d swptr %d\n",
1418 dmabuf->count, dmabuf->swptr);
1420 * buffer is full, start the dma machine and
1421 * wait for data to be played
1423 spin_lock_irqsave(&unit->reg_lock, flags);
1424 if (!state->wpcm.running) {
1425 ymf_playback_trigger(unit, &state->wpcm, 1);
1427 spin_unlock_irqrestore(&unit->reg_lock, flags);
1428 if (file->f_flags & O_NONBLOCK) {
1429 if (!ret) ret = -EAGAIN;
1433 set_current_state(TASK_INTERRUPTIBLE);
1434 if (signal_pending(current)) {
1435 if (!ret) ret = -ERESTARTSYS;
1440 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1441 if (!ret) ret = -EFAULT;
1445 if ((swptr += cnt) >= dmabuf->dmasize) {
1446 swptr -= dmabuf->dmasize;
1449 spin_lock_irqsave(&unit->reg_lock, flags);
1450 if (unit->suspended) {
1451 spin_unlock_irqrestore(&unit->reg_lock, flags);
1454 dmabuf->swptr = swptr;
1455 dmabuf->count += cnt;
1458 * Start here is a bad idea - may cause startup click
1459 * in /bin/play when dmabuf is not full yet.
1460 * However, some broken applications do not make
1461 * any use of SNDCTL_DSP_SYNC (Doom is the worst).
1462 * One frame is about 5.3ms, Doom write size is 46ms.
1464 delay = state->format.rate / 20; /* 50ms */
1465 delay <<= state->format.shift;
1466 if (dmabuf->count >= delay && !state->wpcm.running) {
1467 ymf_playback_trigger(unit, &state->wpcm, 1);
1470 spin_unlock_irqrestore(&unit->reg_lock, flags);
1477 set_current_state(TASK_RUNNING);
1478 remove_wait_queue(&dmabuf->wait, &waita);
1480 YMFDBGW("ymf_write: ret %d dmabuf.count %d\n", ret, dmabuf->count);
1484 static unsigned int ymf_poll(struct file *file, struct poll_table_struct *wait)
1486 struct ymf_state *state = (struct ymf_state *)file->private_data;
1487 struct ymf_dmabuf *dmabuf;
1489 unsigned long flags;
1490 unsigned int mask = 0;
1492 if (file->f_mode & FMODE_WRITE)
1493 poll_wait(file, &state->wpcm.dmabuf.wait, wait);
1494 if (file->f_mode & FMODE_READ)
1495 poll_wait(file, &state->rpcm.dmabuf.wait, wait);
1497 spin_lock_irqsave(&state->unit->reg_lock, flags);
1498 if (file->f_mode & FMODE_READ) {
1499 dmabuf = &state->rpcm.dmabuf;
1500 if (dmabuf->count >= (signed)dmabuf->fragsize)
1501 mask |= POLLIN | POLLRDNORM;
1503 if (file->f_mode & FMODE_WRITE) {
1504 redzone = ymf_calc_lend(state->format.rate);
1505 redzone <<= state->format.shift;
1508 dmabuf = &state->wpcm.dmabuf;
1509 if (dmabuf->mapped) {
1510 if (dmabuf->count >= (signed)dmabuf->fragsize)
1511 mask |= POLLOUT | POLLWRNORM;
1514 * Don't select unless a full fragment is available.
1515 * Otherwise artsd does GETOSPACE, sees 0, and loops.
1517 if (dmabuf->count + redzone + dmabuf->fragsize
1519 mask |= POLLOUT | POLLWRNORM;
1522 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1527 static int ymf_mmap(struct file *file, struct vm_area_struct *vma)
1529 struct ymf_state *state = (struct ymf_state *)file->private_data;
1530 struct ymf_dmabuf *dmabuf = &state->wpcm.dmabuf;
1534 if (vma->vm_flags & VM_WRITE) {
1535 if ((ret = prog_dmabuf(state, 0)) != 0)
1537 } else if (vma->vm_flags & VM_READ) {
1538 if ((ret = prog_dmabuf(state, 1)) != 0)
1543 if (vma->vm_pgoff != 0)
1545 size = vma->vm_end - vma->vm_start;
1546 if (size > (PAGE_SIZE << dmabuf->buforder))
1548 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
1549 size, vma->vm_page_prot))
1553 /* P3 */ printk(KERN_INFO "ymfpci: using memory mapped sound, untested!\n");
1557 static int ymf_ioctl(struct inode *inode, struct file *file,
1558 unsigned int cmd, unsigned long arg)
1560 struct ymf_state *state = (struct ymf_state *)file->private_data;
1561 struct ymf_dmabuf *dmabuf;
1562 unsigned long flags;
1563 audio_buf_info abinfo;
1567 void __user *argp = (void __user *)arg;
1568 int __user *p = argp;
1571 case OSS_GETVERSION:
1572 YMFDBGX("ymf_ioctl: cmd 0x%x(GETVER) arg 0x%lx\n", cmd, arg);
1573 return put_user(SOUND_VERSION, p);
1575 case SNDCTL_DSP_RESET:
1576 YMFDBGX("ymf_ioctl: cmd 0x%x(RESET)\n", cmd);
1577 if (file->f_mode & FMODE_WRITE) {
1578 ymf_wait_dac(state);
1579 dmabuf = &state->wpcm.dmabuf;
1580 spin_lock_irqsave(&state->unit->reg_lock, flags);
1582 dmabuf->swptr = dmabuf->hwptr;
1583 dmabuf->count = dmabuf->total_bytes = 0;
1584 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1586 if (file->f_mode & FMODE_READ) {
1587 ymf_stop_adc(state);
1588 dmabuf = &state->rpcm.dmabuf;
1589 spin_lock_irqsave(&state->unit->reg_lock, flags);
1591 dmabuf->swptr = dmabuf->hwptr;
1592 dmabuf->count = dmabuf->total_bytes = 0;
1593 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1597 case SNDCTL_DSP_SYNC:
1598 YMFDBGX("ymf_ioctl: cmd 0x%x(SYNC)\n", cmd);
1599 if (file->f_mode & FMODE_WRITE) {
1600 dmabuf = &state->wpcm.dmabuf;
1601 if (file->f_flags & O_NONBLOCK) {
1602 spin_lock_irqsave(&state->unit->reg_lock, flags);
1603 if (dmabuf->count != 0 && !state->wpcm.running) {
1604 ymf_start_dac(state);
1606 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1608 ymf_wait_dac(state);
1611 /* XXX What does this do for reading? dmabuf->count=0; ? */
1614 case SNDCTL_DSP_SPEED: /* set smaple rate */
1615 if (get_user(val, p))
1617 YMFDBGX("ymf_ioctl: cmd 0x%x(SPEED) sp %d\n", cmd, val);
1618 if (val >= 8000 && val <= 48000) {
1619 if (file->f_mode & FMODE_WRITE) {
1620 ymf_wait_dac(state);
1621 dmabuf = &state->wpcm.dmabuf;
1622 spin_lock_irqsave(&state->unit->reg_lock, flags);
1624 state->format.rate = val;
1625 ymf_pcm_update_shift(&state->format);
1626 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1628 if (file->f_mode & FMODE_READ) {
1629 ymf_stop_adc(state);
1630 dmabuf = &state->rpcm.dmabuf;
1631 spin_lock_irqsave(&state->unit->reg_lock, flags);
1633 state->format.rate = val;
1634 ymf_pcm_update_shift(&state->format);
1635 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1638 return put_user(state->format.rate, p);
1641 * OSS manual does not mention SNDCTL_DSP_STEREO at all.
1642 * All channels are mono and if you want stereo, you
1643 * play into two channels with SNDCTL_DSP_CHANNELS.
1644 * However, mpg123 calls it. I wonder, why Michael Hipp used it.
1646 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
1647 if (get_user(val, p))
1649 YMFDBGX("ymf_ioctl: cmd 0x%x(STEREO) st %d\n", cmd, val);
1650 if (file->f_mode & FMODE_WRITE) {
1651 ymf_wait_dac(state);
1652 dmabuf = &state->wpcm.dmabuf;
1653 spin_lock_irqsave(&state->unit->reg_lock, flags);
1655 state->format.voices = val ? 2 : 1;
1656 ymf_pcm_update_shift(&state->format);
1657 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1659 if (file->f_mode & FMODE_READ) {
1660 ymf_stop_adc(state);
1661 dmabuf = &state->rpcm.dmabuf;
1662 spin_lock_irqsave(&state->unit->reg_lock, flags);
1664 state->format.voices = val ? 2 : 1;
1665 ymf_pcm_update_shift(&state->format);
1666 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1670 case SNDCTL_DSP_GETBLKSIZE:
1671 YMFDBGX("ymf_ioctl: cmd 0x%x(GETBLK)\n", cmd);
1672 if (file->f_mode & FMODE_WRITE) {
1673 if ((val = prog_dmabuf(state, 0)))
1675 val = state->wpcm.dmabuf.fragsize;
1676 YMFDBGX("ymf_ioctl: GETBLK w %d\n", val);
1677 return put_user(val, p);
1679 if (file->f_mode & FMODE_READ) {
1680 if ((val = prog_dmabuf(state, 1)))
1682 val = state->rpcm.dmabuf.fragsize;
1683 YMFDBGX("ymf_ioctl: GETBLK r %d\n", val);
1684 return put_user(val, p);
1688 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
1689 YMFDBGX("ymf_ioctl: cmd 0x%x(GETFMTS)\n", cmd);
1690 return put_user(AFMT_S16_LE|AFMT_U8, p);
1692 case SNDCTL_DSP_SETFMT: /* Select sample format */
1693 if (get_user(val, p))
1695 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFMT) fmt %d\n", cmd, val);
1696 if (val == AFMT_S16_LE || val == AFMT_U8) {
1697 if (file->f_mode & FMODE_WRITE) {
1698 ymf_wait_dac(state);
1699 dmabuf = &state->wpcm.dmabuf;
1700 spin_lock_irqsave(&state->unit->reg_lock, flags);
1702 state->format.format = val;
1703 ymf_pcm_update_shift(&state->format);
1704 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1706 if (file->f_mode & FMODE_READ) {
1707 ymf_stop_adc(state);
1708 dmabuf = &state->rpcm.dmabuf;
1709 spin_lock_irqsave(&state->unit->reg_lock, flags);
1711 state->format.format = val;
1712 ymf_pcm_update_shift(&state->format);
1713 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1716 return put_user(state->format.format, p);
1718 case SNDCTL_DSP_CHANNELS:
1719 if (get_user(val, p))
1721 YMFDBGX("ymf_ioctl: cmd 0x%x(CHAN) ch %d\n", cmd, val);
1723 if (file->f_mode & FMODE_WRITE) {
1724 ymf_wait_dac(state);
1725 if (val == 1 || val == 2) {
1726 spin_lock_irqsave(&state->unit->reg_lock, flags);
1727 dmabuf = &state->wpcm.dmabuf;
1729 state->format.voices = val;
1730 ymf_pcm_update_shift(&state->format);
1731 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1734 if (file->f_mode & FMODE_READ) {
1735 ymf_stop_adc(state);
1736 if (val == 1 || val == 2) {
1737 spin_lock_irqsave(&state->unit->reg_lock, flags);
1738 dmabuf = &state->rpcm.dmabuf;
1740 state->format.voices = val;
1741 ymf_pcm_update_shift(&state->format);
1742 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1746 return put_user(state->format.voices, p);
1748 case SNDCTL_DSP_POST:
1749 YMFDBGX("ymf_ioctl: cmd 0x%x(POST)\n", cmd);
1752 * The ioctl SNDCTL_DSP_POST is a lightweight version of
1753 * SNDCTL_DSP_SYNC. It just tells to the driver that there
1754 * is likely to be a pause in the output. This makes it
1755 * possible for the device to handle the pause more
1756 * intelligently. This ioctl doesn't block the application.
1758 * The paragraph above is a clumsy way to say "flush ioctl".
1759 * This ioctl is used by mpg123.
1761 spin_lock_irqsave(&state->unit->reg_lock, flags);
1762 if (state->wpcm.dmabuf.count != 0 && !state->wpcm.running) {
1763 ymf_start_dac(state);
1765 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1768 case SNDCTL_DSP_SETFRAGMENT:
1769 if (get_user(val, p))
1771 YMFDBGX("ymf_ioctl: cmd 0x%x(SETFRAG) fr 0x%04x:%04x(%d:%d)\n",
1773 (val >> 16) & 0xFFFF, val & 0xFFFF,
1774 (val >> 16) & 0xFFFF, val & 0xFFFF);
1775 dmabuf = &state->wpcm.dmabuf;
1776 dmabuf->ossfragshift = val & 0xffff;
1777 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
1778 if (dmabuf->ossfragshift < 4)
1779 dmabuf->ossfragshift = 4;
1780 if (dmabuf->ossfragshift > 15)
1781 dmabuf->ossfragshift = 15;
1784 case SNDCTL_DSP_GETOSPACE:
1785 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOSPACE)\n", cmd);
1786 if (!(file->f_mode & FMODE_WRITE))
1788 dmabuf = &state->wpcm.dmabuf;
1789 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
1791 redzone = ymf_calc_lend(state->format.rate);
1792 redzone <<= state->format.shift;
1794 spin_lock_irqsave(&state->unit->reg_lock, flags);
1795 abinfo.fragsize = dmabuf->fragsize;
1796 abinfo.bytes = dmabuf->dmasize - dmabuf->count - redzone;
1797 abinfo.fragstotal = dmabuf->numfrag;
1798 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1799 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1800 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1802 case SNDCTL_DSP_GETISPACE:
1803 YMFDBGX("ymf_ioctl: cmd 0x%x(GETISPACE)\n", cmd);
1804 if (!(file->f_mode & FMODE_READ))
1806 dmabuf = &state->rpcm.dmabuf;
1807 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
1809 spin_lock_irqsave(&state->unit->reg_lock, flags);
1810 abinfo.fragsize = dmabuf->fragsize;
1811 abinfo.bytes = dmabuf->count;
1812 abinfo.fragstotal = dmabuf->numfrag;
1813 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
1814 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1815 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
1817 case SNDCTL_DSP_NONBLOCK:
1818 YMFDBGX("ymf_ioctl: cmd 0x%x(NONBLOCK)\n", cmd);
1819 file->f_flags |= O_NONBLOCK;
1822 case SNDCTL_DSP_GETCAPS:
1823 YMFDBGX("ymf_ioctl: cmd 0x%x(GETCAPS)\n", cmd);
1824 /* return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
1826 return put_user(0, p);
1828 case SNDCTL_DSP_GETIPTR:
1829 YMFDBGX("ymf_ioctl: cmd 0x%x(GETIPTR)\n", cmd);
1830 if (!(file->f_mode & FMODE_READ))
1832 dmabuf = &state->rpcm.dmabuf;
1833 spin_lock_irqsave(&state->unit->reg_lock, flags);
1834 cinfo.bytes = dmabuf->total_bytes;
1835 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1836 cinfo.ptr = dmabuf->hwptr;
1837 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1838 YMFDBGX("ymf_ioctl: GETIPTR ptr %d bytes %d\n",
1839 cinfo.ptr, cinfo.bytes);
1840 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1842 case SNDCTL_DSP_GETOPTR:
1843 YMFDBGX("ymf_ioctl: cmd 0x%x(GETOPTR)\n", cmd);
1844 if (!(file->f_mode & FMODE_WRITE))
1846 dmabuf = &state->wpcm.dmabuf;
1847 spin_lock_irqsave(&state->unit->reg_lock, flags);
1848 cinfo.bytes = dmabuf->total_bytes;
1849 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
1850 cinfo.ptr = dmabuf->hwptr;
1851 spin_unlock_irqrestore(&state->unit->reg_lock, flags);
1852 YMFDBGX("ymf_ioctl: GETOPTR ptr %d bytes %d\n",
1853 cinfo.ptr, cinfo.bytes);
1854 return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
1856 case SNDCTL_DSP_SETDUPLEX:
1857 YMFDBGX("ymf_ioctl: cmd 0x%x(SETDUPLEX)\n", cmd);
1858 return 0; /* Always duplex */
1860 case SOUND_PCM_READ_RATE:
1861 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_RATE)\n", cmd);
1862 return put_user(state->format.rate, p);
1864 case SOUND_PCM_READ_CHANNELS:
1865 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_CH)\n", cmd);
1866 return put_user(state->format.voices, p);
1868 case SOUND_PCM_READ_BITS:
1869 YMFDBGX("ymf_ioctl: cmd 0x%x(READ_BITS)\n", cmd);
1870 return put_user(AFMT_S16_LE, p);
1872 case SNDCTL_DSP_MAPINBUF:
1873 case SNDCTL_DSP_MAPOUTBUF:
1874 case SNDCTL_DSP_SETSYNCRO:
1875 case SOUND_PCM_WRITE_FILTER:
1876 case SOUND_PCM_READ_FILTER:
1877 YMFDBGX("ymf_ioctl: cmd 0x%x unsupported\n", cmd);
1882 * Some programs mix up audio devices and ioctls
1883 * or perhaps they expect "universal" ioctls,
1884 * for instance we get SNDCTL_TMR_CONTINUE here.
1885 * (mpg123 -g 100 ends here too - to be fixed.)
1887 YMFDBGX("ymf_ioctl: cmd 0x%x unknown\n", cmd);
1895 * We use upper part of the minor to distinguish between soundcards.
1896 * Channels are opened with a clone open.
1898 static int ymf_open(struct inode *inode, struct file *file)
1900 struct list_head *list;
1901 ymfpci_t *unit = NULL;
1903 struct ymf_state *state;
1906 minor = iminor(inode);
1907 if ((minor & 0x0F) == 3) { /* /dev/dspN */
1913 unit = NULL; /* gcc warns */
1914 spin_lock(&ymf_devs_lock);
1915 list_for_each(list, &ymf_devs) {
1916 unit = list_entry(list, ymfpci_t, ymf_devs);
1917 if (((unit->dev_audio ^ minor) & ~0x0F) == 0)
1920 spin_unlock(&ymf_devs_lock);
1924 down(&unit->open_sem);
1926 if ((state = ymf_state_alloc(unit)) == NULL) {
1927 up(&unit->open_sem);
1930 list_add_tail(&state->chain, &unit->states);
1932 file->private_data = state;
1935 * ymf_read and ymf_write that we borrowed from cs46xx
1936 * allocate buffers with prog_dmabuf(). We call prog_dmabuf
1937 * here so that in case of DMA memory exhaustion open
1938 * fails rather than write.
1940 * XXX prog_dmabuf allocates voice. Should allocate explicitly, above.
1942 if (file->f_mode & FMODE_WRITE) {
1943 if (!state->wpcm.dmabuf.ready) {
1944 if ((err = prog_dmabuf(state, 0)) != 0) {
1949 if (file->f_mode & FMODE_READ) {
1950 if (!state->rpcm.dmabuf.ready) {
1951 if ((err = prog_dmabuf(state, 1)) != 0) {
1957 #if 0 /* test if interrupts work */
1958 ymfpci_writew(unit, YDSXGR_TIMERCOUNT, 0xfffe); /* ~ 680ms */
1959 ymfpci_writeb(unit, YDSXGR_TIMERCTRL,
1960 (YDSXGR_TIMERCTRL_TEN|YDSXGR_TIMERCTRL_TIEN));
1962 up(&unit->open_sem);
1964 return nonseekable_open(inode, file);
1968 * XXX Broken custom: "goto out_xxx" in other place is
1969 * a nestable exception, but here it is not nestable due to semaphore.
1970 * XXX Doubtful technique of self-describing objects....
1972 dealloc_dmabuf(unit, &state->wpcm.dmabuf);
1973 dealloc_dmabuf(unit, &state->rpcm.dmabuf);
1974 ymf_pcm_free_substream(&state->wpcm);
1975 ymf_pcm_free_substream(&state->rpcm);
1977 list_del(&state->chain);
1980 up(&unit->open_sem);
1984 static int ymf_release(struct inode *inode, struct file *file)
1986 struct ymf_state *state = (struct ymf_state *)file->private_data;
1987 ymfpci_t *unit = state->unit;
1989 #if 0 /* test if interrupts work */
1990 ymfpci_writeb(unit, YDSXGR_TIMERCTRL, 0);
1993 down(&unit->open_sem);
1996 * XXX Solve the case of O_NONBLOCK close - don't deallocate here.
1997 * Deallocate when unloading the driver and we can wait.
1999 ymf_wait_dac(state);
2000 ymf_stop_adc(state); /* fortunately, it's immediate */
2001 dealloc_dmabuf(unit, &state->wpcm.dmabuf);
2002 dealloc_dmabuf(unit, &state->rpcm.dmabuf);
2003 ymf_pcm_free_substream(&state->wpcm);
2004 ymf_pcm_free_substream(&state->rpcm);
2006 list_del(&state->chain);
2007 file->private_data = NULL; /* Can you tell I programmed Solaris */
2010 up(&unit->open_sem);
2016 * Mixer operations are based on cs46xx.
2018 static int ymf_open_mixdev(struct inode *inode, struct file *file)
2020 int minor = iminor(inode);
2021 struct list_head *list;
2025 spin_lock(&ymf_devs_lock);
2026 list_for_each(list, &ymf_devs) {
2027 unit = list_entry(list, ymfpci_t, ymf_devs);
2028 for (i = 0; i < NR_AC97; i++) {
2029 if (unit->ac97_codec[i] != NULL &&
2030 unit->ac97_codec[i]->dev_mixer == minor) {
2031 spin_unlock(&ymf_devs_lock);
2036 spin_unlock(&ymf_devs_lock);
2040 file->private_data = unit->ac97_codec[i];
2042 return nonseekable_open(inode, file);
2045 static int ymf_ioctl_mixdev(struct inode *inode, struct file *file,
2046 unsigned int cmd, unsigned long arg)
2048 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
2050 return codec->mixer_ioctl(codec, cmd, arg);
2053 static int ymf_release_mixdev(struct inode *inode, struct file *file)
2058 static /*const*/ struct file_operations ymf_fops = {
2059 .owner = THIS_MODULE,
2060 .llseek = no_llseek,
2067 .release = ymf_release,
2070 static /*const*/ struct file_operations ymf_mixer_fops = {
2071 .owner = THIS_MODULE,
2072 .llseek = no_llseek,
2073 .ioctl = ymf_ioctl_mixdev,
2074 .open = ymf_open_mixdev,
2075 .release = ymf_release_mixdev,
2081 static int ymf_suspend(struct pci_dev *pcidev, u32 unused)
2083 struct ymf_unit *unit = pci_get_drvdata(pcidev);
2084 unsigned long flags;
2085 struct ymf_dmabuf *dmabuf;
2086 struct list_head *p;
2087 struct ymf_state *state;
2088 struct ac97_codec *codec;
2091 spin_lock_irqsave(&unit->reg_lock, flags);
2093 unit->suspended = 1;
2095 for (i = 0; i < NR_AC97; i++) {
2096 if ((codec = unit->ac97_codec[i]) != NULL)
2097 ac97_save_state(codec);
2100 list_for_each(p, &unit->states) {
2101 state = list_entry(p, struct ymf_state, chain);
2103 dmabuf = &state->wpcm.dmabuf;
2104 dmabuf->hwptr = dmabuf->swptr = 0;
2105 dmabuf->total_bytes = 0;
2108 dmabuf = &state->rpcm.dmabuf;
2109 dmabuf->hwptr = dmabuf->swptr = 0;
2110 dmabuf->total_bytes = 0;
2114 ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0);
2115 ymfpci_disable_dsp(unit);
2117 spin_unlock_irqrestore(&unit->reg_lock, flags);
2122 static int ymf_resume(struct pci_dev *pcidev)
2124 struct ymf_unit *unit = pci_get_drvdata(pcidev);
2125 unsigned long flags;
2126 struct list_head *p;
2127 struct ymf_state *state;
2128 struct ac97_codec *codec;
2131 ymfpci_aclink_reset(unit->pci);
2132 ymfpci_codec_ready(unit, 0, 1); /* prints diag if not ready. */
2134 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2135 /* XXX At this time the legacy registers are probably deprogrammed. */
2138 ymfpci_download_image(unit);
2142 spin_lock_irqsave(&unit->reg_lock, flags);
2144 if (unit->start_count) {
2145 ymfpci_writel(unit, YDSXGR_MODE, 3);
2146 unit->active_bank = ymfpci_readl(unit, YDSXGR_CTRLSELECT) & 1;
2149 for (i = 0; i < NR_AC97; i++) {
2150 if ((codec = unit->ac97_codec[i]) != NULL)
2151 ac97_restore_state(codec);
2154 unit->suspended = 0;
2155 list_for_each(p, &unit->states) {
2156 state = list_entry(p, struct ymf_state, chain);
2157 wake_up(&state->wpcm.dmabuf.wait);
2158 wake_up(&state->rpcm.dmabuf.wait);
2161 spin_unlock_irqrestore(&unit->reg_lock, flags);
2166 * initialization routines
2169 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2171 static int ymfpci_setup_legacy(ymfpci_t *unit, struct pci_dev *pcidev)
2174 int mpuio = -1, oplio = -1;
2176 switch (unit->iomidi) {
2192 switch (unit->iosynth) {
2208 if (mpuio >= 0 || oplio >= 0) {
2209 /* 0x0020: 1 - 10 bits of I/O address decoded, 0 - 16 bits. */
2211 pci_write_config_word(pcidev, PCIR_LEGCTRL, v);
2213 switch (pcidev->device) {
2214 case PCI_DEVICE_ID_YAMAHA_724:
2215 case PCI_DEVICE_ID_YAMAHA_740:
2216 case PCI_DEVICE_ID_YAMAHA_724F:
2217 case PCI_DEVICE_ID_YAMAHA_740C:
2219 if (mpuio >= 0) { v |= mpuio<<4; }
2220 if (oplio >= 0) { v |= oplio; }
2221 pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2224 case PCI_DEVICE_ID_YAMAHA_744:
2225 case PCI_DEVICE_ID_YAMAHA_754:
2227 pci_write_config_word(pcidev, PCIR_ELEGCTRL, v);
2229 pci_write_config_word(pcidev, PCIR_OPLADR, unit->iosynth);
2232 pci_write_config_word(pcidev, PCIR_MPUADR, unit->iomidi);
2237 printk(KERN_ERR "ymfpci: Unknown device ID: 0x%x\n",
2245 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2247 static void ymfpci_aclink_reset(struct pci_dev * pci)
2252 * In the 744, 754 only 0x01 exists, 0x02 is undefined.
2253 * It does not seem to hurt to trip both regardless of revision.
2255 pci_read_config_byte(pci, PCIR_DSXGCTRL, &cmd);
2256 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2257 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd | 0x03);
2258 pci_write_config_byte(pci, PCIR_DSXGCTRL, cmd & 0xfc);
2260 pci_write_config_word(pci, PCIR_DSXPWRCTRL1, 0);
2261 pci_write_config_word(pci, PCIR_DSXPWRCTRL2, 0);
2264 static void ymfpci_enable_dsp(ymfpci_t *codec)
2266 ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000001);
2269 static void ymfpci_disable_dsp(ymfpci_t *codec)
2274 val = ymfpci_readl(codec, YDSXGR_CONFIG);
2276 ymfpci_writel(codec, YDSXGR_CONFIG, 0x00000000);
2277 while (timeout-- > 0) {
2278 val = ymfpci_readl(codec, YDSXGR_STATUS);
2279 if ((val & 0x00000002) == 0)
2284 #include "ymfpci_image.h"
2286 static void ymfpci_download_image(ymfpci_t *codec)
2291 ymfpci_writel(codec, YDSXGR_NATIVEDACOUTVOL, 0x00000000);
2292 ymfpci_disable_dsp(codec);
2293 ymfpci_writel(codec, YDSXGR_MODE, 0x00010000);
2294 ymfpci_writel(codec, YDSXGR_MODE, 0x00000000);
2295 ymfpci_writel(codec, YDSXGR_MAPOFREC, 0x00000000);
2296 ymfpci_writel(codec, YDSXGR_MAPOFEFFECT, 0x00000000);
2297 ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0x00000000);
2298 ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0x00000000);
2299 ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0x00000000);
2300 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2301 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2303 /* setup DSP instruction code */
2304 for (i = 0; i < YDSXG_DSPLENGTH / 4; i++)
2305 ymfpci_writel(codec, YDSXGR_DSPINSTRAM + (i << 2), DspInst[i]);
2307 switch (codec->pci->device) {
2308 case PCI_DEVICE_ID_YAMAHA_724F:
2309 case PCI_DEVICE_ID_YAMAHA_740C:
2310 case PCI_DEVICE_ID_YAMAHA_744:
2311 case PCI_DEVICE_ID_YAMAHA_754:
2319 /* setup control instruction code */
2320 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2321 ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst1E[i]);
2323 for (i = 0; i < YDSXG_CTRLLENGTH / 4; i++)
2324 ymfpci_writel(codec, YDSXGR_CTRLINSTRAM + (i << 2), CntrlInst[i]);
2327 ymfpci_enable_dsp(codec);
2329 /* 0.02s sounds not too bad, we may do schedule_timeout() later. */
2330 mdelay(20); /* seems we need some delay after downloading image.. */
2333 static int ymfpci_memalloc(ymfpci_t *codec)
2335 unsigned int playback_ctrl_size;
2336 unsigned int bank_size_playback;
2337 unsigned int bank_size_capture;
2338 unsigned int bank_size_effect;
2345 playback_ctrl_size = 4 + 4 * YDSXG_PLAYBACK_VOICES;
2346 bank_size_playback = ymfpci_readl(codec, YDSXGR_PLAYCTRLSIZE) << 2;
2347 bank_size_capture = ymfpci_readl(codec, YDSXGR_RECCTRLSIZE) << 2;
2348 bank_size_effect = ymfpci_readl(codec, YDSXGR_EFFCTRLSIZE) << 2;
2349 codec->work_size = YDSXG_DEFAULT_WORK_SIZE;
2351 size = ((playback_ctrl_size + 0x00ff) & ~0x00ff) +
2352 ((bank_size_playback * 2 * YDSXG_PLAYBACK_VOICES + 0xff) & ~0xff) +
2353 ((bank_size_capture * 2 * YDSXG_CAPTURE_VOICES + 0xff) & ~0xff) +
2354 ((bank_size_effect * 2 * YDSXG_EFFECT_VOICES + 0xff) & ~0xff) +
2357 ptr = pci_alloc_consistent(codec->pci, size + 0xff, &pba);
2360 codec->dma_area_va = ptr;
2361 codec->dma_area_ba = pba;
2362 codec->dma_area_size = size + 0xff;
2364 off = (unsigned long)ptr & 0xff;
2371 * Hardware requires only ptr[playback_ctrl_size] zeroed,
2372 * but in our judgement it is a wrong kind of savings, so clear it all.
2374 memset(ptr, 0, size);
2376 codec->ctrl_playback = (u32 *)ptr;
2377 codec->ctrl_playback_ba = pba;
2378 codec->ctrl_playback[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES);
2379 ptr += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2380 pba += (playback_ctrl_size + 0x00ff) & ~0x00ff;
2383 for (voice = 0; voice < YDSXG_PLAYBACK_VOICES; voice++) {
2384 codec->voices[voice].number = voice;
2385 codec->voices[voice].bank =
2386 (ymfpci_playback_bank_t *) (ptr + off);
2387 codec->voices[voice].bank_ba = pba + off;
2388 off += 2 * bank_size_playback; /* 2 banks */
2390 off = (off + 0xff) & ~0xff;
2395 codec->bank_base_capture = pba;
2396 for (voice = 0; voice < YDSXG_CAPTURE_VOICES; voice++)
2397 for (bank = 0; bank < 2; bank++) {
2398 codec->bank_capture[voice][bank] =
2399 (ymfpci_capture_bank_t *) (ptr + off);
2400 off += bank_size_capture;
2402 off = (off + 0xff) & ~0xff;
2407 codec->bank_base_effect = pba;
2408 for (voice = 0; voice < YDSXG_EFFECT_VOICES; voice++)
2409 for (bank = 0; bank < 2; bank++) {
2410 codec->bank_effect[voice][bank] =
2411 (ymfpci_effect_bank_t *) (ptr + off);
2412 off += bank_size_effect;
2414 off = (off + 0xff) & ~0xff;
2418 codec->work_base = pba;
2423 static void ymfpci_memfree(ymfpci_t *codec)
2425 ymfpci_writel(codec, YDSXGR_PLAYCTRLBASE, 0);
2426 ymfpci_writel(codec, YDSXGR_RECCTRLBASE, 0);
2427 ymfpci_writel(codec, YDSXGR_EFFCTRLBASE, 0);
2428 ymfpci_writel(codec, YDSXGR_WORKBASE, 0);
2429 ymfpci_writel(codec, YDSXGR_WORKSIZE, 0);
2430 pci_free_consistent(codec->pci,
2431 codec->dma_area_size, codec->dma_area_va, codec->dma_area_ba);
2434 static void ymf_memload(ymfpci_t *unit)
2437 ymfpci_writel(unit, YDSXGR_PLAYCTRLBASE, unit->ctrl_playback_ba);
2438 ymfpci_writel(unit, YDSXGR_RECCTRLBASE, unit->bank_base_capture);
2439 ymfpci_writel(unit, YDSXGR_EFFCTRLBASE, unit->bank_base_effect);
2440 ymfpci_writel(unit, YDSXGR_WORKBASE, unit->work_base);
2441 ymfpci_writel(unit, YDSXGR_WORKSIZE, unit->work_size >> 2);
2443 /* S/PDIF output initialization */
2444 ymfpci_writew(unit, YDSXGR_SPDIFOUTCTRL, 0);
2445 ymfpci_writew(unit, YDSXGR_SPDIFOUTSTATUS,
2446 SND_PCM_AES0_CON_EMPHASIS_NONE |
2447 (SND_PCM_AES1_CON_ORIGINAL << 8) |
2448 (SND_PCM_AES1_CON_PCM_CODER << 8));
2450 /* S/PDIF input initialization */
2451 ymfpci_writew(unit, YDSXGR_SPDIFINCTRL, 0);
2453 /* move this volume setup to mixer */
2454 ymfpci_writel(unit, YDSXGR_NATIVEDACOUTVOL, 0x3fff3fff);
2455 ymfpci_writel(unit, YDSXGR_BUF441OUTVOL, 0);
2456 ymfpci_writel(unit, YDSXGR_NATIVEADCINVOL, 0x3fff3fff);
2457 ymfpci_writel(unit, YDSXGR_NATIVEDACINVOL, 0x3fff3fff);
2460 static int ymf_ac97_init(ymfpci_t *unit, int num_ac97)
2462 struct ac97_codec *codec;
2465 if ((codec = ac97_alloc_codec()) == NULL)
2468 /* initialize some basic codec information, other fields will be filled
2469 in ac97_probe_codec */
2470 codec->private_data = unit;
2471 codec->id = num_ac97;
2473 codec->codec_read = ymfpci_codec_read;
2474 codec->codec_write = ymfpci_codec_write;
2476 if (ac97_probe_codec(codec) == 0) {
2477 printk(KERN_ERR "ymfpci: ac97_probe_codec failed\n");
2481 eid = ymfpci_codec_read(codec, AC97_EXTENDED_ID);
2483 printk(KERN_WARNING "ymfpci: no codec attached ?\n");
2487 unit->ac97_features = eid;
2489 if ((codec->dev_mixer = register_sound_mixer(&ymf_mixer_fops, -1)) < 0) {
2490 printk(KERN_ERR "ymfpci: couldn't register mixer!\n");
2494 unit->ac97_codec[num_ac97] = codec;
2498 ac97_release_codec(codec);
2502 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2505 static int synth_io;
2506 MODULE_PARM(mpu_io, "i");
2507 MODULE_PARM(synth_io, "i");
2509 static int mpu_io = 0x330;
2510 static int synth_io = 0x388;
2512 static int assigned;
2513 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2515 static int __devinit ymf_probe_one(struct pci_dev *pcidev, const struct pci_device_id *ent)
2523 if ((err = pci_enable_device(pcidev)) != 0) {
2524 printk(KERN_ERR "ymfpci: pci_enable_device failed\n");
2527 base = pci_resource_start(pcidev, 0);
2529 if ((codec = kmalloc(sizeof(ymfpci_t), GFP_KERNEL)) == NULL) {
2530 printk(KERN_ERR "ymfpci: no core\n");
2533 memset(codec, 0, sizeof(*codec));
2535 spin_lock_init(&codec->reg_lock);
2536 spin_lock_init(&codec->voice_lock);
2537 spin_lock_init(&codec->ac97_lock);
2538 init_MUTEX(&codec->open_sem);
2539 INIT_LIST_HEAD(&codec->states);
2540 codec->pci = pcidev;
2542 pci_read_config_byte(pcidev, PCI_REVISION_ID, &codec->rev);
2544 if (request_mem_region(base, 0x8000, "ymfpci") == NULL) {
2545 printk(KERN_ERR "ymfpci: unable to request mem region\n");
2549 if ((codec->reg_area_virt = ioremap(base, 0x8000)) == NULL) {
2550 printk(KERN_ERR "ymfpci: unable to map registers\n");
2551 goto out_release_region;
2554 pci_set_master(pcidev);
2556 printk(KERN_INFO "ymfpci: %s at 0x%lx IRQ %d\n",
2557 (char *)ent->driver_data, base, pcidev->irq);
2559 ymfpci_aclink_reset(pcidev);
2560 if (ymfpci_codec_ready(codec, 0, 1) < 0)
2563 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2564 if (assigned == 0) {
2565 codec->iomidi = mpu_io;
2566 codec->iosynth = synth_io;
2567 if (ymfpci_setup_legacy(codec, pcidev) < 0)
2573 ymfpci_download_image(codec);
2575 if (ymfpci_memalloc(codec) < 0)
2576 goto out_disable_dsp;
2579 if (request_irq(pcidev->irq, ymf_interrupt, SA_SHIRQ, "ymfpci", codec) != 0) {
2580 printk(KERN_ERR "ymfpci: unable to request IRQ %d\n",
2585 /* register /dev/dsp */
2586 if ((codec->dev_audio = register_sound_dsp(&ymf_fops, -1)) < 0) {
2587 printk(KERN_ERR "ymfpci: unable to register dsp\n");
2592 * Poke just the primary for the moment.
2594 if ((err = ymf_ac97_init(codec, 0)) != 0)
2595 goto out_unregister_sound_dsp;
2597 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2598 codec->opl3_data.name = "ymfpci";
2599 codec->mpu_data.name = "ymfpci";
2601 codec->opl3_data.io_base = codec->iosynth;
2602 codec->opl3_data.irq = -1;
2604 codec->mpu_data.io_base = codec->iomidi;
2605 codec->mpu_data.irq = -1; /* May be different from our PCI IRQ. */
2607 if (codec->iomidi) {
2608 if (!probe_uart401(&codec->mpu_data, THIS_MODULE)) {
2609 codec->iomidi = 0; /* XXX kludge */
2612 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2614 /* put it into driver list */
2615 spin_lock(&ymf_devs_lock);
2616 list_add_tail(&codec->ymf_devs, &ymf_devs);
2617 spin_unlock(&ymf_devs_lock);
2618 pci_set_drvdata(pcidev, codec);
2622 out_unregister_sound_dsp:
2623 unregister_sound_dsp(codec->dev_audio);
2625 free_irq(pcidev->irq, codec);
2627 ymfpci_memfree(codec);
2629 ymfpci_disable_dsp(codec);
2630 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2631 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2632 ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2634 iounmap(codec->reg_area_virt);
2636 release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2638 if (codec->ac97_codec[0])
2639 ac97_release_codec(codec->ac97_codec[0]);
2643 static void __devexit ymf_remove_one(struct pci_dev *pcidev)
2646 ymfpci_t *codec = pci_get_drvdata(pcidev);
2648 /* remove from list of devices */
2649 spin_lock(&ymf_devs_lock);
2650 list_del(&codec->ymf_devs);
2651 spin_unlock(&ymf_devs_lock);
2653 unregister_sound_mixer(codec->ac97_codec[0]->dev_mixer);
2654 ac97_release_codec(codec->ac97_codec[0]);
2655 unregister_sound_dsp(codec->dev_audio);
2656 free_irq(pcidev->irq, codec);
2657 ymfpci_memfree(codec);
2658 ymfpci_writel(codec, YDSXGR_STATUS, ~0);
2659 ymfpci_disable_dsp(codec);
2660 ctrl = ymfpci_readw(codec, YDSXGR_GLOBALCTRL);
2661 ymfpci_writew(codec, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
2662 iounmap(codec->reg_area_virt);
2663 release_mem_region(pci_resource_start(pcidev, 0), 0x8000);
2664 #ifdef CONFIG_SOUND_YMFPCI_LEGACY
2665 if (codec->iomidi) {
2666 unload_uart401(&codec->mpu_data);
2668 #endif /* CONFIG_SOUND_YMFPCI_LEGACY */
2671 MODULE_AUTHOR("Jaroslav Kysela");
2672 MODULE_DESCRIPTION("Yamaha YMF7xx PCI Audio");
2673 MODULE_LICENSE("GPL");
2675 static struct pci_driver ymfpci_driver = {
2677 .id_table = ymf_id_tbl,
2678 .probe = ymf_probe_one,
2679 .remove = __devexit_p(ymf_remove_one),
2680 .suspend = ymf_suspend,
2681 .resume = ymf_resume
2684 static int __init ymf_init_module(void)
2686 return pci_module_init(&ymfpci_driver);
2689 static void __exit ymf_cleanup_module (void)
2691 pci_unregister_driver(&ymfpci_driver);
2694 module_init(ymf_init_module);
2695 module_exit(ymf_cleanup_module);