超级蓝果科技

《生死狙击2》这个游戏很好玩。

Wed, 20 Mar 2024 10:40:16 +0800

生死狙击2是一个联网对战的战场式的枪战游戏。可以组队行动。

进入大厅的时候是这样子的。

Linux下通用声卡驱动源码。（CM8738,CM2000,TE-734,Crystal系列）

Mon, 04 Mar 2024 11:42:08 +0800

Linux 下的通用声卡驱动源码：

/*****************************************************************************/

/*
 *      cmpci.c  --  C-Media PCI audio driver.
 *
 *      Copyright (C) 1999  ChenLi Tien (cltien@home.com)
 *      		    C-media support (support@cmedia.com.tw)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Special thanks to David C. Niemi, Jan Pfeifer
 *
 *
 * Module command line parameters:
 *   none so far
 *
 *
 *  Supported devices:
 *  /dev/dsp    standard /dev/dsp device, (mostly) OSS compatible
 *  /dev/mixer  standard /dev/mixer device, (mostly) OSS compatible
 *  /dev/midi   simple MIDI UART interface, no ioctl
 *
 *  The card has both an FM and a Wavetable synth, but I have to figure
 *  out first how to drive them...
 *
 *  Revision history
 *    06.05.98   0.1   Initial release
 *    10.05.98   0.2   Fixed many bugs, esp. ADC rate calculation
 *                     First stab at a simple midi interface (no bells&whistles)
 *    13.05.98   0.3   Fix stupid cut&paste error: set_adc_rate was called instead of
 *                     set_dac_rate in the FMODE_WRITE case in cm_open
 *                     Fix hwptr out of bounds (now mpg123 works)
 *    14.05.98   0.4   Don't allow excessive interrupt rates
 *    08.06.98   0.5   First release using Alan Cox' soundcore instead of miscdevice
 *    03.08.98   0.6   Do not include modversions.h
 *                     Now mixer behaviour can basically be selected between
 *                     "OSS documented" and "OSS actual" behaviour
 *    31.08.98   0.7   Fix realplayer problems - dac.count issues
 *    10.12.98   0.8   Fix drain_dac trying to wait on not yet initialized DMA
 *    16.12.98   0.9   Fix a few f_file & FMODE_ bugs
 *    06.01.99   0.10  remove the silly SA_INTERRUPT flag.
 *                     hopefully killed the egcs section type conflict
 *    12.03.99   0.11  cinfo.blocks should be reset after GETxPTR ioctl.
 *                     reported by Johan Maes <joma@telindus.be>
 *    22.03.99   0.12  return EAGAIN instead of EBUSY when O_NONBLOCK
 *                     read/write cannot be executed
 *    18.08.99   1.5   Only deallocate DMA buffer when unloading.
 *    02.09.99   1.6   Enable SPDIF LOOP
 *                     Change the mixer read back
 *    21.09.99   2.33  Use RCS version as driver version.
 *                     Add support for modem, S/PDIF loop and 4 channels.
 *                     (8738 only)
 *                     Fix bug cause x11amp cannot play.
 *
 */

/*****************************************************************************/
      
#define EXPORT_SYMTAB
#include <linux/version.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/sound.h>
#include <linux/malloc.h>
#include <linux/soundcard.h>
#include <linux/pci.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/init.h>
#include <linux/poll.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
#include <linux/spinlock.h>
#else
#include <asm/spinlock.h>
#endif
#include <asm/uaccess.h>
#include <asm/hardirq.h>

#include "dm.h"

/* --------------------------------------------------------------------- */

#undef OSS_DOCUMENTED_MIXER_SEMANTICS

/* --------------------------------------------------------------------- */

#ifndef PCI_VENDOR_ID_CMEDIA
#define PCI_VENDOR_ID_CMEDIA         0x13F6
#endif
#ifndef PCI_DEVICE_ID_CMEDIA_CM8338A
#define PCI_DEVICE_ID_CMEDIA_CM8338A 0x0100
#endif
#ifndef PCI_DEVICE_ID_CMEDIA_CM8338B
#define PCI_DEVICE_ID_CMEDIA_CM8338B 0x0101
#endif
#ifndef PCI_DEVICE_ID_CMEDIA_CM8738
#define PCI_DEVICE_ID_CMEDIA_CM8738  0x0111
#endif
#ifndef PCI_DEVICE_ID_CMEDIA_CM8738B
#define PCI_DEVICE_ID_CMEDIA_CM8738B 0x0112
#endif

#define CM_MAGIC  ((PCI_VENDOR_ID_CMEDIA<<16)|PCI_DEVICE_ID_CMEDIA_CM8338A)

/*
 * CM8338 registers definition
 */

#define CODEC_CMI_FUNCTRL0      (0x00)
#define CODEC_CMI_FUNCTRL1      (0x04)
#define CODEC_CMI_CHFORMAT      (0x08)
#define CODEC_CMI_INT_HLDCLR    (0x0C)
#define CODEC_CMI_INT_STATUS    (0x10)
#define CODEC_CMI_LEGACY_CTRL   (0x14)
#define CODEC_CMI_MISC_CTRL     (0x18)
#define CODEC_CMI_TDMA_POS      (0x1C)
#define CODEC_CMI_MIXER         (0x20)
#define CODEC_SB16_DATA         (0x22)
#define CODEC_SB16_ADDR         (0x23)
#define CODEC_CMI_MIXER1        (0x24)
#define CODEC_CMI_MIXER2        (0x25)
#define CODEC_CMI_AUX_VOL       (0x26)
#define CODEC_CMI_MISC          (0x27)
#define CODEC_CMI_AC97          (0x28)

#define CODEC_CMI_CH0_FRAME1    (0x80)
#define CODEC_CMI_CH0_FRAME2    (0x84)
#define CODEC_CMI_CH1_FRAME1    (0x88)
#define CODEC_CMI_CH1_FRAME2    (0x8C)

#define CODEC_CMI_EXT_REG       (0xF0)
#define UCHAR	unsigned char
/*
**  Mixer registers for SB16
*/

#define DSP_MIX_DATARESETIDX    ((UCHAR)(0x00))

#define DSP_MIX_MASTERVOLIDX_L  ((UCHAR)(0x30))
#define DSP_MIX_MASTERVOLIDX_R  ((UCHAR)(0x31))
#define DSP_MIX_VOICEVOLIDX_L   ((UCHAR)(0x32))
#define DSP_MIX_VOICEVOLIDX_R   ((UCHAR)(0x33))
#define DSP_MIX_FMVOLIDX_L      ((UCHAR)(0x34))
#define DSP_MIX_FMVOLIDX_R      ((UCHAR)(0x35))
#define DSP_MIX_CDVOLIDX_L      ((UCHAR)(0x36))
#define DSP_MIX_CDVOLIDX_R      ((UCHAR)(0x37))
#define DSP_MIX_LINEVOLIDX_L    ((UCHAR)(0x38))
#define DSP_MIX_LINEVOLIDX_R    ((UCHAR)(0x39))

#define DSP_MIX_MICVOLIDX       ((UCHAR)(0x3A))
#define DSP_MIX_SPKRVOLIDX      ((UCHAR)(0x3B))

#define DSP_MIX_OUTMIXIDX       ((UCHAR)(0x3C))

#define DSP_MIX_ADCMIXIDX_L     ((UCHAR)(0x3D))
#define DSP_MIX_ADCMIXIDX_R     ((UCHAR)(0x3E))

#define DSP_MIX_INGAINIDX_L     ((UCHAR)(0x3F))
#define DSP_MIX_INGAINIDX_R     ((UCHAR)(0x40))
#define DSP_MIX_OUTGAINIDX_L    ((UCHAR)(0x41))
#define DSP_MIX_OUTGAINIDX_R    ((UCHAR)(0x42))

#define DSP_MIX_AGCIDX          ((UCHAR)(0x43))

#define DSP_MIX_TREBLEIDX_L     ((UCHAR)(0x44))
#define DSP_MIX_TREBLEIDX_R     ((UCHAR)(0x45))
#define DSP_MIX_BASSIDX_L       ((UCHAR)(0x46))
#define DSP_MIX_BASSIDX_R       ((UCHAR)(0x47))
#define CM_CH0_RESET	  0x04
#define CM_CH1_RESET	  0x08
#define CM_EXTENT_CODEC	  0x100
#define CM_EXTENT_MIDI	  0x2
#define CM_EXTENT_SYNTH	  0x4
#define CM_INT_CH0	  1
#define CM_INT_CH1	  2

#define CM_CFMT_STEREO     0x01
#define CM_CFMT_16BIT      0x02
#define CM_CFMT_MASK       0x03
#define CM_CFMT_DACSHIFT   0   
#define CM_CFMT_ADCSHIFT   2

static const unsigned sample_size[] = { 1, 2, 2, 4 };
static const unsigned sample_shift[] = { 0, 1, 1, 2 };

#define CM_CENABLE_RE      0x2
#define CM_CENABLE_PE      0x1


/* MIDI buffer sizes */

#define MIDIINBUF  256
#define MIDIOUTBUF 256

#define FMODE_MIDI_SHIFT 2
#define FMODE_MIDI_READ  (FMODE_READ << FMODE_MIDI_SHIFT)
#define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)

#define FMODE_DMFM 0x10

#define SND_DEV_DSP16   5 

#ifdef CONFIG_SOUND_CMPCI_4CH
#define DUAL_DAC
#endif
#ifdef DUAL_DAC
#define	set_dac1_rate	set_adc_rate
#define	stop_dac1	stop_adc
#define	get_dmadac1	get_dmaadc
#endif

/* --------------------------------------------------------------------- */

struct cm_state {
	/* magic */
	unsigned int magic;

	/* we keep cm cards in a linked list */
	struct cm_state *next;

	/* soundcore stuff */
	int dev_audio;
	int dev_mixer;
#ifdef	DUAL_DAC
	int dev_dsp;
	int dual_mode;
	int hw_dual_dac;
#endif
	int four_ch;
	int dev_midi;
	int dev_dmfm;

	/* hardware resources */
	unsigned int iosb, iobase, iosynth, iomidi, iogame, irq;

        /* mixer stuff */
        struct {
                unsigned int modcnt;
#ifndef OSS_DOCUMENTED_MIXER_SEMANTICS
		unsigned short vol[13];
#endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
        } mix;

	/* wave stuff */
	unsigned int rateadc, ratedac;
	unsigned char fmt, enable;

	spinlock_t lock;
	struct semaphore open_sem;
	mode_t open_mode;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	wait_queue_head_t open_wait;
#else
	struct wait_queue *open_wait;
#endif

	struct dmabuf {
		void *rawbuf;
		unsigned rawphys;
		unsigned buforder;
		unsigned numfrag;
		unsigned fragshift;
		unsigned hwptr, swptr;
		unsigned total_bytes;
		int count;
		unsigned error; /* over/underrun */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		wait_queue_head_t wait;
#else
		struct wait_queue *wait;
#endif
		/* redundant, but makes calculations easier */
		unsigned fragsize;
		unsigned dmasize;
		unsigned fragsamples;
		unsigned dmasamples;
		/* OSS stuff */
		unsigned mapped:1;
		unsigned ready:1;
		unsigned endcleared:1;
		unsigned ossfragshift;
		int ossmaxfrags;
		unsigned subdivision;
	} dma_dac, dma_adc;

	/* midi stuff */
	struct {
		unsigned ird, iwr, icnt;
		unsigned ord, owr, ocnt;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		wait_queue_head_t iwait;
		wait_queue_head_t owait;
#else
		struct wait_queue *iwait;
		struct wait_queue *owait;
#endif
		struct timer_list timer;
		unsigned char ibuf[MIDIINBUF];
		unsigned char obuf[MIDIOUTBUF];
	} midi;
	
	/* misc stuff */
	int	modem;
};

/* --------------------------------------------------------------------- */

static struct cm_state *devs = NULL;
static struct cm_state *devaudio = NULL;
static unsigned long wavetable_mem = 0;

/* --------------------------------------------------------------------- */

extern __inline__ unsigned ld2(unsigned int x)
{
	unsigned r = 0;
	
	if (x >= 0x10000) {
		x >>= 16;
		r += 16;
	}
	if (x >= 0x100) {
		x >>= 8;
		r += 8;
	}
	if (x >= 0x10) {
		x >>= 4;
		r += 4;
	}
	if (x >= 4) {
		x >>= 2;
		r += 2;
	}
	if (x >= 2)
		r++;
	return r;
}

/*
 * hweightN: returns the hamming weight (i.e. the number
 * of bits set) of a N-bit word
 */

#ifdef hweight32
#undef hweight32
#endif

extern __inline__ unsigned int hweight32(unsigned int w)
{
        unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
        res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
        res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
        return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
}

/* --------------------------------------------------------------------- */

/*
 * Why use byte IO? Nobody knows, but S3 does it also in their Windows driver.
 */

#undef DMABYTEIO

static void set_dmadac(struct cm_state *s, unsigned int addr, unsigned int count)
{
	count--;
	outl(addr, s->iobase + CODEC_CMI_CH0_FRAME1);
	outw(count, s->iobase + CODEC_CMI_CH0_FRAME2);
	outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) & ~1, s->iobase + CODEC_CMI_FUNCTRL0);
}

static void set_dmadac1(struct cm_state *s, unsigned int addr, unsigned int count)
{
	count--;
	outl(addr, s->iobase + CODEC_CMI_CH1_FRAME1);
	outw(count, s->iobase + CODEC_CMI_CH1_FRAME2);
	outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) & ~2, s->iobase + CODEC_CMI_FUNCTRL0);
}

static void set_dmaadc(struct cm_state *s, unsigned int addr, unsigned int count)
{
	count--;
	outl(addr, s->iobase + CODEC_CMI_CH1_FRAME1);
	outw(count, s->iobase + CODEC_CMI_CH1_FRAME2);
	outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) | 2, s->iobase + CODEC_CMI_FUNCTRL0);
}

extern __inline__ unsigned get_dmadac(struct cm_state *s)
{
	unsigned int curr_addr;

#if 1
	curr_addr = inw(s->iobase + CODEC_CMI_CH0_FRAME2) + 1;
	curr_addr <<= sample_shift[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK];
	curr_addr = s->dma_dac.dmasize - curr_addr;
#else
	curr_addr = inl(s->iobase + CODEC_CMI_CH0_FRAME1);
	curr_addr &= ~(sample_size[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK]-1);
	curr_addr -= s->dma_dac.rawphys;
#endif
	return curr_addr;
}

extern __inline__ unsigned get_dmaadc(struct cm_state *s)
{
	unsigned int curr_addr;

#if 1
	curr_addr = inw(s->iobase + CODEC_CMI_CH1_FRAME2) + 1;
	curr_addr <<= sample_shift[(s->fmt >> CM_CFMT_ADCSHIFT) & CM_CFMT_MASK];
	curr_addr = s->dma_adc.dmasize - curr_addr;
#else
	curr_addr = inl(s->iobase + CODEC_CMI_CH1_FRAME1);
	curr_addr &= ~(sample_size[(s->fmt >> CM_CFMT_ADCSHIFT) & CM_CFMT_MASK]-1);
	curr_addr -= s->dma_adc.rawphys;
#endif
	return curr_addr;
}

static void wrmixer(struct cm_state *s, unsigned char idx, unsigned char data)
{
	outb(idx, s->iobase + CODEC_SB16_ADDR);
	outb(data, s->iobase + CODEC_SB16_DATA);
}

static unsigned char rdmixer(struct cm_state *s, unsigned char idx)
{
	unsigned char v;

	outb(idx, s->iobase + CODEC_SB16_ADDR);
	v = inb(s->iobase + CODEC_SB16_DATA);
	return v;
}

static void set_fmt(struct cm_state *s, unsigned char mask, unsigned char data)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if (mask)
		s->fmt = inb(s->iobase + CODEC_CMI_CHFORMAT);
	s->fmt = (s->fmt & mask) | data;
	outb(s->fmt, s->iobase + CODEC_CMI_CHFORMAT);
	spin_unlock_irqrestore(&s->lock, flags);
}

static void frobindir(struct cm_state *s, unsigned char idx, unsigned char mask, unsigned char data)
{
	outb(idx, s->iobase + CODEC_SB16_ADDR);
	outb((inb(s->iobase + CODEC_SB16_DATA) & mask) | data, s->iobase + CODEC_SB16_DATA);
}

static struct {
	unsigned	rate;
	unsigned	lower;
	unsigned	upper;
	unsigned char	freq;
} rate_lookup[] =
{
	{ 5512,		(0 + 5512) / 2,		(5512 + 8000) / 2,	0 },
	{ 8000,		(5512 + 8000) / 2,	(8000 + 11025) / 2,	4 },
	{ 11025,	(8000 + 11025) / 2,	(11025 + 16000) / 2,	1 },
	{ 16000,	(11025 + 16000) / 2,	(16000 + 22050) / 2,	5 },
	{ 22050,	(16000 + 22050) / 2,	(22050 + 32000) / 2,	2 },
	{ 32000,	(22050 + 32000) / 2,	(32000 + 44100) / 2,	6 },
	{ 44100,	(32000 + 44100) / 2,	(44100 + 48000) / 2,	3 },
	{ 48000,	(44100 + 48000) / 2,	48000,			7 }
};

