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>
69 #ifndef PCI_DEVICE_ID_ALI_5455
70 #define PCI_DEVICE_ID_ALI_5455 0x5455
73 #ifndef PCI_VENDOR_ID_ALI
74 #define PCI_VENDOR_ID_ALI 0x10b9
77 static int strict_clocking = 0;
78 static unsigned int clocking = 0;
79 static unsigned int codec_pcmout_share_spdif_locked = 0;
80 static unsigned int codec_independent_spdif_locked = 0;
81 static unsigned int controller_pcmout_share_spdif_locked = 0;
82 static unsigned int controller_independent_spdif_locked = 0;
83 static unsigned int globel = 0;
87 #define CODEC_SPDIFOUT_RUNNING 8
88 #define CONTROLLER_SPDIFOUT_RUNNING 4
90 #define SPDIF_ENABLE_OUTPUT 4 /* bits 0,1 are PCM */
92 #define ALI5455_FMT_16BIT 1
93 #define ALI5455_FMT_STEREO 2
94 #define ALI5455_FMT_MASK 3
96 #define SPDIF_ON 0x0004
97 #define SURR_ON 0x0010
98 #define CENTER_LFE_ON 0x0020
99 #define VOL_MUTED 0x8000
102 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
103 /* the 810's array of pointers to data buffers */
106 #define BUSADDR_MASK 0xFFFFFFFE
108 #define CON_IOC 0x80000000 /* interrupt on completion */
109 #define CON_BUFPAD 0x40000000 /* pad underrun with last sample, else 0 */
110 #define CON_BUFLEN_MASK 0x0000ffff /* buffer length in samples */
114 /* an instance of the ali channel */
117 /* these sg guys should probably be allocated
118 separately as nocache. Must be 8 byte aligned */
119 struct sg_item sg[SG_LEN]; /* 32*8 */
127 * we have 3 separate dma engines. pcm in, pcm out, and mic.
128 * each dma engine has controlling registers. These goofy
129 * names are from the datasheet, but make it easy to write
130 * code while leafing through it.
133 #define ENUM_ENGINE(PRE,DIG) \
135 PRE##_BDBAR = 0x##DIG##0, /* Buffer Descriptor list Base Address */ \
136 PRE##_CIV = 0x##DIG##4, /* Current Index Value */ \
137 PRE##_LVI = 0x##DIG##5, /* Last Valid Index */ \
138 PRE##_SR = 0x##DIG##6, /* Status Register */ \
139 PRE##_PICB = 0x##DIG##8, /* Position In Current Buffer */ \
140 PRE##_CR = 0x##DIG##b /* Control Register */ \
143 ENUM_ENGINE(OFF, 0); /* Offsets */
144 ENUM_ENGINE(PI, 4); /* PCM In */
145 ENUM_ENGINE(PO, 5); /* PCM Out */
146 ENUM_ENGINE(MC, 6); /* Mic In */
147 ENUM_ENGINE(CODECSPDIFOUT, 7); /* CODEC SPDIF OUT */
148 ENUM_ENGINE(CONTROLLERSPDIFIN, A); /* CONTROLLER SPDIF In */
149 ENUM_ENGINE(CONTROLLERSPDIFOUT, B); /* CONTROLLER SPDIF OUT */
153 ALI_SCR = 0x00, /* System Control Register */
154 ALI_SSR = 0x04, /* System Status Register */
155 ALI_DMACR = 0x08, /* DMA Control Register */
156 ALI_FIFOCR1 = 0x0c, /* FIFO Control Register 1 */
157 ALI_INTERFACECR = 0x10, /* Interface Control Register */
158 ALI_INTERRUPTCR = 0x14, /* Interrupt control Register */
159 ALI_INTERRUPTSR = 0x18, /* Interrupt Status Register */
160 ALI_FIFOCR2 = 0x1c, /* FIFO Control Register 2 */
161 ALI_CPR = 0x20, /* Command Port Register */
162 ALI_SPR = 0x24, /* Status Port Register */
163 ALI_FIFOCR3 = 0x2c, /* FIFO Control Register 3 */
164 ALI_TTSR = 0x30, /* Transmit Tag Slot Register */
165 ALI_RTSR = 0x34, /* Receive Tag Slot Register */
166 ALI_CSPSR = 0x38, /* Command/Status Port Status Register */
167 ALI_CAS = 0x3c, /* Codec Write Semaphore Register */
168 ALI_SPDIFCSR = 0xf8, /* spdif channel status register */
169 ALI_SPDIFICS = 0xfc /* spdif interface control/status */
172 // x-status register(x:pcm in ,pcm out, mic in,)
173 /* interrupts for a dma engine */
174 #define DMA_INT_FIFO (1<<4) /* fifo under/over flow */
175 #define DMA_INT_COMPLETE (1<<3) /* buffer read/write complete and ioc set */
176 #define DMA_INT_LVI (1<<2) /* last valid done */
177 #define DMA_INT_CELV (1<<1) /* last valid is current */
178 #define DMA_INT_DCH (1) /* DMA Controller Halted (happens on LVI interrupts) */ //not eqult intel
179 #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
181 /* interrupts for the whole chip */// by interrupt status register finish
183 #define INT_SPDIFOUT (1<<23) /* controller spdif out INTERRUPT */
184 #define INT_SPDIFIN (1<<22)
185 #define INT_CODECSPDIFOUT (1<<19)
186 #define INT_MICIN (1<<18)
187 #define INT_PCMOUT (1<<17)
188 #define INT_PCMIN (1<<16)
189 #define INT_CPRAIS (1<<7)
190 #define INT_SPRAIS (1<<5)
191 #define INT_GPIO (1<<1)
192 #define INT_MASK (INT_SPDIFOUT|INT_CODECSPDIFOUT|INT_MICIN|INT_PCMOUT|INT_PCMIN)
194 #define DRIVER_VERSION "0.02ac"
196 /* magic numbers to protect our data structures */
197 #define ALI5455_CARD_MAGIC 0x5072696E /* "Prin" */
198 #define ALI5455_STATE_MAGIC 0x63657373 /* "cess" */
199 #define ALI5455_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
200 #define NR_HW_CH 5 //I think 5 channel
202 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
205 /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
206 /* stream at a minimum for this card to be happy */
207 static const unsigned sample_size[] = { 1, 2, 2, 4 };
208 /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
209 /* values are one less than might be expected */
210 static const unsigned sample_shift[] = { -1, 0, 0, 1 };
213 static char *card_names[] = {
217 static struct pci_device_id ali_pci_tbl[] = {
218 {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5455,
219 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI5455},
223 MODULE_DEVICE_TABLE(pci, ali_pci_tbl);
226 #define PM_SUSPENDED(card) (card->pm_suspended)
228 #define PM_SUSPENDED(card) (0)
231 /* "software" or virtual channel, an instance of opened /dev/dsp */
234 struct ali_card *card; /* Card info */
236 /* single open lock mechanism, only used for recording */
237 struct semaphore open_sem;
238 wait_queue_head_t open_wait;
243 /* virtual channel number */
247 unsigned int pm_saved_dac_rate, pm_saved_adc_rate;
250 /* wave sample stuff */
252 unsigned char fmt, enable, trigger;
254 /* hardware channel */
255 struct ali_channel *read_channel;
256 struct ali_channel *write_channel;
257 struct ali_channel *codec_spdifout_channel;
258 struct ali_channel *controller_spdifout_channel;
260 /* OSS buffer management stuff */
262 dma_addr_t dma_handle;
267 /* our buffer acts like a circular ring */
268 unsigned hwptr; /* where dma last started, updated by update_ptr */
269 unsigned swptr; /* where driver last clear/filled, updated by read/write */
270 int count; /* bytes to be consumed or been generated by dma machine */
271 unsigned total_bytes; /* total bytes dmaed by hardware */
273 unsigned error; /* number of over/underruns */
274 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
276 /* redundant, but makes calculations easier */
277 /* what the hardware uses */
280 unsigned fragsamples;
282 /* what we tell the user to expect */
284 unsigned userfragsize;
289 unsigned update_flag;
290 unsigned ossfragsize;
291 unsigned ossmaxfrags;
292 unsigned subdivision;
298 struct ali_channel channel[5];
301 /* We keep ali5455 cards in a linked list */
302 struct ali_card *next;
304 /* The ali has a certain amount of cross channel interaction
305 so we use a single per card lock */
307 spinlock_t ac97_lock;
309 /* PCI device stuff */
310 struct pci_dev *pci_dev;
314 u32 pm_save_state[64 / sizeof(u32)];
315 int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
317 /* soundcore stuff */
320 /* structures for abstraction of hardware facilities, codecs, banks and channels */
321 struct ac97_codec *ac97_codec[NR_AC97];
322 struct ali_state *states[NR_HW_CH];
328 /* hardware resources */
329 unsigned long iobase;
333 /* Function support */
334 struct ali_channel *(*alloc_pcm_channel) (struct ali_card *);
335 struct ali_channel *(*alloc_rec_pcm_channel) (struct ali_card *);
336 struct ali_channel *(*alloc_rec_mic_channel) (struct ali_card *);
337 struct ali_channel *(*alloc_codec_spdifout_channel) (struct ali_card *);
338 struct ali_channel *(*alloc_controller_spdifout_channel) (struct ali_card *);
339 void (*free_pcm_channel) (struct ali_card *, int chan);
341 /* We have a *very* long init time possibly, so use this to block */
342 /* attempts to open our devices before we are ready (stops oops'es) */
347 static struct ali_card *devs = NULL;
349 static int ali_open_mixdev(struct inode *inode, struct file *file);
350 static int ali_ioctl_mixdev(struct inode *inode, struct file *file,
351 unsigned int cmd, unsigned long arg);
352 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg);
353 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
355 static struct ali_channel *ali_alloc_pcm_channel(struct ali_card *card)
357 if (card->channel[1].used == 1)
359 card->channel[1].used = 1;
360 return &card->channel[1];
363 static struct ali_channel *ali_alloc_rec_pcm_channel(struct ali_card *card)
365 if (card->channel[0].used == 1)
367 card->channel[0].used = 1;
368 return &card->channel[0];
371 static struct ali_channel *ali_alloc_rec_mic_channel(struct ali_card *card)
373 if (card->channel[2].used == 1)
375 card->channel[2].used = 1;
376 return &card->channel[2];
379 static struct ali_channel *ali_alloc_codec_spdifout_channel(struct ali_card *card)
381 if (card->channel[3].used == 1)
383 card->channel[3].used = 1;
384 return &card->channel[3];
387 static struct ali_channel *ali_alloc_controller_spdifout_channel(struct ali_card *card)
389 if (card->channel[4].used == 1)
391 card->channel[4].used = 1;
392 return &card->channel[4];
394 static void ali_free_pcm_channel(struct ali_card *card, int channel)
396 card->channel[channel].used = 0;
400 //add support codec spdif out
401 static int ali_valid_spdif_rate(struct ac97_codec *codec, int rate)
403 unsigned long id = 0L;
405 id = (ali_ac97_get(codec, AC97_VENDOR_ID1) << 16);
406 id |= ali_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
408 case 0x41445361: /* AD1886 */
413 case 0x414c4720: /* ALC650 */
418 default: /* all other codecs, until we know otherwiae */
419 if (rate == 48000 || rate == 44100 || rate == 32000) {
427 /* ali_set_spdif_output
429 * Configure the S/PDIF output transmitter. When we turn on
430 * S/PDIF, we turn off the analog output. This may not be
431 * the right thing to do.
434 * The DSP sample rate must already be set to a supported
435 * S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
437 static void ali_set_spdif_output(struct ali_state *state, int slots,
442 struct ac97_codec *codec = state->card->ac97_codec[0];
444 if (!(state->card->ac97_features & 4)) {
445 state->card->ac97_status &= ~SPDIF_ON;
447 if (slots == -1) { /* Turn off S/PDIF */
448 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
449 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
451 /* If the volume wasn't muted before we turned on S/PDIF, unmute it */
452 if (!(state->card->ac97_status & VOL_MUTED)) {
453 aud_reg = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
454 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO,
455 (aud_reg & ~VOL_MUTED));
457 state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
461 vol = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
462 state->card->ac97_status = vol & VOL_MUTED;
464 /* Set S/PDIF transmitter sample rate */
465 aud_reg = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
468 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
471 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
474 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
477 /* turn off S/PDIF */
478 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
479 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
480 state->card->ac97_status &= ~SPDIF_ON;
484 ali_ac97_set(codec, AC97_SPDIF_CONTROL, aud_reg);
486 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
487 aud_reg = (aud_reg & AC97_EA_SLOT_MASK) | slots | AC97_EA_SPDIF;
488 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
490 aud_reg = ali_ac97_get(codec, AC97_POWER_CONTROL);
492 ali_ac97_set(codec, AC97_POWER_CONTROL, aud_reg);
495 state->card->ac97_status |= SPDIF_ON;
497 /* Check to make sure the configuration is valid */
498 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
499 if (!(aud_reg & 0x0400)) {
500 /* turn off S/PDIF */
501 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
502 state->card->ac97_status &= ~SPDIF_ON;
505 if (codec_independent_spdif_locked > 0) {
506 aud_reg = ali_ac97_get(codec, 0x6a);
507 ali_ac97_set(codec, 0x6a, (aud_reg & 0xefff));
509 /* Mute the analog output */
510 /* Should this only mute the PCM volume??? */
514 /* ali_set_dac_channels
516 * Configure the codec's multi-channel DACs
518 * The logic is backwards. Setting the bit to 1 turns off the DAC.
520 * What about the ICH? We currently configure it using the
521 * SNDCTL_DSP_CHANNELS ioctl. If we're turnning on the DAC,
522 * does that imply that we want the ICH set to support
526 * vailidate that the codec really supports these DACs
527 * before turning them on.
529 static void ali_set_dac_channels(struct ali_state *state, int channel)
532 struct ac97_codec *codec = state->card->ac97_codec[0];
534 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
535 aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
536 state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
539 case 2: /* always enabled */
542 aud_reg &= ~AC97_EA_PRJ;
543 state->card->ac97_status |= SURR_ON;
546 aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
547 state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
552 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
556 /* set playback sample rate */
557 static unsigned int ali_set_dac_rate(struct ali_state *state,
560 struct dmabuf *dmabuf = &state->dmabuf;
562 struct ac97_codec *codec = state->card->ac97_codec[0];
564 if (!(state->card->ac97_features & 0x0001)) {
565 dmabuf->rate = clocking;
576 * Adjust for misclocked crap
579 rate = (rate * clocking) / 48000;
581 if (strict_clocking && rate < 8000) {
583 dmabuf->rate = (rate * 48000) / clocking;
586 new_rate = ac97_set_dac_rate(codec, rate);
587 if (new_rate != rate) {
588 dmabuf->rate = (new_rate * 48000) / clocking;
594 /* set recording sample rate */
595 static unsigned int ali_set_adc_rate(struct ali_state *state,
598 struct dmabuf *dmabuf = &state->dmabuf;
600 struct ac97_codec *codec = state->card->ac97_codec[0];
602 if (!(state->card->ac97_features & 0x0001)) {
603 dmabuf->rate = clocking;
614 * Adjust for misclocked crap
617 rate = (rate * clocking) / 48000;
618 if (strict_clocking && rate < 8000) {
620 dmabuf->rate = (rate * 48000) / clocking;
623 new_rate = ac97_set_adc_rate(codec, rate);
625 if (new_rate != rate) {
626 dmabuf->rate = (new_rate * 48000) / clocking;
632 /* set codec independent spdifout sample rate */
633 static unsigned int ali_set_codecspdifout_rate(struct ali_state *state,
636 struct dmabuf *dmabuf = &state->dmabuf;
638 if (!(state->card->ac97_features & 0x0001)) {
639 dmabuf->rate = clocking;
652 /* set controller independent spdif out function sample rate */
653 static void ali_set_spdifout_rate(struct ali_state *state,
656 unsigned char ch_st_sel;
657 unsigned short status_rate;
672 ch_st_sel = inb(state->card->iobase + ALI_SPDIFICS) & ALI_SPDIF_OUT_CH_STATUS; //select spdif_out
674 ch_st_sel |= 0x80; //select right
675 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
676 outb(status_rate | 0x20, (state->card->iobase + ALI_SPDIFCSR + 2));
678 ch_st_sel &= (~0x80); //select left
679 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
680 outw(status_rate | 0x10, (state->card->iobase + ALI_SPDIFCSR + 2));
683 /* get current playback/recording dma buffer pointer (byte offset from LBA),
684 called with spinlock held! */
686 static inline unsigned ali_get_dma_addr(struct ali_state *state, int rec)
688 struct dmabuf *dmabuf = &state->dmabuf;
689 unsigned int civ, offset, port, port_picb;
696 port = state->card->iobase + dmabuf->read_channel->port;
698 port = state->card->iobase + dmabuf->codec_spdifout_channel->port;
700 port = state->card->iobase + dmabuf->controller_spdifout_channel->port;
702 port = state->card->iobase + dmabuf->write_channel->port;
704 port_picb = port + OFF_PICB;
707 civ = inb(port + OFF_CIV) & 31;
708 offset = inw(port_picb);
709 /* Must have a delay here! */
713 /* Reread both registers and make sure that that total
714 * offset from the first reading to the second is 0.
715 * There is an issue with SiS hardware where it will count
716 * picb down to 0, then update civ to the next value,
717 * then set the new picb to fragsize bytes. We can catch
718 * it between the civ update and the picb update, making
719 * it look as though we are 1 fragsize ahead of where we
720 * are. The next to we get the address though, it will
721 * be back in thdelay is more than long enough
722 * that we won't have to worry about the chip still being
723 * out of sync with reality ;-)
725 } while (civ != (inb(port + OFF_CIV) & 31) || offset != inw(port_picb));
727 data = ((civ + 1) * dmabuf->fragsize - (2 * offset)) % dmabuf->dmasize;
728 if (inw(port_picb) == 0)
734 /* Stop recording (lock held) */
735 static inline void __stop_adc(struct ali_state *state)
737 struct dmabuf *dmabuf = &state->dmabuf;
738 struct ali_card *card = state->card;
740 dmabuf->enable &= ~ADC_RUNNING;
742 outl((1 << 18) | (1 << 16), card->iobase + ALI_DMACR);
745 outb(0, card->iobase + PI_CR);
746 while (inb(card->iobase + PI_CR) != 0);
748 // now clear any latent interrupt bits (like the halt bit)
749 outb(inb(card->iobase + PI_SR) | 0x001e, card->iobase + PI_SR);
750 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMIN, card->iobase + ALI_INTERRUPTSR);
753 static void stop_adc(struct ali_state *state)
755 struct ali_card *card = state->card;
757 spin_lock_irqsave(&card->lock, flags);
759 spin_unlock_irqrestore(&card->lock, flags);
762 static inline void __start_adc(struct ali_state *state)
764 struct dmabuf *dmabuf = &state->dmabuf;
766 if (dmabuf->count < dmabuf->dmasize && dmabuf->ready
767 && !dmabuf->enable && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
768 dmabuf->enable |= ADC_RUNNING;
769 outb((1 << 4) | (1 << 2), state->card->iobase + PI_CR);
770 if (state->card->channel[0].used == 1)
771 outl(1, state->card->iobase + ALI_DMACR); // DMA CONTROL REGISTRER
773 if (state->card->channel[2].used == 1)
774 outl((1 << 2), state->card->iobase + ALI_DMACR); //DMA CONTROL REGISTER
779 static void start_adc(struct ali_state *state)
781 struct ali_card *card = state->card;
784 spin_lock_irqsave(&card->lock, flags);
786 spin_unlock_irqrestore(&card->lock, flags);
789 /* stop playback (lock held) */
790 static inline void __stop_dac(struct ali_state *state)
792 struct dmabuf *dmabuf = &state->dmabuf;
793 struct ali_card *card = state->card;
795 dmabuf->enable &= ~DAC_RUNNING;
796 outl(0x00020000, card->iobase + 0x08);
797 outb(0, card->iobase + PO_CR);
798 while (inb(card->iobase + PO_CR) != 0)
801 outb(inb(card->iobase + PO_SR) | 0x001e, card->iobase + PO_SR);
803 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMOUT, card->iobase + ALI_INTERRUPTSR);
806 static void stop_dac(struct ali_state *state)
808 struct ali_card *card = state->card;
810 spin_lock_irqsave(&card->lock, flags);
812 spin_unlock_irqrestore(&card->lock, flags);
815 static inline void __start_dac(struct ali_state *state)
817 struct dmabuf *dmabuf = &state->dmabuf;
818 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
819 (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
820 dmabuf->enable |= DAC_RUNNING;
821 outb((1 << 4) | (1 << 2), state->card->iobase + PO_CR);
822 outl((1 << 1), state->card->iobase + 0x08); //dma control register
826 static void start_dac(struct ali_state *state)
828 struct ali_card *card = state->card;
830 spin_lock_irqsave(&card->lock, flags);
832 spin_unlock_irqrestore(&card->lock, flags);
835 /* stop codec and controller spdif out (lock held) */
836 static inline void __stop_spdifout(struct ali_state *state)
838 struct dmabuf *dmabuf = &state->dmabuf;
839 struct ali_card *card = state->card;
841 if (codec_independent_spdif_locked > 0) {
842 dmabuf->enable &= ~CODEC_SPDIFOUT_RUNNING;
843 outl((1 << 19), card->iobase + 0x08);
844 outb(0, card->iobase + CODECSPDIFOUT_CR);
846 while (inb(card->iobase + CODECSPDIFOUT_CR) != 0)
849 outb(inb(card->iobase + CODECSPDIFOUT_SR) | 0x001e, card->iobase + CODECSPDIFOUT_SR);
850 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_CODECSPDIFOUT, card->iobase + ALI_INTERRUPTSR);
852 if (controller_independent_spdif_locked > 0) {
853 dmabuf->enable &= ~CONTROLLER_SPDIFOUT_RUNNING;
854 outl((1 << 23), card->iobase + 0x08);
855 outb(0, card->iobase + CONTROLLERSPDIFOUT_CR);
856 while (inb(card->iobase + CONTROLLERSPDIFOUT_CR) != 0)
858 outb(inb(card->iobase + CONTROLLERSPDIFOUT_SR) | 0x001e, card->iobase + CONTROLLERSPDIFOUT_SR);
859 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_SPDIFOUT, card->iobase + ALI_INTERRUPTSR);
864 static void stop_spdifout(struct ali_state *state)
866 struct ali_card *card = state->card;
868 spin_lock_irqsave(&card->lock, flags);
869 __stop_spdifout(state);
870 spin_unlock_irqrestore(&card->lock, flags);
873 static inline void __start_spdifout(struct ali_state *state)
875 struct dmabuf *dmabuf = &state->dmabuf;
876 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
877 (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
878 if (codec_independent_spdif_locked > 0) {
879 dmabuf->enable |= CODEC_SPDIFOUT_RUNNING;
880 outb((1 << 4) | (1 << 2), state->card->iobase + CODECSPDIFOUT_CR);
881 outl((1 << 3), state->card->iobase + 0x08); //dma control register
883 if (controller_independent_spdif_locked > 0) {
884 dmabuf->enable |= CONTROLLER_SPDIFOUT_RUNNING;
885 outb((1 << 4) | (1 << 2), state->card->iobase + CONTROLLERSPDIFOUT_CR);
886 outl((1 << 7), state->card->iobase + 0x08); //dma control register
892 static void start_spdifout(struct ali_state *state)
894 struct ali_card *card = state->card;
896 spin_lock_irqsave(&card->lock, flags);
897 __start_spdifout(state);
898 spin_unlock_irqrestore(&card->lock, flags);
901 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
902 #define DMABUF_MINORDER 1
904 /* allocate DMA buffer, playback , recording,spdif out buffer should be allocated separately */
905 static int alloc_dmabuf(struct ali_state *state)
907 struct dmabuf *dmabuf = &state->dmabuf;
910 struct page *page, *pend;
912 /* If we don't have any oss frag params, then use our default ones */
913 if (dmabuf->ossmaxfrags == 0)
914 dmabuf->ossmaxfrags = 4;
915 if (dmabuf->ossfragsize == 0)
916 dmabuf->ossfragsize = (PAGE_SIZE << DMABUF_DEFAULTORDER) / dmabuf->ossmaxfrags;
917 size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
919 if (dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
921 /* alloc enough to satisfy the oss params */
922 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
923 if ((PAGE_SIZE << order) > size)
925 if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
927 &dmabuf->dma_handle)))
933 dmabuf->ready = dmabuf->mapped = 0;
934 dmabuf->rawbuf = rawbuf;
935 dmabuf->buforder = order;
937 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
938 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
939 for (page = virt_to_page(rawbuf); page <= pend; page++)
940 SetPageReserved(page);
944 /* free DMA buffer */
945 static void dealloc_dmabuf(struct ali_state *state)
947 struct dmabuf *dmabuf = &state->dmabuf;
948 struct page *page, *pend;
950 if (dmabuf->rawbuf) {
951 /* undo marking the pages as reserved */
952 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
953 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
954 ClearPageReserved(page);
955 pci_free_consistent(state->card->pci_dev,
956 PAGE_SIZE << dmabuf->buforder,
957 dmabuf->rawbuf, dmabuf->dma_handle);
959 dmabuf->rawbuf = NULL;
960 dmabuf->mapped = dmabuf->ready = 0;
963 static int prog_dmabuf(struct ali_state *state, unsigned rec)
965 struct dmabuf *dmabuf = &state->dmabuf;
966 struct ali_channel *c = NULL;
973 spin_lock_irqsave(&state->card->lock, flags);
974 if (dmabuf->enable & DAC_RUNNING)
976 if (dmabuf->enable & ADC_RUNNING)
978 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
979 __stop_spdifout(state);
980 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
981 __stop_spdifout(state);
983 dmabuf->total_bytes = 0;
984 dmabuf->count = dmabuf->error = 0;
985 dmabuf->swptr = dmabuf->hwptr = 0;
986 spin_unlock_irqrestore(&state->card->lock, flags);
988 /* allocate DMA buffer, let alloc_dmabuf determine if we are already
989 * allocated well enough or if we should replace the current buffer
990 * (assuming one is already allocated, if it isn't, then allocate it).
992 if ((ret = alloc_dmabuf(state)))
995 /* FIXME: figure out all this OSS fragment stuff */
996 /* I did, it now does what it should according to the OSS API. DL */
997 /* We may not have realloced our dmabuf, but the fragment size to
998 * fragment number ratio may have changed, so go ahead and reprogram
1002 dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
1003 dmabuf->numfrag = SG_LEN;
1004 dmabuf->fragsize = dmabuf->dmasize / dmabuf->numfrag;
1005 dmabuf->fragsamples = dmabuf->fragsize >> 1;
1006 dmabuf->userfragsize = dmabuf->ossfragsize;
1007 dmabuf->userfrags = dmabuf->dmasize / dmabuf->ossfragsize;
1009 memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
1011 if (dmabuf->ossmaxfrags == 4) {
1013 dmabuf->fragshift = 2;
1014 } else if (dmabuf->ossmaxfrags == 8) {
1016 dmabuf->fragshift = 3;
1017 } else if (dmabuf->ossmaxfrags == 16) {
1019 dmabuf->fragshift = 4;
1022 dmabuf->fragshift = 5;
1025 * Now set up the ring
1029 c = dmabuf->read_channel;
1031 c = dmabuf->codec_spdifout_channel;
1033 c = dmabuf->controller_spdifout_channel;
1035 c = dmabuf->write_channel;
1039 * Load up 32 sg entries and take an interrupt at half
1040 * way (we might want more interrupts later..)
1042 for (i = 0; i < dmabuf->numfrag; i++) {
1044 virt_to_bus(dmabuf->rawbuf +
1045 dmabuf->fragsize * i);
1046 // the card will always be doing 16bit stereo
1047 sg->control = dmabuf->fragsamples;
1048 sg->control |= CON_BUFPAD; //I modify
1049 // set us up to get IOC interrupts as often as needed to
1050 // satisfy numfrag requirements, no more
1051 if (((i + 1) % fragint) == 0) {
1052 sg->control |= CON_IOC;
1056 spin_lock_irqsave(&state->card->lock, flags);
1057 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
1058 outl(virt_to_bus(&c->sg[0]), state->card->iobase + c->port + OFF_BDBAR);
1059 outb(0, state->card->iobase + c->port + OFF_CIV);
1060 outb(0, state->card->iobase + c->port + OFF_LVI);
1061 spin_unlock_irqrestore(&state->card->lock, flags);
1063 /* set the ready flag for the dma buffer */
1068 static void __ali_update_lvi(struct ali_state *state, int rec)
1070 struct dmabuf *dmabuf = &state->dmabuf;
1072 port = state->card->iobase;
1074 port += dmabuf->read_channel->port;
1076 port += dmabuf->codec_spdifout_channel->port;
1078 port += dmabuf->controller_spdifout_channel->port;
1080 port += dmabuf->write_channel->port;
1081 /* if we are currently stopped, then our CIV is actually set to our
1082 * *last* sg segment and we are ready to wrap to the next. However,
1083 * if we set our LVI to the last sg segment, then it won't wrap to
1084 * the next sg segment, it won't even get a start. So, instead, when
1085 * we are stopped, we set both the LVI value and also we increment
1086 * the CIV value to the next sg segment to be played so that when
1087 * we call start_{dac,adc}, things will operate properly
1089 if (!dmabuf->enable && dmabuf->ready) {
1090 if (rec && dmabuf->count < dmabuf->dmasize && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
1091 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1093 while (! (inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1095 } else if (!rec && dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
1096 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1098 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1100 } else if (rec && dmabuf->count && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
1101 if (codec_independent_spdif_locked > 0) {
1102 // outb((inb(port+OFF_CIV))&31, port+OFF_LVI);
1103 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1104 __start_spdifout(state);
1105 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1108 if (controller_independent_spdif_locked > 0) {
1109 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1110 __start_spdifout(state);
1111 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1118 /* swptr - 1 is the tail of our transfer */
1119 x = (dmabuf->dmasize + dmabuf->swptr - 1) % dmabuf->dmasize;
1120 x /= dmabuf->fragsize;
1121 outb(x, port + OFF_LVI);
1124 static void ali_update_lvi(struct ali_state *state, int rec)
1126 struct dmabuf *dmabuf = &state->dmabuf;
1127 unsigned long flags;
1130 spin_lock_irqsave(&state->card->lock, flags);
1131 __ali_update_lvi(state, rec);
1132 spin_unlock_irqrestore(&state->card->lock, flags);
1135 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1136 static void ali_update_ptr(struct ali_state *state)
1138 struct dmabuf *dmabuf = &state->dmabuf;
1142 /* error handling and process wake up for DAC */
1143 if (dmabuf->enable == ADC_RUNNING) {
1144 /* update hardware pointer */
1145 hwptr = ali_get_dma_addr(state, 1);
1146 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1147 dmabuf->hwptr = hwptr;
1148 dmabuf->total_bytes += diff;
1149 dmabuf->count += diff;
1150 if (dmabuf->count > dmabuf->dmasize) {
1151 /* buffer underrun or buffer overrun */
1152 /* this is normal for the end of a read */
1153 /* only give an error if we went past the */
1154 /* last valid sg entry */
1155 if ((inb(state->card->iobase + PI_CIV) & 31) != (inb(state->card->iobase + PI_LVI) & 31)) {
1156 printk(KERN_WARNING "ali_audio: DMA overrun on read\n");
1160 if (dmabuf->count > dmabuf->userfragsize)
1161 wake_up(&dmabuf->wait);
1163 /* error handling and process wake up for DAC */
1164 if (dmabuf->enable == DAC_RUNNING) {
1165 /* update hardware pointer */
1166 hwptr = ali_get_dma_addr(state, 0);
1168 (dmabuf->dmasize + hwptr -
1169 dmabuf->hwptr) % dmabuf->dmasize;
1170 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
1171 printk("DAC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
1173 dmabuf->hwptr = hwptr;
1174 dmabuf->total_bytes += diff;
1175 dmabuf->count -= diff;
1176 if (dmabuf->count < 0) {
1177 /* buffer underrun or buffer overrun */
1178 /* this is normal for the end of a write */
1179 /* only give an error if we went past the */
1180 /* last valid sg entry */
1181 if ((inb(state->card->iobase + PO_CIV) & 31) != (inb(state->card->iobase + PO_LVI) & 31)) {
1182 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1183 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1184 inb(state->card->iobase + PO_CIV) & 31,
1185 inb(state->card->iobase + PO_LVI) & 31,
1191 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1192 wake_up(&dmabuf->wait);
1195 /* error handling and process wake up for CODEC SPDIF OUT */
1196 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
1197 /* update hardware pointer */
1198 hwptr = ali_get_dma_addr(state, 2);
1199 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1200 dmabuf->hwptr = hwptr;
1201 dmabuf->total_bytes += diff;
1202 dmabuf->count -= diff;
1203 if (dmabuf->count < 0) {
1204 /* buffer underrun or buffer overrun */
1205 /* this is normal for the end of a write */
1206 /* only give an error if we went past the */
1207 /* last valid sg entry */
1208 if ((inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31)) {
1209 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1210 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1211 inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31,
1212 inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31,
1213 dmabuf->hwptr, dmabuf->count);
1217 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1218 wake_up(&dmabuf->wait);
1220 /* error handling and process wake up for CONTROLLER SPDIF OUT */
1221 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
1222 /* update hardware pointer */
1223 hwptr = ali_get_dma_addr(state, 3);
1224 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1225 dmabuf->hwptr = hwptr;
1226 dmabuf->total_bytes += diff;
1227 dmabuf->count -= diff;
1228 if (dmabuf->count < 0) {
1229 /* buffer underrun or buffer overrun */
1230 /* this is normal for the end of a write */
1231 /* only give an error if we went past the */
1232 /* last valid sg entry */
1233 if ((inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31)) {
1235 "ali_audio: DMA overrun on write\n");
1236 printk("ali_audio: CIV %d, LVI %d, hwptr %x, "
1238 inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31,
1239 inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31,
1240 dmabuf->hwptr, dmabuf->count);
1244 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1245 wake_up(&dmabuf->wait);
1249 static inline int ali_get_free_write_space(struct
1253 struct dmabuf *dmabuf = &state->dmabuf;
1256 if (dmabuf->count < 0) {
1258 dmabuf->swptr = dmabuf->hwptr;
1260 free = dmabuf->dmasize - dmabuf->swptr;
1261 if ((dmabuf->count + free) > dmabuf->dmasize){
1262 free = dmabuf->dmasize - dmabuf->count;
1267 static inline int ali_get_available_read_data(struct
1271 struct dmabuf *dmabuf = &state->dmabuf;
1273 ali_update_ptr(state);
1274 // catch overruns during record
1275 if (dmabuf->count > dmabuf->dmasize) {
1276 dmabuf->count = dmabuf->dmasize;
1277 dmabuf->swptr = dmabuf->hwptr;
1279 avail = dmabuf->count;
1280 avail -= (dmabuf->hwptr % dmabuf->fragsize);
1286 static int drain_dac(struct ali_state *state, int signals_allowed)
1289 DECLARE_WAITQUEUE(wait, current);
1290 struct dmabuf *dmabuf = &state->dmabuf;
1291 unsigned long flags;
1296 if (dmabuf->mapped) {
1300 add_wait_queue(&dmabuf->wait, &wait);
1303 spin_lock_irqsave(&state->card->lock, flags);
1304 ali_update_ptr(state);
1305 count = dmabuf->count;
1306 spin_unlock_irqrestore(&state->card->lock, flags);
1310 * This will make sure that our LVI is correct, that our
1311 * pointer is updated, and that the DAC is running. We
1312 * have to force the setting of dmabuf->trigger to avoid
1313 * any possible deadlocks.
1315 if (!dmabuf->enable) {
1316 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1317 ali_update_lvi(state, 0);
1319 if (signal_pending(current) && signals_allowed) {
1323 /* It seems that we have to set the current state to
1324 * TASK_INTERRUPTIBLE every time to make the process
1325 * really go to sleep. This also has to be *after* the
1326 * update_ptr() call because update_ptr is likely to
1327 * do a wake_up() which will unset this before we ever
1328 * try to sleep, resuling in a tight loop in this code
1329 * instead of actually sleeping and waiting for an
1330 * interrupt to wake us up!
1332 set_current_state(TASK_INTERRUPTIBLE);
1334 * set the timeout to significantly longer than it *should*
1335 * take for the DAC to drain the DMA buffer
1337 tmo = (count * HZ) / (dmabuf->rate);
1338 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1339 printk(KERN_ERR "ali_audio: drain_dac, dma timeout?\n");
1344 set_current_state(TASK_RUNNING);
1345 remove_wait_queue(&dmabuf->wait, &wait);
1346 if (count > 0 && signal_pending(current) && signals_allowed)
1347 return -ERESTARTSYS;
1353 static int drain_spdifout(struct ali_state *state, int signals_allowed)
1356 DECLARE_WAITQUEUE(wait, current);
1357 struct dmabuf *dmabuf = &state->dmabuf;
1358 unsigned long flags;
1363 if (dmabuf->mapped) {
1364 stop_spdifout(state);
1367 add_wait_queue(&dmabuf->wait, &wait);
1370 spin_lock_irqsave(&state->card->lock, flags);
1371 ali_update_ptr(state);
1372 count = dmabuf->count;
1373 spin_unlock_irqrestore(&state->card->lock, flags);
1377 * This will make sure that our LVI is correct, that our
1378 * pointer is updated, and that the DAC is running. We
1379 * have to force the setting of dmabuf->trigger to avoid
1380 * any possible deadlocks.
1382 if (!dmabuf->enable) {
1383 if (codec_independent_spdif_locked > 0) {
1384 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1385 ali_update_lvi(state, 2);
1387 if (controller_independent_spdif_locked > 0) {
1388 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1389 ali_update_lvi(state, 3);
1393 if (signal_pending(current) && signals_allowed) {
1397 /* It seems that we have to set the current state to
1398 * TASK_INTERRUPTIBLE every time to make the process
1399 * really go to sleep. This also has to be *after* the
1400 * update_ptr() call because update_ptr is likely to
1401 * do a wake_up() which will unset this before we ever
1402 * try to sleep, resuling in a tight loop in this code
1403 * instead of actually sleeping and waiting for an
1404 * interrupt to wake us up!
1406 set_current_state(TASK_INTERRUPTIBLE);
1408 * set the timeout to significantly longer than it *should*
1409 * take for the DAC to drain the DMA buffer
1411 tmo = (count * HZ) / (dmabuf->rate);
1412 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1413 printk(KERN_ERR "ali_audio: drain_spdifout, dma timeout?\n");
1418 set_current_state(TASK_RUNNING);
1419 remove_wait_queue(&dmabuf->wait, &wait);
1420 if (count > 0 && signal_pending(current) && signals_allowed)
1421 return -ERESTARTSYS;
1422 stop_spdifout(state);
1426 static void ali_channel_interrupt(struct ali_card *card)
1430 for (i = 0; i < NR_HW_CH; i++) {
1431 struct ali_state *state = card->states[i];
1432 struct ali_channel *c = NULL;
1433 struct dmabuf *dmabuf;
1434 unsigned long port = card->iobase;
1438 if (!state->dmabuf.ready)
1440 dmabuf = &state->dmabuf;
1441 if (codec_independent_spdif_locked > 0) {
1442 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
1443 c = dmabuf->codec_spdifout_channel;
1446 if (controller_independent_spdif_locked > 0) {
1447 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1448 c = dmabuf->controller_spdifout_channel;
1450 if (dmabuf->enable & DAC_RUNNING) {
1451 c = dmabuf->write_channel;
1452 } else if (dmabuf->enable & ADC_RUNNING) {
1453 c = dmabuf->read_channel;
1460 status = inw(port + OFF_SR);
1462 if (status & DMA_INT_COMPLETE) {
1463 /* only wake_up() waiters if this interrupt signals
1464 * us being beyond a userfragsize of data open or
1465 * available, and ali_update_ptr() does that for
1468 ali_update_ptr(state);
1471 if (status & DMA_INT_LVI) {
1472 ali_update_ptr(state);
1473 wake_up(&dmabuf->wait);
1475 if (dmabuf->enable & DAC_RUNNING)
1476 count = dmabuf->count;
1477 else if (dmabuf->enable & ADC_RUNNING)
1478 count = dmabuf->dmasize - dmabuf->count;
1479 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1480 count = dmabuf->count;
1481 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1482 count = dmabuf->count;
1486 if (dmabuf->enable & DAC_RUNNING)
1487 outl((1 << 1), state->card->iobase + ALI_DMACR);
1488 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1489 outl((1 << 3), state->card->iobase + ALI_DMACR);
1490 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1491 outl((1 << 7), state->card->iobase + ALI_DMACR);
1493 if (dmabuf->enable & DAC_RUNNING)
1495 if (dmabuf->enable & ADC_RUNNING)
1497 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1498 __stop_spdifout(state);
1499 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1500 __stop_spdifout(state);
1502 wake_up(&dmabuf->wait);
1506 if (!(status & DMA_INT_DCH)) {
1507 ali_update_ptr(state);
1508 wake_up(&dmabuf->wait);
1509 if (dmabuf->enable & DAC_RUNNING)
1510 count = dmabuf->count;
1511 else if (dmabuf->enable & ADC_RUNNING)
1512 count = dmabuf->dmasize - dmabuf->count;
1513 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1514 count = dmabuf->count;
1515 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1516 count = dmabuf->count;
1521 if (dmabuf->enable & DAC_RUNNING)
1522 outl((1 << 1), state->card->iobase + ALI_DMACR);
1523 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1524 outl((1 << 3), state->card->iobase + ALI_DMACR);
1525 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1526 outl((1 << 7), state->card->iobase + ALI_DMACR);
1528 if (dmabuf->enable & DAC_RUNNING)
1530 if (dmabuf->enable & ADC_RUNNING)
1532 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1533 __stop_spdifout(state);
1534 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1535 __stop_spdifout(state);
1537 wake_up(&dmabuf->wait);
1540 outw(status & DMA_INT_MASK, port + OFF_SR);
1544 static irqreturn_t ali_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1546 struct ali_card *card = (struct ali_card *) dev_id;
1550 spin_lock(&card->lock);
1551 status = inl(card->iobase + ALI_INTERRUPTSR);
1552 if (!(status & INT_MASK)) {
1553 spin_unlock(&card->lock);
1554 return IRQ_NONE; /* not for us */
1557 if (codec_independent_spdif_locked > 0) {
1560 status2 = inw(card->iobase + 0x76);
1561 outw(status2 | 0x000c, card->iobase + 0x76);
1563 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1564 ali_channel_interrupt(card);
1567 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1568 ali_channel_interrupt(card);
1572 outl(status & INT_MASK, card->iobase + ALI_INTERRUPTSR);
1573 spin_unlock(&card->lock);
1577 /* in this loop, dmabuf.count signifies the amount of data that is
1578 waiting to be copied to the user's buffer. It is filled by the dma
1579 machine and drained by this loop. */
1581 static ssize_t ali_read(struct file *file, char __user *buffer,
1582 size_t count, loff_t * ppos)
1584 struct ali_state *state = (struct ali_state *) file->private_data;
1585 struct ali_card *card = state ? state->card : NULL;
1586 struct dmabuf *dmabuf = &state->dmabuf;
1588 unsigned long flags;
1591 DECLARE_WAITQUEUE(waita, current);
1593 printk("ali_audio: ali_read called, count = %d\n", count);
1597 if (dmabuf->enable & DAC_RUNNING)
1599 if (!dmabuf->read_channel) {
1601 dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
1602 if (!dmabuf->read_channel) {
1606 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1608 if (!access_ok(VERIFY_WRITE, buffer, count))
1611 add_wait_queue(&dmabuf->wait, &waita);
1613 set_current_state(TASK_INTERRUPTIBLE);
1614 spin_lock_irqsave(&card->lock, flags);
1615 if (PM_SUSPENDED(card)) {
1616 spin_unlock_irqrestore(&card->lock, flags);
1618 if (signal_pending(current)) {
1625 swptr = dmabuf->swptr;
1626 cnt = ali_get_available_read_data(state);
1627 // this is to make the copy_to_user simpler below
1628 if (cnt > (dmabuf->dmasize - swptr))
1629 cnt = dmabuf->dmasize - swptr;
1630 spin_unlock_irqrestore(&card->lock, flags);
1633 /* Lop off the last two bits to force the code to always
1634 * write in full samples. This keeps software that sets
1635 * O_NONBLOCK but doesn't check the return value of the
1636 * write call from getting things out of state where they
1637 * think a full 4 byte sample was written when really only
1638 * a portion was, resulting in odd sound and stereo
1645 * Don't let us deadlock. The ADC won't start if
1646 * dmabuf->trigger isn't set. A call to SETTRIGGER
1647 * could have turned it off after we set it to on
1650 dmabuf->trigger = PCM_ENABLE_INPUT;
1652 * This does three things. Updates LVI to be correct,
1653 * makes sure the ADC is running, and updates the
1656 ali_update_lvi(state, 1);
1657 if (file->f_flags & O_NONBLOCK) {
1662 /* Set the timeout to how long it would take to fill
1663 * two of our buffers. If we haven't been woke up
1664 * by then, then we know something is wrong.
1666 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1668 /* There are two situations when sleep_on_timeout returns, one is when
1669 the interrupt is serviced correctly and the process is waked up by
1670 ISR ON TIME. Another is when timeout is expired, which means that
1671 either interrupt is NOT serviced correctly (pending interrupt) or it
1672 is TOO LATE for the process to be scheduled to run (scheduler latency)
1673 which results in a (potential) buffer overrun. And worse, there is
1674 NOTHING we can do to prevent it. */
1675 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1677 "ali_audio: recording schedule timeout, "
1678 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1679 dmabuf->dmasize, dmabuf->fragsize,
1680 dmabuf->count, dmabuf->hwptr,
1682 /* a buffer overrun, we delay the recovery until next time the
1683 while loop begin and we REALLY have space to record */
1685 if (signal_pending(current)) {
1686 ret = ret ? ret : -ERESTARTSYS;
1692 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1698 swptr = (swptr + cnt) % dmabuf->dmasize;
1699 spin_lock_irqsave(&card->lock, flags);
1700 if (PM_SUSPENDED(card)) {
1701 spin_unlock_irqrestore(&card->lock, flags);
1704 dmabuf->swptr = swptr;
1705 dmabuf->count -= cnt;
1706 spin_unlock_irqrestore(&card->lock, flags);
1712 ali_update_lvi(state, 1);
1713 set_current_state(TASK_RUNNING);
1714 remove_wait_queue(&dmabuf->wait, &waita);
1718 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1719 the soundcard. it is drained by the dma machine and filled by this loop. */
1720 static ssize_t ali_write(struct file *file,
1721 const char __user *buffer, size_t count, loff_t * ppos)
1723 struct ali_state *state = (struct ali_state *) file->private_data;
1724 struct ali_card *card = state ? state->card : NULL;
1725 struct dmabuf *dmabuf = &state->dmabuf;
1727 unsigned long flags;
1728 unsigned int swptr = 0;
1730 DECLARE_WAITQUEUE(waita, current);
1732 printk("ali_audio: ali_write called, count = %d\n", count);
1736 if (dmabuf->enable & ADC_RUNNING)
1738 if (codec_independent_spdif_locked > 0) {
1739 if (!dmabuf->codec_spdifout_channel) {
1741 dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card);
1742 if (!dmabuf->codec_spdifout_channel)
1746 if (controller_independent_spdif_locked > 0) {
1747 if (!dmabuf->controller_spdifout_channel) {
1749 dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card);
1750 if (!dmabuf->controller_spdifout_channel)
1754 if (!dmabuf->write_channel) {
1756 dmabuf->write_channel =
1757 card->alloc_pcm_channel(card);
1758 if (!dmabuf->write_channel)
1764 if (codec_independent_spdif_locked > 0) {
1765 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
1768 if (controller_independent_spdif_locked > 0) {
1769 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
1773 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1777 if (!access_ok(VERIFY_READ, buffer, count))
1780 add_wait_queue(&dmabuf->wait, &waita);
1782 set_current_state(TASK_INTERRUPTIBLE);
1783 spin_lock_irqsave(&state->card->lock, flags);
1784 if (PM_SUSPENDED(card)) {
1785 spin_unlock_irqrestore(&card->lock, flags);
1787 if (signal_pending(current)) {
1795 swptr = dmabuf->swptr;
1796 cnt = ali_get_free_write_space(state);
1797 /* Bound the maximum size to how much we can copy to the
1798 * dma buffer before we hit the end. If we have more to
1799 * copy then it will get done in a second pass of this
1800 * loop starting from the beginning of the buffer.
1802 if (cnt > (dmabuf->dmasize - swptr))
1803 cnt = dmabuf->dmasize - swptr;
1804 spin_unlock_irqrestore(&state->card->lock, flags);
1807 "ali_audio: ali_write: %d bytes available space\n",
1812 /* Lop off the last two bits to force the code to always
1813 * write in full samples. This keeps software that sets
1814 * O_NONBLOCK but doesn't check the return value of the
1815 * write call from getting things out of state where they
1816 * think a full 4 byte sample was written when really only
1817 * a portion was, resulting in odd sound and stereo
1823 // There is data waiting to be played
1825 * Force the trigger setting since we would
1826 * deadlock with it set any other way
1828 if (codec_independent_spdif_locked > 0) {
1829 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1830 ali_update_lvi(state, 2);
1832 if (controller_independent_spdif_locked > 0) {
1833 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1834 ali_update_lvi(state, 3);
1837 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1838 ali_update_lvi(state, 0);
1841 if (file->f_flags & O_NONBLOCK) {
1846 /* Not strictly correct but works */
1847 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1848 /* There are two situations when sleep_on_timeout returns, one is when
1849 the interrupt is serviced correctly and the process is waked up by
1850 ISR ON TIME. Another is when timeout is expired, which means that
1851 either interrupt is NOT serviced correctly (pending interrupt) or it
1852 is TOO LATE for the process to be scheduled to run (scheduler latency)
1853 which results in a (potential) buffer underrun. And worse, there is
1854 NOTHING we can do to prevent it. */
1856 /* FIXME - do timeout handling here !! */
1857 schedule_timeout(tmo >= 2 ? tmo : 2);
1859 if (signal_pending(current)) {
1866 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1872 swptr = (swptr + cnt) % dmabuf->dmasize;
1873 spin_lock_irqsave(&state->card->lock, flags);
1874 if (PM_SUSPENDED(card)) {
1875 spin_unlock_irqrestore(&card->lock, flags);
1879 dmabuf->swptr = swptr;
1880 dmabuf->count += cnt;
1884 spin_unlock_irqrestore(&state->card->lock, flags);
1886 if (swptr % dmabuf->fragsize) {
1887 x = dmabuf->fragsize - (swptr % dmabuf->fragsize);
1888 memset(dmabuf->rawbuf + swptr, '\0', x);
1891 if (codec_independent_spdif_locked > 0) {
1892 ali_update_lvi(state, 2);
1894 if (controller_independent_spdif_locked > 0) {
1895 ali_update_lvi(state, 3);
1897 ali_update_lvi(state, 0);
1900 set_current_state(TASK_RUNNING);
1901 remove_wait_queue(&dmabuf->wait, &waita);
1905 /* No kernel lock - we have our own spinlock */
1906 static unsigned int ali_poll(struct file *file, struct poll_table_struct
1909 struct ali_state *state = (struct ali_state *) file->private_data;
1910 struct dmabuf *dmabuf = &state->dmabuf;
1911 unsigned long flags;
1912 unsigned int mask = 0;
1915 poll_wait(file, &dmabuf->wait, wait);
1916 spin_lock_irqsave(&state->card->lock, flags);
1917 ali_update_ptr(state);
1918 if (file->f_mode & FMODE_READ && dmabuf->enable & ADC_RUNNING) {
1919 if (dmabuf->count >= (signed) dmabuf->fragsize)
1920 mask |= POLLIN | POLLRDNORM;
1922 if (file->f_mode & FMODE_WRITE && (dmabuf->enable & (DAC_RUNNING|CODEC_SPDIFOUT_RUNNING|CONTROLLER_SPDIFOUT_RUNNING))) {
1923 if ((signed) dmabuf->dmasize >= dmabuf->count + (signed) dmabuf->fragsize)
1924 mask |= POLLOUT | POLLWRNORM;
1926 spin_unlock_irqrestore(&state->card->lock, flags);
1930 static int ali_mmap(struct file *file, struct vm_area_struct *vma)
1932 struct ali_state *state = (struct ali_state *) file->private_data;
1933 struct dmabuf *dmabuf = &state->dmabuf;
1937 if (vma->vm_flags & VM_WRITE) {
1938 if (!dmabuf->write_channel && (dmabuf->write_channel = state->card->alloc_pcm_channel(state->card)) == NULL) {
1943 if (vma->vm_flags & VM_READ) {
1944 if (!dmabuf->read_channel && (dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
1949 if ((ret = prog_dmabuf(state, 0)) != 0)
1952 if (vma->vm_pgoff != 0)
1954 size = vma->vm_end - vma->vm_start;
1955 if (size > (PAGE_SIZE << dmabuf->buforder))
1958 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf), size, vma->vm_page_prot))
1961 dmabuf->trigger = 0;
1968 static int ali_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1970 struct ali_state *state = (struct ali_state *) file->private_data;
1971 struct ali_channel *c = NULL;
1972 struct dmabuf *dmabuf = &state->dmabuf;
1973 unsigned long flags;
1974 audio_buf_info abinfo;
1978 struct ac97_codec *codec = state->card->ac97_codec[0];
1979 void __user *argp = (void __user *)arg;
1980 int __user *p = argp;
1983 printk("ali_audio: ali_ioctl, arg=0x%x, cmd=",
1987 case OSS_GETVERSION:
1989 printk("OSS_GETVERSION\n");
1991 return put_user(SOUND_VERSION, p);
1992 case SNDCTL_DSP_RESET:
1994 printk("SNDCTL_DSP_RESET\n");
1996 spin_lock_irqsave(&state->card->lock, flags);
1997 if (dmabuf->enable == DAC_RUNNING) {
1998 c = dmabuf->write_channel;
2001 if (dmabuf->enable == ADC_RUNNING) {
2002 c = dmabuf->read_channel;
2005 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2006 c = dmabuf->codec_spdifout_channel;
2007 __stop_spdifout(state);
2009 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2010 c = dmabuf->controller_spdifout_channel;
2011 __stop_spdifout(state);
2014 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
2015 outl(virt_to_bus(&c->sg[0]),
2016 state->card->iobase + c->port + OFF_BDBAR);
2017 outb(0, state->card->iobase + c->port + OFF_CIV);
2018 outb(0, state->card->iobase + c->port + OFF_LVI);
2021 spin_unlock_irqrestore(&state->card->lock, flags);
2022 synchronize_irq(state->card->pci_dev->irq);
2024 dmabuf->swptr = dmabuf->hwptr = 0;
2025 dmabuf->count = dmabuf->total_bytes = 0;
2027 case SNDCTL_DSP_SYNC:
2029 printk("SNDCTL_DSP_SYNC\n");
2031 if (codec_independent_spdif_locked > 0) {
2032 if (dmabuf->enable != CODEC_SPDIFOUT_RUNNING
2033 || file->f_flags & O_NONBLOCK)
2035 if ((val = drain_spdifout(state, 1)))
2038 if (controller_independent_spdif_locked > 0) {
2039 if (dmabuf->enable !=
2040 CONTROLLER_SPDIFOUT_RUNNING
2041 || file->f_flags & O_NONBLOCK)
2043 if ((val = drain_spdifout(state, 1)))
2046 if (dmabuf->enable != DAC_RUNNING
2047 || file->f_flags & O_NONBLOCK)
2049 if ((val = drain_dac(state, 1)))
2053 dmabuf->total_bytes = 0;
2055 case SNDCTL_DSP_SPEED: /* set smaple rate */
2057 printk("SNDCTL_DSP_SPEED\n");
2059 if (get_user(val, p))
2062 if (file->f_mode & FMODE_WRITE) {
2063 if ((state->card->ac97_status & SPDIF_ON)) { /* S/PDIF Enabled */
2064 /* RELTEK ALC650 only support 48000, need to check that */
2065 if (ali_valid_spdif_rate(codec, val)) {
2066 if (codec_independent_spdif_locked > 0) {
2067 ali_set_spdif_output(state, -1, 0);
2068 stop_spdifout(state);
2070 /* I add test codec independent spdif out */
2071 spin_lock_irqsave(&state->card->lock, flags);
2072 ali_set_codecspdifout_rate(state, val); // I modified
2073 spin_unlock_irqrestore(&state->card->lock, flags);
2074 /* Set S/PDIF transmitter rate. */
2075 i_scr = inl(state->card->iobase + ALI_SCR);
2076 if ((i_scr & 0x00300000) == 0x00100000) {
2077 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2079 if ((i_scr&0x00300000) == 0x00200000)
2081 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2083 if ((i_scr & 0x00300000) == 0x00300000) {
2084 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2086 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2091 if (!(state->card->ac97_status & SPDIF_ON)) {
2095 if (controller_independent_spdif_locked > 0)
2097 stop_spdifout(state);
2099 spin_lock_irqsave(&state->card->lock, flags);
2100 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2101 spin_unlock_irqrestore(&state->card->lock, flags);
2104 ali_set_spdif_output(state, -1, 0);
2107 spin_lock_irqsave(&state->card->lock, flags);
2108 ali_set_dac_rate(state, val);
2109 spin_unlock_irqrestore(&state->card->lock, flags);
2110 /* Set S/PDIF transmitter rate. */
2111 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, val);
2112 if (!(state->card->ac97_status & SPDIF_ON))
2118 } else { /* Not a valid rate for S/PDIF, ignore it */
2124 spin_lock_irqsave(&state->card->lock, flags);
2125 ali_set_dac_rate(state, val);
2126 spin_unlock_irqrestore(&state->card->lock, flags);
2129 if (file->f_mode & FMODE_READ) {
2132 spin_lock_irqsave(&state->card->lock, flags);
2133 ali_set_adc_rate(state, val);
2134 spin_unlock_irqrestore(&state->card->lock, flags);
2137 return put_user(dmabuf->rate, p);
2138 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2140 printk("SNDCTL_DSP_STEREO\n");
2142 if (dmabuf->enable & DAC_RUNNING) {
2145 if (dmabuf->enable & ADC_RUNNING) {
2148 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2149 stop_spdifout(state);
2151 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2152 stop_spdifout(state);
2154 return put_user(1, p);
2155 case SNDCTL_DSP_GETBLKSIZE:
2156 if (file->f_mode & FMODE_WRITE) {
2157 if (codec_independent_spdif_locked > 0) {
2158 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)))
2161 if (controller_independent_spdif_locked > 0) {
2162 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)))
2165 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
2171 if (file->f_mode & FMODE_READ) {
2172 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
2176 printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
2178 return put_user(dmabuf->userfragsize, p);
2179 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2181 printk("SNDCTL_DSP_GETFMTS\n");
2183 return put_user(AFMT_S16_LE, p);
2184 case SNDCTL_DSP_SETFMT: /* Select sample format */
2186 printk("SNDCTL_DSP_SETFMT\n");
2188 return put_user(AFMT_S16_LE, p);
2189 case SNDCTL_DSP_CHANNELS: // add support 4,6 channel
2191 printk("SNDCTL_DSP_CHANNELS\n");
2193 if (get_user(val, p))
2196 if (dmabuf->enable & DAC_RUNNING) {
2199 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2200 stop_spdifout(state);
2202 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2203 stop_spdifout(state);
2205 if (dmabuf->enable & ADC_RUNNING) {
2209 return put_user(state->card->channels, p);
2212 i_scr = inl(state->card->iobase + ALI_SCR);
2213 /* Current # of channels enabled */
2214 if (i_scr & 0x00000100)
2216 else if (i_scr & 0x00000200)
2221 case 2: /* 2 channels is always supported */
2222 if (codec_independent_spdif_locked > 0) {
2223 outl(((i_scr & 0xfffffcff) | 0x00100000), (state->card->iobase + ALI_SCR));
2225 outl((i_scr & 0xfffffcff), (state->card->iobase + ALI_SCR));
2226 /* Do we need to change mixer settings???? */
2228 case 4: /* Supported on some chipsets, better check first */
2229 if (codec_independent_spdif_locked > 0) {
2230 outl(((i_scr & 0xfffffcff) | 0x00000100 | 0x00200000), (state->card->iobase + ALI_SCR));
2232 outl(((i_scr & 0xfffffcff) | 0x00000100), (state->card->iobase + ALI_SCR));
2234 case 6: /* Supported on some chipsets, better check first */
2235 if (codec_independent_spdif_locked > 0) {
2236 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000 | 0x00300000), (state->card->iobase + ALI_SCR));
2238 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000), (state->card->iobase + ALI_SCR));
2240 default: /* nothing else is ever supported by the chipset */
2244 return put_user(val, p);
2245 case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
2246 /* we update the swptr to the end of the last sg segment then return */
2248 printk("SNDCTL_DSP_POST\n");
2250 if (codec_independent_spdif_locked > 0) {
2251 if (!dmabuf->ready || (dmabuf->enable != CODEC_SPDIFOUT_RUNNING))
2254 if (controller_independent_spdif_locked > 0) {
2255 if (!dmabuf->ready || (dmabuf->enable != CONTROLLER_SPDIFOUT_RUNNING))
2258 if (!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
2262 if ((dmabuf->swptr % dmabuf->fragsize) != 0) {
2263 val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
2264 dmabuf->swptr += val;
2265 dmabuf->count += val;
2268 case SNDCTL_DSP_SUBDIVIDE:
2269 if (dmabuf->subdivision)
2271 if (get_user(val, p))
2273 if (val != 1 && val != 2 && val != 4)
2276 printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
2278 dmabuf->subdivision = val;
2281 case SNDCTL_DSP_SETFRAGMENT:
2282 if (get_user(val, p))
2284 dmabuf->ossfragsize = 1 << (val & 0xffff);
2285 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2286 if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
2289 * Bound the frag size into our allowed range of 256 - 4096
2291 if (dmabuf->ossfragsize < 256)
2292 dmabuf->ossfragsize = 256;
2293 else if (dmabuf->ossfragsize > 4096)
2294 dmabuf->ossfragsize = 4096;
2296 * The numfrags could be something reasonable, or it could
2297 * be 0xffff meaning "Give me as much as possible". So,
2298 * we check the numfrags * fragsize doesn't exceed our
2299 * 64k buffer limit, nor is it less than our 8k minimum.
2300 * If it fails either one of these checks, then adjust the
2301 * number of fragments, not the size of them. It's OK if
2302 * our number of fragments doesn't equal 32 or anything
2303 * like our hardware based number now since we are using
2304 * a different frag count for the hardware. Before we get
2305 * into this though, bound the maxfrags to avoid overflow
2306 * issues. A reasonable bound would be 64k / 256 since our
2307 * maximum buffer size is 64k and our minimum frag size is
2308 * 256. On the other end, our minimum buffer size is 8k and
2309 * our maximum frag size is 4k, so the lower bound should
2312 if (dmabuf->ossmaxfrags > 256)
2313 dmabuf->ossmaxfrags = 256;
2314 else if (dmabuf->ossmaxfrags < 2)
2315 dmabuf->ossmaxfrags = 2;
2316 val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
2317 while (val < 8192) {
2319 dmabuf->ossmaxfrags <<= 1;
2321 while (val > 65536) {
2323 dmabuf->ossmaxfrags >>= 1;
2327 printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
2328 dmabuf->ossfragsize, dmabuf->ossmaxfrags);
2331 case SNDCTL_DSP_GETOSPACE:
2332 if (!(file->f_mode & FMODE_WRITE))
2334 if (codec_independent_spdif_locked > 0) {
2335 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2338 if (controller_independent_spdif_locked > 0) {
2339 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2342 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2346 spin_lock_irqsave(&state->card->lock, flags);
2347 ali_update_ptr(state);
2348 abinfo.fragsize = dmabuf->userfragsize;
2349 abinfo.fragstotal = dmabuf->userfrags;
2351 abinfo.bytes = dmabuf->dmasize;
2353 abinfo.bytes = ali_get_free_write_space(state);
2354 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2355 spin_unlock_irqrestore(&state->card->lock, flags);
2356 #if defined(DEBUG) || defined(DEBUG_MMAP)
2357 printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n",
2358 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2361 return copy_to_user(argp, &abinfo,
2362 sizeof(abinfo)) ? -EFAULT : 0;
2363 case SNDCTL_DSP_GETOPTR:
2364 if (!(file->f_mode & FMODE_WRITE))
2366 if (codec_independent_spdif_locked > 0) {
2367 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2370 if (controller_independent_spdif_locked > 0) {
2371 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2374 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2378 spin_lock_irqsave(&state->card->lock, flags);
2379 val = ali_get_free_write_space(state);
2380 cinfo.bytes = dmabuf->total_bytes;
2381 cinfo.ptr = dmabuf->hwptr;
2382 cinfo.blocks = val / dmabuf->userfragsize;
2383 if (codec_independent_spdif_locked > 0) {
2384 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2385 dmabuf->count += val;
2386 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2387 __ali_update_lvi(state, 2);
2390 if (controller_independent_spdif_locked > 0) {
2391 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2392 dmabuf->count += val;
2393 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2394 __ali_update_lvi(state, 3);
2397 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
2398 dmabuf->count += val;
2399 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2400 __ali_update_lvi(state, 0);
2404 spin_unlock_irqrestore(&state->card->lock, flags);
2405 #if defined(DEBUG) || defined(DEBUG_MMAP)
2406 printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
2407 cinfo.blocks, cinfo.ptr, dmabuf->count);
2409 return copy_to_user(argp, &cinfo, sizeof(cinfo))? -EFAULT : 0;
2410 case SNDCTL_DSP_GETISPACE:
2411 if (!(file->f_mode & FMODE_READ))
2413 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
2415 spin_lock_irqsave(&state->card->lock, flags);
2416 abinfo.bytes = ali_get_available_read_data(state);
2417 abinfo.fragsize = dmabuf->userfragsize;
2418 abinfo.fragstotal = dmabuf->userfrags;
2419 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2420 spin_unlock_irqrestore(&state->card->lock, flags);
2421 #if defined(DEBUG) || defined(DEBUG_MMAP)
2422 printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n",
2423 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2426 return copy_to_user(argp, &abinfo,
2427 sizeof(abinfo)) ? -EFAULT : 0;
2428 case SNDCTL_DSP_GETIPTR:
2429 if (!(file->f_mode & FMODE_READ))
2431 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2433 spin_lock_irqsave(&state->card->lock, flags);
2434 val = ali_get_available_read_data(state);
2435 cinfo.bytes = dmabuf->total_bytes;
2436 cinfo.blocks = val / dmabuf->userfragsize;
2437 cinfo.ptr = dmabuf->hwptr;
2438 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
2439 dmabuf->count -= val;
2440 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2441 __ali_update_lvi(state, 1);
2443 spin_unlock_irqrestore(&state->card->lock, flags);
2444 #if defined(DEBUG) || defined(DEBUG_MMAP)
2445 printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
2446 cinfo.blocks, cinfo.ptr, dmabuf->count);
2448 return copy_to_user(argp, &cinfo, sizeof(cinfo))? -EFAULT: 0;
2449 case SNDCTL_DSP_NONBLOCK:
2451 printk("SNDCTL_DSP_NONBLOCK\n");
2453 file->f_flags |= O_NONBLOCK;
2455 case SNDCTL_DSP_GETCAPS:
2457 printk("SNDCTL_DSP_GETCAPS\n");
2459 return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2460 DSP_CAP_MMAP | DSP_CAP_BIND, p);
2461 case SNDCTL_DSP_GETTRIGGER:
2464 printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
2466 return put_user(dmabuf->trigger, p);
2467 case SNDCTL_DSP_SETTRIGGER:
2468 if (get_user(val, p))
2470 #if defined(DEBUG) || defined(DEBUG_MMAP)
2471 printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
2473 if (!(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
2476 if (!(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
2479 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2480 stop_spdifout(state);
2482 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2483 stop_spdifout(state);
2485 dmabuf->trigger = val;
2486 if (val & PCM_ENABLE_OUTPUT && !(dmabuf->enable & DAC_RUNNING)) {
2487 if (!dmabuf->write_channel) {
2489 dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
2490 if (!dmabuf->write_channel)
2493 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
2495 if (dmabuf->mapped) {
2496 spin_lock_irqsave(&state->card->lock, flags);
2497 ali_update_ptr(state);
2499 dmabuf->swptr = dmabuf->hwptr;
2500 dmabuf->count = ali_get_free_write_space(state);
2501 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2502 __ali_update_lvi(state, 0);
2503 spin_unlock_irqrestore(&state->card->lock,
2508 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CODEC_SPDIFOUT_RUNNING)) {
2509 if (!dmabuf->codec_spdifout_channel) {
2511 dmabuf->codec_spdifout_channel = state->card->alloc_codec_spdifout_channel(state->card);
2512 if (!dmabuf->codec_spdifout_channel)
2515 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
2517 if (dmabuf->mapped) {
2518 spin_lock_irqsave(&state->card->lock, flags);
2519 ali_update_ptr(state);
2521 dmabuf->swptr = dmabuf->hwptr;
2522 dmabuf->count = ali_get_free_write_space(state);
2523 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2524 __ali_update_lvi(state, 2);
2525 spin_unlock_irqrestore(&state->card->lock,
2528 start_spdifout(state);
2530 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)) {
2531 if (!dmabuf->controller_spdifout_channel) {
2533 dmabuf->controller_spdifout_channel = state->card->alloc_controller_spdifout_channel(state->card);
2534 if (!dmabuf->controller_spdifout_channel)
2537 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
2539 if (dmabuf->mapped) {
2540 spin_lock_irqsave(&state->card->lock, flags);
2541 ali_update_ptr(state);
2543 dmabuf->swptr = dmabuf->hwptr;
2544 dmabuf->count = ali_get_free_write_space(state);
2545 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2546 __ali_update_lvi(state, 3);
2547 spin_unlock_irqrestore(&state->card->lock, flags);
2549 start_spdifout(state);
2551 if (val & PCM_ENABLE_INPUT && !(dmabuf->enable & ADC_RUNNING)) {
2552 if (!dmabuf->read_channel) {
2554 dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
2555 if (!dmabuf->read_channel)
2558 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
2560 if (dmabuf->mapped) {
2561 spin_lock_irqsave(&state->card->lock,
2563 ali_update_ptr(state);
2564 dmabuf->swptr = dmabuf->hwptr;
2566 spin_unlock_irqrestore(&state->card->lock, flags);
2568 ali_update_lvi(state, 1);
2572 case SNDCTL_DSP_SETDUPLEX:
2574 printk("SNDCTL_DSP_SETDUPLEX\n");
2577 case SNDCTL_DSP_GETODELAY:
2578 if (!(file->f_mode & FMODE_WRITE))
2580 spin_lock_irqsave(&state->card->lock, flags);
2581 ali_update_ptr(state);
2582 val = dmabuf->count;
2583 spin_unlock_irqrestore(&state->card->lock, flags);
2585 printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
2587 return put_user(val, p);
2588 case SOUND_PCM_READ_RATE:
2590 printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
2592 return put_user(dmabuf->rate, p);
2593 case SOUND_PCM_READ_CHANNELS:
2595 printk("SOUND_PCM_READ_CHANNELS\n");
2597 return put_user(2, p);
2598 case SOUND_PCM_READ_BITS:
2600 printk("SOUND_PCM_READ_BITS\n");
2602 return put_user(AFMT_S16_LE, p);
2603 case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
2605 printk("SNDCTL_DSP_SETSPDIF\n");
2607 if (get_user(val, p))
2609 /* Check to make sure the codec supports S/PDIF transmitter */
2610 if ((state->card->ac97_features & 4)) {
2611 /* mask out the transmitter speed bits so the user can't set them */
2613 /* Add the current transmitter speed bits to the passed value */
2614 ret = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2615 val |= (ret & 0x3000);
2616 ali_ac97_set(codec, AC97_SPDIF_CONTROL, val);
2617 if (ali_ac97_get(codec, AC97_SPDIF_CONTROL) != val) {
2618 printk(KERN_ERR "ali_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
2624 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2626 return put_user(val, p);
2627 case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
2629 printk("SNDCTL_DSP_GETSPDIF\n");
2631 if (get_user(val, p))
2633 /* Check to make sure the codec supports S/PDIF transmitter */
2634 if (!(state->card->ac97_features & 4)) {
2636 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2640 val = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2643 return put_user(val, p);
2644 //end add support spdif out
2645 //add support 4,6 channel
2646 case SNDCTL_DSP_GETCHANNELMASK:
2648 printk("SNDCTL_DSP_GETCHANNELMASK\n");
2650 if (get_user(val, p))
2652 /* Based on AC'97 DAC support, not ICH hardware */
2653 val = DSP_BIND_FRONT;
2654 if (state->card->ac97_features & 0x0004)
2655 val |= DSP_BIND_SPDIF;
2656 if (state->card->ac97_features & 0x0080)
2657 val |= DSP_BIND_SURR;
2658 if (state->card->ac97_features & 0x0140)
2659 val |= DSP_BIND_CENTER_LFE;
2660 return put_user(val, p);
2661 case SNDCTL_DSP_BIND_CHANNEL:
2663 printk("SNDCTL_DSP_BIND_CHANNEL\n");
2665 if (get_user(val, p))
2667 if (val == DSP_BIND_QUERY) {
2668 val = DSP_BIND_FRONT; /* Always report this as being enabled */
2669 if (state->card->ac97_status & SPDIF_ON)
2670 val |= DSP_BIND_SPDIF;
2672 if (state->card->ac97_status & SURR_ON)
2673 val |= DSP_BIND_SURR;
2675 ac97_status & CENTER_LFE_ON)
2676 val |= DSP_BIND_CENTER_LFE;
2678 } else { /* Not a query, set it */
2679 if (!(file->f_mode & FMODE_WRITE))
2681 if (dmabuf->enable == DAC_RUNNING) {
2684 if (val & DSP_BIND_SPDIF) { /* Turn on SPDIF */
2685 /* Ok, this should probably define what slots
2686 * to use. For now, we'll only set it to the
2689 * non multichannel codec maps to slots 3&4
2690 * 2 channel codec maps to slots 7&8
2691 * 4 channel codec maps to slots 6&9
2692 * 6 channel codec maps to slots 10&11
2694 * there should be some way for the app to
2695 * select the slot assignment.
2697 i_scr = inl(state->card->iobase + ALI_SCR);
2698 if (codec_independent_spdif_locked > 0) {
2700 if ((i_scr & 0x00300000) == 0x00100000) {
2701 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2703 if ((i_scr & 0x00300000) == 0x00200000) {
2704 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2706 if ((i_scr & 0x00300000) == 0x00300000) {
2707 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2711 } else { /* codec spdif out (pcm out share ) */
2712 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, dmabuf->rate); //I do not modify
2715 if (!(state->card->ac97_status & SPDIF_ON))
2716 val &= ~DSP_BIND_SPDIF;
2720 /* Turn off S/PDIF if it was on */
2721 if (state->card->ac97_status & SPDIF_ON)
2722 ali_set_spdif_output(state, -1, 0);
2724 val & (DSP_BIND_FRONT | DSP_BIND_SURR |
2725 DSP_BIND_CENTER_LFE);
2727 case DSP_BIND_FRONT:
2730 case DSP_BIND_FRONT | DSP_BIND_SURR:
2733 case DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE:
2737 val = DSP_BIND_FRONT;
2741 ali_set_dac_channels(state, channels);
2742 /* check that they really got turned on */
2743 if (!state->card->ac97_status & SURR_ON)
2744 val &= ~DSP_BIND_SURR;
2746 ac97_status & CENTER_LFE_ON)
2747 val &= ~DSP_BIND_CENTER_LFE;
2750 return put_user(val, p);
2751 case SNDCTL_DSP_MAPINBUF:
2752 case SNDCTL_DSP_MAPOUTBUF:
2753 case SNDCTL_DSP_SETSYNCRO:
2754 case SOUND_PCM_WRITE_FILTER:
2755 case SOUND_PCM_READ_FILTER:
2761 static int ali_open(struct inode *inode, struct file *file)
2764 struct ali_card *card = devs;
2765 struct ali_state *state = NULL;
2766 struct dmabuf *dmabuf = NULL;
2769 /* find an available virtual channel (instance of /dev/dsp) */
2771 while (card != NULL) {
2774 * If we are initializing and then fail, card could go
2775 * away unuexpectedly while we are in the for() loop.
2776 * So, check for card on each iteration before we check
2777 * for card->initializing to avoid a possible oops.
2778 * This usually only matters for times when the driver is
2779 * autoloaded by kmod.
2781 for (i = 0; i < 50 && card && card->initializing; i++) {
2782 set_current_state(TASK_UNINTERRUPTIBLE);
2783 schedule_timeout(HZ / 20);
2786 for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
2787 if (card->states[i] == NULL) {
2788 state = card->states[i] = (struct ali_state *) kmalloc(sizeof(struct ali_state), GFP_KERNEL);
2791 memset(state, 0, sizeof(struct ali_state));
2792 dmabuf = &state->dmabuf;
2799 /* no more virtual channel avaiable */
2803 /* initialize the virtual channel */
2807 state->magic = ALI5455_STATE_MAGIC;
2808 init_waitqueue_head(&dmabuf->wait);
2809 init_MUTEX(&state->open_sem);
2810 file->private_data = state;
2811 dmabuf->trigger = 0;
2812 /* allocate hardware channels */
2813 if (file->f_mode & FMODE_READ) {
2814 if ((dmabuf->read_channel =
2815 card->alloc_rec_pcm_channel(card)) == NULL) {
2816 kfree(card->states[i]);
2817 card->states[i] = NULL;
2820 dmabuf->trigger |= PCM_ENABLE_INPUT;
2821 ali_set_adc_rate(state, 8000);
2823 if (file->f_mode & FMODE_WRITE) {
2824 if (codec_independent_spdif_locked > 0) {
2825 if ((dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card)) == NULL) {
2826 kfree(card->states[i]);
2827 card->states[i] = NULL;
2830 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2831 ali_set_codecspdifout_rate(state, codec_independent_spdif_locked); //It must add
2832 i_scr = inl(state->card->iobase + ALI_SCR);
2833 if ((i_scr & 0x00300000) == 0x00100000) {
2834 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2836 if ((i_scr & 0x00300000) == 0x00200000) {
2837 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2839 if ((i_scr & 0x00300000) == 0x00300000) {
2840 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2842 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2848 if (controller_independent_spdif_locked > 0) {
2849 if ((dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card)) == NULL) {
2850 kfree(card->states[i]);
2851 card->states[i] = NULL;
2854 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2855 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2857 if ((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
2858 kfree(card->states[i]);
2859 card->states[i] = NULL;
2862 /* Initialize to 8kHz? What if we don't support 8kHz? */
2863 /* Let's change this to check for S/PDIF stuff */
2865 dmabuf->trigger |= PCM_ENABLE_OUTPUT;
2866 if (codec_pcmout_share_spdif_locked) {
2867 ali_set_dac_rate(state, codec_pcmout_share_spdif_locked);
2868 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, codec_pcmout_share_spdif_locked);
2870 ali_set_dac_rate(state, 8000);
2877 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
2878 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2879 /dev/dspW will accept 16-bits sample, but we don't support those so we
2880 set it immediately to stereo and 16bit, which is all we do support */
2881 dmabuf->fmt |= ALI5455_FMT_16BIT | ALI5455_FMT_STEREO;
2882 dmabuf->ossfragsize = 0;
2883 dmabuf->ossmaxfrags = 0;
2884 dmabuf->subdivision = 0;
2885 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2886 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
2887 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
2888 return nonseekable_open(inode, file);
2891 static int ali_release(struct inode *inode, struct file *file)
2893 struct ali_state *state = (struct ali_state *) file->private_data;
2894 struct ali_card *card = state->card;
2895 struct dmabuf *dmabuf = &state->dmabuf;
2896 unsigned long flags;
2899 /* stop DMA state machine and free DMA buffers/channels */
2900 if (dmabuf->trigger & PCM_ENABLE_OUTPUT)
2901 drain_dac(state, 0);
2903 if (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)
2904 drain_spdifout(state, 0);
2906 if (dmabuf->trigger & PCM_ENABLE_INPUT)
2909 spin_lock_irqsave(&card->lock, flags);
2910 dealloc_dmabuf(state);
2911 if (file->f_mode & FMODE_WRITE) {
2912 if (codec_independent_spdif_locked > 0) {
2913 state->card->free_pcm_channel(state->card, dmabuf->codec_spdifout_channel->num);
2915 if (controller_independent_spdif_locked > 0)
2916 state->card->free_pcm_channel(state->card,
2917 dmabuf->controller_spdifout_channel->num);
2918 else state->card->free_pcm_channel(state->card,
2919 dmabuf->write_channel->num);
2922 if (file->f_mode & FMODE_READ)
2923 state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
2925 state->card->states[state->virt] = NULL;
2927 spin_unlock_irqrestore(&card->lock, flags);
2932 static /*const */ struct file_operations ali_audio_fops = {
2933 .owner = THIS_MODULE,
2934 .llseek = no_llseek,
2941 .release = ali_release,
2944 /* Read AC97 codec registers */
2945 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg)
2947 struct ali_card *card = dev->private_data;
2950 unsigned short int data = 0, count, addr1, addr2 = 0;
2952 spin_lock(&card->ac97_lock);
2953 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2958 for (count = 0; count < 0x7f; count++) {
2959 val = inb(card->iobase + ALI_CSPSR);
2965 spin_unlock(&card->ac97_lock);
2968 outw(reg, (card->iobase + ALI_CPR) + 2);
2969 for (count = 0; count < 0x7f; count++) {
2970 val = inb(card->iobase + ALI_CSPSR);
2972 data = inw(card->iobase + ALI_SPR);
2973 addr2 = inw((card->iobase + ALI_SPR) + 2);
2977 spin_unlock(&card->ac97_lock);
2982 return ((u16) data);
2985 /* write ac97 codec register */
2987 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
2989 struct ali_card *card = dev->private_data;
2992 unsigned short int count;
2994 spin_lock(&card->ac97_lock);
2995 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2998 for (count = 0; count < 0x7f; count++) {
2999 val = inb(card->iobase + ALI_CSPSR);
3003 if (count == 0x7f) {
3004 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3005 spin_unlock(&card->ac97_lock);
3008 outw(data, (card->iobase + ALI_CPR));
3009 outb(reg, (card->iobase + ALI_CPR) + 2);
3010 for (count = 0; count < 0x7f; count++) {
3011 val = inb(card->iobase + ALI_CSPSR);
3015 spin_unlock(&card->ac97_lock);
3017 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3021 /* OSS /dev/mixer file operation methods */
3023 static int ali_open_mixdev(struct inode *inode, struct file *file)
3026 int minor = iminor(inode);
3027 struct ali_card *card = devs;
3028 for (card = devs; card != NULL; card = card->next) {
3030 * If we are initializing and then fail, card could go
3031 * away unuexpectedly while we are in the for() loop.
3032 * So, check for card on each iteration before we check
3033 * for card->initializing to avoid a possible oops.
3034 * This usually only matters for times when the driver is
3035 * autoloaded by kmod.
3037 for (i = 0; i < 50 && card && card->initializing; i++) {
3038 set_current_state(TASK_UNINTERRUPTIBLE);
3039 schedule_timeout(HZ / 20);
3041 for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
3042 if (card->ac97_codec[i] != NULL
3043 && card->ac97_codec[i]->dev_mixer == minor) {
3044 file->private_data = card->ac97_codec[i];
3045 return nonseekable_open(inode, file);
3051 static int ali_ioctl_mixdev(struct inode *inode,
3053 unsigned int cmd, unsigned long arg)
3055 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
3056 return codec->mixer_ioctl(codec, cmd, arg);
3059 static /*const */ struct file_operations ali_mixer_fops = {
3060 .owner = THIS_MODULE,
3061 .llseek = no_llseek,
3062 .ioctl = ali_ioctl_mixdev,
3063 .open = ali_open_mixdev,
3066 /* AC97 codec initialisation. These small functions exist so we don't
3067 duplicate code between module init and apm resume */
3069 static inline int ali_ac97_exists(struct ali_card *card, int ac97_number)
3072 u32 reg = inl(card->iobase + ALI_RTSR);
3076 reg = inl(card->iobase + ALI_RTSR);
3080 outl(reg | 0x00000040,
3081 card->iobase + 0x34);
3089 reg = inl(card->iobase + ALI_RTSR);
3093 outl(reg | 0x00000080,
3094 card->iobase + 0x34);
3107 static inline int ali_ac97_enable_variable_rate(struct ac97_codec *codec)
3109 ali_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
3110 ali_ac97_set(codec, AC97_EXTENDED_STATUS, ali_ac97_get(codec, AC97_EXTENDED_STATUS) | 0xE800);
3111 return (ali_ac97_get(codec, AC97_EXTENDED_STATUS) & 1);
3115 static int ali_ac97_probe_and_powerup(struct ali_card *card, struct ac97_codec *codec)
3117 /* Returns 0 on failure */
3120 if (ac97_probe_codec(codec) == 0)
3122 /* ac97_probe_codec is success ,then begin to init codec */
3123 ali_ac97_set(codec, AC97_RESET, 0xffff);
3124 if (card->channel[0].used == 1) {
3125 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3126 ali_ac97_set(codec, AC97_LINEIN_VOL, 0x0808);
3127 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3130 if (card->channel[2].used == 1) //if MICin then init codec
3132 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3133 ali_ac97_set(codec, AC97_MIC_VOL, 0x8808);
3134 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3135 ali_ac97_set(codec, AC97_RECORD_GAIN_MIC, 0x0000);
3138 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO, 0x0000);
3139 ali_ac97_set(codec, AC97_HEADPHONE_VOL, 0x0000);
3140 ali_ac97_set(codec, AC97_PCMOUT_VOL, 0x0000);
3141 ali_ac97_set(codec, AC97_CD_VOL, 0x0808);
3142 ali_ac97_set(codec, AC97_VIDEO_VOL, 0x0808);
3143 ali_ac97_set(codec, AC97_AUX_VOL, 0x0808);
3144 ali_ac97_set(codec, AC97_PHONE_VOL, 0x8048);
3145 ali_ac97_set(codec, AC97_PCBEEP_VOL, 0x0000);
3146 ali_ac97_set(codec, AC97_GENERAL_PURPOSE, AC97_GP_MIX);
3147 ali_ac97_set(codec, AC97_MASTER_VOL_MONO, 0x0000);
3148 ali_ac97_set(codec, 0x38, 0x0000);
3149 addr = ali_ac97_get(codec, 0x2a);
3150 ali_ac97_set(codec, 0x2a, addr | 0x0001);
3151 addr = ali_ac97_get(codec, 0x2a);
3152 addr = ali_ac97_get(codec, 0x28);
3153 ali_ac97_set(codec, 0x2c, 0xbb80);
3154 addr = ali_ac97_get(codec, 0x2c);
3155 /* power it all up */
3156 ali_ac97_set(codec, AC97_POWER_CONTROL,
3157 ali_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
3158 /* wait for analog ready */
3159 for (i = 10; i && ((ali_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--) {
3160 set_current_state(TASK_UNINTERRUPTIBLE);
3161 schedule_timeout(HZ / 20);
3169 /* I clone ali5455(2.4.7 ) not clone i810_audio(2.4.18) */
3171 static int ali_reset_5455(struct ali_card *card)
3173 outl(0x80000003, card->iobase + ALI_SCR);
3174 outl(0x83838383, card->iobase + ALI_FIFOCR1);
3175 outl(0x83838383, card->iobase + ALI_FIFOCR2);
3176 if (controller_pcmout_share_spdif_locked > 0) {
3177 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3178 card->iobase + ALI_SPDIFICS);
3179 outl(0x0408000a, card->iobase + ALI_INTERFACECR);
3181 if (codec_independent_spdif_locked > 0) {
3182 outl((inl(card->iobase + ALI_SCR) | 0x00100000), card->iobase + ALI_SCR); // now I select slot 7 & 8
3183 outl(0x00200000, card->iobase + ALI_INTERFACECR); //enable codec independent spdifout
3185 outl(0x04080002, card->iobase + ALI_INTERFACECR);
3188 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
3189 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
3190 if (controller_independent_spdif_locked > 0)
3191 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3192 card->iobase + ALI_SPDIFICS);
3197 static int ali_ac97_random_init_stuff(struct ali_card
3200 u32 reg = inl(card->iobase + ALI_SCR);
3202 reg = inl(card->iobase + ALI_SCR);
3203 if ((reg & 2) == 0) /* Cold required */
3206 reg |= 1; /* Warm */
3207 reg &= ~0x80000000; /* ACLink on */
3208 outl(reg, card->iobase + ALI_SCR);
3211 if ((inl(card->iobase + 0x18) & (1 << 1)) == 0)
3213 current->state = TASK_UNINTERRUPTIBLE;
3214 schedule_timeout(HZ / 20);
3218 printk(KERN_ERR "ali_audio: AC'97 reset failed.\n");
3222 set_current_state(TASK_UNINTERRUPTIBLE);
3223 schedule_timeout(HZ / 2);
3227 /* AC97 codec initialisation. */
3229 static int __devinit ali_ac97_init(struct ali_card *card)
3232 int total_channels = 0;
3233 struct ac97_codec *codec;
3236 if (!ali_ac97_random_init_stuff(card))
3239 /* Number of channels supported */
3240 /* What about the codec? Just because the ICH supports */
3241 /* multiple channels doesn't mean the codec does. */
3242 /* we'll have to modify this in the codec section below */
3243 /* to reflect what the codec has. */
3244 /* ICH and ICH0 only support 2 channels so don't bother */
3246 inl(card->iobase + ALI_CPR);
3249 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3251 /* Assume codec isn't available until we go through the
3253 card->ac97_codec[num_ac97] = NULL;
3254 /* The ICH programmer's reference says you should */
3255 /* check the ready status before probing. So we chk */
3256 /* What do we do if it's not ready? Wait and try */
3257 /* again, or abort? */
3258 if (!ali_ac97_exists(card, num_ac97)) {
3260 printk(KERN_ERR "ali_audio: Primary codec not ready.\n");
3264 if ((codec = ac97_alloc_codec()) == NULL)
3266 /* initialize some basic codec information, other fields will be filled
3267 in ac97_probe_codec */
3268 codec->private_data = card;
3269 codec->id = num_ac97;
3270 codec->codec_read = ali_ac97_get;
3271 codec->codec_write = ali_ac97_set;
3272 if (!ali_ac97_probe_and_powerup(card, codec)) {
3273 printk(KERN_ERR "ali_audio: timed out waiting for codec %d analog ready",
3276 break; /* it didn't work */
3279 /* Store state information about S/PDIF transmitter */
3280 card->ac97_status = 0;
3281 /* Don't attempt to get eid until powerup is complete */
3282 eid = ali_ac97_get(codec, AC97_EXTENDED_ID);
3283 if (eid == 0xFFFF) {
3284 printk(KERN_ERR "ali_audio: no codec attached ?\n");
3289 card->ac97_features = eid;
3290 /* Now check the codec for useful features to make up for
3291 the dumbness of the ali5455 hardware engine */
3292 if (!(eid & 0x0001))
3294 "ali_audio: only 48Khz playback available.\n");
3296 if (!ali_ac97_enable_variable_rate(codec)) {
3298 "ali_audio: Codec refused to allow VRA, using 48Khz only.\n");
3299 card->ac97_features &= ~1;
3303 /* Determine how many channels the codec(s) support */
3304 /* - The primary codec always supports 2 */
3305 /* - If the codec supports AMAP, surround DACs will */
3306 /* automaticlly get assigned to slots. */
3307 /* * Check for surround DACs and increment if */
3309 /* - Else check if the codec is revision 2.2 */
3310 /* * If surround DACs exist, assign them to slots */
3311 /* and increment channel count. */
3313 /* All of this only applies to ICH2 and above. ICH */
3314 /* and ICH0 only support 2 channels. ICH2 will only */
3315 /* support multiple codecs in a "split audio" config. */
3316 /* as described above. */
3318 /* TODO: Remove all the debugging messages! */
3320 if ((eid & 0xc000) == 0) /* primary codec */
3321 total_channels += 2;
3322 if ((codec->dev_mixer = register_sound_mixer(&ali_mixer_fops, -1)) < 0) {
3323 printk(KERN_ERR "ali_audio: couldn't register mixer!\n");
3327 card->ac97_codec[num_ac97] = codec;
3329 /* pick the minimum of channels supported by ICHx or codec(s) */
3330 card->channels = (card->channels > total_channels) ? total_channels : card->channels;
3334 static void __devinit ali_configure_clocking(void)
3336 struct ali_card *card;
3337 struct ali_state *state;
3338 struct dmabuf *dmabuf;
3339 unsigned int i, offset, new_offset;
3340 unsigned long flags;
3343 /* We could try to set the clocking for multiple cards, but can you even have
3344 * more than one ali in a machine? Besides, clocking is global, so unless
3345 * someone actually thinks more than one ali in a machine is possible and
3346 * decides to rewrite that little bit, setting the rate for more than one card
3347 * is a waste of time.
3350 state = card->states[0] = (struct ali_state *)
3351 kmalloc(sizeof(struct ali_state), GFP_KERNEL);
3354 memset(state, 0, sizeof(struct ali_state));
3355 dmabuf = &state->dmabuf;
3356 dmabuf->write_channel = card->alloc_pcm_channel(card);
3359 state->magic = ALI5455_STATE_MAGIC;
3360 init_waitqueue_head(&dmabuf->wait);
3361 init_MUTEX(&state->open_sem);
3362 dmabuf->fmt = ALI5455_FMT_STEREO | ALI5455_FMT_16BIT;
3363 dmabuf->trigger = PCM_ENABLE_OUTPUT;
3364 ali_set_dac_rate(state, 48000);
3365 if (prog_dmabuf(state, 0) != 0)
3366 goto config_out_nodmabuf;
3368 if (dmabuf->dmasize < 16384)
3371 dmabuf->count = dmabuf->dmasize;
3372 outb(31, card->iobase + dmabuf->write_channel->port + OFF_LVI);
3374 local_irq_save(flags);
3376 offset = ali_get_dma_addr(state, 0);
3378 new_offset = ali_get_dma_addr(state, 0);
3381 outb(2, card->iobase + dmabuf->write_channel->port + OFF_CR);
3382 local_irq_restore(flags);
3384 i = new_offset - offset;
3389 if (i > 48500 || i < 47500) {
3390 clocking = clocking * clocking / i;
3393 dealloc_dmabuf(state);
3394 config_out_nodmabuf:
3395 state->card->free_pcm_channel(state->card, state->dmabuf. write_channel->num);
3397 card->states[0] = NULL;
3401 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3402 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3404 static int __devinit ali_probe(struct pci_dev *pci_dev,
3405 const struct pci_device_id *pci_id)
3407 struct ali_card *card;
3408 if (pci_enable_device(pci_dev))
3410 if (pci_set_dma_mask(pci_dev, ALI5455_DMA_MASK)) {
3411 printk(KERN_ERR "ali5455: architecture does not support"
3412 " 32bit PCI busmaster DMA\n");
3416 if ((card = kmalloc(sizeof(struct ali_card), GFP_KERNEL)) == NULL) {
3417 printk(KERN_ERR "ali_audio: out of memory\n");
3420 memset(card, 0, sizeof(*card));
3421 card->initializing = 1;
3422 card->iobase = pci_resource_start(pci_dev, 0);
3423 card->pci_dev = pci_dev;
3424 card->pci_id = pci_id->device;
3425 card->irq = pci_dev->irq;
3427 card->magic = ALI5455_CARD_MAGIC;
3429 card->pm_suspended = 0;
3431 spin_lock_init(&card->lock);
3432 spin_lock_init(&card->ac97_lock);
3434 pci_set_master(pci_dev);
3435 printk(KERN_INFO "ali: %s found at IO 0x%04lx, IRQ %d\n",
3436 card_names[pci_id->driver_data], card->iobase, card->irq);
3437 card->alloc_pcm_channel = ali_alloc_pcm_channel;
3438 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
3439 card->alloc_rec_mic_channel = ali_alloc_rec_mic_channel;
3440 card->alloc_codec_spdifout_channel = ali_alloc_codec_spdifout_channel;
3441 card->alloc_controller_spdifout_channel = ali_alloc_controller_spdifout_channel;
3442 card->free_pcm_channel = ali_free_pcm_channel;
3443 card->channel[0].offset = 0;
3444 card->channel[0].port = 0x40;
3445 card->channel[0].num = 0;
3446 card->channel[1].offset = 0;
3447 card->channel[1].port = 0x50;
3448 card->channel[1].num = 1;
3449 card->channel[2].offset = 0;
3450 card->channel[2].port = 0x60;
3451 card->channel[2].num = 2;
3452 card->channel[3].offset = 0;
3453 card->channel[3].port = 0x70;
3454 card->channel[3].num = 3;
3455 card->channel[4].offset = 0;
3456 card->channel[4].port = 0xb0;
3457 card->channel[4].num = 4;
3458 /* claim our iospace and irq */
3459 request_region(card->iobase, 256, card_names[pci_id->driver_data]);
3460 if (request_irq(card->irq, &ali_interrupt, SA_SHIRQ,
3461 card_names[pci_id->driver_data], card)) {
3462 printk(KERN_ERR "ali_audio: unable to allocate irq %d\n",
3464 release_region(card->iobase, 256);
3469 if (ali_reset_5455(card) <= 0) {
3470 unregister_sound_dsp(card->dev_audio);
3471 release_region(card->iobase, 256);
3472 free_irq(card->irq, card);
3477 /* initialize AC97 codec and register /dev/mixer */
3478 if (ali_ac97_init(card) < 0) {
3479 release_region(card->iobase, 256);
3480 free_irq(card->irq, card);
3485 pci_set_drvdata(pci_dev, card);
3487 if (clocking == 0) {
3489 ali_configure_clocking();
3492 /* register /dev/dsp */
3493 if ((card->dev_audio = register_sound_dsp(&ali_audio_fops, -1)) < 0) {
3495 printk(KERN_ERR"ali_audio: couldn't register DSP device!\n");
3496 release_region(card->iobase, 256);
3497 free_irq(card->irq, card);
3498 for (i = 0; i < NR_AC97; i++)
3499 if (card->ac97_codec[i] != NULL) {
3500 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3501 kfree(card->ac97_codec[i]);
3506 card->initializing = 0;
3510 static void __devexit ali_remove(struct pci_dev *pci_dev)
3513 struct ali_card *card = pci_get_drvdata(pci_dev);
3514 /* free hardware resources */
3515 free_irq(card->irq, devs);
3516 release_region(card->iobase, 256);
3517 /* unregister audio devices */
3518 for (i = 0; i < NR_AC97; i++)
3519 if (card->ac97_codec[i] != NULL) {
3520 unregister_sound_mixer(card->ac97_codec[i]->
3522 ac97_release_codec(card->ac97_codec[i]);
3523 card->ac97_codec[i] = NULL;
3525 unregister_sound_dsp(card->dev_audio);
3530 static int ali_pm_suspend(struct pci_dev *dev, u32 pm_state)
3532 struct ali_card *card = pci_get_drvdata(dev);
3533 struct ali_state *state;
3534 unsigned long flags;
3535 struct dmabuf *dmabuf;
3540 spin_lock_irqsave(&card->lock, flags);
3541 card->pm_suspended = 1;
3542 for (i = 0; i < NR_HW_CH; i++) {
3543 state = card->states[i];
3546 /* this happens only if there are open files */
3547 dmabuf = &state->dmabuf;
3548 if (dmabuf->enable & DAC_RUNNING ||
3550 && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
3551 state->pm_saved_dac_rate = dmabuf->rate;
3554 state->pm_saved_dac_rate = 0;
3556 if (dmabuf->enable & ADC_RUNNING) {
3557 state->pm_saved_adc_rate = dmabuf->rate;
3560 state->pm_saved_adc_rate = 0;
3563 dmabuf->swptr = dmabuf->hwptr = 0;
3564 dmabuf->count = dmabuf->total_bytes = 0;
3567 spin_unlock_irqrestore(&card->lock, flags);
3568 /* save mixer settings */
3569 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3570 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3573 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3574 if ((supported_mixer(codec, i)) && (codec->read_mixer)) {
3575 card->pm_saved_mixer_settings[i][num_ac97] = codec->read_mixer(codec, i);
3579 pci_save_state(dev, card->pm_save_state); /* XXX do we need this? */
3580 pci_disable_device(dev); /* disable busmastering */
3581 pci_set_power_state(dev, 3); /* Zzz. */
3586 static int ali_pm_resume(struct pci_dev *dev)
3588 int num_ac97, i = 0;
3589 struct ali_card *card = pci_get_drvdata(dev);
3590 pci_enable_device(dev);
3591 pci_restore_state(dev, card->pm_save_state);
3592 /* observation of a toshiba portege 3440ct suggests that the
3593 hardware has to be more or less completely reinitialized from
3594 scratch after an apm suspend. Works For Me. -dan */
3595 ali_ac97_random_init_stuff(card);
3596 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3597 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3598 /* check they haven't stolen the hardware while we were
3600 if (!codec || !ali_ac97_exists(card, num_ac97)) {
3606 if (!ali_ac97_probe_and_powerup(card, codec))
3608 if ((card->ac97_features & 0x0001)) {
3609 /* at probe time we found we could do variable
3610 rates, but APM suspend has made it forget
3611 its magical powers */
3612 if (!ali_ac97_enable_variable_rate(codec))
3615 /* we lost our mixer settings, so restore them */
3616 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3617 if (supported_mixer(codec, i)) {
3618 int val = card->pm_saved_mixer_settings[i][num_ac97];
3619 codec->mixer_state[i] = val;
3620 codec->write_mixer(codec, i,
3622 ((val >> 8) & 0xff));
3627 /* we need to restore the sample rate from whatever it was */
3628 for (i = 0; i < NR_HW_CH; i++) {
3629 struct ali_state *state = card->states[i];
3631 if (state->pm_saved_adc_rate)
3632 ali_set_adc_rate(state, state->pm_saved_adc_rate);
3633 if (state->pm_saved_dac_rate)
3634 ali_set_dac_rate(state, state->pm_saved_dac_rate);
3638 card->pm_suspended = 0;
3639 /* any processes that were reading/writing during the suspend
3640 probably ended up here */
3641 for (i = 0; i < NR_HW_CH; i++) {
3642 struct ali_state *state = card->states[i];
3644 wake_up(&state->dmabuf.wait);
3648 #endif /* CONFIG_PM */
3651 MODULE_DESCRIPTION("ALI 5455 audio support");
3652 MODULE_LICENSE("GPL");
3653 MODULE_PARM(clocking, "i");
3654 MODULE_PARM(strict_clocking, "i");
3655 MODULE_PARM(codec_pcmout_share_spdif_locked, "i");
3656 MODULE_PARM(codec_independent_spdif_locked, "i");
3657 MODULE_PARM(controller_pcmout_share_spdif_locked, "i");
3658 MODULE_PARM(controller_independent_spdif_locked, "i");
3659 #define ALI5455_MODULE_NAME "ali5455"
3660 static struct pci_driver ali_pci_driver = {
3661 .name = ALI5455_MODULE_NAME,
3662 .id_table = ali_pci_tbl,
3664 .remove = __devexit_p(ali_remove),
3666 .suspend = ali_pm_suspend,
3667 .resume = ali_pm_resume,
3668 #endif /* CONFIG_PM */
3671 static int __init ali_init_module(void)
3673 printk(KERN_INFO "ALI 5455 + AC97 Audio, version "
3674 DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
3676 if (codec_independent_spdif_locked > 0) {
3677 if (codec_independent_spdif_locked == 32000
3678 || codec_independent_spdif_locked == 44100
3679 || codec_independent_spdif_locked == 48000) {
3680 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_independent_spdif_locked);
3682 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3683 codec_independent_spdif_locked = 0;
3686 if (controller_independent_spdif_locked > 0) {
3687 if (controller_independent_spdif_locked == 32000
3688 || controller_independent_spdif_locked == 44100
3689 || controller_independent_spdif_locked == 48000) {
3690 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", controller_independent_spdif_locked);
3692 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3693 controller_independent_spdif_locked = 0;
3697 if (codec_pcmout_share_spdif_locked > 0) {
3698 if (codec_pcmout_share_spdif_locked == 32000
3699 || codec_pcmout_share_spdif_locked == 44100
3700 || codec_pcmout_share_spdif_locked == 48000) {
3701 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_pcmout_share_spdif_locked);
3703 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3704 codec_pcmout_share_spdif_locked = 0;
3707 if (controller_pcmout_share_spdif_locked > 0) {
3708 if (controller_pcmout_share_spdif_locked == 32000
3709 || controller_pcmout_share_spdif_locked == 44100
3710 || controller_pcmout_share_spdif_locked == 48000) {
3711 printk(KERN_INFO "ali_audio: Enabling controller S/PDIF at sample rate %dHz.\n", controller_pcmout_share_spdif_locked);
3713 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3714 controller_pcmout_share_spdif_locked = 0;
3717 if (!pci_register_driver(&ali_pci_driver)) {
3718 pci_unregister_driver(&ali_pci_driver);
3724 static void __exit ali_cleanup_module(void)
3726 pci_unregister_driver(&ali_pci_driver);
3729 module_init(ali_init_module);
3730 module_exit(ali_cleanup_module);