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