unsigned int ai_interval;
        /* commands */
        u8 *dux_commands;
-       struct semaphore sem;
+       struct mutex mut;
 };
 
 static void usbdux_unlink_urbs(struct urb **urbs, int num_urbs)
        struct usbdux_private *devpriv = dev->private;
 
        /* prevent other CPUs from submitting new commands just now */
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
        /* unlink only if the urb really has been submitted */
        usbdux_ai_stop(dev, devpriv->ai_cmd_running);
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return 0;
 }
        struct usbdux_private *devpriv = dev->private;
 
        /* prevent other CPUs from submitting a command just now */
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
        /* unlink only if it is really running */
        usbdux_ao_stop(dev, devpriv->ao_cmd_running);
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return 0;
 }
        if (trig_num != cmd->start_arg)
                return -EINVAL;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (!devpriv->ai_cmd_running) {
                devpriv->ai_cmd_running = 1;
        }
 
 ai_trig_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
        return ret;
 }
 
        int i;
 
        /* block other CPUs from starting an ai_cmd */
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (devpriv->ai_cmd_running)
                goto ai_cmd_exit;
        }
 
 ai_cmd_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret;
 }
        int ret = -EBUSY;
        int i;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (devpriv->ai_cmd_running)
                goto ai_read_exit;
        }
 
 ai_read_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret ? ret : insn->n;
 }
        struct usbdux_private *devpriv = dev->private;
        int ret;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
        ret = comedi_readback_insn_read(dev, s, insn, data);
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret;
 }
        int ret = -EBUSY;
        int i;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (devpriv->ao_cmd_running)
                goto ao_write_exit;
        }
 
 ao_write_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret ? ret : insn->n;
 }
        if (trig_num != cmd->start_arg)
                return -EINVAL;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (!devpriv->ao_cmd_running) {
                devpriv->ao_cmd_running = 1;
        }
 
 ao_trig_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
        return ret;
 }
 
        struct comedi_cmd *cmd = &s->async->cmd;
        int ret = -EBUSY;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (devpriv->ao_cmd_running)
                goto ao_cmd_exit;
        }
 
 ao_cmd_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret;
 }
        struct usbdux_private *devpriv = dev->private;
        int ret;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        comedi_dio_update_state(s, data);
 
        data[1] = le16_to_cpu(devpriv->insn_buf[1]);
 
 dio_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret ? ret : insn->n;
 }
        int ret = 0;
        int i;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        for (i = 0; i < insn->n; i++) {
                ret = send_dux_commands(dev, USBDUX_CMD_TIMER_RD);
        }
 
 counter_read_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret ? ret : insn->n;
 }
        int ret = 0;
        int i;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        devpriv->dux_commands[1] = chan;
 
                        break;
        }
 
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret ? ret : insn->n;
 }
        struct usbdux_private *devpriv = dev->private;
        int ret;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
        /* unlink only if it is really running */
        usbdux_pwm_stop(dev, devpriv->pwm_cmd_running);
        ret = send_dux_commands(dev, USBDUX_CMD_PWM_OFF);
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret;
 }
        struct usbdux_private *devpriv = dev->private;
        int ret = 0;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        if (devpriv->pwm_cmd_running)
                goto pwm_start_exit;
                devpriv->pwm_cmd_running = 0;
 
 pwm_start_exit:
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 
        return ret;
 }
        if (!devpriv)
                return -ENOMEM;
 
-       sema_init(&devpriv->sem, 1);
+       mutex_init(&devpriv->mut);
 
        usb_set_intfdata(intf, devpriv);
 
        if (!devpriv)
                return;
 
-       down(&devpriv->sem);
+       mutex_lock(&devpriv->mut);
 
        /* force unlink all urbs */
        usbdux_pwm_stop(dev, 1);
 
        usbdux_free_usb_buffers(dev);
 
-       up(&devpriv->sem);
+       mutex_unlock(&devpriv->mut);
 }
 
 static struct comedi_driver usbdux_driver = {