[linux-2.6-block.git] / sound / isa / sb / emu8000_patch.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Patch routines for the emu8000 (AWE32/64)
 *
 *  Copyright (C) 1999 Steve Ratcliffe
 *  Copyright (C) 1999-2000 Takashi Iwai <tiwai@suse.de>
 */

#include "emu8000_local.h"

#include <linux/sched/signal.h>
#include <linux/uaccess.h>
#include <linux/moduleparam.h>

static int emu8000_reset_addr;
module_param(emu8000_reset_addr, int, 0444);
MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes slowdown)");


/*
 * Open up channels.
 */
static int
snd_emu8000_open_dma(struct snd_emu8000 *emu, int write)
{
	int i;

	/* reserve all 30 voices for loading */
	for (i = 0; i < EMU8000_DRAM_VOICES; i++) {
		snd_emux_lock_voice(emu->emu, i);
		snd_emu8000_dma_chan(emu, i, write);
	}

	/* assign voice 31 and 32 to ROM */
	EMU8000_VTFT_WRITE(emu, 30, 0);
	EMU8000_PSST_WRITE(emu, 30, 0x1d8);
	EMU8000_CSL_WRITE(emu, 30, 0x1e0);
	EMU8000_CCCA_WRITE(emu, 30, 0x1d8);
	EMU8000_VTFT_WRITE(emu, 31, 0);
	EMU8000_PSST_WRITE(emu, 31, 0x1d8);
	EMU8000_CSL_WRITE(emu, 31, 0x1e0);
	EMU8000_CCCA_WRITE(emu, 31, 0x1d8);

	return 0;
}

/*
 * Close all dram channels.
 */
static void
snd_emu8000_close_dma(struct snd_emu8000 *emu)
{
	int i;

	for (i = 0; i < EMU8000_DRAM_VOICES; i++) {
		snd_emu8000_dma_chan(emu, i, EMU8000_RAM_CLOSE);
		snd_emux_unlock_voice(emu->emu, i);
	}
}

/*
 */

#define BLANK_LOOP_START	4
#define BLANK_LOOP_END		8
#define BLANK_LOOP_SIZE		12
#define BLANK_HEAD_SIZE		48

/*
 * Read a word from userland, taking care of conversions from
 * 8bit samples etc.
 */
static unsigned short
read_word(const void __user *buf, int offset, int mode)
{
	unsigned short c;
	if (mode & SNDRV_SFNT_SAMPLE_8BITS) {
		unsigned char cc;
		get_user(cc, (unsigned char __user *)buf + offset);
		c = cc << 8; /* convert 8bit -> 16bit */
	} else {
#ifdef SNDRV_LITTLE_ENDIAN
		get_user(c, (unsigned short __user *)buf + offset);
#else
		unsigned short cc;
		get_user(cc, (unsigned short __user *)buf + offset);
		c = swab16(cc);
#endif
	}
	if (mode & SNDRV_SFNT_SAMPLE_UNSIGNED)
		c ^= 0x8000; /* unsigned -> signed */
	return c;
}

/*
 */
static void
snd_emu8000_write_wait(struct snd_emu8000 *emu)
{
	while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
		schedule_timeout_interruptible(1);
		if (signal_pending(current))
			break;
	}
}

/*
 * write sample word data
 *
 * You should not have to keep resetting the address each time
 * as the chip is supposed to step on the next address automatically.
 * It mostly does, but during writes of some samples at random it
 * completely loses words (every one in 16 roughly but with no
 * obvious pattern).
 *
 * This is therefore much slower than need be, but is at least
 * working.
 */
static inline void
write_word(struct snd_emu8000 *emu, int *offset, unsigned short data)
{
	if (emu8000_reset_addr) {
		if (emu8000_reset_addr > 1)
			snd_emu8000_write_wait(emu);
		EMU8000_SMALW_WRITE(emu, *offset);
	}
	EMU8000_SMLD_WRITE(emu, data);
	*offset += 1;
}

/*
 * Write the sample to EMU800 memory.  This routine is invoked out of
 * the generic soundfont routines as a callback.
 */
