10 files changed, 220 insertions, 106 deletions

diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index c1070e33b32f..c4a4cdc07ab9 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -43,6 +43,7 @@
 #include <linux/sound.h>
 #include <linux/slab.h>
 #include <linux/soundcard.h>
+#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
@@ -162,19 +163,10 @@ ld2(unsigned int x)
 static void
 au1550_delay(int msec)
 {
-        unsigned long   tmo;
-        signed long     tmo2;
-
         if (in_interrupt())
                 return;
 
-        tmo = jiffies + (msec * HZ) / 1000;
-        for (;;) {
-                tmo2 = tmo - jiffies;
-                if (tmo2 <= 0)
-                        break;
-                schedule_timeout(tmo2);
-        }
+        schedule_timeout_uninterruptible(msecs_to_jiffies(msec));
 }
 
 static u16
@@ -807,7 +799,9 @@ au1550_llseek(struct file *file, loff_t offset, int origin)
 static int
 au1550_open_mixdev(struct inode *inode, struct file *file)
 {
+        lock_kernel();
         file->private_data = &au1550_state;
+        unlock_kernel();
         return 0;
 }
 
@@ -824,22 +818,26 @@ mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd,
         return codec->mixer_ioctl(codec, cmd, arg);
 }
 
-static int
-au1550_ioctl_mixdev(struct inode *inode, struct file *file,
-                               unsigned int cmd, unsigned long arg)
+static long
+au1550_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct au1550_state *s = (struct au1550_state *)file->private_data;
         struct ac97_codec *codec = s->codec;
+        int ret;
 
-        return mixdev_ioctl(codec, cmd, arg);
+        lock_kernel();
+        ret = mixdev_ioctl(codec, cmd, arg);
+        unlock_kernel();
+
+        return ret;
 }
 
 static /*const */ struct file_operations au1550_mixer_fops = {
-        owner:THIS_MODULE,
-        llseek:au1550_llseek,
-        ioctl:au1550_ioctl_mixdev,
-        open:au1550_open_mixdev,
-        release:au1550_release_mixdev,
+        .owner          = THIS_MODULE,
+        .llseek         = au1550_llseek,
+        .unlocked_ioctl = au1550_ioctl_mixdev,
+        .open           = au1550_open_mixdev,
+        .release        = au1550_release_mixdev,
 };
 
 static int
@@ -1343,8 +1341,7 @@ dma_count_done(struct dmabuf *db)
 
 
 static int
-au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                                                        unsigned long arg)
+au1550_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct au1550_state *s = (struct au1550_state *)file->private_data;
         unsigned long   flags;
@@ -1780,6 +1777,17 @@ au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         return mixdev_ioctl(s->codec, cmd, arg);
 }
 
+static long
+au1550_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = au1550_ioctl(file, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
 
 static int
 au1550_open(struct inode *inode, struct file *file)
@@ -1797,21 +1805,22 @@ au1550_open(struct inode *inode, struct file *file)
 #endif
 
         file->private_data = s;
+        lock_kernel();
         /* wait for device to become free */
         mutex_lock(&s->open_mutex);
         while (s->open_mode & file->f_mode) {
-                if (file->f_flags & O_NONBLOCK) {
-                        mutex_unlock(&s->open_mutex);
-                        return -EBUSY;
-                }
+                ret = -EBUSY;
+                if (file->f_flags & O_NONBLOCK)
+                        goto out;
                 add_wait_queue(&s->open_wait, &wait);
                 __set_current_state(TASK_INTERRUPTIBLE);
                 mutex_unlock(&s->open_mutex);
                 schedule();
                 remove_wait_queue(&s->open_wait, &wait);
                 set_current_state(TASK_RUNNING);
+                ret = -ERESTARTSYS;
                 if (signal_pending(current))
-                        return -ERESTARTSYS;
+                        goto out2;
                 mutex_lock(&s->open_mutex);
         }
 
@@ -1840,17 +1849,21 @@ au1550_open(struct inode *inode, struct file *file)
 
         if (file->f_mode & FMODE_READ) {
                 if ((ret = prog_dmabuf_adc(s)))
-                        return ret;
+                        goto out;
         }
         if (file->f_mode & FMODE_WRITE) {
                 if ((ret = prog_dmabuf_dac(s)))
-                        return ret;
+                        goto out;
         }
 
         s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
-        mutex_unlock(&s->open_mutex);
         mutex_init(&s->sem);
-        return 0;
+        ret = 0;
+out:
+        mutex_unlock(&s->open_mutex);
+out2:
+        unlock_kernel();
+        return ret;
 }
 
 static int
