[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / pci / emu10k1 / emu10k1_patch.c

/*
 *  Patch transfer callback for Emu10k1
 *
 *  Copyright (C) 2000 Takashi iwai <tiwai@suse.de>
 *
 *   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
 */
/*
 * All the code for loading in a patch.  There is very little that is
 * chip specific here.  Just the actual writing to the board.
 */

#include "emu10k1_synth_local.h"

/*
 */
#define BLANK_LOOP_START	4
#define BLANK_LOOP_END		8
#define BLANK_LOOP_SIZE		12
#define BLANK_HEAD_SIZE		32

/*
 * allocate a sample block and copy data from userspace
 */
int
snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp,
		       struct snd_util_memhdr *hdr,
		       const void __user *data, long count)
{
	int offset;
	int truesize, size, loopsize, blocksize;
	int loopend, sampleend;
	unsigned int start_addr;
	struct snd_emu10k1 *emu;

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

	if (sp->v.size == 0) {
		snd_printd("emu: rom font for sample %d\n", sp->v.sample);
		return 0;
	}

	/* 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;

	/* some samples have invalid data.  the addresses are corrected in voice info */
	sampleend = sp->v.end;
	if (sampleend > sp->v.size)
		sampleend = sp->v.size;
	loopend = sp->v.loopend;
	if (loopend > sampleend)
		loopend = sampleend;

	/* be sure loop points start < end */
	if (sp->v.loopstart >= sp->v.loopend) {
		int tmp = sp->v.loopstart;
		sp->v.loopstart = sp->v.loopend;
		sp->v.loopend = tmp;
	}

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

	/* try to allocate a memory block */
	blocksize = truesize;
	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
		blocksize *= 2;
	sp->block = snd_emu10k1_synth_alloc(emu, blocksize);
	if (sp->block == NULL) {
		snd_printd("emu10k1: synth malloc failed (size=%d)\n", blocksize);
		/* not ENOMEM (for compatibility with OSS) */
		return -ENOSPC;
	}
	/* set the total size */
	sp->v.truesize = blocksize;

	/* write blank samples at head */
	offset = 0;
	size = BLANK_HEAD_SIZE;
	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
		size *= 2;
	if (offset + size > blocksize)
		return -EINVAL;
	snd_emu10k1_synth_bzero(emu, sp->block, offset, size);
	offset += size;

	/* copy start->loopend */
	size = loopend;
	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
		size *= 2;
	if (offset + size > blocksize)
		return -EINVAL;
	if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
		snd_emu10k1_synth_free(emu, sp->block);
		sp->block = NULL;
		return -EFAULT;
	}
	offset += size;
	data += size;

#if 0 /* not supported yet */
	/* handle reverse (or bidirectional) loop */
	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)) {
		/* copy loop in reverse */
		if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
			int woffset;
			unsigned short *wblock = (unsigned short*)block;
			woffset = offset / 2;
			if (offset + loopsize * 2 > blocksize)
				return -EINVAL;
			for (i = 0; i < loopsize; i++)
				wblock[woffset + i] = wblock[woffset - i -1];
			offset += loopsize * 2;
		} else {
			if (offset + loopsize > blocksize)
				return -EINVAL;
			for (i = 0; i < loopsize; i++)
				block[offset + i] = block[offset - i -1];
			offset += loopsize;
		}

		/* modify loop pointers */
		if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
			sp->v.loopend += loopsize;
		} else {
			sp->v.loopstart += loopsize;
			sp->v.loopend += loopsize;
		}
		/* add sample pointer */
		sp->v.end += loopsize;
	}
#endif

	/* loopend -> sample end */
	size = sp->v.size - loopend;
	if (size < 0)
		return -EINVAL;
	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
		size *= 2;
	if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
		snd_emu10k1_synth_free(emu, sp->block);
		sp->block = NULL;
		return -EFAULT;
	}
	offset += size;

	/* clear rest of samples (if any) */
	if (offset < blocksize)
		snd_emu10k1_synth_bzero(emu, sp->block, offset, blocksize - offset);

	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
		/* if no blank loop is attached in the sample, add it */
		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;
		}
	}

#if 0 /* not supported yet */
	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_UNSIGNED) {
		/* unsigned -> signed */
		if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
			unsigned short *wblock = (unsigned short*)block;
			for (i = 0; i < truesize; i++)
				wblock[i] ^= 0x8000;
		} else {
			for (i = 0; i < truesize; i++)
				block[i] ^= 0x80;
		}
	}
