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