PageRenderTime 111ms CodeModel.GetById 18ms app.highlight 82ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/media/video/zr364xx.c

https://gitlab.com/TeamCarbonXtreme/android_kernel_samsung_msm7x27
C | 1723 lines | 1340 code | 250 blank | 133 comment | 189 complexity | 239f4611c7c906060549a62ad5e8fbb6 MD5 | raw file
   1/*
   2 * Zoran 364xx based USB webcam module version 0.73
   3 *
   4 * Allows you to use your USB webcam with V4L2 applications
   5 * This is still in heavy developpement !
   6 *
   7 * Copyright (C) 2004  Antoine Jacquet <royale@zerezo.com>
   8 * http://royale.zerezo.com/zr364xx/
   9 *
  10 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
  11 * V4L2 version inspired by meye.c driver
  12 *
  13 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
  14 *
  15 * This program is free software; you can redistribute it and/or modify
  16 * it under the terms of the GNU General Public License as published by
  17 * the Free Software Foundation; either version 2 of the License, or
  18 * (at your option) any later version.
  19 *
  20 * This program is distributed in the hope that it will be useful,
  21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 * GNU General Public License for more details.
  24 *
  25 * You should have received a copy of the GNU General Public License
  26 * along with this program; if not, write to the Free Software
  27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  28 */
  29
  30
  31#include <linux/module.h>
  32#include <linux/version.h>
  33#include <linux/init.h>
  34#include <linux/usb.h>
  35#include <linux/vmalloc.h>
  36#include <linux/slab.h>
  37#include <linux/proc_fs.h>
  38#include <linux/highmem.h>
  39#include <media/v4l2-common.h>
  40#include <media/v4l2-ioctl.h>
  41#include <media/videobuf-vmalloc.h>
  42
  43
  44/* Version Information */
  45#define DRIVER_VERSION "v0.73"
  46#define ZR364XX_VERSION_CODE KERNEL_VERSION(0, 7, 3)
  47#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
  48#define DRIVER_DESC "Zoran 364xx"
  49
  50
  51/* Camera */
  52#define FRAMES 1
  53#define MAX_FRAME_SIZE 200000
  54#define BUFFER_SIZE 0x1000
  55#define CTRL_TIMEOUT 500
  56
  57#define ZR364XX_DEF_BUFS	4
  58#define ZR364XX_READ_IDLE	0
  59#define ZR364XX_READ_FRAME	1
  60
  61/* Debug macro */
  62#define DBG(fmt, args...) \
  63	do { \
  64		if (debug) { \
  65			printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
  66		} \
  67	} while (0)
  68
  69/*#define FULL_DEBUG 1*/
  70#ifdef FULL_DEBUG
  71#define _DBG DBG
  72#else
  73#define _DBG(fmt, args...)
  74#endif
  75
  76/* Init methods, need to find nicer names for these
  77 * the exact names of the chipsets would be the best if someone finds it */
  78#define METHOD0 0
  79#define METHOD1 1
  80#define METHOD2 2
  81#define METHOD3 3
  82
  83
  84/* Module parameters */
  85static int debug;
  86static int mode;
  87
  88
  89/* Module parameters interface */
  90module_param(debug, int, 0644);
  91MODULE_PARM_DESC(debug, "Debug level");
  92module_param(mode, int, 0644);
  93MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
  94
  95
  96/* Devices supported by this driver
  97 * .driver_info contains the init method used by the camera */
  98static struct usb_device_id device_table[] = {
  99	{USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
 100	{USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
 101	{USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
 102	{USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
 103	{USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
 104	{USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
 105	{USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
 106	{USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
 107	{USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
 108	{USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
 109	{USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
 110	{USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
 111	{USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
 112	{USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
 113	{USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
 114	{USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
 115	{USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
 116	{USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
 117	{USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
 118	{USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
 119	{USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
 120	{}			/* Terminating entry */
 121};
 122
 123MODULE_DEVICE_TABLE(usb, device_table);
 124
 125struct zr364xx_mode {
 126	u32 color;	/* output video color format */
 127	u32 brightness;	/* brightness */
 128};
 129
 130/* frame structure */
 131struct zr364xx_framei {
 132	unsigned long ulState;	/* ulState:ZR364XX_READ_IDLE,
 133					   ZR364XX_READ_FRAME */
 134	void *lpvbits;		/* image data */
 135	unsigned long cur_size;	/* current data copied to it */
 136};
 137
 138/* image buffer structure */
 139struct zr364xx_bufferi {
 140	unsigned long dwFrames;			/* number of frames in buffer */
 141	struct zr364xx_framei frame[FRAMES];	/* array of FRAME structures */
 142};
 143
 144struct zr364xx_dmaqueue {
 145	struct list_head	active;
 146	struct zr364xx_camera	*cam;
 147};
 148
 149struct zr364xx_pipeinfo {
 150	u32 transfer_size;
 151	u8 *transfer_buffer;
 152	u32 state;
 153	void *stream_urb;
 154	void *cam;	/* back pointer to zr364xx_camera struct */
 155	u32 err_count;
 156	u32 idx;
 157};
 158
 159struct zr364xx_fmt {
 160	char *name;
 161	u32 fourcc;
 162	int depth;
 163};
 164
 165/* image formats.  */
 166static const struct zr364xx_fmt formats[] = {
 167	{
 168		.name = "JPG",
 169		.fourcc = V4L2_PIX_FMT_JPEG,
 170		.depth = 24
 171	}
 172};
 173
 174/* Camera stuff */
 175struct zr364xx_camera {
 176	struct usb_device *udev;	/* save off the usb device pointer */
 177	struct usb_interface *interface;/* the interface for this device */
 178	struct video_device *vdev;	/* v4l video device */
 179	int nb;
 180	struct zr364xx_bufferi		buffer;
 181	int skip;
 182	int width;
 183	int height;
 184	int method;
 185	struct mutex lock;
 186	struct mutex open_lock;
 187	int users;
 188
 189	spinlock_t		slock;
 190	struct zr364xx_dmaqueue	vidq;
 191	int			resources;
 192	int			last_frame;
 193	int			cur_frame;
 194	unsigned long		frame_count;
 195	int			b_acquire;
 196	struct zr364xx_pipeinfo	pipe[1];
 197
 198	u8			read_endpoint;
 199
 200	const struct zr364xx_fmt *fmt;
 201	struct videobuf_queue	vb_vidq;
 202	enum v4l2_buf_type	type;
 203	struct zr364xx_mode	mode;
 204};
 205
 206/* buffer for one video frame */
 207struct zr364xx_buffer {
 208	/* common v4l buffer stuff -- must be first */
 209	struct videobuf_buffer vb;
 210	const struct zr364xx_fmt *fmt;
 211};
 212
 213/* function used to send initialisation commands to the camera */
 214static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
 215			    u16 index, unsigned char *cp, u16 size)
 216{
 217	int status;
 218
 219	unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
 220	if (!transfer_buffer) {
 221		dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
 222		return -ENOMEM;
 223	}
 224
 225	memcpy(transfer_buffer, cp, size);
 226
 227	status = usb_control_msg(udev,
 228				 usb_sndctrlpipe(udev, 0),
 229				 request,
 230				 USB_DIR_OUT | USB_TYPE_VENDOR |
 231				 USB_RECIP_DEVICE, value, index,
 232				 transfer_buffer, size, CTRL_TIMEOUT);
 233
 234	kfree(transfer_buffer);
 235
 236	if (status < 0)
 237		dev_err(&udev->dev,
 238			"Failed sending control message, error %d.\n", status);
 239
 240	return status;
 241}
 242
 243
 244/* Control messages sent to the camera to initialize it
 245 * and launch the capture */
 246typedef struct {
 247	unsigned int value;
 248	unsigned int size;
 249	unsigned char *bytes;
 250} message;
 251
 252/* method 0 */
 253static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 254static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
 255static unsigned char m0d3[] = { 0, 0 };
 256static message m0[] = {
 257	{0x1f30, 0, NULL},
 258	{0xd000, 0, NULL},
 259	{0x3370, sizeof(m0d1), m0d1},
 260	{0x2000, 0, NULL},
 261	{0x2f0f, 0, NULL},
 262	{0x2610, sizeof(m0d2), m0d2},
 263	{0xe107, 0, NULL},
 264	{0x2502, 0, NULL},
 265	{0x1f70, 0, NULL},
 266	{0xd000, 0, NULL},
 267	{0x9a01, sizeof(m0d3), m0d3},
 268	{-1, -1, NULL}
 269};
 270
 271/* method 1 */
 272static unsigned char m1d1[] = { 0xff, 0xff };
 273static unsigned char m1d2[] = { 0x00, 0x00 };
 274static message m1[] = {
 275	{0x1f30, 0, NULL},
 276	{0xd000, 0, NULL},
 277	{0xf000, 0, NULL},
 278	{0x2000, 0, NULL},
 279	{0x2f0f, 0, NULL},
 280	{0x2650, 0, NULL},
 281	{0xe107, 0, NULL},
 282	{0x2502, sizeof(m1d1), m1d1},
 283	{0x1f70, 0, NULL},
 284	{0xd000, 0, NULL},
 285	{0xd000, 0, NULL},
 286	{0xd000, 0, NULL},
 287	{0x9a01, sizeof(m1d2), m1d2},
 288	{-1, -1, NULL}
 289};
 290
 291/* method 2 */
 292static unsigned char m2d1[] = { 0xff, 0xff };
 293static message m2[] = {
 294	{0x1f30, 0, NULL},
 295	{0xf000, 0, NULL},
 296	{0x2000, 0, NULL},
 297	{0x2f0f, 0, NULL},
 298	{0x2650, 0, NULL},
 299	{0xe107, 0, NULL},
 300	{0x2502, sizeof(m2d1), m2d1},
 301	{0x1f70, 0, NULL},
 302	{-1, -1, NULL}
 303};
 304
 305/* init table */
 306static message *init[4] = { m0, m1, m2, m2 };
 307
 308
 309/* JPEG static data in header (Huffman table, etc) */
 310static unsigned char header1[] = {
 311	0xFF, 0xD8,
 312	/*
 313	0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
 314	0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
 315	*/
 316	0xFF, 0xDB, 0x00, 0x84
 317};
 318static unsigned char header2[] = {
 319	0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
 320	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 321	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
 322	0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
 323	0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
 324	0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
 325	0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
 326	0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
 327	0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
 328	0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 329	0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
 330	0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
 331	0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
 332	0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
 333	0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
 334	0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
 335	0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
 336	0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
 337	0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
 338	0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
 339	0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 340	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
 341	0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
 342	0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
 343	0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
 344	0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 345	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
 346	0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
 347	0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
 348	0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
 349	0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
 350	0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
 351	0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
 352	0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
 353	0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
 354	0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
 355	0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
 356	0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
 357	0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 358	0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
 359	0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
 360	0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
 361	0x00, 0x3F, 0x00
 362};
 363static unsigned char header3;
 364
 365/* ------------------------------------------------------------------
 366   Videobuf operations
 367   ------------------------------------------------------------------*/
 368
 369static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
 370			unsigned int *size)
 371{
 372	struct zr364xx_camera *cam = vq->priv_data;
 373
 374	*size = cam->width * cam->height * (cam->fmt->depth >> 3);
 375
 376	if (*count == 0)
 377		*count = ZR364XX_DEF_BUFS;
 378
 379	if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
 380		*count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
 381
 382	return 0;
 383}
 384
 385static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
 386{
 387	_DBG("%s\n", __func__);
 388
 389	if (in_interrupt())
 390		BUG();
 391
 392	videobuf_vmalloc_free(&buf->vb);
 393	buf->vb.state = VIDEOBUF_NEEDS_INIT;
 394}
 395
 396static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 397			  enum v4l2_field field)
 398{
 399	struct zr364xx_camera *cam = vq->priv_data;
 400	struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
 401						  vb);
 402	int rc;
 403
 404	DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
 405	    cam->fmt->name : "");
 406	if (cam->fmt == NULL)
 407		return -EINVAL;
 408
 409	buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
 410
 411	if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
 412		DBG("invalid buffer prepare\n");
 413		return -EINVAL;
 414	}
 415
 416	buf->fmt = cam->fmt;
 417	buf->vb.width = cam->width;
 418	buf->vb.height = cam->height;
 419	buf->vb.field = field;
 420
 421	if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
 422		rc = videobuf_iolock(vq, &buf->vb, NULL);
 423		if (rc < 0)
 424			goto fail;
 425	}
 426
 427	buf->vb.state = VIDEOBUF_PREPARED;
 428	return 0;
 429fail:
 430	free_buffer(vq, buf);
 431	return rc;
 432}
 433
 434static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 435{
 436	struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
 437						  vb);
 438	struct zr364xx_camera *cam = vq->priv_data;
 439
 440	_DBG("%s\n", __func__);
 441
 442	buf->vb.state = VIDEOBUF_QUEUED;
 443	list_add_tail(&buf->vb.queue, &cam->vidq.active);
 444}
 445
 446static void buffer_release(struct videobuf_queue *vq,
 447			   struct videobuf_buffer *vb)
 448{
 449	struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
 450						  vb);
 451
 452	_DBG("%s\n", __func__);
 453	free_buffer(vq, buf);
 454}
 455
 456static struct videobuf_queue_ops zr364xx_video_qops = {
 457	.buf_setup = buffer_setup,
 458	.buf_prepare = buffer_prepare,
 459	.buf_queue = buffer_queue,
 460	.buf_release = buffer_release,
 461};
 462
 463/********************/
 464/* V4L2 integration */
 465/********************/
 466static int zr364xx_vidioc_streamon(struct file *file, void *priv,
 467				   enum v4l2_buf_type type);
 468
 469static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
 470			    loff_t * ppos)
 471{
 472	struct zr364xx_camera *cam = video_drvdata(file);
 473
 474	_DBG("%s\n", __func__);
 475
 476	if (!buf)
 477		return -EINVAL;
 478
 479	if (!count)
 480		return -EINVAL;
 481
 482	if (cam->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 483	    zr364xx_vidioc_streamon(file, cam, cam->type) == 0) {
 484		DBG("%s: reading %d bytes at pos %d.\n", __func__, (int) count,
 485		    (int) *ppos);
 486
 487		/* NoMan Sux ! */
 488		return videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
 489					file->f_flags & O_NONBLOCK);
 490	}
 491
 492	return 0;
 493}
 494
 495/* video buffer vmalloc implementation based partly on VIVI driver which is
 496 *          Copyright (c) 2006 by
 497 *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
 498 *                  Ted Walther <ted--a.t--enumera.com>
 499 *                  John Sokol <sokol--a.t--videotechnology.com>
 500 *                  http://v4l.videotechnology.com/
 501 *
 502 */
 503static void zr364xx_fillbuff(struct zr364xx_camera *cam,
 504			     struct zr364xx_buffer *buf,
 505			     int jpgsize)
 506{
 507	int pos = 0;
 508	struct timeval ts;
 509	const char *tmpbuf;
 510	char *vbuf = videobuf_to_vmalloc(&buf->vb);
 511	unsigned long last_frame;
 512	struct zr364xx_framei *frm;
 513
 514	if (!vbuf)
 515		return;
 516
 517	last_frame = cam->last_frame;
 518	if (last_frame != -1) {
 519		frm = &cam->buffer.frame[last_frame];
 520		tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
 521		switch (buf->fmt->fourcc) {
 522		case V4L2_PIX_FMT_JPEG:
 523			buf->vb.size = jpgsize;
 524			memcpy(vbuf, tmpbuf, buf->vb.size);
 525			break;
 526		default:
 527			printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
 528		}
 529		cam->last_frame = -1;
 530	} else {
 531		printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
 532		return;
 533	}
 534	DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
 535		(unsigned long)vbuf, pos);
 536	/* tell v4l buffer was filled */
 537
 538	buf->vb.field_count = cam->frame_count * 2;
 539	do_gettimeofday(&ts);
 540	buf->vb.ts = ts;
 541	buf->vb.state = VIDEOBUF_DONE;
 542}
 543
 544static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
 545{
 546	struct zr364xx_dmaqueue *dma_q = &cam->vidq;
 547	struct zr364xx_buffer *buf;
 548	unsigned long flags = 0;
 549	int rc = 0;
 550
 551	DBG("wakeup: %p\n", &dma_q);
 552	spin_lock_irqsave(&cam->slock, flags);
 553
 554	if (list_empty(&dma_q->active)) {
 555		DBG("No active queue to serve\n");
 556		rc = -1;
 557		goto unlock;
 558	}
 559	buf = list_entry(dma_q->active.next,
 560			 struct zr364xx_buffer, vb.queue);
 561
 562	if (!waitqueue_active(&buf->vb.done)) {
 563		/* no one active */
 564		rc = -1;
 565		goto unlock;
 566	}
 567	list_del(&buf->vb.queue);
 568	do_gettimeofday(&buf->vb.ts);
 569	DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
 570	zr364xx_fillbuff(cam, buf, jpgsize);
 571	wake_up(&buf->vb.done);
 572	DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
 573unlock:
 574	spin_unlock_irqrestore(&cam->slock, flags);
 575	return 0;
 576}
 577
 578/* this function moves the usb stream read pipe data
 579 * into the system buffers.
 580 * returns 0 on success, EAGAIN if more data to process (call this
 581 * function again).
 582 */
 583static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
 584					struct zr364xx_pipeinfo *pipe_info,
 585					struct urb *purb)
 586{
 587	unsigned char *pdest;
 588	unsigned char *psrc;
 589	s32 idx = -1;
 590	struct zr364xx_framei *frm;
 591	int i = 0;
 592	unsigned char *ptr = NULL;
 593
 594	_DBG("buffer to user\n");
 595	idx = cam->cur_frame;
 596	frm = &cam->buffer.frame[idx];
 597
 598	/* swap bytes if camera needs it */
 599	if (cam->method == METHOD0) {
 600		u16 *buf = (u16 *)pipe_info->transfer_buffer;
 601		for (i = 0; i < purb->actual_length/2; i++)
 602			swab16s(buf + i);
 603	}
 604
 605	/* search done.  now find out if should be acquiring */
 606	if (!cam->b_acquire) {
 607		/* we found a frame, but this channel is turned off */
 608		frm->ulState = ZR364XX_READ_IDLE;
 609		return -EINVAL;
 610	}
 611
 612	psrc = (u8 *)pipe_info->transfer_buffer;
 613	ptr = pdest = frm->lpvbits;
 614
 615	if (frm->ulState == ZR364XX_READ_IDLE) {
 616		frm->ulState = ZR364XX_READ_FRAME;
 617		frm->cur_size = 0;
 618
 619		_DBG("jpeg header, ");
 620		memcpy(ptr, header1, sizeof(header1));
 621		ptr += sizeof(header1);
 622		header3 = 0;
 623		memcpy(ptr, &header3, 1);
 624		ptr++;
 625		memcpy(ptr, psrc, 64);
 626		ptr += 64;
 627		header3 = 1;
 628		memcpy(ptr, &header3, 1);
 629		ptr++;
 630		memcpy(ptr, psrc + 64, 64);
 631		ptr += 64;
 632		memcpy(ptr, header2, sizeof(header2));
 633		ptr += sizeof(header2);
 634		memcpy(ptr, psrc + 128,
 635		       purb->actual_length - 128);
 636		ptr += purb->actual_length - 128;
 637		_DBG("header : %d %d %d %d %d %d %d %d %d\n",
 638		    psrc[0], psrc[1], psrc[2],
 639		    psrc[3], psrc[4], psrc[5],
 640		    psrc[6], psrc[7], psrc[8]);
 641		frm->cur_size = ptr - pdest;
 642	} else {
 643		if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
 644			dev_info(&cam->udev->dev,
 645				 "%s: buffer (%d bytes) too small to hold "
 646				 "frame data. Discarding frame data.\n",
 647				 __func__, MAX_FRAME_SIZE);
 648		} else {
 649			pdest += frm->cur_size;
 650			memcpy(pdest, psrc, purb->actual_length);
 651			frm->cur_size += purb->actual_length;
 652		}
 653	}
 654	/*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
 655		purb->actual_length);*/
 656
 657	if (purb->actual_length < pipe_info->transfer_size) {
 658		_DBG("****************Buffer[%d]full*************\n", idx);
 659		cam->last_frame = cam->cur_frame;
 660		cam->cur_frame++;
 661		/* end of system frame ring buffer, start at zero */
 662		if (cam->cur_frame == cam->buffer.dwFrames)
 663			cam->cur_frame = 0;
 664
 665		/* frame ready */
 666		/* go back to find the JPEG EOI marker */
 667		ptr = pdest = frm->lpvbits;
 668		ptr += frm->cur_size - 2;
 669		while (ptr > pdest) {
 670			if (*ptr == 0xFF && *(ptr + 1) == 0xD9
 671			    && *(ptr + 2) == 0xFF)
 672				break;
 673			ptr--;
 674		}
 675		if (ptr == pdest)
 676			DBG("No EOI marker\n");
 677
 678		/* Sometimes there is junk data in the middle of the picture,
 679		 * we want to skip this bogus frames */
 680		while (ptr > pdest) {
 681			if (*ptr == 0xFF && *(ptr + 1) == 0xFF
 682			    && *(ptr + 2) == 0xFF)
 683				break;
 684			ptr--;
 685		}
 686		if (ptr != pdest) {
 687			DBG("Bogus frame ? %d\n", ++(cam->nb));
 688		} else if (cam->b_acquire) {
 689			/* we skip the 2 first frames which are usually buggy */
 690			if (cam->skip)
 691				cam->skip--;
 692			else {
 693				_DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
 694				    frm->cur_size,
 695				    pdest[0], pdest[1], pdest[2], pdest[3],
 696				    pdest[4], pdest[5], pdest[6], pdest[7]);
 697
 698				zr364xx_got_frame(cam, frm->cur_size);
 699			}
 700		}
 701		cam->frame_count++;
 702		frm->ulState = ZR364XX_READ_IDLE;
 703		frm->cur_size = 0;
 704	}
 705	/* done successfully */
 706	return 0;
 707}
 708
 709static int res_get(struct zr364xx_camera *cam)
 710{
 711	/* is it free? */
 712	mutex_lock(&cam->lock);
 713	if (cam->resources) {
 714		/* no, someone else uses it */
 715		mutex_unlock(&cam->lock);
 716		return 0;
 717	}
 718	/* it's free, grab it */
 719	cam->resources = 1;
 720	_DBG("res: get\n");
 721	mutex_unlock(&cam->lock);
 722	return 1;
 723}
 724
 725static inline int res_check(struct zr364xx_camera *cam)
 726{
 727	return cam->resources;
 728}
 729
 730static void res_free(struct zr364xx_camera *cam)
 731{
 732	mutex_lock(&cam->lock);
 733	cam->resources = 0;
 734	mutex_unlock(&cam->lock);
 735	_DBG("res: put\n");
 736}
 737
 738static int zr364xx_vidioc_querycap(struct file *file, void *priv,
 739				   struct v4l2_capability *cap)
 740{
 741	struct zr364xx_camera *cam = video_drvdata(file);
 742
 743	strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
 744	strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
 745	strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
 746		sizeof(cap->bus_info));
 747	cap->version = ZR364XX_VERSION_CODE;
 748	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
 749			    V4L2_CAP_READWRITE |
 750			    V4L2_CAP_STREAMING;
 751
 752	return 0;
 753}
 754
 755static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
 756				     struct v4l2_input *i)
 757{
 758	if (i->index != 0)
 759		return -EINVAL;
 760	strcpy(i->name, DRIVER_DESC " Camera");
 761	i->type = V4L2_INPUT_TYPE_CAMERA;
 762	return 0;
 763}
 764
 765static int zr364xx_vidioc_g_input(struct file *file, void *priv,
 766				  unsigned int *i)
 767{
 768	*i = 0;
 769	return 0;
 770}
 771
 772static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 773				  unsigned int i)
 774{
 775	if (i != 0)
 776		return -EINVAL;
 777	return 0;
 778}
 779
 780static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
 781				    struct v4l2_queryctrl *c)
 782{
 783	struct zr364xx_camera *cam;
 784
 785	if (file == NULL)
 786		return -ENODEV;
 787	cam = video_drvdata(file);
 788
 789	switch (c->id) {
 790	case V4L2_CID_BRIGHTNESS:
 791		c->type = V4L2_CTRL_TYPE_INTEGER;
 792		strcpy(c->name, "Brightness");
 793		c->minimum = 0;
 794		c->maximum = 127;
 795		c->step = 1;
 796		c->default_value = cam->mode.brightness;
 797		c->flags = 0;
 798		break;
 799	default:
 800		return -EINVAL;
 801	}
 802	return 0;
 803}
 804
 805static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
 806				 struct v4l2_control *c)
 807{
 808	struct zr364xx_camera *cam;
 809	int temp;
 810
 811	if (file == NULL)
 812		return -ENODEV;
 813	cam = video_drvdata(file);
 814
 815	switch (c->id) {
 816	case V4L2_CID_BRIGHTNESS:
 817		cam->mode.brightness = c->value;
 818		/* hardware brightness */
 819		mutex_lock(&cam->lock);
 820		send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
 821		temp = (0x60 << 8) + 127 - cam->mode.brightness;
 822		send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
 823		mutex_unlock(&cam->lock);
 824		break;
 825	default:
 826		return -EINVAL;
 827	}
 828
 829	return 0;
 830}
 831
 832static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
 833				 struct v4l2_control *c)
 834{
 835	struct zr364xx_camera *cam;
 836
 837	if (file == NULL)
 838		return -ENODEV;
 839	cam = video_drvdata(file);
 840
 841	switch (c->id) {
 842	case V4L2_CID_BRIGHTNESS:
 843		c->value = cam->mode.brightness;
 844		break;
 845	default:
 846		return -EINVAL;
 847	}
 848	return 0;
 849}
 850
 851static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
 852				       void *priv, struct v4l2_fmtdesc *f)
 853{
 854	if (f->index > 0)
 855		return -EINVAL;
 856	f->flags = V4L2_FMT_FLAG_COMPRESSED;
 857	strcpy(f->description, formats[0].name);
 858	f->pixelformat = formats[0].fourcc;
 859	return 0;
 860}
 861
 862static char *decode_fourcc(__u32 pixelformat, char *buf)
 863{
 864	buf[0] = pixelformat & 0xff;
 865	buf[1] = (pixelformat >> 8) & 0xff;
 866	buf[2] = (pixelformat >> 16) & 0xff;
 867	buf[3] = (pixelformat >> 24) & 0xff;
 868	buf[4] = '\0';
 869	return buf;
 870}
 871
 872static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 873				      struct v4l2_format *f)
 874{
 875	struct zr364xx_camera *cam = video_drvdata(file);
 876	char pixelformat_name[5];
 877
 878	if (cam == NULL)
 879		return -ENODEV;
 880
 881	if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
 882		DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
 883		    decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
 884		return -EINVAL;
 885	}
 886
 887	if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
 888	    !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
 889		f->fmt.pix.width = 320;
 890		f->fmt.pix.height = 240;
 891	}
 892
 893	f->fmt.pix.field = V4L2_FIELD_NONE;
 894	f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 895	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 896	f->fmt.pix.colorspace = 0;
 897	f->fmt.pix.priv = 0;
 898	DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
 899	    decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
 900	    f->fmt.pix.field);
 901	return 0;
 902}
 903
 904static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 905				    struct v4l2_format *f)
 906{
 907	struct zr364xx_camera *cam;
 908
 909	if (file == NULL)
 910		return -ENODEV;
 911	cam = video_drvdata(file);
 912
 913	f->fmt.pix.pixelformat = formats[0].fourcc;
 914	f->fmt.pix.field = V4L2_FIELD_NONE;
 915	f->fmt.pix.width = cam->width;
 916	f->fmt.pix.height = cam->height;
 917	f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 918	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 919	f->fmt.pix.colorspace = 0;
 920	f->fmt.pix.priv = 0;
 921	return 0;
 922}
 923
 924static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 925				    struct v4l2_format *f)
 926{
 927	struct zr364xx_camera *cam = video_drvdata(file);
 928	struct videobuf_queue *q = &cam->vb_vidq;
 929	char pixelformat_name[5];
 930	int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
 931	int i;
 932
 933	if (ret < 0)
 934		return ret;
 935
 936	mutex_lock(&q->vb_lock);
 937
 938	if (videobuf_queue_is_busy(&cam->vb_vidq)) {
 939		DBG("%s queue busy\n", __func__);
 940		ret = -EBUSY;
 941		goto out;
 942	}
 943
 944	if (res_check(cam)) {
 945		DBG("%s can't change format after started\n", __func__);
 946		ret = -EBUSY;
 947		goto out;
 948	}
 949
 950	cam->width = f->fmt.pix.width;
 951	cam->height = f->fmt.pix.height;
 952	dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
 953		 cam->width, cam->height);
 954	f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 955	f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 956	f->fmt.pix.colorspace = 0;
 957	f->fmt.pix.priv = 0;
 958	cam->vb_vidq.field = f->fmt.pix.field;
 959	cam->mode.color = V4L2_PIX_FMT_JPEG;
 960
 961	if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
 962		mode = 1;
 963	else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
 964		mode = 2;
 965	else
 966		mode = 0;
 967
 968	m0d1[0] = mode;
 969	m1[2].value = 0xf000 + mode;
 970	m2[1].value = 0xf000 + mode;
 971
 972	/* special case for METHOD3, the modes are different */
 973	if (cam->method == METHOD3) {
 974		switch (mode) {
 975		case 1:
 976			m2[1].value = 0xf000 + 4;
 977			break;
 978		case 2:
 979			m2[1].value = 0xf000 + 0;
 980			break;
 981		default:
 982			m2[1].value = 0xf000 + 1;
 983			break;
 984		}
 985	}
 986
 987	header2[437] = cam->height / 256;
 988	header2[438] = cam->height % 256;
 989	header2[439] = cam->width / 256;
 990	header2[440] = cam->width % 256;
 991
 992	for (i = 0; init[cam->method][i].size != -1; i++) {
 993		ret =
 994		    send_control_msg(cam->udev, 1, init[cam->method][i].value,
 995				     0, init[cam->method][i].bytes,
 996				     init[cam->method][i].size);
 997		if (ret < 0) {
 998			dev_err(&cam->udev->dev,
 999			   "error during resolution change sequence: %d\n", i);
1000			goto out;
1001		}
1002	}
1003
1004	/* Added some delay here, since opening/closing the camera quickly,
1005	 * like Ekiga does during its startup, can crash the webcam
1006	 */
1007	mdelay(100);
1008	cam->skip = 2;
1009	ret = 0;
1010
1011out:
1012	mutex_unlock(&q->vb_lock);
1013
1014	DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
1015	    decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
1016	    f->fmt.pix.field);
1017	return ret;
1018}
1019
1020static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1021			  struct v4l2_requestbuffers *p)
1022{
1023	int rc;
1024	struct zr364xx_camera *cam = video_drvdata(file);
1025	rc = videobuf_reqbufs(&cam->vb_vidq, p);
1026	return rc;
1027}
1028
1029static int zr364xx_vidioc_querybuf(struct file *file,
1030				void *priv,
1031				struct v4l2_buffer *p)
1032{
1033	int rc;
1034	struct zr364xx_camera *cam = video_drvdata(file);
1035	rc = videobuf_querybuf(&cam->vb_vidq, p);
1036	return rc;
1037}
1038
1039static int zr364xx_vidioc_qbuf(struct file *file,
1040				void *priv,
1041				struct v4l2_buffer *p)
1042{
1043	int rc;
1044	struct zr364xx_camera *cam = video_drvdata(file);
1045	_DBG("%s\n", __func__);
1046	rc = videobuf_qbuf(&cam->vb_vidq, p);
1047	return rc;
1048}
1049
1050static int zr364xx_vidioc_dqbuf(struct file *file,
1051				void *priv,
1052				struct v4l2_buffer *p)
1053{
1054	int rc;
1055	struct zr364xx_camera *cam = video_drvdata(file);
1056	_DBG("%s\n", __func__);
1057	rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1058	return rc;
1059}
1060
1061static void read_pipe_completion(struct urb *purb)
1062{
1063	struct zr364xx_pipeinfo *pipe_info;
1064	struct zr364xx_camera *cam;
1065	int pipe;
1066
1067	pipe_info = purb->context;
1068	_DBG("%s %p, status %d\n", __func__, purb, purb->status);
1069	if (pipe_info == NULL) {
1070		printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1071		return;
1072	}
1073
1074	cam = pipe_info->cam;
1075	if (cam == NULL) {
1076		printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1077		return;
1078	}
1079
1080	/* if shutting down, do not resubmit, exit immediately */
1081	if (purb->status == -ESHUTDOWN) {
1082		DBG("%s, err shutdown\n", __func__);
1083		pipe_info->err_count++;
1084		return;
1085	}
1086
1087	if (pipe_info->state == 0) {
1088		DBG("exiting USB pipe\n");
1089		return;
1090	}
1091
1092	if (purb->actual_length < 0 ||
1093	    purb->actual_length > pipe_info->transfer_size) {
1094		dev_err(&cam->udev->dev, "wrong number of bytes\n");
1095		return;
1096	}
1097
1098	if (purb->status == 0)
1099		zr364xx_read_video_callback(cam, pipe_info, purb);
1100	else {
1101		pipe_info->err_count++;
1102		DBG("%s: failed URB %d\n", __func__, purb->status);
1103	}
1104
1105	pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1106
1107	/* reuse urb */
1108	usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1109			  pipe,
1110			  pipe_info->transfer_buffer,
1111			  pipe_info->transfer_size,
1112			  read_pipe_completion, pipe_info);
1113
1114	if (pipe_info->state != 0) {
1115		purb->status = usb_submit_urb(pipe_info->stream_urb,
1116					      GFP_ATOMIC);
1117
1118		if (purb->status)
1119			dev_err(&cam->udev->dev,
1120				"error submitting urb (error=%i)\n",
1121				purb->status);
1122	} else
1123		DBG("read pipe complete state 0\n");
1124}
1125
1126static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1127{
1128	int pipe;
1129	int retval;
1130	struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1131	pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1132	DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1133
1134	pipe_info->state = 1;
1135	pipe_info->err_count = 0;
1136	pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1137	if (!pipe_info->stream_urb) {
1138		dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1139		return -ENOMEM;
1140	}
1141	/* transfer buffer allocated in board_init */
1142	usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1143			  pipe,
1144			  pipe_info->transfer_buffer,
1145			  pipe_info->transfer_size,
1146			  read_pipe_completion, pipe_info);
1147
1148	DBG("submitting URB %p\n", pipe_info->stream_urb);
1149	retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1150	if (retval) {
1151		printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1152		return retval;
1153	}
1154
1155	return 0;
1156}
1157
1158static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1159{
1160	struct zr364xx_pipeinfo *pipe_info;
1161
1162	if (cam == NULL) {
1163		printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1164		return;
1165	}
1166	DBG("stop read pipe\n");
1167	pipe_info = cam->pipe;
1168	if (pipe_info) {
1169		if (pipe_info->state != 0)
1170			pipe_info->state = 0;
1171
1172		if (pipe_info->stream_urb) {
1173			/* cancel urb */
1174			usb_kill_urb(pipe_info->stream_urb);
1175			usb_free_urb(pipe_info->stream_urb);
1176			pipe_info->stream_urb = NULL;
1177		}
1178	}
1179	return;
1180}
1181
1182/* starts acquisition process */
1183static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1184{
1185	int j;
1186
1187	DBG("start acquire\n");
1188
1189	cam->last_frame = -1;
1190	cam->cur_frame = 0;
1191	for (j = 0; j < FRAMES; j++) {
1192		cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1193		cam->buffer.frame[j].cur_size = 0;
1194	}
1195	cam->b_acquire = 1;
1196	return 0;
1197}
1198
1199static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1200{
1201	cam->b_acquire = 0;
1202	return 0;
1203}
1204
1205static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1206				   enum v4l2_buf_type type)
1207{
1208	struct zr364xx_camera *cam = video_drvdata(file);
1209	int j;
1210	int res;
1211
1212	DBG("%s\n", __func__);
1213
1214	if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1215		dev_err(&cam->udev->dev, "invalid fh type0\n");
1216		return -EINVAL;
1217	}
1218	if (cam->type != type) {
1219		dev_err(&cam->udev->dev, "invalid fh type1\n");
1220		return -EINVAL;
1221	}
1222
1223	if (!res_get(cam)) {
1224		dev_err(&cam->udev->dev, "stream busy\n");
1225		return -EBUSY;
1226	}
1227
1228	cam->last_frame = -1;
1229	cam->cur_frame = 0;
1230	cam->frame_count = 0;
1231	for (j = 0; j < FRAMES; j++) {
1232		cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1233		cam->buffer.frame[j].cur_size = 0;
1234	}
1235	res = videobuf_streamon(&cam->vb_vidq);
1236	if (res == 0) {
1237		zr364xx_start_acquire(cam);
1238	} else {
1239		res_free(cam);
1240	}
1241	return res;
1242}
1243
1244static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1245				    enum v4l2_buf_type type)
1246{
1247	int res;
1248	struct zr364xx_camera *cam = video_drvdata(file);
1249
1250	DBG("%s\n", __func__);
1251	if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1252		dev_err(&cam->udev->dev, "invalid fh type0\n");
1253		return -EINVAL;
1254	}
1255	if (cam->type != type) {
1256		dev_err(&cam->udev->dev, "invalid fh type1\n");
1257		return -EINVAL;
1258	}
1259	zr364xx_stop_acquire(cam);
1260	res = videobuf_streamoff(&cam->vb_vidq);
1261	if (res < 0)
1262		return res;
1263	res_free(cam);
1264	return 0;
1265}
1266
1267
1268/* open the camera */
1269static int zr364xx_open(struct file *file)
1270{
1271	struct video_device *vdev = video_devdata(file);
1272	struct zr364xx_camera *cam = video_drvdata(file);
1273	struct usb_device *udev = cam->udev;
1274	int i, err;
1275
1276	DBG("%s\n", __func__);
1277
1278	mutex_lock(&cam->open_lock);
1279
1280	if (cam->users) {
1281		err = -EBUSY;
1282		goto out;
1283	}
1284
1285	for (i = 0; init[cam->method][i].size != -1; i++) {
1286		err =
1287		    send_control_msg(udev, 1, init[cam->method][i].value,
1288				     0, init[cam->method][i].bytes,
1289				     init[cam->method][i].size);
1290		if (err < 0) {
1291			dev_err(&cam->udev->dev,
1292				"error during open sequence: %d\n", i);
1293			goto out;
1294		}
1295	}
1296
1297	cam->skip = 2;
1298	cam->users++;
1299	file->private_data = vdev;
1300	cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1301	cam->fmt = formats;
1302
1303	videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1304				    NULL, &cam->slock,
1305				    cam->type,
1306				    V4L2_FIELD_NONE,
1307				    sizeof(struct zr364xx_buffer), cam);
1308
1309	/* Added some delay here, since opening/closing the camera quickly,
1310	 * like Ekiga does during its startup, can crash the webcam
1311	 */
1312	mdelay(100);
1313	err = 0;
1314
1315out:
1316	mutex_unlock(&cam->open_lock);
1317	DBG("%s: %d\n", __func__, err);
1318	return err;
1319}
1320
1321static void zr364xx_destroy(struct zr364xx_camera *cam)
1322{
1323	unsigned long i;
1324
1325	if (!cam) {
1326		printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1327		return;
1328	}
1329	mutex_lock(&cam->open_lock);
1330	if (cam->vdev)
1331		video_unregister_device(cam->vdev);
1332	cam->vdev = NULL;
1333
1334	/* stops the read pipe if it is running */
1335	if (cam->b_acquire)
1336		zr364xx_stop_acquire(cam);
1337
1338	zr364xx_stop_readpipe(cam);
1339
1340	/* release sys buffers */
1341	for (i = 0; i < FRAMES; i++) {
1342		if (cam->buffer.frame[i].lpvbits) {
1343			DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1344			vfree(cam->buffer.frame[i].lpvbits);
1345		}
1346		cam->buffer.frame[i].lpvbits = NULL;
1347	}
1348
1349	/* release transfer buffer */
1350	kfree(cam->pipe->transfer_buffer);
1351	cam->pipe->transfer_buffer = NULL;
1352	mutex_unlock(&cam->open_lock);
1353	kfree(cam);
1354	cam = NULL;
1355}
1356
1357/* release the camera */
1358static int zr364xx_release(struct file *file)
1359{
1360	struct zr364xx_camera *cam;
1361	struct usb_device *udev;
1362	int i, err;
1363
1364	DBG("%s\n", __func__);
1365	cam = video_drvdata(file);
1366
1367	if (!cam)
1368		return -ENODEV;
1369
1370	mutex_lock(&cam->open_lock);
1371	udev = cam->udev;
1372
1373	/* turn off stream */
1374	if (res_check(cam)) {
1375		if (cam->b_acquire)
1376			zr364xx_stop_acquire(cam);
1377		videobuf_streamoff(&cam->vb_vidq);
1378		res_free(cam);
1379	}
1380
1381	cam->users--;
1382	file->private_data = NULL;
1383
1384	for (i = 0; i < 2; i++) {
1385		err =
1386		    send_control_msg(udev, 1, init[cam->method][i].value,
1387				     0, init[cam->method][i].bytes,
1388				     init[cam->method][i].size);
1389		if (err < 0) {
1390			dev_err(&udev->dev, "error during release sequence\n");
1391			goto out;
1392		}
1393	}
1394
1395	/* Added some delay here, since opening/closing the camera quickly,
1396	 * like Ekiga does during its startup, can crash the webcam
1397	 */
1398	mdelay(100);
1399	err = 0;
1400
1401out:
1402	mutex_unlock(&cam->open_lock);
1403
1404	return err;
1405}
1406
1407
1408static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1409{
1410	struct zr364xx_camera *cam = video_drvdata(file);
1411	int ret;
1412
1413	if (cam == NULL) {
1414		DBG("%s: cam == NULL\n", __func__);
1415		return -ENODEV;
1416	}
1417	DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1418
1419	ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1420
1421	DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1422		(unsigned long)vma->vm_start,
1423		(unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1424	return ret;
1425}
1426
1427static unsigned int zr364xx_poll(struct file *file,
1428			       struct poll_table_struct *wait)
1429{
1430	struct zr364xx_camera *cam = video_drvdata(file);
1431	struct videobuf_queue *q = &cam->vb_vidq;
1432	_DBG("%s\n", __func__);
1433
1434	if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1435		return POLLERR;
1436
1437	return videobuf_poll_stream(file, q, wait);
1438}
1439
1440static const struct v4l2_file_operations zr364xx_fops = {
1441	.owner = THIS_MODULE,
1442	.open = zr364xx_open,
1443	.release = zr364xx_release,
1444	.read = zr364xx_read,
1445	.mmap = zr364xx_mmap,
1446	.ioctl = video_ioctl2,
1447	.poll = zr364xx_poll,
1448};
1449
1450static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1451	.vidioc_querycap	= zr364xx_vidioc_querycap,
1452	.vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1453	.vidioc_try_fmt_vid_cap	= zr364xx_vidioc_try_fmt_vid_cap,
1454	.vidioc_s_fmt_vid_cap	= zr364xx_vidioc_s_fmt_vid_cap,
1455	.vidioc_g_fmt_vid_cap	= zr364xx_vidioc_g_fmt_vid_cap,
1456	.vidioc_enum_input	= zr364xx_vidioc_enum_input,
1457	.vidioc_g_input		= zr364xx_vidioc_g_input,
1458	.vidioc_s_input		= zr364xx_vidioc_s_input,
1459	.vidioc_streamon	= zr364xx_vidioc_streamon,
1460	.vidioc_streamoff	= zr364xx_vidioc_streamoff,
1461	.vidioc_queryctrl	= zr364xx_vidioc_queryctrl,
1462	.vidioc_g_ctrl		= zr364xx_vidioc_g_ctrl,
1463	.vidioc_s_ctrl		= zr364xx_vidioc_s_ctrl,
1464	.vidioc_reqbufs         = zr364xx_vidioc_reqbufs,
1465	.vidioc_querybuf        = zr364xx_vidioc_querybuf,
1466	.vidioc_qbuf            = zr364xx_vidioc_qbuf,
1467	.vidioc_dqbuf           = zr364xx_vidioc_dqbuf,
1468};
1469
1470static struct video_device zr364xx_template = {
1471	.name = DRIVER_DESC,
1472	.fops = &zr364xx_fops,
1473	.ioctl_ops = &zr364xx_ioctl_ops,
1474	.release = video_device_release,
1475};
1476
1477
1478
1479/*******************/
1480/* USB integration */
1481/*******************/
1482static int zr364xx_board_init(struct zr364xx_camera *cam)
1483{
1484	struct zr364xx_pipeinfo *pipe = cam->pipe;
1485	unsigned long i;
1486
1487	DBG("board init: %p\n", cam);
1488	memset(pipe, 0, sizeof(*pipe));
1489	pipe->cam = cam;
1490	pipe->transfer_size = BUFFER_SIZE;
1491
1492	pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1493					GFP_KERNEL);
1494	if (pipe->transfer_buffer == NULL) {
1495		DBG("out of memory!\n");
1496		return -ENOMEM;
1497	}
1498
1499	cam->b_acquire = 0;
1500	cam->frame_count = 0;
1501
1502	/*** start create system buffers ***/
1503	for (i = 0; i < FRAMES; i++) {
1504		/* always allocate maximum size for system buffers */
1505		cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1506
1507		DBG("valloc %p, idx %lu, pdata %p\n",
1508			&cam->buffer.frame[i], i,
1509			cam->buffer.frame[i].lpvbits);
1510		if (cam->buffer.frame[i].lpvbits == NULL) {
1511			printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1512			       "Using less frames\n");
1513			break;
1514		}
1515	}
1516
1517	if (i == 0) {
1518		printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1519		kfree(cam->pipe->transfer_buffer);
1520		cam->pipe->transfer_buffer = NULL;
1521		return -ENOMEM;
1522	} else
1523		cam->buffer.dwFrames = i;
1524
1525	/* make sure internal states are set */
1526	for (i = 0; i < FRAMES; i++) {
1527		cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1528		cam->buffer.frame[i].cur_size = 0;
1529	}
1530
1531	cam->cur_frame = 0;
1532	cam->last_frame = -1;
1533	/*** end create system buffers ***/
1534
1535	/* start read pipe */
1536	zr364xx_start_readpipe(cam);
1537	DBG(": board initialized\n");
1538	return 0;
1539}
1540
1541static int zr364xx_probe(struct usb_interface *intf,
1542			 const struct usb_device_id *id)
1543{
1544	struct usb_device *udev = interface_to_usbdev(intf);
1545	struct zr364xx_camera *cam = NULL;
1546	struct usb_host_interface *iface_desc;
1547	struct usb_endpoint_descriptor *endpoint;
1548	int err;
1549	int i;
1550
1551	DBG("probing...\n");
1552
1553	dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1554	dev_info(&intf->dev, "model %04x:%04x detected\n",
1555		 le16_to_cpu(udev->descriptor.idVendor),
1556		 le16_to_cpu(udev->descriptor.idProduct));
1557
1558	cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1559	if (cam == NULL) {
1560		dev_err(&udev->dev, "cam: out of memory !\n");
1561		return -ENOMEM;
1562	}
1563	/* save the init method used by this camera */
1564	cam->method = id->driver_info;
1565
1566	cam->vdev = video_device_alloc();
1567	if (cam->vdev == NULL) {
1568		dev_err(&udev->dev, "cam->vdev: out of memory !\n");
1569		kfree(cam);
1570		cam = NULL;
1571		return -ENOMEM;
1572	}
1573	memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
1574	cam->vdev->parent = &intf->dev;
1575	video_set_drvdata(cam->vdev, cam);
1576	if (debug)
1577		cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1578
1579	cam->udev = udev;
1580
1581	switch (mode) {
1582	case 1:
1583		dev_info(&udev->dev, "160x120 mode selected\n");
1584		cam->width = 160;
1585		cam->height = 120;
1586		break;
1587	case 2:
1588		dev_info(&udev->dev, "640x480 mode selected\n");
1589		cam->width = 640;
1590		cam->height = 480;
1591		break;
1592	default:
1593		dev_info(&udev->dev, "320x240 mode selected\n");
1594		cam->width = 320;
1595		cam->height = 240;
1596		break;
1597	}
1598
1599	m0d1[0] = mode;
1600	m1[2].value = 0xf000 + mode;
1601	m2[1].value = 0xf000 + mode;
1602
1603	/* special case for METHOD3, the modes are different */
1604	if (cam->method == METHOD3) {
1605		switch (mode) {
1606		case 1:
1607			m2[1].value = 0xf000 + 4;
1608			break;
1609		case 2:
1610			m2[1].value = 0xf000 + 0;
1611			break;
1612		default:
1613			m2[1].value = 0xf000 + 1;
1614			break;
1615		}
1616	}
1617
1618	header2[437] = cam->height / 256;
1619	header2[438] = cam->height % 256;
1620	header2[439] = cam->width / 256;
1621	header2[440] = cam->width % 256;
1622
1623	cam->users = 0;
1624	cam->nb = 0;
1625	cam->mode.brightness = 64;
1626	mutex_init(&cam->lock);
1627	mutex_init(&cam->open_lock);
1628
1629	DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1630
1631	/* set up the endpoint information  */
1632	iface_desc = intf->cur_altsetting;
1633	DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1634	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1635		endpoint = &iface_desc->endpoint[i].desc;
1636		if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1637			/* we found the bulk in endpoint */
1638			cam->read_endpoint = endpoint->bEndpointAddress;
1639		}
1640	}
1641
1642	if (!cam->read_endpoint) {
1643		dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1644		return -ENOMEM;
1645	}
1646
1647	/* v4l */
1648	INIT_LIST_HEAD(&cam->vidq.active);
1649	cam->vidq.cam = cam;
1650	err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1651	if (err) {
1652		dev_err(&udev->dev, "video_register_device failed\n");
1653		video_device_release(cam->vdev);
1654		kfree(cam);
1655		cam = NULL;
1656		return err;
1657	}
1658
1659	usb_set_intfdata(intf, cam);
1660
1661	/* load zr364xx board specific */
1662	err = zr364xx_board_init(cam);
1663	if (err) {
1664		spin_lock_init(&cam->slock);
1665		return err;
1666	}
1667
1668	spin_lock_init(&cam->slock);
1669
1670	dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1671		 video_device_node_name(cam->vdev));
1672	return 0;
1673}
1674
1675
1676static void zr364xx_disconnect(struct usb_interface *intf)
1677{
1678	struct zr364xx_camera *cam = usb_get_intfdata(intf);
1679	videobuf_mmap_free(&cam->vb_vidq);
1680	usb_set_intfdata(intf, NULL);
1681	dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1682	zr364xx_destroy(cam);
1683}
1684
1685
1686
1687/**********************/
1688/* Module integration */
1689/**********************/
1690
1691static struct usb_driver zr364xx_driver = {
1692	.name = "zr364xx",
1693	.probe = zr364xx_probe,
1694	.disconnect = zr364xx_disconnect,
1695	.id_table = device_table
1696};
1697
1698
1699static int __init zr364xx_init(void)
1700{
1701	int retval;
1702	retval = usb_register(&zr364xx_driver);
1703	if (retval)
1704		printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
1705	else
1706		printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1707	return retval;
1708}
1709
1710
1711static void __exit zr364xx_exit(void)
1712{
1713	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
1714	usb_deregister(&zr364xx_driver);
1715}
1716
1717
1718module_init(zr364xx_init);
1719module_exit(zr364xx_exit);
1720
1721MODULE_AUTHOR(DRIVER_AUTHOR);
1722MODULE_DESCRIPTION(DRIVER_DESC);
1723MODULE_LICENSE("GPL");