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         err = video_exclusive_open(inode, file);
 647         if (err < 0)
 648                 return err;
 649
 650         if (!cam->framebuf) {
 651                 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
 652                 if (!cam->framebuf) {
 653                         info("vmalloc_32 failed!");
 654                         return -ENOMEM;
 655                 }
 656         }
 657
 658         mutex_lock(&cam->lock);
 659         for (i = 0; init[cam->method][i].size != -1; i++) {
 660                 err =
 661                     send_control_msg(udev, 1, init[cam->method][i].value,
 662                                      0, init[cam->method][i].bytes,
 663                                      init[cam->method][i].size);
 664                 if (err < 0) {
 665                         info("error during open sequence: %d", i);
 666                         mutex_unlock(&cam->lock);
 667                         return err;
 668                 }
 669         }
 670
 671         file->private_data = vdev;
 672
 673         /* Added some delay here, since opening/closing the camera quickly,
 674          * like Ekiga does during its startup, can crash the webcam
 675          */
 676         mdelay(100);
 677
 678         mutex_unlock(&cam->lock);
 679         return 0;
 680 }
 681
 682
 683 /* release the camera */
 684 static int zr364xx_release(struct inode *inode, struct file *file)
 685 {
 686         struct video_device *vdev = video_devdata(file);
 687         struct zr364xx_camera *cam;
 688         struct usb_device *udev;
 689         int i, err;
 690
 691         DBG("zr364xx_release");
 692
 693         if (vdev == NULL)
 694                 return -ENODEV;
 695         cam = video_get_drvdata(vdev);
 696
 697         udev = cam->udev;
 698
 699         mutex_lock(&cam->lock);
 700         for (i = 0; i < 2; i++) {
 701                 err =
 702                     send_control_msg(udev, 1, init[cam->method][i].value,
 703                                      0, init[i][cam->method].bytes,
 704                                      init[cam->method][i].size);
 705                 if (err < 0) {
 706                         info("error during release sequence");
 707                         mutex_unlock(&cam->lock);
 708                         return err;
 709                 }
 710         }
 711
 712         file->private_data = NULL;
 713         video_exclusive_release(inode, file);
 714
 715         /* Added some delay here, since opening/closing the camera quickly,
 716          * like Ekiga does during its startup, can crash the webcam
 717          */
 718         mdelay(100);
 719
 720         mutex_unlock(&cam->lock);
 721         return 0;
 722 }
 723
 724
 725 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
 726 {
 727         void *pos;
 728         unsigned long start = vma->vm_start;
 729         unsigned long size = vma->vm_end - vma->vm_start;
 730         struct video_device *vdev = video_devdata(file);
 731         struct zr364xx_camera *cam;
 732
 733         DBG("zr364xx_mmap: %ld\n", size);
 734
 735         if (vdev == NULL)
 736                 return -ENODEV;
 737         cam = video_get_drvdata(vdev);
 738
 739         pos = cam->framebuf;
 740         while (size > 0) {
 741                 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
 742                         return -EAGAIN;
 743                 start += PAGE_SIZE;
 744                 pos += PAGE_SIZE;
 745                 if (size > PAGE_SIZE)
 746                         size -= PAGE_SIZE;
 747                 else
 748                         size = 0;
 749         }
 750
 751         return 0;
 752 }
 753
 754
 755 static const struct file_operations zr364xx_fops = {
 756         .owner = THIS_MODULE,
 757         .open = zr364xx_open,
 758         .release = zr364xx_release,
 759         .read = zr364xx_read,
 760         .mmap = zr364xx_mmap,
 761         .ioctl = video_ioctl2,
 762         .llseek = no_llseek,
 763 };
 764
 765 static struct video_device zr364xx_template = {
 766         .owner = THIS_MODULE,
 767         .name = DRIVER_DESC,
 768         .type = VID_TYPE_CAPTURE,
 769         .fops = &zr364xx_fops,
 770         .release = video_device_release,
 771         .minor = -1,
 772
 773         .vidioc_querycap        = zr364xx_vidioc_querycap,
 774         .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
 775         .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
 776         .vidioc_s_fmt_vid_cap   = zr364xx_vidioc_s_fmt_vid_cap,
 777         .vidioc_g_fmt_vid_cap   = zr364xx_vidioc_g_fmt_vid_cap,
 778         .vidioc_enum_input      = zr364xx_vidioc_enum_input,
 779         .vidioc_g_input         = zr364xx_vidioc_g_input,
 780         .vidioc_s_input         = zr364xx_vidioc_s_input,
 781         .vidioc_streamon        = zr364xx_vidioc_streamon,
 782         .vidioc_streamoff       = zr364xx_vidioc_streamoff,
 783         .vidioc_queryctrl       = zr364xx_vidioc_queryctrl,
 784         .vidioc_g_ctrl          = zr364xx_vidioc_g_ctrl,
 785         .vidioc_s_ctrl          = zr364xx_vidioc_s_ctrl,
 786 };
 787
 788
 789
 790 /*******************/
 791 /* USB integration */
 792 /*******************/
 793
 794 static int zr364xx_probe(struct usb_interface *intf,
 795                          const struct usb_device_id *id)
 796 {
 797         struct usb_device *udev = interface_to_usbdev(intf);
 798         struct zr364xx_camera *cam = NULL;
 799         int err;
 800
 801         DBG("probing...");
 802
 803         info(DRIVER_DESC " compatible webcam plugged");
 804         info("model %04x:%04x detected", udev->descriptor.idVendor,
 805              udev->descriptor.idProduct);
 806
 807         cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
 808         if (cam == NULL) {
 809                 info("cam: out of memory !");
 810                 return -ENOMEM;
 811         }
 812         /* save the init method used by this camera */
 813         cam->method = id->driver_info;
 814
 815         cam->vdev = video_device_alloc();
 816         if (cam->vdev == NULL) {
 817                 info("cam->vdev: out of memory !");
 818                 kfree(cam);
 819                 return -ENOMEM;
 820         }
 821         memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
 822         video_set_drvdata(cam->vdev, cam);
 823         if (debug)
 824                 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
 825
 826         cam->udev = udev;
 827
 828         if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
 829                 info("cam->buffer: out of memory !");
 830                 video_device_release(cam->vdev);
 831                 kfree(cam);
 832                 return -ENODEV;
 833         }
 834
 835         switch (mode) {
 836         case 1:
 837                 info("160x120 mode selected");
 838                 cam->width = 160;
 839                 cam->height = 120;
 840                 break;
 841         case 2:
 842                 info("640x480 mode selected");
 843                 cam->width = 640;
 844                 cam->height = 480;
 845                 break;
 846         default:
 847                 info("320x240 mode selected");
 848                 cam->width = 320;
 849                 cam->height = 240;
 850                 break;
 851         }
 852
 853         m0d1[0] = mode;
 854         m1[2].value = 0xf000 + mode;
 855         m2[1].value = 0xf000 + mode;
 856         header2[437] = cam->height / 256;
 857         header2[438] = cam->height % 256;
 858         header2[439] = cam->width / 256;
 859         header2[440] = cam->width % 256;
 860
 861         cam->nb = 0;
 862         cam->brightness = 64;
 863         mutex_init(&cam->lock);
 864
 865         err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
 866         if (err) {
 867                 info("video_register_device failed");
 868                 video_device_release(cam->vdev);
 869                 kfree(cam->buffer);
 870                 kfree(cam);
 871                 return err;
 872         }
 873
 874         usb_set_intfdata(intf, cam);
 875
 876         info(DRIVER_DESC " controlling video device %d", cam->vdev->minor);
 877         return 0;
 878 }
 879
 880
 881 static void zr364xx_disconnect(struct usb_interface *intf)
 882 {
 883         struct zr364xx_camera *cam = usb_get_intfdata(intf);
 884         usb_set_intfdata(intf, NULL);
 885         dev_set_drvdata(&intf->dev, NULL);
 886         info(DRIVER_DESC " webcam unplugged");
 887         if (cam->vdev)
 888                 video_unregister_device(cam->vdev);
 889         cam->vdev = NULL;
 890         kfree(cam->buffer);
 891         if (cam->framebuf)
 892                 vfree(cam->framebuf);
 893         kfree(cam);
 894 }
 895
 896
 897
 898 /**********************/
 899 /* Module integration */
 900 /**********************/
 901
 902 static struct usb_driver zr364xx_driver = {
 903         .name = "zr364xx",
 904         .probe = zr364xx_probe,
 905         .disconnect = zr364xx_disconnect,
 906         .id_table = device_table
 907 };
 908
 909
 910 static int __init zr364xx_init(void)
 911 {
 912         int retval;
 913         retval = usb_register(&zr364xx_driver);
 914         if (retval)
 915                 info("usb_register failed!");
 916         else
 917                 info(DRIVER_DESC " module loaded");
 918         return retval;
 919 }
 920
 921
 922 static void __exit zr364xx_exit(void)
 923 {
 924         info(DRIVER_DESC " module unloaded");
 925         usb_deregister(&zr364xx_driver);
 926 }
 927
 928
 929 module_init(zr364xx_init);
 930 module_exit(zr364xx_exit);
 931
 932 MODULE_AUTHOR(DRIVER_AUTHOR);
 933 MODULE_DESCRIPTION(DRIVER_DESC);
 934 MODULE_LICENSE("GPL");