sound/oss/cs46xx.c

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