drivers/usb/media/sn9c102_core.c

   1 /***************************************************************************
   2  * V4L2 driver for SN9C10x PC Camera Controllers                           *
   3  *                                                                         *
   4  * Copyright (C) 2004-2005 by Luca Risolia <luca.risolia@studio.unibo.it>  *
   5  *                                                                         *
   6  * This program is free software; you can redistribute it and/or modify    *
   7  * it under the terms of the GNU General Public License as published by    *
   8  * the Free Software Foundation; either version 2 of the License, or       *
   9  * (at your option) any later version.                                     *
  10  *                                                                         *
  11  * This program is distributed in the hope that it will be useful,         *
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  14  * GNU General Public License for more details.                            *
  15  *                                                                         *
  16  * You should have received a copy of the GNU General Public License       *
  17  * along with this program; if not, write to the Free Software             *
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
  19  ***************************************************************************/
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/kernel.h>
  24 #include <linux/param.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/errno.h>
  27 #include <linux/slab.h>
  28 #include <linux/string.h>
  29 #include <linux/device.h>
  30 #include <linux/fs.h>
  31 #include <linux/delay.h>
  32 #include <linux/stddef.h>
  33 #include <linux/compiler.h>
  34 #include <linux/ioctl.h>
  35 #include <linux/poll.h>
  36 #include <linux/stat.h>
  37 #include <linux/mm.h>
  38 #include <linux/vmalloc.h>
  39 #include <linux/page-flags.h>
  40 #include <linux/byteorder/generic.h>
  41 #include <asm/page.h>
  42 #include <asm/uaccess.h>
  43
  44 #include "sn9c102.h"
  45
  46 /*****************************************************************************/
  47
  48 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
  49
  50 MODULE_AUTHOR(SN9C102_MODULE_AUTHOR " " SN9C102_AUTHOR_EMAIL);
  51 MODULE_DESCRIPTION(SN9C102_MODULE_NAME);
  52 MODULE_VERSION(SN9C102_MODULE_VERSION);
  53 MODULE_LICENSE(SN9C102_MODULE_LICENSE);
  54
  55 static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};
  56 module_param_array(video_nr, short, NULL, 0444);
  57 MODULE_PARM_DESC(video_nr,
  58                  "\n<-1|n[,...]> Specify V4L2 minor mode number."
  59                  "\n -1 = use next available (default)"
  60                  "\n  n = use minor number n (integer >= 0)"
  61                  "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
  62                  " cameras this way."
  63                  "\nFor example:"
  64                  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
  65                  "\nthe second camera and use auto for the first"
  66                  "\none and for every other camera."
  67                  "\n");
  68
  69 static short force_munmap[] = {[0 ... SN9C102_MAX_DEVICES-1] =
  70                                SN9C102_FORCE_MUNMAP};
  71 module_param_array(force_munmap, bool, NULL, 0444);
  72 MODULE_PARM_DESC(force_munmap,
  73                  "\n<0|1[,...]> Force the application to unmap previously "
  74                  "\nmapped buffer memory before calling any VIDIOC_S_CROP or "
  75                  "\nVIDIOC_S_FMT ioctl's. Not all the applications support "
  76                  "\nthis feature. This parameter is specific for each "
  77                  "\ndetected camera."
  78                  "\n 0 = do not force memory unmapping"
  79                  "\n 1 = force memory unmapping (save memory)"
  80                  "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
  81                  "\n");
  82
  83 #ifdef SN9C102_DEBUG
  84 static unsigned short debug = SN9C102_DEBUG_LEVEL;
  85 module_param(debug, ushort, 0644);
  86 MODULE_PARM_DESC(debug,
  87                  "\n<n> Debugging information level, from 0 to 3:"
  88                  "\n0 = none (use carefully)"
  89                  "\n1 = critical errors"
  90                  "\n2 = significant informations"
  91                  "\n3 = more verbose messages"
  92                  "\nLevel 3 is useful for testing only, when only "
  93                  "one device is used."
  94                  "\nDefault value is "__MODULE_STRING(SN9C102_DEBUG_LEVEL)"."
  95                  "\n");
  96 #endif
  97
  98 /*****************************************************************************/
  99
 100 static sn9c102_sof_header_t sn9c102_sof_header[] = {
 101         {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x00},
 102         {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x01},
 103 };
 104
 105
 106 static sn9c102_eof_header_t sn9c102_eof_header[] = {
 107         {0x00, 0x00, 0x00, 0x00},
 108         {0x40, 0x00, 0x00, 0x00},
 109         {0x80, 0x00, 0x00, 0x00},
 110         {0xc0, 0x00, 0x00, 0x00},
 111 };
 112
 113 /*****************************************************************************/
 114
 115 static void* rvmalloc(size_t size)
 116 {
 117         void* mem;
 118         unsigned long adr;
 119
 120         size = PAGE_ALIGN(size);
 121
 122         mem = vmalloc_32((unsigned long)size);
 123         if (!mem)
 124                 return NULL;
 125
 126         memset(mem, 0, size);
 127
 128         adr = (unsigned long)mem;
 129         while (size > 0) {
 130                 SetPageReserved(vmalloc_to_page((void *)adr));
 131                 adr += PAGE_SIZE;
 132                 size -= PAGE_SIZE;
 133         }
 134
 135         return mem;
 136 }
 137
 138
 139 static void rvfree(void* mem, size_t size)
 140 {
 141         unsigned long adr;
 142
 143         if (!mem)
 144                 return;
 145
 146         size = PAGE_ALIGN(size);
 147
 148         adr = (unsigned long)mem;
 149         while (size > 0) {
 150                 ClearPageReserved(vmalloc_to_page((void *)adr));
 151                 adr += PAGE_SIZE;
 152                 size -= PAGE_SIZE;
 153         }
 154
 155         vfree(mem);
 156 }
 157
 158
 159 static u32
 160 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
 161                         enum sn9c102_io_method io)
 162 {
 163         struct v4l2_pix_format* p = &(cam->sensor->pix_format);
 164         struct v4l2_rect* r = &(cam->sensor->cropcap.bounds);
 165         const size_t imagesize = cam->module_param.force_munmap ||
 166                                  io == IO_READ ?
 167                                  (p->width * p->height * p->priv)/8 :
 168                                  (r->width * r->height * p->priv)/8;
 169         void* buff = NULL;
 170         u32 i;
 171
 172         if (count > SN9C102_MAX_FRAMES)
 173                 count = SN9C102_MAX_FRAMES;
 174
 175         cam->nbuffers = count;
 176         while (cam->nbuffers > 0) {
 177                 if ((buff = rvmalloc(cam->nbuffers * PAGE_ALIGN(imagesize))))
 178                         break;
 179                 cam->nbuffers--;
 180         }
 181
 182         for (i = 0; i < cam->nbuffers; i++) {
 183                 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
 184                 cam->frame[i].buf.index = i;
 185                 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
 186                 cam->frame[i].buf.length = imagesize;
 187                 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 188                 cam->frame[i].buf.sequence = 0;
 189                 cam->frame[i].buf.field = V4L2_FIELD_NONE;
 190                 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
 191                 cam->frame[i].buf.flags = 0;
 192         }
 193
 194         return cam->nbuffers;
 195 }
 196
 197
 198 static void sn9c102_release_buffers(struct sn9c102_device* cam)
 199 {
 200         if (cam->nbuffers) {
 201                 rvfree(cam->frame[0].bufmem,
 202                        cam->nbuffers * cam->frame[0].buf.length);
 203                 cam->nbuffers = 0;
 204         }
 205 }
 206
 207
 208 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
 209 {
 210         u32 i;
 211
 212         INIT_LIST_HEAD(&cam->inqueue);
 213         INIT_LIST_HEAD(&cam->outqueue);
 214
 215         for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
 216                 cam->frame[i].state = F_UNUSED;
 217                 cam->frame[i].buf.bytesused = 0;
 218         }
 219 }
 220
 221
 222 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
 223 {
 224         unsigned long lock_flags;
 225         u32 i;
 226
 227         for (i = 0; i < cam->nbuffers; i++)
 228                 if (cam->frame[i].state == F_UNUSED) {
 229                         cam->frame[i].state = F_QUEUED;
 230                         spin_lock_irqsave(&cam->queue_lock, lock_flags);
 231                         list_add_tail(&cam->frame[i].frame, &cam->inqueue);
 232                         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 233                 }
 234 }
 235
 236 /*****************************************************************************/
 237
 238 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
 239 {
 240         struct usb_device* udev = cam->usbdev;
 241         u8* buff = cam->control_buffer;
 242         int res;
 243
 244         *buff = value;
 245
 246         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 247                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 248         if (res < 0) {
 249                 DBG(3, "Failed to write a register (value 0x%02X, index "
 250                        "0x%02X, error %d)", value, index, res)
 251                 return -1;
 252         }
 253
 254         cam->reg[index] = value;
 255
 256         return 0;
 257 }
 258
 259
 260 /* NOTE: reading some registers always returns 0 */
 261 static int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
 262 {
 263         struct usb_device* udev = cam->usbdev;
 264         u8* buff = cam->control_buffer;
 265         int res;
 266
 267         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 268                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 269         if (res < 0)
 270                 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
 271                     index, res)
 272
 273         return (res >= 0) ? (int)(*buff) : -1;
 274 }
 275
 276
 277 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
 278 {
 279         if (index > 0x1f)
 280                 return -EINVAL;
 281
 282         return cam->reg[index];
 283 }
 284
 285
 286 static int
 287 sn9c102_i2c_wait(struct sn9c102_device* cam, struct sn9c102_sensor* sensor)
 288 {
 289         int i, r;
 290
 291         for (i = 1; i <= 5; i++) {
 292                 r = sn9c102_read_reg(cam, 0x08);
 293                 if (r < 0)
 294                         return -EIO;
 295                 if (r & 0x04)
 296                         return 0;
 297                 if (sensor->frequency & SN9C102_I2C_400KHZ)
 298                         udelay(5*16);
 299                 else
 300                         udelay(16*16);
 301         }
 302         return -EBUSY;
 303 }
 304
 305
 306 static int
 307 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
 308                               struct sn9c102_sensor* sensor)
 309 {
 310         int r;
 311         r = sn9c102_read_reg(cam, 0x08);
 312         return (r < 0 || (r >= 0 && !(r & 0x08))) ? -EIO : 0;
 313 }
 314
 315
 316 static int
 317 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
 318                                struct sn9c102_sensor* sensor)
 319 {
 320         int r;
 321         r = sn9c102_read_reg(cam, 0x08);
 322         return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
 323 }
 324
 325
 326 int
 327 sn9c102_i2c_try_raw_read(struct sn9c102_device* cam,
 328                          struct sn9c102_sensor* sensor, u8 data0, u8 data1,
 329                          u8 n, u8 buffer[])
 330 {
 331         struct usb_device* udev = cam->usbdev;
 332         u8* data = cam->control_buffer;
 333         int err = 0, res;
 334
 335         /* Write cycle */
 336         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 337                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) | 0x10;
 338         data[1] = data0; /* I2C slave id */
 339         data[2] = data1; /* address */
 340         data[7] = 0x10;
 341         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 342                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 343         if (res < 0)
 344                 err += res;
 345
 346         err += sn9c102_i2c_wait(cam, sensor);
 347
 348         /* Read cycle - n bytes */
 349         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 350                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
 351                   (n << 4) | 0x02;
 352         data[1] = data0;
 353         data[7] = 0x10;
 354         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 355                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 356         if (res < 0)
 357                 err += res;
 358
 359         err += sn9c102_i2c_wait(cam, sensor);
 360
 361         /* The first read byte will be placed in data[4] */
 362         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 363                               0x0a, 0, data, 5, SN9C102_CTRL_TIMEOUT);
 364         if (res < 0)
 365                 err += res;
 366
 367         err += sn9c102_i2c_detect_read_error(cam, sensor);
 368
 369         PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
 370               data[4])
 371
 372         if (err) {
 373                 DBG(3, "I2C read failed for %s image sensor", sensor->name)
 374                 return -1;
 375         }
 376
 377         if (buffer)
 378                 memcpy(buffer, data, sizeof(buffer));
 379
 380         return (int)data[4];
 381 }
 382
 383
 384 int
 385 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
 386                           struct sn9c102_sensor* sensor, u8 n, u8 data0,
 387                           u8 data1, u8 data2, u8 data3, u8 data4, u8 data5)
 388 {
 389         struct usb_device* udev = cam->usbdev;
 390         u8* data = cam->control_buffer;
 391         int err = 0, res;
 392
 393         /* Write cycle. It usually is address + value */
 394         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 395                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0)
 396                   | ((n - 1) << 4);
 397         data[1] = data0;
 398         data[2] = data1;
 399         data[3] = data2;
 400         data[4] = data3;
 401         data[5] = data4;
 402         data[6] = data5;
 403         data[7] = 0x14;
 404         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 405                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 406         if (res < 0)
 407                 err += res;
 408
 409         err += sn9c102_i2c_wait(cam, sensor);
 410         err += sn9c102_i2c_detect_write_error(cam, sensor);
 411
 412         if (err)
 413                 DBG(3, "I2C write failed for %s image sensor", sensor->name)
 414
 415         PDBGG("I2C raw write: %u bytes, data0 = 0x%02X, data1 = 0x%02X, "
 416               "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X",
 417               n, data0, data1, data2, data3, data4, data5)
 418
 419         return err ? -1 : 0;
 420 }
 421
 422
 423 int
 424 sn9c102_i2c_try_read(struct sn9c102_device* cam,
 425                      struct sn9c102_sensor* sensor, u8 address)
 426 {
 427         return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
 428                                         address, 1, NULL);
 429 }
 430
 431
 432 int
 433 sn9c102_i2c_try_write(struct sn9c102_device* cam,
 434                       struct sn9c102_sensor* sensor, u8 address, u8 value)
 435 {
 436         return sn9c102_i2c_try_raw_write(cam, sensor, 3,
 437                                          sensor->i2c_slave_id, address,
 438                                          value, 0, 0, 0);
 439 }
 440
 441
 442 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
 443 {
 444         if (!cam->sensor)
 445                 return -1;
 446
 447         return sn9c102_i2c_try_read(cam, cam->sensor, address);
 448 }
 449
 450
 451 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
 452 {
 453         if (!cam->sensor)
 454                 return -1;
 455
 456         return sn9c102_i2c_try_write(cam, cam->sensor, address, value);
 457 }
 458
 459 /*****************************************************************************/
 460
 461 static void*
 462 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
 463 {
 464         size_t soflen = sizeof(sn9c102_sof_header_t), i;
 465         u8 j, n = sizeof(sn9c102_sof_header) / soflen;
 466
 467         for (i = 0; (len >= soflen) && (i <= len - soflen); i++)
 468                 for (j = 0; j < n; j++)
 469                         /* It's enough to compare 7 bytes */
 470                         if (!memcmp(mem + i, sn9c102_sof_header[j], 7)) {
 471                                 memcpy(cam->sof_header, mem + i, soflen);
 472                                 /* Skip the header */
 473                                 return mem + i + soflen;
 474                         }
 475
 476         return NULL;
 477 }
 478
 479
 480 static void*
 481 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
 482 {
 483         size_t eoflen = sizeof(sn9c102_eof_header_t), i;
 484         unsigned j, n = sizeof(sn9c102_eof_header) / eoflen;
 485
 486         if (cam->sensor->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
 487                 return NULL; /* EOF header does not exist in compressed data */
 488
 489         for (i = 0; (len >= eoflen) && (i <= len - eoflen); i++)
 490                 for (j = 0; j < n; j++)
 491                         if (!memcmp(mem + i, sn9c102_eof_header[j], eoflen))
 492                                 return mem + i;
 493
 494         return NULL;
 495 }
 496
 497
 498 static void sn9c102_urb_complete(struct urb *urb, struct pt_regs* regs)
 499 {
 500         struct sn9c102_device* cam = urb->context;
 501         struct sn9c102_frame_t** f;
 502         unsigned long lock_flags;
 503         u8 i;
 504         int err = 0;
 505
 506         if (urb->status == -ENOENT)
 507                 return;
 508
 509         f = &cam->frame_current;
 510
 511         if (cam->stream == STREAM_INTERRUPT) {
 512                 cam->stream = STREAM_OFF;
 513                 if ((*f))
 514                         (*f)->state = F_QUEUED;
 515                 DBG(3, "Stream interrupted")
 516                 wake_up_interruptible(&cam->wait_stream);
 517         }
 518
 519         if ((cam->state & DEV_DISCONNECTED)||(cam->state & DEV_MISCONFIGURED))
 520                 return;
 521
 522         if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
 523                 goto resubmit_urb;
 524
 525         if (!(*f))
 526                 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
 527                                   frame);
 528
 529         for (i = 0; i < urb->number_of_packets; i++) {
 530                 unsigned int img, len, status;
 531                 void *pos, *sof, *eof;
 532
 533                 len = urb->iso_frame_desc[i].actual_length;
 534                 status = urb->iso_frame_desc[i].status;
 535                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 536
 537                 if (status) {
 538                         DBG(3, "Error in isochronous frame")
 539                         (*f)->state = F_ERROR;
 540                         continue;
 541                 }
 542
 543                 PDBGG("Isochrnous frame: length %u, #%u i", len, i)
 544
 545                 /*
 546                    NOTE: It is probably correct to assume that SOF and EOF
 547                          headers do not occur between two consecutive packets,
 548                          but who knows..Whatever is the truth, this assumption
 549                          doesn't introduce bugs.
 550                 */
 551
 552 redo:
 553                 sof = sn9c102_find_sof_header(cam, pos, len);
 554                 if (!sof) {
 555                         eof = sn9c102_find_eof_header(cam, pos, len);
 556                         if ((*f)->state == F_GRABBING) {
 557 end_of_frame:
 558                                 img = len;
 559
 560                                 if (eof)
 561                                         img = (eof > pos) ? eof - pos - 1 : 0;
 562
 563                                 if ((*f)->buf.bytesused+img>(*f)->buf.length) {
 564                                         u32 b = (*f)->buf.bytesused + img -
 565                                                 (*f)->buf.length;
 566                                         img = (*f)->buf.length -
 567                                               (*f)->buf.bytesused;
 568                                         DBG(3, "Expected EOF not found: "
 569                                                "video frame cut")
 570                                         if (eof)
 571                                                 DBG(3, "Exceeded limit: +%u "
 572                                                        "bytes", (unsigned)(b))
 573                                 }
 574
 575                                 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
 576                                        img);
 577
 578                                 if ((*f)->buf.bytesused == 0)
 579                                         do_gettimeofday(&(*f)->buf.timestamp);
 580
 581                                 (*f)->buf.bytesused += img;
 582
 583                                 if ((*f)->buf.bytesused == (*f)->buf.length ||
 584                                     (cam->sensor->pix_format.pixelformat ==
 585                                                 V4L2_PIX_FMT_SN9C10X && eof)) {
 586                                         u32 b = (*f)->buf.bytesused;
 587                                         (*f)->state = F_DONE;
 588                                         (*f)->buf.sequence= ++cam->frame_count;
 589                                         spin_lock_irqsave(&cam->queue_lock,
 590                                                           lock_flags);
 591                                         list_move_tail(&(*f)->frame,
 592                                                        &cam->outqueue);
 593                                         if (!list_empty(&cam->inqueue))
 594                                                 (*f) = list_entry(
 595                                                         cam->inqueue.next,
 596                                                         struct sn9c102_frame_t,
 597                                                         frame );
 598                                         else
 599                                                 (*f) = NULL;
 600                                         spin_unlock_irqrestore(&cam->queue_lock
 601                                                                , lock_flags);
 602                                         memcpy(cam->sysfs.frame_header,
 603                                                cam->sof_header,
 604                                                sizeof(sn9c102_sof_header_t));
 605                                         DBG(3, "Video frame captured: "
 606                                                "%lu bytes", (unsigned long)(b))
 607
 608                                         if (!(*f))
 609                                                 goto resubmit_urb;
 610
 611                                 } else if (eof) {
 612                                         (*f)->state = F_ERROR;
 613                                         DBG(3, "Not expected EOF after %lu "
 614                                                "bytes of image data",
 615                                           (unsigned long)((*f)->buf.bytesused))
 616                                 }
 617
 618                                 if (sof) /* (1) */
 619                                         goto start_of_frame;
 620
 621                         } else if (eof) {
 622                                 DBG(3, "EOF without SOF")
 623                                 continue;
 624
 625                         } else {
 626                                 PDBGG("Ignoring pointless isochronous frame")
 627                                 continue;
 628                         }
 629
 630                 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
 631 start_of_frame:
 632                         (*f)->state = F_GRABBING;
 633                         (*f)->buf.bytesused = 0;
 634                         len -= (sof - pos);
 635                         pos = sof;
 636                         DBG(3, "SOF detected: new video frame")
 637                         if (len)
 638                                 goto redo;
 639
 640                 } else if ((*f)->state == F_GRABBING) {
 641                         eof = sn9c102_find_eof_header(cam, pos, len);
 642                         if (eof && eof < sof)
 643                                 goto end_of_frame; /* (1) */
 644                         else {
 645                                 if (cam->sensor->pix_format.pixelformat ==
 646                                     V4L2_PIX_FMT_SN9C10X) {
 647                                         eof = sof-sizeof(sn9c102_sof_header_t);
 648                                         goto end_of_frame;
 649                                 } else {
 650                                         DBG(3, "SOF before expected EOF after "
 651                                                "%lu bytes of image data",
 652                                           (unsigned long)((*f)->buf.bytesused))
 653                                         goto start_of_frame;
 654                                 }
 655                         }
 656                 }
 657         }
 658
 659 resubmit_urb:
 660         urb->dev = cam->usbdev;
 661         err = usb_submit_urb(urb, GFP_ATOMIC);
 662         if (err < 0 && err != -EPERM) {
 663                 cam->state |= DEV_MISCONFIGURED;
 664                 DBG(1, "usb_submit_urb() failed")
 665         }
 666
 667         wake_up_interruptible(&cam->wait_frame);
 668 }
 669
 670
 671 static int sn9c102_start_transfer(struct sn9c102_device* cam)
 672 {
 673         struct usb_device *udev = cam->usbdev;
 674         struct urb* urb;
 675         const unsigned int wMaxPacketSize[] = {0, 128, 256, 384, 512,
 676                                                680, 800, 900, 1023};
 677         const unsigned int psz = wMaxPacketSize[SN9C102_ALTERNATE_SETTING];
 678         s8 i, j;
 679         int err = 0;
 680
 681         for (i = 0; i < SN9C102_URBS; i++) {
 682                 cam->transfer_buffer[i] = kmalloc(SN9C102_ISO_PACKETS * psz,
 683                                                   GFP_KERNEL);
 684                 if (!cam->transfer_buffer[i]) {
 685                         err = -ENOMEM;
 686                         DBG(1, "Not enough memory")
 687                         goto free_buffers;
 688                 }
 689         }
 690
 691         for (i = 0; i < SN9C102_URBS; i++) {
 692                 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
 693                 cam->urb[i] = urb;
 694                 if (!urb) {
 695                         err = -ENOMEM;
 696                         DBG(1, "usb_alloc_urb() failed")
 697                         goto free_urbs;
 698                 }
 699                 urb->dev = udev;
 700                 urb->context = cam;
 701                 urb->pipe = usb_rcvisocpipe(udev, 1);
 702                 urb->transfer_flags = URB_ISO_ASAP;
 703                 urb->number_of_packets = SN9C102_ISO_PACKETS;
 704                 urb->complete = sn9c102_urb_complete;
 705                 urb->transfer_buffer = cam->transfer_buffer[i];
 706                 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
 707                 urb->interval = 1;
 708                 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
 709                         urb->iso_frame_desc[j].offset = psz * j;
 710                         urb->iso_frame_desc[j].length = psz;
 711                 }
 712         }
 713
 714         /* Enable video */
 715         if (!(cam->reg[0x01] & 0x04)) {
 716                 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
 717                 if (err) {
 718                         err = -EIO;
 719                         DBG(1, "I/O hardware error")
 720                         goto free_urbs;
 721                 }
 722         }
 723
 724         err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
 725         if (err) {
 726                 DBG(1, "usb_set_interface() failed")
 727                 goto free_urbs;
 728         }
 729
 730         cam->frame_current = NULL;
 731
 732         for (i = 0; i < SN9C102_URBS; i++) {
 733                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 734                 if (err) {
 735                         for (j = i-1; j >= 0; j--)
 736                                 usb_kill_urb(cam->urb[j]);
 737                         DBG(1, "usb_submit_urb() failed, error %d", err)
 738                         goto free_urbs;
 739                 }
 740         }
 741
 742         return 0;
 743
 744 free_urbs:
 745         for (i = 0; (i < SN9C102_URBS) &&  cam->urb[i]; i++)
 746                 usb_free_urb(cam->urb[i]);
 747
 748 free_buffers:
 749         for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
 750                 kfree(cam->transfer_buffer[i]);
 751
 752         return err;
 753 }
 754
 755
 756 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
 757 {
 758         struct usb_device *udev = cam->usbdev;
 759         s8 i;
 760         int err = 0;
 761
 762         if (cam->state & DEV_DISCONNECTED)
 763                 return 0;
 764
 765         for (i = SN9C102_URBS-1; i >= 0; i--) {
 766                 usb_kill_urb(cam->urb[i]);
 767                 usb_free_urb(cam->urb[i]);
 768                 kfree(cam->transfer_buffer[i]);
 769         }
 770
 771         err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 772         if (err)
 773                 DBG(3, "usb_set_interface() failed")
 774
 775         return err;
 776 }
 777
 778
 779 int sn9c102_stream_interrupt(struct sn9c102_device* cam)
 780 {
 781         int err = 0;
 782
 783         cam->stream = STREAM_INTERRUPT;
 784         err = wait_event_timeout(cam->wait_stream,
 785                                  (cam->stream == STREAM_OFF) ||
 786                                  (cam->state & DEV_DISCONNECTED),
 787                                  SN9C102_URB_TIMEOUT);
 788         if (cam->state & DEV_DISCONNECTED)
 789                 return -ENODEV;
 790         else if (err) {
 791                 cam->state |= DEV_MISCONFIGURED;
 792                 DBG(1, "The camera is misconfigured. To use it, close and "
 793                        "open /dev/video%d again.", cam->v4ldev->minor)
 794                 return err;
 795         }
 796
 797         return 0;
 798 }
 799
 800 /*****************************************************************************/
 801
 802 static u8 sn9c102_strtou8(const char* buff, size_t len, ssize_t* count)
 803 {
 804         char str[5];
 805         char* endp;
 806         unsigned long val;
 807
 808         if (len < 4) {
 809                 strncpy(str, buff, len);
 810                 str[len+1] = '\0';
 811         } else {
 812                 strncpy(str, buff, 4);
 813                 str[4] = '\0';
 814         }
 815
 816         val = simple_strtoul(str, &endp, 0);
 817
 818         *count = 0;
 819         if (val <= 0xff)
 820                 *count = (ssize_t)(endp - str);
 821         if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
 822                 *count += 1;
 823
 824         return (u8)val;
 825 }
 826
 827 /*
 828    NOTE 1: being inside one of the following methods implies that the v4l
 829            device exists for sure (see kobjects and reference counters)
 830    NOTE 2: buffers are PAGE_SIZE long
 831 */
 832
 833 static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
 834 {
 835         struct sn9c102_device* cam;
 836         ssize_t count;
 837
 838         if (down_interruptible(&sn9c102_sysfs_lock))
 839                 return -ERESTARTSYS;
 840
 841         cam = video_get_drvdata(to_video_device(cd));
 842         if (!cam) {
 843                 up(&sn9c102_sysfs_lock);
 844                 return -ENODEV;
 845         }
 846
 847         count = sprintf(buf, "%u\n", cam->sysfs.reg);
 848
 849         up(&sn9c102_sysfs_lock);
 850
 851         return count;
 852 }
 853
 854
 855 static ssize_t
 856 sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
 857 {
 858         struct sn9c102_device* cam;
 859         u8 index;
 860         ssize_t count;
 861
 862         if (down_interruptible(&sn9c102_sysfs_lock))
 863                 return -ERESTARTSYS;
 864
 865         cam = video_get_drvdata(to_video_device(cd));
 866         if (!cam) {
 867                 up(&sn9c102_sysfs_lock);
 868                 return -ENODEV;
 869         }
 870
 871         index = sn9c102_strtou8(buf, len, &count);
 872         if (index > 0x1f || !count) {
 873                 up(&sn9c102_sysfs_lock);
 874                 return -EINVAL;
 875         }
 876
 877         cam->sysfs.reg = index;
 878
 879         DBG(2, "Moved SN9C10X register index to 0x%02X", cam->sysfs.reg)
 880         DBG(3, "Written bytes: %zd", count)
 881
 882         up(&sn9c102_sysfs_lock);
 883
 884         return count;
 885 }
 886
 887
 888 static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
 889 {
 890         struct sn9c102_device* cam;
 891         ssize_t count;
 892         int val;
 893
 894         if (down_interruptible(&sn9c102_sysfs_lock))
 895                 return -ERESTARTSYS;
 896
 897         cam = video_get_drvdata(to_video_device(cd));
 898         if (!cam) {
 899                 up(&sn9c102_sysfs_lock);
 900                 return -ENODEV;
 901         }
 902
 903         if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
 904                 up(&sn9c102_sysfs_lock);
 905                 return -EIO;
 906         }
 907
 908         count = sprintf(buf, "%d\n", val);
 909
 910         DBG(3, "Read bytes: %zd", count)
 911
 912         up(&sn9c102_sysfs_lock);
 913
 914         return count;
 915 }
 916
 917
 918 static ssize_t
 919 sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
 920 {
 921         struct sn9c102_device* cam;
 922         u8 value;
 923         ssize_t count;
 924         int err;
 925
 926         if (down_interruptible(&sn9c102_sysfs_lock))
 927                 return -ERESTARTSYS;
 928
 929         cam = video_get_drvdata(to_video_device(cd));
 930         if (!cam) {
 931                 up(&sn9c102_sysfs_lock);
 932                 return -ENODEV;
 933         }
 934
 935         value = sn9c102_strtou8(buf, len, &count);
 936         if (!count) {
 937                 up(&sn9c102_sysfs_lock);
 938                 return -EINVAL;
 939         }
 940
 941         err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
 942         if (err) {
 943                 up(&sn9c102_sysfs_lock);
 944                 return -EIO;
 945         }
 946
 947         DBG(2, "Written SN9C10X reg. 0x%02X, val. 0x%02X",
 948             cam->sysfs.reg, value)
 949         DBG(3, "Written bytes: %zd", count)
 950
 951         up(&sn9c102_sysfs_lock);
 952
 953         return count;
 954 }
 955
 956
 957 static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
 958 {
 959         struct sn9c102_device* cam;
 960         ssize_t count;
 961
 962         if (down_interruptible(&sn9c102_sysfs_lock))
 963                 return -ERESTARTSYS;
 964
 965         cam = video_get_drvdata(to_video_device(cd));
 966         if (!cam) {
 967                 up(&sn9c102_sysfs_lock);
 968                 return -ENODEV;
 969         }
 970
 971         count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
 972
 973         DBG(3, "Read bytes: %zd", count)
 974
 975         up(&sn9c102_sysfs_lock);
 976
 977         return count;
 978 }
 979
 980
 981 static ssize_t
 982 sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
 983 {
 984         struct sn9c102_device* cam;
 985         u8 index;
 986         ssize_t count;
 987
 988         if (down_interruptible(&sn9c102_sysfs_lock))
 989                 return -ERESTARTSYS;
 990
 991         cam = video_get_drvdata(to_video_device(cd));
 992         if (!cam) {
 993                 up(&sn9c102_sysfs_lock);
 994                 return -ENODEV;
 995         }
 996
 997         index = sn9c102_strtou8(buf, len, &count);
 998         if (!count) {
 999                 up(&sn9c102_sysfs_lock);
1000                 return -EINVAL;
1001         }
1002
1003         cam->sysfs.i2c_reg = index;
1004
1005         DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg)
1006         DBG(3, "Written bytes: %zd", count)
1007
1008         up(&sn9c102_sysfs_lock);
1009
1010         return count;
1011 }
1012
1013
1014 static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
1015 {
1016         struct sn9c102_device* cam;
1017         ssize_t count;
1018         int val;
1019
1020         if (down_interruptible(&sn9c102_sysfs_lock))
1021                 return -ERESTARTSYS;
1022
1023         cam = video_get_drvdata(to_video_device(cd));
1024         if (!cam) {
1025                 up(&sn9c102_sysfs_lock);
1026                 return -ENODEV;
1027         }
1028
1029         if (!(cam->sensor->sysfs_ops & SN9C102_I2C_READ)) {
1030                 up(&sn9c102_sysfs_lock);
1031                 return -ENOSYS;
1032         }
1033
1034         if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1035                 up(&sn9c102_sysfs_lock);
1036                 return -EIO;
1037         }
1038
1039         count = sprintf(buf, "%d\n", val);
1040
1041         DBG(3, "Read bytes: %zd", count)
1042
1043         up(&sn9c102_sysfs_lock);
1044
1045         return count;
1046 }
1047
1048
1049 static ssize_t
1050 sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
1051 {
1052         struct sn9c102_device* cam;
1053         u8 value;
1054         ssize_t count;
1055         int err;
1056
1057         if (down_interruptible(&sn9c102_sysfs_lock))
1058                 return -ERESTARTSYS;
1059
1060         cam = video_get_drvdata(to_video_device(cd));
1061         if (!cam) {
1062                 up(&sn9c102_sysfs_lock);
1063                 return -ENODEV;
1064         }
1065
1066         if (!(cam->sensor->sysfs_ops & SN9C102_I2C_WRITE)) {
1067                 up(&sn9c102_sysfs_lock);
1068                 return -ENOSYS;
1069         }
1070
1071         value = sn9c102_strtou8(buf, len, &count);
1072         if (!count) {
1073                 up(&sn9c102_sysfs_lock);
1074                 return -EINVAL;
1075         }
1076
1077         err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1078         if (err) {
1079                 up(&sn9c102_sysfs_lock);
1080                 return -EIO;
1081         }
1082
1083         DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1084             cam->sysfs.i2c_reg, value)
1085         DBG(3, "Written bytes: %zd", count)
1086
1087         up(&sn9c102_sysfs_lock);
1088
1089         return count;
1090 }
1091
1092
1093 static ssize_t
1094 sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
1095 {
1096         struct sn9c102_device* cam;
1097         enum sn9c102_bridge bridge;
1098         ssize_t res = 0;
1099         u8 value;
1100         ssize_t count;
1101
1102         if (down_interruptible(&sn9c102_sysfs_lock))
1103                 return -ERESTARTSYS;
1104
1105         cam = video_get_drvdata(to_video_device(cd));
1106         if (!cam) {
1107                 up(&sn9c102_sysfs_lock);
1108                 return -ENODEV;
1109         }
1110
1111         bridge = cam->bridge;
1112
1113         up(&sn9c102_sysfs_lock);
1114
1115         value = sn9c102_strtou8(buf, len, &count);
1116         if (!count)
1117                 return -EINVAL;
1118
1119         switch (bridge) {
1120         case BRIDGE_SN9C101:
1121         case BRIDGE_SN9C102:
1122                 if (value > 0x0f)
1123                         return -EINVAL;
1124                 if ((res = sn9c102_store_reg(cd, "0x11", 4)) >= 0)
1125                         res = sn9c102_store_val(cd, buf, len);
1126                 break;
1127         case BRIDGE_SN9C103:
1128                 if (value > 0x7f)
1129                         return -EINVAL;
1130                 if ((res = sn9c102_store_reg(cd, "0x04", 4)) >= 0)
1131                         res = sn9c102_store_val(cd, buf, len);
1132                 break;
1133         }
1134
1135         return res;
1136 }
1137
1138
1139 static ssize_t
1140 sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
1141 {
1142         ssize_t res = 0;
1143         u8 value;
1144         ssize_t count;
1145
1146         value = sn9c102_strtou8(buf, len, &count);
1147         if (!count || value > 0x7f)
1148                 return -EINVAL;
1149
1150         if ((res = sn9c102_store_reg(cd, "0x06", 4)) >= 0)
1151                 res = sn9c102_store_val(cd, buf, len);
1152
1153         return res;
1154 }
1155
1156
1157 static ssize_t
1158 sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
1159 {
1160         ssize_t res = 0;
1161         u8 value;
1162         ssize_t count;
1163
1164         value = sn9c102_strtou8(buf, len, &count);
1165         if (!count || value > 0x7f)
1166                 return -EINVAL;
1167
1168         if ((res = sn9c102_store_reg(cd, "0x05", 4)) >= 0)
1169                 res = sn9c102_store_val(cd, buf, len);
1170
1171         return res;
1172 }
1173
1174
1175 static ssize_t sn9c102_show_frame_header(struct class_device* cd, char* buf)
1176 {
1177         struct sn9c102_device* cam;
1178         ssize_t count;
1179
1180         cam = video_get_drvdata(to_video_device(cd));
1181         if (!cam)
1182                 return -ENODEV;
1183
1184         count = sizeof(cam->sysfs.frame_header);
1185         memcpy(buf, cam->sysfs.frame_header, count);
1186
1187         DBG(3, "Frame header, read bytes: %zd", count)
1188
1189         return count;
1190 }
1191
1192
1193 static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
1194                          sn9c102_show_reg, sn9c102_store_reg);
1195 static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
1196                          sn9c102_show_val, sn9c102_store_val);
1197 static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1198                          sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1199 static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1200                          sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1201 static CLASS_DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1202 static CLASS_DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1203 static CLASS_DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1204 static CLASS_DEVICE_ATTR(frame_header, S_IRUGO,
1205                          sn9c102_show_frame_header, NULL);
1206
1207
1208 static void sn9c102_create_sysfs(struct sn9c102_device* cam)
1209 {
1210         struct video_device *v4ldev = cam->v4ldev;
1211
1212         video_device_create_file(v4ldev, &class_device_attr_reg);
1213         video_device_create_file(v4ldev, &class_device_attr_val);
1214         video_device_create_file(v4ldev, &class_device_attr_frame_header);
1215         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
1216                 video_device_create_file(v4ldev, &class_device_attr_green);
1217         else if (cam->bridge == BRIDGE_SN9C103) {
1218                 video_device_create_file(v4ldev, &class_device_attr_blue);
1219                 video_device_create_file(v4ldev, &class_device_attr_red);
1220         }
1221         if (cam->sensor->sysfs_ops) {
1222                 video_device_create_file(v4ldev, &class_device_attr_i2c_reg);
1223                 video_device_create_file(v4ldev, &class_device_attr_i2c_val);
1224         }
1225 }
1226
1227 /*****************************************************************************/
1228
1229 static int
1230 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1231 {
1232         int err = 0;
1233
1234         if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
1235                 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80, 0x18);
1236         else
1237                 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f, 0x18);
1238
1239         return err ? -EIO : 0;
1240 }
1241
1242
1243 static int
1244 sn9c102_set_compression(struct sn9c102_device* cam,
1245                         struct v4l2_jpegcompression* compression)
1246 {
1247         int err = 0;
1248
1249         if (compression->quality == 0)
1250                 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01, 0x17);
1251         else if (compression->quality == 1)
1252                 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe, 0x17);
1253
1254         return err ? -EIO : 0;
1255 }
1256
1257
1258 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1259 {
1260         u8 r = 0;
1261         int err = 0;
1262
1263         if (scale == 1)
1264                 r = cam->reg[0x18] & 0xcf;
1265         else if (scale == 2) {
1266                 r = cam->reg[0x18] & 0xcf;
1267                 r |= 0x10;
1268         } else if (scale == 4)
1269                 r = cam->reg[0x18] | 0x20;
1270
1271         err += sn9c102_write_reg(cam, r, 0x18);
1272         if (err)
1273                 return -EIO;
1274
1275         PDBGG("Scaling factor: %u", scale)
1276
1277         return 0;
1278 }
1279
1280
1281 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1282 {
1283         struct sn9c102_sensor* s = cam->sensor;
1284         u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1285            v_start = (u8)(rect->top - s->cropcap.bounds.top),
1286            h_size = (u8)(rect->width / 16),
1287            v_size = (u8)(rect->height / 16);
1288         int err = 0;
1289
1290         err += sn9c102_write_reg(cam, h_start, 0x12);
1291         err += sn9c102_write_reg(cam, v_start, 0x13);
1292         err += sn9c102_write_reg(cam, h_size, 0x15);
1293         err += sn9c102_write_reg(cam, v_size, 0x16);
1294         if (err)
1295                 return -EIO;
1296
1297         PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1298               "%u %u %u %u", h_start, v_start, h_size, v_size)
1299
1300         return 0;
1301 }
1302
1303
1304 static int sn9c102_init(struct sn9c102_device* cam)
1305 {
1306         struct sn9c102_sensor* s = cam->sensor;
1307         struct v4l2_control ctrl;
1308         struct v4l2_queryctrl *qctrl;
1309         struct v4l2_rect* rect;
1310         u8 i = 0, n = 0;
1311         int err = 0;
1312
1313         if (!(cam->state & DEV_INITIALIZED)) {
1314                 init_waitqueue_head(&cam->open);
1315                 qctrl = s->qctrl;
1316                 rect = &(s->cropcap.defrect);
1317         } else { /* use current values */
1318                 qctrl = s->_qctrl;
1319                 rect = &(s->_rect);
1320         }
1321
1322         err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1323         err += sn9c102_set_crop(cam, rect);
1324         if (err)
1325                 return err;
1326
1327         if (s->init) {
1328                 err = s->init(cam);
1329                 if (err) {
1330                         DBG(3, "Sensor initialization failed")
1331                         return err;
1332                 }
1333         }
1334
1335         if (!(cam->state & DEV_INITIALIZED))
1336                 cam->compression.quality =  cam->reg[0x17] & 0x01 ? 0 : 1;
1337         else
1338                 err += sn9c102_set_compression(cam, &cam->compression);
1339         err += sn9c102_set_pix_format(cam, &s->pix_format);
1340         if (s->set_pix_format)
1341                 err += s->set_pix_format(cam, &s->pix_format);
1342         if (err)
1343                 return err;
1344
1345         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1346                 DBG(3, "Compressed video format is active, quality %d",
1347                     cam->compression.quality)
1348         else
1349                 DBG(3, "Uncompressed video format is active")
1350
1351         if (s->set_crop)
1352                 if ((err = s->set_crop(cam, rect))) {
1353                         DBG(3, "set_crop() failed")
1354                         return err;
1355                 }
1356
1357         if (s->set_ctrl) {
1358                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1359                 for (i = 0; i < n; i++)
1360                         if (s->qctrl[i].id != 0 &&
1361                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1362                                 ctrl.id = s->qctrl[i].id;
1363                                 ctrl.value = qctrl[i].default_value;
1364                                 err = s->set_ctrl(cam, &ctrl);
1365                                 if (err) {
1366                                         DBG(3, "Set %s control failed",
1367                                             s->qctrl[i].name)
1368                                         return err;
1369                                 }
1370                                 DBG(3, "Image sensor supports '%s' control",
1371                                     s->qctrl[i].name)
1372                         }
1373         }
1374
1375         if (!(cam->state & DEV_INITIALIZED)) {
1376                 init_MUTEX(&cam->fileop_sem);
1377                 spin_lock_init(&cam->queue_lock);
1378                 init_waitqueue_head(&cam->wait_frame);
1379                 init_waitqueue_head(&cam->wait_stream);
1380                 cam->nreadbuffers = 2;
1381                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1382                 memcpy(&(s->_rect), &(s->cropcap.defrect),
1383                        sizeof(struct v4l2_rect));
1384                 cam->state |= DEV_INITIALIZED;
1385         }
1386
1387         DBG(2, "Initialization succeeded")
1388         return 0;
1389 }
1390
1391
1392 static void sn9c102_release_resources(struct sn9c102_device* cam)
1393 {
1394         down(&sn9c102_sysfs_lock);
1395
1396         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor)
1397         video_set_drvdata(cam->v4ldev, NULL);
1398         video_unregister_device(cam->v4ldev);
1399
1400         up(&sn9c102_sysfs_lock);
1401
1402         kfree(cam->control_buffer);
1403 }
1404
1405 /*****************************************************************************/
1406
1407 static int sn9c102_open(struct inode* inode, struct file* filp)
1408 {
1409         struct sn9c102_device* cam;
1410         int err = 0;
1411
1412         /*
1413            This is the only safe way to prevent race conditions with
1414            disconnect
1415         */
1416         if (!down_read_trylock(&sn9c102_disconnect))
1417                 return -ERESTARTSYS;
1418
1419         cam = video_get_drvdata(video_devdata(filp));
1420
1421         if (down_interruptible(&cam->dev_sem)) {
1422                 up_read(&sn9c102_disconnect);
1423                 return -ERESTARTSYS;
1424         }
1425
1426         if (cam->users) {
1427                 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor)
1428                 if ((filp->f_flags & O_NONBLOCK) ||
1429                     (filp->f_flags & O_NDELAY)) {
1430                         err = -EWOULDBLOCK;
1431                         goto out;
1432                 }
1433                 up(&cam->dev_sem);
1434                 err = wait_event_interruptible_exclusive(cam->open,
1435                                                   cam->state & DEV_DISCONNECTED
1436                                                          || !cam->users);
1437                 if (err) {
1438                         up_read(&sn9c102_disconnect);
1439                         return err;
1440                 }
1441                 if (cam->state & DEV_DISCONNECTED) {
1442                         up_read(&sn9c102_disconnect);
1443                         return -ENODEV;
1444                 }
1445                 down(&cam->dev_sem);
1446         }
1447
1448
1449         if (cam->state & DEV_MISCONFIGURED) {
1450                 err = sn9c102_init(cam);
1451                 if (err) {
1452                         DBG(1, "Initialization failed again. "
1453                                "I will retry on next open().")
1454                         goto out;
1455                 }
1456                 cam->state &= ~DEV_MISCONFIGURED;
1457         }
1458
1459         if ((err = sn9c102_start_transfer(cam)))
1460                 goto out;
1461
1462         filp->private_data = cam;
1463         cam->users++;
1464         cam->io = IO_NONE;
1465         cam->stream = STREAM_OFF;
1466         cam->nbuffers = 0;
1467         cam->frame_count = 0;
1468         sn9c102_empty_framequeues(cam);
1469
1470         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor)
1471
1472 out:
1473         up(&cam->dev_sem);
1474         up_read(&sn9c102_disconnect);
1475         return err;
1476 }
1477
1478
1479 static int sn9c102_release(struct inode* inode, struct file* filp)
1480 {
1481         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1482
1483         down(&cam->dev_sem); /* prevent disconnect() to be called */
1484
1485         sn9c102_stop_transfer(cam);
1486
1487         sn9c102_release_buffers(cam);
1488
1489         if (cam->state & DEV_DISCONNECTED) {
1490                 sn9c102_release_resources(cam);
1491                 up(&cam->dev_sem);
1492                 kfree(cam);
1493                 return 0;
1494         }
1495
1496         cam->users--;
1497         wake_up_interruptible_nr(&cam->open, 1);
1498
1499         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor)
1500
1501         up(&cam->dev_sem);
1502
1503         return 0;
1504 }
1505
1506
1507 static ssize_t
1508 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1509 {
1510         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1511         struct sn9c102_frame_t* f, * i;
1512         unsigned long lock_flags;
1513         int err = 0;
1514
1515         if (down_interruptible(&cam->fileop_sem))
1516                 return -ERESTARTSYS;
1517
1518         if (cam->state & DEV_DISCONNECTED) {
1519                 DBG(1, "Device not present")
1520                 up(&cam->fileop_sem);
1521                 return -ENODEV;
1522         }
1523
1524         if (cam->state & DEV_MISCONFIGURED) {
1525                 DBG(1, "The camera is misconfigured. Close and open it again.")
1526                 up(&cam->fileop_sem);
1527                 return -EIO;
1528         }
1529
1530         if (cam->io == IO_MMAP) {
1531                 DBG(3, "Close and open the device again to choose "
1532                        "the read method")
1533                 up(&cam->fileop_sem);
1534                 return -EINVAL;
1535         }
1536
1537         if (cam->io == IO_NONE) {
1538                 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1539                         DBG(1, "read() failed, not enough memory")
1540                         up(&cam->fileop_sem);
1541                         return -ENOMEM;
1542                 }
1543                 cam->io = IO_READ;
1544                 cam->stream = STREAM_ON;
1545                 sn9c102_queue_unusedframes(cam);
1546         }
1547
1548         if (!count) {
1549                 up(&cam->fileop_sem);
1550                 return 0;
1551         }
1552
1553         if (list_empty(&cam->outqueue)) {
1554                 if (filp->f_flags & O_NONBLOCK) {
1555                         up(&cam->fileop_sem);
1556                         return -EAGAIN;
1557                 }
1558                 err = wait_event_interruptible
1559                       ( cam->wait_frame,
1560                         (!list_empty(&cam->outqueue)) ||
1561                         (cam->state & DEV_DISCONNECTED) );
1562                 if (err) {
1563                         up(&cam->fileop_sem);
1564                         return err;
1565                 }
1566                 if (cam->state & DEV_DISCONNECTED) {
1567                         up(&cam->fileop_sem);
1568                         return -ENODEV;
1569                 }
1570         }
1571
1572         f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1573
1574         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1575         list_for_each_entry(i, &cam->outqueue, frame)
1576                 i->state = F_UNUSED;
1577         INIT_LIST_HEAD(&cam->outqueue);
1578         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1579
1580         sn9c102_queue_unusedframes(cam);
1581
1582         if (count > f->buf.bytesused)
1583                 count = f->buf.bytesused;
1584
1585         if (copy_to_user(buf, f->bufmem, count)) {
1586                 up(&cam->fileop_sem);
1587                 return -EFAULT;
1588         }
1589         *f_pos += count;
1590
1591         PDBGG("Frame #%lu, bytes read: %zu", (unsigned long)f->buf.index,count)
1592
1593         up(&cam->fileop_sem);
1594
1595         return count;
1596 }
1597
1598
1599 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1600 {
1601         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1602         unsigned int mask = 0;
1603
1604         if (down_interruptible(&cam->fileop_sem))
1605                 return POLLERR;
1606
1607         if (cam->state & DEV_DISCONNECTED) {
1608                 DBG(1, "Device not present")
1609                 goto error;
1610         }
1611
1612         if (cam->state & DEV_MISCONFIGURED) {
1613                 DBG(1, "The camera is misconfigured. Close and open it again.")
1614                 goto error;
1615         }
1616
1617         if (cam->io == IO_NONE) {
1618                 if (!sn9c102_request_buffers(cam, 2, IO_READ)) {
1619                         DBG(1, "poll() failed, not enough memory")
1620                         goto error;
1621                 }
1622                 cam->io = IO_READ;
1623                 cam->stream = STREAM_ON;
1624         }
1625
1626         if (cam->io == IO_READ)
1627                 sn9c102_queue_unusedframes(cam);
1628
1629         poll_wait(filp, &cam->wait_frame, wait);
1630
1631         if (!list_empty(&cam->outqueue))
1632                 mask |= POLLIN | POLLRDNORM;
1633
1634         up(&cam->fileop_sem);
1635
1636         return mask;
1637
1638 error:
1639         up(&cam->fileop_sem);
1640         return POLLERR;
1641 }
1642
1643
1644 static void sn9c102_vm_open(struct vm_area_struct* vma)
1645 {
1646         struct sn9c102_frame_t* f = vma->vm_private_data;
1647         f->vma_use_count++;
1648 }
1649
1650
1651 static void sn9c102_vm_close(struct vm_area_struct* vma)
1652 {
1653         /* NOTE: buffers are not freed here */
1654         struct sn9c102_frame_t* f = vma->vm_private_data;
1655         f->vma_use_count--;
1656 }
1657
1658
1659 static struct vm_operations_struct sn9c102_vm_ops = {
1660         .open = sn9c102_vm_open,
1661         .close = sn9c102_vm_close,
1662 };
1663
1664
1665 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
1666 {
1667         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1668         unsigned long size = vma->vm_end - vma->vm_start,
1669                       start = vma->vm_start,
1670                       pos,
1671                       page;
1672         u32 i;
1673
1674         if (down_interruptible(&cam->fileop_sem))
1675                 return -ERESTARTSYS;
1676
1677         if (cam->state & DEV_DISCONNECTED) {
1678                 DBG(1, "Device not present")
1679                 up(&cam->fileop_sem);
1680                 return -ENODEV;
1681         }
1682
1683         if (cam->state & DEV_MISCONFIGURED) {
1684                 DBG(1, "The camera is misconfigured. Close and open it again.")
1685                 up(&cam->fileop_sem);
1686                 return -EIO;
1687         }
1688
1689         if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
1690             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
1691                 up(&cam->fileop_sem);
1692                 return -EINVAL;
1693         }
1694
1695         for (i = 0; i < cam->nbuffers; i++) {
1696                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
1697                         break;
1698         }
1699         if (i == cam->nbuffers) {
1700                 up(&cam->fileop_sem);
1701                 return -EINVAL;
1702         }
1703
1704         /* VM_IO is eventually going to replace PageReserved altogether */
1705         vma->vm_flags |= VM_IO;
1706         vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1707
1708         pos = (unsigned long)cam->frame[i].bufmem;
1709         while (size > 0) { /* size is page-aligned */
1710                 page = vmalloc_to_pfn((void *)pos);
1711                 if (remap_pfn_range(vma, start, page, PAGE_SIZE,
1712                                     vma->vm_page_prot)) {
1713                         up(&cam->fileop_sem);
1714                         return -EAGAIN;
1715                 }
1716                 start += PAGE_SIZE;
1717                 pos += PAGE_SIZE;
1718                 size -= PAGE_SIZE;
1719         }
1720
1721         vma->vm_ops = &sn9c102_vm_ops;
1722         vma->vm_private_data = &cam->frame[i];
1723
1724         sn9c102_vm_open(vma);
1725
1726         up(&cam->fileop_sem);
1727
1728         return 0;
1729 }
1730
1731
1732 static int sn9c102_v4l2_ioctl(struct inode* inode, struct file* filp,
1733                               unsigned int cmd, void __user * arg)
1734 {
1735         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1736
1737         switch (cmd) {
1738
1739         case VIDIOC_QUERYCAP:
1740         {
1741                 struct v4l2_capability cap = {
1742                         .driver = "sn9c102",
1743                         .version = SN9C102_MODULE_VERSION_CODE,
1744                         .capabilities = V4L2_CAP_VIDEO_CAPTURE |
1745                                         V4L2_CAP_READWRITE |
1746                                         V4L2_CAP_STREAMING,
1747                 };
1748
1749                 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
1750                 if (usb_make_path(cam->usbdev, cap.bus_info,
1751                     sizeof(cap.bus_info)) < 0)
1752                         strlcpy(cap.bus_info, cam->dev.bus_id,
1753                                 sizeof(cap.bus_info));
1754
1755                 if (copy_to_user(arg, &cap, sizeof(cap)))
1756                         return -EFAULT;
1757
1758                 return 0;
1759         }
1760
1761         case VIDIOC_ENUMINPUT:
1762         {
1763                 struct v4l2_input i;
1764
1765                 if (copy_from_user(&i, arg, sizeof(i)))
1766                         return -EFAULT;
1767
1768                 if (i.index)
1769                         return -EINVAL;
1770
1771                 memset(&i, 0, sizeof(i));
1772                 strcpy(i.name, "USB");
1773
1774                 if (copy_to_user(arg, &i, sizeof(i)))
1775                         return -EFAULT;
1776
1777                 return 0;
1778         }
1779
1780         case VIDIOC_G_INPUT:
1781         case VIDIOC_S_INPUT:
1782         {
1783                 int index;
1784
1785                 if (copy_from_user(&index, arg, sizeof(index)))
1786                         return -EFAULT;
1787
1788                 if (index != 0)
1789                         return -EINVAL;
1790
1791                 return 0;
1792         }
1793
1794         case VIDIOC_QUERYCTRL:
1795         {
1796                 struct sn9c102_sensor* s = cam->sensor;
1797                 struct v4l2_queryctrl qc;
1798                 u8 i, n;
1799
1800                 if (copy_from_user(&qc, arg, sizeof(qc)))
1801                         return -EFAULT;
1802
1803                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1804                 for (i = 0; i < n; i++)
1805                         if (qc.id && qc.id == s->qctrl[i].id) {
1806                                 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
1807                                 if (copy_to_user(arg, &qc, sizeof(qc)))
1808                                         return -EFAULT;
1809                                 return 0;
1810                         }
1811
1812                 return -EINVAL;
1813         }
1814
1815         case VIDIOC_G_CTRL:
1816         {
1817                 struct sn9c102_sensor* s = cam->sensor;
1818                 struct v4l2_control ctrl;
1819                 int err = 0;
1820
1821                 if (!s->get_ctrl)
1822                         return -EINVAL;
1823
1824                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1825                         return -EFAULT;
1826
1827                 err = s->get_ctrl(cam, &ctrl);
1828
1829                 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
1830                         return -EFAULT;
1831
1832                 return err;
1833         }
1834
1835         case VIDIOC_S_CTRL_OLD:
1836         case VIDIOC_S_CTRL:
1837         {
1838                 struct sn9c102_sensor* s = cam->sensor;
1839                 struct v4l2_control ctrl;
1840                 u8 i, n;
1841                 int err = 0;
1842
1843                 if (!s->set_ctrl)
1844                         return -EINVAL;
1845
1846                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1847                         return -EFAULT;
1848
1849                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1850                 for (i = 0; i < n; i++)
1851                         if (ctrl.id == s->qctrl[i].id) {
1852                                 if (ctrl.value < s->qctrl[i].minimum ||
1853                                     ctrl.value > s->qctrl[i].maximum)
1854                                         return -ERANGE;
1855                                 ctrl.value -= ctrl.value % s->qctrl[i].step;
1856                                 break;
1857                         }
1858
1859                 if ((err = s->set_ctrl(cam, &ctrl)))
1860                         return err;
1861
1862                 s->_qctrl[i].default_value = ctrl.value;
1863
1864                 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
1865                       (unsigned long)ctrl.id, (unsigned long)ctrl.value)
1866
1867                 return 0;
1868         }
1869
1870         case VIDIOC_CROPCAP:
1871         {
1872                 struct v4l2_cropcap* cc = &(cam->sensor->cropcap);
1873
1874                 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1875                 cc->pixelaspect.numerator = 1;
1876                 cc->pixelaspect.denominator = 1;
1877
1878                 if (copy_to_user(arg, cc, sizeof(*cc)))
1879                         return -EFAULT;
1880
1881                 return 0;
1882         }
1883
1884         case VIDIOC_G_CROP:
1885         {
1886                 struct sn9c102_sensor* s = cam->sensor;
1887                 struct v4l2_crop crop = {
1888                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
1889                 };
1890
1891                 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
1892
1893                 if (copy_to_user(arg, &crop, sizeof(crop)))
1894                         return -EFAULT;
1895
1896                 return 0;
1897         }
1898
1899         case VIDIOC_S_CROP:
1900         {
1901                 struct sn9c102_sensor* s = cam->sensor;
1902                 struct v4l2_crop crop;
1903                 struct v4l2_rect* rect;
1904                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
1905                 struct v4l2_pix_format* pix_format = &(s->pix_format);
1906                 u8 scale;
1907                 const enum sn9c102_stream_state stream = cam->stream;
1908                 const u32 nbuffers = cam->nbuffers;
1909                 u32 i;
1910                 int err = 0;
1911
1912                 if (copy_from_user(&crop, arg, sizeof(crop)))
1913                         return -EFAULT;
1914
1915                 rect = &(crop.c);
1916
1917                 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1918                         return -EINVAL;
1919
1920                 if (cam->module_param.force_munmap)
1921                         for (i = 0; i < cam->nbuffers; i++)
1922                                 if (cam->frame[i].vma_use_count) {
1923                                         DBG(3, "VIDIOC_S_CROP failed. "
1924                                                "Unmap the buffers first.")
1925                                         return -EINVAL;
1926                                 }
1927
1928                 /* Preserve R,G or B origin */
1929                 rect->left = (s->_rect.left & 1L) ?
1930                              rect->left | 1L : rect->left & ~1L;
1931                 rect->top = (s->_rect.top & 1L) ?
1932                             rect->top | 1L : rect->top & ~1L;
1933
1934                 if (rect->width < 16)
1935                         rect->width = 16;
1936                 if (rect->height < 16)
1937                         rect->height = 16;
1938                 if (rect->width > bounds->width)
1939                         rect->width = bounds->width;
1940                 if (rect->height > bounds->height)
1941                         rect->height = bounds->height;
1942                 if (rect->left < bounds->left)
1943                         rect->left = bounds->left;
1944                 if (rect->top < bounds->top)
1945                         rect->top = bounds->top;
1946                 if (rect->left + rect->width > bounds->left + bounds->width)
1947                         rect->left = bounds->left+bounds->width - rect->width;
1948                 if (rect->top + rect->height > bounds->top + bounds->height)
1949                         rect->top = bounds->top+bounds->height - rect->height;
1950
1951                 rect->width &= ~15L;
1952                 rect->height &= ~15L;
1953
1954                 if (SN9C102_PRESERVE_IMGSCALE) {
1955                         /* Calculate the actual scaling factor */
1956                         u32 a, b;
1957                         a = rect->width * rect->height;
1958                         b = pix_format->width * pix_format->height;
1959                         scale = b ? (u8)((a / b) < 4 ? 1 :
1960                                         ((a / b) < 16 ? 2 : 4)) : 1;
1961                 } else
1962                         scale = 1;
1963
1964                 if (cam->stream == STREAM_ON)
1965                         if ((err = sn9c102_stream_interrupt(cam)))
1966                                 return err;
1967
1968                 if (copy_to_user(arg, &crop, sizeof(crop))) {
1969                         cam->stream = stream;
1970                         return -EFAULT;
1971                 }
1972
1973                 if (cam->module_param.force_munmap)
1974                         sn9c102_release_buffers(cam);
1975
1976                 err = sn9c102_set_crop(cam, rect);
1977                 if (s->set_crop)
1978                         err += s->set_crop(cam, rect);
1979                 err += sn9c102_set_scale(cam, scale);
1980
1981                 if (err) { /* atomic, no rollback in ioctl() */
1982                         cam->state |= DEV_MISCONFIGURED;
1983                         DBG(1, "VIDIOC_S_CROP failed because of hardware "
1984                                "problems. To use the camera, close and open "
1985                                "/dev/video%d again.", cam->v4ldev->minor)
1986                         return -EIO;
1987                 }
1988
1989                 s->pix_format.width = rect->width/scale;
1990                 s->pix_format.height = rect->height/scale;
1991                 memcpy(&(s->_rect), rect, sizeof(*rect));
1992
1993                 if (cam->module_param.force_munmap &&
1994                     nbuffers != sn9c102_request_buffers(cam, nbuffers,
1995                                                         cam->io)) {
1996                         cam->state |= DEV_MISCONFIGURED;
1997                         DBG(1, "VIDIOC_S_CROP failed because of not enough "
1998                                "memory. To use the camera, close and open "
1999                                "/dev/video%d again.", cam->v4ldev->minor)
2000                         return -ENOMEM;
2001                 }
2002
2003                 cam->stream = stream;
2004
2005                 return 0;
2006         }
2007
2008         case VIDIOC_ENUM_FMT:
2009         {
2010                 struct v4l2_fmtdesc fmtd;
2011
2012                 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2013                         return -EFAULT;
2014
2015                 if (fmtd.index == 0) {
2016                         strcpy(fmtd.description, "bayer rgb");
2017                         fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2018                 } else if (fmtd.index == 1) {
2019                         strcpy(fmtd.description, "compressed");
2020                         fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2021                         fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2022                 } else
2023                         return -EINVAL;
2024
2025                 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2026                 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2027
2028                 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2029                         return -EFAULT;
2030
2031                 return 0;
2032         }
2033
2034         case VIDIOC_G_FMT:
2035         {
2036                 struct v4l2_format format;
2037                 struct v4l2_pix_format* pfmt = &(cam->sensor->pix_format);
2038
2039                 if (copy_from_user(&format, arg, sizeof(format)))
2040                         return -EFAULT;
2041
2042                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2043                         return -EINVAL;
2044
2045                 pfmt->bytesperline = (pfmt->pixelformat==V4L2_PIX_FMT_SN9C10X)
2046                                      ? 0 : (pfmt->width * pfmt->priv) / 8;
2047                 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2048                 pfmt->field = V4L2_FIELD_NONE;
2049                 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2050
2051                 if (copy_to_user(arg, &format, sizeof(format)))
2052                         return -EFAULT;
2053
2054                 return 0;
2055         }
2056
2057         case VIDIOC_TRY_FMT:
2058         case VIDIOC_S_FMT:
2059         {
2060                 struct sn9c102_sensor* s = cam->sensor;
2061                 struct v4l2_format format;
2062                 struct v4l2_pix_format* pix;
2063                 struct v4l2_pix_format* pfmt = &(s->pix_format);
2064                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2065                 struct v4l2_rect rect;
2066                 u8 scale;
2067                 const enum sn9c102_stream_state stream = cam->stream;
2068                 const u32 nbuffers = cam->nbuffers;
2069                 u32 i;
2070                 int err = 0;
2071
2072                 if (copy_from_user(&format, arg, sizeof(format)))
2073                         return -EFAULT;
2074
2075                 pix = &(format.fmt.pix);
2076
2077                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2078                         return -EINVAL;
2079
2080                 memcpy(&rect, &(s->_rect), sizeof(rect));
2081
2082                 { /* calculate the actual scaling factor */
2083                         u32 a, b;
2084                         a = rect.width * rect.height;
2085                         b = pix->width * pix->height;
2086                         scale = b ? (u8)((a / b) < 4 ? 1 :
2087                                         ((a / b) < 16 ? 2 : 4)) : 1;
2088                 }
2089
2090                 rect.width = scale * pix->width;
2091                 rect.height = scale * pix->height;
2092
2093                 if (rect.width < 16)
2094                         rect.width = 16;
2095                 if (rect.height < 16)
2096                         rect.height = 16;
2097                 if (rect.width > bounds->left + bounds->width - rect.left)
2098                         rect.width = bounds->left + bounds->width - rect.left;
2099                 if (rect.height > bounds->top + bounds->height - rect.top)
2100                         rect.height = bounds->top + bounds->height - rect.top;
2101
2102                 rect.width &= ~15L;
2103                 rect.height &= ~15L;
2104
2105                 { /* adjust the scaling factor */
2106                         u32 a, b;
2107                         a = rect.width * rect.height;
2108                         b = pix->width * pix->height;
2109                         scale = b ? (u8)((a / b) < 4 ? 1 :
2110                                         ((a / b) < 16 ? 2 : 4)) : 1;
2111                 }
2112
2113                 pix->width = rect.width / scale;
2114                 pix->height = rect.height / scale;
2115
2116                 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2117                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2118                         pix->pixelformat = pfmt->pixelformat;
2119                 pix->priv = pfmt->priv; /* bpp */
2120                 pix->colorspace = pfmt->colorspace;
2121                 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
2122                                     ? 0 : (pix->width * pix->priv) / 8;
2123                 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2124                 pix->field = V4L2_FIELD_NONE;
2125
2126                 if (cmd == VIDIOC_TRY_FMT) {
2127                         if (copy_to_user(arg, &format, sizeof(format)))
2128                                 return -EFAULT;
2129                         return 0;
2130                 }
2131
2132                 if (cam->module_param.force_munmap)
2133                         for (i = 0; i < cam->nbuffers; i++)
2134                                 if (cam->frame[i].vma_use_count) {
2135                                         DBG(3, "VIDIOC_S_FMT failed. "
2136                                                "Unmap the buffers first.")
2137                                         return -EINVAL;
2138                                 }
2139
2140                 if (cam->stream == STREAM_ON)
2141                         if ((err = sn9c102_stream_interrupt(cam)))
2142                                 return err;
2143
2144                 if (copy_to_user(arg, &format, sizeof(format))) {
2145                         cam->stream = stream;
2146                         return -EFAULT;
2147                 }
2148
2149                 if (cam->module_param.force_munmap)
2150                         sn9c102_release_buffers(cam);
2151
2152                 err += sn9c102_set_pix_format(cam, pix);
2153                 err += sn9c102_set_crop(cam, &rect);
2154                 if (s->set_pix_format)
2155                         err += s->set_pix_format(cam, pix);
2156                 if (s->set_crop)
2157                         err += s->set_crop(cam, &rect);
2158                 err += sn9c102_set_scale(cam, scale);
2159
2160                 if (err) { /* atomic, no rollback in ioctl() */
2161                         cam->state |= DEV_MISCONFIGURED;
2162                         DBG(1, "VIDIOC_S_FMT failed because of hardware "
2163                                "problems. To use the camera, close and open "
2164                                "/dev/video%d again.", cam->v4ldev->minor)
2165                         return -EIO;
2166                 }
2167
2168                 memcpy(pfmt, pix, sizeof(*pix));
2169                 memcpy(&(s->_rect), &rect, sizeof(rect));
2170
2171                 if (cam->module_param.force_munmap &&
2172                     nbuffers != sn9c102_request_buffers(cam, nbuffers,
2173                                                         cam->io)) {
2174                         cam->state |= DEV_MISCONFIGURED;
2175                         DBG(1, "VIDIOC_S_FMT failed because of not enough "
2176                                "memory. To use the camera, close and open "
2177                                "/dev/video%d again.", cam->v4ldev->minor)
2178                         return -ENOMEM;
2179                 }
2180
2181                 cam->stream = stream;
2182
2183                 return 0;
2184         }
2185
2186         case VIDIOC_G_JPEGCOMP:
2187         {
2188                 if (copy_to_user(arg, &cam->compression,
2189                                  sizeof(cam->compression)))
2190                         return -EFAULT;
2191
2192                 return 0;
2193         }
2194
2195         case VIDIOC_S_JPEGCOMP:
2196         {
2197                 struct v4l2_jpegcompression jc;
2198                 const enum sn9c102_stream_state stream = cam->stream;
2199                 int err = 0;
2200
2201                 if (copy_from_user(&jc, arg, sizeof(jc)))
2202                         return -EFAULT;
2203
2204                 if (jc.quality != 0 && jc.quality != 1)
2205                         return -EINVAL;
2206
2207                 if (cam->stream == STREAM_ON)
2208                         if ((err = sn9c102_stream_interrupt(cam)))
2209                                 return err;
2210
2211                 err += sn9c102_set_compression(cam, &jc);
2212                 if (err) { /* atomic, no rollback in ioctl() */
2213                         cam->state |= DEV_MISCONFIGURED;
2214                         DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2215                                "problems. To use the camera, close and open "
2216                                "/dev/video%d again.", cam->v4ldev->minor)
2217                         return -EIO;
2218                 }
2219
2220                 cam->compression.quality = jc.quality;
2221
2222                 cam->stream = stream;
2223
2224                 return 0;
2225         }
2226
2227         case VIDIOC_REQBUFS:
2228         {
2229                 struct v4l2_requestbuffers rb;
2230                 u32 i;
2231                 int err;
2232
2233                 if (copy_from_user(&rb, arg, sizeof(rb)))
2234                         return -EFAULT;
2235
2236                 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2237                     rb.memory != V4L2_MEMORY_MMAP)
2238                         return -EINVAL;
2239
2240                 if (cam->io == IO_READ) {
2241                         DBG(3, "Close and open the device again to choose "
2242                                "the mmap I/O method")
2243                         return -EINVAL;
2244                 }
2245
2246                 for (i = 0; i < cam->nbuffers; i++)
2247                         if (cam->frame[i].vma_use_count) {
2248                                 DBG(3, "VIDIOC_REQBUFS failed. "
2249                                        "Previous buffers are still mapped.")
2250                                 return -EINVAL;
2251                         }
2252
2253                 if (cam->stream == STREAM_ON)
2254                         if ((err = sn9c102_stream_interrupt(cam)))
2255                                 return err;
2256
2257                 sn9c102_empty_framequeues(cam);
2258
2259                 sn9c102_release_buffers(cam);
2260                 if (rb.count)
2261                         rb.count = sn9c102_request_buffers(cam, rb.count,
2262                                                            IO_MMAP);
2263
2264                 if (copy_to_user(arg, &rb, sizeof(rb))) {
2265                         sn9c102_release_buffers(cam);
2266                         cam->io = IO_NONE;
2267                         return -EFAULT;
2268                 }
2269
2270                 cam->io = rb.count ? IO_MMAP : IO_NONE;
2271
2272                 return 0;
2273         }
2274
2275         case VIDIOC_QUERYBUF:
2276         {
2277                 struct v4l2_buffer b;
2278
2279                 if (copy_from_user(&b, arg, sizeof(b)))
2280                         return -EFAULT;
2281
2282                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2283                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2284                         return -EINVAL;
2285
2286                 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2287
2288                 if (cam->frame[b.index].vma_use_count)
2289                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2290
2291                 if (cam->frame[b.index].state == F_DONE)
2292                         b.flags |= V4L2_BUF_FLAG_DONE;
2293                 else if (cam->frame[b.index].state != F_UNUSED)
2294                         b.flags |= V4L2_BUF_FLAG_QUEUED;
2295
2296                 if (copy_to_user(arg, &b, sizeof(b)))
2297                         return -EFAULT;
2298
2299                 return 0;
2300         }
2301
2302         case VIDIOC_QBUF:
2303         {
2304                 struct v4l2_buffer b;
2305                 unsigned long lock_flags;
2306
2307                 if (copy_from_user(&b, arg, sizeof(b)))
2308                         return -EFAULT;
2309
2310                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2311                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2312                         return -EINVAL;
2313
2314                 if (cam->frame[b.index].state != F_UNUSED)
2315                         return -EINVAL;
2316
2317                 cam->frame[b.index].state = F_QUEUED;
2318
2319                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2320                 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2321                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2322
2323                 PDBGG("Frame #%lu queued", (unsigned long)b.index)
2324
2325                 return 0;
2326         }
2327
2328         case VIDIOC_DQBUF:
2329         {
2330                 struct v4l2_buffer b;
2331                 struct sn9c102_frame_t *f;
2332                 unsigned long lock_flags;
2333                 int err = 0;
2334
2335                 if (copy_from_user(&b, arg, sizeof(b)))
2336                         return -EFAULT;
2337
2338                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io!= IO_MMAP)
2339                         return -EINVAL;
2340
2341                 if (list_empty(&cam->outqueue)) {
2342                         if (cam->stream == STREAM_OFF)
2343                                 return -EINVAL;
2344                         if (filp->f_flags & O_NONBLOCK)
2345                                 return -EAGAIN;
2346                         err = wait_event_interruptible
2347                               ( cam->wait_frame,
2348                                 (!list_empty(&cam->outqueue)) ||
2349                                 (cam->state & DEV_DISCONNECTED) );
2350                         if (err)
2351                                 return err;
2352                         if (cam->state & DEV_DISCONNECTED)
2353                                 return -ENODEV;
2354                 }
2355
2356                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2357                 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t,
2358                                frame);
2359                 list_del(cam->outqueue.next);
2360                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2361
2362                 f->state = F_UNUSED;
2363
2364                 memcpy(&b, &f->buf, sizeof(b));
2365                 if (f->vma_use_count)
2366                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2367
2368                 if (copy_to_user(arg, &b, sizeof(b)))
2369                         return -EFAULT;
2370
2371                 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index)
2372
2373                 return 0;
2374         }
2375
2376         case VIDIOC_STREAMON:
2377         {
2378                 int type;
2379
2380                 if (copy_from_user(&type, arg, sizeof(type)))
2381                         return -EFAULT;
2382
2383                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2384                         return -EINVAL;
2385
2386                 if (list_empty(&cam->inqueue))
2387                         return -EINVAL;
2388
2389                 cam->stream = STREAM_ON;
2390
2391                 DBG(3, "Stream on")
2392
2393                 return 0;
2394         }
2395
2396         case VIDIOC_STREAMOFF:
2397         {
2398                 int type, err;
2399
2400                 if (copy_from_user(&type, arg, sizeof(type)))
2401                         return -EFAULT;
2402
2403                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2404                         return -EINVAL;
2405
2406                 if (cam->stream == STREAM_ON)
2407                         if ((err = sn9c102_stream_interrupt(cam)))
2408                                 return err;
2409
2410                 sn9c102_empty_framequeues(cam);
2411
2412                 DBG(3, "Stream off")
2413
2414                 return 0;
2415         }
2416
2417         case VIDIOC_G_PARM:
2418         {
2419                 struct v4l2_streamparm sp;
2420
2421                 if (copy_from_user(&sp, arg, sizeof(sp)))
2422                         return -EFAULT;
2423
2424                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2425                         return -EINVAL;
2426
2427                 sp.parm.capture.extendedmode = 0;
2428                 sp.parm.capture.readbuffers = cam->nreadbuffers;
2429
2430                 if (copy_to_user(arg, &sp, sizeof(sp)))
2431                         return -EFAULT;
2432
2433                 return 0;
2434         }
2435
2436         case VIDIOC_S_PARM_OLD:
2437         case VIDIOC_S_PARM:
2438         {
2439                 struct v4l2_streamparm sp;
2440
2441                 if (copy_from_user(&sp, arg, sizeof(sp)))
2442                         return -EFAULT;
2443
2444                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2445                         return -EINVAL;
2446
2447                 sp.parm.capture.extendedmode = 0;
2448
2449                 if (sp.parm.capture.readbuffers == 0)
2450                         sp.parm.capture.readbuffers = cam->nreadbuffers;
2451
2452                 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
2453                         sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
2454
2455                 if (copy_to_user(arg, &sp, sizeof(sp)))
2456                         return -EFAULT;
2457
2458                 cam->nreadbuffers = sp.parm.capture.readbuffers;
2459
2460                 return 0;
2461         }
2462
2463         case VIDIOC_G_STD:
2464         case VIDIOC_S_STD:
2465         case VIDIOC_QUERYSTD:
2466         case VIDIOC_ENUMSTD:
2467         case VIDIOC_QUERYMENU:
2468                 return -EINVAL;
2469
2470         default:
2471                 return -EINVAL;
2472
2473         }
2474 }
2475
2476
2477 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
2478                          unsigned int cmd, unsigned long arg)
2479 {
2480         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2481         int err = 0;
2482
2483         if (down_interruptible(&cam->fileop_sem))
2484                 return -ERESTARTSYS;
2485
2486         if (cam->state & DEV_DISCONNECTED) {
2487                 DBG(1, "Device not present")
2488                 up(&cam->fileop_sem);
2489                 return -ENODEV;
2490         }
2491
2492         if (cam->state & DEV_MISCONFIGURED) {
2493                 DBG(1, "The camera is misconfigured. Close and open it again.")
2494                 up(&cam->fileop_sem);
2495                 return -EIO;
2496         }
2497
2498         err = sn9c102_v4l2_ioctl(inode, filp, cmd, (void __user *)arg);
2499
2500         up(&cam->fileop_sem);
2501
2502         return err;
2503 }
2504
2505
2506 static struct file_operations sn9c102_fops = {
2507         .owner =   THIS_MODULE,
2508         .open =    sn9c102_open,
2509         .release = sn9c102_release,
2510         .ioctl =   sn9c102_ioctl,
2511         .read =    sn9c102_read,
2512         .poll =    sn9c102_poll,
2513         .mmap =    sn9c102_mmap,
2514         .llseek =  no_llseek,
2515 };
2516
2517 /*****************************************************************************/
2518
2519 /* It exists a single interface only. We do not need to validate anything. */
2520 static int
2521 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
2522 {
2523         struct usb_device *udev = interface_to_usbdev(intf);
2524         struct sn9c102_device* cam;
2525         static unsigned int dev_nr = 0;
2526         unsigned int i, n;
2527         int err = 0, r;
2528
2529         n = sizeof(sn9c102_id_table)/sizeof(sn9c102_id_table[0]);
2530         for (i = 0; i < n-1; i++)
2531                 if (le16_to_cpu(udev->descriptor.idVendor) ==
2532                     sn9c102_id_table[i].idVendor &&
2533                     le16_to_cpu(udev->descriptor.idProduct) ==
2534                     sn9c102_id_table[i].idProduct)
2535                         break;
2536         if (i == n-1)
2537                 return -ENODEV;
2538
2539         if (!(cam = kmalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
2540                 return -ENOMEM;
2541         memset(cam, 0, sizeof(*cam));
2542
2543         cam->usbdev = udev;
2544
2545         memcpy(&cam->dev, &udev->dev, sizeof(struct device));
2546
2547         if (!(cam->control_buffer = kmalloc(8, GFP_KERNEL))) {
2548                 DBG(1, "kmalloc() failed")
2549                 err = -ENOMEM;
2550                 goto fail;
2551         }
2552         memset(cam->control_buffer, 0, 8);
2553
2554         if (!(cam->v4ldev = video_device_alloc())) {
2555                 DBG(1, "video_device_alloc() failed")
2556                 err = -ENOMEM;
2557                 goto fail;
2558         }
2559
2560         init_MUTEX(&cam->dev_sem);
2561
2562         r = sn9c102_read_reg(cam, 0x00);
2563         if (r < 0 || r != 0x10) {
2564                 DBG(1, "Sorry, this is not a SN9C10x based camera "
2565                        "(vid/pid 0x%04X/0x%04X)",
2566                     sn9c102_id_table[i].idVendor,sn9c102_id_table[i].idProduct)
2567                 err = -ENODEV;
2568                 goto fail;
2569         }
2570
2571         cam->bridge = (sn9c102_id_table[i].idProduct & 0xffc0) == 0x6080 ?
2572                       BRIDGE_SN9C103 : BRIDGE_SN9C102;
2573         switch (cam->bridge) {
2574         case BRIDGE_SN9C101:
2575         case BRIDGE_SN9C102:
2576                 DBG(2, "SN9C10[12] PC Camera Controller detected "
2577                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2578                     sn9c102_id_table[i].idProduct)
2579                 break;
2580         case BRIDGE_SN9C103:
2581                 DBG(2, "SN9C103 PC Camera Controller detected "
2582                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2583                     sn9c102_id_table[i].idProduct)
2584                 break;
2585         }
2586
2587         for  (i = 0; sn9c102_sensor_table[i]; i++) {
2588                 err = sn9c102_sensor_table[i](cam);
2589                 if (!err)
2590                         break;
2591         }
2592
2593         if (!err && cam->sensor) {
2594                 DBG(2, "%s image sensor detected", cam->sensor->name)
2595                 DBG(3, "Support for %s maintained by %s",
2596                     cam->sensor->name, cam->sensor->maintainer)
2597         } else {
2598                 DBG(1, "No supported image sensor detected")
2599                 err = -ENODEV;
2600                 goto fail;
2601         }
2602
2603         if (sn9c102_init(cam)) {
2604                 DBG(1, "Initialization failed. I will retry on open().")
2605                 cam->state |= DEV_MISCONFIGURED;
2606         }
2607
2608         strcpy(cam->v4ldev->name, "SN9C10x PC Camera");
2609         cam->v4ldev->owner = THIS_MODULE;
2610         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
2611         cam->v4ldev->hardware = VID_HARDWARE_SN9C102;
2612         cam->v4ldev->fops = &sn9c102_fops;
2613         cam->v4ldev->minor = video_nr[dev_nr];
2614         cam->v4ldev->release = video_device_release;
2615         video_set_drvdata(cam->v4ldev, cam);
2616
2617         down(&cam->dev_sem);
2618
2619         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
2620                                     video_nr[dev_nr]);
2621         if (err) {
2622                 DBG(1, "V4L2 device registration failed")
2623                 if (err == -ENFILE && video_nr[dev_nr] == -1)
2624                         DBG(1, "Free /dev/videoX node not found")
2625                 video_nr[dev_nr] = -1;
2626                 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2627                 up(&cam->dev_sem);
2628                 goto fail;
2629         }
2630
2631         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor)
2632
2633         cam->module_param.force_munmap = force_munmap[dev_nr];
2634
2635         dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2636
2637         sn9c102_create_sysfs(cam);
2638         DBG(2, "Optional device control through 'sysfs' interface ready")
2639
2640         usb_set_intfdata(intf, cam);
2641
2642         up(&cam->dev_sem);
2643
2644         return 0;
2645
2646 fail:
2647         if (cam) {
2648                 kfree(cam->control_buffer);
2649                 if (cam->v4ldev)
2650                         video_device_release(cam->v4ldev);
2651                 kfree(cam);
2652         }
2653         return err;
2654 }
2655
2656
2657 static void sn9c102_usb_disconnect(struct usb_interface* intf)
2658 {
2659         struct sn9c102_device* cam = usb_get_intfdata(intf);
2660
2661         if (!cam)
2662                 return;
2663
2664         down_write(&sn9c102_disconnect);
2665
2666         down(&cam->dev_sem);
2667
2668         DBG(2, "Disconnecting %s...", cam->v4ldev->name)
2669
2670         wake_up_interruptible_all(&cam->open);
2671
2672         if (cam->users) {
2673                 DBG(2, "Device /dev/video%d is open! Deregistration and "
2674                        "memory deallocation are deferred on close.",
2675                     cam->v4ldev->minor)
2676                 cam->state |= DEV_MISCONFIGURED;
2677                 sn9c102_stop_transfer(cam);
2678                 cam->state |= DEV_DISCONNECTED;
2679                 wake_up_interruptible(&cam->wait_frame);
2680                 wake_up_interruptible(&cam->wait_stream);
2681         } else {
2682                 cam->state |= DEV_DISCONNECTED;
2683                 sn9c102_release_resources(cam);
2684         }
2685
2686         up(&cam->dev_sem);
2687
2688         if (!cam->users)
2689                 kfree(cam);
2690
2691         up_write(&sn9c102_disconnect);
2692 }
2693
2694
2695 static struct usb_driver sn9c102_usb_driver = {
2696         .owner =      THIS_MODULE,
2697         .name =       "sn9c102",
2698         .id_table =   sn9c102_id_table,
2699         .probe =      sn9c102_usb_probe,
2700         .disconnect = sn9c102_usb_disconnect,
2701 };
2702
2703 /*****************************************************************************/
2704
2705 static int __init sn9c102_module_init(void)
2706 {
2707         int err = 0;
2708
2709         KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION)
2710         KDBG(3, SN9C102_MODULE_AUTHOR)
2711
2712         if ((err = usb_register(&sn9c102_usb_driver)))
2713                 KDBG(1, "usb_register() failed")
2714
2715         return err;
2716 }
2717
2718
2719 static void __exit sn9c102_module_exit(void)
2720 {
2721         usb_deregister(&sn9c102_usb_driver);
2722 }
2723
2724
2725 module_init(sn9c102_module_init);
2726 module_exit(sn9c102_module_exit);