[mirror_ubuntu-artful-kernel.git] / sound / oss / dmasound / dmasound_q40.c

/*
 *  linux/sound/oss/dmasound/dmasound_q40.c
 *
 *  Q40 DMA Sound Driver
 *
 *  See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
 *  prior to 28/01/2001
 *
 *  28/01/2001 [0.1] Iain Sandoe
 *		     - added versioning
 *		     - put in and populated the hardware_afmts field.
 *             [0.2] - put in SNDCTL_DSP_GETCAPS value.
 *	       [0.3] - put in default hard/soft settings.
 */


#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/soundcard.h>
#include <linux/interrupt.h>

#include <linux/uaccess.h>
#include <asm/q40ints.h>
#include <asm/q40_master.h>

#include "dmasound.h"

#define DMASOUND_Q40_REVISION 0
#define DMASOUND_Q40_EDITION 3

static int expand_bal;	/* Balance factor for expanding (not volume!) */
static int expand_data;	/* Data for expanding */


/*** Low level stuff *********************************************************/


static void *Q40Alloc(unsigned int size, gfp_t flags);
static void Q40Free(void *, unsigned int);
static int Q40IrqInit(void);
#ifdef MODULE
static void Q40IrqCleanUp(void);
#endif
static void Q40Silence(void);
static void Q40Init(void);
static int Q40SetFormat(int format);
static int Q40SetVolume(int volume);
static void Q40PlayNextFrame(int index);
static void Q40Play(void);
static irqreturn_t Q40StereoInterrupt(int irq, void *dummy);
static irqreturn_t Q40MonoInterrupt(int irq, void *dummy);
static void Q40Interrupt(void);


/*** Mid level stuff *********************************************************/


/* userCount, frameUsed, frameLeft == byte counts */
static ssize_t q40_ct_law(const u_char __user *userPtr, size_t userCount,
			   u_char frame[], ssize_t *frameUsed,
			   ssize_t frameLeft)
{
	char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8;
	ssize_t count, used;
	u_char *p = (u_char *) &frame[*frameUsed];

	used = count = min_t(size_t, userCount, frameLeft);
	if (copy_from_user(p,userPtr,count))
	  return -EFAULT;
	while (count > 0) {
		*p = table[*p]+128;
		p++;
		count--;
	}
	*frameUsed += used ;
	return used;
}


static ssize_t q40_ct_s8(const u_char __user *userPtr, size_t userCount,
			  u_char frame[], ssize_t *frameUsed,
			  ssize_t frameLeft)
{
	ssize_t count, used;
	u_char *p = (u_char *) &frame[*frameUsed];

	used = count = min_t(size_t, userCount, frameLeft);
	if (copy_from_user(p,userPtr,count))
	  return -EFAULT;
	while (count > 0) {
		*p = *p + 128;
		p++;
		count--;
	}
	*frameUsed += used;
	return used;
}

static ssize_t q40_ct_u8(const u_char __user *userPtr, size_t userCount,
			  u_char frame[], ssize_t *frameUsed,
			  ssize_t frameLeft)
{
	ssize_t count, used;
	u_char *p = (u_char *) &frame[*frameUsed];

	used = count = min_t(size_t, userCount, frameLeft);
	if (copy_from_user(p,userPtr,count))
	  return -EFAULT;
	*frameUsed += used;
	return used;
}


