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/version.h>
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/usb.h>
  33 #include <linux/vmalloc.h>
  34 #include <linux/slab.h>
  35 #include <linux/proc_fs.h>
  36 #include <linux/highmem.h>
  37 #include <media/v4l2-common.h>
  38 #include <media/v4l2-ioctl.h>
  39
  40
  41 /* Version Information */
  42 #define DRIVER_VERSION "v0.72"
  43 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
  44 #define DRIVER_DESC "Zoran 364xx"
  45
  46
  47 /* Camera */
  48 #define FRAMES 2
  49 #define MAX_FRAME_SIZE 100000
  50 #define BUFFER_SIZE 0x1000
  51 #define CTRL_TIMEOUT 500
  52
  53
  54 /* Debug macro */
  55 #define DBG(x...) if (debug) printk(KERN_INFO KBUILD_MODNAME x)
  56
  57
  58 /* Init methods, need to find nicer names for these
  59  * the exact names of the chipsets would be the best if someone finds it */
  60 #define METHOD0 0
  61 #define METHOD1 1
  62 #define METHOD2 2
  63
  64
  65 /* Module parameters */
  66 static int debug;
  67 static int mode;
  68
  69
  70 /* Module parameters interface */
  71 module_param(debug, int, 0644);
  72 MODULE_PARM_DESC(debug, "Debug level");
  73 module_param(mode, int, 0644);
  74 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
  75
  76
  77 /* Devices supported by this driver
  78  * .driver_info contains the init method used by the camera */
  79 static struct usb_device_id device_table[] = {
  80         {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
  81         {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
  82         {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
  83         {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
  84         {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
  85         {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
  86         {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
  87         {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
  88         {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
  89         {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
  90         {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
  91         {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
  92         {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
  93         {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
  94         {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
  95         {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
  96         {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
  97         {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
  98         {USB_DEVICE(0x041e, 0x405d), .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         memset(cap, 0, sizeof(*cap));
 429         strcpy(cap->driver, DRIVER_DESC);
 430         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
 431         return 0;
 432 }
 433
 434 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
 435                                      struct v4l2_input *i)
 436 {
 437         if (i->index != 0)
 438                 return -EINVAL;
 439         memset(i, 0, sizeof(*i));
 440         i->index = 0;
 441         strcpy(i->name, DRIVER_DESC " Camera");
 442         i->type = V4L2_INPUT_TYPE_CAMERA;
 443         return 0;
 444 }
 445
 446 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
 447                                   unsigned int *i)
 448 {
 449         *i = 0;
 450         return 0;
 451 }
 452
 453 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
 454                                   unsigned int i)
 455 {
 456         if (i != 0)
 457                 return -EINVAL;
 458         return 0;
 459 }
 460
 461 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
 462                                     struct v4l2_queryctrl *c)
 463 {
 464         struct video_device *vdev = video_devdata(file);
 465         struct zr364xx_camera *cam;
 466
 467         if (vdev == NULL)
 468                 return -ENODEV;
 469         cam = video_get_drvdata(vdev);
 470
 471         switch (c->id) {
 472         case V4L2_CID_BRIGHTNESS:
 473                 c->type = V4L2_CTRL_TYPE_INTEGER;
 474                 strcpy(c->name, "Brightness");
 475                 c->minimum = 0;
 476                 c->maximum = 127;
 477                 c->step = 1;
 478                 c->default_value = cam->brightness;
 479                 c->flags = 0;
 480                 break;
 481         default:
 482                 return -EINVAL;
 483         }
 484         return 0;
 485 }
 486
 487 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
 488                                  struct v4l2_control *c)
 489 {
 490         struct video_device *vdev = video_devdata(file);
 491         struct zr364xx_camera *cam;
 492
 493         if (vdev == NULL)
 494                 return -ENODEV;
 495         cam = video_get_drvdata(vdev);
 496
 497         switch (c->id) {
 498         case V4L2_CID_BRIGHTNESS:
 499                 cam->brightness = c->value;
 500                 break;
 501         default:
 502                 return -EINVAL;
 503         }
 504         return 0;
 505 }
 506
 507 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
 508                                  struct v4l2_control *c)
 509 {
 510         struct video_device *vdev = video_devdata(file);
 511         struct zr364xx_camera *cam;
 512
 513         if (vdev == NULL)
 514                 return -ENODEV;
 515         cam = video_get_drvdata(vdev);
 516
 517         switch (c->id) {
 518         case V4L2_CID_BRIGHTNESS:
 519                 c->value = cam->brightness;
 520                 break;
 521         default:
 522                 return -EINVAL;
 523         }
 524         return 0;
 525 }
 526
 527 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
 528                                        void *priv, struct v4l2_fmtdesc *f)
 529 {
 530         if (f->index > 0)
 531                 return -EINVAL;
 532         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 533                 return -EINVAL;
 534         memset(f, 0, sizeof(*f));
 535         f->index = 0;
 536         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 537         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 538         strcpy(f->description, "JPEG");
 539         f->pixelformat = V4L2_PIX_FMT_JPEG;
 540         return 0;
 541 }
 542
 543 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 544                                       struct v4l2_format *f)
 545 {
 546         struct video_device *vdev = video_devdata(file);
 547         struct zr364xx_camera *cam;
 548
 549         if (vdev == NULL)
 550                 return -ENODEV;
 551         cam = video_get_drvdata(vdev);
 552
 553         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 554                 return -EINVAL;
 555         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
 556                 return -EINVAL;
 557         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
 558             f->fmt.pix.field != V4L2_FIELD_NONE)
 559                 return -EINVAL;
 560         f->fmt.pix.field = V4L2_FIELD_NONE;
 561         f->fmt.pix.width = cam->width;
 562         f->fmt.pix.height = cam->height;
 563         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 564         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 565         f->fmt.pix.colorspace = 0;
 566         f->fmt.pix.priv = 0;
 567         return 0;
 568 }
 569
 570 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 571                                     struct v4l2_format *f)
 572 {
 573         struct video_device *vdev = video_devdata(file);
 574         struct zr364xx_camera *cam;
 575
 576         if (vdev == NULL)
 577                 return -ENODEV;
 578         cam = video_get_drvdata(vdev);
 579
 580         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 581                 return -EINVAL;
 582         memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
 583         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 584         f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
 585         f->fmt.pix.field = V4L2_FIELD_NONE;
 586         f->fmt.pix.width = cam->width;
 587         f->fmt.pix.height = cam->height;
 588         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 589         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 590         f->fmt.pix.colorspace = 0;
 591         f->fmt.pix.priv = 0;
 592         return 0;
 593 }
 594
 595 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 596                                     struct v4l2_format *f)
 597 {
 598         struct video_device *vdev = video_devdata(file);
 599         struct zr364xx_camera *cam;
 600
 601         if (vdev == NULL)
 602                 return -ENODEV;
 603         cam = video_get_drvdata(vdev);
 604
 605         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 606                 return -EINVAL;
 607         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
 608                 return -EINVAL;
 609         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
 610             f->fmt.pix.field != V4L2_FIELD_NONE)
 611                 return -EINVAL;
 612         f->fmt.pix.field = V4L2_FIELD_NONE;
 613         f->fmt.pix.width = cam->width;
 614         f->fmt.pix.height = cam->height;
 615         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
 616         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 617         f->fmt.pix.colorspace = 0;
 618         f->fmt.pix.priv = 0;
 619         DBG("ok!");
 620         return 0;
 621 }
 622
 623 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
 624                                    enum v4l2_buf_type type)
 625 {
 626         return 0;
 627 }
 628
 629 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
 630                                     enum v4l2_buf_type type)
 631 {
 632         return 0;
 633 }
 634
 635
 636 /* open the camera */
 637 static int zr364xx_open(struct file *file)
 638 {
 639         struct video_device *vdev = video_devdata(file);
 640         struct zr364xx_camera *cam = video_get_drvdata(vdev);
 641         struct usb_device *udev = cam->udev;
 642         int i, err;
 643
 644         DBG("zr364xx_open");
 645
 646         mutex_lock(&cam->lock);
 647
 648         if (cam->users) {
 649                 err = -EBUSY;
 650                 goto out;
 651         }
 652
 653         if (!cam->framebuf) {
 654                 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
 655                 if (!cam->framebuf) {
 656                         dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
 657                         err = -ENOMEM;
 658                         goto out;
 659                 }
 660         }
 661
 662         for (i = 0; init[cam->method][i].size != -1; i++) {
 663                 err =
 664                     send_control_msg(udev, 1, init[cam->method][i].value,
 665                                      0, init[cam->method][i].bytes,
 666                                      init[cam->method][i].size);
 667                 if (err < 0) {
 668                         dev_err(&cam->udev->dev,
 669                                 "error during open sequence: %d\n", i);
 670                         goto out;
 671                 }
 672         }
 673
 674         cam->skip = 2;
 675         cam->users++;
 676         file->private_data = vdev;
 677
 678         /* Added some delay here, since opening/closing the camera quickly,
 679          * like Ekiga does during its startup, can crash the webcam
 680          */
 681         mdelay(100);
 682         err = 0;
 683
 684 out:
 685         mutex_unlock(&cam->lock);
 686         return err;
 687 }
 688
 689
 690 /* release the camera */
 691 static int zr364xx_release(struct file *file)
 692 {
 693         struct video_device *vdev = video_devdata(file);
 694         struct zr364xx_camera *cam;
 695         struct usb_device *udev;
 696         int i, err;
 697
 698         DBG("zr364xx_release");
 699
 700         if (vdev == NULL)
 701                 return -ENODEV;
 702         cam = video_get_drvdata(vdev);
 703
 704         udev = cam->udev;
 705
 706         mutex_lock(&cam->lock);
 707
 708         cam->users--;
 709         file->private_data = NULL;
 710
 711         for (i = 0; i < 2; i++) {
 712                 err =
 713                     send_control_msg(udev, 1, init[cam->method][i].value,
 714                                      0, init[i][cam->method].bytes,
 715                                      init[cam->method][i].size);
 716                 if (err < 0) {
 717                         dev_err(&udev->dev, "error during release sequence\n");
 718                         goto out;
 719                 }
 720         }
 721
 722         /* Added some delay here, since opening/closing the camera quickly,
 723          * like Ekiga does during its startup, can crash the webcam
 724          */
 725         mdelay(100);
 726         err = 0;
 727
 728 out:
 729         mutex_unlock(&cam->lock);
 730         return err;
 731 }
 732
 733
 734 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
 735 {
 736         void *pos;
 737         unsigned long start = vma->vm_start;
 738         unsigned long size = vma->vm_end - vma->vm_start;
 739         struct video_device *vdev = video_devdata(file);
 740         struct zr364xx_camera *cam;
 741
 742         DBG("zr364xx_mmap: %ld\n", size);
 743
 744         if (vdev == NULL)
 745                 return -ENODEV;
 746         cam = video_get_drvdata(vdev);
 747
 748         pos = cam->framebuf;
 749         while (size > 0) {
 750                 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
 751                         return -EAGAIN;
 752                 start += PAGE_SIZE;
 753                 pos += PAGE_SIZE;
 754                 if (size > PAGE_SIZE)
 755                         size -= PAGE_SIZE;
 756                 else
 757                         size = 0;
 758         }
 759
 760         return 0;
 761 }
 762
 763
 764 static const struct v4l2_file_operations zr364xx_fops = {
 765         .owner = THIS_MODULE,
 766         .open = zr364xx_open,
 767         .release = zr364xx_release,
 768         .read = zr364xx_read,
 769         .mmap = zr364xx_mmap,
 770         .ioctl = video_ioctl2,
 771 };
 772
 773 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
 774         .vidioc_querycap        = zr364xx_vidioc_querycap,
 775         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
 776         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
 777         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
 778         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
 779         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
 780         .vidioc_g_input         = zr364xx_vidioc_g_input,
 781         .vidioc_s_input         = zr364xx_vidioc_s_input,
 782         .vidioc_streamon        = zr364xx_vidioc_streamon,
 783         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
 784         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
 785         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
 786         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
 787 };
 788
 789 static struct video_device zr364xx_template = {
 790         .name = DRIVER_DESC,
 791         .fops = &zr364xx_fops,
 792         .ioctl_ops = &zr364xx_ioctl_ops,
 793         .release = video_device_release,
 794         .minor = -1,
 795 };
 796
 797
 798
 799 /*******************/
 800 /* USB integration */
 801 /*******************/
 802
 803 static int zr364xx_probe(struct usb_interface *intf,
 804                          const struct usb_device_id *id)
 805 {
 806         struct usb_device *udev = interface_to_usbdev(intf);
 807         struct zr364xx_camera *cam = NULL;
 808         int err;
 809
 810         DBG("probing...");
 811
 812         dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
 813         dev_info(&intf->dev, "model %04x:%04x detected\n",
 814                  le16_to_cpu(udev->descriptor.idVendor),
 815                  le16_to_cpu(udev->descriptor.idProduct));
 816
 817         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
 818         if (cam == NULL) {
 819                 dev_err(&udev->dev, "cam: out of memory !\n");
 820                 return -ENOMEM;
 821         }
 822         /* save the init method used by this camera */
 823         cam->method = id->driver_info;
 824
 825         cam->vdev = video_device_alloc();
 826         if (cam->vdev == NULL) {
 827                 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
 828                 kfree(cam);
 829                 return -ENOMEM;
 830         }
 831         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
 832         video_set_drvdata(cam->vdev, cam);
 833         if (debug)
 834                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
 835
 836         cam->udev = udev;
 837
 838         if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
 839                 dev_info(&udev->dev, "cam->buffer: out of memory !\n");
 840                 video_device_release(cam->vdev);
 841                 kfree(cam);
 842                 return -ENODEV;
 843         }
 844
 845         switch (mode) {
 846         case 1:
 847                 dev_info(&udev->dev, "160x120 mode selected\n");
 848                 cam->width = 160;
 849                 cam->height = 120;
 850                 break;
 851         case 2:
 852                 dev_info(&udev->dev, "640x480 mode selected\n");
 853                 cam->width = 640;
 854                 cam->height = 480;
 855                 break;
 856         default:
 857                 dev_info(&udev->dev, "320x240 mode selected\n");
 858                 cam->width = 320;
 859                 cam->height = 240;
 860                 break;
 861         }
 862
 863         m0d1[0] = mode;
 864         m1[2].value = 0xf000 + mode;
 865         m2[1].value = 0xf000 + mode;
 866         header2[437] = cam->height / 256;
 867         header2[438] = cam->height % 256;
 868         header2[439] = cam->width / 256;
 869         header2[440] = cam->width % 256;
 870
 871         cam->nb = 0;
 872         cam->brightness = 64;
 873         mutex_init(&cam->lock);
 874
 875         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
 876         if (err) {
 877                 dev_err(&udev->dev, "video_register_device failed\n");
 878                 video_device_release(cam->vdev);
 879                 kfree(cam->buffer);
 880                 kfree(cam);
 881                 return err;
 882         }
 883
 884         usb_set_intfdata(intf, cam);
 885
 886         dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
 887                  cam->vdev->num);
 888         return 0;
 889 }
 890
 891
 892 static void zr364xx_disconnect(struct usb_interface *intf)
 893 {
 894         struct zr364xx_camera *cam = usb_get_intfdata(intf);
 895         usb_set_intfdata(intf, NULL);
 896         dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
 897         if (cam->vdev)
 898                 video_unregister_device(cam->vdev);
 899         cam->vdev = NULL;
 900         kfree(cam->buffer);
 901         if (cam->framebuf)
 902                 vfree(cam->framebuf);
 903         kfree(cam);
 904 }
 905
 906
 907
 908 /**********************/
 909 /* Module integration */
 910 /**********************/
 911
 912 static struct usb_driver zr364xx_driver = {
 913         .name = "zr364xx",
 914         .probe = zr364xx_probe,
 915         .disconnect = zr364xx_disconnect,
 916         .id_table = device_table
 917 };
 918
 919
 920 static int __init zr364xx_init(void)
 921 {
 922         int retval;
 923         retval = usb_register(&zr364xx_driver);
 924         if (retval)
 925                 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
 926         else
 927                 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 928         return retval;
 929 }
 930
 931
 932 static void __exit zr364xx_exit(void)
 933 {
 934         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
 935         usb_deregister(&zr364xx_driver);
 936 }
 937
 938
 939 module_init(zr364xx_init);
 940 module_exit(zr364xx_exit);
 941
 942 MODULE_AUTHOR(DRIVER_AUTHOR);
 943 MODULE_DESCRIPTION(DRIVER_DESC);
 944 MODULE_LICENSE("GPL");