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