static void set_dac_rate(struct cm_state *s, unsigned rate)
{
	unsigned long flags;
	unsigned char freq = 4, val;
	int	i;

	if (rate > 48000)
		rate = 48000;
	if (rate < 5512)
		rate = 5512;
	for (i = 0; i < sizeof(rate_lookup) / sizeof(rate_lookup[0]); i++)
	{
		if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper)
		{
			rate = rate_lookup[i].rate;
			freq = rate_lookup[i].freq;
			break;
	    	}
	}
	s->ratedac = rate;
	freq <<= 2;
	spin_lock_irqsave(&s->lock, flags);
	val = inb(s->iobase + CODEC_CMI_FUNCTRL1 + 1) & ~0x1c; 
	outb(val | freq, s->iobase + CODEC_CMI_FUNCTRL1 + 1);
	spin_unlock_irqrestore(&s->lock, flags);
}

static void set_adc_rate(struct cm_state *s, unsigned rate)
{
	unsigned long flags;
	unsigned char freq = 4, val;
	int	i;

	if (rate > 48000)
		rate = 48000;
	if (rate < 5512)
		rate = 5512;
	for (i = 0; i < sizeof(rate_lookup) / sizeof(rate_lookup[0]); i++)
	{
		if (rate > rate_lookup[i].lower && rate <= rate_lookup[i].upper)
		{
			rate = rate_lookup[i].rate;
			freq = rate_lookup[i].freq;
			break;
	    	}
	}
	s->rateadc = rate;
	freq <<= 5;
	spin_lock_irqsave(&s->lock, flags);
	val = inb(s->iobase + CODEC_CMI_FUNCTRL1 + 1) & ~0xe0; 
	outb(val | freq, s->iobase + CODEC_CMI_FUNCTRL1 + 1);
	spin_unlock_irqrestore(&s->lock, flags);
}

/* --------------------------------------------------------------------- */
static inline void reset_adc(struct cm_state *s)
{
	/* reset bus master */
	outb(s->enable | CM_CH1_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	outb(s->enable & ~CM_CH1_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
}

static inline void reset_dac(struct cm_state *s)
{
	/* reset bus master */
	outb(s->enable | CM_CH0_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	outb(s->enable & ~CM_CH0_RESET, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
}

static inline void pause_adc(struct cm_state *s)
{
        outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) | 8, s->iobase + CODEC_CMI_FUNCTRL0);
}

static inline void pause_dac(struct cm_state *s)
{
        outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) | 4, s->iobase + CODEC_CMI_FUNCTRL0);
}

extern inline void disable_adc(struct cm_state *s)
{
	/* disable channel */
	s->enable &= ~CM_CENABLE_RE;
	outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	reset_adc(s);
}

extern inline void disable_dac(struct cm_state *s)
{
	/* disable channel */
	s->enable &= ~CM_CENABLE_PE;
	outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	reset_dac(s);
}

extern inline void enable_adc(struct cm_state *s)
{
	if (!(s->enable & CM_CENABLE_RE))
	{
	/* enable channel */
	s->enable |= CM_CENABLE_RE;
	outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	}
	else
	{
       	outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) & ~8, s->iobase + CODEC_CMI_FUNCTRL0);
	}
}

extern inline void enable_dac(struct cm_state *s)
{
	if (!(s->enable & CM_CENABLE_PE))
	{
	/* enable channel */
	s->enable |= CM_CENABLE_PE;
	outb(s->enable, s->iobase + CODEC_CMI_FUNCTRL0 + 2);
	}
	else
	{
       	outb(inb(s->iobase + CODEC_CMI_FUNCTRL0) & ~4, s->iobase + CODEC_CMI_FUNCTRL0);
	}
}

extern inline void stop_adc(struct cm_state *s)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if (s->enable & CM_CENABLE_RE)
	{
	/* disable interrupt */
	outb(inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2) & ~2, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
	disable_adc(s);
	}
	spin_unlock_irqrestore(&s->lock, flags);
}	

extern inline void stop_dac(struct cm_state *s)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if (s->enable & CM_CENABLE_PE)
	{
	/* disable interrupt */
	outb(inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2) & ~1, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
	disable_dac(s);
	}
	spin_unlock_irqrestore(&s->lock, flags);
}	

static void start_dac(struct cm_state *s)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if ((s->dma_dac.mapped || s->dma_dac.count > 0) && s->dma_dac.ready) {
		/* enable interrupt */
		outb(inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2) | 1, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
		enable_dac(s);
	}
	spin_unlock_irqrestore(&s->lock, flags);
}	

static void start_dac1(struct cm_state *s)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if ((s->dma_adc.mapped || s->dma_adc.count > 0) && s->dma_adc.ready) {
		/* enable interrupt */
		outb(inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2) | 2, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
		enable_adc(s);
	}
	spin_unlock_irqrestore(&s->lock, flags);
}	

static void start_adc(struct cm_state *s)
{
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	if ((s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize)) 
	    && s->dma_adc.ready) {
		/* enable interrupt */
		outb(inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2) | 2, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
		enable_adc(s);
	}
	spin_unlock_irqrestore(&s->lock, flags);
}	

/* --------------------------------------------------------------------- */

#define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
#define DMABUF_MINORDER 1

static void dealloc_dmabuf(struct dmabuf *db)
{
	unsigned long map, mapend;

	if (db->rawbuf) {
		/* undo marking the pages as reserved */
		mapend = MAP_NR(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
		for (map = MAP_NR(db->rawbuf); map <= mapend; map++)
			clear_bit(PG_reserved, &mem_map[map].flags);	
		free_pages((unsigned long)db->rawbuf, db->buforder);
	}
	db->rawbuf = NULL;
	db->mapped = db->ready = 0;
}


/* Ch0 is used for playback, Ch1 is used for recording */

static int prog_dmabuf(struct cm_state *s, unsigned rec)
{
	struct dmabuf *db = rec ? &s->dma_adc : &s->dma_dac;
	unsigned rate = rec ? s->rateadc : s->ratedac;
	int order;
	unsigned bytepersec;
	unsigned bufs;
	unsigned long map, mapend;
	unsigned char fmt;
	unsigned long flags;

	spin_lock_irqsave(&s->lock, flags);
	fmt = s->fmt;
	if (rec) {
		stop_adc(s);
		fmt >>= CM_CFMT_ADCSHIFT;
	} else {
		stop_dac(s);
		fmt >>= CM_CFMT_DACSHIFT;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	fmt &= CM_CFMT_MASK;
	db->hwptr = db->swptr = db->total_bytes = db->count = db->error = db->endcleared = 0;
	if (!db->rawbuf) {
		db->ready = db->mapped = 0;
		for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--)
			if ((db->rawbuf = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA, order)))
				break;
		if (!db->rawbuf)
			return -ENOMEM;
		db->buforder = order;
		db->rawphys = virt_to_bus(db->rawbuf);
		if ((db->rawphys ^ (db->rawphys + (PAGE_SIZE << db->buforder) - 1)) & ~0xffff)
			printk(KERN_DEBUG "cm: DMA buffer crosses 64k boundary: busaddr 0x%lx  size %ld\n", 
			       (long) db->rawphys, PAGE_SIZE << db->buforder);
		if ((db->rawphys + (PAGE_SIZE << db->buforder) - 1) & ~0xffffff)
			printk(KERN_DEBUG "cm: DMA buffer beyond 16MB: busaddr 0x%lx  size %ld\n", 
			       (long) db->rawphys, PAGE_SIZE << db->buforder);
		/* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
		mapend = MAP_NR(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
		for (map = MAP_NR(db->rawbuf); map <= mapend; map++)
			set_bit(PG_reserved, &mem_map[map].flags);
	}
	bytepersec = rate << sample_shift[fmt];
	bufs = PAGE_SIZE << db->buforder;
	if (db->ossfragshift) {
		if ((1000 << db->ossfragshift) < bytepersec)
			db->fragshift = ld2(bytepersec/1000);
		else
			db->fragshift = db->ossfragshift;
	} else {
		db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
		if (db->fragshift < 3)
			db->fragshift = 3;
	}
	db->numfrag = bufs >> db->fragshift;
	while (db->numfrag < 4 && db->fragshift > 3) {
		db->fragshift--;
		db->numfrag = bufs >> db->fragshift;
	}
	db->fragsize = 1 << db->fragshift;
	if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
		db->numfrag = db->ossmaxfrags;
 	/* to make fragsize >= 4096 */
	if (s->modem)
	{
	 	while (db->fragsize < 4096 && db->numfrag >= 4)
 		{
 			db->fragsize *= 2;
 			db->fragshift++;
 			db->numfrag /= 2;
 		}
	}
	db->fragsamples = db->fragsize >> sample_shift[fmt];
	db->dmasize = db->numfrag << db->fragshift;
	db->dmasamples = db->dmasize >> sample_shift[fmt];
	memset(db->rawbuf, (fmt & CM_CFMT_16BIT) ? 0 : 0x80, db->dmasize);
	spin_lock_irqsave(&s->lock, flags);
	if (rec) {
#ifdef DUAL_DAC
	    if (s->dual_mode)
		set_dmadac1(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
	    else
#endif
		set_dmaadc(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
		/* program sample counts */
		outw(db->fragsamples-1, s->iobase + CODEC_CMI_CH1_FRAME2 + 2);
	} else {
		set_dmadac(s, db->rawphys, db->dmasize >> sample_shift[fmt]);
		/* program sample counts */
		outw(db->fragsamples-1, s->iobase + CODEC_CMI_CH0_FRAME2 + 2);
	}
	spin_unlock_irqrestore(&s->lock, flags);
	db->ready = 1;
	return 0;
}

extern __inline__ void clear_advance(struct cm_state *s)
{
	unsigned char c = (s->fmt & (CM_CFMT_16BIT << CM_CFMT_DACSHIFT)) ? 0 : 0x80;
	unsigned char *buf = s->dma_dac.rawbuf;
#ifdef DUAL_DAC
	unsigned char *buf1 = s->dma_adc.rawbuf;
#endif
	unsigned bsize = s->dma_dac.dmasize;
	unsigned bptr = s->dma_dac.swptr;
	unsigned len = s->dma_dac.fragsize;

	if (bptr + len > bsize) {
		unsigned x = bsize - bptr;
		memset(buf + bptr, c, x);
#ifdef DUAL_DAC
		if (s->dual_mode)
			memset(buf1 + bptr, c, x);
#endif
		bptr = 0;
		len -= x;
	}
	memset(buf + bptr, c, len);
#ifdef DUAL_DAC
	if (s->dual_mode)
		memset(buf1 + bptr, c, len);
#endif
}

/* call with spinlock held! */
static void cm_update_ptr(struct cm_state *s)
{
	unsigned hwptr;
	int diff;

	/* update ADC pointer */
	if (s->dma_adc.ready) {
#ifdef DUAL_DAC
	    if (s->dual_mode)
	    {
		hwptr = get_dmaadc(s) % s->dma_adc.dmasize;
		diff = (s->dma_adc.dmasize + hwptr - s->dma_adc.hwptr) % s->dma_adc.dmasize;
		s->dma_adc.hwptr = hwptr;
		s->dma_adc.total_bytes += diff;
		if (s->dma_adc.mapped) {
			s->dma_adc.count += diff;
			if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
				wake_up(&s->dma_adc.wait);
		} else {
			s->dma_adc.count -= diff;
			if (s->dma_adc.count <= 0) {
				pause_adc(s);
				s->dma_adc.error++;
			} else if (s->dma_adc.count <= (signed)s->dma_adc.fragsize && !s->dma_adc.endcleared) {
				clear_advance(s);
				s->dma_adc.endcleared = 1;
			}
			if (s->dma_dac.count + (signed)s->dma_dac.fragsize <= (signed)s->dma_dac.dmasize)
				wake_up(&s->dma_adc.wait);
		}
	    }
	    else
	    {
#endif
		hwptr = get_dmaadc(s) % s->dma_adc.dmasize;
		diff = (s->dma_adc.dmasize + hwptr - s->dma_adc.hwptr) % s->dma_adc.dmasize;
		s->dma_adc.hwptr = hwptr;
		s->dma_adc.total_bytes += diff;
		s->dma_adc.count += diff;
		if (s->dma_adc.count >= (signed)s->dma_adc.fragsize) 
			wake_up(&s->dma_adc.wait);
		if (!s->dma_adc.mapped) {
			if (s->dma_adc.count > (signed)(s->dma_adc.dmasize - ((3 * s->dma_adc.fragsize) >> 1))) {
				pause_adc(s);
				s->dma_adc.error++;
			}
		}
#ifdef DUAL_DAC
	    }
#endif
	}
	/* update DAC pointer */
	if (s->dma_dac.ready) {
		hwptr = get_dmadac(s) % s->dma_dac.dmasize;
		diff = (s->dma_dac.dmasize + hwptr - s->dma_dac.hwptr) % s->dma_dac.dmasize;
		s->dma_dac.hwptr = hwptr;
		s->dma_dac.total_bytes += diff;
		if (s->dma_dac.mapped) {
			s->dma_dac.count += diff;
			if (s->dma_dac.count >= (signed)s->dma_dac.fragsize)
				wake_up(&s->dma_dac.wait);
		} else {
			s->dma_dac.count -= diff;
			if (s->dma_dac.count <= 0) {
				pause_dac(s);
				s->dma_dac.error++;
			} else if (s->dma_dac.count <= (signed)s->dma_dac.fragsize && !s->dma_dac.endcleared) {
				clear_advance(s);
				s->dma_dac.endcleared = 1;
			}
			if (s->dma_dac.count + (signed)s->dma_dac.fragsize <= (signed)s->dma_dac.dmasize)
				wake_up(&s->dma_dac.wait);
		}
	}
}

#ifdef CONFIG_SOUND_CMPCI_MIDI
/* hold spinlock for the following! */
static void cm_handle_midi(struct cm_state *s)
{
	unsigned char ch;
	int wake;

	wake = 0;
	while (!(inb(s->iomidi+1) & 0x80)) {
		ch = inb(s->iomidi);
		if (s->midi.icnt < MIDIINBUF) {
			s->midi.ibuf[s->midi.iwr] = ch;
			s->midi.iwr = (s->midi.iwr + 1) % MIDIINBUF;
			s->midi.icnt++;
		}
		wake = 1;
	}
	if (wake)
		wake_up(&s->midi.iwait);
	wake = 0;
	while (!(inb(s->iomidi+1) & 0x40) && s->midi.ocnt > 0) {
		outb(s->midi.obuf[s->midi.ord], s->iomidi);
		s->midi.ord = (s->midi.ord + 1) % MIDIOUTBUF;
		s->midi.ocnt--;
		if (s->midi.ocnt < MIDIOUTBUF-16)
			wake = 1;
	}
	if (wake)
		wake_up(&s->midi.owait);
}
#endif

static void cm_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
        struct cm_state *s = (struct cm_state *)dev_id;
	unsigned int intsrc, intstat;
	unsigned char mask = 0;
	
	/* fastpath out, to ease interrupt sharing */
	intsrc = inl(s->iobase + CODEC_CMI_INT_STATUS);
	if (!(intsrc & 0x80000000))
		return;
	spin_lock(&s->lock);
	intstat = inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2);
	/* acknowledge interrupt */
	if (intsrc & CM_INT_CH0)
		mask |= 1;
	if (intsrc & CM_INT_CH1)
		mask |= 2;
	outb(intstat & ~mask, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
	outb(intstat | mask, s->iobase + CODEC_CMI_INT_HLDCLR + 2);
	cm_update_ptr(s);
#ifdef CONFIG_SOUND_CMPCI_MIDI
	cm_handle_midi(s);
#endif
	spin_unlock(&s->lock);
}

#ifdef CONFIG_SOUND_CMPCI_MIDI
static void cm_midi_timer(unsigned long data)
{
	struct cm_state *s = (struct cm_state *)data;
	unsigned long flags;
	
	spin_lock_irqsave(&s->lock, flags);
	cm_handle_midi(s);
	spin_unlock_irqrestore(&s->lock, flags);
	s->midi.timer.expires = jiffies+1;
	add_timer(&s->midi.timer);
}
#endif

/* --------------------------------------------------------------------- */

static const char invalid_magic[] = KERN_CRIT "cm: invalid magic value\n";

#ifdef CONFIG_SOUND_CMPCI	/* support multiple chips */
#define VALIDATE_STATE(s)
#else
#define VALIDATE_STATE(s)                         \
({                                                \
	if (!(s) || (s)->magic != CM_MAGIC) { \
		printk(invalid_magic);            \
		return -ENXIO;                    \
	}                                         \
})
#endif

/* --------------------------------------------------------------------- */

#define MT_4          1
#define MT_5MUTE      2
#define MT_4MUTEMONO  3
#define MT_6MUTE      4
#define MT_5MUTEMONO  5

static const struct {
	unsigned left;
	unsigned right;
	unsigned type;
	unsigned rec;
	unsigned play;
} mixtable[SOUND_MIXER_NRDEVICES] = {
	[SOUND_MIXER_CD]     = { DSP_MIX_CDVOLIDX_L,     DSP_MIX_CDVOLIDX_R,     MT_5MUTE,     0x04, 0x02 },
	[SOUND_MIXER_LINE]   = { DSP_MIX_LINEVOLIDX_L,   DSP_MIX_LINEVOLIDX_R,   MT_5MUTE,     0x10, 0x08 },
	[SOUND_MIXER_MIC]    = { DSP_MIX_MICVOLIDX,      DSP_MIX_MICVOLIDX,      MT_5MUTEMONO, 0x01, 0x01 },
	[SOUND_MIXER_SYNTH]  = { DSP_MIX_FMVOLIDX_L,  	 DSP_MIX_FMVOLIDX_R,     MT_5MUTE,     0x40, 0x00 },
	[SOUND_MIXER_VOLUME] = { DSP_MIX_MASTERVOLIDX_L, DSP_MIX_MASTERVOLIDX_R, MT_5MUTE,     0x00, 0x00 },
	[SOUND_MIXER_PCM]    = { DSP_MIX_VOICEVOLIDX_L,  DSP_MIX_VOICEVOLIDX_R,  MT_5MUTE,     0x00, 0x00 }
};

#ifdef OSS_DOCUMENTED_MIXER_SEMANTICS

static int return_mixval(struct cm_state *s, unsigned i, int *arg)
{
	unsigned long flags;
	unsigned char l, r, rl, rr;

	spin_lock_irqsave(&s->lock, flags);
	l = rdmixer(s, mixtable[i].left);
	r = rdmixer(s, mixtable[i].right);
	spin_unlock_irqrestore(&s->lock, flags);
	switch (mixtable[i].type) {
	case MT_4:
		r &= 0xf;
		l &= 0xf;
		rl = 10 + 6 * (l & 15);
		rr = 10 + 6 * (r & 15);
		break;

	case MT_4MUTEMONO:
		rl = 55 - 3 * (l & 15);
		if (r & 0x10)
			rl += 45;
		rr = rl;
		r = l;
		break;

	case MT_5MUTEMONO:
		r = l;
		rl = 100 - 3 * ((l >> 3) & 31);
		rr = rl;
		break;
				
	case MT_5MUTE:
	default:
		rl = 100 - 3 * ((l >> 3) & 31);
		rr = 100 - 3 * ((r >> 3) & 31);
		break;
				
	case MT_6MUTE:
		rl = 100 - 3 * (l & 63) / 2;
		rr = 100 - 3 * (r & 63) / 2;
		break;
	}
	if (l & 0x80)
		rl = 0;
	if (r & 0x80)
		rr = 0;
	return put_user((rr << 8) | rl, arg);
}

#else /* OSS_DOCUMENTED_MIXER_SEMANTICS */

static const unsigned char volidx[SOUND_MIXER_NRDEVICES] = 
{
	[SOUND_MIXER_CD]     = 1,
	[SOUND_MIXER_LINE]   = 2,
	[SOUND_MIXER_MIC]    = 3,
	[SOUND_MIXER_SYNTH]  = 4,
	[SOUND_MIXER_VOLUME] = 5,
	[SOUND_MIXER_PCM]    = 6
};

#endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */

static unsigned mixer_recmask(struct cm_state *s)
{
	unsigned long flags;
	int i, j, k;

	spin_lock_irqsave(&s->lock, flags);
	j = rdmixer(s, DSP_MIX_ADCMIXIDX_L);
	spin_unlock_irqrestore(&s->lock, flags);
	j &= 0x7f;
	for (k = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
		if (j & mixtable[i].rec)
			k |= 1 << i;
	return k;
}

static int mixer_ioctl(struct cm_state *s, unsigned int cmd, unsigned long arg)
{
	unsigned long flags;
	int i, val, j;
	unsigned char l, r, rl, rr;

	VALIDATE_STATE(s);
        if (cmd == SOUND_MIXER_INFO) {
		mixer_info info;
		strncpy(info.id, "cmpci", sizeof(info.id));
		strncpy(info.name, "C-Media PCI", sizeof(info.name));
		info.modify_counter = s->mix.modcnt;
		if (copy_to_user((void *)arg, &info, sizeof(info)))
			return -EFAULT;
		return 0;
	}
	if (cmd == SOUND_OLD_MIXER_INFO) {
		_old_mixer_info info;
		strncpy(info.id, "cmpci", sizeof(info.id));
		strncpy(info.name, "C-Media cmpci", sizeof(info.name));
		if (copy_to_user((void *)arg, &info, sizeof(info)))
			return -EFAULT;
		return 0;
	}
	if (cmd == OSS_GETVERSION)
		return put_user(SOUND_VERSION, (int *)arg);
	if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
                return -EINVAL;
        if (_IOC_DIR(cmd) == _IOC_READ) {
                switch (_IOC_NR(cmd)) {
                case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
			return put_user(mixer_recmask(s), (int *)arg);
			
                case SOUND_MIXER_OUTSRC: /* Arg contains a bit for each recording source */
			return put_user(mixer_recmask(s), (int *)arg);//need fix
			
                case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
			for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
				if (mixtable[i].type)
					val |= 1 << i;
			return put_user(val, (int *)arg);

                case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
			for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
				if (mixtable[i].rec)
					val |= 1 << i;
			return put_user(val, (int *)arg);
			
                case SOUND_MIXER_OUTMASK: /* Arg contains a bit for each supported recording source */
			for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
				if (mixtable[i].play)
					val |= 1 << i;
			return put_user(val, (int *)arg);
			
                 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
			for (val = i = 0; i < SOUND_MIXER_NRDEVICES; i++)
				if (mixtable[i].type && mixtable[i].type != MT_4MUTEMONO)
					val |= 1 << i;
			return put_user(val, (int *)arg);
			
                case SOUND_MIXER_CAPS:
			return put_user(0, (int *)arg);

		default:
			i = _IOC_NR(cmd);
                        if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].type)
                                return -EINVAL;
#ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
			return return_mixval(s, i, (int *)arg);
#else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
			if (!volidx[i])
				return -EINVAL;
			return put_user(s->mix.vol[volidx[i]-1], (int *)arg);
#endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
		}
	}
        if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE)) 
		return -EINVAL;
	s->mix.modcnt++;
	switch (_IOC_NR(cmd)) {
	case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
		get_user_ret(val, (int *)arg, -EFAULT);
		i = hweight32(val);
		for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
			if (!(val & (1 << i)))
				continue;
			if (!mixtable[i].rec) {
				val &= ~(1 << i);
				continue;
			}
			j |= mixtable[i].rec;
		}
		spin_lock_irqsave(&s->lock, flags);
		wrmixer(s, DSP_MIX_ADCMIXIDX_L, j);
		wrmixer(s, DSP_MIX_ADCMIXIDX_R, (j & 1) | (j>>1));
		spin_unlock_irqrestore(&s->lock, flags);
		return 0;

	case SOUND_MIXER_OUTSRC: /* Arg contains a bit for each recording source */
		get_user_ret(val, (int *)arg, -EFAULT);
		for (j = i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
			if (!(val & (1 << i)))
				continue;
			if (!mixtable[i].play) {
				val &= ~(1 << i);
				continue;
			}
			j |= mixtable[i].play;
		}
		spin_lock_irqsave(&s->lock, flags);
		frobindir(s, DSP_MIX_OUTMIXIDX, 0x1f, j);
		spin_unlock_irqrestore(&s->lock, flags);
		return 0;

		default:
		i = _IOC_NR(cmd);
		if (i >= SOUND_MIXER_NRDEVICES || !mixtable[i].type)
			return -EINVAL;
		get_user_ret(val, (int *)arg, -EFAULT);
		l = val & 0xff;
		r = (val >> 8) & 0xff;
		if (l > 100)
			l = 100;
		if (r > 100)
			r = 100;
		spin_lock_irqsave(&s->lock, flags);
		switch (mixtable[i].type) {
		case MT_4:
			if (l >= 10)
				l -= 10;
			if (r >= 10)
				r -= 10;
			frobindir(s, mixtable[i].left, 0xf0, l / 6);
			frobindir(s, mixtable[i].right, 0xf0, l / 6);
			break;

		case MT_4MUTEMONO:
			rl = (l < 4 ? 0 : (l - 5) / 3) & 31;
			rr = (rl >> 2) & 7;
			wrmixer(s, mixtable[i].left, rl<<3);
			outb((inb(s->iobase + CODEC_CMI_MIXER2) & ~0x0e) | rr<<1, s->iobase + CODEC_CMI_MIXER2);
			break;
			
		case MT_5MUTEMONO:
			r = l;
			rl = l < 4 ? 0 : (l - 5) / 3;
			rr = rl >> 2;
 			wrmixer(s, mixtable[i].left, rl<<3);
			outb((inb(s->iobase + CODEC_CMI_MIXER2) & ~0x0e) | rr<<1, s->iobase + CODEC_CMI_MIXER2);
			break;
				
		case MT_5MUTE:
			rl = l < 4 ? 0 : (l - 5) / 3;
			rr = r < 4 ? 0 : (r - 5) / 3;
 			wrmixer(s, mixtable[i].left, rl<<3);
			wrmixer(s, mixtable[i].right, rr<<3);
			break;
				
		case MT_6MUTE:
			if (l < 6)
				rl = 0x00;
			else
				rl = l * 2 / 3;
			if (r < 6)
				rr = 0x00;
			else
				rr = r * 2 / 3;
			wrmixer(s, mixtable[i].left, rl);
			wrmixer(s, mixtable[i].right, rr);
			break;
		}
		spin_unlock_irqrestore(&s->lock, flags);
