/* Video4Linux2 framework for usb video devices (webcams)                  *
 *                                                                         *
 * Copyright (C) 2008 by Hans de Goede <j.w.r.degoede@hhs.nl>              *
 * Buffer management code taken from the Video4Linux2 zc030x driver:       *
 * Copyright (C) 2006-2007 by Luca Risolia <luca.risolia@studio.unibo.it>  *
 * Many ideas and code snippets taken from the gspca driver:               *
 * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr                        *
 *                                                                         *
 * This program is free software; you can redistribute it and/or modify    *
 * it under the terms of the GNU General Public License as published by    *
 * the Free Software Foundation; either version 2 of the License, or       *
 * (at your option) any later version.                                     *
 *                                                                         *
 * This program is distributed in the hope that it will be useful,         *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
 * GNU General Public License for more details.                            *
 *                                                                         *
 * You should have received a copy of the GNU General Public License       *
 * along with this program; if not, write to the Free Software             *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
 ***************************************************************************/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/param.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/compiler.h>
#include <linux/ioctl.h>
#include <linux/poll.h>
#include <linux/stat.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>
#include <linux/page-flags.h>
#include <linux/byteorder/generic.h>
#include <asm/page.h>
#include <asm/uaccess.h>

#include "usbvideo2.h"

/*****************************************************************************/

MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
MODULE_DESCRIPTION("Video4Linux2 framework for usb video devices (webcams)");
MODULE_LICENSE("GPL");

static unsigned short debug = USBVIDEO2_DEBUG_LEVEL;
module_param(debug, ushort, 0644);
MODULE_PARM_DESC(debug,
		 "\n<n> Debugging information level, from 0 to 3:"
		 "\n0 = none (use carefully)"
		 "\n1 = critical errors"
		 "\n2 = significant informations"
		 "\n3 = more verbose messages"
		 "\nLevel 3 is useful for testing only, when only "
		 "one device is used."
		 "\nDefault value is "__MODULE_STRING(USBVIDEO2_DEBUG_LEVEL)"."
		 "\n");

/*****************************************************************************/

static DEFINE_MUTEX(usbvideo2_dev_lock);

/*****************************************************************************/

static u32
usbvideo2_request_buffers(struct usbvideo2_device* cam, u32 count)
{
	void* buff = NULL;
	u32 i;

	if (count > USBVIDEO2_MAX_FRAMES)
		count = USBVIDEO2_MAX_FRAMES;

	cam->nbuffers = count;
	while (cam->nbuffers) {
		if ((buff = vmalloc_32_user(cam->nbuffers *
						PAGE_ALIGN(cam->imagesize))))
			break;
		cam->nbuffers--;
	}

	for (i = 0; i < cam->nbuffers; i++) {
		cam->frame[i].bufmem = buff + i*PAGE_ALIGN(cam->imagesize);
		cam->frame[i].buf.index = i;
		cam->frame[i].buf.m.offset = i*PAGE_ALIGN(cam->imagesize);
		cam->frame[i].buf.length = cam->imagesize;
		cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		cam->frame[i].buf.sequence = 0;
		cam->frame[i].buf.field = V4L2_FIELD_NONE;
		cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
		cam->frame[i].buf.flags = 0;
		cam->frame[i].buf.bytesused = 0;
		cam->frame[i].state = F_UNUSED;
	}

	return cam->nbuffers;
}


static void usbvideo2_release_buffers(struct usbvideo2_device* cam)
{
	if (cam->nbuffers) {
		vfree(cam->frame[0].bufmem);
		cam->nbuffers = 0;
	}
}


static void usbvideo2_empty_framequeues(struct usbvideo2_device* cam)
{
	u32 i;

	INIT_LIST_HEAD(&cam->inqueue);
	INIT_LIST_HEAD(&cam->outqueue);

	for (i = 0; i < USBVIDEO2_MAX_FRAMES; i++) {
		cam->frame[i].state = F_UNUSED;
		cam->frame[i].buf.bytesused = 0;
	}
}


static void usbvideo2_queue_unusedframes(struct usbvideo2_device* cam)
{
	unsigned long lock_flags;
	u32 i;

	for (i = 0; i < cam->nbuffers; i++)
		if (cam->frame[i].state == F_UNUSED) {
			cam->frame[i].state = F_QUEUED;
			spin_lock_irqsave(&cam->queue_lock, lock_flags);
			list_add_tail(&cam->frame[i].frame, &cam->inqueue);
			spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
		}
}

