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