sound/core/seq/instr/ainstr_iw.c

   1 /*
   2  *   IWFFFF - AMD InterWave (tm) - Instrument routines
   3  *   Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  *
  19  */
  20
  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>
  29
  30 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  31 MODULE_DESCRIPTION("Advanced Linux Sound Architecture IWFFFF support.");
  32 MODULE_LICENSE("GPL");
  33
  34 static unsigned int snd_seq_iwffff_size(unsigned int size, unsigned int format)
  35 {
  36         unsigned int result = size;
  37
  38         if (format & IWFFFF_WAVE_16BIT)
  39                 result <<= 1;
  40         if (format & IWFFFF_WAVE_STEREO)
  41                 result <<= 1;
  42         return result;
  43 }
  44
  45 static void snd_seq_iwffff_copy_lfo_from_stream(iwffff_lfo_t *fp,
  46                                                 iwffff_xlfo_t *fx)
  47 {
  48         fp->freq = le16_to_cpu(fx->freq);
  49         fp->depth = le16_to_cpu(fx->depth);
  50         fp->sweep = le16_to_cpu(fx->sweep);
  51         fp->shape = fx->shape;
  52         fp->delay = fx->delay;
  53 }
  54
  55 static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype,
  56                                                iwffff_layer_t *lp,
  57                                                iwffff_env_t *ep,
  58                                                iwffff_xenv_t *ex,
  59                                                char __user **data,
  60                                                long *len,
  61                                                gfp_t gfp_mask)
  62 {
  63         __u32 stype;
  64         iwffff_env_record_t *rp, *rp_last;
  65         iwffff_xenv_record_t rx;
  66         iwffff_env_point_t *pp;
  67         iwffff_xenv_point_t px;
  68         int points_size, idx;
  69
  70         ep->flags = ex->flags;
  71         ep->mode = ex->mode;
  72         ep->index = ex->index;
  73         rp_last = NULL;
  74         while (1) {
  75                 if (*len < (long)sizeof(__u32))
  76                         return -EINVAL;
  77                 if (copy_from_user(&stype, *data, sizeof(stype)))
  78                         return -EFAULT;
  79                 if (stype == IWFFFF_STRU_WAVE)
  80                         return 0;
  81                 if (req_stype != stype) {
  82                         if (stype == IWFFFF_STRU_ENV_RECP ||
  83                             stype == IWFFFF_STRU_ENV_RECV)
  84                                 return 0;
  85                 }
  86                 if (*len < (long)sizeof(rx))
  87                         return -EINVAL;
  88                 if (copy_from_user(&rx, *data, sizeof(rx)))
  89                         return -EFAULT;
  90                 *data += sizeof(rx);
  91                 *len -= sizeof(rx);
  92                 points_size = (le16_to_cpu(rx.nattack) + le16_to_cpu(rx.nrelease)) * 2 * sizeof(__u16);
  93                 if (points_size > *len)
  94                         return -EINVAL;
  95                 rp = kzalloc(sizeof(*rp) + points_size, gfp_mask);
  96                 if (rp == NULL)
  97                         return -ENOMEM;
  98                 rp->nattack = le16_to_cpu(rx.nattack);
  99                 rp->nrelease = le16_to_cpu(rx.nrelease);
 100                 rp->sustain_offset = le16_to_cpu(rx.sustain_offset);
 101                 rp->sustain_rate = le16_to_cpu(rx.sustain_rate);
 102                 rp->release_rate = le16_to_cpu(rx.release_rate);
 103                 rp->hirange = rx.hirange;
 104                 pp = (iwffff_env_point_t *)(rp + 1);
 105                 for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
 106                         if (copy_from_user(&px, *data, sizeof(px)))
 107                                 return -EFAULT;
 108                         *data += sizeof(px);
 109                         *len -= sizeof(px);
 110                         pp->offset = le16_to_cpu(px.offset);
 111                         pp->rate = le16_to_cpu(px.rate);
 112                 }
 113                 if (ep->record == NULL) {
 114                         ep->record = rp;
 115                 } else {
 116                         rp_last = rp;
 117                 }
 118                 rp_last = rp;
 119         }
 120         return 0;
 121 }
 122
 123 static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops,
 124                                                 iwffff_layer_t *lp,
 125                                                 char __user **data,
 126                                                 long *len,
 127                                                 int atomic)
 128 {
 129         iwffff_wave_t *wp, *prev;
 130         iwffff_xwave_t xp;
 131         int err;
 132         unsigned int gfp_mask;
 133         unsigned int real_size;
 134
 135         gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
 136         if (*len < (long)sizeof(xp))
 137                 return -EINVAL;
 138         if (copy_from_user(&xp, *data, sizeof(xp)))
 139                 return -EFAULT;
 140         *data += sizeof(xp);
 141         *len -= sizeof(xp);
 142         wp = kzalloc(sizeof(*wp), gfp_mask);
 143         if (wp == NULL)
 144                 return -ENOMEM;
 145         wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
 146         wp->share_id[1] = le32_to_cpu(xp.share_id[1]);
 147         wp->share_id[2] = le32_to_cpu(xp.share_id[2]);
 148         wp->share_id[3] = le32_to_cpu(xp.share_id[3]);
 149         wp->format = le32_to_cpu(xp.format);
 150         wp->address.memory = le32_to_cpu(xp.offset);
 151         wp->size = le32_to_cpu(xp.size);
 152         wp->start = le32_to_cpu(xp.start);
 153         wp->loop_start = le32_to_cpu(xp.loop_start);
 154         wp->loop_end = le32_to_cpu(xp.loop_end);
 155         wp->loop_repeat = le16_to_cpu(xp.loop_repeat);
 156         wp->sample_ratio = le32_to_cpu(xp.sample_ratio);
 157         wp->attenuation = xp.attenuation;
 158         wp->low_note = xp.low_note;
 159         wp->high_note = xp.high_note;
 160         real_size = snd_seq_iwffff_size(wp->size, wp->format);
 161         if (!(wp->format & IWFFFF_WAVE_ROM)) {
 162                 if ((long)real_size > *len) {
 163                         kfree(wp);
 164                         return -ENOMEM;
 165                 }
 166         }
 167         if (ops->put_sample) {
 168                 err = ops->put_sample(ops->private_data, wp,
 169                                       *data, real_size, atomic);
 170                 if (err < 0) {
 171                         kfree(wp);
 172                         return err;
 173                 }
 174         }
 175         if (!(wp->format & IWFFFF_WAVE_ROM)) {
 176                 *data += real_size;
 177                 *len -= real_size;
 178         }
 179         prev = lp->wave;
 180         if (prev) {
 181                 while (prev->next) prev = prev->next;
 182                 prev->next = wp;
 183         } else {
 184                 lp->wave = wp;
 185         }
 186         return 0;
 187 }
 188
 189 static void snd_seq_iwffff_env_free(snd_iwffff_ops_t *ops,
 190                                     iwffff_env_t *env,
 191                                     int atomic)
 192 {
 193         iwffff_env_record_t *rec;
 194
 195         while ((rec = env->record) != NULL) {
 196                 env->record = rec->next;
 197                 kfree(rec);
 198         }
 199 }
 200
 201 static void snd_seq_iwffff_wave_free(snd_iwffff_ops_t *ops,
 202                                      iwffff_wave_t *wave,
 203                                      int atomic)
 204 {
 205         if (ops->remove_sample)
 206                 ops->remove_sample(ops->private_data, wave, atomic);
 207         kfree(wave);
 208 }
 209
 210 static void snd_seq_iwffff_instr_free(snd_iwffff_ops_t *ops,
 211                                       iwffff_instrument_t *ip,
 212                                       int atomic)
 213 {
 214         iwffff_layer_t *layer;
 215         iwffff_wave_t *wave;
 216
 217         while ((layer = ip->layer) != NULL) {
 218                 ip->layer = layer->next;
 219                 snd_seq_iwffff_env_free(ops, &layer->penv, atomic);
 220                 snd_seq_iwffff_env_free(ops, &layer->venv, atomic);
 221                 while ((wave = layer->wave) != NULL) {
 222                         layer->wave = wave->next;
 223                         snd_seq_iwffff_wave_free(ops, wave, atomic);
 224                 }
 225                 kfree(layer);
 226         }
 227 }
 228
 229 static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr,
 230                               char __user *instr_data, long len, int atomic,
 231                               int cmd)
 232 {
 233         snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
 234         iwffff_instrument_t *ip;
 235         iwffff_xinstrument_t ix;
 236         iwffff_layer_t *lp, *prev_lp;
 237         iwffff_xlayer_t lx;
 238         int err;
 239         unsigned int gfp_mask;
 240
 241         if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
 242                 return -EINVAL;
 243         gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
 244         /* copy instrument data */
 245         if (len < (long)sizeof(ix))
 246                 return -EINVAL;
 247         if (copy_from_user(&ix, instr_data, sizeof(ix)))
 248                 return -EFAULT;
 249         if (ix.stype != IWFFFF_STRU_INSTR)
 250                 return -EINVAL;
 251         instr_data += sizeof(ix);
 252         len -= sizeof(ix);
 253         ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
 254         ip->exclusion = le16_to_cpu(ix.exclusion);
 255         ip->layer_type = le16_to_cpu(ix.layer_type);
 256         ip->exclusion_group = le16_to_cpu(ix.exclusion_group);
 257         ip->effect1 = ix.effect1;
 258         ip->effect1_depth = ix.effect1_depth;
 259         ip->effect2 = ix.effect2;
 260         ip->effect2_depth = ix.effect2_depth;
 261         /* copy layers */
 262         prev_lp = NULL;
 263         while (len > 0) {
 264                 if (len < (long)sizeof(iwffff_xlayer_t)) {
 265                         snd_seq_iwffff_instr_free(ops, ip, atomic);
 266                         return -EINVAL;
 267                 }
 268                 if (copy_from_user(&lx, instr_data, sizeof(lx)))
 269                         return -EFAULT;
 270                 instr_data += sizeof(lx);
 271                 len -= sizeof(lx);
 272                 if (lx.stype != IWFFFF_STRU_LAYER) {
 273                         snd_seq_iwffff_instr_free(ops, ip, atomic);
 274                         return -EINVAL;
 275                 }
 276                 lp = kzalloc(sizeof(*lp), gfp_mask);
 277                 if (lp == NULL) {
 278                         snd_seq_iwffff_instr_free(ops, ip, atomic);
 279                         return -ENOMEM;
 280                 }
 281                 if (prev_lp) {
 282                         prev_lp->next = lp;
 283                 } else {
 284                         ip->layer = lp;
 285                 }
 286                 prev_lp = lp;
 287                 lp->flags = lx.flags;
 288                 lp->velocity_mode = lx.velocity_mode;
 289                 lp->layer_event = lx.layer_event;
 290                 lp->low_range = lx.low_range;
 291                 lp->high_range = lx.high_range;
 292                 lp->pan = lx.pan;
 293                 lp->pan_freq_scale = lx.pan_freq_scale;
 294                 lp->attenuation = lx.attenuation;
 295                 snd_seq_iwffff_copy_lfo_from_stream(&lp->tremolo, &lx.tremolo);
 296                 snd_seq_iwffff_copy_lfo_from_stream(&lp->vibrato, &lx.vibrato);
 297                 lp->freq_scale = le16_to_cpu(lx.freq_scale);
 298                 lp->freq_center = lx.freq_center;
 299                 err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECP,
 300                                                           lp,
 301                                                           &lp->penv, &lx.penv,
 302                                                           &instr_data, &len,
 303                                                           gfp_mask);
 304                 if (err < 0) {
 305                         snd_seq_iwffff_instr_free(ops, ip, atomic);
 306                         return err;
 307                 }
 308                 err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECV,
 309                                                           lp,
 310                                                           &lp->venv, &lx.venv,
 311                                                           &instr_data, &len,
 312                                                           gfp_mask);
 313                 if (err < 0) {
 314                         snd_seq_iwffff_instr_free(ops, ip, atomic);
 315                         return err;
 316                 }
 317                 while (len > (long)sizeof(__u32)) {
 318                         __u32 stype;
 319
 320                         if (copy_from_user(&stype, instr_data, sizeof(stype)))
 321                                 return -EFAULT;
 322                         if (stype != IWFFFF_STRU_WAVE)
 323                                 break;
 324                         err = snd_seq_iwffff_copy_wave_from_stream(ops,
 325                                                                    lp,
 326                                                                    &instr_data,
 327                                                                    &len,
 328                                                                    atomic);
 329                         if (err < 0) {
 330                                 snd_seq_iwffff_instr_free(ops, ip, atomic);
 331                                 return err;
 332                         }
 333                 }
 334         }
 335         return 0;
 336 }
 337
 338 static void snd_seq_iwffff_copy_lfo_to_stream(iwffff_xlfo_t *fx,
 339                                               iwffff_lfo_t *fp)
 340 {
 341         fx->freq = cpu_to_le16(fp->freq);
 342         fx->depth = cpu_to_le16(fp->depth);
 343         fx->sweep = cpu_to_le16(fp->sweep);
 344         fp->shape = fx->shape;
 345         fp->delay = fx->delay;
 346 }
 347
 348 static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype,
 349                                              iwffff_layer_t *lp,
 350                                              iwffff_xenv_t *ex,
 351                                              iwffff_env_t *ep,
 352                                              char __user **data,
 353                                              long *len)
 354 {
 355         iwffff_env_record_t *rp;
 356         iwffff_xenv_record_t rx;
 357         iwffff_env_point_t *pp;
 358         iwffff_xenv_point_t px;
 359         int points_size, idx;
 360
 361         ex->flags = ep->flags;
 362         ex->mode = ep->mode;
 363         ex->index = ep->index;
 364         for (rp = ep->record; rp; rp = rp->next) {
 365                 if (*len < (long)sizeof(rx))
 366                         return -ENOMEM;
 367                 memset(&rx, 0, sizeof(rx));
 368                 rx.stype = req_stype;
 369                 rx.nattack = cpu_to_le16(rp->nattack);
 370                 rx.nrelease = cpu_to_le16(rp->nrelease);
 371                 rx.sustain_offset = cpu_to_le16(rp->sustain_offset);
 372                 rx.sustain_rate = cpu_to_le16(rp->sustain_rate);
 373                 rx.release_rate = cpu_to_le16(rp->release_rate);
 374                 rx.hirange = cpu_to_le16(rp->hirange);
 375                 if (copy_to_user(*data, &rx, sizeof(rx)))
 376                         return -EFAULT;
 377                 *data += sizeof(rx);
 378                 *len -= sizeof(rx);
 379                 points_size = (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
 380                 if (*len < points_size)
 381                         return -ENOMEM;
 382                 pp = (iwffff_env_point_t *)(rp + 1);
 383                 for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
 384                         px.offset = cpu_to_le16(pp->offset);
 385                         px.rate = cpu_to_le16(pp->rate);
 386                         if (copy_to_user(*data, &px, sizeof(px)))
 387                                 return -EFAULT;
 388                         *data += sizeof(px);
 389                         *len -= sizeof(px);
 390                 }
 391         }
 392         return 0;
 393 }
 394
 395 static int snd_seq_iwffff_copy_wave_to_stream(snd_iwffff_ops_t *ops,
 396                                               iwffff_layer_t *lp,
 397                                               char __user **data,
 398                                               long *len,
 399                                               int atomic)
 400 {
 401         iwffff_wave_t *wp;
 402         iwffff_xwave_t xp;
 403         int err;
 404         unsigned int real_size;
 405
 406         for (wp = lp->wave; wp; wp = wp->next) {
 407                 if (*len < (long)sizeof(xp))
 408                         return -ENOMEM;
 409                 memset(&xp, 0, sizeof(xp));
 410                 xp.stype = IWFFFF_STRU_WAVE;
 411                 xp.share_id[0] = cpu_to_le32(wp->share_id[0]);
 412                 xp.share_id[1] = cpu_to_le32(wp->share_id[1]);
 413                 xp.share_id[2] = cpu_to_le32(wp->share_id[2]);
 414                 xp.share_id[3] = cpu_to_le32(wp->share_id[3]);
 415                 xp.format = cpu_to_le32(wp->format);
 416                 if (wp->format & IWFFFF_WAVE_ROM)
 417                         xp.offset = cpu_to_le32(wp->address.memory);
 418                 xp.size = cpu_to_le32(wp->size);
 419                 xp.start = cpu_to_le32(wp->start);
 420                 xp.loop_start = cpu_to_le32(wp->loop_start);
 421                 xp.loop_end = cpu_to_le32(wp->loop_end);
 422                 xp.loop_repeat = cpu_to_le32(wp->loop_repeat);
 423                 xp.sample_ratio = cpu_to_le32(wp->sample_ratio);
 424                 xp.attenuation = wp->attenuation;
 425                 xp.low_note = wp->low_note;
 426                 xp.high_note = wp->high_note;
 427                 if (copy_to_user(*data, &xp, sizeof(xp)))
 428                         return -EFAULT;
 429                 *data += sizeof(xp);
 430                 *len -= sizeof(xp);
 431                 real_size = snd_seq_iwffff_size(wp->size, wp->format);
 432                 if (!(wp->format & IWFFFF_WAVE_ROM)) {
 433                         if (*len < (long)real_size)
 434                                 return -ENOMEM;
 435                 }
 436                 if (ops->get_sample) {
 437                         err = ops->get_sample(ops->private_data, wp,
 438                                               *data, real_size, atomic);
 439                         if (err < 0)
 440                                 return err;
 441                 }
 442                 if (!(wp->format & IWFFFF_WAVE_ROM)) {
 443                         *data += real_size;
 444                         *len -= real_size;
 445                 }
 446         }
 447         return 0;
 448 }
 449
 450 static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr,
 451                               char __user *instr_data, long len, int atomic, int cmd)
 452 {
 453         snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
 454         iwffff_instrument_t *ip;
 455         iwffff_xinstrument_t ix;
 456         iwffff_layer_t *lp;
 457         iwffff_xlayer_t lx;
 458         char __user *layer_instr_data;
 459         int err;
 460
 461         if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
 462                 return -EINVAL;
 463         if (len < (long)sizeof(ix))
 464                 return -ENOMEM;
 465         memset(&ix, 0, sizeof(ix));
 466         ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
 467         ix.stype = IWFFFF_STRU_INSTR;
 468         ix.exclusion = cpu_to_le16(ip->exclusion);
 469         ix.layer_type = cpu_to_le16(ip->layer_type);
 470         ix.exclusion_group = cpu_to_le16(ip->exclusion_group);
 471         ix.effect1 = cpu_to_le16(ip->effect1);
 472         ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
 473         ix.effect2 = ip->effect2;
 474         ix.effect2_depth = ip->effect2_depth;
 475         if (copy_to_user(instr_data, &ix, sizeof(ix)))
 476                 return -EFAULT;
 477         instr_data += sizeof(ix);
 478         len -= sizeof(ix);
 479         for (lp = ip->layer; lp; lp = lp->next) {
 480                 if (len < (long)sizeof(lx))
 481                         return -ENOMEM;
 482                 memset(&lx, 0, sizeof(lx));
 483                 lx.stype = IWFFFF_STRU_LAYER;
 484                 lx.flags = lp->flags;
 485                 lx.velocity_mode = lp->velocity_mode;
 486                 lx.layer_event = lp->layer_event;
 487                 lx.low_range = lp->low_range;
 488                 lx.high_range = lp->high_range;
 489                 lx.pan = lp->pan;
 490                 lx.pan_freq_scale = lp->pan_freq_scale;
 491                 lx.attenuation = lp->attenuation;
 492                 snd_seq_iwffff_copy_lfo_to_stream(&lx.tremolo, &lp->tremolo);
 493                 snd_seq_iwffff_copy_lfo_to_stream(&lx.vibrato, &lp->vibrato);
 494                 layer_instr_data = instr_data;
 495                 instr_data += sizeof(lx);
 496                 len -= sizeof(lx);
 497                 err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECP,
 498                                                         lp,
 499                                                         &lx.penv, &lp->penv,
 500                                                         &instr_data, &len);
 501                 if (err < 0)
 502                         return err;
 503                 err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECV,
 504                                                         lp,
 505                                                         &lx.venv, &lp->venv,
 506                                                         &instr_data, &len);
 507                 if (err < 0)
 508                         return err;
 509                 /* layer structure updating is now finished */
 510                 if (copy_to_user(layer_instr_data, &lx, sizeof(lx)))
 511                         return -EFAULT;
 512                 err = snd_seq_iwffff_copy_wave_to_stream(ops,
 513                                                          lp,
 514                                                          &instr_data,
 515                                                          &len,
 516                                                          atomic);
 517                 if (err < 0)
 518                         return err;
 519         }
 520         return 0;
 521 }
 522
 523 static long snd_seq_iwffff_env_size_in_stream(iwffff_env_t *ep)
 524 {
 525         long result = 0;
 526         iwffff_env_record_t *rp;
 527
 528         for (rp = ep->record; rp; rp = rp->next) {
 529                 result += sizeof(iwffff_xenv_record_t);
 530                 result += (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
 531         }
 532         return 0;
 533 }
 534
 535 static long snd_seq_iwffff_wave_size_in_stream(iwffff_layer_t *lp)
 536 {
 537         long result = 0;
 538         iwffff_wave_t *wp;
 539
 540         for (wp = lp->wave; wp; wp = wp->next) {
 541                 result += sizeof(iwffff_xwave_t);
 542                 if (!(wp->format & IWFFFF_WAVE_ROM))
 543                         result += wp->size;
 544         }
 545         return result;
 546 }
 547
 548 static int snd_seq_iwffff_get_size(void *private_data, snd_seq_kinstr_t *instr,
 549                                    long *size)
 550 {
 551         long result;
 552         iwffff_instrument_t *ip;
 553         iwffff_layer_t *lp;
 554
 555         *size = 0;
 556         ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
 557         result = sizeof(iwffff_xinstrument_t);
 558         for (lp = ip->layer; lp; lp = lp->next) {
 559                 result += sizeof(iwffff_xlayer_t);
 560                 result += snd_seq_iwffff_env_size_in_stream(&lp->penv);
 561                 result += snd_seq_iwffff_env_size_in_stream(&lp->venv);
 562                 result += snd_seq_iwffff_wave_size_in_stream(lp);
 563         }
 564         *size = result;
 565         return 0;
 566 }
 567
 568 static int snd_seq_iwffff_remove(void *private_data,
 569                                  snd_seq_kinstr_t *instr,
 570                                  int atomic)
 571 {
 572         snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
 573         iwffff_instrument_t *ip;
 574
 575         ip = (iwffff_instrument_t *)KINSTR_DATA(instr);
 576         snd_seq_iwffff_instr_free(ops, ip, atomic);
 577         return 0;
 578 }
 579
 580 static void snd_seq_iwffff_notify(void *private_data,
 581                                   snd_seq_kinstr_t *instr,
 582                                   int what)
 583 {
 584         snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data;
 585
 586         if (ops->notify)
 587                 ops->notify(ops->private_data, instr, what);
 588 }
 589
 590 int snd_seq_iwffff_init(snd_iwffff_ops_t *ops,
 591                         void *private_data,
 592                         snd_seq_kinstr_ops_t *next)
 593 {
 594         memset(ops, 0, sizeof(*ops));
 595         ops->private_data = private_data;
 596         ops->kops.private_data = ops;
 597         ops->kops.add_len = sizeof(iwffff_instrument_t);
 598         ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_INTERWAVE;
 599         ops->kops.put = snd_seq_iwffff_put;
 600         ops->kops.get = snd_seq_iwffff_get;
 601         ops->kops.get_size = snd_seq_iwffff_get_size;
 602         ops->kops.remove = snd_seq_iwffff_remove;
 603         ops->kops.notify = snd_seq_iwffff_notify;
 604         ops->kops.next = next;
 605         return 0;
 606 }
 607
 608 /*
 609  *  Init part
 610  */
 611
 612 static int __init alsa_ainstr_iw_init(void)
 613 {
 614         return 0;
 615 }
 616
 617 static void __exit alsa_ainstr_iw_exit(void)
 618 {
 619 }
 620
 621 module_init(alsa_ainstr_iw_init)
 622 module_exit(alsa_ainstr_iw_exit)
 623
 624 EXPORT_SYMBOL(snd_seq_iwffff_init);