9 files changed, 95 insertions, 59 deletions

diff --git a/sound/oss/dmabuf.c b/sound/oss/dmabuf.c
index 461d94cfecbe..e3f29132d3ac 100644
--- a/sound/oss/dmabuf.c
+++ b/sound/oss/dmabuf.c
@@ -28,6 +28,7 @@
 #include <linux/mm.h>
 #include <linux/gfp.h>
 #include "sound_config.h"
+#include "sleep.h"
 
 #define DMAP_FREE_ON_CLOSE      0
 #define DMAP_KEEP_ON_CLOSE      1
@@ -351,8 +352,7 @@ static void dma_reset_output(int dev)
         if (!signal_pending(current) && adev->dmap_out->qlen && 
             adev->dmap_out->underrun_count == 0){
                 spin_unlock_irqrestore(&dmap->lock,flags);
-                interruptible_sleep_on_timeout(&adev->out_sleeper,
-                                               dmabuf_timeout(dmap));
+                oss_broken_sleep_on(&adev->out_sleeper, dmabuf_timeout(dmap));
                 spin_lock_irqsave(&dmap->lock,flags);
         }
         adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
@@ -446,7 +446,7 @@ int DMAbuf_sync(int dev)
                         long t = dmabuf_timeout(dmap);
                         spin_unlock_irqrestore(&dmap->lock,flags);
                         /* FIXME: not safe may miss events */
