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