drivers/media/video/zr364xx.c

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