60 files changed, 246 insertions, 2519 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index df0774c76f6f..01a1a5af47bb 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/threads.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
@@ -232,8 +231,6 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
         access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
                  (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
                                       SNDRV_CTL_ELEM_ACCESS_INACTIVE|
-                                      SNDRV_CTL_ELEM_ACCESS_DINDIRECT|
-                                      SNDRV_CTL_ELEM_ACCESS_INDIRECT|
                                       SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
                                       SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
         kctl.info = ncontrol->info;
@@ -692,7 +689,7 @@ int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
-        int result, indirect;
+        int result;
 
         down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &control->id);
@@ -701,17 +698,12 @@ int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
         } else {
                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
                 vd = &kctl->vd[index_offset];
-                indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
-                if (control->indirect != indirect) {
-                        result = -EACCES;
-                } else {
-                        if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) && kctl->get != NULL) {
-                                snd_ctl_build_ioff(&control->id, kctl, index_offset);
-                                result = kctl->get(kctl, control);
-                        } else {
-                                result = -EPERM;
-                        }
-                }
+                if ((vd->access & SNDRV_CTL_ELEM_ACCESS_READ) &&
+                    kctl->get != NULL) {
+                        snd_ctl_build_ioff(&control->id, kctl, index_offset);
+                        result = kctl->get(kctl, control);
+                } else
+                        result = -EPERM;
         }
         up_read(&card->controls_rwsem);
         return result;
@@ -748,7 +740,7 @@ int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
-        int result, indirect;
+        int result;
 
         down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &control->id);
@@ -757,23 +749,19 @@ int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
         } else {
                 index_offset = snd_ctl_get_ioff(kctl, &control->id);
                 vd = &kctl->vd[index_offset];
-                indirect = vd->access & SNDRV_CTL_ELEM_ACCESS_INDIRECT ? 1 : 0;
-                if (control->indirect != indirect) {
-                        result = -EACCES;
+                if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
+                    kctl->put == NULL ||
+                    (file && vd->owner && vd->owner != file)) {
+                        result = -EPERM;
                 } else {
-                        if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ||
-                            kctl->put == NULL ||
-                            (file && vd->owner != NULL && vd->owner != file)) {
-                                result = -EPERM;
-                        } else {
-                                snd_ctl_build_ioff(&control->id, kctl, index_offset);
-                                result = kctl->put(kctl, control);
-                        }
-                        if (result > 0) {
-                                up_read(&card->controls_rwsem);
-                                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &control->id);
-                                return 0;
-                        }
+                        snd_ctl_build_ioff(&control->id, kctl, index_offset);
+                        result = kctl->put(kctl, control);
+                }
+                if (result > 0) {
+                        up_read(&card->controls_rwsem);
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                       &control->id);
+                        return 0;
                 }
         }
         up_read(&card->controls_rwsem);
diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c
index 9311ca397bbc..6101259ad860 100644
--- a/sound/core/control_compat.c
+++ b/sound/core/control_compat.c
@@ -219,7 +219,8 @@ static int copy_ctl_value_from_user(struct snd_card *card,
                                     struct snd_ctl_elem_value32 __user *data32,
                                     int *typep, int *countp)
 {
-        int i, type, count, size;
+        int i, type, size;
+        int uninitialized_var(count);
         unsigned int indirect;
 
         if (copy_from_user(&data->id, &data32->id, sizeof(data->id)))
diff --git a/sound/core/device.c b/sound/core/device.c
index ea1a0621eefb..202dac0e4d89 100644
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/errno.h>
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index bfd9d182b8a3..6d6589f93899 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/major.h>
 #include <linux/init.h>
 #include <linux/slab.h>
diff --git a/sound/core/info.c b/sound/core/info.c
index 1ffd29bb4cd0..9977ec2eace3 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/smp_lock.h>
diff --git a/sound/core/info_oss.c b/sound/core/info_oss.c
index 435c9399f7a9..e35789a92752 100644
--- a/sound/core/info_oss.c
+++ b/sound/core/info_oss.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/string.h>
@@ -66,8 +65,6 @@ int snd_oss_info_register(int dev, int num, char *string)
 
 EXPORT_SYMBOL(snd_oss_info_register);
 
-extern void snd_card_info_read_oss(struct snd_info_buffer *buffer);
-
 static int snd_sndstat_show_strings(struct snd_info_buffer *buf, char *id, int dev)
 {
         int idx, ok = -1;
diff --git a/sound/core/init.c b/sound/core/init.c
index 2cb7099eb1e1..e3338d6071ef 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/file.h>
@@ -43,6 +42,40 @@ EXPORT_SYMBOL(snd_cards);
 
 static DEFINE_MUTEX(snd_card_mutex);
 
+static char *slots[SNDRV_CARDS];
+module_param_array(slots, charp, NULL, 0444);
+MODULE_PARM_DESC(slots, "Module names assigned to the slots.");
+
+/* return non-zero if the given index is already reserved for another
+ * module via slots option
+ */
+static int module_slot_mismatch(struct module *module, int idx)
+{
+#ifdef MODULE
+        char *s1, *s2;
+        if (!module || !module->name || !slots[idx])
+                return 0;
+        s1 = slots[idx];
+        s2 = module->name;
+        /* compare module name strings
+         * hyphens are handled as equivalent with underscore
+         */
+        for (;;) {
+                char c1 = *s1++;
+                char c2 = *s2++;
+                if (c1 == '-')
+                        c1 = '_';
+                if (c2 == '-')
+                        c2 = '_';
+                if (c1 != c2)
+                        return 1;
+                if (!c1)
+                        break;
+        }
+#endif
+        return 0;
+}
+
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
 int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
 EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
@@ -115,6 +148,8 @@ struct snd_card *snd_card_new(int idx, const char *xid,
                 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
                         /* idx == -1 == 0xffff means: take any free slot */
                         if (~snd_cards_lock & idx & 1<<idx2) {
+                                if (module_slot_mismatch(module, idx2))
+                                        continue;
                                 idx = idx2;
                                 if (idx >= snd_ecards_limit)
                                         snd_ecards_limit = idx + 1;
@@ -304,8 +339,8 @@ int snd_card_disconnect(struct snd_card *card)
                 list_add(&mfile->shutdown_list, &shutdown_files);
                 spin_unlock(&shutdown_lock);
 
-                fops_get(&snd_shutdown_f_ops);
                 mfile->file->f_op = &snd_shutdown_f_ops;
+                fops_get(mfile->file->f_op);
                 
                 mfile = mfile->next;
         }
diff --git a/sound/core/isadma.c b/sound/core/isadma.c
index eb173cef4f05..79f0f16af339 100644
--- a/sound/core/isadma.c
+++ b/sound/core/isadma.c
@@ -26,7 +26,6 @@
 
 #undef HAVE_REALLY_SLOW_DMA_CONTROLLER
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include <asm/dma.h>
 
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index 9b4992eab479..920e5780c228 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -568,6 +568,7 @@ static ssize_t snd_mem_proc_write(struct file *file, const char __user * buffer,
                                 if (pci_set_dma_mask(pci, mask) < 0 ||
                                     pci_set_consistent_dma_mask(pci, mask) < 0) {
                                         printk(KERN_ERR "snd-page-alloc: cannot set DMA mask %lx for pci %04x:%04x\n", mask, vendor, device);
+                                        pci_dev_put(pci);
                                         return count;
                                 }
                         }
diff --git a/sound/core/memory.c b/sound/core/memory.c
index 25b0f056563e..1161158582a6 100644
--- a/sound/core/memory.c
+++ b/sound/core/memory.c
@@ -20,9 +20,9 @@
  *
  */
 
-#include <linux/module.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
+#include <sound/core.h>
 
 /**
  * copy_to_user_fromio - copy data from mmio-space to user-space
diff --git a/sound/core/misc.c b/sound/core/misc.c
index 6cabab8cc537..102d1c36cf26 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/ioport.h>
diff --git a/sound/core/oss/copy.c b/sound/core/oss/copy.c
index d6a04c2d5a75..9ded30d0e97d 100644
--- a/sound/core/oss/copy.c
+++ b/sound/core/oss/copy.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/oss/io.c b/sound/core/oss/io.c
index 3ece39fc48db..f874f6ca3657 100644
--- a/sound/core/oss/io.c
+++ b/sound/core/oss/io.c
@@ -19,7 +19,6 @@
  *
  */
   
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c
index 06f96a3e86f6..da3dbd41669e 100644
--- a/sound/core/oss/linear.c
+++ b/sound/core/oss/linear.c
@@ -20,7 +20,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index c5a5ab9cae8c..75daed298a15 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/time.h>
diff --git a/sound/core/oss/mulaw.c b/sound/core/oss/mulaw.c
index 848db82529ed..77f96194a0ed 100644
--- a/sound/core/oss/mulaw.c
+++ b/sound/core/oss/mulaw.c
@@ -21,7 +21,6 @@
  *
  */
   
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index d0c4ceb9f0b4..4c601b192ddf 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -26,7 +26,6 @@
 #define OSS_DEBUG
 #endif
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/time.h>
@@ -985,10 +984,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
                 sw_params->stop_threshold = runtime->buffer_size;
         sw_params->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
         sw_params->period_step = 1;
-        sw_params->sleep_min = 0;
         sw_params->avail_min = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
                 1 : runtime->period_size;
-        sw_params->xfer_align = 1;
         if (atomic_read(&substream->mmap_count) ||
             substream->oss.setup.nosilence) {
                 sw_params->silence_threshold = 0;
@@ -1624,6 +1621,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                                         snd_pcm_format_set_silence(runtime->format,
                                                                    runtime->oss.buffer,
                                                                    size1);
+                                        size1 /= runtime->channels; /* frames */
                                         fs = snd_enter_user();
                                         snd_pcm_lib_write(substream, (void __user *)runtime->oss.buffer, size1);
                                         snd_leave_user(fs);
diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
index 14095a927a1b..bec94138205e 100644
--- a/sound/core/oss/pcm_plugin.c
+++ b/sound/core/oss/pcm_plugin.c
@@ -24,7 +24,6 @@
 #define PLUGIN_DEBUG
 #endif
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/vmalloc.h>
diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c
index 9eb267913c38..14dfb3175d84 100644
--- a/sound/core/oss/rate.c
+++ b/sound/core/oss/rate.c
@@ -19,7 +19,6 @@
  *
  */
   
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c
index de3ffdeaf7e3..da7ab7a3e82c 100644
--- a/sound/core/oss/route.c
+++ b/sound/core/oss/route.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <sound/core.h>
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index cf9b9493d41d..9dd9bc73fe1d 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/time.h>
@@ -228,7 +227,7 @@ static char *snd_pcm_subformat_names[] = {
 
 static char *snd_pcm_tstamp_mode_names[] = {
         TSTAMP(NONE),
-        TSTAMP(MMAP),
+        TSTAMP(ENABLE),
 };
 
 static const char *snd_pcm_stream_name(int stream)
@@ -359,7 +358,6 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
         snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den); 
         snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);        
         snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);        
-        snd_iprintf(buffer, "tick_time: %u\n", runtime->tick_time);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (substream->oss.oss) {
                 snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
@@ -387,9 +385,7 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
         }
         snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
         snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
-        snd_iprintf(buffer, "sleep_min: %u\n", runtime->sleep_min);
         snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
-        snd_iprintf(buffer, "xfer_align: %lu\n", runtime->xfer_align);
         snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
         snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
         snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
@@ -765,12 +761,6 @@ static int snd_pcm_dev_free(struct snd_device *device)
         return snd_pcm_free(pcm);
 }
 
-static void snd_pcm_tick_timer_func(unsigned long data)
-{
-        struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data;
-        snd_pcm_tick_elapsed(substream);
-}
-
 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
                              struct file *file,
                              struct snd_pcm_substream **rsubstream)
@@ -877,9 +867,6 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         memset((void*)runtime->control, 0, size);
 
         init_waitqueue_head(&runtime->sleep);
-        init_timer(&runtime->tick_timer);
-        runtime->tick_timer.function = snd_pcm_tick_timer_func;
-        runtime->tick_timer.data = (unsigned long) substream;
 
         runtime->status->state = SNDRV_PCM_STATE_OPEN;
 
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index 2b539799d23b..49aa693fba8a 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -484,6 +484,7 @@ static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned l
         case SNDRV_PCM_IOCTL_PVERSION:
         case SNDRV_PCM_IOCTL_INFO:
         case SNDRV_PCM_IOCTL_TSTAMP:
