[ALSA] Remove sequencer instrument layer

Remove sequencer instrument layer from the tree.
This mechanism hasn't been used much with the actual devices.  The only
reasonable user was OPL3 loader, and now it was rewritten to use hwdep
instead.  So, let's remove the rest of rotten codes.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>

9 files changed, 3 insertions, 2045 deletions

diff --git a/sound/core/seq/Makefile b/sound/core/seq/Makefile
index ceef14a..0695937 100644
--- a/sound/core/seq/Makefile
+++ b/sound/core/seq/Makefile
@@ -3,7 +3,6 @@
 # Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
 #
 
-obj-$(CONFIG_SND) += instr/
 ifeq ($(CONFIG_SND_SEQUENCER_OSS),y)
   obj-$(CONFIG_SND_SEQUENCER) += oss/
 endif
@@ -15,7 +14,6 @@ snd-seq-objs := seq.o seq_lock.o seq_clientmgr.o seq_memory.o seq_queue.o \
 snd-seq-midi-objs := seq_midi.o
 snd-seq-midi-emul-objs := seq_midi_emul.o
 snd-seq-midi-event-objs := seq_midi_event.o
-snd-seq-instr-objs := seq_instr.o
 snd-seq-dummy-objs := seq_dummy.o
 snd-seq-virmidi-objs := seq_virmidi.o
 
@@ -36,9 +34,7 @@ obj-$(CONFIG_SND_SEQ_DUMMY) += snd-seq-dummy.o
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_VIRMIDI) += snd-seq-virmidi.o snd-seq-midi-event.o
 obj-$(call sequencer,$(CONFIG_SND_RAWMIDI)) += snd-seq-midi.o snd-seq-midi-event.o
-obj-$(call sequencer,$(CONFIG_SND_OPL3_LIB)) += snd-seq-midi-event.o snd-seq-midi-emul.o snd-seq-instr.o
-obj-$(call sequencer,$(CONFIG_SND_OPL4_LIB)) += snd-seq-midi-event.o snd-seq-midi-emul.o snd-seq-instr.o
-obj-$(call sequencer,$(CONFIG_SND_GUS_SYNTH)) += snd-seq-midi-emul.o snd-seq-instr.o
+obj-$(call sequencer,$(CONFIG_SND_OPL3_LIB)) += snd-seq-midi-event.o snd-seq-midi-emul.o
+obj-$(call sequencer,$(CONFIG_SND_OPL4_LIB)) += snd-seq-midi-event.o snd-seq-midi-emul.o
 obj-$(call sequencer,$(CONFIG_SND_SBAWE)) += snd-seq-midi-emul.o snd-seq-virmidi.o
 obj-$(call sequencer,$(CONFIG_SND_EMU10K1)) += snd-seq-midi-emul.o snd-seq-virmidi.o