/* a bit too complicated to optimise right now ..*/
static ssize_t q40_ctx_law(const u_char __user *userPtr, size_t userCount,
			    u_char frame[], ssize_t *frameUsed,
			    ssize_t frameLeft)
{
	unsigned char *table = (unsigned char *)
		(dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
	unsigned int data = expand_data;
	u_char *p = (u_char *) &frame[*frameUsed];
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;

	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		if (bal < 0) {
			if (userCount == 0)
				break;
			if (get_user(c, userPtr++))
				return -EFAULT;
			data = table[c];
			data += 0x80;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft);
	utotal -= userCount;
	return utotal;
}


static ssize_t q40_ctx_s8(const u_char __user *userPtr, size_t userCount,
			   u_char frame[], ssize_t *frameUsed,
			   ssize_t frameLeft)
{
	u_char *p = (u_char *) &frame[*frameUsed];
	unsigned int data = expand_data;
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;


	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		if (bal < 0) {
			if (userCount == 0)
				break;
			if (get_user(c, userPtr++))
				return -EFAULT;
			data = c ;
			data += 0x80;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft);
	utotal -= userCount;
	return utotal;
}


static ssize_t q40_ctx_u8(const u_char __user *userPtr, size_t userCount,
			   u_char frame[], ssize_t *frameUsed,
			   ssize_t frameLeft)
{
	u_char *p = (u_char *) &frame[*frameUsed];
	unsigned int data = expand_data;
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;

	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		if (bal < 0) {
			if (userCount == 0)
				break;
			if (get_user(c, userPtr++))
				return -EFAULT;
			data = c ;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft) ;
	utotal -= userCount;
	return utotal;
}

/* compressing versions */
static ssize_t q40_ctc_law(const u_char __user *userPtr, size_t userCount,
			    u_char frame[], ssize_t *frameUsed,
			    ssize_t frameLeft)
{
	unsigned char *table = (unsigned char *)
		(dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
	unsigned int data = expand_data;
	u_char *p = (u_char *) &frame[*frameUsed];
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;
 
	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		while(bal<0) {
			if (userCount == 0)
				goto lout;
			if (!(bal<(-hSpeed))) {
				if (get_user(c, userPtr))
					return -EFAULT;
				data = 0x80 + table[c];
			}
			userPtr++;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
 lout:
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft);
	utotal -= userCount;
	return utotal;
}


static ssize_t q40_ctc_s8(const u_char __user *userPtr, size_t userCount,
			   u_char frame[], ssize_t *frameUsed,
			   ssize_t frameLeft)
{
	u_char *p = (u_char *) &frame[*frameUsed];
	unsigned int data = expand_data;
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;

	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		while (bal < 0) {
			if (userCount == 0)
				goto lout;
			if (!(bal<(-hSpeed))) {
				if (get_user(c, userPtr))
					return -EFAULT;
				data = c + 0x80;
			}
			userPtr++;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
 lout:
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft);
	utotal -= userCount;
	return utotal;
}


static ssize_t q40_ctc_u8(const u_char __user *userPtr, size_t userCount,
			   u_char frame[], ssize_t *frameUsed,
			   ssize_t frameLeft)
{
	u_char *p = (u_char *) &frame[*frameUsed];
	unsigned int data = expand_data;
	int bal = expand_bal;
	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	int utotal, ftotal;

	ftotal = frameLeft;
	utotal = userCount;
	while (frameLeft) {
		u_char c;
		while (bal < 0) {
			if (userCount == 0)
				goto lout;
			if (!(bal<(-hSpeed))) {
				if (get_user(c, userPtr))
					return -EFAULT;
				data = c ;
			}
			userPtr++;
			userCount--;
			bal += hSpeed;
		}
		*p++ = data;
		frameLeft--;
		bal -= sSpeed;
	}
 lout:
	expand_bal = bal;
	expand_data = data;
	*frameUsed += (ftotal - frameLeft) ;
	utotal -= userCount;
	return utotal;
}


static TRANS transQ40Normal = {
	q40_ct_law, q40_ct_law, q40_ct_s8, q40_ct_u8, NULL, NULL, NULL, NULL
};

static TRANS transQ40Expanding = {
	q40_ctx_law, q40_ctx_law, q40_ctx_s8, q40_ctx_u8, NULL, NULL, NULL, NULL
};

static TRANS transQ40Compressing = {
	q40_ctc_law, q40_ctc_law, q40_ctc_s8, q40_ctc_u8, NULL, NULL, NULL, NULL
};


/*** Low level stuff *********************************************************/

static void *Q40Alloc(unsigned int size, gfp_t flags)
{
         return kmalloc(size, flags); /* change to vmalloc */
}

static void Q40Free(void *ptr, unsigned int size)
{
	kfree(ptr);
}

static int __init Q40IrqInit(void)
{
	/* Register interrupt handler. */
	if (request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
		    "DMA sound", Q40Interrupt))
		return 0;

	return(1);
}


#ifdef MODULE
static void Q40IrqCleanUp(void)
{
        master_outb(0,SAMPLE_ENABLE_REG);
	free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
}
#endif /* MODULE */


static void Q40Silence(void)
{
        master_outb(0,SAMPLE_ENABLE_REG);
	*DAC_LEFT=*DAC_RIGHT=127;
}

static char *q40_pp;
static unsigned int q40_sc;

static void Q40PlayNextFrame(int index)
{
	u_char *start;
	u_long size;
	u_char speed;
	int error;

	/* used by Q40Play() if all doubts whether there really is something
	 * to be played are already wiped out.
	 */
	start = write_sq.buffers[write_sq.front];
	size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size);

	q40_pp=start;
	q40_sc=size;

	write_sq.front = (write_sq.front+1) % write_sq.max_count;
	write_sq.active++;

	speed=(dmasound.hard.speed==10000 ? 0 : 1);

	master_outb( 0,SAMPLE_ENABLE_REG);
	free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
	if (dmasound.soft.stereo)
		error = request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
				    "Q40 sound", Q40Interrupt);
	  else
		error = request_irq(Q40_IRQ_SAMPLE, Q40MonoInterrupt, 0,
				    "Q40 sound", Q40Interrupt);
	if (error && printk_ratelimit())
		pr_err("Couldn't register sound interrupt\n");

	master_outb( speed, SAMPLE_RATE_REG);
	master_outb( 1,SAMPLE_CLEAR_REG);
	master_outb( 1,SAMPLE_ENABLE_REG);
}

