?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Move valid_dma_direction() from x86_64 to generic code
[usb.git] / sound / oss / ali5455.c
blob70dcd703a66fc18436af8fd03af52854e29e0b9f
1 /*
2 * ALI ali5455 and friends ICH driver for Linux
3 * LEI HU <Lei_Hu@ali.com.tw>
4 *
5 * Built from:
6 * drivers/sound/i810_audio
7 *
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
10 * the i810 driver.
11 *
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.
16 *
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.
21 *
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.
25 *
26 *
27 * ALi 5455 theory of operation
28 *
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.
36 *
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.
40 *
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.
44 *
45 * If you need to force a specific rate set the clocking= option
46 *
47 */
48
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>
59 #include <asm/io.h>
60 #include <asm/dma.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 <linux/mutex.h>
68
69 #include <asm/uaccess.h>
70
71 #ifndef PCI_DEVICE_ID_ALI_5455
72 #define PCI_DEVICE_ID_ALI_5455 0x5455
73 #endif
74
75 #ifndef PCI_VENDOR_ID_ALI
76 #define PCI_VENDOR_ID_ALI 0x10b9
77 #endif
78
79 static int strict_clocking = 0;
80 static unsigned int clocking = 0;
81 static unsigned int codec_pcmout_share_spdif_locked = 0;
82 static unsigned int codec_independent_spdif_locked = 0;
83 static unsigned int controller_pcmout_share_spdif_locked = 0;
84 static unsigned int controller_independent_spdif_locked = 0;
85 static unsigned int globel = 0;
86
87 #define ADC_RUNNING 1
88 #define DAC_RUNNING 2
89 #define CODEC_SPDIFOUT_RUNNING 8
90 #define CONTROLLER_SPDIFOUT_RUNNING 4
91
92 #define SPDIF_ENABLE_OUTPUT 4 /* bits 0,1 are PCM */
93
94 #define ALI5455_FMT_16BIT 1
95 #define ALI5455_FMT_STEREO 2
96 #define ALI5455_FMT_MASK 3
97
98 #define SPDIF_ON 0x0004
99 #define SURR_ON 0x0010
100 #define CENTER_LFE_ON 0x0020
101 #define VOL_MUTED 0x8000
102
103
104 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
105 /* the 810's array of pointers to data buffers */
106
107 struct sg_item {
108 #define BUSADDR_MASK 0xFFFFFFFE
109 u32 busaddr;
110 #define CON_IOC 0x80000000 /* interrupt on completion */
111 #define CON_BUFPAD 0x40000000 /* pad underrun with last sample, else 0 */
112 #define CON_BUFLEN_MASK 0x0000ffff /* buffer length in samples */
113 u32 control;
114 };
115
116 /* an instance of the ali channel */
117 #define SG_LEN 32
118 struct ali_channel {
119 /* these sg guys should probably be allocated
120 separately as nocache. Must be 8 byte aligned */
121 struct sg_item sg[SG_LEN]; /* 32*8 */
122 u32 offset; /* 4 */
123 u32 port; /* 4 */
124 u32 used;
125 u32 num;
126 };
127
128 /*
129 * we have 3 separate dma engines. pcm in, pcm out, and mic.
130 * each dma engine has controlling registers. These goofy
131 * names are from the datasheet, but make it easy to write
132 * code while leafing through it.
133 */
134
135 #define ENUM_ENGINE(PRE,DIG) \
136 enum { \
137 PRE##_BDBAR = 0x##DIG##0, /* Buffer Descriptor list Base Address */ \
138 PRE##_CIV = 0x##DIG##4, /* Current Index Value */ \
139 PRE##_LVI = 0x##DIG##5, /* Last Valid Index */ \
140 PRE##_SR = 0x##DIG##6, /* Status Register */ \
141 PRE##_PICB = 0x##DIG##8, /* Position In Current Buffer */ \
142 PRE##_CR = 0x##DIG##b /* Control Register */ \
143 }
144
145 ENUM_ENGINE(OFF, 0); /* Offsets */
146 ENUM_ENGINE(PI, 4); /* PCM In */
147 ENUM_ENGINE(PO, 5); /* PCM Out */
148 ENUM_ENGINE(MC, 6); /* Mic In */
149 ENUM_ENGINE(CODECSPDIFOUT, 7); /* CODEC SPDIF OUT */
150 ENUM_ENGINE(CONTROLLERSPDIFIN, A); /* CONTROLLER SPDIF In */
151 ENUM_ENGINE(CONTROLLERSPDIFOUT, B); /* CONTROLLER SPDIF OUT */
152
153
154 enum {
155 ALI_SCR = 0x00, /* System Control Register */
156 ALI_SSR = 0x04, /* System Status Register */
157 ALI_DMACR = 0x08, /* DMA Control Register */
158 ALI_FIFOCR1 = 0x0c, /* FIFO Control Register 1 */
159 ALI_INTERFACECR = 0x10, /* Interface Control Register */
160 ALI_INTERRUPTCR = 0x14, /* Interrupt control Register */
161 ALI_INTERRUPTSR = 0x18, /* Interrupt Status Register */
162 ALI_FIFOCR2 = 0x1c, /* FIFO Control Register 2 */
163 ALI_CPR = 0x20, /* Command Port Register */
164 ALI_SPR = 0x24, /* Status Port Register */
165 ALI_FIFOCR3 = 0x2c, /* FIFO Control Register 3 */
166 ALI_TTSR = 0x30, /* Transmit Tag Slot Register */
167 ALI_RTSR = 0x34, /* Receive Tag Slot Register */
168 ALI_CSPSR = 0x38, /* Command/Status Port Status Register */
169 ALI_CAS = 0x3c, /* Codec Write Semaphore Register */
170 ALI_SPDIFCSR = 0xf8, /* spdif channel status register */
171 ALI_SPDIFICS = 0xfc /* spdif interface control/status */
172 };
173
174 // x-status register(x:pcm in ,pcm out, mic in,)
175 /* interrupts for a dma engine */
176 #define DMA_INT_FIFO (1<<4) /* fifo under/over flow */
177 #define DMA_INT_COMPLETE (1<<3) /* buffer read/write complete and ioc set */
178 #define DMA_INT_LVI (1<<2) /* last valid done */
179 #define DMA_INT_CELV (1<<1) /* last valid is current */
180 #define DMA_INT_DCH (1) /* DMA Controller Halted (happens on LVI interrupts) */ //not eqult intel
181 #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
182
183 /* interrupts for the whole chip */// by interrupt status register finish
184
185 #define INT_SPDIFOUT (1<<23) /* controller spdif out INTERRUPT */
186 #define INT_SPDIFIN (1<<22)
187 #define INT_CODECSPDIFOUT (1<<19)
188 #define INT_MICIN (1<<18)
189 #define INT_PCMOUT (1<<17)
190 #define INT_PCMIN (1<<16)
191 #define INT_CPRAIS (1<<7)
192 #define INT_SPRAIS (1<<5)
193 #define INT_GPIO (1<<1)
194 #define INT_MASK (INT_SPDIFOUT|INT_CODECSPDIFOUT|INT_MICIN|INT_PCMOUT|INT_PCMIN)
195
196 #define DRIVER_VERSION "0.02ac"
197
198 /* magic numbers to protect our data structures */
199 #define ALI5455_CARD_MAGIC 0x5072696E /* "Prin" */
200 #define ALI5455_STATE_MAGIC 0x63657373 /* "cess" */
201 #define ALI5455_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
202 #define NR_HW_CH 5 //I think 5 channel
203
204 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
205 #define NR_AC97 2
206
207 /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
208 /* stream at a minimum for this card to be happy */
209 static const unsigned sample_size[] = { 1, 2, 2, 4 };
210 /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
211 /* values are one less than might be expected */
212 static const unsigned sample_shift[] = { -1, 0, 0, 1 };
213
214 #define ALI5455
215 static char *card_names[] = {
216 "ALI 5455"
217 };
218
219 static struct pci_device_id ali_pci_tbl[] = {
220 {PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5455,
221 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ALI5455},
222 {0,}
223 };
224
225 MODULE_DEVICE_TABLE(pci, ali_pci_tbl);
226
227 #ifdef CONFIG_PM
228 #define PM_SUSPENDED(card) (card->pm_suspended)
229 #else
230 #define PM_SUSPENDED(card) (0)
231 #endif
232
233 /* "software" or virtual channel, an instance of opened /dev/dsp */
234 struct ali_state {
235 unsigned int magic;
236 struct ali_card *card; /* Card info */
237
238 /* single open lock mechanism, only used for recording */
239 struct mutex open_mutex;
240 wait_queue_head_t open_wait;
241
242 /* file mode */
243 mode_t open_mode;
244
245 /* virtual channel number */
246 int virt;
247
248 #ifdef CONFIG_PM
249 unsigned int pm_saved_dac_rate, pm_saved_adc_rate;
250 #endif
251 struct dmabuf {
252 /* wave sample stuff */
253 unsigned int rate;
254 unsigned char fmt, enable, trigger;
255
256 /* hardware channel */
257 struct ali_channel *read_channel;
258 struct ali_channel *write_channel;
259 struct ali_channel *codec_spdifout_channel;
260 struct ali_channel *controller_spdifout_channel;
261
262 /* OSS buffer management stuff */
263 void *rawbuf;
264 dma_addr_t dma_handle;
265 unsigned buforder;
266 unsigned numfrag;
267 unsigned fragshift;
268
269 /* our buffer acts like a circular ring */
270 unsigned hwptr; /* where dma last started, updated by update_ptr */
271 unsigned swptr; /* where driver last clear/filled, updated by read/write */
272 int count; /* bytes to be consumed or been generated by dma machine */
273 unsigned total_bytes; /* total bytes dmaed by hardware */
274
275 unsigned error; /* number of over/underruns */
276 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
277
278 /* redundant, but makes calculations easier */
279 /* what the hardware uses */
280 unsigned dmasize;
281 unsigned fragsize;
282 unsigned fragsamples;
283
284 /* what we tell the user to expect */
285 unsigned userfrags;
286 unsigned userfragsize;
287
288 /* OSS stuff */
289 unsigned mapped:1;
290 unsigned ready:1;
291 unsigned update_flag;
292 unsigned ossfragsize;
293 unsigned ossmaxfrags;
294 unsigned subdivision;
295 } dmabuf;
296 };
297
298
299 struct ali_card {
300 struct ali_channel channel[5];
301 unsigned int magic;
302
303 /* We keep ali5455 cards in a linked list */
304 struct ali_card *next;
305
306 /* The ali has a certain amount of cross channel interaction
307 so we use a single per card lock */
308 spinlock_t lock;
309 spinlock_t ac97_lock;
310
311 /* PCI device stuff */
312 struct pci_dev *pci_dev;
313 u16 pci_id;
314 #ifdef CONFIG_PM
315 u16 pm_suspended;
316 int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
317 #endif
318 /* soundcore stuff */
319 int dev_audio;
320
321 /* structures for abstraction of hardware facilities, codecs, banks and channels */
322 struct ac97_codec *ac97_codec[NR_AC97];
323 struct ali_state *states[NR_HW_CH];
324
325 u16 ac97_features;
326 u16 ac97_status;
327 u16 channels;
328
329 /* hardware resources */
330 unsigned long iobase;
331
332 u32 irq;
333
334 /* Function support */
335 struct ali_channel *(*alloc_pcm_channel) (struct ali_card *);
336 struct ali_channel *(*alloc_rec_pcm_channel) (struct ali_card *);
337 struct ali_channel *(*alloc_rec_mic_channel) (struct ali_card *);
338 struct ali_channel *(*alloc_codec_spdifout_channel) (struct ali_card *);
339 struct ali_channel *(*alloc_controller_spdifout_channel) (struct ali_card *);
340 void (*free_pcm_channel) (struct ali_card *, int chan);
341
342 /* We have a *very* long init time possibly, so use this to block */
343 /* attempts to open our devices before we are ready (stops oops'es) */
344 int initializing;
345 };
346
347
348 static struct ali_card *devs = NULL;
349
350 static int ali_open_mixdev(struct inode *inode, struct file *file);
351 static int ali_ioctl_mixdev(struct inode *inode, struct file *file,
352 unsigned int cmd, unsigned long arg);
353 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg);
354 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
355
356 static struct ali_channel *ali_alloc_pcm_channel(struct ali_card *card)
357 {
358 if (card->channel[1].used == 1)
359 return NULL;
360 card->channel[1].used = 1;
361 return &card->channel[1];
362 }
363
364 static struct ali_channel *ali_alloc_rec_pcm_channel(struct ali_card *card)
365 {
366 if (card->channel[0].used == 1)
367 return NULL;
368 card->channel[0].used = 1;
369 return &card->channel[0];
370 }
371
372 static struct ali_channel *ali_alloc_rec_mic_channel(struct ali_card *card)
373 {
374 if (card->channel[2].used == 1)
375 return NULL;
376 card->channel[2].used = 1;
377 return &card->channel[2];
378 }
379
380 static struct ali_channel *ali_alloc_codec_spdifout_channel(struct ali_card *card)
381 {
382 if (card->channel[3].used == 1)
383 return NULL;
384 card->channel[3].used = 1;
385 return &card->channel[3];
386 }
387
388 static struct ali_channel *ali_alloc_controller_spdifout_channel(struct ali_card *card)
389 {
390 if (card->channel[4].used == 1)
391 return NULL;
392 card->channel[4].used = 1;
393 return &card->channel[4];
394 }
395 static void ali_free_pcm_channel(struct ali_card *card, int channel)
396 {
397 card->channel[channel].used = 0;
398 }
399
400
401 //add support codec spdif out
402 static int ali_valid_spdif_rate(struct ac97_codec *codec, int rate)
403 {
404 unsigned long id = 0L;
405
406 id = (ali_ac97_get(codec, AC97_VENDOR_ID1) << 16);
407 id |= ali_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
408 switch (id) {
409 case 0x41445361: /* AD1886 */
410 if (rate == 48000) {
411 return 1;
412 }
413 break;
414 case 0x414c4720: /* ALC650 */
415 if (rate == 48000) {
416 return 1;
417 }
418 break;
419 default: /* all other codecs, until we know otherwiae */
420 if (rate == 48000 || rate == 44100 || rate == 32000) {
421 return 1;
422 }
423 break;
424 }
425 return (0);
426 }
427
428 /* ali_set_spdif_output
429 *
430 * Configure the S/PDIF output transmitter. When we turn on
431 * S/PDIF, we turn off the analog output. This may not be
432 * the right thing to do.
433 *
434 * Assumptions:
435 * The DSP sample rate must already be set to a supported
436 * S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
437 */
438 static void ali_set_spdif_output(struct ali_state *state, int slots,
439 int rate)
440 {
441 int vol;
442 int aud_reg;
443 struct ac97_codec *codec = state->card->ac97_codec[0];
444
445 if (!(state->card->ac97_features & 4)) {
446 state->card->ac97_status &= ~SPDIF_ON;
447 } else {
448 if (slots == -1) { /* Turn off S/PDIF */
449 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
450 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
451
452 /* If the volume wasn't muted before we turned on S/PDIF, unmute it */
453 if (!(state->card->ac97_status & VOL_MUTED)) {
454 aud_reg = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
455 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO,
456 (aud_reg & ~VOL_MUTED));
457 }
458 state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
459 return;
460 }
461
462 vol = ali_ac97_get(codec, AC97_MASTER_VOL_STEREO);
463 state->card->ac97_status = vol & VOL_MUTED;
464
465 /* Set S/PDIF transmitter sample rate */
466 aud_reg = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
467 switch (rate) {
468 case 32000:
469 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_32K;
470 break;
471 case 44100:
472 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_44K;
473 break;
474 case 48000:
475 aud_reg = (aud_reg & AC97_SC_SPSR_MASK) | AC97_SC_SPSR_48K;
476 break;
477 default:
478 /* turn off S/PDIF */
479 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
480 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
481 state->card->ac97_status &= ~SPDIF_ON;
482 return;
483 }
484
485 ali_ac97_set(codec, AC97_SPDIF_CONTROL, aud_reg);
486
487 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
488 aud_reg = (aud_reg & AC97_EA_SLOT_MASK) | slots | AC97_EA_SPDIF;
489 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
490
491 aud_reg = ali_ac97_get(codec, AC97_POWER_CONTROL);
492 aud_reg |= 0x0002;
493 ali_ac97_set(codec, AC97_POWER_CONTROL, aud_reg);
494 udelay(1);
495
496 state->card->ac97_status |= SPDIF_ON;
497
498 /* Check to make sure the configuration is valid */
499 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
500 if (!(aud_reg & 0x0400)) {
501 /* turn off S/PDIF */
502 ali_ac97_set(codec, AC97_EXTENDED_STATUS, (aud_reg & ~AC97_EA_SPDIF));
503 state->card->ac97_status &= ~SPDIF_ON;
504 return;
505 }
506 if (codec_independent_spdif_locked > 0) {
507 aud_reg = ali_ac97_get(codec, 0x6a);
508 ali_ac97_set(codec, 0x6a, (aud_reg & 0xefff));
509 }
510 /* Mute the analog output */
511 /* Should this only mute the PCM volume??? */
512 }
513 }
514
515 /* ali_set_dac_channels
516 *
517 * Configure the codec's multi-channel DACs
518 *
519 * The logic is backwards. Setting the bit to 1 turns off the DAC.
520 *
521 * What about the ICH? We currently configure it using the
522 * SNDCTL_DSP_CHANNELS ioctl. If we're turnning on the DAC,
523 * does that imply that we want the ICH set to support
524 * these channels?
525 *
526 * TODO:
527 * vailidate that the codec really supports these DACs
528 * before turning them on.
529 */
530 static void ali_set_dac_channels(struct ali_state *state, int channel)
531 {
532 int aud_reg;
533 struct ac97_codec *codec = state->card->ac97_codec[0];
534
535 aud_reg = ali_ac97_get(codec, AC97_EXTENDED_STATUS);
536 aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
537 state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
538
539 switch (channel) {
540 case 2: /* always enabled */
541 break;
542 case 4:
543 aud_reg &= ~AC97_EA_PRJ;
544 state->card->ac97_status |= SURR_ON;
545 break;
546 case 6:
547 aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
548 state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
549 break;
550 default:
551 break;
552 }
553 ali_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
554
555 }
556
557 /* set playback sample rate */
558 static unsigned int ali_set_dac_rate(struct ali_state *state,
559 unsigned int rate)
560 {
561 struct dmabuf *dmabuf = &state->dmabuf;
562 u32 new_rate;
563 struct ac97_codec *codec = state->card->ac97_codec[0];
564
565 if (!(state->card->ac97_features & 0x0001)) {
566 dmabuf->rate = clocking;
567 return clocking;
568 }
569
570 if (rate > 48000)
571 rate = 48000;
572 if (rate < 8000)
573 rate = 8000;
574 dmabuf->rate = rate;
575
576 /*
577 * Adjust for misclocked crap
578 */
579
580 rate = (rate * clocking) / 48000;
581
582 if (strict_clocking && rate < 8000) {
583 rate = 8000;
584 dmabuf->rate = (rate * 48000) / clocking;
585 }
586
587 new_rate = ac97_set_dac_rate(codec, rate);
588 if (new_rate != rate) {
589 dmabuf->rate = (new_rate * 48000) / clocking;
590 }
591 rate = new_rate;
592 return dmabuf->rate;
593 }
594
595 /* set recording sample rate */
596 static unsigned int ali_set_adc_rate(struct ali_state *state,
597 unsigned int rate)
598 {
599 struct dmabuf *dmabuf = &state->dmabuf;
600 u32 new_rate;
601 struct ac97_codec *codec = state->card->ac97_codec[0];
602
603 if (!(state->card->ac97_features & 0x0001)) {
604 dmabuf->rate = clocking;
605 return clocking;
606 }
607
608 if (rate > 48000)
609 rate = 48000;
610 if (rate < 8000)
611 rate = 8000;
612 dmabuf->rate = rate;
613
614 /*
615 * Adjust for misclocked crap
616 */
617
618 rate = (rate * clocking) / 48000;
619 if (strict_clocking && rate < 8000) {
620 rate = 8000;
621 dmabuf->rate = (rate * 48000) / clocking;
622 }
623
624 new_rate = ac97_set_adc_rate(codec, rate);
625
626 if (new_rate != rate) {
627 dmabuf->rate = (new_rate * 48000) / clocking;
628 rate = new_rate;
629 }
630 return dmabuf->rate;
631 }
632
633 /* set codec independent spdifout sample rate */
634 static unsigned int ali_set_codecspdifout_rate(struct ali_state *state,
635 unsigned int rate)
636 {
637 struct dmabuf *dmabuf = &state->dmabuf;
638
639 if (!(state->card->ac97_features & 0x0001)) {
640 dmabuf->rate = clocking;
641 return clocking;
642 }
643
644 if (rate > 48000)
645 rate = 48000;
646 if (rate < 8000)
647 rate = 8000;
648 dmabuf->rate = rate;
649
650 return dmabuf->rate;
651 }
652
653 /* set controller independent spdif out function sample rate */
654 static void ali_set_spdifout_rate(struct ali_state *state,
655 unsigned int rate)
656 {
657 unsigned char ch_st_sel;
658 unsigned short status_rate;
659
660 switch (rate) {
661 case 44100:
662 status_rate = 0;
663 break;
664 case 32000:
665 status_rate = 0x300;
666 break;
667 case 48000:
668 default:
669 status_rate = 0x200;
670 break;
671 }
672
673 ch_st_sel = inb(state->card->iobase + ALI_SPDIFICS) & ALI_SPDIF_OUT_CH_STATUS; //select spdif_out
674
675 ch_st_sel |= 0x80; //select right
676 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
677 outb(status_rate | 0x20, (state->card->iobase + ALI_SPDIFCSR + 2));
678
679 ch_st_sel &= (~0x80); //select left
680 outb(ch_st_sel, (state->card->iobase + ALI_SPDIFICS));
681 outw(status_rate | 0x10, (state->card->iobase + ALI_SPDIFCSR + 2));
682 }
683
684 /* get current playback/recording dma buffer pointer (byte offset from LBA),
685 called with spinlock held! */
686
687 static inline unsigned ali_get_dma_addr(struct ali_state *state, int rec)
688 {
689 struct dmabuf *dmabuf = &state->dmabuf;
690 unsigned int civ, offset, port, port_picb;
691 unsigned int data;
692
693 if (!dmabuf->enable)
694 return 0;
695
696 if (rec == 1)
697 port = state->card->iobase + dmabuf->read_channel->port;
698 else if (rec == 2)
699 port = state->card->iobase + dmabuf->codec_spdifout_channel->port;
700 else if (rec == 3)
701 port = state->card->iobase + dmabuf->controller_spdifout_channel->port;
702 else
703 port = state->card->iobase + dmabuf->write_channel->port;
704
705 port_picb = port + OFF_PICB;
706
707 do {
708 civ = inb(port + OFF_CIV) & 31;
709 offset = inw(port_picb);
710 /* Must have a delay here! */
711 if (offset == 0)
712 udelay(1);
713
714 /* Reread both registers and make sure that that total
715 * offset from the first reading to the second is 0.
716 * There is an issue with SiS hardware where it will count
717 * picb down to 0, then update civ to the next value,
718 * then set the new picb to fragsize bytes. We can catch
719 * it between the civ update and the picb update, making
720 * it look as though we are 1 fragsize ahead of where we
721 * are. The next to we get the address though, it will
722 * be back in thdelay is more than long enough
723 * that we won't have to worry about the chip still being
724 * out of sync with reality ;-)
725 */
726 } while (civ != (inb(port + OFF_CIV) & 31) || offset != inw(port_picb));
727
728 data = ((civ + 1) * dmabuf->fragsize - (2 * offset)) % dmabuf->dmasize;
729 if (inw(port_picb) == 0)
730 data -= 2048;
731
732 return data;
733 }
734
735 /* Stop recording (lock held) */
736 static inline void __stop_adc(struct ali_state *state)
737 {
738 struct dmabuf *dmabuf = &state->dmabuf;
739 struct ali_card *card = state->card;
740
741 dmabuf->enable &= ~ADC_RUNNING;
742
743 outl((1 << 18) | (1 << 16), card->iobase + ALI_DMACR);
744 udelay(1);
745
746 outb(0, card->iobase + PI_CR);
747 while (inb(card->iobase + PI_CR) != 0);
748
749 // now clear any latent interrupt bits (like the halt bit)
750 outb(inb(card->iobase + PI_SR) | 0x001e, card->iobase + PI_SR);
751 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMIN, card->iobase + ALI_INTERRUPTSR);
752 }
753
754 static void stop_adc(struct ali_state *state)
755 {
756 struct ali_card *card = state->card;
757 unsigned long flags;
758 spin_lock_irqsave(&card->lock, flags);
759 __stop_adc(state);
760 spin_unlock_irqrestore(&card->lock, flags);
761 }
762
763 static inline void __start_adc(struct ali_state *state)
764 {
765 struct dmabuf *dmabuf = &state->dmabuf;
766
767 if (dmabuf->count < dmabuf->dmasize && dmabuf->ready
768 && !dmabuf->enable && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
769 dmabuf->enable |= ADC_RUNNING;
770 outb((1 << 4) | (1 << 2), state->card->iobase + PI_CR);
771 if (state->card->channel[0].used == 1)
772 outl(1, state->card->iobase + ALI_DMACR); // DMA CONTROL REGISTRER
773 udelay(100);
774 if (state->card->channel[2].used == 1)
775 outl((1 << 2), state->card->iobase + ALI_DMACR); //DMA CONTROL REGISTER
776 udelay(100);
777 }
778 }
779
780 static void start_adc(struct ali_state *state)
781 {
782 struct ali_card *card = state->card;
783 unsigned long flags;
784
785 spin_lock_irqsave(&card->lock, flags);
786 __start_adc(state);
787 spin_unlock_irqrestore(&card->lock, flags);
788 }
789
790 /* stop playback (lock held) */
791 static inline void __stop_dac(struct ali_state *state)
792 {
793 struct dmabuf *dmabuf = &state->dmabuf;
794 struct ali_card *card = state->card;
795
796 dmabuf->enable &= ~DAC_RUNNING;
797 outl(0x00020000, card->iobase + 0x08);
798 outb(0, card->iobase + PO_CR);
799 while (inb(card->iobase + PO_CR) != 0)
800 cpu_relax();
801
802 outb(inb(card->iobase + PO_SR) | 0x001e, card->iobase + PO_SR);
803
804 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_PCMOUT, card->iobase + ALI_INTERRUPTSR);
805 }
806
807 static void stop_dac(struct ali_state *state)
808 {
809 struct ali_card *card = state->card;
810 unsigned long flags;
811 spin_lock_irqsave(&card->lock, flags);
812 __stop_dac(state);
813 spin_unlock_irqrestore(&card->lock, flags);
814 }
815
816 static inline void __start_dac(struct ali_state *state)
817 {
818 struct dmabuf *dmabuf = &state->dmabuf;
819 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
820 (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
821 dmabuf->enable |= DAC_RUNNING;
822 outb((1 << 4) | (1 << 2), state->card->iobase + PO_CR);
823 outl((1 << 1), state->card->iobase + 0x08); //dma control register
824 }
825 }
826
827 static void start_dac(struct ali_state *state)
828 {
829 struct ali_card *card = state->card;
830 unsigned long flags;
831 spin_lock_irqsave(&card->lock, flags);
832 __start_dac(state);
833 spin_unlock_irqrestore(&card->lock, flags);
834 }
835
836 /* stop codec and controller spdif out (lock held) */
837 static inline void __stop_spdifout(struct ali_state *state)
838 {
839 struct dmabuf *dmabuf = &state->dmabuf;
840 struct ali_card *card = state->card;
841
842 if (codec_independent_spdif_locked > 0) {
843 dmabuf->enable &= ~CODEC_SPDIFOUT_RUNNING;
844 outl((1 << 19), card->iobase + 0x08);
845 outb(0, card->iobase + CODECSPDIFOUT_CR);
846
847 while (inb(card->iobase + CODECSPDIFOUT_CR) != 0)
848 cpu_relax();
849
850 outb(inb(card->iobase + CODECSPDIFOUT_SR) | 0x001e, card->iobase + CODECSPDIFOUT_SR);
851 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_CODECSPDIFOUT, card->iobase + ALI_INTERRUPTSR);
852 } else {
853 if (controller_independent_spdif_locked > 0) {
854 dmabuf->enable &= ~CONTROLLER_SPDIFOUT_RUNNING;
855 outl((1 << 23), card->iobase + 0x08);
856 outb(0, card->iobase + CONTROLLERSPDIFOUT_CR);
857 while (inb(card->iobase + CONTROLLERSPDIFOUT_CR) != 0)
858 cpu_relax();
859 outb(inb(card->iobase + CONTROLLERSPDIFOUT_SR) | 0x001e, card->iobase + CONTROLLERSPDIFOUT_SR);
860 outl(inl(card->iobase + ALI_INTERRUPTSR) & INT_SPDIFOUT, card->iobase + ALI_INTERRUPTSR);
861 }
862 }
863 }
864
865 static void stop_spdifout(struct ali_state *state)
866 {
867 struct ali_card *card = state->card;
868 unsigned long flags;
869 spin_lock_irqsave(&card->lock, flags);
870 __stop_spdifout(state);
871 spin_unlock_irqrestore(&card->lock, flags);
872 }
873
874 static inline void __start_spdifout(struct ali_state *state)
875 {
876 struct dmabuf *dmabuf = &state->dmabuf;
877 if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
878 (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
879 if (codec_independent_spdif_locked > 0) {
880 dmabuf->enable |= CODEC_SPDIFOUT_RUNNING;
881 outb((1 << 4) | (1 << 2), state->card->iobase + CODECSPDIFOUT_CR);
882 outl((1 << 3), state->card->iobase + 0x08); //dma control register
883 } else {
884 if (controller_independent_spdif_locked > 0) {
885 dmabuf->enable |= CONTROLLER_SPDIFOUT_RUNNING;
886 outb((1 << 4) | (1 << 2), state->card->iobase + CONTROLLERSPDIFOUT_CR);
887 outl((1 << 7), state->card->iobase + 0x08); //dma control register
888 }
889 }
890 }
891 }
892
893 static void start_spdifout(struct ali_state *state)
894 {
895 struct ali_card *card = state->card;
896 unsigned long flags;
897 spin_lock_irqsave(&card->lock, flags);
898 __start_spdifout(state);
899 spin_unlock_irqrestore(&card->lock, flags);
900 }
901
902 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
903 #define DMABUF_MINORDER 1
904
905 /* allocate DMA buffer, playback , recording,spdif out buffer should be allocated separately */
906 static int alloc_dmabuf(struct ali_state *state)
907 {
908 struct dmabuf *dmabuf = &state->dmabuf;
909 void *rawbuf = NULL;
910 int order, size;
911 struct page *page, *pend;
912
913 /* If we don't have any oss frag params, then use our default ones */
914 if (dmabuf->ossmaxfrags == 0)
915 dmabuf->ossmaxfrags = 4;
916 if (dmabuf->ossfragsize == 0)
917 dmabuf->ossfragsize = (PAGE_SIZE << DMABUF_DEFAULTORDER) / dmabuf->ossmaxfrags;
918 size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
919
920 if (dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
921 return 0;
922 /* alloc enough to satisfy the oss params */
923 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
924 if ((PAGE_SIZE << order) > size)
925 continue;
926 if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
927 PAGE_SIZE << order,
928 &dmabuf->dma_handle)))
929 break;
930 }
931 if (!rawbuf)
932 return -ENOMEM;
933
934 dmabuf->ready = dmabuf->mapped = 0;
935 dmabuf->rawbuf = rawbuf;
936 dmabuf->buforder = order;
937
938 /* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
939 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
940 for (page = virt_to_page(rawbuf); page <= pend; page++)
941 SetPageReserved(page);
942 return 0;
943 }
944
945 /* free DMA buffer */
946 static void dealloc_dmabuf(struct ali_state *state)
947 {
948 struct dmabuf *dmabuf = &state->dmabuf;
949 struct page *page, *pend;
950
951 if (dmabuf->rawbuf) {
952 /* undo marking the pages as reserved */
953 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
954 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
955 ClearPageReserved(page);
956 pci_free_consistent(state->card->pci_dev,
957 PAGE_SIZE << dmabuf->buforder,
958 dmabuf->rawbuf, dmabuf->dma_handle);
959 }
960 dmabuf->rawbuf = NULL;
961 dmabuf->mapped = dmabuf->ready = 0;
962 }
963
964 static int prog_dmabuf(struct ali_state *state, unsigned rec)
965 {
966 struct dmabuf *dmabuf = &state->dmabuf;
967 struct ali_channel *c = NULL;
968 struct sg_item *sg;
969 unsigned long flags;
970 int ret;
971 unsigned fragint;
972 int i;
973
974 spin_lock_irqsave(&state->card->lock, flags);
975 if (dmabuf->enable & DAC_RUNNING)
976 __stop_dac(state);
977 if (dmabuf->enable & ADC_RUNNING)
978 __stop_adc(state);
979 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
980 __stop_spdifout(state);
981 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
982 __stop_spdifout(state);
983
984 dmabuf->total_bytes = 0;
985 dmabuf->count = dmabuf->error = 0;
986 dmabuf->swptr = dmabuf->hwptr = 0;
987 spin_unlock_irqrestore(&state->card->lock, flags);
988
989 /* allocate DMA buffer, let alloc_dmabuf determine if we are already
990 * allocated well enough or if we should replace the current buffer
991 * (assuming one is already allocated, if it isn't, then allocate it).
992 */
993 if ((ret = alloc_dmabuf(state)))
994 return ret;
995
996 /* FIXME: figure out all this OSS fragment stuff */
997 /* I did, it now does what it should according to the OSS API. DL */
998 /* We may not have realloced our dmabuf, but the fragment size to
999 * fragment number ratio may have changed, so go ahead and reprogram
1000 * things
1001 */
1002
1003 dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
1004 dmabuf->numfrag = SG_LEN;
1005 dmabuf->fragsize = dmabuf->dmasize / dmabuf->numfrag;
1006 dmabuf->fragsamples = dmabuf->fragsize >> 1;
1007 dmabuf->userfragsize = dmabuf->ossfragsize;
1008 dmabuf->userfrags = dmabuf->dmasize / dmabuf->ossfragsize;
1009
1010 memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
1011
1012 if (dmabuf->ossmaxfrags == 4) {
1013 fragint = 8;
1014 dmabuf->fragshift = 2;
1015 } else if (dmabuf->ossmaxfrags == 8) {
1016 fragint = 4;
1017 dmabuf->fragshift = 3;
1018 } else if (dmabuf->ossmaxfrags == 16) {
1019 fragint = 2;
1020 dmabuf->fragshift = 4;
1021 } else {
1022 fragint = 1;
1023 dmabuf->fragshift = 5;
1024 }
1025 /*
1026 * Now set up the ring
1027 */
1028
1029 if (rec == 1)
1030 c = dmabuf->read_channel;
1031 else if (rec == 2)
1032 c = dmabuf->codec_spdifout_channel;
1033 else if (rec == 3)
1034 c = dmabuf->controller_spdifout_channel;
1035 else if (rec == 0)
1036 c = dmabuf->write_channel;
1037 if (c != NULL) {
1038 sg = &c->sg[0];
1039 /*
1040 * Load up 32 sg entries and take an interrupt at half
1041 * way (we might want more interrupts later..)
1042 */
1043 for (i = 0; i < dmabuf->numfrag; i++) {
1044 sg->busaddr =
1045 virt_to_bus(dmabuf->rawbuf +
1046 dmabuf->fragsize * i);
1047 // the card will always be doing 16bit stereo
1048 sg->control = dmabuf->fragsamples;
1049 sg->control |= CON_BUFPAD; //I modify
1050 // set us up to get IOC interrupts as often as needed to
1051 // satisfy numfrag requirements, no more
1052 if (((i + 1) % fragint) == 0) {
1053 sg->control |= CON_IOC;
1054 }
1055 sg++;
1056 }
1057 spin_lock_irqsave(&state->card->lock, flags);
1058 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
1059 outl(virt_to_bus(&c->sg[0]), state->card->iobase + c->port + OFF_BDBAR);
1060 outb(0, state->card->iobase + c->port + OFF_CIV);
1061 outb(0, state->card->iobase + c->port + OFF_LVI);
1062 spin_unlock_irqrestore(&state->card->lock, flags);
1063 }
1064 /* set the ready flag for the dma buffer */
1065 dmabuf->ready = 1;
1066 return 0;
1067 }
1068
1069 static void __ali_update_lvi(struct ali_state *state, int rec)
1070 {
1071 struct dmabuf *dmabuf = &state->dmabuf;
1072 int x, port;
1073 port = state->card->iobase;
1074 if (rec == 1)
1075 port += dmabuf->read_channel->port;
1076 else if (rec == 2)
1077 port += dmabuf->codec_spdifout_channel->port;
1078 else if (rec == 3)
1079 port += dmabuf->controller_spdifout_channel->port;
1080 else if (rec == 0)
1081 port += dmabuf->write_channel->port;
1082 /* if we are currently stopped, then our CIV is actually set to our
1083 * *last* sg segment and we are ready to wrap to the next. However,
1084 * if we set our LVI to the last sg segment, then it won't wrap to
1085 * the next sg segment, it won't even get a start. So, instead, when
1086 * we are stopped, we set both the LVI value and also we increment
1087 * the CIV value to the next sg segment to be played so that when
1088 * we call start_{dac,adc}, things will operate properly
1089 */
1090 if (!dmabuf->enable && dmabuf->ready) {
1091 if (rec && dmabuf->count < dmabuf->dmasize && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
1092 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1093 __start_adc(state);
1094 while (! (inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1095 cpu_relax();
1096 } else if (!rec && dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
1097 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1098 __start_dac(state);
1099 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1100 cpu_relax();
1101 } else if (rec && dmabuf->count && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
1102 if (codec_independent_spdif_locked > 0) {
1103 // outb((inb(port+OFF_CIV))&31, port+OFF_LVI);
1104 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1105 __start_spdifout(state);
1106 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1107 cpu_relax();
1108 } else {
1109 if (controller_independent_spdif_locked > 0) {
1110 outb((inb(port + OFF_CIV) + 1) & 31, port + OFF_LVI);
1111 __start_spdifout(state);
1112 while (!(inb(port + OFF_CR) & ((1 << 4) | (1 << 2))))
1113 cpu_relax();
1114 }
1115 }
1116 }
1117 }
1118
1119 /* swptr - 1 is the tail of our transfer */
1120 x = (dmabuf->dmasize + dmabuf->swptr - 1) % dmabuf->dmasize;
1121 x /= dmabuf->fragsize;
1122 outb(x, port + OFF_LVI);
1123 }
1124
1125 static void ali_update_lvi(struct ali_state *state, int rec)
1126 {
1127 struct dmabuf *dmabuf = &state->dmabuf;
1128 unsigned long flags;
1129 if (!dmabuf->ready)
1130 return;
1131 spin_lock_irqsave(&state->card->lock, flags);
1132 __ali_update_lvi(state, rec);
1133 spin_unlock_irqrestore(&state->card->lock, flags);
1134 }
1135
1136 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1137 static void ali_update_ptr(struct ali_state *state)
1138 {
1139 struct dmabuf *dmabuf = &state->dmabuf;
1140 unsigned hwptr;
1141 int diff;
1142
1143 /* error handling and process wake up for DAC */
1144 if (dmabuf->enable == ADC_RUNNING) {
1145 /* update hardware pointer */
1146 hwptr = ali_get_dma_addr(state, 1);
1147 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1148 dmabuf->hwptr = hwptr;
1149 dmabuf->total_bytes += diff;
1150 dmabuf->count += diff;
1151 if (dmabuf->count > dmabuf->dmasize) {
1152 /* buffer underrun or buffer overrun */
1153 /* this is normal for the end of a read */
1154 /* only give an error if we went past the */
1155 /* last valid sg entry */
1156 if ((inb(state->card->iobase + PI_CIV) & 31) != (inb(state->card->iobase + PI_LVI) & 31)) {
1157 printk(KERN_WARNING "ali_audio: DMA overrun on read\n");
1158 dmabuf->error++;
1159 }
1160 }
1161 if (dmabuf->count > dmabuf->userfragsize)
1162 wake_up(&dmabuf->wait);
1163 }
1164 /* error handling and process wake up for DAC */
1165 if (dmabuf->enable == DAC_RUNNING) {
1166 /* update hardware pointer */
1167 hwptr = ali_get_dma_addr(state, 0);
1168 diff =
1169 (dmabuf->dmasize + hwptr -
1170 dmabuf->hwptr) % dmabuf->dmasize;
1171 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
1172 printk("DAC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
1173 #endif
1174 dmabuf->hwptr = hwptr;
1175 dmabuf->total_bytes += diff;
1176 dmabuf->count -= diff;
1177 if (dmabuf->count < 0) {
1178 /* buffer underrun or buffer overrun */
1179 /* this is normal for the end of a write */
1180 /* only give an error if we went past the */
1181 /* last valid sg entry */
1182 if ((inb(state->card->iobase + PO_CIV) & 31) != (inb(state->card->iobase + PO_LVI) & 31)) {
1183 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1184 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1185 inb(state->card->iobase + PO_CIV) & 31,
1186 inb(state->card->iobase + PO_LVI) & 31,
1187 dmabuf->hwptr,
1188 dmabuf->count);
1189 dmabuf->error++;
1190 }
1191 }
1192 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1193 wake_up(&dmabuf->wait);
1194 }
1195
1196 /* error handling and process wake up for CODEC SPDIF OUT */
1197 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
1198 /* update hardware pointer */
1199 hwptr = ali_get_dma_addr(state, 2);
1200 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1201 dmabuf->hwptr = hwptr;
1202 dmabuf->total_bytes += diff;
1203 dmabuf->count -= diff;
1204 if (dmabuf->count < 0) {
1205 /* buffer underrun or buffer overrun */
1206 /* this is normal for the end of a write */
1207 /* only give an error if we went past the */
1208 /* last valid sg entry */
1209 if ((inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31)) {
1210 printk(KERN_WARNING "ali_audio: DMA overrun on write\n");
1211 printk(KERN_DEBUG "ali_audio: CIV %d, LVI %d, hwptr %x, count %d\n",
1212 inb(state->card->iobase + CODECSPDIFOUT_CIV) & 31,
1213 inb(state->card->iobase + CODECSPDIFOUT_LVI) & 31,
1214 dmabuf->hwptr, dmabuf->count);
1215 dmabuf->error++;
1216 }
1217 }
1218 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1219 wake_up(&dmabuf->wait);
1220 }
1221 /* error handling and process wake up for CONTROLLER SPDIF OUT */
1222 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
1223 /* update hardware pointer */
1224 hwptr = ali_get_dma_addr(state, 3);
1225 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1226 dmabuf->hwptr = hwptr;
1227 dmabuf->total_bytes += diff;
1228 dmabuf->count -= diff;
1229 if (dmabuf->count < 0) {
1230 /* buffer underrun or buffer overrun */
1231 /* this is normal for the end of a write */
1232 /* only give an error if we went past the */
1233 /* last valid sg entry */
1234 if ((inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31) != (inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31)) {
1235 printk(KERN_WARNING
1236 "ali_audio: DMA overrun on write\n");
1237 printk("ali_audio: CIV %d, LVI %d, hwptr %x, "
1238 "count %d\n",
1239 inb(state->card->iobase + CONTROLLERSPDIFOUT_CIV) & 31,
1240 inb(state->card->iobase + CONTROLLERSPDIFOUT_LVI) & 31,
1241 dmabuf->hwptr, dmabuf->count);
1242 dmabuf->error++;
1243 }
1244 }
1245 if (dmabuf->count < (dmabuf->dmasize - dmabuf->userfragsize))
1246 wake_up(&dmabuf->wait);
1247 }
1248 }
1249
1250 static inline int ali_get_free_write_space(struct
1251 ali_state
1252 *state)
1253 {
1254 struct dmabuf *dmabuf = &state->dmabuf;
1255 int free;
1256
1257 if (dmabuf->count < 0) {
1258 dmabuf->count = 0;
1259 dmabuf->swptr = dmabuf->hwptr;
1260 }
1261 free = dmabuf->dmasize - dmabuf->swptr;
1262 if ((dmabuf->count + free) > dmabuf->dmasize){
1263 free = dmabuf->dmasize - dmabuf->count;
1264 }
1265 return free;
1266 }
1267
1268 static inline int ali_get_available_read_data(struct
1269 ali_state
1270 *state)
1271 {
1272 struct dmabuf *dmabuf = &state->dmabuf;
1273 int avail;
1274 ali_update_ptr(state);
1275 // catch overruns during record
1276 if (dmabuf->count > dmabuf->dmasize) {
1277 dmabuf->count = dmabuf->dmasize;
1278 dmabuf->swptr = dmabuf->hwptr;
1279 }
1280 avail = dmabuf->count;
1281 avail -= (dmabuf->hwptr % dmabuf->fragsize);
1282 if (avail < 0)
1283 return (0);
1284 return (avail);
1285 }
1286
1287 static int drain_dac(struct ali_state *state, int signals_allowed)
1288 {
1289
1290 DECLARE_WAITQUEUE(wait, current);
1291 struct dmabuf *dmabuf = &state->dmabuf;
1292 unsigned long flags;
1293 unsigned long tmo;
1294 int count;
1295 if (!dmabuf->ready)
1296 return 0;
1297 if (dmabuf->mapped) {
1298 stop_dac(state);
1299 return 0;
1300 }
1301 add_wait_queue(&dmabuf->wait, &wait);
1302 for (;;) {
1303
1304 spin_lock_irqsave(&state->card->lock, flags);
1305 ali_update_ptr(state);
1306 count = dmabuf->count;
1307 spin_unlock_irqrestore(&state->card->lock, flags);
1308 if (count <= 0)
1309 break;
1310 /*
1311 * This will make sure that our LVI is correct, that our
1312 * pointer is updated, and that the DAC is running. We
1313 * have to force the setting of dmabuf->trigger to avoid
1314 * any possible deadlocks.
1315 */
1316 if (!dmabuf->enable) {
1317 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1318 ali_update_lvi(state, 0);
1319 }
1320 if (signal_pending(current) && signals_allowed) {
1321 break;
1322 }
1323
1324 /* It seems that we have to set the current state to
1325 * TASK_INTERRUPTIBLE every time to make the process
1326 * really go to sleep. This also has to be *after* the
1327 * update_ptr() call because update_ptr is likely to
1328 * do a wake_up() which will unset this before we ever
1329 * try to sleep, resuling in a tight loop in this code
1330 * instead of actually sleeping and waiting for an
1331 * interrupt to wake us up!
1332 */
1333 set_current_state(TASK_INTERRUPTIBLE);
1334 /*
1335 * set the timeout to significantly longer than it *should*
1336 * take for the DAC to drain the DMA buffer
1337 */
1338 tmo = (count * HZ) / (dmabuf->rate);
1339 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1340 printk(KERN_ERR "ali_audio: drain_dac, dma timeout?\n");
1341 count = 0;
1342 break;
1343 }
1344 }
1345 set_current_state(TASK_RUNNING);
1346 remove_wait_queue(&dmabuf->wait, &wait);
1347 if (count > 0 && signal_pending(current) && signals_allowed)
1348 return -ERESTARTSYS;
1349 stop_dac(state);
1350 return 0;
1351 }
1352
1353
1354 static int drain_spdifout(struct ali_state *state, int signals_allowed)
1355 {
1356
1357 DECLARE_WAITQUEUE(wait, current);
1358 struct dmabuf *dmabuf = &state->dmabuf;
1359 unsigned long flags;
1360 unsigned long tmo;
1361 int count;
1362 if (!dmabuf->ready)
1363 return 0;
1364 if (dmabuf->mapped) {
1365 stop_spdifout(state);
1366 return 0;
1367 }
1368 add_wait_queue(&dmabuf->wait, &wait);
1369 for (;;) {
1370
1371 spin_lock_irqsave(&state->card->lock, flags);
1372 ali_update_ptr(state);
1373 count = dmabuf->count;
1374 spin_unlock_irqrestore(&state->card->lock, flags);
1375 if (count <= 0)
1376 break;
1377 /*
1378 * This will make sure that our LVI is correct, that our
1379 * pointer is updated, and that the DAC is running. We
1380 * have to force the setting of dmabuf->trigger to avoid
1381 * any possible deadlocks.
1382 */
1383 if (!dmabuf->enable) {
1384 if (codec_independent_spdif_locked > 0) {
1385 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1386 ali_update_lvi(state, 2);
1387 } else {
1388 if (controller_independent_spdif_locked > 0) {
1389 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1390 ali_update_lvi(state, 3);
1391 }
1392 }
1393 }
1394 if (signal_pending(current) && signals_allowed) {
1395 break;
1396 }
1397
1398 /* It seems that we have to set the current state to
1399 * TASK_INTERRUPTIBLE every time to make the process
1400 * really go to sleep. This also has to be *after* the
1401 * update_ptr() call because update_ptr is likely to
1402 * do a wake_up() which will unset this before we ever
1403 * try to sleep, resuling in a tight loop in this code
1404 * instead of actually sleeping and waiting for an
1405 * interrupt to wake us up!
1406 */
1407 set_current_state(TASK_INTERRUPTIBLE);
1408 /*
1409 * set the timeout to significantly longer than it *should*
1410 * take for the DAC to drain the DMA buffer
1411 */
1412 tmo = (count * HZ) / (dmabuf->rate);
1413 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1414 printk(KERN_ERR "ali_audio: drain_spdifout, dma timeout?\n");
1415 count = 0;
1416 break;
1417 }
1418 }
1419 set_current_state(TASK_RUNNING);
1420 remove_wait_queue(&dmabuf->wait, &wait);
1421 if (count > 0 && signal_pending(current) && signals_allowed)
1422 return -ERESTARTSYS;
1423 stop_spdifout(state);
1424 return 0;
1425 }
1426
1427 static void ali_channel_interrupt(struct ali_card *card)
1428 {
1429 int i, count;
1430
1431 for (i = 0; i < NR_HW_CH; i++) {
1432 struct ali_state *state = card->states[i];
1433 struct ali_channel *c = NULL;
1434 struct dmabuf *dmabuf;
1435 unsigned long port = card->iobase;
1436 u16 status;
1437 if (!state)
1438 continue;
1439 if (!state->dmabuf.ready)
1440 continue;
1441 dmabuf = &state->dmabuf;
1442 if (codec_independent_spdif_locked > 0) {
1443 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
1444 c = dmabuf->codec_spdifout_channel;
1445 }
1446 } else {
1447 if (controller_independent_spdif_locked > 0) {
1448 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1449 c = dmabuf->controller_spdifout_channel;
1450 } else {
1451 if (dmabuf->enable & DAC_RUNNING) {
1452 c = dmabuf->write_channel;
1453 } else if (dmabuf->enable & ADC_RUNNING) {
1454 c = dmabuf->read_channel;
1455 } else
1456 continue;
1457 }
1458 }
1459 port += c->port;
1460
1461 status = inw(port + OFF_SR);
1462
1463 if (status & DMA_INT_COMPLETE) {
1464 /* only wake_up() waiters if this interrupt signals
1465 * us being beyond a userfragsize of data open or
1466 * available, and ali_update_ptr() does that for
1467 * us
1468 */
1469 ali_update_ptr(state);
1470 }
1471
1472 if (status & DMA_INT_LVI) {
1473 ali_update_ptr(state);
1474 wake_up(&dmabuf->wait);
1475
1476 if (dmabuf->enable & DAC_RUNNING)
1477 count = dmabuf->count;
1478 else if (dmabuf->enable & ADC_RUNNING)
1479 count = dmabuf->dmasize - dmabuf->count;
1480 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1481 count = dmabuf->count;
1482 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1483 count = dmabuf->count;
1484 else count = 0;
1485
1486 if (count > 0) {
1487 if (dmabuf->enable & DAC_RUNNING)
1488 outl((1 << 1), state->card->iobase + ALI_DMACR);
1489 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1490 outl((1 << 3), state->card->iobase + ALI_DMACR);
1491 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1492 outl((1 << 7), state->card->iobase + ALI_DMACR);
1493 } else {
1494 if (dmabuf->enable & DAC_RUNNING)
1495 __stop_dac(state);
1496 if (dmabuf->enable & ADC_RUNNING)
1497 __stop_adc(state);
1498 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1499 __stop_spdifout(state);
1500 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1501 __stop_spdifout(state);
1502 dmabuf->enable = 0;
1503 wake_up(&dmabuf->wait);
1504 }
1505
1506 }
1507 if (!(status & DMA_INT_DCH)) {
1508 ali_update_ptr(state);
1509 wake_up(&dmabuf->wait);
1510 if (dmabuf->enable & DAC_RUNNING)
1511 count = dmabuf->count;
1512 else if (dmabuf->enable & ADC_RUNNING)
1513 count = dmabuf->dmasize - dmabuf->count;
1514 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1515 count = dmabuf->count;
1516 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1517 count = dmabuf->count;
1518 else
1519 count = 0;
1520
1521 if (count > 0) {
1522 if (dmabuf->enable & DAC_RUNNING)
1523 outl((1 << 1), state->card->iobase + ALI_DMACR);
1524 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1525 outl((1 << 3), state->card->iobase + ALI_DMACR);
1526 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1527 outl((1 << 7), state->card->iobase + ALI_DMACR);
1528 } else {
1529 if (dmabuf->enable & DAC_RUNNING)
1530 __stop_dac(state);
1531 if (dmabuf->enable & ADC_RUNNING)
1532 __stop_adc(state);
1533 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1534 __stop_spdifout(state);
1535 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1536 __stop_spdifout(state);
1537 dmabuf->enable = 0;
1538 wake_up(&dmabuf->wait);
1539 }
1540 }
1541 outw(status & DMA_INT_MASK, port + OFF_SR);
1542 }
1543 }
1544
1545 static irqreturn_t ali_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1546 {
1547 struct ali_card *card = (struct ali_card *) dev_id;
1548 u32 status;
1549 u16 status2;
1550
1551 spin_lock(&card->lock);
1552 status = inl(card->iobase + ALI_INTERRUPTSR);
1553 if (!(status & INT_MASK)) {
1554 spin_unlock(&card->lock);
1555 return IRQ_NONE; /* not for us */
1556 }
1557
1558 if (codec_independent_spdif_locked > 0) {
1559 if (globel == 0) {
1560 globel += 1;
1561 status2 = inw(card->iobase + 0x76);
1562 outw(status2 | 0x000c, card->iobase + 0x76);
1563 } else {
1564 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1565 ali_channel_interrupt(card);
1566 }
1567 } else {
1568 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1569 ali_channel_interrupt(card);
1570 }
1571
1572 /* clear 'em */
1573 outl(status & INT_MASK, card->iobase + ALI_INTERRUPTSR);
1574 spin_unlock(&card->lock);
1575 return IRQ_HANDLED;
1576 }
1577
1578 /* in this loop, dmabuf.count signifies the amount of data that is
1579 waiting to be copied to the user's buffer. It is filled by the dma
1580 machine and drained by this loop. */
1581
1582 static ssize_t ali_read(struct file *file, char __user *buffer,
1583 size_t count, loff_t * ppos)
1584 {
1585 struct ali_state *state = (struct ali_state *) file->private_data;
1586 struct ali_card *card = state ? state->card : NULL;
1587 struct dmabuf *dmabuf = &state->dmabuf;
1588 ssize_t ret;
1589 unsigned long flags;
1590 unsigned int swptr;
1591 int cnt;
1592 DECLARE_WAITQUEUE(waita, current);
1593 #ifdef DEBUG2
1594 printk("ali_audio: ali_read called, count = %d\n", count);
1595 #endif
1596 if (dmabuf->mapped)
1597 return -ENXIO;
1598 if (dmabuf->enable & DAC_RUNNING)
1599 return -ENODEV;
1600 if (!dmabuf->read_channel) {
1601 dmabuf->ready = 0;
1602 dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
1603 if (!dmabuf->read_channel) {
1604 return -EBUSY;
1605 }
1606 }
1607 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1608 return ret;
1609 if (!access_ok(VERIFY_WRITE, buffer, count))
1610 return -EFAULT;
1611 ret = 0;
1612 add_wait_queue(&dmabuf->wait, &waita);
1613 while (count > 0) {
1614 set_current_state(TASK_INTERRUPTIBLE);
1615 spin_lock_irqsave(&card->lock, flags);
1616 if (PM_SUSPENDED(card)) {
1617 spin_unlock_irqrestore(&card->lock, flags);
1618 schedule();
1619 if (signal_pending(current)) {
1620 if (!ret)
1621 ret = -EAGAIN;
1622 break;
1623 }
1624 continue;
1625 }
1626 swptr = dmabuf->swptr;
1627 cnt = ali_get_available_read_data(state);
1628 // this is to make the copy_to_user simpler below
1629 if (cnt > (dmabuf->dmasize - swptr))
1630 cnt = dmabuf->dmasize - swptr;
1631 spin_unlock_irqrestore(&card->lock, flags);
1632 if (cnt > count)
1633 cnt = count;
1634 /* Lop off the last two bits to force the code to always
1635 * write in full samples. This keeps software that sets
1636 * O_NONBLOCK but doesn't check the return value of the
1637 * write call from getting things out of state where they
1638 * think a full 4 byte sample was written when really only
1639 * a portion was, resulting in odd sound and stereo
1640 * hysteresis.
1641 */
1642 cnt &= ~0x3;
1643 if (cnt <= 0) {
1644 unsigned long tmo;
1645 /*
1646 * Don't let us deadlock. The ADC won't start if
1647 * dmabuf->trigger isn't set. A call to SETTRIGGER
1648 * could have turned it off after we set it to on
1649 * previously.
1650 */
1651 dmabuf->trigger = PCM_ENABLE_INPUT;
1652 /*
1653 * This does three things. Updates LVI to be correct,
1654 * makes sure the ADC is running, and updates the
1655 * hwptr.
1656 */
1657 ali_update_lvi(state, 1);
1658 if (file->f_flags & O_NONBLOCK) {
1659 if (!ret)
1660 ret = -EAGAIN;
1661 goto done;
1662 }
1663 /* Set the timeout to how long it would take to fill
1664 * two of our buffers. If we haven't been woke up
1665 * by then, then we know something is wrong.
1666 */
1667 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1668
1669 /* There are two situations when sleep_on_timeout returns, one is when
1670 the interrupt is serviced correctly and the process is waked up by
1671 ISR ON TIME. Another is when timeout is expired, which means that
1672 either interrupt is NOT serviced correctly (pending interrupt) or it
1673 is TOO LATE for the process to be scheduled to run (scheduler latency)
1674 which results in a (potential) buffer overrun. And worse, there is
1675 NOTHING we can do to prevent it. */
1676 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1677 printk(KERN_ERR
1678 "ali_audio: recording schedule timeout, "
1679 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1680 dmabuf->dmasize, dmabuf->fragsize,
1681 dmabuf->count, dmabuf->hwptr,
1682 dmabuf->swptr);
1683 /* a buffer overrun, we delay the recovery until next time the
1684 while loop begin and we REALLY have space to record */
1685 }
1686 if (signal_pending(current)) {
1687 ret = ret ? ret : -ERESTARTSYS;
1688 goto done;
1689 }
1690 continue;
1691 }
1692
1693 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1694 if (!ret)
1695 ret = -EFAULT;
1696 goto done;
1697 }
1698
1699 swptr = (swptr + cnt) % dmabuf->dmasize;
1700 spin_lock_irqsave(&card->lock, flags);
1701 if (PM_SUSPENDED(card)) {
1702 spin_unlock_irqrestore(&card->lock, flags);
1703 continue;
1704 }
1705 dmabuf->swptr = swptr;
1706 dmabuf->count -= cnt;
1707 spin_unlock_irqrestore(&card->lock, flags);
1708 count -= cnt;
1709 buffer += cnt;
1710 ret += cnt;
1711 }
1712 done:
1713 ali_update_lvi(state, 1);
1714 set_current_state(TASK_RUNNING);
1715 remove_wait_queue(&dmabuf->wait, &waita);
1716 return ret;
1717 }
1718
1719 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1720 the soundcard. it is drained by the dma machine and filled by this loop. */
1721 static ssize_t ali_write(struct file *file,
1722 const char __user *buffer, size_t count, loff_t * ppos)
1723 {
1724 struct ali_state *state = (struct ali_state *) file->private_data;
1725 struct ali_card *card = state ? state->card : NULL;
1726 struct dmabuf *dmabuf = &state->dmabuf;
1727 ssize_t ret;
1728 unsigned long flags;
1729 unsigned int swptr = 0;
1730 int cnt, x;
1731 DECLARE_WAITQUEUE(waita, current);
1732 #ifdef DEBUG2
1733 printk("ali_audio: ali_write called, count = %d\n", count);
1734 #endif
1735 if (dmabuf->mapped)
1736 return -ENXIO;
1737 if (dmabuf->enable & ADC_RUNNING)
1738 return -ENODEV;
1739 if (codec_independent_spdif_locked > 0) {
1740 if (!dmabuf->codec_spdifout_channel) {
1741 dmabuf->ready = 0;
1742 dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card);
1743 if (!dmabuf->codec_spdifout_channel)
1744 return -EBUSY;
1745 }
1746 } else {
1747 if (controller_independent_spdif_locked > 0) {
1748 if (!dmabuf->controller_spdifout_channel) {
1749 dmabuf->ready = 0;
1750 dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card);
1751 if (!dmabuf->controller_spdifout_channel)
1752 return -EBUSY;
1753 }
1754 } else {
1755 if (!dmabuf->write_channel) {
1756 dmabuf->ready = 0;
1757 dmabuf->write_channel =
1758 card->alloc_pcm_channel(card);
1759 if (!dmabuf->write_channel)
1760 return -EBUSY;
1761 }
1762 }
1763 }
1764
1765 if (codec_independent_spdif_locked > 0) {
1766 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
1767 return ret;
1768 } else {
1769 if (controller_independent_spdif_locked > 0) {
1770 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
1771 return ret;
1772 } else {
1773
1774 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1775 return ret;
1776 }
1777 }
1778 if (!access_ok(VERIFY_READ, buffer, count))
1779 return -EFAULT;
1780 ret = 0;
1781 add_wait_queue(&dmabuf->wait, &waita);
1782 while (count > 0) {
1783 set_current_state(TASK_INTERRUPTIBLE);
1784 spin_lock_irqsave(&state->card->lock, flags);
1785 if (PM_SUSPENDED(card)) {
1786 spin_unlock_irqrestore(&card->lock, flags);
1787 schedule();
1788 if (signal_pending(current)) {
1789 if (!ret)
1790 ret = -EAGAIN;
1791 break;
1792 }
1793 continue;
1794 }
1795
1796 swptr = dmabuf->swptr;
1797 cnt = ali_get_free_write_space(state);
1798 /* Bound the maximum size to how much we can copy to the
1799 * dma buffer before we hit the end. If we have more to
1800 * copy then it will get done in a second pass of this
1801 * loop starting from the beginning of the buffer.
1802 */
1803 if (cnt > (dmabuf->dmasize - swptr))
1804 cnt = dmabuf->dmasize - swptr;
1805 spin_unlock_irqrestore(&state->card->lock, flags);
1806 #ifdef DEBUG2
1807 printk(KERN_INFO
1808 "ali_audio: ali_write: %d bytes available space\n",
1809 cnt);
1810 #endif
1811 if (cnt > count)
1812 cnt = count;
1813 /* Lop off the last two bits to force the code to always
1814 * write in full samples. This keeps software that sets
1815 * O_NONBLOCK but doesn't check the return value of the
1816 * write call from getting things out of state where they
1817 * think a full 4 byte sample was written when really only
1818 * a portion was, resulting in odd sound and stereo
1819 * hysteresis.
1820 */
1821 cnt &= ~0x3;
1822 if (cnt <= 0) {
1823 unsigned long tmo;
1824 // There is data waiting to be played
1825 /*
1826 * Force the trigger setting since we would
1827 * deadlock with it set any other way
1828 */
1829 if (codec_independent_spdif_locked > 0) {
1830 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1831 ali_update_lvi(state, 2);
1832 } else {
1833 if (controller_independent_spdif_locked > 0) {
1834 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1835 ali_update_lvi(state, 3);
1836 } else {
1837
1838 dmabuf->trigger = PCM_ENABLE_OUTPUT;
1839 ali_update_lvi(state, 0);
1840 }
1841 }
1842 if (file->f_flags & O_NONBLOCK) {
1843 if (!ret)
1844 ret = -EAGAIN;
1845 goto ret;
1846 }
1847 /* Not strictly correct but works */
1848 tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1849 /* There are two situations when sleep_on_timeout returns, one is when
1850 the interrupt is serviced correctly and the process is waked up by
1851 ISR ON TIME. Another is when timeout is expired, which means that
1852 either interrupt is NOT serviced correctly (pending interrupt) or it
1853 is TOO LATE for the process to be scheduled to run (scheduler latency)
1854 which results in a (potential) buffer underrun. And worse, there is
1855 NOTHING we can do to prevent it. */
1856
1857 /* FIXME - do timeout handling here !! */
1858 schedule_timeout(tmo >= 2 ? tmo : 2);
1859
1860 if (signal_pending(current)) {
1861 if (!ret)
1862 ret = -ERESTARTSYS;
1863 goto ret;
1864 }
1865 continue;
1866 }
1867 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1868 if (!ret)
1869 ret = -EFAULT;
1870 goto ret;
1871 }
1872
1873 swptr = (swptr + cnt) % dmabuf->dmasize;
1874 spin_lock_irqsave(&state->card->lock, flags);
1875 if (PM_SUSPENDED(card)) {
1876 spin_unlock_irqrestore(&card->lock, flags);
1877 continue;
1878 }
1879
1880 dmabuf->swptr = swptr;
1881 dmabuf->count += cnt;
1882 count -= cnt;
1883 buffer += cnt;
1884 ret += cnt;
1885 spin_unlock_irqrestore(&state->card->lock, flags);
1886 }
1887 if (swptr % dmabuf->fragsize) {
1888 x = dmabuf->fragsize - (swptr % dmabuf->fragsize);
1889 memset(dmabuf->rawbuf + swptr, '\0', x);
1890 }
1891 ret:
1892 if (codec_independent_spdif_locked > 0) {
1893 ali_update_lvi(state, 2);
1894 } else {
1895 if (controller_independent_spdif_locked > 0) {
1896 ali_update_lvi(state, 3);
1897 } else {
1898 ali_update_lvi(state, 0);
1899 }
1900 }
1901 set_current_state(TASK_RUNNING);
1902 remove_wait_queue(&dmabuf->wait, &waita);
1903 return ret;
1904 }
1905
1906 /* No kernel lock - we have our own spinlock */
1907 static unsigned int ali_poll(struct file *file, struct poll_table_struct
1908 *wait)
1909 {
1910 struct ali_state *state = (struct ali_state *) file->private_data;
1911 struct dmabuf *dmabuf = &state->dmabuf;
1912 unsigned long flags;
1913 unsigned int mask = 0;
1914 if (!dmabuf->ready)
1915 return 0;
1916 poll_wait(file, &dmabuf->wait, wait);
1917 spin_lock_irqsave(&state->card->lock, flags);
1918 ali_update_ptr(state);
1919 if (file->f_mode & FMODE_READ && dmabuf->enable & ADC_RUNNING) {
1920 if (dmabuf->count >= (signed) dmabuf->fragsize)
1921 mask |= POLLIN | POLLRDNORM;
1922 }
1923 if (file->f_mode & FMODE_WRITE && (dmabuf->enable & (DAC_RUNNING|CODEC_SPDIFOUT_RUNNING|CONTROLLER_SPDIFOUT_RUNNING))) {
1924 if ((signed) dmabuf->dmasize >= dmabuf->count + (signed) dmabuf->fragsize)
1925 mask |= POLLOUT | POLLWRNORM;
1926 }
1927 spin_unlock_irqrestore(&state->card->lock, flags);
1928 return mask;
1929 }
1930
1931 static int ali_mmap(struct file *file, struct vm_area_struct *vma)
1932 {
1933 struct ali_state *state = (struct ali_state *) file->private_data;
1934 struct dmabuf *dmabuf = &state->dmabuf;
1935 int ret = -EINVAL;
1936 unsigned long size;
1937 lock_kernel();
1938 if (vma->vm_flags & VM_WRITE) {
1939 if (!dmabuf->write_channel && (dmabuf->write_channel = state->card->alloc_pcm_channel(state->card)) == NULL) {
1940 ret = -EBUSY;
1941 goto out;
1942 }
1943 }
1944 if (vma->vm_flags & VM_READ) {
1945 if (!dmabuf->read_channel && (dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
1946 ret = -EBUSY;
1947 goto out;
1948 }
1949 }
1950 if ((ret = prog_dmabuf(state, 0)) != 0)
1951 goto out;
1952 ret = -EINVAL;
1953 if (vma->vm_pgoff != 0)
1954 goto out;
1955 size = vma->vm_end - vma->vm_start;
1956 if (size > (PAGE_SIZE << dmabuf->buforder))
1957 goto out;
1958 ret = -EAGAIN;
1959 if (remap_pfn_range(vma, vma->vm_start,
1960 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
1961 size, vma->vm_page_prot))
1962 goto out;
1963 dmabuf->mapped = 1;
1964 dmabuf->trigger = 0;
1965 ret = 0;
1966 out:
1967 unlock_kernel();
1968 return ret;
1969 }
1970
1971 static int ali_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1972 {
1973 struct ali_state *state = (struct ali_state *) file->private_data;
1974 struct ali_channel *c = NULL;
1975 struct dmabuf *dmabuf = &state->dmabuf;
1976 unsigned long flags;
1977 audio_buf_info abinfo;
1978 count_info cinfo;
1979 unsigned int i_scr;
1980 int val = 0, ret;
1981 struct ac97_codec *codec = state->card->ac97_codec[0];
1982 void __user *argp = (void __user *)arg;
1983 int __user *p = argp;
1984
1985 #ifdef DEBUG
1986 printk("ali_audio: ali_ioctl, arg=0x%x, cmd=",
1987 arg ? *p : 0);
1988 #endif
1989 switch (cmd) {
1990 case OSS_GETVERSION:
1991 #ifdef DEBUG
1992 printk("OSS_GETVERSION\n");
1993 #endif
1994 return put_user(SOUND_VERSION, p);
1995 case SNDCTL_DSP_RESET:
1996 #ifdef DEBUG
1997 printk("SNDCTL_DSP_RESET\n");
1998 #endif
1999 spin_lock_irqsave(&state->card->lock, flags);
2000 if (dmabuf->enable == DAC_RUNNING) {
2001 c = dmabuf->write_channel;
2002 __stop_dac(state);
2003 }
2004 if (dmabuf->enable == ADC_RUNNING) {
2005 c = dmabuf->read_channel;
2006 __stop_adc(state);
2007 }
2008 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2009 c = dmabuf->codec_spdifout_channel;
2010 __stop_spdifout(state);
2011 }
2012 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2013 c = dmabuf->controller_spdifout_channel;
2014 __stop_spdifout(state);
2015 }
2016 if (c != NULL) {
2017 outb(2, state->card->iobase + c->port + OFF_CR); /* reset DMA machine */
2018 outl(virt_to_bus(&c->sg[0]),
2019 state->card->iobase + c->port + OFF_BDBAR);
2020 outb(0, state->card->iobase + c->port + OFF_CIV);
2021 outb(0, state->card->iobase + c->port + OFF_LVI);
2022 }
2023
2024 spin_unlock_irqrestore(&state->card->lock, flags);
2025 synchronize_irq(state->card->pci_dev->irq);
2026 dmabuf->ready = 0;
2027 dmabuf->swptr = dmabuf->hwptr = 0;
2028 dmabuf->count = dmabuf->total_bytes = 0;
2029 return 0;
2030 case SNDCTL_DSP_SYNC:
2031 #ifdef DEBUG
2032 printk("SNDCTL_DSP_SYNC\n");
2033 #endif
2034 if (codec_independent_spdif_locked > 0) {
2035 if (dmabuf->enable != CODEC_SPDIFOUT_RUNNING
2036 || file->f_flags & O_NONBLOCK)
2037 return 0;
2038 if ((val = drain_spdifout(state, 1)))
2039 return val;
2040 } else {
2041 if (controller_independent_spdif_locked > 0) {
2042 if (dmabuf->enable !=
2043 CONTROLLER_SPDIFOUT_RUNNING
2044 || file->f_flags & O_NONBLOCK)
2045 return 0;
2046 if ((val = drain_spdifout(state, 1)))
2047 return val;
2048 } else {
2049 if (dmabuf->enable != DAC_RUNNING
2050 || file->f_flags & O_NONBLOCK)
2051 return 0;
2052 if ((val = drain_dac(state, 1)))
2053 return val;
2054 }
2055 }
2056 dmabuf->total_bytes = 0;
2057 return 0;
2058 case SNDCTL_DSP_SPEED: /* set smaple rate */
2059 #ifdef DEBUG
2060 printk("SNDCTL_DSP_SPEED\n");
2061 #endif
2062 if (get_user(val, p))
2063 return -EFAULT;
2064 if (val >= 0) {
2065 if (file->f_mode & FMODE_WRITE) {
2066 if ((state->card->ac97_status & SPDIF_ON)) { /* S/PDIF Enabled */
2067 /* RELTEK ALC650 only support 48000, need to check that */
2068 if (ali_valid_spdif_rate(codec, val)) {
2069 if (codec_independent_spdif_locked > 0) {
2070 ali_set_spdif_output(state, -1, 0);
2071 stop_spdifout(state);
2072 dmabuf->ready = 0;
2073 /* I add test codec independent spdif out */
2074 spin_lock_irqsave(&state->card->lock, flags);
2075 ali_set_codecspdifout_rate(state, val); // I modified
2076 spin_unlock_irqrestore(&state->card->lock, flags);
2077 /* Set S/PDIF transmitter rate. */
2078 i_scr = inl(state->card->iobase + ALI_SCR);
2079 if ((i_scr & 0x00300000) == 0x00100000) {
2080 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2081 } else {
2082 if ((i_scr&0x00300000) == 0x00200000)
2083 {
2084 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2085 } else {
2086 if ((i_scr & 0x00300000) == 0x00300000) {
2087 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2088 } else {
2089 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2090 }
2091 }
2092 }
2093
2094 if (!(state->card->ac97_status & SPDIF_ON)) {
2095 val = dmabuf->rate;
2096 }
2097 } else {
2098 if (controller_independent_spdif_locked > 0)
2099 {
2100 stop_spdifout(state);
2101 dmabuf->ready = 0;
2102 spin_lock_irqsave(&state->card->lock, flags);
2103 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2104 spin_unlock_irqrestore(&state->card->lock, flags);
2105 } else {
2106 /* Set DAC rate */
2107 ali_set_spdif_output(state, -1, 0);
2108 stop_dac(state);
2109 dmabuf->ready = 0;
2110 spin_lock_irqsave(&state->card->lock, flags);
2111 ali_set_dac_rate(state, val);
2112 spin_unlock_irqrestore(&state->card->lock, flags);
2113 /* Set S/PDIF transmitter rate. */
2114 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, val);
2115 if (!(state->card->ac97_status & SPDIF_ON))
2116 {
2117 val = dmabuf->rate;
2118 }
2119 }
2120 }
2121 } else { /* Not a valid rate for S/PDIF, ignore it */
2122 val = dmabuf->rate;
2123 }
2124 } else {
2125 stop_dac(state);
2126 dmabuf->ready = 0;
2127 spin_lock_irqsave(&state->card->lock, flags);
2128 ali_set_dac_rate(state, val);
2129 spin_unlock_irqrestore(&state->card->lock, flags);
2130 }
2131 }
2132 if (file->f_mode & FMODE_READ) {
2133 stop_adc(state);
2134 dmabuf->ready = 0;
2135 spin_lock_irqsave(&state->card->lock, flags);
2136 ali_set_adc_rate(state, val);
2137 spin_unlock_irqrestore(&state->card->lock, flags);
2138 }
2139 }
2140 return put_user(dmabuf->rate, p);
2141 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2142 #ifdef DEBUG
2143 printk("SNDCTL_DSP_STEREO\n");
2144 #endif
2145 if (dmabuf->enable & DAC_RUNNING) {
2146 stop_dac(state);
2147 }
2148 if (dmabuf->enable & ADC_RUNNING) {
2149 stop_adc(state);
2150 }
2151 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2152 stop_spdifout(state);
2153 }
2154 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2155 stop_spdifout(state);
2156 }
2157 return put_user(1, p);
2158 case SNDCTL_DSP_GETBLKSIZE:
2159 if (file->f_mode & FMODE_WRITE) {
2160 if (codec_independent_spdif_locked > 0) {
2161 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)))
2162 return val;
2163 } else {
2164 if (controller_independent_spdif_locked > 0) {
2165 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)))
2166 return val;
2167 } else {
2168 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
2169 return val;
2170 }
2171 }
2172 }
2173
2174 if (file->f_mode & FMODE_READ) {
2175 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
2176 return val;
2177 }
2178 #ifdef DEBUG
2179 printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
2180 #endif
2181 return put_user(dmabuf->userfragsize, p);
2182 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
2183 #ifdef DEBUG
2184 printk("SNDCTL_DSP_GETFMTS\n");
2185 #endif
2186 return put_user(AFMT_S16_LE, p);
2187 case SNDCTL_DSP_SETFMT: /* Select sample format */
2188 #ifdef DEBUG
2189 printk("SNDCTL_DSP_SETFMT\n");
2190 #endif
2191 return put_user(AFMT_S16_LE, p);
2192 case SNDCTL_DSP_CHANNELS: // add support 4,6 channel
2193 #ifdef DEBUG
2194 printk("SNDCTL_DSP_CHANNELS\n");
2195 #endif
2196 if (get_user(val, p))
2197 return -EFAULT;
2198 if (val > 0) {
2199 if (dmabuf->enable & DAC_RUNNING) {
2200 stop_dac(state);
2201 }
2202 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2203 stop_spdifout(state);
2204 }
2205 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2206 stop_spdifout(state);
2207 }
2208 if (dmabuf->enable & ADC_RUNNING) {
2209 stop_adc(state);
2210 }
2211 } else {
2212 return put_user(state->card->channels, p);
2213 }
2214
2215 i_scr = inl(state->card->iobase + ALI_SCR);
2216 /* Current # of channels enabled */
2217 if (i_scr & 0x00000100)
2218 ret = 4;
2219 else if (i_scr & 0x00000200)
2220 ret = 6;
2221 else
2222 ret = 2;
2223 switch (val) {
2224 case 2: /* 2 channels is always supported */
2225 if (codec_independent_spdif_locked > 0) {
2226 outl(((i_scr & 0xfffffcff) | 0x00100000), (state->card->iobase + ALI_SCR));
2227 } else
2228 outl((i_scr & 0xfffffcff), (state->card->iobase + ALI_SCR));
2229 /* Do we need to change mixer settings???? */
2230 break;
2231 case 4: /* Supported on some chipsets, better check first */
2232 if (codec_independent_spdif_locked > 0) {
2233 outl(((i_scr & 0xfffffcff) | 0x00000100 | 0x00200000), (state->card->iobase + ALI_SCR));
2234 } else
2235 outl(((i_scr & 0xfffffcff) | 0x00000100), (state->card->iobase + ALI_SCR));
2236 break;
2237 case 6: /* Supported on some chipsets, better check first */
2238 if (codec_independent_spdif_locked > 0) {
2239 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000 | 0x00300000), (state->card->iobase + ALI_SCR));
2240 } else
2241 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000), (state->card->iobase + ALI_SCR));
2242 break;
2243 default: /* nothing else is ever supported by the chipset */
2244 val = ret;
2245 break;
2246 }
2247 return put_user(val, p);
2248 case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
2249 /* we update the swptr to the end of the last sg segment then return */
2250 #ifdef DEBUG
2251 printk("SNDCTL_DSP_POST\n");
2252 #endif
2253 if (codec_independent_spdif_locked > 0) {
2254 if (!dmabuf->ready || (dmabuf->enable != CODEC_SPDIFOUT_RUNNING))
2255 return 0;
2256 } else {
2257 if (controller_independent_spdif_locked > 0) {
2258 if (!dmabuf->ready || (dmabuf->enable != CONTROLLER_SPDIFOUT_RUNNING))
2259 return 0;
2260 } else {
2261 if (!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
2262 return 0;
2263 }
2264 }
2265 if ((dmabuf->swptr % dmabuf->fragsize) != 0) {
2266 val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
2267 dmabuf->swptr += val;
2268 dmabuf->count += val;
2269 }
2270 return 0;
2271 case SNDCTL_DSP_SUBDIVIDE:
2272 if (dmabuf->subdivision)
2273 return -EINVAL;
2274 if (get_user(val, p))
2275 return -EFAULT;
2276 if (val != 1 && val != 2 && val != 4)
2277 return -EINVAL;
2278 #ifdef DEBUG
2279 printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
2280 #endif
2281 dmabuf->subdivision = val;
2282 dmabuf->ready = 0;
2283 return 0;
2284 case SNDCTL_DSP_SETFRAGMENT:
2285 if (get_user(val, p))
2286 return -EFAULT;
2287 dmabuf->ossfragsize = 1 << (val & 0xffff);
2288 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2289 if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
2290 return -EINVAL;
2291 /*
2292 * Bound the frag size into our allowed range of 256 - 4096
2293 */
2294 if (dmabuf->ossfragsize < 256)
2295 dmabuf->ossfragsize = 256;
2296 else if (dmabuf->ossfragsize > 4096)
2297 dmabuf->ossfragsize = 4096;
2298 /*
2299 * The numfrags could be something reasonable, or it could
2300 * be 0xffff meaning "Give me as much as possible". So,
2301 * we check the numfrags * fragsize doesn't exceed our
2302 * 64k buffer limit, nor is it less than our 8k minimum.
2303 * If it fails either one of these checks, then adjust the
2304 * number of fragments, not the size of them. It's OK if
2305 * our number of fragments doesn't equal 32 or anything
2306 * like our hardware based number now since we are using
2307 * a different frag count for the hardware. Before we get
2308 * into this though, bound the maxfrags to avoid overflow
2309 * issues. A reasonable bound would be 64k / 256 since our
2310 * maximum buffer size is 64k and our minimum frag size is
2311 * 256. On the other end, our minimum buffer size is 8k and
2312 * our maximum frag size is 4k, so the lower bound should
2313 * be 2.
2314 */
2315 if (dmabuf->ossmaxfrags > 256)
2316 dmabuf->ossmaxfrags = 256;
2317 else if (dmabuf->ossmaxfrags < 2)
2318 dmabuf->ossmaxfrags = 2;
2319 val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
2320 while (val < 8192) {
2321 val <<= 1;
2322 dmabuf->ossmaxfrags <<= 1;
2323 }
2324 while (val > 65536) {
2325 val >>= 1;
2326 dmabuf->ossmaxfrags >>= 1;
2327 }
2328 dmabuf->ready = 0;
2329 #ifdef DEBUG
2330 printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
2331 dmabuf->ossfragsize, dmabuf->ossmaxfrags);
2332 #endif
2333 return 0;
2334 case SNDCTL_DSP_GETOSPACE:
2335 if (!(file->f_mode & FMODE_WRITE))
2336 return -EINVAL;
2337 if (codec_independent_spdif_locked > 0) {
2338 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2339 return val;
2340 } else {
2341 if (controller_independent_spdif_locked > 0) {
2342 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2343 return val;
2344 } else {
2345 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2346 return val;
2347 }
2348 }
2349 spin_lock_irqsave(&state->card->lock, flags);
2350 ali_update_ptr(state);
2351 abinfo.fragsize = dmabuf->userfragsize;
2352 abinfo.fragstotal = dmabuf->userfrags;
2353 if (dmabuf->mapped)
2354 abinfo.bytes = dmabuf->dmasize;
2355 else
2356 abinfo.bytes = ali_get_free_write_space(state);
2357 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2358 spin_unlock_irqrestore(&state->card->lock, flags);
2359 #if defined(DEBUG) || defined(DEBUG_MMAP)
2360 printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n",
2361 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2362 abinfo.fragstotal);
2363 #endif
2364 return copy_to_user(argp, &abinfo,
2365 sizeof(abinfo)) ? -EFAULT : 0;
2366 case SNDCTL_DSP_GETOPTR:
2367 if (!(file->f_mode & FMODE_WRITE))
2368 return -EINVAL;
2369 if (codec_independent_spdif_locked > 0) {
2370 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2371 return val;
2372 } else {
2373 if (controller_independent_spdif_locked > 0) {
2374 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2375 return val;
2376 } else {
2377 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2378 return val;
2379 }
2380 }
2381 spin_lock_irqsave(&state->card->lock, flags);
2382 val = ali_get_free_write_space(state);
2383 cinfo.bytes = dmabuf->total_bytes;
2384 cinfo.ptr = dmabuf->hwptr;
2385 cinfo.blocks = val / dmabuf->userfragsize;
2386 if (codec_independent_spdif_locked > 0) {
2387 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2388 dmabuf->count += val;
2389 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2390 __ali_update_lvi(state, 2);
2391 }
2392 } else {
2393 if (controller_independent_spdif_locked > 0) {
2394 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2395 dmabuf->count += val;
2396 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2397 __ali_update_lvi(state, 3);
2398 }
2399 } else {
2400 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
2401 dmabuf->count += val;
2402 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2403 __ali_update_lvi(state, 0);
2404 }
2405 }
2406 }
2407 spin_unlock_irqrestore(&state->card->lock, flags);
2408 #if defined(DEBUG) || defined(DEBUG_MMAP)
2409 printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
2410 cinfo.blocks, cinfo.ptr, dmabuf->count);
2411 #endif
2412 return copy_to_user(argp, &cinfo, sizeof(cinfo))? -EFAULT : 0;
2413 case SNDCTL_DSP_GETISPACE:
2414 if (!(file->f_mode & FMODE_READ))
2415 return -EINVAL;
2416 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
2417 return val;
2418 spin_lock_irqsave(&state->card->lock, flags);
2419 abinfo.bytes = ali_get_available_read_data(state);
2420 abinfo.fragsize = dmabuf->userfragsize;
2421 abinfo.fragstotal = dmabuf->userfrags;
2422 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2423 spin_unlock_irqrestore(&state->card->lock, flags);
2424 #if defined(DEBUG) || defined(DEBUG_MMAP)
2425 printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n",
2426 abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2427 abinfo.fragstotal);
2428 #endif
2429 return copy_to_user(argp, &abinfo,
2430 sizeof(abinfo)) ? -EFAULT : 0;
2431 case SNDCTL_DSP_GETIPTR:
2432 if (!(file->f_mode & FMODE_READ))
2433 return -EINVAL;
2434 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2435 return val;
2436 spin_lock_irqsave(&state->card->lock, flags);
2437 val = ali_get_available_read_data(state);
2438 cinfo.bytes = dmabuf->total_bytes;
2439 cinfo.blocks = val / dmabuf->userfragsize;
2440 cinfo.ptr = dmabuf->hwptr;
2441 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
2442 dmabuf->count -= val;
2443 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2444 __ali_update_lvi(state, 1);
2445 }
2446 spin_unlock_irqrestore(&state->card->lock, flags);
2447 #if defined(DEBUG) || defined(DEBUG_MMAP)
2448 printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
2449 cinfo.blocks, cinfo.ptr, dmabuf->count);
2450 #endif
2451 return copy_to_user(argp, &cinfo, sizeof(cinfo))? -EFAULT: 0;
2452 case SNDCTL_DSP_NONBLOCK:
2453 #ifdef DEBUG
2454 printk("SNDCTL_DSP_NONBLOCK\n");
2455 #endif
2456 file->f_flags |= O_NONBLOCK;
2457 return 0;
2458 case SNDCTL_DSP_GETCAPS:
2459 #ifdef DEBUG
2460 printk("SNDCTL_DSP_GETCAPS\n");
2461 #endif
2462 return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2463 DSP_CAP_MMAP | DSP_CAP_BIND, p);
2464 case SNDCTL_DSP_GETTRIGGER:
2465 val = 0;
2466 #ifdef DEBUG
2467 printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
2468 #endif
2469 return put_user(dmabuf->trigger, p);
2470 case SNDCTL_DSP_SETTRIGGER:
2471 if (get_user(val, p))
2472 return -EFAULT;
2473 #if defined(DEBUG) || defined(DEBUG_MMAP)
2474 printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
2475 #endif
2476 if (!(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
2477 stop_adc(state);
2478 }
2479 if (!(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
2480 stop_dac(state);
2481 }
2482 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2483 stop_spdifout(state);
2484 }
2485 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2486 stop_spdifout(state);
2487 }
2488 dmabuf->trigger = val;
2489 if (val & PCM_ENABLE_OUTPUT && !(dmabuf->enable & DAC_RUNNING)) {
2490 if (!dmabuf->write_channel) {
2491 dmabuf->ready = 0;
2492 dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
2493 if (!dmabuf->write_channel)
2494 return -EBUSY;
2495 }
2496 if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
2497 return ret;
2498 if (dmabuf->mapped) {
2499 spin_lock_irqsave(&state->card->lock, flags);
2500 ali_update_ptr(state);
2501 dmabuf->count = 0;
2502 dmabuf->swptr = dmabuf->hwptr;
2503 dmabuf->count = ali_get_free_write_space(state);
2504 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2505 __ali_update_lvi(state, 0);
2506 spin_unlock_irqrestore(&state->card->lock,
2507 flags);
2508 } else
2509 start_dac(state);
2510 }
2511 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CODEC_SPDIFOUT_RUNNING)) {
2512 if (!dmabuf->codec_spdifout_channel) {
2513 dmabuf->ready = 0;
2514 dmabuf->codec_spdifout_channel = state->card->alloc_codec_spdifout_channel(state->card);
2515 if (!dmabuf->codec_spdifout_channel)
2516 return -EBUSY;
2517 }
2518 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
2519 return ret;
2520 if (dmabuf->mapped) {
2521 spin_lock_irqsave(&state->card->lock, flags);
2522 ali_update_ptr(state);
2523 dmabuf->count = 0;
2524 dmabuf->swptr = dmabuf->hwptr;
2525 dmabuf->count = ali_get_free_write_space(state);
2526 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2527 __ali_update_lvi(state, 2);
2528 spin_unlock_irqrestore(&state->card->lock,
2529 flags);
2530 } else
2531 start_spdifout(state);
2532 }
2533 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)) {
2534 if (!dmabuf->controller_spdifout_channel) {
2535 dmabuf->ready = 0;
2536 dmabuf->controller_spdifout_channel = state->card->alloc_controller_spdifout_channel(state->card);
2537 if (!dmabuf->controller_spdifout_channel)
2538 return -EBUSY;
2539 }
2540 if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
2541 return ret;
2542 if (dmabuf->mapped) {
2543 spin_lock_irqsave(&state->card->lock, flags);
2544 ali_update_ptr(state);
2545 dmabuf->count = 0;
2546 dmabuf->swptr = dmabuf->hwptr;
2547 dmabuf->count = ali_get_free_write_space(state);
2548 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2549 __ali_update_lvi(state, 3);
2550 spin_unlock_irqrestore(&state->card->lock, flags);
2551 } else
2552 start_spdifout(state);
2553 }
2554 if (val & PCM_ENABLE_INPUT && !(dmabuf->enable & ADC_RUNNING)) {
2555 if (!dmabuf->read_channel) {
2556 dmabuf->ready = 0;
2557 dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
2558 if (!dmabuf->read_channel)
2559 return -EBUSY;
2560 }
2561 if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
2562 return ret;
2563 if (dmabuf->mapped) {
2564 spin_lock_irqsave(&state->card->lock,
2565 flags);
2566 ali_update_ptr(state);
2567 dmabuf->swptr = dmabuf->hwptr;
2568 dmabuf->count = 0;
2569 spin_unlock_irqrestore(&state->card->lock, flags);
2570 }
2571 ali_update_lvi(state, 1);
2572 start_adc(state);
2573 }
2574 return 0;
2575 case SNDCTL_DSP_SETDUPLEX:
2576 #ifdef DEBUG
2577 printk("SNDCTL_DSP_SETDUPLEX\n");
2578 #endif
2579 return -EINVAL;
2580 case SNDCTL_DSP_GETODELAY:
2581 if (!(file->f_mode & FMODE_WRITE))
2582 return -EINVAL;
2583 spin_lock_irqsave(&state->card->lock, flags);
2584 ali_update_ptr(state);
2585 val = dmabuf->count;
2586 spin_unlock_irqrestore(&state->card->lock, flags);
2587 #ifdef DEBUG
2588 printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
2589 #endif
2590 return put_user(val, p);
2591 case SOUND_PCM_READ_RATE:
2592 #ifdef DEBUG
2593 printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
2594 #endif
2595 return put_user(dmabuf->rate, p);
2596 case SOUND_PCM_READ_CHANNELS:
2597 #ifdef DEBUG
2598 printk("SOUND_PCM_READ_CHANNELS\n");
2599 #endif
2600 return put_user(2, p);
2601 case SOUND_PCM_READ_BITS:
2602 #ifdef DEBUG
2603 printk("SOUND_PCM_READ_BITS\n");
2604 #endif
2605 return put_user(AFMT_S16_LE, p);
2606 case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
2607 #ifdef DEBUG
2608 printk("SNDCTL_DSP_SETSPDIF\n");
2609 #endif
2610 if (get_user(val, p))
2611 return -EFAULT;
2612 /* Check to make sure the codec supports S/PDIF transmitter */
2613 if ((state->card->ac97_features & 4)) {
2614 /* mask out the transmitter speed bits so the user can't set them */
2615 val &= ~0x3000;
2616 /* Add the current transmitter speed bits to the passed value */
2617 ret = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2618 val |= (ret & 0x3000);
2619 ali_ac97_set(codec, AC97_SPDIF_CONTROL, val);
2620 if (ali_ac97_get(codec, AC97_SPDIF_CONTROL) != val) {
2621 printk(KERN_ERR "ali_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
2622 return -EFAULT;
2623 }
2624 }
2625 #ifdef DEBUG
2626 else
2627 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2628 #endif
2629 return put_user(val, p);
2630 case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
2631 #ifdef DEBUG
2632 printk("SNDCTL_DSP_GETSPDIF\n");
2633 #endif
2634 if (get_user(val, p))
2635 return -EFAULT;
2636 /* Check to make sure the codec supports S/PDIF transmitter */
2637 if (!(state->card->ac97_features & 4)) {
2638 #ifdef DEBUG
2639 printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2640 #endif
2641 val = 0;
2642 } else {
2643 val = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2644 }
2645
2646 return put_user(val, p);
2647 //end add support spdif out
2648 //add support 4,6 channel
2649 case SNDCTL_DSP_GETCHANNELMASK:
2650 #ifdef DEBUG
2651 printk("SNDCTL_DSP_GETCHANNELMASK\n");
2652 #endif
2653 if (get_user(val, p))
2654 return -EFAULT;
2655 /* Based on AC'97 DAC support, not ICH hardware */
2656 val = DSP_BIND_FRONT;
2657 if (state->card->ac97_features & 0x0004)
2658 val |= DSP_BIND_SPDIF;
2659 if (state->card->ac97_features & 0x0080)
2660 val |= DSP_BIND_SURR;
2661 if (state->card->ac97_features & 0x0140)
2662 val |= DSP_BIND_CENTER_LFE;
2663 return put_user(val, p);
2664 case SNDCTL_DSP_BIND_CHANNEL:
2665 #ifdef DEBUG
2666 printk("SNDCTL_DSP_BIND_CHANNEL\n");
2667 #endif
2668 if (get_user(val, p))
2669 return -EFAULT;
2670 if (val == DSP_BIND_QUERY) {
2671 val = DSP_BIND_FRONT; /* Always report this as being enabled */
2672 if (state->card->ac97_status & SPDIF_ON)
2673 val |= DSP_BIND_SPDIF;
2674 else {
2675 if (state->card->ac97_status & SURR_ON)
2676 val |= DSP_BIND_SURR;
2677 if (state->card->
2678 ac97_status & CENTER_LFE_ON)
2679 val |= DSP_BIND_CENTER_LFE;
2680 }
2681 } else { /* Not a query, set it */
2682 if (!(file->f_mode & FMODE_WRITE))
2683 return -EINVAL;
2684 if (dmabuf->enable == DAC_RUNNING) {
2685 stop_dac(state);
2686 }
2687 if (val & DSP_BIND_SPDIF) { /* Turn on SPDIF */
2688 /* Ok, this should probably define what slots
2689 * to use. For now, we'll only set it to the
2690 * defaults:
2691 *
2692 * non multichannel codec maps to slots 3&4
2693 * 2 channel codec maps to slots 7&8
2694 * 4 channel codec maps to slots 6&9
2695 * 6 channel codec maps to slots 10&11
2696 *
2697 * there should be some way for the app to
2698 * select the slot assignment.
2699 */
2700 i_scr = inl(state->card->iobase + ALI_SCR);
2701 if (codec_independent_spdif_locked > 0) {
2702
2703 if ((i_scr & 0x00300000) == 0x00100000) {
2704 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2705 } else {
2706 if ((i_scr & 0x00300000) == 0x00200000) {
2707 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2708 } else {
2709 if ((i_scr & 0x00300000) == 0x00300000) {
2710 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2711 }
2712 }
2713 }
2714 } else { /* codec spdif out (pcm out share ) */
2715 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, dmabuf->rate); //I do not modify
2716 }
2717
2718 if (!(state->card->ac97_status & SPDIF_ON))
2719 val &= ~DSP_BIND_SPDIF;
2720 } else {
2721 int mask;
2722 int channels;
2723 /* Turn off S/PDIF if it was on */
2724 if (state->card->ac97_status & SPDIF_ON)
2725 ali_set_spdif_output(state, -1, 0);
2726 mask =
2727 val & (DSP_BIND_FRONT | DSP_BIND_SURR |
2728 DSP_BIND_CENTER_LFE);
2729 switch (mask) {
2730 case DSP_BIND_FRONT:
2731 channels = 2;
2732 break;
2733 case DSP_BIND_FRONT | DSP_BIND_SURR:
2734 channels = 4;
2735 break;
2736 case DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE:
2737 channels = 6;
2738 break;
2739 default:
2740 val = DSP_BIND_FRONT;
2741 channels = 2;
2742 break;
2743 }
2744 ali_set_dac_channels(state, channels);
2745 /* check that they really got turned on */
2746 if (!state->card->ac97_status & SURR_ON)
2747 val &= ~DSP_BIND_SURR;
2748 if (!state->card->
2749 ac97_status & CENTER_LFE_ON)
2750 val &= ~DSP_BIND_CENTER_LFE;
2751 }
2752 }
2753 return put_user(val, p);
2754 case SNDCTL_DSP_MAPINBUF:
2755 case SNDCTL_DSP_MAPOUTBUF:
2756 case SNDCTL_DSP_SETSYNCRO:
2757 case SOUND_PCM_WRITE_FILTER:
2758 case SOUND_PCM_READ_FILTER:
2759 return -EINVAL;
2760 }
2761 return -EINVAL;
2762 }
2763
2764 static int ali_open(struct inode *inode, struct file *file)
2765 {
2766 int i = 0;
2767 struct ali_card *card = devs;
2768 struct ali_state *state = NULL;
2769 struct dmabuf *dmabuf = NULL;
2770 unsigned int i_scr;
2771
2772 /* find an available virtual channel (instance of /dev/dsp) */
2773
2774 while (card != NULL) {
2775
2776 /*
2777 * If we are initializing and then fail, card could go
2778 * away unuexpectedly while we are in the for() loop.
2779 * So, check for card on each iteration before we check
2780 * for card->initializing to avoid a possible oops.
2781 * This usually only matters for times when the driver is
2782 * autoloaded by kmod.
2783 */
2784 for (i = 0; i < 50 && card && card->initializing; i++) {
2785 set_current_state(TASK_UNINTERRUPTIBLE);
2786 schedule_timeout(HZ / 20);
2787 }
2788
2789 for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
2790 if (card->states[i] == NULL) {
2791 state = card->states[i] = (struct ali_state *) kmalloc(sizeof(struct ali_state), GFP_KERNEL);
2792 if (state == NULL)
2793 return -ENOMEM;
2794 memset(state, 0, sizeof(struct ali_state));
2795 dmabuf = &state->dmabuf;
2796 goto found_virt;
2797 }
2798 }
2799 card = card->next;
2800 }
2801
2802 /* no more virtual channel avaiable */
2803 if (!state)
2804 return -ENODEV;
2805 found_virt:
2806 /* initialize the virtual channel */
2807
2808 state->virt = i;
2809 state->card = card;
2810 state->magic = ALI5455_STATE_MAGIC;
2811 init_waitqueue_head(&dmabuf->wait);
2812 mutex_init(&state->open_mutex);
2813 file->private_data = state;
2814 dmabuf->trigger = 0;
2815 /* allocate hardware channels */
2816 if (file->f_mode & FMODE_READ) {
2817 if ((dmabuf->read_channel =
2818 card->alloc_rec_pcm_channel(card)) == NULL) {
2819 kfree(card->states[i]);
2820 card->states[i] = NULL;
2821 return -EBUSY;
2822 }
2823 dmabuf->trigger |= PCM_ENABLE_INPUT;
2824 ali_set_adc_rate(state, 8000);
2825 }
2826 if (file->f_mode & FMODE_WRITE) {
2827 if (codec_independent_spdif_locked > 0) {
2828 if ((dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card)) == NULL) {
2829 kfree(card->states[i]);
2830 card->states[i] = NULL;
2831 return -EBUSY;
2832 }
2833 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2834 ali_set_codecspdifout_rate(state, codec_independent_spdif_locked); //It must add
2835 i_scr = inl(state->card->iobase + ALI_SCR);
2836 if ((i_scr & 0x00300000) == 0x00100000) {
2837 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2838 } else {
2839 if ((i_scr & 0x00300000) == 0x00200000) {
2840 ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2841 } else {
2842 if ((i_scr & 0x00300000) == 0x00300000) {
2843 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2844 } else {
2845 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2846 }
2847 }
2848
2849 }
2850 } else {
2851 if (controller_independent_spdif_locked > 0) {
2852 if ((dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card)) == NULL) {
2853 kfree(card->states[i]);
2854 card->states[i] = NULL;
2855 return -EBUSY;
2856 }
2857 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2858 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2859 } else {
2860 if ((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
2861 kfree(card->states[i]);
2862 card->states[i] = NULL;
2863 return -EBUSY;
2864 }
2865 /* Initialize to 8kHz? What if we don't support 8kHz? */
2866 /* Let's change this to check for S/PDIF stuff */
2867
2868 dmabuf->trigger |= PCM_ENABLE_OUTPUT;
2869 if (codec_pcmout_share_spdif_locked) {
2870 ali_set_dac_rate(state, codec_pcmout_share_spdif_locked);
2871 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, codec_pcmout_share_spdif_locked);
2872 } else {
2873 ali_set_dac_rate(state, 8000);
2874 }
2875 }
2876
2877 }
2878 }
2879
2880 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
2881 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2882 /dev/dspW will accept 16-bits sample, but we don't support those so we
2883 set it immediately to stereo and 16bit, which is all we do support */
2884 dmabuf->fmt |= ALI5455_FMT_16BIT | ALI5455_FMT_STEREO;
2885 dmabuf->ossfragsize = 0;
2886 dmabuf->ossmaxfrags = 0;
2887 dmabuf->subdivision = 0;
2888 state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2889 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
2890 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
2891 return nonseekable_open(inode, file);
2892 }
2893
2894 static int ali_release(struct inode *inode, struct file *file)
2895 {
2896 struct ali_state *state = (struct ali_state *) file->private_data;
2897 struct ali_card *card = state->card;
2898 struct dmabuf *dmabuf = &state->dmabuf;
2899 unsigned long flags;
2900 lock_kernel();
2901
2902 /* stop DMA state machine and free DMA buffers/channels */
2903 if (dmabuf->trigger & PCM_ENABLE_OUTPUT)
2904 drain_dac(state, 0);
2905
2906 if (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)
2907 drain_spdifout(state, 0);
2908
2909 if (dmabuf->trigger & PCM_ENABLE_INPUT)
2910 stop_adc(state);
2911
2912 spin_lock_irqsave(&card->lock, flags);
2913 dealloc_dmabuf(state);
2914 if (file->f_mode & FMODE_WRITE) {
2915 if (codec_independent_spdif_locked > 0) {
2916 state->card->free_pcm_channel(state->card, dmabuf->codec_spdifout_channel->num);
2917 } else {
2918 if (controller_independent_spdif_locked > 0)
2919 state->card->free_pcm_channel(state->card,
2920 dmabuf->controller_spdifout_channel->num);
2921 else state->card->free_pcm_channel(state->card,
2922 dmabuf->write_channel->num);
2923 }
2924 }
2925 if (file->f_mode & FMODE_READ)
2926 state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
2927
2928 state->card->states[state->virt] = NULL;
2929 kfree(state);
2930 spin_unlock_irqrestore(&card->lock, flags);
2931 unlock_kernel();
2932 return 0;
2933 }
2934
2935 static /*const */ struct file_operations ali_audio_fops = {
2936 .owner = THIS_MODULE,
2937 .llseek = no_llseek,
2938 .read = ali_read,
2939 .write = ali_write,
2940 .poll = ali_poll,
2941 .ioctl = ali_ioctl,
2942 .mmap = ali_mmap,
2943 .open = ali_open,
2944 .release = ali_release,
2945 };
2946
2947 /* Read AC97 codec registers */
2948 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg)
2949 {
2950 struct ali_card *card = dev->private_data;
2951 int count1 = 100;
2952 char val;
2953 unsigned short int data = 0, count, addr1, addr2 = 0;
2954
2955 spin_lock(&card->ac97_lock);
2956 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2957 udelay(1);
2958
2959 addr1 = reg;
2960 reg |= 0x0080;
2961 for (count = 0; count < 0x7f; count++) {
2962 val = inb(card->iobase + ALI_CSPSR);
2963 if (val & 0x08)
2964 break;
2965 }
2966 if (count == 0x7f)
2967 {
2968 spin_unlock(&card->ac97_lock);
2969 return -1;
2970 }
2971 outw(reg, (card->iobase + ALI_CPR) + 2);
2972 for (count = 0; count < 0x7f; count++) {
2973 val = inb(card->iobase + ALI_CSPSR);
2974 if (val & 0x02) {
2975 data = inw(card->iobase + ALI_SPR);
2976 addr2 = inw((card->iobase + ALI_SPR) + 2);
2977 break;
2978 }
2979 }
2980 spin_unlock(&card->ac97_lock);
2981 if (count == 0x7f)
2982 return -1;
2983 if (addr2 != addr1)
2984 return -1;
2985 return ((u16) data);
2986 }
2987
2988 /* write ac97 codec register */
2989
2990 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
2991 {
2992 struct ali_card *card = dev->private_data;
2993 int count1 = 100;
2994 char val;
2995 unsigned short int count;
2996
2997 spin_lock(&card->ac97_lock);
2998 while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2999 udelay(1);
3000
3001 for (count = 0; count < 0x7f; count++) {
3002 val = inb(card->iobase + ALI_CSPSR);
3003 if (val & 0x08)
3004 break;
3005 }
3006 if (count == 0x7f) {
3007 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3008 spin_unlock(&card->ac97_lock);
3009 return;
3010 }
3011 outw(data, (card->iobase + ALI_CPR));
3012 outb(reg, (card->iobase + ALI_CPR) + 2);
3013 for (count = 0; count < 0x7f; count++) {
3014 val = inb(card->iobase + ALI_CSPSR);
3015 if (val & 0x01)
3016 break;
3017 }
3018 spin_unlock(&card->ac97_lock);
3019 if (count == 0x7f)
3020 printk(KERN_WARNING "ali_ac97_set: AC97 codec register access timed out. \n");
3021 return;
3022 }
3023
3024 /* OSS /dev/mixer file operation methods */
3025
3026 static int ali_open_mixdev(struct inode *inode, struct file *file)
3027 {
3028 int i;
3029 int minor = iminor(inode);
3030 struct ali_card *card = devs;
3031 for (card = devs; card != NULL; card = card->next) {
3032 /*
3033 * If we are initializing and then fail, card could go
3034 * away unuexpectedly while we are in the for() loop.
3035 * So, check for card on each iteration before we check
3036 * for card->initializing to avoid a possible oops.
3037 * This usually only matters for times when the driver is
3038 * autoloaded by kmod.
3039 */
3040 for (i = 0; i < 50 && card && card->initializing; i++) {
3041 set_current_state(TASK_UNINTERRUPTIBLE);
3042 schedule_timeout(HZ / 20);
3043 }
3044 for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
3045 if (card->ac97_codec[i] != NULL
3046 && card->ac97_codec[i]->dev_mixer == minor) {
3047 file->private_data = card->ac97_codec[i];
3048 return nonseekable_open(inode, file);
3049 }
3050 }
3051 return -ENODEV;
3052 }
3053
3054 static int ali_ioctl_mixdev(struct inode *inode,
3055 struct file *file,
3056 unsigned int cmd, unsigned long arg)
3057 {
3058 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
3059 return codec->mixer_ioctl(codec, cmd, arg);
3060 }
3061
3062 static /*const */ struct file_operations ali_mixer_fops = {
3063 .owner = THIS_MODULE,
3064 .llseek = no_llseek,
3065 .ioctl = ali_ioctl_mixdev,
3066 .open = ali_open_mixdev,
3067 };
3068
3069 /* AC97 codec initialisation. These small functions exist so we don't
3070 duplicate code between module init and apm resume */
3071
3072 static inline int ali_ac97_exists(struct ali_card *card, int ac97_number)
3073 {
3074 unsigned int i = 1;
3075 u32 reg = inl(card->iobase + ALI_RTSR);
3076 if (ac97_number) {
3077 while (i < 100) {
3078
3079 reg = inl(card->iobase + ALI_RTSR);
3080 if (reg & 0x40) {
3081 break;
3082 } else {
3083 outl(reg | 0x00000040,
3084 card->iobase + 0x34);
3085 udelay(1);
3086 }
3087 i++;
3088 }
3089
3090 } else {
3091 while (i < 100) {
3092 reg = inl(card->iobase + ALI_RTSR);
3093 if (reg & 0x80) {
3094 break;
3095 } else {
3096 outl(reg | 0x00000080,
3097 card->iobase + 0x34);
3098 udelay(1);
3099 }
3100 i++;
3101 }
3102 }
3103
3104 if (ac97_number)
3105 return reg & 0x40;
3106 else
3107 return reg & 0x80;
3108 }
3109
3110 static inline int ali_ac97_enable_variable_rate(struct ac97_codec *codec)
3111 {
3112 ali_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
3113 ali_ac97_set(codec, AC97_EXTENDED_STATUS, ali_ac97_get(codec, AC97_EXTENDED_STATUS) | 0xE800);
3114 return (ali_ac97_get(codec, AC97_EXTENDED_STATUS) & 1);
3115 }
3116
3117
3118 static int ali_ac97_probe_and_powerup(struct ali_card *card, struct ac97_codec *codec)
3119 {
3120 /* Returns 0 on failure */
3121 int i;
3122 u16 addr;
3123 if (ac97_probe_codec(codec) == 0)
3124 return 0;
3125 /* ac97_probe_codec is success ,then begin to init codec */
3126 ali_ac97_set(codec, AC97_RESET, 0xffff);
3127 if (card->channel[0].used == 1) {
3128 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3129 ali_ac97_set(codec, AC97_LINEIN_VOL, 0x0808);
3130 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3131 }
3132
3133 if (card->channel[2].used == 1) //if MICin then init codec
3134 {
3135 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3136 ali_ac97_set(codec, AC97_MIC_VOL, 0x8808);
3137 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3138 ali_ac97_set(codec, AC97_RECORD_GAIN_MIC, 0x0000);
3139 }
3140
3141 ali_ac97_set(codec, AC97_MASTER_VOL_STEREO, 0x0000);
3142 ali_ac97_set(codec, AC97_HEADPHONE_VOL, 0x0000);
3143 ali_ac97_set(codec, AC97_PCMOUT_VOL, 0x0000);
3144 ali_ac97_set(codec, AC97_CD_VOL, 0x0808);
3145 ali_ac97_set(codec, AC97_VIDEO_VOL, 0x0808);
3146 ali_ac97_set(codec, AC97_AUX_VOL, 0x0808);
3147 ali_ac97_set(codec, AC97_PHONE_VOL, 0x8048);
3148 ali_ac97_set(codec, AC97_PCBEEP_VOL, 0x0000);
3149 ali_ac97_set(codec, AC97_GENERAL_PURPOSE, AC97_GP_MIX);
3150 ali_ac97_set(codec, AC97_MASTER_VOL_MONO, 0x0000);
3151 ali_ac97_set(codec, 0x38, 0x0000);
3152 addr = ali_ac97_get(codec, 0x2a);
3153 ali_ac97_set(codec, 0x2a, addr | 0x0001);
3154 addr = ali_ac97_get(codec, 0x2a);
3155 addr = ali_ac97_get(codec, 0x28);
3156 ali_ac97_set(codec, 0x2c, 0xbb80);
3157 addr = ali_ac97_get(codec, 0x2c);
3158 /* power it all up */
3159 ali_ac97_set(codec, AC97_POWER_CONTROL,
3160 ali_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
3161 /* wait for analog ready */
3162 for (i = 10; i && ((ali_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--) {
3163 set_current_state(TASK_UNINTERRUPTIBLE);
3164 schedule_timeout(HZ / 20);
3165 }
3166 /* FIXME !! */
3167 i++;
3168 return i;
3169 }
3170
3171
3172 /* I clone ali5455(2.4.7 ) not clone i810_audio(2.4.18) */
3173
3174 static int ali_reset_5455(struct ali_card *card)
3175 {
3176 outl(0x80000003, card->iobase + ALI_SCR);
3177 outl(0x83838383, card->iobase + ALI_FIFOCR1);
3178 outl(0x83838383, card->iobase + ALI_FIFOCR2);
3179 if (controller_pcmout_share_spdif_locked > 0) {
3180 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3181 card->iobase + ALI_SPDIFICS);
3182 outl(0x0408000a, card->iobase + ALI_INTERFACECR);
3183 } else {
3184 if (codec_independent_spdif_locked > 0) {
3185 outl((inl(card->iobase + ALI_SCR) | 0x00100000), card->iobase + ALI_SCR); // now I select slot 7 & 8
3186 outl(0x00200000, card->iobase + ALI_INTERFACECR); //enable codec independent spdifout
3187 } else
3188 outl(0x04080002, card->iobase + ALI_INTERFACECR);
3189 }
3190
3191 outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
3192 outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
3193 if (controller_independent_spdif_locked > 0)
3194 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3195 card->iobase + ALI_SPDIFICS);
3196 return 1;
3197 }
3198
3199
3200 static int ali_ac97_random_init_stuff(struct ali_card
3201 *card)
3202 {
3203 u32 reg = inl(card->iobase + ALI_SCR);
3204 int i = 0;
3205 reg = inl(card->iobase + ALI_SCR);
3206 if ((reg & 2) == 0) /* Cold required */
3207 reg |= 2;
3208 else
3209 reg |= 1; /* Warm */
3210 reg &= ~0x80000000; /* ACLink on */
3211 outl(reg, card->iobase + ALI_SCR);
3212
3213 while (i < 10) {
3214 if ((inl(card->iobase + 0x18) & (1 << 1)) == 0)
3215 break;
3216 current->state = TASK_UNINTERRUPTIBLE;
3217 schedule_timeout(HZ / 20);
3218 i++;
3219 }
3220 if (i == 10) {
3221 printk(KERN_ERR "ali_audio: AC'97 reset failed.\n");
3222 return 0;
3223 }
3224
3225 set_current_state(TASK_UNINTERRUPTIBLE);
3226 schedule_timeout(HZ / 2);
3227 return 1;
3228 }
3229
3230 /* AC97 codec initialisation. */
3231
3232 static int __devinit ali_ac97_init(struct ali_card *card)
3233 {
3234 int num_ac97 = 0;
3235 int total_channels = 0;
3236 struct ac97_codec *codec;
3237 u16 eid;
3238
3239 if (!ali_ac97_random_init_stuff(card))
3240 return 0;
3241
3242 /* Number of channels supported */
3243 /* What about the codec? Just because the ICH supports */
3244 /* multiple channels doesn't mean the codec does. */
3245 /* we'll have to modify this in the codec section below */
3246 /* to reflect what the codec has. */
3247 /* ICH and ICH0 only support 2 channels so don't bother */
3248 /* to check.... */
3249 inl(card->iobase + ALI_CPR);
3250 card->channels = 2;
3251
3252 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3253
3254 /* Assume codec isn't available until we go through the
3255 * gauntlet below */
3256 card->ac97_codec[num_ac97] = NULL;
3257 /* The ICH programmer's reference says you should */
3258 /* check the ready status before probing. So we chk */
3259 /* What do we do if it's not ready? Wait and try */
3260 /* again, or abort? */
3261 if (!ali_ac97_exists(card, num_ac97)) {
3262 if (num_ac97 == 0)
3263 printk(KERN_ERR "ali_audio: Primary codec not ready.\n");
3264 break;
3265 }
3266
3267 if ((codec = ac97_alloc_codec()) == NULL)
3268 return -ENOMEM;
3269 /* initialize some basic codec information, other fields will be filled
3270 in ac97_probe_codec */
3271 codec->private_data = card;
3272 codec->id = num_ac97;
3273 codec->codec_read = ali_ac97_get;
3274 codec->codec_write = ali_ac97_set;
3275 if (!ali_ac97_probe_and_powerup(card, codec)) {
3276 printk(KERN_ERR "ali_audio: timed out waiting for codec %d analog ready",
3277 num_ac97);
3278 kfree(codec);
3279 break; /* it didn't work */
3280 }
3281
3282 /* Store state information about S/PDIF transmitter */
3283 card->ac97_status = 0;
3284 /* Don't attempt to get eid until powerup is complete */
3285 eid = ali_ac97_get(codec, AC97_EXTENDED_ID);
3286 if (eid == 0xFFFF) {
3287 printk(KERN_ERR "ali_audio: no codec attached ?\n");
3288 kfree(codec);
3289 break;
3290 }
3291
3292 card->ac97_features = eid;
3293 /* Now check the codec for useful features to make up for
3294 the dumbness of the ali5455 hardware engine */
3295 if (!(eid & 0x0001))
3296 printk(KERN_WARNING
3297 "ali_audio: only 48Khz playback available.\n");
3298 else {
3299 if (!ali_ac97_enable_variable_rate(codec)) {
3300 printk(KERN_WARNING
3301 "ali_audio: Codec refused to allow VRA, using 48Khz only.\n");
3302 card->ac97_features &= ~1;
3303 }
3304 }
3305
3306 /* Determine how many channels the codec(s) support */
3307 /* - The primary codec always supports 2 */
3308 /* - If the codec supports AMAP, surround DACs will */
3309 /* automaticlly get assigned to slots. */
3310 /* * Check for surround DACs and increment if */
3311 /* found. */
3312 /* - Else check if the codec is revision 2.2 */
3313 /* * If surround DACs exist, assign them to slots */
3314 /* and increment channel count. */
3315
3316 /* All of this only applies to ICH2 and above. ICH */
3317 /* and ICH0 only support 2 channels. ICH2 will only */
3318 /* support multiple codecs in a "split audio" config. */
3319 /* as described above. */
3320
3321 /* TODO: Remove all the debugging messages! */
3322
3323 if ((eid & 0xc000) == 0) /* primary codec */
3324 total_channels += 2;
3325 if ((codec->dev_mixer = register_sound_mixer(&ali_mixer_fops, -1)) < 0) {
3326 printk(KERN_ERR "ali_audio: couldn't register mixer!\n");
3327 kfree(codec);
3328 break;
3329 }
3330 card->ac97_codec[num_ac97] = codec;
3331 }
3332 /* pick the minimum of channels supported by ICHx or codec(s) */
3333 card->channels = (card->channels > total_channels) ? total_channels : card->channels;
3334 return num_ac97;
3335 }
3336
3337 static void __devinit ali_configure_clocking(void)
3338 {
3339 struct ali_card *card;
3340 struct ali_state *state;
3341 struct dmabuf *dmabuf;
3342 unsigned int i, offset, new_offset;
3343 unsigned long flags;
3344 card = devs;
3345
3346 /* We could try to set the clocking for multiple cards, but can you even have
3347 * more than one ali in a machine? Besides, clocking is global, so unless
3348 * someone actually thinks more than one ali in a machine is possible and
3349 * decides to rewrite that little bit, setting the rate for more than one card
3350 * is a waste of time.
3351 */
3352 if (card != NULL) {
3353 state = card->states[0] = (struct ali_state *)
3354 kmalloc(sizeof(struct ali_state), GFP_KERNEL);
3355 if (state == NULL)
3356 return;
3357 memset(state, 0, sizeof(struct ali_state));
3358 dmabuf = &state->dmabuf;
3359 dmabuf->write_channel = card->alloc_pcm_channel(card);
3360 state->virt = 0;
3361 state->card = card;
3362 state->magic = ALI5455_STATE_MAGIC;
3363 init_waitqueue_head(&dmabuf->wait);
3364 mutex_init(&state->open_mutex);
3365 dmabuf->fmt = ALI5455_FMT_STEREO | ALI5455_FMT_16BIT;
3366 dmabuf->trigger = PCM_ENABLE_OUTPUT;
3367 ali_set_dac_rate(state, 48000);
3368 if (prog_dmabuf(state, 0) != 0)
3369 goto config_out_nodmabuf;
3370
3371 if (dmabuf->dmasize < 16384)
3372 goto config_out;
3373
3374 dmabuf->count = dmabuf->dmasize;
3375 outb(31, card->iobase + dmabuf->write_channel->port + OFF_LVI);
3376
3377 local_irq_save(flags);
3378 start_dac(state);
3379 offset = ali_get_dma_addr(state, 0);
3380 mdelay(50);
3381 new_offset = ali_get_dma_addr(state, 0);
3382 stop_dac(state);
3383
3384 outb(2, card->iobase + dmabuf->write_channel->port + OFF_CR);
3385 local_irq_restore(flags);
3386
3387 i = new_offset - offset;
3388
3389 if (i == 0)
3390 goto config_out;
3391 i = i / 4 * 20;
3392 if (i > 48500 || i < 47500) {
3393 clocking = clocking * clocking / i;
3394 }
3395 config_out:
3396 dealloc_dmabuf(state);
3397 config_out_nodmabuf:
3398 state->card->free_pcm_channel(state->card, state->dmabuf. write_channel->num);
3399 kfree(state);
3400 card->states[0] = NULL;
3401 }
3402 }
3403
3404 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3405 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3406
3407 static int __devinit ali_probe(struct pci_dev *pci_dev,
3408 const struct pci_device_id *pci_id)
3409 {
3410 struct ali_card *card;
3411 if (pci_enable_device(pci_dev))
3412 return -EIO;
3413 if (pci_set_dma_mask(pci_dev, ALI5455_DMA_MASK)) {
3414 printk(KERN_ERR "ali5455: architecture does not support"
3415 " 32bit PCI busmaster DMA\n");
3416 return -ENODEV;
3417 }
3418
3419 if ((card = kmalloc(sizeof(struct ali_card), GFP_KERNEL)) == NULL) {
3420 printk(KERN_ERR "ali_audio: out of memory\n");
3421 return -ENOMEM;
3422 }
3423 memset(card, 0, sizeof(*card));
3424 card->initializing = 1;
3425 card->iobase = pci_resource_start(pci_dev, 0);
3426 card->pci_dev = pci_dev;
3427 card->pci_id = pci_id->device;
3428 card->irq = pci_dev->irq;
3429 card->next = devs;
3430 card->magic = ALI5455_CARD_MAGIC;
3431 #ifdef CONFIG_PM
3432 card->pm_suspended = 0;
3433 #endif
3434 spin_lock_init(&card->lock);
3435 spin_lock_init(&card->ac97_lock);
3436 devs = card;
3437 pci_set_master(pci_dev);
3438 printk(KERN_INFO "ali: %s found at IO 0x%04lx, IRQ %d\n",
3439 card_names[pci_id->driver_data], card->iobase, card->irq);
3440 card->alloc_pcm_channel = ali_alloc_pcm_channel;
3441 card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
3442 card->alloc_rec_mic_channel = ali_alloc_rec_mic_channel;
3443 card->alloc_codec_spdifout_channel = ali_alloc_codec_spdifout_channel;
3444 card->alloc_controller_spdifout_channel = ali_alloc_controller_spdifout_channel;
3445 card->free_pcm_channel = ali_free_pcm_channel;
3446 card->channel[0].offset = 0;
3447 card->channel[0].port = 0x40;
3448 card->channel[0].num = 0;
3449 card->channel[1].offset = 0;
3450 card->channel[1].port = 0x50;
3451 card->channel[1].num = 1;
3452 card->channel[2].offset = 0;
3453 card->channel[2].port = 0x60;
3454 card->channel[2].num = 2;
3455 card->channel[3].offset = 0;
3456 card->channel[3].port = 0x70;
3457 card->channel[3].num = 3;
3458 card->channel[4].offset = 0;
3459 card->channel[4].port = 0xb0;
3460 card->channel[4].num = 4;
3461 /* claim our iospace and irq */
3462 request_region(card->iobase, 256, card_names[pci_id->driver_data]);
3463 if (request_irq(card->irq, &ali_interrupt, IRQF_SHARED,
3464 card_names[pci_id->driver_data], card)) {
3465 printk(KERN_ERR "ali_audio: unable to allocate irq %d\n",
3466 card->irq);
3467 release_region(card->iobase, 256);
3468 kfree(card);
3469 return -ENODEV;
3470 }
3471
3472 if (ali_reset_5455(card) <= 0) {
3473 unregister_sound_dsp(card->dev_audio);
3474 release_region(card->iobase, 256);
3475 free_irq(card->irq, card);
3476 kfree(card);
3477 return -ENODEV;
3478 }
3479
3480 /* initialize AC97 codec and register /dev/mixer */
3481 if (ali_ac97_init(card) < 0) {
3482 release_region(card->iobase, 256);
3483 free_irq(card->irq, card);
3484 kfree(card);
3485 return -ENODEV;
3486 }
3487
3488 pci_set_drvdata(pci_dev, card);
3489
3490 if (clocking == 0) {
3491 clocking = 48000;
3492 ali_configure_clocking();
3493 }
3494
3495 /* register /dev/dsp */
3496 if ((card->dev_audio = register_sound_dsp(&ali_audio_fops, -1)) < 0) {
3497 int i;
3498 printk(KERN_ERR"ali_audio: couldn't register DSP device!\n");
3499 release_region(card->iobase, 256);
3500 free_irq(card->irq, card);
3501 for (i = 0; i < NR_AC97; i++)
3502 if (card->ac97_codec[i] != NULL) {
3503 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3504 kfree(card->ac97_codec[i]);
3505 }
3506 kfree(card);
3507 return -ENODEV;
3508 }
3509 card->initializing = 0;
3510 return 0;
3511 }
3512
3513 static void __devexit ali_remove(struct pci_dev *pci_dev)
3514 {
3515 int i;
3516 struct ali_card *card = pci_get_drvdata(pci_dev);
3517 /* free hardware resources */
3518 free_irq(card->irq, devs);
3519 release_region(card->iobase, 256);
3520 /* unregister audio devices */
3521 for (i = 0; i < NR_AC97; i++)
3522 if (card->ac97_codec[i] != NULL) {
3523 unregister_sound_mixer(card->ac97_codec[i]->
3524 dev_mixer);
3525 ac97_release_codec(card->ac97_codec[i]);
3526 card->ac97_codec[i] = NULL;
3527 }
3528 unregister_sound_dsp(card->dev_audio);
3529 kfree(card);
3530 }
3531
3532 #ifdef CONFIG_PM
3533 static int ali_pm_suspend(struct pci_dev *dev, pm_message_t pm_state)
3534 {
3535 struct ali_card *card = pci_get_drvdata(dev);
3536 struct ali_state *state;
3537 unsigned long flags;
3538 struct dmabuf *dmabuf;
3539 int i, num_ac97;
3540
3541 if (!card)
3542 return 0;
3543 spin_lock_irqsave(&card->lock, flags);
3544 card->pm_suspended = 1;
3545 for (i = 0; i < NR_HW_CH; i++) {
3546 state = card->states[i];
3547 if (!state)
3548 continue;
3549 /* this happens only if there are open files */
3550 dmabuf = &state->dmabuf;
3551 if (dmabuf->enable & DAC_RUNNING ||
3552 (dmabuf->count
3553 && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
3554 state->pm_saved_dac_rate = dmabuf->rate;
3555 stop_dac(state);
3556 } else {
3557 state->pm_saved_dac_rate = 0;
3558 }
3559 if (dmabuf->enable & ADC_RUNNING) {
3560 state->pm_saved_adc_rate = dmabuf->rate;
3561 stop_adc(state);
3562 } else {
3563 state->pm_saved_adc_rate = 0;
3564 }
3565 dmabuf->ready = 0;
3566 dmabuf->swptr = dmabuf->hwptr = 0;
3567 dmabuf->count = dmabuf->total_bytes = 0;
3568 }
3569
3570 spin_unlock_irqrestore(&card->lock, flags);
3571 /* save mixer settings */
3572 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3573 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3574 if (!codec)
3575 continue;
3576 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3577 if ((supported_mixer(codec, i)) && (codec->read_mixer)) {
3578 card->pm_saved_mixer_settings[i][num_ac97] = codec->read_mixer(codec, i);
3579 }
3580 }
3581 }
3582 pci_save_state(dev); /* XXX do we need this? */
3583 pci_disable_device(dev); /* disable busmastering */
3584 pci_set_power_state(dev, 3); /* Zzz. */
3585 return 0;
3586 }
3587
3588
3589 static int ali_pm_resume(struct pci_dev *dev)
3590 {
3591 int num_ac97, i = 0;
3592 struct ali_card *card = pci_get_drvdata(dev);
3593 pci_enable_device(dev);
3594 pci_restore_state(dev);
3595 /* observation of a toshiba portege 3440ct suggests that the
3596 hardware has to be more or less completely reinitialized from
3597 scratch after an apm suspend. Works For Me. -dan */
3598 ali_ac97_random_init_stuff(card);
3599 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3600 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3601 /* check they haven't stolen the hardware while we were
3602 away */
3603 if (!codec || !ali_ac97_exists(card, num_ac97)) {
3604 if (num_ac97)
3605 continue;
3606 else
3607 BUG();
3608 }
3609 if (!ali_ac97_probe_and_powerup(card, codec))
3610 BUG();
3611 if ((card->ac97_features & 0x0001)) {
3612 /* at probe time we found we could do variable
3613 rates, but APM suspend has made it forget
3614 its magical powers */
3615 if (!ali_ac97_enable_variable_rate(codec))
3616 BUG();
3617 }
3618 /* we lost our mixer settings, so restore them */
3619 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3620 if (supported_mixer(codec, i)) {
3621 int val = card->pm_saved_mixer_settings[i][num_ac97];
3622 codec->mixer_state[i] = val;
3623 codec->write_mixer(codec, i,
3624 (val & 0xff),
3625 ((val >> 8) & 0xff));
3626 }
3627 }
3628 }
3629
3630 /* we need to restore the sample rate from whatever it was */
3631 for (i = 0; i < NR_HW_CH; i++) {
3632 struct ali_state *state = card->states[i];
3633 if (state) {
3634 if (state->pm_saved_adc_rate)
3635 ali_set_adc_rate(state, state->pm_saved_adc_rate);
3636 if (state->pm_saved_dac_rate)
3637 ali_set_dac_rate(state, state->pm_saved_dac_rate);
3638 }
3639 }
3640
3641 card->pm_suspended = 0;
3642 /* any processes that were reading/writing during the suspend
3643 probably ended up here */
3644 for (i = 0; i < NR_HW_CH; i++) {
3645 struct ali_state *state = card->states[i];
3646 if (state)
3647 wake_up(&state->dmabuf.wait);
3648 }
3649 return 0;
3650 }
3651 #endif /* CONFIG_PM */
3652
3653 MODULE_AUTHOR("");
3654 MODULE_DESCRIPTION("ALI 5455 audio support");
3655 MODULE_LICENSE("GPL");
3656 module_param(clocking, int, 0);
3657 /* FIXME: bool? */
3658 module_param(strict_clocking, uint, 0);
3659 module_param(codec_pcmout_share_spdif_locked, uint, 0);
3660 module_param(codec_independent_spdif_locked, uint, 0);
3661 module_param(controller_pcmout_share_spdif_locked, uint, 0);
3662 module_param(controller_independent_spdif_locked, uint, 0);
3663 #define ALI5455_MODULE_NAME "ali5455"
3664 static struct pci_driver ali_pci_driver = {
3665 .name = ALI5455_MODULE_NAME,
3666 .id_table = ali_pci_tbl,
3667 .probe = ali_probe,
3668 .remove = __devexit_p(ali_remove),
3669 #ifdef CONFIG_PM
3670 .suspend = ali_pm_suspend,
3671 .resume = ali_pm_resume,
3672 #endif /* CONFIG_PM */
3673 };
3674
3675 static int __init ali_init_module(void)
3676 {
3677 printk(KERN_INFO "ALI 5455 + AC97 Audio, version "
3678 DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
3679
3680 if (codec_independent_spdif_locked > 0) {
3681 if (codec_independent_spdif_locked == 32000
3682 || codec_independent_spdif_locked == 44100
3683 || codec_independent_spdif_locked == 48000) {
3684 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_independent_spdif_locked);
3685 } else {
3686 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3687 codec_independent_spdif_locked = 0;
3688 }
3689 }
3690 if (controller_independent_spdif_locked > 0) {
3691 if (controller_independent_spdif_locked == 32000
3692 || controller_independent_spdif_locked == 44100
3693 || controller_independent_spdif_locked == 48000) {
3694 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", controller_independent_spdif_locked);
3695 } else {
3696 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3697 controller_independent_spdif_locked = 0;
3698 }
3699 }
3700
3701 if (codec_pcmout_share_spdif_locked > 0) {
3702 if (codec_pcmout_share_spdif_locked == 32000
3703 || codec_pcmout_share_spdif_locked == 44100
3704 || codec_pcmout_share_spdif_locked == 48000) {
3705 printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_pcmout_share_spdif_locked);
3706 } else {
3707 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3708 codec_pcmout_share_spdif_locked = 0;
3709 }
3710 }
3711 if (controller_pcmout_share_spdif_locked > 0) {
3712 if (controller_pcmout_share_spdif_locked == 32000
3713 || controller_pcmout_share_spdif_locked == 44100
3714 || controller_pcmout_share_spdif_locked == 48000) {
3715 printk(KERN_INFO "ali_audio: Enabling controller S/PDIF at sample rate %dHz.\n", controller_pcmout_share_spdif_locked);
3716 } else {
3717 printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3718 controller_pcmout_share_spdif_locked = 0;
3719 }
3720 }
3721 return pci_register_driver(&ali_pci_driver);
3722 }
3723
3724 static void __exit ali_cleanup_module(void)
3725 {
3726 pci_unregister_driver(&ali_pci_driver);
3727 }
3728
3729 module_init(ali_init_module);
3730 module_exit(ali_cleanup_module);
3731 /*
3732 Local Variables:
3733 c-basic-offset: 8
3734 End:
3735 */
USB Experimental Work