drivers/media/usb/zr364xx/zr364xx.c

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