/*****************************************************************************/

static void usbvideo2_urb_complete(struct urb *urb)
{
	struct usbvideo2_device* cam = urb->context;
	struct usbvideo2_frame_t** f;
	int i, ret;

	switch (urb->status) {
		case 0:
			break;
		case -ENOENT:		/* usb_kill_urb() called. */
		case -ECONNRESET:	/* usb_unlink_urb() called. */
		case -ESHUTDOWN:	/* The endpoint is being disabled. */
			return;
		default:
			goto resubmit_urb;
	}

	f = &cam->frame_current;

	if (!(*f)) {
		if (list_empty(&cam->inqueue))
			goto resubmit_urb;

		(*f) = list_entry(cam->inqueue.next, struct usbvideo2_frame_t,
					frame);
	} 

	for (i = 0; i < urb->number_of_packets; i++) {
		unsigned int len, repeat = 0;
		u8 *pos, *sof;

		len = urb->iso_frame_desc[i].actual_length;
		pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;

		if (urb->iso_frame_desc[i].status) {
			DBG(3, "Error in isochronous frame");
			(*f)->state = F_ERROR;
			continue;
		}

		while (len) {
			sof = cam->funcs->find_sof(cam, pos, len, repeat++);

			if (((*f)->state == F_QUEUED ||
					(*f)->state == F_ERROR) && sof) {
start_of_frame:
				(*f)->state = F_GRABBING;
				(*f)->buf.bytesused = 0;
				do_gettimeofday(&(*f)->buf.timestamp);
				cam->funcs->decode_frame_init(cam);
				len -= sof - pos;
				pos = sof;
				continue; /* check for another sof in packet */
			}

			if ((*f)->state == F_GRABBING) {
				unsigned int n;

				/* If sof decode until sof */
				if (sof) {
					n = sof - pos;
					if (n > cam->sof_marker_size)
						n -= cam->sof_marker_size;
					else
						n = 0;
				} else
					n = len;

				if ((ret = cam->funcs->decode_frame_data(cam,
						*f, pos, n))) {
					(*f)->buf.sequence= ++cam->frame_count;
					spin_lock(&cam->queue_lock);
					list_move_tail(&(*f)->frame,
						&cam->outqueue);
					if (!list_empty(&cam->inqueue))
						(*f) = list_entry(
							cam->inqueue.next,
							struct usbvideo2_frame_t,
							frame);
					else
						(*f) = NULL;
					spin_unlock(&cam->queue_lock);
					wake_up_interruptible(&cam->wait_frame);
					DBG(3, "Video frame captured");

					if (!(*f))
						goto resubmit_urb;
				}

				if (sof) {
					if (!ret)
						DBG(3, "Incomplete frame");
					goto start_of_frame;
				}

				len -= n;
				pos += n;
			}
			else
				break;
		}
	}

resubmit_urb:
	urb->dev = cam->usbdev;
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (ret < 0)
		DBG(1, "usb_submit_urb() failed, error: %d", ret);
}

static void usbvideo2_kill_and_free_urbs(struct usbvideo2_device* cam)
{
	int i;
	struct urb* urb;
	struct usb_device *udev = cam->usbdev;
	
	for (i = 0; i < USBVIDEO2_URBS; i++) {
		if (!(urb = cam->urb[i]))
			continue;

		/* Note: usb_kill_urb() is harmless on a not submitted urb */
		usb_kill_urb(urb);

		if (urb->transfer_buffer) {
			usb_buffer_free(udev, urb->transfer_buffer_length,
				urb->transfer_buffer, urb->transfer_dma);
		}
		usb_free_urb(urb);
		cam->urb[i] = NULL;
	}	
}

static void usbvideo2_stop_transfer(struct usbvideo2_device* cam);

