sound/oss/cs46xx.c

   1 /*
   2  *      Crystal SoundFusion CS46xx driver
   3  *
   4  *      Copyright 1998-2001 Cirrus Logic Corporation <pcaudio@crystal.cirrus.com>
   5  *                                              <twoller@crystal.cirrus.com>
   6  *      Copyright 1999-2000 Jaroslav Kysela <perex@suse.cz>
   7  *      Copyright 2000 Alan Cox <alan@redhat.com>
   8  *
   9  *      The core of this code is taken from the ALSA project driver by
  10  *      Jaroslav. Please send Jaroslav the credit for the driver and
  11  *      report bugs in this port to <alan@redhat.com>
  12  *
  13  *      This program is free software; you can redistribute it and/or modify
  14  *      it under the terms of the GNU General Public License as published by
  15  *      the Free Software Foundation; either version 2 of the License, or
  16  *      (at your option) any later version.
  17  *
  18  *      This program is distributed in the hope that it will be useful,
  19  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *      GNU General Public License for more details.
  22  *
  23  *      You should have received a copy of the GNU General Public License
  24  *      along with this program; if not, write to the Free Software
  25  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *      Current maintainers:
  27  *              Cirrus Logic Corporation, Thomas Woller (tw)
  28  *                      <twoller@crystal.cirrus.com>
  29  *              Nils Faerber (nf)
  30  *                      <nils@kernelconcepts.de>
  31  *              Thanks to David Pollard for testing.
  32  *
  33  *      Changes:
  34  *      20000909-nf     Changed cs_read, cs_write and drain_dac
  35  *      20001025-tw     Separate Playback/Capture structs and buffers.
  36  *                      Added Scatter/Gather support for Playback.
  37  *                      Added Capture.
  38  *      20001027-nf     Port to kernel 2.4.0-test9, some clean-ups
  39  *                      Start of powermanagement support (CS46XX_PM).
  40  *      20001128-tw     Add module parm for default buffer order.
  41  *                      added DMA_GFP flag to kmalloc dma buffer allocs.
  42  *                      backfill silence to eliminate stuttering on
  43  *                      underruns.
  44  *      20001201-tw     add resyncing of swptr on underruns.
  45  *      20001205-tw-nf  fixed GETOSPACE ioctl() after open()
  46  *      20010113-tw     patch from Hans Grobler general cleanup.
  47  *      20010117-tw     2.4.0 pci cleanup, wrapper code for 2.2.16-2.4.0
  48  *      20010118-tw     basic PM support for 2.2.16+ and 2.4.0/2.4.2.
  49  *      20010228-dh     patch from David Huggins - cs_update_ptr recursion.
  50  *      20010409-tw     add hercules game theatre XP amp code.
  51  *      20010420-tw     cleanup powerdown/up code.
  52  *      20010521-tw     eliminate pops, and fixes for powerdown.
  53  *      20010525-tw     added fixes for thinkpads with powerdown logic.
  54  *      20010723-sh     patch from Horms (Simon Horman) -
  55  *                      SOUND_PCM_READ_BITS returns bits as set in driver
  56  *                      rather than a logical or of the possible values.
  57  *                      Various ioctls handle the case where the device
  58  *                      is open for reading or writing but not both better.
  59  *
  60  *      Status:
  61  *      Playback/Capture supported from 8k-48k.
  62  *      16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
  63  *
  64  *      APM/PM - 2.2.x APM is enabled and functioning fine. APM can also
  65  *      be enabled for 2.4.x by modifying the CS46XX_ACPI_SUPPORT macro
  66  *      definition.
  67  *
  68  *      Hercules Game Theatre XP - the EGPIO2 pin controls the external Amp,
  69  *      so, use the drain/polarity to enable.
  70  *      hercules_egpio_disable set to 1, will force a 0 to EGPIODR.
  71  *
  72  *      VTB Santa Cruz - the GPIO7/GPIO8 on the Secondary Codec control
  73  *      the external amplifier for the "back" speakers, since we do not
  74  *      support the secondary codec then this external amp is also not
  75  *      turned on.
  76  */
  77
  78 #include <linux/interrupt.h>
  79 #include <linux/list.h>
  80 #include <linux/module.h>
  81 #include <linux/string.h>
  82 #include <linux/ioport.h>
  83 #include <linux/sched.h>
  84 #include <linux/delay.h>
  85 #include <linux/sound.h>
  86 #include <linux/slab.h>
  87 #include <linux/soundcard.h>
  88 #include <linux/pci.h>
  89 #include <linux/bitops.h>
  90 #include <linux/init.h>
  91 #include <linux/poll.h>
  92 #include <linux/ac97_codec.h>
  93
  94 #include <asm/io.h>
  95 #include <asm/dma.h>
  96 #include <asm/uaccess.h>
  97
  98 #include "cs46xxpm-24.h"
  99 #include "cs46xx_wrapper-24.h"
 100 #include "cs461x.h"
 101
 102 /* MIDI buffer sizes */
 103 #define CS_MIDIINBUF  500
 104 #define CS_MIDIOUTBUF 500
 105
 106 #define ADC_RUNNING     1
 107 #define DAC_RUNNING     2
 108
 109 #define CS_FMT_16BIT    1               /* These are fixed in fact */
 110 #define CS_FMT_STEREO   2
 111 #define CS_FMT_MASK     3
 112
 113 #define CS_TYPE_ADC     1
 114 #define CS_TYPE_DAC     2
 115
 116 #define CS_TRUE         1
 117 #define CS_FALSE        0
 118
 119 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
 120 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
 121 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
 122 #define CS_IN_USE(m) (atomic_read(m) != 0)
 123
 124 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
 125 /*
 126  *      CS461x definitions
 127  */
 128
 129 #define CS461X_BA0_SIZE         0x2000
 130 #define CS461X_BA1_DATA0_SIZE   0x3000
 131 #define CS461X_BA1_DATA1_SIZE   0x3800
 132 #define CS461X_BA1_PRG_SIZE     0x7000
 133 #define CS461X_BA1_REG_SIZE     0x0100
 134
 135 #define GOF_PER_SEC     200
 136
 137 #define CSDEBUG_INTERFACE 1
 138 #define CSDEBUG 1
 139 /*
 140  * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
 141  *
 142  *
 143  * CSDEBUG is usual mode is set to 1, then use the
 144  * cs_debuglevel and cs_debugmask to turn on or off debugging.
 145  * Debug level of 1 has been defined to be kernel errors and info
 146  * that should be printed on any released driver.
 147  */
 148 #if CSDEBUG
 149 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
 150 #else
 151 #define CS_DBGOUT(mask,level,x)
 152 #endif
 153 /*
 154  * cs_debugmask areas
 155  */
 156 #define CS_INIT         0x00000001              /* initialization and probe functions */
 157 #define CS_ERROR        0x00000002              /* tmp debugging bit placeholder */
 158 #define CS_INTERRUPT    0x00000004              /* interrupt handler (separate from all other) */
 159 #define CS_FUNCTION     0x00000008              /* enter/leave functions */
 160 #define CS_WAVE_WRITE   0x00000010              /* write information for wave */
 161 #define CS_WAVE_READ    0x00000020              /* read information for wave */
 162 #define CS_MIDI_WRITE   0x00000040              /* write information for midi */
 163 #define CS_MIDI_READ    0x00000080              /* read information for midi */
 164 #define CS_MPU401_WRITE 0x00000100              /* write information for mpu401 */
 165 #define CS_MPU401_READ  0x00000200              /* read information for mpu401 */
 166 #define CS_OPEN         0x00000400              /* all open functions in the driver */
 167 #define CS_RELEASE      0x00000800              /* all release functions in the driver */
 168 #define CS_PARMS        0x00001000              /* functional and operational parameters */
 169 #define CS_IOCTL        0x00002000              /* ioctl (non-mixer) */
 170 #define CS_PM           0x00004000              /* PM */
 171 #define CS_TMP          0x10000000              /* tmp debug mask bit */
 172
 173 #define CS_IOCTL_CMD_SUSPEND    0x1     // suspend
 174 #define CS_IOCTL_CMD_RESUME     0x2     // resume
 175
 176 #if CSDEBUG
 177 static unsigned long cs_debuglevel=1;                   /* levels range from 1-9 */
 178 MODULE_PARM(cs_debuglevel, "i");
 179 static unsigned long cs_debugmask=CS_INIT | CS_ERROR;   /* use CS_DBGOUT with various mask values */
 180 MODULE_PARM(cs_debugmask, "i");
 181 #endif
 182 static unsigned long hercules_egpio_disable;  /* if non-zero set all EGPIO to 0 */
 183 MODULE_PARM(hercules_egpio_disable, "i");
 184 static unsigned long initdelay=700;  /* PM delay in millisecs */
 185 MODULE_PARM(initdelay, "i");
 186 static unsigned long powerdown=-1;  /* turn on/off powerdown processing in driver */
 187 MODULE_PARM(powerdown, "i");
 188 #define DMABUF_DEFAULTORDER 3
 189 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
 190 MODULE_PARM(defaultorder, "i");
 191
 192 static int external_amp;
 193 MODULE_PARM(external_amp, "i");
 194 static int thinkpad;
 195 MODULE_PARM(thinkpad, "i");
 196
 197 /*
 198 * set the powerdown module parm to 0 to disable all
 199 * powerdown. also set thinkpad to 1 to disable powerdown,
 200 * but also to enable the clkrun functionality.
 201 */
 202 static unsigned cs_powerdown=1;
 203 static unsigned cs_laptop_wait=1;
 204
 205 /* An instance of the 4610 channel */
 206 struct cs_channel
 207 {
 208         int used;
 209         int num;
 210         void *state;
 211 };
 212
 213 #define CS46XX_MAJOR_VERSION "1"
 214 #define CS46XX_MINOR_VERSION "28"
 215
 216 #ifdef __ia64__
 217 #define CS46XX_ARCH             "64"    //architecture key
 218 #else
 219 #define CS46XX_ARCH             "32"    //architecture key
 220 #endif
 221
 222 struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
 223
 224 /* magic numbers to protect our data structures */
 225 #define CS_CARD_MAGIC           0x43525553 /* "CRUS" */
 226 #define CS_STATE_MAGIC          0x4c4f4749 /* "LOGI" */
 227 #define NR_HW_CH                3
 228
 229 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
 230 #define NR_AC97         2
 231
 232 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 233 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 234
 235 /* "software" or virtual channel, an instance of opened /dev/dsp */
 236 struct cs_state {
 237         unsigned int magic;
 238         struct cs_card *card;   /* Card info */
 239
 240         /* single open lock mechanism, only used for recording */
 241         struct semaphore open_sem;
 242         wait_queue_head_t open_wait;
 243
 244         /* file mode */
 245         mode_t open_mode;
 246
 247         /* virtual channel number */
 248         int virt;
 249
 250         struct dmabuf {
 251                 /* wave sample stuff */
 252                 unsigned int rate;
 253                 unsigned char fmt, enable;
 254
 255                 /* hardware channel */
 256                 struct cs_channel *channel;
 257                 int pringbuf;           /* Software ring slot */
 258                 void *pbuf;             /* 4K hardware DMA buffer */
 259
 260                 /* OSS buffer management stuff */
 261                 void *rawbuf;
 262                 dma_addr_t dma_handle;
 263                 unsigned buforder;
 264                 unsigned numfrag;
 265                 unsigned fragshift;
 266                 unsigned divisor;
 267                 unsigned type;
 268                 void *tmpbuff;                  /* tmp buffer for sample conversions */
 269                 dma_addr_t dmaaddr;
 270                 dma_addr_t dmaaddr_tmpbuff;
 271                 unsigned buforder_tmpbuff;      /* Log base 2 of size in bytes.. */
 272
 273                 /* our buffer acts like a circular ring */
 274                 unsigned hwptr;         /* where dma last started, updated by update_ptr */
 275                 unsigned swptr;         /* where driver last clear/filled, updated by read/write */
 276                 int count;              /* bytes to be comsumed or been generated by dma machine */
 277                 unsigned total_bytes;   /* total bytes dmaed by hardware */
 278                 unsigned blocks;        /* total blocks */
 279
 280                 unsigned error;         /* number of over/underruns */
 281                 unsigned underrun;      /* underrun pending before next write has occurred */
 282                 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
 283
 284                 /* redundant, but makes calculations easier */
 285                 unsigned fragsize;
 286                 unsigned dmasize;
 287                 unsigned fragsamples;
 288
 289                 /* OSS stuff */
 290                 unsigned mapped:1;
 291                 unsigned ready:1;
 292                 unsigned endcleared:1;
 293                 unsigned SGok:1;
 294                 unsigned update_flag;
 295                 unsigned ossfragshift;
 296                 int ossmaxfrags;
 297                 unsigned subdivision;
 298         } dmabuf;
 299         /* Guard against mmap/write/read races */
 300         struct semaphore sem;
 301 };
 302
 303 struct cs_card {
 304         struct cs_channel channel[2];
 305         unsigned int magic;
 306
 307         /* We keep cs461x cards in a linked list */
 308         struct cs_card *next;
 309
 310         /* The cs461x has a certain amount of cross channel interaction
 311            so we use a single per card lock */
 312         spinlock_t lock;
 313
 314         /* Keep AC97 sane */
 315         spinlock_t ac97_lock;
 316
 317         /* mixer use count */
 318         atomic_t mixer_use_cnt;
 319
 320         /* PCI device stuff */
 321         struct pci_dev * pci_dev;
 322         struct list_head list;
 323
 324         unsigned int pctl, cctl;        /* Hardware DMA flag sets */
 325
 326         /* soundcore stuff */
 327         int dev_audio;
 328         int dev_midi;
 329
 330         /* structures for abstraction of hardware facilities, codecs, banks and channels*/
 331         struct ac97_codec *ac97_codec[NR_AC97];
 332         struct cs_state *states[2];
 333
 334         u16 ac97_features;
 335
 336         int amplifier;                  /* Amplifier control */
 337         void (*amplifier_ctrl)(struct cs_card *, int);
 338         void (*amp_init)(struct cs_card *);
 339
 340         int active;                     /* Active clocking */
 341         void (*active_ctrl)(struct cs_card *, int);
 342
 343         /* hardware resources */
 344         unsigned long ba0_addr;
 345         unsigned long ba1_addr;
 346         u32 irq;
 347
 348         /* mappings */
 349         void *ba0;
 350         union
 351         {
 352                 struct
 353                 {
 354                         u8 *data0;
 355                         u8 *data1;
 356                         u8 *pmem;
 357                         u8 *reg;
 358                 } name;
 359                 u8 *idx[4];
 360         } ba1;
 361
 362         /* Function support */
 363         struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
 364         struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
 365         void (*free_pcm_channel)(struct cs_card *, int chan);
 366
 367         /* /dev/midi stuff */
 368         struct {
 369                 unsigned ird, iwr, icnt;
 370                 unsigned ord, owr, ocnt;
 371                 wait_queue_head_t open_wait;
 372                 wait_queue_head_t iwait;
 373                 wait_queue_head_t owait;
 374                 spinlock_t lock;
 375                 unsigned char ibuf[CS_MIDIINBUF];
 376                 unsigned char obuf[CS_MIDIOUTBUF];
 377                 mode_t open_mode;
 378                 struct semaphore open_sem;
 379         } midi;
 380         struct cs46xx_pm pm;
 381 };
 382
 383 static int cs_open_mixdev(struct inode *inode, struct file *file);
 384 static int cs_release_mixdev(struct inode *inode, struct file *file);
 385 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 386                                 unsigned long arg);
 387 static int cs_hardware_init(struct cs_card *card);
 388 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
 389 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
 390 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
 391 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state);
 392 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
 393
 394 static inline unsigned ld2(unsigned int x)
 395 {
 396         unsigned r = 0;
 397
 398         if (x >= 0x10000) {
 399                 x >>= 16;
 400                 r += 16;
 401         }
 402         if (x >= 0x100) {
 403                 x >>= 8;
 404                 r += 8;
 405         }
 406         if (x >= 0x10) {
 407                 x >>= 4;
 408                 r += 4;
 409         }
 410         if (x >= 4) {
 411                 x >>= 2;
 412                 r += 2;
 413         }
 414         if (x >= 2)
 415                 r++;
 416         return r;
 417 }
 418
 419 #if CSDEBUG
 420
 421 /* DEBUG ROUTINES */
 422
 423 #define SOUND_MIXER_CS_GETDBGLEVEL      _SIOWR('M',120, int)
 424 #define SOUND_MIXER_CS_SETDBGLEVEL      _SIOWR('M',121, int)
 425 #define SOUND_MIXER_CS_GETDBGMASK       _SIOWR('M',122, int)
 426 #define SOUND_MIXER_CS_SETDBGMASK       _SIOWR('M',123, int)
 427 #define SOUND_MIXER_CS_APM              _SIOWR('M',124, int)
 428
 429 void printioctl(unsigned int x)
 430 {
 431     unsigned int i;
 432     unsigned char vidx;
 433         /* these values are incorrect for the ac97 driver, fix.
 434          * Index of mixtable1[] member is Device ID
 435          * and must be <= SOUND_MIXER_NRDEVICES.
 436          * Value of array member is index into s->mix.vol[]
 437          */
 438         static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
 439                 [SOUND_MIXER_PCM]     = 1,   /* voice */
 440                 [SOUND_MIXER_LINE1]   = 2,   /* AUX */
 441                 [SOUND_MIXER_CD]      = 3,   /* CD */
 442                 [SOUND_MIXER_LINE]    = 4,   /* Line */
 443                 [SOUND_MIXER_SYNTH]   = 5,   /* FM */
 444                 [SOUND_MIXER_MIC]     = 6,   /* Mic */
 445                 [SOUND_MIXER_SPEAKER] = 7,   /* Speaker */
 446                 [SOUND_MIXER_RECLEV]  = 8,   /* Recording level */
 447                 [SOUND_MIXER_VOLUME]  = 9    /* Master Volume */
 448         };
 449
 450     switch(x)
 451     {
 452         case SOUND_MIXER_CS_GETDBGMASK:
 453                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
 454                 break;
 455         case SOUND_MIXER_CS_GETDBGLEVEL:
 456                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
 457                 break;
 458         case SOUND_MIXER_CS_SETDBGMASK:
 459                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
 460                 break;
 461         case SOUND_MIXER_CS_SETDBGLEVEL:
 462                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
 463                 break;
 464         case OSS_GETVERSION:
 465                 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
 466                 break;
 467         case SNDCTL_DSP_SYNC:
 468                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
 469                 break;
 470         case SNDCTL_DSP_SETDUPLEX:
 471                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
 472                 break;
 473         case SNDCTL_DSP_GETCAPS:
 474                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
 475                 break;
 476         case SNDCTL_DSP_RESET:
 477                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
 478                 break;
 479         case SNDCTL_DSP_SPEED:
 480                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
 481                 break;
 482         case SNDCTL_DSP_STEREO:
 483                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
 484                 break;
 485         case SNDCTL_DSP_CHANNELS:
 486                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
 487                 break;
 488         case SNDCTL_DSP_GETFMTS:
 489                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
 490                 break;
 491         case SNDCTL_DSP_SETFMT:
 492                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
 493                 break;
 494         case SNDCTL_DSP_POST:
 495                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
 496                 break;
 497         case SNDCTL_DSP_GETTRIGGER:
 498                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
 499                 break;
 500         case SNDCTL_DSP_SETTRIGGER:
 501                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
 502                 break;
 503         case SNDCTL_DSP_GETOSPACE:
 504                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
 505                 break;
 506         case SNDCTL_DSP_GETISPACE:
 507                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
 508                 break;
 509         case SNDCTL_DSP_NONBLOCK:
 510                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
 511                 break;
 512         case SNDCTL_DSP_GETODELAY:
 513                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
 514                 break;
 515         case SNDCTL_DSP_GETIPTR:
 516                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
 517                 break;
 518         case SNDCTL_DSP_GETOPTR:
 519                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
 520                 break;
 521         case SNDCTL_DSP_GETBLKSIZE:
 522                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
 523                 break;
 524         case SNDCTL_DSP_SETFRAGMENT:
 525                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
 526                 break;
 527         case SNDCTL_DSP_SUBDIVIDE:
 528                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
 529                 break;
 530         case SOUND_PCM_READ_RATE:
 531                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
 532                 break;
 533         case SOUND_PCM_READ_CHANNELS:
 534                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
 535                 break;
 536         case SOUND_PCM_READ_BITS:
 537                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
 538                 break;
 539         case SOUND_PCM_WRITE_FILTER:
 540                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
 541                 break;
 542         case SNDCTL_DSP_SETSYNCRO:
 543                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
 544                 break;
 545         case SOUND_PCM_READ_FILTER:
 546                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
 547                 break;
 548
 549         case SOUND_MIXER_PRIVATE1:
 550                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
 551                 break;
 552         case SOUND_MIXER_PRIVATE2:
 553                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
 554                 break;
 555         case SOUND_MIXER_PRIVATE3:
 556                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
 557                 break;
 558         case SOUND_MIXER_PRIVATE4:
 559                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
 560                 break;
 561         case SOUND_MIXER_PRIVATE5:
 562                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
 563                 break;
 564         case SOUND_MIXER_INFO:
 565                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
 566                 break;
 567         case SOUND_OLD_MIXER_INFO:
 568                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
 569                 break;
 570
 571         default:
 572                 switch (_IOC_NR(x))
 573                 {
 574                         case SOUND_MIXER_VOLUME:
 575                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
 576                                 break;
 577                         case SOUND_MIXER_SPEAKER:
 578                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
 579                                 break;
 580                         case SOUND_MIXER_RECLEV:
 581                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
 582                                 break;
 583                         case SOUND_MIXER_MIC:
 584                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
 585                                 break;
 586                         case SOUND_MIXER_SYNTH:
 587                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
 588                                 break;
 589                         case SOUND_MIXER_RECSRC:
 590                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
 591                                 break;
 592                         case SOUND_MIXER_DEVMASK:
 593                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
 594                                 break;
 595                         case SOUND_MIXER_RECMASK:
 596                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
 597                                 break;
 598                         case SOUND_MIXER_STEREODEVS:
 599                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
 600                                 break;
 601                         case SOUND_MIXER_CAPS:
 602                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
 603                                 break;
 604                         default:
 605                                 i = _IOC_NR(x);
 606                                 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
 607                                 {
 608                                         CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
 609                                 }
 610                                 else
 611                                 {
 612                                         CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
 613                                                         x,i) );
 614                                 }
 615                                 break;
 616                 }
 617     }
 618     CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
 619 }
 620 #endif
 621
 622 /*
 623  *  common I/O routines
 624  */
 625
 626 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
 627 {
 628         writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
 629 }
 630
 631 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
 632 {
 633         return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
 634 }
 635
 636 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
 637 {
 638         writel(val, codec->ba0+reg);
 639 }
 640
 641 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
 642 {
 643         return readl(codec->ba0+reg);
 644 }
 645
 646
 647 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
 648 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
 649
 650 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
 651 {
 652         if(card->channel[1].used==1)
 653                 return NULL;
 654         card->channel[1].used=1;
 655         card->channel[1].num=1;
 656         return &card->channel[1];
 657 }
 658
 659 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
 660 {
 661         if(card->channel[0].used==1)
 662                 return NULL;
 663         card->channel[0].used=1;
 664         card->channel[0].num=0;
 665         return &card->channel[0];
 666 }
 667
 668 static void cs_free_pcm_channel(struct cs_card *card, int channel)
 669 {
 670         card->channel[channel].state = NULL;
 671         card->channel[channel].used=0;
 672 }
 673
 674 /*
 675  * setup a divisor value to help with conversion from
 676  * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
 677  * assign a divisor of 1 if using 16bit Stereo as that is
 678  * the only format that the static image will capture.
 679  */
 680 static void cs_set_divisor(struct dmabuf *dmabuf)
 681 {
 682         if(dmabuf->type == CS_TYPE_DAC)
 683                 dmabuf->divisor = 1;
 684         else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
 685             (dmabuf->fmt & CS_FMT_16BIT))
 686                 dmabuf->divisor = 2;
 687         else if( (dmabuf->fmt & CS_FMT_STEREO) &&
 688             !(dmabuf->fmt & CS_FMT_16BIT))
 689                 dmabuf->divisor = 2;
 690         else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
 691             !(dmabuf->fmt & CS_FMT_16BIT))
 692                 dmabuf->divisor = 4;
 693         else
 694                 dmabuf->divisor = 1;
 695
 696         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
 697                 "cs46xx: cs_set_divisor()- %s %d\n",
 698                         (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
 699                         dmabuf->divisor) );
 700 }
 701
 702 /*
 703 * mute some of the more prevalent registers to avoid popping.
 704 */
 705 static void cs_mute(struct cs_card *card, int state)
 706 {
 707         struct ac97_codec *dev=card->ac97_codec[0];
 708
 709         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
 710                 (state == CS_TRUE) ? "Muting" : "UnMuting") );
 711
 712         if(state == CS_TRUE)
 713         {
 714         /*
 715         * fix pops when powering up on thinkpads
 716         */
 717                 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
 718                                 (u8)BA0_AC97_MASTER_VOLUME);
 719                 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
 720                                 (u8)BA0_AC97_HEADPHONE_VOLUME);
 721                 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
 722                                 (u8)BA0_AC97_MASTER_VOLUME_MONO);
 723                 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
 724                                 (u8)BA0_AC97_PCM_OUT_VOLUME);
 725
 726                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
 727                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
 728                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
 729                 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
 730         }
 731         else
 732         {
 733                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
 734                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
 735                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
 736                 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
 737         }
 738         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
 739 }
 740
 741 /* set playback sample rate */
 742 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
 743 {
 744         struct dmabuf *dmabuf = &state->dmabuf;
 745         unsigned int tmp1, tmp2;
 746         unsigned int phiIncr;
 747         unsigned int correctionPerGOF, correctionPerSec;
 748         unsigned long flags;
 749
 750         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
 751
 752         /*
 753          *  Compute the values used to drive the actual sample rate conversion.
 754          *  The following formulas are being computed, using inline assembly
 755          *  since we need to use 64 bit arithmetic to compute the values:
 756          *
 757          *  phiIncr = floor((Fs,in * 2^26) / Fs,out)
 758          *  correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
 759          *                                   GOF_PER_SEC)
 760          *  ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
 761          *                       GOF_PER_SEC * correctionPerGOF
 762          *
 763          *  i.e.
 764          *
 765          *  phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
 766          *  correctionPerGOF:correctionPerSec =
 767          *      dividend:remainder(ulOther / GOF_PER_SEC)
 768          */
 769         tmp1 = rate << 16;
 770         phiIncr = tmp1 / 48000;
 771         tmp1 -= phiIncr * 48000;
 772         tmp1 <<= 10;
 773         phiIncr <<= 10;
 774         tmp2 = tmp1 / 48000;
 775         phiIncr += tmp2;
 776         tmp1 -= tmp2 * 48000;
 777         correctionPerGOF = tmp1 / GOF_PER_SEC;
 778         tmp1 -= correctionPerGOF * GOF_PER_SEC;
 779         correctionPerSec = tmp1;
 780
 781         /*
 782          *  Fill in the SampleRateConverter control block.
 783          */
 784
 785         spin_lock_irqsave(&state->card->lock, flags);
 786         cs461x_poke(state->card, BA1_PSRC,
 787           ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 788         cs461x_poke(state->card, BA1_PPI, phiIncr);
 789         spin_unlock_irqrestore(&state->card->lock, flags);
 790         dmabuf->rate = rate;
 791
 792         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
 793         return rate;
 794 }
 795
 796 /* set recording sample rate */
 797 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
 798 {
 799         struct dmabuf *dmabuf = &state->dmabuf;
 800         struct cs_card *card = state->card;
 801         unsigned int phiIncr, coeffIncr, tmp1, tmp2;
 802         unsigned int correctionPerGOF, correctionPerSec, initialDelay;
 803         unsigned int frameGroupLength, cnt;
 804         unsigned long flags;
 805         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
 806
 807         /*
 808          *  We can only decimate by up to a factor of 1/9th the hardware rate.
 809          *  Correct the value if an attempt is made to stray outside that limit.
 810          */
 811         if ((rate * 9) < 48000)
 812                 rate = 48000 / 9;
 813
 814         /*
 815          *  We can not capture at at rate greater than the Input Rate (48000).
 816          *  Return an error if an attempt is made to stray outside that limit.
 817          */
 818         if (rate > 48000)
 819                 rate = 48000;
 820
 821         /*
 822          *  Compute the values used to drive the actual sample rate conversion.
 823          *  The following formulas are being computed, using inline assembly
 824          *  since we need to use 64 bit arithmetic to compute the values:
 825          *
 826          *     coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
 827          *     phiIncr = floor((Fs,in * 2^26) / Fs,out)
 828          *     correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
 829          *                                GOF_PER_SEC)
 830          *     correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
 831          *                          GOF_PER_SEC * correctionPerGOF
 832          *     initialDelay = ceil((24 * Fs,in) / Fs,out)
 833          *
 834          * i.e.
 835          *
 836          *     coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
 837          *     phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
 838          *     correctionPerGOF:correctionPerSec =
 839          *          dividend:remainder(ulOther / GOF_PER_SEC)
 840          *     initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
 841          */
 842
 843         tmp1 = rate << 16;
 844         coeffIncr = tmp1 / 48000;
 845         tmp1 -= coeffIncr * 48000;
 846         tmp1 <<= 7;
 847         coeffIncr <<= 7;
 848         coeffIncr += tmp1 / 48000;
 849         coeffIncr ^= 0xFFFFFFFF;
 850         coeffIncr++;
 851         tmp1 = 48000 << 16;
 852         phiIncr = tmp1 / rate;
 853         tmp1 -= phiIncr * rate;
 854         tmp1 <<= 10;
 855         phiIncr <<= 10;
 856         tmp2 = tmp1 / rate;
 857         phiIncr += tmp2;
 858         tmp1 -= tmp2 * rate;
 859         correctionPerGOF = tmp1 / GOF_PER_SEC;
 860         tmp1 -= correctionPerGOF * GOF_PER_SEC;
 861         correctionPerSec = tmp1;
 862         initialDelay = ((48000 * 24) + rate - 1) / rate;
 863
 864         /*
 865          *  Fill in the VariDecimate control block.
 866          */
 867         spin_lock_irqsave(&card->lock, flags);
 868         cs461x_poke(card, BA1_CSRC,
 869                 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 870         cs461x_poke(card, BA1_CCI, coeffIncr);
 871         cs461x_poke(card, BA1_CD,
 872                 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
 873         cs461x_poke(card, BA1_CPI, phiIncr);
 874         spin_unlock_irqrestore(&card->lock, flags);
 875
 876         /*
 877          *  Figure out the frame group length for the write back task.  Basically,
 878          *  this is just the factors of 24000 (2^6*3*5^3) that are not present in
 879          *  the output sample rate.
 880          */
 881         frameGroupLength = 1;
 882         for (cnt = 2; cnt <= 64; cnt *= 2) {
 883                 if (((rate / cnt) * cnt) != rate)
 884                         frameGroupLength *= 2;
 885         }
 886         if (((rate / 3) * 3) != rate) {
 887                 frameGroupLength *= 3;
 888         }
 889         for (cnt = 5; cnt <= 125; cnt *= 5) {
 890                 if (((rate / cnt) * cnt) != rate)
 891                         frameGroupLength *= 5;
 892         }
 893
 894         /*
 895          * Fill in the WriteBack control block.
 896          */
 897         spin_lock_irqsave(&card->lock, flags);
 898         cs461x_poke(card, BA1_CFG1, frameGroupLength);
 899         cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
 900         cs461x_poke(card, BA1_CCST, 0x0000FFFF);
 901         cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
 902         cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
 903         spin_unlock_irqrestore(&card->lock, flags);
 904         dmabuf->rate = rate;
 905         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
 906         return rate;
 907 }
 908
 909 /* prepare channel attributes for playback */
 910 static void cs_play_setup(struct cs_state *state)
 911 {
 912         struct dmabuf *dmabuf = &state->dmabuf;
 913         struct cs_card *card = state->card;
 914         unsigned int tmp, Count, playFormat;
 915
 916         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
 917         cs461x_poke(card, BA1_PVOL, 0x80008000);
 918         if(!dmabuf->SGok)
 919                cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
 920
 921         Count = 4;
 922         playFormat=cs461x_peek(card, BA1_PFIE);
 923         if ((dmabuf->fmt & CS_FMT_STEREO)) {
 924                 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
 925                 Count *= 2;
 926         }
 927         else
 928                 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
 929
 930         if ((dmabuf->fmt & CS_FMT_16BIT)) {
 931                 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
 932                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
 933                 Count *= 2;
 934         }
 935         else
 936                 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
 937                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
 938
 939         cs461x_poke(card, BA1_PFIE, playFormat);
 940
 941         tmp = cs461x_peek(card, BA1_PDTC);
 942         tmp &= 0xfffffe00;
 943         cs461x_poke(card, BA1_PDTC, tmp | --Count);
 944
 945         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
 946
 947 }
 948
 949 static struct InitStruct
 950 {
 951     u32 off;
 952     u32 val;
 953 } InitArray[] = { {0x00000040, 0x3fc0000f},
 954                   {0x0000004c, 0x04800000},
 955
 956                   {0x000000b3, 0x00000780},
 957                   {0x000000b7, 0x00000000},
 958                   {0x000000bc, 0x07800000},
 959
 960                   {0x000000cd, 0x00800000},
 961                 };
 962
 963 /*
 964  * "SetCaptureSPValues()" -- Initialize record task values before each
 965  *      capture startup.
 966  */
 967 void SetCaptureSPValues(struct cs_card *card)
 968 {
 969         unsigned i, offset;
 970         CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
 971         for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
 972         {
 973                 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
 974                 cs461x_poke(card, offset, InitArray[i].val );
 975         }
 976         CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
 977 }
 978
 979 /* prepare channel attributes for recording */
 980 static void cs_rec_setup(struct cs_state *state)
 981 {
 982         struct cs_card *card = state->card;
 983         struct dmabuf *dmabuf = &state->dmabuf;
 984         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
 985
 986         SetCaptureSPValues(card);
 987
 988         /*
 989          * set the attenuation to 0dB
 990          */
 991         cs461x_poke(card, BA1_CVOL, 0x80008000);
 992
 993         /*
 994          * set the physical address of the capture buffer into the SP
 995          */
 996         cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
 997
 998         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
 999 }
1000
1001
1002 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1003    called with spinlock held! */
1004
1005 static inline unsigned cs_get_dma_addr(struct cs_state *state)
1006 {
1007         struct dmabuf *dmabuf = &state->dmabuf;
1008         u32 offset;
1009
1010         if ( (!(dmabuf->enable & DAC_RUNNING)) &&
1011              (!(dmabuf->enable & ADC_RUNNING) ) )
1012         {
1013                 CS_DBGOUT(CS_ERROR, 2, printk(
1014                         "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
1015                 return 0;
1016         }
1017
1018         /*
1019          * granularity is byte boundary, good part.
1020          */
1021         if(dmabuf->enable & DAC_RUNNING)
1022         {
1023                 offset = cs461x_peek(state->card, BA1_PBA);
1024         }
1025         else /* ADC_RUNNING must be set */
1026         {
1027                 offset = cs461x_peek(state->card, BA1_CBA);
1028         }
1029         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
1030                 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
1031         offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
1032         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
1033                 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
1034         return offset;
1035 }
1036
1037 static void resync_dma_ptrs(struct cs_state *state)
1038 {
1039         struct dmabuf *dmabuf;
1040
1041         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1042         if(state)
1043         {
1044                 dmabuf = &state->dmabuf;
1045                 dmabuf->hwptr=dmabuf->swptr = 0;
1046                 dmabuf->pringbuf = 0;
1047         }
1048         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1049 }
1050
1051 /* Stop recording (lock held) */
1052 static inline void __stop_adc(struct cs_state *state)
1053 {
1054         struct dmabuf *dmabuf = &state->dmabuf;
1055         struct cs_card *card = state->card;
1056         unsigned int tmp;
1057
1058         dmabuf->enable &= ~ADC_RUNNING;
1059
1060         tmp = cs461x_peek(card, BA1_CCTL);
1061         tmp &= 0xFFFF0000;
1062         cs461x_poke(card, BA1_CCTL, tmp );
1063 }
1064
1065 static void stop_adc(struct cs_state *state)
1066 {
1067         unsigned long flags;
1068
1069         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1070         spin_lock_irqsave(&state->card->lock, flags);
1071         __stop_adc(state);
1072         spin_unlock_irqrestore(&state->card->lock, flags);
1073         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1074 }
1075
1076 static void start_adc(struct cs_state *state)
1077 {
1078         struct dmabuf *dmabuf = &state->dmabuf;
1079         struct cs_card *card = state->card;
1080         unsigned long flags;
1081         unsigned int tmp;
1082
1083         spin_lock_irqsave(&card->lock, flags);
1084         if (!(dmabuf->enable & ADC_RUNNING) &&
1085              ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1086                && dmabuf->ready) &&
1087                ((card->pm.flags & CS46XX_PM_IDLE) ||
1088                 (card->pm.flags & CS46XX_PM_RESUMED)) )
1089         {
1090                 dmabuf->enable |= ADC_RUNNING;
1091                 cs_set_divisor(dmabuf);
1092                 tmp = cs461x_peek(card, BA1_CCTL);
1093                 tmp &= 0xFFFF0000;
1094                 tmp |= card->cctl;
1095                 CS_DBGOUT(CS_FUNCTION, 2, printk(
1096                         "cs46xx: start_adc() poke 0x%x \n",tmp) );
1097                 cs461x_poke(card, BA1_CCTL, tmp);
1098         }
1099         spin_unlock_irqrestore(&card->lock, flags);
1100 }
1101
1102 /* stop playback (lock held) */
1103 static inline void __stop_dac(struct cs_state *state)
1104 {
1105         struct dmabuf *dmabuf = &state->dmabuf;
1106         struct cs_card *card = state->card;
1107         unsigned int tmp;
1108
1109         dmabuf->enable &= ~DAC_RUNNING;
1110
1111         tmp=cs461x_peek(card, BA1_PCTL);
1112         tmp&=0xFFFF;
1113         cs461x_poke(card, BA1_PCTL, tmp);
1114 }
1115
1116 static void stop_dac(struct cs_state *state)
1117 {
1118         unsigned long flags;
1119
1120         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1121         spin_lock_irqsave(&state->card->lock, flags);
1122         __stop_dac(state);
1123         spin_unlock_irqrestore(&state->card->lock, flags);
1124         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1125 }
1126
1127 static void start_dac(struct cs_state *state)
1128 {
1129         struct dmabuf *dmabuf = &state->dmabuf;
1130         struct cs_card *card = state->card;
1131         unsigned long flags;
1132         int tmp;
1133
1134         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1135         spin_lock_irqsave(&card->lock, flags);
1136         if (!(dmabuf->enable & DAC_RUNNING) &&
1137             ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1138                ((card->pm.flags & CS46XX_PM_IDLE) ||
1139                 (card->pm.flags & CS46XX_PM_RESUMED)) )
1140         {
1141                 dmabuf->enable |= DAC_RUNNING;
1142                 tmp = cs461x_peek(card, BA1_PCTL);
1143                 tmp &= 0xFFFF;
1144                 tmp |= card->pctl;
1145                 CS_DBGOUT(CS_PARMS, 6, printk(
1146                     "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
1147                     card, (unsigned)tmp,
1148                     card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1149                 cs461x_poke(card, BA1_PCTL, tmp);
1150         }
1151         spin_unlock_irqrestore(&card->lock, flags);
1152         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1153 }
1154
1155 #define DMABUF_MINORDER 1
1156
1157 /*
1158  * allocate DMA buffer, playback and recording buffers are separate.
1159  */
1160 static int alloc_dmabuf(struct cs_state *state)
1161 {
1162
1163         struct cs_card *card=state->card;
1164         struct dmabuf *dmabuf = &state->dmabuf;
1165         void *rawbuf = NULL;
1166         void *tmpbuff = NULL;
1167         int order;
1168         struct page *map, *mapend;
1169         unsigned long df;
1170
1171         dmabuf->ready  = dmabuf->mapped = 0;
1172         dmabuf->SGok = 0;
1173 /*
1174 * check for order within limits, but do not overwrite value.
1175 */
1176         if((defaultorder > 1) && (defaultorder < 12))
1177                 df = defaultorder;
1178         else
1179                 df = 2;
1180
1181         for (order = df; order >= DMABUF_MINORDER; order--)
1182                 if ( (rawbuf = (void *) pci_alloc_consistent(
1183                         card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1184                             break;
1185         if (!rawbuf) {
1186                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1187                         "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1188                 return -ENOMEM;
1189         }
1190         dmabuf->buforder = order;
1191         dmabuf->rawbuf = rawbuf;
1192         // Now mark the pages as reserved; otherwise the
1193         // remap_page_range() in cs46xx_mmap doesn't work.
1194         // 1. get index to last page in mem_map array for rawbuf.
1195         mapend = virt_to_page(dmabuf->rawbuf +
1196                 (PAGE_SIZE << dmabuf->buforder) - 1);
1197
1198         // 2. mark each physical page in range as 'reserved'.
1199         for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1200                 cs4x_mem_map_reserve(map);
1201
1202         CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1203                PAGE_SIZE << order, order, rawbuf) );
1204
1205 /*
1206 *  only allocate the conversion buffer for the ADC
1207 */
1208         if(dmabuf->type == CS_TYPE_DAC)
1209         {
1210                 dmabuf->tmpbuff = NULL;
1211                 dmabuf->buforder_tmpbuff = 0;
1212                 return 0;
1213         }
1214 /*
1215  * now the temp buffer for 16/8 conversions
1216  */
1217
1218         tmpbuff = (void *) pci_alloc_consistent(
1219                 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1220
1221         if (!tmpbuff)
1222                 return -ENOMEM;
1223         CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1224                PAGE_SIZE << order, order, tmpbuff) );
1225
1226         dmabuf->tmpbuff = tmpbuff;
1227         dmabuf->buforder_tmpbuff = order;
1228
1229         // Now mark the pages as reserved; otherwise the
1230         // remap_page_range() in cs46xx_mmap doesn't work.
1231         // 1. get index to last page in mem_map array for rawbuf.
1232         mapend = virt_to_page(dmabuf->tmpbuff +
1233                 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1234
1235         // 2. mark each physical page in range as 'reserved'.
1236         for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1237                 cs4x_mem_map_reserve(map);
1238         return 0;
1239 }
1240
1241 /* free DMA buffer */
1242 static void dealloc_dmabuf(struct cs_state *state)
1243 {
1244         struct dmabuf *dmabuf = &state->dmabuf;
1245         struct page *map, *mapend;
1246
1247         if (dmabuf->rawbuf) {
1248                 // Undo prog_dmabuf()'s marking the pages as reserved
1249                 mapend = virt_to_page(dmabuf->rawbuf +
1250                                 (PAGE_SIZE << dmabuf->buforder) - 1);
1251                 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1252                         cs4x_mem_map_unreserve(map);
1253                 free_dmabuf(state->card, dmabuf);
1254         }
1255
1256         if (dmabuf->tmpbuff) {
1257                 // Undo prog_dmabuf()'s marking the pages as reserved
1258                 mapend = virt_to_page(dmabuf->tmpbuff +
1259                                 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1260                 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1261                         cs4x_mem_map_unreserve(map);
1262                 free_dmabuf2(state->card, dmabuf);
1263         }
1264
1265         dmabuf->rawbuf = NULL;
1266         dmabuf->tmpbuff = NULL;
1267         dmabuf->mapped = dmabuf->ready = 0;
1268         dmabuf->SGok = 0;
1269 }
1270
1271 static int __prog_dmabuf(struct cs_state *state)
1272 {
1273         struct dmabuf *dmabuf = &state->dmabuf;
1274         unsigned long flags;
1275         unsigned long allocated_pages, allocated_bytes;
1276         unsigned long tmp1, tmp2, fmt=0;
1277         unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1278         unsigned long SGarray[9], nSGpages=0;
1279         int ret;
1280
1281         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1282 /*
1283  * check for CAPTURE and use only non-sg for initial release
1284  */
1285         if(dmabuf->type == CS_TYPE_ADC)
1286         {
1287                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1288                 /*
1289                  * add in non-sg support for capture.
1290                  */
1291                 spin_lock_irqsave(&state->card->lock, flags);
1292         /* add code to reset the rawbuf memory. TRW */
1293                 resync_dma_ptrs(state);
1294                 dmabuf->total_bytes = dmabuf->blocks = 0;
1295                 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1296
1297                 dmabuf->SGok = 0;
1298
1299                 spin_unlock_irqrestore(&state->card->lock, flags);
1300
1301                 /* allocate DMA buffer if not allocated yet */
1302                 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1303                         if ((ret = alloc_dmabuf(state)))
1304                                 return ret;
1305         /*
1306          * static image only supports 16Bit signed, stereo - hard code fmt
1307          */
1308                 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1309
1310                 dmabuf->numfrag = 2;
1311                 dmabuf->fragsize = 2048;
1312                 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1313                 dmabuf->dmasize = 4096;
1314                 dmabuf->fragshift = 11;
1315
1316                 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1317                        dmabuf->dmasize);
1318                 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1319                         PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1320
1321                 /*
1322                  *      Now set up the ring
1323                  */
1324
1325                 spin_lock_irqsave(&state->card->lock, flags);
1326                 cs_rec_setup(state);
1327                 spin_unlock_irqrestore(&state->card->lock, flags);
1328
1329                 /* set the ready flag for the dma buffer */
1330                 dmabuf->ready = 1;
1331
1332                 CS_DBGOUT(CS_PARMS, 4, printk(
1333                         "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1334                         "fragsize=%d dmasize=%d\n",
1335                             dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1336                             dmabuf->fragsize, dmabuf->dmasize) );
1337
1338                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1339                 return 0;
1340         }
1341         else if (dmabuf->type == CS_TYPE_DAC)
1342         {
1343         /*
1344          * Must be DAC
1345          */
1346                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1347                 spin_lock_irqsave(&state->card->lock, flags);
1348                 resync_dma_ptrs(state);
1349                 dmabuf->total_bytes = dmabuf->blocks = 0;
1350                 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1351
1352                 dmabuf->SGok = 0;
1353
1354                 spin_unlock_irqrestore(&state->card->lock, flags);
1355
1356                 /* allocate DMA buffer if not allocated yet */
1357                 if (!dmabuf->rawbuf)
1358                         if ((ret = alloc_dmabuf(state)))
1359                                 return ret;
1360
1361                 allocated_pages = 1 << dmabuf->buforder;
1362                 allocated_bytes = allocated_pages*PAGE_SIZE;
1363
1364                 if(allocated_pages < 2)
1365                 {
1366                         CS_DBGOUT(CS_FUNCTION, 4, printk(
1367                             "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1368                                 (unsigned)allocated_pages));
1369                         return -ENOMEM;
1370                 }
1371
1372                 /* Use all the pages allocated, fragsize 4k. */
1373                 /* Use 'pbuf' for S/G page map table. */
1374                 dmabuf->SGok = 1;           /* Use S/G. */
1375
1376                 nSGpages = allocated_bytes/4096;    /* S/G pages always 4k. */
1377
1378                      /* Set up S/G variables. */
1379                 *ptmp = virt_to_bus(dmabuf->rawbuf);
1380                 *(ptmp+1) = 0x00000008;
1381                 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1382                         *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1383                         if( tmp1 == nSGpages-1)
1384                                 tmp2 = 0xbfff0000;
1385                         else
1386                                 tmp2 = 0x80000000+8*(tmp1+1);
1387                         *(ptmp+2*tmp1+1) = tmp2;
1388                 }
1389                 SGarray[0] = 0x82c0200d;
1390                 SGarray[1] = 0xffff0000;
1391                 SGarray[2] = *ptmp;
1392                 SGarray[3] = 0x00010600;
1393                 SGarray[4] = *(ptmp+2);
1394                 SGarray[5] = 0x80000010;
1395                 SGarray[6] = *ptmp;
1396                 SGarray[7] = *(ptmp+2);
1397                 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1398
1399                 if (dmabuf->SGok) {
1400                         dmabuf->numfrag = nSGpages;
1401                         dmabuf->fragsize = 4096;
1402                         dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1403                         dmabuf->fragshift = 12;
1404                         dmabuf->dmasize = dmabuf->numfrag*4096;
1405                 }
1406                 else {
1407                         SGarray[0] = 0xf2c0000f;
1408                         SGarray[1] = 0x00000200;
1409                         SGarray[2] = 0;
1410                         SGarray[3] = 0x00010600;
1411                         SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1412                         dmabuf->numfrag = 2;
1413                         dmabuf->fragsize = 2048;
1414                         dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1415                         dmabuf->dmasize = 4096;
1416                         dmabuf->fragshift = 11;
1417                 }
1418                 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1419                         cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1420
1421                 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1422                        dmabuf->dmasize);
1423
1424                 /*
1425                  *      Now set up the ring
1426                  */
1427
1428                 spin_lock_irqsave(&state->card->lock, flags);
1429                 cs_play_setup(state);
1430                 spin_unlock_irqrestore(&state->card->lock, flags);
1431
1432                 /* set the ready flag for the dma buffer */
1433                 dmabuf->ready = 1;
1434
1435                 CS_DBGOUT(CS_PARMS, 4, printk(
1436                         "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1437                         "fragsize=%d dmasize=%d\n",
1438                             dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1439                             dmabuf->fragsize, dmabuf->dmasize) );
1440
1441                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1442                 return 0;
1443         }
1444         else
1445         {
1446                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1447                         dmabuf->type));
1448         }
1449         return 1;
1450 }
1451
1452 static int prog_dmabuf(struct cs_state *state)
1453 {
1454         int ret;
1455
1456         down(&state->sem);
1457         ret = __prog_dmabuf(state);
1458         up(&state->sem);
1459
1460         return ret;
1461 }
1462
1463 static void cs_clear_tail(struct cs_state *state)
1464 {
1465 }
1466
1467 static int drain_dac(struct cs_state *state, int nonblock)
1468 {
1469         DECLARE_WAITQUEUE(wait, current);
1470         struct dmabuf *dmabuf = &state->dmabuf;
1471         struct cs_card *card=state->card;
1472         unsigned long flags;
1473         unsigned long tmo;
1474         int count;
1475
1476         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1477         if (dmabuf->mapped || !dmabuf->ready)
1478         {
1479                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1480                 return 0;
1481         }
1482
1483         add_wait_queue(&dmabuf->wait, &wait);
1484         for (;;) {
1485                 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1486                    every time to make the process really go to sleep */
1487                 current->state = TASK_INTERRUPTIBLE;
1488
1489                 spin_lock_irqsave(&state->card->lock, flags);
1490                 count = dmabuf->count;
1491                 spin_unlock_irqrestore(&state->card->lock, flags);
1492
1493                 if (count <= 0)
1494                         break;
1495
1496                 if (signal_pending(current))
1497                         break;
1498
1499                 if (nonblock) {
1500                         remove_wait_queue(&dmabuf->wait, &wait);
1501                         current->state = TASK_RUNNING;
1502                         return -EBUSY;
1503                 }
1504
1505                 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1506                 tmo >>= sample_shift[dmabuf->fmt];
1507                 tmo += (2048*HZ)/dmabuf->rate;
1508
1509                 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1510                         printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1511                         break;
1512                 }
1513         }
1514         remove_wait_queue(&dmabuf->wait, &wait);
1515         current->state = TASK_RUNNING;
1516         if (signal_pending(current))
1517         {
1518                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1519                 /*
1520                 * set to silence and let that clear the fifos.
1521                 */
1522                 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1523                 return -ERESTARTSYS;
1524         }
1525
1526         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1527         return 0;
1528 }
1529
1530
1531 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1532 static void cs_update_ptr(struct cs_card *card, int wake)
1533 {
1534         struct cs_state *state;
1535         struct dmabuf *dmabuf;
1536         unsigned hwptr;
1537         int diff;
1538
1539         /* error handling and process wake up for ADC */
1540         state = card->states[0];
1541         if(state)
1542         {
1543                 dmabuf = &state->dmabuf;
1544                 if (dmabuf->enable & ADC_RUNNING) {
1545                         /* update hardware pointer */
1546                         hwptr = cs_get_dma_addr(state);
1547
1548                         diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1549                         CS_DBGOUT(CS_PARMS, 9, printk(
1550                                 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1551                                 hwptr,diff) );
1552                         dmabuf->hwptr = hwptr;
1553                         dmabuf->total_bytes += diff;
1554                         dmabuf->count += diff;
1555                         if (dmabuf->count > dmabuf->dmasize)
1556                                 dmabuf->count = dmabuf->dmasize;
1557
1558                         if(dmabuf->mapped)
1559                         {
1560                                 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1561                                         wake_up(&dmabuf->wait);
1562                         } else
1563                         {
1564                                 if (wake && dmabuf->count > 0)
1565                                         wake_up(&dmabuf->wait);
1566                         }
1567                 }
1568         }
1569
1570 /*
1571  * Now the DAC
1572  */
1573         state = card->states[1];
1574         if(state)
1575         {
1576                 dmabuf = &state->dmabuf;
1577                 /* error handling and process wake up for DAC */
1578                 if (dmabuf->enable & DAC_RUNNING) {
1579                         /* update hardware pointer */
1580                         hwptr = cs_get_dma_addr(state);
1581
1582                         diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1583                         CS_DBGOUT(CS_PARMS, 9, printk(
1584                                 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1585                                 hwptr,diff) );
1586                         dmabuf->hwptr = hwptr;
1587                         dmabuf->total_bytes += diff;
1588                         if (dmabuf->mapped) {
1589                                 dmabuf->count += diff;
1590                                 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1591                                         wake_up(&dmabuf->wait);
1592                                 /*
1593                                  * other drivers use fragsize, but don't see any sense
1594                                  * in that, since dmasize is the buffer asked for
1595                                  * via mmap.
1596                                  */
1597                                 if( dmabuf->count > dmabuf->dmasize)
1598                                         dmabuf->count &= dmabuf->dmasize-1;
1599                         } else {
1600                                 dmabuf->count -= diff;
1601                                 /*
1602                                  * backfill with silence and clear out the last
1603                                  * "diff" number of bytes.
1604                                  */
1605                                 if(hwptr >= diff)
1606                                 {
1607                                         memset(dmabuf->rawbuf + hwptr - diff,
1608                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1609                                 }
1610                                 else
1611                                 {
1612                                         memset(dmabuf->rawbuf,
1613                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1614                                                 (unsigned)hwptr);
1615                                         memset((char *)dmabuf->rawbuf +
1616                                                         dmabuf->dmasize + hwptr - diff,
1617                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1618                                                 diff - hwptr);
1619                                 }
1620
1621                                 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1622                                         CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1623                                           "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1624                                                 dmabuf->count));
1625                                         /*
1626                                         * buffer underrun or buffer overrun, reset the
1627                                         * count of bytes written back to 0.
1628                                         */
1629                                         if(dmabuf->count < 0)
1630                                                 dmabuf->underrun=1;
1631                                         dmabuf->count = 0;
1632                                         dmabuf->error++;
1633                                 }
1634                                 if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
1635                                         wake_up(&dmabuf->wait);
1636                         }
1637                 }
1638         }
1639 }
1640
1641
1642 /* hold spinlock for the following! */
1643 static void cs_handle_midi(struct cs_card *card)
1644 {
1645         unsigned char ch;
1646         int wake;
1647         unsigned temp1;
1648
1649         wake = 0;
1650         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_RBE)) {
1651                 ch = cs461x_peekBA0(card, BA0_MIDRP);
1652                 if (card->midi.icnt < CS_MIDIINBUF) {
1653                         card->midi.ibuf[card->midi.iwr] = ch;
1654                         card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1655                         card->midi.icnt++;
1656                 }
1657                 wake = 1;
1658         }
1659         if (wake)
1660                 wake_up(&card->midi.iwait);
1661         wake = 0;
1662         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1663                 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1664                 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1665                 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1666                 card->midi.ocnt--;
1667                 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1668                         wake = 1;
1669         }
1670         if (wake)
1671                 wake_up(&card->midi.owait);
1672 }
1673
1674 static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1675 {
1676         struct cs_card *card = (struct cs_card *)dev_id;
1677         /* Single channel card */
1678         struct cs_state *recstate = card->channel[0].state;
1679         struct cs_state *playstate = card->channel[1].state;
1680         u32 status;
1681
1682         CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1683
1684         spin_lock(&card->lock);
1685
1686         status = cs461x_peekBA0(card, BA0_HISR);
1687
1688         if ((status & 0x7fffffff) == 0)
1689         {
1690                 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1691                 spin_unlock(&card->lock);
1692                 return IRQ_HANDLED;     /* Might be IRQ_NONE.. */
1693         }
1694
1695         /*
1696          * check for playback or capture interrupt only
1697          */
1698         if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1699             (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1700         {
1701                 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1702                         "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1703                 cs_update_ptr(card, CS_TRUE);
1704         }
1705
1706         if( status & HISR_MIDI )
1707                 cs_handle_midi(card);
1708
1709         /* clear 'em */
1710         cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1711         spin_unlock(&card->lock);
1712         CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1713         return IRQ_HANDLED;
1714 }
1715
1716
1717 /**********************************************************************/
1718
1719 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1720 {
1721         struct cs_card *card = (struct cs_card *)file->private_data;
1722         ssize_t ret;
1723         unsigned long flags;
1724         unsigned ptr;
1725         int cnt;
1726
1727         if (!access_ok(VERIFY_WRITE, buffer, count))
1728                 return -EFAULT;
1729         ret = 0;
1730         while (count > 0) {
1731                 spin_lock_irqsave(&card->lock, flags);
1732                 ptr = card->midi.ird;
1733                 cnt = CS_MIDIINBUF - ptr;
1734                 if (card->midi.icnt < cnt)
1735                         cnt = card->midi.icnt;
1736                 spin_unlock_irqrestore(&card->lock, flags);
1737                 if (cnt > count)
1738                         cnt = count;
1739                 if (cnt <= 0) {
1740                         if (file->f_flags & O_NONBLOCK)
1741                                 return ret ? ret : -EAGAIN;
1742                         interruptible_sleep_on(&card->midi.iwait);
1743                         if (signal_pending(current))
1744                                 return ret ? ret : -ERESTARTSYS;
1745                         continue;
1746                 }
1747                 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1748                         return ret ? ret : -EFAULT;
1749                 ptr = (ptr + cnt) % CS_MIDIINBUF;
1750                 spin_lock_irqsave(&card->lock, flags);
1751                 card->midi.ird = ptr;
1752                 card->midi.icnt -= cnt;
1753                 spin_unlock_irqrestore(&card->lock, flags);
1754                 count -= cnt;
1755                 buffer += cnt;
1756                 ret += cnt;
1757         }
1758         return ret;
1759 }
1760
1761
1762 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1763 {
1764         struct cs_card *card = (struct cs_card *)file->private_data;
1765         ssize_t ret;
1766         unsigned long flags;
1767         unsigned ptr;
1768         int cnt;
1769
1770         if (!access_ok(VERIFY_READ, buffer, count))
1771                 return -EFAULT;
1772         ret = 0;
1773         while (count > 0) {
1774                 spin_lock_irqsave(&card->lock, flags);
1775                 ptr = card->midi.owr;
1776                 cnt = CS_MIDIOUTBUF - ptr;
1777                 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1778                         cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1779                 if (cnt <= 0)
1780                         cs_handle_midi(card);
1781                 spin_unlock_irqrestore(&card->lock, flags);
1782                 if (cnt > count)
1783                         cnt = count;
1784                 if (cnt <= 0) {
1785                         if (file->f_flags & O_NONBLOCK)
1786                                 return ret ? ret : -EAGAIN;
1787                         interruptible_sleep_on(&card->midi.owait);
1788                         if (signal_pending(current))
1789                                 return ret ? ret : -ERESTARTSYS;
1790                         continue;
1791                 }
1792                 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1793                         return ret ? ret : -EFAULT;
1794                 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1795                 spin_lock_irqsave(&card->lock, flags);
1796                 card->midi.owr = ptr;
1797                 card->midi.ocnt += cnt;
1798                 spin_unlock_irqrestore(&card->lock, flags);
1799                 count -= cnt;
1800                 buffer += cnt;
1801                 ret += cnt;
1802                 spin_lock_irqsave(&card->lock, flags);
1803                 cs_handle_midi(card);
1804                 spin_unlock_irqrestore(&card->lock, flags);
1805         }
1806         return ret;
1807 }
1808
1809
1810 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1811 {
1812         struct cs_card *card = (struct cs_card *)file->private_data;
1813         unsigned long flags;
1814         unsigned int mask = 0;
1815
1816         if (file->f_flags & FMODE_WRITE)
1817                 poll_wait(file, &card->midi.owait, wait);
1818         if (file->f_flags & FMODE_READ)
1819                 poll_wait(file, &card->midi.iwait, wait);
1820         spin_lock_irqsave(&card->lock, flags);
1821         if (file->f_flags & FMODE_READ) {
1822                 if (card->midi.icnt > 0)
1823                         mask |= POLLIN | POLLRDNORM;
1824         }
1825         if (file->f_flags & FMODE_WRITE) {
1826                 if (card->midi.ocnt < CS_MIDIOUTBUF)
1827                         mask |= POLLOUT | POLLWRNORM;
1828         }
1829         spin_unlock_irqrestore(&card->lock, flags);
1830         return mask;
1831 }
1832
1833
1834 static int cs_midi_open(struct inode *inode, struct file *file)
1835 {
1836         unsigned int minor = iminor(inode);
1837         struct cs_card *card=NULL;
1838         unsigned long flags;
1839         struct list_head *entry;
1840
1841         list_for_each(entry, &cs46xx_devs)
1842         {
1843                 card = list_entry(entry, struct cs_card, list);
1844                 if (card->dev_midi == minor)
1845                         break;
1846         }
1847
1848         if (entry == &cs46xx_devs)
1849                 return -ENODEV;
1850         if (!card)
1851         {
1852                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1853                         "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1854                 return -ENODEV;
1855         }
1856
1857         file->private_data = card;
1858         /* wait for device to become free */
1859         down(&card->midi.open_sem);
1860         while (card->midi.open_mode & file->f_mode) {
1861                 if (file->f_flags & O_NONBLOCK) {
1862                         up(&card->midi.open_sem);
1863                         return -EBUSY;
1864                 }
1865                 up(&card->midi.open_sem);
1866                 interruptible_sleep_on(&card->midi.open_wait);
1867                 if (signal_pending(current))
1868                         return -ERESTARTSYS;
1869                 down(&card->midi.open_sem);
1870         }
1871         spin_lock_irqsave(&card->midi.lock, flags);
1872         if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1873                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1874                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1875                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1876                 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f);            /* Enable xmit, rcv. */
1877                 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);   /* Enable interrupts */
1878         }
1879         if (file->f_mode & FMODE_READ) {
1880                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1881         }
1882         if (file->f_mode & FMODE_WRITE) {
1883                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1884         }
1885         spin_unlock_irqrestore(&card->midi.lock, flags);
1886         card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1887         up(&card->midi.open_sem);
1888         return 0;
1889 }
1890
1891
1892 static int cs_midi_release(struct inode *inode, struct file *file)
1893 {
1894         struct cs_card *card = (struct cs_card *)file->private_data;
1895         DECLARE_WAITQUEUE(wait, current);
1896         unsigned long flags;
1897         unsigned count, tmo;
1898
1899         if (file->f_mode & FMODE_WRITE) {
1900                 current->state = TASK_INTERRUPTIBLE;
1901                 add_wait_queue(&card->midi.owait, &wait);
1902                 for (;;) {
1903                         spin_lock_irqsave(&card->midi.lock, flags);
1904                         count = card->midi.ocnt;
1905                         spin_unlock_irqrestore(&card->midi.lock, flags);
1906                         if (count <= 0)
1907                                 break;
1908                         if (signal_pending(current))
1909                                 break;
1910                         if (file->f_flags & O_NONBLOCK)
1911                                 break;
1912                         tmo = (count * HZ) / 3100;
1913                         if (!schedule_timeout(tmo ? : 1) && tmo)
1914                                 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1915                 }
1916                 remove_wait_queue(&card->midi.owait, &wait);
1917                 current->state = TASK_RUNNING;
1918         }
1919         down(&card->midi.open_sem);
1920         card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1921         up(&card->midi.open_sem);
1922         wake_up(&card->midi.open_wait);
1923         return 0;
1924 }
1925
1926 /*
1927  *   Midi file operations struct.
1928  */
1929 static /*const*/ struct file_operations cs_midi_fops = {
1930         CS_OWNER        CS_THIS_MODULE
1931         .llseek         = no_llseek,
1932         .read           = cs_midi_read,
1933         .write          = cs_midi_write,
1934         .poll           = cs_midi_poll,
1935         .open           = cs_midi_open,
1936         .release        = cs_midi_release,
1937 };
1938
1939 /*
1940  *
1941  * CopySamples copies 16-bit stereo signed samples from the source to the
1942  * destination, possibly converting down to unsigned 8-bit and/or mono.
1943  * count specifies the number of output bytes to write.
1944  *
1945  *  Arguments:
1946  *
1947  *  dst             - Pointer to a destination buffer.
1948  *  src             - Pointer to a source buffer
1949  *  count           - The number of bytes to copy into the destination buffer.
1950  *  fmt             - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1951  *  dmabuf          - pointer to the dma buffer structure
1952  *
1953  * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1954  *
1955  *
1956  */
1957 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1958                 struct dmabuf *dmabuf)
1959 {
1960
1961     s32 s32AudioSample;
1962     s16 *psSrc=(s16 *)src;
1963     s16 *psDst=(s16 *)dst;
1964     u8 *pucDst=(u8 *)dst;
1965
1966     CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1967     CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1968         " dst=%p src=%p count=%d fmt=0x%x\n",
1969         dst,src,count,fmt) );
1970
1971     /*
1972      * See if the data should be output as 8-bit unsigned stereo.
1973      */
1974     if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1975     {
1976         /*
1977          * Convert each 16-bit signed stereo sample to 8-bit unsigned
1978          * stereo using rounding.
1979          */
1980         psSrc = (s16 *)src;
1981         count = count/2;
1982         while(count--)
1983         {
1984             *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1985         }
1986     }
1987     /*
1988      * See if the data should be output at 8-bit unsigned mono.
1989      */
1990     else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1991     {
1992         /*
1993          * Convert each 16-bit signed stereo sample to 8-bit unsigned
1994          * mono using averaging and rounding.
1995          */
1996         psSrc = (s16 *)src;
1997         count = count/2;
1998         while(count--)
1999         {
2000             s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
2001             if(s32AudioSample > 0x7fff)
2002                 s32AudioSample = 0x7fff;
2003             *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
2004             psSrc += 2;
2005         }
2006     }
2007     /*
2008      * See if the data should be output at 16-bit signed mono.
2009      */
2010     else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
2011     {
2012         /*
2013          * Convert each 16-bit signed stereo sample to 16-bit signed
2014          * mono using averaging.
2015          */
2016         psSrc = (s16 *)src;
2017         count = count/2;
2018         while(count--)
2019         {
2020             *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
2021             psSrc += 2;
2022         }
2023     }
2024 }
2025
2026 /*
2027  * cs_copy_to_user()
2028  * replacement for the standard copy_to_user, to allow for a conversion from
2029  * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
2030  * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
2031  * so we convert from any of the other format combinations.
2032  */
2033 static unsigned cs_copy_to_user(
2034         struct cs_state *s,
2035         void __user *dest,
2036         void *hwsrc,
2037         unsigned cnt,
2038         unsigned *copied)
2039 {
2040         struct dmabuf *dmabuf = &s->dmabuf;
2041         void *src = hwsrc;  /* default to the standard destination buffer addr */
2042
2043         CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
2044                 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
2045                 dmabuf->fmt,(unsigned)cnt,dest) );
2046
2047         if(cnt > dmabuf->dmasize)
2048         {
2049                 cnt = dmabuf->dmasize;
2050         }
2051         if(!cnt)
2052         {
2053                 *copied = 0;
2054                 return 0;
2055         }
2056         if(dmabuf->divisor != 1)
2057         {
2058                 if(!dmabuf->tmpbuff)
2059                 {
2060                         *copied = cnt/dmabuf->divisor;
2061                         return 0;
2062                 }
2063
2064                 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
2065                         dmabuf->fmt, dmabuf);
2066                 src = dmabuf->tmpbuff;
2067                 cnt = cnt/dmabuf->divisor;
2068         }
2069         if (copy_to_user(dest, src, cnt))
2070         {
2071                 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
2072                         "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2073                                 dest,src,cnt) );
2074                 *copied = 0;
2075                 return -EFAULT;
2076         }
2077         *copied = cnt;
2078         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2079                 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
2080         return 0;
2081 }
2082
2083 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2084    the user's buffer.  it is filled by the dma machine and drained by this loop. */
2085 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2086 {
2087         struct cs_card *card = (struct cs_card *) file->private_data;
2088         struct cs_state *state;
2089         DECLARE_WAITQUEUE(wait, current);
2090         struct dmabuf *dmabuf;
2091         ssize_t ret = 0;
2092         unsigned long flags;
2093         unsigned swptr;
2094         int cnt;
2095         unsigned copied=0;
2096
2097         CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2098                 printk("cs46xx: cs_read()+ %zd\n",count) );
2099         state = (struct cs_state *)card->states[0];
2100         if(!state)
2101                 return -ENODEV;
2102         dmabuf = &state->dmabuf;
2103
2104         if (dmabuf->mapped)
2105                 return -ENXIO;
2106         if (!access_ok(VERIFY_WRITE, buffer, count))
2107                 return -EFAULT;
2108
2109         down(&state->sem);
2110         if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2111                 goto out2;
2112
2113         add_wait_queue(&state->dmabuf.wait, &wait);
2114         while (count > 0) {
2115                 while(!(card->pm.flags & CS46XX_PM_IDLE))
2116                 {
2117                         schedule();
2118                         if (signal_pending(current)) {
2119                                 if(!ret) ret = -ERESTARTSYS;
2120                                 goto out;
2121                         }
2122                 }
2123                 spin_lock_irqsave(&state->card->lock, flags);
2124                 swptr = dmabuf->swptr;
2125                 cnt = dmabuf->dmasize - swptr;
2126                 if (dmabuf->count < cnt)
2127                         cnt = dmabuf->count;
2128                 if (cnt <= 0)
2129                         __set_current_state(TASK_INTERRUPTIBLE);
2130                 spin_unlock_irqrestore(&state->card->lock, flags);
2131
2132                 if (cnt > (count * dmabuf->divisor))
2133                         cnt = count * dmabuf->divisor;
2134                 if (cnt <= 0) {
2135                         /* buffer is empty, start the dma machine and wait for data to be
2136                            recorded */
2137                         start_adc(state);
2138                         if (file->f_flags & O_NONBLOCK) {
2139                                 if (!ret) ret = -EAGAIN;
2140                                 goto out;
2141                         }
2142                         up(&state->sem);
2143                         schedule();
2144                         if (signal_pending(current)) {
2145                                 if(!ret) ret = -ERESTARTSYS;
2146                                 goto out;
2147                         }
2148                         down(&state->sem);
2149                         if (dmabuf->mapped)
2150                         {
2151                                 if(!ret)
2152                                         ret = -ENXIO;
2153                                 goto out;
2154                         }
2155                         continue;
2156                 }
2157
2158                 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2159                         "_read() copy_to cnt=%d count=%zd ", cnt,count) );
2160                 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2161                         " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
2162                         dmabuf->dmasize,dmabuf->count,buffer,ret) );
2163
2164                 if (cs_copy_to_user(state, buffer,
2165                         (char *)dmabuf->rawbuf + swptr, cnt, &copied))
2166                 {
2167                         if (!ret) ret = -EFAULT;
2168                         goto out;
2169                 }
2170                 swptr = (swptr + cnt) % dmabuf->dmasize;
2171                 spin_lock_irqsave(&card->lock, flags);
2172                 dmabuf->swptr = swptr;
2173                 dmabuf->count -= cnt;
2174                 spin_unlock_irqrestore(&card->lock, flags);
2175                 count -= copied;
2176                 buffer += copied;
2177                 ret += copied;
2178                 start_adc(state);
2179         }
2180 out:
2181         remove_wait_queue(&state->dmabuf.wait, &wait);
2182 out2:
2183         up(&state->sem);
2184         set_current_state(TASK_RUNNING);
2185         CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2186                 printk("cs46xx: cs_read()- %zd\n",ret) );
2187         return ret;
2188 }
2189
2190 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2191    the soundcard.  it is drained by the dma machine and filled by this loop. */
2192 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2193 {
2194         struct cs_card *card = (struct cs_card *) file->private_data;
2195         struct cs_state *state;
2196         DECLARE_WAITQUEUE(wait, current);
2197         struct dmabuf *dmabuf;
2198         ssize_t ret;
2199         unsigned long flags;
2200         unsigned swptr;
2201         int cnt;
2202
2203         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2204                 printk("cs46xx: cs_write called, count = %zd\n", count) );
2205         state = (struct cs_state *)card->states[1];
2206         if(!state)
2207                 return -ENODEV;
2208         if (!access_ok(VERIFY_READ, buffer, count))
2209                 return -EFAULT;
2210         dmabuf = &state->dmabuf;
2211
2212         down(&state->sem);
2213         if (dmabuf->mapped)
2214         {
2215                 ret = -ENXIO;
2216                 goto out;
2217         }
2218
2219         if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2220                 goto out;
2221         add_wait_queue(&state->dmabuf.wait, &wait);
2222         ret = 0;
2223 /*
2224 * Start the loop to read from the user's buffer and write to the dma buffer.
2225 * check for PM events and underrun/overrun in the loop.
2226 */
2227         while (count > 0) {
2228                 while(!(card->pm.flags & CS46XX_PM_IDLE))
2229                 {
2230                         schedule();
2231                         if (signal_pending(current)) {
2232                                 if(!ret) ret = -ERESTARTSYS;
2233                                 goto out;
2234                         }
2235                 }
2236                 spin_lock_irqsave(&state->card->lock, flags);
2237                 if (dmabuf->count < 0) {
2238                         /* buffer underrun, we are recovering from sleep_on_timeout,
2239                            resync hwptr and swptr */
2240                         dmabuf->count = 0;
2241                         dmabuf->swptr = dmabuf->hwptr;
2242                 }
2243                 if (dmabuf->underrun)
2244                 {
2245                         dmabuf->underrun = 0;
2246                         dmabuf->hwptr = cs_get_dma_addr(state);
2247                         dmabuf->swptr = dmabuf->hwptr;
2248                 }
2249
2250                 swptr = dmabuf->swptr;
2251                 cnt = dmabuf->dmasize - swptr;
2252                 if (dmabuf->count + cnt > dmabuf->dmasize)
2253                         cnt = dmabuf->dmasize - dmabuf->count;
2254                 if (cnt <= 0)
2255                         __set_current_state(TASK_INTERRUPTIBLE);
2256                 spin_unlock_irqrestore(&state->card->lock, flags);
2257
2258                 if (cnt > count)
2259                         cnt = count;
2260                 if (cnt <= 0) {
2261                         /* buffer is full, start the dma machine and wait for data to be
2262                            played */
2263                         start_dac(state);
2264                         if (file->f_flags & O_NONBLOCK) {
2265                                 if (!ret) ret = -EAGAIN;
2266                                 goto out;
2267                         }
2268                         up(&state->sem);
2269                         schedule();
2270                         if (signal_pending(current)) {
2271                                 if(!ret) ret = -ERESTARTSYS;
2272                                 goto out;
2273                         }
2274                         down(&state->sem);
2275                         if (dmabuf->mapped)
2276                         {
2277                                 if(!ret)
2278                                         ret = -ENXIO;
2279                                 goto out;
2280                         }
2281                         continue;
2282                 }
2283                 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2284                         if (!ret) ret = -EFAULT;
2285                         goto out;
2286                 }
2287                 spin_lock_irqsave(&state->card->lock, flags);
2288                 swptr = (swptr + cnt) % dmabuf->dmasize;
2289                 dmabuf->swptr = swptr;
2290                 dmabuf->count += cnt;
2291                 if(dmabuf->count > dmabuf->dmasize)
2292                 {
2293                         CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2294                             "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2295                         dmabuf->count = dmabuf->dmasize;
2296                 }
2297                 dmabuf->endcleared = 0;
2298                 spin_unlock_irqrestore(&state->card->lock, flags);
2299
2300                 count -= cnt;
2301                 buffer += cnt;
2302                 ret += cnt;
2303                 start_dac(state);
2304         }
2305 out:
2306         up(&state->sem);
2307         remove_wait_queue(&state->dmabuf.wait, &wait);
2308         set_current_state(TASK_RUNNING);
2309
2310         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2311                 printk("cs46xx: cs_write()- ret=%zd\n", ret) );
2312         return ret;
2313 }
2314
2315 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2316 {
2317         struct cs_card *card = (struct cs_card *)file->private_data;
2318         struct dmabuf *dmabuf;
2319         struct cs_state *state;
2320
2321         unsigned long flags;
2322         unsigned int mask = 0;
2323
2324         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2325         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2326         {
2327                 return -EINVAL;
2328         }
2329         if (file->f_mode & FMODE_WRITE)
2330         {
2331                 state = card->states[1];
2332                 if(state)
2333                 {
2334                         dmabuf = &state->dmabuf;
2335                         poll_wait(file, &dmabuf->wait, wait);
2336                 }
2337         }
2338         if (file->f_mode & FMODE_READ)
2339         {
2340                 state = card->states[0];
2341                 if(state)
2342                 {
2343                         dmabuf = &state->dmabuf;
2344                         poll_wait(file, &dmabuf->wait, wait);
2345                 }
2346         }
2347
2348         spin_lock_irqsave(&card->lock, flags);
2349         cs_update_ptr(card, CS_FALSE);
2350         if (file->f_mode & FMODE_READ) {
2351                 state = card->states[0];
2352                 if(state)
2353                 {
2354                         dmabuf = &state->dmabuf;
2355                         if (dmabuf->count >= (signed)dmabuf->fragsize)
2356                                 mask |= POLLIN | POLLRDNORM;
2357                 }
2358         }
2359         if (file->f_mode & FMODE_WRITE) {
2360                 state = card->states[1];
2361                 if(state)
2362                 {
2363                         dmabuf = &state->dmabuf;
2364                         if (dmabuf->mapped) {
2365                                 if (dmabuf->count >= (signed)dmabuf->fragsize)
2366                                     mask |= POLLOUT | POLLWRNORM;
2367                         } else {
2368                                 if ((signed)dmabuf->dmasize >= dmabuf->count
2369                                         + (signed)dmabuf->fragsize)
2370                                     mask |= POLLOUT | POLLWRNORM;
2371                         }
2372                 }
2373         }
2374         spin_unlock_irqrestore(&card->lock, flags);
2375
2376         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2377                 mask));
2378         return mask;
2379 }
2380
2381 /*
2382  *      We let users mmap the ring buffer. Its not the real DMA buffer but
2383  *      that side of the code is hidden in the IRQ handling. We do a software
2384  *      emulation of DMA from a 64K or so buffer into a 2K FIFO.
2385  *      (the hardware probably deserves a moan here but Crystal send me nice
2386  *      toys ;)).
2387  */
2388
2389 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2390 {
2391         struct cs_card *card = (struct cs_card *)file->private_data;
2392         struct cs_state *state;
2393         struct dmabuf *dmabuf;
2394         int ret = 0;
2395         unsigned long size;
2396
2397         CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
2398                 file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2399                 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2400
2401         if (vma->vm_flags & VM_WRITE) {
2402                 state = card->states[1];
2403                 if(state)
2404                 {
2405                         CS_DBGOUT(CS_OPEN, 2, printk(
2406                           "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2407                         if ((ret = prog_dmabuf(state)) != 0)
2408                                 return ret;
2409                 }
2410         } else if (vma->vm_flags & VM_READ) {
2411                 state = card->states[0];
2412                 if(state)
2413                 {
2414                         CS_DBGOUT(CS_OPEN, 2, printk(
2415                           "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2416                         if ((ret = prog_dmabuf(state)) != 0)
2417                                 return ret;
2418                 }
2419         } else {
2420                 CS_DBGOUT(CS_ERROR, 2, printk(
2421                   "cs46xx: cs_mmap() return -EINVAL\n") );
2422                 return -EINVAL;
2423         }
2424
2425 /*
2426  * For now ONLY support playback, but seems like the only way to use
2427  * mmap() is to open an FD with RDWR, just read or just write access
2428  * does not function, get an error back from the kernel.
2429  * Also, QuakeIII opens with RDWR!  So, there must be something
2430  * to needing read/write access mapping.  So, allow read/write but
2431  * use the DAC only.
2432  */
2433         state = card->states[1];
2434         if (!state) {
2435                 ret = -EINVAL;
2436                 goto out;
2437         }
2438
2439         down(&state->sem);
2440         dmabuf = &state->dmabuf;
2441         if (cs4x_pgoff(vma) != 0)
2442         {
2443                 ret = -EINVAL;
2444                 goto out;
2445         }
2446         size = vma->vm_end - vma->vm_start;
2447
2448         CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2449
2450         if (size > (PAGE_SIZE << dmabuf->buforder))
2451         {
2452                 ret = -EINVAL;
2453                 goto out;
2454         }
2455         if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2456                              size, vma->vm_page_prot))
2457         {
2458                 ret = -EAGAIN;
2459                 goto out;
2460         }
2461         dmabuf->mapped = 1;
2462
2463         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2464 out:
2465         up(&state->sem);
2466         return ret;
2467 }
2468
2469 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2470 {
2471         struct cs_card *card = (struct cs_card *)file->private_data;
2472         struct cs_state *state;
2473         struct dmabuf *dmabuf=NULL;
2474         unsigned long flags;
2475         audio_buf_info abinfo;
2476         count_info cinfo;
2477         int val, valsave, mapped, ret;
2478         void __user *argp = (void __user *)arg;
2479         int __user *p = argp;
2480
2481         state = (struct cs_state *)card->states[0];
2482         if(state)
2483         {
2484                 dmabuf = &state->dmabuf;
2485                 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2486         }
2487         state = (struct cs_state *)card->states[1];
2488         if(state)
2489         {
2490                 dmabuf = &state->dmabuf;
2491                 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2492         }
2493
2494 #if CSDEBUG
2495         printioctl(cmd);
2496 #endif
2497
2498         switch (cmd)
2499         {
2500         case OSS_GETVERSION:
2501                 return put_user(SOUND_VERSION, p);
2502
2503         case SNDCTL_DSP_RESET:
2504                 /* FIXME: spin_lock ? */
2505                 if (file->f_mode & FMODE_WRITE) {
2506                         state = (struct cs_state *)card->states[1];
2507                         if(state)
2508                         {
2509                                 dmabuf = &state->dmabuf;
2510                                 stop_dac(state);
2511                                 synchronize_irq(card->irq);
2512                                 dmabuf->ready = 0;
2513                                 resync_dma_ptrs(state);
2514                                 dmabuf->swptr = dmabuf->hwptr = 0;
2515                                 dmabuf->count = dmabuf->total_bytes = 0;
2516                                 dmabuf->blocks = 0;
2517                                 dmabuf->SGok = 0;
2518                         }
2519                 }
2520                 if (file->f_mode & FMODE_READ) {
2521                         state = (struct cs_state *)card->states[0];
2522                         if(state)
2523                         {
2524                                 dmabuf = &state->dmabuf;
2525                                 stop_adc(state);
2526                                 synchronize_irq(card->irq);
2527                                 resync_dma_ptrs(state);
2528                                 dmabuf->ready = 0;
2529                                 dmabuf->swptr = dmabuf->hwptr = 0;
2530                                 dmabuf->count = dmabuf->total_bytes = 0;
2531                                 dmabuf->blocks = 0;
2532                                 dmabuf->SGok = 0;
2533                         }
2534                 }
2535                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2536                 return 0;
2537
2538         case SNDCTL_DSP_SYNC:
2539                 if (file->f_mode & FMODE_WRITE)
2540                         return drain_dac(state, file->f_flags & O_NONBLOCK);
2541                 return 0;
2542
2543         case SNDCTL_DSP_SPEED: /* set sample rate */
2544                 if (get_user(val, p))
2545                         return -EFAULT;
2546                 if (val >= 0) {
2547                         if (file->f_mode & FMODE_READ) {
2548                                 state = (struct cs_state *)card->states[0];
2549                                 if(state)
2550                                 {
2551                                         dmabuf = &state->dmabuf;
2552                                         stop_adc(state);
2553                                         dmabuf->ready = 0;
2554                                         dmabuf->SGok = 0;
2555                                         cs_set_adc_rate(state, val);
2556                                         cs_set_divisor(dmabuf);
2557                                 }
2558                         }
2559                         if (file->f_mode & FMODE_WRITE) {
2560                                 state = (struct cs_state *)card->states[1];
2561                                 if(state)
2562                                 {
2563                                         dmabuf = &state->dmabuf;
2564                                         stop_dac(state);
2565                                         dmabuf->ready = 0;
2566                                         dmabuf->SGok = 0;
2567                                         cs_set_dac_rate(state, val);
2568                                         cs_set_divisor(dmabuf);
2569                                 }
2570                         }
2571                         CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2572                             "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2573                                 file->f_mode & FMODE_WRITE ? "DAC" : "",
2574                                 file->f_mode & FMODE_READ ? "ADC" : "",
2575                                 dmabuf->rate ) );
2576                         return put_user(dmabuf->rate, p);
2577                 }
2578                 return put_user(0, p);
2579
2580         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2581                 if (get_user(val, p))
2582                         return -EFAULT;
2583                 if (file->f_mode & FMODE_WRITE) {
2584                         state = (struct cs_state *)card->states[1];
2585                         if(state)
2586                         {
2587                                 dmabuf = &state->dmabuf;
2588                                 stop_dac(state);
2589                                 dmabuf->ready = 0;
2590                                 dmabuf->SGok = 0;
2591                                 if(val)
2592                                         dmabuf->fmt |= CS_FMT_STEREO;
2593                                 else
2594                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2595                                 cs_set_divisor(dmabuf);
2596                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2597                                     "cs46xx: DSP_STEREO() DAC %s\n",
2598                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2599                                         "STEREO":"MONO") );
2600                         }
2601                 }
2602                 if (file->f_mode & FMODE_READ) {
2603                         state = (struct cs_state *)card->states[0];
2604                         if(state)
2605                         {
2606                                 dmabuf = &state->dmabuf;
2607                                 stop_adc(state);
2608                                 dmabuf->ready = 0;
2609                                 dmabuf->SGok = 0;
2610                                 if(val)
2611                                         dmabuf->fmt |= CS_FMT_STEREO;
2612                                 else
2613                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2614                                 cs_set_divisor(dmabuf);
2615                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2616                                     "cs46xx: DSP_STEREO() ADC %s\n",
2617                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2618                                         "STEREO":"MONO") );
2619                         }
2620                 }
2621                 return 0;
2622
2623         case SNDCTL_DSP_GETBLKSIZE:
2624                 if (file->f_mode & FMODE_WRITE) {
2625                         state = (struct cs_state *)card->states[1];
2626                         if(state)
2627                         {
2628                                 dmabuf = &state->dmabuf;
2629                                 if ((val = prog_dmabuf(state)))
2630                                         return val;
2631                                 return put_user(dmabuf->fragsize, p);
2632                         }
2633                 }
2634                 if (file->f_mode & FMODE_READ) {
2635                         state = (struct cs_state *)card->states[0];
2636                         if(state)
2637                         {
2638                                 dmabuf = &state->dmabuf;
2639                                 if ((val = prog_dmabuf(state)))
2640                                         return val;
2641                                 return put_user(dmabuf->fragsize/dmabuf->divisor,
2642                                                 p);
2643                         }
2644                 }
2645                 return put_user(0, p);
2646
2647         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2648                 return put_user(AFMT_S16_LE | AFMT_U8, p);
2649
2650         case SNDCTL_DSP_SETFMT: /* Select sample format */
2651                 if (get_user(val, p))
2652                         return -EFAULT;
2653                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2654                     "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2655                         file->f_mode & FMODE_WRITE ? "DAC" : "",
2656                         file->f_mode & FMODE_READ ? "ADC" : "",
2657                         val == AFMT_S16_LE ? "16Bit Signed" : "",
2658                         val == AFMT_U8 ? "8Bit Unsigned" : "") );
2659                 valsave = val;
2660                 if (val != AFMT_QUERY) {
2661                         if(val==AFMT_S16_LE || val==AFMT_U8)
2662                         {
2663                                 if (file->f_mode & FMODE_WRITE) {
2664                                         state = (struct cs_state *)card->states[1];
2665                                         if(state)
2666                                         {
2667                                                 dmabuf = &state->dmabuf;
2668                                                 stop_dac(state);
2669                                                 dmabuf->ready = 0;
2670                                                 dmabuf->SGok = 0;
2671                                                 if(val==AFMT_S16_LE)
2672                                                         dmabuf->fmt |= CS_FMT_16BIT;
2673                                                 else
2674                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2675                                                 cs_set_divisor(dmabuf);
2676                                                 if((ret = prog_dmabuf(state)))
2677                                                         return ret;
2678                                         }
2679                                 }
2680                                 if (file->f_mode & FMODE_READ) {
2681                                         val = valsave;
2682                                         state = (struct cs_state *)card->states[0];
2683                                         if(state)
2684                                         {
2685                                                 dmabuf = &state->dmabuf;
2686                                                 stop_adc(state);
2687                                                 dmabuf->ready = 0;
2688                                                 dmabuf->SGok = 0;
2689                                                 if(val==AFMT_S16_LE)
2690                                                         dmabuf->fmt |= CS_FMT_16BIT;
2691                                                 else
2692                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2693                                                 cs_set_divisor(dmabuf);
2694                                                 if((ret = prog_dmabuf(state)))
2695                                                         return ret;
2696                                         }
2697                                 }
2698                         }
2699                         else
2700                         {
2701                                 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2702                                     "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2703                                         valsave) );
2704                         }
2705                 }
2706                 else
2707                 {
2708                         if(file->f_mode & FMODE_WRITE)
2709                         {
2710                                 state = (struct cs_state *)card->states[1];
2711                                 if(state)
2712                                         dmabuf = &state->dmabuf;
2713                         }
2714                         else if(file->f_mode & FMODE_READ)
2715                         {
2716                                 state = (struct cs_state *)card->states[0];
2717                                 if(state)
2718                                         dmabuf = &state->dmabuf;
2719                         }
2720                 }
2721                 if(dmabuf)
2722                 {
2723                         if(dmabuf->fmt & CS_FMT_16BIT)
2724                                 return put_user(AFMT_S16_LE, p);
2725                         else
2726                                 return put_user(AFMT_U8, p);
2727                 }
2728                 return put_user(0, p);
2729
2730         case SNDCTL_DSP_CHANNELS:
2731                 if (get_user(val, p))
2732                         return -EFAULT;
2733                 if (val != 0) {
2734                         if (file->f_mode & FMODE_WRITE) {
2735                                 state = (struct cs_state *)card->states[1];
2736                                 if(state)
2737                                 {
2738                                         dmabuf = &state->dmabuf;
2739                                         stop_dac(state);
2740                                         dmabuf->ready = 0;
2741                                         dmabuf->SGok = 0;
2742                                         if(val>1)
2743                                                 dmabuf->fmt |= CS_FMT_STEREO;
2744                                         else
2745                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2746                                         cs_set_divisor(dmabuf);
2747                                         if (prog_dmabuf(state))
2748                                                 return 0;
2749                                 }
2750                         }
2751                         if (file->f_mode & FMODE_READ) {
2752                                 state = (struct cs_state *)card->states[0];
2753                                 if(state)
2754                                 {
2755                                         dmabuf = &state->dmabuf;
2756                                         stop_adc(state);
2757                                         dmabuf->ready = 0;
2758                                         dmabuf->SGok = 0;
2759                                         if(val>1)
2760                                                 dmabuf->fmt |= CS_FMT_STEREO;
2761                                         else
2762                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2763                                         cs_set_divisor(dmabuf);
2764                                         if (prog_dmabuf(state))
2765                                                 return 0;
2766                                 }
2767                         }
2768                 }
2769                 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2770                                 p);
2771
2772         case SNDCTL_DSP_POST:
2773                 /*
2774                  * There will be a longer than normal pause in the data.
2775                  * so... do nothing, because there is nothing that we can do.
2776                  */
2777                 return 0;
2778
2779         case SNDCTL_DSP_SUBDIVIDE:
2780                 if (file->f_mode & FMODE_WRITE) {
2781                         state = (struct cs_state *)card->states[1];
2782                         if(state)
2783                         {
2784                                 dmabuf = &state->dmabuf;
2785                                 if (dmabuf->subdivision)
2786                                         return -EINVAL;
2787                                 if (get_user(val, p))
2788                                         return -EFAULT;
2789                                 if (val != 1 && val != 2)
2790                                         return -EINVAL;
2791                                 dmabuf->subdivision = val;
2792                         }
2793                 }
2794                 if (file->f_mode & FMODE_READ) {
2795                         state = (struct cs_state *)card->states[0];
2796                         if(state)
2797                         {
2798                                 dmabuf = &state->dmabuf;
2799                                 if (dmabuf->subdivision)
2800                                         return -EINVAL;
2801                                 if (get_user(val, p))
2802                                         return -EFAULT;
2803                                 if (val != 1 && val != 2)
2804                                         return -EINVAL;
2805                                 dmabuf->subdivision = val;
2806                         }
2807                 }
2808                 return 0;
2809
2810         case SNDCTL_DSP_SETFRAGMENT:
2811                 if (get_user(val, p))
2812                         return -EFAULT;
2813
2814                 if (file->f_mode & FMODE_WRITE) {
2815                         state = (struct cs_state *)card->states[1];
2816                         if(state)
2817                         {
2818                                 dmabuf = &state->dmabuf;
2819                                 dmabuf->ossfragshift = val & 0xffff;
2820                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2821                         }
2822                 }
2823                 if (file->f_mode & FMODE_READ) {
2824                         state = (struct cs_state *)card->states[0];
2825                         if(state)
2826                         {
2827                                 dmabuf = &state->dmabuf;
2828                                 dmabuf->ossfragshift = val & 0xffff;
2829                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2830                         }
2831                 }
2832                 return 0;
2833
2834         case SNDCTL_DSP_GETOSPACE:
2835                 if (!(file->f_mode & FMODE_WRITE))
2836                         return -EINVAL;
2837                 state = (struct cs_state *)card->states[1];
2838                 if(state)
2839                 {
2840                         dmabuf = &state->dmabuf;
2841                         spin_lock_irqsave(&state->card->lock, flags);
2842                         cs_update_ptr(card, CS_TRUE);
2843                         abinfo.fragsize = dmabuf->fragsize;
2844                         abinfo.fragstotal = dmabuf->numfrag;
2845                 /*
2846                  * for mmap we always have total space available
2847                  */
2848                         if (dmabuf->mapped)
2849                                 abinfo.bytes = dmabuf->dmasize;
2850                         else
2851                                 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2852
2853                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2854                         spin_unlock_irqrestore(&state->card->lock, flags);
2855                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2856                 }
2857                 return -ENODEV;
2858
2859         case SNDCTL_DSP_GETISPACE:
2860                 if (!(file->f_mode & FMODE_READ))
2861                         return -EINVAL;
2862                 state = (struct cs_state *)card->states[0];
2863                 if(state)
2864                 {
2865                         dmabuf = &state->dmabuf;
2866                         spin_lock_irqsave(&state->card->lock, flags);
2867                         cs_update_ptr(card, CS_TRUE);
2868                         abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2869                         abinfo.bytes = dmabuf->count/dmabuf->divisor;
2870                         abinfo.fragstotal = dmabuf->numfrag;
2871                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2872                         spin_unlock_irqrestore(&state->card->lock, flags);
2873                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2874                 }
2875                 return -ENODEV;
2876
2877         case SNDCTL_DSP_NONBLOCK:
2878                 file->f_flags |= O_NONBLOCK;
2879                 return 0;
2880
2881         case SNDCTL_DSP_GETCAPS:
2882                 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2883                             p);
2884
2885         case SNDCTL_DSP_GETTRIGGER:
2886                 val = 0;
2887                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2888                 if (file->f_mode & FMODE_WRITE)
2889                 {
2890                         state = (struct cs_state *)card->states[1];
2891                         if(state)
2892                         {
2893                                 dmabuf = &state->dmabuf;
2894                                 if(dmabuf->enable & DAC_RUNNING)
2895                                         val |= PCM_ENABLE_INPUT;
2896                         }
2897                 }
2898                 if (file->f_mode & FMODE_READ)
2899                 {
2900                         if(state)
2901                         {
2902                                 state = (struct cs_state *)card->states[0];
2903                                 dmabuf = &state->dmabuf;
2904                                 if(dmabuf->enable & ADC_RUNNING)
2905                                         val |= PCM_ENABLE_OUTPUT;
2906                         }
2907                 }
2908                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2909                 return put_user(val, p);
2910
2911         case SNDCTL_DSP_SETTRIGGER:
2912                 if (get_user(val, p))
2913                         return -EFAULT;
2914                 if (file->f_mode & FMODE_READ) {
2915                         state = (struct cs_state *)card->states[0];
2916                         if(state)
2917                         {
2918                                 dmabuf = &state->dmabuf;
2919                                 if (val & PCM_ENABLE_INPUT) {
2920                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2921                                                 return ret;
2922                                         start_adc(state);
2923                                 } else
2924                                         stop_adc(state);
2925                         }
2926                 }
2927                 if (file->f_mode & FMODE_WRITE) {
2928                         state = (struct cs_state *)card->states[1];
2929                         if(state)
2930                         {
2931                                 dmabuf = &state->dmabuf;
2932                                 if (val & PCM_ENABLE_OUTPUT) {
2933                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2934                                                 return ret;
2935                                         start_dac(state);
2936                                 } else
2937                                         stop_dac(state);
2938                         }
2939                 }
2940                 return 0;
2941
2942         case SNDCTL_DSP_GETIPTR:
2943                 if (!(file->f_mode & FMODE_READ))
2944                         return -EINVAL;
2945                 state = (struct cs_state *)card->states[0];
2946                 if(state)
2947                 {
2948                         dmabuf = &state->dmabuf;
2949                         spin_lock_irqsave(&state->card->lock, flags);
2950                         cs_update_ptr(card, CS_TRUE);
2951                         cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2952                         cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2953                         cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2954                         spin_unlock_irqrestore(&state->card->lock, flags);
2955                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2956                                 return -EFAULT;
2957                         return 0;
2958                 }
2959                 return -ENODEV;
2960
2961         case SNDCTL_DSP_GETOPTR:
2962                 if (!(file->f_mode & FMODE_WRITE))
2963                         return -EINVAL;
2964                 state = (struct cs_state *)card->states[1];
2965                 if(state)
2966                 {
2967                         dmabuf = &state->dmabuf;
2968                         spin_lock_irqsave(&state->card->lock, flags);
2969                         cs_update_ptr(card, CS_TRUE);
2970                         cinfo.bytes = dmabuf->total_bytes;
2971                         if (dmabuf->mapped)
2972                         {
2973                                 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2974                                                         - dmabuf->blocks;
2975                                 CS_DBGOUT(CS_PARMS, 8,
2976                                         printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2977                                         cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2978                                 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2979                         }
2980                         else
2981                         {
2982                                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2983                         }
2984                         cinfo.ptr = dmabuf->hwptr;
2985
2986                         CS_DBGOUT(CS_PARMS, 4, printk(
2987                             "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2988                                 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2989                         spin_unlock_irqrestore(&state->card->lock, flags);
2990                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2991                                 return -EFAULT;
2992                         return 0;
2993                 }
2994                 return -ENODEV;
2995
2996         case SNDCTL_DSP_SETDUPLEX:
2997                 return 0;
2998
2999         case SNDCTL_DSP_GETODELAY:
3000                 if (!(file->f_mode & FMODE_WRITE))
3001                         return -EINVAL;
3002                 state = (struct cs_state *)card->states[1];
3003                 if(state)
3004                 {
3005                         dmabuf = &state->dmabuf;
3006                         spin_lock_irqsave(&state->card->lock, flags);
3007                         cs_update_ptr(card, CS_TRUE);
3008                         val = dmabuf->count;
3009                         spin_unlock_irqrestore(&state->card->lock, flags);
3010                 }
3011                 else
3012                         val = 0;
3013                 return put_user(val, p);
3014
3015         case SOUND_PCM_READ_RATE:
3016                 if(file->f_mode & FMODE_READ)
3017                         state = (struct cs_state *)card->states[0];
3018                 else
3019                         state = (struct cs_state *)card->states[1];
3020                 if(state)
3021                 {
3022                         dmabuf = &state->dmabuf;
3023                         return put_user(dmabuf->rate, p);
3024                 }
3025                 return put_user(0, p);
3026
3027
3028         case SOUND_PCM_READ_CHANNELS:
3029                 if(file->f_mode & FMODE_READ)
3030                         state = (struct cs_state *)card->states[0];
3031                 else
3032                         state = (struct cs_state *)card->states[1];
3033                 if(state)
3034                 {
3035                         dmabuf = &state->dmabuf;
3036                         return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3037                                 p);
3038                 }
3039                 return put_user(0, p);
3040
3041         case SOUND_PCM_READ_BITS:
3042                 if(file->f_mode & FMODE_READ)
3043                         state = (struct cs_state *)card->states[0];
3044                 else
3045                         state = (struct cs_state *)card->states[1];
3046                 if(state)
3047                 {
3048                         dmabuf = &state->dmabuf;
3049                         return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3050                                 AFMT_S16_LE : AFMT_U8, p);
3051
3052                 }
3053                 return put_user(0, p);
3054
3055         case SNDCTL_DSP_MAPINBUF:
3056         case SNDCTL_DSP_MAPOUTBUF:
3057         case SNDCTL_DSP_SETSYNCRO:
3058         case SOUND_PCM_WRITE_FILTER:
3059         case SOUND_PCM_READ_FILTER:
3060                 return -EINVAL;
3061         }
3062         return -EINVAL;
3063 }
3064
3065
3066 /*
3067  *      AMP control - null AMP
3068  */
3069
3070 static void amp_none(struct cs_card *card, int change)
3071 {
3072 }
3073
3074 /*
3075  *      Crystal EAPD mode
3076  */
3077
3078 static void amp_voyetra(struct cs_card *card, int change)
3079 {
3080         /* Manage the EAPD bit on the Crystal 4297
3081            and the Analog AD1885 */
3082
3083         int old=card->amplifier;
3084
3085         card->amplifier+=change;
3086         if(card->amplifier && !old)
3087         {
3088                 /* Turn the EAPD amp on */
3089                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3090                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3091                                 0x8000);
3092         }
3093         else if(old && !card->amplifier)
3094         {
3095                 /* Turn the EAPD amp off */
3096                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3097                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3098                                 ~0x8000);
3099         }
3100 }
3101
3102
3103 /*
3104  *      Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3105  */
3106
3107 static void amp_hercules(struct cs_card *card, int change)
3108 {
3109         int old=card->amplifier;
3110         if(!card)
3111         {
3112                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3113                         "cs46xx: amp_hercules() called before initialized.\n"));
3114                 return;
3115         }
3116         card->amplifier+=change;
3117         if( (card->amplifier && !old) && !(hercules_egpio_disable))
3118         {
3119                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3120                         "cs46xx: amp_hercules() external amp enabled\n"));
3121                 cs461x_pokeBA0(card, BA0_EGPIODR,
3122                         EGPIODR_GPOE2);     /* enable EGPIO2 output */
3123                 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3124                         EGPIOPTR_GPPT2);   /* open-drain on output */
3125         }
3126         else if(old && !card->amplifier)
3127         {
3128                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3129                         "cs46xx: amp_hercules() external amp disabled\n"));
3130                 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3131                 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3132         }
3133 }
3134
3135 /*
3136  *      Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3137  *      whenever we need to beat on the chip.
3138  *
3139  *      The original idea and code for this hack comes from David Kaiser at
3140  *      Linuxcare. Perhaps one day Crystal will document their chips well
3141  *      enough to make them useful.
3142  */
3143
3144 static void clkrun_hack(struct cs_card *card, int change)
3145 {
3146         struct pci_dev *acpi_dev;
3147         u16 control;
3148         u8 pp;
3149         unsigned long port;
3150         int old=card->active;
3151
3152         card->active+=change;
3153
3154         acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3155         if(acpi_dev == NULL)
3156                 return;         /* Not a thinkpad thats for sure */
3157
3158         /* Find the control port */
3159         pci_read_config_byte(acpi_dev, 0x41, &pp);
3160         port=pp<<8;
3161
3162         /* Read ACPI port */
3163         control=inw(port+0x10);
3164
3165         /* Flip CLKRUN off while running */
3166         if(!card->active && old)
3167         {
3168                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3169                         "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3170                                 change,card->active));
3171                 outw(control|0x2000, port+0x10);
3172         }
3173         else
3174         {
3175         /*
3176         * sometimes on a resume the bit is set, so always reset the bit.
3177         */
3178                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3179                         "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3180                                 change,card->active));
3181                 outw(control&~0x2000, port+0x10);
3182         }
3183 }
3184
3185
3186 static int cs_open(struct inode *inode, struct file *file)
3187 {
3188         struct cs_card *card = (struct cs_card *)file->private_data;
3189         struct cs_state *state = NULL;
3190         struct dmabuf *dmabuf = NULL;
3191         struct list_head *entry;
3192         unsigned int minor = iminor(inode);
3193         int ret=0;
3194         unsigned int tmp;
3195
3196         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3197                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3198                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3199
3200         list_for_each(entry, &cs46xx_devs)
3201         {
3202                 card = list_entry(entry, struct cs_card, list);
3203
3204                 if (!((card->dev_audio ^ minor) & ~0xf))
3205                         break;
3206         }
3207         if (entry == &cs46xx_devs)
3208                 return -ENODEV;
3209         if (!card) {
3210                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3211                         "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3212                 return -ENODEV;
3213         }
3214
3215         /*
3216          * hardcode state[0] for capture, [1] for playback
3217          */
3218         if(file->f_mode & FMODE_READ)
3219         {
3220                 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3221                 if (card->states[0] == NULL) {
3222                         state = card->states[0] = (struct cs_state *)
3223                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3224                         if (state == NULL)
3225                                 return -ENOMEM;
3226                         memset(state, 0, sizeof(struct cs_state));
3227                         init_MUTEX(&state->sem);
3228                         dmabuf = &state->dmabuf;
3229                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3230                         if(dmabuf->pbuf==NULL)
3231                         {
3232                                 kfree(state);
3233                                 card->states[0]=NULL;
3234                                 return -ENOMEM;
3235                         }
3236                 }
3237                 else
3238                 {
3239                         state = card->states[0];
3240                         if(state->open_mode & FMODE_READ)
3241                                 return -EBUSY;
3242                 }
3243                 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3244
3245                 if (dmabuf->channel == NULL) {
3246                         kfree (card->states[0]);
3247                         card->states[0] = NULL;
3248                         return -ENODEV;
3249                 }
3250
3251                 /* Now turn on external AMP if needed */
3252                 state->card = card;
3253                 state->card->active_ctrl(state->card,1);
3254                 state->card->amplifier_ctrl(state->card,1);
3255
3256                 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3257                 {
3258                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3259                                 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3260                         return -EIO;
3261                 }
3262
3263                 dmabuf->channel->state = state;
3264                 /* initialize the virtual channel */
3265                 state->virt = 0;
3266                 state->magic = CS_STATE_MAGIC;
3267                 init_waitqueue_head(&dmabuf->wait);
3268                 init_MUTEX(&state->open_sem);
3269                 file->private_data = card;
3270
3271                 down(&state->open_sem);
3272
3273                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3274                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3275                    /dev/dspW will accept 16-bits sample */
3276
3277                 /* Default input is 8bit mono */
3278                 dmabuf->fmt &= ~CS_FMT_MASK;
3279                 dmabuf->type = CS_TYPE_ADC;
3280                 dmabuf->ossfragshift = 0;
3281                 dmabuf->ossmaxfrags  = 0;
3282                 dmabuf->subdivision  = 0;
3283                 cs_set_adc_rate(state, 8000);
3284                 cs_set_divisor(dmabuf);
3285
3286                 state->open_mode |= FMODE_READ;
3287                 up(&state->open_sem);
3288         }
3289         if(file->f_mode & FMODE_WRITE)
3290         {
3291                 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3292                 if (card->states[1] == NULL) {
3293                         state = card->states[1] = (struct cs_state *)
3294                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3295                         if (state == NULL)
3296                                 return -ENOMEM;
3297                         memset(state, 0, sizeof(struct cs_state));
3298                         init_MUTEX(&state->sem);
3299                         dmabuf = &state->dmabuf;
3300                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3301                         if(dmabuf->pbuf==NULL)
3302                         {
3303                                 kfree(state);
3304                                 card->states[1]=NULL;
3305                                 return -ENOMEM;
3306                         }
3307                 }
3308                 else
3309                 {
3310                         state = card->states[1];
3311                         if(state->open_mode & FMODE_WRITE)
3312                                 return -EBUSY;
3313                 }
3314                 dmabuf->channel = card->alloc_pcm_channel(card);
3315
3316                 if (dmabuf->channel == NULL) {
3317                         kfree (card->states[1]);
3318                         card->states[1] = NULL;
3319                         return -ENODEV;
3320                 }
3321
3322                 /* Now turn on external AMP if needed */
3323                 state->card = card;
3324                 state->card->active_ctrl(state->card,1);
3325                 state->card->amplifier_ctrl(state->card,1);
3326
3327                 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3328                 {
3329                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3330                                 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3331                         return -EIO;
3332                 }
3333
3334                 dmabuf->channel->state = state;
3335                 /* initialize the virtual channel */
3336                 state->virt = 1;
3337                 state->magic = CS_STATE_MAGIC;
3338                 init_waitqueue_head(&dmabuf->wait);
3339                 init_MUTEX(&state->open_sem);
3340                 file->private_data = card;
3341
3342                 down(&state->open_sem);
3343
3344                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3345                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3346                    /dev/dspW will accept 16-bits sample */
3347
3348                 /* Default output is 8bit mono. */
3349                 dmabuf->fmt &= ~CS_FMT_MASK;
3350                 dmabuf->type = CS_TYPE_DAC;
3351                 dmabuf->ossfragshift = 0;
3352                 dmabuf->ossmaxfrags  = 0;
3353                 dmabuf->subdivision  = 0;
3354                 cs_set_dac_rate(state, 8000);
3355                 cs_set_divisor(dmabuf);
3356
3357                 state->open_mode |= FMODE_WRITE;
3358                 up(&state->open_sem);
3359                 if((ret = prog_dmabuf(state)))
3360                         return ret;
3361         }
3362         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3363         return nonseekable_open(inode, file);
3364 }
3365
3366 static int cs_release(struct inode *inode, struct file *file)
3367 {
3368         struct cs_card *card = (struct cs_card *)file->private_data;
3369         struct dmabuf *dmabuf;
3370         struct cs_state *state;
3371         unsigned int tmp;
3372         CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3373                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3374                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3375
3376         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3377         {
3378                 return -EINVAL;
3379         }
3380         state = card->states[1];
3381         if(state)
3382         {
3383                 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3384                 {
3385                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3386                         dmabuf = &state->dmabuf;
3387                         cs_clear_tail(state);
3388                         drain_dac(state, file->f_flags & O_NONBLOCK);
3389                         /* stop DMA state machine and free DMA buffers/channels */
3390                         down(&state->open_sem);
3391                         stop_dac(state);
3392                         dealloc_dmabuf(state);
3393                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3394                         free_page((unsigned long)state->dmabuf.pbuf);
3395
3396                         /* we're covered by the open_sem */
3397                         up(&state->open_sem);
3398                         state->card->states[state->virt] = NULL;
3399                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3400
3401                         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3402                         {
3403                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3404                                         "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3405                         }
3406
3407                         /* Now turn off external AMP if needed */
3408                         state->card->amplifier_ctrl(state->card, -1);
3409                         state->card->active_ctrl(state->card, -1);
3410
3411                         kfree(state);
3412                 }
3413         }
3414
3415         state = card->states[0];
3416         if(state)
3417         {
3418                 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3419                 {
3420                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3421                         dmabuf = &state->dmabuf;
3422                         down(&state->open_sem);
3423                         stop_adc(state);
3424                         dealloc_dmabuf(state);
3425                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3426                         free_page((unsigned long)state->dmabuf.pbuf);
3427
3428                         /* we're covered by the open_sem */
3429                         up(&state->open_sem);
3430                         state->card->states[state->virt] = NULL;
3431                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3432
3433                         if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3434                         {
3435                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3436                                         "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3437                         }
3438
3439                         /* Now turn off external AMP if needed */
3440                         state->card->amplifier_ctrl(state->card, -1);
3441                         state->card->active_ctrl(state->card, -1);
3442
3443                         kfree(state);
3444                 }
3445         }
3446
3447         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3448         return 0;
3449 }
3450
3451 static void printpm(struct cs_card *s)
3452 {
3453         CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3454         CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3455                 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3456         CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3457                 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3458         CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3459                 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3460         CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3461                 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3462         CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3463                 s->pm.u32SSCR,s->pm.u32SRCSA));
3464         CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3465                 s->pm.u32DacASR,s->pm.u32AdcASR));
3466         CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3467                 s->pm.u32DacSR,s->pm.u32AdcSR));
3468         CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3469                 s->pm.u32MIDCR_Save));
3470         CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3471                 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3472         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3473                 s->pm.u32AC97_master_volume));
3474         CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3475                 s->pm.u32AC97_headphone_volume));
3476         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3477                 s->pm.u32AC97_master_volume_mono));
3478         CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3479                 s->pm.u32AC97_pcm_out_volume));
3480         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3481                 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3482         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3483                 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3484
3485 }
3486
3487 /****************************************************************************
3488 *
3489 *  Suspend - save the ac97 regs, mute the outputs and power down the part.
3490 *
3491 ****************************************************************************/
3492 void cs46xx_ac97_suspend(struct cs_card *card)
3493 {
3494         int Count,i;
3495         struct ac97_codec *dev=card->ac97_codec[0];
3496         unsigned int tmp;
3497
3498         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3499
3500         if(card->states[1])
3501         {
3502                 stop_dac(card->states[1]);
3503                 resync_dma_ptrs(card->states[1]);
3504         }
3505         if(card->states[0])
3506         {
3507                 stop_adc(card->states[0]);
3508                 resync_dma_ptrs(card->states[0]);
3509         }
3510
3511         for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3512                         && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3513                 Count += 2, i++)
3514         {
3515                 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3516         }
3517 /*
3518 * Save the ac97 volume registers as well as the current powerdown state.
3519 * Now, mute the all the outputs (master, headphone, and mono), as well
3520 * as the PCM volume, in preparation for powering down the entire part.
3521         card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3522                         (u8)BA0_AC97_MASTER_VOLUME);
3523         card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3524                         (u8)BA0_AC97_HEADPHONE_VOLUME);
3525         card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3526                         (u8)BA0_AC97_MASTER_VOLUME_MONO);
3527         card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3528                         (u8)BA0_AC97_PCM_OUT_VOLUME);
3529 */
3530 /*
3531 * mute the outputs
3532 */
3533         cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3534         cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3535         cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3536         cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3537
3538 /*
3539 * save the registers that cause pops
3540 */
3541         card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3542         card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3543 /*
3544 * And power down everything on the AC97 codec.
3545 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3546 * trouble with removing VREF.
3547 */
3548         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3549                         CS_POWER_MIXVON, CS_TRUE )) )
3550         {
3551                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3552                         "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3553         }
3554
3555         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3556 }
3557
3558 /****************************************************************************
3559 *
3560 *  Resume - power up the part and restore its registers..
3561 *
3562 ****************************************************************************/
3563 void cs46xx_ac97_resume(struct cs_card *card)
3564 {
3565         int Count,i;
3566         struct ac97_codec *dev=card->ac97_codec[0];
3567
3568         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3569
3570 /*
3571 * First, we restore the state of the general purpose register.  This
3572 * contains the mic select (mic1 or mic2) and if we restore this after
3573 * we restore the mic volume/boost state and mic2 was selected at
3574 * suspend time, we will end up with a brief period of time where mic1
3575 * is selected with the volume/boost settings for mic2, causing
3576 * acoustic feedback.  So we restore the general purpose register
3577 * first, thereby getting the correct mic selected before we restore
3578 * the mic volume/boost.
3579 */
3580         cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3581                 (u16)card->pm.u32AC97_general_purpose);
3582 /*
3583 * Now, while the outputs are still muted, restore the state of power
3584 * on the AC97 part.
3585 */
3586         cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3587         mdelay(5 * cs_laptop_wait);
3588 /*
3589 * Restore just the first set of registers, from register number
3590 * 0x02 to the register number that ulHighestRegToRestore specifies.
3591 */
3592         for(    Count = 0x2, i=0;
3593                 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3594                         && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3595                 Count += 2, i++)
3596         {
3597                 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3598         }
3599
3600         /* Check if we have to init the amplifier */
3601         if(card->amp_init)
3602                 card->amp_init(card);
3603
3604         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3605 }
3606
3607
3608 static int cs46xx_restart_part(struct cs_card *card)
3609 {
3610         struct dmabuf *dmabuf;
3611         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3612                 printk( "cs46xx: cs46xx_restart_part()+\n"));
3613         if(card->states[1])
3614         {
3615                 dmabuf = &card->states[1]->dmabuf;
3616                 dmabuf->ready = 0;
3617                 resync_dma_ptrs(card->states[1]);
3618                 cs_set_divisor(dmabuf);
3619                 if(__prog_dmabuf(card->states[1]))
3620                 {
3621                         CS_DBGOUT(CS_PM | CS_ERROR, 1,
3622                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3623                         return -1;
3624                 }
3625                 cs_set_dac_rate(card->states[1], dmabuf->rate);
3626         }
3627         if(card->states[0])
3628         {
3629                 dmabuf = &card->states[0]->dmabuf;
3630                 dmabuf->ready = 0;
3631                 resync_dma_ptrs(card->states[0]);
3632                 cs_set_divisor(dmabuf);
3633                 if(__prog_dmabuf(card->states[0]))
3634                 {
3635                         CS_DBGOUT(CS_PM | CS_ERROR, 1,
3636                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3637                         return -1;
3638                 }
3639                 cs_set_adc_rate(card->states[0], dmabuf->rate);
3640         }
3641         card->pm.flags |= CS46XX_PM_RESUMED;
3642         if(card->states[0])
3643                 start_adc(card->states[0]);
3644         if(card->states[1])
3645                 start_dac(card->states[1]);
3646
3647         card->pm.flags |= CS46XX_PM_IDLE;
3648         card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3649                         | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3650         if(card->states[0])
3651                 wake_up(&card->states[0]->dmabuf.wait);
3652         if(card->states[1])
3653                 wake_up(&card->states[1]->dmabuf.wait);
3654
3655         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3656                 printk( "cs46xx: cs46xx_restart_part()-\n"));
3657         return 0;
3658 }
3659
3660
3661 static void cs461x_reset(struct cs_card *card);
3662 static void cs461x_proc_stop(struct cs_card *card);
3663 static int cs46xx_suspend(struct cs_card *card, u32 state)
3664 {
3665         unsigned int tmp;
3666         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3667                 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
3668                         (unsigned)card->pm.flags,card));
3669 /*
3670 * check the current state, only suspend if IDLE
3671 */
3672         if(!(card->pm.flags & CS46XX_PM_IDLE))
3673         {
3674                 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3675                         printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3676                 return 1;
3677         }
3678         card->pm.flags &= ~CS46XX_PM_IDLE;
3679         card->pm.flags |= CS46XX_PM_SUSPENDING;
3680
3681         card->active_ctrl(card,1);
3682
3683         tmp = cs461x_peek(card, BA1_PFIE);
3684         tmp &= ~0x0000f03f;
3685         tmp |=  0x00000010;
3686         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt disable */
3687
3688         tmp = cs461x_peek(card, BA1_CIE);
3689         tmp &= ~0x0000003f;
3690         tmp |=  0x00000011;
3691         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt disable */
3692
3693         /*
3694          *  Stop playback DMA.
3695          */
3696         tmp = cs461x_peek(card, BA1_PCTL);
3697         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3698
3699         /*
3700          *  Stop capture DMA.
3701          */
3702         tmp = cs461x_peek(card, BA1_CCTL);
3703         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3704
3705         if(card->states[1])
3706         {
3707                 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3708                 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3709         }
3710         if(card->states[0])
3711         {
3712                 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3713                 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3714         }
3715
3716         cs46xx_ac97_suspend(card);
3717
3718         /*
3719          *  Reset the processor.
3720          */
3721         cs461x_reset(card);
3722
3723         cs461x_proc_stop(card);
3724
3725         /*
3726          *  Power down the DAC and ADC.  For now leave the other areas on.
3727          */
3728         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3729
3730         /*
3731          *  Power down the PLL.
3732          */
3733         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3734
3735         /*
3736          *  Turn off the Processor by turning off the software clock enable flag in
3737          *  the clock control register.
3738          */
3739         tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3740         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3741
3742         card->active_ctrl(card,-1);
3743
3744         card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3745         card->pm.flags |= CS46XX_PM_SUSPENDED;
3746
3747         printpm(card);
3748
3749         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3750                 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3751                         (unsigned)card->pm.flags));
3752         return 0;
3753 }
3754
3755 static int cs46xx_resume(struct cs_card *card)
3756 {
3757         int i;
3758
3759         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3760                 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3761                         (unsigned)card->pm.flags));
3762         if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
3763         {
3764                 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3765                         printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3766                 return 1;
3767         }
3768         card->pm.flags |= CS46XX_PM_RESUMING;
3769         card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3770         printpm(card);
3771         card->active_ctrl(card, 1);
3772
3773         for(i=0;i<5;i++)
3774         {
3775                 if (cs_hardware_init(card) != 0)
3776                 {
3777                         CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3778                                 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3779                         mdelay(10 * cs_laptop_wait);
3780                         cs461x_reset(card);
3781                         continue;
3782                 }
3783                 break;
3784         }
3785         if(i>=4)
3786         {
3787                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3788                         "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3789                 return 0;
3790         }
3791
3792         if(cs46xx_restart_part(card))
3793         {
3794                 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3795                         "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3796         }
3797
3798         card->active_ctrl(card, -1);
3799
3800         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3801                 (unsigned)card->pm.flags));
3802         return 0;
3803 }
3804
3805 static /*const*/ struct file_operations cs461x_fops = {
3806         CS_OWNER        CS_THIS_MODULE
3807         .llseek         = no_llseek,
3808         .read           = cs_read,
3809         .write          = cs_write,
3810         .poll           = cs_poll,
3811         .ioctl          = cs_ioctl,
3812         .mmap           = cs_mmap,
3813         .open           = cs_open,
3814         .release        = cs_release,
3815 };
3816
3817 /* Write AC97 codec registers */
3818
3819
3820 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3821 {
3822         struct cs_card *card = dev->private_data;
3823         int count,loopcnt;
3824         unsigned int tmp;
3825         u16 ret;
3826
3827         /*
3828          *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3829          *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
3830          *  3. Write ACCTL = Control Register = 460h for initiating the write
3831          *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3832          *  5. if DCV not cleared, break and return error
3833          *  6. Read ACSTS = Status Register = 464h, check VSTS bit
3834          */
3835
3836         cs461x_peekBA0(card, BA0_ACSDA);
3837
3838         /*
3839          *  Setup the AC97 control registers on the CS461x to send the
3840          *  appropriate command to the AC97 to perform the read.
3841          *  ACCAD = Command Address Register = 46Ch
3842          *  ACCDA = Command Data Register = 470h
3843          *  ACCTL = Control Register = 460h
3844          *  set DCV - will clear when process completed
3845          *  set CRW - Read command
3846          *  set VFRM - valid frame enabled
3847          *  set ESYN - ASYNC generation enabled
3848          *  set RSTN - ARST# inactive, AC97 codec not reset
3849          */
3850
3851         cs461x_pokeBA0(card, BA0_ACCAD, reg);
3852         cs461x_pokeBA0(card, BA0_ACCDA, 0);
3853         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3854                                              ACCTL_VFRM | ACCTL_ESYN |
3855                                              ACCTL_RSTN);
3856
3857
3858         /*
3859          *  Wait for the read to occur.
3860          */
3861         if(!(card->pm.flags & CS46XX_PM_IDLE))
3862                 loopcnt = 2000;
3863         else
3864                 loopcnt = 500 * cs_laptop_wait;
3865         loopcnt *= cs_laptop_wait;
3866         for (count = 0; count < loopcnt; count++) {
3867                 /*
3868                  *  First, we want to wait for a short time.
3869                  */
3870                 udelay(10 * cs_laptop_wait);
3871                 /*
3872                  *  Now, check to see if the read has completed.
3873                  *  ACCTL = 460h, DCV should be reset by now and 460h = 17h
3874                  */
3875                 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3876                         break;
3877         }
3878
3879         /*
3880          *  Make sure the read completed.
3881          */
3882         if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3883                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3884                         "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3885                 return 0xffff;
3886         }
3887
3888         /*
3889          *  Wait for the valid status bit to go active.
3890          */
3891
3892         if(!(card->pm.flags & CS46XX_PM_IDLE))
3893                 loopcnt = 2000;
3894         else
3895                 loopcnt = 1000;
3896         loopcnt *= cs_laptop_wait;
3897         for (count = 0; count < loopcnt; count++) {
3898                 /*
3899                  *  Read the AC97 status register.
3900                  *  ACSTS = Status Register = 464h
3901                  *  VSTS - Valid Status
3902                  */
3903                 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3904                         break;
3905                 udelay(10 * cs_laptop_wait);
3906         }
3907
3908         /*
3909          *  Make sure we got valid status.
3910          */
3911         if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3912                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3913                         "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3914                                 reg, tmp));
3915                 return 0xffff;
3916         }
3917
3918         /*
3919          *  Read the data returned from the AC97 register.
3920          *  ACSDA = Status Data Register = 474h
3921          */
3922         CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3923                 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3924                         reg, cs461x_peekBA0(card, BA0_ACSDA),
3925                         cs461x_peekBA0(card, BA0_ACCAD)));
3926         ret = cs461x_peekBA0(card, BA0_ACSDA);
3927         return ret;
3928 }
3929
3930 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3931 {
3932         u16 ret;
3933         struct cs_card *card = dev->private_data;
3934
3935         spin_lock(&card->ac97_lock);
3936         ret = _cs_ac97_get(dev, reg);
3937         spin_unlock(&card->ac97_lock);
3938         return ret;
3939 }
3940
3941 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3942 {
3943         struct cs_card *card = dev->private_data;
3944         int count;
3945         int val2 = 0;
3946
3947         spin_lock(&card->ac97_lock);
3948
3949         if(reg == AC97_CD_VOL)
3950         {
3951                 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3952         }
3953
3954
3955         /*
3956          *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3957          *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
3958          *  3. Write ACCTL = Control Register = 460h for initiating the write
3959          *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3960          *  5. if DCV not cleared, break and return error
3961          */
3962
3963         /*
3964          *  Setup the AC97 control registers on the CS461x to send the
3965          *  appropriate command to the AC97 to perform the read.
3966          *  ACCAD = Command Address Register = 46Ch
3967          *  ACCDA = Command Data Register = 470h
3968          *  ACCTL = Control Register = 460h
3969          *  set DCV - will clear when process completed
3970          *  reset CRW - Write command
3971          *  set VFRM - valid frame enabled
3972          *  set ESYN - ASYNC generation enabled
3973          *  set RSTN - ARST# inactive, AC97 codec not reset
3974          */
3975         cs461x_pokeBA0(card, BA0_ACCAD, reg);
3976         cs461x_pokeBA0(card, BA0_ACCDA, val);
3977         cs461x_peekBA0(card, BA0_ACCTL);
3978         cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3979         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3980                                              ACCTL_ESYN | ACCTL_RSTN);
3981         for (count = 0; count < 1000; count++) {
3982                 /*
3983                  *  First, we want to wait for a short time.
3984                  */
3985                 udelay(10 * cs_laptop_wait);
3986                 /*
3987                  *  Now, check to see if the write has completed.
3988                  *  ACCTL = 460h, DCV should be reset by now and 460h = 07h
3989                  */
3990                 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3991                         break;
3992         }
3993         /*
3994          *  Make sure the write completed.
3995          */
3996         if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
3997         {
3998                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3999                         "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
4000         }
4001
4002         spin_unlock(&card->ac97_lock);
4003
4004         /*
4005          *      Adjust power if the mixer is selected/deselected according
4006          *      to the CD.
4007          *
4008          *      IF the CD is a valid input source (mixer or direct) AND
4009          *              the CD is not muted THEN power is needed
4010          *
4011          *      We do two things. When record select changes the input to
4012          *      add/remove the CD we adjust the power count if the CD is
4013          *      unmuted.
4014          *
4015          *      When the CD mute changes we adjust the power level if the
4016          *      CD was a valid input.
4017          *
4018          *      We also check for CD volume != 0, as the CD mute isn't
4019          *      normally tweaked from userspace.
4020          */
4021
4022         /* CD mute change ? */
4023
4024         if(reg==AC97_CD_VOL)
4025         {
4026                 /* Mute bit change ? */
4027                 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
4028                 {
4029                         /* This is a hack but its cleaner than the alternatives.
4030                            Right now card->ac97_codec[0] might be NULL as we are
4031                            still doing codec setup. This does an early assignment
4032                            to avoid the problem if it occurs */
4033
4034                         if(card->ac97_codec[0]==NULL)
4035                                 card->ac97_codec[0]=dev;
4036
4037                         /* Mute on */
4038                         if(val&0x8000 || val == 0x1f1f)
4039                                 card->amplifier_ctrl(card, -1);
4040                         else /* Mute off power on */
4041                         {
4042                                 if(card->amp_init)
4043                                         card->amp_init(card);
4044                                 card->amplifier_ctrl(card, 1);
4045                         }
4046                 }
4047         }
4048 }
4049
4050
4051 /* OSS /dev/mixer file operation methods */
4052
4053 static int cs_open_mixdev(struct inode *inode, struct file *file)
4054 {
4055         int i=0;
4056         unsigned int minor = iminor(inode);
4057         struct cs_card *card=NULL;
4058         struct list_head *entry;
4059         unsigned int tmp;
4060
4061         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4062                   printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
4063
4064         list_for_each(entry, &cs46xx_devs)
4065         {
4066                 card = list_entry(entry, struct cs_card, list);
4067                 for (i = 0; i < NR_AC97; i++)
4068                         if (card->ac97_codec[i] != NULL &&
4069                             card->ac97_codec[i]->dev_mixer == minor)
4070                                 goto match;
4071         }
4072         if (!card)
4073         {
4074                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4075                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4076                 return -ENODEV;
4077         }
4078  match:
4079         if(!card->ac97_codec[i])
4080                 return -ENODEV;
4081         file->private_data = card->ac97_codec[i];
4082
4083         card->active_ctrl(card,1);
4084         if(!CS_IN_USE(&card->mixer_use_cnt))
4085         {
4086                 if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
4087                 {
4088                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4089                                 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
4090                         return -EIO;
4091                 }
4092         }
4093         card->amplifier_ctrl(card, 1);
4094         CS_INC_USE_COUNT(&card->mixer_use_cnt);
4095         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4096                   printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
4097         return nonseekable_open(inode, file);
4098 }
4099
4100 static int cs_release_mixdev(struct inode *inode, struct file *file)
4101 {
4102         unsigned int minor = iminor(inode);
4103         struct cs_card *card=NULL;
4104         struct list_head *entry;
4105         int i;
4106         unsigned int tmp;
4107
4108         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4109                   printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
4110         list_for_each(entry, &cs46xx_devs)
4111         {
4112                 card = list_entry(entry, struct cs_card, list);
4113                 for (i = 0; i < NR_AC97; i++)
4114                         if (card->ac97_codec[i] != NULL &&
4115                             card->ac97_codec[i]->dev_mixer == minor)
4116                                 goto match;
4117         }
4118         if (!card)
4119         {
4120                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4121                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4122                 return -ENODEV;
4123         }
4124 match:
4125         if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
4126         {
4127                 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4128                           printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
4129                 card->active_ctrl(card, -1);
4130                 card->amplifier_ctrl(card, -1);
4131                 return 0;
4132         }
4133 /*
4134 * ok, no outstanding mixer opens, so powerdown.
4135 */
4136         if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
4137         {
4138                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4139                         "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
4140                 card->active_ctrl(card, -1);
4141                 card->amplifier_ctrl(card, -1);
4142                 return -EIO;
4143         }
4144         card->active_ctrl(card, -1);
4145         card->amplifier_ctrl(card, -1);
4146         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4147                   printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
4148         return 0;
4149 }
4150
4151 void __exit cs46xx_cleanup_module(void);
4152 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4153                                 unsigned long arg)
4154 {
4155         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
4156         struct cs_card *card=NULL;
4157         struct list_head *entry;
4158         unsigned long __user *p = (long __user *)arg;
4159
4160 #if CSDEBUG_INTERFACE
4161         int val;
4162
4163         if(     (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
4164                 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
4165                 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
4166                 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
4167                 (cmd == SOUND_MIXER_CS_APM))
4168         {
4169             switch(cmd)
4170             {
4171
4172                 case SOUND_MIXER_CS_GETDBGMASK:
4173                         return put_user(cs_debugmask, p);
4174
4175                 case SOUND_MIXER_CS_GETDBGLEVEL:
4176                         return put_user(cs_debuglevel, p);
4177
4178                 case SOUND_MIXER_CS_SETDBGMASK:
4179                         if (get_user(val, p))
4180                                 return -EFAULT;
4181                         cs_debugmask = val;
4182                         return 0;
4183
4184                 case SOUND_MIXER_CS_SETDBGLEVEL:
4185                         if (get_user(val, p))
4186                                 return -EFAULT;
4187                         cs_debuglevel = val;
4188                         return 0;
4189
4190                 case SOUND_MIXER_CS_APM:
4191                         if (get_user(val, p))
4192                                 return -EFAULT;
4193                         if(val == CS_IOCTL_CMD_SUSPEND)
4194                         {
4195                                 list_for_each(entry, &cs46xx_devs)
4196                                 {
4197                                         card = list_entry(entry, struct cs_card, list);
4198                                         cs46xx_suspend(card, 0);
4199                                 }
4200
4201                         }
4202                         else if(val == CS_IOCTL_CMD_RESUME)
4203                         {
4204                                 list_for_each(entry, &cs46xx_devs)
4205                                 {
4206                                         card = list_entry(entry, struct cs_card, list);
4207                                         cs46xx_resume(card);
4208                                 }
4209                         }
4210                         else
4211                         {
4212                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4213                                     "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
4214                                         val));
4215                         }
4216                         return 0;
4217
4218                 default:
4219                         CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4220                                 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
4221                         return 0;
4222             }
4223         }
4224 #endif
4225         return codec->mixer_ioctl(codec, cmd, arg);
4226 }
4227
4228 static /*const*/ struct file_operations cs_mixer_fops = {
4229         CS_OWNER        CS_THIS_MODULE
4230         .llseek         = no_llseek,
4231         .ioctl          = cs_ioctl_mixdev,
4232         .open           = cs_open_mixdev,
4233         .release        = cs_release_mixdev,
4234 };
4235
4236 /* AC97 codec initialisation. */
4237 static int __init cs_ac97_init(struct cs_card *card)
4238 {
4239         int num_ac97 = 0;
4240         int ready_2nd = 0;
4241         struct ac97_codec *codec;
4242         u16 eid;
4243
4244         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4245                 "cs46xx: cs_ac97_init()+\n") );
4246
4247         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4248                 if ((codec = ac97_alloc_codec()) == NULL)
4249                         return -ENOMEM;
4250
4251                 /* initialize some basic codec information, other fields will be filled
4252                    in ac97_probe_codec */
4253                 codec->private_data = card;
4254                 codec->id = num_ac97;
4255
4256                 codec->codec_read = cs_ac97_get;
4257                 codec->codec_write = cs_ac97_set;
4258
4259                 if (ac97_probe_codec(codec) == 0)
4260                 {
4261                         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4262                                 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4263                                         num_ac97) );
4264                         card->ac97_codec[num_ac97] = NULL;
4265                         break;
4266                 }
4267                 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4268                         "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
4269
4270                 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4271
4272                 if(eid==0xFFFF)
4273                 {
4274                         printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4275                         ac97_release_codec(codec);
4276                         break;
4277                 }
4278
4279                 card->ac97_features = eid;
4280
4281                 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4282                         printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4283                         ac97_release_codec(codec);
4284                         break;
4285                 }
4286                 card->ac97_codec[num_ac97] = codec;
4287
4288                 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4289                         "cs46xx: cs_ac97_init() ac97_codec[%d] set to %p\n",
4290                                 (unsigned int)num_ac97,
4291                                 codec));
4292                 /* if there is no secondary codec at all, don't probe any more */
4293                 if (!ready_2nd)
4294                 {
4295                         num_ac97 += 1;
4296                         break;
4297                 }
4298         }
4299         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4300                 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4301         return num_ac97;
4302 }
4303
4304 /*
4305  * load the static image into the DSP
4306  */
4307 #include "cs461x_image.h"
4308 static void cs461x_download_image(struct cs_card *card)
4309 {
4310     unsigned i, j, temp1, temp2, offset, count;
4311     unsigned char *pBA1 = ioremap(card->ba1_addr, 0x40000);
4312     for( i=0; i < CLEAR__COUNT; i++)
4313     {
4314         offset = ClrStat[i].BA1__DestByteOffset;
4315         count  = ClrStat[i].BA1__SourceSize;
4316         for(  temp1 = offset; temp1<(offset+count); temp1+=4 )
4317               writel(0, pBA1+temp1);
4318     }
4319
4320     for(i=0; i<FILL__COUNT; i++)
4321     {
4322         temp2 = FillStat[i].Offset;
4323         for(j=0; j<(FillStat[i].Size)/4; j++)
4324         {
4325             temp1 = (FillStat[i]).pFill[j];
4326             writel(temp1, pBA1+temp2+j*4);
4327         }
4328     }
4329     iounmap(pBA1);
4330 }
4331
4332
4333 /*
4334  *  Chip reset
4335  */
4336
4337 static void cs461x_reset(struct cs_card *card)
4338 {
4339         int idx;
4340
4341         /*
4342          *  Write the reset bit of the SP control register.
4343          */
4344         cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4345
4346         /*
4347          *  Write the control register.
4348          */
4349         cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4350
4351         /*
4352          *  Clear the trap registers.
4353          */
4354         for (idx = 0; idx < 8; idx++) {
4355                 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4356                 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4357         }
4358         cs461x_poke(card, BA1_DREG, 0);
4359
4360         /*
4361          *  Set the frame timer to reflect the number of cycles per frame.
4362          */
4363         cs461x_poke(card, BA1_FRMT, 0xadf);
4364 }
4365
4366 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4367 {
4368         int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4369         unsigned int tmp;
4370
4371         /*
4372          *  See if the devices are powered down.  If so, we must power them up first
4373          *  or they will not respond.
4374          */
4375         if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4376                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4377                 powerdown1 = 1;
4378         }
4379
4380         /*
4381          *  We want to clear out the serial port FIFOs so we don't end up playing
4382          *  whatever random garbage happens to be in them.  We fill the sample FIFOS
4383          *  with zero (silence).
4384          */
4385         cs461x_pokeBA0(card, BA0_SERBWP, 0);
4386
4387         /*
4388         * Check for which FIFO locations to clear, if we are currently
4389         * playing or capturing then we don't want to put in 128 bytes of
4390         * "noise".
4391          */
4392         if(type & CS_TYPE_DAC)
4393         {
4394                 startfifo = 128;
4395                 endfifo = 256;
4396         }
4397         if(type & CS_TYPE_ADC)
4398         {
4399                 startfifo = 0;
4400                 if(!endfifo)
4401                         endfifo = 128;
4402         }
4403         /*
4404          *  Fill sample FIFO locations (256 locations total).
4405          */
4406         for (idx = startfifo; idx < endfifo; idx++) {
4407                 /*
4408                  *  Make sure the previous FIFO write operation has completed.
4409                  */
4410                 for (loop = 0; loop < 5; loop++) {
4411                         udelay(50);
4412                         if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4413                                 break;
4414                 }
4415                 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4416                         if (powerdown1)
4417                                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4418                 }
4419                 /*
4420                  *  Write the serial port FIFO index.
4421                  */
4422                 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4423                 /*
4424                  *  Tell the serial port to load the new value into the FIFO location.
4425                  */
4426                 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4427         }
4428         /*
4429          *  Now, if we powered up the devices, then power them back down again.
4430          *  This is kinda ugly, but should never happen.
4431          */
4432         if (powerdown1)
4433                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4434 }
4435
4436
4437 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4438 {
4439         int count;
4440         unsigned int tmp=0,muted=0;
4441
4442         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4443                 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4444         if(!cs_powerdown && !suspendflag)
4445         {
4446                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4447                         "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4448                 return 0;
4449         }
4450         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4451         CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4452                 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4453 /*
4454 * if powering down only the VREF, and not powering down the DAC/ADC,
4455 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4456 * currently powered down.  If powering down DAC and ADC, then
4457 * it is possible to power down the VREF (ON).
4458 */
4459         if (    ((type & CS_POWER_MIXVON) &&
4460                  (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
4461               &&
4462                 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4463                  (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
4464         {
4465                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4466                         "cs46xx: cs461x_powerdown()- 0  unable to powerdown. tmp=0x%x\n",tmp));
4467                 return 0;
4468         }
4469 /*
4470 * for now, always keep power to the mixer block.
4471 * not sure why it's a problem but it seems to be if we power off.
4472 */
4473         type &= ~CS_POWER_MIXVON;
4474         type &= ~CS_POWER_MIXVOFF;
4475
4476         /*
4477          *  Power down indicated areas.
4478          */
4479         if(type & CS_POWER_MIXVOFF)
4480         {
4481
4482                 CS_DBGOUT(CS_FUNCTION, 4,
4483                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4484                 /*
4485                  *  Power down the MIXER (VREF ON) on the AC97 card.
4486                  */
4487                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4488                 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4489                 {
4490                         if(!muted)
4491                         {
4492                                 cs_mute(card, CS_TRUE);
4493                                 muted=1;
4494                         }
4495                         tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4496                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4497                         /*
4498                          *  Now, we wait until we sample a ready state.
4499                          */
4500                         for (count = 0; count < 32; count++) {
4501                                 /*
4502                                  *  First, lets wait a short while to let things settle out a
4503                                  *  bit, and to prevent retrying the read too quickly.
4504                                  */
4505                                 udelay(500);
4506
4507                                 /*
4508                                  *  Read the current state of the power control register.
4509                                  */
4510                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4511                                         CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4512                                         break;
4513                         }
4514
4515                         /*
4516                          *  Check the status..
4517                          */
4518                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4519                                 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4520                         {
4521                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4522                                         "cs46xx: powerdown MIXVOFF failed\n"));
4523                                 return 1;
4524                         }
4525                 }
4526         }
4527         if(type & CS_POWER_MIXVON)
4528         {
4529
4530                 CS_DBGOUT(CS_FUNCTION, 4,
4531                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4532                 /*
4533                  *  Power down the MIXER (VREF ON) on the AC97 card.
4534                  */
4535                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4536                 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
4537                 {
4538                         if(!muted)
4539                         {
4540                                 cs_mute(card, CS_TRUE);
4541                                 muted=1;
4542                         }
4543                         tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4544                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4545                         /*
4546                          *  Now, we wait until we sample a ready state.
4547                          */
4548                         for (count = 0; count < 32; count++) {
4549                                 /*
4550                                  *  First, lets wait a short while to let things settle out a
4551                                  *  bit, and to prevent retrying the read too quickly.
4552                                  */
4553                                 udelay(500);
4554
4555                                 /*
4556                                  *  Read the current state of the power control register.
4557                                  */
4558                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4559                                         CS_AC97_POWER_CONTROL_MIXVON_ON))
4560                                         break;
4561                         }
4562
4563                         /*
4564                          *  Check the status..
4565                          */
4566                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4567                                 CS_AC97_POWER_CONTROL_MIXVON_ON)
4568                         {
4569                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4570                                         "cs46xx: powerdown MIXVON failed\n"));
4571                                 return 1;
4572                         }
4573                 }
4574         }
4575         if(type & CS_POWER_ADC)
4576         {
4577                 /*
4578                  *  Power down the ADC on the AC97 card.
4579                  */
4580                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4581                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4582                 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
4583                 {
4584                         if(!muted)
4585                         {
4586                                 cs_mute(card, CS_TRUE);
4587                                 muted=1;
4588                         }
4589                         tmp |= CS_AC97_POWER_CONTROL_ADC;
4590                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4591
4592                         /*
4593                          *  Now, we wait until we sample a ready state.
4594                          */
4595                         for (count = 0; count < 32; count++) {
4596                                 /*
4597                                  *  First, lets wait a short while to let things settle out a
4598                                  *  bit, and to prevent retrying the read too quickly.
4599                                  */
4600                                 udelay(500);
4601
4602                                 /*
4603                                  *  Read the current state of the power control register.
4604                                  */
4605                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4606                                         CS_AC97_POWER_CONTROL_ADC_ON))
4607                                         break;
4608                         }
4609
4610                         /*
4611                          *  Check the status..
4612                          */
4613                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4614                                 CS_AC97_POWER_CONTROL_ADC_ON)
4615                         {
4616                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4617                                         "cs46xx: powerdown ADC failed\n"));
4618                                 return 1;
4619                         }
4620                 }
4621         }
4622         if(type & CS_POWER_DAC)
4623         {
4624                 /*
4625                  *  Power down the DAC on the AC97 card.
4626                  */
4627
4628                 CS_DBGOUT(CS_FUNCTION, 4,
4629                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4630                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4631                 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
4632                 {
4633                         if(!muted)
4634                         {
4635                                 cs_mute(card, CS_TRUE);
4636                                 muted=1;
4637                         }
4638                         tmp |= CS_AC97_POWER_CONTROL_DAC;
4639                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4640                         /*
4641                          *  Now, we wait until we sample a ready state.
4642                          */
4643                         for (count = 0; count < 32; count++) {
4644                                 /*
4645                                  *  First, lets wait a short while to let things settle out a
4646                                  *  bit, and to prevent retrying the read too quickly.
4647                                  */
4648                                 udelay(500);
4649
4650                                 /*
4651                                  *  Read the current state of the power control register.
4652                                  */
4653                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4654                                         CS_AC97_POWER_CONTROL_DAC_ON))
4655                                         break;
4656                         }
4657
4658                         /*
4659                          *  Check the status..
4660                          */
4661                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4662                                 CS_AC97_POWER_CONTROL_DAC_ON)
4663                         {
4664                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4665                                         "cs46xx: powerdown DAC failed\n"));
4666                                 return 1;
4667                         }
4668                 }
4669         }
4670         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4671         if(muted)
4672                 cs_mute(card, CS_FALSE);
4673         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4674                 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4675         return 0;
4676 }
4677
4678 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4679 {
4680         int count;
4681         unsigned int tmp=0,muted=0;
4682
4683         CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4684                 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4685         /*
4686         * check for VREF and powerup if need to.
4687         */
4688         if(type & CS_POWER_MIXVON)
4689                 type |= CS_POWER_MIXVOFF;
4690         if(type & (CS_POWER_DAC | CS_POWER_ADC))
4691                 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4692
4693         /*
4694          *  Power up indicated areas.
4695          */
4696         if(type & CS_POWER_MIXVOFF)
4697         {
4698
4699                 CS_DBGOUT(CS_FUNCTION, 4,
4700                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4701                 /*
4702                  *  Power up the MIXER (VREF ON) on the AC97 card.
4703                  */
4704                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4705                 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4706                 {
4707                         if(!muted)
4708                         {
4709                                 cs_mute(card, CS_TRUE);
4710                                 muted=1;
4711                         }
4712                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4713                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4714                         /*
4715                          *  Now, we wait until we sample a ready state.
4716                          */
4717                         for (count = 0; count < 32; count++) {
4718                                 /*
4719                                  *  First, lets wait a short while to let things settle out a
4720                                  *  bit, and to prevent retrying the read too quickly.
4721                                  */
4722                                 udelay(500);
4723
4724                                 /*
4725                                  *  Read the current state of the power control register.
4726                                  */
4727                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4728                                         CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4729                                         break;
4730                         }
4731
4732                         /*
4733                          *  Check the status..
4734                          */
4735                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4736                                 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4737                         {
4738                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4739                                         "cs46xx: powerup MIXVOFF failed\n"));
4740                                 return 1;
4741                         }
4742                 }
4743         }
4744         if(type & CS_POWER_MIXVON)
4745         {
4746
4747                 CS_DBGOUT(CS_FUNCTION, 4,
4748                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4749                 /*
4750                  *  Power up the MIXER (VREF ON) on the AC97 card.
4751                  */
4752                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4753                 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
4754                 {
4755                         if(!muted)
4756                         {
4757                                 cs_mute(card, CS_TRUE);
4758                                 muted=1;
4759                         }
4760                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4761                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4762                         /*
4763                          *  Now, we wait until we sample a ready state.
4764                          */
4765                         for (count = 0; count < 32; count++) {
4766                                 /*
4767                                  *  First, lets wait a short while to let things settle out a
4768                                  *  bit, and to prevent retrying the read too quickly.
4769                                  */
4770                                 udelay(500);
4771
4772                                 /*
4773                                  *  Read the current state of the power control register.
4774                                  */
4775                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4776                                         CS_AC97_POWER_CONTROL_MIXVON_ON)
4777                                         break;
4778                         }
4779
4780                         /*
4781                          *  Check the status..
4782                          */
4783                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4784                                 CS_AC97_POWER_CONTROL_MIXVON_ON))
4785                         {
4786                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4787                                         "cs46xx: powerup MIXVON failed\n"));
4788                                 return 1;
4789                         }
4790                 }
4791         }
4792         if(type & CS_POWER_ADC)
4793         {
4794                 /*
4795                  *  Power up the ADC on the AC97 card.
4796                  */
4797                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4798                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4799                 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
4800                 {
4801                         if(!muted)
4802                         {
4803                                 cs_mute(card, CS_TRUE);
4804                                 muted=1;
4805                         }
4806                         tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4807                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4808
4809                         /*
4810                          *  Now, we wait until we sample a ready state.
4811                          */
4812                         for (count = 0; count < 32; count++) {
4813                                 /*
4814                                  *  First, lets wait a short while to let things settle out a
4815                                  *  bit, and to prevent retrying the read too quickly.
4816                                  */
4817                                 udelay(500);
4818
4819                                 /*
4820                                  *  Read the current state of the power control register.
4821                                  */
4822                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4823                                         CS_AC97_POWER_CONTROL_ADC_ON)
4824                                         break;
4825                         }
4826
4827                         /*
4828                          *  Check the status..
4829                          */
4830                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4831                                 CS_AC97_POWER_CONTROL_ADC_ON))
4832                         {
4833                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4834                                         "cs46xx: powerup ADC failed\n"));
4835                                 return 1;
4836                         }
4837                 }
4838         }
4839         if(type & CS_POWER_DAC)
4840         {
4841                 /*
4842                  *  Power up the DAC on the AC97 card.
4843                  */
4844
4845                 CS_DBGOUT(CS_FUNCTION, 4,
4846                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4847                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4848                 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
4849                 {
4850                         if(!muted)
4851                         {
4852                                 cs_mute(card, CS_TRUE);
4853                                 muted=1;
4854                         }
4855                         tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4856                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4857                         /*
4858                          *  Now, we wait until we sample a ready state.
4859                          */
4860                         for (count = 0; count < 32; count++) {
4861                                 /*
4862                                  *  First, lets wait a short while to let things settle out a
4863                                  *  bit, and to prevent retrying the read too quickly.
4864                                  */
4865                                 udelay(500);
4866
4867                                 /*
4868                                  *  Read the current state of the power control register.
4869                                  */
4870                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4871                                         CS_AC97_POWER_CONTROL_DAC_ON)
4872                                         break;
4873                         }
4874
4875                         /*
4876                          *  Check the status..
4877                          */
4878                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4879                                 CS_AC97_POWER_CONTROL_DAC_ON))
4880                         {
4881                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4882                                         "cs46xx: powerup DAC failed\n"));
4883                                 return 1;
4884                         }
4885                 }
4886         }
4887         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4888         if(muted)
4889                 cs_mute(card, CS_FALSE);
4890         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4891                 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4892         return 0;
4893 }
4894
4895
4896 static void cs461x_proc_start(struct cs_card *card)
4897 {
4898         int cnt;
4899
4900         /*
4901          *  Set the frame timer to reflect the number of cycles per frame.
4902          */
4903         cs461x_poke(card, BA1_FRMT, 0xadf);
4904         /*
4905          *  Turn on the run, run at frame, and DMA enable bits in the local copy of
4906          *  the SP control register.
4907          */
4908         cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4909         /*
4910          *  Wait until the run at frame bit resets itself in the SP control
4911          *  register.
4912          */
4913         for (cnt = 0; cnt < 25; cnt++) {
4914                 udelay(50);
4915                 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4916                         break;
4917         }
4918
4919         if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4920                 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4921 }
4922
4923 static void cs461x_proc_stop(struct cs_card *card)
4924 {
4925         /*
4926          *  Turn off the run, run at frame, and DMA enable bits in the local copy of
4927          *  the SP control register.
4928          */
4929         cs461x_poke(card, BA1_SPCR, 0);
4930 }
4931
4932 static int cs_hardware_init(struct cs_card *card)
4933 {
4934         unsigned long end_time;
4935         unsigned int tmp,count;
4936
4937         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4938                 "cs46xx: cs_hardware_init()+\n") );
4939         /*
4940          *  First, blast the clock control register to zero so that the PLL starts
4941          *  out in a known state, and blast the master serial port control register
4942          *  to zero so that the serial ports also start out in a known state.
4943          */
4944         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4945         cs461x_pokeBA0(card, BA0_SERMC1, 0);
4946
4947         /*
4948          *  If we are in AC97 mode, then we must set the part to a host controlled
4949          *  AC-link.  Otherwise, we won't be able to bring up the link.
4950          */
4951         cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03);  /* 1.03 card */
4952         /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4953
4954         /*
4955          *  Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4956          *  spec) and then drive it high.  This is done for non AC97 modes since
4957          *  there might be logic external to the CS461x that uses the ARST# line
4958          *  for a reset.
4959          */
4960         cs461x_pokeBA0(card, BA0_ACCTL, 1);
4961         udelay(50);
4962         cs461x_pokeBA0(card, BA0_ACCTL, 0);
4963         udelay(50);
4964         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4965
4966         /*
4967          *  The first thing we do here is to enable sync generation.  As soon
4968          *  as we start receiving bit clock, we'll start producing the SYNC
4969          *  signal.
4970          */
4971         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4972
4973         /*
4974          *  Now wait for a short while to allow the AC97 part to start
4975          *  generating bit clock (so we don't try to start the PLL without an
4976          *  input clock).
4977          */
4978         mdelay(5 * cs_laptop_wait);             /* 1 should be enough ?? (and pigs might fly) */
4979
4980         /*
4981          *  Set the serial port timing configuration, so that
4982          *  the clock control circuit gets its clock from the correct place.
4983          */
4984         cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4985
4986         /*
4987         * The part seems to not be ready for a while after a resume.
4988         * so, if we are resuming, then wait for 700 mils.  Note that 600 mils
4989         * is not enough for some platforms! tested on an IBM Thinkpads and
4990         * reference cards.
4991         */
4992         if(!(card->pm.flags & CS46XX_PM_IDLE))
4993                 mdelay(initdelay);
4994         /*
4995          *  Write the selected clock control setup to the hardware.  Do not turn on
4996          *  SWCE yet (if requested), so that the devices clocked by the output of
4997          *  PLL are not clocked until the PLL is stable.
4998          */
4999         cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
5000         cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
5001         cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
5002
5003         /*
5004          *  Power up the PLL.
5005          */
5006         cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
5007
5008         /*
5009          *  Wait until the PLL has stabilized.
5010          */
5011         mdelay(5 * cs_laptop_wait);             /* Again 1 should be enough ?? */
5012
5013         /*
5014          *  Turn on clocking of the core so that we can setup the serial ports.
5015          */
5016         tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
5017         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5018
5019         /*
5020          *  Fill the serial port FIFOs with silence.
5021          */
5022         cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
5023
5024         /*
5025          *  Set the serial port FIFO pointer to the first sample in the FIFO.
5026          */
5027         /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
5028
5029         /*
5030          *  Write the serial port configuration to the part.  The master
5031          *  enable bit is not set until all other values have been written.
5032          */
5033         cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
5034         cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
5035         cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
5036
5037
5038         mdelay(5 * cs_laptop_wait);             /* Shouldnt be needed ?? */
5039
5040 /*
5041 * If we are resuming under 2.2.x then we can not schedule a timeout.
5042 * so, just spin the CPU.
5043 */
5044         if(card->pm.flags & CS46XX_PM_IDLE)
5045         {
5046         /*
5047          * Wait for the card ready signal from the AC97 card.
5048          */
5049                 end_time = jiffies + 3 * (HZ >> 2);
5050                 do {
5051                 /*
5052                  *  Read the AC97 status register to see if we've seen a CODEC READY
5053                  *  signal from the AC97 card.
5054                  */
5055                         if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5056                                 break;
5057                         current->state = TASK_UNINTERRUPTIBLE;
5058                         schedule_timeout(1);
5059                 } while (time_before(jiffies, end_time));
5060         }
5061         else
5062         {
5063                 for (count = 0; count < 100; count++) {
5064                 // First, we want to wait for a short time.
5065                         udelay(25 * cs_laptop_wait);
5066
5067                         if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5068                                 break;
5069                 }
5070         }
5071
5072         /*
5073          *  Make sure CODEC is READY.
5074          */
5075         if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
5076                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5077                         "cs46xx: create - never read card ready from AC'97\n"));
5078                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5079                         "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
5080                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5081                         "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
5082                 return -EIO;
5083         }
5084
5085         /*
5086          *  Assert the vaid frame signal so that we can start sending commands
5087          *  to the AC97 card.
5088          */
5089         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
5090
5091         if(card->pm.flags & CS46XX_PM_IDLE)
5092         {
5093         /*
5094          *  Wait until we've sampled input slots 3 and 4 as valid, meaning that
5095          *  the card is pumping ADC data across the AC-link.
5096          */
5097                 end_time = jiffies + 3 * (HZ >> 2);
5098                 do {
5099                         /*
5100                          *  Read the input slot valid register and see if input slots 3 and
5101                          *  4 are valid yet.
5102                          */
5103                         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5104                                 break;
5105                         current->state = TASK_UNINTERRUPTIBLE;
5106                         schedule_timeout(1);
5107                 } while (time_before(jiffies, end_time));
5108         }
5109         else
5110         {
5111                 for (count = 0; count < 100; count++) {
5112                 // First, we want to wait for a short time.
5113                         udelay(25 * cs_laptop_wait);
5114
5115                         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5116                                 break;
5117                 }
5118         }
5119         /*
5120          *  Make sure input slots 3 and 4 are valid.  If not, then return
5121          *  an error.
5122          */
5123         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
5124                 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
5125                 return -EIO;
5126         }
5127
5128         /*
5129          *  Now, assert valid frame and the slot 3 and 4 valid bits.  This will
5130          *  commense the transfer of digital audio data to the AC97 card.
5131          */
5132         cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
5133
5134         /*
5135          *  Turn off the Processor by turning off the software clock enable flag in
5136          *  the clock control register.
5137          */
5138         /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
5139         /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
5140
5141         /*
5142          *  Reset the processor.
5143          */
5144         cs461x_reset(card);
5145
5146         /*
5147          *  Download the image to the processor.
5148          */
5149
5150         cs461x_download_image(card);
5151
5152         /*
5153          *  Stop playback DMA.
5154          */
5155         tmp = cs461x_peek(card, BA1_PCTL);
5156         card->pctl = tmp & 0xffff0000;
5157         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5158
5159         /*
5160          *  Stop capture DMA.
5161          */
5162         tmp = cs461x_peek(card, BA1_CCTL);
5163         card->cctl = tmp & 0x0000ffff;
5164         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5165
5166         /* initialize AC97 codec and register /dev/mixer */
5167         if(card->pm.flags & CS46XX_PM_IDLE)
5168         {
5169                 if (cs_ac97_init(card) <= 0)
5170                 {
5171                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5172                                 "cs46xx: cs_ac97_init() failure\n") );
5173                         return -EIO;
5174                 }
5175         }
5176         else
5177         {
5178                 cs46xx_ac97_resume(card);
5179         }
5180
5181         cs461x_proc_start(card);
5182
5183         /*
5184          *  Enable interrupts on the part.
5185          */
5186         cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
5187
5188         tmp = cs461x_peek(card, BA1_PFIE);
5189         tmp &= ~0x0000f03f;
5190         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt enable */
5191
5192         tmp = cs461x_peek(card, BA1_CIE);
5193         tmp &= ~0x0000003f;
5194         tmp |=  0x00000001;
5195         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt enable */
5196
5197         /*
5198          *  If IDLE then Power down the part.  We will power components up
5199          *  when we need them.
5200          */
5201         if(card->pm.flags & CS46XX_PM_IDLE)
5202         {
5203                 if(!cs_powerdown)
5204                 {
5205                         if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
5206                                         CS_POWER_MIXVON )) )
5207                         {
5208                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5209                                         "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
5210                                 return -EIO;
5211                         }
5212                 }
5213                 else
5214                 {
5215                         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5216                                         CS_POWER_MIXVON, CS_FALSE )) )
5217                         {
5218                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5219                                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5220                                 return -EIO;
5221                         }
5222                 }
5223         }
5224         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
5225                 "cs46xx: cs_hardware_init()- 0\n"));
5226         return 0;
5227 }
5228
5229 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
5230    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
5231
5232 /*
5233  *      Card subid table
5234  */
5235
5236 struct cs_card_type
5237 {
5238         u16 vendor;
5239         u16 id;
5240         char *name;
5241         void (*amp)(struct cs_card *, int);
5242         void (*amp_init)(struct cs_card *);
5243         void (*active)(struct cs_card *, int);
5244 };
5245
5246 static struct cs_card_type cards[] = {
5247         {
5248                 .vendor = 0x1489,
5249                 .id     = 0x7001,
5250                 .name   = "Genius Soundmaker 128 value",
5251                 .amp    = amp_none,
5252         },
5253         {
5254                 .vendor = 0x5053,
5255                 .id     = 0x3357,
5256                 .name   = "Voyetra",
5257                 .amp    = amp_voyetra,
5258         },
5259         {
5260                 .vendor = 0x1071,
5261                 .id     = 0x6003,
5262                 .name   = "Mitac MI6020/21",
5263                 .amp    = amp_voyetra,
5264         },
5265         {
5266                 .vendor = 0x14AF,
5267                 .id     = 0x0050,
5268                 .name   = "Hercules Game Theatre XP",
5269                 .amp    = amp_hercules,
5270         },
5271         {
5272                 .vendor = 0x1681,
5273                 .id     = 0x0050,
5274                 .name   = "Hercules Game Theatre XP",
5275                 .amp    = amp_hercules,
5276         },
5277         {
5278                 .vendor = 0x1681,
5279                 .id     = 0x0051,
5280                 .name   = "Hercules Game Theatre XP",
5281                 .amp    = amp_hercules,
5282         },
5283         {
5284                 .vendor = 0x1681,
5285                 .id     = 0x0052,
5286                 .name   = "Hercules Game Theatre XP",
5287                 .amp    = amp_hercules,
5288         },
5289         {
5290                 .vendor = 0x1681,
5291                 .id     = 0x0053,
5292                 .name   = "Hercules Game Theatre XP",
5293                 .amp    = amp_hercules,
5294         },
5295         {
5296                 .vendor = 0x1681,
5297                 .id     = 0x0054,
5298                 .name   = "Hercules Game Theatre XP",
5299                 .amp    = amp_hercules,
5300         },
5301         {
5302                 .vendor = 0x1681,
5303                 .id     = 0xa010,
5304                 .name   = "Hercules Fortissimo II",
5305                 .amp    = amp_none,
5306         },
5307         /* Not sure if the 570 needs the clkrun hack */
5308         {
5309                 .vendor = PCI_VENDOR_ID_IBM,
5310                 .id     = 0x0132,
5311                 .name   = "Thinkpad 570",
5312                 .amp    = amp_none,
5313                 .active = clkrun_hack,
5314         },
5315         {
5316                 .vendor = PCI_VENDOR_ID_IBM,
5317                 .id     = 0x0153,
5318                 .name   = "Thinkpad 600X/A20/T20",
5319                 .amp    = amp_none,
5320                 .active = clkrun_hack,
5321         },
5322         {
5323                 .vendor = PCI_VENDOR_ID_IBM,
5324                 .id     = 0x1010,
5325                 .name   = "Thinkpad 600E (unsupported)",
5326         },
5327         {
5328                 .name   = "Card without SSID set",
5329         },
5330         { 0, },
5331 };
5332
5333 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5334 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5335 MODULE_LICENSE("GPL");
5336
5337
5338 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5339 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5340
5341 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5342                                   const struct pci_device_id *pciid)
5343 {
5344         struct pm_dev *pmdev;
5345         int i,j;
5346         u16 ss_card, ss_vendor;
5347         struct cs_card *card;
5348         dma_addr_t dma_mask;
5349         struct cs_card_type *cp = &cards[0];
5350
5351         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5352                   printk(KERN_INFO "cs46xx: probe()+\n"));
5353
5354         dma_mask = 0xffffffff;  /* this enables playback and recording */
5355         if (pci_enable_device(pci_dev)) {
5356                 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5357                          "cs46xx: pci_enable_device() failed\n"));
5358                 return -1;
5359         }
5360         if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5361             !RSRCISMEMORYREGION(pci_dev, 1)) {
5362                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5363                          "cs46xx: probe()- Memory region not assigned\n"));
5364                 return -1;
5365         }
5366         if (pci_dev->irq == 0) {
5367                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5368                          "cs46xx: probe() IRQ not assigned\n"));
5369                 return -1;
5370         }
5371         if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5372                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5373                       "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5374                 return -1;
5375         }
5376         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5377         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5378
5379         if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5380                 printk(KERN_ERR "cs46xx: out of memory\n");
5381                 return -ENOMEM;
5382         }
5383         memset(card, 0, sizeof(*card));
5384         card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5385         card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5386         card->pci_dev = pci_dev;
5387         card->irq = pci_dev->irq;
5388         card->magic = CS_CARD_MAGIC;
5389         spin_lock_init(&card->lock);
5390         spin_lock_init(&card->ac97_lock);
5391
5392         pci_set_master(pci_dev);
5393
5394         printk(cs46xx_banner);
5395         printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5396                card->ba0_addr, card->ba1_addr, card->irq);
5397
5398         card->alloc_pcm_channel = cs_alloc_pcm_channel;
5399         card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5400         card->free_pcm_channel = cs_free_pcm_channel;
5401         card->amplifier_ctrl = amp_none;
5402         card->active_ctrl = amp_none;
5403
5404         while (cp->name)
5405         {
5406                 if(cp->vendor == ss_vendor && cp->id == ss_card)
5407                 {
5408                         card->amplifier_ctrl = cp->amp;
5409                         if(cp->active)
5410                                 card->active_ctrl = cp->active;
5411                         if(cp->amp_init)
5412                                 card->amp_init = cp->amp_init;
5413                         break;
5414                 }
5415                 cp++;
5416         }
5417         if (cp->name==NULL)
5418         {
5419                 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5420                         ss_vendor, ss_card, card->ba0_addr, card->ba1_addr,  card->irq);
5421         }
5422         else
5423         {
5424                 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5425                         cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5426         }
5427
5428         if (card->amplifier_ctrl==NULL)
5429         {
5430                 card->amplifier_ctrl = amp_none;
5431                 card->active_ctrl = clkrun_hack;
5432         }
5433
5434         if (external_amp == 1)
5435         {
5436                 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5437                 card->amplifier_ctrl = amp_voyetra;
5438         }
5439
5440         if (thinkpad == 1)
5441         {
5442                 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5443                 card->active_ctrl = clkrun_hack;
5444         }
5445 /*
5446 * The thinkpads don't work well without runtime updating on their kernel
5447 * delay values (or any laptop with variable CPU speeds really).
5448 * so, just to be safe set the init delay to 2100.  Eliminates
5449 * failures on T21 Thinkpads.  remove this code when the udelay
5450 * and mdelay kernel code is replaced by a pm timer, or the delays
5451 * work well for battery and/or AC power both.
5452 */
5453         if(card->active_ctrl == clkrun_hack)
5454         {
5455                 initdelay = 2100;
5456                 cs_laptop_wait = 5;
5457         }
5458         if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
5459         {
5460 /*
5461 * for some currently unknown reason, powering down the DAC and ADC component
5462 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5463 * codec access problems.  probably the serial clock becomes unsynced.
5464 * added code to sync the chips back up, but only helped about 70% the time.
5465 */
5466                 cs_powerdown = 0;
5467         }
5468         if(powerdown == 0)
5469                 cs_powerdown = 0;
5470         card->active_ctrl(card, 1);
5471
5472         /* claim our iospace and irq */
5473
5474         card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5475         card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5476         card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5477         card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5478         card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5479
5480         CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5481                 "cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
5482         CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5483                 "cs46xx: card->ba1=%p %p %p %p\n",
5484                         card->ba1.name.data0,
5485                         card->ba1.name.data1,
5486                         card->ba1.name.pmem,
5487                         card->ba1.name.reg) );
5488
5489         if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5490                 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5491                 card->ba1.name.reg == 0)
5492                 goto fail2;
5493
5494         if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs46xx", card)) {
5495                 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5496                 goto fail2;
5497         }
5498         /* register /dev/dsp */
5499         if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5500                 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5501                 goto fail;
5502         }
5503
5504         /* register /dev/midi */
5505         if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5506                 printk(KERN_ERR "cs46xx: unable to register midi\n");
5507
5508         card->pm.flags |= CS46XX_PM_IDLE;
5509         for(i=0;i<5;i++)
5510         {
5511                 if (cs_hardware_init(card) != 0)
5512                 {
5513                         CS_DBGOUT(CS_ERROR, 4, printk(
5514                                 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5515                         for (j = 0; j < NR_AC97; j++)
5516                                 if (card->ac97_codec[j] != NULL) {
5517                                         unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5518                                         ac97_release_codec(card->ac97_codec[j]);
5519                                 }
5520                         mdelay(10 * cs_laptop_wait);
5521                         continue;
5522                 }
5523                 break;
5524         }
5525         if(i>=4)
5526         {
5527                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5528                         "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5529                 unregister_sound_dsp(card->dev_audio);
5530                 if(card->dev_midi)
5531                         unregister_sound_midi(card->dev_midi);
5532                 goto fail;
5533         }
5534
5535         init_waitqueue_head(&card->midi.open_wait);
5536         init_MUTEX(&card->midi.open_sem);
5537         init_waitqueue_head(&card->midi.iwait);
5538         init_waitqueue_head(&card->midi.owait);
5539         cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5540         cs461x_pokeBA0(card, BA0_MIDCR, 0);
5541
5542         /*
5543         * Check if we have to init the amplifier, but probably already done
5544         * since the CD logic in the ac97 init code will turn on the ext amp.
5545         */
5546         if(cp->amp_init)
5547                 cp->amp_init(card);
5548         card->active_ctrl(card, -1);
5549
5550         PCI_SET_DRIVER_DATA(pci_dev, card);
5551         PCI_SET_DMA_MASK(pci_dev, dma_mask);
5552         list_add(&card->list, &cs46xx_devs);
5553
5554         pmdev = cs_pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
5555         if (pmdev)
5556         {
5557                 CS_DBGOUT(CS_INIT | CS_PM, 4, printk(KERN_INFO
5558                          "cs46xx: probe() pm_register() succeeded (%p).\n",
5559                                 pmdev));
5560                 pmdev->data = card;
5561         }
5562         else
5563         {
5564                 CS_DBGOUT(CS_INIT | CS_PM | CS_ERROR, 2, printk(KERN_INFO
5565                          "cs46xx: probe() pm_register() failed (%p).\n",
5566                                 pmdev));
5567                 card->pm.flags |= CS46XX_PM_NOT_REGISTERED;
5568         }
5569
5570         CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
5571                 (unsigned)card->pm.flags,card));
5572
5573         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5574                 "cs46xx: probe()- device allocated successfully\n"));
5575         return 0;
5576
5577 fail:
5578         free_irq(card->irq, card);
5579 fail2:
5580         if(card->ba0)
5581                 iounmap(card->ba0);
5582         if(card->ba1.name.data0)
5583                 iounmap(card->ba1.name.data0);
5584         if(card->ba1.name.data1)
5585                 iounmap(card->ba1.name.data1);
5586         if(card->ba1.name.pmem)
5587                 iounmap(card->ba1.name.pmem);
5588         if(card->ba1.name.reg)
5589                 iounmap(card->ba1.name.reg);
5590         kfree(card);
5591         CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5592                 "cs46xx: probe()- no device allocated\n"));
5593         return -ENODEV;
5594 } // probe_cs46xx
5595
5596 // ---------------------------------------------------------------------
5597
5598 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5599 {
5600         struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5601         int i;
5602         unsigned int tmp;
5603
5604         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5605                  "cs46xx: cs46xx_remove()+\n"));
5606
5607         card->active_ctrl(card,1);
5608
5609         tmp = cs461x_peek(card, BA1_PFIE);
5610         tmp &= ~0x0000f03f;
5611         tmp |=  0x00000010;
5612         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt disable */
5613
5614         tmp = cs461x_peek(card, BA1_CIE);
5615         tmp &= ~0x0000003f;
5616         tmp |=  0x00000011;
5617         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt disable */
5618
5619         /*
5620          *  Stop playback DMA.
5621          */
5622         tmp = cs461x_peek(card, BA1_PCTL);
5623         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5624
5625         /*
5626          *  Stop capture DMA.
5627          */
5628         tmp = cs461x_peek(card, BA1_CCTL);
5629         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5630
5631         /*
5632          *  Reset the processor.
5633          */
5634         cs461x_reset(card);
5635
5636         cs461x_proc_stop(card);
5637
5638         /*
5639          *  Power down the DAC and ADC.  We will power them up (if) when we need
5640          *  them.
5641          */
5642         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5643                         CS_POWER_MIXVON, CS_TRUE )) )
5644         {
5645                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5646                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5647         }
5648
5649         /*
5650          *  Power down the PLL.
5651          */
5652         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5653
5654         /*
5655          *  Turn off the Processor by turning off the software clock enable flag in
5656          *  the clock control register.
5657          */
5658         tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5659         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5660
5661         card->active_ctrl(card,-1);
5662
5663         /* free hardware resources */
5664         free_irq(card->irq, card);
5665         iounmap(card->ba0);
5666         iounmap(card->ba1.name.data0);
5667         iounmap(card->ba1.name.data1);
5668         iounmap(card->ba1.name.pmem);
5669         iounmap(card->ba1.name.reg);
5670
5671         /* unregister audio devices */
5672         for (i = 0; i < NR_AC97; i++)
5673                 if (card->ac97_codec[i] != NULL) {
5674                         unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5675                         ac97_release_codec(card->ac97_codec[i]);
5676                 }
5677         unregister_sound_dsp(card->dev_audio);
5678         if(card->dev_midi)
5679                 unregister_sound_midi(card->dev_midi);
5680         list_del(&card->list);
5681         kfree(card);
5682         PCI_SET_DRIVER_DATA(pci_dev,NULL);
5683
5684         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5685                  "cs46xx: cs46xx_remove()-: remove successful\n"));
5686 }
5687
5688 enum {
5689         CS46XX_4610 = 0,
5690         CS46XX_4612,    /* same as 4630 */
5691         CS46XX_4615,    /* same as 4624 */
5692 };
5693
5694 static struct pci_device_id cs46xx_pci_tbl[] = {
5695         {
5696                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5697                 .device      = PCI_DEVICE_ID_CIRRUS_4610,
5698                 .subvendor   = PCI_ANY_ID,
5699                 .subdevice   = PCI_ANY_ID,
5700                 .driver_data = CS46XX_4610,
5701         },
5702         {
5703                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5704                 .device      = PCI_DEVICE_ID_CIRRUS_4612,
5705                 .subvendor   = PCI_ANY_ID,
5706                 .subdevice   = PCI_ANY_ID,
5707                 .driver_data = CS46XX_4612,
5708         },
5709         {
5710                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5711                 .device      = PCI_DEVICE_ID_CIRRUS_4615,
5712                 .subvendor   = PCI_ANY_ID,
5713                 .subdevice   = PCI_ANY_ID,
5714                 .driver_data = CS46XX_4615,
5715         },
5716         { 0, },
5717 };
5718
5719 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5720
5721 struct pci_driver cs46xx_pci_driver = {
5722         .name     = "cs46xx",
5723         .id_table = cs46xx_pci_tbl,
5724         .probe    = cs46xx_probe,
5725         .remove   = __devexit_p(cs46xx_remove),
5726         .suspend  = CS46XX_SUSPEND_TBL,
5727         .resume   = CS46XX_RESUME_TBL,
5728 };
5729
5730 int __init cs46xx_init_module(void)
5731 {
5732         int rtn = 0;
5733         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5734                 "cs46xx: cs46xx_init_module()+ \n"));
5735         rtn = pci_module_init(&cs46xx_pci_driver);
5736
5737         if(rtn == -ENODEV)
5738         {
5739                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5740                         "cs46xx: Unable to detect valid cs46xx device\n"));
5741         }
5742
5743         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5744                   printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5745         return rtn;
5746 }
5747
5748 void __exit cs46xx_cleanup_module(void)
5749 {
5750         pci_unregister_driver(&cs46xx_pci_driver);
5751         cs_pm_unregister_all(cs46xx_pm_callback);
5752         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5753                   printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5754 }
5755
5756 module_init(cs46xx_init_module);
5757 module_exit(cs46xx_cleanup_module);
5758
5759 int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
5760 {
5761         struct cs_card *card;
5762
5763         CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5764                 "cs46xx: cs46xx_pm_callback dev=%p rqst=0x%x card=%p\n",
5765                         dev,(unsigned)rqst,data));
5766         card = (struct cs_card *) dev->data;
5767         if (card) {
5768                 switch(rqst) {
5769                         case PM_SUSPEND:
5770                                 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5771                                         "cs46xx: PM suspend request\n"));
5772                                 if(cs46xx_suspend(card, 0))
5773                                 {
5774                                     CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5775                                         "cs46xx: PM suspend request refused\n"));
5776                                         return 1;
5777                                 }
5778                                 break;
5779                         case PM_RESUME:
5780                                 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5781                                         "cs46xx: PM resume request\n"));
5782                                 if(cs46xx_resume(card))
5783                                 {
5784                                     CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5785                                         "cs46xx: PM resume request refused\n"));
5786                                         return 1;
5787                                 }
5788                                 break;
5789                 }
5790         }
5791
5792         return 0;
5793 }
5794
5795 #if CS46XX_ACPI_SUPPORT
5796 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state)
5797 {
5798         struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5799         CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5800                 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5801         cs46xx_suspend(s, 0);
5802         return 0;
5803 }
5804
5805 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5806 {
5807         struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5808         CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5809                 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
5810         cs46xx_resume(s);
5811         return 0;
5812 }
5813 #endif