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