+        case SNDRV_PCM_IOCTL_TTSTAMP:
         case SNDRV_PCM_IOCTL_HWSYNC:
         case SNDRV_PCM_IOCTL_PREPARE:
         case SNDRV_PCM_IOCTL_RESET:
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 806f1fba5446..1533f0379e9d 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -20,7 +20,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <sound/core.h>
@@ -145,11 +144,11 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substre
 {
         snd_pcm_uframes_t pos;
 
+        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
         pos = substream->ops->pointer(substream);
         if (pos == SNDRV_PCM_POS_XRUN)
                 return pos; /* XRUN */
-        if (runtime->tstamp_mode & SNDRV_PCM_TSTAMP_MMAP)
-                getnstimeofday((struct timespec *)&runtime->status->tstamp);
 #ifdef CONFIG_SND_DEBUG
         if (pos >= runtime->buffer_size) {
                 snd_printk(KERN_ERR  "BUG: stream = %i, pos = 0x%lx, buffer size = 0x%lx, period size = 0x%lx\n", substream->stream, pos, runtime->buffer_size, runtime->period_size);
@@ -1139,7 +1138,7 @@ EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
 
 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
 {
-        static int pow2_sizes[] = {
+        static unsigned int pow2_sizes[] = {
                 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
                 1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
                 1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
@@ -1451,108 +1450,13 @@ int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
 
 EXPORT_SYMBOL(snd_pcm_lib_ioctl);
 
-/*
- *  Conditions
- */
-
-static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, 
-                                    unsigned long ticks)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        if (ticks == 0)
-                del_timer(&runtime->tick_timer);
-        else {
-                ticks += (1000000 / HZ) - 1;
-                ticks /= (1000000 / HZ);
-                mod_timer(&runtime->tick_timer, jiffies + ticks);
-        }
-}
-
-/* Temporary alias */
-void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks)
-{
-        snd_pcm_system_tick_set(substream, ticks);
-}
-
-void snd_pcm_tick_prepare(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        snd_pcm_uframes_t frames = ULONG_MAX;
-        snd_pcm_uframes_t avail, dist;
-        unsigned int ticks;
-        u_int64_t n;
-        u_int32_t r;
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                if (runtime->silence_size >= runtime->boundary) {
-                        frames = 1;
-                } else if (runtime->silence_size > 0 &&
-                           runtime->silence_filled < runtime->buffer_size) {
-                        snd_pcm_sframes_t noise_dist;
-                        noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
-                        if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold)
-                                frames = noise_dist - runtime->silence_threshold;
-                }
-                avail = snd_pcm_playback_avail(runtime);
-        } else {
-                avail = snd_pcm_capture_avail(runtime);
-        }
-        if (avail < runtime->control->avail_min) {
-                snd_pcm_sframes_t n = runtime->control->avail_min - avail;
-                if (n > 0 && frames > (snd_pcm_uframes_t)n)
-                        frames = n;
-        }
-        if (avail < runtime->buffer_size) {
-                snd_pcm_sframes_t n = runtime->buffer_size - avail;
-                if (n > 0 && frames > (snd_pcm_uframes_t)n)
-                        frames = n;
-        }
-        if (frames == ULONG_MAX) {
-                snd_pcm_tick_set(substream, 0);
-                return;
-        }
-        dist = runtime->status->hw_ptr - runtime->hw_ptr_base;
-        /* Distance to next interrupt */
-        dist = runtime->period_size - dist % runtime->period_size;
-        if (dist <= frames) {
-                snd_pcm_tick_set(substream, 0);
-                return;
-        }
-        /* the base time is us */
-        n = frames;
-        n *= 1000000;
-        div64_32(&n, runtime->tick_time * runtime->rate, &r);
-        ticks = n + (r > 0 ? 1 : 0);
-        if (ticks < runtime->sleep_min)
-                ticks = runtime->sleep_min;
-        snd_pcm_tick_set(substream, (unsigned long) ticks);
-}
-
-void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime;
-        unsigned long flags;
-        
-        snd_assert(substream != NULL, return);
-        runtime = substream->runtime;
-        snd_assert(runtime != NULL, return);
-
-        snd_pcm_stream_lock_irqsave(substream, flags);
-        if (!snd_pcm_running(substream) ||
-            snd_pcm_update_hw_ptr(substream) < 0)
-                goto _end;
-        if (runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
- _end:
-        snd_pcm_stream_unlock_irqrestore(substream, flags);
-}
-
 /**
  * snd_pcm_period_elapsed - update the pcm status for the next period
  * @substream: the pcm substream instance
  *
  * This function is called from the interrupt handler when the
  * PCM has processed the period size.  It will update the current
- * pointer, set up the tick, wake up sleepers, etc.
+ * pointer, wake up sleepers, etc.
  *
  * Even if more than one periods have elapsed since the last call, you
  * have to call this only once.
@@ -1576,8 +1480,6 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 
         if (substream->timer_running)
                 snd_timer_interrupt(substream->timer, 1);
-        if (runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
  _end:
         snd_pcm_stream_unlock_irqrestore(substream, flags);
         if (runtime->transfer_ack_end)
@@ -1587,6 +1489,71 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 
 EXPORT_SYMBOL(snd_pcm_period_elapsed);
 
+/*
+ * Wait until avail_min data becomes available
+ * Returns a negative error code if any error occurs during operation.
+ * The available space is stored on availp.  When err = 0 and avail = 0
+ * on the capture stream, it indicates the stream is in DRAINING state.
+ */
+static int wait_for_avail_min(struct snd_pcm_substream *substream,
+                              snd_pcm_uframes_t *availp)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
+        wait_queue_t wait;
+        int err = 0;
+        snd_pcm_uframes_t avail = 0;
+        long tout;
+
+        init_waitqueue_entry(&wait, current);
+        add_wait_queue(&runtime->sleep, &wait);
+        for (;;) {
+                if (signal_pending(current)) {
+                        err = -ERESTARTSYS;
+                        break;
+                }
+                set_current_state(TASK_INTERRUPTIBLE);
+                snd_pcm_stream_unlock_irq(substream);
+                tout = schedule_timeout(msecs_to_jiffies(10000));
+                snd_pcm_stream_lock_irq(substream);
+                switch (runtime->status->state) {
+                case SNDRV_PCM_STATE_SUSPENDED:
+                        err = -ESTRPIPE;
+                        goto _endloop;
+                case SNDRV_PCM_STATE_XRUN:
+                        err = -EPIPE;
+                        goto _endloop;
+                case SNDRV_PCM_STATE_DRAINING:
+                        if (is_playback)
+                                err = -EPIPE;
+                        else 
+                                avail = 0; /* indicate draining */
+                        goto _endloop;
+                case SNDRV_PCM_STATE_OPEN:
+                case SNDRV_PCM_STATE_SETUP:
+                case SNDRV_PCM_STATE_DISCONNECTED:
+                        err = -EBADFD;
+                        goto _endloop;
+                }
+                if (!tout) {
+                        snd_printd("%s write error (DMA or IRQ trouble?)\n",
+                                   is_playback ? "playback" : "capture");
+                        err = -EIO;
+                        break;
+                }
+                if (is_playback)
+                        avail = snd_pcm_playback_avail(runtime);
+                else
+                        avail = snd_pcm_capture_avail(runtime);
+                if (avail >= runtime->control->avail_min)
+                        break;
+        }
+ _endloop:
+        remove_wait_queue(&runtime->sleep, &wait);
+        *availp = avail;
+        return err;
+}
+        
 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
@@ -1624,8 +1591,6 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
 
         if (size == 0)
                 return 0;
