drivers/media/video/zr364xx.c

   1 /*
   2  * Zoran 364xx based USB webcam module version 0.72
   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  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26  */
  27
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/usb.h>
  32 #include <linux/vmalloc.h>
  33 #include <linux/slab.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/highmem.h>
  36 #include <media/v4l2-common.h>
  37 #include <media/v4l2-ioctl.h>
  38
  39
  40 /* Version Information */
  41 #define DRIVER_VERSION "v0.72"
  42 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
  43 #define DRIVER_DESC "Zoran 364xx"
  44
  45
  46 /* Camera */
  47 #define FRAMES 2
  48 #define MAX_FRAME_SIZE 100000
  49 #define BUFFER_SIZE 0x1000
  50 #define CTRL_TIMEOUT 500
  51
  52
  53 /* Debug macro */
  54 #define DBG(x...) if (debug) printk(KERN_INFO KBUILD_MODNAME x)
  55
  56
  57 /* Init methods, need to find nicer names for these
  58  * the exact names of the chipsets would be the best if someone finds it */
  59 #define METHOD0 0
  60 #define METHOD1 1
  61 #define METHOD2 2
  62
  63
  64 /* Module parameters */
  65 static int debug;
  66 static int mode;
  67
  68
  69 /* Module parameters interface */
  70 module_param(debug, int, 0644);
  71 MODULE_PARM_DESC(debug, "Debug level");
  72 module_param(mode, int, 0644);
  73 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
  74
  75
  76 /* Devices supported by this driver
  77  * .driver_info contains the init method used by the camera */
  78 static struct usb_device_id device_table[] = {
  79         {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
  80         {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
  81         {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
  82         {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
  83         {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
  84         {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
  85         {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
  86         {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
  87         {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
  88         {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
  89         {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
  90         {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
  91         {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
  92         {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
  93         {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
  94         {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
  95         {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
  96         {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
  97         {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
  98         {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD2 },
  99         {}                      /* Terminating entry */
 100 };
 101
 102 MODULE_DEVICE_TABLE(usb, device_table);
 103
 104
 105 /* Camera stuff */
 106 struct zr364xx_camera {
 107         struct usb_device *udev;        /* save off the usb device pointer */
 108         struct usb_interface *interface;/* the interface for this device */
 109         struct video_device *vdev;      /* v4l video device */
 110         u8 *framebuf;
 111         int nb;
 112         unsigned char *buffer;
 113         int skip;
 114         int brightness;
 115         int width;
 116         int height;
 117         int method;
 118         struct mutex lock;
 119         int users;
 120 };
 121
 122
 123 /* function used to send initialisation commands to the camera */
 124 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
 125                             u16 index, unsigned char *cp, u16 size)
 126 {
 127         int status;
 128
 129         unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
 130         if (!transfer_buffer) {
 131                 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
 132                 return -ENOMEM;
 133         }
 134
 135         memcpy(transfer_buffer, cp, size);
 136
 137         status = usb_control_msg(udev,
 138                                  usb_sndctrlpipe(udev, 0),
 139                                  request,
 140                                  USB_DIR_OUT | USB_TYPE_VENDOR |
 141                                  USB_RECIP_DEVICE, value, index,
 142                                  transfer_buffer, size, CTRL_TIMEOUT);
 143
 144         kfree(transfer_buffer);
 145
 146         if (status < 0)
 147                 dev_err(&udev->dev,
 148                         "Failed sending control message, error %d.\n", status);
 149
 150         return status;
 151 }
 152
 153
 154 /* Control messages sent to the camera to initialize it
 155  * and launch the capture */
 156 typedef struct {
 157         unsigned int value;
 158         unsigned int size;
 159         unsigned char *bytes;
 160 } message;
 161
 162 /* method 0 */
 163 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 164 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
 165 static unsigned char m0d3[] = { 0, 0 };
 166 static message m0[] = {
 167         {0x1f30, 0, NULL},
 168         {0xd000, 0, NULL},
 169         {0x3370, sizeof(m0d1), m0d1},
 170         {0x2000, 0, NULL},
 171         {0x2f0f, 0, NULL},
 172         {0x2610, sizeof(m0d2), m0d2},
 173         {0xe107, 0, NULL},
 174         {0x2502, 0, NULL},
 175         {0x1f70, 0, NULL},
 176         {0xd000, 0, NULL},
 177         {0x9a01, sizeof(m0d3), m0d3},
 178         {-1, -1, NULL}
 179 };
 180
 181 /* method 1 */
 182 static unsigned char m1d1[] = { 0xff, 0xff };
 183 static unsigned char m1d2[] = { 0x00, 0x00 };
 184 static message m1[] = {
 185         {0x1f30, 0, NULL},
 186         {0xd000, 0, NULL},
 187         {0xf000, 0, NULL},
 188         {0x2000, 0, NULL},
 189         {0x2f0f, 0, NULL},
 190         {0x2650, 0, NULL},
 191         {0xe107, 0, NULL},
 192         {0x2502, sizeof(m1d1), m1d1},
 193         {0x1f70, 0, NULL},
 194         {0xd000, 0, NULL},
 195         {0xd000, 0, NULL},
 196         {0xd000, 0, NULL},
 197         {0x9a01, sizeof(m1d2), m1d2},
 198         {-1, -1, NULL}
 199 };
 200
 201 /* method 2 */
 202 static unsigned char m2d1[] = { 0xff, 0xff };
 203 static message m2[] = {
 204         {0x1f30, 0, NULL},
 205         {0xf000, 0, NULL},
 206         {0x2000, 0, NULL},
 207         {0x2f0f, 0, NULL},
 208         {0x2650, 0, NULL},
 209         {0xe107, 0, NULL},
 210         {0x2502, sizeof(m2d1), m2d1},
 211         {0x1f70, 0, NULL},
 212         {-1, -1, NULL}
 213 };
 214
 215 /* init table */
 216 static message *init[3] = { m0, m1, m2 };
 217
 218
 219 /* JPEG static data in header (Huffman table, etc) */
 220 static unsigned char header1[] = {
 221         0xFF, 0xD8,
 222         /*
 223         0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
 224         0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
 225         */
 226         0xFF, 0xDB, 0x00, 0x84
 227 };
 228 static unsigned char header2[] = {
 229         0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
 230         0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 231         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
 232         0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
 233         0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
 234         0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
 235         0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
 236         0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
 237         0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
 238         0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 239         0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
 240         0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
 241         0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
 242         0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
 243         0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
 244         0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
 245         0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
 246         0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
 247         0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
 248         0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
 249         0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 250         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
 251         0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
 252         0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
 253         0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
 254         0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 255         0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
 256         0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
 257         0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
 258         0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
 259         0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
 260         0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
 261         0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
 262         0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
 263         0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
 264         0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
 265         0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
 266         0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
 267         0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
 268         0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
 269         0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
 270         0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
 271         0x00, 0x3F, 0x00
 272 };
 273 static unsigned char header3;
 274
 275
 276
 277 /********************/
 278 /* V4L2 integration */
 279 /********************/
 280
 281 /* this function reads a full JPEG picture synchronously
 282  * TODO: do it asynchronously... */
 283 static int read_frame(struct zr364xx_camera *cam, int framenum)
 284 {
 285         int i, n, temp, head, size, actual_length;
 286         unsigned char *ptr = NULL, *jpeg;
 287
 288       redo:
 289         /* hardware brightness */
 290         n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
 291         temp = (0x60 << 8) + 127 - cam->brightness;
 292         n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
 293
 294         /* during the first loop we are going to insert JPEG header */
 295         head = 0;
 296         /* this is the place in memory where we are going to build
 297          * the JPEG image */
 298         jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;
 299         /* read data... */
 300         do {
 301                 n = usb_bulk_msg(cam->udev,
 302                                  usb_rcvbulkpipe(cam->udev, 0x81),
 303                                  cam->buffer, BUFFER_SIZE, &actual_length,
 304                                  CTRL_TIMEOUT);
 305                 DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);
 306                 DBG("bulk : n=%d size=%d", n, actual_length);
 307                 if (n < 0) {
 308                         dev_err(&cam->udev->dev, "error reading bulk msg\n");
 309                         return 0;
 310                 }
 311                 if (actual_length < 0 || actual_length > BUFFER_SIZE) {
 312                         dev_err(&cam->udev->dev, "wrong number of bytes\n");
 313                         return 0;
 314                 }
 315
 316                 /* swap bytes if camera needs it */
 317                 if (cam->method == METHOD0) {
 318                         u16 *buf = (u16*)cam->buffer;
 319                         for (i = 0; i < BUFFER_SIZE/2; i++)
 320                                 swab16s(buf + i);
 321                 }
 322
 323                 /* write the JPEG header */
 324                 if (!head) {
 325                         DBG("jpeg header");
 326                         ptr = jpeg;
 327                         memcpy(ptr, header1, sizeof(header1));
 328                         ptr += sizeof(header1);
 329                         header3 = 0;
 330                         memcpy(ptr, &header3, 1);
 331                         ptr++;
 332                         memcpy(ptr, cam->buffer, 64);
 333                         ptr += 64;
 334                         header3 = 1;
 335                         memcpy(ptr, &header3, 1);
 336                         ptr++;
 337                         memcpy(ptr, cam->buffer + 64, 64);
 338                         ptr += 64;
 339                         memcpy(ptr, header2, sizeof(header2));
 340                         ptr += sizeof(header2);
 341                         memcpy(ptr, cam->buffer + 128,
 342                                actual_length - 128);
 343                         ptr += actual_length - 128;
 344                         head = 1;
 345                         DBG("header : %d %d %d %d %d %d %d %d %d",
 346                             cam->buffer[0], cam->buffer[1], cam->buffer[2],
 347                             cam->buffer[3], cam->buffer[4], cam->buffer[5],
 348                             cam->buffer[6], cam->buffer[7], cam->buffer[8]);
 349                 } else {
 350                         memcpy(ptr, cam->buffer, actual_length);
 351                         ptr += actual_length;
 352                 }
 353         }
 354         /* ... until there is no more */
 355         while (actual_length == BUFFER_SIZE);
 356
 357         /* we skip the 2 first frames which are usually buggy */
 358         if (cam->skip) {
 359                 cam->skip--;
 360                 goto redo;
 361         }
 362
 363         /* go back to find the JPEG EOI marker */
 364         size = ptr - jpeg;
 365         ptr -= 2;
 366         while (ptr > jpeg) {
 367                 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
 368                     && *(ptr + 2) == 0xFF)
 369                         break;
 370                 ptr--;
 371         }
 372         if (ptr == jpeg)
 373                 DBG("No EOI marker");
 374
 375         /* Sometimes there is junk data in the middle of the picture,
 376          * we want to skip this bogus frames */
 377         while (ptr > jpeg) {
 378                 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
 379                     && *(ptr + 2) == 0xFF)
 380                         break;
 381                 ptr--;
 382         }
 383         if (ptr != jpeg) {
 384                 DBG("Bogus frame ? %d", cam->nb);
 385                 goto redo;
 386         }
 387
 388         DBG("jpeg : %d %d %d %d %d %d %d %d",
 389             jpeg[0], jpeg[1], jpeg[2], jpeg[3],
 390             jpeg[4], jpeg[5], jpeg[6], jpeg[7]);
 391
 392         return size;
 393 }
 394
 395
 396 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
 397                             loff_t * ppos)
 398 {
 399         unsigned long count = cnt;
 400         struct video_device *vdev = video_devdata(file);
 401         struct zr364xx_camera *cam;
 402
 403         DBG("zr364xx_read: read %d bytes.", (int) count);
 404
 405         if (vdev == NULL)
 406                 return -ENODEV;
 407         cam = video_get_drvdata(vdev);
 408
 409         if (!buf)
 410                 return -EINVAL;
 411
 412         if (!count)
 413                 return -EINVAL;
 414
 415         /* NoMan Sux ! */
 416         count = read_frame(cam, 0);
 417
 418         if (copy_to_user(buf, cam->framebuf, count))
 419                 return -EFAULT;
 420
 421         return count;
 422 }
 423
 424
 425 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
 426                                    struct v4l2_capability *cap)
 427 {
 428         strcpy(cap->driver, DRIVER_DESC);
 429         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
 430         return 0;
 431 }
 432
 433 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
 434                                      struct v4l2_input *i)
 435 {
 436         if (i->index != 0)
 437                 return -EINVAL;
 438         strcpy(i->name, DRIVER_DESC " Camera");
 439         i->type = V4L2_INPUT_TYPE_CAMERA;
 440         return 0;
 441 }
 442
 443 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
 444                                   unsigned int *i)
 445 {
 446         *i = 0;
 447         return 0;
 448 }
 449
 450 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 451                                   unsigned int i)
 452 {
 453         if (i != 0)
 454                 return -EINVAL;
 455         return 0;
 456 }
 457
 458 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
 459                                     struct v4l2_queryctrl *c)
 460 {
 461         struct video_device *vdev = video_devdata(file);
 462         struct zr364xx_camera *cam;
 463
 464         if (vdev == NULL)
 465                 return -ENODEV;
 466         cam = video_get_drvdata(vdev);
 467
 468         switch (c->id) {
 469         case V4L2_CID_BRIGHTNESS:
 470                 c->type = V4L2_CTRL_TYPE_INTEGER;
 471                 strcpy(c->name, "Brightness");
 472                 c->minimum = 0;
 473                 c->maximum = 127;
 474                 c->step = 1;
 475                 c->default_value = cam->brightness;
 476                 c->flags = 0;
 477                 break;
 478         default:
 479                 return -EINVAL;
 480         }
 481         return 0;
 482 }
 483
 484 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
 485                                  struct v4l2_control *c)
 486 {
 487         struct video_device *vdev = video_devdata(file);
 488         struct zr364xx_camera *cam;
 489
 490         if (vdev == NULL)
 491                 return -ENODEV;
 492         cam = video_get_drvdata(vdev);
 493
 494         switch (c->id) {
 495         case V4L2_CID_BRIGHTNESS:
 496                 cam->brightness = c->value;
 497                 break;
 498         default:
 499                 return -EINVAL;
 500         }
 501         return 0;
 502 }
 503
 504 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
 505                                  struct v4l2_control *c)
 506 {
 507         struct video_device *vdev = video_devdata(file);
 508         struct zr364xx_camera *cam;
 509
 510         if (vdev == NULL)
 511                 return -ENODEV;
 512         cam = video_get_drvdata(vdev);
 513
 514         switch (c->id) {
 515         case V4L2_CID_BRIGHTNESS:
 516                 c->value = cam->brightness;
 517                 break;
 518         default:
 519                 return -EINVAL;
 520         }
 521         return 0;
 522 }
 523
 524 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
 525                                        void *priv, struct v4l2_fmtdesc *f)
 526 {
 527         if (f->index > 0)
 528                 return -EINVAL;
 529         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 530         strcpy(f->description, "JPEG");
 531         f->pixelformat = V4L2_PIX_FMT_JPEG;
 532         return 0;
 533 }
 534
 535 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 536                                       struct v4l2_format *f)
 537 {
 538         struct video_device *vdev = video_devdata(file);
 539         struct zr364xx_camera *cam;
 540
 541         if (vdev == NULL)
 542                 return -ENODEV;
 543         cam = video_get_drvdata(vdev);
 544
 545         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
 546                 return -EINVAL;
 547         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
 548             f->fmt.pix.field != V4L2_FIELD_NONE)
 549                 return -EINVAL;
 550         f->fmt.pix.field = V4L2_FIELD_NONE;
 551         f->fmt.pix.width = cam->width;
 552         f->fmt.pix.height = cam->height;
 553         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 554         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 555         f->fmt.pix.colorspace = 0;
 556         f->fmt.pix.priv = 0;
 557         return 0;
 558 }
 559
 560 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 561                                     struct v4l2_format *f)
 562 {
 563         struct video_device *vdev = video_devdata(file);
 564         struct zr364xx_camera *cam;
 565
 566         if (vdev == NULL)
 567                 return -ENODEV;
 568         cam = video_get_drvdata(vdev);
 569
 570         f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
 571         f->fmt.pix.field = V4L2_FIELD_NONE;
 572         f->fmt.pix.width = cam->width;
 573         f->fmt.pix.height = cam->height;
 574         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 575         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 576         f->fmt.pix.colorspace = 0;
 577         f->fmt.pix.priv = 0;
 578         return 0;
 579 }
 580
 581 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 582                                     struct v4l2_format *f)
 583 {
 584         struct video_device *vdev = video_devdata(file);
 585         struct zr364xx_camera *cam;
 586
 587         if (vdev == NULL)
 588                 return -ENODEV;
 589         cam = video_get_drvdata(vdev);
 590
 591         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
 592                 return -EINVAL;
 593         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
 594             f->fmt.pix.field != V4L2_FIELD_NONE)
 595                 return -EINVAL;
 596         f->fmt.pix.field = V4L2_FIELD_NONE;
 597         f->fmt.pix.width = cam->width;
 598         f->fmt.pix.height = cam->height;
 599         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 600         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 601         f->fmt.pix.colorspace = 0;
 602         f->fmt.pix.priv = 0;
 603         DBG("ok!");
 604         return 0;
 605 }
 606
 607 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
 608                                    enum v4l2_buf_type type)
 609 {
 610         return 0;
 611 }
 612
 613 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
 614                                     enum v4l2_buf_type type)
 615 {
 616         return 0;
 617 }
 618
 619
 620 /* open the camera */
 621 static int zr364xx_open(struct file *file)
 622 {
 623         struct video_device *vdev = video_devdata(file);
 624         struct zr364xx_camera *cam = video_get_drvdata(vdev);
 625         struct usb_device *udev = cam->udev;
 626         int i, err;
 627
 628         DBG("zr364xx_open");
 629
 630         mutex_lock(&cam->lock);
 631
 632         if (cam->users) {
 633                 err = -EBUSY;
 634                 goto out;
 635         }
 636
 637         if (!cam->framebuf) {
 638                 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
 639                 if (!cam->framebuf) {
 640                         dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
 641                         err = -ENOMEM;
 642                         goto out;
 643                 }
 644         }
 645
 646         for (i = 0; init[cam->method][i].size != -1; i++) {
 647                 err =
 648                     send_control_msg(udev, 1, init[cam->method][i].value,
 649                                      0, init[cam->method][i].bytes,
 650                                      init[cam->method][i].size);
 651                 if (err < 0) {
 652                         dev_err(&cam->udev->dev,
 653                                 "error during open sequence: %d\n", i);
 654                         goto out;
 655                 }
 656         }
 657
 658         cam->skip = 2;
 659         cam->users++;
 660         file->private_data = vdev;
 661
 662         /* Added some delay here, since opening/closing the camera quickly,
 663          * like Ekiga does during its startup, can crash the webcam
 664          */
 665         mdelay(100);
 666         err = 0;
 667
 668 out:
 669         mutex_unlock(&cam->lock);
 670         return err;
 671 }
 672
 673
 674 /* release the camera */
 675 static int zr364xx_release(struct file *file)
 676 {
 677         struct video_device *vdev = video_devdata(file);
 678         struct zr364xx_camera *cam;
 679         struct usb_device *udev;
 680         int i, err;
 681
 682         DBG("zr364xx_release");
 683
 684         if (vdev == NULL)
 685                 return -ENODEV;
 686         cam = video_get_drvdata(vdev);
 687
 688         udev = cam->udev;
 689
 690         mutex_lock(&cam->lock);
 691
 692         cam->users--;
 693         file->private_data = NULL;
 694
 695         for (i = 0; i < 2; i++) {
 696                 err =
 697                     send_control_msg(udev, 1, init[cam->method][i].value,
 698                                      0, init[i][cam->method].bytes,
 699                                      init[cam->method][i].size);
 700                 if (err < 0) {
 701                         dev_err(&udev->dev, "error during release sequence\n");
 702                         goto out;
 703                 }
 704         }
 705
 706         /* Added some delay here, since opening/closing the camera quickly,
 707          * like Ekiga does during its startup, can crash the webcam
 708          */
 709         mdelay(100);
 710         err = 0;
 711
 712 out:
 713         mutex_unlock(&cam->lock);
 714         return err;
 715 }
 716
 717
 718 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
 719 {
 720         void *pos;
 721         unsigned long start = vma->vm_start;
 722         unsigned long size = vma->vm_end - vma->vm_start;
 723         struct video_device *vdev = video_devdata(file);
 724         struct zr364xx_camera *cam;
 725
 726         DBG("zr364xx_mmap: %ld\n", size);
 727
 728         if (vdev == NULL)
 729                 return -ENODEV;
 730         cam = video_get_drvdata(vdev);
 731
 732         pos = cam->framebuf;
 733         while (size > 0) {
 734                 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
 735                         return -EAGAIN;
 736                 start += PAGE_SIZE;
 737                 pos += PAGE_SIZE;
 738                 if (size > PAGE_SIZE)
 739                         size -= PAGE_SIZE;
 740                 else
 741                         size = 0;
 742         }
 743
 744         return 0;
 745 }
 746
 747
 748 static const struct v4l2_file_operations zr364xx_fops = {
 749         .owner = THIS_MODULE,
 750         .open = zr364xx_open,
 751         .release = zr364xx_release,
 752         .read = zr364xx_read,
 753         .mmap = zr364xx_mmap,
 754         .ioctl = video_ioctl2,
 755 };
 756
 757 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
 758         .vidioc_querycap        = zr364xx_vidioc_querycap,
 759         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
 760         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
 761         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
 762         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
 763         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
 764         .vidioc_g_input         = zr364xx_vidioc_g_input,
 765         .vidioc_s_input         = zr364xx_vidioc_s_input,
 766         .vidioc_streamon        = zr364xx_vidioc_streamon,
 767         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
 768         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
 769         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
 770         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
 771 };
 772
 773 static struct video_device zr364xx_template = {
 774         .name = DRIVER_DESC,
 775         .fops = &zr364xx_fops,
 776         .ioctl_ops = &zr364xx_ioctl_ops,
 777         .release = video_device_release,
 778         .minor = -1,
 779 };
 780
 781
 782
 783 /*******************/
 784 /* USB integration */
 785 /*******************/
 786
 787 static int zr364xx_probe(struct usb_interface *intf,
 788                          const struct usb_device_id *id)
 789 {
 790         struct usb_device *udev = interface_to_usbdev(intf);
 791         struct zr364xx_camera *cam = NULL;
 792         int err;
 793
 794         DBG("probing...");
 795
 796         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
 797         dev_info(&intf->dev, "model %04x:%04x detected\n",
 798                  le16_to_cpu(udev->descriptor.idVendor),
 799                  le16_to_cpu(udev->descriptor.idProduct));
 800
 801         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
 802         if (cam == NULL) {
 803                 dev_err(&udev->dev, "cam: out of memory !\n");
 804                 return -ENOMEM;
 805         }
 806         /* save the init method used by this camera */
 807         cam->method = id->driver_info;
 808
 809         cam->vdev = video_device_alloc();
 810         if (cam->vdev == NULL) {
 811                 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
 812                 kfree(cam);
 813                 return -ENOMEM;
 814         }
 815         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
 816         video_set_drvdata(cam->vdev, cam);
 817         if (debug)
 818                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
 819
 820         cam->udev = udev;
 821
 822         if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
 823                 dev_info(&udev->dev, "cam->buffer: out of memory !\n");
 824                 video_device_release(cam->vdev);
 825                 kfree(cam);
 826                 return -ENODEV;
 827         }
 828
 829         switch (mode) {
 830         case 1:
 831                 dev_info(&udev->dev, "160x120 mode selected\n");
 832                 cam->width = 160;
 833                 cam->height = 120;
 834                 break;
 835         case 2:
 836                 dev_info(&udev->dev, "640x480 mode selected\n");
 837                 cam->width = 640;
 838                 cam->height = 480;
 839                 break;
 840         default:
 841                 dev_info(&udev->dev, "320x240 mode selected\n");
 842                 cam->width = 320;
 843                 cam->height = 240;
 844                 break;
 845         }
 846
 847         m0d1[0] = mode;
 848         m1[2].value = 0xf000 + mode;
 849         m2[1].value = 0xf000 + mode;
 850         header2[437] = cam->height / 256;
 851         header2[438] = cam->height % 256;
 852         header2[439] = cam->width / 256;
 853         header2[440] = cam->width % 256;
 854
 855         cam->nb = 0;
 856         cam->brightness = 64;
 857         mutex_init(&cam->lock);
 858
 859         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
 860         if (err) {
 861                 dev_err(&udev->dev, "video_register_device failed\n");
 862                 video_device_release(cam->vdev);
 863                 kfree(cam->buffer);
 864                 kfree(cam);
 865                 return err;
 866         }
 867
 868         usb_set_intfdata(intf, cam);
 869
 870         dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
 871                  cam->vdev->num);
 872         return 0;
 873 }
 874
 875
 876 static void zr364xx_disconnect(struct usb_interface *intf)
 877 {
 878         struct zr364xx_camera *cam = usb_get_intfdata(intf);
 879         usb_set_intfdata(intf, NULL);
 880         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
 881         if (cam->vdev)
 882                 video_unregister_device(cam->vdev);
 883         cam->vdev = NULL;
 884         kfree(cam->buffer);
 885         cam->buffer = NULL;
 886         vfree(cam->framebuf);
 887         cam->framebuf = NULL;
 888         kfree(cam);
 889         cam = NULL;
 890 }
 891
 892
 893
 894 /**********************/
 895 /* Module integration */
 896 /**********************/
 897
 898 static struct usb_driver zr364xx_driver = {
 899         .name = "zr364xx",
 900         .probe = zr364xx_probe,
 901         .disconnect = zr364xx_disconnect,
 902         .id_table = device_table
 903 };
 904
 905
 906 static int __init zr364xx_init(void)
 907 {
 908         int retval;
 909         retval = usb_register(&zr364xx_driver);
 910         if (retval)
 911                 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
 912         else
 913                 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 914         return retval;
 915 }
 916
 917
 918 static void __exit zr364xx_exit(void)
 919 {
 920         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
 921         usb_deregister(&zr364xx_driver);
 922 }
 923
 924
 925 module_init(zr364xx_init);
 926 module_exit(zr364xx_exit);
 927
 928 MODULE_AUTHOR(DRIVER_AUTHOR);
 929 MODULE_DESCRIPTION(DRIVER_DESC);
 930 MODULE_LICENSE("GPL");