2 * GF1 (GUS) Patch - Instrument routines
3 * Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <sound/driver.h>
22 #include <linux/init.h>
23 #include <linux/sched.h>
24 #include <linux/slab.h>
25 #include <sound/core.h>
26 #include <sound/ainstr_gf1.h>
27 #include <sound/initval.h>
28 #include <asm/uaccess.h>
30 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
31 MODULE_DESCRIPTION("Advanced Linux Sound Architecture GF1 (GUS) Patch support.");
32 MODULE_LICENSE("GPL");
33 MODULE_CLASSES("{sound}");
34 MODULE_SUPPORTED_DEVICE("sound");
36 char *snd_seq_gf1_id = SNDRV_SEQ_INSTR_ID_GUS_PATCH;
38 static unsigned int snd_seq_gf1_size(unsigned int size, unsigned int format)
40 unsigned int result = size;
42 if (format & GF1_WAVE_16BIT)
44 if (format & GF1_WAVE_STEREO)
49 static int snd_seq_gf1_copy_wave_from_stream(snd_gf1_ops_t *ops,
55 gf1_wave_t *wp, *prev;
58 unsigned int real_size;
60 gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
61 if (*len < (long)sizeof(xp))
63 if (copy_from_user(&xp, *data, sizeof(xp)))
67 wp = (gf1_wave_t *)snd_kcalloc(sizeof(*wp), gfp_mask);
70 wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
71 wp->share_id[1] = le32_to_cpu(xp.share_id[1]);
72 wp->share_id[2] = le32_to_cpu(xp.share_id[2]);
73 wp->share_id[3] = le32_to_cpu(xp.share_id[3]);
74 wp->format = le32_to_cpu(xp.format);
75 wp->size = le32_to_cpu(xp.size);
76 wp->start = le32_to_cpu(xp.start);
77 wp->loop_start = le32_to_cpu(xp.loop_start);
78 wp->loop_end = le32_to_cpu(xp.loop_end);
79 wp->loop_repeat = le16_to_cpu(xp.loop_repeat);
81 wp->sample_rate = le32_to_cpu(xp.sample_rate);
82 wp->low_frequency = le32_to_cpu(xp.low_frequency);
83 wp->high_frequency = le32_to_cpu(xp.high_frequency);
84 wp->root_frequency = le32_to_cpu(xp.root_frequency);
85 wp->tune = le16_to_cpu(xp.tune);
86 wp->balance = xp.balance;
87 memcpy(wp->envelope_rate, xp.envelope_rate, 6);
88 memcpy(wp->envelope_offset, xp.envelope_offset, 6);
89 wp->tremolo_sweep = xp.tremolo_sweep;
90 wp->tremolo_rate = xp.tremolo_rate;
91 wp->tremolo_depth = xp.tremolo_depth;
92 wp->vibrato_sweep = xp.vibrato_sweep;
93 wp->vibrato_rate = xp.vibrato_rate;
94 wp->vibrato_depth = xp.vibrato_depth;
95 wp->scale_frequency = le16_to_cpu(xp.scale_frequency);
96 wp->scale_factor = le16_to_cpu(xp.scale_factor);
97 real_size = snd_seq_gf1_size(wp->size, wp->format);
98 if ((long)real_size > *len) {
102 if (ops->put_sample) {
103 err = ops->put_sample(ops->private_data, wp,
104 *data, real_size, atomic);
114 while (prev->next) prev = prev->next;
122 static void snd_seq_gf1_wave_free(snd_gf1_ops_t *ops,
126 if (ops->remove_sample)
127 ops->remove_sample(ops->private_data, wave, atomic);
131 static void snd_seq_gf1_instr_free(snd_gf1_ops_t *ops,
132 gf1_instrument_t *ip,
137 while ((wave = ip->wave) != NULL) {
138 ip->wave = wave->next;
139 snd_seq_gf1_wave_free(ops, wave, atomic);
143 static int snd_seq_gf1_put(void *private_data, snd_seq_kinstr_t *instr,
144 char *instr_data, long len, int atomic, int cmd)
146 snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data;
147 gf1_instrument_t *ip;
148 gf1_xinstrument_t ix;
151 if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
153 gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
154 /* copy instrument data */
155 if (len < (long)sizeof(ix))
157 if (copy_from_user(&ix, instr_data, sizeof(ix)))
159 if (ix.stype != GF1_STRU_INSTR)
161 instr_data += sizeof(ix);
163 ip = (gf1_instrument_t *)KINSTR_DATA(instr);
164 ip->exclusion = le16_to_cpu(ix.exclusion);
165 ip->exclusion_group = le16_to_cpu(ix.exclusion_group);
166 ip->effect1 = ix.effect1;
167 ip->effect1_depth = ix.effect1_depth;
168 ip->effect2 = ix.effect2;
169 ip->effect2_depth = ix.effect2_depth;
171 while (len > (long)sizeof(__u32)) {
174 if (copy_from_user(&stype, instr_data, sizeof(stype)))
176 if (stype != GF1_STRU_WAVE) {
177 snd_seq_gf1_instr_free(ops, ip, atomic);
180 err = snd_seq_gf1_copy_wave_from_stream(ops,
186 snd_seq_gf1_instr_free(ops, ip, atomic);
193 static int snd_seq_gf1_copy_wave_to_stream(snd_gf1_ops_t *ops,
194 gf1_instrument_t *ip,
202 unsigned int real_size;
204 for (wp = ip->wave; wp; wp = wp->next) {
205 if (*len < (long)sizeof(xp))
207 memset(&xp, 0, sizeof(xp));
208 xp.stype = GF1_STRU_WAVE;
209 xp.share_id[0] = cpu_to_le32(wp->share_id[0]);
210 xp.share_id[1] = cpu_to_le32(wp->share_id[1]);
211 xp.share_id[2] = cpu_to_le32(wp->share_id[2]);
212 xp.share_id[3] = cpu_to_le32(wp->share_id[3]);
213 xp.format = cpu_to_le32(wp->format);
214 xp.size = cpu_to_le32(wp->size);
215 xp.start = cpu_to_le32(wp->start);
216 xp.loop_start = cpu_to_le32(wp->loop_start);
217 xp.loop_end = cpu_to_le32(wp->loop_end);
218 xp.loop_repeat = cpu_to_le32(wp->loop_repeat);
219 xp.flags = wp->flags;
220 xp.sample_rate = cpu_to_le32(wp->sample_rate);
221 xp.low_frequency = cpu_to_le32(wp->low_frequency);
222 xp.high_frequency = cpu_to_le32(wp->high_frequency);
223 xp.root_frequency = cpu_to_le32(wp->root_frequency);
224 xp.tune = cpu_to_le16(wp->tune);
225 xp.balance = wp->balance;
226 memcpy(xp.envelope_rate, wp->envelope_rate, 6);
227 memcpy(xp.envelope_offset, wp->envelope_offset, 6);
228 xp.tremolo_sweep = wp->tremolo_sweep;
229 xp.tremolo_rate = wp->tremolo_rate;
230 xp.tremolo_depth = wp->tremolo_depth;
231 xp.vibrato_sweep = wp->vibrato_sweep;
232 xp.vibrato_rate = wp->vibrato_rate;
233 xp.vibrato_depth = wp->vibrato_depth;
234 xp.scale_frequency = cpu_to_le16(wp->scale_frequency);
235 xp.scale_factor = cpu_to_le16(wp->scale_factor);
236 if (copy_to_user(*data, &xp, sizeof(xp)))
240 real_size = snd_seq_gf1_size(wp->size, wp->format);
241 if (*len < (long)real_size)
243 if (ops->get_sample) {
244 err = ops->get_sample(ops->private_data, wp,
245 *data, real_size, atomic);
255 static int snd_seq_gf1_get(void *private_data, snd_seq_kinstr_t *instr,
256 char *instr_data, long len, int atomic, int cmd)
258 snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data;
259 gf1_instrument_t *ip;
260 gf1_xinstrument_t ix;
262 if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
264 if (len < (long)sizeof(ix))
266 memset(&ix, 0, sizeof(ix));
267 ip = (gf1_instrument_t *)KINSTR_DATA(instr);
268 ix.stype = GF1_STRU_INSTR;
269 ix.exclusion = cpu_to_le16(ip->exclusion);
270 ix.exclusion_group = cpu_to_le16(ip->exclusion_group);
271 ix.effect1 = cpu_to_le16(ip->effect1);
272 ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
273 ix.effect2 = ip->effect2;
274 ix.effect2_depth = ip->effect2_depth;
275 if (copy_to_user(instr_data, &ix, sizeof(ix)))
277 instr_data += sizeof(ix);
279 return snd_seq_gf1_copy_wave_to_stream(ops,
286 static int snd_seq_gf1_get_size(void *private_data, snd_seq_kinstr_t *instr,
290 gf1_instrument_t *ip;
294 ip = (gf1_instrument_t *)KINSTR_DATA(instr);
295 result = sizeof(gf1_xinstrument_t);
296 for (wp = ip->wave; wp; wp = wp->next) {
297 result += sizeof(gf1_xwave_t);
304 static int snd_seq_gf1_remove(void *private_data,
305 snd_seq_kinstr_t *instr,
308 snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data;
309 gf1_instrument_t *ip;
311 ip = (gf1_instrument_t *)KINSTR_DATA(instr);
312 snd_seq_gf1_instr_free(ops, ip, atomic);
316 static void snd_seq_gf1_notify(void *private_data,
317 snd_seq_kinstr_t *instr,
320 snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data;
323 ops->notify(ops->private_data, instr, what);
326 int snd_seq_gf1_init(snd_gf1_ops_t *ops,
328 snd_seq_kinstr_ops_t *next)
330 memset(ops, 0, sizeof(*ops));
331 ops->private_data = private_data;
332 ops->kops.private_data = ops;
333 ops->kops.add_len = sizeof(gf1_instrument_t);
334 ops->kops.instr_type = snd_seq_gf1_id;
335 ops->kops.put = snd_seq_gf1_put;
336 ops->kops.get = snd_seq_gf1_get;
337 ops->kops.get_size = snd_seq_gf1_get_size;
338 ops->kops.remove = snd_seq_gf1_remove;
339 ops->kops.notify = snd_seq_gf1_notify;
340 ops->kops.next = next;
348 static int __init alsa_ainstr_gf1_init(void)
353 static void __exit alsa_ainstr_gf1_exit(void)
357 module_init(alsa_ainstr_gf1_init)
358 module_exit(alsa_ainstr_gf1_exit)
360 EXPORT_SYMBOL(snd_seq_gf1_id);
361 EXPORT_SYMBOL(snd_seq_gf1_init);