-        if (size > runtime->xfer_align)
-                size -= size % runtime->xfer_align;
 
         snd_pcm_stream_lock_irq(substream);
         switch (runtime->status->state) {
@@ -1648,84 +1613,18 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
                 snd_pcm_uframes_t cont;
-                if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                         snd_pcm_update_hw_ptr(substream);
                 avail = snd_pcm_playback_avail(runtime);
-                if (((avail < runtime->control->avail_min && size > avail) ||
-                   (size >= runtime->xfer_align && avail < runtime->xfer_align))) {
-                        wait_queue_t wait;
-                        enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
-                        long tout;
-
+                if (!avail) {
                         if (nonblock) {
                                 err = -EAGAIN;
                                 goto _end_unlock;
                         }
-
-                        init_waitqueue_entry(&wait, current);
-                        add_wait_queue(&runtime->sleep, &wait);
-                        while (1) {
-                                if (signal_pending(current)) {
-                                        state = SIGNALED;
-                                        break;
-                                }
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                snd_pcm_stream_unlock_irq(substream);
-                                tout = schedule_timeout(10 * HZ);
-                                snd_pcm_stream_lock_irq(substream);
-                                if (tout == 0) {
-                                        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
-                                            runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
-                                                state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
-                                                break;
-                                        }
-                                }
-                                switch (runtime->status->state) {
-                                case SNDRV_PCM_STATE_XRUN:
-                                case SNDRV_PCM_STATE_DRAINING:
-                                        state = ERROR;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SUSPENDED:
-                                        state = SUSPENDED;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SETUP:
-                                        state = DROPPED;
-                                        goto _end_loop;
-                                default:
-                                        break;
-                                }
-                                avail = snd_pcm_playback_avail(runtime);
-                                if (avail >= runtime->control->avail_min) {
-                                        state = READY;
-                                        break;
-                                }
-                        }
-                       _end_loop:
-                        remove_wait_queue(&runtime->sleep, &wait);
-
-                        switch (state) {
-                        case ERROR:
-                                err = -EPIPE;
-                                goto _end_unlock;
-                        case SUSPENDED:
-                                err = -ESTRPIPE;
-                                goto _end_unlock;
-                        case SIGNALED:
-                                err = -ERESTARTSYS;
-                                goto _end_unlock;
-                        case EXPIRED:
-                                snd_printd("playback write error (DMA or IRQ trouble?)\n");
-                                err = -EIO;
-                                goto _end_unlock;
-                        case DROPPED:
-                                err = -EBADFD;
+                        err = wait_for_avail_min(substream, &avail);
+                        if (err < 0)
                                 goto _end_unlock;
-                        default:
-                                break;
-                        }
                 }
-                if (avail > runtime->xfer_align)
-                        avail -= avail % runtime->xfer_align;
                 frames = size > avail ? avail : size;
                 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
                 if (frames > cont)
@@ -1763,9 +1662,6 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                         if (err < 0)
                                 goto _end_unlock;
                 }
-                if (runtime->sleep_min &&
-                    runtime->status->state == SNDRV_PCM_STATE_RUNNING)
-                        snd_pcm_tick_prepare(substream);
         }
  _end_unlock:
         snd_pcm_stream_unlock_irq(substream);
@@ -1893,8 +1789,6 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
 
         if (size == 0)
                 return 0;
