drivers/usb/media/zc0301_core.c

   1 /***************************************************************************
   2  * Video4Linux2 driver for ZC0301 Image Processor and Control Chip         *
   3  *                                                                         *
   4  * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it>       *
   5  *                                                                         *
   6  * Informations about the chip internals needed to enable the I2C protocol *
   7  * have been taken from the documentation of the ZC030x Video4Linux1       *
   8  * driver written by Andrew Birkett <andy@nobugs.org>                      *
   9  *                                                                         *
  10  * This program is free software; you can redistribute it and/or modify    *
  11  * it under the terms of the GNU General Public License as published by    *
  12  * the Free Software Foundation; either version 2 of the License, or       *
  13  * (at your option) any later version.                                     *
  14  *                                                                         *
  15  * This program is distributed in the hope that it will be useful,         *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  18  * GNU General Public License for more details.                            *
  19  *                                                                         *
  20  * You should have received a copy of the GNU General Public License       *
  21  * along with this program; if not, write to the Free Software             *
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
  23  ***************************************************************************/
  24
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/kernel.h>
  28 #include <linux/param.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/errno.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/device.h>
  34 #include <linux/fs.h>
  35 #include <linux/delay.h>
  36 #include <linux/stddef.h>
  37 #include <linux/compiler.h>
  38 #include <linux/ioctl.h>
  39 #include <linux/poll.h>
  40 #include <linux/stat.h>
  41 #include <linux/mm.h>
  42 #include <linux/vmalloc.h>
  43 #include <linux/page-flags.h>
  44 #include <linux/byteorder/generic.h>
  45 #include <asm/page.h>
  46 #include <asm/uaccess.h>
  47
  48 #include "zc0301.h"
  49
  50 /*****************************************************************************/
  51
  52 #define ZC0301_MODULE_NAME    "V4L2 driver for ZC0301 "                       \
  53                               "Image Processor and Control Chip"
  54 #define ZC0301_MODULE_AUTHOR  "(C) 2006 Luca Risolia"
  55 #define ZC0301_AUTHOR_EMAIL   "<luca.risolia@studio.unibo.it>"
  56 #define ZC0301_MODULE_LICENSE "GPL"
  57 #define ZC0301_MODULE_VERSION "1:1.01"
  58 #define ZC0301_MODULE_VERSION_CODE  KERNEL_VERSION(1, 0, 1)
  59
  60 /*****************************************************************************/
  61
  62 MODULE_DEVICE_TABLE(usb, zc0301_id_table);
  63
  64 MODULE_AUTHOR(ZC0301_MODULE_AUTHOR " " ZC0301_AUTHOR_EMAIL);
  65 MODULE_DESCRIPTION(ZC0301_MODULE_NAME);
  66 MODULE_VERSION(ZC0301_MODULE_VERSION);
  67 MODULE_LICENSE(ZC0301_MODULE_LICENSE);
  68
  69 static short video_nr[] = {[0 ... ZC0301_MAX_DEVICES-1] = -1};
  70 module_param_array(video_nr, short, NULL, 0444);
  71 MODULE_PARM_DESC(video_nr,
  72                  "\n<-1|n[,...]> Specify V4L2 minor mode number."
  73                  "\n -1 = use next available (default)"
  74                  "\n  n = use minor number n (integer >= 0)"
  75                  "\nYou can specify up to "
  76                  __MODULE_STRING(ZC0301_MAX_DEVICES) " cameras this way."
  77                  "\nFor example:"
  78                  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
  79                  "\nthe second registered camera and use auto for the first"
  80                  "\none and for every other camera."
  81                  "\n");
  82
  83 static short force_munmap[] = {[0 ... ZC0301_MAX_DEVICES-1] =
  84                                ZC0301_FORCE_MUNMAP};
  85 module_param_array(force_munmap, bool, NULL, 0444);
  86 MODULE_PARM_DESC(force_munmap,
  87                  "\n<0|1[,...]> Force the application to unmap previously"
  88                  "\nmapped buffer memory before calling any VIDIOC_S_CROP or"
  89                  "\nVIDIOC_S_FMT ioctl's. Not all the applications support"
  90                  "\nthis feature. This parameter is specific for each"
  91                  "\ndetected camera."
  92                  "\n 0 = do not force memory unmapping"
  93                  "\n 1 = force memory unmapping (save memory)"
  94                  "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
  95                  "\n");
  96
  97 #ifdef ZC0301_DEBUG
  98 static unsigned short debug = ZC0301_DEBUG_LEVEL;
  99 module_param(debug, ushort, 0644);
 100 MODULE_PARM_DESC(debug,
 101                  "\n<n> Debugging information level, from 0 to 3:"
 102                  "\n0 = none (use carefully)"
 103                  "\n1 = critical errors"
 104                  "\n2 = significant informations"
 105                  "\n3 = more verbose messages"
 106                  "\nLevel 3 is useful for testing only, when only "
 107                  "one device is used."
 108                  "\nDefault value is "__MODULE_STRING(ZC0301_DEBUG_LEVEL)"."
 109                  "\n");
 110 #endif
 111
 112 /*****************************************************************************/
 113
 114 static u32
 115 zc0301_request_buffers(struct zc0301_device* cam, u32 count,
 116                        enum zc0301_io_method io)
 117 {
 118         struct v4l2_pix_format* p = &(cam->sensor->pix_format);
 119         struct v4l2_rect* r = &(cam->sensor->cropcap.bounds);
 120         const size_t imagesize = cam->module_param.force_munmap ||
 121                                  io == IO_READ ?
 122                                  (p->width * p->height * p->priv) / 8 :
 123                                  (r->width * r->height * p->priv) / 8;
 124         void* buff = NULL;
 125         u32 i;
 126
 127         if (count > ZC0301_MAX_FRAMES)
 128                 count = ZC0301_MAX_FRAMES;
 129
 130         cam->nbuffers = count;
 131         while (cam->nbuffers > 0) {
 132                 if ((buff = vmalloc_32(cam->nbuffers * PAGE_ALIGN(imagesize))))
 133                         break;
 134                 cam->nbuffers--;
 135         }
 136
 137         for (i = 0; i < cam->nbuffers; i++) {
 138                 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
 139                 cam->frame[i].buf.index = i;
 140                 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
 141                 cam->frame[i].buf.length = imagesize;
 142                 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 143                 cam->frame[i].buf.sequence = 0;
 144                 cam->frame[i].buf.field = V4L2_FIELD_NONE;
 145                 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
 146                 cam->frame[i].buf.flags = 0;
 147         }
 148
 149         return cam->nbuffers;
 150 }
 151
 152
 153 static void zc0301_release_buffers(struct zc0301_device* cam)
 154 {
 155         if (cam->nbuffers) {
 156                 vfree(cam->frame[0].bufmem);
 157                 cam->nbuffers = 0;
 158         }
 159         cam->frame_current = NULL;
 160 }
 161
 162
 163 static void zc0301_empty_framequeues(struct zc0301_device* cam)
 164 {
 165         u32 i;
 166
 167         INIT_LIST_HEAD(&cam->inqueue);
 168         INIT_LIST_HEAD(&cam->outqueue);
 169
 170         for (i = 0; i < ZC0301_MAX_FRAMES; i++) {
 171                 cam->frame[i].state = F_UNUSED;
 172                 cam->frame[i].buf.bytesused = 0;
 173         }
 174 }
 175
 176
 177 static void zc0301_requeue_outqueue(struct zc0301_device* cam)
 178 {
 179         struct zc0301_frame_t *i;
 180
 181         list_for_each_entry(i, &cam->outqueue, frame) {
 182                 i->state = F_QUEUED;
 183                 list_add(&i->frame, &cam->inqueue);
 184         }
 185
 186         INIT_LIST_HEAD(&cam->outqueue);
 187 }
 188
 189
 190 static void zc0301_queue_unusedframes(struct zc0301_device* cam)
 191 {
 192         unsigned long lock_flags;
 193         u32 i;
 194
 195         for (i = 0; i < cam->nbuffers; i++)
 196                 if (cam->frame[i].state == F_UNUSED) {
 197                         cam->frame[i].state = F_QUEUED;
 198                         spin_lock_irqsave(&cam->queue_lock, lock_flags);
 199                         list_add_tail(&cam->frame[i].frame, &cam->inqueue);
 200                         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 201                 }
 202 }
 203
 204 /*****************************************************************************/
 205
 206 int zc0301_write_reg(struct zc0301_device* cam, u16 index, u16 value)
 207 {
 208         struct usb_device* udev = cam->usbdev;
 209         int res;
 210
 211         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0xa0, 0x40,
 212                               value, index, NULL, 0, ZC0301_CTRL_TIMEOUT);
 213         if (res < 0) {
 214                 DBG(3, "Failed to write a register (index 0x%04X, "
 215                        "value 0x%02X, error %d)",index, value, res);
 216                 return -1;
 217         }
 218
 219         return 0;
 220 }
 221
 222
 223 int zc0301_read_reg(struct zc0301_device* cam, u16 index)
 224 {
 225         struct usb_device* udev = cam->usbdev;
 226         u8* buff = cam->control_buffer;
 227         int res;
 228
 229         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0xa1, 0xc0,
 230                               0x0001, index, buff, 1, ZC0301_CTRL_TIMEOUT);
 231         if (res < 0)
 232                 DBG(3, "Failed to read a register (index 0x%04X, error %d)",
 233                     index, res);
 234
 235         PDBGG("Read: index 0x%04X, value: 0x%04X", index, (int)(*buff));
 236
 237         return (res >= 0) ? (int)(*buff) : -1;
 238 }
 239
 240
 241 int zc0301_i2c_read(struct zc0301_device* cam, u16 address, u8 length)
 242 {
 243         int err = 0, res, r0, r1;
 244
 245         err += zc0301_write_reg(cam, 0x0092, address);
 246         err += zc0301_write_reg(cam, 0x0090, 0x02);
 247
 248         msleep(1);
 249
 250         res = zc0301_read_reg(cam, 0x0091);
 251         if (res < 0)
 252                 err += res;
 253         r0 = zc0301_read_reg(cam, 0x0095);
 254         if (r0 < 0)
 255                 err += r0;
 256         r1 = zc0301_read_reg(cam, 0x0096);
 257         if (r1 < 0)
 258                 err += r1;
 259
 260         res = (length <= 1) ? r0 : r0 | (r1 << 8);
 261
 262         if (err)
 263                 DBG(3, "I2C read failed at address 0x%04X, value: 0x%04X",
 264                     address, res);
 265
 266
 267         PDBGG("I2C read: address 0x%04X, value: 0x%04X", address, res);
 268
 269         return err ? -1 : res;
 270 }
 271
 272
 273 int zc0301_i2c_write(struct zc0301_device* cam, u16 address, u16 value)
 274 {
 275         int err = 0, res;
 276
 277         err += zc0301_write_reg(cam, 0x0092, address);
 278         err += zc0301_write_reg(cam, 0x0093, value & 0xff);
 279         err += zc0301_write_reg(cam, 0x0094, value >> 8);
 280         err += zc0301_write_reg(cam, 0x0090, 0x01);
 281
 282         msleep(1);
 283
 284         res = zc0301_read_reg(cam, 0x0091);
 285         if (res < 0)
 286                 err += res;
 287
 288         if (err)
 289                 DBG(3, "I2C write failed at address 0x%04X, value: 0x%04X",
 290                     address, value);
 291
 292         PDBGG("I2C write: address 0x%04X, value: 0x%04X", address, value);
 293
 294         return err ? -1 : 0;
 295 }
 296
 297 /*****************************************************************************/
 298
 299 static void zc0301_urb_complete(struct urb *urb, struct pt_regs* regs)
 300 {
 301         struct zc0301_device* cam = urb->context;
 302         struct zc0301_frame_t** f;
 303         size_t imagesize;
 304         u8 i;
 305         int err = 0;
 306
 307         if (urb->status == -ENOENT)
 308                 return;
 309
 310         f = &cam->frame_current;
 311
 312         if (cam->stream == STREAM_INTERRUPT) {
 313                 cam->stream = STREAM_OFF;
 314                 if ((*f))
 315                         (*f)->state = F_QUEUED;
 316                 DBG(3, "Stream interrupted");
 317                 wake_up(&cam->wait_stream);
 318         }
 319
 320         if (cam->state & DEV_DISCONNECTED)
 321                 return;
 322
 323         if (cam->state & DEV_MISCONFIGURED) {
 324                 wake_up_interruptible(&cam->wait_frame);
 325                 return;
 326         }
 327
 328         if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
 329                 goto resubmit_urb;
 330
 331         if (!(*f))
 332                 (*f) = list_entry(cam->inqueue.next, struct zc0301_frame_t,
 333                                   frame);
 334
 335         imagesize = (cam->sensor->pix_format.width *
 336                      cam->sensor->pix_format.height *
 337                      cam->sensor->pix_format.priv) / 8;
 338
 339         for (i = 0; i < urb->number_of_packets; i++) {
 340                 unsigned int len, status;
 341                 void *pos;
 342                 u16* soi;
 343                 u8 sof;
 344
 345                 len = urb->iso_frame_desc[i].actual_length;
 346                 status = urb->iso_frame_desc[i].status;
 347                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 348
 349                 if (status) {
 350                         DBG(3, "Error in isochronous frame");
 351                         (*f)->state = F_ERROR;
 352                         continue;
 353                 }
 354
 355                 sof = (*(soi = pos) == 0xd8ff);
 356
 357                 PDBGG("Isochrnous frame: length %u, #%u i,", len, i);
 358
 359                 if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR)
 360 start_of_frame:
 361                         if (sof) {
 362                                 (*f)->state = F_GRABBING;
 363                                 (*f)->buf.bytesused = 0;
 364                                 do_gettimeofday(&(*f)->buf.timestamp);
 365                                 DBG(3, "SOF detected: new video frame");
 366                         }
 367
 368                 if ((*f)->state == F_GRABBING) {
 369                         if (sof && (*f)->buf.bytesused)
 370                                         goto end_of_frame;
 371
 372                         if ((*f)->buf.bytesused + len > imagesize) {
 373                                 DBG(3, "Video frame size exceeded");
 374                                 (*f)->state = F_ERROR;
 375                                 continue;
 376                         }
 377
 378                         memcpy((*f)->bufmem+(*f)->buf.bytesused, pos, len);
 379                         (*f)->buf.bytesused += len;
 380
 381                         if ((*f)->buf.bytesused == imagesize) {
 382                                 u32 b;
 383 end_of_frame:
 384                                 b = (*f)->buf.bytesused;
 385                                 (*f)->state = F_DONE;
 386                                 (*f)->buf.sequence= ++cam->frame_count;
 387                                 spin_lock(&cam->queue_lock);
 388                                 list_move_tail(&(*f)->frame, &cam->outqueue);
 389                                 if (!list_empty(&cam->inqueue))
 390                                         (*f) = list_entry(cam->inqueue.next,
 391                                                        struct zc0301_frame_t,
 392                                                           frame);
 393                                 else
 394                                         (*f) = NULL;
 395                                 spin_unlock(&cam->queue_lock);
 396                                 DBG(3, "Video frame captured: : %lu bytes",
 397                                        (unsigned long)(b));
 398
 399                                 if (!(*f))
 400                                         goto resubmit_urb;
 401
 402                                 if (sof)
 403                                         goto start_of_frame;
 404                         }
 405                 }
 406         }
 407
 408 resubmit_urb:
 409         urb->dev = cam->usbdev;
 410         err = usb_submit_urb(urb, GFP_ATOMIC);
 411         if (err < 0 && err != -EPERM) {
 412                 cam->state |= DEV_MISCONFIGURED;
 413                 DBG(1, "usb_submit_urb() failed");
 414         }
 415
 416         wake_up_interruptible(&cam->wait_frame);
 417 }
 418
 419
 420 static int zc0301_start_transfer(struct zc0301_device* cam)
 421 {
 422         struct usb_device *udev = cam->usbdev;
 423         struct urb* urb;
 424         const unsigned int wMaxPacketSize[] = {0, 128, 192, 256, 384,
 425                                                512, 768, 1023};
 426         const unsigned int psz = wMaxPacketSize[ZC0301_ALTERNATE_SETTING];
 427         s8 i, j;
 428         int err = 0;
 429
 430         for (i = 0; i < ZC0301_URBS; i++) {
 431                 cam->transfer_buffer[i] = kzalloc(ZC0301_ISO_PACKETS * psz,
 432                                                   GFP_KERNEL);
 433                 if (!cam->transfer_buffer[i]) {
 434                         err = -ENOMEM;
 435                         DBG(1, "Not enough memory");
 436                         goto free_buffers;
 437                 }
 438         }
 439
 440         for (i = 0; i < ZC0301_URBS; i++) {
 441                 urb = usb_alloc_urb(ZC0301_ISO_PACKETS, GFP_KERNEL);
 442                 cam->urb[i] = urb;
 443                 if (!urb) {
 444                         err = -ENOMEM;
 445                         DBG(1, "usb_alloc_urb() failed");
 446                         goto free_urbs;
 447                 }
 448                 urb->dev = udev;
 449                 urb->context = cam;
 450                 urb->pipe = usb_rcvisocpipe(udev, 1);
 451                 urb->transfer_flags = URB_ISO_ASAP;
 452                 urb->number_of_packets = ZC0301_ISO_PACKETS;
 453                 urb->complete = zc0301_urb_complete;
 454                 urb->transfer_buffer = cam->transfer_buffer[i];
 455                 urb->transfer_buffer_length = psz * ZC0301_ISO_PACKETS;
 456                 urb->interval = 1;
 457                 for (j = 0; j < ZC0301_ISO_PACKETS; j++) {
 458                         urb->iso_frame_desc[j].offset = psz * j;
 459                         urb->iso_frame_desc[j].length = psz;
 460                 }
 461         }
 462
 463         err = usb_set_interface(udev, 0, ZC0301_ALTERNATE_SETTING);
 464         if (err) {
 465                 DBG(1, "usb_set_interface() failed");
 466                 goto free_urbs;
 467         }
 468
 469         cam->frame_current = NULL;
 470
 471         for (i = 0; i < ZC0301_URBS; i++) {
 472                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 473                 if (err) {
 474                         for (j = i-1; j >= 0; j--)
 475                                 usb_kill_urb(cam->urb[j]);
 476                         DBG(1, "usb_submit_urb() failed, error %d", err);
 477                         goto free_urbs;
 478                 }
 479         }
 480
 481         return 0;
 482
 483 free_urbs:
 484         for (i = 0; (i < ZC0301_URBS) &&  cam->urb[i]; i++)
 485                 usb_free_urb(cam->urb[i]);
 486
 487 free_buffers:
 488         for (i = 0; (i < ZC0301_URBS) && cam->transfer_buffer[i]; i++)
 489                 kfree(cam->transfer_buffer[i]);
 490
 491         return err;
 492 }
 493
 494
 495 static int zc0301_stop_transfer(struct zc0301_device* cam)
 496 {
 497         struct usb_device *udev = cam->usbdev;
 498         s8 i;
 499         int err = 0;
 500
 501         if (cam->state & DEV_DISCONNECTED)
 502                 return 0;
 503
 504         for (i = ZC0301_URBS-1; i >= 0; i--) {
 505                 usb_kill_urb(cam->urb[i]);
 506                 usb_free_urb(cam->urb[i]);
 507                 kfree(cam->transfer_buffer[i]);
 508         }
 509
 510         err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 511         if (err)
 512                 DBG(3, "usb_set_interface() failed");
 513
 514         return err;
 515 }
 516
 517
 518 static int zc0301_stream_interrupt(struct zc0301_device* cam)
 519 {
 520         long timeout;
 521
 522         cam->stream = STREAM_INTERRUPT;
 523         timeout = wait_event_timeout(cam->wait_stream,
 524                                      (cam->stream == STREAM_OFF) ||
 525                                      (cam->state & DEV_DISCONNECTED),
 526                                      ZC0301_URB_TIMEOUT);
 527         if (cam->state & DEV_DISCONNECTED)
 528                 return -ENODEV;
 529         else if (cam->stream != STREAM_OFF) {
 530                 cam->state |= DEV_MISCONFIGURED;
 531                 DBG(1, "URB timeout reached. The camera is misconfigured. To "
 532                        "use it, close and open /dev/video%d again.",
 533                     cam->v4ldev->minor);
 534                 return -EIO;
 535         }
 536
 537         return 0;
 538 }
 539
 540 /*****************************************************************************/
 541
 542 static int
 543 zc0301_set_compression(struct zc0301_device* cam,
 544                        struct v4l2_jpegcompression* compression)
 545 {
 546         int r, err = 0;
 547
 548         if ((r = zc0301_read_reg(cam, 0x0008)) < 0)
 549                 err += r;
 550         err += zc0301_write_reg(cam, 0x0008, r | 0x11 | compression->quality);
 551
 552         return err ? -EIO : 0;
 553 }
 554
 555
 556 static int zc0301_init(struct zc0301_device* cam)
 557 {
 558         struct zc0301_sensor* s = cam->sensor;
 559         struct v4l2_control ctrl;
 560         struct v4l2_queryctrl *qctrl;
 561         struct v4l2_rect* rect;
 562         u8 i = 0;
 563         int err = 0;
 564
 565         if (!(cam->state & DEV_INITIALIZED)) {
 566                 init_waitqueue_head(&cam->open);
 567                 qctrl = s->qctrl;
 568                 rect = &(s->cropcap.defrect);
 569                 cam->compression.quality = ZC0301_COMPRESSION_QUALITY;
 570         } else { /* use current values */
 571                 qctrl = s->_qctrl;
 572                 rect = &(s->_rect);
 573         }
 574
 575         if (s->init) {
 576                 err = s->init(cam);
 577                 if (err) {
 578                         DBG(3, "Sensor initialization failed");
 579                         return err;
 580                 }
 581         }
 582
 583         if ((err = zc0301_set_compression(cam, &cam->compression))) {
 584                 DBG(3, "set_compression() failed");
 585                 return err;
 586         }
 587
 588         if (s->set_crop)
 589                 if ((err = s->set_crop(cam, rect))) {
 590                         DBG(3, "set_crop() failed");
 591                         return err;
 592                 }
 593
 594         if (s->set_ctrl) {
 595                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
 596                         if (s->qctrl[i].id != 0 &&
 597                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
 598                                 ctrl.id = s->qctrl[i].id;
 599                                 ctrl.value = qctrl[i].default_value;
 600                                 err = s->set_ctrl(cam, &ctrl);
 601                                 if (err) {
 602                                         DBG(3, "Set %s control failed",
 603                                             s->qctrl[i].name);
 604                                         return err;
 605                                 }
 606                                 DBG(3, "Image sensor supports '%s' control",
 607                                     s->qctrl[i].name);
 608                         }
 609         }
 610
 611         if (!(cam->state & DEV_INITIALIZED)) {
 612                 mutex_init(&cam->fileop_mutex);
 613                 spin_lock_init(&cam->queue_lock);
 614                 init_waitqueue_head(&cam->wait_frame);
 615                 init_waitqueue_head(&cam->wait_stream);
 616                 cam->nreadbuffers = 2;
 617                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
 618                 memcpy(&(s->_rect), &(s->cropcap.defrect),
 619                        sizeof(struct v4l2_rect));
 620                 cam->state |= DEV_INITIALIZED;
 621         }
 622
 623         DBG(2, "Initialization succeeded");
 624         return 0;
 625 }
 626
 627
 628 static void zc0301_release_resources(struct zc0301_device* cam)
 629 {
 630         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
 631         video_set_drvdata(cam->v4ldev, NULL);
 632         video_unregister_device(cam->v4ldev);
 633         kfree(cam->control_buffer);
 634 }
 635
 636 /*****************************************************************************/
 637
 638 static int zc0301_open(struct inode* inode, struct file* filp)
 639 {
 640         struct zc0301_device* cam;
 641         int err = 0;
 642
 643         /*
 644            This is the only safe way to prevent race conditions with
 645            disconnect
 646         */
 647         if (!down_read_trylock(&zc0301_disconnect))
 648                 return -ERESTARTSYS;
 649
 650         cam = video_get_drvdata(video_devdata(filp));
 651
 652         if (mutex_lock_interruptible(&cam->dev_mutex)) {
 653                 up_read(&zc0301_disconnect);
 654                 return -ERESTARTSYS;
 655         }
 656
 657         if (cam->users) {
 658                 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor);
 659                 if ((filp->f_flags & O_NONBLOCK) ||
 660                     (filp->f_flags & O_NDELAY)) {
 661                         err = -EWOULDBLOCK;
 662                         goto out;
 663                 }
 664                 mutex_unlock(&cam->dev_mutex);
 665                 err = wait_event_interruptible_exclusive(cam->open,
 666                                                   cam->state & DEV_DISCONNECTED
 667                                                          || !cam->users);
 668                 if (err) {
 669                         up_read(&zc0301_disconnect);
 670                         return err;
 671                 }
 672                 if (cam->state & DEV_DISCONNECTED) {
 673                         up_read(&zc0301_disconnect);
 674                         return -ENODEV;
 675                 }
 676                 mutex_lock(&cam->dev_mutex);
 677         }
 678
 679
 680         if (cam->state & DEV_MISCONFIGURED) {
 681                 err = zc0301_init(cam);
 682                 if (err) {
 683                         DBG(1, "Initialization failed again. "
 684                                "I will retry on next open().");
 685                         goto out;
 686                 }
 687                 cam->state &= ~DEV_MISCONFIGURED;
 688         }
 689
 690         if ((err = zc0301_start_transfer(cam)))
 691                 goto out;
 692
 693         filp->private_data = cam;
 694         cam->users++;
 695         cam->io = IO_NONE;
 696         cam->stream = STREAM_OFF;
 697         cam->nbuffers = 0;
 698         cam->frame_count = 0;
 699         zc0301_empty_framequeues(cam);
 700
 701         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);
 702
 703 out:
 704         mutex_unlock(&cam->dev_mutex);
 705         up_read(&zc0301_disconnect);
 706         return err;
 707 }
 708
 709
 710 static int zc0301_release(struct inode* inode, struct file* filp)
 711 {
 712         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
 713
 714         mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */
 715
 716         zc0301_stop_transfer(cam);
 717
 718         zc0301_release_buffers(cam);
 719
 720         if (cam->state & DEV_DISCONNECTED) {
 721                 zc0301_release_resources(cam);
 722                 mutex_unlock(&cam->dev_mutex);
 723                 kfree(cam);
 724                 return 0;
 725         }
 726
 727         cam->users--;
 728         wake_up_interruptible_nr(&cam->open, 1);
 729
 730         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);
 731
 732         mutex_unlock(&cam->dev_mutex);
 733
 734         return 0;
 735 }
 736
 737
 738 static ssize_t
 739 zc0301_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
 740 {
 741         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
 742         struct zc0301_frame_t* f, * i;
 743         unsigned long lock_flags;
 744         long timeout;
 745         int err = 0;
 746
 747         if (mutex_lock_interruptible(&cam->fileop_mutex))
 748                 return -ERESTARTSYS;
 749
 750         if (cam->state & DEV_DISCONNECTED) {
 751                 DBG(1, "Device not present");
 752                 mutex_unlock(&cam->fileop_mutex);
 753                 return -ENODEV;
 754         }
 755
 756         if (cam->state & DEV_MISCONFIGURED) {
 757                 DBG(1, "The camera is misconfigured. Close and open it "
 758                        "again.");
 759                 mutex_unlock(&cam->fileop_mutex);
 760                 return -EIO;
 761         }
 762
 763         if (cam->io == IO_MMAP) {
 764                 DBG(3, "Close and open the device again to choose the read "
 765                        "method");
 766                 mutex_unlock(&cam->fileop_mutex);
 767                 return -EINVAL;
 768         }
 769
 770         if (cam->io == IO_NONE) {
 771                 if (!zc0301_request_buffers(cam, cam->nreadbuffers, IO_READ)) {
 772                         DBG(1, "read() failed, not enough memory");
 773                         mutex_unlock(&cam->fileop_mutex);
 774                         return -ENOMEM;
 775                 }
 776                 cam->io = IO_READ;
 777                 cam->stream = STREAM_ON;
 778         }
 779
 780         if (list_empty(&cam->inqueue)) {
 781                 if (!list_empty(&cam->outqueue))
 782                         zc0301_empty_framequeues(cam);
 783                 zc0301_queue_unusedframes(cam);
 784         }
 785
 786         if (!count) {
 787                 mutex_unlock(&cam->fileop_mutex);
 788                 return 0;
 789         }
 790
 791         if (list_empty(&cam->outqueue)) {
 792                 if (filp->f_flags & O_NONBLOCK) {
 793                         mutex_unlock(&cam->fileop_mutex);
 794                         return -EAGAIN;
 795                 }
 796                 timeout = wait_event_interruptible_timeout
 797                           ( cam->wait_frame,
 798                             (!list_empty(&cam->outqueue)) ||
 799                             (cam->state & DEV_DISCONNECTED) ||
 800                             (cam->state & DEV_MISCONFIGURED),
 801                             ZC0301_FRAME_TIMEOUT );
 802                 if (timeout < 0) {
 803                         mutex_unlock(&cam->fileop_mutex);
 804                         return timeout;
 805                 }
 806                 if (cam->state & DEV_DISCONNECTED) {
 807                         mutex_unlock(&cam->fileop_mutex);
 808                         return -ENODEV;
 809                 }
 810                 if (!timeout || (cam->state & DEV_MISCONFIGURED)) {
 811                         mutex_unlock(&cam->fileop_mutex);
 812                         return -EIO;
 813                 }
 814         }
 815
 816         f = list_entry(cam->outqueue.prev, struct zc0301_frame_t, frame);
 817
 818         if (count > f->buf.bytesused)
 819                 count = f->buf.bytesused;
 820
 821         if (copy_to_user(buf, f->bufmem, count)) {
 822                 err = -EFAULT;
 823                 goto exit;
 824         }
 825         *f_pos += count;
 826
 827 exit:
 828         spin_lock_irqsave(&cam->queue_lock, lock_flags);
 829         list_for_each_entry(i, &cam->outqueue, frame)
 830                 i->state = F_UNUSED;
 831         INIT_LIST_HEAD(&cam->outqueue);
 832         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 833
 834         zc0301_queue_unusedframes(cam);
 835
 836         PDBGG("Frame #%lu, bytes read: %zu",
 837               (unsigned long)f->buf.index, count);
 838
 839         mutex_unlock(&cam->fileop_mutex);
 840
 841         return err ? err : count;
 842 }
 843
 844
 845 static unsigned int zc0301_poll(struct file *filp, poll_table *wait)
 846 {
 847         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
 848         struct zc0301_frame_t* f;
 849         unsigned long lock_flags;
 850         unsigned int mask = 0;
 851
 852         if (mutex_lock_interruptible(&cam->fileop_mutex))
 853                 return POLLERR;
 854
 855         if (cam->state & DEV_DISCONNECTED) {
 856                 DBG(1, "Device not present");
 857                 goto error;
 858         }
 859
 860         if (cam->state & DEV_MISCONFIGURED) {
 861                 DBG(1, "The camera is misconfigured. Close and open it "
 862                        "again.");
 863                 goto error;
 864         }
 865
 866         if (cam->io == IO_NONE) {
 867                 if (!zc0301_request_buffers(cam, cam->nreadbuffers, IO_READ)) {
 868                         DBG(1, "poll() failed, not enough memory");
 869                         goto error;
 870                 }
 871                 cam->io = IO_READ;
 872                 cam->stream = STREAM_ON;
 873         }
 874
 875         if (cam->io == IO_READ) {
 876                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
 877                 list_for_each_entry(f, &cam->outqueue, frame)
 878                         f->state = F_UNUSED;
 879                 INIT_LIST_HEAD(&cam->outqueue);
 880                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 881                 zc0301_queue_unusedframes(cam);
 882         }
 883
 884         poll_wait(filp, &cam->wait_frame, wait);
 885
 886         if (!list_empty(&cam->outqueue))
 887                 mask |= POLLIN | POLLRDNORM;
 888
 889         mutex_unlock(&cam->fileop_mutex);
 890
 891         return mask;
 892
 893 error:
 894         mutex_unlock(&cam->fileop_mutex);
 895         return POLLERR;
 896 }
 897
 898
 899 static void zc0301_vm_open(struct vm_area_struct* vma)
 900 {
 901         struct zc0301_frame_t* f = vma->vm_private_data;
 902         f->vma_use_count++;
 903 }
 904
 905
 906 static void zc0301_vm_close(struct vm_area_struct* vma)
 907 {
 908         /* NOTE: buffers are not freed here */
 909         struct zc0301_frame_t* f = vma->vm_private_data;
 910         f->vma_use_count--;
 911 }
 912
 913
 914 static struct vm_operations_struct zc0301_vm_ops = {
 915         .open = zc0301_vm_open,
 916         .close = zc0301_vm_close,
 917 };
 918
 919
 920 static int zc0301_mmap(struct file* filp, struct vm_area_struct *vma)
 921 {
 922         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
 923         unsigned long size = vma->vm_end - vma->vm_start,
 924                       start = vma->vm_start;
 925         void *pos;
 926         u32 i;
 927
 928         if (mutex_lock_interruptible(&cam->fileop_mutex))
 929                 return -ERESTARTSYS;
 930
 931         if (cam->state & DEV_DISCONNECTED) {
 932                 DBG(1, "Device not present");
 933                 mutex_unlock(&cam->fileop_mutex);
 934                 return -ENODEV;
 935         }
 936
 937         if (cam->state & DEV_MISCONFIGURED) {
 938                 DBG(1, "The camera is misconfigured. Close and open it "
 939                        "again.");
 940                 mutex_unlock(&cam->fileop_mutex);
 941                 return -EIO;
 942         }
 943
 944         if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
 945             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
 946                 mutex_unlock(&cam->fileop_mutex);
 947                 return -EINVAL;
 948         }
 949
 950         for (i = 0; i < cam->nbuffers; i++) {
 951                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
 952                         break;
 953         }
 954         if (i == cam->nbuffers) {
 955                 mutex_unlock(&cam->fileop_mutex);
 956                 return -EINVAL;
 957         }
 958
 959         vma->vm_flags |= VM_IO;
 960         vma->vm_flags |= VM_RESERVED;
 961
 962         pos = cam->frame[i].bufmem;
 963         while (size > 0) { /* size is page-aligned */
 964                 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
 965                         mutex_unlock(&cam->fileop_mutex);
 966                         return -EAGAIN;
 967                 }
 968                 start += PAGE_SIZE;
 969                 pos += PAGE_SIZE;
 970                 size -= PAGE_SIZE;
 971         }
 972
 973         vma->vm_ops = &zc0301_vm_ops;
 974         vma->vm_private_data = &cam->frame[i];
 975
 976         zc0301_vm_open(vma);
 977
 978         mutex_unlock(&cam->fileop_mutex);
 979
 980         return 0;
 981 }
 982
 983 /*****************************************************************************/
 984
 985 static int
 986 zc0301_vidioc_querycap(struct zc0301_device* cam, void __user * arg)
 987 {
 988         struct v4l2_capability cap = {
 989                 .driver = "zc0301",
 990                 .version = ZC0301_MODULE_VERSION_CODE,
 991                 .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
 992                                 V4L2_CAP_STREAMING,
 993         };
 994
 995         strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
 996         if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
 997                 strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
 998                         sizeof(cap.bus_info));
 999