static void Q40Play(void)
{
        unsigned long flags;

	if (write_sq.active || write_sq.count<=0 ) {
		/* There's already a frame loaded */
		return;
	}

	/* nothing in the queue */
	if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
	         /* hmmm, the only existing frame is not
		  * yet filled and we're not syncing?
		  */
	         return;
	}
	spin_lock_irqsave(&dmasound.lock, flags);
	Q40PlayNextFrame(1);
	spin_unlock_irqrestore(&dmasound.lock, flags);
}

static irqreturn_t Q40StereoInterrupt(int irq, void *dummy)
{
	spin_lock(&dmasound.lock);
        if (q40_sc>1){
            *DAC_LEFT=*q40_pp++;
	    *DAC_RIGHT=*q40_pp++;
	    q40_sc -=2;
	    master_outb(1,SAMPLE_CLEAR_REG);
	}else Q40Interrupt();
	spin_unlock(&dmasound.lock);
	return IRQ_HANDLED;
}
static irqreturn_t Q40MonoInterrupt(int irq, void *dummy)
{
	spin_lock(&dmasound.lock);
        if (q40_sc>0){
            *DAC_LEFT=*q40_pp;
	    *DAC_RIGHT=*q40_pp++;
	    q40_sc --;
	    master_outb(1,SAMPLE_CLEAR_REG);
	}else Q40Interrupt();
	spin_unlock(&dmasound.lock);
	return IRQ_HANDLED;
}
static void Q40Interrupt(void)
{
	if (!write_sq.active) {
	          /* playing was interrupted and sq_reset() has already cleared
		   * the sq variables, so better don't do anything here.
		   */
	           WAKE_UP(write_sq.sync_queue);
		   master_outb(0,SAMPLE_ENABLE_REG); /* better safe */
		   goto exit;
	} else write_sq.active=0;
	write_sq.count--;
	Q40Play();

	if (q40_sc<2)
	      { /* there was nothing to play, disable irq */
		master_outb(0,SAMPLE_ENABLE_REG);
		*DAC_LEFT=*DAC_RIGHT=127;
	      }
	WAKE_UP(write_sq.action_queue);

 exit:
	master_outb(1,SAMPLE_CLEAR_REG);
}


static void Q40Init(void)
{
	int i, idx;
	const int freq[] = {10000, 20000};

	/* search a frequency that fits into the allowed error range */

	idx = -1;
	for (i = 0; i < 2; i++)
		if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) <= catchRadius)
			idx = i;

	dmasound.hard = dmasound.soft;
	/*sound.hard.stereo=1;*/ /* no longer true */
	dmasound.hard.size=8;

	if (idx > -1) {
		dmasound.soft.speed = freq[idx];
		dmasound.trans_write = &transQ40Normal;
	} else
		dmasound.trans_write = &transQ40Expanding;

	Q40Silence();

	if (dmasound.hard.speed > 20200) {
		/* squeeze the sound, we do that */
		dmasound.hard.speed = 20000;
		dmasound.trans_write = &transQ40Compressing;
	} else if (dmasound.hard.speed > 10000) {
		dmasound.hard.speed = 20000;
	} else {
		dmasound.hard.speed = 10000;
	}
	expand_bal = -dmasound.soft.speed;
}


static int Q40SetFormat(int format)
{
	/* Q40 sound supports only 8bit modes */

	switch (format) {
	case AFMT_QUERY:
		return(dmasound.soft.format);
	case AFMT_MU_LAW:
	case AFMT_A_LAW:
	case AFMT_S8:
	case AFMT_U8:
		break;
	default:
		format = AFMT_S8;
	}

	dmasound.soft.format = format;
	dmasound.soft.size = 8;
	if (dmasound.minDev == SND_DEV_DSP) {
		dmasound.dsp.format = format;
		dmasound.dsp.size = 8;
	}
	Q40Init();

	return(format);
}

