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 = minor(inode->i_rdev);
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 = (struct cm_state *)file->private_data;
1466
1467         VALIDATE_STATE(s);
1468         return 0;
1469 }
1470
1471 static int cm_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1472 {
1473         return mixer_ioctl((struct cm_state *)file->private_data, cmd, arg);
1474 }
1475
1476 static /*const*/ struct file_operations cm_mixer_fops = {
1477         .owner   = THIS_MODULE,
1478         .llseek  = no_llseek,
1479         .ioctl   = cm_ioctl_mixdev,
1480         .open    = cm_open_mixdev,
1481         .release = cm_release_mixdev,
1482 };
1483
1484
1485 /* --------------------------------------------------------------------- */
1486
1487 static int drain_dac(struct cm_state *s, int nonblock)
1488 {
1489         DECLARE_WAITQUEUE(wait, current);
1490         unsigned long flags;
1491         int count, tmo;
1492
1493         if (s->dma_dac.mapped || !s->dma_dac.ready)
1494                 return 0;
1495         set_current_state(TASK_INTERRUPTIBLE);
1496         add_wait_queue(&s->dma_dac.wait, &wait);
1497         for (;;) {
1498                 spin_lock_irqsave(&s->lock, flags);
1499                 count = s->dma_dac.count;
1500                 spin_unlock_irqrestore(&s->lock, flags);
1501                 if (count <= 0)
1502                         break;
1503                 if (signal_pending(current))
1504                         break;
1505                 if (nonblock) {
1506                         remove_wait_queue(&s->dma_dac.wait, &wait);
1507                         set_current_state(TASK_RUNNING);
1508                         return -EBUSY;
1509                 }
1510                 tmo = 3 * HZ * (count + s->dma_dac.fragsize) / 2 / s->ratedac;
1511                 tmo >>= sample_shift[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK];
1512                 if (!schedule_timeout(tmo + 1))
1513                         printk(KERN_DEBUG "cmpci: dma timed out??\n");
1514         }
1515         remove_wait_queue(&s->dma_dac.wait, &wait);
1516         set_current_state(TASK_RUNNING);
1517         if (signal_pending(current))
1518                 return -ERESTARTSYS;
1519         return 0;
1520 }
1521
1522 /* --------------------------------------------------------------------- */
1523
1524 static ssize_t cm_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1525 {
1526         struct cm_state *s = (struct cm_state *)file->private_data;
1527         ssize_t ret;
1528         unsigned long flags;
1529         unsigned swptr;
1530         int cnt;
1531
1532         VALIDATE_STATE(s);
1533         if (ppos != &file->f_pos)
1534                 return -ESPIPE;
1535         if (s->dma_adc.mapped)
1536                 return -ENXIO;
1537         if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1538                 return ret;
1539         if (!access_ok(VERIFY_WRITE, buffer, count))
1540                 return -EFAULT;
1541         ret = 0;
1542
1543         while (count > 0) {
1544                 spin_lock_irqsave(&s->lock, flags);
1545                 swptr = s->dma_adc.swptr;
1546                 cnt = s->dma_adc.dmasize-swptr;
1547                 if (s->dma_adc.count < cnt)
1548                         cnt = s->dma_adc.count;
1549                 spin_unlock_irqrestore(&s->lock, flags);
1550                 if (cnt > count)
1551                         cnt = count;
1552                 if (cnt <= 0) {
1553                         start_adc(s);
1554                         if (file->f_flags & O_NONBLOCK)
1555                                 return ret ? ret : -EAGAIN;
1556                         if (!interruptible_sleep_on_timeout(&s->dma_adc.wait, HZ)) {
1557                                 printk(KERN_DEBUG "cmpci: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1558                                        s->dma_adc.dmasize, s->dma_adc.fragsize, s->dma_adc.count,
1559                                        s->dma_adc.hwptr, s->dma_adc.swptr);
1560                                 spin_lock_irqsave(&s->lock, flags);
1561                                 stop_adc_unlocked(s);
1562                                 set_dmaadc(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
1563                                 /* program sample counts */
1564                                 set_countadc(s, s->dma_adc.fragsamples);
1565                                 s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
1566                                 spin_unlock_irqrestore(&s->lock, flags);
1567                         }
1568                         if (signal_pending(current))
1569                                 return ret ? ret : -ERESTARTSYS;
1570                         continue;
1571                 }
1572                 if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt))
1573                         return ret ? ret : -EFAULT;
1574                 swptr = (swptr + cnt) % s->dma_adc.dmasize;
1575                 spin_lock_irqsave(&s->lock, flags);
1576                 s->dma_adc.swptr = swptr;
1577                 s->dma_adc.count -= cnt;
1578                 count -= cnt;
1579                 buffer += cnt;
1580                 ret += cnt;
1581                 start_adc_unlocked(s);
1582                 spin_unlock_irqrestore(&s->lock, flags);
1583         }
1584         return ret;
1585 }
1586
1587 static ssize_t cm_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1588 {
1589         struct cm_state *s = (struct cm_state *)file->private_data;
1590         ssize_t ret;
1591         unsigned long flags;
1592         unsigned swptr;
1593         int cnt;
1594
1595         VALIDATE_STATE(s);
1596         if (ppos != &file->f_pos)
1597                 return -ESPIPE;
1598         if (s->dma_dac.mapped)
1599                 return -ENXIO;
1600         if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
1601                 return ret;
1602         if (!access_ok(VERIFY_READ, buffer, count))
1603                 return -EFAULT;
1604         if (s->status & DO_DUAL_DAC) {
1605                 if (s->dma_adc.mapped)
1606                         return -ENXIO;
1607                 if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1608                         return ret;
1609                 if (!access_ok(VERIFY_READ, buffer, count))
1610                         return -EFAULT;
1611         }
1612         ret = 0;
1613
1614         while (count > 0) {
1615                 spin_lock_irqsave(&s->lock, flags);
1616                 if (s->dma_dac.count < 0) {
1617                         s->dma_dac.count = 0;
1618                         s->dma_dac.swptr = s->dma_dac.hwptr;
1619                 }
1620                 if (s->status & DO_DUAL_DAC) {
1621                         s->dma_adc.swptr = s->dma_dac.swptr;
1622                         s->dma_adc.count = s->dma_dac.count;
1623                         s->dma_adc.endcleared = s->dma_dac.endcleared;
1624                 }
1625                 swptr = s->dma_dac.swptr;
1626                 cnt = s->dma_dac.dmasize-swptr;
1627                 if (s->status & DO_AC3_SW) {
1628                         if (s->dma_dac.count + 2 * cnt > s->dma_dac.dmasize)
1629                                 cnt = (s->dma_dac.dmasize - s->dma_dac.count) / 2;
1630                 } else {
1631                         if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
1632                                 cnt = s->dma_dac.dmasize - s->dma_dac.count;
1633                 }
1634                 spin_unlock_irqrestore(&s->lock, flags);
1635                 if (cnt > count)
1636                         cnt = count;
1637                 if ((s->status & DO_DUAL_DAC) && (cnt > count / 2))
1638                     cnt = count / 2;
1639                 if (cnt <= 0) {
1640                         start_dac(s);
1641                         if (file->f_flags & O_NONBLOCK)
1642                                 return ret ? ret : -EAGAIN;
1643                         if (!interruptible_sleep_on_timeout(&s->dma_dac.wait, HZ)) {
1644                                 printk(KERN_DEBUG "cmpci: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
1645                                        s->dma_dac.dmasize, s->dma_dac.fragsize, s->dma_dac.count,
1646                                        s->dma_dac.hwptr, s->dma_dac.swptr);
1647                                 spin_lock_irqsave(&s->lock, flags);
1648                                 stop_dac_unlocked(s);
1649                                 set_dmadac(s, s->dma_dac.rawphys, s->dma_dac.dmasamples);
1650                                 /* program sample counts */
1651                                 set_countdac(s, s->dma_dac.fragsamples);
1652                                 s->dma_dac.count = s->dma_dac.hwptr = s->dma_dac.swptr = 0;
1653                                 if (s->status & DO_DUAL_DAC)  {
1654                                         set_dmadac1(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
1655                                         s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
1656                                 }
1657                                 spin_unlock_irqrestore(&s->lock, flags);
1658                         }
1659                         if (signal_pending(current))
1660                                 return ret ? ret : -ERESTARTSYS;
1661                         continue;
1662                 }
1663                 if (s->status & DO_AC3_SW) {
1664                         int err;
1665
1666                         // clip exceeded data, caught by 033 and 037
1667                         if (swptr + 2 * cnt > s->dma_dac.dmasize)
1668                                 cnt = (s->dma_dac.dmasize - swptr) / 2;
1669                         if ((err = trans_ac3(s, s->dma_dac.rawbuf + swptr, buffer, cnt)))
1670                                 return err;
1671                         swptr = (swptr + 2 * cnt) % s->dma_dac.dmasize;
1672                 } else if (s->status & DO_DUAL_DAC) {
1673                         int     i, err;
1674                         unsigned long *src, *dst0, *dst1;
1675
1676                         src = (unsigned long *) buffer;
1677                         dst0 = (unsigned long *) (s->dma_dac.rawbuf + swptr);
1678                         dst1 = (unsigned long *) (s->dma_adc.rawbuf + swptr);
1679                         // copy left/right sample at one time
1680                         for (i = 0; i <= cnt / 4; i++) {
1681                                 if ((err = __get_user(*dst0++, src++)))
1682                                         return err;
1683                                 if ((err = __get_user(*dst1++, src++)))
1684                                         return err;
1685                         }
1686                         swptr = (swptr + cnt) % s->dma_dac.dmasize;
1687                 } else {
1688                         if (copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt))
1689                                 return ret ? ret : -EFAULT;
1690                         swptr = (swptr + cnt) % s->dma_dac.dmasize;
1691                 }
1692                 spin_lock_irqsave(&s->lock, flags);
1693                 s->dma_dac.swptr = swptr;
1694                 s->dma_dac.count += cnt;
1695                 if (s->status & DO_AC3_SW)
1696                         s->dma_dac.count += cnt;
1697                 s->dma_dac.endcleared = 0;
1698                 spin_unlock_irqrestore(&s->lock, flags);
1699                 count -= cnt;
1700                 buffer += cnt;
1701                 ret += cnt;
1702                 if (s->status & DO_DUAL_DAC) {
1703                         count -= cnt;
1704                         buffer += cnt;
1705                         ret += cnt;
1706                 }
1707                 start_dac(s);
1708         }
1709         return ret;
1710 }
1711
1712 static unsigned int cm_poll(struct file *file, struct poll_table_struct *wait)
1713 {
1714         struct cm_state *s = (struct cm_state *)file->private_data;
1715         unsigned long flags;
1716         unsigned int mask = 0;
1717
1718         VALIDATE_STATE(s);
1719         if (file->f_mode & FMODE_WRITE)
1720                 poll_wait(file, &s->dma_dac.wait, wait);
1721         if (file->f_mode & FMODE_READ)
1722                 poll_wait(file, &s->dma_adc.wait, wait);
1723         spin_lock_irqsave(&s->lock, flags);
1724         cm_update_ptr(s);
1725         if (file->f_mode & FMODE_READ) {
1726                 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1727                         mask |= POLLIN | POLLRDNORM;
1728         }
1729         if (file->f_mode & FMODE_WRITE) {
1730                 if (s->dma_dac.mapped) {
1731                         if (s->dma_dac.count >= (signed)s->dma_dac.fragsize)
1732                                 mask |= POLLOUT | POLLWRNORM;
1733                 } else {
1734                         if ((signed)s->dma_dac.dmasize >= s->dma_dac.count + (signed)s->dma_dac.fragsize)
1735                                 mask |= POLLOUT | POLLWRNORM;
1736                 }
1737         }
1738         spin_unlock_irqrestore(&s->lock, flags);
1739         return mask;
1740 }
1741
1742 static int cm_mmap(struct file *file, struct vm_area_struct *vma)
1743 {
1744         struct cm_state *s = (struct cm_state *)file->private_data;
1745         struct dmabuf *db;
1746         int ret = -EINVAL;
1747         unsigned long size;
1748
1749         VALIDATE_STATE(s);
1750         lock_kernel();
1751         if (vma->vm_flags & VM_WRITE) {
1752                 if ((ret = prog_dmabuf(s, 0)) != 0)
1753                         goto out;
1754                 db = &s->dma_dac;
1755         } else if (vma->vm_flags & VM_READ) {
1756                 if ((ret = prog_dmabuf(s, 1)) != 0)
1757                         goto out;
1758                 db = &s->dma_adc;
1759         } else
1760                 goto out;
1761         ret = -EINVAL;
1762         if (vma->vm_pgoff != 0)
1763                 goto out;
1764         size = vma->vm_end - vma->vm_start;
1765         if (size > (PAGE_SIZE << db->buforder))
1766                 goto out;
1767         ret = -EINVAL;
1768         if (remap_page_range(vma, vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot))
1769                 goto out;
1770         db->mapped = 1;
1771         ret = 0;
1772 out:
1773         unlock_kernel();
1774         return ret;
1775 }
1776
1777 static int cm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1778 {
1779         struct cm_state *s = (struct cm_state *)file->private_data;
1780         unsigned long flags;
1781         audio_buf_info abinfo;
1782         count_info cinfo;
1783         int val, mapped, ret;
1784         unsigned char fmtm, fmtd;
1785
1786         VALIDATE_STATE(s);
1787         mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
1788                 ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
1789         switch (cmd) {
1790         case OSS_GETVERSION:
1791                 return put_user(SOUND_VERSION, (int *)arg);
1792
1793         case SNDCTL_DSP_SYNC:
1794                 if (file->f_mode & FMODE_WRITE)
1795                         return drain_dac(s, 0/*file->f_flags & O_NONBLOCK*/);
1796                 return 0;
1797
1798         case SNDCTL_DSP_SETDUPLEX:
1799                 return 0;
1800
1801         case SNDCTL_DSP_GETCAPS:
1802                 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_BIND, (int *)arg);
1803
1804         case SNDCTL_DSP_RESET:
1805                 if (file->f_mode & FMODE_WRITE) {
1806                         stop_dac(s);
1807                         synchronize_irq(s->irq);
1808                         s->dma_dac.swptr = s->dma_dac.hwptr = s->dma_dac.count = s->dma_dac.total_bytes = 0;
1809                         if (s->status & DO_DUAL_DAC)
1810                                 s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
1811                 }
1812                 if (file->f_mode & FMODE_READ) {
1813                         stop_adc(s);
1814                         synchronize_irq(s->irq);
1815                         s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
1816                 }
1817                 return 0;
1818
1819         case SNDCTL_DSP_SPEED:
1820                 if (get_user(val, (int *)arg))
1821                         return -EFAULT;
1822                 if (val >= 0) {
1823                         if (file->f_mode & FMODE_READ) {
1824                                 spin_lock_irqsave(&s->lock, flags);
1825                                 stop_adc_unlocked(s);
1826                                 s->dma_adc.ready = 0;
1827                                 set_adc_rate_unlocked(s, val);
1828                                 spin_unlock_irqrestore(&s->lock, flags);
1829                         }
1830                         if (file->f_mode & FMODE_WRITE) {
1831                                 stop_dac(s);
1832                                 s->dma_dac.ready = 0;
1833                                 if (s->status & DO_DUAL_DAC)
1834                                         s->dma_adc.ready = 0;
1835                                 set_dac_rate(s, val);
1836                         }
1837                 }
1838                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
1839
1840         case SNDCTL_DSP_STEREO:
1841                 if (get_user(val, (int *)arg))
1842                         return -EFAULT;
1843                 fmtd = 0;
1844                 fmtm = ~0;
1845                 if (file->f_mode & FMODE_READ) {
1846                         stop_adc(s);
1847                         s->dma_adc.ready = 0;
1848                         if (val)
1849                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1850                         else
1851                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1852                 }
1853                 if (file->f_mode & FMODE_WRITE) {
1854                         stop_dac(s);
1855                         s->dma_dac.ready = 0;
1856                         if (val)
1857                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1858                         else
1859                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
1860                         if (s->status & DO_DUAL_DAC) {
1861                                 s->dma_adc.ready = 0;
1862                                 if (val)
1863                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1864                                 else
1865                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1866                         }
1867                 }
1868                 set_fmt(s, fmtm, fmtd);
1869                 return 0;
1870
1871         case SNDCTL_DSP_CHANNELS:
1872                 if (get_user(val, (int *)arg))
1873                         return -EFAULT;
1874                 if (val != 0) {
1875                         fmtd = 0;
1876                         fmtm = ~0;
1877                         if (file->f_mode & FMODE_READ) {
1878                                 stop_adc(s);
1879                                 s->dma_adc.ready = 0;
1880                                 if (val >= 2)
1881                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1882                                 else
1883                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1884                         }
1885                         if (file->f_mode & FMODE_WRITE) {
1886                                 stop_dac(s);
1887                                 s->dma_dac.ready = 0;
1888                                 if (val >= 2)
1889                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1890                                 else
1891                                         fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
1892                                 if (s->status & DO_DUAL_DAC) {
1893                                         s->dma_adc.ready = 0;
1894                                         if (val >= 2)
1895                                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1896                                         else
1897                                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1898                                 }
1899                         }
1900                         set_fmt(s, fmtm, fmtd);
1901                         if ((s->capability & CAN_MULTI_CH)
1902                              && (file->f_mode & FMODE_WRITE)) {
1903                                 val = set_dac_channels(s, val);
1904                                 return put_user(val, (int *)arg);
1905                         }
1906                 }
1907                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_STEREO << CM_CFMT_ADCSHIFT)
1908                                            : (CM_CFMT_STEREO << CM_CFMT_DACSHIFT))) ? 2 : 1, (int *)arg);
1909
1910         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
1911                 return put_user(AFMT_S16_LE|AFMT_U8|AFMT_AC3, (int *)arg);
1912
1913         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
1914                 if (get_user(val, (int *)arg))
1915                         return -EFAULT;
1916                 if (val != AFMT_QUERY) {
1917                         fmtd = 0;
1918                         fmtm = ~0;
1919                         if (file->f_mode & FMODE_READ) {
1920                                 stop_adc(s);
1921                                 s->dma_adc.ready = 0;
1922                                 if (val == AFMT_S16_LE)
1923                                         fmtd |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
1924                                 else
1925                                         fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_ADCSHIFT);
1926                         }
1927                         if (file->f_mode & FMODE_WRITE) {
1928                                 stop_dac(s);
1929                                 s->dma_dac.ready = 0;
1930                                 if (val == AFMT_S16_LE || val == AFMT_AC3)
1931                                         fmtd |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
1932                                 else
1933                                         fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_DACSHIFT);
1934                                 if (val == AFMT_AC3) {
1935                                         fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
1936                                         set_ac3(s, s->ratedac);
1937                                 } else
1938                                         set_ac3(s, 0);
1939                                 if (s->status & DO_DUAL_DAC) {
1940                                         s->dma_adc.ready = 0;
1941                                         if (val == AFMT_S16_LE)
1942                                                 fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
1943                                         else
1944                                                 fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
1945                                 }
1946                         }
1947                         set_fmt(s, fmtm, fmtd);
1948                 }
1949                 if (s->status & DO_AC3) return put_user(AFMT_AC3, (int *)arg);
1950                 return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_16BIT << CM_CFMT_ADCSHIFT)
1951                                            : (CM_CFMT_16BIT << CM_CFMT_DACSHIFT))) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
1952
1953         case SNDCTL_DSP_POST:
1954                 return 0;
1955
1956         case SNDCTL_DSP_GETTRIGGER:
1957                 val = 0;
1958                 if (s->status & DO_DUAL_DAC) {
1959                         if (file->f_mode & FMODE_WRITE &&
1960                          (s->enable & CM_ENABLE_CH1) &&
1961                          (s->enable & CM_ENABLE_CH0))
1962                                 val |= PCM_ENABLE_OUTPUT;
1963                         return put_user(val, (int *)arg);
1964                 }
1965                 if (file->f_mode & FMODE_READ && s->enable & CM_ENABLE_CH0)
1966                         val |= PCM_ENABLE_INPUT;
1967                 if (file->f_mode & FMODE_WRITE && s->enable & CM_ENABLE_CH1)
1968                         val |= PCM_ENABLE_OUTPUT;
1969                 return put_user(val, (int *)arg);
1970
1971         case SNDCTL_DSP_SETTRIGGER:
1972                 if (get_user(val, (int *)arg))
1973                         return -EFAULT;
1974                 if (file->f_mode & FMODE_READ) {
1975                         if (val & PCM_ENABLE_INPUT) {
1976                                 if (!s->dma_adc.ready && (ret =  prog_dmabuf(s, 1)))
1977                                         return ret;
1978                                 start_adc(s);
1979                         } else
1980                                 stop_adc(s);
1981                 }
1982                 if (file->f_mode & FMODE_WRITE) {
1983                         if (val & PCM_ENABLE_OUTPUT) {
1984                                 if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
1985                                         return ret;
1986                                 if (s->status & DO_DUAL_DAC) {
1987                                         if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
1988                                                 return ret;
1989                                 }
1990                                 start_dac(s);
1991                         } else
1992                                 stop_dac(s);
1993                 }
1994                 return 0;
1995
1996         case SNDCTL_DSP_GETOSPACE:
1997                 if (!(file->f_mode & FMODE_WRITE))
1998                         return -EINVAL;
1999                 if (!(s->enable & CM_ENABLE_CH1) && (val = prog_dmabuf(s, 0)) != 0)
2000                         return val;
2001                 spin_lock_irqsave(&s->lock, flags);
2002                 cm_update_ptr(s);
2003                 abinfo.fragsize = s->dma_dac.fragsize;
2004                 abinfo.bytes = s->dma_dac.dmasize - s->dma_dac.count;
2005                 abinfo.fragstotal = s->dma_dac.numfrag;
2006                 abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;
2007                 spin_unlock_irqrestore(&s->lock, flags);
2008                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2009
2010         case SNDCTL_DSP_GETISPACE:
2011                 if (!(file->f_mode & FMODE_READ))
2012                         return -EINVAL;
2013                 if (!(s->enable & CM_ENABLE_CH0) && (val = prog_dmabuf(s, 1)) != 0)
2014                         return val;
2015                 spin_lock_irqsave(&s->lock, flags);
2016                 cm_update_ptr(s);
2017                 abinfo.fragsize = s->dma_adc.fragsize;
2018                 abinfo.bytes = s->dma_adc.count;
2019                 abinfo.fragstotal = s->dma_adc.numfrag;
2020                 abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;
2021                 spin_unlock_irqrestore(&s->lock, flags);
2022                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2023
2024         case SNDCTL_DSP_NONBLOCK:
2025                 file->f_flags |= O_NONBLOCK;
2026                 return 0;
2027
2028         case SNDCTL_DSP_GETODELAY:
2029                 if (!(file->f_mode & FMODE_WRITE))
2030                         return -EINVAL;
2031                 spin_lock_irqsave(&s->lock, flags);
2032                 cm_update_ptr(s);
2033                 val = s->dma_dac.count;
2034                 spin_unlock_irqrestore(&s->lock, flags);
2035                 return put_user(val, (int *)arg);
2036
2037         case SNDCTL_DSP_GETIPTR:
2038                 if (!(file->f_mode & FMODE_READ))
2039                         return -EINVAL;
2040                 spin_lock_irqsave(&s->lock, flags);
2041                 cm_update_ptr(s);
2042                 cinfo.bytes = s->dma_adc.total_bytes;
2043                 cinfo.blocks = s->dma_adc.count >> s->dma_adc.fragshift;
2044                 cinfo.ptr = s->dma_adc.hwptr;
2045                 if (s->dma_adc.mapped)
2046                         s->dma_adc.count &= s->dma_adc.fragsize-1;
2047                 spin_unlock_irqrestore(&s->lock, flags);
2048                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
2049                         return -EFAULT;
2050                 return 0;
2051
2052         case SNDCTL_DSP_GETOPTR:
2053                 if (!(file->f_mode & FMODE_WRITE))
2054                         return -EINVAL;
2055                 spin_lock_irqsave(&s->lock, flags);
2056                 cm_update_ptr(s);
2057                 cinfo.bytes = s->dma_dac.total_bytes;
2058                 cinfo.blocks = s->dma_dac.count >> s->dma_dac.fragshift;
2059                 cinfo.ptr = s->dma_dac.hwptr;
2060                 if (s->dma_dac.mapped)
2061                         s->dma_dac.count &= s->dma_dac.fragsize-1;
2062                 if (s->status & DO_DUAL_DAC) {
2063                         if (s->dma_adc.mapped)
2064                                 s->dma_adc.count &= s->dma_adc.fragsize-1;
2065                 }
2066                 spin_unlock_irqrestore(&s->lock, flags);
2067                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
2068                         return -EFAULT;
2069                 return 0;
2070
2071         case SNDCTL_DSP_GETBLKSIZE:
2072                 if (file->f_mode & FMODE_WRITE) {
2073                         if ((val = prog_dmabuf(s, 0)))
2074                                 return val;
2075                         if (s->status & DO_DUAL_DAC) {
2076                                 if ((val = prog_dmabuf(s, 1)))
2077                                         return val;
2078                                 return put_user(2 * s->dma_dac.fragsize, (int *)arg);
2079                         }
2080                         return put_user(s->dma_dac.fragsize, (int *)arg);
2081                 }
2082                 if ((val = prog_dmabuf(s, 1)))
2083                         return val;
2084                 return put_user(s->dma_adc.fragsize, (int *)arg);
2085
2086         case SNDCTL_DSP_SETFRAGMENT:
2087                 if (get_user(val, (int *)arg))
2088                         return -EFAULT;
2089                 if (file->f_mode & FMODE_READ) {
2090                         s->dma_adc.ossfragshift = val & 0xffff;
2091                         s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
2092                         if (s->dma_adc.ossfragshift < 4)
2093                                 s->dma_adc.ossfragshift = 4;
2094                         if (s->dma_adc.ossfragshift > 15)
2095                                 s->dma_adc.ossfragshift = 15;
2096                         if (s->dma_adc.ossmaxfrags < 4)
2097                                 s->dma_adc.ossmaxfrags = 4;
2098                 }
2099                 if (file->f_mode & FMODE_WRITE) {
2100                         s->dma_dac.ossfragshift = val & 0xffff;
2101                         s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
2102                         if (s->dma_dac.ossfragshift < 4)
2103                                 s->dma_dac.ossfragshift = 4;
2104                         if (s->dma_dac.ossfragshift > 15)
2105                                 s->dma_dac.ossfragshift = 15;
2106                         if (s->dma_dac.ossmaxfrags < 4)
2107                                 s->dma_dac.ossmaxfrags = 4;
2108                         if (s->status & DO_DUAL_DAC) {
2109                                 s->dma_adc.ossfragshift = s->dma_dac.ossfragshift;
2110                                 s->dma_adc.ossmaxfrags = s->dma_dac.ossmaxfrags;
2111                         }
2112                 }
2113                 return 0;
2114
2115         case SNDCTL_DSP_SUBDIVIDE:
2116                 if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
2117                     (file->f_mode & FMODE_WRITE && s->dma_dac.subdivision))
2118                         return -EINVAL;
2119                 if (get_user(val, (int *)arg))
2120                         return -EFAULT;
2121                 if (val != 1 && val != 2 && val != 4)
2122                         return -EINVAL;
2123                 if (file->f_mode & FMODE_READ)
2124                         s->dma_adc.subdivision = val;
2125                 if (file->f_mode & FMODE_WRITE) {
2126                         s->dma_dac.subdivision = val;
2127                         if (s->status & DO_DUAL_DAC)
2128                                 s->dma_adc.subdivision = val;
2129                 }
2130                 return 0;
2131
2132         case SOUND_PCM_READ_RATE:
2133                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
2134
2135         case SOUND_PCM_READ_CHANNELS:
2136                 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);
2137
2138         case SOUND_PCM_READ_BITS:
2139                 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);
2140
2141         case SOUND_PCM_READ_FILTER:
2142                 return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
2143
2144         case SNDCTL_DSP_GETCHANNELMASK:
2145                 return put_user(DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE|DSP_BIND_SPDIF, (int *)arg);
2146
2147         case SNDCTL_DSP_BIND_CHANNEL:
2148                 if (get_user(val, (int *)arg))
2149                         return -EFAULT;
2150                 if (val == DSP_BIND_QUERY) {
2151                         val = DSP_BIND_FRONT;
2152                         if (s->status & DO_SPDIF_OUT)
2153                                 val |= DSP_BIND_SPDIF;
2154                         else {
2155                                 if (s->curr_channels == 4)
2156                                         val |= DSP_BIND_SURR;
2157                                 if (s->curr_channels > 4)
2158                                         val |= DSP_BIND_CENTER_LFE;
2159                         }
2160                 } else {
2161                         if (file->f_mode & FMODE_READ) {
2162                                 stop_adc(s);
2163                                 s->dma_adc.ready = 0;
2164                         }
2165                         if (file->f_mode & FMODE_WRITE) {
2166                                 stop_dac(s);
2167                                 s->dma_dac.ready = 0;
2168                                 if (val & DSP_BIND_SPDIF) {
2169                                         set_spdifout(s, s->ratedac);
2170                                         set_dac_channels(s, s->fmt & (CM_CFMT_STEREO << CM_CFMT_DACSHIFT) ? 2 : 1);
2171                                         if (!(s->status & DO_SPDIF_OUT))
2172                                                 val &= ~DSP_BIND_SPDIF;
2173                                 } else {
2174                                         int channels;
2175                                         int mask;
2176
2177                                         mask = val & (DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE);
2178                                         switch (mask) {
2179                                             case DSP_BIND_FRONT:
2180                                                 channels = 2;
2181                                                 break;
2182                                             case DSP_BIND_FRONT|DSP_BIND_SURR:
2183                                                 channels = 4;
2184                                                 break;
2185                                             case DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE:
2186                                                 channels = 6;
2187                                                 break;
2188                                             default:
2189                                                 channels = s->fmt & (CM_CFMT_STEREO << CM_CFMT_DACSHIFT) ? 2 : 1;
2190                                                 break;
2191                                         }
2192                                         set_dac_channels(s, channels);
2193                                 }
2194                         }
2195                 }
2196                 return put_user(val, (int *)arg);
2197
2198         case SOUND_PCM_WRITE_FILTER:
2199         case SNDCTL_DSP_MAPINBUF:
2200         case SNDCTL_DSP_MAPOUTBUF:
2201         case SNDCTL_DSP_SETSYNCRO:
2202                 return -EINVAL;
2203
2204         }
2205         return mixer_ioctl(s, cmd, arg);
2206 }
2207
2208 static int cm_open(struct inode *inode, struct file *file)
2209 {
2210         int minor = minor(inode->i_rdev);
2211         struct cm_state *s = devs;
2212         unsigned char fmtm = ~0, fmts = 0;
2213
2214         while (s && ((s->dev_audio ^ minor) & ~0xf))
2215                 s = s->next;
2216         if (!s)
2217                 return -ENODEV;
2218         VALIDATE_STATE(s);
2219         file->private_data = s;
2220         /* wait for device to become free */
2221         down(&s->open_sem);
2222         while (s->open_mode & file->f_mode) {
2223                 if (file->f_flags & O_NONBLOCK) {
2224                         up(&s->open_sem);
2225                         return -EBUSY;
2226                 }
2227                 up(&s->open_sem);
2228                 interruptible_sleep_on(&s->open_wait);
2229                 if (signal_pending(current))
2230                         return -ERESTARTSYS;
2231                 down(&s->open_sem);
2232         }
2233         if (file->f_mode & FMODE_READ) {
2234                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_ADCSHIFT);
2235                 if ((minor & 0xf) == SND_DEV_DSP16)
2236                         fmts |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
2237                 s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
2238                 set_adc_rate(s, 8000);
2239         }
2240         if (file->f_mode & FMODE_WRITE) {
2241                 fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
2242                 if ((minor & 0xf) == SND_DEV_DSP16)
2243                         fmts |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
2244                 s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags = s->dma_dac.subdivision = 0;
2245                 set_dac_rate(s, 8000);
2246                 // clear previous multichannel, spdif, ac3 state
2247                 set_spdifout(s, 0);
2248                 if (s->deviceid == PCI_DEVICE_ID_CMEDIA_CM8738) {
2249                         set_ac3(s, 0);
2250                         set_dac_channels(s, 1);
2251                 }
2252         }
2253         set_fmt(s, fmtm, fmts);
2254         s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2255         up(&s->open_sem);
2256         return 0;
2257 }
2258
2259 static int cm_release(struct inode *inode, struct file *file)
2260 {
2261         struct cm_state *s = (struct cm_state *)file->private_data;
2262
2263         VALIDATE_STATE(s);
2264         lock_kernel();
2265         if (file->f_mode & FMODE_WRITE)
2266                 drain_dac(s, file->f_flags & O_NONBLOCK);
2267         down(&s->open_sem);
2268         if (file->f_mode & FMODE_WRITE) {
2269                 stop_dac(s);
2270
2271                 dealloc_dmabuf(&s->dma_dac);
2272                 if (s->status & DO_DUAL_DAC)
2273                         dealloc_dmabuf(&s->dma_adc);
2274
2275                 if (s->status & DO_MULTI_CH)
2276                         set_dac_channels(s, 0);
2277                 if (s->status & DO_AC3)
2278                         set_ac3(s, 0);
2279                 if (s->status & DO_SPDIF_OUT)
2280                         set_spdifout(s, 0);
2281         }
2282         if (file->f_mode & FMODE_READ) {
2283                 stop_adc(s);
2284                 dealloc_dmabuf(&s->dma_adc);
2285         }
2286         s->open_mode &= ~(file->f_mode & (FMODE_READ|FMODE_WRITE));
2287         up(&s->open_sem);
2288         wake_up(&s->open_wait);
2289         unlock_kernel();
2290         return 0;
2291 }
2292
2293 static /*const*/ struct file_operations cm_audio_fops = {
2294         .owner   = THIS_MODULE,
2295         .llseek  = no_llseek,
2296         .read    = cm_read,
2297         .write   = cm_write,
2298         .poll    = cm_poll,
2299         .ioctl   = cm_ioctl,
2300         .mmap    = cm_mmap,
2301         .open    = cm_open,
2302         .release = cm_release,
2303 };
2304
2305 #ifdef CONFIG_SOUND_CMPCI_MIDI
2306 /* --------------------------------------------------------------------- */
2307
2308 static ssize_t cm_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2309 {
2310         struct cm_state *s = (struct cm_state *)file->private_data;
2311         DECLARE_WAITQUEUE(wait, current);
2312         ssize_t ret;
2313         unsigned long flags;
2314         unsigned ptr;
2315         int cnt;
2316
2317         VALIDATE_STATE(s);
2318         if (ppos != &file->f_pos)
2319                 return -ESPIPE;
2320         if (!access_ok(VERIFY_WRITE, buffer, count))
2321                 return -EFAULT;
2322         ret = 0;
2323         add_wait_queue(&s->midi.iwait, &wait);
2324         while (count > 0) {
2325                 spin_lock_irqsave(&s->lock, flags);
2326                 ptr = s->midi.ird;
2327                 cnt = MIDIINBUF - ptr;
2328                 if (s->midi.icnt < cnt)
2329                         cnt = s->midi.icnt;
2330                 spin_unlock_irqrestore(&s->lock, flags);
2331                 if (cnt > count)
2332                         cnt = count;
2333                 if (cnt <= 0) {
2334                         if (file->f_flags & O_NONBLOCK)
2335                         {
2336                                 if (!ret)
2337                                         ret = -EAGAIN;
2338                                 break;
2339                         }
2340                         __set_current_state(TASK_INTERRUPTIBLE);
2341                         schedule();
2342                         if (signal_pending(current))
2343                         {
2344                                 if (!ret)
2345                                         ret = -ERESTARTSYS;
2346                                 break;
2347                         }
2348                         continue;
2349                 }
2350                 if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt))
2351                 {
2352                         if (!ret)
2353                                 ret = -EFAULT;
2354                         break;
2355                 }
2356                 ptr = (ptr + cnt) % MIDIINBUF;
2357                 spin_lock_irqsave(&s->lock, flags);
2358                 s->midi.ird = ptr;
2359                 s->midi.icnt -= cnt;
2360                 spin_unlock_irqrestore(&s->lock, flags);
2361                 count -= cnt;
2362                 buffer += cnt;
2363                 ret += cnt;
2364                 break;
2365         }
2366         __set_current_state(TASK_RUNNING);
2367         remove_wait_queue(&s->midi.iwait, &wait);
2368         return ret;
2369 }
2370
2371 static ssize_t cm_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2372 {
2373         struct cm_state *s = (struct cm_state *)file->private_data;
2374         DECLARE_WAITQUEUE(wait, current);
2375         ssize_t ret;
2376         unsigned long flags;
2377         unsigned ptr;
2378         int cnt;
2379
2380         VALIDATE_STATE(s);
2381         if (ppos != &file->f_pos)
2382                 return -ESPIPE;
2383         if (!access_ok(VERIFY_READ, buffer, count))
2384                 return -EFAULT;
2385         if (count == 0)
2386                 return 0;
2387         ret = 0;
2388         add_wait_queue(&s->midi.owait, &wait);
2389         while (count > 0) {
2390                 spin_lock_irqsave(&s->lock, flags);
2391                 ptr = s->midi.owr;
2392                 cnt = MIDIOUTBUF - ptr;
2393                 if (s->midi.ocnt + cnt > MIDIOUTBUF)
2394                         cnt = MIDIOUTBUF - s->midi.ocnt;
2395                 if (cnt <= 0)
2396                         cm_handle_midi(s);
2397                 spin_unlock_irqrestore(&s->lock, flags);
2398                 if (cnt > count)
2399                         cnt = count;
2400                 if (cnt <= 0) {
2401                         if (file->f_flags & O_NONBLOCK)
2402                         {
2403                                 if (!ret)
2404                                         ret = -EAGAIN;
2405                                 break;
2406                         }
2407                         __set_current_state(TASK_INTERRUPTIBLE);
2408                         schedule();
2409                         if (signal_pending(current)) {
2410                                 if (!ret)
2411                                         ret = -ERESTARTSYS;
2412                                 break;
2413                         }
2414                         continue;
2415                 }
2416                 if (copy_from_user(s->midi.obuf + ptr, buffer, cnt))
2417                 {
2418                         if (!ret)
2419                                 ret = -EFAULT;
2420                         break;
2421                 }
2422                 ptr = (ptr + cnt) % MIDIOUTBUF;
2423                 spin_lock_irqsave(&s->lock, flags);
2424                 s->midi.owr = ptr;
2425                 s->midi.ocnt += cnt;
2426                 spin_unlock_irqrestore(&s->lock, flags);
2427                 count -= cnt;
2428                 buffer += cnt;
2429                 ret += cnt;
2430                 spin_lock_irqsave(&s->lock, flags);
2431                 cm_handle_midi(s);
2432                 spin_unlock_irqrestore(&s->lock, flags);
2433         }
2434         __set_current_state(TASK_RUNNING);
2435         remove_wait_queue(&s->midi.owait, &wait);
2436         return ret;
2437 }
2438
2439 static unsigned int cm_midi_poll(struct file *file, struct poll_table_struct *wait)
2440 {
2441         struct cm_state *s = (struct cm_state *)file->private_data;
2442         unsigned long flags;
2443         unsigned int mask = 0;
2444
2445         VALIDATE_STATE(s);
2446         if (file->f_mode & FMODE_WRITE)
2447                 poll_wait(file, &s->midi.owait, wait);
2448         if (file->f_mode & FMODE_READ)
2449                 poll_wait(file, &s->midi.iwait, wait);
2450         spin_lock_irqsave(&s->lock, flags);
2451         if (file->f_mode & FMODE_READ) {
2452                 if (s->midi.icnt > 0)
2453                         mask |= POLLIN | POLLRDNORM;
2454         }
2455         if (file->f_mode & FMODE_WRITE) {
2456                 if (s->midi.ocnt < MIDIOUTBUF)
2457                         mask |= POLLOUT | POLLWRNORM;
2458         }
2459         spin_unlock_irqrestore(&s->lock, flags);
2460         return mask;
2461 }
2462
2463 static int cm_midi_open(struct inode *inode, struct file *file)
2464 {
2465         int minor = minor(inode->i_rdev);
2466         struct cm_state *s = devs;
2467         unsigned long flags;
2468
2469         while (s && s->dev_midi != minor)
2470                 s = s->next;
2471         if (!s)
2472                 return -ENODEV;
2473         VALIDATE_STATE(s);
2474         file->private_data = s;
2475         /* wait for device to become free */
2476         down(&s->open_sem);
2477         while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
2478                 if (file->f_flags & O_NONBLOCK) {
2479                         up(&s->open_sem);
2480                         return -EBUSY;
2481                 }
2482                 up(&s->open_sem);
2483                 interruptible_sleep_on(&s->open_wait);
2484                 if (signal_pending(current))
2485                         return -ERESTARTSYS;
2486                 down(&s->open_sem);
2487         }
2488         spin_lock_irqsave(&s->lock, flags);
2489         if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2490                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2491                 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2492                 /* enable MPU-401 */
2493                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 4);
2494                 outb(0xff, s->iomidi+1); /* reset command */
2495                 if (!(inb(s->iomidi+1) & 0x80))
2496                         inb(s->iomidi);
2497                 outb(0x3f, s->iomidi+1); /* uart command */
2498                 if (!(inb(s->iomidi+1) & 0x80))
2499                         inb(s->iomidi);
2500                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2501                 init_timer(&s->midi.timer);
2502                 s->midi.timer.expires = jiffies+1;
2503                 s->midi.timer.data = (unsigned long)s;
2504                 s->midi.timer.function = cm_midi_timer;
2505                 add_timer(&s->midi.timer);
2506         }
2507         if (file->f_mode & FMODE_READ) {
2508                 s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
2509         }
2510         if (file->f_mode & FMODE_WRITE) {
2511                 s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
2512         }
2513         spin_unlock_irqrestore(&s->lock, flags);
2514         s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
2515         up(&s->open_sem);
2516         return 0;
2517 }
2518
2519 static int cm_midi_release(struct inode *inode, struct file *file)
2520 {
2521         struct cm_state *s = (struct cm_state *)file->private_data;
2522         DECLARE_WAITQUEUE(wait, current);
2523         unsigned long flags;
2524         unsigned count, tmo;
2525
2526         VALIDATE_STATE(s);
2527         lock_kernel();
2528
2529         if (file->f_mode & FMODE_WRITE) {
2530                 __set_current_state(TASK_INTERRUPTIBLE);
2531                 add_wait_queue(&s->midi.owait, &wait);
2532                 for (;;) {
2533                         spin_lock_irqsave(&s->lock, flags);
2534                         count = s->midi.ocnt;
2535                         spin_unlock_irqrestore(&s->lock, flags);
2536                         if (count <= 0)
2537                                 break;
2538                         if (signal_pending(current))
2539                                 break;
2540                         if (file->f_flags & O_NONBLOCK) {
2541                                 remove_wait_queue(&s->midi.owait, &wait);
2542                                 set_current_state(TASK_RUNNING);
2543                                 unlock_kernel();
2544                                 return -EBUSY;
2545                         }
2546                         tmo = (count * HZ) / 3100;
2547                         if (!schedule_timeout(tmo ? : 1) && tmo)
2548                                 printk(KERN_DEBUG "cmpci: midi timed out??\n");
2549                 }
2550                 remove_wait_queue(&s->midi.owait, &wait);
2551                 set_current_state(TASK_RUNNING);
2552         }
2553         down(&s->open_sem);
2554         s->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE));
2555         spin_lock_irqsave(&s->lock, flags);
2556         if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
2557                 del_timer(&s->midi.timer);
2558                 outb(0xff, s->iomidi+1); /* reset command */
2559                 if (!(inb(s->iomidi+1) & 0x80))
2560                         inb(s->iomidi);
2561                 /* disable MPU-401 */
2562                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~4, 0);
2563         }
2564         spin_unlock_irqrestore(&s->lock, flags);
2565         up(&s->open_sem);
2566         wake_up(&s->open_wait);
2567         unlock_kernel();
2568         return 0;
2569 }
2570
2571 static /*const*/ struct file_operations cm_midi_fops = {
2572         .owner   = THIS_MODULE,
2573         .llseek  = no_llseek,
2574         .read    = cm_midi_read,
2575         .write   = cm_midi_write,
2576         .poll    = cm_midi_poll,
2577         .open    = cm_midi_open,
2578         .release = cm_midi_release,
2579 };
2580 #endif
2581
2582 /* --------------------------------------------------------------------- */
2583
2584 #ifdef CONFIG_SOUND_CMPCI_FM
2585 static int cm_dmfm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2586 {
2587         static const unsigned char op_offset[18] = {
2588                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
2589                 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
2590                 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
2591         };
2592         struct cm_state *s = (struct cm_state *)file->private_data;
2593         struct dm_fm_voice v;
2594         struct dm_fm_note n;
2595         struct dm_fm_params p;
2596         unsigned int io;
2597         unsigned int regb;
2598
2599         switch (cmd) {
2600         case FM_IOCTL_RESET:
2601                 for (regb = 0xb0; regb < 0xb9; regb++) {
2602                         outb(regb, s->iosynth);
2603                         outb(0, s->iosynth+1);
2604                         outb(regb, s->iosynth+2);
2605                         outb(0, s->iosynth+3);
2606                 }
2607                 return 0;
2608
2609         case FM_IOCTL_PLAY_NOTE:
2610                 if (copy_from_user(&n, (void *)arg, sizeof(n)))
2611                         return -EFAULT;
2612                 if (n.voice >= 18)
2613                         return -EINVAL;
2614                 if (n.voice >= 9) {
2615                         regb = n.voice - 9;
2616                         io = s->iosynth+2;
2617                 } else {
2618                         regb = n.voice;
2619                         io = s->iosynth;
2620                 }
2621                 outb(0xa0 + regb, io);
2622                 outb(n.fnum & 0xff, io+1);
2623                 outb(0xb0 + regb, io);
2624                 outb(((n.fnum >> 8) & 3) | ((n.octave & 7) << 2) | ((n.key_on & 1) << 5), io+1);
2625                 return 0;
2626
2627         case FM_IOCTL_SET_VOICE:
2628                 if (copy_from_user(&v, (void *)arg, sizeof(v)))
2629                         return -EFAULT;
2630                 if (v.voice >= 18)
2631                         return -EINVAL;
2632                 regb = op_offset[v.voice];
2633                 io = s->iosynth + ((v.op & 1) << 1);
2634                 outb(0x20 + regb, io);
2635                 outb(((v.am & 1) << 7) | ((v.vibrato & 1) << 6) | ((v.do_sustain & 1) << 5) |
2636                      ((v.kbd_scale & 1) << 4) | (v.harmonic & 0xf), io+1);
2637                 outb(0x40 + regb, io);
2638                 outb(((v.scale_level & 0x3) << 6) | (v.volume & 0x3f), io+1);
2639                 outb(0x60 + regb, io);
2640                 outb(((v.attack & 0xf) << 4) | (v.decay & 0xf), io+1);
2641                 outb(0x80 + regb, io);
2642                 outb(((v.sustain & 0xf) << 4) | (v.release & 0xf), io+1);
2643                 outb(0xe0 + regb, io);
2644                 outb(v.waveform & 0x7, io+1);
2645                 if (n.voice >= 9) {
2646                         regb = n.voice - 9;
2647                         io = s->iosynth+2;
2648                 } else {
2649                         regb = n.voice;
2650                         io = s->iosynth;
2651                 }
2652                 outb(0xc0 + regb, io);
2653                 outb(((v.right & 1) << 5) | ((v.left & 1) << 4) | ((v.feedback & 7) << 1) |
2654                      (v.connection & 1), io+1);
2655                 return 0;
2656
2657         case FM_IOCTL_SET_PARAMS:
2658                 if (copy_from_user(&p, (void *)arg, sizeof(p)))
2659                         return -EFAULT;
2660                 outb(0x08, s->iosynth);
2661                 outb((p.kbd_split & 1) << 6, s->iosynth+1);
2662                 outb(0xbd, s->iosynth);
2663                 outb(((p.am_depth & 1) << 7) | ((p.vib_depth & 1) << 6) | ((p.rhythm & 1) << 5) | ((p.bass & 1) << 4) |
2664                      ((p.snare & 1) << 3) | ((p.tomtom & 1) << 2) | ((p.cymbal & 1) << 1) | (p.hihat & 1), s->iosynth+1);
2665                 return 0;
2666
2667         case FM_IOCTL_SET_OPL:
2668                 outb(4, s->iosynth+2);
2669                 outb(arg, s->iosynth+3);
2670                 return 0;
2671
2672         case FM_IOCTL_SET_MODE:
2673                 outb(5, s->iosynth+2);
2674                 outb(arg & 1, s->iosynth+3);
2675                 return 0;
2676         }
2677         return -EINVAL;
2678 }
2679
2680 static int cm_dmfm_open(struct inode *inode, struct file *file)
2681 {
2682         int minor = minor(inode->i_rdev);
2683         struct cm_state *s = devs;
2684
2685         while (s && s->dev_dmfm != minor)
2686                 s = s->next;
2687         if (!s)
2688                 return -ENODEV;
2689         VALIDATE_STATE(s);
2690         file->private_data = s;
2691         /* wait for device to become free */
2692         down(&s->open_sem);
2693         while (s->open_mode & FMODE_DMFM) {
2694                 if (file->f_flags & O_NONBLOCK) {
2695                         up(&s->open_sem);
2696                         return -EBUSY;
2697                 }
2698                 up(&s->open_sem);
2699                 interruptible_sleep_on(&s->open_wait);
2700                 if (signal_pending(current))
2701                         return -ERESTARTSYS;
2702                 down(&s->open_sem);
2703         }
2704         /* init the stuff */
2705         outb(1, s->iosynth);
2706         outb(0x20, s->iosynth+1); /* enable waveforms */
2707         outb(4, s->iosynth+2);
2708         outb(0, s->iosynth+3);  /* no 4op enabled */
2709         outb(5, s->iosynth+2);
2710         outb(1, s->iosynth+3);  /* enable OPL3 */
2711         s->open_mode |= FMODE_DMFM;
2712         up(&s->open_sem);
2713         return 0;
2714 }
2715
2716 static int cm_dmfm_release(struct inode *inode, struct file *file)
2717 {
2718         struct cm_state *s = (struct cm_state *)file->private_data;
2719         unsigned int regb;
2720
2721         VALIDATE_STATE(s);
2722         lock_kernel();
2723         down(&s->open_sem);
2724         s->open_mode &= ~FMODE_DMFM;
2725         for (regb = 0xb0; regb < 0xb9; regb++) {
2726                 outb(regb, s->iosynth);
2727                 outb(0, s->iosynth+1);
2728                 outb(regb, s->iosynth+2);
2729                 outb(0, s->iosynth+3);
2730         }
2731         up(&s->open_sem);
2732         wake_up(&s->open_wait);
2733         unlock_kernel();
2734         return 0;
2735 }
2736
2737 static /*const*/ struct file_operations cm_dmfm_fops = {
2738         .owner   = THIS_MODULE,
2739         .llseek  = no_llseek,
2740         .ioctl   = cm_dmfm_ioctl,
2741         .open    = cm_dmfm_open,
2742         .release = cm_dmfm_release,
2743 };
2744 #endif /* CONFIG_SOUND_CMPCI_FM */
2745
2746
2747
2748 static struct initvol {
2749         int mixch;
2750         int vol;
2751 } initvol[] __initdata = {
2752         { SOUND_MIXER_WRITE_CD, 0x4f4f },
2753         { SOUND_MIXER_WRITE_LINE, 0x4f4f },
2754         { SOUND_MIXER_WRITE_MIC, 0x4f4f },
2755         { SOUND_MIXER_WRITE_SYNTH, 0x4f4f },
2756         { SOUND_MIXER_WRITE_VOLUME, 0x4f4f },
2757         { SOUND_MIXER_WRITE_PCM, 0x4f4f }
2758 };
2759
2760 /* check chip version and capability */
2761 static int query_chip(struct cm_state *s)
2762 {
2763         int ChipVersion = -1;
2764         unsigned char RegValue;
2765
2766         // check reg 0Ch, bit 24-31
2767         RegValue = inb(s->iobase + CODEC_CMI_INT_HLDCLR + 3);
2768         if (RegValue == 0) {
2769             // check reg 08h, bit 24-28
2770             RegValue = inb(s->iobase + CODEC_CMI_CHFORMAT + 3);
2771             RegValue &= 0x1f;
2772             if (RegValue == 0) {
2773                 ChipVersion = 33;
2774                 s->max_channels = 4;
2775                 s->capability |= CAN_AC3_SW;
2776                 s->capability |= CAN_DUAL_DAC;
2777             } else {
2778                 ChipVersion = 37;
2779                 s->max_channels = 4;
2780                 s->capability |= CAN_AC3_HW;
2781                 s->capability |= CAN_DUAL_DAC;
2782             }
2783         } else {
2784             // check reg 0Ch, bit 26
2785             if (RegValue & (1 << (26-24))) {
2786                 ChipVersion = 39;
2787                 if (RegValue & (1 << (24-24)))
2788                     s->max_channels  = 6;
2789                 else
2790                     s->max_channels = 4;
2791                 s->capability |= CAN_AC3_HW;
2792                 s->capability |= CAN_DUAL_DAC;
2793                 s->capability |= CAN_MULTI_CH_HW;
2794             } else {
2795                 ChipVersion = 55; // 4 or 6 channels
2796                 s->max_channels  = 6;
2797                 s->capability |= CAN_AC3_HW;
2798                 s->capability |= CAN_DUAL_DAC;
2799                 s->capability |= CAN_MULTI_CH_HW;
2800             }
2801         }
2802         // still limited to number of speakers
2803         if (s->max_channels > s->speakers)
2804                 s->max_channels = s->speakers;
2805         return ChipVersion;
2806 }
2807
2808 #ifdef CONFIG_SOUND_CMPCI_MIDI
2809 static  int     mpuio = CONFIG_SOUND_CMPCI_MPUIO;
2810 #else
2811 static  int     mpuio;
2812 #endif
2813 #ifdef CONFIG_SOUND_CMPCI_FM
2814 static  int     fmio = CONFIG_SOUND_CMPCI_FMIO;
2815 #else
2816 static  int     fmio;
2817 #endif
2818 #ifdef CONFIG_SOUND_CMPCI_SPDIFINVERSE
2819 static  int     spdif_inverse = 1;
2820 #else
2821 static  int     spdif_inverse;
2822 #endif
2823 #ifdef CONFIG_SOUND_CMPCI_SPDIFLOOP
2824 static  int     spdif_loop = 1;
2825 #else
2826 static  int     spdif_loop;
2827 #endif
2828 #ifdef CONFIG_SOUND_CMPCI_SPEAKERS
2829 static  int     speakers = CONFIG_SOUND_CMPCI_SPEAKERS;
2830 #else
2831 static  int     speakers = 2;
2832 #endif
2833 #ifdef CONFIG_SOUND_CMPCI_LINE_REAR
2834 static  int     use_line_as_rear = 1;
2835 #else
2836 static  int     use_line_as_rear;
2837 #endif
2838 #ifdef CONFIG_SOUND_CMPCI_LINE_BASS
2839 static  int     use_line_as_bass = 1;
2840 #else
2841 static  int     use_line_as_bass;
2842 #endif
2843 #ifdef CONFIG_SOUND_CMPCI_JOYSTICK
2844 static  int     joystick = 1;
2845 #else
2846 static  int     joystick;
2847 #endif
2848 MODULE_PARM(mpuio, "i");
2849 MODULE_PARM(fmio, "i");
2850 MODULE_PARM(spdif_inverse, "i");
2851 MODULE_PARM(spdif_loop, "i");
2852 MODULE_PARM(speakers, "i");
2853 MODULE_PARM(use_line_as_rear, "i");
2854 MODULE_PARM(use_line_as_bass, "i");
2855 MODULE_PARM(joystick, "i");
2856 MODULE_PARM_DESC(mpuio, "(0x330, 0x320, 0x310, 0x300) Base of MPU-401, 0 to disable");
2857 MODULE_PARM_DESC(fmio, "(0x388, 0x3C8, 0x3E0) Base of OPL3, 0 to disable");
2858 MODULE_PARM_DESC(spdif_inverse, "(1/0) Invert S/PDIF-in signal");
2859 MODULE_PARM_DESC(spdif_loop, "(1/0) Route S/PDIF-in to S/PDIF-out directly");
2860 MODULE_PARM_DESC(speakers, "(2-6) Number of speakers you connect");
2861 MODULE_PARM_DESC(use_line_as_rear, "(1/0) Use line-in jack as rear-out");
2862 MODULE_PARM_DESC(use_line_as_bass, "(1/0) Use line-in jack as bass/center");
2863 MODULE_PARM_DESC(joystick, "(1/0) Enable joystick interface, still need joystick driver");
2864
2865 static struct pci_device_id cmpci_pci_tbl[] = {
2866         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738,
2867           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2868         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A,
2869           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2870         { PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B,
2871           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2872         { 0 }
2873 };
2874 MODULE_DEVICE_TABLE(pci, cmpci_pci_tbl);
2875
2876 void initialize_chip(struct pci_dev *pcidev)
2877 {
2878         struct cm_state *s;
2879         mm_segment_t fs;
2880         int i, val;
2881 #if defined(CONFIG_SOUND_CMPCI_MIDI) || defined(CONFIG_SOUND_CMPCI_FM)
2882         unsigned char reg_mask = 0;
2883 #endif
2884         struct {
2885                 unsigned short  deviceid;
2886                 char            *devicename;
2887         } devicetable[] =
2888         {
2889                 { PCI_DEVICE_ID_CMEDIA_CM8338A, "CM8338A" },
2890                 { PCI_DEVICE_ID_CMEDIA_CM8338B, "CM8338B" },
2891                 { PCI_DEVICE_ID_CMEDIA_CM8738,  "CM8738" },
2892                 { PCI_DEVICE_ID_CMEDIA_CM8738B, "CM8738B" },
2893         };
2894         char    *devicename = "unknown";
2895         {
2896                 if (pci_enable_device(pcidev))
2897                         return;
2898                 if (pcidev->irq == 0)
2899                         return;
2900                 s = kmalloc(sizeof(*s), GFP_KERNEL);
2901                 if (!s) {
2902                         printk(KERN_WARNING "cmpci: out of memory\n");
2903                         return;
2904                 }
2905                 /* search device name */
2906                 for (i = 0; i < sizeof(devicetable) / sizeof(devicetable[0]); i++) {
2907                         if (devicetable[i].deviceid == pcidev->device)
2908                         {
2909                                 devicename = devicetable[i].devicename;
2910                                 break;
2911                         }
2912                 }
2913                 memset(s, 0, sizeof(struct cm_state));
2914                 init_waitqueue_head(&s->dma_adc.wait);
2915                 init_waitqueue_head(&s->dma_dac.wait);
2916                 init_waitqueue_head(&s->open_wait);
2917                 init_waitqueue_head(&s->midi.iwait);
2918                 init_waitqueue_head(&s->midi.owait);
2919                 init_MUTEX(&s->open_sem);
2920                 spin_lock_init(&s->lock);
2921                 s->magic = CM_MAGIC;
2922                 s->iobase = pci_resource_start(pcidev, 0);
2923                 s->iosynth = fmio;
2924                 s->iomidi = mpuio;
2925                 s->status = 0;
2926                 /* range check */
2927                 if (speakers < 2)
2928                         speakers = 2;
2929                 else if (speakers > 6)
2930                         speakers = 6;
2931                 s->speakers = speakers;
2932                 if (s->iobase == 0)
2933                         return;
2934                 s->irq = pcidev->irq;
2935
2936                 if (!request_region(s->iobase, CM_EXTENT_CODEC, "cmpci")) {
2937                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iobase, s->iobase+CM_EXTENT_CODEC-1);
2938                         goto err_region5;
2939                 }
2940 #ifdef CONFIG_SOUND_CMPCI_MIDI
2941                 /* disable MPU-401 */
2942                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x04, 0);
2943                 if (s->iomidi) {
2944                     if (!request_region(s->iomidi, CM_EXTENT_MIDI, "cmpci Midi")) {
2945                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iomidi, s->iomidi+CM_EXTENT_MIDI-1);
2946                         s->iomidi = 0;
2947                     } else {
2948                         /* set IO based at 0x330 */
2949                         switch (s->iomidi) {
2950                             case 0x330:
2951                                 reg_mask = 0;
2952                                 break;
2953                             case 0x320:
2954                                 reg_mask = 0x20;
2955                                 break;
2956                             case 0x310:
2957                                 reg_mask = 0x40;
2958                                 break;
2959                             case 0x300:
2960                                 reg_mask = 0x60;
2961                                 break;
2962                             default:
2963                                 s->iomidi = 0;
2964                                 break;
2965                         }
2966                         outb((inb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3) & ~0x60) | reg_mask, s->iobase + CODEC_CMI_LEGACY_CTRL + 3);
2967                         /* enable MPU-401 */
2968                         if (s->iomidi) {
2969                             maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x04);
2970                         }
2971                     }
2972                 }
2973 #endif
2974 #ifdef CONFIG_SOUND_CMPCI_FM
2975                 /* disable FM */
2976                 maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~8, 0);
2977                 if (s->iosynth) {
2978                     if (!request_region(s->iosynth, CM_EXTENT_SYNTH, "cmpci FM")) {
2979                         printk(KERN_ERR "cmpci: io ports %#x-%#x in use\n", s->iosynth, s->iosynth+CM_EXTENT_SYNTH-1);
2980                         s->iosynth = 0;
2981                     } else {
2982                         /* set IO based at 0x388 */
2983                         switch (s->iosynth) {
2984                             case 0x388:
2985                                 reg_mask = 0;
2986                                 break;
2987                             case 0x3C8:
2988                                 reg_mask = 0x01;
2989                                 break;
2990                             case 0x3E0:
2991                                 reg_mask = 0x02;
2992                                 break;
2993                             case 0x3E8:
2994                                 reg_mask = 0x03;
2995                                 break;
2996                             default:
2997                                 s->iosynth = 0;
2998                                 break;
2999                         }
3000                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3, ~0x03, reg_mask);
3001                         /* enable FM */
3002                         if (s->iosynth) {
3003                             maskb(s->iobase + CODEC_CMI_MISC_CTRL + 2, ~0, 8);
3004                         }
3005                     }
3006                 }
3007 #endif
3008                 /* enable joystick */
3009                 if (joystick)
3010                         maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x02);
3011                 else
3012                         maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x02, 0);
3013                 /* initialize codec registers */
3014                 outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
3015                 outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
3016                 /* reset mixer */
3017                 wrmixer(s, DSP_MIX_DATARESETIDX, 0);
3018
3019                 /* request irq */
3020                 if (request_irq(s->irq, cm_interrupt, SA_SHIRQ, "cmpci", s)) {
3021                         printk(KERN_ERR "cmpci: irq %u in use\n", s->irq);
3022                         goto err_irq;
3023                 }
3024                 printk(KERN_INFO "cmpci: found %s adapter at io %#06x irq %u\n",
3025                        devicename, s->iobase, s->irq);
3026                 /* register devices */
3027                 if ((s->dev_audio = register_sound_dsp(&cm_audio_fops, -1)) < 0)
3028                         goto err_dev1;
3029                 if ((s->dev_mixer = register_sound_mixer(&cm_mixer_fops, -1)) < 0)
3030                         goto err_dev2;
3031 #ifdef CONFIG_SOUND_CMPCI_MIDI
3032                 if ((s->dev_midi = register_sound_midi(&cm_midi_fops, -1)) < 0)
3033                         goto err_dev3;
3034 #endif
3035 #ifdef CONFIG_SOUND_CMPCI_FM
3036                 if ((s->dev_dmfm = register_sound_special(&cm_dmfm_fops, 15 /* ?? */)) < 0)
3037                         goto err_dev4;
3038 #endif
3039                 pci_set_master(pcidev); /* enable bus mastering */
3040                 /* initialize the chips */
3041                 fs = get_fs();
3042                 set_fs(KERNEL_DS);
3043                 /* set mixer output */
3044                 frobindir(s, DSP_MIX_OUTMIXIDX, 0x1f, 0x1f);
3045                 /* set mixer input */
3046                 val = SOUND_MASK_LINE|SOUND_MASK_SYNTH|SOUND_MASK_CD|SOUND_MASK_MIC;
3047                 mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
3048                 for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
3049                         val = initvol[i].vol;
3050                         mixer_ioctl(s, initvol[i].mixch, (unsigned long)&val);
3051                 }
3052                 /* use channel 0 for record, channel 1 for play */
3053                 maskb(s->iobase + CODEC_CMI_FUNCTRL0, ~2, 1);
3054                 s->deviceid = pcidev->device;
3055
3056                 if (pcidev->device == PCI_DEVICE_ID_CMEDIA_CM8738) {
3057
3058                         /* chip version and hw capability check */
3059                         s->chip_version = query_chip(s);
3060                         printk(KERN_INFO "cmpci: chip version = 0%d\n", s->chip_version);
3061
3062                         /* seet SPDIF-in inverse before enable SPDIF loop */
3063                         if (spdif_inverse) {
3064                                 /* turn on spdif-in inverse */
3065                                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~0, 1);
3066                                 printk(KERN_INFO "cmpci: Inverse SPDIF-in\n");
3067                         } else {
3068                                 /* turn off spdif-ininverse */
3069                                 maskb(s->iobase + CODEC_CMI_CHFORMAT + 2, ~1, 0);
3070                         }
3071
3072                         /* enable SPDIF loop */
3073                         if (spdif_loop) {
3074                                 s->status |= DO_SPDIF_LOOP;
3075                                 /* turn on spdif-in to spdif-out */
3076                                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0, 0x80);
3077                                 printk(KERN_INFO "cmpci: Enable SPDIF loop\n");
3078                         } else {
3079                                 s->status &= ~DO_SPDIF_LOOP;
3080                                 /* turn off spdif-in to spdif-out */
3081                                 maskb(s->iobase + CODEC_CMI_FUNCTRL1, ~0x80, 0);
3082                         }
3083                         if (use_line_as_rear) {
3084                                 s->capability |= CAN_LINE_AS_REAR;
3085                                 s->status |= DO_LINE_AS_REAR;
3086                                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0, 0x20);
3087                         } else
3088                                 maskb(s->iobase + CODEC_CMI_MIXER1, ~0x20, 0);
3089                         if (s->chip_version >= 39) {
3090                                 if (use_line_as_bass) {
3091                                         s->capability |= CAN_LINE_AS_BASS;
3092                                         s->status |= DO_LINE_AS_BASS;
3093                                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0, 0x60);
3094                                 } else
3095                                         maskb(s->iobase + CODEC_CMI_LEGACY_CTRL + 1, ~0x60, 0);
3096                         }
3097                 } else {
3098                         /* 8338 will fall here */
3099                         s->max_channels = 2;
3100                 }
3101                 /* queue it for later freeing */
3102                 s->next = devs;
3103                 devs = s;
3104                 return;
3105
3106 #ifdef CONFIG_SOUND_CMPCI_FM
3107                 unregister_sound_special(s->dev_dmfm);
3108         err_dev4:
3109 #endif
3110 #ifdef CONFIG_SOUND_CMPCI_MIDI
3111                 unregister_sound_midi(s->dev_midi);
3112         err_dev3:
3113 #endif
3114                 unregister_sound_mixer(s->dev_mixer);
3115         err_dev2:
3116                 unregister_sound_dsp(s->dev_audio);
3117         err_dev1:
3118                 printk(KERN_ERR "cmpci: cannot register misc device\n");
3119                 free_irq(s->irq, s);
3120         err_irq:
3121 #ifdef CONFIG_SOUND_CMPCI_FM
3122                 if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
3123 #endif
3124 #ifdef CONFIG_SOUND_CMPCI_MIDI
3125                 if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
3126 #endif
3127                 release_region(s->iobase, CM_EXTENT_CODEC);
3128         err_region5:
3129                 kfree(s);
3130         }
3131         if (!devs) {
3132                 if (wavetable_mem)
3133                         free_pages(wavetable_mem, 20-PAGE_SHIFT);
3134                 return;
3135         }
3136         return;
3137 }
3138
3139 static int __init init_cmpci(void)
3140 {
3141         struct pci_dev *pcidev = NULL;
3142         int index = 0;
3143
3144         printk(KERN_INFO "cmpci: version $Revision: 5.64 $ time " __TIME__ " " __DATE__ "\n");
3145
3146         while (index < NR_DEVICE && (
3147                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738, pcidev)))) {
3148                 initialize_chip(pcidev);
3149                 index++;
3150         }
3151         while (index < NR_DEVICE && (
3152                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A, pcidev)))) {
3153                 initialize_chip(pcidev);
3154                 index++;
3155         }
3156         while (index < NR_DEVICE && (
3157                (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B, pcidev)))) {
3158                 initialize_chip(pcidev);
3159                 index++;
3160         }
3161         return 0;
3162 }
3163
3164 /* --------------------------------------------------------------------- */
3165
3166 MODULE_AUTHOR("ChenLi Tien, cltien@cmedia.com.tw");
3167 MODULE_DESCRIPTION("CM8x38 Audio Driver");
3168 MODULE_LICENSE("GPL");
3169
3170
3171 static void __exit cleanup_cmpci(void)
3172 {
3173         struct cm_state *s;
3174
3175         while ((s = devs)) {
3176                 devs = devs->next;
3177                 outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
3178                 synchronize_irq(s->irq);
3179                 outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
3180                 free_irq(s->irq, s);
3181
3182                 /* reset mixer */
3183                 wrmixer(s, DSP_MIX_DATARESETIDX, 0);
3184
3185                 release_region(s->iobase, CM_EXTENT_CODEC);
3186 #ifdef CONFIG_SOUND_CMPCI_MIDI
3187                 if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
3188 #endif
3189 #ifdef CONFIG_SOUND_CMPCI_FM
3190                 if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
3191 #endif
3192                 unregister_sound_dsp(s->dev_audio);
3193                 unregister_sound_mixer(s->dev_mixer);
3194 #ifdef CONFIG_SOUND_CMPCI_MIDI
3195                 unregister_sound_midi(s->dev_midi);
3196 #endif
3197 #ifdef CONFIG_SOUND_CMPCI_FM
3198                 unregister_sound_special(s->dev_dmfm);
3199 #endif
3200                 kfree(s);
3201         }
3202         if (wavetable_mem)
3203                 free_pages(wavetable_mem, 20-PAGE_SHIFT);
3204         printk(KERN_INFO "cmpci: unloading\n");
3205 }
3206
3207 module_init(init_cmpci);
3208 module_exit(cleanup_cmpci);