-                        t = interruptible_sleep_on_timeout(&adev->out_sleeper, t);
+                        t = oss_broken_sleep_on(&adev->out_sleeper, t);
                         spin_lock_irqsave(&dmap->lock,flags);
                         if (!t) {
                                 adev->dmap_out->flags &= ~DMA_SYNCING;
@@ -466,7 +466,7 @@ int DMAbuf_sync(int dev)
                         while (!signal_pending(current) &&
                                adev->d->local_qlen(dev)){
                                 spin_unlock_irqrestore(&dmap->lock,flags);
-                                interruptible_sleep_on_timeout(&adev->out_sleeper,
+                                oss_broken_sleep_on(&adev->out_sleeper,
                                                                dmabuf_timeout(dmap));
                                 spin_lock_irqsave(&dmap->lock,flags);
                         }
@@ -587,8 +587,7 @@ int DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
                         timeout = dmabuf_timeout(dmap);
 
                 spin_unlock_irqrestore(&dmap->lock,flags);
-                timeout = interruptible_sleep_on_timeout(&adev->in_sleeper,
-                                                         timeout);
+                timeout = oss_broken_sleep_on(&adev->in_sleeper, timeout);
                 if (!timeout) {
                         /* FIXME: include device name */
                         err = -EIO;
@@ -768,8 +767,7 @@ static int output_sleep(int dev, int dontblock)
                 timeout_value = dmabuf_timeout(dmap);
         else
                 timeout_value = MAX_SCHEDULE_TIMEOUT;
-        timeout_value = interruptible_sleep_on_timeout(&adev->out_sleeper,
-                                                       timeout_value);
+        timeout_value = oss_broken_sleep_on(&adev->out_sleeper, timeout_value);
         if (timeout != MAX_SCHEDULE_TIMEOUT && !timeout_value) {
                 printk(KERN_WARNING "Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
                 dma_reset_output(dev);
diff --git a/sound/oss/dmasound/dmasound.h b/sound/oss/dmasound/dmasound.h
index 1308d8d34186..01019f06fa91 100644
--- a/sound/oss/dmasound/dmasound.h
+++ b/sound/oss/dmasound/dmasound.h
@@ -239,7 +239,6 @@ struct sound_queue {
     int busy, syncing, xruns, died;
 };
 
-#define SLEEP(queue)            interruptible_sleep_on_timeout(&queue, HZ)
 #define WAKE_UP(queue)          (wake_up_interruptible(&queue))
 
 extern struct sound_queue dmasound_write_sq;
diff --git a/sound/oss/dmasound/dmasound_core.c b/sound/oss/dmasound/dmasound_core.c
index bac43b5b6e95..f4ee85a4c42f 100644
--- a/sound/oss/dmasound/dmasound_core.c
+++ b/sound/oss/dmasound/dmasound_core.c
@@ -619,15 +619,27 @@ static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
         }
 
         while (uLeft) {
+                DEFINE_WAIT(wait);
+
                 while (write_sq.count >= write_sq.max_active) {
+                        prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE);
                         sq_play();
-                        if (write_sq.non_blocking)
+                        if (write_sq.non_blocking) {
+                                finish_wait(&write_sq.action_queue, &wait);
                                 return uWritten > 0 ? uWritten : -EAGAIN;
-                        SLEEP(write_sq.action_queue);
-                        if (signal_pending(current))
+                        }
+                        if (write_sq.count < write_sq.max_active)
+                                break;
+
+                        schedule_timeout(HZ);
+                        if (signal_pending(current)) {
+                                finish_wait(&write_sq.action_queue, &wait);
                                 return uWritten > 0 ? uWritten : -EINTR;
+                        }
                 }
 
+                finish_wait(&write_sq.action_queue, &wait);
+
                 /* Here, we can avoid disabling the interrupt by first
                  * copying and translating the data, and then updating
                  * the write_sq variables. Until this is done, the interrupt
@@ -707,11 +719,8 @@ static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
                         if (file->f_flags & O_NONBLOCK)
                                 return rc;
                         rc = -EINTR;
-                        while (sq->busy) {
-                                SLEEP(sq->open_queue);
-                                if (signal_pending(current))
-                                        return rc;
-                        }
+                        if (wait_event_interruptible(sq->open_queue, !sq->busy))
+                                return rc;
                         rc = 0;
 #else
                         /* OSS manual says we will return EBUSY regardless
@@ -844,7 +853,8 @@ static int sq_fsync(void)
         sq_play();      /* there may be an incomplete frame waiting */
 
         while (write_sq.active) {
-                SLEEP(write_sq.sync_queue);
+                wait_event_interruptible_timeout(write_sq.sync_queue,
+                                                 !write_sq.active, HZ);
                 if (signal_pending(current)) {
                         /* While waiting for audio output to drain, an
                          * interrupt occurred.  Stop audio output immediately
diff --git a/sound/oss/midibuf.c b/sound/oss/midibuf.c
index 8cdb2cfe65c8..8f45cd999965 100644
--- a/sound/oss/midibuf.c
+++ b/sound/oss/midibuf.c
@@ -86,9 +86,8 @@ static void drain_midi_queue(int dev)
          */
 
         if (midi_devs[dev]->buffer_status != NULL)
-                while (!signal_pending(current) && midi_devs[dev]->buffer_status(dev)) 
-                        interruptible_sleep_on_timeout(&midi_sleeper[dev],
-                                                       HZ/10);
+                wait_event_interruptible_timeout(midi_sleeper[dev],
+                                !midi_devs[dev]->buffer_status(dev), HZ/10);
 }
 
 static void midi_input_intr(int dev, unsigned char data)
@@ -233,8 +232,8 @@ void MIDIbuf_release(int dev, struct file *file)
                                                            * devices
                                                          */
 
-                while (!signal_pending(current) && DATA_AVAIL(midi_out_buf[dev]))
-                          interruptible_sleep_on(&midi_sleeper[dev]);
+                wait_event_interruptible(midi_sleeper[dev],
+                                         !DATA_AVAIL(midi_out_buf[dev]));
                 /*
                  *      Sync
                  */
@@ -282,8 +281,8 @@ int MIDIbuf_write(int dev, struct file *file, const char __user *buf, int count)
                                 goto out;
                         }
 
-                        interruptible_sleep_on(&midi_sleeper[dev]);
-                        if (signal_pending(current)) 
+                        if (wait_event_interruptible(midi_sleeper[dev],
+                                                SPACE_AVAIL(midi_out_buf[dev])))
                         {
                                 c = -EINTR;
                                 goto out;
@@ -325,8 +324,9 @@ int MIDIbuf_read(int dev, struct file *file, char __user *buf, int count)
                         c = -EAGAIN;
                         goto out;
                 }
-                interruptible_sleep_on_timeout(&input_sleeper[dev],
-                                               parms[dev].prech_timeout);
+                wait_event_interruptible_timeout(input_sleeper[dev],
+                                                 DATA_AVAIL(midi_in_buf[dev]),
+                                                 parms[dev].prech_timeout);
 
                 if (signal_pending(current))
                         c = -EINTR;     /* The user is getting restless */
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index 11ff7c55240c..c23f9f95bfa5 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -664,12 +664,15 @@ static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
 static void dsp_write_flush(void)
 {
+        int timeout = get_play_delay_jiffies(dev.DAPF.len);
+
         if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
                 return;
         set_bit(F_WRITEFLUSH, &dev.flags);
-        interruptible_sleep_on_timeout(
-                &dev.writeflush,
-                get_play_delay_jiffies(dev.DAPF.len));
+        wait_event_interruptible_timeout(
+                dev.writeflush,
+                !test_bit(F_WRITEFLUSH, &dev.flags),
+                timeout);
         clear_bit(F_WRITEFLUSH, &dev.flags);
         if (!signal_pending(current)) {
                 current->state = TASK_INTERRUPTIBLE;
@@ -897,6 +900,7 @@ static int dsp_read(char __user *buf, size_t len)
 {
         int count = len;
         char *page = (char *)__get_free_page(GFP_KERNEL);
+        int timeout = get_rec_delay_jiffies(DAR_BUFF_SIZE);
 
         if (!page)
                 return -ENOMEM;
@@ -936,11 +940,11 @@ static int dsp_read(char __user *buf, size_t len)
 
                 if (count > 0) {
                         set_bit(F_READBLOCK, &dev.flags);
-                        if (!interruptible_sleep_on_timeout(
-                                &dev.readblock,
-                                get_rec_delay_jiffies(DAR_BUFF_SIZE)))
+                        if (wait_event_interruptible_timeout(
+                                        dev.readblock,
+                                        test_bit(F_READBLOCK, &dev.flags),
+                                        timeout) <= 0)
                                 clear_bit(F_READING, &dev.flags);
-                        clear_bit(F_READBLOCK, &dev.flags);
                         if (signal_pending(current)) {
                                 free_page((unsigned long)page);
                                 return -EINTR;
@@ -955,6 +959,7 @@ static int dsp_write(const char __user *buf, size_t len)
 {
         int count = len;
         char *page = (char *)__get_free_page(GFP_KERNEL);
+        int timeout = get_play_delay_jiffies(DAP_BUFF_SIZE);
 
         if (!page)
                 return -ENOMEM;
@@ -995,10 +1000,10 @@ static int dsp_write(const char __user *buf, size_t len)
 
                 if (count > 0) {
                         set_bit(F_WRITEBLOCK, &dev.flags);
-                        interruptible_sleep_on_timeout(
-                                &dev.writeblock,
-                                get_play_delay_jiffies(DAP_BUFF_SIZE));
-                        clear_bit(F_WRITEBLOCK, &dev.flags);
+                        wait_event_interruptible_timeout(
+                                dev.writeblock,
+                                test_bit(F_WRITEBLOCK, &dev.flags),
+                                timeout);
                         if (signal_pending(current)) {
                                 free_page((unsigned long)page);
                                 return -EINTR;
@@ -1044,7 +1049,7 @@ static __inline__ void eval_dsp_msg(register WORD wMessage)
                         clear_bit(F_WRITING, &dev.flags);
                 }
 
-                if (test_bit(F_WRITEBLOCK, &dev.flags))
+                if (test_and_clear_bit(F_WRITEBLOCK, &dev.flags))
                         wake_up_interruptible(&dev.writeblock);
                 break;
 
@@ -1055,7 +1060,7 @@ static __inline__ void eval_dsp_msg(register WORD wMessage)
 
                 pack_DARQ_to_DARF(dev.last_recbank);
 
-                if (test_bit(F_READBLOCK, &dev.flags))
+                if (test_and_clear_bit(F_READBLOCK, &dev.flags))
                         wake_up_interruptible(&dev.readblock);
                 break;
 
diff --git a/sound/oss/sequencer.c b/sound/oss/sequencer.c
index 4ff60a6427d9..9b9f7d385134 100644
--- a/sound/oss/sequencer.c
+++ b/sound/oss/sequencer.c
@@ -19,6 +19,7 @@
 #include "sound_config.h"
 
 #include "midi_ctrl.h"
+#include "sleep.h"
 
 static int      sequencer_ok;
 static struct sound_timer_operations *tmr;
@@ -100,8 +101,7 @@ int sequencer_read(int dev, struct file *file, char __user *buf, int count)
                         return -EAGAIN;
                 }
 
-                interruptible_sleep_on_timeout(&midi_sleeper,
-                                               pre_event_timeout);
+                oss_broken_sleep_on(&midi_sleeper, pre_event_timeout);
                 spin_lock_irqsave(&lock,flags);
                 if (!iqlen)
                 {
@@ -343,7 +343,7 @@ static int seq_queue(unsigned char *note, char nonblock)
                 /*
                  * Sleep until there is enough space on the queue
                  */
-                interruptible_sleep_on(&seq_sleeper);
+                oss_broken_sleep_on(&seq_sleeper, MAX_SCHEDULE_TIMEOUT);
         }
         if (qlen >= SEQ_MAX_QUEUE)
         {
@@ -1122,8 +1122,7 @@ static void seq_drain_midi_queues(void)
                  */
 
                 if (n)
-                        interruptible_sleep_on_timeout(&seq_sleeper,
-                                                       HZ/10);
+                        oss_broken_sleep_on(&seq_sleeper, HZ/10);
         }
 }
 
@@ -1145,8 +1144,7 @@ void sequencer_release(int dev, struct file *file)
                 while (!signal_pending(current) && qlen > 0)
                 {
                         seq_sync();
-                        interruptible_sleep_on_timeout(&seq_sleeper,
-                                                       3*HZ);
+                        oss_broken_sleep_on(&seq_sleeper, 3*HZ);
                         /* Extra delay */
                 }
         }
@@ -1201,7 +1199,7 @@ static int seq_sync(void)
                 seq_startplay();
 
         if (qlen > 0)
-                interruptible_sleep_on_timeout(&seq_sleeper, HZ);
+                oss_broken_sleep_on(&seq_sleeper, HZ);
         return qlen;
 }
 
@@ -1224,7 +1222,7 @@ static void midi_outc(int dev, unsigned char data)
 
         spin_lock_irqsave(&lock,flags);
         while (n && !midi_devs[dev]->outputc(dev, data)) {
-                interruptible_sleep_on_timeout(&seq_sleeper, HZ/25);
+                oss_broken_sleep_on(&seq_sleeper, HZ/25);
                 n--;
         }
         spin_unlock_irqrestore(&lock,flags);
diff --git a/sound/oss/sleep.h b/sound/oss/sleep.h
new file mode 100644
index 000000000000..a20fc925a5ce
--- /dev/null
+++ b/sound/oss/sleep.h
@@ -0,0 +1,18 @@
+#include <linux/wait.h>
+
+/*
+ * Do not use. This is a replacement for the old
+ * "interruptible_sleep_on_timeout" function that has been
+ * deprecated for ages. All users should instead try to use
+ * wait_event_interruptible_timeout.
+ */
+
+static inline long
+oss_broken_sleep_on(wait_queue_head_t *q, long timeout)
+{
+        DEFINE_WAIT(wait);
+        prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE);
+        timeout = schedule_timeout(timeout);
+        finish_wait(q, &wait);
+        return timeout;
+}
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index 7d8803a00b79..f851fd0e199c 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -90,6 +90,8 @@
 #include <asm/sibyte/sb1250_mac.h>
 #include <asm/sibyte/sb1250.h>
 
+#include "sleep.h"
+
 struct cs4297a_state;
 
 static DEFINE_MUTEX(swarm_cs4297a_mutex);
@@ -748,7 +750,7 @@ static int serdma_reg_access(struct cs4297a_state *s, u64 data)
                 /* Since a writer has the DSP open, we have to mux the
                    request in */
                 s->reg_request = data;
-                interruptible_sleep_on(&s->dma_dac.reg_wait);
+                oss_broken_sleep_on(&s->dma_dac.reg_wait, MAX_SCHEDULE_TIMEOUT);
                 /* XXXKW how can I deal with the starvation case where
                    the opener isn't writing? */
         } else {
@@ -790,7 +792,7 @@ static int cs4297a_read_ac97(struct cs4297a_state *s, u32 offset,
         if (serdma_reg_access(s, (0xCLL << 60) | (1LL << 47) | ((u64)(offset & 0x7F) << 40)))
                 return -1;
 
-        interruptible_sleep_on(&s->dma_adc.reg_wait);
+        oss_broken_sleep_on(&s->dma_adc.reg_wait, MAX_SCHEDULE_TIMEOUT);
         *value = s->read_value;
         CS_DBGOUT(CS_AC97, 2,
                   printk(KERN_INFO "cs4297a: rdr reg %x -> %x\n", s->read_reg, s->read_value));
@@ -1740,7 +1742,7 @@ static ssize_t cs4297a_read(struct file *file, char *buffer, size_t count,
                         start_adc(s);
                         if (file->f_flags & O_NONBLOCK)
                                 return ret ? ret : -EAGAIN;
-                        interruptible_sleep_on(&s->dma_adc.wait);
+                        oss_broken_sleep_on(&s->dma_adc.wait, MAX_SCHEDULE_TIMEOUT);
                         if (signal_pending(current))
                                 return ret ? ret : -ERESTARTSYS;
                         continue;
@@ -1836,7 +1838,7 @@ static ssize_t cs4297a_write(struct file *file, const char *buffer,
                         start_dac(s);
                         if (file->f_flags & O_NONBLOCK)
                                 return ret ? ret : -EAGAIN;
-                        interruptible_sleep_on(&d->wait);
+                        oss_broken_sleep_on(&d->wait, MAX_SCHEDULE_TIMEOUT);
                         if (signal_pending(current))
                                 return ret ? ret : -ERESTARTSYS;
                         continue;
@@ -2452,7 +2454,7 @@ static int cs4297a_locked_open(struct inode *inode, struct file *file)
                                 return -EBUSY;
                         }
                         mutex_unlock(&s->open_sem_dac);
-                        interruptible_sleep_on(&s->open_wait_dac);
+                        oss_broken_sleep_on(&s->open_wait_dac, MAX_SCHEDULE_TIMEOUT);
 
                         if (signal_pending(current)) {
                                 printk("open - sig pending\n");
@@ -2469,7 +2471,7 @@ static int cs4297a_locked_open(struct inode *inode, struct file *file)
                                 return -EBUSY;
                         }
                         mutex_unlock(&s->open_sem_adc);
-                        interruptible_sleep_on(&s->open_wait_adc);
+                        oss_broken_sleep_on(&s->open_wait_adc, MAX_SCHEDULE_TIMEOUT);
 
                         if (signal_pending(current)) {
                                 printk("open - sig pending\n");
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 4bbcc0fcd4eb..a077e9c69a5e 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -2921,6 +2921,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
         vwsnd_dev_t *devc;
         int minor = iminor(inode);
         int sw_samplefmt;
+        DEFINE_WAIT(wait);
 
         DBGE("(inode=0x%p, file=0x%p)\n", inode, file);
 
@@ -2937,21 +2938,26 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
         }
 
         mutex_lock(&devc->open_mutex);
-        while (devc->open_mode & file->f_mode) {
+        while (1) {
+                prepare_to_wait(&devc->open_wait, &wait, TASK_INTERRUPTIBLE);
+                if (!(devc->open_mode & file->f_mode))
+                        break;
+
                 mutex_unlock(&devc->open_mutex);
+                mutex_unlock(&vwsnd_mutex);
                 if (file->f_flags & O_NONBLOCK) {
                         DEC_USE_COUNT;
-                        mutex_unlock(&vwsnd_mutex);
                         return -EBUSY;
                 }
-                interruptible_sleep_on(&devc->open_wait);
+                schedule();
                 if (signal_pending(current)) {
                         DEC_USE_COUNT;
-                        mutex_unlock(&vwsnd_mutex);
                         return -ERESTARTSYS;
                 }
+                mutex_lock(&vwsnd_mutex);
                 mutex_lock(&devc->open_mutex);
         }
+        finish_wait(&devc->open_wait, &wait);
         devc->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
         mutex_unlock(&devc->open_mutex);