git.oblomov.eu Git - linux-2.6/blob - 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         size_t imagesize;
 503         unsigned long lock_flags;
 504         u8 i;
 505         int err = 0;
 506
 507         if (urb->status == -ENOENT)
 508                 return;
 509
 510         f = &cam->frame_current;
 511
 512         if (cam->stream == STREAM_INTERRUPT) {
 513                 cam->stream = STREAM_OFF;
 514                 if ((*f))
 515                         (*f)->state = F_QUEUED;
 516                 DBG(3, "Stream interrupted")
 517                 wake_up_interruptible(&cam->wait_stream);
 518         }
 519
 520         if (cam->state & DEV_DISCONNECTED)
 521                 return;
 522
 523         if (cam->state & DEV_MISCONFIGURED) {
 524                 wake_up_interruptible(&cam->wait_frame);
 525                 return;
 526         }
 527
 528         if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
 529                 goto resubmit_urb;
 530
 531         if (!(*f))
 532                 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
 533                                   frame);
 534
 535         imagesize = (cam->sensor->pix_format.width *
 536                      cam->sensor->pix_format.height *
 537                      cam->sensor->pix_format.priv) / 8;
 538
 539         for (i = 0; i < urb->number_of_packets; i++) {
 540                 unsigned int img, len, status;
 541                 void *pos, *sof, *eof;
 542
 543                 len = urb->iso_frame_desc[i].actual_length;
 544                 status = urb->iso_frame_desc[i].status;
 545                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 546
 547                 if (status) {
 548                         DBG(3, "Error in isochronous frame")
 549                         (*f)->state = F_ERROR;
 550                         continue;
 551                 }
 552
 553                 PDBGG("Isochrnous frame: length %u, #%u i", len, i)
 554
 555                 /*
 556                    NOTE: It is probably correct to assume that SOF and EOF
 557                          headers do not occur between two consecutive packets,
 558                          but who knows..Whatever is the truth, this assumption
 559                          doesn't introduce bugs.
 560                 */
 561
 562 redo:
 563                 sof = sn9c102_find_sof_header(cam, pos, len);
 564                 if (!sof) {
 565                         eof = sn9c102_find_eof_header(cam, pos, len);
 566                         if ((*f)->state == F_GRABBING) {
 567 end_of_frame:
 568                                 img = len;
 569
 570                                 if (eof)
 571                                         img = (eof > pos) ? eof - pos - 1 : 0;
 572
 573                                 if ((*f)->buf.bytesused+img > imagesize) {
 574                                         u32 b = (*f)->buf.bytesused + img -
 575                                                 imagesize;
 576                                         img = imagesize - (*f)->buf.bytesused;
 577                                         DBG(3, "Expected EOF not found: "
 578                                                "video frame cut")
 579                                         if (eof)
 580                                                 DBG(3, "Exceeded limit: +%u "
 581                                                        "bytes", (unsigned)(b))
 582                                 }
 583
 584                                 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
 585                                        img);
 586
 587                                 if ((*f)->buf.bytesused == 0)
 588                                         do_gettimeofday(&(*f)->buf.timestamp);
 589
 590                                 (*f)->buf.bytesused += img;
 591
 592                                 if ((*f)->buf.bytesused == imagesize ||
 593                                     (cam->sensor->pix_format.pixelformat ==
 594                                                 V4L2_PIX_FMT_SN9C10X && eof)) {
 595                                         u32 b = (*f)->buf.bytesused;
 596                                         (*f)->state = F_DONE;
 597                                         (*f)->buf.sequence= ++cam->frame_count;
 598                                         spin_lock_irqsave(&cam->queue_lock,
 599                                                           lock_flags);
 600                                         list_move_tail(&(*f)->frame,
 601                                                        &cam->outqueue);
 602                                         if (!list_empty(&cam->inqueue))
 603                                                 (*f) = list_entry(
 604                                                         cam->inqueue.next,
 605                                                         struct sn9c102_frame_t,
 606                                                         frame );
 607                                         else
 608                                                 (*f) = NULL;
 609                                         spin_unlock_irqrestore(&cam->queue_lock
 610                                                                , lock_flags);
 611                                         memcpy(cam->sysfs.frame_header,
 612                                                cam->sof_header,
 613                                                sizeof(sn9c102_sof_header_t));
 614                                         DBG(3, "Video frame captured: "
 615                                                "%lu bytes", (unsigned long)(b))
 616
 617                                         if (!(*f))
 618                                                 goto resubmit_urb;
 619
 620                                 } else if (eof) {
 621                                         (*f)->state = F_ERROR;
 622                                         DBG(3, "Not expected EOF after %lu "
 623                                                "bytes of image data",
 624                                           (unsigned long)((*f)->buf.bytesused))
 625                                 }
 626
 627                                 if (sof) /* (1) */
 628                                         goto start_of_frame;
 629
 630                         } else if (eof) {
 631                                 DBG(3, "EOF without SOF")
 632                                 continue;
 633
 634                         } else {
 635                                 PDBGG("Ignoring pointless isochronous frame")
 636                                 continue;
 637                         }
 638
 639                 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
 640 start_of_frame:
 641                         (*f)->state = F_GRABBING;
 642                         (*f)->buf.bytesused = 0;
 643                         len -= (sof - pos);
 644                         pos = sof;
 645                         DBG(3, "SOF detected: new video frame")
 646                         if (len)
 647                                 goto redo;
 648
 649                 } else if ((*f)->state == F_GRABBING) {
 650                         eof = sn9c102_find_eof_header(cam, pos, len);
 651                         if (eof && eof < sof)
 652                                 goto end_of_frame; /* (1) */
 653                         else {
 654                                 if (cam->sensor->pix_format.pixelformat ==
 655                                     V4L2_PIX_FMT_SN9C10X) {
 656                                         eof = sof-sizeof(sn9c102_sof_header_t);
 657                                         goto end_of_frame;
 658                                 } else {
 659                                         DBG(3, "SOF before expected EOF after "
 660                                                "%lu bytes of image data",
 661                                           (unsigned long)((*f)->buf.bytesused))
 662                                         goto start_of_frame;
 663                                 }
 664                         }
 665                 }
 666         }
 667
 668 resubmit_urb:
 669         urb->dev = cam->usbdev;
 670         err = usb_submit_urb(urb, GFP_ATOMIC);
 671         if (err < 0 && err != -EPERM) {
 672                 cam->state |= DEV_MISCONFIGURED;
 673                 DBG(1, "usb_submit_urb() failed")
 674         }
 675
 676         wake_up_interruptible(&cam->wait_frame);
 677 }
 678
 679
 680 static int sn9c102_start_transfer(struct sn9c102_device* cam)
 681 {
 682         struct usb_device *udev = cam->usbdev;
 683         struct urb* urb;
 684         const unsigned int wMaxPacketSize[] = {0, 128, 256, 384, 512,
 685                                                680, 800, 900, 1023};
 686         const unsigned int psz = wMaxPacketSize[SN9C102_ALTERNATE_SETTING];
 687         s8 i, j;
 688         int err = 0;
 689
 690         for (i = 0; i < SN9C102_URBS; i++) {
 691                 cam->transfer_buffer[i] = kmalloc(SN9C102_ISO_PACKETS * psz,
 692                                                   GFP_KERNEL);
 693                 if (!cam->transfer_buffer[i]) {
 694                         err = -ENOMEM;
 695                         DBG(1, "Not enough memory")
 696                         goto free_buffers;
 697                 }
 698         }
 699
 700         for (i = 0; i < SN9C102_URBS; i++) {
 701                 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
 702                 cam->urb[i] = urb;
 703                 if (!urb) {
 704                         err = -ENOMEM;
 705                         DBG(1, "usb_alloc_urb() failed")
 706                         goto free_urbs;
 707                 }
 708                 urb->dev = udev;
 709                 urb->context = cam;
 710                 urb->pipe = usb_rcvisocpipe(udev, 1);
 711                 urb->transfer_flags = URB_ISO_ASAP;
 712                 urb->number_of_packets = SN9C102_ISO_PACKETS;
 713                 urb->complete = sn9c102_urb_complete;
 714                 urb->transfer_buffer = cam->transfer_buffer[i];
 715                 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
 716                 urb->interval = 1;
 717                 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
 718                         urb->iso_frame_desc[j].offset = psz * j;
 719                         urb->iso_frame_desc[j].length = psz;
 720                 }
 721         }
 722
 723         /* Enable video */
 724         if (!(cam->reg[0x01] & 0x04)) {
 725                 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
 726                 if (err) {
 727                         err = -EIO;
 728                         DBG(1, "I/O hardware error")
 729                         goto free_urbs;
 730                 }
 731         }
 732
 733         err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
 734         if (err) {
 735                 DBG(1, "usb_set_interface() failed")
 736                 goto free_urbs;
 737         }
 738
 739         cam->frame_current = NULL;
 740
 741         for (i = 0; i < SN9C102_URBS; i++) {
 742                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 743                 if (err) {
 744                         for (j = i-1; j >= 0; j--)
 745                                 usb_kill_urb(cam->urb[j]);
 746                         DBG(1, "usb_submit_urb() failed, error %d", err)
 747                         goto free_urbs;
 748                 }
 749         }
 750
 751         return 0;
 752
 753 free_urbs:
 754         for (i = 0; (i < SN9C102_URBS) &&  cam->urb[i]; i++)
 755                 usb_free_urb(cam->urb[i]);
 756
 757 free_buffers:
 758         for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
 759                 kfree(cam->transfer_buffer[i]);
 760
 761         return err;
 762 }
 763
 764
 765 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
 766 {
 767         struct usb_device *udev = cam->usbdev;
 768         s8 i;
 769         int err = 0;
 770
 771         if (cam->state & DEV_DISCONNECTED)
 772                 return 0;
 773
 774         for (i = SN9C102_URBS-1; i >= 0; i--) {
 775                 usb_kill_urb(cam->urb[i]);
 776                 usb_free_urb(cam->urb[i]);
 777                 kfree(cam->transfer_buffer[i]);
 778         }
 779
 780         err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 781         if (err)
 782                 DBG(3, "usb_set_interface() failed")
 783
 784         return err;
 785 }
 786
 787
 788 int sn9c102_stream_interrupt(struct sn9c102_device* cam)
 789 {
 790         int err = 0;
 791
 792         cam->stream = STREAM_INTERRUPT;
 793         err = wait_event_timeout(cam->wait_stream,
 794                                  (cam->stream == STREAM_OFF) ||
 795                                  (cam->state & DEV_DISCONNECTED),
 796                                  SN9C102_URB_TIMEOUT);
 797         if (cam->state & DEV_DISCONNECTED)
 798                 return -ENODEV;
 799         else if (err) {
 800                 cam->state |= DEV_MISCONFIGURED;
 801                 DBG(1, "The camera is misconfigured. To use it, close and "
 802                        "open /dev/video%d again.", cam->v4ldev->minor)
 803                 return err;
 804         }
 805
 806         return 0;
 807 }
 808
 809 /*****************************************************************************/
 810
 811 static u8 sn9c102_strtou8(const char* buff, size_t len, ssize_t* count)
 812 {
 813         char str[5];
 814         char* endp;
 815         unsigned long val;
 816
 817         if (len < 4) {
 818                 strncpy(str, buff, len);
 819                 str[len+1] = '\0';
 820         } else {
 821                 strncpy(str, buff, 4);
 822                 str[4] = '\0';
 823         }
 824
 825         val = simple_strtoul(str, &endp, 0);
 826
 827         *count = 0;
 828         if (val <= 0xff)
 829                 *count = (ssize_t)(endp - str);
 830         if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
 831                 *count += 1;
 832
 833         return (u8)val;
 834 }
 835
 836 /*
 837    NOTE 1: being inside one of the following methods implies that the v4l
 838            device exists for sure (see kobjects and reference counters)
 839    NOTE 2: buffers are PAGE_SIZE long
 840 */
 841
 842 static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
 843 {
 844         struct sn9c102_device* cam;
 845         ssize_t count;
 846
 847         if (down_interruptible(&sn9c102_sysfs_lock))
 848                 return -ERESTARTSYS;
 849
 850         cam = video_get_drvdata(to_video_device(cd));
 851         if (!cam) {
 852                 up(&sn9c102_sysfs_lock);
 853                 return -ENODEV;
 854         }
 855
 856         count = sprintf(buf, "%u\n", cam->sysfs.reg);
 857
 858         up(&sn9c102_sysfs_lock);
 859
 860         return count;
 861 }
 862
 863
 864 static ssize_t
 865 sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
 866 {
 867         struct sn9c102_device* cam;
 868         u8 index;
 869         ssize_t count;
 870
 871         if (down_interruptible(&sn9c102_sysfs_lock))
 872                 return -ERESTARTSYS;
 873
 874         cam = video_get_drvdata(to_video_device(cd));
 875         if (!cam) {
 876                 up(&sn9c102_sysfs_lock);
 877                 return -ENODEV;
 878         }
 879
 880         index = sn9c102_strtou8(buf, len, &count);
 881         if (index > 0x1f || !count) {
 882                 up(&sn9c102_sysfs_lock);
 883                 return -EINVAL;
 884         }
 885
 886         cam->sysfs.reg = index;
 887
 888         DBG(2, "Moved SN9C10X register index to 0x%02X", cam->sysfs.reg)
 889         DBG(3, "Written bytes: %zd", count)
 890
 891         up(&sn9c102_sysfs_lock);
 892
 893         return count;
 894 }
 895
 896
 897 static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
 898 {
 899         struct sn9c102_device* cam;
 900         ssize_t count;
 901         int val;
 902
 903         if (down_interruptible(&sn9c102_sysfs_lock))
 904                 return -ERESTARTSYS;
 905
 906         cam = video_get_drvdata(to_video_device(cd));
 907         if (!cam) {
 908                 up(&sn9c102_sysfs_lock);
 909                 return -ENODEV;
 910         }
 911
 912         if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
 913                 up(&sn9c102_sysfs_lock);
 914                 return -EIO;
 915         }
 916
 917         count = sprintf(buf, "%d\n", val);
 918
 919         DBG(3, "Read bytes: %zd", count)
 920
 921         up(&sn9c102_sysfs_lock);
 922
 923         return count;
 924 }
 925
 926
 927 static ssize_t
 928 sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
 929 {
 930         struct sn9c102_device* cam;
 931         u8 value;
 932         ssize_t count;
 933         int err;
 934
 935         if (down_interruptible(&sn9c102_sysfs_lock))
 936                 return -ERESTARTSYS;
 937
 938         cam = video_get_drvdata(to_video_device(cd));
 939         if (!cam) {
 940                 up(&sn9c102_sysfs_lock);
 941                 return -ENODEV;
 942         }
 943
 944         value = sn9c102_strtou8(buf, len, &count);
 945         if (!count) {
 946                 up(&sn9c102_sysfs_lock);
 947                 return -EINVAL;
 948         }
 949
 950         err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
 951         if (err) {
 952                 up(&sn9c102_sysfs_lock);
 953                 return -EIO;
 954         }
 955
 956         DBG(2, "Written SN9C10X reg. 0x%02X, val. 0x%02X",
 957             cam->sysfs.reg, value)
 958         DBG(3, "Written bytes: %zd", count)
 959
 960         up(&sn9c102_sysfs_lock);
 961
 962         return count;
 963 }
 964
 965
 966 static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
 967 {
 968         struct sn9c102_device* cam;
 969         ssize_t count;
 970
 971         if (down_interruptible(&sn9c102_sysfs_lock))
 972                 return -ERESTARTSYS;
 973
 974         cam = video_get_drvdata(to_video_device(cd));
 975         if (!cam) {
 976                 up(&sn9c102_sysfs_lock);
 977                 return -ENODEV;
 978         }
 979
 980         count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
 981
 982         DBG(3, "Read bytes: %zd", count)
 983
 984         up(&sn9c102_sysfs_lock);
 985
 986         return count;
 987 }
 988
 989
 990 static ssize_t
 991 sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
 992 {
 993         struct sn9c102_device* cam;
 994         u8 index;
 995         ssize_t count;
 996
 997         if (down_interruptible(&sn9c102_sysfs_lock))
 998                 return -ERESTARTSYS;
 999
1000         cam = video_get_drvdata(to_video_device(cd));
1001         if (!cam) {
1002                 up(&sn9c102_sysfs_lock);
1003                 return -ENODEV;
1004         }
1005
1006         index = sn9c102_strtou8(buf, len, &count);
1007         if (!count) {
1008                 up(&sn9c102_sysfs_lock);
1009                 return -EINVAL;
1010         }
1011
1012         cam->sysfs.i2c_reg = index;
1013
1014         DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg)
1015         DBG(3, "Written bytes: %zd", count)
1016
1017         up(&sn9c102_sysfs_lock);
1018
1019         return count;
1020 }
1021
1022
1023 static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
1024 {
1025         struct sn9c102_device* cam;
1026         ssize_t count;
1027         int val;
1028
1029         if (down_interruptible(&sn9c102_sysfs_lock))
1030                 return -ERESTARTSYS;
1031
1032         cam = video_get_drvdata(to_video_device(cd));
1033         if (!cam) {
1034                 up(&sn9c102_sysfs_lock);
1035                 return -ENODEV;
1036         }
1037
1038         if (!(cam->sensor->sysfs_ops & SN9C102_I2C_READ)) {
1039                 up(&sn9c102_sysfs_lock);
1040                 return -ENOSYS;
1041         }
1042
1043         if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1044                 up(&sn9c102_sysfs_lock);
1045                 return -EIO;
1046         }
1047
1048         count = sprintf(buf, "%d\n", val);
1049
1050         DBG(3, "Read bytes: %zd", count)
1051
1052         up(&sn9c102_sysfs_lock);
1053
1054         return count;
1055 }
1056
1057
1058 static ssize_t
1059 sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
1060 {
1061         struct sn9c102_device* cam;
1062         u8 value;
1063         ssize_t count;
1064         int err;
1065
1066         if (down_interruptible(&sn9c102_sysfs_lock))
1067                 return -ERESTARTSYS;
1068
1069         cam = video_get_drvdata(to_video_device(cd));
1070         if (!cam) {
1071                 up(&sn9c102_sysfs_lock);
1072                 return -ENODEV;
1073         }
1074
1075         if (!(cam->sensor->sysfs_ops & SN9C102_I2C_WRITE)) {
1076                 up(&sn9c102_sysfs_lock);
1077                 return -ENOSYS;
1078         }
1079
1080         value = sn9c102_strtou8(buf, len, &count);
1081         if (!count) {
1082                 up(&sn9c102_sysfs_lock);
1083                 return -EINVAL;
1084         }
1085
1086         err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1087         if (err) {
1088                 up(&sn9c102_sysfs_lock);
1089                 return -EIO;
1090         }
1091
1092         DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1093             cam->sysfs.i2c_reg, value)
1094         DBG(3, "Written bytes: %zd", count)
1095
1096         up(&sn9c102_sysfs_lock);
1097
1098         return count;
1099 }
1100
1101
1102 static ssize_t
1103 sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
1104 {
1105         struct sn9c102_device* cam;
1106         enum sn9c102_bridge bridge;
1107         ssize_t res = 0;
1108         u8 value;
1109         ssize_t count;
1110
1111         if (down_interruptible(&sn9c102_sysfs_lock))
1112                 return -ERESTARTSYS;
1113
1114         cam = video_get_drvdata(to_video_device(cd));
1115         if (!cam) {
1116                 up(&sn9c102_sysfs_lock);
1117                 return -ENODEV;
1118         }
1119
1120         bridge = cam->bridge;
1121
1122         up(&sn9c102_sysfs_lock);
1123
1124         value = sn9c102_strtou8(buf, len, &count);
1125         if (!count)
1126                 return -EINVAL;
1127
1128         switch (bridge) {
1129         case BRIDGE_SN9C101:
1130         case BRIDGE_SN9C102:
1131                 if (value > 0x0f)
1132                         return -EINVAL;
1133                 if ((res = sn9c102_store_reg(cd, "0x11", 4)) >= 0)
1134                         res = sn9c102_store_val(cd, buf, len);
1135                 break;
1136         case BRIDGE_SN9C103:
1137                 if (value > 0x7f)
1138                         return -EINVAL;
1139                 if ((res = sn9c102_store_reg(cd, "0x04", 4)) >= 0)
1140                         res = sn9c102_store_val(cd, buf, len);
1141                 break;
1142         }
1143
1144         return res;
1145 }
1146
1147
1148 static ssize_t
1149 sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
1150 {
1151         ssize_t res = 0;
1152         u8 value;
1153         ssize_t count;
1154
1155         value = sn9c102_strtou8(buf, len, &count);
1156         if (!count || value > 0x7f)
1157                 return -EINVAL;
1158
1159         if ((res = sn9c102_store_reg(cd, "0x06", 4)) >= 0)
1160                 res = sn9c102_store_val(cd, buf, len);
1161
1162         return res;
1163 }
1164
1165
1166 static ssize_t
1167 sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
1168 {
1169         ssize_t res = 0;
1170         u8 value;
1171         ssize_t count;
1172
1173         value = sn9c102_strtou8(buf, len, &count);
1174         if (!count || value > 0x7f)
1175                 return -EINVAL;
1176
1177         if ((res = sn9c102_store_reg(cd, "0x05", 4)) >= 0)
1178                 res = sn9c102_store_val(cd, buf, len);
1179
1180         return res;
1181 }
1182
1183
1184 static ssize_t sn9c102_show_frame_header(struct class_device* cd, char* buf)
1185 {
1186         struct sn9c102_device* cam;
1187         ssize_t count;
1188
1189         cam = video_get_drvdata(to_video_device(cd));
1190         if (!cam)
1191                 return -ENODEV;
1192
1193         count = sizeof(cam->sysfs.frame_header);
1194         memcpy(buf, cam->sysfs.frame_header, count);
1195
1196         DBG(3, "Frame header, read bytes: %zd", count)
1197
1198         return count;
1199 }
1200
1201
1202 static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
1203                          sn9c102_show_reg, sn9c102_store_reg);
1204 static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
1205                          sn9c102_show_val, sn9c102_store_val);
1206 static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1207                          sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1208 static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1209                          sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1210 static CLASS_DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1211 static CLASS_DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1212 static CLASS_DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1213 static CLASS_DEVICE_ATTR(frame_header, S_IRUGO,
1214                          sn9c102_show_frame_header, NULL);
1215
1216
1217 static void sn9c102_create_sysfs(struct sn9c102_device* cam)
1218 {
1219         struct video_device *v4ldev = cam->v4ldev;
1220
1221         video_device_create_file(v4ldev, &class_device_attr_reg);
1222         video_device_create_file(v4ldev, &class_device_attr_val);
1223         video_device_create_file(v4ldev, &class_device_attr_frame_header);
1224         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
1225                 video_device_create_file(v4ldev, &class_device_attr_green);
1226         else if (cam->bridge == BRIDGE_SN9C103) {
1227                 video_device_create_file(v4ldev, &class_device_attr_blue);
1228                 video_device_create_file(v4ldev, &class_device_attr_red);
1229         }
1230         if (cam->sensor->sysfs_ops) {
1231                 video_device_create_file(v4ldev, &class_device_attr_i2c_reg);
1232                 video_device_create_file(v4ldev, &class_device_attr_i2c_val);
1233         }
1234 }
1235
1236 /*****************************************************************************/
1237
1238 static int
1239 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1240 {
1241         int err = 0;
1242
1243         if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
1244                 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80, 0x18);
1245         else
1246                 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f, 0x18);
1247
1248         return err ? -EIO : 0;
1249 }
1250
1251
1252 static int
1253 sn9c102_set_compression(struct sn9c102_device* cam,
1254                         struct v4l2_jpegcompression* compression)
1255 {
1256         int err = 0;
1257
1258         if (compression->quality == 0)
1259                 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01, 0x17);
1260         else if (compression->quality == 1)
1261                 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe, 0x17);
1262
1263         return err ? -EIO : 0;
1264 }
1265
1266
1267 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1268 {
1269         u8 r = 0;
1270         int err = 0;
1271
1272         if (scale == 1)
1273                 r = cam->reg[0x18] & 0xcf;
1274         else if (scale == 2) {
1275                 r = cam->reg[0x18] & 0xcf;
1276                 r |= 0x10;
1277         } else if (scale == 4)
1278                 r = cam->reg[0x18] | 0x20;
1279
1280         err += sn9c102_write_reg(cam, r, 0x18);
1281         if (err)
1282                 return -EIO;
1283
1284         PDBGG("Scaling factor: %u", scale)
1285
1286         return 0;
1287 }
1288
1289
1290 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1291 {
1292         struct sn9c102_sensor* s = cam->sensor;
1293         u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1294            v_start = (u8)(rect->top - s->cropcap.bounds.top),
1295            h_size = (u8)(rect->width / 16),
1296            v_size = (u8)(rect->height / 16);
1297         int err = 0;
1298
1299         err += sn9c102_write_reg(cam, h_start, 0x12);
1300         err += sn9c102_write_reg(cam, v_start, 0x13);
1301         err += sn9c102_write_reg(cam, h_size, 0x15);
1302         err += sn9c102_write_reg(cam, v_size, 0x16);
1303         if (err)
1304                 return -EIO;
1305
1306         PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1307               "%u %u %u %u", h_start, v_start, h_size, v_size)
1308
1309         return 0;
1310 }
1311
1312
1313 static int sn9c102_init(struct sn9c102_device* cam)
1314 {
1315         struct sn9c102_sensor* s = cam->sensor;
1316         struct v4l2_control ctrl;
1317         struct v4l2_queryctrl *qctrl;
1318         struct v4l2_rect* rect;
1319         u8 i = 0, n = 0;
1320         int err = 0;
1321
1322         if (!(cam->state & DEV_INITIALIZED)) {
1323                 init_waitqueue_head(&cam->open);
1324                 qctrl = s->qctrl;
1325                 rect = &(s->cropcap.defrect);
1326         } else { /* use current values */
1327                 qctrl = s->_qctrl;
1328                 rect = &(s->_rect);
1329         }
1330
1331         err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1332         err += sn9c102_set_crop(cam, rect);
1333         if (err)
1334                 return err;
1335
1336         if (s->init) {
1337                 err = s->init(cam);
1338                 if (err) {
1339                         DBG(3, "Sensor initialization failed")
1340                         return err;
1341                 }
1342         }
1343
1344         if (!(cam->state & DEV_INITIALIZED))
1345                 cam->compression.quality =  cam->reg[0x17] & 0x01 ? 0 : 1;
1346         else
1347                 err += sn9c102_set_compression(cam, &cam->compression);
1348         err += sn9c102_set_pix_format(cam, &s->pix_format);
1349         if (s->set_pix_format)
1350                 err += s->set_pix_format(cam, &s->pix_format);
1351         if (err)
1352                 return err;
1353
1354         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1355                 DBG(3, "Compressed video format is active, quality %d",
1356                     cam->compression.quality)
1357         else
1358                 DBG(3, "Uncompressed video format is active")
1359
1360         if (s->set_crop)
1361                 if ((err = s->set_crop(cam, rect))) {
1362                         DBG(3, "set_crop() failed")
1363                         return err;
1364                 }
1365
1366         if (s->set_ctrl) {
1367                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1368                 for (i = 0; i < n; i++)
1369                         if (s->qctrl[i].id != 0 &&
1370                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1371                                 ctrl.id = s->qctrl[i].id;
1372                                 ctrl.value = qctrl[i].default_value;
1373                                 err = s->set_ctrl(cam, &ctrl);
1374                                 if (err) {
1375                                         DBG(3, "Set %s control failed",
1376                                             s->qctrl[i].name)
1377                                         return err;
1378                                 }
1379                                 DBG(3, "Image sensor supports '%s' control",
1380                                     s->qctrl[i].name)
1381                         }
1382         }
1383
1384         if (!(cam->state & DEV_INITIALIZED)) {
1385                 init_MUTEX(&cam->fileop_sem);
1386                 spin_lock_init(&cam->queue_lock);
1387                 init_waitqueue_head(&cam->wait_frame);
1388                 init_waitqueue_head(&cam->wait_stream);
1389                 cam->nreadbuffers = 2;
1390                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1391                 memcpy(&(s->_rect), &(s->cropcap.defrect),
1392                        sizeof(struct v4l2_rect));
1393                 cam->state |= DEV_INITIALIZED;
1394         }
1395
1396         DBG(2, "Initialization succeeded")
1397         return 0;
1398 }
1399
1400
1401 static void sn9c102_release_resources(struct sn9c102_device* cam)
1402 {
1403         down(&sn9c102_sysfs_lock);
1404
1405         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor)
1406         video_set_drvdata(cam->v4ldev, NULL);
1407         video_unregister_device(cam->v4ldev);
1408
1409         up(&sn9c102_sysfs_lock);
1410
1411         kfree(cam->control_buffer);
1412 }
1413
1414 /*****************************************************************************/
1415
1416 static int sn9c102_open(struct inode* inode, struct file* filp)
1417 {
1418         struct sn9c102_device* cam;
1419         int err = 0;
1420
1421         /*
1422            This is the only safe way to prevent race conditions with
1423            disconnect
1424         */
1425         if (!down_read_trylock(&sn9c102_disconnect))
1426                 return -ERESTARTSYS;
1427
1428         cam = video_get_drvdata(video_devdata(filp));
1429
1430         if (down_interruptible(&cam->dev_sem)) {
1431                 up_read(&sn9c102_disconnect);
1432                 return -ERESTARTSYS;
1433         }
1434
1435         if (cam->users) {
1436                 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor)
1437                 if ((filp->f_flags & O_NONBLOCK) ||
1438                     (filp->f_flags & O_NDELAY)) {
1439                         err = -EWOULDBLOCK;
1440                         goto out;
1441                 }
1442                 up(&cam->dev_sem);
1443                 err = wait_event_interruptible_exclusive(cam->open,
1444                                                   cam->state & DEV_DISCONNECTED
1445                                                          || !cam->users);
1446                 if (err) {
1447                         up_read(&sn9c102_disconnect);
1448                         return err;
1449                 }
1450                 if (cam->state & DEV_DISCONNECTED) {
1451                         up_read(&sn9c102_disconnect);
1452                         return -ENODEV;
1453                 }
1454                 down(&cam->dev_sem);
1455         }
1456
1457
1458         if (cam->state & DEV_MISCONFIGURED) {
1459                 err = sn9c102_init(cam);
1460                 if (err) {
1461                         DBG(1, "Initialization failed again. "
1462                                "I will retry on next open().")
1463                         goto out;
1464                 }
1465                 cam->state &= ~DEV_MISCONFIGURED;
1466         }
1467
1468         if ((err = sn9c102_start_transfer(cam)))
1469                 goto out;
1470
1471         filp->private_data = cam;
1472         cam->users++;
1473         cam->io = IO_NONE;
1474         cam->stream = STREAM_OFF;
1475         cam->nbuffers = 0;
1476         cam->frame_count = 0;
1477         sn9c102_empty_framequeues(cam);
1478
1479         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor)
1480
1481 out:
1482         up(&cam->dev_sem);
1483         up_read(&sn9c102_disconnect);
1484         return err;
1485 }
1486
1487
1488 static int sn9c102_release(struct inode* inode, struct file* filp)
1489 {
1490         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1491
1492         down(&cam->dev_sem); /* prevent disconnect() to be called */
1493
1494         sn9c102_stop_transfer(cam);
1495
1496         sn9c102_release_buffers(cam);
1497
1498         if (cam->state & DEV_DISCONNECTED) {
1499                 sn9c102_release_resources(cam);
1500                 up(&cam->dev_sem);
1501                 kfree(cam);
1502                 return 0;
1503         }
1504
1505         cam->users--;
1506         wake_up_interruptible_nr(&cam->open, 1);
1507
1508         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor)
1509
1510         up(&cam->dev_sem);
1511
1512         return 0;
1513 }
1514
1515
1516 static ssize_t
1517 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1518 {
1519         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1520         struct sn9c102_frame_t* f, * i;
1521         unsigned long lock_flags;
1522         int err = 0;
1523
1524         if (down_interruptible(&cam->fileop_sem))
1525                 return -ERESTARTSYS;
1526
1527         if (cam->state & DEV_DISCONNECTED) {
1528                 DBG(1, "Device not present")
1529                 up(&cam->fileop_sem);
1530                 return -ENODEV;
1531         }
1532
1533         if (cam->state & DEV_MISCONFIGURED) {
1534                 DBG(1, "The camera is misconfigured. Close and open it again.")
1535                 up(&cam->fileop_sem);
1536                 return -EIO;
1537         }
1538
1539         if (cam->io == IO_MMAP) {
1540                 DBG(3, "Close and open the device again to choose "
1541                        "the read method")
1542                 up(&cam->fileop_sem);
1543                 return -EINVAL;
1544         }
1545
1546         if (cam->io == IO_NONE) {
1547                 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1548                         DBG(1, "read() failed, not enough memory")
1549                         up(&cam->fileop_sem);
1550                         return -ENOMEM;
1551                 }
1552                 cam->io = IO_READ;
1553                 cam->stream = STREAM_ON;
1554                 sn9c102_queue_unusedframes(cam);
1555         }
1556
1557         if (!count) {
1558                 up(&cam->fileop_sem);
1559                 return 0;
1560         }
1561
1562         if (list_empty(&cam->outqueue)) {
1563                 if (filp->f_flags & O_NONBLOCK) {
1564                         up(&cam->fileop_sem);
1565                         return -EAGAIN;
1566                 }
1567                 err = wait_event_interruptible
1568                       ( cam->wait_frame,
1569                         (!list_empty(&cam->outqueue)) ||
1570                         (cam->state & DEV_DISCONNECTED) ||
1571                         (cam->state & DEV_MISCONFIGURED) );
1572                 if (err) {
1573                         up(&cam->fileop_sem);
1574                         return err;
1575                 }
1576                 if (cam->state & DEV_DISCONNECTED) {
1577                         up(&cam->fileop_sem);
1578                         return -ENODEV;
1579                 }
1580                 if (cam->state & DEV_MISCONFIGURED) {
1581                         up(&cam->fileop_sem);
1582                         return -EIO;
1583                 }
1584         }
1585
1586         f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1587
1588         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1589         list_for_each_entry(i, &cam->outqueue, frame)
1590                 i->state = F_UNUSED;
1591         INIT_LIST_HEAD(&cam->outqueue);
1592         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1593
1594         sn9c102_queue_unusedframes(cam);
1595
1596         if (count > f->buf.bytesused)
1597                 count = f->buf.bytesused;
1598
1599         if (copy_to_user(buf, f->bufmem, count)) {
1600                 up(&cam->fileop_sem);
1601                 return -EFAULT;
1602         }
1603         *f_pos += count;
1604
1605         PDBGG("Frame #%lu, bytes read: %zu", (unsigned long)f->buf.index,count)
1606
1607         up(&cam->fileop_sem);
1608
1609         return count;
1610 }
1611
1612
1613 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1614 {
1615         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1616         unsigned int mask = 0;
1617
1618         if (down_interruptible(&cam->fileop_sem))
1619                 return POLLERR;
1620
1621         if (cam->state & DEV_DISCONNECTED) {
1622                 DBG(1, "Device not present")
1623                 goto error;
1624         }
1625
1626         if (cam->state & DEV_MISCONFIGURED) {
1627                 DBG(1, "The camera is misconfigured. Close and open it again.")
1628                 goto error;
1629         }
1630
1631         if (cam->io == IO_NONE) {
1632                 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
1633                                              IO_READ)) {
1634                         DBG(1, "poll() failed, not enough memory")
1635                         goto error;
1636                 }
1637                 cam->io = IO_READ;
1638                 cam->stream = STREAM_ON;
1639         }
1640
1641         if (cam->io == IO_READ)
1642                 sn9c102_queue_unusedframes(cam);
1643
1644         poll_wait(filp, &cam->wait_frame, wait);
1645
1646         if (!list_empty(&cam->outqueue))
1647                 mask |= POLLIN | POLLRDNORM;
1648
1649         up(&cam->fileop_sem);
1650
1651         return mask;
1652
1653 error:
1654         up(&cam->fileop_sem);
1655         return POLLERR;
1656 }
1657
1658
1659 static void sn9c102_vm_open(struct vm_area_struct* vma)
1660 {
1661         struct sn9c102_frame_t* f = vma->vm_private_data;
1662         f->vma_use_count++;
1663 }
1664
1665
1666 static void sn9c102_vm_close(struct vm_area_struct* vma)
1667 {
1668         /* NOTE: buffers are not freed here */
1669         struct sn9c102_frame_t* f = vma->vm_private_data;
1670         f->vma_use_count--;
1671 }
1672
1673
1674 static struct vm_operations_struct sn9c102_vm_ops = {
1675         .open = sn9c102_vm_open,
1676         .close = sn9c102_vm_close,
1677 };
1678
1679
1680 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
1681 {
1682         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1683         unsigned long size = vma->vm_end - vma->vm_start,
1684                       start = vma->vm_start,
1685                       pos,
1686                       page;
1687         u32 i;
1688
1689         if (down_interruptible(&cam->fileop_sem))
1690                 return -ERESTARTSYS;
1691
1692         if (cam->state & DEV_DISCONNECTED) {
1693                 DBG(1, "Device not present")
1694                 up(&cam->fileop_sem);
1695                 return -ENODEV;
1696         }
1697
1698         if (cam->state & DEV_MISCONFIGURED) {
1699                 DBG(1, "The camera is misconfigured. Close and open it again.")
1700                 up(&cam->fileop_sem);
1701                 return -EIO;
1702         }
1703
1704         if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
1705             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
1706                 up(&cam->fileop_sem);
1707                 return -EINVAL;
1708         }
1709
1710         for (i = 0; i < cam->nbuffers; i++) {
1711                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
1712                         break;
1713         }
1714         if (i == cam->nbuffers) {
1715                 up(&cam->fileop_sem);
1716                 return -EINVAL;
1717         }
1718
1719         /* VM_IO is eventually going to replace PageReserved altogether */
1720         vma->vm_flags |= VM_IO;
1721         vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1722
1723         pos = (unsigned long)cam->frame[i].bufmem;
1724         while (size > 0) { /* size is page-aligned */
1725                 page = vmalloc_to_pfn((void *)pos);
1726                 if (remap_pfn_range(vma, start, page, PAGE_SIZE,
1727                                     vma->vm_page_prot)) {
1728                         up(&cam->fileop_sem);
1729                         return -EAGAIN;
1730                 }
1731                 start += PAGE_SIZE;
1732                 pos += PAGE_SIZE;
1733                 size -= PAGE_SIZE;
1734         }
1735
1736         vma->vm_ops = &sn9c102_vm_ops;
1737         vma->vm_private_data = &cam->frame[i];
1738
1739         sn9c102_vm_open(vma);
1740
1741         up(&cam->fileop_sem);
1742
1743         return 0;
1744 }
1745
1746
1747 static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
1748                               unsigned int cmd, void __user * arg)
1749 {
1750         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1751
1752         switch (cmd) {
1753
1754         case VIDIOC_QUERYCAP:
1755         {
1756                 struct v4l2_capability cap = {
1757                         .driver = "sn9c102",
1758                         .version = SN9C102_MODULE_VERSION_CODE,
1759                         .capabilities = V4L2_CAP_VIDEO_CAPTURE |
1760                                         V4L2_CAP_READWRITE |
1761                                         V4L2_CAP_STREAMING,
1762                 };
1763
1764                 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
1765                 if (usb_make_path(cam->usbdev, cap.bus_info,
1766                     sizeof(cap.bus_info)) < 0)
1767                         strlcpy(cap.bus_info, cam->dev.bus_id,
1768                                 sizeof(cap.bus_info));
1769
1770                 if (copy_to_user(arg, &cap, sizeof(cap)))
1771                         return -EFAULT;
1772
1773                 return 0;
1774         }
1775
1776         case VIDIOC_ENUMINPUT:
1777         {
1778                 struct v4l2_input i;
1779
1780                 if (copy_from_user(&i, arg, sizeof(i)))
1781                         return -EFAULT;
1782
1783                 if (i.index)
1784                         return -EINVAL;
1785
1786                 memset(&i, 0, sizeof(i));
1787                 strcpy(i.name, "USB");
1788
1789                 if (copy_to_user(arg, &i, sizeof(i)))
1790                         return -EFAULT;
1791
1792                 return 0;
1793         }
1794
1795         case VIDIOC_G_INPUT:
1796         case VIDIOC_S_INPUT:
1797         {
1798                 int index;
1799
1800                 if (copy_from_user(&index, arg, sizeof(index)))
1801                         return -EFAULT;
1802
1803                 if (index != 0)
1804                         return -EINVAL;
1805
1806                 return 0;
1807         }
1808
1809         case VIDIOC_QUERYCTRL:
1810         {
1811                 struct sn9c102_sensor* s = cam->sensor;
1812                 struct v4l2_queryctrl qc;
1813                 u8 i, n;
1814
1815                 if (copy_from_user(&qc, arg, sizeof(qc)))
1816                         return -EFAULT;
1817
1818                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1819                 for (i = 0; i < n; i++)
1820                         if (qc.id && qc.id == s->qctrl[i].id) {
1821                                 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
1822                                 if (copy_to_user(arg, &qc, sizeof(qc)))
1823                                         return -EFAULT;
1824                                 return 0;
1825                         }
1826
1827                 return -EINVAL;
1828         }
1829
1830         case VIDIOC_G_CTRL:
1831         {
1832                 struct sn9c102_sensor* s = cam->sensor;
1833                 struct v4l2_control ctrl;
1834                 int err = 0;
1835
1836                 if (!s->get_ctrl)
1837                         return -EINVAL;
1838
1839                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1840                         return -EFAULT;
1841
1842                 err = s->get_ctrl(cam, &ctrl);
1843
1844                 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
1845                         return -EFAULT;
1846
1847                 return err;
1848         }
1849
1850         case VIDIOC_S_CTRL_OLD:
1851         case VIDIOC_S_CTRL:
1852         {
1853                 struct sn9c102_sensor* s = cam->sensor;
1854                 struct v4l2_control ctrl;
1855                 u8 i, n;
1856                 int err = 0;
1857
1858                 if (!s->set_ctrl)
1859                         return -EINVAL;
1860
1861                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1862                         return -EFAULT;
1863
1864                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1865                 for (i = 0; i < n; i++)
1866                         if (ctrl.id == s->qctrl[i].id) {
1867                                 if (ctrl.value < s->qctrl[i].minimum ||
1868                                     ctrl.value > s->qctrl[i].maximum)
1869                                         return -ERANGE;
1870                                 ctrl.value -= ctrl.value % s->qctrl[i].step;
1871                                 break;
1872                         }
1873
1874                 if ((err = s->set_ctrl(cam, &ctrl)))
1875                         return err;
1876
1877                 s->_qctrl[i].default_value = ctrl.value;
1878
1879                 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
1880                       (unsigned long)ctrl.id, (unsigned long)ctrl.value)
1881
1882                 return 0;
1883         }
1884
1885         case VIDIOC_CROPCAP:
1886         {
1887                 struct v4l2_cropcap* cc = &(cam->sensor->cropcap);
1888
1889                 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1890                 cc->pixelaspect.numerator = 1;
1891                 cc->pixelaspect.denominator = 1;
1892
1893                 if (copy_to_user(arg, cc, sizeof(*cc)))
1894                         return -EFAULT;
1895
1896                 return 0;
1897         }
1898
1899         case VIDIOC_G_CROP:
1900         {
1901                 struct sn9c102_sensor* s = cam->sensor;
1902                 struct v4l2_crop crop = {
1903                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
1904                 };
1905
1906                 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
1907
1908                 if (copy_to_user(arg, &crop, sizeof(crop)))
1909                         return -EFAULT;
1910
1911                 return 0;
1912         }
1913
1914         case VIDIOC_S_CROP:
1915         {
1916                 struct sn9c102_sensor* s = cam->sensor;
1917                 struct v4l2_crop crop;
1918                 struct v4l2_rect* rect;
1919                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
1920                 struct v4l2_pix_format* pix_format = &(s->pix_format);
1921                 u8 scale;
1922                 const enum sn9c102_stream_state stream = cam->stream;
1923                 const u32 nbuffers = cam->nbuffers;
1924                 u32 i;
1925                 int err = 0;
1926
1927                 if (copy_from_user(&crop, arg, sizeof(crop)))
1928                         return -EFAULT;
1929
1930                 rect = &(crop.c);
1931
1932                 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1933                         return -EINVAL;
1934
1935                 if (cam->module_param.force_munmap)
1936                         for (i = 0; i < cam->nbuffers; i++)
1937                                 if (cam->frame[i].vma_use_count) {
1938                                         DBG(3, "VIDIOC_S_CROP failed. "
1939                                                "Unmap the buffers first.")
1940                                         return -EINVAL;
1941                                 }
1942
1943                 /* Preserve R,G or B origin */
1944                 rect->left = (s->_rect.left & 1L) ?
1945                              rect->left | 1L : rect->left & ~1L;
1946                 rect->top = (s->_rect.top & 1L) ?
1947                             rect->top | 1L : rect->top & ~1L;
1948
1949                 if (rect->width < 16)
1950                         rect->width = 16;
1951                 if (rect->height < 16)
1952                         rect->height = 16;
1953                 if (rect->width > bounds->width)
1954                         rect->width = bounds->width;
1955                 if (rect->height > bounds->height)
1956                         rect->height = bounds->height;
1957                 if (rect->left < bounds->left)
1958                         rect->left = bounds->left;
1959                 if (rect->top < bounds->top)
1960                         rect->top = bounds->top;
1961                 if (rect->left + rect->width > bounds->left + bounds->width)
1962                         rect->left = bounds->left+bounds->width - rect->width;
1963                 if (rect->top + rect->height > bounds->top + bounds->height)
1964                         rect->top = bounds->top+bounds->height - rect->height;
1965
1966                 rect->width &= ~15L;
1967                 rect->height &= ~15L;
1968
1969                 if (SN9C102_PRESERVE_IMGSCALE) {
1970                         /* Calculate the actual scaling factor */
1971                         u32 a, b;
1972                         a = rect->width * rect->height;
1973                         b = pix_format->width * pix_format->height;
1974                         scale = b ? (u8)((a / b) < 4 ? 1 :
1975                                         ((a / b) < 16 ? 2 : 4)) : 1;
1976                 } else
1977                         scale = 1;
1978
1979                 if (cam->stream == STREAM_ON)
1980                         if ((err = sn9c102_stream_interrupt(cam)))
1981                                 return err;
1982
1983                 if (copy_to_user(arg, &crop, sizeof(crop))) {
1984                         cam->stream = stream;
1985                         return -EFAULT;
1986                 }
1987
1988                 if (cam->module_param.force_munmap || cam->io == IO_READ)
1989                         sn9c102_release_buffers(cam);
1990
1991                 err = sn9c102_set_crop(cam, rect);
1992                 if (s->set_crop)
1993                         err += s->set_crop(cam, rect);
1994                 err += sn9c102_set_scale(cam, scale);
1995
1996                 if (err) { /* atomic, no rollback in ioctl() */
1997                         cam->state |= DEV_MISCONFIGURED;
1998                         DBG(1, "VIDIOC_S_CROP failed because of hardware "
1999                                "problems. To use the camera, close and open "
2000                                "/dev/video%d again.", cam->v4ldev->minor)
2001                         return -EIO;
2002                 }
2003
2004                 s->pix_format.width = rect->width/scale;
2005                 s->pix_format.height = rect->height/scale;
2006                 memcpy(&(s->_rect), rect, sizeof(*rect));
2007
2008                 if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2009                     nbuffers != sn9c102_request_buffers(cam, nbuffers,
2010                                                         cam->io)) {
2011                         cam->state |= DEV_MISCONFIGURED;
2012                         DBG(1, "VIDIOC_S_CROP failed because of not enough "
2013                                "memory. To use the camera, close and open "
2014                                "/dev/video%d again.", cam->v4ldev->minor)
2015                         return -ENOMEM;
2016                 }
2017
2018                 cam->stream = stream;
2019
2020                 return 0;
2021         }
2022
2023         case VIDIOC_ENUM_FMT:
2024         {
2025                 struct v4l2_fmtdesc fmtd;
2026
2027                 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2028                         return -EFAULT;
2029
2030                 if (fmtd.index == 0) {
2031                         strcpy(fmtd.description, "bayer rgb");
2032                         fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2033                 } else if (fmtd.index == 1) {
2034                         strcpy(fmtd.description, "compressed");
2035                         fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2036                         fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2037                 } else
2038                         return -EINVAL;
2039
2040                 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2041                 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2042
2043                 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2044                         return -EFAULT;
2045
2046                 return 0;
2047         }
2048
2049         case VIDIOC_G_FMT:
2050         {
2051                 struct v4l2_format format;
2052                 struct v4l2_pix_format* pfmt = &(cam->sensor->pix_format);
2053
2054                 if (copy_from_user(&format, arg, sizeof(format)))
2055                         return -EFAULT;
2056
2057                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2058                         return -EINVAL;
2059
2060                 pfmt->bytesperline = (pfmt->pixelformat==V4L2_PIX_FMT_SN9C10X)
2061                                      ? 0 : (pfmt->width * pfmt->priv) / 8;
2062                 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2063                 pfmt->field = V4L2_FIELD_NONE;
2064                 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2065
2066                 if (copy_to_user(arg, &format, sizeof(format)))
2067                         return -EFAULT;
2068
2069                 return 0;
2070         }
2071
2072         case VIDIOC_TRY_FMT:
2073         case VIDIOC_S_FMT:
2074         {
2075                 struct sn9c102_sensor* s = cam->sensor;
2076                 struct v4l2_format format;
2077                 struct v4l2_pix_format* pix;
2078                 struct v4l2_pix_format* pfmt = &(s->pix_format);
2079                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
2080                 struct v4l2_rect rect;
2081                 u8 scale;
2082                 const enum sn9c102_stream_state stream = cam->stream;
2083                 const u32 nbuffers = cam->nbuffers;
2084                 u32 i;
2085                 int err = 0;
2086
2087                 if (copy_from_user(&format, arg, sizeof(format)))
2088                         return -EFAULT;
2089
2090                 pix = &(format.fmt.pix);
2091
2092                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2093                         return -EINVAL;
2094
2095                 memcpy(&rect, &(s->_rect), sizeof(rect));
2096
2097                 { /* calculate the actual scaling factor */
2098                         u32 a, b;
2099                         a = rect.width * rect.height;
2100                         b = pix->width * pix->height;
2101                         scale = b ? (u8)((a / b) < 4 ? 1 :
2102                                         ((a / b) < 16 ? 2 : 4)) : 1;
2103                 }
2104
2105                 rect.width = scale * pix->width;
2106                 rect.height = scale * pix->height;
2107
2108                 if (rect.width < 16)
2109                         rect.width = 16;
2110                 if (rect.height < 16)
2111                         rect.height = 16;
2112                 if (rect.width > bounds->left + bounds->width - rect.left)
2113                         rect.width = bounds->left + bounds->width - rect.left;
2114                 if (rect.height > bounds->top + bounds->height - rect.top)
2115                         rect.height = bounds->top + bounds->height - rect.top;
2116
2117                 rect.width &= ~15L;
2118                 rect.height &= ~15L;
2119
2120                 { /* adjust the scaling factor */
2121                         u32 a, b;
2122                         a = rect.width * rect.height;
2123                         b = pix->width * pix->height;
2124                         scale = b ? (u8)((a / b) < 4 ? 1 :
2125                                         ((a / b) < 16 ? 2 : 4)) : 1;
2126                 }
2127
2128                 pix->width = rect.width / scale;
2129                 pix->height = rect.height / scale;
2130
2131                 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2132                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2133                         pix->pixelformat = pfmt->pixelformat;
2134                 pix->priv = pfmt->priv; /* bpp */
2135                 pix->colorspace = pfmt->colorspace;
2136                 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
2137                                     ? 0 : (pix->width * pix->priv) / 8;
2138                 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2139                 pix->field = V4L2_FIELD_NONE;
2140
2141                 if (cmd == VIDIOC_TRY_FMT) {
2142                         if (copy_to_user(arg, &format, sizeof(format)))
2143                                 return -EFAULT;
2144                         return 0;
2145                 }
2146
2147                 if (cam->module_param.force_munmap)
2148                         for (i = 0; i < cam->nbuffers; i++)
2149                                 if (cam->frame[i].vma_use_count) {
2150                                         DBG(3, "VIDIOC_S_FMT failed. "
2151                                                "Unmap the buffers first.")
2152                                         return -EINVAL;
2153                                 }
2154
2155                 if (cam->stream == STREAM_ON)
2156                         if ((err = sn9c102_stream_interrupt(cam)))
2157                                 return err;
2158
2159                 if (copy_to_user(arg, &format, sizeof(format))) {
2160                         cam->stream = stream;
2161                         return -EFAULT;
2162                 }
2163
2164                 if (cam->module_param.force_munmap  || cam->io == IO_READ)
2165                         sn9c102_release_buffers(cam);
2166
2167                 err += sn9c102_set_pix_format(cam, pix);
2168                 err += sn9c102_set_crop(cam, &rect);
2169                 if (s->set_pix_format)
2170                         err += s->set_pix_format(cam, pix);
2171                 if (s->set_crop)
2172                         err += s->set_crop(cam, &rect);
2173                 err += sn9c102_set_scale(cam, scale);
2174
2175                 if (err) { /* atomic, no rollback in ioctl() */
2176                         cam->state |= DEV_MISCONFIGURED;
2177                         DBG(1, "VIDIOC_S_FMT failed because of hardware "
2178                                "problems. To use the camera, close and open "
2179                                "/dev/video%d again.", cam->v4ldev->minor)
2180                         return -EIO;
2181                 }
2182
2183                 memcpy(pfmt, pix, sizeof(*pix));
2184                 memcpy(&(s->_rect), &rect, sizeof(rect));
2185
2186                 if ((cam->module_param.force_munmap  || cam->io == IO_READ) &&
2187                     nbuffers != sn9c102_request_buffers(cam, nbuffers,
2188                                                         cam->io)) {
2189                         cam->state |= DEV_MISCONFIGURED;
2190                         DBG(1, "VIDIOC_S_FMT failed because of not enough "
2191                                "memory. To use the camera, close and open "
2192                                "/dev/video%d again.", cam->v4ldev->minor)
2193                         return -ENOMEM;
2194                 }
2195
2196                 cam->stream = stream;
2197
2198                 return 0;
2199         }
2200
2201         case VIDIOC_G_JPEGCOMP:
2202         {
2203                 if (copy_to_user(arg, &cam->compression,
2204                                  sizeof(cam->compression)))
2205                         return -EFAULT;
2206
2207                 return 0;
2208         }
2209
2210         case VIDIOC_S_JPEGCOMP:
2211         {
2212                 struct v4l2_jpegcompression jc;
2213                 const enum sn9c102_stream_state stream = cam->stream;
2214                 int err = 0;
2215
2216                 if (copy_from_user(&jc, arg, sizeof(jc)))
2217                         return -EFAULT;
2218
2219                 if (jc.quality != 0 && jc.quality != 1)
2220                         return -EINVAL;
2221
2222                 if (cam->stream == STREAM_ON)
2223                         if ((err = sn9c102_stream_interrupt(cam)))
2224                                 return err;
2225
2226                 err += sn9c102_set_compression(cam, &jc);
2227                 if (err) { /* atomic, no rollback in ioctl() */
2228                         cam->state |= DEV_MISCONFIGURED;
2229                         DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2230                                "problems. To use the camera, close and open "
2231                                "/dev/video%d again.", cam->v4ldev->minor)
2232                         return -EIO;
2233                 }
2234
2235                 cam->compression.quality = jc.quality;
2236
2237                 cam->stream = stream;
2238
2239                 return 0;
2240         }
2241
2242         case VIDIOC_REQBUFS:
2243         {
2244                 struct v4l2_requestbuffers rb;
2245                 u32 i;
2246                 int err;
2247
2248                 if (copy_from_user(&rb, arg, sizeof(rb)))
2249                         return -EFAULT;
2250
2251                 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2252                     rb.memory != V4L2_MEMORY_MMAP)
2253                         return -EINVAL;
2254
2255                 if (cam->io == IO_READ) {
2256                         DBG(3, "Close and open the device again to choose "
2257                                "the mmap I/O method")
2258                         return -EINVAL;
2259                 }
2260
2261                 for (i = 0; i < cam->nbuffers; i++)
2262                         if (cam->frame[i].vma_use_count) {
2263                                 DBG(3, "VIDIOC_REQBUFS failed. "
2264                                        "Previous buffers are still mapped.")
2265                                 return -EINVAL;
2266                         }
2267
2268                 if (cam->stream == STREAM_ON)
2269                         if ((err = sn9c102_stream_interrupt(cam)))
2270                                 return err;
2271
2272                 sn9c102_empty_framequeues(cam);
2273
2274                 sn9c102_release_buffers(cam);
2275                 if (rb.count)
2276                         rb.count = sn9c102_request_buffers(cam, rb.count,
2277                                                            IO_MMAP);
2278
2279                 if (copy_to_user(arg, &rb, sizeof(rb))) {
2280                         sn9c102_release_buffers(cam);
2281                         cam->io = IO_NONE;
2282                         return -EFAULT;
2283                 }
2284
2285                 cam->io = rb.count ? IO_MMAP : IO_NONE;
2286
2287                 return 0;
2288         }
2289
2290         case VIDIOC_QUERYBUF:
2291         {
2292                 struct v4l2_buffer b;
2293
2294                 if (copy_from_user(&b, arg, sizeof(b)))
2295                         return -EFAULT;
2296
2297                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2298                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2299                         return -EINVAL;
2300
2301                 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2302
2303                 if (cam->frame[b.index].vma_use_count)
2304                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2305
2306                 if (cam->frame[b.index].state == F_DONE)
2307                         b.flags |= V4L2_BUF_FLAG_DONE;
2308                 else if (cam->frame[b.index].state != F_UNUSED)
2309                         b.flags |= V4L2_BUF_FLAG_QUEUED;
2310
2311                 if (copy_to_user(arg, &b, sizeof(b)))
2312                         return -EFAULT;
2313
2314                 return 0;
2315         }
2316
2317         case VIDIOC_QBUF:
2318         {
2319                 struct v4l2_buffer b;
2320                 unsigned long lock_flags;
2321
2322                 if (copy_from_user(&b, arg, sizeof(b)))
2323                         return -EFAULT;
2324
2325                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2326                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2327                         return -EINVAL;
2328
2329                 if (cam->frame[b.index].state != F_UNUSED)
2330                         return -EINVAL;
2331
2332                 cam->frame[b.index].state = F_QUEUED;
2333
2334                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2335                 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2336                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2337
2338                 PDBGG("Frame #%lu queued", (unsigned long)b.index)
2339
2340                 return 0;
2341         }
2342
2343         case VIDIOC_DQBUF:
2344         {
2345                 struct v4l2_buffer b;
2346                 struct sn9c102_frame_t *f;
2347                 unsigned long lock_flags;
2348                 int err = 0;
2349
2350                 if (copy_from_user(&b, arg, sizeof(b)))
2351                         return -EFAULT;
2352
2353                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io!= IO_MMAP)
2354                         return -EINVAL;
2355
2356                 if (list_empty(&cam->outqueue)) {
2357                         if (cam->stream == STREAM_OFF)
2358                                 return -EINVAL;
2359                         if (filp->f_flags & O_NONBLOCK)
2360                                 return -EAGAIN;
2361                         err = wait_event_interruptible
2362                               ( cam->wait_frame,
2363                                 (!list_empty(&cam->outqueue)) ||
2364                                 (cam->state & DEV_DISCONNECTED) ||
2365                                 (cam->state & DEV_MISCONFIGURED) );
2366                         if (err)
2367                                 return err;
2368                         if (cam->state & DEV_DISCONNECTED)
2369                                 return -ENODEV;
2370                         if (cam->state & DEV_MISCONFIGURED)
2371                                 return -EIO;
2372                 }
2373
2374                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2375                 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t,
2376                                frame);
2377                 list_del(cam->outqueue.next);
2378                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2379
2380                 f->state = F_UNUSED;
2381
2382                 memcpy(&b, &f->buf, sizeof(b));
2383                 if (f->vma_use_count)
2384                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2385
2386                 if (copy_to_user(arg, &b, sizeof(b)))
2387                         return -EFAULT;
2388
2389                 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index)
2390
2391                 return 0;
2392         }
2393
2394         case VIDIOC_STREAMON:
2395         {
2396                 int type;
2397
2398                 if (copy_from_user(&type, arg, sizeof(type)))
2399                         return -EFAULT;
2400
2401                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2402                         return -EINVAL;
2403
2404                 if (list_empty(&cam->inqueue))
2405                         return -EINVAL;
2406
2407                 cam->stream = STREAM_ON;
2408
2409                 DBG(3, "Stream on")
2410
2411                 return 0;
2412         }
2413
2414         case VIDIOC_STREAMOFF:
2415         {
2416                 int type, err;
2417
2418                 if (copy_from_user(&type, arg, sizeof(type)))
2419                         return -EFAULT;
2420
2421                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2422                         return -EINVAL;
2423
2424                 if (cam->stream == STREAM_ON)
2425                         if ((err = sn9c102_stream_interrupt(cam)))
2426                                 return err;
2427
2428                 sn9c102_empty_framequeues(cam);
2429
2430                 DBG(3, "Stream off")
2431
2432                 return 0;
2433         }
2434
2435         case VIDIOC_G_PARM:
2436         {
2437                 struct v4l2_streamparm sp;
2438
2439                 if (copy_from_user(&sp, arg, sizeof(sp)))
2440                         return -EFAULT;
2441
2442                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2443                         return -EINVAL;
2444
2445                 sp.parm.capture.extendedmode = 0;
2446                 sp.parm.capture.readbuffers = cam->nreadbuffers;
2447
2448                 if (copy_to_user(arg, &sp, sizeof(sp)))
2449                         return -EFAULT;
2450
2451                 return 0;
2452         }
2453
2454         case VIDIOC_S_PARM_OLD:
2455         case VIDIOC_S_PARM:
2456         {
2457                 struct v4l2_streamparm sp;
2458
2459                 if (copy_from_user(&sp, arg, sizeof(sp)))
2460                         return -EFAULT;
2461
2462                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2463                         return -EINVAL;
2464
2465                 sp.parm.capture.extendedmode = 0;
2466
2467                 if (sp.parm.capture.readbuffers == 0)
2468                         sp.parm.capture.readbuffers = cam->nreadbuffers;
2469
2470                 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
2471                         sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
2472
2473                 if (copy_to_user(arg, &sp, sizeof(sp)))
2474                         return -EFAULT;
2475
2476                 cam->nreadbuffers = sp.parm.capture.readbuffers;
2477
2478                 return 0;
2479         }
2480
2481         case VIDIOC_G_STD:
2482         case VIDIOC_S_STD:
2483         case VIDIOC_QUERYSTD:
2484         case VIDIOC_ENUMSTD:
2485         case VIDIOC_QUERYMENU:
2486                 return -EINVAL;
2487
2488         default:
2489                 return -EINVAL;
2490
2491         }
2492 }
2493
2494
2495 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
2496                          unsigned int cmd, unsigned long arg)
2497 {
2498         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2499         int err = 0;
2500
2501         if (down_interruptible(&cam->fileop_sem))
2502                 return -ERESTARTSYS;
2503
2504         if (cam->state & DEV_DISCONNECTED) {
2505                 DBG(1, "Device not present")
2506                 up(&cam->fileop_sem);
2507                 return -ENODEV;
2508         }
2509
2510         if (cam->state & DEV_MISCONFIGURED) {
2511                 DBG(1, "The camera is misconfigured. Close and open it again.")
2512                 up(&cam->fileop_sem);
2513                 return -EIO;
2514         }
2515
2516         err = sn9c102_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
2517
2518         up(&cam->fileop_sem);
2519
2520         return err;
2521 }
2522
2523
2524 static struct file_operations sn9c102_fops = {
2525         .owner =   THIS_MODULE,
2526         .open =    sn9c102_open,
2527         .release = sn9c102_release,
2528         .ioctl =   sn9c102_ioctl,
2529         .read =    sn9c102_read,
2530         .poll =    sn9c102_poll,
2531         .mmap =    sn9c102_mmap,
2532         .llseek =  no_llseek,
2533 };
2534
2535 /*****************************************************************************/
2536
2537 /* It exists a single interface only. We do not need to validate anything. */
2538 static int
2539 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
2540 {
2541         struct usb_device *udev = interface_to_usbdev(intf);
2542         struct sn9c102_device* cam;
2543         static unsigned int dev_nr = 0;
2544         unsigned int i, n;
2545         int err = 0, r;
2546
2547         n = sizeof(sn9c102_id_table)/sizeof(sn9c102_id_table[0]);
2548         for (i = 0; i < n-1; i++)
2549                 if (le16_to_cpu(udev->descriptor.idVendor) ==
2550                     sn9c102_id_table[i].idVendor &&
2551                     le16_to_cpu(udev->descriptor.idProduct) ==
2552                     sn9c102_id_table[i].idProduct)
2553                         break;
2554         if (i == n-1)
2555                 return -ENODEV;
2556
2557         if (!(cam = kmalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
2558                 return -ENOMEM;
2559         memset(cam, 0, sizeof(*cam));
2560
2561         cam->usbdev = udev;
2562
2563         memcpy(&cam->dev, &udev->dev, sizeof(struct device));
2564
2565         if (!(cam->control_buffer = kmalloc(8, GFP_KERNEL))) {
2566                 DBG(1, "kmalloc() failed")
2567                 err = -ENOMEM;
2568                 goto fail;
2569         }
2570         memset(cam->control_buffer, 0, 8);
2571
2572         if (!(cam->v4ldev = video_device_alloc())) {
2573                 DBG(1, "video_device_alloc() failed")
2574                 err = -ENOMEM;
2575                 goto fail;
2576         }
2577
2578         init_MUTEX(&cam->dev_sem);
2579
2580         r = sn9c102_read_reg(cam, 0x00);
2581         if (r < 0 || r != 0x10) {
2582                 DBG(1, "Sorry, this is not a SN9C10x based camera "
2583                        "(vid/pid 0x%04X/0x%04X)",
2584                     sn9c102_id_table[i].idVendor,sn9c102_id_table[i].idProduct)
2585                 err = -ENODEV;
2586                 goto fail;
2587         }
2588
2589         cam->bridge = (sn9c102_id_table[i].idProduct & 0xffc0) == 0x6080 ?
2590                       BRIDGE_SN9C103 : BRIDGE_SN9C102;
2591         switch (cam->bridge) {
2592         case BRIDGE_SN9C101:
2593         case BRIDGE_SN9C102:
2594                 DBG(2, "SN9C10[12] PC Camera Controller detected "
2595                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2596                     sn9c102_id_table[i].idProduct)
2597                 break;
2598         case BRIDGE_SN9C103:
2599                 DBG(2, "SN9C103 PC Camera Controller detected "
2600                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2601                     sn9c102_id_table[i].idProduct)
2602                 break;
2603         }
2604
2605         for  (i = 0; sn9c102_sensor_table[i]; i++) {
2606                 err = sn9c102_sensor_table[i](cam);
2607                 if (!err)
2608                         break;
2609         }
2610
2611         if (!err && cam->sensor) {
2612                 DBG(2, "%s image sensor detected", cam->sensor->name)
2613                 DBG(3, "Support for %s maintained by %s",
2614                     cam->sensor->name, cam->sensor->maintainer)
2615         } else {
2616                 DBG(1, "No supported image sensor detected")
2617                 err = -ENODEV;
2618                 goto fail;
2619         }
2620
2621         if (sn9c102_init(cam)) {
2622                 DBG(1, "Initialization failed. I will retry on open().")
2623                 cam->state |= DEV_MISCONFIGURED;
2624         }
2625
2626         strcpy(cam->v4ldev->name, "SN9C10x PC Camera");
2627         cam->v4ldev->owner = THIS_MODULE;
2628         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
2629         cam->v4ldev->hardware = VID_HARDWARE_SN9C102;
2630         cam->v4ldev->fops = &sn9c102_fops;
2631         cam->v4ldev->minor = video_nr[dev_nr];
2632         cam->v4ldev->release = video_device_release;
2633         video_set_drvdata(cam->v4ldev, cam);
2634
2635         down(&cam->dev_sem);
2636
2637         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
2638                                     video_nr[dev_nr]);
2639         if (err) {
2640                 DBG(1, "V4L2 device registration failed")
2641                 if (err == -ENFILE && video_nr[dev_nr] == -1)
2642                         DBG(1, "Free /dev/videoX node not found")
2643                 video_nr[dev_nr] = -1;
2644                 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2645                 up(&cam->dev_sem);
2646                 goto fail;
2647         }
2648
2649         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor)
2650
2651         cam->module_param.force_munmap = force_munmap[dev_nr];
2652
2653         dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2654
2655         sn9c102_create_sysfs(cam);
2656         DBG(2, "Optional device control through 'sysfs' interface ready")
2657
2658         usb_set_intfdata(intf, cam);
2659
2660         up(&cam->dev_sem);
2661
2662         return 0;
2663
2664 fail:
2665         if (cam) {
2666                 kfree(cam->control_buffer);
2667                 if (cam->v4ldev)
2668                         video_device_release(cam->v4ldev);
2669                 kfree(cam);
2670         }
2671         return err;
2672 }
2673
2674
2675 static void sn9c102_usb_disconnect(struct usb_interface* intf)
2676 {
2677         struct sn9c102_device* cam = usb_get_intfdata(intf);
2678
2679         if (!cam)
2680                 return;
2681
2682         down_write(&sn9c102_disconnect);
2683
2684         down(&cam->dev_sem);
2685
2686         DBG(2, "Disconnecting %s...", cam->v4ldev->name)
2687
2688         wake_up_interruptible_all(&cam->open);
2689
2690         if (cam->users) {
2691                 DBG(2, "Device /dev/video%d is open! Deregistration and "
2692                        "memory deallocation are deferred on close.",
2693                     cam->v4ldev->minor)
2694                 cam->state |= DEV_MISCONFIGURED;
2695                 sn9c102_stop_transfer(cam);
2696                 cam->state |= DEV_DISCONNECTED;
2697                 wake_up_interruptible(&cam->wait_frame);
2698                 wake_up_interruptible(&cam->wait_stream);
2699         } else {
2700                 cam->state |= DEV_DISCONNECTED;
2701                 sn9c102_release_resources(cam);
2702         }
2703
2704         up(&cam->dev_sem);
2705
2706         if (!cam->users)
2707                 kfree(cam);
2708
2709         up_write(&sn9c102_disconnect);
2710 }
2711
2712
2713 static struct usb_driver sn9c102_usb_driver = {
2714         .owner =      THIS_MODULE,
2715         .name =       "sn9c102",
2716         .id_table =   sn9c102_id_table,
2717         .probe =      sn9c102_usb_probe,
2718         .disconnect = sn9c102_usb_disconnect,
2719 };
2720
2721 /*****************************************************************************/
2722
2723 static int __init sn9c102_module_init(void)
2724 {
2725         int err = 0;
2726
2727         KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION)
2728         KDBG(3, SN9C102_MODULE_AUTHOR)
2729
2730         if ((err = usb_register(&sn9c102_usb_driver)))
2731                 KDBG(1, "usb_register() failed")
2732
2733         return err;
2734 }
2735
2736
2737 static void __exit sn9c102_module_exit(void)
2738 {
2739         usb_deregister(&sn9c102_usb_driver);
2740 }
2741
2742
2743 module_init(sn9c102_module_init);
2744 module_exit(sn9c102_module_exit);