#ifdef OSS_DOCUMENTED_MIXER_SEMANTICS
                return return_mixval(s, i, (int *)arg);
#else /* OSS_DOCUMENTED_MIXER_SEMANTICS */
		if (!volidx[i])
			return -EINVAL;
		s->mix.vol[volidx[i]-1] = val;
		return put_user(s->mix.vol[volidx[i]-1], (int *)arg);
#endif /* OSS_DOCUMENTED_MIXER_SEMANTICS */
	}
}

/* --------------------------------------------------------------------- */

static loff_t cm_llseek(struct file *file, loff_t offset, int origin)
{
	return -ESPIPE;
}

/* --------------------------------------------------------------------- */

static int cm_open_mixdev(struct inode *inode, struct file *file)
{
	int minor = MINOR(inode->i_rdev);
	struct cm_state *s = devs;

	while (s && s->dev_mixer != minor)
		s = s->next;
	if (!s)
		return -ENODEV;
       	VALIDATE_STATE(s);
	file->private_data = s;
	MOD_INC_USE_COUNT;
	return 0;
}

static int cm_release_mixdev(struct inode *inode, struct file *file)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	
	VALIDATE_STATE(s);
	MOD_DEC_USE_COUNT;
	return 0;
}

static int cm_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	return mixer_ioctl((struct cm_state *)file->private_data, cmd, arg);
}

static /*const*/ struct file_operations cm_mixer_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	llseek:		cm_llseek,
	ioctl:		cm_ioctl_mixdev,
	open:		cm_open_mixdev,
	release:	cm_release_mixdev,
#else
	&cm_llseek,
	NULL,  /* read */
	NULL,  /* write */
	NULL,  /* readdir */
	NULL,  /* poll */
	&cm_ioctl_mixdev,
	NULL,  /* mmap */
	&cm_open_mixdev,
	NULL,	/* flush */
	&cm_release_mixdev,
	NULL,  /* fsync */
	NULL,  /* fasync */
	NULL,  /* check_media_change */
	NULL,  /* revalidate */
	NULL,  /* lock */
#endif
};

int IntrOpen(void)
{
    struct cm_state *s = devs;
    unsigned char fmtm = ~0, fmts = 0;

    /* Locate the /dev/dsp file descriptor */
    while (s && ((s->dev_audio ^ 3) & ~0xf))
	s = s->next;

    devaudio = s;
    down(&s->open_sem);
    if (s->open_mode & FMODE_WRITE)
    {
  	up(&s->open_sem);
	devaudio = NULL;
	return -EBUSY;
    }

    if (!s->dma_dac.ready)
    {
	set_dac_rate(s, 8000);
	fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
	set_fmt(s, fmtm, fmts);
    	s->modem = 1;
    }

    s->open_mode |= FMODE_WRITE;
    up(&s->open_sem);
    MOD_INC_USE_COUNT;
    return 0;
}
EXPORT_SYMBOL(IntrOpen);

int IntrClose(void)
{
    struct cm_state *s = devaudio;

    if (!s)
	  return -ENODEV;
    down(&s->open_sem);
    stop_dac(s);
#ifndef FIXEDDMA
    dealloc_dmabuf(&s->dma_dac);
#endif

    s->open_mode &= ~FMODE_WRITE;
    s->modem = 0;
    up(&s->open_sem);
    wake_up(&s->open_wait);
    MOD_DEC_USE_COUNT;
    devaudio = NULL;
    return 0;
}
EXPORT_SYMBOL(IntrClose);

int IntrWrite(const char *buffer, int count)
{
	struct cm_state *s = devaudio;
	ssize_t ret = 0;
	unsigned long flags;
	unsigned swptr;
	int cnt;

	if (!s)
		return -ENODEV;
	VALIDATE_STATE(s);
	if (s->dma_dac.mapped)
		return -ENXIO;

	if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
		return ret;

	s->dma_dac.ossfragshift = 8;
	s->dma_dac.ossmaxfrags = 16;
	s->dma_dac.subdivision = 0;

	while (count > 0) {
	   	spin_lock_irqsave(&s->lock, flags);
		if (s->dma_dac.count < 0) {
			s->dma_dac.count = 0;
			s->dma_dac.swptr = s->dma_dac.hwptr;
		}
		swptr = s->dma_dac.swptr;
		cnt = s->dma_dac.dmasize-swptr;
		if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
			cnt = s->dma_dac.dmasize - s->dma_dac.count;
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count)
			cnt = count;
		if (cnt <= 0) {
			start_dac(s);
			return ret;
		}
		if (__copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt))
			return ret ? ret : -EFAULT;
		swptr = (swptr + cnt) % s->dma_dac.dmasize;
		spin_lock_irqsave(&s->lock, flags);
		s->dma_dac.swptr = swptr;
		s->dma_dac.count += cnt;
		s->dma_dac.endcleared = 0;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt;
		buffer += cnt;
		ret += cnt;
		start_dac(s);
	}
	return ret;
}
EXPORT_SYMBOL(IntrWrite);

/* --------------------------------------------------------------------- */

static int drain_dac(struct cm_state *s, int nonblock)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	DECLARE_WAITQUEUE(wait, current);
#else
        struct wait_queue wait = { current, NULL };
#endif
	unsigned long flags;
	int count, tmo;

	if (s->dma_dac.mapped || !s->dma_dac.ready)
		return 0;
        current->state = TASK_INTERRUPTIBLE;
        add_wait_queue(&s->dma_dac.wait, &wait);
        for (;;) {
                spin_lock_irqsave(&s->lock, flags);
		count = s->dma_dac.count;
                spin_unlock_irqrestore(&s->lock, flags);
		if (count <= 0)
			break;
		if (signal_pending(current))
                        break;
                if (nonblock) {
                        remove_wait_queue(&s->dma_dac.wait, &wait);
                        current->state = TASK_RUNNING;
                        return -EBUSY;
                }
		tmo = (count * HZ) / s->ratedac;
		tmo >>= sample_shift[(s->fmt >> CM_CFMT_DACSHIFT) & CM_CFMT_MASK];
		if (!schedule_timeout(tmo ? : 1) && tmo)
			printk(KERN_DEBUG "cm: dma timed out??\n");
        }
        remove_wait_queue(&s->dma_dac.wait, &wait);
        current->state = TASK_RUNNING;
        if (signal_pending(current))
                return -ERESTARTSYS;
        return 0;
}

/* --------------------------------------------------------------------- */

static ssize_t cm_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	ssize_t ret;
	unsigned long flags;
	unsigned swptr;
	int cnt;

	VALIDATE_STATE(s);
	if (ppos != &file->f_pos)
		return -ESPIPE;
	if (s->dma_adc.mapped)
		return -ENXIO;
	if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
		return ret;
	if (!access_ok(VERIFY_WRITE, buffer, count))
		return -EFAULT;
	ret = 0;
#if 0
   spin_lock_irqsave(&s->lock, flags);
   cm_update_ptr(s);
   spin_unlock_irqrestore(&s->lock, flags);