static int usbvideo2_start_transfer(struct usbvideo2_device* cam)
{
	struct usb_device *udev = cam->usbdev;
	struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
	struct usb_host_interface* altsetting;
	unsigned int psz;
	struct urb* urb;
	int i, j, alt, err = -ENOSPC;

	if (cam->stream == STREAM_ON)
		return -EBUSY;

	for (alt = intf->num_altsetting - 1; alt && err == -ENOSPC; alt--) {
		altsetting = usb_altnum_to_altsetting(intf, alt);

		/* Find our endpoint to determine the packetsize */
		for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
			if (altsetting->endpoint[i].desc.bEndpointAddress ==
					cam->endpoint_address)
				break;
		}

		/* Endpoint not found or not isoc in this altsetting ?? */
		if (i == altsetting->desc.bNumEndpoints ||
			(altsetting->endpoint[i].desc.bmAttributes &
				USB_ENDPOINT_XFERTYPE_MASK) !=
				USB_ENDPOINT_XFER_ISOC)
			continue;

		psz = le16_to_cpu(altsetting->endpoint[i].desc.wMaxPacketSize);

		/* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
		psz = (psz & 0x07ff) * (1 + ((psz >> 11) & 3));

		err = usb_set_interface(udev, 0, alt);
		if (err) {
			DBG(1, "usb_set_interface() failed");
			return err;
		}

		for (i = 0; i < USBVIDEO2_URBS; i++) {
			urb = usb_alloc_urb(USBVIDEO2_ISO_PACKETS, GFP_KERNEL);
			if (!urb) {
				DBG(1, "usb_alloc_urb() failed");
				usbvideo2_kill_and_free_urbs(cam);
				return -ENOMEM;
			}

			cam->urb[i] = urb;
			/* We alloc psz + 1 bytes per packet, because the
			   decompression code reads bytes at bit offsets and
			   thus can peek up to 7 bits ahead (which will not be
			   used if outside of the actual data, but they will
			   be read)! */
			urb->transfer_buffer = usb_buffer_alloc(udev,
							 (psz + 1) *
							 USBVIDEO2_ISO_PACKETS,
							 GFP_KERNEL,
							 &urb->transfer_dma);
			if (!urb->transfer_buffer) {
				DBG(1, "usb_buffer_alloc() failed");
				usbvideo2_kill_and_free_urbs(cam);
				return -ENOMEM;
			}
			urb->dev = udev;
			urb->context = cam;
			urb->pipe = usb_rcvisocpipe(udev,
							cam->endpoint_address);
			urb->transfer_flags = URB_ISO_ASAP |
						URB_NO_TRANSFER_DMA_MAP;
			urb->number_of_packets = USBVIDEO2_ISO_PACKETS;
			urb->complete = usbvideo2_urb_complete;
			urb->transfer_buffer_length = (psz + 1) *
							USBVIDEO2_ISO_PACKETS;
			urb->interval = 1;
			for (j = 0; j < USBVIDEO2_ISO_PACKETS; j++) {
				urb->iso_frame_desc[j].offset = (psz + 1) * j;
				urb->iso_frame_desc[j].length = psz;
			}
		}
		
		err = cam->funcs->start_transfer(cam);
		if (err) {
			DBG(1, "camera specific start_transfer() failed");
			usbvideo2_kill_and_free_urbs(cam);
			return err;
		}

		cam->stream = STREAM_ON;
		DBG(3, "Stream on");

		for (i = 0; i < USBVIDEO2_URBS; i++) {
			err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
			if (err) {
				DBG(1, "usb_submit_urb() failed, error %d",
					err);
				usbvideo2_stop_transfer(cam);
				break;
			}
		}
	}

	return err;
}


static void usbvideo2_stop_transfer(struct usbvideo2_device* cam)
{
	struct usb_device *udev = cam->usbdev;

	if (cam->stream == STREAM_OFF)
		return;

	if (cam->funcs->stop_transfer_pre_kill_urbs)
		cam->funcs->stop_transfer_pre_kill_urbs(cam);

	usbvideo2_kill_and_free_urbs(cam);

	if (!cam->disconnected) {
		int err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
		if (err)
			DBG(1, "usb_set_interface( 0 ) error: %d\n", err);
	}

	if (cam->funcs->stop_transfer_post_kill_urbs)
		cam->funcs->stop_transfer_post_kill_urbs(cam);

	cam->frame_current = NULL;
	cam->stream = STREAM_OFF;
	DBG(3, "Stream off");
}

/*****************************************************************************/

static void usbvideo2_release_resources(struct kref *kref)
{
	struct usbvideo2_device *cam = container_of(kref,
						struct usbvideo2_device, kref);
	kfree(cam);
}