@@ -1885,15 +1898,15 @@ au1550_release(struct inode *inode, struct file *file)
 }
 
 static /*const */ struct file_operations au1550_audio_fops = {
-        owner:          THIS_MODULE,
-        llseek:         au1550_llseek,
-        read:           au1550_read,
-        write:          au1550_write,
-        poll:           au1550_poll,
-        ioctl:          au1550_ioctl,
-        mmap:           au1550_mmap,
-        open:           au1550_open,
-        release:        au1550_release,
+        .owner          = THIS_MODULE,
+        .llseek         = au1550_llseek,
+        .read           = au1550_read,
+        .write          = au1550_write,
+        .poll           = au1550_poll,
+        .unlocked_ioctl = au1550_unlocked_ioctl,
+        .mmap           = au1550_mmap,
+        .open           = au1550_open,
+        .release        = au1550_release,
 };
 
 MODULE_AUTHOR("Advanced Micro Devices (AMD), dan@embeddededge.com");
diff --git a/sound/oss/dmasound/dmasound_core.c b/sound/oss/dmasound/dmasound_core.c
index 3f3c3f71db4b..6ecd41abb066 100644
--- a/sound/oss/dmasound/dmasound_core.c
+++ b/sound/oss/dmasound/dmasound_core.c
@@ -323,9 +323,13 @@ static struct {
 
 static int mixer_open(struct inode *inode, struct file *file)
 {
-        if (!try_module_get(dmasound.mach.owner))
+        lock_kernel();
+        if (!try_module_get(dmasound.mach.owner)) {
+                unlock_kernel();
                 return -ENODEV;
+        }
         mixer.busy = 1;
+        unlock_kernel();
         return 0;
 }
 
@@ -337,8 +341,8 @@ static int mixer_release(struct inode *inode, struct file *file)
         unlock_kernel();
         return 0;
 }
-static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                       u_long arg)
+
+static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
 {
         if (_SIOC_DIR(cmd) & _SIOC_WRITE)
             mixer.modify_counter++;
@@ -362,11 +366,22 @@ static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
         return -EINVAL;
 }
 
+static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = mixer_ioctl(file, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
+
 static const struct file_operations mixer_fops =
 {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = mixer_ioctl,
+        .unlocked_ioctl = mixer_unlocked_ioctl,
         .open           = mixer_open,
         .release        = mixer_release,
 };
@@ -737,8 +752,11 @@ static int sq_open(struct inode *inode, struct file *file)
 {
         int rc;
 
-        if (!try_module_get(dmasound.mach.owner))
+        lock_kernel();
+        if (!try_module_get(dmasound.mach.owner)) {
+                unlock_kernel();
                 return -ENODEV;
+        }
 
         rc = write_sq_open(file); /* checks the f_mode */
         if (rc)
@@ -781,10 +799,11 @@ static int sq_open(struct inode *inode, struct file *file)
                 sound_set_format(AFMT_MU_LAW);
         }
 #endif
-
+        unlock_kernel();
         return 0;
  out:
         module_put(dmasound.mach.owner);
+        unlock_kernel();
         return rc;
 }
 
@@ -955,8 +974,7 @@ printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
         return 0 ;
 }
 
-static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                    u_long arg)
+static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
 {
         int val, result;
         u_long fmt;
@@ -1114,18 +1132,29 @@ static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
                 return IOCTL_OUT(arg,val);
 
         default:
-                return mixer_ioctl(inode, file, cmd, arg);
+                return mixer_ioctl(file, cmd, arg);
         }
         return -EINVAL;
 }
 