int
snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
		       struct snd_util_memhdr *hdr,
		       const void __user *data, long count)
{
	int  i;
	int  rc;
	int  offset;
	int  truesize;
	int  dram_offset, dram_start;
	struct snd_emu8000 *emu;

	emu = rec->hw;
	if (snd_BUG_ON(!sp))
		return -EINVAL;

	/* compute true data size to be loaded */
	truesize = sp->v.size;
	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))
		truesize += sp->v.loopend - sp->v.loopstart;
	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK)
		truesize += BLANK_LOOP_SIZE;

	sp->block = snd_util_mem_alloc(hdr, truesize * 2);
	if (sp->block == NULL) {
		/* not ENOMEM (for compatibility) */
		return -ENOSPC;
	}

	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS) {
		if (!access_ok(data, sp->v.size))
			return -EFAULT;
	} else {
		if (!access_ok(data, sp->v.size * 2))
			return -EFAULT;
	}

	/* dram position (in word) -- mem_offset is byte */
	dram_offset = EMU8000_DRAM_OFFSET + (sp->block->offset >> 1);
	dram_start = dram_offset;

	/* set the total size (store onto obsolete checksum value) */
	sp->v.truesize = truesize * 2; /* in bytes */

	snd_emux_terminate_all(emu->emu);
	rc = snd_emu8000_open_dma(emu, EMU8000_RAM_WRITE);
	if (rc)
		return rc;

	/* Set the address to start writing at */
	snd_emu8000_write_wait(emu);
	EMU8000_SMALW_WRITE(emu, dram_offset);

	/*snd_emu8000_init_fm(emu);*/

#if 0
	/* first block - write 48 samples for silence */
	if (! sp->block->offset) {
		for (i = 0; i < BLANK_HEAD_SIZE; i++) {
			write_word(emu, &dram_offset, 0);
		}
	}
#endif

	offset = 0;
	for (i = 0; i < sp->v.size; i++) {
		unsigned short s;

		s = read_word(data, offset, sp->v.mode_flags);
		offset++;
		write_word(emu, &dram_offset, s);

		/* we may take too long time in this loop.
		 * so give controls back to kernel if needed.
		 */
		cond_resched();

		if (i == sp->v.loopend &&
		    (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)))
		{
			int looplen = sp->v.loopend - sp->v.loopstart;
			int k;

			/* copy reverse loop */
			for (k = 1; k <= looplen; k++) {
				s = read_word(data, offset - k, sp->v.mode_flags);
				write_word(emu, &dram_offset, s);
			}
			if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
				sp->v.loopend += looplen;
			} else {
				sp->v.loopstart += looplen;
				sp->v.loopend += looplen;
			}
			sp->v.end += looplen;
		}
	}

	/* if no blank loop is attached in the sample, add it */
	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
		for (i = 0; i < BLANK_LOOP_SIZE; i++) {
			write_word(emu, &dram_offset, 0);
		}
		if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) {
			sp->v.loopstart = sp->v.end + BLANK_LOOP_START;
			sp->v.loopend = sp->v.end + BLANK_LOOP_END;
		}
	}

	/* add dram offset */
	sp->v.start += dram_start;
	sp->v.end += dram_start;
	sp->v.loopstart += dram_start;
	sp->v.loopend += dram_start;

	snd_emu8000_close_dma(emu);
	snd_emu8000_init_fm(emu);

	return 0;
}

/*
 * free a sample block
 */
int
snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp,
			struct snd_util_memhdr *hdr)
{
	if (sp->block) {
		snd_util_mem_free(hdr, sp->block);
		sp->block = NULL;
	}
	return 0;
}


/*
 * sample_reset callback - terminate voices
 */
void
snd_emu8000_sample_reset(struct snd_emux *rec)
{
	snd_emux_terminate_all(rec);
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* Patch routines for the emu8000 (AWE32/64)
	4	*
	5	* Copyright (C) 1999 Steve Ratcliffe
	6	* Copyright (C) 1999-2000 Takashi Iwai <tiwai@suse.de>
1da177e4 LT	7	*/
	8
	9	#include "emu8000_local.h"
174cd4b1 IM	10
174cd4b1 IM	11	#include <linux/sched/signal.h>
976412fb	12	#include <linux/uaccess.h>
1da177e4 LT	13	#include <linux/moduleparam.h>
1da177e4 LT	14
6581f4e7	15	static int emu8000_reset_addr;
1da177e4 LT	16	module_param(emu8000_reset_addr, int, 0444);
	17	MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes slowdown)");
	18
	19
	20	/*
	21	* Open up channels.
	22	*/
	23	static int