-        if (size > runtime->xfer_align)
-                size -= size % runtime->xfer_align;
 
         snd_pcm_stream_lock_irq(substream);
         switch (runtime->status->state) {
@@ -1924,91 +1818,25 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
                 snd_pcm_uframes_t cont;
-                if (runtime->sleep_min == 0 && runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
                         snd_pcm_update_hw_ptr(substream);
-              __draining:
                 avail = snd_pcm_capture_avail(runtime);
-                if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
-                        if (avail < runtime->xfer_align) {
-                                err = -EPIPE;
+                if (!avail) {
+                        if (runtime->status->state ==
+                            SNDRV_PCM_STATE_DRAINING) {
+                                snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
                                 goto _end_unlock;
                         }
-                } else if ((avail < runtime->control->avail_min && size > avail) ||
-                           (size >= runtime->xfer_align && avail < runtime->xfer_align)) {
-                        wait_queue_t wait;
-                        enum { READY, SIGNALED, ERROR, SUSPENDED, EXPIRED, DROPPED } state;
-                        long tout;
-
                         if (nonblock) {
                                 err = -EAGAIN;
                                 goto _end_unlock;
                         }
-
-                        init_waitqueue_entry(&wait, current);
-                        add_wait_queue(&runtime->sleep, &wait);
-                        while (1) {
-                                if (signal_pending(current)) {
-                                        state = SIGNALED;
-                                        break;
-                                }
-                                set_current_state(TASK_INTERRUPTIBLE);
-                                snd_pcm_stream_unlock_irq(substream);
-                                tout = schedule_timeout(10 * HZ);
-                                snd_pcm_stream_lock_irq(substream);
-                                if (tout == 0) {
-                                        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED &&
-                                            runtime->status->state != SNDRV_PCM_STATE_PAUSED) {
-                                                state = runtime->status->state == SNDRV_PCM_STATE_SUSPENDED ? SUSPENDED : EXPIRED;
-                                                break;
-                                        }
-                                }
-                                switch (runtime->status->state) {
-                                case SNDRV_PCM_STATE_XRUN:
-                                        state = ERROR;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_SUSPENDED:
-                                        state = SUSPENDED;
-                                        goto _end_loop;
-                                case SNDRV_PCM_STATE_DRAINING:
-                                        goto __draining;
-                                case SNDRV_PCM_STATE_SETUP:
-                                        state = DROPPED;
-                                        goto _end_loop;
-                                default:
-                                        break;
-                                }
-                                avail = snd_pcm_capture_avail(runtime);
-                                if (avail >= runtime->control->avail_min) {
-                                        state = READY;
-                                        break;
-                                }
-                        }
-                       _end_loop:
-                        remove_wait_queue(&runtime->sleep, &wait);
-
-                        switch (state) {
-                        case ERROR:
-                                err = -EPIPE;
-                                goto _end_unlock;
-                        case SUSPENDED:
-                                err = -ESTRPIPE;
-                                goto _end_unlock;
-                        case SIGNALED:
-                                err = -ERESTARTSYS;
-                                goto _end_unlock;
-                        case EXPIRED:
-                                snd_printd("capture read error (DMA or IRQ trouble?)\n");
-                                err = -EIO;
-                                goto _end_unlock;
-                        case DROPPED:
-                                err = -EBADFD;
+                        err = wait_for_avail_min(substream, &avail);
+                        if (err < 0)
                                 goto _end_unlock;
-                        default:
-                                break;
-                        }
+                        if (!avail)
+                                continue; /* draining */
                 }
-                if (avail > runtime->xfer_align)
-                        avail -= avail % runtime->xfer_align;
                 frames = size > avail ? avail : size;
                 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
                 if (frames > cont)
@@ -2040,9 +1868,6 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 offset += frames;
                 size -= frames;
                 xfer += frames;
-                if (runtime->sleep_min &&
-                    runtime->status->state == SNDRV_PCM_STATE_RUNNING)
-                        snd_pcm_tick_prepare(substream);
         }
  _end_unlock:
         snd_pcm_stream_unlock_irq(substream);
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index a13e38cfd2c6..ff07b4a9992e 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <asm/io.h>
 #include <linux/time.h>
 #include <linux/init.h>
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index dd9aa51d8c82..89b7f549bebd 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -19,7 +19,6 @@
  *
  */
   
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -75,7 +74,7 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
         },
         [SNDRV_PCM_FORMAT_U24_BE] = {
                 .width = 24, .phys = 32, .le = 0, .signd = 0,
-                .silence = { 0x80, 0x00, 0x00 },
+                .silence = { 0x00, 0x80, 0x00, 0x00 },
         },
         [SNDRV_PCM_FORMAT_S32_LE] = {
                 .width = 32, .phys = 32, .le = 1, .signd = 1,
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index fb3dde4db045..62449117ee14 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/mm.h>
 #include <linux/file.h>
 #include <linux/slab.h>
@@ -413,7 +412,6 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         runtime->period_size = params_period_size(params);
         runtime->periods = params_periods(params);
         runtime->buffer_size = params_buffer_size(params);
-        runtime->tick_time = params_tick_time(params);
         runtime->info = params->info;
         runtime->rate_num = params->rate_num;
         runtime->rate_den = params->rate_den;
@@ -433,9 +431,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         /* Default sw params */
         runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
         runtime->period_step = 1;
-        runtime->sleep_min = 0;
         runtime->control->avail_min = runtime->period_size;
-        runtime->xfer_align = runtime->period_size;
         runtime->start_threshold = 1;
         runtime->stop_threshold = runtime->buffer_size;
         runtime->silence_threshold = 0;
@@ -532,9 +528,6 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         if (params->avail_min == 0)
                 return -EINVAL;
-        if (params->xfer_align == 0 ||
-            params->xfer_align % runtime->min_align != 0)
-                return -EINVAL;
         if (params->silence_size >= runtime->boundary) {
                 if (params->silence_threshold != 0)
                         return -EINVAL;
@@ -546,20 +539,14 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
         }
         snd_pcm_stream_lock_irq(substream);
         runtime->tstamp_mode = params->tstamp_mode;
-        runtime->sleep_min = params->sleep_min;
         runtime->period_step = params->period_step;
         runtime->control->avail_min = params->avail_min;
         runtime->start_threshold = params->start_threshold;
         runtime->stop_threshold = params->stop_threshold;
         runtime->silence_threshold = params->silence_threshold;
         runtime->silence_size = params->silence_size;
-        runtime->xfer_align = params->xfer_align;
         params->boundary = runtime->boundary;
         if (snd_pcm_running(substream)) {
-                if (runtime->sleep_min)
-                        snd_pcm_tick_prepare(substream);
-                else
-                        snd_pcm_tick_set(substream, 0);
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
                     runtime->silence_size > 0)
                         snd_pcm_playback_silence(substream, ULONG_MAX);
@@ -595,12 +582,13 @@ int snd_pcm_status(struct snd_pcm_substream *substream,
         status->trigger_tstamp = runtime->trigger_tstamp;
         if (snd_pcm_running(substream)) {
                 snd_pcm_update_hw_ptr(substream);
-                if (runtime->tstamp_mode & SNDRV_PCM_TSTAMP_MMAP)
+                if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
                         status->tstamp = runtime->status->tstamp;
-                else
-                        getnstimeofday(&status->tstamp);
-        } else
-                getnstimeofday(&status->tstamp);
+                        goto _tstamp_end;
+                }
+        }
+        snd_pcm_gettime(runtime, &status->tstamp);
+ _tstamp_end:
         status->appl_ptr = runtime->control->appl_ptr;
         status->hw_ptr = runtime->status->hw_ptr;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -688,7 +676,7 @@ static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
         if (runtime->trigger_master == NULL)
                 return;
         if (runtime->trigger_master == substream) {
-                getnstimeofday(&runtime->trigger_tstamp);
+                snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
         } else {
                 snd_pcm_trigger_tstamp(runtime->trigger_master);
                 runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
@@ -875,8 +863,6 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, ULONG_MAX);
-        if (runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
         if (substream->timer)
                 snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART,
                                  &runtime->trigger_tstamp);
@@ -930,7 +916,6 @@ static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
                         snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP,
                                          &runtime->trigger_tstamp);
                 runtime->status->state = state;
-                snd_pcm_tick_set(substream, 0);
         }
         wake_up(&runtime->sleep);
 }
@@ -1014,12 +999,9 @@ static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
                         snd_timer_notify(substream->timer,
                                          SNDRV_TIMER_EVENT_MPAUSE,
                                          &runtime->trigger_tstamp);
-                snd_pcm_tick_set(substream, 0);
                 wake_up(&runtime->sleep);
         } else {
                 runtime->status->state = SNDRV_PCM_STATE_RUNNING;
-                if (runtime->sleep_min)
-                        snd_pcm_tick_prepare(substream);
                 if (substream->timer)
                         snd_timer_notify(substream->timer,
                                          SNDRV_TIMER_EVENT_MCONTINUE,
@@ -1074,7 +1056,6 @@ static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
                                  &runtime->trigger_tstamp);
         runtime->status->suspended_state = runtime->status->state;
         runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
-        snd_pcm_tick_set(substream, 0);
         wake_up(&runtime->sleep);
 }
 
@@ -1177,8 +1158,6 @@ static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state)
                 snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME,
                                  &runtime->trigger_tstamp);
         runtime->status->state = runtime->status->suspended_state;
-        if (runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
 }
 
 static struct action_ops snd_pcm_action_resume = {
@@ -1395,10 +1374,10 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
         } else {
                 /* stop running stream */
                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
-                        int state = snd_pcm_capture_avail(runtime) > 0 ?
+                        int new_state = snd_pcm_capture_avail(runtime) > 0 ?
                                 SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP;
-                        snd_pcm_do_stop(substream, state);
-                        snd_pcm_post_stop(substream, state);
+                        snd_pcm_do_stop(substream, new_state);
+                        snd_pcm_post_stop(substream, new_state);
                 }
         }
         return 0;
@@ -2007,8 +1986,6 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
         }
 
         /* FIXME: this belong to lowlevel */
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_TICK_TIME,
-                                     1000000 / HZ, 1000000 / HZ);
         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
 
         return 0;
@@ -2244,15 +2221,10 @@ static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *subst
         }
         if (frames > (snd_pcm_uframes_t)hw_avail)
                 frames = hw_avail;