static int usbvideo2_open(struct inode* inode, struct file* filp)
{
	struct usbvideo2_device* cam;
	int err = 0;

	/* usb driver disconnect may be running and waiting in
	   video_unregister_device() for the videodev_lock (from videodev.c),
	   which we hold when being called! */
	if (!mutex_trylock(&usbvideo2_dev_lock))
		return -EAGAIN;

	cam = video_get_drvdata(video_devdata(filp));

	if (cam->users) {
		err = -EBUSY;
		goto out;
	}

	if (!try_module_get(cam->funcs->owner)) {
		/* Our cam specific module is being removed ! */
		err = -ENODEV;
		goto out;
	}

	kref_get(&cam->kref);

	filp->private_data = cam;
	cam->users++;
	cam->io = IO_NONE;
	cam->nreadbuffers = USBVIDEO2_DEFAULT_READBUFFERS;
	cam->frame_count = 0;
	/* init the frame queues */
	usbvideo2_empty_framequeues(cam);

	err = cam->funcs->open(cam);
	if (err) {
		DBG(1, "Cam specific open() failed");
		module_put(cam->funcs->owner);
		kref_put(&cam->kref, usbvideo2_release_resources);
	}
out:
	mutex_unlock(&usbvideo2_dev_lock);
	return err;
}


static int usbvideo2_release(struct inode* inode, struct file* filp)
{
	struct usbvideo2_device* cam;

	mutex_lock(&usbvideo2_dev_lock);

	cam = filp->private_data;

	usbvideo2_stop_transfer(cam);
	usbvideo2_release_buffers(cam);
	cam->users--;

	module_put(cam->funcs->owner);
	kref_put(&cam->kref, usbvideo2_release_resources);

 	mutex_unlock(&usbvideo2_dev_lock);

	return 0;
}


static ssize_t
usbvideo2_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
{
	struct usbvideo2_device *cam = filp->private_data;
	struct usbvideo2_frame_t *f;
	unsigned long lock_flags;
	long timeout;
	int err = 0;


	if (cam->disconnected) {
		err = -ENODEV;
		goto out;
	}

	if (cam->io == IO_MMAP) {
		DBG(2, "Close and open the device again to choose the read "
			"method");
		err = -EBUSY;
		goto out;
	}

	if (cam->io == IO_NONE) {
		if (!usbvideo2_request_buffers(cam, cam->nreadbuffers)) {
			DBG(1, "read() failed, not enough memory");
			err = -ENOMEM;
			goto out;
		}

		usbvideo2_queue_unusedframes(cam);

		if ((err = usbvideo2_start_transfer(cam)))
			goto out;

		cam->io = IO_READ;
	}

	/* If the inqueue is depleted, chances are there are some rather old
	   frames in the outqueue (for example an application doing one read
	   every minute), so flush it. */
	if (list_empty(&cam->inqueue)) {
		spin_lock_irqsave(&cam->queue_lock, lock_flags);
		list_for_each_entry(f, &cam->outqueue, frame)
			f->state = F_UNUSED;
		INIT_LIST_HEAD(&cam->outqueue);
		spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
		usbvideo2_queue_unusedframes(cam);
	}

	if (!count)
		goto out;

	/* loop until we get a frame or error, the frame we've been waiting
	   for may be stolen from underneed us, as we release the lock while
	   waiting */ 
	while (list_empty(&cam->outqueue)) {
		if (filp->f_flags & O_NONBLOCK) {
			err = -EAGAIN;
			goto out;
		}

		mutex_unlock(&cam->fileop_mutex);
		timeout = wait_event_interruptible_timeout(cam->wait_frame,
				!list_empty(&cam->outqueue) ||
				cam->disconnected,
				msecs_to_jiffies(USBVIDEO2_FRAME_TIMEOUT) );
		if (mutex_lock_interruptible(&cam->fileop_mutex))
			return -ERESTARTSYS;
		
		if (cam->disconnected) {
			err = -ENODEV;
			goto out;
		}
		if (timeout <= 0) {
			err = (timeout < 0)? timeout : -EIO;
			goto out;
		}
	}

	if (cam->funcs->frame_dequeued)
		cam->funcs->frame_dequeued(cam);

	spin_lock_irqsave(&cam->queue_lock, lock_flags);
	f = list_entry(cam->outqueue.next, struct usbvideo2_frame_t, frame);
	list_del(cam->outqueue.next);
	spin_unlock_irqrestore(&cam->queue_lock, lock_flags);

	if (count > f->buf.bytesused)
		count = f->buf.bytesused;

	if (copy_to_user(buf, f->bufmem, count))
		err = -EFAULT;
	else
		*f_pos += count;

	f->state = F_UNUSED;
	usbvideo2_queue_unusedframes(cam);

out:
	mutex_unlock(&cam->fileop_mutex);

	return err ? err : count;
}


