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