sound/oss/cmpci.c

   1 /*****************************************************************************/
   2 /*
   3  *      cmpci.c  --  C-Media PCI audio driver.
   4  *
   5  *      Copyright (C) 1999  ChenLi Tien (cltien@cmedia.com.tw)
   6  *                          C-media support (support@cmedia.com.tw)
   7  *
   8  *      Based on the PCI drivers by Thomas Sailer (sailer@ife.ee.ethz.ch)
   9  *
  10  *      For update, visit:
  11  *              http://members.home.net/puresoft/cmedia.html
  12  *              http://www.cmedia.com.tw
  13  *
  14  *      This program is free software; you can redistribute it and/or modify
  15  *      it under the terms of the GNU General Public License as published by
  16  *      the Free Software Foundation; either version 2 of the License, or
  17  *      (at your option) any later version.
  18  *
  19  *      This program is distributed in the hope that it will be useful,
  20  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *      GNU General Public License for more details.
  23  *
  24  *      You should have received a copy of the GNU General Public License
  25  *      along with this program; if not, write to the Free Software
  26  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27  *
  28  * Special thanks to David C. Niemi, Jan Pfeifer
  29  *
  30  *
  31  * Module command line parameters:
  32  *   none so far
  33  *
  34  *
  35  *  Supported devices:
  36  *  /dev/dsp    standard /dev/dsp device, (mostly) OSS compatible
  37  *  /dev/mixer  standard /dev/mixer device, (mostly) OSS compatible
  38  *  /dev/midi   simple MIDI UART interface, no ioctl
  39  *
  40  *  The card has both an FM and a Wavetable synth, but I have to figure
  41  *  out first how to drive them...
  42  *
  43  *  Revision history
  44  *    06.05.98   0.1   Initial release
  45  *    10.05.98   0.2   Fixed many bugs, esp. ADC rate calculation
  46  *                     First stab at a simple midi interface (no bells&whistles)
  47  *    13.05.98   0.3   Fix stupid cut&paste error: set_adc_rate was called instead of
  48  *                     set_dac_rate in the FMODE_WRITE case in cm_open
  49  *                     Fix hwptr out of bounds (now mpg123 works)
  50  *    14.05.98   0.4   Don't allow excessive interrupt rates
  51  *    08.06.98   0.5   First release using Alan Cox' soundcore instead of miscdevice
  52  *    03.08.98   0.6   Do not include modversions.h
  53  *                     Now mixer behaviour can basically be selected between
  54  *                     "OSS documented" and "OSS actual" behaviour
  55  *    31.08.98   0.7   Fix realplayer problems - dac.count issues
  56  *    10.12.98   0.8   Fix drain_dac trying to wait on not yet initialized DMA
  57  *    16.12.98   0.9   Fix a few f_file & FMODE_ bugs
  58  *    06.01.99   0.10  remove the silly SA_INTERRUPT flag.
  59  *                     hopefully killed the egcs section type conflict
  60  *    12.03.99   0.11  cinfo.blocks should be reset after GETxPTR ioctl.
  61  *                     reported by Johan Maes <joma@telindus.be>
  62  *    22.03.99   0.12  return EAGAIN instead of EBUSY when O_NONBLOCK
  63  *                     read/write cannot be executed
  64  *    18.08.99   1.5   Only deallocate DMA buffer when unloading.
  65  *    02.09.99   1.6   Enable SPDIF LOOP
  66  *                     Change the mixer read back
  67  *    21.09.99   2.33  Use RCS version as driver version.
  68  *                     Add support for modem, S/PDIF loop and 4 channels.
  69  *                     (8738 only)
  70  *                     Fix bug cause x11amp cannot play.
  71  *
  72  *    Fixes:
  73  *    Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  74  *    18/05/2001 - .bss nitpicks, fix a bug in set_dac_channels where it
  75  *                 was calling prog_dmabuf with s->lock held, call missing
  76  *                 unlock_kernel in cm_midi_release
  77  *    08/10/2001 - use set_current_state in some more places
  78  *
  79  *      Carlos Eduardo Gorges <carlos@techlinux.com.br>
  80  *      Fri May 25 2001
  81  *      - SMP support ( spin[un]lock* revision )
  82  *      - speaker mixer support
  83  *      Mon Aug 13 2001
  84  *      - optimizations and cleanups
  85  *    03/01/2003 - open_mode fixes from Georg Acher <acher@in.tum.de>
  86  *
  87  */
  88 /*****************************************************************************/
  89
  90 #include <linux/config.h>
  91 #include <linux/module.h>
  92 #include <linux/string.h>
  93 #include <linux/interrupt.h>
  94 #include <linux/ioport.h>
  95 #include <linux/sched.h>
  96 #include <linux/delay.h>
  97 #include <linux/sound.h>
  98 #include <linux/slab.h>
  99 #include <linux/soundcard.h>
 100 #include <linux/pci.h>
 101 #include <linux/init.h>
 102 #include <linux/poll.h>
 103 #include <linux/spinlock.h>
 104 #include <linux/smp_lock.h>
 105 #include <linux/bitops.h>
 106 #include <linux/wait.h>
 107
 108 #include <asm/io.h>
 109 #include <asm/page.h>
 110 #include <asm/uaccess.h>
 111
 112 #include "dm.h"
 113
 114 /* --------------------------------------------------------------------- */
 115 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
 116 #undef DMABYTEIO
 117 /* --------------------------------------------------------------------- */
 118
 119 #define CM_MAGIC  ((PCI_VENDOR_ID_CMEDIA<<16)|PCI_DEVICE_ID_CMEDIA_CM8338A)
 120
 121 /* CM8338 registers definition ****************/
 122
 123 #define CODEC_CMI_FUNCTRL0              (0x00)
 124 #define CODEC_CMI_FUNCTRL1              (0x04)
 125 #define CODEC_CMI_CHFORMAT              (0x08)
 126 #define CODEC_CMI_INT_HLDCLR            (0x0C)
 127 #define CODEC_CMI_INT_STATUS            (0x10)
 128 #define CODEC_CMI_LEGACY_CTRL           (0x14)
 129 #define CODEC_CMI_MISC_CTRL             (0x18)
 130 #define CODEC_CMI_TDMA_POS              (0x1C)
 131 #define CODEC_CMI_MIXER                 (0x20)
 132 #define CODEC_SB16_DATA                 (0x22)
 133 #define CODEC_SB16_ADDR                 (0x23)
 134 #define CODEC_CMI_MIXER1                (0x24)
 135 #define CODEC_CMI_MIXER2                (0x25)
 136 #define CODEC_CMI_AUX_VOL               (0x26)
 137 #define CODEC_CMI_MISC                  (0x27)
 138 #define CODEC_CMI_AC97                  (0x28)
 139
 140 #define CODEC_CMI_CH0_FRAME1            (0x80)
 141 #define CODEC_CMI_CH0_FRAME2            (0x84)
 142 #define CODEC_CMI_CH1_FRAME1            (0x88)
 143 #define CODEC_CMI_CH1_FRAME2            (0x8C)
 144
 145 #define CODEC_CMI_EXT_REG               (0xF0)
 146
 147 /*  Mixer registers for SB16 ******************/
 148
 149 #define DSP_MIX_DATARESETIDX            ((unsigned char)(0x00))
 150
 151 #define DSP_MIX_MASTERVOLIDX_L          ((unsigned char)(0x30))
 152 #define DSP_MIX_MASTERVOLIDX_R          ((unsigned char)(0x31))
 153 #define DSP_MIX_VOICEVOLIDX_L           ((unsigned char)(0x32))
 154 #define DSP_MIX_VOICEVOLIDX_R           ((unsigned char)(0x33))
 155 #define DSP_MIX_FMVOLIDX_L              ((unsigned char)(0x34))
 156 #define DSP_MIX_FMVOLIDX_R              ((unsigned char)(0x35))
 157 #define DSP_MIX_CDVOLIDX_L              ((unsigned char)(0x36))
 158 #define DSP_MIX_CDVOLIDX_R              ((unsigned char)(0x37))
 159 #define DSP_MIX_LINEVOLIDX_L            ((unsigned char)(0x38))
 160 #define DSP_MIX_LINEVOLIDX_R            ((unsigned char)(0x39))
 161
 162 #define DSP_MIX_MICVOLIDX               ((unsigned char)(0x3A))
 163 #define DSP_MIX_SPKRVOLIDX              ((unsigned char)(0x3B))
 164
 165 #define DSP_MIX_OUTMIXIDX               ((unsigned char)(0x3C))
 166
 167 #define DSP_MIX_ADCMIXIDX_L             ((unsigned char)(0x3D))
 168 #define DSP_MIX_ADCMIXIDX_R             ((unsigned char)(0x3E))
 169
 170 #define DSP_MIX_INGAINIDX_L             ((unsigned char)(0x3F))
 171 #define DSP_MIX_INGAINIDX_R             ((unsigned char)(0x40))
 172 #define DSP_MIX_OUTGAINIDX_L            ((unsigned char)(0x41))
 173 #define DSP_MIX_OUTGAINIDX_R            ((unsigned char)(0x42))
 174
 175 #define DSP_MIX_AGCIDX                  ((unsigned char)(0x43))
 176
 177 #define DSP_MIX_TREBLEIDX_L             ((unsigned char)(0x44))
 178 #define DSP_MIX_TREBLEIDX_R             ((unsigned char)(0x45))
 179 #define DSP_MIX_BASSIDX_L               ((unsigned char)(0x46))
 180 #define DSP_MIX_BASSIDX_R               ((unsigned char)(0x47))
 181
 182 #define CM_CH0_RESET                    0x04
 183 #define CM_CH1_RESET                    0x08
 184 #define CM_EXTENT_CODEC                 0x100
 185 #define CM_EXTENT_MIDI                  0x2
 186 #define CM_EXTENT_SYNTH                 0x4
 187 #define CM_INT_CH0                      1
 188 #define CM_INT_CH1                      2
 189
 190 #define CM_CFMT_STEREO                  0x01
 191 #define CM_CFMT_16BIT                   0x02
 192 #define CM_CFMT_MASK                    0x03
 193 #define CM_CFMT_DACSHIFT                2
 194 #define CM_CFMT_ADCSHIFT                0
 195
 196 static const unsigned sample_shift[]    = { 0, 1, 1, 2 };
 197
 198 #define CM_ENABLE_CH1      0x2
 199 #define CM_ENABLE_CH0      0x1
 200
 201 /* MIDI buffer sizes **************************/
 202
 203 #define MIDIINBUF  256
 204 #define MIDIOUTBUF 256
 205
 206 #define FMODE_MIDI_SHIFT 2
 207 #define FMODE_MIDI_READ  (FMODE_READ << FMODE_MIDI_SHIFT)
 208 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
 209
 210 #define FMODE_DMFM 0x10
 211
 212 #define SND_DEV_DSP16   5
 213
 214 #define NR_DEVICE 3             /* maximum number of devices */
 215
 216 /*********************************************/
 217
 218 struct cm_state {
 219         unsigned int magic;             /* magic */
 220         struct cm_state *next;          /* we keep cm cards in a linked list */
 221
 222         int dev_audio;                  /* soundcore stuff */
 223         int dev_mixer;
 224         int dev_midi;
 225         int dev_dmfm;
 226
 227         unsigned int iosb, iobase, iosynth,
 228                          iomidi, iogame, irq;   /* hardware resources */
 229         unsigned short deviceid;                /* pci_id */
 230
 231         struct {                                /* mixer stuff */
 232                 unsigned int modcnt;
 233                 unsigned short vol[13];
 234         } mix;
 235
 236         unsigned int rateadc, ratedac;          /* wave stuff */
 237         unsigned char fmt, enable;
 238
 239         spinlock_t lock;
 240         struct semaphore open_sem;
 241         mode_t open_mode;
 242         wait_queue_head_t open_wait;
 243
 244         struct dmabuf {
 245                 void *rawbuf;
 246                 unsigned rawphys;
 247                 unsigned buforder;
 248                 unsigned numfrag;
 249                 unsigned fragshift;
 250                 unsigned hwptr, swptr;
 251                 unsigned total_bytes;
 252                 int count;
 253                 unsigned error;         /* over/underrun */
 254                 wait_queue_head_t wait;
 255
 256                 unsigned fragsize;      /* redundant, but makes calculations easier */
 257                 unsigned dmasize;
 258                 unsigned fragsamples;
 259                 unsigned dmasamples;
 260
 261                 unsigned mapped:1;      /* OSS stuff */
 262                 unsigned ready:1;
 263                 unsigned endcleared:1;
 264                 unsigned ossfragshift;
 265                 int ossmaxfrags;
 266                 unsigned subdivision;
 267         } dma_dac, dma_adc;
 268
 269         struct {                        /* midi stuff */
 270                 unsigned ird, iwr, icnt;
 271                 unsigned ord, owr, ocnt;
 272                 wait_queue_head_t iwait;
 273                 wait_queue_head_t owait;
 274                 struct timer_list timer;
 275                 unsigned char ibuf[MIDIINBUF];
 276                 unsigned char obuf[MIDIOUTBUF];
 277         } midi;
 278
 279         int     chip_version;
 280         int     max_channels;
 281         int     curr_channels;
 282         int     speakers;               /* number of speakers */
 283         int     capability;             /* HW capability, various for chip versions */
 284
 285         int     status;                 /* HW or SW state */
 286
 287         int     spdif_counter;          /* spdif frame counter */
 288 };
 289
 290 /* flags used for capability */
 291 #define CAN_AC3_HW              0x00000001              /* 037 or later */
 292 #define CAN_AC3_SW              0x00000002              /* 033 or later */
 293 #define CAN_AC3                 (CAN_AC3_HW | CAN_AC3_SW)
 294 #define CAN_DUAL_DAC            0x00000004              /* 033 or later */
 295 #define CAN_MULTI_CH_HW         0x00000008              /* 039 or later */
 296 #define CAN_MULTI_CH            (CAN_MULTI_CH_HW | CAN_DUAL_DAC)
 297 #define CAN_LINE_AS_REAR        0x00000010              /* 033 or later */
 298 #define CAN_LINE_AS_BASS        0x00000020              /* 039 or later */
 299 #define CAN_MIC_AS_BASS         0x00000040              /* 039 or later */
 300
 301 /* flags used for status */
 302 #define DO_AC3_HW               0x00000001
 303 #define DO_AC3_SW               0x00000002
 304 #define DO_AC3                  (DO_AC3_HW | DO_AC3_SW)
 305 #define DO_DUAL_DAC             0x00000004
 306 #define DO_MULTI_CH_HW          0x00000008
 307 #define DO_MULTI_CH             (DO_MULTI_CH_HW | DO_DUAL_DAC)
 308 #define DO_LINE_AS_REAR         0x00000010              /* 033 or later */
 309 #define DO_LINE_AS_BASS         0x00000020              /* 039 or later */
 310 #define DO_MIC_AS_BASS          0x00000040              /* 039 or later */
 311 #define DO_SPDIF_OUT            0x00000100
 312 #define DO_SPDIF_IN             0x00000200
 313 #define DO_SPDIF_LOOP           0x00000400
 314
 315 static struct cm_state *devs;
 316 static unsigned long wavetable_mem;
 317
 318 /* --------------------------------------------------------------------- */
 319
 320 static inline unsigned ld2(unsigned int x)
 321 {
 322         unsigned exp=16,l=5,r=0;
 323         static const unsigned num[]={0x2,0x4,0x10,0x100,0x10000};
 324
 325         /* num: 2, 4, 16, 256, 65536 */
 326         /* exp: 1, 2,  4,   8,    16 */
 327
 328         while(l--) {
 329                 if( x >= num[l] ) {
 330                         if(num[l]>2) x >>= exp;
 331                         r+=exp;
 332                 }
 333                 exp>>=1;
 334         }
 335
 336         return r;
 337 }
 338
 339 /* --------------------------------------------------------------------- */
 340
 341 static void maskb(unsigned int addr, unsigned int mask, unsigned int value)
 342 {
 343         outb((inb(addr) & mask) | value, addr);
 344 }
 345
 346 static void maskw(unsigned int addr, unsigned int mask, unsigned int value)
 347 {
 348         outw((inw(addr) & mask) | value, addr);
 349 }
 350
 351 static void maskl(unsigned int addr, unsigned int mask, unsigned int value)
 352 {
 353         outl((inl(addr) & mask) | value, addr);
 354 }
 355
 356 static void set_dmadac1(struct cm_state *s, unsigned int addr, unsigned int count)
 357 {
 358         if (addr)
 359             outl(addr, s->iobase + CODEC_CMI_CH0_FRAME1);
 360         outw(count - 1, s->iobase + CODEC_CMI_CH0_FRAME2);
 361         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~1, 0);
 362 }
 363
 364 static void set_dmaadc(struct cm_state *s, unsigned int addr, unsigned int count)
 365 {
 366         outl(addr, s->iobase + CODEC_CMI_CH0_FRAME1);
 367         outw(count - 1, s->iobase + CODEC_CMI_CH0_FRAME2);
 368         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~0, 1);
 369 }
 370
 371 static void set_dmadac(struct cm_state *s, unsigned int addr, unsigned int count)
 372 {
 373         outl(addr, s->iobase + CODEC_CMI_CH1_FRAME1);
 374         outw(count - 1, s->iobase + CODEC_CMI_CH1_FRAME2);
 375         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~2, 0);
 376         if (s->status & DO_DUAL_DAC)
 377                 set_dmadac1(s, 0, count);
 378 }
 379
 380 static void set_countadc(struct cm_state *s, unsigned count)
 381 {
 382         outw(count - 1, s->iobase + CODEC_CMI_CH0_FRAME2 + 2);
 383 }
 384
 385 static void set_countdac(struct cm_state *s, unsigned count)
 386 {
 387         outw(count - 1, s->iobase + CODEC_CMI_CH1_FRAME2 + 2);
 388         if (s->status & DO_DUAL_DAC)
 389             set_countadc(s, count);
 390 }
 391
 392 static inline unsigned get_dmadac(struct cm_state *s)
 393 {
 394         unsigned int curr_addr;
 395
 396         curr_addr = inw(s->iobase + CODEC_CMI_CH1_FRAME2) + 1;
 397         curr_addr <<= sample_shift[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK];
 398         curr_addr = s->dma_dac.dmasize - curr_addr;
 399
 400         return curr_addr;
 401 }
 402
 403 static inline unsigned get_dmaadc(struct cm_state *s)
 404 {
 405         unsigned int curr_addr;
 406
 407         curr_addr = inw(s->iobase + CODEC_CMI_CH0_FRAME2) + 1;
 408         curr_addr <<= sample_shift[(s->fmt >> CM_CFMT_ADCSHIFT) & CM_CFMT_MASK];
 409         curr_addr = s->dma_adc.dmasize - curr_addr;
 410
 411         return curr_addr;
 412 }
 413
 414 static void wrmixer(struct cm_state *s, unsigned char idx, unsigned char data)
 415 {
 416         outb(idx, s->iobase + CODEC_SB16_ADDR);
 417         udelay(10);
 418         outb(data, s->iobase + CODEC_SB16_DATA);
 419         udelay(10);
 420 }
 421
 422 static unsigned char rdmixer(struct cm_state *s, unsigned char idx)
 423 {
 424         unsigned char v;
 425         unsigned long flags;
 426
 427         spin_lock_irqsave(&s->lock, flags);
 428         outb(idx, s->iobase + CODEC_SB16_ADDR);
 429         udelay(10);
 430         v = inb(s->iobase + CODEC_SB16_DATA);
 431         udelay(10);
 432         spin_unlock_irqrestore(&s->lock, flags);
 433         return v;
 434 }
 435
 436 static void set_fmt_unlocked(struct cm_state *s, unsigned char mask, unsigned char data)
 437 {
 438         if (mask)
 439         {
 440                 s->fmt = inb(s->iobase + CODEC_CMI_CHFORMAT);
 441                 udelay(10);
 442         }
 443         s->fmt = (s->fmt & mask) | data;
 444         outb(s->fmt, s->iobase + CODEC_CMI_CHFORMAT);
 445         udelay(10);
 446 }
 447
 448 static void set_fmt(struct cm_state *s, unsigned char mask, unsigned char data)
 449 {
 450         unsigned long flags;
 451
 452         spin_lock_irqsave(&s->lock, flags);
 453         set_fmt_unlocked(s,mask,data);
 454         spin_unlock_irqrestore(&s->lock, flags);
 455 }
 456
 457 static void frobindir(struct cm_state *s, unsigned char idx, unsigned char mask, unsigned char data)
 458 {
 459         outb(idx, s->iobase + CODEC_SB16_ADDR);
 460         udelay(10);
 461         outb((inb(s->iobase + CODEC_SB16_DATA) & mask) | data, s->iobase + CODEC_SB16_DATA);
 462         udelay(10);
 463 }
 464
 465 static struct {
 466         unsigned        rate;
 467         unsigned        lower;
 468         unsigned        upper;
 469         unsigned char   freq;
 470 } rate_lookup[] =
 471 {
 472         { 5512,         (0 + 5512) / 2,         (5512 + 8000) / 2,      0 },
 473         { 8000,         (5512 + 8000) / 2,      (8000 + 11025) / 2,     4 },
 474         { 11025,        (8000 + 11025) / 2,     (11025 + 16000) / 2,    1 },
 475         { 16000,        (11025 + 16000) / 2,    (16000 + 22050) / 2,    5 },
 476         { 22050,        (16000 + 22050) / 2,    (22050 + 32000) / 2,    2 },
 477         { 32000,        (22050 + 32000) / 2,    (32000 + 44100) / 2,    6 },
 478         { 44100,        (32000 + 44100) / 2,    (44100 + 48000) / 2,    3 },
 479         { 48000,        (44100 + 48000) / 2,    48000,                  7 }
 480 };
 481
 482 static void set_spdifout_unlocked(struct cm_state *s, unsigned rate)
 483 {
 484         if (rate == 48000 || rate == 44100) {
 485                 // SPDIFI48K SPDF_ACc97
 486                 maskl(s->iobase + CODEC_CMI_MISC_CTRL, ~0x01008000, rate == 48000 ? 0x01008000 : 0);
 487                 // ENSPDOUT
 488                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 2, ~0, 0x80);
 489                 // SPDF_1 SPD2DAC
 490                 maskw(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x240);
 491                 // CDPLAY
 492                 if (s->chip_version >= 39)
 493                         maskb(s->iobase + CODEC_CMI_MIXER1, ~0, 1);
 494                 s->status |= DO_SPDIF_OUT;
 495         } else {
 496                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 2, ~0x80, 0);
 497                 maskw(s->iobase + CODEC_CMI_FUNCTRL1, ~0x240, 0);
 498                 if (s->chip_version >= 39)
 499                         maskb(s->iobase + CODEC_CMI_MIXER1, ~1, 0);
 500                 s->status &= ~DO_SPDIF_OUT;
 501         }
 502 }
 503
 504 static void set_spdifout(struct cm_state *s, unsigned rate)
 505 {
 506         unsigned long flags;
 507
 508         spin_lock_irqsave(&s->lock, flags);
 509         set_spdifout_unlocked(s,rate);
 510         spin_unlock_irqrestore(&s->lock, flags);
 511 }
 512
 513 /* find parity for bit 4~30 */
 514 static unsigned parity(unsigned data)
 515 {
 516         unsigned parity = 0;
 517         int counter = 4;
 518
 519         data >>= 4;     // start from bit 4
 520         while (counter <= 30) {
 521                 if (data & 1)
 522                         parity++;
 523                 data >>= 1;
 524                 counter++;
 525         }
 526         return parity & 1;
 527 }
 528
 529 static void set_ac3_unlocked(struct cm_state *s, unsigned rate)
 530 {
 531         /* enable AC3 */
 532         if (rate == 48000 || rate == 44100) {
 533                 // mute DAC
 534                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0, 0x40);
 535                 // AC3EN for 037, 0x10
 536                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~0, 0x10);
 537                 // AC3EN for 039, 0x04
 538                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0, 0x04);
 539                 if (s->capability & CAN_AC3_HW) {
 540                         // SPD24SEL for 037, 0x02
 541                         // SPD24SEL for 039, 0x20, but cannot be set
 542                         maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~0, 0x02);
 543                         s->status |= DO_AC3_HW;
 544                         if (s->chip_version >= 39)
 545                                 maskb(s->iobase + CODEC_CMI_MIXER1, ~1, 0);
 546                  } else {
 547                         // SPD32SEL for 037 & 039, 0x20
 548                         maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0, 0x20);
 549                         // set 176K sample rate to fix 033 HW bug
 550                         if (s->chip_version == 33) {
 551                                 if (rate == 48000)
 552                                         maskb(s->iobase + CODEC_CMI_CHFORMAT + 1, ~0, 0x08);
 553                                 else
 554                                         maskb(s->iobase + CODEC_CMI_CHFORMAT + 1, ~0x08, 0);
 555                         }
 556                         s->status |= DO_AC3_SW;
 557                 }
 558         } else {
 559                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0x40, 0);
 560                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~0x32, 0);
 561                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0x24, 0);
 562                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 1, ~0x08, 0);
 563                 if (s->chip_version == 33)
 564                         maskb(s->iobase + CODEC_CMI_CHFORMAT + 1, ~0x08, 0);
 565                 if (s->chip_version >= 39)
 566                         maskb(s->iobase + CODEC_CMI_MIXER1, ~0, 1);
 567                 s->status &= ~DO_AC3;
 568         }
 569         s->spdif_counter = 0;
 570
 571 }
 572
 573 static void set_ac3(struct cm_state *s, unsigned rate)
 574 {
 575         unsigned long flags;
 576
 577         spin_lock_irqsave(&s->lock, flags);
 578         set_spdifout_unlocked(s, rate);
 579         set_ac3_unlocked(s,rate);
 580         spin_unlock_irqrestore(&s->lock, flags);
 581 }
 582
 583 static int trans_ac3(struct cm_state *s, void *dest, const char *source, int size)
 584 {
 585         int   i = size / 2;
 586         int err;
 587         unsigned long data;
 588         unsigned long *dst = (unsigned long *) dest;
 589         unsigned short *src = (unsigned short *)source;
 590
 591         do {
 592                 if ((err = __get_user(data, src++)))
 593                         return err;
 594                 data <<= 12;                    // ok for 16-bit data
 595                 if (s->spdif_counter == 2 || s->spdif_counter == 3)
 596                         data |= 0x40000000;     // indicate AC-3 raw data
 597                 if (parity(data))
 598                         data |= 0x80000000;     // parity
 599                 if (s->spdif_counter == 0)
 600                         data |= 3;              // preamble 'M'
 601                 else if (s->spdif_counter & 1)
 602                         data |= 5;              // odd, 'W'
 603                 else
 604                         data |= 9;              // even, 'M'
 605                 *dst++ = data;
 606                 s->spdif_counter++;
 607                 if (s->spdif_counter == 384)
 608                         s->spdif_counter = 0;
 609         } while (--i);
 610
 611         return 0;
 612 }
 613
 614 static void set_adc_rate_unlocked(struct cm_state *s, unsigned rate)
 615 {
 616         unsigned char freq = 4;
 617         int     i;
 618
 619         if (rate > 48000)
 620                 rate = 48000;
 621         if (rate < 8000)
 622                 rate = 8000;
 623         for (i = 0; i < sizeof(rate_lookup) / sizeof(rate_lookup[0]); i++) {
 624                 if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper) {
 625                         rate = rate_lookup[i].rate;
 626                         freq = rate_lookup[i].freq;
 627                         break;
 628                 }
 629         }
 630         s->rateadc = rate;
 631         freq <<= 2;
 632
 633         maskb(s->iobase + CODEC_CMI_FUNCTRL1 + 1, ~0x1c, freq);
 634 }
 635
 636 static void set_adc_rate(struct cm_state *s, unsigned rate)
 637 {
 638         unsigned long flags;
 639         unsigned char freq = 4;
 640         int     i;
 641
 642         if (rate > 48000)
 643                 rate = 48000;
 644         if (rate < 8000)
 645                 rate = 8000;
 646         for (i = 0; i < sizeof(rate_lookup) / sizeof(rate_lookup[0]); i++) {
 647                 if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper) {
 648                         rate = rate_lookup[i].rate;
 649                         freq = rate_lookup[i].freq;
 650                         break;
 651                 }
 652         }
 653         s->rateadc = rate;
 654         freq <<= 2;
 655
 656         spin_lock_irqsave(&s->lock, flags);
 657         maskb(s->iobase + CODEC_CMI_FUNCTRL1 + 1, ~0x1c, freq);
 658         spin_unlock_irqrestore(&s->lock, flags);
 659 }
 660
 661 static void set_dac_rate(struct cm_state *s, unsigned rate)
 662 {
 663         unsigned long flags;
 664         unsigned char freq = 4;
 665         int     i;
 666
 667         if (rate > 48000)
 668                 rate = 48000;
 669         if (rate < 8000)
 670                 rate = 8000;
 671         for (i = 0; i < sizeof(rate_lookup) / sizeof(rate_lookup[0]); i++) {
 672                 if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper) {
 673                         rate = rate_lookup[i].rate;
 674                         freq = rate_lookup[i].freq;
 675                         break;
 676                 }
 677         }
 678         s->ratedac = rate;
 679         freq <<= 5;
 680
 681         spin_lock_irqsave(&s->lock, flags);
 682         maskb(s->iobase + CODEC_CMI_FUNCTRL1 + 1, ~0xe0, freq);
 683
 684
 685         if (s->curr_channels <=  2)
 686                 set_spdifout_unlocked(s, rate);
 687         if (s->status & DO_DUAL_DAC)
 688                 set_adc_rate_unlocked(s, rate);
 689
 690         spin_unlock_irqrestore(&s->lock, flags);
 691 }
 692
 693 /* --------------------------------------------------------------------- */
 694 static inline void reset_adc(struct cm_state *s)
 695 {
 696         /* reset bus master */
 697         outb(s->enable | CM_CH0_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 698         udelay(10);
 699         outb(s->enable & ~CM_CH0_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 700 }
 701
 702 static inline void reset_dac(struct cm_state *s)
 703 {
 704         /* reset bus master */
 705         outb(s->enable | CM_CH1_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 706         outb(s->enable & ~CM_CH1_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 707         if (s->status & DO_DUAL_DAC)
 708                 reset_adc(s);
 709 }
 710
 711 static inline void pause_adc(struct cm_state *s)
 712 {
 713         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~0, 4);
 714 }
 715
 716 static inline void pause_dac(struct cm_state *s)
 717 {
 718         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~0, 8);
 719         if (s->status & DO_DUAL_DAC)
 720                 pause_adc(s);
 721 }
 722
 723 static inline void disable_adc(struct cm_state *s)
 724 {
 725         /* disable channel */
 726         s->enable &= ~CM_ENABLE_CH0;
 727         outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 728         reset_adc(s);
 729 }
 730
 731 static inline void disable_dac(struct cm_state *s)
 732 {
 733         /* disable channel */
 734         s->enable &= ~CM_ENABLE_CH1;
 735         outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 736         reset_dac(s);
 737         if (s->status & DO_DUAL_DAC)
 738                 disable_adc(s);
 739 }
 740
 741 static inline void enable_adc(struct cm_state *s)
 742 {
 743         if (!(s->enable & CM_ENABLE_CH0)) {
 744                 /* enable channel */
 745                 s->enable |= CM_ENABLE_CH0;
 746                 outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 747         }
 748         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~4, 0);
 749 }
 750
 751 static inline void enable_dac_unlocked(struct cm_state *s)
 752 {
 753         if (!(s->enable & CM_ENABLE_CH1)) {
 754                 /* enable channel */
 755                 s->enable |= CM_ENABLE_CH1;
 756                 outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
 757         }
 758         maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~8, 0);
 759
 760         if (s->status & DO_DUAL_DAC)
 761                 enable_adc(s);
 762 }
 763
 764 static inline void enable_dac(struct cm_state *s)
 765 {
 766         unsigned long flags;
 767
 768         spin_lock_irqsave(&s->lock, flags);
 769         enable_dac_unlocked(s);
 770         spin_unlock_irqrestore(&s->lock, flags);
 771 }
 772
 773 static inline void stop_adc_unlocked(struct cm_state *s)
 774 {
 775         if (s->enable & CM_ENABLE_CH0) {
 776                 /* disable interrupt */
 777                 maskb(s->iobase + CODEC_CMI_INT_HLDCLR + 2, ~1, 0);
 778                 disable_adc(s);
 779         }
 780 }
 781
 782 static inline void stop_adc(struct cm_state *s)
 783 {
 784         unsigned long flags;
 785
 786         spin_lock_irqsave(&s->lock, flags);
 787         stop_adc_unlocked(s);
 788         spin_unlock_irqrestore(&s->lock, flags);
 789
 790 }
 791
 792 static inline void stop_dac_unlocked(struct cm_state *s)
 793 {
 794         if (s->enable & CM_ENABLE_CH1) {
 795                 /* disable interrupt */
 796                 maskb(s->iobase + CODEC_CMI_INT_HLDCLR + 2, ~2, 0);
 797                 disable_dac(s);
 798         }
 799         if (s->status & DO_DUAL_DAC)
 800                 stop_adc_unlocked(s);
 801 }
 802
 803 static inline void stop_dac(struct cm_state *s)
 804 {
 805         unsigned long flags;
 806
 807         spin_lock_irqsave(&s->lock, flags);
 808         stop_dac_unlocked(s);
 809         spin_unlock_irqrestore(&s->lock, flags);
 810 }
 811
 812 static void start_adc_unlocked(struct cm_state *s)
 813 {
 814         if ((s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize))
 815             && s->dma_adc.ready) {
 816                 /* enable interrupt */
 817                 maskb(s->iobase + CODEC_CMI_INT_HLDCLR + 2, ~0, 1);
 818                 enable_adc(s);
 819         }
 820 }
 821
 822 static void start_adc(struct cm_state *s)
 823 {
 824         unsigned long flags;
 825
 826         spin_lock_irqsave(&s->lock, flags);
 827         start_adc_unlocked(s);
 828         spin_unlock_irqrestore(&s->lock, flags);
 829 }
 830
 831 static void start_dac1_unlocked(struct cm_state *s)
 832 {
 833         if ((s->dma_adc.mapped || s->dma_adc.count > 0) && s->dma_adc.ready) {
 834                 /* enable interrupt */
 835 //              maskb(s->iobase + CODEC_CMI_INT_HLDCLR + 2, ~0, 1);
 836                 enable_dac_unlocked(s);
 837         }
 838 }
 839
 840 static void start_dac_unlocked(struct cm_state *s)
 841 {
 842         if ((s->dma_dac.mapped || s->dma_dac.count > 0) && s->dma_dac.ready) {
 843                 /* enable interrupt */
 844                 maskb(s->iobase + CODEC_CMI_INT_HLDCLR + 2, ~0, 2);
 845                 enable_dac_unlocked(s);
 846         }
 847                 if (s->status & DO_DUAL_DAC)
 848                         start_dac1_unlocked(s);
 849 }
 850
 851 static void start_dac(struct cm_state *s)
 852 {
 853         unsigned long flags;
 854
 855         spin_lock_irqsave(&s->lock, flags);
 856         start_dac_unlocked(s);
 857         spin_unlock_irqrestore(&s->lock, flags);
 858 }
 859
 860 static int prog_dmabuf(struct cm_state *s, unsigned rec);
 861
 862 static int set_dac_channels(struct cm_state *s, int channels)
 863 {
 864         unsigned long flags;
 865         spin_lock_irqsave(&s->lock, flags);
 866
 867         if ((channels > 2) && (channels <= s->max_channels)
 868          && (((s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK) == (CM_CFMT_STEREO | CM_CFMT_16BIT))) {
 869             set_spdifout_unlocked(s, 0);
 870             if (s->capability & CAN_MULTI_CH_HW) {
 871                 // NXCHG
 872                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3, ~0, 0x80);
 873                 // CHB3D or CHB3D5C
 874                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 3, ~0xa0, channels > 4 ? 0x80 : 0x20);
 875                 // CHB3D6C
 876                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0x80, channels == 6 ? 0x80 : 0);
 877                 // ENCENTER
 878                 maskb(s->iobase + CODEC_CMI_MISC_CTRL, ~0x80, channels == 6 ? 0x80 : 0);
 879                 s->status |= DO_MULTI_CH_HW;
 880             } else if (s->capability & CAN_DUAL_DAC) {
 881                 unsigned char fmtm = ~0, fmts = 0;
 882                 ssize_t ret;
 883
 884                 // ENDBDAC, turn on double DAC mode
 885                 // XCHGDAC, CH0 -> back, CH1->front
 886                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0, 0xC0);
 887                 s->status |= DO_DUAL_DAC;
 888                 // prepare secondary buffer
 889
 890                 spin_unlock_irqrestore(&s->lock, flags);
 891                 ret = prog_dmabuf(s, 1);
 892                 if (ret) return ret;
 893                 spin_lock_irqsave(&s->lock, flags);
 894
 895                 // copy the hw state
 896                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
 897                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_ADCSHIFT);
 898                 // the HW only support 16-bit stereo
 899                 fmts |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
 900                 fmts |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
 901                 fmts |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
 902                 fmts |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
 903
 904                 set_fmt_unlocked(s, fmtm, fmts);
 905                 set_adc_rate_unlocked(s, s->ratedac);
 906
 907             }
 908
 909             if (s->speakers > 2)
 910                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 3, ~0x04, 0);
 911             s->curr_channels = channels;
 912         } else {
 913             if (s->status & DO_MULTI_CH_HW) {
 914                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3, ~0x80, 0);
 915                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 3, ~0xa0, 0);
 916                 maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0x80, 0);
 917             } else if (s->status & DO_DUAL_DAC) {
 918                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0x80, 0);
 919             }
 920             // N4SPK3D, enable 4 speaker mode (analog duplicate)
 921             if (s->speakers > 2)
 922                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 3, ~0, 0x04);
 923             s->status &= ~DO_MULTI_CH;
 924             s->curr_channels = s->fmt & (CM_CFMT_STEREO << CM_CFMT_DACSHIFT) ? 2 : 1;
 925         }
 926
 927         spin_unlock_irqrestore(&s->lock, flags);
 928         return s->curr_channels;
 929 }
 930
 931 /* --------------------------------------------------------------------- */
 932
 933 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
 934 #define DMABUF_MINORDER 1
 935
 936 static void dealloc_dmabuf(struct dmabuf *db)
 937 {
 938         struct page *pstart, *pend;
 939
 940         if (db->rawbuf) {
 941                 /* undo marking the pages as reserved */
 942                 pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
 943                 for (pstart = virt_to_page(db->rawbuf); pstart <= pend; pstart++)
 944                         ClearPageReserved(pstart);
 945                 free_pages((unsigned long)db->rawbuf, db->buforder);
 946         }
 947         db->rawbuf = NULL;
 948         db->mapped = db->ready = 0;
 949 }
 950
 951 /* Ch1 is used for playback, Ch0 is used for recording */
 952
 953 static int prog_dmabuf(struct cm_state *s, unsigned rec)
 954 {
 955         struct dmabuf *db = rec ? &s->dma_adc : &s->dma_dac;
 956         unsigned rate = rec ? s->rateadc : s->ratedac;
 957         int order;
 958         unsigned bytepersec;
 959         unsigned bufs;
 960         struct page *pstart, *pend;
 961         unsigned char fmt;
 962         unsigned long flags;
 963
 964         fmt = s->fmt;
 965         if (rec) {
 966                 stop_adc(s);
 967                 fmt >>= CM_CFMT_ADCSHIFT;
 968         } else {
 969                 stop_dac(s);
 970                 fmt >>= CM_CFMT_DACSHIFT;
 971         }
 972
 973         fmt &= CM_CFMT_MASK;
 974         db->hwptr = db->swptr = db->total_bytes = db->count = db->error = db->endcleared = 0;
 975         if (!db->rawbuf) {
 976                 db->ready = db->mapped = 0;
 977                 for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--)
 978                         if ((db->rawbuf = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA, order)))
 979                                 break;
 980                 if (!db->rawbuf)
 981                         return -ENOMEM;
 982                 db->buforder = order;
 983                 db->rawphys = virt_to_bus(db->rawbuf);
 984                 if ((db->rawphys ^ (db->rawphys + (PAGE_SIZE << db->buforder) - 1)) & ~0xffff)
 985                         printk(KERN_DEBUG "cmpci: DMA buffer crosses 64k boundary: busaddr 0x%lx  size %ld\n",
 986                                (long) db->rawphys, PAGE_SIZE << db->buforder);
 987                 if ((db->rawphys + (PAGE_SIZE << db->buforder) - 1) & ~0xffffff)
 988                         printk(KERN_DEBUG "cmpci: DMA buffer beyond 16MB: busaddr 0x%lx  size %ld\n",
 989                                (long) db->rawphys, PAGE_SIZE << db->buforder);
 990                 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
 991                 pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
 992                 for (pstart = virt_to_page(db->rawbuf); pstart <= pend; pstart++)
 993                         SetPageReserved(pstart);
 994         }
 995         bytepersec = rate << sample_shift[fmt];
 996         bufs = PAGE_SIZE << db->buforder;
 997         if (db->ossfragshift) {
 998                 if ((1000 << db->ossfragshift) < bytepersec)
 999                         db->fragshift = ld2(bytepersec/1000);
1000                 else
1001                         db->fragshift = db->ossfragshift;
1002         } else {
1003                 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
1004                 if (db->fragshift < 3)
1005                         db->fragshift = 3;
1006         }
1007         db->numfrag = bufs >> db->fragshift;
1008         while (db->numfrag < 4 && db->fragshift > 3) {
1009                 db->fragshift--;
1010                 db->numfrag = bufs >> db->fragshift;
1011         }
1012         db->fragsize = 1 << db->fragshift;
1013         if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
1014                 db->numfrag = db->ossmaxfrags;
1015         /* to make fragsize >= 4096 */
1016         db->fragsamples = db->fragsize >> sample_shift[fmt];
1017         db->dmasize = db->numfrag << db->fragshift;
1018         db->dmasamples = db->dmasize >> sample_shift[fmt];
1019         memset(db->rawbuf, (fmt & CM_CFMT_16BIT) ? 0 : 0x80, db->dmasize);
1020         spin_lock_irqsave(&s->lock, flags);
1021         if (rec) {
1022                 if (s->status & DO_DUAL_DAC)
1023                     set_dmadac1(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
1024                 else
1025                     set_dmaadc(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
1026                 /* program sample counts */
1027                 set_countdac(s, db->fragsamples);
1028         } else {
1029                 set_dmadac(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
1030                 /* program sample counts */
1031                 set_countdac(s, db->fragsamples);
1032         }
1033         spin_unlock_irqrestore(&s->lock, flags);
1034         db->ready = 1;
1035         return 0;
1036 }
1037
1038 static inline void clear_advance(struct cm_state *s)
1039 {
1040         unsigned char c = (s->fmt & (CM_CFMT_16BIT << CM_CFMT_DACSHIFT)) ? 0 : 0x80;
1041         unsigned char *buf = s->dma_dac.rawbuf;
1042         unsigned char *buf1 = s->dma_adc.rawbuf;
1043         unsigned bsize = s->dma_dac.dmasize;
1044         unsigned bptr = s->dma_dac.swptr;
1045         unsigned len = s->dma_dac.fragsize;
1046
1047         if (bptr + len > bsize) {
1048                 unsigned x = bsize - bptr;
1049                 memset(buf + bptr, c, x);
1050                 if (s->status & DO_DUAL_DAC)
1051                         memset(buf1 + bptr, c, x);
1052                 bptr = 0;
1053                 len -= x;
1054         }
1055         memset(buf + bptr, c, len);
1056         if (s->status & DO_DUAL_DAC)
1057                 memset(buf1 + bptr, c, len);
1058 }
1059
1060 /* call with spinlock held! */
1061 static void cm_update_ptr(struct cm_state *s)
1062 {
1063         unsigned hwptr;
1064         int diff;
1065
1066         /* update ADC pointer */
1067         if (s->dma_adc.ready) {
1068             if (s->status & DO_DUAL_DAC) {
1069                 hwptr = get_dmaadc(s) % s->dma_adc.dmasize;
1070                 diff = (s->dma_adc.dmasize + hwptr - s->dma_adc.hwptr) % s->dma_adc.dmasize;
1071                 s->dma_adc.hwptr = hwptr;
1072                 s->dma_adc.total_bytes += diff;
1073                 if (s->dma_adc.mapped) {
1074                         s->dma_adc.count += diff;
1075                         if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1076                                 wake_up(&s->dma_adc.wait);
1077                 } else {
1078                         s->dma_adc.count -= diff;
1079                         if (s->dma_adc.count <= 0) {
1080                                 pause_adc(s);
1081                                 s->dma_adc.error++;
1082                         } else if (s->dma_adc.count <= (signed)s->dma_adc.fragsize && !s->dma_adc.endcleared) {
1083                                 clear_advance(s);
1084                                 s->dma_adc.endcleared = 1;
1085                         }
1086                         if (s->dma_dac.count + (signed)s->dma_dac.fragsize <= (signed)s->dma_dac.dmasize)
1087                                 wake_up(&s->dma_adc.wait);
1088                 }
1089             } else {
1090                 hwptr = get_dmaadc(s) % s->dma_adc.dmasize;
1091                 diff = (s->dma_adc.dmasize + hwptr - s->dma_adc.hwptr) % s->dma_adc.dmasize;
1092                 s->dma_adc.hwptr = hwptr;
1093                 s->dma_adc.total_bytes += diff;
1094                 s->dma_adc.count += diff;
1095                 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1096                         wake_up(&s->dma_adc.wait);
1097                 if (!s->dma_adc.mapped) {
1098                         if (s->dma_adc.count > (signed)(s->dma_adc.dmasize - ((3 * s->dma_adc.fragsize) >> 1))) {
1099                                 pause_adc(s);
1100                                 s->dma_adc.error++;
1101                         }
1102                 }
1103             }
1104         }
1105         /* update DAC pointer */
1106         if (s->dma_dac.ready) {
1107                 hwptr = get_dmadac(s) % s->dma_dac.dmasize;
1108                 diff = (s->dma_dac.dmasize + hwptr - s->dma_dac.hwptr) % s->dma_dac.dmasize;
1109                 s->dma_dac.hwptr = hwptr;
1110                 s->dma_dac.total_bytes += diff;
1111                 if (s->dma_dac.mapped) {
1112                         s->dma_dac.count += diff;
1113                         if (s->dma_dac.count >= (signed)s->dma_dac.fragsize)
1114                                 wake_up(&s->dma_dac.wait);
1115                 } else {
1116                         s->dma_dac.count -= diff;
1117                         if (s->dma_dac.count <= 0) {
1118                                 pause_dac(s);
1119                                 s->dma_dac.error++;
1120                         } else if (s->dma_dac.count <= (signed)s->dma_dac.fragsize && !s->dma_dac.endcleared) {
1121                                 clear_advance(s);
1122                                 s->dma_dac.endcleared = 1;
1123                         }
1124                         if (s->dma_dac.count + (signed)s->dma_dac.fragsize <= (signed)s->dma_dac.dmasize)
1125                                 wake_up(&s->dma_dac.wait);
1126                 }
1127         }
1128 }
1129
1130 #ifdef CONFIG_SOUND_CMPCI_MIDI
1131 /* hold spinlock for the following! */
1132 static void cm_handle_midi(struct cm_state *s)
1133 {
1134         unsigned char ch;
1135         int wake;
1136
1137         wake = 0;
1138         while (!(inb(s->iomidi+1) & 0x80)) {
1139                 ch = inb(s->iomidi);
1140                 if (s->midi.icnt < MIDIINBUF) {
1141                         s->midi.ibuf[s->midi.iwr] = ch;
1142                         s->midi.iwr = (s->midi.iwr + 1) % MIDIINBUF;
1143                         s->midi.icnt++;
1144                 }
1145                 wake = 1;
1146         }
1147         if (wake)
1148                 wake_up(&s->midi.iwait);
1149         wake = 0;
1150         while (!(inb(s->iomidi+1) & 0x40) && s->midi.ocnt > 0) {
1151                 outb(s->midi.obuf[s->midi.ord], s->iomidi);
1152                 s->midi.ord = (s->midi.ord + 1) % MIDIOUTBUF;
1153                 s->midi.ocnt--;
1154                 if (s->midi.ocnt < MIDIOUTBUF-16)
1155                         wake = 1;
1156         }
1157         if (wake)
1158                 wake_up(&s->midi.owait);
1159 }
1160 #endif
1161
1162 static irqreturn_t cm_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1163 {
1164         struct cm_state *s = (struct cm_state *)dev_id;
1165         unsigned int intsrc, intstat;
1166         unsigned char mask = 0;
1167
1168         /* fastpath out, to ease interrupt sharing */
1169         intsrc = inl(s->iobase + CODEC_CMI_INT_STATUS);
1170         if (!(intsrc & 0x80000000))
1171                 return IRQ_NONE;
1172         spin_lock(&s->lock);
1173         intstat = inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2);
1174         /* acknowledge interrupt */
1175         if (intsrc & CM_INT_CH0)
1176                 mask |= 1;
1177         if (intsrc & CM_INT_CH1)
1178                 mask |= 2;
1179         outb(intstat & ~mask, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
1180         outb(intstat | mask, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
1181         cm_update_ptr(s);
1182 #ifdef CONFIG_SOUND_CMPCI_MIDI
1183         cm_handle_midi(s);
1184 #endif
1185         spin_unlock(&s->lock);
1186         return IRQ_HANDLED;
1187 }
1188
1189 #ifdef CONFIG_SOUND_CMPCI_MIDI
1190 static void cm_midi_timer(unsigned long data)
1191 {
1192         struct cm_state *s = (struct cm_state *)data;
1193         unsigned long flags;
1194
1195         spin_lock_irqsave(&s->lock, flags);
1196         cm_handle_midi(s);
1197         spin_unlock_irqrestore(&s->lock, flags);
1198         s->midi.timer.expires = jiffies+1;
1199         add_timer(&s->midi.timer);
1200 }
1201 #endif
1202
1203 /* --------------------------------------------------------------------- */
1204
1205 static const char invalid_magic[] = KERN_CRIT "cmpci: invalid magic value\n";
1206
1207 #ifdef CONFIG_SOUND_CMPCI       /* support multiple chips */
1208 #define VALIDATE_STATE(s)
1209 #else
1210 #define VALIDATE_STATE(s)                         \
1211 ({                                                \
1212         if (!(s) || (s)->magic != CM_MAGIC) { \
1213                 printk(invalid_magic);            \
1214                 return -ENXIO;                    \
1215         }                                         \
1216 })
1217 #endif
1218
1219 /* --------------------------------------------------------------------- */
1220
1221 #define MT_4          1
1222 #define MT_5MUTE      2
1223 #define MT_4MUTEMONO  3
1224 #define MT_6MUTE      4
1225 #define MT_5MUTEMONO  5
1226
1227 static const struct {
1228         unsigned left;
1229         unsigned right;
1230         unsigned type;
1231         unsigned rec;
1232         unsigned play;
1233 } mixtable[SOUND_MIXER_NRDEVICES] = {
1234         [SOUND_MIXER_CD]     = { DSP_MIX_CDVOLIDX_L,     DSP_MIX_CDVOLIDX_R,     MT_5MUTE,     0x04, 0x02 },
1235         [SOUND_MIXER_LINE]   = { DSP_MIX_LINEVOLIDX_L,   DSP_MIX_LINEVOLIDX_R,   MT_5MUTE,     0x10, 0x08 },
1236         [SOUND_MIXER_MIC]    = { DSP_MIX_MICVOLIDX,      DSP_MIX_MICVOLIDX,      MT_5MUTEMONO, 0x01, 0x01 },
1237         [SOUND_MIXER_SYNTH]  = { DSP_MIX_FMVOLIDX_L,     DSP_MIX_FMVOLIDX_R,     MT_5MUTE,     0x40, 0x00 },
1238         [SOUND_MIXER_VOLUME] = { DSP_MIX_MASTERVOLIDX_L, DSP_MIX_MASTERVOLIDX_R, MT_5MUTE,     0x00, 0x00 },
1239         [SOUND_MIXER_PCM]    = { DSP_MIX_VOICEVOLIDX_L,  DSP_MIX_VOICEVOLIDX_R,  MT_5MUTE,     0x00, 0x00 },
1240         [SOUND_MIXER_SPEAKER]= { DSP_MIX_SPKRVOLIDX,     DSP_MIX_SPKRVOLIDX,     MT_5MUTEMONO, 0x01, 0x01 }
1241 };
1242
1243 static const unsigned char volidx[SOUND_MIXER_NRDEVICES] =
1244 {
1245         [SOUND_MIXER_CD]     = 1,
1246         [SOUND_MIXER_LINE]   = 2,
1247         [SOUND_MIXER_MIC]    = 3,
1248         [SOUND_MIXER_SYNTH]  = 4,
1249         [SOUND_MIXER_VOLUME] = 5,
1250         [SOUND_MIXER_PCM]    = 6,
1251         [SOUND_MIXER_SPEAKER]= 7
1252 };
1253
1254 static unsigned mixer_recmask(struct cm_state *s)
1255 {
1256         int i, j, k;
1257
1258         j = rdmixer(s, DSP_MIX_ADCMIXIDX_L);
1259         j &= 0x7f;
1260         for (k = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1261                 if (j & mixtable[i].rec)
1262                         k |= 1 << i;
1263         return k;
1264 }
1265
1266 static int mixer_ioctl(struct cm_state *s, unsigned int cmd, unsigned long arg)
1267 {
1268         unsigned long flags;
1269         int i, val, j;
1270         unsigned char l, r, rl, rr;
1271
1272         VALIDATE_STATE(s);
1273         if (cmd == SOUND_MIXER_INFO) {
1274                 mixer_info info;
1275                 memset(&info, 0, sizeof(info));
1276                 strlcpy(info.id, "cmpci", sizeof(info.id));
1277                 strlcpy(info.name, "C-Media PCI", sizeof(info.name));
1278                 info.modify_counter = s->mix.modcnt;
1279                 if (copy_to_user((void *)arg, &info, sizeof(info)))
1280                         return -EFAULT;
1281                 return 0;
1282         }
1283         if (cmd == SOUND_OLD_MIXER_INFO) {
1284                 _old_mixer_info info;
1285                 memset(&info, 0, sizeof(info));
1286                 strlcpy(info.id, "cmpci", sizeof(info.id));
1287                 strlcpy(info.name, "C-Media cmpci", sizeof(info.name));
1288                 if (copy_to_user((void *)arg, &info, sizeof(info)))
1289                         return -EFAULT;
1290                 return 0;
1291         }
1292         if (cmd == OSS_GETVERSION)
1293                 return put_user(SOUND_VERSION, (int *)arg);
1294         if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
1295                 return -EINVAL;
1296         if (_IOC_DIR(cmd) == _IOC_READ) {
1297                 switch (_IOC_NR(cmd)) {
1298                 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
1299                         return put_user(mixer_recmask(s), (int *)arg);
1300
1301                 case SOUND_MIXER_OUTSRC: /* Arg contains a bit for each recording source */
1302                         return put_user(mixer_recmask(s), (int *)arg);//need fix
1303
1304                 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
1305                         for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1306                                 if (mixtable[i].type)
1307                                         val |= 1 << i;
1308                         return put_user(val, (int *)arg);
1309
1310                 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
1311                         for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1312                                 if (mixtable[i].rec)
1313                                         val |= 1 << i;
1314                         return put_user(val, (int *)arg);
1315
1316                 case SOUND_MIXER_OUTMASK: /* Arg contains a bit for each supported recording source */
1317                         for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1318                                 if (mixtable[i].play)
1319                                         val |= 1 << i;
1320                         return put_user(val, (int *)arg);
1321
1322                  case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
1323                         for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1324                                 if (mixtable[i].type && mixtable[i].type != MT_4MUTEMONO)
1325                                         val |= 1 << i;
1326                         return put_user(val, (int *)arg);
1327
1328                 case SOUND_MIXER_CAPS:
1329                         return put_user(0, (int *)arg);
1330
1331                 default:
1332                         i = _IOC_NR(cmd);
1333                         if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].type)
1334                                 return -EINVAL;
1335                         if (!volidx[i])
1336                                 return -EINVAL;
1337                         return put_user(s->mix.vol[volidx[i]-1], (int *)arg);
1338                 }
1339         }
1340         if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
1341                 return -EINVAL;
1342         s->mix.modcnt++;
1343         switch (_IOC_NR(cmd)) {
1344         case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
1345                 if (get_user(val, (int *)arg))
1346                         return -EFAULT;
1347                 i = generic_hweight32(val);
1348                 for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
1349                         if (!(val & (1 << i)))
1350                                 continue;
1351                         if (!mixtable[i].rec) {
1352                                 val &= ~(1 << i);
1353                                 continue;
1354                         }
1355                         j |= mixtable[i].rec;
1356                 }
1357                 spin_lock_irqsave(&s->lock, flags);
1358                 wrmixer(s, DSP_MIX_ADCMIXIDX_L, j);
1359                 wrmixer(s, DSP_MIX_ADCMIXIDX_R, (j & 1) | (j>>1));
1360                 spin_unlock_irqrestore(&s->lock, flags);
1361                 return 0;
1362
1363         case SOUND_MIXER_OUTSRC: /* Arg contains a bit for each recording source */
1364                 if (get_user(val, (int *)arg))
1365                         return -EFAULT;
1366                 for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
1367                         if (!(val & (1 << i)))
1368                                 continue;
1369                         if (!mixtable[i].play) {
1370                                 val &= ~(1 << i);
1371                                 continue;
1372                         }
1373                         j |= mixtable[i].play;
1374                 }
1375                 spin_lock_irqsave(&s->lock, flags);
1376                 frobindir(s, DSP_MIX_OUTMIXIDX, 0x1f, j);
1377                 spin_unlock_irqrestore(&s->lock, flags);
1378                 return 0;
1379
1380                 default:
1381                 i = _IOC_NR(cmd);
1382                 if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].type)
1383                         return -EINVAL;
1384                 if (get_user(val, (int *)arg))
1385                         return -EFAULT;
1386                 l = val & 0xff;
1387                 r = (val >> 8) & 0xff;
1388                 if (l > 100)
1389                         l = 100;
1390                 if (r > 100)
1391                         r = 100;
1392                 spin_lock_irqsave(&s->lock, flags);
1393                 switch (mixtable[i].type) {
1394                 case MT_4:
1395                         if (l >= 10)
1396                                 l -= 10;
1397                         if (r >= 10)
1398                                 r -= 10;
1399                         frobindir(s, mixtable[i].left, 0xf0, l / 6);
1400                         frobindir(s, mixtable[i].right, 0xf0, l / 6);
1401                         break;
1402
1403                 case MT_4MUTEMONO:
1404                         rl = (l < 4 ? 0 : (l - 5) / 3) & 31;
1405                         rr = (rl >> 2) & 7;
1406                         wrmixer(s, mixtable[i].left, rl<<3);
1407                         maskb(s->iobase + CODEC_CMI_MIXER2, ~0x0e, rr<<1);
1408                         break;
1409
1410                 case MT_5MUTEMONO:
1411                         r = l;
1412                         rl = l < 4 ? 0 : (l - 5) / 3;
1413                         rr = rl >> 2;
1414                         wrmixer(s, mixtable[i].left, rl<<3);
1415                         maskb(s->iobase + CODEC_CMI_MIXER2, ~0x0e, rr<<1);
1416                         break;
1417
1418                 case MT_5MUTE:
1419                         rl = l < 4 ? 0 : (l - 5) / 3;
1420                         rr = r < 4 ? 0 : (r - 5) / 3;
1421                         wrmixer(s, mixtable[i].left, rl<<3);
1422                         wrmixer(s, mixtable[i].right, rr<<3);
1423                         break;
1424
1425                 case MT_6MUTE:
1426                         if (l < 6)
1427                                 rl = 0x00;
1428                         else
1429                                 rl = l * 2 / 3;
1430                         if (r < 6)
1431                                 rr = 0x00;
1432                         else
1433                                 rr = r * 2 / 3;
1434                         wrmixer(s, mixtable[i].left, rl);
1435                         wrmixer(s, mixtable[i].right, rr);
1436                         break;
1437                 }
1438                 spin_unlock_irqrestore(&s->lock, flags);
1439
1440                 if (!volidx[i])
1441                         return -EINVAL;
1442                 s->mix.vol[volidx[i]-1] = val;
1443                 return put_user(s->mix.vol[volidx[i]-1], (int *)arg);
1444         }
1445 }
1446
1447 /* --------------------------------------------------------------------- */
1448
1449 static int cm_open_mixdev(struct inode *inode, struct file *file)
1450 {
1451         int minor = iminor(inode);
1452         struct cm_state *s = devs;
1453
1454         while (s && s->dev_mixer != minor)
1455                 s = s->next;
1456         if (!s)
1457                 return -ENODEV;
1458         VALIDATE_STATE(s);
1459         file->private_data = s;
1460         return 0;
1461 }
1462
1463 static int cm_release_mixdev(struct inode *inode, struct file *file)
1464 {
1465         struct cm_state *s;
1466
1467         s = file->private_data;
1468
1469         VALIDATE_STATE(s);
1470         return 0;
1471 }
1472
1473 static int cm_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1474 {
1475         return mixer_ioctl((struct cm_state *)file->private_data, cmd, arg);
1476 }
1477
1478 static /*const*/ struct file_operations cm_mixer_fops = {
1479         .owner   = THIS_MODULE,
1480         .llseek  = no_llseek,
1481         .ioctl   = cm_ioctl_mixdev,
1482         .open    = cm_open_mixdev,
1483         .release = cm_release_mixdev,
1484 };
1485
1486
1487 /* --------------------------------------------------------------------- */
1488
1489 static int drain_dac(struct cm_state *s, int nonblock)
1490 {
1491         DECLARE_WAITQUEUE(wait, current);
1492         unsigned long flags;
1493         int count, tmo;
1494
1495         if (s->dma_dac.mapped || !s->dma_dac.ready)
1496                 return 0;
1497         set_current_state(TASK_INTERRUPTIBLE);
1498         add_wait_queue(&s->dma_dac.wait, &wait);
1499         for (;;) {
1500                 spin_lock_irqsave(&s->lock, flags);
1501                 count = s->dma_dac.count;
1502                 spin_unlock_irqrestore(&s->lock, flags);
1503                 if (count <= 0)
1504                         break;
1505                 if (signal_pending(current))
1506                         break;
1507                 if (nonblock) {
1508                         remove_wait_queue(&s->dma_dac.wait, &wait);
1509                         set_current_state(TASK_RUNNING);
1510                         return -EBUSY;
1511                 }
1512                 tmo = 3 * HZ * (count + s->dma_dac.fragsize) / 2 / s->ratedac;
1513                 tmo >>= sample_shift[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK];
1514                 if (!schedule_timeout(tmo + 1))
1515                         printk(KERN_DEBUG "cmpci: dma timed out??\n");
1516         }
1517         remove_wait_queue(&s->dma_dac.wait, &wait);
1518         set_current_state(TASK_RUNNING);
1519         if (signal_pending(current))
1520                 return -ERESTARTSYS;
1521         return 0;
1522 }
1523
1524 /* --------------------------------------------------------------------- */
1525
1526 static ssize_t cm_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1527 {
1528         struct cm_state *s = (struct cm_state *)file->private_data;
1529         ssize_t ret;
1530         unsigned long flags;
1531         unsigned swptr;
1532         int cnt;
1533
1534         VALIDATE_STATE(s);
1535         if (ppos != &file->f_pos)
1536                 return -ESPIPE;
1537         if (s->dma_adc.mapped)
1538                 return -ENXIO;
1539         if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1540                 return ret;
1541         if (!access_ok(VERIFY_WRITE, buffer, count))
1542                 return -EFAULT;
1543         ret = 0;
1544
1545         while (count > 0) {
1546                 spin_lock_irqsave(&s->lock, flags);
1547                 swptr = s->dma_adc.swptr;
1548                 cnt = s->dma_adc.dmasize-swptr;
1549                 if (s->dma_adc.count < cnt)
1550                         cnt = s->dma_adc.count;
1551                 spin_unlock_irqrestore(&s->lock, flags);
1552                 if (cnt > count)
1553                         cnt = count;
1554                 if (cnt <= 0) {
1555                         start_adc(s);
1556                         if (file->f_flags & O_NONBLOCK)
1557                                 return ret ? ret : -EAGAIN;
1558                         if (!interruptible_sleep_on_timeout(&s->dma_adc.wait, HZ)) {
1559                                 printk(KERN_DEBUG "cmpci: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1560                                        s->dma_adc.dmasize, s->dma_adc.fragsize, s->dma_adc.count,
1561                                        s->dma_adc.hwptr, s->dma_adc.swptr);
1562                                 spin_lock_irqsave(&s->lock, flags);
1563                                 stop_adc_unlocked(s);
1564                                 set_dmaadc(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
1565                                 /* program sample counts */
1566                                 set_countadc(s, s->dma_adc.fragsamples);
1567                                 s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
1568                                 spin_unlock_irqrestore(&s->lock, flags);
1569                         }
1570                         if (signal_pending(current))
1571                                 return ret ? ret : -ERESTARTSYS;
1572                         continue;
1573                 }
1574                 if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt))
1575                         return ret ? ret : -EFAULT;
1576                 swptr = (swptr + cnt) % s->dma_adc.dmasize;
1577                 spin_lock_irqsave(&s->lock, flags);
1578                 s->dma_adc.swptr = swptr;
1579                 s->dma_adc.count -= cnt;
1580                 count -= cnt;
1581                 buffer += cnt;
1582                 ret += cnt;
1583                 start_adc_unlocked(s);
1584                 spin_unlock_irqrestore(&s->lock, flags);
1585         }
1586         return ret;
1587 }
1588
1589 static ssize_t cm_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1590 {
1591         struct cm_state *s = (struct cm_state *)file->private_data;
1592         ssize_t ret;
1593         unsigned long flags;
1594         unsigned swptr;
1595         int cnt;
1596
1597         VALIDATE_STATE(s);
1598         if (ppos != &file->f_pos)
1599                 return -ESPIPE;
1600         if (s->dma_dac.mapped)
1601                 return -ENXIO;
1602         if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
1603                 return ret;
1604         if (!access_ok(VERIFY_READ, buffer, count))
1605                 return -EFAULT;
1606         if (s->status & DO_DUAL_DAC) {
1607                 if (s->dma_adc.mapped)
1608                         return -ENXIO;
1609                 if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1610                         return ret;
1611                 if (!access_ok(VERIFY_READ, buffer, count))
1612                         return -EFAULT;
1613         }
1614         ret = 0;
1615
1616         while (count > 0) {
1617                 spin_lock_irqsave(&s->lock, flags);
1618                 if (s->dma_dac.count < 0) {
1619                         s->dma_dac.count = 0;
1620                         s->dma_dac.swptr = s->dma_dac.hwptr;
1621                 }
1622                 if (s->status & DO_DUAL_DAC) {
1623                         s->dma_adc.swptr = s->dma_dac.swptr;
1624                         s->dma_adc.count = s->dma_dac.count;
1625                         s->dma_adc.endcleared = s->dma_dac.endcleared;
1626                 }
1627                 swptr = s->dma_dac.swptr;
1628                 cnt = s->dma_dac.dmasize-swptr;
1629                 if (s->status & DO_AC3_SW) {
1630                         if (s->dma_dac.count + 2 * cnt > s->dma_dac.dmasize)
1631                                 cnt = (s->dma_dac.dmasize - s->dma_dac.count) / 2;
1632                 } else {
1633                         if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
1634                                 cnt = s->dma_dac.dmasize - s->dma_dac.count;
1635                 }
1636                 spin_unlock_irqrestore(&s->lock, flags);
1637                 if (cnt > count)
1638                         cnt = count;
1639                 if ((s->status & DO_DUAL_DAC) && (cnt > count / 2))
1640                     cnt = count / 2;
1641                 if (cnt <= 0) {
1642                         start_dac(s);
1643                         if (file->f_flags & O_NONBLOCK)
1644                                 return ret ? ret : -EAGAIN;
1645                         if (!interruptible_sleep_on_timeout(&s->dma_dac.wait, HZ)) {
1646                                 printk(KERN_DEBUG "cmpci: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1647                                        s->dma_dac.dmasize, s->dma_dac.fragsize, s->dma_dac.count,
1648                                        s->dma_dac.hwptr, s->dma_dac.swptr);
1649                                 spin_lock_irqsave(&s->lock, flags);
1650                                 stop_dac_unlocked(s);
1651                                 set_dmadac(s, s->dma_dac.rawphys, s->dma_dac.dmasamples);
1652                                 /* program sample counts */
1653                                 set_countdac(s, s->dma_dac.fragsamples);
1654                                 s->dma_dac.count = s->dma_dac.hwptr = s->dma_dac.swptr = 0;
1655                                 if (s->status & DO_DUAL_DAC)  {
1656                                         set_dmadac1(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
1657                                         s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
1658                                 }
1659                                 spin_unlock_irqrestore(&s->lock, flags);
1660                         }
1661                         if (signal_pending(current))
1662                                 return ret ? ret : -ERESTARTSYS;
1663                         continue;
1664                 }
1665                 if (s->status & DO_AC3_SW) {
1666                         int err;
1667
1668                         // clip exceeded data, caught by 033 and 037
1669                         if (swptr + 2 * cnt > s->dma_dac.dmasize)
1670                                 cnt = (s->dma_dac.dmasize - swptr) / 2;
1671                         if ((err = trans_ac3(s, s->dma_dac.rawbuf + swptr, buffer, cnt)))
1672                                 return err;
1673                         swptr = (swptr + 2 * cnt) % s->dma_dac.dmasize;
1674                 } else if (s->status & DO_DUAL_DAC) {
1675                         int     i, err;
1676                         unsigned long *src, *dst0, *dst1;
1677
1678                         src = (unsigned long *) buffer;
1679                         dst0 = (unsigned long *) (s->dma_dac.rawbuf + swptr);
1680                         dst1 = (unsigned long *) (s->dma_adc.rawbuf + swptr);
1681                         // copy left/right sample at one time
1682                         for (i = 0; i <= cnt / 4; i++) {
1683                                 if ((err = __get_user(*dst0++, src++)))
1684                                         return err;
1685                                 if ((err = __get_user(*dst1++, src++)))
1686                                         return err;
1687                         }
1688                         swptr = (swptr + cnt) % s->dma_dac.dmasize;
1689                 } else {
1690                         if (copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt))
1691                                 return ret ? ret : -EFAULT;
1692                         swptr = (swptr + cnt) % s->dma_dac.dmasize;
1693                 }
1694                 spin_lock_irqsave(&s->lock, flags);
1695                 s->dma_dac.swptr = swptr;
1696                 s->dma_dac.count += cnt;
1697                 if (s->status & DO_AC3_SW)
1698                         s->dma_dac.count += cnt;
1699                 s->dma_dac.endcleared = 0;
1700                 spin_unlock_irqrestore(&s->lock, flags);
1701                 count -= cnt;
1702                 buffer += cnt;
1703                 ret += cnt;
1704                 if (s->status & DO_DUAL_DAC) {
1705                         count -= cnt;
1706                         buffer += cnt;
1707                         ret += cnt;
1708                 }
1709                 start_dac(s);
1710         }
1711         return ret;
1712 }
1713
1714 static unsigned int cm_poll(struct file *file, struct poll_table_struct *wait)
1715 {
1716         struct cm_state *s = (struct cm_state *)file->private_data;
1717         unsigned long flags;
1718         unsigned int mask = 0;
1719
1720         VALIDATE_STATE(s);
1721         if (file->f_mode & FMODE_WRITE)
1722                 poll_wait(file, &s->dma_dac.wait, wait);
1723         if (file->f_mode & FMODE_READ)
1724                 poll_wait(file, &s->dma_adc.wait, wait);
1725         spin_lock_irqsave(&s->lock, flags);
1726         cm_update_ptr(s);
1727         if (file->f_mode & FMODE_READ) {
1728                 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1729                         mask |= POLLIN | POLLRDNORM;
1730         }
1731         if (file->f_mode & FMODE_WRITE) {
1732                 if (s->dma_dac.mapped) {
1733                         if (s->dma_dac.count >= (signed)s->dma_dac.fragsize)
1734                                 mask |= POLLOUT | POLLWRNORM;
1735                 } else {
1736                         if ((signed)s->dma_dac.dmasize >= s->dma_dac.count + (signed)s->dma_dac.fragsize)
1737                                 mask |= POLLOUT | POLLWRNORM;
1738                 }
1739         }
1740         spin_unlock_irqrestore(&s->lock, flags);
1741         return mask;
1742 }
1743
1744 static int cm_mmap(struct file *file, struct vm_area_struct *vma)
1745 {
1746         struct cm_state *s = (struct cm_state *)file->private_data;
1747         struct dmabuf *db;
1748         int ret = -EINVAL;
1749         unsigned long size;
1750
1751         VALIDATE_STATE(s);
1752         lock_kernel();
1753         if (vma->vm_flags & VM_WRITE) {
1754                 if ((ret = prog_dmabuf(s, 0)) != 0)
1755                         goto out;
1756                 db = &s->dma_dac;
1757         } else if (vma->vm_flags & VM_READ) {
1758                 if ((ret = prog_dmabuf(s, 1)) != 0)
1759                         goto out;
1760                 db = &s->dma_adc;
1761         } else
1762                 goto out;
1763         ret = -EINVAL;
1764         if (vma->vm_pgoff != 0)
1765                 goto out;
1766         size = vma->vm_end - vma->vm_start;
1767         if (size > (PAGE_SIZE << db->buforder))
1768                 goto out;
1769         ret = -EINVAL;
1770         if (remap_page_range(vma, vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot))
1771                 goto out;
1772         db->mapped = 1;
1773         ret = 0;
1774 out:
1775         unlock_kernel();
1776         return ret;
1777 }
1778
1779 static int cm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1780 {
1781         struct cm_state *s = (struct cm_state *)file->private_data;
1782         unsigned long flags;
1783         audio_buf_info abinfo;
1784         count_info cinfo;
1785         int val, mapped, ret;
1786         unsigned char fmtm, fmtd;
1787
1788         VALIDATE_STATE(s);
1789         mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
1790                 ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
1791         switch (cmd) {
1792         case OSS_GETVERSION:
1793                 return put_user(SOUND_VERSION, (int *)arg);
1794
1795         case SNDCTL_DSP_SYNC:
1796                 if (file->f_mode & FMODE_WRITE)
1797                         return drain_dac(s, 0/*file->f_flags & O_NONBLOCK*/);
1798                 return 0;
1799
1800         case SNDCTL_DSP_SETDUPLEX:
1801                 return 0;
1802
1803         case SNDCTL_DSP_GETCAPS:
1804                 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_BIND, (int *)arg);
1805
1806         case SNDCTL_DSP_RESET:
1807                 if (file->f_mode & FMODE_WRITE) {
1808                         stop_dac(s);
1809                         synchronize_irq(s->irq);
1810                         s->dma_dac.swptr = s->dma_dac.hwptr = s->dma_dac.count = s->dma_dac.total_bytes = 0;
1811                         if (s->status & DO_DUAL_DAC)
1812                                 s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
1813                 }
1814                 if (file->f_mode & FMODE_READ) {
1815                         stop_adc(s);
1816                         synchronize_irq(s->irq);
1817                         s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
1818                 }
1819                 return 0;
1820
1821         case SNDCTL_DSP_SPEED:
1822                 if (get_user(val, (int *)arg))
1823                         return -EFAULT;
1824                 if (val >= 0) {
1825                         if (file->f_mode & FMODE_READ) {
1826                                 spin_lock_irqsave(&s->lock, flags);
1827                                 stop_adc_unlocked(s);
1828                                 s->dma_adc.ready = 0;
1829                                 set_adc_rate_unlocked(s, val);
1830                                 spin_unlock_irqrestore(&s->lock, flags);
1831                         }
1832                         if (file->f_mode & FMODE_WRITE) {
1833                                 stop_dac(s);
1834                                 s->dma_dac.ready = 0;
1835                                 if (s->status & DO_DUAL_DAC)
1836                                         s->dma_adc.ready = 0;
1837                                 set_dac_rate(s, val);
1838                         }
1839                 }
1840                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
1841
1842         case SNDCTL_DSP_STEREO:
1843                 if (get_user(val, (int *)arg))
1844                         return -EFAULT;
1845                 fmtd = 0;
1846                 fmtm = ~0;
1847                 if (file->f_mode & FMODE_READ) {
1848                         stop_adc(s);
1849                         s->dma_adc.ready = 0;
1850                         if (val)
1851                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1852                         else
1853                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1854                 }
1855                 if (file->f_mode & FMODE_WRITE) {
1856                         stop_dac(s);
1857                         s->dma_dac.ready = 0;
1858                         if (val)
1859                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1860                         else
1861                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
1862                         if (s->status & DO_DUAL_DAC) {
1863                                 s->dma_adc.ready = 0;
1864                                 if (val)
1865                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1866                                 else
1867                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1868                         }
1869                 }
1870                 set_fmt(s, fmtm, fmtd);
1871                 return 0;
1872
1873         case SNDCTL_DSP_CHANNELS:
1874                 if (get_user(val, (int *)arg))
1875                         return -EFAULT;
1876                 if (val != 0) {
1877                         fmtd = 0;
1878                         fmtm = ~0;
1879                         if (file->f_mode & FMODE_READ) {
1880                                 stop_adc(s);
1881                                 s->dma_adc.ready = 0;
1882                                 if (val >= 2)
1883                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1884                                 else
1885                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1886                         }
1887                         if (file->f_mode & FMODE_WRITE) {
1888                                 stop_dac(s);
1889                                 s->dma_dac.ready = 0;
1890                                 if (val >= 2)
1891                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1892                                 else
1893                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
1894                                 if (s->status & DO_DUAL_DAC) {
1895                                         s->dma_adc.ready = 0;
1896                                         if (val >= 2)
1897                                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1898                                         else
1899                                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1900                                 }
1901                         }
1902                         set_fmt(s, fmtm, fmtd);
1903                         if ((s->capability & CAN_MULTI_CH)
1904                              && (file->f_mode & FMODE_WRITE)) {
1905                                 val = set_dac_channels(s, val);
1906                                 return put_user(val, (int *)arg);
1907                         }
1908                 }
1909                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_STEREO << CM_CFMT_ADCSHIFT)
1910                                            : (CM_CFMT_STEREO << CM_CFMT_DACSHIFT))) ? 2 : 1, (int *)arg);
1911
1912         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
1913                 return put_user(AFMT_S16_LE|AFMT_U8|AFMT_AC3, (int *)arg);
1914
1915         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
1916                 if (get_user(val, (int *)arg))
1917                         return -EFAULT;
1918                 if (val != AFMT_QUERY) {
1919                         fmtd = 0;
1920                         fmtm = ~0;
1921                         if (file->f_mode & FMODE_READ) {
1922                                 stop_adc(s);
1923                                 s->dma_adc.ready = 0;
1924                                 if (val == AFMT_S16_LE)
1925                                         fmtd |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
1926                                 else
1927                                         fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_ADCSHIFT);
1928                         }
1929                         if (file->f_mode & FMODE_WRITE) {
1930                                 stop_dac(s);
1931                                 s->dma_dac.ready = 0;
1932                                 if (val == AFMT_S16_LE || val == AFMT_AC3)
1933                                         fmtd |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
1934                                 else
1935                                         fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_DACSHIFT);
1936                                 if (val == AFMT_AC3) {
1937                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1938                                         set_ac3(s, s->ratedac);
1939                                 } else
1940                                         set_ac3(s, 0);
1941                                 if (s->status & DO_DUAL_DAC) {
1942                                         s->dma_adc.ready = 0;
1943                                         if (val == AFMT_S16_LE)
1944                                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1945                                         else
1946                                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1947                                 }
1948                         }
1949                         set_fmt(s, fmtm, fmtd);
1950                 }
1951                 if (s->status & DO_AC3) return put_user(AFMT_AC3, (int *)arg);
1952                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_16BIT << CM_CFMT_ADCSHIFT)
1953                                            : (CM_CFMT_16BIT << CM_CFMT_DACSHIFT))) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
1954
1955         case SNDCTL_DSP_POST:
1956                 return 0;
1957
1958         case SNDCTL_DSP_GETTRIGGER:
1959                 val = 0;
1960                 if (s->status & DO_DUAL_DAC) {
1961                         if (file->f_mode & FMODE_WRITE &&
1962                          (s->enable & CM_ENABLE_CH1) &&
1963                          (s->enable & CM_ENABLE_CH0))
1964                                 val |= PCM_ENABLE_OUTPUT;
1965                         return put_user(val, (int *)arg);
1966                 }
1967                 if (file->f_mode & FMODE_READ && s->enable & CM_ENABLE_CH0)
1968                         val |= PCM_ENABLE_INPUT;
1969                 if (file->f_mode & FMODE_WRITE && s->enable & CM_ENABLE_CH1)
1970                         val |= PCM_ENABLE_OUTPUT;
1971                 return put_user(val, (int *)arg);
1972
1973         case SNDCTL_DSP_SETTRIGGER:
1974                 if (get_user(val, (int *)arg))
1975                         return -EFAULT;
1976                 if (file->f_mode & FMODE_READ) {
1977                         if (val & PCM_ENABLE_INPUT) {
1978                                 if (!s->dma_adc.ready && (ret =  prog_dmabuf(s, 1)))
1979                                         return ret;
1980                                 start_adc(s);
1981                         } else
1982                                 stop_adc(s);
1983                 }
1984                 if (file->f_mode & FMODE_WRITE) {
1985                         if (val & PCM_ENABLE_OUTPUT) {
1986                                 if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
1987                                         return ret;
1988                                 if (s->status & DO_DUAL_DAC) {
1989                                         if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1990                                                 return ret;
1991                                 }
1992                                 start_dac(s);
1993                         } else
1994                                 stop_dac(s);
1995                 }
1996                 return 0;
1997
1998         case SNDCTL_DSP_GETOSPACE:
1999                 if (!(file->f_mode & FMODE_WRITE))
2000                         return -EINVAL;
2001                 if (!(s->enable & CM_ENABLE_CH1) && (val = prog_dmabuf(s, 0)) != 0)
2002                         return val;
2003                 spin_lock_irqsave(&s->lock, flags);
2004                 cm_update_ptr(s);
2005                 abinfo.fragsize = s->dma_dac.fragsize;
2006                 abinfo.bytes = s->dma_dac.dmasize - s->dma_dac.count;
2007                 abinfo.fragstotal = s->dma_dac.numfrag;
2008                 abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;
2009                 spin_unlock_irqrestore(&s->lock, flags);
2010                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2011
2012         case SNDCTL_DSP_GETISPACE:
2013                 if (!(file->f_mode & FMODE_READ))
2014                         return -EINVAL;
2015                 if (!(s->enable & CM_ENABLE_CH0) && (val = prog_dmabuf(s, 1)) != 0)
2016                         return val;
2017                 spin_lock_irqsave(&s->lock, flags);
2018                 cm_update_ptr(s);
2019                 abinfo.fragsize = s->dma_adc.fragsize;
2020                 abinfo.bytes = s->dma_adc.count;
2021                 abinfo.fragstotal = s->dma_adc.numfrag;
2022                 abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;
2023                 spin_unlock_irqrestore(&s->lock, flags);
2024                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2025
2026         case SNDCTL_DSP_NONBLOCK:
2027                 file->f_flags |= O_NONBLOCK;
2028                 return 0;
2029
2030         case SNDCTL_DSP_GETODELAY:
2031                 if (!(file->f_mode & FMODE_WRITE))
2032                         return -EINVAL;
2033                 spin_lock_irqsave(&s->lock, flags);
2034                 cm_update_ptr(s);
2035                 val = s->dma_dac.count;
2036                 spin_unlock_irqrestore(&s->lock, flags);
2037                 return put_user(val, (int *)arg);
2038
2039         case SNDCTL_DSP_GETIPTR:
2040                 if (!(file->f_mode & FMODE_READ))
2041                         return -EINVAL;
2042                 spin_lock_irqsave(&s->lock, flags);
2043                 cm_update_ptr(s);
2044                 cinfo.bytes = s->dma_adc.total_bytes;
2045                 cinfo.blocks = s->dma_adc.count >> s->dma_adc.fragshift;
2046                 cinfo.ptr = s->dma_adc.hwptr;
2047                 if (s->dma_adc.mapped)
2048                         s->dma_adc.count &= s->dma_adc.fragsize-1;
2049                 spin_unlock_irqrestore(&s->lock, flags);
2050                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
2051                         return -EFAULT;
2052                 return 0;
2053
2054         case SNDCTL_DSP_GETOPTR:
2055                 if (!(file->f_mode & FMODE_WRITE))
2056                         return -EINVAL;
2057                 spin_lock_irqsave(&s->lock, flags);
2058                 cm_update_ptr(s);
2059                 cinfo.bytes = s->dma_dac.total_bytes;
2060                 cinfo.blocks = s->dma_dac.count >> s->dma_dac.fragshift;
2061                 cinfo.ptr = s->dma_dac.hwptr;
2062                 if (s->dma_dac.mapped)
2063                         s->dma_dac.count &= s->dma_dac.fragsize-1;
2064                 if (s->status & DO_DUAL_DAC) {
2065                         if (s->dma_adc.mapped)
2066                                 s->dma_adc.count &= s->dma_adc.fragsize-1;
2067                 }
2068                 spin_unlock_irqrestore(&s->lock, flags);
2069                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
2070                         return -EFAULT;
2071                 return 0;
2072
2073         case SNDCTL_DSP_GETBLKSIZE:
2074                 if (file->f_mode & FMODE_WRITE) {
2075                         if ((val = prog_dmabuf(s, 0)))
2076                                 return val;
2077                         if (s->status & DO_DUAL_DAC) {
2078                                 if ((val = prog_dmabuf(s, 1)))
2079                                         return val;
2080                                 return put_user(2 * s->dma_dac.fragsize, (int *)arg);
2081                         }
2082                         return put_user(s->dma_dac.fragsize, (int *)arg);
2083                 }
2084                 if ((val = prog_dmabuf(s, 1)))
2085                         return val;
2086                 return put_user(s->dma_adc.fragsize, (int *)arg);
2087
2088         case SNDCTL_DSP_SETFRAGMENT:
2089                 if (get_user(val, (int *)arg))
2090                         return -EFAULT;
2091                 if (file->f_mode & FMODE_READ) {
2092                         s->dma_adc.ossfragshift = val & 0xffff;
2093                         s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
2094                         if (s->dma_adc.ossfragshift < 4)
2095                                 s->dma_adc.ossfragshift = 4;
2096                         if (s->dma_adc.ossfragshift > 15)
2097                                 s->dma_adc.ossfragshift = 15;
2098                         if (s->dma_adc.ossmaxfrags < 4)
2099                                 s->dma_adc.ossmaxfrags = 4;
2100                 }
2101                 if (file->f_mode & FMODE_WRITE) {
2102                         s->dma_dac.ossfragshift = val & 0xffff;
2103                         s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
2104                         if (s->dma_dac.ossfragshift < 4)
2105                                 s->dma_dac.ossfragshift = 4;
2106                         if (s->dma_dac.ossfragshift > 15)
2107                                 s->dma_dac.ossfragshift = 15;
2108                         if (s->dma_dac.ossmaxfrags < 4)
2109                                 s->dma_dac.ossmaxfrags = 4;
2110                         if (s->status & DO_DUAL_DAC) {
2111                                 s->dma_adc.ossfragshift = s->dma_dac.ossfragshift;
2112                                 s->dma_adc.ossmaxfrags = s->dma_dac.ossmaxfrags;
2113                         }
2114                 }
2115                 return 0;
2116
2117         case SNDCTL_DSP_SUBDIVIDE:
2118                 if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
2119                     (file->f_mode & FMODE_WRITE && s->dma_dac.subdivision))
2120                         return -EINVAL;
2121                 if (get_user(val, (int *)arg))
2122                         return -EFAULT;
2123                 if (val != 1 && val != 2 && val != 4)
2124                         return -EINVAL;
2125                 if (file->f_mode & FMODE_READ)
2126                         s->dma_adc.subdivision = val;
2127                 if (file->f_mode & FMODE_WRITE) {
2128                         s->dma_dac.subdivision = val;
2129                         if (s->status & DO_DUAL_DAC)
2130                                 s->dma_adc.subdivision = val;
2131                 }
2132                 return 0;
2133
2134         case SOUND_PCM_READ_RATE:
2135                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
2136
2137         case SOUND_PCM_READ_CHANNELS:
2138                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_STEREO << CM_CFMT_ADCSHIFT) : (CM_CFMT_STEREO << CM_CFMT_DACSHIFT))) ? 2 : 1, (int *)arg);
2139
2140         case SOUND_PCM_READ_BITS:
2141                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_16BIT << CM_CFMT_ADCSHIFT) : (CM_CFMT_16BIT << CM_CFMT_DACSHIFT))) ? 16 : 8, (int *)arg);
2142
2143         case SOUND_PCM_READ_FILTER:
2144                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
2145
2146         case SNDCTL_DSP_GETCHANNELMASK:
2147                 return put_user(DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE|DSP_BIND_SPDIF, (int *)arg);
2148
2149         case SNDCTL_DSP_BIND_CHANNEL:
2150                 if (get_user(val, (int *)arg))
2151                         return -EFAULT;
2152                 if (val == DSP_BIND_QUERY) {
2153                         val = DSP_BIND_FRONT;
2154                         if (s->status & DO_SPDIF_OUT)
2155                                 val |= DSP_BIND_SPDIF;
2156                         else {
2157                                 if (s->curr_channels == 4)
2158                                         val |= DSP_BIND_SURR;
2159                                 if (s->curr_channels > 4)
2160                                         val |= DSP_BIND_CENTER_LFE;
2161                         }
2162                 } else {
2163                         if (file->f_mode & FMODE_READ) {
2164                                 stop_adc(s);
2165                                 s->dma_adc.ready = 0;
2166                         }
2167                         if (file->f_mode & FMODE_WRITE) {
2168                                 stop_dac(s);
2169                                 s->dma_dac.ready = 0;
2170                                 if (val & DSP_BIND_SPDIF) {
2171                                         set_spdifout(s, s->ratedac);
2172                                         set_dac_channels(s, s->fmt & (CM_CFMT_STEREO << CM_CFMT_DACSHIFT) ? 2 : 1);
2173                                         if (!(s->status & DO_SPDIF_OUT))
2174                                                 val &= ~DSP_BIND_SPDIF;
2175                                 } else {
2176                                         int channels;
2177                                         int mask;
2178
2179                                         mask = val & (DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE);
2180                                         switch (mask) {
2181                                             case DSP_BIND_FRONT:
2182                                                 channels = 2;
2183                                                 break;
2184                                             case DSP_BIND_FRONT|DSP_BIND_SURR:
2185                                                 channels = 4;
2186                                                 break;
2187                                             case DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE:
2188                                                 channels = 6;
2189                                                 break;
2190                                             default:
2191                                                 channels = s->fmt & (CM_CFMT_STEREO << CM_CFMT_DACSHIFT) ? 2 : 1;
2192                                                 break;
2193                                         }
2194                                         set_dac_channels(s, channels);
2195                                 }
2196                         }
2197                 }
2198                 return put_user(val, (int *)arg);
2199
2200         case SOUND_PCM_WRITE_FILTER:
2201         case SNDCTL_DSP_MAPINBUF:
2202         case SNDCTL_DSP_MAPOUTBUF:
2203         case SNDCTL_DSP_SETSYNCRO:
2204                 return -EINVAL;
2205
2206         }
2207         return mixer_ioctl(s, cmd, arg);
2208 }
2209
2210 static int cm_open(struct inode *inode, struct file *file)
2211 {
2212         int minor = iminor(inode);
2213         struct cm_state *s = devs;
2214         unsigned char fmtm = ~0, fmts = 0;
2215
2216         while (s && ((s->dev_audio ^ minor) & ~0xf))
2217                 s = s->next;
2218         if (!s)
2219                 return -ENODEV;
2220         VALIDATE_STATE(s);
2221         file->private_data = s;
2222         /* wait for device to become free */
2223         down(&s->open_sem);
2224         while (s->open_mode & file->f_mode) {
2225                 if (file->f_flags & O_NONBLOCK) {
2226                         up(&s->open_sem);
2227                         return -EBUSY;
2228                 }
2229                 up(&s->open_sem);
2230                 interruptible_sleep_on(&s->open_wait);
2231                 if (signal_pending(current))
2232                         return -ERESTARTSYS;
2233                 down(&s->open_sem);
2234         }
2235         if (file->f_mode & FMODE_READ) {
2236                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_ADCSHIFT);
2237                 if ((minor & 0xf) == SND_DEV_DSP16)
2238                         fmts |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
2239                 s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
2240                 set_adc_rate(s, 8000);
2241         }
2242         if (file->f_mode & FMODE_WRITE) {
2243                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
2244                 if ((minor & 0xf) == SND_DEV_DSP16)
2245                         fmts |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
2246                 s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags = s->dma_dac.subdivision = 0;
2247                 set_dac_rate(s, 8000);
2248                 // clear previous multichannel, spdif, ac3 state
2249                 set_spdifout(s, 0);
2250                 if (s->deviceid == PCI_DEVICE_ID_CMEDIA_CM8738) {
2251                         set_ac3(s, 0);
2252                         set_dac_channels(s, 1);
2253                 }
2254         }
2255         set_fmt(s, fmtm, fmts);
2256         s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2257         up(&s->open_sem);
2258         return 0;
2259 }
2260
2261 static int cm_release(struct inode *inode, struct file *file)
2262 {
2263         struct cm_state *s = (struct cm_state *)file->private_data;
2264
2265         VALIDATE_STATE(s);
2266         lock_kernel();
2267         if (file->f_mode & FMODE_WRITE)
2268                 drain_dac(s, file->f_flags & O_NONBLOCK);
2269         down(&s->open_sem);
2270         if (file->f_mode & FMODE_WRITE) {
2271                 stop_dac(s);
2272
2273                 dealloc_dmabuf(&s->dma_dac);
2274                 if (s->status & DO_DUAL_DAC)
2275                         dealloc_dmabuf(&s->dma_adc);
2276
2277                 if (s->status & DO_MULTI_CH)
2278                         set_dac_channels(s, 0);
2279                 if (s->status & DO_AC3)
2280                         set_ac3(s, 0);
2281                 if (s->status & DO_SPDIF_OUT)
2282                         set_spdifout(s, 0);
2283         }
2284         if (file->f_mode & FMODE_READ) {
2285                 stop_adc(s);
2286                 dealloc_dmabuf(&s->dma_adc);
2287         }
2288         s->open_mode &= ~(file->f_mode & (FMODE_READ|FMODE_WRITE));
2289         up(&s->open_sem);
2290         wake_up(&s->open_wait);
2291         unlock_kernel();
2292         return 0;
2293 }
2294
2295 static /*const*/ struct file_operations cm_audio_fops = {
2296         .owner   = THIS_MODULE,
2297         .llseek  = no_llseek,
2298         .read    = cm_read,
2299         .write   = cm_write,
2300         .poll    = cm_poll,
2301         .ioctl   = cm_ioctl,
2302         .mmap    = cm_mmap,
2303         .open    = cm_open,
2304         .release = cm_release,
2305 };
2306
2307 #ifdef CONFIG_SOUND_CMPCI_MIDI
2308 /* --------------------------------------------------------------------- */
2309
2310 static ssize_t cm_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2311 {
2312         struct cm_state *s = (struct cm_state *)file->private_data;
2313         DECLARE_WAITQUEUE(wait, current);
2314         ssize_t ret;
2315         unsigned long flags;
2316         unsigned ptr;
2317         int cnt;
2318
2319         VALIDATE_STATE(s);
2320         if (ppos != &file->f_pos)
2321                 return -ESPIPE;
2322         if (!access_ok(VERIFY_WRITE, buffer, count))
2323                 return -EFAULT;
2324         ret = 0;
2325         add_wait_queue(&s->midi.iwait, &wait);
2326         while (count > 0) {
2327                 spin_lock_irqsave(&s->lock, flags);
2328                 ptr = s->midi.ird;
2329                 cnt = MIDIINBUF - ptr;
2330                 if (s->midi.icnt < cnt)
2331                         cnt = s->midi.icnt;
2332                 spin_unlock_irqrestore(&s->lock, flags);
2333                 if (cnt > count)
2334                         cnt = count;
2335                 if (cnt <= 0) {
2336                         if (file->f_flags & O_NONBLOCK)
2337                         {
2338                                 if (!ret)
2339                                         ret = -EAGAIN;
2340                                 break;
2341                         }
2342                         __set_current_state(TASK_INTERRUPTIBLE);
2343                         schedule();
2344                         if (signal_pending(current))
2345                         {
2346                                 if (!ret)
2347                                         ret = -ERESTARTSYS;
2348                                 break;
2349                         }
2350                         continue;
2351                 }
2352                 if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt))
2353                 {
2354                         if (!ret)
2355                                 ret = -EFAULT;
2356                         break;
2357                 }
2358                 ptr = (ptr + cnt) % MIDIINBUF;
2359                 spin_lock_irqsave(&s->lock, flags);
2360                 s->midi.ird = ptr;
2361                 s->midi.icnt -= cnt;
2362                 spin_unlock_irqrestore(&s->lock, flags);
2363                 count -= cnt;
2364                 buffer += cnt;
2365                 ret += cnt;
2366                 break;
2367         }
2368         __set_current_state(TASK_RUNNING);
2369         remove_wait_queue(&s->midi.iwait, &wait);
2370         return ret;
2371 }
2372
2373 static ssize_t cm_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2374 {
2375         struct cm_state *s = (struct cm_state *)file->private_data;
2376         DECLARE_WAITQUEUE(wait, current);
2377         ssize_t ret;
2378         unsigned long flags;
2379         unsigned ptr;
2380         int cnt;
2381
2382         VALIDATE_STATE(s);
2383         if (ppos != &file->f_pos)
2384                 return -ESPIPE;
2385         if (!access_ok(VERIFY_READ, buffer, count))
2386                 return -EFAULT;
2387         if (count == 0)
2388                 return 0;
2389         ret = 0;
2390         add_wait_queue(&s->midi.owait, &wait);
2391         while (count > 0) {
2392                 spin_lock_irqsave(&s->lock, flags);
2393                 ptr = s->midi.owr;
2394                 cnt = MIDIOUTBUF - ptr;
2395                 if (s->midi.ocnt + cnt > MIDIOUTBUF)
2396                         cnt = MIDIOUTBUF - s->midi.ocnt;
2397                 if (cnt <= 0)
2398                         cm_handle_midi(s);
2399                 spin_unlock_irqrestore(&s->lock, flags);
2400                 if (cnt > count)
2401                         cnt = count;
2402                 if (cnt <= 0) {
2403                         if (file->f_flags & O_NONBLOCK)
2404                         {
2405                                 if (!ret)
2406                                         ret = -EAGAIN;
2407                                 break;
2408                         }
2409                         __set_current_state(TASK_INTERRUPTIBLE);
2410                         schedule();
2411                         if (signal_pending(current)) {
2412                                 if (!ret)
2413                                         ret = -ERESTARTSYS;
2414                                 break;
2415                         }
2416                         continue;
2417                 }
2418                 if (copy_from_user(s->midi.obuf + ptr, buffer, cnt))
2419                 {
2420                         if (!ret)
2421                                 ret = -EFAULT;
2422                         break;
2423                 }
2424                 ptr = (ptr + cnt) % MIDIOUTBUF;
2425                 spin_lock_irqsave(&s->lock, flags);
2426                 s->midi.owr = ptr;
2427                 s->midi.ocnt += cnt;
2428                 spin_unlock_irqrestore(&s->lock, flags);
2429                 count -= cnt;
2430                 buffer += cnt;
2431                 ret += cnt;
2432                 spin_lock_irqsave(&s->lock, flags);
2433                 cm_handle_midi(s);
2434                 spin_unlock_irqrestore(&s->lock, flags);
2435         }
2436         __set_current_state(TASK_RUNNING);
2437         remove_wait_queue(&s->midi.owait, &wait);
2438         return ret;
2439 }
2440
2441 static unsigned int cm_midi_poll(struct file *file, struct poll_table_struct *wait)
2442 {
2443         struct cm_state *s = (struct cm_state *)file->private_data;
2444         unsigned long flags;
2445         unsigned int mask = 0;
2446
2447         VALIDATE_STATE(s);
2448         if (file->f_mode & FMODE_WRITE)
2449                 poll_wait(file, &s->midi.owait, wait);
2450         if (file->f_mode & FMODE_READ)
2451                 poll_wait(file, &s->midi.iwait, wait);
2452         spin_lock_irqsave(&s->lock, flags);
2453         if (file->f_mode & FMODE_READ) {
2454                 if (s->midi.icnt > 0)
2455                         mask |= POLLIN | POLLRDNORM;
2456         }
2457         if (file->f_mode & FMODE_WRITE) {
2458                 if (s->midi.ocnt < MIDIOUTBUF)
2459                         mask |= POLLOUT | POLLWRNORM;
2460         }
2461         spin_unlock_irqrestore(&s->lock, flags);
2462         return mask;
2463 }
2464
2465 static int cm_midi_open(struct inode *inode, struct file *file)
2466 {
2467         int minor = iminor(inode);
2468         struct cm_state *s = devs;
2469         unsigned long flags;
2470
2471         while (s && s->dev_midi != minor)
2472                 s = s->next;
2473         if (!s)
2474                 return -ENODEV;
2475         VALIDATE_STATE(s);
2476         file->private_data = s;
2477         /* wait for device to become free */
2478         down(&s->open_sem);
2479         while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
2480                 if (file->f_flags & O_NONBLOCK) {
2481                         up(&s->open_sem);
2482                         return -EBUSY;
2483                 }
2484                 up(&s->open_sem);
2485                 interruptible_sleep_on(&s->open_wait);
2486                 if (signal_pending(current))
2487                         return -ERESTARTSYS;
2488                 down(&s->open_sem);
2489         }
2490         spin_lock_irqsave(&s->lock, flags);
2491         if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2492                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2493                 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2494                 /* enable MPU-401 */
2495                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 4);
2496                 outb(0xff, s->iomidi+1); /* reset command */
2497                 if (!(inb(s->iomidi+1) & 0x80))
2498                         inb(s->iomidi);
2499                 outb(0x3f, s->iomidi+1); /* uart command */
2500                 if (!(inb(s->iomidi+1) & 0x80))
2501                         inb(s->iomidi);
2502                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2503                 init_timer(&s->midi.timer);
2504                 s->midi.timer.expires = jiffies+1;
2505                 s->midi.timer.data = (unsigned long)s;
2506                 s->midi.timer.function = cm_midi_timer;
2507                 add_timer(&s->midi.timer);
2508         }
2509         if (file->f_mode & FMODE_READ) {
2510                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2511         }
2512         if (file->f_mode & FMODE_WRITE) {
2513                 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2514         }
2515         spin_unlock_irqrestore(&s->lock, flags);
2516         s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
2517         up(&s->open_sem);
2518         return 0;
2519 }
2520
2521 static int cm_midi_release(struct inode *inode, struct file *file)
2522 {
2523         struct cm_state *s = (struct cm_state *)file->private_data;
2524         DECLARE_WAITQUEUE(wait, current);
2525         unsigned long flags;
2526         unsigned count, tmo;
2527
2528         VALIDATE_STATE(s);
2529         lock_kernel();
2530
2531         if (file->f_mode & FMODE_WRITE) {
2532                 __set_current_state(TASK_INTERRUPTIBLE);
2533                 add_wait_queue(&s->midi.owait, &wait);
2534                 for (;;) {
2535                         spin_lock_irqsave(&s->lock, flags);
2536                         count = s->midi.ocnt;
2537                         spin_unlock_irqrestore(&s->lock, flags);
2538                         if (count <= 0)
2539                                 break;
2540                         if (signal_pending(current))
2541                                 break;
2542                         if (file->f_flags & O_NONBLOCK) {
2543                                 remove_wait_queue(&s->midi.owait, &wait);
2544                                 set_current_state(TASK_RUNNING);
2545                                 unlock_kernel();
2546                                 return -EBUSY;
2547                         }
2548                         tmo = (count * HZ) / 3100;
2549                         if (!schedule_timeout(tmo ? : 1) && tmo)
2550                                 printk(KERN_DEBUG "cmpci: midi timed out??\n");
2551                 }
2552                 remove_wait_queue(&s->midi.owait, &wait);
2553                 set_current_state(TASK_RUNNING);
2554         }
2555         down(&s->open_sem);
2556         s->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE));
2557         spin_lock_irqsave(&s->lock, flags);
2558         if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2559                 del_timer(&s->midi.timer);
2560                 outb(0xff, s->iomidi+1); /* reset command */
2561                 if (!(inb(s->iomidi+1) & 0x80))
2562                         inb(s->iomidi);
2563                 /* disable MPU-401 */
2564                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~4, 0);
2565         }
2566         spin_unlock_irqrestore(&s->lock, flags);
2567         up(&s->open_sem);
2568         wake_up(&s->open_wait);
2569         unlock_kernel();
2570         return 0;
2571 }
2572
2573 static /*const*/ struct file_operations cm_midi_fops = {
2574         .owner   = THIS_MODULE,
2575         .llseek  = no_llseek,
2576         .read    = cm_midi_read,
2577         .write   = cm_midi_write,
2578         .poll    = cm_midi_poll,
2579         .open    = cm_midi_open,
2580         .release = cm_midi_release,
2581 };
2582 #endif
2583
2584 /* --------------------------------------------------------------------- */
2585
2586 #ifdef CONFIG_SOUND_CMPCI_FM
2587 static int cm_dmfm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2588 {
2589         static const unsigned char op_offset[18] = {
2590                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2591                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
2592                 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
2593         };
2594         struct cm_state *s = (struct cm_state *)file->private_data;
2595         struct dm_fm_voice v;
2596         struct dm_fm_note n;
2597         struct dm_fm_params p;
2598         unsigned int io;
2599         unsigned int regb;
2600
2601         switch (cmd) {
2602         case FM_IOCTL_RESET:
2603                 for (regb = 0xb0; regb < 0xb9; regb++) {
2604                         outb(regb, s->iosynth);
2605                         outb(0, s->iosynth+1);
2606                         outb(regb, s->iosynth+2);
2607                         outb(0, s->iosynth+3);
2608                 }
2609                 return 0;
2610
2611         case FM_IOCTL_PLAY_NOTE:
2612                 if (copy_from_user(&n, (void *)arg, sizeof(n)))
2613                         return -EFAULT;
2614                 if (n.voice >= 18)
2615                         return -EINVAL;
2616                 if (n.voice >= 9) {
2617                         regb = n.voice - 9;
2618                         io = s->iosynth+2;
2619                 } else {
2620                         regb = n.voice;
2621                         io = s->iosynth;
2622                 }
2623                 outb(0xa0 + regb, io);
2624                 outb(n.fnum & 0xff, io+1);
2625                 outb(0xb0 + regb, io);
2626                 outb(((n.fnum >> 8) & 3) | ((n.octave & 7) << 2) | ((n.key_on & 1) << 5), io+1);
2627                 return 0;
2628
2629         case FM_IOCTL_SET_VOICE:
2630                 if (copy_from_user(&v, (void *)arg, sizeof(v)))
2631                         return -EFAULT;
2632                 if (v.voice >= 18)
2633                         return -EINVAL;
2634                 regb = op_offset[v.voice];
2635                 io = s->iosynth + ((v.op & 1) << 1);
2636                 outb(0x20 + regb, io);
2637                 outb(((v.am & 1) << 7) | ((v.vibrato & 1) << 6) | ((v.do_sustain & 1) << 5) |
2638                      ((v.kbd_scale & 1) << 4) | (v.harmonic & 0xf), io+1);
2639                 outb(0x40 + regb, io);
2640                 outb(((v.scale_level & 0x3) << 6) | (v.volume & 0x3f), io+1);
2641                 outb(0x60 + regb, io);
2642                 outb(((v.attack & 0xf) << 4) | (v.decay & 0xf), io+1);
2643                 outb(0x80 + regb, io);
2644                 outb(((v.sustain & 0xf) << 4) | (v.release & 0xf), io+1);
2645                 outb(0xe0 + regb, io);
2646                 outb(v.waveform & 0x7, io+1);
2647                 if (n.voice >= 9) {
2648                         regb = n.voice - 9;
2649                         io = s->iosynth+2;
2650                 } else {
2651                         regb = n.voice;
2652                         io = s->iosynth;
2653                 }
2654                 outb(0xc0 + regb, io);
2655                 outb(((v.right & 1) << 5) | ((v.left & 1) << 4) | ((v.feedback & 7) << 1) |
2656                      (v.connection & 1), io+1);
2657                 return 0;
2658
2659         case FM_IOCTL_SET_PARAMS:
2660                 if (copy_from_user(&p, (void *)arg, sizeof(p)))
2661                         return -EFAULT;
2662                 outb(0x08, s->iosynth);
2663                 outb((p.kbd_split & 1) << 6, s->iosynth+1);
2664                 outb(0xbd, s->iosynth);
2665                 outb(((p.am_depth & 1) << 7) | ((p.vib_depth & 1) << 6) | ((p.rhythm & 1) << 5) | ((p.bass & 1) << 4) |
2666                      ((p.snare & 1) << 3) | ((p.tomtom & 1) << 2) | ((p.cymbal & 1) << 1) | (p.hihat & 1), s->iosynth+1);
2667                 return 0;
2668
2669         case FM_IOCTL_SET_OPL:
2670                 outb(4, s->iosynth+2);
2671                 outb(arg, s->iosynth+3);
2672                 return 0;
2673
2674         case FM_IOCTL_SET_MODE:
2675                 outb(5, s->iosynth+2);
2676                 outb(arg & 1, s->iosynth+3);
2677                 return 0;
2678         }
2679         return -EINVAL;
2680 }
2681
2682 static int cm_dmfm_open(struct inode *inode, struct file *file)
2683 {
2684         int minor = iminor(inode);
2685         struct cm_state *s = devs;
2686
2687         while (s && s->dev_dmfm != minor)
2688                 s = s->next;
2689         if (!s)
2690                 return -ENODEV;
2691         VALIDATE_STATE(s);
2692         file->private_data = s;
2693         /* wait for device to become free */
2694         down(&s->open_sem);
2695         while (s->open_mode & FMODE_DMFM) {
2696                 if (file->f_flags & O_NONBLOCK) {
2697                         up(&s->open_sem);
2698                         return -EBUSY;
2699                 }
2700                 up(&s->open_sem);
2701                 interruptible_sleep_on(&s->open_wait);
2702                 if (signal_pending(current))
2703                         return -ERESTARTSYS;
2704                 down(&s->open_sem);
2705         }
2706         /* init the stuff */
2707         outb(1, s->iosynth);
2708         outb(0x20, s->iosynth+1); /* enable waveforms */
2709         outb(4, s->iosynth+2);
2710         outb(0, s->iosynth+3);  /* no 4op enabled */
2711         outb(5, s->iosynth+2);
2712         outb(1, s->iosynth+3);  /* enable OPL3 */
2713         s->open_mode |= FMODE_DMFM;
2714         up(&s->open_sem);
2715         return 0;
2716 }
2717
2718 static int cm_dmfm_release(struct inode *inode, struct file *file)
2719 {
2720         struct cm_state *s = (struct cm_state *)file->private_data;
2721         unsigned int regb;
2722
2723         VALIDATE_STATE(s);
2724         lock_kernel();
2725         down(&s->open_sem);
2726         s->open_mode &= ~FMODE_DMFM;
2727         for (regb = 0xb0; regb < 0xb9; regb++) {
2728                 outb(regb, s->iosynth);
2729                 outb(0, s->iosynth+1);
2730                 outb(regb, s->iosynth+2);
2731                 outb(0, s->iosynth+3);
2732         }
2733         up(&s->open_sem);
2734         wake_up(&s->open_wait);
2735         unlock_kernel();
2736         return 0;
2737 }
2738
2739 static /*const*/ struct file_operations cm_dmfm_fops = {
2740         .owner   = THIS_MODULE,
2741         .llseek  = no_llseek,
2742         .ioctl   = cm_dmfm_ioctl,
2743         .open    = cm_dmfm_open,
2744         .release = cm_dmfm_release,
2745 };
2746 #endif /* CONFIG_SOUND_CMPCI_FM */
2747
2748
2749
2750 static struct initvol {
2751         int mixch;
2752         int vol;
2753 } initvol[] __initdata = {
2754         { SOUND_MIXER_WRITE_CD, 0x4f4f },
2755         { SOUND_MIXER_WRITE_LINE, 0x4f4f },
2756         { SOUND_MIXER_WRITE_MIC, 0x4f4f },
2757         { SOUND_MIXER_WRITE_SYNTH, 0x4f4f },
2758         { SOUND_MIXER_WRITE_VOLUME, 0x4f4f },
2759         { SOUND_MIXER_WRITE_PCM, 0x4f4f }
2760 };
2761
2762 /* check chip version and capability */
2763 static int query_chip(struct cm_state *s)
2764 {
2765         int ChipVersion = -1;
2766         unsigned char RegValue;
2767
2768         // check reg 0Ch, bit 24-31
2769         RegValue = inb(s->iobase + CODEC_CMI_INT_HLDCLR + 3);
2770         if (RegValue == 0) {
2771             // check reg 08h, bit 24-28
2772             RegValue = inb(s->iobase + CODEC_CMI_CHFORMAT + 3);
2773             RegValue &= 0x1f;
2774             if (RegValue == 0) {
2775                 ChipVersion = 33;
2776                 s->max_channels = 4;
2777                 s->capability |= CAN_AC3_SW;
2778                 s->capability |= CAN_DUAL_DAC;
2779             } else {
2780                 ChipVersion = 37;
2781                 s->max_channels = 4;
2782                 s->capability |= CAN_AC3_HW;
2783                 s->capability |= CAN_DUAL_DAC;
2784             }
2785         } else {
2786             // check reg 0Ch, bit 26
2787             if (RegValue & (1 << (26-24))) {
2788                 ChipVersion = 39;
2789                 if (RegValue & (1 << (24-24)))
2790                     s->max_channels  = 6;
2791                 else
2792                     s->max_channels = 4;
2793                 s->capability |= CAN_AC3_HW;
2794                 s->capability |= CAN_DUAL_DAC;
2795                 s->capability |= CAN_MULTI_CH_HW;
2796             } else {
2797                 ChipVersion = 55; // 4 or 6 channels
2798                 s->max_channels  = 6;
2799                 s->capability |= CAN_AC3_HW;
2800                 s->capability |= CAN_DUAL_DAC;
2801                 s->capability |= CAN_MULTI_CH_HW;
2802             }
2803         }
2804         // still limited to number of speakers
2805         if (s->max_channels > s->speakers)
2806                 s->max_channels = s->speakers;
2807         return ChipVersion;
2808 }
2809
2810 #ifdef CONFIG_SOUND_CMPCI_MIDI
2811 static  int     mpuio = CONFIG_SOUND_CMPCI_MPUIO;
2812 #else
2813 static  int     mpuio;
2814 #endif
2815 #ifdef CONFIG_SOUND_CMPCI_FM
2816 static  int     fmio = CONFIG_SOUND_CMPCI_FMIO;
2817 #else
2818 static  int     fmio;
2819 #endif
2820 #ifdef CONFIG_SOUND_CMPCI_SPDIFINVERSE
2821 static  int     spdif_inverse = 1;
2822 #else
2823 static  int     spdif_inverse;
2824 #endif
2825 #ifdef CONFIG_SOUND_CMPCI_SPDIFLOOP
2826 static  int     spdif_loop = 1;
2827 #else
2828 static  int     spdif_loop;
2829 #endif
2830 #ifdef CONFIG_SOUND_CMPCI_SPEAKERS
2831 static  int     speakers = CONFIG_SOUND_CMPCI_SPEAKERS;
2832 #else
2833 static  int     speakers = 2;
2834 #endif
2835 #ifdef CONFIG_SOUND_CMPCI_LINE_REAR
2836 static  int     use_line_as_rear = 1;
2837 #else
2838 static  int     use_line_as_rear;
2839 #endif
2840 #ifdef CONFIG_SOUND_CMPCI_LINE_BASS
2841 static  int     use_line_as_bass = 1;
2842 #else
2843 static  int     use_line_as_bass;
2844 #endif
2845 #ifdef CONFIG_SOUND_CMPCI_JOYSTICK
2846 static  int     joystick = 1;
2847 #else
2848 static  int     joystick;
2849 #endif
2850 MODULE_PARM(mpuio, "i");
2851 MODULE_PARM(fmio, "i");
2852 MODULE_PARM(spdif_inverse, "i");
2853 MODULE_PARM(spdif_loop, "i");
2854 MODULE_PARM(speakers, "i");
2855 MODULE_PARM(use_line_as_rear, "i");
2856 MODULE_PARM(use_line_as_bass, "i");
2857 MODULE_PARM(joystick, "i");
2858 MODULE_PARM_DESC(mpuio, "(0x330, 0x320, 0x310, 0x300) Base of MPU-401, 0 to disable");
2859 MODULE_PARM_DESC(fmio, "(0x388, 0x3C8, 0x3E0) Base of OPL3, 0 to disable");
2860 MODULE_PARM_DESC(spdif_inverse, "(1/0) Invert S/PDIF-in signal");
2861 MODULE_PARM_DESC(spdif_loop, "(1/0) Route S/PDIF-in to S/PDIF-out directly");
2862 MODULE_PARM_DESC(speakers, "(2-6) Number of speakers you connect");
2863 MODULE_PARM_DESC(use_line_as_rear, "(1/0) Use line-in jack as rear-out");
2864 MODULE_PARM_DESC(use_line_as_bass, "(1/0) Use line-in jack as bass/center");
2865 MODULE_PARM_DESC(joystick, "(1/0) Enable joystick interface, still need joystick driver");
2866
2867 static struct pci_device_id cmpci_pci_tbl[] = {
2868         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738,
2869           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2870         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A,
2871           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2872         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B,
2873           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2874         { 0 }
2875 };
2876 MODULE_DEVICE_TABLE(pci, cmpci_pci_tbl);
2877
2878 void initialize_chip(struct pci_dev *pcidev)
2879 {
2880         struct cm_state *s;
2881         int i, val;
2882 #if defined(CONFIG_SOUND_CMPCI_MIDI) || defined(CONFIG_SOUND_CMPCI_FM)
2883         unsigned char reg_mask = 0;
2884 #endif
2885         struct {
2886                 unsigned short  deviceid;
2887                 char            *devicename;
2888         } devicetable[] =
2889         {
2890                 { PCI_DEVICE_ID_CMEDIA_CM8338A, "CM8338A" },
2891                 { PCI_DEVICE_ID_CMEDIA_CM8338B, "CM8338B" },
2892                 { PCI_DEVICE_ID_CMEDIA_CM8738,  "CM8738" },
2893                 { PCI_DEVICE_ID_CMEDIA_CM8738B, "CM8738B" },
2894         };
2895         char    *devicename = "unknown";
2896         {
2897                 if (pci_enable_device(pcidev))
2898                         return;
2899                 if (pcidev->irq == 0)
2900                         return;
2901                 s = kmalloc(sizeof(*s), GFP_KERNEL);
2902                 if (!s) {
2903                         printk(KERN_WARNING "cmpci: out of memory\n");
2904                         return;
2905                 }
2906                 /* search device name */
2907                 for (i = 0; i < sizeof(devicetable) / sizeof(devicetable[0]); i++) {
2908                         if (devicetable[i].deviceid == pcidev->device)
2909                         {
2910                                 devicename = devicetable[i].devicename;
2911                                 break;
2912                         }
2913                 }
2914                 memset(s, 0, sizeof(struct cm_state));
2915                 init_waitqueue_head(&s->dma_adc.wait);
2916                 init_waitqueue_head(&s->dma_dac.wait);
2917                 init_waitqueue_head(&s->open_wait);
2918                 init_waitqueue_head(&s->midi.iwait);
2919                 init_waitqueue_head(&s->midi.owait);
2920                 init_MUTEX(&s->open_sem);
2921                 spin_lock_init(&s->lock);
2922                 s->magic = CM_MAGIC;
2923                 s->iobase = pci_resource_start(pcidev, 0);
2924                 s->iosynth = fmio;
2925                 s->iomidi = mpuio;
2926                 s->status = 0;
2927                 /* range check */
2928                 if (speakers < 2)
2929                         speakers = 2;
2930                 else if (speakers > 6)
2931                         speakers = 6;
2932                 s->speakers = speakers;
2933                 if (s->iobase == 0)
2934                         return;
2935                 s->irq = pcidev->irq;
2936
2937                 if (!request_region(s->iobase, CM_EXTENT_CODEC, "cmpci")) {
2938                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iobase, s->iobase+CM_EXTENT_CODEC-1);
2939                         goto err_region5;
2940                 }
2941 #ifdef CONFIG_SOUND_CMPCI_MIDI
2942                 /* disable MPU-401 */
2943                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x04, 0);
2944                 if (s->iomidi) {
2945                     if (!request_region(s->iomidi, CM_EXTENT_MIDI, "cmpci Midi")) {
2946                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iomidi, s->iomidi+CM_EXTENT_MIDI-1);
2947                         s->iomidi = 0;
2948                     } else {
2949                         /* set IO based at 0x330 */
2950                         switch (s->iomidi) {
2951                             case 0x330:
2952                                 reg_mask = 0;
2953                                 break;
2954                             case 0x320:
2955                                 reg_mask = 0x20;
2956                                 break;
2957                             case 0x310:
2958                                 reg_mask = 0x40;
2959                                 break;
2960                             case 0x300:
2961                                 reg_mask = 0x60;
2962                                 break;
2963                             default:
2964                                 s->iomidi = 0;
2965                                 break;
2966                         }
2967                         outb((inb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3) & ~0x60) | reg_mask, s->iobase + CODEC_CMI_LEGACY_CTRL + 3);
2968                         /* enable MPU-401 */
2969                         if (s->iomidi) {
2970                             maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x04);
2971                         }
2972                     }
2973                 }
2974 #endif
2975 #ifdef CONFIG_SOUND_CMPCI_FM
2976                 /* disable FM */
2977                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~8, 0);
2978                 if (s->iosynth) {
2979                     if (!request_region(s->iosynth, CM_EXTENT_SYNTH, "cmpci FM")) {
2980                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iosynth, s->iosynth+CM_EXTENT_SYNTH-1);
2981                         s->iosynth = 0;
2982                     } else {
2983                         /* set IO based at 0x388 */
2984                         switch (s->iosynth) {
2985                             case 0x388:
2986                                 reg_mask = 0;
2987                                 break;
2988                             case 0x3C8:
2989                                 reg_mask = 0x01;
2990                                 break;
2991                             case 0x3E0:
2992                                 reg_mask = 0x02;
2993                                 break;
2994                             case 0x3E8:
2995                                 reg_mask = 0x03;
2996                                 break;
2997                             default:
2998                                 s->iosynth = 0;
2999                                 break;
3000                         }
3001                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3, ~0x03, reg_mask);
3002                         /* enable FM */
3003                         if (s->iosynth) {
3004                             maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0, 8);
3005                         }
3006                     }
3007                 }
3008 #endif
3009                 /* enable joystick */
3010                 if (joystick)
3011                         maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x02);
3012                 else
3013                         maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x02, 0);
3014                 /* initialize codec registers */
3015                 outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
3016                 outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
3017                 /* reset mixer */
3018                 wrmixer(s, DSP_MIX_DATARESETIDX, 0);
3019
3020                 /* request irq */
3021                 if (request_irq(s->irq, cm_interrupt, SA_SHIRQ, "cmpci", s)) {
3022                         printk(KERN_ERR "cmpci: irq %u in use\n", s->irq);
3023                         goto err_irq;
3024                 }
3025                 printk(KERN_INFO "cmpci: found %s adapter at io %#06x irq %u\n",
3026                        devicename, s->iobase, s->irq);
3027                 /* register devices */
3028                 if ((s->dev_audio = register_sound_dsp(&cm_audio_fops, -1)) < 0)
3029                         goto err_dev1;
3030                 if ((s->dev_mixer = register_sound_mixer(&cm_mixer_fops, -1)) < 0)
3031                         goto err_dev2;
3032 #ifdef CONFIG_SOUND_CMPCI_MIDI
3033                 if ((s->dev_midi = register_sound_midi(&cm_midi_fops, -1)) < 0)
3034                         goto err_dev3;
3035 #endif
3036 #ifdef CONFIG_SOUND_CMPCI_FM
3037                 if ((s->dev_dmfm = register_sound_special(&cm_dmfm_fops, 15 /* ?? */)) < 0)
3038                         goto err_dev4;
3039 #endif
3040                 pci_set_master(pcidev); /* enable bus mastering */
3041                 /* initialize the chips */
3042                 /* set mixer output */
3043                 frobindir(s, DSP_MIX_OUTMIXIDX, 0x1f, 0x1f);
3044                 /* set mixer input */
3045                 val = SOUND_MASK_LINE|SOUND_MASK_SYNTH|SOUND_MASK_CD|SOUND_MASK_MIC;
3046                 mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
3047                 for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
3048                         val = initvol[i].vol;
3049                         mixer_ioctl(s, initvol[i].mixch, (unsigned long)&val);
3050                 }
3051                 /* use channel 0 for record, channel 1 for play */
3052                 maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~2, 1);
3053                 s->deviceid = pcidev->device;
3054
3055                 if (pcidev->device == PCI_DEVICE_ID_CMEDIA_CM8738) {
3056
3057                         /* chip version and hw capability check */
3058                         s->chip_version = query_chip(s);
3059                         printk(KERN_INFO "cmpci: chip version = 0%d\n", s->chip_version);
3060
3061                         /* seet SPDIF-in inverse before enable SPDIF loop */
3062                         if (spdif_inverse) {
3063                                 /* turn on spdif-in inverse */
3064                                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~0, 1);
3065                                 printk(KERN_INFO "cmpci: Inverse SPDIF-in\n");
3066                         } else {
3067                                 /* turn off spdif-ininverse */
3068                                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~1, 0);
3069                         }
3070
3071                         /* enable SPDIF loop */
3072                         if (spdif_loop) {
3073                                 s->status |= DO_SPDIF_LOOP;
3074                                 /* turn on spdif-in to spdif-out */
3075                                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x80);
3076                                 printk(KERN_INFO "cmpci: Enable SPDIF loop\n");
3077                         } else {
3078                                 s->status &= ~DO_SPDIF_LOOP;
3079                                 /* turn off spdif-in to spdif-out */
3080                                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x80, 0);
3081                         }
3082                         if (use_line_as_rear) {
3083                                 s->capability |= CAN_LINE_AS_REAR;
3084                                 s->status |= DO_LINE_AS_REAR;
3085                                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0, 0x20);
3086                         } else
3087                                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0x20, 0);
3088                         if (s->chip_version >= 39) {
3089                                 if (use_line_as_bass) {
3090                                         s->capability |= CAN_LINE_AS_BASS;
3091                                         s->status |= DO_LINE_AS_BASS;
3092                                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0, 0x60);
3093                                 } else
3094                                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0x60, 0);
3095                         }
3096                 } else {
3097                         /* 8338 will fall here */
3098                         s->max_channels = 2;
3099                 }
3100                 /* queue it for later freeing */
3101                 s->next = devs;
3102                 devs = s;
3103                 return;
3104
3105 #ifdef CONFIG_SOUND_CMPCI_FM
3106                 unregister_sound_special(s->dev_dmfm);
3107         err_dev4:
3108 #endif
3109 #ifdef CONFIG_SOUND_CMPCI_MIDI
3110                 unregister_sound_midi(s->dev_midi);
3111         err_dev3:
3112 #endif
3113                 unregister_sound_mixer(s->dev_mixer);
3114         err_dev2:
3115                 unregister_sound_dsp(s->dev_audio);
3116         err_dev1:
3117                 printk(KERN_ERR "cmpci: cannot register misc device\n");
3118                 free_irq(s->irq, s);
3119         err_irq:
3120 #ifdef CONFIG_SOUND_CMPCI_FM
3121                 if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
3122 #endif
3123 #ifdef CONFIG_SOUND_CMPCI_MIDI
3124                 if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
3125 #endif
3126                 release_region(s->iobase, CM_EXTENT_CODEC);
3127         err_region5:
3128                 kfree(s);
3129         }
3130         if (!devs) {
3131                 if (wavetable_mem)
3132                         free_pages(wavetable_mem, 20-PAGE_SHIFT);
3133                 return;
3134         }
3135         return;
3136 }
3137
3138 static int __init init_cmpci(void)
3139 {
3140         struct pci_dev *pcidev = NULL;
3141         int index = 0;
3142
3143         printk(KERN_INFO "cmpci: version $Revision: 5.64 $ time " __TIME__ " " __DATE__ "\n");
3144
3145         while (index < NR_DEVICE && (
3146                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738, pcidev)))) {
3147                 initialize_chip(pcidev);
3148                 index++;
3149         }
3150         while (index < NR_DEVICE && (
3151                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A, pcidev)))) {
3152                 initialize_chip(pcidev);
3153                 index++;
3154         }
3155         while (index < NR_DEVICE && (
3156                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B, pcidev)))) {
3157                 initialize_chip(pcidev);
3158                 index++;
3159         }
3160         return 0;
3161 }
3162
3163 /* --------------------------------------------------------------------- */
3164
3165 MODULE_AUTHOR("ChenLi Tien, cltien@cmedia.com.tw");
3166 MODULE_DESCRIPTION("CM8x38 Audio Driver");
3167 MODULE_LICENSE("GPL");
3168
3169
3170 static void __exit cleanup_cmpci(void)
3171 {
3172         struct cm_state *s;
3173
3174         while ((s = devs)) {
3175                 devs = devs->next;
3176                 outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
3177                 synchronize_irq(s->irq);
3178                 outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
3179                 free_irq(s->irq, s);
3180
3181                 /* reset mixer */
3182                 wrmixer(s, DSP_MIX_DATARESETIDX, 0);
3183
3184                 release_region(s->iobase, CM_EXTENT_CODEC);
3185 #ifdef CONFIG_SOUND_CMPCI_MIDI
3186                 if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
3187 #endif
3188 #ifdef CONFIG_SOUND_CMPCI_FM
3189                 if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
3190 #endif
3191                 unregister_sound_dsp(s->dev_audio);
3192                 unregister_sound_mixer(s->dev_mixer);
3193 #ifdef CONFIG_SOUND_CMPCI_MIDI
3194                 unregister_sound_midi(s->dev_midi);
3195 #endif
3196 #ifdef CONFIG_SOUND_CMPCI_FM
3197                 unregister_sound_special(s->dev_dmfm);
3198 #endif
3199                 kfree(s);
3200         }
3201         if (wavetable_mem)
3202                 free_pages(wavetable_mem, 20-PAGE_SHIFT);
3203         printk(KERN_INFO "cmpci: unloading\n");
3204 }
3205
3206 module_init(init_cmpci);
3207 module_exit(cleanup_cmpci);