static unsigned int usbvideo2_poll(struct file *filp, poll_table *wait)
{
	struct usbvideo2_device* cam = filp->private_data;
	struct usbvideo2_frame_t* f;
	unsigned long lock_flags;
	unsigned int mask = 0;

	if (mutex_lock_interruptible(&cam->fileop_mutex))
		return POLLERR;

	if (cam->disconnected) {
		mask = POLLERR;
		goto out;
	}

	if (cam->io == IO_NONE) {
		if (!usbvideo2_request_buffers(cam, cam->nreadbuffers)) {
			DBG(1, "poll() failed, not enough memory");
			mask = POLLERR;
			goto out;
		}

		usbvideo2_queue_unusedframes(cam);

		if (usbvideo2_start_transfer(cam)) {
			DBG(1, "poll() failed, start transfer failed");
			mask = POLLERR;
			goto out;
		}

		cam->io = IO_READ;
	}

	if (cam->io == IO_READ) {
		/* If the inqueue is depleted, read will flush the outqueue,
		   so do that here, otherwise read will still block. */
		if (list_empty(&cam->inqueue)) {
			spin_lock_irqsave(&cam->queue_lock, lock_flags);
			list_for_each_entry(f, &cam->outqueue, frame)
				f->state = F_UNUSED;
			INIT_LIST_HEAD(&cam->outqueue);
			spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
			usbvideo2_queue_unusedframes(cam);
		}
	}

	poll_wait(filp, &cam->wait_frame, wait);

	if (!list_empty(&cam->outqueue))
		mask |= POLLIN | POLLRDNORM;

out:
	mutex_unlock(&cam->fileop_mutex);
	return mask;
}


static void usbvideo2_vm_open(struct vm_area_struct* vma)
{
	struct usbvideo2_frame_t* f = vma->vm_private_data;
	f->vma_use_count++;
}


static void usbvideo2_vm_close(struct vm_area_struct* vma)
{
	/* NOTE: buffers are not freed here */
	struct usbvideo2_frame_t* f = vma->vm_private_data;
	f->vma_use_count--;
}


static struct vm_operations_struct usbvideo2_vm_ops = {
	.open = usbvideo2_vm_open,
	.close = usbvideo2_vm_close,
};


static int usbvideo2_mmap(struct file* filp, struct vm_area_struct *vma)
{
	struct usbvideo2_device* cam = filp->private_data;
	unsigned long size = vma->vm_end - vma->vm_start,
			  start = vma->vm_start;
	void *pos;
	u32 i;
	int err = 0;

	if (mutex_lock_interruptible(&cam->fileop_mutex))
		return -ERESTARTSYS;

	if (cam->disconnected) {
		err = -ENODEV;
		goto out;
	}

	if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
		err = -EACCES;
		goto out;
	}

	if (cam->io != IO_MMAP ||
			size != PAGE_ALIGN(cam->frame[0].buf.length)) {
		err = -EINVAL;
		goto out;
	}

	for (i = 0; i < cam->nbuffers; i++) {
		if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
			break;
	}
	if (i == cam->nbuffers) {
		err = -EINVAL;
		goto out;
	}

	vma->vm_flags |= VM_IO;
	vma->vm_flags |= VM_RESERVED;

	pos = cam->frame[i].bufmem;
	while (size > 0) { /* size is page-aligned */
		if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
			err = -EAGAIN;
			goto out;
		}
		start += PAGE_SIZE;
		pos += PAGE_SIZE;
		size -= PAGE_SIZE;
	}

	vma->vm_ops = &usbvideo2_vm_ops;
	vma->vm_private_data = &cam->frame[i];
	usbvideo2_vm_open(vma);

out:
	mutex_unlock(&cam->fileop_mutex);

	return err;
}