-        else
-                frames -= frames % runtime->xfer_align;
         appl_ptr = runtime->control->appl_ptr - frames;
         if (appl_ptr < 0)
                 appl_ptr += runtime->boundary;
         runtime->control->appl_ptr = appl_ptr;
-        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
-            runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
         ret = frames;
  __end:
         snd_pcm_stream_unlock_irq(substream);
@@ -2294,15 +2266,10 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substr
         }
         if (frames > (snd_pcm_uframes_t)hw_avail)
                 frames = hw_avail;
-        else
-                frames -= frames % runtime->xfer_align;
         appl_ptr = runtime->control->appl_ptr - frames;
         if (appl_ptr < 0)
                 appl_ptr += runtime->boundary;
         runtime->control->appl_ptr = appl_ptr;
-        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
-            runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
         ret = frames;
  __end:
         snd_pcm_stream_unlock_irq(substream);
@@ -2345,15 +2312,10 @@ static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *subs
         }
         if (frames > (snd_pcm_uframes_t)avail)
                 frames = avail;
-        else
-                frames -= frames % runtime->xfer_align;
         appl_ptr = runtime->control->appl_ptr + frames;
         if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
                 appl_ptr -= runtime->boundary;
         runtime->control->appl_ptr = appl_ptr;
-        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
-            runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
         ret = frames;
  __end:
         snd_pcm_stream_unlock_irq(substream);
@@ -2396,15 +2358,10 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *subst
         }
         if (frames > (snd_pcm_uframes_t)avail)
                 frames = avail;
-        else
-                frames -= frames % runtime->xfer_align;
         appl_ptr = runtime->control->appl_ptr + frames;
         if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
                 appl_ptr -= runtime->boundary;
         runtime->control->appl_ptr = appl_ptr;
-        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
-            runtime->sleep_min)
-                snd_pcm_tick_prepare(substream);
         ret = frames;
  __end:
         snd_pcm_stream_unlock_irq(substream);
@@ -2519,6 +2476,21 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
                 return -EFAULT;
         return 0;
 }
+
+static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int arg;
+        
+        if (get_user(arg, _arg))
+                return -EFAULT;
+        if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
+                return -EINVAL;
+        runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY;
+        if (arg == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
+                runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC;
+        return 0;
+}
                 
 static int snd_pcm_common_ioctl1(struct file *file,
                                  struct snd_pcm_substream *substream,
@@ -2531,8 +2503,10 @@ static int snd_pcm_common_ioctl1(struct file *file,
                 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
         case SNDRV_PCM_IOCTL_INFO:
                 return snd_pcm_info_user(substream, arg);
-        case SNDRV_PCM_IOCTL_TSTAMP: /* just for compatibility */
+        case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
                 return 0;
+        case SNDRV_PCM_IOCTL_TTSTAMP:
+                return snd_pcm_tstamp(substream, arg);
         case SNDRV_PCM_IOCTL_HW_REFINE:
                 return snd_pcm_hw_refine_user(substream, arg);
         case SNDRV_PCM_IOCTL_HW_PARAMS:
@@ -3018,26 +2992,23 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
 /*
  * mmap status record
  */
-static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area,
-                                                unsigned long address, int *type)
+static int snd_pcm_mmap_status_fault(struct vm_area_struct *area,
+                                                struct vm_fault *vmf)
 {
         struct snd_pcm_substream *substream = area->vm_private_data;
         struct snd_pcm_runtime *runtime;
-        struct page * page;
         
         if (substream == NULL)
-                return NOPAGE_SIGBUS;
+                return VM_FAULT_SIGBUS;
         runtime = substream->runtime;
-        page = virt_to_page(runtime->status);
-        get_page(page);
-        if (type)
-                *type = VM_FAULT_MINOR;
-        return page;
+        vmf->page = virt_to_page(runtime->status);
+        get_page(vmf->page);
+        return 0;
 }
 
 static struct vm_operations_struct snd_pcm_vm_ops_status =
 {
-        .nopage =       snd_pcm_mmap_status_nopage,
+        .fault =        snd_pcm_mmap_status_fault,
 };
 
 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
@@ -3061,26 +3032,23 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
 /*
  * mmap control record
  */
-static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area,
-                                                 unsigned long address, int *type)
+static int snd_pcm_mmap_control_fault(struct vm_area_struct *area,
+                                                struct vm_fault *vmf)
 {
         struct snd_pcm_substream *substream = area->vm_private_data;
         struct snd_pcm_runtime *runtime;
-        struct page * page;
         
         if (substream == NULL)
-                return NOPAGE_SIGBUS;
+                return VM_FAULT_SIGBUS;
         runtime = substream->runtime;
-        page = virt_to_page(runtime->control);
-        get_page(page);
-        if (type)
-                *type = VM_FAULT_MINOR;
-        return page;
+        vmf->page = virt_to_page(runtime->control);
+        get_page(vmf->page);
+        return 0;
 }
 
 static struct vm_operations_struct snd_pcm_vm_ops_control =
 {
-        .nopage =       snd_pcm_mmap_control_nopage,
+        .fault =        snd_pcm_mmap_control_fault,
 };
 
 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
@@ -3117,10 +3085,10 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file
 #endif /* coherent mmap */
 
 /*
- * nopage callback for mmapping a RAM page
+ * fault callback for mmapping a RAM page
  */
-static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area,
-                                             unsigned long address, int *type)
+static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
+                                                struct vm_fault *vmf)
 {
         struct snd_pcm_substream *substream = area->vm_private_data;
         struct snd_pcm_runtime *runtime;
@@ -3130,33 +3098,30 @@ static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area,
         size_t dma_bytes;
         
         if (substream == NULL)
-                return NOPAGE_SIGBUS;
+                return VM_FAULT_SIGBUS;
         runtime = substream->runtime;
-        offset = area->vm_pgoff << PAGE_SHIFT;
-        offset += address - area->vm_start;
-        snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_SIGBUS);
+        offset = vmf->pgoff << PAGE_SHIFT;
         dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
         if (offset > dma_bytes - PAGE_SIZE)
-                return NOPAGE_SIGBUS;
+                return VM_FAULT_SIGBUS;
         if (substream->ops->page) {
                 page = substream->ops->page(substream, offset);
-                if (! page)
-                        return NOPAGE_OOM; /* XXX: is this really due to OOM? */
+                if (!page)
+                        return VM_FAULT_SIGBUS;
         } else {
                 vaddr = runtime->dma_area + offset;
                 page = virt_to_page(vaddr);
         }
         get_page(page);
