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