static int usbvideo2_ioctl(struct inode *inode, struct file *filp,
			  unsigned int cmd, unsigned long arg)
{
	struct usbvideo2_device* cam = filp->private_data;
	int err;

	if (mutex_lock_interruptible(&cam->fileop_mutex))
		return -ERESTARTSYS;

	if (cam->disconnected) {
		err = -ENODEV;
		goto out;
	}

	err = video_ioctl2(inode, filp, cmd, arg);
out:
	mutex_unlock(&cam->fileop_mutex);

	return err;
}

static const struct file_operations usbvideo2_fops = {
	.owner = THIS_MODULE,
	.open =	usbvideo2_open,
	.release = usbvideo2_release,
	.ioctl = usbvideo2_ioctl,
	.compat_ioctl = v4l_compat_ioctl32,
	.read =	usbvideo2_read,
	.poll =	usbvideo2_poll,
	.mmap =	usbvideo2_mmap,
	.llseek = no_llseek,
};

/*****************************************************************************/

static int
usbvideo2_vidioc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
{
	struct usbvideo2_device* cam = fh;

	cap->version = LINUX_VERSION_CODE;
	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
				V4L2_CAP_STREAMING;
	strcpy(cap->driver, cam->driver);
	strlcpy(cap->card, cam->name, sizeof(cap->card));
	if (usb_make_path(cam->usbdev, cap->bus_info, sizeof(cap->bus_info))
			< 0)
		strlcpy(cap->bus_info, cam->usbdev->dev.bus_id,
			sizeof(cap->bus_info));

	return 0;
}


static int
usbvideo2_vidioc_enuminput(struct file *file, void *fh, struct v4l2_input *inp)
{
	if (inp->index)
		return -EINVAL;

	memset(inp, 0, sizeof(*inp));
	strcpy(inp->name, "Camera");
	inp->type = V4L2_INPUT_TYPE_CAMERA;

	return 0;
}


static int
usbvideo2_vidioc_g_input(struct file *file, void *fh, unsigned int *i)
{
	*i = 0;

	return 0;
}


static int
usbvideo2_vidioc_s_input(struct file *file, void *fh, unsigned int i)
{
	if (i != 0)
		return -EINVAL;

	return 0;
}


static int
usbvideo2_vidioc_s_fmt_cap(struct file *file, void *fh, struct v4l2_format *f)
{
	struct usbvideo2_device* cam = fh;
	int err;

	if ((err = cam->funcs->vidioc_try_fmt_cap(file, fh, f)))
		return err;

	if (cam->stream != STREAM_OFF)
		return -EBUSY;

	return cam->funcs->vidioc_s_fmt_cap(file, fh, f);
}


static int
usbvideo2_vidioc_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
{
	u32 i;
	struct usbvideo2_device* cam = fh;

	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
			b->memory != V4L2_MEMORY_MMAP)
		return -EINVAL;

	if (cam->io == IO_READ) {
		DBG(2, "Close and open the device again to choose the "
			"mmap I/O method");
		return -EBUSY;
	}

	if (cam->stream == STREAM_ON)
		return -EBUSY;

	for (i = 0; i < cam->nbuffers; i++)
		if (cam->frame[i].vma_use_count) {
			DBG(2, "VIDIOC_REQBUFS failed. "
				   "Previous buffers are still mapped.");
			return -EBUSY;
		}

	usbvideo2_release_buffers(cam);
	if (b->count)
		b->count = usbvideo2_request_buffers(cam, b->count);

	cam->io = b->count ? IO_MMAP : IO_NONE;

	return 0;
}


static int
usbvideo2_vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
{
	struct usbvideo2_device* cam = fh;

	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
			b->index >= cam->nbuffers || cam->io != IO_MMAP)
		return -EINVAL;

	memcpy(b, &cam->frame[b->index].buf, sizeof(*b));

	if (cam->frame[b->index].vma_use_count)
		b->flags |= V4L2_BUF_FLAG_MAPPED;

	if (cam->frame[b->index].state == F_DONE)
		b->flags |= V4L2_BUF_FLAG_DONE;
	else if (cam->frame[b->index].state != F_UNUSED)
		b->flags |= V4L2_BUF_FLAG_QUEUED;

	return 0;
}


