git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/zr364xx.c

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