Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
6581f4e7 | 26 | static int emu8000_reset_addr; |
1da177e4 LT |
27 | module_param(emu8000_reset_addr, int, 0444); |
28 | MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes slowdown)"); | |
29 | ||
30 | ||
31 | /* | |
32 | * Open up channels. | |
33 | */ | |
34 | static int | |
029d64b0 | 35 | snd_emu8000_open_dma(struct snd_emu8000 *emu, int write) |
1da177e4 LT |
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 | */ | |
61 | static void | |
029d64b0 | 62 | snd_emu8000_close_dma(struct snd_emu8000 *emu) |
1da177e4 LT |
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 | */ | |
84 | static unsigned short | |
85 | read_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 | */ | |
108 | static void | |
029d64b0 | 109 | snd_emu8000_write_wait(struct snd_emu8000 *emu) |
1da177e4 LT |
110 | { |
111 | while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) { | |
8433a509 | 112 | schedule_timeout_interruptible(1); |
1da177e4 LT |
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 | */ | |
77933d72 | 130 | static inline void |
029d64b0 | 131 | write_word(struct snd_emu8000 *emu, int *offset, unsigned short data) |
1da177e4 LT |
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 | */ | |
146 | int | |
029d64b0 TI |
147 | snd_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) | |
1da177e4 LT |
150 | { |
151 | int i; | |
152 | int rc; | |
153 | int offset; | |
154 | int truesize; | |
155 | int dram_offset, dram_start; | |
029d64b0 | 156 | struct snd_emu8000 *emu; |
1da177e4 LT |
157 | |
158 | emu = rec->hw; | |
622207dc TI |
159 | if (snd_BUG_ON(!sp)) |
160 | return -EINVAL; | |
1da177e4 LT |
161 | |
162 | if (sp->v.size == 0) | |
163 | return 0; | |
164 | ||
165 | /* be sure loop points start < end */ | |
166 | if (sp->v.loopstart > sp->v.loopend) { | |
167 | int tmp = sp->v.loopstart; | |
168 | sp->v.loopstart = sp->v.loopend; | |
169 | sp->v.loopend = tmp; | |
170 | } | |
171 | ||
172 | /* compute true data size to be loaded */ | |
173 | truesize = sp->v.size; | |
174 | if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP)) | |
175 | truesize += sp->v.loopend - sp->v.loopstart; | |
176 | if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) | |
177 | truesize += BLANK_LOOP_SIZE; | |
178 | ||
179 | sp->block = snd_util_mem_alloc(hdr, truesize * 2); | |
180 | if (sp->block == NULL) { | |
181 | /*snd_printd("EMU8000: out of memory\n");*/ | |
182 | /* not ENOMEM (for compatibility) */ | |
183 | return -ENOSPC; | |
184 | } | |
185 | ||
186 | if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS) { | |
187 | if (!access_ok(VERIFY_READ, data, sp->v.size)) | |
188 | return -EFAULT; | |
189 | } else { | |
190 | if (!access_ok(VERIFY_READ, data, sp->v.size * 2)) | |
191 | return -EFAULT; | |
192 | } | |
193 | ||
194 | /* recalculate address offset */ | |
195 | sp->v.end -= sp->v.start; | |
196 | sp->v.loopstart -= sp->v.start; | |
197 | sp->v.loopend -= sp->v.start; | |
198 | sp->v.start = 0; | |
199 | ||
200 | /* dram position (in word) -- mem_offset is byte */ | |
201 | dram_offset = EMU8000_DRAM_OFFSET + (sp->block->offset >> 1); | |
202 | dram_start = dram_offset; | |
203 | ||
204 | /* set the total size (store onto obsolete checksum value) */ | |
205 | sp->v.truesize = truesize * 2; /* in bytes */ | |
206 | ||
207 | snd_emux_terminate_all(emu->emu); | |
208 | if ((rc = snd_emu8000_open_dma(emu, EMU8000_RAM_WRITE)) != 0) | |
209 | return rc; | |
210 | ||
211 | /* Set the address to start writing at */ | |
212 | snd_emu8000_write_wait(emu); | |
213 | EMU8000_SMALW_WRITE(emu, dram_offset); | |
214 | ||
215 | /*snd_emu8000_init_fm(emu);*/ | |
216 | ||
217 | #if 0 | |
218 | /* first block - write 48 samples for silence */ | |
219 | if (! sp->block->offset) { | |
220 | for (i = 0; i < BLANK_HEAD_SIZE; i++) { | |
221 | write_word(emu, &dram_offset, 0); | |
222 | } | |
223 | } | |
224 | #endif | |
225 | ||
226 | offset = 0; | |
227 | for (i = 0; i < sp->v.size; i++) { | |
228 | unsigned short s; | |
229 | ||
230 | s = read_word(data, offset, sp->v.mode_flags); | |
231 | offset++; | |
232 | write_word(emu, &dram_offset, s); | |
233 | ||
234 | /* we may take too long time in this loop. | |
235 | * so give controls back to kernel if needed. | |
236 | */ | |
237 | cond_resched(); | |
238 | ||
239 | if (i == sp->v.loopend && | |
240 | (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP|SNDRV_SFNT_SAMPLE_REVERSE_LOOP))) | |
241 | { | |
242 | int looplen = sp->v.loopend - sp->v.loopstart; | |
243 | int k; | |
244 | ||
245 | /* copy reverse loop */ | |
246 | for (k = 1; k <= looplen; k++) { | |
247 | s = read_word(data, offset - k, sp->v.mode_flags); | |
248 | write_word(emu, &dram_offset, s); | |
249 | } | |
250 | if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_BIDIR_LOOP) { | |
251 | sp->v.loopend += looplen; | |
252 | } else { | |
253 | sp->v.loopstart += looplen; | |
254 | sp->v.loopend += looplen; | |
255 | } | |
256 | sp->v.end += looplen; | |
257 | } | |
258 | } | |
259 | ||
260 | /* if no blank loop is attached in the sample, add it */ | |
261 | if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) { | |
262 | for (i = 0; i < BLANK_LOOP_SIZE; i++) { | |
263 | write_word(emu, &dram_offset, 0); | |
264 | } | |
265 | if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) { | |
266 | sp->v.loopstart = sp->v.end + BLANK_LOOP_START; | |
267 | sp->v.loopend = sp->v.end + BLANK_LOOP_END; | |
268 | } | |
269 | } | |
270 | ||
271 | /* add dram offset */ | |
272 | sp->v.start += dram_start; | |
273 | sp->v.end += dram_start; | |
274 | sp->v.loopstart += dram_start; | |
275 | sp->v.loopend += dram_start; | |
276 | ||
277 | snd_emu8000_close_dma(emu); | |
278 | snd_emu8000_init_fm(emu); | |
279 | ||
280 | return 0; | |
281 | } | |
282 | ||
283 | /* | |
284 | * free a sample block | |
285 | */ | |
286 | int | |
029d64b0 TI |
287 | snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, |
288 | struct snd_util_memhdr *hdr) | |
1da177e4 LT |
289 | { |
290 | if (sp->block) { | |
291 | snd_util_mem_free(hdr, sp->block); | |
292 | sp->block = NULL; | |
293 | } | |
294 | return 0; | |
295 | } | |
296 | ||
297 | ||
298 | /* | |
299 | * sample_reset callback - terminate voices | |
300 | */ | |
301 | void | |
029d64b0 | 302 | snd_emu8000_sample_reset(struct snd_emux *rec) |
1da177e4 LT |
303 | { |
304 | snd_emux_terminate_all(rec); | |
305 | } |