+static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = sq_ioctl(file, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
+
 static const struct file_operations sq_fops =
 {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = sq_write,
         .poll           = sq_poll,
-        .ioctl          = sq_ioctl,
+        .unlocked_ioctl = sq_unlocked_ioctl,
         .open           = sq_open,
         .release        = sq_release,
 };
@@ -1226,12 +1255,17 @@ static int state_open(struct inode *inode, struct file *file)
 {
         char *buffer = state.buf;
         int len = 0;
+        int ret;
 
+        lock_kernel();
+        ret = -EBUSY;
         if (state.busy)
-                return -EBUSY;
+                goto out;
 
+        ret = -ENODEV;
         if (!try_module_get(dmasound.mach.owner))
-                return -ENODEV;
+                goto out;
+
         state.ptr = 0;
         state.busy = 1;
 
@@ -1293,7 +1327,10 @@ printk("dmasound: stat buffer used %d bytes\n", len) ;
                 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
 
         state.len = len;
-        return 0;
+        ret = 0;
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int state_release(struct inode *inode, struct file *file)
diff --git a/sound/oss/midi_synth.c b/sound/oss/midi_synth.c
index 3bc7104c5379..3c09374ea5bf 100644
--- a/sound/oss/midi_synth.c
+++ b/sound/oss/midi_synth.c
@@ -523,7 +523,9 @@ midi_synth_load_patch(int dev, int format, const char __user *addr,
         {
                 unsigned char   data;
 
-                get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[hdr_size + i]));
+                if (get_user(data,
+                    (unsigned char __user *)(addr + hdr_size + i)))
+                        return -EFAULT;
 
                 eox_seen = (i > 0 && data & 0x80);      /* End of sysex */
 
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index a1e3f9671bea..2e48b17667d0 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -639,21 +639,26 @@ static int mixer_ioctl(unsigned int cmd, unsigned long arg)
         return -EINVAL;
 }
 
-static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        int minor = iminor(inode);
+        int minor = iminor(file->f_path.dentry->d_inode);
+        int ret;
 
         if (cmd == OSS_GETVERSION) {
                 int sound_version = SOUND_VERSION;
                 return put_user(sound_version, (int __user *)arg);
         }
 
+        ret = -EINVAL;
+
+        lock_kernel();
         if (minor == dev.dsp_minor)
-                return dsp_ioctl(file, cmd, arg);
+                ret = dsp_ioctl(file, cmd, arg);
         else if (minor == dev.mixer_minor)
-                return mixer_ioctl(cmd, arg);
+                ret = mixer_ioctl(cmd, arg);
+        unlock_kernel();
 
-        return -EINVAL;
+        return ret;
 }
 
 static void dsp_write_flush(void)
@@ -756,12 +761,15 @@ static int dev_open(struct inode *inode, struct file *file)
         int minor = iminor(inode);
         int err = 0;
 
+        lock_kernel();
         if (minor == dev.dsp_minor) {
                 if ((file->f_mode & FMODE_WRITE &&
                      test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
                     (file->f_mode & FMODE_READ &&
-                     test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
-                        return -EBUSY;
+                     test_bit(F_AUDIO_READ_INUSE, &dev.flags))) {
+                        err = -EBUSY;
+                        goto out;
+                }
 
                 if ((err = dsp_open(file)) >= 0) {
                         dev.nresets = 0;
@@ -782,7 +790,8 @@ static int dev_open(struct inode *inode, struct file *file)
                 /* nothing */
         } else
                 err = -EINVAL;
-
+out:
+        unlock_kernel();
         return err;
 }
 
@@ -1105,7 +1114,7 @@ static const struct file_operations dev_fileops = {
         .owner          = THIS_MODULE,
         .read           = dev_read,
         .write          = dev_write,
-        .ioctl          = dev_ioctl,
+        .unlocked_ioctl = dev_ioctl,
         .open           = dev_open,
         .release        = dev_release,
 };
@@ -1391,9 +1400,13 @@ static int __init attach_multisound(void)
                 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
                 return err;
         }
-        request_region(dev.io, dev.numio, dev.name);
+        if (request_region(dev.io, dev.numio, dev.name) == NULL) {
+                free_irq(dev.irq, &dev);
+                return -EBUSY;
+        }
 
