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