V4L/DVB (12859): go7007: semaphore -> mutex conversion

#include <linux/device.h>

#include <linux/i2c.h>

#include <linux/firmware.h>

#include <linux/semaphore.h>

#include <linux/mutex.h>

#include <linux/uaccess.h>

#include <asm/system.h>

#include <linux/videodev2.h>

{

	int ret;

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	ret = go7007_load_encoder(go);

	up(&go->hw_lock);

	mutex_unlock(&go->hw_lock);

	if (ret < 0)

		return -1;

	if (!init_i2c)

	printk(KERN_INFO "go7007: registering new %s\n", go->name);

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	ret = go7007_init_encoder(go);

	up(&go->hw_lock);

	mutex_unlock(&go->hw_lock);

	if (ret < 0)

		return -1;

	go->tuner_type = -1;

	go->channel_number = 0;

	go->name[0] = 0;

	init_MUTEX(&go->hw_lock);

	mutex_init(&go->hw_lock);

	init_waitqueue_head(&go->frame_waitq);

	spin_lock_init(&go->spinlock);

	go->video_dev = NULL;

#include <linux/time.h>

#include <linux/device.h>

#include <linux/i2c.h>

#include <linux/semaphore.h>

#include <linux/mutex.h>

#include <linux/uaccess.h>

#include <asm/system.h>

/* There is only one I2C port on the TW2804 that feeds all four GO7007 VIPs

 * on the Adlink PCI-MPG24, so access is shared between all of them. */

static DECLARE_MUTEX(adlink_mpg24_i2c_lock);

static DEFINE_MUTEX(adlink_mpg24_i2c_lock);

static int go7007_i2c_xfer(struct go7007 *go, u16 addr, int read,

		u16 command, int flags, u8 *data)

			*data, command, addr);

#endif

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	if (go->board_id == GO7007_BOARDID_ADLINK_MPG24) {

		/* Bridge the I2C port on this GO7007 to the shared bus */

		down(&adlink_mpg24_i2c_lock);

		mutex_lock(&adlink_mpg24_i2c_lock);

		go7007_write_addr(go, 0x3c82, 0x0020);

	}

	if (go->board_id == GO7007_BOARDID_ADLINK_MPG24) {

		/* Isolate the I2C port on this GO7007 from the shared bus */

		go7007_write_addr(go, 0x3c82, 0x0000);

		up(&adlink_mpg24_i2c_lock);

		mutex_unlock(&adlink_mpg24_i2c_lock);

	}

	up(&go->hw_lock);

	mutex_unlock(&go->hw_lock);

	return ret;

}

struct go7007_file {

	struct go7007 *go;

	struct semaphore lock;

	struct mutex lock;

	int buf_count;

	struct go7007_buffer *bufs;

};

	int ref_count;

	enum { STATUS_INIT, STATUS_ONLINE, STATUS_SHUTDOWN } status;

	spinlock_t spinlock;

	struct semaphore hw_lock;

	struct mutex hw_lock;

	int streaming;

	int in_use;

	int audio_enabled;

	unsigned short interrupt_data;

};

/* All of these must be called with the hpi_lock semaphore held! */

/* All of these must be called with the hpi_lock mutex held! */

#define go7007_interface_reset(go) \

			((go)->hpi_ops->interface_reset(go))

#define	go7007_write_interrupt(go, x, y) \

struct go7007_usb {

	struct go7007_usb_board *board;

	struct semaphore i2c_lock;

	struct mutex i2c_lock;

	struct usb_device *usbdev;

	struct urb *video_urbs[8];

	struct urb *audio_urbs[8];

	if (go->status == STATUS_SHUTDOWN)

		return -1;

	down(&usb->i2c_lock);

	mutex_lock(&usb->i2c_lock);

