#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <linux/usb.h>
#include <linux/usb_cdc.h>
static struct tty_driver *acm_tty_driver;
static struct acm *acm_table[ACM_TTY_MINORS];
-static DECLARE_MUTEX(open_sem);
+static DEFINE_MUTEX(open_mutex);
#define ACM_READY(acm) (acm && acm->dev && acm->used)
int rv = -EINVAL;
int i;
dbg("Entering acm_tty_open.\n");
-
- down(&open_sem);
+
+ mutex_lock(&open_mutex);
acm = acm_table[tty->index];
if (!acm || !acm->dev)
done:
err_out:
- up(&open_sem);
+ mutex_unlock(&open_mutex);
return rv;
full_bailout:
usb_kill_urb(acm->ctrlurb);
bail_out:
acm->used--;
- up(&open_sem);
+ mutex_unlock(&open_mutex);
return -EIO;
}
if (!acm || !acm->used)
return;
- down(&open_sem);
+ mutex_lock(&open_mutex);
if (!--acm->used) {
if (acm->dev) {
acm_set_control(acm, acm->ctrlout = 0);
} else
acm_tty_unregister(acm);
}
- up(&open_sem);
+ mutex_unlock(&open_mutex);
}
static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
return;
}
- down(&open_sem);
+ mutex_lock(&open_mutex);
if (!usb_get_intfdata(intf)) {
- up(&open_sem);
+ mutex_unlock(&open_mutex);
return;
}
acm->dev = NULL;
if (!acm->used) {
acm_tty_unregister(acm);
- up(&open_sem);
+ mutex_unlock(&open_mutex);
return;
}
- up(&open_sem);
+ mutex_unlock(&open_mutex);
if (acm->tty)
tty_hangup(acm->tty);
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/lp.h>
+#include <linux/mutex.h>
#undef DEBUG
#include <linux/usb.h>
/* forward reference to make our lives easier */
static struct usb_driver usblp_driver;
-static DECLARE_MUTEX(usblp_sem); /* locks the existence of usblp's */
+static DEFINE_MUTEX(usblp_mutex); /* locks the existence of usblp's */
/*
* Functions for usblp control messages.
if (minor < 0)
return -ENODEV;
- down (&usblp_sem);
+ mutex_lock (&usblp_mutex);
retval = -ENODEV;
intf = usb_find_interface(&usblp_driver, minor);
}
}
out:
- up (&usblp_sem);
+ mutex_unlock (&usblp_mutex);
return retval;
}
{
struct usblp *usblp = file->private_data;
- down (&usblp_sem);
+ mutex_lock (&usblp_mutex);
usblp->used = 0;
if (usblp->present) {
usblp_unlink_urbs(usblp);
} else /* finish cleanup from disconnect */
usblp_cleanup (usblp);
- up (&usblp_sem);
+ mutex_unlock (&usblp_mutex);
return 0;
}
device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
- down (&usblp_sem);
+ mutex_lock (&usblp_mutex);
down (&usblp->sem);
usblp->present = 0;
usb_set_intfdata (intf, NULL);
if (!usblp->used)
usblp_cleanup (usblp);
- up (&usblp_sem);
+ mutex_unlock (&usblp_mutex);
}
static struct usb_device_id usblp_ids [] = {
#include <linux/usb.h>
#include <linux/smp_lock.h>
#include <linux/usbdevice_fs.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include "usb.h"
if (!access_ok(VERIFY_WRITE, buf, nbytes))
return -EFAULT;
- down (&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
/* print devices for all busses */
list_for_each_entry(bus, &usb_bus_list, bus_list) {
/* recurse through all children of the root hub */
ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos, bus->root_hub, bus, 0, 0, 0);
usb_unlock_device(bus->root_hub);
if (ret < 0) {
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return ret;
}
total_written += ret;
}
- up (&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return total_written;
}
#include <asm/scatterlist.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
+#include <linux/mutex.h>
#include <asm/irq.h>
#include <asm/byteorder.h>
static struct usb_busmap busmap;
/* used when updating list of hcds */
-DECLARE_MUTEX (usb_bus_list_lock); /* exported only for usbfs */
+DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */
EXPORT_SYMBOL_GPL (usb_bus_list_lock);
/* used for controlling access to virtual root hubs */
{
int busnum;
- down (&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
if (busnum < USB_MAXBUS) {
set_bit (busnum, busmap.busmap);
bus->busnum = busnum;
} else {
printk (KERN_ERR "%s: too many buses\n", usbcore_name);
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return -E2BIG;
}
bus->controller, "usb_host%d", busnum);
if (IS_ERR(bus->class_dev)) {
clear_bit(busnum, busmap.busmap);
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return PTR_ERR(bus->class_dev);
}
/* Add it to the local list of buses */
list_add (&bus->bus_list, &usb_bus_list);
- up (&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
usb_notify_add_bus(bus);
* controller code, as well as having it call this when cleaning
* itself up
*/
- down (&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
list_del (&bus->bus_list);
- up (&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
usb_notify_remove_bus(bus);
set_bit (devnum, usb_dev->bus->devmap.devicemap);
usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
- down (&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
usb_dev->bus->root_hub = usb_dev;
usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
if (retval != sizeof usb_dev->descriptor) {
usb_dev->bus->root_hub = NULL;
- up (&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
usb_dev->dev.bus_id, retval);
return (retval < 0) ? retval : -EMSGSIZE;
dev_err (parent_dev, "can't register root hub for %s, %d\n",
usb_dev->dev.bus_id, retval);
}
- up (&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
if (retval == 0) {
spin_lock_irq (&hcd_root_hub_lock);
hcd->rh_registered = 0;
spin_unlock_irq (&hcd_root_hub_lock);
- down(&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
usb_disconnect(&hcd->self.root_hub);
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
hcd->poll_rh = 0;
del_timer_sync(&hcd->rh_timer);
/* exported only within usbcore */
extern struct list_head usb_bus_list;
-extern struct semaphore usb_bus_list_lock;
+extern struct mutex usb_bus_list_lock;
extern wait_queue_head_t usb_kill_urb_queue;
extern struct usb_bus *usb_bus_get (struct usb_bus *bus);
#include <linux/usb.h>
#include <linux/usbdevice_fs.h>
#include <linux/kthread.h>
+#include <linux/mutex.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>
hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
int retry_counter)
{
- static DECLARE_MUTEX(usb_address0_sem);
+ static DEFINE_MUTEX(usb_address0_mutex);
struct usb_device *hdev = hub->hdev;
int i, j, retval;
if (oldspeed == USB_SPEED_LOW)
delay = HUB_LONG_RESET_TIME;
- down(&usb_address0_sem);
+ mutex_lock(&usb_address0_mutex);
/* Reset the device; full speed may morph to high speed */
retval = hub_port_reset(hub, port1, udev, delay);
fail:
if (retval)
hub_port_disable(hub, port1, 0);
- up(&usb_address0_sem);
+ mutex_unlock(&usb_address0_mutex);
return retval;
}
#include <linux/kernel.h>
#include <linux/notifier.h>
#include <linux/usb.h>
+#include <linux/mutex.h>
#include "usb.h"
static struct notifier_block *usb_notifier_list;
-static DECLARE_MUTEX(usb_notifier_lock);
+static DEFINE_MUTEX(usb_notifier_lock);
static void usb_notifier_chain_register(struct notifier_block **list,
struct notifier_block *n)
{
- down(&usb_notifier_lock);
+ mutex_lock(&usb_notifier_lock);
while (*list) {
if (n->priority > (*list)->priority)
break;
}
n->next = *list;
*list = n;
- up(&usb_notifier_lock);
+ mutex_unlock(&usb_notifier_lock);
}
static void usb_notifier_chain_unregister(struct notifier_block **nl,
struct notifier_block *n)
{
- down(&usb_notifier_lock);
+ mutex_lock(&usb_notifier_lock);
while ((*nl)!=NULL) {
if ((*nl)==n) {
*nl = n->next;
nl=&((*nl)->next);
}
exit:
- up(&usb_notifier_lock);
+ mutex_unlock(&usb_notifier_lock);
}
static int usb_notifier_call_chain(struct notifier_block **n,
int ret=NOTIFY_DONE;
struct notifier_block *nb = *n;
- down(&usb_notifier_lock);
+ mutex_lock(&usb_notifier_lock);
while (nb) {
ret = nb->notifier_call(nb,val,v);
if (ret&NOTIFY_STOP_MASK) {
nb = nb->next;
}
exit:
- up(&usb_notifier_lock);
+ mutex_unlock(&usb_notifier_lock);
return ret;
}
#include <linux/errno.h>
#include <linux/smp_lock.h>
#include <linux/usb.h>
+#include <linux/mutex.h>
#include <asm/io.h>
#include <asm/scatterlist.h>
struct usb_bus *bus;
struct usb_device *dev = NULL;
- down(&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
for (buslist = usb_bus_list.next;
buslist != &usb_bus_list;
buslist = buslist->next) {
goto exit;
}
exit:
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return dev;
}
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/wait.h>
+#include <linux/mutex.h>
#include <linux/usb.h>
#include <linux/fs.h>
int out_count; // Bytes in the buffer
int open; // Camera device open ?
- struct semaphore io_lock; // IO -lock
+ struct mutex io_lock; // IO -lock
char in [8]; // Command Input Buffer
int in_count;
info ("Found Mustek MDC800 on USB.");
- down (&mdc800->io_lock);
+ mutex_lock(&mdc800->io_lock);
retval = usb_register_dev(intf, &mdc800_class);
if (retval) {
mdc800->state=READY;
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
usb_set_intfdata(intf, mdc800);
return 0;
int retval=0;
int errn=0;
- down (&mdc800->io_lock);
+ mutex_lock(&mdc800->io_lock);
if (mdc800->state == NOT_CONNECTED)
{
dbg ("Mustek MDC800 device opened.");
error_out:
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return errn;
}
int retval=0;
dbg ("Mustek MDC800 device closed.");
- down (&mdc800->io_lock);
+ mutex_lock(&mdc800->io_lock);
if (mdc800->open && (mdc800->state != NOT_CONNECTED))
{
usb_kill_urb(mdc800->irq_urb);
retval=-EIO;
}
- up(&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return retval;
}
size_t left=len, sts=len; /* single transfer size */
char __user *ptr = buf;
- down (&mdc800->io_lock);
+ mutex_lock(&mdc800->io_lock);
if (mdc800->state == NOT_CONNECTED)
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EBUSY;
}
if (mdc800->state == WORKING)
{
warn ("Illegal State \"working\" reached during read ?!");
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EBUSY;
}
if (!mdc800->open)
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EBUSY;
}
{
if (signal_pending (current))
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EINTR;
}
if (usb_submit_urb (mdc800->download_urb, GFP_KERNEL))
{
err ("Can't submit download urb (status=%i)",mdc800->download_urb->status);
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return len-left;
}
wait_event_timeout(mdc800->download_wait, mdc800->downloaded,
if (mdc800->download_urb->status != 0)
{
err ("request download-bytes fails (status=%i)",mdc800->download_urb->status);
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return len-left;
}
}
else
{
/* No more bytes -> that's an error*/
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
}
/* Copy Bytes */
if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
sts)) {
- up(&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EFAULT;
}
ptr+=sts;
}
}
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return len-left;
}
{
size_t i=0;
- down (&mdc800->io_lock);
+ mutex_lock(&mdc800->io_lock);
if (mdc800->state != READY)
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EBUSY;
}
if (!mdc800->open )
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EBUSY;
}
unsigned char c;
if (signal_pending (current))
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EINTR;
}
if(get_user(c, buf+i))
{
- up(&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EFAULT;
}
}
else
{
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
{
err ("Camera didn't get ready.\n");
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
if (usb_submit_urb (mdc800->write_urb, GFP_KERNEL))
{
err ("submitting write urb fails (status=%i)", mdc800->write_urb->status);
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
wait_event_timeout(mdc800->write_wait, mdc800->written, TO_WRITE_GET_READY*HZ/1000);
if (mdc800->state == WORKING)
{
usb_kill_urb(mdc800->write_urb);
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
{
err ("call 0x07 before 0x05,0x3e");
mdc800->state=READY;
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
mdc800->pic_len=-1;
if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
{
err ("requesting answer from irq fails");
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
{
err ("Command Timeout.");
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return -EIO;
}
}
}
i++;
}
- up (&mdc800->io_lock);
+ mutex_unlock(&mdc800->io_lock);
return i;
}
mdc800->dev = NULL;
mdc800->state=NOT_CONNECTED;
- init_MUTEX (&mdc800->io_lock);
+ mutex_init (&mdc800->io_lock);
init_waitqueue_head (&mdc800->irq_wait);
init_waitqueue_head (&mdc800->write_wait);
*/
#define FILTER_TIME (HZ / 20)
-static DECLARE_MUTEX(disconnect_sem);
-
struct ati_remote {
struct input_dev *idev;
struct usb_device *udev;
#include <linux/delay.h>
#include <linux/usb.h>
#include <linux/smp_lock.h>
+#include <linux/mutex.h>
#include "dabusb.h"
#include "dabfirmware.h"
s->readptr = 0;
}
}
- err: //up(&s->mutex);
+ err: //mutex_unlock(&s->mutex);
return ret;
}
s = &dabusb[devnum - DABUSB_MINOR];
dbg("dabusb_open");
- down (&s->mutex);
+ mutex_lock(&s->mutex);
while (!s->usbdev || s->opened) {
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
if (file->f_flags & O_NONBLOCK) {
return -EBUSY;
if (signal_pending (current)) {
return -EAGAIN;
}
- down (&s->mutex);
+ mutex_lock(&s->mutex);
}
if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
- up(&s->mutex);
+ mutex_unlock(&s->mutex);
err("set_interface failed");
return -EINVAL;
}
s->opened = 1;
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
file->f_pos = 0;
file->private_data = s;
dbg("dabusb_release");
- down (&s->mutex);
+ mutex_lock(&s->mutex);
dabusb_stop (s);
dabusb_free_buffers (s);
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
if (!s->remove_pending) {
if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
if (s->remove_pending)
return -EIO;
- down (&s->mutex);
+ mutex_lock(&s->mutex);
if (!s->usbdev) {
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
return -EIO;
}
ret = -ENOIOCTLCMD;
break;
}
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
return ret;
}
s = &dabusb[intf->minor];
- down (&s->mutex);
+ mutex_lock(&s->mutex);
s->remove_pending = 0;
s->usbdev = usbdev;
s->devnum = intf->minor;
}
dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
usb_set_intfdata (intf, s);
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
retval = usb_register_dev(intf, &dabusb_class);
if (retval) {
return 0;
reject:
- up (&s->mutex);
+ mutex_unlock(&s->mutex);
s->usbdev = NULL;
return -ENODEV;
}
for (u = 0; u < NRDABUSB; u++) {
pdabusb_t s = &dabusb[u];
memset (s, 0, sizeof (dabusb_t));
- init_MUTEX (&s->mutex);
+ mutex_init (&s->mutex);
s->usbdev = NULL;
s->total_buffer_size = buffers;
init_waitqueue_head (&s->wait);
typedef struct
{
- struct semaphore mutex;
+ struct mutex mutex;
struct usb_device *usbdev;
wait_queue_head_t wait;
wait_queue_head_t remove_ok;
PDEBUG(5, "0x%02X:0x%02X", reg, value);
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
ov->cbuf[0] = value;
rc = usb_control_msg(ov->dev,
usb_sndctrlpipe(ov->dev, 0),
(ov->bclass == BCL_OV518)?1:2 /* REG_IO */,
USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0, (__u16)reg, &ov->cbuf[0], 1, 1000);
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
if (rc < 0)
err("reg write: error %d: %s", rc, symbolic(urb_errlist, rc));
{
int rc;
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
rc = usb_control_msg(ov->dev,
usb_rcvctrlpipe(ov->dev, 0),
(ov->bclass == BCL_OV518)?1:3 /* REG_IO */,
PDEBUG(5, "0x%02X:0x%02X", reg, ov->cbuf[0]);
}
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
return rc;
}
PDEBUG(5, "0x%02X:%7d, n=%d", reg, val, n);
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
*((__le32 *)ov->cbuf) = __cpu_to_le32(val);
1 /* REG_IO */,
USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0, (__u16)reg, ov->cbuf, n, 1000);
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
if (rc < 0)
err("reg write multiple: error %d: %s", rc,
{
int rc;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
if (ov->bclass == BCL_OV518)
rc = ov518_i2c_read_internal(ov, reg);
else
rc = ov511_i2c_read_internal(ov, reg);
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
{
int rc;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
if (ov->bclass == BCL_OV518)
rc = ov518_i2c_write_internal(ov, reg, value);
else
rc = ov511_i2c_write_internal(ov, reg, value);
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
{
int rc;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
rc = ov51x_i2c_write_mask_internal(ov, reg, value, mask);
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
{
int rc = 0;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
/* Set new slave IDs */
rc = i2c_set_slave_internal(ov, slave);
if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
err("Couldn't restore primary I2C slave");
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
{
int rc;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
/* Set new slave IDs */
rc = i2c_set_slave_internal(ov, slave);
if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
err("Couldn't restore primary I2C slave");
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
{
int rc;
- down(&ov->i2c_lock);
+ mutex_lock(&ov->i2c_lock);
rc = i2c_set_slave_internal(ov, sid);
if (rc < 0)
// FIXME: Is this actually necessary?
rc = ov51x_reset(ov, OV511_RESET_NOREGS);
out:
- up(&ov->i2c_lock);
+ mutex_unlock(&ov->i2c_lock);
return rc;
}
const int raw_bufsize = OV511_NUMFRAMES * MAX_RAW_DATA_SIZE(w, h);
PDEBUG(4, "entered");
- down(&ov->buf_lock);
+ mutex_lock(&ov->buf_lock);
if (ov->buf_state == BUF_ALLOCATED)
goto out;
ov->buf_state = BUF_ALLOCATED;
out:
- up(&ov->buf_lock);
+ mutex_unlock(&ov->buf_lock);
PDEBUG(4, "leaving");
return 0;
error:
ov51x_do_dealloc(ov);
- up(&ov->buf_lock);
+ mutex_unlock(&ov->buf_lock);
PDEBUG(4, "errored");
return -ENOMEM;
}
ov51x_dealloc(struct usb_ov511 *ov)
{
PDEBUG(4, "entered");
- down(&ov->buf_lock);
+ mutex_lock(&ov->buf_lock);
ov51x_do_dealloc(ov);
- up(&ov->buf_lock);
+ mutex_unlock(&ov->buf_lock);
PDEBUG(4, "leaving");
}
PDEBUG(4, "opening");
- down(&ov->lock);
+ mutex_lock(&ov->lock);
err = -EBUSY;
if (ov->user)
ov51x_led_control(ov, 1);
out:
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return err;
}
PDEBUG(4, "ov511_close");
- down(&ov->lock);
+ mutex_lock(&ov->lock);
ov->user--;
ov51x_stop_isoc(ov);
if (ov->dev)
ov51x_dealloc(ov);
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
/* Device unplugged while open. Only a minimum of unregistration is done
* here; the disconnect callback already did the rest. */
if (!ov->dev) {
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
kfree(ov->cbuf);
ov->cbuf = NULL;
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
ov51x_dealloc(ov);
kfree(ov);
struct usb_ov511 *ov = video_get_drvdata(vdev);
int rc;
- if (down_interruptible(&ov->lock))
+ if (mutex_lock_interruptible(&ov->lock))
return -EINTR;
rc = video_usercopy(inode, file, cmd, arg, ov51x_v4l1_ioctl_internal);
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return rc;
}
int i, rc = 0, frmx = -1;
struct ov511_frame *frame;
- if (down_interruptible(&ov->lock))
+ if (mutex_lock_interruptible(&ov->lock))
return -EINTR;
PDEBUG(4, "%ld bytes, noblock=%d", count, noblock);
PDEBUG(4, "read finished, returning %ld (sweet)", count);
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return count;
error:
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return rc;
}
+ PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))))
return -EINVAL;
- if (down_interruptible(&ov->lock))
+ if (mutex_lock_interruptible(&ov->lock))
return -EINTR;
pos = (unsigned long)ov->fbuf;
while (size > 0) {
page = vmalloc_to_pfn((void *)pos);
if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return -EAGAIN;
}
start += PAGE_SIZE;
size = 0;
}
- up(&ov->lock);
+ mutex_unlock(&ov->lock);
return 0;
}
init_waitqueue_head(&ov->wq);
- init_MUTEX(&ov->lock); /* to 1 == available */
- init_MUTEX(&ov->buf_lock);
- init_MUTEX(&ov->param_lock);
- init_MUTEX(&ov->i2c_lock);
- init_MUTEX(&ov->cbuf_lock);
+ mutex_init(&ov->lock); /* to 1 == available */
+ mutex_init(&ov->buf_lock);
+ mutex_init(&ov->i2c_lock);
+ mutex_init(&ov->cbuf_lock);
ov->buf_state = BUF_NOT_ALLOCATED;
}
if (ov->cbuf) {
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
kfree(ov->cbuf);
ov->cbuf = NULL;
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
}
kfree(ov);
/* Free the memory */
if (ov && !ov->user) {
- down(&ov->cbuf_lock);
+ mutex_lock(&ov->cbuf_lock);
kfree(ov->cbuf);
ov->cbuf = NULL;
- up(&ov->cbuf_lock);
+ mutex_unlock(&ov->cbuf_lock);
ov51x_dealloc(ov);
kfree(ov);
#include <linux/videodev.h>
#include <linux/smp_lock.h>
#include <linux/usb.h>
+#include <linux/mutex.h>
#define OV511_DEBUG /* Turn on debug messages */
int led_policy; /* LED: off|on|auto; OV511+ only */
- struct semaphore lock; /* Serializes user-accessible operations */
+ struct mutex lock; /* Serializes user-accessible operations */
int user; /* user count for exclusive use */
int streaming; /* Are we streaming Isochronous? */
int packet_size; /* Frame size per isoc desc */
int packet_numbering; /* Is ISO frame numbering enabled? */
- struct semaphore param_lock; /* params lock for this camera */
-
/* Framebuffer/sbuf management */
int buf_state;
- struct semaphore buf_lock;
+ struct mutex buf_lock;
struct ov51x_decomp_ops *decomp_ops;
int pal; /* Device is designed for PAL resolution */
/* I2C interface */
- struct semaphore i2c_lock; /* Protect I2C controller regs */
+ struct mutex i2c_lock; /* Protect I2C controller regs */
unsigned char primary_i2c_slave; /* I2C write id of sensor */
/* Control transaction stuff */
unsigned char *cbuf; /* Buffer for payload */
- struct semaphore cbuf_lock;
+ struct mutex cbuf_lock;
};
/* Used to represent a list of values and their respective symbolic names */
unsigned long size = vma->vm_end-vma->vm_start;
unsigned long page, pos;
- down(&se401->lock);
+ mutex_lock(&se401->lock);
if (se401->dev == NULL) {
- up(&se401->lock);
+ mutex_unlock(&se401->lock);
return -EIO;
}
if (size > (((SE401_NUMFRAMES * se401->maxframesize) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))) {
- up(&se401->lock);
+ mutex_unlock(&se401->lock);
return -EINVAL;
}
pos = (unsigned long)se401->fbuf;
while (size > 0) {
page = vmalloc_to_pfn((void *)pos);
if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
- up(&se401->lock);
+ mutex_unlock(&se401->lock);
return -EAGAIN;
}
start += PAGE_SIZE;
else
size = 0;
}
- up(&se401->lock);
+ mutex_unlock(&se401->lock);
return 0;
}
memcpy(&se401->vdev, &se401_template, sizeof(se401_template));
memcpy(se401->vdev.name, se401->camera_name, strlen(se401->camera_name));
init_waitqueue_head(&se401->wq);
- init_MUTEX(&se401->lock);
+ mutex_init(&se401->lock);
wmb();
if (video_register_device(&se401->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
#include <asm/uaccess.h>
#include <linux/videodev.h>
#include <linux/smp_lock.h>
+#include <linux/mutex.h>
#define se401_DEBUG /* Turn on debug messages */
int maxframesize;
int cframesize; /* current framesize */
- struct semaphore lock;
+ struct mutex lock;
int user; /* user count for exclusive use */
int removed; /* device disconnected */
#include <linux/types.h>
#include <linux/param.h>
#include <linux/rwsem.h>
+#include <linux/mutex.h>
#include <asm/semaphore.h>
#include "sn9c102_sensor.h"
u8 force_munmap;
};
-static DECLARE_MUTEX(sn9c102_sysfs_lock);
+static DEFINE_MUTEX(sn9c102_sysfs_lock);
static DECLARE_RWSEM(sn9c102_disconnect);
struct sn9c102_device {
enum sn9c102_dev_state state;
u8 users;
- struct semaphore dev_sem, fileop_sem;
+ struct mutex dev_mutex, fileop_mutex;
spinlock_t queue_lock;
wait_queue_head_t open, wait_frame, wait_stream;
};
struct sn9c102_device* cam;
ssize_t count;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
count = sprintf(buf, "%u\n", cam->sysfs.reg);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
u8 index;
ssize_t count;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
index = sn9c102_strtou8(buf, len, &count);
if (index > 0x1f || !count) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EINVAL;
}
DBG(2, "Moved SN9C10X register index to 0x%02X", cam->sysfs.reg);
DBG(3, "Written bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
ssize_t count;
int val;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EIO;
}
DBG(3, "Read bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
ssize_t count;
int err;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
value = sn9c102_strtou8(buf, len, &count);
if (!count) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EINVAL;
}
err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
if (err) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EIO;
}
cam->sysfs.reg, value);
DBG(3, "Written bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
struct sn9c102_device* cam;
ssize_t count;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
DBG(3, "Read bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
u8 index;
ssize_t count;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
index = sn9c102_strtou8(buf, len, &count);
if (!count) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EINVAL;
}
DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
DBG(3, "Written bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
ssize_t count;
int val;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
if (!(cam->sensor->sysfs_ops & SN9C102_I2C_READ)) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENOSYS;
}
if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EIO;
}
DBG(3, "Read bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
ssize_t count;
int err;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
if (!(cam->sensor->sysfs_ops & SN9C102_I2C_WRITE)) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENOSYS;
}
value = sn9c102_strtou8(buf, len, &count);
if (!count) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EINVAL;
}
err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
if (err) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -EIO;
}
cam->sysfs.i2c_reg, value);
DBG(3, "Written bytes: %zd", count);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return count;
}
u8 value;
ssize_t count;
- if (down_interruptible(&sn9c102_sysfs_lock))
+ if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
return -ERESTARTSYS;
cam = video_get_drvdata(to_video_device(cd));
if (!cam) {
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
return -ENODEV;
}
bridge = cam->bridge;
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
value = sn9c102_strtou8(buf, len, &count);
if (!count)
}
if (!(cam->state & DEV_INITIALIZED)) {
- init_MUTEX(&cam->fileop_sem);
+ mutex_init(&cam->fileop_mutex);
spin_lock_init(&cam->queue_lock);
init_waitqueue_head(&cam->wait_frame);
init_waitqueue_head(&cam->wait_stream);
static void sn9c102_release_resources(struct sn9c102_device* cam)
{
- down(&sn9c102_sysfs_lock);
+ mutex_lock(&sn9c102_sysfs_lock);
DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
video_set_drvdata(cam->v4ldev, NULL);
video_unregister_device(cam->v4ldev);
- up(&sn9c102_sysfs_lock);
+ mutex_unlock(&sn9c102_sysfs_lock);
kfree(cam->control_buffer);
}
cam = video_get_drvdata(video_devdata(filp));
- if (down_interruptible(&cam->dev_sem)) {
+ if (mutex_lock_interruptible(&cam->dev_mutex)) {
up_read(&sn9c102_disconnect);
return -ERESTARTSYS;
}
err = -EWOULDBLOCK;
goto out;
}
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
err = wait_event_interruptible_exclusive(cam->open,
cam->state & DEV_DISCONNECTED
|| !cam->users);
up_read(&sn9c102_disconnect);
return -ENODEV;
}
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
}
DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);
out:
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
up_read(&sn9c102_disconnect);
return err;
}
{
struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
- down(&cam->dev_sem); /* prevent disconnect() to be called */
+ mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */
sn9c102_stop_transfer(cam);
if (cam->state & DEV_DISCONNECTED) {
sn9c102_release_resources(cam);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
kfree(cam);
return 0;
}
DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
return 0;
}
unsigned long lock_flags;
int err = 0;
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return -ERESTARTSYS;
if (cam->state & DEV_DISCONNECTED) {
DBG(1, "Device not present");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->state & DEV_MISCONFIGURED) {
DBG(1, "The camera is misconfigured. Close and open it "
"again.");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
if (cam->io == IO_MMAP) {
DBG(3, "Close and open the device again to choose "
"the read method");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EINVAL;
}
if (cam->io == IO_NONE) {
if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
DBG(1, "read() failed, not enough memory");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENOMEM;
}
cam->io = IO_READ;
}
if (!count) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return 0;
}
if (list_empty(&cam->outqueue)) {
if (filp->f_flags & O_NONBLOCK) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EAGAIN;
}
err = wait_event_interruptible
(cam->state & DEV_DISCONNECTED) ||
(cam->state & DEV_MISCONFIGURED) );
if (err) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return err;
}
if (cam->state & DEV_DISCONNECTED) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->state & DEV_MISCONFIGURED) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
}
PDBGG("Frame #%lu, bytes read: %zu",
(unsigned long)f->buf.index, count);
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return count;
}
unsigned long lock_flags;
unsigned int mask = 0;
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return POLLERR;
if (cam->state & DEV_DISCONNECTED) {
if (!list_empty(&cam->outqueue))
mask |= POLLIN | POLLRDNORM;
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return mask;
error:
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return POLLERR;
}
void *pos;
u32 i;
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return -ERESTARTSYS;
if (cam->state & DEV_DISCONNECTED) {
DBG(1, "Device not present");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->state & DEV_MISCONFIGURED) {
DBG(1, "The camera is misconfigured. Close and open it "
"again.");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
size != PAGE_ALIGN(cam->frame[0].buf.length)) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EINVAL;
}
break;
}
if (i == cam->nbuffers) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EINVAL;
}
pos = cam->frame[i].bufmem;
while (size > 0) { /* size is page-aligned */
if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EAGAIN;
}
start += PAGE_SIZE;
sn9c102_vm_open(vma);
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return 0;
}
struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
int err = 0;
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return -ERESTARTSYS;
if (cam->state & DEV_DISCONNECTED) {
DBG(1, "Device not present");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->state & DEV_MISCONFIGURED) {
DBG(1, "The camera is misconfigured. Close and open it "
"again.");
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
err = sn9c102_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return err;
}
goto fail;
}
- init_MUTEX(&cam->dev_sem);
+ mutex_init(&cam->dev_mutex);
r = sn9c102_read_reg(cam, 0x00);
if (r < 0 || r != 0x10) {
cam->v4ldev->release = video_device_release;
video_set_drvdata(cam->v4ldev, cam);
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
video_nr[dev_nr]);
DBG(1, "Free /dev/videoX node not found");
video_nr[dev_nr] = -1;
dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
goto fail;
}
usb_set_intfdata(intf, cam);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
return 0;
down_write(&sn9c102_disconnect);
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
DBG(2, "Disconnecting %s...", cam->v4ldev->name);
sn9c102_release_resources(cam);
}
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
if (!cam->users)
kfree(cam);
#include <linux/errno.h>
#include <linux/videodev.h>
#include <linux/usb.h>
+#include <linux/mutex.h>
#include "stv680.h"
unsigned long size = vma->vm_end-vma->vm_start;
unsigned long page, pos;
- down (&stv680->lock);
+ mutex_lock(&stv680->lock);
if (stv680->udev == NULL) {
- up (&stv680->lock);
+ mutex_unlock(&stv680->lock);
return -EIO;
}
if (size > (((STV680_NUMFRAMES * stv680->maxframesize) + PAGE_SIZE - 1)
& ~(PAGE_SIZE - 1))) {
- up (&stv680->lock);
+ mutex_unlock(&stv680->lock);
return -EINVAL;
}
pos = (unsigned long) stv680->fbuf;
while (size > 0) {
page = vmalloc_to_pfn((void *)pos);
if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
- up (&stv680->lock);
+ mutex_unlock(&stv680->lock);
return -EAGAIN;
}
start += PAGE_SIZE;
else
size = 0;
}
- up (&stv680->lock);
+ mutex_unlock(&stv680->lock);
return 0;
}
memcpy (stv680->vdev->name, stv680->camera_name, strlen (stv680->camera_name));
init_waitqueue_head (&stv680->wq);
- init_MUTEX (&stv680->lock);
+ mutex_init (&stv680->lock);
wmb ();
if (video_register_device (stv680->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
int origGain;
int origMode; /* original camera mode */
- struct semaphore lock; /* to lock the structure */
+ struct mutex lock; /* to lock the structure */
int user; /* user count for exclusive use */
int removed; /* device disconnected */
int streaming; /* Are we streaming video? */
cams->md_module = md;
if (cams->md_module == NULL)
warn("%s: module == NULL!", __FUNCTION__);
- init_MUTEX(&cams->lock); /* to 1 == available */
+ mutex_init(&cams->lock); /* to 1 == available */
for (i = 0; i < num_cams; i++) {
struct uvd *up = &cams->cam[i];
if (uvd->debug > 0)
info("%s(%p.)", __FUNCTION__, intf);
- down(&uvd->lock);
+ mutex_lock(&uvd->lock);
uvd->remove_pending = 1; /* Now all ISO data will be ignored */
/* At this time we ask to cancel outstanding URBs */
info("%s: In use, disconnect pending.", __FUNCTION__);
else
usbvideo_CameraRelease(uvd);
- up(&uvd->lock);
+ mutex_unlock(&uvd->lock);
info("USB camera disconnected.");
usbvideo_ClientDecModCount(uvd);
err("No usbvideo handle?");
return -1;
}
- down(&cams->lock);
+ mutex_lock(&cams->lock);
for (u = 0; u < cams->num_cameras; u++) {
struct uvd *uvd = &cams->cam[u];
if (!uvd->uvd_used) /* This one is free */
{
uvd->uvd_used = 1; /* In use now */
- init_MUTEX(&uvd->lock); /* to 1 == available */
+ mutex_init(&uvd->lock); /* to 1 == available */
uvd->dev = NULL;
rv = u;
break;
}
}
- up(&cams->lock);
+ mutex_unlock(&cams->lock);
return rv;
}
/* Not relying upon caller we increase module counter ourselves */
usbvideo_ClientIncModCount(uvd);
- down(&uvd->lock);
+ mutex_lock(&uvd->lock);
for (i=0; i < USBVIDEO_NUMSBUF; i++) {
uvd->sbuf[i].urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
if (uvd->sbuf[i].urb == NULL) {
* return control to the client's probe function right now.
*/
allocate_done:
- up (&uvd->lock);
+ mutex_unlock(&uvd->lock);
usbvideo_ClientDecModCount(uvd);
return uvd;
}
info("%s($%p)", __FUNCTION__, dev);
usbvideo_ClientIncModCount(uvd);
- down(&uvd->lock);
+ mutex_lock(&uvd->lock);
if (uvd->user) {
err("%s: Someone tried to open an already opened device!", __FUNCTION__);
}
}
}
- up(&uvd->lock);
+ mutex_unlock(&uvd->lock);
if (errCode != 0)
usbvideo_ClientDecModCount(uvd);
if (uvd->debug > 0)
if (uvd->debug > 1)
info("%s($%p)", __FUNCTION__, dev);
- down(&uvd->lock);
+ mutex_lock(&uvd->lock);
GET_CALLBACK(uvd, stopDataPump)(uvd);
usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size);
uvd->fbuf = NULL;
info("usbvideo_v4l_close: Final disconnect.");
usbvideo_CameraRelease(uvd);
}
- up(&uvd->lock);
+ mutex_unlock(&uvd->lock);
usbvideo_ClientDecModCount(uvd);
if (uvd->debug > 1)
if (uvd->debug >= 1)
info("%s: %Zd. bytes, noblock=%d.", __FUNCTION__, count, noblock);
- down(&uvd->lock);
+ mutex_lock(&uvd->lock);
/* See if a frame is completed, then use it. */
for(i = 0; i < USBVIDEO_NUMFRAMES; i++) {
}
}
read_done:
- up(&uvd->lock);
+ mutex_unlock(&uvd->lock);
return count;
}
#include <linux/config.h>
#include <linux/videodev.h>
#include <linux/usb.h>
+#include <linux/mutex.h>
/* Most helpful debugging aid */
#define assert(expr) ((void) ((expr) ? 0 : (err("assert failed at line %d",__LINE__))))
unsigned long flags; /* FLAGS_USBVIDEO_xxx */
unsigned long paletteBits; /* Which palettes we accept? */
unsigned short defaultPalette; /* What palette to use for read() */
- struct semaphore lock;
+ struct mutex lock;
int user; /* user count for exclusive use */
videosize_t videosize; /* Current setting */
int num_cameras; /* As allocated */
struct usb_driver usbdrv; /* Interface to the USB stack */
char drvName[80]; /* Driver name */
- struct semaphore lock; /* Mutex protecting camera structures */
+ struct mutex lock; /* Mutex protecting camera structures */
struct usbvideo_cb cb; /* Table of callbacks (virtual methods) */
struct video_device vdt; /* Video device template */
struct uvd *cam; /* Array of camera structures */
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
+#include <linux/mutex.h>
#include "usbvideo.h"
// #define VICAM_DEBUG
struct usb_device *udev; // usb device
/* guard against simultaneous accesses to the camera */
- struct semaphore cam_lock;
+ struct mutex cam_lock;
int is_initialized;
u8 open_count;
u16 size)
{
int status = -ENODEV;
- down(&cam->cam_lock);
+ mutex_lock(&cam->cam_lock);
if (cam->udev) {
status = __send_control_msg(cam, request, value,
index, cp, size);
}
- up(&cam->cam_lock);
+ mutex_unlock(&cam->cam_lock);
return status;
}
static int
rvfree(cam->framebuf, VICAM_MAX_FRAME_SIZE * VICAM_FRAMES);
kfree(cam->cntrlbuf);
- down(&cam->cam_lock);
+ mutex_lock(&cam->cam_lock);
cam->open_count--;
open_count = cam->open_count;
udev = cam->udev;
- up(&cam->cam_lock);
+ mutex_unlock(&cam->cam_lock);
if (!open_count && !udev) {
kfree(cam);
request[8] = 0;
// bytes 9-15 do not seem to affect exposure or image quality
- down(&cam->cam_lock);
+ mutex_lock(&cam->cam_lock);
if (!cam->udev) {
goto done;
}
done:
- up(&cam->cam_lock);
+ mutex_unlock(&cam->cam_lock);
}
static ssize_t
cam->shutter_speed = 15;
- init_MUTEX(&cam->cam_lock);
+ mutex_init(&cam->cam_lock);
memcpy(&cam->vdev, &vicam_template,
sizeof (vicam_template));
/* stop the camera from being used */
- down(&cam->cam_lock);
+ mutex_lock(&cam->cam_lock);
/* mark the camera as gone */
open_count = cam->open_count;
- up(&cam->cam_lock);
+ mutex_unlock(&cam->cam_lock);
if (!open_count) {
kfree(cam);
#include "w9968cf.h"
#include "w9968cf_decoder.h"
+static struct w9968cf_vpp_t* w9968cf_vpp;
+static DECLARE_WAIT_QUEUE_HEAD(w9968cf_vppmod_wait);
+
+static LIST_HEAD(w9968cf_dev_list); /* head of V4L registered cameras list */
+static DEFINE_MUTEX(w9968cf_devlist_mutex); /* semaphore for list traversal */
+
+static DECLARE_RWSEM(w9968cf_disconnect); /* prevent races with open() */
/****************************************************************************
enum w9968cf_model_id mod_id,
const unsigned short dev_nr)
{
- init_MUTEX(&cam->fileop_sem);
+ mutex_init(&cam->fileop_mutex);
init_waitqueue_head(&cam->open);
spin_lock_init(&cam->urb_lock);
spin_lock_init(&cam->flist_lock);
--------------------------------------------------------------------------*/
static void w9968cf_release_resources(struct w9968cf_device* cam)
{
- down(&w9968cf_devlist_sem);
+ mutex_lock(&w9968cf_devlist_mutex);
DBG(2, "V4L device deregistered: /dev/video%d", cam->v4ldev->minor)
kfree(cam->control_buffer);
kfree(cam->data_buffer);
- up(&w9968cf_devlist_sem);
+ mutex_unlock(&w9968cf_devlist_mutex);
}
cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
if (cam->sensor == CC_UNKNOWN) {
DBG(2, "No supported image sensor has been detected by the "
"'ovcamchip' module for the %s (/dev/video%d). Make "
"sure it is loaded *before* (re)connecting the camera.",
symbolic(camlist, cam->id), cam->v4ldev->minor)
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
up_read(&w9968cf_disconnect);
return -ENODEV;
}
DBG(2, "%s (/dev/video%d) has been already occupied by '%s'",
symbolic(camlist, cam->id),cam->v4ldev->minor,cam->command)
if ((filp->f_flags & O_NONBLOCK)||(filp->f_flags & O_NDELAY)) {
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
up_read(&w9968cf_disconnect);
return -EWOULDBLOCK;
}
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
err = wait_event_interruptible_exclusive(cam->open,
cam->disconnected ||
!cam->users);
up_read(&w9968cf_disconnect);
return -ENODEV;
}
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
}
DBG(5, "Opening '%s', /dev/video%d ...",
DBG(5, "Video device is open")
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
up_read(&w9968cf_disconnect);
return 0;
deallocate_memory:
w9968cf_deallocate_memory(cam);
DBG(2, "Failed to open the video device")
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
up_read(&w9968cf_disconnect);
return err;
}
cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
- down(&cam->dev_sem); /* prevent disconnect() to be called */
+ mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */
w9968cf_stop_transfer(cam);
if (cam->disconnected) {
w9968cf_release_resources(cam);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
kfree(cam);
return 0;
}
wake_up_interruptible_nr(&cam->open, 1);
DBG(5, "Video device closed")
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
return 0;
}
if (filp->f_flags & O_NONBLOCK)
return -EWOULDBLOCK;
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return -ERESTARTSYS;
if (cam->disconnected) {
DBG(2, "Device not present")
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->misconfigured) {
DBG(2, "The camera is misconfigured. Close and open it again.")
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
cam->frame[1].status == F_READY ||
cam->disconnected);
if (err) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return err;
}
if (cam->disconnected) {
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (copy_to_user(buf, fr->buffer, count)) {
fr->status = F_UNUSED;
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EFAULT;
}
*f_pos += count;
DBG(5, "%zu bytes read", count)
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return count;
}
cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
- if (down_interruptible(&cam->fileop_sem))
+ if (mutex_lock_interruptible(&cam->fileop_mutex))
return -ERESTARTSYS;
if (cam->disconnected) {
DBG(2, "Device not present")
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -ENODEV;
}
if (cam->misconfigured) {
DBG(2, "The camera is misconfigured. Close and open it again.")
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return -EIO;
}
err = w9968cf_v4l_ioctl(inode, filp, cmd, (void __user *)arg);
- up(&cam->fileop_sem);
+ mutex_unlock(&cam->fileop_mutex);
return err;
}
if (!cam)
return -ENOMEM;
- init_MUTEX(&cam->dev_sem);
- down(&cam->dev_sem);
+ mutex_init(&cam->dev_mutex);
+ mutex_lock(&cam->dev_mutex);
cam->usbdev = udev;
/* NOTE: a local copy is used to avoid possible race conditions */
simcams = W9968CF_SIMCAMS;
/* How many cameras are connected ? */
- down(&w9968cf_devlist_sem);
+ mutex_lock(&w9968cf_devlist_mutex);
list_for_each(ptr, &w9968cf_dev_list)
sc++;
- up(&w9968cf_devlist_sem);
+ mutex_unlock(&w9968cf_devlist_mutex);
if (sc >= simcams) {
DBG(2, "Device rejected: too many connected cameras "
w9968cf_configure_camera(cam, udev, mod_id, dev_nr);
/* Add a new entry into the list of V4L registered devices */
- down(&w9968cf_devlist_sem);
+ mutex_lock(&w9968cf_devlist_mutex);
list_add(&cam->v4llist, &w9968cf_dev_list);
- up(&w9968cf_devlist_sem);
+ mutex_unlock(&w9968cf_devlist_mutex);
dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
w9968cf_turn_on_led(cam);
w9968cf_i2c_init(cam);
usb_set_intfdata(intf, cam);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
return 0;
fail: /* Free unused memory */
kfree(cam->data_buffer);
if (cam->v4ldev)
video_device_release(cam->v4ldev);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
kfree(cam);
return err;
}
if (cam) {
/* Prevent concurrent accesses to data */
- down(&cam->dev_sem);
+ mutex_lock(&cam->dev_mutex);
cam->disconnected = 1;
} else
w9968cf_release_resources(cam);
- up(&cam->dev_sem);
+ mutex_unlock(&cam->dev_mutex);
if (!cam->users)
kfree(cam);
#include <linux/param.h>
#include <linux/types.h>
#include <linux/rwsem.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
#include <media/ovcamchip.h>
VPP_UYVY_TO_RGBX = 0x08,
};
-static struct w9968cf_vpp_t* w9968cf_vpp;
-static DECLARE_WAIT_QUEUE_HEAD(w9968cf_vppmod_wait);
-
-static LIST_HEAD(w9968cf_dev_list); /* head of V4L registered cameras list */
-static DECLARE_MUTEX(w9968cf_devlist_sem); /* semaphore for list traversal */
-
-static DECLARE_RWSEM(w9968cf_disconnect); /* prevent races with open() */
-
/* Main device driver structure */
struct w9968cf_device {
struct device dev; /* device structure */
struct i2c_client* sensor_client;
/* Locks */
- struct semaphore dev_sem, /* for probe, disconnect,open and close */
- fileop_sem; /* for read and ioctl */
+ struct mutex dev_mutex, /* for probe, disconnect,open and close */
+ fileop_mutex; /* for read and ioctl */
spinlock_t urb_lock, /* for submit_urb() and unlink_urb() */
flist_lock; /* for requested frame list accesses */
wait_queue_head_t open, wait_queue;
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <linux/usb.h>
};
/* prevent races between open() and disconnect() */
-static DECLARE_MUTEX(disconnect_sem);
+static DEFINE_MUTEX(disconnect_mutex);
static int idmouse_create_image(struct usb_idmouse *dev)
{
int result = 0;
/* prevent disconnects */
- down(&disconnect_sem);
+ mutex_lock(&disconnect_mutex);
/* get the interface from minor number and driver information */
interface = usb_find_interface (&idmouse_driver, iminor (inode));
if (!interface) {
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return -ENODEV;
}
/* get the device information block from the interface */
dev = usb_get_intfdata(interface);
if (!dev) {
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return -ENODEV;
}
up(&dev->sem);
/* unlock the disconnect semaphore */
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return result;
}
struct usb_idmouse *dev;
/* prevent a race condition with open() */
- down(&disconnect_sem);
+ mutex_lock(&disconnect_mutex);
dev = (struct usb_idmouse *) file->private_data;
if (dev == NULL) {
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return -ENODEV;
}
/* are we really open? */
if (dev->open <= 0) {
up(&dev->sem);
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return -ENODEV;
}
/* the device was unplugged before the file was released */
up(&dev->sem);
idmouse_delete(dev);
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return 0;
}
up(&dev->sem);
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return 0;
}
struct usb_idmouse *dev;
/* prevent races with open() */
- down(&disconnect_sem);
+ mutex_lock(&disconnect_mutex);
/* get device structure */
dev = usb_get_intfdata(interface);
if (!dev->open)
idmouse_delete(dev);
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
info("%s disconnected", DRIVER_DESC);
}
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <linux/input.h>
};
/* prevent races between open() and disconnect() */
-static DECLARE_MUTEX(disconnect_sem);
+static DEFINE_MUTEX(disconnect_mutex);
static struct usb_driver ld_usb_driver;
nonseekable_open(inode, file);
subminor = iminor(inode);
- down(&disconnect_sem);
+ mutex_lock(&disconnect_mutex);
interface = usb_find_interface(&ld_usb_driver, subminor);
up(&dev->sem);
unlock_disconnect_exit:
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
return retval;
}
struct ld_usb *dev;
int minor;
- down(&disconnect_sem);
+ mutex_lock(&disconnect_mutex);
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
up(&dev->sem);
}
- up(&disconnect_sem);
+ mutex_unlock(&disconnect_mutex);
dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
(minor - USB_LD_MINOR_BASE));
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include <linux/usb.h>
#include <linux/poll.h>
/* prevent races between open() and disconnect */
-static DECLARE_MUTEX (disconnect_sem);
+static DEFINE_MUTEX (disconnect_mutex);
/* file operations needed when we register this driver */
static struct file_operations tower_fops = {
nonseekable_open(inode, file);
subminor = iminor(inode);
- down (&disconnect_sem);
+ mutex_lock (&disconnect_mutex);
interface = usb_find_interface (&tower_driver, subminor);
up (&dev->sem);
unlock_disconnect_exit:
- up (&disconnect_sem);
+ mutex_unlock (&disconnect_mutex);
dbg(2, "%s: leave, return value %d ", __FUNCTION__, retval);
dbg(2, "%s: enter", __FUNCTION__);
- down (&disconnect_sem);
+ mutex_lock (&disconnect_mutex);
dev = usb_get_intfdata (interface);
usb_set_intfdata (interface, NULL);
up (&dev->sem);
}
- up (&disconnect_sem);
+ mutex_unlock (&disconnect_mutex);
info("LEGO USB Tower #%d now disconnected", (minor - LEGO_USB_TOWER_MINOR_BASE));
#include <linux/debugfs.h>
#include <linux/smp_lock.h>
#include <linux/notifier.h>
+#include <linux/mutex.h>
#include "usb_mon.h"
#include "../core/hcd.h"
static void mon_bus_drop(struct kref *r);
static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus);
-DECLARE_MUTEX(mon_lock);
+DEFINE_MUTEX(mon_lock);
static struct dentry *mon_dir; /* /dbg/usbmon */
static LIST_HEAD(mon_buses); /* All buses we know: struct mon_bus */
{
struct mon_bus *mbus = ubus->mon_bus;
- down(&mon_lock);
+ mutex_lock(&mon_lock);
list_del(&mbus->bus_link);
debugfs_remove(mbus->dent_t);
debugfs_remove(mbus->dent_s);
mon_dissolve(mbus, ubus);
kref_put(&mbus->ref, mon_bus_drop);
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
}
static int mon_notify(struct notifier_block *self, unsigned long action,
goto err_create_s;
mbus->dent_s = d;
- down(&mon_lock);
+ mutex_lock(&mon_lock);
list_add_tail(&mbus->bus_link, &mon_buses);
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
return;
err_create_s:
usb_register_notify(&mon_nb);
- down(&usb_bus_list_lock);
+ mutex_lock(&usb_bus_list_lock);
list_for_each_entry (ubus, &usb_bus_list, bus_list) {
mon_bus_init(mondir, ubus);
}
- up(&usb_bus_list_lock);
+ mutex_unlock(&usb_bus_list_lock);
return 0;
}
usb_unregister_notify(&mon_nb);
usb_mon_deregister();
- down(&mon_lock);
+ mutex_lock(&mon_lock);
while (!list_empty(&mon_buses)) {
p = mon_buses.next;
mbus = list_entry(p, struct mon_bus, bus_link);
mon_dissolve(mbus, mbus->u_bus);
kref_put(&mbus->ref, mon_bus_drop);
}
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
debugfs_remove(mon_dir);
}
#include <linux/list.h>
#include <linux/usb.h>
#include <linux/time.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
#include "usb_mon.h"
wait_queue_head_t wait;
int printf_size;
char *printf_buf;
- struct semaphore printf_lock;
+ struct mutex printf_lock;
char slab_name[SLAB_NAME_SZ];
};
struct mon_reader_text *rp;
int rc;
- down(&mon_lock);
+ mutex_lock(&mon_lock);
mbus = inode->u.generic_ip;
ubus = mbus->u_bus;
memset(rp, 0, sizeof(struct mon_reader_text));
INIT_LIST_HEAD(&rp->e_list);
init_waitqueue_head(&rp->wait);
- init_MUTEX(&rp->printf_lock);
+ mutex_init(&rp->printf_lock);
rp->printf_size = PRINTF_DFL;
rp->printf_buf = kmalloc(rp->printf_size, GFP_KERNEL);
mon_reader_add(mbus, &rp->r);
file->private_data = rp;
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
return 0;
// err_busy:
err_alloc_pr:
kfree(rp);
err_alloc:
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
return rc;
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&rp->wait, &waita);
- down(&rp->printf_lock);
+ mutex_lock(&rp->printf_lock);
cnt = 0;
pbuf = rp->printf_buf;
limit = rp->printf_size;
if (copy_to_user(buf, rp->printf_buf, cnt))
cnt = -EFAULT;
- up(&rp->printf_lock);
+ mutex_unlock(&rp->printf_lock);
kmem_cache_free(rp->e_slab, ep);
return cnt;
}
struct list_head *p;
struct mon_event_text *ep;
- down(&mon_lock);
+ mutex_lock(&mon_lock);
mbus = inode->u.generic_ip;
if (mbus->nreaders <= 0) {
printk(KERN_ERR TAG ": consistency error on close\n");
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
return 0;
}
mon_reader_del(mbus, &rp->r);
kfree(rp->printf_buf);
kfree(rp);
- up(&mon_lock);
+ mutex_unlock(&mon_lock);
return 0;
}
*/
extern char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len);
-extern struct semaphore mon_lock;
+extern struct mutex mon_lock;
extern struct file_operations mon_fops_text;
extern struct file_operations mon_fops_stat;
#include <linux/slab.h>
#include <linux/module.h>
+#include <linux/mutex.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
US_DEBUGP("%s called\n", __FUNCTION__);
/* lock the device pointers and do the reset */
- down(&(us->dev_semaphore));
+ mutex_lock(&(us->dev_mutex));
result = us->transport_reset(us);
- up(&(us->dev_semaphore));
+ mutex_unlock(&us->dev_mutex);
return result < 0 ? FAILED : SUCCESS;
}
US_DEBUGP("%s called\n", __FUNCTION__);
- down(&(us->dev_semaphore));
+ mutex_lock(&(us->dev_mutex));
result = usb_stor_port_reset(us);
- up(&(us->dev_semaphore));
+ mutex_unlock(&us->dev_mutex);
return result < 0 ? FAILED : SUCCESS;
}
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/kthread.h>
+#include <linux/mutex.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
struct us_data *us = usb_get_intfdata(iface);
/* Wait until no command is running */
- down(&us->dev_semaphore);
+ mutex_lock(&us->dev_mutex);
US_DEBUGP("%s\n", __FUNCTION__);
if (us->suspend_resume_hook)
/* When runtime PM is working, we'll set a flag to indicate
* whether we should autoresume when a SCSI request arrives. */
- up(&us->dev_semaphore);
+ mutex_unlock(&us->dev_mutex);
return 0;
}
{
struct us_data *us = usb_get_intfdata(iface);
- down(&us->dev_semaphore);
+ mutex_lock(&us->dev_mutex);
US_DEBUGP("%s\n", __FUNCTION__);
if (us->suspend_resume_hook)
(us->suspend_resume_hook)(us, US_RESUME);
iface->dev.power.power_state.event = PM_EVENT_ON;
- up(&us->dev_semaphore);
+ mutex_unlock(&us->dev_mutex);
return 0;
}
US_DEBUGP("*** thread awakened.\n");
/* lock the device pointers */
- down(&(us->dev_semaphore));
+ mutex_lock(&(us->dev_mutex));
/* if the device has disconnected, we are free to exit */
if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
US_DEBUGP("-- exiting\n");
- up(&(us->dev_semaphore));
+ mutex_unlock(&us->dev_mutex);
break;
}
scsi_unlock(host);
/* unlock the device pointers */
- up(&(us->dev_semaphore));
+ mutex_unlock(&us->dev_mutex);
} /* for (;;) */
scsi_host_put(host);
* The thread will exit when it sees the DISCONNECTING flag. */
/* Wait for the current command to finish, then remove the host */
- down(&us->dev_semaphore);
- up(&us->dev_semaphore);
+ mutex_lock(&us->dev_mutex);
+ mutex_unlock(&us->dev_mutex);
/* queuecommand won't accept any new commands and the control
* thread won't execute a previously-queued command. If there
/* For bulk-only devices, determine the max LUN value */
if (us->protocol == US_PR_BULK &&
!(us->flags & US_FL_SINGLE_LUN)) {
- down(&us->dev_semaphore);
+ mutex_lock(&us->dev_mutex);
us->max_lun = usb_stor_Bulk_max_lun(us);
- up(&us->dev_semaphore);
+ mutex_unlock(&us->dev_mutex);
}
scsi_scan_host(us_to_host(us));
printk(KERN_DEBUG "usb-storage: device scan complete\n");
us = host_to_us(host);
memset(us, 0, sizeof(struct us_data));
- init_MUTEX(&(us->dev_semaphore));
+ mutex_init(&(us->dev_mutex));
init_MUTEX_LOCKED(&(us->sema));
init_completion(&(us->notify));
init_waitqueue_head(&us->delay_wait);
#include <linux/blkdev.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>
+#include <linux/mutex.h>
#include <scsi/scsi_host.h>
struct us_data;
struct us_data {
/* The device we're working with
* It's important to note:
- * (o) you must hold dev_semaphore to change pusb_dev
+ * (o) you must hold dev_mutex to change pusb_dev
*/
- struct semaphore dev_semaphore; /* protect pusb_dev */
+ struct mutex dev_mutex; /* protect pusb_dev */
struct usb_device *pusb_dev; /* this usb_device */
struct usb_interface *pusb_intf; /* this interface */
struct us_unusual_dev *unusual_dev; /* device-filter entry */
git.openpandora.org / pandora-kernel.git / commitdiff