#endif
	while (count > 0) {
		spin_lock_irqsave(&s->lock, flags);
		swptr = s->dma_adc.swptr;
		cnt = s->dma_adc.dmasize-swptr;
		if (s->dma_adc.count < cnt)
			cnt = s->dma_adc.count;
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count)
			cnt = count;
		if (cnt <= 0) {
			start_adc(s);
			if (file->f_flags & O_NONBLOCK)
				return ret ? ret : -EAGAIN;
			if (!interruptible_sleep_on_timeout(&s->dma_adc.wait, HZ)) {
				printk(KERN_DEBUG "cm: read: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
				       s->dma_adc.dmasize, s->dma_adc.fragsize, s->dma_adc.count,
				       s->dma_adc.hwptr, s->dma_adc.swptr);
				stop_adc(s);
				spin_lock_irqsave(&s->lock, flags);
				set_dmaadc(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
				/* program sample counts */
				outw(s->dma_adc.fragsamples-1, s->iobase + CODEC_CMI_CH1_FRAME2 + 2);
				s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
				spin_unlock_irqrestore(&s->lock, flags);
			}
			if (signal_pending(current))
				return ret ? ret : -ERESTARTSYS;
			continue;
		}
		if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt))
			return ret ? ret : -EFAULT;
		swptr = (swptr + cnt) % s->dma_adc.dmasize;
		spin_lock_irqsave(&s->lock, flags);
		s->dma_adc.swptr = swptr;
		s->dma_adc.count -= cnt;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt;
		buffer += cnt;
		ret += cnt;
		start_adc(s);
	}
	return ret;
}

static ssize_t cm_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	ssize_t ret;
	unsigned long flags;
	unsigned swptr;
	int cnt;

	VALIDATE_STATE(s);
	if (ppos != &file->f_pos)
		return -ESPIPE;
	if (s->dma_dac.mapped)
		return -ENXIO;
	if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
		return ret;
	if (!access_ok(VERIFY_READ, buffer, count))
		return -EFAULT;
	ret = 0;
#if 0
   spin_lock_irqsave(&s->lock, flags);
   cm_update_ptr(s);
   spin_unlock_irqrestore(&s->lock, flags);
#endif
	while (count > 0) {
		spin_lock_irqsave(&s->lock, flags);
		if (s->dma_dac.count < 0) {
			s->dma_dac.count = 0;
			s->dma_dac.swptr = s->dma_dac.hwptr;
		}
		swptr = s->dma_dac.swptr;
		cnt = s->dma_dac.dmasize-swptr;
		if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
			cnt = s->dma_dac.dmasize - s->dma_dac.count;
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count)
			cnt = count;
		if (cnt <= 0) {
			start_dac(s);
			if (file->f_flags & O_NONBLOCK)
				return ret ? ret : -EAGAIN;
			if (!interruptible_sleep_on_timeout(&s->dma_dac.wait, HZ)) {
				printk(KERN_DEBUG "cm: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
				       s->dma_dac.dmasize, s->dma_dac.fragsize, s->dma_dac.count,
				       s->dma_dac.hwptr, s->dma_dac.swptr);
				stop_dac(s);
				spin_lock_irqsave(&s->lock, flags);
				set_dmadac(s, s->dma_dac.rawphys, s->dma_dac.dmasamples);
				/* program sample counts */
				outw(s->dma_dac.fragsamples-1, s->iobase + CODEC_CMI_CH0_FRAME2 + 2);
				s->dma_dac.count = s->dma_dac.hwptr = s->dma_dac.swptr = 0;
				spin_unlock_irqrestore(&s->lock, flags);
			}
			if (signal_pending(current))
				return ret ? ret : -ERESTARTSYS;
			continue;
		}
		if (copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt))
			return ret ? ret : -EFAULT;
		swptr = (swptr + cnt) % s->dma_dac.dmasize;
		spin_lock_irqsave(&s->lock, flags);
		s->dma_dac.swptr = swptr;
		s->dma_dac.count += cnt;
		s->dma_dac.endcleared = 0;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt;
		buffer += cnt;
		ret += cnt;
		start_dac(s);
	}
	return ret;
}

static unsigned int cm_poll(struct file *file, struct poll_table_struct *wait)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned long flags;
	unsigned int mask = 0;

	VALIDATE_STATE(s);
	if (file->f_mode & FMODE_WRITE)
		poll_wait(file, &s->dma_dac.wait, wait);
	if (file->f_mode & FMODE_READ)
		poll_wait(file, &s->dma_adc.wait, wait);
	spin_lock_irqsave(&s->lock, flags);
	cm_update_ptr(s);
	if (file->f_mode & FMODE_READ) {
		if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
			mask |= POLLIN | POLLRDNORM;
	}
	if (file->f_mode & FMODE_WRITE) {
		if (s->dma_dac.mapped) {
			if (s->dma_dac.count >= (signed)s->dma_dac.fragsize) 
				mask |= POLLOUT | POLLWRNORM;
		} else {
			if ((signed)s->dma_dac.dmasize >= s->dma_dac.count + (signed)s->dma_dac.fragsize)
				mask |= POLLOUT | POLLWRNORM;
		}
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return mask;
}

static int cm_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	struct dmabuf *db;
	int ret;
	unsigned long size;

	VALIDATE_STATE(s);
	if (vma->vm_flags & VM_WRITE) {
		if ((ret = prog_dmabuf(s, 1)) != 0)
			return ret;
		db = &s->dma_dac;
	} else if (vma->vm_flags & VM_READ) {
		if ((ret = prog_dmabuf(s, 0)) != 0)
			return ret;
		db = &s->dma_adc;
	} else 
		return -EINVAL;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	if (vma->vm_pgoff != 0)
#else
	if (vma->vm_offset != 0)
#endif
		return -EINVAL;
	size = vma->vm_end - vma->vm_start;
	if (size > (PAGE_SIZE << db->buforder))
		return -EINVAL;
	if (remap_page_range(vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot))
		return -EAGAIN;
	db->mapped = 1;
	return 0;
}

static int cm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned long flags;
        audio_buf_info abinfo;
        count_info cinfo;
	int val, mapped, ret;
	unsigned char fmtm, fmtd;

	VALIDATE_STATE(s);
        mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
		((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
	switch (cmd) {
	case OSS_GETVERSION:
		return put_user(SOUND_VERSION, (int *)arg);

	case SNDCTL_DSP_SYNC:
		if (file->f_mode & FMODE_WRITE)
			return drain_dac(s, 0/*file->f_flags & O_NONBLOCK*/);
		return 0;
		
	case SNDCTL_DSP_SETDUPLEX:
		return 0;

	case SNDCTL_DSP_GETCAPS:
		return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
		
        case SNDCTL_DSP_RESET:
		if (file->f_mode & FMODE_WRITE) {
			stop_dac(s);
			synchronize_irq();
			s->dma_dac.swptr = s->dma_dac.hwptr = s->dma_dac.count = s->dma_dac.total_bytes = 0;
		}
		if (file->f_mode & FMODE_READ) {
			stop_adc(s);
			synchronize_irq();
			s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
		}
		return 0;

        case SNDCTL_DSP_SPEED:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val >= 0) {
			if (file->f_mode & FMODE_READ) {
				stop_adc(s);
				s->dma_adc.ready = 0;
				set_adc_rate(s, val);
			}
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				s->dma_dac.ready = 0;
				set_dac_rate(s, val);
			}
		}
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
		
        case SNDCTL_DSP_STEREO:
                get_user_ret(val, (int *)arg, -EFAULT);
		fmtd = 0;
		fmtm = ~0;
		if (file->f_mode & FMODE_READ) {
			stop_adc(s);
			s->dma_adc.ready = 0;
			if (val)
				fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
			else
				fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
		}
		if (file->f_mode & FMODE_WRITE) {
			stop_dac(s);
			s->dma_dac.ready = 0;
			if (val)
				fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
			else
				fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
		}
		set_fmt(s, fmtm, fmtd);
		return 0;

        case SNDCTL_DSP_CHANNELS:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val != 0) {
			fmtd = 0;
			fmtm = ~0;
			if (file->f_mode & FMODE_READ) {
				stop_adc(s);
				s->dma_adc.ready = 0;
				if (val >= 2)
					fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
				else
					fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
			}
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				s->dma_dac.ready = 0;
				if (val >= 2)
					fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
				else
					fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
			}
			set_fmt(s, fmtm, fmtd);
		}
		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);
		
	case SNDCTL_DSP_GETFMTS: /* Returns a mask */
                return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
		
	case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
		get_user_ret(val, (int *)arg, -EFAULT);
		if (val != AFMT_QUERY) {
			fmtd = 0;
			fmtm = ~0;
			if (file->f_mode & FMODE_READ) {
				stop_adc(s);
				s->dma_adc.ready = 0;
				if (val == AFMT_S16_LE)
					fmtd |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
				else
					fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_ADCSHIFT);
			}
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				s->dma_dac.ready = 0;
				if (val == AFMT_S16_LE)
					fmtd |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
				else
					fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_DACSHIFT);
			}
			set_fmt(s, fmtm, fmtd);
		}
		return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_16BIT << CM_CFMT_ADCSHIFT) 
					   : (CM_CFMT_16BIT << CM_CFMT_DACSHIFT))) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
		
	case SNDCTL_DSP_POST:
                return 0;

        case SNDCTL_DSP_GETTRIGGER:
		val = 0;
		if (file->f_mode & FMODE_READ && s->enable & CM_CENABLE_RE) 
			val |= PCM_ENABLE_INPUT;
		if (file->f_mode & FMODE_WRITE && s->enable & CM_CENABLE_PE) 
			val |= PCM_ENABLE_OUTPUT;
		return put_user(val, (int *)arg);
		
	case SNDCTL_DSP_SETTRIGGER:
		get_user_ret(val, (int *)arg, -EFAULT);
		if (file->f_mode & FMODE_READ) {
			if (val & PCM_ENABLE_INPUT) {
				if (!s->dma_adc.ready && (ret =  prog_dmabuf(s, 1)))
					return ret;
				start_adc(s);
			} else
				stop_adc(s);
		}
		if (file->f_mode & FMODE_WRITE) {
			if (val & PCM_ENABLE_OUTPUT) {
				if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
					return ret;
				start_dac(s);
			} else
				stop_dac(s);
		}
		return 0;

	case SNDCTL_DSP_GETOSPACE:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		if (!(s->enable & CM_CENABLE_PE) && (val = prog_dmabuf(s, 0)) != 0)
			return val;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
		abinfo.fragsize = s->dma_dac.fragsize;
                abinfo.bytes = s->dma_dac.dmasize - s->dma_dac.count;
                abinfo.fragstotal = s->dma_dac.numfrag;
                abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;      
		spin_unlock_irqrestore(&s->lock, flags);
		return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;

	case SNDCTL_DSP_GETISPACE:
		if (!(file->f_mode & FMODE_READ))
			return -EINVAL;
		if (!(s->enable & CM_CENABLE_RE) && (val = prog_dmabuf(s, 1)) != 0)
			return val;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
		abinfo.fragsize = s->dma_adc.fragsize;
                abinfo.bytes = s->dma_adc.count;
                abinfo.fragstotal = s->dma_adc.numfrag;
                abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;      
		spin_unlock_irqrestore(&s->lock, flags);
		return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
		
        case SNDCTL_DSP_NONBLOCK:
                file->f_flags |= O_NONBLOCK;
                return 0;

        case SNDCTL_DSP_GETODELAY:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
                val = s->dma_dac.count;
		spin_unlock_irqrestore(&s->lock, flags);
		return put_user(val, (int *)arg);

        case SNDCTL_DSP_GETIPTR:
		if (!(file->f_mode & FMODE_READ))
			return -EINVAL;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
                cinfo.bytes = s->dma_adc.total_bytes;
                cinfo.blocks = s->dma_adc.count >> s->dma_adc.fragshift;
                cinfo.ptr = s->dma_adc.hwptr;
		if (s->dma_adc.mapped)
			s->dma_adc.count &= s->dma_adc.fragsize-1;
		spin_unlock_irqrestore(&s->lock, flags);
                return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));

        case SNDCTL_DSP_GETOPTR:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
                cinfo.bytes = s->dma_dac.total_bytes;
                cinfo.blocks = s->dma_dac.count >> s->dma_dac.fragshift;
                cinfo.ptr = s->dma_dac.hwptr;
		if (s->dma_dac.mapped)
			s->dma_dac.count &= s->dma_dac.fragsize-1;
		spin_unlock_irqrestore(&s->lock, flags);
                return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));

        case SNDCTL_DSP_GETBLKSIZE:
		if (file->f_mode & FMODE_WRITE) {
			if ((val = prog_dmabuf(s, 0)))
				return val;
			return put_user(s->dma_dac.fragsize, (int *)arg);
		}
		if ((val = prog_dmabuf(s, 1)))
			return val;
		return put_user(s->dma_adc.fragsize, (int *)arg);

        case SNDCTL_DSP_SETFRAGMENT:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (file->f_mode & FMODE_READ) {
			s->dma_adc.ossfragshift = val & 0xffff;
			s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
			if (s->dma_adc.ossfragshift < 4)
				s->dma_adc.ossfragshift = 4;
			if (s->dma_adc.ossfragshift > 15)
				s->dma_adc.ossfragshift = 15;
			if (s->dma_adc.ossmaxfrags < 4)
				s->dma_adc.ossmaxfrags = 4;
		}
		if (file->f_mode & FMODE_WRITE) {
			s->dma_dac.ossfragshift = val & 0xffff;
			s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
			if (s->dma_dac.ossfragshift < 4)
				s->dma_dac.ossfragshift = 4;
			if (s->dma_dac.ossfragshift > 15)
				s->dma_dac.ossfragshift = 15;
			if (s->dma_dac.ossmaxfrags < 4)
				s->dma_dac.ossmaxfrags = 4;
		}
		return 0;

        case SNDCTL_DSP_SUBDIVIDE:
		if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
		    (file->f_mode & FMODE_WRITE && s->dma_dac.subdivision))
			return -EINVAL;
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val != 1 && val != 2 && val != 4)
			return -EINVAL;
		if (file->f_mode & FMODE_READ)
			s->dma_adc.subdivision = val;
		if (file->f_mode & FMODE_WRITE)
			s->dma_dac.subdivision = val;
		return 0;

        case SOUND_PCM_READ_RATE:
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);

        case SOUND_PCM_READ_CHANNELS:
		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);

        case SOUND_PCM_READ_BITS:
		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);

        case SOUND_PCM_READ_FILTER:
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
        case SOUND_PCM_WRITE_FILTER:
        case SNDCTL_DSP_SETSYNCRO:
                return -EINVAL;
		
	}
	return mixer_ioctl(s, cmd, arg);
}

static int cm_open(struct inode *inode, struct file *file)
{
	int minor = MINOR(inode->i_rdev);
	struct cm_state *s = devs;
	unsigned char fmtm = ~0, fmts = 0;

	while (s && ((s->dev_audio ^ minor) & ~0xf))
		s = s->next;
	if (!s)
		return -ENODEV;
       	VALIDATE_STATE(s);
	file->private_data = s;
	/* wait for device to become free */
	down(&s->open_sem);
	while (s->open_mode & file->f_mode) {
		if (file->f_flags & O_NONBLOCK) {
			up(&s->open_sem);
			return -EBUSY;
		}
		up(&s->open_sem);
		interruptible_sleep_on(&s->open_wait);
		if (signal_pending(current))
			return -ERESTARTSYS;
		down(&s->open_sem);
	}
	if (file->f_mode & FMODE_READ) {
		fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_ADCSHIFT);
		if ((minor & 0xf) == SND_DEV_DSP16)
			fmts |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
		s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
		set_adc_rate(s, 8000);
	}
	if (file->f_mode & FMODE_WRITE) {
		fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
		if ((minor & 0xf) == SND_DEV_DSP16)
			fmts |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
		s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags = s->dma_dac.subdivision = 0;
		set_dac_rate(s, 8000);
	}
	set_fmt(s, fmtm, fmts);
	s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
	up(&s->open_sem);
	MOD_INC_USE_COUNT;
	return 0;
}

static int cm_release(struct inode *inode, struct file *file)
{
	struct cm_state *s = (struct cm_state *)file->private_data;

	VALIDATE_STATE(s);
	if (file->f_mode & FMODE_WRITE)
		drain_dac(s, file->f_flags & O_NONBLOCK);
	down(&s->open_sem);
	if (file->f_mode & FMODE_WRITE) {
		stop_dac(s);
#ifndef FIXEDDMA
		dealloc_dmabuf(&s->dma_dac);
#endif
	}
	if (file->f_mode & FMODE_READ) {
		stop_adc(s);
#ifndef FIXEDDMA
		dealloc_dmabuf(&s->dma_adc);
#endif
	}
	s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
	up(&s->open_sem);
	wake_up(&s->open_wait);
	MOD_DEC_USE_COUNT;
	return 0;
}

static /*const*/ struct file_operations cm_audio_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	llseek:		cm_llseek,
	read:		cm_read,
	write:		cm_write,
	poll:		cm_poll,
	ioctl:		cm_ioctl,
	mmap:		cm_mmap,
	open:		cm_open,
	release:	cm_release,
#else
	&cm_llseek,
	&cm_read,
	&cm_write,
	NULL,  /* readdir */
	&cm_poll,
	&cm_ioctl,
	&cm_mmap,
	&cm_open,
	NULL,	/* flush */
	&cm_release,
	NULL,  /* fsync */
	NULL,  /* fasync */
	NULL,  /* check_media_change */
	NULL,  /* revalidate */
	NULL,  /* lock */
#endif
};

