drivers/media/video/zr364xx.c

   1 /*
   2  * Zoran 364xx based USB webcam module version 0.73
   3  *
   4  * Allows you to use your USB webcam with V4L2 applications
   5  * This is still in heavy developpement !
   6  *
   7  * Copyright (C) 2004  Antoine Jacquet <royale@zerezo.com>
   8  * http://royale.zerezo.com/zr364xx/
   9  *
  10  * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
  11  * V4L2 version inspired by meye.c driver
  12  *
  13  * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  28  */
  29
  30
  31 #include <linux/module.h>
  32 #include <linux/version.h>
  33 #include <linux/init.h>
  34 #include <linux/usb.h>
  35 #include <linux/vmalloc.h>
  36 #include <linux/slab.h>
  37 #include <linux/proc_fs.h>
  38 #include <linux/highmem.h>
  39 #include <media/v4l2-common.h>
  40 #include <media/v4l2-ioctl.h>
  41 #include <media/videobuf-vmalloc.h>
  42
  43
  44 /* Version Information */
  45 #define DRIVER_VERSION "v0.73"
  46 #define ZR364XX_VERSION_CODE KERNEL_VERSION(0, 7, 3)
  47 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
  48 #define DRIVER_DESC "Zoran 364xx"
  49
  50
  51 /* Camera */
  52 #define FRAMES 1
  53 #define MAX_FRAME_SIZE 200000
  54 #define BUFFER_SIZE 0x1000
  55 #define CTRL_TIMEOUT 500
  56
  57 #define ZR364XX_DEF_BUFS        4
  58 #define ZR364XX_READ_IDLE       0
  59 #define ZR364XX_READ_FRAME      1
  60
  61 /* Debug macro */
  62 #define DBG(fmt, args...) \
  63         do { \
  64                 if (debug) { \
  65                         printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
  66                 } \
  67         } while (0)
  68
  69 /*#define FULL_DEBUG 1*/
  70 #ifdef FULL_DEBUG
  71 #define _DBG DBG
  72 #else
  73 #define _DBG(fmt, args...)
  74 #endif
  75
  76 /* Init methods, need to find nicer names for these
  77  * the exact names of the chipsets would be the best if someone finds it */
  78 #define METHOD0 0
  79 #define METHOD1 1
  80 #define METHOD2 2
  81
  82
  83 /* Module parameters */
  84 static int debug;
  85 static int mode;
  86
  87
  88 /* Module parameters interface */
  89 module_param(debug, int, 0644);
  90 MODULE_PARM_DESC(debug, "Debug level");
  91 module_param(mode, int, 0644);
  92 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
  93
  94
  95 /* Devices supported by this driver
  96  * .driver_info contains the init method used by the camera */
  97 static struct usb_device_id device_table[] = {
  98         {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
  99         {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
 100         {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
 101         {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
 102         {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
 103         {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
 104         {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
 105         {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
 106         {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
 107         {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
 108         {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
 109         {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
 110         {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
 111         {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
 112         {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
 113         {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
 114         {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
 115         {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
 116         {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
 117         {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD2 },
 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[3] = { m0, m1, 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         while (*size * (*count) > ZR364XX_DEF_BUFS * 1024 * 1024)
 378                 (*count)--;
 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 0;
 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->version = ZR364XX_VERSION_CODE;
 746         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
 747                             V4L2_CAP_READWRITE |
 748                             V4L2_CAP_STREAMING;
 749
 750         return 0;
 751 }
 752
 753 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
 754                                      struct v4l2_input *i)
 755 {
 756         if (i->index != 0)
 757                 return -EINVAL;
 758         strcpy(i->name, DRIVER_DESC " Camera");
 759         i->type = V4L2_INPUT_TYPE_CAMERA;
 760         return 0;
 761 }
 762
 763 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
 764                                   unsigned int *i)
 765 {
 766         *i = 0;
 767         return 0;
 768 }
 769
 770 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 771                                   unsigned int i)
 772 {
 773         if (i != 0)
 774                 return -EINVAL;
 775         return 0;
 776 }
 777
 778 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
 779                                     struct v4l2_queryctrl *c)
 780 {
 781         struct zr364xx_camera *cam;
 782
 783         if (file == NULL)
 784                 return -ENODEV;
 785         cam = video_drvdata(file);
 786
 787         switch (c->id) {
 788         case V4L2_CID_BRIGHTNESS:
 789                 c->type = V4L2_CTRL_TYPE_INTEGER;
 790                 strcpy(c->name, "Brightness");
 791                 c->minimum = 0;
 792                 c->maximum = 127;
 793                 c->step = 1;
 794                 c->default_value = cam->mode.brightness;
 795                 c->flags = 0;
 796                 break;
 797         default:
 798                 return -EINVAL;
 799         }
 800         return 0;
 801 }
 802
 803 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
 804                                  struct v4l2_control *c)
 805 {
 806         struct zr364xx_camera *cam;
 807         int temp;
 808
 809         if (file == NULL)
 810                 return -ENODEV;
 811         cam = video_drvdata(file);
 812
 813         switch (c->id) {
 814         case V4L2_CID_BRIGHTNESS:
 815                 cam->mode.brightness = c->value;
 816                 /* hardware brightness */
 817                 mutex_lock(&cam->lock);
 818                 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
 819                 temp = (0x60 << 8) + 127 - cam->mode.brightness;
 820                 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
 821                 mutex_unlock(&cam->lock);
 822                 break;
 823         default:
 824                 return -EINVAL;
 825         }
 826
 827         return 0;
 828 }
 829
 830 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
 831                                  struct v4l2_control *c)
 832 {
 833         struct zr364xx_camera *cam;
 834
 835         if (file == NULL)
 836                 return -ENODEV;
 837         cam = video_drvdata(file);
 838
 839         switch (c->id) {
 840         case V4L2_CID_BRIGHTNESS:
 841                 c->value = cam->mode.brightness;
 842                 break;
 843         default:
 844                 return -EINVAL;
 845         }
 846         return 0;
 847 }
 848
 849 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
 850                                        void *priv, struct v4l2_fmtdesc *f)
 851 {
 852         if (f->index > 0)
 853                 return -EINVAL;
 854         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 855         strcpy(f->description, formats[0].name);
 856         f->pixelformat = formats[0].fourcc;
 857         return 0;
 858 }
 859
 860 static char *decode_fourcc(__u32 pixelformat, char *buf)
 861 {
 862         buf[0] = pixelformat & 0xff;
 863         buf[1] = (pixelformat >> 8) & 0xff;
 864         buf[2] = (pixelformat >> 16) & 0xff;
 865         buf[3] = (pixelformat >> 24) & 0xff;
 866         buf[4] = '\0';
 867         return buf;
 868 }
 869
 870 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 871                                       struct v4l2_format *f)
 872 {
 873         struct zr364xx_camera *cam = video_drvdata(file);
 874         char pixelformat_name[5];
 875
 876         if (cam == NULL)
 877                 return -ENODEV;
 878
 879         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
 880                 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
 881                     decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
 882                 return -EINVAL;
 883         }
 884
 885         if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
 886             !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
 887                 f->fmt.pix.width = 320;
 888                 f->fmt.pix.height = 240;
 889         }
 890
 891         f->fmt.pix.field = V4L2_FIELD_NONE;
 892         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 893         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 894         f->fmt.pix.colorspace = 0;
 895         f->fmt.pix.priv = 0;
 896         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
 897             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
 898             f->fmt.pix.field);
 899         return 0;
 900 }
 901
 902 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 903                                     struct v4l2_format *f)
 904 {
 905         struct zr364xx_camera *cam;
 906
 907         if (file == NULL)
 908                 return -ENODEV;
 909         cam = video_drvdata(file);
 910
 911         f->fmt.pix.pixelformat = formats[0].fourcc;
 912         f->fmt.pix.field = V4L2_FIELD_NONE;
 913         f->fmt.pix.width = cam->width;
 914         f->fmt.pix.height = cam->height;
 915         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 916         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 917         f->fmt.pix.colorspace = 0;
 918         f->fmt.pix.priv = 0;
 919         return 0;
 920 }
 921
 922 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 923                                     struct v4l2_format *f)
 924 {
 925         struct zr364xx_camera *cam = video_drvdata(file);
 926         struct videobuf_queue *q = &cam->vb_vidq;
 927         char pixelformat_name[5];
 928         int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
 929         int i;
 930
 931         if (ret < 0)
 932                 return ret;
 933
 934         mutex_lock(&q->vb_lock);
 935
 936         if (videobuf_queue_is_busy(&cam->vb_vidq)) {
 937                 DBG("%s queue busy\n", __func__);
 938                 ret = -EBUSY;
 939                 goto out;
 940         }
 941
 942         if (res_check(cam)) {
 943                 DBG("%s can't change format after started\n", __func__);
 944                 ret = -EBUSY;
 945                 goto out;
 946         }
 947
 948         cam->width = f->fmt.pix.width;
 949         cam->height = f->fmt.pix.height;
 950         dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
 951                  cam->width, cam->height);
 952         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 953         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 954         f->fmt.pix.colorspace = 0;
 955         f->fmt.pix.priv = 0;
 956         cam->vb_vidq.field = f->fmt.pix.field;
 957         cam->mode.color = V4L2_PIX_FMT_JPEG;
 958
 959         if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
 960                 mode = 1;
 961         else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
 962                 mode = 2;
 963         else
 964                 mode = 0;
 965
 966         m0d1[0] = mode;
 967         m1[2].value = 0xf000 + mode;
 968         m2[1].value = 0xf000 + mode;
 969         header2[437] = cam->height / 256;
 970         header2[438] = cam->height % 256;
 971         header2[439] = cam->width / 256;
 972         header2[440] = cam->width % 256;
 973
 974         for (i = 0; init[cam->method][i].size != -1; i++) {
 975                 ret =
 976                     send_control_msg(cam->udev, 1, init[cam->method][i].value,
 977                                      0, init[cam->method][i].bytes,
 978                                      init[cam->method][i].size);
 979                 if (ret < 0) {
 980                         dev_err(&cam->udev->dev,
 981                            "error during resolution change sequence: %d\n", i);
 982                         goto out;
 983                 }
 984         }
 985
 986         /* Added some delay here, since opening/closing the camera quickly,
 987          * like Ekiga does during its startup, can crash the webcam
 988          */
 989         mdelay(100);
 990         cam->skip = 2;
 991         ret = 0;
 992
 993 out:
 994         mutex_unlock(&q->vb_lock);
 995
 996         DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
 997             decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
 998             f->fmt.pix.field);
 999         return ret;
1000 }
1001
1002 static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1003                           struct v4l2_requestbuffers *p)
1004 {
1005         int rc;
1006         struct zr364xx_camera *cam = video_drvdata(file);
1007         rc = videobuf_reqbufs(&cam->vb_vidq, p);
1008         return rc;
1009 }
1010
1011 static int zr364xx_vidioc_querybuf(struct file *file,
1012                                 void *priv,
1013                                 struct v4l2_buffer *p)
1014 {
1015         int rc;
1016         struct zr364xx_camera *cam = video_drvdata(file);
1017         rc = videobuf_querybuf(&cam->vb_vidq, p);
1018         return rc;
1019 }
1020
1021 static int zr364xx_vidioc_qbuf(struct file *file,
1022                                 void *priv,
1023                                 struct v4l2_buffer *p)
1024 {
1025         int rc;
1026         struct zr364xx_camera *cam = video_drvdata(file);
1027         _DBG("%s\n", __func__);
1028         rc = videobuf_qbuf(&cam->vb_vidq, p);
1029         return rc;
1030 }
1031
1032 static int zr364xx_vidioc_dqbuf(struct file *file,
1033                                 void *priv,
1034                                 struct v4l2_buffer *p)
1035 {
1036         int rc;
1037         struct zr364xx_camera *cam = video_drvdata(file);
1038         _DBG("%s\n", __func__);
1039         rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1040         return rc;
1041 }
1042
1043 static void read_pipe_completion(struct urb *purb)
1044 {
1045         struct zr364xx_pipeinfo *pipe_info;
1046         struct zr364xx_camera *cam;
1047         int pipe;
1048
1049         pipe_info = purb->context;
1050         _DBG("%s %p, status %d\n", __func__, purb, purb->status);
1051         if (pipe_info == NULL) {
1052                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1053                 return;
1054         }
1055
1056         cam = pipe_info->cam;
1057         if (cam == NULL) {
1058                 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1059                 return;
1060         }
1061
1062         /* if shutting down, do not resubmit, exit immediately */
1063         if (purb->status == -ESHUTDOWN) {
1064                 DBG("%s, err shutdown\n", __func__);
1065                 pipe_info->err_count++;
1066                 return;
1067         }
1068
1069         if (pipe_info->state == 0) {
1070                 DBG("exiting USB pipe\n");
1071                 return;
1072         }
1073
1074         if (purb->actual_length < 0 ||
1075             purb->actual_length > pipe_info->transfer_size) {
1076                 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1077                 return;
1078         }
1079
1080         if (purb->status == 0)
1081                 zr364xx_read_video_callback(cam, pipe_info, purb);
1082         else {
1083                 pipe_info->err_count++;
1084                 DBG("%s: failed URB %d\n", __func__, purb->status);
1085         }
1086
1087         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1088
1089         /* reuse urb */
1090         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1091                           pipe,
1092                           pipe_info->transfer_buffer,
1093                           pipe_info->transfer_size,
1094                           read_pipe_completion, pipe_info);
1095
1096         if (pipe_info->state != 0) {
1097                 purb->status = usb_submit_urb(pipe_info->stream_urb,
1098                                               GFP_ATOMIC);
1099
1100                 if (purb->status)
1101                         dev_err(&cam->udev->dev,
1102                                 "error submitting urb (error=%i)\n",
1103                                 purb->status);
1104         } else
1105                 DBG("read pipe complete state 0\n");
1106 }
1107
1108 static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1109 {
1110         int pipe;
1111         int retval;
1112         struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1113         pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1114         DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1115
1116         pipe_info->state = 1;
1117         pipe_info->err_count = 0;
1118         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1119         if (!pipe_info->stream_urb) {
1120                 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1121                 return -ENOMEM;
1122         }
1123         /* transfer buffer allocated in board_init */
1124         usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1125                           pipe,
1126                           pipe_info->transfer_buffer,
1127                           pipe_info->transfer_size,
1128                           read_pipe_completion, pipe_info);
1129
1130         DBG("submitting URB %p\n", pipe_info->stream_urb);
1131         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1132         if (retval) {
1133                 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1134                 return retval;
1135         }
1136
1137         return 0;
1138 }
1139
1140 static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1141 {
1142         struct zr364xx_pipeinfo *pipe_info;
1143
1144         if (cam == NULL) {
1145                 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1146                 return;
1147         }
1148         DBG("stop read pipe\n");
1149         pipe_info = cam->pipe;
1150         if (pipe_info) {
1151                 if (pipe_info->state != 0)
1152                         pipe_info->state = 0;
1153
1154                 if (pipe_info->stream_urb) {
1155                         /* cancel urb */
1156                         usb_kill_urb(pipe_info->stream_urb);
1157                         usb_free_urb(pipe_info->stream_urb);
1158                         pipe_info->stream_urb = NULL;
1159                 }
1160         }
1161         return;
1162 }
1163
1164 /* starts acquisition process */
1165 static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1166 {
1167         int j;
1168
1169         DBG("start acquire\n");
1170
1171         cam->last_frame = -1;
1172         cam->cur_frame = 0;
1173         for (j = 0; j < FRAMES; j++) {
1174                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1175                 cam->buffer.frame[j].cur_size = 0;
1176         }
1177         cam->b_acquire = 1;
1178         return 0;
1179 }
1180
1181 static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1182 {
1183         cam->b_acquire = 0;
1184         return 0;
1185 }
1186
1187 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1188                                    enum v4l2_buf_type type)
1189 {
1190         struct zr364xx_camera *cam = video_drvdata(file);
1191         int j;
1192         int res;
1193
1194         DBG("%s\n", __func__);
1195
1196         if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1197                 dev_err(&cam->udev->dev, "invalid fh type0\n");
1198                 return -EINVAL;
1199         }
1200         if (cam->type != type) {
1201                 dev_err(&cam->udev->dev, "invalid fh type1\n");
1202                 return -EINVAL;
1203         }
1204
1205         if (!res_get(cam)) {
1206                 dev_err(&cam->udev->dev, "stream busy\n");
1207                 return -EBUSY;
1208         }
1209
1210         cam->last_frame = -1;
1211         cam->cur_frame = 0;
1212         cam->frame_count = 0;
1213         for (j = 0; j < FRAMES; j++) {
1214                 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1215                 cam->buffer.frame[j].cur_size = 0;
1216         }
1217         res = videobuf_streamon(&cam->vb_vidq);
1218         if (res == 0) {
1219                 zr364xx_start_acquire(cam);
1220         } else {
1221                 res_free(cam);
1222         }
1223         return res;
1224 }
1225
1226 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1227                                     enum v4l2_buf_type type)
1228 {
1229         int res;
1230         struct zr364xx_camera *cam = video_drvdata(file);
1231
1232         DBG("%s\n", __func__);
1233         if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1234                 dev_err(&cam->udev->dev, "invalid fh type0\n");
1235                 return -EINVAL;
1236         }
1237         if (cam->type != type) {
1238                 dev_err(&cam->udev->dev, "invalid fh type1\n");
1239                 return -EINVAL;
1240         }
1241         zr364xx_stop_acquire(cam);
1242         res = videobuf_streamoff(&cam->vb_vidq);
1243         if (res < 0)
1244                 return res;
1245         res_free(cam);
1246         return 0;
1247 }
1248
1249
1250 /* open the camera */
1251 static int zr364xx_open(struct file *file)
1252 {
1253         struct video_device *vdev = video_devdata(file);
1254         struct zr364xx_camera *cam = video_drvdata(file);
1255         struct usb_device *udev = cam->udev;
1256         int i, err;
1257
1258         DBG("%s\n", __func__);
1259
1260         mutex_lock(&cam->open_lock);
1261
1262         if (cam->users) {
1263                 err = -EBUSY;
1264                 goto out;
1265         }
1266
1267         for (i = 0; init[cam->method][i].size != -1; i++) {
1268                 err =
1269                     send_control_msg(udev, 1, init[cam->method][i].value,
1270                                      0, init[cam->method][i].bytes,
1271                                      init[cam->method][i].size);
1272                 if (err < 0) {
1273                         dev_err(&cam->udev->dev,
1274                                 "error during open sequence: %d\n", i);
1275                         goto out;
1276                 }
1277         }
1278
1279         cam->skip = 2;
1280         cam->users++;
1281         file->private_data = vdev;
1282         cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1283         cam->fmt = formats;
1284
1285         videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1286                                     NULL, &cam->slock,
1287                                     cam->type,
1288                                     V4L2_FIELD_NONE,
1289                                     sizeof(struct zr364xx_buffer), cam);
1290
1291         /* Added some delay here, since opening/closing the camera quickly,
1292          * like Ekiga does during its startup, can crash the webcam
1293          */
1294         mdelay(100);
1295         err = 0;
1296
1297 out:
1298         mutex_unlock(&cam->open_lock);
1299         DBG("%s: %d\n", __func__, err);
1300         return err;
1301 }
1302
1303 static void zr364xx_destroy(struct zr364xx_camera *cam)
1304 {
1305         unsigned long i;
1306
1307         if (!cam) {
1308                 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1309                 return;
1310         }
1311         mutex_lock(&cam->open_lock);
1312         if (cam->vdev)
1313                 video_unregister_device(cam->vdev);
1314         cam->vdev = NULL;
1315
1316         /* stops the read pipe if it is running */
1317         if (cam->b_acquire)
1318                 zr364xx_stop_acquire(cam);
1319
1320         zr364xx_stop_readpipe(cam);
1321
1322         /* release sys buffers */
1323         for (i = 0; i < FRAMES; i++) {
1324                 if (cam->buffer.frame[i].lpvbits) {
1325                         DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1326                         vfree(cam->buffer.frame[i].lpvbits);
1327                 }
1328                 cam->buffer.frame[i].lpvbits = NULL;
1329         }
1330
1331         /* release transfer buffer */
1332         kfree(cam->pipe->transfer_buffer);
1333         cam->pipe->transfer_buffer = NULL;
1334         mutex_unlock(&cam->open_lock);
1335         kfree(cam);
1336         cam = NULL;
1337 }
1338
1339 /* release the camera */
1340 static int zr364xx_release(struct file *file)
1341 {
1342         struct zr364xx_camera *cam;
1343         struct usb_device *udev;
1344         int i, err;
1345
1346         DBG("%s\n", __func__);
1347         cam = video_drvdata(file);
1348
1349         if (!cam)
1350                 return -ENODEV;
1351
1352         mutex_lock(&cam->open_lock);
1353         udev = cam->udev;
1354
1355         /* turn off stream */
1356         if (res_check(cam)) {
1357                 if (cam->b_acquire)
1358                         zr364xx_stop_acquire(cam);
1359                 videobuf_streamoff(&cam->vb_vidq);
1360                 res_free(cam);
1361         }
1362
1363         cam->users--;
1364         file->private_data = NULL;
1365
1366         for (i = 0; i < 2; i++) {
1367                 err =
1368                     send_control_msg(udev, 1, init[cam->method][i].value,
1369                                      0, init[cam->method][i].bytes,
1370                                      init[cam->method][i].size);
1371                 if (err < 0) {
1372                         dev_err(&udev->dev, "error during release sequence\n");
1373                         goto out;
1374                 }
1375         }
1376
1377         /* Added some delay here, since opening/closing the camera quickly,
1378          * like Ekiga does during its startup, can crash the webcam
1379          */
1380         mdelay(100);
1381         err = 0;
1382
1383 out:
1384         mutex_unlock(&cam->open_lock);
1385
1386         return err;
1387 }
1388
1389
1390 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1391 {
1392         struct zr364xx_camera *cam = video_drvdata(file);
1393         int ret;
1394
1395         if (cam == NULL) {
1396                 DBG("%s: cam == NULL\n", __func__);
1397                 return -ENODEV;
1398         }
1399         DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
1400
1401         ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1402
1403         DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1404                 (unsigned long)vma->vm_start,
1405                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1406         return ret;
1407 }
1408
1409 static unsigned int zr364xx_poll(struct file *file,
1410                                struct poll_table_struct *wait)
1411 {
1412         struct zr364xx_camera *cam = video_drvdata(file);
1413         struct videobuf_queue *q = &cam->vb_vidq;
1414         _DBG("%s\n", __func__);
1415
1416         if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1417                 return POLLERR;
1418
1419         return videobuf_poll_stream(file, q, wait);
1420 }
1421
1422 static const struct v4l2_file_operations zr364xx_fops = {
1423         .owner = THIS_MODULE,
1424         .open = zr364xx_open,
1425         .release = zr364xx_release,
1426         .read = zr364xx_read,
1427         .mmap = zr364xx_mmap,
1428         .ioctl = video_ioctl2,
1429         .poll = zr364xx_poll,
1430 };
1431
1432 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
1433         .vidioc_querycap        = zr364xx_vidioc_querycap,
1434         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1435         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1436         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
1437         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
1438         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
1439         .vidioc_g_input         = zr364xx_vidioc_g_input,
1440         .vidioc_s_input         = zr364xx_vidioc_s_input,
1441         .vidioc_streamon        = zr364xx_vidioc_streamon,
1442         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
1443         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
1444         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
1445         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
1446         .vidioc_reqbufs         = zr364xx_vidioc_reqbufs,
1447         .vidioc_querybuf        = zr364xx_vidioc_querybuf,
1448         .vidioc_qbuf            = zr364xx_vidioc_qbuf,
1449         .vidioc_dqbuf           = zr364xx_vidioc_dqbuf,
1450 };
1451
1452 static struct video_device zr364xx_template = {
1453         .name = DRIVER_DESC,
1454         .fops = &zr364xx_fops,
1455         .ioctl_ops = &zr364xx_ioctl_ops,
1456         .release = video_device_release,
1457         .minor = -1,
1458 };
1459
1460
1461
1462 /*******************/
1463 /* USB integration */
1464 /*******************/
1465 static int zr364xx_board_init(struct zr364xx_camera *cam)
1466 {
1467         struct zr364xx_pipeinfo *pipe = cam->pipe;
1468         unsigned long i;
1469
1470         DBG("board init: %p\n", cam);
1471         memset(pipe, 0, sizeof(*pipe));
1472         pipe->cam = cam;
1473         pipe->transfer_size = BUFFER_SIZE;
1474
1475         pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1476                                         GFP_KERNEL);
1477         if (pipe->transfer_buffer == NULL) {
1478                 DBG("out of memory!\n");
1479                 return -ENOMEM;
1480         }
1481
1482         cam->b_acquire = 0;
1483         cam->frame_count = 0;
1484
1485         /*** start create system buffers ***/
1486         for (i = 0; i < FRAMES; i++) {
1487                 /* always allocate maximum size for system buffers */
1488                 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1489
1490                 DBG("valloc %p, idx %lu, pdata %p\n",
1491                         &cam->buffer.frame[i], i,
1492                         cam->buffer.frame[i].lpvbits);
1493                 if (cam->buffer.frame[i].lpvbits == NULL) {
1494                         printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1495                                "Using less frames\n");
1496                         break;
1497                 }
1498         }
1499
1500         if (i == 0) {
1501                 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1502                 kfree(cam->pipe->transfer_buffer);
1503                 cam->pipe->transfer_buffer = NULL;
1504                 return -ENOMEM;
1505         } else
1506                 cam->buffer.dwFrames = i;
1507
1508         /* make sure internal states are set */
1509         for (i = 0; i < FRAMES; i++) {
1510                 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1511                 cam->buffer.frame[i].cur_size = 0;
1512         }
1513
1514         cam->cur_frame = 0;
1515         cam->last_frame = -1;
1516         /*** end create system buffers ***/
1517
1518         /* start read pipe */
1519         zr364xx_start_readpipe(cam);
1520         DBG(": board initialized\n");
1521         return 0;
1522 }
1523
1524 static int zr364xx_probe(struct usb_interface *intf,
1525                          const struct usb_device_id *id)
1526 {
1527         struct usb_device *udev = interface_to_usbdev(intf);
1528         struct zr364xx_camera *cam = NULL;
1529         struct usb_host_interface *iface_desc;
1530         struct usb_endpoint_descriptor *endpoint;
1531         int err;
1532         int i;
1533
1534         DBG("probing...\n");
1535
1536         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1537         dev_info(&intf->dev, "model %04x:%04x detected\n",
1538                  le16_to_cpu(udev->descriptor.idVendor),
1539                  le16_to_cpu(udev->descriptor.idProduct));
1540
1541         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1542         if (cam == NULL) {
1543                 dev_err(&udev->dev, "cam: out of memory !\n");
1544                 return -ENOMEM;
1545         }
1546         /* save the init method used by this camera */
1547         cam->method = id->driver_info;
1548
1549         cam->vdev = video_device_alloc();
1550         if (cam->vdev == NULL) {
1551                 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
1552                 kfree(cam);
1553                 cam = NULL;
1554                 return -ENOMEM;
1555         }
1556         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
1557         cam->vdev->parent = &intf->dev;
1558         video_set_drvdata(cam->vdev, cam);
1559         if (debug)
1560                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1561
1562         cam->udev = udev;
1563
1564         switch (mode) {
1565         case 1:
1566                 dev_info(&udev->dev, "160x120 mode selected\n");
1567                 cam->width = 160;
1568                 cam->height = 120;
1569                 break;
1570         case 2:
1571                 dev_info(&udev->dev, "640x480 mode selected\n");
1572                 cam->width = 640;
1573                 cam->height = 480;
1574                 break;
1575         default:
1576                 dev_info(&udev->dev, "320x240 mode selected\n");
1577                 cam->width = 320;
1578                 cam->height = 240;
1579                 break;
1580         }
1581
1582         m0d1[0] = mode;
1583         m1[2].value = 0xf000 + mode;
1584         m2[1].value = 0xf000 + mode;
1585         header2[437] = cam->height / 256;
1586         header2[438] = cam->height % 256;
1587         header2[439] = cam->width / 256;
1588         header2[440] = cam->width % 256;
1589
1590         cam->users = 0;
1591         cam->nb = 0;
1592         cam->mode.brightness = 64;
1593         mutex_init(&cam->lock);
1594         mutex_init(&cam->open_lock);
1595
1596         DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1597
1598         /* set up the endpoint information  */
1599         iface_desc = intf->cur_altsetting;
1600         DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1601         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1602                 endpoint = &iface_desc->endpoint[i].desc;
1603                 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1604                         /* we found the bulk in endpoint */
1605                         cam->read_endpoint = endpoint->bEndpointAddress;
1606                 }
1607         }
1608
1609         if (!cam->read_endpoint) {
1610                 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1611                 return -ENOMEM;
1612         }
1613
1614         /* v4l */
1615         INIT_LIST_HEAD(&cam->vidq.active);
1616         cam->vidq.cam = cam;
1617         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1618         if (err) {
1619                 dev_err(&udev->dev, "video_register_device failed\n");
1620                 video_device_release(cam->vdev);
1621                 kfree(cam);
1622                 cam = NULL;
1623                 return err;
1624         }
1625
1626         usb_set_intfdata(intf, cam);
1627
1628         /* load zr364xx board specific */
1629         err = zr364xx_board_init(cam);
1630         if (err) {
1631                 spin_lock_init(&cam->slock);
1632                 return err;
1633         }
1634
1635         spin_lock_init(&cam->slock);
1636
1637         dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
1638                  cam->vdev->num);
1639         return 0;
1640 }
1641
1642
1643 static void zr364xx_disconnect(struct usb_interface *intf)
1644 {
1645         struct zr364xx_camera *cam = usb_get_intfdata(intf);
1646         videobuf_mmap_free(&cam->vb_vidq);
1647         usb_set_intfdata(intf, NULL);
1648         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
1649         zr364xx_destroy(cam);
1650 }
1651
1652
1653
1654 /**********************/
1655 /* Module integration */
1656 /**********************/
1657
1658 static struct usb_driver zr364xx_driver = {
1659         .name = "zr364xx",
1660         .probe = zr364xx_probe,
1661         .disconnect = zr364xx_disconnect,
1662         .id_table = device_table
1663 };
1664
1665
1666 static int __init zr364xx_init(void)
1667 {
1668         int retval;
1669         retval = usb_register(&zr364xx_driver);
1670         if (retval)
1671                 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
1672         else
1673                 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1674         return retval;
1675 }
1676
1677
1678 static void __exit zr364xx_exit(void)
1679 {
1680         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
1681         usb_deregister(&zr364xx_driver);
1682 }
1683
1684
1685 module_init(zr364xx_init);
1686 module_exit(zr364xx_exit);
1687
1688 MODULE_AUTHOR(DRIVER_AUTHOR);
1689 MODULE_DESCRIPTION(DRIVER_DESC);
1690 MODULE_LICENSE("GPL");