static int Q40SetVolume(int volume)
{
    return 0;
}


/*** Machine definitions *****************************************************/

static SETTINGS def_hard = {
	.format	= AFMT_U8,
	.stereo	= 0,
	.size	= 8,
	.speed	= 10000
} ;

static SETTINGS def_soft = {
	.format	= AFMT_U8,
	.stereo	= 0,
	.size	= 8,
	.speed	= 8000
} ;

static MACHINE machQ40 = {
	.name		= "Q40",
	.name2		= "Q40",
	.owner		= THIS_MODULE,
	.dma_alloc	= Q40Alloc,
	.dma_free	= Q40Free,
	.irqinit	= Q40IrqInit,
#ifdef MODULE
	.irqcleanup	= Q40IrqCleanUp,
#endif /* MODULE */
	.init		= Q40Init,
	.silence	= Q40Silence,
	.setFormat	= Q40SetFormat,
	.setVolume	= Q40SetVolume,
	.play		= Q40Play,
 	.min_dsp_speed	= 10000,
	.version	= ((DMASOUND_Q40_REVISION<<8) | DMASOUND_Q40_EDITION),
	.hardware_afmts	= AFMT_U8, /* h'ware-supported formats *only* here */
	.capabilities	= DSP_CAP_BATCH  /* As per SNDCTL_DSP_GETCAPS */
};


/*** Config & Setup **********************************************************/


static int __init dmasound_q40_init(void)
{
	if (MACH_IS_Q40) {
	    dmasound.mach = machQ40;
	    dmasound.mach.default_hard = def_hard ;
	    dmasound.mach.default_soft = def_soft ;
	    return dmasound_init();
	} else
	    return -ENODEV;
}

static void __exit dmasound_q40_cleanup(void)
{
	dmasound_deinit();
}

module_init(dmasound_q40_init);
module_exit(dmasound_q40_cleanup);

MODULE_DESCRIPTION("Q40/Q60 sound driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/sound/oss/dmasound/dmasound_q40.c
	3	*
	4	* Q40 DMA Sound Driver
	5	*
	6	* See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
	7	* prior to 28/01/2001
	8	*
	9	* 28/01/2001 [0.1] Iain Sandoe
	10	* - added versioning
	11	* - put in and populated the hardware_afmts field.
	12	* [0.2] - put in SNDCTL_DSP_GETCAPS value.
	13	* [0.3] - put in default hard/soft settings.
	14	*/
	15
	16
	17	#include <linux/module.h>
	18	#include <linux/init.h>
	19	#include <linux/slab.h>
	20	#include <linux/soundcard.h>
	21	#include <linux/interrupt.h>
	22
7c0f6ba6	23	#include <linux/uaccess.h>
1da177e4 LT	24	#include <asm/q40ints.h>
	25	#include <asm/q40_master.h>
	26
	27	#include "dmasound.h"
	28
	29	#define DMASOUND_Q40_REVISION 0
	30	#define DMASOUND_Q40_EDITION 3
	31
	32	static int expand_bal; /* Balance factor for expanding (not volume!) */
	33	static int expand_data; /* Data for expanding */
	34
	35
	36	/* Low level stuff *******************************************************/
	37
	38
1ef64e67	39	static void *Q40Alloc(unsigned int size, gfp_t flags);
1da177e4 LT	40	static void Q40Free(void *, unsigned int);
	41	static int Q40IrqInit(void);
	42	#ifdef MODULE
	43	static void Q40IrqCleanUp(void);
	44	#endif
	45	static void Q40Silence(void);
	46	static void Q40Init(void);
	47	static int Q40SetFormat(int format);
	48	static int Q40SetVolume(int volume);
	49	static void Q40PlayNextFrame(int index);
	50	static void Q40Play(void);
7d12e780 DH	51	static irqreturn_t Q40StereoInterrupt(int irq, void *dummy);
7d12e780 DH	52	static irqreturn_t Q40MonoInterrupt(int irq, void *dummy);
1da177e4 LT	53	static void Q40Interrupt(void);
	54
	55
	56	/* Mid level stuff *******************************************************/
	57
	58
	59
	60	/* userCount, frameUsed, frameLeft == byte counts */
031eb4cd	61	static ssize_t q40_ct_law(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	62	u_char frame[], ssize_t *frameUsed,
	63	ssize_t frameLeft)
	64	{
	65	char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8;
	66	ssize_t count, used;
	67	u_char p = (u_char ) &frame[*frameUsed];
	68
	69	used = count = min_t(size_t, userCount, frameLeft);
	70	if (copy_from_user(p,userPtr,count))
	71	return -EFAULT;
	72	while (count > 0) {
	73	p = table[p]+128;
	74	p++;
	75	count--;
	76	}
	77	*frameUsed += used ;
	78	return used;
	79	}
	80
	81
031eb4cd	82	static ssize_t q40_ct_s8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	83	u_char frame[], ssize_t *frameUsed,
	84	ssize_t frameLeft)
	85	{
	86	ssize_t count, used;
	87	u_char p = (u_char ) &frame[*frameUsed];
	88
	89	used = count = min_t(size_t, userCount, frameLeft);
	90	if (copy_from_user(p,userPtr,count))
	91	return -EFAULT;
	92	while (count > 0) {
	93	p = p + 128;
	94	p++;
	95	count--;
	96	}
	97	*frameUsed += used;
	98	return used;
	99	}
	100
