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