[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;

	if (sp->v.size == 0)
		return 0;

	/* be sure loop points start < end */
	if (sp->v.loopstart > sp->v.loopend)
		swap(sp->v.loopstart, sp->v.loopend);

	/* 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) {
		/*snd_printd("EMU8000: out of memory\n");*/
		/* 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;
	}

	/* recalculate address offset */
	sp->v.end -= sp->v.start;
	sp->v.loopstart -= sp->v.start;
	sp->v.loopend -= sp->v.start;
	sp->v.start = 0;

	/* 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 LT	150
	151	if (sp->v.size == 0)
	152	return 0;
	153
	154	/* be sure loop points start < end */
7373c2a9 GS	155	if (sp->v.loopstart > sp->v.loopend)
7373c2a9 GS	156	swap(sp->v.loopstart, sp->v.loopend);
1da177e4 LT	157
	158	/* compute true data size to be loaded */
	159	truesize = sp->v.size;
	160	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))
	161	truesize += sp->v.loopend - sp->v.loopstart;
	162	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK)
	163	truesize += BLANK_LOOP_SIZE;
	164
	165	sp->block = snd_util_mem_alloc(hdr, truesize * 2);
	166	if (sp->block == NULL) {
	167	/snd_printd("EMU8000: out of memory\n");/
	168	/* not ENOMEM (for compatibility) */
	169	return -ENOSPC;
	170	}
	171
	172	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS) {
96d4f267	173	if (!access_ok(data, sp->v.size))
1da177e4 LT	174	return -EFAULT;
1da177e4 LT	175	} else {
96d4f267	176	if (!access_ok(data, sp->v.size * 2))
1da177e4 LT	177	return -EFAULT;
	178	}
	179
	180	/* recalculate address offset */
	181	sp->v.end -= sp->v.start;
	182	sp->v.loopstart -= sp->v.start;
	183	sp->v.loopend -= sp->v.start;
	184	sp->v.start = 0;
	185
	186	/* dram position (in word) -- mem_offset is byte */
	187	dram_offset = EMU8000_DRAM_OFFSET + (sp->block->offset >> 1);
	188	dram_start = dram_offset;
	189
	190	/* set the total size (store onto obsolete checksum value) */
	191	sp->v.truesize = truesize * 2; /* in bytes */
	192
	193	snd_emux_terminate_all(emu->emu);
10dc8ad5 TI	194	rc = snd_emu8000_open_dma(emu, EMU8000_RAM_WRITE);
10dc8ad5 TI	195	if (rc)
1da177e4 LT	196	return rc;
	197
	198	/* Set the address to start writing at */
	199	snd_emu8000_write_wait(emu);
	200	EMU8000_SMALW_WRITE(emu, dram_offset);
	201
	202	/snd_emu8000_init_fm(emu);/
	203
	204	#if 0
	205	/* first block - write 48 samples for silence */
	206	if (! sp->block->offset) {
	207	for (i = 0; i < BLANK_HEAD_SIZE; i++) {
	208	write_word(emu, &dram_offset, 0);
	209	}
	210	}
	211	#endif
	212
	213	offset = 0;
	214	for (i = 0; i < sp->v.size; i++) {
	215	unsigned short s;
	216
	217	s = read_word(data, offset, sp->v.mode_flags);
	218	offset++;
	219	write_word(emu, &dram_offset, s);
	220
	221	/* we may take too long time in this loop.
	222	* so give controls back to kernel if needed.
	223	*/
	224	cond_resched();
	225
	226	if (i == sp->v.loopend &&
	227	(sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)))
	228	{
	229	int looplen = sp->v.loopend - sp->v.loopstart;
	230	int k;
	231
	232	/* copy reverse loop */
	233	for (k = 1; k <= looplen; k++) {
	234	s = read_word(data, offset - k, sp->v.mode_flags);
	235	write_word(emu, &dram_offset, s);
	236	}
	237	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
	238	sp->v.loopend += looplen;
	239	} else {
	240	sp->v.loopstart += looplen;
	241	sp->v.loopend += looplen;
	242	}
	243	sp->v.end += looplen;
	244	}
	245	}
	246
	247	/* if no blank loop is attached in the sample, add it */
	248	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
	249	for (i = 0; i < BLANK_LOOP_SIZE; i++) {
	250	write_word(emu, &dram_offset, 0);
	251	}
	252	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) {
	253	sp->v.loopstart = sp->v.end + BLANK_LOOP_START;
	254	sp->v.loopend = sp->v.end + BLANK_LOOP_END;
	255	}
	256	}
	257
	258	/* add dram offset */
	259	sp->v.start += dram_start;
260	sp->v.end += dram_start;
261	sp->v.loopstart += dram_start;
262	sp->v.loopend += dram_start;
263
264	snd_emu8000_close_dma(emu);
265	snd_emu8000_init_fm(emu);
266
267	return 0;
268	}
269
270	/*
271	* free a sample block
272	*/
273	int
029d64b0 TI	274	snd_emu8000_sample_free(struct snd_emux rec, struct snd_sf_sample sp,
029d64b0 TI	275	struct snd_util_memhdr *hdr)
1da177e4 LT	276	{
	277	if (sp->block) {
	278	snd_util_mem_free(hdr, sp->block);
	279	sp->block = NULL;
	280	}
	281	return 0;
	282	}
	283
	284
	285	/*
	286	* sample_reset callback - terminate voices
	287	*/
	288	void
029d64b0	289	snd_emu8000_sample_reset(struct snd_emux *rec)
1da177e4 LT	290	{
	291	snd_emux_terminate_all(rec);
	292	}