031eb4cd	101	static ssize_t q40_ct_u8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	102	u_char frame[], ssize_t *frameUsed,
	103	ssize_t frameLeft)
	104	{
	105	ssize_t count, used;
	106	u_char p = (u_char ) &frame[*frameUsed];
	107
	108	used = count = min_t(size_t, userCount, frameLeft);
	109	if (copy_from_user(p,userPtr,count))
	110	return -EFAULT;
	111	*frameUsed += used;
	112	return used;
	113	}
	114
	115
	116	/* a bit too complicated to optimise right now ..*/
031eb4cd	117	static ssize_t q40_ctx_law(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	118	u_char frame[], ssize_t *frameUsed,
	119	ssize_t frameLeft)
	120	{
	121	unsigned char table = (unsigned char )
	122	(dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
	123	unsigned int data = expand_data;
	124	u_char p = (u_char ) &frame[*frameUsed];
	125	int bal = expand_bal;
	126	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	127	int utotal, ftotal;
	128
	129	ftotal = frameLeft;
	130	utotal = userCount;
	131	while (frameLeft) {
	132	u_char c;
	133	if (bal < 0) {
	134	if (userCount == 0)
	135	break;
	136	if (get_user(c, userPtr++))
	137	return -EFAULT;
	138	data = table[c];
	139	data += 0x80;
	140	userCount--;
	141	bal += hSpeed;
	142	}
	143	*p++ = data;
	144	frameLeft--;
	145	bal -= sSpeed;
	146	}
	147	expand_bal = bal;
	148	expand_data = data;
	149	*frameUsed += (ftotal - frameLeft);
	150	utotal -= userCount;
	151	return utotal;
	152	}
	153
	154
031eb4cd	155	static ssize_t q40_ctx_s8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	156	u_char frame[], ssize_t *frameUsed,
	157	ssize_t frameLeft)
	158	{
	159	u_char p = (u_char ) &frame[*frameUsed];
	160	unsigned int data = expand_data;
	161	int bal = expand_bal;
	162	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	163	int utotal, ftotal;
	164
	165
	166	ftotal = frameLeft;
	167	utotal = userCount;
	168	while (frameLeft) {
	169	u_char c;
	170	if (bal < 0) {
	171	if (userCount == 0)
	172	break;
	173	if (get_user(c, userPtr++))
	174	return -EFAULT;
	175	data = c ;
	176	data += 0x80;
	177	userCount--;
	178	bal += hSpeed;
	179	}
	180	*p++ = data;
	181	frameLeft--;
	182	bal -= sSpeed;
	183	}
	184	expand_bal = bal;
	185	expand_data = data;
	186	*frameUsed += (ftotal - frameLeft);
	187	utotal -= userCount;
	188	return utotal;
	189	}
	190
	191
031eb4cd	192	static ssize_t q40_ctx_u8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	193	u_char frame[], ssize_t *frameUsed,
	194	ssize_t frameLeft)
	195	{
	196	u_char p = (u_char ) &frame[*frameUsed];
	197	unsigned int data = expand_data;
	198	int bal = expand_bal;
	199	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	200	int utotal, ftotal;
	201
	202	ftotal = frameLeft;
	203	utotal = userCount;
	204	while (frameLeft) {
	205	u_char c;
	206	if (bal < 0) {
	207	if (userCount == 0)
	208	break;
	209	if (get_user(c, userPtr++))
	210	return -EFAULT;
	211	data = c ;
	212	userCount--;
	213	bal += hSpeed;
	214	}
	215	*p++ = data;
	216	frameLeft--;
	217	bal -= sSpeed;
	218	}
	219	expand_bal = bal;
	220	expand_data = data;
	221	*frameUsed += (ftotal - frameLeft) ;
	222	utotal -= userCount;
	223	return utotal;
	224	}
	225
	226	/* compressing versions */
