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