2 * ALI ali5455 and friends ICH driver for Linux
3 * LEI HU <Lei_Hu@ali.com.tw>
6 * drivers/sound/i810_audio
8 * The ALi 5455 is similar but not quite identical to the Intel ICH
9 * series of controllers. Its easier to keep the driver separated from
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 * ALi 5455 theory of operation
29 * The chipset provides three DMA channels that talk to an AC97
30 * CODEC (AC97 is a digital/analog mixer standard). At its simplest
31 * you get 48Khz audio with basic volume and mixer controls. At the
32 * best you get rate adaption in the codec. We set the card up so
33 * that we never take completion interrupts but instead keep the card
34 * chasing its tail around a ring buffer. This is needed for mmap
35 * mode audio and happens to work rather well for non-mmap modes too.
37 * The board has one output channel for PCM audio (supported) and
38 * a stereo line in and mono microphone input. Again these are normally
39 * locked to 48Khz only. Right now recording is not finished.
41 * There is no midi support, no synth support. Use timidity. To get
42 * esd working you need to use esd -r 48000 as it won't probe 48KHz
43 * by default. mpg123 can't handle 48Khz only audio so use xmms.
45 * If you need to force a specific rate set the clocking= option
49 #include <linux/module.h>
50 #include <linux/string.h>
51 #include <linux/ctype.h>
52 #include <linux/ioport.h>
53 #include <linux/sched.h>
54 #include <linux/delay.h>
55 #include <linux/sound.h>
56 #include <linux/slab.h>
57 #include <linux/soundcard.h>
58 #include <linux/pci.h>
61 #include <linux/init.h>
62 #include <linux/poll.h>
63 #include <linux/spinlock.h>
64 #include <linux/smp_lock.h>
65 #include <linux/ac97_codec.h>
66 #include <linux/interrupt.h>
67 #include <asm/uaccess.h>
68 #include <asm/hardirq.h>
70 #ifndef PCI_DEVICE_ID_ALI_5455
71 #define PCI_DEVICE_ID_ALI_5455 0x5455
74 #ifndef PCI_VENDOR_ID_ALI
75 #define PCI_VENDOR_ID_ALI 0x10b9
78 static int strict_clocking = 0;
79 static unsigned int clocking = 0;
80 static unsigned int codec_pcmout_share_spdif_locked = 0;
81 static unsigned int codec_independent_spdif_locked = 0;
82 static unsigned int controller_pcmout_share_spdif_locked = 0;
83 static unsigned int controller_independent_spdif_locked = 0;
84 static unsigned int globel = 0;
88 #define CODEC_SPDIFOUT_RUNNING 8
89 #define CONTROLLER_SPDIFOUT_RUNNING 4
91 #define SPDIF_ENABLE_OUTPUT 4 /* bits 0,1 are PCM */
93 #define ALI5455_FMT_16BIT 1
94 #define ALI5455_FMT_STEREO 2
95 #define ALI5455_FMT_MASK 3
97 #define SPDIF_ON 0x0004
98 #define SURR_ON 0x0010
99 #define CENTER_LFE_ON 0x0020
100 #define VOL_MUTED 0x8000
103 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
104 /* the 810's array of pointers to data buffers */
107 #define BUSADDR_MASK 0xFFFFFFFE
109 #define CON_IOC 0x80000000 /* interrupt on completion */
110 #define CON_BUFPAD 0x40000000 /* pad underrun with last sample, else 0 */
111 #define CON_BUFLEN_MASK 0x0000ffff /* buffer length in samples */
115 /* an instance of the ali channel */
118 /* these sg guys should probably be allocated
119 separately as nocache. Must be 8 byte aligned */
120 struct sg_item sg[SG_LEN]; /* 32*8 */
128 * we have 3 separate dma engines. pcm in, pcm out, and mic.
129 * each dma engine has controlling registers. These goofy
130 * names are from the datasheet, but make it easy to write
131 * code while leafing through it.
134 #define ENUM_ENGINE(PRE,DIG) \
136 PRE##_BDBAR = 0x##DIG##0, /* Buffer Descriptor list Base Address */ \
137 PRE##_CIV = 0x##DIG##4, /* Current Index Value */ \
138 PRE##_LVI = 0x##DIG##5, /* Last Valid Index */ \
139 PRE##_SR = 0x##DIG##6, /* Status Register */ \
140 PRE##_PICB = 0x##DIG##8, /* Position In Current Buffer */ \
141 PRE##_CR = 0x##DIG##b /* Control Register */ \
144 ENUM_ENGINE(OFF, 0); /* Offsets */
145 ENUM_ENGINE(PI, 4); /* PCM In */
146 ENUM_ENGINE(PO, 5); /* PCM Out */
147 ENUM_ENGINE(MC, 6); /* Mic In */
148 ENUM_ENGINE(CODECSPDIFOUT, 7); /* CODEC SPDIF OUT */
149 ENUM_ENGINE(CONTROLLERSPDIFIN, A); /* CONTROLLER SPDIF In */
150 ENUM_ENGINE(CONTROLLERSPDIFOUT, B); /* CONTROLLER SPDIF OUT */
154 ALI_SCR = 0x00, /* System Control Register */
155 ALI_SSR = 0x04, /* System Status Register */
156 ALI_DMACR = 0x08, /* DMA Control Register */
157 ALI_FIFOCR1 = 0x0c, /* FIFO Control Register 1 */
158 ALI_INTERFACECR = 0x10, /* Interface Control Register */
159 ALI_INTERRUPTCR = 0x14, /* Interrupt control Register */
160 ALI_INTERRUPTSR = 0x18, /* Interrupt Status Register */
161 ALI_FIFOCR2 = 0x1c, /* FIFO Control Register 2 */
162 ALI_CPR = 0x20, /* Command Port Register */
163 ALI_SPR = 0x24, /* Status Port Register */
164 ALI_FIFOCR3 = 0x2c, /* FIFO Control Register 3 */
165 ALI_TTSR = 0x30, /* Transmit Tag Slot Register */
166 ALI_RTSR = 0x34, /* Receive Tag Slot Register */
167 ALI_CSPSR = 0x38, /* Command/Status Port Status Register */
168 ALI_CAS = 0x3c, /* Codec Write Semaphore Register */
169 ALI_SPDIFCSR = 0xf8, /* spdif channel status register */
170 ALI_SPDIFICS = 0xfc /* spdif interface control/status */
173 // x-status register(x:pcm in ,pcm out, mic in,)
174 /* interrupts for a dma engine */
175 #define DMA_INT_FIFO (1<<4) /* fifo under/over flow */
176 #define DMA_INT_COMPLETE (1<<3) /* buffer read/write complete and ioc set */
177 #define DMA_INT_LVI (1<<2) /* last valid done */
178 #define DMA_INT_CELV (1<<1) /* last valid is current */
179 #define DMA_INT_DCH (1) /* DMA Controller Halted (happens on LVI interrupts) */ //not eqult intel
180 #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
182 /* interrupts for the whole chip */// by interrupt status register finish
184 #define INT_SPDIFOUT (1<<23) /* controller spdif out INTERRUPT */
185 #define INT_SPDIFIN (1<<22)
186 #define INT_CODECSPDIFOUT (1<<19)
187 #define INT_MICIN (1<<18)
188 #define INT_PCMOUT (1<<17)
189 #define INT_PCMIN (1<<16)
190 #define INT_CPRAIS (1<<7)
191 #define INT_SPRAIS (1<<5)
192 #define INT_GPIO (1<<1)
193 #define INT_MASK (INT_SPDIFOUT|INT_CODECSPDIFOUT|INT_MICIN|INT_PCMOUT|INT_PCMIN)
195 #define DRIVER_VERSION "0.02ac"
197 /* magic numbers to protect our data structures */
198 #define ALI5455_CARD_MAGIC 0x5072696E /* "Prin" */
199 #define ALI5455_STATE_MAGIC 0x63657373 /* "cess" */
200 #define ALI5455_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
201 #define NR_HW_CH 5 //I think 5 channel
203 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
206 /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
207 /* stream at a minimum for this card to be happy */
208 static const unsigned sample_size[] = { 1, 2, 2, 4 };
209 /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
210 /* values are one less than might be expected */
211 static const unsigned sample_shift[] = { -1, 0, 0, 1 };
214 static char *card_names[] = {
218 static struct pci_device_id ali_pci_tbl[] = {
219 {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5455,
220 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI5455},
224 MODULE_DEVICE_TABLE(pci, ali_pci_tbl);
227 #define PM_SUSPENDED(card) (card->pm_suspended)
229 #define PM_SUSPENDED(card) (0)
232 /* "software" or virtual channel, an instance of opened /dev/dsp */
235 struct ali_card *card; /* Card info */
237 /* single open lock mechanism, only used for recording */
238 struct semaphore open_sem;
239 wait_queue_head_t open_wait;
244 /* virtual channel number */
248 unsigned int pm_saved_dac_rate, pm_saved_adc_rate;
251 /* wave sample stuff */
253 unsigned char fmt, enable, trigger;
255 /* hardware channel */
256 struct ali_channel *read_channel;
257 struct ali_channel *write_channel;
258 struct ali_channel *codec_spdifout_channel;
259 struct ali_channel *controller_spdifout_channel;
261 /* OSS buffer management stuff */
263 dma_addr_t dma_handle;
268 /* our buffer acts like a circular ring */
269 unsigned hwptr; /* where dma last started, updated by update_ptr */
270 unsigned swptr; /* where driver last clear/filled, updated by read/write */
271 int count; /* bytes to be consumed or been generated by dma machine */
272 unsigned total_bytes; /* total bytes dmaed by hardware */
274 unsigned error; /* number of over/underruns */
275 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
277 /* redundant, but makes calculations easier */
278 /* what the hardware uses */
281 unsigned fragsamples;
283 /* what we tell the user to expect */
285 unsigned userfragsize;
290 unsigned update_flag;
291 unsigned ossfragsize;
292 unsigned ossmaxfrags;
293 unsigned subdivision;
299 struct ali_channel channel[5];
302 /* We keep ali5455 cards in a linked list */
303 struct ali_card *next;
305 /* The ali has a certain amount of cross channel interaction
306 so we use a single per card lock */
308 spinlock_t ac97_lock;
310 /* PCI device stuff */
311 struct pci_dev *pci_dev;
315 u32 pm_save_state[64 / sizeof(u32)];
316 int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
318 /* soundcore stuff */
321 /* structures for abstraction of hardware facilities, codecs, banks and channels */
322 struct ac97_codec *ac97_codec[NR_AC97];
323 struct ali_state *states[NR_HW_CH];
329 /* hardware resources */
330 unsigned long iobase;
334 /* Function support */
335 struct ali_channel *(*alloc_pcm_channel) (struct ali_card *);
336 struct ali_channel *(*alloc_rec_pcm_channel) (struct ali_card *);
337 struct ali_channel *(*alloc_rec_mic_channel) (struct ali_card *);
338 struct ali_channel *(*alloc_codec_spdifout_channel) (struct ali_card *);
339 struct ali_channel *(*alloc_controller_spdifout_channel) (struct ali_card *);
340 void (*free_pcm_channel) (struct ali_card *, int chan);
342 /* We have a *very* long init time possibly, so use this to block */
343 /* attempts to open our devices before we are ready (stops oops'es) */
348 static struct ali_card *devs = NULL;
350 static int ali_open_mixdev(struct inode *inode, struct file *file);
351 static int ali_ioctl_mixdev(struct inode *inode, struct file *file,
352 unsigned int cmd, unsigned long arg);
353 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg);
354 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
356 static struct ali_channel *ali_alloc_pcm_channel(struct ali_card *card)
358 if (card->channel[1].used == 1)
360 card->channel[1].used = 1;
361 return &card->channel[1];
364 static struct ali_channel *ali_alloc_rec_pcm_channel(struct ali_card *card)
366 if (card->channel[0].used == 1)
368 card->channel[0].used = 1;
369 return &card->channel[0];
372 static struct ali_channel *ali_alloc_rec_mic_channel(struct ali_card *card)
374 if (card->channel[2].used == 1)
376 card->channel[2].used = 1;
377 return &card->channel[2];
380 static struct ali_channel *ali_alloc_codec_spdifout_channel(struct ali_card *card)
382 if (card->channel[3].used == 1)
384 card->channel[3].used = 1;
385 return &card->channel[3];
388 static struct ali_channel *ali_alloc_controller_spdifout_channel(struct ali_card *card)
390 if (card->channel[4].used == 1)
392 card->channel[4].used = 1;
393 return &card->channel[4];
395 static void ali_free_pcm_channel(struct ali_card *card, int channel)
397 card->channel[channel].used = 0;
401 //add support codec spdif out
402 static int ali_valid_spdif_rate(struct ac97_codec *codec, int rate)
404 unsigned long id = 0L;
406 id = (ali_ac97_get(codec, AC97_VENDOR_ID1) << 16);
407 id |= ali_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
409 case 0x41445361: /* AD1886 */
414 case 0x414c4720: /* ALC650 */
419 default: /* all other codecs, until we know otherwiae */
420 if (rate == 48000 || rate == 44100 || rate == 32000) {
428 /* ali_set_spdif_output
430 * Configure the S/PDIF output transmitter. When we turn on
431 * S/PDIF, we turn off the analog output. This may not be
432 * the right thing to do.
435 * The DSP sample rate must already be set to a supported
436 * S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
438 static void ali_set_spdif_output(struct ali_state *state, int slots,
443 struct ac97_codec *codec = state->card->ac97_codec[0];
445 if (!(state->card->ac97_features & 4)) {
446 state->card->ac97_status &= ~SPDIF_ON;
448 if (slots == -1) { /* Turn off S/PDIF */
449 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
450 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
452 /* If the volume wasn't muted before we turned on S/PDIF, unmute it */
453 if (!(state->card->ac97_status & VOL_MUTED)) {
454 aud_reg = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
455 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO,
456 (aud_reg & ~VOL_MUTED));
458 state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
462 vol = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
463 state->card->ac97_status = vol & VOL_MUTED;
465 /* Set S/PDIF transmitter sample rate */
466 aud_reg = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
469 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
472 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
475 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
478 /* turn off S/PDIF */
479 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
480 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
481 state->card->ac97_status &= ~SPDIF_ON;
485 ali_ac97_set(codec, AC97_SPDIF_CONTROL, aud_reg);
487 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
488 aud_reg = (aud_reg & AC97_EA_SLOT_MASK) | slots | AC97_EA_SPDIF;
489 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
491 aud_reg = ali_ac97_get(codec, AC97_POWER_CONTROL);
493 ali_ac97_set(codec, AC97_POWER_CONTROL, aud_reg);
496 state->card->ac97_status |= SPDIF_ON;
498 /* Check to make sure the configuration is valid */
499 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
500 if (!(aud_reg & 0x0400)) {
501 /* turn off S/PDIF */
502 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
503 state->card->ac97_status &= ~SPDIF_ON;
506 if (codec_independent_spdif_locked > 0) {
507 aud_reg = ali_ac97_get(codec, 0x6a);
508 ali_ac97_set(codec, 0x6a, (aud_reg & 0xefff));
510 /* Mute the analog output */
511 /* Should this only mute the PCM volume??? */
515 /* ali_set_dac_channels
517 * Configure the codec's multi-channel DACs
519 * The logic is backwards. Setting the bit to 1 turns off the DAC.
521 * What about the ICH? We currently configure it using the
522 * SNDCTL_DSP_CHANNELS ioctl. If we're turnning on the DAC,
523 * does that imply that we want the ICH set to support
527 * vailidate that the codec really supports these DACs
528 * before turning them on.
530 static void ali_set_dac_channels(struct ali_state *state, int channel)
533 struct ac97_codec *codec = state->card->ac97_codec[0];
535 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
536 aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
537 state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
540 case 2: /* always enabled */
543 aud_reg &= ~AC97_EA_PRJ;
544 state->card->ac97_status |= SURR_ON;
547 aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
548 state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
553 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
557 /* set playback sample rate */
558 static unsigned int ali_set_dac_rate(struct ali_state *state,
561 struct dmabuf *dmabuf = &state->dmabuf;
563 struct ac97_codec *codec = state->card->ac97_codec[0];
565 if (!(state->card->ac97_features & 0x0001)) {
566 dmabuf->rate = clocking;
577 * Adjust for misclocked crap
580 rate = (rate * clocking) / 48000;
582 if (strict_clocking && rate < 8000) {
584 dmabuf->rate = (rate * 48000) / clocking;
587 new_rate = ac97_set_dac_rate(codec, rate);
588 if (new_rate != rate) {
589 dmabuf->rate = (new_rate * 48000) / clocking;
595 /* set recording sample rate */
596 static unsigned int ali_set_adc_rate(struct ali_state *state,
599 struct dmabuf *dmabuf = &state->dmabuf;
601 struct ac97_codec *codec = state->card->ac97_codec[0];
603 if (!(state->card->ac97_features & 0x0001)) {
604 dmabuf->rate = clocking;
615 * Adjust for misclocked crap
618 rate = (rate * clocking) / 48000;
619 if (strict_clocking && rate < 8000) {
621 dmabuf->rate = (rate * 48000) / clocking;
624 new_rate = ac97_set_adc_rate(codec, rate);
626 if (new_rate != rate) {
627 dmabuf->rate = (new_rate * 48000) / clocking;
633 /* set codec independent spdifout sample rate */
634 static unsigned int ali_set_codecspdifout_rate(struct ali_state *state,
637 struct dmabuf *dmabuf = &state->dmabuf;
639 if (!(state->card->ac97_features & 0x0001)) {
640 dmabuf->rate = clocking;
653 /* set controller independent spdif out function sample rate */
654 static void ali_set_spdifout_rate(struct ali_state *state,
657 unsigned char ch_st_sel;
658 unsigned short status_rate;
673 ch_st_sel = inb(state->card->iobase + ALI_SPDIFICS) & ALI_SPDIF_OUT_CH_STATUS; //select spdif_out
675 ch_st_sel |= 0x80; //select right
676 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
677 outb(status_rate | 0x20, (state->card->iobase + ALI_SPDIFCSR + 2));
679 ch_st_sel &= (~0x80); //select left
680 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
681 outw(status_rate | 0x10, (state->card->iobase + ALI_SPDIFCSR + 2));
684 /* get current playback/recording dma buffer pointer (byte offset from LBA),
685 called with spinlock held! */
687 static inline unsigned ali_get_dma_addr(struct ali_state *state, int rec)
689 struct dmabuf *dmabuf = &state->dmabuf;
690 unsigned int civ, offset, port, port_picb;
697 port = state->card->iobase + dmabuf->read_channel->port;
699 port = state->card->iobase + dmabuf->codec_spdifout_channel->port;
701 port = state->card->iobase + dmabuf->controller_spdifout_channel->port;
703 port = state->card->iobase + dmabuf->write_channel->port;
705 port_picb = port + OFF_PICB;
708 civ = inb(port + OFF_CIV) & 31;
709 offset = inw(port_picb);
710 /* Must have a delay here! */
714 /* Reread both registers and make sure that that total
715 * offset from the first reading to the second is 0.
716 * There is an issue with SiS hardware where it will count
717 * picb down to 0, then update civ to the next value,
718 * then set the new picb to fragsize bytes. We can catch
719 * it between the civ update and the picb update, making
720 * it look as though we are 1 fragsize ahead of where we
721 * are. The next to we get the address though, it will
722 * be back in thdelay is more than long enough
723 * that we won't have to worry about the chip still being
724 * out of sync with reality ;-)
726 } while (civ != (inb(port + OFF_CIV) & 31) || offset != inw(port_picb));
728 data = ((civ + 1) * dmabuf->fragsize - (2 * offset)) % dmabuf->dmasize;
729 if (inw(port_picb) == 0)
735 /* Stop recording (lock held) */
736 static inline void __stop_adc(struct ali_state *state)
738 struct dmabuf *dmabuf = &state->dmabuf;
739 struct ali_card *card = state->card;
741 dmabuf->enable &= ~ADC_RUNNING;
743 outl((1 << 18) | (1 << 16), card->iobase + ALI_DMACR);
746 outb(0, card->iobase + PI_CR);
747 while (inb(card->iobase + PI_CR) != 0);
749 // now clear any latent interrupt bits (like the halt bit)
750 outb(inb(card->iobase + PI_SR) | 0x001e, card->iobase + PI_SR);
751 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMIN, card->iobase + ALI_INTERRUPTSR);
754 static void stop_adc(struct ali_state *state)
756 struct ali_card *card = state->card;
758 spin_lock_irqsave(&card->lock, flags);
760 spin_unlock_irqrestore(&card->lock, flags);
763 static inline void __start_adc(struct ali_state *state)
765 struct dmabuf *dmabuf = &state->dmabuf;
767 if (dmabuf->count < dmabuf->dmasize && dmabuf->ready
768 && !dmabuf->enable && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
769 dmabuf->enable |= ADC_RUNNING;
770 outb((1 << 4) | (1 << 2), state->card->iobase + PI_CR);
771 if (state->card->channel[0].used == 1)
772 outl(1, state->card->iobase + ALI_DMACR); // DMA CONTROL REGISTRER
774 if (state->card->channel[2].used == 1)
775 outl((1 << 2), state->card->iobase + ALI_DMACR); //DMA CONTROL REGISTER
780 static void start_adc(struct ali_state *state)
782 struct ali_card *card = state->card;
785 spin_lock_irqsave(&card->lock, flags);
787 spin_unlock_irqrestore(&card->lock, flags);
790 /* stop playback (lock held) */
791 static inline void __stop_dac(struct ali_state *state)
793 struct dmabuf *dmabuf = &state->dmabuf;
794 struct ali_card *card = state->card;
796 dmabuf->enable &= ~DAC_RUNNING;
797 outl(0x00020000, card->iobase + 0x08);
798 outb(0, card->iobase + PO_CR);
799 while (inb(card->iobase + PO_CR) != 0)
802 outb(inb(card->iobase + PO_SR) | 0x001e, card->iobase + PO_SR);
804 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMOUT, card->iobase + ALI_INTERRUPTSR);
807 static void stop_dac(struct ali_state *state)
809 struct ali_card *card = state->card;
811 spin_lock_irqsave(&card->lock, flags);
813 spin_unlock_irqrestore(&card->lock, flags);
816 static inline void __start_dac(struct ali_state *state)
818 struct dmabuf *dmabuf = &state->dmabuf;
819 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
820 (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
821 dmabuf->enable |= DAC_RUNNING;
822 outb((1 << 4) | (1 << 2), state->card->iobase + PO_CR);
823 outl((1 << 1), state->card->iobase + 0x08); //dma control register
827 static void start_dac(struct ali_state *state)
829 struct ali_card *card = state->card;
831 spin_lock_irqsave(&card->lock, flags);
833 spin_unlock_irqrestore(&card->lock, flags);
836 /* stop codec and controller spdif out (lock held) */
837 static inline void __stop_spdifout(struct ali_state *state)
839 struct dmabuf *dmabuf = &state->dmabuf;
840 struct ali_card *card = state->card;
842 if (codec_independent_spdif_locked > 0) {
843 dmabuf->enable &= ~CODEC_SPDIFOUT_RUNNING;
844 outl((1 << 19), card->iobase + 0x08);
845 outb(0, card->iobase + CODECSPDIFOUT_CR);
847 while (inb(card->iobase + CODECSPDIFOUT_CR) != 0)
850 outb(inb(card->iobase + CODECSPDIFOUT_SR) | 0x001e, card->iobase + CODECSPDIFOUT_SR);
851 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_CODECSPDIFOUT, card->iobase + ALI_INTERRUPTSR);
853 if (controller_independent_spdif_locked > 0) {
854 dmabuf->enable &= ~CONTROLLER_SPDIFOUT_RUNNING;
855 outl((1 << 23), card->iobase + 0x08);
856 outb(0, card->iobase + CONTROLLERSPDIFOUT_CR);
857 while (inb(card->iobase + CONTROLLERSPDIFOUT_CR) != 0)
859 outb(inb(card->iobase + CONTROLLERSPDIFOUT_SR) | 0x001e, card->iobase + CONTROLLERSPDIFOUT_SR);
860 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_SPDIFOUT, card->iobase + ALI_INTERRUPTSR);
865 static void stop_spdifout(struct ali_state *state)
867 struct ali_card *card = state->card;
869 spin_lock_irqsave(&card->lock, flags);
870 __stop_spdifout(state);
871 spin_unlock_irqrestore(&card->lock, flags);
874 static inline void __start_spdifout(struct ali_state *state)
876 struct dmabuf *dmabuf = &state->dmabuf;
877 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
878 (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
879 if (codec_independent_spdif_locked > 0) {
880 dmabuf->enable |= CODEC_SPDIFOUT_RUNNING;
881 outb((1 << 4) | (1 << 2), state->card->iobase + CODECSPDIFOUT_CR);
882 outl((1 << 3), state->card->iobase + 0x08); //dma control register
884 if (controller_independent_spdif_locked > 0) {
885 dmabuf->enable |= CONTROLLER_SPDIFOUT_RUNNING;
886 outb((1 << 4) | (1 << 2), state->card->iobase + CONTROLLERSPDIFOUT_CR);
887 outl((1 << 7), state->card->iobase + 0x08); //dma control register
893 static void start_spdifout(struct ali_state *state)
895 struct ali_card *card = state->card;
897 spin_lock_irqsave(&card->lock, flags);
898 __start_spdifout(state);
899 spin_unlock_irqrestore(&card->lock, flags);
902 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
903 #define DMABUF_MINORDER 1
905 /* allocate DMA buffer, playback , recording,spdif out buffer should be allocated separately */
906 static int alloc_dmabuf(struct ali_state *state)
908 struct dmabuf *dmabuf = &state->dmabuf;
911 struct page *page, *pend;
913 /* If we don't have any oss frag params, then use our default ones */
914 if (dmabuf->ossmaxfrags == 0)
915 dmabuf->ossmaxfrags = 4;
916 if (dmabuf->ossfragsize == 0)
917 dmabuf->ossfragsize = (PAGE_SIZE << DMABUF_DEFAULTORDER) / dmabuf->ossmaxfrags;
918 size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
920 if (dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
922 /* alloc enough to satisfy the oss params */
923 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
924 if ((PAGE_SIZE << order) > size)
926 if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
928 &dmabuf->dma_handle)))
934 dmabuf->ready = dmabuf->mapped = 0;
935 dmabuf->rawbuf = rawbuf;
936 dmabuf->buforder = order;
938 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
939 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
940 for (page = virt_to_page(rawbuf); page <= pend; page++)
941 SetPageReserved(page);
945 /* free DMA buffer */
946 static void dealloc_dmabuf(struct ali_state *state)
948 struct dmabuf *dmabuf = &state->dmabuf;
949 struct page *page, *pend;
951 if (dmabuf->rawbuf) {
952 /* undo marking the pages as reserved */
953 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
954 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
955 ClearPageReserved(page);
956 pci_free_consistent(state->card->pci_dev,
957 PAGE_SIZE << dmabuf->buforder,
958 dmabuf->rawbuf, dmabuf->dma_handle);
960 dmabuf->rawbuf = NULL;
961 dmabuf->mapped = dmabuf->ready = 0;
964 static int prog_dmabuf(struct ali_state *state, unsigned rec)
966 struct dmabuf *dmabuf = &state->dmabuf;
967 struct ali_channel *c = NULL;
974 spin_lock_irqsave(&state->card->lock, flags);
975 if (dmabuf->enable & DAC_RUNNING)
977 if (dmabuf->enable & ADC_RUNNING)
979 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
980 __stop_spdifout(state);
981 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
982 __stop_spdifout(state);
984 dmabuf->total_bytes = 0;
985 dmabuf->count = dmabuf->error = 0;
986 dmabuf->swptr = dmabuf->hwptr = 0;
987 spin_unlock_irqrestore(&state->card->lock, flags);
989 /* allocate DMA buffer, let alloc_dmabuf determine if we are already
990 * allocated well enough or if we should replace the current buffer
991 * (assuming one is already allocated, if it isn't, then allocate it).
993 if ((ret = alloc_dmabuf(state)))
996 /* FIXME: figure out all this OSS fragment stuff */
997 /* I did, it now does what it should according to the OSS API. DL */
998 /* We may not have realloced our dmabuf, but the fragment size to
999 * fragment number ratio may have changed, so go ahead and reprogram
1003 dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
1004 dmabuf->numfrag = SG_LEN;
1005 dmabuf->fragsize = dmabuf->dmasize / dmabuf->numfrag;
1006 dmabuf->fragsamples = dmabuf->fragsize >> 1;
1007 dmabuf->userfragsize = dmabuf->ossfragsize;
1008 dmabuf->userfrags = dmabuf->dmasize / dmabuf->ossfragsize;
1010 memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
1012 if (dmabuf->ossmaxfrags == 4) {
1014 dmabuf->fragshift = 2;
1015 } else if (dmabuf->ossmaxfrags == 8) {
1017 dmabuf->fragshift = 3;
1018 } else if (dmabuf->ossmaxfrags == 16) {
1020 dmabuf->fragshift = 4;
1023 dmabuf->fragshift = 5;
1026 * Now set up the ring
1030 c = dmabuf->read_channel;
1032 c = dmabuf->codec_spdifout_channel;
1034 c = dmabuf->controller_spdifout_channel;
1036 c = dmabuf->write_channel;
1040 * Load up 32 sg entries and take an interrupt at half
1041 * way (we might want more interrupts later..)
1043 for (i = 0; i < dmabuf->numfrag; i++) {
1045 virt_to_bus(dmabuf->rawbuf +
1046 dmabuf->fragsize * i);
1047 // the card will always be doing 16bit stereo
1048 sg->control = dmabuf->fragsamples;
1049 sg->control |= CON_BUFPAD; //I modify
1050 // set us up to get IOC interrupts as often as needed to
1051 // satisfy numfrag requirements, no more
1052 if (((i + 1) % fragint) == 0) {
1053 sg->control |= CON_IOC;
1057 spin_lock_irqsave(&state->card->lock, flags);
1058 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
1059 outl(virt_to_bus(&c->sg[0]), state->card->iobase + c->port + OFF_BDBAR);
1060 outb(0, state->card->iobase + c->port + OFF_CIV);
1061 outb(0, state->card->iobase + c->port + OFF_LVI);
1062 spin_unlock_irqrestore(&state->card->lock, flags);
1064 /* set the ready flag for the dma buffer */
1069 static void __ali_update_lvi(struct ali_state *state, int rec)
1071 struct dmabuf *dmabuf = &state->dmabuf;
1073 port = state->card->iobase;
1075 port += dmabuf->read_channel->port;
1077 port += dmabuf->codec_spdifout_channel->port;
1079 port += dmabuf->controller_spdifout_channel->port;
1081 port += dmabuf->write_channel->port;
1082 /* if we are currently stopped, then our CIV is actually set to our
1083 * *last* sg segment and we are ready to wrap to the next. However,
1084 * if we set our LVI to the last sg segment, then it won't wrap to
1085 * the next sg segment, it won't even get a start. So, instead, when
1086 * we are stopped, we set both the LVI value and also we increment
1087 * the CIV value to the next sg segment to be played so that when
1088 * we call start_{dac,adc}, things will operate properly
1090 if (!dmabuf->enable && dmabuf->ready) {
1091 if (rec && dmabuf->count < dmabuf->dmasize && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
1092 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1094 while (! (inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1096 } else if (!rec && dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
1097 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1099 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1101 } else if (rec && dmabuf->count && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
1102 if (codec_independent_spdif_locked > 0) {
1103 // outb((inb(port+OFF_CIV))&31, port+OFF_LVI);
1104 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1105 __start_spdifout(state);
1106 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1109 if (controller_independent_spdif_locked > 0) {
1110 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1111 __start_spdifout(state);
1112 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1119 /* swptr - 1 is the tail of our transfer */
1120 x = (dmabuf->dmasize + dmabuf->swptr - 1) % dmabuf->dmasize;
1121 x /= dmabuf->fragsize;
1122 outb(x, port + OFF_LVI);
1125 static void ali_update_lvi(struct ali_state *state, int rec)
1127 struct dmabuf *dmabuf = &state->dmabuf;
1128 unsigned long flags;
1131 spin_lock_irqsave(&state->card->lock, flags);
1132 __ali_update_lvi(state, rec);
1133 spin_unlock_irqrestore(&state->card->lock, flags);
1136 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1137 static void ali_update_ptr(struct ali_state *state)
1139 struct dmabuf *dmabuf = &state->dmabuf;
1143 /* error handling and process wake up for DAC */
1144 if (dmabuf->enable == ADC_RUNNING) {
1145 /* update hardware pointer */
1146 hwptr = ali_get_dma_addr(state, 1);
1147 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1148 dmabuf->hwptr = hwptr;
1149 dmabuf->total_bytes += diff;
1150 dmabuf->count += diff;
1151 if (dmabuf->count > dmabuf->dmasize) {
1152 /* buffer underrun or buffer overrun */
1153 /* this is normal for the end of a read */
1154 /* only give an error if we went past the */
1155 /* last valid sg entry */
1156 if ((inb(state->card->iobase + PI_CIV) & 31) != (inb(state->card->iobase + PI_LVI) & 31)) {
1157 printk(KERN_WARNING "ali_audio: DMA overrun on read\n");
1161 if (dmabuf->count > dmabuf->userfragsize)
1162 wake_up(&dmabuf->wait);
1164 /* error handling and process wake up for DAC */
1165 if (dmabuf->enable == DAC_RUNNING) {
1166 /* update hardware pointer */
1167 hwptr = ali_get_dma_addr(state, 0);
1169 (dmabuf->dmasize + hwptr -
1170 dmabuf->hwptr) % dmabuf->dmasize;
1171 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
1172 printk("DAC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
1174 dmabuf->hwptr = hwptr;
1175 dmabuf->total_bytes += diff;
1176 dmabuf->count -= diff;
1177 if (dmabuf->count < 0) {
1178 /* buffer underrun or buffer overrun */
1179 /* this is normal for the end of a write */
1180 /* only give an error if we went past the */
1181 /* last valid sg entry */
1182 if ((inb(state->card->iobase + PO_CIV) & 31) != (inb(state->card->iobase + PO_LVI) & 31)) {
1183 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1184 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1185 inb(state->card->iobase + PO_CIV) & 31,
1186 inb(state->card->iobase + PO_LVI) & 31,
1192 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1193 wake_up(&dmabuf->wait);
1196 /* error handling and process wake up for CODEC SPDIF OUT */
1197 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
1198 /* update hardware pointer */
1199 hwptr = ali_get_dma_addr(state, 2);
1200 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1201 dmabuf->hwptr = hwptr;
1202 dmabuf->total_bytes += diff;
1203 dmabuf->count -= diff;
1204 if (dmabuf->count < 0) {
1205 /* buffer underrun or buffer overrun */
1206 /* this is normal for the end of a write */
1207 /* only give an error if we went past the */
1208 /* last valid sg entry */
1209 if ((inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31)) {
1210 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1211 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1212 inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31,
1213 inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31,
1214 dmabuf->hwptr, dmabuf->count);
1218 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1219 wake_up(&dmabuf->wait);
1221 /* error handling and process wake up for CONTROLLER SPDIF OUT */
1222 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
1223 /* update hardware pointer */
1224 hwptr = ali_get_dma_addr(state, 3);
1225 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1226 dmabuf->hwptr = hwptr;
1227 dmabuf->total_bytes += diff;
1228 dmabuf->count -= diff;
1229 if (dmabuf->count < 0) {
1230 /* buffer underrun or buffer overrun */
1231 /* this is normal for the end of a write */
1232 /* only give an error if we went past the */
1233 /* last valid sg entry */
1234 if ((inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31)) {
1236 "ali_audio: DMA overrun on write\n");
1237 printk("ali_audio: CIV %d, LVI %d, hwptr %x, "
1239 inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31,
1240 inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31,
1241 dmabuf->hwptr, dmabuf->count);
1245 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1246 wake_up(&dmabuf->wait);
1250 static inline int ali_get_free_write_space(struct
1254 struct dmabuf *dmabuf = &state->dmabuf;
1257 if (dmabuf->count < 0) {
1259 dmabuf->swptr = dmabuf->hwptr;
1261 free = dmabuf->dmasize - dmabuf->swptr;
1262 if ((dmabuf->count + free) > dmabuf->dmasize){
1263 free = dmabuf->dmasize - dmabuf->count;
1268 static inline int ali_get_available_read_data(struct
1272 struct dmabuf *dmabuf = &state->dmabuf;
1274 ali_update_ptr(state);
1275 // catch overruns during record
1276 if (dmabuf->count > dmabuf->dmasize) {
1277 dmabuf->count = dmabuf->dmasize;
1278 dmabuf->swptr = dmabuf->hwptr;
1280 avail = dmabuf->count;
1281 avail -= (dmabuf->hwptr % dmabuf->fragsize);
1287 static int drain_dac(struct ali_state *state, int signals_allowed)
1290 DECLARE_WAITQUEUE(wait, current);
1291 struct dmabuf *dmabuf = &state->dmabuf;
1292 unsigned long flags;
1297 if (dmabuf->mapped) {
1301 add_wait_queue(&dmabuf->wait, &wait);
1304 spin_lock_irqsave(&state->card->lock, flags);
1305 ali_update_ptr(state);
1306 count = dmabuf->count;
1307 spin_unlock_irqrestore(&state->card->lock, flags);
1311 * This will make sure that our LVI is correct, that our
1312 * pointer is updated, and that the DAC is running. We
1313 * have to force the setting of dmabuf->trigger to avoid
1314 * any possible deadlocks.
1316 if (!dmabuf->enable) {
1317 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1318 ali_update_lvi(state, 0);
1320 if (signal_pending(current) && signals_allowed) {
1324 /* It seems that we have to set the current state to
1325 * TASK_INTERRUPTIBLE every time to make the process
1326 * really go to sleep. This also has to be *after* the
1327 * update_ptr() call because update_ptr is likely to
1328 * do a wake_up() which will unset this before we ever
1329 * try to sleep, resuling in a tight loop in this code
1330 * instead of actually sleeping and waiting for an
1331 * interrupt to wake us up!
1333 set_current_state(TASK_INTERRUPTIBLE);
1335 * set the timeout to significantly longer than it *should*
1336 * take for the DAC to drain the DMA buffer
1338 tmo = (count * HZ) / (dmabuf->rate);
1339 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1340 printk(KERN_ERR "ali_audio: drain_dac, dma timeout?\n");
1345 set_current_state(TASK_RUNNING);
1346 remove_wait_queue(&dmabuf->wait, &wait);
1347 if (count > 0 && signal_pending(current) && signals_allowed)
1348 return -ERESTARTSYS;
1354 static int drain_spdifout(struct ali_state *state, int signals_allowed)
1357 DECLARE_WAITQUEUE(wait, current);
1358 struct dmabuf *dmabuf = &state->dmabuf;
1359 unsigned long flags;
1364 if (dmabuf->mapped) {
1365 stop_spdifout(state);
1368 add_wait_queue(&dmabuf->wait, &wait);
1371 spin_lock_irqsave(&state->card->lock, flags);
1372 ali_update_ptr(state);
1373 count = dmabuf->count;
1374 spin_unlock_irqrestore(&state->card->lock, flags);
1378 * This will make sure that our LVI is correct, that our
1379 * pointer is updated, and that the DAC is running. We
1380 * have to force the setting of dmabuf->trigger to avoid
1381 * any possible deadlocks.
1383 if (!dmabuf->enable) {
1384 if (codec_independent_spdif_locked > 0) {
1385 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1386 ali_update_lvi(state, 2);
1388 if (controller_independent_spdif_locked > 0) {
1389 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1390 ali_update_lvi(state, 3);
1394 if (signal_pending(current) && signals_allowed) {
1398 /* It seems that we have to set the current state to
1399 * TASK_INTERRUPTIBLE every time to make the process
1400 * really go to sleep. This also has to be *after* the
1401 * update_ptr() call because update_ptr is likely to
1402 * do a wake_up() which will unset this before we ever
1403 * try to sleep, resuling in a tight loop in this code
1404 * instead of actually sleeping and waiting for an
1405 * interrupt to wake us up!
1407 set_current_state(TASK_INTERRUPTIBLE);
1409 * set the timeout to significantly longer than it *should*
1410 * take for the DAC to drain the DMA buffer
1412 tmo = (count * HZ) / (dmabuf->rate);
1413 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1414 printk(KERN_ERR "ali_audio: drain_spdifout, dma timeout?\n");
1419 set_current_state(TASK_RUNNING);
1420 remove_wait_queue(&dmabuf->wait, &wait);
1421 if (count > 0 && signal_pending(current) && signals_allowed)
1422 return -ERESTARTSYS;
1423 stop_spdifout(state);
1427 static void ali_channel_interrupt(struct ali_card *card)
1431 for (i = 0; i < NR_HW_CH; i++) {
1432 struct ali_state *state = card->states[i];
1433 struct ali_channel *c = NULL;
1434 struct dmabuf *dmabuf;
1435 unsigned long port = card->iobase;
1439 if (!state->dmabuf.ready)
1441 dmabuf = &state->dmabuf;
1442 if (codec_independent_spdif_locked > 0) {
1443 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
1444 c = dmabuf->codec_spdifout_channel;
1447 if (controller_independent_spdif_locked > 0) {
1448 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1449 c = dmabuf->controller_spdifout_channel;
1451 if (dmabuf->enable & DAC_RUNNING) {
1452 c = dmabuf->write_channel;
1453 } else if (dmabuf->enable & ADC_RUNNING) {
1454 c = dmabuf->read_channel;
1461 status = inw(port + OFF_SR);
1463 if (status & DMA_INT_COMPLETE) {
1464 /* only wake_up() waiters if this interrupt signals
1465 * us being beyond a userfragsize of data open or
1466 * available, and ali_update_ptr() does that for
1469 ali_update_ptr(state);
1472 if (status & DMA_INT_LVI) {
1473 ali_update_ptr(state);
1474 wake_up(&dmabuf->wait);
1476 if (dmabuf->enable & DAC_RUNNING)
1477 count = dmabuf->count;
1478 else if (dmabuf->enable & ADC_RUNNING)
1479 count = dmabuf->dmasize - dmabuf->count;
1480 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1481 count = dmabuf->count;
1482 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1483 count = dmabuf->count;
1487 if (dmabuf->enable & DAC_RUNNING)
1488 outl((1 << 1), state->card->iobase + ALI_DMACR);
1489 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1490 outl((1 << 3), state->card->iobase + ALI_DMACR);
1491 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1492 outl((1 << 7), state->card->iobase + ALI_DMACR);
1494 if (dmabuf->enable & DAC_RUNNING)
1496 if (dmabuf->enable & ADC_RUNNING)
1498 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1499 __stop_spdifout(state);
1500 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1501 __stop_spdifout(state);
1503 wake_up(&dmabuf->wait);
1507 if (!(status & DMA_INT_DCH)) {
1508 ali_update_ptr(state);
1509 wake_up(&dmabuf->wait);
1510 if (dmabuf->enable & DAC_RUNNING)
1511 count = dmabuf->count;
1512 else if (dmabuf->enable & ADC_RUNNING)
1513 count = dmabuf->dmasize - dmabuf->count;
1514 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1515 count = dmabuf->count;
1516 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1517 count = dmabuf->count;
1522 if (dmabuf->enable & DAC_RUNNING)
1523 outl((1 << 1), state->card->iobase + ALI_DMACR);
1524 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1525 outl((1 << 3), state->card->iobase + ALI_DMACR);
1526 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1527 outl((1 << 7), state->card->iobase + ALI_DMACR);
1529 if (dmabuf->enable & DAC_RUNNING)
1531 if (dmabuf->enable & ADC_RUNNING)
1533 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1534 __stop_spdifout(state);
1535 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1536 __stop_spdifout(state);
1538 wake_up(&dmabuf->wait);
1541 outw(status & DMA_INT_MASK, port + OFF_SR);
1545 static irqreturn_t ali_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1547 struct ali_card *card = (struct ali_card *) dev_id;
1551 spin_lock(&card->lock);
1552 status = inl(card->iobase + ALI_INTERRUPTSR);
1553 if (!(status & INT_MASK)) {
1554 spin_unlock(&card->lock);
1555 return IRQ_NONE; /* not for us */
1558 if (codec_independent_spdif_locked > 0) {
1561 status2 = inw(card->iobase + 0x76);
1562 outw(status2 | 0x000c, card->iobase + 0x76);
1564 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1565 ali_channel_interrupt(card);
1568 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1569 ali_channel_interrupt(card);
1573 outl(status & INT_MASK, card->iobase + ALI_INTERRUPTSR);
1574 spin_unlock(&card->lock);
1578 /* in this loop, dmabuf.count signifies the amount of data that is
1579 waiting to be copied to the user's buffer. It is filled by the dma
1580 machine and drained by this loop. */
1582 static ssize_t ali_read(struct file *file, char *buffer,
1583 size_t count, loff_t * ppos)
1585 struct ali_state *state = (struct ali_state *) file->private_data;
1586 struct ali_card *card = state ? state->card : 0;
1587 struct dmabuf *dmabuf = &state->dmabuf;
1589 unsigned long flags;
1592 DECLARE_WAITQUEUE(waita, current);
1594 printk("ali_audio: ali_read called, count = %d\n", count);
1596 if (ppos != &file->f_pos)
1600 if (dmabuf->enable & DAC_RUNNING)
1602 if (!dmabuf->read_channel) {
1604 dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
1605 if (!dmabuf->read_channel) {
1609 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1611 if (!access_ok(VERIFY_WRITE, buffer, count))
1614 add_wait_queue(&dmabuf->wait, &waita);
1616 set_current_state(TASK_INTERRUPTIBLE);
1617 spin_lock_irqsave(&card->lock, flags);
1618 if (PM_SUSPENDED(card)) {
1619 spin_unlock_irqrestore(&card->lock, flags);
1621 if (signal_pending(current)) {
1628 swptr = dmabuf->swptr;
1629 cnt = ali_get_available_read_data(state);
1630 // this is to make the copy_to_user simpler below
1631 if (cnt > (dmabuf->dmasize - swptr))
1632 cnt = dmabuf->dmasize - swptr;
1633 spin_unlock_irqrestore(&card->lock, flags);
1636 /* Lop off the last two bits to force the code to always
1637 * write in full samples. This keeps software that sets
1638 * O_NONBLOCK but doesn't check the return value of the
1639 * write call from getting things out of state where they
1640 * think a full 4 byte sample was written when really only
1641 * a portion was, resulting in odd sound and stereo
1648 * Don't let us deadlock. The ADC won't start if
1649 * dmabuf->trigger isn't set. A call to SETTRIGGER
1650 * could have turned it off after we set it to on
1653 dmabuf->trigger = PCM_ENABLE_INPUT;
1655 * This does three things. Updates LVI to be correct,
1656 * makes sure the ADC is running, and updates the
1659 ali_update_lvi(state, 1);
1660 if (file->f_flags & O_NONBLOCK) {
1665 /* Set the timeout to how long it would take to fill
1666 * two of our buffers. If we haven't been woke up
1667 * by then, then we know something is wrong.
1669 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1671 /* There are two situations when sleep_on_timeout returns, one is when
1672 the interrupt is serviced correctly and the process is waked up by
1673 ISR ON TIME. Another is when timeout is expired, which means that
1674 either interrupt is NOT serviced correctly (pending interrupt) or it
1675 is TOO LATE for the process to be scheduled to run (scheduler latency)
1676 which results in a (potential) buffer overrun. And worse, there is
1677 NOTHING we can do to prevent it. */
1678 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1680 "ali_audio: recording schedule timeout, "
1681 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1682 dmabuf->dmasize, dmabuf->fragsize,
1683 dmabuf->count, dmabuf->hwptr,
1685 /* a buffer overrun, we delay the recovery until next time the
1686 while loop begin and we REALLY have space to record */
1688 if (signal_pending(current)) {
1689 ret = ret ? ret : -ERESTARTSYS;
1695 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1701 swptr = (swptr + cnt) % dmabuf->dmasize;
1702 spin_lock_irqsave(&card->lock, flags);
1703 if (PM_SUSPENDED(card)) {
1704 spin_unlock_irqrestore(&card->lock, flags);
1707 dmabuf->swptr = swptr;
1708 dmabuf->count -= cnt;
1709 spin_unlock_irqrestore(&card->lock, flags);
1715 ali_update_lvi(state, 1);
1716 set_current_state(TASK_RUNNING);
1717 remove_wait_queue(&dmabuf->wait, &waita);
1721 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1722 the soundcard. it is drained by the dma machine and filled by this loop. */
1723 static ssize_t ali_write(struct file *file,
1724 const char *buffer, size_t count, loff_t * ppos)
1726 struct ali_state *state = (struct ali_state *) file->private_data;
1727 struct ali_card *card = state ? state->card : 0;
1728 struct dmabuf *dmabuf = &state->dmabuf;
1730 unsigned long flags;
1731 unsigned int swptr = 0;
1733 DECLARE_WAITQUEUE(waita, current);
1735 printk("ali_audio: ali_write called, count = %d\n", count);
1737 if (ppos != &file->f_pos)
1741 if (dmabuf->enable & ADC_RUNNING)
1743 if (codec_independent_spdif_locked > 0) {
1744 if (!dmabuf->codec_spdifout_channel) {
1746 dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card);
1747 if (!dmabuf->codec_spdifout_channel)
1751 if (controller_independent_spdif_locked > 0) {
1752 if (!dmabuf->controller_spdifout_channel) {
1754 dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card);
1755 if (!dmabuf->controller_spdifout_channel)
1759 if (!dmabuf->write_channel) {
1761 dmabuf->write_channel =
1762 card->alloc_pcm_channel(card);
1763 if (!dmabuf->write_channel)
1769 if (codec_independent_spdif_locked > 0) {
1770 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
1773 if (controller_independent_spdif_locked > 0) {
1774 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
1778 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1782 if (!access_ok(VERIFY_READ, buffer, count))
1785 add_wait_queue(&dmabuf->wait, &waita);
1787 set_current_state(TASK_INTERRUPTIBLE);
1788 spin_lock_irqsave(&state->card->lock, flags);
1789 if (PM_SUSPENDED(card)) {
1790 spin_unlock_irqrestore(&card->lock, flags);
1792 if (signal_pending(current)) {
1800 swptr = dmabuf->swptr;
1801 cnt = ali_get_free_write_space(state);
1802 /* Bound the maximum size to how much we can copy to the
1803 * dma buffer before we hit the end. If we have more to
1804 * copy then it will get done in a second pass of this
1805 * loop starting from the beginning of the buffer.
1807 if (cnt > (dmabuf->dmasize - swptr))
1808 cnt = dmabuf->dmasize - swptr;
1809 spin_unlock_irqrestore(&state->card->lock, flags);
1812 "ali_audio: ali_write: %d bytes available space\n",
1817 /* Lop off the last two bits to force the code to always
1818 * write in full samples. This keeps software that sets
1819 * O_NONBLOCK but doesn't check the return value of the
1820 * write call from getting things out of state where they
1821 * think a full 4 byte sample was written when really only
1822 * a portion was, resulting in odd sound and stereo
1828 // There is data waiting to be played
1830 * Force the trigger setting since we would
1831 * deadlock with it set any other way
1833 if (codec_independent_spdif_locked > 0) {
1834 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1835 ali_update_lvi(state, 2);
1837 if (controller_independent_spdif_locked > 0) {
1838 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1839 ali_update_lvi(state, 3);
1842 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1843 ali_update_lvi(state, 0);
1846 if (file->f_flags & O_NONBLOCK) {
1851 /* Not strictly correct but works */
1852 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1853 /* There are two situations when sleep_on_timeout returns, one is when
1854 the interrupt is serviced correctly and the process is waked up by
1855 ISR ON TIME. Another is when timeout is expired, which means that
1856 either interrupt is NOT serviced correctly (pending interrupt) or it
1857 is TOO LATE for the process to be scheduled to run (scheduler latency)
1858 which results in a (potential) buffer underrun. And worse, there is
1859 NOTHING we can do to prevent it. */
1861 /* FIXME - do timeout handling here !! */
1862 schedule_timeout(tmo >= 2 ? tmo : 2);
1864 if (signal_pending(current)) {
1871 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1877 swptr = (swptr + cnt) % dmabuf->dmasize;
1878 spin_lock_irqsave(&state->card->lock, flags);
1879 if (PM_SUSPENDED(card)) {
1880 spin_unlock_irqrestore(&card->lock, flags);
1884 dmabuf->swptr = swptr;
1885 dmabuf->count += cnt;
1889 spin_unlock_irqrestore(&state->card->lock, flags);
1891 if (swptr % dmabuf->fragsize) {
1892 x = dmabuf->fragsize - (swptr % dmabuf->fragsize);
1893 memset(dmabuf->rawbuf + swptr, '\0', x);
1896 if (codec_independent_spdif_locked > 0) {
1897 ali_update_lvi(state, 2);
1899 if (controller_independent_spdif_locked > 0) {
1900 ali_update_lvi(state, 3);
1902 ali_update_lvi(state, 0);
1905 set_current_state(TASK_RUNNING);
1906 remove_wait_queue(&dmabuf->wait, &waita);
1910 /* No kernel lock - we have our own spinlock */
1911 static unsigned int ali_poll(struct file *file, struct poll_table_struct
1914 struct ali_state *state = (struct ali_state *) file->private_data;
1915 struct dmabuf *dmabuf = &state->dmabuf;
1916 unsigned long flags;
1917 unsigned int mask = 0;
1920 poll_wait(file, &dmabuf->wait, wait);
1921 spin_lock_irqsave(&state->card->lock, flags);
1922 ali_update_ptr(state);
1923 if (file->f_mode & FMODE_READ && dmabuf->enable & ADC_RUNNING) {
1924 if (dmabuf->count >= (signed) dmabuf->fragsize)
1925 mask |= POLLIN | POLLRDNORM;
1927 if (file->f_mode & FMODE_WRITE && (dmabuf->enable & (DAC_RUNNING|CODEC_SPDIFOUT_RUNNING|CONTROLLER_SPDIFOUT_RUNNING))) {
1928 if ((signed) dmabuf->dmasize >= dmabuf->count + (signed) dmabuf->fragsize)
1929 mask |= POLLOUT | POLLWRNORM;
1931 spin_unlock_irqrestore(&state->card->lock, flags);
1935 static int ali_mmap(struct file *file, struct vm_area_struct *vma)
1937 struct ali_state *state = (struct ali_state *) file->private_data;
1938 struct dmabuf *dmabuf = &state->dmabuf;
1942 if (vma->vm_flags & VM_WRITE) {
1943 if (!dmabuf->write_channel && (dmabuf->write_channel = state->card->alloc_pcm_channel(state->card)) == NULL) {
1948 if (vma->vm_flags & VM_READ) {
1949 if (!dmabuf->read_channel && (dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
1954 if ((ret = prog_dmabuf(state, 0)) != 0)
1957 if (vma->vm_pgoff != 0)
1959 size = vma->vm_end - vma->vm_start;
1960 if (size > (PAGE_SIZE << dmabuf->buforder))
1963 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf), size, vma->vm_page_prot))
1966 dmabuf->trigger = 0;
1973 static int ali_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1975 struct ali_state *state = (struct ali_state *) file->private_data;
1976 struct ali_channel *c = NULL;
1977 struct dmabuf *dmabuf = &state->dmabuf;
1978 unsigned long flags;
1979 audio_buf_info abinfo;
1983 struct ac97_codec *codec = state->card->ac97_codec[0];
1985 printk("ali_audio: ali_ioctl, arg=0x%x, cmd=",
1986 arg ? *(int *) arg : 0);
1989 case OSS_GETVERSION:
1991 printk("OSS_GETVERSION\n");
1993 return put_user(SOUND_VERSION, (int *) arg);
1994 case SNDCTL_DSP_RESET:
1996 printk("SNDCTL_DSP_RESET\n");
1998 spin_lock_irqsave(&state->card->lock, flags);
1999 if (dmabuf->enable == DAC_RUNNING) {
2000 c = dmabuf->write_channel;
2003 if (dmabuf->enable == ADC_RUNNING) {
2004 c = dmabuf->read_channel;
2007 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2008 c = dmabuf->codec_spdifout_channel;
2009 __stop_spdifout(state);
2011 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2012 c = dmabuf->controller_spdifout_channel;
2013 __stop_spdifout(state);
2016 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
2017 outl(virt_to_bus(&c->sg[0]),
2018 state->card->iobase + c->port + OFF_BDBAR);
2019 outb(0, state->card->iobase + c->port + OFF_CIV);
2020 outb(0, state->card->iobase + c->port + OFF_LVI);
2023 spin_unlock_irqrestore(&state->card->lock, flags);
2024 synchronize_irq(state->card->pci_dev->irq);
2026 dmabuf->swptr = dmabuf->hwptr = 0;
2027 dmabuf->count = dmabuf->total_bytes = 0;
2029 case SNDCTL_DSP_SYNC:
2031 printk("SNDCTL_DSP_SYNC\n");
2033 if (codec_independent_spdif_locked > 0) {
2034 if (dmabuf->enable != CODEC_SPDIFOUT_RUNNING
2035 || file->f_flags & O_NONBLOCK)
2037 if ((val = drain_spdifout(state, 1)))
2040 if (controller_independent_spdif_locked > 0) {
2041 if (dmabuf->enable !=
2042 CONTROLLER_SPDIFOUT_RUNNING
2043 || file->f_flags & O_NONBLOCK)
2045 if ((val = drain_spdifout(state, 1)))
2048 if (dmabuf->enable != DAC_RUNNING
2049 || file->f_flags & O_NONBLOCK)
2051 if ((val = drain_dac(state, 1)))
2055 dmabuf->total_bytes = 0;
2057 case SNDCTL_DSP_SPEED: /* set smaple rate */
2059 printk("SNDCTL_DSP_SPEED\n");
2061 if (get_user(val, (int *) arg))
2064 if (file->f_mode & FMODE_WRITE) {
2065 if ((state->card->ac97_status & SPDIF_ON)) { /* S/PDIF Enabled */
2066 /* RELTEK ALC650 only support 48000, need to check that */
2067 if (ali_valid_spdif_rate(codec, val)) {
2068 if (codec_independent_spdif_locked > 0) {
2069 ali_set_spdif_output(state, -1, 0);
2070 stop_spdifout(state);
2072 /* I add test codec independent spdif out */
2073 spin_lock_irqsave(&state->card->lock, flags);
2074 ali_set_codecspdifout_rate(state, val); // I modified
2075 spin_unlock_irqrestore(&state->card->lock, flags);
2076 /* Set S/PDIF transmitter rate. */
2077 i_scr = inl(state->card->iobase + ALI_SCR);
2078 if ((i_scr & 0x00300000) == 0x00100000) {
2079 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2081 if ((i_scr&0x00300000) == 0x00200000)
2083 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2085 if ((i_scr & 0x00300000) == 0x00300000) {
2086 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2088 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2093 if (!(state->card->ac97_status & SPDIF_ON)) {
2097 if (controller_independent_spdif_locked > 0)
2099 stop_spdifout(state);
2101 spin_lock_irqsave(&state->card->lock, flags);
2102 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2103 spin_unlock_irqrestore(&state->card->lock, flags);
2106 ali_set_spdif_output(state, -1, 0);
2109 spin_lock_irqsave(&state->card->lock, flags);
2110 ali_set_dac_rate(state, val);
2111 spin_unlock_irqrestore(&state->card->lock, flags);
2112 /* Set S/PDIF transmitter rate. */
2113 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, val);
2114 if (!(state->card->ac97_status & SPDIF_ON))
2120 } else { /* Not a valid rate for S/PDIF, ignore it */
2126 spin_lock_irqsave(&state->card->lock, flags);
2127 ali_set_dac_rate(state, val);
2128 spin_unlock_irqrestore(&state->card->lock, flags);
2131 if (file->f_mode & FMODE_READ) {
2134 spin_lock_irqsave(&state->card->lock, flags);
2135 ali_set_adc_rate(state, val);
2136 spin_unlock_irqrestore(&state->card->lock, flags);
2139 return put_user(dmabuf->rate, (int *) arg);
2140 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2142 printk("SNDCTL_DSP_STEREO\n");
2144 if (dmabuf->enable & DAC_RUNNING) {
2147 if (dmabuf->enable & ADC_RUNNING) {
2150 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2151 stop_spdifout(state);
2153 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2154 stop_spdifout(state);
2156 return put_user(1, (int *) arg);
2157 case SNDCTL_DSP_GETBLKSIZE:
2158 if (file->f_mode & FMODE_WRITE) {
2159 if (codec_independent_spdif_locked > 0) {
2160 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)))
2163 if (controller_independent_spdif_locked > 0) {
2164 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)))
2167 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
2173 if (file->f_mode & FMODE_READ) {
2174 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
2178 printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
2180 return put_user(dmabuf->userfragsize, (int *) arg);
2181 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2183 printk("SNDCTL_DSP_GETFMTS\n");
2185 return put_user(AFMT_S16_LE, (int *) arg);
2186 case SNDCTL_DSP_SETFMT: /* Select sample format */
2188 printk("SNDCTL_DSP_SETFMT\n");
2190 return put_user(AFMT_S16_LE, (int *) arg);
2191 case SNDCTL_DSP_CHANNELS: // add support 4,6 channel
2193 printk("SNDCTL_DSP_CHANNELS\n");
2195 if (get_user(val, (int *) arg))
2198 if (dmabuf->enable & DAC_RUNNING) {
2201 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2202 stop_spdifout(state);
2204 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2205 stop_spdifout(state);
2207 if (dmabuf->enable & ADC_RUNNING) {
2211 return put_user(state->card->channels, (int *) arg);
2214 i_scr = inl(state->card->iobase + ALI_SCR);
2215 /* Current # of channels enabled */
2216 if (i_scr & 0x00000100)
2218 else if (i_scr & 0x00000200)
2223 case 2: /* 2 channels is always supported */
2224 if (codec_independent_spdif_locked > 0) {
2225 outl(((i_scr & 0xfffffcff) | 0x00100000), (state->card->iobase + ALI_SCR));
2227 outl((i_scr & 0xfffffcff), (state->card->iobase + ALI_SCR));
2228 /* Do we need to change mixer settings???? */
2230 case 4: /* Supported on some chipsets, better check first */
2231 if (codec_independent_spdif_locked > 0) {
2232 outl(((i_scr & 0xfffffcff) | 0x00000100 | 0x00200000), (state->card->iobase + ALI_SCR));
2234 outl(((i_scr & 0xfffffcff) | 0x00000100), (state->card->iobase + ALI_SCR));
2236 case 6: /* Supported on some chipsets, better check first */
2237 if (codec_independent_spdif_locked > 0) {
2238 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000 | 0x00300000), (state->card->iobase + ALI_SCR));
2240 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000), (state->card->iobase + ALI_SCR));
2242 default: /* nothing else is ever supported by the chipset */
2246 return put_user(val, (int *) arg);
2247 case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
2248 /* we update the swptr to the end of the last sg segment then return */
2250 printk("SNDCTL_DSP_POST\n");
2252 if (codec_independent_spdif_locked > 0) {
2253 if (!dmabuf->ready || (dmabuf->enable != CODEC_SPDIFOUT_RUNNING))
2256 if (controller_independent_spdif_locked > 0) {
2257 if (!dmabuf->ready || (dmabuf->enable != CONTROLLER_SPDIFOUT_RUNNING))
2260 if (!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
2264 if ((dmabuf->swptr % dmabuf->fragsize) != 0) {
2265 val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
2266 dmabuf->swptr += val;
2267 dmabuf->count += val;
2270 case SNDCTL_DSP_SUBDIVIDE:
2271 if (dmabuf->subdivision)
2273 if (get_user(val, (int *) arg))
2275 if (val != 1 && val != 2 && val != 4)
2278 printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
2280 dmabuf->subdivision = val;
2283 case SNDCTL_DSP_SETFRAGMENT:
2284 if (get_user(val, (int *) arg))
2286 dmabuf->ossfragsize = 1 << (val & 0xffff);
2287 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2288 if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
2291 * Bound the frag size into our allowed range of 256 - 4096
2293 if (dmabuf->ossfragsize < 256)
2294 dmabuf->ossfragsize = 256;
2295 else if (dmabuf->ossfragsize > 4096)
2296 dmabuf->ossfragsize = 4096;
2298 * The numfrags could be something reasonable, or it could
2299 * be 0xffff meaning "Give me as much as possible". So,
2300 * we check the numfrags * fragsize doesn't exceed our
2301 * 64k buffer limit, nor is it less than our 8k minimum.
2302 * If it fails either one of these checks, then adjust the
2303 * number of fragments, not the size of them. It's OK if
2304 * our number of fragments doesn't equal 32 or anything
2305 * like our hardware based number now since we are using
2306 * a different frag count for the hardware. Before we get
2307 * into this though, bound the maxfrags to avoid overflow
2308 * issues. A reasonable bound would be 64k / 256 since our
2309 * maximum buffer size is 64k and our minimum frag size is
2310 * 256. On the other end, our minimum buffer size is 8k and
2311 * our maximum frag size is 4k, so the lower bound should
2314 if (dmabuf->ossmaxfrags > 256)
2315 dmabuf->ossmaxfrags = 256;
2316 else if (dmabuf->ossmaxfrags < 2)
2317 dmabuf->ossmaxfrags = 2;
2318 val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
2319 while (val < 8192) {
2321 dmabuf->ossmaxfrags <<= 1;
2323 while (val > 65536) {
2325 dmabuf->ossmaxfrags >>= 1;
2329 printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
2330 dmabuf->ossfragsize, dmabuf->ossmaxfrags);
2333 case SNDCTL_DSP_GETOSPACE:
2334 if (!(file->f_mode & FMODE_WRITE))
2336 if (codec_independent_spdif_locked > 0) {
2337 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2340 if (controller_independent_spdif_locked > 0) {
2341 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2344 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2348 spin_lock_irqsave(&state->card->lock, flags);
2349 ali_update_ptr(state);
2350 abinfo.fragsize = dmabuf->userfragsize;
2351 abinfo.fragstotal = dmabuf->userfrags;
2353 abinfo.bytes = dmabuf->dmasize;
2355 abinfo.bytes = ali_get_free_write_space(state);
2356 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2357 spin_unlock_irqrestore(&state->card->lock, flags);
2358 #if defined(DEBUG) || defined(DEBUG_MMAP)
2359 printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n",
2360 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2363 return copy_to_user((void *) arg, &abinfo,
2364 sizeof(abinfo)) ? -EFAULT : 0;
2365 case SNDCTL_DSP_GETOPTR:
2366 if (!(file->f_mode & FMODE_WRITE))
2368 if (codec_independent_spdif_locked > 0) {
2369 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2372 if (controller_independent_spdif_locked > 0) {
2373 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2376 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2380 spin_lock_irqsave(&state->card->lock, flags);
2381 val = ali_get_free_write_space(state);
2382 cinfo.bytes = dmabuf->total_bytes;
2383 cinfo.ptr = dmabuf->hwptr;
2384 cinfo.blocks = val / dmabuf->userfragsize;
2385 if (codec_independent_spdif_locked > 0) {
2386 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2387 dmabuf->count += val;
2388 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2389 __ali_update_lvi(state, 2);
2392 if (controller_independent_spdif_locked > 0) {
2393 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2394 dmabuf->count += val;
2395 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2396 __ali_update_lvi(state, 3);
2399 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
2400 dmabuf->count += val;
2401 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2402 __ali_update_lvi(state, 0);
2406 spin_unlock_irqrestore(&state->card->lock, flags);
2407 #if defined(DEBUG) || defined(DEBUG_MMAP)
2408 printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
2409 cinfo.blocks, cinfo.ptr, dmabuf->count);
2411 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo))? -EFAULT : 0;
2412 case SNDCTL_DSP_GETISPACE:
2413 if (!(file->f_mode & FMODE_READ))
2415 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
2417 spin_lock_irqsave(&state->card->lock, flags);
2418 abinfo.bytes = ali_get_available_read_data(state);
2419 abinfo.fragsize = dmabuf->userfragsize;
2420 abinfo.fragstotal = dmabuf->userfrags;
2421 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2422 spin_unlock_irqrestore(&state->card->lock, flags);
2423 #if defined(DEBUG) || defined(DEBUG_MMAP)
2424 printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n",
2425 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2428 return copy_to_user((void *) arg, &abinfo,
2429 sizeof(abinfo)) ? -EFAULT : 0;
2430 case SNDCTL_DSP_GETIPTR:
2431 if (!(file->f_mode & FMODE_READ))
2433 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2435 spin_lock_irqsave(&state->card->lock, flags);
2436 val = ali_get_available_read_data(state);
2437 cinfo.bytes = dmabuf->total_bytes;
2438 cinfo.blocks = val / dmabuf->userfragsize;
2439 cinfo.ptr = dmabuf->hwptr;
2440 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
2441 dmabuf->count -= val;
2442 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2443 __ali_update_lvi(state, 1);
2445 spin_unlock_irqrestore(&state->card->lock, flags);
2446 #if defined(DEBUG) || defined(DEBUG_MMAP)
2447 printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
2448 cinfo.blocks, cinfo.ptr, dmabuf->count);
2450 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo))? -EFAULT: 0;
2451 case SNDCTL_DSP_NONBLOCK:
2453 printk("SNDCTL_DSP_NONBLOCK\n");
2455 file->f_flags |= O_NONBLOCK;
2457 case SNDCTL_DSP_GETCAPS:
2459 printk("SNDCTL_DSP_GETCAPS\n");
2461 return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2462 DSP_CAP_MMAP | DSP_CAP_BIND, (int *) arg);
2463 case SNDCTL_DSP_GETTRIGGER:
2466 printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
2468 return put_user(dmabuf->trigger, (int *) arg);
2469 case SNDCTL_DSP_SETTRIGGER:
2470 if (get_user(val, (int *) arg))
2472 #if defined(DEBUG) || defined(DEBUG_MMAP)
2473 printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
2475 if (!(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
2478 if (!(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
2481 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2482 stop_spdifout(state);
2484 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2485 stop_spdifout(state);
2487 dmabuf->trigger = val;
2488 if (val & PCM_ENABLE_OUTPUT && !(dmabuf->enable & DAC_RUNNING)) {
2489 if (!dmabuf->write_channel) {
2491 dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
2492 if (!dmabuf->write_channel)
2495 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
2497 if (dmabuf->mapped) {
2498 spin_lock_irqsave(&state->card->lock, flags);
2499 ali_update_ptr(state);
2501 dmabuf->swptr = dmabuf->hwptr;
2502 dmabuf->count = ali_get_free_write_space(state);
2503 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2504 __ali_update_lvi(state, 0);
2505 spin_unlock_irqrestore(&state->card->lock,
2510 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CODEC_SPDIFOUT_RUNNING)) {
2511 if (!dmabuf->codec_spdifout_channel) {
2513 dmabuf->codec_spdifout_channel = state->card->alloc_codec_spdifout_channel(state->card);
2514 if (!dmabuf->codec_spdifout_channel)
2517 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
2519 if (dmabuf->mapped) {
2520 spin_lock_irqsave(&state->card->lock, flags);
2521 ali_update_ptr(state);
2523 dmabuf->swptr = dmabuf->hwptr;
2524 dmabuf->count = ali_get_free_write_space(state);
2525 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2526 __ali_update_lvi(state, 2);
2527 spin_unlock_irqrestore(&state->card->lock,
2530 start_spdifout(state);
2532 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)) {
2533 if (!dmabuf->controller_spdifout_channel) {
2535 dmabuf->controller_spdifout_channel = state->card->alloc_controller_spdifout_channel(state->card);
2536 if (!dmabuf->controller_spdifout_channel)
2539 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
2541 if (dmabuf->mapped) {
2542 spin_lock_irqsave(&state->card->lock, flags);
2543 ali_update_ptr(state);
2545 dmabuf->swptr = dmabuf->hwptr;
2546 dmabuf->count = ali_get_free_write_space(state);
2547 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2548 __ali_update_lvi(state, 3);
2549 spin_unlock_irqrestore(&state->card->lock, flags);
2551 start_spdifout(state);
2553 if (val & PCM_ENABLE_INPUT && !(dmabuf->enable & ADC_RUNNING)) {
2554 if (!dmabuf->read_channel) {
2556 dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
2557 if (!dmabuf->read_channel)
2560 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
2562 if (dmabuf->mapped) {
2563 spin_lock_irqsave(&state->card->lock,
2565 ali_update_ptr(state);
2566 dmabuf->swptr = dmabuf->hwptr;
2568 spin_unlock_irqrestore(&state->card->lock, flags);
2570 ali_update_lvi(state, 1);
2574 case SNDCTL_DSP_SETDUPLEX:
2576 printk("SNDCTL_DSP_SETDUPLEX\n");
2579 case SNDCTL_DSP_GETODELAY:
2580 if (!(file->f_mode & FMODE_WRITE))
2582 spin_lock_irqsave(&state->card->lock, flags);
2583 ali_update_ptr(state);
2584 val = dmabuf->count;
2585 spin_unlock_irqrestore(&state->card->lock, flags);
2587 printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
2589 return put_user(val, (int *) arg);
2590 case SOUND_PCM_READ_RATE:
2592 printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
2594 return put_user(dmabuf->rate, (int *) arg);
2595 case SOUND_PCM_READ_CHANNELS:
2597 printk("SOUND_PCM_READ_CHANNELS\n");
2599 return put_user(2, (int *) arg);
2600 case SOUND_PCM_READ_BITS:
2602 printk("SOUND_PCM_READ_BITS\n");
2604 return put_user(AFMT_S16_LE, (int *) arg);
2605 case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
2607 printk("SNDCTL_DSP_SETSPDIF\n");
2609 if (get_user(val, (int *) arg))
2611 /* Check to make sure the codec supports S/PDIF transmitter */
2612 if ((state->card->ac97_features & 4)) {
2613 /* mask out the transmitter speed bits so the user can't set them */
2615 /* Add the current transmitter speed bits to the passed value */
2616 ret = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2617 val |= (ret & 0x3000);
2618 ali_ac97_set(codec, AC97_SPDIF_CONTROL, val);
2619 if (ali_ac97_get(codec, AC97_SPDIF_CONTROL) != val) {
2620 printk(KERN_ERR "ali_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
2626 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2628 return put_user(val, (int *) arg);
2629 case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
2631 printk("SNDCTL_DSP_GETSPDIF\n");
2633 if (get_user(val, (int *) arg))
2635 /* Check to make sure the codec supports S/PDIF transmitter */
2636 if (!(state->card->ac97_features & 4)) {
2638 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2642 val = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2645 return put_user(val, (int *) arg);
2646 //end add support spdif out
2647 //add support 4,6 channel
2648 case SNDCTL_DSP_GETCHANNELMASK:
2650 printk("SNDCTL_DSP_GETCHANNELMASK\n");
2652 if (get_user(val, (int *) arg))
2654 /* Based on AC'97 DAC support, not ICH hardware */
2655 val = DSP_BIND_FRONT;
2656 if (state->card->ac97_features & 0x0004)
2657 val |= DSP_BIND_SPDIF;
2658 if (state->card->ac97_features & 0x0080)
2659 val |= DSP_BIND_SURR;
2660 if (state->card->ac97_features & 0x0140)
2661 val |= DSP_BIND_CENTER_LFE;
2662 return put_user(val, (int *) arg);
2663 case SNDCTL_DSP_BIND_CHANNEL:
2665 printk("SNDCTL_DSP_BIND_CHANNEL\n");
2667 if (get_user(val, (int *) arg))
2669 if (val == DSP_BIND_QUERY) {
2670 val = DSP_BIND_FRONT; /* Always report this as being enabled */
2671 if (state->card->ac97_status & SPDIF_ON)
2672 val |= DSP_BIND_SPDIF;
2674 if (state->card->ac97_status & SURR_ON)
2675 val |= DSP_BIND_SURR;
2677 ac97_status & CENTER_LFE_ON)
2678 val |= DSP_BIND_CENTER_LFE;
2680 } else { /* Not a query, set it */
2681 if (!(file->f_mode & FMODE_WRITE))
2683 if (dmabuf->enable == DAC_RUNNING) {
2686 if (val & DSP_BIND_SPDIF) { /* Turn on SPDIF */
2687 /* Ok, this should probably define what slots
2688 * to use. For now, we'll only set it to the
2691 * non multichannel codec maps to slots 3&4
2692 * 2 channel codec maps to slots 7&8
2693 * 4 channel codec maps to slots 6&9
2694 * 6 channel codec maps to slots 10&11
2696 * there should be some way for the app to
2697 * select the slot assignment.
2699 i_scr = inl(state->card->iobase + ALI_SCR);
2700 if (codec_independent_spdif_locked > 0) {
2702 if ((i_scr & 0x00300000) == 0x00100000) {
2703 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2705 if ((i_scr & 0x00300000) == 0x00200000) {
2706 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2708 if ((i_scr & 0x00300000) == 0x00300000) {
2709 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2713 } else { /* codec spdif out (pcm out share ) */
2714 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, dmabuf->rate); //I do not modify
2717 if (!(state->card->ac97_status & SPDIF_ON))
2718 val &= ~DSP_BIND_SPDIF;
2722 /* Turn off S/PDIF if it was on */
2723 if (state->card->ac97_status & SPDIF_ON)
2724 ali_set_spdif_output(state, -1, 0);
2726 val & (DSP_BIND_FRONT | DSP_BIND_SURR |
2727 DSP_BIND_CENTER_LFE);
2729 case DSP_BIND_FRONT:
2732 case DSP_BIND_FRONT | DSP_BIND_SURR:
2735 case DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE:
2739 val = DSP_BIND_FRONT;
2743 ali_set_dac_channels(state, channels);
2744 /* check that they really got turned on */
2745 if (!state->card->ac97_status & SURR_ON)
2746 val &= ~DSP_BIND_SURR;
2748 ac97_status & CENTER_LFE_ON)
2749 val &= ~DSP_BIND_CENTER_LFE;
2752 return put_user(val, (int *) arg);
2753 case SNDCTL_DSP_MAPINBUF:
2754 case SNDCTL_DSP_MAPOUTBUF:
2755 case SNDCTL_DSP_SETSYNCRO:
2756 case SOUND_PCM_WRITE_FILTER:
2757 case SOUND_PCM_READ_FILTER:
2763 static int ali_open(struct inode *inode, struct file *file)
2766 struct ali_card *card = devs;
2767 struct ali_state *state = NULL;
2768 struct dmabuf *dmabuf = NULL;
2771 /* find an available virtual channel (instance of /dev/dsp) */
2773 while (card != NULL) {
2776 * If we are initializing and then fail, card could go
2777 * away unuexpectedly while we are in the for() loop.
2778 * So, check for card on each iteration before we check
2779 * for card->initializing to avoid a possible oops.
2780 * This usually only matters for times when the driver is
2781 * autoloaded by kmod.
2783 for (i = 0; i < 50 && card && card->initializing; i++) {
2784 set_current_state(TASK_UNINTERRUPTIBLE);
2785 schedule_timeout(HZ / 20);
2788 for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
2789 if (card->states[i] == NULL) {
2790 state = card->states[i] = (struct ali_state *) kmalloc(sizeof(struct ali_state), GFP_KERNEL);
2793 memset(state, 0, sizeof(struct ali_state));
2794 dmabuf = &state->dmabuf;
2801 /* no more virtual channel avaiable */
2805 /* initialize the virtual channel */
2809 state->magic = ALI5455_STATE_MAGIC;
2810 init_waitqueue_head(&dmabuf->wait);
2811 init_MUTEX(&state->open_sem);
2812 file->private_data = state;
2813 dmabuf->trigger = 0;
2814 /* allocate hardware channels */
2815 if (file->f_mode & FMODE_READ) {
2816 if ((dmabuf->read_channel =
2817 card->alloc_rec_pcm_channel(card)) == NULL) {
2818 kfree(card->states[i]);
2819 card->states[i] = NULL;
2822 dmabuf->trigger |= PCM_ENABLE_INPUT;
2823 ali_set_adc_rate(state, 8000);
2825 if (file->f_mode & FMODE_WRITE) {
2826 if (codec_independent_spdif_locked > 0) {
2827 if ((dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card)) == NULL) {
2828 kfree(card->states[i]);
2829 card->states[i] = NULL;
2832 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2833 ali_set_codecspdifout_rate(state, codec_independent_spdif_locked); //It must add
2834 i_scr = inl(state->card->iobase + ALI_SCR);
2835 if ((i_scr & 0x00300000) == 0x00100000) {
2836 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2838 if ((i_scr & 0x00300000) == 0x00200000) {
2839 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2841 if ((i_scr & 0x00300000) == 0x00300000) {
2842 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2844 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2850 if (controller_independent_spdif_locked > 0) {
2851 if ((dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card)) == NULL) {
2852 kfree(card->states[i]);
2853 card->states[i] = NULL;
2856 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2857 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2859 if ((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
2860 kfree(card->states[i]);
2861 card->states[i] = NULL;
2864 /* Initialize to 8kHz? What if we don't support 8kHz? */
2865 /* Let's change this to check for S/PDIF stuff */
2867 dmabuf->trigger |= PCM_ENABLE_OUTPUT;
2868 if (codec_pcmout_share_spdif_locked) {
2869 ali_set_dac_rate(state, codec_pcmout_share_spdif_locked);
2870 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, codec_pcmout_share_spdif_locked);
2872 ali_set_dac_rate(state, 8000);
2879 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
2880 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2881 /dev/dspW will accept 16-bits sample, but we don't support those so we
2882 set it immediately to stereo and 16bit, which is all we do support */
2883 dmabuf->fmt |= ALI5455_FMT_16BIT | ALI5455_FMT_STEREO;
2884 dmabuf->ossfragsize = 0;
2885 dmabuf->ossmaxfrags = 0;
2886 dmabuf->subdivision = 0;
2887 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2888 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
2889 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
2893 static int ali_release(struct inode *inode, struct file *file)
2895 struct ali_state *state = (struct ali_state *) file->private_data;
2896 struct ali_card *card = state->card;
2897 struct dmabuf *dmabuf = &state->dmabuf;
2898 unsigned long flags;
2901 /* stop DMA state machine and free DMA buffers/channels */
2902 if (dmabuf->trigger & PCM_ENABLE_OUTPUT)
2903 drain_dac(state, 0);
2905 if (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)
2906 drain_spdifout(state, 0);
2908 if (dmabuf->trigger & PCM_ENABLE_INPUT)
2911 spin_lock_irqsave(&card->lock, flags);
2912 dealloc_dmabuf(state);
2913 if (file->f_mode & FMODE_WRITE) {
2914 if (codec_independent_spdif_locked > 0) {
2915 state->card->free_pcm_channel(state->card, dmabuf->codec_spdifout_channel->num);
2917 if (controller_independent_spdif_locked > 0)
2918 state->card->free_pcm_channel(state->card,
2919 dmabuf->controller_spdifout_channel->num);
2920 else state->card->free_pcm_channel(state->card,
2921 dmabuf->write_channel->num);
2924 if (file->f_mode & FMODE_READ)
2925 state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
2927 state->card->states[state->virt] = NULL;
2929 spin_unlock_irqrestore(&card->lock, flags);
2934 static /*const */ struct file_operations ali_audio_fops = {
2935 .owner = THIS_MODULE,
2936 .llseek = no_llseek,
2943 .release = ali_release,
2946 /* Read AC97 codec registers */
2947 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg)
2949 struct ali_card *card = dev->private_data;
2952 unsigned short int data = 0, count, addr1, addr2 = 0;
2954 spin_lock(&card->ac97_lock);
2955 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2960 for (count = 0; count < 0x7f; count++) {
2961 val = inb(card->iobase + ALI_CSPSR);
2967 spin_unlock(&card->ac97_lock);
2970 outw(reg, (card->iobase + ALI_CPR) + 2);
2971 for (count = 0; count < 0x7f; count++) {
2972 val = inb(card->iobase + ALI_CSPSR);
2974 data = inw(card->iobase + ALI_SPR);
2975 addr2 = inw((card->iobase + ALI_SPR) + 2);
2979 spin_unlock(&card->ac97_lock);
2984 return ((u16) data);
2987 /* write ac97 codec register */
2989 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
2991 struct ali_card *card = dev->private_data;
2994 unsigned short int count;
2996 spin_lock(&card->ac97_lock);
2997 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
3000 for (count = 0; count < 0x7f; count++) {
3001 val = inb(card->iobase + ALI_CSPSR);
3005 if (count == 0x7f) {
3006 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3007 spin_unlock(&card->ac97_lock);
3010 outw(data, (card->iobase + ALI_CPR));
3011 outb(reg, (card->iobase + ALI_CPR) + 2);
3012 for (count = 0; count < 0x7f; count++) {
3013 val = inb(card->iobase + ALI_CSPSR);
3017 spin_unlock(&card->ac97_lock);
3019 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3023 /* OSS /dev/mixer file operation methods */
3025 static int ali_open_mixdev(struct inode *inode, struct file *file)
3028 int minor = iminor(inode);
3029 struct ali_card *card = devs;
3030 for (card = devs; card != NULL; card = card->next) {
3032 * If we are initializing and then fail, card could go
3033 * away unuexpectedly while we are in the for() loop.
3034 * So, check for card on each iteration before we check
3035 * for card->initializing to avoid a possible oops.
3036 * This usually only matters for times when the driver is
3037 * autoloaded by kmod.
3039 for (i = 0; i < 50 && card && card->initializing; i++) {
3040 set_current_state(TASK_UNINTERRUPTIBLE);
3041 schedule_timeout(HZ / 20);
3043 for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
3044 if (card->ac97_codec[i] != NULL
3045 && card->ac97_codec[i]->dev_mixer == minor) {
3046 file->private_data = card->ac97_codec[i];
3053 static int ali_ioctl_mixdev(struct inode *inode,
3055 unsigned int cmd, unsigned long arg)
3057 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
3058 return codec->mixer_ioctl(codec, cmd, arg);
3061 static /*const */ struct file_operations ali_mixer_fops = {
3062 .owner = THIS_MODULE,
3063 .llseek = no_llseek,
3064 .ioctl = ali_ioctl_mixdev,
3065 .open = ali_open_mixdev,
3068 /* AC97 codec initialisation. These small functions exist so we don't
3069 duplicate code between module init and apm resume */
3071 static inline int ali_ac97_exists(struct ali_card *card, int ac97_number)
3074 u32 reg = inl(card->iobase + ALI_RTSR);
3078 reg = inl(card->iobase + ALI_RTSR);
3082 outl(reg | 0x00000040,
3083 card->iobase + 0x34);
3091 reg = inl(card->iobase + ALI_RTSR);
3095 outl(reg | 0x00000080,
3096 card->iobase + 0x34);
3109 static inline int ali_ac97_enable_variable_rate(struct ac97_codec *codec)
3111 ali_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
3112 ali_ac97_set(codec, AC97_EXTENDED_STATUS, ali_ac97_get(codec, AC97_EXTENDED_STATUS) | 0xE800);
3113 return (ali_ac97_get(codec, AC97_EXTENDED_STATUS) & 1);
3117 static int ali_ac97_probe_and_powerup(struct ali_card *card, struct ac97_codec *codec)
3119 /* Returns 0 on failure */
3122 if (ac97_probe_codec(codec) == 0)
3124 /* ac97_probe_codec is success ,then begin to init codec */
3125 ali_ac97_set(codec, AC97_RESET, 0xffff);
3126 if (card->channel[0].used == 1) {
3127 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3128 ali_ac97_set(codec, AC97_LINEIN_VOL, 0x0808);
3129 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3132 if (card->channel[2].used == 1) //if MICin then init codec
3134 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3135 ali_ac97_set(codec, AC97_MIC_VOL, 0x8808);
3136 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3137 ali_ac97_set(codec, AC97_RECORD_GAIN_MIC, 0x0000);
3140 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO, 0x0000);
3141 ali_ac97_set(codec, AC97_HEADPHONE_VOL, 0x0000);
3142 ali_ac97_set(codec, AC97_PCMOUT_VOL, 0x0000);
3143 ali_ac97_set(codec, AC97_CD_VOL, 0x0808);
3144 ali_ac97_set(codec, AC97_VIDEO_VOL, 0x0808);
3145 ali_ac97_set(codec, AC97_AUX_VOL, 0x0808);
3146 ali_ac97_set(codec, AC97_PHONE_VOL, 0x8048);
3147 ali_ac97_set(codec, AC97_PCBEEP_VOL, 0x0000);
3148 ali_ac97_set(codec, AC97_GENERAL_PURPOSE, AC97_GP_MIX);
3149 ali_ac97_set(codec, AC97_MASTER_VOL_MONO, 0x0000);
3150 ali_ac97_set(codec, 0x38, 0x0000);
3151 addr = ali_ac97_get(codec, 0x2a);
3152 ali_ac97_set(codec, 0x2a, addr | 0x0001);
3153 addr = ali_ac97_get(codec, 0x2a);
3154 addr = ali_ac97_get(codec, 0x28);
3155 ali_ac97_set(codec, 0x2c, 0xbb80);
3156 addr = ali_ac97_get(codec, 0x2c);
3157 /* power it all up */
3158 ali_ac97_set(codec, AC97_POWER_CONTROL,
3159 ali_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
3160 /* wait for analog ready */
3161 for (i = 10; i && ((ali_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--) {
3162 set_current_state(TASK_UNINTERRUPTIBLE);
3163 schedule_timeout(HZ / 20);
3171 /* I clone ali5455(2.4.7 ) not clone i810_audio(2.4.18) */
3173 static int ali_reset_5455(struct ali_card *card)
3175 outl(0x80000003, card->iobase + ALI_SCR);
3176 outl(0x83838383, card->iobase + ALI_FIFOCR1);
3177 outl(0x83838383, card->iobase + ALI_FIFOCR2);
3178 if (controller_pcmout_share_spdif_locked > 0) {
3179 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3180 card->iobase + ALI_SPDIFICS);
3181 outl(0x0408000a, card->iobase + ALI_INTERFACECR);
3183 if (codec_independent_spdif_locked > 0) {
3184 outl((inl(card->iobase + ALI_SCR) | 0x00100000), card->iobase + ALI_SCR); // now I select slot 7 & 8
3185 outl(0x00200000, card->iobase + ALI_INTERFACECR); //enable codec independent spdifout
3187 outl(0x04080002, card->iobase + ALI_INTERFACECR);
3190 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
3191 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
3192 if (controller_independent_spdif_locked > 0)
3193 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3194 card->iobase + ALI_SPDIFICS);
3199 static int ali_ac97_random_init_stuff(struct ali_card
3202 u32 reg = inl(card->iobase + ALI_SCR);
3204 reg = inl(card->iobase + ALI_SCR);
3205 if ((reg & 2) == 0) /* Cold required */
3208 reg |= 1; /* Warm */
3209 reg &= ~0x80000000; /* ACLink on */
3210 outl(reg, card->iobase + ALI_SCR);
3213 if ((inl(card->iobase + 0x18) & (1 << 1)) == 0)
3215 current->state = TASK_UNINTERRUPTIBLE;
3216 schedule_timeout(HZ / 20);
3220 printk(KERN_ERR "ali_audio: AC'97 reset failed.\n");
3224 set_current_state(TASK_UNINTERRUPTIBLE);
3225 schedule_timeout(HZ / 2);
3229 /* AC97 codec initialisation. */
3231 static int __devinit ali_ac97_init(struct ali_card *card)
3234 int total_channels = 0;
3235 struct ac97_codec *codec;
3238 if (!ali_ac97_random_init_stuff(card))
3241 /* Number of channels supported */
3242 /* What about the codec? Just because the ICH supports */
3243 /* multiple channels doesn't mean the codec does. */
3244 /* we'll have to modify this in the codec section below */
3245 /* to reflect what the codec has. */
3246 /* ICH and ICH0 only support 2 channels so don't bother */
3248 inl(card->iobase + ALI_CPR);
3251 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3253 /* Assume codec isn't available until we go through the
3255 card->ac97_codec[num_ac97] = NULL;
3256 /* The ICH programmer's reference says you should */
3257 /* check the ready status before probing. So we chk */
3258 /* What do we do if it's not ready? Wait and try */
3259 /* again, or abort? */
3260 if (!ali_ac97_exists(card, num_ac97)) {
3262 printk(KERN_ERR "ali_audio: Primary codec not ready.\n");
3266 if ((codec = ac97_alloc_codec()) == NULL)
3268 /* initialize some basic codec information, other fields will be filled
3269 in ac97_probe_codec */
3270 codec->private_data = card;
3271 codec->id = num_ac97;
3272 codec->codec_read = ali_ac97_get;
3273 codec->codec_write = ali_ac97_set;
3274 if (!ali_ac97_probe_and_powerup(card, codec)) {
3275 printk(KERN_ERR "ali_audio: timed out waiting for codec %d analog ready",
3278 break; /* it didn't work */
3281 /* Store state information about S/PDIF transmitter */
3282 card->ac97_status = 0;
3283 /* Don't attempt to get eid until powerup is complete */
3284 eid = ali_ac97_get(codec, AC97_EXTENDED_ID);
3285 if (eid == 0xFFFF) {
3286 printk(KERN_ERR "ali_audio: no codec attached ?\n");
3291 card->ac97_features = eid;
3292 /* Now check the codec for useful features to make up for
3293 the dumbness of the ali5455 hardware engine */
3294 if (!(eid & 0x0001))
3296 "ali_audio: only 48Khz playback available.\n");
3298 if (!ali_ac97_enable_variable_rate(codec)) {
3300 "ali_audio: Codec refused to allow VRA, using 48Khz only.\n");
3301 card->ac97_features &= ~1;
3305 /* Determine how many channels the codec(s) support */
3306 /* - The primary codec always supports 2 */
3307 /* - If the codec supports AMAP, surround DACs will */
3308 /* automaticlly get assigned to slots. */
3309 /* * Check for surround DACs and increment if */
3311 /* - Else check if the codec is revision 2.2 */
3312 /* * If surround DACs exist, assign them to slots */
3313 /* and increment channel count. */
3315 /* All of this only applies to ICH2 and above. ICH */
3316 /* and ICH0 only support 2 channels. ICH2 will only */
3317 /* support multiple codecs in a "split audio" config. */
3318 /* as described above. */
3320 /* TODO: Remove all the debugging messages! */
3322 if ((eid & 0xc000) == 0) /* primary codec */
3323 total_channels += 2;
3324 if ((codec->dev_mixer = register_sound_mixer(&ali_mixer_fops, -1)) < 0) {
3325 printk(KERN_ERR "ali_audio: couldn't register mixer!\n");
3329 card->ac97_codec[num_ac97] = codec;
3331 /* pick the minimum of channels supported by ICHx or codec(s) */
3332 card->channels = (card->channels > total_channels) ? total_channels : card->channels;
3336 static void __devinit ali_configure_clocking(void)
3338 struct ali_card *card;
3339 struct ali_state *state;
3340 struct dmabuf *dmabuf;
3341 unsigned int i, offset, new_offset;
3342 unsigned long flags;
3345 /* We could try to set the clocking for multiple cards, but can you even have
3346 * more than one ali in a machine? Besides, clocking is global, so unless
3347 * someone actually thinks more than one ali in a machine is possible and
3348 * decides to rewrite that little bit, setting the rate for more than one card
3349 * is a waste of time.
3352 state = card->states[0] = (struct ali_state *)
3353 kmalloc(sizeof(struct ali_state), GFP_KERNEL);
3356 memset(state, 0, sizeof(struct ali_state));
3357 dmabuf = &state->dmabuf;
3358 dmabuf->write_channel = card->alloc_pcm_channel(card);
3361 state->magic = ALI5455_STATE_MAGIC;
3362 init_waitqueue_head(&dmabuf->wait);
3363 init_MUTEX(&state->open_sem);
3364 dmabuf->fmt = ALI5455_FMT_STEREO | ALI5455_FMT_16BIT;
3365 dmabuf->trigger = PCM_ENABLE_OUTPUT;
3366 ali_set_dac_rate(state, 48000);
3367 if (prog_dmabuf(state, 0) != 0)
3368 goto config_out_nodmabuf;
3370 if (dmabuf->dmasize < 16384)
3373 dmabuf->count = dmabuf->dmasize;
3374 outb(31, card->iobase + dmabuf->write_channel->port + OFF_LVI);
3376 local_irq_save(flags);
3378 offset = ali_get_dma_addr(state, 0);
3380 new_offset = ali_get_dma_addr(state, 0);
3383 outb(2, card->iobase + dmabuf->write_channel->port + OFF_CR);
3384 local_irq_restore(flags);
3386 i = new_offset - offset;
3391 if (i > 48500 || i < 47500) {
3392 clocking = clocking * clocking / i;
3395 dealloc_dmabuf(state);
3396 config_out_nodmabuf:
3397 state->card->free_pcm_channel(state->card, state->dmabuf. write_channel->num);
3399 card->states[0] = NULL;
3403 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3404 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3406 static int __devinit ali_probe(struct pci_dev *pci_dev,
3407 const struct pci_device_id *pci_id)
3409 struct ali_card *card;
3410 if (pci_enable_device(pci_dev))
3412 if (pci_set_dma_mask(pci_dev, ALI5455_DMA_MASK)) {
3413 printk(KERN_ERR "ali5455: architecture does not support"
3414 " 32bit PCI busmaster DMA\n");
3418 if ((card = kmalloc(sizeof(struct ali_card), GFP_KERNEL)) == NULL) {
3419 printk(KERN_ERR "ali_audio: out of memory\n");
3422 memset(card, 0, sizeof(*card));
3423 card->initializing = 1;
3424 card->iobase = pci_resource_start(pci_dev, 0);
3425 card->pci_dev = pci_dev;
3426 card->pci_id = pci_id->device;
3427 card->irq = pci_dev->irq;
3429 card->magic = ALI5455_CARD_MAGIC;
3431 card->pm_suspended = 0;
3433 spin_lock_init(&card->lock);
3434 spin_lock_init(&card->ac97_lock);
3436 pci_set_master(pci_dev);
3437 printk(KERN_INFO "ali: %s found at IO 0x%04lx, IRQ %d\n",
3438 card_names[pci_id->driver_data], card->iobase, card->irq);
3439 card->alloc_pcm_channel = ali_alloc_pcm_channel;
3440 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
3441 card->alloc_rec_mic_channel = ali_alloc_rec_mic_channel;
3442 card->alloc_codec_spdifout_channel = ali_alloc_codec_spdifout_channel;
3443 card->alloc_controller_spdifout_channel = ali_alloc_controller_spdifout_channel;
3444 card->free_pcm_channel = ali_free_pcm_channel;
3445 card->channel[0].offset = 0;
3446 card->channel[0].port = 0x40;
3447 card->channel[0].num = 0;
3448 card->channel[1].offset = 0;
3449 card->channel[1].port = 0x50;
3450 card->channel[1].num = 1;
3451 card->channel[2].offset = 0;
3452 card->channel[2].port = 0x60;
3453 card->channel[2].num = 2;
3454 card->channel[3].offset = 0;
3455 card->channel[3].port = 0x70;
3456 card->channel[3].num = 3;
3457 card->channel[4].offset = 0;
3458 card->channel[4].port = 0xb0;
3459 card->channel[4].num = 4;
3460 /* claim our iospace and irq */
3461 request_region(card->iobase, 256, card_names[pci_id->driver_data]);
3462 if (request_irq(card->irq, &ali_interrupt, SA_SHIRQ,
3463 card_names[pci_id->driver_data], card)) {
3464 printk(KERN_ERR "ali_audio: unable to allocate irq %d\n",
3466 release_region(card->iobase, 256);
3471 if (ali_reset_5455(card) <= 0) {
3472 unregister_sound_dsp(card->dev_audio);
3473 release_region(card->iobase, 256);
3474 free_irq(card->irq, card);
3479 /* initialize AC97 codec and register /dev/mixer */
3480 if (ali_ac97_init(card) < 0) {
3481 release_region(card->iobase, 256);
3482 free_irq(card->irq, card);
3487 pci_set_drvdata(pci_dev, card);
3489 if (clocking == 0) {
3491 ali_configure_clocking();
3494 /* register /dev/dsp */
3495 if ((card->dev_audio = register_sound_dsp(&ali_audio_fops, -1)) < 0) {
3497 printk(KERN_ERR"ali_audio: couldn't register DSP device!\n");
3498 release_region(card->iobase, 256);
3499 free_irq(card->irq, card);
3500 for (i = 0; i < NR_AC97; i++)
3501 if (card->ac97_codec[i] != NULL) {
3502 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3503 kfree(card->ac97_codec[i]);
3508 card->initializing = 0;
3512 static void __devexit ali_remove(struct pci_dev *pci_dev)
3515 struct ali_card *card = pci_get_drvdata(pci_dev);
3516 /* free hardware resources */
3517 free_irq(card->irq, devs);
3518 release_region(card->iobase, 256);
3519 /* unregister audio devices */
3520 for (i = 0; i < NR_AC97; i++)
3521 if (card->ac97_codec[i] != NULL) {
3522 unregister_sound_mixer(card->ac97_codec[i]->
3524 ac97_release_codec(card->ac97_codec[i]);
3525 card->ac97_codec[i] = NULL;
3527 unregister_sound_dsp(card->dev_audio);
3532 static int ali_pm_suspend(struct pci_dev *dev, u32 pm_state)
3534 struct ali_card *card = pci_get_drvdata(dev);
3535 struct ali_state *state;
3536 unsigned long flags;
3537 struct dmabuf *dmabuf;
3542 spin_lock_irqsave(&card->lock, flags);
3543 card->pm_suspended = 1;
3544 for (i = 0; i < NR_HW_CH; i++) {
3545 state = card->states[i];
3548 /* this happens only if there are open files */
3549 dmabuf = &state->dmabuf;
3550 if (dmabuf->enable & DAC_RUNNING ||
3552 && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
3553 state->pm_saved_dac_rate = dmabuf->rate;
3556 state->pm_saved_dac_rate = 0;
3558 if (dmabuf->enable & ADC_RUNNING) {
3559 state->pm_saved_adc_rate = dmabuf->rate;
3562 state->pm_saved_adc_rate = 0;
3565 dmabuf->swptr = dmabuf->hwptr = 0;
3566 dmabuf->count = dmabuf->total_bytes = 0;
3569 spin_unlock_irqrestore(&card->lock, flags);
3570 /* save mixer settings */
3571 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3572 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3575 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3576 if ((supported_mixer(codec, i)) && (codec->read_mixer)) {
3577 card->pm_saved_mixer_settings[i][num_ac97] = codec->read_mixer(codec, i);
3581 pci_save_state(dev, card->pm_save_state); /* XXX do we need this? */
3582 pci_disable_device(dev); /* disable busmastering */
3583 pci_set_power_state(dev, 3); /* Zzz. */
3588 static int ali_pm_resume(struct pci_dev *dev)
3590 int num_ac97, i = 0;
3591 struct ali_card *card = pci_get_drvdata(dev);
3592 pci_enable_device(dev);
3593 pci_restore_state(dev, card->pm_save_state);
3594 /* observation of a toshiba portege 3440ct suggests that the
3595 hardware has to be more or less completely reinitialized from
3596 scratch after an apm suspend. Works For Me. -dan */
3597 ali_ac97_random_init_stuff(card);
3598 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3599 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3600 /* check they haven't stolen the hardware while we were
3602 if (!codec || !ali_ac97_exists(card, num_ac97)) {
3608 if (!ali_ac97_probe_and_powerup(card, codec))
3610 if ((card->ac97_features & 0x0001)) {
3611 /* at probe time we found we could do variable
3612 rates, but APM suspend has made it forget
3613 its magical powers */
3614 if (!ali_ac97_enable_variable_rate(codec))
3617 /* we lost our mixer settings, so restore them */
3618 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3619 if (supported_mixer(codec, i)) {
3620 int val = card->pm_saved_mixer_settings[i][num_ac97];
3621 codec->mixer_state[i] = val;
3622 codec->write_mixer(codec, i,
3624 ((val >> 8) & 0xff));
3629 /* we need to restore the sample rate from whatever it was */
3630 for (i = 0; i < NR_HW_CH; i++) {
3631 struct ali_state *state = card->states[i];
3633 if (state->pm_saved_adc_rate)
3634 ali_set_adc_rate(state, state->pm_saved_adc_rate);
3635 if (state->pm_saved_dac_rate)
3636 ali_set_dac_rate(state, state->pm_saved_dac_rate);
3640 card->pm_suspended = 0;
3641 /* any processes that were reading/writing during the suspend
3642 probably ended up here */
3643 for (i = 0; i < NR_HW_CH; i++) {
3644 struct ali_state *state = card->states[i];
3646 wake_up(&state->dmabuf.wait);
3650 #endif /* CONFIG_PM */
3653 MODULE_DESCRIPTION("ALI 5455 audio support");
3654 MODULE_LICENSE("GPL");
3655 MODULE_PARM(clocking, "i");
3656 MODULE_PARM(strict_clocking, "i");
3657 MODULE_PARM(codec_pcmout_share_spdif_locked, "i");
3658 MODULE_PARM(codec_independent_spdif_locked, "i");
3659 MODULE_PARM(controller_pcmout_share_spdif_locked, "i");
3660 MODULE_PARM(controller_independent_spdif_locked, "i");
3661 #define ALI5455_MODULE_NAME "ali5455"
3662 static struct pci_driver ali_pci_driver = {
3663 .name = ALI5455_MODULE_NAME,
3664 .id_table = ali_pci_tbl,
3666 .remove = __devexit_p(ali_remove),
3668 .suspend = ali_pm_suspend,
3669 .resume = ali_pm_resume,
3670 #endif /* CONFIG_PM */
3673 static int __init ali_init_module(void)
3675 printk(KERN_INFO "ALI 5455 + AC97 Audio, version "
3676 DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
3678 if (codec_independent_spdif_locked > 0) {
3679 if (codec_independent_spdif_locked == 32000
3680 || codec_independent_spdif_locked == 44100
3681 || codec_independent_spdif_locked == 48000) {
3682 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_independent_spdif_locked);
3684 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3685 codec_independent_spdif_locked = 0;
3688 if (controller_independent_spdif_locked > 0) {
3689 if (controller_independent_spdif_locked == 32000
3690 || controller_independent_spdif_locked == 44100
3691 || controller_independent_spdif_locked == 48000) {
3692 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", controller_independent_spdif_locked);
3694 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3695 controller_independent_spdif_locked = 0;
3699 if (codec_pcmout_share_spdif_locked > 0) {
3700 if (codec_pcmout_share_spdif_locked == 32000
3701 || codec_pcmout_share_spdif_locked == 44100
3702 || codec_pcmout_share_spdif_locked == 48000) {
3703 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_pcmout_share_spdif_locked);
3705 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3706 codec_pcmout_share_spdif_locked = 0;
3709 if (controller_pcmout_share_spdif_locked > 0) {
3710 if (controller_pcmout_share_spdif_locked == 32000
3711 || controller_pcmout_share_spdif_locked == 44100
3712 || controller_pcmout_share_spdif_locked == 48000) {
3713 printk(KERN_INFO "ali_audio: Enabling controller S/PDIF at sample rate %dHz.\n", controller_pcmout_share_spdif_locked);
3715 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3716 controller_pcmout_share_spdif_locked = 0;
3719 if (!pci_register_driver(&ali_pci_driver)) {
3720 pci_unregister_driver(&ali_pci_driver);
3726 static void __exit ali_cleanup_module(void)
3728 pci_unregister_driver(&ali_pci_driver);
3731 module_init(ali_init_module);
3732 module_exit(ali_cleanup_module);