031eb4cd	227	static ssize_t q40_ctc_law(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	228	u_char frame[], ssize_t *frameUsed,
	229	ssize_t frameLeft)
	230	{
	231	unsigned char table = (unsigned char )
	232	(dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
	233	unsigned int data = expand_data;
	234	u_char p = (u_char ) &frame[*frameUsed];
	235	int bal = expand_bal;
	236	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	237	int utotal, ftotal;
	238
	239	ftotal = frameLeft;
	240	utotal = userCount;
	241	while (frameLeft) {
	242	u_char c;
	243	while(bal<0) {
	244	if (userCount == 0)
	245	goto lout;
	246	if (!(bal<(-hSpeed))) {
	247	if (get_user(c, userPtr))
	248	return -EFAULT;
	249	data = 0x80 + table[c];
	250	}
	251	userPtr++;
	252	userCount--;
	253	bal += hSpeed;
	254	}
	255	*p++ = data;
	256	frameLeft--;
	257	bal -= sSpeed;
	258	}
	259	lout:
	260	expand_bal = bal;
	261	expand_data = data;
	262	*frameUsed += (ftotal - frameLeft);
	263	utotal -= userCount;
	264	return utotal;
	265	}
	266
	267
031eb4cd	268	static ssize_t q40_ctc_s8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	269	u_char frame[], ssize_t *frameUsed,
	270	ssize_t frameLeft)
	271	{
	272	u_char p = (u_char ) &frame[*frameUsed];
	273	unsigned int data = expand_data;
	274	int bal = expand_bal;
	275	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	276	int utotal, ftotal;
	277
	278	ftotal = frameLeft;
	279	utotal = userCount;
	280	while (frameLeft) {
	281	u_char c;
	282	while (bal < 0) {
	283	if (userCount == 0)
	284	goto lout;
	285	if (!(bal<(-hSpeed))) {
	286	if (get_user(c, userPtr))
	287	return -EFAULT;
	288	data = c + 0x80;
	289	}
	290	userPtr++;
	291	userCount--;
	292	bal += hSpeed;
	293	}
	294	*p++ = data;
	295	frameLeft--;
	296	bal -= sSpeed;
	297	}
	298	lout:
	299	expand_bal = bal;
	300	expand_data = data;
	301	*frameUsed += (ftotal - frameLeft);
	302	utotal -= userCount;
	303	return utotal;
	304	}
	305
	306
031eb4cd	307	static ssize_t q40_ctc_u8(const u_char __user *userPtr, size_t userCount,
1da177e4 LT	308	u_char frame[], ssize_t *frameUsed,
	309	ssize_t frameLeft)
	310	{
	311	u_char p = (u_char ) &frame[*frameUsed];
	312	unsigned int data = expand_data;
	313	int bal = expand_bal;
	314	int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
	315	int utotal, ftotal;
	316
	317	ftotal = frameLeft;
	318	utotal = userCount;
	319	while (frameLeft) {
	320	u_char c;
	321	while (bal < 0) {
	322	if (userCount == 0)
	323	goto lout;
	324	if (!(bal<(-hSpeed))) {
	325	if (get_user(c, userPtr))
	326	return -EFAULT;
	327	data = c ;
	328	}
	329	userPtr++;
	330	userCount--;
	331	bal += hSpeed;
	332	}
	333	*p++ = data;
	334	frameLeft--;
	335	bal -= sSpeed;
	336	}
	337	lout:
	338	expand_bal = bal;
	339	expand_data = data;
	340	*frameUsed += (ftotal - frameLeft) ;
	341	utotal -= userCount;
	342	return utotal;
	343	}
	344
	345
	346	static TRANS transQ40Normal = {
	347	q40_ct_law, q40_ct_law, q40_ct_s8, q40_ct_u8, NULL, NULL, NULL, NULL
	348	};
	349
	350	static TRANS transQ40Expanding = {
	351	q40_ctx_law, q40_ctx_law, q40_ctx_s8, q40_ctx_u8, NULL, NULL, NULL, NULL
	352	};
	353
	354	static TRANS transQ40Compressing = {
	355	q40_ctc_law, q40_ctc_law, q40_ctc_s8, q40_ctc_u8, NULL, NULL, NULL, NULL
	356	};
	357
	358
	359	/* Low level stuff *******************************************************/
	360