#ifdef DUAL_DAC
static ssize_t cm_write_dual(struct file *file, const char *buffer, size_t count, loff_t *ppos)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	ssize_t ret;
	unsigned long flags;
	unsigned swptr;
	int cnt;

	VALIDATE_STATE(s);
	if (ppos != &file->f_pos)
		return -ESPIPE;
	if (s->dma_dac.mapped)
		return -ENXIO;
	if (s->dma_adc.mapped)
		return -ENXIO;
	if (!s->dma_dac.ready && (ret = prog_dmabuf(s, 0)))
		return ret;
	if (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1)))
		return ret;
	if (!access_ok(VERIFY_READ, buffer, count))
		return -EFAULT;
	ret = 0;
#if 0
   spin_lock_irqsave(&s->lock, flags);
   cm_update_ptr(s);
   spin_unlock_irqrestore(&s->lock, flags);
#endif
	while (count > 0) {
		spin_lock_irqsave(&s->lock, flags);
		if (s->dma_dac.count < 0) {
			s->dma_dac.count = 0;
			s->dma_dac.swptr = s->dma_dac.hwptr;
		}
		if (s->dma_adc.count < 0) {
			s->dma_adc.count = 0;
			s->dma_adc.swptr = s->dma_adc.hwptr;
		}
		swptr = s->dma_dac.swptr;
		cnt = s->dma_dac.dmasize-swptr;
		if (s->dma_dac.count + cnt > s->dma_dac.dmasize)
			cnt = s->dma_dac.dmasize - s->dma_dac.count;
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count  / 2)
			cnt = count / 2;
		if (cnt <= 0) {
			start_dac(s);
			start_dac1(s);
			if (file->f_flags & O_NONBLOCK)
				return ret ? ret : -EAGAIN;
			if (!interruptible_sleep_on_timeout(&s->dma_dac.wait, HZ)) {
				printk(KERN_DEBUG "cm: write: chip lockup? dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
				       s->dma_dac.dmasize, s->dma_dac.fragsize, s->dma_dac.count,
				       s->dma_dac.hwptr, s->dma_dac.swptr);
				stop_dac(s);
				stop_dac1(s);
				spin_lock_irqsave(&s->lock, flags);
				set_dmadac(s, s->dma_dac.rawphys, s->dma_dac.dmasamples);
				set_dmadac1(s, s->dma_adc.rawphys, s->dma_adc.dmasamples);
				/* program sample counts */
				outw(s->dma_dac.fragsamples-1, s->iobase + CODEC_CMI_CH0_FRAME2 + 2);
				outw(s->dma_adc.fragsamples-1, s->iobase + CODEC_CMI_CH1_FRAME2 + 2);
				s->dma_adc.count = s->dma_adc.hwptr = s->dma_adc.swptr = 0;
				s->dma_dac.count = s->dma_dac.hwptr = s->dma_dac.swptr = 0;
				spin_unlock_irqrestore(&s->lock, flags);
			}
			if (signal_pending(current))
				return ret ? ret : -ERESTARTSYS;
			continue;
		}
#if 1
		{
			int	i;
			unsigned long *src, *dst0, *dst1;

			src = (unsigned long *) buffer;
			dst0 = (unsigned long *) (s->dma_dac.rawbuf + swptr);
			dst1 = (unsigned long *) (s->dma_adc.rawbuf + swptr);
			// copy left/right sample at one time
			for (i = 0; i <= cnt / 4; i++)
			{
				*dst0++ = *src++;
				*dst1++ = *src++;
			}
		}
#else
		if (copy_from_user(s->dma_dac.rawbuf + swptr, buffer, cnt))
			return ret ? ret : -EFAULT;
		if (copy_from_user(s->dma_adc.rawbuf + swptr, buffer, cnt))
			return ret ? ret : -EFAULT;
#endif
		swptr = (swptr + cnt) % s->dma_dac.dmasize;
		spin_lock_irqsave(&s->lock, flags);
		s->dma_adc.swptr =
		s->dma_dac.swptr = swptr;
		s->dma_adc.count += cnt;
		s->dma_dac.count += cnt;
		s->dma_adc.endcleared =
		s->dma_dac.endcleared = 0;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt  * 2;
		buffer += cnt  * 2;
		ret += cnt * 2;
		start_dac(s);
		start_dac1(s);
	}
	return ret;
}

static unsigned int cm_poll_dual(struct file *file, struct poll_table_struct *wait)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned long flags;
	unsigned int mask = 0;

	VALIDATE_STATE(s);
	if (file->f_mode & FMODE_WRITE)
		poll_wait(file, &s->dma_dac.wait, wait);
	if (file->f_mode & FMODE_READ)
		poll_wait(file, &s->dma_adc.wait, wait);
	spin_lock_irqsave(&s->lock, flags);
	cm_update_ptr(s);
	if (file->f_mode & FMODE_READ) {
		if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
			mask |= POLLIN | POLLRDNORM;
	}
	if (file->f_mode & FMODE_WRITE) {
		if (s->dma_dac.mapped) {
			if (s->dma_dac.count >= (signed)s->dma_dac.fragsize) 
				mask |= POLLOUT | POLLWRNORM;
		} else {
			if ((signed)s->dma_dac.dmasize >= s->dma_dac.count + (signed)s->dma_dac.fragsize)
				mask |= POLLOUT | POLLWRNORM;
		}
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return mask;
}

static int cm_mmap_dual(struct file *file, struct vm_area_struct *vma)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	struct dmabuf *db;
	int ret;
	unsigned long size;

	VALIDATE_STATE(s);
	if (vma->vm_flags & VM_WRITE) {
		if ((ret = prog_dmabuf(s, 1)) != 0)
			return ret;
		db = &s->dma_dac;
	} else if (vma->vm_flags & VM_READ) {
		if ((ret = prog_dmabuf(s, 0)) != 0)
			return ret;
		db = &s->dma_adc;
	} else 
		return -EINVAL;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	if (vma->vm_pgoff != 0)
#else
	if (vma->vm_offset != 0)
#endif
		return -EINVAL;
	size = vma->vm_end - vma->vm_start;
	if (size > (PAGE_SIZE << db->buforder))
		return -EINVAL;
	if (remap_page_range(vma->vm_start, virt_to_phys(db->rawbuf), size, vma->vm_page_prot))
		return -EAGAIN;
	db->mapped = 1;
	return 0;
}

static int cm_ioctl_dual(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned long flags;
        audio_buf_info abinfo;
        count_info cinfo;
	int val, mapped, ret;
	unsigned char fmtm, fmtd;

	VALIDATE_STATE(s);
        mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
		((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
	switch (cmd) {
	case OSS_GETVERSION:
		return put_user(SOUND_VERSION, (int *)arg);

	case SNDCTL_DSP_SYNC:
		if (file->f_mode & FMODE_WRITE)
			return drain_dac(s, 0/*file->f_flags & O_NONBLOCK*/);
		return 0;
		
	case SNDCTL_DSP_SETDUPLEX:
		return 0;

	case SNDCTL_DSP_GETCAPS:
		return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
		
        case SNDCTL_DSP_RESET:
		if (file->f_mode & FMODE_WRITE) {
			stop_dac(s);
			stop_dac1(s);
			synchronize_irq();
			s->dma_dac.swptr = s->dma_dac.hwptr = s->dma_dac.count = s->dma_dac.total_bytes = 0;
			s->dma_adc.swptr = s->dma_adc.hwptr = s->dma_adc.count = s->dma_adc.total_bytes = 0;
		}
		return 0;

        case SNDCTL_DSP_SPEED:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val >= 0) {
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				stop_dac1(s);
				s->dma_dac.ready = 0;
				s->dma_adc.ready = 0;
				set_dac_rate(s, val);
				set_dac1_rate(s, val);
			}
		}
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
		
        case SNDCTL_DSP_STEREO:
                get_user_ret(val, (int *)arg, -EFAULT);
		fmtd = 0;
		fmtm = ~0;
		if (file->f_mode & FMODE_WRITE) {
			stop_dac(s);
			stop_dac1(s);
			s->dma_dac.ready = 0;
			s->dma_adc.ready = 0;
			if (val) {
				fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
				fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
			} else {
				fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
				fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
			}
		}
		set_fmt(s, fmtm, fmtd);
		return 0;

        case SNDCTL_DSP_CHANNELS:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val != 0) {
			fmtd = 0;
			fmtm = ~0;
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				stop_dac1(s);
				s->dma_dac.ready = 0;
				s->dma_adc.ready = 0;
				if (val >= 2) {
					fmtd |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
					fmtd |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
				} else {
					fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_DACSHIFT);
					fmtm &= ~(CM_CFMT_STEREO << CM_CFMT_ADCSHIFT);
				}
			}
			set_fmt(s, fmtm, fmtd);
		}
		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);
		
	case SNDCTL_DSP_GETFMTS: /* Returns a mask */
                return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
		
	case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
		get_user_ret(val, (int *)arg, -EFAULT);
		if (val != AFMT_QUERY) {
			fmtd = 0;
			fmtm = ~0;
			if (file->f_mode & FMODE_WRITE) {
				stop_dac(s);
				stop_dac1(s);
				s->dma_dac.ready = 0;
				s->dma_adc.ready = 0;
				if (val == AFMT_S16_LE) {
					fmtd |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
					fmtd |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
				} else {
					fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_DACSHIFT);
					fmtm &= ~(CM_CFMT_16BIT << CM_CFMT_ADCSHIFT);
				}
			}
			set_fmt(s, fmtm, fmtd);
		}
		return put_user((s->fmt & ((file->f_mode & FMODE_READ) ? (CM_CFMT_16BIT << CM_CFMT_ADCSHIFT) 
					   : (CM_CFMT_16BIT << CM_CFMT_DACSHIFT))) ? AFMT_S16_LE : AFMT_U8, (int *)arg);
		
	case SNDCTL_DSP_POST:
                return 0;

        case SNDCTL_DSP_GETTRIGGER:
		val = 0;
		if (file->f_mode & FMODE_WRITE && s->enable & CM_CENABLE_PE) 
			val |= PCM_ENABLE_OUTPUT;
		return put_user(val, (int *)arg);
		
	case SNDCTL_DSP_SETTRIGGER:
		get_user_ret(val, (int *)arg, -EFAULT);
		if (file->f_mode & FMODE_WRITE) {
			if (val & PCM_ENABLE_OUTPUT) {
				if ((!s->dma_dac.ready && (ret = prog_dmabuf(s, 0))) || (!s->dma_adc.ready && (ret = prog_dmabuf(s, 1))))
					return ret;
				start_dac(s);
				start_dac1(s);
			} else {
				stop_dac(s);
				stop_dac1(s);
			}
		}
		return 0;

	case SNDCTL_DSP_GETOSPACE:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		if (!(s->enable & CM_CENABLE_PE) && (val = prog_dmabuf(s, 0) | prog_dmabuf(s, 1)) != 0)
			return val;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
		abinfo.fragsize = s->dma_dac.fragsize;
                abinfo.bytes = s->dma_dac.dmasize - s->dma_dac.count;
                abinfo.fragstotal = s->dma_dac.numfrag;
                abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;      
		abinfo.fragsize *= 2;
		abinfo.bytes *= 2;
		spin_unlock_irqrestore(&s->lock, flags);
		return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;

        case SNDCTL_DSP_NONBLOCK:
                file->f_flags |= O_NONBLOCK;
                return 0;

        case SNDCTL_DSP_GETODELAY:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
                val = s->dma_dac.count;
		val *= 2;
		spin_unlock_irqrestore(&s->lock, flags);
		return put_user(val, (int *)arg);

        case SNDCTL_DSP_GETOPTR:
		if (!(file->f_mode & FMODE_WRITE))
			return -EINVAL;
		spin_lock_irqsave(&s->lock, flags);
		cm_update_ptr(s);
                cinfo.bytes = s->dma_dac.total_bytes;
                cinfo.blocks = s->dma_dac.count >> s->dma_dac.fragshift;
                cinfo.ptr = s->dma_dac.hwptr;
		cinfo.bytes *= 2;
		cinfo.ptr *= 2;
		if (s->dma_dac.mapped)
			s->dma_dac.count &= s->dma_dac.fragsize-1;
		spin_unlock_irqrestore(&s->lock, flags);
                return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));

        case SNDCTL_DSP_GETBLKSIZE:
		if (file->f_mode & FMODE_WRITE) {
			if ((val = prog_dmabuf(s, 0) | prog_dmabuf(s, 1)))
				return val;
			return put_user(2 * s->dma_dac.fragsize, (int *)arg);
		}
		if ((val = prog_dmabuf(s, 1)))
			return val;
		return put_user(2 * s->dma_adc.fragsize, (int *)arg);

        case SNDCTL_DSP_SETFRAGMENT:
                get_user_ret(val, (int *)arg, -EFAULT);
		if (file->f_mode & FMODE_WRITE) {
			s->dma_adc.ossfragshift =
			s->dma_dac.ossfragshift = val & 0xffff;
			s->dma_adc.ossmaxfrags =
			s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
			if (s->dma_dac.ossfragshift < 4)
				s->dma_adc.ossfragshift =
				s->dma_dac.ossfragshift = 4;
			if (s->dma_dac.ossfragshift > 15)
				s->dma_adc.ossfragshift =
				s->dma_dac.ossfragshift = 15;
			if (s->dma_dac.ossmaxfrags < 4)
				s->dma_adc.ossmaxfrags =
				s->dma_dac.ossmaxfrags = 4;
		}
		return 0;

        case SNDCTL_DSP_SUBDIVIDE:
		if (file->f_mode & FMODE_WRITE && s->dma_dac.subdivision)
			return -EINVAL;
                get_user_ret(val, (int *)arg, -EFAULT);
		if (val != 1 && val != 2 && val != 4)
			return -EINVAL;
		if (file->f_mode & FMODE_WRITE)
			s->dma_adc.subdivision =
			s->dma_dac.subdivision = val;
		return 0;

        case SOUND_PCM_READ_RATE:
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);

        case SOUND_PCM_READ_CHANNELS:
		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);

        case SOUND_PCM_READ_BITS:
		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);

        case SOUND_PCM_READ_FILTER:
		return put_user((file->f_mode & FMODE_READ) ? s->rateadc : s->ratedac, (int *)arg);
        case SOUND_PCM_WRITE_FILTER:
        case SNDCTL_DSP_SETSYNCRO:
                return -EINVAL;
		
	}
	return mixer_ioctl(s, cmd, arg);
}

static int cm_open_dual(struct inode *inode, struct file *file)
{
	int minor = MINOR(inode->i_rdev);
	struct cm_state *s = devs;
	unsigned char fmtm = ~0, fmts = 0;

	while (s && ((s->dev_dsp ^ minor) & ~0xf))
		s = s->next;
	if (!s)
		return -ENODEV;
       	VALIDATE_STATE(s);
	if (!(file->f_mode & FMODE_WRITE))
		return -EINVAL;
	file->private_data = s;
	/* wait for device to become free */
	down(&s->open_sem);
	while (s->open_mode & file->f_mode) {
		if (file->f_flags & O_NONBLOCK) {
			up(&s->open_sem);
			return -EBUSY;
		}
		up(&s->open_sem);
		interruptible_sleep_on(&s->open_wait);
		if (signal_pending(current))
			return -ERESTARTSYS;
		down(&s->open_sem);
	}
	if (file->f_mode & FMODE_WRITE) {
		fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_DACSHIFT);
		fmtm &= ~((CM_CFMT_STEREO | CM_CFMT_16BIT) << CM_CFMT_ADCSHIFT);
		// the HW only support 16-bit stereo
		fmts |= CM_CFMT_16BIT << CM_CFMT_DACSHIFT;
		fmts |= CM_CFMT_16BIT << CM_CFMT_ADCSHIFT;
		fmts |= CM_CFMT_STEREO << CM_CFMT_DACSHIFT;
		fmts |= CM_CFMT_STEREO << CM_CFMT_ADCSHIFT;
		s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags = s->dma_dac.subdivision = 0;
		s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
		set_dac_rate(s, 8000);
		set_dac1_rate(s, 8000);
	}
	set_fmt(s, fmtm, fmts);
	s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
	s->dual_mode  = 1;
	/* disable 4 channel mode (analog duplicate) */
	if (s->four_ch)
		outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 3) & ~0x04, s->iobase + CODEC_CMI_MISC_CTRL + 3);
	/* turn on double DAC mode */
	outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 2) | 0x80, s->iobase + CODEC_CMI_MISC_CTRL + 2);
	up(&s->open_sem);
	MOD_INC_USE_COUNT;
	return 0;
}