029d64b0	24	snd_emu8000_open_dma(struct snd_emu8000 *emu, int write)
1da177e4 LT	25	{
	26	int i;
	27
	28	/* reserve all 30 voices for loading */
	29	for (i = 0; i < EMU8000_DRAM_VOICES; i++) {
	30	snd_emux_lock_voice(emu->emu, i);
	31	snd_emu8000_dma_chan(emu, i, write);
	32	}
	33
	34	/* assign voice 31 and 32 to ROM */
	35	EMU8000_VTFT_WRITE(emu, 30, 0);
	36	EMU8000_PSST_WRITE(emu, 30, 0x1d8);
	37	EMU8000_CSL_WRITE(emu, 30, 0x1e0);
	38	EMU8000_CCCA_WRITE(emu, 30, 0x1d8);
	39	EMU8000_VTFT_WRITE(emu, 31, 0);
	40	EMU8000_PSST_WRITE(emu, 31, 0x1d8);
	41	EMU8000_CSL_WRITE(emu, 31, 0x1e0);
	42	EMU8000_CCCA_WRITE(emu, 31, 0x1d8);
	43
	44	return 0;
	45	}
	46
	47	/*
	48	* Close all dram channels.
	49	*/
	50	static void
029d64b0	51	snd_emu8000_close_dma(struct snd_emu8000 *emu)
1da177e4 LT	52	{
	53	int i;
	54
	55	for (i = 0; i < EMU8000_DRAM_VOICES; i++) {
	56	snd_emu8000_dma_chan(emu, i, EMU8000_RAM_CLOSE);
	57	snd_emux_unlock_voice(emu->emu, i);
	58	}
	59	}
	60
	61	/*
	62	*/
	63
	64	#define BLANK_LOOP_START 4
	65	#define BLANK_LOOP_END 8
	66	#define BLANK_LOOP_SIZE 12
	67	#define BLANK_HEAD_SIZE 48
	68
	69	/*
	70	* Read a word from userland, taking care of conversions from
	71	* 8bit samples etc.
	72	*/
	73	static unsigned short
	74	read_word(const void __user *buf, int offset, int mode)
	75	{
	76	unsigned short c;
	77	if (mode & SNDRV_SFNT_SAMPLE_8BITS) {
	78	unsigned char cc;
	79	get_user(cc, (unsigned char __user *)buf + offset);
	80	c = cc << 8; /* convert 8bit -> 16bit */
	81	} else {
	82	#ifdef SNDRV_LITTLE_ENDIAN
	83	get_user(c, (unsigned short __user *)buf + offset);
	84	#else
	85	unsigned short cc;
	86	get_user(cc, (unsigned short __user *)buf + offset);
	87	c = swab16(cc);
	88	#endif
	89	}
	90	if (mode & SNDRV_SFNT_SAMPLE_UNSIGNED)
	91	c ^= 0x8000; /* unsigned -> signed */
	92	return c;
	93	}
	94
	95	/*
	96	*/
	97	static void
029d64b0	98	snd_emu8000_write_wait(struct snd_emu8000 *emu)
1da177e4 LT	99	{
1da177e4 LT	100	while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
8433a509	101	schedule_timeout_interruptible(1);
1da177e4 LT	102	if (signal_pending(current))
	103	break;
	104	}
	105	}
	106
	107	/*
	108	* write sample word data
	109	*
	110	* You should not have to keep resetting the address each time
	111	* as the chip is supposed to step on the next address automatically.
	112	* It mostly does, but during writes of some samples at random it
	113	* completely loses words (every one in 16 roughly but with no
	114	* obvious pattern).
	115	*
	116	* This is therefore much slower than need be, but is at least
	117	* working.
	118	*/
77933d72	119	static inline void
029d64b0	120	write_word(struct snd_emu8000 emu, int offset, unsigned short data)
1da177e4 LT	121	{
	122	if (emu8000_reset_addr) {
	123	if (emu8000_reset_addr > 1)
	124	snd_emu8000_write_wait(emu);
	125	EMU8000_SMALW_WRITE(emu, *offset);
	126	}
	127	EMU8000_SMLD_WRITE(emu, data);
	128	*offset += 1;
	129	}
	130
	131	/*
	132	* Write the sample to EMU800 memory. This routine is invoked out of
	133	* the generic soundfont routines as a callback.
	134	*/
	135	int
029d64b0 TI	136	snd_emu8000_sample_new(struct snd_emux rec, struct snd_sf_sample sp,
	137	struct snd_util_memhdr *hdr,
	138	const void __user *data, long count)