1ef64e67	361	static void *Q40Alloc(unsigned int size, gfp_t flags)
1da177e4 LT	362	{
	363	return kmalloc(size, flags); /* change to vmalloc */
	364	}
	365
	366	static void Q40Free(void *ptr, unsigned int size)
	367	{
	368	kfree(ptr);
	369	}
	370
	371	static int __init Q40IrqInit(void)
	372	{
	373	/* Register interrupt handler. */
89bde7b8 GU	374	if (request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
	375	"DMA sound", Q40Interrupt))
	376	return 0;
1da177e4 LT	377
	378	return(1);
	379	}
	380
	381
	382	#ifdef MODULE
	383	static void Q40IrqCleanUp(void)
	384	{
	385	master_outb(0,SAMPLE_ENABLE_REG);
	386	free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
	387	}
	388	#endif /* MODULE */
	389
	390
	391	static void Q40Silence(void)
	392	{
	393	master_outb(0,SAMPLE_ENABLE_REG);
	394	DAC_LEFT=DAC_RIGHT=127;
	395	}
	396
	397	static char *q40_pp;
	398	static unsigned int q40_sc;
	399
	400	static void Q40PlayNextFrame(int index)
	401	{
	402	u_char *start;
	403	u_long size;
	404	u_char speed;
89bde7b8	405	int error;
1da177e4 LT	406
	407	/* used by Q40Play() if all doubts whether there really is something
	408	* to be played are already wiped out.
	409	*/
	410	start = write_sq.buffers[write_sq.front];
	411	size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size);
	412
	413	q40_pp=start;
	414	q40_sc=size;
	415
	416	write_sq.front = (write_sq.front+1) % write_sq.max_count;
	417	write_sq.active++;
	418
	419	speed=(dmasound.hard.speed==10000 ? 0 : 1);
	420
	421	master_outb( 0,SAMPLE_ENABLE_REG);
	422	free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
	423	if (dmasound.soft.stereo)
89bde7b8 GU	424	error = request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
89bde7b8 GU	425	"Q40 sound", Q40Interrupt);
1da177e4	426	else
89bde7b8 GU	427	error = request_irq(Q40_IRQ_SAMPLE, Q40MonoInterrupt, 0,
	428	"Q40 sound", Q40Interrupt);
	429	if (error && printk_ratelimit())
	430	pr_err("Couldn't register sound interrupt\n");
1da177e4 LT	431
	432	master_outb( speed, SAMPLE_RATE_REG);
	433	master_outb( 1,SAMPLE_CLEAR_REG);
	434	master_outb( 1,SAMPLE_ENABLE_REG);
	435	}
	436
	437	static void Q40Play(void)
	438	{
	439	unsigned long flags;
	440
	441	if (write_sq.active \|\| write_sq.count<=0 ) {
	442	/* There's already a frame loaded */
	443	return;
	444	}
	445
	446	/* nothing in the queue */
	447	if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
	448	/* hmmm, the only existing frame is not
	449	* yet filled and we're not syncing?
	450	*/
	451	return;
	452	}
	453	spin_lock_irqsave(&dmasound.lock, flags);
	454	Q40PlayNextFrame(1);
	455	spin_unlock_irqrestore(&dmasound.lock, flags);
	456	}
	457
7d12e780	458	static irqreturn_t Q40StereoInterrupt(int irq, void *dummy)
1da177e4 LT	459	{
	460	spin_lock(&dmasound.lock);
	461	if (q40_sc>1){
	462	DAC_LEFT=q40_pp++;
	463	DAC_RIGHT=q40_pp++;
	464	q40_sc -=2;
	465	master_outb(1,SAMPLE_CLEAR_REG);
	466	}else Q40Interrupt();
	467	spin_unlock(&dmasound.lock);
	468	return IRQ_HANDLED;
	469	}