static int cm_release_dual(struct inode *inode, struct file *file)
{
	struct cm_state *s = (struct cm_state *)file->private_data;

	VALIDATE_STATE(s);
	if (file->f_mode & FMODE_WRITE)
		drain_dac(s, file->f_flags & O_NONBLOCK);
	down(&s->open_sem);
	if (file->f_mode & FMODE_WRITE) {
		stop_dac(s);
		stop_dac1(s);
#ifndef FIXEDDMA
		dealloc_dmabuf(&s->dma_dac);
		dealloc_dmabuf(&s->dma_adc);
#endif
	}
	s->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
	s->dual_mode = 0;
	/* enable 4 channel mode (analog duplicate) */
	if (s->four_ch)
		outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 3) | 0x04, s->iobase + CODEC_CMI_MISC_CTRL + 3);
	/* turn off double DAC mode */
	outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 2) & ~0x80, s->iobase + CODEC_CMI_MISC_CTRL + 2);
	up(&s->open_sem);
	wake_up(&s->open_wait);
	MOD_DEC_USE_COUNT;
	return 0;
}

static /*const*/ struct file_operations cm_dsp_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	llseek:		cm_llseek,
	write:		cm_write_dual,
	poll:		cm_poll_dual,
	ioctl:		cm_ioctl_dual,
	mmap:		cm_mmap_dual,
	open:		cm_open_dual,
	release:	cm_release_dual,
#else
	&cm_llseek,
	NULL,
	&cm_write_dual,
	NULL,  /* readdir */
	&cm_poll_dual,
	&cm_ioctl_dual,
	&cm_mmap_dual,
	&cm_open_dual,
	NULL,	/* flush */
	&cm_release_dual,
	NULL,  /* fsync */
	NULL,  /* fasync */
	NULL,  /* check_media_change */
	NULL,  /* revalidate */
	NULL,  /* lock */
#endif
};
#endif

#ifdef CONFIG_SOUND_CMPCI_MIDI
/* --------------------------------------------------------------------- */

static ssize_t cm_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	DECLARE_WAITQUEUE(wait, current);
#endif
	ssize_t ret;
	unsigned long flags;
	unsigned ptr;
	int cnt;

	VALIDATE_STATE(s);
	if (ppos != &file->f_pos)
		return -ESPIPE;
	if (!access_ok(VERIFY_WRITE, buffer, count))
		return -EFAULT;
	ret = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	add_wait_queue(&s->midi.iwait, &wait);
#endif
	while (count > 0) {
		spin_lock_irqsave(&s->lock, flags);
		ptr = s->midi.ird;
		cnt = MIDIINBUF - ptr;
		if (s->midi.icnt < cnt)
			cnt = s->midi.icnt;
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count)
			cnt = count;
		if (cnt <= 0) {
			if (file->f_flags & O_NONBLOCK)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
			{
				if (!ret)
					ret = -EAGAIN;
				break;
			}
			__set_current_state(TASK_INTERRUPTIBLE);
			schedule();
			if (signal_pending(current))
			{
				if (!ret)
					ret = -ERESTARTSYS;
				break;
			}
#else
				return ret ? ret : -EAGAIN;
			interruptible_sleep_on(&s->midi.iwait);
			if (signal_pending(current))
				return ret ? ret : -ERESTARTSYS;
#endif
			continue;
		}
		if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt))
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		{
			if (!ret)
				ret = -EFAULT;
			break;
		}
#else
			return ret ? ret : -EFAULT;
#endif
		ptr = (ptr + cnt) % MIDIINBUF;
		spin_lock_irqsave(&s->lock, flags);
		s->midi.ird = ptr;
		s->midi.icnt -= cnt;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt;
		buffer += cnt;
		ret += cnt;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		break;
#endif
	}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(&s->midi.iwait, &wait);
#endif
	return ret;
}

static ssize_t cm_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	DECLARE_WAITQUEUE(wait, current);
#endif
	ssize_t ret;
	unsigned long flags;
	unsigned ptr;
	int cnt;

	VALIDATE_STATE(s);
	if (ppos != &file->f_pos)
		return -ESPIPE;
	if (!access_ok(VERIFY_READ, buffer, count))
		return -EFAULT;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	if (count == 0)
		return 0;
#endif
	ret = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	add_wait_queue(&s->midi.owait, &wait);
#endif
	while (count > 0) {
		spin_lock_irqsave(&s->lock, flags);
		ptr = s->midi.owr;
		cnt = MIDIOUTBUF - ptr;
		if (s->midi.ocnt + cnt > MIDIOUTBUF)
			cnt = MIDIOUTBUF - s->midi.ocnt;
		if (cnt <= 0)
			cm_handle_midi(s);
		spin_unlock_irqrestore(&s->lock, flags);
		if (cnt > count)
			cnt = count;
		if (cnt <= 0) {
			if (file->f_flags & O_NONBLOCK)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
			{
				if (!ret)
					ret = -EAGAIN;
				break;
			}
			__set_current_state(TASK_INTERRUPTIBLE);
			schedule();
			if (signal_pending(current)) {
				if (!ret)
					ret = -ERESTARTSYS;
				break;
			}
#else
				return ret ? ret : -EAGAIN;
			interruptible_sleep_on(&s->midi.owait);
			if (signal_pending(current))
				return ret ? ret : -ERESTARTSYS;
#endif
			continue;
		}
		if (copy_from_user(s->midi.obuf + ptr, buffer, cnt))
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		{
			if (!ret)
				ret = -EFAULT;
			break;
		}
#else
			return ret ? ret : -EFAULT;
#endif
		ptr = (ptr + cnt) % MIDIOUTBUF;
		spin_lock_irqsave(&s->lock, flags);
		s->midi.owr = ptr;
		s->midi.ocnt += cnt;
		spin_unlock_irqrestore(&s->lock, flags);
		count -= cnt;
		buffer += cnt;
		ret += cnt;
		spin_lock_irqsave(&s->lock, flags);
		cm_handle_midi(s);
		spin_unlock_irqrestore(&s->lock, flags);
	}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(&s->midi.owait, &wait);
#endif
	return ret;
}

static unsigned int cm_midi_poll(struct file *file, struct poll_table_struct *wait)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned long flags;
	unsigned int mask = 0;

	VALIDATE_STATE(s);
	if (file->f_mode & FMODE_WRITE)
		poll_wait(file, &s->midi.owait, wait);
	if (file->f_mode & FMODE_READ)
		poll_wait(file, &s->midi.iwait, wait);
	spin_lock_irqsave(&s->lock, flags);
	if (file->f_mode & FMODE_READ) {
		if (s->midi.icnt > 0)
			mask |= POLLIN | POLLRDNORM;
	}
	if (file->f_mode & FMODE_WRITE) {
		if (s->midi.ocnt < MIDIOUTBUF)
			mask |= POLLOUT | POLLWRNORM;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return mask;
}

static int cm_midi_open(struct inode *inode, struct file *file)
{
	int minor = MINOR(inode->i_rdev);
	struct cm_state *s = devs;
	unsigned long flags;

	while (s && s->dev_midi != minor)
		s = s->next;
	if (!s)
		return -ENODEV;
       	VALIDATE_STATE(s);
	file->private_data = s;
	/* wait for device to become free */
	down(&s->open_sem);
	while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
		if (file->f_flags & O_NONBLOCK) {
			up(&s->open_sem);
			return -EBUSY;
		}
		up(&s->open_sem);
		interruptible_sleep_on(&s->open_wait);
		if (signal_pending(current))
			return -ERESTARTSYS;
		down(&s->open_sem);
	}
	spin_lock_irqsave(&s->lock, flags);
	if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
		s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
		s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
		/* enable MPU-401 */
		outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) | 4, s->iobase + CODEC_CMI_FUNCTRL1);
		outb(0xff, s->iomidi+1); /* reset command */
		if (!(inb(s->iomidi+1) & 0x80))
			inb(s->iomidi);
		outb(0x3f, s->iomidi+1); /* uart command */
		if (!(inb(s->iomidi+1) & 0x80))
			inb(s->iomidi);
		s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
		init_timer(&s->midi.timer);
		s->midi.timer.expires = jiffies+1;
		s->midi.timer.data = (unsigned long)s;
		s->midi.timer.function = cm_midi_timer;
		add_timer(&s->midi.timer);
	}
	if (file->f_mode & FMODE_READ) {
		s->midi.ird = s->midi.iwr = s->midi.icnt = 0;
	}
	if (file->f_mode & FMODE_WRITE) {
		s->midi.ord = s->midi.owr = s->midi.ocnt = 0;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
	up(&s->open_sem);
	MOD_INC_USE_COUNT;
	return 0;
}

static int cm_midi_release(struct inode *inode, struct file *file)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	DECLARE_WAITQUEUE(wait, current);
#else
        struct wait_queue wait = { current, NULL };
#endif
	unsigned long flags;
	unsigned count, tmo;

	VALIDATE_STATE(s);

	if (file->f_mode & FMODE_WRITE) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		__set_current_state(TASK_INTERRUPTIBLE);
#else
		current->state = TASK_INTERRUPTIBLE;
#endif
		add_wait_queue(&s->midi.owait, &wait);
		for (;;) {
			spin_lock_irqsave(&s->lock, flags);
			count = s->midi.ocnt;
			spin_unlock_irqrestore(&s->lock, flags);
			if (count <= 0)
				break;
			if (signal_pending(current))
				break;
			if (file->f_flags & O_NONBLOCK) {
				remove_wait_queue(&s->midi.owait, &wait);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
				set_current_state(TASK_RUNNING);
#else
				current->state = TASK_RUNNING;
#endif
				return -EBUSY;
			}
			tmo = (count * HZ) / 3100;
			if (!schedule_timeout(tmo ? : 1) && tmo)
				printk(KERN_DEBUG "cm: midi timed out??\n");
		}
		remove_wait_queue(&s->midi.owait, &wait);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		set_current_state(TASK_RUNNING);
#else
		current->state = TASK_RUNNING;
#endif
	}
	down(&s->open_sem);
	s->open_mode &= (~(file->f_mode << FMODE_MIDI_SHIFT)) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE);
	spin_lock_irqsave(&s->lock, flags);
	if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
		del_timer(&s->midi.timer);		
		outb(0xff, s->iomidi+1); /* reset command */
		if (!(inb(s->iomidi+1) & 0x80))
			inb(s->iomidi);
		/* disable MPU-401 */
		outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) & ~4, s->iobase + CODEC_CMI_FUNCTRL1);
	}
	spin_unlock_irqrestore(&s->lock, flags);
	up(&s->open_sem);
	wake_up(&s->open_wait);
	MOD_DEC_USE_COUNT;
	return 0;
}

static /*const*/ struct file_operations cm_midi_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	llseek:		cm_llseek,
	read:		cm_midi_read,
	write:		cm_midi_write,
	poll:		cm_midi_poll,
	open:		cm_midi_open,
	release:	cm_midi_release,
#else
	&cm_llseek,
	&cm_midi_read,
	&cm_midi_write,
	NULL,  /* readdir */
	&cm_midi_poll,
	NULL,  /* ioctl */
	NULL,  /* mmap */
	&cm_midi_open,
	NULL,	/* flush */
	&cm_midi_release,
	NULL,  /* fsync */
	NULL,  /* fasync */
	NULL,  /* check_media_change */
	NULL,  /* revalidate */
	NULL,  /* lock */
#endif
};
#endif

/* --------------------------------------------------------------------- */

#ifdef CONFIG_SOUND_CMPCI_FM
static int cm_dmfm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	static const unsigned char op_offset[18] = {
		0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
		0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
		0x10, 0x11, 0x12, 0x13, 0x14, 0x15
	};
	struct cm_state *s = (struct cm_state *)file->private_data;
	struct dm_fm_voice v;
	struct dm_fm_note n;
	struct dm_fm_params p;
	unsigned int io;
	unsigned int regb;

	switch (cmd) {		
	case FM_IOCTL_RESET:
		for (regb = 0xb0; regb < 0xb9; regb++) {
			outb(regb, s->iosynth);
			outb(0, s->iosynth+1);
			outb(regb, s->iosynth+2);
			outb(0, s->iosynth+3);
		}
		return 0;

	case FM_IOCTL_PLAY_NOTE:
		if (copy_from_user(&n, (void *)arg, sizeof(n)))
			return -EFAULT;
		if (n.voice >= 18)
			return -EINVAL;
		if (n.voice >= 9) {
			regb = n.voice - 9;
			io = s->iosynth+2;
		} else {
			regb = n.voice;
			io = s->iosynth;
		}
		outb(0xa0 + regb, io);
		outb(n.fnum & 0xff, io+1);
		outb(0xb0 + regb, io);
		outb(((n.fnum >> 8) & 3) | ((n.octave & 7) << 2) | ((n.key_on & 1) << 5), io+1);
		return 0;

	case FM_IOCTL_SET_VOICE:
		if (copy_from_user(&v, (void *)arg, sizeof(v)))
			return -EFAULT;
		if (v.voice >= 18)
			return -EINVAL;
		regb = op_offset[v.voice];
		io = s->iosynth + ((v.op & 1) << 1);
		outb(0x20 + regb, io);
		outb(((v.am & 1) << 7) | ((v.vibrato & 1) << 6) | ((v.do_sustain & 1) << 5) | 
		     ((v.kbd_scale & 1) << 4) | (v.harmonic & 0xf), io+1);
		outb(0x40 + regb, io);
		outb(((v.scale_level & 0x3) << 6) | (v.volume & 0x3f), io+1);
		outb(0x60 + regb, io);
		outb(((v.attack & 0xf) << 4) | (v.decay & 0xf), io+1);
		outb(0x80 + regb, io);
		outb(((v.sustain & 0xf) << 4) | (v.release & 0xf), io+1);
		outb(0xe0 + regb, io);
		outb(v.waveform & 0x7, io+1);
		if (n.voice >= 9) {
			regb = n.voice - 9;
			io = s->iosynth+2;
		} else {
			regb = n.voice;
			io = s->iosynth;
		}
		outb(0xc0 + regb, io);
		outb(((v.right & 1) << 5) | ((v.left & 1) << 4) | ((v.feedback & 7) << 1) |
		     (v.connection & 1), io+1);
		return 0;
		
	case FM_IOCTL_SET_PARAMS:
		if (copy_from_user(&p, (void *)arg, sizeof(p)))
			return -EFAULT;
		outb(0x08, s->iosynth);
		outb((p.kbd_split & 1) << 6, s->iosynth+1);
		outb(0xbd, s->iosynth);
		outb(((p.am_depth & 1) << 7) | ((p.vib_depth & 1) << 6) | ((p.rhythm & 1) << 5) | ((p.bass & 1) << 4) |
		     ((p.snare & 1) << 3) | ((p.tomtom & 1) << 2) | ((p.cymbal & 1) << 1) | (p.hihat & 1), s->iosynth+1);
		return 0;

	case FM_IOCTL_SET_OPL:
		outb(4, s->iosynth+2);
		outb(arg, s->iosynth+3);
		return 0;

	case FM_IOCTL_SET_MODE:
		outb(5, s->iosynth+2);
		outb(arg & 1, s->iosynth+3);
		return 0;

	default:
		return -EINVAL;
	}
}

static int cm_dmfm_open(struct inode *inode, struct file *file)
{
	int minor = MINOR(inode->i_rdev);
	struct cm_state *s = devs;

	while (s && s->dev_dmfm != minor)
		s = s->next;
	if (!s)
		return -ENODEV;
       	VALIDATE_STATE(s);
	file->private_data = s;
	/* wait for device to become free */
	down(&s->open_sem);
	while (s->open_mode & FMODE_DMFM) {
		if (file->f_flags & O_NONBLOCK) {
			up(&s->open_sem);
			return -EBUSY;
		}
		up(&s->open_sem);
		interruptible_sleep_on(&s->open_wait);
		if (signal_pending(current))
			return -ERESTARTSYS;
		down(&s->open_sem);
	}
	/* init the stuff */
	outb(1, s->iosynth);
	outb(0x20, s->iosynth+1); /* enable waveforms */
	outb(4, s->iosynth+2);
	outb(0, s->iosynth+3);  /* no 4op enabled */
	outb(5, s->iosynth+2);
	outb(1, s->iosynth+3);  /* enable OPL3 */
	s->open_mode |= FMODE_DMFM;
	up(&s->open_sem);
	MOD_INC_USE_COUNT;
	return 0;
}

static int cm_dmfm_release(struct inode *inode, struct file *file)
{
	struct cm_state *s = (struct cm_state *)file->private_data;
	unsigned int regb;

	VALIDATE_STATE(s);
	down(&s->open_sem);
	s->open_mode &= ~FMODE_DMFM;
	for (regb = 0xb0; regb < 0xb9; regb++) {
		outb(regb, s->iosynth);
		outb(0, s->iosynth+1);
		outb(regb, s->iosynth+2);
		outb(0, s->iosynth+3);
	}
	up(&s->open_sem);
	wake_up(&s->open_wait);
	MOD_DEC_USE_COUNT;
	return 0;
}

static /*const*/ struct file_operations cm_dmfm_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
	llseek:		cm_llseek,
	ioctl:		cm_dmfm_ioctl,
	open:		cm_dmfm_open,
	release:	cm_dmfm_release,
#else
	&cm_llseek,
	NULL,  /* read */
	NULL,  /* write */
	NULL,  /* readdir */
	NULL,  /* poll */
	&cm_dmfm_ioctl,
	NULL,  /* mmap */
	&cm_dmfm_open,
	NULL,	/* flush */
	&cm_dmfm_release,
	NULL,  /* fsync */
	NULL,  /* fasync */
	NULL,  /* check_media_change */
	NULL,  /* revalidate */
	NULL,  /* lock */
#endif
};
#endif /* CONFIG_SOUND_CMPCI_FM */

/* --------------------------------------------------------------------- */

/* maximum number of devices */
#define NR_DEVICE 5

#if 0
static int reverb[NR_DEVICE] = { 0, };

static int wavetable[NR_DEVICE] = { 0, };
#endif

/* --------------------------------------------------------------------- */

static struct initvol {
	int mixch;
	int vol;
} initvol[] __initdata = {
	{ SOUND_MIXER_WRITE_CD, 0x4040 },
	{ SOUND_MIXER_WRITE_LINE, 0x4040 },
	{ SOUND_MIXER_WRITE_MIC, 0x4040 },
	{ SOUND_MIXER_WRITE_SYNTH, 0x4040 },
	{ SOUND_MIXER_WRITE_VOLUME, 0x4040 },
	{ SOUND_MIXER_WRITE_PCM, 0x4040 }
};

#ifdef CONFIG_SOUND_CMPCI_MIDI
static	int	mpu_io = CONFIG_SOUND_CMPCI_MPUIO;
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
static	int	fm_io = CONFIG_SOUND_CMPCI_FMIO;
#endif
#ifdef CONFIG_SOUND_CMPCI_SPDIFLOOP
static	int	spdif_loop = 1;
#else
static	int	spdif_loop = 0;
#endif
#ifdef CONFIG_SOUND_CMPCI_4CH
static	int	four_ch = 1;
#else
static	int	four_ch = 0;
#endif
#ifdef CONFIG_SOUND_CMPCI_REAR
static	int	rear_out = 1;
#else
static	int	rear_out = 0;
#endif
#ifdef CONFIG_SOUND_CMPCI_PCTEL
static	int	modem = 1;
#else
static	int	modem = 0;
#endif
#ifdef CONFIG_SOUND_CMPCI_JOYSTICK
static	int	joystick = 1;
#else
static	int	joystick = 0;
#endif
#ifdef MODULE
MODULE_PARM(mpu_io, "i");
MODULE_PARM(fm_io, "i");
MODULE_PARM(spdif_loop, "i");
MODULE_PARM(four_ch, "i");
MODULE_PARM(rear_out, "i");
MODULE_PARM(modem, "i");
MODULE_PARM(joystick, "i");
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
int __init init_module(void)
#else
__initfunc(int init_module(void))
#endif
#else
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
int __init init_cmpci(void)
#else
__initfunc(int init_cmpci(void))
#endif
#endif
{
	struct cm_state *s;
	struct pci_dev *pcidev = NULL;
	mm_segment_t fs;
	int i, val, index = 0;
#ifdef CONFIG_SOUND_CMPCI_MIDI
	unsigned char reg_mask = 0;
#endif
	struct {
		unsigned short	deviceid;
		char		*devicename;
	} devicetable[] =
	{
		{ PCI_DEVICE_ID_CMEDIA_CM8338A, "CM8338A" },
		{ PCI_DEVICE_ID_CMEDIA_CM8338B, "CM8338B" },
		{ PCI_DEVICE_ID_CMEDIA_CM8738,  "CM8738" },
		{ PCI_DEVICE_ID_CMEDIA_CM8738B, "CM8738B" },
	};
	char	*devicename = "unknown";

#ifdef CONFIG_PCI
	if (!pci_present())   /* No PCI bus in this machine! */
#endif
		return -ENODEV;
	printk(KERN_INFO "cm: version $Revision: 4.3 $ time " __TIME__ " " __DATE__ "\n");
#if 0
	if (!(wavetable_mem = __get_free_pages(GFP_KERNEL, 20-PAGE_SHIFT)))
		printk(KERN_INFO "cm: cannot allocate 1MB of contiguous nonpageable memory for wavetable data\n");
#endif
	while (index < NR_DEVICE && pcidev == NULL && (
 	       (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A, pcidev)) ||
	       (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B, pcidev)) ||
	       (pcidev = pci_find_device(PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738, pcidev)))) { 
		if (pcidev->irq == 0)
			continue;
		if (!(s = kmalloc(sizeof(struct cm_state), GFP_KERNEL))) {
			printk(KERN_WARNING "cm: out of memory\n");
			continue;
		}
		/* search device name */
		for (i = 0; i < sizeof(devicetable) / sizeof(devicetable[0]); i++)
		{
			if (devicetable[i].deviceid == pcidev->device)
			{
				devicename = devicetable[i].devicename;
				break;
			}
		}
		memset(s, 0, sizeof(struct cm_state));
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		init_waitqueue_head(&s->dma_adc.wait);
		init_waitqueue_head(&s->dma_dac.wait);
		init_waitqueue_head(&s->open_wait);
		init_waitqueue_head(&s->midi.iwait);
		init_waitqueue_head(&s->midi.owait);
		init_MUTEX(&s->open_sem);
#else
		init_waitqueue(&s->dma_adc.wait);
		init_waitqueue(&s->dma_dac.wait);
		init_waitqueue(&s->open_wait);
		init_waitqueue(&s->midi.iwait);
		init_waitqueue(&s->midi.owait);
		s->open_sem = MUTEX;
#endif
		spin_lock_init(&s->lock);
		s->magic = CM_MAGIC;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
		s->iobase = pcidev->resource[0].start;
#else
		s->iobase = pcidev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		s->iosynth = fm_io;
#endif
#ifdef CONFIG_SOUND_CMPCI_MIDI
		s->iomidi = mpu_io;
#endif
#ifdef DUAL_DAC
		s->dual_mode = 0;
		s->hw_dual_dac = (pcidev->device == PCI_DEVICE_ID_CMEDIA_CM8738B);
#endif
		s->four_ch = four_ch;
		if (s->iobase == 0)
			continue;
		s->irq = pcidev->irq;

		if (check_region(s->iobase, CM_EXTENT_CODEC)) {
			printk(KERN_ERR "cm: io ports %#x-%#x in use\n", s->iobase, s->iobase+CM_EXTENT_CODEC-1);
			goto err_region5;
		}
		request_region(s->iobase, CM_EXTENT_CODEC, "cmpci");
#ifdef CONFIG_SOUND_CMPCI_MIDI
		if (s->iomidi)
		{
		    if (check_region(s->iomidi, CM_EXTENT_MIDI)) {
			printk(KERN_ERR "cm: io ports %#x-%#x in use\n", s->iomidi, s->iomidi+CM_EXTENT_MIDI-1);
			goto err_region4;
		    }
		    request_region(s->iomidi, CM_EXTENT_MIDI, "cmpci Midi");
		    /* set IO based at 0x330 */
		    switch (s->iomidi)
		    {
			case 0x330:
				reg_mask = 0;
				break;
			case 0x320:
				reg_mask = 0x20;
				break;
			case 0x310:
				reg_mask = 0x40;
				break;
			case 0x300:
				reg_mask = 0x60;
				break;
		    }
		    outb((inb(s->iobase + CODEC_CMI_LEGACY_CTRL + 3) & ~0x60) | reg_mask, s->iobase + CODEC_CMI_LEGACY_CTRL + 3);
		}
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		if (s->iosynth)
		{
		    if (check_region(s->iosynth, CM_EXTENT_SYNTH)) {
			printk(KERN_ERR "cm: io ports %#x-%#x in use\n", s->iosynth, s->iosynth+CM_EXTENT_SYNTH-1);
			goto err_region1;
		    }
		    request_region(s->iosynth, CM_EXTENT_SYNTH, "cmpci FM");
		    /* enable FM */
		    outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 2) | 8, s->iobase + CODEC_CMI_MISC_CTRL);
		}
#endif
		/* initialize codec registers */
		outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
		outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
		/* reset mixer */
		wrmixer(s, DSP_MIX_DATARESETIDX, 0);

		/* request irq */
		if (request_irq(s->irq, cm_interrupt, SA_SHIRQ, "cmpci", s)) {
			printk(KERN_ERR "cm: irq %u in use\n", s->irq);
			goto err_irq;
		}
		printk(KERN_INFO "cm: found %s adapter at io %#06x irq %u\n",
		       devicename, s->iobase, s->irq);
		/* register devices */
		if ((s->dev_audio = register_sound_dsp(&cm_audio_fops, -1)) < 0)
			goto err_dev1;
		if ((s->dev_mixer = register_sound_mixer(&cm_mixer_fops, -1)) < 0)
			goto err_dev2;
#ifdef CONFIG_SOUND_CMPCI_MIDI
		if ((s->dev_midi = register_sound_midi(&cm_midi_fops, -1)) < 0)
			goto err_dev3;
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		if ((s->dev_dmfm = register_sound_special(&cm_dmfm_fops, 15 /* ?? */)) < 0)
			goto err_dev4;
#endif
#ifdef DUAL_DAC
		if ((s->dev_dsp = register_sound_special(&cm_dsp_fops, 14)) < 0)
			goto err_dev5;
#endif
		pci_set_master(pcidev);	/* enable bus mastering */
		/* initialize the chips */
		fs = get_fs();
		set_fs(KERNEL_DS);
		/* set mixer output */
		frobindir(s, DSP_MIX_OUTMIXIDX, 0x1f, 0x1f);
		/* set mixer input */
		val = SOUND_MASK_LINE|SOUND_MASK_SYNTH|SOUND_MASK_CD|SOUND_MASK_MIC;
		mixer_ioctl(s, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
		for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
			val = initvol[i].vol;
			mixer_ioctl(s, initvol[i].mixch, (unsigned long)&val);
		}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
		set_fs(fs);
#endif
		if (pcidev->device == PCI_DEVICE_ID_CMEDIA_CM8738)
		{
			s->modem = modem;
			if (modem)
			{
				/* enable FLINKON and disable FLINKOFF */
				outb(inb((s->iobase + CODEC_CMI_MISC_CTRL) | 0x80) & ~0x40, s->iobase + CODEC_CMI_MISC_CTRL);
				printk(KERN_INFO "cm: modem function supported\n");
			}
			/* enable SPDIF loop */
			if (spdif_loop)
			{
				/* turn on spdif-in to spdif-out */
				outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) | 0x80, s->iobase + CODEC_CMI_FUNCTRL1);
				printk(KERN_INFO "cm: Enable SPDIF loop\n");
			}
			else
				outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) & ~0x80, s->iobase + CODEC_CMI_FUNCTRL1);
			/* enable 4 channels mode */
			if (four_ch)
			{
				/* 4 channel mode (analog duplicate) */
				outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 3) | 0x04, s->iobase + CODEC_CMI_MISC_CTRL + 3);
				printk(KERN_INFO "cm: Enable 4 channels mode\n");
				/* has separate rear-out jack ? */
				if (rear_out)
				{
					/* has separate rear out jack */
					outb(inb(s->iobase + CODEC_CMI_MIXER1) & ~0x20, s->iobase + CODEC_CMI_MIXER1);
				}
				else
				{
					outb(inb(s->iobase + CODEC_CMI_MIXER1) | 0x20, s->iobase + CODEC_CMI_MIXER1);
					printk(KERN_INFO "cm: line-in routed as rear-out\n");
				}
			}
			else
				outb(inb(s->iobase + CODEC_CMI_MISC_CTRL + 3) & ~0x04, s->iobase + CODEC_CMI_MISC_CTRL + 3);
		}
		/* enable joystick */
		if (joystick)
			outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) | 0x02, s->iobase + CODEC_CMI_FUNCTRL1);
		else
			outb(inb(s->iobase + CODEC_CMI_FUNCTRL1) & ~0x02, s->iobase + CODEC_CMI_FUNCTRL1);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
		set_fs(fs);
#endif
		/* queue it for later freeing */
		s->next = devs;
		devs = s;
		index++;
		continue;

#ifdef DUAL_DAC
	err_dev5:
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		unregister_sound_special(s->dev_dmfm);
	err_dev4:
#endif
#ifdef CONFIG_SOUND_CMPCI_MIDI
		unregister_sound_midi(s->dev_midi);
	err_dev3:
#endif
		unregister_sound_mixer(s->dev_mixer);
	err_dev2:
		unregister_sound_dsp(s->dev_audio);
	err_dev1:
		printk(KERN_ERR "cm: cannot register misc device\n");
		free_irq(s->irq, s);
	err_irq:
#ifdef CONFIG_SOUND_CMPCI_FM
		if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
	err_region1:
#endif
#ifdef CONFIG_SOUND_CMPCI_MIDI
		if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
	err_region4:
#endif
		release_region(s->iobase, CM_EXTENT_CODEC);
	err_region5:
		kfree_s(s, sizeof(struct cm_state));
	}
	if (!devs) {
		if (wavetable_mem)
			free_pages(wavetable_mem, 20-PAGE_SHIFT);
		return -ENODEV;
	}
	return 0;
}

/* --------------------------------------------------------------------- */

#ifdef MODULE

#if 0
MODULE_PARM(wavetable, "1-" __MODULE_STRING(NR_DEVICE) "i");
MODULE_PARM_DESC(wavetable, "if 1 the wavetable synth is enabled");
#endif

MODULE_AUTHOR("ChenLi Tien, cltien@home.com");
MODULE_DESCRIPTION("CMPCI Audio Driver");

void cleanup_module(void)
{
	struct cm_state *s;

	while ((s = devs)) {
		devs = devs->next;
		outb(0, s->iobase + CODEC_CMI_INT_HLDCLR + 2);  /* disable ints */
		synchronize_irq();
		outb(0, s->iobase + CODEC_CMI_FUNCTRL0 + 2); /* disable channels */
		free_irq(s->irq, s);
#ifdef FIXEDDMA
    		dealloc_dmabuf(&s->dma_dac);
    		dealloc_dmabuf(&s->dma_adc);
#endif

		/* reset mixer */
		wrmixer(s, DSP_MIX_DATARESETIDX, 0);

		release_region(s->iobase, CM_EXTENT_CODEC);
#ifdef CONFIG_SOUND_CMPCI_MIDI
		if (s->iomidi) release_region(s->iomidi, CM_EXTENT_MIDI);
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		if (s->iosynth) release_region(s->iosynth, CM_EXTENT_SYNTH);
#endif
		unregister_sound_dsp(s->dev_audio);
		unregister_sound_mixer(s->dev_mixer);
#ifdef CONFIG_SOUND_CMPCI_MIDI
		unregister_sound_midi(s->dev_midi);
#endif
#ifdef CONFIG_SOUND_CMPCI_FM
		unregister_sound_special(s->dev_dmfm);
#endif
#ifdef DUAL_DAC
		unregister_sound_special(s->dev_dsp);
#endif
		kfree_s(s, sizeof(struct cm_state));
	}
	if (wavetable_mem)
		free_pages(wavetable_mem, 20-PAGE_SHIFT);
	printk(KERN_INFO "cm: unloading\n");
}

#endif /* MODULE */

下载软件源码：

cmpci-4.03.tar.gz

DOSBOX-X 含调试器的DOS模拟器。

Sun, 25 Feb 2024 10:53:13 +0800

DOSBOX-X的模拟器下载地址：

https://github.com/joncampbell123/dosbox-x/releases

很舒服的一个界面，DOS下程序都可以使用，兼容DOSBOX，比DOSBOX多一个调试器。这点很吸引眼球。

一个颜色块的游戏策划。

Fri, 23 Feb 2024 10:24:04 +0800

说实在的，我原来写过数据库程序，现在的话也会设计一些图画。过年好，新年刚刚开始。

我来策划一个颜色块的视觉游戏吧。

这个游戏色块游戏是色块找相同。

也就是说找两个颜色相近的或者相同的色块。

你知道这个颜色的话，人类在很不在意的时候的话会分辨成相同颜色。

但是作为一个设计师来说颜，颜色的一点点差别都要分辨清楚。

那个色彩的相同会使工作中断之后仍然能做好看。

人的眼睛会分辨很多颜色。然后眼睛的受体是黄斑，但黄斑就是感觉细胞。人的色感细胞分三种，所以说能识别三种颜色。

很多动物的眼睛跟我们不一样。但我们识别万物的颜色就这三种。人们游戏训练后将会怎样，我也不太清楚。

显示器的颜色分类三种颜色。显示器的温度也有色温差。其实在我们的现实世界中，颜色是千变万化的。这个颜色系数并不稳定。

但是色彩的改变的感觉相差极少。小到感觉并不存在。

我们以红蓝绿为主。主要是这三种颜色有细胞直接看全。

把显示器的颜色不代表万物的颜色。只是三种颜色的混杂度。

所以说我们对显示器来说更直接。

按道理来说，人类的眼睛是喜欢光的。

色彩分冷色系和暖色系。

色彩还有纯度之说。

色彩的识别有个圆盘理论。

只身过径河，那里的公园还不错。

Mon, 29 Jan 2024 16:04:56 +0800

马厩山公园和莲花湖公园

这里是公园雕塑，积极向上

人过独本桥，哪能不跌倒，是可以扶的

中国穿花，缕空建筑。

很简单的木桥，其它的地方没有，仿邻乡石桥建设

公园旁的博物馆，可以在这里买蜂蜜，买点食物和香火。看看历史文物

是小学生以前必来的春游的地方，教育小学生，从小简朴，生活朴素。

山水亭，那有些草可以他用，公园的草木不要动，留给当地人。

哪能把公园做为已有，只能过来走走

家庭的水帘墙的造型，加一个建筑表现一下，上得庭堂，以天地为家，细竹开花节节高。

莲花湖的桥，地方不大可以养鱼，领导，你说怎办，原生态就这一点点，还是人造。夏天这里有柳条。

这石路是一个视觉效果，有些人是有特效技术的。这是一个人的视觉技术的体现。

山茶花，你看这个茶花是不是比灌木丛要好一点，没事可以做做茶。

姜太公钓鱼，这是钓鱼的地方，分季节，先生，钓鱼吗？来了不要吵。

这里的人不太多，是领导过来换心情的地方。随便走走就可以了。观音静坐观心之地

木板用得不多，不是你家的东西，有点缺点，但是不太引人注意。你说的可以提，以后再说，现在喜欢就行。

你说这是正门还是后门，反正鲤鱼也精，可以大得和小娃娃一起玩。

跑路的路，这里可以比赛，小孩子的公路赛

像不像街机游戏F1赛车跑道，是这样子考虑的，孩子乖。

一个64位汇编的例子。

Sun, 28 Jan 2024 05:49:25 +0800

;cmdline.asm
extern printf
section .data
	msg db "The command and arguments:",10,0
	fmt  db "%s",10,0
section .bss
section .text
	global main
main:
	push rbp
	mov rbp,rsp
	mov r12,rdi	;参数数量
	mov r13,rsi	;参数数组的地址
	; 打印标题
	mov rdi,msg
	call printf
	mov r14,0
	; 打印命令和参数
.ploop:
	mov rdi,fmt
	mov  rsi,qword [r13+r14*8]
	call printf
	inc r14
	cmp r14,12	; 参数数量达到了吗？
	jl  .ploop
	; leave		; 权3以后无效，权0差配对
	ret

这个例子说明了64位汇编的编法，那些用函数的注意64位函数的参数第5个参数，第6个参数，使用调试软件调试一下。

不解释，64位汇编是系统用的汇编。合理使用汇编语言编译器，没事自已改改编译器，拥有自已的那套规则就正常了。

那跨平台的程序是跨了又跨，那字符终端字符平台一开始一定要的。

一个自已的系统也许老套只要三个文件或者一个区块。然后加上应用的自已的编译器，调试器就可以了。

很多可以参考windows 32[中文版]这套系统。你会发现以前的不是很难，现在看起来很容易。但是要时间。

64位的系统，一样32位寻址和计算，说实话，一些程序32程序已经可以了，信不信128位也只是带个地址，想了又想，实在是没有必要的事情。

64位和128位的计算很多只是讲讲速度。是电脑的数据流派。硬计算和按位读取，存入再计算要快得多。

一个游戏也许只有4Kb字节，16Kb字节，你看多年以前的任天堂FC红白机的卡带。内容很紧，储存并不多，够用就行。

很多事情就是界面，图形，视频，那些计算机中做出来的图片什么的，也是功夫茶。占内存的就是这些东西，大多没有其它。

Intel 处理器中的电脑调用函数call ，enter, syscall。

Tue, 16 Jan 2024 17:35:14 +0800

说实话，计算机程序中有很多调用。这个调用可以理解为程序分支或子函数。

先说call 调用子函数，call调用子函数分近调用和远调用。也就是返回的地址有8位16位32位。

call, ret;

call, retf;

call,retn;

这几种伪汇编方法，其中调用sp指针堆栈中的返回地址。是8位16位32位寻址的计算机系统的用法。

enter是16位，32位的调用。它的系统使用对是enter,level。

enter,level

enter 2,256

level

enter 后面是有两组数字的，这个是进入函数的堆的大小和缓冲区大小，也就是为另一程序开拓一个程序空间，理解为程序空间调用就可以了。

那个syscall 也不错，这个理解

syscall 到一定段自动返回。

CPU的十个指头。

Wed, 03 Jan 2024 08:17:27 +0800

话说CPU是计算机的中央处理器，是计算机的核心部分，有人想把所有的东西都集成到一个CPU中，我想，那单片机能做到的事情，我们的台式机也可以做到。

因为现在说的是CPU的模块，那CPU的超大规模集成块也是有“小岛”的，也就是很多器件已经被固定认可，然后可以拼接。打开CPU的铁盖，那是屏蔽信号的。一个单元一个单元的，一个CPU模块中可以放多个处理单元。也就是多模。这就会产生各个型号，各个规格的CPU。

CPU的寄存器也可以模组出来，比如另外加一组锁相器，位移器等，小单元就会多一些特别的寄存器，这样剖析，那CPU的电路就很简单了，听说CPU中的电子元件上万上亿，说起来，那是相同的电路组成多，没有什么难的，了解原理，那CPU就做起来非常容易。当然要硬件硬道理的。

那CPU的电路图要做成照片或者通过光学原理照到晶原上面，晶原是二氧化硅的纯结晶，二氧化硅的层要做出来，还要很纯净的那种，所以从零开始是很难的，已经快到百年历史了。现在中国的光刻机什么的，也是初始，也就是另外一种电路的技术，那以前是通过其它方法做成的，要分解等，经过很多处理，像洗照片一样。一个晶原做出来成本很高，还有晶原的切割技术，切不好坏一整片晶原。所有的集成电路没对齐的损坏。还有微尘。

那洁净的空间是要的，光空气洁净还不行的，如果有人进了没有灰尘的洁净空间，那人呼出的一口气中，包含了很多细胞和细菌的。当然空气中的1个细菌睡在晶片上，那是要占领好多电路啊！所以说洁净空间是要戴口罩，再洁净点防护服，防自已的微垃圾对洁净空间有影响，再洁净点，那就是机器人等了。那空气的一个细菌或者一个灰尘很孤独啊，一个细菌相对另一个细菌是一千里的路。

当然，那CPU芯片上也会有小暗门，比如一个电感。一个发光二极管等等。可以通过旁路测试CPU的情况。那测试点一定是有的，防止CPU会有错误，那散装和盒装的还是不一样，盒装是测试过的CPU。一般CPU也有容错性。也就是出错再计算。这也就说明白了计算机运行软件有时会卡机。一般是主板或CPU上的电容有问题，CPU上的问题并不主要，只是耗电和计算变慢。那主板的分立电容8年一定会坏的，问过周围每个使用电脑的人的，很少人有连续使用8年的电脑。总有相关电路会坏，过压，失效，死机，等等。那也就是说，低电压工作的电脑不会让电脑过于老化。但是那些稳定电路的一些特殊元件，元件有值差，维修是很难还原那些值的，只能说是可用，但是达不到理想值。

多核处理，也就是在CPU中加上多个处理单元，然后用一个分发器分发到每一个处理单元，这就是多核的简单说法，看技术资料没有硬件这个角度理解快。但是很多使用方法看资料不用红烧脑袋，轻轻松松。那INTEL的资料的编写角度和AMD资料的编写角度不一样啊，没事比较一下又开阔了很多，虽然技术绝大部分是相同的，但是编写的资料层面不同啊！编写阐述的角度的主次不同。

现在很多操作系统的系统软件没有使用CPU其它的寄存器，要知道以前，当少一个ES寄存器，CPU的机器语言汇编有多难。很难扩展。现在为了提速和扩展，批量加速处理数据，后来的寄存器是一组一组的。

可以这样看，那些机器码的指令只是换个方法，用助记符表示电路的开关而已。

可以这样说，那机器指令码的格式是通的。一定的长度，执行一定的功能。这样看，把指令用“刀”切几块，这个电路一块，那个电路一块，你就明白了指令的格式是怎么来的了，为什么都差不多。

自从奔腾CPU也就是586以后，就没有这种编号了，出的处理器是为了处理高速度的视频流，声音流之类的数据流，而不是数据记录。所以有了MMX寄存器，MMX寄存器是64位的，可以扩展到64位的地址上来，也就是有些地方可以通过MMX这个寄存器越权，操作系统不知道现在在管理吗？是一个操作系统上的漏洞。现在的XMM和YMM还有ZMM是MMX寄存器的复用，扩展之后的MMX啊64位128位256位和512位，现在是512位了，刚刚可以处理MPG的视频编码不用谈速度。

一个CPU上插上一小块外设主板，就是一台电脑了，很简单，会淘汰一些大型的电脑周边的公司。越尖端，看上去越简单！！！

上个月上传文章缓冲坏了。连续的电脑问题是010脚本。

Mon, 04 Dec 2023 23:51:41 +0800

我们来谈谈010脚本吧。

010是一个文本编辑器，是一个很老牌好用的一个编辑器，可能说是名列前茅的编辑器。我认为是第一，没有第二。

当然也有那winhex编辑器，不好区分啊。010的脚本可扩展。这点是第一的。要有其它思想你就知道010的强大功能了。

010编辑器可以看2进制，可以看16进制，当加上自己的脚本的时候那功能十分强。

在文本方面可以有文本编辑的很多加强功能。

我可以说梦幻的一面，那有个插件文本010的一个缺点。脚本缺点。也就是有个插件叫ISASIIC。这个处理脚本。

这个脚本和模板是有区别的。脚本可以执行和处理文件，模板化，可以显示和区分文件内容格式。

PS:说这些话，那金钱是没有的，盯的人很多，圣诞前夜快到了，还是预祝你们这些看客圣诞快乐，捣蛋的孩子们还是别太顽皮了。

成年人呢，也就默默的逛逛吧。圣诞老人不可能把礼物送到每个小朋友。他很忙，那些小朋友的爸爸是可以为小朋友准备的。

话外以后。。。

那模板可以看二进制和文件包内容还有执行文件头。很有用的。可以复制一些SMC补丁。

这个脚本缺点是不认同其它的国家的语言，只认英语啊，说实话是我们国家的人去外国发展成为外国的独立公司的。和一些外国大公司都曾经有过联系。

以前这个beyond公司是发展系统安装程序起步和起家的。有些软件并没有公开，软件很小，速度很快，真的很棒，是外国的公司，也已是外国人。

是的，比如中文可以在中文widnows中使用国标字符让windows 识别，但是那注释部分一定要是英文，不然脚本不通过。

ISASIIC这个脚本是可以识别一些不能执行的模块和语句的。滤化脚本，避免出错，可以解决很多问题。

为什么双字符系统比单字ansi字符集容易被侵入（漫谈，路漫漫）

Tue, 14 Nov 2023 01:59:08 +0800

说实话我们国家是宽字符，双字节的文字，很多国家用的是单字节的字符集，是ansi字符集。

那双字节系统为什么会被入侵？

说实话，双字符文字和语言是转义过的的语言。两个字节可以容纳更多的字符串。

一些字符集是双字的。也就是刚好是一个跳转指令的指令宽度。

比如单字符的ansi字符集，如果没有转义，那么那就是那个字符，在命令行终端，如果不在终端执行命令是不可能入侵的。

实际点双字节的也不太会有问题，但是很多系统会有字符集的识别，也就是我用的是简体中文，有时候也会通过其它程序覆盖成繁体。

有时候那字符串是什么就是什么。两个汉字如果以一半字符开头，会产生乱码。也就是说，可以异构指令执行。那些文字是指令。

还有一个就是源机和目的机的信任。只要安装受信软件系统，那些字符和指令在中间反复加密到目标机也是原指令的。

双字符系统还有一个问题，就是有些共享库可以帮助你把字符反复刷成正确的，可以显示的结果，说实话，两个不相关的字符，也可以在被过滤的情况合成另一种指令。

再说真正的实话，一些系统为了远方管理方便，是留有管理后台的。因为上一次服务器的路实际要走很远。

说实话，一个操作系统中，一个使用电脑的真的会在电脑上创造价值吗？我思考了一下。

一般最初是文字输入吧，把文字整理成一些漂亮的书稿和介绍。在实际中相互沟通。

再就是程序，我的系统我管理一下，记一下数据和资料。管理一下实物。电脑本来就是这样使用的。

如有互联。那系统应是公共的平台，没什么内容，只是介绍了。一个公司的介绍，让你来访。

很多实际的资料是不公开的。资料很多。开放在某时段，有时会定向IP。有双加密登录密码和密码有时间。不是长期联通。也行，没问题的。

那些网上被入侵的是很公开的单位，入侵后有升级。是一种进化的升级，公共平台被黑了解之后只会重启，那些查询系统前台，重启就可以了。

说实话，看别人的东西有四种可能，两边都不发展，两边，你发展我不发展，两边都发展的四种。看生活和工作时间段。

一句话不要太依赖网络，外面的世界精彩更多。网络什么都可以，是皮毛，是介绍啊。在网上不能自理生活，只能告诉你自理方法。

那字符的转义也就是显示一个字符的方式问题，很多种数据编排方式，通过一定的方法都可以显示成看得懂的语言，也就是大字符集的数据越多，那入侵比就越高。

那英文，或者法文。字符集也就256字符那么大，还可以半字符集，也就是128个字符，你说用这种字符集改系统，运行程序有多难。同样的问题，也比其它的亚洲字符集难很多的。

还有那程序的版本问题，越便利越有疏忽，也就是识别有个缝。比如指令的 JNZ 或 JNA 等等原始的跳转，这个汇编指令是占两个字节的。

其中指令其它问题是，那个指令不见得会判断准确，肯定一个时，其它的所有也就否定了，这只是一个逻辑问题。谁也会留下逻辑问题，遇到这些指令的时候。

那JNZ是不为零还是相等跳转。这一直是程序员自己思考的问题。当想法出缝了，那漏一定是有的。是进位跳，还是置位跳，还是大于跳转，也是个问题啊。

其中有相等大于跳转，和直接大于跳转的问题，如果程序处理到下一步了，那其它的数据怎么控制？说实话，一般的规则数据是可以正常的，那些不规则的数据也就漏了。

也就是字符那系统文件的路径符号“/"也会拦不住，还有，一个远程的用户，我把他看成本地的了。一个普通的用户，我看成管理者了。

信不信，有些系统服务是方便管理的。那些保留的指令和保留的空间还有那保留的指令，可以让你使用和操作更加方便。要不然，那些软件什么的，也就发展不了的。

你要知道，苹果公司的苹果CPU系统，就是在原来的CPU上加了一个附加ES段寄存器让程序有个海阔天空的，可以有更大的发展，原来的CPU是2k到4k啊，加系统只8k

所以那寄存器，一直在发展，很多寄存器现在是留空的状态。系统也不太使用。

当我们使用这些寄存器时，你就知道。我可以看你的电脑上其它的数据，如早期的64位数据指令"MMX"系列，可以寻址的64位指令。也就是越权寄存器。操作系统很少使用的。

也就是系统的缝在那些不常使用的寄存器上。

实际的16位系统和32位的系统的转换也可以用跳转实现，那就是多8位的跳转指令啊，原址8位移就可以了。地址转换也就是在位移之间。

还有为什么32位的和64位的程序软件功能一样使用一样不能两个系统实际互用？因为执行的程序的格式不一样的。也就是把软件安装到系统的空间中。

那为什么又可以通用呢，那就是64位的系统只是引导32位的软件进系统，用32位的方式运行啊。实话可以这样说，在64位的系统中，只有数据是64位以上的，那些指令集，

32位的指令集已经很宽松了，想用就用。64位的指令很多空零，你用吗？占用内存。所以在64位的内存映射中，那些数据都很零散。所以，那4G以上的内存都很富有了。

当然是单机个人使用的情况，也就是说，很多内存，你不打理自己的电脑，是会被别人使用的，也就是入侵多用户行为。生活很无聊的，我在看你在做什么。

当然，刚才说了四种进步情况。习惯使用别人的电脑好吗？我也不知道，我只知道自己有电脑吧？一个人使用两台电脑，一个自己的一个别人的，当没网的时候是不是感觉像抽烟。

说实话，就是单机电脑也会上瘾的。那些游戏很不错啊。更何况是在网络上和别人较板？你的考试现在已及格，那下次考试呢？你在做什么？还是幼稚园，还是小学生，还是中学生吗？

当进入社会，人可以生存了，那应该是大学生呀。人是相对独立的，不要依赖哥。听网上的风在说，哥只是一个传说。该丟掉马桶出去了。（一个病院的故事：电影：法国）

对了，我的东西整理好了，你弄乱了，那整理的资料，你是不是得到后也整理了？发展一下吧？我在做别的事，那个接力的红白小棍棍交你了。是队友还是别人的队友。

我们就算是比赛，你也不应该拿别人的棒棒吧？棒子都一样，你帮我跑完算了。生活很累。天冷了，我还在家里畏被。很轻松啊。人已老，时间已逝，那些电脑上的成品，半成品。

你变价值了吗？很多可用的软件很简单，只是一个工具。电脑只能这样。让你在家中获得一些信息流。电影，新闻，在家里让你享受够。有些地方我已经有。这是我做的，让你也有拥有的感觉。

感觉一样，你有我有大家有啊。那种花的种完，你过来拍照，都有啊！！！然后，那照片很好看。美女，帅哥在找另一半。