sound/oss/cs46xx.c

   1 /*
   2  *      Crystal SoundFusion CS46xx driver
   3  *
   4  *      Copyright 1998-2001 Cirrus Logic Corporation <pcaudio@crystal.cirrus.com>
   5  *                                              <twoller@crystal.cirrus.com>
   6  *      Copyright 1999-2000 Jaroslav Kysela <perex@suse.cz>
   7  *      Copyright 2000 Alan Cox <alan@redhat.com>
   8  *
   9  *      The core of this code is taken from the ALSA project driver by
  10  *      Jaroslav. Please send Jaroslav the credit for the driver and
  11  *      report bugs in this port to <alan@redhat.com>
  12  *
  13  *      This program is free software; you can redistribute it and/or modify
  14  *      it under the terms of the GNU General Public License as published by
  15  *      the Free Software Foundation; either version 2 of the License, or
  16  *      (at your option) any later version.
  17  *
  18  *      This program is distributed in the hope that it will be useful,
  19  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *      GNU General Public License for more details.
  22  *
  23  *      You should have received a copy of the GNU General Public License
  24  *      along with this program; if not, write to the Free Software
  25  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *      Current maintainers:
  27  *              Cirrus Logic Corporation, Thomas Woller (tw)
  28  *                      <twoller@crystal.cirrus.com>
  29  *              Nils Faerber (nf)
  30  *                      <nils@kernelconcepts.de>
  31  *              Thanks to David Pollard for testing.
  32  *
  33  *      Changes:
  34  *      20000909-nf     Changed cs_read, cs_write and drain_dac
  35  *      20001025-tw     Separate Playback/Capture structs and buffers.
  36  *                      Added Scatter/Gather support for Playback.
  37  *                      Added Capture.
  38  *      20001027-nf     Port to kernel 2.4.0-test9, some clean-ups
  39  *                      Start of powermanagement support (CS46XX_PM).
  40  *      20001128-tw     Add module parm for default buffer order.
  41  *                      added DMA_GFP flag to kmalloc dma buffer allocs.
  42  *                      backfill silence to eliminate stuttering on
  43  *                      underruns.
  44  *      20001201-tw     add resyncing of swptr on underruns.
  45  *      20001205-tw-nf  fixed GETOSPACE ioctl() after open()
  46  *      20010113-tw     patch from Hans Grobler general cleanup.
  47  *      20010117-tw     2.4.0 pci cleanup, wrapper code for 2.2.16-2.4.0
  48  *      20010118-tw     basic PM support for 2.2.16+ and 2.4.0/2.4.2.
  49  *      20010228-dh     patch from David Huggins - cs_update_ptr recursion.
  50  *      20010409-tw     add hercules game theatre XP amp code.
  51  *      20010420-tw     cleanup powerdown/up code.
  52  *      20010521-tw     eliminate pops, and fixes for powerdown.
  53  *      20010525-tw     added fixes for thinkpads with powerdown logic.
  54  *      20010723-sh     patch from Horms (Simon Horman) -
  55  *                      SOUND_PCM_READ_BITS returns bits as set in driver
  56  *                      rather than a logical or of the possible values.
  57  *                      Various ioctls handle the case where the device
  58  *                      is open for reading or writing but not both better.
  59  *
  60  *      Status:
  61  *      Playback/Capture supported from 8k-48k.
  62  *      16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
  63  *
  64  *      APM/PM - 2.2.x APM is enabled and functioning fine. APM can also
  65  *      be enabled for 2.4.x by modifying the CS46XX_ACPI_SUPPORT macro
  66  *      definition.
  67  *
  68  *      Hercules Game Theatre XP - the EGPIO2 pin controls the external Amp,
  69  *      so, use the drain/polarity to enable.
  70  *      hercules_egpio_disable set to 1, will force a 0 to EGPIODR.
  71  *
  72  *      VTB Santa Cruz - the GPIO7/GPIO8 on the Secondary Codec control
  73  *      the external amplifier for the "back" speakers, since we do not
  74  *      support the secondary codec then this external amp is also not
  75  *      turned on.
  76  */
  77
  78 #include <linux/interrupt.h>
  79 #include <linux/list.h>
  80 #include <linux/module.h>
  81 #include <linux/string.h>
  82 #include <linux/ioport.h>
  83 #include <linux/sched.h>
  84 #include <linux/delay.h>
  85 #include <linux/sound.h>
  86 #include <linux/slab.h>
  87 #include <linux/soundcard.h>
  88 #include <linux/pci.h>
  89 #include <linux/bitops.h>
  90 #include <linux/init.h>
  91 #include <linux/poll.h>
  92 #include <linux/ac97_codec.h>
  93
  94 #include <asm/io.h>
  95 #include <asm/dma.h>
  96 #include <asm/uaccess.h>
  97
  98 #include "cs46xxpm-24.h"
  99 #include "cs46xx_wrapper-24.h"
 100 #include "cs461x.h"
 101
 102 /* MIDI buffer sizes */
 103 #define CS_MIDIINBUF  500
 104 #define CS_MIDIOUTBUF 500
 105
 106 #define ADC_RUNNING     1
 107 #define DAC_RUNNING     2
 108
 109 #define CS_FMT_16BIT    1               /* These are fixed in fact */
 110 #define CS_FMT_STEREO   2
 111 #define CS_FMT_MASK     3
 112
 113 #define CS_TYPE_ADC     1
 114 #define CS_TYPE_DAC     2
 115
 116 #define CS_TRUE         1
 117 #define CS_FALSE        0
 118
 119 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
 120 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
 121 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
 122 #define CS_IN_USE(m) (atomic_read(m) != 0)
 123
 124 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
 125 /*
 126  *      CS461x definitions
 127  */
 128
 129 #define CS461X_BA0_SIZE         0x2000
 130 #define CS461X_BA1_DATA0_SIZE   0x3000
 131 #define CS461X_BA1_DATA1_SIZE   0x3800
 132 #define CS461X_BA1_PRG_SIZE     0x7000
 133 #define CS461X_BA1_REG_SIZE     0x0100
 134
 135 #define GOF_PER_SEC     200
 136
 137 #define CSDEBUG_INTERFACE 1
 138 #define CSDEBUG 1
 139 /*
 140  * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
 141  *
 142  *
 143  * CSDEBUG is usual mode is set to 1, then use the
 144  * cs_debuglevel and cs_debugmask to turn on or off debugging.
 145  * Debug level of 1 has been defined to be kernel errors and info
 146  * that should be printed on any released driver.
 147  */
 148 #if CSDEBUG
 149 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
 150 #else
 151 #define CS_DBGOUT(mask,level,x)
 152 #endif
 153 /*
 154  * cs_debugmask areas
 155  */
 156 #define CS_INIT         0x00000001              /* initialization and probe functions */
 157 #define CS_ERROR        0x00000002              /* tmp debugging bit placeholder */
 158 #define CS_INTERRUPT    0x00000004              /* interrupt handler (separate from all other) */
 159 #define CS_FUNCTION     0x00000008              /* enter/leave functions */
 160 #define CS_WAVE_WRITE   0x00000010              /* write information for wave */
 161 #define CS_WAVE_READ    0x00000020              /* read information for wave */
 162 #define CS_MIDI_WRITE   0x00000040              /* write information for midi */
 163 #define CS_MIDI_READ    0x00000080              /* read information for midi */
 164 #define CS_MPU401_WRITE 0x00000100              /* write information for mpu401 */
 165 #define CS_MPU401_READ  0x00000200              /* read information for mpu401 */
 166 #define CS_OPEN         0x00000400              /* all open functions in the driver */
 167 #define CS_RELEASE      0x00000800              /* all release functions in the driver */
 168 #define CS_PARMS        0x00001000              /* functional and operational parameters */
 169 #define CS_IOCTL        0x00002000              /* ioctl (non-mixer) */
 170 #define CS_PM           0x00004000              /* PM */
 171 #define CS_TMP          0x10000000              /* tmp debug mask bit */
 172
 173 #define CS_IOCTL_CMD_SUSPEND    0x1     // suspend
 174 #define CS_IOCTL_CMD_RESUME     0x2     // resume
 175
 176 #if CSDEBUG
 177 static unsigned long cs_debuglevel=1;                   /* levels range from 1-9 */
 178 module_param(cs_debuglevel, ulong, 0644);
 179 static unsigned long cs_debugmask=CS_INIT | CS_ERROR;   /* use CS_DBGOUT with various mask values */
 180 module_param(cs_debugmask, ulong, 0644);
 181 #endif
 182 static unsigned long hercules_egpio_disable;  /* if non-zero set all EGPIO to 0 */
 183 module_param(hercules_egpio_disable, ulong, 0);
 184 static unsigned long initdelay=700;  /* PM delay in millisecs */
 185 module_param(initdelay, ulong, 0);
 186 static unsigned long powerdown=-1;  /* turn on/off powerdown processing in driver */
 187 module_param(powerdown, ulong, 0);
 188 #define DMABUF_DEFAULTORDER 3
 189 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
 190 module_param(defaultorder, ulong, 0);
 191
 192 static int external_amp;
 193 module_param(external_amp, bool, 0);
 194 static int thinkpad;
 195 module_param(thinkpad, bool, 0);
 196
 197 /*
 198 * set the powerdown module parm to 0 to disable all
 199 * powerdown. also set thinkpad to 1 to disable powerdown,
 200 * but also to enable the clkrun functionality.
 201 */
 202 static unsigned cs_powerdown=1;
 203 static unsigned cs_laptop_wait=1;
 204
 205 /* An instance of the 4610 channel */
 206 struct cs_channel
 207 {
 208         int used;
 209         int num;
 210         void *state;
 211 };
 212
 213 #define CS46XX_MAJOR_VERSION "1"
 214 #define CS46XX_MINOR_VERSION "28"
 215
 216 #ifdef __ia64__
 217 #define CS46XX_ARCH             "64"    //architecture key
 218 #else
 219 #define CS46XX_ARCH             "32"    //architecture key
 220 #endif
 221
 222 static struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
 223
 224 /* magic numbers to protect our data structures */
 225 #define CS_CARD_MAGIC           0x43525553 /* "CRUS" */
 226 #define CS_STATE_MAGIC          0x4c4f4749 /* "LOGI" */
 227 #define NR_HW_CH                3
 228
 229 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
 230 #define NR_AC97         2
 231
 232 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 233 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 234
 235 /* "software" or virtual channel, an instance of opened /dev/dsp */
 236 struct cs_state {
 237         unsigned int magic;
 238         struct cs_card *card;   /* Card info */
 239
 240         /* single open lock mechanism, only used for recording */
 241         struct semaphore open_sem;
 242         wait_queue_head_t open_wait;
 243
 244         /* file mode */
 245         mode_t open_mode;
 246
 247         /* virtual channel number */
 248         int virt;
 249
 250         struct dmabuf {
 251                 /* wave sample stuff */
 252                 unsigned int rate;
 253                 unsigned char fmt, enable;
 254
 255                 /* hardware channel */
 256                 struct cs_channel *channel;
 257                 int pringbuf;           /* Software ring slot */
 258                 void *pbuf;             /* 4K hardware DMA buffer */
 259
 260                 /* OSS buffer management stuff */
 261                 void *rawbuf;
 262                 dma_addr_t dma_handle;
 263                 unsigned buforder;
 264                 unsigned numfrag;
 265                 unsigned fragshift;
 266                 unsigned divisor;
 267                 unsigned type;
 268                 void *tmpbuff;                  /* tmp buffer for sample conversions */
 269                 dma_addr_t dmaaddr;
 270                 dma_addr_t dmaaddr_tmpbuff;
 271                 unsigned buforder_tmpbuff;      /* Log base 2 of size in bytes.. */
 272
 273                 /* our buffer acts like a circular ring */
 274                 unsigned hwptr;         /* where dma last started, updated by update_ptr */
 275                 unsigned swptr;         /* where driver last clear/filled, updated by read/write */
 276                 int count;              /* bytes to be comsumed or been generated by dma machine */
 277                 unsigned total_bytes;   /* total bytes dmaed by hardware */
 278                 unsigned blocks;        /* total blocks */
 279
 280                 unsigned error;         /* number of over/underruns */
 281                 unsigned underrun;      /* underrun pending before next write has occurred */
 282                 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
 283
 284                 /* redundant, but makes calculations easier */
 285                 unsigned fragsize;
 286                 unsigned dmasize;
 287                 unsigned fragsamples;
 288
 289                 /* OSS stuff */
 290                 unsigned mapped:1;
 291                 unsigned ready:1;
 292                 unsigned endcleared:1;
 293                 unsigned SGok:1;
 294                 unsigned update_flag;
 295                 unsigned ossfragshift;
 296                 int ossmaxfrags;
 297                 unsigned subdivision;
 298         } dmabuf;
 299         /* Guard against mmap/write/read races */
 300         struct semaphore sem;
 301 };
 302
 303 struct cs_card {
 304         struct cs_channel channel[2];
 305         unsigned int magic;
 306
 307         /* We keep cs461x cards in a linked list */
 308         struct cs_card *next;
 309
 310         /* The cs461x has a certain amount of cross channel interaction
 311            so we use a single per card lock */
 312         spinlock_t lock;
 313
 314         /* Keep AC97 sane */
 315         spinlock_t ac97_lock;
 316
 317         /* mixer use count */
 318         atomic_t mixer_use_cnt;
 319
 320         /* PCI device stuff */
 321         struct pci_dev * pci_dev;
 322         struct list_head list;
 323
 324         unsigned int pctl, cctl;        /* Hardware DMA flag sets */
 325
 326         /* soundcore stuff */
 327         int dev_audio;
 328         int dev_midi;
 329
 330         /* structures for abstraction of hardware facilities, codecs, banks and channels*/
 331         struct ac97_codec *ac97_codec[NR_AC97];
 332         struct cs_state *states[2];
 333
 334         u16 ac97_features;
 335
 336         int amplifier;                  /* Amplifier control */
 337         void (*amplifier_ctrl)(struct cs_card *, int);
 338         void (*amp_init)(struct cs_card *);
 339
 340         int active;                     /* Active clocking */
 341         void (*active_ctrl)(struct cs_card *, int);
 342
 343         /* hardware resources */
 344         unsigned long ba0_addr;
 345         unsigned long ba1_addr;
 346         u32 irq;
 347
 348         /* mappings */
 349         void __iomem *ba0;
 350         union
 351         {
 352                 struct
 353                 {
 354                         u8 __iomem *data0;
 355                         u8 __iomem *data1;
 356                         u8 __iomem *pmem;
 357                         u8 __iomem *reg;
 358                 } name;
 359                 u8 __iomem *idx[4];
 360         } ba1;
 361
 362         /* Function support */
 363         struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
 364         struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
 365         void (*free_pcm_channel)(struct cs_card *, int chan);
 366
 367         /* /dev/midi stuff */
 368         struct {
 369                 unsigned ird, iwr, icnt;
 370                 unsigned ord, owr, ocnt;
 371                 wait_queue_head_t open_wait;
 372                 wait_queue_head_t iwait;
 373                 wait_queue_head_t owait;
 374                 spinlock_t lock;
 375                 unsigned char ibuf[CS_MIDIINBUF];
 376                 unsigned char obuf[CS_MIDIOUTBUF];
 377                 mode_t open_mode;
 378                 struct semaphore open_sem;
 379         } midi;
 380         struct cs46xx_pm pm;
 381 };
 382
 383 static int cs_open_mixdev(struct inode *inode, struct file *file);
 384 static int cs_release_mixdev(struct inode *inode, struct file *file);
 385 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 386                                 unsigned long arg);
 387 static int cs_hardware_init(struct cs_card *card);
 388 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
 389 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
 390 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
 391 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state);
 392 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
 393
 394 #ifndef CS46XX_ACPI_SUPPORT
 395 static int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data);
 396 #endif
 397
 398 #if CSDEBUG
 399
 400 /* DEBUG ROUTINES */
 401
 402 #define SOUND_MIXER_CS_GETDBGLEVEL      _SIOWR('M',120, int)
 403 #define SOUND_MIXER_CS_SETDBGLEVEL      _SIOWR('M',121, int)
 404 #define SOUND_MIXER_CS_GETDBGMASK       _SIOWR('M',122, int)
 405 #define SOUND_MIXER_CS_SETDBGMASK       _SIOWR('M',123, int)
 406 #define SOUND_MIXER_CS_APM              _SIOWR('M',124, int)
 407
 408 static void printioctl(unsigned int x)
 409 {
 410     unsigned int i;
 411     unsigned char vidx;
 412         /* these values are incorrect for the ac97 driver, fix.
 413          * Index of mixtable1[] member is Device ID
 414          * and must be <= SOUND_MIXER_NRDEVICES.
 415          * Value of array member is index into s->mix.vol[]
 416          */
 417         static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
 418                 [SOUND_MIXER_PCM]     = 1,   /* voice */
 419                 [SOUND_MIXER_LINE1]   = 2,   /* AUX */
 420                 [SOUND_MIXER_CD]      = 3,   /* CD */
 421                 [SOUND_MIXER_LINE]    = 4,   /* Line */
 422                 [SOUND_MIXER_SYNTH]   = 5,   /* FM */
 423                 [SOUND_MIXER_MIC]     = 6,   /* Mic */
 424                 [SOUND_MIXER_SPEAKER] = 7,   /* Speaker */
 425                 [SOUND_MIXER_RECLEV]  = 8,   /* Recording level */
 426                 [SOUND_MIXER_VOLUME]  = 9    /* Master Volume */
 427         };
 428
 429     switch(x)
 430     {
 431         case SOUND_MIXER_CS_GETDBGMASK:
 432                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
 433                 break;
 434         case SOUND_MIXER_CS_GETDBGLEVEL:
 435                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
 436                 break;
 437         case SOUND_MIXER_CS_SETDBGMASK:
 438                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
 439                 break;
 440         case SOUND_MIXER_CS_SETDBGLEVEL:
 441                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
 442                 break;
 443         case OSS_GETVERSION:
 444                 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
 445                 break;
 446         case SNDCTL_DSP_SYNC:
 447                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
 448                 break;
 449         case SNDCTL_DSP_SETDUPLEX:
 450                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
 451                 break;
 452         case SNDCTL_DSP_GETCAPS:
 453                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
 454                 break;
 455         case SNDCTL_DSP_RESET:
 456                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
 457                 break;
 458         case SNDCTL_DSP_SPEED:
 459                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
 460                 break;
 461         case SNDCTL_DSP_STEREO:
 462                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
 463                 break;
 464         case SNDCTL_DSP_CHANNELS:
 465                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
 466                 break;
 467         case SNDCTL_DSP_GETFMTS:
 468                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
 469                 break;
 470         case SNDCTL_DSP_SETFMT:
 471                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
 472                 break;
 473         case SNDCTL_DSP_POST:
 474                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
 475                 break;
 476         case SNDCTL_DSP_GETTRIGGER:
 477                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
 478                 break;
 479         case SNDCTL_DSP_SETTRIGGER:
 480                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
 481                 break;
 482         case SNDCTL_DSP_GETOSPACE:
 483                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
 484                 break;
 485         case SNDCTL_DSP_GETISPACE:
 486                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
 487                 break;
 488         case SNDCTL_DSP_NONBLOCK:
 489                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
 490                 break;
 491         case SNDCTL_DSP_GETODELAY:
 492                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
 493                 break;
 494         case SNDCTL_DSP_GETIPTR:
 495                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
 496                 break;
 497         case SNDCTL_DSP_GETOPTR:
 498                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
 499                 break;
 500         case SNDCTL_DSP_GETBLKSIZE:
 501                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
 502                 break;
 503         case SNDCTL_DSP_SETFRAGMENT:
 504                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
 505                 break;
 506         case SNDCTL_DSP_SUBDIVIDE:
 507                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
 508                 break;
 509         case SOUND_PCM_READ_RATE:
 510                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
 511                 break;
 512         case SOUND_PCM_READ_CHANNELS:
 513                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
 514                 break;
 515         case SOUND_PCM_READ_BITS:
 516                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
 517                 break;
 518         case SOUND_PCM_WRITE_FILTER:
 519                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
 520                 break;
 521         case SNDCTL_DSP_SETSYNCRO:
 522                 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
 523                 break;
 524         case SOUND_PCM_READ_FILTER:
 525                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
 526                 break;
 527
 528         case SOUND_MIXER_PRIVATE1:
 529                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
 530                 break;
 531         case SOUND_MIXER_PRIVATE2:
 532                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
 533                 break;
 534         case SOUND_MIXER_PRIVATE3:
 535                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
 536                 break;
 537         case SOUND_MIXER_PRIVATE4:
 538                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
 539                 break;
 540         case SOUND_MIXER_PRIVATE5:
 541                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
 542                 break;
 543         case SOUND_MIXER_INFO:
 544                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
 545                 break;
 546         case SOUND_OLD_MIXER_INFO:
 547                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
 548                 break;
 549
 550         default:
 551                 switch (_IOC_NR(x))
 552                 {
 553                         case SOUND_MIXER_VOLUME:
 554                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
 555                                 break;
 556                         case SOUND_MIXER_SPEAKER:
 557                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
 558                                 break;
 559                         case SOUND_MIXER_RECLEV:
 560                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
 561                                 break;
 562                         case SOUND_MIXER_MIC:
 563                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
 564                                 break;
 565                         case SOUND_MIXER_SYNTH:
 566                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
 567                                 break;
 568                         case SOUND_MIXER_RECSRC:
 569                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
 570                                 break;
 571                         case SOUND_MIXER_DEVMASK:
 572                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
 573                                 break;
 574                         case SOUND_MIXER_RECMASK:
 575                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
 576                                 break;
 577                         case SOUND_MIXER_STEREODEVS:
 578                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
 579                                 break;
 580                         case SOUND_MIXER_CAPS:
 581                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
 582                                 break;
 583                         default:
 584                                 i = _IOC_NR(x);
 585                                 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
 586                                 {
 587                                         CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
 588                                 }
 589                                 else
 590                                 {
 591                                         CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
 592                                                         x,i) );
 593                                 }
 594                                 break;
 595                 }
 596     }
 597     CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
 598 }
 599 #endif
 600
 601 /*
 602  *  common I/O routines
 603  */
 604
 605 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
 606 {
 607         writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
 608 }
 609
 610 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
 611 {
 612         return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
 613 }
 614
 615 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
 616 {
 617         writel(val, codec->ba0+reg);
 618 }
 619
 620 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
 621 {
 622         return readl(codec->ba0+reg);
 623 }
 624
 625
 626 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
 627 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
 628
 629 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
 630 {
 631         if(card->channel[1].used==1)
 632                 return NULL;
 633         card->channel[1].used=1;
 634         card->channel[1].num=1;
 635         return &card->channel[1];
 636 }
 637
 638 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
 639 {
 640         if(card->channel[0].used==1)
 641                 return NULL;
 642         card->channel[0].used=1;
 643         card->channel[0].num=0;
 644         return &card->channel[0];
 645 }
 646
 647 static void cs_free_pcm_channel(struct cs_card *card, int channel)
 648 {
 649         card->channel[channel].state = NULL;
 650         card->channel[channel].used=0;
 651 }
 652
 653 /*
 654  * setup a divisor value to help with conversion from
 655  * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
 656  * assign a divisor of 1 if using 16bit Stereo as that is
 657  * the only format that the static image will capture.
 658  */
 659 static void cs_set_divisor(struct dmabuf *dmabuf)
 660 {
 661         if(dmabuf->type == CS_TYPE_DAC)
 662                 dmabuf->divisor = 1;
 663         else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
 664             (dmabuf->fmt & CS_FMT_16BIT))
 665                 dmabuf->divisor = 2;
 666         else if( (dmabuf->fmt & CS_FMT_STEREO) &&
 667             !(dmabuf->fmt & CS_FMT_16BIT))
 668                 dmabuf->divisor = 2;
 669         else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
 670             !(dmabuf->fmt & CS_FMT_16BIT))
 671                 dmabuf->divisor = 4;
 672         else
 673                 dmabuf->divisor = 1;
 674
 675         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
 676                 "cs46xx: cs_set_divisor()- %s %d\n",
 677                         (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
 678                         dmabuf->divisor) );
 679 }
 680
 681 /*
 682 * mute some of the more prevalent registers to avoid popping.
 683 */
 684 static void cs_mute(struct cs_card *card, int state)
 685 {
 686         struct ac97_codec *dev=card->ac97_codec[0];
 687
 688         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
 689                 (state == CS_TRUE) ? "Muting" : "UnMuting") );
 690
 691         if(state == CS_TRUE)
 692         {
 693         /*
 694         * fix pops when powering up on thinkpads
 695         */
 696                 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
 697                                 (u8)BA0_AC97_MASTER_VOLUME);
 698                 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
 699                                 (u8)BA0_AC97_HEADPHONE_VOLUME);
 700                 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
 701                                 (u8)BA0_AC97_MASTER_VOLUME_MONO);
 702                 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
 703                                 (u8)BA0_AC97_PCM_OUT_VOLUME);
 704
 705                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
 706                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
 707                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
 708                 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
 709         }
 710         else
 711         {
 712                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
 713                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
 714                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
 715                 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
 716         }
 717         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
 718 }
 719
 720 /* set playback sample rate */
 721 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
 722 {
 723         struct dmabuf *dmabuf = &state->dmabuf;
 724         unsigned int tmp1, tmp2;
 725         unsigned int phiIncr;
 726         unsigned int correctionPerGOF, correctionPerSec;
 727         unsigned long flags;
 728
 729         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
 730
 731         /*
 732          *  Compute the values used to drive the actual sample rate conversion.
 733          *  The following formulas are being computed, using inline assembly
 734          *  since we need to use 64 bit arithmetic to compute the values:
 735          *
 736          *  phiIncr = floor((Fs,in * 2^26) / Fs,out)
 737          *  correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
 738          *                                   GOF_PER_SEC)
 739          *  ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
 740          *                       GOF_PER_SEC * correctionPerGOF
 741          *
 742          *  i.e.
 743          *
 744          *  phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
 745          *  correctionPerGOF:correctionPerSec =
 746          *      dividend:remainder(ulOther / GOF_PER_SEC)
 747          */
 748         tmp1 = rate << 16;
 749         phiIncr = tmp1 / 48000;
 750         tmp1 -= phiIncr * 48000;
 751         tmp1 <<= 10;
 752         phiIncr <<= 10;
 753         tmp2 = tmp1 / 48000;
 754         phiIncr += tmp2;
 755         tmp1 -= tmp2 * 48000;
 756         correctionPerGOF = tmp1 / GOF_PER_SEC;
 757         tmp1 -= correctionPerGOF * GOF_PER_SEC;
 758         correctionPerSec = tmp1;
 759
 760         /*
 761          *  Fill in the SampleRateConverter control block.
 762          */
 763
 764         spin_lock_irqsave(&state->card->lock, flags);
 765         cs461x_poke(state->card, BA1_PSRC,
 766           ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 767         cs461x_poke(state->card, BA1_PPI, phiIncr);
 768         spin_unlock_irqrestore(&state->card->lock, flags);
 769         dmabuf->rate = rate;
 770
 771         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
 772         return rate;
 773 }
 774
 775 /* set recording sample rate */
 776 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
 777 {
 778         struct dmabuf *dmabuf = &state->dmabuf;
 779         struct cs_card *card = state->card;
 780         unsigned int phiIncr, coeffIncr, tmp1, tmp2;
 781         unsigned int correctionPerGOF, correctionPerSec, initialDelay;
 782         unsigned int frameGroupLength, cnt;
 783         unsigned long flags;
 784         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
 785
 786         /*
 787          *  We can only decimate by up to a factor of 1/9th the hardware rate.
 788          *  Correct the value if an attempt is made to stray outside that limit.
 789          */
 790         if ((rate * 9) < 48000)
 791                 rate = 48000 / 9;
 792
 793         /*
 794          *  We can not capture at at rate greater than the Input Rate (48000).
 795          *  Return an error if an attempt is made to stray outside that limit.
 796          */
 797         if (rate > 48000)
 798                 rate = 48000;
 799
 800         /*
 801          *  Compute the values used to drive the actual sample rate conversion.
 802          *  The following formulas are being computed, using inline assembly
 803          *  since we need to use 64 bit arithmetic to compute the values:
 804          *
 805          *     coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
 806          *     phiIncr = floor((Fs,in * 2^26) / Fs,out)
 807          *     correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
 808          *                                GOF_PER_SEC)
 809          *     correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
 810          *                          GOF_PER_SEC * correctionPerGOF
 811          *     initialDelay = ceil((24 * Fs,in) / Fs,out)
 812          *
 813          * i.e.
 814          *
 815          *     coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
 816          *     phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
 817          *     correctionPerGOF:correctionPerSec =
 818          *          dividend:remainder(ulOther / GOF_PER_SEC)
 819          *     initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
 820          */
 821
 822         tmp1 = rate << 16;
 823         coeffIncr = tmp1 / 48000;
 824         tmp1 -= coeffIncr * 48000;
 825         tmp1 <<= 7;
 826         coeffIncr <<= 7;
 827         coeffIncr += tmp1 / 48000;
 828         coeffIncr ^= 0xFFFFFFFF;
 829         coeffIncr++;
 830         tmp1 = 48000 << 16;
 831         phiIncr = tmp1 / rate;
 832         tmp1 -= phiIncr * rate;
 833         tmp1 <<= 10;
 834         phiIncr <<= 10;
 835         tmp2 = tmp1 / rate;
 836         phiIncr += tmp2;
 837         tmp1 -= tmp2 * rate;
 838         correctionPerGOF = tmp1 / GOF_PER_SEC;
 839         tmp1 -= correctionPerGOF * GOF_PER_SEC;
 840         correctionPerSec = tmp1;
 841         initialDelay = ((48000 * 24) + rate - 1) / rate;
 842
 843         /*
 844          *  Fill in the VariDecimate control block.
 845          */
 846         spin_lock_irqsave(&card->lock, flags);
 847         cs461x_poke(card, BA1_CSRC,
 848                 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 849         cs461x_poke(card, BA1_CCI, coeffIncr);
 850         cs461x_poke(card, BA1_CD,
 851                 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
 852         cs461x_poke(card, BA1_CPI, phiIncr);
 853         spin_unlock_irqrestore(&card->lock, flags);
 854
 855         /*
 856          *  Figure out the frame group length for the write back task.  Basically,
 857          *  this is just the factors of 24000 (2^6*3*5^3) that are not present in
 858          *  the output sample rate.
 859          */
 860         frameGroupLength = 1;
 861         for (cnt = 2; cnt <= 64; cnt *= 2) {
 862                 if (((rate / cnt) * cnt) != rate)
 863                         frameGroupLength *= 2;
 864         }
 865         if (((rate / 3) * 3) != rate) {
 866                 frameGroupLength *= 3;
 867         }
 868         for (cnt = 5; cnt <= 125; cnt *= 5) {
 869                 if (((rate / cnt) * cnt) != rate)
 870                         frameGroupLength *= 5;
 871         }
 872
 873         /*
 874          * Fill in the WriteBack control block.
 875          */
 876         spin_lock_irqsave(&card->lock, flags);
 877         cs461x_poke(card, BA1_CFG1, frameGroupLength);
 878         cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
 879         cs461x_poke(card, BA1_CCST, 0x0000FFFF);
 880         cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
 881         cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
 882         spin_unlock_irqrestore(&card->lock, flags);
 883         dmabuf->rate = rate;
 884         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
 885         return rate;
 886 }
 887
 888 /* prepare channel attributes for playback */
 889 static void cs_play_setup(struct cs_state *state)
 890 {
 891         struct dmabuf *dmabuf = &state->dmabuf;
 892         struct cs_card *card = state->card;
 893         unsigned int tmp, Count, playFormat;
 894
 895         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
 896         cs461x_poke(card, BA1_PVOL, 0x80008000);
 897         if(!dmabuf->SGok)
 898                cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
 899
 900         Count = 4;
 901         playFormat=cs461x_peek(card, BA1_PFIE);
 902         if ((dmabuf->fmt & CS_FMT_STEREO)) {
 903                 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
 904                 Count *= 2;
 905         }
 906         else
 907                 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
 908
 909         if ((dmabuf->fmt & CS_FMT_16BIT)) {
 910                 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
 911                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
 912                 Count *= 2;
 913         }
 914         else
 915                 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
 916                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
 917
 918         cs461x_poke(card, BA1_PFIE, playFormat);
 919
 920         tmp = cs461x_peek(card, BA1_PDTC);
 921         tmp &= 0xfffffe00;
 922         cs461x_poke(card, BA1_PDTC, tmp | --Count);
 923
 924         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
 925
 926 }
 927
 928 static struct InitStruct
 929 {
 930     u32 off;
 931     u32 val;
 932 } InitArray[] = { {0x00000040, 0x3fc0000f},
 933                   {0x0000004c, 0x04800000},
 934
 935                   {0x000000b3, 0x00000780},
 936                   {0x000000b7, 0x00000000},
 937                   {0x000000bc, 0x07800000},
 938
 939                   {0x000000cd, 0x00800000},
 940                 };
 941
 942 /*
 943  * "SetCaptureSPValues()" -- Initialize record task values before each
 944  *      capture startup.
 945  */
 946 static void SetCaptureSPValues(struct cs_card *card)
 947 {
 948         unsigned i, offset;
 949         CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
 950         for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
 951         {
 952                 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
 953                 cs461x_poke(card, offset, InitArray[i].val );
 954         }
 955         CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
 956 }
 957
 958 /* prepare channel attributes for recording */
 959 static void cs_rec_setup(struct cs_state *state)
 960 {
 961         struct cs_card *card = state->card;
 962         struct dmabuf *dmabuf = &state->dmabuf;
 963         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
 964
 965         SetCaptureSPValues(card);
 966
 967         /*
 968          * set the attenuation to 0dB
 969          */
 970         cs461x_poke(card, BA1_CVOL, 0x80008000);
 971
 972         /*
 973          * set the physical address of the capture buffer into the SP
 974          */
 975         cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
 976
 977         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
 978 }
 979
 980
 981 /* get current playback/recording dma buffer pointer (byte offset from LBA),
 982    called with spinlock held! */
 983
 984 static inline unsigned cs_get_dma_addr(struct cs_state *state)
 985 {
 986         struct dmabuf *dmabuf = &state->dmabuf;
 987         u32 offset;
 988
 989         if ( (!(dmabuf->enable & DAC_RUNNING)) &&
 990              (!(dmabuf->enable & ADC_RUNNING) ) )
 991         {
 992                 CS_DBGOUT(CS_ERROR, 2, printk(
 993                         "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
 994                 return 0;
 995         }
 996
 997         /*
 998          * granularity is byte boundary, good part.
 999          */
1000         if(dmabuf->enable & DAC_RUNNING)
1001         {
1002                 offset = cs461x_peek(state->card, BA1_PBA);
1003         }
1004         else /* ADC_RUNNING must be set */
1005         {
1006                 offset = cs461x_peek(state->card, BA1_CBA);
1007         }
1008         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
1009                 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
1010         offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
1011         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
1012                 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
1013         return offset;
1014 }
1015
1016 static void resync_dma_ptrs(struct cs_state *state)
1017 {
1018         struct dmabuf *dmabuf;
1019
1020         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1021         if(state)
1022         {
1023                 dmabuf = &state->dmabuf;
1024                 dmabuf->hwptr=dmabuf->swptr = 0;
1025                 dmabuf->pringbuf = 0;
1026         }
1027         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1028 }
1029
1030 /* Stop recording (lock held) */
1031 static inline void __stop_adc(struct cs_state *state)
1032 {
1033         struct dmabuf *dmabuf = &state->dmabuf;
1034         struct cs_card *card = state->card;
1035         unsigned int tmp;
1036
1037         dmabuf->enable &= ~ADC_RUNNING;
1038
1039         tmp = cs461x_peek(card, BA1_CCTL);
1040         tmp &= 0xFFFF0000;
1041         cs461x_poke(card, BA1_CCTL, tmp );
1042 }
1043
1044 static void stop_adc(struct cs_state *state)
1045 {
1046         unsigned long flags;
1047
1048         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1049         spin_lock_irqsave(&state->card->lock, flags);
1050         __stop_adc(state);
1051         spin_unlock_irqrestore(&state->card->lock, flags);
1052         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1053 }
1054
1055 static void start_adc(struct cs_state *state)
1056 {
1057         struct dmabuf *dmabuf = &state->dmabuf;
1058         struct cs_card *card = state->card;
1059         unsigned long flags;
1060         unsigned int tmp;
1061
1062         spin_lock_irqsave(&card->lock, flags);
1063         if (!(dmabuf->enable & ADC_RUNNING) &&
1064              ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1065                && dmabuf->ready) &&
1066                ((card->pm.flags & CS46XX_PM_IDLE) ||
1067                 (card->pm.flags & CS46XX_PM_RESUMED)) )
1068         {
1069                 dmabuf->enable |= ADC_RUNNING;
1070                 cs_set_divisor(dmabuf);
1071                 tmp = cs461x_peek(card, BA1_CCTL);
1072                 tmp &= 0xFFFF0000;
1073                 tmp |= card->cctl;
1074                 CS_DBGOUT(CS_FUNCTION, 2, printk(
1075                         "cs46xx: start_adc() poke 0x%x \n",tmp) );
1076                 cs461x_poke(card, BA1_CCTL, tmp);
1077         }
1078         spin_unlock_irqrestore(&card->lock, flags);
1079 }
1080
1081 /* stop playback (lock held) */
1082 static inline void __stop_dac(struct cs_state *state)
1083 {
1084         struct dmabuf *dmabuf = &state->dmabuf;
1085         struct cs_card *card = state->card;
1086         unsigned int tmp;
1087
1088         dmabuf->enable &= ~DAC_RUNNING;
1089
1090         tmp=cs461x_peek(card, BA1_PCTL);
1091         tmp&=0xFFFF;
1092         cs461x_poke(card, BA1_PCTL, tmp);
1093 }
1094
1095 static void stop_dac(struct cs_state *state)
1096 {
1097         unsigned long flags;
1098
1099         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1100         spin_lock_irqsave(&state->card->lock, flags);
1101         __stop_dac(state);
1102         spin_unlock_irqrestore(&state->card->lock, flags);
1103         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1104 }
1105
1106 static void start_dac(struct cs_state *state)
1107 {
1108         struct dmabuf *dmabuf = &state->dmabuf;
1109         struct cs_card *card = state->card;
1110         unsigned long flags;
1111         int tmp;
1112
1113         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1114         spin_lock_irqsave(&card->lock, flags);
1115         if (!(dmabuf->enable & DAC_RUNNING) &&
1116             ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1117                ((card->pm.flags & CS46XX_PM_IDLE) ||
1118                 (card->pm.flags & CS46XX_PM_RESUMED)) )
1119         {
1120                 dmabuf->enable |= DAC_RUNNING;
1121                 tmp = cs461x_peek(card, BA1_PCTL);
1122                 tmp &= 0xFFFF;
1123                 tmp |= card->pctl;
1124                 CS_DBGOUT(CS_PARMS, 6, printk(
1125                     "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
1126                     card, (unsigned)tmp,
1127                     card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1128                 cs461x_poke(card, BA1_PCTL, tmp);
1129         }
1130         spin_unlock_irqrestore(&card->lock, flags);
1131         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1132 }
1133
1134 #define DMABUF_MINORDER 1
1135
1136 /*
1137  * allocate DMA buffer, playback and recording buffers are separate.
1138  */
1139 static int alloc_dmabuf(struct cs_state *state)
1140 {
1141
1142         struct cs_card *card=state->card;
1143         struct dmabuf *dmabuf = &state->dmabuf;
1144         void *rawbuf = NULL;
1145         void *tmpbuff = NULL;
1146         int order;
1147         struct page *map, *mapend;
1148         unsigned long df;
1149
1150         dmabuf->ready  = dmabuf->mapped = 0;
1151         dmabuf->SGok = 0;
1152 /*
1153 * check for order within limits, but do not overwrite value.
1154 */
1155         if((defaultorder > 1) && (defaultorder < 12))
1156                 df = defaultorder;
1157         else
1158                 df = 2;
1159
1160         for (order = df; order >= DMABUF_MINORDER; order--)
1161                 if ( (rawbuf = (void *) pci_alloc_consistent(
1162                         card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1163                             break;
1164         if (!rawbuf) {
1165                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1166                         "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1167                 return -ENOMEM;
1168         }
1169         dmabuf->buforder = order;
1170         dmabuf->rawbuf = rawbuf;
1171         // Now mark the pages as reserved; otherwise the
1172         // remap_pfn_range() in cs46xx_mmap doesn't work.
1173         // 1. get index to last page in mem_map array for rawbuf.
1174         mapend = virt_to_page(dmabuf->rawbuf +
1175                 (PAGE_SIZE << dmabuf->buforder) - 1);
1176
1177         // 2. mark each physical page in range as 'reserved'.
1178         for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1179                 cs4x_mem_map_reserve(map);
1180
1181         CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1182                PAGE_SIZE << order, order, rawbuf) );
1183
1184 /*
1185 *  only allocate the conversion buffer for the ADC
1186 */
1187         if(dmabuf->type == CS_TYPE_DAC)
1188         {
1189                 dmabuf->tmpbuff = NULL;
1190                 dmabuf->buforder_tmpbuff = 0;
1191                 return 0;
1192         }
1193 /*
1194  * now the temp buffer for 16/8 conversions
1195  */
1196
1197         tmpbuff = (void *) pci_alloc_consistent(
1198                 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1199
1200         if (!tmpbuff)
1201                 return -ENOMEM;
1202         CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1203                PAGE_SIZE << order, order, tmpbuff) );
1204
1205         dmabuf->tmpbuff = tmpbuff;
1206         dmabuf->buforder_tmpbuff = order;
1207
1208         // Now mark the pages as reserved; otherwise the
1209         // remap_pfn_range() in cs46xx_mmap doesn't work.
1210         // 1. get index to last page in mem_map array for rawbuf.
1211         mapend = virt_to_page(dmabuf->tmpbuff +
1212                 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1213
1214         // 2. mark each physical page in range as 'reserved'.
1215         for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1216                 cs4x_mem_map_reserve(map);
1217         return 0;
1218 }
1219
1220 /* free DMA buffer */
1221 static void dealloc_dmabuf(struct cs_state *state)
1222 {
1223         struct dmabuf *dmabuf = &state->dmabuf;
1224         struct page *map, *mapend;
1225
1226         if (dmabuf->rawbuf) {
1227                 // Undo prog_dmabuf()'s marking the pages as reserved
1228                 mapend = virt_to_page(dmabuf->rawbuf +
1229                                 (PAGE_SIZE << dmabuf->buforder) - 1);
1230                 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1231                         cs4x_mem_map_unreserve(map);
1232                 free_dmabuf(state->card, dmabuf);
1233         }
1234
1235         if (dmabuf->tmpbuff) {
1236                 // Undo prog_dmabuf()'s marking the pages as reserved
1237                 mapend = virt_to_page(dmabuf->tmpbuff +
1238                                 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1239                 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1240                         cs4x_mem_map_unreserve(map);
1241                 free_dmabuf2(state->card, dmabuf);
1242         }
1243
1244         dmabuf->rawbuf = NULL;
1245         dmabuf->tmpbuff = NULL;
1246         dmabuf->mapped = dmabuf->ready = 0;
1247         dmabuf->SGok = 0;
1248 }
1249
1250 static int __prog_dmabuf(struct cs_state *state)
1251 {
1252         struct dmabuf *dmabuf = &state->dmabuf;
1253         unsigned long flags;
1254         unsigned long allocated_pages, allocated_bytes;
1255         unsigned long tmp1, tmp2, fmt=0;
1256         unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1257         unsigned long SGarray[9], nSGpages=0;
1258         int ret;
1259
1260         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1261 /*
1262  * check for CAPTURE and use only non-sg for initial release
1263  */
1264         if(dmabuf->type == CS_TYPE_ADC)
1265         {
1266                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1267                 /*
1268                  * add in non-sg support for capture.
1269                  */
1270                 spin_lock_irqsave(&state->card->lock, flags);
1271         /* add code to reset the rawbuf memory. TRW */
1272                 resync_dma_ptrs(state);
1273                 dmabuf->total_bytes = dmabuf->blocks = 0;
1274                 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1275
1276                 dmabuf->SGok = 0;
1277
1278                 spin_unlock_irqrestore(&state->card->lock, flags);
1279
1280                 /* allocate DMA buffer if not allocated yet */
1281                 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1282                         if ((ret = alloc_dmabuf(state)))
1283                                 return ret;
1284         /*
1285          * static image only supports 16Bit signed, stereo - hard code fmt
1286          */
1287                 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1288
1289                 dmabuf->numfrag = 2;
1290                 dmabuf->fragsize = 2048;
1291                 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1292                 dmabuf->dmasize = 4096;
1293                 dmabuf->fragshift = 11;
1294
1295                 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1296                        dmabuf->dmasize);
1297                 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1298                         PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1299
1300                 /*
1301                  *      Now set up the ring
1302                  */
1303
1304                 spin_lock_irqsave(&state->card->lock, flags);
1305                 cs_rec_setup(state);
1306                 spin_unlock_irqrestore(&state->card->lock, flags);
1307
1308                 /* set the ready flag for the dma buffer */
1309                 dmabuf->ready = 1;
1310
1311                 CS_DBGOUT(CS_PARMS, 4, printk(
1312                         "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1313                         "fragsize=%d dmasize=%d\n",
1314                             dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1315                             dmabuf->fragsize, dmabuf->dmasize) );
1316
1317                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1318                 return 0;
1319         }
1320         else if (dmabuf->type == CS_TYPE_DAC)
1321         {
1322         /*
1323          * Must be DAC
1324          */
1325                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1326                 spin_lock_irqsave(&state->card->lock, flags);
1327                 resync_dma_ptrs(state);
1328                 dmabuf->total_bytes = dmabuf->blocks = 0;
1329                 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1330
1331                 dmabuf->SGok = 0;
1332
1333                 spin_unlock_irqrestore(&state->card->lock, flags);
1334
1335                 /* allocate DMA buffer if not allocated yet */
1336                 if (!dmabuf->rawbuf)
1337                         if ((ret = alloc_dmabuf(state)))
1338                                 return ret;
1339
1340                 allocated_pages = 1 << dmabuf->buforder;
1341                 allocated_bytes = allocated_pages*PAGE_SIZE;
1342
1343                 if(allocated_pages < 2)
1344                 {
1345                         CS_DBGOUT(CS_FUNCTION, 4, printk(
1346                             "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1347                                 (unsigned)allocated_pages));
1348                         return -ENOMEM;
1349                 }
1350
1351                 /* Use all the pages allocated, fragsize 4k. */
1352                 /* Use 'pbuf' for S/G page map table. */
1353                 dmabuf->SGok = 1;           /* Use S/G. */
1354
1355                 nSGpages = allocated_bytes/4096;    /* S/G pages always 4k. */
1356
1357                      /* Set up S/G variables. */
1358                 *ptmp = virt_to_bus(dmabuf->rawbuf);
1359                 *(ptmp+1) = 0x00000008;
1360                 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1361                         *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1362                         if( tmp1 == nSGpages-1)
1363                                 tmp2 = 0xbfff0000;
1364                         else
1365                                 tmp2 = 0x80000000+8*(tmp1+1);
1366                         *(ptmp+2*tmp1+1) = tmp2;
1367                 }
1368                 SGarray[0] = 0x82c0200d;
1369                 SGarray[1] = 0xffff0000;
1370                 SGarray[2] = *ptmp;
1371                 SGarray[3] = 0x00010600;
1372                 SGarray[4] = *(ptmp+2);
1373                 SGarray[5] = 0x80000010;
1374                 SGarray[6] = *ptmp;
1375                 SGarray[7] = *(ptmp+2);
1376                 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1377
1378                 if (dmabuf->SGok) {
1379                         dmabuf->numfrag = nSGpages;
1380                         dmabuf->fragsize = 4096;
1381                         dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1382                         dmabuf->fragshift = 12;
1383                         dmabuf->dmasize = dmabuf->numfrag*4096;
1384                 }
1385                 else {
1386                         SGarray[0] = 0xf2c0000f;
1387                         SGarray[1] = 0x00000200;
1388                         SGarray[2] = 0;
1389                         SGarray[3] = 0x00010600;
1390                         SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1391                         dmabuf->numfrag = 2;
1392                         dmabuf->fragsize = 2048;
1393                         dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1394                         dmabuf->dmasize = 4096;
1395                         dmabuf->fragshift = 11;
1396                 }
1397                 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1398                         cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1399
1400                 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1401                        dmabuf->dmasize);
1402
1403                 /*
1404                  *      Now set up the ring
1405                  */
1406
1407                 spin_lock_irqsave(&state->card->lock, flags);
1408                 cs_play_setup(state);
1409                 spin_unlock_irqrestore(&state->card->lock, flags);
1410
1411                 /* set the ready flag for the dma buffer */
1412                 dmabuf->ready = 1;
1413
1414                 CS_DBGOUT(CS_PARMS, 4, printk(
1415                         "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1416                         "fragsize=%d dmasize=%d\n",
1417                             dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1418                             dmabuf->fragsize, dmabuf->dmasize) );
1419
1420                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1421                 return 0;
1422         }
1423         else
1424         {
1425                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1426                         dmabuf->type));
1427         }
1428         return 1;
1429 }
1430
1431 static int prog_dmabuf(struct cs_state *state)
1432 {
1433         int ret;
1434
1435         down(&state->sem);
1436         ret = __prog_dmabuf(state);
1437         up(&state->sem);
1438
1439         return ret;
1440 }
1441
1442 static void cs_clear_tail(struct cs_state *state)
1443 {
1444 }
1445
1446 static int drain_dac(struct cs_state *state, int nonblock)
1447 {
1448         DECLARE_WAITQUEUE(wait, current);
1449         struct dmabuf *dmabuf = &state->dmabuf;
1450         struct cs_card *card=state->card;
1451         unsigned long flags;
1452         unsigned long tmo;
1453         int count;
1454
1455         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1456         if (dmabuf->mapped || !dmabuf->ready)
1457         {
1458                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1459                 return 0;
1460         }
1461
1462         add_wait_queue(&dmabuf->wait, &wait);
1463         for (;;) {
1464                 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1465                    every time to make the process really go to sleep */
1466                 current->state = TASK_INTERRUPTIBLE;
1467
1468                 spin_lock_irqsave(&state->card->lock, flags);
1469                 count = dmabuf->count;
1470                 spin_unlock_irqrestore(&state->card->lock, flags);
1471
1472                 if (count <= 0)
1473                         break;
1474
1475                 if (signal_pending(current))
1476                         break;
1477
1478                 if (nonblock) {
1479                         remove_wait_queue(&dmabuf->wait, &wait);
1480                         current->state = TASK_RUNNING;
1481                         return -EBUSY;
1482                 }
1483
1484                 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1485                 tmo >>= sample_shift[dmabuf->fmt];
1486                 tmo += (2048*HZ)/dmabuf->rate;
1487
1488                 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1489                         printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1490                         break;
1491                 }
1492         }
1493         remove_wait_queue(&dmabuf->wait, &wait);
1494         current->state = TASK_RUNNING;
1495         if (signal_pending(current))
1496         {
1497                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1498                 /*
1499                 * set to silence and let that clear the fifos.
1500                 */
1501                 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1502                 return -ERESTARTSYS;
1503         }
1504
1505         CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1506         return 0;
1507 }
1508
1509
1510 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1511 static void cs_update_ptr(struct cs_card *card, int wake)
1512 {
1513         struct cs_state *state;
1514         struct dmabuf *dmabuf;
1515         unsigned hwptr;
1516         int diff;
1517
1518         /* error handling and process wake up for ADC */
1519         state = card->states[0];
1520         if(state)
1521         {
1522                 dmabuf = &state->dmabuf;
1523                 if (dmabuf->enable & ADC_RUNNING) {
1524                         /* update hardware pointer */
1525                         hwptr = cs_get_dma_addr(state);
1526
1527                         diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1528                         CS_DBGOUT(CS_PARMS, 9, printk(
1529                                 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1530                                 hwptr,diff) );
1531                         dmabuf->hwptr = hwptr;
1532                         dmabuf->total_bytes += diff;
1533                         dmabuf->count += diff;
1534                         if (dmabuf->count > dmabuf->dmasize)
1535                                 dmabuf->count = dmabuf->dmasize;
1536
1537                         if(dmabuf->mapped)
1538                         {
1539                                 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1540                                         wake_up(&dmabuf->wait);
1541                         } else
1542                         {
1543                                 if (wake && dmabuf->count > 0)
1544                                         wake_up(&dmabuf->wait);
1545                         }
1546                 }
1547         }
1548
1549 /*
1550  * Now the DAC
1551  */
1552         state = card->states[1];
1553         if(state)
1554         {
1555                 dmabuf = &state->dmabuf;
1556                 /* error handling and process wake up for DAC */
1557                 if (dmabuf->enable & DAC_RUNNING) {
1558                         /* update hardware pointer */
1559                         hwptr = cs_get_dma_addr(state);
1560
1561                         diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1562                         CS_DBGOUT(CS_PARMS, 9, printk(
1563                                 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1564                                 hwptr,diff) );
1565                         dmabuf->hwptr = hwptr;
1566                         dmabuf->total_bytes += diff;
1567                         if (dmabuf->mapped) {
1568                                 dmabuf->count += diff;
1569                                 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1570                                         wake_up(&dmabuf->wait);
1571                                 /*
1572                                  * other drivers use fragsize, but don't see any sense
1573                                  * in that, since dmasize is the buffer asked for
1574                                  * via mmap.
1575                                  */
1576                                 if( dmabuf->count > dmabuf->dmasize)
1577                                         dmabuf->count &= dmabuf->dmasize-1;
1578                         } else {
1579                                 dmabuf->count -= diff;
1580                                 /*
1581                                  * backfill with silence and clear out the last
1582                                  * "diff" number of bytes.
1583                                  */
1584                                 if(hwptr >= diff)
1585                                 {
1586                                         memset(dmabuf->rawbuf + hwptr - diff,
1587                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1588                                 }
1589                                 else
1590                                 {
1591                                         memset(dmabuf->rawbuf,
1592                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1593                                                 (unsigned)hwptr);
1594                                         memset((char *)dmabuf->rawbuf +
1595                                                         dmabuf->dmasize + hwptr - diff,
1596                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1597                                                 diff - hwptr);
1598                                 }
1599
1600                                 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1601                                         CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1602                                           "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1603                                                 dmabuf->count));
1604                                         /*
1605                                         * buffer underrun or buffer overrun, reset the
1606                                         * count of bytes written back to 0.
1607                                         */
1608                                         if(dmabuf->count < 0)
1609                                                 dmabuf->underrun=1;
1610                                         dmabuf->count = 0;
1611                                         dmabuf->error++;
1612                                 }
1613                                 if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
1614                                         wake_up(&dmabuf->wait);
1615                         }
1616                 }
1617         }
1618 }
1619
1620
1621 /* hold spinlock for the following! */
1622 static void cs_handle_midi(struct cs_card *card)
1623 {
1624         unsigned char ch;
1625         int wake;
1626         unsigned temp1;
1627
1628         wake = 0;
1629         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_RBE)) {
1630                 ch = cs461x_peekBA0(card, BA0_MIDRP);
1631                 if (card->midi.icnt < CS_MIDIINBUF) {
1632                         card->midi.ibuf[card->midi.iwr] = ch;
1633                         card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1634                         card->midi.icnt++;
1635                 }
1636                 wake = 1;
1637         }
1638         if (wake)
1639                 wake_up(&card->midi.iwait);
1640         wake = 0;
1641         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1642                 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1643                 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1644                 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1645                 card->midi.ocnt--;
1646                 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1647                         wake = 1;
1648         }
1649         if (wake)
1650                 wake_up(&card->midi.owait);
1651 }
1652
1653 static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1654 {
1655         struct cs_card *card = (struct cs_card *)dev_id;
1656         /* Single channel card */
1657         struct cs_state *recstate = card->channel[0].state;
1658         struct cs_state *playstate = card->channel[1].state;
1659         u32 status;
1660
1661         CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1662
1663         spin_lock(&card->lock);
1664
1665         status = cs461x_peekBA0(card, BA0_HISR);
1666
1667         if ((status & 0x7fffffff) == 0)
1668         {
1669                 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1670                 spin_unlock(&card->lock);
1671                 return IRQ_HANDLED;     /* Might be IRQ_NONE.. */
1672         }
1673
1674         /*
1675          * check for playback or capture interrupt only
1676          */
1677         if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1678             (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1679         {
1680                 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1681                         "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1682                 cs_update_ptr(card, CS_TRUE);
1683         }
1684
1685         if( status & HISR_MIDI )
1686                 cs_handle_midi(card);
1687
1688         /* clear 'em */
1689         cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1690         spin_unlock(&card->lock);
1691         CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1692         return IRQ_HANDLED;
1693 }
1694
1695
1696 /**********************************************************************/
1697
1698 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1699 {
1700         struct cs_card *card = (struct cs_card *)file->private_data;
1701         ssize_t ret;
1702         unsigned long flags;
1703         unsigned ptr;
1704         int cnt;
1705
1706         if (!access_ok(VERIFY_WRITE, buffer, count))
1707                 return -EFAULT;
1708         ret = 0;
1709         while (count > 0) {
1710                 spin_lock_irqsave(&card->lock, flags);
1711                 ptr = card->midi.ird;
1712                 cnt = CS_MIDIINBUF - ptr;
1713                 if (card->midi.icnt < cnt)
1714                         cnt = card->midi.icnt;
1715                 spin_unlock_irqrestore(&card->lock, flags);
1716                 if (cnt > count)
1717                         cnt = count;
1718                 if (cnt <= 0) {
1719                         if (file->f_flags & O_NONBLOCK)
1720                                 return ret ? ret : -EAGAIN;
1721                         interruptible_sleep_on(&card->midi.iwait);
1722                         if (signal_pending(current))
1723                                 return ret ? ret : -ERESTARTSYS;
1724                         continue;
1725                 }
1726                 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1727                         return ret ? ret : -EFAULT;
1728                 ptr = (ptr + cnt) % CS_MIDIINBUF;
1729                 spin_lock_irqsave(&card->lock, flags);
1730                 card->midi.ird = ptr;
1731                 card->midi.icnt -= cnt;
1732                 spin_unlock_irqrestore(&card->lock, flags);
1733                 count -= cnt;
1734                 buffer += cnt;
1735                 ret += cnt;
1736         }
1737         return ret;
1738 }
1739
1740
1741 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1742 {
1743         struct cs_card *card = (struct cs_card *)file->private_data;
1744         ssize_t ret;
1745         unsigned long flags;
1746         unsigned ptr;
1747         int cnt;
1748
1749         if (!access_ok(VERIFY_READ, buffer, count))
1750                 return -EFAULT;
1751         ret = 0;
1752         while (count > 0) {
1753                 spin_lock_irqsave(&card->lock, flags);
1754                 ptr = card->midi.owr;
1755                 cnt = CS_MIDIOUTBUF - ptr;
1756                 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1757                         cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1758                 if (cnt <= 0)
1759                         cs_handle_midi(card);
1760                 spin_unlock_irqrestore(&card->lock, flags);
1761                 if (cnt > count)
1762                         cnt = count;
1763                 if (cnt <= 0) {
1764                         if (file->f_flags & O_NONBLOCK)
1765                                 return ret ? ret : -EAGAIN;
1766                         interruptible_sleep_on(&card->midi.owait);
1767                         if (signal_pending(current))
1768                                 return ret ? ret : -ERESTARTSYS;
1769                         continue;
1770                 }
1771                 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1772                         return ret ? ret : -EFAULT;
1773                 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1774                 spin_lock_irqsave(&card->lock, flags);
1775                 card->midi.owr = ptr;
1776                 card->midi.ocnt += cnt;
1777                 spin_unlock_irqrestore(&card->lock, flags);
1778                 count -= cnt;
1779                 buffer += cnt;
1780                 ret += cnt;
1781                 spin_lock_irqsave(&card->lock, flags);
1782                 cs_handle_midi(card);
1783                 spin_unlock_irqrestore(&card->lock, flags);
1784         }
1785         return ret;
1786 }
1787
1788
1789 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1790 {
1791         struct cs_card *card = (struct cs_card *)file->private_data;
1792         unsigned long flags;
1793         unsigned int mask = 0;
1794
1795         if (file->f_flags & FMODE_WRITE)
1796                 poll_wait(file, &card->midi.owait, wait);
1797         if (file->f_flags & FMODE_READ)
1798                 poll_wait(file, &card->midi.iwait, wait);
1799         spin_lock_irqsave(&card->lock, flags);
1800         if (file->f_flags & FMODE_READ) {
1801                 if (card->midi.icnt > 0)
1802                         mask |= POLLIN | POLLRDNORM;
1803         }
1804         if (file->f_flags & FMODE_WRITE) {
1805                 if (card->midi.ocnt < CS_MIDIOUTBUF)
1806                         mask |= POLLOUT | POLLWRNORM;
1807         }
1808         spin_unlock_irqrestore(&card->lock, flags);
1809         return mask;
1810 }
1811
1812
1813 static int cs_midi_open(struct inode *inode, struct file *file)
1814 {
1815         unsigned int minor = iminor(inode);
1816         struct cs_card *card=NULL;
1817         unsigned long flags;
1818         struct list_head *entry;
1819
1820         list_for_each(entry, &cs46xx_devs)
1821         {
1822                 card = list_entry(entry, struct cs_card, list);
1823                 if (card->dev_midi == minor)
1824                         break;
1825         }
1826
1827         if (entry == &cs46xx_devs)
1828                 return -ENODEV;
1829         if (!card)
1830         {
1831                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1832                         "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1833                 return -ENODEV;
1834         }
1835
1836         file->private_data = card;
1837         /* wait for device to become free */
1838         down(&card->midi.open_sem);
1839         while (card->midi.open_mode & file->f_mode) {
1840                 if (file->f_flags & O_NONBLOCK) {
1841                         up(&card->midi.open_sem);
1842                         return -EBUSY;
1843                 }
1844                 up(&card->midi.open_sem);
1845                 interruptible_sleep_on(&card->midi.open_wait);
1846                 if (signal_pending(current))
1847                         return -ERESTARTSYS;
1848                 down(&card->midi.open_sem);
1849         }
1850         spin_lock_irqsave(&card->midi.lock, flags);
1851         if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1852                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1853                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1854                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1855                 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f);            /* Enable xmit, rcv. */
1856                 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);   /* Enable interrupts */
1857         }
1858         if (file->f_mode & FMODE_READ) {
1859                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1860         }
1861         if (file->f_mode & FMODE_WRITE) {
1862                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1863         }
1864         spin_unlock_irqrestore(&card->midi.lock, flags);
1865         card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1866         up(&card->midi.open_sem);
1867         return 0;
1868 }
1869
1870
1871 static int cs_midi_release(struct inode *inode, struct file *file)
1872 {
1873         struct cs_card *card = (struct cs_card *)file->private_data;
1874         DECLARE_WAITQUEUE(wait, current);
1875         unsigned long flags;
1876         unsigned count, tmo;
1877
1878         if (file->f_mode & FMODE_WRITE) {
1879                 current->state = TASK_INTERRUPTIBLE;
1880                 add_wait_queue(&card->midi.owait, &wait);
1881                 for (;;) {
1882                         spin_lock_irqsave(&card->midi.lock, flags);
1883                         count = card->midi.ocnt;
1884                         spin_unlock_irqrestore(&card->midi.lock, flags);
1885                         if (count <= 0)
1886                                 break;
1887                         if (signal_pending(current))
1888                                 break;
1889                         if (file->f_flags & O_NONBLOCK)
1890                                 break;
1891                         tmo = (count * HZ) / 3100;
1892                         if (!schedule_timeout(tmo ? : 1) && tmo)
1893                                 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1894                 }
1895                 remove_wait_queue(&card->midi.owait, &wait);
1896                 current->state = TASK_RUNNING;
1897         }
1898         down(&card->midi.open_sem);
1899         card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1900         up(&card->midi.open_sem);
1901         wake_up(&card->midi.open_wait);
1902         return 0;
1903 }
1904
1905 /*
1906  *   Midi file operations struct.
1907  */
1908 static /*const*/ struct file_operations cs_midi_fops = {
1909         CS_OWNER        CS_THIS_MODULE
1910         .llseek         = no_llseek,
1911         .read           = cs_midi_read,
1912         .write          = cs_midi_write,
1913         .poll           = cs_midi_poll,
1914         .open           = cs_midi_open,
1915         .release        = cs_midi_release,
1916 };
1917
1918 /*
1919  *
1920  * CopySamples copies 16-bit stereo signed samples from the source to the
1921  * destination, possibly converting down to unsigned 8-bit and/or mono.
1922  * count specifies the number of output bytes to write.
1923  *
1924  *  Arguments:
1925  *
1926  *  dst             - Pointer to a destination buffer.
1927  *  src             - Pointer to a source buffer
1928  *  count           - The number of bytes to copy into the destination buffer.
1929  *  fmt             - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1930  *  dmabuf          - pointer to the dma buffer structure
1931  *
1932  * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1933  *
1934  *
1935  */
1936 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1937                 struct dmabuf *dmabuf)
1938 {
1939
1940     s32 s32AudioSample;
1941     s16 *psSrc=(s16 *)src;
1942     s16 *psDst=(s16 *)dst;
1943     u8 *pucDst=(u8 *)dst;
1944
1945     CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1946     CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1947         " dst=%p src=%p count=%d fmt=0x%x\n",
1948         dst,src,count,fmt) );
1949
1950     /*
1951      * See if the data should be output as 8-bit unsigned stereo.
1952      */
1953     if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1954     {
1955         /*
1956          * Convert each 16-bit signed stereo sample to 8-bit unsigned
1957          * stereo using rounding.
1958          */
1959         psSrc = (s16 *)src;
1960         count = count/2;
1961         while(count--)
1962         {
1963             *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1964         }
1965     }
1966     /*
1967      * See if the data should be output at 8-bit unsigned mono.
1968      */
1969     else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1970     {
1971         /*
1972          * Convert each 16-bit signed stereo sample to 8-bit unsigned
1973          * mono using averaging and rounding.
1974          */
1975         psSrc = (s16 *)src;
1976         count = count/2;
1977         while(count--)
1978         {
1979             s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
1980             if(s32AudioSample > 0x7fff)
1981                 s32AudioSample = 0x7fff;
1982             *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
1983             psSrc += 2;
1984         }
1985     }
1986     /*
1987      * See if the data should be output at 16-bit signed mono.
1988      */
1989     else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
1990     {
1991         /*
1992          * Convert each 16-bit signed stereo sample to 16-bit signed
1993          * mono using averaging.
1994          */
1995         psSrc = (s16 *)src;
1996         count = count/2;
1997         while(count--)
1998         {
1999             *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
2000             psSrc += 2;
2001         }
2002     }
2003 }
2004
2005 /*
2006  * cs_copy_to_user()
2007  * replacement for the standard copy_to_user, to allow for a conversion from
2008  * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
2009  * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
2010  * so we convert from any of the other format combinations.
2011  */
2012 static unsigned cs_copy_to_user(
2013         struct cs_state *s,
2014         void __user *dest,
2015         void *hwsrc,
2016         unsigned cnt,
2017         unsigned *copied)
2018 {
2019         struct dmabuf *dmabuf = &s->dmabuf;
2020         void *src = hwsrc;  /* default to the standard destination buffer addr */
2021
2022         CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
2023                 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
2024                 dmabuf->fmt,(unsigned)cnt,dest) );
2025
2026         if(cnt > dmabuf->dmasize)
2027         {
2028                 cnt = dmabuf->dmasize;
2029         }
2030         if(!cnt)
2031         {
2032                 *copied = 0;
2033                 return 0;
2034         }
2035         if(dmabuf->divisor != 1)
2036         {
2037                 if(!dmabuf->tmpbuff)
2038                 {
2039                         *copied = cnt/dmabuf->divisor;
2040                         return 0;
2041                 }
2042
2043                 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
2044                         dmabuf->fmt, dmabuf);
2045                 src = dmabuf->tmpbuff;
2046                 cnt = cnt/dmabuf->divisor;
2047         }
2048         if (copy_to_user(dest, src, cnt))
2049         {
2050                 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
2051                         "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2052                                 dest,src,cnt) );
2053                 *copied = 0;
2054                 return -EFAULT;
2055         }
2056         *copied = cnt;
2057         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2058                 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
2059         return 0;
2060 }
2061
2062 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2063    the user's buffer.  it is filled by the dma machine and drained by this loop. */
2064 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2065 {
2066         struct cs_card *card = (struct cs_card *) file->private_data;
2067         struct cs_state *state;
2068         DECLARE_WAITQUEUE(wait, current);
2069         struct dmabuf *dmabuf;
2070         ssize_t ret = 0;
2071         unsigned long flags;
2072         unsigned swptr;
2073         int cnt;
2074         unsigned copied=0;
2075
2076         CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2077                 printk("cs46xx: cs_read()+ %zd\n",count) );
2078         state = (struct cs_state *)card->states[0];
2079         if(!state)
2080                 return -ENODEV;
2081         dmabuf = &state->dmabuf;
2082
2083         if (dmabuf->mapped)
2084                 return -ENXIO;
2085         if (!access_ok(VERIFY_WRITE, buffer, count))
2086                 return -EFAULT;
2087
2088         down(&state->sem);
2089         if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2090                 goto out2;
2091
2092         add_wait_queue(&state->dmabuf.wait, &wait);
2093         while (count > 0) {
2094                 while(!(card->pm.flags & CS46XX_PM_IDLE))
2095                 {
2096                         schedule();
2097                         if (signal_pending(current)) {
2098                                 if(!ret) ret = -ERESTARTSYS;
2099                                 goto out;
2100                         }
2101                 }
2102                 spin_lock_irqsave(&state->card->lock, flags);
2103                 swptr = dmabuf->swptr;
2104                 cnt = dmabuf->dmasize - swptr;
2105                 if (dmabuf->count < cnt)
2106                         cnt = dmabuf->count;
2107                 if (cnt <= 0)
2108                         __set_current_state(TASK_INTERRUPTIBLE);
2109                 spin_unlock_irqrestore(&state->card->lock, flags);
2110
2111                 if (cnt > (count * dmabuf->divisor))
2112                         cnt = count * dmabuf->divisor;
2113                 if (cnt <= 0) {
2114                         /* buffer is empty, start the dma machine and wait for data to be
2115                            recorded */
2116                         start_adc(state);
2117                         if (file->f_flags & O_NONBLOCK) {
2118                                 if (!ret) ret = -EAGAIN;
2119                                 goto out;
2120                         }
2121                         up(&state->sem);
2122                         schedule();
2123                         if (signal_pending(current)) {
2124                                 if(!ret) ret = -ERESTARTSYS;
2125                                 goto out;
2126                         }
2127                         down(&state->sem);
2128                         if (dmabuf->mapped)
2129                         {
2130                                 if(!ret)
2131                                         ret = -ENXIO;
2132                                 goto out;
2133                         }
2134                         continue;
2135                 }
2136
2137                 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2138                         "_read() copy_to cnt=%d count=%zd ", cnt,count) );
2139                 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2140                         " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
2141                         dmabuf->dmasize,dmabuf->count,buffer,ret) );
2142
2143                 if (cs_copy_to_user(state, buffer,
2144                         (char *)dmabuf->rawbuf + swptr, cnt, &copied))
2145                 {
2146                         if (!ret) ret = -EFAULT;
2147                         goto out;
2148                 }
2149                 swptr = (swptr + cnt) % dmabuf->dmasize;
2150                 spin_lock_irqsave(&card->lock, flags);
2151                 dmabuf->swptr = swptr;
2152                 dmabuf->count -= cnt;
2153                 spin_unlock_irqrestore(&card->lock, flags);
2154                 count -= copied;
2155                 buffer += copied;
2156                 ret += copied;
2157                 start_adc(state);
2158         }
2159 out:
2160         remove_wait_queue(&state->dmabuf.wait, &wait);
2161 out2:
2162         up(&state->sem);
2163         set_current_state(TASK_RUNNING);
2164         CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2165                 printk("cs46xx: cs_read()- %zd\n",ret) );
2166         return ret;
2167 }
2168
2169 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2170    the soundcard.  it is drained by the dma machine and filled by this loop. */
2171 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2172 {
2173         struct cs_card *card = (struct cs_card *) file->private_data;
2174         struct cs_state *state;
2175         DECLARE_WAITQUEUE(wait, current);
2176         struct dmabuf *dmabuf;
2177         ssize_t ret;
2178         unsigned long flags;
2179         unsigned swptr;
2180         int cnt;
2181
2182         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2183                 printk("cs46xx: cs_write called, count = %zd\n", count) );
2184         state = (struct cs_state *)card->states[1];
2185         if(!state)
2186                 return -ENODEV;
2187         if (!access_ok(VERIFY_READ, buffer, count))
2188                 return -EFAULT;
2189         dmabuf = &state->dmabuf;
2190
2191         down(&state->sem);
2192         if (dmabuf->mapped)
2193         {
2194                 ret = -ENXIO;
2195                 goto out;
2196         }
2197
2198         if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2199                 goto out;
2200         add_wait_queue(&state->dmabuf.wait, &wait);
2201         ret = 0;
2202 /*
2203 * Start the loop to read from the user's buffer and write to the dma buffer.
2204 * check for PM events and underrun/overrun in the loop.
2205 */
2206         while (count > 0) {
2207                 while(!(card->pm.flags & CS46XX_PM_IDLE))
2208                 {
2209                         schedule();
2210                         if (signal_pending(current)) {
2211                                 if(!ret) ret = -ERESTARTSYS;
2212                                 goto out;
2213                         }
2214                 }
2215                 spin_lock_irqsave(&state->card->lock, flags);
2216                 if (dmabuf->count < 0) {
2217                         /* buffer underrun, we are recovering from sleep_on_timeout,
2218                            resync hwptr and swptr */
2219                         dmabuf->count = 0;
2220                         dmabuf->swptr = dmabuf->hwptr;
2221                 }
2222                 if (dmabuf->underrun)
2223                 {
2224                         dmabuf->underrun = 0;
2225                         dmabuf->hwptr = cs_get_dma_addr(state);
2226                         dmabuf->swptr = dmabuf->hwptr;
2227                 }
2228
2229                 swptr = dmabuf->swptr;
2230                 cnt = dmabuf->dmasize - swptr;
2231                 if (dmabuf->count + cnt > dmabuf->dmasize)
2232                         cnt = dmabuf->dmasize - dmabuf->count;
2233                 if (cnt <= 0)
2234                         __set_current_state(TASK_INTERRUPTIBLE);
2235                 spin_unlock_irqrestore(&state->card->lock, flags);
2236
2237                 if (cnt > count)
2238                         cnt = count;
2239                 if (cnt <= 0) {
2240                         /* buffer is full, start the dma machine and wait for data to be
2241                            played */
2242                         start_dac(state);
2243                         if (file->f_flags & O_NONBLOCK) {
2244                                 if (!ret) ret = -EAGAIN;
2245                                 goto out;
2246                         }
2247                         up(&state->sem);
2248                         schedule();
2249                         if (signal_pending(current)) {
2250                                 if(!ret) ret = -ERESTARTSYS;
2251                                 goto out;
2252                         }
2253                         down(&state->sem);
2254                         if (dmabuf->mapped)
2255                         {
2256                                 if(!ret)
2257                                         ret = -ENXIO;
2258                                 goto out;
2259                         }
2260                         continue;
2261                 }
2262                 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2263                         if (!ret) ret = -EFAULT;
2264                         goto out;
2265                 }
2266                 spin_lock_irqsave(&state->card->lock, flags);
2267                 swptr = (swptr + cnt) % dmabuf->dmasize;
2268                 dmabuf->swptr = swptr;
2269                 dmabuf->count += cnt;
2270                 if(dmabuf->count > dmabuf->dmasize)
2271                 {
2272                         CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2273                             "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2274                         dmabuf->count = dmabuf->dmasize;
2275                 }
2276                 dmabuf->endcleared = 0;
2277                 spin_unlock_irqrestore(&state->card->lock, flags);
2278
2279                 count -= cnt;
2280                 buffer += cnt;
2281                 ret += cnt;
2282                 start_dac(state);
2283         }
2284 out:
2285         up(&state->sem);
2286         remove_wait_queue(&state->dmabuf.wait, &wait);
2287         set_current_state(TASK_RUNNING);
2288
2289         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2290                 printk("cs46xx: cs_write()- ret=%zd\n", ret) );
2291         return ret;
2292 }
2293
2294 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2295 {
2296         struct cs_card *card = (struct cs_card *)file->private_data;
2297         struct dmabuf *dmabuf;
2298         struct cs_state *state;
2299
2300         unsigned long flags;
2301         unsigned int mask = 0;
2302
2303         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2304         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2305         {
2306                 return -EINVAL;
2307         }
2308         if (file->f_mode & FMODE_WRITE)
2309         {
2310                 state = card->states[1];
2311                 if(state)
2312                 {
2313                         dmabuf = &state->dmabuf;
2314                         poll_wait(file, &dmabuf->wait, wait);
2315                 }
2316         }
2317         if (file->f_mode & FMODE_READ)
2318         {
2319                 state = card->states[0];
2320                 if(state)
2321                 {
2322                         dmabuf = &state->dmabuf;
2323                         poll_wait(file, &dmabuf->wait, wait);
2324                 }
2325         }
2326
2327         spin_lock_irqsave(&card->lock, flags);
2328         cs_update_ptr(card, CS_FALSE);
2329         if (file->f_mode & FMODE_READ) {
2330                 state = card->states[0];
2331                 if(state)
2332                 {
2333                         dmabuf = &state->dmabuf;
2334                         if (dmabuf->count >= (signed)dmabuf->fragsize)
2335                                 mask |= POLLIN | POLLRDNORM;
2336                 }
2337         }
2338         if (file->f_mode & FMODE_WRITE) {
2339                 state = card->states[1];
2340                 if(state)
2341                 {
2342                         dmabuf = &state->dmabuf;
2343                         if (dmabuf->mapped) {
2344                                 if (dmabuf->count >= (signed)dmabuf->fragsize)
2345                                     mask |= POLLOUT | POLLWRNORM;
2346                         } else {
2347                                 if ((signed)dmabuf->dmasize >= dmabuf->count
2348                                         + (signed)dmabuf->fragsize)
2349                                     mask |= POLLOUT | POLLWRNORM;
2350                         }
2351                 }
2352         }
2353         spin_unlock_irqrestore(&card->lock, flags);
2354
2355         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2356                 mask));
2357         return mask;
2358 }
2359
2360 /*
2361  *      We let users mmap the ring buffer. Its not the real DMA buffer but
2362  *      that side of the code is hidden in the IRQ handling. We do a software
2363  *      emulation of DMA from a 64K or so buffer into a 2K FIFO.
2364  *      (the hardware probably deserves a moan here but Crystal send me nice
2365  *      toys ;)).
2366  */
2367
2368 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2369 {
2370         struct cs_card *card = (struct cs_card *)file->private_data;
2371         struct cs_state *state;
2372         struct dmabuf *dmabuf;
2373         int ret = 0;
2374         unsigned long size;
2375
2376         CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
2377                 file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2378                 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2379
2380         if (vma->vm_flags & VM_WRITE) {
2381                 state = card->states[1];
2382                 if(state)
2383                 {
2384                         CS_DBGOUT(CS_OPEN, 2, printk(
2385                           "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2386                         if ((ret = prog_dmabuf(state)) != 0)
2387                                 return ret;
2388                 }
2389         } else if (vma->vm_flags & VM_READ) {
2390                 state = card->states[0];
2391                 if(state)
2392                 {
2393                         CS_DBGOUT(CS_OPEN, 2, printk(
2394                           "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2395                         if ((ret = prog_dmabuf(state)) != 0)
2396                                 return ret;
2397                 }
2398         } else {
2399                 CS_DBGOUT(CS_ERROR, 2, printk(
2400                   "cs46xx: cs_mmap() return -EINVAL\n") );
2401                 return -EINVAL;
2402         }
2403
2404 /*
2405  * For now ONLY support playback, but seems like the only way to use
2406  * mmap() is to open an FD with RDWR, just read or just write access
2407  * does not function, get an error back from the kernel.
2408  * Also, QuakeIII opens with RDWR!  So, there must be something
2409  * to needing read/write access mapping.  So, allow read/write but
2410  * use the DAC only.
2411  */
2412         state = card->states[1];
2413         if (!state) {
2414                 ret = -EINVAL;
2415                 goto out;
2416         }
2417
2418         down(&state->sem);
2419         dmabuf = &state->dmabuf;
2420         if (cs4x_pgoff(vma) != 0)
2421         {
2422                 ret = -EINVAL;
2423                 goto out;
2424         }
2425         size = vma->vm_end - vma->vm_start;
2426
2427         CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2428
2429         if (size > (PAGE_SIZE << dmabuf->buforder))
2430         {
2431                 ret = -EINVAL;
2432                 goto out;
2433         }
2434         if (remap_pfn_range(vma, vma->vm_start,
2435                              virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
2436                              size, vma->vm_page_prot))
2437         {
2438                 ret = -EAGAIN;
2439                 goto out;
2440         }
2441         dmabuf->mapped = 1;
2442
2443         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2444 out:
2445         up(&state->sem);
2446         return ret;
2447 }
2448
2449 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2450 {
2451         struct cs_card *card = (struct cs_card *)file->private_data;
2452         struct cs_state *state;
2453         struct dmabuf *dmabuf=NULL;
2454         unsigned long flags;
2455         audio_buf_info abinfo;
2456         count_info cinfo;
2457         int val, valsave, mapped, ret;
2458         void __user *argp = (void __user *)arg;
2459         int __user *p = argp;
2460
2461         state = (struct cs_state *)card->states[0];
2462         if(state)
2463         {
2464                 dmabuf = &state->dmabuf;
2465                 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2466         }
2467         state = (struct cs_state *)card->states[1];
2468         if(state)
2469         {
2470                 dmabuf = &state->dmabuf;
2471                 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2472         }
2473
2474 #if CSDEBUG
2475         printioctl(cmd);
2476 #endif
2477
2478         switch (cmd)
2479         {
2480         case OSS_GETVERSION:
2481                 return put_user(SOUND_VERSION, p);
2482
2483         case SNDCTL_DSP_RESET:
2484                 /* FIXME: spin_lock ? */
2485                 if (file->f_mode & FMODE_WRITE) {
2486                         state = (struct cs_state *)card->states[1];
2487                         if(state)
2488                         {
2489                                 dmabuf = &state->dmabuf;
2490                                 stop_dac(state);
2491                                 synchronize_irq(card->irq);
2492                                 dmabuf->ready = 0;
2493                                 resync_dma_ptrs(state);
2494                                 dmabuf->swptr = dmabuf->hwptr = 0;
2495                                 dmabuf->count = dmabuf->total_bytes = 0;
2496                                 dmabuf->blocks = 0;
2497                                 dmabuf->SGok = 0;
2498                         }
2499                 }
2500                 if (file->f_mode & FMODE_READ) {
2501                         state = (struct cs_state *)card->states[0];
2502                         if(state)
2503                         {
2504                                 dmabuf = &state->dmabuf;
2505                                 stop_adc(state);
2506                                 synchronize_irq(card->irq);
2507                                 resync_dma_ptrs(state);
2508                                 dmabuf->ready = 0;
2509                                 dmabuf->swptr = dmabuf->hwptr = 0;
2510                                 dmabuf->count = dmabuf->total_bytes = 0;
2511                                 dmabuf->blocks = 0;
2512                                 dmabuf->SGok = 0;
2513                         }
2514                 }
2515                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2516                 return 0;
2517
2518         case SNDCTL_DSP_SYNC:
2519                 if (file->f_mode & FMODE_WRITE)
2520                         return drain_dac(state, file->f_flags & O_NONBLOCK);
2521                 return 0;
2522
2523         case SNDCTL_DSP_SPEED: /* set sample rate */
2524                 if (get_user(val, p))
2525                         return -EFAULT;
2526                 if (val >= 0) {
2527                         if (file->f_mode & FMODE_READ) {
2528                                 state = (struct cs_state *)card->states[0];
2529                                 if(state)
2530                                 {
2531                                         dmabuf = &state->dmabuf;
2532                                         stop_adc(state);
2533                                         dmabuf->ready = 0;
2534                                         dmabuf->SGok = 0;
2535                                         cs_set_adc_rate(state, val);
2536                                         cs_set_divisor(dmabuf);
2537                                 }
2538                         }
2539                         if (file->f_mode & FMODE_WRITE) {
2540                                 state = (struct cs_state *)card->states[1];
2541                                 if(state)
2542                                 {
2543                                         dmabuf = &state->dmabuf;
2544                                         stop_dac(state);
2545                                         dmabuf->ready = 0;
2546                                         dmabuf->SGok = 0;
2547                                         cs_set_dac_rate(state, val);
2548                                         cs_set_divisor(dmabuf);
2549                                 }
2550                         }
2551                         CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2552                             "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2553                                 file->f_mode & FMODE_WRITE ? "DAC" : "",
2554                                 file->f_mode & FMODE_READ ? "ADC" : "",
2555                                 dmabuf->rate ) );
2556                         return put_user(dmabuf->rate, p);
2557                 }
2558                 return put_user(0, p);
2559
2560         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2561                 if (get_user(val, p))
2562                         return -EFAULT;
2563                 if (file->f_mode & FMODE_WRITE) {
2564                         state = (struct cs_state *)card->states[1];
2565                         if(state)
2566                         {
2567                                 dmabuf = &state->dmabuf;
2568                                 stop_dac(state);
2569                                 dmabuf->ready = 0;
2570                                 dmabuf->SGok = 0;
2571                                 if(val)
2572                                         dmabuf->fmt |= CS_FMT_STEREO;
2573                                 else
2574                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2575                                 cs_set_divisor(dmabuf);
2576                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2577                                     "cs46xx: DSP_STEREO() DAC %s\n",
2578                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2579                                         "STEREO":"MONO") );
2580                         }
2581                 }
2582                 if (file->f_mode & FMODE_READ) {
2583                         state = (struct cs_state *)card->states[0];
2584                         if(state)
2585                         {
2586                                 dmabuf = &state->dmabuf;
2587                                 stop_adc(state);
2588                                 dmabuf->ready = 0;
2589                                 dmabuf->SGok = 0;
2590                                 if(val)
2591                                         dmabuf->fmt |= CS_FMT_STEREO;
2592                                 else
2593                                         dmabuf->fmt &= ~CS_FMT_STEREO;
2594                                 cs_set_divisor(dmabuf);
2595                                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2596                                     "cs46xx: DSP_STEREO() ADC %s\n",
2597                                     (dmabuf->fmt & CS_FMT_STEREO) ?
2598                                         "STEREO":"MONO") );
2599                         }
2600                 }
2601                 return 0;
2602
2603         case SNDCTL_DSP_GETBLKSIZE:
2604                 if (file->f_mode & FMODE_WRITE) {
2605                         state = (struct cs_state *)card->states[1];
2606                         if(state)
2607                         {
2608                                 dmabuf = &state->dmabuf;
2609                                 if ((val = prog_dmabuf(state)))
2610                                         return val;
2611                                 return put_user(dmabuf->fragsize, p);
2612                         }
2613                 }
2614                 if (file->f_mode & FMODE_READ) {
2615                         state = (struct cs_state *)card->states[0];
2616                         if(state)
2617                         {
2618                                 dmabuf = &state->dmabuf;
2619                                 if ((val = prog_dmabuf(state)))
2620                                         return val;
2621                                 return put_user(dmabuf->fragsize/dmabuf->divisor,
2622                                                 p);
2623                         }
2624                 }
2625                 return put_user(0, p);
2626
2627         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2628                 return put_user(AFMT_S16_LE | AFMT_U8, p);
2629
2630         case SNDCTL_DSP_SETFMT: /* Select sample format */
2631                 if (get_user(val, p))
2632                         return -EFAULT;
2633                 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2634                     "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2635                         file->f_mode & FMODE_WRITE ? "DAC" : "",
2636                         file->f_mode & FMODE_READ ? "ADC" : "",
2637                         val == AFMT_S16_LE ? "16Bit Signed" : "",
2638                         val == AFMT_U8 ? "8Bit Unsigned" : "") );
2639                 valsave = val;
2640                 if (val != AFMT_QUERY) {
2641                         if(val==AFMT_S16_LE || val==AFMT_U8)
2642                         {
2643                                 if (file->f_mode & FMODE_WRITE) {
2644                                         state = (struct cs_state *)card->states[1];
2645                                         if(state)
2646                                         {
2647                                                 dmabuf = &state->dmabuf;
2648                                                 stop_dac(state);
2649                                                 dmabuf->ready = 0;
2650                                                 dmabuf->SGok = 0;
2651                                                 if(val==AFMT_S16_LE)
2652                                                         dmabuf->fmt |= CS_FMT_16BIT;
2653                                                 else
2654                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2655                                                 cs_set_divisor(dmabuf);
2656                                                 if((ret = prog_dmabuf(state)))
2657                                                         return ret;
2658                                         }
2659                                 }
2660                                 if (file->f_mode & FMODE_READ) {
2661                                         val = valsave;
2662                                         state = (struct cs_state *)card->states[0];
2663                                         if(state)
2664                                         {
2665                                                 dmabuf = &state->dmabuf;
2666                                                 stop_adc(state);
2667                                                 dmabuf->ready = 0;
2668                                                 dmabuf->SGok = 0;
2669                                                 if(val==AFMT_S16_LE)
2670                                                         dmabuf->fmt |= CS_FMT_16BIT;
2671                                                 else
2672                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
2673                                                 cs_set_divisor(dmabuf);
2674                                                 if((ret = prog_dmabuf(state)))
2675                                                         return ret;
2676                                         }
2677                                 }
2678                         }
2679                         else
2680                         {
2681                                 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2682                                     "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2683                                         valsave) );
2684                         }
2685                 }
2686                 else
2687                 {
2688                         if(file->f_mode & FMODE_WRITE)
2689                         {
2690                                 state = (struct cs_state *)card->states[1];
2691                                 if(state)
2692                                         dmabuf = &state->dmabuf;
2693                         }
2694                         else if(file->f_mode & FMODE_READ)
2695                         {
2696                                 state = (struct cs_state *)card->states[0];
2697                                 if(state)
2698                                         dmabuf = &state->dmabuf;
2699                         }
2700                 }
2701                 if(dmabuf)
2702                 {
2703                         if(dmabuf->fmt & CS_FMT_16BIT)
2704                                 return put_user(AFMT_S16_LE, p);
2705                         else
2706                                 return put_user(AFMT_U8, p);
2707                 }
2708                 return put_user(0, p);
2709
2710         case SNDCTL_DSP_CHANNELS:
2711                 if (get_user(val, p))
2712                         return -EFAULT;
2713                 if (val != 0) {
2714                         if (file->f_mode & FMODE_WRITE) {
2715                                 state = (struct cs_state *)card->states[1];
2716                                 if(state)
2717                                 {
2718                                         dmabuf = &state->dmabuf;
2719                                         stop_dac(state);
2720                                         dmabuf->ready = 0;
2721                                         dmabuf->SGok = 0;
2722                                         if(val>1)
2723                                                 dmabuf->fmt |= CS_FMT_STEREO;
2724                                         else
2725                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2726                                         cs_set_divisor(dmabuf);
2727                                         if (prog_dmabuf(state))
2728                                                 return 0;
2729                                 }
2730                         }
2731                         if (file->f_mode & FMODE_READ) {
2732                                 state = (struct cs_state *)card->states[0];
2733                                 if(state)
2734                                 {
2735                                         dmabuf = &state->dmabuf;
2736                                         stop_adc(state);
2737                                         dmabuf->ready = 0;
2738                                         dmabuf->SGok = 0;
2739                                         if(val>1)
2740                                                 dmabuf->fmt |= CS_FMT_STEREO;
2741                                         else
2742                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
2743                                         cs_set_divisor(dmabuf);
2744                                         if (prog_dmabuf(state))
2745                                                 return 0;
2746                                 }
2747                         }
2748                 }
2749                 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2750                                 p);
2751
2752         case SNDCTL_DSP_POST:
2753                 /*
2754                  * There will be a longer than normal pause in the data.
2755                  * so... do nothing, because there is nothing that we can do.
2756                  */
2757                 return 0;
2758
2759         case SNDCTL_DSP_SUBDIVIDE:
2760                 if (file->f_mode & FMODE_WRITE) {
2761                         state = (struct cs_state *)card->states[1];
2762                         if(state)
2763                         {
2764                                 dmabuf = &state->dmabuf;
2765                                 if (dmabuf->subdivision)
2766                                         return -EINVAL;
2767                                 if (get_user(val, p))
2768                                         return -EFAULT;
2769                                 if (val != 1 && val != 2)
2770                                         return -EINVAL;
2771                                 dmabuf->subdivision = val;
2772                         }
2773                 }
2774                 if (file->f_mode & FMODE_READ) {
2775                         state = (struct cs_state *)card->states[0];
2776                         if(state)
2777                         {
2778                                 dmabuf = &state->dmabuf;
2779                                 if (dmabuf->subdivision)
2780                                         return -EINVAL;
2781                                 if (get_user(val, p))
2782                                         return -EFAULT;
2783                                 if (val != 1 && val != 2)
2784                                         return -EINVAL;
2785                                 dmabuf->subdivision = val;
2786                         }
2787                 }
2788                 return 0;
2789
2790         case SNDCTL_DSP_SETFRAGMENT:
2791                 if (get_user(val, p))
2792                         return -EFAULT;
2793
2794                 if (file->f_mode & FMODE_WRITE) {
2795                         state = (struct cs_state *)card->states[1];
2796                         if(state)
2797                         {
2798                                 dmabuf = &state->dmabuf;
2799                                 dmabuf->ossfragshift = val & 0xffff;
2800                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2801                         }
2802                 }
2803                 if (file->f_mode & FMODE_READ) {
2804                         state = (struct cs_state *)card->states[0];
2805                         if(state)
2806                         {
2807                                 dmabuf = &state->dmabuf;
2808                                 dmabuf->ossfragshift = val & 0xffff;
2809                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2810                         }
2811                 }
2812                 return 0;
2813
2814         case SNDCTL_DSP_GETOSPACE:
2815                 if (!(file->f_mode & FMODE_WRITE))
2816                         return -EINVAL;
2817                 state = (struct cs_state *)card->states[1];
2818                 if(state)
2819                 {
2820                         dmabuf = &state->dmabuf;
2821                         spin_lock_irqsave(&state->card->lock, flags);
2822                         cs_update_ptr(card, CS_TRUE);
2823                         abinfo.fragsize = dmabuf->fragsize;
2824                         abinfo.fragstotal = dmabuf->numfrag;
2825                 /*
2826                  * for mmap we always have total space available
2827                  */
2828                         if (dmabuf->mapped)
2829                                 abinfo.bytes = dmabuf->dmasize;
2830                         else
2831                                 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2832
2833                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2834                         spin_unlock_irqrestore(&state->card->lock, flags);
2835                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2836                 }
2837                 return -ENODEV;
2838
2839         case SNDCTL_DSP_GETISPACE:
2840                 if (!(file->f_mode & FMODE_READ))
2841                         return -EINVAL;
2842                 state = (struct cs_state *)card->states[0];
2843                 if(state)
2844                 {
2845                         dmabuf = &state->dmabuf;
2846                         spin_lock_irqsave(&state->card->lock, flags);
2847                         cs_update_ptr(card, CS_TRUE);
2848                         abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2849                         abinfo.bytes = dmabuf->count/dmabuf->divisor;
2850                         abinfo.fragstotal = dmabuf->numfrag;
2851                         abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2852                         spin_unlock_irqrestore(&state->card->lock, flags);
2853                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2854                 }
2855                 return -ENODEV;
2856
2857         case SNDCTL_DSP_NONBLOCK:
2858                 file->f_flags |= O_NONBLOCK;
2859                 return 0;
2860
2861         case SNDCTL_DSP_GETCAPS:
2862                 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2863                             p);
2864
2865         case SNDCTL_DSP_GETTRIGGER:
2866                 val = 0;
2867                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2868                 if (file->f_mode & FMODE_WRITE)
2869                 {
2870                         state = (struct cs_state *)card->states[1];
2871                         if(state)
2872                         {
2873                                 dmabuf = &state->dmabuf;
2874                                 if(dmabuf->enable & DAC_RUNNING)
2875                                         val |= PCM_ENABLE_INPUT;
2876                         }
2877                 }
2878                 if (file->f_mode & FMODE_READ)
2879                 {
2880                         if(state)
2881                         {
2882                                 state = (struct cs_state *)card->states[0];
2883                                 dmabuf = &state->dmabuf;
2884                                 if(dmabuf->enable & ADC_RUNNING)
2885                                         val |= PCM_ENABLE_OUTPUT;
2886                         }
2887                 }
2888                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2889                 return put_user(val, p);
2890
2891         case SNDCTL_DSP_SETTRIGGER:
2892                 if (get_user(val, p))
2893                         return -EFAULT;
2894                 if (file->f_mode & FMODE_READ) {
2895                         state = (struct cs_state *)card->states[0];
2896                         if(state)
2897                         {
2898                                 dmabuf = &state->dmabuf;
2899                                 if (val & PCM_ENABLE_INPUT) {
2900                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2901                                                 return ret;
2902                                         start_adc(state);
2903                                 } else
2904                                         stop_adc(state);
2905                         }
2906                 }
2907                 if (file->f_mode & FMODE_WRITE) {
2908                         state = (struct cs_state *)card->states[1];
2909                         if(state)
2910                         {
2911                                 dmabuf = &state->dmabuf;
2912                                 if (val & PCM_ENABLE_OUTPUT) {
2913                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2914                                                 return ret;
2915                                         start_dac(state);
2916                                 } else
2917                                         stop_dac(state);
2918                         }
2919                 }
2920                 return 0;
2921
2922         case SNDCTL_DSP_GETIPTR:
2923                 if (!(file->f_mode & FMODE_READ))
2924                         return -EINVAL;
2925                 state = (struct cs_state *)card->states[0];
2926                 if(state)
2927                 {
2928                         dmabuf = &state->dmabuf;
2929                         spin_lock_irqsave(&state->card->lock, flags);
2930                         cs_update_ptr(card, CS_TRUE);
2931                         cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2932                         cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2933                         cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2934                         spin_unlock_irqrestore(&state->card->lock, flags);
2935                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2936                                 return -EFAULT;
2937                         return 0;
2938                 }
2939                 return -ENODEV;
2940
2941         case SNDCTL_DSP_GETOPTR:
2942                 if (!(file->f_mode & FMODE_WRITE))
2943                         return -EINVAL;
2944                 state = (struct cs_state *)card->states[1];
2945                 if(state)
2946                 {
2947                         dmabuf = &state->dmabuf;
2948                         spin_lock_irqsave(&state->card->lock, flags);
2949                         cs_update_ptr(card, CS_TRUE);
2950                         cinfo.bytes = dmabuf->total_bytes;
2951                         if (dmabuf->mapped)
2952                         {
2953                                 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2954                                                         - dmabuf->blocks;
2955                                 CS_DBGOUT(CS_PARMS, 8,
2956                                         printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2957                                         cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2958                                 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2959                         }
2960                         else
2961                         {
2962                                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2963                         }
2964                         cinfo.ptr = dmabuf->hwptr;
2965
2966                         CS_DBGOUT(CS_PARMS, 4, printk(
2967                             "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2968                                 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2969                         spin_unlock_irqrestore(&state->card->lock, flags);
2970                         if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2971                                 return -EFAULT;
2972                         return 0;
2973                 }
2974                 return -ENODEV;
2975
2976         case SNDCTL_DSP_SETDUPLEX:
2977                 return 0;
2978
2979         case SNDCTL_DSP_GETODELAY:
2980                 if (!(file->f_mode & FMODE_WRITE))
2981                         return -EINVAL;
2982                 state = (struct cs_state *)card->states[1];
2983                 if(state)
2984                 {
2985                         dmabuf = &state->dmabuf;
2986                         spin_lock_irqsave(&state->card->lock, flags);
2987                         cs_update_ptr(card, CS_TRUE);
2988                         val = dmabuf->count;
2989                         spin_unlock_irqrestore(&state->card->lock, flags);
2990                 }
2991                 else
2992                         val = 0;
2993                 return put_user(val, p);
2994
2995         case SOUND_PCM_READ_RATE:
2996                 if(file->f_mode & FMODE_READ)
2997                         state = (struct cs_state *)card->states[0];
2998                 else
2999                         state = (struct cs_state *)card->states[1];
3000                 if(state)
3001                 {
3002                         dmabuf = &state->dmabuf;
3003                         return put_user(dmabuf->rate, p);
3004                 }
3005                 return put_user(0, p);
3006
3007
3008         case SOUND_PCM_READ_CHANNELS:
3009                 if(file->f_mode & FMODE_READ)
3010                         state = (struct cs_state *)card->states[0];
3011                 else
3012                         state = (struct cs_state *)card->states[1];
3013                 if(state)
3014                 {
3015                         dmabuf = &state->dmabuf;
3016                         return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3017                                 p);
3018                 }
3019                 return put_user(0, p);
3020
3021         case SOUND_PCM_READ_BITS:
3022                 if(file->f_mode & FMODE_READ)
3023                         state = (struct cs_state *)card->states[0];
3024                 else
3025                         state = (struct cs_state *)card->states[1];
3026                 if(state)
3027                 {
3028                         dmabuf = &state->dmabuf;
3029                         return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3030                                 AFMT_S16_LE : AFMT_U8, p);
3031
3032                 }
3033                 return put_user(0, p);
3034
3035         case SNDCTL_DSP_MAPINBUF:
3036         case SNDCTL_DSP_MAPOUTBUF:
3037         case SNDCTL_DSP_SETSYNCRO:
3038         case SOUND_PCM_WRITE_FILTER:
3039         case SOUND_PCM_READ_FILTER:
3040                 return -EINVAL;
3041         }
3042         return -EINVAL;
3043 }
3044
3045
3046 /*
3047  *      AMP control - null AMP
3048  */
3049
3050 static void amp_none(struct cs_card *card, int change)
3051 {
3052 }
3053
3054 /*
3055  *      Crystal EAPD mode
3056  */
3057
3058 static void amp_voyetra(struct cs_card *card, int change)
3059 {
3060         /* Manage the EAPD bit on the Crystal 4297
3061            and the Analog AD1885 */
3062
3063         int old=card->amplifier;
3064
3065         card->amplifier+=change;
3066         if(card->amplifier && !old)
3067         {
3068                 /* Turn the EAPD amp on */
3069                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3070                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3071                                 0x8000);
3072         }
3073         else if(old && !card->amplifier)
3074         {
3075                 /* Turn the EAPD amp off */
3076                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
3077                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3078                                 ~0x8000);
3079         }
3080 }
3081
3082
3083 /*
3084  *      Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3085  */
3086
3087 static void amp_hercules(struct cs_card *card, int change)
3088 {
3089         int old=card->amplifier;
3090         if(!card)
3091         {
3092                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3093                         "cs46xx: amp_hercules() called before initialized.\n"));
3094                 return;
3095         }
3096         card->amplifier+=change;
3097         if( (card->amplifier && !old) && !(hercules_egpio_disable))
3098         {
3099                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3100                         "cs46xx: amp_hercules() external amp enabled\n"));
3101                 cs461x_pokeBA0(card, BA0_EGPIODR,
3102                         EGPIODR_GPOE2);     /* enable EGPIO2 output */
3103                 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3104                         EGPIOPTR_GPPT2);   /* open-drain on output */
3105         }
3106         else if(old && !card->amplifier)
3107         {
3108                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3109                         "cs46xx: amp_hercules() external amp disabled\n"));
3110                 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3111                 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3112         }
3113 }
3114
3115 /*
3116  *      Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3117  *      whenever we need to beat on the chip.
3118  *
3119  *      The original idea and code for this hack comes from David Kaiser at
3120  *      Linuxcare. Perhaps one day Crystal will document their chips well
3121  *      enough to make them useful.
3122  */
3123
3124 static void clkrun_hack(struct cs_card *card, int change)
3125 {
3126         struct pci_dev *acpi_dev;
3127         u16 control;
3128         u8 pp;
3129         unsigned long port;
3130         int old=card->active;
3131
3132         card->active+=change;
3133
3134         acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3135         if(acpi_dev == NULL)
3136                 return;         /* Not a thinkpad thats for sure */
3137
3138         /* Find the control port */
3139         pci_read_config_byte(acpi_dev, 0x41, &pp);
3140         port=pp<<8;
3141
3142         /* Read ACPI port */
3143         control=inw(port+0x10);
3144
3145         /* Flip CLKRUN off while running */
3146         if(!card->active && old)
3147         {
3148                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3149                         "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3150                                 change,card->active));
3151                 outw(control|0x2000, port+0x10);
3152         }
3153         else
3154         {
3155         /*
3156         * sometimes on a resume the bit is set, so always reset the bit.
3157         */
3158                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3159                         "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3160                                 change,card->active));
3161                 outw(control&~0x2000, port+0x10);
3162         }
3163 }
3164
3165
3166 static int cs_open(struct inode *inode, struct file *file)
3167 {
3168         struct cs_card *card = (struct cs_card *)file->private_data;
3169         struct cs_state *state = NULL;
3170         struct dmabuf *dmabuf = NULL;
3171         struct list_head *entry;
3172         unsigned int minor = iminor(inode);
3173         int ret=0;
3174         unsigned int tmp;
3175
3176         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3177                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3178                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3179
3180         list_for_each(entry, &cs46xx_devs)
3181         {
3182                 card = list_entry(entry, struct cs_card, list);
3183
3184                 if (!((card->dev_audio ^ minor) & ~0xf))
3185                         break;
3186         }
3187         if (entry == &cs46xx_devs)
3188                 return -ENODEV;
3189         if (!card) {
3190                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3191                         "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3192                 return -ENODEV;
3193         }
3194
3195         /*
3196          * hardcode state[0] for capture, [1] for playback
3197          */
3198         if(file->f_mode & FMODE_READ)
3199         {
3200                 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3201                 if (card->states[0] == NULL) {
3202                         state = card->states[0] = (struct cs_state *)
3203                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3204                         if (state == NULL)
3205                                 return -ENOMEM;
3206                         memset(state, 0, sizeof(struct cs_state));
3207                         init_MUTEX(&state->sem);
3208                         dmabuf = &state->dmabuf;
3209                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3210                         if(dmabuf->pbuf==NULL)
3211                         {
3212                                 kfree(state);
3213                                 card->states[0]=NULL;
3214                                 return -ENOMEM;
3215                         }
3216                 }
3217                 else
3218                 {
3219                         state = card->states[0];
3220                         if(state->open_mode & FMODE_READ)
3221                                 return -EBUSY;
3222                 }
3223                 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3224
3225                 if (dmabuf->channel == NULL) {
3226                         kfree (card->states[0]);
3227                         card->states[0] = NULL;
3228                         return -ENODEV;
3229                 }
3230
3231                 /* Now turn on external AMP if needed */
3232                 state->card = card;
3233                 state->card->active_ctrl(state->card,1);
3234                 state->card->amplifier_ctrl(state->card,1);
3235
3236                 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3237                 {
3238                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3239                                 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3240                         return -EIO;
3241                 }
3242
3243                 dmabuf->channel->state = state;
3244                 /* initialize the virtual channel */
3245                 state->virt = 0;
3246                 state->magic = CS_STATE_MAGIC;
3247                 init_waitqueue_head(&dmabuf->wait);
3248                 init_MUTEX(&state->open_sem);
3249                 file->private_data = card;
3250
3251                 down(&state->open_sem);
3252
3253                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3254                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3255                    /dev/dspW will accept 16-bits sample */
3256
3257                 /* Default input is 8bit mono */
3258                 dmabuf->fmt &= ~CS_FMT_MASK;
3259                 dmabuf->type = CS_TYPE_ADC;
3260                 dmabuf->ossfragshift = 0;
3261                 dmabuf->ossmaxfrags  = 0;
3262                 dmabuf->subdivision  = 0;
3263                 cs_set_adc_rate(state, 8000);
3264                 cs_set_divisor(dmabuf);
3265
3266                 state->open_mode |= FMODE_READ;
3267                 up(&state->open_sem);
3268         }
3269         if(file->f_mode & FMODE_WRITE)
3270         {
3271                 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3272                 if (card->states[1] == NULL) {
3273                         state = card->states[1] = (struct cs_state *)
3274                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3275                         if (state == NULL)
3276                                 return -ENOMEM;
3277                         memset(state, 0, sizeof(struct cs_state));
3278                         init_MUTEX(&state->sem);
3279                         dmabuf = &state->dmabuf;
3280                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3281                         if(dmabuf->pbuf==NULL)
3282                         {
3283                                 kfree(state);
3284                                 card->states[1]=NULL;
3285                                 return -ENOMEM;
3286                         }
3287                 }
3288                 else
3289                 {
3290                         state = card->states[1];
3291                         if(state->open_mode & FMODE_WRITE)
3292                                 return -EBUSY;
3293                 }
3294                 dmabuf->channel = card->alloc_pcm_channel(card);
3295
3296                 if (dmabuf->channel == NULL) {
3297                         kfree (card->states[1]);
3298                         card->states[1] = NULL;
3299                         return -ENODEV;
3300                 }
3301
3302                 /* Now turn on external AMP if needed */
3303                 state->card = card;
3304                 state->card->active_ctrl(state->card,1);
3305                 state->card->amplifier_ctrl(state->card,1);
3306
3307                 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3308                 {
3309                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3310                                 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3311                         return -EIO;
3312                 }
3313
3314                 dmabuf->channel->state = state;
3315                 /* initialize the virtual channel */
3316                 state->virt = 1;
3317                 state->magic = CS_STATE_MAGIC;
3318                 init_waitqueue_head(&dmabuf->wait);
3319                 init_MUTEX(&state->open_sem);
3320                 file->private_data = card;
3321
3322                 down(&state->open_sem);
3323
3324                 /* set default sample format. According to OSS Programmer's Guide  /dev/dsp
3325                    should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3326                    /dev/dspW will accept 16-bits sample */
3327
3328                 /* Default output is 8bit mono. */
3329                 dmabuf->fmt &= ~CS_FMT_MASK;
3330                 dmabuf->type = CS_TYPE_DAC;
3331                 dmabuf->ossfragshift = 0;
3332                 dmabuf->ossmaxfrags  = 0;
3333                 dmabuf->subdivision  = 0;
3334                 cs_set_dac_rate(state, 8000);
3335                 cs_set_divisor(dmabuf);
3336
3337                 state->open_mode |= FMODE_WRITE;
3338                 up(&state->open_sem);
3339                 if((ret = prog_dmabuf(state)))
3340                         return ret;
3341         }
3342         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3343         return nonseekable_open(inode, file);
3344 }
3345
3346 static int cs_release(struct inode *inode, struct file *file)
3347 {
3348         struct cs_card *card = (struct cs_card *)file->private_data;
3349         struct dmabuf *dmabuf;
3350         struct cs_state *state;
3351         unsigned int tmp;
3352         CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3353                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3354                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3355
3356         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3357         {
3358                 return -EINVAL;
3359         }
3360         state = card->states[1];
3361         if(state)
3362         {
3363                 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3364                 {
3365                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3366                         dmabuf = &state->dmabuf;
3367                         cs_clear_tail(state);
3368                         drain_dac(state, file->f_flags & O_NONBLOCK);
3369                         /* stop DMA state machine and free DMA buffers/channels */
3370                         down(&state->open_sem);
3371                         stop_dac(state);
3372                         dealloc_dmabuf(state);
3373                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3374                         free_page((unsigned long)state->dmabuf.pbuf);
3375
3376                         /* we're covered by the open_sem */
3377                         up(&state->open_sem);
3378                         state->card->states[state->virt] = NULL;
3379                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3380
3381                         if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3382                         {
3383                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3384                                         "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3385                         }
3386
3387                         /* Now turn off external AMP if needed */
3388                         state->card->amplifier_ctrl(state->card, -1);
3389                         state->card->active_ctrl(state->card, -1);
3390
3391                         kfree(state);
3392                 }
3393         }
3394
3395         state = card->states[0];
3396         if(state)
3397         {
3398                 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3399                 {
3400                         CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3401                         dmabuf = &state->dmabuf;
3402                         down(&state->open_sem);
3403                         stop_adc(state);
3404                         dealloc_dmabuf(state);
3405                         state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3406                         free_page((unsigned long)state->dmabuf.pbuf);
3407
3408                         /* we're covered by the open_sem */
3409                         up(&state->open_sem);
3410                         state->card->states[state->virt] = NULL;
3411                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3412
3413                         if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3414                         {
3415                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3416                                         "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3417                         }
3418
3419                         /* Now turn off external AMP if needed */
3420                         state->card->amplifier_ctrl(state->card, -1);
3421                         state->card->active_ctrl(state->card, -1);
3422
3423                         kfree(state);
3424                 }
3425         }
3426
3427         CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3428         return 0;
3429 }
3430
3431 static void printpm(struct cs_card *s)
3432 {
3433         CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3434         CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3435                 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3436         CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3437                 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3438         CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3439                 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3440         CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3441                 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3442         CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3443                 s->pm.u32SSCR,s->pm.u32SRCSA));
3444         CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3445                 s->pm.u32DacASR,s->pm.u32AdcASR));
3446         CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3447                 s->pm.u32DacSR,s->pm.u32AdcSR));
3448         CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3449                 s->pm.u32MIDCR_Save));
3450         CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3451                 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3452         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3453                 s->pm.u32AC97_master_volume));
3454         CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3455                 s->pm.u32AC97_headphone_volume));
3456         CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3457                 s->pm.u32AC97_master_volume_mono));
3458         CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3459                 s->pm.u32AC97_pcm_out_volume));
3460         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3461                 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3462         CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3463                 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3464
3465 }
3466
3467 /****************************************************************************
3468 *
3469 *  Suspend - save the ac97 regs, mute the outputs and power down the part.
3470 *
3471 ****************************************************************************/
3472 static void cs46xx_ac97_suspend(struct cs_card *card)
3473 {
3474         int Count,i;
3475         struct ac97_codec *dev=card->ac97_codec[0];
3476         unsigned int tmp;
3477
3478         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3479
3480         if(card->states[1])
3481         {
3482                 stop_dac(card->states[1]);
3483                 resync_dma_ptrs(card->states[1]);
3484         }
3485         if(card->states[0])
3486         {
3487                 stop_adc(card->states[0]);
3488                 resync_dma_ptrs(card->states[0]);
3489         }
3490
3491         for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3492                         && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3493                 Count += 2, i++)
3494         {
3495                 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3496         }
3497 /*
3498 * Save the ac97 volume registers as well as the current powerdown state.
3499 * Now, mute the all the outputs (master, headphone, and mono), as well
3500 * as the PCM volume, in preparation for powering down the entire part.
3501         card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3502                         (u8)BA0_AC97_MASTER_VOLUME);
3503         card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3504                         (u8)BA0_AC97_HEADPHONE_VOLUME);
3505         card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3506                         (u8)BA0_AC97_MASTER_VOLUME_MONO);
3507         card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3508                         (u8)BA0_AC97_PCM_OUT_VOLUME);
3509 */
3510 /*
3511 * mute the outputs