	for (i = 0; i < num; ++i) {

		/* The hardware command is "write some bytes then read some

	ret = 0;

i2c_done:

	up(&usb->i2c_lock);

	mutex_unlock(&usb->i2c_lock);

	return ret;

}

	if (board->flags & GO7007_USB_EZUSB_I2C) {

		memcpy(&go->i2c_adapter, &go7007_usb_adap_templ,

				sizeof(go7007_usb_adap_templ));

		init_MUTEX(&usb->i2c_lock);

		mutex_init(&usb->i2c_lock);

		go->i2c_adapter.dev.parent = go->dev;

		i2c_set_adapdata(&go->i2c_adapter, go);

		if (i2c_add_adapter(&go->i2c_adapter) < 0) {

#include <media/v4l2-common.h>

#include <media/v4l2-ioctl.h>

#include <linux/i2c.h>

#include <linux/semaphore.h>

#include <linux/mutex.h>

#include <linux/uaccess.h>

#include <asm/system.h>

	int retval = -EINVAL;

	unsigned long flags;

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	if (go->streaming) {

		go->streaming = 0;

		go7007_stream_stop(go);

		go7007_reset_encoder(go);

		retval = 0;

	}

	up(&go->hw_lock);

	mutex_unlock(&go->hw_lock);

	return 0;

}

		return -ENOMEM;

	++go->ref_count;

	gofh->go = go;

	init_MUTEX(&gofh->lock);

	mutex_init(&gofh->lock);

	gofh->buf_count = 0;

	file->private_data = gofh;

	return 0;

			req->memory != V4L2_MEMORY_MMAP)

		return -EINVAL;

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	for (i = 0; i < gofh->buf_count; ++i)

		if (gofh->bufs[i].mapped > 0)

			goto unlock_and_return;

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	if (go->in_use > 0 && gofh->buf_count == 0) {

		up(&go->hw_lock);

		mutex_unlock(&go->hw_lock);

		goto unlock_and_return;

	}

				     GFP_KERNEL);

		if (!gofh->bufs) {

			up(&go->hw_lock);

			mutex_unlock(&go->hw_lock);

			goto unlock_and_return;

		}

	}

	gofh->buf_count = count;

	up(&go->hw_lock);

	up(&gofh->lock);

	mutex_unlock(&go->hw_lock);

	mutex_unlock(&gofh->lock);

	memset(req, 0, sizeof(*req));

	return 0;

unlock_and_return:

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return retval;

}

	index = buf->index;

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	if (index >= gofh->buf_count)

		goto unlock_and_return;

	buf->memory = V4L2_MEMORY_MMAP;

	buf->m.offset = index * GO7007_BUF_SIZE;

	buf->length = GO7007_BUF_SIZE;

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return 0;

unlock_and_return:

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return retval;

}

			buf->memory != V4L2_MEMORY_MMAP)

		return retval;

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	if (buf->index < 0 || buf->index >= gofh->buf_count)

		goto unlock_and_return;

	spin_lock_irqsave(&go->spinlock, flags);

	list_add_tail(&gobuf->stream, &go->stream);

	spin_unlock_irqrestore(&go->spinlock, flags);

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return 0;

unlock_and_return:

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return retval;

}

	if (buf->memory != V4L2_MEMORY_MMAP)

		return retval;

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	if (list_empty(&go->stream))

		goto unlock_and_return;

	gobuf = list_entry(go->stream.next,

	buf->length = GO7007_BUF_SIZE;

	buf->reserved = gobuf->modet_active;

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return 0;

unlock_and_return:

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return retval;

}

	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)

		return -EINVAL;

	down(&gofh->lock);

	down(&go->hw_lock);

	mutex_lock(&gofh->lock);

	mutex_lock(&go->hw_lock);

	if (!go->streaming) {

		go->streaming = 1;

		else

			retval = 0;

	}

	up(&go->hw_lock);

	up(&gofh->lock);

	mutex_unlock(&go->hw_lock);

	mutex_unlock(&gofh->lock);

	return retval;

}

	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)

		return -EINVAL;

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	go7007_streamoff(go);

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return 0;

}

		return -EINVAL; /* only support VM_SHARED mapping */

	if (vma->vm_end - vma->vm_start != GO7007_BUF_SIZE)

		return -EINVAL; /* must map exactly one full buffer */

	down(&gofh->lock);

	mutex_lock(&gofh->lock);

	index = vma->vm_pgoff / GO7007_BUF_PAGES;

	if (index >= gofh->buf_count) {

		up(&gofh->lock);

		mutex_unlock(&gofh->lock);

		return -EINVAL; /* trying to map beyond requested buffers */

	}

	if (index * GO7007_BUF_PAGES != vma->vm_pgoff) {

		up(&gofh->lock);

		mutex_unlock(&gofh->lock);

		return -EINVAL; /* offset is not aligned on buffer boundary */

	}

	if (gofh->bufs[index].mapped > 0) {

		up(&gofh->lock);

		mutex_unlock(&gofh->lock);

		return -EBUSY;

	}

	gofh->bufs[index].mapped = 1;

	vma->vm_flags |= VM_DONTEXPAND;

	vma->vm_flags &= ~VM_IO;

	vma->vm_private_data = &gofh->bufs[index];

	up(&gofh->lock);

	mutex_unlock(&gofh->lock);

	return 0;

}

{

	unsigned long flags;

	down(&go->hw_lock);

	mutex_lock(&go->hw_lock);

	if (go->streaming) {

		go->streaming = 0;

		go7007_stream_stop(go);

		abort_queued(go);

		spin_unlock_irqrestore(&go->spinlock, flags);

	}

	up(&go->hw_lock);

	mutex_unlock(&go->hw_lock);

	if (go->video_dev)

		video_unregister_device(go->video_dev);

}