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