-obj-$(call sequencer,$(CONFIG_SND_TRIDENT)) += snd-seq-midi-emul.o snd-seq-instr.o
diff --git a/sound/core/seq/instr/Makefile b/sound/core/seq/instr/Makefile
deleted file mode 100644
index 6089603..0000000
--- a/sound/core/seq/instr/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-#
-# Makefile for ALSA
-# Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
-#
-
-snd-ainstr-fm-objs := ainstr_fm.o
-snd-ainstr-simple-objs := ainstr_simple.o
-snd-ainstr-gf1-objs := ainstr_gf1.o
-snd-ainstr-iw-objs := ainstr_iw.o
-
-#
-# this function returns:
-#   "m" - CONFIG_SND_SEQUENCER is m
-#   <empty string> - CONFIG_SND_SEQUENCER is undefined
-#   otherwise parameter #1 value
-#
-sequencer = $(if $(subst y,,$(CONFIG_SND_SEQUENCER)),$(if $(1),m),$(if $(CONFIG_SND_SEQUENCER),$(1)))
-
-# Toplevel Module Dependency
-obj-$(call sequencer,$(CONFIG_SND_OPL3_LIB)) += snd-ainstr-fm.o
-obj-$(call sequencer,$(CONFIG_SND_OPL4_LIB)) += snd-ainstr-fm.o
-obj-$(call sequencer,$(CONFIG_SND_GUS_SYNTH)) += snd-ainstr-gf1.o snd-ainstr-simple.o snd-ainstr-iw.o
-obj-$(call sequencer,$(CONFIG_SND_TRIDENT)) += snd-ainstr-simple.o
diff --git a/sound/core/seq/instr/ainstr_fm.c b/sound/core/seq/instr/ainstr_fm.c
deleted file mode 100644
index f80fab8..0000000
--- a/sound/core/seq/instr/ainstr_fm.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- *  FM (OPL2/3) Instrument routines
- *  Copyright (c) 2000 Uros Bizjak <uros@kss-loka.si>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
- 
-#include <sound/driver.h>
-#include <linux/init.h>
-#include <sound/core.h>
-#include <sound/ainstr_fm.h>
-#include <sound/initval.h>
-#include <asm/uaccess.h>
-
-MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>");
-MODULE_DESCRIPTION("Advanced Linux Sound Architecture FM Instrument support.");
-MODULE_LICENSE("GPL");
-
-static int snd_seq_fm_put(void *private_data, struct snd_seq_kinstr *instr,
-			  char __user *instr_data, long len, int atomic, int cmd)
-{
-	struct fm_instrument *ip;
-	struct fm_xinstrument ix;
-	int idx;
-
-	if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
-		return -EINVAL;
-	/* copy instrument data */
-	if (len < (long)sizeof(ix))
-		return -EINVAL;
-	if (copy_from_user(&ix, instr_data, sizeof(ix)))
-		return -EFAULT;
-	if (ix.stype != FM_STRU_INSTR)
-		return -EINVAL;
-	ip = (struct fm_instrument *)KINSTR_DATA(instr);
-	ip->share_id[0] = le32_to_cpu(ix.share_id[0]);
-	ip->share_id[1] = le32_to_cpu(ix.share_id[1]);
-	ip->share_id[2] = le32_to_cpu(ix.share_id[2]);
-	ip->share_id[3] = le32_to_cpu(ix.share_id[3]);
-	ip->type = ix.type;
-	for (idx = 0; idx < 4; idx++) {
-		ip->op[idx].am_vib = ix.op[idx].am_vib;
-		ip->op[idx].ksl_level = ix.op[idx].ksl_level;
-		ip->op[idx].attack_decay = ix.op[idx].attack_decay;
-		ip->op[idx].sustain_release = ix.op[idx].sustain_release;
-		ip->op[idx].wave_select = ix.op[idx].wave_select;
-	}
-	for (idx = 0; idx < 2; idx++) {
-		ip->feedback_connection[idx] = ix.feedback_connection[idx];
-	}
-	ip->echo_delay = ix.echo_delay;
-	ip->echo_atten = ix.echo_atten;
-	ip->chorus_spread = ix.chorus_spread;
-	ip->trnsps = ix.trnsps;
-	ip->fix_dur = ix.fix_dur;
-	ip->modes = ix.modes;
-	ip->fix_key = ix.fix_key;
-	return 0;
-}
-
-static int snd_seq_fm_get(void *private_data, struct snd_seq_kinstr *instr,
-			  char __user *instr_data, long len, int atomic,
-			  int cmd)
-{
-	struct fm_instrument *ip;
-	struct fm_xinstrument ix;
-	int idx;
-	
-	if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
-		return -EINVAL;
-	if (len < (long)sizeof(ix))
-		return -ENOMEM;
-	memset(&ix, 0, sizeof(ix));
-	ip = (struct fm_instrument *)KINSTR_DATA(instr);
-	ix.stype = FM_STRU_INSTR;
-	ix.share_id[0] = cpu_to_le32(ip->share_id[0]);
-	ix.share_id[1] = cpu_to_le32(ip->share_id[1]);
-	ix.share_id[2] = cpu_to_le32(ip->share_id[2]);
-	ix.share_id[3] = cpu_to_le32(ip->share_id[3]);
-	ix.type = ip->type;
-	for (idx = 0; idx < 4; idx++) {
-		ix.op[idx].am_vib = ip->op[idx].am_vib;
-		ix.op[idx].ksl_level = ip->op[idx].ksl_level;
-		ix.op[idx].attack_decay = ip->op[idx].attack_decay;
-		ix.op[idx].sustain_release = ip->op[idx].sustain_release;
-		ix.op[idx].wave_select = ip->op[idx].wave_select;
-	}
-	for (idx = 0; idx < 2; idx++) {
-		ix.feedback_connection[idx] = ip->feedback_connection[idx];
-	}
-	if (copy_to_user(instr_data, &ix, sizeof(ix)))
-		return -EFAULT;
-	ix.echo_delay = ip->echo_delay;
-	ix.echo_atten = ip->echo_atten;
-	ix.chorus_spread = ip->chorus_spread;
-	ix.trnsps = ip->trnsps;
-	ix.fix_dur = ip->fix_dur;
-	ix.modes = ip->modes;
-	ix.fix_key = ip->fix_key;
-	return 0;
-}
-
-static int snd_seq_fm_get_size(void *private_data, struct snd_seq_kinstr *instr,
-			       long *size)
-{
-	*size = sizeof(struct fm_xinstrument);
-	return 0;
-}
-
-int snd_seq_fm_init(struct snd_seq_kinstr_ops *ops,
-		    struct snd_seq_kinstr_ops *next)
-{
-	memset(ops, 0, sizeof(*ops));
-	// ops->private_data = private_data;
-	ops->add_len = sizeof(struct fm_instrument);
-	ops->instr_type = SNDRV_SEQ_INSTR_ID_OPL2_3;
-	ops->put = snd_seq_fm_put;
-	ops->get = snd_seq_fm_get;
-	ops->get_size = snd_seq_fm_get_size;
-	// ops->remove = snd_seq_fm_remove;
-	// ops->notify = snd_seq_fm_notify;
-	ops->next = next;
-	return 0;
-}
-
-/*
- *  Init part
- */
-
-static int __init alsa_ainstr_fm_init(void)
-{
-	return 0;
-}
-
-static void __exit alsa_ainstr_fm_exit(void)
-{
-}
-
-module_init(alsa_ainstr_fm_init)
-module_exit(alsa_ainstr_fm_exit)
-
-EXPORT_SYMBOL(snd_seq_fm_init);
diff --git a/sound/core/seq/instr/ainstr_gf1.c b/sound/core/seq/instr/ainstr_gf1.c
deleted file mode 100644
index 4940026..0000000
--- a/sound/core/seq/instr/ainstr_gf1.c
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
- *   GF1 (GUS) Patch - Instrument routines
- *   Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
- 
-#include <sound/driver.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <sound/core.h>
-#include <sound/ainstr_gf1.h>
-#include <sound/initval.h>
-#include <asm/uaccess.h>
-
-MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
-MODULE_DESCRIPTION("Advanced Linux Sound Architecture GF1 (GUS) Patch support.");
-MODULE_LICENSE("GPL");
-
-static unsigned int snd_seq_gf1_size(unsigned int size, unsigned int format)
-{
-	unsigned int result = size;
-	
-	if (format & GF1_WAVE_16BIT)
-		result <<= 1;
-	if (format & GF1_WAVE_STEREO)
-		result <<= 1;
-	return format;
-}
-
-static int snd_seq_gf1_copy_wave_from_stream(struct snd_gf1_ops *ops,
-					     struct gf1_instrument *ip,
-					     char __user **data,
-					     long *len,
-					     int atomic)
-{
-	struct gf1_wave *wp, *prev;
-	struct gf1_xwave xp;
-	int err;
-	gfp_t gfp_mask;
-	unsigned int real_size;
-	
-	gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
-	if (*len < (long)sizeof(xp))
-		return -EINVAL;
-	if (copy_from_user(&xp, *data, sizeof(xp)))
-		return -EFAULT;
-	*data += sizeof(xp);
-	*len -= sizeof(xp);
-	wp = kzalloc(sizeof(*wp), gfp_mask);
-	if (wp == NULL)
-		return -ENOMEM;
-	wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
-	wp->share_id[1] = le32_to_cpu(xp.share_id[1]);
-	wp->share_id[2] = le32_to_cpu(xp.share_id[2]);
-	wp->share_id[3] = le32_to_cpu(xp.share_id[3]);
-	wp->format = le32_to_cpu(xp.format);
-	wp->size = le32_to_cpu(xp.size);
-	wp->start = le32_to_cpu(xp.start);
-	wp->loop_start = le32_to_cpu(xp.loop_start);
-	wp->loop_end = le32_to_cpu(xp.loop_end);
-	wp->loop_repeat = le16_to_cpu(xp.loop_repeat);
-	wp->flags = xp.flags;
-	wp->sample_rate = le32_to_cpu(xp.sample_rate);
-	wp->low_frequency = le32_to_cpu(xp.low_frequency);
-	wp->high_frequency = le32_to_cpu(xp.high_frequency);
-	wp->root_frequency = le32_to_cpu(xp.root_frequency);
-	wp->tune = le16_to_cpu(xp.tune);
-	wp->balance = xp.balance;
-	memcpy(wp->envelope_rate, xp.envelope_rate, 6);
-	memcpy(wp->envelope_offset, xp.envelope_offset, 6);
-	wp->tremolo_sweep = xp.tremolo_sweep;
-	wp->tremolo_rate = xp.tremolo_rate;
-	wp->tremolo_depth = xp.tremolo_depth;
-	wp->vibrato_sweep = xp.vibrato_sweep;
-	wp->vibrato_rate = xp.vibrato_rate;
-	wp->vibrato_depth = xp.vibrato_depth;
-	wp->scale_frequency = le16_to_cpu(xp.scale_frequency);
-	wp->scale_factor = le16_to_cpu(xp.scale_factor);
-	real_size = snd_seq_gf1_size(wp->size, wp->format);
-	if ((long)real_size > *len) {
-		kfree(wp);
-		return -ENOMEM;
-	}
-	if (ops->put_sample) {
-		err = ops->put_sample(ops->private_data, wp,
-				      *data, real_size, atomic);
-		if (err < 0) {
-			kfree(wp);
-			return err;
-		}
-	}
-	*data += real_size;
-	*len -= real_size;
-	prev = ip->wave;
-	if (prev) {
-		while (prev->next) prev = prev->next;
-		prev->next = wp;
-	} else {
-		ip->wave = wp;
-	}
-	return 0;
-}
-
-static void snd_seq_gf1_wave_free(struct snd_gf1_ops *ops,
-				  struct gf1_wave *wave,
-				  int atomic)
-{
-	if (ops->remove_sample)
-		ops->remove_sample(ops->private_data, wave, atomic);
-	kfree(wave);
-}
-
-static void snd_seq_gf1_instr_free(struct snd_gf1_ops *ops,
-				   struct gf1_instrument *ip,
-				   int atomic)
-{
-	struct gf1_wave *wave;
-	
-	while ((wave = ip->wave) != NULL) {
-		ip->wave = wave->next;
-		snd_seq_gf1_wave_free(ops, wave, atomic);
-	}
-}
-
-static int snd_seq_gf1_put(void *private_data, struct snd_seq_kinstr *instr,
-			   char __user *instr_data, long len, int atomic,
-			   int cmd)
-{
-	struct snd_gf1_ops *ops = private_data;
-	struct gf1_instrument *ip;
-	struct gf1_xinstrument ix;
-	int err;
-	gfp_t gfp_mask;
-
-	if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
-		return -EINVAL;
-	gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
-	/* copy instrument data */
-	if (len < (long)sizeof(ix))
-		return -EINVAL;
-	if (copy_from_user(&ix, instr_data, sizeof(ix)))
-		return -EFAULT;
-	if (ix.stype != GF1_STRU_INSTR)
-		return -EINVAL;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	ip = (struct gf1_instrument *)KINSTR_DATA(instr);
-	ip->exclusion = le16_to_cpu(ix.exclusion);
-	ip->exclusion_group = le16_to_cpu(ix.exclusion_group);
-	ip->effect1 = ix.effect1;
-	ip->effect1_depth = ix.effect1_depth;
-	ip->effect2 = ix.effect2;
-	ip->effect2_depth = ix.effect2_depth;
-	/* copy layers */
-	while (len > (long)sizeof(__u32)) {
-		__u32 stype;
-
-		if (copy_from_user(&stype, instr_data, sizeof(stype)))
-			return -EFAULT;
-		if (stype != GF1_STRU_WAVE) {
-			snd_seq_gf1_instr_free(ops, ip, atomic);
-			return -EINVAL;
-		}
-		err = snd_seq_gf1_copy_wave_from_stream(ops,
-							ip,
-							&instr_data,
-							&len,
-							atomic);
-		if (err < 0) {
-			snd_seq_gf1_instr_free(ops, ip, atomic);
-			return err;
-		}
-	}
-	return 0;
-}
-
-static int snd_seq_gf1_copy_wave_to_stream(struct snd_gf1_ops *ops,
-					   struct gf1_instrument *ip,
-					   char __user **data,
-					   long *len,
-					   int atomic)
-{
-	struct gf1_wave *wp;
-	struct gf1_xwave xp;
-	int err;
-	unsigned int real_size;
-	
-	for (wp = ip->wave; wp; wp = wp->next) {
-		if (*len < (long)sizeof(xp))
-			return -ENOMEM;
-		memset(&xp, 0, sizeof(xp));
-		xp.stype = GF1_STRU_WAVE;
-		xp.share_id[0] = cpu_to_le32(wp->share_id[0]);
-		xp.share_id[1] = cpu_to_le32(wp->share_id[1]);
-		xp.share_id[2] = cpu_to_le32(wp->share_id[2]);
-		xp.share_id[3] = cpu_to_le32(wp->share_id[3]);
-		xp.format = cpu_to_le32(wp->format);
-		xp.size = cpu_to_le32(wp->size);
-		xp.start = cpu_to_le32(wp->start);
-		xp.loop_start = cpu_to_le32(wp->loop_start);
-		xp.loop_end = cpu_to_le32(wp->loop_end);
-		xp.loop_repeat = cpu_to_le32(wp->loop_repeat);
-		xp.flags = wp->flags;
-		xp.sample_rate = cpu_to_le32(wp->sample_rate);
-		xp.low_frequency = cpu_to_le32(wp->low_frequency);
-		xp.high_frequency = cpu_to_le32(wp->high_frequency);
-		xp.root_frequency = cpu_to_le32(wp->root_frequency);
-		xp.tune = cpu_to_le16(wp->tune);
-		xp.balance = wp->balance;
-		memcpy(xp.envelope_rate, wp->envelope_rate, 6);
-		memcpy(xp.envelope_offset, wp->envelope_offset, 6);
-		xp.tremolo_sweep = wp->tremolo_sweep;
-		xp.tremolo_rate = wp->tremolo_rate;
-		xp.tremolo_depth = wp->tremolo_depth;
-		xp.vibrato_sweep = wp->vibrato_sweep;
-		xp.vibrato_rate = wp->vibrato_rate;
-		xp.vibrato_depth = wp->vibrato_depth;
-		xp.scale_frequency = cpu_to_le16(wp->scale_frequency);
-		xp.scale_factor = cpu_to_le16(wp->scale_factor);
-		if (copy_to_user(*data, &xp, sizeof(xp)))
-			return -EFAULT;
-		*data += sizeof(xp);
-		*len -= sizeof(xp);
-		real_size = snd_seq_gf1_size(wp->size, wp->format);
-		if (*len < (long)real_size)
-			return -ENOMEM;
-		if (ops->get_sample) {
-			err = ops->get_sample(ops->private_data, wp,
-					      *data, real_size, atomic);
-			if (err < 0)
-				return err;
-		}
-		*data += wp->size;
-		*len -= wp->size;
-	}
-	return 0;
-}
-
-static int snd_seq_gf1_get(void *private_data, struct snd_seq_kinstr *instr,
-			   char __user *instr_data, long len, int atomic,
-			   int cmd)
-{
-	struct snd_gf1_ops *ops = private_data;
-	struct gf1_instrument *ip;
-	struct gf1_xinstrument ix;
-	
-	if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
-		return -EINVAL;
-	if (len < (long)sizeof(ix))
-		return -ENOMEM;
-	memset(&ix, 0, sizeof(ix));
-	ip = (struct gf1_instrument *)KINSTR_DATA(instr);
-	ix.stype = GF1_STRU_INSTR;
-	ix.exclusion = cpu_to_le16(ip->exclusion);
-	ix.exclusion_group = cpu_to_le16(ip->exclusion_group);
-	ix.effect1 = cpu_to_le16(ip->effect1);
-	ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
-	ix.effect2 = ip->effect2;
-	ix.effect2_depth = ip->effect2_depth;
-	if (copy_to_user(instr_data, &ix, sizeof(ix)))
-		return -EFAULT;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	return snd_seq_gf1_copy_wave_to_stream(ops,
-					       ip,
-					       &instr_data,
-					       &len,
-					       atomic);
-}
-
-static int snd_seq_gf1_get_size(void *private_data, struct snd_seq_kinstr *instr,
-				long *size)
-{
-	long result;
-	struct gf1_instrument *ip;
-	struct gf1_wave *wp;
-
-	*size = 0;
-	ip = (struct gf1_instrument *)KINSTR_DATA(instr);
-	result = sizeof(struct gf1_xinstrument);
-	for (wp = ip->wave; wp; wp = wp->next) {
-		result += sizeof(struct gf1_xwave);
-		result += wp->size;
-	}
-	*size = result;
-	return 0;
-}
-
-static int snd_seq_gf1_remove(void *private_data,
-			      struct snd_seq_kinstr *instr,
-                              int atomic)
-{
-	struct snd_gf1_ops *ops = private_data;
-	struct gf1_instrument *ip;
-
-	ip = (struct gf1_instrument *)KINSTR_DATA(instr);
-	snd_seq_gf1_instr_free(ops, ip, atomic);
-	return 0;
-}
-
-static void snd_seq_gf1_notify(void *private_data,
-			       struct snd_seq_kinstr *instr,
-			       int what)
-{
-	struct snd_gf1_ops *ops = private_data;
-
-	if (ops->notify)
-		ops->notify(ops->private_data, instr, what);
-}
-
-int snd_seq_gf1_init(struct snd_gf1_ops *ops,
-		     void *private_data,
-		     struct snd_seq_kinstr_ops *next)
-{
-	memset(ops, 0, sizeof(*ops));
-	ops->private_data = private_data;
-	ops->kops.private_data = ops;
-	ops->kops.add_len = sizeof(struct gf1_instrument);
-	ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_GUS_PATCH;
-	ops->kops.put = snd_seq_gf1_put;
-	ops->kops.get = snd_seq_gf1_get;
-	ops->kops.get_size = snd_seq_gf1_get_size;
-	ops->kops.remove = snd_seq_gf1_remove;
-	ops->kops.notify = snd_seq_gf1_notify;
-	ops->kops.next = next;
-	return 0;
-}
-
-/*
- *  Init part
- */
-
-static int __init alsa_ainstr_gf1_init(void)
-{
-	return 0;
-}
-
-static void __exit alsa_ainstr_gf1_exit(void)
-{
-}
-
-module_init(alsa_ainstr_gf1_init)
-module_exit(alsa_ainstr_gf1_exit)
-
-EXPORT_SYMBOL(snd_seq_gf1_init);
diff --git a/sound/core/seq/instr/ainstr_iw.c b/sound/core/seq/instr/ainstr_iw.c
deleted file mode 100644
index 6c40eb7..0000000
--- a/sound/core/seq/instr/ainstr_iw.c
+++ /dev/null
@@ -1,623 +0,0 @@
-/*
- *   IWFFFF - AMD InterWave (tm) - Instrument routines
- *   Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
- 
-#include <sound/driver.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <sound/core.h>
-#include <sound/ainstr_iw.h>
-#include <sound/initval.h>
-#include <asm/uaccess.h>
-
-MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
-MODULE_DESCRIPTION("Advanced Linux Sound Architecture IWFFFF support.");
-MODULE_LICENSE("GPL");
-
-static unsigned int snd_seq_iwffff_size(unsigned int size, unsigned int format)
-{
-	unsigned int result = size;
-	
-	if (format & IWFFFF_WAVE_16BIT)
-		result <<= 1;
-	if (format & IWFFFF_WAVE_STEREO)
-		result <<= 1;
-	return result;
-}
-
-static void snd_seq_iwffff_copy_lfo_from_stream(struct iwffff_lfo *fp,
-						struct iwffff_xlfo *fx)
-{
-	fp->freq = le16_to_cpu(fx->freq);
-	fp->depth = le16_to_cpu(fx->depth);
-	fp->sweep = le16_to_cpu(fx->sweep);
-	fp->shape = fx->shape;
-	fp->delay = fx->delay;
-}
-
-static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype,
-					       struct iwffff_layer *lp,
-					       struct iwffff_env *ep,
-					       struct iwffff_xenv *ex,
-					       char __user **data,
-					       long *len,
-					       gfp_t gfp_mask)
-{
-	__u32 stype;
-	struct iwffff_env_record *rp, *rp_last;
-	struct iwffff_xenv_record rx;
-	struct iwffff_env_point *pp;
-	struct iwffff_xenv_point px;
-	int points_size, idx;
-
-	ep->flags = ex->flags;
-	ep->mode = ex->mode;
-	ep->index = ex->index;
-	rp_last = NULL;
-	while (1) {
-		if (*len < (long)sizeof(__u32))
-			return -EINVAL;
-		if (copy_from_user(&stype, *data, sizeof(stype)))
-			return -EFAULT;
-		if (stype == IWFFFF_STRU_WAVE)
-			return 0;
-		if (req_stype != stype) {
-			if (stype == IWFFFF_STRU_ENV_RECP ||
-			    stype == IWFFFF_STRU_ENV_RECV)
-				return 0;
-		}
-		if (*len < (long)sizeof(rx))
-			return -EINVAL;
-		if (copy_from_user(&rx, *data, sizeof(rx)))
-			return -EFAULT;
-		*data += sizeof(rx);
-		*len -= sizeof(rx);
-		points_size = (le16_to_cpu(rx.nattack) + le16_to_cpu(rx.nrelease)) * 2 * sizeof(__u16);
-		if (points_size > *len)
-			return -EINVAL;
-		rp = kzalloc(sizeof(*rp) + points_size, gfp_mask);
-		if (rp == NULL)
-			return -ENOMEM;
-		rp->nattack = le16_to_cpu(rx.nattack);
-		rp->nrelease = le16_to_cpu(rx.nrelease);
-		rp->sustain_offset = le16_to_cpu(rx.sustain_offset);
-		rp->sustain_rate = le16_to_cpu(rx.sustain_rate);
-		rp->release_rate = le16_to_cpu(rx.release_rate);
-		rp->hirange = rx.hirange;
-		pp = (struct iwffff_env_point *)(rp + 1);
-		for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
-			if (copy_from_user(&px, *data, sizeof(px)))
-				return -EFAULT;
-			*data += sizeof(px);
-			*len -= sizeof(px);
-			pp->offset = le16_to_cpu(px.offset);
-			pp->rate = le16_to_cpu(px.rate);
-		}
-		if (ep->record == NULL) {
-			ep->record = rp;
-		} else {
-			rp_last = rp;
-		}
-		rp_last = rp;
-	}
-	return 0;
-}
-
-static int snd_seq_iwffff_copy_wave_from_stream(struct snd_iwffff_ops *ops,
-						struct iwffff_layer *lp,
-					        char __user **data,
-					        long *len,
-					        int atomic)
-{
-	struct iwffff_wave *wp, *prev;
-	struct iwffff_xwave xp;
-	int err;
-	gfp_t gfp_mask;
-	unsigned int real_size;
-	
-	gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
-	if (*len < (long)sizeof(xp))
-		return -EINVAL;
-	if (copy_from_user(&xp, *data, sizeof(xp)))
-		return -EFAULT;
-	*data += sizeof(xp);
-	*len -= sizeof(xp);
-	wp = kzalloc(sizeof(*wp), gfp_mask);
-	if (wp == NULL)
-		return -ENOMEM;
-	wp->share_id[0] = le32_to_cpu(xp.share_id[0]);
-	wp->share_id[1] = le32_to_cpu(xp.share_id[1]);
-	wp->share_id[2] = le32_to_cpu(xp.share_id[2]);
-	wp->share_id[3] = le32_to_cpu(xp.share_id[3]);
-	wp->format = le32_to_cpu(xp.format);
-	wp->address.memory = le32_to_cpu(xp.offset);
-	wp->size = le32_to_cpu(xp.size);
-	wp->start = le32_to_cpu(xp.start);
-	wp->loop_start = le32_to_cpu(xp.loop_start);
-	wp->loop_end = le32_to_cpu(xp.loop_end);
-	wp->loop_repeat = le16_to_cpu(xp.loop_repeat);
-	wp->sample_ratio = le32_to_cpu(xp.sample_ratio);
-	wp->attenuation = xp.attenuation;
-	wp->low_note = xp.low_note;
-	wp->high_note = xp.high_note;
-	real_size = snd_seq_iwffff_size(wp->size, wp->format);
-	if (!(wp->format & IWFFFF_WAVE_ROM)) {
-		if ((long)real_size > *len) {
-			kfree(wp);
-			return -ENOMEM;
-		}
-	}
-	if (ops->put_sample) {
-		err = ops->put_sample(ops->private_data, wp,
-				      *data, real_size, atomic);
-		if (err < 0) {
-			kfree(wp);
-			return err;
-		}
-	}
-	if (!(wp->format & IWFFFF_WAVE_ROM)) {
-		*data += real_size;
-		*len -= real_size;
-	}
-	prev = lp->wave;
-	if (prev) {
-		while (prev->next) prev = prev->next;
-		prev->next = wp;
-	} else {
-		lp->wave = wp;
-	}
-	return 0;
-}
-
-static void snd_seq_iwffff_env_free(struct snd_iwffff_ops *ops,
-				    struct iwffff_env *env,
-				    int atomic)
-{
-	struct iwffff_env_record *rec;
-	
-	while ((rec = env->record) != NULL) {
-		env->record = rec->next;
-		kfree(rec);
-	}
-}
-				    
-static void snd_seq_iwffff_wave_free(struct snd_iwffff_ops *ops,
-				     struct iwffff_wave *wave,
-				     int atomic)
-{
-	if (ops->remove_sample)
-		ops->remove_sample(ops->private_data, wave, atomic);
-	kfree(wave);
-}
-
-static void snd_seq_iwffff_instr_free(struct snd_iwffff_ops *ops,
-                                      struct iwffff_instrument *ip,
-                                      int atomic)
-{
-	struct iwffff_layer *layer;
-	struct iwffff_wave *wave;
-	
-	while ((layer = ip->layer) != NULL) {
-		ip->layer = layer->next;
-		snd_seq_iwffff_env_free(ops, &layer->penv, atomic);
-		snd_seq_iwffff_env_free(ops, &layer->venv, atomic);
-		while ((wave = layer->wave) != NULL) {
-			layer->wave = wave->next;
-			snd_seq_iwffff_wave_free(ops, wave, atomic);
-		}
-		kfree(layer);
-	}
-}
-
-static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr,
-			      char __user *instr_data, long len, int atomic,
-			      int cmd)
-{
-	struct snd_iwffff_ops *ops = private_data;
-	struct iwffff_instrument *ip;
-	struct iwffff_xinstrument ix;
-	struct iwffff_layer *lp, *prev_lp;
-	struct iwffff_xlayer lx;
-	int err;
-	gfp_t gfp_mask;
-
-	if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
-		return -EINVAL;
-	gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
-	/* copy instrument data */
-	if (len < (long)sizeof(ix))
-		return -EINVAL;
-	if (copy_from_user(&ix, instr_data, sizeof(ix)))
-		return -EFAULT;
-	if (ix.stype != IWFFFF_STRU_INSTR)
-		return -EINVAL;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	ip = (struct iwffff_instrument *)KINSTR_DATA(instr);
-	ip->exclusion = le16_to_cpu(ix.exclusion);
-	ip->layer_type = le16_to_cpu(ix.layer_type);
-	ip->exclusion_group = le16_to_cpu(ix.exclusion_group);
-	ip->effect1 = ix.effect1;
-	ip->effect1_depth = ix.effect1_depth;
-	ip->effect2 = ix.effect2;
-	ip->effect2_depth = ix.effect2_depth;
-	/* copy layers */
-	prev_lp = NULL;
-	while (len > 0) {
-		if (len < (long)sizeof(struct iwffff_xlayer)) {
-			snd_seq_iwffff_instr_free(ops, ip, atomic);
-			return -EINVAL;
-		}
-		if (copy_from_user(&lx, instr_data, sizeof(lx)))
-			return -EFAULT;
-		instr_data += sizeof(lx);
-		len -= sizeof(lx);
-		if (lx.stype != IWFFFF_STRU_LAYER) {
-			snd_seq_iwffff_instr_free(ops, ip, atomic);
-			return -EINVAL;
-		}
-		lp = kzalloc(sizeof(*lp), gfp_mask);
-		if (lp == NULL) {
-			snd_seq_iwffff_instr_free(ops, ip, atomic);
-			return -ENOMEM;
-		}
-		if (prev_lp) {
-			prev_lp->next = lp;
-		} else {
-			ip->layer = lp;
-		}
-		prev_lp = lp;
-		lp->flags = lx.flags;
-		lp->velocity_mode = lx.velocity_mode;
-		lp->layer_event = lx.layer_event;
-		lp->low_range = lx.low_range;
-		lp->high_range = lx.high_range;
-		lp->pan = lx.pan;
-		lp->pan_freq_scale = lx.pan_freq_scale;
-		lp->attenuation = lx.attenuation;
-		snd_seq_iwffff_copy_lfo_from_stream(&lp->tremolo, &lx.tremolo);
-		snd_seq_iwffff_copy_lfo_from_stream(&lp->vibrato, &lx.vibrato);
-		lp->freq_scale = le16_to_cpu(lx.freq_scale);
-		lp->freq_center = lx.freq_center;
-		err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECP,
-							  lp,
-							  &lp->penv, &lx.penv,
-						          &instr_data, &len,
-						          gfp_mask);
-		if (err < 0) {
-			snd_seq_iwffff_instr_free(ops, ip, atomic);
-			return err;
-		}
-		err = snd_seq_iwffff_copy_env_from_stream(IWFFFF_STRU_ENV_RECV,
-							  lp,
-							  &lp->venv, &lx.venv,
-						          &instr_data, &len,
-						          gfp_mask);
-		if (err < 0) {
-			snd_seq_iwffff_instr_free(ops, ip, atomic);
-			return err;
-		}
-		while (len > (long)sizeof(__u32)) {
-			__u32 stype;
-
-			if (copy_from_user(&stype, instr_data, sizeof(stype)))
-				return -EFAULT;
-			if (stype != IWFFFF_STRU_WAVE)
-				break;
-			err = snd_seq_iwffff_copy_wave_from_stream(ops,
-								   lp,
-							    	   &instr_data,
-								   &len,
-								   atomic);
-			if (err < 0) {
-				snd_seq_iwffff_instr_free(ops, ip, atomic);
-				return err;
-			}
-		}
-	}
-	return 0;
-}
-
-static void snd_seq_iwffff_copy_lfo_to_stream(struct iwffff_xlfo *fx,
-					      struct iwffff_lfo *fp)
-{
-	fx->freq = cpu_to_le16(fp->freq);
-	fx->depth = cpu_to_le16(fp->depth);
-	fx->sweep = cpu_to_le16(fp->sweep);
-	fp->shape = fx->shape;
-	fp->delay = fx->delay;
-}
-
-static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype,
-					     struct iwffff_layer *lp,
-					     struct iwffff_xenv *ex,
-					     struct iwffff_env *ep,
-					     char __user **data,
-					     long *len)
-{
-	struct iwffff_env_record *rp;
-	struct iwffff_xenv_record rx;
-	struct iwffff_env_point *pp;
-	struct iwffff_xenv_point px;
-	int points_size, idx;
-
-	ex->flags = ep->flags;
-	ex->mode = ep->mode;
-	ex->index = ep->index;
-	for (rp = ep->record; rp; rp = rp->next) {
-		if (*len < (long)sizeof(rx))
-			return -ENOMEM;
-		memset(&rx, 0, sizeof(rx));
-		rx.stype = req_stype;
-		rx.nattack = cpu_to_le16(rp->nattack);
-		rx.nrelease = cpu_to_le16(rp->nrelease);
-		rx.sustain_offset = cpu_to_le16(rp->sustain_offset);
-		rx.sustain_rate = cpu_to_le16(rp->sustain_rate);
-		rx.release_rate = cpu_to_le16(rp->release_rate);
-		rx.hirange = cpu_to_le16(rp->hirange);
-		if (copy_to_user(*data, &rx, sizeof(rx)))
-			return -EFAULT;
-		*data += sizeof(rx);
-		*len -= sizeof(rx);
-		points_size = (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
-		if (*len < points_size)
-			return -ENOMEM;
-		pp = (struct iwffff_env_point *)(rp + 1);
-		for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) {
-			px.offset = cpu_to_le16(pp->offset);
-			px.rate = cpu_to_le16(pp->rate);
-			if (copy_to_user(*data, &px, sizeof(px)))
-				return -EFAULT;
-			*data += sizeof(px);
-			*len -= sizeof(px);
-		}
-	}
-	return 0;
-}
-
-static int snd_seq_iwffff_copy_wave_to_stream(struct snd_iwffff_ops *ops,
-					      struct iwffff_layer *lp,
-					      char __user **data,
-					      long *len,
-					      int atomic)
-{
-	struct iwffff_wave *wp;
-	struct iwffff_xwave xp;
-	int err;
-	unsigned int real_size;
-	
-	for (wp = lp->wave; wp; wp = wp->next) {
-		if (*len < (long)sizeof(xp))
-			return -ENOMEM;
-		memset(&xp, 0, sizeof(xp));
-		xp.stype = IWFFFF_STRU_WAVE;
-		xp.share_id[0] = cpu_to_le32(wp->share_id[0]);
-		xp.share_id[1] = cpu_to_le32(wp->share_id[1]);
-		xp.share_id[2] = cpu_to_le32(wp->share_id[2]);
-		xp.share_id[3] = cpu_to_le32(wp->share_id[3]);
-		xp.format = cpu_to_le32(wp->format);
-		if (wp->format & IWFFFF_WAVE_ROM)
-			xp.offset = cpu_to_le32(wp->address.memory);
-		xp.size = cpu_to_le32(wp->size);
-		xp.start = cpu_to_le32(wp->start);
-		xp.loop_start = cpu_to_le32(wp->loop_start);
-		xp.loop_end = cpu_to_le32(wp->loop_end);
-		xp.loop_repeat = cpu_to_le32(wp->loop_repeat);
-		xp.sample_ratio = cpu_to_le32(wp->sample_ratio);
-		xp.attenuation = wp->attenuation;
-		xp.low_note = wp->low_note;
-		xp.high_note = wp->high_note;
-		if (copy_to_user(*data, &xp, sizeof(xp)))
-			return -EFAULT;
-		*data += sizeof(xp);
-		*len -= sizeof(xp);
-		real_size = snd_seq_iwffff_size(wp->size, wp->format);
-		if (!(wp->format & IWFFFF_WAVE_ROM)) {
-			if (*len < (long)real_size)
-				return -ENOMEM;
-		}
-		if (ops->get_sample) {
-			err = ops->get_sample(ops->private_data, wp,
-					      *data, real_size, atomic);
-			if (err < 0)
-				return err;
-		}
-		if (!(wp->format & IWFFFF_WAVE_ROM)) {
-			*data += real_size;
-			*len -= real_size;
-		}
-	}
-	return 0;
-}
-
-static int snd_seq_iwffff_get(void *private_data, struct snd_seq_kinstr *instr,
-			      char __user *instr_data, long len, int atomic, int cmd)
-{
-	struct snd_iwffff_ops *ops = private_data;
-	struct iwffff_instrument *ip;
-	struct iwffff_xinstrument ix;
-	struct iwffff_layer *lp;
-	struct iwffff_xlayer lx;
-	char __user *layer_instr_data;
-	int err;
-	
-	if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
-		return -EINVAL;
-	if (len < (long)sizeof(ix))
-		return -ENOMEM;
-	memset(&ix, 0, sizeof(ix));
-	ip = (struct iwffff_instrument *)KINSTR_DATA(instr);
-	ix.stype = IWFFFF_STRU_INSTR;
-	ix.exclusion = cpu_to_le16(ip->exclusion);
-	ix.layer_type = cpu_to_le16(ip->layer_type);
-	ix.exclusion_group = cpu_to_le16(ip->exclusion_group);
-	ix.effect1 = cpu_to_le16(ip->effect1);
-	ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
-	ix.effect2 = ip->effect2;
-	ix.effect2_depth = ip->effect2_depth;
-	if (copy_to_user(instr_data, &ix, sizeof(ix)))
-		return -EFAULT;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	for (lp = ip->layer; lp; lp = lp->next) {
-		if (len < (long)sizeof(lx))
-			return -ENOMEM;
-		memset(&lx, 0, sizeof(lx));
-		lx.stype = IWFFFF_STRU_LAYER;
-		lx.flags = lp->flags;
-		lx.velocity_mode = lp->velocity_mode;
-		lx.layer_event = lp->layer_event;
-		lx.low_range = lp->low_range;
-		lx.high_range = lp->high_range;
-		lx.pan = lp->pan;
-		lx.pan_freq_scale = lp->pan_freq_scale;
-		lx.attenuation = lp->attenuation;
-		snd_seq_iwffff_copy_lfo_to_stream(&lx.tremolo, &lp->tremolo);
-		snd_seq_iwffff_copy_lfo_to_stream(&lx.vibrato, &lp->vibrato);
-		layer_instr_data = instr_data;
-		instr_data += sizeof(lx);
-		len -= sizeof(lx);
-		err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECP,
-							lp,
-							&lx.penv, &lp->penv,
-						        &instr_data, &len);
-		if (err < 0)
-			return err;
-		err = snd_seq_iwffff_copy_env_to_stream(IWFFFF_STRU_ENV_RECV,
-							lp,
-							&lx.venv, &lp->venv,
-						        &instr_data, &len);
-		if (err < 0)
-			return err;
-		/* layer structure updating is now finished */
-		if (copy_to_user(layer_instr_data, &lx, sizeof(lx)))
-			return -EFAULT;
-		err = snd_seq_iwffff_copy_wave_to_stream(ops,
-							 lp,
-							 &instr_data,
-							 &len,
-							 atomic);
-		if (err < 0)
-			return err;
-	}
-	return 0;
-}
-
-static long snd_seq_iwffff_env_size_in_stream(struct iwffff_env *ep)
-{
-	long result = 0;
-	struct iwffff_env_record *rp;
-
-	for (rp = ep->record; rp; rp = rp->next) {
-		result += sizeof(struct iwffff_xenv_record);
-		result += (rp->nattack + rp->nrelease) * 2 * sizeof(__u16);
-	}
-	return 0;
-}
-
-static long snd_seq_iwffff_wave_size_in_stream(struct iwffff_layer *lp)
-{
-	long result = 0;
-	struct iwffff_wave *wp;
-	
-	for (wp = lp->wave; wp; wp = wp->next) {
-		result += sizeof(struct iwffff_xwave);
-		if (!(wp->format & IWFFFF_WAVE_ROM))
-			result += wp->size;
-	}
-	return result;
-}
-
-static int snd_seq_iwffff_get_size(void *private_data, struct snd_seq_kinstr *instr,
-				   long *size)
-{
-	long result;
-	struct iwffff_instrument *ip;
-	struct iwffff_layer *lp;
-
-	*size = 0;
-	ip = (struct iwffff_instrument *)KINSTR_DATA(instr);
-	result = sizeof(struct iwffff_xinstrument);
-	for (lp = ip->layer; lp; lp = lp->next) {
-		result += sizeof(struct iwffff_xlayer);
-		result += snd_seq_iwffff_env_size_in_stream(&lp->penv);
-		result += snd_seq_iwffff_env_size_in_stream(&lp->venv);
-		result += snd_seq_iwffff_wave_size_in_stream(lp);
-	}
-	*size = result;
-	return 0;
-}
-
-static int snd_seq_iwffff_remove(void *private_data,
-				 struct snd_seq_kinstr *instr,
-                                 int atomic)
-{
-	struct snd_iwffff_ops *ops = private_data;
-	struct iwffff_instrument *ip;
-
-	ip = (struct iwffff_instrument *)KINSTR_DATA(instr);
-	snd_seq_iwffff_instr_free(ops, ip, atomic);
-	return 0;
-}
-
-static void snd_seq_iwffff_notify(void *private_data,
-				  struct snd_seq_kinstr *instr,
-                                  int what)
-{
-	struct snd_iwffff_ops *ops = private_data;
-
-	if (ops->notify)
-		ops->notify(ops->private_data, instr, what);
-}
-
-int snd_seq_iwffff_init(struct snd_iwffff_ops *ops,
-			void *private_data,
-			struct snd_seq_kinstr_ops *next)
-{
-	memset(ops, 0, sizeof(*ops));
-	ops->private_data = private_data;
-	ops->kops.private_data = ops;
-	ops->kops.add_len = sizeof(struct iwffff_instrument);
-	ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_INTERWAVE;
-	ops->kops.put = snd_seq_iwffff_put;
-	ops->kops.get = snd_seq_iwffff_get;
-	ops->kops.get_size = snd_seq_iwffff_get_size;
-	ops->kops.remove = snd_seq_iwffff_remove;
-	ops->kops.notify = snd_seq_iwffff_notify;
-	ops->kops.next = next;
-	return 0;
-}
-
-/*
- *  Init part
- */
-
-static int __init alsa_ainstr_iw_init(void)
-{
-	return 0;
-}
-
-static void __exit alsa_ainstr_iw_exit(void)
-{
-}
-
-module_init(alsa_ainstr_iw_init)
-module_exit(alsa_ainstr_iw_exit)
-
-EXPORT_SYMBOL(snd_seq_iwffff_init);
diff --git a/sound/core/seq/instr/ainstr_simple.c b/sound/core/seq/instr/ainstr_simple.c
deleted file mode 100644
index 78f68be..0000000
--- a/sound/core/seq/instr/ainstr_simple.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- *   Simple (MOD player) - Instrument routines
- *   Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
- 
-#include <sound/driver.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <sound/core.h>
-#include <sound/ainstr_simple.h>
-#include <sound/initval.h>
-#include <asm/uaccess.h>
-
-MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
-MODULE_DESCRIPTION("Advanced Linux Sound Architecture Simple Instrument support.");
-MODULE_LICENSE("GPL");
-
-static unsigned int snd_seq_simple_size(unsigned int size, unsigned int format)
-{
-	unsigned int result = size;
-	
-	if (format & SIMPLE_WAVE_16BIT)
-		result <<= 1;
-	if (format & SIMPLE_WAVE_STEREO)
-		result <<= 1;
-	return result;
-}
-
-static void snd_seq_simple_instr_free(struct snd_simple_ops *ops,
-				      struct simple_instrument *ip,
-				      int atomic)
-{
-	if (ops->remove_sample)
-		ops->remove_sample(ops->private_data, ip, atomic);
-}
-
-static int snd_seq_simple_put(void *private_data, struct snd_seq_kinstr *instr,
-			      char __user *instr_data, long len,
-			      int atomic, int cmd)
-{
-	struct snd_simple_ops *ops = private_data;
-	struct simple_instrument *ip;
-	struct simple_xinstrument ix;
-	int err;
-	gfp_t gfp_mask;
-	unsigned int real_size;
-
-	if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE)
-		return -EINVAL;
-	gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL;
-	/* copy instrument data */
-	if (len < (long)sizeof(ix))
-		return -EINVAL;
-	if (copy_from_user(&ix, instr_data, sizeof(ix)))
-		return -EFAULT;
-	if (ix.stype != SIMPLE_STRU_INSTR)
-		return -EINVAL;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	ip = (struct simple_instrument *)KINSTR_DATA(instr);
-	ip->share_id[0] = le32_to_cpu(ix.share_id[0]);
-	ip->share_id[1] = le32_to_cpu(ix.share_id[1]);
-	ip->share_id[2] = le32_to_cpu(ix.share_id[2]);
-	ip->share_id[3] = le32_to_cpu(ix.share_id[3]);
-	ip->format = le32_to_cpu(ix.format);
-	ip->size = le32_to_cpu(ix.size);
-	ip->start = le32_to_cpu(ix.start);
-	ip->loop_start = le32_to_cpu(ix.loop_start);
-	ip->loop_end = le32_to_cpu(ix.loop_end);
-	ip->loop_repeat = le16_to_cpu(ix.loop_repeat);
-	ip->effect1 = ix.effect1;
-	ip->effect1_depth = ix.effect1_depth;
-	ip->effect2 = ix.effect2;
-	ip->effect2_depth = ix.effect2_depth;
-	real_size = snd_seq_simple_size(ip->size, ip->format);
-	if (len < (long)real_size)
-		return -EINVAL;
-	if (ops->put_sample) {
-		err = ops->put_sample(ops->private_data, ip,
-				      instr_data, real_size, atomic);
-		if (err < 0)
-			return err;
-	}
-	return 0;
-}
-
-static int snd_seq_simple_get(void *private_data, struct snd_seq_kinstr *instr,
-			      char __user *instr_data, long len,
-			      int atomic, int cmd)
-{
-	struct snd_simple_ops *ops = private_data;
-	struct simple_instrument *ip;
-	struct simple_xinstrument ix;
-	int err;
-	unsigned int real_size;
-	
-	if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL)
-		return -EINVAL;
-	if (len < (long)sizeof(ix))
-		return -ENOMEM;
-	memset(&ix, 0, sizeof(ix));
-	ip = (struct simple_instrument *)KINSTR_DATA(instr);
-	ix.stype = SIMPLE_STRU_INSTR;
-	ix.share_id[0] = cpu_to_le32(ip->share_id[0]);
-	ix.share_id[1] = cpu_to_le32(ip->share_id[1]);
-	ix.share_id[2] = cpu_to_le32(ip->share_id[2]);
-	ix.share_id[3] = cpu_to_le32(ip->share_id[3]);
-	ix.format = cpu_to_le32(ip->format);
-	ix.size = cpu_to_le32(ip->size);
-	ix.start = cpu_to_le32(ip->start);
-	ix.loop_start = cpu_to_le32(ip->loop_start);
-	ix.loop_end = cpu_to_le32(ip->loop_end);
-	ix.loop_repeat = cpu_to_le32(ip->loop_repeat);
-	ix.effect1 = cpu_to_le16(ip->effect1);
-	ix.effect1_depth = cpu_to_le16(ip->effect1_depth);
-	ix.effect2 = ip->effect2;
-	ix.effect2_depth = ip->effect2_depth;
-	if (copy_to_user(instr_data, &ix, sizeof(ix)))
-		return -EFAULT;
-	instr_data += sizeof(ix);
-	len -= sizeof(ix);
-	real_size = snd_seq_simple_size(ip->size, ip->format);
-	if (len < (long)real_size)
-		return -ENOMEM;
-	if (ops->get_sample) {
-		err = ops->get_sample(ops->private_data, ip,
-				      instr_data, real_size, atomic);
-		if (err < 0)
-			return err;
-	}
-	return 0;
-}
-
-static int snd_seq_simple_get_size(void *private_data, struct snd_seq_kinstr *instr,
-				   long *size)
-{
-	struct simple_instrument *ip;
-
-	ip = (struct simple_instrument *)KINSTR_DATA(instr);
-	*size = sizeof(struct simple_xinstrument) + snd_seq_simple_size(ip->size, ip->format);
-	return 0;
-}
-
-static int snd_seq_simple_remove(void *private_data,
-			         struct snd_seq_kinstr *instr,
-                                 int atomic)
-{
-	struct snd_simple_ops *ops = private_data;
-	struct simple_instrument *ip;
-
-	ip = (struct simple_instrument *)KINSTR_DATA(instr);
-	snd_seq_simple_instr_free(ops, ip, atomic);
-	return 0;
-}
-
-static void snd_seq_simple_notify(void *private_data,
-			          struct snd_seq_kinstr *instr,
-                                  int what)
-{
-	struct snd_simple_ops *ops = private_data;
-
-	if (ops->notify)
-		ops->notify(ops->private_data, instr, what);
-}
-
-int snd_seq_simple_init(struct snd_simple_ops *ops,
-		        void *private_data,
-		        struct snd_seq_kinstr_ops *next)
-{
-	memset(ops, 0, sizeof(*ops));
-	ops->private_data = private_data;
-	ops->kops.private_data = ops;
-	ops->kops.add_len = sizeof(struct simple_instrument);
-	ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_SIMPLE;
-	ops->kops.put = snd_seq_simple_put;
-	ops->kops.get = snd_seq_simple_get;
-	ops->kops.get_size = snd_seq_simple_get_size;
-	ops->kops.remove = snd_seq_simple_remove;
-	ops->kops.notify = snd_seq_simple_notify;
-	ops->kops.next = next;
-	return 0;
-}
-
-/*
- *  Init part
- */
-
-static int __init alsa_ainstr_simple_init(void)
-{
-	return 0;
-}
-
-static void __exit alsa_ainstr_simple_exit(void)
-{
-}
-
-module_init(alsa_ainstr_simple_init)
-module_exit(alsa_ainstr_simple_exit)
-
-EXPORT_SYMBOL(snd_seq_simple_init);
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 2e3fa25..69421ca 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -966,8 +966,7 @@ static int check_event_type_and_length(struct snd_seq_event *ev)
 			return -EINVAL;
 		break;
 	case SNDRV_SEQ_EVENT_LENGTH_VARUSR:
