Eric Lee / smarc-fsl-linux-kernel

Commit f23f6e08c47acbdd20e9c49a79da8c404ea168e1

Authored by Al Viro 19 years ago

Exists in master and in 40 other branches

[PATCH] severing poll.h -> mm.h

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 12 changed files with 13 additions and 1 deletions Inline Diff

drivers/char/hpet.c
drivers/media/dvb/cinergyT2/cinergyT2.c
include/linux/poll.h
include/sound/pcm.h
sound/oss/cs46xx.c
sound/oss/dmabuf.c
sound/oss/emu10k1/audio.c
sound/oss/es1371.c
sound/oss/i810_audio.c
sound/oss/soundcard.c
sound/oss/sscape.c
sound/oss/trident.c

drivers/char/hpet.c

Diff comments View file @ f23f6e0

 /*
  * Intel & MS High Precision Event Timer Implementation.
  *
  * Copyright (C) 2003 Intel Corporation
  *	Venki Pallipadi
  * (c) Copyright 2004 Hewlett-Packard Development Company, L.P.
  *	Bob Picco <robert.picco@hp.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/miscdevice.h>
 #include <linux/major.h>
 #include <linux/ioport.h>
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
+#include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
 #include <linux/sysctl.h>
 #include <linux/wait.h>
 #include <linux/bcd.h>
 #include <linux/seq_file.h>
 #include <linux/bitops.h>
 #include <asm/current.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/div64.h>
 #include <linux/acpi.h>
 #include <acpi/acpi_bus.h>
 #include <linux/hpet.h>
 /*
  * The High Precision Event Timer driver.
  * This driver is closely modelled after the rtc.c driver.
  * http://www.intel.com/hardwaredesign/hpetspec.htm
  */
 #define	HPET_USER_FREQ	(64)
 #define	HPET_DRIFT	(500)
 #define HPET_RANGE_SIZE		1024	/* from HPET spec */
 static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
 /* A lock for concurrent access by app and isr hpet activity. */
 static DEFINE_SPINLOCK(hpet_lock);
 /* A lock for concurrent intermodule access to hpet and isr hpet activity. */
 static DEFINE_SPINLOCK(hpet_task_lock);
 #define	HPET_DEV_NAME	(7)
 struct hpet_dev {
 	struct hpets *hd_hpets;
 	struct hpet __iomem *hd_hpet;
 	struct hpet_timer __iomem *hd_timer;
 	unsigned long hd_ireqfreq;
 	unsigned long hd_irqdata;
 	wait_queue_head_t hd_waitqueue;
 	struct fasync_struct *hd_async_queue;
 	struct hpet_task *hd_task;
 	unsigned int hd_flags;
 	unsigned int hd_irq;
 	unsigned int hd_hdwirq;
 	char hd_name[HPET_DEV_NAME];
 };
 struct hpets {
 	struct hpets *hp_next;
 	struct hpet __iomem *hp_hpet;
 	unsigned long hp_hpet_phys;
 	struct time_interpolator *hp_interpolator;
 	unsigned long long hp_tick_freq;
 	unsigned long hp_delta;
 	unsigned int hp_ntimer;
 	unsigned int hp_which;
 	struct hpet_dev hp_dev[1];
 };
 static struct hpets *hpets;
 #define	HPET_OPEN		0x0001
 #define	HPET_IE			0x0002	/* interrupt enabled */
 #define	HPET_PERIODIC		0x0004
 #define	HPET_SHARED_IRQ		0x0008
 #if BITS_PER_LONG == 64
 #define	write_counter(V, MC)	writeq(V, MC)
 #define	read_counter(MC)	readq(MC)
 #else
 #define	write_counter(V, MC) 	writel(V, MC)
 #define	read_counter(MC)	readl(MC)
 #endif
 #ifndef readq
 static inline unsigned long long readq(void __iomem *addr)
 {
 	return readl(addr) | (((unsigned long long)readl(addr + 4)) << 32LL);
 }
 #endif
 #ifndef writeq
 static inline void writeq(unsigned long long v, void __iomem *addr)
 {
 	writel(v & 0xffffffff, addr);
 	writel(v >> 32, addr + 4);
 }
 #endif
 static irqreturn_t hpet_interrupt(int irq, void *data)
 {
 	struct hpet_dev *devp;
 	unsigned long isr;
 	devp = data;
 	isr = 1 << (devp - devp->hd_hpets->hp_dev);
 	if ((devp->hd_flags & HPET_SHARED_IRQ) &&
 	    !(isr & readl(&devp->hd_hpet->hpet_isr)))
 		return IRQ_NONE;
 	spin_lock(&hpet_lock);
 	devp->hd_irqdata++;
 	/*
 	 * For non-periodic timers, increment the accumulator.
 	 * This has the effect of treating non-periodic like periodic.
 	 */
 	if ((devp->hd_flags & (HPET_IE | HPET_PERIODIC)) == HPET_IE) {
 		unsigned long m, t;
 		t = devp->hd_ireqfreq;
 		m = read_counter(&devp->hd_hpet->hpet_mc);
 		write_counter(t + m + devp->hd_hpets->hp_delta,
 			      &devp->hd_timer->hpet_compare);
 	}
 	if (devp->hd_flags & HPET_SHARED_IRQ)
 		writel(isr, &devp->hd_hpet->hpet_isr);
 	spin_unlock(&hpet_lock);
 	spin_lock(&hpet_task_lock);
 	if (devp->hd_task)
 		devp->hd_task->ht_func(devp->hd_task->ht_data);
 	spin_unlock(&hpet_task_lock);
 	wake_up_interruptible(&devp->hd_waitqueue);
 	kill_fasync(&devp->hd_async_queue, SIGIO, POLL_IN);
 	return IRQ_HANDLED;
 }
 static int hpet_open(struct inode *inode, struct file *file)
 {
 	struct hpet_dev *devp;
 	struct hpets *hpetp;
 	int i;
 	if (file->f_mode & FMODE_WRITE)
 		return -EINVAL;
 	spin_lock_irq(&hpet_lock);
 	for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next)
 		for (i = 0; i < hpetp->hp_ntimer; i++)
 			if (hpetp->hp_dev[i].hd_flags & HPET_OPEN
 			    || hpetp->hp_dev[i].hd_task)
 				continue;
 			else {
 				devp = &hpetp->hp_dev[i];
 				break;
 			}
 	if (!devp) {
 		spin_unlock_irq(&hpet_lock);
 		return -EBUSY;
 	}
 	file->private_data = devp;
 	devp->hd_irqdata = 0;
 	devp->hd_flags |= HPET_OPEN;
 	spin_unlock_irq(&hpet_lock);
 	return 0;
 }
 static ssize_t
 hpet_read(struct file *file, char __user *buf, size_t count, loff_t * ppos)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long data;
 	ssize_t retval;
 	struct hpet_dev *devp;
 	devp = file->private_data;
 	if (!devp->hd_ireqfreq)
 		return -EIO;
 	if (count < sizeof(unsigned long))
 		return -EINVAL;
 	add_wait_queue(&devp->hd_waitqueue, &wait);
 	for ( ; ; ) {
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irq(&hpet_lock);
 		data = devp->hd_irqdata;
 		devp->hd_irqdata = 0;
 		spin_unlock_irq(&hpet_lock);
 		if (data)
 			break;
 		else if (file->f_flags & O_NONBLOCK) {
 			retval = -EAGAIN;
 			goto out;
 		} else if (signal_pending(current)) {
 			retval = -ERESTARTSYS;
 			goto out;
 		}
 		schedule();
 	}
 	retval = put_user(data, (unsigned long __user *)buf);
 	if (!retval)
 		retval = sizeof(unsigned long);
 out:
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&devp->hd_waitqueue, &wait);
 	return retval;
 }
 static unsigned int hpet_poll(struct file *file, poll_table * wait)
 {
 	unsigned long v;
 	struct hpet_dev *devp;
 	devp = file->private_data;
 	if (!devp->hd_ireqfreq)
 		return 0;
 	poll_wait(file, &devp->hd_waitqueue, wait);
 	spin_lock_irq(&hpet_lock);
 	v = devp->hd_irqdata;
 	spin_unlock_irq(&hpet_lock);
 	if (v != 0)
 		return POLLIN | POLLRDNORM;
 	return 0;
 }
 static int hpet_mmap(struct file *file, struct vm_area_struct *vma)
 {
 #ifdef	CONFIG_HPET_MMAP
 	struct hpet_dev *devp;
 	unsigned long addr;
 	if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) || vma->vm_pgoff)
 		return -EINVAL;
 	devp = file->private_data;
 	addr = devp->hd_hpets->hp_hpet_phys;
 	if (addr & (PAGE_SIZE - 1))
 		return -ENOSYS;
 	vma->vm_flags |= VM_IO;
 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 	if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT,
 					PAGE_SIZE, vma->vm_page_prot)) {
 		printk(KERN_ERR "%s: io_remap_pfn_range failed\n",
 			__FUNCTION__);
 		return -EAGAIN;
 	}
 	return 0;
 #else
 	return -ENOSYS;
 #endif
 }
 static int hpet_fasync(int fd, struct file *file, int on)
 {
 	struct hpet_dev *devp;
 	devp = file->private_data;
 	if (fasync_helper(fd, file, on, &devp->hd_async_queue) >= 0)
 		return 0;
 	else
 		return -EIO;
 }
 static int hpet_release(struct inode *inode, struct file *file)
 {
 	struct hpet_dev *devp;
 	struct hpet_timer __iomem *timer;
 	int irq = 0;
 	devp = file->private_data;
 	timer = devp->hd_timer;
 	spin_lock_irq(&hpet_lock);
 	writeq((readq(&timer->hpet_config) & ~Tn_INT_ENB_CNF_MASK),
 	       &timer->hpet_config);
 	irq = devp->hd_irq;
 	devp->hd_irq = 0;
 	devp->hd_ireqfreq = 0;
 	if (devp->hd_flags & HPET_PERIODIC
 	    && readq(&timer->hpet_config) & Tn_TYPE_CNF_MASK) {
 		unsigned long v;
 		v = readq(&timer->hpet_config);
 		v ^= Tn_TYPE_CNF_MASK;
 		writeq(v, &timer->hpet_config);
 	}
 	devp->hd_flags &= ~(HPET_OPEN | HPET_IE | HPET_PERIODIC);
 	spin_unlock_irq(&hpet_lock);
 	if (irq)
 		free_irq(irq, devp);
 	if (file->f_flags & FASYNC)
 		hpet_fasync(-1, file, 0);
 	file->private_data = NULL;
 	return 0;
 }
 static int hpet_ioctl_common(struct hpet_dev *, int, unsigned long, int);
 static int
 hpet_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 	   unsigned long arg)
 {
 	struct hpet_dev *devp;
 	devp = file->private_data;
 	return hpet_ioctl_common(devp, cmd, arg, 0);
 }
 static int hpet_ioctl_ieon(struct hpet_dev *devp)
 {
 	struct hpet_timer __iomem *timer;
 	struct hpet __iomem *hpet;
 	struct hpets *hpetp;
 	int irq;
 	unsigned long g, v, t, m;
 	unsigned long flags, isr;
 	timer = devp->hd_timer;
 	hpet = devp->hd_hpet;
 	hpetp = devp->hd_hpets;
 	if (!devp->hd_ireqfreq)
 		return -EIO;
 	spin_lock_irq(&hpet_lock);
 	if (devp->hd_flags & HPET_IE) {
 		spin_unlock_irq(&hpet_lock);
 		return -EBUSY;
 	}
 	devp->hd_flags |= HPET_IE;
 	if (readl(&timer->hpet_config) & Tn_INT_TYPE_CNF_MASK)
 		devp->hd_flags |= HPET_SHARED_IRQ;
 	spin_unlock_irq(&hpet_lock);
 	irq = devp->hd_hdwirq;
 	if (irq) {
 		unsigned long irq_flags;
 		sprintf(devp->hd_name, "hpet%d", (int)(devp - hpetp->hp_dev));
 		irq_flags = devp->hd_flags & HPET_SHARED_IRQ
 						? IRQF_SHARED : IRQF_DISABLED;
 		if (request_irq(irq, hpet_interrupt, irq_flags,
 				devp->hd_name, (void *)devp)) {
 			printk(KERN_ERR "hpet: IRQ %d is not free\n", irq);
 			irq = 0;
 		}
 	}
 	if (irq == 0) {
 		spin_lock_irq(&hpet_lock);
 		devp->hd_flags ^= HPET_IE;
 		spin_unlock_irq(&hpet_lock);
 		return -EIO;
 	}
 	devp->hd_irq = irq;
 	t = devp->hd_ireqfreq;
 	v = readq(&timer->hpet_config);
 	g = v | Tn_INT_ENB_CNF_MASK;
 	if (devp->hd_flags & HPET_PERIODIC) {
 		write_counter(t, &timer->hpet_compare);
 		g |= Tn_TYPE_CNF_MASK;
 		v |= Tn_TYPE_CNF_MASK;
 		writeq(v, &timer->hpet_config);
 		v |= Tn_VAL_SET_CNF_MASK;
 		writeq(v, &timer->hpet_config);
 		local_irq_save(flags);
 		m = read_counter(&hpet->hpet_mc);
 		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
 	} else {
 		local_irq_save(flags);
 		m = read_counter(&hpet->hpet_mc);
 		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
 	}
 	if (devp->hd_flags & HPET_SHARED_IRQ) {
 		isr = 1 << (devp - devp->hd_hpets->hp_dev);
 		writel(isr, &hpet->hpet_isr);
 	}
 	writeq(g, &timer->hpet_config);
 	local_irq_restore(flags);
 	return 0;
 }
 /* converts Hz to number of timer ticks */
 static inline unsigned long hpet_time_div(struct hpets *hpets,
 					  unsigned long dis)
 {
 	unsigned long long m;
 	m = hpets->hp_tick_freq + (dis >> 1);
 	do_div(m, dis);
 	return (unsigned long)m;
 }
 static int
 hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
 {
 	struct hpet_timer __iomem *timer;
 	struct hpet __iomem *hpet;
 	struct hpets *hpetp;
 	int err;
 	unsigned long v;
 	switch (cmd) {
 	case HPET_IE_OFF:
 	case HPET_INFO:
 	case HPET_EPI:
 	case HPET_DPI:
 	case HPET_IRQFREQ:
 		timer = devp->hd_timer;
 		hpet = devp->hd_hpet;
 		hpetp = devp->hd_hpets;
 		break;
 	case HPET_IE_ON:
 		return hpet_ioctl_ieon(devp);
 	default:
 		return -EINVAL;
 	}
 	err = 0;
 	switch (cmd) {
 	case HPET_IE_OFF:
 		if ((devp->hd_flags & HPET_IE) == 0)
 			break;
 		v = readq(&timer->hpet_config);
 		v &= ~Tn_INT_ENB_CNF_MASK;
 		writeq(v, &timer->hpet_config);
 		if (devp->hd_irq) {
 			free_irq(devp->hd_irq, devp);
 			devp->hd_irq = 0;
 		}
 		devp->hd_flags ^= HPET_IE;
 		break;
 	case HPET_INFO:
 		{
 			struct hpet_info info;
 			if (devp->hd_ireqfreq)
 				info.hi_ireqfreq =
 					hpet_time_div(hpetp, devp->hd_ireqfreq);
 			else
 				info.hi_ireqfreq = 0;
 			info.hi_flags =
 			    readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
 			info.hi_hpet = hpetp->hp_which;
 			info.hi_timer = devp - hpetp->hp_dev;
 			if (kernel)
 				memcpy((void *)arg, &info, sizeof(info));
 			else
 				if (copy_to_user((void __user *)arg, &info,
 						 sizeof(info)))
 					err = -EFAULT;
 			break;
 		}
 	case HPET_EPI:
 		v = readq(&timer->hpet_config);
 		if ((v & Tn_PER_INT_CAP_MASK) == 0) {
 			err = -ENXIO;
 			break;
 		}
 		devp->hd_flags |= HPET_PERIODIC;
 		break;
 	case HPET_DPI:
 		v = readq(&timer->hpet_config);
 		if ((v & Tn_PER_INT_CAP_MASK) == 0) {
 			err = -ENXIO;
 			break;
 		}
 		if (devp->hd_flags & HPET_PERIODIC &&
 		    readq(&timer->hpet_config) & Tn_TYPE_CNF_MASK) {
 			v = readq(&timer->hpet_config);
 			v ^= Tn_TYPE_CNF_MASK;
 			writeq(v, &timer->hpet_config);
 		}
 		devp->hd_flags &= ~HPET_PERIODIC;
 		break;
 	case HPET_IRQFREQ:
 		if (!kernel && (arg > hpet_max_freq) &&
 		    !capable(CAP_SYS_RESOURCE)) {
 			err = -EACCES;
 			break;
 		}
 		if (!arg) {
 			err = -EINVAL;
 			break;
 		}
 		devp->hd_ireqfreq = hpet_time_div(hpetp, arg);
 	}
 	return err;
 }
 static const struct file_operations hpet_fops = {
 	.owner = THIS_MODULE,
 	.llseek = no_llseek,
 	.read = hpet_read,
 	.poll = hpet_poll,
 	.ioctl = hpet_ioctl,
 	.open = hpet_open,
 	.release = hpet_release,
 	.fasync = hpet_fasync,
 	.mmap = hpet_mmap,
 };
 static int hpet_is_known(struct hpet_data *hdp)
 {
 	struct hpets *hpetp;
 	for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
 		if (hpetp->hp_hpet_phys == hdp->hd_phys_address)
 			return 1;
 	return 0;
 }
 EXPORT_SYMBOL(hpet_alloc);
 EXPORT_SYMBOL(hpet_register);
 EXPORT_SYMBOL(hpet_unregister);
 EXPORT_SYMBOL(hpet_control);
 int hpet_register(struct hpet_task *tp, int periodic)
 {
 	unsigned int i;
 	u64 mask;
 	struct hpet_timer __iomem *timer;
 	struct hpet_dev *devp;
 	struct hpets *hpetp;
 	switch (periodic) {
 	case 1:
 		mask = Tn_PER_INT_CAP_MASK;
 		break;
 	case 0:
 		mask = 0;
 		break;
 	default:
 		return -EINVAL;
 	}
 	tp->ht_opaque = NULL;
 	spin_lock_irq(&hpet_task_lock);
 	spin_lock(&hpet_lock);
 	for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next)
 		for (timer = hpetp->hp_hpet->hpet_timers, i = 0;
 		     i < hpetp->hp_ntimer; i++, timer++) {
 			if ((readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK)
 			    != mask)
 				continue;
 			devp = &hpetp->hp_dev[i];
 			if (devp->hd_flags & HPET_OPEN || devp->hd_task) {
 				devp = NULL;
 				continue;
 			}
 			tp->ht_opaque = devp;
 			devp->hd_task = tp;
 			break;
 		}
 	spin_unlock(&hpet_lock);
 	spin_unlock_irq(&hpet_task_lock);
 	if (tp->ht_opaque)
 		return 0;
 	else
 		return -EBUSY;
 }
 static inline int hpet_tpcheck(struct hpet_task *tp)
 {
 	struct hpet_dev *devp;
 	struct hpets *hpetp;
 	devp = tp->ht_opaque;
 	if (!devp)
 		return -ENXIO;
 	for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
 		if (devp >= hpetp->hp_dev
 		    && devp < (hpetp->hp_dev + hpetp->hp_ntimer)
 		    && devp->hd_hpet == hpetp->hp_hpet)
 			return 0;
 	return -ENXIO;
 }
 int hpet_unregister(struct hpet_task *tp)
 {
 	struct hpet_dev *devp;
 	struct hpet_timer __iomem *timer;
 	int err;
 	if ((err = hpet_tpcheck(tp)))
 		return err;
 	spin_lock_irq(&hpet_task_lock);
 	spin_lock(&hpet_lock);
 	devp = tp->ht_opaque;
 	if (devp->hd_task != tp) {
 		spin_unlock(&hpet_lock);
 		spin_unlock_irq(&hpet_task_lock);
 		return -ENXIO;
 	}
 	timer = devp->hd_timer;
 	writeq((readq(&timer->hpet_config) & ~Tn_INT_ENB_CNF_MASK),
 	       &timer->hpet_config);
 	devp->hd_flags &= ~(HPET_IE | HPET_PERIODIC);
 	devp->hd_task = NULL;
 	spin_unlock(&hpet_lock);
 	spin_unlock_irq(&hpet_task_lock);
 	return 0;
 }
 int hpet_control(struct hpet_task *tp, unsigned int cmd, unsigned long arg)
 {
 	struct hpet_dev *devp;
 	int err;
 	if ((err = hpet_tpcheck(tp)))
 		return err;
 	spin_lock_irq(&hpet_lock);
 	devp = tp->ht_opaque;
 	if (devp->hd_task != tp) {
 		spin_unlock_irq(&hpet_lock);
 		return -ENXIO;
 	}
 	spin_unlock_irq(&hpet_lock);
 	return hpet_ioctl_common(devp, cmd, arg, 1);
 }
 static ctl_table hpet_table[] = {
 	{
 	 .ctl_name = 1,
 	 .procname = "max-user-freq",
 	 .data = &hpet_max_freq,
 	 .maxlen = sizeof(int),
 	 .mode = 0644,
 	 .proc_handler = &proc_dointvec,
 	 },
 	{.ctl_name = 0}
 };
 static ctl_table hpet_root[] = {
 	{
 	 .ctl_name = 1,
 	 .procname = "hpet",
 	 .maxlen = 0,
 	 .mode = 0555,
 	 .child = hpet_table,
 	 },
 	{.ctl_name = 0}
 };
 static ctl_table dev_root[] = {
 	{
 	 .ctl_name = CTL_DEV,
 	 .procname = "dev",
 	 .maxlen = 0,
 	 .mode = 0555,
 	 .child = hpet_root,
 	 },
 	{.ctl_name = 0}
 };
 static struct ctl_table_header *sysctl_header;
 static void hpet_register_interpolator(struct hpets *hpetp)
 {
 #ifdef	CONFIG_TIME_INTERPOLATION
 	struct time_interpolator *ti;
 	ti = kzalloc(sizeof(*ti), GFP_KERNEL);
 	if (!ti)
 		return;
 	ti->source = TIME_SOURCE_MMIO64;
 	ti->shift = 10;
 	ti->addr = &hpetp->hp_hpet->hpet_mc;
 	ti->frequency = hpetp->hp_tick_freq;
 	ti->drift = HPET_DRIFT;
 	ti->mask = -1;
 	hpetp->hp_interpolator = ti;
 	register_time_interpolator(ti);
 #endif
 }
 /*
  * Adjustment for when arming the timer with
  * initial conditions.  That is, main counter
  * ticks expired before interrupts are enabled.
  */
 #define	TICK_CALIBRATE	(1000UL)
 static unsigned long hpet_calibrate(struct hpets *hpetp)
 {
 	struct hpet_timer __iomem *timer = NULL;
 	unsigned long t, m, count, i, flags, start;
 	struct hpet_dev *devp;
 	int j;
 	struct hpet __iomem *hpet;
 	for (j = 0, devp = hpetp->hp_dev; j < hpetp->hp_ntimer; j++, devp++)
 		if ((devp->hd_flags & HPET_OPEN) == 0) {
 			timer = devp->hd_timer;
 			break;
 		}
 	if (!timer)
 		return 0;
 	hpet = hpetp->hp_hpet;
 	t = read_counter(&timer->hpet_compare);
 	i = 0;
 	count = hpet_time_div(hpetp, TICK_CALIBRATE);
 	local_irq_save(flags);
 	start = read_counter(&hpet->hpet_mc);
 	do {
 		m = read_counter(&hpet->hpet_mc);
 		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
 	} while (i++, (m - start) < count);
 	local_irq_restore(flags);
 	return (m - start) / i;
 }
 int hpet_alloc(struct hpet_data *hdp)
 {
 	u64 cap, mcfg;
 	struct hpet_dev *devp;
 	u32 i, ntimer;
 	struct hpets *hpetp;
 	size_t siz;
 	struct hpet __iomem *hpet;
 	static struct hpets *last = NULL;
 	unsigned long period;
 	unsigned long long temp;
 	/*
 	 * hpet_alloc can be called by platform dependent code.
 	 * If platform dependent code has allocated the hpet that
 	 * ACPI has also reported, then we catch it here.
 	 */
 	if (hpet_is_known(hdp)) {
 		printk(KERN_DEBUG "%s: duplicate HPET ignored\n",
 			__FUNCTION__);
 		return 0;
 	}
 	siz = sizeof(struct hpets) + ((hdp->hd_nirqs - 1) *
 				      sizeof(struct hpet_dev));
 	hpetp = kzalloc(siz, GFP_KERNEL);
 	if (!hpetp)
 		return -ENOMEM;
 	hpetp->hp_which = hpet_nhpet++;
 	hpetp->hp_hpet = hdp->hd_address;
 	hpetp->hp_hpet_phys = hdp->hd_phys_address;
 	hpetp->hp_ntimer = hdp->hd_nirqs;
 	for (i = 0; i < hdp->hd_nirqs; i++)
 		hpetp->hp_dev[i].hd_hdwirq = hdp->hd_irq[i];
 	hpet = hpetp->hp_hpet;
 	cap = readq(&hpet->hpet_cap);
 	ntimer = ((cap & HPET_NUM_TIM_CAP_MASK) >> HPET_NUM_TIM_CAP_SHIFT) + 1;
 	if (hpetp->hp_ntimer != ntimer) {
 		printk(KERN_WARNING "hpet: number irqs doesn't agree"
 		       " with number of timers\n");
 		kfree(hpetp);
 		return -ENODEV;
 	}
 	if (last)
 		last->hp_next = hpetp;
 	else
 		hpets = hpetp;
 	last = hpetp;
 	period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
 		HPET_COUNTER_CLK_PERIOD_SHIFT; /* fs, 10^-15 */
 	temp = 1000000000000000uLL; /* 10^15 femtoseconds per second */
 	temp += period >> 1; /* round */
 	do_div(temp, period);
 	hpetp->hp_tick_freq = temp; /* ticks per second */
 	printk(KERN_INFO "hpet%d: at MMIO 0x%lx, IRQ%s",
 		hpetp->hp_which, hdp->hd_phys_address,
 		hpetp->hp_ntimer > 1 ? "s" : "");
 	for (i = 0; i < hpetp->hp_ntimer; i++)
 		printk("%s %d", i > 0 ? "," : "", hdp->hd_irq[i]);
 	printk("\n");
 	printk(KERN_INFO "hpet%u: %u %d-bit timers, %Lu Hz\n",
 	       hpetp->hp_which, hpetp->hp_ntimer,
 	       cap & HPET_COUNTER_SIZE_MASK ? 64 : 32, hpetp->hp_tick_freq);
 	mcfg = readq(&hpet->hpet_config);
 	if ((mcfg & HPET_ENABLE_CNF_MASK) == 0) {
 		write_counter(0L, &hpet->hpet_mc);
 		mcfg |= HPET_ENABLE_CNF_MASK;
 		writeq(mcfg, &hpet->hpet_config);
 	}
 	for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer; i++, devp++) {
 		struct hpet_timer __iomem *timer;
 		timer = &hpet->hpet_timers[devp - hpetp->hp_dev];
 		devp->hd_hpets = hpetp;
 		devp->hd_hpet = hpet;
 		devp->hd_timer = timer;
 		/*
 		 * If the timer was reserved by platform code,
 		 * then make timer unavailable for opens.
 		 */
 		if (hdp->hd_state & (1 << i)) {
 			devp->hd_flags = HPET_OPEN;
 			continue;
 		}
 		init_waitqueue_head(&devp->hd_waitqueue);
 	}
 	hpetp->hp_delta = hpet_calibrate(hpetp);
 	hpet_register_interpolator(hpetp);
 	return 0;
 }
 static acpi_status hpet_resources(struct acpi_resource *res, void *data)
 {
 	struct hpet_data *hdp;
 	acpi_status status;
 	struct acpi_resource_address64 addr;
 	hdp = data;
 	status = acpi_resource_to_address64(res, &addr);
 	if (ACPI_SUCCESS(status)) {
 		hdp->hd_phys_address = addr.minimum;
 		hdp->hd_address = ioremap(addr.minimum, addr.address_length);
 		if (hpet_is_known(hdp)) {
 			printk(KERN_DEBUG "%s: 0x%lx is busy\n",
 				__FUNCTION__, hdp->hd_phys_address);
 			iounmap(hdp->hd_address);
 			return -EBUSY;
 		}
 	} else if (res->type == ACPI_RESOURCE_TYPE_FIXED_MEMORY32) {
 		struct acpi_resource_fixed_memory32 *fixmem32;
 		fixmem32 = &res->data.fixed_memory32;
 		if (!fixmem32)
 			return -EINVAL;
 		hdp->hd_phys_address = fixmem32->address;
 		hdp->hd_address = ioremap(fixmem32->address,
 						HPET_RANGE_SIZE);
 		if (hpet_is_known(hdp)) {
 			printk(KERN_DEBUG "%s: 0x%lx is busy\n",
 				__FUNCTION__, hdp->hd_phys_address);
 			iounmap(hdp->hd_address);
 			return -EBUSY;
 		}
 	} else if (res->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
 		struct acpi_resource_extended_irq *irqp;
 		int i, irq;
 		irqp = &res->data.extended_irq;
 		for (i = 0; i < irqp->interrupt_count; i++) {
 			irq = acpi_register_gsi(irqp->interrupts[i],
 				      irqp->triggering, irqp->polarity);
 			if (irq < 0)
 				return AE_ERROR;
 			hdp->hd_irq[hdp->hd_nirqs] = irq;
 			hdp->hd_nirqs++;
 		}
 	}
 	return AE_OK;
 }
 static int hpet_acpi_add(struct acpi_device *device)
 {
 	acpi_status result;
 	struct hpet_data data;
 	memset(&data, 0, sizeof(data));
 	result =
 	    acpi_walk_resources(device->handle, METHOD_NAME__CRS,
 				hpet_resources, &data);
 	if (ACPI_FAILURE(result))
 		return -ENODEV;
 	if (!data.hd_address || !data.hd_nirqs) {
 		printk("%s: no address or irqs in _CRS\n", __FUNCTION__);
 		return -ENODEV;
 	}
 	return hpet_alloc(&data);
 }
 static int hpet_acpi_remove(struct acpi_device *device, int type)
 {
 	/* XXX need to unregister interpolator, dealloc mem, etc */
 	return -EINVAL;
 }
 static struct acpi_driver hpet_acpi_driver = {
 	.name = "hpet",
 	.ids = "PNP0103",
 	.ops = {
 		.add = hpet_acpi_add,
 		.remove = hpet_acpi_remove,
 		},
 };
 static struct miscdevice hpet_misc = { HPET_MINOR, "hpet", &hpet_fops };
 static int __init hpet_init(void)
 {
 	int result;
 	result = misc_register(&hpet_misc);
 	if (result < 0)
 		return -ENODEV;
 	sysctl_header = register_sysctl_table(dev_root, 0);
 	result = acpi_bus_register_driver(&hpet_acpi_driver);
 	if (result < 0) {
 		if (sysctl_header)
 			unregister_sysctl_table(sysctl_header);
 		misc_deregister(&hpet_misc);
 		return result;
 	}
 	return 0;
 }
 static void __exit hpet_exit(void)
 {
 	acpi_bus_unregister_driver(&hpet_acpi_driver);
 	if (sysctl_header)
 		unregister_sysctl_table(sysctl_header);
 	misc_deregister(&hpet_misc);
 	return;
 }
 module_init(hpet_init);
 module_exit(hpet_exit);
 MODULE_AUTHOR("Bob Picco <Robert.Picco@hp.com>");
 MODULE_LICENSE("GPL");

drivers/media/dvb/cinergyT2/cinergyT2.c

Diff comments View file @ f23f6e0

 /*
  * TerraTec Cinergy T²/qanu USB2 DVB-T adapter.
  *
  * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
  *		    Holger Waechtler <holger@qanu.de>
  *
  *  Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
  *
  * 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.
  *
  */
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/pci.h>
 #include <linux/input.h>
 #include <linux/dvb/frontend.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 #include "dmxdev.h"
 #include "dvb_demux.h"
 #include "dvb_net.h"
 #ifdef CONFIG_DVB_CINERGYT2_TUNING
 	#define STREAM_URB_COUNT (CONFIG_DVB_CINERGYT2_STREAM_URB_COUNT)
 	#define STREAM_BUF_SIZE (CONFIG_DVB_CINERGYT2_STREAM_BUF_SIZE)
 	#define QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_QUERY_INTERVAL)
 	#ifdef CONFIG_DVB_CINERGYT2_ENABLE_RC_INPUT_DEVICE
 		#define RC_QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_RC_QUERY_INTERVAL)
 		#define ENABLE_RC (1)
 	#endif
 #else
 	#define STREAM_URB_COUNT (32)
 	#define STREAM_BUF_SIZE (512)	/* bytes */
 	#define ENABLE_RC (1)
 	#define RC_QUERY_INTERVAL (50)	/* milliseconds */
 	#define QUERY_INTERVAL (333)	/* milliseconds */
 #endif
 #define DRIVER_NAME "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver"
 static int debug;
 module_param_named(debug, debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
 #define dprintk(level, args...)						\
 do {									\
 	if ((debug & level)) {						\
 		printk("%s: %s(): ", KBUILD_MODNAME,			\
 		       __FUNCTION__);					\
 		printk(args); }						\
 } while (0)
 enum cinergyt2_ep1_cmd {
 	CINERGYT2_EP1_PID_TABLE_RESET		= 0x01,
 	CINERGYT2_EP1_PID_SETUP			= 0x02,
 	CINERGYT2_EP1_CONTROL_STREAM_TRANSFER	= 0x03,
 	CINERGYT2_EP1_SET_TUNER_PARAMETERS	= 0x04,
 	CINERGYT2_EP1_GET_TUNER_STATUS		= 0x05,
 	CINERGYT2_EP1_START_SCAN		= 0x06,
 	CINERGYT2_EP1_CONTINUE_SCAN		= 0x07,
 	CINERGYT2_EP1_GET_RC_EVENTS		= 0x08,
 	CINERGYT2_EP1_SLEEP_MODE		= 0x09
 };
 struct dvbt_set_parameters_msg {
 	uint8_t cmd;
 	uint32_t freq;
 	uint8_t bandwidth;
 	uint16_t tps;
 	uint8_t flags;
 } __attribute__((packed));
 struct dvbt_get_status_msg {
 	uint32_t freq;
 	uint8_t bandwidth;
 	uint16_t tps;
 	uint8_t flags;
 	uint16_t gain;
 	uint8_t snr;
 	uint32_t viterbi_error_rate;
 	uint32_t rs_error_rate;
 	uint32_t uncorrected_block_count;
 	uint8_t lock_bits;
 	uint8_t prev_lock_bits;
 } __attribute__((packed));
 static struct dvb_frontend_info cinergyt2_fe_info = {
 	.name = DRIVER_NAME,
 	.type = FE_OFDM,
 	.frequency_min = 174000000,
 	.frequency_max = 862000000,
 	.frequency_stepsize = 166667,
 	.caps = FE_CAN_INVERSION_AUTO | FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
 		FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
 		FE_CAN_FEC_AUTO |
 		FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 		FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
 		FE_CAN_HIERARCHY_AUTO | FE_CAN_RECOVER | FE_CAN_MUTE_TS
 };
 struct cinergyt2 {
 	struct dvb_demux demux;
 	struct usb_device *udev;
 	struct mutex sem;
 	struct dvb_adapter adapter;
 	struct dvb_device *fedev;
 	struct dmxdev dmxdev;
 	struct dvb_net dvbnet;
 	int streaming;
 	int sleeping;
 	struct dvbt_set_parameters_msg param;
 	struct dvbt_get_status_msg status;
 	struct work_struct query_work;
 	wait_queue_head_t poll_wq;
 	int pending_fe_events;
 	int disconnect_pending;
 	atomic_t inuse;
 	void *streambuf;
 	dma_addr_t streambuf_dmahandle;
 	struct urb *stream_urb [STREAM_URB_COUNT];
 #ifdef ENABLE_RC
 	struct input_dev *rc_input_dev;
 	char phys[64];
 	struct work_struct rc_query_work;
 	int rc_input_event;
 	u32 rc_last_code;
 	unsigned long last_event_jiffies;
 #endif
 };
 enum {
 	CINERGYT2_RC_EVENT_TYPE_NONE = 0x00,
 	CINERGYT2_RC_EVENT_TYPE_NEC  = 0x01,
 	CINERGYT2_RC_EVENT_TYPE_RC5  = 0x02
 };
 struct cinergyt2_rc_event {
 	char type;
 	uint32_t value;
 } __attribute__((packed));
 static const uint32_t rc_keys[] = {
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xfe01eb04,	KEY_POWER,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xfd02eb04,	KEY_1,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xfc03eb04,	KEY_2,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xfb04eb04,	KEY_3,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xfa05eb04,	KEY_4,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf906eb04,	KEY_5,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf807eb04,	KEY_6,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf708eb04,	KEY_7,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf609eb04,	KEY_8,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf50aeb04,	KEY_9,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf30ceb04,	KEY_0,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf40beb04,	KEY_VIDEO,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf20deb04,	KEY_REFRESH,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf10eeb04,	KEY_SELECT,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xf00feb04,	KEY_EPG,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xef10eb04,	KEY_UP,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xeb14eb04,	KEY_DOWN,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xee11eb04,	KEY_LEFT,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xec13eb04,	KEY_RIGHT,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xed12eb04,	KEY_OK,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xea15eb04,	KEY_TEXT,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe916eb04,	KEY_INFO,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe817eb04,	KEY_RED,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe718eb04,	KEY_GREEN,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe619eb04,	KEY_YELLOW,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe51aeb04,	KEY_BLUE,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe31ceb04,	KEY_VOLUMEUP,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe11eeb04,	KEY_VOLUMEDOWN,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe21deb04,	KEY_MUTE,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe41beb04,	KEY_CHANNELUP,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xe01feb04,	KEY_CHANNELDOWN,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xbf40eb04,	KEY_PAUSE,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xb34ceb04,	KEY_PLAY,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xa758eb04,	KEY_RECORD,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xab54eb04,	KEY_PREVIOUS,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xb748eb04,	KEY_STOP,
 	CINERGYT2_RC_EVENT_TYPE_NEC,	0xa35ceb04,	KEY_NEXT
 };
 static int cinergyt2_command (struct cinergyt2 *cinergyt2,
 			      char *send_buf, int send_buf_len,
 			      char *recv_buf, int recv_buf_len)
 {
 	int actual_len;
 	char dummy;
 	int ret;
 	ret = usb_bulk_msg(cinergyt2->udev, usb_sndbulkpipe(cinergyt2->udev, 1),
 			   send_buf, send_buf_len, &actual_len, 1000);
 	if (ret)
 		dprintk(1, "usb_bulk_msg (send) failed, err %i\n", ret);
 	if (!recv_buf)
 		recv_buf = &dummy;
 	ret = usb_bulk_msg(cinergyt2->udev, usb_rcvbulkpipe(cinergyt2->udev, 1),
 			   recv_buf, recv_buf_len, &actual_len, 1000);
 	if (ret)
 		dprintk(1, "usb_bulk_msg (read) failed, err %i\n", ret);
 	return ret ? ret : actual_len;
 }
 static void cinergyt2_control_stream_transfer (struct cinergyt2 *cinergyt2, int enable)
 {
 	char buf [] = { CINERGYT2_EP1_CONTROL_STREAM_TRANSFER, enable ? 1 : 0 };
 	cinergyt2_command(cinergyt2, buf, sizeof(buf), NULL, 0);
 }
 static void cinergyt2_sleep (struct cinergyt2 *cinergyt2, int sleep)
 {
 	char buf [] = { CINERGYT2_EP1_SLEEP_MODE, sleep ? 1 : 0 };
 	cinergyt2_command(cinergyt2, buf, sizeof(buf), NULL, 0);
 	cinergyt2->sleeping = sleep;
 }
 static void cinergyt2_stream_irq (struct urb *urb);
 static int cinergyt2_submit_stream_urb (struct cinergyt2 *cinergyt2, struct urb *urb)
 {
 	int err;
 	usb_fill_bulk_urb(urb,
 			  cinergyt2->udev,
 			  usb_rcvbulkpipe(cinergyt2->udev, 0x2),
 			  urb->transfer_buffer,
 			  STREAM_BUF_SIZE,
 			  cinergyt2_stream_irq,
 			  cinergyt2);
 	if ((err = usb_submit_urb(urb, GFP_ATOMIC)))
 		dprintk(1, "urb submission failed (err = %i)!\n", err);
 	return err;
 }
 static void cinergyt2_stream_irq (struct urb *urb)
 {
 	struct cinergyt2 *cinergyt2 = urb->context;
 	if (urb->actual_length > 0)
 		dvb_dmx_swfilter(&cinergyt2->demux,
 				 urb->transfer_buffer, urb->actual_length);
 	if (cinergyt2->streaming)
 		cinergyt2_submit_stream_urb(cinergyt2, urb);
 }
 static void cinergyt2_free_stream_urbs (struct cinergyt2 *cinergyt2)
 {
 	int i;
 	for (i=0; i<STREAM_URB_COUNT; i++)
 		usb_free_urb(cinergyt2->stream_urb[i]);
 	usb_buffer_free(cinergyt2->udev, STREAM_URB_COUNT*STREAM_BUF_SIZE,
 			    cinergyt2->streambuf, cinergyt2->streambuf_dmahandle);
 }
 static int cinergyt2_alloc_stream_urbs (struct cinergyt2 *cinergyt2)
 {
 	int i;
 	cinergyt2->streambuf = usb_buffer_alloc(cinergyt2->udev, STREAM_URB_COUNT*STREAM_BUF_SIZE,
 					      SLAB_KERNEL, &cinergyt2->streambuf_dmahandle);
 	if (!cinergyt2->streambuf) {
 		dprintk(1, "failed to alloc consistent stream memory area, bailing out!\n");
 		return -ENOMEM;
 	}
 	memset(cinergyt2->streambuf, 0, STREAM_URB_COUNT*STREAM_BUF_SIZE);
 	for (i=0; i<STREAM_URB_COUNT; i++) {
 		struct urb *urb;
 		if (!(urb = usb_alloc_urb(0, GFP_ATOMIC))) {
 			dprintk(1, "failed to alloc consistent stream urbs, bailing out!\n");
 			cinergyt2_free_stream_urbs(cinergyt2);
 			return -ENOMEM;
 		}
 		urb->transfer_buffer = cinergyt2->streambuf + i * STREAM_BUF_SIZE;
 		urb->transfer_buffer_length = STREAM_BUF_SIZE;
 		cinergyt2->stream_urb[i] = urb;
 	}
 	return 0;
 }
 static void cinergyt2_stop_stream_xfer (struct cinergyt2 *cinergyt2)
 {
 	int i;
 	cinergyt2_control_stream_transfer(cinergyt2, 0);
 	for (i=0; i<STREAM_URB_COUNT; i++)
 		usb_kill_urb(cinergyt2->stream_urb[i]);
 }
 static int cinergyt2_start_stream_xfer (struct cinergyt2 *cinergyt2)
 {
 	int i, err;
 	for (i=0; i<STREAM_URB_COUNT; i++) {
 		if ((err = cinergyt2_submit_stream_urb(cinergyt2, cinergyt2->stream_urb[i]))) {
 			cinergyt2_stop_stream_xfer(cinergyt2);
 			dprintk(1, "failed urb submission (%i: err = %i)!\n", i, err);
 			return err;
 		}
 	}
 	cinergyt2_control_stream_transfer(cinergyt2, 1);
 	return 0;
 }
 static int cinergyt2_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
 	struct dvb_demux *demux = dvbdmxfeed->demux;
 	struct cinergyt2 *cinergyt2 = demux->priv;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if (cinergyt2->streaming == 0)
 		cinergyt2_start_stream_xfer(cinergyt2);
 	cinergyt2->streaming++;
 	mutex_unlock(&cinergyt2->sem);
 	return 0;
 }
 static int cinergyt2_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
 	struct dvb_demux *demux = dvbdmxfeed->demux;
 	struct cinergyt2 *cinergyt2 = demux->priv;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if (--cinergyt2->streaming == 0)
 		cinergyt2_stop_stream_xfer(cinergyt2);
 	mutex_unlock(&cinergyt2->sem);
 	return 0;
 }
 /**
  *  convert linux-dvb frontend parameter set into TPS.
  *  See ETSI ETS-300744, section 4.6.2, table 9 for details.
  *
  *  This function is probably reusable and may better get placed in a support
  *  library.
  *
  *  We replace errornous fields by default TPS fields (the ones with value 0).
  */
 static uint16_t compute_tps (struct dvb_frontend_parameters *p)
 {
 	struct dvb_ofdm_parameters *op = &p->u.ofdm;
 	uint16_t tps = 0;
 	switch (op->code_rate_HP) {
 		case FEC_2_3:
 			tps |= (1 << 7);
 			break;
 		case FEC_3_4:
 			tps |= (2 << 7);
 			break;
 		case FEC_5_6:
 			tps |= (3 << 7);
 			break;
 		case FEC_7_8:
 			tps |= (4 << 7);
 			break;
 		case FEC_1_2:
 		case FEC_AUTO:
 		default:
 			/* tps |= (0 << 7) */;
 	}
 	switch (op->code_rate_LP) {
 		case FEC_2_3:
 			tps |= (1 << 4);
 			break;
 		case FEC_3_4:
 			tps |= (2 << 4);
 			break;
 		case FEC_5_6:
 			tps |= (3 << 4);
 			break;
 		case FEC_7_8:
 			tps |= (4 << 4);
 			break;
 		case FEC_1_2:
 		case FEC_AUTO:
 		default:
 			/* tps |= (0 << 4) */;
 	}
 	switch (op->constellation) {
 		case QAM_16:
 			tps |= (1 << 13);
 			break;
 		case QAM_64:
 			tps |= (2 << 13);
 			break;
 		case QPSK:
 		default:
 			/* tps |= (0 << 13) */;
 	}
 	switch (op->transmission_mode) {
 		case TRANSMISSION_MODE_8K:
 			tps |= (1 << 0);
 			break;
 		case TRANSMISSION_MODE_2K:
 		default:
 			/* tps |= (0 << 0) */;
 	}
 	switch (op->guard_interval) {
 		case GUARD_INTERVAL_1_16:
 			tps |= (1 << 2);
 			break;
 		case GUARD_INTERVAL_1_8:
 			tps |= (2 << 2);
 			break;
 		case GUARD_INTERVAL_1_4:
 			tps |= (3 << 2);
 			break;
 		case GUARD_INTERVAL_1_32:
 		default:
 			/* tps |= (0 << 2) */;
 	}
 	switch (op->hierarchy_information) {
 		case HIERARCHY_1:
 			tps |= (1 << 10);
 			break;
 		case HIERARCHY_2:
 			tps |= (2 << 10);
 			break;
 		case HIERARCHY_4:
 			tps |= (3 << 10);
 			break;
 		case HIERARCHY_NONE:
 		default:
 			/* tps |= (0 << 10) */;
 	}
 	return tps;
 }
 static int cinergyt2_open (struct inode *inode, struct file *file)
 {
 	struct dvb_device *dvbdev = file->private_data;
 	struct cinergyt2 *cinergyt2 = dvbdev->priv;
 	int err = -ERESTARTSYS;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if ((err = dvb_generic_open(inode, file))) {
 		mutex_unlock(&cinergyt2->sem);
 		return err;
 	}
 	if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
 		cinergyt2_sleep(cinergyt2, 0);
 		schedule_delayed_work(&cinergyt2->query_work, HZ/2);
 	}
 	atomic_inc(&cinergyt2->inuse);
 	mutex_unlock(&cinergyt2->sem);
 	return 0;
 }
 static void cinergyt2_unregister(struct cinergyt2 *cinergyt2)
 {
 	dvb_net_release(&cinergyt2->dvbnet);
 	dvb_dmxdev_release(&cinergyt2->dmxdev);
 	dvb_dmx_release(&cinergyt2->demux);
 	dvb_unregister_device(cinergyt2->fedev);
 	dvb_unregister_adapter(&cinergyt2->adapter);
 	cinergyt2_free_stream_urbs(cinergyt2);
 	kfree(cinergyt2);
 }
 static int cinergyt2_release (struct inode *inode, struct file *file)
 {
 	struct dvb_device *dvbdev = file->private_data;
 	struct cinergyt2 *cinergyt2 = dvbdev->priv;
 	if (mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if (!cinergyt2->disconnect_pending && (file->f_flags & O_ACCMODE) != O_RDONLY) {
 		cancel_delayed_work(&cinergyt2->query_work);
 		flush_scheduled_work();
 		cinergyt2_sleep(cinergyt2, 1);
 	}
 	mutex_unlock(&cinergyt2->sem);
 	if (atomic_dec_and_test(&cinergyt2->inuse) && cinergyt2->disconnect_pending) {
 		warn("delayed unregister in release");
 		cinergyt2_unregister(cinergyt2);
 	}
 	return dvb_generic_release(inode, file);
 }
 static unsigned int cinergyt2_poll (struct file *file, struct poll_table_struct *wait)
 {
 	struct dvb_device *dvbdev = file->private_data;
 	struct cinergyt2 *cinergyt2 = dvbdev->priv;
        unsigned int mask = 0;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	poll_wait(file, &cinergyt2->poll_wq, wait);
        if (cinergyt2->pending_fe_events != 0)
 		mask |= (POLLIN | POLLRDNORM | POLLPRI);
 	mutex_unlock(&cinergyt2->sem);
        return mask;
 }
 static int cinergyt2_ioctl (struct inode *inode, struct file *file,
 		     unsigned cmd, unsigned long arg)
 {
 	struct dvb_device *dvbdev = file->private_data;
 	struct cinergyt2 *cinergyt2 = dvbdev->priv;
 	struct dvbt_get_status_msg *stat = &cinergyt2->status;
 	fe_status_t status = 0;
 	switch (cmd) {
 	case FE_GET_INFO:
 		return copy_to_user((void __user*) arg, &cinergyt2_fe_info,
 				    sizeof(struct dvb_frontend_info));
 	case FE_READ_STATUS:
 		if (0xffff - le16_to_cpu(stat->gain) > 30)
 			status |= FE_HAS_SIGNAL;
 		if (stat->lock_bits & (1 << 6))
 			status |= FE_HAS_LOCK;
 		if (stat->lock_bits & (1 << 5))
 			status |= FE_HAS_SYNC;
 		if (stat->lock_bits & (1 << 4))
 			status |= FE_HAS_CARRIER;
 		if (stat->lock_bits & (1 << 1))
 			status |= FE_HAS_VITERBI;
 		return copy_to_user((void  __user*) arg, &status, sizeof(status));
 	case FE_READ_BER:
 		return put_user(le32_to_cpu(stat->viterbi_error_rate),
 				(__u32 __user *) arg);
 	case FE_READ_SIGNAL_STRENGTH:
 		return put_user(0xffff - le16_to_cpu(stat->gain),
 				(__u16 __user *) arg);
 	case FE_READ_SNR:
 		return put_user((stat->snr << 8) | stat->snr,
 				(__u16 __user *) arg);
 	case FE_READ_UNCORRECTED_BLOCKS:
 	{
 		uint32_t unc_count;
 		unc_count = stat->uncorrected_block_count;
 		stat->uncorrected_block_count = 0;
 		/* UNC are already converted to host byte order... */
 		return put_user(unc_count,(__u32 __user *) arg);
 	}
 	case FE_SET_FRONTEND:
 	{
 		struct dvbt_set_parameters_msg *param = &cinergyt2->param;
 		struct dvb_frontend_parameters p;
 		int err;
 		if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 			return -EPERM;
 		if (copy_from_user(&p, (void  __user*) arg, sizeof(p)))
 			return -EFAULT;
 		if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 			return -ERESTARTSYS;
 		param->cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
 		param->tps = cpu_to_le16(compute_tps(&p));
 		param->freq = cpu_to_le32(p.frequency / 1000);
 		param->bandwidth = 8 - p.u.ofdm.bandwidth - BANDWIDTH_8_MHZ;
 		stat->lock_bits = 0;
 		cinergyt2->pending_fe_events++;
 		wake_up_interruptible(&cinergyt2->poll_wq);
 		err = cinergyt2_command(cinergyt2,
 					(char *) param, sizeof(*param),
 					NULL, 0);
 		mutex_unlock(&cinergyt2->sem);
 		return (err < 0) ? err : 0;
 	}
 	case FE_GET_FRONTEND:
 		/**
 		 *  trivial to implement (see struct dvbt_get_status_msg).
 		 *  equivalent to FE_READ ioctls, but needs
 		 *  TPS -> linux-dvb parameter set conversion. Feel free
 		 *  to implement this and send us a patch if you need this
 		 *  functionality.
 		 */
 		break;
 	case FE_GET_EVENT:
 	{
 		/**
 		 *  for now we only fill the status field. the parameters
 		 *  are trivial to fill as soon FE_GET_FRONTEND is done.
 		 */
 		struct dvb_frontend_event __user *e = (void __user *) arg;
 		if (cinergyt2->pending_fe_events == 0) {
 			if (file->f_flags & O_NONBLOCK)
 				return -EWOULDBLOCK;
 			wait_event_interruptible(cinergyt2->poll_wq,
 						 cinergyt2->pending_fe_events > 0);
 		}
 		cinergyt2->pending_fe_events = 0;
 		return cinergyt2_ioctl(inode, file, FE_READ_STATUS,
 					(unsigned long) &e->status);
 	}
 	default:
 		;
 	}
 	return -EINVAL;
 }
 static int cinergyt2_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct dvb_device *dvbdev = file->private_data;
 	struct cinergyt2 *cinergyt2 = dvbdev->priv;
 	int ret = 0;
 	lock_kernel();
 	if (vma->vm_flags & (VM_WRITE | VM_EXEC)) {
 		ret = -EPERM;
 		goto bailout;
 	}
 	if (vma->vm_end > vma->vm_start + STREAM_URB_COUNT * STREAM_BUF_SIZE) {
 		ret = -EINVAL;
 		goto bailout;
 	}
 	vma->vm_flags |= (VM_IO | VM_DONTCOPY);
 	vma->vm_file = file;
 	ret = remap_pfn_range(vma, vma->vm_start,
 			      virt_to_phys(cinergyt2->streambuf) >> PAGE_SHIFT,
 			      vma->vm_end - vma->vm_start,
 			      vma->vm_page_prot) ? -EAGAIN : 0;
 bailout:
 	unlock_kernel();
 	return ret;
 }
 static struct file_operations cinergyt2_fops = {
 	.owner          = THIS_MODULE,
 	.ioctl		= cinergyt2_ioctl,
 	.poll           = cinergyt2_poll,
 	.open           = cinergyt2_open,
 	.release        = cinergyt2_release,
 	.mmap		= cinergyt2_mmap
 };
 static struct dvb_device cinergyt2_fe_template = {
 	.users = ~0,
 	.writers = 1,
 	.readers = (~0)-1,
 	.fops = &cinergyt2_fops
 };
 #ifdef ENABLE_RC
 static void cinergyt2_query_rc (void *data)
 {
 	struct cinergyt2 *cinergyt2 = data;
 	char buf[1] = { CINERGYT2_EP1_GET_RC_EVENTS };
 	struct cinergyt2_rc_event rc_events[12];
 	int n, len, i;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return;
 	len = cinergyt2_command(cinergyt2, buf, sizeof(buf),
 				(char *) rc_events, sizeof(rc_events));
 	if (len < 0)
 		goto out;
 	if (len == 0) {
 		if (time_after(jiffies, cinergyt2->last_event_jiffies +
 			       msecs_to_jiffies(150))) {
 			/* stop key repeat */
 			if (cinergyt2->rc_input_event != KEY_MAX) {
 				dprintk(1, "rc_input_event=%d Up\n", cinergyt2->rc_input_event);
 				input_report_key(cinergyt2->rc_input_dev,
 						 cinergyt2->rc_input_event, 0);
 				cinergyt2->rc_input_event = KEY_MAX;
 			}
 			cinergyt2->rc_last_code = ~0;
 		}
 		goto out;
 	}
 	cinergyt2->last_event_jiffies = jiffies;
 	for (n = 0; n < (len / sizeof(rc_events[0])); n++) {
 		dprintk(1, "rc_events[%d].value = %x, type=%x\n",
 			n, le32_to_cpu(rc_events[n].value), rc_events[n].type);
 		if (rc_events[n].type == CINERGYT2_RC_EVENT_TYPE_NEC &&
 		    rc_events[n].value == ~0) {
 			/* keyrepeat bit -> just repeat last rc_input_event */
 		} else {
 			cinergyt2->rc_input_event = KEY_MAX;
 			for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3) {
 				if (rc_keys[i + 0] == rc_events[n].type &&
 				    rc_keys[i + 1] == le32_to_cpu(rc_events[n].value)) {
 					cinergyt2->rc_input_event = rc_keys[i + 2];
 					break;
 				}
 			}
 		}
 		if (cinergyt2->rc_input_event != KEY_MAX) {
 			if (rc_events[n].value == cinergyt2->rc_last_code &&
 			    cinergyt2->rc_last_code != ~0) {
 				/* emit a key-up so the double event is recognized */
 				dprintk(1, "rc_input_event=%d UP\n", cinergyt2->rc_input_event);
 				input_report_key(cinergyt2->rc_input_dev,
 						 cinergyt2->rc_input_event, 0);
 			}
 			dprintk(1, "rc_input_event=%d\n", cinergyt2->rc_input_event);
 			input_report_key(cinergyt2->rc_input_dev,
 					 cinergyt2->rc_input_event, 1);
 			cinergyt2->rc_last_code = rc_events[n].value;
 		}
 	}
 out:
 	schedule_delayed_work(&cinergyt2->rc_query_work,
 			      msecs_to_jiffies(RC_QUERY_INTERVAL));
 	mutex_unlock(&cinergyt2->sem);
 }
 static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2)
 {
 	struct input_dev *input_dev;
 	int i;
 	cinergyt2->rc_input_dev = input_dev = input_allocate_device();
 	if (!input_dev)
 		return -ENOMEM;
 	usb_make_path(cinergyt2->udev, cinergyt2->phys, sizeof(cinergyt2->phys));
 	strlcat(cinergyt2->phys, "/input0", sizeof(cinergyt2->phys));
 	cinergyt2->rc_input_event = KEY_MAX;
 	cinergyt2->rc_last_code = ~0;
 	INIT_WORK(&cinergyt2->rc_query_work, cinergyt2_query_rc, cinergyt2);
 	input_dev->name = DRIVER_NAME " remote control";
 	input_dev->phys = cinergyt2->phys;
 	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
 	for (i = 0; i < ARRAY_SIZE(rc_keys); i += 3)
 		set_bit(rc_keys[i + 2], input_dev->keybit);
 	input_dev->keycodesize = 0;
 	input_dev->keycodemax = 0;
 	input_register_device(cinergyt2->rc_input_dev);
 	schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
 	return 0;
 }
 static void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2)
 {
 	cancel_delayed_work(&cinergyt2->rc_query_work);
 	input_unregister_device(cinergyt2->rc_input_dev);
 }
 static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2)
 {
 	cancel_delayed_work(&cinergyt2->rc_query_work);
 }
 static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2)
 {
 	schedule_delayed_work(&cinergyt2->rc_query_work, HZ/2);
 }
 #else
 static inline int cinergyt2_register_rc(struct cinergyt2 *cinergyt2) { return 0; }
 static inline void cinergyt2_unregister_rc(struct cinergyt2 *cinergyt2) { }
 static inline void cinergyt2_suspend_rc(struct cinergyt2 *cinergyt2) { }
 static inline void cinergyt2_resume_rc(struct cinergyt2 *cinergyt2) { }
 #endif /* ENABLE_RC */
 static void cinergyt2_query (void *data)
 {
 	struct cinergyt2 *cinergyt2 = (struct cinergyt2 *) data;
 	char cmd [] = { CINERGYT2_EP1_GET_TUNER_STATUS };
 	struct dvbt_get_status_msg *s = &cinergyt2->status;
 	uint8_t lock_bits;
 	uint32_t unc;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return;
 	unc = s->uncorrected_block_count;
 	lock_bits = s->lock_bits;
 	cinergyt2_command(cinergyt2, cmd, sizeof(cmd), (char *) s, sizeof(*s));
 	unc += le32_to_cpu(s->uncorrected_block_count);
 	s->uncorrected_block_count = unc;
 	if (lock_bits != s->lock_bits) {
 		wake_up_interruptible(&cinergyt2->poll_wq);
 		cinergyt2->pending_fe_events++;
 	}
 	schedule_delayed_work(&cinergyt2->query_work,
 			      msecs_to_jiffies(QUERY_INTERVAL));
 	mutex_unlock(&cinergyt2->sem);
 }
 static int cinergyt2_probe (struct usb_interface *intf,
 		  const struct usb_device_id *id)
 {
 	struct cinergyt2 *cinergyt2;
 	int err;
 	if (!(cinergyt2 = kmalloc (sizeof(struct cinergyt2), GFP_KERNEL))) {
 		dprintk(1, "out of memory?!?\n");
 		return -ENOMEM;
 	}
 	memset (cinergyt2, 0, sizeof (struct cinergyt2));
 	usb_set_intfdata (intf, (void *) cinergyt2);
 	mutex_init(&cinergyt2->sem);
 	init_waitqueue_head (&cinergyt2->poll_wq);
 	INIT_WORK(&cinergyt2->query_work, cinergyt2_query, cinergyt2);
 	cinergyt2->udev = interface_to_usbdev(intf);
 	cinergyt2->param.cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
 	if (cinergyt2_alloc_stream_urbs (cinergyt2) < 0) {
 		dprintk(1, "unable to allocate stream urbs\n");
 		kfree(cinergyt2);
 		return -ENOMEM;
 	}
 	if ((err = dvb_register_adapter(&cinergyt2->adapter, DRIVER_NAME, THIS_MODULE, &cinergyt2->udev->dev)) < 0) {
 		kfree(cinergyt2);
 		return err;
 	}
 	cinergyt2->demux.priv = cinergyt2;
 	cinergyt2->demux.filternum = 256;
 	cinergyt2->demux.feednum = 256;
 	cinergyt2->demux.start_feed = cinergyt2_start_feed;
 	cinergyt2->demux.stop_feed = cinergyt2_stop_feed;
 	cinergyt2->demux.dmx.capabilities = DMX_TS_FILTERING |
 					    DMX_SECTION_FILTERING |
 					    DMX_MEMORY_BASED_FILTERING;
 	if ((err = dvb_dmx_init(&cinergyt2->demux)) < 0) {
 		dprintk(1, "dvb_dmx_init() failed (err = %d)\n", err);
 		goto bailout;
 	}
 	cinergyt2->dmxdev.filternum = cinergyt2->demux.filternum;
 	cinergyt2->dmxdev.demux = &cinergyt2->demux.dmx;
 	cinergyt2->dmxdev.capabilities = 0;
 	if ((err = dvb_dmxdev_init(&cinergyt2->dmxdev, &cinergyt2->adapter)) < 0) {
 		dprintk(1, "dvb_dmxdev_init() failed (err = %d)\n", err);
 		goto bailout;
 	}
 	if (dvb_net_init(&cinergyt2->adapter, &cinergyt2->dvbnet, &cinergyt2->demux.dmx))
 		dprintk(1, "dvb_net_init() failed!\n");
 	dvb_register_device(&cinergyt2->adapter, &cinergyt2->fedev,
 			    &cinergyt2_fe_template, cinergyt2,
 			    DVB_DEVICE_FRONTEND);
 	err = cinergyt2_register_rc(cinergyt2);
 	if (err)
 		goto bailout;
 	return 0;
 bailout:
 	dvb_net_release(&cinergyt2->dvbnet);
 	dvb_dmxdev_release(&cinergyt2->dmxdev);
 	dvb_dmx_release(&cinergyt2->demux);
 	dvb_unregister_adapter(&cinergyt2->adapter);
 	cinergyt2_free_stream_urbs(cinergyt2);
 	kfree(cinergyt2);
 	return -ENOMEM;
 }
 static void cinergyt2_disconnect (struct usb_interface *intf)
 {
 	struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
 	flush_scheduled_work();
 	cinergyt2_unregister_rc(cinergyt2);
 	cancel_delayed_work(&cinergyt2->query_work);
 	wake_up_interruptible(&cinergyt2->poll_wq);
 	cinergyt2->demux.dmx.close(&cinergyt2->demux.dmx);
 	cinergyt2->disconnect_pending = 1;
 	if (!atomic_read(&cinergyt2->inuse))
 		cinergyt2_unregister(cinergyt2);
 }
 static int cinergyt2_suspend (struct usb_interface *intf, pm_message_t state)
 {
 	struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if (1) {
 		struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
 		cinergyt2_suspend_rc(cinergyt2);
 		cancel_delayed_work(&cinergyt2->query_work);
 		if (cinergyt2->streaming)
 			cinergyt2_stop_stream_xfer(cinergyt2);
 		flush_scheduled_work();
 		cinergyt2_sleep(cinergyt2, 1);
 	}
 	mutex_unlock(&cinergyt2->sem);
 	return 0;
 }
 static int cinergyt2_resume (struct usb_interface *intf)
 {
 	struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
 	struct dvbt_set_parameters_msg *param = &cinergyt2->param;
 	if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
 		return -ERESTARTSYS;
 	if (!cinergyt2->sleeping) {
 		cinergyt2_sleep(cinergyt2, 0);
 		cinergyt2_command(cinergyt2, (char *) param, sizeof(*param), NULL, 0);
 		if (cinergyt2->streaming)
 			cinergyt2_start_stream_xfer(cinergyt2);
 		schedule_delayed_work(&cinergyt2->query_work, HZ/2);
 	}
 	cinergyt2_resume_rc(cinergyt2);
 	mutex_unlock(&cinergyt2->sem);
 	return 0;
 }
 static const struct usb_device_id cinergyt2_table [] __devinitdata = {
 	{ USB_DEVICE(0x0ccd, 0x0038) },
 	{ 0 }
 };
 MODULE_DEVICE_TABLE(usb, cinergyt2_table);
 static struct usb_driver cinergyt2_driver = {
 	.name	= "cinergyT2",
 	.probe	= cinergyt2_probe,
 	.disconnect	= cinergyt2_disconnect,
 	.suspend	= cinergyt2_suspend,
 	.resume		= cinergyt2_resume,
 	.id_table	= cinergyt2_table
 };
 static int __init cinergyt2_init (void)
 {
 	int err;
 	if ((err = usb_register(&cinergyt2_driver)) < 0)
 		dprintk(1, "usb_register() failed! (err %i)\n", err);
 	return err;
 }
 static void __exit cinergyt2_exit (void)
 {
 	usb_deregister(&cinergyt2_driver);
 }
 module_init (cinergyt2_init);
 module_exit (cinergyt2_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Holger Waechtler, Daniel Mack");

include/linux/poll.h

Diff comments View file @ f23f6e0

 #ifndef _LINUX_POLL_H
 #define _LINUX_POLL_H
 #include <asm/poll.h>
 #ifdef __KERNEL__
 #include <linux/compiler.h>
 #include <linux/wait.h>
 #include <linux/string.h>
-#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
 #include <asm/uaccess.h>
 /* ~832 bytes of stack space used max in sys_select/sys_poll before allocating
    additional memory. */
 #define MAX_STACK_ALLOC 832
 #define FRONTEND_STACK_ALLOC	256
 #define SELECT_STACK_ALLOC	FRONTEND_STACK_ALLOC
 #define POLL_STACK_ALLOC	FRONTEND_STACK_ALLOC
 #define WQUEUES_STACK_ALLOC	(MAX_STACK_ALLOC - FRONTEND_STACK_ALLOC)
 #define N_INLINE_POLL_ENTRIES	(WQUEUES_STACK_ALLOC / sizeof(struct poll_table_entry))
 struct poll_table_struct;
 /*
  * structures and helpers for f_op->poll implementations
  */
 typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
 typedef struct poll_table_struct {
 	poll_queue_proc qproc;
 } poll_table;
 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
 {
 	if (p && wait_address)
 		p->qproc(filp, wait_address, p);
 }
 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
 {
 	pt->qproc = qproc;
 }
 struct poll_table_entry {
 	struct file * filp;
 	wait_queue_t wait;
 	wait_queue_head_t * wait_address;
 };
 /*
  * Structures and helpers for sys_poll/sys_poll
  */
 struct poll_wqueues {
 	poll_table pt;
 	struct poll_table_page * table;
 	int error;
 	int inline_index;
 	struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
 };
 extern void poll_initwait(struct poll_wqueues *pwq);
 extern void poll_freewait(struct poll_wqueues *pwq);
 /*
  * Scaleable version of the fd_set.
  */
 typedef struct {
 	unsigned long *in, *out, *ex;
 	unsigned long *res_in, *res_out, *res_ex;
 } fd_set_bits;
 /*
  * How many longwords for "nr" bits?
  */
 #define FDS_BITPERLONG	(8*sizeof(long))
 #define FDS_LONGS(nr)	(((nr)+FDS_BITPERLONG-1)/FDS_BITPERLONG)
 #define FDS_BYTES(nr)	(FDS_LONGS(nr)*sizeof(long))
 /*
  * We do a VERIFY_WRITE here even though we are only reading this time:
  * we'll write to it eventually..
  *
  * Use "unsigned long" accesses to let user-mode fd_set's be long-aligned.
  */
 static inline
 int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
 {
 	nr = FDS_BYTES(nr);
 	if (ufdset)
 		return copy_from_user(fdset, ufdset, nr) ? -EFAULT : 0;
 	memset(fdset, 0, nr);
 	return 0;
 }
 static inline unsigned long __must_check
 set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
 {
 	if (ufdset)
 		return __copy_to_user(ufdset, fdset, FDS_BYTES(nr));
 	return 0;
 }
 static inline
 void zero_fd_set(unsigned long nr, unsigned long *fdset)
 {
 	memset(fdset, 0, FDS_BYTES(nr));
 }
 #define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1)
 extern int do_select(int n, fd_set_bits *fds, s64 *timeout);
 extern int do_sys_poll(struct pollfd __user * ufds, unsigned int nfds,
 		       s64 *timeout);
 #endif /* KERNEL */
 #endif /* _LINUX_POLL_H */

include/sound/pcm.h

Diff comments View file @ f23f6e0

 #ifndef __SOUND_PCM_H
 #define __SOUND_PCM_H
 /*
  *  Digital Audio (PCM) abstract layer
  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
  *                   Abramo Bagnara <abramo@alsa-project.org>
  *
  *
  *   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */
 #include <sound/asound.h>
 #include <sound/memalloc.h>
 #include <linux/poll.h>
+#include <linux/mm.h>
 #include <linux/bitops.h>
 #define snd_pcm_substream_chip(substream) ((substream)->private_data)
 #define snd_pcm_chip(pcm) ((pcm)->private_data)
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 #include "pcm_oss.h"
 #endif
 /*
  *  Hardware (lowlevel) section
  */
 struct snd_pcm_hardware {
 	unsigned int info;		/* SNDRV_PCM_INFO_* */
 	u64 formats;			/* SNDRV_PCM_FMTBIT_* */
 	unsigned int rates;		/* SNDRV_PCM_RATE_* */
 	unsigned int rate_min;		/* min rate */
 	unsigned int rate_max;		/* max rate */
 	unsigned int channels_min;	/* min channels */
 	unsigned int channels_max;	/* max channels */
 	size_t buffer_bytes_max;	/* max buffer size */
 	size_t period_bytes_min;	/* min period size */
 	size_t period_bytes_max;	/* max period size */
 	unsigned int periods_min;	/* min # of periods */
 	unsigned int periods_max;	/* max # of periods */
 	size_t fifo_size;		/* fifo size in bytes */
 };
 struct snd_pcm_ops {
 	int (*open)(struct snd_pcm_substream *substream);
 	int (*close)(struct snd_pcm_substream *substream);
 	int (*ioctl)(struct snd_pcm_substream * substream,
 		     unsigned int cmd, void *arg);
 	int (*hw_params)(struct snd_pcm_substream *substream,
 			 struct snd_pcm_hw_params *params);
 	int (*hw_free)(struct snd_pcm_substream *substream);
 	int (*prepare)(struct snd_pcm_substream *substream);
 	int (*trigger)(struct snd_pcm_substream *substream, int cmd);
 	snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
 	int (*copy)(struct snd_pcm_substream *substream, int channel,
 		    snd_pcm_uframes_t pos,
 		    void __user *buf, snd_pcm_uframes_t count);
 	int (*silence)(struct snd_pcm_substream *substream, int channel,
 		       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
 	struct page *(*page)(struct snd_pcm_substream *substream,
 			     unsigned long offset);
 	int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
 	int (*ack)(struct snd_pcm_substream *substream);
 };
 /*
  *
  */
 #define SNDRV_PCM_DEVICES		8
 #define SNDRV_PCM_IOCTL1_FALSE		((void *)0)
 #define SNDRV_PCM_IOCTL1_TRUE		((void *)1)
 #define SNDRV_PCM_IOCTL1_RESET		0
 #define SNDRV_PCM_IOCTL1_INFO		1
 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO	2
 #define SNDRV_PCM_IOCTL1_GSTATE		3
 #define SNDRV_PCM_TRIGGER_STOP		0
 #define SNDRV_PCM_TRIGGER_START		1
 #define SNDRV_PCM_TRIGGER_PAUSE_PUSH	3
 #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE	4
 #define SNDRV_PCM_TRIGGER_SUSPEND	5
 #define SNDRV_PCM_TRIGGER_RESUME	6
 #define SNDRV_PCM_POS_XRUN		((snd_pcm_uframes_t)-1)
 /* If you change this don't forget to change rates[] table in pcm_native.c */
 #define SNDRV_PCM_RATE_5512		(1<<0)		/* 5512Hz */
 #define SNDRV_PCM_RATE_8000		(1<<1)		/* 8000Hz */
 #define SNDRV_PCM_RATE_11025		(1<<2)		/* 11025Hz */
 #define SNDRV_PCM_RATE_16000		(1<<3)		/* 16000Hz */
 #define SNDRV_PCM_RATE_22050		(1<<4)		/* 22050Hz */
 #define SNDRV_PCM_RATE_32000		(1<<5)		/* 32000Hz */
 #define SNDRV_PCM_RATE_44100		(1<<6)		/* 44100Hz */
 #define SNDRV_PCM_RATE_48000		(1<<7)		/* 48000Hz */
 #define SNDRV_PCM_RATE_64000		(1<<8)		/* 64000Hz */
 #define SNDRV_PCM_RATE_88200		(1<<9)		/* 88200Hz */
 #define SNDRV_PCM_RATE_96000		(1<<10)		/* 96000Hz */
 #define SNDRV_PCM_RATE_176400		(1<<11)		/* 176400Hz */
 #define SNDRV_PCM_RATE_192000		(1<<12)		/* 192000Hz */
 #define SNDRV_PCM_RATE_CONTINUOUS	(1<<30)		/* continuous range */
 #define SNDRV_PCM_RATE_KNOT		(1<<31)		/* supports more non-continuos rates */
 #define SNDRV_PCM_RATE_8000_44100	(SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
 					 SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
 					 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
 #define SNDRV_PCM_RATE_8000_48000	(SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
 #define SNDRV_PCM_RATE_8000_96000	(SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
 					 SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
 #define SNDRV_PCM_RATE_8000_192000	(SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
 					 SNDRV_PCM_RATE_192000)
 #define SNDRV_PCM_FMTBIT_S8		(1ULL << SNDRV_PCM_FORMAT_S8)
 #define SNDRV_PCM_FMTBIT_U8		(1ULL << SNDRV_PCM_FORMAT_U8)
 #define SNDRV_PCM_FMTBIT_S16_LE		(1ULL << SNDRV_PCM_FORMAT_S16_LE)
 #define SNDRV_PCM_FMTBIT_S16_BE		(1ULL << SNDRV_PCM_FORMAT_S16_BE)
 #define SNDRV_PCM_FMTBIT_U16_LE		(1ULL << SNDRV_PCM_FORMAT_U16_LE)
 #define SNDRV_PCM_FMTBIT_U16_BE		(1ULL << SNDRV_PCM_FORMAT_U16_BE)
 #define SNDRV_PCM_FMTBIT_S24_LE		(1ULL << SNDRV_PCM_FORMAT_S24_LE)
 #define SNDRV_PCM_FMTBIT_S24_BE		(1ULL << SNDRV_PCM_FORMAT_S24_BE)
 #define SNDRV_PCM_FMTBIT_U24_LE		(1ULL << SNDRV_PCM_FORMAT_U24_LE)
 #define SNDRV_PCM_FMTBIT_U24_BE		(1ULL << SNDRV_PCM_FORMAT_U24_BE)
 #define SNDRV_PCM_FMTBIT_S32_LE		(1ULL << SNDRV_PCM_FORMAT_S32_LE)
 #define SNDRV_PCM_FMTBIT_S32_BE		(1ULL << SNDRV_PCM_FORMAT_S32_BE)
 #define SNDRV_PCM_FMTBIT_U32_LE		(1ULL << SNDRV_PCM_FORMAT_U32_LE)
 #define SNDRV_PCM_FMTBIT_U32_BE		(1ULL << SNDRV_PCM_FORMAT_U32_BE)
 #define SNDRV_PCM_FMTBIT_FLOAT_LE	(1ULL << SNDRV_PCM_FORMAT_FLOAT_LE)
 #define SNDRV_PCM_FMTBIT_FLOAT_BE	(1ULL << SNDRV_PCM_FORMAT_FLOAT_BE)
 #define SNDRV_PCM_FMTBIT_FLOAT64_LE	(1ULL << SNDRV_PCM_FORMAT_FLOAT64_LE)
 #define SNDRV_PCM_FMTBIT_FLOAT64_BE	(1ULL << SNDRV_PCM_FORMAT_FLOAT64_BE)
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE)
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE (1ULL << SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE)
 #define SNDRV_PCM_FMTBIT_MU_LAW		(1ULL << SNDRV_PCM_FORMAT_MU_LAW)
 #define SNDRV_PCM_FMTBIT_A_LAW		(1ULL << SNDRV_PCM_FORMAT_A_LAW)
 #define SNDRV_PCM_FMTBIT_IMA_ADPCM	(1ULL << SNDRV_PCM_FORMAT_IMA_ADPCM)
 #define SNDRV_PCM_FMTBIT_MPEG		(1ULL << SNDRV_PCM_FORMAT_MPEG)
 #define SNDRV_PCM_FMTBIT_GSM		(1ULL << SNDRV_PCM_FORMAT_GSM)
 #define SNDRV_PCM_FMTBIT_SPECIAL	(1ULL << SNDRV_PCM_FORMAT_SPECIAL)
 #define SNDRV_PCM_FMTBIT_S24_3LE	(1ULL << SNDRV_PCM_FORMAT_S24_3LE)
 #define SNDRV_PCM_FMTBIT_U24_3LE	(1ULL << SNDRV_PCM_FORMAT_U24_3LE)
 #define SNDRV_PCM_FMTBIT_S24_3BE	(1ULL << SNDRV_PCM_FORMAT_S24_3BE)
 #define SNDRV_PCM_FMTBIT_U24_3BE	(1ULL << SNDRV_PCM_FORMAT_U24_3BE)
 #define SNDRV_PCM_FMTBIT_S20_3LE	(1ULL << SNDRV_PCM_FORMAT_S20_3LE)
 #define SNDRV_PCM_FMTBIT_U20_3LE	(1ULL << SNDRV_PCM_FORMAT_U20_3LE)
 #define SNDRV_PCM_FMTBIT_S20_3BE	(1ULL << SNDRV_PCM_FORMAT_S20_3BE)
 #define SNDRV_PCM_FMTBIT_U20_3BE	(1ULL << SNDRV_PCM_FORMAT_U20_3BE)
 #define SNDRV_PCM_FMTBIT_S18_3LE	(1ULL << SNDRV_PCM_FORMAT_S18_3LE)
 #define SNDRV_PCM_FMTBIT_U18_3LE	(1ULL << SNDRV_PCM_FORMAT_U18_3LE)
 #define SNDRV_PCM_FMTBIT_S18_3BE	(1ULL << SNDRV_PCM_FORMAT_S18_3BE)
 #define SNDRV_PCM_FMTBIT_U18_3BE	(1ULL << SNDRV_PCM_FORMAT_U18_3BE)
 #ifdef SNDRV_LITTLE_ENDIAN
 #define SNDRV_PCM_FMTBIT_S16		SNDRV_PCM_FMTBIT_S16_LE
 #define SNDRV_PCM_FMTBIT_U16		SNDRV_PCM_FMTBIT_U16_LE
 #define SNDRV_PCM_FMTBIT_S24		SNDRV_PCM_FMTBIT_S24_LE
 #define SNDRV_PCM_FMTBIT_U24		SNDRV_PCM_FMTBIT_U24_LE
 #define SNDRV_PCM_FMTBIT_S32		SNDRV_PCM_FMTBIT_S32_LE
 #define SNDRV_PCM_FMTBIT_U32		SNDRV_PCM_FMTBIT_U32_LE
 #define SNDRV_PCM_FMTBIT_FLOAT		SNDRV_PCM_FMTBIT_FLOAT_LE
 #define SNDRV_PCM_FMTBIT_FLOAT64	SNDRV_PCM_FMTBIT_FLOAT64_LE
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
 #endif
 #ifdef SNDRV_BIG_ENDIAN
 #define SNDRV_PCM_FMTBIT_S16		SNDRV_PCM_FMTBIT_S16_BE
 #define SNDRV_PCM_FMTBIT_U16		SNDRV_PCM_FMTBIT_U16_BE
 #define SNDRV_PCM_FMTBIT_S24		SNDRV_PCM_FMTBIT_S24_BE
 #define SNDRV_PCM_FMTBIT_U24		SNDRV_PCM_FMTBIT_U24_BE
 #define SNDRV_PCM_FMTBIT_S32		SNDRV_PCM_FMTBIT_S32_BE
 #define SNDRV_PCM_FMTBIT_U32		SNDRV_PCM_FMTBIT_U32_BE
 #define SNDRV_PCM_FMTBIT_FLOAT		SNDRV_PCM_FMTBIT_FLOAT_BE
 #define SNDRV_PCM_FMTBIT_FLOAT64	SNDRV_PCM_FMTBIT_FLOAT64_BE
 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
 #endif
 struct snd_pcm_file {
 	struct snd_pcm_substream *substream;
 	int no_compat_mmap;
 };
 struct snd_pcm_hw_rule;
 typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
 				      struct snd_pcm_hw_rule *rule);
 struct snd_pcm_hw_rule {
 	unsigned int cond;
 	snd_pcm_hw_rule_func_t func;
 	int var;
 	int deps[4];
 	void *private;
 };
 struct snd_pcm_hw_constraints {
 	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
 			 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
 	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
 			     SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
 	unsigned int rules_num;
 	unsigned int rules_all;
 	struct snd_pcm_hw_rule *rules;
 };
 static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
 					    snd_pcm_hw_param_t var)
 {
 	return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
 }
 static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
 						    snd_pcm_hw_param_t var)
 {
 	return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 }
 struct snd_ratnum {
 	unsigned int num;
 	unsigned int den_min, den_max, den_step;
 };
 struct snd_ratden {
 	unsigned int num_min, num_max, num_step;
 	unsigned int den;
 };
 struct snd_pcm_hw_constraint_ratnums {
 	int nrats;
 	struct snd_ratnum *rats;
 };
 struct snd_pcm_hw_constraint_ratdens {
 	int nrats;
 	struct snd_ratden *rats;
 };
 struct snd_pcm_hw_constraint_list {
 	unsigned int count;
 	unsigned int *list;
 	unsigned int mask;
 };
 struct snd_pcm_runtime {
 	/* -- Status -- */
 	struct snd_pcm_substream *trigger_master;
 	struct timespec trigger_tstamp;	/* trigger timestamp */
 	int overrange;
 	snd_pcm_uframes_t avail_max;
 	snd_pcm_uframes_t hw_ptr_base;	/* Position at buffer restart */
 	snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time*/
 	/* -- HW params -- */
 	snd_pcm_access_t access;	/* access mode */
 	snd_pcm_format_t format;	/* SNDRV_PCM_FORMAT_* */
 	snd_pcm_subformat_t subformat;	/* subformat */
 	unsigned int rate;		/* rate in Hz */
 	unsigned int channels;		/* channels */
 	snd_pcm_uframes_t period_size;	/* period size */
 	unsigned int periods;		/* periods */
 	snd_pcm_uframes_t buffer_size;	/* buffer size */
 	unsigned int tick_time;		/* tick time */
 	snd_pcm_uframes_t min_align;	/* Min alignment for the format */
 	size_t byte_align;
 	unsigned int frame_bits;
 	unsigned int sample_bits;
 	unsigned int info;
 	unsigned int rate_num;
 	unsigned int rate_den;
 	/* -- SW params -- */
 	int tstamp_mode;		/* mmap timestamp is updated */
   	unsigned int period_step;
 	unsigned int sleep_min;		/* min ticks to sleep */
 	snd_pcm_uframes_t xfer_align;	/* xfer size need to be a multiple */
 	snd_pcm_uframes_t start_threshold;
 	snd_pcm_uframes_t stop_threshold;
 	snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
 						noise is nearest than this */
 	snd_pcm_uframes_t silence_size;	/* Silence filling size */
 	snd_pcm_uframes_t boundary;	/* pointers wrap point */
 	snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
 	snd_pcm_uframes_t silence_filled; /* size filled with silence */
 	union snd_pcm_sync_id sync;	/* hardware synchronization ID */
 	/* -- mmap -- */
 	volatile struct snd_pcm_mmap_status *status;
 	volatile struct snd_pcm_mmap_control *control;
 	/* -- locking / scheduling -- */
 	wait_queue_head_t sleep;
 	struct timer_list tick_timer;
 	struct fasync_struct *fasync;
 	/* -- private section -- */
 	void *private_data;
 	void (*private_free)(struct snd_pcm_runtime *runtime);
 	/* -- hardware description -- */
 	struct snd_pcm_hardware hw;
 	struct snd_pcm_hw_constraints hw_constraints;
 	/* -- interrupt callbacks -- */
 	void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
 	void (*transfer_ack_end)(struct snd_pcm_substream *substream);
 	/* -- timer -- */
 	unsigned int timer_resolution;	/* timer resolution */
 	/* -- DMA -- */
 	unsigned char *dma_area;	/* DMA area */
 	dma_addr_t dma_addr;		/* physical bus address (not accessible from main CPU) */
 	size_t dma_bytes;		/* size of DMA area */
 	struct snd_dma_buffer *dma_buffer_p;	/* allocated buffer */
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 	/* -- OSS things -- */
 	struct snd_pcm_oss_runtime oss;
 #endif
 };
 struct snd_pcm_group {		/* keep linked substreams */
 	spinlock_t lock;
 	struct list_head substreams;
 	int count;
 };
 struct snd_pcm_substream {
 	struct snd_pcm *pcm;
 	struct snd_pcm_str *pstr;
 	void *private_data;		/* copied from pcm->private_data */
 	int number;
 	char name[32];			/* substream name */
 	int stream;			/* stream (direction) */
 	char latency_id[20];		/* latency identifier */
 	size_t buffer_bytes_max;	/* limit ring buffer size */
 	struct snd_dma_buffer dma_buffer;
 	unsigned int dma_buf_id;
 	size_t dma_max;
 	/* -- hardware operations -- */
 	struct snd_pcm_ops *ops;
 	/* -- runtime information -- */
 	struct snd_pcm_runtime *runtime;
         /* -- timer section -- */
 	struct snd_timer *timer;		/* timer */
 	unsigned timer_running: 1;	/* time is running */
 	spinlock_t timer_lock;
 	/* -- next substream -- */
 	struct snd_pcm_substream *next;
 	/* -- linked substreams -- */
 	struct list_head link_list;	/* linked list member */
 	struct snd_pcm_group self_group;	/* fake group for non linked substream (with substream lock inside) */
 	struct snd_pcm_group *group;		/* pointer to current group */
 	/* -- assigned files -- */
 	void *file;
 	int ref_count;
 	atomic_t mmap_count;
 	unsigned int f_flags;
 	void (*pcm_release)(struct snd_pcm_substream *);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 	/* -- OSS things -- */
 	struct snd_pcm_oss_substream oss;
 #endif
 #ifdef CONFIG_SND_VERBOSE_PROCFS
 	struct snd_info_entry *proc_root;
 	struct snd_info_entry *proc_info_entry;
 	struct snd_info_entry *proc_hw_params_entry;
 	struct snd_info_entry *proc_sw_params_entry;
 	struct snd_info_entry *proc_status_entry;
 	struct snd_info_entry *proc_prealloc_entry;
 #endif
 	/* misc flags */
 	unsigned int hw_opened: 1;
 };
 #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
 struct snd_pcm_str {
 	int stream;				/* stream (direction) */
 	struct snd_pcm *pcm;
 	/* -- substreams -- */
 	unsigned int substream_count;
 	unsigned int substream_opened;
 	struct snd_pcm_substream *substream;
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 	/* -- OSS things -- */
 	struct snd_pcm_oss_stream oss;
 #endif
 #ifdef CONFIG_SND_VERBOSE_PROCFS
 	struct snd_info_entry *proc_root;
 	struct snd_info_entry *proc_info_entry;
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
 	unsigned int xrun_debug;	/* 0 = disabled, 1 = verbose, 2 = stacktrace */
 	struct snd_info_entry *proc_xrun_debug_entry;
 #endif
 #endif
 };
 struct snd_pcm {
 	struct snd_card *card;
 	struct list_head list;
 	unsigned int device;	/* device number */
 	unsigned int info_flags;
 	unsigned short dev_class;
 	unsigned short dev_subclass;
 	char id[64];
 	char name[80];
 	struct snd_pcm_str streams[2];
 	struct mutex open_mutex;
 	wait_queue_head_t open_wait;
 	void *private_data;
 	void (*private_free) (struct snd_pcm *pcm);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 	struct snd_pcm_oss oss;
 #endif
 };
 struct snd_pcm_notify {
 	int (*n_register) (struct snd_pcm * pcm);
 	int (*n_disconnect) (struct snd_pcm * pcm);
 	int (*n_unregister) (struct snd_pcm * pcm);
 	struct list_head list;
 };
 /*
  *  Registering
  */
 extern struct file_operations snd_pcm_f_ops[2];
 int snd_pcm_new(struct snd_card *card, char *id, int device,
 		int playback_count, int capture_count,
 		struct snd_pcm **rpcm);
 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
 /*
  *  Native I/O
  */
 extern rwlock_t snd_pcm_link_rwlock;
 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
 int snd_pcm_info_user(struct snd_pcm_substream *substream,
 		      struct snd_pcm_info __user *info);
 int snd_pcm_status(struct snd_pcm_substream *substream,
 		   struct snd_pcm_status *status);
 int snd_pcm_start(struct snd_pcm_substream *substream);
 int snd_pcm_stop(struct snd_pcm_substream *substream, int status);
 int snd_pcm_drain_done(struct snd_pcm_substream *substream);
 #ifdef CONFIG_PM
 int snd_pcm_suspend(struct snd_pcm_substream *substream);
 int snd_pcm_suspend_all(struct snd_pcm *pcm);
 #endif
 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
 			   struct snd_pcm_substream **rsubstream);
 void snd_pcm_release_substream(struct snd_pcm_substream *substream);
 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
 			     struct snd_pcm_substream **rsubstream);
 void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
 void snd_pcm_vma_notify_data(void *client, void *data);
 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
 #if BITS_PER_LONG >= 64
 static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
 {
 	*rem = *n % div;
 	*n /= div;
 }
 #elif defined(i386)
 static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
 {
 	u_int32_t low, high;
 	low = *n & 0xffffffff;
 	high = *n >> 32;
 	if (high) {
 		u_int32_t high1 = high % div;
 		high /= div;
 		asm("divl %2":"=a" (low), "=d" (*rem):"rm" (div), "a" (low), "d" (high1));
 		*n = (u_int64_t)high << 32 | low;
 	} else {
 		*n = low / div;
 		*rem = low % div;
 	}
 }
 #else
 static inline void divl(u_int32_t high, u_int32_t low,
 			u_int32_t div,
 			u_int32_t *q, u_int32_t *r)
 {
 	u_int64_t n = (u_int64_t)high << 32 | low;
 	u_int64_t d = (u_int64_t)div << 31;
 	u_int32_t q1 = 0;
 	int c = 32;
 	while (n > 0xffffffffU) {
 		q1 <<= 1;
 		if (n >= d) {
 			n -= d;
 			q1 |= 1;
 		}
 		d >>= 1;
 		c--;
 	}
 	q1 <<= c;
 	if (n) {
 		low = n;
 		*q = q1 | (low / div);
 		*r = low % div;
 	} else {
 		*r = 0;
 		*q = q1;
 	}
 	return;
 }
 static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
 {
 	u_int32_t low, high;
 	low = *n & 0xffffffff;
 	high = *n >> 32;
 	if (high) {
 		u_int32_t high1 = high % div;
 		u_int32_t low1 = low;
 		high /= div;
 		divl(high1, low1, div, &low, rem);
 		*n = (u_int64_t)high << 32 | low;
 	} else {
 		*n = low / div;
 		*rem = low % div;
 	}
 }
 #endif
 /*
  *  PCM library
  */
 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
 {
 	return substream->group != &substream->self_group;
 }
 static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
 {
 	read_lock(&snd_pcm_link_rwlock);
 	spin_lock(&substream->self_group.lock);
 }
 static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
 {
 	spin_unlock(&substream->self_group.lock);
 	read_unlock(&snd_pcm_link_rwlock);
 }
 static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
 {
 	read_lock_irq(&snd_pcm_link_rwlock);
 	spin_lock(&substream->self_group.lock);
 }
 static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
 {
 	spin_unlock(&substream->self_group.lock);
 	read_unlock_irq(&snd_pcm_link_rwlock);
 }
 #define snd_pcm_stream_lock_irqsave(substream, flags) \
 do { \
 	read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \
 	spin_lock(&substream->self_group.lock); \
 } while (0)
 #define snd_pcm_stream_unlock_irqrestore(substream, flags) \
 do { \
 	spin_unlock(&substream->self_group.lock); \
 	read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \
 } while (0)
 #define snd_pcm_group_for_each(pos, substream) \
 	list_for_each(pos, &substream->group->substreams)
 #define snd_pcm_group_substream_entry(pos) \
 	list_entry(pos, struct snd_pcm_substream, link_list)
 static inline int snd_pcm_running(struct snd_pcm_substream *substream)
 {
 	return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
 		(substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
 		 substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
 }
 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
 {
 	return size * 8 / runtime->sample_bits;
 }
 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
 {
 	return size * 8 / runtime->frame_bits;
 }
 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
 {
 	return size * runtime->sample_bits / 8;
 }
 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
 {
 	return size * runtime->frame_bits / 8;
 }
 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
 {
 	return bytes % runtime->byte_align == 0;
 }
 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return frames_to_bytes(runtime, runtime->buffer_size);
 }
 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return frames_to_bytes(runtime, runtime->period_size);
 }
 /*
  *  result is: 0 ... (boundary - 1)
  */
 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
 {
 	snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
 	if (avail < 0)
 		avail += runtime->boundary;
 	else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
 		avail -= runtime->boundary;
 	return avail;
 }
 /*
  *  result is: 0 ... (boundary - 1)
  */
 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
 {
 	snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
 	if (avail < 0)
 		avail += runtime->boundary;
 	return avail;
 }
 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
 {
 	return runtime->buffer_size - snd_pcm_playback_avail(runtime);
 }
 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
 {
 	return runtime->buffer_size - snd_pcm_capture_avail(runtime);
 }
 /**
  * snd_pcm_playback_ready - check whether the playback buffer is available
  * @substream: the pcm substream instance
  *
  * Checks whether enough free space is available on the playback buffer.
  *
  * Returns non-zero if available, or zero if not.
  */
 static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
 }
 /**
  * snd_pcm_capture_ready - check whether the capture buffer is available
  * @substream: the pcm substream instance
  *
  * Checks whether enough capture data is available on the capture buffer.
  *
  * Returns non-zero if available, or zero if not.
  */
 static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
 }
 /**
  * snd_pcm_playback_data - check whether any data exists on the playback buffer
  * @substream: the pcm substream instance
  *
  * Checks whether any data exists on the playback buffer. If stop_threshold
  * is bigger or equal to boundary, then this function returns always non-zero.
  *
  * Returns non-zero if exists, or zero if not.
  */
 static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	if (runtime->stop_threshold >= runtime->boundary)
 		return 1;
 	return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
 }
 /**
  * snd_pcm_playback_empty - check whether the playback buffer is empty
  * @substream: the pcm substream instance
  *
  * Checks whether the playback buffer is empty.
  *
  * Returns non-zero if empty, or zero if not.
  */
 static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
 }
 /**
  * snd_pcm_capture_empty - check whether the capture buffer is empty
  * @substream: the pcm substream instance
  *
  * Checks whether the capture buffer is empty.
  *
  * Returns non-zero if empty, or zero if not.
  */
 static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	return snd_pcm_capture_avail(runtime) == 0;
 }
 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
 					struct snd_pcm_substream *master)
 {
 	substream->runtime->trigger_master = master;
 }
 static inline int hw_is_mask(int var)
 {
 	return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
 		var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
 }
 static inline int hw_is_interval(int var)
 {
 	return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
 		var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
 }
 static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
 				     snd_pcm_hw_param_t var)
 {
 	return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
 }
 static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
 					     snd_pcm_hw_param_t var)
 {
 	return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
 }
 static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
 					     snd_pcm_hw_param_t var)
 {
 	return (const struct snd_mask *)hw_param_mask((struct snd_pcm_hw_params*) params, var);
 }
 static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
 						     snd_pcm_hw_param_t var)
 {
 	return (const struct snd_interval *)hw_param_interval((struct snd_pcm_hw_params*) params, var);
 }
 #define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS))
 #define params_format(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_FORMAT))
 #define params_subformat(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_SUBFORMAT))
 #define params_channels(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min
 #define params_rate(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_RATE)->min
 #define params_period_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min
 #define params_period_bytes(p) ((params_period_size(p)*snd_pcm_format_physical_width(params_format(p))*params_channels(p))/8)
 #define params_periods(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_PERIODS)->min
 #define params_buffer_size(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min
 #define params_buffer_bytes(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min
 #define params_tick_time(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_TICK_TIME)->min
 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
 			  unsigned int k, struct snd_interval *c);
 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
 			  const struct snd_interval *b, struct snd_interval *c);
 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask);
 int snd_interval_ratnum(struct snd_interval *i,
 			unsigned int rats_count, struct snd_ratnum *rats,
 			unsigned int *nump, unsigned int *denp);
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
 int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream);
 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream);
 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 			       u_int32_t mask);
 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 				 u_int64_t mask);
 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 				 unsigned int min, unsigned int max);
 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var,
 			       struct snd_pcm_hw_constraint_list *l);
 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
 				  unsigned int cond,
 				  snd_pcm_hw_param_t var,
 				  struct snd_pcm_hw_constraint_ratnums *r);
 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
 				  unsigned int cond,
 				  snd_pcm_hw_param_t var,
 				  struct snd_pcm_hw_constraint_ratdens *r);
 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
 				 unsigned int cond,
 				 unsigned int width,
 				 unsigned int msbits);
 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var,
 			       unsigned long step);
 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var);
 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
 			unsigned int cond,
 			int var,
 			snd_pcm_hw_rule_func_t func, void *private,
 			int dep, ...);
 int snd_pcm_format_signed(snd_pcm_format_t format);
 int snd_pcm_format_unsigned(snd_pcm_format_t format);
 int snd_pcm_format_linear(snd_pcm_format_t format);
 int snd_pcm_format_little_endian(snd_pcm_format_t format);
 int snd_pcm_format_big_endian(snd_pcm_format_t format);
 #if 0 /* just for DocBook */
 /**
  * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
  * @format: the format to check
  *
  * Returns 1 if the given PCM format is CPU-endian, 0 if
  * opposite, or a negative error code if endian not specified.
  */
 int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
 #endif /* DocBook */
 #ifdef SNDRV_LITTLE_ENDIAN
 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
 #else
 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
 #endif
 int snd_pcm_format_width(snd_pcm_format_t format);			/* in bits */
 int snd_pcm_format_physical_width(snd_pcm_format_t format);		/* in bits */
 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
 snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian);
 void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops);
 void snd_pcm_set_sync(struct snd_pcm_substream *substream);
 int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
 		      unsigned int cmd, void *arg);
 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
 int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);
 int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream);
 int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream);
 int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream);
 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr);
 void snd_pcm_tick_prepare(struct snd_pcm_substream *substream);
 void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks);
 void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream);
 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream,
 				    const void __user *buf,
 				    snd_pcm_uframes_t frames);
 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream,
 				   void __user *buf, snd_pcm_uframes_t frames);
 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
 				     void __user **bufs, snd_pcm_uframes_t frames);
 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
 				    void __user **bufs, snd_pcm_uframes_t frames);
 int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
 static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
 					      struct snd_dma_buffer *bufp)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	if (bufp) {
 		runtime->dma_buffer_p = bufp;
 		runtime->dma_area = bufp->area;
 		runtime->dma_addr = bufp->addr;
 		runtime->dma_bytes = bufp->bytes;
 	} else {
 		runtime->dma_buffer_p = NULL;
 		runtime->dma_area = NULL;
 		runtime->dma_addr = 0;
 		runtime->dma_bytes = 0;
 	}
 }
 /*
  *  Timer interface
  */
 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
 void snd_pcm_timer_init(struct snd_pcm_substream *substream);
 void snd_pcm_timer_done(struct snd_pcm_substream *substream);
 /*
  *  Memory
  */
 int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
 int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
 int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
 				  int type, struct device *data,
 				  size_t size, size_t max);
 int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
 					  int type, void *data,
 					  size_t size, size_t max);
 int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
 #define snd_pcm_substream_sgbuf(substream) ((substream)->runtime->dma_buffer_p->private_data)
 #define snd_pcm_sgbuf_pages(size) snd_sgbuf_aligned_pages(size)
 #define snd_pcm_sgbuf_get_addr(sgbuf,ofs) snd_sgbuf_get_addr(sgbuf,ofs)
 struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset);
 /* handle mmap counter - PCM mmap callback should handle this counter properly */
 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
 {
 	struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
 	atomic_inc(&substream->mmap_count);
 }
 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
 {
 	struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
 	atomic_dec(&substream->mmap_count);
 }
 /* mmap for io-memory area */
 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
 #define SNDRV_PCM_INFO_MMAP_IOMEM	SNDRV_PCM_INFO_MMAP
 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
 #else
 #define SNDRV_PCM_INFO_MMAP_IOMEM	0
 #define snd_pcm_lib_mmap_iomem	NULL
 #endif
 static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
 {
 	*max = dma < 4 ? 64 * 1024 : 128 * 1024;
 }
 /*
  *  Misc
  */
 #define SNDRV_PCM_DEFAULT_CON_SPDIF	(IEC958_AES0_CON_EMPHASIS_NONE|\
 					 (IEC958_AES1_CON_ORIGINAL<<8)|\
 					 (IEC958_AES1_CON_PCM_CODER<<8)|\
 					 (IEC958_AES3_CON_FS_48000<<24))
 #endif /* __SOUND_PCM_H */

sound/oss/cs46xx.c

Diff comments View file @ f23f6e0

 /*
  *	Crystal SoundFusion CS46xx driver
  *
  *	Copyright 1998-2001 Cirrus Logic Corporation <pcaudio@crystal.cirrus.com>
  *						<twoller@crystal.cirrus.com>
  *	Copyright 1999-2000 Jaroslav Kysela <perex@suse.cz>
  *	Copyright 2000 Alan Cox <alan@redhat.com>
  *
  *	The core of this code is taken from the ALSA project driver by
  *	Jaroslav. Please send Jaroslav the credit for the driver and
  *	report bugs in this port to <alan@redhat.com>
  *
  *	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.
  *	Current maintainers:
  *		Cirrus Logic Corporation, Thomas Woller (tw)
  *			<twoller@crystal.cirrus.com>
  *		Nils Faerber (nf)
  *			<nils@kernelconcepts.de>
  *		Thanks to David Pollard for testing.
  *
  *	Changes:
  *	20000909-nf	Changed cs_read, cs_write and drain_dac
  *	20001025-tw	Separate Playback/Capture structs and buffers.
  *			Added Scatter/Gather support for Playback.
  *			Added Capture.
  *	20001027-nf	Port to kernel 2.4.0-test9, some clean-ups
  *			Start of powermanagement support (CS46XX_PM).
  *	20001128-tw	Add module parm for default buffer order.
  *			added DMA_GFP flag to kmalloc dma buffer allocs.
  *			backfill silence to eliminate stuttering on
  *			underruns.
  *	20001201-tw	add resyncing of swptr on underruns.
  *	20001205-tw-nf	fixed GETOSPACE ioctl() after open()
  *	20010113-tw	patch from Hans Grobler general cleanup.
  *	20010117-tw	2.4.0 pci cleanup, wrapper code for 2.2.16-2.4.0
  *	20010118-tw	basic PM support for 2.2.16+ and 2.4.0/2.4.2.
  *	20010228-dh	patch from David Huggins - cs_update_ptr recursion.
  *	20010409-tw	add hercules game theatre XP amp code.
  *	20010420-tw	cleanup powerdown/up code.
  *	20010521-tw	eliminate pops, and fixes for powerdown.
  *	20010525-tw	added fixes for thinkpads with powerdown logic.
  *	20010723-sh     patch from Horms (Simon Horman) -
  *	                SOUND_PCM_READ_BITS returns bits as set in driver
  *	                rather than a logical or of the possible values.
  *	                Various ioctls handle the case where the device
  *	                is open for reading or writing but not both better.
  *
  *	Status:
  *	Playback/Capture supported from 8k-48k.
  *	16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
  *
  *	APM/PM - 2.2.x APM is enabled and functioning fine. APM can also
  *	be enabled for 2.4.x by modifying the CS46XX_ACPI_SUPPORT macro
  *	definition.
  *
  *      Hercules Game Theatre XP - the EGPIO2 pin controls the external Amp,
  *	so, use the drain/polarity to enable.
  *	hercules_egpio_disable set to 1, will force a 0 to EGPIODR.
  *
  *	VTB Santa Cruz - the GPIO7/GPIO8 on the Secondary Codec control
  *	the external amplifier for the "back" speakers, since we do not
  *	support the secondary codec then this external amp is also not
  *	turned on.
  */
 #include <linux/interrupt.h>
 #include <linux/list.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/slab.h>
 #include <linux/soundcard.h>
 #include <linux/pci.h>
 #include <linux/bitops.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/ac97_codec.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 #include <asm/io.h>
 #include <asm/dma.h>
 #include <asm/uaccess.h>
 #include "cs46xxpm.h"
 #include "cs46xx_wrapper-24.h"
 #include "cs461x.h"
 /* MIDI buffer sizes */
 #define CS_MIDIINBUF  500
 #define CS_MIDIOUTBUF 500
 #define ADC_RUNNING	1
 #define DAC_RUNNING	2
 #define CS_FMT_16BIT	1		/* These are fixed in fact */
 #define CS_FMT_STEREO	2
 #define CS_FMT_MASK	3
 #define CS_TYPE_ADC	1
 #define CS_TYPE_DAC	2
 #define CS_TRUE 	1
 #define CS_FALSE 	0
 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
 #define CS_IN_USE(m) (atomic_read(m) != 0)
 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
 /*
  *	CS461x definitions
  */
 #define CS461X_BA0_SIZE		0x2000
 #define CS461X_BA1_DATA0_SIZE	0x3000
 #define CS461X_BA1_DATA1_SIZE	0x3800
 #define CS461X_BA1_PRG_SIZE	0x7000
 #define CS461X_BA1_REG_SIZE	0x0100
 #define GOF_PER_SEC	200
 #define CSDEBUG_INTERFACE 1
 #define CSDEBUG 1
 /*
  * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
  *
  *
  * CSDEBUG is usual mode is set to 1, then use the
  * cs_debuglevel and cs_debugmask to turn on or off debugging.
  * Debug level of 1 has been defined to be kernel errors and info
  * that should be printed on any released driver.
  */
 #if CSDEBUG
 #define CS_DBGOUT(mask,level,x) if ((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
 #else
 #define CS_DBGOUT(mask,level,x)
 #endif
 /*
  * cs_debugmask areas
  */
 #define CS_INIT	 	0x00000001		/* initialization and probe functions */
 #define CS_ERROR 	0x00000002		/* tmp debugging bit placeholder */
 #define CS_INTERRUPT	0x00000004		/* interrupt handler (separate from all other) */
 #define CS_FUNCTION 	0x00000008		/* enter/leave functions */
 #define CS_WAVE_WRITE 	0x00000010		/* write information for wave */
 #define CS_WAVE_READ 	0x00000020		/* read information for wave */
 #define CS_MIDI_WRITE 	0x00000040		/* write information for midi */
 #define CS_MIDI_READ 	0x00000080		/* read information for midi */
 #define CS_MPU401_WRITE 0x00000100		/* write information for mpu401 */
 #define CS_MPU401_READ 	0x00000200		/* read information for mpu401 */
 #define CS_OPEN		0x00000400		/* all open functions in the driver */
 #define CS_RELEASE	0x00000800		/* all release functions in the driver */
 #define CS_PARMS	0x00001000		/* functional and operational parameters */
 #define CS_IOCTL	0x00002000		/* ioctl (non-mixer) */
 #define CS_PM		0x00004000		/* PM */
 #define CS_TMP		0x10000000		/* tmp debug mask bit */
 #define CS_IOCTL_CMD_SUSPEND	0x1	// suspend
 #define CS_IOCTL_CMD_RESUME	0x2	// resume
 #if CSDEBUG
 static unsigned long cs_debuglevel = 1;			/* levels range from 1-9 */
 module_param(cs_debuglevel, ulong, 0644);
 static unsigned long cs_debugmask = CS_INIT | CS_ERROR;	/* use CS_DBGOUT with various mask values */
 module_param(cs_debugmask, ulong, 0644);
 #endif
 static unsigned long hercules_egpio_disable;  /* if non-zero set all EGPIO to 0 */
 module_param(hercules_egpio_disable, ulong, 0);
 static unsigned long initdelay = 700;  /* PM delay in millisecs */
 module_param(initdelay, ulong, 0);
 static unsigned long powerdown = -1;  /* turn on/off powerdown processing in driver */
 module_param(powerdown, ulong, 0);
 #define DMABUF_DEFAULTORDER 3
 static unsigned long defaultorder = DMABUF_DEFAULTORDER;
 module_param(defaultorder, ulong, 0);
 static int external_amp;
 module_param(external_amp, bool, 0);
 static int thinkpad;
 module_param(thinkpad, bool, 0);
 /*
 * set the powerdown module parm to 0 to disable all
 * powerdown. also set thinkpad to 1 to disable powerdown,
 * but also to enable the clkrun functionality.
 */
 static unsigned cs_powerdown = 1;
 static unsigned cs_laptop_wait = 1;
 /* An instance of the 4610 channel */
 struct cs_channel
 {
 	int used;
 	int num;
 	void *state;
 };
 #define CS46XX_MAJOR_VERSION "1"
 #define CS46XX_MINOR_VERSION "28"
 #ifdef __ia64__
 #define CS46XX_ARCH	     	"64"	//architecture key
 #else
 #define CS46XX_ARCH	     	"32"	//architecture key
 #endif
 static struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
 /* magic numbers to protect our data structures */
 #define CS_CARD_MAGIC		0x43525553 /* "CRUS" */
 #define CS_STATE_MAGIC		0x4c4f4749 /* "LOGI" */
 #define NR_HW_CH		3
 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
 #define NR_AC97		2
 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 /* "software" or virtual channel, an instance of opened /dev/dsp */
 struct cs_state {
 	unsigned int magic;
 	struct cs_card *card;	/* Card info */
 	/* single open lock mechanism, only used for recording */
 	struct mutex open_mutex;
 	wait_queue_head_t open_wait;
 	/* file mode */
 	mode_t open_mode;
 	/* virtual channel number */
 	int virt;
 	struct dmabuf {
 		/* wave sample stuff */
 		unsigned int rate;
 		unsigned char fmt, enable;
 		/* hardware channel */
 		struct cs_channel *channel;
 		int pringbuf;		/* Software ring slot */
 		void *pbuf;		/* 4K hardware DMA buffer */
 		/* OSS buffer management stuff */
 		void *rawbuf;
 		dma_addr_t dma_handle;
 		unsigned buforder;
 		unsigned numfrag;
 		unsigned fragshift;
 		unsigned divisor;
 		unsigned type;
 		void *tmpbuff;			/* tmp buffer for sample conversions */
 		dma_addr_t dmaaddr;
 		dma_addr_t dmaaddr_tmpbuff;
 		unsigned buforder_tmpbuff;	/* Log base 2 of size in bytes.. */
 		/* our buffer acts like a circular ring */
 		unsigned hwptr;		/* where dma last started, updated by update_ptr */
 		unsigned swptr;		/* where driver last clear/filled, updated by read/write */
 		int count;		/* bytes to be comsumed or been generated by dma machine */
 		unsigned total_bytes;	/* total bytes dmaed by hardware */
 		unsigned blocks;	/* total blocks */
 		unsigned error;		/* number of over/underruns */
 		unsigned underrun;	/* underrun pending before next write has occurred */
 		wait_queue_head_t wait;	/* put process on wait queue when no more space in buffer */
 		/* redundant, but makes calculations easier */
 		unsigned fragsize;
 		unsigned dmasize;
 		unsigned fragsamples;
 		/* OSS stuff */
 		unsigned mapped:1;
 		unsigned ready:1;
 		unsigned endcleared:1;
 		unsigned SGok:1;
 		unsigned update_flag;
 		unsigned ossfragshift;
 		int ossmaxfrags;
 		unsigned subdivision;
 	} dmabuf;
 	/* Guard against mmap/write/read races */
 	struct mutex sem;
 };
 struct cs_card {
 	struct cs_channel channel[2];
 	unsigned int magic;
 	/* We keep cs461x cards in a linked list */
 	struct cs_card *next;
 	/* The cs461x has a certain amount of cross channel interaction
 	   so we use a single per card lock */
 	spinlock_t lock;
 	/* Keep AC97 sane */
 	spinlock_t ac97_lock;
 	/* mixer use count */
 	atomic_t mixer_use_cnt;
 	/* PCI device stuff */
 	struct pci_dev *pci_dev;
 	struct list_head list;
 	unsigned int pctl, cctl;	/* Hardware DMA flag sets */
 	/* soundcore stuff */
 	int dev_audio;
 	int dev_midi;
 	/* structures for abstraction of hardware facilities, codecs, banks and channels*/
 	struct ac97_codec *ac97_codec[NR_AC97];
 	struct cs_state *states[2];
 	u16 ac97_features;
 	int amplifier;			/* Amplifier control */
 	void (*amplifier_ctrl)(struct cs_card *, int);
 	void (*amp_init)(struct cs_card *);
 	int active;			/* Active clocking */
 	void (*active_ctrl)(struct cs_card *, int);
 	/* hardware resources */
 	unsigned long ba0_addr;
 	unsigned long ba1_addr;
 	u32 irq;
 	/* mappings */
 	void __iomem *ba0;
 	union
 	{
 		struct
 		{
 			u8 __iomem *data0;
 			u8 __iomem *data1;
 			u8 __iomem *pmem;
 			u8 __iomem *reg;
 		} name;
 		u8 __iomem *idx[4];
 	} ba1;
 	/* Function support */
 	struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
 	struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
 	void (*free_pcm_channel)(struct cs_card *, int chan);
 	/* /dev/midi stuff */
 	struct {
 		unsigned ird, iwr, icnt;
 		unsigned ord, owr, ocnt;
 		wait_queue_head_t open_wait;
 		wait_queue_head_t iwait;
 		wait_queue_head_t owait;
 		spinlock_t lock;
 		unsigned char ibuf[CS_MIDIINBUF];
 		unsigned char obuf[CS_MIDIOUTBUF];
 		mode_t open_mode;
 		struct mutex open_mutex;
 	} midi;
 	struct cs46xx_pm pm;
 };
 static int cs_open_mixdev(struct inode *inode, struct file *file);
 static int cs_release_mixdev(struct inode *inode, struct file *file);
 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 			unsigned long arg);
 static int cs_hardware_init(struct cs_card *card);
 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
 #ifdef CONFIG_PM
 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state);
 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
 #endif
 #if CSDEBUG
 /* DEBUG ROUTINES */
 #define SOUND_MIXER_CS_GETDBGLEVEL 	_SIOWR('M',120, int)
 #define SOUND_MIXER_CS_SETDBGLEVEL 	_SIOWR('M',121, int)
 #define SOUND_MIXER_CS_GETDBGMASK 	_SIOWR('M',122, int)
 #define SOUND_MIXER_CS_SETDBGMASK 	_SIOWR('M',123, int)
 #define SOUND_MIXER_CS_APM	 	_SIOWR('M',124, int)
 static void printioctl(unsigned int x)
 {
     unsigned int i;
     unsigned char vidx;
 	/* these values are incorrect for the ac97 driver, fix.
          * Index of mixtable1[] member is Device ID
          * and must be <= SOUND_MIXER_NRDEVICES.
          * Value of array member is index into s->mix.vol[]
          */
         static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
                 [SOUND_MIXER_PCM]     = 1,   /* voice */
                 [SOUND_MIXER_LINE1]   = 2,   /* AUX */
                 [SOUND_MIXER_CD]      = 3,   /* CD */
                 [SOUND_MIXER_LINE]    = 4,   /* Line */
                 [SOUND_MIXER_SYNTH]   = 5,   /* FM */
                 [SOUND_MIXER_MIC]     = 6,   /* Mic */
                 [SOUND_MIXER_SPEAKER] = 7,   /* Speaker */
                 [SOUND_MIXER_RECLEV]  = 8,   /* Recording level */
                 [SOUND_MIXER_VOLUME]  = 9    /* Master Volume */
         };
     switch (x) {
 	case SOUND_MIXER_CS_GETDBGMASK:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
 		break;
 	case SOUND_MIXER_CS_GETDBGLEVEL:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
 		break;
 	case SOUND_MIXER_CS_SETDBGMASK:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
 		break;
 	case SOUND_MIXER_CS_SETDBGLEVEL:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
 		break;
         case OSS_GETVERSION:
 		CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
 		break;
         case SNDCTL_DSP_SYNC:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
 		break;
         case SNDCTL_DSP_SETDUPLEX:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
 		break;
         case SNDCTL_DSP_GETCAPS:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
 		break;
         case SNDCTL_DSP_RESET:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
 		break;
         case SNDCTL_DSP_SPEED:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
 		break;
         case SNDCTL_DSP_STEREO:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
 		break;
         case SNDCTL_DSP_CHANNELS:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
 		break;
         case SNDCTL_DSP_GETFMTS:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
 		break;
         case SNDCTL_DSP_SETFMT:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
 		break;
         case SNDCTL_DSP_POST:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
 		break;
         case SNDCTL_DSP_GETTRIGGER:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
 		break;
         case SNDCTL_DSP_SETTRIGGER:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
 		break;
         case SNDCTL_DSP_GETOSPACE:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
 		break;
         case SNDCTL_DSP_GETISPACE:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
 		break;
         case SNDCTL_DSP_NONBLOCK:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
 		break;
         case SNDCTL_DSP_GETODELAY:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
 		break;
         case SNDCTL_DSP_GETIPTR:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
 		break;
         case SNDCTL_DSP_GETOPTR:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
 		break;
         case SNDCTL_DSP_GETBLKSIZE:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
 		break;
         case SNDCTL_DSP_SETFRAGMENT:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
 		break;
         case SNDCTL_DSP_SUBDIVIDE:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
 		break;
         case SOUND_PCM_READ_RATE:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
 		break;
         case SOUND_PCM_READ_CHANNELS:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
 		break;
         case SOUND_PCM_READ_BITS:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
 		break;
         case SOUND_PCM_WRITE_FILTER:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
 		break;
         case SNDCTL_DSP_SETSYNCRO:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
 		break;
         case SOUND_PCM_READ_FILTER:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
 		break;
         case SOUND_MIXER_PRIVATE1:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
 		break;
         case SOUND_MIXER_PRIVATE2:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
 		break;
         case SOUND_MIXER_PRIVATE3:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
 		break;
         case SOUND_MIXER_PRIVATE4:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
 		break;
         case SOUND_MIXER_PRIVATE5:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
 		break;
         case SOUND_MIXER_INFO:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
 		break;
         case SOUND_OLD_MIXER_INFO:
 		CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
 		break;
 	default:
 		switch (_IOC_NR(x)) {
 			case SOUND_MIXER_VOLUME:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
 				break;
 			case SOUND_MIXER_SPEAKER:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
 				break;
 			case SOUND_MIXER_RECLEV:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
 				break;
 			case SOUND_MIXER_MIC:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
 				break;
 			case SOUND_MIXER_SYNTH:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
 				break;
 			case SOUND_MIXER_RECSRC:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
 				break;
 			case SOUND_MIXER_DEVMASK:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
 				break;
 			case SOUND_MIXER_RECMASK:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
 				break;
 			case SOUND_MIXER_STEREODEVS:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
 				break;
 			case SOUND_MIXER_CAPS:
 				CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
 				break;
 			default:
 				i = _IOC_NR(x);
 				if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i])) {
 					CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
 				} else {
 					CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
 							x,i));
 				}
 				break;
 		}
     }
     CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
 }
 #endif
 /*
  *  common I/O routines
  */
 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
 {
 	writel(val, codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
 }
 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
 {
 	return readl(codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
 }
 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
 {
 	writel(val, codec->ba0 + reg);
 }
 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
 {
 	return readl(codec->ba0 + reg);
 }
 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
 {
 	if (card->channel[1].used == 1)
 		return NULL;
 	card->channel[1].used = 1;
 	card->channel[1].num = 1;
 	return &card->channel[1];
 }
 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
 {
 	if (card->channel[0].used == 1)
 		return NULL;
 	card->channel[0].used = 1;
 	card->channel[0].num = 0;
 	return &card->channel[0];
 }
 static void cs_free_pcm_channel(struct cs_card *card, int channel)
 {
 	card->channel[channel].state = NULL;
 	card->channel[channel].used = 0;
 }
 /*
  * setup a divisor value to help with conversion from
  * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
  * assign a divisor of 1 if using 16bit Stereo as that is
  * the only format that the static image will capture.
  */
 static void cs_set_divisor(struct dmabuf *dmabuf)
 {
 	if (dmabuf->type == CS_TYPE_DAC)
 		dmabuf->divisor = 1;
 	else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
 	    (dmabuf->fmt & CS_FMT_16BIT))
 		dmabuf->divisor = 2;
 	else if ((dmabuf->fmt & CS_FMT_STEREO) &&
 	    !(dmabuf->fmt & CS_FMT_16BIT))
 		dmabuf->divisor = 2;
 	else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
 	    !(dmabuf->fmt & CS_FMT_16BIT))
 		dmabuf->divisor = 4;
 	else
 		dmabuf->divisor = 1;
 	CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
 		"cs46xx: cs_set_divisor()- %s %d\n",
 			(dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
 			dmabuf->divisor) );
 }
 /*
 * mute some of the more prevalent registers to avoid popping.
 */
 static void cs_mute(struct cs_card *card, int state)
 {
 	struct ac97_codec *dev = card->ac97_codec[0];
 	CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
 		(state == CS_TRUE) ? "Muting" : "UnMuting"));
 	if (state == CS_TRUE) {
 	/*
 	* fix pops when powering up on thinkpads
 	*/
 		card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
 				(u8)BA0_AC97_MASTER_VOLUME);
 		card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
 				(u8)BA0_AC97_HEADPHONE_VOLUME);
 		card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
 				(u8)BA0_AC97_MASTER_VOLUME_MONO);
 		card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
 				(u8)BA0_AC97_PCM_OUT_VOLUME);
 		cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
 		cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
 		cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
 		cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
 	} else {
 		cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
 		cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
 		cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
 		cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
 	}
 	CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
 }
 /* set playback sample rate */
 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int tmp1, tmp2;
 	unsigned int phiIncr;
 	unsigned int correctionPerGOF, correctionPerSec;
 	unsigned long flags;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
 	/*
 	 *  Compute the values used to drive the actual sample rate conversion.
 	 *  The following formulas are being computed, using inline assembly
 	 *  since we need to use 64 bit arithmetic to compute the values:
 	 *
 	 *  phiIncr = floor((Fs,in * 2^26) / Fs,out)
 	 *  correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
          *                                   GOF_PER_SEC)
          *  ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
          *                       GOF_PER_SEC * correctionPerGOF
 	 *
 	 *  i.e.
 	 *
 	 *  phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
 	 *  correctionPerGOF:correctionPerSec =
 	 *      dividend:remainder(ulOther / GOF_PER_SEC)
 	 */
 	tmp1 = rate << 16;
 	phiIncr = tmp1 / 48000;
 	tmp1 -= phiIncr * 48000;
 	tmp1 <<= 10;
 	phiIncr <<= 10;
 	tmp2 = tmp1 / 48000;
 	phiIncr += tmp2;
 	tmp1 -= tmp2 * 48000;
 	correctionPerGOF = tmp1 / GOF_PER_SEC;
 	tmp1 -= correctionPerGOF * GOF_PER_SEC;
 	correctionPerSec = tmp1;
 	/*
 	 *  Fill in the SampleRateConverter control block.
 	 */
 	spin_lock_irqsave(&state->card->lock, flags);
 	cs461x_poke(state->card, BA1_PSRC,
 	  ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 	cs461x_poke(state->card, BA1_PPI, phiIncr);
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	dmabuf->rate = rate;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
 	return rate;
 }
 /* set recording sample rate */
 static unsigned int cs_set_adc_rate(struct cs_state *state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
 	unsigned int phiIncr, coeffIncr, tmp1, tmp2;
 	unsigned int correctionPerGOF, correctionPerSec, initialDelay;
 	unsigned int frameGroupLength, cnt;
 	unsigned long flags;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
 	/*
 	 *  We can only decimate by up to a factor of 1/9th the hardware rate.
 	 *  Correct the value if an attempt is made to stray outside that limit.
 	 */
 	if ((rate * 9) < 48000)
 		rate = 48000 / 9;
 	/*
 	 *  We cannot capture at at rate greater than the Input Rate (48000).
 	 *  Return an error if an attempt is made to stray outside that limit.
 	 */
 	if (rate > 48000)
 		rate = 48000;
 	/*
 	 *  Compute the values used to drive the actual sample rate conversion.
 	 *  The following formulas are being computed, using inline assembly
 	 *  since we need to use 64 bit arithmetic to compute the values:
 	 *
 	 *     coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
 	 *     phiIncr = floor((Fs,in * 2^26) / Fs,out)
 	 *     correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
 	 *                                GOF_PER_SEC)
 	 *     correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
 	 *                          GOF_PER_SEC * correctionPerGOF
 	 *     initialDelay = ceil((24 * Fs,in) / Fs,out)
 	 *
 	 * i.e.
 	 *
 	 *     coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
 	 *     phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
 	 *     correctionPerGOF:correctionPerSec =
 	 * 	    dividend:remainder(ulOther / GOF_PER_SEC)
 	 *     initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
 	 */
 	tmp1 = rate << 16;
 	coeffIncr = tmp1 / 48000;
 	tmp1 -= coeffIncr * 48000;
 	tmp1 <<= 7;
 	coeffIncr <<= 7;
 	coeffIncr += tmp1 / 48000;
 	coeffIncr ^= 0xFFFFFFFF;
 	coeffIncr++;
 	tmp1 = 48000 << 16;
 	phiIncr = tmp1 / rate;
 	tmp1 -= phiIncr * rate;
 	tmp1 <<= 10;
 	phiIncr <<= 10;
 	tmp2 = tmp1 / rate;
 	phiIncr += tmp2;
 	tmp1 -= tmp2 * rate;
 	correctionPerGOF = tmp1 / GOF_PER_SEC;
 	tmp1 -= correctionPerGOF * GOF_PER_SEC;
 	correctionPerSec = tmp1;
 	initialDelay = ((48000 * 24) + rate - 1) / rate;
 	/*
 	 *  Fill in the VariDecimate control block.
 	 */
 	spin_lock_irqsave(&card->lock, flags);
 	cs461x_poke(card, BA1_CSRC,
 		((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
 	cs461x_poke(card, BA1_CCI, coeffIncr);
 	cs461x_poke(card, BA1_CD,
 		(((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
 	cs461x_poke(card, BA1_CPI, phiIncr);
 	spin_unlock_irqrestore(&card->lock, flags);
 	/*
 	 *  Figure out the frame group length for the write back task.  Basically,
 	 *  this is just the factors of 24000 (2^6*3*5^3) that are not present in
 	 *  the output sample rate.
 	 */
 	frameGroupLength = 1;
 	for (cnt = 2; cnt <= 64; cnt *= 2) {
 		if (((rate / cnt) * cnt) != rate)
 			frameGroupLength *= 2;
 	}
 	if (((rate / 3) * 3) != rate) {
 		frameGroupLength *= 3;
 	}
 	for (cnt = 5; cnt <= 125; cnt *= 5) {
 		if (((rate / cnt) * cnt) != rate)
 			frameGroupLength *= 5;
         }
 	/*
 	 * Fill in the WriteBack control block.
 	 */
 	spin_lock_irqsave(&card->lock, flags);
 	cs461x_poke(card, BA1_CFG1, frameGroupLength);
 	cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
 	cs461x_poke(card, BA1_CCST, 0x0000FFFF);
 	cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
 	cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
 	spin_unlock_irqrestore(&card->lock, flags);
 	dmabuf->rate = rate;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
 	return rate;
 }
 /* prepare channel attributes for playback */
 static void cs_play_setup(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
         unsigned int tmp, Count, playFormat;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
         cs461x_poke(card, BA1_PVOL, 0x80008000);
         if (!dmabuf->SGok)
                cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
         Count = 4;
         playFormat=cs461x_peek(card, BA1_PFIE);
         if ((dmabuf->fmt & CS_FMT_STEREO)) {
                 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
                 Count *= 2;
         } else
                 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
         if ((dmabuf->fmt & CS_FMT_16BIT)) {
                 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
                 Count *= 2;
         } else
                 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
                            | DMA_RQ_C2_AC_SIGNED_CONVERT);
         cs461x_poke(card, BA1_PFIE, playFormat);
         tmp = cs461x_peek(card, BA1_PDTC);
         tmp &= 0xfffffe00;
         cs461x_poke(card, BA1_PDTC, tmp | --Count);
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
 }
 static struct InitStruct
 {
     u32 off;
     u32 val;
 } InitArray[] = { {0x00000040, 0x3fc0000f},
                   {0x0000004c, 0x04800000},
                   {0x000000b3, 0x00000780},
                   {0x000000b7, 0x00000000},
                   {0x000000bc, 0x07800000},
                   {0x000000cd, 0x00800000},
                 };
 /*
  * "SetCaptureSPValues()" -- Initialize record task values before each
  * 	capture startup.
  */
 static void SetCaptureSPValues(struct cs_card *card)
 {
 	unsigned i, offset;
 	CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
 	for (i = 0; i < sizeof(InitArray) / sizeof(struct InitStruct); i++) {
 		offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
 		cs461x_poke(card, offset, InitArray[i].val );
 	}
 	CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
 }
 /* prepare channel attributes for recording */
 static void cs_rec_setup(struct cs_state *state)
 {
 	struct cs_card *card = state->card;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n"));
 	SetCaptureSPValues(card);
 	/*
 	 * set the attenuation to 0dB
 	 */
 	cs461x_poke(card, BA1_CVOL, 0x80008000);
 	/*
 	 * set the physical address of the capture buffer into the SP
 	 */
 	cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
 }
 /* get current playback/recording dma buffer pointer (byte offset from LBA),
    called with spinlock held! */
 static inline unsigned cs_get_dma_addr(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	u32 offset;
 	if ( (!(dmabuf->enable & DAC_RUNNING)) &&
 	     (!(dmabuf->enable & ADC_RUNNING) ) )
 	{
 		CS_DBGOUT(CS_ERROR, 2, printk(
 			"cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
 		return 0;
 	}
 	/*
 	 * granularity is byte boundary, good part.
 	 */
 	if (dmabuf->enable & DAC_RUNNING)
 		offset = cs461x_peek(state->card, BA1_PBA);
 	else /* ADC_RUNNING must be set */
 		offset = cs461x_peek(state->card, BA1_CBA);
 	CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
 		printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
 	offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
 	CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
 		printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
 	return offset;
 }
 static void resync_dma_ptrs(struct cs_state *state)
 {
 	struct dmabuf *dmabuf;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
 	if (state) {
 		dmabuf = &state->dmabuf;
 		dmabuf->hwptr=dmabuf->swptr = 0;
 		dmabuf->pringbuf = 0;
 	}
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
 }
 /* Stop recording (lock held) */
 static inline void __stop_adc(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
 	unsigned int tmp;
 	dmabuf->enable &= ~ADC_RUNNING;
 	tmp = cs461x_peek(card, BA1_CCTL);
 	tmp &= 0xFFFF0000;
 	cs461x_poke(card, BA1_CCTL, tmp );
 }
 static void stop_adc(struct cs_state *state)
 {
 	unsigned long flags;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
 	spin_lock_irqsave(&state->card->lock, flags);
 	__stop_adc(state);
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
 }
 static void start_adc(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
 	unsigned long flags;
 	unsigned int tmp;
 	spin_lock_irqsave(&card->lock, flags);
 	if (!(dmabuf->enable & ADC_RUNNING) &&
 	     ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
 	       && dmabuf->ready) &&
 	       ((card->pm.flags & CS46XX_PM_IDLE) ||
 	        (card->pm.flags & CS46XX_PM_RESUMED)) )
 	{
 		dmabuf->enable |= ADC_RUNNING;
 		cs_set_divisor(dmabuf);
 		tmp = cs461x_peek(card, BA1_CCTL);
 		tmp &= 0xFFFF0000;
 		tmp |= card->cctl;
 		CS_DBGOUT(CS_FUNCTION, 2, printk(
 			"cs46xx: start_adc() poke 0x%x \n",tmp) );
 		cs461x_poke(card, BA1_CCTL, tmp);
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 /* stop playback (lock held) */
 static inline void __stop_dac(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
 	unsigned int tmp;
 	dmabuf->enable &= ~DAC_RUNNING;
 	tmp=cs461x_peek(card, BA1_PCTL);
 	tmp&=0xFFFF;
 	cs461x_poke(card, BA1_PCTL, tmp);
 }
 static void stop_dac(struct cs_state *state)
 {
 	unsigned long flags;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
 	spin_lock_irqsave(&state->card->lock, flags);
 	__stop_dac(state);
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
 }
 static void start_dac(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card = state->card;
 	unsigned long flags;
 	int tmp;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
 	spin_lock_irqsave(&card->lock, flags);
 	if (!(dmabuf->enable & DAC_RUNNING) &&
 	    ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
 	       ((card->pm.flags & CS46XX_PM_IDLE) ||
 	        (card->pm.flags & CS46XX_PM_RESUMED)) )
 	{
 		dmabuf->enable |= DAC_RUNNING;
 		tmp = cs461x_peek(card, BA1_PCTL);
 		tmp &= 0xFFFF;
 		tmp |= card->pctl;
 		CS_DBGOUT(CS_PARMS, 6, printk(
 		    "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
 		    card, (unsigned)tmp,
 		    card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
 		cs461x_poke(card, BA1_PCTL, tmp);
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
 }
 #define DMABUF_MINORDER 1
 /*
  * allocate DMA buffer, playback and recording buffers are separate.
  */
 static int alloc_dmabuf(struct cs_state *state)
 {
 	struct cs_card *card=state->card;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	void *rawbuf = NULL;
 	void *tmpbuff = NULL;
 	int order;
 	struct page *map, *mapend;
 	unsigned long df;
 	dmabuf->ready  = dmabuf->mapped = 0;
 	dmabuf->SGok = 0;
 /*
 * check for order within limits, but do not overwrite value.
 */
 	if ((defaultorder > 1) && (defaultorder < 12))
 		df = defaultorder;
 	else
 		df = 2;
 	for (order = df; order >= DMABUF_MINORDER; order--)
 		if ((rawbuf = (void *)pci_alloc_consistent(
 			card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
 			    break;
 	if (!rawbuf) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
 			"cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
 		return -ENOMEM;
 	}
 	dmabuf->buforder = order;
 	dmabuf->rawbuf = rawbuf;
 	// Now mark the pages as reserved; otherwise the
 	// remap_pfn_range() in cs46xx_mmap doesn't work.
 	// 1. get index to last page in mem_map array for rawbuf.
 	mapend = virt_to_page(dmabuf->rawbuf +
 		(PAGE_SIZE << dmabuf->buforder) - 1);
 	// 2. mark each physical page in range as 'reserved'.
 	for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
 		cs4x_mem_map_reserve(map);
 	CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
 	       PAGE_SIZE << order, order, rawbuf) );
 /*
 *  only allocate the conversion buffer for the ADC
 */
 	if (dmabuf->type == CS_TYPE_DAC) {
 		dmabuf->tmpbuff = NULL;
 		dmabuf->buforder_tmpbuff = 0;
 		return 0;
 	}
 /*
  * now the temp buffer for 16/8 conversions
  */
 	tmpbuff = (void *) pci_alloc_consistent(
 		card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
 	if (!tmpbuff)
 		return -ENOMEM;
 	CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
 	       PAGE_SIZE << order, order, tmpbuff) );
 	dmabuf->tmpbuff = tmpbuff;
 	dmabuf->buforder_tmpbuff = order;
 	// Now mark the pages as reserved; otherwise the
 	// remap_pfn_range() in cs46xx_mmap doesn't work.
 	// 1. get index to last page in mem_map array for rawbuf.
 	mapend = virt_to_page(dmabuf->tmpbuff +
 		(PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
 	// 2. mark each physical page in range as 'reserved'.
 	for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
 		cs4x_mem_map_reserve(map);
 	return 0;
 }
 /* free DMA buffer */
 static void dealloc_dmabuf(struct cs_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct page *map, *mapend;
 	if (dmabuf->rawbuf) {
 		// Undo prog_dmabuf()'s marking the pages as reserved
 		mapend = virt_to_page(dmabuf->rawbuf +
 				(PAGE_SIZE << dmabuf->buforder) - 1);
 		for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
 			cs4x_mem_map_unreserve(map);
 		free_dmabuf(state->card, dmabuf);
 	}
 	if (dmabuf->tmpbuff) {
 		// Undo prog_dmabuf()'s marking the pages as reserved
 		mapend = virt_to_page(dmabuf->tmpbuff +
 				(PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
 		for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
 			cs4x_mem_map_unreserve(map);
 		free_dmabuf2(state->card, dmabuf);
 	}
 	dmabuf->rawbuf = NULL;
 	dmabuf->tmpbuff = NULL;
 	dmabuf->mapped = dmabuf->ready = 0;
 	dmabuf->SGok = 0;
 }
 static int __prog_dmabuf(struct cs_state *state)
 {
         struct dmabuf *dmabuf = &state->dmabuf;
         unsigned long flags;
         unsigned long allocated_pages, allocated_bytes;
         unsigned long tmp1, tmp2, fmt=0;
         unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
         unsigned long SGarray[9], nSGpages=0;
         int ret;
 	CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
 /*
  * check for CAPTURE and use only non-sg for initial release
  */
 	if (dmabuf->type == CS_TYPE_ADC) {
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
 		/*
 		 * add in non-sg support for capture.
 		 */
 		spin_lock_irqsave(&state->card->lock, flags);
 	/* add code to reset the rawbuf memory. TRW */
 		resync_dma_ptrs(state);
 		dmabuf->total_bytes = dmabuf->blocks = 0;
 		dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
 		dmabuf->SGok = 0;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		/* allocate DMA buffer if not allocated yet */
 		if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
 			if ((ret = alloc_dmabuf(state)))
 				return ret;
 	/*
 	 * static image only supports 16Bit signed, stereo - hard code fmt
 	 */
 		fmt = CS_FMT_16BIT | CS_FMT_STEREO;
 		dmabuf->numfrag = 2;
 		dmabuf->fragsize = 2048;
 		dmabuf->fragsamples = 2048 >> sample_shift[fmt];
 		dmabuf->dmasize = 4096;
 		dmabuf->fragshift = 11;
 		memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
 		       dmabuf->dmasize);
         	memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
 			PAGE_SIZE<<dmabuf->buforder_tmpbuff);
 		/*
 		 *      Now set up the ring
 		 */
 		spin_lock_irqsave(&state->card->lock, flags);
 		cs_rec_setup(state);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		/* set the ready flag for the dma buffer */
 		dmabuf->ready = 1;
 		CS_DBGOUT(CS_PARMS, 4, printk(
 			"cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
 			"fragsize=%d dmasize=%d\n",
 			    dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
 			    dmabuf->fragsize, dmabuf->dmasize) );
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
 		return 0;
 	} else if (dmabuf->type == CS_TYPE_DAC) {
 	/*
 	 * Must be DAC
 	 */
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
 		spin_lock_irqsave(&state->card->lock, flags);
 		resync_dma_ptrs(state);
 		dmabuf->total_bytes = dmabuf->blocks = 0;
 		dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
 		dmabuf->SGok = 0;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		/* allocate DMA buffer if not allocated yet */
 		if (!dmabuf->rawbuf)
 			if ((ret = alloc_dmabuf(state)))
 				return ret;
 		allocated_pages = 1 << dmabuf->buforder;
 		allocated_bytes = allocated_pages*PAGE_SIZE;
 		if (allocated_pages < 2) {
 			CS_DBGOUT(CS_FUNCTION, 4, printk(
 			    "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
 				(unsigned)allocated_pages));
 			return -ENOMEM;
 		}
 		/* Use all the pages allocated, fragsize 4k. */
 		/* Use 'pbuf' for S/G page map table. */
 		dmabuf->SGok = 1;           /* Use S/G. */
 		nSGpages = allocated_bytes/4096;    /* S/G pages always 4k. */
 		     /* Set up S/G variables. */
 		*ptmp = virt_to_bus(dmabuf->rawbuf);
 		*(ptmp + 1) = 0x00000008;
 		for (tmp1 = 1; tmp1 < nSGpages; tmp1++) {
 			*(ptmp + 2 * tmp1) = virt_to_bus((dmabuf->rawbuf) + 4096 * tmp1);
 			if (tmp1 == nSGpages - 1)
 				tmp2 = 0xbfff0000;
 			else
 				tmp2 = 0x80000000 + 8 * (tmp1 + 1);
 			*(ptmp + 2 * tmp1 + 1) = tmp2;
 		}
 		SGarray[0] = 0x82c0200d;
 		SGarray[1] = 0xffff0000;
 		SGarray[2] = *ptmp;
 		SGarray[3] = 0x00010600;
 		SGarray[4] = *(ptmp+2);
 		SGarray[5] = 0x80000010;
 		SGarray[6] = *ptmp;
 		SGarray[7] = *(ptmp+2);
 		SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
 		if (dmabuf->SGok) {
 			dmabuf->numfrag = nSGpages;
 			dmabuf->fragsize = 4096;
 			dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
 			dmabuf->fragshift = 12;
 			dmabuf->dmasize = dmabuf->numfrag * 4096;
 		} else {
 			SGarray[0] = 0xf2c0000f;
 			SGarray[1] = 0x00000200;
 			SGarray[2] = 0;
 			SGarray[3] = 0x00010600;
 			SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
 			dmabuf->numfrag = 2;
 			dmabuf->fragsize = 2048;
 			dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
 			dmabuf->dmasize = 4096;
 			dmabuf->fragshift = 11;
 		}
 		for (tmp1 = 0; tmp1 < sizeof(SGarray) / 4; tmp1++)
 			cs461x_poke(state->card, BA1_PDTC+tmp1 * 4, SGarray[tmp1]);
 		memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
 		       dmabuf->dmasize);
 		/*
 		 *      Now set up the ring
 		 */
 		spin_lock_irqsave(&state->card->lock, flags);
 		cs_play_setup(state);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		/* set the ready flag for the dma buffer */
 		dmabuf->ready = 1;
 		CS_DBGOUT(CS_PARMS, 4, printk(
 			"cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
 			"fragsize=%d dmasize=%d\n",
 			    dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
 			    dmabuf->fragsize, dmabuf->dmasize) );
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
 		return 0;
 	} else {
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
 			dmabuf->type));
 	}
 	return 1;
 }
 static int prog_dmabuf(struct cs_state *state)
 {
 	int ret;
 	mutex_lock(&state->sem);
 	ret = __prog_dmabuf(state);
 	mutex_unlock(&state->sem);
 	return ret;
 }
 static void cs_clear_tail(struct cs_state *state)
 {
 }
 static int drain_dac(struct cs_state *state, int nonblock)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct cs_card *card=state->card;
 	unsigned long flags;
 	unsigned long tmo;
 	int count;
 	CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
 	if (dmabuf->mapped || !dmabuf->ready)
 	{
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
 		return 0;
 	}
 	add_wait_queue(&dmabuf->wait, &wait);
 	for (;;) {
 		/* It seems that we have to set the current state to TASK_INTERRUPTIBLE
 		   every time to make the process really go to sleep */
 		current->state = TASK_INTERRUPTIBLE;
 		spin_lock_irqsave(&state->card->lock, flags);
 		count = dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (count <= 0)
 			break;
 		if (signal_pending(current))
 			break;
 		if (nonblock) {
 			remove_wait_queue(&dmabuf->wait, &wait);
 			current->state = TASK_RUNNING;
 			return -EBUSY;
 		}
 		tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
 		tmo >>= sample_shift[dmabuf->fmt];
 		tmo += (2048*HZ)/dmabuf->rate;
 		if (!schedule_timeout(tmo ? tmo : 1) && tmo){
 			printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
 			break;
 		}
 	}
 	remove_wait_queue(&dmabuf->wait, &wait);
 	current->state = TASK_RUNNING;
 	if (signal_pending(current)) {
 		CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
 		/*
 		* set to silence and let that clear the fifos.
 		*/
 		cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
 		return -ERESTARTSYS;
 	}
 	CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
 	return 0;
 }
 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
 static void cs_update_ptr(struct cs_card *card, int wake)
 {
 	struct cs_state *state;
 	struct dmabuf *dmabuf;
 	unsigned hwptr;
 	int diff;
 	/* error handling and process wake up for ADC */
 	state = card->states[0];
 	if (state) {
 		dmabuf = &state->dmabuf;
 		if (dmabuf->enable & ADC_RUNNING) {
 			/* update hardware pointer */
 			hwptr = cs_get_dma_addr(state);
 			diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
 			CS_DBGOUT(CS_PARMS, 9, printk(
 				"cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
 				hwptr,diff) );
 			dmabuf->hwptr = hwptr;
 			dmabuf->total_bytes += diff;
 			dmabuf->count += diff;
 			if (dmabuf->count > dmabuf->dmasize)
 				dmabuf->count = dmabuf->dmasize;
 			if (dmabuf->mapped) {
 				if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
 					wake_up(&dmabuf->wait);
 			} else {
 				if (wake && dmabuf->count > 0)
 					wake_up(&dmabuf->wait);
 			}
 		}
 	}
 /*
  * Now the DAC
  */
 	state = card->states[1];
 	if (state) {
 		dmabuf = &state->dmabuf;
 		/* error handling and process wake up for DAC */
 		if (dmabuf->enable & DAC_RUNNING) {
 			/* update hardware pointer */
 			hwptr = cs_get_dma_addr(state);
 			diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
 			CS_DBGOUT(CS_PARMS, 9, printk(
 				"cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
 				hwptr,diff) );
 			dmabuf->hwptr = hwptr;
 			dmabuf->total_bytes += diff;
 			if (dmabuf->mapped) {
 				dmabuf->count += diff;
 				if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
 					wake_up(&dmabuf->wait);
 				/*
 				 * other drivers use fragsize, but don't see any sense
 				 * in that, since dmasize is the buffer asked for
 				 * via mmap.
 				 */
 				if (dmabuf->count > dmabuf->dmasize)
 					dmabuf->count &= dmabuf->dmasize-1;
 			} else {
 				dmabuf->count -= diff;
 				/*
 				 * backfill with silence and clear out the last
 				 * "diff" number of bytes.
 				 */
 				if (hwptr >= diff) {
 					memset(dmabuf->rawbuf + hwptr - diff,
 						(dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
 				} else {
 					memset(dmabuf->rawbuf,
 						(dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
 						(unsigned)hwptr);
 					memset((char *)dmabuf->rawbuf +
 							dmabuf->dmasize + hwptr - diff,
 						(dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
 						diff - hwptr);
 				}
 				if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
 					CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
 					  "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
 					  	dmabuf->count));
 					/*
 					* buffer underrun or buffer overrun, reset the
 					* count of bytes written back to 0.
 					*/
 					if (dmabuf->count < 0)
 						dmabuf->underrun = 1;
 					dmabuf->count = 0;
 					dmabuf->error++;
 				}
 				if (wake && dmabuf->count < (signed)dmabuf->dmasize / 2)
 					wake_up(&dmabuf->wait);
 			}
 		}
 	}
 }
 /* hold spinlock for the following! */
 static void cs_handle_midi(struct cs_card *card)
 {
         unsigned char ch;
         int wake;
         unsigned temp1;
         wake = 0;
         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_RBE)) {
                 ch = cs461x_peekBA0(card, BA0_MIDRP);
                 if (card->midi.icnt < CS_MIDIINBUF) {
                         card->midi.ibuf[card->midi.iwr] = ch;
                         card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
                         card->midi.icnt++;
                 }
                 wake = 1;
         }
         if (wake)
                 wake_up(&card->midi.iwait);
         wake = 0;
         while (!(cs461x_peekBA0(card,  BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
                 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
                 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
                 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
                 card->midi.ocnt--;
                 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
                         wake = 1;
         }
         if (wake)
                 wake_up(&card->midi.owait);
 }
 static irqreturn_t cs_interrupt(int irq, void *dev_id)
 {
 	struct cs_card *card = (struct cs_card *)dev_id;
 	/* Single channel card */
 	struct cs_state *recstate = card->channel[0].state;
 	struct cs_state *playstate = card->channel[1].state;
 	u32 status;
 	CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
 	spin_lock(&card->lock);
 	status = cs461x_peekBA0(card, BA0_HISR);
 	if ((status & 0x7fffffff) == 0) {
 		cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
 		spin_unlock(&card->lock);
 		return IRQ_HANDLED;	/* Might be IRQ_NONE.. */
 	}
 	/*
 	 * check for playback or capture interrupt only
 	 */
 	if (((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
 	    (((status & HISR_VC1) && recstate && recstate->dmabuf.ready))) {
 		CS_DBGOUT(CS_INTERRUPT, 8, printk(
 			"cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
 		cs_update_ptr(card, CS_TRUE);
 	}
         if (status & HISR_MIDI)
                 cs_handle_midi(card);
  	/* clear 'em */
 	cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
 	spin_unlock(&card->lock);
 	CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
 	return IRQ_HANDLED;
 }
 /**********************************************************************/
 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
         struct cs_card *card = file->private_data;
         ssize_t ret;
         unsigned long flags;
         unsigned ptr;
         int cnt;
         if (!access_ok(VERIFY_WRITE, buffer, count))
                 return -EFAULT;
         ret = 0;
         while (count > 0) {
                 spin_lock_irqsave(&card->lock, flags);
                 ptr = card->midi.ird;
                 cnt = CS_MIDIINBUF - ptr;
                 if (card->midi.icnt < cnt)
                         cnt = card->midi.icnt;
                 spin_unlock_irqrestore(&card->lock, flags);
                 if (cnt > count)
                         cnt = count;
                 if (cnt <= 0) {
                         if (file->f_flags & O_NONBLOCK)
                                 return ret ? ret : -EAGAIN;
                         interruptible_sleep_on(&card->midi.iwait);
                         if (signal_pending(current))
                                 return ret ? ret : -ERESTARTSYS;
                         continue;
                 }
                 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
                         return ret ? ret : -EFAULT;
                 ptr = (ptr + cnt) % CS_MIDIINBUF;
                 spin_lock_irqsave(&card->lock, flags);
                 card->midi.ird = ptr;
                 card->midi.icnt -= cnt;
                 spin_unlock_irqrestore(&card->lock, flags);
                 count -= cnt;
                 buffer += cnt;
                 ret += cnt;
         }
         return ret;
 }
 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
         struct cs_card *card = file->private_data;
         ssize_t ret;
         unsigned long flags;
         unsigned ptr;
         int cnt;
         if (!access_ok(VERIFY_READ, buffer, count))
                 return -EFAULT;
         ret = 0;
         while (count > 0) {
                 spin_lock_irqsave(&card->lock, flags);
                 ptr = card->midi.owr;
                 cnt = CS_MIDIOUTBUF - ptr;
                 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
                         cnt = CS_MIDIOUTBUF - card->midi.ocnt;
                 if (cnt <= 0)
                         cs_handle_midi(card);
                 spin_unlock_irqrestore(&card->lock, flags);
                 if (cnt > count)
                         cnt = count;
                 if (cnt <= 0) {
                         if (file->f_flags & O_NONBLOCK)
                                 return ret ? ret : -EAGAIN;
                         interruptible_sleep_on(&card->midi.owait);
                         if (signal_pending(current))
                                 return ret ? ret : -ERESTARTSYS;
                         continue;
                 }
                 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
                         return ret ? ret : -EFAULT;
                 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
                 spin_lock_irqsave(&card->lock, flags);
                 card->midi.owr = ptr;
                 card->midi.ocnt += cnt;
                 spin_unlock_irqrestore(&card->lock, flags);
                 count -= cnt;
                 buffer += cnt;
                 ret += cnt;
                 spin_lock_irqsave(&card->lock, flags);
                 cs_handle_midi(card);
                 spin_unlock_irqrestore(&card->lock, flags);
         }
         return ret;
 }
 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
 {
         struct cs_card *card = file->private_data;
         unsigned long flags;
         unsigned int mask = 0;
         if (file->f_flags & FMODE_WRITE)
                 poll_wait(file, &card->midi.owait, wait);
         if (file->f_flags & FMODE_READ)
                 poll_wait(file, &card->midi.iwait, wait);
         spin_lock_irqsave(&card->lock, flags);
         if (file->f_flags & FMODE_READ) {
                 if (card->midi.icnt > 0)
                         mask |= POLLIN | POLLRDNORM;
         }
         if (file->f_flags & FMODE_WRITE) {
                 if (card->midi.ocnt < CS_MIDIOUTBUF)
                         mask |= POLLOUT | POLLWRNORM;
         }
         spin_unlock_irqrestore(&card->lock, flags);
         return mask;
 }
 static int cs_midi_open(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode);
         struct cs_card *card = NULL;
         unsigned long flags;
 	struct list_head *entry;
 	list_for_each(entry, &cs46xx_devs) {
 		card = list_entry(entry, struct cs_card, list);
 		if (card->dev_midi == minor)
 			break;
 	}
 	if (entry == &cs46xx_devs)
 		return -ENODEV;
 	if (!card) {
 		CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
 			"cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
 		return -ENODEV;
 	}
         file->private_data = card;
         /* wait for device to become free */
         mutex_lock(&card->midi.open_mutex);
         while (card->midi.open_mode & file->f_mode) {
                 if (file->f_flags & O_NONBLOCK) {
                         mutex_unlock(&card->midi.open_mutex);
                         return -EBUSY;
                 }
                 mutex_unlock(&card->midi.open_mutex);
                 interruptible_sleep_on(&card->midi.open_wait);
                 if (signal_pending(current))
                         return -ERESTARTSYS;
                 mutex_lock(&card->midi.open_mutex);
         }
         spin_lock_irqsave(&card->midi.lock, flags);
         if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
                 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f);            /* Enable xmit, rcv. */
                 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);   /* Enable interrupts */
         }
         if (file->f_mode & FMODE_READ)
                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
         if (file->f_mode & FMODE_WRITE)
                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
         spin_unlock_irqrestore(&card->midi.lock, flags);
         card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
         mutex_unlock(&card->midi.open_mutex);
         return 0;
 }
 static int cs_midi_release(struct inode *inode, struct file *file)
 {
         struct cs_card *card = file->private_data;
         DECLARE_WAITQUEUE(wait, current);
         unsigned long flags;
         unsigned count, tmo;
         if (file->f_mode & FMODE_WRITE) {
                 current->state = TASK_INTERRUPTIBLE;
                 add_wait_queue(&card->midi.owait, &wait);
                 for (;;) {
                         spin_lock_irqsave(&card->midi.lock, flags);
                         count = card->midi.ocnt;
                         spin_unlock_irqrestore(&card->midi.lock, flags);
                         if (count <= 0)
                                 break;
                         if (signal_pending(current))
                                 break;
                         if (file->f_flags & O_NONBLOCK)
                         	break;
                         tmo = (count * HZ) / 3100;
                         if (!schedule_timeout(tmo ? : 1) && tmo)
                                 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
                 }
                 remove_wait_queue(&card->midi.owait, &wait);
                 current->state = TASK_RUNNING;
         }
         mutex_lock(&card->midi.open_mutex);
         card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
         mutex_unlock(&card->midi.open_mutex);
         wake_up(&card->midi.open_wait);
         return 0;
 }
 /*
  *   Midi file operations struct.
  */
 static /*const*/ struct file_operations cs_midi_fops = {
 	CS_OWNER	CS_THIS_MODULE
 	.llseek		= no_llseek,
 	.read		= cs_midi_read,
 	.write		= cs_midi_write,
 	.poll		= cs_midi_poll,
 	.open		= cs_midi_open,
 	.release	= cs_midi_release,
 };
 /*
  *
  * CopySamples copies 16-bit stereo signed samples from the source to the
  * destination, possibly converting down to unsigned 8-bit and/or mono.
  * count specifies the number of output bytes to write.
  *
  *  Arguments:
  *
  *  dst             - Pointer to a destination buffer.
  *  src             - Pointer to a source buffer
  *  count           - The number of bytes to copy into the destination buffer.
  *  fmt             - CS_FMT_16BIT and/or CS_FMT_STEREO bits
  *  dmabuf          - pointer to the dma buffer structure
  *
  * NOTES: only call this routine if the output desired is not 16 Signed Stereo
  *
  *
  */
 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
 		struct dmabuf *dmabuf)
 {
     s32 s32AudioSample;
     s16 *psSrc = (s16 *)src;
     s16 *psDst = (s16 *)dst;
     u8 *pucDst = (u8 *)dst;
     CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
     CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
 	" dst=%p src=%p count=%d fmt=0x%x\n",
 	dst,src,count,fmt) );
     /*
      * See if the data should be output as 8-bit unsigned stereo.
      */
     if ((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 8-bit unsigned
 	 * stereo using rounding.
          */
         psSrc = (s16 *)src;
 	count = count / 2;
         while (count--)
             *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
     }
     /*
      * See if the data should be output at 8-bit unsigned mono.
      */
     else if (!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 8-bit unsigned
 	 * mono using averaging and rounding.
          */
         psSrc = (s16 *)src;
 	count = count / 2;
         while (count--) {
 	    s32AudioSample = ((*psSrc) + (*(psSrc + 1))) / 2 + (s32)0x80;
 	    if (s32AudioSample > 0x7fff)
 	    	s32AudioSample = 0x7fff;
             *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
 	    psSrc += 2;
         }
     }
     /*
      * See if the data should be output at 16-bit signed mono.
      */
     else if (!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 16-bit signed
 	 * mono using averaging.
          */
         psSrc = (s16 *)src;
 	count = count / 2;
         while (count--) {
             *(psDst++) = (s16)((*psSrc) + (*(psSrc + 1))) / 2;
 	    psSrc += 2;
         }
     }
 }
 /*
  * cs_copy_to_user()
  * replacement for the standard copy_to_user, to allow for a conversion from
  * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
  * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
  * so we convert from any of the other format combinations.
  */
 static unsigned cs_copy_to_user(
 	struct cs_state *s,
 	void __user *dest,
 	void *hwsrc,
 	unsigned cnt,
 	unsigned *copied)
 {
 	struct dmabuf *dmabuf = &s->dmabuf;
 	void *src = hwsrc;  /* default to the standard destination buffer addr */
 	CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
 		"cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
 		dmabuf->fmt,(unsigned)cnt,dest) );
 	if (cnt > dmabuf->dmasize)
 		cnt = dmabuf->dmasize;
 	if (!cnt) {
 		*copied = 0;
 		return 0;
 	}
 	if (dmabuf->divisor != 1) {
 		if (!dmabuf->tmpbuff) {
 			*copied = cnt / dmabuf->divisor;
 			return 0;
 		}
 		CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
 			dmabuf->fmt, dmabuf);
 		src = dmabuf->tmpbuff;
 		cnt = cnt/dmabuf->divisor;
 	}
         if (copy_to_user(dest, src, cnt)) {
 		CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
 			"cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
 				dest,src,cnt));
 		*copied = 0;
 		return -EFAULT;
 	}
 	*copied = cnt;
 	CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
 		"cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt));
 	return 0;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
    the user's buffer.  it is filled by the dma machine and drained by this loop. */
 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct cs_card *card = file->private_data;
 	struct cs_state *state;
 	DECLARE_WAITQUEUE(wait, current);
 	struct dmabuf *dmabuf;
 	ssize_t ret = 0;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	unsigned copied = 0;
 	CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
 		printk("cs46xx: cs_read()+ %zd\n",count) );
 	state = card->states[0];
 	if (!state)
 		return -ENODEV;
 	dmabuf = &state->dmabuf;
 	if (dmabuf->mapped)
 		return -ENXIO;
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	mutex_lock(&state->sem);
 	if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
 		goto out2;
 	add_wait_queue(&state->dmabuf.wait, &wait);
 	while (count > 0) {
 		while (!(card->pm.flags & CS46XX_PM_IDLE)) {
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out;
 			}
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		swptr = dmabuf->swptr;
 		cnt = dmabuf->dmasize - swptr;
 		if (dmabuf->count < cnt)
 			cnt = dmabuf->count;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (cnt > (count * dmabuf->divisor))
 			cnt = count * dmabuf->divisor;
 		if (cnt <= 0) {
 			/* buffer is empty, start the dma machine and wait for data to be
 			   recorded */
 			start_adc(state);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
  			}
 			mutex_unlock(&state->sem);
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out;
 			}
 			mutex_lock(&state->sem);
 			if (dmabuf->mapped) {
 				if (!ret)
 					ret = -ENXIO;
 				goto out;
 			}
  			continue;
 		}
 		CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
 			"_read() copy_to cnt=%d count=%zd ", cnt,count) );
 		CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
 			" .dmasize=%d .count=%d buffer=%p ret=%zd\n",
 			dmabuf->dmasize,dmabuf->count,buffer,ret));
                 if (cs_copy_to_user(state, buffer,
 			(char *)dmabuf->rawbuf + swptr, cnt, &copied)) {
 			if (!ret)
 				ret = -EFAULT;
 			goto out;
 		}
                 swptr = (swptr + cnt) % dmabuf->dmasize;
                 spin_lock_irqsave(&card->lock, flags);
                 dmabuf->swptr = swptr;
                 dmabuf->count -= cnt;
                 spin_unlock_irqrestore(&card->lock, flags);
                 count -= copied;
                 buffer += copied;
                 ret += copied;
                 start_adc(state);
 	}
 out:
 	remove_wait_queue(&state->dmabuf.wait, &wait);
 out2:
 	mutex_unlock(&state->sem);
 	set_current_state(TASK_RUNNING);
 	CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
 		printk("cs46xx: cs_read()- %zd\n",ret) );
 	return ret;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
    the soundcard.  it is drained by the dma machine and filled by this loop. */
 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct cs_card *card = file->private_data;
 	struct cs_state *state;
 	DECLARE_WAITQUEUE(wait, current);
 	struct dmabuf *dmabuf;
 	ssize_t ret;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
 		printk("cs46xx: cs_write called, count = %zd\n", count) );
 	state = card->states[1];
 	if (!state)
 		return -ENODEV;
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	dmabuf = &state->dmabuf;
 	mutex_lock(&state->sem);
 	if (dmabuf->mapped) {
 		ret = -ENXIO;
 		goto out;
 	}
 	if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
 		goto out;
 	add_wait_queue(&state->dmabuf.wait, &wait);
 	ret = 0;
 /*
 * Start the loop to read from the user's buffer and write to the dma buffer.
 * check for PM events and underrun/overrun in the loop.
 */
 	while (count > 0) {
 		while (!(card->pm.flags & CS46XX_PM_IDLE)) {
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out;
 			}
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		if (dmabuf->count < 0) {
 			/* buffer underrun, we are recovering from sleep_on_timeout,
 			   resync hwptr and swptr */
 			dmabuf->count = 0;
 			dmabuf->swptr = dmabuf->hwptr;
 		}
 		if (dmabuf->underrun) {
 			dmabuf->underrun = 0;
 			dmabuf->hwptr = cs_get_dma_addr(state);
 			dmabuf->swptr = dmabuf->hwptr;
 		}
 		swptr = dmabuf->swptr;
 		cnt = dmabuf->dmasize - swptr;
 		if (dmabuf->count + cnt > dmabuf->dmasize)
 			cnt = dmabuf->dmasize - dmabuf->count;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			/* buffer is full, start the dma machine and wait for data to be
 			   played */
 			start_dac(state);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
  			}
 			mutex_unlock(&state->sem);
 			schedule();
  			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out;
  			}
 			mutex_lock(&state->sem);
 			if (dmabuf->mapped) {
 				if (!ret)
 					ret = -ENXIO;
 				goto out;
 			}
  			continue;
  		}
 		if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			goto out;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		swptr = (swptr + cnt) % dmabuf->dmasize;
 		dmabuf->swptr = swptr;
 		dmabuf->count += cnt;
 		if (dmabuf->count > dmabuf->dmasize) {
 			CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
 			    "cs46xx: cs_write() d->count > dmasize - resetting\n"));
 			dmabuf->count = dmabuf->dmasize;
 		}
 		dmabuf->endcleared = 0;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		start_dac(state);
 	}
 out:
 	mutex_unlock(&state->sem);
 	remove_wait_queue(&state->dmabuf.wait, &wait);
 	set_current_state(TASK_RUNNING);
 	CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
 		printk("cs46xx: cs_write()- ret=%zd\n", ret));
 	return ret;
 }
 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct cs_card *card = file->private_data;
 	struct dmabuf *dmabuf;
 	struct cs_state *state;
 	unsigned long flags;
 	unsigned int mask = 0;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
 	if (!(file->f_mode & (FMODE_WRITE | FMODE_READ))) {
 		return -EINVAL;
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			poll_wait(file, &dmabuf->wait, wait);
 		}
 	}
 	if (file->f_mode & FMODE_READ) {
 		state = card->states[0];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			poll_wait(file, &dmabuf->wait, wait);
 		}
 	}
 	spin_lock_irqsave(&card->lock, flags);
 	cs_update_ptr(card, CS_FALSE);
 	if (file->f_mode & FMODE_READ) {
 		state = card->states[0];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			if (dmabuf->count >= (signed)dmabuf->fragsize)
 				mask |= POLLIN | POLLRDNORM;
 		}
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			if (dmabuf->mapped) {
 				if (dmabuf->count >= (signed)dmabuf->fragsize)
 				    mask |= POLLOUT | POLLWRNORM;
 			} else {
 				if ((signed)dmabuf->dmasize >= dmabuf->count
 					+ (signed)dmabuf->fragsize)
 				    mask |= POLLOUT | POLLWRNORM;
 			}
 		}
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
 		mask));
 	return mask;
 }
 /*
  *	We let users mmap the ring buffer. Its not the real DMA buffer but
  *	that side of the code is hidden in the IRQ handling. We do a software
  *	emulation of DMA from a 64K or so buffer into a 2K FIFO.
  *	(the hardware probably deserves a moan here but Crystal send me nice
  *	toys ;)).
  */
 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct cs_card *card = file->private_data;
 	struct cs_state *state;
 	struct dmabuf *dmabuf;
 	int ret = 0;
 	unsigned long size;
 	CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
 		file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
 		vma->vm_flags & VM_READ ? "VM_READ" : "") );
 	if (vma->vm_flags & VM_WRITE) {
 		state = card->states[1];
 		if (state) {
 			CS_DBGOUT(CS_OPEN, 2, printk(
 			  "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
 			if ((ret = prog_dmabuf(state)) != 0)
 				return ret;
 		}
 	} else if (vma->vm_flags & VM_READ) {
 		state = card->states[0];
 		if (state) {
 			CS_DBGOUT(CS_OPEN, 2, printk(
 			  "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
 			if ((ret = prog_dmabuf(state)) != 0)
 				return ret;
 		}
 	} else {
 		CS_DBGOUT(CS_ERROR, 2, printk(
 		  "cs46xx: cs_mmap() return -EINVAL\n") );
 		return -EINVAL;
 	}
 /*
  * For now ONLY support playback, but seems like the only way to use
  * mmap() is to open an FD with RDWR, just read or just write access
  * does not function, get an error back from the kernel.
  * Also, QuakeIII opens with RDWR!  So, there must be something
  * to needing read/write access mapping.  So, allow read/write but
  * use the DAC only.
  */
 	state = card->states[1];
 	if (!state) {
 		ret = -EINVAL;
 		goto out;
 	}
 	mutex_lock(&state->sem);
 	dmabuf = &state->dmabuf;
 	if (cs4x_pgoff(vma) != 0) {
 		ret = -EINVAL;
 		goto out;
 	}
 	size = vma->vm_end - vma->vm_start;
 	CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
 	if (size > (PAGE_SIZE << dmabuf->buforder)) {
 		ret = -EINVAL;
 		goto out;
 	}
 	if (remap_pfn_range(vma, vma->vm_start,
 			     virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
 			     size, vma->vm_page_prot)) {
 		ret = -EAGAIN;
 		goto out;
 	}
 	dmabuf->mapped = 1;
 	CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
 out:
 	mutex_unlock(&state->sem);
 	return ret;
 }
 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct cs_card *card = file->private_data;
 	struct cs_state *state;
 	struct dmabuf *dmabuf = NULL;
 	unsigned long flags;
 	audio_buf_info abinfo;
 	count_info cinfo;
 	int val, valsave, ret;
 	int mapped = 0;
 	void __user *argp = (void __user *)arg;
 	int __user *p = argp;
 	state = card->states[0];
 	if (state) {
 		dmabuf = &state->dmabuf;
 		mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
 	}
 	state = card->states[1];
 	if (state) {
 		dmabuf = &state->dmabuf;
 		mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
 	}
 #if CSDEBUG
 	printioctl(cmd);
 #endif
 	switch (cmd) {
 	case OSS_GETVERSION:
 		return put_user(SOUND_VERSION, p);
 	case SNDCTL_DSP_RESET:
 		/* FIXME: spin_lock ? */
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				stop_dac(state);
 				synchronize_irq(card->irq);
 				dmabuf->ready = 0;
 				resync_dma_ptrs(state);
 				dmabuf->swptr = dmabuf->hwptr = 0;
 				dmabuf->count = dmabuf->total_bytes = 0;
 				dmabuf->blocks = 0;
 				dmabuf->SGok = 0;
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				stop_adc(state);
 				synchronize_irq(card->irq);
 				resync_dma_ptrs(state);
 				dmabuf->ready = 0;
 				dmabuf->swptr = dmabuf->hwptr = 0;
 				dmabuf->count = dmabuf->total_bytes = 0;
 				dmabuf->blocks = 0;
 				dmabuf->SGok = 0;
 			}
 		}
 		CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
 		return 0;
 	case SNDCTL_DSP_SYNC:
 		if (file->f_mode & FMODE_WRITE)
 			return drain_dac(state, file->f_flags & O_NONBLOCK);
 		return 0;
 	case SNDCTL_DSP_SPEED: /* set sample rate */
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val >= 0) {
 			if (file->f_mode & FMODE_READ) {
 				state = card->states[0];
 				if (state) {
 					dmabuf = &state->dmabuf;
 					stop_adc(state);
 					dmabuf->ready = 0;
 					dmabuf->SGok = 0;
 					cs_set_adc_rate(state, val);
 					cs_set_divisor(dmabuf);
 				}
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				state = card->states[1];
 				if (state) {
 					dmabuf = &state->dmabuf;
 					stop_dac(state);
 					dmabuf->ready = 0;
 					dmabuf->SGok = 0;
 					cs_set_dac_rate(state, val);
 					cs_set_divisor(dmabuf);
 				}
 			}
 			CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
 			    "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
 				file->f_mode & FMODE_WRITE ? "DAC" : "",
 				file->f_mode & FMODE_READ ? "ADC" : "",
 				dmabuf->rate ) );
 			return put_user(dmabuf->rate, p);
 		}
 		return put_user(0, p);
 	case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				stop_dac(state);
 				dmabuf->ready = 0;
 				dmabuf->SGok = 0;
 				if (val)
 					dmabuf->fmt |= CS_FMT_STEREO;
 				else
 					dmabuf->fmt &= ~CS_FMT_STEREO;
 				cs_set_divisor(dmabuf);
 				CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
 				    "cs46xx: DSP_STEREO() DAC %s\n",
 				    (dmabuf->fmt & CS_FMT_STEREO) ?
 					"STEREO":"MONO") );
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				stop_adc(state);
 				dmabuf->ready = 0;
 				dmabuf->SGok = 0;
 				if (val)
 					dmabuf->fmt |= CS_FMT_STEREO;
 				else
 					dmabuf->fmt &= ~CS_FMT_STEREO;
 				cs_set_divisor(dmabuf);
 				CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
 				    "cs46xx: DSP_STEREO() ADC %s\n",
 				    (dmabuf->fmt & CS_FMT_STEREO) ?
 					"STEREO":"MONO") );
 			}
 		}
 		return 0;
 	case SNDCTL_DSP_GETBLKSIZE:
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if ((val = prog_dmabuf(state)))
 					return val;
 				return put_user(dmabuf->fragsize, p);
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if ((val = prog_dmabuf(state)))
 					return val;
 				return put_user(dmabuf->fragsize/dmabuf->divisor,
 						p);
 			}
 		}
 		return put_user(0, p);
 	case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
 		return put_user(AFMT_S16_LE | AFMT_U8, p);
 	case SNDCTL_DSP_SETFMT: /* Select sample format */
 		if (get_user(val, p))
 			return -EFAULT;
 		CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
 		    "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
 			file->f_mode & FMODE_WRITE ? "DAC" : "",
 			file->f_mode & FMODE_READ ? "ADC" : "",
 			val == AFMT_S16_LE ? "16Bit Signed" : "",
 			val == AFMT_U8 ? "8Bit Unsigned" : "") );
 		valsave = val;
 		if (val != AFMT_QUERY) {
 			if (val==AFMT_S16_LE || val==AFMT_U8) {
 				if (file->f_mode & FMODE_WRITE) {
 					state = card->states[1];
 					if (state) {
 						dmabuf = &state->dmabuf;
 						stop_dac(state);
 						dmabuf->ready = 0;
 						dmabuf->SGok = 0;
 						if (val == AFMT_S16_LE)
 							dmabuf->fmt |= CS_FMT_16BIT;
 						else
 							dmabuf->fmt &= ~CS_FMT_16BIT;
 						cs_set_divisor(dmabuf);
 						if ((ret = prog_dmabuf(state)))
 							return ret;
 					}
 				}
 				if (file->f_mode & FMODE_READ) {
 					val = valsave;
 					state = card->states[0];
 					if (state) {
 						dmabuf = &state->dmabuf;
 						stop_adc(state);
 						dmabuf->ready = 0;
 						dmabuf->SGok = 0;
 						if (val == AFMT_S16_LE)
 							dmabuf->fmt |= CS_FMT_16BIT;
 						else
 							dmabuf->fmt &= ~CS_FMT_16BIT;
 						cs_set_divisor(dmabuf);
 						if ((ret = prog_dmabuf(state)))
 							return ret;
 					}
 				}
 			} else {
 				CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
 				    "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
 					valsave) );
 			}
 		} else {
 			if (file->f_mode & FMODE_WRITE) {
 				state = card->states[1];
 				if (state)
 					dmabuf = &state->dmabuf;
 			} else if (file->f_mode & FMODE_READ) {
 				state = card->states[0];
 				if (state)
 					dmabuf = &state->dmabuf;
 			}
 		}
 		if (dmabuf) {
 			if (dmabuf->fmt & CS_FMT_16BIT)
 				return put_user(AFMT_S16_LE, p);
 			else
 				return put_user(AFMT_U8, p);
 		}
 		return put_user(0, p);
 	case SNDCTL_DSP_CHANNELS:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val != 0) {
 			if (file->f_mode & FMODE_WRITE) {
 				state = card->states[1];
 				if (state) {
 					dmabuf = &state->dmabuf;
 					stop_dac(state);
 					dmabuf->ready = 0;
 					dmabuf->SGok = 0;
 					if (val > 1)
 						dmabuf->fmt |= CS_FMT_STEREO;
 					else
 						dmabuf->fmt &= ~CS_FMT_STEREO;
 					cs_set_divisor(dmabuf);
 					if (prog_dmabuf(state))
 						return 0;
 				}
 			}
 			if (file->f_mode & FMODE_READ) {
 				state = card->states[0];
 				if (state) {
 					dmabuf = &state->dmabuf;
 					stop_adc(state);
 					dmabuf->ready = 0;
 					dmabuf->SGok = 0;
 					if (val > 1)
 						dmabuf->fmt |= CS_FMT_STEREO;
 					else
 						dmabuf->fmt &= ~CS_FMT_STEREO;
 					cs_set_divisor(dmabuf);
 					if (prog_dmabuf(state))
 						return 0;
 				}
 			}
 		}
 		return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
 				p);
 	case SNDCTL_DSP_POST:
 		/*
 		 * There will be a longer than normal pause in the data.
 		 * so... do nothing, because there is nothing that we can do.
 		 */
 		return 0;
 	case SNDCTL_DSP_SUBDIVIDE:
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if (dmabuf->subdivision)
 					return -EINVAL;
 				if (get_user(val, p))
 					return -EFAULT;
 				if (val != 1 && val != 2)
 					return -EINVAL;
 				dmabuf->subdivision = val;
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if (dmabuf->subdivision)
 					return -EINVAL;
 				if (get_user(val, p))
 					return -EFAULT;
 				if (val != 1 && val != 2)
 					return -EINVAL;
 				dmabuf->subdivision = val;
 			}
 		}
 		return 0;
 	case SNDCTL_DSP_SETFRAGMENT:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				dmabuf->ossfragshift = val & 0xffff;
 				dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				dmabuf->ossfragshift = val & 0xffff;
 				dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
 			}
 		}
 		return 0;
 	case SNDCTL_DSP_GETOSPACE:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			spin_lock_irqsave(&state->card->lock, flags);
 			cs_update_ptr(card, CS_TRUE);
 			abinfo.fragsize = dmabuf->fragsize;
 			abinfo.fragstotal = dmabuf->numfrag;
 		/*
 		 * for mmap we always have total space available
 		 */
 			if (dmabuf->mapped)
 				abinfo.bytes = dmabuf->dmasize;
 			else
 				abinfo.bytes = dmabuf->dmasize - dmabuf->count;
 			abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
 			spin_unlock_irqrestore(&state->card->lock, flags);
 			return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 		}
 		return -ENODEV;
 	case SNDCTL_DSP_GETISPACE:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		state = card->states[0];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			spin_lock_irqsave(&state->card->lock, flags);
 			cs_update_ptr(card, CS_TRUE);
 			abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
 			abinfo.bytes = dmabuf->count/dmabuf->divisor;
 			abinfo.fragstotal = dmabuf->numfrag;
 			abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
 			spin_unlock_irqrestore(&state->card->lock, flags);
 			return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 		}
 		return -ENODEV;
 	case SNDCTL_DSP_NONBLOCK:
 		file->f_flags |= O_NONBLOCK;
 		return 0;
 	case SNDCTL_DSP_GETCAPS:
 		return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
 			    p);
 	case SNDCTL_DSP_GETTRIGGER:
 		val = 0;
 		CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if (dmabuf->enable & DAC_RUNNING)
 					val |= PCM_ENABLE_INPUT;
 			}
 		}
 		if (file->f_mode & FMODE_READ) {
 			if (state) {
 				state = card->states[0];
 				dmabuf = &state->dmabuf;
 				if (dmabuf->enable & ADC_RUNNING)
 					val |= PCM_ENABLE_OUTPUT;
 			}
 		}
 		CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
 		return put_user(val, p);
 	case SNDCTL_DSP_SETTRIGGER:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_READ) {
 			state = card->states[0];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if (val & PCM_ENABLE_INPUT) {
 					if (!dmabuf->ready && (ret = prog_dmabuf(state)))
 						return ret;
 					start_adc(state);
 				} else
 					stop_adc(state);
 			}
 		}
 		if (file->f_mode & FMODE_WRITE) {
 			state = card->states[1];
 			if (state) {
 				dmabuf = &state->dmabuf;
 				if (val & PCM_ENABLE_OUTPUT) {
 					if (!dmabuf->ready && (ret = prog_dmabuf(state)))
 						return ret;
 					start_dac(state);
 				} else
 					stop_dac(state);
 			}
 		}
 		return 0;
 	case SNDCTL_DSP_GETIPTR:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		state = card->states[0];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			spin_lock_irqsave(&state->card->lock, flags);
 			cs_update_ptr(card, CS_TRUE);
 			cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
 			cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
 			cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
 			spin_unlock_irqrestore(&state->card->lock, flags);
 			if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
 				return -EFAULT;
 			return 0;
 		}
 		return -ENODEV;
 	case SNDCTL_DSP_GETOPTR:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			spin_lock_irqsave(&state->card->lock, flags);
 			cs_update_ptr(card, CS_TRUE);
 			cinfo.bytes = dmabuf->total_bytes;
 			if (dmabuf->mapped) {
 				cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
 							- dmabuf->blocks;
 				CS_DBGOUT(CS_PARMS, 8,
 					printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
 					cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
 				dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
 			} else {
 				cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
 			}
 			cinfo.ptr = dmabuf->hwptr;
 			CS_DBGOUT(CS_PARMS, 4, printk(
 			    "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
 				cinfo.bytes,cinfo.blocks,cinfo.ptr) );
 			spin_unlock_irqrestore(&state->card->lock, flags);
 			if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
 				return -EFAULT;
 			return 0;
 		}
 		return -ENODEV;
 	case SNDCTL_DSP_SETDUPLEX:
 		return 0;
 	case SNDCTL_DSP_GETODELAY:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			spin_lock_irqsave(&state->card->lock, flags);
 			cs_update_ptr(card, CS_TRUE);
 			val = dmabuf->count;
 			spin_unlock_irqrestore(&state->card->lock, flags);
 		} else
 			val = 0;
 		return put_user(val, p);
 	case SOUND_PCM_READ_RATE:
 		if (file->f_mode & FMODE_READ)
 			state = card->states[0];
 		else
 			state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			return put_user(dmabuf->rate, p);
 		}
 		return put_user(0, p);
 	case SOUND_PCM_READ_CHANNELS:
 		if (file->f_mode & FMODE_READ)
 			state = card->states[0];
 		else
 			state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
 				p);
 		}
 		return put_user(0, p);
 	case SOUND_PCM_READ_BITS:
 		if (file->f_mode & FMODE_READ)
 			state = card->states[0];
 		else
 			state = card->states[1];
 		if (state) {
 			dmabuf = &state->dmabuf;
 			return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
 			  	AFMT_S16_LE : AFMT_U8, p);
 		}
 		return put_user(0, p);
 	case SNDCTL_DSP_MAPINBUF:
 	case SNDCTL_DSP_MAPOUTBUF:
 	case SNDCTL_DSP_SETSYNCRO:
 	case SOUND_PCM_WRITE_FILTER:
 	case SOUND_PCM_READ_FILTER:
 		return -EINVAL;
 	}
 	return -EINVAL;
 }
 /*
  *	AMP control - null AMP
  */
 static void amp_none(struct cs_card *card, int change)
 {
 }
 /*
  *	Crystal EAPD mode
  */
 static void amp_voyetra(struct cs_card *card, int change)
 {
 	/* Manage the EAPD bit on the Crystal 4297
 	   and the Analog AD1885 */
 	int old = card->amplifier;
 	card->amplifier+=change;
 	if (card->amplifier && !old) {
 		/* Turn the EAPD amp on */
 		cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
 			cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
 				0x8000);
 	} else if(old && !card->amplifier) {
 		/* Turn the EAPD amp off */
 		cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL,
 			cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				~0x8000);
 	}
 }
 /*
  *	Game Theatre XP card - EGPIO[2] is used to enable the external amp.
  */
 static void amp_hercules(struct cs_card *card, int change)
 {
 	int old = card->amplifier;
 	if (!card) {
 		CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
 			"cs46xx: amp_hercules() called before initialized.\n"));
 		return;
 	}
 	card->amplifier+=change;
 	if ((card->amplifier && !old) && !(hercules_egpio_disable)) {
 		CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
 			"cs46xx: amp_hercules() external amp enabled\n"));
 		cs461x_pokeBA0(card, BA0_EGPIODR,
 			EGPIODR_GPOE2);     /* enable EGPIO2 output */
 		cs461x_pokeBA0(card, BA0_EGPIOPTR,
 			EGPIOPTR_GPPT2);   /* open-drain on output */
 	} else if (old && !card->amplifier) {
 		CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
 			"cs46xx: amp_hercules() external amp disabled\n"));
 		cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
 		cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
 	}
 }
 /*
  *	Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
  *	whenever we need to beat on the chip.
  *
  *	The original idea and code for this hack comes from David Kaiser at
  *	Linuxcare. Perhaps one day Crystal will document their chips well
  *	enough to make them useful.
  */
 static void clkrun_hack(struct cs_card *card, int change)
 {
 	struct pci_dev *acpi_dev;
 	u16 control;
 	u8 pp;
 	unsigned long port;
 	int old = card->active;
 	card->active+=change;
 	acpi_dev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
 	if (acpi_dev == NULL)
 		return;		/* Not a thinkpad thats for sure */
 	/* Find the control port */
 	pci_read_config_byte(acpi_dev, 0x41, &pp);
 	port = pp << 8;
 	/* Read ACPI port */
 	control = inw(port + 0x10);
 	/* Flip CLKRUN off while running */
 	if (!card->active && old) {
 		CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
 			"cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
 				change,card->active));
 		outw(control|0x2000, port+0x10);
 	} else {
 	/*
 	* sometimes on a resume the bit is set, so always reset the bit.
 	*/
 		CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
 			"cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
 				change,card->active));
 		outw(control&~0x2000, port+0x10);
 	}
 	pci_dev_put(acpi_dev);
 }
 static int cs_open(struct inode *inode, struct file *file)
 {
 	struct cs_card *card = file->private_data;
 	struct cs_state *state = NULL;
 	struct dmabuf *dmabuf = NULL;
 	struct list_head *entry;
         unsigned int minor = iminor(inode);
 	int ret = 0;
 	unsigned int tmp;
 	CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
 		file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
 		file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
 	list_for_each(entry, &cs46xx_devs) {
 		card = list_entry(entry, struct cs_card, list);
 		if (!((card->dev_audio ^ minor) & ~0xf))
 			break;
 	}
 	if (entry == &cs46xx_devs)
 		return -ENODEV;
 	if (!card) {
 		CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
 			"cs46xx: cs_open(): Error - unable to find audio card struct\n"));
 		return -ENODEV;
 	}
 	/*
 	 * hardcode state[0] for capture, [1] for playback
 	 */
 	if (file->f_mode & FMODE_READ) {
 		CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
 		if (card->states[0] == NULL) {
 			state = card->states[0] =
 				kmalloc(sizeof(struct cs_state), GFP_KERNEL);
 			if (state == NULL)
 				return -ENOMEM;
 			memset(state, 0, sizeof(struct cs_state));
 			mutex_init(&state->sem);
 			dmabuf = &state->dmabuf;
 			dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 			if (dmabuf->pbuf == NULL) {
 				kfree(state);
 				card->states[0] = NULL;
 				return -ENOMEM;
 			}
 		} else {
 			state = card->states[0];
 			if (state->open_mode & FMODE_READ)
 				return -EBUSY;
 		}
 		dmabuf->channel = card->alloc_rec_pcm_channel(card);
 		if (dmabuf->channel == NULL) {
 			kfree(card->states[0]);
 			card->states[0] = NULL;
 			return -ENODEV;
 		}
 		/* Now turn on external AMP if needed */
 		state->card = card;
 		state->card->active_ctrl(state->card, 1);
 		state->card->amplifier_ctrl(state->card, 1);
 		if ((tmp = cs46xx_powerup(card, CS_POWER_ADC))) {
 			CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 				"cs46xx: cs46xx_powerup of ADC failed (0x%x)\n", tmp));
 			return -EIO;
 		}
 		dmabuf->channel->state = state;
 		/* initialize the virtual channel */
 		state->virt = 0;
 		state->magic = CS_STATE_MAGIC;
 		init_waitqueue_head(&dmabuf->wait);
 		mutex_init(&state->open_mutex);
 		file->private_data = card;
 		mutex_lock(&state->open_mutex);
 		/* set default sample format. According to OSS Programmer's Guide  /dev/dsp
 		   should be default to unsigned 8-bits, mono, with sample rate 8kHz and
 		   /dev/dspW will accept 16-bits sample */
 		/* Default input is 8bit mono */
 		dmabuf->fmt &= ~CS_FMT_MASK;
 		dmabuf->type = CS_TYPE_ADC;
 		dmabuf->ossfragshift = 0;
 		dmabuf->ossmaxfrags  = 0;
 		dmabuf->subdivision  = 0;
 		cs_set_adc_rate(state, 8000);
 		cs_set_divisor(dmabuf);
 		state->open_mode |= FMODE_READ;
 		mutex_unlock(&state->open_mutex);
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
 		if (card->states[1] == NULL) {
 			state = card->states[1] =
 				kmalloc(sizeof(struct cs_state), GFP_KERNEL);
 			if (state == NULL)
 				return -ENOMEM;
 			memset(state, 0, sizeof(struct cs_state));
 			mutex_init(&state->sem);
 			dmabuf = &state->dmabuf;
 			dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 			if (dmabuf->pbuf == NULL) {
 				kfree(state);
 				card->states[1] = NULL;
 				return -ENOMEM;
 			}
 		} else {
 			state = card->states[1];
 			if (state->open_mode & FMODE_WRITE)
 				return -EBUSY;
 		}
 		dmabuf->channel = card->alloc_pcm_channel(card);
 		if (dmabuf->channel == NULL) {
 			kfree(card->states[1]);
 			card->states[1] = NULL;
 			return -ENODEV;
 		}
 		/* Now turn on external AMP if needed */
 		state->card = card;
 		state->card->active_ctrl(state->card, 1);
 		state->card->amplifier_ctrl(state->card, 1);
 		if ((tmp = cs46xx_powerup(card, CS_POWER_DAC))) {
 			CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 				"cs46xx: cs46xx_powerup of DAC failed (0x%x)\n", tmp));
 			return -EIO;
 		}
 		dmabuf->channel->state = state;
 		/* initialize the virtual channel */
 		state->virt = 1;
 		state->magic = CS_STATE_MAGIC;
 		init_waitqueue_head(&dmabuf->wait);
 		mutex_init(&state->open_mutex);
 		file->private_data = card;
 		mutex_lock(&state->open_mutex);
 		/* set default sample format. According to OSS Programmer's Guide  /dev/dsp
 		   should be default to unsigned 8-bits, mono, with sample rate 8kHz and
 		   /dev/dspW will accept 16-bits sample */
 		/* Default output is 8bit mono. */
 		dmabuf->fmt &= ~CS_FMT_MASK;
 		dmabuf->type = CS_TYPE_DAC;
 		dmabuf->ossfragshift = 0;
 		dmabuf->ossmaxfrags  = 0;
 		dmabuf->subdivision  = 0;
 		cs_set_dac_rate(state, 8000);
 		cs_set_divisor(dmabuf);
 		state->open_mode |= FMODE_WRITE;
 		mutex_unlock(&state->open_mutex);
 		if ((ret = prog_dmabuf(state)))
 			return ret;
 	}
 	CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n"));
 	return nonseekable_open(inode, file);
 }
 static int cs_release(struct inode *inode, struct file *file)
 {
 	struct cs_card *card = file->private_data;
 	struct dmabuf *dmabuf;
 	struct cs_state *state;
 	unsigned int tmp;
 	CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
 		file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
 		file->f_mode & FMODE_READ ? "FMODE_READ" : ""));
 	if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
 		return -EINVAL;
 	state = card->states[1];
 	if (state) {
 		if ((state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE)) {
 			CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n"));
 			dmabuf = &state->dmabuf;
 			cs_clear_tail(state);
 			drain_dac(state, file->f_flags & O_NONBLOCK);
 			/* stop DMA state machine and free DMA buffers/channels */
 			mutex_lock(&state->open_mutex);
 			stop_dac(state);
 			dealloc_dmabuf(state);
 			state->card->free_pcm_channel(state->card, dmabuf->channel->num);
 			free_page((unsigned long)state->dmabuf.pbuf);
 			/* we're covered by the open_mutex */
 			mutex_unlock(&state->open_mutex);
 			state->card->states[state->virt] = NULL;
 			state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
 			if ((tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE))) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
 					"cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
 			}
 			/* Now turn off external AMP if needed */
 			state->card->amplifier_ctrl(state->card, -1);
 			state->card->active_ctrl(state->card, -1);
 			kfree(state);
 		}
 	}
 	state = card->states[0];
 	if (state) {
 		if ((state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ)) {
 			CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n"));
 			dmabuf = &state->dmabuf;
 			mutex_lock(&state->open_mutex);
 			stop_adc(state);
 			dealloc_dmabuf(state);
 			state->card->free_pcm_channel(state->card, dmabuf->channel->num);
 			free_page((unsigned long)state->dmabuf.pbuf);
 			/* we're covered by the open_mutex */
 			mutex_unlock(&state->open_mutex);
 			state->card->states[state->virt] = NULL;
 			state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
 			if ((tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE))) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
 					"cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
 			}
 			/* Now turn off external AMP if needed */
 			state->card->amplifier_ctrl(state->card, -1);
 			state->card->active_ctrl(state->card, -1);
 			kfree(state);
 		}
 	}
 	CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n"));
 	return 0;
 }
 static void printpm(struct cs_card *s)
 {
 	CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
 	CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
 		(unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
 	CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
 		s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
 	CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
 		s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
 	CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
 		s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
 	CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
 		s->pm.u32SSCR,s->pm.u32SRCSA));
 	CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
 		s->pm.u32DacASR,s->pm.u32AdcASR));
 	CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
 		s->pm.u32DacSR,s->pm.u32AdcSR));
 	CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
 		s->pm.u32MIDCR_Save));
 	CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
 		s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
 	CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
 		s->pm.u32AC97_master_volume));
 	CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
 		s->pm.u32AC97_headphone_volume));
 	CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
 		s->pm.u32AC97_master_volume_mono));
 	CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
 		s->pm.u32AC97_pcm_out_volume));
 	CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
 		s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
 	CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
 		s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
 }
 /****************************************************************************
 *
 *  Suspend - save the ac97 regs, mute the outputs and power down the part.
 *
 ****************************************************************************/
 static void cs46xx_ac97_suspend(struct cs_card *card)
 {
 	int Count,i;
 	struct ac97_codec *dev=card->ac97_codec[0];
 	unsigned int tmp;
 	CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
 	if (card->states[1]) {
 		stop_dac(card->states[1]);
 		resync_dma_ptrs(card->states[1]);
 	}
 	if (card->states[0]) {
 		stop_adc(card->states[0]);
 		resync_dma_ptrs(card->states[0]);
 	}
 	for (Count = 0x2, i = 0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
 			&& (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
 			Count += 2, i++) {
 		card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
 	}
 /*
 * Save the ac97 volume registers as well as the current powerdown state.
 * Now, mute the all the outputs (master, headphone, and mono), as well
 * as the PCM volume, in preparation for powering down the entire part.
 	card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
 			(u8)BA0_AC97_MASTER_VOLUME);
 	card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
 			(u8)BA0_AC97_HEADPHONE_VOLUME);
 	card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
 			(u8)BA0_AC97_MASTER_VOLUME_MONO);
 	card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
 			(u8)BA0_AC97_PCM_OUT_VOLUME);
 */
 /*
 * mute the outputs
 */
 	cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
 	cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
 	cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
 	cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
 /*
 * save the registers that cause pops
 */
 	card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
 	card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
 /*
 * And power down everything on the AC97 codec.
 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
 * trouble with removing VREF.
 */
 	if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
 			CS_POWER_MIXVON, CS_TRUE))) {
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 			"cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp));
 	}
 	CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
 }
 /****************************************************************************
 *
 *  Resume - power up the part and restore its registers..
 *
 ****************************************************************************/
 static void cs46xx_ac97_resume(struct cs_card *card)
 {
 	int Count,i;
 	struct ac97_codec *dev=card->ac97_codec[0];
 	CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
 /*
 * First, we restore the state of the general purpose register.  This
 * contains the mic select (mic1 or mic2) and if we restore this after
 * we restore the mic volume/boost state and mic2 was selected at
 * suspend time, we will end up with a brief period of time where mic1
 * is selected with the volume/boost settings for mic2, causing
 * acoustic feedback.  So we restore the general purpose register
 * first, thereby getting the correct mic selected before we restore
 * the mic volume/boost.
 */
 	cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
 		(u16)card->pm.u32AC97_general_purpose);
 /*
 * Now, while the outputs are still muted, restore the state of power
 * on the AC97 part.
 */
 	cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
 	mdelay(5 * cs_laptop_wait);
 /*
 * Restore just the first set of registers, from register number
 * 0x02 to the register number that ulHighestRegToRestore specifies.
 */
 	for (Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE) &&
 			(i < CS46XX_AC97_NUMBER_RESTORE_REGS); Count += 2, i++) {
 		cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
 	}
 	/* Check if we have to init the amplifier */
 	if (card->amp_init)
 		card->amp_init(card);
 	CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
 }
 static int cs46xx_restart_part(struct cs_card *card)
 {
 	struct dmabuf *dmabuf;
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
 		printk( "cs46xx: cs46xx_restart_part()+\n"));
 	if (card->states[1]) {
 		dmabuf = &card->states[1]->dmabuf;
 		dmabuf->ready = 0;
 		resync_dma_ptrs(card->states[1]);
 		cs_set_divisor(dmabuf);
 		if (__prog_dmabuf(card->states[1])) {
 			CS_DBGOUT(CS_PM | CS_ERROR, 1,
 				printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
 			return -1;
 		}
 		cs_set_dac_rate(card->states[1], dmabuf->rate);
 	}
 	if (card->states[0]) {
 		dmabuf = &card->states[0]->dmabuf;
 		dmabuf->ready = 0;
 		resync_dma_ptrs(card->states[0]);
 		cs_set_divisor(dmabuf);
 		if (__prog_dmabuf(card->states[0])) {
 			CS_DBGOUT(CS_PM | CS_ERROR, 1,
 				printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
 			return -1;
 		}
 		cs_set_adc_rate(card->states[0], dmabuf->rate);
 	}
 	card->pm.flags |= CS46XX_PM_RESUMED;
 	if (card->states[0])
 		start_adc(card->states[0]);
 	if (card->states[1])
 		start_dac(card->states[1]);
 	card->pm.flags |= CS46XX_PM_IDLE;
 	card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
 			| CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
 	if (card->states[0])
 		wake_up(&card->states[0]->dmabuf.wait);
 	if (card->states[1])
 		wake_up(&card->states[1]->dmabuf.wait);
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
 		printk( "cs46xx: cs46xx_restart_part()-\n"));
 	return 0;
 }
 static void cs461x_reset(struct cs_card *card);
 static void cs461x_proc_stop(struct cs_card *card);
 static int cs46xx_suspend(struct cs_card *card, pm_message_t state)
 {
 	unsigned int tmp;
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
 		printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
 			(unsigned)card->pm.flags,card));
 /*
 * check the current state, only suspend if IDLE
 */
 	if (!(card->pm.flags & CS46XX_PM_IDLE)) {
 		CS_DBGOUT(CS_PM | CS_ERROR, 2,
 			printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
 		return 1;
 	}
 	card->pm.flags &= ~CS46XX_PM_IDLE;
 	card->pm.flags |= CS46XX_PM_SUSPENDING;
 	card->active_ctrl(card,1);
 	tmp = cs461x_peek(card, BA1_PFIE);
 	tmp &= ~0x0000f03f;
 	tmp |=  0x00000010;
 	cs461x_poke(card, BA1_PFIE, tmp);	/* playback interrupt disable */
 	tmp = cs461x_peek(card, BA1_CIE);
 	tmp &= ~0x0000003f;
 	tmp |=  0x00000011;
 	cs461x_poke(card, BA1_CIE, tmp);	/* capture interrupt disable */
 	/*
          *  Stop playback DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_PCTL);
 	cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
 	/*
          *  Stop capture DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_CCTL);
 	cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
 	if (card->states[1]) {
 		card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
 		card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
 	}
 	if (card->states[0]) {
 		card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
 		card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
 	}
 	cs46xx_ac97_suspend(card);
 	/*
          *  Reset the processor.
          */
 	cs461x_reset(card);
 	cs461x_proc_stop(card);
 	/*
 	 *  Power down the DAC and ADC.  For now leave the other areas on.
 	 */
 	cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
 	/*
 	 *  Power down the PLL.
 	 */
 	cs461x_pokeBA0(card, BA0_CLKCR1, 0);
 	/*
 	 *  Turn off the Processor by turning off the software clock enable flag in
 	 *  the clock control register.
 	 */
 	tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
 	cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
 	card->active_ctrl(card,-1);
 	card->pm.flags &= ~CS46XX_PM_SUSPENDING;
 	card->pm.flags |= CS46XX_PM_SUSPENDED;
 	printpm(card);
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
 		printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
 			(unsigned)card->pm.flags));
 	return 0;
 }
 static int cs46xx_resume(struct cs_card *card)
 {
 	int i;
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
 		printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
 			(unsigned)card->pm.flags));
 	if (!(card->pm.flags & CS46XX_PM_SUSPENDED)) {
 		CS_DBGOUT(CS_PM | CS_ERROR, 2,
 			printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
 		return 1;
 	}
 	card->pm.flags |= CS46XX_PM_RESUMING;
 	card->pm.flags &= ~CS46XX_PM_SUSPENDED;
 	printpm(card);
 	card->active_ctrl(card, 1);
 	for (i = 0; i < 5; i++) {
 		if (cs_hardware_init(card) != 0) {
 			CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
 				"cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
 			mdelay(10 * cs_laptop_wait);
 			cs461x_reset(card);
 			continue;
 		}
 		break;
 	}
 	if (i >= 4) {
 		CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
 			"cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
 		return 0;
 	}
 	if (cs46xx_restart_part(card)) {
 		CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
 			"cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
 	}
 	card->active_ctrl(card, -1);
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
 		(unsigned)card->pm.flags));
 	return 0;
 }
 static /*const*/ struct file_operations cs461x_fops = {
 	CS_OWNER	CS_THIS_MODULE
 	.llseek		= no_llseek,
 	.read		= cs_read,
 	.write		= cs_write,
 	.poll		= cs_poll,
 	.ioctl		= cs_ioctl,
 	.mmap		= cs_mmap,
 	.open		= cs_open,
 	.release	= cs_release,
 };
 /* Write AC97 codec registers */
 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
 {
 	struct cs_card *card = dev->private_data;
 	int count,loopcnt;
 	unsigned int tmp;
 	u16 ret;
 	/*
 	 *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
 	 *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
 	 *  3. Write ACCTL = Control Register = 460h for initiating the write
 	 *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
 	 *  5. if DCV not cleared, break and return error
 	 *  6. Read ACSTS = Status Register = 464h, check VSTS bit
 	 */
 	cs461x_peekBA0(card, BA0_ACSDA);
 	/*
 	 *  Setup the AC97 control registers on the CS461x to send the
 	 *  appropriate command to the AC97 to perform the read.
 	 *  ACCAD = Command Address Register = 46Ch
 	 *  ACCDA = Command Data Register = 470h
 	 *  ACCTL = Control Register = 460h
 	 *  set DCV - will clear when process completed
 	 *  set CRW - Read command
 	 *  set VFRM - valid frame enabled
 	 *  set ESYN - ASYNC generation enabled
 	 *  set RSTN - ARST# inactive, AC97 codec not reset
 	 */
 	cs461x_pokeBA0(card, BA0_ACCAD, reg);
 	cs461x_pokeBA0(card, BA0_ACCDA, 0);
 	cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
 					     ACCTL_VFRM | ACCTL_ESYN |
 					     ACCTL_RSTN);
 	/*
 	 *  Wait for the read to occur.
 	 */
 	if (!(card->pm.flags & CS46XX_PM_IDLE))
 		loopcnt = 2000;
 	else
 		loopcnt = 500 * cs_laptop_wait;
  	loopcnt *= cs_laptop_wait;
 	for (count = 0; count < loopcnt; count++) {
 		/*
 		 *  First, we want to wait for a short time.
 	 	 */
 		udelay(10 * cs_laptop_wait);
 		/*
 		 *  Now, check to see if the read has completed.
 		 *  ACCTL = 460h, DCV should be reset by now and 460h = 17h
 		 */
 		if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
 			break;
 	}
 	/*
 	 *  Make sure the read completed.
 	 */
 	if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 			"cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
 		return 0xffff;
 	}
 	/*
 	 *  Wait for the valid status bit to go active.
 	 */
 	if (!(card->pm.flags & CS46XX_PM_IDLE))
 		loopcnt = 2000;
 	else
 		loopcnt = 1000;
  	loopcnt *= cs_laptop_wait;
 	for (count = 0; count < loopcnt; count++) {
 		/*
 		 *  Read the AC97 status register.
 		 *  ACSTS = Status Register = 464h
 		 *  VSTS - Valid Status
 		 */
 		if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
 			break;
 		udelay(10 * cs_laptop_wait);
 	}
 	/*
 	 *  Make sure we got valid status.
 	 */
 	if (!((tmp = cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
 		CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
 			"cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
 				reg, tmp));
 		return 0xffff;
 	}
 	/*
 	 *  Read the data returned from the AC97 register.
 	 *  ACSDA = Status Data Register = 474h
 	 */
 	CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
 		"cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
 			reg, cs461x_peekBA0(card, BA0_ACSDA),
 			cs461x_peekBA0(card, BA0_ACCAD)));
 	ret = cs461x_peekBA0(card, BA0_ACSDA);
 	return ret;
 }
 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
 {
 	u16 ret;
 	struct cs_card *card = dev->private_data;
 	spin_lock(&card->ac97_lock);
 	ret = _cs_ac97_get(dev, reg);
 	spin_unlock(&card->ac97_lock);
 	return ret;
 }
 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
 {
 	struct cs_card *card = dev->private_data;
 	int count;
 	int val2 = 0;
 	spin_lock(&card->ac97_lock);
 	if (reg == AC97_CD_VOL)
 		val2 = _cs_ac97_get(dev, AC97_CD_VOL);
 	/*
 	 *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
 	 *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
 	 *  3. Write ACCTL = Control Register = 460h for initiating the write
 	 *  4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
 	 *  5. if DCV not cleared, break and return error
 	 */
 	/*
 	 *  Setup the AC97 control registers on the CS461x to send the
 	 *  appropriate command to the AC97 to perform the read.
 	 *  ACCAD = Command Address Register = 46Ch
 	 *  ACCDA = Command Data Register = 470h
 	 *  ACCTL = Control Register = 460h
 	 *  set DCV - will clear when process completed
 	 *  reset CRW - Write command
 	 *  set VFRM - valid frame enabled
 	 *  set ESYN - ASYNC generation enabled
 	 *  set RSTN - ARST# inactive, AC97 codec not reset
          */
 	cs461x_pokeBA0(card, BA0_ACCAD, reg);
 	cs461x_pokeBA0(card, BA0_ACCDA, val);
 	cs461x_peekBA0(card, BA0_ACCTL);
 	cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
 	cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
 				             ACCTL_ESYN | ACCTL_RSTN);
 	for (count = 0; count < 1000; count++) {
 		/*
 		 *  First, we want to wait for a short time.
 		 */
 		udelay(10 * cs_laptop_wait);
 		/*
 		 *  Now, check to see if the write has completed.
 		 *  ACCTL = 460h, DCV should be reset by now and 460h = 07h
 		 */
 		if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
 			break;
 	}
 	/*
 	 *  Make sure the write completed.
 	 */
 	if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 			"cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
 	}
 	spin_unlock(&card->ac97_lock);
 	/*
 	 *	Adjust power if the mixer is selected/deselected according
 	 *	to the CD.
 	 *
 	 *	IF the CD is a valid input source (mixer or direct) AND
 	 *		the CD is not muted THEN power is needed
 	 *
 	 *	We do two things. When record select changes the input to
 	 *	add/remove the CD we adjust the power count if the CD is
 	 *	unmuted.
 	 *
 	 *	When the CD mute changes we adjust the power level if the
 	 *	CD was a valid input.
 	 *
 	 *      We also check for CD volume != 0, as the CD mute isn't
 	 *      normally tweaked from userspace.
 	 */
 	/* CD mute change ? */
 	if (reg == AC97_CD_VOL) {
 		/* Mute bit change ? */
 		if ((val2^val) & 0x8000 ||
 		    ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val)) {
 			/* This is a hack but its cleaner than the alternatives.
 			   Right now card->ac97_codec[0] might be NULL as we are
 			   still doing codec setup. This does an early assignment
 			   to avoid the problem if it occurs */
 			if (card->ac97_codec[0] == NULL)
 				card->ac97_codec[0] = dev;
 			/* Mute on */
 			if (val & 0x8000 || val == 0x1f1f)
 				card->amplifier_ctrl(card, -1);
 			else { /* Mute off power on */
 				if (card->amp_init)
 					card->amp_init(card);
 				card->amplifier_ctrl(card, 1);
 			}
 		}
 	}
 }
 /* OSS /dev/mixer file operation methods */
 static int cs_open_mixdev(struct inode *inode, struct file *file)
 {
 	int i = 0;
 	unsigned int minor = iminor(inode);
 	struct cs_card *card = NULL;
 	struct list_head *entry;
 	unsigned int tmp;
 	CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
 		  printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
 	list_for_each(entry, &cs46xx_devs) {
 		card = list_entry(entry, struct cs_card, list);
 		for (i = 0; i < NR_AC97; i++)
 			if (card->ac97_codec[i] != NULL &&
 			    card->ac97_codec[i]->dev_mixer == minor)
 				goto match;
 	}
 	if (!card) {
 		CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
 			printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
 		return -ENODEV;
 	}
  match:
 	if (!card->ac97_codec[i])
 		return -ENODEV;
 	file->private_data = card->ac97_codec[i];
 	card->active_ctrl(card,1);
 	if (!CS_IN_USE(&card->mixer_use_cnt)) {
 		if ((tmp = cs46xx_powerup(card, CS_POWER_MIXVON))) {
 			CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 				"cs46xx: cs_open_mixdev() powerup failure (0x%x)\n", tmp));
 			return -EIO;
 		}
 	}
 	card->amplifier_ctrl(card, 1);
 	CS_INC_USE_COUNT(&card->mixer_use_cnt);
 	CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
 		  printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
 	return nonseekable_open(inode, file);
 }
 static int cs_release_mixdev(struct inode *inode, struct file *file)
 {
 	unsigned int minor = iminor(inode);
 	struct cs_card *card = NULL;
 	struct list_head *entry;
 	int i;
 	unsigned int tmp;
 	CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
 		  printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
 	list_for_each(entry, &cs46xx_devs)
 	{
 		card = list_entry(entry, struct cs_card, list);
 		for (i = 0; i < NR_AC97; i++)
 			if (card->ac97_codec[i] != NULL &&
 			    card->ac97_codec[i]->dev_mixer == minor)
 				goto match;
 	}
 	if (!card) {
 		CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
 			printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
 		return -ENODEV;
 	}
 match:
 	if (!CS_DEC_AND_TEST(&card->mixer_use_cnt)) {
 		CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
 			  printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
 		card->active_ctrl(card, -1);
 		card->amplifier_ctrl(card, -1);
 		return 0;
 	}
 /*
 * ok, no outstanding mixer opens, so powerdown.
 */
 	if ((tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE))) {
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 			"cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n", tmp));
 		card->active_ctrl(card, -1);
 		card->amplifier_ctrl(card, -1);
 		return -EIO;
 	}
 	card->active_ctrl(card, -1);
 	card->amplifier_ctrl(card, -1);
 	CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
 		  printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
 	return 0;
 }
 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 			unsigned long arg)
 {
 	struct ac97_codec *codec = file->private_data;
 	struct cs_card *card = NULL;
 	struct list_head *entry;
 	unsigned long __user *p = (long __user *)arg;
 #if CSDEBUG_INTERFACE
         int val;
 	if (	(cmd == SOUND_MIXER_CS_GETDBGMASK) ||
 		(cmd == SOUND_MIXER_CS_SETDBGMASK) ||
 		(cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
 		(cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
 		(cmd == SOUND_MIXER_CS_APM)) {
 		switch (cmd) {
 		case SOUND_MIXER_CS_GETDBGMASK:
 			return put_user(cs_debugmask, p);
 		case SOUND_MIXER_CS_GETDBGLEVEL:
 			return put_user(cs_debuglevel, p);
 		case SOUND_MIXER_CS_SETDBGMASK:
 			if (get_user(val, p))
 				return -EFAULT;
 			cs_debugmask = val;
 			return 0;
 		case SOUND_MIXER_CS_SETDBGLEVEL:
 			if (get_user(val, p))
 				return -EFAULT;
 			cs_debuglevel = val;
 			return 0;
 		case SOUND_MIXER_CS_APM:
 			if (get_user(val, p))
 				return -EFAULT;
 			if (val == CS_IOCTL_CMD_SUSPEND) {
 				list_for_each(entry, &cs46xx_devs) {
 					card = list_entry(entry, struct cs_card, list);
 					cs46xx_suspend(card, PMSG_ON);
 				}
 			} else if (val == CS_IOCTL_CMD_RESUME) {
 				list_for_each(entry, &cs46xx_devs) {
 					card = list_entry(entry, struct cs_card, list);
 					cs46xx_resume(card);
 				}
 			} else {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
 				    "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
 					val));
 			}
 			return 0;
 		default:
 			CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
 				"cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n"));
 			return 0;
 		}
 	}
 #endif
 	return codec->mixer_ioctl(codec, cmd, arg);
 }
 static /*const*/ struct file_operations cs_mixer_fops = {
 	CS_OWNER	CS_THIS_MODULE
 	.llseek		= no_llseek,
 	.ioctl		= cs_ioctl_mixdev,
 	.open		= cs_open_mixdev,
 	.release	= cs_release_mixdev,
 };
 /* AC97 codec initialisation. */
 static int __init cs_ac97_init(struct cs_card *card)
 {
 	int num_ac97 = 0;
 	int ready_2nd = 0;
 	struct ac97_codec *codec;
 	u16 eid;
 	CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 		"cs46xx: cs_ac97_init()+\n") );
 	for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
 		if ((codec = ac97_alloc_codec()) == NULL)
 			return -ENOMEM;
 		/* initialize some basic codec information, other fields will be filled
 		   in ac97_probe_codec */
 		codec->private_data = card;
 		codec->id = num_ac97;
 		codec->codec_read = cs_ac97_get;
 		codec->codec_write = cs_ac97_set;
 		if (ac97_probe_codec(codec) == 0) {
 			CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 				"cs46xx: cs_ac97_init()- codec number %d not found\n",
 					num_ac97) );
 			card->ac97_codec[num_ac97] = NULL;
 			break;
 		}
 		CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 			"cs46xx: cs_ac97_init() found codec %d\n",num_ac97));
 		eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
 		if (eid == 0xFFFF) {
 			printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
 			ac97_release_codec(codec);
 			break;
 		}
 		card->ac97_features = eid;
 		if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
 			printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
 			ac97_release_codec(codec);
 			break;
 		}
 		card->ac97_codec[num_ac97] = codec;
 		CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 			"cs46xx: cs_ac97_init() ac97_codec[%d] set to %p\n",
 				(unsigned int)num_ac97,
 				codec));
 		/* if there is no secondary codec at all, don't probe any more */
 		if (!ready_2nd)
 		{
 			num_ac97 += 1;
 			break;
 		}
 	}
 	CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 		"cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
 	return num_ac97;
 }
 /*
  * load the static image into the DSP
  */
 #include "cs461x_image.h"
 static void cs461x_download_image(struct cs_card *card)
 {
     unsigned i, j, temp1, temp2, offset, count;
     unsigned char __iomem *pBA1 = ioremap(card->ba1_addr, 0x40000);
     for (i = 0; i < CLEAR__COUNT; i++) {
         offset = ClrStat[i].BA1__DestByteOffset;
         count  = ClrStat[i].BA1__SourceSize;
         for (temp1 = offset; temp1 < (offset + count); temp1 += 4)
               writel(0, pBA1+temp1);
     }
     for (i = 0; i < FILL__COUNT; i++) {
         temp2 = FillStat[i].Offset;
         for (j = 0; j < (FillStat[i].Size) / 4; j++) {
             temp1 = (FillStat[i]).pFill[j];
             writel(temp1, pBA1+temp2 + j * 4);
         }
     }
     iounmap(pBA1);
 }
 /*
  *  Chip reset
  */
 static void cs461x_reset(struct cs_card *card)
 {
 	int idx;
 	/*
 	 *  Write the reset bit of the SP control register.
 	 */
 	cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
 	/*
 	 *  Write the control register.
 	 */
 	cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
 	/*
 	 *  Clear the trap registers.
 	 */
 	for (idx = 0; idx < 8; idx++) {
 		cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
 		cs461x_poke(card, BA1_TWPR, 0xFFFF);
 	}
 	cs461x_poke(card, BA1_DREG, 0);
 	/*
 	 *  Set the frame timer to reflect the number of cycles per frame.
 	 */
 	cs461x_poke(card, BA1_FRMT, 0xadf);
 }
 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
 {
 	int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
 	unsigned int tmp;
 	/*
 	 *  See if the devices are powered down.  If so, we must power them up first
 	 *  or they will not respond.
 	 */
 	if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
 		cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
 		powerdown1 = 1;
 	}
 	/*
 	 *  We want to clear out the serial port FIFOs so we don't end up playing
 	 *  whatever random garbage happens to be in them.  We fill the sample FIFOS
 	 *  with zero (silence).
          */
 	cs461x_pokeBA0(card, BA0_SERBWP, 0);
 	/*
 	* Check for which FIFO locations to clear, if we are currently
 	* playing or capturing then we don't want to put in 128 bytes of
 	* "noise".
 	 */
 	if (type & CS_TYPE_DAC) {
 		startfifo = 128;
 		endfifo = 256;
 	}
 	if (type & CS_TYPE_ADC) {
 		startfifo = 0;
 		if (!endfifo)
 			endfifo = 128;
 	}
 	/*
 	 *  Fill sample FIFO locations (256 locations total).
 	 */
 	for (idx = startfifo; idx < endfifo; idx++) {
 		/*
 		 *  Make sure the previous FIFO write operation has completed.
 		 */
 		for (loop = 0; loop < 5; loop++) {
 			udelay(50);
 			if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
 				break;
 		}
 		if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
 			if (powerdown1)
 				cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
 		}
 		/*
 		 *  Write the serial port FIFO index.
 		 */
 		cs461x_pokeBA0(card, BA0_SERBAD, idx);
 		/*
 		 *  Tell the serial port to load the new value into the FIFO location.
 		 */
 		cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
 	}
 	/*
 	 *  Now, if we powered up the devices, then power them back down again.
 	 *  This is kinda ugly, but should never happen.
 	 */
 	if (powerdown1)
 		cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
 }
 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
 {
 	int count;
 	unsigned int tmp=0,muted=0;
 	CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
 		"cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
 	if (!cs_powerdown && !suspendflag) {
 		CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
 			"cs46xx: cs461x_powerdown() DISABLED exiting\n"));
 		return 0;
 	}
 	tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 	CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
 		"cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
 /*
 * if powering down only the VREF, and not powering down the DAC/ADC,
 * then do not power down the VREF, UNLESS both the DAC and ADC are not
 * currently powered down.  If powering down DAC and ADC, then
 * it is possible to power down the VREF (ON).
 */
 	if (((type & CS_POWER_MIXVON) &&
 		 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))))
 	      &&
 		((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
 		 (tmp & CS_AC97_POWER_CONTROL_DAC_ON))) {
 		CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
 			"cs46xx: cs461x_powerdown()- 0  unable to powerdown. tmp=0x%x\n",tmp));
 		return 0;
 	}
 /*
 * for now, always keep power to the mixer block.
 * not sure why it's a problem but it seems to be if we power off.
 */
 	type &= ~CS_POWER_MIXVON;
 	type &= ~CS_POWER_MIXVOFF;
 	/*
 	 *  Power down indicated areas.
 	 */
 	if (type & CS_POWER_MIXVOFF) {
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
 		/*
 		 *  Power down the MIXER (VREF ON) on the AC97 card.
 		 */
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_MIXVOFF_ON))
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerdown MIXVOFF failed\n"));
 				return 1;
 			}
 		}
 	}
 	if (type & CS_POWER_MIXVON) {
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
 		/*
 		 *  Power down the MIXER (VREF ON) on the AC97 card.
 		 */
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp |= CS_AC97_POWER_CONTROL_MIXVON;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_MIXVON_ON))
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_MIXVON_ON) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerdown MIXVON failed\n"));
 				return 1;
 			}
 		}
 	}
 	if (type & CS_POWER_ADC) {
 		/*
 		 *  Power down the ADC on the AC97 card.
 		 */
 		CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (tmp & CS_AC97_POWER_CONTROL_ADC_ON) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp |= CS_AC97_POWER_CONTROL_ADC;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_ADC_ON))
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_ADC_ON) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerdown ADC failed\n"));
 				return 1;
 			}
 		}
 	}
 	if (type & CS_POWER_DAC) {
 		/*
 		 *  Power down the DAC on the AC97 card.
 		 */
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (tmp & CS_AC97_POWER_CONTROL_DAC_ON) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp |= CS_AC97_POWER_CONTROL_DAC;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_DAC_ON))
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_DAC_ON) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerdown DAC failed\n"));
 				return 1;
 			}
 		}
 	}
 	tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 	if (muted)
 		cs_mute(card, CS_FALSE);
 	CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
 		"cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
 	return 0;
 }
 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
 {
 	int count;
 	unsigned int tmp = 0, muted = 0;
 	CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
 		"cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
 	/*
 	* check for VREF and powerup if need to.
 	*/
 	if (type & CS_POWER_MIXVON)
 		type |= CS_POWER_MIXVOFF;
 	if (type & (CS_POWER_DAC | CS_POWER_ADC))
 		type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
 	/*
 	 *  Power up indicated areas.
 	 */
 	if (type & CS_POWER_MIXVOFF) {
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
 		/*
 		 *  Power up the MIXER (VREF ON) on the AC97 card.
 		 */
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_MIXVOFF_ON)
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerup MIXVOFF failed\n"));
 				return 1;
 			}
 		}
 	}
 	if(type & CS_POWER_MIXVON) {
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
 		/*
 		 *  Power up the MIXER (VREF ON) on the AC97 card.
 		 */
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_MIXVON_ON)
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_MIXVON_ON)) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerup MIXVON failed\n"));
 				return 1;
 			}
 		}
 	}
 	if (type & CS_POWER_ADC) {
 		/*
 		 *  Power up the ADC on the AC97 card.
 		 */
 		CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON)) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp &= ~CS_AC97_POWER_CONTROL_ADC;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_ADC_ON)
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_ADC_ON)) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerup ADC failed\n"));
 				return 1;
 			}
 		}
 	}
 	if (type & CS_POWER_DAC) {
 		/*
 		 *  Power up the DAC on the AC97 card.
 		 */
 		CS_DBGOUT(CS_FUNCTION, 4,
 			printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
 		tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 		if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON)) {
 			if (!muted) {
 				cs_mute(card, CS_TRUE);
 				muted = 1;
 			}
 			tmp &= ~CS_AC97_POWER_CONTROL_DAC;
 			cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
 			/*
 			 *  Now, we wait until we sample a ready state.
 			 */
 			for (count = 0; count < 32; count++) {
 				/*
 				 *  First, lets wait a short while to let things settle out a
 				 *  bit, and to prevent retrying the read too quickly.
 				 */
 				udelay(500);
 				/*
 				 *  Read the current state of the power control register.
 				 */
 				if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 					CS_AC97_POWER_CONTROL_DAC_ON)
 					break;
 			}
 			/*
 			 *  Check the status..
 			 */
 			if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
 				CS_AC97_POWER_CONTROL_DAC_ON)) {
 				CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
 					"cs46xx: powerup DAC failed\n"));
 				return 1;
 			}
 		}
 	}
 	tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
 	if (muted)
 		cs_mute(card, CS_FALSE);
 	CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
 		"cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
 	return 0;
 }
 static void cs461x_proc_start(struct cs_card *card)
 {
 	int cnt;
 	/*
 	 *  Set the frame timer to reflect the number of cycles per frame.
 	 */
 	cs461x_poke(card, BA1_FRMT, 0xadf);
 	/*
 	 *  Turn on the run, run at frame, and DMA enable bits in the local copy of
 	 *  the SP control register.
 	 */
 	cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
 	/*
 	 *  Wait until the run at frame bit resets itself in the SP control
 	 *  register.
 	 */
 	for (cnt = 0; cnt < 25; cnt++) {
 		udelay(50);
 		if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
 			break;
 	}
 	if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
 		printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
 }
 static void cs461x_proc_stop(struct cs_card *card)
 {
 	/*
 	 *  Turn off the run, run at frame, and DMA enable bits in the local copy of
 	 *  the SP control register.
 	 */
 	cs461x_poke(card, BA1_SPCR, 0);
 }
 static int cs_hardware_init(struct cs_card *card)
 {
 	unsigned long end_time;
 	unsigned int tmp,count;
 	CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 		"cs46xx: cs_hardware_init()+\n") );
 	/*
 	 *  First, blast the clock control register to zero so that the PLL starts
          *  out in a known state, and blast the master serial port control register
          *  to zero so that the serial ports also start out in a known state.
          */
         cs461x_pokeBA0(card, BA0_CLKCR1, 0);
         cs461x_pokeBA0(card, BA0_SERMC1, 0);
 	/*
 	 *  If we are in AC97 mode, then we must set the part to a host controlled
          *  AC-link.  Otherwise, we won't be able to bring up the link.
          */
         cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03);	/* 1.03 card */
         /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
         /*
          *  Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
          *  spec) and then drive it high.  This is done for non AC97 modes since
          *  there might be logic external to the CS461x that uses the ARST# line
          *  for a reset.
          */
         cs461x_pokeBA0(card, BA0_ACCTL, 1);
         udelay(50);
         cs461x_pokeBA0(card, BA0_ACCTL, 0);
         udelay(50);
         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
 	/*
 	 *  The first thing we do here is to enable sync generation.  As soon
 	 *  as we start receiving bit clock, we'll start producing the SYNC
 	 *  signal.
 	 */
 	cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
 	/*
 	 *  Now wait for a short while to allow the AC97 part to start
 	 *  generating bit clock (so we don't try to start the PLL without an
 	 *  input clock).
 	 */
 	mdelay(5 * cs_laptop_wait);		/* 1 should be enough ?? (and pigs might fly) */
 	/*
 	 *  Set the serial port timing configuration, so that
 	 *  the clock control circuit gets its clock from the correct place.
 	 */
 	cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
 	/*
 	* The part seems to not be ready for a while after a resume.
 	* so, if we are resuming, then wait for 700 mils.  Note that 600 mils
 	* is not enough for some platforms! tested on an IBM Thinkpads and
 	* reference cards.
 	*/
 	if (!(card->pm.flags & CS46XX_PM_IDLE))
 		mdelay(initdelay);
 	/*
 	 *  Write the selected clock control setup to the hardware.  Do not turn on
 	 *  SWCE yet (if requested), so that the devices clocked by the output of
 	 *  PLL are not clocked until the PLL is stable.
 	 */
 	cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
 	cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
 	cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
 	/*
 	 *  Power up the PLL.
 	 */
 	cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
 	/*
          *  Wait until the PLL has stabilized.
 	 */
 	mdelay(5 * cs_laptop_wait);		/* Again 1 should be enough ?? */
 	/*
 	 *  Turn on clocking of the core so that we can setup the serial ports.
 	 */
 	tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
 	cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
 	/*
 	 *  Fill the serial port FIFOs with silence.
 	 */
 	cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
 	/*
 	 *  Set the serial port FIFO pointer to the first sample in the FIFO.
 	 */
 	/* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
 	/*
 	 *  Write the serial port configuration to the part.  The master
 	 *  enable bit is not set until all other values have been written.
 	 */
 	cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
 	cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
 	cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
 	mdelay(5 * cs_laptop_wait);		/* Shouldnt be needed ?? */
 /*
 * If we are resuming under 2.2.x then we cannot schedule a timeout,
 * so just spin the CPU.
 */
 	if (card->pm.flags & CS46XX_PM_IDLE) {
 	/*
 	 * Wait for the card ready signal from the AC97 card.
 	 */
 		end_time = jiffies + 3 * (HZ >> 2);
 		do {
 		/*
 		 *  Read the AC97 status register to see if we've seen a CODEC READY
 		 *  signal from the AC97 card.
 		 */
 			if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
 				break;
 			current->state = TASK_UNINTERRUPTIBLE;
 			schedule_timeout(1);
 		} while (time_before(jiffies, end_time));
 	} else {
 		for (count = 0; count < 100; count++) {
 		// First, we want to wait for a short time.
 			udelay(25 * cs_laptop_wait);
 			if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
 				break;
 		}
 	}
 	/*
 	 *  Make sure CODEC is READY.
 	 */
 	if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
 			"cs46xx: create - never read card ready from AC'97\n"));
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
 			"cs46xx: probably not a bug, try using the CS4232 driver,\n"));
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
 			"cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
 		return -EIO;
 	}
 	/*
 	 *  Assert the vaid frame signal so that we can start sending commands
 	 *  to the AC97 card.
 	 */
 	cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
 	if (card->pm.flags & CS46XX_PM_IDLE) {
 	/*
 	 *  Wait until we've sampled input slots 3 and 4 as valid, meaning that
 	 *  the card is pumping ADC data across the AC-link.
 	 */
 		end_time = jiffies + 3 * (HZ >> 2);
 		do {
 			/*
 			 *  Read the input slot valid register and see if input slots 3 and
 			 *  4 are valid yet.
 			 */
 			if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
 				break;
 			current->state = TASK_UNINTERRUPTIBLE;
 			schedule_timeout(1);
 		} while (time_before(jiffies, end_time));
 	} else {
 		for (count = 0; count < 100; count++) {
 		// First, we want to wait for a short time.
 			udelay(25 * cs_laptop_wait);
 			if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
 				break;
 		}
 	}
 	/*
 	 *  Make sure input slots 3 and 4 are valid.  If not, then return
 	 *  an error.
 	 */
 	if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
 		printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
 		return -EIO;
 	}
 	/*
 	 *  Now, assert valid frame and the slot 3 and 4 valid bits.  This will
 	 *  commense the transfer of digital audio data to the AC97 card.
 	 */
 	cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
 	/*
 	 *  Turn off the Processor by turning off the software clock enable flag in
 	 *  the clock control register.
 	 */
 	/* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
 	/* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
 	/*
          *  Reset the processor.
          */
 	cs461x_reset(card);
 	/*
          *  Download the image to the processor.
 	 */
 	cs461x_download_image(card);
 	/*
          *  Stop playback DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_PCTL);
 	card->pctl = tmp & 0xffff0000;
 	cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
 	/*
          *  Stop capture DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_CCTL);
 	card->cctl = tmp & 0x0000ffff;
 	cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
 	/* initialize AC97 codec and register /dev/mixer */
 	if (card->pm.flags & CS46XX_PM_IDLE) {
 		if (cs_ac97_init(card) <= 0) {
 			CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 				"cs46xx: cs_ac97_init() failure\n"));
 			return -EIO;
 		}
 	} else {
 		cs46xx_ac97_resume(card);
 	}
 	cs461x_proc_start(card);
 	/*
 	 *  Enable interrupts on the part.
 	 */
 	cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
 	tmp = cs461x_peek(card, BA1_PFIE);
 	tmp &= ~0x0000f03f;
 	cs461x_poke(card, BA1_PFIE, tmp);	/* playback interrupt enable */
 	tmp = cs461x_peek(card, BA1_CIE);
 	tmp &= ~0x0000003f;
 	tmp |=  0x00000001;
 	cs461x_poke(card, BA1_CIE, tmp);	/* capture interrupt enable */
 	/*
 	 *  If IDLE then Power down the part.  We will power components up
 	 *  when we need them.
 	 */
 	if (card->pm.flags & CS46XX_PM_IDLE) {
 		if (!cs_powerdown) {
 			if ((tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
 					CS_POWER_MIXVON))) {
 				CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 					"cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
 				return -EIO;
 			}
 		} else {
 			if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
 					CS_POWER_MIXVON, CS_FALSE))) {
 				CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 					"cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
 				return -EIO;
 			}
 		}
 	}
 	CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
 		"cs46xx: cs_hardware_init()- 0\n"));
 	return 0;
 }
 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
 /*
  *	Card subid table
  */
 struct cs_card_type
 {
 	u16 vendor;
 	u16 id;
 	char *name;
 	void (*amp)(struct cs_card *, int);
 	void (*amp_init)(struct cs_card *);
 	void (*active)(struct cs_card *, int);
 };
 static struct cs_card_type cards[] = {
 	{
 		.vendor	= 0x1489,
 		.id	= 0x7001,
 		.name	= "Genius Soundmaker 128 value",
 		.amp	= amp_none,
 	},
 	{
 		.vendor	= 0x5053,
 		.id	= 0x3357,
 		.name	= "Voyetra",
 		.amp	= amp_voyetra,
 	},
 	{
 		.vendor	= 0x1071,
 		.id	= 0x6003,
 		.name	= "Mitac MI6020/21",
 		.amp	= amp_voyetra,
 	},
 	{
 		.vendor	= 0x14AF,
 		.id	= 0x0050,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0x0050,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0x0051,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0x0052,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0x0053,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0x0054,
 		.name	= "Hercules Game Theatre XP",
 		.amp	= amp_hercules,
 	},
 	{
 		.vendor	= 0x1681,
 		.id	= 0xa010,
 		.name	= "Hercules Fortissimo II",
 		.amp	= amp_none,
 	},
 	/* Not sure if the 570 needs the clkrun hack */
 	{
 		.vendor	= PCI_VENDOR_ID_IBM,
 		.id	= 0x0132,
 		.name	= "Thinkpad 570",
 		.amp	= amp_none,
 		.active	= clkrun_hack,
 	},
 	{
 		.vendor	= PCI_VENDOR_ID_IBM,
 		.id	= 0x0153,
 		.name	= "Thinkpad 600X/A20/T20",
 		.amp	= amp_none,
 		.active	= clkrun_hack,
 	},
 	{
 		.vendor	= PCI_VENDOR_ID_IBM,
 		.id	= 0x1010,
 		.name	= "Thinkpad 600E (unsupported)",
 	},
 	{
 		.name	= "Card without SSID set",
 	},
 	{ 0, },
 };
 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
 MODULE_LICENSE("GPL");
 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
 				  const struct pci_device_id *pciid)
 {
 	int i, j;
 	u16 ss_card, ss_vendor;
 	struct cs_card *card;
 	dma_addr_t dma_mask;
 	struct cs_card_type *cp = &cards[0];
 	CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
 		  printk(KERN_INFO "cs46xx: probe()+\n"));
 	dma_mask = 0xffffffff;	/* this enables playback and recording */
 	if (pci_enable_device(pci_dev)) {
 		CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
 			 "cs46xx: pci_enable_device() failed\n"));
 		return -1;
 	}
 	if (!RSRCISMEMORYREGION(pci_dev, 0) ||
 	    !RSRCISMEMORYREGION(pci_dev, 1)) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
 			 "cs46xx: probe()- Memory region not assigned\n"));
 		return -1;
 	}
 	if (pci_dev->irq == 0) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
 			 "cs46xx: probe() IRQ not assigned\n"));
 		return -1;
 	}
 	if (!pci_dma_supported(pci_dev, 0xffffffff)) {
 		CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
 		      "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
 		return -1;
 	}
 	pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
 	pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
 	if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
 		printk(KERN_ERR "cs46xx: out of memory\n");
 		return -ENOMEM;
 	}
 	memset(card, 0, sizeof(*card));
 	card->ba0_addr = RSRCADDRESS(pci_dev, 0);
 	card->ba1_addr = RSRCADDRESS(pci_dev, 1);
 	card->pci_dev = pci_dev;
 	card->irq = pci_dev->irq;
 	card->magic = CS_CARD_MAGIC;
 	spin_lock_init(&card->lock);
 	spin_lock_init(&card->ac97_lock);
 	pci_set_master(pci_dev);
 	printk(cs46xx_banner);
 	printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
 	       card->ba0_addr, card->ba1_addr, card->irq);
 	card->alloc_pcm_channel = cs_alloc_pcm_channel;
 	card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
 	card->free_pcm_channel = cs_free_pcm_channel;
 	card->amplifier_ctrl = amp_none;
 	card->active_ctrl = amp_none;
 	while (cp->name)
 	{
 		if (cp->vendor == ss_vendor && cp->id == ss_card) {
 			card->amplifier_ctrl = cp->amp;
 			if (cp->active)
 				card->active_ctrl = cp->active;
 			if (cp->amp_init)
 				card->amp_init = cp->amp_init;
 			break;
 		}
 		cp++;
 	}
 	if (cp->name == NULL) {
 		printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
 			ss_vendor, ss_card, card->ba0_addr, card->ba1_addr,  card->irq);
 	} else {
 		printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
 			cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
 	}
 	if (card->amplifier_ctrl == NULL) {
 		card->amplifier_ctrl = amp_none;
 		card->active_ctrl = clkrun_hack;
 	}
 	if (external_amp == 1) {
 		printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
 		card->amplifier_ctrl = amp_voyetra;
 	}
 	if (thinkpad == 1) {
 		printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
 		card->active_ctrl = clkrun_hack;
 	}
 /*
 * The thinkpads don't work well without runtime updating on their kernel
 * delay values (or any laptop with variable CPU speeds really).
 * so, just to be safe set the init delay to 2100.  Eliminates
 * failures on T21 Thinkpads.  remove this code when the udelay
 * and mdelay kernel code is replaced by a pm timer, or the delays
 * work well for battery and/or AC power both.
 */
 	if (card->active_ctrl == clkrun_hack) {
 		initdelay = 2100;
 		cs_laptop_wait = 5;
 	}
 	if ((card->active_ctrl == clkrun_hack) && !(powerdown == 1)) {
 /*
 * for some currently unknown reason, powering down the DAC and ADC component
 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
 * codec access problems.  probably the serial clock becomes unsynced.
 * added code to sync the chips back up, but only helped about 70% the time.
 */
 		cs_powerdown = 0;
 	}
 	if (powerdown == 0)
 		cs_powerdown = 0;
 	card->active_ctrl(card, 1);
 	/* claim our iospace and irq */
 	card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
 	card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
 	card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
 	card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
 	card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
 	CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
 		"cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
 	CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
 		"cs46xx: card->ba1=%p %p %p %p\n",
 			card->ba1.name.data0,
 			card->ba1.name.data1,
 			card->ba1.name.pmem,
 			card->ba1.name.reg) );
 	if (card->ba0 == 0 || card->ba1.name.data0 == 0 ||
 		card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
 		card->ba1.name.reg == 0)
 		goto fail2;
 	if (request_irq(card->irq, &cs_interrupt, IRQF_SHARED, "cs46xx", card)) {
 		printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
 		goto fail2;
 	}
 	/* register /dev/dsp */
 	if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
 		printk(KERN_ERR "cs46xx: unable to register dsp\n");
 		goto fail;
 	}
         /* register /dev/midi */
         if ((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
                 printk(KERN_ERR "cs46xx: unable to register midi\n");
 	card->pm.flags |= CS46XX_PM_IDLE;
 	for (i = 0; i < 5; i++) {
 		if (cs_hardware_init(card) != 0) {
 			CS_DBGOUT(CS_ERROR, 4, printk(
 				"cs46xx: ERROR in cs_hardware_init()... retrying\n"));
 			for (j = 0; j < NR_AC97; j++)
 				if (card->ac97_codec[j] != NULL) {
 					unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
 					ac97_release_codec(card->ac97_codec[j]);
 				}
 			mdelay(10 * cs_laptop_wait);
 			continue;
 		}
 		break;
 	}
 	if(i >= 4) {
 		CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
 			"cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
                 unregister_sound_dsp(card->dev_audio);
                 if (card->dev_midi)
                         unregister_sound_midi(card->dev_midi);
                 goto fail;
 	}
         init_waitqueue_head(&card->midi.open_wait);
         mutex_init(&card->midi.open_mutex);
         init_waitqueue_head(&card->midi.iwait);
         init_waitqueue_head(&card->midi.owait);
         cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
         cs461x_pokeBA0(card, BA0_MIDCR, 0);
 	/*
 	* Check if we have to init the amplifier, but probably already done
 	* since the CD logic in the ac97 init code will turn on the ext amp.
 	*/
 	if (cp->amp_init)
 		cp->amp_init(card);
         card->active_ctrl(card, -1);
 	PCI_SET_DRIVER_DATA(pci_dev, card);
 	PCI_SET_DMA_MASK(pci_dev, dma_mask);
 	list_add(&card->list, &cs46xx_devs);
 	CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
 		(unsigned)card->pm.flags,card));
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
 		"cs46xx: probe()- device allocated successfully\n"));
         return 0;
 fail:
 	free_irq(card->irq, card);
 fail2:
 	if (card->ba0)
 		iounmap(card->ba0);
 	if (card->ba1.name.data0)
 		iounmap(card->ba1.name.data0);
 	if (card->ba1.name.data1)
 		iounmap(card->ba1.name.data1);
 	if (card->ba1.name.pmem)
 		iounmap(card->ba1.name.pmem);
 	if (card->ba1.name.reg)
 		iounmap(card->ba1.name.reg);
 	kfree(card);
 	CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
 		"cs46xx: probe()- no device allocated\n"));
 	return -ENODEV;
 } // probe_cs46xx
 // ---------------------------------------------------------------------
 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
 {
 	struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
 	int i;
 	unsigned int tmp;
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
 		 "cs46xx: cs46xx_remove()+\n"));
 	card->active_ctrl(card,1);
 	tmp = cs461x_peek(card, BA1_PFIE);
 	tmp &= ~0x0000f03f;
 	tmp |=  0x00000010;
 	cs461x_poke(card, BA1_PFIE, tmp);	/* playback interrupt disable */
 	tmp = cs461x_peek(card, BA1_CIE);
 	tmp &= ~0x0000003f;
 	tmp |=  0x00000011;
 	cs461x_poke(card, BA1_CIE, tmp);	/* capture interrupt disable */
 	/*
          *  Stop playback DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_PCTL);
 	cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
 	/*
          *  Stop capture DMA.
 	 */
 	tmp = cs461x_peek(card, BA1_CCTL);
 	cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
 	/*
          *  Reset the processor.
          */
 	cs461x_reset(card);
 	cs461x_proc_stop(card);
 	/*
 	 *  Power down the DAC and ADC.  We will power them up (if) when we need
 	 *  them.
 	 */
 	if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
 			CS_POWER_MIXVON, CS_TRUE))) {
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
 			"cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
 	}
 	/*
 	 *  Power down the PLL.
 	 */
 	cs461x_pokeBA0(card, BA0_CLKCR1, 0);
 	/*
 	 *  Turn off the Processor by turning off the software clock enable flag in
 	 *  the clock control register.
 	 */
 	tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
 	cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
 	card->active_ctrl(card,-1);
 	/* free hardware resources */
 	free_irq(card->irq, card);
 	iounmap(card->ba0);
 	iounmap(card->ba1.name.data0);
 	iounmap(card->ba1.name.data1);
 	iounmap(card->ba1.name.pmem);
 	iounmap(card->ba1.name.reg);
 	/* unregister audio devices */
 	for (i = 0; i < NR_AC97; i++)
 		if (card->ac97_codec[i] != NULL) {
 			unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
 			ac97_release_codec(card->ac97_codec[i]);
 		}
 	unregister_sound_dsp(card->dev_audio);
         if (card->dev_midi)
                 unregister_sound_midi(card->dev_midi);
 	list_del(&card->list);
 	kfree(card);
 	PCI_SET_DRIVER_DATA(pci_dev,NULL);
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
 		 "cs46xx: cs46xx_remove()-: remove successful\n"));
 }
 enum {
 	CS46XX_4610 = 0,
 	CS46XX_4612,  	/* same as 4630 */
 	CS46XX_4615,  	/* same as 4624 */
 };
 static struct pci_device_id cs46xx_pci_tbl[] = {
 	{
 		.vendor	     = PCI_VENDOR_ID_CIRRUS,
 		.device	     = PCI_DEVICE_ID_CIRRUS_4610,
 		.subvendor   = PCI_ANY_ID,
 		.subdevice   = PCI_ANY_ID,
 		.driver_data = CS46XX_4610,
 	},
 	{
 		.vendor	     = PCI_VENDOR_ID_CIRRUS,
 		.device	     = PCI_DEVICE_ID_CIRRUS_4612,
 		.subvendor   = PCI_ANY_ID,
 		.subdevice   = PCI_ANY_ID,
 		.driver_data = CS46XX_4612,
 	},
 	{
 		.vendor	     = PCI_VENDOR_ID_CIRRUS,
 		.device	     = PCI_DEVICE_ID_CIRRUS_4615,
 		.subvendor   = PCI_ANY_ID,
 		.subdevice   = PCI_ANY_ID,
 		.driver_data = CS46XX_4615,
 	},
 	{ 0, },
 };
 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
 static struct pci_driver cs46xx_pci_driver = {
 	.name	  = "cs46xx",
 	.id_table = cs46xx_pci_tbl,
 	.probe	  = cs46xx_probe,
 	.remove	  = __devexit_p(cs46xx_remove),
 #ifdef CONFIG_PM
 	.suspend  = cs46xx_suspend_tbl,
 	.resume	  = cs46xx_resume_tbl,
 #endif
 };
 static int __init cs46xx_init_module(void)
 {
 	int rtn = 0;
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
 		"cs46xx: cs46xx_init_module()+ \n"));
 	rtn = pci_register_driver(&cs46xx_pci_driver);
 	if (rtn == -ENODEV) {
 		CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
 			"cs46xx: Unable to detect valid cs46xx device\n"));
 	}
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
 		  printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
 	return rtn;
 }
 static void __exit cs46xx_cleanup_module(void)
 {
 	pci_unregister_driver(&cs46xx_pci_driver);
 	CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
 		  printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
 }
 module_init(cs46xx_init_module);
 module_exit(cs46xx_cleanup_module);
 #ifdef CONFIG_PM
 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state)
 {
 	struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
 		printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
 	cs46xx_suspend(s, state);
 	return 0;
 }
 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
 {
 	struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
 	CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
 		printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
 	cs46xx_resume(s);
 	return 0;
 }
 #endif

sound/oss/dmabuf.c

Diff comments View file @ f23f6e0

 /*
  * sound/oss/dmabuf.c
  *
  * The DMA buffer manager for digitized voice applications
  */
 /*
  * Copyright (C) by Hannu Savolainen 1993-1997
  *
  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  * for more info.
  *
  * Thomas Sailer   : moved several static variables into struct audio_operations
  *                   (which is grossly misnamed btw.) because they have the same
  *                   lifetime as the rest in there and dynamic allocation saves
  *                   12k or so
  * Thomas Sailer   : remove {in,out}_sleep_flag. It was used for the sleeper to
  *                   determine if it was woken up by the expiring timeout or by
  *                   an explicit wake_up. The return value from schedule_timeout
  *		     can be used instead; if 0, the wakeup was due to the timeout.
  *
  * Rob Riggs		Added persistent DMA buffers (1998/10/17)
  */
 #define BE_CONSERVATIVE
 #define SAMPLE_ROUNDUP 0
+#include <linux/mm.h>
 #include "sound_config.h"
 #define DMAP_FREE_ON_CLOSE      0
 #define DMAP_KEEP_ON_CLOSE      1
 extern int sound_dmap_flag;
 static void dma_reset_output(int dev);
 static void dma_reset_input(int dev);
 static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode);
 static int debugmem;    	/* switched off by default */
 static int dma_buffsize = DSP_BUFFSIZE;
 static long dmabuf_timeout(struct dma_buffparms *dmap)
 {
 	long tmout;
 	tmout = (dmap->fragment_size * HZ) / dmap->data_rate;
 	tmout += HZ / 5;	/* Some safety distance */
 	if (tmout < (HZ / 2))
 		tmout = HZ / 2;
 	if (tmout > 20 * HZ)
 		tmout = 20 * HZ;
 	return tmout;
 }
 static int sound_alloc_dmap(struct dma_buffparms *dmap)
 {
 	char *start_addr, *end_addr;
 	int dma_pagesize;
 	int sz, size;
 	struct page *page;
 	dmap->mapping_flags &= ~DMA_MAP_MAPPED;
 	if (dmap->raw_buf != NULL)
 		return 0;	/* Already done */
 	if (dma_buffsize < 4096)
 		dma_buffsize = 4096;
 	dma_pagesize = (dmap->dma < 4) ? (64 * 1024) : (128 * 1024);
 	/*
 	 *	Now check for the Cyrix problem.
 	 */
 	if(isa_dma_bridge_buggy==2)
 		dma_pagesize=32768;
 	dmap->raw_buf = NULL;
 	dmap->buffsize = dma_buffsize;
 	if (dmap->buffsize > dma_pagesize)
 		dmap->buffsize = dma_pagesize;
 	start_addr = NULL;
 	/*
 	 * Now loop until we get a free buffer. Try to get smaller buffer if
 	 * it fails. Don't accept smaller than 8k buffer for performance
 	 * reasons.
 	 */
 	while (start_addr == NULL && dmap->buffsize > PAGE_SIZE) {
 		for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
 		dmap->buffsize = PAGE_SIZE * (1 << sz);
 		start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA|__GFP_NOWARN, sz);
 		if (start_addr == NULL)
 			dmap->buffsize /= 2;
 	}
 	if (start_addr == NULL) {
 		printk(KERN_WARNING "Sound error: Couldn't allocate DMA buffer\n");
 		return -ENOMEM;
 	} else {
 		/* make some checks */
 		end_addr = start_addr + dmap->buffsize - 1;
 		if (debugmem)
 			printk(KERN_DEBUG "sound: start 0x%lx, end 0x%lx\n", (long) start_addr, (long) end_addr);
 		/* now check if it fits into the same dma-pagesize */
 		if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
 		    || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
 			printk(KERN_ERR "sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, dmap->buffsize);
 			return -EFAULT;
 		}
 	}
 	dmap->raw_buf = start_addr;
 	dmap->raw_buf_phys = virt_to_bus(start_addr);
 	for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 		SetPageReserved(page);
 	return 0;
 }
 static void sound_free_dmap(struct dma_buffparms *dmap)
 {
 	int sz, size;
 	struct page *page;
 	unsigned long start_addr, end_addr;
 	if (dmap->raw_buf == NULL)
 		return;
 	if (dmap->mapping_flags & DMA_MAP_MAPPED)
 		return;		/* Don't free mmapped buffer. Will use it next time */
 	for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
 	start_addr = (unsigned long) dmap->raw_buf;
 	end_addr = start_addr + dmap->buffsize;
 	for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 		ClearPageReserved(page);
 	free_pages((unsigned long) dmap->raw_buf, sz);
 	dmap->raw_buf = NULL;
 }
 /* Intel version !!!!!!!!! */
 static int sound_start_dma(struct dma_buffparms *dmap, unsigned long physaddr, int count, int dma_mode)
 {
 	unsigned long flags;
 	int chan = dmap->dma;
 	/* printk( "Start DMA%d %d, %d\n",  chan,  (int)(physaddr-dmap->raw_buf_phys),  count); */
 	flags = claim_dma_lock();
 	disable_dma(chan);
 	clear_dma_ff(chan);
 	set_dma_mode(chan, dma_mode);
 	set_dma_addr(chan, physaddr);
 	set_dma_count(chan, count);
 	enable_dma(chan);
 	release_dma_lock(flags);
 	return 0;
 }
 static void dma_init_buffers(struct dma_buffparms *dmap)
 {
 	dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 	dmap->byte_counter = 0;
 	dmap->max_byte_counter = 8000 * 60 * 60;
 	dmap->bytes_in_use = dmap->buffsize;
 	dmap->dma_mode = DMODE_NONE;
 	dmap->mapping_flags = 0;
 	dmap->neutral_byte = 0x80;
 	dmap->data_rate = 8000;
 	dmap->cfrag = -1;
 	dmap->closing = 0;
 	dmap->nbufs = 1;
 	dmap->flags = DMA_BUSY;	/* Other flags off */
 }
 static int open_dmap(struct audio_operations *adev, int mode, struct dma_buffparms *dmap)
 {
 	int err;
 	if (dmap->flags & DMA_BUSY)
 		return -EBUSY;
 	if ((err = sound_alloc_dmap(dmap)) < 0)
 		return err;
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_WARNING "Sound: DMA buffers not available\n");
 		return -ENOSPC;	/* Memory allocation failed during boot */
 	}
 	if (dmap->dma >= 0 && sound_open_dma(dmap->dma, adev->name)) {
 		printk(KERN_WARNING "Unable to grab(2) DMA%d for the audio driver\n", dmap->dma);
 		return -EBUSY;
 	}
 	dma_init_buffers(dmap);
 	spin_lock_init(&dmap->lock);
 	dmap->open_mode = mode;
 	dmap->subdivision = dmap->underrun_count = 0;
 	dmap->fragment_size = 0;
 	dmap->max_fragments = 65536;	/* Just a large value */
 	dmap->byte_counter = 0;
 	dmap->max_byte_counter = 8000 * 60 * 60;
 	dmap->applic_profile = APF_NORMAL;
 	dmap->needs_reorg = 1;
 	dmap->audio_callback = NULL;
 	dmap->callback_parm = 0;
 	return 0;
 }
 static void close_dmap(struct audio_operations *adev, struct dma_buffparms *dmap)
 {
 	unsigned long flags;
 	if (dmap->dma >= 0) {
 		sound_close_dma(dmap->dma);
 		flags=claim_dma_lock();
 		disable_dma(dmap->dma);
 		release_dma_lock(flags);
 	}
 	if (dmap->flags & DMA_BUSY)
 		dmap->dma_mode = DMODE_NONE;
 	dmap->flags &= ~DMA_BUSY;
 	if (sound_dmap_flag == DMAP_FREE_ON_CLOSE)
 		sound_free_dmap(dmap);
 }
 static unsigned int default_set_bits(int dev, unsigned int bits)
 {
 	mm_segment_t fs = get_fs();
 	set_fs(get_ds());
 	audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SETFMT, (void __user *)&bits);
 	set_fs(fs);
 	return bits;
 }
 static int default_set_speed(int dev, int speed)
 {
 	mm_segment_t fs = get_fs();
 	set_fs(get_ds());
 	audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SPEED, (void __user *)&speed);
 	set_fs(fs);
 	return speed;
 }
 static short default_set_channels(int dev, short channels)
 {
 	int c = channels;
 	mm_segment_t fs = get_fs();
 	set_fs(get_ds());
 	audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_CHANNELS, (void __user *)&c);
 	set_fs(fs);
 	return c;
 }
 static void check_driver(struct audio_driver *d)
 {
 	if (d->set_speed == NULL)
 		d->set_speed = default_set_speed;
 	if (d->set_bits == NULL)
 		d->set_bits = default_set_bits;
 	if (d->set_channels == NULL)
 		d->set_channels = default_set_channels;
 }
 int DMAbuf_open(int dev, int mode)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	int retval;
 	struct dma_buffparms *dmap_in = NULL;
 	struct dma_buffparms *dmap_out = NULL;
 	if (!adev)
 		  return -ENXIO;
 	if (!(adev->flags & DMA_DUPLEX))
 		adev->dmap_in = adev->dmap_out;
 	check_driver(adev->d);
 	if ((retval = adev->d->open(dev, mode)) < 0)
 		return retval;
 	dmap_out = adev->dmap_out;
 	dmap_in = adev->dmap_in;
 	if (dmap_in == dmap_out)
 		adev->flags &= ~DMA_DUPLEX;
 	if (mode & OPEN_WRITE) {
 		if ((retval = open_dmap(adev, mode, dmap_out)) < 0) {
 			adev->d->close(dev);
 			return retval;
 		}
 	}
 	adev->enable_bits = mode;
 	if (mode == OPEN_READ || (mode != OPEN_WRITE && (adev->flags & DMA_DUPLEX))) {
 		if ((retval = open_dmap(adev, mode, dmap_in)) < 0) {
 			adev->d->close(dev);
 			if (mode & OPEN_WRITE)
 				close_dmap(adev, dmap_out);
 			return retval;
 		}
 	}
 	adev->open_mode = mode;
 	adev->go = 1;
 	adev->d->set_bits(dev, 8);
 	adev->d->set_channels(dev, 1);
 	adev->d->set_speed(dev, DSP_DEFAULT_SPEED);
 	if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
 		memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
 		       adev->dmap_out->bytes_in_use);
 	return 0;
 }
 /* MUST not hold the spinlock */
 void DMAbuf_reset(int dev)
 {
 	if (audio_devs[dev]->open_mode & OPEN_WRITE)
 		dma_reset_output(dev);
 	if (audio_devs[dev]->open_mode & OPEN_READ)
 		dma_reset_input(dev);
 }
 static void dma_reset_output(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags,f ;
 	struct dma_buffparms *dmap = adev->dmap_out;
 	if (!(dmap->flags & DMA_STARTED))	/* DMA is not active */
 		return;
 	/*
 	 *	First wait until the current fragment has been played completely
 	 */
 	spin_lock_irqsave(&dmap->lock,flags);
 	adev->dmap_out->flags |= DMA_SYNCING;
 	adev->dmap_out->underrun_count = 0;
 	if (!signal_pending(current) && adev->dmap_out->qlen &&
 	    adev->dmap_out->underrun_count == 0){
 		spin_unlock_irqrestore(&dmap->lock,flags);
 		interruptible_sleep_on_timeout(&adev->out_sleeper,
 					       dmabuf_timeout(dmap));
 		spin_lock_irqsave(&dmap->lock,flags);
 	}
 	adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
 	/*
 	 *	Finally shut the device off
 	 */
 	if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_output)
 		adev->d->halt_io(dev);
 	else
 		adev->d->halt_output(dev);
 	adev->dmap_out->flags &= ~DMA_STARTED;
 	f=claim_dma_lock();
 	clear_dma_ff(dmap->dma);
 	disable_dma(dmap->dma);
 	release_dma_lock(f);
 	dmap->byte_counter = 0;
 	reorganize_buffers(dev, adev->dmap_out, 0);
 	dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 	spin_unlock_irqrestore(&dmap->lock,flags);
 }
 static void dma_reset_input(int dev)
 {
         struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags;
 	struct dma_buffparms *dmap = adev->dmap_in;
 	spin_lock_irqsave(&dmap->lock,flags);
 	if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_input)
 		adev->d->halt_io(dev);
 	else
 		adev->d->halt_input(dev);
 	adev->dmap_in->flags &= ~DMA_STARTED;
 	dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 	dmap->byte_counter = 0;
 	reorganize_buffers(dev, adev->dmap_in, 1);
 	spin_unlock_irqrestore(&dmap->lock,flags);
 }
 /* MUST be called with holding the dmap->lock */
 void DMAbuf_launch_output(int dev, struct dma_buffparms *dmap)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	if (!((adev->enable_bits * adev->go) & PCM_ENABLE_OUTPUT))
 		return;		/* Don't start DMA yet */
 	dmap->dma_mode = DMODE_OUTPUT;
 	if (!(dmap->flags & DMA_ACTIVE) || !(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
 		if (!(dmap->flags & DMA_STARTED)) {
 			reorganize_buffers(dev, dmap, 0);
 			if (adev->d->prepare_for_output(dev, dmap->fragment_size, dmap->nbufs))
 				return;
 			if (!(dmap->flags & DMA_NODMA))
 				local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_WRITE);
 			dmap->flags |= DMA_STARTED;
 		}
 		if (dmap->counts[dmap->qhead] == 0)
 			dmap->counts[dmap->qhead] = dmap->fragment_size;
 		dmap->dma_mode = DMODE_OUTPUT;
 		adev->d->output_block(dev, dmap->raw_buf_phys + dmap->qhead * dmap->fragment_size,
 				      dmap->counts[dmap->qhead], 1);
 		if (adev->d->trigger)
 			adev->d->trigger(dev,adev->enable_bits * adev->go);
 	}
 	dmap->flags |= DMA_ACTIVE;
 }
 int DMAbuf_sync(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags;
 	int n = 0;
 	struct dma_buffparms *dmap;
 	if (!adev->go && !(adev->enable_bits & PCM_ENABLE_OUTPUT))
 		return 0;
 	if (adev->dmap_out->dma_mode == DMODE_OUTPUT) {
 		dmap = adev->dmap_out;
 		spin_lock_irqsave(&dmap->lock,flags);
 		if (dmap->qlen > 0 && !(dmap->flags & DMA_ACTIVE))
 			DMAbuf_launch_output(dev, dmap);
 		adev->dmap_out->flags |= DMA_SYNCING;
 		adev->dmap_out->underrun_count = 0;
 		while (!signal_pending(current) && n++ <= adev->dmap_out->nbufs &&
 		       adev->dmap_out->qlen && adev->dmap_out->underrun_count == 0) {
 			long t = dmabuf_timeout(dmap);
 			spin_unlock_irqrestore(&dmap->lock,flags);
 			/* FIXME: not safe may miss events */
 			t = interruptible_sleep_on_timeout(&adev->out_sleeper, t);
 			spin_lock_irqsave(&dmap->lock,flags);
 			if (!t) {
 				adev->dmap_out->flags &= ~DMA_SYNCING;
 				spin_unlock_irqrestore(&dmap->lock,flags);
 				return adev->dmap_out->qlen;
 			}
 		}
 		adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
 		/*
 		 * Some devices such as GUS have huge amount of on board RAM for the
 		 * audio data. We have to wait until the device has finished playing.
 		 */
 		/* still holding the lock */
 		if (adev->d->local_qlen) {   /* Device has hidden buffers */
 			while (!signal_pending(current) &&
 			       adev->d->local_qlen(dev)){
 				spin_unlock_irqrestore(&dmap->lock,flags);
 				interruptible_sleep_on_timeout(&adev->out_sleeper,
 							       dmabuf_timeout(dmap));
 				spin_lock_irqsave(&dmap->lock,flags);
 			}
 		}
 		spin_unlock_irqrestore(&dmap->lock,flags);
 	}
 	adev->dmap_out->dma_mode = DMODE_NONE;
 	return adev->dmap_out->qlen;
 }
 int DMAbuf_release(int dev, int mode)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap;
 	unsigned long flags;
 	dmap = adev->dmap_out;
 	if (adev->open_mode & OPEN_WRITE)
 		adev->dmap_out->closing = 1;
 	if (adev->open_mode & OPEN_READ){
 		adev->dmap_in->closing = 1;
 		dmap = adev->dmap_in;
 	}
 	if (adev->open_mode & OPEN_WRITE)
 		if (!(adev->dmap_out->mapping_flags & DMA_MAP_MAPPED))
 			if (!signal_pending(current) && (adev->dmap_out->dma_mode == DMODE_OUTPUT))
 				DMAbuf_sync(dev);
 	if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
 		memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte, adev->dmap_out->bytes_in_use);
 	DMAbuf_reset(dev);
 	spin_lock_irqsave(&dmap->lock,flags);
 	adev->d->close(dev);
 	if (adev->open_mode & OPEN_WRITE)
 		close_dmap(adev, adev->dmap_out);
 	if (adev->open_mode == OPEN_READ ||
 	    (adev->open_mode != OPEN_WRITE &&
 	     (adev->flags & DMA_DUPLEX)))
 		close_dmap(adev, adev->dmap_in);
 	adev->open_mode = 0;
 	spin_unlock_irqrestore(&dmap->lock,flags);
 	return 0;
 }
 /* called with dmap->lock dold */
 int DMAbuf_activate_recording(int dev, struct dma_buffparms *dmap)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	int  err;
 	if (!(adev->open_mode & OPEN_READ))
 		return 0;
 	if (!(adev->enable_bits & PCM_ENABLE_INPUT))
 		return 0;
 	if (dmap->dma_mode == DMODE_OUTPUT) {	/* Direction change */
 		/* release lock - it's not recursive */
 		spin_unlock_irq(&dmap->lock);
 		DMAbuf_sync(dev);
 		DMAbuf_reset(dev);
 		spin_lock_irq(&dmap->lock);
 		dmap->dma_mode = DMODE_NONE;
 	}
 	if (!dmap->dma_mode) {
 		reorganize_buffers(dev, dmap, 1);
 		if ((err = adev->d->prepare_for_input(dev,
 				dmap->fragment_size, dmap->nbufs)) < 0)
 			return err;
 		dmap->dma_mode = DMODE_INPUT;
 	}
 	if (!(dmap->flags & DMA_ACTIVE)) {
 		if (dmap->needs_reorg)
 			reorganize_buffers(dev, dmap, 0);
 		local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
 		adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
 				     dmap->fragment_size, 0);
 		dmap->flags |= DMA_ACTIVE;
 		if (adev->d->trigger)
 			adev->d->trigger(dev, adev->enable_bits * adev->go);
 	}
 	return 0;
 }
 /* acquires lock */
 int DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags;
 	int err = 0, n = 0;
 	struct dma_buffparms *dmap = adev->dmap_in;
 	int go;
 	if (!(adev->open_mode & OPEN_READ))
 		return -EIO;
 	spin_lock_irqsave(&dmap->lock,flags);
 	if (dmap->needs_reorg)
 		reorganize_buffers(dev, dmap, 0);
 	if (adev->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
 /*		  printk(KERN_WARNING "Sound: Can't read from mmapped device (1)\n");*/
 		  spin_unlock_irqrestore(&dmap->lock,flags);
 		  return -EINVAL;
 	} else while (dmap->qlen <= 0 && n++ < 10) {
 		long timeout = MAX_SCHEDULE_TIMEOUT;
 		if (!(adev->enable_bits & PCM_ENABLE_INPUT) || !adev->go) {
 			spin_unlock_irqrestore(&dmap->lock,flags);
 			return -EAGAIN;
 		}
 		if ((err = DMAbuf_activate_recording(dev, dmap)) < 0) {
 			spin_unlock_irqrestore(&dmap->lock,flags);
 			return err;
 		}
 		/* Wait for the next block */
 		if (dontblock) {
 			spin_unlock_irqrestore(&dmap->lock,flags);
 			return -EAGAIN;
 		}
 		if ((go = adev->go))
 			timeout = dmabuf_timeout(dmap);
 		spin_unlock_irqrestore(&dmap->lock,flags);
 		timeout = interruptible_sleep_on_timeout(&adev->in_sleeper,
 							 timeout);
 		if (!timeout) {
 			/* FIXME: include device name */
 			err = -EIO;
 			printk(KERN_WARNING "Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
 			dma_reset_input(dev);
 		} else
 			err = -EINTR;
 		spin_lock_irqsave(&dmap->lock,flags);
 	}
 	spin_unlock_irqrestore(&dmap->lock,flags);
 	if (dmap->qlen <= 0)
 		return err ? err : -EINTR;
 	*buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
 	*len = dmap->fragment_size - dmap->counts[dmap->qhead];
 	return dmap->qhead;
 }
 int DMAbuf_rmchars(int dev, int buff_no, int c)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_in;
 	int p = dmap->counts[dmap->qhead] + c;
 	if (dmap->mapping_flags & DMA_MAP_MAPPED)
 	{
 /*		  printk("Sound: Can't read from mmapped device (2)\n");*/
 		return -EINVAL;
 	}
 	else if (dmap->qlen <= 0)
 		return -EIO;
 	else if (p >= dmap->fragment_size) {  /* This buffer is completely empty */
 		dmap->counts[dmap->qhead] = 0;
 		dmap->qlen--;
 		dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 	}
 	else dmap->counts[dmap->qhead] = p;
 	return 0;
 }
 /* MUST be called with dmap->lock hold */
 int DMAbuf_get_buffer_pointer(int dev, struct dma_buffparms *dmap, int direction)
 {
 	/*
 	 *	Try to approximate the active byte position of the DMA pointer within the
 	 *	buffer area as well as possible.
 	 */
 	int pos;
 	unsigned long f;
 	if (!(dmap->flags & DMA_ACTIVE))
 		pos = 0;
 	else {
 		int chan = dmap->dma;
 		f=claim_dma_lock();
 		clear_dma_ff(chan);
 		if(!isa_dma_bridge_buggy)
 			disable_dma(dmap->dma);
 		pos = get_dma_residue(chan);
 		pos = dmap->bytes_in_use - pos;
 		if (!(dmap->mapping_flags & DMA_MAP_MAPPED)) {
 			if (direction == DMODE_OUTPUT) {
 				if (dmap->qhead == 0)
 					if (pos > dmap->fragment_size)
 						pos = 0;
 			} else {
 				if (dmap->qtail == 0)
 					if (pos > dmap->fragment_size)
 						pos = 0;
 			}
 		}
 		if (pos < 0)
 			pos = 0;
 		if (pos >= dmap->bytes_in_use)
 			pos = 0;
 		if(!isa_dma_bridge_buggy)
 			enable_dma(dmap->dma);
 		release_dma_lock(f);
 	}
 	/* printk( "%04x ",  pos); */
 	return pos;
 }
 /*
  *	DMAbuf_start_devices() is called by the /dev/music driver to start
  *	one or more audio devices at desired moment.
  */
 void DMAbuf_start_devices(unsigned int devmask)
 {
 	struct audio_operations *adev;
 	int dev;
 	for (dev = 0; dev < num_audiodevs; dev++) {
 		if (!(devmask & (1 << dev)))
 			continue;
 		if (!(adev = audio_devs[dev]))
 			continue;
 		if (adev->open_mode == 0)
 			continue;
 		if (adev->go)
 			continue;
 		/* OK to start the device */
 		adev->go = 1;
 		if (adev->d->trigger)
 			adev->d->trigger(dev,adev->enable_bits * adev->go);
 	}
 }
 /* via poll called without a lock ?*/
 int DMAbuf_space_in_queue(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	int len, max, tmp;
 	struct dma_buffparms *dmap = adev->dmap_out;
 	int lim = dmap->nbufs;
 	if (lim < 2)
 		lim = 2;
 	if (dmap->qlen >= lim)	/* No space at all */
 		return 0;
 	/*
 	 *	Verify that there are no more pending buffers than the limit
 	 *	defined by the process.
 	 */
 	max = dmap->max_fragments;
 	if (max > lim)
 		max = lim;
 	len = dmap->qlen;
 	if (adev->d->local_qlen) {
 		tmp = adev->d->local_qlen(dev);
 		if (tmp && len)
 			tmp--;	/* This buffer has been counted twice */
 		len += tmp;
 	}
 	if (dmap->byte_counter % dmap->fragment_size)	/* There is a partial fragment */
 		len = len + 1;
 	if (len >= max)
 		return 0;
 	return max - len;
 }
 /* MUST not hold the spinlock  - this function may sleep */
 static int output_sleep(int dev, int dontblock)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	int err = 0;
 	struct dma_buffparms *dmap = adev->dmap_out;
 	long timeout;
 	long timeout_value;
 	if (dontblock)
 		return -EAGAIN;
 	if (!(adev->enable_bits & PCM_ENABLE_OUTPUT))
 		return -EAGAIN;
 	/*
 	 * Wait for free space
 	 */
 	if (signal_pending(current))
 		return -EINTR;
 	timeout = (adev->go && !(dmap->flags & DMA_NOTIMEOUT));
 	if (timeout)
 		timeout_value = dmabuf_timeout(dmap);
 	else
 		timeout_value = MAX_SCHEDULE_TIMEOUT;
 	timeout_value = interruptible_sleep_on_timeout(&adev->out_sleeper,
 						       timeout_value);
 	if (timeout != MAX_SCHEDULE_TIMEOUT && !timeout_value) {
 		printk(KERN_WARNING "Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
 		dma_reset_output(dev);
 	} else {
 		if (signal_pending(current))
 			err = -EINTR;
 	}
 	return err;
 }
 /* called with the lock held */
 static int find_output_space(int dev, char **buf, int *size)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_out;
 	unsigned long active_offs;
 	long len, offs;
 	int maxfrags;
 	int occupied_bytes = (dmap->user_counter % dmap->fragment_size);
 	*buf = dmap->raw_buf;
 	if (!(maxfrags = DMAbuf_space_in_queue(dev)) && !occupied_bytes)
 		return 0;
 #ifdef BE_CONSERVATIVE
 	active_offs = dmap->byte_counter + dmap->qhead * dmap->fragment_size;
 #else
 	active_offs = DMAbuf_get_buffer_pointer(dev, dmap, DMODE_OUTPUT);
 	/* Check for pointer wrapping situation */
 	if (active_offs < 0 || active_offs >= dmap->bytes_in_use)
 		active_offs = 0;
 	active_offs += dmap->byte_counter;
 #endif
 	offs = (dmap->user_counter % dmap->bytes_in_use) & ~SAMPLE_ROUNDUP;
 	if (offs < 0 || offs >= dmap->bytes_in_use) {
 		printk(KERN_ERR "Sound: Got unexpected offs %ld. Giving up.\n", offs);
 		printk("Counter = %ld, bytes=%d\n", dmap->user_counter, dmap->bytes_in_use);
 		return 0;
 	}
 	*buf = dmap->raw_buf + offs;
 	len = active_offs + dmap->bytes_in_use - dmap->user_counter;	/* Number of unused bytes in buffer */
 	if ((offs + len) > dmap->bytes_in_use)
 		len = dmap->bytes_in_use - offs;
 	if (len < 0) {
 		return 0;
 	}
 	if (len > ((maxfrags * dmap->fragment_size) - occupied_bytes))
 		len = (maxfrags * dmap->fragment_size) - occupied_bytes;
 	*size = len & ~SAMPLE_ROUNDUP;
 	return (*size > 0);
 }
 /* acquires lock  */
 int DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags;
 	int err = -EIO;
 	struct dma_buffparms *dmap = adev->dmap_out;
 	if (dmap->mapping_flags & DMA_MAP_MAPPED) {
 /*		printk(KERN_DEBUG "Sound: Can't write to mmapped device (3)\n");*/
 		return -EINVAL;
 	}
 	spin_lock_irqsave(&dmap->lock,flags);
 	if (dmap->needs_reorg)
 		reorganize_buffers(dev, dmap, 0);
 	if (dmap->dma_mode == DMODE_INPUT) {	/* Direction change */
 		spin_unlock_irqrestore(&dmap->lock,flags);
 		DMAbuf_reset(dev);
 		spin_lock_irqsave(&dmap->lock,flags);
 	}
 	dmap->dma_mode = DMODE_OUTPUT;
 	while (find_output_space(dev, buf, size) <= 0) {
 		spin_unlock_irqrestore(&dmap->lock,flags);
 		if ((err = output_sleep(dev, dontblock)) < 0) {
 			return err;
 		}
 		spin_lock_irqsave(&dmap->lock,flags);
 	}
 	spin_unlock_irqrestore(&dmap->lock,flags);
 	return 0;
 }
 /* has to acquire dmap->lock */
 int DMAbuf_move_wrpointer(int dev, int l)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_out;
 	unsigned long ptr;
 	unsigned long end_ptr, p;
 	int post;
 	unsigned long flags;
 	spin_lock_irqsave(&dmap->lock,flags);
 	post= (dmap->flags & DMA_POST);
 	ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
 	dmap->flags &= ~DMA_POST;
 	dmap->cfrag = -1;
 	dmap->user_counter += l;
 	dmap->flags |= DMA_DIRTY;
 	if (dmap->byte_counter >= dmap->max_byte_counter) {
 		/* Wrap the byte counters */
 		long decr = dmap->byte_counter;
 		dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
 		decr -= dmap->byte_counter;
 		dmap->user_counter -= decr;
 	}
 	end_ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
 	p = (dmap->user_counter - 1) % dmap->bytes_in_use;
 	dmap->neutral_byte = dmap->raw_buf[p];
 	/* Update the fragment based bookkeeping too */
 	while (ptr < end_ptr) {
 		dmap->counts[dmap->qtail] = dmap->fragment_size;
 		dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 		dmap->qlen++;
 		ptr += dmap->fragment_size;
 	}
 	dmap->counts[dmap->qtail] = dmap->user_counter - ptr;
 	/*
 	 *	Let the low level driver perform some postprocessing to
 	 *	the written data.
 	 */
 	if (adev->d->postprocess_write)
 		adev->d->postprocess_write(dev);
 	if (!(dmap->flags & DMA_ACTIVE))
 		if (dmap->qlen > 1 || (dmap->qlen > 0 && (post || dmap->qlen >= dmap->nbufs - 1)))
 			DMAbuf_launch_output(dev, dmap);
 	spin_unlock_irqrestore(&dmap->lock,flags);
 	return 0;
 }
 int DMAbuf_start_dma(int dev, unsigned long physaddr, int count, int dma_mode)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_ERR "sound: DMA buffer(1) == NULL\n");
 		printk("Device %d, chn=%s\n", dev, (dmap == adev->dmap_out) ? "out" : "in");
 		return 0;
 	}
 	if (dmap->dma < 0)
 		return 0;
 	sound_start_dma(dmap, physaddr, count, dma_mode);
 	return count;
 }
 EXPORT_SYMBOL(DMAbuf_start_dma);
 static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode)
 {
 	struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_ERR "sound: DMA buffer(2) == NULL\n");
 		printk(KERN_ERR "Device %s, chn=%s\n", adev->name, (dmap == adev->dmap_out) ? "out" : "in");
 		return 0;
 	}
 	if (dmap->flags & DMA_NODMA)
 		return 1;
 	if (dmap->dma < 0)
 		return 0;
 	sound_start_dma(dmap, dmap->raw_buf_phys, dmap->bytes_in_use, dma_mode | DMA_AUTOINIT);
 	dmap->flags |= DMA_STARTED;
 	return count;
 }
 static void finish_output_interrupt(int dev, struct dma_buffparms *dmap)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	if (dmap->audio_callback != NULL)
 		dmap->audio_callback(dev, dmap->callback_parm);
 	wake_up(&adev->out_sleeper);
 	wake_up(&adev->poll_sleeper);
 }
 /* called with dmap->lock held in irq context*/
 static void do_outputintr(int dev, int dummy)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_out;
 	int this_fragment;
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_ERR "Sound: Error. Audio interrupt (%d) after freeing buffers.\n", dev);
 		return;
 	}
 	if (dmap->mapping_flags & DMA_MAP_MAPPED) {	/* Virtual memory mapped access */
 		/* mmapped access */
 		dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 		if (dmap->qhead == 0) {	    /* Wrapped */
 			dmap->byte_counter += dmap->bytes_in_use;
 			if (dmap->byte_counter >= dmap->max_byte_counter) {	/* Overflow */
 				long decr = dmap->byte_counter;
 				dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
 				decr -= dmap->byte_counter;
 				dmap->user_counter -= decr;
 			}
 		}
 		dmap->qlen++;	/* Yes increment it (don't decrement) */
 		if (!(adev->flags & DMA_AUTOMODE))
 			dmap->flags &= ~DMA_ACTIVE;
 		dmap->counts[dmap->qhead] = dmap->fragment_size;
 		DMAbuf_launch_output(dev, dmap);
 		finish_output_interrupt(dev, dmap);
 		return;
 	}
 	dmap->qlen--;
 	this_fragment = dmap->qhead;
 	dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 	if (dmap->qhead == 0) {	/* Wrapped */
 		dmap->byte_counter += dmap->bytes_in_use;
 		if (dmap->byte_counter >= dmap->max_byte_counter) {	/* Overflow */
 			long decr = dmap->byte_counter;
 			dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
 			decr -= dmap->byte_counter;
 			dmap->user_counter -= decr;
 		}
 	}
 	if (!(adev->flags & DMA_AUTOMODE))
 		dmap->flags &= ~DMA_ACTIVE;
 	/*
 	 *	This is  dmap->qlen <= 0 except when closing when
 	 *	dmap->qlen < 0
 	 */
 	while (dmap->qlen <= -dmap->closing) {
 		dmap->underrun_count++;
 		dmap->qlen++;
 		if ((dmap->flags & DMA_DIRTY) && dmap->applic_profile != APF_CPUINTENS) {
 			dmap->flags &= ~DMA_DIRTY;
 			memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
 			       adev->dmap_out->buffsize);
 		}
 		dmap->user_counter += dmap->fragment_size;
 		dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 	}
 	if (dmap->qlen > 0)
 		DMAbuf_launch_output(dev, dmap);
 	finish_output_interrupt(dev, dmap);
 }
 /* called in irq context */
 void DMAbuf_outputintr(int dev, int notify_only)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	unsigned long flags;
 	struct dma_buffparms *dmap = adev->dmap_out;
 	spin_lock_irqsave(&dmap->lock,flags);
 	if (!(dmap->flags & DMA_NODMA)) {
 		int chan = dmap->dma, pos, n;
 		unsigned long f;
 		f=claim_dma_lock();
 		if(!isa_dma_bridge_buggy)
 			disable_dma(dmap->dma);
 		clear_dma_ff(chan);
 		pos = dmap->bytes_in_use - get_dma_residue(chan);
 		if(!isa_dma_bridge_buggy)
 			enable_dma(dmap->dma);
 		release_dma_lock(f);
 		pos = pos / dmap->fragment_size;	/* Actual qhead */
 		if (pos < 0 || pos >= dmap->nbufs)
 			pos = 0;
 		n = 0;
 		while (dmap->qhead != pos && n++ < dmap->nbufs)
 			do_outputintr(dev, notify_only);
 	}
 	else
 		do_outputintr(dev, notify_only);
 	spin_unlock_irqrestore(&dmap->lock,flags);
 }
 EXPORT_SYMBOL(DMAbuf_outputintr);
 /* called with dmap->lock held in irq context */
 static void do_inputintr(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_in;
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_ERR "Sound: Fatal error. Audio interrupt after freeing buffers.\n");
 		return;
 	}
 	if (dmap->mapping_flags & DMA_MAP_MAPPED) {
 		dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 		if (dmap->qtail == 0) {		/* Wrapped */
 			dmap->byte_counter += dmap->bytes_in_use;
 			if (dmap->byte_counter >= dmap->max_byte_counter) {	/* Overflow */
 				long decr = dmap->byte_counter;
 				dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
 				decr -= dmap->byte_counter;
 				dmap->user_counter -= decr;
 			}
 		}
 		dmap->qlen++;
 		if (!(adev->flags & DMA_AUTOMODE)) {
 			if (dmap->needs_reorg)
 				reorganize_buffers(dev, dmap, 0);
 			local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_READ);
 			adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
 					     dmap->fragment_size, 1);
 			if (adev->d->trigger)
 				adev->d->trigger(dev, adev->enable_bits * adev->go);
 		}
 		dmap->flags |= DMA_ACTIVE;
 	} else if (dmap->qlen >= (dmap->nbufs - 1)) {
 		printk(KERN_WARNING "Sound: Recording overrun\n");
 		dmap->underrun_count++;
 		/* Just throw away the oldest fragment but keep the engine running */
 		dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 		dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 	} else if (dmap->qlen >= 0 && dmap->qlen < dmap->nbufs) {
 		dmap->qlen++;
 		dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 		if (dmap->qtail == 0) {		/* Wrapped */
 			dmap->byte_counter += dmap->bytes_in_use;
 			if (dmap->byte_counter >= dmap->max_byte_counter) {	/* Overflow */
 				long decr = dmap->byte_counter;
 				dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
 				decr -= dmap->byte_counter;
 				dmap->user_counter -= decr;
 			}
 		}
 	}
 	if (!(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
 		local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
 		adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size, dmap->fragment_size, 1);
 		if (adev->d->trigger)
 			adev->d->trigger(dev,adev->enable_bits * adev->go);
 	}
 	dmap->flags |= DMA_ACTIVE;
 	if (dmap->qlen > 0)
 	{
 		wake_up(&adev->in_sleeper);
 		wake_up(&adev->poll_sleeper);
 	}
 }
 /* called in irq context */
 void DMAbuf_inputintr(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_in;
 	unsigned long flags;
 	spin_lock_irqsave(&dmap->lock,flags);
 	if (!(dmap->flags & DMA_NODMA)) {
 		int chan = dmap->dma, pos, n;
 		unsigned long f;
 		f=claim_dma_lock();
 		if(!isa_dma_bridge_buggy)
 			disable_dma(dmap->dma);
 		clear_dma_ff(chan);
 		pos = dmap->bytes_in_use - get_dma_residue(chan);
 		if(!isa_dma_bridge_buggy)
 			enable_dma(dmap->dma);
 		release_dma_lock(f);
 		pos = pos / dmap->fragment_size;	/* Actual qhead */
 		if (pos < 0 || pos >= dmap->nbufs)
 			pos = 0;
 		n = 0;
 		while (dmap->qtail != pos && ++n < dmap->nbufs)
 			do_inputintr(dev);
 	} else
 		do_inputintr(dev);
 	spin_unlock_irqrestore(&dmap->lock,flags);
 }
 EXPORT_SYMBOL(DMAbuf_inputintr);
 void DMAbuf_init(int dev, int dma1, int dma2)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	/*
 	 * NOTE! This routine could be called several times.
 	 */
 	if (adev && adev->dmap_out == NULL) {
 		if (adev->d == NULL)
 			panic("OSS: audio_devs[%d]->d == NULL\n", dev);
 		if (adev->parent_dev) {	 /* Use DMA map of the parent dev */
 			int parent = adev->parent_dev - 1;
 			adev->dmap_out = audio_devs[parent]->dmap_out;
 			adev->dmap_in = audio_devs[parent]->dmap_in;
 		} else {
 			adev->dmap_out = adev->dmap_in = &adev->dmaps[0];
 			adev->dmap_out->dma = dma1;
 			if (adev->flags & DMA_DUPLEX) {
 				adev->dmap_in = &adev->dmaps[1];
 				adev->dmap_in->dma = dma2;
 			}
 		}
 		/* Persistent DMA buffers allocated here */
 		if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
 			if (adev->dmap_in->raw_buf == NULL)
 				sound_alloc_dmap(adev->dmap_in);
 			if (adev->dmap_out->raw_buf == NULL)
 				sound_alloc_dmap(adev->dmap_out);
 		}
 	}
 }
 /* No kernel lock - DMAbuf_activate_recording protected by global cli/sti */
 static unsigned int poll_input(struct file * file, int dev, poll_table *wait)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_in;
 	if (!(adev->open_mode & OPEN_READ))
 		return 0;
 	if (dmap->mapping_flags & DMA_MAP_MAPPED) {
 		if (dmap->qlen)
 			return POLLIN | POLLRDNORM;
 		return 0;
 	}
 	if (dmap->dma_mode != DMODE_INPUT) {
 		if (dmap->dma_mode == DMODE_NONE &&
 		    adev->enable_bits & PCM_ENABLE_INPUT &&
 		    !dmap->qlen && adev->go) {
 			unsigned long flags;
 			spin_lock_irqsave(&dmap->lock,flags);
 			DMAbuf_activate_recording(dev, dmap);
 			spin_unlock_irqrestore(&dmap->lock,flags);
 		}
 		return 0;
 	}
 	if (!dmap->qlen)
 		return 0;
 	return POLLIN | POLLRDNORM;
 }
 static unsigned int poll_output(struct file * file, int dev, poll_table *wait)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	struct dma_buffparms *dmap = adev->dmap_out;
 	if (!(adev->open_mode & OPEN_WRITE))
 		return 0;
 	if (dmap->mapping_flags & DMA_MAP_MAPPED) {
 		if (dmap->qlen)
 			return POLLOUT | POLLWRNORM;
 		return 0;
 	}
 	if (dmap->dma_mode == DMODE_INPUT)
 		return 0;
 	if (dmap->dma_mode == DMODE_NONE)
 		return POLLOUT | POLLWRNORM;
 	if (!DMAbuf_space_in_queue(dev))
 		return 0;
 	return POLLOUT | POLLWRNORM;
 }
 unsigned int DMAbuf_poll(struct file * file, int dev, poll_table *wait)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	poll_wait(file, &adev->poll_sleeper, wait);
 	return poll_input(file, dev, wait) | poll_output(file, dev, wait);
 }
 void DMAbuf_deinit(int dev)
 {
 	struct audio_operations *adev = audio_devs[dev];
 	/* This routine is called when driver is being unloaded */
 	if (!adev)
 		return;
 	/* Persistent DMA buffers deallocated here */
 	if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
 		sound_free_dmap(adev->dmap_out);
 		if (adev->flags & DMA_DUPLEX)
 			sound_free_dmap(adev->dmap_in);
 	}
 }

sound/oss/emu10k1/audio.c

Diff comments View file @ f23f6e0

 /*
  **********************************************************************
  *     audio.c -- /dev/dsp interface for emu10k1 driver
  *     Copyright 1999, 2000 Creative Labs, Inc.
  *
  **********************************************************************
  *
  *     Date                 Author          Summary of changes
  *     ----                 ------          ------------------
  *     October 20, 1999     Bertrand Lee    base code release
  *     November 2, 1999	    Alan Cox        cleaned up types/leaks
  *
  **********************************************************************
  *
  *     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.
  *
  **********************************************************************
  */
 #include <linux/module.h>
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/bitops.h>
 #include <asm/io.h>
 #include <linux/sched.h>
+#include <linux/mm.h>
 #include <linux/smp_lock.h>
 #include "hwaccess.h"
 #include "cardwo.h"
 #include "cardwi.h"
 #include "recmgr.h"
 #include "irqmgr.h"
 #include "audio.h"
 #include "8010.h"
 static void calculate_ofrag(struct woinst *);
 static void calculate_ifrag(struct wiinst *);
 static void emu10k1_waveout_bh(unsigned long refdata);
 static void emu10k1_wavein_bh(unsigned long refdata);
 /* Audio file operations */
 static ssize_t emu10k1_audio_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	struct wiinst *wiinst = wave_dev->wiinst;
 	ssize_t ret = 0;
 	unsigned long flags;
 	DPD(3, "emu10k1_audio_read(), buffer=%p, count=%d\n", buffer, (u32) count);
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	spin_lock_irqsave(&wiinst->lock, flags);
 	if (wiinst->mmapped) {
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 		return -ENXIO;
 	}
 	if (wiinst->state == WAVE_STATE_CLOSED) {
 		calculate_ifrag(wiinst);
 		while (emu10k1_wavein_open(wave_dev) < 0) {
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 			if (file->f_flags & O_NONBLOCK)
 				return -EAGAIN;
 			interruptible_sleep_on(&wave_dev->card->open_wait);
 			if (signal_pending(current))
 				return -ERESTARTSYS;
 			spin_lock_irqsave(&wiinst->lock, flags);
 		}
 	}
 	spin_unlock_irqrestore(&wiinst->lock, flags);
 	while (count > 0) {
 		u32 bytestocopy;
 		spin_lock_irqsave(&wiinst->lock, flags);
 		if (!(wiinst->state & WAVE_STATE_STARTED)
 		    && (wave_dev->enablebits & PCM_ENABLE_INPUT))
 			emu10k1_wavein_start(wave_dev);
 		emu10k1_wavein_update(wave_dev->card, wiinst);
 		emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 		DPD(3, "bytestocopy --> %d\n", bytestocopy);
 		if ((bytestocopy >= wiinst->buffer.fragment_size)
 		    || (bytestocopy >= count)) {
 			bytestocopy = min_t(u32, bytestocopy, count);
 			emu10k1_wavein_xferdata(wiinst, (u8 __user *)buffer, &bytestocopy);
 			count -= bytestocopy;
 			buffer += bytestocopy;
 			ret += bytestocopy;
 		}
 		if (count > 0) {
 			if ((file->f_flags & O_NONBLOCK)
 			    || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
 				return (ret ? ret : -EAGAIN);
 			interruptible_sleep_on(&wiinst->wait_queue);
 			if (signal_pending(current))
 				return (ret ? ret : -ERESTARTSYS);
 		}
 	}
 	DPD(3, "bytes copied -> %d\n", (u32) ret);
 	return ret;
 }
 static ssize_t emu10k1_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	struct woinst *woinst = wave_dev->woinst;
 	ssize_t ret;
 	unsigned long flags;
 	DPD(3, "emu10k1_audio_write(), buffer=%p, count=%d\n", buffer, (u32) count);
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	spin_lock_irqsave(&woinst->lock, flags);
 	if (woinst->mmapped) {
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		return -ENXIO;
 	}
 	// This is for emu10k1 revs less than 7, we need to go through tram
 	if (woinst->format.passthrough == 1) {
 		int r;
 		woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
 		woinst->buffer.numfrags = PT_BLOCKCOUNT;
 		calculate_ofrag(woinst);
 		r = emu10k1_pt_write(file, buffer, count);
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		return r;
 	}
 	if (woinst->state == WAVE_STATE_CLOSED) {
 		calculate_ofrag(woinst);
 		while (emu10k1_waveout_open(wave_dev) < 0) {
 			spin_unlock_irqrestore(&woinst->lock, flags);
 			if (file->f_flags & O_NONBLOCK)
 				return -EAGAIN;
 			interruptible_sleep_on(&wave_dev->card->open_wait);
 			if (signal_pending(current))
 				return -ERESTARTSYS;
 			spin_lock_irqsave(&woinst->lock, flags);
 		}
 	}
 	spin_unlock_irqrestore(&woinst->lock, flags);
 	ret = 0;
 	if (count % woinst->format.bytespersample)
                 return -EINVAL;
 	count /= woinst->num_voices;
 	while (count > 0) {
 		u32 bytestocopy;
 		spin_lock_irqsave(&woinst->lock, flags);
 		emu10k1_waveout_update(woinst);
 		emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		DPD(3, "bytestocopy --> %d\n", bytestocopy);
 		if ((bytestocopy >= woinst->buffer.fragment_size)
 		    || (bytestocopy >= count)) {
 			bytestocopy = min_t(u32, bytestocopy, count);
 			emu10k1_waveout_xferdata(woinst, (u8 __user *) buffer, &bytestocopy);
 			count -= bytestocopy;
 			buffer += bytestocopy * woinst->num_voices;
 			ret += bytestocopy * woinst->num_voices;
 			spin_lock_irqsave(&woinst->lock, flags);
 			woinst->total_copied += bytestocopy;
 			if (!(woinst->state & WAVE_STATE_STARTED)
 			    && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
 			    && (woinst->total_copied >= woinst->buffer.fragment_size))
 				emu10k1_waveout_start(wave_dev);
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		if (count > 0) {
 			if ((file->f_flags & O_NONBLOCK)
 			    || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
 				return (ret ? ret : -EAGAIN);
 			interruptible_sleep_on(&woinst->wait_queue);
 			if (signal_pending(current))
 				return (ret ? ret : -ERESTARTSYS);
 		}
 	}
 	DPD(3, "bytes copied -> %d\n", (u32) ret);
 	return ret;
 }
 static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	struct woinst *woinst = NULL;
 	struct wiinst *wiinst = NULL;
 	int val = 0;
 	u32 bytestocopy;
 	unsigned long flags;
 	int __user *p = (int __user *)arg;
 	DPF(4, "emu10k1_audio_ioctl()\n");
 	if (file->f_mode & FMODE_WRITE)
 		woinst = wave_dev->woinst;
 	if (file->f_mode & FMODE_READ)
 		wiinst = wave_dev->wiinst;
 	switch (cmd) {
 	case OSS_GETVERSION:
 		DPF(2, "OSS_GETVERSION:\n");
 		return put_user(SOUND_VERSION, p);
 	case SNDCTL_DSP_RESET:
 		DPF(2, "SNDCTL_DSP_RESET:\n");
 		wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
 		if (file->f_mode & FMODE_WRITE) {
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (woinst->state & WAVE_STATE_OPEN) {
 				emu10k1_waveout_close(wave_dev);
 			}
 			woinst->mmapped = 0;
 			woinst->total_copied = 0;
 			woinst->total_played = 0;
 			woinst->blocks = 0;
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		if (file->f_mode & FMODE_READ) {
 			spin_lock_irqsave(&wiinst->lock, flags);
 			if (wiinst->state & WAVE_STATE_OPEN) {
 				emu10k1_wavein_close(wave_dev);
 			}
 			wiinst->mmapped = 0;
 			wiinst->total_recorded = 0;
 			wiinst->blocks = 0;
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 		}
 		break;
 	case SNDCTL_DSP_SYNC:
 		DPF(2, "SNDCTL_DSP_SYNC:\n");
 		if (file->f_mode & FMODE_WRITE) {
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (woinst->state & WAVE_STATE_OPEN) {
 				if (woinst->state & WAVE_STATE_STARTED)
 					while ((woinst->total_played < woinst->total_copied)
 					       && !signal_pending(current)) {
 						spin_unlock_irqrestore(&woinst->lock, flags);
 						interruptible_sleep_on(&woinst->wait_queue);
 						spin_lock_irqsave(&woinst->lock, flags);
 					}
 				emu10k1_waveout_close(wave_dev);
 			}
 			woinst->mmapped = 0;
 			woinst->total_copied = 0;
 			woinst->total_played = 0;
 			woinst->blocks = 0;
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		if (file->f_mode & FMODE_READ) {
 			spin_lock_irqsave(&wiinst->lock, flags);
 			if (wiinst->state & WAVE_STATE_OPEN) {
 				emu10k1_wavein_close(wave_dev);
 			}
 			wiinst->mmapped = 0;
 			wiinst->total_recorded = 0;
 			wiinst->blocks = 0;
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 		}
 		break;
 	case SNDCTL_DSP_SETDUPLEX:
 		DPF(2, "SNDCTL_DSP_SETDUPLEX:\n");
 		break;
 	case SNDCTL_DSP_GETCAPS:
 		DPF(2, "SNDCTL_DSP_GETCAPS:\n");
 		return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
 				DSP_CAP_TRIGGER | DSP_CAP_MMAP |
 				DSP_CAP_COPROC| DSP_CAP_MULTI, p);
 	case SNDCTL_DSP_SPEED:
 		DPF(2, "SNDCTL_DSP_SPEED:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		DPD(2, "val is %d\n", val);
 		if (val > 0) {
 			if (file->f_mode & FMODE_READ) {
 				struct wave_format format;
 				spin_lock_irqsave(&wiinst->lock, flags);
 				format = wiinst->format;
 				format.samplingrate = val;
 				if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&wiinst->lock, flags);
 					return -EINVAL;
 				}
 				val = wiinst->format.samplingrate;
 				spin_unlock_irqrestore(&wiinst->lock, flags);
 				DPD(2, "set recording sampling rate -> %d\n", val);
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				struct wave_format format;
 				spin_lock_irqsave(&woinst->lock, flags);
 				format = woinst->format;
 				format.samplingrate = val;
 				if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&woinst->lock, flags);
 					return -EINVAL;
 				}
 				val = woinst->format.samplingrate;
 				spin_unlock_irqrestore(&woinst->lock, flags);
 				DPD(2, "set playback sampling rate -> %d\n", val);
 			}
 			return put_user(val, p);
 		} else {
 			if (file->f_mode & FMODE_READ)
 				val = wiinst->format.samplingrate;
 			else if (file->f_mode & FMODE_WRITE)
 				val = woinst->format.samplingrate;
 			return put_user(val, p);
 		}
 		break;
 	case SNDCTL_DSP_STEREO:
 		DPF(2, "SNDCTL_DSP_STEREO:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		DPD(2, " val is %d\n", val);
 		if (file->f_mode & FMODE_READ) {
 			struct wave_format format;
 			spin_lock_irqsave(&wiinst->lock, flags);
 			format = wiinst->format;
 			format.channels = val ? 2 : 1;
 			if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 				spin_unlock_irqrestore(&wiinst->lock, flags);
 				return -EINVAL;
 			}
 			val = wiinst->format.channels - 1;
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 			DPD(2, "set recording stereo -> %d\n", val);
 		}
 		if (file->f_mode & FMODE_WRITE) {
 			struct wave_format format;
 			spin_lock_irqsave(&woinst->lock, flags);
 			format = woinst->format;
 			format.channels = val ? 2 : 1;
 			if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 				spin_unlock_irqrestore(&woinst->lock, flags);
 				return -EINVAL;
 			}
 			val = woinst->format.channels - 1;
 			spin_unlock_irqrestore(&woinst->lock, flags);
 			DPD(2, "set playback stereo -> %d\n", val);
 		}
 		return put_user(val, p);
 		break;
 	case SNDCTL_DSP_CHANNELS:
 		DPF(2, "SNDCTL_DSP_CHANNELS:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		DPD(2, " val is %d\n", val);
 		if (val > 0) {
 			if (file->f_mode & FMODE_READ) {
 				struct wave_format format;
 				spin_lock_irqsave(&wiinst->lock, flags);
 				format = wiinst->format;
 				format.channels = val;
 				if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&wiinst->lock, flags);
 					return -EINVAL;
 				}
 				val = wiinst->format.channels;
 				spin_unlock_irqrestore(&wiinst->lock, flags);
 				DPD(2, "set recording number of channels -> %d\n", val);
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				struct wave_format format;
 				spin_lock_irqsave(&woinst->lock, flags);
 				format = woinst->format;
 				format.channels = val;
 				if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&woinst->lock, flags);
 					return -EINVAL;
 				}
 				val = woinst->format.channels;
 				spin_unlock_irqrestore(&woinst->lock, flags);
 				DPD(2, "set playback number of channels -> %d\n", val);
 			}
 			return put_user(val, p);
 		} else {
 			if (file->f_mode & FMODE_READ)
 				val = wiinst->format.channels;
 			else if (file->f_mode & FMODE_WRITE)
 				val = woinst->format.channels;
 			return put_user(val, p);
 		}
 		break;
 	case SNDCTL_DSP_GETFMTS:
 		DPF(2, "SNDCTL_DSP_GETFMTS:\n");
 		if (file->f_mode & FMODE_READ)
 			val = AFMT_S16_LE;
 		else if (file->f_mode & FMODE_WRITE) {
 			val = AFMT_S16_LE | AFMT_U8;
 			if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
 						     wave_dev->card->pt.patch_name,
 						     wave_dev->card->pt.enable_gpr_name) >= 0)
 				val |= AFMT_AC3;
 		}
 		return put_user(val, p);
 	case SNDCTL_DSP_SETFMT:	/* Same as SNDCTL_DSP_SAMPLESIZE */
 		DPF(2, "SNDCTL_DSP_SETFMT:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		DPD(2, " val is %d\n", val);
 		if (val != AFMT_QUERY) {
 			if (file->f_mode & FMODE_READ) {
 				struct wave_format format;
 				spin_lock_irqsave(&wiinst->lock, flags);
 				format = wiinst->format;
 				format.id = val;
 				if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&wiinst->lock, flags);
 					return -EINVAL;
 				}
 				val = wiinst->format.id;
 				spin_unlock_irqrestore(&wiinst->lock, flags);
 				DPD(2, "set recording format -> %d\n", val);
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				struct wave_format format;
 				spin_lock_irqsave(&woinst->lock, flags);
 				format = woinst->format;
 				format.id = val;
 				if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
 					spin_unlock_irqrestore(&woinst->lock, flags);
 					return -EINVAL;
 				}
 				val = woinst->format.id;
 				spin_unlock_irqrestore(&woinst->lock, flags);
 				DPD(2, "set playback format -> %d\n", val);
 			}
 			return put_user(val, p);
 		} else {
 			if (file->f_mode & FMODE_READ)
 				val = wiinst->format.id;
 			else if (file->f_mode & FMODE_WRITE)
 				val = woinst->format.id;
 			return put_user(val, p);
 		}
 		break;
 	case SOUND_PCM_READ_BITS:
 		if (file->f_mode & FMODE_READ)
 			val = wiinst->format.bitsperchannel;
 		else if (file->f_mode & FMODE_WRITE)
 			val = woinst->format.bitsperchannel;
 		return put_user(val, p);
 	case SOUND_PCM_READ_RATE:
 		if (file->f_mode & FMODE_READ)
 			val = wiinst->format.samplingrate;
 		else if (file->f_mode & FMODE_WRITE)
 			val = woinst->format.samplingrate;
 		return put_user(val, p);
 	case SOUND_PCM_READ_CHANNELS:
 		if (file->f_mode & FMODE_READ)
 			val = wiinst->format.channels;
 		else if (file->f_mode & FMODE_WRITE)
 			val = woinst->format.channels;
 		return put_user(val, p);
 	case SOUND_PCM_WRITE_FILTER:
 		DPF(2, "SOUND_PCM_WRITE_FILTER: not implemented\n");
 		break;
 	case SOUND_PCM_READ_FILTER:
 		DPF(2, "SOUND_PCM_READ_FILTER: not implemented\n");
 		break;
 	case SNDCTL_DSP_SETSYNCRO:
 		DPF(2, "SNDCTL_DSP_SETSYNCRO: not implemented\n");
 		break;
 	case SNDCTL_DSP_GETTRIGGER:
 		DPF(2, "SNDCTL_DSP_GETTRIGGER:\n");
 		if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
 			val |= PCM_ENABLE_OUTPUT;
 		if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
 			val |= PCM_ENABLE_INPUT;
 		return put_user(val, p);
 	case SNDCTL_DSP_SETTRIGGER:
 		DPF(2, "SNDCTL_DSP_SETTRIGGER:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_WRITE) {
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (val & PCM_ENABLE_OUTPUT) {
 				wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
 				if (woinst->state & WAVE_STATE_OPEN)
 					emu10k1_waveout_start(wave_dev);
 			} else {
 				wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
 				if (woinst->state & WAVE_STATE_STARTED)
 					emu10k1_waveout_stop(wave_dev);
 			}
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		if (file->f_mode & FMODE_READ) {
 			spin_lock_irqsave(&wiinst->lock, flags);
 			if (val & PCM_ENABLE_INPUT) {
 				wave_dev->enablebits |= PCM_ENABLE_INPUT;
 				if (wiinst->state & WAVE_STATE_OPEN)
 					emu10k1_wavein_start(wave_dev);
 			} else {
 				wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
 				if (wiinst->state & WAVE_STATE_STARTED)
 					emu10k1_wavein_stop(wave_dev);
 			}
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 		}
 		break;
 	case SNDCTL_DSP_GETOSPACE:
 		{
 			audio_buf_info info;
 			DPF(4, "SNDCTL_DSP_GETOSPACE:\n");
 			if (!(file->f_mode & FMODE_WRITE))
 				return -EINVAL;
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (woinst->state & WAVE_STATE_OPEN) {
 				emu10k1_waveout_update(woinst);
 				emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 				info.bytes = bytestocopy;
 			} else {
 				calculate_ofrag(woinst);
 				info.bytes = woinst->buffer.size;
 			}
 			spin_unlock_irqrestore(&woinst->lock, flags);
 			info.bytes *= woinst->num_voices;
 			info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
 			info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
 			info.fragments = info.bytes / info.fragsize;
 			if (copy_to_user(p, &info, sizeof(info)))
 				return -EFAULT;
 		}
 		break;
 	case SNDCTL_DSP_GETISPACE:
 		{
 			audio_buf_info info;
 			DPF(4, "SNDCTL_DSP_GETISPACE:\n");
 			if (!(file->f_mode & FMODE_READ))
 				return -EINVAL;
 			spin_lock_irqsave(&wiinst->lock, flags);
 			if (wiinst->state & WAVE_STATE_OPEN) {
 				emu10k1_wavein_update(wave_dev->card, wiinst);
 				emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 				info.bytes = bytestocopy;
 			} else {
 				calculate_ifrag(wiinst);
 				info.bytes = 0;
 			}
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 			info.fragstotal = wiinst->buffer.numfrags;
 			info.fragments = info.bytes / wiinst->buffer.fragment_size;
 			info.fragsize = wiinst->buffer.fragment_size;
 			if (copy_to_user(p, &info, sizeof(info)))
 				return -EFAULT;
 		}
 		break;
 	case SNDCTL_DSP_NONBLOCK:
 		DPF(2, "SNDCTL_DSP_NONBLOCK:\n");
 		file->f_flags |= O_NONBLOCK;
 		break;
 	case SNDCTL_DSP_GETODELAY:
 		DPF(4, "SNDCTL_DSP_GETODELAY:\n");
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		spin_lock_irqsave(&woinst->lock, flags);
 		if (woinst->state & WAVE_STATE_OPEN) {
 			emu10k1_waveout_update(woinst);
 			emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 			val = woinst->buffer.size - bytestocopy;
 		} else
 			val = 0;
 		val *= woinst->num_voices;
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		return put_user(val, p);
 	case SNDCTL_DSP_GETIPTR:
 		{
 			count_info cinfo;
 			DPF(4, "SNDCTL_DSP_GETIPTR: \n");
 			if (!(file->f_mode & FMODE_READ))
 				return -EINVAL;
 			spin_lock_irqsave(&wiinst->lock, flags);
 			if (wiinst->state & WAVE_STATE_OPEN) {
 				emu10k1_wavein_update(wave_dev->card, wiinst);
 				cinfo.ptr = wiinst->buffer.hw_pos;
 				cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
 				cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
 				wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
 			} else {
 				cinfo.ptr = 0;
 				cinfo.bytes = 0;
 				cinfo.blocks = 0;
 			}
 			if (wiinst->mmapped)
 				wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 			if (copy_to_user(p, &cinfo, sizeof(cinfo)))
 				return -EFAULT;
 		}
 		break;
 	case SNDCTL_DSP_GETOPTR:
 		{
 			count_info cinfo;
 			DPF(4, "SNDCTL_DSP_GETOPTR:\n");
 			if (!(file->f_mode & FMODE_WRITE))
 				return -EINVAL;
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (woinst->state & WAVE_STATE_OPEN ||
 			    ((woinst->format.passthrough == 1) && wave_dev->card->pt.state)) {
 				int num_fragments;
 				if (woinst->format.passthrough == 1) {
 					emu10k1_pt_waveout_update(wave_dev);
 					cinfo.bytes = woinst->total_played;
 				} else {
 					emu10k1_waveout_update(woinst);
 					cinfo.bytes = woinst->total_played;
 				}
 				cinfo.ptr = woinst->buffer.hw_pos;
 				num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
 				cinfo.blocks = num_fragments - woinst->blocks;
 				woinst->blocks = num_fragments;
 				cinfo.bytes *= woinst->num_voices;
 				cinfo.ptr *= woinst->num_voices;
 			} else {
 				cinfo.ptr = 0;
 				cinfo.bytes = 0;
 				cinfo.blocks = 0;
 			}
 			if (woinst->mmapped)
 				woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
 			spin_unlock_irqrestore(&woinst->lock, flags);
 			if (copy_to_user(p, &cinfo, sizeof(cinfo)))
 				return -EFAULT;
 		}
 		break;
 	case SNDCTL_DSP_GETBLKSIZE:
 		DPF(2, "SNDCTL_DSP_GETBLKSIZE:\n");
 		if (file->f_mode & FMODE_WRITE) {
 			spin_lock_irqsave(&woinst->lock, flags);
 			calculate_ofrag(woinst);
 			val = woinst->buffer.fragment_size * woinst->num_voices;
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		if (file->f_mode & FMODE_READ) {
 			spin_lock_irqsave(&wiinst->lock, flags);
 			calculate_ifrag(wiinst);
 			val = wiinst->buffer.fragment_size;
 			spin_unlock_irqrestore(&wiinst->lock, flags);
 		}
 		return put_user(val, p);
 		break;
 	case SNDCTL_DSP_POST:
 		if (file->f_mode & FMODE_WRITE) {
 			spin_lock_irqsave(&woinst->lock, flags);
 			if (!(woinst->state & WAVE_STATE_STARTED)
 			    && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
 			    && (woinst->total_copied > 0))
 				emu10k1_waveout_start(wave_dev);
 			spin_unlock_irqrestore(&woinst->lock, flags);
 		}
 		break;
 	case SNDCTL_DSP_SUBDIVIDE:
 		DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implemented\n");
 		break;
 	case SNDCTL_DSP_SETFRAGMENT:
 		DPF(2, "SNDCTL_DSP_SETFRAGMENT:\n");
 		if (get_user(val, p))
 			return -EFAULT;
 		DPD(2, "val is %#x\n", val);
 		if (val == 0)
 			return -EIO;
 		if (file->f_mode & FMODE_WRITE) {
 			/* digital pass-through fragment count and size are fixed values */
 			if (woinst->state & WAVE_STATE_OPEN || (woinst->format.passthrough == 1))
 				return -EINVAL;	/* too late to change */
 			woinst->buffer.ossfragshift = val & 0xffff;
 			woinst->buffer.numfrags = (val >> 16) & 0xffff;
 		}
 		if (file->f_mode & FMODE_READ) {
 			if (wiinst->state & WAVE_STATE_OPEN)
 				return -EINVAL;	/* too late to change */
 			wiinst->buffer.ossfragshift = val & 0xffff;
 			wiinst->buffer.numfrags = (val >> 16) & 0xffff;
 		}
 		break;
 	case SNDCTL_COPR_LOAD:
 		{
 			copr_buffer *buf;
 			u32 i;
 			DPF(4, "SNDCTL_COPR_LOAD:\n");
 			buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
 			if (!buf)
 				return -ENOMEM;
 			if (copy_from_user(buf, p, sizeof(copr_buffer))) {
 				kfree (buf);
 				return -EFAULT;
 			}
 			if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
 				kfree (buf);
 				return -EINVAL;
 			}
 			if (buf->command == CMD_WRITE) {
 #ifdef DBGEMU
 				if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
 #else
 				if (((buf->offs < 0x100) || (buf->offs + buf->len > (wave_dev->card->is_audigy ? 0xe00 : 0x800)) || (buf->len > 1000)
 				) && !(
 					//any register allowed raw access to users goes here:
 					(buf->offs == DBG ||
 					  buf->offs == A_DBG)
 					&& (buf->len == 1))) {
 #endif
 					kfree(buf);
 					return -EINVAL;
 				}
 			} else {
 				if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
 					kfree(buf);
 					return -EINVAL;
 				}
 			}
 			if (((unsigned)buf->flags) > 0x3f)
 				buf->flags = 0;
 			if (buf->command == CMD_READ) {
 				for (i = 0; i < buf->len; i++)
 					((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, buf->flags);
 				if (copy_to_user(p, buf, sizeof(copr_buffer))) {
 					kfree(buf);
 					return -EFAULT;
 				}
 			} else {
 				for (i = 0; i < buf->len; i++)
 					sblive_writeptr(wave_dev->card, buf->offs + i, buf->flags, ((u32 *) buf->data)[i]);
 			}
 			kfree (buf);
 			break;
 		}
 	default:		/* Default is unrecognized command */
 		DPD(2, "default: %#x\n", cmd);
 		return -EINVAL;
 	}
 	return 0;
 }
 static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int *type)
 {
 	struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
 	struct woinst *woinst = wave_dev->woinst;
 	struct wiinst *wiinst = wave_dev->wiinst;
 	struct page *dmapage;
 	unsigned long pgoff;
 	int rd, wr;
 	DPF(3, "emu10k1_mm_nopage()\n");
 	DPD(3, "addr: %#lx\n", address);
 	if (address > vma->vm_end) {
 		DPF(1, "EXIT, returning NOPAGE_SIGBUS\n");
 		return NOPAGE_SIGBUS; /* Disallow mremap */
 	}
 	pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
 	if (woinst != NULL)
 		wr = woinst->mmapped;
 	else
 		wr = 0;
 	if (wiinst != NULL)
 		rd = wiinst->mmapped;
 	else
 		rd = 0;
 	/* if full-duplex (read+write) and we have two sets of bufs,
 	* then the playback buffers come first, sez soundcard.c */
 	if (wr) {
 		if (pgoff >= woinst->buffer.pages) {
 			pgoff -= woinst->buffer.pages;
 			dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
 		} else
 			dmapage = virt_to_page (woinst->voice[0].mem.addr[pgoff]);
 	} else {
 		dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
 	}
 	get_page (dmapage);
 	DPD(3, "page: %#lx\n", (unsigned long) dmapage);
 	if (type)
 		*type = VM_FAULT_MINOR;
 	return dmapage;
 }
 static struct vm_operations_struct emu10k1_mm_ops = {
 	.nopage         = emu10k1_mm_nopage,
 };
 static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	unsigned long max_pages, n_pages, pgoffset;
 	struct woinst *woinst = NULL;
 	struct wiinst *wiinst = NULL;
 	unsigned long flags;
 	DPF(2, "emu10k1_audio_mmap()\n");
 	max_pages = 0;
 	if (vma->vm_flags & VM_WRITE) {
 		woinst = wave_dev->woinst;
 		spin_lock_irqsave(&woinst->lock, flags);
 		/* No m'mapping possible for multichannel */
 		if (woinst->num_voices > 1) {
 			spin_unlock_irqrestore(&woinst->lock, flags);
                 	return -EINVAL;
 		}
 		if (woinst->state == WAVE_STATE_CLOSED) {
 			calculate_ofrag(woinst);
 			if (emu10k1_waveout_open(wave_dev) < 0) {
 				spin_unlock_irqrestore(&woinst->lock, flags);
 				ERROR();
 				return -EINVAL;
 			}
 		}
 		woinst->mmapped = 1;
 		max_pages += woinst->buffer.pages;
 		spin_unlock_irqrestore(&woinst->lock, flags);
 	}
 	if (vma->vm_flags & VM_READ) {
 		wiinst = wave_dev->wiinst;
 		spin_lock_irqsave(&wiinst->lock, flags);
 		if (wiinst->state == WAVE_STATE_CLOSED) {
 			calculate_ifrag(wiinst);
 			if (emu10k1_wavein_open(wave_dev) < 0) {
 				spin_unlock_irqrestore(&wiinst->lock, flags);
 				ERROR();
 				return -EINVAL;
 			}
 		}
 		wiinst->mmapped = 1;
 		max_pages += wiinst->buffer.pages;
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 	}
 	n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	pgoffset = vma->vm_pgoff;
 	DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ld\n", vma->vm_start, vma->vm_end, pgoffset);
 	DPD(2, "n_pages: %ld, max_pages: %ld\n", n_pages, max_pages);
 	if (pgoffset + n_pages > max_pages)
 		return -EINVAL;
 	vma->vm_flags |= VM_RESERVED;
 	vma->vm_ops = &emu10k1_mm_ops;
 	vma->vm_private_data = wave_dev;
 	return 0;
 }
 static int emu10k1_audio_open(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	struct emu10k1_card *card = NULL;
 	struct list_head *entry;
 	struct emu10k1_wavedevice *wave_dev;
 	DPF(2, "emu10k1_audio_open()\n");
 	/* Check for correct device to open */
 	list_for_each(entry, &emu10k1_devs) {
 		card = list_entry(entry, struct emu10k1_card, list);
 		if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
 			goto match;
 	}
 	return -ENODEV;
 match:
 	wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
 	if (wave_dev == NULL) {
 		ERROR();
 		return -ENOMEM;
 	}
 	wave_dev->card = card;
 	wave_dev->wiinst = NULL;
 	wave_dev->woinst = NULL;
 	wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;	/* Default */
 	if (file->f_mode & FMODE_READ) {
 		/* Recording */
 		struct wiinst *wiinst;
 		if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
 			ERROR();
 			kfree(wave_dev);
 			return -ENOMEM;
 		}
 		wiinst->recsrc = card->wavein.recsrc;
                 wiinst->fxwc = card->wavein.fxwc;
 		switch (wiinst->recsrc) {
 		case WAVERECORD_AC97:
 			wiinst->format.id = AFMT_S16_LE;
 			wiinst->format.samplingrate = 8000;
 			wiinst->format.bitsperchannel = 16;
 			wiinst->format.channels = 1;
 			break;
 		case WAVERECORD_MIC:
 			wiinst->format.id = AFMT_S16_LE;
 			wiinst->format.samplingrate = 8000;
 			wiinst->format.bitsperchannel = 16;
 			wiinst->format.channels = 1;
 			break;
 		case WAVERECORD_FX:
 			wiinst->format.id = AFMT_S16_LE;
 			wiinst->format.samplingrate = 48000;
 			wiinst->format.bitsperchannel = 16;
 			wiinst->format.channels = hweight32(wiinst->fxwc);
 			break;
 		default:
 			kfree(wave_dev);
 			kfree(wiinst);
 			BUG();
 			break;
 		}
 		wiinst->state = WAVE_STATE_CLOSED;
 		wiinst->buffer.ossfragshift = 0;
 		wiinst->buffer.fragment_size = 0;
 		wiinst->buffer.numfrags = 0;
 		init_waitqueue_head(&wiinst->wait_queue);
 		wiinst->mmapped = 0;
 		wiinst->total_recorded = 0;
 		wiinst->blocks = 0;
 		spin_lock_init(&wiinst->lock);
 		tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
 		wave_dev->wiinst = wiinst;
 		emu10k1_wavein_setformat(wave_dev, &wiinst->format);
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		struct woinst *woinst;
 		int i;
 		if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
 			ERROR();
 			kfree(wave_dev);
 			return -ENOMEM;
 		}
 		if (wave_dev->wiinst != NULL) {
 			woinst->format = wave_dev->wiinst->format;
 		} else {
 			woinst->format.id = AFMT_U8;
 			woinst->format.samplingrate = 8000;
 			woinst->format.bitsperchannel = 8;
 			woinst->format.channels = 1;
 		}
 		woinst->state = WAVE_STATE_CLOSED;
 		woinst->buffer.fragment_size = 0;
 		woinst->buffer.ossfragshift = 0;
 		woinst->buffer.numfrags = 0;
 		woinst->device = (card->audio_dev1 == minor);
 		woinst->timer.state = TIMER_STATE_UNINSTALLED;
 		woinst->num_voices = 1;
 		for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
 			woinst->voice[i].usage = VOICE_USAGE_FREE;
 			woinst->voice[i].mem.emupageindex = -1;
 		}
 		init_waitqueue_head(&woinst->wait_queue);
 		woinst->mmapped = 0;
 		woinst->total_copied = 0;
 		woinst->total_played = 0;
 		woinst->blocks = 0;
 		spin_lock_init(&woinst->lock);
 		tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
 		wave_dev->woinst = woinst;
 		emu10k1_waveout_setformat(wave_dev, &woinst->format);
 	}
 	file->private_data = (void *) wave_dev;
 	return nonseekable_open(inode, file);
 }
 static int emu10k1_audio_release(struct inode *inode, struct file *file)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	struct emu10k1_card *card;
 	unsigned long flags;
 	card = wave_dev->card;
 	DPF(2, "emu10k1_audio_release()\n");
 	if (file->f_mode & FMODE_WRITE) {
 		struct woinst *woinst = wave_dev->woinst;
 		spin_lock_irqsave(&woinst->lock, flags);
 		if(woinst->format.passthrough==2)
 			card->pt.state=PT_STATE_PLAYING;
 		if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE){
 			spin_lock(&card->pt.lock);
                         emu10k1_pt_stop(card);
 			spin_unlock(&card->pt.lock);
 		}
 		if (woinst->state & WAVE_STATE_OPEN) {
 			if (woinst->state & WAVE_STATE_STARTED) {
 				if (!(file->f_flags & O_NONBLOCK)) {
 					while (!signal_pending(current)
 					       && (woinst->total_played < woinst->total_copied)) {
 						DPF(4, "Buffer hasn't been totally played, sleep....\n");
 						spin_unlock_irqrestore(&woinst->lock, flags);
 						interruptible_sleep_on(&woinst->wait_queue);
 						spin_lock_irqsave(&woinst->lock, flags);
 					}
 				}
 			}
 			emu10k1_waveout_close(wave_dev);
 		}
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		/* remove the tasklet */
 		tasklet_kill(&woinst->timer.tasklet);
 		kfree(wave_dev->woinst);
 	}
 	if (file->f_mode & FMODE_READ) {
 		struct wiinst *wiinst = wave_dev->wiinst;
 		spin_lock_irqsave(&wiinst->lock, flags);
 		if (wiinst->state & WAVE_STATE_OPEN) {
 			emu10k1_wavein_close(wave_dev);
 		}
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 		tasklet_kill(&wiinst->timer.tasklet);
 		kfree(wave_dev->wiinst);
 	}
 	kfree(wave_dev);
 	if (waitqueue_active(&card->open_wait))
 		wake_up_interruptible(&card->open_wait);
 	return 0;
 }
 /* FIXME sort out poll() + mmap() */
 static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
 	struct woinst *woinst = wave_dev->woinst;
 	struct wiinst *wiinst = wave_dev->wiinst;
 	unsigned int mask = 0;
 	u32 bytestocopy;
 	unsigned long flags;
 	DPF(4, "emu10k1_audio_poll()\n");
 	if (file->f_mode & FMODE_WRITE)
 		poll_wait(file, &woinst->wait_queue, wait);
 	if (file->f_mode & FMODE_READ)
 		poll_wait(file, &wiinst->wait_queue, wait);
 	if (file->f_mode & FMODE_WRITE) {
 		spin_lock_irqsave(&woinst->lock, flags);
 		if (woinst->state & WAVE_STATE_OPEN) {
 			emu10k1_waveout_update(woinst);
 			emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 			if (bytestocopy >= woinst->buffer.fragment_size)
 				mask |= POLLOUT | POLLWRNORM;
 		} else
 			mask |= POLLOUT | POLLWRNORM;
 		spin_unlock_irqrestore(&woinst->lock, flags);
 	}
 	if (file->f_mode & FMODE_READ) {
 		spin_lock_irqsave(&wiinst->lock, flags);
 		if (wiinst->state & WAVE_STATE_OPEN) {
 			emu10k1_wavein_update(wave_dev->card, wiinst);
 			emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 			if (bytestocopy >= wiinst->buffer.fragment_size)
 				mask |= POLLIN | POLLRDNORM;
 		}
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 	}
 	return mask;
 }
 static void calculate_ofrag(struct woinst *woinst)
 {
 	struct waveout_buffer *buffer = &woinst->buffer;
 	u32 fragsize;
 	if (buffer->fragment_size)
 		return;
 	if (!buffer->ossfragshift) {
 		fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
 		while (fragsize) {
 			fragsize >>= 1;
 			buffer->ossfragshift++;
 		}
 	}
 	if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
 		buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
 	buffer->fragment_size = 1 << buffer->ossfragshift;
 	while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)
 		buffer->fragment_size >>= 1;
 	/* now we are sure that:
 	 (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)
 	*/
 	if (!buffer->numfrags) {
 		u32 numfrags;
 		numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
 			   (buffer->fragment_size * 1000) - 1;
 		buffer->numfrags = 1;
 		while (numfrags) {
 			numfrags >>= 1;
 			buffer->numfrags <<= 1;
 		}
 	}
 	if (buffer->numfrags < WAVEOUT_MINFRAGS)
 		buffer->numfrags = WAVEOUT_MINFRAGS;
 	if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)
 		buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
 	if (buffer->numfrags < WAVEOUT_MINFRAGS)
 		BUG();
 	buffer->size = buffer->fragment_size * buffer->numfrags;
 	buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
 	DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);
 	DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);
 	return;
 }
 static void calculate_ifrag(struct wiinst *wiinst)
 {
 	struct wavein_buffer *buffer = &wiinst->buffer;
 	u32 fragsize, bufsize, size[4];
 	int i, j;
 	if (buffer->fragment_size)
 		return;
 	if (!buffer->ossfragshift) {
 		fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
 		while (fragsize) {
 			fragsize >>= 1;
 			buffer->ossfragshift++;
 		}
 	}
 	if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
 		buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
 	buffer->fragment_size = 1 << buffer->ossfragshift;
 	while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)
 		buffer->fragment_size >>= 1;
 	/* now we are sure that:
 	   (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)
         */
 	if (!buffer->numfrags)
 		buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
 	if (buffer->numfrags < WAVEIN_MINFRAGS)
 		buffer->numfrags = WAVEIN_MINFRAGS;
 	if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)
 		buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
 	if (buffer->numfrags < WAVEIN_MINFRAGS)
 		BUG();
 	bufsize = buffer->fragment_size * buffer->numfrags;
 	/* the buffer size for recording is restricted to certain values, adjust it now */
 	if (bufsize >= 0x10000) {
 		buffer->size = 0x10000;
 		buffer->sizeregval = 0x1f;
 	} else {
 		buffer->size = 0;
 		size[0] = 384;
 		size[1] = 448;
 		size[2] = 512;
 		size[3] = 640;
 		for (i = 0; i < 8; i++)
 			for (j = 0; j < 4; j++)
 				if (bufsize >= size[j]) {
 					buffer->size = size[j];
 					size[j] *= 2;
 					buffer->sizeregval = i * 4 + j + 1;
 				} else
 					goto exitloop;
 	      exitloop:
 		if (buffer->size == 0) {
 			buffer->size = 384;
 			buffer->sizeregval = 0x01;
 		}
 	}
 	/* adjust the fragment size so that buffer size is an integer multiple */
 	while (buffer->size % buffer->fragment_size)
 		buffer->fragment_size >>= 1;
 	buffer->numfrags = buffer->size / buffer->fragment_size;
 	buffer->pages =  buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
 	DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);
 	DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);
 	DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);
 	return;
 }
 static void emu10k1_wavein_bh(unsigned long refdata)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
 	struct wiinst *wiinst = wave_dev->wiinst;
 	u32 bytestocopy;
 	unsigned long flags;
 	if (!wiinst)
 		return;
 	spin_lock_irqsave(&wiinst->lock, flags);
 	if (!(wiinst->state & WAVE_STATE_STARTED)) {
 		spin_unlock_irqrestore(&wiinst->lock, flags);
 		return;
 	}
 	emu10k1_wavein_update(wave_dev->card, wiinst);
 	emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
 	spin_unlock_irqrestore(&wiinst->lock, flags);
 	if (bytestocopy >= wiinst->buffer.fragment_size) {
 	 	if (waitqueue_active(&wiinst->wait_queue))
 			wake_up_interruptible(&wiinst->wait_queue);
 	} else
 		DPD(3, "Not enough transfer size, %d\n", bytestocopy);
 	return;
 }
 static void emu10k1_waveout_bh(unsigned long refdata)
 {
 	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
 	struct woinst *woinst = wave_dev->woinst;
 	u32 bytestocopy;
 	unsigned long flags;
 	if (!woinst)
 		return;
 	spin_lock_irqsave(&woinst->lock, flags);
 	if (!(woinst->state & WAVE_STATE_STARTED)) {
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		return;
 	}
 	emu10k1_waveout_update(woinst);
 	emu10k1_waveout_getxfersize(woinst, &bytestocopy);
 	if (woinst->buffer.fill_silence) {
 		spin_unlock_irqrestore(&woinst->lock, flags);
 		emu10k1_waveout_fillsilence(woinst);
 	} else
 		spin_unlock_irqrestore(&woinst->lock, flags);
 	if (bytestocopy >= woinst->buffer.fragment_size) {
 		if (waitqueue_active(&woinst->wait_queue))
 			wake_up_interruptible(&woinst->wait_queue);
 	} else
 		DPD(3, "Not enough transfer size -> %d\n", bytestocopy);
 	return;
 }
 struct file_operations emu10k1_audio_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= emu10k1_audio_read,
 	.write		= emu10k1_audio_write,
 	.poll		= emu10k1_audio_poll,
 	.ioctl		= emu10k1_audio_ioctl,
 	.mmap		= emu10k1_audio_mmap,
 	.open		= emu10k1_audio_open,
 	.release	= emu10k1_audio_release,
 };

sound/oss/es1371.c

Diff comments View file @ f23f6e0

 /*****************************************************************************/
 /*
  *      es1371.c  --  Creative Ensoniq ES1371.
  *
  *      Copyright (C) 1998-2001, 2003  Thomas Sailer (t.sailer@alumni.ethz.ch)
  *
  *      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 Ensoniq
  *
  *  Supported devices:
  *  /dev/dsp    standard /dev/dsp device, (mostly) OSS compatible
  *  /dev/mixer  standard /dev/mixer device, (mostly) OSS compatible
  *  /dev/dsp1   additional DAC, like /dev/dsp, but outputs to mixer "SYNTH" setting
  *  /dev/midi   simple MIDI UART interface, no ioctl
  *
  *  NOTE: the card does not have any FM/Wavetable synthesizer, it is supposed
  *  to be done in software. That is what /dev/dac is for. By now (Q2 1998)
  *  there are several MIDI to PCM (WAV) packages, one of them is timidity.
  *
  *  Revision history
  *    04.06.1998   0.1   Initial release
  *                       Mixer stuff should be overhauled; especially optional AC97 mixer bits
  *                       should be detected. This results in strange behaviour of some mixer
  *                       settings, like master volume and mic.
  *    08.06.1998   0.2   First release using Alan Cox' soundcore instead of miscdevice
  *    03.08.1998   0.3   Do not include modversions.h
  *                       Now mixer behaviour can basically be selected between
  *                       "OSS documented" and "OSS actual" behaviour
  *    31.08.1998   0.4   Fix realplayer problems - dac.count issues
  *    27.10.1998   0.5   Fix joystick support
  *                       -- Oliver Neukum (c188@org.chemie.uni-muenchen.de)
  *    10.12.1998   0.6   Fix drain_dac trying to wait on not yet initialized DMA
  *    23.12.1998   0.7   Fix a few f_file & FMODE_ bugs
  *                       Don't wake up app until there are fragsize bytes to read/write
  *    06.01.1999   0.8   remove the silly SA_INTERRUPT flag.
  *                       hopefully killed the egcs section type conflict
  *    12.03.1999   0.9   cinfo.blocks should be reset after GETxPTR ioctl.
  *                       reported by Johan Maes <joma@telindus.be>
  *    22.03.1999   0.10  return EAGAIN instead of EBUSY when O_NONBLOCK
  *                       read/write cannot be executed
  *    07.04.1999   0.11  implemented the following ioctl's: SOUND_PCM_READ_RATE,
  *                       SOUND_PCM_READ_CHANNELS, SOUND_PCM_READ_BITS;
  *                       Alpha fixes reported by Peter Jones <pjones@redhat.com>
  *                       Another Alpha fix (wait_src_ready in init routine)
  *                       reported by "Ivan N. Kokshaysky" <ink@jurassic.park.msu.ru>
  *                       Note: joystick address handling might still be wrong on archs
  *                       other than i386
  *    15.06.1999   0.12  Fix bad allocation bug.
  *                       Thanks to Deti Fliegl <fliegl@in.tum.de>
  *    28.06.1999   0.13  Add pci_set_master
  *    03.08.1999   0.14  adapt to Linus' new __setup/__initcall
  *                       added kernel command line option "es1371=joystickaddr"
  *                       removed CONFIG_SOUND_ES1371_JOYPORT_BOOT kludge
  *    10.08.1999   0.15  (Re)added S/PDIF module option for cards revision >= 4.
  *                       Initial version by Dave Platt <dplatt@snulbug.mtview.ca.us>.
  *                       module_init/__setup fixes
  *    08.16.1999   0.16  Joe Cotellese <joec@ensoniq.com>
  *                       Added detection for ES1371 revision ID so that we can
  *                       detect the ES1373 and later parts.
  *                       added AC97 #defines for readability
  *                       added a /proc file system for dumping hardware state
  *                       updated SRC and CODEC w/r functions to accommodate bugs
  *                       in some versions of the ES137x chips.
  *    31.08.1999   0.17  add spin_lock_init
  *                       replaced current->state = x with set_current_state(x)
  *    03.09.1999   0.18  change read semantics for MIDI to match
  *                       OSS more closely; remove possible wakeup race
  *    21.10.1999   0.19  Round sampling rates, requested by
  *                       Kasamatsu Kenichi <t29w0267@ip.media.kyoto-u.ac.jp>
  *    27.10.1999   0.20  Added SigmaTel 3D enhancement string
  *                       Codec ID printing changes
  *    28.10.1999   0.21  More waitqueue races fixed
  *                       Joe Cotellese <joec@ensoniq.com>
  *                       Changed PCI detection routine so we can more easily
  *                       detect ES137x chip and derivatives.
  *    05.01.2000   0.22  Should now work with rev7 boards; patch by
  *                       Eric Lemar, elemar@cs.washington.edu
  *    08.01.2000   0.23  Prevent some ioctl's from returning bad count values on underrun/overrun;
  *                       Tim Janik's BSE (Bedevilled Sound Engine) found this
  *    07.02.2000   0.24  Use pci_alloc_consistent and pci_register_driver
  *    07.02.2000   0.25  Use ac97_codec
  *    01.03.2000   0.26  SPDIF patch by Mikael Bouillot <mikael.bouillot@bigfoot.com>
  *                       Use pci_module_init
  *    21.11.2000   0.27  Initialize dma buffers in poll, otherwise poll may return a bogus mask
  *    12.12.2000   0.28  More dma buffer initializations, patch from
  *                       Tjeerd Mulder <tjeerd.mulder@fujitsu-siemens.com>
  *    05.01.2001   0.29  Hopefully updates will not be required anymore when Creative bumps
  *                       the CT5880 revision.
  *                       suggested by Stephan Müller <smueller@chronox.de>
  *    31.01.2001   0.30  Register/Unregister gameport
  *                       Fix SETTRIGGER non OSS API conformity
  *    14.07.2001   0.31  Add list of laptops needing amplifier control
  *    03.01.2003   0.32  open_mode fixes from Georg Acher <acher@in.tum.de>
  */
 /*****************************************************************************/
 #include <linux/interrupt.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/slab.h>
 #include <linux/soundcard.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/bitops.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
 #include <linux/ac97_codec.h>
 #include <linux/gameport.h>
 #include <linux/wait.h>
 #include <linux/dma-mapping.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 #include <asm/io.h>
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 #define SUPPORT_JOYSTICK
 #endif
 /* --------------------------------------------------------------------- */
 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
 #define ES1371_DEBUG
 #define DBG(x) {}
 /*#define DBG(x) {x}*/
 /* --------------------------------------------------------------------- */
 #ifndef PCI_VENDOR_ID_ENSONIQ
 #define PCI_VENDOR_ID_ENSONIQ        0x1274
 #endif
 #ifndef PCI_VENDOR_ID_ECTIVA
 #define PCI_VENDOR_ID_ECTIVA         0x1102
 #endif
 #ifndef PCI_DEVICE_ID_ENSONIQ_ES1371
 #define PCI_DEVICE_ID_ENSONIQ_ES1371 0x1371
 #endif
 #ifndef PCI_DEVICE_ID_ENSONIQ_CT5880
 #define PCI_DEVICE_ID_ENSONIQ_CT5880 0x5880
 #endif
 #ifndef PCI_DEVICE_ID_ECTIVA_EV1938
 #define PCI_DEVICE_ID_ECTIVA_EV1938 0x8938
 #endif
 /* ES1371 chip ID */
 /* This is a little confusing because all ES1371 compatible chips have the
    same DEVICE_ID, the only thing differentiating them is the REV_ID field.
    This is only significant if you want to enable features on the later parts.
    Yes, I know it's stupid and why didn't we use the sub IDs?
 */
 #define ES1371REV_ES1373_A  0x04
 #define ES1371REV_ES1373_B  0x06
 #define ES1371REV_CT5880_A  0x07
 #define CT5880REV_CT5880_C  0x02
 #define CT5880REV_CT5880_D  0x03
 #define ES1371REV_ES1371_B  0x09
 #define EV1938REV_EV1938_A  0x00
 #define ES1371REV_ES1373_8  0x08
 #define ES1371_MAGIC  ((PCI_VENDOR_ID_ENSONIQ<<16)|PCI_DEVICE_ID_ENSONIQ_ES1371)
 #define ES1371_EXTENT             0x40
 #define JOY_EXTENT                8
 #define ES1371_REG_CONTROL        0x00
 #define ES1371_REG_STATUS         0x04 /* on the 5880 it is control/status */
 #define ES1371_REG_UART_DATA      0x08
 #define ES1371_REG_UART_STATUS    0x09
 #define ES1371_REG_UART_CONTROL   0x09
 #define ES1371_REG_UART_TEST      0x0a
 #define ES1371_REG_MEMPAGE        0x0c
 #define ES1371_REG_SRCONV         0x10
 #define ES1371_REG_CODEC          0x14
 #define ES1371_REG_LEGACY         0x18
 #define ES1371_REG_SERIAL_CONTROL 0x20
 #define ES1371_REG_DAC1_SCOUNT    0x24
 #define ES1371_REG_DAC2_SCOUNT    0x28
 #define ES1371_REG_ADC_SCOUNT     0x2c
 #define ES1371_REG_DAC1_FRAMEADR  0xc30
 #define ES1371_REG_DAC1_FRAMECNT  0xc34
 #define ES1371_REG_DAC2_FRAMEADR  0xc38
 #define ES1371_REG_DAC2_FRAMECNT  0xc3c
 #define ES1371_REG_ADC_FRAMEADR   0xd30
 #define ES1371_REG_ADC_FRAMECNT   0xd34
 #define ES1371_FMT_U8_MONO     0
 #define ES1371_FMT_U8_STEREO   1
 #define ES1371_FMT_S16_MONO    2
 #define ES1371_FMT_S16_STEREO  3
 #define ES1371_FMT_STEREO      1
 #define ES1371_FMT_S16         2
 #define ES1371_FMT_MASK        3
 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 #define CTRL_RECEN_B    0x08000000  /* 1 = don't mix analog in to digital out */
 #define CTRL_SPDIFEN_B  0x04000000
 #define CTRL_JOY_SHIFT  24
 #define CTRL_JOY_MASK   3
 #define CTRL_JOY_200    0x00000000  /* joystick base address */
 #define CTRL_JOY_208    0x01000000
 #define CTRL_JOY_210    0x02000000
 #define CTRL_JOY_218    0x03000000
 #define CTRL_GPIO_IN0   0x00100000  /* general purpose inputs/outputs */
 #define CTRL_GPIO_IN1   0x00200000
 #define CTRL_GPIO_IN2   0x00400000
 #define CTRL_GPIO_IN3   0x00800000
 #define CTRL_GPIO_OUT0  0x00010000
 #define CTRL_GPIO_OUT1  0x00020000
 #define CTRL_GPIO_OUT2  0x00040000
 #define CTRL_GPIO_OUT3  0x00080000
 #define CTRL_MSFMTSEL   0x00008000  /* MPEG serial data fmt: 0 = Sony, 1 = I2S */
 #define CTRL_SYNCRES    0x00004000  /* AC97 warm reset */
 #define CTRL_ADCSTOP    0x00002000  /* stop ADC transfers */
 #define CTRL_PWR_INTRM  0x00001000  /* 1 = power level ints enabled */
 #define CTRL_M_CB       0x00000800  /* recording source: 0 = ADC, 1 = MPEG */
 #define CTRL_CCB_INTRM  0x00000400  /* 1 = CCB "voice" ints enabled */
 #define CTRL_PDLEV0     0x00000000  /* power down level */
 #define CTRL_PDLEV1     0x00000100
 #define CTRL_PDLEV2     0x00000200
 #define CTRL_PDLEV3     0x00000300
 #define CTRL_BREQ       0x00000080  /* 1 = test mode (internal mem test) */
 #define CTRL_DAC1_EN    0x00000040  /* enable DAC1 */
 #define CTRL_DAC2_EN    0x00000020  /* enable DAC2 */
 #define CTRL_ADC_EN     0x00000010  /* enable ADC */
 #define CTRL_UART_EN    0x00000008  /* enable MIDI uart */
 #define CTRL_JYSTK_EN   0x00000004  /* enable Joystick port */
 #define CTRL_XTALCLKDIS 0x00000002  /* 1 = disable crystal clock input */
 #define CTRL_PCICLKDIS  0x00000001  /* 1 = disable PCI clock distribution */
 #define STAT_INTR       0x80000000  /* wired or of all interrupt bits */
 #define CSTAT_5880_AC97_RST 0x20000000 /* CT5880 Reset bit */
 #define STAT_EN_SPDIF   0x00040000  /* enable S/PDIF circuitry */
 #define STAT_TS_SPDIF   0x00020000  /* test S/PDIF circuitry */
 #define STAT_TESTMODE   0x00010000  /* test ASIC */
 #define STAT_SYNC_ERR   0x00000100  /* 1 = codec sync error */
 #define STAT_VC         0x000000c0  /* CCB int source, 0=DAC1, 1=DAC2, 2=ADC, 3=undef */
 #define STAT_SH_VC      6
 #define STAT_MPWR       0x00000020  /* power level interrupt */
 #define STAT_MCCB       0x00000010  /* CCB int pending */
 #define STAT_UART       0x00000008  /* UART int pending */
 #define STAT_DAC1       0x00000004  /* DAC1 int pending */
 #define STAT_DAC2       0x00000002  /* DAC2 int pending */
 #define STAT_ADC        0x00000001  /* ADC int pending */
 #define USTAT_RXINT     0x80        /* UART rx int pending */
 #define USTAT_TXINT     0x04        /* UART tx int pending */
 #define USTAT_TXRDY     0x02        /* UART tx ready */
 #define USTAT_RXRDY     0x01        /* UART rx ready */
 #define UCTRL_RXINTEN   0x80        /* 1 = enable RX ints */
 #define UCTRL_TXINTEN   0x60        /* TX int enable field mask */
 #define UCTRL_ENA_TXINT 0x20        /* enable TX int */
 #define UCTRL_CNTRL     0x03        /* control field */
 #define UCTRL_CNTRL_SWR 0x03        /* software reset command */
 /* sample rate converter */
 #define SRC_OKSTATE        1
 #define SRC_RAMADDR_MASK   0xfe000000
 #define SRC_RAMADDR_SHIFT  25
 #define SRC_DAC1FREEZE     (1UL << 21)
 #define SRC_DAC2FREEZE      (1UL << 20)
 #define SRC_ADCFREEZE      (1UL << 19)
 #define SRC_WE             0x01000000  /* read/write control for SRC RAM */
 #define SRC_BUSY           0x00800000  /* SRC busy */
 #define SRC_DIS            0x00400000  /* 1 = disable SRC */
 #define SRC_DDAC1          0x00200000  /* 1 = disable accum update for DAC1 */
 #define SRC_DDAC2          0x00100000  /* 1 = disable accum update for DAC2 */
 #define SRC_DADC           0x00080000  /* 1 = disable accum update for ADC2 */
 #define SRC_CTLMASK        0x00780000
 #define SRC_RAMDATA_MASK   0x0000ffff
 #define SRC_RAMDATA_SHIFT  0
 #define SRCREG_ADC      0x78
 #define SRCREG_DAC1     0x70
 #define SRCREG_DAC2     0x74
 #define SRCREG_VOL_ADC  0x6c
 #define SRCREG_VOL_DAC1 0x7c
 #define SRCREG_VOL_DAC2 0x7e
 #define SRCREG_TRUNC_N     0x00
 #define SRCREG_INT_REGS    0x01
 #define SRCREG_ACCUM_FRAC  0x02
 #define SRCREG_VFREQ_FRAC  0x03
 #define CODEC_PIRD        0x00800000  /* 0 = write AC97 register */
 #define CODEC_PIADD_MASK  0x007f0000
 #define CODEC_PIADD_SHIFT 16
 #define CODEC_PIDAT_MASK  0x0000ffff
 #define CODEC_PIDAT_SHIFT 0
 #define CODEC_RDY         0x80000000  /* AC97 read data valid */
 #define CODEC_WIP         0x40000000  /* AC97 write in progress */
 #define CODEC_PORD        0x00800000  /* 0 = write AC97 register */
 #define CODEC_POADD_MASK  0x007f0000
 #define CODEC_POADD_SHIFT 16
 #define CODEC_PODAT_MASK  0x0000ffff
 #define CODEC_PODAT_SHIFT 0
 #define LEGACY_JFAST      0x80000000  /* fast joystick timing */
 #define LEGACY_FIRQ       0x01000000  /* force IRQ */
 #define SCTRL_DACTEST     0x00400000  /* 1 = DAC test, test vector generation purposes */
 #define SCTRL_P2ENDINC    0x00380000  /*  */
 #define SCTRL_SH_P2ENDINC 19
 #define SCTRL_P2STINC     0x00070000  /*  */
 #define SCTRL_SH_P2STINC  16
 #define SCTRL_R1LOOPSEL   0x00008000  /* 0 = loop mode */
 #define SCTRL_P2LOOPSEL   0x00004000  /* 0 = loop mode */
 #define SCTRL_P1LOOPSEL   0x00002000  /* 0 = loop mode */
 #define SCTRL_P2PAUSE     0x00001000  /* 1 = pause mode */
 #define SCTRL_P1PAUSE     0x00000800  /* 1 = pause mode */
 #define SCTRL_R1INTEN     0x00000400  /* enable interrupt */
 #define SCTRL_P2INTEN     0x00000200  /* enable interrupt */
 #define SCTRL_P1INTEN     0x00000100  /* enable interrupt */
 #define SCTRL_P1SCTRLD    0x00000080  /* reload sample count register for DAC1 */
 #define SCTRL_P2DACSEN    0x00000040  /* 1 = DAC2 play back last sample when disabled */
 #define SCTRL_R1SEB       0x00000020  /* 1 = 16bit */
 #define SCTRL_R1SMB       0x00000010  /* 1 = stereo */
 #define SCTRL_R1FMT       0x00000030  /* format mask */
 #define SCTRL_SH_R1FMT    4
 #define SCTRL_P2SEB       0x00000008  /* 1 = 16bit */
 #define SCTRL_P2SMB       0x00000004  /* 1 = stereo */
 #define SCTRL_P2FMT       0x0000000c  /* format mask */
 #define SCTRL_SH_P2FMT    2
 #define SCTRL_P1SEB       0x00000002  /* 1 = 16bit */
 #define SCTRL_P1SMB       0x00000001  /* 1 = stereo */
 #define SCTRL_P1FMT       0x00000003  /* format mask */
 #define SCTRL_SH_P1FMT    0
 /* misc stuff */
 #define POLL_COUNT   0x1000
 #define FMODE_DAC         4           /* slight misuse of mode_t */
 /* MIDI buffer sizes */
 #define MIDIINBUF  256
 #define MIDIOUTBUF 256
 #define FMODE_MIDI_SHIFT 3
 #define FMODE_MIDI_READ  (FMODE_READ << FMODE_MIDI_SHIFT)
 #define FMODE_MIDI_WRITE (FMODE_WRITE << FMODE_MIDI_SHIFT)
 #define ES1371_MODULE_NAME "es1371"
 #define PFX ES1371_MODULE_NAME ": "
 /* --------------------------------------------------------------------- */
 struct es1371_state {
 	/* magic */
 	unsigned int magic;
 	/* list of es1371 devices */
 	struct list_head devs;
 	/* the corresponding pci_dev structure */
 	struct pci_dev *dev;
 	/* soundcore stuff */
 	int dev_audio;
 	int dev_dac;
 	int dev_midi;
 	/* hardware resources */
 	unsigned long io; /* long for SPARC */
 	unsigned int irq;
 	/* PCI ID's */
 	u16 vendor;
 	u16 device;
         u8 rev; /* the chip revision */
 	/* options */
 	int spdif_volume; /* S/PDIF output is enabled if != -1 */
 #ifdef ES1371_DEBUG
         /* debug /proc entry */
 	struct proc_dir_entry *ps;
 #endif /* ES1371_DEBUG */
 	struct ac97_codec *codec;
 	/* wave stuff */
 	unsigned ctrl;
 	unsigned sctrl;
 	unsigned dac1rate, dac2rate, adcrate;
 	spinlock_t lock;
 	struct mutex open_mutex;
 	mode_t open_mode;
 	wait_queue_head_t open_wait;
 	struct dmabuf {
 		void *rawbuf;
 		dma_addr_t dmaaddr;
 		unsigned buforder;
 		unsigned numfrag;
 		unsigned fragshift;
 		unsigned hwptr, swptr;
 		unsigned total_bytes;
 		int count;
 		unsigned error; /* over/underrun */
 		wait_queue_head_t wait;
 		/* redundant, but makes calculations easier */
 		unsigned fragsize;
 		unsigned dmasize;
 		unsigned fragsamples;
 		/* OSS stuff */
 		unsigned mapped:1;
 		unsigned ready:1;
 		unsigned endcleared:1;
 		unsigned enabled:1;
 		unsigned ossfragshift;
 		int ossmaxfrags;
 		unsigned subdivision;
 	} dma_dac1, dma_dac2, dma_adc;
 	/* midi stuff */
 	struct {
 		unsigned ird, iwr, icnt;
 		unsigned ord, owr, ocnt;
 		wait_queue_head_t iwait;
 		wait_queue_head_t owait;
 		unsigned char ibuf[MIDIINBUF];
 		unsigned char obuf[MIDIOUTBUF];
 	} midi;
 #ifdef SUPPORT_JOYSTICK
 	struct gameport *gameport;
 #endif
 	struct mutex sem;
 };
 /* --------------------------------------------------------------------- */
 static LIST_HEAD(devs);
 /* --------------------------------------------------------------------- */
 static 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;
 }
 /* --------------------------------------------------------------------- */
 static unsigned wait_src_ready(struct es1371_state *s)
 {
 	unsigned int t, r;
 	for (t = 0; t < POLL_COUNT; t++) {
 		if (!((r = inl(s->io + ES1371_REG_SRCONV)) & SRC_BUSY))
 			return r;
 		udelay(1);
 	}
 	printk(KERN_DEBUG PFX "sample rate converter timeout r = 0x%08x\n", r);
 	return r;
 }
 static unsigned src_read(struct es1371_state *s, unsigned reg)
 {
         unsigned int temp,i,orig;
         /* wait for ready */
         temp = wait_src_ready (s);
         /* we can only access the SRC at certain times, make sure
            we're allowed to before we read */
         orig = temp;
         /* expose the SRC state bits */
         outl ( (temp & SRC_CTLMASK) | (reg << SRC_RAMADDR_SHIFT) | 0x10000UL,
                s->io + ES1371_REG_SRCONV);
         /* now, wait for busy and the correct time to read */
         temp = wait_src_ready (s);
         if ( (temp & 0x00870000UL ) != ( SRC_OKSTATE << 16 )){
                 /* wait for the right state */
                 for (i=0; i<POLL_COUNT; i++){
                         temp = inl (s->io + ES1371_REG_SRCONV);
                         if ( (temp & 0x00870000UL ) == ( SRC_OKSTATE << 16 ))
                                 break;
                 }
         }
         /* hide the state bits */
         outl ((orig & SRC_CTLMASK) | (reg << SRC_RAMADDR_SHIFT), s->io + ES1371_REG_SRCONV);
         return temp;
 }
 static void src_write(struct es1371_state *s, unsigned reg, unsigned data)
 {
 	unsigned int r;
 	r = wait_src_ready(s) & (SRC_DIS | SRC_DDAC1 | SRC_DDAC2 | SRC_DADC);
 	r |= (reg << SRC_RAMADDR_SHIFT) & SRC_RAMADDR_MASK;
 	r |= (data << SRC_RAMDATA_SHIFT) & SRC_RAMDATA_MASK;
 	outl(r | SRC_WE, s->io + ES1371_REG_SRCONV);
 }
 /* --------------------------------------------------------------------- */
 /* most of the following here is black magic */
 static void set_adc_rate(struct es1371_state *s, unsigned rate)
 {
 	unsigned long flags;
 	unsigned int n, truncm, freq;
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 4000)
 		rate = 4000;
 	n = rate / 3000;
 	if ((1 << n) & ((1 << 15) | (1 << 13) | (1 << 11) | (1 << 9)))
 		n--;
 	truncm = (21 * n - 1) | 1;
         freq = ((48000UL << 15) / rate) * n;
 	s->adcrate = (48000UL << 15) / (freq / n);
 	spin_lock_irqsave(&s->lock, flags);
 	if (rate >= 24000) {
 		if (truncm > 239)
 			truncm = 239;
 		src_write(s, SRCREG_ADC+SRCREG_TRUNC_N,
 			  (((239 - truncm) >> 1) << 9) | (n << 4));
 	} else {
 		if (truncm > 119)
 			truncm = 119;
 		src_write(s, SRCREG_ADC+SRCREG_TRUNC_N,
 			  0x8000 | (((119 - truncm) >> 1) << 9) | (n << 4));
 	}
 	src_write(s, SRCREG_ADC+SRCREG_INT_REGS,
 		  (src_read(s, SRCREG_ADC+SRCREG_INT_REGS) & 0x00ff) |
 		  ((freq >> 5) & 0xfc00));
 	src_write(s, SRCREG_ADC+SRCREG_VFREQ_FRAC, freq & 0x7fff);
 	src_write(s, SRCREG_VOL_ADC, n << 8);
 	src_write(s, SRCREG_VOL_ADC+1, n << 8);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static void set_dac1_rate(struct es1371_state *s, unsigned rate)
 {
 	unsigned long flags;
 	unsigned int freq, r;
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 4000)
 		rate = 4000;
         freq = ((rate << 15) + 1500) / 3000;
 	s->dac1rate = (freq * 3000 + 16384) >> 15;
 	spin_lock_irqsave(&s->lock, flags);
 	r = (wait_src_ready(s) & (SRC_DIS | SRC_DDAC2 | SRC_DADC)) | SRC_DDAC1;
 	outl(r, s->io + ES1371_REG_SRCONV);
 	src_write(s, SRCREG_DAC1+SRCREG_INT_REGS,
 		  (src_read(s, SRCREG_DAC1+SRCREG_INT_REGS) & 0x00ff) |
 		  ((freq >> 5) & 0xfc00));
 	src_write(s, SRCREG_DAC1+SRCREG_VFREQ_FRAC, freq & 0x7fff);
 	r = (wait_src_ready(s) & (SRC_DIS | SRC_DDAC2 | SRC_DADC));
 	outl(r, s->io + ES1371_REG_SRCONV);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static void set_dac2_rate(struct es1371_state *s, unsigned rate)
 {
 	unsigned long flags;
 	unsigned int freq, r;
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 4000)
 		rate = 4000;
         freq = ((rate << 15) + 1500) / 3000;
 	s->dac2rate = (freq * 3000 + 16384) >> 15;
 	spin_lock_irqsave(&s->lock, flags);
 	r = (wait_src_ready(s) & (SRC_DIS | SRC_DDAC1 | SRC_DADC)) | SRC_DDAC2;
 	outl(r, s->io + ES1371_REG_SRCONV);
 	src_write(s, SRCREG_DAC2+SRCREG_INT_REGS,
 		  (src_read(s, SRCREG_DAC2+SRCREG_INT_REGS) & 0x00ff) |
 		  ((freq >> 5) & 0xfc00));
 	src_write(s, SRCREG_DAC2+SRCREG_VFREQ_FRAC, freq & 0x7fff);
 	r = (wait_src_ready(s) & (SRC_DIS | SRC_DDAC1 | SRC_DADC));
 	outl(r, s->io + ES1371_REG_SRCONV);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 /* --------------------------------------------------------------------- */
 static void __devinit src_init(struct es1371_state *s)
 {
         unsigned int i;
         /* before we enable or disable the SRC we need
            to wait for it to become ready */
         wait_src_ready(s);
         outl(SRC_DIS, s->io + ES1371_REG_SRCONV);
         for (i = 0; i < 0x80; i++)
                 src_write(s, i, 0);
         src_write(s, SRCREG_DAC1+SRCREG_TRUNC_N, 16 << 4);
         src_write(s, SRCREG_DAC1+SRCREG_INT_REGS, 16 << 10);
         src_write(s, SRCREG_DAC2+SRCREG_TRUNC_N, 16 << 4);
         src_write(s, SRCREG_DAC2+SRCREG_INT_REGS, 16 << 10);
         src_write(s, SRCREG_VOL_ADC, 1 << 12);
         src_write(s, SRCREG_VOL_ADC+1, 1 << 12);
         src_write(s, SRCREG_VOL_DAC1, 1 << 12);
         src_write(s, SRCREG_VOL_DAC1+1, 1 << 12);
         src_write(s, SRCREG_VOL_DAC2, 1 << 12);
         src_write(s, SRCREG_VOL_DAC2+1, 1 << 12);
         set_adc_rate(s, 22050);
         set_dac1_rate(s, 22050);
         set_dac2_rate(s, 22050);
         /* WARNING:
          * enabling the sample rate converter without properly programming
          * its parameters causes the chip to lock up (the SRC busy bit will
          * be stuck high, and I've found no way to rectify this other than
          * power cycle)
          */
         wait_src_ready(s);
         outl(0, s->io+ES1371_REG_SRCONV);
 }
 /* --------------------------------------------------------------------- */
 static void wrcodec(struct ac97_codec *codec, u8 addr, u16 data)
 {
 	struct es1371_state *s = (struct es1371_state *)codec->private_data;
 	unsigned long flags;
 	unsigned t, x;
 	spin_lock_irqsave(&s->lock, flags);
 	for (t = 0; t < POLL_COUNT; t++)
 		if (!(inl(s->io+ES1371_REG_CODEC) & CODEC_WIP))
 			break;
         /* save the current state for later */
         x = wait_src_ready(s);
         /* enable SRC state data in SRC mux */
 	outl((x & (SRC_DIS | SRC_DDAC1 | SRC_DDAC2 | SRC_DADC)) | 0x00010000,
 	     s->io+ES1371_REG_SRCONV);
         /* wait for not busy (state 0) first to avoid
            transition states */
         for (t=0; t<POLL_COUNT; t++){
                 if((inl(s->io+ES1371_REG_SRCONV) & 0x00870000) ==0 )
                     break;
                 udelay(1);
         }
         /* wait for a SAFE time to write addr/data and then do it, dammit */
         for (t=0; t<POLL_COUNT; t++){
                 if((inl(s->io+ES1371_REG_SRCONV) & 0x00870000) ==0x00010000)
                     break;
                 udelay(1);
         }
 	outl(((addr << CODEC_POADD_SHIFT) & CODEC_POADD_MASK) |
 	     ((data << CODEC_PODAT_SHIFT) & CODEC_PODAT_MASK), s->io+ES1371_REG_CODEC);
 	/* restore SRC reg */
 	wait_src_ready(s);
 	outl(x, s->io+ES1371_REG_SRCONV);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static u16 rdcodec(struct ac97_codec *codec, u8 addr)
 {
 	struct es1371_state *s = (struct es1371_state *)codec->private_data;
 	unsigned long flags;
 	unsigned t, x;
 	spin_lock_irqsave(&s->lock, flags);
         /* wait for WIP to go away */
 	for (t = 0; t < 0x1000; t++)
 		if (!(inl(s->io+ES1371_REG_CODEC) & CODEC_WIP))
 			break;
 	/* save the current state for later */
 	x = (wait_src_ready(s) & (SRC_DIS | SRC_DDAC1 | SRC_DDAC2 | SRC_DADC));
 	/* enable SRC state data in SRC mux */
 	outl( x | 0x00010000,
               s->io+ES1371_REG_SRCONV);
         /* wait for not busy (state 0) first to avoid
            transition states */
         for (t=0; t<POLL_COUNT; t++){
                 if((inl(s->io+ES1371_REG_SRCONV) & 0x00870000) ==0 )
                     break;
                 udelay(1);
         }
         /* wait for a SAFE time to write addr/data and then do it, dammit */
         for (t=0; t<POLL_COUNT; t++){
                 if((inl(s->io+ES1371_REG_SRCONV) & 0x00870000) ==0x00010000)
                     break;
                 udelay(1);
         }
 	outl(((addr << CODEC_POADD_SHIFT) & CODEC_POADD_MASK) | CODEC_PORD, s->io+ES1371_REG_CODEC);
 	/* restore SRC reg */
 	wait_src_ready(s);
 	outl(x, s->io+ES1371_REG_SRCONV);
         /* wait for WIP again */
 	for (t = 0; t < 0x1000; t++)
 		if (!(inl(s->io+ES1371_REG_CODEC) & CODEC_WIP))
 			break;
 	/* now wait for the stinkin' data (RDY) */
 	for (t = 0; t < POLL_COUNT; t++)
 		if ((x = inl(s->io+ES1371_REG_CODEC)) & CODEC_RDY)
 			break;
 	spin_unlock_irqrestore(&s->lock, flags);
 	return ((x & CODEC_PIDAT_MASK) >> CODEC_PIDAT_SHIFT);
 }
 /* --------------------------------------------------------------------- */
 static inline void stop_adc(struct es1371_state *s)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&s->lock, flags);
 	s->ctrl &= ~CTRL_ADC_EN;
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static inline void stop_dac1(struct es1371_state *s)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&s->lock, flags);
 	s->ctrl &= ~CTRL_DAC1_EN;
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static inline void stop_dac2(struct es1371_state *s)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&s->lock, flags);
 	s->ctrl &= ~CTRL_DAC2_EN;
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static void start_dac1(struct es1371_state *s)
 {
 	unsigned long flags;
 	unsigned fragremain, fshift;
 	spin_lock_irqsave(&s->lock, flags);
 	if (!(s->ctrl & CTRL_DAC1_EN) && (s->dma_dac1.mapped || s->dma_dac1.count > 0)
 	    && s->dma_dac1.ready) {
 		s->ctrl |= CTRL_DAC1_EN;
 		s->sctrl = (s->sctrl & ~(SCTRL_P1LOOPSEL | SCTRL_P1PAUSE | SCTRL_P1SCTRLD)) | SCTRL_P1INTEN;
 		outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 		fragremain = ((- s->dma_dac1.hwptr) & (s->dma_dac1.fragsize-1));
 		fshift = sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
 		if (fragremain < 2*fshift)
 			fragremain = s->dma_dac1.fragsize;
 		outl((fragremain >> fshift) - 1, s->io+ES1371_REG_DAC1_SCOUNT);
 		outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 		outl((s->dma_dac1.fragsize >> fshift) - 1, s->io+ES1371_REG_DAC1_SCOUNT);
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static void start_dac2(struct es1371_state *s)
 {
 	unsigned long flags;
 	unsigned fragremain, fshift;
 	spin_lock_irqsave(&s->lock, flags);
 	if (!(s->ctrl & CTRL_DAC2_EN) && (s->dma_dac2.mapped || s->dma_dac2.count > 0)
 	    && s->dma_dac2.ready) {
 		s->ctrl |= CTRL_DAC2_EN;
 		s->sctrl = (s->sctrl & ~(SCTRL_P2LOOPSEL | SCTRL_P2PAUSE | SCTRL_P2DACSEN |
 					 SCTRL_P2ENDINC | SCTRL_P2STINC)) | SCTRL_P2INTEN |
 			(((s->sctrl & SCTRL_P2FMT) ? 2 : 1) << SCTRL_SH_P2ENDINC) |
 			(0 << SCTRL_SH_P2STINC);
 		outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 		fragremain = ((- s->dma_dac2.hwptr) & (s->dma_dac2.fragsize-1));
 		fshift = sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
 		if (fragremain < 2*fshift)
 			fragremain = s->dma_dac2.fragsize;
 		outl((fragremain >> fshift) - 1, s->io+ES1371_REG_DAC2_SCOUNT);
 		outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 		outl((s->dma_dac2.fragsize >> fshift) - 1, s->io+ES1371_REG_DAC2_SCOUNT);
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 static void start_adc(struct es1371_state *s)
 {
 	unsigned long flags;
 	unsigned fragremain, fshift;
 	spin_lock_irqsave(&s->lock, flags);
 	if (!(s->ctrl & CTRL_ADC_EN) && (s->dma_adc.mapped || s->dma_adc.count < (signed)(s->dma_adc.dmasize - 2*s->dma_adc.fragsize))
 	    && s->dma_adc.ready) {
 		s->ctrl |= CTRL_ADC_EN;
 		s->sctrl = (s->sctrl & ~SCTRL_R1LOOPSEL) | SCTRL_R1INTEN;
 		outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 		fragremain = ((- s->dma_adc.hwptr) & (s->dma_adc.fragsize-1));
 		fshift = sample_shift[(s->sctrl & SCTRL_R1FMT) >> SCTRL_SH_R1FMT];
 		if (fragremain < 2*fshift)
 			fragremain = s->dma_adc.fragsize;
 		outl((fragremain >> fshift) - 1, s->io+ES1371_REG_ADC_SCOUNT);
 		outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 		outl((s->dma_adc.fragsize >> fshift) - 1, s->io+ES1371_REG_ADC_SCOUNT);
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 }
 /* --------------------------------------------------------------------- */
 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
 #define DMABUF_MINORDER 1
 static inline void dealloc_dmabuf(struct es1371_state *s, struct dmabuf *db)
 {
 	struct page *page, *pend;
 	if (db->rawbuf) {
 		/* undo marking the pages as reserved */
 		pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
 		for (page = virt_to_page(db->rawbuf); page <= pend; page++)
 			ClearPageReserved(page);
 		pci_free_consistent(s->dev, PAGE_SIZE << db->buforder, db->rawbuf, db->dmaaddr);
 	}
 	db->rawbuf = NULL;
 	db->mapped = db->ready = 0;
 }
 static int prog_dmabuf(struct es1371_state *s, struct dmabuf *db, unsigned rate, unsigned fmt, unsigned reg)
 {
 	int order;
 	unsigned bytepersec;
 	unsigned bufs;
 	struct page *page, *pend;
 	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 = pci_alloc_consistent(s->dev, PAGE_SIZE << order, &db->dmaaddr)))
 				break;
 		if (!db->rawbuf)
 			return -ENOMEM;
 		db->buforder = order;
 		/* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
 		pend = virt_to_page(db->rawbuf + (PAGE_SIZE << db->buforder) - 1);
 		for (page = virt_to_page(db->rawbuf); page <= pend; page++)
 			SetPageReserved(page);
 	}
 	fmt &= ES1371_FMT_MASK;
 	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;
 	db->fragsamples = db->fragsize >> sample_shift[fmt];
 	db->dmasize = db->numfrag << db->fragshift;
 	memset(db->rawbuf, (fmt & ES1371_FMT_S16) ? 0 : 0x80, db->dmasize);
 	outl((reg >> 8) & 15, s->io+ES1371_REG_MEMPAGE);
 	outl(db->dmaaddr, s->io+(reg & 0xff));
 	outl((db->dmasize >> 2)-1, s->io+((reg + 4) & 0xff));
 	db->enabled = 1;
 	db->ready = 1;
 	return 0;
 }
 static inline int prog_dmabuf_adc(struct es1371_state *s)
 {
 	stop_adc(s);
 	return prog_dmabuf(s, &s->dma_adc, s->adcrate, (s->sctrl >> SCTRL_SH_R1FMT) & ES1371_FMT_MASK,
 			   ES1371_REG_ADC_FRAMEADR);
 }
 static inline int prog_dmabuf_dac2(struct es1371_state *s)
 {
 	stop_dac2(s);
 	return prog_dmabuf(s, &s->dma_dac2, s->dac2rate, (s->sctrl >> SCTRL_SH_P2FMT) & ES1371_FMT_MASK,
 			   ES1371_REG_DAC2_FRAMEADR);
 }
 static inline int prog_dmabuf_dac1(struct es1371_state *s)
 {
 	stop_dac1(s);
 	return prog_dmabuf(s, &s->dma_dac1, s->dac1rate, (s->sctrl >> SCTRL_SH_P1FMT) & ES1371_FMT_MASK,
 			   ES1371_REG_DAC1_FRAMEADR);
 }
 static inline unsigned get_hwptr(struct es1371_state *s, struct dmabuf *db, unsigned reg)
 {
 	unsigned hwptr, diff;
 	outl((reg >> 8) & 15, s->io+ES1371_REG_MEMPAGE);
 	hwptr = (inl(s->io+(reg & 0xff)) >> 14) & 0x3fffc;
 	diff = (db->dmasize + hwptr - db->hwptr) % db->dmasize;
 	db->hwptr = hwptr;
 	return diff;
 }
 static inline void clear_advance(void *buf, unsigned bsize, unsigned bptr, unsigned len, unsigned char c)
 {
 	if (bptr + len > bsize) {
 		unsigned x = bsize - bptr;
 		memset(((char *)buf) + bptr, c, x);
 		bptr = 0;
 		len -= x;
 	}
 	memset(((char *)buf) + bptr, c, len);
 }
 /* call with spinlock held! */
 static void es1371_update_ptr(struct es1371_state *s)
 {
 	int diff;
 	/* update ADC pointer */
 	if (s->ctrl & CTRL_ADC_EN) {
 		diff = get_hwptr(s, &s->dma_adc, ES1371_REG_ADC_FRAMECNT);
 		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))) {
 				s->ctrl &= ~CTRL_ADC_EN;
 				outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 				s->dma_adc.error++;
 			}
 		}
 	}
 	/* update DAC1 pointer */
 	if (s->ctrl & CTRL_DAC1_EN) {
 		diff = get_hwptr(s, &s->dma_dac1, ES1371_REG_DAC1_FRAMECNT);
 		s->dma_dac1.total_bytes += diff;
 		if (s->dma_dac1.mapped) {
 			s->dma_dac1.count += diff;
 			if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
 				wake_up(&s->dma_dac1.wait);
 		} else {
 			s->dma_dac1.count -= diff;
 			if (s->dma_dac1.count <= 0) {
 				s->ctrl &= ~CTRL_DAC1_EN;
 				outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 				s->dma_dac1.error++;
 			} else if (s->dma_dac1.count <= (signed)s->dma_dac1.fragsize && !s->dma_dac1.endcleared) {
 				clear_advance(s->dma_dac1.rawbuf, s->dma_dac1.dmasize, s->dma_dac1.swptr,
 					      s->dma_dac1.fragsize, (s->sctrl & SCTRL_P1SEB) ? 0 : 0x80);
 				s->dma_dac1.endcleared = 1;
 			}
 			if (s->dma_dac1.count + (signed)s->dma_dac1.fragsize <= (signed)s->dma_dac1.dmasize)
 				wake_up(&s->dma_dac1.wait);
 		}
 	}
 	/* update DAC2 pointer */
 	if (s->ctrl & CTRL_DAC2_EN) {
 		diff = get_hwptr(s, &s->dma_dac2, ES1371_REG_DAC2_FRAMECNT);
 		s->dma_dac2.total_bytes += diff;
 		if (s->dma_dac2.mapped) {
 			s->dma_dac2.count += diff;
 			if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize)
 				wake_up(&s->dma_dac2.wait);
 		} else {
 			s->dma_dac2.count -= diff;
 			if (s->dma_dac2.count <= 0) {
 				s->ctrl &= ~CTRL_DAC2_EN;
 				outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 				s->dma_dac2.error++;
 			} else if (s->dma_dac2.count <= (signed)s->dma_dac2.fragsize && !s->dma_dac2.endcleared) {
 				clear_advance(s->dma_dac2.rawbuf, s->dma_dac2.dmasize, s->dma_dac2.swptr,
 					      s->dma_dac2.fragsize, (s->sctrl & SCTRL_P2SEB) ? 0 : 0x80);
 				s->dma_dac2.endcleared = 1;
 			}
 			if (s->dma_dac2.count + (signed)s->dma_dac2.fragsize <= (signed)s->dma_dac2.dmasize)
 				wake_up(&s->dma_dac2.wait);
 		}
 	}
 }
 /* hold spinlock for the following! */
 static void es1371_handle_midi(struct es1371_state *s)
 {
 	unsigned char ch;
 	int wake;
 	if (!(s->ctrl & CTRL_UART_EN))
 		return;
 	wake = 0;
 	while (inb(s->io+ES1371_REG_UART_STATUS) & USTAT_RXRDY) {
 		ch = inb(s->io+ES1371_REG_UART_DATA);
 		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->io+ES1371_REG_UART_STATUS) & USTAT_TXRDY) && s->midi.ocnt > 0) {
 		outb(s->midi.obuf[s->midi.ord], s->io+ES1371_REG_UART_DATA);
 		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);
 	outb((s->midi.ocnt > 0) ? UCTRL_RXINTEN | UCTRL_ENA_TXINT : UCTRL_RXINTEN, s->io+ES1371_REG_UART_CONTROL);
 }
 static irqreturn_t es1371_interrupt(int irq, void *dev_id)
 {
         struct es1371_state *s = dev_id;
 	unsigned int intsrc, sctl;
 	/* fastpath out, to ease interrupt sharing */
 	intsrc = inl(s->io+ES1371_REG_STATUS);
 	if (!(intsrc & 0x80000000))
 		return IRQ_NONE;
 	spin_lock(&s->lock);
 	/* clear audio interrupts first */
 	sctl = s->sctrl;
 	if (intsrc & STAT_ADC)
 		sctl &= ~SCTRL_R1INTEN;
 	if (intsrc & STAT_DAC1)
 		sctl &= ~SCTRL_P1INTEN;
 	if (intsrc & STAT_DAC2)
 		sctl &= ~SCTRL_P2INTEN;
 	outl(sctl, s->io+ES1371_REG_SERIAL_CONTROL);
 	outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 	es1371_update_ptr(s);
 	es1371_handle_midi(s);
 	spin_unlock(&s->lock);
 	return IRQ_HANDLED;
 }
 /* --------------------------------------------------------------------- */
 static const char invalid_magic[] = KERN_CRIT PFX "invalid magic value\n";
 #define VALIDATE_STATE(s)                         \
 ({                                                \
 	if (!(s) || (s)->magic != ES1371_MAGIC) { \
 		printk(invalid_magic);            \
 		return -ENXIO;                    \
 	}                                         \
 })
 /* --------------------------------------------------------------------- */
 /* Conversion table for S/PDIF PCM volume emulation through the SRC */
 /* dB-linear table of DAC vol values; -0dB to -46.5dB with mute */
 static const unsigned short DACVolTable[101] =
 {
 	0x1000, 0x0f2a, 0x0e60, 0x0da0, 0x0cea, 0x0c3e, 0x0b9a, 0x0aff,
 	0x0a6d, 0x09e1, 0x095e, 0x08e1, 0x086a, 0x07fa, 0x078f, 0x072a,
 	0x06cb, 0x0670, 0x061a, 0x05c9, 0x057b, 0x0532, 0x04ed, 0x04ab,
 	0x046d, 0x0432, 0x03fa, 0x03c5, 0x0392, 0x0363, 0x0335, 0x030b,
 	0x02e2, 0x02bc, 0x0297, 0x0275, 0x0254, 0x0235, 0x0217, 0x01fb,
 	0x01e1, 0x01c8, 0x01b0, 0x0199, 0x0184, 0x0170, 0x015d, 0x014b,
 	0x0139, 0x0129, 0x0119, 0x010b, 0x00fd, 0x00f0, 0x00e3, 0x00d7,
 	0x00cc, 0x00c1, 0x00b7, 0x00ae, 0x00a5, 0x009c, 0x0094, 0x008c,
 	0x0085, 0x007e, 0x0077, 0x0071, 0x006b, 0x0066, 0x0060, 0x005b,
 	0x0057, 0x0052, 0x004e, 0x004a, 0x0046, 0x0042, 0x003f, 0x003c,
 	0x0038, 0x0036, 0x0033, 0x0030, 0x002e, 0x002b, 0x0029, 0x0027,
 	0x0025, 0x0023, 0x0021, 0x001f, 0x001e, 0x001c, 0x001b, 0x0019,
 	0x0018, 0x0017, 0x0016, 0x0014, 0x0000
 };
 /*
  * when we are in S/PDIF mode, we want to disable any analog output so
  * we filter the mixer ioctls
  */
 static int mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd, unsigned long arg)
 {
 	struct es1371_state *s = (struct es1371_state *)codec->private_data;
 	int val;
 	unsigned long flags;
 	unsigned int left, right;
 	VALIDATE_STATE(s);
 	/* filter mixer ioctls to catch PCM and MASTER volume when in S/PDIF mode */
 	if (s->spdif_volume == -1)
 		return codec->mixer_ioctl(codec, cmd, arg);
 	switch (cmd) {
 	case SOUND_MIXER_WRITE_VOLUME:
 		return 0;
 	case SOUND_MIXER_WRITE_PCM:   /* use SRC for PCM volume */
 		if (get_user(val, (int __user *)arg))
 			return -EFAULT;
 		right = ((val >> 8)  & 0xff);
 		left = (val  & 0xff);
 		if (right > 100)
 			right = 100;
 		if (left > 100)
 			left = 100;
 		s->spdif_volume = (right << 8) | left;
 		spin_lock_irqsave(&s->lock, flags);
 		src_write(s, SRCREG_VOL_DAC2, DACVolTable[100 - left]);
 		src_write(s, SRCREG_VOL_DAC2+1, DACVolTable[100 - right]);
 		spin_unlock_irqrestore(&s->lock, flags);
 		return 0;
 	case SOUND_MIXER_READ_PCM:
 		return put_user(s->spdif_volume, (int __user *)arg);
 	}
 	return codec->mixer_ioctl(codec, cmd, arg);
 }
 /* --------------------------------------------------------------------- */
 /*
  * AC97 Mixer Register to Connections mapping of the Concert 97 board
  *
  * AC97_MASTER_VOL_STEREO   Line Out
  * AC97_MASTER_VOL_MONO     TAD Output
  * AC97_PCBEEP_VOL          none
  * AC97_PHONE_VOL           TAD Input (mono)
  * AC97_MIC_VOL             MIC Input (mono)
  * AC97_LINEIN_VOL          Line Input (stereo)
  * AC97_CD_VOL              CD Input (stereo)
  * AC97_VIDEO_VOL           none
  * AC97_AUX_VOL             Aux Input (stereo)
  * AC97_PCMOUT_VOL          Wave Output (stereo)
  */
 static int es1371_open_mixdev(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	struct list_head *list;
 	struct es1371_state *s;
 	for (list = devs.next; ; list = list->next) {
 		if (list == &devs)
 			return -ENODEV;
 		s = list_entry(list, struct es1371_state, devs);
 		if (s->codec->dev_mixer == minor)
 			break;
 	}
        	VALIDATE_STATE(s);
 	file->private_data = s;
 	return nonseekable_open(inode, file);
 }
 static int es1371_release_mixdev(struct inode *inode, struct file *file)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	VALIDATE_STATE(s);
 	return 0;
 }
 static int es1371_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	struct ac97_codec *codec = s->codec;
 	return mixdev_ioctl(codec, cmd, arg);
 }
 static /*const*/ struct file_operations es1371_mixer_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.ioctl		= es1371_ioctl_mixdev,
 	.open		= es1371_open_mixdev,
 	.release	= es1371_release_mixdev,
 };
 /* --------------------------------------------------------------------- */
 static int drain_dac1(struct es1371_state *s, int nonblock)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	int count, tmo;
 	if (s->dma_dac1.mapped || !s->dma_dac1.ready)
 		return 0;
         add_wait_queue(&s->dma_dac1.wait, &wait);
         for (;;) {
 		__set_current_state(TASK_INTERRUPTIBLE);
                 spin_lock_irqsave(&s->lock, flags);
 		count = s->dma_dac1.count;
                 spin_unlock_irqrestore(&s->lock, flags);
 		if (count <= 0)
 			break;
 		if (signal_pending(current))
                         break;
                 if (nonblock) {
                         remove_wait_queue(&s->dma_dac1.wait, &wait);
                         set_current_state(TASK_RUNNING);
                         return -EBUSY;
                 }
 		tmo = 3 * HZ * (count + s->dma_dac1.fragsize) / 2 / s->dac1rate;
 		tmo >>= sample_shift[(s->sctrl & SCTRL_P1FMT) >> SCTRL_SH_P1FMT];
 		if (!schedule_timeout(tmo + 1))
 			DBG(printk(KERN_DEBUG PFX "dac1 dma timed out??\n");)
         }
         remove_wait_queue(&s->dma_dac1.wait, &wait);
         set_current_state(TASK_RUNNING);
         if (signal_pending(current))
                 return -ERESTARTSYS;
         return 0;
 }
 static int drain_dac2(struct es1371_state *s, int nonblock)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	int count, tmo;
 	if (s->dma_dac2.mapped || !s->dma_dac2.ready)
 		return 0;
         add_wait_queue(&s->dma_dac2.wait, &wait);
         for (;;) {
 		__set_current_state(TASK_UNINTERRUPTIBLE);
                 spin_lock_irqsave(&s->lock, flags);
 		count = s->dma_dac2.count;
                 spin_unlock_irqrestore(&s->lock, flags);
 		if (count <= 0)
 			break;
 		if (signal_pending(current))
                         break;
                 if (nonblock) {
                         remove_wait_queue(&s->dma_dac2.wait, &wait);
                         set_current_state(TASK_RUNNING);
                         return -EBUSY;
                 }
 		tmo = 3 * HZ * (count + s->dma_dac2.fragsize) / 2 / s->dac2rate;
 		tmo >>= sample_shift[(s->sctrl & SCTRL_P2FMT) >> SCTRL_SH_P2FMT];
 		if (!schedule_timeout(tmo + 1))
 			DBG(printk(KERN_DEBUG PFX "dac2 dma timed out??\n");)
         }
         remove_wait_queue(&s->dma_dac2.wait, &wait);
         set_current_state(TASK_RUNNING);
         if (signal_pending(current))
                 return -ERESTARTSYS;
         return 0;
 }
 /* --------------------------------------------------------------------- */
 static ssize_t es1371_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret = 0;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	VALIDATE_STATE(s);
 	if (s->dma_adc.mapped)
 		return -ENXIO;
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	mutex_lock(&s->sem);
 	if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
 		goto out2;
 	add_wait_queue(&s->dma_adc.wait, &wait);
 	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;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			if (s->dma_adc.enabled)
 				start_adc(s);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
 			}
 			mutex_unlock(&s->sem);
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out2;
 			}
 			mutex_lock(&s->sem);
 			if (s->dma_adc.mapped)
 			{
 				ret = -ENXIO;
 				goto out;
 			}
 			continue;
 		}
 		if (copy_to_user(buffer, s->dma_adc.rawbuf + swptr, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			goto out;
 		}
 		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;
 		if (s->dma_adc.enabled)
 			start_adc(s);
 	}
 out:
 	mutex_unlock(&s->sem);
 out2:
 	remove_wait_queue(&s->dma_adc.wait, &wait);
 	set_current_state(TASK_RUNNING);
 	return ret;
 }
 static ssize_t es1371_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	VALIDATE_STATE(s);
 	if (s->dma_dac2.mapped)
 		return -ENXIO;
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	mutex_lock(&s->sem);
 	if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
 		goto out3;
 	ret = 0;
 	add_wait_queue(&s->dma_dac2.wait, &wait);
 	while (count > 0) {
 		spin_lock_irqsave(&s->lock, flags);
 		if (s->dma_dac2.count < 0) {
 			s->dma_dac2.count = 0;
 			s->dma_dac2.swptr = s->dma_dac2.hwptr;
 		}
 		swptr = s->dma_dac2.swptr;
 		cnt = s->dma_dac2.dmasize-swptr;
 		if (s->dma_dac2.count + cnt > s->dma_dac2.dmasize)
 			cnt = s->dma_dac2.dmasize - s->dma_dac2.count;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			if (s->dma_dac2.enabled)
 				start_dac2(s);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
 			}
 			mutex_unlock(&s->sem);
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out2;
 			}
 			mutex_lock(&s->sem);
 			if (s->dma_dac2.mapped)
 			{
 				ret = -ENXIO;
 				goto out;
 			}
 			continue;
 		}
 		if (copy_from_user(s->dma_dac2.rawbuf + swptr, buffer, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			goto out;
 		}
 		swptr = (swptr + cnt) % s->dma_dac2.dmasize;
 		spin_lock_irqsave(&s->lock, flags);
 		s->dma_dac2.swptr = swptr;
 		s->dma_dac2.count += cnt;
 		s->dma_dac2.endcleared = 0;
 		spin_unlock_irqrestore(&s->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		if (s->dma_dac2.enabled)
 			start_dac2(s);
 	}
 out:
 	mutex_unlock(&s->sem);
 out2:
 	remove_wait_queue(&s->dma_dac2.wait, &wait);
 out3:
 	set_current_state(TASK_RUNNING);
 	return ret;
 }
 /* No kernel lock - we have our own spinlock */
 static unsigned int es1371_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	unsigned long flags;
 	unsigned int mask = 0;
 	VALIDATE_STATE(s);
 	if (file->f_mode & FMODE_WRITE) {
 		if (!s->dma_dac2.ready && prog_dmabuf_dac2(s))
 			return 0;
 		poll_wait(file, &s->dma_dac2.wait, wait);
 	}
 	if (file->f_mode & FMODE_READ) {
 		if (!s->dma_adc.ready && prog_dmabuf_adc(s))
 			return 0;
 		poll_wait(file, &s->dma_adc.wait, wait);
 	}
 	spin_lock_irqsave(&s->lock, flags);
 	es1371_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_dac2.mapped) {
 			if (s->dma_dac2.count >= (signed)s->dma_dac2.fragsize)
 				mask |= POLLOUT | POLLWRNORM;
 		} else {
 			if ((signed)s->dma_dac2.dmasize >= s->dma_dac2.count + (signed)s->dma_dac2.fragsize)
 				mask |= POLLOUT | POLLWRNORM;
 		}
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 	return mask;
 }
 static int es1371_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	struct dmabuf *db;
 	int ret = 0;
 	unsigned long size;
 	VALIDATE_STATE(s);
 	lock_kernel();
 	mutex_lock(&s->sem);
 	if (vma->vm_flags & VM_WRITE) {
 		if ((ret = prog_dmabuf_dac2(s)) != 0) {
 			goto out;
 		}
 		db = &s->dma_dac2;
 	} else if (vma->vm_flags & VM_READ) {
 		if ((ret = prog_dmabuf_adc(s)) != 0) {
 			goto out;
 		}
 		db = &s->dma_adc;
 	} else {
 		ret = -EINVAL;
 		goto out;
 	}
 	if (vma->vm_pgoff != 0) {
 		ret = -EINVAL;
 		goto out;
 	}
 	size = vma->vm_end - vma->vm_start;
 	if (size > (PAGE_SIZE << db->buforder)) {
 		ret = -EINVAL;
 		goto out;
 	}
 	if (remap_pfn_range(vma, vma->vm_start,
 				virt_to_phys(db->rawbuf) >> PAGE_SHIFT,
 				size, vma->vm_page_prot)) {
 		ret = -EAGAIN;
 		goto out;
 	}
 	db->mapped = 1;
 out:
 	mutex_unlock(&s->sem);
 	unlock_kernel();
 	return ret;
 }
 static int es1371_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	unsigned long flags;
         audio_buf_info abinfo;
         count_info cinfo;
 	int count;
 	int val, mapped, ret;
 	void __user *argp = (void __user *)arg;
 	int __user *p = argp;
 	VALIDATE_STATE(s);
         mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac2.mapped) ||
 		((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
 	switch (cmd) {
 	case OSS_GETVERSION:
 		return put_user(SOUND_VERSION, p);
 	case SNDCTL_DSP_SYNC:
 		if (file->f_mode & FMODE_WRITE)
 			return drain_dac2(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, p);
         case SNDCTL_DSP_RESET:
 		if (file->f_mode & FMODE_WRITE) {
 			stop_dac2(s);
 			synchronize_irq(s->irq);
 			s->dma_dac2.swptr = s->dma_dac2.hwptr = s->dma_dac2.count = s->dma_dac2.total_bytes = 0;
 		}
 		if (file->f_mode & FMODE_READ) {
 			stop_adc(s);
 			synchronize_irq(s->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:
                 if (get_user(val, p))
 			return -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_dac2(s);
 				s->dma_dac2.ready = 0;
 				set_dac2_rate(s, val);
 			}
 		}
 		return put_user((file->f_mode & FMODE_READ) ? s->adcrate : s->dac2rate, p);
         case SNDCTL_DSP_STEREO:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_READ) {
 			stop_adc(s);
 			s->dma_adc.ready = 0;
 			spin_lock_irqsave(&s->lock, flags);
 			if (val)
 				s->sctrl |= SCTRL_R1SMB;
 			else
 				s->sctrl &= ~SCTRL_R1SMB;
 			outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 			spin_unlock_irqrestore(&s->lock, flags);
 		}
 		if (file->f_mode & FMODE_WRITE) {
 			stop_dac2(s);
 			s->dma_dac2.ready = 0;
 			spin_lock_irqsave(&s->lock, flags);
 			if (val)
 				s->sctrl |= SCTRL_P2SMB;
 			else
 				s->sctrl &= ~SCTRL_P2SMB;
 			outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 			spin_unlock_irqrestore(&s->lock, flags);
                 }
 		return 0;
         case SNDCTL_DSP_CHANNELS:
                 if (get_user(val, p))
 			return -EFAULT;
 		if (val != 0) {
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(s);
 				s->dma_adc.ready = 0;
 				spin_lock_irqsave(&s->lock, flags);
 				if (val >= 2)
 					s->sctrl |= SCTRL_R1SMB;
 				else
 					s->sctrl &= ~SCTRL_R1SMB;
 				outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 				spin_unlock_irqrestore(&s->lock, flags);
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				stop_dac2(s);
 				s->dma_dac2.ready = 0;
 				spin_lock_irqsave(&s->lock, flags);
 				if (val >= 2)
 					s->sctrl |= SCTRL_P2SMB;
 				else
 					s->sctrl &= ~SCTRL_P2SMB;
 				outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 				spin_unlock_irqrestore(&s->lock, flags);
 			}
 		}
 		return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ? 2 : 1, p);
 	case SNDCTL_DSP_GETFMTS: /* Returns a mask */
                 return put_user(AFMT_S16_LE|AFMT_U8, p);
 	case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val != AFMT_QUERY) {
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(s);
 				s->dma_adc.ready = 0;
 				spin_lock_irqsave(&s->lock, flags);
 				if (val == AFMT_S16_LE)
 					s->sctrl |= SCTRL_R1SEB;
 				else
 					s->sctrl &= ~SCTRL_R1SEB;
 				outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 				spin_unlock_irqrestore(&s->lock, flags);
 			}
 			if (file->f_mode & FMODE_WRITE) {
 				stop_dac2(s);
 				s->dma_dac2.ready = 0;
 				spin_lock_irqsave(&s->lock, flags);
 				if (val == AFMT_S16_LE)
 					s->sctrl |= SCTRL_P2SEB;
 				else
 					s->sctrl &= ~SCTRL_P2SEB;
 				outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 				spin_unlock_irqrestore(&s->lock, flags);
 			}
 		}
 		return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ?
 				AFMT_S16_LE : AFMT_U8, p);
 	case SNDCTL_DSP_POST:
                 return 0;
         case SNDCTL_DSP_GETTRIGGER:
 		val = 0;
 		if (file->f_mode & FMODE_READ && s->ctrl & CTRL_ADC_EN)
 			val |= PCM_ENABLE_INPUT;
 		if (file->f_mode & FMODE_WRITE && s->ctrl & CTRL_DAC2_EN)
 			val |= PCM_ENABLE_OUTPUT;
 		return put_user(val, p);
 	case SNDCTL_DSP_SETTRIGGER:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (file->f_mode & FMODE_READ) {
 			if (val & PCM_ENABLE_INPUT) {
 				if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
 					return ret;
 				s->dma_adc.enabled = 1;
 				start_adc(s);
 			} else {
 				s->dma_adc.enabled = 0;
 				stop_adc(s);
 			}
 		}
 		if (file->f_mode & FMODE_WRITE) {
 			if (val & PCM_ENABLE_OUTPUT) {
 				if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
 					return ret;
 				s->dma_dac2.enabled = 1;
 				start_dac2(s);
 			} else {
 				s->dma_dac2.enabled = 0;
 				stop_dac2(s);
 			}
 		}
 		return 0;
 	case SNDCTL_DSP_GETOSPACE:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
 		abinfo.fragsize = s->dma_dac2.fragsize;
 		count = s->dma_dac2.count;
 		if (count < 0)
 			count = 0;
                 abinfo.bytes = s->dma_dac2.dmasize - count;
                 abinfo.fragstotal = s->dma_dac2.numfrag;
                 abinfo.fragments = abinfo.bytes >> s->dma_dac2.fragshift;
 		spin_unlock_irqrestore(&s->lock, flags);
 		return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 	case SNDCTL_DSP_GETISPACE:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		if (!s->dma_adc.ready && (val = prog_dmabuf_adc(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
 		abinfo.fragsize = s->dma_adc.fragsize;
 		count = s->dma_adc.count;
 		if (count < 0)
 			count = 0;
                 abinfo.bytes = 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(argp, &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;
 		if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
                 count = s->dma_dac2.count;
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (count < 0)
 			count = 0;
 		return put_user(count, p);
         case SNDCTL_DSP_GETIPTR:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		if (!s->dma_adc.ready && (val = prog_dmabuf_adc(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
                 cinfo.bytes = s->dma_adc.total_bytes;
 		count = s->dma_adc.count;
 		if (count < 0)
 			count = 0;
                 cinfo.blocks = 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);
 		if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
 			return -EFAULT;
 		return 0;
         case SNDCTL_DSP_GETOPTR:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		if (!s->dma_dac2.ready && (val = prog_dmabuf_dac2(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
                 cinfo.bytes = s->dma_dac2.total_bytes;
 		count = s->dma_dac2.count;
 		if (count < 0)
 			count = 0;
                 cinfo.blocks = count >> s->dma_dac2.fragshift;
                 cinfo.ptr = s->dma_dac2.hwptr;
 		if (s->dma_dac2.mapped)
 			s->dma_dac2.count &= s->dma_dac2.fragsize-1;
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
 			return -EFAULT;
 		return 0;
         case SNDCTL_DSP_GETBLKSIZE:
 		if (file->f_mode & FMODE_WRITE) {
 			if ((val = prog_dmabuf_dac2(s)))
 				return val;
 			return put_user(s->dma_dac2.fragsize, p);
 		}
 		if ((val = prog_dmabuf_adc(s)))
 			return val;
 		return put_user(s->dma_adc.fragsize, p);
         case SNDCTL_DSP_SETFRAGMENT:
                 if (get_user(val, p))
 			return -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_dac2.ossfragshift = val & 0xffff;
 			s->dma_dac2.ossmaxfrags = (val >> 16) & 0xffff;
 			if (s->dma_dac2.ossfragshift < 4)
 				s->dma_dac2.ossfragshift = 4;
 			if (s->dma_dac2.ossfragshift > 15)
 				s->dma_dac2.ossfragshift = 15;
 			if (s->dma_dac2.ossmaxfrags < 4)
 				s->dma_dac2.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_dac2.subdivision))
 			return -EINVAL;
                 if (get_user(val, p))
 			return -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_dac2.subdivision = val;
 		return 0;
         case SOUND_PCM_READ_RATE:
 		return put_user((file->f_mode & FMODE_READ) ? s->adcrate : s->dac2rate, p);
         case SOUND_PCM_READ_CHANNELS:
 		return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SMB : SCTRL_P2SMB)) ? 2 : 1, p);
         case SOUND_PCM_READ_BITS:
 		return put_user((s->sctrl & ((file->f_mode & FMODE_READ) ? SCTRL_R1SEB : SCTRL_P2SEB)) ? 16 : 8, p);
         case SOUND_PCM_WRITE_FILTER:
         case SNDCTL_DSP_SETSYNCRO:
         case SOUND_PCM_READ_FILTER:
                 return -EINVAL;
 	}
 	return mixdev_ioctl(s->codec, cmd, arg);
 }
 static int es1371_open(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	struct list_head *list;
 	struct es1371_state *s;
 	for (list = devs.next; ; list = list->next) {
 		if (list == &devs)
 			return -ENODEV;
 		s = list_entry(list, struct es1371_state, devs);
 		if (!((s->dev_audio ^ minor) & ~0xf))
 			break;
 	}
        	VALIDATE_STATE(s);
 	file->private_data = s;
 	/* wait for device to become free */
 	mutex_lock(&s->open_mutex);
 	while (s->open_mode & file->f_mode) {
 		if (file->f_flags & O_NONBLOCK) {
 			mutex_unlock(&s->open_mutex);
 			return -EBUSY;
 		}
 		add_wait_queue(&s->open_wait, &wait);
 		__set_current_state(TASK_INTERRUPTIBLE);
 		mutex_unlock(&s->open_mutex);
 		schedule();
 		remove_wait_queue(&s->open_wait, &wait);
 		set_current_state(TASK_RUNNING);
 		if (signal_pending(current))
 			return -ERESTARTSYS;
 		mutex_lock(&s->open_mutex);
 	}
 	if (file->f_mode & FMODE_READ) {
 		s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags = s->dma_adc.subdivision = 0;
 		s->dma_adc.enabled = 1;
 		set_adc_rate(s, 8000);
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		s->dma_dac2.ossfragshift = s->dma_dac2.ossmaxfrags = s->dma_dac2.subdivision = 0;
 		s->dma_dac2.enabled = 1;
 		set_dac2_rate(s, 8000);
 	}
 	spin_lock_irqsave(&s->lock, flags);
 	if (file->f_mode & FMODE_READ) {
 		s->sctrl &= ~SCTRL_R1FMT;
 		if ((minor & 0xf) == SND_DEV_DSP16)
 			s->sctrl |= ES1371_FMT_S16_MONO << SCTRL_SH_R1FMT;
 		else
 			s->sctrl |= ES1371_FMT_U8_MONO << SCTRL_SH_R1FMT;
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		s->sctrl &= ~SCTRL_P2FMT;
 		if ((minor & 0xf) == SND_DEV_DSP16)
 			s->sctrl |= ES1371_FMT_S16_MONO << SCTRL_SH_P2FMT;
 		else
 			s->sctrl |= ES1371_FMT_U8_MONO << SCTRL_SH_P2FMT;
 	}
 	outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 	spin_unlock_irqrestore(&s->lock, flags);
 	s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
 	mutex_unlock(&s->open_mutex);
 	mutex_init(&s->sem);
 	return nonseekable_open(inode, file);
 }
 static int es1371_release(struct inode *inode, struct file *file)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	VALIDATE_STATE(s);
 	lock_kernel();
 	if (file->f_mode & FMODE_WRITE)
 		drain_dac2(s, file->f_flags & O_NONBLOCK);
 	mutex_lock(&s->open_mutex);
 	if (file->f_mode & FMODE_WRITE) {
 		stop_dac2(s);
 		dealloc_dmabuf(s, &s->dma_dac2);
 	}
 	if (file->f_mode & FMODE_READ) {
 		stop_adc(s);
 		dealloc_dmabuf(s, &s->dma_adc);
 	}
 	s->open_mode &= ~(file->f_mode & (FMODE_READ|FMODE_WRITE));
 	mutex_unlock(&s->open_mutex);
 	wake_up(&s->open_wait);
 	unlock_kernel();
 	return 0;
 }
 static /*const*/ struct file_operations es1371_audio_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= es1371_read,
 	.write		= es1371_write,
 	.poll		= es1371_poll,
 	.ioctl		= es1371_ioctl,
 	.mmap		= es1371_mmap,
 	.open		= es1371_open,
 	.release	= es1371_release,
 };
 /* --------------------------------------------------------------------- */
 static ssize_t es1371_write_dac(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret = 0;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	VALIDATE_STATE(s);
 	if (s->dma_dac1.mapped)
 		return -ENXIO;
 	if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
 		return ret;
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	add_wait_queue(&s->dma_dac1.wait, &wait);
 	while (count > 0) {
 		spin_lock_irqsave(&s->lock, flags);
 		if (s->dma_dac1.count < 0) {
 			s->dma_dac1.count = 0;
 			s->dma_dac1.swptr = s->dma_dac1.hwptr;
 		}
 		swptr = s->dma_dac1.swptr;
 		cnt = s->dma_dac1.dmasize-swptr;
 		if (s->dma_dac1.count + cnt > s->dma_dac1.dmasize)
 			cnt = s->dma_dac1.dmasize - s->dma_dac1.count;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			if (s->dma_dac1.enabled)
 				start_dac1(s);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				break;
 			}
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				break;
 			}
 			continue;
 		}
 		if (copy_from_user(s->dma_dac1.rawbuf + swptr, buffer, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			break;
 		}
 		swptr = (swptr + cnt) % s->dma_dac1.dmasize;
 		spin_lock_irqsave(&s->lock, flags);
 		s->dma_dac1.swptr = swptr;
 		s->dma_dac1.count += cnt;
 		s->dma_dac1.endcleared = 0;
 		spin_unlock_irqrestore(&s->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		if (s->dma_dac1.enabled)
 			start_dac1(s);
 	}
 	remove_wait_queue(&s->dma_dac1.wait, &wait);
 	set_current_state(TASK_RUNNING);
 	return ret;
 }
 /* No kernel lock - we have our own spinlock */
 static unsigned int es1371_poll_dac(struct file *file, struct poll_table_struct *wait)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	unsigned long flags;
 	unsigned int mask = 0;
 	VALIDATE_STATE(s);
 	if (!s->dma_dac1.ready && prog_dmabuf_dac1(s))
 		return 0;
 	poll_wait(file, &s->dma_dac1.wait, wait);
 	spin_lock_irqsave(&s->lock, flags);
 	es1371_update_ptr(s);
 	if (s->dma_dac1.mapped) {
 		if (s->dma_dac1.count >= (signed)s->dma_dac1.fragsize)
 			mask |= POLLOUT | POLLWRNORM;
 	} else {
 		if ((signed)s->dma_dac1.dmasize >= s->dma_dac1.count + (signed)s->dma_dac1.fragsize)
 			mask |= POLLOUT | POLLWRNORM;
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 	return mask;
 }
 static int es1371_mmap_dac(struct file *file, struct vm_area_struct *vma)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	int ret;
 	unsigned long size;
 	VALIDATE_STATE(s);
 	if (!(vma->vm_flags & VM_WRITE))
 		return -EINVAL;
 	lock_kernel();
 	if ((ret = prog_dmabuf_dac1(s)) != 0)
 		goto out;
 	ret = -EINVAL;
 	if (vma->vm_pgoff != 0)
 		goto out;
 	size = vma->vm_end - vma->vm_start;
 	if (size > (PAGE_SIZE << s->dma_dac1.buforder))
 		goto out;
 	ret = -EAGAIN;
 	if (remap_pfn_range(vma, vma->vm_start,
 			virt_to_phys(s->dma_dac1.rawbuf) >> PAGE_SHIFT,
 			size, vma->vm_page_prot))
 		goto out;
 	s->dma_dac1.mapped = 1;
 	ret = 0;
 out:
 	unlock_kernel();
 	return ret;
 }
 static int es1371_ioctl_dac(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	unsigned long flags;
         audio_buf_info abinfo;
         count_info cinfo;
 	int count;
 	int val, ret;
 	int __user *p = (int __user *)arg;
 	VALIDATE_STATE(s);
 	switch (cmd) {
 	case OSS_GETVERSION:
 		return put_user(SOUND_VERSION, p);
 	case SNDCTL_DSP_SYNC:
 		return drain_dac1(s, 0/*file->f_flags & O_NONBLOCK*/);
 	case SNDCTL_DSP_SETDUPLEX:
 		return -EINVAL;
 	case SNDCTL_DSP_GETCAPS:
 		return put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP, p);
         case SNDCTL_DSP_RESET:
 		stop_dac1(s);
 		synchronize_irq(s->irq);
 		s->dma_dac1.swptr = s->dma_dac1.hwptr = s->dma_dac1.count = s->dma_dac1.total_bytes = 0;
 		return 0;
         case SNDCTL_DSP_SPEED:
                 if (get_user(val, p))
 			return -EFAULT;
 		if (val >= 0) {
 			stop_dac1(s);
 			s->dma_dac1.ready = 0;
 			set_dac1_rate(s, val);
 		}
 		return put_user(s->dac1rate, p);
         case SNDCTL_DSP_STEREO:
 		if (get_user(val, p))
 			return -EFAULT;
 		stop_dac1(s);
 		s->dma_dac1.ready = 0;
 		spin_lock_irqsave(&s->lock, flags);
 		if (val)
 			s->sctrl |= SCTRL_P1SMB;
 		else
 			s->sctrl &= ~SCTRL_P1SMB;
 		outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 		spin_unlock_irqrestore(&s->lock, flags);
 		return 0;
         case SNDCTL_DSP_CHANNELS:
                 if (get_user(val, p))
 			return -EFAULT;
 		if (val != 0) {
 			stop_dac1(s);
 			s->dma_dac1.ready = 0;
 			spin_lock_irqsave(&s->lock, flags);
 			if (val >= 2)
 				s->sctrl |= SCTRL_P1SMB;
 			else
 				s->sctrl &= ~SCTRL_P1SMB;
 			outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 			spin_unlock_irqrestore(&s->lock, flags);
 		}
 		return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, p);
         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
                 return put_user(AFMT_S16_LE|AFMT_U8, p);
         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val != AFMT_QUERY) {
 			stop_dac1(s);
 			s->dma_dac1.ready = 0;
 			spin_lock_irqsave(&s->lock, flags);
 			if (val == AFMT_S16_LE)
 				s->sctrl |= SCTRL_P1SEB;
 			else
 				s->sctrl &= ~SCTRL_P1SEB;
 			outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 			spin_unlock_irqrestore(&s->lock, flags);
 		}
 		return put_user((s->sctrl & SCTRL_P1SEB) ? AFMT_S16_LE : AFMT_U8, p);
         case SNDCTL_DSP_POST:
                 return 0;
         case SNDCTL_DSP_GETTRIGGER:
 		return put_user((s->ctrl & CTRL_DAC1_EN) ? PCM_ENABLE_OUTPUT : 0, p);
 	case SNDCTL_DSP_SETTRIGGER:
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val & PCM_ENABLE_OUTPUT) {
 			if (!s->dma_dac1.ready && (ret = prog_dmabuf_dac1(s)))
 				return ret;
 			s->dma_dac1.enabled = 1;
 			start_dac1(s);
 		} else {
 			s->dma_dac1.enabled = 0;
 			stop_dac1(s);
 		}
 		return 0;
 	case SNDCTL_DSP_GETOSPACE:
 		if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
 		abinfo.fragsize = s->dma_dac1.fragsize;
 		count = s->dma_dac1.count;
 		if (count < 0)
 			count = 0;
                 abinfo.bytes = s->dma_dac1.dmasize - count;
                 abinfo.fragstotal = s->dma_dac1.numfrag;
                 abinfo.fragments = abinfo.bytes >> s->dma_dac1.fragshift;
 		spin_unlock_irqrestore(&s->lock, flags);
 		return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
         case SNDCTL_DSP_NONBLOCK:
                 file->f_flags |= O_NONBLOCK;
                 return 0;
         case SNDCTL_DSP_GETODELAY:
 		if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
                 count = s->dma_dac1.count;
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (count < 0)
 			count = 0;
 		return put_user(count, p);
         case SNDCTL_DSP_GETOPTR:
 		if (!s->dma_dac1.ready && (val = prog_dmabuf_dac1(s)) != 0)
 			return val;
 		spin_lock_irqsave(&s->lock, flags);
 		es1371_update_ptr(s);
                 cinfo.bytes = s->dma_dac1.total_bytes;
 		count = s->dma_dac1.count;
 		if (count < 0)
 			count = 0;
                 cinfo.blocks = count >> s->dma_dac1.fragshift;
                 cinfo.ptr = s->dma_dac1.hwptr;
 		if (s->dma_dac1.mapped)
 			s->dma_dac1.count &= s->dma_dac1.fragsize-1;
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (copy_to_user((void __user *)arg, &cinfo, sizeof(cinfo)))
 			return -EFAULT;
 		return 0;
         case SNDCTL_DSP_GETBLKSIZE:
 		if ((val = prog_dmabuf_dac1(s)))
 			return val;
                 return put_user(s->dma_dac1.fragsize, p);
         case SNDCTL_DSP_SETFRAGMENT:
                 if (get_user(val, p))
 			return -EFAULT;
 		s->dma_dac1.ossfragshift = val & 0xffff;
 		s->dma_dac1.ossmaxfrags = (val >> 16) & 0xffff;
 		if (s->dma_dac1.ossfragshift < 4)
 			s->dma_dac1.ossfragshift = 4;
 		if (s->dma_dac1.ossfragshift > 15)
 			s->dma_dac1.ossfragshift = 15;
 		if (s->dma_dac1.ossmaxfrags < 4)
 			s->dma_dac1.ossmaxfrags = 4;
 		return 0;
         case SNDCTL_DSP_SUBDIVIDE:
 		if (s->dma_dac1.subdivision)
 			return -EINVAL;
                 if (get_user(val, p))
 			return -EFAULT;
 		if (val != 1 && val != 2 && val != 4)
 			return -EINVAL;
 		s->dma_dac1.subdivision = val;
 		return 0;
         case SOUND_PCM_READ_RATE:
 		return put_user(s->dac1rate, p);
         case SOUND_PCM_READ_CHANNELS:
 		return put_user((s->sctrl & SCTRL_P1SMB) ? 2 : 1, p);
         case SOUND_PCM_READ_BITS:
 		return put_user((s->sctrl & SCTRL_P1SEB) ? 16 : 8, p);
         case SOUND_PCM_WRITE_FILTER:
         case SNDCTL_DSP_SETSYNCRO:
         case SOUND_PCM_READ_FILTER:
                 return -EINVAL;
 	}
 	return mixdev_ioctl(s->codec, cmd, arg);
 }
 static int es1371_open_dac(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	struct list_head *list;
 	struct es1371_state *s;
 	for (list = devs.next; ; list = list->next) {
 		if (list == &devs)
 			return -ENODEV;
 		s = list_entry(list, struct es1371_state, devs);
 		if (!((s->dev_dac ^ minor) & ~0xf))
 			break;
 	}
        	VALIDATE_STATE(s);
        	/* we allow opening with O_RDWR, most programs do it although they will only write */
 #if 0
 	if (file->f_mode & FMODE_READ)
 		return -EPERM;
 #endif
 	if (!(file->f_mode & FMODE_WRITE))
 		return -EINVAL;
        	file->private_data = s;
 	/* wait for device to become free */
 	mutex_lock(&s->open_mutex);
 	while (s->open_mode & FMODE_DAC) {
 		if (file->f_flags & O_NONBLOCK) {
 			mutex_unlock(&s->open_mutex);
 			return -EBUSY;
 		}
 		add_wait_queue(&s->open_wait, &wait);
 		__set_current_state(TASK_INTERRUPTIBLE);
 		mutex_unlock(&s->open_mutex);
 		schedule();
 		remove_wait_queue(&s->open_wait, &wait);
 		set_current_state(TASK_RUNNING);
 		if (signal_pending(current))
 			return -ERESTARTSYS;
 		mutex_lock(&s->open_mutex);
 	}
 	s->dma_dac1.ossfragshift = s->dma_dac1.ossmaxfrags = s->dma_dac1.subdivision = 0;
 	s->dma_dac1.enabled = 1;
 	set_dac1_rate(s, 8000);
 	spin_lock_irqsave(&s->lock, flags);
 	s->sctrl &= ~SCTRL_P1FMT;
 	if ((minor & 0xf) == SND_DEV_DSP16)
 		s->sctrl |= ES1371_FMT_S16_MONO << SCTRL_SH_P1FMT;
 	else
 		s->sctrl |= ES1371_FMT_U8_MONO << SCTRL_SH_P1FMT;
 	outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 	spin_unlock_irqrestore(&s->lock, flags);
 	s->open_mode |= FMODE_DAC;
 	mutex_unlock(&s->open_mutex);
 	return nonseekable_open(inode, file);
 }
 static int es1371_release_dac(struct inode *inode, struct file *file)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	VALIDATE_STATE(s);
 	lock_kernel();
 	drain_dac1(s, file->f_flags & O_NONBLOCK);
 	mutex_lock(&s->open_mutex);
 	stop_dac1(s);
 	dealloc_dmabuf(s, &s->dma_dac1);
 	s->open_mode &= ~FMODE_DAC;
 	mutex_unlock(&s->open_mutex);
 	wake_up(&s->open_wait);
 	unlock_kernel();
 	return 0;
 }
 static /*const*/ struct file_operations es1371_dac_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.write		= es1371_write_dac,
 	.poll		= es1371_poll_dac,
 	.ioctl		= es1371_ioctl_dac,
 	.mmap		= es1371_mmap_dac,
 	.open		= es1371_open_dac,
 	.release	= es1371_release_dac,
 };
 /* --------------------------------------------------------------------- */
 static ssize_t es1371_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret;
 	unsigned long flags;
 	unsigned ptr;
 	int cnt;
 	VALIDATE_STATE(s);
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	if (count == 0)
 		return 0;
 	ret = 0;
         add_wait_queue(&s->midi.iwait, &wait);
 	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;
 		if (cnt <= 0)
 			__set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				break;
 			}
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				break;
 			}
 			continue;
 		}
 		if (copy_to_user(buffer, s->midi.ibuf + ptr, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			break;
 		}
 		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;
 		break;
 	}
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&s->midi.iwait, &wait);
 	return ret;
 }
 static ssize_t es1371_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret;
 	unsigned long flags;
 	unsigned ptr;
 	int cnt;
 	VALIDATE_STATE(s);
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	if (count == 0)
 		return 0;
 	ret = 0;
         add_wait_queue(&s->midi.owait, &wait);
 	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) {
 			__set_current_state(TASK_INTERRUPTIBLE);
 			es1371_handle_midi(s);
 		}
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				break;
 			}
 			schedule();
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				break;
 			}
 			continue;
 		}
 		if (copy_from_user(s->midi.obuf + ptr, buffer, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			break;
 		}
 		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);
 		es1371_handle_midi(s);
 		spin_unlock_irqrestore(&s->lock, flags);
 	}
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&s->midi.owait, &wait);
 	return ret;
 }
 /* No kernel lock - we have our own spinlock */
 static unsigned int es1371_midi_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct es1371_state *s = (struct es1371_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 es1371_midi_open(struct inode *inode, struct file *file)
 {
 	int minor = iminor(inode);
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	struct list_head *list;
 	struct es1371_state *s;
 	for (list = devs.next; ; list = list->next) {
 		if (list == &devs)
 			return -ENODEV;
 		s = list_entry(list, struct es1371_state, devs);
 		if (s->dev_midi == minor)
 			break;
 	}
        	VALIDATE_STATE(s);
 	file->private_data = s;
 	/* wait for device to become free */
 	mutex_lock(&s->open_mutex);
 	while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
 		if (file->f_flags & O_NONBLOCK) {
 			mutex_unlock(&s->open_mutex);
 			return -EBUSY;
 		}
 		add_wait_queue(&s->open_wait, &wait);
 		__set_current_state(TASK_INTERRUPTIBLE);
 		mutex_unlock(&s->open_mutex);
 		schedule();
 		remove_wait_queue(&s->open_wait, &wait);
 		set_current_state(TASK_RUNNING);
 		if (signal_pending(current))
 			return -ERESTARTSYS;
 		mutex_lock(&s->open_mutex);
 	}
 	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;
 		outb(UCTRL_CNTRL_SWR, s->io+ES1371_REG_UART_CONTROL);
 		outb(0, s->io+ES1371_REG_UART_CONTROL);
 		outb(0, s->io+ES1371_REG_UART_TEST);
 	}
 	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;
 	}
 	s->ctrl |= CTRL_UART_EN;
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	es1371_handle_midi(s);
 	spin_unlock_irqrestore(&s->lock, flags);
 	s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
 	mutex_unlock(&s->open_mutex);
 	return nonseekable_open(inode, file);
 }
 static int es1371_midi_release(struct inode *inode, struct file *file)
 {
 	struct es1371_state *s = (struct es1371_state *)file->private_data;
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	unsigned count, tmo;
 	VALIDATE_STATE(s);
 	lock_kernel();
 	if (file->f_mode & FMODE_WRITE) {
 		add_wait_queue(&s->midi.owait, &wait);
 		for (;;) {
 			__set_current_state(TASK_INTERRUPTIBLE);
 			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)
 				break;
 			tmo = (count * HZ) / 3100;
 			if (!schedule_timeout(tmo ? : 1) && tmo)
 				printk(KERN_DEBUG PFX "midi timed out??\n");
 		}
 		remove_wait_queue(&s->midi.owait, &wait);
 		set_current_state(TASK_RUNNING);
 	}
 	mutex_lock(&s->open_mutex);
 	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))) {
 		s->ctrl &= ~CTRL_UART_EN;
 		outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	}
 	spin_unlock_irqrestore(&s->lock, flags);
 	mutex_unlock(&s->open_mutex);
 	wake_up(&s->open_wait);
 	unlock_kernel();
 	return 0;
 }
 static /*const*/ struct file_operations es1371_midi_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= es1371_midi_read,
 	.write		= es1371_midi_write,
 	.poll		= es1371_midi_poll,
 	.open		= es1371_midi_open,
 	.release	= es1371_midi_release,
 };
 /* --------------------------------------------------------------------- */
 /*
  * for debugging purposes, we'll create a proc device that dumps the
  * CODEC chipstate
  */
 #ifdef ES1371_DEBUG
 static int proc_es1371_dump (char *buf, char **start, off_t fpos, int length, int *eof, void *data)
 {
 	struct es1371_state *s;
         int cnt, len = 0;
 	if (list_empty(&devs))
 		return 0;
 	s = list_entry(devs.next, struct es1371_state, devs);
         /* print out header */
         len += sprintf(buf + len, "\t\tCreative ES137x Debug Dump-o-matic\n");
         /* print out CODEC state */
         len += sprintf (buf + len, "AC97 CODEC state\n");
 	for (cnt=0; cnt <= 0x7e; cnt = cnt +2)
                 len+= sprintf (buf + len, "reg:0x%02x  val:0x%04x\n", cnt, rdcodec(s->codec, cnt));
         if (fpos >=len){
                 *start = buf;
                 *eof =1;
                 return 0;
         }
         *start = buf + fpos;
         if ((len -= fpos) > length)
                 return length;
         *eof =1;
         return len;
 }
 #endif /* ES1371_DEBUG */
 /* --------------------------------------------------------------------- */
 /* maximum number of devices; only used for command line params */
 #define NR_DEVICE 5
 static int spdif[NR_DEVICE];
 static int nomix[NR_DEVICE];
 static int amplifier[NR_DEVICE];
 static unsigned int devindex;
 module_param_array(spdif, bool, NULL, 0);
 MODULE_PARM_DESC(spdif, "if 1 the output is in S/PDIF digital mode");
 module_param_array(nomix, bool, NULL, 0);
 MODULE_PARM_DESC(nomix, "if 1 no analog audio is mixed to the digital output");
 module_param_array(amplifier, bool, NULL, 0);
 MODULE_PARM_DESC(amplifier, "Set to 1 if the machine needs the amp control enabling (many laptops)");
 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
 MODULE_DESCRIPTION("ES1371 AudioPCI97 Driver");
 MODULE_LICENSE("GPL");
 /* --------------------------------------------------------------------- */
 static struct initvol {
 	int mixch;
 	int vol;
 } initvol[] __devinitdata = {
 	{ SOUND_MIXER_WRITE_LINE, 0x4040 },
 	{ SOUND_MIXER_WRITE_CD, 0x4040 },
 	{ MIXER_WRITE(SOUND_MIXER_VIDEO), 0x4040 },
 	{ SOUND_MIXER_WRITE_LINE1, 0x4040 },
 	{ SOUND_MIXER_WRITE_PCM, 0x4040 },
 	{ SOUND_MIXER_WRITE_VOLUME, 0x4040 },
 	{ MIXER_WRITE(SOUND_MIXER_PHONEOUT), 0x4040 },
 	{ SOUND_MIXER_WRITE_OGAIN, 0x4040 },
 	{ MIXER_WRITE(SOUND_MIXER_PHONEIN), 0x4040 },
 	{ SOUND_MIXER_WRITE_SPEAKER, 0x4040 },
 	{ SOUND_MIXER_WRITE_MIC, 0x4040 },
 	{ SOUND_MIXER_WRITE_RECLEV, 0x4040 },
 	{ SOUND_MIXER_WRITE_IGAIN, 0x4040 }
 };
 static struct
 {
 	short svid, sdid;
 } amplifier_needed[] =
 {
 	{ 0x107B, 0x2150 },		/* Gateway Solo 2150 */
 	{ 0x13BD, 0x100C },		/* Mebius PC-MJ100V */
 	{ 0x1102, 0x5938 },		/* Targa Xtender 300 */
 	{ 0x1102, 0x8938 },		/* IPC notebook */
 	{ PCI_ANY_ID, PCI_ANY_ID }
 };
 #ifdef SUPPORT_JOYSTICK
 static int __devinit es1371_register_gameport(struct es1371_state *s)
 {
 	struct gameport *gp;
 	int gpio;
 	for (gpio = 0x218; gpio >= 0x200; gpio -= 0x08)
 		if (request_region(gpio, JOY_EXTENT, "es1371"))
 			break;
 	if (gpio < 0x200) {
 		printk(KERN_ERR PFX "no free joystick address found\n");
 		return -EBUSY;
 	}
 	s->gameport = gp = gameport_allocate_port();
 	if (!gp) {
 		printk(KERN_ERR PFX "can not allocate memory for gameport\n");
 		release_region(gpio, JOY_EXTENT);
 		return -ENOMEM;
 	}
 	gameport_set_name(gp, "ESS1371 Gameport");
 	gameport_set_phys(gp, "isa%04x/gameport0", gpio);
 	gp->dev.parent = &s->dev->dev;
 	gp->io = gpio;
 	s->ctrl |= CTRL_JYSTK_EN | (((gpio >> 3) & CTRL_JOY_MASK) << CTRL_JOY_SHIFT);
 	outl(s->ctrl, s->io + ES1371_REG_CONTROL);
 	gameport_register_port(gp);
 	return 0;
 }
 static inline void es1371_unregister_gameport(struct es1371_state *s)
 {
 	if (s->gameport) {
 		int gpio = s->gameport->io;
 		gameport_unregister_port(s->gameport);
 		release_region(gpio, JOY_EXTENT);
 	}
 }
 #else
 static inline int es1371_register_gameport(struct es1371_state *s) { return -ENOSYS; }
 static inline void es1371_unregister_gameport(struct es1371_state *s) { }
 #endif /* SUPPORT_JOYSTICK */
 static int __devinit es1371_probe(struct pci_dev *pcidev, const struct pci_device_id *pciid)
 {
 	struct es1371_state *s;
 	mm_segment_t fs;
 	int i, val, res = -1;
 	int idx;
 	unsigned long tmo;
 	signed long tmo2;
 	unsigned int cssr;
 	if ((res=pci_enable_device(pcidev)))
 		return res;
 	if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_IO))
 		return -ENODEV;
 	if (pcidev->irq == 0)
 		return -ENODEV;
 	i = pci_set_dma_mask(pcidev, DMA_32BIT_MASK);
 	if (i) {
 		printk(KERN_WARNING "es1371: architecture does not support 32bit PCI busmaster DMA\n");
 		return i;
 	}
 	if (!(s = kmalloc(sizeof(struct es1371_state), GFP_KERNEL))) {
 		printk(KERN_WARNING PFX "out of memory\n");
 		return -ENOMEM;
 	}
 	memset(s, 0, sizeof(struct es1371_state));
 	s->codec = ac97_alloc_codec();
 	if(s->codec == NULL)
 		goto err_codec;
 	init_waitqueue_head(&s->dma_adc.wait);
 	init_waitqueue_head(&s->dma_dac1.wait);
 	init_waitqueue_head(&s->dma_dac2.wait);
 	init_waitqueue_head(&s->open_wait);
 	init_waitqueue_head(&s->midi.iwait);
 	init_waitqueue_head(&s->midi.owait);
 	mutex_init(&s->open_mutex);
 	spin_lock_init(&s->lock);
 	s->magic = ES1371_MAGIC;
 	s->dev = pcidev;
 	s->io = pci_resource_start(pcidev, 0);
 	s->irq = pcidev->irq;
 	s->vendor = pcidev->vendor;
 	s->device = pcidev->device;
 	pci_read_config_byte(pcidev, PCI_REVISION_ID, &s->rev);
 	s->codec->private_data = s;
 	s->codec->id = 0;
 	s->codec->codec_read = rdcodec;
 	s->codec->codec_write = wrcodec;
 	printk(KERN_INFO PFX "found chip, vendor id 0x%04x device id 0x%04x revision 0x%02x\n",
 	       s->vendor, s->device, s->rev);
 	if (!request_region(s->io, ES1371_EXTENT, "es1371")) {
 		printk(KERN_ERR PFX "io ports %#lx-%#lx in use\n", s->io, s->io+ES1371_EXTENT-1);
 		res = -EBUSY;
 		goto err_region;
 	}
 	if ((res=request_irq(s->irq, es1371_interrupt, IRQF_SHARED, "es1371",s))) {
 		printk(KERN_ERR PFX "irq %u in use\n", s->irq);
 		goto err_irq;
 	}
 	printk(KERN_INFO PFX "found es1371 rev %d at io %#lx irq %u\n",
 	       s->rev, s->io, s->irq);
 	/* register devices */
 	if ((res=(s->dev_audio = register_sound_dsp(&es1371_audio_fops,-1)))<0)
 		goto err_dev1;
 	if ((res=(s->codec->dev_mixer = register_sound_mixer(&es1371_mixer_fops, -1))) < 0)
 		goto err_dev2;
 	if ((res=(s->dev_dac = register_sound_dsp(&es1371_dac_fops, -1))) < 0)
 		goto err_dev3;
 	if ((res=(s->dev_midi = register_sound_midi(&es1371_midi_fops, -1)))<0 )
 		goto err_dev4;
 #ifdef ES1371_DEBUG
 	/* initialize the debug proc device */
 	s->ps = create_proc_read_entry("es1371",0,NULL,proc_es1371_dump,NULL);
 #endif /* ES1371_DEBUG */
 	/* initialize codec registers */
 	s->ctrl = 0;
 	/* Check amplifier requirements */
 	if (amplifier[devindex])
 		s->ctrl |= CTRL_GPIO_OUT0;
 	else for(idx = 0; amplifier_needed[idx].svid != PCI_ANY_ID; idx++)
 	{
 		if(pcidev->subsystem_vendor == amplifier_needed[idx].svid &&
 		   pcidev->subsystem_device == amplifier_needed[idx].sdid)
 		{
                     	s->ctrl |= CTRL_GPIO_OUT0;   /* turn internal amplifier on */
                     	printk(KERN_INFO PFX "Enabling internal amplifier.\n");
 		}
 	}
 	s->sctrl = 0;
 	cssr = 0;
 	s->spdif_volume = -1;
 	/* check to see if s/pdif mode is being requested */
 	if (spdif[devindex]) {
 		if (s->rev >= 4) {
 			printk(KERN_INFO PFX "enabling S/PDIF output\n");
 			s->spdif_volume = 0;
 			cssr |= STAT_EN_SPDIF;
 			s->ctrl |= CTRL_SPDIFEN_B;
 			if (nomix[devindex]) /* don't mix analog inputs to s/pdif output */
 				s->ctrl |= CTRL_RECEN_B;
 		} else {
 			printk(KERN_ERR PFX "revision %d does not support S/PDIF\n", s->rev);
 		}
 	}
 	/* initialize the chips */
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	outl(s->sctrl, s->io+ES1371_REG_SERIAL_CONTROL);
 	outl(LEGACY_JFAST, s->io+ES1371_REG_LEGACY);
 	pci_set_master(pcidev);  /* enable bus mastering */
 	/* if we are a 5880 turn on the AC97 */
 	if (s->vendor == PCI_VENDOR_ID_ENSONIQ &&
 	    ((s->device == PCI_DEVICE_ID_ENSONIQ_CT5880 && s->rev >= CT5880REV_CT5880_C) ||
 	     (s->device == PCI_DEVICE_ID_ENSONIQ_ES1371 && s->rev == ES1371REV_CT5880_A) ||
 	     (s->device == PCI_DEVICE_ID_ENSONIQ_ES1371 && s->rev == ES1371REV_ES1373_8))) {
 		cssr |= CSTAT_5880_AC97_RST;
 		outl(cssr, s->io+ES1371_REG_STATUS);
 		/* need to delay around 20ms(bleech) to give
 		   some CODECs enough time to wakeup */
 		tmo = jiffies + (HZ / 50) + 1;
 		for (;;) {
 			tmo2 = tmo - jiffies;
 			if (tmo2 <= 0)
 				break;
 			schedule_timeout(tmo2);
 		}
 	}
 	/* AC97 warm reset to start the bitclk */
 	outl(s->ctrl | CTRL_SYNCRES, s->io+ES1371_REG_CONTROL);
 	udelay(2);
 	outl(s->ctrl, s->io+ES1371_REG_CONTROL);
 	/* init the sample rate converter */
 	src_init(s);
 	/* codec init */
 	if (!ac97_probe_codec(s->codec)) {
 		res = -ENODEV;
 		goto err_gp;
 	}
 	/* set default values */
 	fs = get_fs();
 	set_fs(KERNEL_DS);
 	val = SOUND_MASK_LINE;
 	mixdev_ioctl(s->codec, SOUND_MIXER_WRITE_RECSRC, (unsigned long)&val);
 	for (i = 0; i < sizeof(initvol)/sizeof(initvol[0]); i++) {
 		val = initvol[i].vol;
 		mixdev_ioctl(s->codec, initvol[i].mixch, (unsigned long)&val);
 	}
 	/* mute master and PCM when in S/PDIF mode */
 	if (s->spdif_volume != -1) {
 		val = 0x0000;
 		s->codec->mixer_ioctl(s->codec, SOUND_MIXER_WRITE_VOLUME, (unsigned long)&val);
 		s->codec->mixer_ioctl(s->codec, SOUND_MIXER_WRITE_PCM, (unsigned long)&val);
 	}
 	set_fs(fs);
 	/* turn on S/PDIF output driver if requested */
 	outl(cssr, s->io+ES1371_REG_STATUS);
 	es1371_register_gameport(s);
 	/* store it in the driver field */
 	pci_set_drvdata(pcidev, s);
 	/* put it into driver list */
 	list_add_tail(&s->devs, &devs);
 	/* increment devindex */
 	if (devindex < NR_DEVICE-1)
 		devindex++;
 	return 0;
  err_gp:
 #ifdef ES1371_DEBUG
 	if (s->ps)
 		remove_proc_entry("es1371", NULL);
 #endif
 	unregister_sound_midi(s->dev_midi);
  err_dev4:
 	unregister_sound_dsp(s->dev_dac);
  err_dev3:
 	unregister_sound_mixer(s->codec->dev_mixer);
  err_dev2:
 	unregister_sound_dsp(s->dev_audio);
  err_dev1:
 	printk(KERN_ERR PFX "cannot register misc device\n");
 	free_irq(s->irq, s);
  err_irq:
 	release_region(s->io, ES1371_EXTENT);
  err_region:
  err_codec:
 	ac97_release_codec(s->codec);
 	kfree(s);
 	return res;
 }
 static void __devexit es1371_remove(struct pci_dev *dev)
 {
 	struct es1371_state *s = pci_get_drvdata(dev);
 	if (!s)
 		return;
 	list_del(&s->devs);
 #ifdef ES1371_DEBUG
 	if (s->ps)
 		remove_proc_entry("es1371", NULL);
 #endif /* ES1371_DEBUG */
 	outl(0, s->io+ES1371_REG_CONTROL); /* switch everything off */
 	outl(0, s->io+ES1371_REG_SERIAL_CONTROL); /* clear serial interrupts */
 	synchronize_irq(s->irq);
 	free_irq(s->irq, s);
 	es1371_unregister_gameport(s);
 	release_region(s->io, ES1371_EXTENT);
 	unregister_sound_dsp(s->dev_audio);
 	unregister_sound_mixer(s->codec->dev_mixer);
 	unregister_sound_dsp(s->dev_dac);
 	unregister_sound_midi(s->dev_midi);
 	ac97_release_codec(s->codec);
 	kfree(s);
 	pci_set_drvdata(dev, NULL);
 }
 static struct pci_device_id id_table[] = {
 	{ PCI_VENDOR_ID_ENSONIQ, PCI_DEVICE_ID_ENSONIQ_ES1371, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 	{ PCI_VENDOR_ID_ENSONIQ, PCI_DEVICE_ID_ENSONIQ_CT5880, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 	{ PCI_VENDOR_ID_ECTIVA, PCI_DEVICE_ID_ECTIVA_EV1938, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 	{ 0, }
 };
 MODULE_DEVICE_TABLE(pci, id_table);
 static struct pci_driver es1371_driver = {
 	.name		= "es1371",
 	.id_table	= id_table,
 	.probe		= es1371_probe,
 	.remove		= __devexit_p(es1371_remove),
 };
 static int __init init_es1371(void)
 {
 	printk(KERN_INFO PFX "version v0.32 time " __TIME__ " " __DATE__ "\n");
 	return pci_register_driver(&es1371_driver);
 }
 static void __exit cleanup_es1371(void)
 {
 	printk(KERN_INFO PFX "unloading\n");
 	pci_unregister_driver(&es1371_driver);
 }
 module_init(init_es1371);
 module_exit(cleanup_es1371);
 /* --------------------------------------------------------------------- */
 #ifndef MODULE
 /* format is: es1371=[spdif,[nomix,[amplifier]]] */
 static int __init es1371_setup(char *str)
 {
 	static unsigned __initdata nr_dev = 0;
 	if (nr_dev >= NR_DEVICE)
 		return 0;
 	(void)
         ((get_option(&str, &spdif[nr_dev]) == 2)
          && (get_option(&str, &nomix[nr_dev]) == 2)
          && (get_option(&str, &amplifier[nr_dev])));
 	nr_dev++;
 	return 1;
 }
 __setup("es1371=", es1371_setup);
 #endif /* MODULE */

sound/oss/i810_audio.c

Diff comments View file @ f23f6e0

 /*
  *	Intel i810 and friends ICH driver for Linux
  *	Alan Cox <alan@redhat.com>
  *
  *  Built from:
  *	Low level code:  Zach Brown (original nonworking i810 OSS driver)
  *			 Jaroslav Kysela <perex@suse.cz> (working ALSA driver)
  *
  *	Framework: Thomas Sailer <sailer@ife.ee.ethz.ch>
  *	Extended by: Zach Brown <zab@redhat.com>
  *			and others..
  *
  *  Hardware Provided By:
  *	Analog Devices (A major AC97 codec maker)
  *	Intel Corp  (you've probably heard of them already)
  *
  *  AC97 clues and assistance provided by
  *	Analog Devices
  *	Zach 'Fufu' Brown
  *	Jeff Garzik
  *
  *	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.
  *
  *
  *	Intel 810 theory of operation
  *
  *	The chipset provides three DMA channels that talk to an AC97
  *	CODEC (AC97 is a digital/analog mixer standard). At its simplest
  *	you get 48Khz audio with basic volume and mixer controls. At the
  *	best you get rate adaption in the codec. We set the card up so
  *	that we never take completion interrupts but instead keep the card
  *	chasing its tail around a ring buffer. This is needed for mmap
  *	mode audio and happens to work rather well for non-mmap modes too.
  *
  *	The board has one output channel for PCM audio (supported) and
  *	a stereo line in and mono microphone input. Again these are normally
  *	locked to 48Khz only. Right now recording is not finished.
  *
  *	There is no midi support, no synth support. Use timidity. To get
  *	esd working you need to use esd -r 48000 as it won't probe 48KHz
  *	by default. mpg123 can't handle 48Khz only audio so use xmms.
  *
  *	Fix The Sound On Dell
  *
  *	Not everyone uses 48KHz. We know of no way to detect this reliably
  *	and certainly not to get the right data. If your i810 audio sounds
  *	stupid you may need to investigate other speeds. According to Analog
  *	they tend to use a 14.318MHz clock which gives you a base rate of
  *	41194Hz.
  *
  *	This is available via the 'ftsodell=1' option.
  *
  *	If you need to force a specific rate set the clocking= option
  *
  *	This driver is cursed. (Ben LaHaise)
  *
  *  ICH 3 caveats
  *	Intel errata #7 for ICH3 IO. We need to disable SMI stuff
  *	when codec probing. [Not Yet Done]
  *
  *  ICH 4 caveats
  *
  *	The ICH4 has the feature, that the codec ID doesn't have to be
  *	congruent with the IO connection.
  *
  *	Therefore, from driver version 0.23 on, there is a "codec ID" <->
  *	"IO register base offset" mapping (card->ac97_id_map) field.
  *
  *	Juergen "George" Sawinski (jsaw)
  */
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/sound.h>
 #include <linux/slab.h>
 #include <linux/soundcard.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <asm/io.h>
 #include <asm/dma.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
 #include <linux/ac97_codec.h>
 #include <linux/bitops.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 #include <asm/uaccess.h>
 #define DRIVER_VERSION "1.01"
 #define MODULOP2(a, b) ((a) & ((b) - 1))
 #define MASKP2(a, b) ((a) & ~((b) - 1))
 static int ftsodell;
 static int strict_clocking;
 static unsigned int clocking;
 static int spdif_locked;
 static int ac97_quirk = AC97_TUNE_DEFAULT;
 //#define DEBUG
 //#define DEBUG2
 //#define DEBUG_INTERRUPTS
 //#define DEBUG_MMAP
 //#define DEBUG_MMIO
 #define ADC_RUNNING	1
 #define DAC_RUNNING	2
 #define I810_FMT_16BIT	1
 #define I810_FMT_STEREO	2
 #define I810_FMT_MASK	3
 #define SPDIF_ON	0x0004
 #define SURR_ON		0x0010
 #define CENTER_LFE_ON	0x0020
 #define VOL_MUTED	0x8000
 /* the 810's array of pointers to data buffers */
 struct sg_item {
 #define BUSADDR_MASK	0xFFFFFFFE
 	u32 busaddr;
 #define CON_IOC 	0x80000000 /* interrupt on completion */
 #define CON_BUFPAD	0x40000000 /* pad underrun with last sample, else 0 */
 #define CON_BUFLEN_MASK	0x0000ffff /* buffer length in samples */
 	u32 control;
 };
 /* an instance of the i810 channel */
 #define SG_LEN 32
 struct i810_channel
 {
 	/* these sg guys should probably be allocated
 	   separately as nocache. Must be 8 byte aligned */
 	struct sg_item sg[SG_LEN];	/* 32*8 */
 	u32 offset;			/* 4 */
 	u32 port;			/* 4 */
 	u32 used;
 	u32 num;
 };
 /*
  * we have 3 separate dma engines.  pcm in, pcm out, and mic.
  * each dma engine has controlling registers.  These goofy
  * names are from the datasheet, but make it easy to write
  * code while leafing through it.
  *
  * ICH4 has 6 dma engines, pcm in, pcm out, mic, pcm in 2,
  * mic in 2, s/pdif.   Of special interest is the fact that
  * the upper 3 DMA engines on the ICH4 *must* be accessed
  * via mmio access instead of pio access.
  */
 #define ENUM_ENGINE(PRE,DIG) 									\
 enum {												\
 	PRE##_BASE =	0x##DIG##0,		/* Base Address */				\
 	PRE##_BDBAR =	0x##DIG##0,		/* Buffer Descriptor list Base Address */	\
 	PRE##_CIV =	0x##DIG##4,		/* Current Index Value */			\
 	PRE##_LVI =	0x##DIG##5,		/* Last Valid Index */				\
 	PRE##_SR =	0x##DIG##6,		/* Status Register */				\
 	PRE##_PICB =	0x##DIG##8,		/* Position In Current Buffer */		\
 	PRE##_PIV =	0x##DIG##a,		/* Prefetched Index Value */			\
 	PRE##_CR =	0x##DIG##b		/* Control Register */				\
 }
 ENUM_ENGINE(OFF,0);	/* Offsets */
 ENUM_ENGINE(PI,0);	/* PCM In */
 ENUM_ENGINE(PO,1);	/* PCM Out */
 ENUM_ENGINE(MC,2);	/* Mic In */
 enum {
 	GLOB_CNT =	0x2c,			/* Global Control */
 	GLOB_STA = 	0x30,			/* Global Status */
 	CAS	 = 	0x34			/* Codec Write Semaphore Register */
 };
 ENUM_ENGINE(MC2,4);     /* Mic In 2 */
 ENUM_ENGINE(PI2,5);     /* PCM In 2 */
 ENUM_ENGINE(SP,6);      /* S/PDIF */
 enum {
 	SDM =           0x80                    /* SDATA_IN Map Register */
 };
 /* interrupts for a dma engine */
 #define DMA_INT_FIFO		(1<<4)  /* fifo under/over flow */
 #define DMA_INT_COMPLETE	(1<<3)  /* buffer read/write complete and ioc set */
 #define DMA_INT_LVI		(1<<2)  /* last valid done */
 #define DMA_INT_CELV		(1<<1)  /* last valid is current */
 #define DMA_INT_DCH		(1)	/* DMA Controller Halted (happens on LVI interrupts) */
 #define DMA_INT_MASK (DMA_INT_FIFO|DMA_INT_COMPLETE|DMA_INT_LVI)
 /* interrupts for the whole chip */
 #define INT_SEC		(1<<11)
 #define INT_PRI		(1<<10)
 #define INT_MC		(1<<7)
 #define INT_PO		(1<<6)
 #define INT_PI		(1<<5)
 #define INT_MO		(1<<2)
 #define INT_NI		(1<<1)
 #define INT_GPI		(1<<0)
 #define INT_MASK (INT_SEC|INT_PRI|INT_MC|INT_PO|INT_PI|INT_MO|INT_NI|INT_GPI)
 /* magic numbers to protect our data structures */
 #define I810_CARD_MAGIC		0x5072696E /* "Prin" */
 #define I810_STATE_MAGIC	0x63657373 /* "cess" */
 #define I810_DMA_MASK		0xffffffff /* DMA buffer mask for pci_alloc_consist */
 #define NR_HW_CH		3
 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
 #define NR_AC97                 4
 /* Please note that an 8bit mono stream is not valid on this card, you must have a 16bit */
 /* stream at a minimum for this card to be happy */
 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 /* Samples are 16bit values, so we are shifting to a word, not to a byte, hence shift */
 /* values are one less than might be expected */
 static const unsigned sample_shift[] = { -1, 0, 0, 1 };
 enum {
 	ICH82801AA = 0,
 	ICH82901AB,
 	INTEL440MX,
 	INTELICH2,
 	INTELICH3,
 	INTELICH4,
 	INTELICH5,
 	SI7012,
 	NVIDIA_NFORCE,
 	AMD768,
 	AMD8111
 };
 static char * card_names[] = {
 	"Intel ICH 82801AA",
 	"Intel ICH 82901AB",
 	"Intel 440MX",
 	"Intel ICH2",
 	"Intel ICH3",
 	"Intel ICH4",
 	"Intel ICH5",
 	"SiS 7012",
 	"NVIDIA nForce Audio",
 	"AMD 768",
 	"AMD-8111 IOHub"
 };
 /* These are capabilities (and bugs) the chipsets _can_ have */
 static struct {
 	int16_t      nr_ac97;
 #define CAP_MMIO                 0x0001
 #define CAP_20BIT_AUDIO_SUPPORT  0x0002
 	u_int16_t flags;
 } card_cap[] = {
 	{  1, 0x0000 }, /* ICH82801AA */
 	{  1, 0x0000 }, /* ICH82901AB */
 	{  1, 0x0000 }, /* INTEL440MX */
 	{  1, 0x0000 }, /* INTELICH2 */
 	{  2, 0x0000 }, /* INTELICH3 */
  	{  3, 0x0003 }, /* INTELICH4 */
 	{  3, 0x0003 }, /* INTELICH5 */
 	/*@FIXME to be verified*/	{  2, 0x0000 }, /* SI7012 */
 	/*@FIXME to be verified*/	{  2, 0x0000 }, /* NVIDIA_NFORCE */
 	/*@FIXME to be verified*/	{  2, 0x0000 }, /* AMD768 */
 	/*@FIXME to be verified*/	{  3, 0x0001 }, /* AMD8111 */
 };
 static struct pci_device_id i810_pci_tbl [] = {
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ICH82801AA},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ICH82901AB},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_440MX,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTEL440MX},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_4,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH2},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH3},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH5},
 	{PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7012,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SI7012},
 	{PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP1_AUDIO,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
 	{PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP2_AUDIO,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
 	{PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
 	{PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_OPUS_7445,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD768},
 	{PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_AUDIO,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD8111},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_5,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
 	{PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_18,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, INTELICH4},
 	{PCI_VENDOR_ID_NVIDIA,  PCI_DEVICE_ID_NVIDIA_CK804_AUDIO,
 	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, NVIDIA_NFORCE},
 	{0,}
 };
 MODULE_DEVICE_TABLE (pci, i810_pci_tbl);
 #ifdef CONFIG_PM
 #define PM_SUSPENDED(card) (card->pm_suspended)
 #else
 #define PM_SUSPENDED(card) (0)
 #endif
 /* "software" or virtual channel, an instance of opened /dev/dsp */
 struct i810_state {
 	unsigned int magic;
 	struct i810_card *card;	/* Card info */
 	/* single open lock mechanism, only used for recording */
 	struct mutex open_mutex;
 	wait_queue_head_t open_wait;
 	/* file mode */
 	mode_t open_mode;
 	/* virtual channel number */
 	int virt;
 #ifdef CONFIG_PM
 	unsigned int pm_saved_dac_rate,pm_saved_adc_rate;
 #endif
 	struct dmabuf {
 		/* wave sample stuff */
 		unsigned int rate;
 		unsigned char fmt, enable, trigger;
 		/* hardware channel */
 		struct i810_channel *read_channel;
 		struct i810_channel *write_channel;
 		/* OSS buffer management stuff */
 		void *rawbuf;
 		dma_addr_t dma_handle;
 		unsigned buforder;
 		unsigned numfrag;
 		unsigned fragshift;
 		/* our buffer acts like a circular ring */
 		unsigned hwptr;		/* where dma last started, updated by update_ptr */
 		unsigned swptr;		/* where driver last clear/filled, updated by read/write */
 		int count;		/* bytes to be consumed or been generated by dma machine */
 		unsigned total_bytes;	/* total bytes dmaed by hardware */
 		unsigned error;		/* number of over/underruns */
 		wait_queue_head_t wait;	/* put process on wait queue when no more space in buffer */
 		/* redundant, but makes calculations easier */
 		/* what the hardware uses */
 		unsigned dmasize;
 		unsigned fragsize;
 		unsigned fragsamples;
 		/* what we tell the user to expect */
 		unsigned userfrags;
 		unsigned userfragsize;
 		/* OSS stuff */
 		unsigned mapped:1;
 		unsigned ready:1;
 		unsigned update_flag;
 		unsigned ossfragsize;
 		unsigned ossmaxfrags;
 		unsigned subdivision;
 	} dmabuf;
 };
 struct i810_card {
 	unsigned int magic;
 	/* We keep i810 cards in a linked list */
 	struct i810_card *next;
 	/* The i810 has a certain amount of cross channel interaction
 	   so we use a single per card lock */
 	spinlock_t lock;
 	/* Control AC97 access serialization */
 	spinlock_t ac97_lock;
 	/* PCI device stuff */
 	struct pci_dev * pci_dev;
 	u16 pci_id;
 	u16 pci_id_internal; /* used to access card_cap[] */
 #ifdef CONFIG_PM
 	u16 pm_suspended;
 	int pm_saved_mixer_settings[SOUND_MIXER_NRDEVICES][NR_AC97];
 #endif
 	/* soundcore stuff */
 	int dev_audio;
 	/* structures for abstraction of hardware facilities, codecs, banks and channels*/
 	u16    ac97_id_map[NR_AC97];
 	struct ac97_codec *ac97_codec[NR_AC97];
 	struct i810_state *states[NR_HW_CH];
 	struct i810_channel *channel;	/* 1:1 to states[] but diff. lifetime */
 	dma_addr_t chandma;
 	u16 ac97_features;
 	u16 ac97_status;
 	u16 channels;
 	/* hardware resources */
 	unsigned long ac97base;
 	unsigned long iobase;
 	u32 irq;
 	unsigned long ac97base_mmio_phys;
 	unsigned long iobase_mmio_phys;
 	u_int8_t __iomem *ac97base_mmio;
 	u_int8_t __iomem *iobase_mmio;
 	int           use_mmio;
 	/* Function support */
 	struct i810_channel *(*alloc_pcm_channel)(struct i810_card *);
 	struct i810_channel *(*alloc_rec_pcm_channel)(struct i810_card *);
 	struct i810_channel *(*alloc_rec_mic_channel)(struct i810_card *);
 	void (*free_pcm_channel)(struct i810_card *, int chan);
 	/* We have a *very* long init time possibly, so use this to block */
 	/* attempts to open our devices before we are ready (stops oops'es) */
 	int initializing;
 };
 /* extract register offset from codec struct */
 #define IO_REG_OFF(codec) (((struct i810_card *) codec->private_data)->ac97_id_map[codec->id])
 #define I810_IOREAD(size, type, card, off)				\
 ({									\
 	type val;							\
 	if (card->use_mmio)						\
 		val=read##size(card->iobase_mmio+off);			\
 	else								\
 		val=in##size(card->iobase+off);				\
 	val;								\
 })
 #define I810_IOREADL(card, off)		I810_IOREAD(l, u32, card, off)
 #define I810_IOREADW(card, off)		I810_IOREAD(w, u16, card, off)
 #define I810_IOREADB(card, off)		I810_IOREAD(b, u8,  card, off)
 #define I810_IOWRITE(size, val, card, off)				\
 ({									\
 	if (card->use_mmio)						\
 		write##size(val, card->iobase_mmio+off);		\
 	else								\
 		out##size(val, card->iobase+off);			\
 })
 #define I810_IOWRITEL(val, card, off)	I810_IOWRITE(l, val, card, off)
 #define I810_IOWRITEW(val, card, off)	I810_IOWRITE(w, val, card, off)
 #define I810_IOWRITEB(val, card, off)	I810_IOWRITE(b, val, card, off)
 #define GET_CIV(card, port) MODULOP2(I810_IOREADB((card), (port) + OFF_CIV), SG_LEN)
 #define GET_LVI(card, port) MODULOP2(I810_IOREADB((card), (port) + OFF_LVI), SG_LEN)
 /* set LVI from CIV */
 #define CIV_TO_LVI(card, port, off) \
 	I810_IOWRITEB(MODULOP2(GET_CIV((card), (port)) + (off), SG_LEN), (card), (port) + OFF_LVI)
 static struct ac97_quirk ac97_quirks[] __devinitdata = {
 	{
 		.vendor = 0x0e11,
 		.device = 0x00b8,
 		.name = "Compaq Evo D510C",
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1028,
 		.device = 0x00d8,
 		.name = "Dell Precision 530",   /* AD1885 */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1028,
 		.device = 0x0126,
 		.name = "Dell Optiplex GX260",  /* AD1981A */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1028,
 		.device = 0x012d,
 		.name = "Dell Precision 450",   /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{       /* FIXME: which codec? */
 		.vendor = 0x103c,
 		.device = 0x00c3,
 		.name = "Hewlett-Packard onboard",
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x103c,
 		.device = 0x12f1,
 		.name = "HP xw8200",    /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x103c,
 		.device = 0x3008,
 		.name = "HP xw4200",    /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x10f1,
 		.device = 0x2665,
 		.name = "Fujitsu-Siemens Celsius",      /* AD1981? */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x10f1,
 		.device = 0x2885,
 		.name = "AMD64 Mobo",   /* ALC650 */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x110a,
 		.device = 0x0056,
 		.name = "Fujitsu-Siemens Scenic",       /* AD1981? */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x11d4,
 		.device = 0x5375,
 		.name = "ADI AD1985 (discrete)",
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1462,
 		.device = 0x5470,
 		.name = "MSI P4 ATX 645 Ultra",
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1734,
 		.device = 0x0088,
 		.name = "Fujitsu-Siemens D1522",	/* AD1981 */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x8086,
 		.device = 0x4856,
 		.name = "Intel D845WN (82801BA)",
 		.type = AC97_TUNE_SWAP_HP
 	},
 	{
 		.vendor = 0x8086,
 		.device = 0x4d44,
 		.name = "Intel D850EMV2",       /* AD1885 */
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x8086,
 		.device = 0x4d56,
 		.name = "Intel ICH/AD1885",
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x1028,
 		.device = 0x012d,
 		.name = "Dell Precision 450",   /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x103c,
 		.device = 0x3008,
 		.name = "HP xw4200",    /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{
 		.vendor = 0x103c,
 		.device = 0x12f1,
 		.name = "HP xw8200",    /* AD1981B*/
 		.type = AC97_TUNE_HP_ONLY
 	},
 	{ } /* terminator */
 };
 static struct i810_card *devs = NULL;
 static int i810_open_mixdev(struct inode *inode, struct file *file);
 static int i810_ioctl_mixdev(struct inode *inode, struct file *file,
 			     unsigned int cmd, unsigned long arg);
 static u16 i810_ac97_get(struct ac97_codec *dev, u8 reg);
 static void i810_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
 static u16 i810_ac97_get_mmio(struct ac97_codec *dev, u8 reg);
 static void i810_ac97_set_mmio(struct ac97_codec *dev, u8 reg, u16 data);
 static u16 i810_ac97_get_io(struct ac97_codec *dev, u8 reg);
 static void i810_ac97_set_io(struct ac97_codec *dev, u8 reg, u16 data);
 static struct i810_channel *i810_alloc_pcm_channel(struct i810_card *card)
 {
 	if(card->channel[1].used==1)
 		return NULL;
 	card->channel[1].used=1;
 	return &card->channel[1];
 }
 static struct i810_channel *i810_alloc_rec_pcm_channel(struct i810_card *card)
 {
 	if(card->channel[0].used==1)
 		return NULL;
 	card->channel[0].used=1;
 	return &card->channel[0];
 }
 static struct i810_channel *i810_alloc_rec_mic_channel(struct i810_card *card)
 {
 	if(card->channel[2].used==1)
 		return NULL;
 	card->channel[2].used=1;
 	return &card->channel[2];
 }
 static void i810_free_pcm_channel(struct i810_card *card, int channel)
 {
 	card->channel[channel].used=0;
 }
 static int i810_valid_spdif_rate ( struct ac97_codec *codec, int rate )
 {
 	unsigned long id = 0L;
 	id = (i810_ac97_get(codec, AC97_VENDOR_ID1) << 16);
 	id |= i810_ac97_get(codec, AC97_VENDOR_ID2) & 0xffff;
 #ifdef DEBUG
 	printk ( "i810_audio: codec = %s, codec_id = 0x%08lx\n", codec->name, id);
 #endif
 	switch ( id ) {
 		case 0x41445361: /* AD1886 */
 			if (rate == 48000) {
 				return 1;
 			}
 			break;
 		default: /* all other codecs, until we know otherwiae */
 			if (rate == 48000 || rate == 44100 || rate == 32000) {
 				return 1;
 			}
 			break;
 	}
 	return (0);
 }
 /* i810_set_spdif_output
  *
  *  Configure the S/PDIF output transmitter. When we turn on
  *  S/PDIF, we turn off the analog output. This may not be
  *  the right thing to do.
  *
  *  Assumptions:
  *     The DSP sample rate must already be set to a supported
  *     S/PDIF rate (32kHz, 44.1kHz, or 48kHz) or we abort.
  */
 static int i810_set_spdif_output(struct i810_state *state, int slots, int rate)
 {
 	int	vol;
 	int	aud_reg;
 	int	r = 0;
 	struct ac97_codec *codec = state->card->ac97_codec[0];
 	if(!codec->codec_ops->digital) {
 		state->card->ac97_status &= ~SPDIF_ON;
 	} else {
 		if ( slots == -1 ) { /* Turn off S/PDIF */
 			codec->codec_ops->digital(codec, 0, 0, 0);
 			/* If the volume wasn't muted before we turned on S/PDIF, unmute it */
 			if ( !(state->card->ac97_status & VOL_MUTED) ) {
 				aud_reg = i810_ac97_get(codec, AC97_MASTER_VOL_STEREO);
 				i810_ac97_set(codec, AC97_MASTER_VOL_STEREO, (aud_reg & ~VOL_MUTED));
 			}
 			state->card->ac97_status &= ~(VOL_MUTED | SPDIF_ON);
 			return 0;
 		}
 		vol = i810_ac97_get(codec, AC97_MASTER_VOL_STEREO);
 		state->card->ac97_status = vol & VOL_MUTED;
 		r = codec->codec_ops->digital(codec, slots, rate, 0);
 		if(r)
 			state->card->ac97_status |= SPDIF_ON;
 		else
 			state->card->ac97_status &= ~SPDIF_ON;
 		/* Mute the analog output */
 		/* Should this only mute the PCM volume??? */
 		i810_ac97_set(codec, AC97_MASTER_VOL_STEREO, (vol | VOL_MUTED));
 	}
 	return r;
 }
 /* i810_set_dac_channels
  *
  *  Configure the codec's multi-channel DACs
  *
  *  The logic is backwards. Setting the bit to 1 turns off the DAC.
  *
  *  What about the ICH? We currently configure it using the
  *  SNDCTL_DSP_CHANNELS ioctl.  If we're turnning on the DAC,
  *  does that imply that we want the ICH set to support
  *  these channels?
  *
  *  TODO:
  *    vailidate that the codec really supports these DACs
  *    before turning them on.
  */
 static void i810_set_dac_channels(struct i810_state *state, int channel)
 {
 	int	aud_reg;
 	struct ac97_codec *codec = state->card->ac97_codec[0];
 	/* No codec, no setup */
 	if(codec == NULL)
 		return;
 	aud_reg = i810_ac97_get(codec, AC97_EXTENDED_STATUS);
 	aud_reg |= AC97_EA_PRI | AC97_EA_PRJ | AC97_EA_PRK;
 	state->card->ac97_status &= ~(SURR_ON | CENTER_LFE_ON);
 	switch ( channel ) {
 		case 2: /* always enabled */
 			break;
 		case 4:
 			aud_reg &= ~AC97_EA_PRJ;
 			state->card->ac97_status |= SURR_ON;
 			break;
 		case 6:
 			aud_reg &= ~(AC97_EA_PRJ | AC97_EA_PRI | AC97_EA_PRK);
 			state->card->ac97_status |= SURR_ON | CENTER_LFE_ON;
 			break;
 		default:
 			break;
 	}
 	i810_ac97_set(codec, AC97_EXTENDED_STATUS, aud_reg);
 }
 /* set playback sample rate */
 static unsigned int i810_set_dac_rate(struct i810_state * state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	u32 new_rate;
 	struct ac97_codec *codec=state->card->ac97_codec[0];
 	if(!(state->card->ac97_features&0x0001))
 	{
 		dmabuf->rate = clocking;
 #ifdef DEBUG
 		printk("Asked for %d Hz, but ac97_features says we only do %dHz.  Sorry!\n",
 		       rate,clocking);
 #endif
 		return clocking;
 	}
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 8000)
 		rate = 8000;
 	dmabuf->rate = rate;
 	/*
 	 *	Adjust for misclocked crap
 	 */
 	rate = ( rate * clocking)/48000;
 	if(strict_clocking && rate < 8000) {
 		rate = 8000;
 		dmabuf->rate = (rate * 48000)/clocking;
 	}
         new_rate=ac97_set_dac_rate(codec, rate);
 	if(new_rate != rate) {
 		dmabuf->rate = (new_rate * 48000)/clocking;
 	}
 #ifdef DEBUG
 	printk("i810_audio: called i810_set_dac_rate : asked for %d, got %d\n", rate, dmabuf->rate);
 #endif
 	rate = new_rate;
 	return dmabuf->rate;
 }
 /* set recording sample rate */
 static unsigned int i810_set_adc_rate(struct i810_state * state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	u32 new_rate;
 	struct ac97_codec *codec=state->card->ac97_codec[0];
 	if(!(state->card->ac97_features&0x0001))
 	{
 		dmabuf->rate = clocking;
 		return clocking;
 	}
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 8000)
 		rate = 8000;
 	dmabuf->rate = rate;
 	/*
 	 *	Adjust for misclocked crap
 	 */
 	rate = ( rate * clocking)/48000;
 	if(strict_clocking && rate < 8000) {
 		rate = 8000;
 		dmabuf->rate = (rate * 48000)/clocking;
 	}
 	new_rate = ac97_set_adc_rate(codec, rate);
 	if(new_rate != rate) {
 		dmabuf->rate = (new_rate * 48000)/clocking;
 		rate = new_rate;
 	}
 #ifdef DEBUG
 	printk("i810_audio: called i810_set_adc_rate : rate = %d/%d\n", dmabuf->rate, rate);
 #endif
 	return dmabuf->rate;
 }
 /* get current playback/recording dma buffer pointer (byte offset from LBA),
    called with spinlock held! */
 static inline unsigned i810_get_dma_addr(struct i810_state *state, int rec)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int civ, offset, port, port_picb, bytes = 2;
 	if (!dmabuf->enable)
 		return 0;
 	if (rec)
 		port = dmabuf->read_channel->port;
 	else
 		port = dmabuf->write_channel->port;
 	if(state->card->pci_id == PCI_DEVICE_ID_SI_7012) {
 		port_picb = port + OFF_SR;
 		bytes = 1;
 	} else
 		port_picb = port + OFF_PICB;
 	do {
 		civ = GET_CIV(state->card, port);
 		offset = I810_IOREADW(state->card, port_picb);
 		/* Must have a delay here! */
 		if(offset == 0)
 			udelay(1);
 		/* Reread both registers and make sure that that total
 		 * offset from the first reading to the second is 0.
 		 * There is an issue with SiS hardware where it will count
 		 * picb down to 0, then update civ to the next value,
 		 * then set the new picb to fragsize bytes.  We can catch
 		 * it between the civ update and the picb update, making
 		 * it look as though we are 1 fragsize ahead of where we
 		 * are.  The next to we get the address though, it will
 		 * be back in the right place, and we will suddenly think
 		 * we just went forward dmasize - fragsize bytes, causing
 		 * totally stupid *huge* dma overrun messages.  We are
 		 * assuming that the 1us delay is more than long enough
 		 * that we won't have to worry about the chip still being
 		 * out of sync with reality ;-)
 		 */
 	} while (civ != GET_CIV(state->card, port) || offset != I810_IOREADW(state->card, port_picb));
 	return (((civ + 1) * dmabuf->fragsize - (bytes * offset))
 		% dmabuf->dmasize);
 }
 /* Stop recording (lock held) */
 static inline void __stop_adc(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct i810_card *card = state->card;
 	dmabuf->enable &= ~ADC_RUNNING;
 	I810_IOWRITEB(0, card, PI_CR);
 	// wait for the card to acknowledge shutdown
 	while( I810_IOREADB(card, PI_CR) != 0 ) ;
 	// now clear any latent interrupt bits (like the halt bit)
 	if(card->pci_id == PCI_DEVICE_ID_SI_7012)
 		I810_IOWRITEB( I810_IOREADB(card, PI_PICB), card, PI_PICB );
 	else
 		I810_IOWRITEB( I810_IOREADB(card, PI_SR), card, PI_SR );
 	I810_IOWRITEL( I810_IOREADL(card, GLOB_STA) & INT_PI, card, GLOB_STA);
 }
 static void stop_adc(struct i810_state *state)
 {
 	struct i810_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__stop_adc(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static inline void __start_adc(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	if (dmabuf->count < dmabuf->dmasize && dmabuf->ready && !dmabuf->enable &&
 	    (dmabuf->trigger & PCM_ENABLE_INPUT)) {
 		dmabuf->enable |= ADC_RUNNING;
 		// Interrupt enable, LVI enable, DMA enable
 		I810_IOWRITEB(0x10 | 0x04 | 0x01, state->card, PI_CR);
 	}
 }
 static void start_adc(struct i810_state *state)
 {
 	struct i810_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__start_adc(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 /* stop playback (lock held) */
 static inline void __stop_dac(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct i810_card *card = state->card;
 	dmabuf->enable &= ~DAC_RUNNING;
 	I810_IOWRITEB(0, card, PO_CR);
 	// wait for the card to acknowledge shutdown
 	while( I810_IOREADB(card, PO_CR) != 0 ) ;
 	// now clear any latent interrupt bits (like the halt bit)
 	if(card->pci_id == PCI_DEVICE_ID_SI_7012)
 		I810_IOWRITEB( I810_IOREADB(card, PO_PICB), card, PO_PICB );
 	else
 		I810_IOWRITEB( I810_IOREADB(card, PO_SR), card, PO_SR );
 	I810_IOWRITEL( I810_IOREADL(card, GLOB_STA) & INT_PO, card, GLOB_STA);
 }
 static void stop_dac(struct i810_state *state)
 {
 	struct i810_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__stop_dac(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static inline void __start_dac(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	if (dmabuf->count > 0 && dmabuf->ready && !dmabuf->enable &&
 	    (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
 		dmabuf->enable |= DAC_RUNNING;
 		// Interrupt enable, LVI enable, DMA enable
 		I810_IOWRITEB(0x10 | 0x04 | 0x01, state->card, PO_CR);
 	}
 }
 static void start_dac(struct i810_state *state)
 {
 	struct i810_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__start_dac(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 #define DMABUF_DEFAULTORDER (16-PAGE_SHIFT)
 #define DMABUF_MINORDER 1
 /* allocate DMA buffer, playback and recording buffer should be allocated separately */
 static int alloc_dmabuf(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	void *rawbuf= NULL;
 	int order, size;
 	struct page *page, *pend;
 	/* If we don't have any oss frag params, then use our default ones */
 	if(dmabuf->ossmaxfrags == 0)
 		dmabuf->ossmaxfrags = 4;
 	if(dmabuf->ossfragsize == 0)
 		dmabuf->ossfragsize = (PAGE_SIZE<<DMABUF_DEFAULTORDER)/dmabuf->ossmaxfrags;
 	size = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
 	if(dmabuf->rawbuf && (PAGE_SIZE << dmabuf->buforder) == size)
 		return 0;
 	/* alloc enough to satisfy the oss params */
 	for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
 		if ( (PAGE_SIZE<<order) > size )
 			continue;
 		if ((rawbuf = pci_alloc_consistent(state->card->pci_dev,
 						   PAGE_SIZE << order,
 						   &dmabuf->dma_handle)))
 			break;
 	}
 	if (!rawbuf)
 		return -ENOMEM;
 #ifdef DEBUG
 	printk("i810_audio: allocated %ld (order = %d) bytes at %p\n",
 	       PAGE_SIZE << order, order, rawbuf);
 #endif
 	dmabuf->ready  = dmabuf->mapped = 0;
 	dmabuf->rawbuf = rawbuf;
 	dmabuf->buforder = order;
 	/* now mark the pages as reserved; otherwise remap_pfn_range doesn't do what we want */
 	pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
 	for (page = virt_to_page(rawbuf); page <= pend; page++)
 		SetPageReserved(page);
 	return 0;
 }
 /* free DMA buffer */
 static void dealloc_dmabuf(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct page *page, *pend;
 	if (dmabuf->rawbuf) {
 		/* undo marking the pages as reserved */
 		pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
 		for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
 			ClearPageReserved(page);
 		pci_free_consistent(state->card->pci_dev, PAGE_SIZE << dmabuf->buforder,
 				    dmabuf->rawbuf, dmabuf->dma_handle);
 	}
 	dmabuf->rawbuf = NULL;
 	dmabuf->mapped = dmabuf->ready = 0;
 }
 static int prog_dmabuf(struct i810_state *state, unsigned rec)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct i810_channel *c;
 	struct sg_item *sg;
 	unsigned long flags;
 	int ret;
 	unsigned fragint;
 	int i;
 	spin_lock_irqsave(&state->card->lock, flags);
 	if(dmabuf->enable & DAC_RUNNING)
 		__stop_dac(state);
 	if(dmabuf->enable & ADC_RUNNING)
 		__stop_adc(state);
 	dmabuf->total_bytes = 0;
 	dmabuf->count = dmabuf->error = 0;
 	dmabuf->swptr = dmabuf->hwptr = 0;
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	/* allocate DMA buffer, let alloc_dmabuf determine if we are already
 	 * allocated well enough or if we should replace the current buffer
 	 * (assuming one is already allocated, if it isn't, then allocate it).
 	 */
 	if ((ret = alloc_dmabuf(state)))
 		return ret;
 	/* FIXME: figure out all this OSS fragment stuff */
 	/* I did, it now does what it should according to the OSS API.  DL */
 	/* We may not have realloced our dmabuf, but the fragment size to
 	 * fragment number ratio may have changed, so go ahead and reprogram
 	 * things
 	 */
 	dmabuf->dmasize = PAGE_SIZE << dmabuf->buforder;
 	dmabuf->numfrag = SG_LEN;
 	dmabuf->fragsize = dmabuf->dmasize/dmabuf->numfrag;
 	dmabuf->fragsamples = dmabuf->fragsize >> 1;
 	dmabuf->fragshift = ffs(dmabuf->fragsize) - 1;
 	dmabuf->userfragsize = dmabuf->ossfragsize;
 	dmabuf->userfrags = dmabuf->dmasize/dmabuf->ossfragsize;
 	memset(dmabuf->rawbuf, 0, dmabuf->dmasize);
 	if(dmabuf->ossmaxfrags == 4) {
 		fragint = 8;
 	} else if (dmabuf->ossmaxfrags == 8) {
 		fragint = 4;
 	} else if (dmabuf->ossmaxfrags == 16) {
 		fragint = 2;
 	} else {
 		fragint = 1;
 	}
 	/*
 	 *	Now set up the ring
 	 */
 	if(dmabuf->read_channel)
 		c = dmabuf->read_channel;
 	else
 		c = dmabuf->write_channel;
 	while(c != NULL) {
 		sg=&c->sg[0];
 		/*
 		 *	Load up 32 sg entries and take an interrupt at half
 		 *	way (we might want more interrupts later..)
 		 */
 		for(i=0;i<dmabuf->numfrag;i++)
 		{
 			sg->busaddr=(u32)dmabuf->dma_handle+dmabuf->fragsize*i;
 			// the card will always be doing 16bit stereo
 			sg->control=dmabuf->fragsamples;
 			if(state->card->pci_id == PCI_DEVICE_ID_SI_7012)
 				sg->control <<= 1;
 			sg->control|=CON_BUFPAD;
 			// set us up to get IOC interrupts as often as needed to
 			// satisfy numfrag requirements, no more
 			if( ((i+1) % fragint) == 0) {
 				sg->control|=CON_IOC;
 			}
 			sg++;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		I810_IOWRITEB(2, state->card, c->port+OFF_CR);   /* reset DMA machine */
 		while( I810_IOREADB(state->card, c->port+OFF_CR) & 0x02 ) ;
 		I810_IOWRITEL((u32)state->card->chandma +
 		    c->num*sizeof(struct i810_channel),
 		    state->card, c->port+OFF_BDBAR);
 		CIV_TO_LVI(state->card, c->port, 0);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if(c != dmabuf->write_channel)
 			c = dmabuf->write_channel;
 		else
 			c = NULL;
 	}
 	/* set the ready flag for the dma buffer */
 	dmabuf->ready = 1;
 #ifdef DEBUG
 	printk("i810_audio: prog_dmabuf, sample rate = %d, format = %d,\n\tnumfrag = %d, "
 	       "fragsize = %d dmasize = %d\n",
 	       dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
 	       dmabuf->fragsize, dmabuf->dmasize);
 #endif
 	return 0;
 }
 static void __i810_update_lvi(struct i810_state *state, int rec)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int x, port;
 	int trigger;
 	int count, fragsize;
 	void (*start)(struct i810_state *);
 	count = dmabuf->count;
 	if (rec) {
 		port = dmabuf->read_channel->port;
 		trigger = PCM_ENABLE_INPUT;
 		start = __start_adc;
 		count = dmabuf->dmasize - count;
 	} else {
 		port = dmabuf->write_channel->port;
 		trigger = PCM_ENABLE_OUTPUT;
 		start = __start_dac;
 	}
 	/* Do not process partial fragments. */
 	fragsize = dmabuf->fragsize;
 	if (count < fragsize)
 		return;
 	/* if we are currently stopped, then our CIV is actually set to our
 	 * *last* sg segment and we are ready to wrap to the next.  However,
 	 * if we set our LVI to the last sg segment, then it won't wrap to
 	 * the next sg segment, it won't even get a start.  So, instead, when
 	 * we are stopped, we set both the LVI value and also we increment
 	 * the CIV value to the next sg segment to be played so that when
 	 * we call start, things will operate properly.  Since the CIV can't
 	 * be written to directly for this purpose, we set the LVI to CIV + 1
 	 * temporarily.  Once the engine has started we set the LVI to its
 	 * final value.
 	 */
 	if (!dmabuf->enable && dmabuf->ready) {
 		if (!(dmabuf->trigger & trigger))
 			return;
 		CIV_TO_LVI(state->card, port, 1);
 		start(state);
 		while (!(I810_IOREADB(state->card, port + OFF_CR) & ((1<<4) | (1<<2))))
 			;
 	}
 	/* MASKP2(swptr, fragsize) - 1 is the tail of our transfer */
 	x = MODULOP2(MASKP2(dmabuf->swptr, fragsize) - 1, dmabuf->dmasize);
 	x >>= dmabuf->fragshift;
 	I810_IOWRITEB(x, state->card, port + OFF_LVI);
 }
 static void i810_update_lvi(struct i810_state *state, int rec)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	if(!dmabuf->ready)
 		return;
 	spin_lock_irqsave(&state->card->lock, flags);
 	__i810_update_lvi(state, rec);
 	spin_unlock_irqrestore(&state->card->lock, flags);
 }
 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
 static void i810_update_ptr(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned hwptr;
 	unsigned fragmask, dmamask;
 	int diff;
 	fragmask = MASKP2(~0, dmabuf->fragsize);
 	dmamask = MODULOP2(~0, dmabuf->dmasize);
 	/* error handling and process wake up for ADC */
 	if (dmabuf->enable == ADC_RUNNING) {
 		/* update hardware pointer */
 		hwptr = i810_get_dma_addr(state, 1) & fragmask;
 		diff = (hwptr - dmabuf->hwptr) & dmamask;
 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
 		printk("ADC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
 #endif
 		dmabuf->hwptr = hwptr;
 		dmabuf->total_bytes += diff;
 		dmabuf->count += diff;
 		if (dmabuf->count > dmabuf->dmasize) {
 			/* buffer underrun or buffer overrun */
 			/* this is normal for the end of a read */
 			/* only give an error if we went past the */
 			/* last valid sg entry */
 			if (GET_CIV(state->card, PI_BASE) !=
 			    GET_LVI(state->card, PI_BASE)) {
 				printk(KERN_WARNING "i810_audio: DMA overrun on read\n");
 				dmabuf->error++;
 			}
 		}
 		if (diff)
 			wake_up(&dmabuf->wait);
 	}
 	/* error handling and process wake up for DAC */
 	if (dmabuf->enable == DAC_RUNNING) {
 		/* update hardware pointer */
 		hwptr = i810_get_dma_addr(state, 0) & fragmask;
 		diff = (hwptr - dmabuf->hwptr) & dmamask;
 #if defined(DEBUG_INTERRUPTS) || defined(DEBUG_MMAP)
 		printk("DAC HWP %d,%d,%d\n", hwptr, dmabuf->hwptr, diff);
 #endif
 		dmabuf->hwptr = hwptr;
 		dmabuf->total_bytes += diff;
 		dmabuf->count -= diff;
 		if (dmabuf->count < 0) {
 			/* buffer underrun or buffer overrun */
 			/* this is normal for the end of a write */
 			/* only give an error if we went past the */
 			/* last valid sg entry */
 			if (GET_CIV(state->card, PO_BASE) !=
 			    GET_LVI(state->card, PO_BASE)) {
 				printk(KERN_WARNING "i810_audio: DMA overrun on write\n");
 				printk("i810_audio: CIV %d, LVI %d, hwptr %x, "
 					"count %d\n",
 					GET_CIV(state->card, PO_BASE),
 					GET_LVI(state->card, PO_BASE),
 					dmabuf->hwptr, dmabuf->count);
 				dmabuf->error++;
 			}
 		}
 		if (diff)
 			wake_up(&dmabuf->wait);
 	}
 }
 static inline int i810_get_free_write_space(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int free;
 	i810_update_ptr(state);
 	// catch underruns during playback
 	if (dmabuf->count < 0) {
 		dmabuf->count = 0;
 		dmabuf->swptr = dmabuf->hwptr;
 	}
 	free = dmabuf->dmasize - dmabuf->count;
 	if(free < 0)
 		return(0);
 	return(free);
 }
 static inline int i810_get_available_read_data(struct i810_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int avail;
 	i810_update_ptr(state);
 	// catch overruns during record
 	if (dmabuf->count > dmabuf->dmasize) {
 		dmabuf->count = dmabuf->dmasize;
 		dmabuf->swptr = dmabuf->hwptr;
 	}
 	avail = dmabuf->count;
 	if(avail < 0)
 		return(0);
 	return(avail);
 }
 static inline void fill_partial_frag(struct dmabuf *dmabuf)
 {
 	unsigned fragsize;
 	unsigned swptr, len;
 	fragsize = dmabuf->fragsize;
 	swptr = dmabuf->swptr;
 	len = fragsize - MODULOP2(dmabuf->swptr, fragsize);
 	if (len == fragsize)
 		return;
 	memset(dmabuf->rawbuf + swptr, '\0', len);
 	dmabuf->swptr = MODULOP2(swptr + len, dmabuf->dmasize);
 	dmabuf->count += len;
 }
 static int drain_dac(struct i810_state *state, int signals_allowed)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	unsigned long tmo;
 	int count;
 	if (!dmabuf->ready)
 		return 0;
 	if(dmabuf->mapped) {
 		stop_dac(state);
 		return 0;
 	}
 	spin_lock_irqsave(&state->card->lock, flags);
 	fill_partial_frag(dmabuf);
 	/*
 	 * This will make sure that our LVI is correct, that our
 	 * pointer is updated, and that the DAC is running.  We
 	 * have to force the setting of dmabuf->trigger to avoid
 	 * any possible deadlocks.
 	 */
 	dmabuf->trigger = PCM_ENABLE_OUTPUT;
 	__i810_update_lvi(state, 0);
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	add_wait_queue(&dmabuf->wait, &wait);
 	for (;;) {
 		spin_lock_irqsave(&state->card->lock, flags);
 		i810_update_ptr(state);
 		count = dmabuf->count;
 		/* It seems that we have to set the current state to
 		 * TASK_INTERRUPTIBLE every time to make the process
 		 * really go to sleep.  This also has to be *after* the
 		 * update_ptr() call because update_ptr is likely to
 		 * do a wake_up() which will unset this before we ever
 		 * try to sleep, resuling in a tight loop in this code
 		 * instead of actually sleeping and waiting for an
 		 * interrupt to wake us up!
 		 */
 		__set_current_state(signals_allowed ?
 				    TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (count <= 0)
 			break;
                 if (signal_pending(current) && signals_allowed) {
                         break;
                 }
 		/*
 		 * set the timeout to significantly longer than it *should*
 		 * take for the DAC to drain the DMA buffer
 		 */
 		tmo = (count * HZ) / (dmabuf->rate);
 		if (!schedule_timeout(tmo >= 2 ? tmo : 2)){
 			printk(KERN_ERR "i810_audio: drain_dac, dma timeout?\n");
 			count = 0;
 			break;
 		}
 	}
 	set_current_state(TASK_RUNNING);
 	remove_wait_queue(&dmabuf->wait, &wait);
 	if(count > 0 && signal_pending(current) && signals_allowed)
 		return -ERESTARTSYS;
 	stop_dac(state);
 	return 0;
 }
 static void i810_channel_interrupt(struct i810_card *card)
 {
 	int i, count;
 #ifdef DEBUG_INTERRUPTS
 	printk("CHANNEL ");
 #endif
 	for(i=0;i<NR_HW_CH;i++)
 	{
 		struct i810_state *state = card->states[i];
 		struct i810_channel *c;
 		struct dmabuf *dmabuf;
 		unsigned long port;
 		u16 status;
 		if(!state)
 			continue;
 		if(!state->dmabuf.ready)
 			continue;
 		dmabuf = &state->dmabuf;
 		if(dmabuf->enable & DAC_RUNNING) {
 			c=dmabuf->write_channel;
 		} else if(dmabuf->enable & ADC_RUNNING) {
 			c=dmabuf->read_channel;
 		} else	/* This can occur going from R/W to close */
 			continue;
 		port = c->port;
 		if(card->pci_id == PCI_DEVICE_ID_SI_7012)
 			status = I810_IOREADW(card, port + OFF_PICB);
 		else
 			status = I810_IOREADW(card, port + OFF_SR);
 #ifdef DEBUG_INTERRUPTS
 		printk("NUM %d PORT %X IRQ ( ST%d ", c->num, c->port, status);
 #endif
 		if(status & DMA_INT_COMPLETE)
 		{
 			/* only wake_up() waiters if this interrupt signals
 			 * us being beyond a userfragsize of data open or
 			 * available, and i810_update_ptr() does that for
 			 * us
 			 */
 			i810_update_ptr(state);
 #ifdef DEBUG_INTERRUPTS
 			printk("COMP %d ", dmabuf->hwptr /
 					dmabuf->fragsize);
 #endif
 		}
 		if(status & (DMA_INT_LVI | DMA_INT_DCH))
 		{
 			/* wake_up() unconditionally on LVI and DCH */
 			i810_update_ptr(state);
 			wake_up(&dmabuf->wait);
 #ifdef DEBUG_INTERRUPTS
 			if(status & DMA_INT_LVI)
 				printk("LVI ");
 			if(status & DMA_INT_DCH)
 				printk("DCH -");
 #endif
 			count = dmabuf->count;
 			if(dmabuf->enable & ADC_RUNNING)
 				count = dmabuf->dmasize - count;
 			if (count >= (int)dmabuf->fragsize) {
 				I810_IOWRITEB(I810_IOREADB(card, port+OFF_CR) | 1, card, port+OFF_CR);
 #ifdef DEBUG_INTERRUPTS
 				printk(" CONTINUE ");
 #endif
 			} else {
 				if (dmabuf->enable & DAC_RUNNING)
 					__stop_dac(state);
 				if (dmabuf->enable & ADC_RUNNING)
 					__stop_adc(state);
 				dmabuf->enable = 0;
 #ifdef DEBUG_INTERRUPTS
 				printk(" STOP ");
 #endif
 			}
 		}
 		if(card->pci_id == PCI_DEVICE_ID_SI_7012)
 			I810_IOWRITEW(status & DMA_INT_MASK, card, port + OFF_PICB);
 		else
 			I810_IOWRITEW(status & DMA_INT_MASK, card, port + OFF_SR);
 	}
 #ifdef DEBUG_INTERRUPTS
 	printk(")\n");
 #endif
 }
 static irqreturn_t i810_interrupt(int irq, void *dev_id)
 {
 	struct i810_card *card = dev_id;
 	u32 status;
 	spin_lock(&card->lock);
 	status = I810_IOREADL(card, GLOB_STA);
 	if(!(status & INT_MASK))
 	{
 		spin_unlock(&card->lock);
 		return IRQ_NONE;  /* not for us */
 	}
 	if(status & (INT_PO|INT_PI|INT_MC))
 		i810_channel_interrupt(card);
  	/* clear 'em */
 	I810_IOWRITEL(status & INT_MASK, card, GLOB_STA);
 	spin_unlock(&card->lock);
 	return IRQ_HANDLED;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is
    waiting to be copied to the user's buffer.  It is filled by the dma
    machine and drained by this loop. */
 static ssize_t i810_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct i810_card *card=state ? state->card : NULL;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	ssize_t ret;
 	unsigned long flags;
 	unsigned int swptr;
 	int cnt;
 	int pending;
         DECLARE_WAITQUEUE(waita, current);
 #ifdef DEBUG2
 	printk("i810_audio: i810_read called, count = %d\n", count);
 #endif
 	if (dmabuf->mapped)
 		return -ENXIO;
 	if (dmabuf->enable & DAC_RUNNING)
 		return -ENODEV;
 	if (!dmabuf->read_channel) {
 		dmabuf->ready = 0;
 		dmabuf->read_channel = card->alloc_rec_pcm_channel(card);
 		if (!dmabuf->read_channel) {
 			return -EBUSY;
 		}
 	}
 	if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
 		return ret;
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	ret = 0;
 	pending = 0;
         add_wait_queue(&dmabuf->wait, &waita);
 	while (count > 0) {
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&card->lock, flags);
                 if (PM_SUSPENDED(card)) {
                         spin_unlock_irqrestore(&card->lock, flags);
                         schedule();
                         if (signal_pending(current)) {
                                 if (!ret) ret = -EAGAIN;
                                 break;
                         }
                         continue;
                 }
 		cnt = i810_get_available_read_data(state);
 		swptr = dmabuf->swptr;
 		// this is to make the copy_to_user simpler below
 		if(cnt > (dmabuf->dmasize - swptr))
 			cnt = dmabuf->dmasize - swptr;
 		spin_unlock_irqrestore(&card->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			unsigned long tmo;
 			/*
 			 * Don't let us deadlock.  The ADC won't start if
 			 * dmabuf->trigger isn't set.  A call to SETTRIGGER
 			 * could have turned it off after we set it to on
 			 * previously.
 			 */
 			dmabuf->trigger = PCM_ENABLE_INPUT;
 			/*
 			 * This does three things.  Updates LVI to be correct,
 			 * makes sure the ADC is running, and updates the
 			 * hwptr.
 			 */
 			i810_update_lvi(state,1);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret) ret = -EAGAIN;
 				goto done;
 			}
 			/* Set the timeout to how long it would take to fill
 			 * two of our buffers.  If we haven't been woke up
 			 * by then, then we know something is wrong.
 			 */
 			tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
 			/* There are two situations when sleep_on_timeout returns, one is when
 			   the interrupt is serviced correctly and the process is waked up by
 			   ISR ON TIME. Another is when timeout is expired, which means that
 			   either interrupt is NOT serviced correctly (pending interrupt) or it
 			   is TOO LATE for the process to be scheduled to run (scheduler latency)
 			   which results in a (potential) buffer overrun. And worse, there is
 			   NOTHING we can do to prevent it. */
 			if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
 #ifdef DEBUG
 				printk(KERN_ERR "i810_audio: recording schedule timeout, "
 				       "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
 				       dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
 				       dmabuf->hwptr, dmabuf->swptr);
 #endif
 				/* a buffer overrun, we delay the recovery until next time the
 				   while loop begin and we REALLY have space to record */
 			}
 			if (signal_pending(current)) {
 				ret = ret ? ret : -ERESTARTSYS;
 				goto done;
 			}
 			continue;
 		}
 		if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
 			if (!ret) ret = -EFAULT;
 			goto done;
 		}
 		swptr = MODULOP2(swptr + cnt, dmabuf->dmasize);
 		spin_lock_irqsave(&card->lock, flags);
                 if (PM_SUSPENDED(card)) {
                         spin_unlock_irqrestore(&card->lock, flags);
                         continue;
                 }
 		dmabuf->swptr = swptr;
 		pending = dmabuf->count -= cnt;
 		spin_unlock_irqrestore(&card->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 	}
  done:
 	pending = dmabuf->dmasize - pending;
 	if (dmabuf->enable || pending >= dmabuf->userfragsize)
 		i810_update_lvi(state, 1);
         set_current_state(TASK_RUNNING);
         remove_wait_queue(&dmabuf->wait, &waita);
 	return ret;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
    the soundcard.  it is drained by the dma machine and filled by this loop. */
 static ssize_t i810_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct i810_card *card=state ? state->card : NULL;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	ssize_t ret;
 	unsigned long flags;
 	unsigned int swptr = 0;
 	int pending;
 	int cnt;
         DECLARE_WAITQUEUE(waita, current);
 #ifdef DEBUG2
 	printk("i810_audio: i810_write called, count = %d\n", count);
 #endif
 	if (dmabuf->mapped)
 		return -ENXIO;
 	if (dmabuf->enable & ADC_RUNNING)
 		return -ENODEV;
 	if (!dmabuf->write_channel) {
 		dmabuf->ready = 0;
 		dmabuf->write_channel = card->alloc_pcm_channel(card);
 		if(!dmabuf->write_channel)
 			return -EBUSY;
 	}
 	if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
 		return ret;
 	if (!access_ok(VERIFY_READ, buffer, count))
 		return -EFAULT;
 	ret = 0;
 	pending = 0;
         add_wait_queue(&dmabuf->wait, &waita);
 	while (count > 0) {
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&state->card->lock, flags);
                 if (PM_SUSPENDED(card)) {
                         spin_unlock_irqrestore(&card->lock, flags);
                         schedule();
                         if (signal_pending(current)) {
                                 if (!ret) ret = -EAGAIN;
                                 break;
                         }
                         continue;
                 }
 		cnt = i810_get_free_write_space(state);
 		swptr = dmabuf->swptr;
 		/* Bound the maximum size to how much we can copy to the
 		 * dma buffer before we hit the end.  If we have more to
 		 * copy then it will get done in a second pass of this
 		 * loop starting from the beginning of the buffer.
 		 */
 		if(cnt > (dmabuf->dmasize - swptr))
 			cnt = dmabuf->dmasize - swptr;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #ifdef DEBUG2
 		printk(KERN_INFO "i810_audio: i810_write: %d bytes available space\n", cnt);
 #endif
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			unsigned long tmo;
 			// There is data waiting to be played
 			/*
 			 * Force the trigger setting since we would
 			 * deadlock with it set any other way
 			 */
 			dmabuf->trigger = PCM_ENABLE_OUTPUT;
 			i810_update_lvi(state,0);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret) ret = -EAGAIN;
 				goto ret;
 			}
 			/* Not strictly correct but works */
 			tmo = (dmabuf->dmasize * HZ * 2) / (dmabuf->rate * 4);
 			/* There are two situations when sleep_on_timeout returns, one is when
 			   the interrupt is serviced correctly and the process is waked up by
 			   ISR ON TIME. Another is when timeout is expired, which means that
 			   either interrupt is NOT serviced correctly (pending interrupt) or it
 			   is TOO LATE for the process to be scheduled to run (scheduler latency)
 			   which results in a (potential) buffer underrun. And worse, there is
 			   NOTHING we can do to prevent it. */
 			if (!schedule_timeout(tmo >= 2 ? tmo : 2)) {
 #ifdef DEBUG
 				printk(KERN_ERR "i810_audio: playback schedule timeout, "
 				       "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
 				       dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
 				       dmabuf->hwptr, dmabuf->swptr);
 #endif
 				/* a buffer underrun, we delay the recovery until next time the
 				   while loop begin and we REALLY have data to play */
 				//return ret;
 			}
 			if (signal_pending(current)) {
 				if (!ret) ret = -ERESTARTSYS;
 				goto ret;
 			}
 			continue;
 		}
 		if (copy_from_user(dmabuf->rawbuf+swptr,buffer,cnt)) {
 			if (!ret) ret = -EFAULT;
 			goto ret;
 		}
 		swptr = MODULOP2(swptr + cnt, dmabuf->dmasize);
 		spin_lock_irqsave(&state->card->lock, flags);
                 if (PM_SUSPENDED(card)) {
                         spin_unlock_irqrestore(&card->lock, flags);
                         continue;
                 }
 		dmabuf->swptr = swptr;
 		pending = dmabuf->count += cnt;
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 	}
 ret:
 	if (dmabuf->enable || pending >= dmabuf->userfragsize)
 		i810_update_lvi(state, 0);
         set_current_state(TASK_RUNNING);
         remove_wait_queue(&dmabuf->wait, &waita);
 	return ret;
 }
 /* No kernel lock - we have our own spinlock */
 static unsigned int i810_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	unsigned int mask = 0;
 	if(!dmabuf->ready)
 		return 0;
 	poll_wait(file, &dmabuf->wait, wait);
 	spin_lock_irqsave(&state->card->lock, flags);
 	if (dmabuf->enable & ADC_RUNNING ||
 	    dmabuf->trigger & PCM_ENABLE_INPUT) {
 		if (i810_get_available_read_data(state) >=
 		    (signed)dmabuf->userfragsize)
 			mask |= POLLIN | POLLRDNORM;
 	}
 	if (dmabuf->enable & DAC_RUNNING ||
 	    dmabuf->trigger & PCM_ENABLE_OUTPUT) {
 		if (i810_get_free_write_space(state) >=
 		    (signed)dmabuf->userfragsize)
 			mask |= POLLOUT | POLLWRNORM;
 	}
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	return mask;
 }
 static int i810_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int ret = -EINVAL;
 	unsigned long size;
 	lock_kernel();
 	if (vma->vm_flags & VM_WRITE) {
 		if (!dmabuf->write_channel &&
 		    (dmabuf->write_channel =
 		     state->card->alloc_pcm_channel(state->card)) == NULL) {
 			ret = -EBUSY;
 			goto out;
 		}
 	}
 	if (vma->vm_flags & VM_READ) {
 		if (!dmabuf->read_channel &&
 		    (dmabuf->read_channel =
 		     state->card->alloc_rec_pcm_channel(state->card)) == NULL) {
 			ret = -EBUSY;
 			goto out;
 		}
 	}
 	if ((ret = prog_dmabuf(state, 0)) != 0)
 		goto out;
 	ret = -EINVAL;
 	if (vma->vm_pgoff != 0)
 		goto out;
 	size = vma->vm_end - vma->vm_start;
 	if (size > (PAGE_SIZE << dmabuf->buforder))
 		goto out;
 	ret = -EAGAIN;
 	if (remap_pfn_range(vma, vma->vm_start,
 			     virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
 			     size, vma->vm_page_prot))
 		goto out;
 	dmabuf->mapped = 1;
 	dmabuf->trigger = 0;
 	ret = 0;
 #ifdef DEBUG_MMAP
 	printk("i810_audio: mmap'ed %ld bytes of data space\n", size);
 #endif
 out:
 	unlock_kernel();
 	return ret;
 }
 static int i810_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct i810_channel *c = NULL;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	audio_buf_info abinfo;
 	count_info cinfo;
 	unsigned int i_glob_cnt;
 	int val = 0, ret;
 	struct ac97_codec *codec = state->card->ac97_codec[0];
 	void __user *argp = (void __user *)arg;
 	int __user *p = argp;
 #ifdef DEBUG
 	printk("i810_audio: i810_ioctl, arg=0x%x, cmd=", arg ? *p : 0);
 #endif
 	switch (cmd)
 	{
 	case OSS_GETVERSION:
 #ifdef DEBUG
 		printk("OSS_GETVERSION\n");
 #endif
 		return put_user(SOUND_VERSION, p);
 	case SNDCTL_DSP_RESET:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_RESET\n");
 #endif
 		spin_lock_irqsave(&state->card->lock, flags);
 		if (dmabuf->enable == DAC_RUNNING) {
 			c = dmabuf->write_channel;
 			__stop_dac(state);
 		}
 		if (dmabuf->enable == ADC_RUNNING) {
 			c = dmabuf->read_channel;
 			__stop_adc(state);
 		}
 		if (c != NULL) {
 			I810_IOWRITEB(2, state->card, c->port+OFF_CR);   /* reset DMA machine */
 			while ( I810_IOREADB(state->card, c->port+OFF_CR) & 2 )
 				cpu_relax();
 			I810_IOWRITEL((u32)state->card->chandma +
 			    c->num*sizeof(struct i810_channel),
 			    state->card, c->port+OFF_BDBAR);
 			CIV_TO_LVI(state->card, c->port, 0);
 		}
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		synchronize_irq(state->card->pci_dev->irq);
 		dmabuf->ready = 0;
 		dmabuf->swptr = dmabuf->hwptr = 0;
 		dmabuf->count = dmabuf->total_bytes = 0;
 		return 0;
 	case SNDCTL_DSP_SYNC:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SYNC\n");
 #endif
 		if (dmabuf->enable != DAC_RUNNING || file->f_flags & O_NONBLOCK)
 			return 0;
 		if((val = drain_dac(state, 1)))
 			return val;
 		dmabuf->total_bytes = 0;
 		return 0;
 	case SNDCTL_DSP_SPEED: /* set smaple rate */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SPEED\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val >= 0) {
 			if (file->f_mode & FMODE_WRITE) {
 				if ( (state->card->ac97_status & SPDIF_ON) ) {  /* S/PDIF Enabled */
 					/* AD1886 only supports 48000, need to check that */
 					if ( i810_valid_spdif_rate ( codec, val ) ) {
 						/* Set DAC rate */
                                         	i810_set_spdif_output ( state, -1, 0 );
 						stop_dac(state);
 						dmabuf->ready = 0;
 						spin_lock_irqsave(&state->card->lock, flags);
 						i810_set_dac_rate(state, val);
 						spin_unlock_irqrestore(&state->card->lock, flags);
 						/* Set S/PDIF transmitter rate. */
 						i810_set_spdif_output ( state, AC97_EA_SPSA_3_4, val );
 	                                        if ( ! (state->card->ac97_status & SPDIF_ON) ) {
 							val = dmabuf->rate;
 						}
 					} else { /* Not a valid rate for S/PDIF, ignore it */
 						val = dmabuf->rate;
 					}
 				} else {
 					stop_dac(state);
 					dmabuf->ready = 0;
 					spin_lock_irqsave(&state->card->lock, flags);
 					i810_set_dac_rate(state, val);
 					spin_unlock_irqrestore(&state->card->lock, flags);
 				}
 			}
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(state);
 				dmabuf->ready = 0;
 				spin_lock_irqsave(&state->card->lock, flags);
 				i810_set_adc_rate(state, val);
 				spin_unlock_irqrestore(&state->card->lock, flags);
 			}
 		}
 		return put_user(dmabuf->rate, p);
 	case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_STEREO\n");
 #endif
 		if (dmabuf->enable & DAC_RUNNING) {
 			stop_dac(state);
 		}
 		if (dmabuf->enable & ADC_RUNNING) {
 			stop_adc(state);
 		}
 		return put_user(1, p);
 	case SNDCTL_DSP_GETBLKSIZE:
 		if (file->f_mode & FMODE_WRITE) {
 			if (!dmabuf->ready && (val = prog_dmabuf(state, 0)))
 				return val;
 		}
 		if (file->f_mode & FMODE_READ) {
 			if (!dmabuf->ready && (val = prog_dmabuf(state, 1)))
 				return val;
 		}
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETBLKSIZE %d\n", dmabuf->userfragsize);
 #endif
 		return put_user(dmabuf->userfragsize, p);
 	case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETFMTS\n");
 #endif
 		return put_user(AFMT_S16_LE, p);
 	case SNDCTL_DSP_SETFMT: /* Select sample format */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SETFMT\n");
 #endif
 		return put_user(AFMT_S16_LE, p);
 	case SNDCTL_DSP_CHANNELS:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_CHANNELS\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val > 0) {
 			if (dmabuf->enable & DAC_RUNNING) {
 				stop_dac(state);
 			}
 			if (dmabuf->enable & ADC_RUNNING) {
 				stop_adc(state);
 			}
 		} else {
 			return put_user(state->card->channels, p);
 		}
 		/* ICH and ICH0 only support 2 channels */
 		if ( state->card->pci_id == PCI_DEVICE_ID_INTEL_82801AA_5
 		     || state->card->pci_id == PCI_DEVICE_ID_INTEL_82801AB_5)
 			return put_user(2, p);
 		/* Multi-channel support was added with ICH2. Bits in */
 		/* Global Status and Global Control register are now  */
 		/* used to indicate this.                             */
                 i_glob_cnt = I810_IOREADL(state->card, GLOB_CNT);
 		/* Current # of channels enabled */
 		if ( i_glob_cnt & 0x0100000 )
 			ret = 4;
 		else if ( i_glob_cnt & 0x0200000 )
 			ret = 6;
 		else
 			ret = 2;
 		switch ( val ) {
 			case 2: /* 2 channels is always supported */
 				I810_IOWRITEL(i_glob_cnt & 0xffcfffff,
 				     state->card, GLOB_CNT);
 				/* Do we need to change mixer settings????  */
 				break;
 			case 4: /* Supported on some chipsets, better check first */
 				if ( state->card->channels >= 4 ) {
 					I810_IOWRITEL((i_glob_cnt & 0xffcfffff) | 0x100000,
 					      state->card, GLOB_CNT);
 					/* Do we need to change mixer settings??? */
 				} else {
 					val = ret;
 				}
 				break;
 			case 6: /* Supported on some chipsets, better check first */
 				if ( state->card->channels >= 6 ) {
 					I810_IOWRITEL((i_glob_cnt & 0xffcfffff) | 0x200000,
 					      state->card, GLOB_CNT);
 					/* Do we need to change mixer settings??? */
 				} else {
 					val = ret;
 				}
 				break;
 			default: /* nothing else is ever supported by the chipset */
 				val = ret;
 				break;
 		}
 		return put_user(val, p);
 	case SNDCTL_DSP_POST: /* the user has sent all data and is notifying us */
 		/* we update the swptr to the end of the last sg segment then return */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_POST\n");
 #endif
 		if(!dmabuf->ready || (dmabuf->enable != DAC_RUNNING))
 			return 0;
 		if((dmabuf->swptr % dmabuf->fragsize) != 0) {
 			val = dmabuf->fragsize - (dmabuf->swptr % dmabuf->fragsize);
 			dmabuf->swptr += val;
 			dmabuf->count += val;
 		}
 		return 0;
 	case SNDCTL_DSP_SUBDIVIDE:
 		if (dmabuf->subdivision)
 			return -EINVAL;
 		if (get_user(val, p))
 			return -EFAULT;
 		if (val != 1 && val != 2 && val != 4)
 			return -EINVAL;
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SUBDIVIDE %d\n", val);
 #endif
 		dmabuf->subdivision = val;
 		dmabuf->ready = 0;
 		return 0;
 	case SNDCTL_DSP_SETFRAGMENT:
 		if (get_user(val, p))
 			return -EFAULT;
 		dmabuf->ossfragsize = 1<<(val & 0xffff);
 		dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
 		if (!dmabuf->ossfragsize || !dmabuf->ossmaxfrags)
 			return -EINVAL;
 		/*
 		 * Bound the frag size into our allowed range of 256 - 4096
 		 */
 		if (dmabuf->ossfragsize < 256)
 			dmabuf->ossfragsize = 256;
 		else if (dmabuf->ossfragsize > 4096)
 			dmabuf->ossfragsize = 4096;
 		/*
 		 * The numfrags could be something reasonable, or it could
 		 * be 0xffff meaning "Give me as much as possible".  So,
 		 * we check the numfrags * fragsize doesn't exceed our
 		 * 64k buffer limit, nor is it less than our 8k minimum.
 		 * If it fails either one of these checks, then adjust the
 		 * number of fragments, not the size of them.  It's OK if
 		 * our number of fragments doesn't equal 32 or anything
 		 * like our hardware based number now since we are using
 		 * a different frag count for the hardware.  Before we get
 		 * into this though, bound the maxfrags to avoid overflow
 		 * issues.  A reasonable bound would be 64k / 256 since our
 		 * maximum buffer size is 64k and our minimum frag size is
 		 * 256.  On the other end, our minimum buffer size is 8k and
 		 * our maximum frag size is 4k, so the lower bound should
 		 * be 2.
 		 */
 		if(dmabuf->ossmaxfrags > 256)
 			dmabuf->ossmaxfrags = 256;
 		else if (dmabuf->ossmaxfrags < 2)
 			dmabuf->ossmaxfrags = 2;
 		val = dmabuf->ossfragsize * dmabuf->ossmaxfrags;
 		while (val < 8192) {
 		    val <<= 1;
 		    dmabuf->ossmaxfrags <<= 1;
 		}
 		while (val > 65536) {
 		    val >>= 1;
 		    dmabuf->ossmaxfrags >>= 1;
 		}
 		dmabuf->ready = 0;
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SETFRAGMENT 0x%x, %d, %d\n", val,
 			dmabuf->ossfragsize, dmabuf->ossmaxfrags);
 #endif
 		return 0;
 	case SNDCTL_DSP_GETOSPACE:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
 			return val;
 		spin_lock_irqsave(&state->card->lock, flags);
 		i810_update_ptr(state);
 		abinfo.fragsize = dmabuf->userfragsize;
 		abinfo.fragstotal = dmabuf->userfrags;
 		if (dmabuf->mapped)
  			abinfo.bytes = dmabuf->dmasize;
   		else
  			abinfo.bytes = i810_get_free_write_space(state);
 		abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #if defined(DEBUG) || defined(DEBUG_MMAP)
 		printk("SNDCTL_DSP_GETOSPACE %d, %d, %d, %d\n", abinfo.bytes,
 			abinfo.fragsize, abinfo.fragments, abinfo.fragstotal);
 #endif
 		return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 	case SNDCTL_DSP_GETOPTR:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
 			return val;
 		spin_lock_irqsave(&state->card->lock, flags);
 		val = i810_get_free_write_space(state);
 		cinfo.bytes = dmabuf->total_bytes;
 		cinfo.ptr = dmabuf->hwptr;
 		cinfo.blocks = val/dmabuf->userfragsize;
 		if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_OUTPUT)) {
 			dmabuf->count += val;
 			dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
 			__i810_update_lvi(state, 0);
 		}
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #if defined(DEBUG) || defined(DEBUG_MMAP)
 		printk("SNDCTL_DSP_GETOPTR %d, %d, %d, %d\n", cinfo.bytes,
 			cinfo.blocks, cinfo.ptr, dmabuf->count);
 #endif
 		return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
 	case SNDCTL_DSP_GETISPACE:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		if (!dmabuf->ready && (val = prog_dmabuf(state, 1)) != 0)
 			return val;
 		spin_lock_irqsave(&state->card->lock, flags);
 		abinfo.bytes = i810_get_available_read_data(state);
 		abinfo.fragsize = dmabuf->userfragsize;
 		abinfo.fragstotal = dmabuf->userfrags;
 		abinfo.fragments = abinfo.bytes / dmabuf->userfragsize;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #if defined(DEBUG) || defined(DEBUG_MMAP)
 		printk("SNDCTL_DSP_GETISPACE %d, %d, %d, %d\n", abinfo.bytes,
 			abinfo.fragsize, abinfo.fragments, abinfo.fragstotal);
 #endif
 		return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 	case SNDCTL_DSP_GETIPTR:
 		if (!(file->f_mode & FMODE_READ))
 			return -EINVAL;
 		if (!dmabuf->ready && (val = prog_dmabuf(state, 0)) != 0)
 			return val;
 		spin_lock_irqsave(&state->card->lock, flags);
 		val = i810_get_available_read_data(state);
 		cinfo.bytes = dmabuf->total_bytes;
 		cinfo.blocks = val/dmabuf->userfragsize;
 		cinfo.ptr = dmabuf->hwptr;
 		if (dmabuf->mapped && (dmabuf->trigger & PCM_ENABLE_INPUT)) {
 			dmabuf->count -= val;
 			dmabuf->swptr = (dmabuf->swptr + val) % dmabuf->dmasize;
 			__i810_update_lvi(state, 1);
 		}
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #if defined(DEBUG) || defined(DEBUG_MMAP)
 		printk("SNDCTL_DSP_GETIPTR %d, %d, %d, %d\n", cinfo.bytes,
 			cinfo.blocks, cinfo.ptr, dmabuf->count);
 #endif
 		return copy_to_user(argp, &cinfo, sizeof(cinfo)) ? -EFAULT : 0;
 	case SNDCTL_DSP_NONBLOCK:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_NONBLOCK\n");
 #endif
 		file->f_flags |= O_NONBLOCK;
 		return 0;
 	case SNDCTL_DSP_GETCAPS:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETCAPS\n");
 #endif
 	    return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP|DSP_CAP_BIND,
 			    p);
 	case SNDCTL_DSP_GETTRIGGER:
 		val = 0;
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETTRIGGER 0x%x\n", dmabuf->trigger);
 #endif
 		return put_user(dmabuf->trigger, p);
 	case SNDCTL_DSP_SETTRIGGER:
 		if (get_user(val, p))
 			return -EFAULT;
 #if defined(DEBUG) || defined(DEBUG_MMAP)
 		printk("SNDCTL_DSP_SETTRIGGER 0x%x\n", val);
 #endif
 		/* silently ignore invalid PCM_ENABLE_xxx bits,
 		 * like the other drivers do
 		 */
 		if (!(file->f_mode & FMODE_READ ))
 			val &= ~PCM_ENABLE_INPUT;
 		if (!(file->f_mode & FMODE_WRITE ))
 			val &= ~PCM_ENABLE_OUTPUT;
 		if((file->f_mode & FMODE_READ) && !(val & PCM_ENABLE_INPUT) && dmabuf->enable == ADC_RUNNING) {
 			stop_adc(state);
 		}
 		if((file->f_mode & FMODE_WRITE) && !(val & PCM_ENABLE_OUTPUT) && dmabuf->enable == DAC_RUNNING) {
 			stop_dac(state);
 		}
 		dmabuf->trigger = val;
 		if((val & PCM_ENABLE_OUTPUT) && !(dmabuf->enable & DAC_RUNNING)) {
 			if (!dmabuf->write_channel) {
 				dmabuf->ready = 0;
 				dmabuf->write_channel = state->card->alloc_pcm_channel(state->card);
 				if (!dmabuf->write_channel)
 					return -EBUSY;
 			}
 			if (!dmabuf->ready && (ret = prog_dmabuf(state, 0)))
 				return ret;
 			if (dmabuf->mapped) {
 				spin_lock_irqsave(&state->card->lock, flags);
 				i810_update_ptr(state);
 				dmabuf->count = 0;
 				dmabuf->swptr = dmabuf->hwptr;
 				dmabuf->count = i810_get_free_write_space(state);
 				dmabuf->swptr = (dmabuf->swptr + dmabuf->count) % dmabuf->dmasize;
 				spin_unlock_irqrestore(&state->card->lock, flags);
 			}
 			i810_update_lvi(state, 0);
 			start_dac(state);
 		}
 		if((val & PCM_ENABLE_INPUT) && !(dmabuf->enable & ADC_RUNNING)) {
 			if (!dmabuf->read_channel) {
 				dmabuf->ready = 0;
 				dmabuf->read_channel = state->card->alloc_rec_pcm_channel(state->card);
 				if (!dmabuf->read_channel)
 					return -EBUSY;
 			}
 			if (!dmabuf->ready && (ret = prog_dmabuf(state, 1)))
 				return ret;
 			if (dmabuf->mapped) {
 				spin_lock_irqsave(&state->card->lock, flags);
 				i810_update_ptr(state);
 				dmabuf->swptr = dmabuf->hwptr;
 				dmabuf->count = 0;
 				spin_unlock_irqrestore(&state->card->lock, flags);
 			}
 			i810_update_lvi(state, 1);
 			start_adc(state);
 		}
 		return 0;
 	case SNDCTL_DSP_SETDUPLEX:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SETDUPLEX\n");
 #endif
 		return -EINVAL;
 	case SNDCTL_DSP_GETODELAY:
 		if (!(file->f_mode & FMODE_WRITE))
 			return -EINVAL;
 		spin_lock_irqsave(&state->card->lock, flags);
 		i810_update_ptr(state);
 		val = dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETODELAY %d\n", dmabuf->count);
 #endif
 		return put_user(val, p);
 	case SOUND_PCM_READ_RATE:
 #ifdef DEBUG
 		printk("SOUND_PCM_READ_RATE %d\n", dmabuf->rate);
 #endif
 		return put_user(dmabuf->rate, p);
 	case SOUND_PCM_READ_CHANNELS:
 #ifdef DEBUG
 		printk("SOUND_PCM_READ_CHANNELS\n");
 #endif
 		return put_user(2, p);
 	case SOUND_PCM_READ_BITS:
 #ifdef DEBUG
 		printk("SOUND_PCM_READ_BITS\n");
 #endif
 		return put_user(AFMT_S16_LE, p);
 	case SNDCTL_DSP_SETSPDIF: /* Set S/PDIF Control register */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_SETSPDIF\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		/* Check to make sure the codec supports S/PDIF transmitter */
 		if((state->card->ac97_features & 4)) {
 			/* mask out the transmitter speed bits so the user can't set them */
 			val &= ~0x3000;
 			/* Add the current transmitter speed bits to the passed value */
 			ret = i810_ac97_get(codec, AC97_SPDIF_CONTROL);
 			val |= (ret & 0x3000);
 			i810_ac97_set(codec, AC97_SPDIF_CONTROL, val);
 			if(i810_ac97_get(codec, AC97_SPDIF_CONTROL) != val ) {
 				printk(KERN_ERR "i810_audio: Unable to set S/PDIF configuration to 0x%04x.\n", val);
 				return -EFAULT;
 			}
 		}
 #ifdef DEBUG
 		else
 			printk(KERN_WARNING "i810_audio: S/PDIF transmitter not avalible.\n");
 #endif
 		return put_user(val, p);
 	case SNDCTL_DSP_GETSPDIF: /* Get S/PDIF Control register */
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETSPDIF\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		/* Check to make sure the codec supports S/PDIF transmitter */
 		if(!(state->card->ac97_features & 4)) {
 #ifdef DEBUG
 			printk(KERN_WARNING "i810_audio: S/PDIF transmitter not avalible.\n");
 #endif
 			val = 0;
 		} else {
 			val = i810_ac97_get(codec, AC97_SPDIF_CONTROL);
 		}
 		//return put_user((val & 0xcfff), p);
 		return put_user(val, p);
 	case SNDCTL_DSP_GETCHANNELMASK:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_GETCHANNELMASK\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		/* Based on AC'97 DAC support, not ICH hardware */
 		val = DSP_BIND_FRONT;
 		if ( state->card->ac97_features & 0x0004 )
 			val |= DSP_BIND_SPDIF;
 		if ( state->card->ac97_features & 0x0080 )
 			val |= DSP_BIND_SURR;
 		if ( state->card->ac97_features & 0x0140 )
 			val |= DSP_BIND_CENTER_LFE;
 		return put_user(val, p);
 	case SNDCTL_DSP_BIND_CHANNEL:
 #ifdef DEBUG
 		printk("SNDCTL_DSP_BIND_CHANNEL\n");
 #endif
 		if (get_user(val, p))
 			return -EFAULT;
 		if ( val == DSP_BIND_QUERY ) {
 			val = DSP_BIND_FRONT; /* Always report this as being enabled */
 			if ( state->card->ac97_status & SPDIF_ON )
 				val |= DSP_BIND_SPDIF;
 			else {
 				if ( state->card->ac97_status & SURR_ON )
 					val |= DSP_BIND_SURR;
 				if ( state->card->ac97_status & CENTER_LFE_ON )
 					val |= DSP_BIND_CENTER_LFE;
 			}
 		} else {  /* Not a query, set it */
 			if (!(file->f_mode & FMODE_WRITE))
 				return -EINVAL;
 			if ( dmabuf->enable == DAC_RUNNING ) {
 				stop_dac(state);
 			}
 			if ( val & DSP_BIND_SPDIF ) {  /* Turn on SPDIF */
 				/*  Ok, this should probably define what slots
 				 *  to use. For now, we'll only set it to the
 				 *  defaults:
 				 *
 				 *   non multichannel codec maps to slots 3&4
 				 *   2 channel codec maps to slots 7&8
 				 *   4 channel codec maps to slots 6&9
 				 *   6 channel codec maps to slots 10&11
 				 *
 				 *  there should be some way for the app to
 				 *  select the slot assignment.
 				 */
 				i810_set_spdif_output ( state, AC97_EA_SPSA_3_4, dmabuf->rate );
 				if ( !(state->card->ac97_status & SPDIF_ON) )
 					val &= ~DSP_BIND_SPDIF;
 			} else {
 				int mask;
 				int channels;
 				/* Turn off S/PDIF if it was on */
 				if ( state->card->ac97_status & SPDIF_ON )
 					i810_set_spdif_output ( state, -1, 0 );
 				mask = val & (DSP_BIND_FRONT | DSP_BIND_SURR | DSP_BIND_CENTER_LFE);
 				switch (mask) {
 					case DSP_BIND_FRONT:
 						channels = 2;
 						break;
 					case DSP_BIND_FRONT|DSP_BIND_SURR:
 						channels = 4;
 						break;
 					case DSP_BIND_FRONT|DSP_BIND_SURR|DSP_BIND_CENTER_LFE:
 						channels = 6;
 						break;
 					default:
 						val = DSP_BIND_FRONT;
 						channels = 2;
 						break;
 				}
 				i810_set_dac_channels ( state, channels );
 				/* check that they really got turned on */
 				if (!(state->card->ac97_status & SURR_ON))
 					val &= ~DSP_BIND_SURR;
 				if (!(state->card->ac97_status & CENTER_LFE_ON))
 					val &= ~DSP_BIND_CENTER_LFE;
 			}
 		}
 		return put_user(val, p);
 	case SNDCTL_DSP_MAPINBUF:
 	case SNDCTL_DSP_MAPOUTBUF:
 	case SNDCTL_DSP_SETSYNCRO:
 	case SOUND_PCM_WRITE_FILTER:
 	case SOUND_PCM_READ_FILTER:
 #ifdef DEBUG
 		printk("SNDCTL_* -EINVAL\n");
 #endif
 		return -EINVAL;
 	}
 	return -EINVAL;
 }
 static int i810_open(struct inode *inode, struct file *file)
 {
 	int i = 0;
 	struct i810_card *card = devs;
 	struct i810_state *state = NULL;
 	struct dmabuf *dmabuf = NULL;
 	/* find an avaiable virtual channel (instance of /dev/dsp) */
 	while (card != NULL) {
 		/*
 		 * If we are initializing and then fail, card could go
 		 * away unuexpectedly while we are in the for() loop.
 		 * So, check for card on each iteration before we check
 		 * for card->initializing to avoid a possible oops.
 		 * This usually only matters for times when the driver is
 		 * autoloaded by kmod.
 		 */
 		for (i = 0; i < 50 && card && card->initializing; i++) {
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout(HZ/20);
 		}
 		for (i = 0; i < NR_HW_CH && card && !card->initializing; i++) {
 			if (card->states[i] == NULL) {
 				state = card->states[i] = (struct i810_state *)
 					kmalloc(sizeof(struct i810_state), GFP_KERNEL);
 				if (state == NULL)
 					return -ENOMEM;
 				memset(state, 0, sizeof(struct i810_state));
 				dmabuf = &state->dmabuf;
 				goto found_virt;
 			}
 		}
 		card = card->next;
 	}
 	/* no more virtual channel avaiable */
 	if (!state)
 		return -ENODEV;
 found_virt:
 	/* initialize the virtual channel */
 	state->virt = i;
 	state->card = card;
 	state->magic = I810_STATE_MAGIC;
 	init_waitqueue_head(&dmabuf->wait);
 	mutex_init(&state->open_mutex);
 	file->private_data = state;
 	dmabuf->trigger = 0;
 	/* allocate hardware channels */
 	if(file->f_mode & FMODE_READ) {
 		if((dmabuf->read_channel = card->alloc_rec_pcm_channel(card)) == NULL) {
 			kfree (card->states[i]);
 			card->states[i] = NULL;
 			return -EBUSY;
 		}
 		dmabuf->trigger |= PCM_ENABLE_INPUT;
 		i810_set_adc_rate(state, 8000);
 	}
 	if(file->f_mode & FMODE_WRITE) {
 		if((dmabuf->write_channel = card->alloc_pcm_channel(card)) == NULL) {
 			/* make sure we free the record channel allocated above */
 			if(file->f_mode & FMODE_READ)
 				card->free_pcm_channel(card,dmabuf->read_channel->num);
 			kfree (card->states[i]);
 			card->states[i] = NULL;
 			return -EBUSY;
 		}
 		/* Initialize to 8kHz?  What if we don't support 8kHz? */
 		/*  Let's change this to check for S/PDIF stuff */
 		dmabuf->trigger |= PCM_ENABLE_OUTPUT;
 		if ( spdif_locked ) {
 			i810_set_dac_rate(state, spdif_locked);
 			i810_set_spdif_output(state, AC97_EA_SPSA_3_4, spdif_locked);
 		} else {
 			i810_set_dac_rate(state, 8000);
 			/* Put the ACLink in 2 channel mode by default */
 			i = I810_IOREADL(card, GLOB_CNT);
 			I810_IOWRITEL(i & 0xffcfffff, card, GLOB_CNT);
 		}
 	}
 	/* set default sample format. According to OSS Programmer's Guide  /dev/dsp
 	   should be default to unsigned 8-bits, mono, with sample rate 8kHz and
 	   /dev/dspW will accept 16-bits sample, but we don't support those so we
 	   set it immediately to stereo and 16bit, which is all we do support */
 	dmabuf->fmt |= I810_FMT_16BIT | I810_FMT_STEREO;
 	dmabuf->ossfragsize = 0;
 	dmabuf->ossmaxfrags  = 0;
 	dmabuf->subdivision  = 0;
 	state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
 	return nonseekable_open(inode, file);
 }
 static int i810_release(struct inode *inode, struct file *file)
 {
 	struct i810_state *state = (struct i810_state *)file->private_data;
 	struct i810_card *card = state->card;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	lock_kernel();
 	/* stop DMA state machine and free DMA buffers/channels */
 	if(dmabuf->trigger & PCM_ENABLE_OUTPUT) {
 		drain_dac(state, 0);
 	}
 	if(dmabuf->trigger & PCM_ENABLE_INPUT) {
 		stop_adc(state);
 	}
 	spin_lock_irqsave(&card->lock, flags);
 	dealloc_dmabuf(state);
 	if (file->f_mode & FMODE_WRITE) {
 		state->card->free_pcm_channel(state->card, dmabuf->write_channel->num);
 	}
 	if (file->f_mode & FMODE_READ) {
 		state->card->free_pcm_channel(state->card, dmabuf->read_channel->num);
 	}
 	state->card->states[state->virt] = NULL;
 	kfree(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 	unlock_kernel();
 	return 0;
 }
 static /*const*/ struct file_operations i810_audio_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= i810_read,
 	.write		= i810_write,
 	.poll		= i810_poll,
 	.ioctl		= i810_ioctl,
 	.mmap		= i810_mmap,
 	.open		= i810_open,
 	.release	= i810_release,
 };
 /* Write AC97 codec registers */
 static u16 i810_ac97_get_mmio(struct ac97_codec *dev, u8 reg)
 {
 	struct i810_card *card = dev->private_data;
 	int count = 100;
 	u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
 	while(count-- && (readb(card->iobase_mmio + CAS) & 1))
 		udelay(1);
 #ifdef DEBUG_MMIO
 	{
 		u16 ans = readw(card->ac97base_mmio + reg_set);
 		printk(KERN_DEBUG "i810_audio: ac97_get_mmio(%d) -> 0x%04X\n", ((int) reg_set) & 0xffff, (u32) ans);
 		return ans;
 	}
 #else
 	return readw(card->ac97base_mmio + reg_set);
 #endif
 }
 static u16 i810_ac97_get_io(struct ac97_codec *dev, u8 reg)
 {
 	struct i810_card *card = dev->private_data;
 	int count = 100;
 	u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
 	while(count-- && (I810_IOREADB(card, CAS) & 1))
 		udelay(1);
 	return inw(card->ac97base + reg_set);
 }
 static void i810_ac97_set_mmio(struct ac97_codec *dev, u8 reg, u16 data)
 {
 	struct i810_card *card = dev->private_data;
 	int count = 100;
 	u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
 	while(count-- && (readb(card->iobase_mmio + CAS) & 1))
 		udelay(1);
 	writew(data, card->ac97base_mmio + reg_set);
 #ifdef DEBUG_MMIO
 	printk(KERN_DEBUG "i810_audio: ac97_set_mmio(0x%04X, %d)\n", (u32) data, ((int) reg_set) & 0xffff);
 #endif
 }
 static void i810_ac97_set_io(struct ac97_codec *dev, u8 reg, u16 data)
 {
 	struct i810_card *card = dev->private_data;
 	int count = 100;
 	u16 reg_set = IO_REG_OFF(dev) | (reg&0x7f);
 	while(count-- && (I810_IOREADB(card, CAS) & 1))
 		udelay(1);
         outw(data, card->ac97base + reg_set);
 }
 static u16 i810_ac97_get(struct ac97_codec *dev, u8 reg)
 {
 	struct i810_card *card = dev->private_data;
 	u16 ret;
 	spin_lock(&card->ac97_lock);
 	if (card->use_mmio) {
 		ret = i810_ac97_get_mmio(dev, reg);
 	}
 	else {
 		ret = i810_ac97_get_io(dev, reg);
 	}
 	spin_unlock(&card->ac97_lock);
 	return ret;
 }
 static void i810_ac97_set(struct ac97_codec *dev, u8 reg, u16 data)
 {
 	struct i810_card *card = dev->private_data;
 	spin_lock(&card->ac97_lock);
 	if (card->use_mmio) {
 		i810_ac97_set_mmio(dev, reg, data);
 	}
 	else {
 		i810_ac97_set_io(dev, reg, data);
 	}
 	spin_unlock(&card->ac97_lock);
 }
 /* OSS /dev/mixer file operation methods */
 static int i810_open_mixdev(struct inode *inode, struct file *file)
 {
 	int i;
 	int minor = iminor(inode);
 	struct i810_card *card = devs;
 	for (card = devs; card != NULL; card = card->next) {
 		/*
 		 * If we are initializing and then fail, card could go
 		 * away unuexpectedly while we are in the for() loop.
 		 * So, check for card on each iteration before we check
 		 * for card->initializing to avoid a possible oops.
 		 * This usually only matters for times when the driver is
 		 * autoloaded by kmod.
 		 */
 		for (i = 0; i < 50 && card && card->initializing; i++) {
 			set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule_timeout(HZ/20);
 		}
 		for (i = 0; i < NR_AC97 && card && !card->initializing; i++)
 			if (card->ac97_codec[i] != NULL &&
 			    card->ac97_codec[i]->dev_mixer == minor) {
 				file->private_data = card->ac97_codec[i];
 				return nonseekable_open(inode, file);
 			}
 	}
 	return -ENODEV;
 }
 static int i810_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 				unsigned long arg)
 {
 	struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 	return codec->mixer_ioctl(codec, cmd, arg);
 }
 static /*const*/ struct file_operations i810_mixer_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.ioctl		= i810_ioctl_mixdev,
 	.open		= i810_open_mixdev,
 };
 /* AC97 codec initialisation.  These small functions exist so we don't
    duplicate code between module init and apm resume */
 static inline int i810_ac97_exists(struct i810_card *card, int ac97_number)
 {
 	u32 reg = I810_IOREADL(card, GLOB_STA);
 	switch (ac97_number) {
 	case 0:
 		return reg & (1<<8);
 	case 1:
 		return reg & (1<<9);
 	case 2:
 		return reg & (1<<28);
 	}
 	return 0;
 }
 static inline int i810_ac97_enable_variable_rate(struct ac97_codec *codec)
 {
 	i810_ac97_set(codec, AC97_EXTENDED_STATUS, 9);
 	i810_ac97_set(codec,AC97_EXTENDED_STATUS,
 		      i810_ac97_get(codec, AC97_EXTENDED_STATUS)|0xE800);
 	return (i810_ac97_get(codec, AC97_EXTENDED_STATUS)&1);
 }
 static int i810_ac97_probe_and_powerup(struct i810_card *card,struct ac97_codec *codec)
 {
 	/* Returns 0 on failure */
 	int i;
 	if (ac97_probe_codec(codec) == 0) return 0;
 	/* power it all up */
 	i810_ac97_set(codec, AC97_POWER_CONTROL,
 		      i810_ac97_get(codec, AC97_POWER_CONTROL) & ~0x7f00);
 	/* wait for analog ready */
 	for (i=100; i && ((i810_ac97_get(codec, AC97_POWER_CONTROL) & 0xf) != 0xf); i--)
 	{
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(HZ/20);
 	}
 	return i;
 }
 static int is_new_ich(u16 pci_id)
 {
 	switch (pci_id) {
 	case PCI_DEVICE_ID_INTEL_82801DB_5:
 	case PCI_DEVICE_ID_INTEL_82801EB_5:
 	case PCI_DEVICE_ID_INTEL_ESB_5:
 	case PCI_DEVICE_ID_INTEL_ICH6_18:
 		return 1;
 	default:
 		break;
 	}
 	return 0;
 }
 static inline int ich_use_mmio(struct i810_card *card)
 {
 	return is_new_ich(card->pci_id) && card->use_mmio;
 }
 /**
  *	i810_ac97_power_up_bus	-	bring up AC97 link
  *	@card : ICH audio device to power up
  *
  *	Bring up the ACLink AC97 codec bus
  */
 static int i810_ac97_power_up_bus(struct i810_card *card)
 {
 	u32 reg = I810_IOREADL(card, GLOB_CNT);
 	int i;
 	int primary_codec_id = 0;
 	if((reg&2)==0)	/* Cold required */
 		reg|=2;
 	else
 		reg|=4;	/* Warm */
 	reg&=~8;	/* ACLink on */
 	/* At this point we deassert AC_RESET # */
 	I810_IOWRITEL(reg , card, GLOB_CNT);
 	/* We must now allow time for the Codec initialisation.
 	   600mS is the specified time */
 	for(i=0;i<10;i++)
 	{
 		if((I810_IOREADL(card, GLOB_CNT)&4)==0)
 			break;
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(HZ/20);
 	}
 	if(i==10)
 	{
 		printk(KERN_ERR "i810_audio: AC'97 reset failed.\n");
 		return 0;
 	}
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	schedule_timeout(HZ/2);
 	/*
 	 *	See if the primary codec comes ready. This must happen
 	 *	before we start doing DMA stuff
 	 */
 	/* see i810_ac97_init for the next 10 lines (jsaw) */
 	if (card->use_mmio)
 		readw(card->ac97base_mmio);
 	else
 		inw(card->ac97base);
 	if (ich_use_mmio(card)) {
 		primary_codec_id = (int) readl(card->iobase_mmio + SDM) & 0x3;
 		printk(KERN_INFO "i810_audio: Primary codec has ID %d\n",
 		       primary_codec_id);
 	}
 	if(! i810_ac97_exists(card, primary_codec_id))
 	{
 		printk(KERN_INFO "i810_audio: Codec not ready.. wait.. ");
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(HZ);	/* actually 600mS by the spec */
 		if(i810_ac97_exists(card, primary_codec_id))
 			printk("OK\n");
 		else
 			printk("no response.\n");
 	}
 	if (card->use_mmio)
 		readw(card->ac97base_mmio);
 	else
 		inw(card->ac97base);
 	return 1;
 }
 static int __devinit i810_ac97_init(struct i810_card *card)
 {
 	int num_ac97 = 0;
 	int ac97_id;
 	int total_channels = 0;
 	int nr_ac97_max = card_cap[card->pci_id_internal].nr_ac97;
 	struct ac97_codec *codec;
 	u16 eid;
 	u32 reg;
 	if(!i810_ac97_power_up_bus(card)) return 0;
 	/* Number of channels supported */
 	/* What about the codec?  Just because the ICH supports */
 	/* multiple channels doesn't mean the codec does.       */
 	/* we'll have to modify this in the codec section below */
 	/* to reflect what the codec has.                       */
 	/* ICH and ICH0 only support 2 channels so don't bother */
 	/* to check....                                         */
 	card->channels = 2;
 	reg = I810_IOREADL(card, GLOB_STA);
 	if ( reg & 0x0200000 )
 		card->channels = 6;
 	else if ( reg & 0x0100000 )
 		card->channels = 4;
 	printk(KERN_INFO "i810_audio: Audio Controller supports %d channels.\n", card->channels);
 	printk(KERN_INFO "i810_audio: Defaulting to base 2 channel mode.\n");
 	reg = I810_IOREADL(card, GLOB_CNT);
 	I810_IOWRITEL(reg & 0xffcfffff, card, GLOB_CNT);
 	for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++)
 		card->ac97_codec[num_ac97] = NULL;
 	/*@FIXME I don't know, if I'm playing to safe here... (jsaw) */
 	if ((nr_ac97_max > 2) && !card->use_mmio) nr_ac97_max = 2;
 	for (num_ac97 = 0; num_ac97 < nr_ac97_max; num_ac97++) {
 		/* codec reset */
 		printk(KERN_INFO "i810_audio: Resetting connection %d\n", num_ac97);
 		if (card->use_mmio)
 			readw(card->ac97base_mmio + 0x80*num_ac97);
 		else
 			inw(card->ac97base + 0x80*num_ac97);
 		/* If we have the SDATA_IN Map Register, as on ICH4, we
 		   do not loop thru all possible codec IDs but thru all
 		   possible IO channels. Bit 0:1 of SDM then holds the
 		   last codec ID spoken to.
 		*/
 		if (ich_use_mmio(card)) {
 			ac97_id = (int) readl(card->iobase_mmio + SDM) & 0x3;
 			printk(KERN_INFO "i810_audio: Connection %d with codec id %d\n",
 			       num_ac97, ac97_id);
 		}
 		else {
 			ac97_id = num_ac97;
 		}
 		/* The ICH programmer's reference says you should   */
 		/* check the ready status before probing. So we chk */
 		/*   What do we do if it's not ready?  Wait and try */
 		/*   again, or abort?                               */
 		if (!i810_ac97_exists(card, ac97_id)) {
 			if(num_ac97 == 0)
 				printk(KERN_ERR "i810_audio: Primary codec not ready.\n");
 		}
 		if ((codec = ac97_alloc_codec()) == NULL)
 			return -ENOMEM;
 		/* initialize some basic codec information, other fields will be filled
 		   in ac97_probe_codec */
 		codec->private_data = card;
 		codec->id = ac97_id;
 		card->ac97_id_map[ac97_id] = num_ac97 * 0x80;
 		if (card->use_mmio) {
 			codec->codec_read = i810_ac97_get_mmio;
 			codec->codec_write = i810_ac97_set_mmio;
 		}
 		else {
 			codec->codec_read = i810_ac97_get_io;
 			codec->codec_write = i810_ac97_set_io;
 		}
 		if(!i810_ac97_probe_and_powerup(card,codec)) {
 			printk(KERN_ERR "i810_audio: timed out waiting for codec %d analog ready.\n", ac97_id);
 			ac97_release_codec(codec);
 			break;	/* it didn't work */
 		}
 		/* Store state information about S/PDIF transmitter */
 		card->ac97_status = 0;
 		/* Don't attempt to get eid until powerup is complete */
 		eid = i810_ac97_get(codec, AC97_EXTENDED_ID);
 		if(eid==0xFFFF)
 		{
 			printk(KERN_WARNING "i810_audio: no codec attached ?\n");
 			ac97_release_codec(codec);
 			break;
 		}
 		/* Check for an AC97 1.0 soft modem (ID1) */
 		if(codec->modem)
 		{
 			printk(KERN_WARNING "i810_audio: codec %d is a softmodem - skipping.\n", ac97_id);
 			ac97_release_codec(codec);
 			continue;
 		}
 		card->ac97_features = eid;
 		/* Now check the codec for useful features to make up for
 		   the dumbness of the 810 hardware engine */
 		if(!(eid&0x0001))
 			printk(KERN_WARNING "i810_audio: only 48Khz playback available.\n");
 		else
 		{
 			if(!i810_ac97_enable_variable_rate(codec)) {
 				printk(KERN_WARNING "i810_audio: Codec refused to allow VRA, using 48Khz only.\n");
 				card->ac97_features&=~1;
 			}
 		}
 		/* Turn on the amplifier */
 		codec->codec_write(codec, AC97_POWER_CONTROL,
 			 codec->codec_read(codec, AC97_POWER_CONTROL) & ~0x8000);
 		/* Determine how many channels the codec(s) support   */
 		/*   - The primary codec always supports 2            */
 		/*   - If the codec supports AMAP, surround DACs will */
 		/*     automaticlly get assigned to slots.            */
 		/*     * Check for surround DACs and increment if     */
 		/*       found.                                       */
 		/*   - Else check if the codec is revision 2.2        */
 		/*     * If surround DACs exist, assign them to slots */
 		/*       and increment channel count.                 */
 		/* All of this only applies to ICH2 and above. ICH    */
 		/* and ICH0 only support 2 channels.  ICH2 will only  */
 		/* support multiple codecs in a "split audio" config. */
 		/* as described above.                                */
 		/* TODO: Remove all the debugging messages!           */
 		if((eid & 0xc000) == 0) /* primary codec */
 			total_channels += 2;
 		if(eid & 0x200) { /* GOOD, AMAP support */
 			if (eid & 0x0080) /* L/R Surround channels */
 				total_channels += 2;
 			if (eid & 0x0140) /* LFE and Center channels */
 				total_channels += 2;
 			printk("i810_audio: AC'97 codec %d supports AMAP, total channels = %d\n", ac97_id, total_channels);
 		} else if (eid & 0x0400) {  /* this only works on 2.2 compliant codecs */
 			eid &= 0xffcf;
 			if((eid & 0xc000) != 0)	{
 				switch ( total_channels ) {
 					case 2:
 						/* Set dsa1, dsa0 to 01 */
 						eid |= 0x0010;
 						break;
 					case 4:
 						/* Set dsa1, dsa0 to 10 */
 						eid |= 0x0020;
 						break;
 					case 6:
 						/* Set dsa1, dsa0 to 11 */
 						eid |= 0x0030;
 						break;
 				}
 				total_channels += 2;
 			}
 			i810_ac97_set(codec, AC97_EXTENDED_ID, eid);
 			eid = i810_ac97_get(codec, AC97_EXTENDED_ID);
 			printk("i810_audio: AC'97 codec %d, new EID value = 0x%04x\n", ac97_id, eid);
 			if (eid & 0x0080) /* L/R Surround channels */
 				total_channels += 2;
 			if (eid & 0x0140) /* LFE and Center channels */
 				total_channels += 2;
 			printk("i810_audio: AC'97 codec %d, DAC map configured, total channels = %d\n", ac97_id, total_channels);
 		} else {
 			printk("i810_audio: AC'97 codec %d Unable to map surround DAC's (or DAC's not present), total channels = %d\n", ac97_id, total_channels);
 		}
 		if ((codec->dev_mixer = register_sound_mixer(&i810_mixer_fops, -1)) < 0) {
 			printk(KERN_ERR "i810_audio: couldn't register mixer!\n");
 			ac97_release_codec(codec);
 			break;
 		}
 		card->ac97_codec[num_ac97] = codec;
 	}
 	/* tune up the primary codec */
 	ac97_tune_hardware(card->pci_dev, ac97_quirks, ac97_quirk);
 	/* pick the minimum of channels supported by ICHx or codec(s) */
 	card->channels = (card->channels > total_channels)?total_channels:card->channels;
 	return num_ac97;
 }
 static void __devinit i810_configure_clocking (void)
 {
 	struct i810_card *card;
 	struct i810_state *state;
 	struct dmabuf *dmabuf;
 	unsigned int i, offset, new_offset;
 	unsigned long flags;
 	card = devs;
 	/* We could try to set the clocking for multiple cards, but can you even have
 	 * more than one i810 in a machine?  Besides, clocking is global, so unless
 	 * someone actually thinks more than one i810 in a machine is possible and
 	 * decides to rewrite that little bit, setting the rate for more than one card
 	 * is a waste of time.
 	 */
 	if(card != NULL) {
 		state = card->states[0] = (struct i810_state *)
 					kmalloc(sizeof(struct i810_state), GFP_KERNEL);
 		if (state == NULL)
 			return;
 		memset(state, 0, sizeof(struct i810_state));
 		dmabuf = &state->dmabuf;
 		dmabuf->write_channel = card->alloc_pcm_channel(card);
 		state->virt = 0;
 		state->card = card;
 		state->magic = I810_STATE_MAGIC;
 		init_waitqueue_head(&dmabuf->wait);
 		mutex_init(&state->open_mutex);
 		dmabuf->fmt = I810_FMT_STEREO | I810_FMT_16BIT;
 		dmabuf->trigger = PCM_ENABLE_OUTPUT;
 		i810_set_spdif_output(state, -1, 0);
 		i810_set_dac_channels(state, 2);
 		i810_set_dac_rate(state, 48000);
 		if(prog_dmabuf(state, 0) != 0) {
 			goto config_out_nodmabuf;
 		}
 		if(dmabuf->dmasize < 16384) {
 			goto config_out;
 		}
 		dmabuf->count = dmabuf->dmasize;
 		CIV_TO_LVI(card, dmabuf->write_channel->port, -1);
 		local_irq_save(flags);
 		start_dac(state);
 		offset = i810_get_dma_addr(state, 0);
 		mdelay(50);
 		new_offset = i810_get_dma_addr(state, 0);
 		stop_dac(state);
 		local_irq_restore(flags);
 		i = new_offset - offset;
 #ifdef DEBUG_INTERRUPTS
 		printk("i810_audio: %d bytes in 50 milliseconds\n", i);
 #endif
 		if(i == 0)
 			goto config_out;
 		i = i / 4 * 20;
 		if (i > 48500 || i < 47500) {
 			clocking = clocking * clocking / i;
 			printk("i810_audio: setting clocking to %d\n", clocking);
 		}
 config_out:
 		dealloc_dmabuf(state);
 config_out_nodmabuf:
 		state->card->free_pcm_channel(state->card,state->dmabuf.write_channel->num);
 		kfree(state);
 		card->states[0] = NULL;
 	}
 }
 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
    until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
 static int __devinit i810_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
 {
 	struct i810_card *card;
 	if (pci_enable_device(pci_dev))
 		return -EIO;
 	if (pci_set_dma_mask(pci_dev, I810_DMA_MASK)) {
 		printk(KERN_ERR "i810_audio: architecture does not support"
 		       " 32bit PCI busmaster DMA\n");
 		return -ENODEV;
 	}
 	if ((card = kmalloc(sizeof(struct i810_card), GFP_KERNEL)) == NULL) {
 		printk(KERN_ERR "i810_audio: out of memory\n");
 		return -ENOMEM;
 	}
 	memset(card, 0, sizeof(*card));
 	card->initializing = 1;
 	card->pci_dev = pci_dev;
 	card->pci_id = pci_id->device;
 	card->ac97base = pci_resource_start (pci_dev, 0);
 	card->iobase = pci_resource_start (pci_dev, 1);
 	if (!(card->ac97base) || !(card->iobase)) {
 		card->ac97base = 0;
 		card->iobase = 0;
 	}
 	/* if chipset could have mmio capability, check it */
 	if (card_cap[pci_id->driver_data].flags & CAP_MMIO) {
 		card->ac97base_mmio_phys = pci_resource_start (pci_dev, 2);
 		card->iobase_mmio_phys = pci_resource_start (pci_dev, 3);
 		if ((card->ac97base_mmio_phys) && (card->iobase_mmio_phys)) {
 			card->use_mmio = 1;
 		}
 		else {
 			card->ac97base_mmio_phys = 0;
 			card->iobase_mmio_phys = 0;
 		}
 	}
 	if (!(card->use_mmio) && (!(card->iobase) || !(card->ac97base))) {
 		printk(KERN_ERR "i810_audio: No I/O resources available.\n");
 		goto out_mem;
 	}
 	card->irq = pci_dev->irq;
 	card->next = devs;
 	card->magic = I810_CARD_MAGIC;
 #ifdef CONFIG_PM
 	card->pm_suspended=0;
 #endif
 	spin_lock_init(&card->lock);
 	spin_lock_init(&card->ac97_lock);
 	devs = card;
 	pci_set_master(pci_dev);
 	printk(KERN_INFO "i810: %s found at IO 0x%04lx and 0x%04lx, "
 	       "MEM 0x%04lx and 0x%04lx, IRQ %d\n",
 	       card_names[pci_id->driver_data],
 	       card->iobase, card->ac97base,
 	       card->ac97base_mmio_phys, card->iobase_mmio_phys,
 	       card->irq);
 	card->alloc_pcm_channel = i810_alloc_pcm_channel;
 	card->alloc_rec_pcm_channel = i810_alloc_rec_pcm_channel;
 	card->alloc_rec_mic_channel = i810_alloc_rec_mic_channel;
 	card->free_pcm_channel = i810_free_pcm_channel;
 	if ((card->channel = pci_alloc_consistent(pci_dev,
 	    sizeof(struct i810_channel)*NR_HW_CH, &card->chandma)) == NULL) {
 		printk(KERN_ERR "i810: cannot allocate channel DMA memory\n");
 		goto out_mem;
 	}
 	{ /* We may dispose of this altogether some time soon, so... */
 		struct i810_channel *cp = card->channel;
 		cp[0].offset = 0;
 		cp[0].port = 0x00;
 		cp[0].num = 0;
 		cp[1].offset = 0;
 		cp[1].port = 0x10;
 		cp[1].num = 1;
 		cp[2].offset = 0;
 		cp[2].port = 0x20;
 		cp[2].num = 2;
 	}
 	/* claim our iospace and irq */
 	if (!request_region(card->iobase, 64, card_names[pci_id->driver_data])) {
 		printk(KERN_ERR "i810_audio: unable to allocate region %lx\n", card->iobase);
 		goto out_region1;
 	}
 	if (!request_region(card->ac97base, 256, card_names[pci_id->driver_data])) {
 		printk(KERN_ERR "i810_audio: unable to allocate region %lx\n", card->ac97base);
 		goto out_region2;
 	}
 	if (card->use_mmio) {
 		if (request_mem_region(card->ac97base_mmio_phys, 512, "ich_audio MMBAR")) {
 			if ((card->ac97base_mmio = ioremap(card->ac97base_mmio_phys, 512))) { /*@FIXME can ioremap fail? don't know (jsaw) */
 				if (request_mem_region(card->iobase_mmio_phys, 256, "ich_audio MBBAR")) {
 					if ((card->iobase_mmio = ioremap(card->iobase_mmio_phys, 256))) {
 						printk(KERN_INFO "i810: %s mmio at 0x%04lx and 0x%04lx\n",
 						       card_names[pci_id->driver_data],
 						       (unsigned long) card->ac97base_mmio,
 						       (unsigned long) card->iobase_mmio);
 					}
 					else {
 						iounmap(card->ac97base_mmio);
 						release_mem_region(card->ac97base_mmio_phys, 512);
 						release_mem_region(card->iobase_mmio_phys, 512);
 						card->use_mmio = 0;
 					}
 				}
 				else {
 					iounmap(card->ac97base_mmio);
 					release_mem_region(card->ac97base_mmio_phys, 512);
 					card->use_mmio = 0;
 				}
 			}
 		}
 		else {
 			card->use_mmio = 0;
 		}
 	}
 	/* initialize AC97 codec and register /dev/mixer */
 	if (i810_ac97_init(card) <= 0)
 		goto out_iospace;
 	pci_set_drvdata(pci_dev, card);
 	if(clocking == 0) {
 		clocking = 48000;
 		i810_configure_clocking();
 	}
 	/* register /dev/dsp */
 	if ((card->dev_audio = register_sound_dsp(&i810_audio_fops, -1)) < 0) {
 		int i;
 		printk(KERN_ERR "i810_audio: couldn't register DSP device!\n");
 		for (i = 0; i < NR_AC97; i++)
 		if (card->ac97_codec[i] != NULL) {
 			unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
 			ac97_release_codec(card->ac97_codec[i]);
 		}
 		goto out_iospace;
 	}
 	if (request_irq(card->irq, &i810_interrupt, IRQF_SHARED,
 			card_names[pci_id->driver_data], card)) {
 		printk(KERN_ERR "i810_audio: unable to allocate irq %d\n", card->irq);
 		goto out_iospace;
 	}
  	card->initializing = 0;
 	return 0;
 out_iospace:
 	if (card->use_mmio) {
 		iounmap(card->ac97base_mmio);
 		iounmap(card->iobase_mmio);
 		release_mem_region(card->ac97base_mmio_phys, 512);
 		release_mem_region(card->iobase_mmio_phys, 256);
 	}
 	release_region(card->ac97base, 256);
 out_region2:
 	release_region(card->iobase, 64);
 out_region1:
 	pci_free_consistent(pci_dev, sizeof(struct i810_channel)*NR_HW_CH,
 	    card->channel, card->chandma);
 out_mem:
 	kfree(card);
 	return -ENODEV;
 }
 static void __devexit i810_remove(struct pci_dev *pci_dev)
 {
 	int i;
 	struct i810_card *card = pci_get_drvdata(pci_dev);
 	/* free hardware resources */
 	free_irq(card->irq, devs);
 	release_region(card->iobase, 64);
 	release_region(card->ac97base, 256);
 	pci_free_consistent(pci_dev, sizeof(struct i810_channel)*NR_HW_CH,
 			    card->channel, card->chandma);
 	if (card->use_mmio) {
 		iounmap(card->ac97base_mmio);
 		iounmap(card->iobase_mmio);
 		release_mem_region(card->ac97base_mmio_phys, 512);
 		release_mem_region(card->iobase_mmio_phys, 256);
 	}
 	/* unregister audio devices */
 	for (i = 0; i < NR_AC97; i++)
 		if (card->ac97_codec[i] != NULL) {
 			unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
 			ac97_release_codec(card->ac97_codec[i]);
 			card->ac97_codec[i] = NULL;
 		}
 	unregister_sound_dsp(card->dev_audio);
 	kfree(card);
 }
 #ifdef CONFIG_PM
 static int i810_pm_suspend(struct pci_dev *dev, pm_message_t pm_state)
 {
         struct i810_card *card = pci_get_drvdata(dev);
         struct i810_state *state;
 	unsigned long flags;
 	struct dmabuf *dmabuf;
 	int i,num_ac97;
 #ifdef DEBUG
 	printk("i810_audio: i810_pm_suspend called\n");
 #endif
 	if(!card) return 0;
 	spin_lock_irqsave(&card->lock, flags);
 	card->pm_suspended=1;
 	for(i=0;i<NR_HW_CH;i++) {
 		state = card->states[i];
 		if(!state) continue;
 		/* this happens only if there are open files */
 		dmabuf = &state->dmabuf;
 		if(dmabuf->enable & DAC_RUNNING ||
 		   (dmabuf->count && (dmabuf->trigger & PCM_ENABLE_OUTPUT))) {
 			state->pm_saved_dac_rate=dmabuf->rate;
 			stop_dac(state);
 		} else {
 			state->pm_saved_dac_rate=0;
 		}
 		if(dmabuf->enable & ADC_RUNNING) {
 			state->pm_saved_adc_rate=dmabuf->rate;
 			stop_adc(state);
 		} else {
 			state->pm_saved_adc_rate=0;
 		}
 		dmabuf->ready = 0;
 		dmabuf->swptr = dmabuf->hwptr = 0;
 		dmabuf->count = dmabuf->total_bytes = 0;
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 	/* save mixer settings */
 	for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
 		struct ac97_codec *codec = card->ac97_codec[num_ac97];
 		if(!codec) continue;
 		for(i=0;i< SOUND_MIXER_NRDEVICES ;i++) {
 			if((supported_mixer(codec,i)) &&
 			   (codec->read_mixer)) {
 				card->pm_saved_mixer_settings[i][num_ac97]=
 					codec->read_mixer(codec,i);
 			}
 		}
 	}
 	pci_save_state(dev); /* XXX do we need this? */
 	pci_disable_device(dev); /* disable busmastering */
 	pci_set_power_state(dev,3); /* Zzz. */
 	return 0;
 }
 static int i810_pm_resume(struct pci_dev *dev)
 {
 	int num_ac97,i=0;
 	struct i810_card *card=pci_get_drvdata(dev);
 	pci_enable_device(dev);
 	pci_restore_state (dev);
 	/* observation of a toshiba portege 3440ct suggests that the
 	   hardware has to be more or less completely reinitialized from
 	   scratch after an apm suspend.  Works For Me.   -dan */
 	i810_ac97_power_up_bus(card);
 	for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
 		struct ac97_codec *codec = card->ac97_codec[num_ac97];
 		/* check they haven't stolen the hardware while we were
 		   away */
 		if(!codec || !i810_ac97_exists(card,num_ac97)) {
 			if(num_ac97) continue;
 			else BUG();
 		}
 		if(!i810_ac97_probe_and_powerup(card,codec)) BUG();
 		if((card->ac97_features&0x0001)) {
 			/* at probe time we found we could do variable
 			   rates, but APM suspend has made it forget
 			   its magical powers */
 			if(!i810_ac97_enable_variable_rate(codec)) BUG();
 		}
 		/* we lost our mixer settings, so restore them */
 		for(i=0;i< SOUND_MIXER_NRDEVICES ;i++) {
 			if(supported_mixer(codec,i)){
 				int val=card->
 					pm_saved_mixer_settings[i][num_ac97];
 				codec->mixer_state[i]=val;
 				codec->write_mixer(codec,i,
 						   (val  & 0xff) ,
 						   ((val >> 8)  & 0xff) );
 			}
 		}
 	}
 	/* we need to restore the sample rate from whatever it was */
 	for(i=0;i<NR_HW_CH;i++) {
 		struct i810_state * state=card->states[i];
 		if(state) {
 			if(state->pm_saved_adc_rate)
 				i810_set_adc_rate(state,state->pm_saved_adc_rate);
 			if(state->pm_saved_dac_rate)
 				i810_set_dac_rate(state,state->pm_saved_dac_rate);
 		}
 	}
         card->pm_suspended = 0;
 	/* any processes that were reading/writing during the suspend
 	   probably ended up here */
 	for(i=0;i<NR_HW_CH;i++) {
 		struct i810_state *state = card->states[i];
 		if(state) wake_up(&state->dmabuf.wait);
         }
 	return 0;
 }
 #endif /* CONFIG_PM */
 MODULE_AUTHOR("The Linux kernel team");
 MODULE_DESCRIPTION("Intel 810 audio support");
 MODULE_LICENSE("GPL");
 module_param(ftsodell, int, 0444);
 module_param(clocking, uint, 0444);
 module_param(strict_clocking, int, 0444);
 module_param(spdif_locked, int, 0444);
 #define I810_MODULE_NAME "i810_audio"
 static struct pci_driver i810_pci_driver = {
 	.name		= I810_MODULE_NAME,
 	.id_table	= i810_pci_tbl,
 	.probe		= i810_probe,
 	.remove		= __devexit_p(i810_remove),
 #ifdef CONFIG_PM
 	.suspend	= i810_pm_suspend,
 	.resume		= i810_pm_resume,
 #endif /* CONFIG_PM */
 };
 static int __init i810_init_module (void)
 {
 	int retval;
 	printk(KERN_INFO "Intel 810 + AC97 Audio, version "
 	       DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
 	retval = pci_register_driver(&i810_pci_driver);
 	if (retval)
 		return retval;
 	if(ftsodell != 0) {
 		printk("i810_audio: ftsodell is now a deprecated option.\n");
 	}
 	if(spdif_locked > 0 ) {
 		if(spdif_locked == 32000 || spdif_locked == 44100 || spdif_locked == 48000) {
 			printk("i810_audio: Enabling S/PDIF at sample rate %dHz.\n", spdif_locked);
 		} else {
 			printk("i810_audio: S/PDIF can only be locked to 32000, 44100, or 48000Hz.\n");
 			spdif_locked = 0;
 		}
 	}
 	return 0;
 }
 static void __exit i810_cleanup_module (void)
 {
 	pci_unregister_driver(&i810_pci_driver);
 }
 module_init(i810_init_module);
 module_exit(i810_cleanup_module);
 /*
 Local Variables:
 c-basic-offset: 8
 End:
 */

sound/oss/soundcard.c

Diff comments View file @ f23f6e0

 /*
  * linux/sound/oss/soundcard.c
  *
  * Sound card driver for Linux
  *
  *
  * Copyright (C) by Hannu Savolainen 1993-1997
  *
  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  * for more info.
  *
  *
  * Thomas Sailer     : ioctl code reworked (vmalloc/vfree removed)
  *                   integrated sound_switch.c
  * Stefan Reinauer   : integrated /proc/sound (equals to /dev/sndstat,
  *                   which should disappear in the near future)
  * Eric Dumas	     : devfs support (22-Jan-98) <dumas@linux.eu.org> with
  *                   fixups by C. Scott Ananian <cananian@alumni.princeton.edu>
  * Richard Gooch     : moved common (non OSS-specific) devices to sound_core.c
  * Rob Riggs	     : Added persistent DMA buffers support (1998/10/17)
  * Christoph Hellwig : Some cleanup work (2000/03/01)
  */
 #include "sound_config.h"
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
 #include <linux/fcntl.h>
 #include <linux/ctype.h>
 #include <linux/stddef.h>
 #include <linux/kmod.h>
 #include <asm/dma.h>
 #include <asm/io.h>
 #include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/major.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/module.h>
+#include <linux/mm.h>
 /*
  * This ought to be moved into include/asm/dma.h
  */
 #ifndef valid_dma
 #define valid_dma(n) ((n) >= 0 && (n) < MAX_DMA_CHANNELS && (n) != 4)
 #endif
 /*
  * Table for permanently allocated memory (used when unloading the module)
  */
 void *          sound_mem_blocks[1024];
 int             sound_nblocks = 0;
 /* Persistent DMA buffers */
 #ifdef CONFIG_SOUND_DMAP
 int             sound_dmap_flag = 1;
 #else
 int             sound_dmap_flag = 0;
 #endif
 static char     dma_alloc_map[MAX_DMA_CHANNELS];
 #define DMA_MAP_UNAVAIL		0
 #define DMA_MAP_FREE		1
 #define DMA_MAP_BUSY		2
 unsigned long seq_time = 0;	/* Time for /dev/sequencer */
 extern struct class *sound_class;
 /*
  * Table for configurable mixer volume handling
  */
 static mixer_vol_table mixer_vols[MAX_MIXER_DEV];
 static int num_mixer_volumes;
 int *load_mixer_volumes(char *name, int *levels, int present)
 {
 	int             i, n;
 	for (i = 0; i < num_mixer_volumes; i++) {
 		if (strcmp(name, mixer_vols[i].name) == 0) {
 			if (present)
 				mixer_vols[i].num = i;
 			return mixer_vols[i].levels;
 		}
 	}
 	if (num_mixer_volumes >= MAX_MIXER_DEV) {
 		printk(KERN_ERR "Sound: Too many mixers (%s)\n", name);
 		return levels;
 	}
 	n = num_mixer_volumes++;
 	strcpy(mixer_vols[n].name, name);
 	if (present)
 		mixer_vols[n].num = n;
 	else
 		mixer_vols[n].num = -1;
 	for (i = 0; i < 32; i++)
 		mixer_vols[n].levels[i] = levels[i];
 	return mixer_vols[n].levels;
 }
 EXPORT_SYMBOL(load_mixer_volumes);
 static int set_mixer_levels(void __user * arg)
 {
         /* mixer_vol_table is 174 bytes, so IMHO no reason to not allocate it on the stack */
 	mixer_vol_table buf;
 	if (__copy_from_user(&buf, arg, sizeof(buf)))
 		return -EFAULT;
 	load_mixer_volumes(buf.name, buf.levels, 0);
 	if (__copy_to_user(arg, &buf, sizeof(buf)))
 		return -EFAULT;
 	return 0;
 }
 static int get_mixer_levels(void __user * arg)
 {
 	int n;
 	if (__get_user(n, (int __user *)(&(((mixer_vol_table __user *)arg)->num))))
 		return -EFAULT;
 	if (n < 0 || n >= num_mixer_volumes)
 		return -EINVAL;
 	if (__copy_to_user(arg, &mixer_vols[n], sizeof(mixer_vol_table)))
 		return -EFAULT;
 	return 0;
 }
 /* 4K page size but our output routines use some slack for overruns */
 #define PROC_BLOCK_SIZE (3*1024)
 static ssize_t sound_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
 	int dev = iminor(file->f_dentry->d_inode);
 	int ret = -EINVAL;
 	/*
 	 *	The OSS drivers aren't remotely happy without this locking,
 	 *	and unless someone fixes them when they are about to bite the
 	 *	big one anyway, we might as well bandage here..
 	 */
 	lock_kernel();
 	DEB(printk("sound_read(dev=%d, count=%d)\n", dev, count));
 	switch (dev & 0x0f) {
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		ret = audio_read(dev, file, buf, count);
 		break;
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		ret = sequencer_read(dev, file, buf, count);
 		break;
 	case SND_DEV_MIDIN:
 		ret = MIDIbuf_read(dev, file, buf, count);
 	}
 	unlock_kernel();
 	return ret;
 }
 static ssize_t sound_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
 	int dev = iminor(file->f_dentry->d_inode);
 	int ret = -EINVAL;
 	lock_kernel();
 	DEB(printk("sound_write(dev=%d, count=%d)\n", dev, count));
 	switch (dev & 0x0f) {
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		ret =  sequencer_write(dev, file, buf, count);
 		break;
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		ret = audio_write(dev, file, buf, count);
 		break;
 	case SND_DEV_MIDIN:
 		ret =  MIDIbuf_write(dev, file, buf, count);
 		break;
 	}
 	unlock_kernel();
 	return ret;
 }
 static int sound_open(struct inode *inode, struct file *file)
 {
 	int dev = iminor(inode);
 	int retval;
 	DEB(printk("sound_open(dev=%d)\n", dev));
 	if ((dev >= SND_NDEVS) || (dev < 0)) {
 		printk(KERN_ERR "Invalid minor device %d\n", dev);
 		return -ENXIO;
 	}
 	switch (dev & 0x0f) {
 	case SND_DEV_CTL:
 		dev >>= 4;
 		if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
 			request_module("mixer%d", dev);
 		}
 		if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
 			return -ENXIO;
 		if (!try_module_get(mixer_devs[dev]->owner))
 			return -ENXIO;
 		break;
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		if ((retval = sequencer_open(dev, file)) < 0)
 			return retval;
 		break;
 	case SND_DEV_MIDIN:
 		if ((retval = MIDIbuf_open(dev, file)) < 0)
 			return retval;
 		break;
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		if ((retval = audio_open(dev, file)) < 0)
 			return retval;
 		break;
 	default:
 		printk(KERN_ERR "Invalid minor device %d\n", dev);
 		return -ENXIO;
 	}
 	return 0;
 }
 static int sound_release(struct inode *inode, struct file *file)
 {
 	int dev = iminor(inode);
 	lock_kernel();
 	DEB(printk("sound_release(dev=%d)\n", dev));
 	switch (dev & 0x0f) {
 	case SND_DEV_CTL:
 		module_put(mixer_devs[dev >> 4]->owner);
 		break;
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		sequencer_release(dev, file);
 		break;
 	case SND_DEV_MIDIN:
 		MIDIbuf_release(dev, file);
 		break;
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		audio_release(dev, file);
 		break;
 	default:
 		printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev);
 	}
 	unlock_kernel();
 	return 0;
 }
 static int get_mixer_info(int dev, void __user *arg)
 {
 	mixer_info info;
 	memset(&info, 0, sizeof(info));
 	strlcpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
 	strlcpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
 	info.modify_counter = mixer_devs[dev]->modify_counter;
 	if (__copy_to_user(arg, &info,  sizeof(info)))
 		return -EFAULT;
 	return 0;
 }
 static int get_old_mixer_info(int dev, void __user *arg)
 {
 	_old_mixer_info info;
 	memset(&info, 0, sizeof(info));
  	strlcpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
  	strlcpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
  	if (copy_to_user(arg, &info,  sizeof(info)))
 		return -EFAULT;
 	return 0;
 }
 static int sound_mixer_ioctl(int mixdev, unsigned int cmd, void __user *arg)
 {
  	if (mixdev < 0 || mixdev >= MAX_MIXER_DEV)
  		return -ENXIO;
  	/* Try to load the mixer... */
  	if (mixer_devs[mixdev] == NULL) {
  		request_module("mixer%d", mixdev);
  	}
  	if (mixdev >= num_mixers || !mixer_devs[mixdev])
  		return -ENXIO;
 	if (cmd == SOUND_MIXER_INFO)
 		return get_mixer_info(mixdev, arg);
 	if (cmd == SOUND_OLD_MIXER_INFO)
 		return get_old_mixer_info(mixdev, arg);
 	if (_SIOC_DIR(cmd) & _SIOC_WRITE)
 		mixer_devs[mixdev]->modify_counter++;
 	if (!mixer_devs[mixdev]->ioctl)
 		return -EINVAL;
 	return mixer_devs[mixdev]->ioctl(mixdev, cmd, arg);
 }
 static int sound_ioctl(struct inode *inode, struct file *file,
 		       unsigned int cmd, unsigned long arg)
 {
 	int len = 0, dtype;
 	int dev = iminor(inode);
 	void __user *p = (void __user *)arg;
 	if (_SIOC_DIR(cmd) != _SIOC_NONE && _SIOC_DIR(cmd) != 0) {
 		/*
 		 * Have to validate the address given by the process.
 		 */
 		len = _SIOC_SIZE(cmd);
 		if (len < 1 || len > 65536 || !p)
 			return -EFAULT;
 		if (_SIOC_DIR(cmd) & _SIOC_WRITE)
 			if (!access_ok(VERIFY_READ, p, len))
 				return -EFAULT;
 		if (_SIOC_DIR(cmd) & _SIOC_READ)
 			if (!access_ok(VERIFY_WRITE, p, len))
 				return -EFAULT;
 	}
 	DEB(printk("sound_ioctl(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
 	if (cmd == OSS_GETVERSION)
 		return __put_user(SOUND_VERSION, (int __user *)p);
 	if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 &&   /* Mixer ioctl */
 	    (dev & 0x0f) != SND_DEV_CTL) {
 		dtype = dev & 0x0f;
 		switch (dtype) {
 		case SND_DEV_DSP:
 		case SND_DEV_DSP16:
 		case SND_DEV_AUDIO:
 			return sound_mixer_ioctl(audio_devs[dev >> 4]->mixer_dev,
 						 cmd, p);
 		default:
 			return sound_mixer_ioctl(dev >> 4, cmd, p);
 		}
 	}
 	switch (dev & 0x0f) {
 	case SND_DEV_CTL:
 		if (cmd == SOUND_MIXER_GETLEVELS)
 			return get_mixer_levels(p);
 		if (cmd == SOUND_MIXER_SETLEVELS)
 			return set_mixer_levels(p);
 		return sound_mixer_ioctl(dev >> 4, cmd, p);
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		return sequencer_ioctl(dev, file, cmd, p);
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		return audio_ioctl(dev, file, cmd, p);
 		break;
 	case SND_DEV_MIDIN:
 		return MIDIbuf_ioctl(dev, file, cmd, p);
 		break;
 	}
 	return -EINVAL;
 }
 static unsigned int sound_poll(struct file *file, poll_table * wait)
 {
 	struct inode *inode = file->f_dentry->d_inode;
 	int dev = iminor(inode);
 	DEB(printk("sound_poll(dev=%d)\n", dev));
 	switch (dev & 0x0f) {
 	case SND_DEV_SEQ:
 	case SND_DEV_SEQ2:
 		return sequencer_poll(dev, file, wait);
 	case SND_DEV_MIDIN:
 		return MIDIbuf_poll(dev, file, wait);
 	case SND_DEV_DSP:
 	case SND_DEV_DSP16:
 	case SND_DEV_AUDIO:
 		return DMAbuf_poll(file, dev >> 4, wait);
 	}
 	return 0;
 }
 static int sound_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	int dev_class;
 	unsigned long size;
 	struct dma_buffparms *dmap = NULL;
 	int dev = iminor(file->f_dentry->d_inode);
 	dev_class = dev & 0x0f;
 	dev >>= 4;
 	if (dev_class != SND_DEV_DSP && dev_class != SND_DEV_DSP16 && dev_class != SND_DEV_AUDIO) {
 		printk(KERN_ERR "Sound: mmap() not supported for other than audio devices\n");
 		return -EINVAL;
 	}
 	lock_kernel();
 	if (vma->vm_flags & VM_WRITE)	/* Map write and read/write to the output buf */
 		dmap = audio_devs[dev]->dmap_out;
 	else if (vma->vm_flags & VM_READ)
 		dmap = audio_devs[dev]->dmap_in;
 	else {
 		printk(KERN_ERR "Sound: Undefined mmap() access\n");
 		unlock_kernel();
 		return -EINVAL;
 	}
 	if (dmap == NULL) {
 		printk(KERN_ERR "Sound: mmap() error. dmap == NULL\n");
 		unlock_kernel();
 		return -EIO;
 	}
 	if (dmap->raw_buf == NULL) {
 		printk(KERN_ERR "Sound: mmap() called when raw_buf == NULL\n");
 		unlock_kernel();
 		return -EIO;
 	}
 	if (dmap->mapping_flags) {
 		printk(KERN_ERR "Sound: mmap() called twice for the same DMA buffer\n");
 		unlock_kernel();
 		return -EIO;
 	}
 	if (vma->vm_pgoff != 0) {
 		printk(KERN_ERR "Sound: mmap() offset must be 0.\n");
 		unlock_kernel();
 		return -EINVAL;
 	}
 	size = vma->vm_end - vma->vm_start;
 	if (size != dmap->bytes_in_use) {
 		printk(KERN_WARNING "Sound: mmap() size = %ld. Should be %d\n", size, dmap->bytes_in_use);
 	}
 	if (remap_pfn_range(vma, vma->vm_start,
 			virt_to_phys(dmap->raw_buf) >> PAGE_SHIFT,
 			vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
 		unlock_kernel();
 		return -EAGAIN;
 	}
 	dmap->mapping_flags |= DMA_MAP_MAPPED;
 	if( audio_devs[dev]->d->mmap)
 		audio_devs[dev]->d->mmap(dev);
 	memset(dmap->raw_buf,
 	       dmap->neutral_byte,
 	       dmap->bytes_in_use);
 	unlock_kernel();
 	return 0;
 }
 struct file_operations oss_sound_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= sound_read,
 	.write		= sound_write,
 	.poll		= sound_poll,
 	.ioctl		= sound_ioctl,
 	.mmap		= sound_mmap,
 	.open		= sound_open,
 	.release	= sound_release,
 };
 /*
  *	Create the required special subdevices
  */
 static int create_special_devices(void)
 {
 	int seq1,seq2;
 	seq1=register_sound_special(&oss_sound_fops, 1);
 	if(seq1==-1)
 		goto bad;
 	seq2=register_sound_special(&oss_sound_fops, 8);
 	if(seq2!=-1)
 		return 0;
 	unregister_sound_special(1);
 bad:
 	return -1;
 }
 /* These device names follow the official Linux device list,
  * Documentation/devices.txt.  Let us know if there are other
  * common names we should support for compatibility.
  * Only those devices not created by the generic code in sound_core.c are
  * registered here.
  */
 static const struct {
 	unsigned short minor;
 	char *name;
 	umode_t mode;
 	int *num;
 } dev_list[] = { /* list of minor devices */
 /* seems to be some confusion here -- this device is not in the device list */
 	{SND_DEV_DSP16,     "dspW",	 S_IWUGO | S_IRUSR | S_IRGRP,
 	 &num_audiodevs},
 	{SND_DEV_AUDIO,     "audio",	 S_IWUGO | S_IRUSR | S_IRGRP,
 	 &num_audiodevs},
 };
 static int dmabuf;
 static int dmabug;
 module_param(dmabuf, int, 0444);
 module_param(dmabug, int, 0444);
 static int __init oss_init(void)
 {
 	int             err;
 	int i, j;
 #ifdef CONFIG_PCI
 	if(dmabug)
 		isa_dma_bridge_buggy = dmabug;
 #endif
 	err = create_special_devices();
 	if (err) {
 		printk(KERN_ERR "sound: driver already loaded/included in kernel\n");
 		return err;
 	}
 	/* Protecting the innocent */
 	sound_dmap_flag = (dmabuf > 0 ? 1 : 0);
 	for (i = 0; i < sizeof (dev_list) / sizeof *dev_list; i++) {
 		device_create(sound_class, NULL,
 			      MKDEV(SOUND_MAJOR, dev_list[i].minor),
 			      "%s", dev_list[i].name);
 		if (!dev_list[i].num)
 			continue;
 		for (j = 1; j < *dev_list[i].num; j++)
 			device_create(sound_class, NULL,
 				      MKDEV(SOUND_MAJOR, dev_list[i].minor + (j*0x10)),
 				      "%s%d", dev_list[i].name, j);
 	}
 	if (sound_nblocks >= 1024)
 		printk(KERN_ERR "Sound warning: Deallocation table was too small.\n");
 	return 0;
 }
 static void __exit oss_cleanup(void)
 {
 	int i, j;
 	for (i = 0; i < sizeof (dev_list) / sizeof *dev_list; i++) {
 		device_destroy(sound_class, MKDEV(SOUND_MAJOR, dev_list[i].minor));
 		if (!dev_list[i].num)
 			continue;
 		for (j = 1; j < *dev_list[i].num; j++)
 			device_destroy(sound_class, MKDEV(SOUND_MAJOR, dev_list[i].minor + (j*0x10)));
 	}
 	unregister_sound_special(1);
 	unregister_sound_special(8);
 	sound_stop_timer();
 	sequencer_unload();
 	for (i = 0; i < MAX_DMA_CHANNELS; i++)
 		if (dma_alloc_map[i] != DMA_MAP_UNAVAIL) {
 			printk(KERN_ERR "Sound: Hmm, DMA%d was left allocated - fixed\n", i);
 			sound_free_dma(i);
 		}
 	for (i = 0; i < sound_nblocks; i++)
 		vfree(sound_mem_blocks[i]);
 }
 module_init(oss_init);
 module_exit(oss_cleanup);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("OSS Sound subsystem");
 MODULE_AUTHOR("Hannu Savolainen, et al.");
 int sound_alloc_dma(int chn, char *deviceID)
 {
 	int err;
 	if ((err = request_dma(chn, deviceID)) != 0)
 		return err;
 	dma_alloc_map[chn] = DMA_MAP_FREE;
 	return 0;
 }
 EXPORT_SYMBOL(sound_alloc_dma);
 int sound_open_dma(int chn, char *deviceID)
 {
 	if (!valid_dma(chn)) {
 		printk(KERN_ERR "sound_open_dma: Invalid DMA channel %d\n", chn);
 		return 1;
 	}
 	if (dma_alloc_map[chn] != DMA_MAP_FREE) {
 		printk("sound_open_dma: DMA channel %d busy or not allocated (%d)\n", chn, dma_alloc_map[chn]);
 		return 1;
 	}
 	dma_alloc_map[chn] = DMA_MAP_BUSY;
 	return 0;
 }
 EXPORT_SYMBOL(sound_open_dma);
 void sound_free_dma(int chn)
 {
 	if (dma_alloc_map[chn] == DMA_MAP_UNAVAIL) {
 		/* printk( "sound_free_dma: Bad access to DMA channel %d\n",  chn); */
 		return;
 	}
 	free_dma(chn);
 	dma_alloc_map[chn] = DMA_MAP_UNAVAIL;
 }
 EXPORT_SYMBOL(sound_free_dma);
 void sound_close_dma(int chn)
 {
 	if (dma_alloc_map[chn] != DMA_MAP_BUSY) {
 		printk(KERN_ERR "sound_close_dma: Bad access to DMA channel %d\n", chn);
 		return;
 	}
 	dma_alloc_map[chn] = DMA_MAP_FREE;
 }
 EXPORT_SYMBOL(sound_close_dma);
 static void do_sequencer_timer(unsigned long dummy)
 {
 	sequencer_timer(0);
 }
 static DEFINE_TIMER(seq_timer, do_sequencer_timer, 0, 0);
 void request_sound_timer(int count)
 {
 	extern unsigned long seq_time;
 	if (count < 0) {
 		seq_timer.expires = (-count) + jiffies;
 		add_timer(&seq_timer);
 		return;
 	}
 	count += seq_time;
 	count -= jiffies;
 	if (count < 1)
 		count = 1;
 	seq_timer.expires = (count) + jiffies;
 	add_timer(&seq_timer);
 }
 void sound_stop_timer(void)
 {
 	del_timer(&seq_timer);
 }
 void conf_printf(char *name, struct address_info *hw_config)
 {
 #ifndef CONFIG_SOUND_TRACEINIT
 	return;
 #else
 	printk("<%s> at 0x%03x", name, hw_config->io_base);
 	if (hw_config->irq)
 		printk(" irq %d", (hw_config->irq > 0) ? hw_config->irq : -hw_config->irq);
 	if (hw_config->dma != -1 || hw_config->dma2 != -1)
 	{
 		printk(" dma %d", hw_config->dma);
 		if (hw_config->dma2 != -1)
 			printk(",%d", hw_config->dma2);
 	}
 	printk("\n");
 #endif
 }
 EXPORT_SYMBOL(conf_printf);
 void conf_printf2(char *name, int base, int irq, int dma, int dma2)
 {
 #ifndef CONFIG_SOUND_TRACEINIT
 	return;
 #else
 	printk("<%s> at 0x%03x", name, base);
 	if (irq)
 		printk(" irq %d", (irq > 0) ? irq : -irq);
 	if (dma != -1 || dma2 != -1)
 	{
 		  printk(" dma %d", dma);
 		  if (dma2 != -1)
 			  printk(",%d", dma2);
 	}
 	printk("\n");
 #endif
 }
 EXPORT_SYMBOL(conf_printf2);

sound/oss/sscape.c

Diff comments View file @ f23f6e0

 /*
  * sound/oss/sscape.c
  *
  * Low level driver for Ensoniq SoundScape
  *
  *
  * Copyright (C) by Hannu Savolainen 1993-1997
  *
  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  * for more info.
  *
  *
  * Thomas Sailer   	: ioctl code reworked (vmalloc/vfree removed)
  * Sergey Smitienko	: ensoniq p'n'p support
  * Christoph Hellwig	: adapted to module_init/module_exit
  * Bartlomiej Zolnierkiewicz : added __init to attach_sscape()
  * Chris Rankin		: Specify that this module owns the coprocessor
  * Arnaldo C. de Melo	: added missing restore_flags in sscape_pnp_upload_file
  */
 #include <linux/init.h>
 #include <linux/module.h>
 #include "sound_config.h"
 #include "sound_firmware.h"
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
 #include <linux/fcntl.h>
 #include <linux/ctype.h>
 #include <linux/stddef.h>
 #include <linux/kmod.h>
 #include <asm/dma.h>
 #include <asm/io.h>
 #include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
+#include <linux/mm.h>
 #include <linux/spinlock.h>
 #include "coproc.h"
 #include "ad1848.h"
 #include "mpu401.h"
 /*
  *    I/O ports
  */
 #define MIDI_DATA       0
 #define MIDI_CTRL       1
 #define HOST_CTRL       2
 #define TX_READY	0x02
 #define RX_READY	0x01
 #define HOST_DATA       3
 #define ODIE_ADDR       4
 #define ODIE_DATA       5
 /*
  *    Indirect registers
  */
 #define GA_INTSTAT_REG	0
 #define GA_INTENA_REG	1
 #define GA_DMAA_REG	2
 #define GA_DMAB_REG	3
 #define GA_INTCFG_REG	4
 #define GA_DMACFG_REG	5
 #define GA_CDCFG_REG	6
 #define GA_SMCFGA_REG	7
 #define GA_SMCFGB_REG	8
 #define GA_HMCTL_REG	9
 /*
  * DMA channel identifiers (A and B)
  */
 #define SSCAPE_DMA_A	0
 #define SSCAPE_DMA_B	1
 #define PORT(name)	(devc->base+name)
 /*
  * Host commands recognized by the OBP microcode
  */
 #define CMD_GEN_HOST_ACK	0x80
 #define CMD_GEN_MPU_ACK		0x81
 #define CMD_GET_BOARD_TYPE	0x82
 #define CMD_SET_CONTROL		0x88	/* Old firmware only */
 #define CMD_GET_CONTROL		0x89	/* Old firmware only */
 #define CTL_MASTER_VOL		0
 #define CTL_MIC_MODE		2
 #define CTL_SYNTH_VOL		4
 #define CTL_WAVE_VOL		7
 #define CMD_SET_EXTMIDI		0x8a
 #define CMD_GET_EXTMIDI		0x8b
 #define CMD_SET_MT32		0x8c
 #define CMD_GET_MT32		0x8d
 #define CMD_ACK			0x80
 #define	IC_ODIE			1
 #define	IC_OPUS			2
 typedef struct sscape_info
 {
 	int	base, irq, dma;
 	int	codec, codec_irq;	/* required to setup pnp cards*/
 	int	codec_type;
 	int	ic_type;
 	char*	raw_buf;
 	unsigned long	raw_buf_phys;
 	int	buffsize;		/* -------------------------- */
 	spinlock_t lock;
 	int	ok;	/* Properly detected */
 	int	failed;
 	int	dma_allocated;
 	int	codec_audiodev;
 	int	opened;
 	int	*osp;
 	int	my_audiodev;
 } sscape_info;
 static struct sscape_info adev_info = {
 	0
 };
 static struct sscape_info *devc = &adev_info;
 static int sscape_mididev = -1;
 /* Some older cards have assigned interrupt bits differently than new ones */
 static char valid_interrupts_old[] = {
 	9, 7, 5, 15
 };
 static char valid_interrupts_new[] = {
 	9, 5, 7, 10
 };
 static char *valid_interrupts = valid_interrupts_new;
 /*
  *	See the bottom of the driver. This can be set by spea =0/1.
  */
 #ifdef REVEAL_SPEA
 static char old_hardware = 1;
 #else
 static char old_hardware;
 #endif
 static void sleep(unsigned howlong)
 {
 	current->state = TASK_INTERRUPTIBLE;
 	schedule_timeout(howlong);
 }
 static unsigned char sscape_read(struct sscape_info *devc, int reg)
 {
 	unsigned long flags;
 	unsigned char val;
 	spin_lock_irqsave(&devc->lock,flags);
 	outb(reg, PORT(ODIE_ADDR));
 	val = inb(PORT(ODIE_DATA));
 	spin_unlock_irqrestore(&devc->lock,flags);
 	return val;
 }
 static void __sscape_write(int reg, int data)
 {
 	outb(reg, PORT(ODIE_ADDR));
 	outb(data, PORT(ODIE_DATA));
 }
 static void sscape_write(struct sscape_info *devc, int reg, int data)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&devc->lock,flags);
 	__sscape_write(reg, data);
 	spin_unlock_irqrestore(&devc->lock,flags);
 }
 static unsigned char sscape_pnp_read_codec(sscape_info* devc, unsigned char reg)
 {
 	unsigned char res;
 	unsigned long flags;
 	spin_lock_irqsave(&devc->lock,flags);
 	outb( reg, devc -> codec);
 	res = inb (devc -> codec + 1);
 	spin_unlock_irqrestore(&devc->lock,flags);
 	return res;
 }
 static void sscape_pnp_write_codec(sscape_info* devc, unsigned char reg, unsigned char data)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&devc->lock,flags);
 	outb( reg, devc -> codec);
 	outb( data, devc -> codec + 1);
 	spin_unlock_irqrestore(&devc->lock,flags);
 }
 static void host_open(struct sscape_info *devc)
 {
 	outb((0x00), PORT(HOST_CTRL));	/* Put the board to the host mode */
 }
 static void host_close(struct sscape_info *devc)
 {
 	outb((0x03), PORT(HOST_CTRL));	/* Put the board to the MIDI mode */
 }
 static int host_write(struct sscape_info *devc, unsigned char *data, int count)
 {
 	unsigned long flags;
 	int i, timeout_val;
 	spin_lock_irqsave(&devc->lock,flags);
 	/*
 	 * Send the command and data bytes
 	 */
 	for (i = 0; i < count; i++)
 	{
 		for (timeout_val = 10000; timeout_val > 0; timeout_val--)
 			if (inb(PORT(HOST_CTRL)) & TX_READY)
 				break;
 		if (timeout_val <= 0)
 		{
 				spin_unlock_irqrestore(&devc->lock,flags);
 			    return 0;
 		}
 		outb(data[i], PORT(HOST_DATA));
 	}
 	spin_unlock_irqrestore(&devc->lock,flags);
 	return 1;
 }
 static int host_read(struct sscape_info *devc)
 {
 	unsigned long flags;
 	int timeout_val;
 	unsigned char data;
 	spin_lock_irqsave(&devc->lock,flags);
 	/*
 	 * Read a byte
 	 */
 	for (timeout_val = 10000; timeout_val > 0; timeout_val--)
 		if (inb(PORT(HOST_CTRL)) & RX_READY)
 			break;
 	if (timeout_val <= 0)
 	{
 		spin_unlock_irqrestore(&devc->lock,flags);
 		return -1;
 	}
 	data = inb(PORT(HOST_DATA));
 	spin_unlock_irqrestore(&devc->lock,flags);
 	return data;
 }
 #if 0 /* unused */
 static int host_command1(struct sscape_info *devc, int cmd)
 {
 	unsigned char buf[10];
 	buf[0] = (unsigned char) (cmd & 0xff);
 	return host_write(devc, buf, 1);
 }
 #endif /* unused */
 static int host_command2(struct sscape_info *devc, int cmd, int parm1)
 {
 	unsigned char buf[10];
 	buf[0] = (unsigned char) (cmd & 0xff);
 	buf[1] = (unsigned char) (parm1 & 0xff);
 	return host_write(devc, buf, 2);
 }
 static int host_command3(struct sscape_info *devc, int cmd, int parm1, int parm2)
 {
 	unsigned char buf[10];
 	buf[0] = (unsigned char) (cmd & 0xff);
 	buf[1] = (unsigned char) (parm1 & 0xff);
 	buf[2] = (unsigned char) (parm2 & 0xff);
 	return host_write(devc, buf, 3);
 }
 static void set_mt32(struct sscape_info *devc, int value)
 {
 	host_open(devc);
 	host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
 	if (host_read(devc) != CMD_ACK)
 	{
 		/* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
 	}
 	host_close(devc);
 }
 static void set_control(struct sscape_info *devc, int ctrl, int value)
 {
 	host_open(devc);
 	host_command3(devc, CMD_SET_CONTROL, ctrl, value);
 	if (host_read(devc) != CMD_ACK)
 	{
 		/* printk( "SNDSCAPE: Setting control (%d) failed\n",  ctrl); */
 	}
 	host_close(devc);
 }
 static void do_dma(struct sscape_info *devc, int dma_chan, unsigned long buf, int blk_size, int mode)
 {
 	unsigned char temp;
 	if (dma_chan != SSCAPE_DMA_A)
 	{
 		printk(KERN_WARNING "soundscape: Tried to use DMA channel  != A. Why?\n");
 		return;
 	}
 	audio_devs[devc->codec_audiodev]->flags &= ~DMA_AUTOMODE;
 	DMAbuf_start_dma(devc->codec_audiodev, buf, blk_size, mode);
 	audio_devs[devc->codec_audiodev]->flags |= DMA_AUTOMODE;
 	temp = devc->dma << 4;	/* Setup DMA channel select bits */
 	if (devc->dma <= 3)
 		temp |= 0x80;	/* 8 bit DMA channel */
 	temp |= 1;		/* Trigger DMA */
 	sscape_write(devc, GA_DMAA_REG, temp);
 	temp &= 0xfe;		/* Clear DMA trigger */
 	sscape_write(devc, GA_DMAA_REG, temp);
 }
 static int verify_mpu(struct sscape_info *devc)
 {
 	/*
 	 * The SoundScape board could be in three modes (MPU, 8250 and host).
 	 * If the card is not in the MPU mode, enabling the MPU driver will
 	 * cause infinite loop (the driver believes that there is always some
 	 * received data in the buffer.
 	 *
 	 * Detect this by looking if there are more than 10 received MIDI bytes
 	 * (0x00) in the buffer.
 	 */
 	int i;
 	for (i = 0; i < 10; i++)
 	{
 		if (inb(devc->base + HOST_CTRL) & 0x80)
 			return 1;
 		if (inb(devc->base) != 0x00)
 			return 1;
 	}
 	printk(KERN_WARNING "SoundScape: The device is not in the MPU-401 mode\n");
 	return 0;
 }
 static int sscape_coproc_open(void *dev_info, int sub_device)
 {
 	if (sub_device == COPR_MIDI)
 	{
 		set_mt32(devc, 0);
 		if (!verify_mpu(devc))
 			return -EIO;
 	}
 	return 0;
 }
 static void sscape_coproc_close(void *dev_info, int sub_device)
 {
 	struct sscape_info *devc = dev_info;
 	unsigned long   flags;
 	spin_lock_irqsave(&devc->lock,flags);
 	if (devc->dma_allocated)
 	{
 		__sscape_write(GA_DMAA_REG, 0x20);	/* DMA channel disabled */
 		devc->dma_allocated = 0;
 	}
 	spin_unlock_irqrestore(&devc->lock,flags);
 	return;
 }
 static void sscape_coproc_reset(void *dev_info)
 {
 }
 static int sscape_download_boot(struct sscape_info *devc, unsigned char *block, int size, int flag)
 {
 	unsigned long flags;
 	unsigned char temp;
 	volatile int done, timeout_val;
 	static unsigned char codec_dma_bits;
 	if (flag & CPF_FIRST)
 	{
 		/*
 		 * First block. Have to allocate DMA and to reset the board
 		 * before continuing.
 		 */
 		spin_lock_irqsave(&devc->lock,flags);
 		codec_dma_bits = sscape_read(devc, GA_CDCFG_REG);
 		if (devc->dma_allocated == 0)
 			devc->dma_allocated = 1;
 		spin_unlock_irqrestore(&devc->lock,flags);
 		sscape_write(devc, GA_HMCTL_REG,
 			(temp = sscape_read(devc, GA_HMCTL_REG)) & 0x3f);	/*Reset */
 		for (timeout_val = 10000; timeout_val > 0; timeout_val--)
 			sscape_read(devc, GA_HMCTL_REG);	/* Delay */
 		/* Take board out of reset */
 		sscape_write(devc, GA_HMCTL_REG,
 			(temp = sscape_read(devc, GA_HMCTL_REG)) | 0x80);
 	}
 	/*
 	 * Transfer one code block using DMA
 	 */
 	if (audio_devs[devc->codec_audiodev]->dmap_out->raw_buf == NULL)
 	{
 		printk(KERN_WARNING "soundscape: DMA buffer not available\n");
 		return 0;
 	}
 	memcpy(audio_devs[devc->codec_audiodev]->dmap_out->raw_buf, block, size);
 	spin_lock_irqsave(&devc->lock,flags);
 	/******** INTERRUPTS DISABLED NOW ********/
 	do_dma(devc, SSCAPE_DMA_A,
 	       audio_devs[devc->codec_audiodev]->dmap_out->raw_buf_phys,
 	       size, DMA_MODE_WRITE);
 	/*
 	 * Wait until transfer completes.
 	 */
 	done = 0;
 	timeout_val = 30;
 	while (!done && timeout_val-- > 0)
 	{
 		int resid;
 		if (HZ / 50)
 			sleep(HZ / 50);
 		clear_dma_ff(devc->dma);
 		if ((resid = get_dma_residue(devc->dma)) == 0)
 			done = 1;
 	}
 	spin_unlock_irqrestore(&devc->lock,flags);
 	if (!done)
 		return 0;
 	if (flag & CPF_LAST)
 	{
 		/*
 		 * Take the board out of reset
 		 */
 		outb((0x00), PORT(HOST_CTRL));
 		outb((0x00), PORT(MIDI_CTRL));
 		temp = sscape_read(devc, GA_HMCTL_REG);
 		temp |= 0x40;
 		sscape_write(devc, GA_HMCTL_REG, temp);	/* Kickstart the board */
 		/*
 		 * Wait until the ODB wakes up
 		 */
 		spin_lock_irqsave(&devc->lock,flags);
 		done = 0;
 		timeout_val = 5 * HZ;
 		while (!done && timeout_val-- > 0)
 		{
 			unsigned char x;
 			sleep(1);
 			x = inb(PORT(HOST_DATA));
 			if (x == 0xff || x == 0xfe)		/* OBP startup acknowledge */
 			{
 				DDB(printk("Soundscape: Acknowledge = %x\n", x));
 				done = 1;
 			}
 		}
 		sscape_write(devc, GA_CDCFG_REG, codec_dma_bits);
 		spin_unlock_irqrestore(&devc->lock,flags);
 		if (!done)
 		{
 			printk(KERN_ERR "soundscape: The OBP didn't respond after code download\n");
 			return 0;
 		}
 		spin_lock_irqsave(&devc->lock,flags);
 		done = 0;
 		timeout_val = 5 * HZ;
 		while (!done && timeout_val-- > 0)
 		{
 			sleep(1);
 			if (inb(PORT(HOST_DATA)) == 0xfe)	/* Host startup acknowledge */
 				done = 1;
 		}
 		spin_unlock_irqrestore(&devc->lock,flags);
 		if (!done)
 		{
 			printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
 			return 0;
 		}
 		printk(KERN_INFO "SoundScape board initialized OK\n");
 		set_control(devc, CTL_MASTER_VOL, 100);
 		set_control(devc, CTL_SYNTH_VOL, 100);
 #ifdef SSCAPE_DEBUG3
 		/*
 		 * Temporary debugging aid. Print contents of the registers after
 		 * downloading the code.
 		 */
 		{
 			int i;
 			for (i = 0; i < 13; i++)
 				printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
 		}
 #endif
 	}
 	return 1;
 }
 static int download_boot_block(void *dev_info, copr_buffer * buf)
 {
 	if (buf->len <= 0 || buf->len > sizeof(buf->data))
 		return -EINVAL;
 	if (!sscape_download_boot(devc, buf->data, buf->len, buf->flags))
 	{
 		printk(KERN_ERR "soundscape: Unable to load microcode block to the OBP.\n");
 		return -EIO;
 	}
 	return 0;
 }
 static int sscape_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
 {
 	copr_buffer *buf;
 	int err;
 	switch (cmd)
 	{
 		case SNDCTL_COPR_RESET:
 			sscape_coproc_reset(dev_info);
 			return 0;
 		case SNDCTL_COPR_LOAD:
 			buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
 			if (buf == NULL)
 				return -ENOSPC;
 			if (copy_from_user(buf, arg, sizeof(copr_buffer)))
 			{
 				vfree(buf);
 				return -EFAULT;
 			}
 			err = download_boot_block(dev_info, buf);
 			vfree(buf);
 			return err;
 		default:
 			return -EINVAL;
 	}
 }
 static coproc_operations sscape_coproc_operations =
 {
 	"SoundScape M68K",
 	THIS_MODULE,
 	sscape_coproc_open,
 	sscape_coproc_close,
 	sscape_coproc_ioctl,
 	sscape_coproc_reset,
 	&adev_info
 };
 static struct resource *sscape_ports;
 static int sscape_is_pnp;
 static void __init attach_sscape(struct address_info *hw_config)
 {
 #ifndef SSCAPE_REGS
 	/*
 	 * Config register values for Spea/V7 Media FX and Ensoniq S-2000.
 	 * These values are card
 	 * dependent. If you have another SoundScape based card, you have to
 	 * find the correct values. Do the following:
 	 *  - Compile this driver with SSCAPE_DEBUG1 defined.
 	 *  - Shut down and power off your machine.
 	 *  - Boot with DOS so that the SSINIT.EXE program is run.
 	 *  - Warm boot to {Linux|SYSV|BSD} and write down the lines displayed
 	 *    when detecting the SoundScape.
 	 *  - Modify the following list to use the values printed during boot.
 	 *    Undefine the SSCAPE_DEBUG1
 	 */
 #define SSCAPE_REGS { \
 /* I0 */	0x00, \
 /* I1 */	0xf0, /* Note! Ignored. Set always to 0xf0 */ \
 /* I2 */	0x20, /* Note! Ignored. Set always to 0x20 */ \
 /* I3 */	0x20, /* Note! Ignored. Set always to 0x20 */ \
 /* I4 */	0xf5, /* Ignored */ \
 /* I5 */	0x10, \
 /* I6 */	0x00, \
 /* I7 */	0x2e, /* I7 MEM config A. Likely to vary between models */ \
 /* I8 */	0x00, /* I8 MEM config B. Likely to vary between models */ \
 /* I9 */	0x40 /* Ignored */ \
 	}
 #endif
 	unsigned long   flags;
 	static unsigned char regs[10] = SSCAPE_REGS;
 	int i, irq_bits = 0xff;
 	if (old_hardware)
 	{
 		valid_interrupts = valid_interrupts_old;
 		conf_printf("Ensoniq SoundScape (old)", hw_config);
 	}
 	else
 		conf_printf("Ensoniq SoundScape", hw_config);
 	for (i = 0; i < 4; i++)
 	{
 		if (hw_config->irq == valid_interrupts[i])
 		{
 			irq_bits = i;
 			break;
 		}
 	}
 	if (hw_config->irq > 15 || (regs[4] = irq_bits == 0xff))
 	{
 		printk(KERN_ERR "Invalid IRQ%d\n", hw_config->irq);
 		release_region(devc->base, 2);
 		release_region(devc->base + 2, 6);
 		if (sscape_is_pnp)
 			release_region(devc->codec, 2);
 		return;
 	}
 	if (!sscape_is_pnp) {
 		spin_lock_irqsave(&devc->lock,flags);
 		/* Host interrupt enable */
 		sscape_write(devc, 1, 0xf0);	/* All interrupts enabled */
 		/* DMA A status/trigger register */
 		sscape_write(devc, 2, 0x20);	/* DMA channel disabled */
 		/* DMA B status/trigger register */
 		sscape_write(devc, 3, 0x20);	/* DMA channel disabled */
 		/* Host interrupt config reg */
 		sscape_write(devc, 4, 0xf0 | (irq_bits << 2) | irq_bits);
 		/* Don't destroy CD-ROM DMA config bits (0xc0) */
 		sscape_write(devc, 5, (regs[5] & 0x3f) | (sscape_read(devc, 5) & 0xc0));
 		/* CD-ROM config (WSS codec actually) */
 		sscape_write(devc, 6, regs[6]);
 		sscape_write(devc, 7, regs[7]);
 		sscape_write(devc, 8, regs[8]);
 		/* Master control reg. Don't modify CR-ROM bits. Disable SB emul */
 		sscape_write(devc, 9, (sscape_read(devc, 9) & 0xf0) | 0x08);
 		spin_unlock_irqrestore(&devc->lock,flags);
 	}
 #ifdef SSCAPE_DEBUG2
 	/*
 	 * Temporary debugging aid. Print contents of the registers after
 	 * changing them.
 	 */
 	{
 		int i;
 		for (i = 0; i < 13; i++)
 			printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
 	}
 #endif
 	if (probe_mpu401(hw_config, sscape_ports))
 		hw_config->always_detect = 1;
 	hw_config->name = "SoundScape";
 	hw_config->irq *= -1;	/* Negative value signals IRQ sharing */
 	attach_mpu401(hw_config, THIS_MODULE);
 	hw_config->irq *= -1;	/* Restore it */
 	if (hw_config->slots[1] != -1)	/* The MPU driver installed itself */
 	{
 		sscape_mididev = hw_config->slots[1];
 		midi_devs[hw_config->slots[1]]->coproc = &sscape_coproc_operations;
 	}
 	sscape_write(devc, GA_INTENA_REG, 0x80);	/* Master IRQ enable */
 	devc->ok = 1;
 	devc->failed = 0;
 }
 static int detect_ga(sscape_info * devc)
 {
 	unsigned char save;
 	DDB(printk("Entered Soundscape detect_ga(%x)\n", devc->base));
 	/*
 	 * First check that the address register of "ODIE" is
 	 * there and that it has exactly 4 writable bits.
 	 * First 4 bits
 	 */
 	if ((save = inb(PORT(ODIE_ADDR))) & 0xf0)
 	{
 		DDB(printk("soundscape: Detect error A\n"));
 		return 0;
 	}
 	outb((0x00), PORT(ODIE_ADDR));
 	if (inb(PORT(ODIE_ADDR)) != 0x00)
 	{
 		DDB(printk("soundscape: Detect error B\n"));
 		return 0;
 	}
 	outb((0xff), PORT(ODIE_ADDR));
 	if (inb(PORT(ODIE_ADDR)) != 0x0f)
 	{
 		DDB(printk("soundscape: Detect error C\n"));
 		return 0;
 	}
 	outb((save), PORT(ODIE_ADDR));
 	/*
 	 * Now verify that some indirect registers return zero on some bits.
 	 * This may break the driver with some future revisions of "ODIE" but...
 	 */
 	if (sscape_read(devc, 0) & 0x0c)
 	{
 		DDB(printk("soundscape: Detect error D (%x)\n", sscape_read(devc, 0)));
 		return 0;
 	}
 	if (sscape_read(devc, 1) & 0x0f)
 	{
 		DDB(printk("soundscape: Detect error E\n"));
 		return 0;
 	}
 	if (sscape_read(devc, 5) & 0x0f)
 	{
 		DDB(printk("soundscape: Detect error F\n"));
 		return 0;
 	}
 	return 1;
 }
 static	int sscape_read_host_ctrl(sscape_info* devc)
 {
 	return host_read(devc);
 }
 static	void sscape_write_host_ctrl2(sscape_info *devc, int a, int b)
 {
 	host_command2(devc, a, b);
 }
 static int sscape_alloc_dma(sscape_info *devc)
 {
 	char *start_addr, *end_addr;
 	int dma_pagesize;
 	int sz, size;
 	struct page *page;
 	if (devc->raw_buf != NULL) return 0;	/* Already done */
 	dma_pagesize = (devc->dma < 4) ? (64 * 1024) : (128 * 1024);
 	devc->raw_buf = NULL;
 	devc->buffsize = 8192*4;
 	if (devc->buffsize > dma_pagesize) devc->buffsize = dma_pagesize;
 	start_addr = NULL;
 	/*
 	 * Now loop until we get a free buffer. Try to get smaller buffer if
 	 * it fails. Don't accept smaller than 8k buffer for performance
 	 * reasons.
 	 */
 	while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
 		for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
 		devc->buffsize = PAGE_SIZE * (1 << sz);
 		start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA, sz);
 		if (start_addr == NULL) devc->buffsize /= 2;
 	}
 	if (start_addr == NULL) {
 		printk(KERN_ERR "sscape pnp init error: Couldn't allocate DMA buffer\n");
 		return 0;
 	} else {
 		/* make some checks */
 		end_addr = start_addr + devc->buffsize - 1;
 		/* now check if it fits into the same dma-pagesize */
 		if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
 		    || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
 			printk(KERN_ERR "sscape pnp: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, devc->buffsize);
 			return 0;
 		}
 	}
 	devc->raw_buf = start_addr;
 	devc->raw_buf_phys = virt_to_bus(start_addr);
 	for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 		SetPageReserved(page);
 	return 1;
 }
 static void sscape_free_dma(sscape_info *devc)
 {
 	int sz, size;
 	unsigned long start_addr, end_addr;
 	struct page *page;
 	if (devc->raw_buf == NULL) return;
 	for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
 	start_addr = (unsigned long) devc->raw_buf;
 	end_addr = start_addr + devc->buffsize;
 	for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 		ClearPageReserved(page);
 	free_pages((unsigned long) devc->raw_buf, sz);
 	devc->raw_buf = NULL;
 }
 /* Intel version !!!!!!!!! */
 static int sscape_start_dma(int chan, unsigned long physaddr, int count, int dma_mode)
 {
 	unsigned long flags;
 	flags = claim_dma_lock();
 	disable_dma(chan);
 	clear_dma_ff(chan);
 	set_dma_mode(chan, dma_mode);
 	set_dma_addr(chan, physaddr);
 	set_dma_count(chan, count);
 	enable_dma(chan);
 	release_dma_lock(flags);
 	return 0;
 }
 static void sscape_pnp_start_dma(sscape_info* devc, int arg )
 {
 	int reg;
 	if (arg == 0) reg = 2;
 	else reg = 3;
 	sscape_write(devc, reg, sscape_read( devc, reg) | 0x01);
 	sscape_write(devc, reg, sscape_read( devc, reg) & 0xFE);
 }
 static int sscape_pnp_wait_dma (sscape_info* devc, int arg )
 {
 	int		reg;
 	unsigned long	i;
 	unsigned char	d;
 	if (arg == 0) reg = 2;
 	else reg = 3;
 	sleep ( 1 );
 	i = 0;
 	do {
 		d = sscape_read(devc, reg) & 1;
 		if ( d == 1)  break;
 		i++;
 	} while (i < 500000);
 	d = sscape_read(devc, reg) & 1;
 	return d;
 }
 static	int	sscape_pnp_alloc_dma(sscape_info* devc)
 {
 	/* printk(KERN_INFO "sscape: requesting dma\n"); */
 	if (request_dma(devc -> dma, "sscape")) return 0;
 	/* printk(KERN_INFO "sscape: dma channel allocated\n"); */
 	if (!sscape_alloc_dma(devc)) {
 		free_dma(devc -> dma);
 		return 0;
 	};
 	return 1;
 }
 static	void	sscape_pnp_free_dma(sscape_info* devc)
 {
 	sscape_free_dma( devc);
 	free_dma(devc -> dma );
 	/* printk(KERN_INFO "sscape: dma released\n"); */
 }
 static	int	sscape_pnp_upload_file(sscape_info* devc, char* fn)
 {
 	int	     	done = 0;
 	int	     	timeout_val;
 	char*	     	data,*dt;
 	int	     	len,l;
 	unsigned long	flags;
 	sscape_write( devc, 9, sscape_read(devc, 9 )  & 0x3F );
 	sscape_write( devc, 2, (devc -> dma << 4) | 0x80 );
 	sscape_write( devc, 3, 0x20 );
 	sscape_write( devc, 9, sscape_read( devc, 9 )  | 0x80 );
 	len = mod_firmware_load(fn, &data);
 	if (len == 0) {
 		    printk(KERN_ERR "sscape: file not found: %s\n", fn);
 		    return 0;
 	}
 	dt = data;
 	spin_lock_irqsave(&devc->lock,flags);
 	while ( len > 0 ) {
 		if (len > devc -> buffsize) l = devc->buffsize;
 		else l = len;
 		len -= l;
 		memcpy(devc->raw_buf, dt, l); dt += l;
 		sscape_start_dma(devc->dma, devc->raw_buf_phys, l, 0x48);
 		sscape_pnp_start_dma ( devc, 0 );
 		if (sscape_pnp_wait_dma ( devc, 0 ) == 0) {
 			spin_unlock_irqrestore(&devc->lock,flags);
 			return 0;
 		}
 	}
 	spin_unlock_irqrestore(&devc->lock,flags);
 	vfree(data);
 	outb(0, devc -> base + 2);
 	outb(0, devc -> base);
 	sscape_write ( devc, 9, sscape_read( devc, 9 ) | 0x40);
 	timeout_val = 5 * HZ;
 	while (!done && timeout_val-- > 0)
 	{
 		unsigned char x;
 		sleep(1);
 		x = inb( devc -> base + 3);
 		if (x == 0xff || x == 0xfe)		/* OBP startup acknowledge */
 		{
 			//printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
 			done = 1;
 		}
 	}
 	timeout_val = 5 * HZ;
 	done = 0;
 	while (!done && timeout_val-- > 0)
 	{
 		unsigned char x;
 		sleep(1);
 		x = inb( devc -> base + 3);
 		if (x == 0xfe)		/* OBP startup acknowledge */
 		{
 			//printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
 			done = 1;
 		}
 	}
 	if ( !done ) printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
 	sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
 	sscape_write( devc, 3, (devc -> dma << 4) + 0x80);
 	return 1;
 }
 static void __init sscape_pnp_init_hw(sscape_info* devc)
 {
 	unsigned char midi_irq = 0, sb_irq = 0;
 	unsigned i;
 	static	char code_file_name[23] = "/sndscape/sndscape.cox";
 	int sscape_joystic_enable	= 0x7f;
 	int sscape_mic_enable		= 0;
 	int sscape_ext_midi		= 0;
 	if ( !sscape_pnp_alloc_dma(devc) ) {
 		printk(KERN_ERR "sscape: faild to allocate dma\n");
 		return;
 	}
 	for (i = 0; i < 4; i++) {
 		if ( devc -> irq   == valid_interrupts[i] )
 			midi_irq = i;
 		if ( devc -> codec_irq == valid_interrupts[i] )
 			sb_irq = i;
 	}
 	sscape_write( devc, 5, 0x50);
 	sscape_write( devc, 7, 0x2e);
 	sscape_write( devc, 8, 0x00);
 	sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
 	sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
 	sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
 	i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
 	if (sscape_joystic_enable) i |= 8;
 	sscape_write (devc, 9, i);
 	sscape_write (devc, 6, 0x80);
 	sscape_write (devc, 1, 0x80);
 	if (devc -> codec_type == 2) {
 		sscape_pnp_write_codec( devc, 0x0C, 0x50);
 		sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
 		sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
 		sscape_pnp_write_codec( devc, 29, 0x20);
 	}
 	if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
 		printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.cod\n");
 		sscape_pnp_free_dma(devc);
 		return;
 	}
 	i = sscape_read_host_ctrl( devc );
 	if ( (i & 0x0F) >  7 ) {
 		printk(KERN_ERR "sscape: scope.cod faild\n");
 		sscape_pnp_free_dma(devc);
 		return;
 	}
 	if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
 	code_file_name[21] = (char) ( i & 0x0F) + 0x30;
 	if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
 		printk(KERN_ERR "sscape: faild to upload file %s\n", code_file_name);
 		sscape_pnp_free_dma(devc);
 		return;
 	}
 	if (devc->ic_type != IC_ODIE) {
 		sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
 		 ( sscape_mic_enable == 0 ? 0x00 : 0x80) );
 	}
 	sscape_write_host_ctrl2( devc, 0x84, 0x64 );  /* MIDI volume */
 	sscape_write_host_ctrl2( devc, 0x86, 0x64 );  /* MIDI volume?? */
 	sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
 	sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
 	sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
 	sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
 	sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
 	if (devc -> codec_type == 1) {
 		sscape_pnp_write_codec ( devc, 4, 0x1F );
 		sscape_pnp_write_codec ( devc, 5, 0x1F );
 		sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
 	} else {
 		int t;
 		sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
 		sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
 		t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
 		if ( (sscape_mic_enable == 0)) t |= 0;
 		else t |= 0x20;
 		sscape_pnp_write_codec ( devc, 0x00, t);
 		t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
 		if ( (sscape_mic_enable == 0) ) t |= 0;
 		else t |= 0x20;
 		sscape_pnp_write_codec ( devc, 0x01, t);
 		sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
 		outb(0, devc -> codec);
 	}
 	if (devc -> ic_type == IC_OPUS ) {
 		int i = sscape_read( devc, 9 );
 		sscape_write( devc, 9, i | 3 );
 		sscape_write( devc, 3, 0x40);
 		if (request_region(0x228, 1, "sscape setup junk")) {
 			outb(0, 0x228);
 			release_region(0x228,1);
 		}
 		sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
 		sscape_write( devc, 9, i );
 	}
 	host_close ( devc );
 	sscape_pnp_free_dma(devc);
 }
 static int __init detect_sscape_pnp(sscape_info* devc)
 {
 	long	 i, irq_bits = 0xff;
 	unsigned int d;
 	DDB(printk("Entered detect_sscape_pnp(%x)\n", devc->base));
 	if (!request_region(devc->codec, 2, "sscape codec")) {
 		printk(KERN_ERR "detect_sscape_pnp: port %x is not free\n", devc->codec);
 		return 0;
 	}
 	if ((inb(devc->base + 2) & 0x78) != 0)
 		goto fail;
 	d = inb ( devc -> base + 4) & 0xF0;
 	if (d & 0x80)
 		goto fail;
 	if (d == 0) {
 		devc->codec_type = 1;
 		devc->ic_type = IC_ODIE;
 	} else if ( (d & 0x60) != 0) {
 		devc->codec_type = 2;
 		devc->ic_type = IC_OPUS;
 	} else if ( (d & 0x40) != 0) {	/* WTF? */
 		devc->codec_type = 2;
 		devc->ic_type = IC_ODIE;
 	} else
 		goto fail;
 	sscape_is_pnp = 1;
 	outb(0xFA, devc -> base+4);
 	if  ((inb( devc -> base+4) & 0x9F) != 0x0A)
 		goto fail;
 	outb(0xFE, devc -> base+4);
 	if  ( (inb(devc -> base+4) & 0x9F) != 0x0E)
 		goto fail;
 	if  ( (inb(devc -> base+5) & 0x9F) != 0x0E)
 		goto fail;
 	if (devc->codec_type == 2) {
 		if (devc->codec != devc->base + 8) {
 			printk("soundscape warning: incorrect codec port specified\n");
 			goto fail;
 		}
 		d = 0x10 | (sscape_read(devc, 9)  & 0xCF);
 		sscape_write(devc, 9, d);
 		sscape_write(devc, 6, 0x80);
 	} else {
 		//todo: check codec is not base + 8
 	}
 	d  = (sscape_read(devc, 9) & 0x3F) | 0xC0;
 	sscape_write(devc, 9, d);
 	for (i = 0; i < 550000; i++)
 		if ( !(inb(devc -> codec) & 0x80) ) break;
 	d = inb(devc -> codec);
 	if (d & 0x80)
 		goto fail;
 	if ( inb(devc -> codec + 2) == 0xFF)
 		goto fail;
 	sscape_write(devc, 9, sscape_read(devc, 9)  & 0x3F );
 	d  = inb(devc -> codec) & 0x80;
 	if ( d == 0) {
 		printk(KERN_INFO "soundscape: hardware detected\n");
 		valid_interrupts = valid_interrupts_new;
 	} else	{
 		printk(KERN_INFO "soundscape: board looks like media fx\n");
 		valid_interrupts = valid_interrupts_old;
 		old_hardware = 1;
 	}
 	sscape_write( devc, 9, 0xC0 | (sscape_read(devc, 9)  & 0x3F) );
 	for (i = 0; i < 550000; i++)
 		if ( !(inb(devc -> codec) & 0x80))
 			break;
 	sscape_pnp_init_hw(devc);
 	for (i = 0; i < 4; i++)
 	{
 		if (devc->codec_irq == valid_interrupts[i]) {
 			irq_bits = i;
 			break;
 		}
 	}
 	sscape_write(devc, GA_INTENA_REG, 0x00);
 	sscape_write(devc, GA_DMACFG_REG, 0x50);
 	sscape_write(devc, GA_DMAA_REG, 0x70);
 	sscape_write(devc, GA_DMAB_REG, 0x20);
 	sscape_write(devc, GA_INTCFG_REG, 0xf0);
 	sscape_write(devc, GA_CDCFG_REG, 0x89 | (devc->dma << 4) | (irq_bits << 1));
 	sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 0) | 0x20);
 	sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 1) | 0x20);
 	return 1;
 fail:
 	release_region(devc->codec, 2);
 	return 0;
 }
 static int __init probe_sscape(struct address_info *hw_config)
 {
 	devc->base = hw_config->io_base;
 	devc->irq = hw_config->irq;
 	devc->dma = hw_config->dma;
 	devc->osp = hw_config->osp;
 #ifdef SSCAPE_DEBUG1
 	/*
 	 * Temporary debugging aid. Print contents of the registers before
 	 * changing them.
 	 */
 	{
 		int i;
 		for (i = 0; i < 13; i++)
 			printk("I%d = %02x (old value)\n", i, sscape_read(devc, i));
 	}
 #endif
 	devc->failed = 1;
 	sscape_ports = request_region(devc->base, 2, "mpu401");
 	if (!sscape_ports)
 		return 0;
 	if (!request_region(devc->base + 2, 6, "SoundScape")) {
 		release_region(devc->base, 2);
 		return 0;
 	}
 	if (!detect_ga(devc)) {
 		if (detect_sscape_pnp(devc))
 			return 1;
 		release_region(devc->base, 2);
 		release_region(devc->base + 2, 6);
 		return 0;
 	}
 	if (old_hardware)	/* Check that it's really an old Spea/Reveal card. */
 	{
 		unsigned char   tmp;
 		int             cc;
 		if (!((tmp = sscape_read(devc, GA_HMCTL_REG)) & 0xc0))
 		{
 			sscape_write(devc, GA_HMCTL_REG, tmp | 0x80);
 			for (cc = 0; cc < 200000; ++cc)
 				inb(devc->base + ODIE_ADDR);
 		}
 	}
 	return 1;
 }
 static int __init init_ss_ms_sound(struct address_info *hw_config)
 {
 	int i, irq_bits = 0xff;
 	int ad_flags = 0;
 	struct resource *ports;
 	if (devc->failed)
 	{
 		printk(KERN_ERR "soundscape: Card not detected\n");
 		return 0;
 	}
 	if (devc->ok == 0)
 	{
 		printk(KERN_ERR "soundscape: Invalid initialization order.\n");
 		return 0;
 	}
 	for (i = 0; i < 4; i++)
 	{
 		if (hw_config->irq == valid_interrupts[i])
 		{
 			irq_bits = i;
 			break;
 		}
 	}
 	if (irq_bits == 0xff) {
 		printk(KERN_ERR "soundscape: Invalid MSS IRQ%d\n", hw_config->irq);
 		return 0;
 	}
 	if (old_hardware)
 		ad_flags = 0x12345677;	/* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
 	else if (sscape_is_pnp)
 		ad_flags = 0x87654321;  /* Tell that we have a soundscape pnp with 1845 chip */
 	ports = request_region(hw_config->io_base, 4, "ad1848");
 	if (!ports) {
 		printk(KERN_ERR "soundscape: ports busy\n");
 		return 0;
 	}
 	if (!ad1848_detect(ports, &ad_flags, hw_config->osp)) {
 		release_region(hw_config->io_base, 4);
 		return 0;
 	}
  	if (!sscape_is_pnp)  /*pnp is already setup*/
  	{
  		/*
      		 * Setup the DMA polarity.
  	    	 */
  		sscape_write(devc, GA_DMACFG_REG, 0x50);
  		/*
  		 * Take the gate-array off of the DMA channel.
  		 */
  		sscape_write(devc, GA_DMAB_REG, 0x20);
  		/*
  		 * Init the AD1848 (CD-ROM) config reg.
  		 */
  		sscape_write(devc, GA_CDCFG_REG, 0x89 | (hw_config->dma << 4) | (irq_bits << 1));
  	}
  	if (hw_config->irq == devc->irq)
  		printk(KERN_WARNING "soundscape: Warning! The WSS mode can't share IRQ with MIDI\n");
 	hw_config->slots[0] = ad1848_init(
 			sscape_is_pnp ? "SoundScape" : "SoundScape PNP",
 			ports,
 			hw_config->irq,
 			hw_config->dma,
 			hw_config->dma,
 			0,
 			devc->osp,
 			THIS_MODULE);
 	if (hw_config->slots[0] != -1)	/* The AD1848 driver installed itself */
 	{
 		audio_devs[hw_config->slots[0]]->coproc = &sscape_coproc_operations;
 		devc->codec_audiodev = hw_config->slots[0];
 		devc->my_audiodev = hw_config->slots[0];
 		/* Set proper routings here (what are they) */
 		AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);
 	}
 #ifdef SSCAPE_DEBUG5
 	/*
 	 * Temporary debugging aid. Print contents of the registers
 	 * after the AD1848 device has been initialized.
 	 */
 	{
 		int i;
 		for (i = 0; i < 13; i++)
 			printk("I%d = %02x\n", i, sscape_read(devc, i));
 	}
 #endif
 	return 1;
 }
 static void __exit unload_sscape(struct address_info *hw_config)
 {
 	release_region(devc->base + 2, 6);
 	unload_mpu401(hw_config);
 	if (sscape_is_pnp)
 		release_region(devc->codec, 2);
 }
 static void __exit unload_ss_ms_sound(struct address_info *hw_config)
 {
 	ad1848_unload(hw_config->io_base,
 		      hw_config->irq,
 		      devc->dma,
 		      devc->dma,
 		      0);
 	sound_unload_audiodev(hw_config->slots[0]);
 }
 static struct address_info cfg;
 static struct address_info cfg_mpu;
 static int __initdata spea = -1;
 static int mss = 0;
 static int __initdata dma = -1;
 static int __initdata irq = -1;
 static int __initdata io = -1;
 static int __initdata mpu_irq = -1;
 static int __initdata mpu_io = -1;
 module_param(dma, int, 0);
 module_param(irq, int, 0);
 module_param(io, int, 0);
 module_param(spea, int, 0);		/* spea=0/1 set the old_hardware */
 module_param(mpu_irq, int, 0);
 module_param(mpu_io, int, 0);
 module_param(mss, int, 0);
 static int __init init_sscape(void)
 {
 	printk(KERN_INFO "Soundscape driver Copyright (C) by Hannu Savolainen 1993-1996\n");
 	cfg.irq = irq;
 	cfg.dma = dma;
 	cfg.io_base = io;
 	cfg_mpu.irq = mpu_irq;
 	cfg_mpu.io_base = mpu_io;
 	/* WEH - Try to get right dma channel */
         cfg_mpu.dma = dma;
 	devc->codec = cfg.io_base;
 	devc->codec_irq = cfg.irq;
 	devc->codec_type = 0;
 	devc->ic_type = 0;
 	devc->raw_buf = NULL;
 	spin_lock_init(&devc->lock);
 	if (cfg.dma == -1 || cfg.irq == -1 || cfg.io_base == -1) {
 		printk(KERN_ERR "DMA, IRQ, and IO port must be specified.\n");
 		return -EINVAL;
 	}
 	if (cfg_mpu.irq == -1 && cfg_mpu.io_base != -1) {
 		printk(KERN_ERR "MPU_IRQ must be specified if MPU_IO is set.\n");
 		return -EINVAL;
 	}
 	if(spea != -1) {
 		old_hardware = spea;
 		printk(KERN_INFO "Forcing %s hardware support.\n",
 			spea?"new":"old");
 	}
 	if (probe_sscape(&cfg_mpu) == 0)
 		return -ENODEV;
 	attach_sscape(&cfg_mpu);
 	mss = init_ss_ms_sound(&cfg);
 	return 0;
 }
 static void __exit cleanup_sscape(void)
 {
 	if (mss)
 		unload_ss_ms_sound(&cfg);
 	unload_sscape(&cfg_mpu);
 }
 module_init(init_sscape);
 module_exit(cleanup_sscape);
 #ifndef MODULE
 static int __init setup_sscape(char *str)
 {
 	/* io, irq, dma, mpu_io, mpu_irq */
 	int ints[6];
 	str = get_options(str, ARRAY_SIZE(ints), ints);
 	io	= ints[1];
 	irq	= ints[2];
 	dma	= ints[3];
 	mpu_io	= ints[4];
 	mpu_irq	= ints[5];
 	return 1;
 }
 __setup("sscape=", setup_sscape);
 #endif
 MODULE_LICENSE("GPL");

sound/oss/trident.c

Diff comments View file @ f23f6e0

 /*
  *	OSS driver for Linux 2.[46].x for
  *
  *	Trident 4D-Wave
  *	SiS 7018
  *	ALi 5451
  *	Tvia/IGST CyberPro 5050
  *
  *	Driver: Alan Cox <alan@redhat.com>
  *
  *  Built from:
  *	Low level code: <audio@tridentmicro.com> from ALSA
  *	Framework: Thomas Sailer <sailer@ife.ee.ethz.ch>
  *	Extended by: Zach Brown <zab@redhat.com>
  *
  *  Hacked up by:
  *	Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  *	Ollie Lho <ollie@sis.com.tw> SiS 7018 Audio Core Support
  *	Ching-Ling Lee <cling-li@ali.com.tw> ALi 5451 Audio Core Support
  *	Matt Wu <mattwu@acersoftech.com.cn> ALi 5451 Audio Core Support
  *	Peter Wächtler <pwaechtler@loewe-komp.de> CyberPro5050 support
  *      Muli Ben-Yehuda <mulix@mulix.org>
  *
  *
  *	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.
  *
  *  History
  *  v0.14.10j
  *  	January 3 2004 Eugene Teo <eugeneteo@eugeneteo.net>
  *  	minor cleanup to use pr_debug instead of TRDBG since it is already
  *  	defined in linux/kernel.h.
  *  v0.14.10i
  *      December 29 2003 Muli Ben-Yehuda <mulix@mulix.org>
  *      major cleanup for 2.6, fix a few error patch buglets
  *      with returning without properly cleaning up first,
  *      get rid of lock_kernel().
  *  v0.14.10h
  *	Sept 10 2002 Pascal Schmidt <der.eremit@email.de>
  *	added support for ALi 5451 joystick port
  *  v0.14.10g
  *	Sept 05 2002 Alan Cox <alan@redhat.com>
  *	adapt to new pci joystick attachment interface
  *  v0.14.10f
  *      July 24 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      patch from Eric Lemar (via Ian Soboroff): in suspend and resume,
  *      fix wrong cast from pci_dev* to struct trident_card*.
  *  v0.14.10e
  *      July 19 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      rewrite the DMA buffer allocation/deallcoation functions, to make it
  *      modular and fix a bug where we would call free_pages on memory
  *      obtained with pci_alloc_consistent. Also remove unnecessary #ifdef
  *      CONFIG_PROC_FS and various other cleanups.
  *  v0.14.10d
  *      July 19 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      made several printk(KERN_NOTICE...) into TRDBG(...), to avoid spamming
  *      my syslog with hundreds of messages.
  *  v0.14.10c
  *      July 16 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      Cleaned up Lei Hu's 0.4.10 driver to conform to Documentation/CodingStyle
  *      and the coding style used in the rest of the file.
  *  v0.14.10b
  *      June 23 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      add a missing unlock_set_fmt, remove a superflous lock/unlock pair
  *      with nothing in between.
  *  v0.14.10a
  *      June 21 2002 Muli Ben-Yehuda <mulix@actcom.co.il>
  *      use a debug macro instead of #ifdef CONFIG_DEBUG, trim to 80 columns
  *      per line, use 'do {} while (0)' in statement macros.
  *  v0.14.10
  *      June 6 2002 Lei Hu <Lei_hu@ali.com.tw>
  *      rewrite the part to read/write registers of audio codec for Ali5451
  *  v0.14.9e
  *      January 2 2002 Vojtech Pavlik <vojtech@ucw.cz> added gameport
  *      support to avoid resource conflict with pcigame.c
  *  v0.14.9d
  *  	October 8 2001 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  *	use set_current_state, properly release resources on failure in
  *	trident_probe, get rid of check_region
  *  v0.14.9c
  *	August 10 2001 Peter Wächtler <pwaechtler@loewe-komp.de>
  *	added support for Tvia (formerly Integraphics/IGST) CyberPro5050
  *	this chip is often found in settop boxes (combined video+audio)
  *  v0.14.9b
  *	Switch to static inline not extern inline (gcc 3)
  *  v0.14.9a
  *	Aug 6 2001 Alan Cox
  *	0.14.9 crashed on rmmod due to a timer/bh left running. Simplified
  *	the existing logic (the BH doesn't help as ac97 is lock_irqsave)
  *	and used del_timer_sync to clean up
  *	Fixed a problem where the ALi change broke my generic card
  *  v0.14.9
  *	Jul 10 2001 Matt Wu
  *	Add H/W Volume Control
  *  v0.14.8a
  *	July 7 2001 Alan Cox
  *	Moved Matt Wu's ac97 register cache into the card structure
  *  v0.14.8
  *	Apr 30 2001 Matt Wu
  *	Set EBUF1 and EBUF2 to still mode
  *	Add dc97/ac97 reset function
  *	Fix power management: ali_restore_regs
  *  unreleased
  *	Mar 09 2001 Matt Wu
  *	Add cache for ac97 access
  *  v0.14.7
  *	Feb 06 2001 Matt Wu
  *	Fix ac97 initialization
  *	Fix bug: an extra tail will be played when playing
  *	Jan 05 2001 Matt Wu
  *	Implement multi-channels and S/PDIF in support for ALi 1535+
  *  v0.14.6
  *	Nov 1 2000 Ching-Ling Lee
  *	Fix the bug of memory leak when switching 5.1-channels to 2 channels.
  *	Add lock protection into dynamic changing format of data.
  *	Oct 18 2000 Ching-Ling Lee
  *	5.1-channels support for ALi
  *	June 28 2000 Ching-Ling Lee
  *	S/PDIF out/in(playback/record) support for ALi 1535+, using /proc to be selected by user
  *	Simple Power Management support for ALi
  *  v0.14.5 May 23 2000 Ollie Lho
  *  	Misc bug fix from the Net
  *  v0.14.4 May 20 2000 Aaron Holtzman
  *  	Fix kfree'd memory access in release
  *  	Fix race in open while looking for a free virtual channel slot
  *  	remove open_wait wq (which appears to be unused)
  *  v0.14.3 May 10 2000 Ollie Lho
  *	fixed a small bug in trident_update_ptr, xmms 1.0.1 no longer uses 100% CPU
  *  v0.14.2 Mar 29 2000 Ching-Ling Lee
  *	Add clear to silence advance in trident_update_ptr
  *	fix invalid data of the end of the sound
  *  v0.14.1 Mar 24 2000 Ching-Ling Lee
  *	ALi 5451 support added, playback and recording O.K.
  *	ALi 5451 originally developed and structured based on sonicvibes, and
  *	suggested to merge into this file by Alan Cox.
  *  v0.14 Mar 15 2000 Ollie Lho
  *	5.1 channel output support with channel binding. What's the Matrix ?
  *  v0.13.1 Mar 10 2000 Ollie Lho
  *	few minor bugs on dual codec support, needs more testing
  *  v0.13 Mar 03 2000 Ollie Lho
  *	new pci_* for 2.4 kernel, back ported to 2.2
  *  v0.12 Feb 23 2000 Ollie Lho
  *	Preliminary Recording support
  *  v0.11.2 Feb 19 2000 Ollie Lho
  *	removed incomplete full-dulplex support
  *  v0.11.1 Jan 28 2000 Ollie Lho
  *	small bug in setting sample rate for 4d-nx (reported by Aaron)
  *  v0.11 Jan 27 2000 Ollie Lho
  *	DMA bug, scheduler latency, second try
  *  v0.10 Jan 24 2000 Ollie Lho
  *	DMA bug fixed, found kernel scheduling problem
  *  v0.09 Jan 20 2000 Ollie Lho
  *	Clean up of channel register access routine (prepare for channel binding)
  *  v0.08 Jan 14 2000 Ollie Lho
  *	Isolation of AC97 codec code
  *  v0.07 Jan 13 2000 Ollie Lho
  *	Get rid of ugly old low level access routines (e.g. CHRegs.lp****)
  *  v0.06 Jan 11 2000 Ollie Lho
  *	Preliminary support for dual (more ?) AC97 codecs
  *  v0.05 Jan 08 2000 Luca Montecchiani <m.luca@iname.com>
  *	adapt to 2.3.x new __setup/__init call
  *  v0.04 Dec 31 1999 Ollie Lho
  *	Multiple Open, using Middle Loop Interrupt to smooth playback
  *  v0.03 Dec 24 1999 Ollie Lho
  *	mem leak in prog_dmabuf and dealloc_dmabuf removed
  *  v0.02 Dec 15 1999 Ollie Lho
  *	SiS 7018 support added, playback O.K.
  *  v0.01 Alan Cox et. al.
  *	Initial Release in kernel 2.3.30, does not work
  *
  *  ToDo
  *	Clean up of low level channel register access code. (done)
  *	Fix the bug on dma buffer management in update_ptr, read/write, drain_dac (done)
  *	Dual AC97 codecs support (done)
  *	Recording support (done)
  *	Mmap support
  *	"Channel Binding" ioctl extension (done)
  *	new pci device driver interface for 2.4 kernel (done)
  *
  *	Lock order (high->low)
  *		lock	-	hardware lock
  *		open_mutex - 	guard opens
  *		sem	-	guard dmabuf, write re-entry etc
  */
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/sound.h>
 #include <linux/slab.h>
 #include <linux/soundcard.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
 #include <linux/ac97_codec.h>
 #include <linux/bitops.h>
 #include <linux/proc_fs.h>
 #include <linux/interrupt.h>
 #include <linux/pm.h>
 #include <linux/gameport.h>
 #include <linux/kernel.h>
 #include <linux/mutex.h>
+#include <linux/mm.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/dma.h>
 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
 #include <asm/hwrpb.h>
 #endif
 #include "trident.h"
 #define DRIVER_VERSION "0.14.10j-2.6"
 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 #define SUPPORT_JOYSTICK 1
 #endif
 /* magic numbers to protect our data structures */
 #define TRIDENT_CARD_MAGIC	0x5072696E	/* "Prin" */
 #define TRIDENT_STATE_MAGIC	0x63657373	/* "cess" */
 #define TRIDENT_DMA_MASK	0x3fffffff	/* DMA buffer mask for pci_alloc_consist */
 #define ALI_DMA_MASK		0x7fffffff	/* ALI Tridents have 31-bit DMA. Wow. */
 #define NR_HW_CH		32
 /* maximum number of AC97 codecs connected, AC97 2.0 defined 4, but 7018 and 4D-NX only
    have 2 SDATA_IN lines (currently) */
 #define NR_AC97		2
 /* minor number of /dev/swmodem (temporary, experimental) */
 #define SND_DEV_SWMODEM	7
 static const unsigned ali_multi_channels_5_1[] = {
 	/*ALI_SURR_LEFT_CHANNEL, ALI_SURR_RIGHT_CHANNEL, */
 	ALI_CENTER_CHANNEL,
 	ALI_LEF_CHANNEL,
 	ALI_SURR_LEFT_CHANNEL,
 	ALI_SURR_RIGHT_CHANNEL
 };
 static const unsigned sample_size[] = { 1, 2, 2, 4 };
 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
 static const char invalid_magic[] = KERN_CRIT "trident: invalid magic value in %s\n";
 enum {
 	TRIDENT_4D_DX = 0,
 	TRIDENT_4D_NX,
 	SIS_7018,
 	ALI_5451,
 	CYBER5050
 };
 static char *card_names[] = {
 	"Trident 4DWave DX",
 	"Trident 4DWave NX",
 	"SiS 7018 PCI Audio",
 	"ALi Audio Accelerator",
 	"Tvia/IGST CyberPro 5050"
 };
 static struct pci_device_id trident_pci_tbl[] = {
 	{PCI_DEVICE(PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX),
 		PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TRIDENT_4D_DX},
 	{PCI_DEVICE(PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX),
 		0, 0, TRIDENT_4D_NX},
 	{PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7018), 0, 0, SIS_7018},
 	{PCI_DEVICE(PCI_VENDOR_ID_ALI, PCI_DEVICE_ID_ALI_5451), 0, 0, ALI_5451},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTERG, PCI_DEVICE_ID_INTERG_5050),
 		0, 0, CYBER5050},
 	{0,}
 };
 MODULE_DEVICE_TABLE(pci, trident_pci_tbl);
 /* "software" or virtual channel, an instance of opened /dev/dsp */
 struct trident_state {
 	unsigned int magic;
 	struct trident_card *card;	/* Card info */
 	/* file mode */
 	mode_t open_mode;
 	/* virtual channel number */
 	int virt;
 	struct dmabuf {
 		/* wave sample stuff */
 		unsigned int rate;
 		unsigned char fmt, enable;
 		/* hardware channel */
 		struct trident_channel *channel;
 		/* OSS buffer management stuff */
 		void *rawbuf;
 		dma_addr_t dma_handle;
 		unsigned buforder;
 		unsigned numfrag;
 		unsigned fragshift;
 		/* our buffer acts like a circular ring */
 		unsigned hwptr;	/* where dma last started, updated by update_ptr */
 		unsigned swptr;	/* where driver last clear/filled, updated by read/write */
 		int count;	/* bytes to be comsumed or been generated by dma machine */
 		unsigned total_bytes;	/* total bytes dmaed by hardware */
 		unsigned error;	/* number of over/underruns */
                 /* put process on wait queue when no more space in buffer */
 		wait_queue_head_t wait;
 		/* redundant, but makes calculations easier */
 		unsigned fragsize;
 		unsigned dmasize;
 		unsigned fragsamples;
 		/* OSS stuff */
 		unsigned mapped:1;
 		unsigned ready:1;
 		unsigned endcleared:1;
 		unsigned update_flag;
 		unsigned ossfragshift;
 		int ossmaxfrags;
 		unsigned subdivision;
 	} dmabuf;
 	/* 5.1 channels */
 	struct trident_state *other_states[4];
 	int multi_channels_adjust_count;
 	unsigned chans_num;
 	unsigned long fmt_flag;
 	/* Guard against mmap/write/read races */
 	struct mutex sem;
 };
 /* hardware channels */
 struct trident_channel {
 	int num; /* channel number */
 	u32 lba; /* Loop Begine Address, where dma buffer starts */
 	u32 eso; /* End Sample Offset, wehre dma buffer ends */
 	         /* (in the unit of samples) */
 	u32 delta; /* delta value, sample rate / 48k for playback, */
 	           /* 48k/sample rate for recording */
 	u16 attribute; /* control where PCM data go and come  */
 	u16 fm_vol;
 	u32 control; /* signed/unsigned, 8/16 bits, mono/stereo */
 };
 struct trident_pcm_bank_address {
 	u32 start;
 	u32 stop;
 	u32 aint;
 	u32 aint_en;
 };
 static struct trident_pcm_bank_address bank_a_addrs = {
 	T4D_START_A,
 	T4D_STOP_A,
 	T4D_AINT_A,
 	T4D_AINTEN_A
 };
 static struct trident_pcm_bank_address bank_b_addrs = {
 	T4D_START_B,
 	T4D_STOP_B,
 	T4D_AINT_B,
 	T4D_AINTEN_B
 };
 struct trident_pcm_bank {
 	/* register addresses to control bank operations */
 	struct trident_pcm_bank_address *addresses;
 	/* each bank has 32 channels */
 	u32 bitmap;		/* channel allocation bitmap */
 	struct trident_channel channels[32];
 };
 struct trident_card {
 	unsigned int magic;
 	/* We keep trident cards in a linked list */
 	struct trident_card *next;
 	/* single open lock mechanism, only used for recording */
 	struct mutex open_mutex;
 	/* The trident has a certain amount of cross channel interaction
 	   so we use a single per card lock */
 	spinlock_t lock;
 	/* PCI device stuff */
 	struct pci_dev *pci_dev;
 	u16 pci_id;
 	u8 revision;
 	/* soundcore stuff */
 	int dev_audio;
 	/* structures for abstraction of hardware facilities, codecs, */
 	/* banks and channels */
 	struct ac97_codec *ac97_codec[NR_AC97];
 	struct trident_pcm_bank banks[NR_BANKS];
 	struct trident_state *states[NR_HW_CH];
 	/* hardware resources */
 	unsigned long iobase;
 	u32 irq;
 	/* Function support */
 	struct trident_channel *(*alloc_pcm_channel) (struct trident_card *);
 	struct trident_channel *(*alloc_rec_pcm_channel) (struct trident_card *);
 	void (*free_pcm_channel) (struct trident_card *, unsigned int chan);
 	void (*address_interrupt) (struct trident_card *);
 	/* Added by Matt Wu 01-05-2001 for spdif in */
 	int multi_channel_use_count;
 	int rec_channel_use_count;
 	u16 mixer_regs[64][NR_AC97];	/* Made card local by Alan */
 	int mixer_regs_ready;
 	/* Added for hardware volume control */
 	int hwvolctl;
 	struct timer_list timer;
 	/* Game port support */
 	struct gameport *gameport;
 };
 enum dmabuf_mode {
 	DM_PLAYBACK = 0,
 	DM_RECORD
 };
 /* table to map from CHANNELMASK to channel attribute for SiS 7018 */
 static u16 mask2attr[] = {
 	PCM_LR, PCM_LR, SURR_LR, CENTER_LFE,
 	HSET, MIC, MODEM_LINE1, MODEM_LINE2,
 	I2S_LR, SPDIF_LR
 };
 /* table to map from channel attribute to CHANNELMASK for SiS 7018 */
 static int attr2mask[] = {
 	DSP_BIND_MODEM1, DSP_BIND_MODEM2, DSP_BIND_FRONT, DSP_BIND_HANDSET,
 	DSP_BIND_I2S, DSP_BIND_CENTER_LFE, DSP_BIND_SURR, DSP_BIND_SPDIF
 };
 /* Added by Matt Wu 01-05-2001 for spdif in */
 static int ali_close_multi_channels(void);
 static void ali_delay(struct trident_card *card, int interval);
 static void ali_detect_spdif_rate(struct trident_card *card);
 static void ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val);
 static u16 ali_ac97_read(struct ac97_codec *codec, u8 reg);
 static struct trident_card *devs;
 static void trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val);
 static u16 trident_ac97_get(struct ac97_codec *codec, u8 reg);
 static int trident_open_mixdev(struct inode *inode, struct file *file);
 static int trident_ioctl_mixdev(struct inode *inode, struct file *file,
 				unsigned int cmd, unsigned long arg);
 static void ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val);
 static u16 ali_ac97_get(struct trident_card *card, int secondary, u8 reg);
 static void ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate);
 static void ali_enable_special_channel(struct trident_state *stat);
 static struct trident_channel *ali_alloc_rec_pcm_channel(struct trident_card *card);
 static struct trident_channel *ali_alloc_pcm_channel(struct trident_card *card);
 static void ali_free_pcm_channel(struct trident_card *card, unsigned int channel);
 static int ali_setup_multi_channels(struct trident_card *card, int chan_nums);
 static unsigned int ali_get_spdif_in_rate(struct trident_card *card);
 static void ali_setup_spdif_in(struct trident_card *card);
 static void ali_disable_spdif_in(struct trident_card *card);
 static void ali_disable_special_channel(struct trident_card *card, int ch);
 static void ali_setup_spdif_out(struct trident_card *card, int flag);
 static int ali_write_5_1(struct trident_state *state,
 			 const char __user *buffer,
 			 int cnt_for_multi_channel, unsigned int *copy_count,
 			 unsigned int *state_cnt);
 static int ali_allocate_other_states_resources(struct trident_state *state,
 					       int chan_nums);
 static void ali_free_other_states_resources(struct trident_state *state);
 #define seek_offset(dma_ptr, buffer, cnt, offset, copy_count)	do { \
         (dma_ptr) += (offset);	  \
 	(buffer) += (offset);	  \
         (cnt) -= (offset);	  \
 	(copy_count) += (offset); \
 } while (0)
 static inline int lock_set_fmt(struct trident_state* state)
 {
 	if (test_and_set_bit(0, &state->fmt_flag))
 		return -EFAULT;
 	return 0;
 }
 static inline void unlock_set_fmt(struct trident_state* state)
 {
 	clear_bit(0, &state->fmt_flag);
 }
 static int
 trident_enable_loop_interrupts(struct trident_card *card)
 {
 	u32 global_control;
 	global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
 	switch (card->pci_id) {
 	case PCI_DEVICE_ID_SI_7018:
 		global_control |= (ENDLP_IE | MIDLP_IE | BANK_B_EN);
 		break;
 	case PCI_DEVICE_ID_ALI_5451:
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 	case PCI_DEVICE_ID_INTERG_5050:
 		global_control |= (ENDLP_IE | MIDLP_IE);
 		break;
 	default:
 		return 0;
 	}
 	outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
 	pr_debug("trident: Enable Loop Interrupts, globctl = 0x%08X\n",
 		 inl(TRID_REG(card, T4D_LFO_GC_CIR)));
 	return 1;
 }
 static int
 trident_disable_loop_interrupts(struct trident_card *card)
 {
 	u32 global_control;
 	global_control = inl(TRID_REG(card, T4D_LFO_GC_CIR));
 	global_control &= ~(ENDLP_IE | MIDLP_IE);
 	outl(global_control, TRID_REG(card, T4D_LFO_GC_CIR));
 	pr_debug("trident: Disabled Loop Interrupts, globctl = 0x%08X\n",
 		 global_control);
 	return 1;
 }
 static void
 trident_enable_voice_irq(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 	u32 reg, addr = bank->addresses->aint_en;
 	reg = inl(TRID_REG(card, addr));
 	reg |= mask;
 	outl(reg, TRID_REG(card, addr));
 #ifdef DEBUG
 	reg = inl(TRID_REG(card, addr));
 	pr_debug("trident: enabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
 		 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
 		 reg, addr);
 #endif /* DEBUG */
 }
 static void
 trident_disable_voice_irq(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 	u32 reg, addr = bank->addresses->aint_en;
 	reg = inl(TRID_REG(card, addr));
 	reg &= ~mask;
 	outl(reg, TRID_REG(card, addr));
 	/* Ack the channel in case the interrupt was set before we disable it. */
 	outl(mask, TRID_REG(card, bank->addresses->aint));
 #ifdef DEBUG
 	reg = inl(TRID_REG(card, addr));
 	pr_debug("trident: disabled IRQ on channel %d, %s = 0x%08x(addr:%X)\n",
 		 channel, addr == T4D_AINTEN_B ? "AINTEN_B" : "AINTEN_A",
 		 reg, addr);
 #endif /* DEBUG */
 }
 static void
 trident_start_voice(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 	u32 addr = bank->addresses->start;
 #ifdef DEBUG
 	u32 reg;
 #endif /* DEBUG */
 	outl(mask, TRID_REG(card, addr));
 #ifdef DEBUG
 	reg = inl(TRID_REG(card, addr));
 	pr_debug("trident: start voice on channel %d, %s = 0x%08x(addr:%X)\n",
 		 channel, addr == T4D_START_B ? "START_B" : "START_A",
 		 reg, addr);
 #endif /* DEBUG */
 }
 static void
 trident_stop_voice(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 	u32 addr = bank->addresses->stop;
 #ifdef DEBUG
 	u32 reg;
 #endif /* DEBUG */
 	outl(mask, TRID_REG(card, addr));
 #ifdef DEBUG
 	reg = inl(TRID_REG(card, addr));
 	pr_debug("trident: stop voice on channel %d, %s = 0x%08x(addr:%X)\n",
 		 channel, addr == T4D_STOP_B ? "STOP_B" : "STOP_A",
 		 reg, addr);
 #endif /* DEBUG */
 }
 static u32
 trident_get_interrupt_mask(struct trident_card *card, unsigned int channel)
 {
 	struct trident_pcm_bank *bank = &card->banks[channel];
 	u32 addr = bank->addresses->aint;
 	return inl(TRID_REG(card, addr));
 }
 static int
 trident_check_channel_interrupt(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	u32 reg = trident_get_interrupt_mask(card, channel >> 5);
 #ifdef DEBUG
 	if (reg & mask)
 		pr_debug("trident: channel %d has interrupt, %s = 0x%08x\n",
 			 channel, reg == T4D_AINT_B ? "AINT_B" : "AINT_A",
 			 reg);
 #endif /* DEBUG */
 	return (reg & mask) ? 1 : 0;
 }
 static void
 trident_ack_channel_interrupt(struct trident_card *card, unsigned int channel)
 {
 	unsigned int mask = 1 << (channel & 0x1f);
 	struct trident_pcm_bank *bank = &card->banks[channel >> 5];
 	u32 reg, addr = bank->addresses->aint;
 	reg = inl(TRID_REG(card, addr));
 	reg &= mask;
 	outl(reg, TRID_REG(card, addr));
 #ifdef DEBUG
 	reg = inl(TRID_REG(card, T4D_AINT_B));
 	pr_debug("trident: Ack channel %d interrupt, AINT_B = 0x%08x\n",
 		 channel, reg);
 #endif /* DEBUG */
 }
 static struct trident_channel *
 trident_alloc_pcm_channel(struct trident_card *card)
 {
 	struct trident_pcm_bank *bank;
 	int idx;
 	bank = &card->banks[BANK_B];
 	for (idx = 31; idx >= 0; idx--) {
 		if (!(bank->bitmap & (1 << idx))) {
 			struct trident_channel *channel = &bank->channels[idx];
 			bank->bitmap |= 1 << idx;
 			channel->num = idx + 32;
 			return channel;
 		}
 	}
 	/* no more free channels available */
 	printk(KERN_ERR "trident: no more channels available on Bank B.\n");
 	return NULL;
 }
 static void
 trident_free_pcm_channel(struct trident_card *card, unsigned int channel)
 {
 	int bank;
 	unsigned char b;
 	if (channel < 31 || channel > 63)
 		return;
 	if (card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_DX ||
 	    card->pci_id == PCI_DEVICE_ID_TRIDENT_4DWAVE_NX) {
 		b = inb(TRID_REG(card, T4D_REC_CH));
 		if ((b & ~0x80) == channel)
 			outb(0x0, TRID_REG(card, T4D_REC_CH));
 	}
 	bank = channel >> 5;
 	channel = channel & 0x1f;
 	card->banks[bank].bitmap &= ~(1 << (channel));
 }
 static struct trident_channel *
 cyber_alloc_pcm_channel(struct trident_card *card)
 {
 	struct trident_pcm_bank *bank;
 	int idx;
 	/* The cyberpro 5050 has only 32 voices and one bank */
 	/* .. at least they are not documented (if you want to call that
 	 * crap documentation), perhaps broken ? */
 	bank = &card->banks[BANK_A];
 	for (idx = 31; idx >= 0; idx--) {
 		if (!(bank->bitmap & (1 << idx))) {
 			struct trident_channel *channel = &bank->channels[idx];
 			bank->bitmap |= 1 << idx;
 			channel->num = idx;
 			return channel;
 		}
 	}
 	/* no more free channels available */
 	printk(KERN_ERR "cyberpro5050: no more channels available on Bank A.\n");
 	return NULL;
 }
 static void
 cyber_free_pcm_channel(struct trident_card *card, unsigned int channel)
 {
 	if (channel > 31)
 		return;
 	card->banks[BANK_A].bitmap &= ~(1 << (channel));
 }
 static inline void
 cyber_outidx(int port, int idx, int data)
 {
 	outb(idx, port);
 	outb(data, port + 1);
 }
 static inline int
 cyber_inidx(int port, int idx)
 {
 	outb(idx, port);
 	return inb(port + 1);
 }
 static int
 cyber_init_ritual(struct trident_card *card)
 {
 	/* some black magic, taken from SDK samples */
 	/* remove this and nothing will work */
 	int portDat;
 	int ret = 0;
 	unsigned long flags;
 	/*
 	 *      Keep interrupts off for the configure - we don't want to
 	 *      clash with another cyberpro config event
 	 */
 	spin_lock_irqsave(&card->lock, flags);
 	portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
 	/* enable, if it was disabled */
 	if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
 		printk(KERN_INFO "cyberpro5050: enabling audio controller\n");
 		cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE,
 			     portDat | CYBER_BMSK_AUENZ_ENABLE);
 		/* check again if hardware is enabled now */
 		portDat = cyber_inidx(CYBER_PORT_AUDIO, CYBER_IDX_AUDIO_ENABLE);
 	}
 	if ((portDat & CYBER_BMSK_AUENZ) != CYBER_BMSK_AUENZ_ENABLE) {
 		printk(KERN_ERR "cyberpro5050: initAudioAccess: no success\n");
 		ret = -1;
 	} else {
 		cyber_outidx(CYBER_PORT_AUDIO, CYBER_IDX_IRQ_ENABLE,
 			     CYBER_BMSK_AUDIO_INT_ENABLE);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x01);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xba, 0x20);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xbb, 0x08);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x02);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xb3, 0x06);
 		cyber_outidx(CYBER_PORT_AUDIO, 0xbf, 0x00);
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 	return ret;
 }
 /*  called with spin lock held */
 static int
 trident_load_channel_registers(struct trident_card *card, u32 * data,
 			       unsigned int channel)
 {
 	int i;
 	if (channel > 63)
 		return 0;
 	/* select hardware channel to write */
 	outb(channel, TRID_REG(card, T4D_LFO_GC_CIR));
 	/* Output the channel registers, but don't write register
 	   three to an ALI chip. */
 	for (i = 0; i < CHANNEL_REGS; i++) {
 		if (i == 3 && card->pci_id == PCI_DEVICE_ID_ALI_5451)
 			continue;
 		outl(data[i], TRID_REG(card, CHANNEL_START + 4 * i));
 	}
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
 	    card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
 		outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF1));
 		outl(ALI_EMOD_Still, TRID_REG(card, ALI_EBUF2));
 	}
 	return 1;
 }
 /* called with spin lock held */
 static int
 trident_write_voice_regs(struct trident_state *state)
 {
 	unsigned int data[CHANNEL_REGS + 1];
 	struct trident_channel *channel;
 	channel = state->dmabuf.channel;
 	data[1] = channel->lba;
 	data[4] = channel->control;
 	switch (state->card->pci_id) {
 	case PCI_DEVICE_ID_ALI_5451:
 		data[0] = 0;	/* Current Sample Offset */
 		data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 		data[3] = 0;
 		break;
 	case PCI_DEVICE_ID_SI_7018:
 	case PCI_DEVICE_ID_INTERG_5050:
 		data[0] = 0;	/* Current Sample Offset */
 		data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 		data[3] = (channel->attribute << 16) | (channel->fm_vol & 0xffff);
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 		data[0] = 0;	/* Current Sample Offset */
 		data[2] = (channel->eso << 16) | (channel->delta & 0xffff);
 		data[3] = channel->fm_vol & 0xffff;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		data[0] = (channel->delta << 24);
 		data[2] = ((channel->delta << 16) & 0xff000000) |
 			(channel->eso & 0x00ffffff);
 		data[3] = channel->fm_vol & 0xffff;
 		break;
 	default:
 		return 0;
 	}
 	return trident_load_channel_registers(state->card, data, channel->num);
 }
 static int
 compute_rate_play(u32 rate)
 {
 	int delta;
 	/* We special case 44100 and 8000 since rounding with the equation
 	   does not give us an accurate enough value. For 11025 and 22050
 	   the equation gives us the best answer. All other frequencies will
 	   also use the equation. JDW */
 	if (rate == 44100)
 		delta = 0xeb3;
 	else if (rate == 8000)
 		delta = 0x2ab;
 	else if (rate == 48000)
 		delta = 0x1000;
 	else
 		delta = (((rate << 12) + rate) / 48000) & 0x0000ffff;
 	return delta;
 }
 static int
 compute_rate_rec(u32 rate)
 {
 	int delta;
 	if (rate == 44100)
 		delta = 0x116a;
 	else if (rate == 8000)
 		delta = 0x6000;
 	else if (rate == 48000)
 		delta = 0x1000;
 	else
 		delta = ((48000 << 12) / rate) & 0x0000ffff;
 	return delta;
 }
 /* set playback sample rate */
 static unsigned int
 trident_set_dac_rate(struct trident_state *state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 4000)
 		rate = 4000;
 	dmabuf->rate = rate;
 	dmabuf->channel->delta = compute_rate_play(rate);
 	trident_write_voice_regs(state);
 	pr_debug("trident: called trident_set_dac_rate : rate = %d\n", rate);
 	return rate;
 }
 /* set recording sample rate */
 static unsigned int
 trident_set_adc_rate(struct trident_state *state, unsigned int rate)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	if (rate > 48000)
 		rate = 48000;
 	if (rate < 4000)
 		rate = 4000;
 	dmabuf->rate = rate;
 	dmabuf->channel->delta = compute_rate_rec(rate);
 	trident_write_voice_regs(state);
 	pr_debug("trident: called trident_set_adc_rate : rate = %d\n", rate);
 	return rate;
 }
 /* prepare channel attributes for playback */
 static void
 trident_play_setup(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct trident_channel *channel = dmabuf->channel;
 	channel->lba = dmabuf->dma_handle;
 	channel->delta = compute_rate_play(dmabuf->rate);
 	channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
 	channel->eso -= 1;
 	if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
 		channel->attribute = 0;
 		if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 			if ((channel->num == ALI_SPDIF_IN_CHANNEL) ||
 			    (channel->num == ALI_PCM_IN_CHANNEL))
 				ali_disable_special_channel(state->card, channel->num);
 			else if ((inl(TRID_REG(state->card, ALI_GLOBAL_CONTROL))
 				  & ALI_SPDIF_OUT_CH_ENABLE)
 				 && (channel->num == ALI_SPDIF_OUT_CHANNEL)) {
 				ali_set_spdif_out_rate(state->card,
 						       state->dmabuf.rate);
 				state->dmabuf.channel->delta = 0x1000;
 			}
 		}
 	}
 	channel->fm_vol = 0x0;
 	channel->control = CHANNEL_LOOP;
 	if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
 		/* 16-bits */
 		channel->control |= CHANNEL_16BITS;
 		/* signed */
 		channel->control |= CHANNEL_SIGNED;
 	}
 	if (dmabuf->fmt & TRIDENT_FMT_STEREO)
 		/* stereo */
 		channel->control |= CHANNEL_STEREO;
 	pr_debug("trident: trident_play_setup, LBA = 0x%08x, Delta = 0x%08x, "
 		 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
 		 channel->delta, channel->eso, channel->control);
 	trident_write_voice_regs(state);
 }
 /* prepare channel attributes for recording */
 static void
 trident_rec_setup(struct trident_state *state)
 {
 	u16 w;
 	u8 bval;
 	struct trident_card *card = state->card;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct trident_channel *channel = dmabuf->channel;
 	unsigned int rate;
 	/* Enable AC-97 ADC (capture) */
 	switch (card->pci_id) {
 	case PCI_DEVICE_ID_ALI_5451:
 		ali_enable_special_channel(state);
 		break;
 	case PCI_DEVICE_ID_SI_7018:
 		/* for 7018, the ac97 is always in playback/record (duplex) mode */
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 		w = inb(TRID_REG(card, DX_ACR2_AC97_COM_STAT));
 		outb(w | 0x48, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
 		/* enable and set record channel */
 		outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		w = inw(TRID_REG(card, T4D_MISCINT));
 		outw(w | 0x1000, TRID_REG(card, T4D_MISCINT));
 		/* enable and set record channel */
 		outb(0x80 | channel->num, TRID_REG(card, T4D_REC_CH));
 		break;
 	case PCI_DEVICE_ID_INTERG_5050:
 		/* don't know yet, using special channel 22 in GC1(0xd4)? */
 		break;
 	default:
 		return;
 	}
 	channel->lba = dmabuf->dma_handle;
 	channel->delta = compute_rate_rec(dmabuf->rate);
 	if ((card->pci_id == PCI_DEVICE_ID_ALI_5451) &&
 	    (channel->num == ALI_SPDIF_IN_CHANNEL)) {
 		rate = ali_get_spdif_in_rate(card);
 		if (rate == 0) {
 			printk(KERN_WARNING "trident: ALi 5451 "
 			       "S/PDIF input setup error!\n");
 			rate = 48000;
 		}
 		bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 		if (bval & 0x10) {
 			outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
 			printk(KERN_WARNING "trident: cleared ALi "
 			       "5451 S/PDIF parity error flag.\n");
 		}
 		if (rate != 48000)
 			channel->delta = ((rate << 12) / dmabuf->rate) & 0x0000ffff;
 	}
 	channel->eso = dmabuf->dmasize >> sample_shift[dmabuf->fmt];
 	channel->eso -= 1;
 	if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
 		channel->attribute = 0;
 	}
 	channel->fm_vol = 0x0;
 	channel->control = CHANNEL_LOOP;
 	if (dmabuf->fmt & TRIDENT_FMT_16BIT) {
 		/* 16-bits */
 		channel->control |= CHANNEL_16BITS;
 		/* signed */
 		channel->control |= CHANNEL_SIGNED;
 	}
 	if (dmabuf->fmt & TRIDENT_FMT_STEREO)
 		/* stereo */
 		channel->control |= CHANNEL_STEREO;
 	pr_debug("trident: trident_rec_setup, LBA = 0x%08x, Delat = 0x%08x, "
 		 "ESO = 0x%08x, Control = 0x%08x\n", channel->lba,
 		 channel->delta, channel->eso, channel->control);
 	trident_write_voice_regs(state);
 }
 /* get current playback/recording dma buffer pointer (byte offset from LBA),
    called with spinlock held! */
 static inline unsigned
 trident_get_dma_addr(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	u32 cso;
 	if (!dmabuf->enable)
 		return 0;
 	outb(dmabuf->channel->num, TRID_REG(state->card, T4D_LFO_GC_CIR));
 	switch (state->card->pci_id) {
 	case PCI_DEVICE_ID_ALI_5451:
 	case PCI_DEVICE_ID_SI_7018:
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 	case PCI_DEVICE_ID_INTERG_5050:
 		/* 16 bits ESO, CSO for 7018 and DX */
 		cso = inw(TRID_REG(state->card, CH_DX_CSO_ALPHA_FMS + 2));
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		/* 24 bits ESO, CSO for NX */
 		cso = inl(TRID_REG(state->card, CH_NX_DELTA_CSO)) & 0x00ffffff;
 		break;
 	default:
 		return 0;
 	}
 	pr_debug("trident: trident_get_dma_addr: chip reported channel: %d, "
 		 "cso = 0x%04x\n", dmabuf->channel->num, cso);
 	/* ESO and CSO are in units of Samples, convert to byte offset */
 	cso <<= sample_shift[dmabuf->fmt];
 	return (cso % dmabuf->dmasize);
 }
 /* Stop recording (lock held) */
 static inline void
 __stop_adc(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int chan_num = dmabuf->channel->num;
 	struct trident_card *card = state->card;
 	dmabuf->enable &= ~ADC_RUNNING;
 	trident_stop_voice(card, chan_num);
 	trident_disable_voice_irq(card, chan_num);
 }
 static void
 stop_adc(struct trident_state *state)
 {
 	struct trident_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__stop_adc(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static void
 start_adc(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int chan_num = dmabuf->channel->num;
 	struct trident_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	if ((dmabuf->mapped ||
 	     dmabuf->count < (signed) dmabuf->dmasize) &&
 	    dmabuf->ready) {
 		dmabuf->enable |= ADC_RUNNING;
 		trident_enable_voice_irq(card, chan_num);
 		trident_start_voice(card, chan_num);
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 /* stop playback (lock held) */
 static inline void
 __stop_dac(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int chan_num = dmabuf->channel->num;
 	struct trident_card *card = state->card;
 	dmabuf->enable &= ~DAC_RUNNING;
 	trident_stop_voice(card, chan_num);
 	if (state->chans_num == 6) {
 		trident_stop_voice(card, state->other_states[0]->
 				   dmabuf.channel->num);
 		trident_stop_voice(card, state->other_states[1]->
 				   dmabuf.channel->num);
 		trident_stop_voice(card, state->other_states[2]->
 				   dmabuf.channel->num);
 		trident_stop_voice(card, state->other_states[3]->
 				   dmabuf.channel->num);
 	}
 	trident_disable_voice_irq(card, chan_num);
 }
 static void
 stop_dac(struct trident_state *state)
 {
 	struct trident_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	__stop_dac(state);
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static void
 start_dac(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned int chan_num = dmabuf->channel->num;
 	struct trident_card *card = state->card;
 	unsigned long flags;
 	spin_lock_irqsave(&card->lock, flags);
 	if ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) {
 		dmabuf->enable |= DAC_RUNNING;
 		trident_enable_voice_irq(card, chan_num);
 		trident_start_voice(card, chan_num);
 		if (state->chans_num == 6) {
 			trident_start_voice(card, state->other_states[0]->
 					    dmabuf.channel->num);
 			trident_start_voice(card, state->other_states[1]->
 					    dmabuf.channel->num);
 			trident_start_voice(card, state->other_states[2]->
 					    dmabuf.channel->num);
 			trident_start_voice(card, state->other_states[3]->
 					    dmabuf.channel->num);
 		}
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 #define DMABUF_DEFAULTORDER (15-PAGE_SHIFT)
 #define DMABUF_MINORDER 1
 /* alloc a DMA buffer of with a buffer of this order */
 static int
 alloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev, int order)
 {
 	void *rawbuf = NULL;
 	struct page *page, *pend;
 	if (!(rawbuf = pci_alloc_consistent(pci_dev, PAGE_SIZE << order,
 					    &dmabuf->dma_handle)))
 		return -ENOMEM;
 	pr_debug("trident: allocated %ld (order = %d) bytes at %p\n",
 		 PAGE_SIZE << order, order, rawbuf);
 	dmabuf->ready = dmabuf->mapped = 0;
 	dmabuf->rawbuf = rawbuf;
 	dmabuf->buforder = order;
 	/* now mark the pages as reserved; otherwise */
 	/* remap_pfn_range doesn't do what we want */
 	pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
 	for (page = virt_to_page(rawbuf); page <= pend; page++)
 		SetPageReserved(page);
 	return 0;
 }
 /* allocate the main DMA buffer, playback and recording buffer should be */
 /* allocated separately */
 static int
 alloc_main_dmabuf(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int order;
 	int ret = -ENOMEM;
 	/* alloc as big a chunk as we can, FIXME: is this necessary ?? */
 	for (order = DMABUF_DEFAULTORDER; order >= DMABUF_MINORDER; order--) {
 		if (!(ret = alloc_dmabuf(dmabuf, state->card->pci_dev, order)))
 			return 0;
 		/* else try again */
 	}
 	return ret;
 }
 /* deallocate a DMA buffer */
 static void
 dealloc_dmabuf(struct dmabuf *dmabuf, struct pci_dev *pci_dev)
 {
 	struct page *page, *pend;
 	if (dmabuf->rawbuf) {
 		/* undo marking the pages as reserved */
 		pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
 		for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
 			ClearPageReserved(page);
 		pci_free_consistent(pci_dev, PAGE_SIZE << dmabuf->buforder,
 				    dmabuf->rawbuf, dmabuf->dma_handle);
 		dmabuf->rawbuf = NULL;
 	}
 	dmabuf->mapped = dmabuf->ready = 0;
 }
 static int
 prog_dmabuf(struct trident_state *state, enum dmabuf_mode rec)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned bytepersec;
 	struct trident_state *s = state;
 	unsigned bufsize, dma_nums;
 	unsigned long flags;
 	int ret, i, order;
 	if ((ret = lock_set_fmt(state)) < 0)
 		return ret;
 	if (state->chans_num == 6)
 		dma_nums = 5;
 	else
 		dma_nums = 1;
 	for (i = 0; i < dma_nums; i++) {
 		if (i > 0) {
 			s = state->other_states[i - 1];
 			dmabuf = &s->dmabuf;
 			dmabuf->fmt = state->dmabuf.fmt;
 			dmabuf->rate = state->dmabuf.rate;
 		}
 		spin_lock_irqsave(&s->card->lock, flags);
 		dmabuf->hwptr = dmabuf->swptr = dmabuf->total_bytes = 0;
 		dmabuf->count = dmabuf->error = 0;
 		spin_unlock_irqrestore(&s->card->lock, flags);
 		/* allocate DMA buffer if not allocated yet */
 		if (!dmabuf->rawbuf) {
 			if (i == 0) {
 				if ((ret = alloc_main_dmabuf(state))) {
 					unlock_set_fmt(state);
 					return ret;
 				}
 			} else {
 				ret = -ENOMEM;
 				order = state->dmabuf.buforder - 1;
 				if (order >= DMABUF_MINORDER) {
 					ret = alloc_dmabuf(dmabuf,
 							   state->card->pci_dev,
 							   order);
 				}
 				if (ret) {
 					/* release the main DMA buffer */
 					dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
 					/* release the auxiliary DMA buffers */
 					for (i -= 2; i >= 0; i--)
 						dealloc_dmabuf(&state->other_states[i]->dmabuf,
 							       state->card->pci_dev);
 					unlock_set_fmt(state);
 					return ret;
 				}
 			}
 		}
 		/* FIXME: figure out all this OSS fragment stuff */
 		bytepersec = dmabuf->rate << sample_shift[dmabuf->fmt];
 		bufsize = PAGE_SIZE << dmabuf->buforder;
 		if (dmabuf->ossfragshift) {
 			if ((1000 << dmabuf->ossfragshift) < bytepersec)
 				dmabuf->fragshift = ld2(bytepersec / 1000);
 			else
 				dmabuf->fragshift = dmabuf->ossfragshift;
 		} else {
 			/* lets hand out reasonable big ass buffers by default */
 			dmabuf->fragshift = (dmabuf->buforder + PAGE_SHIFT - 2);
 		}
 		dmabuf->numfrag = bufsize >> dmabuf->fragshift;
 		while (dmabuf->numfrag < 4 && dmabuf->fragshift > 3) {
 			dmabuf->fragshift--;
 			dmabuf->numfrag = bufsize >> dmabuf->fragshift;
 		}
 		dmabuf->fragsize = 1 << dmabuf->fragshift;
 		if (dmabuf->ossmaxfrags >= 4 && dmabuf->ossmaxfrags < dmabuf->numfrag)
 			dmabuf->numfrag = dmabuf->ossmaxfrags;
 		dmabuf->fragsamples = dmabuf->fragsize >> sample_shift[dmabuf->fmt];
 		dmabuf->dmasize = dmabuf->numfrag << dmabuf->fragshift;
 		memset(dmabuf->rawbuf, (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80,
 		       dmabuf->dmasize);
 		spin_lock_irqsave(&s->card->lock, flags);
 		if (rec == DM_RECORD)
 			trident_rec_setup(s);
 		else /* DM_PLAYBACK */
 			trident_play_setup(s);
 		spin_unlock_irqrestore(&s->card->lock, flags);
 		/* set the ready flag for the dma buffer */
 		dmabuf->ready = 1;
 		pr_debug("trident: prog_dmabuf(%d), sample rate = %d, "
 			 "format = %d, numfrag = %d, fragsize = %d "
 			 "dmasize = %d\n", dmabuf->channel->num,
 			 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
 			 dmabuf->fragsize, dmabuf->dmasize);
 	}
 	unlock_set_fmt(state);
 	return 0;
 }
 static inline int prog_dmabuf_record(struct trident_state* state)
 {
 	return prog_dmabuf(state, DM_RECORD);
 }
 static inline int prog_dmabuf_playback(struct trident_state* state)
 {
 	return prog_dmabuf(state, DM_PLAYBACK);
 }
 /* we are doing quantum mechanics here, the buffer can only be empty, half or full filled i.e.
    |------------|------------|   or   |xxxxxxxxxxxx|------------|   or   |xxxxxxxxxxxx|xxxxxxxxxxxx|
    but we almost always get this
    |xxxxxx------|------------|   or   |xxxxxxxxxxxx|xxxxx-------|
    so we have to clear the tail space to "silence"
    |xxxxxx000000|------------|   or   |xxxxxxxxxxxx|xxxxxx000000|
 */
 static void
 trident_clear_tail(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned swptr;
 	unsigned char silence = (dmabuf->fmt & TRIDENT_FMT_16BIT) ? 0 : 0x80;
 	unsigned int len;
 	unsigned long flags;
 	spin_lock_irqsave(&state->card->lock, flags);
 	swptr = dmabuf->swptr;
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	if (swptr == 0 || swptr == dmabuf->dmasize / 2 ||
 	    swptr == dmabuf->dmasize)
 		return;
 	if (swptr < dmabuf->dmasize / 2)
 		len = dmabuf->dmasize / 2 - swptr;
 	else
 		len = dmabuf->dmasize - swptr;
 	memset(dmabuf->rawbuf + swptr, silence, len);
 	if (state->card->pci_id != PCI_DEVICE_ID_ALI_5451) {
 		spin_lock_irqsave(&state->card->lock, flags);
 		dmabuf->swptr += len;
 		dmabuf->count += len;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 	}
 	/* restart the dma machine in case it is halted */
 	start_dac(state);
 }
 static int
 drain_dac(struct trident_state *state, int nonblock)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	unsigned long tmo;
 	int count;
 	unsigned long diff = 0;
 	if (dmabuf->mapped || !dmabuf->ready)
 		return 0;
 	add_wait_queue(&dmabuf->wait, &wait);
 	for (;;) {
 		/* It seems that we have to set the current state to TASK_INTERRUPTIBLE
 		   every time to make the process really go to sleep */
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&state->card->lock, flags);
 		count = dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (count <= 0)
 			break;
 		if (signal_pending(current))
 			break;
 		if (nonblock) {
 			remove_wait_queue(&dmabuf->wait, &wait);
 			set_current_state(TASK_RUNNING);
 			return -EBUSY;
 		}
 		/* No matter how much data is left in the buffer, we have to wait until
 		   CSO == ESO/2 or CSO == ESO when address engine interrupts */
 		if (state->card->pci_id == PCI_DEVICE_ID_ALI_5451 ||
 		    state->card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
 			diff = dmabuf->swptr - trident_get_dma_addr(state) + dmabuf->dmasize;
 			diff = diff % (dmabuf->dmasize);
 			tmo = (diff * HZ) / dmabuf->rate;
 		} else {
 			tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
 		}
 		tmo >>= sample_shift[dmabuf->fmt];
 		if (!schedule_timeout(tmo ? tmo : 1) && tmo) {
 			break;
 		}
 	}
 	remove_wait_queue(&dmabuf->wait, &wait);
 	set_current_state(TASK_RUNNING);
 	if (signal_pending(current))
 		return -ERESTARTSYS;
 	return 0;
 }
 /* update buffer manangement pointers, especially, */
 /* dmabuf->count and dmabuf->hwptr */
 static void
 trident_update_ptr(struct trident_state *state)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned hwptr, swptr;
 	int clear_cnt = 0;
 	int diff;
 	unsigned char silence;
 	unsigned half_dmasize;
 	/* update hardware pointer */
 	hwptr = trident_get_dma_addr(state);
 	diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
 	dmabuf->hwptr = hwptr;
 	dmabuf->total_bytes += diff;
 	/* error handling and process wake up for ADC */
 	if (dmabuf->enable == ADC_RUNNING) {
 		if (dmabuf->mapped) {
 			dmabuf->count -= diff;
 			if (dmabuf->count >= (signed) dmabuf->fragsize)
 				wake_up(&dmabuf->wait);
 		} else {
 			dmabuf->count += diff;
 			if (dmabuf->count < 0 ||
 			    dmabuf->count > dmabuf->dmasize) {
 				/* buffer underrun or buffer overrun, */
 				/* we have no way to recover it here, just */
 				/* stop the machine and let the process */
 				/* force hwptr and swptr to sync */
 				__stop_adc(state);
 				dmabuf->error++;
 			}
 			if (dmabuf->count < (signed) dmabuf->dmasize / 2)
 				wake_up(&dmabuf->wait);
 		}
 	}
 	/* error handling and process wake up for DAC */
 	if (dmabuf->enable == DAC_RUNNING) {
 		if (dmabuf->mapped) {
 			dmabuf->count += diff;
 			if (dmabuf->count >= (signed) dmabuf->fragsize)
 				wake_up(&dmabuf->wait);
 		} else {
 			dmabuf->count -= diff;
 			if (dmabuf->count < 0 ||
 			    dmabuf->count > dmabuf->dmasize) {
 				/* buffer underrun or buffer overrun, we have no way to recover
 				   it here, just stop the machine and let the process force hwptr
 				   and swptr to sync */
 				__stop_dac(state);
 				dmabuf->error++;
 			} else if (!dmabuf->endcleared) {
 				swptr = dmabuf->swptr;
 				silence = (dmabuf->fmt & TRIDENT_FMT_16BIT ? 0 : 0x80);
 				if (dmabuf->update_flag & ALI_ADDRESS_INT_UPDATE) {
 					/* We must clear end data of 1/2 dmabuf if needed.
 					   According to 1/2 algorithm of Address Engine Interrupt,
 					   check the validation of the data of half dmasize. */
 					half_dmasize = dmabuf->dmasize / 2;
 					if ((diff = hwptr - half_dmasize) < 0)
 						diff = hwptr;
 					if ((dmabuf->count + diff) < half_dmasize) {
 						//there is invalid data in the end of half buffer
 						if ((clear_cnt = half_dmasize - swptr) < 0)
 							clear_cnt += half_dmasize;
 						//clear the invalid data
 						memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
 						if (state->chans_num == 6) {
 							clear_cnt = clear_cnt / 2;
 							swptr = swptr / 2;
 							memset(state->other_states[0]->dmabuf.rawbuf + swptr,
 							       silence, clear_cnt);
 							memset(state->other_states[1]->dmabuf.rawbuf + swptr,
 							       silence, clear_cnt);
 							memset(state->other_states[2]->dmabuf.rawbuf + swptr,
 							       silence, clear_cnt);
 							memset(state->other_states[3]->dmabuf.rawbuf + swptr,
 							       silence, clear_cnt);
 						}
 						dmabuf->endcleared = 1;
 					}
 				} else if (dmabuf->count < (signed) dmabuf->fragsize) {
 					clear_cnt = dmabuf->fragsize;
 					if ((swptr + clear_cnt) > dmabuf->dmasize)
 						clear_cnt = dmabuf->dmasize - swptr;
 					memset(dmabuf->rawbuf + swptr, silence, clear_cnt);
 					if (state->chans_num == 6) {
 						clear_cnt = clear_cnt / 2;
 						swptr = swptr / 2;
 						memset(state->other_states[0]->dmabuf.rawbuf + swptr,
 						       silence, clear_cnt);
 						memset(state->other_states[1]->dmabuf.rawbuf + swptr,
 						       silence, clear_cnt);
 						memset(state->other_states[2]->dmabuf.rawbuf + swptr,
 						       silence, clear_cnt);
 						memset(state->other_states[3]->dmabuf.rawbuf + swptr,
 						       silence, clear_cnt);
 					}
 					dmabuf->endcleared = 1;
 				}
 			}
 			/* trident_update_ptr is called by interrupt handler or by process via
 			   ioctl/poll, we only wake up the waiting process when we have more
 			   than 1/2 buffer free (always true for interrupt handler) */
 			if (dmabuf->count < (signed) dmabuf->dmasize / 2)
 				wake_up(&dmabuf->wait);
 		}
 	}
 	dmabuf->update_flag &= ~ALI_ADDRESS_INT_UPDATE;
 }
 static void
 trident_address_interrupt(struct trident_card *card)
 {
 	int i;
 	struct trident_state *state;
 	unsigned int channel;
 	/* Update the pointers for all channels we are running. */
 	/* FIXME: should read interrupt status only once */
 	for (i = 0; i < NR_HW_CH; i++) {
 		channel = 63 - i;
 		if (trident_check_channel_interrupt(card, channel)) {
 			trident_ack_channel_interrupt(card, channel);
 			if ((state = card->states[i]) != NULL) {
 				trident_update_ptr(state);
 			} else {
 				printk(KERN_WARNING "trident: spurious channel "
 				       "irq %d.\n", channel);
 				trident_stop_voice(card, channel);
 				trident_disable_voice_irq(card, channel);
 			}
 		}
 	}
 }
 static void
 ali_hwvol_control(struct trident_card *card, int opt)
 {
 	u16 dwTemp, volume[2], mute, diff, *pVol[2];
 	dwTemp = ali_ac97_read(card->ac97_codec[0], 0x02);
 	mute = dwTemp & 0x8000;
 	volume[0] = dwTemp & 0x001f;
 	volume[1] = (dwTemp & 0x1f00) >> 8;
 	if (volume[0] < volume[1]) {
 		pVol[0] = &volume[0];
 		pVol[1] = &volume[1];
 	} else {
 		pVol[1] = &volume[0];
 		pVol[0] = &volume[1];
 	}
 	diff = *(pVol[1]) - *(pVol[0]);
 	if (opt == 1) {		// MUTE
 		dwTemp ^= 0x8000;
 		ali_ac97_write(card->ac97_codec[0],
 			       0x02, dwTemp);
 	} else if (opt == 2) {	// Down
 		if (mute)
 			return;
 		if (*(pVol[1]) < 0x001f) {
 			(*pVol[1])++;
 			*(pVol[0]) = *(pVol[1]) - diff;
 		}
 		dwTemp &= 0xe0e0;
 		dwTemp |= (volume[0]) | (volume[1] << 8);
 		ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
 		card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
 			(((32 - volume[1]) * 25 / 8) << 8);
 	} else if (opt == 4) {	// Up
 		if (mute)
 			return;
 		if (*(pVol[0]) > 0) {
 			(*pVol[0])--;
 			*(pVol[1]) = *(pVol[0]) + diff;
 		}
 		dwTemp &= 0xe0e0;
 		dwTemp |= (volume[0]) | (volume[1] << 8);
 		ali_ac97_write(card->ac97_codec[0], 0x02, dwTemp);
 		card->ac97_codec[0]->mixer_state[0] = ((32 - volume[0]) * 25 / 8) |
 			(((32 - volume[1]) * 25 / 8) << 8);
 	} else {
 		/* Nothing needs doing */
 	}
 }
 /*
  *	Re-enable reporting of vol change after 0.1 seconds
  */
 static void
 ali_timeout(unsigned long ptr)
 {
 	struct trident_card *card = (struct trident_card *) ptr;
 	u16 temp = 0;
 	/* Enable GPIO IRQ (MISCINT bit 18h) */
 	temp = inw(TRID_REG(card, T4D_MISCINT + 2));
 	temp |= 0x0004;
 	outw(temp, TRID_REG(card, T4D_MISCINT + 2));
 }
 /*
  *	Set up the timer to clear the vol change notification
  */
 static void
 ali_set_timer(struct trident_card *card)
 {
 	/* Add Timer Routine to Enable GPIO IRQ */
 	del_timer(&card->timer);	/* Never queue twice */
 	card->timer.function = ali_timeout;
 	card->timer.data = (unsigned long) card;
 	card->timer.expires = jiffies + HZ / 10;
 	add_timer(&card->timer);
 }
 /*
  *	Process a GPIO event
  */
 static void
 ali_queue_task(struct trident_card *card, int opt)
 {
 	u16 temp;
 	/* Disable GPIO IRQ (MISCINT bit 18h) */
 	temp = inw(TRID_REG(card, T4D_MISCINT + 2));
 	temp &= (u16) (~0x0004);
 	outw(temp, TRID_REG(card, T4D_MISCINT + 2));
 	/* Adjust the volume */
 	ali_hwvol_control(card, opt);
 	/* Set the timer for 1/10th sec */
 	ali_set_timer(card);
 }
 static void
 cyber_address_interrupt(struct trident_card *card)
 {
 	int i, irq_status;
 	struct trident_state *state;
 	unsigned int channel;
 	/* Update the pointers for all channels we are running. */
 	/* FIXED: read interrupt status only once */
 	irq_status = inl(TRID_REG(card, T4D_AINT_A));
 	pr_debug("cyber_address_interrupt: irq_status 0x%X\n", irq_status);
 	for (i = 0; i < NR_HW_CH; i++) {
 		channel = 31 - i;
 		if (irq_status & (1 << channel)) {
 			/* clear bit by writing a 1, zeroes are ignored */
 			outl((1 << channel), TRID_REG(card, T4D_AINT_A));
 			pr_debug("cyber_interrupt: channel %d\n", channel);
 			if ((state = card->states[i]) != NULL) {
 				trident_update_ptr(state);
 			} else {
 				printk(KERN_WARNING "cyber5050: spurious "
 				       "channel irq %d.\n", channel);
 				trident_stop_voice(card, channel);
 				trident_disable_voice_irq(card, channel);
 			}
 		}
 	}
 }
 static irqreturn_t
 trident_interrupt(int irq, void *dev_id)
 {
 	struct trident_card *card = (struct trident_card *) dev_id;
 	u32 event;
 	u32 gpio;
 	spin_lock(&card->lock);
 	event = inl(TRID_REG(card, T4D_MISCINT));
 	pr_debug("trident: trident_interrupt called, MISCINT = 0x%08x\n",
 		 event);
 	if (event & ADDRESS_IRQ) {
 		card->address_interrupt(card);
 	}
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		/* GPIO IRQ (H/W Volume Control) */
 		event = inl(TRID_REG(card, T4D_MISCINT));
 		if (event & (1 << 25)) {
 			gpio = inl(TRID_REG(card, ALI_GPIO));
 			if (!timer_pending(&card->timer))
 				ali_queue_task(card, gpio & 0x07);
 		}
 		event = inl(TRID_REG(card, T4D_MISCINT));
 		outl(event | (ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
 		     TRID_REG(card, T4D_MISCINT));
 		spin_unlock(&card->lock);
 		return IRQ_HANDLED;
 	}
 	/* manually clear interrupt status, bad hardware design, blame T^2 */
 	outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
 	     TRID_REG(card, T4D_MISCINT));
 	spin_unlock(&card->lock);
 	return IRQ_HANDLED;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is waiting */
 /* to be copied to the user's buffer.  it is filled by the dma machine and */
 /* drained by this loop. */
 static ssize_t
 trident_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	ssize_t ret = 0;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	pr_debug("trident: trident_read called, count = %zd\n", count);
 	VALIDATE_STATE(state);
 	if (dmabuf->mapped)
 		return -ENXIO;
 	if (!access_ok(VERIFY_WRITE, buffer, count))
 		return -EFAULT;
 	mutex_lock(&state->sem);
 	if (!dmabuf->ready && (ret = prog_dmabuf_record(state)))
 		goto out;
 	while (count > 0) {
 		spin_lock_irqsave(&state->card->lock, flags);
 		if (dmabuf->count > (signed) dmabuf->dmasize) {
 			/* buffer overrun, we are recovering from */
 			/* sleep_on_timeout, resync hwptr and swptr, */
 			/* make process flush the buffer */
 			dmabuf->count = dmabuf->dmasize;
 			dmabuf->swptr = dmabuf->hwptr;
 		}
 		swptr = dmabuf->swptr;
 		cnt = dmabuf->dmasize - swptr;
 		if (dmabuf->count < cnt)
 			cnt = dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			unsigned long tmo;
 			/* buffer is empty, start the dma machine and */
 			/* wait for data to be recorded */
 			start_adc(state);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
 			}
 			mutex_unlock(&state->sem);
 			/* No matter how much space left in the buffer, */
 			/* we have to wait until CSO == ESO/2 or CSO == ESO */
 			/* when address engine interrupts */
 			tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
 			tmo >>= sample_shift[dmabuf->fmt];
 			/* There are two situations when sleep_on_timeout returns, one is when
 			   the interrupt is serviced correctly and the process is waked up by
 			   ISR ON TIME. Another is when timeout is expired, which means that
 			   either interrupt is NOT serviced correctly (pending interrupt) or it
 			   is TOO LATE for the process to be scheduled to run (scheduler latency)
 			   which results in a (potential) buffer overrun. And worse, there is
 			   NOTHING we can do to prevent it. */
 			if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
 				pr_debug(KERN_ERR "trident: recording schedule timeout, "
 					 "dmasz %u fragsz %u count %i hwptr %u swptr %u\n",
 					 dmabuf->dmasize, dmabuf->fragsize, dmabuf->count,
 					 dmabuf->hwptr, dmabuf->swptr);
 				/* a buffer overrun, we delay the recovery until next time the
 				   while loop begin and we REALLY have space to record */
 			}
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out;
 			}
 			mutex_lock(&state->sem);
 			if (dmabuf->mapped) {
 				if (!ret)
 					ret = -ENXIO;
 				goto out;
 			}
 			continue;
 		}
 		if (copy_to_user(buffer, dmabuf->rawbuf + swptr, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			goto out;
 		}
 		swptr = (swptr + cnt) % dmabuf->dmasize;
 		spin_lock_irqsave(&state->card->lock, flags);
 		dmabuf->swptr = swptr;
 		dmabuf->count -= cnt;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		start_adc(state);
 	}
 out:
 	mutex_unlock(&state->sem);
 	return ret;
 }
 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
    the soundcard.  it is drained by the dma machine and filled by this loop. */
 static ssize_t
 trident_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	ssize_t ret;
 	unsigned long flags;
 	unsigned swptr;
 	int cnt;
 	unsigned int state_cnt;
 	unsigned int copy_count;
 	int lret; /* for lock_set_fmt */
 	pr_debug("trident: trident_write called, count = %zd\n", count);
 	VALIDATE_STATE(state);
 	/*
 	 *      Guard against an mmap or ioctl while writing
 	 */
 	mutex_lock(&state->sem);
 	if (dmabuf->mapped) {
 		ret = -ENXIO;
 		goto out;
 	}
 	if (!dmabuf->ready && (ret = prog_dmabuf_playback(state)))
 		goto out;
 	if (!access_ok(VERIFY_READ, buffer, count)) {
 		ret = -EFAULT;
 		goto out;
 	}
 	ret = 0;
 	while (count > 0) {
 		spin_lock_irqsave(&state->card->lock, flags);
 		if (dmabuf->count < 0) {
 			/* buffer underrun, we are recovering from */
 			/* sleep_on_timeout, resync hwptr and swptr */
 			dmabuf->count = 0;
 			dmabuf->swptr = dmabuf->hwptr;
 		}
 		swptr = dmabuf->swptr;
 		cnt = dmabuf->dmasize - swptr;
 		if (dmabuf->count + cnt > dmabuf->dmasize)
 			cnt = dmabuf->dmasize - dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			unsigned long tmo;
 			/* buffer is full, start the dma machine and */
 			/* wait for data to be played */
 			start_dac(state);
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				goto out;
 			}
 			/* No matter how much data left in the buffer, */
 			/* we have to wait until CSO == ESO/2 or CSO == ESO */
 			/* when address engine interrupts */
 			lock_set_fmt(state);
 			tmo = (dmabuf->dmasize * HZ) / (dmabuf->rate * 2);
 			tmo >>= sample_shift[dmabuf->fmt];
 			unlock_set_fmt(state);
 			mutex_unlock(&state->sem);
 			/* There are two situations when sleep_on_timeout */
 			/* returns, one is when the interrupt is serviced */
 			/* correctly and the process is waked up by ISR */
 			/* ON TIME. Another is when timeout is expired, which */
 			/* means that either interrupt is NOT serviced */
 			/* correctly (pending interrupt) or it is TOO LATE */
 			/* for the process to be scheduled to run */
 			/* (scheduler latency) which results in a (potential) */
 			/* buffer underrun. And worse, there is NOTHING we */
 			/* can do to prevent it. */
 			if (!interruptible_sleep_on_timeout(&dmabuf->wait, tmo)) {
 				pr_debug(KERN_ERR "trident: playback schedule "
 					 "timeout, dmasz %u fragsz %u count %i "
 					 "hwptr %u swptr %u\n", dmabuf->dmasize,
 					 dmabuf->fragsize, dmabuf->count,
 					 dmabuf->hwptr, dmabuf->swptr);
 				/* a buffer underrun, we delay the recovery */
 				/* until next time the while loop begin and */
 				/* we REALLY have data to play */
 			}
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				goto out_nolock;
 			}
 			mutex_lock(&state->sem);
 			if (dmabuf->mapped) {
 				if (!ret)
 					ret = -ENXIO;
 				goto out;
 			}
 			continue;
 		}
 		if ((lret = lock_set_fmt(state)) < 0) {
 			ret = lret;
 			goto out;
 		}
 		if (state->chans_num == 6) {
 			copy_count = 0;
 			state_cnt = 0;
 			if (ali_write_5_1(state, buffer, cnt, &copy_count,
 					  &state_cnt) == -EFAULT) {
 				if (state_cnt) {
 					swptr = (swptr + state_cnt) % dmabuf->dmasize;
 					spin_lock_irqsave(&state->card->lock, flags);
 					dmabuf->swptr = swptr;
 					dmabuf->count += state_cnt;
 					dmabuf->endcleared = 0;
 					spin_unlock_irqrestore(&state->card->lock, flags);
 				}
 				ret += copy_count;
 				if (!ret)
 					ret = -EFAULT;
 				unlock_set_fmt(state);
 				goto out;
 			}
 		} else {
 			if (copy_from_user(dmabuf->rawbuf + swptr,
 					   buffer, cnt)) {
 				if (!ret)
 					ret = -EFAULT;
 				unlock_set_fmt(state);
 				goto out;
 			}
 			state_cnt = cnt;
 		}
 		unlock_set_fmt(state);
 		swptr = (swptr + state_cnt) % dmabuf->dmasize;
 		spin_lock_irqsave(&state->card->lock, flags);
 		dmabuf->swptr = swptr;
 		dmabuf->count += state_cnt;
 		dmabuf->endcleared = 0;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		start_dac(state);
 	}
 out:
 	mutex_unlock(&state->sem);
 out_nolock:
 	return ret;
 }
 /* No kernel lock - we have our own spinlock */
 static unsigned int
 trident_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	unsigned int mask = 0;
 	VALIDATE_STATE(state);
 	/*
 	 *      Guard against a parallel poll and write causing multiple
 	 *      prog_dmabuf events
 	 */
 	mutex_lock(&state->sem);
 	if (file->f_mode & FMODE_WRITE) {
 		if (!dmabuf->ready && prog_dmabuf_playback(state)) {
 			mutex_unlock(&state->sem);
 			return 0;
 		}
 		poll_wait(file, &dmabuf->wait, wait);
 	}
 	if (file->f_mode & FMODE_READ) {
 		if (!dmabuf->ready && prog_dmabuf_record(state)) {
 			mutex_unlock(&state->sem);
 			return 0;
 		}
 		poll_wait(file, &dmabuf->wait, wait);
 	}
 	mutex_unlock(&state->sem);
 	spin_lock_irqsave(&state->card->lock, flags);
 	trident_update_ptr(state);
 	if (file->f_mode & FMODE_READ) {
 		if (dmabuf->count >= (signed) dmabuf->fragsize)
 			mask |= POLLIN | POLLRDNORM;
 	}
 	if (file->f_mode & FMODE_WRITE) {
 		if (dmabuf->mapped) {
 			if (dmabuf->count >= (signed) dmabuf->fragsize)
 				mask |= POLLOUT | POLLWRNORM;
 		} else {
 			if ((signed) dmabuf->dmasize >= dmabuf->count +
 			    (signed) dmabuf->fragsize)
 				mask |= POLLOUT | POLLWRNORM;
 		}
 	}
 	spin_unlock_irqrestore(&state->card->lock, flags);
 	return mask;
 }
 static int
 trident_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	int ret = -EINVAL;
 	unsigned long size;
 	VALIDATE_STATE(state);
 	/*
 	 *      Lock against poll read write or mmap creating buffers. Also lock
 	 *      a read or write against an mmap.
 	 */
 	mutex_lock(&state->sem);
 	if (vma->vm_flags & VM_WRITE) {
 		if ((ret = prog_dmabuf_playback(state)) != 0)
 			goto out;
 	} else if (vma->vm_flags & VM_READ) {
 		if ((ret = prog_dmabuf_record(state)) != 0)
 			goto out;
 	} else
 		goto out;
 	ret = -EINVAL;
 	if (vma->vm_pgoff != 0)
 		goto out;
 	size = vma->vm_end - vma->vm_start;
 	if (size > (PAGE_SIZE << dmabuf->buforder))
 		goto out;
 	ret = -EAGAIN;
 	if (remap_pfn_range(vma, vma->vm_start,
 			     virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
 			     size, vma->vm_page_prot))
 		goto out;
 	dmabuf->mapped = 1;
 	ret = 0;
 out:
 	mutex_unlock(&state->sem);
 	return ret;
 }
 static int
 trident_ioctl(struct inode *inode, struct file *file,
 	      unsigned int cmd, unsigned long arg)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct dmabuf *dmabuf = &state->dmabuf;
 	unsigned long flags;
 	audio_buf_info abinfo;
 	count_info cinfo;
 	int val, mapped, ret = 0;
 	struct trident_card *card = state->card;
 	void __user *argp = (void __user *)arg;
 	int __user *p = argp;
 	VALIDATE_STATE(state);
 	mapped = ((file->f_mode & (FMODE_WRITE | FMODE_READ)) && dmabuf->mapped);
 	pr_debug("trident: trident_ioctl, command = %2d, arg = 0x%08x\n",
 		 _IOC_NR(cmd), arg ? *p : 0);
 	switch (cmd) {
 	case OSS_GETVERSION:
 		ret = put_user(SOUND_VERSION, p);
 		break;
 	case SNDCTL_DSP_RESET:
 		/* FIXME: spin_lock ? */
 		if (file->f_mode & FMODE_WRITE) {
 			stop_dac(state);
 			synchronize_irq(card->irq);
 			dmabuf->ready = 0;
 			dmabuf->swptr = dmabuf->hwptr = 0;
 			dmabuf->count = dmabuf->total_bytes = 0;
 		}
 		if (file->f_mode & FMODE_READ) {
 			stop_adc(state);
 			synchronize_irq(card->irq);
 			dmabuf->ready = 0;
 			dmabuf->swptr = dmabuf->hwptr = 0;
 			dmabuf->count = dmabuf->total_bytes = 0;
 		}
 		break;
 	case SNDCTL_DSP_SYNC:
 		if (file->f_mode & FMODE_WRITE)
 			ret = drain_dac(state, file->f_flags & O_NONBLOCK);
 		break;
 	case SNDCTL_DSP_SPEED:	/* set smaple rate */
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if (val >= 0) {
 			if (file->f_mode & FMODE_WRITE) {
 				stop_dac(state);
 				dmabuf->ready = 0;
 				spin_lock_irqsave(&state->card->lock, flags);
 				trident_set_dac_rate(state, val);
 				spin_unlock_irqrestore(&state->card->lock, flags);
 			}
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(state);
 				dmabuf->ready = 0;
 				spin_lock_irqsave(&state->card->lock, flags);
 				trident_set_adc_rate(state, val);
 				spin_unlock_irqrestore(&state->card->lock, flags);
 			}
 		}
 		ret = put_user(dmabuf->rate, p);
 		break;
 	case SNDCTL_DSP_STEREO:	/* set stereo or mono channel */
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if ((ret = lock_set_fmt(state)) < 0)
 			return ret;
 		if (file->f_mode & FMODE_WRITE) {
 			stop_dac(state);
 			dmabuf->ready = 0;
 			if (val)
 				dmabuf->fmt |= TRIDENT_FMT_STEREO;
 			else
 				dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
 		}
 		if (file->f_mode & FMODE_READ) {
 			stop_adc(state);
 			dmabuf->ready = 0;
 			if (val)
 				dmabuf->fmt |= TRIDENT_FMT_STEREO;
 			else
 				dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
 		}
 		unlock_set_fmt(state);
 		break;
 	case SNDCTL_DSP_GETBLKSIZE:
 		if (file->f_mode & FMODE_WRITE) {
 			if ((val = prog_dmabuf_playback(state)))
 				ret = val;
 			else
 				ret = put_user(dmabuf->fragsize, p);
 			break;
 		}
 		if (file->f_mode & FMODE_READ) {
 			if ((val = prog_dmabuf_record(state)))
 				ret = val;
 			else
 				ret = put_user(dmabuf->fragsize, p);
 			break;
 		}
 		/* neither READ nor WRITE? is this even possible? */
 		ret = -EINVAL;
 		break;
 	case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format */
 		ret = put_user(AFMT_S16_LE | AFMT_U16_LE | AFMT_S8 |
 			       AFMT_U8, p);
 		break;
 	case SNDCTL_DSP_SETFMT:	/* Select sample format */
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if ((ret = lock_set_fmt(state)) < 0)
 			return ret;
 		if (val != AFMT_QUERY) {
 			if (file->f_mode & FMODE_WRITE) {
 				stop_dac(state);
 				dmabuf->ready = 0;
 				if (val == AFMT_S16_LE)
 					dmabuf->fmt |= TRIDENT_FMT_16BIT;
 				else
 					dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
 			}
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(state);
 				dmabuf->ready = 0;
 				if (val == AFMT_S16_LE)
 					dmabuf->fmt |= TRIDENT_FMT_16BIT;
 				else
 					dmabuf->fmt &= ~TRIDENT_FMT_16BIT;
 			}
 		}
 		unlock_set_fmt(state);
 		ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
 			       AFMT_U8, p);
 		break;
 	case SNDCTL_DSP_CHANNELS:
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if (val != 0) {
 			if ((ret = lock_set_fmt(state)) < 0)
 				return ret;
 			if (file->f_mode & FMODE_WRITE) {
 				stop_dac(state);
 				dmabuf->ready = 0;
 				//prevent from memory leak
 				if ((state->chans_num > 2) && (state->chans_num != val)) {
 					ali_free_other_states_resources(state);
 					state->chans_num = 1;
 				}
 				if (val >= 2) {
 					dmabuf->fmt |= TRIDENT_FMT_STEREO;
 					if ((val == 6) && (state->card->pci_id == PCI_DEVICE_ID_ALI_5451)) {
 						if (card->rec_channel_use_count > 0) {
 							printk(KERN_ERR "trident: Record is "
 							       "working on the card!\n");
 							ret = -EBUSY;
 							unlock_set_fmt(state);
 							break;
 						}
 						ret = ali_setup_multi_channels(state->card, 6);
 						if (ret < 0) {
 							unlock_set_fmt(state);
 							break;
 						}
 						mutex_lock(&state->card->open_mutex);
 						ret = ali_allocate_other_states_resources(state, 6);
 						if (ret < 0) {
 							mutex_unlock(&state->card->open_mutex);
 							unlock_set_fmt(state);
 							break;
 						}
 						state->card->multi_channel_use_count++;
 						mutex_unlock(&state->card->open_mutex);
 					} else
 						val = 2;	/*yield to 2-channels */
 				} else
 					dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
 				state->chans_num = val;
 			}
 			if (file->f_mode & FMODE_READ) {
 				stop_adc(state);
 				dmabuf->ready = 0;
 				if (val >= 2) {
 					if (!((file->f_mode & FMODE_WRITE) &&
 					      (val == 6)))
 						val = 2;
 					dmabuf->fmt |= TRIDENT_FMT_STEREO;
 				} else
 					dmabuf->fmt &= ~TRIDENT_FMT_STEREO;
 				state->chans_num = val;
 			}
 			unlock_set_fmt(state);
 		}
 		ret = put_user(val, p);
 		break;
 	case SNDCTL_DSP_POST:
 		/* Cause the working fragment to be output */
 		break;
 	case SNDCTL_DSP_SUBDIVIDE:
 		if (dmabuf->subdivision) {
 			ret = -EINVAL;
 			break;
 		}
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if (val != 1 && val != 2 && val != 4) {
 			ret = -EINVAL;
 			break;
 		}
 		dmabuf->subdivision = val;
 		break;
 	case SNDCTL_DSP_SETFRAGMENT:
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		dmabuf->ossfragshift = val & 0xffff;
 		dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
 		if (dmabuf->ossfragshift < 4)
 			dmabuf->ossfragshift = 4;
 		if (dmabuf->ossfragshift > 15)
 			dmabuf->ossfragshift = 15;
 		if (dmabuf->ossmaxfrags < 4)
 			dmabuf->ossmaxfrags = 4;
 		break;
 	case SNDCTL_DSP_GETOSPACE:
 		if (!(file->f_mode & FMODE_WRITE)) {
 			ret = -EINVAL;
 			break;
 		}
 		if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
 			ret = val;
 			break;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		trident_update_ptr(state);
 		abinfo.fragsize = dmabuf->fragsize;
 		abinfo.bytes = dmabuf->dmasize - dmabuf->count;
 		abinfo.fragstotal = dmabuf->numfrag;
 		abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
 			-EFAULT : 0;
 		break;
 	case SNDCTL_DSP_GETISPACE:
 		if (!(file->f_mode & FMODE_READ)) {
 			ret = -EINVAL;
 			break;
 		}
 		if (!dmabuf->ready && (val = prog_dmabuf_record(state)) != 0) {
 			ret = val;
 			break;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		trident_update_ptr(state);
 		abinfo.fragsize = dmabuf->fragsize;
 		abinfo.bytes = dmabuf->count;
 		abinfo.fragstotal = dmabuf->numfrag;
 		abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		ret = copy_to_user(argp, &abinfo, sizeof (abinfo)) ?
 			-EFAULT : 0;
 		break;
 	case SNDCTL_DSP_NONBLOCK:
 		file->f_flags |= O_NONBLOCK;
 		break;
 	case SNDCTL_DSP_GETCAPS:
 		ret = put_user(DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
 			       DSP_CAP_MMAP | DSP_CAP_BIND, p);
 		break;
 	case SNDCTL_DSP_GETTRIGGER:
 		val = 0;
 		if ((file->f_mode & FMODE_READ) && dmabuf->enable)
 			val |= PCM_ENABLE_INPUT;
 		if ((file->f_mode & FMODE_WRITE) && dmabuf->enable)
 			val |= PCM_ENABLE_OUTPUT;
 		ret = put_user(val, p);
 		break;
 	case SNDCTL_DSP_SETTRIGGER:
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if (file->f_mode & FMODE_READ) {
 			if (val & PCM_ENABLE_INPUT) {
 				if (!dmabuf->ready &&
 				    (ret = prog_dmabuf_record(state)))
 					break;
 				start_adc(state);
 			} else
 				stop_adc(state);
 		}
 		if (file->f_mode & FMODE_WRITE) {
 			if (val & PCM_ENABLE_OUTPUT) {
 				if (!dmabuf->ready &&
 				    (ret = prog_dmabuf_playback(state)))
 					break;
 				start_dac(state);
 			} else
 				stop_dac(state);
 		}
 		break;
 	case SNDCTL_DSP_GETIPTR:
 		if (!(file->f_mode & FMODE_READ)) {
 			ret = -EINVAL;
 			break;
 		}
 		if (!dmabuf->ready && (val = prog_dmabuf_record(state))
 		    != 0) {
 			ret = val;
 			break;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		trident_update_ptr(state);
 		cinfo.bytes = dmabuf->total_bytes;
 		cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
 		cinfo.ptr = dmabuf->hwptr;
 		if (dmabuf->mapped)
 			dmabuf->count &= dmabuf->fragsize - 1;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
 			-EFAULT : 0;
 		break;
 	case SNDCTL_DSP_GETOPTR:
 		if (!(file->f_mode & FMODE_WRITE)) {
 			ret = -EINVAL;
 			break;
 		}
 		if (!dmabuf->ready && (val = prog_dmabuf_playback(state))
 		    != 0) {
 			ret = val;
 			break;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		trident_update_ptr(state);
 		cinfo.bytes = dmabuf->total_bytes;
 		cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
 		cinfo.ptr = dmabuf->hwptr;
 		if (dmabuf->mapped)
 			dmabuf->count &= dmabuf->fragsize - 1;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		ret = copy_to_user(argp, &cinfo, sizeof (cinfo)) ?
 			-EFAULT : 0;
 		break;
 	case SNDCTL_DSP_SETDUPLEX:
 		ret = -EINVAL;
 		break;
 	case SNDCTL_DSP_GETODELAY:
 		if (!(file->f_mode & FMODE_WRITE)) {
 			ret = -EINVAL;
 			break;
 		}
 		if (!dmabuf->ready && (val = prog_dmabuf_playback(state)) != 0) {
 			ret = val;
 			break;
 		}
 		spin_lock_irqsave(&state->card->lock, flags);
 		trident_update_ptr(state);
 		val = dmabuf->count;
 		spin_unlock_irqrestore(&state->card->lock, flags);
 		ret = put_user(val, p);
 		break;
 	case SOUND_PCM_READ_RATE:
 		ret = put_user(dmabuf->rate, p);
 		break;
 	case SOUND_PCM_READ_CHANNELS:
 		ret = put_user((dmabuf->fmt & TRIDENT_FMT_STEREO) ? 2 : 1,
 			       p);
 		break;
 	case SOUND_PCM_READ_BITS:
 		ret = put_user((dmabuf->fmt & TRIDENT_FMT_16BIT) ? AFMT_S16_LE :
 			       AFMT_U8, p);
 		break;
 	case SNDCTL_DSP_GETCHANNELMASK:
 		ret = put_user(DSP_BIND_FRONT | DSP_BIND_SURR |
 			       DSP_BIND_CENTER_LFE,  p);
 		break;
 	case SNDCTL_DSP_BIND_CHANNEL:
 		if (state->card->pci_id != PCI_DEVICE_ID_SI_7018) {
 			ret = -EINVAL;
 			break;
 		}
 		if (get_user(val, p)) {
 			ret = -EFAULT;
 			break;
 		}
 		if (val == DSP_BIND_QUERY) {
 			val = dmabuf->channel->attribute | 0x3c00;
 			val = attr2mask[val >> 8];
 		} else {
 			dmabuf->ready = 0;
 			if (file->f_mode & FMODE_READ)
 				dmabuf->channel->attribute = (CHANNEL_REC |
 							      SRC_ENABLE);
 			if (file->f_mode & FMODE_WRITE)
 				dmabuf->channel->attribute = (CHANNEL_SPC_PB |
 							      SRC_ENABLE);
 			dmabuf->channel->attribute |= mask2attr[ffs(val)];
 		}
 		ret = put_user(val, p);
 		break;
 	case SNDCTL_DSP_MAPINBUF:
 	case SNDCTL_DSP_MAPOUTBUF:
 	case SNDCTL_DSP_SETSYNCRO:
 	case SOUND_PCM_WRITE_FILTER:
 	case SOUND_PCM_READ_FILTER:
 	default:
 		ret = -EINVAL;
 		break;
 	}
 	return ret;
 }
 static int
 trident_open(struct inode *inode, struct file *file)
 {
 	int i = 0;
 	int minor = iminor(inode);
 	struct trident_card *card = devs;
 	struct trident_state *state = NULL;
 	struct dmabuf *dmabuf = NULL;
 	/* Added by Matt Wu 01-05-2001 */
 	/* TODO: there's some redundacy here wrt the check below */
 	/* for multi_use_count > 0. Should we return -EBUSY or find */
 	/* a different card? for now, don't break current behaviour */
 	/* -- mulix */
 	if (file->f_mode & FMODE_READ) {
 		if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 			if (card->multi_channel_use_count > 0)
 				return -EBUSY;
 		}
 	}
 	/* find an available virtual channel (instance of /dev/dsp) */
 	while (card != NULL) {
 		mutex_lock(&card->open_mutex);
 		if (file->f_mode & FMODE_READ) {
 			/* Skip opens on cards that are in 6 channel mode */
 			if (card->multi_channel_use_count > 0) {
 				mutex_unlock(&card->open_mutex);
 				card = card->next;
 				continue;
 			}
 		}
 		for (i = 0; i < NR_HW_CH; i++) {
 			if (card->states[i] == NULL) {
 				state = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
 				if (state == NULL) {
 					mutex_unlock(&card->open_mutex);
 					return -ENOMEM;
 				}
 				memset(state, 0, sizeof(*state));
 				mutex_init(&state->sem);
 				dmabuf = &state->dmabuf;
 				goto found_virt;
 			}
 		}
 		mutex_unlock(&card->open_mutex);
 		card = card->next;
 	}
 	/* no more virtual channel avaiable */
 	if (!state) {
 		return -ENODEV;
 	}
       found_virt:
 	/* found a free virtual channel, allocate hardware channels */
 	if (file->f_mode & FMODE_READ)
 		dmabuf->channel = card->alloc_rec_pcm_channel(card);
 	else
 		dmabuf->channel = card->alloc_pcm_channel(card);
 	if (dmabuf->channel == NULL) {
 		kfree(card->states[i]);
 		card->states[i] = NULL;
 		return -ENODEV;
 	}
 	/* initialize the virtual channel */
 	state->virt = i;
 	state->card = card;
 	state->magic = TRIDENT_STATE_MAGIC;
 	init_waitqueue_head(&dmabuf->wait);
 	file->private_data = state;
 	/* set default sample format. According to OSS Programmer's */
 	/* Guide  /dev/dsp should be default to unsigned 8-bits, mono, */
 	/* with sample rate 8kHz and /dev/dspW will accept 16-bits sample */
 	if (file->f_mode & FMODE_WRITE) {
 		dmabuf->fmt &= ~TRIDENT_FMT_MASK;
 		if ((minor & 0x0f) == SND_DEV_DSP16)
 			dmabuf->fmt |= TRIDENT_FMT_16BIT;
 		dmabuf->ossfragshift = 0;
 		dmabuf->ossmaxfrags = 0;
 		dmabuf->subdivision = 0;
 		if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
 			/* set default channel attribute to normal playback */
 			dmabuf->channel->attribute = CHANNEL_PB;
 		}
 		trident_set_dac_rate(state, 8000);
 	}
 	if (file->f_mode & FMODE_READ) {
 		/* FIXME: Trident 4d can only record in signed 16-bits stereo, */
 		/* 48kHz sample, to be dealed with in trident_set_adc_rate() ?? */
 		dmabuf->fmt &= ~TRIDENT_FMT_MASK;
 		if ((minor & 0x0f) == SND_DEV_DSP16)
 			dmabuf->fmt |= TRIDENT_FMT_16BIT;
 		dmabuf->ossfragshift = 0;
 		dmabuf->ossmaxfrags = 0;
 		dmabuf->subdivision = 0;
 		if (card->pci_id == PCI_DEVICE_ID_SI_7018) {
 			/* set default channel attribute to 0x8a80, record from
 			   PCM L/R FIFO and mono = (left + right + 1)/2 */
 			dmabuf->channel->attribute = (CHANNEL_REC | PCM_LR |
 						      MONO_MIX);
 		}
 		trident_set_adc_rate(state, 8000);
 		/* Added by Matt Wu 01-05-2001 */
 		if (card->pci_id == PCI_DEVICE_ID_ALI_5451)
 			card->rec_channel_use_count++;
 	}
 	state->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
 	mutex_unlock(&card->open_mutex);
 	pr_debug("trident: open virtual channel %d, hard channel %d\n",
 		 state->virt, dmabuf->channel->num);
 	return nonseekable_open(inode, file);
 }
 static int
 trident_release(struct inode *inode, struct file *file)
 {
 	struct trident_state *state = (struct trident_state *)file->private_data;
 	struct trident_card *card;
 	struct dmabuf *dmabuf;
 	VALIDATE_STATE(state);
 	card = state->card;
 	dmabuf = &state->dmabuf;
 	if (file->f_mode & FMODE_WRITE) {
 		trident_clear_tail(state);
 		drain_dac(state, file->f_flags & O_NONBLOCK);
 	}
 	pr_debug("trident: closing virtual channel %d, hard channel %d\n",
 		 state->virt, dmabuf->channel->num);
 	/* stop DMA state machine and free DMA buffers/channels */
 	mutex_lock(&card->open_mutex);
 	if (file->f_mode & FMODE_WRITE) {
 		stop_dac(state);
 		dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
 		state->card->free_pcm_channel(state->card, dmabuf->channel->num);
 		/* Added by Matt Wu */
 		if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 			if (state->chans_num > 2) {
 				if (card->multi_channel_use_count-- < 0)
 					card->multi_channel_use_count = 0;
 				if (card->multi_channel_use_count == 0)
 					ali_close_multi_channels();
 				ali_free_other_states_resources(state);
 			}
 		}
 	}
 	if (file->f_mode & FMODE_READ) {
 		stop_adc(state);
 		dealloc_dmabuf(&state->dmabuf, state->card->pci_dev);
 		state->card->free_pcm_channel(state->card, dmabuf->channel->num);
 		/* Added by Matt Wu */
 		if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 			if (card->rec_channel_use_count-- < 0)
 				card->rec_channel_use_count = 0;
 		}
 	}
 	card->states[state->virt] = NULL;
 	kfree(state);
 	/* we're covered by the open_mutex */
 	mutex_unlock(&card->open_mutex);
 	return 0;
 }
 static /*const */ struct file_operations trident_audio_fops = {
 	.owner = THIS_MODULE,
 	.llseek = no_llseek,
 	.read = trident_read,
 	.write = trident_write,
 	.poll = trident_poll,
 	.ioctl = trident_ioctl,
 	.mmap = trident_mmap,
 	.open = trident_open,
 	.release = trident_release,
 };
 /* trident specific AC97 functions */
 /* Write AC97 codec registers */
 static void
 trident_ac97_set(struct ac97_codec *codec, u8 reg, u16 val)
 {
 	struct trident_card *card = (struct trident_card *)codec->private_data;
 	unsigned int address, mask, busy;
 	unsigned short count = 0xffff;
 	unsigned long flags;
 	u32 data;
 	data = ((u32) val) << 16;
 	switch (card->pci_id) {
 	default:
 	case PCI_DEVICE_ID_SI_7018:
 		address = SI_AC97_WRITE;
 		mask = SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY;
 		if (codec->id)
 			mask |= SI_AC97_SECONDARY;
 		busy = SI_AC97_BUSY_WRITE;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 		address = DX_ACR0_AC97_W;
 		mask = busy = DX_AC97_BUSY_WRITE;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		address = NX_ACR1_AC97_W;
 		mask = NX_AC97_BUSY_WRITE;
 		if (codec->id)
 			mask |= NX_AC97_WRITE_SECONDARY;
 		busy = NX_AC97_BUSY_WRITE;
 		break;
 	case PCI_DEVICE_ID_INTERG_5050:
 		address = SI_AC97_WRITE;
 		mask = busy = SI_AC97_BUSY_WRITE;
 		if (codec->id)
 			mask |= SI_AC97_SECONDARY;
 		break;
 	}
 	spin_lock_irqsave(&card->lock, flags);
 	do {
 		if ((inw(TRID_REG(card, address)) & busy) == 0)
 			break;
 	} while (count--);
 	data |= (mask | (reg & AC97_REG_ADDR));
 	if (count == 0) {
 		printk(KERN_ERR "trident: AC97 CODEC write timed out.\n");
 		spin_unlock_irqrestore(&card->lock, flags);
 		return;
 	}
 	outl(data, TRID_REG(card, address));
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 /* Read AC97 codec registers */
 static u16
 trident_ac97_get(struct ac97_codec *codec, u8 reg)
 {
 	struct trident_card *card = (struct trident_card *)codec->private_data;
 	unsigned int address, mask, busy;
 	unsigned short count = 0xffff;
 	unsigned long flags;
 	u32 data;
 	switch (card->pci_id) {
 	default:
 	case PCI_DEVICE_ID_SI_7018:
 		address = SI_AC97_READ;
 		mask = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY;
 		if (codec->id)
 			mask |= SI_AC97_SECONDARY;
 		busy = SI_AC97_BUSY_READ;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 		address = DX_ACR1_AC97_R;
 		mask = busy = DX_AC97_BUSY_READ;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		if (codec->id)
 			address = NX_ACR3_AC97_R_SECONDARY;
 		else
 			address = NX_ACR2_AC97_R_PRIMARY;
 		mask = NX_AC97_BUSY_READ;
 		busy = NX_AC97_BUSY_READ | NX_AC97_BUSY_DATA;
 		break;
 	case PCI_DEVICE_ID_INTERG_5050:
 		address = SI_AC97_READ;
 		mask = busy = SI_AC97_BUSY_READ;
 		if (codec->id)
 			mask |= SI_AC97_SECONDARY;
 		break;
 	}
 	data = (mask | (reg & AC97_REG_ADDR));
 	spin_lock_irqsave(&card->lock, flags);
 	outl(data, TRID_REG(card, address));
 	do {
 		data = inl(TRID_REG(card, address));
 		if ((data & busy) == 0)
 			break;
 	} while (count--);
 	spin_unlock_irqrestore(&card->lock, flags);
 	if (count == 0) {
 		printk(KERN_ERR "trident: AC97 CODEC read timed out.\n");
 		data = 0;
 	}
 	return ((u16) (data >> 16));
 }
 /* rewrite ac97 read and write mixer register by hulei for ALI*/
 static int
 acquirecodecaccess(struct trident_card *card)
 {
 	u16 wsemamask = 0x6000;	/* bit 14..13 */
 	u16 wsemabits;
 	u16 wcontrol;
 	int block = 0;
 	int ncount = 25;
 	while (1) {
 		wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
 		wsemabits = wcontrol & wsemamask;
 		if (wsemabits == 0x4000)
 			return 1;	/* 0x4000 is audio ,then success */
 		if (ncount-- < 0)
 			break;
 		if (wsemabits == 0) {
 		      unlock:
 			outl(((u32) (wcontrol & 0x1eff) | 0x00004000),
 			     TRID_REG(card, ALI_AC97_WRITE));
 			continue;
 		}
 		udelay(20);
 	}
 	if (!block) {
 		pr_debug("accesscodecsemaphore: try unlock\n");
 		block = 1;
 		goto unlock;
 	}
 	return 0;
 }
 static void
 releasecodecaccess(struct trident_card *card)
 {
 	unsigned long wcontrol;
 	wcontrol = inl(TRID_REG(card, ALI_AC97_WRITE));
 	outl((wcontrol & 0xffff1eff), TRID_REG(card, ALI_AC97_WRITE));
 }
 static int
 waitforstimertick(struct trident_card *card)
 {
 	unsigned long chk1, chk2;
 	unsigned int wcount = 0xffff;
 	chk1 = inl(TRID_REG(card, ALI_STIMER));
 	while (1) {
 		chk2 = inl(TRID_REG(card, ALI_STIMER));
 		if ((wcount > 0) && chk1 != chk2)
 			return 1;
 		if (wcount <= 0)
 			break;
 		udelay(50);
 	}
 	return 0;
 }
 /* Read AC97 codec registers for ALi*/
 static u16
 ali_ac97_get(struct trident_card *card, int secondary, u8 reg)
 {
 	unsigned int address, mask;
 	unsigned int ncount;
 	unsigned long aud_reg;
 	u32 data;
 	u16 wcontrol;
 	unsigned long flags;
 	if (!card)
 		BUG();
 	address = ALI_AC97_READ;
 	if (card->revision == ALI_5451_V02) {
 		address = ALI_AC97_WRITE;
 	}
 	mask = ALI_AC97_READ_ACTION | ALI_AC97_AUDIO_BUSY;
 	if (secondary)
 		mask |= ALI_AC97_SECONDARY;
 	spin_lock_irqsave(&card->lock, flags);
 	if (!acquirecodecaccess(card))
 		printk(KERN_ERR "access codec fail\n");
 	wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
 	wcontrol &= 0xfe00;
 	wcontrol |= (0x8000 | reg);
 	outw(wcontrol, TRID_REG(card, ALI_AC97_WRITE));
 	data = (mask | (reg & AC97_REG_ADDR));
 	if (!waitforstimertick(card)) {
 		printk(KERN_ERR "ali_ac97_read: BIT_CLOCK is dead\n");
 		goto releasecodec;
 	}
 	udelay(20);
 	ncount = 10;
 	while (1) {
 		if ((inw(TRID_REG(card, ALI_AC97_WRITE)) & ALI_AC97_BUSY_READ)
 		    != 0)
 			break;
 		if (ncount <= 0)
 			break;
 		if (ncount-- == 1) {
 			pr_debug("ali_ac97_read :try clear busy flag\n");
 			aud_reg = inl(TRID_REG(card, ALI_AC97_WRITE));
 			outl((aud_reg & 0xffff7fff),
 			     TRID_REG(card, ALI_AC97_WRITE));
 		}
 		udelay(10);
 	}
 	data = inl(TRID_REG(card, address));
 	spin_unlock_irqrestore(&card->lock, flags);
 	return ((u16) (data >> 16));
       releasecodec:
 	releasecodecaccess(card);
 	spin_unlock_irqrestore(&card->lock, flags);
 	printk(KERN_ERR "ali_ac97_read: AC97 CODEC read timed out.\n");
 	return 0;
 }
 /* Write AC97 codec registers for hulei*/
 static void
 ali_ac97_set(struct trident_card *card, int secondary, u8 reg, u16 val)
 {
 	unsigned int address, mask;
 	unsigned int ncount;
 	u32 data;
 	u16 wcontrol;
 	unsigned long flags;
 	data = ((u32) val) << 16;
 	if (!card)
 		BUG();
 	address = ALI_AC97_WRITE;
 	mask = ALI_AC97_WRITE_ACTION | ALI_AC97_AUDIO_BUSY;
 	if (secondary)
 		mask |= ALI_AC97_SECONDARY;
 	if (card->revision == ALI_5451_V02)
 		mask |= ALI_AC97_WRITE_MIXER_REGISTER;
 	spin_lock_irqsave(&card->lock, flags);
 	if (!acquirecodecaccess(card))
 		printk(KERN_ERR "ali_ac97_write: access codec fail\n");
 	wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
 	wcontrol &= 0xff00;
 	wcontrol |= (0x8100 | reg); /* bit 8=1: (ali1535 )reserved/ */
 	                            /* ali1535+ write */
 	outl((data | wcontrol), TRID_REG(card, ALI_AC97_WRITE));
 	if (!waitforstimertick(card)) {
 		printk(KERN_ERR "BIT_CLOCK is dead\n");
 		goto releasecodec;
 	}
 	ncount = 10;
 	while (1) {
 		wcontrol = inw(TRID_REG(card, ALI_AC97_WRITE));
 		if (!(wcontrol & 0x8000))
 			break;
 		if (ncount <= 0)
 			break;
 		if (ncount-- == 1) {
 			pr_debug("ali_ac97_set :try clear busy flag!!\n");
 			outw(wcontrol & 0x7fff,
 			     TRID_REG(card, ALI_AC97_WRITE));
 		}
 		udelay(10);
 	}
       releasecodec:
 	releasecodecaccess(card);
 	spin_unlock_irqrestore(&card->lock, flags);
 	return;
 }
 static void
 ali_enable_special_channel(struct trident_state *stat)
 {
 	struct trident_card *card = stat->card;
 	unsigned long s_channels;
 	s_channels = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
 	s_channels |= (1 << stat->dmabuf.channel->num);
 	outl(s_channels, TRID_REG(card, ALI_GLOBAL_CONTROL));
 }
 static u16
 ali_ac97_read(struct ac97_codec *codec, u8 reg)
 {
 	int id;
 	u16 data;
 	struct trident_card *card = NULL;
 	/* Added by Matt Wu */
 	if (!codec)
 		BUG();
 	card = (struct trident_card *) codec->private_data;
 	if (!card->mixer_regs_ready)
 		return ali_ac97_get(card, codec->id, reg);
 	/*
 	 *      FIXME: need to stop this caching some registers
 	 */
 	if (codec->id)
 		id = 1;
 	else
 		id = 0;
 	data = card->mixer_regs[reg / 2][id];
 	return data;
 }
 static void
 ali_ac97_write(struct ac97_codec *codec, u8 reg, u16 val)
 {
 	int id;
 	struct trident_card *card;
 	/*  Added by Matt Wu */
 	if (!codec)
 		BUG();
 	card = (struct trident_card *) codec->private_data;
 	if (!card->mixer_regs_ready) {
 		ali_ac97_set(card, codec->id, reg, val);
 		return;
 	}
 	if (codec->id)
 		id = 1;
 	else
 		id = 0;
 	card->mixer_regs[reg / 2][id] = val;
 	ali_ac97_set(card, codec->id, reg, val);
 }
 /*
 flag:	ALI_SPDIF_OUT_TO_SPDIF_OUT
 	ALI_PCM_TO_SPDIF_OUT
 */
 static void
 ali_setup_spdif_out(struct trident_card *card, int flag)
 {
 	unsigned long spdif;
 	unsigned char ch;
 	char temp;
 	struct pci_dev *pci_dev = NULL;
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
 				 pci_dev);
 	if (pci_dev == NULL)
 		return;
 	pci_read_config_byte(pci_dev, 0x61, &temp);
 	temp |= 0x40;
 	pci_write_config_byte(pci_dev, 0x61, temp);
 	pci_read_config_byte(pci_dev, 0x7d, &temp);
 	temp |= 0x01;
 	pci_write_config_byte(pci_dev, 0x7d, temp);
 	pci_read_config_byte(pci_dev, 0x7e, &temp);
 	temp &= (~0x20);
 	temp |= 0x10;
 	pci_write_config_byte(pci_dev, 0x7e, temp);
 	pci_dev_put(pci_dev);
 	ch = inb(TRID_REG(card, ALI_SCTRL));
 	outb(ch | ALI_SPDIF_OUT_ENABLE, TRID_REG(card, ALI_SCTRL));
 	ch = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 	outb(ch & ALI_SPDIF_OUT_CH_STATUS, TRID_REG(card, ALI_SPDIF_CTRL));
 	if (flag & ALI_SPDIF_OUT_TO_SPDIF_OUT) {
 		spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
 		spdif |= ALI_SPDIF_OUT_CH_ENABLE;
 		spdif &= ALI_SPDIF_OUT_SEL_SPDIF;
 		outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
 		spdif = inw(TRID_REG(card, ALI_SPDIF_CS));
 		if (flag & ALI_SPDIF_OUT_NON_PCM)
 			spdif |= 0x0002;
 		else
 			spdif &= (~0x0002);
 		outw(spdif, TRID_REG(card, ALI_SPDIF_CS));
 	} else {
 		spdif = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
 		spdif |= ALI_SPDIF_OUT_SEL_PCM;
 		outw(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
 	}
 }
 static void
 ali_disable_special_channel(struct trident_card *card, int ch)
 {
 	unsigned long sc;
 	sc = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
 	sc &= ~(1 << ch);
 	outl(sc, TRID_REG(card, ALI_GLOBAL_CONTROL));
 }
 static void
 ali_disable_spdif_in(struct trident_card *card)
 {
 	unsigned long spdif;
 	spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
 	spdif &= (~ALI_SPDIF_IN_SUPPORT);
 	outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
 	ali_disable_special_channel(card, ALI_SPDIF_IN_CHANNEL);
 }
 static void
 ali_setup_spdif_in(struct trident_card *card)
 {
 	unsigned long spdif;
 	//Set SPDIF IN Supported
 	spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
 	spdif |= ALI_SPDIF_IN_SUPPORT;
 	outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
 	//Set SPDIF IN Rec
 	spdif = inl(TRID_REG(card, ALI_GLOBAL_CONTROL));
 	spdif |= ALI_SPDIF_IN_CH_ENABLE;
 	outl(spdif, TRID_REG(card, ALI_GLOBAL_CONTROL));
 	spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 	spdif |= ALI_SPDIF_IN_CH_STATUS;
 	outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
 /*
 	spdif = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 	spdif |= ALI_SPDIF_IN_FUNC_ENABLE;
 	outb(spdif, TRID_REG(card, ALI_SPDIF_CTRL));
 */
 }
 static void
 ali_delay(struct trident_card *card, int interval)
 {
 	unsigned long begintimer, currenttimer;
 	begintimer = inl(TRID_REG(card, ALI_STIMER));
 	currenttimer = inl(TRID_REG(card, ALI_STIMER));
 	while (currenttimer < begintimer + interval)
 		currenttimer = inl(TRID_REG(card, ALI_STIMER));
 }
 static void
 ali_detect_spdif_rate(struct trident_card *card)
 {
 	u16 wval = 0;
 	u16 count = 0;
 	u8 bval = 0, R1 = 0, R2 = 0;
 	bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 	bval |= 0x02;
 	outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
 	bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
 	bval |= 0x1F;
 	outb(bval, TRID_REG(card, ALI_SPDIF_CTRL + 1));
 	while (((R1 < 0x0B) || (R1 > 0x0E)) && (R1 != 0x12) &&
 	       count <= 50000) {
 		count++;
 		ali_delay(card, 6);
 		bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
 		R1 = bval & 0x1F;
 	}
 	if (count > 50000) {
 		printk(KERN_WARNING "trident: Error in "
 		       "ali_detect_spdif_rate!\n");
 		return;
 	}
 	count = 0;
 	while (count <= 50000) {
 		count++;
 		ali_delay(card, 6);
 		bval = inb(TRID_REG(card, ALI_SPDIF_CTRL + 1));
 		R2 = bval & 0x1F;
 		if (R2 != R1)
 			R1 = R2;
 		else
 			break;
 	}
 	if (count > 50000) {
 		printk(KERN_WARNING "trident: Error in "
 		       "ali_detect_spdif_rate!\n");
 		return;
 	}
 	switch (R2) {
 	case 0x0b:
 	case 0x0c:
 	case 0x0d:
 	case 0x0e:
 		wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
 		wval &= 0xE0F0;
 		wval |= (u16) 0x09 << 8 | (u16) 0x05;
 		outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
 		bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
 		outb(bval | 0x02, TRID_REG(card, ALI_SPDIF_CS + 3));
 		break;
 	case 0x12:
 		wval = inw(TRID_REG(card, ALI_SPDIF_CTRL + 2));
 		wval &= 0xE0F0;
 		wval |= (u16) 0x0E << 8 | (u16) 0x08;
 		outw(wval, TRID_REG(card, ALI_SPDIF_CTRL + 2));
 		bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3)) & 0xF0;
 		outb(bval | 0x03, TRID_REG(card, ALI_SPDIF_CS + 3));
 		break;
 	default:
 		break;
 	}
 }
 static unsigned int
 ali_get_spdif_in_rate(struct trident_card *card)
 {
 	u32 dwRate = 0;
 	u8 bval = 0;
 	ali_detect_spdif_rate(card);
 	bval = inb(TRID_REG(card, ALI_SPDIF_CTRL));
 	bval &= 0x7F;
 	bval |= 0x40;
 	outb(bval, TRID_REG(card, ALI_SPDIF_CTRL));
 	bval = inb(TRID_REG(card, ALI_SPDIF_CS + 3));
 	bval &= 0x0F;
 	switch (bval) {
 	case 0:
 		dwRate = 44100;
 		break;
 	case 1:
 		dwRate = 48000;
 		break;
 	case 2:
 		dwRate = 32000;
 		break;
 	default:
 		// Error occurs
 		break;
 	}
 	return dwRate;
 }
 static int
 ali_close_multi_channels(void)
 {
 	char temp = 0;
 	struct pci_dev *pci_dev = NULL;
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
 				 pci_dev);
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_byte(pci_dev, 0x59, &temp);
 	temp &= ~0x80;
 	pci_write_config_byte(pci_dev, 0x59, temp);
 	pci_dev_put(pci_dev);
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
 				 NULL);
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_byte(pci_dev, 0xB8, &temp);
 	temp &= ~0x20;
 	pci_write_config_byte(pci_dev, 0xB8, temp);
 	pci_dev_put(pci_dev);
 	return 0;
 }
 static int
 ali_setup_multi_channels(struct trident_card *card, int chan_nums)
 {
 	unsigned long dwValue;
 	char temp = 0;
 	struct pci_dev *pci_dev = NULL;
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
 				 pci_dev);
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_byte(pci_dev, 0x59, &temp);
 	temp |= 0x80;
 	pci_write_config_byte(pci_dev, 0x59, temp);
 	pci_dev_put(pci_dev);
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
 				 NULL);
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_byte(pci_dev, (int) 0xB8, &temp);
 	temp |= 0x20;
 	pci_write_config_byte(pci_dev, (int) 0xB8, (u8) temp);
 	pci_dev_put(pci_dev);
 	if (chan_nums == 6) {
 		dwValue = inl(TRID_REG(card, ALI_SCTRL)) | 0x000f0000;
 		outl(dwValue, TRID_REG(card, ALI_SCTRL));
 		mdelay(4);
 		dwValue = inl(TRID_REG(card, ALI_SCTRL));
 		if (dwValue & 0x2000000) {
 			ali_ac97_write(card->ac97_codec[0], 0x02, 8080);
 			ali_ac97_write(card->ac97_codec[0], 0x36, 0);
 			ali_ac97_write(card->ac97_codec[0], 0x38, 0);
 			/*
 			 *      On a board with a single codec you won't get the
 			 *      surround. On other boards configure it.
 			 */
 			if (card->ac97_codec[1] != NULL) {
 				ali_ac97_write(card->ac97_codec[1], 0x36, 0);
 				ali_ac97_write(card->ac97_codec[1], 0x38, 0);
 				ali_ac97_write(card->ac97_codec[1], 0x02, 0x0606);
 				ali_ac97_write(card->ac97_codec[1], 0x18, 0x0303);
 				ali_ac97_write(card->ac97_codec[1], 0x74, 0x3);
 			}
 			return 1;
 		}
 	}
 	return -EINVAL;
 }
 static void
 ali_free_pcm_channel(struct trident_card *card, unsigned int channel)
 {
 	int bank;
 	if (channel > 31)
 		return;
 	bank = channel >> 5;
 	channel = channel & 0x1f;
 	card->banks[bank].bitmap &= ~(1 << (channel));
 }
 static int
 ali_allocate_other_states_resources(struct trident_state *state, int chan_nums)
 {
 	struct trident_card *card = state->card;
 	struct trident_state *s;
 	int i, state_count = 0;
 	struct trident_pcm_bank *bank;
 	struct trident_channel *channel;
 	unsigned long num;
 	bank = &card->banks[BANK_A];
 	if (chan_nums != 6)
 		return 0;
 	for (i = 0; (i < ALI_CHANNELS) && (state_count != 4); i++) {
 		if (card->states[i])
 			continue;
 		num = ali_multi_channels_5_1[state_count];
 		if (!(bank->bitmap & (1 << num))) {
 			bank->bitmap |= 1 << num;
 			channel = &bank->channels[num];
 			channel->num = num;
 		} else {
 			state_count--;
 			for (; state_count >= 0; state_count--) {
 				kfree(state->other_states[state_count]);
 				num = ali_multi_channels_5_1[state_count];
 					ali_free_pcm_channel(card, num);
 			}
 			return -EBUSY;
 		}
 		s = card->states[i] = kmalloc(sizeof(*state), GFP_KERNEL);
 		if (!s) {
 			num = ali_multi_channels_5_1[state_count];
 			ali_free_pcm_channel(card, num);
 			state_count--;
 			for (; state_count >= 0; state_count--) {
 				num = ali_multi_channels_5_1[state_count];
 				ali_free_pcm_channel(card, num);
 				kfree(state->other_states[state_count]);
 			}
 			return -ENOMEM;
 		}
 		memset(s, 0, sizeof(*state));
 		s->dmabuf.channel = channel;
 		s->dmabuf.ossfragshift = s->dmabuf.ossmaxfrags =
 			s->dmabuf.subdivision = 0;
 		init_waitqueue_head(&s->dmabuf.wait);
 		s->magic = card->magic;
 		s->card = card;
 		s->virt = i;
 		ali_enable_special_channel(s);
 		state->other_states[state_count++] = s;
 	}
 	if (state_count != 4) {
 		state_count--;
 		for (; state_count >= 0; state_count--) {
 			kfree(state->other_states[state_count]);
 			num = ali_multi_channels_5_1[state_count];
 			ali_free_pcm_channel(card, num);
 		}
 		return -EBUSY;
 	}
 	return 0;
 }
 #ifdef CONFIG_PM
 /* save registers for ALi Power Management */
 static struct ali_saved_registers {
 	unsigned long global_regs[ALI_GLOBAL_REGS];
 	unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS];
 	unsigned mixer_regs[ALI_MIXER_REGS];
 } ali_registers;
 static void
 ali_save_regs(struct trident_card *card)
 {
 	unsigned long flags;
 	int i, j;
 	spin_lock_irqsave(&card->lock, flags);
 	ali_registers.global_regs[0x2c] = inl(TRID_REG(card, T4D_MISCINT));
 	//ali_registers.global_regs[0x20] = inl(TRID_REG(card,T4D_START_A));
 	ali_registers.global_regs[0x21] = inl(TRID_REG(card, T4D_STOP_A));
 	//disable all IRQ bits
 	outl(ALI_DISABLE_ALL_IRQ, TRID_REG(card, T4D_MISCINT));
 	for (i = 1; i < ALI_MIXER_REGS; i++)
 		ali_registers.mixer_regs[i] = ali_ac97_read(card->ac97_codec[0],
 							    i * 2);
 	for (i = 0; i < ALI_GLOBAL_REGS; i++) {
 		if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A))
 			continue;
 		ali_registers.global_regs[i] = inl(TRID_REG(card, i * 4));
 	}
 	for (i = 0; i < ALI_CHANNELS; i++) {
 		outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
 		for (j = 0; j < ALI_CHANNEL_REGS; j++)
 			ali_registers.channel_regs[i][j] = inl(TRID_REG(card,
 									j * 4 + 0xe0));
 	}
 	//Stop all HW channel
 	outl(ALI_STOP_ALL_CHANNELS, TRID_REG(card, T4D_STOP_A));
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static void
 ali_restore_regs(struct trident_card *card)
 {
 	unsigned long flags;
 	int i, j;
 	spin_lock_irqsave(&card->lock, flags);
 	for (i = 1; i < ALI_MIXER_REGS; i++)
 		ali_ac97_write(card->ac97_codec[0], i * 2,
 			       ali_registers.mixer_regs[i]);
 	for (i = 0; i < ALI_CHANNELS; i++) {
 		outb(i, TRID_REG(card, T4D_LFO_GC_CIR));
 		for (j = 0; j < ALI_CHANNEL_REGS; j++)
 			outl(ali_registers.channel_regs[i][j],
 			     TRID_REG(card, j * 4 + 0xe0));
 	}
 	for (i = 0; i < ALI_GLOBAL_REGS; i++) {
 		if ((i * 4 == T4D_MISCINT) || (i * 4 == T4D_STOP_A) ||
 		    (i * 4 == T4D_START_A))
 			continue;
 		outl(ali_registers.global_regs[i], TRID_REG(card, i * 4));
 	}
 	//start HW channel
 	outl(ali_registers.global_regs[0x20], TRID_REG(card, T4D_START_A));
 	//restore IRQ enable bits
 	outl(ali_registers.global_regs[0x2c], TRID_REG(card, T4D_MISCINT));
 	spin_unlock_irqrestore(&card->lock, flags);
 }
 static int
 trident_suspend(struct pci_dev *dev, pm_message_t unused)
 {
 	struct trident_card *card = pci_get_drvdata(dev);
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		ali_save_regs(card);
 	}
 	return 0;
 }
 static int
 trident_resume(struct pci_dev *dev)
 {
 	struct trident_card *card = pci_get_drvdata(dev);
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		ali_restore_regs(card);
 	}
 	return 0;
 }
 #endif
 static struct trident_channel *
 ali_alloc_pcm_channel(struct trident_card *card)
 {
 	struct trident_pcm_bank *bank;
 	int idx;
 	bank = &card->banks[BANK_A];
 	if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) &
 	    (ALI_SPDIF_OUT_CH_ENABLE)) {
 		idx = ALI_SPDIF_OUT_CHANNEL;
 		if (!(bank->bitmap & (1 << idx))) {
 			struct trident_channel *channel = &bank->channels[idx];
 			bank->bitmap |= 1 << idx;
 			channel->num = idx;
 			return channel;
 		}
 	}
 	for (idx = ALI_PCM_OUT_CHANNEL_FIRST; idx <= ALI_PCM_OUT_CHANNEL_LAST;
 	     idx++) {
 		if (!(bank->bitmap & (1 << idx))) {
 			struct trident_channel *channel = &bank->channels[idx];
 			bank->bitmap |= 1 << idx;
 			channel->num = idx;
 			return channel;
 		}
 	}
 	/* no more free channels avaliable */
 #if 0
 	printk(KERN_ERR "ali: no more channels available on Bank A.\n");
 #endif /* 0 */
 	return NULL;
 }
 static struct trident_channel *
 ali_alloc_rec_pcm_channel(struct trident_card *card)
 {
 	struct trident_pcm_bank *bank;
 	int idx;
 	if (inl(TRID_REG(card, ALI_GLOBAL_CONTROL)) & ALI_SPDIF_IN_SUPPORT)
 		idx = ALI_SPDIF_IN_CHANNEL;
 	else
 		idx = ALI_PCM_IN_CHANNEL;
 	bank = &card->banks[BANK_A];
 	if (!(bank->bitmap & (1 << idx))) {
 		struct trident_channel *channel = &bank->channels[idx];
 		bank->bitmap |= 1 << idx;
 		channel->num = idx;
 		return channel;
 	}
 	/* no free recordable channels avaliable */
 #if 0
 	printk(KERN_ERR "ali: no recordable channels available on Bank A.\n");
 #endif /* 0 */
 	return NULL;
 }
 static void
 ali_set_spdif_out_rate(struct trident_card *card, unsigned int rate)
 {
 	unsigned char ch_st_sel;
 	unsigned short status_rate;
 	switch (rate) {
 	case 44100:
 		status_rate = 0;
 		break;
 	case 32000:
 		status_rate = 0x300;
 		break;
 	case 48000:
 	default:
 		status_rate = 0x200;
 		break;
 	}
 	/* select spdif_out */
 	ch_st_sel = inb(TRID_REG(card, ALI_SPDIF_CTRL)) & ALI_SPDIF_OUT_CH_STATUS;
 	ch_st_sel |= 0x80;	/* select right */
 	outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
 	outb(status_rate | 0x20, TRID_REG(card, ALI_SPDIF_CS + 2));
 	ch_st_sel &= (~0x80);	/* select left */
 	outb(ch_st_sel, TRID_REG(card, ALI_SPDIF_CTRL));
 	outw(status_rate | 0x10, TRID_REG(card, ALI_SPDIF_CS + 2));
 }
 static void
 ali_address_interrupt(struct trident_card *card)
 {
 	int i, channel;
 	struct trident_state *state;
 	u32 mask, channel_mask;
 	mask = trident_get_interrupt_mask(card, 0);
 	for (i = 0; i < NR_HW_CH; i++) {
 		if ((state = card->states[i]) == NULL)
 			continue;
 		channel = state->dmabuf.channel->num;
 		if ((channel_mask = 1 << channel) & mask) {
 			mask &= ~channel_mask;
 			trident_ack_channel_interrupt(card, channel);
 			udelay(100);
 			state->dmabuf.update_flag |= ALI_ADDRESS_INT_UPDATE;
 			trident_update_ptr(state);
 		}
 	}
 	if (mask) {
 		for (i = 0; i < NR_HW_CH; i++) {
 			if (mask & (1 << i)) {
 				printk("ali: spurious channel irq %d.\n", i);
 				trident_ack_channel_interrupt(card, i);
 				trident_stop_voice(card, i);
 				trident_disable_voice_irq(card, i);
 			}
 		}
 	}
 }
 /* Updating the values of counters of other_states' DMAs without lock
 protection is no harm because all DMAs of multi-channels and interrupt
 depend on a master state's DMA, and changing the counters of the master
 state DMA is protected by a spinlock.
 */
 static int
 ali_write_5_1(struct trident_state *state, const char __user *buf,
 	      int cnt_for_multi_channel, unsigned int *copy_count,
 	      unsigned int *state_cnt)
 {
 	struct dmabuf *dmabuf = &state->dmabuf;
 	struct dmabuf *dmabuf_temp;
 	const char __user *buffer = buf;
 	unsigned swptr, other_dma_nums, sample_s;
 	unsigned int i, loop;
 	other_dma_nums = 4;
 	sample_s = sample_size[dmabuf->fmt] >> 1;
 	swptr = dmabuf->swptr;
 	if ((i = state->multi_channels_adjust_count) > 0) {
 		if (i == 1) {
 			if (copy_from_user(dmabuf->rawbuf + swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 			i--;
 			(*state_cnt) += sample_s;
 			state->multi_channels_adjust_count++;
 		} else
 			i = i - (state->chans_num - other_dma_nums);
 		for (; (i < other_dma_nums) && (cnt_for_multi_channel > 0); i++) {
 			dmabuf_temp = &state->other_states[i]->dmabuf;
 			if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 		}
 		if (cnt_for_multi_channel == 0)
 			state->multi_channels_adjust_count += i;
 	}
 	if (cnt_for_multi_channel > 0) {
 		loop = cnt_for_multi_channel / (state->chans_num * sample_s);
 		for (i = 0; i < loop; i++) {
 			if (copy_from_user(dmabuf->rawbuf + swptr, buffer,
 					   sample_s * 2))
 				return -EFAULT;
 			seek_offset(swptr, buffer, cnt_for_multi_channel,
 				    sample_s * 2, *copy_count);
 			(*state_cnt) += (sample_s * 2);
 			dmabuf_temp = &state->other_states[0]->dmabuf;
 			if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 			dmabuf_temp = &state->other_states[1]->dmabuf;
 			if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 			dmabuf_temp = &state->other_states[2]->dmabuf;
 			if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 			dmabuf_temp = &state->other_states[3]->dmabuf;
 			if (copy_from_user(dmabuf_temp->rawbuf + dmabuf_temp->swptr,
 					   buffer, sample_s))
 				return -EFAULT;
 			seek_offset(dmabuf_temp->swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 		}
 		if (cnt_for_multi_channel > 0) {
 			state->multi_channels_adjust_count = cnt_for_multi_channel / sample_s;
 			if (copy_from_user(dmabuf->rawbuf + swptr, buffer, sample_s))
 				return -EFAULT;
 			seek_offset(swptr, buffer, cnt_for_multi_channel,
 				    sample_s, *copy_count);
 			(*state_cnt) += sample_s;
 			if (cnt_for_multi_channel > 0) {
 				if (copy_from_user(dmabuf->rawbuf + swptr,
 						   buffer, sample_s))
 					return -EFAULT;
 				seek_offset(swptr, buffer, cnt_for_multi_channel,
 					    sample_s, *copy_count);
 				(*state_cnt) += sample_s;
 				if (cnt_for_multi_channel > 0) {
 					int diff = state->chans_num - other_dma_nums;
 					loop = state->multi_channels_adjust_count - diff;
 					for (i = 0; i < loop; i++) {
 						dmabuf_temp = &state->other_states[i]->dmabuf;
 						if (copy_from_user(dmabuf_temp->rawbuf +
 								   dmabuf_temp->swptr,
 								   buffer, sample_s))
 							return -EFAULT;
 						seek_offset(dmabuf_temp->swptr, buffer,
 							    cnt_for_multi_channel,
 							    sample_s, *copy_count);
 					}
 				}
 			}
 		} else
 			state->multi_channels_adjust_count = 0;
 	}
 	for (i = 0; i < other_dma_nums; i++) {
 		dmabuf_temp = &state->other_states[i]->dmabuf;
 		dmabuf_temp->swptr = dmabuf_temp->swptr % dmabuf_temp->dmasize;
 	}
 	return *state_cnt;
 }
 static void
 ali_free_other_states_resources(struct trident_state *state)
 {
 	int i;
 	struct trident_card *card = state->card;
 	struct trident_state *s;
 	unsigned other_states_count;
 	other_states_count = state->chans_num - 2; /* except PCM L/R channels */
 	for (i = 0; i < other_states_count; i++) {
 		s = state->other_states[i];
 		dealloc_dmabuf(&s->dmabuf, card->pci_dev);
 		ali_disable_special_channel(s->card, s->dmabuf.channel->num);
 		state->card->free_pcm_channel(s->card, s->dmabuf.channel->num);
 		card->states[s->virt] = NULL;
 		kfree(s);
 	}
 }
 static struct proc_dir_entry *res;
 static int
 ali_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
 {
 	struct trident_card *card = (struct trident_card *) data;
 	unsigned long flags;
 	char c;
 	if (count < 0)
 		return -EINVAL;
 	if (count == 0)
 		return 0;
 	if (get_user(c, buffer))
 		return -EFAULT;
 	spin_lock_irqsave(&card->lock, flags);
 	switch (c) {
 	case '0':
 		ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
 		ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
 		break;
 	case '1':
 		ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
 				    ALI_SPDIF_OUT_PCM);
 		break;
 	case '2':
 		ali_setup_spdif_out(card, ALI_SPDIF_OUT_TO_SPDIF_OUT |
 				    ALI_SPDIF_OUT_NON_PCM);
 		break;
 	case '3':
 		ali_disable_spdif_in(card);	//default
 		break;
 	case '4':
 		ali_setup_spdif_in(card);
 		break;
 	}
 	spin_unlock_irqrestore(&card->lock, flags);
 	return count;
 }
 /* OSS /dev/mixer file operation methods */
 static int
 trident_open_mixdev(struct inode *inode, struct file *file)
 {
 	int i = 0;
 	int minor = iminor(inode);
 	struct trident_card *card = devs;
 	for (card = devs; card != NULL; card = card->next)
 		for (i = 0; i < NR_AC97; i++)
 			if (card->ac97_codec[i] != NULL &&
 			    card->ac97_codec[i]->dev_mixer == minor)
 				goto match;
 	if (!card) {
 		return -ENODEV;
 	}
       match:
 	file->private_data = card->ac97_codec[i];
 	return nonseekable_open(inode, file);
 }
 static int
 trident_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
 		     unsigned long arg)
 {
 	struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
 	return codec->mixer_ioctl(codec, cmd, arg);
 }
 static /*const */ struct file_operations trident_mixer_fops = {
 	.owner = THIS_MODULE,
 	.llseek = no_llseek,
 	.ioctl = trident_ioctl_mixdev,
 	.open = trident_open_mixdev,
 };
 static int
 ali_reset_5451(struct trident_card *card)
 {
 	struct pci_dev *pci_dev = NULL;
 	unsigned int dwVal;
 	unsigned short wCount, wReg;
 	pci_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
 				 pci_dev);
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_dword(pci_dev, 0x7c, &dwVal);
 	pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
 	udelay(5000);
 	pci_read_config_dword(pci_dev, 0x7c, &dwVal);
 	pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
 	udelay(5000);
 	pci_dev_put(pci_dev);
 	pci_dev = card->pci_dev;
 	if (pci_dev == NULL)
 		return -1;
 	pci_read_config_dword(pci_dev, 0x44, &dwVal);
 	pci_write_config_dword(pci_dev, 0x44, dwVal | 0x000c0000);
 	udelay(500);
 	pci_read_config_dword(pci_dev, 0x44, &dwVal);
 	pci_write_config_dword(pci_dev, 0x44, dwVal & 0xfffbffff);
 	udelay(5000);
 	/* TODO: recognize if we have a PM capable codec and only do this */
 	/* if the codec is PM capable */
 	wCount = 2000;
 	while (wCount--) {
 		wReg = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
 		if ((wReg & 0x000f) == 0x000f)
 			return 0;
 		udelay(5000);
 	}
 	/* This is non fatal if you have a non PM capable codec.. */
 	return 0;
 }
 /* AC97 codec initialisation. */
 static int __devinit
 trident_ac97_init(struct trident_card *card)
 {
 	int num_ac97 = 0;
 	unsigned long ready_2nd = 0;
 	struct ac97_codec *codec;
 	int i = 0;
 	/* initialize controller side of AC link, and find out if secondary codes
 	   really exist */
 	switch (card->pci_id) {
 	case PCI_DEVICE_ID_ALI_5451:
 		if (ali_reset_5451(card)) {
 			printk(KERN_ERR "trident_ac97_init: error "
 			       "resetting 5451.\n");
 			return -1;
 		}
 		outl(0x80000001, TRID_REG(card, ALI_GLOBAL_CONTROL));
 		outl(0x00000000, TRID_REG(card, T4D_AINTEN_A));
 		outl(0xffffffff, TRID_REG(card, T4D_AINT_A));
 		outl(0x00000000, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
 		outb(0x10, TRID_REG(card, ALI_MPUR2));
 		ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
 		ready_2nd &= 0x3fff;
 		outl(ready_2nd | PCMOUT | 0x8000, TRID_REG(card, ALI_SCTRL));
 		ready_2nd = inl(TRID_REG(card, ALI_SCTRL));
 		ready_2nd &= SI_AC97_SECONDARY_READY;
 		if (card->revision < ALI_5451_V02)
 			ready_2nd = 0;
 		break;
 	case PCI_DEVICE_ID_SI_7018:
 		/* disable AC97 GPIO interrupt */
 		outl(0x00, TRID_REG(card, SI_AC97_GPIO));
 		/* when power up the AC link is in cold reset mode so stop it */
 		outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT | SECONDARY_ID,
 		     TRID_REG(card, SI_SERIAL_INTF_CTRL));
 		/* it take a long time to recover from a cold reset */
 		/* (especially when you have more than one codec) */
 		udelay(2000);
 		ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
 		ready_2nd &= SI_AC97_SECONDARY_READY;
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_DX:
 		/* playback on */
 		outl(DX_AC97_PLAYBACK, TRID_REG(card, DX_ACR2_AC97_COM_STAT));
 		break;
 	case PCI_DEVICE_ID_TRIDENT_4DWAVE_NX:
 		/* enable AC97 Output Slot 3,4 (PCM Left/Right Playback) */
 		outl(NX_AC97_PCM_OUTPUT, TRID_REG(card, NX_ACR0_AC97_COM_STAT));
 		ready_2nd = inl(TRID_REG(card, NX_ACR0_AC97_COM_STAT));
 		ready_2nd &= NX_AC97_SECONDARY_READY;
 		break;
 	case PCI_DEVICE_ID_INTERG_5050:
 		/* disable AC97 GPIO interrupt */
 		outl(0x00, TRID_REG(card, SI_AC97_GPIO));
 		/* when power up, the AC link is in cold reset mode, so stop it */
 		outl(PCMOUT | SURROUT | CENTEROUT | LFEOUT,
 		     TRID_REG(card, SI_SERIAL_INTF_CTRL));
 		/* it take a long time to recover from a cold reset (especially */
 		/* when you have more than one codec) */
 		udelay(2000);
 		ready_2nd = inl(TRID_REG(card, SI_SERIAL_INTF_CTRL));
 		ready_2nd &= SI_AC97_SECONDARY_READY;
 		break;
 	}
 	for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
 		if ((codec = ac97_alloc_codec()) == NULL)
 			return -ENOMEM;
 		/* initialize some basic codec information, other fields */
 		/* will be filled in ac97_probe_codec */
 		codec->private_data = card;
 		codec->id = num_ac97;
 		if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 			codec->codec_read = ali_ac97_read;
 			codec->codec_write = ali_ac97_write;
 		} else {
 			codec->codec_read = trident_ac97_get;
 			codec->codec_write = trident_ac97_set;
 		}
 		if (ac97_probe_codec(codec) == 0)
 			break;
 		codec->dev_mixer = register_sound_mixer(&trident_mixer_fops, -1);
 		if (codec->dev_mixer < 0) {
 			printk(KERN_ERR "trident: couldn't register mixer!\n");
 			ac97_release_codec(codec);
 			break;
 		}
 		card->ac97_codec[num_ac97] = codec;
 		/* if there is no secondary codec at all, don't probe any more */
 		if (!ready_2nd)
 			break;
 	}
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
 			if (card->ac97_codec[num_ac97] == NULL)
 				break;
 			for (i = 0; i < 64; i++) {
 				u16 reg = ali_ac97_get(card, num_ac97, i * 2);
 				card->mixer_regs[i][num_ac97] = reg;
 			}
 		}
 	}
 	return num_ac97 + 1;
 }
 #ifdef SUPPORT_JOYSTICK
 /* Gameport functions for the cards ADC gameport */
 static unsigned char trident_game_read(struct gameport *gameport)
 {
 	struct trident_card *card = gameport->port_data;
 	return inb(TRID_REG(card, T4D_GAME_LEG));
 }
 static void trident_game_trigger(struct gameport *gameport)
 {
 	struct trident_card *card = gameport->port_data;
 	outb(0xff, TRID_REG(card, T4D_GAME_LEG));
 }
 static int trident_game_cooked_read(struct gameport *gameport,
 				    int *axes, int *buttons)
 {
 	struct trident_card *card = gameport->port_data;
 	int i;
 	*buttons = (~inb(TRID_REG(card, T4D_GAME_LEG)) >> 4) & 0xf;
 	for (i = 0; i < 4; i++) {
 		axes[i] = inw(TRID_REG(card, T4D_GAME_AXD) + i * sizeof (u16));
 		if (axes[i] == 0xffff)
 			axes[i] = -1;
 	}
 	return 0;
 }
 static int trident_game_open(struct gameport *gameport, int mode)
 {
 	struct trident_card *card = gameport->port_data;
 	switch (mode) {
 	case GAMEPORT_MODE_COOKED:
 		outb(0x80, TRID_REG(card, T4D_GAME_CR));
 		msleep(20);
 		return 0;
 	case GAMEPORT_MODE_RAW:
 		outb(0x00, TRID_REG(card, T4D_GAME_CR));
 		return 0;
 	default:
 		return -1;
 	}
 	return 0;
 }
 static int __devinit trident_register_gameport(struct trident_card *card)
 {
 	struct gameport *gp;
 	card->gameport = gp = gameport_allocate_port();
 	if (!gp) {
 		printk(KERN_ERR "trident: can not allocate memory for gameport\n");
 		return -ENOMEM;
 	}
 	gameport_set_name(gp, "Trident 4DWave");
 	gameport_set_phys(gp, "pci%s/gameport0", pci_name(card->pci_dev));
 	gp->read = trident_game_read;
 	gp->trigger = trident_game_trigger;
 	gp->cooked_read = trident_game_cooked_read;
 	gp->open = trident_game_open;
 	gp->fuzz = 64;
 	gp->port_data = card;
 	gameport_register_port(gp);
 	return 0;
 }
 static inline void trident_unregister_gameport(struct trident_card *card)
 {
 	if (card->gameport)
 		gameport_unregister_port(card->gameport);
 }
 #else
 static inline int trident_register_gameport(struct trident_card *card) { return -ENOSYS; }
 static inline void trident_unregister_gameport(struct trident_card *card) { }
 #endif /* SUPPORT_JOYSTICK */
 /* install the driver, we do not allocate hardware channel nor DMA buffer */
 /* now, they are defered until "ACCESS" time (in prog_dmabuf called by */
 /* open/read/write/ioctl/mmap) */
 static int __devinit
 trident_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
 {
 	unsigned long iobase;
 	struct trident_card *card;
 	u8 bits;
 	u8 revision;
 	int i = 0;
 	u16 temp;
 	struct pci_dev *pci_dev_m1533 = NULL;
 	int rc = -ENODEV;
 	u64 dma_mask;
 	if (pci_enable_device(pci_dev))
 		goto out;
 	if (pci_dev->device == PCI_DEVICE_ID_ALI_5451)
 		dma_mask = ALI_DMA_MASK;
 	else
 		dma_mask = TRIDENT_DMA_MASK;
 	if (pci_set_dma_mask(pci_dev, dma_mask)) {
 		printk(KERN_ERR "trident: architecture does not support"
 		       " %s PCI busmaster DMA\n",
 		       pci_dev->device == PCI_DEVICE_ID_ALI_5451 ?
 		       "32-bit" : "30-bit");
 		goto out;
 	}
 	pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
 	if (pci_id->device == PCI_DEVICE_ID_INTERG_5050)
 		iobase = pci_resource_start(pci_dev, 1);
 	else
 		iobase = pci_resource_start(pci_dev, 0);
 	if (!request_region(iobase, 256, card_names[pci_id->driver_data])) {
 		printk(KERN_ERR "trident: can't allocate I/O space at "
 		       "0x%4.4lx\n", iobase);
 		goto out;
 	}
 	rc = -ENOMEM;
 	if ((card = kmalloc(sizeof(*card), GFP_KERNEL)) == NULL) {
 		printk(KERN_ERR "trident: out of memory\n");
 		goto out_release_region;
 	}
 	memset(card, 0, sizeof (*card));
 	init_timer(&card->timer);
 	card->iobase = iobase;
 	card->pci_dev = pci_dev_get(pci_dev);
 	card->pci_id = pci_id->device;
 	card->revision = revision;
 	card->irq = pci_dev->irq;
 	card->next = devs;
 	card->magic = TRIDENT_CARD_MAGIC;
 	card->banks[BANK_A].addresses = &bank_a_addrs;
 	card->banks[BANK_A].bitmap = 0UL;
 	card->banks[BANK_B].addresses = &bank_b_addrs;
 	card->banks[BANK_B].bitmap = 0UL;
 	mutex_init(&card->open_mutex);
 	spin_lock_init(&card->lock);
 	init_timer(&card->timer);
 	devs = card;
 	pci_set_master(pci_dev);
 	printk(KERN_INFO "trident: %s found at IO 0x%04lx, IRQ %d\n",
 	       card_names[pci_id->driver_data], card->iobase, card->irq);
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		/* ALi channel Management */
 		card->alloc_pcm_channel = ali_alloc_pcm_channel;
 		card->alloc_rec_pcm_channel = ali_alloc_rec_pcm_channel;
 		card->free_pcm_channel = ali_free_pcm_channel;
 		card->address_interrupt = ali_address_interrupt;
 		/* Added by Matt Wu 01-05-2001 for spdif in */
 		card->multi_channel_use_count = 0;
 		card->rec_channel_use_count = 0;
 		/* ALi SPDIF OUT function */
 		if (card->revision == ALI_5451_V02) {
 			ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
 			res = create_proc_entry("ALi5451", 0, NULL);
 			if (res) {
 				res->write_proc = ali_write_proc;
 				res->data = card;
 			}
 		}
 		/* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
 		card->hwvolctl = 0;
 		pci_dev_m1533 = pci_find_device(PCI_VENDOR_ID_AL,
 						PCI_DEVICE_ID_AL_M1533,
 						pci_dev_m1533);
 		rc = -ENODEV;
 		if (pci_dev_m1533 == NULL)
 			goto out_proc_fs;
 		pci_read_config_byte(pci_dev_m1533, 0x63, &bits);
 		if (bits & (1 << 5))
 			card->hwvolctl = 1;
 		if (card->hwvolctl) {
 			/* Clear m1533 pci cfg 78h bit 30 to zero, which makes
 			   GPIO11/12/13 work as ACGP_UP/DOWN/MUTE. */
 			pci_read_config_byte(pci_dev_m1533, 0x7b, &bits);
 			bits &= 0xbf;	/*clear bit 6 */
 			pci_write_config_byte(pci_dev_m1533, 0x7b, bits);
 		}
 	} else if (card->pci_id == PCI_DEVICE_ID_INTERG_5050) {
 		card->alloc_pcm_channel = cyber_alloc_pcm_channel;
 		card->alloc_rec_pcm_channel = cyber_alloc_pcm_channel;
 		card->free_pcm_channel = cyber_free_pcm_channel;
 		card->address_interrupt = cyber_address_interrupt;
 		cyber_init_ritual(card);
 	} else {
 		card->alloc_pcm_channel = trident_alloc_pcm_channel;
 		card->alloc_rec_pcm_channel = trident_alloc_pcm_channel;
 		card->free_pcm_channel = trident_free_pcm_channel;
 		card->address_interrupt = trident_address_interrupt;
 	}
 	/* claim our irq */
 	rc = -ENODEV;
 	if (request_irq(card->irq, &trident_interrupt, IRQF_SHARED,
 			card_names[pci_id->driver_data], card)) {
 		printk(KERN_ERR "trident: unable to allocate irq %d\n",
 		       card->irq);
 		goto out_proc_fs;
 	}
 	/* register /dev/dsp */
 	if ((card->dev_audio = register_sound_dsp(&trident_audio_fops, -1)) < 0) {
 		printk(KERN_ERR "trident: couldn't register DSP device!\n");
 		goto out_free_irq;
 	}
 	card->mixer_regs_ready = 0;
 	/* initialize AC97 codec and register /dev/mixer */
 	if (trident_ac97_init(card) <= 0) {
 		/* unregister audio devices */
 		for (i = 0; i < NR_AC97; i++) {
 			if (card->ac97_codec[i] != NULL) {
 				struct ac97_codec* codec = card->ac97_codec[i];
 				unregister_sound_mixer(codec->dev_mixer);
 				ac97_release_codec(codec);
 			}
 		}
 		goto out_unregister_sound_dsp;
 	}
 	card->mixer_regs_ready = 1;
 	outl(0x00, TRID_REG(card, T4D_MUSICVOL_WAVEVOL));
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		/* Add H/W Volume Control By Matt Wu Jul. 06, 2001 */
 		if (card->hwvolctl) {
 			/* Enable GPIO IRQ (MISCINT bit 18h) */
 			temp = inw(TRID_REG(card, T4D_MISCINT + 2));
 			temp |= 0x0004;
 			outw(temp, TRID_REG(card, T4D_MISCINT + 2));
 			/* Enable H/W Volume Control GLOVAL CONTROL bit 0 */
 			temp = inw(TRID_REG(card, ALI_GLOBAL_CONTROL));
 			temp |= 0x0001;
 			outw(temp, TRID_REG(card, ALI_GLOBAL_CONTROL));
 		}
 		if (card->revision == ALI_5451_V02)
 			ali_close_multi_channels();
 		/* edited by HMSEO for GT sound */
 #if defined(CONFIG_ALPHA_NAUTILUS) || defined(CONFIG_ALPHA_GENERIC)
 		{
 			u16 ac97_data;
 			extern struct hwrpb_struct *hwrpb;
 			if ((hwrpb->sys_type) == 201) {
 				printk(KERN_INFO "trident: Running on Alpha system "
 				       "type Nautilus\n");
 				ac97_data = ali_ac97_get(card, 0, AC97_POWER_CONTROL);
 				ali_ac97_set(card, 0, AC97_POWER_CONTROL,
 					     ac97_data | ALI_EAPD_POWER_DOWN);
 			}
 		}
 #endif				/* CONFIG_ALPHA_NAUTILUS || CONFIG_ALPHA_GENERIC */
 		/* edited by HMSEO for GT sound */
 	}
 	rc = 0;
 	pci_set_drvdata(pci_dev, card);
 	/* Enable Address Engine Interrupts */
 	trident_enable_loop_interrupts(card);
 	/* Register gameport */
 	trident_register_gameport(card);
 out:
 	return rc;
 out_unregister_sound_dsp:
 	unregister_sound_dsp(card->dev_audio);
 out_free_irq:
 	free_irq(card->irq, card);
 out_proc_fs:
 	pci_dev_put(card->pci_dev);
 	if (res) {
 		remove_proc_entry("ALi5451", NULL);
 		res = NULL;
 	}
 	kfree(card);
 	devs = NULL;
 out_release_region:
 	release_region(iobase, 256);
 	return rc;
 }
 static void __devexit
 trident_remove(struct pci_dev *pci_dev)
 {
 	int i;
 	struct trident_card *card = pci_get_drvdata(pci_dev);
 	/*
 	 *      Kill running timers before unload. We can't have them
 	 *      going off after rmmod!
 	 */
 	if (card->hwvolctl)
 		del_timer_sync(&card->timer);
 	/* ALi S/PDIF and Power Management */
 	if (card->pci_id == PCI_DEVICE_ID_ALI_5451) {
 		ali_setup_spdif_out(card, ALI_PCM_TO_SPDIF_OUT);
 		ali_disable_special_channel(card, ALI_SPDIF_OUT_CHANNEL);
 		ali_disable_spdif_in(card);
 		remove_proc_entry("ALi5451", NULL);
 	}
 	/* Unregister gameport */
 	trident_unregister_gameport(card);
 	/* Kill interrupts, and SP/DIF */
 	trident_disable_loop_interrupts(card);
 	/* free hardware resources */
 	free_irq(card->irq, card);
 	release_region(card->iobase, 256);
 	/* unregister audio devices */
 	for (i = 0; i < NR_AC97; i++)
 		if (card->ac97_codec[i] != NULL) {
 			unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
 			ac97_release_codec(card->ac97_codec[i]);
 		}
 	unregister_sound_dsp(card->dev_audio);
 	pci_set_drvdata(pci_dev, NULL);
 	pci_dev_put(card->pci_dev);
 	kfree(card);
 }
 MODULE_AUTHOR("Alan Cox, Aaron Holtzman, Ollie Lho, Ching Ling Lee, Muli Ben-Yehuda");
 MODULE_DESCRIPTION("Trident 4DWave/SiS 7018/ALi 5451 and Tvia/IGST CyberPro5050 PCI "
 		   "Audio Driver");
 MODULE_LICENSE("GPL");
 #define TRIDENT_MODULE_NAME "trident"
 static struct pci_driver trident_pci_driver = {
 	.name = TRIDENT_MODULE_NAME,
 	.id_table = trident_pci_tbl,
 	.probe = trident_probe,
 	.remove = __devexit_p(trident_remove),
 #ifdef CONFIG_PM
 	.suspend = trident_suspend,
 	.resume = trident_resume
 #endif
 };
 static int __init
 trident_init_module(void)
 {
 	printk(KERN_INFO "Trident 4DWave/SiS 7018/ALi 5451,Tvia CyberPro "
 	       "5050 PCI Audio, version " DRIVER_VERSION ", " __TIME__ " "
 	       __DATE__ "\n");
 	return pci_register_driver(&trident_pci_driver);
 }
 static void __exit
 trident_cleanup_module(void)
 {
 	pci_unregister_driver(&trident_pci_driver);
 }
 module_init(trident_init_module);
 module_exit(trident_cleanup_module);