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