#endif

	/* recalculate offset */
	start_addr = BLANK_HEAD_SIZE * 2;
	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
		start_addr >>= 1;
	sp->v.start += start_addr;
	sp->v.end += start_addr;
	sp->v.loopstart += start_addr;
	sp->v.loopend += start_addr;

	return 0;
}

/*
 * free a sample block
 */
int
snd_emu10k1_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp,
			struct snd_util_memhdr *hdr)
{
	struct snd_emu10k1 *emu;

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

	if (sp->block) {
		snd_emu10k1_synth_free(emu, sp->block);
		sp->block = NULL;
	}
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Patch transfer callback for Emu10k1
	3	*
	4	* Copyright (C) 2000 Takashi iwai <tiwai@suse.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20	/*
	21	* All the code for loading in a patch. There is very little that is
	22	* chip specific here. Just the actual writing to the board.
	23	*/
	24
	25	#include "emu10k1_synth_local.h"
	26
	27	/*
	28	*/
	29	#define BLANK_LOOP_START 4
	30	#define BLANK_LOOP_END 8
	31	#define BLANK_LOOP_SIZE 12
	32	#define BLANK_HEAD_SIZE 32
	33
	34	/*
	35	* allocate a sample block and copy data from userspace
	36	*/
	37	int
eb4698f3 TI	38	snd_emu10k1_sample_new(struct snd_emux rec, struct snd_sf_sample sp,
	39	struct snd_util_memhdr *hdr,
	40	const void __user *data, long count)
1da177e4 LT	41	{
	42	int offset;
	43	int truesize, size, loopsize, blocksize;
	44	int loopend, sampleend;
	45	unsigned int start_addr;
eb4698f3	46	struct snd_emu10k1 *emu;
1da177e4 LT	47
1da177e4 LT	48	emu = rec->hw;
da3cec35 TI	49	if (snd_BUG_ON(!sp \|\| !hdr))
da3cec35 TI	50	return -EINVAL;
1da177e4 LT	51
	52	if (sp->v.size == 0) {
	53	snd_printd("emu: rom font for sample %d\n", sp->v.sample);
	54	return 0;
	55	}
	56
	57	/* recalculate address offset */
	58	sp->v.end -= sp->v.start;
	59	sp->v.loopstart -= sp->v.start;
	60	sp->v.loopend -= sp->v.start;
	61	sp->v.start = 0;
	62
	63	/* some samples have invalid data. the addresses are corrected in voice info */
	64	sampleend = sp->v.end;
	65	if (sampleend > sp->v.size)
	66	sampleend = sp->v.size;
	67	loopend = sp->v.loopend;
	68	if (loopend > sampleend)
	69	loopend = sampleend;
	70
	71	/* be sure loop points start < end */
	72	if (sp->v.loopstart >= sp->v.loopend) {
	73	int tmp = sp->v.loopstart;
	74	sp->v.loopstart = sp->v.loopend;
	75	sp->v.loopend = tmp;
	76	}
	77
	78	/* compute true data size to be loaded */
	79	truesize = sp->v.size + BLANK_HEAD_SIZE;
	80	loopsize = 0;
	81	#if 0 /* not supported */
	82	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))
	83	loopsize = sp->v.loopend - sp->v.loopstart;
	84	truesize += loopsize;
	85	#endif
	86	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK)
	87	truesize += BLANK_LOOP_SIZE;
	88
	89	/* try to allocate a memory block */
	90	blocksize = truesize;
	91	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
	92	blocksize *= 2;
	93	sp->block = snd_emu10k1_synth_alloc(emu, blocksize);
	94	if (sp->block == NULL) {
	95	snd_printd("emu10k1: synth malloc failed (size=%d)\n", blocksize);
	96	/* not ENOMEM (for compatibility with OSS) */
	97	return -ENOSPC;
	98	}
	99	/* set the total size */
	100	sp->v.truesize = blocksize;
	101
	102	/* write blank samples at head */
	103	offset = 0;
	104	size = BLANK_HEAD_SIZE;
	105	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
	106	size *= 2;