static int
usbvideo2_vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
{
	struct usbvideo2_device* cam = fh;
	unsigned long lock_flags;

	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
			b->index >= cam->nbuffers ||
			cam->io != IO_MMAP ||
			cam->frame[b->index].state != F_UNUSED)
		return -EINVAL;

	cam->frame[b->index].state = F_QUEUED;

	spin_lock_irqsave(&cam->queue_lock, lock_flags);
	list_add_tail(&cam->frame[b->index].frame, &cam->inqueue);
	spin_unlock_irqrestore(&cam->queue_lock, lock_flags);

	return 0;
}


static int
usbvideo2_vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
{
	struct usbvideo2_device* cam = fh;
	struct usbvideo2_frame_t *f;
	unsigned long lock_flags;
	long timeout;

	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP ||
			cam->stream == STREAM_OFF)
		return -EINVAL;

	if (list_empty(&cam->outqueue)) {
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;

		timeout = wait_event_interruptible_timeout(cam->wait_frame,
				!list_empty(&cam->outqueue) ||
				cam->disconnected,
				msecs_to_jiffies(USBVIDEO2_FRAME_TIMEOUT) );
		if (cam->disconnected)
			return -ENODEV;

		if (timeout <= 0)
			return (timeout < 0)? timeout : -EIO;
	}

	if (cam->funcs->frame_dequeued)
		cam->funcs->frame_dequeued(cam);

	spin_lock_irqsave(&cam->queue_lock, lock_flags);
	f = list_entry(cam->outqueue.next, struct usbvideo2_frame_t, frame);
	list_del(cam->outqueue.next);
	spin_unlock_irqrestore(&cam->queue_lock, lock_flags);

	f->state = F_UNUSED;

	memcpy(b, &f->buf, sizeof(*b));
	if (f->vma_use_count)
		b->flags |= V4L2_BUF_FLAG_MAPPED;

	return 0;
}


static int
usbvideo2_vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
{
	struct usbvideo2_device* cam = fh;

	if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
		return -EINVAL;

	return usbvideo2_start_transfer(cam);
}


static int
usbvideo2_vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
{
	struct usbvideo2_device* cam = fh;

	if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
		return -EINVAL;

	usbvideo2_stop_transfer(cam);
	usbvideo2_empty_framequeues(cam);

	return 0;
}


static int
usbvideo2_vidioc_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
{
	struct usbvideo2_device* cam = fh;

	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return -EINVAL;

	a->parm.capture.extendedmode = 0;
	a->parm.capture.readbuffers = cam->nreadbuffers;

	return 0;
}


static int
usbvideo2_vidioc_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
{
	struct usbvideo2_device* cam = fh;

	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return -EINVAL;

	a->parm.capture.extendedmode = 0;

	if (a->parm.capture.readbuffers == 0)
		a->parm.capture.readbuffers = cam->nreadbuffers;

	if (a->parm.capture.readbuffers > USBVIDEO2_MAX_FRAMES)
		a->parm.capture.readbuffers = USBVIDEO2_MAX_FRAMES;

	cam->nreadbuffers = a->parm.capture.readbuffers;

	return 0;
}

/*****************************************************************************/