-		if (! snd_seq_ev_is_instr_type(ev) ||
-		    ! snd_seq_ev_is_direct(ev))
+		if (! snd_seq_ev_is_direct(ev))
 			return -EINVAL;
 		break;
 	}
diff --git a/sound/core/seq/seq_instr.c b/sound/core/seq/seq_instr.c
deleted file mode 100644
index 9a6fd56..0000000
--- a/sound/core/seq/seq_instr.c
+++ /dev/null
@@ -1,655 +0,0 @@
-/*
- *   Generic Instrument routines for ALSA sequencer
- *   Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
- 
-#include <sound/driver.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <sound/core.h>
-#include "seq_clientmgr.h"
-#include <sound/seq_instr.h>
-#include <sound/initval.h>
-
-MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
-MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer instrument library.");
-MODULE_LICENSE("GPL");
-
-
-static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list)
-{
-	if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
-		spin_lock_irqsave(&list->ops_lock, list->ops_flags);
-	} else {
-		mutex_lock(&list->ops_mutex);
-	}
-}
-
-static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list)
-{
-	if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) {
-		spin_unlock_irqrestore(&list->ops_lock, list->ops_flags);
-	} else {
-		mutex_unlock(&list->ops_mutex);
-	}
-}
-
-static struct snd_seq_kinstr *snd_seq_instr_new(int add_len, int atomic)
-{
-	struct snd_seq_kinstr *instr;
-	
-	instr = kzalloc(sizeof(struct snd_seq_kinstr) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL);
-	if (instr == NULL)
-		return NULL;
-	instr->add_len = add_len;
-	return instr;
-}
-
-static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic)
-{
-	int result = 0;
-
-	if (instr == NULL)
-		return -EINVAL;
-	if (instr->ops && instr->ops->remove)
-		result = instr->ops->remove(instr->ops->private_data, instr, 1);
-	if (!result)
-		kfree(instr);
-	return result;
-}
-
-struct snd_seq_kinstr_list *snd_seq_instr_list_new(void)
-{
-	struct snd_seq_kinstr_list *list;
-
-	list = kzalloc(sizeof(struct snd_seq_kinstr_list), GFP_KERNEL);
-	if (list == NULL)
-		return NULL;
-	spin_lock_init(&list->lock);
-	spin_lock_init(&list->ops_lock);
-	mutex_init(&list->ops_mutex);
-	list->owner = -1;
-	return list;
-}
-
-void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr)
-{
-	struct snd_seq_kinstr_list *list;
-	struct snd_seq_kinstr *instr;
-	struct snd_seq_kcluster *cluster;
-	int idx;
-	unsigned long flags;
-
-	if (list_ptr == NULL)
-		return;
-	list = *list_ptr;
-	*list_ptr = NULL;
-	if (list == NULL)
-		return;
-	
-	for (idx = 0; idx < SNDRV_SEQ_INSTR_HASH_SIZE; idx++) {		
-		while ((instr = list->hash[idx]) != NULL) {
-			list->hash[idx] = instr->next;
-			list->count--;
-			spin_lock_irqsave(&list->lock, flags);
-			while (instr->use) {
-				spin_unlock_irqrestore(&list->lock, flags);
-				schedule_timeout_uninterruptible(1);
-				spin_lock_irqsave(&list->lock, flags);
-			}				
-			spin_unlock_irqrestore(&list->lock, flags);
-			if (snd_seq_instr_free(instr, 0)<0)
-				snd_printk(KERN_WARNING "instrument free problem\n");
-		}
-		while ((cluster = list->chash[idx]) != NULL) {
-			list->chash[idx] = cluster->next;
-			list->ccount--;
-			kfree(cluster);
-		}
-	}
-	kfree(list);
-}
-
-static int instr_free_compare(struct snd_seq_kinstr *instr,
-			      struct snd_seq_instr_header *ifree,
-			      unsigned int client)
-{
-	switch (ifree->cmd) {
-	case SNDRV_SEQ_INSTR_FREE_CMD_ALL:
-		/* all, except private for other clients */
-		if ((instr->instr.std & 0xff000000) == 0)
-			return 0;
-		if (((instr->instr.std >> 24) & 0xff) == client)
-			return 0;
-		return 1;
-	case SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE:
-		/* all my private instruments */
-		if ((instr->instr.std & 0xff000000) == 0)
-			return 1;
-		if (((instr->instr.std >> 24) & 0xff) == client)
-			return 0;
-		return 1;
-	case SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER:
-		/* all my private instruments */
-		if ((instr->instr.std & 0xff000000) == 0) {
-			if (instr->instr.cluster == ifree->id.cluster)
-				return 0;
-			return 1;
-		}
-		if (((instr->instr.std >> 24) & 0xff) == client) {
-			if (instr->instr.cluster == ifree->id.cluster)
-				return 0;
-		}
-		return 1;
-	}
-	return 1;
-}
-
-int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list,
-			         struct snd_seq_instr_header *ifree,
-			         int client,
-			         int atomic)
-{
-	struct snd_seq_kinstr *instr, *prev, *next, *flist;
-	int idx;
-	unsigned long flags;
-
-	snd_instr_lock_ops(list);
-	for (idx = 0; idx < SNDRV_SEQ_INSTR_HASH_SIZE; idx++) {
-		spin_lock_irqsave(&list->lock, flags);
-		instr = list->hash[idx];
-		prev = flist = NULL;
-		while (instr) {
-			while (instr && instr_free_compare(instr, ifree, (unsigned int)client)) {
-				prev = instr;
-				instr = instr->next;
-			}
-			if (instr == NULL)
-				continue;
-			if (instr->ops && instr->ops->notify)
-				instr->ops->notify(instr->ops->private_data, instr, SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
-			next = instr->next;
-			if (prev == NULL) {
-				list->hash[idx] = next;
-			} else {
-				prev->next = next;
-			}
-			list->count--;
-			instr->next = flist;
-			flist = instr;
-			instr = next;
-		}
-		spin_unlock_irqrestore(&list->lock, flags);
-		while (flist) {
-			instr = flist;
-			flist = instr->next;
-			while (instr->use) {
-				schedule_timeout_uninterruptible(1);
-				barrier();
-			}
-			if (snd_seq_instr_free(instr, atomic)<0)
-				snd_printk(KERN_WARNING "instrument free problem\n");
-			instr = next;
-		}
-	}
-	snd_instr_unlock_ops(list);
-	return 0;	
-}
-
-static int compute_hash_instr_key(struct snd_seq_instr *instr)
-{
-	int result;
-	
-	result = instr->bank | (instr->prg << 16);
-	result += result >> 24;
-	result += result >> 16;
-	result += result >> 8;
-	return result & (SNDRV_SEQ_INSTR_HASH_SIZE-1);
-}
-
-#if 0
-static int compute_hash_cluster_key(snd_seq_instr_cluster_t cluster)
-{
-	int result;
-	
-	result = cluster;
-	result += result >> 24;
-	result += result >> 16;
-	result += result >> 8;
-	return result & (SNDRV_SEQ_INSTR_HASH_SIZE-1);
-}
-#endif
-
-static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int exact)
-{
-	if (exact) {
-		if (i1->cluster != i2->cluster ||
-		    i1->bank != i2->bank ||
-		    i1->prg != i2->prg)
-			return 1;
-		if ((i1->std & 0xff000000) != (i2->std & 0xff000000))
-			return 1;
-		if (!(i1->std & i2->std))
-			return 1;
-		return 0;
-	} else {
-		unsigned int client_check;
-		
-		if (i2->cluster && i1->cluster != i2->cluster)
-			return 1;
-		client_check = i2->std & 0xff000000;
-		if (client_check) {
-			if ((i1->std & 0xff000000) != client_check)
-				return 1;
-		} else {
-			if ((i1->std & i2->std) != i2->std)
-				return 1;
-		}
-		return i1->bank != i2->bank || i1->prg != i2->prg;
-	}
-}
-
-struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list,
-					  struct snd_seq_instr *instr,
-					  int exact,
-					  int follow_alias)
-{
-	unsigned long flags;
-	int depth = 0;
-	struct snd_seq_kinstr *result;
-
-	if (list == NULL || instr == NULL)
-		return NULL;
-	spin_lock_irqsave(&list->lock, flags);
-      __again:
-	result = list->hash[compute_hash_instr_key(instr)];
-	while (result) {
-		if (!compare_instr(&result->instr, instr, exact)) {
-			if (follow_alias && (result->type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)) {
-				instr = (struct snd_seq_instr *)KINSTR_DATA(result);
-				if (++depth > 10)
-					goto __not_found;
-				goto __again;
-			}
-			result->use++;
-			spin_unlock_irqrestore(&list->lock, flags);
-			return result;
-		}
-		result = result->next;
-	}
-      __not_found:
-	spin_unlock_irqrestore(&list->lock, flags);
-	return NULL;
-}
-
-void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list,
-			    struct snd_seq_kinstr *instr)
-{
-	unsigned long flags;
-
-	if (list == NULL || instr == NULL)
-		return;
-	spin_lock_irqsave(&list->lock, flags);
-	if (instr->use <= 0) {
-		snd_printk(KERN_ERR "free_use: fatal!!! use = %i, name = '%s'\n", instr->use, instr->name);
-	} else {
-		instr->use--;
-	}
-	spin_unlock_irqrestore(&list->lock, flags);
-}
-
-static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops,
-					    char *instr_type)
-{
-	while (ops) {
-		if (!strcmp(ops->instr_type, instr_type))
-			return ops;
-		ops = ops->next;
-	}
-	return NULL;
-}
-
-static int instr_result(struct snd_seq_event *ev,
-			int type, int result,
-			int atomic)
-{
-	struct snd_seq_event sev;
-	
-	memset(&sev, 0, sizeof(sev));
-	sev.type = SNDRV_SEQ_EVENT_RESULT;
-	sev.flags = SNDRV_SEQ_TIME_STAMP_REAL | SNDRV_SEQ_EVENT_LENGTH_FIXED |
-	            SNDRV_SEQ_PRIORITY_NORMAL;
-	sev.source = ev->dest;
-	sev.dest = ev->source;
-	sev.data.result.event = type;
-	sev.data.result.result = result;
-#if 0
-	printk("instr result - type = %i, result = %i, queue = %i, source.client:port = %i:%i, dest.client:port = %i:%i\n",
-				type, result,
-				sev.queue,
-				sev.source.client, sev.source.port,
-				sev.dest.client, sev.dest.port);
-#endif
-	return snd_seq_kernel_client_dispatch(sev.source.client, &sev, atomic, 0);
-}
-
-static int instr_begin(struct snd_seq_kinstr_ops *ops,
-		       struct snd_seq_kinstr_list *list,
-		       struct snd_seq_event *ev,
-		       int atomic, int hop)
-{
-	unsigned long flags;
-
-	spin_lock_irqsave(&list->lock, flags);
-	if (list->owner >= 0 && list->owner != ev->source.client) {
-		spin_unlock_irqrestore(&list->lock, flags);
-		return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, -EBUSY, atomic);
-	}
-	list->owner = ev->source.client;
-	spin_unlock_irqrestore(&list->lock, flags);
-	return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, 0, atomic);
-}
-
-static int instr_end(struct snd_seq_kinstr_ops *ops,
-		     struct snd_seq_kinstr_list *list,
-		     struct snd_seq_event *ev,
-		     int atomic, int hop)
-{
-	unsigned long flags;
-
-	/* TODO: timeout handling */
-	spin_lock_irqsave(&list->lock, flags);
-	if (list->owner == ev->source.client) {
-		list->owner = -1;
-		spin_unlock_irqrestore(&list->lock, flags);
-		return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, 0, atomic);
-	}
-	spin_unlock_irqrestore(&list->lock, flags);
-	return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, -EINVAL, atomic);
-}
-
-static int instr_info(struct snd_seq_kinstr_ops *ops,
-		      struct snd_seq_kinstr_list *list,
-		      struct snd_seq_event *ev,
-		      int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_format_info(struct snd_seq_kinstr_ops *ops,
-			     struct snd_seq_kinstr_list *list,
-			     struct snd_seq_event *ev,
-			     int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_reset(struct snd_seq_kinstr_ops *ops,
-		       struct snd_seq_kinstr_list *list,
-		       struct snd_seq_event *ev,
-		       int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_status(struct snd_seq_kinstr_ops *ops,
-			struct snd_seq_kinstr_list *list,
-			struct snd_seq_event *ev,
-			int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_put(struct snd_seq_kinstr_ops *ops,
-		     struct snd_seq_kinstr_list *list,
-		     struct snd_seq_event *ev,
-		     int atomic, int hop)
-{
-	unsigned long flags;
-	struct snd_seq_instr_header put;
-	struct snd_seq_kinstr *instr;
-	int result = -EINVAL, len, key;
-
-	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
-		goto __return;
-
-	if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
-		goto __return;
-	if (copy_from_user(&put, (void __user *)ev->data.ext.ptr,
-			   sizeof(struct snd_seq_instr_header))) {
-		result = -EFAULT;
-		goto __return;
-	}
-	snd_instr_lock_ops(list);
-	if (put.id.instr.std & 0xff000000) {	/* private instrument */
-		put.id.instr.std &= 0x00ffffff;
-		put.id.instr.std |= (unsigned int)ev->source.client << 24;
-	}
-	if ((instr = snd_seq_instr_find(list, &put.id.instr, 1, 0))) {
-		snd_seq_instr_free_use(list, instr);
-		snd_instr_unlock_ops(list);
-		result = -EBUSY;
-		goto __return;
-	}
-	ops = instr_ops(ops, put.data.data.format);
-	if (ops == NULL) {
-		snd_instr_unlock_ops(list);
-		goto __return;
-	}
-	len = ops->add_len;
-	if (put.data.type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)
-		len = sizeof(struct snd_seq_instr);
-	instr = snd_seq_instr_new(len, atomic);
-	if (instr == NULL) {
-		snd_instr_unlock_ops(list);
-		result = -ENOMEM;
-		goto __return;
-	}
-	instr->ops = ops;
-	instr->instr = put.id.instr;
-	strlcpy(instr->name, put.data.name, sizeof(instr->name));
-	instr->type = put.data.type;
-	if (instr->type == SNDRV_SEQ_INSTR_ATYPE_DATA) {
-		result = ops->put(ops->private_data,
-				  instr,
-				  (void __user *)ev->data.ext.ptr + sizeof(struct snd_seq_instr_header),
-				  ev->data.ext.len - sizeof(struct snd_seq_instr_header),
-				  atomic,
-				  put.cmd);
-		if (result < 0) {
-			snd_seq_instr_free(instr, atomic);
-			snd_instr_unlock_ops(list);
-			goto __return;
-		}
-	}
-	key = compute_hash_instr_key(&instr->instr);
-	spin_lock_irqsave(&list->lock, flags);
-	instr->next = list->hash[key];
-	list->hash[key] = instr;
-	list->count++;
-	spin_unlock_irqrestore(&list->lock, flags);
-	snd_instr_unlock_ops(list);
-	result = 0;
-      __return:
-	instr_result(ev, SNDRV_SEQ_EVENT_INSTR_PUT, result, atomic);
-	return result;
-}
-
-static int instr_get(struct snd_seq_kinstr_ops *ops,
-		     struct snd_seq_kinstr_list *list,
-		     struct snd_seq_event *ev,
-		     int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_free(struct snd_seq_kinstr_ops *ops,
-		      struct snd_seq_kinstr_list *list,
-		      struct snd_seq_event *ev,
-		      int atomic, int hop)
-{
-	struct snd_seq_instr_header ifree;
-	struct snd_seq_kinstr *instr, *prev;
-	int result = -EINVAL;
-	unsigned long flags;
-	unsigned int hash;
-
-	if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR)
-		goto __return;
-
-	if (ev->data.ext.len < sizeof(struct snd_seq_instr_header))
-		goto __return;
-	if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr,
-			   sizeof(struct snd_seq_instr_header))) {
-		result = -EFAULT;
-		goto __return;
-	}
-	if (ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_ALL ||
-	    ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE ||
-	    ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER) {
-	    	result = snd_seq_instr_list_free_cond(list, &ifree, ev->dest.client, atomic);
-	    	goto __return;
-	}
-	if (ifree.cmd == SNDRV_SEQ_INSTR_FREE_CMD_SINGLE) {
-		if (ifree.id.instr.std & 0xff000000) {
-			ifree.id.instr.std &= 0x00ffffff;
-			ifree.id.instr.std |= (unsigned int)ev->source.client << 24;
-		}
-		hash = compute_hash_instr_key(&ifree.id.instr);
-		snd_instr_lock_ops(list);
-		spin_lock_irqsave(&list->lock, flags);
-		instr = list->hash[hash];
-		prev = NULL;
-		while (instr) {
-			if (!compare_instr(&instr->instr, &ifree.id.instr, 1))
-				goto __free_single;
-			prev = instr;
-			instr = instr->next;
-		}
-		result = -ENOENT;
-		spin_unlock_irqrestore(&list->lock, flags);
-		snd_instr_unlock_ops(list);
-		goto __return;
-		
-	      __free_single:
-		if (prev) {
-			prev->next = instr->next;
-		} else {
-			list->hash[hash] = instr->next;
-		}
-		if (instr->ops && instr->ops->notify)
-			instr->ops->notify(instr->ops->private_data, instr,
-					   SNDRV_SEQ_INSTR_NOTIFY_REMOVE);
-		while (instr->use) {
-			spin_unlock_irqrestore(&list->lock, flags);
-			schedule_timeout_uninterruptible(1);
-			spin_lock_irqsave(&list->lock, flags);
-		}				
-		spin_unlock_irqrestore(&list->lock, flags);
-		result = snd_seq_instr_free(instr, atomic);
-		snd_instr_unlock_ops(list);
-		goto __return;
-	}
-
-      __return:
-	instr_result(ev, SNDRV_SEQ_EVENT_INSTR_FREE, result, atomic);
-	return result;
-}
-
-static int instr_list(struct snd_seq_kinstr_ops *ops,
-		      struct snd_seq_kinstr_list *list,
-		      struct snd_seq_event *ev,
-		      int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-static int instr_cluster(struct snd_seq_kinstr_ops *ops,
-			 struct snd_seq_kinstr_list *list,
-			 struct snd_seq_event *ev,
-			 int atomic, int hop)
-{
-	return -ENXIO;
-}
-
-int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops,
-			struct snd_seq_kinstr_list *list,
-			struct snd_seq_event *ev,
-			int client,
-			int atomic,
-			int hop)
-{
-	int direct = 0;
-
-	snd_assert(ops != NULL && list != NULL && ev != NULL, return -EINVAL);
-	if (snd_seq_ev_is_direct(ev)) {
-		direct = 1;
-		switch (ev->type) {
-		case SNDRV_SEQ_EVENT_INSTR_BEGIN:
-			return instr_begin(ops, list, ev, atomic, hop);
-		case SNDRV_SEQ_EVENT_INSTR_END:
-			return instr_end(ops, list, ev, atomic, hop);
-		}
-	}
-	if ((list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT) && !direct)
-		return -EINVAL;
-	switch (ev->type) {
-	case SNDRV_SEQ_EVENT_INSTR_INFO:
-		return instr_info(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_FINFO:
-		return instr_format_info(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_RESET:
-		return instr_reset(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_STATUS:
-		return instr_status(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_PUT:
-		return instr_put(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_GET:
-		return instr_get(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_FREE:
-		return instr_free(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_LIST:
-		return instr_list(ops, list, ev, atomic, hop);
-	case SNDRV_SEQ_EVENT_INSTR_CLUSTER:
-		return instr_cluster(ops, list, ev, atomic, hop);
-	}
-	return -EINVAL;
-}
-			
-/*
- *  Init part
- */
-
-static int __init alsa_seq_instr_init(void)
-{
-	return 0;
-}
-
-static void __exit alsa_seq_instr_exit(void)
-{
-}
-
-module_init(alsa_seq_instr_init)
-module_exit(alsa_seq_instr_exit)
-
-EXPORT_SYMBOL(snd_seq_instr_list_new);
-EXPORT_SYMBOL(snd_seq_instr_list_free);
-EXPORT_SYMBOL(snd_seq_instr_list_free_cond);
-EXPORT_SYMBOL(snd_seq_instr_find);
-EXPORT_SYMBOL(snd_seq_instr_free_use);
-EXPORT_SYMBOL(snd_seq_instr_event);
diff --git a/sound/core/seq/seq_midi_emul.c b/sound/core/seq/seq_midi_emul.c
index 17b3e6f..6645fc5 100644
--- a/sound/core/seq/seq_midi_emul.c
+++ b/sound/core/seq/seq_midi_emul.c
@@ -229,13 +229,6 @@ snd_midi_process_event(struct snd_midi_op *ops,
 	case SNDRV_SEQ_EVENT_PORT_START:
 	case SNDRV_SEQ_EVENT_PORT_EXIT:
 	case SNDRV_SEQ_EVENT_PORT_CHANGE:
-	case SNDRV_SEQ_EVENT_SAMPLE:
-	case SNDRV_SEQ_EVENT_SAMPLE_START:
-	case SNDRV_SEQ_EVENT_SAMPLE_STOP:
-	case SNDRV_SEQ_EVENT_SAMPLE_FREQ:
-	case SNDRV_SEQ_EVENT_SAMPLE_VOLUME:
-	case SNDRV_SEQ_EVENT_SAMPLE_LOOP:
-	case SNDRV_SEQ_EVENT_SAMPLE_POSITION:
 	case SNDRV_SEQ_EVENT_ECHO:
 	not_yet:
 	default: