#include <linux/gameport.h>
#include <linux/wait.h>
#include <linux/dma-mapping.h>
-#include <linux/mutex.h>
#include <asm/io.h>
#include <asm/page.h>
unsigned sctrl;
spinlock_t lock;
- struct mutex open_mutex;
+ struct semaphore open_sem;
mode_t open_mode;
wait_queue_head_t open_wait;
struct gameport *gameport;
#endif
- struct mutex mutex;
+ struct semaphore sem;
};
/* --------------------------------------------------------------------- */
return -ENXIO;
if (!access_ok(VERIFY_WRITE, buffer, count))
return -EFAULT;
- mutex_lock(&s->mutex);
+ down(&s->sem);
if (!s->dma_adc.ready && (ret = prog_dmabuf_adc(s)))
goto out;
ret = -EAGAIN;
goto out;
}
- mutex_unlock(&s->mutex);
+ up(&s->sem);
schedule();
if (signal_pending(current)) {
if (!ret)
ret = -ERESTARTSYS;
goto out;
}
- mutex_lock(&s->mutex);
+ down(&s->sem);
if (s->dma_adc.mapped)
{
ret = -ENXIO;
start_adc(s);
}
out:
- mutex_unlock(&s->mutex);
+ up(&s->sem);
remove_wait_queue(&s->dma_adc.wait, &wait);
set_current_state(TASK_RUNNING);
return ret;
return -ENXIO;
if (!access_ok(VERIFY_READ, buffer, count))
return -EFAULT;
- mutex_lock(&s->mutex);
+ down(&s->sem);
if (!s->dma_dac2.ready && (ret = prog_dmabuf_dac2(s)))
goto out;
ret = 0;
ret = -EAGAIN;
goto out;
}
- mutex_unlock(&s->mutex);
+ up(&s->sem);
schedule();
if (signal_pending(current)) {
if (!ret)
ret = -ERESTARTSYS;
goto out;
}
- mutex_lock(&s->mutex);
+ down(&s->sem);
if (s->dma_dac2.mapped)
{
ret = -ENXIO;
start_dac2(s);
}
out:
- mutex_unlock(&s->mutex);
+ up(&s->sem);
remove_wait_queue(&s->dma_dac2.wait, &wait);
set_current_state(TASK_RUNNING);
return ret;
VALIDATE_STATE(s);
lock_kernel();
- mutex_lock(&s->mutex);
+ down(&s->sem);
if (vma->vm_flags & VM_WRITE) {
if ((ret = prog_dmabuf_dac2(s)) != 0) {
goto out;
}
db->mapped = 1;
out:
- mutex_unlock(&s->mutex);
+ up(&s->sem);
unlock_kernel();
return ret;
}
VALIDATE_STATE(s);
file->private_data = s;
/* wait for device to become free */
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
while (s->open_mode & file->f_mode) {
if (file->f_flags & O_NONBLOCK) {
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
return -EBUSY;
}
add_wait_queue(&s->open_wait, &wait);
__set_current_state(TASK_INTERRUPTIBLE);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
schedule();
remove_wait_queue(&s->open_wait, &wait);
set_current_state(TASK_RUNNING);
if (signal_pending(current))
return -ERESTARTSYS;
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
}
spin_lock_irqsave(&s->lock, flags);
if (!(s->open_mode & (FMODE_READ|FMODE_WRITE)))
outl(s->ctrl, s->io+ES1370_REG_CONTROL);
spin_unlock_irqrestore(&s->lock, flags);
s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
- mutex_unlock(&s->open_mutex);
- mutex_init(&s->mutex);
+ up(&s->open_sem);
+ init_MUTEX(&s->sem);
return nonseekable_open(inode, file);
}
lock_kernel();
if (file->f_mode & FMODE_WRITE)
drain_dac2(s, file->f_flags & O_NONBLOCK);
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
if (file->f_mode & FMODE_WRITE) {
stop_dac2(s);
synchronize_irq(s->irq);
}
s->open_mode &= ~(file->f_mode & (FMODE_READ|FMODE_WRITE));
wake_up(&s->open_wait);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
unlock_kernel();
return 0;
}
return -EINVAL;
file->private_data = s;
/* wait for device to become free */
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
while (s->open_mode & FMODE_DAC) {
if (file->f_flags & O_NONBLOCK) {
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
return -EBUSY;
}
add_wait_queue(&s->open_wait, &wait);
__set_current_state(TASK_INTERRUPTIBLE);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
schedule();
remove_wait_queue(&s->open_wait, &wait);
set_current_state(TASK_RUNNING);
if (signal_pending(current))
return -ERESTARTSYS;
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
}
s->dma_dac1.ossfragshift = s->dma_dac1.ossmaxfrags = s->dma_dac1.subdivision = 0;
s->dma_dac1.enabled = 1;
outl(s->ctrl, s->io+ES1370_REG_CONTROL);
spin_unlock_irqrestore(&s->lock, flags);
s->open_mode |= FMODE_DAC;
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
return nonseekable_open(inode, file);
}
VALIDATE_STATE(s);
lock_kernel();
drain_dac1(s, file->f_flags & O_NONBLOCK);
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
stop_dac1(s);
dealloc_dmabuf(s, &s->dma_dac1);
s->open_mode &= ~FMODE_DAC;
wake_up(&s->open_wait);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
unlock_kernel();
return 0;
}
VALIDATE_STATE(s);
file->private_data = s;
/* wait for device to become free */
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
while (s->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
if (file->f_flags & O_NONBLOCK) {
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
return -EBUSY;
}
add_wait_queue(&s->open_wait, &wait);
__set_current_state(TASK_INTERRUPTIBLE);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
schedule();
remove_wait_queue(&s->open_wait, &wait);
set_current_state(TASK_RUNNING);
if (signal_pending(current))
return -ERESTARTSYS;
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
}
spin_lock_irqsave(&s->lock, flags);
if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
es1370_handle_midi(s);
spin_unlock_irqrestore(&s->lock, flags);
s->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
return nonseekable_open(inode, file);
}
remove_wait_queue(&s->midi.owait, &wait);
set_current_state(TASK_RUNNING);
}
- mutex_lock(&s->open_mutex);
+ down(&s->open_sem);
s->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ|FMODE_MIDI_WRITE));
spin_lock_irqsave(&s->lock, flags);
if (!(s->open_mode & (FMODE_MIDI_READ | FMODE_MIDI_WRITE))) {
}
spin_unlock_irqrestore(&s->lock, flags);
wake_up(&s->open_wait);
- mutex_unlock(&s->open_mutex);
+ up(&s->open_sem);
unlock_kernel();
return 0;
}
init_waitqueue_head(&s->open_wait);
init_waitqueue_head(&s->midi.iwait);
init_waitqueue_head(&s->midi.owait);
- mutex_init(&s->open_mutex);
+ init_MUTEX(&s->open_sem);
spin_lock_init(&s->lock);
s->magic = ES1370_MAGIC;
s->dev = pcidev;