drivers/media/usb/zr364xx/zr364xx.c

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