drivers/sound/ali5455.c

   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 seperated 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/version.h>
  51 #include <linux/string.h>
  52 #include <linux/ctype.h>
  53 #include <linux/ioport.h>
  54 #include <linux/sched.h>
  55 #include <linux/delay.h>
  56 #include <linux/sound.h>
  57 #include <linux/slab.h>
  58 #include <linux/soundcard.h>
  59 #include <linux/pci.h>
  60 #include <asm/io.h>
  61 #include <asm/dma.h>
  62 #include <linux/init.h>
  63 #include <linux/poll.h>
  64 #include <linux/spinlock.h>
  65 #include <linux/smp_lock.h>
  66 #include <linux/ac97_codec.h>
  67 #include <linux/wrapper.h>
  68 #include <asm/uaccess.h>
  69 #include <asm/hardirq.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            seperately 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 seperate 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[] __initdata = {
 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 semaphore open_sem;
 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
 310         /* PCI device stuff */
 311         struct pci_dev *pci_dev;
 312         u16 pci_id;
 313 #ifdef CONFIG_PM
 314         u16 pm_suspended;
 315         u32 pm_save_state[64 / sizeof(u32)];
 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 seperately */
 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_page_range doesn't do what we want */
 939         pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
 940         for (page = virt_to_page(rawbuf); page <= pend; page++)
 941                 mem_map_reserve(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                         mem_map_unreserve(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         ali_update_ptr(state);
1257         // catch underruns during playback
1258         if (dmabuf->count < 0) {
1259                 dmabuf->count = 0;
1260                 dmabuf->swptr = dmabuf->hwptr;
1261         }
1262         free = dmabuf->dmasize - dmabuf->count;
1263         free -= (dmabuf->hwptr % dmabuf->fragsize);
1264         if (free < 0)
1265                 return (0);
1266         return (free);
1267 }
1268
1269 static inline int ali_get_available_read_data(struct
1270                                               ali_state
1271                                               *state)
1272 {
1273         struct dmabuf *dmabuf = &state->dmabuf;
1274         int avail;
1275         ali_update_ptr(state);
1276         // catch overruns during record
1277         if (dmabuf->count > dmabuf->dmasize) {
1278                 dmabuf->count = dmabuf->dmasize;
1279                 dmabuf->swptr = dmabuf->hwptr;
1280         }
1281         avail = dmabuf->count;
1282         avail -= (dmabuf->hwptr % dmabuf->fragsize);
1283         if (avail < 0)
1284                 return (0);
1285         return (avail);
1286 }
1287
1288 static int drain_dac(struct ali_state *state, int signals_allowed)
1289 {
1290
1291         DECLARE_WAITQUEUE(wait, current);
1292         struct dmabuf *dmabuf = &state->dmabuf;
1293         unsigned long flags;
1294         unsigned long tmo;
1295         int count;
1296         if (!dmabuf->ready)
1297                 return 0;
1298         if (dmabuf->mapped) {
1299                 stop_dac(state);
1300                 return 0;
1301         }
1302         add_wait_queue(&dmabuf->wait, &wait);
1303         for (;;) {
1304
1305                 spin_lock_irqsave(&state->card->lock, flags);
1306                 ali_update_ptr(state);
1307                 count = dmabuf->count;
1308                 spin_unlock_irqrestore(&state->card->lock, flags);
1309                 if (count <= 0)
1310                         break;
1311                 /*
1312                  * This will make sure that our LVI is correct, that our
1313                  * pointer is updated, and that the DAC is running.  We
1314                  * have to force the setting of dmabuf->trigger to avoid
1315                  * any possible deadlocks.
1316                  */
1317                 if (!dmabuf->enable) {
1318                         dmabuf->trigger = PCM_ENABLE_OUTPUT;
1319                         ali_update_lvi(state, 0);
1320                 }
1321                 if (signal_pending(current) && signals_allowed) {
1322                         break;
1323                 }
1324
1325                 /* It seems that we have to set the current state to
1326                  * TASK_INTERRUPTIBLE every time to make the process
1327                  * really go to sleep.  This also has to be *after* the
1328                  * update_ptr() call because update_ptr is likely to
1329                  * do a wake_up() which will unset this before we ever
1330                  * try to sleep, resuling in a tight loop in this code
1331                  * instead of actually sleeping and waiting for an
1332                  * interrupt to wake us up!
1333                  */
1334                 set_current_state(TASK_INTERRUPTIBLE);
1335                 /*
1336                  * set the timeout to significantly longer than it *should*
1337                  * take for the DAC to drain the DMA buffer
1338                  */
1339                 tmo = (count * HZ) / (dmabuf->rate);
1340                 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1341                         printk(KERN_ERR "ali_audio: drain_dac, dma timeout?\n");
1342                         count = 0;
1343                         break;
1344                 }
1345         }
1346         set_current_state(TASK_RUNNING);
1347         remove_wait_queue(&dmabuf->wait, &wait);
1348         if (count > 0 && signal_pending(current) && signals_allowed)
1349                 return -ERESTARTSYS;
1350         stop_dac(state);
1351         return 0;
1352 }
1353
1354
1355 static int drain_spdifout(struct ali_state *state, int signals_allowed)
1356 {
1357
1358         DECLARE_WAITQUEUE(wait, current);
1359         struct dmabuf *dmabuf = &state->dmabuf;
1360         unsigned long flags;
1361         unsigned long tmo;
1362         int count;
1363         if (!dmabuf->ready)
1364                 return 0;
1365         if (dmabuf->mapped) {
1366                 stop_spdifout(state);
1367                 return 0;
1368         }
1369         add_wait_queue(&dmabuf->wait, &wait);
1370         for (;;) {
1371
1372                 spin_lock_irqsave(&state->card->lock, flags);
1373                 ali_update_ptr(state);
1374                 count = dmabuf->count;
1375                 spin_unlock_irqrestore(&state->card->lock, flags);
1376                 if (count <= 0)
1377                         break;
1378                 /*
1379                  * This will make sure that our LVI is correct, that our
1380                  * pointer is updated, and that the DAC is running.  We
1381                  * have to force the setting of dmabuf->trigger to avoid
1382                  * any possible deadlocks.
1383                  */
1384                 if (!dmabuf->enable) {
1385                         if (codec_independent_spdif_locked > 0) {
1386                                 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1387                                 ali_update_lvi(state, 2);
1388                         } else {
1389                                 if (controller_independent_spdif_locked > 0) {
1390                                         dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1391                                         ali_update_lvi(state, 3);
1392                                 }
1393                         }
1394                 }
1395                 if (signal_pending(current) && signals_allowed) {
1396                         break;
1397                 }
1398
1399                 /* It seems that we have to set the current state to
1400                  * TASK_INTERRUPTIBLE every time to make the process
1401                  * really go to sleep.  This also has to be *after* the
1402                  * update_ptr() call because update_ptr is likely to
1403                  * do a wake_up() which will unset this before we ever
1404                  * try to sleep, resuling in a tight loop in this code
1405                  * instead of actually sleeping and waiting for an
1406                  * interrupt to wake us up!
1407                  */
1408                 set_current_state(TASK_INTERRUPTIBLE);
1409                 /*
1410                  * set the timeout to significantly longer than it *should*
1411                  * take for the DAC to drain the DMA buffer
1412                  */
1413                 tmo = (count * HZ) / (dmabuf->rate);
1414                 if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1415                         printk(KERN_ERR "ali_audio: drain_spdifout, dma timeout?\n");
1416                         count = 0;
1417                         break;
1418                 }
1419         }
1420         set_current_state(TASK_RUNNING);
1421         remove_wait_queue(&dmabuf->wait, &wait);
1422         if (count > 0 && signal_pending(current) && signals_allowed)
1423                 return -ERESTARTSYS;
1424         stop_spdifout(state);
1425         return 0;
1426 }
1427
1428 static void ali_channel_interrupt(struct ali_card *card)
1429 {
1430         int i, count;
1431
1432         for (i = 0; i < NR_HW_CH; i++) {
1433                 struct ali_state *state = card->states[i];
1434                 struct ali_channel *c = NULL;
1435                 struct dmabuf *dmabuf;
1436                 unsigned long port = card->iobase;
1437                 u16 status;
1438                 if (!state)
1439                         continue;
1440                 if (!state->dmabuf.ready)
1441                         continue;
1442                 dmabuf = &state->dmabuf;
1443                 if (codec_independent_spdif_locked > 0) {
1444                         if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
1445                                 c = dmabuf->codec_spdifout_channel;
1446                         }
1447                 } else {
1448                         if (controller_independent_spdif_locked > 0) {
1449                                 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1450                                         c = dmabuf->controller_spdifout_channel;
1451                         } else {
1452                                 if (dmabuf->enable & DAC_RUNNING) {
1453                                         c = dmabuf->write_channel;
1454                                 } else if (dmabuf->enable & ADC_RUNNING) {
1455                                         c = dmabuf->read_channel;
1456                                 } else
1457                                         continue;
1458                         }
1459                 }
1460                 port += c->port;
1461
1462                 status = inw(port + OFF_SR);
1463
1464                 if (status & DMA_INT_COMPLETE) {
1465                         /* only wake_up() waiters if this interrupt signals
1466                          * us being beyond a userfragsize of data open or
1467                          * available, and ali_update_ptr() does that for
1468                          * us
1469                          */
1470                         ali_update_ptr(state);
1471                 }
1472
1473                 if (status & DMA_INT_LVI) {
1474                         ali_update_ptr(state);
1475                         wake_up(&dmabuf->wait);
1476
1477                         if (dmabuf->enable & DAC_RUNNING)
1478                                 count = dmabuf->count;
1479                         else if (dmabuf->enable & ADC_RUNNING)
1480                                 count = dmabuf->dmasize - dmabuf->count;
1481                         else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1482                                 count = dmabuf->count;
1483                         else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1484                                 count = dmabuf->count;
1485                         else count = 0;
1486
1487                         if (count > 0) {
1488                                 if (dmabuf->enable & DAC_RUNNING)
1489                                         outl((1 << 1), state->card->iobase + ALI_DMACR);
1490                                 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1491                                                 outl((1 << 3), state->card->iobase + ALI_DMACR);
1492                                 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1493                                         outl((1 << 7), state->card->iobase + ALI_DMACR);
1494                         } else {
1495                                 if (dmabuf->enable & DAC_RUNNING)
1496                                         __stop_dac(state);
1497                                 if (dmabuf->enable & ADC_RUNNING)
1498                                         __stop_adc(state);
1499                                 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1500                                         __stop_spdifout(state);
1501                                 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1502                                         __stop_spdifout(state);
1503                                 dmabuf->enable = 0;
1504                                 wake_up(&dmabuf->wait);
1505                         }
1506
1507                 }
1508                 if (!(status & DMA_INT_DCH)) {
1509                         ali_update_ptr(state);
1510                         wake_up(&dmabuf->wait);
1511                         if (dmabuf->enable & DAC_RUNNING)
1512                                 count = dmabuf->count;
1513                         else if (dmabuf->enable & ADC_RUNNING)
1514                                 count = dmabuf->dmasize - dmabuf->count;
1515                         else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1516                                 count = dmabuf->count;
1517                         else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1518                                 count = dmabuf->count;
1519                         else
1520                                 count = 0;
1521
1522                         if (count > 0) {
1523                                 if (dmabuf->enable & DAC_RUNNING)
1524                                         outl((1 << 1), state->card->iobase + ALI_DMACR);
1525                                 else if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1526                                         outl((1 << 3), state->card->iobase + ALI_DMACR);
1527                                 else if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1528                                         outl((1 << 7), state->card->iobase + ALI_DMACR);
1529                         } else {
1530                                 if (dmabuf->enable & DAC_RUNNING)
1531                                         __stop_dac(state);
1532                                 if (dmabuf->enable & ADC_RUNNING)
1533                                         __stop_adc(state);
1534                                 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING)
1535                                         __stop_spdifout(state);
1536                                 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)
1537                                         __stop_spdifout(state);
1538                                 dmabuf->enable = 0;
1539                                 wake_up(&dmabuf->wait);
1540                         }
1541                 }
1542                 outw(status & DMA_INT_MASK, port + OFF_SR);
1543         }
1544 }
1545
1546 static void ali_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1547 {
1548         struct ali_card *card = (struct ali_card *) dev_id;
1549         u32 status;
1550         u16 status2;
1551
1552         spin_lock(&card->lock);
1553         status = inl(card->iobase + ALI_INTERRUPTSR);
1554         if (!(status & INT_MASK)) {
1555                 spin_unlock(&card->lock);
1556                 return;         /* not for us */
1557         }
1558
1559         if (codec_independent_spdif_locked > 0) {
1560                 if (globel == 0) {
1561                         globel += 1;
1562                         status2 = inw(card->iobase + 0x76);
1563                         outw(status2 | 0x000c, card->iobase + 0x76);
1564                 } else {
1565                         if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1566                                 ali_channel_interrupt(card);
1567                 }
1568         } else {
1569                 if (status & (INT_PCMOUT | INT_PCMIN | INT_MICIN | INT_SPDIFOUT | INT_CODECSPDIFOUT))
1570                         ali_channel_interrupt(card);
1571         }
1572
1573         /* clear 'em */
1574         outl(status & INT_MASK, card->iobase + ALI_INTERRUPTSR);
1575         spin_unlock(&card->lock);
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 *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 : 0;
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 (ppos != &file->f_pos)
1597                 return -ESPIPE;
1598         if (dmabuf->mapped)
1599                 return -ENXIO;
1600         if (dmabuf->enable & DAC_RUNNING)
1601                 return -ENODEV;
1602         if (!dmabuf->read_channel) {
1603                 dmabuf->ready = 0;
1604                 dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
1605                 if (!dmabuf->read_channel) {
1606                         return -EBUSY;
1607                 }
1608         }
1609         if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
1610                 return ret;
1611         if (!access_ok(VERIFY_WRITE, buffer, count))
1612                 return -EFAULT;
1613         ret = 0;
1614         add_wait_queue(&dmabuf->wait, &waita);
1615         while (count > 0) {
1616                 set_current_state(TASK_INTERRUPTIBLE);
1617                 spin_lock_irqsave(&card->lock, flags);
1618                 if (PM_SUSPENDED(card)) {
1619                         spin_unlock_irqrestore(&card->lock, flags);
1620                         schedule();
1621                         if (signal_pending(current)) {
1622                                 if (!ret)
1623                                         ret = -EAGAIN;
1624                                 break;
1625                         }
1626                         continue;
1627                 }
1628                 swptr = dmabuf->swptr;
1629                 cnt = ali_get_available_read_data(state);
1630                 // this is to make the copy_to_user simpler below
1631                 if (cnt > (dmabuf->dmasize - swptr))
1632                         cnt = dmabuf->dmasize - swptr;
1633                 spin_unlock_irqrestore(&card->lock, flags);
1634                 if (cnt > count)
1635                         cnt = count;
1636                 /* Lop off the last two bits to force the code to always
1637                  * write in full samples.  This keeps software that sets
1638                  * O_NONBLOCK but doesn't check the return value of the
1639                  * write call from getting things out of state where they
1640                  * think a full 4 byte sample was written when really only
1641                  * a portion was, resulting in odd sound and stereo
1642                  * hysteresis.
1643                  */
1644                 cnt &= ~0x3;
1645                 if (cnt <= 0) {
1646                         unsigned long tmo;
1647                         /*
1648                          * Don't let us deadlock.  The ADC won't start if
1649                          * dmabuf->trigger isn't set.  A call to SETTRIGGER
1650                          * could have turned it off after we set it to on
1651                          * previously.
1652                          */
1653                         dmabuf->trigger = PCM_ENABLE_INPUT;
1654                         /*
1655                          * This does three things.  Updates LVI to be correct,
1656                          * makes sure the ADC is running, and updates the
1657                          * hwptr.
1658                          */
1659                         ali_update_lvi(state, 1);
1660                         if (file->f_flags & O_NONBLOCK) {
1661                                 if (!ret)
1662                                         ret = -EAGAIN;
1663                                 goto done;
1664                         }
1665                         /* Set the timeout to how long it would take to fill
1666                          * two of our buffers.  If we haven't been woke up
1667                          * by then, then we know something is wrong.
1668                          */
1669                         tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1670
1671                         /* There are two situations when sleep_on_timeout returns, one is when
1672                            the interrupt is serviced correctly and the process is waked up by
1673                            ISR ON TIME. Another is when timeout is expired, which means that
1674                            either interrupt is NOT serviced correctly (pending interrupt) or it
1675                            is TOO LATE for the process to be scheduled to run (scheduler latency)
1676                            which results in a (potential) buffer overrun. And worse, there is
1677                            NOTHING we can do to prevent it. */
1678                         if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
1679                                 printk(KERN_ERR
1680                                        "ali_audio: recording schedule timeout, "
1681                                        "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1682                                        dmabuf->dmasize, dmabuf->fragsize,
1683                                        dmabuf->count, dmabuf->hwptr,
1684                                        dmabuf->swptr);
1685                                 /* a buffer overrun, we delay the recovery until next time the
1686                                    while loop begin and we REALLY have space to record */
1687                         }
1688                         if (signal_pending(current)) {
1689                                 ret = ret ? ret : -ERESTARTSYS;
1690                                 goto done;
1691                         }
1692                         continue;
1693                 }
1694
1695                 if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
1696                         if (!ret)
1697                                 ret = -EFAULT;
1698                         goto done;
1699                 }
1700
1701                 swptr = (swptr + cnt) % dmabuf->dmasize;
1702                 spin_lock_irqsave(&card->lock, flags);
1703                 if (PM_SUSPENDED(card)) {
1704                         spin_unlock_irqrestore(&card->lock, flags);
1705                         continue;
1706                 }
1707                 dmabuf->swptr = swptr;
1708                 dmabuf->count -= cnt;
1709                 spin_unlock_irqrestore(&card->lock, flags);
1710                 count -= cnt;
1711                 buffer += cnt;
1712                 ret += cnt;
1713         }
1714 done:
1715         ali_update_lvi(state, 1);
1716         set_current_state(TASK_RUNNING);
1717         remove_wait_queue(&dmabuf->wait, &waita);
1718         return ret;
1719 }
1720
1721 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
1722    the soundcard.  it is drained by the dma machine and filled by this loop. */
1723 static ssize_t ali_write(struct file *file,
1724                          const char *buffer, size_t count, loff_t * ppos)
1725 {
1726         struct ali_state *state = (struct ali_state *) file->private_data;
1727         struct ali_card *card = state ? state->card : 0;
1728         struct dmabuf *dmabuf = &state->dmabuf;
1729         ssize_t ret;
1730         unsigned long flags;
1731         unsigned int swptr = 0;
1732         int cnt, x;
1733         DECLARE_WAITQUEUE(waita, current);
1734 #ifdef DEBUG2
1735         printk("ali_audio: ali_write called, count = %d\n", count);
1736 #endif
1737         if (ppos != &file->f_pos)
1738                 return -ESPIPE;
1739         if (dmabuf->mapped)
1740                 return -ENXIO;
1741         if (dmabuf->enable & ADC_RUNNING)
1742                 return -ENODEV;
1743         if (codec_independent_spdif_locked > 0) {
1744                 if (!dmabuf->codec_spdifout_channel) {
1745                         dmabuf->ready = 0;
1746                         dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card);
1747                         if (!dmabuf->codec_spdifout_channel)
1748                                 return -EBUSY;
1749                 }
1750         } else {
1751                 if (controller_independent_spdif_locked > 0) {
1752                         if (!dmabuf->controller_spdifout_channel) {
1753                                 dmabuf->ready = 0;
1754                                 dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card);
1755                                 if (!dmabuf->controller_spdifout_channel)
1756                                         return -EBUSY;
1757                         }
1758                 } else {
1759                         if (!dmabuf->write_channel) {
1760                                 dmabuf->ready = 0;
1761                                 dmabuf->write_channel =
1762                                     card->alloc_pcm_channel(card);
1763                                 if (!dmabuf->write_channel)
1764                                         return -EBUSY;
1765                         }
1766                 }
1767         }
1768
1769         if (codec_independent_spdif_locked > 0) {
1770                 if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
1771                         return ret;
1772         } else {
1773                 if (controller_independent_spdif_locked > 0) {
1774                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
1775                                 return ret;
1776                 } else {
1777
1778                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
1779                                 return ret;
1780                 }
1781         }
1782         if (!access_ok(VERIFY_READ, buffer, count))
1783                 return -EFAULT;
1784         ret = 0;
1785         add_wait_queue(&dmabuf->wait, &waita);
1786         while (count > 0) {
1787                 set_current_state(TASK_INTERRUPTIBLE);
1788                 spin_lock_irqsave(&state->card->lock, flags);
1789                 if (PM_SUSPENDED(card)) {
1790                         spin_unlock_irqrestore(&card->lock, flags);
1791                         schedule();
1792                         if (signal_pending(current)) {
1793                                 if (!ret)
1794                                         ret = -EAGAIN;
1795                                 break;
1796                         }
1797                         continue;
1798                 }
1799
1800                 swptr = dmabuf->swptr;
1801                 cnt = ali_get_free_write_space(state);
1802                 /* Bound the maximum size to how much we can copy to the
1803                  * dma buffer before we hit the end.  If we have more to
1804                  * copy then it will get done in a second pass of this
1805                  * loop starting from the beginning of the buffer.
1806                  */
1807                 if (cnt > (dmabuf->dmasize - swptr))
1808                         cnt = dmabuf->dmasize - swptr;
1809                 spin_unlock_irqrestore(&state->card->lock, flags);
1810 #ifdef DEBUG2
1811                 printk(KERN_INFO
1812                        "ali_audio: ali_write: %d bytes available space\n",
1813                        cnt);
1814 #endif
1815                 if (cnt > count)
1816                         cnt = count;
1817                 /* Lop off the last two bits to force the code to always
1818                  * write in full samples.  This keeps software that sets
1819                  * O_NONBLOCK but doesn't check the return value of the
1820                  * write call from getting things out of state where they
1821                  * think a full 4 byte sample was written when really only
1822                  * a portion was, resulting in odd sound and stereo
1823                  * hysteresis.
1824                  */
1825                 cnt &= ~0x3;
1826                 if (cnt <= 0) {
1827                         unsigned long tmo;
1828                         // There is data waiting to be played
1829                         /*
1830                          * Force the trigger setting since we would
1831                          * deadlock with it set any other way
1832                          */
1833                         if (codec_independent_spdif_locked > 0) {
1834                                 dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1835                                 ali_update_lvi(state, 2);
1836                         } else {
1837                                 if (controller_independent_spdif_locked > 0) {
1838                                         dmabuf->trigger = SPDIF_ENABLE_OUTPUT;
1839                                         ali_update_lvi(state, 3);
1840                                 } else {
1841
1842                                         dmabuf->trigger = PCM_ENABLE_OUTPUT;
1843                                         ali_update_lvi(state, 0);
1844                                 }
1845                         }
1846                         if (file->f_flags & O_NONBLOCK) {
1847                                 if (!ret)
1848                                         ret = -EAGAIN;
1849                                 goto ret;
1850                         }
1851                         /* Not strictly correct but works */
1852                         tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
1853                         /* There are two situations when sleep_on_timeout returns, one is when
1854                            the interrupt is serviced correctly and the process is waked up by
1855                            ISR ON TIME. Another is when timeout is expired, which means that
1856                            either interrupt is NOT serviced correctly (pending interrupt) or it
1857                            is TOO LATE for the process to be scheduled to run (scheduler latency)
1858                            which results in a (potential) buffer underrun. And worse, there is
1859                            NOTHING we can do to prevent it. */
1860
1861                         /* FIXME - do timeout handling here !! */
1862
1863                         if (signal_pending(current)) {
1864                                 if (!ret)
1865                                         ret = -ERESTARTSYS;
1866                                 goto ret;
1867                         }
1868                         continue;
1869                 }
1870                 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
1871                         if (!ret)
1872                                 ret = -EFAULT;
1873                         goto ret;
1874                 }
1875
1876                 swptr = (swptr + cnt) % dmabuf->dmasize;
1877                 spin_lock_irqsave(&state->card->lock, flags);
1878                 if (PM_SUSPENDED(card)) {
1879                         spin_unlock_irqrestore(&card->lock, flags);
1880                         continue;
1881                 }
1882
1883                 dmabuf->swptr = swptr;
1884                 dmabuf->count += cnt;
1885                 count -= cnt;
1886                 buffer += cnt;
1887                 ret += cnt;
1888                 spin_unlock_irqrestore(&state->card->lock, flags);
1889         }
1890         if (swptr % dmabuf->fragsize) {
1891                 x = dmabuf->fragsize - (swptr % dmabuf->fragsize);
1892                 memset(dmabuf->rawbuf + swptr, '\0', x);
1893         }
1894 ret:
1895         if (codec_independent_spdif_locked > 0) {
1896                 ali_update_lvi(state, 2);
1897         } else {
1898                 if (controller_independent_spdif_locked > 0) {
1899                         ali_update_lvi(state, 3);
1900                 } else {
1901                         ali_update_lvi(state, 0);
1902                 }
1903         }
1904         set_current_state(TASK_RUNNING);
1905         remove_wait_queue(&dmabuf->wait, &waita);
1906         return ret;
1907 }
1908
1909 /* No kernel lock - we have our own spinlock */
1910 static unsigned int ali_poll(struct file *file, struct poll_table_struct
1911                              *wait)
1912 {
1913         struct ali_state *state = (struct ali_state *) file->private_data;
1914         struct dmabuf *dmabuf = &state->dmabuf;
1915         unsigned long flags;
1916         unsigned int mask = 0;
1917         if (!dmabuf->ready)
1918                 return 0;
1919         poll_wait(file, &dmabuf->wait, wait);
1920         spin_lock_irqsave(&state->card->lock, flags);
1921         ali_update_ptr(state);
1922         if (file->f_mode & FMODE_READ && dmabuf->enable & ADC_RUNNING) {
1923                 if (dmabuf->count >= (signed) dmabuf->fragsize)
1924                         mask |= POLLIN | POLLRDNORM;
1925         }
1926         if (file->f_mode & FMODE_WRITE  && (dmabuf->enable & (DAC_RUNNING|CODEC_SPDIFOUT_RUNNING|CONTROLLER_SPDIFOUT_RUNNING))) {
1927                 if ((signed) dmabuf->dmasize >= dmabuf->count + (signed) dmabuf->fragsize)
1928                         mask |= POLLOUT | POLLWRNORM;
1929         }
1930         spin_unlock_irqrestore(&state->card->lock, flags);
1931         return mask;
1932 }
1933
1934 static int ali_mmap(struct file *file, struct vm_area_struct *vma)
1935 {
1936         struct ali_state *state = (struct ali_state *) file->private_data;
1937         struct dmabuf *dmabuf = &state->dmabuf;
1938         int ret = -EINVAL;
1939         unsigned long size;
1940         lock_kernel();
1941         if (vma->vm_flags & VM_WRITE) {
1942                 if (!dmabuf->write_channel && (dmabuf->write_channel = state->card->alloc_pcm_channel(state->card)) == NULL) {
1943                         ret = -EBUSY;
1944                         goto out;
1945                 }
1946         }
1947         if (vma->vm_flags & VM_READ) {
1948                 if (!dmabuf->read_channel && (dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
1949                         ret = -EBUSY;
1950                         goto out;
1951                 }
1952         }
1953         if ((ret = prog_dmabuf(state, 0)) != 0)
1954                 goto out;
1955         ret = -EINVAL;
1956         if (vma->vm_pgoff != 0)
1957                 goto out;
1958         size = vma->vm_end - vma->vm_start;
1959         if (size > (PAGE_SIZE << dmabuf->buforder))
1960                 goto out;
1961         ret = -EAGAIN;
1962         if (remap_page_range(vma->vm_start, virt_to_phys(dmabuf->rawbuf), size, vma->vm_page_prot))
1963                 goto out;
1964         dmabuf->mapped = 1;
1965         dmabuf->trigger = 0;
1966         ret = 0;
1967 out:
1968         unlock_kernel();
1969         return ret;
1970 }
1971
1972 static int ali_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1973 {
1974         struct ali_state *state = (struct ali_state *) file->private_data;
1975         struct ali_channel *c = NULL;
1976         struct dmabuf *dmabuf = &state->dmabuf;
1977         unsigned long flags;
1978         audio_buf_info abinfo;
1979         count_info cinfo;
1980         unsigned int i_scr;
1981         int val = 0, ret;
1982         struct ac97_codec *codec = state->card->ac97_codec[0];
1983 #ifdef DEBUG
1984         printk("ali_audio: ali_ioctl, arg=0x%x, cmd=",
1985                arg ? *(int *) arg : 0);
1986 #endif
1987         switch (cmd) {
1988         case OSS_GETVERSION:
1989 #ifdef DEBUG
1990                 printk("OSS_GETVERSION\n");
1991 #endif
1992                 return put_user(SOUND_VERSION, (int *) arg);
1993         case SNDCTL_DSP_RESET:
1994 #ifdef DEBUG
1995                 printk("SNDCTL_DSP_RESET\n");
1996 #endif
1997                 spin_lock_irqsave(&state->card->lock, flags);
1998                 if (dmabuf->enable == DAC_RUNNING) {
1999                         c = dmabuf->write_channel;
2000                         __stop_dac(state);
2001                 }
2002                 if (dmabuf->enable == ADC_RUNNING) {
2003                         c = dmabuf->read_channel;
2004                         __stop_adc(state);
2005                 }
2006                 if (dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2007                         c = dmabuf->codec_spdifout_channel;
2008                         __stop_spdifout(state);
2009                 }
2010                 if (dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2011                         c = dmabuf->controller_spdifout_channel;
2012                         __stop_spdifout(state);
2013                 }
2014                 if (c != NULL) {
2015                         outb(2, state->card->iobase + c->port + OFF_CR);        /* reset DMA machine */
2016                         outl(virt_to_bus(&c->sg[0]),
2017                              state->card->iobase + c->port + OFF_BDBAR);
2018                         outb(0, state->card->iobase + c->port + OFF_CIV);
2019                         outb(0, state->card->iobase + c->port + OFF_LVI);
2020                 }
2021
2022                 spin_unlock_irqrestore(&state->card->lock, flags);
2023                 synchronize_irq();
2024                 dmabuf->ready = 0;
2025                 dmabuf->swptr = dmabuf->hwptr = 0;
2026                 dmabuf->count = dmabuf->total_bytes = 0;
2027                 return 0;
2028         case SNDCTL_DSP_SYNC:
2029 #ifdef DEBUG
2030                 printk("SNDCTL_DSP_SYNC\n");
2031 #endif
2032                 if (codec_independent_spdif_locked > 0) {
2033                         if (dmabuf->enable != CODEC_SPDIFOUT_RUNNING
2034                             || file->f_flags & O_NONBLOCK)
2035                                 return 0;
2036                         if ((val = drain_spdifout(state, 1)))
2037                                 return val;
2038                 } else {
2039                         if (controller_independent_spdif_locked > 0) {
2040                                 if (dmabuf->enable !=
2041                                     CONTROLLER_SPDIFOUT_RUNNING
2042                                     || file->f_flags & O_NONBLOCK)
2043                                         return 0;
2044                                 if ((val = drain_spdifout(state, 1)))
2045                                         return val;
2046                         } else {
2047                                 if (dmabuf->enable != DAC_RUNNING
2048                                     || file->f_flags & O_NONBLOCK)
2049                                         return 0;
2050                                 if ((val = drain_dac(state, 1)))
2051                                         return val;
2052                         }
2053                 }
2054                 dmabuf->total_bytes = 0;
2055                 return 0;
2056         case SNDCTL_DSP_SPEED:  /* set smaple rate */
2057 #ifdef DEBUG
2058                 printk("SNDCTL_DSP_SPEED\n");
2059 #endif
2060                 if (get_user(val, (int *) arg))
2061                         return -EFAULT;
2062                 if (val >= 0) {
2063                         if (file->f_mode & FMODE_WRITE) {
2064                                 if ((state->card->ac97_status & SPDIF_ON)) {    /* S/PDIF Enabled */
2065                                         /* RELTEK ALC650 only support 48000, need to check that */
2066                                         if (ali_valid_spdif_rate(codec, val)) {
2067                                                 if (codec_independent_spdif_locked > 0) {
2068                                                         ali_set_spdif_output(state, -1, 0);
2069                                                         stop_spdifout(state);
2070                                                         dmabuf->ready = 0;
2071                                                         /* I add test codec independent spdif out */
2072                                                         spin_lock_irqsave(&state->card->lock, flags);
2073                                                         ali_set_codecspdifout_rate(state, val); // I modified
2074                                                         spin_unlock_irqrestore(&state->card->lock, flags);
2075                                                         /* Set S/PDIF transmitter rate. */
2076                                                         i_scr = inl(state->card->iobase + ALI_SCR);
2077                                                         if ((i_scr & 0x00300000) == 0x00100000) {
2078                                                                 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2079                                                         } else {
2080                                                                 if ((i_scr&0x00300000)  == 0x00200000)
2081                                                                 {
2082                                                                         ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2083                                                                 } else {
2084                                                                         if ((i_scr & 0x00300000) == 0x00300000) {
2085                                                                                 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2086                                                                         } else {
2087                                                                                 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2088                                                                         }
2089                                                                 }
2090                                                         }
2091
2092                                                         if (!(state->card->ac97_status & SPDIF_ON)) {
2093                                                                 val = dmabuf->rate;
2094                                                         }
2095                                                 } else {
2096                                                         if (controller_independent_spdif_locked > 0)
2097                                                         {
2098                                                                 stop_spdifout(state);
2099                                                                 dmabuf->ready = 0;
2100                                                                 spin_lock_irqsave(&state->card->lock, flags);
2101                                                                 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2102                                                                 spin_unlock_irqrestore(&state->card->lock, flags);
2103                                                         } else {
2104                                                                 /* Set DAC rate */
2105                                                                 ali_set_spdif_output(state, -1, 0);
2106                                                                 stop_dac(state);
2107                                                                 dmabuf->ready = 0;
2108                                                                 spin_lock_irqsave(&state->card->lock, flags);
2109                                                                 ali_set_dac_rate(state, val);
2110                                                                 spin_unlock_irqrestore(&state->card->lock, flags);
2111                                                                 /* Set S/PDIF transmitter rate. */
2112                                                                 ali_set_spdif_output(state, AC97_EA_SPSA_3_4, val);
2113                                                                 if (!(state->card->ac97_status & SPDIF_ON))
2114                                                                 {
2115                                                                         val = dmabuf->rate;
2116                                                                 }
2117                                                         }
2118                                                 }
2119                                         } else {        /* Not a valid rate for S/PDIF, ignore it */
2120                                                 val = dmabuf->rate;
2121                                         }
2122                                 } else {
2123                                         stop_dac(state);
2124                                         dmabuf->ready = 0;
2125                                         spin_lock_irqsave(&state->card->lock, flags);
2126                                         ali_set_dac_rate(state, val);
2127                                         spin_unlock_irqrestore(&state->card->lock, flags);
2128                                 }
2129                         }
2130                         if (file->f_mode & FMODE_READ) {
2131                                 stop_adc(state);
2132                                 dmabuf->ready = 0;
2133                                 spin_lock_irqsave(&state->card->lock, flags);
2134                                 ali_set_adc_rate(state, val);
2135                                 spin_unlock_irqrestore(&state->card->lock, flags);
2136                         }
2137                 }
2138                 return put_user(dmabuf->rate, (int *) arg);
2139         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2140 #ifdef DEBUG
2141                 printk("SNDCTL_DSP_STEREO\n");
2142 #endif
2143                 if (dmabuf->enable & DAC_RUNNING) {
2144                         stop_dac(state);
2145                 }
2146                 if (dmabuf->enable & ADC_RUNNING) {
2147                         stop_adc(state);
2148                 }
2149                 if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2150                         stop_spdifout(state);
2151                 }
2152                 if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2153                         stop_spdifout(state);
2154                 }
2155                 return put_user(1, (int *) arg);
2156         case SNDCTL_DSP_GETBLKSIZE:
2157                 if (file->f_mode & FMODE_WRITE) {
2158                         if (codec_independent_spdif_locked > 0) {
2159                                 if (!dmabuf->ready && (val = prog_dmabuf(state, 2)))
2160                                         return val;
2161                         } else {
2162                                 if (controller_independent_spdif_locked > 0) {
2163                                         if (!dmabuf->ready && (val = prog_dmabuf(state, 3)))
2164                                                 return val;
2165                                 } else {
2166                                         if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
2167                                                 return val;
2168                                 }
2169                         }
2170                 }
2171
2172                 if (file->f_mode & FMODE_READ) {
2173                         if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
2174                                 return val;
2175                 }
2176 #ifdef DEBUG
2177                 printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
2178 #endif
2179                 return put_user(dmabuf->userfragsize, (int *) arg);
2180         case SNDCTL_DSP_GETFMTS:        /* Returns a mask of supported sample format */
2181 #ifdef DEBUG
2182                 printk("SNDCTL_DSP_GETFMTS\n");
2183 #endif
2184                 return put_user(AFMT_S16_LE, (int *) arg);
2185         case SNDCTL_DSP_SETFMT: /* Select sample format */
2186 #ifdef DEBUG
2187                 printk("SNDCTL_DSP_SETFMT\n");
2188 #endif
2189                 return put_user(AFMT_S16_LE, (int *) arg);
2190         case SNDCTL_DSP_CHANNELS:       // add support 4,6 channel
2191 #ifdef DEBUG
2192                 printk("SNDCTL_DSP_CHANNELS\n");
2193 #endif
2194                 if (get_user(val, (int *) arg))
2195                         return -EFAULT;
2196                 if (val > 0) {
2197                         if (dmabuf->enable & DAC_RUNNING) {
2198                                 stop_dac(state);
2199                         }
2200                         if (dmabuf->enable & CODEC_SPDIFOUT_RUNNING) {
2201                                 stop_spdifout(state);
2202                         }
2203                         if (dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING) {
2204                                 stop_spdifout(state);
2205                         }
2206                         if (dmabuf->enable & ADC_RUNNING) {
2207                                 stop_adc(state);
2208                         }
2209                 } else {
2210                         return put_user(state->card->channels, (int *) arg);
2211                 }
2212
2213                 i_scr = inl(state->card->iobase + ALI_SCR);
2214                 /* Current # of channels enabled */
2215                 if (i_scr & 0x00000100)
2216                         ret = 4;
2217                 else if (i_scr & 0x00000200)
2218                         ret = 6;
2219                 else
2220                         ret = 2;
2221                 switch (val) {
2222                 case 2: /* 2 channels is always supported */
2223                         if (codec_independent_spdif_locked > 0) {
2224                                 outl(((i_scr & 0xfffffcff) | 0x00100000), (state->card->iobase + ALI_SCR));
2225                         } else
2226                                 outl((i_scr & 0xfffffcff), (state->card->iobase + ALI_SCR));
2227                         /* Do we need to change mixer settings????  */
2228                         break;
2229                 case 4: /* Supported on some chipsets, better check first */
2230                         if (codec_independent_spdif_locked > 0) {
2231                                 outl(((i_scr & 0xfffffcff) | 0x00000100 | 0x00200000), (state->card->iobase + ALI_SCR));
2232                         } else
2233                                 outl(((i_scr & 0xfffffcff) | 0x00000100), (state->card->iobase + ALI_SCR));
2234                         break;
2235                 case 6: /* Supported on some chipsets, better check first */
2236                         if (codec_independent_spdif_locked > 0) {
2237                                 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000 | 0x00300000), (state->card->iobase + ALI_SCR));
2238                         } else
2239                                 outl(((i_scr & 0xfffffcff) | 0x00000200 | 0x00008000), (state->card->iobase + ALI_SCR));
2240                         break;
2241                 default:        /* nothing else is ever supported by the chipset */
2242                         val = ret;
2243                         break;
2244                 }
2245                 return put_user(val, (int *) arg);
2246         case SNDCTL_DSP_POST:   /* the user has sent all data and is notifying us */
2247                 /* we update the swptr to the end of the last sg segment then return */
2248 #ifdef DEBUG
2249                 printk("SNDCTL_DSP_POST\n");
2250 #endif
2251                 if (codec_independent_spdif_locked > 0) {
2252                         if (!dmabuf->ready || (dmabuf->enable != CODEC_SPDIFOUT_RUNNING))
2253                                 return 0;
2254                 } else {
2255                         if (controller_independent_spdif_locked > 0) {
2256                                 if (!dmabuf->ready || (dmabuf->enable != CONTROLLER_SPDIFOUT_RUNNING))
2257                                         return 0;
2258                         } else {
2259                                 if (!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
2260                                         return 0;
2261                         }
2262                 }
2263                 if ((dmabuf->swptr % dmabuf->fragsize) != 0) {
2264                         val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
2265                         dmabuf->swptr += val;
2266                         dmabuf->count += val;
2267                 }
2268                 return 0;
2269         case SNDCTL_DSP_SUBDIVIDE:
2270                 if (dmabuf->subdivision)
2271                         return -EINVAL;
2272                 if (get_user(val, (int *) arg))
2273                         return -EFAULT;
2274                 if (val != 1 && val != 2 && val != 4)
2275                         return -EINVAL;
2276 #ifdef DEBUG
2277                 printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
2278 #endif
2279                 dmabuf->subdivision = val;
2280                 dmabuf->ready = 0;
2281                 return 0;
2282         case SNDCTL_DSP_SETFRAGMENT:
2283                 if (get_user(val, (int *) arg))
2284                         return -EFAULT;
2285                 dmabuf->ossfragsize = 1 << (val & 0xffff);
2286                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2287                 if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
2288                         return -EINVAL;
2289                 /*
2290                  * Bound the frag size into our allowed range of 256 - 4096
2291                  */
2292                 if (dmabuf->ossfragsize < 256)
2293                         dmabuf->ossfragsize = 256;
2294                 else if (dmabuf->ossfragsize > 4096)
2295                         dmabuf->ossfragsize = 4096;
2296                 /*
2297                  * The numfrags could be something reasonable, or it could
2298                  * be 0xffff meaning "Give me as much as possible".  So,
2299                  * we check the numfrags * fragsize doesn't exceed our
2300                  * 64k buffer limit, nor is it less than our 8k minimum.
2301                  * If it fails either one of these checks, then adjust the
2302                  * number of fragments, not the size of them.  It's OK if
2303                  * our number of fragments doesn't equal 32 or anything
2304                  * like our hardware based number now since we are using
2305                  * a different frag count for the hardware.  Before we get
2306                  * into this though, bound the maxfrags to avoid overflow
2307                  * issues.  A reasonable bound would be 64k / 256 since our
2308                  * maximum buffer size is 64k and our minimum frag size is
2309                  * 256.  On the other end, our minimum buffer size is 8k and
2310                  * our maximum frag size is 4k, so the lower bound should
2311                  * be 2.
2312                  */
2313                 if (dmabuf->ossmaxfrags > 256)
2314                         dmabuf->ossmaxfrags = 256;
2315                 else if (dmabuf->ossmaxfrags < 2)
2316                         dmabuf->ossmaxfrags = 2;
2317                 val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
2318                 while (val < 8192) {
2319                         val <<= 1;
2320                         dmabuf->ossmaxfrags <<= 1;
2321                 }
2322                 while (val > 65536) {
2323                         val >>= 1;
2324                         dmabuf->ossmaxfrags >>= 1;
2325                 }
2326                 dmabuf->ready = 0;
2327 #ifdef DEBUG
2328                 printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
2329                        dmabuf->ossfragsize, dmabuf->ossmaxfrags);
2330 #endif
2331                 return 0;
2332         case SNDCTL_DSP_GETOSPACE:
2333                 if (!(file->f_mode & FMODE_WRITE))
2334                         return -EINVAL;
2335                 if (codec_independent_spdif_locked > 0) {
2336                         if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2337                                 return val;
2338                 } else {
2339                         if (controller_independent_spdif_locked > 0) {
2340                                 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2341                                         return val;
2342                         } else {
2343                                 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2344                                         return val;
2345                         }
2346                 }
2347                 spin_lock_irqsave(&state->card->lock, flags);
2348                 ali_update_ptr(state);
2349                 abinfo.fragsize = dmabuf->userfragsize;
2350                 abinfo.fragstotal = dmabuf->userfrags;
2351                 if (dmabuf->mapped)
2352                         abinfo.bytes = dmabuf->dmasize;
2353                 else
2354                         abinfo.bytes = ali_get_free_write_space(state);
2355                 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2356                 spin_unlock_irqrestore(&state->card->lock, flags);
2357 #if defined(DEBUG) || defined(DEBUG_MMAP)
2358                 printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n",
2359                        abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2360                        abinfo.fragstotal);
2361 #endif
2362                 return copy_to_user((void *) arg, &abinfo,
2363                                     sizeof(abinfo)) ? -EFAULT : 0;
2364         case SNDCTL_DSP_GETOPTR:
2365                 if (!(file->f_mode & FMODE_WRITE))
2366                         return -EINVAL;
2367                 if (codec_independent_spdif_locked > 0) {
2368                         if (!dmabuf->ready && (val = prog_dmabuf(state, 2)) != 0)
2369                                 return val;
2370                 } else {
2371                         if (controller_independent_spdif_locked > 0) {
2372                                 if (!dmabuf->ready && (val = prog_dmabuf(state, 3)) != 0)
2373                                         return val;
2374                         } else {
2375                                 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2376                                         return val;
2377                         }
2378                 }
2379                 spin_lock_irqsave(&state->card->lock, flags);
2380                 val = ali_get_free_write_space(state);
2381                 cinfo.bytes = dmabuf->total_bytes;
2382                 cinfo.ptr = dmabuf->hwptr;
2383                 cinfo.blocks = val / dmabuf->userfragsize;
2384                 if (codec_independent_spdif_locked > 0) {
2385                         if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2386                                 dmabuf->count += val;
2387                                 dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2388                                 __ali_update_lvi(state, 2);
2389                         }
2390                 } else {
2391                         if (controller_independent_spdif_locked > 0) {
2392                                 if (dmabuf->mapped && (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)) {
2393                                         dmabuf->count += val;
2394                                         dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2395                                         __ali_update_lvi(state, 3);
2396                                 }
2397                         } else {
2398                                 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
2399                                         dmabuf->count += val;
2400                                         dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2401                                         __ali_update_lvi(state, 0);
2402                                 }
2403                         }
2404                 }
2405                 spin_unlock_irqrestore(&state->card->lock, flags);
2406 #if defined(DEBUG) || defined(DEBUG_MMAP)
2407                 printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
2408                        cinfo.blocks, cinfo.ptr, dmabuf->count);
2409 #endif
2410                 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo));
2411         case SNDCTL_DSP_GETISPACE:
2412                 if (!(file->f_mode & FMODE_READ))
2413                         return -EINVAL;
2414                 if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
2415                         return val;
2416                 spin_lock_irqsave(&state->card->lock, flags);
2417                 abinfo.bytes = ali_get_available_read_data(state);
2418                 abinfo.fragsize = dmabuf->userfragsize;
2419                 abinfo.fragstotal = dmabuf->userfrags;
2420                 abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
2421                 spin_unlock_irqrestore(&state->card->lock, flags);
2422 #if defined(DEBUG) || defined(DEBUG_MMAP)
2423                 printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n",
2424                        abinfo.bytes, abinfo.fragsize, abinfo.fragments,
2425                        abinfo.fragstotal);
2426 #endif
2427                 return copy_to_user((void *) arg, &abinfo,
2428                                     sizeof(abinfo)) ? -EFAULT : 0;
2429         case SNDCTL_DSP_GETIPTR:
2430                 if (!(file->f_mode & FMODE_READ))
2431                         return -EINVAL;
2432                 if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
2433                         return val;
2434                 spin_lock_irqsave(&state->card->lock, flags);
2435                 val = ali_get_available_read_data(state);
2436                 cinfo.bytes = dmabuf->total_bytes;
2437                 cinfo.blocks = val / dmabuf->userfragsize;
2438                 cinfo.ptr = dmabuf->hwptr;
2439                 if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
2440                         dmabuf->count -= val;
2441                         dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
2442                         __ali_update_lvi(state, 1);
2443                 }
2444                 spin_unlock_irqrestore(&state->card->lock, flags);
2445 #if defined(DEBUG) || defined(DEBUG_MMAP)
2446                 printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
2447                        cinfo.blocks, cinfo.ptr, dmabuf->count);
2448 #endif
2449                 return copy_to_user((void *) arg, &cinfo, sizeof(cinfo));
2450         case SNDCTL_DSP_NONBLOCK:
2451 #ifdef DEBUG
2452                 printk("SNDCTL_DSP_NONBLOCK\n");
2453 #endif
2454                 file->f_flags |= O_NONBLOCK;
2455                 return 0;
2456         case SNDCTL_DSP_GETCAPS:
2457 #ifdef DEBUG
2458                 printk("SNDCTL_DSP_GETCAPS\n");
2459 #endif
2460                 return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2461                                 DSP_CAP_MMAP | DSP_CAP_BIND, (int *) arg);
2462         case SNDCTL_DSP_GETTRIGGER:
2463                 val = 0;
2464 #ifdef DEBUG
2465                 printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
2466 #endif
2467                 return put_user(dmabuf->trigger, (int *) arg);
2468         case SNDCTL_DSP_SETTRIGGER:
2469                 if (get_user(val, (int *) arg))
2470                         return -EFAULT;
2471 #if defined(DEBUG) || defined(DEBUG_MMAP)
2472                 printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
2473 #endif
2474                 if (!(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
2475                         stop_adc(state);
2476                 }
2477                 if (!(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
2478                         stop_dac(state);
2479                 }
2480                 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CODEC_SPDIFOUT_RUNNING) {
2481                         stop_spdifout(state);
2482                 }
2483                 if (!(val & SPDIF_ENABLE_OUTPUT) && dmabuf->enable == CONTROLLER_SPDIFOUT_RUNNING) {
2484                         stop_spdifout(state);
2485                 }
2486                 dmabuf->trigger = val;
2487                 if (val & PCM_ENABLE_OUTPUT && !(dmabuf->enable & DAC_RUNNING)) {
2488                         if (!dmabuf->write_channel) {
2489                                 dmabuf->ready = 0;
2490                                 dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
2491                                 if (!dmabuf->write_channel)
2492                                         return -EBUSY;
2493                         }
2494                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
2495                                 return ret;
2496                         if (dmabuf->mapped) {
2497                                 spin_lock_irqsave(&state->card->lock, flags);
2498                                 ali_update_ptr(state);
2499                                 dmabuf->count = 0;
2500                                 dmabuf->swptr = dmabuf->hwptr;
2501                                 dmabuf->count = ali_get_free_write_space(state);
2502                                 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2503                                 __ali_update_lvi(state, 0);
2504                                 spin_unlock_irqrestore(&state->card->lock,
2505                                                        flags);
2506                         } else
2507                                 start_dac(state);
2508                 }
2509                 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CODEC_SPDIFOUT_RUNNING)) {
2510                         if (!dmabuf->codec_spdifout_channel) {
2511                                 dmabuf->ready = 0;
2512                                 dmabuf->codec_spdifout_channel = state->card->alloc_codec_spdifout_channel(state->card);
2513                                 if (!dmabuf->codec_spdifout_channel)
2514                                         return -EBUSY;
2515                         }
2516                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 2)))
2517                                 return ret;
2518                         if (dmabuf->mapped) {
2519                                 spin_lock_irqsave(&state->card->lock, flags);
2520                                 ali_update_ptr(state);
2521                                 dmabuf->count = 0;
2522                                 dmabuf->swptr = dmabuf->hwptr;
2523                                 dmabuf->count = ali_get_free_write_space(state);
2524                                 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2525                                 __ali_update_lvi(state, 2);
2526                                 spin_unlock_irqrestore(&state->card->lock,
2527                                                        flags);
2528                         } else
2529                                 start_spdifout(state);
2530                 }
2531                 if (val & SPDIF_ENABLE_OUTPUT && !(dmabuf->enable & CONTROLLER_SPDIFOUT_RUNNING)) {
2532                         if (!dmabuf->controller_spdifout_channel) {
2533                                 dmabuf->ready = 0;
2534                                 dmabuf->controller_spdifout_channel = state->card->alloc_controller_spdifout_channel(state->card);
2535                                 if (!dmabuf->controller_spdifout_channel)
2536                                         return -EBUSY;
2537                         }
2538                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 3)))
2539                                 return ret;
2540                         if (dmabuf->mapped) {
2541                                 spin_lock_irqsave(&state->card->lock, flags);
2542                                 ali_update_ptr(state);
2543                                 dmabuf->count = 0;
2544                                 dmabuf->swptr = dmabuf->hwptr;
2545                                 dmabuf->count = ali_get_free_write_space(state);
2546                                 dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
2547                                 __ali_update_lvi(state, 3);
2548                                 spin_unlock_irqrestore(&state->card->lock, flags);
2549                         } else
2550                                 start_spdifout(state);
2551                 }
2552                 if (val & PCM_ENABLE_INPUT && !(dmabuf->enable & ADC_RUNNING)) {
2553                         if (!dmabuf->read_channel) {
2554                                 dmabuf->ready = 0;
2555                                 dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
2556                                 if (!dmabuf->read_channel)
2557                                         return -EBUSY;
2558                         }
2559                         if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
2560                                 return ret;
2561                         if (dmabuf->mapped) {
2562                                 spin_lock_irqsave(&state->card->lock,
2563                                                   flags);
2564                                 ali_update_ptr(state);
2565                                 dmabuf->swptr = dmabuf->hwptr;
2566                                 dmabuf->count = 0;
2567                                 spin_unlock_irqrestore(&state->card->lock, flags);
2568                         }
2569                         ali_update_lvi(state, 1);
2570                         start_adc(state);
2571                 }
2572                 return 0;
2573         case SNDCTL_DSP_SETDUPLEX:
2574 #ifdef DEBUG
2575                 printk("SNDCTL_DSP_SETDUPLEX\n");
2576 #endif
2577                 return -EINVAL;
2578         case SNDCTL_DSP_GETODELAY:
2579                 if (!(file->f_mode & FMODE_WRITE))
2580                         return -EINVAL;
2581                 spin_lock_irqsave(&state->card->lock, flags);
2582                 ali_update_ptr(state);
2583                 val = dmabuf->count;
2584                 spin_unlock_irqrestore(&state->card->lock, flags);
2585 #ifdef DEBUG
2586                 printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
2587 #endif
2588                 return put_user(val, (int *) arg);
2589         case SOUND_PCM_READ_RATE:
2590 #ifdef DEBUG
2591                 printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
2592 #endif
2593                 return put_user(dmabuf->rate, (int *) arg);
2594         case SOUND_PCM_READ_CHANNELS:
2595 #ifdef DEBUG
2596                 printk("SOUND_PCM_READ_CHANNELS\n");
2597 #endif
2598                 return put_user(2, (int *) arg);
2599         case SOUND_PCM_READ_BITS:
2600 #ifdef DEBUG
2601                 printk("SOUND_PCM_READ_BITS\n");
2602 #endif
2603                 return put_user(AFMT_S16_LE, (int *) arg);
2604         case SNDCTL_DSP_SETSPDIF:       /* Set S/PDIF Control register */
2605 #ifdef DEBUG
2606                 printk("SNDCTL_DSP_SETSPDIF\n");
2607 #endif
2608                 if (get_user(val, (int *) arg))
2609                         return -EFAULT;
2610                 /* Check to make sure the codec supports S/PDIF transmitter */
2611                 if ((state->card->ac97_features & 4)) {
2612                         /* mask out the transmitter speed bits so the user can't set them */
2613                         val &= ~0x3000;
2614                         /* Add the current transmitter speed bits to the passed value */
2615                         ret = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2616                         val |= (ret & 0x3000);
2617                         ali_ac97_set(codec, AC97_SPDIF_CONTROL, val);
2618                         if (ali_ac97_get(codec, AC97_SPDIF_CONTROL) != val) {
2619                                 printk(KERN_ERR "ali_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
2620                                 return -EFAULT;
2621                         }
2622                 }
2623 #ifdef DEBUG
2624                 else
2625                         printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2626 #endif
2627                 return put_user(val, (int *) arg);
2628         case SNDCTL_DSP_GETSPDIF:       /* Get S/PDIF Control register */
2629 #ifdef DEBUG
2630                 printk("SNDCTL_DSP_GETSPDIF\n");
2631 #endif
2632                 if (get_user(val, (int *) arg))
2633                         return -EFAULT;
2634                 /* Check to make sure the codec supports S/PDIF transmitter */
2635                 if (!(state->card->ac97_features & 4)) {
2636 #ifdef DEBUG
2637                         printk(KERN_WARNING "ali_audio: S/PDIF transmitter not avalible.\n");
2638 #endif
2639                         val = 0;
2640                 } else {
2641                         val = ali_ac97_get(codec, AC97_SPDIF_CONTROL);
2642                 }
2643
2644                 return put_user(val, (int *) arg);
2645 //end add support spdif out
2646 //add support 4,6 channel
2647         case SNDCTL_DSP_GETCHANNELMASK:
2648 #ifdef DEBUG
2649                 printk("SNDCTL_DSP_GETCHANNELMASK\n");
2650 #endif
2651                 if (get_user(val, (int *) arg))
2652                         return -EFAULT;
2653                 /* Based on AC'97 DAC support, not ICH hardware */
2654                 val = DSP_BIND_FRONT;
2655                 if (state->card->ac97_features & 0x0004)
2656                         val |= DSP_BIND_SPDIF;
2657                 if (state->card->ac97_features & 0x0080)
2658                         val |= DSP_BIND_SURR;
2659                 if (state->card->ac97_features & 0x0140)
2660                         val |= DSP_BIND_CENTER_LFE;
2661                 return put_user(val, (int *) arg);
2662         case SNDCTL_DSP_BIND_CHANNEL:
2663 #ifdef DEBUG
2664                 printk("SNDCTL_DSP_BIND_CHANNEL\n");
2665 #endif
2666                 if (get_user(val, (int *) arg))
2667                         return -EFAULT;
2668                 if (val == DSP_BIND_QUERY) {
2669                         val = DSP_BIND_FRONT;   /* Always report this as being enabled */
2670                         if (state->card->ac97_status & SPDIF_ON)
2671                                 val |= DSP_BIND_SPDIF;
2672                         else {
2673                                 if (state->card->ac97_status & SURR_ON)
2674                                         val |= DSP_BIND_SURR;
2675                                 if (state->card->
2676                                     ac97_status & CENTER_LFE_ON)
2677                                         val |= DSP_BIND_CENTER_LFE;
2678                         }
2679                 } else {        /* Not a query, set it */
2680                         if (!(file->f_mode & FMODE_WRITE))
2681                                 return -EINVAL;
2682                         if (dmabuf->enable == DAC_RUNNING) {
2683                                 stop_dac(state);
2684                         }
2685                         if (val & DSP_BIND_SPDIF) {     /* Turn on SPDIF */
2686                                 /*  Ok, this should probably define what slots
2687                                  *  to use. For now, we'll only set it to the
2688                                  *  defaults:
2689                                  *
2690                                  *   non multichannel codec maps to slots 3&4
2691                                  *   2 channel codec maps to slots 7&8
2692                                  *   4 channel codec maps to slots 6&9
2693                                  *   6 channel codec maps to slots 10&11
2694                                  *
2695                                  *  there should be some way for the app to
2696                                  *  select the slot assignment.
2697                                  */
2698                                 i_scr = inl(state->card->iobase + ALI_SCR);
2699                                 if (codec_independent_spdif_locked > 0) {
2700
2701                                         if ((i_scr & 0x00300000) == 0x00100000) {
2702                                                 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2703                                         } else {
2704                                                 if ((i_scr & 0x00300000) == 0x00200000) {
2705                                                         ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2706                                                 } else {
2707                                                         if ((i_scr & 0x00300000) == 0x00300000) {
2708                                                                 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2709                                                         }
2710                                                 }
2711                                         }
2712                                 } else {        /* codec spdif out (pcm out share ) */
2713                                         ali_set_spdif_output(state, AC97_EA_SPSA_3_4, dmabuf->rate);    //I do not modify
2714                                 }
2715
2716                                 if (!(state->card->ac97_status & SPDIF_ON))
2717                                         val &= ~DSP_BIND_SPDIF;
2718                         } else {
2719                                 int mask;
2720                                 int channels;
2721                                 /* Turn off S/PDIF if it was on */
2722                                 if (state->card->ac97_status & SPDIF_ON)
2723                                         ali_set_spdif_output(state, -1, 0);
2724                                 mask =
2725                                     val & (DSP_BIND_FRONT | DSP_BIND_SURR |
2726                                            DSP_BIND_CENTER_LFE);
2727                                 switch (mask) {
2728                                 case DSP_BIND_FRONT:
2729                                         channels = 2;
2730                                         break;
2731                                 case DSP_BIND_FRONT | DSP_BIND_SURR:
2732                                         channels = 4;
2733                                         break;
2734                                 case DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE:
2735                                         channels = 6;
2736                                         break;
2737                                 default:
2738                                         val = DSP_BIND_FRONT;
2739                                         channels = 2;
2740                                         break;
2741                                 }
2742                                 ali_set_dac_channels(state, channels);
2743                                 /* check that they really got turned on */
2744                                 if (!state->card->ac97_status & SURR_ON)
2745                                         val &= ~DSP_BIND_SURR;
2746                                 if (!state->card->
2747                                     ac97_status & CENTER_LFE_ON)
2748                                         val &= ~DSP_BIND_CENTER_LFE;
2749                         }
2750                 }
2751                 return put_user(val, (int *) arg);
2752         case SNDCTL_DSP_MAPINBUF:
2753         case SNDCTL_DSP_MAPOUTBUF:
2754         case SNDCTL_DSP_SETSYNCRO:
2755         case SOUND_PCM_WRITE_FILTER:
2756         case SOUND_PCM_READ_FILTER:
2757                 return -EINVAL;
2758         }
2759         return -EINVAL;
2760 }
2761
2762 static int ali_open(struct inode *inode, struct file *file)
2763 {
2764         int i = 0;
2765         struct ali_card *card = devs;
2766         struct ali_state *state = NULL;
2767         struct dmabuf *dmabuf = NULL;
2768         unsigned int i_scr;
2769
2770         /* find an available virtual channel (instance of /dev/dsp) */
2771
2772         while (card != NULL) {
2773
2774                 /*
2775                  * If we are initializing and then fail, card could go
2776                  * away unuexpectedly while we are in the for() loop.
2777                  * So, check for card on each iteration before we check
2778                  * for card->initializing to avoid a possible oops.
2779                  * This usually only matters for times when the driver is
2780                  * autoloaded by kmod.
2781                  */
2782                 for (i = 0; i < 50 && card && card->initializing; i++) {
2783                         set_current_state(TASK_UNINTERRUPTIBLE);
2784                         schedule_timeout(HZ / 20);
2785                 }
2786
2787                 for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
2788                         if (card->states[i] == NULL) {
2789                                 state = card->states[i] = (struct ali_state *) kmalloc(sizeof(struct ali_state), GFP_KERNEL);
2790                                 if (state == NULL)
2791                                         return -ENOMEM;
2792                                 memset(state, 0, sizeof(struct ali_state));
2793                                 dmabuf = &state->dmabuf;
2794                                 goto found_virt;
2795                         }
2796                 }
2797                 card = card->next;
2798         }
2799
2800         /* no more virtual channel avaiable */
2801         if (!state)
2802                 return -ENODEV;
2803 found_virt:
2804         /* initialize the virtual channel */
2805
2806         state->virt = i;
2807         state->card = card;
2808         state->magic = ALI5455_STATE_MAGIC;
2809         init_waitqueue_head(&dmabuf->wait);
2810         init_MUTEX(&state->open_sem);
2811         file->private_data = state;
2812         dmabuf->trigger = 0;
2813         /* allocate hardware channels */
2814         if (file->f_mode & FMODE_READ) {
2815                 if ((dmabuf->read_channel =
2816                      card->alloc_rec_pcm_channel(card)) == NULL) {
2817                         kfree(card->states[i]);
2818                         card->states[i] = NULL;
2819                         return -EBUSY;
2820                 }
2821                 dmabuf->trigger |= PCM_ENABLE_INPUT;
2822                 ali_set_adc_rate(state, 8000);
2823         }
2824         if (file->f_mode & FMODE_WRITE) {
2825                 if (codec_independent_spdif_locked > 0) {
2826                         if ((dmabuf->codec_spdifout_channel = card->alloc_codec_spdifout_channel(card)) == NULL) {
2827                                 kfree(card->states[i]);
2828                                 card->states[i] = NULL;
2829                                 return -EBUSY;
2830                         }
2831                         dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2832                         ali_set_codecspdifout_rate(state, codec_independent_spdif_locked);      //It must add
2833                         i_scr = inl(state->card->iobase + ALI_SCR);
2834                         if ((i_scr & 0x00300000) == 0x00100000) {
2835                                 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2836                         } else {
2837                                 if ((i_scr & 0x00300000) == 0x00200000) {
2838                                         ali_set_spdif_output(state, AC97_EA_SPSA_6_9, codec_independent_spdif_locked);
2839                                 } else {
2840                                         if ((i_scr & 0x00300000) == 0x00300000) {
2841                                                 ali_set_spdif_output(state, AC97_EA_SPSA_10_11, codec_independent_spdif_locked);
2842                                         } else {
2843                                                 ali_set_spdif_output(state, AC97_EA_SPSA_7_8, codec_independent_spdif_locked);
2844                                         }
2845                                 }
2846
2847                         }
2848                 } else {
2849                         if (controller_independent_spdif_locked > 0) {
2850                                 if ((dmabuf->controller_spdifout_channel = card->alloc_controller_spdifout_channel(card)) == NULL) {
2851                                         kfree(card->states[i]);
2852                                         card->states[i] = NULL;
2853                                         return -EBUSY;
2854                                 }
2855                                 dmabuf->trigger |= SPDIF_ENABLE_OUTPUT;
2856                                 ali_set_spdifout_rate(state, controller_independent_spdif_locked);
2857                         } else {
2858                                 if ((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
2859                                         kfree(card->states[i]);
2860                                         card->states[i] = NULL;
2861                                         return -EBUSY;
2862                                 }
2863                                 /* Initialize to 8kHz?  What if we don't support 8kHz? */
2864                                 /*  Let's change this to check for S/PDIF stuff */
2865
2866                                 dmabuf->trigger |= PCM_ENABLE_OUTPUT;
2867                                 if (codec_pcmout_share_spdif_locked) {
2868                                         ali_set_dac_rate(state, codec_pcmout_share_spdif_locked);
2869                                         ali_set_spdif_output(state, AC97_EA_SPSA_3_4, codec_pcmout_share_spdif_locked);
2870                                 } else {
2871                                         ali_set_dac_rate(state, 8000);
2872                                 }
2873                         }
2874
2875                 }
2876         }
2877
2878         /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
2879            should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2880            /dev/dspW will accept 16-bits sample, but we don't support those so we
2881            set it immediately to stereo and 16bit, which is all we do support */
2882         dmabuf->fmt |= ALI5455_FMT_16BIT | ALI5455_FMT_STEREO;
2883         dmabuf->ossfragsize = 0;
2884         dmabuf->ossmaxfrags = 0;
2885         dmabuf->subdivision = 0;
2886         state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2887         outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
2888         outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
2889         return 0;
2890 }
2891
2892 static int ali_release(struct inode *inode, struct file *file)
2893 {
2894         struct ali_state *state = (struct ali_state *) file->private_data;
2895         struct ali_card *card = state->card;
2896         struct dmabuf *dmabuf = &state->dmabuf;
2897         unsigned long flags;
2898         lock_kernel();
2899
2900         /* stop DMA state machine and free DMA buffers/channels */
2901         if (dmabuf->trigger & PCM_ENABLE_OUTPUT)
2902                 drain_dac(state, 0);
2903
2904         if (dmabuf->trigger & SPDIF_ENABLE_OUTPUT)
2905                 drain_spdifout(state, 0);
2906
2907         if (dmabuf->trigger & PCM_ENABLE_INPUT)
2908                 stop_adc(state);
2909
2910         spin_lock_irqsave(&card->lock, flags);
2911         dealloc_dmabuf(state);
2912         if (file->f_mode & FMODE_WRITE) {
2913                 if (codec_independent_spdif_locked > 0) {
2914                         state->card->free_pcm_channel(state->card, dmabuf->codec_spdifout_channel->num);
2915                 } else {
2916                         if (controller_independent_spdif_locked > 0)
2917                                 state->card->free_pcm_channel(state->card,
2918                                                               dmabuf->controller_spdifout_channel->num);
2919                         else state->card->free_pcm_channel(state->card,
2920                                                               dmabuf->write_channel->num);
2921                 }
2922         }
2923         if (file->f_mode & FMODE_READ)
2924                 state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
2925
2926         state->card->states[state->virt] = NULL;
2927         kfree(state);
2928         spin_unlock_irqrestore(&card->lock, flags);
2929         unlock_kernel();
2930         return 0;
2931 }
2932
2933 static /*const */ struct file_operations ali_audio_fops = {
2934         owner:THIS_MODULE,
2935         llseek:no_llseek,
2936         read:ali_read,
2937         write:ali_write,
2938         poll:ali_poll,
2939         ioctl:ali_ioctl,
2940         mmap:ali_mmap,
2941         open:ali_open,
2942         release:ali_release,
2943 };
2944
2945 /* Read AC97 codec registers */
2946 static u16 ali_ac97_get(struct ac97_codec *dev, u8 reg)
2947 {
2948         struct ali_card *card = dev->private_data;
2949         int count1 = 100;
2950         char val;
2951         unsigned short int data, count, addr1, addr2;
2952
2953         while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2954                 udelay(1);
2955
2956         addr1 = reg;
2957         reg |= 0x0080;
2958         for (count = 0; count < 0x7f; count++) {
2959                 val = inb(card->iobase + ALI_CSPSR);
2960                 if (val & 0x08)
2961                         break;
2962         }
2963         if (count == 0x7f)
2964                 return -1;
2965         outw(reg, (card->iobase + ALI_CPR) + 2);
2966         for (count = 0; count < 0x7f; count++) {
2967                 val = inb(card->iobase + ALI_CSPSR);
2968                 if (val & 0x02) {
2969                         data = inw(card->iobase + ALI_SPR);
2970                         addr2 = inw((card->iobase + ALI_SPR) + 2);
2971                         break;
2972                 }
2973         }
2974         if (count == 0x7f)
2975                 return -1;
2976         if (addr2 != addr1)
2977                 return -1;
2978         return ((u16) data);
2979 }
2980
2981 /* write ac97 codec register   */
2982
2983 static void ali_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
2984 {
2985         struct ali_card *card = dev->private_data;
2986         int count1 = 100;
2987         unsigned long flags;
2988         char val;
2989         unsigned short int count;
2990
2991         while (count1-- && (inl(card->iobase + ALI_CAS) & 0x80000000))
2992                 udelay(1);
2993
2994         for (count = 0; count < 0x7f; count++) {
2995                 val = inb(card->iobase + ALI_CSPSR);
2996                 if (val & 0x08)
2997                         break;
2998         }
2999         if (count == 0x7f) {
3000                 printk(KERN_WARNING "ali_ac96_set: AC97 codec register access timed out. \n");
3001                 return;
3002         }
3003         outw(data, (card->iobase + ALI_CPR));
3004         outb(reg, (card->iobase + ALI_CPR) + 2);
3005         for (count = 0; count < 0x7f; count++) {
3006                 val = inb(card->iobase + ALI_CSPSR);
3007                 if (val & 0x01)
3008                         break;
3009         }
3010         if (count == 0x7f) {
3011                 printk(KERN_WARNING "ali_ac96_set: AC97 codec register access timed out. \n");
3012                 return;
3013         }
3014         return;
3015 }
3016
3017 /* OSS /dev/mixer file operation methods */
3018
3019 static int ali_open_mixdev(struct inode *inode, struct file *file)
3020 {
3021         int i;
3022         int minor = MINOR(inode->i_rdev);
3023         struct ali_card *card = devs;
3024         for (card = devs; card != NULL; card = card->next) {
3025                 /*
3026                  * If we are initializing and then fail, card could go
3027                  * away unuexpectedly while we are in the for() loop.
3028                  * So, check for card on each iteration before we check
3029                  * for card->initializing to avoid a possible oops.
3030                  * This usually only matters for times when the driver is
3031                  * autoloaded by kmod.
3032                  */
3033                 for (i = 0; i < 50 && card && card->initializing; i++) {
3034                         set_current_state(TASK_UNINTERRUPTIBLE);
3035                         schedule_timeout(HZ / 20);
3036                 }
3037                 for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
3038                         if (card->ac97_codec[i] != NULL
3039                             && card->ac97_codec[i]->dev_mixer == minor) {
3040                                 file->private_data = card->ac97_codec[i];
3041                                 return 0;
3042                         }
3043         }
3044         return -ENODEV;
3045 }
3046
3047 static int ali_ioctl_mixdev(struct inode *inode,
3048                             struct file *file,
3049                             unsigned int cmd, unsigned long arg)
3050 {
3051         struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
3052         return codec->mixer_ioctl(codec, cmd, arg);
3053 }
3054
3055 static /*const */ struct file_operations ali_mixer_fops = {
3056         owner:THIS_MODULE,
3057         llseek:no_llseek,
3058         ioctl:ali_ioctl_mixdev,
3059         open:ali_open_mixdev,
3060 };
3061
3062 /* AC97 codec initialisation.  These small functions exist so we don't
3063    duplicate code between module init and apm resume */
3064
3065 static inline int ali_ac97_exists(struct ali_card *card, int ac97_number)
3066 {
3067         unsigned int i = 1;
3068         u32 reg = inl(card->iobase + ALI_RTSR);
3069         if (ac97_number) {
3070                 while (i < 100) {
3071
3072                         reg = inl(card->iobase + ALI_RTSR);
3073                         if (reg & 0x40) {
3074                                 break;
3075                         } else {
3076                                 outl(reg | 0x00000040,
3077                                      card->iobase + 0x34);
3078                                 udelay(1);
3079                         }
3080                         i++;
3081                 }
3082
3083         } else {
3084                 while (i < 100) {
3085                         reg = inl(card->iobase + ALI_RTSR);
3086                         if (reg & 0x80) {
3087                                 break;
3088                         } else {
3089                                 outl(reg | 0x00000080,
3090                                      card->iobase + 0x34);
3091                                 udelay(1);
3092                         }
3093                         i++;
3094                 }
3095         }
3096
3097         if (ac97_number)
3098                 return reg & 0x40;
3099         else
3100                 return reg & 0x80;
3101 }
3102
3103 static inline int ali_ac97_enable_variable_rate(struct ac97_codec *codec)
3104 {
3105         ali_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
3106         ali_ac97_set(codec, AC97_EXTENDED_STATUS, ali_ac97_get(codec, AC97_EXTENDED_STATUS) | 0xE800);
3107         return (ali_ac97_get(codec, AC97_EXTENDED_STATUS) & 1);
3108 }
3109
3110
3111 static int ali_ac97_probe_and_powerup(struct ali_card *card, struct ac97_codec *codec)
3112 {
3113         /* Returns 0 on failure */
3114         int i;
3115         u16 addr;
3116         if (ac97_probe_codec(codec) == 0)
3117                 return 0;
3118         /* ac97_probe_codec is success ,then begin to init codec */
3119         ali_ac97_set(codec, AC97_RESET, 0xffff);
3120         if (card->channel[0].used == 1) {
3121                 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3122                 ali_ac97_set(codec, AC97_LINEIN_VOL, 0x0808);
3123                 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3124         }
3125
3126         if (card->channel[2].used == 1) //if MICin then init codec
3127         {
3128                 ali_ac97_set(codec, AC97_RECORD_SELECT, 0x0000);
3129                 ali_ac97_set(codec, AC97_MIC_VOL, 0x8808);
3130                 ali_ac97_set(codec, AC97_RECORD_GAIN, 0x0F0F);
3131                 ali_ac97_set(codec, AC97_RECORD_GAIN_MIC, 0x0000);
3132         }
3133
3134         ali_ac97_set(codec, AC97_MASTER_VOL_STEREO, 0x0000);
3135         ali_ac97_set(codec, AC97_HEADPHONE_VOL, 0x0000);
3136         ali_ac97_set(codec, AC97_PCMOUT_VOL, 0x0000);
3137         ali_ac97_set(codec, AC97_CD_VOL, 0x0808);
3138         ali_ac97_set(codec, AC97_VIDEO_VOL, 0x0808);
3139         ali_ac97_set(codec, AC97_AUX_VOL, 0x0808);
3140         ali_ac97_set(codec, AC97_PHONE_VOL, 0x8048);
3141         ali_ac97_set(codec, AC97_PCBEEP_VOL, 0x0000);
3142         ali_ac97_set(codec, AC97_GENERAL_PURPOSE, AC97_GP_MIX);
3143         ali_ac97_set(codec, AC97_MASTER_VOL_MONO, 0x0000);
3144         ali_ac97_set(codec, 0x38, 0x0000);
3145         addr = ali_ac97_get(codec, 0x2a);
3146         ali_ac97_set(codec, 0x2a, addr | 0x0001);
3147         addr = ali_ac97_get(codec, 0x2a);
3148         addr = ali_ac97_get(codec, 0x28);
3149         ali_ac97_set(codec, 0x2c, 0xbb80);
3150         addr = ali_ac97_get(codec, 0x2c);
3151         /* power it all up */
3152         ali_ac97_set(codec, AC97_POWER_CONTROL,
3153                      ali_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
3154         /* wait for analog ready */
3155         for (i = 10; i && ((ali_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--) {
3156                 set_current_state(TASK_UNINTERRUPTIBLE);
3157                 schedule_timeout(HZ / 20);
3158         }
3159         /* FIXME !! */
3160         i++;
3161         return i;
3162 }
3163
3164
3165 /* I clone ali5455(2.4.7 )  not clone i810_audio(2.4.18)  */
3166
3167 static int ali_reset_5455(struct ali_card *card)
3168 {
3169         outl(0x80000003, card->iobase + ALI_SCR);
3170         outl(0x83838383, card->iobase + ALI_FIFOCR1);
3171         outl(0x83838383, card->iobase + ALI_FIFOCR2);
3172         if (controller_pcmout_share_spdif_locked > 0) {
3173                 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3174                      card->iobase + ALI_SPDIFICS);
3175                 outl(0x0408000a, card->iobase + ALI_INTERFACECR);
3176         } else {
3177                 if (codec_independent_spdif_locked > 0) {
3178                         outl((inl(card->iobase + ALI_SCR) | 0x00100000), card->iobase + ALI_SCR);       // now I select slot 7 & 8
3179                         outl(0x00200000, card->iobase + ALI_INTERFACECR);       //enable codec independent spdifout
3180                 } else
3181                         outl(0x04080002, card->iobase + ALI_INTERFACECR);
3182         }
3183
3184         outl(0x00000000, card->iobase + ALI_INTERRUPTCR);
3185         outl(0x00000000, card->iobase + ALI_INTERRUPTSR);
3186         if (controller_independent_spdif_locked > 0)
3187                 outl((inl(card->iobase + ALI_SPDIFICS) | 0x00000001),
3188                      card->iobase + ALI_SPDIFICS);
3189         return 1;
3190 }
3191
3192
3193 static int ali_ac97_random_init_stuff(struct ali_card
3194                                       *card)
3195 {
3196         u32 reg = inl(card->iobase + ALI_SCR);
3197         int i = 0;
3198         reg = inl(card->iobase + ALI_SCR);
3199         if ((reg & 2) == 0)     /* Cold required */
3200                 reg |= 2;
3201         else
3202                 reg |= 1;       /* Warm */
3203         reg &= ~0x80000000;     /* ACLink on */
3204         outl(reg, card->iobase + ALI_SCR);
3205
3206         while (i < 10) {
3207                 if ((inl(card->iobase + 0x18) & (1 << 1)) == 0)
3208                         break;
3209                 current->state = TASK_UNINTERRUPTIBLE;
3210                 schedule_timeout(HZ / 20);
3211                 i++;
3212         }
3213         if (i == 10) {
3214                 printk(KERN_ERR "ali_audio: AC'97 reset failed.\n");
3215                 return 0;
3216         }
3217
3218         set_current_state(TASK_UNINTERRUPTIBLE);
3219         schedule_timeout(HZ / 2);
3220         return 1;
3221 }
3222
3223 /* AC97 codec initialisation. */
3224
3225 static int __init ali_ac97_init(struct ali_card *card)
3226 {
3227         int num_ac97 = 0;
3228         int total_channels = 0;
3229         struct ac97_codec *codec;
3230         u16 eid;
3231
3232         if (!ali_ac97_random_init_stuff(card))
3233                 return 0;
3234
3235         /* Number of channels supported */
3236         /* What about the codec?  Just because the ICH supports */
3237         /* multiple channels doesn't mean the codec does.       */
3238         /* we'll have to modify this in the codec section below */
3239         /* to reflect what the codec has.                       */
3240         /* ICH and ICH0 only support 2 channels so don't bother */
3241         /* to check....                                         */
3242         inl(card->iobase + ALI_CPR);
3243         card->channels = 2;
3244
3245         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3246
3247                 /* Assume codec isn't available until we go through the
3248                  * gauntlet below */
3249                 card->ac97_codec[num_ac97] = NULL;
3250                 /* The ICH programmer's reference says you should   */
3251                 /* check the ready status before probing. So we chk */
3252                 /*   What do we do if it's not ready?  Wait and try */
3253                 /*   again, or abort?                               */
3254                 if (!ali_ac97_exists(card, num_ac97)) {
3255                         if (num_ac97 == 0)
3256                                 printk(KERN_ERR "ali_audio: Primary codec not ready.\n");
3257                         break;
3258                 }
3259
3260                 if ((codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL)) == NULL)
3261                         return -ENOMEM;
3262                 memset(codec, 0, sizeof(struct ac97_codec));
3263                 /* initialize some basic codec information, other fields will be filled
3264                    in ac97_probe_codec */
3265                 codec->private_data = card;
3266                 codec->id = num_ac97;
3267                 codec->codec_read = ali_ac97_get;
3268                 codec->codec_write = ali_ac97_set;
3269                 if (!ali_ac97_probe_and_powerup(card, codec)) {
3270                         printk(KERN_ERR "ali_audio: timed out waiting for codec %d analog ready",
3271                              num_ac97);
3272                         kfree(codec);
3273                         break;  /* it didn't work */
3274                 }
3275
3276                 /* Store state information about S/PDIF transmitter */
3277                 card->ac97_status = 0;
3278                 /* Don't attempt to get eid until powerup is complete */
3279                 eid = ali_ac97_get(codec, AC97_EXTENDED_ID);
3280                 if (eid == 0xFFFFFF) {
3281                         printk(KERN_ERR "ali_audio: no codec attached ?\n");
3282                         kfree(codec);
3283                         break;
3284                 }
3285
3286                 card->ac97_features = eid;
3287                 /* Now check the codec for useful features to make up for
3288                    the dumbness of the ali5455 hardware engine */
3289                 if (!(eid & 0x0001))
3290                         printk(KERN_WARNING
3291                                "ali_audio: only 48Khz playback available.\n");
3292                 else {
3293                         if (!ali_ac97_enable_variable_rate(codec)) {
3294                                 printk(KERN_WARNING
3295                                        "ali_audio: Codec refused to allow VRA, using 48Khz only.\n");
3296                                 card->ac97_features &= ~1;
3297                         }
3298                 }
3299
3300                 /* Determine how many channels the codec(s) support   */
3301                 /*   - The primary codec always supports 2            */
3302                 /*   - If the codec supports AMAP, surround DACs will */
3303                 /*     automaticlly get assigned to slots.            */
3304                 /*     * Check for surround DACs and increment if     */
3305                 /*       found.                                       */
3306                 /*   - Else check if the codec is revision 2.2        */
3307                 /*     * If surround DACs exist, assign them to slots */
3308                 /*       and increment channel count.                 */
3309
3310                 /* All of this only applies to ICH2 and above. ICH    */
3311                 /* and ICH0 only support 2 channels.  ICH2 will only  */
3312                 /* support multiple codecs in a "split audio" config. */
3313                 /* as described above.                                */
3314
3315                 /* TODO: Remove all the debugging messages!           */
3316
3317                 if ((eid & 0xc000) == 0)        /* primary codec */
3318                         total_channels += 2;
3319                 if ((codec->dev_mixer = register_sound_mixer(&ali_mixer_fops, -1)) < 0) {
3320                         printk(KERN_ERR "ali_audio: couldn't register mixer!\n");
3321                         kfree(codec);
3322                         break;
3323                 }
3324                 card->ac97_codec[num_ac97] = codec;
3325         }
3326         /* pick the minimum of channels supported by ICHx or codec(s) */
3327         card->channels = (card->channels > total_channels) ? total_channels : card->channels;
3328         return num_ac97;
3329 }
3330
3331 static void __init ali_configure_clocking(void)
3332 {
3333         struct ali_card *card;
3334         struct ali_state *state;
3335         struct dmabuf *dmabuf;
3336         unsigned int i, offset, new_offset;
3337         unsigned long flags;
3338         card = devs;
3339
3340         /* We could try to set the clocking for multiple cards, but can you even have
3341          * more than one ali in a machine?  Besides, clocking is global, so unless
3342          * someone actually thinks more than one ali in a machine is possible and
3343          * decides to rewrite that little bit, setting the rate for more than one card
3344          * is a waste of time.
3345          */
3346         if (card != NULL) {
3347                 state = card->states[0] = (struct ali_state *)
3348                     kmalloc(sizeof(struct ali_state), GFP_KERNEL);
3349                 if (state == NULL)
3350                         return;
3351                 memset(state, 0, sizeof(struct ali_state));
3352                 dmabuf = &state->dmabuf;
3353                 dmabuf->write_channel = card->alloc_pcm_channel(card);
3354                 state->virt = 0;
3355                 state->card = card;
3356                 state->magic = ALI5455_STATE_MAGIC;
3357                 init_waitqueue_head(&dmabuf->wait);
3358                 init_MUTEX(&state->open_sem);
3359                 dmabuf->fmt = ALI5455_FMT_STEREO | ALI5455_FMT_16BIT;
3360                 dmabuf->trigger = PCM_ENABLE_OUTPUT;
3361                 ali_set_dac_rate(state, 48000);
3362                 if (prog_dmabuf(state, 0) != 0)
3363                         goto config_out_nodmabuf;
3364
3365                 if (dmabuf->dmasize < 16384)
3366                         goto config_out;
3367
3368                 dmabuf->count = dmabuf->dmasize;
3369                 outb(31, card->iobase + dmabuf->write_channel->port + OFF_LVI);
3370
3371                 save_flags(flags);
3372                 cli();
3373                 start_dac(state);
3374                 offset = ali_get_dma_addr(state, 0);
3375                 mdelay(50);
3376                 new_offset = ali_get_dma_addr(state, 0);
3377                 stop_dac(state);
3378
3379                 outb(2, card->iobase + dmabuf->write_channel->port + OFF_CR);
3380                 restore_flags(flags);
3381
3382                 i = new_offset - offset;
3383
3384                 if (i == 0)
3385                         goto config_out;
3386                 i = i / 4 * 20;
3387                 if (i > 48500 || i < 47500) {
3388                         clocking = clocking * clocking / i;
3389                 }
3390 config_out:
3391                 dealloc_dmabuf(state);
3392 config_out_nodmabuf:
3393                 state->card->free_pcm_channel(state->card, state->dmabuf. write_channel->num);
3394                 kfree(state);
3395                 card->states[0] = NULL;
3396         }
3397 }
3398
3399 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3400    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3401
3402 static int __init ali_probe(struct pci_dev *pci_dev, const struct pci_device_id
3403                             *pci_id)
3404 {
3405         struct ali_card *card;
3406         if (pci_enable_device(pci_dev))
3407                 return -EIO;
3408         if (pci_set_dma_mask(pci_dev, ALI5455_DMA_MASK)) {
3409                 printk(KERN_ERR "ali5455: architecture does not support"
3410                        " 32bit PCI busmaster DMA\n");
3411                 return -ENODEV;
3412         }
3413
3414         if ((card = kmalloc(sizeof(struct ali_card), GFP_KERNEL)) == NULL) {
3415                 printk(KERN_ERR "ali_audio: out of memory\n");
3416                 return -ENOMEM;
3417         }
3418         memset(card, 0, sizeof(*card));
3419         card->initializing = 1;
3420         card->iobase = pci_resource_start(pci_dev, 0);
3421         card->pci_dev = pci_dev;
3422         card->pci_id = pci_id->device;
3423         card->irq = pci_dev->irq;
3424         card->next = devs;
3425         card->magic = ALI5455_CARD_MAGIC;
3426 #ifdef CONFIG_PM
3427         card->pm_suspended = 0;
3428 #endif
3429         spin_lock_init(&card->lock);
3430         devs = card;
3431         pci_set_master(pci_dev);
3432         printk(KERN_INFO "ali: %s found at IO 0x%04lx, IRQ %d\n",
3433                card_names[pci_id->driver_data], card->iobase, card->irq);
3434         card->alloc_pcm_channel = ali_alloc_pcm_channel;
3435         card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
3436         card->alloc_rec_mic_channel = ali_alloc_rec_mic_channel;
3437         card->alloc_codec_spdifout_channel = ali_alloc_codec_spdifout_channel;
3438         card->alloc_controller_spdifout_channel = ali_alloc_controller_spdifout_channel;
3439         card->free_pcm_channel = ali_free_pcm_channel;
3440         card->channel[0].offset = 0;
3441         card->channel[0].port = 0x40;
3442         card->channel[0].num = 0;
3443         card->channel[1].offset = 0;
3444         card->channel[1].port = 0x50;
3445         card->channel[1].num = 1;
3446         card->channel[2].offset = 0;
3447         card->channel[2].port = 0x60;
3448         card->channel[2].num = 2;
3449         card->channel[3].offset = 0;
3450         card->channel[3].port = 0x70;
3451         card->channel[3].num = 3;
3452         card->channel[4].offset = 0;
3453         card->channel[4].port = 0xb0;
3454         card->channel[4].num = 4;
3455         /* claim our iospace and irq */
3456         request_region(card->iobase, 256, card_names[pci_id->driver_data]);
3457         if (request_irq(card->irq, &ali_interrupt, SA_SHIRQ,
3458                         card_names[pci_id->driver_data], card)) {
3459                 printk(KERN_ERR "ali_audio: unable to allocate irq %d\n",
3460                        card->irq);
3461                 release_region(card->iobase, 256);
3462                 kfree(card);
3463                 return -ENODEV;
3464         }
3465
3466         if (ali_reset_5455(card) <= 0) {
3467                 unregister_sound_dsp(card->dev_audio);
3468                 release_region(card->iobase, 256);
3469                 free_irq(card->irq, card);
3470                 kfree(card);
3471                 return -ENODEV;
3472         }
3473
3474         /* initialize AC97 codec and register /dev/mixer */
3475         if (ali_ac97_init(card) < 0) {
3476                 release_region(card->iobase, 256);
3477                 free_irq(card->irq, card);
3478                 kfree(card);
3479                 return -ENODEV;
3480         }
3481
3482         pci_set_drvdata(pci_dev, card);
3483
3484         if (clocking == 0) {
3485                 clocking = 48000;
3486                 ali_configure_clocking();
3487         }
3488
3489         /* register /dev/dsp */
3490         if ((card->dev_audio = register_sound_dsp(&ali_audio_fops, -1)) < 0) {
3491                 int i;
3492                 printk(KERN_ERR"ali_audio: couldn't register DSP device!\n");
3493                 release_region(card->iobase, 256);
3494                 free_irq(card->irq, card);
3495                 for (i = 0; i < NR_AC97; i++)
3496                         if (card->ac97_codec[i] != NULL) {
3497                                 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
3498                                 kfree(card->ac97_codec[i]);
3499                         }
3500                 kfree(card);
3501                 return -ENODEV;
3502         }
3503         card->initializing = 0;
3504         return 0;
3505 }
3506
3507 static void __devexit ali_remove(struct pci_dev *pci_dev)
3508 {
3509         int i;
3510         struct ali_card *card = pci_get_drvdata(pci_dev);
3511         /* free hardware resources */
3512         free_irq(card->irq, devs);
3513         release_region(card->iobase, 256);
3514         /* unregister audio devices */
3515         for (i = 0; i < NR_AC97; i++)
3516                 if (card->ac97_codec[i] != NULL) {
3517                         unregister_sound_mixer(card->ac97_codec[i]->
3518                                                dev_mixer);
3519                         kfree(card->ac97_codec[i]);
3520                         card->ac97_codec[i] = NULL;
3521                 }
3522         unregister_sound_dsp(card->dev_audio);
3523         kfree(card);
3524 }
3525
3526 #ifdef CONFIG_PM
3527 static int ali_pm_suspend(struct pci_dev *dev, u32 pm_state)
3528 {
3529         struct ali_card *card = pci_get_drvdata(dev);
3530         struct ali_state *state;
3531         unsigned long flags;
3532         struct dmabuf *dmabuf;
3533         int i, num_ac97;
3534
3535         if (!card)
3536                 return 0;
3537         spin_lock_irqsave(&card->lock, flags);
3538         card->pm_suspended = 1;
3539         for (i = 0; i < NR_HW_CH; i++) {
3540                 state = card->states[i];
3541                 if (!state)
3542                         continue;
3543                 /* this happens only if there are open files */
3544                 dmabuf = &state->dmabuf;
3545                 if (dmabuf->enable & DAC_RUNNING ||
3546                     (dmabuf->count
3547                      && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
3548                         state->pm_saved_dac_rate = dmabuf->rate;
3549                         stop_dac(state);
3550                 } else {
3551                         state->pm_saved_dac_rate = 0;
3552                 }
3553                 if (dmabuf->enable & ADC_RUNNING) {
3554                         state->pm_saved_adc_rate = dmabuf->rate;
3555                         stop_adc(state);
3556                 } else {
3557                         state->pm_saved_adc_rate = 0;
3558                 }
3559                 dmabuf->ready = 0;
3560                 dmabuf->swptr = dmabuf->hwptr = 0;
3561                 dmabuf->count = dmabuf->total_bytes = 0;
3562         }
3563
3564         spin_unlock_irqrestore(&card->lock, flags);
3565         /* save mixer settings */
3566         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3567                 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3568                 if (!codec)
3569                         continue;
3570                 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3571                         if ((supported_mixer(codec, i)) && (codec->read_mixer)) {
3572                                 card->pm_saved_mixer_settings[i][num_ac97] = codec->read_mixer(codec, i);
3573                         }
3574                 }
3575         }
3576         pci_save_state(dev, card->pm_save_state);       /* XXX do we need this? */
3577         pci_disable_device(dev);        /* disable busmastering */
3578         pci_set_power_state(dev, 3);    /* Zzz. */
3579         return 0;
3580 }
3581
3582
3583 static int ali_pm_resume(struct pci_dev *dev)
3584 {
3585         int num_ac97, i = 0;
3586         struct ali_card *card = pci_get_drvdata(dev);
3587         pci_enable_device(dev);
3588         pci_restore_state(dev, card->pm_save_state);
3589         /* observation of a toshiba portege 3440ct suggests that the
3590            hardware has to be more or less completely reinitialized from
3591            scratch after an apm suspend.  Works For Me.   -dan */
3592         ali_ac97_random_init_stuff(card);
3593         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3594                 struct ac97_codec *codec = card->ac97_codec[num_ac97];
3595                 /* check they haven't stolen the hardware while we were
3596                    away */
3597                 if (!codec || !ali_ac97_exists(card, num_ac97)) {
3598                         if (num_ac97)
3599                                 continue;
3600                         else
3601                                 BUG();
3602                 }
3603                 if (!ali_ac97_probe_and_powerup(card, codec))
3604                         BUG();
3605                 if ((card->ac97_features & 0x0001)) {
3606                         /* at probe time we found we could do variable
3607                            rates, but APM suspend has made it forget
3608                            its magical powers */
3609                         if (!ali_ac97_enable_variable_rate(codec))
3610                                 BUG();
3611                 }
3612                 /* we lost our mixer settings, so restore them */
3613                 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
3614                         if (supported_mixer(codec, i)) {
3615                                 int val = card->pm_saved_mixer_settings[i][num_ac97];
3616                                 codec->mixer_state[i] = val;
3617                                 codec->write_mixer(codec, i,
3618                                                    (val & 0xff),
3619                                                    ((val >> 8) & 0xff));
3620                         }
3621                 }
3622         }
3623
3624         /* we need to restore the sample rate from whatever it was */
3625         for (i = 0; i < NR_HW_CH; i++) {
3626                 struct ali_state *state = card->states[i];
3627                 if (state) {
3628                         if (state->pm_saved_adc_rate)
3629                                 ali_set_adc_rate(state, state->pm_saved_adc_rate);
3630                         if (state->pm_saved_dac_rate)
3631                                 ali_set_dac_rate(state, state->pm_saved_dac_rate);
3632                 }
3633         }
3634
3635         card->pm_suspended = 0;
3636         /* any processes that were reading/writing during the suspend
3637            probably ended up here */
3638         for (i = 0; i < NR_HW_CH; i++) {
3639                 struct ali_state *state = card->states[i];
3640                 if (state)
3641                         wake_up(&state->dmabuf.wait);
3642         }
3643         return 0;
3644 }
3645 #endif                          /* CONFIG_PM */
3646
3647 MODULE_AUTHOR("");
3648 MODULE_DESCRIPTION("ALI 5455 audio support");
3649 MODULE_LICENSE("GPL");
3650 MODULE_PARM(clocking, "i");
3651 MODULE_PARM(strict_clocking, "i");
3652 MODULE_PARM(codec_pcmout_share_spdif_locked, "i");
3653 MODULE_PARM(codec_independent_spdif_locked, "i");
3654 MODULE_PARM(controller_pcmout_share_spdif_locked, "i");
3655 MODULE_PARM(controller_independent_spdif_locked, "i");
3656 #define ALI5455_MODULE_NAME "ali5455"
3657 static struct pci_driver ali_pci_driver = {
3658         name:ALI5455_MODULE_NAME, id_table:ali_pci_tbl, probe:ali_probe,
3659             remove:__devexit_p(ali_remove),
3660 #ifdef CONFIG_PM
3661         suspend:ali_pm_suspend, resume:ali_pm_resume,
3662 #endif                          /* CONFIG_PM */
3663 };
3664
3665 static int __init ali_init_module(void)
3666 {
3667         if (!pci_present())     /* No PCI bus in this machine! */
3668                 return -ENODEV;
3669         printk(KERN_INFO "ALI 5455 + AC97 Audio, version "
3670                DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
3671
3672         if (codec_independent_spdif_locked > 0) {
3673                 if (codec_independent_spdif_locked == 32000
3674                     || codec_independent_spdif_locked == 44100
3675                     || codec_independent_spdif_locked == 48000) {
3676                         printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_independent_spdif_locked);
3677                 } else {
3678                         printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3679                         codec_independent_spdif_locked = 0;
3680                 }
3681         }
3682         if (controller_independent_spdif_locked > 0) {
3683                 if (controller_independent_spdif_locked == 32000
3684                     || controller_independent_spdif_locked == 44100
3685                     || controller_independent_spdif_locked == 48000) {
3686                         printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", controller_independent_spdif_locked);
3687                 } else {
3688                         printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3689                         controller_independent_spdif_locked = 0;
3690                 }
3691         }
3692
3693         if (codec_pcmout_share_spdif_locked > 0) {
3694                 if (codec_pcmout_share_spdif_locked == 32000
3695                     || codec_pcmout_share_spdif_locked == 44100
3696                     || codec_pcmout_share_spdif_locked == 48000) {
3697                         printk(KERN_INFO "ali_audio: Enabling S/PDIF at sample rate %dHz.\n", codec_pcmout_share_spdif_locked);
3698                 } else {
3699                         printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3700                         codec_pcmout_share_spdif_locked = 0;
3701                 }
3702         }
3703         if (controller_pcmout_share_spdif_locked > 0) {
3704                 if (controller_pcmout_share_spdif_locked == 32000
3705                     || controller_pcmout_share_spdif_locked == 44100
3706                     || controller_pcmout_share_spdif_locked == 48000) {
3707                         printk(KERN_INFO "ali_audio: Enabling controller S/PDIF at sample rate %dHz.\n", controller_pcmout_share_spdif_locked);
3708                 } else {
3709                         printk(KERN_INFO "ali_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
3710                         controller_pcmout_share_spdif_locked = 0;
3711                 }
3712         }
3713         if (!pci_register_driver(&ali_pci_driver)) {
3714                 pci_unregister_driver(&ali_pci_driver);
3715                 return -ENODEV;
3716         }
3717         return 0;
3718 }
3719
3720 static void __exit ali_cleanup_module(void)
3721 {
3722         pci_unregister_driver(&ali_pci_driver);
3723 }
3724
3725 module_init(ali_init_module);
3726 module_exit(ali_cleanup_module);
3727 /*
3728 Local Variables:
3729 c-basic-offset: 8
3730 End:
3731 */