-        if ((err = dsp_full_reset()) < 0) {
+        err = dsp_full_reset();
+        if (err < 0) {
                 release_region(dev.io, dev.numio);
                 free_irq(dev.irq, &dev);
                 return err;
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
index 4153752507e3..fdb58eb83d4e 100644
--- a/sound/oss/sh_dac_audio.c
+++ b/sound/oss/sh_dac_audio.c
@@ -15,7 +15,9 @@
 #include <linux/linkage.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
+#include <linux/smp_lock.h>
 #include <linux/sound.h>
+#include <linux/smp_lock.h>
 #include <linux/soundcard.h>
 #include <linux/interrupt.h>
 #include <linux/hrtimer.h>
@@ -92,7 +94,7 @@ static void dac_audio_set_rate(void)
         wakeups_per_second = ktime_set(0, 1000000000 / rate);
 }
 
-static int dac_audio_ioctl(struct inode *inode, struct file *file,
+static int dac_audio_ioctl(struct file *file,
                            unsigned int cmd, unsigned long arg)
 {
         int val;
@@ -158,6 +160,17 @@ static int dac_audio_ioctl(struct inode *inode, struct file *file,
         return -EINVAL;
 }
 
+static long dac_audio_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = dac_audio_ioctl(file, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
+
 static ssize_t dac_audio_write(struct file *file, const char *buf, size_t count,
                                loff_t * ppos)
 {
@@ -216,13 +229,17 @@ static int dac_audio_open(struct inode *inode, struct file *file)
 {
         if (file->f_mode & FMODE_READ)
                 return -ENODEV;
-        if (in_use)
+
+        lock_kernel();
+        if (in_use) {
+                unlock_kernel();
                 return -EBUSY;
+        }
 
         in_use = 1;
 
         dac_audio_start();
-
+        unlock_kernel();
         return 0;
 }
 
@@ -237,8 +254,8 @@ static int dac_audio_release(struct inode *inode, struct file *file)
 
 const struct file_operations dac_audio_fops = {
       .read =           dac_audio_read,
-      .write =  dac_audio_write,
-      .ioctl =  dac_audio_ioctl,
+      .write =          dac_audio_write,
+      .unlocked_ioctl = dac_audio_unlocked_ioctl,
       .open =           dac_audio_open,
       .release =        dac_audio_release,
 };
diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c
index 2d9c51312622..92aa762ffb7e 100644
--- a/sound/oss/soundcard.c
+++ b/sound/oss/soundcard.c
@@ -210,42 +210,44 @@ static int sound_open(struct inode *inode, struct file *file)
                 printk(KERN_ERR "Invalid minor device %d\n", dev);
                 return -ENXIO;
         }
+        lock_kernel();
         switch (dev & 0x0f) {
         case SND_DEV_CTL:
                 dev >>= 4;
                 if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
                         request_module("mixer%d", dev);
                 }
+                retval = -ENXIO;
                 if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
-                        return -ENXIO;
+                        break;
         
                 if (!try_module_get(mixer_devs[dev]->owner))
-                        return -ENXIO;
+                        break;
+
+                retval = 0;
                 break;
 
         case SND_DEV_SEQ:
         case SND_DEV_SEQ2:
-                if ((retval = sequencer_open(dev, file)) < 0)
-                        return retval;
+                retval = sequencer_open(dev, file);
                 break;
 
         case SND_DEV_MIDIN:
-                if ((retval = MIDIbuf_open(dev, file)) < 0)
-                        return retval;
+                retval = MIDIbuf_open(dev, file);
                 break;
 
         case SND_DEV_DSP:
         case SND_DEV_DSP16:
         case SND_DEV_AUDIO:
-                if ((retval = audio_open(dev, file)) < 0)
-                        return retval;
+                retval = audio_open(dev, file);
                 break;
 
         default:
                 printk(KERN_ERR "Invalid minor device %d\n", dev);
-                return -ENXIO;
+                retval = -ENXIO;
         }
 
+        unlock_kernel();
         return 0;
 }
 
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index 3136c88eacdf..b15840ad2527 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -68,6 +68,7 @@
 #include <linux/delay.h>
 #include <linux/sound.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/soundcard.h>
 #include <linux/ac97_codec.h>
 #include <linux/pci.h>
@@ -1534,6 +1535,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                   printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()+\n"));
 
+        lock_kernel();
         list_for_each(entry, &cs4297a_devs)
         {
                 s = list_entry(entry, struct cs4297a_state, list);
@@ -1544,6 +1546,8 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
         {
                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
                         printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- -ENODEV\n"));
+
+                unlock_kernel();
                 return -ENODEV;
         }
         VALIDATE_STATE(s);
@@ -1551,6 +1555,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
 
         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                   printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- 0\n"));
+        unlock_kernel();
 
         return nonseekable_open(inode, file);
 }
@@ -1566,11 +1571,15 @@ static int cs4297a_release_mixdev(struct inode *inode, struct file *file)
 }
 
 
-static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
+static int cs4297a_ioctl_mixdev(struct file *file,
                                unsigned int cmd, unsigned long arg)
 {
-        return mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
+        int ret;
+        lock_kernel();
+        ret = mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
                            arg);
+        unlock_kernel();
+        return ret;
 }
 
 
