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 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 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                 frm->ulState = ZR364XX_READ_FRAME;
 604                 frm->cur_size = 0;
 605
 606                 _DBG("jpeg header, ");
 607                 memcpy(ptr, header1, sizeof(header1));
 608                 ptr += sizeof(header1);
 609                 header3 = 0;
 610                 memcpy(ptr, &header3, 1);
 611                 ptr++;
 612                 memcpy(ptr, psrc, 64);
 613                 ptr += 64;
 614                 header3 = 1;
 615                 memcpy(ptr, &header3, 1);
 616                 ptr++;
 617                 memcpy(ptr, psrc + 64, 64);
 618                 ptr += 64;
 619                 memcpy(ptr, header2, sizeof(header2));
 620                 ptr += sizeof(header2);
 621                 memcpy(ptr, psrc + 128,
 622                        purb->actual_length - 128);
 623                 ptr += purb->actual_length - 128;
 624                 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
 625                     psrc[0], psrc[1], psrc[2],
 626                     psrc[3], psrc[4], psrc[5],
 627                     psrc[6], psrc[7], psrc[8]);
 628                 frm->cur_size = ptr - pdest;
 629         } else {
 630                 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
 631                         dev_info(&cam->udev->dev,
 632                                  "%s: buffer (%d bytes) too small to hold frame data. Discarding frame data.\n",
 633                                  __func__, MAX_FRAME_SIZE);
 634                 } else {
 635                         pdest += frm->cur_size;
 636                         memcpy(pdest, psrc, purb->actual_length);
 637                         frm->cur_size += purb->actual_length;
 638                 }
 639         }
 640         /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
 641                 purb->actual_length);*/
 642
 643         if (purb->actual_length < pipe_info->transfer_size) {
 644                 _DBG("****************Buffer[%d]full*************\n", idx);
 645                 cam->last_frame = cam->cur_frame;
 646                 cam->cur_frame++;
 647                 /* end of system frame ring buffer, start at zero */
 648                 if (cam->cur_frame == cam->buffer.dwFrames)
 649                         cam->cur_frame = 0;
 650
 651                 /* frame ready */
 652                 /* go back to find the JPEG EOI marker */
 653                 ptr = pdest = frm->lpvbits;
 654                 ptr += frm->cur_size - 2;
 655                 while (ptr > pdest) {
 656                         if (*ptr == 0xFF && *(ptr + 1) == 0xD9
 657                             && *(ptr + 2) == 0xFF)
 658                                 break;
 659                         ptr--;
 660                 }
 661                 if (ptr == pdest)
 662                         DBG("No EOI marker\n");
 663
 664                 /* Sometimes there is junk data in the middle of the picture,
 665                  * we want to skip this bogus frames */
 666                 while (ptr > pdest) {
 667                         if (*ptr == 0xFF && *(ptr + 1) == 0xFF
 668                             && *(ptr + 2) == 0xFF)
 669                                 break;
 670                         ptr--;
 671                 }
 672                 if (ptr != pdest) {
 673                         DBG("Bogus frame ? %d\n", ++(cam->nb));
 674                 } else if (cam->b_acquire) {
 675                         /* we skip the 2 first frames which are usually buggy */
 676                         if (cam->skip)
 677                                 cam->skip--;
 678                         else {
 679                                 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
 680                                     frm->cur_size,
 681                                     pdest[0], pdest[1], pdest[2], pdest[3],
 682                                     pdest[4], pdest[5], pdest[6], pdest[7]);
 683
 684                                 zr364xx_got_frame(cam, frm->cur_size);
 685                         }
 686                 }
 687                 cam->frame_count++;
 688                 frm->ulState = ZR364XX_READ_IDLE;
 689                 frm->cur_size = 0;
 690         }
 691         /* done successfully */
 692         return 0;
 693 }
 694
 695 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
 696                                    struct v4l2_capability *cap)
 697 {
 698         struct zr364xx_camera *cam = video_drvdata(file);
 699
 700         strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
 701         strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
 702         strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
 703                 sizeof(cap->bus_info));
 704         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
 705                             V4L2_CAP_READWRITE |
 706                             V4L2_CAP_STREAMING;
 707         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 708
 709         return 0;
 710 }
 711
 712 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
 713                                      struct v4l2_input *i)
 714 {
 715         if (i->index != 0)
 716                 return -EINVAL;
 717         strcpy(i->name, DRIVER_DESC " Camera");
 718         i->type = V4L2_INPUT_TYPE_CAMERA;
 719         return 0;
 720 }
 721
 722 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
 723                                   unsigned int *i)
 724 {
 725         *i = 0;
 726         return 0;
 727 }
 728
 729 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 730                                   unsigned int i)
 731 {
 732         if (i != 0)
 733                 return -EINVAL;
 734         return 0;
 735 }
 736
 737 static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
 738 {
 739         struct zr364xx_camera *cam =
 740                 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
 741         int temp;
 742
 743         switch (ctrl->id) {
 744         case V4L2_CID_BRIGHTNESS:
 745                 /* hardware brightness */
 746                 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
 747                 temp = (0x60 << 8) + 127 - ctrl->val;
 748                 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
 749                 break;
 750         default:
 751                 return -EINVAL;
 752         }
 753
 754         return 0;
 755 }
 756
 757 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
 758                                        void *priv, struct v4l2_fmtdesc *f)
 759 {
 760         if (f->index > 0)
 761                 return -EINVAL;
 762         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 763         strcpy(f->description, formats[0].name);
 764         f->pixelformat = formats[0].fourcc;
 765         return 0;
 766 }
 767
 768 static char *decode_fourcc(__u32 pixelformat, char *buf)
 769 {
 770         buf[0] = pixelformat & 0xff;
 771         buf[1] = (pixelformat >> 8) & 0xff;
 772         buf[2] = (pixelformat >> 16) & 0xff;
 773         buf[3] = (pixelformat >> 24) & 0xff;
 774         buf[4] = '\0';
 775         return buf;
 776 }
 777
 778 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 779                                       struct v4l2_format *f)
 780 {
 781         struct zr364xx_camera *cam = video_drvdata(file);
 782         char pixelformat_name[5];
 783
 784         if (cam == NULL)
 785                 return -ENODEV;
 786
 787         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
 788                 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
 789                     decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
 790                 return -EINVAL;
 791         }
 792
 793         if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
 794             !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
 795                 f->fmt.pix.width = 320;
 796                 f->fmt.pix.height = 240;
 797         }
 798
 799         f->fmt.pix.field = V4L2_FIELD_NONE;
 800         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 801         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 802         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 803         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
 804             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
 805             f->fmt.pix.field);
 806         return 0;
 807 }
 808
 809 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 810                                     struct v4l2_format *f)
 811 {
 812         struct zr364xx_camera *cam;
 813
 814         if (file == NULL)
 815                 return -ENODEV;
 816         cam = video_drvdata(file);
 817
 818         f->fmt.pix.pixelformat = formats[0].fourcc;
 819         f->fmt.pix.field = V4L2_FIELD_NONE;
 820         f->fmt.pix.width = cam->width;
 821         f->fmt.pix.height = cam->height;
 822         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 823         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 824         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 825         return 0;
 826 }
 827
 828 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 829                                     struct v4l2_format *f)
 830 {
 831         struct zr364xx_camera *cam = video_drvdata(file);
 832         struct videobuf_queue *q = &cam->vb_vidq;
 833         char pixelformat_name[5];
 834         int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
 835         int i;
 836
 837         if (ret < 0)
 838                 return ret;
 839
 840         mutex_lock(&q->vb_lock);
 841
 842         if (videobuf_queue_is_busy(&cam->vb_vidq)) {
 843                 DBG("%s queue busy\n", __func__);
 844                 ret = -EBUSY;
 845                 goto out;
 846         }
 847
 848         if (cam->owner) {
 849                 DBG("%s can't change format after started\n", __func__);
 850                 ret = -EBUSY;
 851                 goto out;
 852         }
 853
 854         cam->width = f->fmt.pix.width;
 855         cam->height = f->fmt.pix.height;
 856         DBG("%s: %dx%d mode selected\n", __func__,
 857                  cam->width, cam->height);
 858         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 859         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 860         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 861         cam->vb_vidq.field = f->fmt.pix.field;
 862
 863         if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
 864                 mode = 1;
 865         else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
 866                 mode = 2;
 867         else
 868                 mode = 0;
 869
 870         m0d1[0] = mode;
 871         m1[2].value = 0xf000 + mode;
 872         m2[1].value = 0xf000 + mode;
 873
 874         /* special case for METHOD3, the modes are different */
 875         if (cam->method == METHOD3) {
 876                 switch (mode) {
 877                 case 1:
 878                         m2[1].value = 0xf000 + 4;
 879                         break;
 880                 case 2:
 881                         m2[1].value = 0xf000 + 0;
 882                         break;
 883                 default:
 884                         m2[1].value = 0xf000 + 1;
 885                         break;
 886                 }
 887         }
 888
 889         header2[437] = cam->height / 256;
 890         header2[438] = cam->height % 256;
 891         header2[439] = cam->width / 256;
 892         header2[440] = cam->width % 256;
 893
 894         for (i = 0; init[cam->method][i].size != -1; i++) {
 895                 ret =
 896                     send_control_msg(cam->udev, 1, init[cam->method][i].value,
 897                                      0, init[cam->method][i].bytes,
 898                                      init[cam->method][i].size);
 899                 if (ret < 0) {
 900                         dev_err(&cam->udev->dev,
 901                            "error during resolution change sequence: %d\n", i);
 902                         goto out;
 903                 }
 904         }
 905
 906         /* Added some delay here, since opening/closing the camera quickly,
 907          * like Ekiga does during its startup, can crash the webcam
 908          */
 909         mdelay(100);
 910         cam->skip = 2;
 911         ret = 0;
 912
 913 out:
 914         mutex_unlock(&q->vb_lock);
 915
 916         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
 917             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
 918             f->fmt.pix.field);
 919         return ret;
 920 }
 921
 922 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
 923                           struct v4l2_requestbuffers *p)
 924 {
 925         struct zr364xx_camera *cam = video_drvdata(file);
 926
 927         if (cam->owner && cam->owner != priv)
 928                 return -EBUSY;
 929         return videobuf_reqbufs(&cam->vb_vidq, p);
 930 }
 931
 932 static int zr364xx_vidioc_querybuf(struct file *file,
 933                                 void *priv,
 934                                 struct v4l2_buffer *p)
 935 {
 936         int rc;
 937         struct zr364xx_camera *cam = video_drvdata(file);
 938         rc = videobuf_querybuf(&cam->vb_vidq, p);
 939         return rc;
 940 }
 941
 942 static int zr364xx_vidioc_qbuf(struct file *file,
 943                                 void *priv,
 944                                 struct v4l2_buffer *p)
 945 {
 946         int rc;
 947         struct zr364xx_camera *cam = video_drvdata(file);
 948         _DBG("%s\n", __func__);
 949         if (cam->owner && cam->owner != priv)
 950                 return -EBUSY;
 951         rc = videobuf_qbuf(&cam->vb_vidq, p);
 952         return rc;
 953 }
 954
 955 static int zr364xx_vidioc_dqbuf(struct file *file,
 956                                 void *priv,
 957                                 struct v4l2_buffer *p)
 958 {
 959         int rc;
 960         struct zr364xx_camera *cam = video_drvdata(file);
 961         _DBG("%s\n", __func__);
 962         if (cam->owner && cam->owner != priv)
 963                 return -EBUSY;
 964         rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
 965         return rc;
 966 }
 967
 968 static void read_pipe_completion(struct urb *purb)
 969 {
 970         struct zr364xx_pipeinfo *pipe_info;
 971         struct zr364xx_camera *cam;
 972         int pipe;
 973
 974         pipe_info = purb->context;
 975         _DBG("%s %p, status %d\n", __func__, purb, purb->status);
 976         if (pipe_info == NULL) {
 977                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
 978                 return;
 979         }
 980
 981         cam = pipe_info->cam;
 982         if (cam == NULL) {
 983                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
 984                 return;
 985         }
 986
 987         /* if shutting down, do not resubmit, exit immediately */
 988         if (purb->status == -ESHUTDOWN) {
 989                 DBG("%s, err shutdown\n", __func__);
 990                 pipe_info->err_count++;
 991                 return;
 992         }
 993
 994         if (pipe_info->state == 0) {
 995                 DBG("exiting USB pipe\n");
 996                 return;
 997         }
 998
 999         if (purb->actual_length > pipe_info->transfer_size) {
1000                 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1001                 return;
1002         }
1003
1004         if (purb->status == 0)
1005                 zr364xx_read_video_callback(cam, pipe_info, purb);
1006         else {
1007                 pipe_info->err_count++;
1008                 DBG("%s: failed URB %d\n", __func__, purb->status);
1009         }
1010
1011         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1012
1013         /* reuse urb */
1014         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1015                           pipe,
1016                           pipe_info->transfer_buffer,
1017                           pipe_info->transfer_size,
1018                           read_pipe_completion, pipe_info);
1019
1020         if (pipe_info->state != 0) {
1021                 purb->status = usb_submit_urb(pipe_info->stream_urb,
1022                                               GFP_ATOMIC);
1023
1024                 if (purb->status)
1025                         dev_err(&cam->udev->dev,
1026                                 "error submitting urb (error=%i)\n",
1027                                 purb->status);
1028         } else
1029                 DBG("read pipe complete state 0\n");
1030 }
1031
1032 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1033 {
1034         int pipe;
1035         int retval;
1036         struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1037         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1038         DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1039
1040         pipe_info->state = 1;
1041         pipe_info->err_count = 0;
1042         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1043         if (!pipe_info->stream_urb)
1044                 return -ENOMEM;
1045         /* transfer buffer allocated in board_init */
1046         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1047                           pipe,
1048                           pipe_info->transfer_buffer,
1049                           pipe_info->transfer_size,
1050                           read_pipe_completion, pipe_info);
1051
1052         DBG("submitting URB %p\n", pipe_info->stream_urb);
1053         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1054         if (retval) {
1055                 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1056                 return retval;
1057         }
1058
1059         return 0;
1060 }
1061
1062 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1063 {
1064         struct zr364xx_pipeinfo *pipe_info;
1065
1066         if (cam == NULL) {
1067                 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1068                 return;
1069         }
1070         DBG("stop read pipe\n");
1071         pipe_info = cam->pipe;
1072         if (pipe_info) {
1073                 if (pipe_info->state != 0)
1074                         pipe_info->state = 0;
1075
1076                 if (pipe_info->stream_urb) {
1077                         /* cancel urb */
1078                         usb_kill_urb(pipe_info->stream_urb);
1079                         usb_free_urb(pipe_info->stream_urb);
1080                         pipe_info->stream_urb = NULL;
1081                 }
1082         }
1083         return;
1084 }
1085
1086 /* starts acquisition process */
1087 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1088 {
1089         int j;
1090
1091         DBG("start acquire\n");
1092
1093         cam->last_frame = -1;
1094         cam->cur_frame = 0;
1095         for (j = 0; j < FRAMES; j++) {
1096                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1097                 cam->buffer.frame[j].cur_size = 0;
1098         }
1099         cam->b_acquire = 1;
1100         return 0;
1101 }
1102
1103 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1104 {
1105         cam->b_acquire = 0;
1106         return 0;
1107 }
1108
1109 static int zr364xx_prepare(struct zr364xx_camera *cam)
1110 {
1111         int res;
1112         int i, j;
1113
1114         for (i = 0; init[cam->method][i].size != -1; i++) {
1115                 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1116                                      0, init[cam->method][i].bytes,
1117                                      init[cam->method][i].size);
1118                 if (res < 0) {
1119                         dev_err(&cam->udev->dev,
1120                                 "error during open sequence: %d\n", i);
1121                         return res;
1122                 }
1123         }
1124
1125         cam->skip = 2;
1126         cam->last_frame = -1;
1127         cam->cur_frame = 0;
1128         cam->frame_count = 0;
1129         for (j = 0; j < FRAMES; j++) {
1130                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1131                 cam->buffer.frame[j].cur_size = 0;
1132         }
1133         v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1134         return 0;
1135 }
1136
1137 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1138                                    enum v4l2_buf_type type)
1139 {
1140         struct zr364xx_camera *cam = video_drvdata(file);
1141         int res;
1142
1143         DBG("%s\n", __func__);
1144
1145         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1146                 return -EINVAL;
1147
1148         if (cam->owner && cam->owner != priv)
1149                 return -EBUSY;
1150
1151         res = zr364xx_prepare(cam);
1152         if (res)
1153                 return res;
1154         res = videobuf_streamon(&cam->vb_vidq);
1155         if (res == 0) {
1156                 zr364xx_start_acquire(cam);
1157                 cam->owner = file->private_data;
1158         }
1159         return res;
1160 }
1161
1162 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1163                                     enum v4l2_buf_type type)
1164 {
1165         struct zr364xx_camera *cam = video_drvdata(file);
1166
1167         DBG("%s\n", __func__);
1168         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1169                 return -EINVAL;
1170         if (cam->owner && cam->owner != priv)
1171                 return -EBUSY;
1172         zr364xx_stop_acquire(cam);
1173         return videobuf_streamoff(&cam->vb_vidq);
1174 }
1175
1176
1177 /* open the camera */
1178 static int zr364xx_open(struct file *file)
1179 {
1180         struct zr364xx_camera *cam = video_drvdata(file);
1181         int err;
1182
1183         DBG("%s\n", __func__);
1184
1185         if (mutex_lock_interruptible(&cam->lock))
1186                 return -ERESTARTSYS;
1187
1188         err = v4l2_fh_open(file);
1189         if (err)
1190                 goto out;
1191
1192         /* Added some delay here, since opening/closing the camera quickly,
1193          * like Ekiga does during its startup, can crash the webcam
1194          */
1195         mdelay(100);
1196         err = 0;
1197
1198 out:
1199         mutex_unlock(&cam->lock);
1200         DBG("%s: %d\n", __func__, err);
1201         return err;
1202 }
1203
1204 static void zr364xx_release(struct v4l2_device *v4l2_dev)
1205 {
1206         struct zr364xx_camera *cam =
1207                 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
1208         unsigned long i;
1209
1210         v4l2_device_unregister(&cam->v4l2_dev);
1211
1212         videobuf_mmap_free(&cam->vb_vidq);
1213
1214         /* release sys buffers */
1215         for (i = 0; i < FRAMES; i++) {
1216                 if (cam->buffer.frame[i].lpvbits) {
1217                         DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1218                         vfree(cam->buffer.frame[i].lpvbits);
1219                 }
1220                 cam->buffer.frame[i].lpvbits = NULL;
1221         }
1222
1223         v4l2_ctrl_handler_free(&cam->ctrl_handler);
1224         /* release transfer buffer */
1225         kfree(cam->pipe->transfer_buffer);
1226         kfree(cam);
1227 }
1228
1229 /* release the camera */
1230 static int zr364xx_close(struct file *file)
1231 {
1232         struct zr364xx_camera *cam;
1233         struct usb_device *udev;
1234         int i;
1235
1236         DBG("%s\n", __func__);
1237         cam = video_drvdata(file);
1238
1239         mutex_lock(&cam->lock);
1240         udev = cam->udev;
1241
1242         if (file->private_data == cam->owner) {
1243                 /* turn off stream */
1244                 if (cam->b_acquire)
1245                         zr364xx_stop_acquire(cam);
1246                 videobuf_streamoff(&cam->vb_vidq);
1247
1248                 for (i = 0; i < 2; i++) {
1249                         send_control_msg(udev, 1, init[cam->method][i].value,
1250                                         0, init[cam->method][i].bytes,
1251                                         init[cam->method][i].size);
1252                 }
1253                 cam->owner = NULL;
1254         }
1255
1256         /* Added some delay here, since opening/closing the camera quickly,
1257          * like Ekiga does during its startup, can crash the webcam
1258          */
1259         mdelay(100);
1260         mutex_unlock(&cam->lock);
1261         return v4l2_fh_release(file);
1262 }
1263
1264
1265 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1266 {
1267         struct zr364xx_camera *cam = video_drvdata(file);
1268         int ret;
1269
1270         if (cam == NULL) {
1271                 DBG("%s: cam == NULL\n", __func__);
1272                 return -ENODEV;
1273         }
1274         DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1275
1276         ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1277
1278         DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1279                 (unsigned long)vma->vm_start,
1280                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1281         return ret;
1282 }
1283
1284 static unsigned int zr364xx_poll(struct file *file,
1285                                struct poll_table_struct *wait)
1286 {
1287         struct zr364xx_camera *cam = video_drvdata(file);
1288         struct videobuf_queue *q = &cam->vb_vidq;
1289         unsigned res = v4l2_ctrl_poll(file, wait);
1290
1291         _DBG("%s\n", __func__);
1292
1293         return res | videobuf_poll_stream(file, q, wait);
1294 }
1295
1296 static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1297         .s_ctrl = zr364xx_s_ctrl,
1298 };
1299
1300 static const struct v4l2_file_operations zr364xx_fops = {
1301         .owner = THIS_MODULE,
1302         .open = zr364xx_open,
1303         .release = zr364xx_close,
1304         .read = zr364xx_read,
1305         .mmap = zr364xx_mmap,
1306         .unlocked_ioctl = video_ioctl2,
1307         .poll = zr364xx_poll,
1308 };
1309
1310 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1311         .vidioc_querycap        = zr364xx_vidioc_querycap,
1312         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1313         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1314         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
1315         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
1316         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
1317         .vidioc_g_input         = zr364xx_vidioc_g_input,
1318         .vidioc_s_input         = zr364xx_vidioc_s_input,
1319         .vidioc_streamon        = zr364xx_vidioc_streamon,
1320         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
1321         .vidioc_reqbufs         = zr364xx_vidioc_reqbufs,
1322         .vidioc_querybuf        = zr364xx_vidioc_querybuf,
1323         .vidioc_qbuf            = zr364xx_vidioc_qbuf,
1324         .vidioc_dqbuf           = zr364xx_vidioc_dqbuf,
1325         .vidioc_log_status      = v4l2_ctrl_log_status,
1326         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1327         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1328 };
1329
1330 static struct video_device zr364xx_template = {
1331         .name = DRIVER_DESC,
1332         .fops = &zr364xx_fops,
1333         .ioctl_ops = &zr364xx_ioctl_ops,
1334         .release = video_device_release_empty,
1335 };
1336
1337
1338
1339 /*******************/
1340 /* USB integration */
1341 /*******************/
1342 static int zr364xx_board_init(struct zr364xx_camera *cam)
1343 {
1344         struct zr364xx_pipeinfo *pipe = cam->pipe;
1345         unsigned long i;
1346
1347         DBG("board init: %p\n", cam);
1348         memset(pipe, 0, sizeof(*pipe));
1349         pipe->cam = cam;
1350         pipe->transfer_size = BUFFER_SIZE;
1351
1352         pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1353                                         GFP_KERNEL);
1354         if (pipe->transfer_buffer == NULL) {
1355                 DBG("out of memory!\n");
1356                 return -ENOMEM;
1357         }
1358
1359         cam->b_acquire = 0;
1360         cam->frame_count = 0;
1361
1362         /*** start create system buffers ***/
1363         for (i = 0; i < FRAMES; i++) {
1364                 /* always allocate maximum size for system buffers */
1365                 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1366
1367                 DBG("valloc %p, idx %lu, pdata %p\n",
1368                         &cam->buffer.frame[i], i,
1369                         cam->buffer.frame[i].lpvbits);
1370                 if (cam->buffer.frame[i].lpvbits == NULL) {
1371                         printk(KERN_INFO KBUILD_MODNAME ": out of memory. Using less frames\n");
1372                         break;
1373                 }
1374         }
1375
1376         if (i == 0) {
1377                 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1378                 kfree(cam->pipe->transfer_buffer);
1379                 cam->pipe->transfer_buffer = NULL;
1380                 return -ENOMEM;
1381         } else
1382                 cam->buffer.dwFrames = i;
1383
1384         /* make sure internal states are set */
1385         for (i = 0; i < FRAMES; i++) {
1386                 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1387                 cam->buffer.frame[i].cur_size = 0;
1388         }
1389
1390         cam->cur_frame = 0;
1391         cam->last_frame = -1;
1392         /*** end create system buffers ***/
1393
1394         /* start read pipe */
1395         zr364xx_start_readpipe(cam);
1396         DBG(": board initialized\n");
1397         return 0;
1398 }
1399
1400 static int zr364xx_probe(struct usb_interface *intf,
1401                          const struct usb_device_id *id)
1402 {
1403         struct usb_device *udev = interface_to_usbdev(intf);
1404         struct zr364xx_camera *cam = NULL;
1405         struct usb_host_interface *iface_desc;
1406         struct usb_endpoint_descriptor *endpoint;
1407         struct v4l2_ctrl_handler *hdl;
1408         int err;
1409         int i;
1410
1411         DBG("probing...\n");
1412
1413         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1414         dev_info(&intf->dev, "model %04x:%04x detected\n",
1415                  le16_to_cpu(udev->descriptor.idVendor),
1416                  le16_to_cpu(udev->descriptor.idProduct));
1417
1418         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1419         if (cam == NULL) {
1420                 dev_err(&udev->dev, "cam: out of memory !\n");
1421                 return -ENOMEM;
1422         }
1423
1424         cam->v4l2_dev.release = zr364xx_release;
1425         err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1426         if (err < 0) {
1427                 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1428                 kfree(cam);
1429                 return err;
1430         }
1431         hdl = &cam->ctrl_handler;
1432         v4l2_ctrl_handler_init(hdl, 1);
1433         v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1434                           V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1435         if (hdl->error) {
1436                 err = hdl->error;
1437                 dev_err(&udev->dev, "couldn't register control\n");
1438                 goto fail;
1439         }
1440         /* save the init method used by this camera */
1441         cam->method = id->driver_info;
1442         mutex_init(&cam->lock);
1443         cam->vdev = zr364xx_template;
1444         cam->vdev.lock = &cam->lock;
1445         cam->vdev.v4l2_dev = &cam->v4l2_dev;
1446         cam->vdev.ctrl_handler = &cam->ctrl_handler;
1447         video_set_drvdata(&cam->vdev, cam);
1448
1449         cam->udev = udev;
1450
1451         switch (mode) {
1452         case 1:
1453                 dev_info(&udev->dev, "160x120 mode selected\n");
1454                 cam->width = 160;
1455                 cam->height = 120;
1456                 break;
1457         case 2:
1458                 dev_info(&udev->dev, "640x480 mode selected\n");
1459                 cam->width = 640;
1460                 cam->height = 480;
1461                 break;
1462         default:
1463                 dev_info(&udev->dev, "320x240 mode selected\n");
1464                 cam->width = 320;
1465                 cam->height = 240;
1466                 break;
1467         }
1468
1469         m0d1[0] = mode;
1470         m1[2].value = 0xf000 + mode;
1471         m2[1].value = 0xf000 + mode;
1472
1473         /* special case for METHOD3, the modes are different */
1474         if (cam->method == METHOD3) {
1475                 switch (mode) {
1476                 case 1:
1477                         m2[1].value = 0xf000 + 4;
1478                         break;
1479                 case 2:
1480                         m2[1].value = 0xf000 + 0;
1481                         break;
1482                 default:
1483                         m2[1].value = 0xf000 + 1;
1484                         break;
1485                 }
1486         }
1487
1488         header2[437] = cam->height / 256;
1489         header2[438] = cam->height % 256;
1490         header2[439] = cam->width / 256;
1491         header2[440] = cam->width % 256;
1492
1493         cam->nb = 0;
1494
1495         DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1496
1497         /* set up the endpoint information  */
1498         iface_desc = intf->cur_altsetting;
1499         DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1500         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1501                 endpoint = &iface_desc->endpoint[i].desc;
1502                 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1503                         /* we found the bulk in endpoint */
1504                         cam->read_endpoint = endpoint->bEndpointAddress;
1505                 }
1506         }
1507
1508         if (!cam->read_endpoint) {
1509                 err = -ENOMEM;
1510                 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1511                 goto fail;
1512         }
1513
1514         /* v4l */
1515         INIT_LIST_HEAD(&cam->vidq.active);
1516         cam->vidq.cam = cam;
1517
1518         usb_set_intfdata(intf, cam);
1519
1520         /* load zr364xx board specific */
1521         err = zr364xx_board_init(cam);
1522         if (!err)
1523                 err = v4l2_ctrl_handler_setup(hdl);
1524         if (err)
1525                 goto fail;
1526
1527         spin_lock_init(&cam->slock);
1528
1529         cam->fmt = formats;
1530
1531         videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1532                                     NULL, &cam->slock,
1533                                     V4L2_BUF_TYPE_VIDEO_CAPTURE,
1534                                     V4L2_FIELD_NONE,
1535                                     sizeof(struct zr364xx_buffer), cam, &cam->lock);
1536
1537         err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1538         if (err) {
1539                 dev_err(&udev->dev, "video_register_device failed\n");
1540                 goto fail;
1541         }
1542
1543         dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1544                  video_device_node_name(&cam->vdev));
1545         return 0;
1546
1547 fail:
1548         v4l2_ctrl_handler_free(hdl);
1549         v4l2_device_unregister(&cam->v4l2_dev);
1550         kfree(cam);
1551         return err;
1552 }
1553
1554
1555 static void zr364xx_disconnect(struct usb_interface *intf)
1556 {
1557         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1558
1559         mutex_lock(&cam->lock);
1560         usb_set_intfdata(intf, NULL);
1561         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1562         video_unregister_device(&cam->vdev);
1563         v4l2_device_disconnect(&cam->v4l2_dev);
1564
1565         /* stops the read pipe if it is running */
1566         if (cam->b_acquire)
1567                 zr364xx_stop_acquire(cam);
1568
1569         zr364xx_stop_readpipe(cam);
1570         mutex_unlock(&cam->lock);
1571         v4l2_device_put(&cam->v4l2_dev);
1572 }
1573
1574
1575 #ifdef CONFIG_PM
1576 static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1577 {
1578         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1579
1580         cam->was_streaming = cam->b_acquire;
1581         if (!cam->was_streaming)
1582                 return 0;
1583         zr364xx_stop_acquire(cam);
1584         zr364xx_stop_readpipe(cam);
1585         return 0;
1586 }
1587
1588 static int zr364xx_resume(struct usb_interface *intf)
1589 {
1590         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1591         int res;
1592
1593         if (!cam->was_streaming)
1594                 return 0;
1595
1596         zr364xx_start_readpipe(cam);
1597         res = zr364xx_prepare(cam);
1598         if (!res)
1599                 zr364xx_start_acquire(cam);
1600         return res;
1601 }
1602 #endif
1603
1604 /**********************/
1605 /* Module integration */
1606 /**********************/
1607
1608 static struct usb_driver zr364xx_driver = {
1609         .name = "zr364xx",
1610         .probe = zr364xx_probe,
1611         .disconnect = zr364xx_disconnect,
1612 #ifdef CONFIG_PM
1613         .suspend = zr364xx_suspend,
1614         .resume = zr364xx_resume,
1615         .reset_resume = zr364xx_resume,
1616 #endif
1617         .id_table = device_table
1618 };
1619
1620 module_usb_driver(zr364xx_driver);
1621
1622 MODULE_AUTHOR(DRIVER_AUTHOR);
1623 MODULE_DESCRIPTION(DRIVER_DESC);
1624 MODULE_LICENSE("GPL");
1625 MODULE_VERSION(DRIVER_VERSION);