1da177e4 LT	139	{
	140	int i;
	141	int rc;
	142	int offset;
	143	int truesize;
	144	int dram_offset, dram_start;
029d64b0	145	struct snd_emu8000 *emu;
1da177e4 LT	146
1da177e4 LT	147	emu = rec->hw;
622207dc TI	148	if (snd_BUG_ON(!sp))
622207dc TI	149	return -EINVAL;
1da177e4	150
1da177e4 LT	151	/* compute true data size to be loaded */
	152	truesize = sp->v.size;
	153	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))
	154	truesize += sp->v.loopend - sp->v.loopstart;
	155	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK)
	156	truesize += BLANK_LOOP_SIZE;
	157
	158	sp->block = snd_util_mem_alloc(hdr, truesize * 2);
	159	if (sp->block == NULL) {
1da177e4 LT	160	/* not ENOMEM (for compatibility) */
	161	return -ENOSPC;
	162	}
	163
	164	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS) {
96d4f267	165	if (!access_ok(data, sp->v.size))
1da177e4 LT	166	return -EFAULT;
1da177e4 LT	167	} else {
96d4f267	168	if (!access_ok(data, sp->v.size * 2))
1da177e4 LT	169	return -EFAULT;
	170	}
	171
1da177e4 LT	172	/* dram position (in word) -- mem_offset is byte */
	173	dram_offset = EMU8000_DRAM_OFFSET + (sp->block->offset >> 1);
	174	dram_start = dram_offset;
	175
	176	/* set the total size (store onto obsolete checksum value) */
	177	sp->v.truesize = truesize * 2; /* in bytes */
	178
	179	snd_emux_terminate_all(emu->emu);
10dc8ad5 TI	180	rc = snd_emu8000_open_dma(emu, EMU8000_RAM_WRITE);
10dc8ad5 TI	181	if (rc)
1da177e4 LT	182	return rc;
	183
	184	/* Set the address to start writing at */
	185	snd_emu8000_write_wait(emu);
	186	EMU8000_SMALW_WRITE(emu, dram_offset);
	187
	188	/snd_emu8000_init_fm(emu);/
	189
	190	#if 0
	191	/* first block - write 48 samples for silence */
	192	if (! sp->block->offset) {
	193	for (i = 0; i < BLANK_HEAD_SIZE; i++) {
	194	write_word(emu, &dram_offset, 0);
	195	}
	196	}
	197	#endif
	198
	199	offset = 0;
	200	for (i = 0; i < sp->v.size; i++) {
	201	unsigned short s;
	202
	203	s = read_word(data, offset, sp->v.mode_flags);
	204	offset++;
	205	write_word(emu, &dram_offset, s);
	206
	207	/* we may take too long time in this loop.
	208	* so give controls back to kernel if needed.
	209	*/
	210	cond_resched();
	211
	212	if (i == sp->v.loopend &&
	213	(sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)))
	214	{
	215	int looplen = sp->v.loopend - sp->v.loopstart;
	216	int k;
	217
	218	/* copy reverse loop */
	219	for (k = 1; k <= looplen; k++) {
	220	s = read_word(data, offset - k, sp->v.mode_flags);
	221	write_word(emu, &dram_offset, s);
	222	}
	223	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
	224	sp->v.loopend += looplen;
	225	} else {
	226	sp->v.loopstart += looplen;
	227	sp->v.loopend += looplen;
	228	}
	229	sp->v.end += looplen;
	230	}
	231	}
	232
	233	/* if no blank loop is attached in the sample, add it */
	234	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
	235	for (i = 0; i < BLANK_LOOP_SIZE; i++) {
	236	write_word(emu, &dram_offset, 0);
	237	}
	238	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) {
	239	sp->v.loopstart = sp->v.end + BLANK_LOOP_START;
	240	sp->v.loopend = sp->v.end + BLANK_LOOP_END;
	241	}
	242	}
	243
	244	/* add dram offset */
	245	sp->v.start += dram_start;
246	sp->v.end += dram_start;
247	sp->v.loopstart += dram_start;
248	sp->v.loopend += dram_start;
249
250	snd_emu8000_close_dma(emu);
251	snd_emu8000_init_fm(emu);
252
253	return 0;
254	}
255
256	/*
257	* free a sample block
258	*/
259	int
029d64b0 TI	260	snd_emu8000_sample_free(struct snd_emux rec, struct snd_sf_sample sp,
029d64b0 TI	261	struct snd_util_memhdr *hdr)
1da177e4 LT	262	{
	263	if (sp->block) {
	264	snd_util_mem_free(hdr, sp->block);
	265	sp->block = NULL;
	266	}
	267	return 0;
	268	}
	269
	270
	271	/*
	272	* sample_reset callback - terminate voices
	273	*/
	274	void
029d64b0	275	snd_emu8000_sample_reset(struct snd_emux *rec)
1da177e4 LT	276	{
	277	snd_emux_terminate_all(rec);
	278	}