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