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 __iomem *ba0;
 350         union
 351         {
 352                 struct
 353                 {
 354                         u8 __iomem *data0;
 355                         u8 __iomem *data1;
 356                         u8 __iomem *pmem;
 357                         u8 __iomem *reg;
 358                 } name;
 359                 u8 __iomem *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_pfn_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_pfn_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_pfn_range(vma, vma->vm_start,
2456                              virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
2457                              size, vma->vm_page_prot))
2458         {
2459                 ret = -EAGAIN;
2460                 goto out;
2461         }
2462         dmabuf->mapped = 1;
2463
2464         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2465 out:
2466         up(&state->sem);
2467         return ret;
2468 }
2469
2470 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2471 {
2472         struct cs_card *card = (struct cs_card *)file->private_data;
2473         struct cs_state *state;
2474         struct dmabuf *dmabuf=NULL;
2475         unsigned long flags;
2476         audio_buf_info abinfo;
2477         count_info cinfo;
2478         int val, valsave, mapped, ret;
2479         void __user *argp = (void __user *)arg;
2480         int __user *p = argp;
2481
2482         state = (struct cs_state *)card->states[0];
2483         if(state)
2484         {
2485                 dmabuf = &state->dmabuf;
2486                 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2487         }
2488         state = (struct cs_state *)card->states[1];
2489         if(state)
2490         {
2491                 dmabuf = &state->dmabuf;
2492                 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2493         }
2494
2495 #if CSDEBUG
2496         printioctl(cmd);
2497 #endif
2498
2499         switch (cmd)
2500         {
2501         case OSS_GETVERSION:
2502                 return put_user(SOUND_VERSION, p);
2503
2504         case SNDCTL_DSP_RESET:
2505                 /* FIXME: spin_lock ? */
2506                 if (file->f_mode & FMODE_WRITE) {
2507                         state = (struct cs_state *)card->states[1];
2508                         if(state)
2509                         {
2510                                 dmabuf = &state->dmabuf;
2511                                 stop_dac(state);
2512                                 synchronize_irq(card->irq);
2513                                 dmabuf->ready = 0;
2514                                 resync_dma_ptrs(state);
2515                                 dmabuf->swptr = dmabuf->hwptr = 0;
2516                                 dmabuf->count = dmabuf->total_bytes = 0;
2517                                 dmabuf->blocks = 0;
2518                                 dmabuf->SGok = 0;
2519                         }
2520                 }
2521                 if (file->f_mode & FMODE_READ) {
2522                         state = (struct cs_state *)card->states[0];
2523                         if(state)
2524                         {
2525                                 dmabuf = &state->dmabuf;
2526                                 stop_adc(state);
2527                                 synchronize_irq(card->irq);
2528                                 resync_dma_ptrs(state);
2529                                 dmabuf->ready = 0;
2530                                 dmabuf->swptr = dmabuf->hwptr = 0;
2531                                 dmabuf->count = dmabuf->total_bytes = 0;
2532                                 dmabuf->blocks = 0;
2533                                 dmabuf->SGok = 0;
2534                         }
2535                 }
2536                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2537                 return 0;
2538
2539         case SNDCTL_DSP_SYNC:
2540                 if (file->f_mode & FMODE_WRITE)
2541                         return drain_dac(state, file->f_flags & O_NONBLOCK);
2542                 return 0;
2543
2544         case SNDCTL_DSP_SPEED: /* set sample rate */
2545                 if (get_user(val, p))
2546                         return -EFAULT;
2547                 if (val >= 0) {
2548                         if (file->f_mode & FMODE_READ) {
2549                                 state = (struct cs_state *)card->states[0];
2550                                 if(state)
2551                                 {
2552                                         dmabuf = &state->dmabuf;
2553                                         stop_adc(state);
2554                                         dmabuf->ready = 0;
2555                                         dmabuf->SGok = 0;
2556                                         cs_set_adc_rate(state, val);
2557                                         cs_set_divisor(dmabuf);
2558                                 }
2559                         }
2560                         if (file->f_mode & FMODE_WRITE) {
2561                                 state = (struct cs_state *)card->states[1];
2562                                 if(state)
2563                                 {
2564                                         dmabuf = &state->dmabuf;
2565                                         stop_dac(state);
2566                                         dmabuf->ready = 0;
2567                                         dmabuf->SGok = 0;
2568                                         cs_set_dac_rate(state, val);
2569                                         cs_set_divisor(dmabuf);
2570                                 }
2571                         }
2572                         CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2573                             "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2574                                 file->f_mode & FMODE_WRITE ? "DAC" : "",
2575                                 file->f_mode & FMODE_READ ? "ADC" : "",
2576                                 dmabuf->rate ) );
2577                         return put_user(dmabuf->rate, p);
2578                 }
2579                 return put_user(0, p);
2580
2581         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2582                 if (get_user(val, p))
2583                         return -EFAULT;
2584                 if (file->f_mode & FMODE_WRITE) {
2585                         state = (struct cs_state *)card->states[1];
2586                         if(state)
2587                         {
2588                                 dmabuf = &state->dmabuf;
2589                                 stop_dac(state);
2590                                 dmabuf->ready = 0;
2591                                 dmabuf->SGok = 0;
2592                                 if(val)
2593                                         dmabuf->fmt |= CS_FMT_STEREO;
2594                                 else
2595                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2596                                 cs_set_divisor(dmabuf);
2597                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2598                                     "cs46xx: DSP_STEREO() DAC %s\n",
2599                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2600                                         "STEREO":"MONO") );
2601                         }
2602                 }
2603                 if (file->f_mode & FMODE_READ) {
2604                         state = (struct cs_state *)card->states[0];
2605                         if(state)
2606                         {
2607                                 dmabuf = &state->dmabuf;
2608                                 stop_adc(state);
2609                                 dmabuf->ready = 0;
2610                                 dmabuf->SGok = 0;
2611                                 if(val)
2612                                         dmabuf->fmt |= CS_FMT_STEREO;
2613                                 else
2614                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2615                                 cs_set_divisor(dmabuf);
2616                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2617                                     "cs46xx: DSP_STEREO() ADC %s\n",
2618                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2619                                         "STEREO":"MONO") );
2620                         }
2621                 }
2622                 return 0;
2623
2624         case SNDCTL_DSP_GETBLKSIZE:
2625                 if (file->f_mode & FMODE_WRITE) {
2626                         state = (struct cs_state *)card->states[1];
2627                         if(state)
2628                         {
2629                                 dmabuf = &state->dmabuf;
2630                                 if ((val = prog_dmabuf(state)))
2631                                         return val;
2632                                 return put_user(dmabuf->fragsize, p);
2633                         }
2634                 }
2635                 if (file->f_mode & FMODE_READ) {
2636                         state = (struct cs_state *)card->states[0];
2637                         if(state)
2638                         {
2639                                 dmabuf = &state->dmabuf;
2640                                 if ((val = prog_dmabuf(state)))
2641                                         return val;
2642                                 return put_user(dmabuf->fragsize/dmabuf->divisor,
2643                                                 p);
2644                         }
2645                 }
2646                 return put_user(0, p);
2647
2648         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2649                 return put_user(AFMT_S16_LE | AFMT_U8, p);
2650
2651         case SNDCTL_DSP_SETFMT: /* Select sample format */
2652                 if (get_user(val, p))
2653                         return -EFAULT;
2654                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2655                     "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2656                         file->f_mode & FMODE_WRITE ? "DAC" : "",
2657                         file->f_mode & FMODE_READ ? "ADC" : "",
2658                         val == AFMT_S16_LE ? "16Bit Signed" : "",
2659                         val == AFMT_U8 ? "8Bit Unsigned" : "") );
2660                 valsave = val;
2661                 if (val != AFMT_QUERY) {
2662                         if(val==AFMT_S16_LE || val==AFMT_U8)
2663                         {
2664                                 if (file->f_mode & FMODE_WRITE) {
2665                                         state = (struct cs_state *)card->states[1];
2666                                         if(state)
2667                                         {
2668                                                 dmabuf = &state->dmabuf;
2669                                                 stop_dac(state);
2670                                                 dmabuf->ready = 0;
2671                                                 dmabuf->SGok = 0;
2672                                                 if(val==AFMT_S16_LE)
2673                                                         dmabuf->fmt |= CS_FMT_16BIT;
2674                                                 else
2675                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2676                                                 cs_set_divisor(dmabuf);
2677                                                 if((ret = prog_dmabuf(state)))
2678                                                         return ret;
2679                                         }
2680                                 }
2681                                 if (file->f_mode & FMODE_READ) {
2682                                         val = valsave;
2683                                         state = (struct cs_state *)card->states[0];
2684                                         if(state)
2685                                         {
2686                                                 dmabuf = &state->dmabuf;
2687                                                 stop_adc(state);
2688                                                 dmabuf->ready = 0;
2689                                                 dmabuf->SGok = 0;
2690                                                 if(val==AFMT_S16_LE)
2691                                                         dmabuf->fmt |= CS_FMT_16BIT;
2692                                                 else
2693                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2694                                                 cs_set_divisor(dmabuf);
2695                                                 if((ret = prog_dmabuf(state)))
2696                                                         return ret;
2697                                         }
2698                                 }
2699                         }
2700                         else
2701                         {
2702                                 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2703                                     "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2704                                         valsave) );
2705                         }
2706                 }
2707                 else
2708                 {
2709                         if(file->f_mode & FMODE_WRITE)
2710                         {
2711                                 state = (struct cs_state *)card->states[1];
2712                                 if(state)
2713                                         dmabuf = &state->dmabuf;
2714                         }
2715                         else if(file->f_mode & FMODE_READ)
2716                         {
2717                                 state = (struct cs_state *)card->states[0];
2718                                 if(state)
2719                                         dmabuf = &state->dmabuf;
2720                         }
2721                 }
2722                 if(dmabuf)
2723                 {
2724                         if(dmabuf->fmt & CS_FMT_16BIT)
2725                                 return put_user(AFMT_S16_LE, p);
2726                         else
2727                                 return put_user(AFMT_U8, p);
2728                 }
2729                 return put_user(0, p);
2730
2731         case SNDCTL_DSP_CHANNELS:
2732                 if (get_user(val, p))
2733                         return -EFAULT;
2734                 if (val != 0) {
2735                         if (file->f_mode & FMODE_WRITE) {
2736                                 state = (struct cs_state *)card->states[1];
2737                                 if(state)
2738                                 {
2739                                         dmabuf = &state->dmabuf;
2740                                         stop_dac(state);
2741                                         dmabuf->ready = 0;
2742                                         dmabuf->SGok = 0;
2743                                         if(val>1)
2744                                                 dmabuf->fmt |= CS_FMT_STEREO;
2745                                         else
2746                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2747                                         cs_set_divisor(dmabuf);
2748                                         if (prog_dmabuf(state))
2749                                                 return 0;
2750                                 }
2751                         }
2752                         if (file->f_mode & FMODE_READ) {
2753                                 state = (struct cs_state *)card->states[0];
2754                                 if(state)
2755                                 {
2756                                         dmabuf = &state->dmabuf;
2757                                         stop_adc(state);
2758                                         dmabuf->ready = 0;
2759                                         dmabuf->SGok = 0;
2760                                         if(val>1)
2761                                                 dmabuf->fmt |= CS_FMT_STEREO;
2762                                         else
2763                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2764                                         cs_set_divisor(dmabuf);
2765                                         if (prog_dmabuf(state))
2766                                                 return 0;
2767                                 }
2768                         }
2769                 }
2770                 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2771                                 p);
2772
2773         case SNDCTL_DSP_POST:
2774                 /*
2775                  * There will be a longer than normal pause in the data.
2776                  * so... do nothing, because there is nothing that we can do.
2777                  */
2778                 return 0;
2779
2780         case SNDCTL_DSP_SUBDIVIDE:
2781                 if (file->f_mode & FMODE_WRITE) {
2782                         state = (struct cs_state *)card->states[1];
2783                         if(state)
2784                         {
2785                                 dmabuf = &state->dmabuf;
2786                                 if (dmabuf->subdivision)
2787                                         return -EINVAL;
2788                                 if (get_user(val, p))
2789                                         return -EFAULT;
2790                                 if (val != 1 && val != 2)
2791                                         return -EINVAL;
2792                                 dmabuf->subdivision = val;
2793                         }
2794                 }
2795                 if (file->f_mode & FMODE_READ) {
2796                         state = (struct cs_state *)card->states[0];
2797                         if(state)
2798                         {
2799                                 dmabuf = &state->dmabuf;
2800                                 if (dmabuf->subdivision)
2801                                         return -EINVAL;
2802                                 if (get_user(val, p))
2803                                         return -EFAULT;
2804                                 if (val != 1 && val != 2)
2805                                         return -EINVAL;
2806                                 dmabuf->subdivision = val;
2807                         }
2808                 }
2809                 return 0;
2810
2811         case SNDCTL_DSP_SETFRAGMENT:
2812                 if (get_user(val, p))
2813                         return -EFAULT;
2814
2815                 if (file->f_mode & FMODE_WRITE) {
2816                         state = (struct cs_state *)card->states[1];
2817                         if(state)
2818                         {
2819                                 dmabuf = &state->dmabuf;
2820                                 dmabuf->ossfragshift = val & 0xffff;
2821                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2822                         }
2823                 }
2824                 if (file->f_mode & FMODE_READ) {
2825                         state = (struct cs_state *)card->states[0];
2826                         if(state)
2827                         {
2828                                 dmabuf = &state->dmabuf;
2829                                 dmabuf->ossfragshift = val & 0xffff;
2830                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2831                         }
2832                 }
2833                 return 0;
2834
2835         case SNDCTL_DSP_GETOSPACE:
2836                 if (!(file->f_mode & FMODE_WRITE))
2837                         return -EINVAL;
2838                 state = (struct cs_state *)card->states[1];
2839                 if(state)
2840                 {
2841                         dmabuf = &state->dmabuf;
2842                         spin_lock_irqsave(&state->card->lock, flags);
2843                         cs_update_ptr(card, CS_TRUE);
2844                         abinfo.fragsize = dmabuf->fragsize;
2845                         abinfo.fragstotal = dmabuf->numfrag;
2846                 /*
2847                  * for mmap we always have total space available
2848                  */
2849                         if (dmabuf->mapped)
2850                                 abinfo.bytes = dmabuf->dmasize;
2851                         else
2852                                 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2853
2854                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2855                         spin_unlock_irqrestore(&state->card->lock, flags);
2856                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2857                 }
2858                 return -ENODEV;
2859
2860         case SNDCTL_DSP_GETISPACE:
2861                 if (!(file->f_mode & FMODE_READ))
2862                         return -EINVAL;
2863                 state = (struct cs_state *)card->states[0];
2864                 if(state)
2865                 {
2866                         dmabuf = &state->dmabuf;
2867                         spin_lock_irqsave(&state->card->lock, flags);
2868                         cs_update_ptr(card, CS_TRUE);
2869                         abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2870                         abinfo.bytes = dmabuf->count/dmabuf->divisor;
2871                         abinfo.fragstotal = dmabuf->numfrag;
2872                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2873                         spin_unlock_irqrestore(&state->card->lock, flags);
2874                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2875                 }
2876                 return -ENODEV;
2877
2878         case SNDCTL_DSP_NONBLOCK:
2879                 file->f_flags |= O_NONBLOCK;
2880                 return 0;
2881
2882         case SNDCTL_DSP_GETCAPS:
2883                 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2884                             p);
2885
2886         case SNDCTL_DSP_GETTRIGGER:
2887                 val = 0;
2888                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2889                 if (file->f_mode & FMODE_WRITE)
2890                 {
2891                         state = (struct cs_state *)card->states[1];
2892                         if(state)
2893                         {
2894                                 dmabuf = &state->dmabuf;
2895                                 if(dmabuf->enable & DAC_RUNNING)
2896                                         val |= PCM_ENABLE_INPUT;
2897                         }
2898                 }
2899                 if (file->f_mode & FMODE_READ)
2900                 {
2901                         if(state)
2902                         {
2903                                 state = (struct cs_state *)card->states[0];
2904                                 dmabuf = &state->dmabuf;
2905                                 if(dmabuf->enable & ADC_RUNNING)
2906                                         val |= PCM_ENABLE_OUTPUT;
2907                         }
2908                 }
2909                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2910                 return put_user(val, p);
2911
2912         case SNDCTL_DSP_SETTRIGGER:
2913                 if (get_user(val, p))
2914                         return -EFAULT;
2915                 if (file->f_mode & FMODE_READ) {
2916                         state = (struct cs_state *)card->states[0];
2917                         if(state)
2918                         {
2919                                 dmabuf = &state->dmabuf;
2920                                 if (val & PCM_ENABLE_INPUT) {
2921                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2922                                                 return ret;
2923                                         start_adc(state);
2924                                 } else
2925                                         stop_adc(state);
2926                         }
2927                 }
2928                 if (file->f_mode & FMODE_WRITE) {
2929                         state = (struct cs_state *)card->states[1];
2930                         if(state)
2931                         {
2932                                 dmabuf = &state->dmabuf;
2933                                 if (val & PCM_ENABLE_OUTPUT) {
2934                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2935                                                 return ret;
2936                                         start_dac(state);
2937                                 } else
2938                                         stop_dac(state);
2939                         }
2940                 }
2941                 return 0;
2942
2943         case SNDCTL_DSP_GETIPTR:
2944                 if (!(file->f_mode & FMODE_READ))
2945                         return -EINVAL;
2946                 state = (struct cs_state *)card->states[0];
2947                 if(state)
2948                 {
2949                         dmabuf = &state->dmabuf;
2950                         spin_lock_irqsave(&state->card->lock, flags);
2951                         cs_update_ptr(card, CS_TRUE);
2952                         cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2953                         cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2954                         cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2955                         spin_unlock_irqrestore(&state->card->lock, flags);
2956                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2957                                 return -EFAULT;
2958                         return 0;
2959                 }
2960                 return -ENODEV;
2961
2962         case SNDCTL_DSP_GETOPTR:
2963                 if (!(file->f_mode & FMODE_WRITE))
2964                         return -EINVAL;
2965                 state = (struct cs_state *)card->states[1];
2966                 if(state)
2967                 {
2968                         dmabuf = &state->dmabuf;
2969                         spin_lock_irqsave(&state->card->lock, flags);
2970                         cs_update_ptr(card, CS_TRUE);
2971                         cinfo.bytes = dmabuf->total_bytes;
2972                         if (dmabuf->mapped)
2973                         {
2974                                 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2975                                                         - dmabuf->blocks;
2976                                 CS_DBGOUT(CS_PARMS, 8,
2977                                         printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2978                                         cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2979                                 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2980                         }
2981                         else
2982                         {
2983                                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2984                         }
2985                         cinfo.ptr = dmabuf->hwptr;
2986
2987                         CS_DBGOUT(CS_PARMS, 4, printk(
2988                             "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2989                                 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2990                         spin_unlock_irqrestore(&state->card->lock, flags);
2991                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2992                                 return -EFAULT;
2993                         return 0;
2994                 }
2995                 return -ENODEV;
2996
2997         case SNDCTL_DSP_SETDUPLEX:
2998                 return 0;
2999
3000         case SNDCTL_DSP_GETODELAY:
3001                 if (!(file->f_mode & FMODE_WRITE))
3002                         return -EINVAL;
3003                 state = (struct cs_state *)card->states[1];
3004                 if(state)
3005                 {
3006                         dmabuf = &state->dmabuf;
3007                         spin_lock_irqsave(&state->card->lock, flags);
3008                         cs_update_ptr(card, CS_TRUE);
3009                         val = dmabuf->count;
3010                         spin_unlock_irqrestore(&state->card->lock, flags);
3011                 }
3012                 else
3013                         val = 0;
3014                 return put_user(val, p);
3015
3016         case SOUND_PCM_READ_RATE:
3017                 if(file->f_mode & FMODE_READ)
3018                         state = (struct cs_state *)card->states[0];
3019                 else
3020                         state = (struct cs_state *)card->states[1];
3021                 if(state)
3022                 {
3023                         dmabuf = &state->dmabuf;
3024                         return put_user(dmabuf->rate, p);
3025                 }
3026                 return put_user(0, p);
3027
3028
3029         case SOUND_PCM_READ_CHANNELS:
3030                 if(file->f_mode & FMODE_READ)
3031                         state = (struct cs_state *)card->states[0];
3032                 else
3033                         state = (struct cs_state *)card->states[1];
3034                 if(state)
3035                 {
3036                         dmabuf = &state->dmabuf;
3037                         return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3038                                 p);
3039                 }
3040                 return put_user(0, p);
3041
3042         case SOUND_PCM_READ_BITS:
3043                 if(file->f_mode & FMODE_READ)
3044                         state = (struct cs_state *)card->states[0];
3045                 else
3046                         state = (struct cs_state *)card->states[1];
3047                 if(state)
3048                 {
3049                         dmabuf = &state->dmabuf;
3050                         return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3051                                 AFMT_S16_LE : AFMT_U8, p);
3052
3053                 }
3054                 return put_user(0, p);
3055
3056         case SNDCTL_DSP_MAPINBUF:
3057         case SNDCTL_DSP_MAPOUTBUF:
3058         case SNDCTL_DSP_SETSYNCRO:
3059         case SOUND_PCM_WRITE_FILTER:
3060         case SOUND_PCM_READ_FILTER:
3061                 return -EINVAL;
3062         }
3063         return -EINVAL;
3064 }
3065
3066
3067 /*
3068  *      AMP control - null AMP
3069  */
3070
3071 static void amp_none(struct cs_card *card, int change)
3072 {
3073 }
3074
3075 /*
3076  *      Crystal EAPD mode
3077  */
3078
3079 static void amp_voyetra(struct cs_card *card, int change)
3080 {
3081         /* Manage the EAPD bit on the Crystal 4297
3082            and the Analog AD1885 */
3083
3084         int old=card->amplifier;
3085
3086         card->amplifier+=change;
3087         if(card->amplifier && !old)
3088         {
3089                 /* Turn the EAPD amp on */
3090                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3091                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3092                                 0x8000);
3093         }
3094         else if(old && !card->amplifier)
3095         {
3096                 /* Turn the EAPD amp off */
3097                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3098                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3099                                 ~0x8000);
3100         }
3101 }
3102
3103
3104 /*
3105  *      Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3106  */
3107
3108 static void amp_hercules(struct cs_card *card, int change)
3109 {
3110         int old=card->amplifier;
3111         if(!card)
3112         {
3113                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3114                         "cs46xx: amp_hercules() called before initialized.\n"));
3115                 return;
3116         }
3117         card->amplifier+=change;
3118         if( (card->amplifier && !old) && !(hercules_egpio_disable))
3119         {
3120                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3121                         "cs46xx: amp_hercules() external amp enabled\n"));
3122                 cs461x_pokeBA0(card, BA0_EGPIODR,
3123                         EGPIODR_GPOE2);     /* enable EGPIO2 output */
3124                 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3125                         EGPIOPTR_GPPT2);   /* open-drain on output */
3126         }
3127         else if(old && !card->amplifier)
3128         {
3129                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3130                         "cs46xx: amp_hercules() external amp disabled\n"));
3131                 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3132                 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3133         }
3134 }
3135
3136 /*
3137  *      Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3138  *      whenever we need to beat on the chip.
3139  *
3140  *      The original idea and code for this hack comes from David Kaiser at
3141  *      Linuxcare. Perhaps one day Crystal will document their chips well
3142  *      enough to make them useful.
3143  */
3144
3145 static void clkrun_hack(struct cs_card *card, int change)
3146 {
3147         struct pci_dev *acpi_dev;
3148         u16 control;
3149         u8 pp;
3150         unsigned long port;
3151         int old=card->active;
3152
3153         card->active+=change;
3154
3155         acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3156         if(acpi_dev == NULL)
3157                 return;         /* Not a thinkpad thats for sure */
3158
3159         /* Find the control port */
3160         pci_read_config_byte(acpi_dev, 0x41, &pp);
3161         port=pp<<8;
3162
3163         /* Read ACPI port */
3164         control=inw(port+0x10);
3165
3166         /* Flip CLKRUN off while running */
3167         if(!card->active && old)
3168         {
3169                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3170                         "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3171                                 change,card->active));
3172                 outw(control|0x2000, port+0x10);
3173         }
3174         else
3175         {
3176         /*
3177         * sometimes on a resume the bit is set, so always reset the bit.
3178         */
3179                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3180                         "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3181                                 change,card->active));
3182                 outw(control&~0x2000, port+0x10);
3183         }
3184 }
3185
3186
3187 static int cs_open(struct inode *inode, struct file *file)
3188 {
3189         struct cs_card *card = (struct cs_card *)file->private_data;
3190         struct cs_state *state = NULL;
3191         struct dmabuf *dmabuf = NULL;
3192         struct list_head *entry;
3193         unsigned int minor = iminor(inode);
3194         int ret=0;
3195         unsigned int tmp;
3196
3197         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3198                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3199                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3200
3201         list_for_each(entry, &cs46xx_devs)
3202         {
3203                 card = list_entry(entry, struct cs_card, list);
3204
3205                 if (!((card->dev_audio ^ minor) & ~0xf))
3206                         break;
3207         }
3208         if (entry == &cs46xx_devs)
3209                 return -ENODEV;
3210         if (!card) {
3211                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3212                         "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3213                 return -ENODEV;
3214         }
3215
3216         /*
3217          * hardcode state[0] for capture, [1] for playback
3218          */
3219         if(file->f_mode & FMODE_READ)
3220         {
3221                 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3222                 if (card->states[0] == NULL) {
3223                         state = card->states[0] = (struct cs_state *)
3224                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3225                         if (state == NULL)
3226                                 return -ENOMEM;
3227                         memset(state, 0, sizeof(struct cs_state));
3228                         init_MUTEX(&state->sem);
3229                         dmabuf = &state->dmabuf;
3230                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3231                         if(dmabuf->pbuf==NULL)
3232                         {
3233                                 kfree(state);
3234                                 card->states[0]=NULL;
3235                                 return -ENOMEM;
3236                         }
3237                 }
3238                 else
3239                 {
3240                         state = card->states[0];
3241                         if(state->open_mode & FMODE_READ)
3242                                 return -EBUSY;
3243                 }
3244                 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3245
3246                 if (dmabuf->channel == NULL) {
3247                         kfree (card->states[0]);
3248                         card->states[0] = NULL;
3249                         return -ENODEV;
3250                 }
3251
3252                 /* Now turn on external AMP if needed */
3253                 state->card = card;
3254                 state->card->active_ctrl(state->card,1);
3255                 state->card->amplifier_ctrl(state->card,1);
3256
3257                 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3258                 {
3259                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3260                                 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3261                         return -EIO;
3262                 }
3263
3264                 dmabuf->channel->state = state;
3265                 /* initialize the virtual channel */
3266                 state->virt = 0;
3267                 state->magic = CS_STATE_MAGIC;
3268                 init_waitqueue_head(&dmabuf->wait);
3269                 init_MUTEX(&state->open_sem);
3270                 file->private_data = card;
3271
3272                 down(&state->open_sem);
3273
3274                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3275                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3276                    /dev/dspW will accept 16-bits sample */
3277
3278                 /* Default input is 8bit mono */
3279                 dmabuf->fmt &= ~CS_FMT_MASK;
3280                 dmabuf->type = CS_TYPE_ADC;
3281                 dmabuf->ossfragshift = 0;
3282                 dmabuf->ossmaxfrags  = 0;
3283                 dmabuf->subdivision  = 0;
3284                 cs_set_adc_rate(state, 8000);
3285                 cs_set_divisor(dmabuf);
3286
3287                 state->open_mode |= FMODE_READ;
3288                 up(&state->open_sem);
3289         }
3290         if(file->f_mode & FMODE_WRITE)
3291         {
3292                 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3293                 if (card->states[1] == NULL) {
3294                         state = card->states[1] = (struct cs_state *)
3295                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3296                         if (state == NULL)
3297                                 return -ENOMEM;
3298                         memset(state, 0, sizeof(struct cs_state));
3299                         init_MUTEX(&state->sem);
3300                         dmabuf = &state->dmabuf;
3301                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3302                         if(dmabuf->pbuf==NULL)
3303                         {
3304                                 kfree(state);
3305                                 card->states[1]=NULL;
3306                                 return -ENOMEM;
3307                         }
3308                 }
3309                 else
3310                 {
3311                         state = card->states[1];
3312                         if(state->open_mode & FMODE_WRITE)
3313                                 return -EBUSY;
3314                 }
3315                 dmabuf->channel = card->alloc_pcm_channel(card);
3316
3317                 if (dmabuf->channel == NULL) {
3318                         kfree (card->states[1]);
3319                         card->states[1] = NULL;
3320                         return -ENODEV;
3321                 }
3322
3323                 /* Now turn on external AMP if needed */
3324                 state->card = card;
3325                 state->card->active_ctrl(state->card,1);
3326                 state->card->amplifier_ctrl(state->card,1);
3327
3328                 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3329                 {
3330                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3331                                 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3332                         return -EIO;
3333                 }
3334
3335                 dmabuf->channel->state = state;
3336                 /* initialize the virtual channel */
3337                 state->virt = 1;
3338                 state->magic = CS_STATE_MAGIC;
3339                 init_waitqueue_head(&dmabuf->wait);
3340                 init_MUTEX(&state->open_sem);
3341                 file->private_data = card;
3342
3343                 down(&state->open_sem);
3344
3345                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3346                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3347                    /dev/dspW will accept 16-bits sample */
3348
3349                 /* Default output is 8bit mono. */
3350                 dmabuf->fmt &= ~CS_FMT_MASK;
3351                 dmabuf->type = CS_TYPE_DAC;
3352                 dmabuf->ossfragshift = 0;
3353                 dmabuf->ossmaxfrags  = 0;
3354                 dmabuf->subdivision  = 0;
3355                 cs_set_dac_rate(state, 8000);
3356                 cs_set_divisor(dmabuf);
3357
3358                 state->open_mode |= FMODE_WRITE;
3359                 up(&state->open_sem);
3360                 if((ret = prog_dmabuf(state)))
3361                         return ret;
3362         }
3363         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3364         return nonseekable_open(inode, file);
3365 }
3366
3367 static int cs_release(struct inode *inode, struct file *file)
3368 {
3369         struct cs_card *card = (struct cs_card *)file->private_data;
3370         struct dmabuf *dmabuf;
3371         struct cs_state *state;
3372         unsigned int tmp;
3373         CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3374                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3375                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3376
3377         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3378         {
3379                 return -EINVAL;
3380         }
3381         state = card->states[1];
3382         if(state)
3383         {
3384                 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3385                 {
3386                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3387                         dmabuf = &state->dmabuf;
3388                         cs_clear_tail(state);
3389                         drain_dac(state, file->f_flags & O_NONBLOCK);
3390                         /* stop DMA state machine and free DMA buffers/channels */
3391                         down(&state->open_sem);
3392                         stop_dac(state);
3393                         dealloc_dmabuf(state);
3394                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3395                         free_page((unsigned long)state->dmabuf.pbuf);
3396
3397                         /* we're covered by the open_sem */
3398                         up(&state->open_sem);
3399                         state->card->states[state->virt] = NULL;
3400                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3401
3402                         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3403                         {
3404                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3405                                         "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3406                         }
3407
3408                         /* Now turn off external AMP if needed */
3409                         state->card->amplifier_ctrl(state->card, -1);
3410                         state->card->active_ctrl(state->card, -1);
3411
3412                         kfree(state);
3413                 }
3414         }
3415
3416         state = card->states[0];
3417         if(state)
3418         {
3419                 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3420                 {
3421                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3422                         dmabuf = &state->dmabuf;
3423                         down(&state->open_sem);
3424                         stop_adc(state);
3425                         dealloc_dmabuf(state);
3426                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3427                         free_page((unsigned long)state->dmabuf.pbuf);
3428
3429                         /* we're covered by the open_sem */
3430                         up(&state->open_sem);
3431                         state->card->states[state->virt] = NULL;
3432                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3433
3434                         if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3435                         {
3436                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3437                                         "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3438                         }
3439
3440                         /* Now turn off external AMP if needed */
3441                         state->card->amplifier_ctrl(state->card, -1);
3442                         state->card->active_ctrl(state->card, -1);
3443
3444                         kfree(state);
3445                 }
3446         }
3447
3448         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3449         return 0;
3450 }
3451
3452 static void printpm(struct cs_card *s)
3453 {
3454         CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3455         CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3456                 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3457         CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3458                 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3459         CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3460                 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3461         CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3462                 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3463         CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3464                 s->pm.u32SSCR,s->pm.u32SRCSA));
3465         CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3466                 s->pm.u32DacASR,s->pm.u32AdcASR));
3467         CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3468                 s->pm.u32DacSR,s->pm.u32AdcSR));
3469         CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3470                 s->pm.u32MIDCR_Save));
3471         CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3472                 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3473         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3474                 s->pm.u32AC97_master_volume));
3475         CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3476                 s->pm.u32AC97_headphone_volume));
3477         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3478                 s->pm.u32AC97_master_volume_mono));
3479         CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3480                 s->pm.u32AC97_pcm_out_volume));
3481         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3482                 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3483         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3484                 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3485
3486 }
3487
3488 /****************************************************************************
3489 *
3490 *  Suspend - save the ac97 regs, mute the outputs and power down the part.
3491 *
3492 ****************************************************************************/
3493 void cs46xx_ac97_suspend(struct cs_card *card)
3494 {
3495         int Count,i;
3496         struct ac97_codec *dev=card->ac97_codec[0];
3497         unsigned int tmp;
3498
3499         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3500
3501         if(card->states[1])
3502         {
3503                 stop_dac(card->states[1]);
3504                 resync_dma_ptrs(card->states[1]);
3505         }
3506         if(card->states[0])
3507         {
3508                 stop_adc(card->states[0]);
3509                 resync_dma_ptrs(card->states[0]);
3510         }
3511
3512         for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3513                         && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3514                 Count += 2, i++)
3515         {
3516                 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3517         }
3518 /*
3519 * Save the ac97 volume registers as well as the current powerdown state.
3520 * Now, mute the all the outputs (master, headphone, and mono), as well
3521 * as the PCM volume, in preparation for powering down the entire part.
3522         card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3523                         (u8)BA0_AC97_MASTER_VOLUME);
3524         card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3525                         (u8)BA0_AC97_HEADPHONE_VOLUME);
3526         card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3527                         (u8)BA0_AC97_MASTER_VOLUME_MONO);
3528         card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3529                         (u8)BA0_AC97_PCM_OUT_VOLUME);
3530 */
3531 /*
3532 * mute the outputs
3533 */
3534         cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3535         cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3536         cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3537         cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3538
3539 /*
3540 * save the registers that cause pops
3541 */
3542         card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3543         card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3544 /*
3545 * And power down everything on the AC97 codec.
3546 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3547 * trouble with removing VREF.
3548 */
3549         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3550                         CS_POWER_MIXVON, CS_TRUE )) )
3551         {
3552                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3553                         "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3554         }
3555
3556         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3557 }
3558
3559 /****************************************************************************
3560 *
3561 *  Resume - power up the part and restore its registers..
3562 *
3563 ****************************************************************************/
3564 void cs46xx_ac97_resume(struct cs_card *card)
3565 {
3566         int Count,i;
3567         struct ac97_codec *dev=card->ac97_codec[0];
3568
3569         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3570
3571 /*
3572 * First, we restore the state of the general purpose register.  This
3573 * contains the mic select (mic1 or mic2) and if we restore this after
3574 * we restore the mic volume/boost state and mic2 was selected at
3575 * suspend time, we will end up with a brief period of time where mic1
3576 * is selected with the volume/boost settings for mic2, causing
3577 * acoustic feedback.  So we restore the general purpose register
3578 * first, thereby getting the correct mic selected before we restore
3579 * the mic volume/boost.
3580 */
3581         cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3582                 (u16)card->pm.u32AC97_general_purpose);
3583 /*
3584 * Now, while the outputs are still muted, restore the state of power
3585 * on the AC97 part.
3586 */
3587         cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3588         mdelay(5 * cs_laptop_wait);
3589 /*
3590 * Restore just the first set of registers, from register number
3591 * 0x02 to the register number that ulHighestRegToRestore specifies.
3592 */
3593         for(    Count = 0x2, i=0;
3594                 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3595                         && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3596                 Count += 2, i++)
3597         {
3598                 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3599         }
3600
3601         /* Check if we have to init the amplifier */
3602         if(card->amp_init)
3603                 card->amp_init(card);
3604
3605         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3606 }
3607
3608
3609 static int cs46xx_restart_part(struct cs_card *card)
3610 {
3611         struct dmabuf *dmabuf;
3612         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3613                 printk( "cs46xx: cs46xx_restart_part()+\n"));
3614         if(card->states[1])
3615         {
3616                 dmabuf = &card->states[1]->dmabuf;
3617                 dmabuf->ready = 0;
3618                 resync_dma_ptrs(card->states[1]);
3619                 cs_set_divisor(dmabuf);
3620                 if(__prog_dmabuf(card->states[1]))
3621                 {
3622                         CS_DBGOUT(CS_PM | CS_ERROR, 1,
3623                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3624                         return -1;
3625                 }
3626                 cs_set_dac_rate(card->states[1], dmabuf->rate);
3627         }
3628         if(card->states[0])
3629         {
3630                 dmabuf = &card->states[0]->dmabuf;
3631                 dmabuf->ready = 0;
3632                 resync_dma_ptrs(card->states[0]);
3633                 cs_set_divisor(dmabuf);
3634                 if(__prog_dmabuf(card->states[0]))
3635                 {
3636                         CS_DBGOUT(CS_PM | CS_ERROR, 1,
3637                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3638                         return -1;
3639                 }
3640                 cs_set_adc_rate(card->states[0], dmabuf->rate);
3641         }
3642         card->pm.flags |= CS46XX_PM_RESUMED;
3643         if(card->states[0])
3644                 start_adc(card->states[0]);
3645         if(card->states[1])
3646                 start_dac(card->states[1]);
3647
3648         card->pm.flags |= CS46XX_PM_IDLE;
3649         card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3650                         | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3651         if(card->states[0])
3652                 wake_up(&card->states[0]->dmabuf.wait);
3653         if(card->states[1])
3654                 wake_up(&card->states[1]->dmabuf.wait);
3655
3656         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3657                 printk( "cs46xx: cs46xx_restart_part()-\n"));
3658         return 0;
3659 }
3660
3661
3662 static void cs461x_reset(struct cs_card *card);
3663 static void cs461x_proc_stop(struct cs_card *card);
3664 static int cs46xx_suspend(struct cs_card *card, u32 state)
3665 {
3666         unsigned int tmp;
3667         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3668                 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
3669                         (unsigned)card->pm.flags,card));
3670 /*
3671 * check the current state, only suspend if IDLE
3672 */
3673         if(!(card->pm.flags & CS46XX_PM_IDLE))
3674         {
3675                 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3676                         printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3677                 return 1;
3678         }
3679         card->pm.flags &= ~CS46XX_PM_IDLE;
3680         card->pm.flags |= CS46XX_PM_SUSPENDING;
3681
3682         card->active_ctrl(card,1);
3683
3684         tmp = cs461x_peek(card, BA1_PFIE);
3685         tmp &= ~0x0000f03f;
3686         tmp |=  0x00000010;
3687         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt disable */
3688
3689         tmp = cs461x_peek(card, BA1_CIE);
3690         tmp &= ~0x0000003f;
3691         tmp |=  0x00000011;
3692         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt disable */
3693
3694         /*
3695          *  Stop playback DMA.
3696          */
3697         tmp = cs461x_peek(card, BA1_PCTL);
3698         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3699
3700         /*
3701          *  Stop capture DMA.
3702          */
3703         tmp = cs461x_peek(card, BA1_CCTL);
3704         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3705
3706         if(card->states[1])
3707         {
3708                 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3709                 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3710         }
3711         if(card->states[0])
3712         {
3713                 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3714                 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3715         }
3716
3717         cs46xx_ac97_suspend(card);
3718
3719         /*
3720          *  Reset the processor.
3721          */
3722         cs461x_reset(card);
3723
3724         cs461x_proc_stop(card);
3725
3726         /*
3727          *  Power down the DAC and ADC.  For now leave the other areas on.
3728          */
3729         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3730
3731         /*
3732          *  Power down the PLL.
3733          */
3734         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3735
3736         /*
3737          *  Turn off the Processor by turning off the software clock enable flag in
3738          *  the clock control register.
3739          */
3740         tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3741         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3742
3743         card->active_ctrl(card,-1);
3744
3745         card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3746         card->pm.flags |= CS46XX_PM_SUSPENDED;
3747
3748         printpm(card);
3749
3750         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3751                 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3752                         (unsigned)card->pm.flags));
3753         return 0;
3754 }
3755
3756 static int cs46xx_resume(struct cs_card *card)
3757 {
3758         int i;
3759
3760         CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3761                 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3762                         (unsigned)card->pm.flags));
3763         if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
3764         {
3765                 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3766                         printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3767                 return 1;
3768         }
3769         card->pm.flags |= CS46XX_PM_RESUMING;
3770         card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3771         printpm(card);
3772         card->active_ctrl(card, 1);
3773
3774         for(i=0;i<5;i++)
3775         {
3776                 if (cs_hardware_init(card) != 0)
3777                 {
3778                         CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3779                                 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3780                         mdelay(10 * cs_laptop_wait);
3781                         cs461x_reset(card);
3782                         continue;
3783                 }
3784                 break;
3785         }
3786         if(i>=4)
3787         {
3788                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3789                         "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3790                 return 0;
3791         }
3792
3793         if(cs46xx_restart_part(card))
3794         {
3795                 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3796                         "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3797         }
3798
3799         card->active_ctrl(card, -1);
3800
3801         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3802                 (unsigned)card->pm.flags));
3803         return 0;
3804 }
3805
3806 static /*const*/ struct file_operations cs461x_fops = {
3807         CS_OWNER        CS_THIS_MODULE
3808         .llseek         = no_llseek,
3809         .read           = cs_read,
3810         .write          = cs_write,
3811         .poll           = cs_poll,
3812         .ioctl          = cs_ioctl,
3813         .mmap           = cs_mmap,
3814         .open           = cs_open,
3815         .release        = cs_release,
3816 };
3817
3818 /* Write AC97 codec registers */
3819
3820
3821 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3822 {
3823         struct cs_card *card = dev->private_data;
3824         int count,loopcnt;
3825         unsigned int tmp;
3826         u16 ret;
3827
3828         /*
3829          *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3830          *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
3831          *  3. Write ACCTL = Control Register = 460h for initiating the write
3832          *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3833          *  5. if DCV not cleared, break and return error
3834          *  6. Read ACSTS = Status Register = 464h, check VSTS bit
3835          */
3836
3837         cs461x_peekBA0(card, BA0_ACSDA);
3838
3839         /*
3840          *  Setup the AC97 control registers on the CS461x to send the
3841          *  appropriate command to the AC97 to perform the read.
3842          *  ACCAD = Command Address Register = 46Ch
3843          *  ACCDA = Command Data Register = 470h
3844          *  ACCTL = Control Register = 460h
3845          *  set DCV - will clear when process completed
3846          *  set CRW - Read command
3847          *  set VFRM - valid frame enabled
3848          *  set ESYN - ASYNC generation enabled
3849          *  set RSTN - ARST# inactive, AC97 codec not reset
3850          */
3851
3852         cs461x_pokeBA0(card, BA0_ACCAD, reg);
3853         cs461x_pokeBA0(card, BA0_ACCDA, 0);
3854         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3855                                              ACCTL_VFRM | ACCTL_ESYN |
3856                                              ACCTL_RSTN);
3857
3858
3859         /*
3860          *  Wait for the read to occur.
3861          */
3862         if(!(card->pm.flags & CS46XX_PM_IDLE))
3863                 loopcnt = 2000;
3864         else
3865                 loopcnt = 500 * cs_laptop_wait;
3866         loopcnt *= cs_laptop_wait;
3867         for (count = 0; count < loopcnt; count++) {
3868                 /*
3869                  *  First, we want to wait for a short time.
3870                  */
3871                 udelay(10 * cs_laptop_wait);
3872                 /*
3873                  *  Now, check to see if the read has completed.
3874                  *  ACCTL = 460h, DCV should be reset by now and 460h = 17h
3875                  */
3876                 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3877                         break;
3878         }
3879
3880         /*
3881          *  Make sure the read completed.
3882          */
3883         if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3884                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3885                         "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3886                 return 0xffff;
3887         }
3888
3889         /*
3890          *  Wait for the valid status bit to go active.
3891          */
3892
3893         if(!(card->pm.flags & CS46XX_PM_IDLE))
3894                 loopcnt = 2000;
3895         else
3896                 loopcnt = 1000;
3897         loopcnt *= cs_laptop_wait;
3898         for (count = 0; count < loopcnt; count++) {
3899                 /*
3900                  *  Read the AC97 status register.
3901                  *  ACSTS = Status Register = 464h
3902                  *  VSTS - Valid Status
3903                  */
3904                 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3905                         break;
3906                 udelay(10 * cs_laptop_wait);
3907         }
3908
3909         /*
3910          *  Make sure we got valid status.
3911          */
3912         if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3913                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3914                         "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3915                                 reg, tmp));
3916                 return 0xffff;
3917         }
3918
3919         /*
3920          *  Read the data returned from the AC97 register.
3921          *  ACSDA = Status Data Register = 474h
3922          */
3923         CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3924                 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3925                         reg, cs461x_peekBA0(card, BA0_ACSDA),
3926                         cs461x_peekBA0(card, BA0_ACCAD)));
3927         ret = cs461x_peekBA0(card, BA0_ACSDA);
3928         return ret;
3929 }
3930
3931 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3932 {
3933         u16 ret;
3934         struct cs_card *card = dev->private_data;
3935
3936         spin_lock(&card->ac97_lock);
3937         ret = _cs_ac97_get(dev, reg);
3938         spin_unlock(&card->ac97_lock);
3939         return ret;
3940 }
3941
3942 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3943 {
3944         struct cs_card *card = dev->private_data;
3945         int count;
3946         int val2 = 0;
3947
3948         spin_lock(&card->ac97_lock);
3949
3950         if(reg == AC97_CD_VOL)
3951         {
3952                 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3953         }
3954
3955
3956         /*
3957          *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3958          *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
3959          *  3. Write ACCTL = Control Register = 460h for initiating the write
3960          *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3961          *  5. if DCV not cleared, break and return error
3962          */
3963
3964         /*
3965          *  Setup the AC97 control registers on the CS461x to send the
3966          *  appropriate command to the AC97 to perform the read.
3967          *  ACCAD = Command Address Register = 46Ch
3968          *  ACCDA = Command Data Register = 470h
3969          *  ACCTL = Control Register = 460h
3970          *  set DCV - will clear when process completed
3971          *  reset CRW - Write command
3972          *  set VFRM - valid frame enabled
3973          *  set ESYN - ASYNC generation enabled
3974          *  set RSTN - ARST# inactive, AC97 codec not reset
3975          */
3976         cs461x_pokeBA0(card, BA0_ACCAD, reg);
3977         cs461x_pokeBA0(card, BA0_ACCDA, val);
3978         cs461x_peekBA0(card, BA0_ACCTL);
3979         cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3980         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3981                                              ACCTL_ESYN | ACCTL_RSTN);
3982         for (count = 0; count < 1000; count++) {
3983                 /*
3984                  *  First, we want to wait for a short time.
3985                  */
3986                 udelay(10 * cs_laptop_wait);
3987                 /*
3988                  *  Now, check to see if the write has completed.
3989                  *  ACCTL = 460h, DCV should be reset by now and 460h = 07h
3990                  */
3991                 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3992                         break;
3993         }
3994         /*
3995          *  Make sure the write completed.
3996          */
3997         if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
3998         {
3999                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4000                         "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
4001         }
4002
4003         spin_unlock(&card->ac97_lock);
4004
4005         /*
4006          *      Adjust power if the mixer is selected/deselected according
4007          *      to the CD.
4008          *
4009          *      IF the CD is a valid input source (mixer or direct) AND
4010          *              the CD is not muted THEN power is needed
4011          *
4012          *      We do two things. When record select changes the input to
4013          *      add/remove the CD we adjust the power count if the CD is
4014          *      unmuted.
4015          *
4016          *      When the CD mute changes we adjust the power level if the
4017          *      CD was a valid input.
4018          *
4019          *      We also check for CD volume != 0, as the CD mute isn't
4020          *      normally tweaked from userspace.
4021          */
4022
4023         /* CD mute change ? */
4024
4025         if(reg==AC97_CD_VOL)
4026         {
4027                 /* Mute bit change ? */
4028                 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
4029                 {
4030                         /* This is a hack but its cleaner than the alternatives.
4031                            Right now card->ac97_codec[0] might be NULL as we are
4032                            still doing codec setup. This does an early assignment
4033                            to avoid the problem if it occurs */
4034
4035                         if(card->ac97_codec[0]==NULL)
4036                                 card->ac97_codec[0]=dev;
4037
4038                         /* Mute on */
4039                         if(val&0x8000 || val == 0x1f1f)
4040                                 card->amplifier_ctrl(card, -1);
4041                         else /* Mute off power on */
4042                         {
4043                                 if(card->amp_init)
4044                                         card->amp_init(card);
4045                                 card->amplifier_ctrl(card, 1);
4046                         }
4047                 }
4048         }
4049 }
4050
4051
4052 /* OSS /dev/mixer file operation methods */
4053
4054 static int cs_open_mixdev(struct inode *inode, struct file *file)
4055 {
4056         int i=0;
4057         unsigned int minor = iminor(inode);
4058         struct cs_card *card=NULL;
4059         struct list_head *entry;
4060         unsigned int tmp;
4061
4062         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4063                   printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
4064
4065         list_for_each(entry, &cs46xx_devs)
4066         {
4067                 card = list_entry(entry, struct cs_card, list);
4068                 for (i = 0; i < NR_AC97; i++)
4069                         if (card->ac97_codec[i] != NULL &&
4070                             card->ac97_codec[i]->dev_mixer == minor)
4071                                 goto match;
4072         }
4073         if (!card)
4074         {
4075                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4076                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4077                 return -ENODEV;
4078         }
4079  match:
4080         if(!card->ac97_codec[i])
4081                 return -ENODEV;
4082         file->private_data = card->ac97_codec[i];
4083
4084         card->active_ctrl(card,1);
4085         if(!CS_IN_USE(&card->mixer_use_cnt))
4086         {
4087                 if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
4088                 {
4089                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4090                                 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
4091                         return -EIO;
4092                 }
4093         }
4094         card->amplifier_ctrl(card, 1);
4095         CS_INC_USE_COUNT(&card->mixer_use_cnt);
4096         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4097                   printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
4098         return nonseekable_open(inode, file);
4099 }
4100
4101 static int cs_release_mixdev(struct inode *inode, struct file *file)
4102 {
4103         unsigned int minor = iminor(inode);
4104         struct cs_card *card=NULL;
4105         struct list_head *entry;
4106         int i;
4107         unsigned int tmp;
4108
4109         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4110                   printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
4111         list_for_each(entry, &cs46xx_devs)
4112         {
4113                 card = list_entry(entry, struct cs_card, list);
4114                 for (i = 0; i < NR_AC97; i++)
4115                         if (card->ac97_codec[i] != NULL &&
4116                             card->ac97_codec[i]->dev_mixer == minor)
4117                                 goto match;
4118         }
4119         if (!card)
4120         {
4121                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4122                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4123                 return -ENODEV;
4124         }
4125 match:
4126         if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
4127         {
4128                 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4129                           printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
4130                 card->active_ctrl(card, -1);
4131                 card->amplifier_ctrl(card, -1);
4132                 return 0;
4133         }
4134 /*
4135 * ok, no outstanding mixer opens, so powerdown.
4136 */
4137         if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
4138         {
4139                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4140                         "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
4141                 card->active_ctrl(card, -1);
4142                 card->amplifier_ctrl(card, -1);
4143                 return -EIO;
4144         }
4145         card->active_ctrl(card, -1);
4146         card->amplifier_ctrl(card, -1);
4147         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4148                   printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
4149         return 0;
4150 }
4151
4152 void __exit cs46xx_cleanup_module(void);
4153 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4154                                 unsigned long arg)
4155 {
4156         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
4157         struct cs_card *card=NULL;
4158         struct list_head *entry;
4159         unsigned long __user *p = (long __user *)arg;
4160
4161 #if CSDEBUG_INTERFACE
4162         int val;
4163
4164         if(     (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
4165                 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
4166                 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
4167                 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
4168                 (cmd == SOUND_MIXER_CS_APM))
4169         {
4170             switch(cmd)
4171             {
4172
4173                 case SOUND_MIXER_CS_GETDBGMASK:
4174                         return put_user(cs_debugmask, p);
4175
4176                 case SOUND_MIXER_CS_GETDBGLEVEL:
4177                         return put_user(cs_debuglevel, p);
4178
4179                 case SOUND_MIXER_CS_SETDBGMASK:
4180                         if (get_user(val, p))
4181                                 return -EFAULT;
4182                         cs_debugmask = val;
4183                         return 0;
4184
4185                 case SOUND_MIXER_CS_SETDBGLEVEL:
4186                         if (get_user(val, p))
4187                                 return -EFAULT;
4188                         cs_debuglevel = val;
4189                         return 0;
4190
4191                 case SOUND_MIXER_CS_APM:
4192                         if (get_user(val, p))
4193                                 return -EFAULT;
4194                         if(val == CS_IOCTL_CMD_SUSPEND)
4195                         {
4196                                 list_for_each(entry, &cs46xx_devs)
4197                                 {
4198                                         card = list_entry(entry, struct cs_card, list);
4199                                         cs46xx_suspend(card, 0);
4200                                 }
4201
4202                         }
4203                         else if(val == CS_IOCTL_CMD_RESUME)
4204                         {
4205                                 list_for_each(entry, &cs46xx_devs)
4206                                 {
4207                                         card = list_entry(entry, struct cs_card, list);
4208                                         cs46xx_resume(card);
4209                                 }
4210                         }
4211                         else
4212                         {
4213                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4214                                     "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
4215                                         val));
4216                         }
4217                         return 0;
4218
4219                 default:
4220                         CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4221                                 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
4222                         return 0;
4223             }
4224         }
4225 #endif
4226         return codec->mixer_ioctl(codec, cmd, arg);
4227 }
4228
4229 static /*const*/ struct file_operations cs_mixer_fops = {
4230         CS_OWNER        CS_THIS_MODULE
4231         .llseek         = no_llseek,
4232         .ioctl          = cs_ioctl_mixdev,
4233         .open           = cs_open_mixdev,
4234         .release        = cs_release_mixdev,
4235 };
4236
4237 /* AC97 codec initialisation. */
4238 static int __init cs_ac97_init(struct cs_card *card)
4239 {
4240         int num_ac97 = 0;
4241         int ready_2nd = 0;
4242         struct ac97_codec *codec;
4243         u16 eid;
4244
4245         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4246                 "cs46xx: cs_ac97_init()+\n") );
4247
4248         for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4249                 if ((codec = ac97_alloc_codec()) == NULL)
4250                         return -ENOMEM;
4251
4252                 /* initialize some basic codec information, other fields will be filled
4253                    in ac97_probe_codec */
4254                 codec->private_data = card;
4255                 codec->id = num_ac97;
4256
4257                 codec->codec_read = cs_ac97_get;
4258                 codec->codec_write = cs_ac97_set;
4259
4260                 if (ac97_probe_codec(codec) == 0)
4261                 {
4262                         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4263                                 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4264                                         num_ac97) );
4265                         card->ac97_codec[num_ac97] = NULL;
4266                         break;
4267                 }
4268                 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4269                         "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
4270
4271                 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4272
4273                 if(eid==0xFFFF)
4274                 {
4275                         printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4276                         ac97_release_codec(codec);
4277                         break;
4278                 }
4279
4280                 card->ac97_features = eid;
4281
4282                 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4283                         printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4284                         ac97_release_codec(codec);
4285                         break;
4286                 }
4287                 card->ac97_codec[num_ac97] = codec;
4288
4289                 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4290                         "cs46xx: cs_ac97_init() ac97_codec[%d] set to %p\n",
4291                                 (unsigned int)num_ac97,
4292                                 codec));
4293                 /* if there is no secondary codec at all, don't probe any more */
4294                 if (!ready_2nd)
4295                 {
4296                         num_ac97 += 1;
4297                         break;
4298                 }
4299         }
4300         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4301                 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4302         return num_ac97;
4303 }
4304
4305 /*
4306  * load the static image into the DSP
4307  */
4308 #include "cs461x_image.h"
4309 static void cs461x_download_image(struct cs_card *card)
4310 {
4311     unsigned i, j, temp1, temp2, offset, count;
4312     unsigned char __iomem *pBA1 = ioremap(card->ba1_addr, 0x40000);
4313     for( i=0; i < CLEAR__COUNT; i++)
4314     {
4315         offset = ClrStat[i].BA1__DestByteOffset;
4316         count  = ClrStat[i].BA1__SourceSize;
4317         for(  temp1 = offset; temp1<(offset+count); temp1+=4 )
4318               writel(0, pBA1+temp1);
4319     }
4320
4321     for(i=0; i<FILL__COUNT; i++)
4322     {
4323         temp2 = FillStat[i].Offset;
4324         for(j=0; j<(FillStat[i].Size)/4; j++)
4325         {
4326             temp1 = (FillStat[i]).pFill[j];
4327             writel(temp1, pBA1+temp2+j*4);
4328         }
4329     }
4330     iounmap(pBA1);
4331 }
4332
4333
4334 /*
4335  *  Chip reset
4336  */
4337
4338 static void cs461x_reset(struct cs_card *card)
4339 {
4340         int idx;
4341
4342         /*
4343          *  Write the reset bit of the SP control register.
4344          */
4345         cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4346
4347         /*
4348          *  Write the control register.
4349          */
4350         cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4351
4352         /*
4353          *  Clear the trap registers.
4354          */
4355         for (idx = 0; idx < 8; idx++) {
4356                 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4357                 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4358         }
4359         cs461x_poke(card, BA1_DREG, 0);
4360
4361         /*
4362          *  Set the frame timer to reflect the number of cycles per frame.
4363          */
4364         cs461x_poke(card, BA1_FRMT, 0xadf);
4365 }
4366
4367 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4368 {
4369         int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4370         unsigned int tmp;
4371
4372         /*
4373          *  See if the devices are powered down.  If so, we must power them up first
4374          *  or they will not respond.
4375          */
4376         if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4377                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4378                 powerdown1 = 1;
4379         }
4380
4381         /*
4382          *  We want to clear out the serial port FIFOs so we don't end up playing
4383          *  whatever random garbage happens to be in them.  We fill the sample FIFOS
4384          *  with zero (silence).
4385          */
4386         cs461x_pokeBA0(card, BA0_SERBWP, 0);
4387
4388         /*
4389         * Check for which FIFO locations to clear, if we are currently
4390         * playing or capturing then we don't want to put in 128 bytes of
4391         * "noise".
4392          */
4393         if(type & CS_TYPE_DAC)
4394         {
4395                 startfifo = 128;
4396                 endfifo = 256;
4397         }
4398         if(type & CS_TYPE_ADC)
4399         {
4400                 startfifo = 0;
4401                 if(!endfifo)
4402                         endfifo = 128;
4403         }
4404         /*
4405          *  Fill sample FIFO locations (256 locations total).
4406          */
4407         for (idx = startfifo; idx < endfifo; idx++) {
4408                 /*
4409                  *  Make sure the previous FIFO write operation has completed.
4410                  */
4411                 for (loop = 0; loop < 5; loop++) {
4412                         udelay(50);
4413                         if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4414                                 break;
4415                 }
4416                 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4417                         if (powerdown1)
4418                                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4419                 }
4420                 /*
4421                  *  Write the serial port FIFO index.
4422                  */
4423                 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4424                 /*
4425                  *  Tell the serial port to load the new value into the FIFO location.
4426                  */
4427                 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4428         }
4429         /*
4430          *  Now, if we powered up the devices, then power them back down again.
4431          *  This is kinda ugly, but should never happen.
4432          */
4433         if (powerdown1)
4434                 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4435 }
4436
4437
4438 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4439 {
4440         int count;
4441         unsigned int tmp=0,muted=0;
4442
4443         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4444                 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4445         if(!cs_powerdown && !suspendflag)
4446         {
4447                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4448                         "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4449                 return 0;
4450         }
4451         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4452         CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4453                 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4454 /*
4455 * if powering down only the VREF, and not powering down the DAC/ADC,
4456 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4457 * currently powered down.  If powering down DAC and ADC, then
4458 * it is possible to power down the VREF (ON).
4459 */
4460         if (    ((type & CS_POWER_MIXVON) &&
4461                  (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
4462               &&
4463                 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4464                  (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
4465         {
4466                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4467                         "cs46xx: cs461x_powerdown()- 0  unable to powerdown. tmp=0x%x\n",tmp));
4468                 return 0;
4469         }
4470 /*
4471 * for now, always keep power to the mixer block.
4472 * not sure why it's a problem but it seems to be if we power off.
4473 */
4474         type &= ~CS_POWER_MIXVON;
4475         type &= ~CS_POWER_MIXVOFF;
4476
4477         /*
4478          *  Power down indicated areas.
4479          */
4480         if(type & CS_POWER_MIXVOFF)
4481         {
4482
4483                 CS_DBGOUT(CS_FUNCTION, 4,
4484                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4485                 /*
4486                  *  Power down the MIXER (VREF ON) on the AC97 card.
4487                  */
4488                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4489                 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4490                 {
4491                         if(!muted)
4492                         {
4493                                 cs_mute(card, CS_TRUE);
4494                                 muted=1;
4495                         }
4496                         tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4497                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4498                         /*
4499                          *  Now, we wait until we sample a ready state.
4500                          */
4501                         for (count = 0; count < 32; count++) {
4502                                 /*
4503                                  *  First, lets wait a short while to let things settle out a
4504                                  *  bit, and to prevent retrying the read too quickly.
4505                                  */
4506                                 udelay(500);
4507
4508                                 /*
4509                                  *  Read the current state of the power control register.
4510                                  */
4511                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4512                                         CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4513                                         break;
4514                         }
4515
4516                         /*
4517                          *  Check the status..
4518                          */
4519                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4520                                 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4521                         {
4522                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4523                                         "cs46xx: powerdown MIXVOFF failed\n"));
4524                                 return 1;
4525                         }
4526                 }
4527         }
4528         if(type & CS_POWER_MIXVON)
4529         {
4530
4531                 CS_DBGOUT(CS_FUNCTION, 4,
4532                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4533                 /*
4534                  *  Power down the MIXER (VREF ON) on the AC97 card.
4535                  */
4536                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4537                 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
4538                 {
4539                         if(!muted)
4540                         {
4541                                 cs_mute(card, CS_TRUE);
4542                                 muted=1;
4543                         }
4544                         tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4545                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4546                         /*
4547                          *  Now, we wait until we sample a ready state.
4548                          */
4549                         for (count = 0; count < 32; count++) {
4550                                 /*
4551                                  *  First, lets wait a short while to let things settle out a
4552                                  *  bit, and to prevent retrying the read too quickly.
4553                                  */
4554                                 udelay(500);
4555
4556                                 /*
4557                                  *  Read the current state of the power control register.
4558                                  */
4559                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4560                                         CS_AC97_POWER_CONTROL_MIXVON_ON))
4561                                         break;
4562                         }
4563
4564                         /*
4565                          *  Check the status..
4566                          */
4567                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4568                                 CS_AC97_POWER_CONTROL_MIXVON_ON)
4569                         {
4570                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4571                                         "cs46xx: powerdown MIXVON failed\n"));
4572                                 return 1;
4573                         }
4574                 }
4575         }
4576         if(type & CS_POWER_ADC)
4577         {
4578                 /*
4579                  *  Power down the ADC on the AC97 card.
4580                  */
4581                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4582                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4583                 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
4584                 {
4585                         if(!muted)
4586                         {
4587                                 cs_mute(card, CS_TRUE);
4588                                 muted=1;
4589                         }
4590                         tmp |= CS_AC97_POWER_CONTROL_ADC;
4591                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4592
4593                         /*
4594                          *  Now, we wait until we sample a ready state.
4595                          */
4596                         for (count = 0; count < 32; count++) {
4597                                 /*
4598                                  *  First, lets wait a short while to let things settle out a
4599                                  *  bit, and to prevent retrying the read too quickly.
4600                                  */
4601                                 udelay(500);
4602
4603                                 /*
4604                                  *  Read the current state of the power control register.
4605                                  */
4606                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4607                                         CS_AC97_POWER_CONTROL_ADC_ON))
4608                                         break;
4609                         }
4610
4611                         /*
4612                          *  Check the status..
4613                          */
4614                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4615                                 CS_AC97_POWER_CONTROL_ADC_ON)
4616                         {
4617                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4618                                         "cs46xx: powerdown ADC failed\n"));
4619                                 return 1;
4620                         }
4621                 }
4622         }
4623         if(type & CS_POWER_DAC)
4624         {
4625                 /*
4626                  *  Power down the DAC on the AC97 card.
4627                  */
4628
4629                 CS_DBGOUT(CS_FUNCTION, 4,
4630                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4631                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4632                 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
4633                 {
4634                         if(!muted)
4635                         {
4636                                 cs_mute(card, CS_TRUE);
4637                                 muted=1;
4638                         }
4639                         tmp |= CS_AC97_POWER_CONTROL_DAC;
4640                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4641                         /*
4642                          *  Now, we wait until we sample a ready state.
4643                          */
4644                         for (count = 0; count < 32; count++) {
4645                                 /*
4646                                  *  First, lets wait a short while to let things settle out a
4647                                  *  bit, and to prevent retrying the read too quickly.
4648                                  */
4649                                 udelay(500);
4650
4651                                 /*
4652                                  *  Read the current state of the power control register.
4653                                  */
4654                                 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4655                                         CS_AC97_POWER_CONTROL_DAC_ON))
4656                                         break;
4657                         }
4658
4659                         /*
4660                          *  Check the status..
4661                          */
4662                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4663                                 CS_AC97_POWER_CONTROL_DAC_ON)
4664                         {
4665                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4666                                         "cs46xx: powerdown DAC failed\n"));
4667                                 return 1;
4668                         }
4669                 }
4670         }
4671         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4672         if(muted)
4673                 cs_mute(card, CS_FALSE);
4674         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4675                 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4676         return 0;
4677 }
4678
4679 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4680 {
4681         int count;
4682         unsigned int tmp=0,muted=0;
4683
4684         CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4685                 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4686         /*
4687         * check for VREF and powerup if need to.
4688         */
4689         if(type & CS_POWER_MIXVON)
4690                 type |= CS_POWER_MIXVOFF;
4691         if(type & (CS_POWER_DAC | CS_POWER_ADC))
4692                 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4693
4694         /*
4695          *  Power up indicated areas.
4696          */
4697         if(type & CS_POWER_MIXVOFF)
4698         {
4699
4700                 CS_DBGOUT(CS_FUNCTION, 4,
4701                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4702                 /*
4703                  *  Power up the MIXER (VREF ON) on the AC97 card.
4704                  */
4705                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4706                 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4707                 {
4708                         if(!muted)
4709                         {
4710                                 cs_mute(card, CS_TRUE);
4711                                 muted=1;
4712                         }
4713                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4714                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4715                         /*
4716                          *  Now, we wait until we sample a ready state.
4717                          */
4718                         for (count = 0; count < 32; count++) {
4719                                 /*
4720                                  *  First, lets wait a short while to let things settle out a
4721                                  *  bit, and to prevent retrying the read too quickly.
4722                                  */
4723                                 udelay(500);
4724
4725                                 /*
4726                                  *  Read the current state of the power control register.
4727                                  */
4728                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4729                                         CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4730                                         break;
4731                         }
4732
4733                         /*
4734                          *  Check the status..
4735                          */
4736                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4737                                 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4738                         {
4739                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4740                                         "cs46xx: powerup MIXVOFF failed\n"));
4741                                 return 1;
4742                         }
4743                 }
4744         }
4745         if(type & CS_POWER_MIXVON)
4746         {
4747
4748                 CS_DBGOUT(CS_FUNCTION, 4,
4749                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4750                 /*
4751                  *  Power up the MIXER (VREF ON) on the AC97 card.
4752                  */
4753                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4754                 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
4755                 {
4756                         if(!muted)
4757                         {
4758                                 cs_mute(card, CS_TRUE);
4759                                 muted=1;
4760                         }
4761                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4762                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4763                         /*
4764                          *  Now, we wait until we sample a ready state.
4765                          */
4766                         for (count = 0; count < 32; count++) {
4767                                 /*
4768                                  *  First, lets wait a short while to let things settle out a
4769                                  *  bit, and to prevent retrying the read too quickly.
4770                                  */
4771                                 udelay(500);
4772
4773                                 /*
4774                                  *  Read the current state of the power control register.
4775                                  */
4776                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4777                                         CS_AC97_POWER_CONTROL_MIXVON_ON)
4778                                         break;
4779                         }
4780
4781                         /*
4782                          *  Check the status..
4783                          */
4784                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4785                                 CS_AC97_POWER_CONTROL_MIXVON_ON))
4786                         {
4787                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4788                                         "cs46xx: powerup MIXVON failed\n"));
4789                                 return 1;
4790                         }
4791                 }
4792         }
4793         if(type & CS_POWER_ADC)
4794         {
4795                 /*
4796                  *  Power up the ADC on the AC97 card.
4797                  */
4798                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4799                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4800                 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
4801                 {
4802                         if(!muted)
4803                         {
4804                                 cs_mute(card, CS_TRUE);
4805                                 muted=1;
4806                         }
4807                         tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4808                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4809
4810                         /*
4811                          *  Now, we wait until we sample a ready state.
4812                          */
4813                         for (count = 0; count < 32; count++) {
4814                                 /*
4815                                  *  First, lets wait a short while to let things settle out a
4816                                  *  bit, and to prevent retrying the read too quickly.
4817                                  */
4818                                 udelay(500);
4819
4820                                 /*
4821                                  *  Read the current state of the power control register.
4822                                  */
4823                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4824                                         CS_AC97_POWER_CONTROL_ADC_ON)
4825                                         break;
4826                         }
4827
4828                         /*
4829                          *  Check the status..
4830                          */
4831                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4832                                 CS_AC97_POWER_CONTROL_ADC_ON))
4833                         {
4834                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4835                                         "cs46xx: powerup ADC failed\n"));
4836                                 return 1;
4837                         }
4838                 }
4839         }
4840         if(type & CS_POWER_DAC)
4841         {
4842                 /*
4843                  *  Power up the DAC on the AC97 card.
4844                  */
4845
4846                 CS_DBGOUT(CS_FUNCTION, 4,
4847                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4848                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4849                 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
4850                 {
4851                         if(!muted)
4852                         {
4853                                 cs_mute(card, CS_TRUE);
4854                                 muted=1;
4855                         }
4856                         tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4857                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4858                         /*
4859                          *  Now, we wait until we sample a ready state.
4860                          */
4861                         for (count = 0; count < 32; count++) {
4862                                 /*
4863                                  *  First, lets wait a short while to let things settle out a
4864                                  *  bit, and to prevent retrying the read too quickly.
4865                                  */
4866                                 udelay(500);
4867
4868                                 /*
4869                                  *  Read the current state of the power control register.
4870                                  */
4871                                 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4872                                         CS_AC97_POWER_CONTROL_DAC_ON)
4873                                         break;
4874                         }
4875
4876                         /*
4877                          *  Check the status..
4878                          */
4879                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4880                                 CS_AC97_POWER_CONTROL_DAC_ON))
4881                         {
4882                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4883                                         "cs46xx: powerup DAC failed\n"));
4884                                 return 1;
4885                         }
4886                 }
4887         }
4888         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4889         if(muted)
4890                 cs_mute(card, CS_FALSE);
4891         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4892                 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4893         return 0;
4894 }
4895
4896
4897 static void cs461x_proc_start(struct cs_card *card)
4898 {
4899         int cnt;
4900
4901         /*
4902          *  Set the frame timer to reflect the number of cycles per frame.
4903          */
4904         cs461x_poke(card, BA1_FRMT, 0xadf);
4905         /*
4906          *  Turn on the run, run at frame, and DMA enable bits in the local copy of
4907          *  the SP control register.
4908          */
4909         cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4910         /*
4911          *  Wait until the run at frame bit resets itself in the SP control
4912          *  register.
4913          */
4914         for (cnt = 0; cnt < 25; cnt++) {
4915                 udelay(50);
4916                 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4917                         break;
4918         }
4919
4920         if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4921                 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4922 }
4923
4924 static void cs461x_proc_stop(struct cs_card *card)
4925 {
4926         /*
4927          *  Turn off the run, run at frame, and DMA enable bits in the local copy of
4928          *  the SP control register.
4929          */
4930         cs461x_poke(card, BA1_SPCR, 0);
4931 }
4932
4933 static int cs_hardware_init(struct cs_card *card)
4934 {
4935         unsigned long end_time;
4936         unsigned int tmp,count;
4937
4938         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4939                 "cs46xx: cs_hardware_init()+\n") );
4940         /*
4941          *  First, blast the clock control register to zero so that the PLL starts
4942          *  out in a known state, and blast the master serial port control register
4943          *  to zero so that the serial ports also start out in a known state.
4944          */
4945         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4946         cs461x_pokeBA0(card, BA0_SERMC1, 0);
4947
4948         /*
4949          *  If we are in AC97 mode, then we must set the part to a host controlled
4950          *  AC-link.  Otherwise, we won't be able to bring up the link.
4951          */
4952         cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03);  /* 1.03 card */
4953         /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4954
4955         /*
4956          *  Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4957          *  spec) and then drive it high.  This is done for non AC97 modes since
4958          *  there might be logic external to the CS461x that uses the ARST# line
4959          *  for a reset.
4960          */
4961         cs461x_pokeBA0(card, BA0_ACCTL, 1);
4962         udelay(50);
4963         cs461x_pokeBA0(card, BA0_ACCTL, 0);
4964         udelay(50);
4965         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4966
4967         /*
4968          *  The first thing we do here is to enable sync generation.  As soon
4969          *  as we start receiving bit clock, we'll start producing the SYNC
4970          *  signal.
4971          */
4972         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4973
4974         /*
4975          *  Now wait for a short while to allow the AC97 part to start
4976          *  generating bit clock (so we don't try to start the PLL without an
4977          *  input clock).
4978          */
4979         mdelay(5 * cs_laptop_wait);             /* 1 should be enough ?? (and pigs might fly) */
4980
4981         /*
4982          *  Set the serial port timing configuration, so that
4983          *  the clock control circuit gets its clock from the correct place.
4984          */
4985         cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4986
4987         /*
4988         * The part seems to not be ready for a while after a resume.
4989         * so, if we are resuming, then wait for 700 mils.  Note that 600 mils
4990         * is not enough for some platforms! tested on an IBM Thinkpads and
4991         * reference cards.
4992         */
4993         if(!(card->pm.flags & CS46XX_PM_IDLE))
4994                 mdelay(initdelay);
4995         /*
4996          *  Write the selected clock control setup to the hardware.  Do not turn on
4997          *  SWCE yet (if requested), so that the devices clocked by the output of
4998          *  PLL are not clocked until the PLL is stable.
4999          */
5000         cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
5001         cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
5002         cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
5003
5004         /*
5005          *  Power up the PLL.
5006          */
5007         cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
5008
5009         /*
5010          *  Wait until the PLL has stabilized.
5011          */
5012         mdelay(5 * cs_laptop_wait);             /* Again 1 should be enough ?? */
5013
5014         /*
5015          *  Turn on clocking of the core so that we can setup the serial ports.
5016          */
5017         tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
5018         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5019
5020         /*
5021          *  Fill the serial port FIFOs with silence.
5022          */
5023         cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
5024
5025         /*
5026          *  Set the serial port FIFO pointer to the first sample in the FIFO.
5027          */
5028         /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
5029
5030         /*
5031          *  Write the serial port configuration to the part.  The master
5032          *  enable bit is not set until all other values have been written.
5033          */
5034         cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
5035         cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
5036         cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
5037
5038
5039         mdelay(5 * cs_laptop_wait);             /* Shouldnt be needed ?? */
5040
5041 /*
5042 * If we are resuming under 2.2.x then we can not schedule a timeout.
5043 * so, just spin the CPU.
5044 */
5045         if(card->pm.flags & CS46XX_PM_IDLE)
5046         {
5047         /*
5048          * Wait for the card ready signal from the AC97 card.
5049          */
5050                 end_time = jiffies + 3 * (HZ >> 2);
5051                 do {
5052                 /*
5053                  *  Read the AC97 status register to see if we've seen a CODEC READY
5054                  *  signal from the AC97 card.
5055                  */
5056                         if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5057                                 break;
5058                         current->state = TASK_UNINTERRUPTIBLE;
5059                         schedule_timeout(1);
5060                 } while (time_before(jiffies, end_time));
5061         }
5062         else
5063         {
5064                 for (count = 0; count < 100; count++) {
5065                 // First, we want to wait for a short time.
5066                         udelay(25 * cs_laptop_wait);
5067
5068                         if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5069                                 break;
5070                 }
5071         }
5072
5073         /*
5074          *  Make sure CODEC is READY.
5075          */
5076         if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
5077                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5078                         "cs46xx: create - never read card ready from AC'97\n"));
5079                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5080                         "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
5081                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5082                         "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
5083                 return -EIO;
5084         }
5085
5086         /*
5087          *  Assert the vaid frame signal so that we can start sending commands
5088          *  to the AC97 card.
5089          */
5090         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
5091
5092         if(card->pm.flags & CS46XX_PM_IDLE)
5093         {
5094         /*
5095          *  Wait until we've sampled input slots 3 and 4 as valid, meaning that
5096          *  the card is pumping ADC data across the AC-link.
5097          */
5098                 end_time = jiffies + 3 * (HZ >> 2);
5099                 do {
5100                         /*
5101                          *  Read the input slot valid register and see if input slots 3 and
5102                          *  4 are valid yet.
5103                          */
5104                         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5105                                 break;
5106                         current->state = TASK_UNINTERRUPTIBLE;
5107                         schedule_timeout(1);
5108                 } while (time_before(jiffies, end_time));
5109         }
5110         else
5111         {
5112                 for (count = 0; count < 100; count++) {
5113                 // First, we want to wait for a short time.
5114                         udelay(25 * cs_laptop_wait);
5115
5116                         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5117                                 break;
5118                 }
5119         }
5120         /*
5121          *  Make sure input slots 3 and 4 are valid.  If not, then return
5122          *  an error.
5123          */
5124         if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
5125                 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
5126                 return -EIO;
5127         }
5128
5129         /*
5130          *  Now, assert valid frame and the slot 3 and 4 valid bits.  This will
5131          *  commense the transfer of digital audio data to the AC97 card.
5132          */
5133         cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
5134
5135         /*
5136          *  Turn off the Processor by turning off the software clock enable flag in
5137          *  the clock control register.
5138          */
5139         /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
5140         /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
5141
5142         /*
5143          *  Reset the processor.
5144          */
5145         cs461x_reset(card);
5146
5147         /*
5148          *  Download the image to the processor.
5149          */
5150
5151         cs461x_download_image(card);
5152
5153         /*
5154          *  Stop playback DMA.
5155          */
5156         tmp = cs461x_peek(card, BA1_PCTL);
5157         card->pctl = tmp & 0xffff0000;
5158         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5159
5160         /*
5161          *  Stop capture DMA.
5162          */
5163         tmp = cs461x_peek(card, BA1_CCTL);
5164         card->cctl = tmp & 0x0000ffff;
5165         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5166
5167         /* initialize AC97 codec and register /dev/mixer */
5168         if(card->pm.flags & CS46XX_PM_IDLE)
5169         {
5170                 if (cs_ac97_init(card) <= 0)
5171                 {
5172                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5173                                 "cs46xx: cs_ac97_init() failure\n") );
5174                         return -EIO;
5175                 }
5176         }
5177         else
5178         {
5179                 cs46xx_ac97_resume(card);
5180         }
5181
5182         cs461x_proc_start(card);
5183
5184         /*
5185          *  Enable interrupts on the part.
5186          */
5187         cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
5188
5189         tmp = cs461x_peek(card, BA1_PFIE);
5190         tmp &= ~0x0000f03f;
5191         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt enable */
5192
5193         tmp = cs461x_peek(card, BA1_CIE);
5194         tmp &= ~0x0000003f;
5195         tmp |=  0x00000001;
5196         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt enable */
5197
5198         /*
5199          *  If IDLE then Power down the part.  We will power components up
5200          *  when we need them.
5201          */
5202         if(card->pm.flags & CS46XX_PM_IDLE)
5203         {
5204                 if(!cs_powerdown)
5205                 {
5206                         if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
5207                                         CS_POWER_MIXVON )) )
5208                         {
5209                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5210                                         "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
5211                                 return -EIO;
5212                         }
5213                 }
5214                 else
5215                 {
5216                         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5217                                         CS_POWER_MIXVON, CS_FALSE )) )
5218                         {
5219                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5220                                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5221                                 return -EIO;
5222                         }
5223                 }
5224         }
5225         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
5226                 "cs46xx: cs_hardware_init()- 0\n"));
5227         return 0;
5228 }
5229
5230 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
5231    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
5232
5233 /*
5234  *      Card subid table
5235  */
5236
5237 struct cs_card_type
5238 {
5239         u16 vendor;
5240         u16 id;
5241         char *name;
5242         void (*amp)(struct cs_card *, int);
5243         void (*amp_init)(struct cs_card *);
5244         void (*active)(struct cs_card *, int);
5245 };
5246
5247 static struct cs_card_type cards[] = {
5248         {
5249                 .vendor = 0x1489,
5250                 .id     = 0x7001,
5251                 .name   = "Genius Soundmaker 128 value",
5252                 .amp    = amp_none,
5253         },
5254         {
5255                 .vendor = 0x5053,
5256                 .id     = 0x3357,
5257                 .name   = "Voyetra",
5258                 .amp    = amp_voyetra,
5259         },
5260         {
5261                 .vendor = 0x1071,
5262                 .id     = 0x6003,
5263                 .name   = "Mitac MI6020/21",
5264                 .amp    = amp_voyetra,
5265         },
5266         {
5267                 .vendor = 0x14AF,
5268                 .id     = 0x0050,
5269                 .name   = "Hercules Game Theatre XP",
5270                 .amp    = amp_hercules,
5271         },
5272         {
5273                 .vendor = 0x1681,
5274                 .id     = 0x0050,
5275                 .name   = "Hercules Game Theatre XP",
5276                 .amp    = amp_hercules,
5277         },
5278         {
5279                 .vendor = 0x1681,
5280                 .id     = 0x0051,
5281                 .name   = "Hercules Game Theatre XP",
5282                 .amp    = amp_hercules,
5283         },
5284         {
5285                 .vendor = 0x1681,
5286                 .id     = 0x0052,
5287                 .name   = "Hercules Game Theatre XP",
5288                 .amp    = amp_hercules,
5289         },
5290         {
5291                 .vendor = 0x1681,
5292                 .id     = 0x0053,
5293                 .name   = "Hercules Game Theatre XP",
5294                 .amp    = amp_hercules,
5295         },
5296         {
5297                 .vendor = 0x1681,
5298                 .id     = 0x0054,
5299                 .name   = "Hercules Game Theatre XP",
5300                 .amp    = amp_hercules,
5301         },
5302         {
5303                 .vendor = 0x1681,
5304                 .id     = 0xa010,
5305                 .name   = "Hercules Fortissimo II",
5306                 .amp    = amp_none,
5307         },
5308         /* Not sure if the 570 needs the clkrun hack */
5309         {
5310                 .vendor = PCI_VENDOR_ID_IBM,
5311                 .id     = 0x0132,
5312                 .name   = "Thinkpad 570",
5313                 .amp    = amp_none,
5314                 .active = clkrun_hack,
5315         },
5316         {
5317                 .vendor = PCI_VENDOR_ID_IBM,
5318                 .id     = 0x0153,
5319                 .name   = "Thinkpad 600X/A20/T20",
5320                 .amp    = amp_none,
5321                 .active = clkrun_hack,
5322         },
5323         {
5324                 .vendor = PCI_VENDOR_ID_IBM,
5325                 .id     = 0x1010,
5326                 .name   = "Thinkpad 600E (unsupported)",
5327         },
5328         {
5329                 .name   = "Card without SSID set",
5330         },
5331         { 0, },
5332 };
5333
5334 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5335 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5336 MODULE_LICENSE("GPL");
5337
5338
5339 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5340 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5341
5342 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5343                                   const struct pci_device_id *pciid)
5344 {
5345         struct pm_dev *pmdev;
5346         int i,j;
5347         u16 ss_card, ss_vendor;
5348         struct cs_card *card;
5349         dma_addr_t dma_mask;
5350         struct cs_card_type *cp = &cards[0];
5351
5352         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5353                   printk(KERN_INFO "cs46xx: probe()+\n"));
5354
5355         dma_mask = 0xffffffff;  /* this enables playback and recording */
5356         if (pci_enable_device(pci_dev)) {
5357                 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5358                          "cs46xx: pci_enable_device() failed\n"));
5359                 return -1;
5360         }
5361         if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5362             !RSRCISMEMORYREGION(pci_dev, 1)) {
5363                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5364                          "cs46xx: probe()- Memory region not assigned\n"));
5365                 return -1;
5366         }
5367         if (pci_dev->irq == 0) {
5368                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5369                          "cs46xx: probe() IRQ not assigned\n"));
5370                 return -1;
5371         }
5372         if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5373                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5374                       "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5375                 return -1;
5376         }
5377         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5378         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5379
5380         if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5381                 printk(KERN_ERR "cs46xx: out of memory\n");
5382                 return -ENOMEM;
5383         }
5384         memset(card, 0, sizeof(*card));
5385         card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5386         card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5387         card->pci_dev = pci_dev;
5388         card->irq = pci_dev->irq;
5389         card->magic = CS_CARD_MAGIC;
5390         spin_lock_init(&card->lock);
5391         spin_lock_init(&card->ac97_lock);
5392
5393         pci_set_master(pci_dev);
5394
5395         printk(cs46xx_banner);
5396         printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5397                card->ba0_addr, card->ba1_addr, card->irq);
5398
5399         card->alloc_pcm_channel = cs_alloc_pcm_channel;
5400         card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5401         card->free_pcm_channel = cs_free_pcm_channel;
5402         card->amplifier_ctrl = amp_none;
5403         card->active_ctrl = amp_none;
5404
5405         while (cp->name)
5406         {
5407                 if(cp->vendor == ss_vendor && cp->id == ss_card)
5408                 {
5409                         card->amplifier_ctrl = cp->amp;
5410                         if(cp->active)
5411                                 card->active_ctrl = cp->active;
5412                         if(cp->amp_init)
5413                                 card->amp_init = cp->amp_init;
5414                         break;
5415                 }
5416                 cp++;
5417         }
5418         if (cp->name==NULL)
5419         {
5420                 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5421                         ss_vendor, ss_card, card->ba0_addr, card->ba1_addr,  card->irq);
5422         }
5423         else
5424         {
5425                 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5426                         cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5427         }
5428
5429         if (card->amplifier_ctrl==NULL)
5430         {
5431                 card->amplifier_ctrl = amp_none;
5432                 card->active_ctrl = clkrun_hack;
5433         }
5434
5435         if (external_amp == 1)
5436         {
5437                 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5438                 card->amplifier_ctrl = amp_voyetra;
5439         }
5440
5441         if (thinkpad == 1)
5442         {
5443                 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5444                 card->active_ctrl = clkrun_hack;
5445         }
5446 /*
5447 * The thinkpads don't work well without runtime updating on their kernel
5448 * delay values (or any laptop with variable CPU speeds really).
5449 * so, just to be safe set the init delay to 2100.  Eliminates
5450 * failures on T21 Thinkpads.  remove this code when the udelay
5451 * and mdelay kernel code is replaced by a pm timer, or the delays
5452 * work well for battery and/or AC power both.
5453 */
5454         if(card->active_ctrl == clkrun_hack)
5455         {
5456                 initdelay = 2100;
5457                 cs_laptop_wait = 5;
5458         }
5459         if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
5460         {
5461 /*
5462 * for some currently unknown reason, powering down the DAC and ADC component
5463 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5464 * codec access problems.  probably the serial clock becomes unsynced.
5465 * added code to sync the chips back up, but only helped about 70% the time.
5466 */
5467                 cs_powerdown = 0;
5468         }
5469         if(powerdown == 0)
5470                 cs_powerdown = 0;
5471         card->active_ctrl(card, 1);
5472
5473         /* claim our iospace and irq */
5474
5475         card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5476         card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5477         card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5478         card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5479         card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5480
5481         CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5482                 "cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
5483         CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5484                 "cs46xx: card->ba1=%p %p %p %p\n",
5485                         card->ba1.name.data0,
5486                         card->ba1.name.data1,
5487                         card->ba1.name.pmem,
5488                         card->ba1.name.reg) );
5489
5490         if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5491                 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5492                 card->ba1.name.reg == 0)
5493                 goto fail2;
5494
5495         if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs46xx", card)) {
5496                 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5497                 goto fail2;
5498         }
5499         /* register /dev/dsp */
5500         if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5501                 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5502                 goto fail;
5503         }
5504
5505         /* register /dev/midi */
5506         if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5507                 printk(KERN_ERR "cs46xx: unable to register midi\n");
5508
5509         card->pm.flags |= CS46XX_PM_IDLE;
5510         for(i=0;i<5;i++)
5511         {
5512                 if (cs_hardware_init(card) != 0)
5513                 {
5514                         CS_DBGOUT(CS_ERROR, 4, printk(
5515                                 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5516                         for (j = 0; j < NR_AC97; j++)
5517                                 if (card->ac97_codec[j] != NULL) {
5518                                         unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5519                                         ac97_release_codec(card->ac97_codec[j]);
5520                                 }
5521                         mdelay(10 * cs_laptop_wait);
5522                         continue;
5523                 }
5524                 break;
5525         }
5526         if(i>=4)
5527         {
5528                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5529                         "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5530                 unregister_sound_dsp(card->dev_audio);
5531                 if(card->dev_midi)
5532                         unregister_sound_midi(card->dev_midi);
5533                 goto fail;
5534         }
5535
5536         init_waitqueue_head(&card->midi.open_wait);
5537         init_MUTEX(&card->midi.open_sem);
5538         init_waitqueue_head(&card->midi.iwait);
5539         init_waitqueue_head(&card->midi.owait);
5540         cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5541         cs461x_pokeBA0(card, BA0_MIDCR, 0);
5542
5543         /*
5544         * Check if we have to init the amplifier, but probably already done
5545         * since the CD logic in the ac97 init code will turn on the ext amp.
5546         */
5547         if(cp->amp_init)
5548                 cp->amp_init(card);
5549         card->active_ctrl(card, -1);
5550
5551         PCI_SET_DRIVER_DATA(pci_dev, card);
5552         PCI_SET_DMA_MASK(pci_dev, dma_mask);
5553         list_add(&card->list, &cs46xx_devs);
5554
5555         pmdev = cs_pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
5556         if (pmdev)
5557         {
5558                 CS_DBGOUT(CS_INIT | CS_PM, 4, printk(KERN_INFO
5559                          "cs46xx: probe() pm_register() succeeded (%p).\n",
5560                                 pmdev));
5561                 pmdev->data = card;
5562         }
5563         else
5564         {
5565                 CS_DBGOUT(CS_INIT | CS_PM | CS_ERROR, 2, printk(KERN_INFO
5566                          "cs46xx: probe() pm_register() failed (%p).\n",
5567                                 pmdev));
5568                 card->pm.flags |= CS46XX_PM_NOT_REGISTERED;
5569         }
5570
5571         CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
5572                 (unsigned)card->pm.flags,card));
5573
5574         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5575                 "cs46xx: probe()- device allocated successfully\n"));
5576         return 0;
5577
5578 fail:
5579         free_irq(card->irq, card);
5580 fail2:
5581         if(card->ba0)
5582                 iounmap(card->ba0);
5583         if(card->ba1.name.data0)
5584                 iounmap(card->ba1.name.data0);
5585         if(card->ba1.name.data1)
5586                 iounmap(card->ba1.name.data1);
5587         if(card->ba1.name.pmem)
5588                 iounmap(card->ba1.name.pmem);
5589         if(card->ba1.name.reg)
5590                 iounmap(card->ba1.name.reg);
5591         kfree(card);
5592         CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5593                 "cs46xx: probe()- no device allocated\n"));
5594         return -ENODEV;
5595 } // probe_cs46xx
5596
5597 // ---------------------------------------------------------------------
5598
5599 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5600 {
5601         struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5602         int i;
5603         unsigned int tmp;
5604
5605         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5606                  "cs46xx: cs46xx_remove()+\n"));
5607
5608         card->active_ctrl(card,1);
5609
5610         tmp = cs461x_peek(card, BA1_PFIE);
5611         tmp &= ~0x0000f03f;
5612         tmp |=  0x00000010;
5613         cs461x_poke(card, BA1_PFIE, tmp);       /* playback interrupt disable */
5614
5615         tmp = cs461x_peek(card, BA1_CIE);
5616         tmp &= ~0x0000003f;
5617         tmp |=  0x00000011;
5618         cs461x_poke(card, BA1_CIE, tmp);        /* capture interrupt disable */
5619
5620         /*
5621          *  Stop playback DMA.
5622          */
5623         tmp = cs461x_peek(card, BA1_PCTL);
5624         cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5625
5626         /*
5627          *  Stop capture DMA.
5628          */
5629         tmp = cs461x_peek(card, BA1_CCTL);
5630         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5631
5632         /*
5633          *  Reset the processor.
5634          */
5635         cs461x_reset(card);
5636
5637         cs461x_proc_stop(card);
5638
5639         /*
5640          *  Power down the DAC and ADC.  We will power them up (if) when we need
5641          *  them.
5642          */
5643         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5644                         CS_POWER_MIXVON, CS_TRUE )) )
5645         {
5646                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5647                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5648         }
5649
5650         /*
5651          *  Power down the PLL.
5652          */
5653         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5654
5655         /*
5656          *  Turn off the Processor by turning off the software clock enable flag in
5657          *  the clock control register.
5658          */
5659         tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5660         cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5661
5662         card->active_ctrl(card,-1);
5663
5664         /* free hardware resources */
5665         free_irq(card->irq, card);
5666         iounmap(card->ba0);
5667         iounmap(card->ba1.name.data0);
5668         iounmap(card->ba1.name.data1);
5669         iounmap(card->ba1.name.pmem);
5670         iounmap(card->ba1.name.reg);
5671
5672         /* unregister audio devices */
5673         for (i = 0; i < NR_AC97; i++)
5674                 if (card->ac97_codec[i] != NULL) {
5675                         unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5676                         ac97_release_codec(card->ac97_codec[i]);
5677                 }
5678         unregister_sound_dsp(card->dev_audio);
5679         if(card->dev_midi)
5680                 unregister_sound_midi(card->dev_midi);
5681         list_del(&card->list);
5682         kfree(card);
5683         PCI_SET_DRIVER_DATA(pci_dev,NULL);
5684
5685         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5686                  "cs46xx: cs46xx_remove()-: remove successful\n"));
5687 }
5688
5689 enum {
5690         CS46XX_4610 = 0,
5691         CS46XX_4612,    /* same as 4630 */
5692         CS46XX_4615,    /* same as 4624 */
5693 };
5694
5695 static struct pci_device_id cs46xx_pci_tbl[] = {
5696         {
5697                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5698                 .device      = PCI_DEVICE_ID_CIRRUS_4610,
5699                 .subvendor   = PCI_ANY_ID,
5700                 .subdevice   = PCI_ANY_ID,
5701                 .driver_data = CS46XX_4610,
5702         },
5703         {
5704                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5705                 .device      = PCI_DEVICE_ID_CIRRUS_4612,
5706                 .subvendor   = PCI_ANY_ID,
5707                 .subdevice   = PCI_ANY_ID,
5708                 .driver_data = CS46XX_4612,
5709         },
5710         {
5711                 .vendor      = PCI_VENDOR_ID_CIRRUS,
5712                 .device      = PCI_DEVICE_ID_CIRRUS_4615,
5713                 .subvendor   = PCI_ANY_ID,
5714                 .subdevice   = PCI_ANY_ID,
5715                 .driver_data = CS46XX_4615,
5716         },
5717         { 0, },
5718 };
5719
5720 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5721
5722 struct pci_driver cs46xx_pci_driver = {
5723         .name     = "cs46xx",
5724         .id_table = cs46xx_pci_tbl,
5725         .probe    = cs46xx_probe,
5726         .remove   = __devexit_p(cs46xx_remove),
5727         .suspend  = CS46XX_SUSPEND_TBL,
5728         .resume   = CS46XX_RESUME_TBL,
5729 };
5730
5731 int __init cs46xx_init_module(void)
5732 {
5733         int rtn = 0;
5734         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5735                 "cs46xx: cs46xx_init_module()+ \n"));
5736         rtn = pci_module_init(&cs46xx_pci_driver);
5737
5738         if(rtn == -ENODEV)
5739         {
5740                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5741                         "cs46xx: Unable to detect valid cs46xx device\n"));
5742         }
5743
5744         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5745                   printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5746         return rtn;
5747 }
5748
5749 void __exit cs46xx_cleanup_module(void)
5750 {
5751         pci_unregister_driver(&cs46xx_pci_driver);
5752         cs_pm_unregister_all(cs46xx_pm_callback);
5753         CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5754                   printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5755 }
5756
5757 module_init(cs46xx_init_module);
5758 module_exit(cs46xx_cleanup_module);
5759
5760 int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
5761 {
5762         struct cs_card *card;
5763
5764         CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5765                 "cs46xx: cs46xx_pm_callback dev=%p rqst=0x%x card=%p\n",
5766                         dev,(unsigned)rqst,data));
5767         card = (struct cs_card *) dev->data;
5768         if (card) {
5769                 switch(rqst) {
5770                         case PM_SUSPEND:
5771                                 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5772                                         "cs46xx: PM suspend request\n"));
5773                                 if(cs46xx_suspend(card, 0))
5774                                 {
5775                                     CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5776                                         "cs46xx: PM suspend request refused\n"));
5777                                         return 1;
5778                                 }
5779                                 break;
5780                         case PM_RESUME:
5781                                 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5782                                         "cs46xx: PM resume request\n"));
5783                                 if(cs46xx_resume(card))
5784                                 {
5785                                     CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5786                                         "cs46xx: PM resume request refused\n"));
5787                                         return 1;
5788                                 }
5789                                 break;
5790                 }
5791         }
5792
5793         return 0;
5794 }
5795
5796 #if CS46XX_ACPI_SUPPORT
5797 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state)
5798 {
5799         struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5800         CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5801                 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5802         cs46xx_suspend(s, 0);
5803         return 0;
5804 }
5805
5806 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5807 {
5808         struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5809         CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5810                 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
5811         cs46xx_resume(s);
5812         return 0;
5813 }
5814 #endif