drivers/media/usb/zr364xx/zr364xx.c

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