@@ -1580,7 +1589,7 @@ static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
 static const struct file_operations cs4297a_mixer_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = cs4297a_ioctl_mixdev,
+        .unlocked_ioctl = cs4297a_ioctl_mixdev,
         .open           = cs4297a_open_mixdev,
         .release        = cs4297a_release_mixdev,
 };
@@ -1944,7 +1953,7 @@ static int cs4297a_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 
-static int cs4297a_ioctl(struct inode *inode, struct file *file,
+static int cs4297a_ioctl(struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         struct cs4297a_state *s =
@@ -2337,6 +2346,16 @@ static int cs4297a_ioctl(struct inode *inode, struct file *file,
         return mixer_ioctl(s, cmd, arg);
 }
 
+static long cs4297a_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = cs4297a_ioctl(file, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
 
 static int cs4297a_release(struct inode *inode, struct file *file)
 {
@@ -2369,7 +2388,7 @@ static int cs4297a_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int cs4297a_open(struct inode *inode, struct file *file)
+static int cs4297a_locked_open(struct inode *inode, struct file *file)
 {
         int minor = iminor(inode);
         struct cs4297a_state *s=NULL;
@@ -2486,6 +2505,16 @@ static int cs4297a_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
+static int cs4297a_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        lock_kernel();
+        ret = cs4297a_open(inode, file);
+        unlock_kernel();
+
+        return ret;
+}
 
 // ******************************************************************************************
 //   Wave (audio) file operations struct.
@@ -2496,7 +2525,7 @@ static const struct file_operations cs4297a_audio_fops = {
         .read           = cs4297a_read,
         .write          = cs4297a_write,
         .poll           = cs4297a_poll,
-        .ioctl          = cs4297a_ioctl,
+        .unlocked_ioctl = cs4297a_unlocked_ioctl,
         .mmap           = cs4297a_mmap,
         .open           = cs4297a_open,
         .release        = cs4297a_release,
diff --git a/sound/oss/vidc.c b/sound/oss/vidc.c
index ac39a531df19..f0e0caa53200 100644
--- a/sound/oss/vidc.c
+++ b/sound/oss/vidc.c
@@ -491,9 +491,6 @@ static void __init attach_vidc(struct address_info *hw_config)
         vidc_adev = adev;
         vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));
 
-#if defined(CONFIG_SOUND_SOFTOSS) || defined(CONFIG_SOUND_SOFTOSS_MODULE)
-        softoss_dev = adev;
-#endif
         return;
 
 irq_failed:
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 20b3b325aa80..8cd73cdd88af 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -2429,8 +2429,7 @@ static unsigned int vwsnd_audio_poll(struct file *file,
         return mask;
 }
 
-static int vwsnd_audio_do_ioctl(struct inode *inode,
-                                struct file *file,
+static int vwsnd_audio_do_ioctl(struct file *file,
                                 unsigned int cmd,
                                 unsigned long arg)
 {
@@ -2446,8 +2445,8 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
         int ival;
 
         
-        DBGEV("(inode=0x%p, file=0x%p, cmd=0x%x, arg=0x%lx)\n",
-              inode, file, cmd, arg);
+        DBGEV("(file=0x%p, cmd=0x%x, arg=0x%lx)\n",
+              file, cmd, arg);
         switch (cmd) {
         case OSS_GETVERSION:            /* _SIOR ('M', 118, int) */
                 DBGX("OSS_GETVERSION\n");
@@ -2885,17 +2884,19 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
         return -EINVAL;
 }
 
-static int vwsnd_audio_ioctl(struct inode *inode,
-                                struct file *file,
+static long vwsnd_audio_ioctl(struct file *file,
                                 unsigned int cmd,
                                 unsigned long arg)
 {
         vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
         int ret;
 
+        lock_kernel();
         mutex_lock(&devc->io_mutex);
-        ret = vwsnd_audio_do_ioctl(inode, file, cmd, arg);
+        ret = vwsnd_audio_do_ioctl(file, cmd, arg);
         mutex_unlock(&devc->io_mutex);
+        unlock_kernel();
+
         return ret;
 }
 
@@ -2921,6 +2922,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         DBGE("(inode=0x%p, file=0x%p)\n", inode, file);
 
+        lock_kernel();
         INC_USE_COUNT;
         for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                 if ((devc->audio_minor & ~0x0F) == (minor & ~0x0F))
@@ -2928,6 +2930,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         if (devc == NULL) {
                 DEC_USE_COUNT;
+                unlock_kernel();
                 return -ENODEV;
         }
 
@@ -2936,11 +2939,13 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
                 mutex_unlock(&devc->open_mutex);
                 if (file->f_flags & O_NONBLOCK) {
                         DEC_USE_COUNT;
+                        unlock_kernel();
                         return -EBUSY;
                 }
                 interruptible_sleep_on(&devc->open_wait);
                 if (signal_pending(current)) {
                         DEC_USE_COUNT;
+                        unlock_kernel();
                         return -ERESTARTSYS;
                 }
                 mutex_lock(&devc->open_mutex);
@@ -2993,6 +2998,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         file->private_data = devc;
         DBGRV();
+        unlock_kernel();
         return 0;
 }
 
@@ -3044,7 +3050,7 @@ static const struct file_operations vwsnd_audio_fops = {
         .read =         vwsnd_audio_read,
         .write =        vwsnd_audio_write,
         .poll =         vwsnd_audio_poll,
-        .ioctl =        vwsnd_audio_ioctl,
+        .unlocked_ioctl = vwsnd_audio_ioctl,
         .mmap =         vwsnd_audio_mmap,
         .open =         vwsnd_audio_open,
         .release =      vwsnd_audio_release,
@@ -3062,15 +3068,18 @@ static int vwsnd_mixer_open(struct inode *inode, struct file *file)
         DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
 
         INC_USE_COUNT;
+        lock_kernel();
         for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                 if (devc->mixer_minor == iminor(inode))
                         break;
 
         if (devc == NULL) {
                 DEC_USE_COUNT;
+                unlock_kernel();
                 return -ENODEV;
         }
         file->private_data = devc;
+        unlock_kernel();
         return 0;
 }
 
@@ -3203,8 +3212,7 @@ static int mixer_write_ioctl(vwsnd_dev_t *devc, unsigned int nr, void __user *ar
 
 /* This is the ioctl entry to the mixer driver. */
 
-static int vwsnd_mixer_ioctl(struct inode *ioctl,
-                              struct file *file,
+static long vwsnd_mixer_ioctl(struct file *file,
                               unsigned int cmd,
                               unsigned long arg)
 {
@@ -3215,6 +3223,7 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
 
         DBGEV("(devc=0x%p, cmd=0x%x, arg=0x%lx)\n", devc, cmd, arg);
 
+        lock_kernel();
         mutex_lock(&devc->mix_mutex);
         {
                 if ((cmd & ~nrmask) == MIXER_READ(0))
@@ -3225,13 +3234,14 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
                         retval = -EINVAL;
         }
         mutex_unlock(&devc->mix_mutex);
+        unlock_kernel();
         return retval;
 }
 
 static const struct file_operations vwsnd_mixer_fops = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
-        .ioctl =        vwsnd_mixer_ioctl,
+        .unlocked_ioctl = vwsnd_mixer_ioctl,
         .open =         vwsnd_mixer_open,
         .release =      vwsnd_mixer_release,
 };
diff --git a/sound/oss/waveartist.c b/sound/oss/waveartist.c
index e688dde6bbde..52468742d9f2 100644
--- a/sound/oss/waveartist.c
+++ b/sound/oss/waveartist.c
@@ -184,14 +184,8 @@ waveartist_iack(wavnc_info *devc)
 static inline int
 waveartist_sleep(int timeout_ms)
 {
-        unsigned int timeout = timeout_ms * 10 * HZ / 100;
-
-        do {
-                set_current_state(TASK_INTERRUPTIBLE);
-                timeout = schedule_timeout(timeout);
-        } while (timeout);
-
-        return 0;
+        unsigned int timeout = msecs_to_jiffies(timeout_ms*100);
+        return schedule_timeout_interruptible(timeout);
 }
 
 static int