1000         if (copy_to_user(arg, &cap, sizeof(cap)))
1001                 return -EFAULT;
1002
1003         return 0;
1004 }
1005
1006
1007 static int
1008 zc0301_vidioc_enuminput(struct zc0301_device* cam, void __user * arg)
1009 {
1010         struct v4l2_input i;
1011
1012         if (copy_from_user(&i, arg, sizeof(i)))
1013                 return -EFAULT;
1014
1015         if (i.index)
1016                 return -EINVAL;
1017
1018         memset(&i, 0, sizeof(i));
1019         strcpy(i.name, "Camera");
1020         i.type = V4L2_INPUT_TYPE_CAMERA;
1021
1022         if (copy_to_user(arg, &i, sizeof(i)))
1023                 return -EFAULT;
1024
1025         return 0;
1026 }
1027
1028
1029 static int
1030 zc0301_vidioc_g_input(struct zc0301_device* cam, void __user * arg)
1031 {
1032         int index = 0;
1033
1034         if (copy_to_user(arg, &index, sizeof(index)))
1035                 return -EFAULT;
1036
1037         return 0;
1038 }
1039
1040
1041 static int
1042 zc0301_vidioc_s_input(struct zc0301_device* cam, void __user * arg)
1043 {
1044         int index;
1045
1046         if (copy_from_user(&index, arg, sizeof(index)))
1047                 return -EFAULT;
1048
1049         if (index != 0)
1050                 return -EINVAL;
1051
1052         return 0;
1053 }
1054
1055
1056 static int
1057 zc0301_vidioc_query_ctrl(struct zc0301_device* cam, void __user * arg)
1058 {
1059         struct zc0301_sensor* s = cam->sensor;
1060         struct v4l2_queryctrl qc;
1061         u8 i;
1062
1063         if (copy_from_user(&qc, arg, sizeof(qc)))
1064                 return -EFAULT;
1065
1066         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1067                 if (qc.id && qc.id == s->qctrl[i].id) {
1068                         memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
1069                         if (copy_to_user(arg, &qc, sizeof(qc)))
1070                                 return -EFAULT;
1071                         return 0;
1072                 }
1073
1074         return -EINVAL;
1075 }
1076
1077
1078 static int
1079 zc0301_vidioc_g_ctrl(struct zc0301_device* cam, void __user * arg)
1080 {
1081         struct zc0301_sensor* s = cam->sensor;
1082         struct v4l2_control ctrl;
1083         int err = 0;
1084         u8 i;
1085
1086         if (!s->get_ctrl && !s->set_ctrl)
1087                 return -EINVAL;
1088
1089         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1090                 return -EFAULT;
1091
1092         if (!s->get_ctrl) {
1093                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1094                         if (ctrl.id == s->qctrl[i].id) {
1095                                 ctrl.value = s->_qctrl[i].default_value;
1096                                 goto exit;
1097                         }
1098                 return -EINVAL;
1099         } else
1100                 err = s->get_ctrl(cam, &ctrl);
1101
1102 exit:
1103         if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
1104                 return -EFAULT;
1105
1106         return err;
1107 }
1108
1109
1110 static int
1111 zc0301_vidioc_s_ctrl(struct zc0301_device* cam, void __user * arg)
1112 {
1113         struct zc0301_sensor* s = cam->sensor;
1114         struct v4l2_control ctrl;
1115         u8 i;
1116         int err = 0;
1117
1118         if (!s->set_ctrl)
1119                 return -EINVAL;
1120
1121         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1122                 return -EFAULT;
1123
1124         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1125                 if (ctrl.id == s->qctrl[i].id) {
1126                         if (ctrl.value < s->qctrl[i].minimum ||
1127                             ctrl.value > s->qctrl[i].maximum)
1128                                 return -ERANGE;
1129                         ctrl.value -= ctrl.value % s->qctrl[i].step;
1130                         break;
1131                 }
1132
1133         if ((err = s->set_ctrl(cam, &ctrl)))
1134                 return err;
1135
1136         s->_qctrl[i].default_value = ctrl.value;
1137
1138         return 0;
1139 }
1140
1141
1142 static int
1143 zc0301_vidioc_cropcap(struct zc0301_device* cam, void __user * arg)
1144 {
1145         struct v4l2_cropcap* cc = &(cam->sensor->cropcap);
1146
1147         cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1148         cc->pixelaspect.numerator = 1;
1149         cc->pixelaspect.denominator = 1;
1150
1151         if (copy_to_user(arg, cc, sizeof(*cc)))
1152                 return -EFAULT;
1153
1154         return 0;
1155 }
1156
1157
1158 static int
1159 zc0301_vidioc_g_crop(struct zc0301_device* cam, void __user * arg)
1160 {
1161         struct zc0301_sensor* s = cam->sensor;
1162         struct v4l2_crop crop = {
1163                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
1164         };
1165
1166         memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
1167
1168         if (copy_to_user(arg, &crop, sizeof(crop)))
1169                 return -EFAULT;
1170
1171         return 0;
1172 }
1173
1174
1175 static int
1176 zc0301_vidioc_s_crop(struct zc0301_device* cam, void __user * arg)
1177 {
1178         struct zc0301_sensor* s = cam->sensor;
1179         struct v4l2_crop crop;
1180         struct v4l2_rect* rect;
1181         struct v4l2_rect* bounds = &(s->cropcap.bounds);
1182         const enum zc0301_stream_state stream = cam->stream;
1183         const u32 nbuffers = cam->nbuffers;
1184         u32 i;
1185         int err = 0;
1186
1187         if (copy_from_user(&crop, arg, sizeof(crop)))
1188                 return -EFAULT;
1189
1190         rect = &(crop.c);
1191
1192         if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1193                 return -EINVAL;
1194
1195         if (cam->module_param.force_munmap)
1196                 for (i = 0; i < cam->nbuffers; i++)
1197                         if (cam->frame[i].vma_use_count) {
1198                                 DBG(3, "VIDIOC_S_CROP failed. "
1199                                        "Unmap the buffers first.");
1200                                 return -EINVAL;
1201                         }
1202
1203         if (!s->set_crop) {
1204                 memcpy(rect, &(s->_rect), sizeof(*rect));
1205                 if (copy_to_user(arg, &crop, sizeof(crop)))
1206                         return -EFAULT;
1207                 return 0;
1208         }
1209
1210         rect->left &= ~7L;
1211         rect->top &= ~7L;
1212         if (rect->width < 8)
1213                 rect->width = 8;
1214         if (rect->height < 8)
1215                 rect->height = 8;
1216         if (rect->width > bounds->width)
1217                 rect->width = bounds->width;
1218         if (rect->height > bounds->height)
1219                 rect->height = bounds->height;
1220         if (rect->left < bounds->left)
1221                 rect->left = bounds->left;
1222         if (rect->top < bounds->top)
1223                 rect->top = bounds->top;
1224         if (rect->left + rect->width > bounds->left + bounds->width)
1225                 rect->left = bounds->left+bounds->width - rect->width;
1226         if (rect->top + rect->height > bounds->top + bounds->height)
1227                 rect->top = bounds->top+bounds->height - rect->height;
1228         rect->width &= ~7L;
1229         rect->height &= ~7L;
1230
1231         if (cam->stream == STREAM_ON)
1232                 if ((err = zc0301_stream_interrupt(cam)))
1233                         return err;
1234
1235         if (copy_to_user(arg, &crop, sizeof(crop))) {
1236                 cam->stream = stream;
1237                 return -EFAULT;
1238         }
1239
1240         if (cam->module_param.force_munmap || cam->io == IO_READ)
1241                 zc0301_release_buffers(cam);
1242
1243         if (s->set_crop)
1244                 err += s->set_crop(cam, rect);
1245
1246         if (err) { /* atomic, no rollback in ioctl() */
1247                 cam->state |= DEV_MISCONFIGURED;
1248                 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
1249                        "use the camera, close and open /dev/video%d again.",
1250                     cam->v4ldev->minor);
1251                 return -EIO;
1252         }
1253
1254         s->pix_format.width = rect->width;
1255         s->pix_format.height = rect->height;
1256         memcpy(&(s->_rect), rect, sizeof(*rect));
1257
1258         if ((cam->module_param.force_munmap  || cam->io == IO_READ) &&
1259             nbuffers != zc0301_request_buffers(cam, nbuffers, cam->io)) {
1260                 cam->state |= DEV_MISCONFIGURED;
1261                 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
1262                        "use the camera, close and open /dev/video%d again.",
1263                     cam->v4ldev->minor);
1264                 return -ENOMEM;
1265         }
1266
1267         if (cam->io == IO_READ)
1268                 zc0301_empty_framequeues(cam);
1269         else if (cam->module_param.force_munmap)
1270                 zc0301_requeue_outqueue(cam);
1271
1272         cam->stream = stream;
1273
1274         return 0;
1275 }
1276
1277
1278 static int
1279 zc0301_vidioc_enum_fmt(struct zc0301_device* cam, void __user * arg)
1280 {
1281         struct v4l2_fmtdesc fmtd;
1282
1283         if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
1284                 return -EFAULT;
1285
1286         if (fmtd.index == 0) {
1287                 strcpy(fmtd.description, "JPEG");
1288                 fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
1289                 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
1290         } else
1291                 return -EINVAL;
1292
1293         fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1294         memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
1295
1296         if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
1297                 return -EFAULT;
1298
1299         return 0;
1300 }
1301
1302
1303 static int
1304 zc0301_vidioc_g_fmt(struct zc0301_device* cam, void __user * arg)
1305 {
1306         struct v4l2_format format;
1307         struct v4l2_pix_format* pfmt = &(cam->sensor->pix_format);
1308
1309         if (copy_from_user(&format, arg, sizeof(format)))
1310                 return -EFAULT;
1311
1312         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1313                 return -EINVAL;
1314
1315         pfmt->bytesperline = 0;
1316         pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
1317         pfmt->field = V4L2_FIELD_NONE;
1318         memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
1319
1320         if (copy_to_user(arg, &format, sizeof(format)))
1321                 return -EFAULT;
1322
1323         return 0;
1324 }
1325
1326
1327 static int
1328 zc0301_vidioc_try_s_fmt(struct zc0301_device* cam, unsigned int cmd,
1329                         void __user * arg)
1330 {
1331         struct zc0301_sensor* s = cam->sensor;
1332         struct v4l2_format format;
1333         struct v4l2_pix_format* pix;
1334         struct v4l2_pix_format* pfmt = &(s->pix_format);
1335         struct v4l2_rect* bounds = &(s->cropcap.bounds);
1336         struct v4l2_rect rect;
1337         const enum zc0301_stream_state stream = cam->stream;
1338         const u32 nbuffers = cam->nbuffers;
1339         u32 i;
1340         int err = 0;
1341
1342         if (copy_from_user(&format, arg, sizeof(format)))
1343                 return -EFAULT;
1344
1345         pix = &(format.fmt.pix);
1346
1347         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1348                 return -EINVAL;
1349
1350         memcpy(&rect, &(s->_rect), sizeof(rect));
1351
1352         if (!s->set_crop) {
1353                 pix->width = rect.width;
1354                 pix->height = rect.height;
1355         } else {
1356                 rect.width = pix->width;
1357                 rect.height = pix->height;
1358         }
1359
1360         if (rect.width < 8)
1361                 rect.width = 8;
1362         if (rect.height < 8)
1363                 rect.height = 8;
1364         if (rect.width > bounds->left + bounds->width - rect.left)
1365                 rect.width = bounds->left + bounds->width - rect.left;
1366         if (rect.height > bounds->top + bounds->height - rect.top)
1367                 rect.height = bounds->top + bounds->height - rect.top;
1368         rect.width &= ~7L;
1369         rect.height &= ~7L;
1370
1371         pix->width = rect.width;
1372         pix->height = rect.height;
1373         pix->pixelformat = pfmt->pixelformat;
1374         pix->priv = pfmt->priv;
1375         pix->colorspace = pfmt->colorspace;
1376         pix->bytesperline = 0;
1377         pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
1378         pix->field = V4L2_FIELD_NONE;
1379
1380         if (cmd == VIDIOC_TRY_FMT) {
1381                 if (copy_to_user(arg, &format, sizeof(format)))
1382                         return -EFAULT;
1383                 return 0;
1384         }
1385
1386         if (cam->module_param.force_munmap)
1387                 for (i = 0; i < cam->nbuffers; i++)
1388                         if (cam->frame[i].vma_use_count) {
1389                                 DBG(3, "VIDIOC_S_FMT failed. "
1390                                        "Unmap the buffers first.");
1391                                 return -EINVAL;
1392                         }
1393
1394         if (cam->stream == STREAM_ON)
1395                 if ((err = zc0301_stream_interrupt(cam)))
1396                         return err;
1397
1398         if (copy_to_user(arg, &format, sizeof(format))) {
1399                 cam->stream = stream;
1400                 return -EFAULT;
1401         }
1402
1403         if (cam->module_param.force_munmap || cam->io == IO_READ)
1404                 zc0301_release_buffers(cam);
1405
1406         if (s->set_crop)
1407                 err += s->set_crop(cam, &rect);
1408
1409         if (err) { /* atomic, no rollback in ioctl() */
1410                 cam->state |= DEV_MISCONFIGURED;
1411                 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
1412                        "use the camera, close and open /dev/video%d again.",
1413                     cam->v4ldev->minor);
1414                 return -EIO;
1415         }
1416
1417         memcpy(pfmt, pix, sizeof(*pix));
1418         memcpy(&(s->_rect), &rect, sizeof(rect));
1419
1420         if ((cam->module_param.force_munmap  || cam->io == IO_READ) &&
1421             nbuffers != zc0301_request_buffers(cam, nbuffers, cam->io)) {
1422                 cam->state |= DEV_MISCONFIGURED;
1423                 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
1424                        "use the camera, close and open /dev/video%d again.",
1425                     cam->v4ldev->minor);
1426                 return -ENOMEM;
1427         }
1428
1429         if (cam->io == IO_READ)
1430                 zc0301_empty_framequeues(cam);
1431         else if (cam->module_param.force_munmap)
1432                 zc0301_requeue_outqueue(cam);
1433
1434         cam->stream = stream;
1435
1436         return 0;
1437 }
1438
1439
1440 static int
1441 zc0301_vidioc_g_jpegcomp(struct zc0301_device* cam, void __user * arg)
1442 {
1443         if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
1444                 return -EFAULT;
1445
1446         return 0;
1447 }
1448
1449
1450 static int
1451 zc0301_vidioc_s_jpegcomp(struct zc0301_device* cam, void __user * arg)
1452 {
1453         struct v4l2_jpegcompression jc;
1454         const enum zc0301_stream_state stream = cam->stream;
1455         int err = 0;
1456
1457         if (copy_from_user(&jc, arg, sizeof(jc)))
1458                 return -EFAULT;
1459
1460         if (jc.quality != 0)
1461                 return -EINVAL;
1462
1463         if (cam->stream == STREAM_ON)
1464                 if ((err = zc0301_stream_interrupt(cam)))
1465                         return err;
1466
1467         err += zc0301_set_compression(cam, &jc);
1468         if (err) { /* atomic, no rollback in ioctl() */
1469                 cam->state |= DEV_MISCONFIGURED;
1470                 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
1471                        "problems. To use the camera, close and open "
1472                        "/dev/video%d again.", cam->v4ldev->minor);
1473                 return -EIO;
1474         }
1475
1476         cam->compression.quality = jc.quality;
1477
1478         cam->stream = stream;
1479
1480         return 0;
1481 }
1482
1483
1484 static int
1485 zc0301_vidioc_reqbufs(struct zc0301_device* cam, void __user * arg)
1486 {
1487         struct v4l2_requestbuffers rb;
1488         u32 i;
1489         int err;
1490
1491         if (copy_from_user(&rb, arg, sizeof(rb)))
1492                 return -EFAULT;
1493
1494         if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1495             rb.memory != V4L2_MEMORY_MMAP)
1496                 return -EINVAL;
1497
1498         if (cam->io == IO_READ) {
1499                 DBG(3, "Close and open the device again to choose the mmap "
1500                        "I/O method");
1501                 return -EINVAL;
1502         }
1503
1504         for (i = 0; i < cam->nbuffers; i++)
1505                 if (cam->frame[i].vma_use_count) {
1506                         DBG(3, "VIDIOC_REQBUFS failed. "
1507                                "Previous buffers are still mapped.");
1508                         return -EINVAL;
1509                 }
1510
1511         if (cam->stream == STREAM_ON)
1512                 if ((err = zc0301_stream_interrupt(cam)))
1513                         return err;
1514
1515         zc0301_empty_framequeues(cam);
1516
1517         zc0301_release_buffers(cam);
1518         if (rb.count)
1519                 rb.count = zc0301_request_buffers(cam, rb.count, IO_MMAP);
1520
1521         if (copy_to_user(arg, &rb, sizeof(rb))) {
1522                 zc0301_release_buffers(cam);
1523                 cam->io = IO_NONE;
1524                 return -EFAULT;
1525         }
1526
1527         cam->io = rb.count ? IO_MMAP : IO_NONE;
1528
1529         return 0;
1530 }
1531
1532
1533 static int
1534 zc0301_vidioc_querybuf(struct zc0301_device* cam, void __user * arg)
1535 {
1536         struct v4l2_buffer b;
1537
1538         if (copy_from_user(&b, arg, sizeof(b)))
1539                 return -EFAULT;
1540
1541         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1542             b.index >= cam->nbuffers || cam->io != IO_MMAP)
1543                 return -EINVAL;
1544
1545         memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
1546
1547         if (cam->frame[b.index].vma_use_count)
1548                 b.flags |= V4L2_BUF_FLAG_MAPPED;
1549
1550         if (cam->frame[b.index].state == F_DONE)
1551                 b.flags |= V4L2_BUF_FLAG_DONE;
1552         else if (cam->frame[b.index].state != F_UNUSED)
1553                 b.flags |= V4L2_BUF_FLAG_QUEUED;
1554
1555         if (copy_to_user(arg, &b, sizeof(b)))
1556                 return -EFAULT;
1557
1558         return 0;
1559 }
1560
1561
1562 static int
1563 zc0301_vidioc_qbuf(struct zc0301_device* cam, void __user * arg)
1564 {
1565         struct v4l2_buffer b;
1566         unsigned long lock_flags;
1567
1568         if (copy_from_user(&b, arg, sizeof(b)))
1569                 return -EFAULT;
1570
1571         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1572             b.index >= cam->nbuffers || cam->io != IO_MMAP)
1573                 return -EINVAL;
1574
1575         if (cam->frame[b.index].state != F_UNUSED)
1576                 return -EINVAL;
1577
1578         cam->frame[b.index].state = F_QUEUED;
1579
1580         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1581         list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
1582         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1583
1584         PDBGG("Frame #%lu queued", (unsigned long)b.index);
1585
1586         return 0;
1587 }
1588
1589
1590 static int
1591 zc0301_vidioc_dqbuf(struct zc0301_device* cam, struct file* filp,
1592                     void __user * arg)
1593 {
1594         struct v4l2_buffer b;
1595         struct zc0301_frame_t *f;
1596         unsigned long lock_flags;
1597         long timeout;
1598
1599         if (copy_from_user(&b, arg, sizeof(b)))
1600                 return -EFAULT;
1601
1602         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io!= IO_MMAP)
1603                 return -EINVAL;
1604
1605         if (list_empty(&cam->outqueue)) {
1606                 if (cam->stream == STREAM_OFF)
1607                         return -EINVAL;
1608                 if (filp->f_flags & O_NONBLOCK)
1609                         return -EAGAIN;
1610                 timeout = wait_event_interruptible_timeout
1611                           ( cam->wait_frame,
1612                             (!list_empty(&cam->outqueue)) ||
1613                             (cam->state & DEV_DISCONNECTED) ||
1614                             (cam->state & DEV_MISCONFIGURED),
1615                             ZC0301_FRAME_TIMEOUT );
1616                 if (timeout < 0)
1617                         return timeout;
1618                 if (cam->state & DEV_DISCONNECTED)
1619                         return -ENODEV;
1620                 if (!timeout || (cam->state & DEV_MISCONFIGURED))
1621                         return -EIO;
1622         }
1623
1624         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1625         f = list_entry(cam->outqueue.next, struct zc0301_frame_t, frame);
1626         list_del(cam->outqueue.next);
1627         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1628
1629         f->state = F_UNUSED;
1630
1631         memcpy(&b, &f->buf, sizeof(b));
1632         if (f->vma_use_count)
1633                 b.flags |= V4L2_BUF_FLAG_MAPPED;
1634
1635         if (copy_to_user(arg, &b, sizeof(b)))
1636                 return -EFAULT;
1637
1638         PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
1639
1640         return 0;
1641 }
1642
1643
1644 static int
1645 zc0301_vidioc_streamon(struct zc0301_device* cam, void __user * arg)
1646 {
1647         int type;
1648
1649         if (copy_from_user(&type, arg, sizeof(type)))
1650                 return -EFAULT;
1651
1652         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
1653                 return -EINVAL;
1654
1655         if (list_empty(&cam->inqueue))
1656                 return -EINVAL;
1657
1658         cam->stream = STREAM_ON;
1659
1660         DBG(3, "Stream on");
1661
1662         return 0;
1663 }
1664
1665
1666 static int
1667 zc0301_vidioc_streamoff(struct zc0301_device* cam, void __user * arg)
1668 {
1669         int type, err;
1670
1671         if (copy_from_user(&type, arg, sizeof(type)))
1672                 return -EFAULT;
1673
1674         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
1675                 return -EINVAL;
1676
1677         if (cam->stream == STREAM_ON)
1678                 if ((err = zc0301_stream_interrupt(cam)))
1679                         return err;
1680
1681         zc0301_empty_framequeues(cam);
1682
1683         DBG(3, "Stream off");
1684
1685         return 0;
1686 }
1687
1688
1689 static int
1690 zc0301_vidioc_g_parm(struct zc0301_device* cam, void __user * arg)
1691 {
1692         struct v4l2_streamparm sp;
1693
1694         if (copy_from_user(&sp, arg, sizeof(sp)))
1695                 return -EFAULT;
1696
1697         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1698                 return -EINVAL;
1699
1700         sp.parm.capture.extendedmode = 0;
1701         sp.parm.capture.readbuffers = cam->nreadbuffers;
1702
1703         if (copy_to_user(arg, &sp, sizeof(sp)))
1704                 return -EFAULT;
1705
1706         return 0;
1707 }
1708
1709
1710 static int
1711 zc0301_vidioc_s_parm(struct zc0301_device* cam, void __user * arg)
1712 {
1713         struct v4l2_streamparm sp;
1714
1715         if (copy_from_user(&sp, arg, sizeof(sp)))
1716                 return -EFAULT;
1717
1718         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1719                 return -EINVAL;
1720
1721         sp.parm.capture.extendedmode = 0;
1722
1723         if (sp.parm.capture.readbuffers == 0)
1724                 sp.parm.capture.readbuffers = cam->nreadbuffers;
1725
1726         if (sp.parm.capture.readbuffers > ZC0301_MAX_FRAMES)
1727                 sp.parm.capture.readbuffers = ZC0301_MAX_FRAMES;
1728
1729         if (copy_to_user(arg, &sp, sizeof(sp)))
1730                 return -EFAULT;
1731
1732         cam->nreadbuffers = sp.parm.capture.readbuffers;
1733
1734         return 0;
1735 }
1736
1737
1738 static int zc0301_ioctl_v4l2(struct inode* inode, struct file* filp,
1739                              unsigned int cmd, void __user * arg)
1740 {
1741         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
1742
1743         switch (cmd) {
1744
1745         case VIDIOC_QUERYCAP:
1746                 return zc0301_vidioc_querycap(cam, arg);
1747
1748         case VIDIOC_ENUMINPUT:
1749                 return zc0301_vidioc_enuminput(cam, arg);
1750
1751         case VIDIOC_G_INPUT:
1752                 return zc0301_vidioc_g_input(cam, arg);
1753
1754         case VIDIOC_S_INPUT:
1755                 return zc0301_vidioc_s_input(cam, arg);
1756
1757         case VIDIOC_QUERYCTRL:
1758                 return zc0301_vidioc_query_ctrl(cam, arg);
1759
1760         case VIDIOC_G_CTRL:
1761                 return zc0301_vidioc_g_ctrl(cam, arg);
1762
1763         case VIDIOC_S_CTRL_OLD:
1764         case VIDIOC_S_CTRL:
1765                 return zc0301_vidioc_s_ctrl(cam, arg);
1766
1767         case VIDIOC_CROPCAP_OLD:
1768         case VIDIOC_CROPCAP:
1769                 return zc0301_vidioc_cropcap(cam, arg);
1770
1771         case VIDIOC_G_CROP:
1772                 return zc0301_vidioc_g_crop(cam, arg);
1773
1774         case VIDIOC_S_CROP:
1775                 return zc0301_vidioc_s_crop(cam, arg);
1776
1777         case VIDIOC_ENUM_FMT:
1778                 return zc0301_vidioc_enum_fmt(cam, arg);
1779
1780         case VIDIOC_G_FMT:
1781                 return zc0301_vidioc_g_fmt(cam, arg);
1782
1783         case VIDIOC_TRY_FMT:
1784         case VIDIOC_S_FMT:
1785                 return zc0301_vidioc_try_s_fmt(cam, cmd, arg);
1786
1787         case VIDIOC_G_JPEGCOMP:
1788                 return zc0301_vidioc_g_jpegcomp(cam, arg);
1789
1790         case VIDIOC_S_JPEGCOMP:
1791                 return zc0301_vidioc_s_jpegcomp(cam, arg);
1792
1793         case VIDIOC_REQBUFS:
1794                 return zc0301_vidioc_reqbufs(cam, arg);
1795
1796         case VIDIOC_QUERYBUF:
1797                 return zc0301_vidioc_querybuf(cam, arg);
1798
1799         case VIDIOC_QBUF:
1800                 return zc0301_vidioc_qbuf(cam, arg);
1801
1802         case VIDIOC_DQBUF:
1803                 return zc0301_vidioc_dqbuf(cam, filp, arg);
1804
1805         case VIDIOC_STREAMON:
1806                 return zc0301_vidioc_streamon(cam, arg);
1807
1808         case VIDIOC_STREAMOFF:
1809                 return zc0301_vidioc_streamoff(cam, arg);
1810
1811         case VIDIOC_G_PARM:
1812                 return zc0301_vidioc_g_parm(cam, arg);
1813
1814         case VIDIOC_S_PARM_OLD:
1815         case VIDIOC_S_PARM:
1816                 return zc0301_vidioc_s_parm(cam, arg);
1817
1818         case VIDIOC_G_STD:
1819         case VIDIOC_S_STD:
1820         case VIDIOC_QUERYSTD:
1821         case VIDIOC_ENUMSTD:
1822         case VIDIOC_QUERYMENU:
1823                 return -EINVAL;
1824
1825         default:
1826                 return -EINVAL;
1827
1828         }
1829 }
1830
1831
1832 static int zc0301_ioctl(struct inode* inode, struct file* filp,
1833                         unsigned int cmd, unsigned long arg)
1834 {
1835         struct zc0301_device* cam = video_get_drvdata(video_devdata(filp));
1836         int err = 0;
1837
1838         if (mutex_lock_interruptible(&cam->fileop_mutex))
1839                 return -ERESTARTSYS;
1840
1841         if (cam->state & DEV_DISCONNECTED) {
1842                 DBG(1, "Device not present");
1843                 mutex_unlock(&cam->fileop_mutex);
1844                 return -ENODEV;
1845         }
1846
1847         if (cam->state & DEV_MISCONFIGURED) {
1848                 DBG(1, "The camera is misconfigured. Close and open it "
1849                        "again.");
1850                 mutex_unlock(&cam->fileop_mutex);
1851                 return -EIO;
1852         }
1853
1854         V4LDBG(3, "zc0301", cmd);
1855
1856         err = zc0301_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
1857
1858         mutex_unlock(&cam->fileop_mutex);
1859
1860         return err;
1861 }
1862
1863
1864 static struct file_operations zc0301_fops = {
1865         .owner =   THIS_MODULE,
1866         .open =    zc0301_open,
1867         .release = zc0301_release,
1868         .ioctl =   zc0301_ioctl,
1869         .read =    zc0301_read,
1870         .poll =    zc0301_poll,
1871         .mmap =    zc0301_mmap,
1872         .llseek =  no_llseek,
1873 };
1874
1875 /*****************************************************************************/
1876
1877 static int
1878 zc0301_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
1879 {
1880         struct usb_device *udev = interface_to_usbdev(intf);
1881         struct zc0301_device* cam;
1882         static unsigned int dev_nr = 0;
1883         unsigned int i;
1884         int err = 0;
1885
1886         if (!(cam = kzalloc(sizeof(struct zc0301_device), GFP_KERNEL)))
1887                 return -ENOMEM;
1888
1889         cam->usbdev = udev;
1890
1891         if (!(cam->control_buffer = kzalloc(4, GFP_KERNEL))) {
1892                 DBG(1, "kmalloc() failed");
1893                 err = -ENOMEM;
1894                 goto fail;
1895         }
1896
1897         if (!(cam->v4ldev = video_device_alloc())) {
1898                 DBG(1, "video_device_alloc() failed");
1899                 err = -ENOMEM;
1900                 goto fail;
1901         }
1902
1903         mutex_init(&cam->dev_mutex);
1904
1905         DBG(2, "ZC0301 Image Processor and Control Chip detected "
1906                "(vid/pid 0x%04X/0x%04X)",id->idVendor, id->idProduct);
1907
1908         for  (i = 0; zc0301_sensor_table[i]; i++) {
1909                 err = zc0301_sensor_table[i](cam);
1910                 if (!err)
1911                         break;
1912         }
1913
1914         if (!err && cam->sensor)
1915                 DBG(2, "%s image sensor detected", cam->sensor->name);
1916         else {
1917                 DBG(1, "No supported image sensor detected");
1918                 err = -ENODEV;
1919                 goto fail;
1920         }
1921
1922         if (zc0301_init(cam)) {
1923                 DBG(1, "Initialization failed. I will retry on open().");
1924                 cam->state |= DEV_MISCONFIGURED;
1925         }
1926
1927         strcpy(cam->v4ldev->name, "ZC0301 PC Camera");
1928         cam->v4ldev->owner = THIS_MODULE;
1929         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
1930         cam->v4ldev->hardware = 0;
1931         cam->v4ldev->fops = &zc0301_fops;
1932         cam->v4ldev->minor = video_nr[dev_nr];
1933         cam->v4ldev->release = video_device_release;
1934         video_set_drvdata(cam->v4ldev, cam);
1935
1936         mutex_lock(&cam->dev_mutex);
1937
1938         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
1939                                     video_nr[dev_nr]);
1940         if (err) {
1941                 DBG(1, "V4L2 device registration failed");
1942                 if (err == -ENFILE && video_nr[dev_nr] == -1)
1943                         DBG(1, "Free /dev/videoX node not found");
1944                 video_nr[dev_nr] = -1;
1945                 dev_nr = (dev_nr < ZC0301_MAX_DEVICES-1) ? dev_nr+1 : 0;
1946                 mutex_unlock(&cam->dev_mutex);
1947                 goto fail;
1948         }
1949
1950         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor);
1951
1952         cam->module_param.force_munmap = force_munmap[dev_nr];
1953
1954         dev_nr = (dev_nr < ZC0301_MAX_DEVICES-1) ? dev_nr+1 : 0;
1955
1956         usb_set_intfdata(intf, cam);
1957
1958         mutex_unlock(&cam->dev_mutex);
1959
1960         return 0;
1961
1962 fail:
1963         if (cam) {
1964                 kfree(cam->control_buffer);
1965                 if (cam->v4ldev)
1966                         video_device_release(cam->v4ldev);
1967                 kfree(cam);
1968         }
1969         return err;
1970 }
1971
1972
1973 static void zc0301_usb_disconnect(struct usb_interface* intf)
1974 {
1975         struct zc0301_device* cam = usb_get_intfdata(intf);
1976
1977         if (!cam)
1978                 return;
1979
1980         down_write(&zc0301_disconnect);
1981
1982         mutex_lock(&cam->dev_mutex);
1983
1984         DBG(2, "Disconnecting %s...", cam->v4ldev->name);
1985
1986         wake_up_interruptible_all(&cam->open);
1987
1988         if (cam->users) {
1989                 DBG(2, "Device /dev/video%d is open! Deregistration and "
1990                        "memory deallocation are deferred on close.",
1991                     cam->v4ldev->minor);
1992                 cam->state |= DEV_MISCONFIGURED;
1993                 zc0301_stop_transfer(cam);
1994                 cam->state |= DEV_DISCONNECTED;
1995                 wake_up_interruptible(&cam->wait_frame);
1996                 wake_up(&cam->wait_stream);
1997         } else {
1998                 cam->state |= DEV_DISCONNECTED;
1999                 zc0301_release_resources(cam);
2000         }
2001
2002         mutex_unlock(&cam->dev_mutex);
2003
2004         if (!cam->users)
2005                 kfree(cam);
2006
2007         up_write(&zc0301_disconnect);
2008 }
2009
2010
2011 static struct usb_driver zc0301_usb_driver = {
2012         .name =       "zc0301",
2013         .id_table =   zc0301_id_table,
2014         .probe =      zc0301_usb_probe,
2015         .disconnect = zc0301_usb_disconnect,
2016 };
2017
2018 /*****************************************************************************/
2019
2020 static int __init zc0301_module_init(void)
2021 {
2022         int err = 0;
2023
2024         KDBG(2, ZC0301_MODULE_NAME " v" ZC0301_MODULE_VERSION);
2025         KDBG(3, ZC0301_MODULE_AUTHOR);
2026
2027         if ((err = usb_register(&zc0301_usb_driver)))
2028                 KDBG(1, "usb_register() failed");
2029
2030         return err;
2031 }
2032
2033
2034 static void __exit zc0301_module_exit(void)
2035 {
2036         usb_deregister(&zc0301_usb_driver);
2037 }
2038
2039
2040 module_init(zc0301_module_init);
2041 module_exit(zc0301_module_exit);