7d12e780	470	static irqreturn_t Q40MonoInterrupt(int irq, void *dummy)
1da177e4 LT	471	{
	472	spin_lock(&dmasound.lock);
	473	if (q40_sc>0){
	474	DAC_LEFT=q40_pp;
	475	DAC_RIGHT=q40_pp++;
	476	q40_sc --;
	477	master_outb(1,SAMPLE_CLEAR_REG);
	478	}else Q40Interrupt();
	479	spin_unlock(&dmasound.lock);
	480	return IRQ_HANDLED;
	481	}
	482	static void Q40Interrupt(void)
	483	{
	484	if (!write_sq.active) {
	485	/* playing was interrupted and sq_reset() has already cleared
	486	* the sq variables, so better don't do anything here.
	487	*/
	488	WAKE_UP(write_sq.sync_queue);
	489	master_outb(0,SAMPLE_ENABLE_REG); /* better safe */
	490	goto exit;
	491	} else write_sq.active=0;
	492	write_sq.count--;
	493	Q40Play();
	494
	495	if (q40_sc<2)
	496	{ /* there was nothing to play, disable irq */
	497	master_outb(0,SAMPLE_ENABLE_REG);
	498	DAC_LEFT=DAC_RIGHT=127;
	499	}
	500	WAKE_UP(write_sq.action_queue);
	501
	502	exit:
	503	master_outb(1,SAMPLE_CLEAR_REG);
	504	}
	505
	506
	507	static void Q40Init(void)
	508	{
	509	int i, idx;
	510	const int freq[] = {10000, 20000};
	511
	512	/* search a frequency that fits into the allowed error range */
	513
	514	idx = -1;
	515	for (i = 0; i < 2; i++)
	516	if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) <= catchRadius)
	517	idx = i;
	518
	519	dmasound.hard = dmasound.soft;
	520	/sound.hard.stereo=1;/ /* no longer true */
	521	dmasound.hard.size=8;
	522
	523	if (idx > -1) {
	524	dmasound.soft.speed = freq[idx];
	525	dmasound.trans_write = &transQ40Normal;
	526	} else
	527	dmasound.trans_write = &transQ40Expanding;
	528
	529	Q40Silence();
	530
	531	if (dmasound.hard.speed > 20200) {
	532	/* squeeze the sound, we do that */
	533	dmasound.hard.speed = 20000;
	534	dmasound.trans_write = &transQ40Compressing;
535	} else if (dmasound.hard.speed > 10000) {
536	dmasound.hard.speed = 20000;
537	} else {
538	dmasound.hard.speed = 10000;
539	}
540	expand_bal = -dmasound.soft.speed;
541	}
542
543
544	static int Q40SetFormat(int format)
545	{
546	/* Q40 sound supports only 8bit modes */
547
548	switch (format) {
549	case AFMT_QUERY:
550	return(dmasound.soft.format);
551	case AFMT_MU_LAW:
552	case AFMT_A_LAW:
553	case AFMT_S8:
554	case AFMT_U8:
555	break;
556	default:
557	format = AFMT_S8;
558	}
559
560	dmasound.soft.format = format;
561	dmasound.soft.size = 8;
562	if (dmasound.minDev == SND_DEV_DSP) {
563	dmasound.dsp.format = format;
564	dmasound.dsp.size = 8;
565	}
566	Q40Init();
567
568	return(format);
569	}
570
571	static int Q40SetVolume(int volume)
572	{
573	return 0;
574	}
575
576
577	/* Machine definitions ***************************************************/
578
579	static SETTINGS def_hard = {
580	.format = AFMT_U8,
581	.stereo = 0,
582	.size = 8,
583	.speed = 10000
584	} ;
585
586	static SETTINGS def_soft = {
587	.format = AFMT_U8,
588	.stereo = 0,
589	.size = 8,
590	.speed = 8000
591	} ;
592
593	static MACHINE machQ40 = {
594	.name = "Q40",
595	.name2 = "Q40",
596	.owner = THIS_MODULE,
597	.dma_alloc = Q40Alloc,
598	.dma_free = Q40Free,
599	.irqinit = Q40IrqInit,
600	#ifdef MODULE
601	.irqcleanup = Q40IrqCleanUp,
602	#endif /* MODULE */
603	.init = Q40Init,
604	.silence = Q40Silence,
605	.setFormat = Q40SetFormat,
606	.setVolume = Q40SetVolume,
607	.play = Q40Play,
608	.min_dsp_speed = 10000,
609	.version = ((DMASOUND_Q40_REVISION<<8) \| DMASOUND_Q40_EDITION),
610	.hardware_afmts = AFMT_U8, /* h'ware-supported formats only here */
611	.capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */
612	};
613
614
615	/* Config & Setup ********************************************************/
616
617
0a1b42db	618	static int __init dmasound_q40_init(void)
1da177e4 LT	619	{
	620	if (MACH_IS_Q40) {
	621	dmasound.mach = machQ40;
	622	dmasound.mach.default_hard = def_hard ;
	623	dmasound.mach.default_soft = def_soft ;
	624	return dmasound_init();
	625	} else
	626	return -ENODEV;
	627	}
	628
	629	static void __exit dmasound_q40_cleanup(void)
	630	{
	631	dmasound_deinit();
	632	}
	633
	634	module_init(dmasound_q40_init);
	635	module_exit(dmasound_q40_cleanup);
	636
	637	MODULE_DESCRIPTION("Q40/Q60 sound driver");
	638	MODULE_LICENSE("GPL");