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