[linux-2.6-block.git] / sound / oss / dmasound / dmasound_q40.c

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