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