int
usbvideo2_probe(struct usb_interface* intf, const struct usb_device_id* id,
	const struct usbvideo2_cam_funcs *funcs, int cam_specific_data_size)
{
	struct usb_device *udev = interface_to_usbdev(intf);
	struct usbvideo2_device* cam;
	int err = -ENOMEM;

	if (!(cam = kzalloc(sizeof(struct usbvideo2_device), GFP_KERNEL)))
		return -ENOMEM;

	if (!(cam->control_buffer = kzalloc(4, GFP_KERNEL)))
		goto fail;

	if (!(cam->cam_data = kzalloc(cam_specific_data_size, GFP_KERNEL)))
		goto fail;

	if (!(cam->v4ldev = video_device_alloc())) {
		DBG(1, "video_device_alloc() failed");
		goto fail;
	}

	cam->usbdev = udev;
	cam->funcs = funcs;
	cam->debug = debug;

	if ((err = funcs->probe(cam, id))) {
		DBG(1, "Error cam initialization failed");
		goto fail;
	}

	cam->v4ldev->owner = THIS_MODULE;
	cam->v4ldev->fops = &usbvideo2_fops; 
	cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
	cam->v4ldev->release = video_device_release;
/*	cam->v4ldev->debug = V4L2_DEBUG_IOCTL_ARG; */
	cam->v4ldev->vidioc_querycap = usbvideo2_vidioc_querycap;
	cam->v4ldev->vidioc_enum_input = usbvideo2_vidioc_enuminput;
	cam->v4ldev->vidioc_g_input = usbvideo2_vidioc_g_input;
	cam->v4ldev->vidioc_s_input = usbvideo2_vidioc_s_input;
	cam->v4ldev->vidioc_queryctrl = funcs->vidioc_query_ctrl;
	cam->v4ldev->vidioc_g_ctrl = funcs->vidioc_g_ctrl;
	cam->v4ldev->vidioc_s_ctrl = funcs->vidioc_s_ctrl;
	cam->v4ldev->vidioc_enum_fmt_cap = funcs->vidioc_enum_fmt_cap;
	cam->v4ldev->vidioc_g_fmt_cap = funcs->vidioc_g_fmt_cap;
	cam->v4ldev->vidioc_s_fmt_cap = usbvideo2_vidioc_s_fmt_cap;
	cam->v4ldev->vidioc_try_fmt_cap = funcs->vidioc_try_fmt_cap;
	cam->v4ldev->vidioc_reqbufs = usbvideo2_vidioc_reqbufs;
	cam->v4ldev->vidioc_querybuf = usbvideo2_vidioc_querybuf;
	cam->v4ldev->vidioc_qbuf = usbvideo2_vidioc_qbuf;
	cam->v4ldev->vidioc_dqbuf = usbvideo2_vidioc_dqbuf;
	cam->v4ldev->vidioc_streamon = usbvideo2_vidioc_streamon;
	cam->v4ldev->vidioc_streamoff = usbvideo2_vidioc_streamoff;
	cam->v4ldev->vidioc_g_parm = usbvideo2_vidioc_g_parm;
	cam->v4ldev->vidioc_s_parm = usbvideo2_vidioc_s_parm;
	strlcpy(cam->v4ldev->name, cam->name, sizeof(cam->v4ldev->name));
	video_set_drvdata(cam->v4ldev, cam);

	mutex_init(&cam->fileop_mutex);
	spin_lock_init(&cam->queue_lock);
	init_waitqueue_head(&cam->wait_frame);
	kref_init(&cam->kref);

	usb_get_dev(cam->usbdev);

	err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER, -1);
	if (err) {
		DBG(1, "V4L2 device registration failed");
		usb_put_dev(cam->usbdev);
		goto fail;
	}

	DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor);

	usb_set_intfdata(intf, cam);

	return 0;

fail:
	kfree(cam->control_buffer);
	kfree(cam->cam_data);
	if (cam->v4ldev)
		video_device_release(cam->v4ldev);
	kfree(cam);

	return err;
}
EXPORT_SYMBOL_GPL(usbvideo2_probe);

void usbvideo2_disconnect(struct usb_interface* intf)
{
	struct usbvideo2_device* cam;

	mutex_lock(&usbvideo2_dev_lock);

	cam = usb_get_intfdata(intf);

	DBG(2, "Disconnecting %s...", cam->name);
	cam->disconnected = 1;

	if (cam->users) {
		/* The cam device is still open by some app */
		wake_up_interruptible(&cam->wait_frame);
		/* Take the fileop_mutex:
		   1) Because we touch shared resources protected by it
		   2) So that we know any current users of the usbdev / v4ldev
		      will be done, there won't come any new ones as we've set
		      the disconnected flag */
		mutex_lock(&cam->fileop_mutex);
		usbvideo2_stop_transfer(cam);
		mutex_unlock(&cam->fileop_mutex);
	}

	DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
	video_set_drvdata(cam->v4ldev, NULL);
	video_unregister_device(cam->v4ldev);
	cam->v4ldev = NULL;

	usb_put_dev(cam->usbdev);
	cam->usbdev = NULL;

	kfree(cam->control_buffer);
	kfree(cam->cam_data);
	cam->control_buffer = NULL;
	cam->cam_data = NULL;

	kref_put(&cam->kref, usbvideo2_release_resources);

	mutex_unlock(&usbvideo2_dev_lock);
}
EXPORT_SYMBOL_GPL(usbvideo2_disconnect);