-        if (type)
-                *type = VM_FAULT_MINOR;
-        return page;
+        vmf->page = page;
+        return 0;
 }
 
 static struct vm_operations_struct snd_pcm_vm_ops_data =
 {
         .open =         snd_pcm_mmap_data_open,
         .close =        snd_pcm_mmap_data_close,
-        .nopage =       snd_pcm_mmap_data_nopage,
+        .fault =        snd_pcm_mmap_data_fault,
 };
 
 /*
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index 23aa9a27e215..033a024d153a 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index b8e700b94e59..f7ea7287c59c 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include <linux/major.h>
 #include <linux/init.h>
@@ -912,7 +911,8 @@ int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
 }
 
 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
-                                     unsigned char *buf, long count, int kernel)
+                                     unsigned char __user *userbuf,
+                                     unsigned char *kernelbuf, long count)
 {
         unsigned long flags;
         long result = 0, count1;
@@ -925,11 +925,11 @@ static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
                 spin_lock_irqsave(&runtime->lock, flags);
                 if (count1 > (int)runtime->avail)
                         count1 = runtime->avail;
-                if (kernel) {
-                        memcpy(buf + result, runtime->buffer + runtime->appl_ptr, count1);
-                } else {
+                if (kernelbuf)
+                        memcpy(kernelbuf + result, runtime->buffer + runtime->appl_ptr, count1);
+                if (userbuf) {
                         spin_unlock_irqrestore(&runtime->lock, flags);
-                        if (copy_to_user((char __user *)buf + result,
+                        if (copy_to_user(userbuf + result,
                                          runtime->buffer + runtime->appl_ptr, count1)) {
                                 return result > 0 ? result : -EFAULT;
                         }
@@ -949,7 +949,7 @@ long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream,
                              unsigned char *buf, long count)
 {
         snd_rawmidi_input_trigger(substream, 1);
-        return snd_rawmidi_kernel_read1(substream, buf, count, 1);
+        return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count);
 }
 
 static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count,
@@ -990,8 +990,9 @@ static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t coun
                 }
                 spin_unlock_irq(&runtime->lock);
                 count1 = snd_rawmidi_kernel_read1(substream,
-                                                  (unsigned char __force *)buf,
-                                                  count, 0);
+                                                  (unsigned char __user *)buf,
+                                                  NULL/*kernelbuf*/,
+                                                  count);
                 if (count1 < 0)
                         return result > 0 ? result : count1;
                 result += count1;
@@ -1132,13 +1133,15 @@ int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
 }
 
 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
-                                      const unsigned char *buf, long count, int kernel)
+                                      const unsigned char __user *userbuf,
+                                      const unsigned char *kernelbuf,
+                                      long count)
 {
         unsigned long flags;
         long count1, result;
         struct snd_rawmidi_runtime *runtime = substream->runtime;
 
-        snd_assert(buf != NULL, return -EINVAL);
+        snd_assert(kernelbuf != NULL || userbuf != NULL, return -EINVAL);
         snd_assert(runtime->buffer != NULL, return -EINVAL);
 
         result = 0;
@@ -1155,12 +1158,13 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
                         count1 = count;
                 if (count1 > (long)runtime->avail)
                         count1 = runtime->avail;
-                if (kernel) {
-                        memcpy(runtime->buffer + runtime->appl_ptr, buf, count1);
-                } else {
+                if (kernelbuf)
+                        memcpy(runtime->buffer + runtime->appl_ptr,
+                               kernelbuf + result, count1);
+                else if (userbuf) {
                         spin_unlock_irqrestore(&runtime->lock, flags);
                         if (copy_from_user(runtime->buffer + runtime->appl_ptr,
-                                           (char __user *)buf, count1)) {
+                                           userbuf + result, count1)) {
                                 spin_lock_irqsave(&runtime->lock, flags);
                                 result = result > 0 ? result : -EFAULT;
                                 goto __end;
@@ -1171,7 +1175,6 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
                 runtime->appl_ptr %= runtime->buffer_size;
                 runtime->avail -= count1;
                 result += count1;
-                buf += count1;
                 count -= count1;
         }
       __end:
@@ -1185,7 +1188,7 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream,
                               const unsigned char *buf, long count)
 {
-        return snd_rawmidi_kernel_write1(substream, buf, count, 1);
+        return snd_rawmidi_kernel_write1(substream, NULL, buf, count);
 }
 
 static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
@@ -1225,9 +1228,7 @@ static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
                         spin_lock_irq(&runtime->lock);
                 }
                 spin_unlock_irq(&runtime->lock);
-                count1 = snd_rawmidi_kernel_write1(substream,
-                                                   (unsigned char __force *)buf,
-                                                   count, 0);
+                count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count);
                 if (count1 < 0)
                         return result > 0 ? result : count1;
                 result += count1;
diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c
index 7cd5e8f5d4ce..97b30fb4c361 100644
--- a/sound/core/rtctimer.c
+++ b/sound/core/rtctimer.c
@@ -20,7 +20,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/moduleparam.h>
diff --git a/sound/core/seq/Makefile b/sound/core/seq/Makefile
index ceef14afee30..069593717fba 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 608960364813..000000000000
--- 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 f80fab8f2ed1..000000000000
--- 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 49400262b1eb..000000000000
--- 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 6c40eb73fa9f..000000000000
--- 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 78f68bee24fe..000000000000
--- 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/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index bc0992398461..777796e94490 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -20,7 +20,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
diff --git a/sound/core/seq/oss/seq_oss_device.h b/sound/core/seq/oss/seq_oss_device.h
index 9a8567c928ec..bf8d2b4cb15e 100644
--- a/sound/core/seq/oss/seq_oss_device.h
+++ b/sound/core/seq/oss/seq_oss_device.h
@@ -21,7 +21,6 @@
 #ifndef __SEQ_OSS_DEVICE_H
 #define __SEQ_OSS_DEVICE_H
 
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <linux/wait.h>
 #include <linux/slab.h>
diff --git a/sound/core/seq/seq.c b/sound/core/seq/seq.c
index 1878208a8026..ee0f8405ab35 100644
--- a/sound/core/seq/seq.c
+++ b/sound/core/seq/seq.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 2e3fa25ab19f..f97c1ba43a28 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -21,7 +21,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -130,8 +129,6 @@ static struct snd_seq_client *clientptr(int clientid)
         return clienttab[clientid];
 }
 
