2 * IWFFFF - AMD InterWave (tm) - 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_iw.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 IWFFFF support.");
32 MODULE_LICENSE("GPL");
33 MODULE_CLASSES("{sound}");
34 MODULE_SUPPORTED_DEVICE("sound");
36 char *snd_seq_iwffff_id = SNDRV_SEQ_INSTR_ID_INTERWAVE;
38 static unsigned int snd_seq_iwffff_size(unsigned int size, unsigned int format)
40 unsigned int result = size;
42 if (format & IWFFFF_WAVE_16BIT)
44 if (format & IWFFFF_WAVE_STEREO)
49 static void snd_seq_iwffff_copy_lfo_from_stream(iwffff_lfo_t *fp,
52 fp->freq = le16_to_cpu(fx->freq);
53 fp->depth = le16_to_cpu(fx->depth);
54 fp->sweep = le16_to_cpu(fx->sweep);
55 fp->shape = fx->shape;
56 fp->delay = fx->delay;
59 static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype,
68 iwffff_env_record_t *rp, *rp_last;
69 iwffff_xenv_record_t rx;
70 iwffff_env_point_t *pp;
71 iwffff_xenv_point_t px;
74 ep->flags = ex->flags;
76 ep->index = ex->index;
79 if (*len < (long)sizeof(__u32))
81 if (copy_from_user(&stype, *data, sizeof(stype)))
83 if (stype == IWFFFF_STRU_WAVE)
85 if (req_stype != stype) {
86 if (stype == IWFFFF_STRU_ENV_RECP ||
87 stype == IWFFFF_STRU_ENV_RECV)
90 if (*len < (long)sizeof(rx))
92 if (copy_from_user(&rx, *data, sizeof(rx)))
96 points_size = (le16_to_cpu(rx.nattack) + le16_to_cpu(rx.nrelease)) * 2 * sizeof(__u16);
97 if (points_size > *len)
99 rp = (iwffff_env_record_t *)snd_kcalloc(sizeof(*rp) + points_size, gfp_mask);
102 rp->nattack = le16_to_cpu(rx.nattack);
103 rp->nrelease = le16_to_cpu(rx.nrelease);
104 rp->sustain_offset = le16_to_cpu(rx.sustain_offset);
105 rp->sustain_rate = le16_to_cpu(rx.sustain_rate);
106 rp->release_rate = le16_to_cpu(rx.release_rate);
107 rp->hirange = rx.hirange;
108 pp = (iwffff_env_point_t *)(rp + 1);
109 for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
110 if (copy_from_user(&px, *data, sizeof(px)))
114 pp->offset = le16_to_cpu(px.offset);
115 pp->rate = le16_to_cpu(px.rate);
117 if (ep->record == NULL) {
127 static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops,
133 iwffff_wave_t *wp, *prev;
136 unsigned int real_size;
138 gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
139 if (*len < (long)sizeof(xp))
141 if (copy_from_user(&xp, *data, sizeof(xp)))
145 wp = (iwffff_wave_t *)snd_kcalloc(sizeof(*wp), gfp_mask);
148 wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
149 wp->share_id[1] = le32_to_cpu(xp.share_id[1]);
150 wp->share_id[2] = le32_to_cpu(xp.share_id[2]);
151 wp->share_id[3] = le32_to_cpu(xp.share_id[3]);
152 wp->format = le32_to_cpu(xp.format);
153 wp->address.memory = le32_to_cpu(xp.offset);
154 wp->size = le32_to_cpu(xp.size);
155 wp->start = le32_to_cpu(xp.start);
156 wp->loop_start = le32_to_cpu(xp.loop_start);
157 wp->loop_end = le32_to_cpu(xp.loop_end);
158 wp->loop_repeat = le16_to_cpu(xp.loop_repeat);
159 wp->sample_ratio = le32_to_cpu(xp.sample_ratio);
160 wp->attenuation = xp.attenuation;
161 wp->low_note = xp.low_note;
162 wp->high_note = xp.high_note;
163 real_size = snd_seq_iwffff_size(wp->size, wp->format);
164 if (!(wp->format & IWFFFF_WAVE_ROM)) {
165 if ((long)real_size > *len) {
170 if (ops->put_sample) {
171 err = ops->put_sample(ops->private_data, wp,
172 *data, real_size, atomic);
178 if (!(wp->format & IWFFFF_WAVE_ROM)) {
184 while (prev->next) prev = prev->next;
192 static void snd_seq_iwffff_env_free(snd_iwffff_ops_t *ops,
196 iwffff_env_record_t *rec;
198 while ((rec = env->record) != NULL) {
199 env->record = rec->next;
204 static void snd_seq_iwffff_wave_free(snd_iwffff_ops_t *ops,
208 if (ops->remove_sample)
209 ops->remove_sample(ops->private_data, wave, atomic);
213 static void snd_seq_iwffff_instr_free(snd_iwffff_ops_t *ops,
214 iwffff_instrument_t *ip,
217 iwffff_layer_t *layer;
220 while ((layer = ip->layer) != NULL) {
221 ip->layer = layer->next;
222 snd_seq_iwffff_env_free(ops, &layer->penv, atomic);
223 snd_seq_iwffff_env_free(ops, &layer->venv, atomic);
224 while ((wave = layer->wave) != NULL) {
225 layer->wave = wave->next;
226 snd_seq_iwffff_wave_free(ops, wave, atomic);
232 static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr,
233 char __user *instr_data, long len, int atomic,
236 snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
237 iwffff_instrument_t *ip;
238 iwffff_xinstrument_t ix;
239 iwffff_layer_t *lp, *prev_lp;
243 if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
245 gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
246 /* copy instrument data */
247 if (len < (long)sizeof(ix))
249 if (copy_from_user(&ix, instr_data, sizeof(ix)))
251 if (ix.stype != IWFFFF_STRU_INSTR)
253 instr_data += sizeof(ix);
255 ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
256 ip->exclusion = le16_to_cpu(ix.exclusion);
257 ip->layer_type = le16_to_cpu(ix.layer_type);
258 ip->exclusion_group = le16_to_cpu(ix.exclusion_group);
259 ip->effect1 = ix.effect1;
260 ip->effect1_depth = ix.effect1_depth;
261 ip->effect2 = ix.effect2;
262 ip->effect2_depth = ix.effect2_depth;
266 if (len < (long)sizeof(iwffff_xlayer_t)) {
267 snd_seq_iwffff_instr_free(ops, ip, atomic);
270 if (copy_from_user(&lx, instr_data, sizeof(lx)))
272 instr_data += sizeof(lx);
274 if (lx.stype != IWFFFF_STRU_LAYER) {
275 snd_seq_iwffff_instr_free(ops, ip, atomic);
278 lp = (iwffff_layer_t *)snd_kcalloc(sizeof(*lp), gfp_mask);
280 snd_seq_iwffff_instr_free(ops, ip, atomic);
289 lp->flags = lx.flags;
290 lp->velocity_mode = lx.velocity_mode;
291 lp->layer_event = lx.layer_event;
292 lp->low_range = lx.low_range;
293 lp->high_range = lx.high_range;
295 lp->pan_freq_scale = lx.pan_freq_scale;
296 lp->attenuation = lx.attenuation;
297 snd_seq_iwffff_copy_lfo_from_stream(&lp->tremolo, &lx.tremolo);
298 snd_seq_iwffff_copy_lfo_from_stream(&lp->vibrato, &lx.vibrato);
299 lp->freq_scale = le16_to_cpu(lx.freq_scale);
300 lp->freq_center = lx.freq_center;
301 err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECP,
307 snd_seq_iwffff_instr_free(ops, ip, atomic);
310 err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECV,
316 snd_seq_iwffff_instr_free(ops, ip, atomic);
319 while (len > (long)sizeof(__u32)) {
322 if (copy_from_user(&stype, instr_data, sizeof(stype)))
324 if (stype != IWFFFF_STRU_WAVE)
326 err = snd_seq_iwffff_copy_wave_from_stream(ops,
332 snd_seq_iwffff_instr_free(ops, ip, atomic);
340 static void snd_seq_iwffff_copy_lfo_to_stream(iwffff_xlfo_t *fx,
343 fx->freq = cpu_to_le16(fp->freq);
344 fx->depth = cpu_to_le16(fp->depth);
345 fx->sweep = cpu_to_le16(fp->sweep);
346 fp->shape = fx->shape;
347 fp->delay = fx->delay;
350 static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype,
357 iwffff_env_record_t *rp;
358 iwffff_xenv_record_t rx;
359 iwffff_env_point_t *pp;
360 iwffff_xenv_point_t px;
361 int points_size, idx;
363 ex->flags = ep->flags;
365 ex->index = ep->index;
366 for (rp = ep->record; rp; rp = rp->next) {
367 if (*len < (long)sizeof(rx))
369 memset(&rx, 0, sizeof(rx));
370 rx.stype = req_stype;
371 rx.nattack = cpu_to_le16(rp->nattack);
372 rx.nrelease = cpu_to_le16(rp->nrelease);
373 rx.sustain_offset = cpu_to_le16(rp->sustain_offset);
374 rx.sustain_rate = cpu_to_le16(rp->sustain_rate);
375 rx.release_rate = cpu_to_le16(rp->release_rate);
376 rx.hirange = cpu_to_le16(rp->hirange);
377 if (copy_to_user(*data, &rx, sizeof(rx)))
381 points_size = (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
382 if (*len < points_size)
384 pp = (iwffff_env_point_t *)(rp + 1);
385 for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
386 px.offset = cpu_to_le16(pp->offset);
387 px.rate = cpu_to_le16(pp->rate);
388 if (copy_to_user(*data, &px, sizeof(px)))
397 static int snd_seq_iwffff_copy_wave_to_stream(snd_iwffff_ops_t *ops,
406 unsigned int real_size;
408 for (wp = lp->wave; wp; wp = wp->next) {
409 if (*len < (long)sizeof(xp))
411 memset(&xp, 0, sizeof(xp));
412 xp.stype = IWFFFF_STRU_WAVE;
413 xp.share_id[0] = cpu_to_le32(wp->share_id[0]);
414 xp.share_id[1] = cpu_to_le32(wp->share_id[1]);
415 xp.share_id[2] = cpu_to_le32(wp->share_id[2]);
416 xp.share_id[3] = cpu_to_le32(wp->share_id[3]);
417 xp.format = cpu_to_le32(wp->format);
418 if (wp->format & IWFFFF_WAVE_ROM)
419 xp.offset = cpu_to_le32(wp->address.memory);
420 xp.size = cpu_to_le32(wp->size);
421 xp.start = cpu_to_le32(wp->start);
422 xp.loop_start = cpu_to_le32(wp->loop_start);
423 xp.loop_end = cpu_to_le32(wp->loop_end);
424 xp.loop_repeat = cpu_to_le32(wp->loop_repeat);
425 xp.sample_ratio = cpu_to_le32(wp->sample_ratio);
426 xp.attenuation = wp->attenuation;
427 xp.low_note = wp->low_note;
428 xp.high_note = wp->high_note;
429 if (copy_to_user(*data, &xp, sizeof(xp)))
433 real_size = snd_seq_iwffff_size(wp->size, wp->format);
434 if (!(wp->format & IWFFFF_WAVE_ROM)) {
435 if (*len < (long)real_size)
438 if (ops->get_sample) {
439 err = ops->get_sample(ops->private_data, wp,
440 *data, real_size, atomic);
444 if (!(wp->format & IWFFFF_WAVE_ROM)) {
452 static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr,
453 char __user *instr_data, long len, int atomic, int cmd)
455 snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
456 iwffff_instrument_t *ip;
457 iwffff_xinstrument_t ix;
460 char __user *layer_instr_data;
463 if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
465 if (len < (long)sizeof(ix))
467 memset(&ix, 0, sizeof(ix));
468 ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
469 ix.stype = IWFFFF_STRU_INSTR;
470 ix.exclusion = cpu_to_le16(ip->exclusion);
471 ix.layer_type = cpu_to_le16(ip->layer_type);
472 ix.exclusion_group = cpu_to_le16(ip->exclusion_group);
473 ix.effect1 = cpu_to_le16(ip->effect1);
474 ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
475 ix.effect2 = ip->effect2;
476 ix.effect2_depth = ip->effect2_depth;
477 if (copy_to_user(instr_data, &ix, sizeof(ix)))
479 instr_data += sizeof(ix);
481 for (lp = ip->layer; lp; lp = lp->next) {
482 if (len < (long)sizeof(lx))
484 memset(&lx, 0, sizeof(lx));
485 lx.stype = IWFFFF_STRU_LAYER;
486 lx.flags = lp->flags;
487 lx.velocity_mode = lp->velocity_mode;
488 lx.layer_event = lp->layer_event;
489 lx.low_range = lp->low_range;
490 lx.high_range = lp->high_range;
492 lx.pan_freq_scale = lp->pan_freq_scale;
493 lx.attenuation = lp->attenuation;
494 snd_seq_iwffff_copy_lfo_to_stream(&lx.tremolo, &lp->tremolo);
495 snd_seq_iwffff_copy_lfo_to_stream(&lx.vibrato, &lp->vibrato);
496 layer_instr_data = instr_data;
497 instr_data += sizeof(lx);
499 err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECP,
505 err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECV,
511 /* layer structure updating is now finished */
512 if (copy_to_user(layer_instr_data, &lx, sizeof(lx)))
514 err = snd_seq_iwffff_copy_wave_to_stream(ops,
525 static long snd_seq_iwffff_env_size_in_stream(iwffff_env_t *ep)
528 iwffff_env_record_t *rp;
530 for (rp = ep->record; rp; rp = rp->next) {
531 result += sizeof(iwffff_xenv_record_t);
532 result += (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
537 static long snd_seq_iwffff_wave_size_in_stream(iwffff_layer_t *lp)
542 for (wp = lp->wave; wp; wp = wp->next) {
543 result += sizeof(iwffff_xwave_t);
544 if (!(wp->format & IWFFFF_WAVE_ROM))
550 static int snd_seq_iwffff_get_size(void *private_data, snd_seq_kinstr_t *instr,
554 iwffff_instrument_t *ip;
558 ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
559 result = sizeof(iwffff_xinstrument_t);
560 for (lp = ip->layer; lp; lp = lp->next) {
561 result += sizeof(iwffff_xlayer_t);
562 result += snd_seq_iwffff_env_size_in_stream(&lp->penv);
563 result += snd_seq_iwffff_env_size_in_stream(&lp->venv);
564 result += snd_seq_iwffff_wave_size_in_stream(lp);
570 static int snd_seq_iwffff_remove(void *private_data,
571 snd_seq_kinstr_t *instr,
574 snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
575 iwffff_instrument_t *ip;
577 ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
578 snd_seq_iwffff_instr_free(ops, ip, atomic);
582 static void snd_seq_iwffff_notify(void *private_data,
583 snd_seq_kinstr_t *instr,
586 snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
589 ops->notify(ops->private_data, instr, what);
592 int snd_seq_iwffff_init(snd_iwffff_ops_t *ops,
594 snd_seq_kinstr_ops_t *next)
596 memset(ops, 0, sizeof(*ops));
597 ops->private_data = private_data;
598 ops->kops.private_data = ops;
599 ops->kops.add_len = sizeof(iwffff_instrument_t);
600 ops->kops.instr_type = snd_seq_iwffff_id;
601 ops->kops.put = snd_seq_iwffff_put;
602 ops->kops.get = snd_seq_iwffff_get;
603 ops->kops.get_size = snd_seq_iwffff_get_size;
604 ops->kops.remove = snd_seq_iwffff_remove;
605 ops->kops.notify = snd_seq_iwffff_notify;
606 ops->kops.next = next;
614 static int __init alsa_ainstr_iw_init(void)
619 static void __exit alsa_ainstr_iw_exit(void)
623 module_init(alsa_ainstr_iw_init)
624 module_exit(alsa_ainstr_iw_exit)
626 EXPORT_SYMBOL(snd_seq_iwffff_id);
627 EXPORT_SYMBOL(snd_seq_iwffff_init);