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