da3cec35 TI	107	if (offset + size > blocksize)
da3cec35 TI	108	return -EINVAL;
1da177e4 LT	109	snd_emu10k1_synth_bzero(emu, sp->block, offset, size);
	110	offset += size;
	111
	112	/* copy start->loopend */
	113	size = loopend;
	114	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
	115	size *= 2;
da3cec35 TI	116	if (offset + size > blocksize)
da3cec35 TI	117	return -EINVAL;
1da177e4 LT	118	if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
	119	snd_emu10k1_synth_free(emu, sp->block);
	120	sp->block = NULL;
	121	return -EFAULT;
	122	}
	123	offset += size;
	124	data += size;
	125
d7558148	126	#if 0 /* not supported yet */
1da177e4 LT	127	/* handle reverse (or bidirectional) loop */
	128	if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP\|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)) {
	129	/* copy loop in reverse */
	130	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
	131	int woffset;
	132	unsigned short wblock = (unsigned short)block;
	133	woffset = offset / 2;
da3cec35 TI	134	if (offset + loopsize * 2 > blocksize)
da3cec35 TI	135	return -EINVAL;
1da177e4 LT	136	for (i = 0; i < loopsize; i++)
	137	wblock[woffset + i] = wblock[woffset - i -1];
	138	offset += loopsize * 2;
	139	} else {
da3cec35 TI	140	if (offset + loopsize > blocksize)
da3cec35 TI	141	return -EINVAL;
1da177e4 LT	142	for (i = 0; i < loopsize; i++)
	143	block[offset + i] = block[offset - i -1];
	144	offset += loopsize;
	145	}
	146
	147	/* modify loop pointers */
	148	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) {
	149	sp->v.loopend += loopsize;
	150	} else {
	151	sp->v.loopstart += loopsize;
	152	sp->v.loopend += loopsize;
	153	}
	154	/* add sample pointer */
	155	sp->v.end += loopsize;
	156	}
	157	#endif
	158
	159	/* loopend -> sample end */
	160	size = sp->v.size - loopend;
da3cec35 TI	161	if (size < 0)
da3cec35 TI	162	return -EINVAL;
1da177e4 LT	163	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
	164	size *= 2;
	165	if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) {
	166	snd_emu10k1_synth_free(emu, sp->block);
	167	sp->block = NULL;
	168	return -EFAULT;
	169	}
	170	offset += size;
	171
	172	/* clear rest of samples (if any) */
	173	if (offset < blocksize)
	174	snd_emu10k1_synth_bzero(emu, sp->block, offset, blocksize - offset);
	175
	176	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) {
	177	/* if no blank loop is attached in the sample, add it */
	178	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) {
	179	sp->v.loopstart = sp->v.end + BLANK_LOOP_START;
	180	sp->v.loopend = sp->v.end + BLANK_LOOP_END;
	181	}
	182	}
	183
	184	#if 0 /* not supported yet */
	185	if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_UNSIGNED) {
	186	/* unsigned -> signed */
	187	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS)) {
	188	unsigned short wblock = (unsigned short)block;
	189	for (i = 0; i < truesize; i++)
	190	wblock[i] ^= 0x8000;
	191	} else {
	192	for (i = 0; i < truesize; i++)
	193	block[i] ^= 0x80;
	194	}
	195	}
	196	#endif
	197
	198	/* recalculate offset */
	199	start_addr = BLANK_HEAD_SIZE * 2;
	200	if (! (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS))
	201	start_addr >>= 1;
	202	sp->v.start += start_addr;
	203	sp->v.end += start_addr;
	204	sp->v.loopstart += start_addr;
	205	sp->v.loopend += start_addr;
	206
	207	return 0;
	208	}
	209
	210	/*
	211	* free a sample block
	212	*/
	213	int
eb4698f3 TI	214	snd_emu10k1_sample_free(struct snd_emux rec, struct snd_sf_sample sp,
eb4698f3 TI	215	struct snd_util_memhdr *hdr)
1da177e4	216	{
eb4698f3	217	struct snd_emu10k1 *emu;
1da177e4 LT	218
1da177e4 LT	219	emu = rec->hw;
da3cec35 TI	220	if (snd_BUG_ON(!sp \|\| !hdr))
da3cec35 TI	221	return -EINVAL;
1da177e4 LT	222
	223	if (sp->block) {
	224	snd_emu10k1_synth_free(emu, sp->block);
	225	sp->block = NULL;
	226	}
	227	return 0;
	228	}
	229