-extern int seq_client_load[];
-
 struct snd_seq_client *snd_seq_client_use_ptr(int clientid)
 {
         unsigned long flags;
@@ -966,8 +963,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_clientmgr.h b/sound/core/seq/seq_clientmgr.h
index 5e04e20e239f..20f0a725ec7d 100644
--- a/sound/core/seq/seq_clientmgr.h
+++ b/sound/core/seq/seq_clientmgr.h
@@ -98,4 +98,6 @@ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table
 int snd_seq_client_notify_subscription(int client, int port,
                                        struct snd_seq_port_subscribe *info, int evtype);
 
+extern int seq_client_load[15];
+
 #endif
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index 37852cdace76..155dc7da4722 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -36,7 +36,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <sound/core.h>
 #include <sound/info.h>
diff --git a/sound/core/seq/seq_dummy.c b/sound/core/seq/seq_dummy.c
index e55488d1237c..f3bdc54b429a 100644
--- a/sound/core/seq/seq_dummy.c
+++ b/sound/core/seq/seq_dummy.c
@@ -18,7 +18,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/moduleparam.h>
diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c
index 6b055aed7a4b..3a94ed021bd9 100644
--- a/sound/core/seq/seq_fifo.c
+++ b/sound/core/seq/seq_fifo.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include <linux/slab.h>
 #include "seq_fifo.h"
diff --git a/sound/core/seq/seq_info.c b/sound/core/seq/seq_info.c
index 8a7fe5cca1c9..201f8106ffdd 100644
--- a/sound/core/seq/seq_info.c
+++ b/sound/core/seq/seq_info.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <sound/core.h>
 
diff --git a/sound/core/seq/seq_instr.c b/sound/core/seq/seq_instr.c
deleted file mode 100644
index 9a6fd56c9109..000000000000
--- 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_lock.c b/sound/core/seq/seq_lock.c
index 1a34941d4217..54f921edda79 100644
--- a/sound/core/seq/seq_lock.c
+++ b/sound/core/seq/seq_lock.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include "seq_lock.h"
 
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index a72a1945bf8a..0cf6ac477318 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -20,7 +20,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 5929aaf1df9d..99b35360c506 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -26,7 +26,6 @@ Possible options for midisynth module:
 */
 
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
diff --git a/sound/core/seq/seq_midi_emul.c b/sound/core/seq/seq_midi_emul.c
index 17b3e6f13ca3..07c663135c62 100644
--- a/sound/core/seq/seq_midi_emul.c
+++ b/sound/core/seq/seq_midi_emul.c
@@ -29,7 +29,6 @@
  * code in here.  If there is it should be reported as a bug.
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/string.h>
@@ -229,13 +228,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:
diff --git a/sound/core/seq/seq_midi_event.c b/sound/core/seq/seq_midi_event.c
index b6820a5a73fc..8284f176a342 100644
--- a/sound/core/seq/seq_midi_event.c
+++ b/sound/core/seq/seq_midi_event.c
@@ -19,7 +19,6 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <sound/driver.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/string.h>
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index b6e23ad12ab9..1c32a53d6bd8 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -20,7 +20,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include <linux/slab.h>
 #include "seq_system.h"
diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c
index 074418617ee9..85969db576c9 100644
--- a/sound/core/seq/seq_prioq.c
+++ b/sound/core/seq/seq_prioq.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/time.h>
 #include <linux/slab.h>
 #include <sound/core.h>
diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index 9b87bb0c7f33..4a48c6ee8ee8 100644
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -35,7 +35,6 @@
  *     - Addition of experimental sync support.
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <sound/core.h>
diff --git a/sound/core/seq/seq_system.c b/sound/core/seq/seq_system.c
index b201b76e9412..77884e62b648 100644
--- a/sound/core/seq/seq_system.c
+++ b/sound/core/seq/seq_system.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <sound/core.h>
 #include "seq_system.h"
diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
index 8716352afc81..d8fcd62e400f 100644
--- a/sound/core/seq/seq_timer.c
+++ b/sound/core/seq/seq_timer.c
@@ -20,20 +20,12 @@
  *
  */
 
-#include <sound/driver.h>
 #include <sound/core.h>
 #include <linux/slab.h>
 #include "seq_timer.h"
 #include "seq_queue.h"
 #include "seq_info.h"
 
-extern int seq_default_timer_class;
-extern int seq_default_timer_sclass;
-extern int seq_default_timer_card;
-extern int seq_default_timer_device;
-extern int seq_default_timer_subdevice;
-extern int seq_default_timer_resolution;
-
 /* allowed sequencer timer frequencies, in Hz */
 #define MIN_FREQUENCY           10
 #define MAX_FREQUENCY           6250
diff --git a/sound/core/seq/seq_timer.h b/sound/core/seq/seq_timer.h
index e9ee1543c924..88dfb71805ae 100644
--- a/sound/core/seq/seq_timer.h
+++ b/sound/core/seq/seq_timer.h
@@ -138,4 +138,11 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, unsigne
 snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr);
 snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr);
 
+extern int seq_default_timer_class;
+extern int seq_default_timer_sclass;
+extern int seq_default_timer_card;
+extern int seq_default_timer_device;
+extern int seq_default_timer_subdevice;
+extern int seq_default_timer_resolution;
+
 #endif
diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c
index e11790f6debe..86e7739269ca 100644
--- a/sound/core/seq/seq_virmidi.c
+++ b/sound/core/seq/seq_virmidi.c
@@ -35,7 +35,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/slab.h>
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 7b486c4d70db..00cca4d6e562 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/time.h>
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index dc73313b733a..7be51546eb9e 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -19,8 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
-
 #ifdef CONFIG_SND_OSSEMUL
 
 #if !defined(CONFIG_SOUND) && !(defined(MODULE) && defined(CONFIG_SOUND_MODULE))
diff --git a/sound/core/timer.c b/sound/core/timer.c
index e7dc56ca4b97..aece465934b8 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <sound/driver.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -44,11 +43,14 @@
 #endif
 
 static int timer_limit = DEFAULT_TIMER_LIMIT;
+static int timer_tstamp_monotonic = 1;
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
 MODULE_DESCRIPTION("ALSA timer interface");
 MODULE_LICENSE("GPL");
 module_param(timer_limit, int, 0444);
 MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
+module_param(timer_tstamp_monotonic, int, 0444);
+MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default).");
 
 struct snd_timer_user {
         struct snd_timer_instance *timeri;
@@ -381,7 +383,10 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
         struct snd_timer_instance *ts;
         struct timespec tstamp;
 
-        getnstimeofday(&tstamp);
+        if (timer_tstamp_monotonic)
+                do_posix_clock_monotonic_gettime(&tstamp);
+        else
+                getnstimeofday(&tstamp);
         snd_assert(event >= SNDRV_TIMER_EVENT_START &&
                    event <= SNDRV_TIMER_EVENT_PAUSE, return);
         if (event == SNDRV_TIMER_EVENT_START ||
@@ -1182,8 +1187,12 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
                 spin_unlock(&tu->qlock);
                 return;
         }
-        if (tu->last_resolution != resolution || ticks > 0)
-                getnstimeofday(&tstamp);
+        if (tu->last_resolution != resolution || ticks > 0) {
+                if (timer_tstamp_monotonic)
+                        do_posix_clock_monotonic_gettime(&tstamp);
+                else
+                        getnstimeofday(&tstamp);
+        }
         if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&
             tu->last_resolution != resolution) {
                 r1.event = SNDRV_TIMER_EVENT_RESOLUTION;