drivers/media/video/sn9c102/sn9c102_core.c

   1 /***************************************************************************
   2  * V4L2 driver for SN9C1xx PC Camera Controllers                           *
   3  *                                                                         *
   4  * Copyright (C) 2004-2007 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/errno.h>
  26 #include <linux/slab.h>
  27 #include <linux/device.h>
  28 #include <linux/fs.h>
  29 #include <linux/delay.h>
  30 #include <linux/compiler.h>
  31 #include <linux/ioctl.h>
  32 #include <linux/poll.h>
  33 #include <linux/stat.h>
  34 #include <linux/mm.h>
  35 #include <linux/vmalloc.h>
  36 #include <linux/page-flags.h>
  37 #include <asm/byteorder.h>
  38 #include <asm/page.h>
  39 #include <asm/uaccess.h>
  40
  41 #include "sn9c102.h"
  42
  43 /*****************************************************************************/
  44
  45 #define SN9C102_MODULE_NAME     "V4L2 driver for SN9C1xx PC Camera Controllers"
  46 #define SN9C102_MODULE_ALIAS    "sn9c1xx"
  47 #define SN9C102_MODULE_AUTHOR   "(C) 2004-2007 Luca Risolia"
  48 #define SN9C102_AUTHOR_EMAIL    "<luca.risolia@studio.unibo.it>"
  49 #define SN9C102_MODULE_LICENSE  "GPL"
  50 #define SN9C102_MODULE_VERSION  "1:1.47pre49"
  51 #define SN9C102_MODULE_VERSION_CODE  KERNEL_VERSION(1, 1, 47)
  52
  53 /*****************************************************************************/
  54
  55 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
  56
  57 MODULE_AUTHOR(SN9C102_MODULE_AUTHOR " " SN9C102_AUTHOR_EMAIL);
  58 MODULE_DESCRIPTION(SN9C102_MODULE_NAME);
  59 MODULE_ALIAS(SN9C102_MODULE_ALIAS);
  60 MODULE_VERSION(SN9C102_MODULE_VERSION);
  61 MODULE_LICENSE(SN9C102_MODULE_LICENSE);
  62
  63 static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};
  64 module_param_array(video_nr, short, NULL, 0444);
  65 MODULE_PARM_DESC(video_nr,
  66                  " <-1|n[,...]>"
  67                  "\nSpecify V4L2 minor mode number."
  68                  "\n-1 = use next available (default)"
  69                  "\n n = use minor number n (integer >= 0)"
  70                  "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
  71                  " cameras this way."
  72                  "\nFor example:"
  73                  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
  74                  "\nthe second camera and use auto for the first"
  75                  "\none and for every other camera."
  76                  "\n");
  77
  78 static short force_munmap[] = {[0 ... SN9C102_MAX_DEVICES-1] =
  79                                SN9C102_FORCE_MUNMAP};
  80 module_param_array(force_munmap, bool, NULL, 0444);
  81 MODULE_PARM_DESC(force_munmap,
  82                  " <0|1[,...]>"
  83                  "\nForce the application to unmap previously"
  84                  "\nmapped buffer memory before calling any VIDIOC_S_CROP or"
  85                  "\nVIDIOC_S_FMT ioctl's. Not all the applications support"
  86                  "\nthis feature. This parameter is specific for each"
  87                  "\ndetected camera."
  88                  "\n0 = do not force memory unmapping"
  89                  "\n1 = force memory unmapping (save memory)"
  90                  "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP)"."
  91                  "\n");
  92
  93 static unsigned int frame_timeout[] = {[0 ... SN9C102_MAX_DEVICES-1] =
  94                                        SN9C102_FRAME_TIMEOUT};
  95 module_param_array(frame_timeout, uint, NULL, 0644);
  96 MODULE_PARM_DESC(frame_timeout,
  97                  " <0|n[,...]>"
  98                  "\nTimeout for a video frame in seconds before"
  99                  "\nreturning an I/O error; 0 for infinity."
 100                  "\nThis parameter is specific for each detected camera."
 101                  "\nDefault value is "__MODULE_STRING(SN9C102_FRAME_TIMEOUT)"."
 102                  "\n");
 103
 104 #ifdef SN9C102_DEBUG
 105 static unsigned short debug = SN9C102_DEBUG_LEVEL;
 106 module_param(debug, ushort, 0644);
 107 MODULE_PARM_DESC(debug,
 108                  " <n>"
 109                  "\nDebugging information level, from 0 to 3:"
 110                  "\n0 = none (use carefully)"
 111                  "\n1 = critical errors"
 112                  "\n2 = significant informations"
 113                  "\n3 = more verbose messages"
 114                  "\nLevel 3 is useful for testing only."
 115                  "\nDefault value is "__MODULE_STRING(SN9C102_DEBUG_LEVEL)"."
 116                  "\n");
 117 #endif
 118
 119 /*****************************************************************************/
 120
 121 static u32
 122 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
 123                         enum sn9c102_io_method io)
 124 {
 125         struct v4l2_pix_format* p = &(cam->sensor.pix_format);
 126         struct v4l2_rect* r = &(cam->sensor.cropcap.bounds);
 127         size_t imagesize = cam->module_param.force_munmap || io == IO_READ ?
 128                            (p->width * p->height * p->priv) / 8 :
 129                            (r->width * r->height * p->priv) / 8;
 130         void* buff = NULL;
 131         u32 i;
 132
 133         if (count > SN9C102_MAX_FRAMES)
 134                 count = SN9C102_MAX_FRAMES;
 135
 136         if (cam->bridge == BRIDGE_SN9C105 || cam->bridge == BRIDGE_SN9C120)
 137                 imagesize += 589 + 2; /* length of JPEG header + EOI marker */
 138
 139         cam->nbuffers = count;
 140         while (cam->nbuffers > 0) {
 141                 if ((buff = vmalloc_32_user(cam->nbuffers *
 142                                             PAGE_ALIGN(imagesize))))
 143                         break;
 144                 cam->nbuffers--;
 145         }
 146
 147         for (i = 0; i < cam->nbuffers; i++) {
 148                 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
 149                 cam->frame[i].buf.index = i;
 150                 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
 151                 cam->frame[i].buf.length = imagesize;
 152                 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 153                 cam->frame[i].buf.sequence = 0;
 154                 cam->frame[i].buf.field = V4L2_FIELD_NONE;
 155                 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
 156                 cam->frame[i].buf.flags = 0;
 157         }
 158
 159         return cam->nbuffers;
 160 }
 161
 162
 163 static void sn9c102_release_buffers(struct sn9c102_device* cam)
 164 {
 165         if (cam->nbuffers) {
 166                 vfree(cam->frame[0].bufmem);
 167                 cam->nbuffers = 0;
 168         }
 169         cam->frame_current = NULL;
 170 }
 171
 172
 173 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
 174 {
 175         u32 i;
 176
 177         INIT_LIST_HEAD(&cam->inqueue);
 178         INIT_LIST_HEAD(&cam->outqueue);
 179
 180         for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
 181                 cam->frame[i].state = F_UNUSED;
 182                 cam->frame[i].buf.bytesused = 0;
 183         }
 184 }
 185
 186
 187 static void sn9c102_requeue_outqueue(struct sn9c102_device* cam)
 188 {
 189         struct sn9c102_frame_t *i;
 190
 191         list_for_each_entry(i, &cam->outqueue, frame) {
 192                 i->state = F_QUEUED;
 193                 list_add(&i->frame, &cam->inqueue);
 194         }
 195
 196         INIT_LIST_HEAD(&cam->outqueue);
 197 }
 198
 199
 200 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
 201 {
 202         unsigned long lock_flags;
 203         u32 i;
 204
 205         for (i = 0; i < cam->nbuffers; i++)
 206                 if (cam->frame[i].state == F_UNUSED) {
 207                         cam->frame[i].state = F_QUEUED;
 208                         spin_lock_irqsave(&cam->queue_lock, lock_flags);
 209                         list_add_tail(&cam->frame[i].frame, &cam->inqueue);
 210                         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 211                 }
 212 }
 213
 214 /*****************************************************************************/
 215
 216 /*
 217    Write a sequence of count value/register pairs. Returns -1 after the first
 218    failed write, or 0 for no errors.
 219 */
 220 int sn9c102_write_regs(struct sn9c102_device* cam, const u8 valreg[][2],
 221                        int count)
 222 {
 223         struct usb_device* udev = cam->usbdev;
 224         u8* buff = cam->control_buffer;
 225         int i, res;
 226
 227         for (i = 0; i < count; i++) {
 228                 u8 index = valreg[i][1];
 229
 230                 /*
 231                    index is a u8, so it must be <256 and can't be out of range.
 232                    If we put in a check anyway, gcc annoys us with a warning
 233                    hat our check is useless. People get all uppity when they
 234                    see warnings in the kernel compile.
 235                 */
 236
 237                 *buff = valreg[i][0];
 238
 239                 res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08,
 240                                       0x41, index, 0, buff, 1,
 241                                       SN9C102_CTRL_TIMEOUT);
 242
 243                 if (res < 0) {
 244                         DBG(3, "Failed to write a register (value 0x%02X, "
 245                                "index 0x%02X, error %d)", *buff, index, res);
 246                         return -1;
 247                 }
 248
 249                 cam->reg[index] = *buff;
 250         }
 251
 252         return 0;
 253 }
 254
 255
 256 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
 257 {
 258         struct usb_device* udev = cam->usbdev;
 259         u8* buff = cam->control_buffer;
 260         int res;
 261
 262         if (index >= ARRAY_SIZE(cam->reg))
 263                 return -1;
 264
 265         *buff = value;
 266
 267         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 268                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 269         if (res < 0) {
 270                 DBG(3, "Failed to write a register (value 0x%02X, index "
 271                        "0x%02X, error %d)", value, index, res);
 272                 return -1;
 273         }
 274
 275         cam->reg[index] = value;
 276
 277         return 0;
 278 }
 279
 280
 281 /* NOTE: with the SN9C10[123] reading some registers always returns 0 */
 282 int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
 283 {
 284         struct usb_device* udev = cam->usbdev;
 285         u8* buff = cam->control_buffer;
 286         int res;
 287
 288         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 289                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 290         if (res < 0)
 291                 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
 292                     index, res);
 293
 294         return (res >= 0) ? (int)(*buff) : -1;
 295 }
 296
 297
 298 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
 299 {
 300         if (index >= ARRAY_SIZE(cam->reg))
 301                 return -1;
 302
 303         return cam->reg[index];
 304 }
 305
 306
 307 static int
 308 sn9c102_i2c_wait(struct sn9c102_device* cam,
 309                  const struct sn9c102_sensor* sensor)
 310 {
 311         int i, r;
 312
 313         for (i = 1; i <= 5; i++) {
 314                 r = sn9c102_read_reg(cam, 0x08);
 315                 if (r < 0)
 316                         return -EIO;
 317                 if (r & 0x04)
 318                         return 0;
 319                 if (sensor->frequency & SN9C102_I2C_400KHZ)
 320                         udelay(5*16);
 321                 else
 322                         udelay(16*16);
 323         }
 324         return -EBUSY;
 325 }
 326
 327
 328 static int
 329 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
 330                               const struct sn9c102_sensor* sensor)
 331 {
 332         int r , err = 0;
 333
 334         r = sn9c102_read_reg(cam, 0x08);
 335         if (r < 0)
 336                 err += r;
 337
 338         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
 339                 if (!(r & 0x08))
 340                         err += -1;
 341         } else {
 342                 if (r & 0x08)
 343                         err += -1;
 344         }
 345
 346         return err ? -EIO : 0;
 347 }
 348
 349
 350 static int
 351 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
 352                                const struct sn9c102_sensor* sensor)
 353 {
 354         int r;
 355         r = sn9c102_read_reg(cam, 0x08);
 356         return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
 357 }
 358
 359
 360 int
 361 sn9c102_i2c_try_raw_read(struct sn9c102_device* cam,
 362                          const struct sn9c102_sensor* sensor, u8 data0,
 363                          u8 data1, u8 n, u8 buffer[])
 364 {
 365         struct usb_device* udev = cam->usbdev;
 366         u8* data = cam->control_buffer;
 367         int i = 0, err = 0, res;
 368
 369         /* Write cycle */
 370         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 371                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) | 0x10;
 372         data[1] = data0; /* I2C slave id */
 373         data[2] = data1; /* address */
 374         data[7] = 0x10;
 375         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 376                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 377         if (res < 0)
 378                 err += res;
 379
 380         err += sn9c102_i2c_wait(cam, sensor);
 381
 382         /* Read cycle - n bytes */
 383         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 384                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
 385                   (n << 4) | 0x02;
 386         data[1] = data0;
 387         data[7] = 0x10;
 388         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 389                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 390         if (res < 0)
 391                 err += res;
 392
 393         err += sn9c102_i2c_wait(cam, sensor);
 394
 395         /* The first read byte will be placed in data[4] */
 396         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 397                               0x0a, 0, data, 5, SN9C102_CTRL_TIMEOUT);
 398         if (res < 0)
 399                 err += res;
 400
 401         err += sn9c102_i2c_detect_read_error(cam, sensor);
 402
 403         PDBGG("I2C read: address 0x%02X, first read byte: 0x%02X", data1,
 404               data[4]);
 405
 406         if (err) {
 407                 DBG(3, "I2C read failed for %s image sensor", sensor->name);
 408                 return -1;
 409         }
 410
 411         if (buffer)
 412                 for (i = 0; i < n && i < 5; i++)
 413                         buffer[n-i-1] = data[4-i];
 414
 415         return (int)data[4];
 416 }
 417
 418
 419 int
 420 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
 421                           const struct sn9c102_sensor* sensor, u8 n, u8 data0,
 422                           u8 data1, u8 data2, u8 data3, u8 data4, u8 data5)
 423 {
 424         struct usb_device* udev = cam->usbdev;
 425         u8* data = cam->control_buffer;
 426         int err = 0, res;
 427
 428         /* Write cycle. It usually is address + value */
 429         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 430                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0)
 431                   | ((n - 1) << 4);
 432         data[1] = data0;
 433         data[2] = data1;
 434         data[3] = data2;
 435         data[4] = data3;
 436         data[5] = data4;
 437         data[6] = data5;
 438         data[7] = 0x17;
 439         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 440                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 441         if (res < 0)
 442                 err += res;
 443
 444         err += sn9c102_i2c_wait(cam, sensor);
 445         err += sn9c102_i2c_detect_write_error(cam, sensor);
 446
 447         if (err)
 448                 DBG(3, "I2C write failed for %s image sensor", sensor->name);
 449
 450         PDBGG("I2C raw write: %u bytes, data0 = 0x%02X, data1 = 0x%02X, "
 451               "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X",
 452               n, data0, data1, data2, data3, data4, data5);
 453
 454         return err ? -1 : 0;
 455 }
 456
 457
 458 int
 459 sn9c102_i2c_try_read(struct sn9c102_device* cam,
 460                      const struct sn9c102_sensor* sensor, u8 address)
 461 {
 462         return sn9c102_i2c_try_raw_read(cam, sensor, sensor->i2c_slave_id,
 463                                         address, 1, NULL);
 464 }
 465
 466
 467 static int sn9c102_i2c_try_write(struct sn9c102_device* cam,
 468                                  const struct sn9c102_sensor* sensor,
 469                                  u8 address, u8 value)
 470 {
 471         return sn9c102_i2c_try_raw_write(cam, sensor, 3,
 472                                          sensor->i2c_slave_id, address,
 473                                          value, 0, 0, 0);
 474 }
 475
 476
 477 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
 478 {
 479         return sn9c102_i2c_try_read(cam, &cam->sensor, address);
 480 }
 481
 482
 483 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
 484 {
 485         return sn9c102_i2c_try_write(cam, &cam->sensor, address, value);
 486 }
 487
 488 /*****************************************************************************/
 489
 490 static size_t sn9c102_sof_length(struct sn9c102_device* cam)
 491 {
 492         switch (cam->bridge) {
 493         case BRIDGE_SN9C101:
 494         case BRIDGE_SN9C102:
 495                 return 12;
 496         case BRIDGE_SN9C103:
 497                 return 18;
 498         case BRIDGE_SN9C105:
 499         case BRIDGE_SN9C120:
 500                 return 62;
 501         }
 502
 503         return 0;
 504 }
 505
 506
 507 static void*
 508 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
 509 {
 510         static const char marker[6] = {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96};
 511         const char *m = mem;
 512         size_t soflen = 0, i, j;
 513
 514         soflen = sn9c102_sof_length(cam);
 515
 516         for (i = 0; i < len; i++) {
 517                 size_t b;
 518
 519                 /* Read the variable part of the header */
 520                 if (unlikely(cam->sof.bytesread >= sizeof(marker))) {
 521                         cam->sof.header[cam->sof.bytesread] = *(m+i);
 522                         if (++cam->sof.bytesread == soflen) {
 523                                 cam->sof.bytesread = 0;
 524                                 return mem + i;
 525                         }
 526                         continue;
 527                 }
 528
 529                 /* Search for the SOF marker (fixed part) in the header */
 530                 for (j = 0, b=cam->sof.bytesread; j+b < sizeof(marker); j++) {
 531                         if (unlikely(i+j == len))
 532                                 return NULL;
 533                         if (*(m+i+j) == marker[cam->sof.bytesread]) {
 534                                 cam->sof.header[cam->sof.bytesread] = *(m+i+j);
 535                                 if (++cam->sof.bytesread == sizeof(marker)) {
 536                                         PDBGG("Bytes to analyze: %zd. SOF "
 537                                               "starts at byte #%zd", len, i);
 538                                         i += j+1;
 539                                         break;
 540                                 }
 541                         } else {
 542                                 cam->sof.bytesread = 0;
 543                                 break;
 544                         }
 545                 }
 546         }
 547
 548         return NULL;
 549 }
 550
 551
 552 static void*
 553 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
 554 {
 555         static const u8 eof_header[4][4] = {
 556                 {0x00, 0x00, 0x00, 0x00},
 557                 {0x40, 0x00, 0x00, 0x00},
 558                 {0x80, 0x00, 0x00, 0x00},
 559                 {0xc0, 0x00, 0x00, 0x00},
 560         };
 561         size_t i, j;
 562
 563         /* The EOF header does not exist in compressed data */
 564         if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
 565             cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
 566                 return NULL;
 567
 568         /*
 569            The EOF header might cross the packet boundary, but this is not a
 570            problem, since the end of a frame is determined by checking its size
 571            in the first place.
 572         */
 573         for (i = 0; (len >= 4) && (i <= len - 4); i++)
 574                 for (j = 0; j < ARRAY_SIZE(eof_header); j++)
 575                         if (!memcmp(mem + i, eof_header[j], 4))
 576                                 return mem + i;
 577
 578         return NULL;
 579 }
 580
 581
 582 static void
 583 sn9c102_write_jpegheader(struct sn9c102_device* cam, struct sn9c102_frame_t* f)
 584 {
 585         static const u8 jpeg_header[589] = {
 586                 0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x06, 0x04, 0x05,
 587                 0x06, 0x05, 0x04, 0x06, 0x06, 0x05, 0x06, 0x07, 0x07, 0x06,
 588                 0x08, 0x0a, 0x10, 0x0a, 0x0a, 0x09, 0x09, 0x0a, 0x14, 0x0e,
 589                 0x0f, 0x0c, 0x10, 0x17, 0x14, 0x18, 0x18, 0x17, 0x14, 0x16,
 590                 0x16, 0x1a, 0x1d, 0x25, 0x1f, 0x1a, 0x1b, 0x23, 0x1c, 0x16,
 591                 0x16, 0x20, 0x2c, 0x20, 0x23, 0x26, 0x27, 0x29, 0x2a, 0x29,
 592                 0x19, 0x1f, 0x2d, 0x30, 0x2d, 0x28, 0x30, 0x25, 0x28, 0x29,
 593                 0x28, 0x01, 0x07, 0x07, 0x07, 0x0a, 0x08, 0x0a, 0x13, 0x0a,
 594                 0x0a, 0x13, 0x28, 0x1a, 0x16, 0x1a, 0x28, 0x28, 0x28, 0x28,
 595                 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 596                 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 597                 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 598                 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
 599                 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0xff, 0xc4, 0x01, 0xa2,
 600                 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 601                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02,
 602                 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01,
 603                 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 604                 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
 605                 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10, 0x00,
 606                 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04,
 607                 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04,
 608                 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
 609                 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23,
 610                 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62,
 611                 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25,
 612                 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38,
 613                 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
 614                 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
 615                 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
 616                 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
 617                 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
 618                 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
 619                 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
 620                 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
 621                 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3,
 622                 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3,
 623                 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0x11, 0x00, 0x02,
 624                 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04,
 625                 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
 626                 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 627                 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1,
 628                 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
 629                 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19,
 630                 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 631                 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
 632                 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
 633                 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
 634                 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 635                 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 636                 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
 637                 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
 638                 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 639                 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3,
 640                 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
 641                 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc0, 0x00, 0x11,
 642                 0x08, 0x01, 0xe0, 0x02, 0x80, 0x03, 0x01, 0x21, 0x00, 0x02,
 643                 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xda, 0x00, 0x0c, 0x03,
 644                 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00
 645         };
 646         u8 *pos = f->bufmem;
 647
 648         memcpy(pos, jpeg_header, sizeof(jpeg_header));
 649         *(pos + 6) = 0x00;
 650         *(pos + 7 + 64) = 0x01;
 651         if (cam->compression.quality == 0) {
 652                 memcpy(pos + 7, SN9C102_Y_QTABLE0, 64);
 653                 memcpy(pos + 8 + 64, SN9C102_UV_QTABLE0, 64);
 654         } else if (cam->compression.quality == 1) {
 655                 memcpy(pos + 7, SN9C102_Y_QTABLE1, 64);
 656                 memcpy(pos + 8 + 64, SN9C102_UV_QTABLE1, 64);
 657         }
 658         *(pos + 564) = cam->sensor.pix_format.width & 0xFF;
 659         *(pos + 563) = (cam->sensor.pix_format.width >> 8) & 0xFF;
 660         *(pos + 562) = cam->sensor.pix_format.height & 0xFF;
 661         *(pos + 561) = (cam->sensor.pix_format.height >> 8) & 0xFF;
 662         *(pos + 567) = 0x21;
 663
 664         f->buf.bytesused += sizeof(jpeg_header);
 665 }
 666
 667
 668 static void sn9c102_urb_complete(struct urb *urb)
 669 {
 670         struct sn9c102_device* cam = urb->context;
 671         struct sn9c102_frame_t** f;
 672         size_t imagesize, soflen;
 673         u8 i;
 674         int err = 0;
 675
 676         if (urb->status == -ENOENT)
 677                 return;
 678
 679         f = &cam->frame_current;
 680
 681         if (cam->stream == STREAM_INTERRUPT) {
 682                 cam->stream = STREAM_OFF;
 683                 if ((*f))
 684                         (*f)->state = F_QUEUED;
 685                 cam->sof.bytesread = 0;
 686                 DBG(3, "Stream interrupted by application");
 687                 wake_up(&cam->wait_stream);
 688         }
 689
 690         if (cam->state & DEV_DISCONNECTED)
 691                 return;
 692
 693         if (cam->state & DEV_MISCONFIGURED) {
 694                 wake_up_interruptible(&cam->wait_frame);
 695                 return;
 696         }
 697
 698         if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
 699                 goto resubmit_urb;
 700
 701         if (!(*f))
 702                 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
 703                                   frame);
 704
 705         imagesize = (cam->sensor.pix_format.width *
 706                      cam->sensor.pix_format.height *
 707                      cam->sensor.pix_format.priv) / 8;
 708         if (cam->sensor.pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
 709                 imagesize += 589; /* length of jpeg header */
 710         soflen = sn9c102_sof_length(cam);
 711
 712         for (i = 0; i < urb->number_of_packets; i++) {
 713                 unsigned int img, len, status;
 714                 void *pos, *sof, *eof;
 715
 716                 len = urb->iso_frame_desc[i].actual_length;
 717                 status = urb->iso_frame_desc[i].status;
 718                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 719
 720                 if (status) {
 721                         DBG(3, "Error in isochronous frame");
 722                         (*f)->state = F_ERROR;
 723                         cam->sof.bytesread = 0;
 724                         continue;
 725                 }
 726
 727                 PDBGG("Isochrnous frame: length %u, #%u i", len, i);
 728
 729 redo:
 730                 sof = sn9c102_find_sof_header(cam, pos, len);
 731                 if (likely(!sof)) {
 732                         eof = sn9c102_find_eof_header(cam, pos, len);
 733                         if ((*f)->state == F_GRABBING) {
 734 end_of_frame:
 735                                 img = len;
 736
 737                                 if (eof)
 738                                         img = (eof > pos) ? eof - pos - 1 : 0;
 739
 740                                 if ((*f)->buf.bytesused + img > imagesize) {
 741                                         u32 b;
 742                                         b = (*f)->buf.bytesused + img -
 743                                             imagesize;
 744                                         img = imagesize - (*f)->buf.bytesused;
 745                                         PDBGG("Expected EOF not found: video "
 746                                               "frame cut");
 747                                         if (eof)
 748                                                 DBG(3, "Exceeded limit: +%u "
 749                                                        "bytes", (unsigned)(b));
 750                                 }
 751
 752                                 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
 753                                        img);
 754
 755                                 if ((*f)->buf.bytesused == 0)
 756                                         do_gettimeofday(&(*f)->buf.timestamp);
 757
 758                                 (*f)->buf.bytesused += img;
 759
 760                                 if ((*f)->buf.bytesused == imagesize ||
 761                                     ((cam->sensor.pix_format.pixelformat ==
 762                                       V4L2_PIX_FMT_SN9C10X ||
 763                                       cam->sensor.pix_format.pixelformat ==
 764                                       V4L2_PIX_FMT_JPEG) && eof)) {
 765                                         u32 b;
 766
 767                                         b = (*f)->buf.bytesused;
 768                                         (*f)->state = F_DONE;
 769                                         (*f)->buf.sequence= ++cam->frame_count;
 770
 771                                         spin_lock(&cam->queue_lock);
 772                                         list_move_tail(&(*f)->frame,
 773                                                        &cam->outqueue);
 774                                         if (!list_empty(&cam->inqueue))
 775                                                 (*f) = list_entry(
 776                                                         cam->inqueue.next,
 777                                                         struct sn9c102_frame_t,
 778                                                         frame );
 779                                         else
 780                                                 (*f) = NULL;
 781                                         spin_unlock(&cam->queue_lock);
 782
 783                                         memcpy(cam->sysfs.frame_header,
 784                                                cam->sof.header, soflen);
 785
 786                                         DBG(3, "Video frame captured: %lu "
 787                                                "bytes", (unsigned long)(b));
 788
 789                                         if (!(*f))
 790                                                 goto resubmit_urb;
 791
 792                                 } else if (eof) {
 793                                         (*f)->state = F_ERROR;
 794                                         DBG(3, "Not expected EOF after %lu "
 795                                                "bytes of image data",
 796                                             (unsigned long)
 797                                             ((*f)->buf.bytesused));
 798                                 }
 799
 800                                 if (sof) /* (1) */
 801                                         goto start_of_frame;
 802
 803                         } else if (eof) {
 804                                 DBG(3, "EOF without SOF");
 805                                 continue;
 806
 807                         } else {
 808                                 PDBGG("Ignoring pointless isochronous frame");
 809                                 continue;
 810                         }
 811
 812                 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
 813 start_of_frame:
 814                         (*f)->state = F_GRABBING;
 815                         (*f)->buf.bytesused = 0;
 816                         len -= (sof - pos);
 817                         pos = sof;
 818                         if (cam->sensor.pix_format.pixelformat ==
 819                             V4L2_PIX_FMT_JPEG)
 820                                 sn9c102_write_jpegheader(cam, (*f));
 821                         DBG(3, "SOF detected: new video frame");
 822                         if (len)
 823                                 goto redo;
 824
 825                 } else if ((*f)->state == F_GRABBING) {
 826                         eof = sn9c102_find_eof_header(cam, pos, len);
 827                         if (eof && eof < sof)
 828                                 goto end_of_frame; /* (1) */
 829                         else {
 830                                 if (cam->sensor.pix_format.pixelformat ==
 831                                     V4L2_PIX_FMT_SN9C10X ||
 832                                     cam->sensor.pix_format.pixelformat ==
 833                                     V4L2_PIX_FMT_JPEG) {
 834                                         if (sof - pos >= soflen) {
 835                                                 eof = sof - soflen;
 836                                         } else { /* remove header */
 837                                                 eof = pos;
 838                                                 (*f)->buf.bytesused -=
 839                                                         (soflen - (sof - pos));
 840                                         }
 841                                         goto end_of_frame;
 842                                 } else {
 843                                         DBG(3, "SOF before expected EOF after "
 844                                                "%lu bytes of image data",
 845                                             (unsigned long)
 846                                             ((*f)->buf.bytesused));
 847                                         goto start_of_frame;
 848                                 }
 849                         }
 850                 }
 851         }
 852
 853 resubmit_urb:
 854         urb->dev = cam->usbdev;
 855         err = usb_submit_urb(urb, GFP_ATOMIC);
 856         if (err < 0 && err != -EPERM) {
 857                 cam->state |= DEV_MISCONFIGURED;
 858                 DBG(1, "usb_submit_urb() failed");
 859         }
 860
 861         wake_up_interruptible(&cam->wait_frame);
 862 }
 863
 864
 865 static int sn9c102_start_transfer(struct sn9c102_device* cam)
 866 {
 867         struct usb_device *udev = cam->usbdev;
 868         struct urb* urb;
 869         struct usb_host_interface* altsetting = usb_altnum_to_altsetting(
 870                                                     usb_ifnum_to_if(udev, 0),
 871                                                     SN9C102_ALTERNATE_SETTING);
 872         const unsigned int psz = le16_to_cpu(altsetting->
 873                                              endpoint[0].desc.wMaxPacketSize);
 874         s8 i, j;
 875         int err = 0;
 876
 877         for (i = 0; i < SN9C102_URBS; i++) {
 878                 cam->transfer_buffer[i] = kzalloc(SN9C102_ISO_PACKETS * psz,
 879                                                   GFP_KERNEL);
 880                 if (!cam->transfer_buffer[i]) {
 881                         err = -ENOMEM;
 882                         DBG(1, "Not enough memory");
 883                         goto free_buffers;
 884                 }
 885         }
 886
 887         for (i = 0; i < SN9C102_URBS; i++) {
 888                 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
 889                 cam->urb[i] = urb;
 890                 if (!urb) {
 891                         err = -ENOMEM;
 892                         DBG(1, "usb_alloc_urb() failed");
 893                         goto free_urbs;
 894                 }
 895                 urb->dev = udev;
 896                 urb->context = cam;
 897                 urb->pipe = usb_rcvisocpipe(udev, 1);
 898                 urb->transfer_flags = URB_ISO_ASAP;
 899                 urb->number_of_packets = SN9C102_ISO_PACKETS;
 900                 urb->complete = sn9c102_urb_complete;
 901                 urb->transfer_buffer = cam->transfer_buffer[i];
 902                 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
 903                 urb->interval = 1;
 904                 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
 905                         urb->iso_frame_desc[j].offset = psz * j;
 906                         urb->iso_frame_desc[j].length = psz;
 907                 }
 908         }
 909
 910         /* Enable video */
 911         if (!(cam->reg[0x01] & 0x04)) {
 912                 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
 913                 if (err) {
 914                         err = -EIO;
 915                         DBG(1, "I/O hardware error");
 916                         goto free_urbs;
 917                 }
 918         }
 919
 920         err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
 921         if (err) {
 922                 DBG(1, "usb_set_interface() failed");
 923                 goto free_urbs;
 924         }
 925
 926         cam->frame_current = NULL;
 927         cam->sof.bytesread = 0;
 928
 929         for (i = 0; i < SN9C102_URBS; i++) {
 930                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 931                 if (err) {
 932                         for (j = i-1; j >= 0; j--)
 933                                 usb_kill_urb(cam->urb[j]);
 934                         DBG(1, "usb_submit_urb() failed, error %d", err);
 935                         goto free_urbs;
 936                 }
 937         }
 938
 939         return 0;
 940
 941 free_urbs:
 942         for (i = 0; (i < SN9C102_URBS) && cam->urb[i]; i++)
 943                 usb_free_urb(cam->urb[i]);
 944
 945 free_buffers:
 946         for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
 947                 kfree(cam->transfer_buffer[i]);
 948
 949         return err;
 950 }
 951
 952
 953 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
 954 {
 955         struct usb_device *udev = cam->usbdev;
 956         s8 i;
 957         int err = 0;
 958
 959         if (cam->state & DEV_DISCONNECTED)
 960                 return 0;
 961
 962         for (i = SN9C102_URBS-1; i >= 0; i--) {
 963                 usb_kill_urb(cam->urb[i]);
 964                 usb_free_urb(cam->urb[i]);
 965                 kfree(cam->transfer_buffer[i]);
 966         }
 967
 968         err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 969         if (err)
 970                 DBG(3, "usb_set_interface() failed");
 971
 972         return err;
 973 }
 974
 975
 976 static int sn9c102_stream_interrupt(struct sn9c102_device* cam)
 977 {
 978         long timeout;
 979
 980         cam->stream = STREAM_INTERRUPT;
 981         timeout = wait_event_timeout(cam->wait_stream,
 982                                      (cam->stream == STREAM_OFF) ||
 983                                      (cam->state & DEV_DISCONNECTED),
 984                                      SN9C102_URB_TIMEOUT);
 985         if (cam->state & DEV_DISCONNECTED)
 986                 return -ENODEV;
 987         else if (cam->stream != STREAM_OFF) {
 988                 cam->state |= DEV_MISCONFIGURED;
 989                 DBG(1, "URB timeout reached. The camera is misconfigured. "
 990                        "To use it, close and open /dev/video%d again.",
 991                     cam->v4ldev->minor);
 992                 return -EIO;
 993         }
 994
 995         return 0;
 996 }
 997
 998 /*****************************************************************************/
 999
1000 #ifdef CONFIG_VIDEO_ADV_DEBUG
1001 static u16 sn9c102_strtou16(const char* buff, size_t len, ssize_t* count)
1002 {
1003         char str[7];
1004         char* endp;
1005         unsigned long val;
1006
1007         if (len < 6) {
1008                 strncpy(str, buff, len);
1009                 str[len] = '\0';
1010         } else {
1011                 strncpy(str, buff, 6);
1012                 str[6] = '\0';
1013         }
1014
1015         val = simple_strtoul(str, &endp, 0);
1016
1017         *count = 0;
1018         if (val <= 0xffff)
1019                 *count = (ssize_t)(endp - str);
1020         if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
1021                 *count += 1;
1022
1023         return (u16)val;
1024 }
1025
1026 /*
1027    NOTE 1: being inside one of the following methods implies that the v4l
1028            device exists for sure (see kobjects and reference counters)
1029    NOTE 2: buffers are PAGE_SIZE long
1030 */
1031
1032 static ssize_t sn9c102_show_reg(struct device* cd,
1033                                 struct device_attribute *attr, char* buf)
1034 {
1035         struct sn9c102_device* cam;
1036         ssize_t count;
1037
1038         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1039                 return -ERESTARTSYS;
1040
1041         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1042         if (!cam) {
1043                 mutex_unlock(&sn9c102_sysfs_lock);
1044                 return -ENODEV;
1045         }
1046
1047         count = sprintf(buf, "%u\n", cam->sysfs.reg);
1048
1049         mutex_unlock(&sn9c102_sysfs_lock);
1050
1051         return count;
1052 }
1053
1054
1055 static ssize_t
1056 sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
1057                   const char* buf, size_t len)
1058 {
1059         struct sn9c102_device* cam;
1060         u16 index;
1061         ssize_t count;
1062
1063         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1064                 return -ERESTARTSYS;
1065
1066         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1067         if (!cam) {
1068                 mutex_unlock(&sn9c102_sysfs_lock);
1069                 return -ENODEV;
1070         }
1071
1072         index = sn9c102_strtou16(buf, len, &count);
1073         if (index >= ARRAY_SIZE(cam->reg) || !count) {
1074                 mutex_unlock(&sn9c102_sysfs_lock);
1075                 return -EINVAL;
1076         }
1077
1078         cam->sysfs.reg = index;
1079
1080         DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1081         DBG(3, "Written bytes: %zd", count);
1082
1083         mutex_unlock(&sn9c102_sysfs_lock);
1084
1085         return count;
1086 }
1087
1088
1089 static ssize_t sn9c102_show_val(struct device* cd,
1090                                 struct device_attribute *attr, char* buf)
1091 {
1092         struct sn9c102_device* cam;
1093         ssize_t count;
1094         int val;
1095
1096         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1097                 return -ERESTARTSYS;
1098
1099         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1100         if (!cam) {
1101                 mutex_unlock(&sn9c102_sysfs_lock);
1102                 return -ENODEV;
1103         }
1104
1105         if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1106                 mutex_unlock(&sn9c102_sysfs_lock);
1107                 return -EIO;
1108         }
1109
1110         count = sprintf(buf, "%d\n", val);
1111
1112         DBG(3, "Read bytes: %zd, value: %d", count, val);
1113
1114         mutex_unlock(&sn9c102_sysfs_lock);
1115
1116         return count;
1117 }
1118
1119
1120 static ssize_t
1121 sn9c102_store_val(struct device* cd, struct device_attribute *attr,
1122                   const char* buf, size_t len)
1123 {
1124         struct sn9c102_device* cam;
1125         u16 value;
1126         ssize_t count;
1127         int err;
1128
1129         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1130                 return -ERESTARTSYS;
1131
1132         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1133         if (!cam) {
1134                 mutex_unlock(&sn9c102_sysfs_lock);
1135                 return -ENODEV;
1136         }
1137
1138         value = sn9c102_strtou16(buf, len, &count);
1139         if (!count) {
1140                 mutex_unlock(&sn9c102_sysfs_lock);
1141                 return -EINVAL;
1142         }
1143
1144         err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1145         if (err) {
1146                 mutex_unlock(&sn9c102_sysfs_lock);
1147                 return -EIO;
1148         }
1149
1150         DBG(2, "Written SN9C1XX reg. 0x%02X, val. 0x%02X",
1151             cam->sysfs.reg, value);
1152         DBG(3, "Written bytes: %zd", count);
1153
1154         mutex_unlock(&sn9c102_sysfs_lock);
1155
1156         return count;
1157 }
1158
1159
1160 static ssize_t sn9c102_show_i2c_reg(struct device* cd,
1161                                     struct device_attribute *attr, char* buf)
1162 {
1163         struct sn9c102_device* cam;
1164         ssize_t count;
1165
1166         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1167                 return -ERESTARTSYS;
1168
1169         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1170         if (!cam) {
1171                 mutex_unlock(&sn9c102_sysfs_lock);
1172                 return -ENODEV;
1173         }
1174
1175         count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1176
1177         DBG(3, "Read bytes: %zd", count);
1178
1179         mutex_unlock(&sn9c102_sysfs_lock);
1180
1181         return count;
1182 }
1183
1184
1185 static ssize_t
1186 sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
1187                       const char* buf, size_t len)
1188 {
1189         struct sn9c102_device* cam;
1190         u16 index;
1191         ssize_t count;
1192
1193         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1194                 return -ERESTARTSYS;
1195
1196         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1197         if (!cam) {
1198                 mutex_unlock(&sn9c102_sysfs_lock);
1199                 return -ENODEV;
1200         }
1201
1202         index = sn9c102_strtou16(buf, len, &count);
1203         if (!count) {
1204                 mutex_unlock(&sn9c102_sysfs_lock);
1205                 return -EINVAL;
1206         }
1207
1208         cam->sysfs.i2c_reg = index;
1209
1210         DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1211         DBG(3, "Written bytes: %zd", count);
1212
1213         mutex_unlock(&sn9c102_sysfs_lock);
1214
1215         return count;
1216 }
1217
1218
1219 static ssize_t sn9c102_show_i2c_val(struct device* cd,
1220                                     struct device_attribute *attr, char* buf)
1221 {
1222         struct sn9c102_device* cam;
1223         ssize_t count;
1224         int val;
1225
1226         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1227                 return -ERESTARTSYS;
1228
1229         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1230         if (!cam) {
1231                 mutex_unlock(&sn9c102_sysfs_lock);
1232                 return -ENODEV;
1233         }
1234
1235         if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1236                 mutex_unlock(&sn9c102_sysfs_lock);
1237                 return -ENOSYS;
1238         }
1239
1240         if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1241                 mutex_unlock(&sn9c102_sysfs_lock);
1242                 return -EIO;
1243         }
1244
1245         count = sprintf(buf, "%d\n", val);
1246
1247         DBG(3, "Read bytes: %zd, value: %d", count, val);
1248
1249         mutex_unlock(&sn9c102_sysfs_lock);
1250
1251         return count;
1252 }
1253
1254
1255 static ssize_t
1256 sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
1257                       const char* buf, size_t len)
1258 {
1259         struct sn9c102_device* cam;
1260         u16 value;
1261         ssize_t count;
1262         int err;
1263
1264         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1265                 return -ERESTARTSYS;
1266
1267         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1268         if (!cam) {
1269                 mutex_unlock(&sn9c102_sysfs_lock);
1270                 return -ENODEV;
1271         }
1272
1273         if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1274                 mutex_unlock(&sn9c102_sysfs_lock);
1275                 return -ENOSYS;
1276         }
1277
1278         value = sn9c102_strtou16(buf, len, &count);
1279         if (!count) {
1280                 mutex_unlock(&sn9c102_sysfs_lock);
1281                 return -EINVAL;
1282         }
1283
1284         err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1285         if (err) {
1286                 mutex_unlock(&sn9c102_sysfs_lock);
1287                 return -EIO;
1288         }
1289
1290         DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1291             cam->sysfs.i2c_reg, value);
1292         DBG(3, "Written bytes: %zd", count);
1293
1294         mutex_unlock(&sn9c102_sysfs_lock);
1295
1296         return count;
1297 }
1298
1299
1300 static ssize_t
1301 sn9c102_store_green(struct device* cd, struct device_attribute *attr,
1302                     const char* buf, size_t len)
1303 {
1304         struct sn9c102_device* cam;
1305         enum sn9c102_bridge bridge;
1306         ssize_t res = 0;
1307         u16 value;
1308         ssize_t count;
1309
1310         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1311                 return -ERESTARTSYS;
1312
1313         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1314         if (!cam) {
1315                 mutex_unlock(&sn9c102_sysfs_lock);
1316                 return -ENODEV;
1317         }
1318
1319         bridge = cam->bridge;
1320
1321         mutex_unlock(&sn9c102_sysfs_lock);
1322
1323         value = sn9c102_strtou16(buf, len, &count);
1324         if (!count)
1325                 return -EINVAL;
1326
1327         switch (bridge) {
1328         case BRIDGE_SN9C101:
1329         case BRIDGE_SN9C102:
1330                 if (value > 0x0f)
1331                         return -EINVAL;
1332                 if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
1333                         res = sn9c102_store_val(cd, attr, buf, len);
1334                 break;
1335         case BRIDGE_SN9C103:
1336         case BRIDGE_SN9C105:
1337         case BRIDGE_SN9C120:
1338                 if (value > 0x7f)
1339                         return -EINVAL;
1340                 if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
1341                         res = sn9c102_store_val(cd, attr, buf, len);
1342                 break;
1343         }
1344
1345         return res;
1346 }
1347
1348
1349 static ssize_t
1350 sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
1351                    const char* buf, size_t len)
1352 {
1353         ssize_t res = 0;
1354         u16 value;
1355         ssize_t count;
1356
1357         value = sn9c102_strtou16(buf, len, &count);
1358         if (!count || value > 0x7f)
1359                 return -EINVAL;
1360
1361         if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
1362                 res = sn9c102_store_val(cd, attr, buf, len);
1363
1364         return res;
1365 }
1366
1367
1368 static ssize_t
1369 sn9c102_store_red(struct device* cd, struct device_attribute *attr,
1370                   const char* buf, size_t len)
1371 {
1372         ssize_t res = 0;
1373         u16 value;
1374         ssize_t count;
1375
1376         value = sn9c102_strtou16(buf, len, &count);
1377         if (!count || value > 0x7f)
1378                 return -EINVAL;
1379
1380         if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
1381                 res = sn9c102_store_val(cd, attr, buf, len);
1382
1383         return res;
1384 }
1385
1386
1387 static ssize_t sn9c102_show_frame_header(struct device* cd,
1388                                          struct device_attribute *attr,
1389                                          char* buf)
1390 {
1391         struct sn9c102_device* cam;
1392         ssize_t count;
1393
1394         cam = video_get_drvdata(container_of(cd, struct video_device, dev));
1395         if (!cam)
1396                 return -ENODEV;
1397
1398         count = sizeof(cam->sysfs.frame_header);
1399         memcpy(buf, cam->sysfs.frame_header, count);
1400
1401         DBG(3, "Frame header, read bytes: %zd", count);
1402
1403         return count;
1404 }
1405
1406
1407 static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR, sn9c102_show_reg, sn9c102_store_reg);
1408 static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, sn9c102_show_val, sn9c102_store_val);
1409 static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1410                    sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1411 static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1412                    sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1413 static DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1414 static DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1415 static DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1416 static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
1417
1418
1419 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1420 {
1421         struct device *dev = &(cam->v4ldev->dev);
1422         int err = 0;
1423
1424         if ((err = device_create_file(dev, &dev_attr_reg)))
1425                 goto err_out;
1426         if ((err = device_create_file(dev, &dev_attr_val)))
1427                 goto err_reg;
1428         if ((err = device_create_file(dev, &dev_attr_frame_header)))
1429                 goto err_val;
1430
1431         if (cam->sensor.sysfs_ops) {
1432                 if ((err = device_create_file(dev, &dev_attr_i2c_reg)))
1433                         goto err_frame_header;
1434                 if ((err = device_create_file(dev, &dev_attr_i2c_val)))
1435                         goto err_i2c_reg;
1436         }
1437
1438         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1439                 if ((err = device_create_file(dev, &dev_attr_green)))
1440                         goto err_i2c_val;
1441         } else {
1442                 if ((err = device_create_file(dev, &dev_attr_blue)))
1443                         goto err_i2c_val;
1444                 if ((err = device_create_file(dev, &dev_attr_red)))
1445                         goto err_blue;
1446         }
1447
1448         return 0;
1449
1450 err_blue:
1451         device_remove_file(dev, &dev_attr_blue);
1452 err_i2c_val:
1453         if (cam->sensor.sysfs_ops)
1454                 device_remove_file(dev, &dev_attr_i2c_val);
1455 err_i2c_reg:
1456         if (cam->sensor.sysfs_ops)
1457                 device_remove_file(dev, &dev_attr_i2c_reg);
1458 err_frame_header:
1459         device_remove_file(dev, &dev_attr_frame_header);
1460 err_val:
1461         device_remove_file(dev, &dev_attr_val);
1462 err_reg:
1463         device_remove_file(dev, &dev_attr_reg);
1464 err_out:
1465         return err;
1466 }
1467 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1468
1469 /*****************************************************************************/
1470
1471 static int
1472 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1473 {
1474         int err = 0;
1475
1476         if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
1477             pix->pixelformat == V4L2_PIX_FMT_JPEG) {
1478                 switch (cam->bridge) {
1479                 case BRIDGE_SN9C101:
1480                 case BRIDGE_SN9C102:
1481                 case BRIDGE_SN9C103:
1482                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1483                                                  0x18);
1484                         break;
1485                 case BRIDGE_SN9C105:
1486                 case BRIDGE_SN9C120:
1487                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1488                                                  0x18);
1489                         break;
1490                 }
1491         } else {
1492                 switch (cam->bridge) {
1493                 case BRIDGE_SN9C101:
1494                 case BRIDGE_SN9C102:
1495                 case BRIDGE_SN9C103:
1496                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1497                                                  0x18);
1498                         break;
1499                 case BRIDGE_SN9C105:
1500                 case BRIDGE_SN9C120:
1501                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1502                                                  0x18);
1503                         break;
1504                 }
1505         }
1506
1507         return err ? -EIO : 0;
1508 }
1509
1510
1511 static int
1512 sn9c102_set_compression(struct sn9c102_device* cam,
1513                         struct v4l2_jpegcompression* compression)
1514 {
1515         int i, err = 0;
1516
1517         switch (cam->bridge) {
1518         case BRIDGE_SN9C101:
1519         case BRIDGE_SN9C102:
1520         case BRIDGE_SN9C103:
1521                 if (compression->quality == 0)
1522                         err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01,
1523                                                  0x17);
1524                 else if (compression->quality == 1)
1525                         err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
1526                                                  0x17);
1527                 break;
1528         case BRIDGE_SN9C105:
1529         case BRIDGE_SN9C120:
1530                 if (compression->quality == 0) {
1531                         for (i = 0; i <= 63; i++) {
1532                                 err += sn9c102_write_reg(cam,
1533                                                          SN9C102_Y_QTABLE1[i],
1534                                                          0x100 + i);
1535                                 err += sn9c102_write_reg(cam,
1536                                                          SN9C102_UV_QTABLE1[i],
1537                                                          0x140 + i);
1538                         }
1539                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1540                                                  0x18);
1541                 } else if (compression->quality == 1) {
1542                         for (i = 0; i <= 63; i++) {
1543                                 err += sn9c102_write_reg(cam,
1544                                                          SN9C102_Y_QTABLE1[i],
1545                                                          0x100 + i);
1546                                 err += sn9c102_write_reg(cam,
1547                                                          SN9C102_UV_QTABLE1[i],
1548                                                          0x140 + i);
1549                         }
1550                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1551                                                  0x18);
1552                 }
1553                 break;
1554         }
1555
1556         return err ? -EIO : 0;
1557 }
1558
1559
1560 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1561 {
1562         u8 r = 0;
1563         int err = 0;
1564
1565         if (scale == 1)
1566                 r = cam->reg[0x18] & 0xcf;
1567         else if (scale == 2) {
1568                 r = cam->reg[0x18] & 0xcf;
1569                 r |= 0x10;
1570         } else if (scale == 4)
1571                 r = cam->reg[0x18] | 0x20;
1572
1573         err += sn9c102_write_reg(cam, r, 0x18);
1574         if (err)
1575                 return -EIO;
1576
1577         PDBGG("Scaling factor: %u", scale);
1578
1579         return 0;
1580 }
1581
1582
1583 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1584 {
1585         struct sn9c102_sensor* s = &cam->sensor;
1586         u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1587            v_start = (u8)(rect->top - s->cropcap.bounds.top),
1588            h_size = (u8)(rect->width / 16),
1589            v_size = (u8)(rect->height / 16);
1590         int err = 0;
1591
1592         err += sn9c102_write_reg(cam, h_start, 0x12);
1593         err += sn9c102_write_reg(cam, v_start, 0x13);
1594         err += sn9c102_write_reg(cam, h_size, 0x15);
1595         err += sn9c102_write_reg(cam, v_size, 0x16);
1596         if (err)
1597                 return -EIO;
1598
1599         PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1600               "%u %u %u %u", h_start, v_start, h_size, v_size);
1601
1602         return 0;
1603 }
1604
1605
1606 static int sn9c102_init(struct sn9c102_device* cam)
1607 {
1608         struct sn9c102_sensor* s = &cam->sensor;
1609         struct v4l2_control ctrl;
1610         struct v4l2_queryctrl *qctrl;
1611         struct v4l2_rect* rect;
1612         u8 i = 0;
1613         int err = 0;
1614
1615         if (!(cam->state & DEV_INITIALIZED)) {
1616                 mutex_init(&cam->open_mutex);
1617                 init_waitqueue_head(&cam->wait_open);
1618                 qctrl = s->qctrl;
1619                 rect = &(s->cropcap.defrect);
1620         } else { /* use current values */
1621                 qctrl = s->_qctrl;
1622                 rect = &(s->_rect);
1623         }
1624
1625         err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1626         err += sn9c102_set_crop(cam, rect);
1627         if (err)
1628                 return err;
1629
1630         if (s->init) {
1631                 err = s->init(cam);
1632                 if (err) {
1633                         DBG(3, "Sensor initialization failed");
1634                         return err;
1635                 }
1636         }
1637
1638         if (!(cam->state & DEV_INITIALIZED))
1639                 if (cam->bridge == BRIDGE_SN9C101 ||
1640                     cam->bridge == BRIDGE_SN9C102 ||
1641                     cam->bridge == BRIDGE_SN9C103) {
1642                         if (s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1643                                 s->pix_format.pixelformat= V4L2_PIX_FMT_SBGGR8;
1644                         cam->compression.quality =  cam->reg[0x17] & 0x01 ?
1645                                                     0 : 1;
1646                 } else {
1647                         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1648                                 s->pix_format.pixelformat = V4L2_PIX_FMT_JPEG;
1649                         cam->compression.quality =  cam->reg[0x18] & 0x40 ?
1650                                                     0 : 1;
1651                         err += sn9c102_set_compression(cam, &cam->compression);
1652                 }
1653         else
1654                 err += sn9c102_set_compression(cam, &cam->compression);
1655         err += sn9c102_set_pix_format(cam, &s->pix_format);
1656         if (s->set_pix_format)
1657                 err += s->set_pix_format(cam, &s->pix_format);
1658         if (err)
1659                 return err;
1660
1661         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
1662             s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1663                 DBG(3, "Compressed video format is active, quality %d",
1664                     cam->compression.quality);
1665         else
1666                 DBG(3, "Uncompressed video format is active");
1667
1668         if (s->set_crop)
1669                 if ((err = s->set_crop(cam, rect))) {
1670                         DBG(3, "set_crop() failed");
1671                         return err;
1672                 }
1673
1674         if (s->set_ctrl) {
1675                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1676                         if (s->qctrl[i].id != 0 &&
1677                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1678                                 ctrl.id = s->qctrl[i].id;
1679                                 ctrl.value = qctrl[i].default_value;
1680                                 err = s->set_ctrl(cam, &ctrl);
1681                                 if (err) {
1682                                         DBG(3, "Set %s control failed",
1683                                             s->qctrl[i].name);
1684                                         return err;
1685                                 }
1686                                 DBG(3, "Image sensor supports '%s' control",
1687                                     s->qctrl[i].name);
1688                         }
1689         }
1690
1691         if (!(cam->state & DEV_INITIALIZED)) {
1692                 mutex_init(&cam->fileop_mutex);
1693                 spin_lock_init(&cam->queue_lock);
1694                 init_waitqueue_head(&cam->wait_frame);
1695                 init_waitqueue_head(&cam->wait_stream);
1696                 cam->nreadbuffers = 2;
1697                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1698                 memcpy(&(s->_rect), &(s->cropcap.defrect),
1699                        sizeof(struct v4l2_rect));
1700                 cam->state |= DEV_INITIALIZED;
1701         }
1702
1703         DBG(2, "Initialization succeeded");
1704         return 0;
1705 }
1706
1707 /*****************************************************************************/
1708
1709 static void sn9c102_release_resources(struct kref *kref)
1710 {
1711         struct sn9c102_device *cam;
1712
1713         mutex_lock(&sn9c102_sysfs_lock);
1714
1715         cam = container_of(kref, struct sn9c102_device, kref);
1716
1717         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
1718         video_set_drvdata(cam->v4ldev, NULL);
1719         video_unregister_device(cam->v4ldev);
1720         usb_put_dev(cam->usbdev);
1721         kfree(cam->control_buffer);
1722         kfree(cam);
1723
1724         mutex_unlock(&sn9c102_sysfs_lock);
1725
1726 }
1727
1728
1729 static int sn9c102_open(struct inode* inode, struct file* filp)
1730 {
1731         struct sn9c102_device* cam;
1732         int err = 0;
1733
1734         /*
1735            A read_trylock() in open() is the only safe way to prevent race
1736            conditions with disconnect(), one close() and multiple (not
1737            necessarily simultaneous) attempts to open(). For example, it
1738            prevents from waiting for a second access, while the device
1739            structure is being deallocated, after a possible disconnect() and
1740            during a following close() holding the write lock: given that, after
1741            this deallocation, no access will be possible anymore, using the
1742            non-trylock version would have let open() gain the access to the
1743            device structure improperly.
1744            For this reason the lock must also not be per-device.
1745         */
1746         if (!down_read_trylock(&sn9c102_dev_lock))
1747                 return -ERESTARTSYS;
1748
1749         cam = video_get_drvdata(video_devdata(filp));
1750
1751         if (wait_for_completion_interruptible(&cam->probe)) {
1752                 up_read(&sn9c102_dev_lock);
1753                 return -ERESTARTSYS;
1754         }
1755
1756         kref_get(&cam->kref);
1757
1758         /*
1759             Make sure to isolate all the simultaneous opens.
1760         */
1761         if (mutex_lock_interruptible(&cam->open_mutex)) {
1762                 kref_put(&cam->kref, sn9c102_release_resources);
1763                 up_read(&sn9c102_dev_lock);
1764                 return -ERESTARTSYS;
1765         }
1766
1767         if (cam->state & DEV_DISCONNECTED) {
1768                 DBG(1, "Device not present");
1769                 err = -ENODEV;
1770                 goto out;
1771         }
1772
1773         if (cam->users) {
1774                 DBG(2, "Device /dev/video%d is already in use",
1775                        cam->v4ldev->minor);
1776                 DBG(3, "Simultaneous opens are not supported");
1777                 /*
1778                    open() must follow the open flags and should block
1779                    eventually while the device is in use.
1780                 */
1781                 if ((filp->f_flags & O_NONBLOCK) ||
1782                     (filp->f_flags & O_NDELAY)) {
1783                         err = -EWOULDBLOCK;
1784                         goto out;
1785                 }
1786                 DBG(2, "A blocking open() has been requested. Wait for the "
1787                        "device to be released...");
1788                 up_read(&sn9c102_dev_lock);
1789                 /*
1790                    We will not release the "open_mutex" lock, so that only one
1791                    process can be in the wait queue below. This way the process
1792                    will be sleeping while holding the lock, without loosing its
1793                    priority after any wake_up().
1794                 */
1795                 err = wait_event_interruptible_exclusive(cam->wait_open,
1796                                                 (cam->state & DEV_DISCONNECTED)
1797                                                          || !cam->users);
1798                 down_read(&sn9c102_dev_lock);
1799                 if (err)
1800                         goto out;
1801                 if (cam->state & DEV_DISCONNECTED) {
1802                         err = -ENODEV;
1803                         goto out;
1804                 }
1805         }
1806
1807         if (cam->state & DEV_MISCONFIGURED) {
1808                 err = sn9c102_init(cam);
1809                 if (err) {
1810                         DBG(1, "Initialization failed again. "
1811                                "I will retry on next open().");
1812                         goto out;
1813                 }
1814                 cam->state &= ~DEV_MISCONFIGURED;
1815         }
1816
1817         if ((err = sn9c102_start_transfer(cam)))
1818                 goto out;
1819
1820         filp->private_data = cam;
1821         cam->users++;
1822         cam->io = IO_NONE;
1823         cam->stream = STREAM_OFF;
1824         cam->nbuffers = 0;
1825         cam->frame_count = 0;
1826         sn9c102_empty_framequeues(cam);
1827
1828         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);
1829
1830 out:
1831         mutex_unlock(&cam->open_mutex);
1832         if (err)
1833                 kref_put(&cam->kref, sn9c102_release_resources);
1834
1835         up_read(&sn9c102_dev_lock);
1836         return err;
1837 }
1838
1839
1840 static int sn9c102_release(struct inode* inode, struct file* filp)
1841 {
1842         struct sn9c102_device* cam;
1843
1844         down_write(&sn9c102_dev_lock);
1845
1846         cam = video_get_drvdata(video_devdata(filp));
1847
1848         sn9c102_stop_transfer(cam);
1849         sn9c102_release_buffers(cam);
1850         cam->users--;
1851         wake_up_interruptible_nr(&cam->wait_open, 1);
1852
1853         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);
1854
1855         kref_put(&cam->kref, sn9c102_release_resources);
1856
1857         up_write(&sn9c102_dev_lock);
1858
1859         return 0;
1860 }
1861
1862
1863 static ssize_t
1864 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1865 {
1866         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1867         struct sn9c102_frame_t* f, * i;
1868         unsigned long lock_flags;
1869         long timeout;
1870         int err = 0;
1871
1872         if (mutex_lock_interruptible(&cam->fileop_mutex))
1873                 return -ERESTARTSYS;
1874
1875         if (cam->state & DEV_DISCONNECTED) {
1876                 DBG(1, "Device not present");
1877                 mutex_unlock(&cam->fileop_mutex);
1878                 return -ENODEV;
1879         }
1880
1881         if (cam->state & DEV_MISCONFIGURED) {
1882                 DBG(1, "The camera is misconfigured. Close and open it "
1883                        "again.");
1884                 mutex_unlock(&cam->fileop_mutex);
1885                 return -EIO;
1886         }
1887
1888         if (cam->io == IO_MMAP) {
1889                 DBG(3, "Close and open the device again to choose "
1890                        "the read method");
1891                 mutex_unlock(&cam->fileop_mutex);
1892                 return -EBUSY;
1893         }
1894
1895         if (cam->io == IO_NONE) {
1896                 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1897                         DBG(1, "read() failed, not enough memory");
1898                         mutex_unlock(&cam->fileop_mutex);
1899                         return -ENOMEM;
1900                 }
1901                 cam->io = IO_READ;
1902                 cam->stream = STREAM_ON;
1903         }
1904
1905         if (list_empty(&cam->inqueue)) {
1906                 if (!list_empty(&cam->outqueue))
1907                         sn9c102_empty_framequeues(cam);
1908                 sn9c102_queue_unusedframes(cam);
1909         }
1910
1911         if (!count) {
1912                 mutex_unlock(&cam->fileop_mutex);
1913                 return 0;
1914         }
1915
1916         if (list_empty(&cam->outqueue)) {
1917                 if (filp->f_flags & O_NONBLOCK) {
1918                         mutex_unlock(&cam->fileop_mutex);
1919                         return -EAGAIN;
1920                 }
1921                 if (!cam->module_param.frame_timeout) {
1922                         err = wait_event_interruptible
1923                               ( cam->wait_frame,
1924                                 (!list_empty(&cam->outqueue)) ||
1925                                 (cam->state & DEV_DISCONNECTED) ||
1926                                 (cam->state & DEV_MISCONFIGURED) );
1927                         if (err) {
1928                                 mutex_unlock(&cam->fileop_mutex);
1929                                 return err;
1930                         }
1931                 } else {
1932                         timeout = wait_event_interruptible_timeout
1933                                   ( cam->wait_frame,
1934                                     (!list_empty(&cam->outqueue)) ||
1935                                     (cam->state & DEV_DISCONNECTED) ||
1936                                     (cam->state & DEV_MISCONFIGURED),
1937                                     cam->module_param.frame_timeout *
1938                                     1000 * msecs_to_jiffies(1) );
1939                         if (timeout < 0) {
1940                                 mutex_unlock(&cam->fileop_mutex);
1941                                 return timeout;
1942                         } else if (timeout == 0 &&
1943                                    !(cam->state & DEV_DISCONNECTED)) {
1944                                 DBG(1, "Video frame timeout elapsed");
1945                                 mutex_unlock(&cam->fileop_mutex);
1946                                 return -EIO;
1947                         }
1948                 }
1949                 if (cam->state & DEV_DISCONNECTED) {
1950                         mutex_unlock(&cam->fileop_mutex);
1951                         return -ENODEV;
1952                 }
1953                 if (cam->state & DEV_MISCONFIGURED) {
1954                         mutex_unlock(&cam->fileop_mutex);
1955                         return -EIO;
1956                 }
1957         }
1958
1959         f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1960
1961         if (count > f->buf.bytesused)
1962                 count = f->buf.bytesused;
1963
1964         if (copy_to_user(buf, f->bufmem, count)) {
1965                 err = -EFAULT;
1966                 goto exit;
1967         }
1968         *f_pos += count;
1969
1970 exit:
1971         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1972         list_for_each_entry(i, &cam->outqueue, frame)
1973                 i->state = F_UNUSED;
1974         INIT_LIST_HEAD(&cam->outqueue);
1975         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1976
1977         sn9c102_queue_unusedframes(cam);
1978
1979         PDBGG("Frame #%lu, bytes read: %zu",
1980               (unsigned long)f->buf.index, count);
1981
1982         mutex_unlock(&cam->fileop_mutex);
1983
1984         return count;
1985 }
1986
1987
1988 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1989 {
1990         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1991         struct sn9c102_frame_t* f;
1992         unsigned long lock_flags;
1993         unsigned int mask = 0;
1994
1995         if (mutex_lock_interruptible(&cam->fileop_mutex))
1996                 return POLLERR;
1997
1998         if (cam->state & DEV_DISCONNECTED) {
1999                 DBG(1, "Device not present");
2000                 goto error;
2001         }
2002
2003         if (cam->state & DEV_MISCONFIGURED) {
2004                 DBG(1, "The camera is misconfigured. Close and open it "
2005                        "again.");
2006                 goto error;
2007         }
2008
2009         if (cam->io == IO_NONE) {
2010                 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
2011                                              IO_READ)) {
2012                         DBG(1, "poll() failed, not enough memory");
2013                         goto error;
2014                 }
2015                 cam->io = IO_READ;
2016                 cam->stream = STREAM_ON;
2017         }
2018
2019         if (cam->io == IO_READ) {
2020                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2021                 list_for_each_entry(f, &cam->outqueue, frame)
2022                         f->state = F_UNUSED;
2023                 INIT_LIST_HEAD(&cam->outqueue);
2024                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2025                 sn9c102_queue_unusedframes(cam);
2026         }
2027
2028         poll_wait(filp, &cam->wait_frame, wait);
2029
2030         if (!list_empty(&cam->outqueue))
2031                 mask |= POLLIN | POLLRDNORM;
2032
2033         mutex_unlock(&cam->fileop_mutex);
2034
2035         return mask;
2036
2037 error:
2038         mutex_unlock(&cam->fileop_mutex);
2039         return POLLERR;
2040 }
2041
2042
2043 static void sn9c102_vm_open(struct vm_area_struct* vma)
2044 {
2045         struct sn9c102_frame_t* f = vma->vm_private_data;
2046         f->vma_use_count++;
2047 }
2048
2049
2050 static void sn9c102_vm_close(struct vm_area_struct* vma)
2051 {
2052         /* NOTE: buffers are not freed here */
2053         struct sn9c102_frame_t* f = vma->vm_private_data;
2054         f->vma_use_count--;
2055 }
2056
2057
2058 static struct vm_operations_struct sn9c102_vm_ops = {
2059         .open = sn9c102_vm_open,
2060         .close = sn9c102_vm_close,
2061 };
2062
2063
2064 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
2065 {
2066         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2067         unsigned long size = vma->vm_end - vma->vm_start,
2068                       start = vma->vm_start;
2069         void *pos;
2070         u32 i;
2071
2072         if (mutex_lock_interruptible(&cam->fileop_mutex))
2073                 return -ERESTARTSYS;
2074
2075         if (cam->state & DEV_DISCONNECTED) {
2076                 DBG(1, "Device not present");
2077                 mutex_unlock(&cam->fileop_mutex);
2078                 return -ENODEV;
2079         }
2080
2081         if (cam->state & DEV_MISCONFIGURED) {
2082                 DBG(1, "The camera is misconfigured. Close and open it "
2083                        "again.");
2084                 mutex_unlock(&cam->fileop_mutex);
2085                 return -EIO;
2086         }
2087
2088         if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
2089                 mutex_unlock(&cam->fileop_mutex);
2090                 return -EACCES;
2091         }
2092
2093         if (cam->io != IO_MMAP ||
2094             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2095                 mutex_unlock(&cam->fileop_mutex);
2096                 return -EINVAL;
2097         }
2098
2099         for (i = 0; i < cam->nbuffers; i++) {
2100                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2101                         break;
2102         }
2103         if (i == cam->nbuffers) {
2104                 mutex_unlock(&cam->fileop_mutex);
2105                 return -EINVAL;
2106         }
2107
2108         vma->vm_flags |= VM_IO;
2109         vma->vm_flags |= VM_RESERVED;
2110
2111         pos = cam->frame[i].bufmem;
2112         while (size > 0) { /* size is page-aligned */
2113                 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
2114                         mutex_unlock(&cam->fileop_mutex);
2115                         return -EAGAIN;
2116                 }
2117                 start += PAGE_SIZE;
2118                 pos += PAGE_SIZE;
2119                 size -= PAGE_SIZE;
2120         }
2121
2122         vma->vm_ops = &sn9c102_vm_ops;
2123         vma->vm_private_data = &cam->frame[i];
2124         sn9c102_vm_open(vma);
2125
2126         mutex_unlock(&cam->fileop_mutex);
2127
2128         return 0;
2129 }
2130
2131 /*****************************************************************************/
2132
2133 static int
2134 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2135 {
2136         struct v4l2_capability cap = {
2137                 .driver = "sn9c102",
2138                 .version = SN9C102_MODULE_VERSION_CODE,
2139                 .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2140                                 V4L2_CAP_STREAMING,
2141         };
2142
2143         strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2144         if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2145                 strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
2146                         sizeof(cap.bus_info));
2147
2148         if (copy_to_user(arg, &cap, sizeof(cap)))
2149                 return -EFAULT;
2150
2151         return 0;
2152 }
2153
2154
2155 static int
2156 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2157 {
2158         struct v4l2_input i;
2159
2160         if (copy_from_user(&i, arg, sizeof(i)))
2161                 return -EFAULT;
2162
2163         if (i.index)
2164                 return -EINVAL;
2165
2166         memset(&i, 0, sizeof(i));
2167         strcpy(i.name, "Camera");
2168         i.type = V4L2_INPUT_TYPE_CAMERA;
2169
2170         if (copy_to_user(arg, &i, sizeof(i)))
2171                 return -EFAULT;
2172
2173         return 0;
2174 }
2175
2176
2177 static int
2178 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2179 {
2180         int index = 0;
2181
2182         if (copy_to_user(arg, &index, sizeof(index)))
2183                 return -EFAULT;
2184
2185         return 0;
2186 }
2187
2188
2189 static int
2190 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2191 {
2192         int index;
2193
2194         if (copy_from_user(&index, arg, sizeof(index)))
2195                 return -EFAULT;
2196
2197         if (index != 0)
2198                 return -EINVAL;
2199
2200         return 0;
2201 }
2202
2203
2204 static int
2205 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2206 {
2207         struct sn9c102_sensor* s = &cam->sensor;
2208         struct v4l2_queryctrl qc;
2209         u8 i;
2210
2211         if (copy_from_user(&qc, arg, sizeof(qc)))
2212                 return -EFAULT;
2213
2214         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2215                 if (qc.id && qc.id == s->qctrl[i].id) {
2216                         memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
2217                         if (copy_to_user(arg, &qc, sizeof(qc)))
2218                                 return -EFAULT;
2219                         return 0;
2220                 }
2221
2222         return -EINVAL;
2223 }
2224
2225
2226 static int
2227 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2228 {
2229         struct sn9c102_sensor* s = &cam->sensor;
2230         struct v4l2_control ctrl;
2231         int err = 0;
2232         u8 i;
2233
2234         if (!s->get_ctrl && !s->set_ctrl)
2235                 return -EINVAL;
2236
2237         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2238                 return -EFAULT;
2239
2240         if (!s->get_ctrl) {
2241                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2242                         if (ctrl.id && ctrl.id == s->qctrl[i].id) {
2243                                 ctrl.value = s->_qctrl[i].default_value;
2244                                 goto exit;
2245                         }
2246                 return -EINVAL;
2247         } else
2248                 err = s->get_ctrl(cam, &ctrl);
2249
2250 exit:
2251         if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
2252                 return -EFAULT;
2253
2254         PDBGG("VIDIOC_G_CTRL: id %lu, value %lu",
2255               (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2256
2257         return err;
2258 }
2259
2260
2261 static int
2262 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2263 {
2264         struct sn9c102_sensor* s = &cam->sensor;
2265         struct v4l2_control ctrl;
2266         u8 i;
2267         int err = 0;
2268
2269         if (!s->set_ctrl)
2270                 return -EINVAL;
2271
2272         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2273                 return -EFAULT;
2274
2275         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2276                 if (ctrl.id == s->qctrl[i].id) {
2277                         if (s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)
2278                                 return -EINVAL;
2279                         if (ctrl.value < s->qctrl[i].minimum ||
2280                             ctrl.value > s->qctrl[i].maximum)
2281                                 return -ERANGE;
2282                         ctrl.value -= ctrl.value % s->qctrl[i].step;
2283                         break;
2284                 }
2285
2286         if ((err = s->set_ctrl(cam, &ctrl)))
2287                 return err;
2288
2289         s->_qctrl[i].default_value = ctrl.value;
2290
2291         PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
2292               (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2293
2294         return 0;
2295 }
2296
2297
2298 static int
2299 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2300 {
2301         struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2302
2303         cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2304         cc->pixelaspect.numerator = 1;
2305         cc->pixelaspect.denominator = 1;
2306
2307         if (copy_to_user(arg, cc, sizeof(*cc)))
2308                 return -EFAULT;
2309
2310         return 0;
2311 }
2312
2313
2314 static int
2315 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2316 {
2317         struct sn9c102_sensor* s = &cam->sensor;
2318         struct v4l2_crop crop = {
2319                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2320         };
2321
2322         memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
2323
2324         if (copy_to_user(arg, &crop, sizeof(crop)))
2325                 return -EFAULT;
2326
2327         return 0;
2328 }
2329
2330
2331 static int
2332 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2333 {
2334         struct sn9c102_sensor* s = &cam->sensor;
2335         struct v4l2_crop crop;
2336         struct v4l2_rect* rect;
2337         struct v4l2_rect* bounds = &(s->cropcap.bounds);
2338         struct v4l2_pix_format* pix_format = &(s->pix_format);
2339         u8 scale;
2340         const enum sn9c102_stream_state stream = cam->stream;
2341         const u32 nbuffers = cam->nbuffers;
2342         u32 i;
2343         int err = 0;
2344
2345         if (copy_from_user(&crop, arg, sizeof(crop)))
2346                 return -EFAULT;
2347
2348         rect = &(crop.c);
2349
2350         if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2351                 return -EINVAL;
2352
2353         if (cam->module_param.force_munmap)
2354                 for (i = 0; i < cam->nbuffers; i++)
2355                         if (cam->frame[i].vma_use_count) {
2356                                 DBG(3, "VIDIOC_S_CROP failed. "
2357                                        "Unmap the buffers first.");
2358                                 return -EBUSY;
2359                         }
2360
2361         /* Preserve R,G or B origin */
2362         rect->left = (s->_rect.left & 1L) ? rect->left | 1L : rect->left & ~1L;
2363         rect->top = (s->_rect.top & 1L) ? rect->top | 1L : rect->top & ~1L;
2364
2365         if (rect->width < 16)
2366                 rect->width = 16;
2367         if (rect->height < 16)
2368                 rect->height = 16;
2369         if (rect->width > bounds->width)
2370                 rect->width = bounds->width;
2371         if (rect->height > bounds->height)
2372                 rect->height = bounds->height;
2373         if (rect->left < bounds->left)
2374                 rect->left = bounds->left;
2375         if (rect->top < bounds->top)
2376                 rect->top = bounds->top;
2377         if (rect->left + rect->width > bounds->left + bounds->width)
2378                 rect->left = bounds->left+bounds->width - rect->width;
2379         if (rect->top + rect->height > bounds->top + bounds->height)
2380                 rect->top = bounds->top+bounds->height - rect->height;
2381
2382         rect->width &= ~15L;
2383         rect->height &= ~15L;
2384
2385         if (SN9C102_PRESERVE_IMGSCALE) {
2386                 /* Calculate the actual scaling factor */
2387                 u32 a, b;
2388                 a = rect->width * rect->height;
2389                 b = pix_format->width * pix_format->height;
2390                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2391         } else
2392                 scale = 1;
2393
2394         if (cam->stream == STREAM_ON)
2395                 if ((err = sn9c102_stream_interrupt(cam)))
2396                         return err;
2397
2398         if (copy_to_user(arg, &crop, sizeof(crop))) {
2399                 cam->stream = stream;
2400                 return -EFAULT;
2401         }
2402
2403         if (cam->module_param.force_munmap || cam->io == IO_READ)
2404                 sn9c102_release_buffers(cam);
2405
2406         err = sn9c102_set_crop(cam, rect);
2407         if (s->set_crop)
2408                 err += s->set_crop(cam, rect);
2409         err += sn9c102_set_scale(cam, scale);
2410
2411         if (err) { /* atomic, no rollback in ioctl() */
2412                 cam->state |= DEV_MISCONFIGURED;
2413                 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
2414                        "use the camera, close and open /dev/video%d again.",
2415                     cam->v4ldev->minor);
2416                 return -EIO;
2417         }
2418
2419         s->pix_format.width = rect->width/scale;
2420         s->pix_format.height = rect->height/scale;
2421         memcpy(&(s->_rect), rect, sizeof(*rect));
2422
2423         if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2424             nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2425                 cam->state |= DEV_MISCONFIGURED;
2426                 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
2427                        "use the camera, close and open /dev/video%d again.",
2428                     cam->v4ldev->minor);
2429                 return -ENOMEM;
2430         }
2431
2432         if (cam->io == IO_READ)
2433                 sn9c102_empty_framequeues(cam);
2434         else if (cam->module_param.force_munmap)
2435                 sn9c102_requeue_outqueue(cam);
2436
2437         cam->stream = stream;
2438
2439         return 0;
2440 }
2441
2442
2443 static int
2444 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2445 {
2446         struct v4l2_frmsizeenum frmsize;
2447
2448         if (copy_from_user(&frmsize, arg, sizeof(frmsize)))
2449                 return -EFAULT;
2450
2451         if (frmsize.index != 0)
2452                 return -EINVAL;
2453
2454         switch (cam->bridge) {
2455         case BRIDGE_SN9C101:
2456         case BRIDGE_SN9C102:
2457         case BRIDGE_SN9C103:
2458                 if (frmsize.pixel_format != V4L2_PIX_FMT_SN9C10X &&
2459                     frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2460                         return -EINVAL;
2461         case BRIDGE_SN9C105:
2462         case BRIDGE_SN9C120:
2463                 if (frmsize.pixel_format != V4L2_PIX_FMT_JPEG &&
2464                     frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2465                         return -EINVAL;
2466         }
2467
2468         frmsize.type = V4L2_FRMSIZE_TYPE_STEPWISE;
2469         frmsize.stepwise.min_width = frmsize.stepwise.step_width = 16;
2470         frmsize.stepwise.min_height = frmsize.stepwise.step_height = 16;
2471         frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2472         frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2473         memset(&frmsize.reserved, 0, sizeof(frmsize.reserved));
2474
2475         if (copy_to_user(arg, &frmsize, sizeof(frmsize)))
2476                 return -EFAULT;
2477
2478         return 0;
2479 }
2480
2481
2482 static int
2483 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2484 {
2485         struct v4l2_fmtdesc fmtd;
2486
2487         if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2488                 return -EFAULT;
2489
2490         if (fmtd.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2491                 return -EINVAL;
2492
2493         if (fmtd.index == 0) {
2494                 strcpy(fmtd.description, "bayer rgb");
2495                 fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2496         } else if (fmtd.index == 1) {
2497                 switch (cam->bridge) {
2498                 case BRIDGE_SN9C101:
2499                 case BRIDGE_SN9C102:
2500                 case BRIDGE_SN9C103:
2501                         strcpy(fmtd.description, "compressed");
2502                         fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2503                         break;
2504                 case BRIDGE_SN9C105:
2505                 case BRIDGE_SN9C120:
2506                         strcpy(fmtd.description, "JPEG");
2507                         fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
2508                         break;
2509                 }
2510                 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2511         } else
2512                 return -EINVAL;
2513
2514         fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2515         memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2516
2517         if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2518                 return -EFAULT;
2519
2520         return 0;
2521 }
2522
2523
2524 static int
2525 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2526 {
2527         struct v4l2_format format;
2528         struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2529
2530         if (copy_from_user(&format, arg, sizeof(format)))
2531                 return -EFAULT;
2532
2533         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2534                 return -EINVAL;
2535
2536         pfmt->colorspace = (pfmt->pixelformat == V4L2_PIX_FMT_JPEG) ?
2537                            V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2538         pfmt->bytesperline = (pfmt->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2539                               pfmt->pixelformat == V4L2_PIX_FMT_JPEG)
2540                              ? 0 : (pfmt->width * pfmt->priv) / 8;
2541         pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2542         pfmt->field = V4L2_FIELD_NONE;
2543         memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2544
2545         if (copy_to_user(arg, &format, sizeof(format)))
2546                 return -EFAULT;
2547
2548         return 0;
2549 }
2550
2551
2552 static int
2553 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2554                          void __user * arg)
2555 {
2556         struct sn9c102_sensor* s = &cam->sensor;
2557         struct v4l2_format format;
2558         struct v4l2_pix_format* pix;
2559         struct v4l2_pix_format* pfmt = &(s->pix_format);
2560         struct v4l2_rect* bounds = &(s->cropcap.bounds);
2561         struct v4l2_rect rect;
2562         u8 scale;
2563         const enum sn9c102_stream_state stream = cam->stream;
2564         const u32 nbuffers = cam->nbuffers;
2565         u32 i;
2566         int err = 0;
2567
2568         if (copy_from_user(&format, arg, sizeof(format)))
2569                 return -EFAULT;
2570
2571         pix = &(format.fmt.pix);
2572
2573         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2574                 return -EINVAL;
2575
2576         memcpy(&rect, &(s->_rect), sizeof(rect));
2577
2578         { /* calculate the actual scaling factor */
2579                 u32 a, b;
2580                 a = rect.width * rect.height;
2581                 b = pix->width * pix->height;
2582                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2583         }
2584
2585         rect.width = scale * pix->width;
2586         rect.height = scale * pix->height;
2587
2588         if (rect.width < 16)
2589                 rect.width = 16;
2590         if (rect.height < 16)
2591                 rect.height = 16;
2592         if (rect.width > bounds->left + bounds->width - rect.left)
2593                 rect.width = bounds->left + bounds->width - rect.left;
2594         if (rect.height > bounds->top + bounds->height - rect.top)
2595                 rect.height = bounds->top + bounds->height - rect.top;
2596
2597         rect.width &= ~15L;
2598         rect.height &= ~15L;
2599
2600         { /* adjust the scaling factor */
2601                 u32 a, b;
2602                 a = rect.width * rect.height;
2603                 b = pix->width * pix->height;
2604                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2605         }
2606
2607         pix->width = rect.width / scale;
2608         pix->height = rect.height / scale;
2609
2610         switch (cam->bridge) {
2611         case BRIDGE_SN9C101:
2612         case BRIDGE_SN9C102:
2613         case BRIDGE_SN9C103:
2614                 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2615                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2616                         pix->pixelformat = pfmt->pixelformat;
2617                 break;
2618         case BRIDGE_SN9C105:
2619         case BRIDGE_SN9C120:
2620                 if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
2621                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2622                         pix->pixelformat = pfmt->pixelformat;
2623                 break;
2624         }
2625         pix->priv = pfmt->priv; /* bpp */
2626         pix->colorspace = (pix->pixelformat == V4L2_PIX_FMT_JPEG) ?
2627                           V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2628         pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2629                              pix->pixelformat == V4L2_PIX_FMT_JPEG)
2630                             ? 0 : (pix->width * pix->priv) / 8;
2631         pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2632         pix->field = V4L2_FIELD_NONE;
2633
2634         if (cmd == VIDIOC_TRY_FMT) {
2635                 if (copy_to_user(arg, &format, sizeof(format)))
2636                         return -EFAULT;
2637                 return 0;
2638         }
2639
2640         if (cam->module_param.force_munmap)
2641                 for (i = 0; i < cam->nbuffers; i++)
2642                         if (cam->frame[i].vma_use_count) {
2643                                 DBG(3, "VIDIOC_S_FMT failed. Unmap the "
2644                                        "buffers first.");
2645                                 return -EBUSY;
2646                         }
2647
2648         if (cam->stream == STREAM_ON)
2649                 if ((err = sn9c102_stream_interrupt(cam)))
2650                         return err;
2651
2652         if (copy_to_user(arg, &format, sizeof(format))) {
2653                 cam->stream = stream;
2654                 return -EFAULT;
2655         }
2656
2657         if (cam->module_param.force_munmap  || cam->io == IO_READ)
2658                 sn9c102_release_buffers(cam);
2659
2660         err += sn9c102_set_pix_format(cam, pix);
2661         err += sn9c102_set_crop(cam, &rect);
2662         if (s->set_pix_format)
2663                 err += s->set_pix_format(cam, pix);
2664         if (s->set_crop)
2665                 err += s->set_crop(cam, &rect);
2666         err += sn9c102_set_scale(cam, scale);
2667
2668         if (err) { /* atomic, no rollback in ioctl() */
2669                 cam->state |= DEV_MISCONFIGURED;
2670                 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2671                        "use the camera, close and open /dev/video%d again.",
2672                     cam->v4ldev->minor);
2673                 return -EIO;
2674         }
2675
2676         memcpy(pfmt, pix, sizeof(*pix));
2677         memcpy(&(s->_rect), &rect, sizeof(rect));
2678
2679         if ((cam->module_param.force_munmap  || cam->io == IO_READ) &&
2680             nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2681                 cam->state |= DEV_MISCONFIGURED;
2682                 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2683                        "use the camera, close and open /dev/video%d again.",
2684                     cam->v4ldev->minor);
2685                 return -ENOMEM;
2686         }
2687
2688         if (cam->io == IO_READ)
2689                 sn9c102_empty_framequeues(cam);
2690         else if (cam->module_param.force_munmap)
2691                 sn9c102_requeue_outqueue(cam);
2692
2693         cam->stream = stream;
2694
2695         return 0;
2696 }
2697
2698
2699 static int
2700 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2701 {
2702         if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2703                 return -EFAULT;
2704
2705         return 0;
2706 }
2707
2708
2709 static int
2710 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2711 {
2712         struct v4l2_jpegcompression jc;
2713         const enum sn9c102_stream_state stream = cam->stream;
2714         int err = 0;
2715
2716         if (copy_from_user(&jc, arg, sizeof(jc)))
2717                 return -EFAULT;
2718
2719         if (jc.quality != 0 && jc.quality != 1)
2720                 return -EINVAL;
2721
2722         if (cam->stream == STREAM_ON)
2723                 if ((err = sn9c102_stream_interrupt(cam)))
2724                         return err;
2725
2726         err += sn9c102_set_compression(cam, &jc);
2727         if (err) { /* atomic, no rollback in ioctl() */
2728                 cam->state |= DEV_MISCONFIGURED;
2729                 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2730                        "problems. To use the camera, close and open "
2731                        "/dev/video%d again.", cam->v4ldev->minor);
2732                 return -EIO;
2733         }
2734
2735         cam->compression.quality = jc.quality;
2736
2737         cam->stream = stream;
2738
2739         return 0;
2740 }
2741
2742
2743 static int
2744 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2745 {
2746         struct v4l2_requestbuffers rb;
2747         u32 i;
2748         int err;
2749
2750         if (copy_from_user(&rb, arg, sizeof(rb)))
2751                 return -EFAULT;
2752
2753         if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2754             rb.memory != V4L2_MEMORY_MMAP)
2755                 return -EINVAL;
2756
2757         if (cam->io == IO_READ) {
2758                 DBG(3, "Close and open the device again to choose the mmap "
2759                        "I/O method");
2760                 return -EBUSY;
2761         }
2762
2763         for (i = 0; i < cam->nbuffers; i++)
2764                 if (cam->frame[i].vma_use_count) {
2765                         DBG(3, "VIDIOC_REQBUFS failed. Previous buffers are "
2766                                "still mapped.");
2767                         return -EBUSY;
2768                 }
2769
2770         if (cam->stream == STREAM_ON)
2771                 if ((err = sn9c102_stream_interrupt(cam)))
2772                         return err;
2773
2774         sn9c102_empty_framequeues(cam);
2775
2776         sn9c102_release_buffers(cam);
2777         if (rb.count)
2778                 rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2779
2780         if (copy_to_user(arg, &rb, sizeof(rb))) {
2781                 sn9c102_release_buffers(cam);
2782                 cam->io = IO_NONE;
2783                 return -EFAULT;
2784         }
2785
2786         cam->io = rb.count ? IO_MMAP : IO_NONE;
2787
2788         return 0;
2789 }
2790
2791
2792 static int
2793 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2794 {
2795         struct v4l2_buffer b;
2796
2797         if (copy_from_user(&b, arg, sizeof(b)))
2798                 return -EFAULT;
2799
2800         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2801             b.index >= cam->nbuffers || cam->io != IO_MMAP)
2802                 return -EINVAL;
2803
2804         memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2805
2806         if (cam->frame[b.index].vma_use_count)
2807                 b.flags |= V4L2_BUF_FLAG_MAPPED;
2808
2809         if (cam->frame[b.index].state == F_DONE)
2810                 b.flags |= V4L2_BUF_FLAG_DONE;
2811         else if (cam->frame[b.index].state != F_UNUSED)
2812                 b.flags |= V4L2_BUF_FLAG_QUEUED;
2813
2814         if (copy_to_user(arg, &b, sizeof(b)))
2815                 return -EFAULT;
2816
2817         return 0;
2818 }
2819
2820
2821 static int
2822 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2823 {
2824         struct v4l2_buffer b;
2825         unsigned long lock_flags;
2826
2827         if (copy_from_user(&b, arg, sizeof(b)))
2828                 return -EFAULT;
2829
2830         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2831             b.index >= cam->nbuffers || cam->io != IO_MMAP)
2832                 return -EINVAL;
2833
2834         if (cam->frame[b.index].state != F_UNUSED)
2835                 return -EINVAL;
2836
2837         cam->frame[b.index].state = F_QUEUED;
2838
2839         spin_lock_irqsave(&cam->queue_lock, lock_flags);
2840         list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2841         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2842
2843         PDBGG("Frame #%lu queued", (unsigned long)b.index);
2844
2845         return 0;
2846 }
2847
2848
2849 static int
2850 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2851                      void __user * arg)
2852 {
2853         struct v4l2_buffer b;
2854         struct sn9c102_frame_t *f;
2855         unsigned long lock_flags;
2856         long timeout;
2857         int err = 0;
2858
2859         if (copy_from_user(&b, arg, sizeof(b)))
2860                 return -EFAULT;
2861
2862         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2863                 return -EINVAL;
2864
2865         if (list_empty(&cam->outqueue)) {
2866                 if (cam->stream == STREAM_OFF)
2867                         return -EINVAL;
2868                 if (filp->f_flags & O_NONBLOCK)
2869                         return -EAGAIN;
2870                 if (!cam->module_param.frame_timeout) {
2871                         err = wait_event_interruptible
2872                               ( cam->wait_frame,
2873                                 (!list_empty(&cam->outqueue)) ||
2874                                 (cam->state & DEV_DISCONNECTED) ||
2875                                 (cam->state & DEV_MISCONFIGURED) );
2876                         if (err)
2877                                 return err;
2878                 } else {
2879                         timeout = wait_event_interruptible_timeout
2880                                   ( cam->wait_frame,
2881                                     (!list_empty(&cam->outqueue)) ||
2882                                     (cam->state & DEV_DISCONNECTED) ||
2883                                     (cam->state & DEV_MISCONFIGURED),
2884                                     cam->module_param.frame_timeout *
2885                                     1000 * msecs_to_jiffies(1) );
2886                         if (timeout < 0)
2887                                 return timeout;
2888                         else if (timeout == 0 &&
2889                                  !(cam->state & DEV_DISCONNECTED)) {
2890                                 DBG(1, "Video frame timeout elapsed");
2891                                 return -EIO;
2892                         }
2893                 }
2894                 if (cam->state & DEV_DISCONNECTED)
2895                         return -ENODEV;
2896                 if (cam->state & DEV_MISCONFIGURED)
2897                         return -EIO;
2898         }
2899
2900         spin_lock_irqsave(&cam->queue_lock, lock_flags);
2901         f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2902         list_del(cam->outqueue.next);
2903         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2904
2905         f->state = F_UNUSED;
2906
2907         memcpy(&b, &f->buf, sizeof(b));
2908         if (f->vma_use_count)
2909                 b.flags |= V4L2_BUF_FLAG_MAPPED;
2910
2911         if (copy_to_user(arg, &b, sizeof(b)))
2912                 return -EFAULT;
2913
2914         PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
2915
2916         return 0;
2917 }
2918
2919
2920 static int
2921 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2922 {
2923         int type;
2924
2925         if (copy_from_user(&type, arg, sizeof(type)))
2926                 return -EFAULT;
2927
2928         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2929                 return -EINVAL;
2930
2931         cam->stream = STREAM_ON;
2932
2933         DBG(3, "Stream on");
2934
2935         return 0;
2936 }
2937
2938
2939 static int
2940 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2941 {
2942         int type, err;
2943
2944         if (copy_from_user(&type, arg, sizeof(type)))
2945                 return -EFAULT;
2946
2947         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2948                 return -EINVAL;
2949
2950         if (cam->stream == STREAM_ON)
2951                 if ((err = sn9c102_stream_interrupt(cam)))
2952                         return err;
2953
2954         sn9c102_empty_framequeues(cam);
2955
2956         DBG(3, "Stream off");
2957
2958         return 0;
2959 }
2960
2961
2962 static int
2963 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2964 {
2965         struct v4l2_streamparm sp;
2966
2967         if (copy_from_user(&sp, arg, sizeof(sp)))
2968                 return -EFAULT;
2969
2970         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2971                 return -EINVAL;
2972
2973         sp.parm.capture.extendedmode = 0;
2974         sp.parm.capture.readbuffers = cam->nreadbuffers;
2975
2976         if (copy_to_user(arg, &sp, sizeof(sp)))
2977                 return -EFAULT;
2978
2979         return 0;
2980 }
2981
2982
2983 static int
2984 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
2985 {
2986         struct v4l2_streamparm sp;
2987
2988         if (copy_from_user(&sp, arg, sizeof(sp)))
2989                 return -EFAULT;
2990
2991         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2992                 return -EINVAL;
2993
2994         sp.parm.capture.extendedmode = 0;
2995
2996         if (sp.parm.capture.readbuffers == 0)
2997                 sp.parm.capture.readbuffers = cam->nreadbuffers;
2998
2999         if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
3000                 sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
3001
3002         if (copy_to_user(arg, &sp, sizeof(sp)))
3003                 return -EFAULT;
3004
3005         cam->nreadbuffers = sp.parm.capture.readbuffers;
3006
3007         return 0;
3008 }
3009
3010
3011 static int
3012 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
3013 {
3014         struct v4l2_audio audio;
3015
3016         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3017                 return -EINVAL;
3018
3019         if (copy_from_user(&audio, arg, sizeof(audio)))
3020                 return -EFAULT;
3021
3022         if (audio.index != 0)
3023                 return -EINVAL;
3024
3025         strcpy(audio.name, "Microphone");
3026         audio.capability = 0;
3027         audio.mode = 0;
3028
3029         if (copy_to_user(arg, &audio, sizeof(audio)))
3030                 return -EFAULT;
3031
3032         return 0;
3033 }
3034
3035
3036 static int
3037 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3038 {
3039         struct v4l2_audio audio;
3040
3041         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3042                 return -EINVAL;
3043
3044         if (copy_from_user(&audio, arg, sizeof(audio)))
3045                 return -EFAULT;
3046
3047         memset(&audio, 0, sizeof(audio));
3048         strcpy(audio.name, "Microphone");
3049
3050         if (copy_to_user(arg, &audio, sizeof(audio)))
3051                 return -EFAULT;
3052
3053         return 0;
3054 }
3055
3056
3057 static int
3058 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3059 {
3060         struct v4l2_audio audio;
3061
3062         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3063                 return -EINVAL;
3064
3065         if (copy_from_user(&audio, arg, sizeof(audio)))
3066                 return -EFAULT;
3067
3068         if (audio.index != 0)
3069                 return -EINVAL;
3070
3071         return 0;
3072 }
3073
3074
3075 static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
3076                               unsigned int cmd, void __user * arg)
3077 {
3078         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3079
3080         switch (cmd) {
3081
3082         case VIDIOC_QUERYCAP:
3083                 return sn9c102_vidioc_querycap(cam, arg);
3084
3085         case VIDIOC_ENUMINPUT:
3086                 return sn9c102_vidioc_enuminput(cam, arg);
3087
3088         case VIDIOC_G_INPUT:
3089                 return sn9c102_vidioc_g_input(cam, arg);
3090
3091         case VIDIOC_S_INPUT:
3092                 return sn9c102_vidioc_s_input(cam, arg);
3093
3094         case VIDIOC_QUERYCTRL:
3095                 return sn9c102_vidioc_query_ctrl(cam, arg);
3096
3097         case VIDIOC_G_CTRL:
3098                 return sn9c102_vidioc_g_ctrl(cam, arg);
3099
3100         case VIDIOC_S_CTRL:
3101                 return sn9c102_vidioc_s_ctrl(cam, arg);
3102
3103         case VIDIOC_CROPCAP:
3104                 return sn9c102_vidioc_cropcap(cam, arg);
3105
3106         case VIDIOC_G_CROP:
3107                 return sn9c102_vidioc_g_crop(cam, arg);
3108
3109         case VIDIOC_S_CROP:
3110                 return sn9c102_vidioc_s_crop(cam, arg);
3111
3112         case VIDIOC_ENUM_FRAMESIZES:
3113                 return sn9c102_vidioc_enum_framesizes(cam, arg);
3114
3115         case VIDIOC_ENUM_FMT:
3116                 return sn9c102_vidioc_enum_fmt(cam, arg);
3117
3118         case VIDIOC_G_FMT:
3119                 return sn9c102_vidioc_g_fmt(cam, arg);
3120
3121         case VIDIOC_TRY_FMT:
3122         case VIDIOC_S_FMT:
3123                 return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3124
3125         case VIDIOC_G_JPEGCOMP:
3126                 return sn9c102_vidioc_g_jpegcomp(cam, arg);
3127
3128         case VIDIOC_S_JPEGCOMP:
3129                 return sn9c102_vidioc_s_jpegcomp(cam, arg);
3130
3131         case VIDIOC_REQBUFS:
3132                 return sn9c102_vidioc_reqbufs(cam, arg);
3133
3134         case VIDIOC_QUERYBUF:
3135                 return sn9c102_vidioc_querybuf(cam, arg);
3136
3137         case VIDIOC_QBUF:
3138                 return sn9c102_vidioc_qbuf(cam, arg);
3139
3140         case VIDIOC_DQBUF:
3141                 return sn9c102_vidioc_dqbuf(cam, filp, arg);
3142
3143         case VIDIOC_STREAMON:
3144                 return sn9c102_vidioc_streamon(cam, arg);
3145
3146         case VIDIOC_STREAMOFF:
3147                 return sn9c102_vidioc_streamoff(cam, arg);
3148
3149         case VIDIOC_G_PARM:
3150                 return sn9c102_vidioc_g_parm(cam, arg);
3151
3152         case VIDIOC_S_PARM:
3153                 return sn9c102_vidioc_s_parm(cam, arg);
3154
3155         case VIDIOC_ENUMAUDIO:
3156                 return sn9c102_vidioc_enumaudio(cam, arg);
3157
3158         case VIDIOC_G_AUDIO:
3159                 return sn9c102_vidioc_g_audio(cam, arg);
3160
3161         case VIDIOC_S_AUDIO:
3162                 return sn9c102_vidioc_s_audio(cam, arg);
3163
3164         case VIDIOC_G_STD:
3165         case VIDIOC_S_STD:
3166         case VIDIOC_QUERYSTD:
3167         case VIDIOC_ENUMSTD:
3168         case VIDIOC_QUERYMENU:
3169         case VIDIOC_ENUM_FRAMEINTERVALS:
3170                 return -EINVAL;
3171
3172         default:
3173                 return -EINVAL;
3174
3175         }
3176 }
3177
3178
3179 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
3180                          unsigned int cmd, unsigned long arg)
3181 {
3182         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3183         int err = 0;
3184
3185         if (mutex_lock_interruptible(&cam->fileop_mutex))
3186                 return -ERESTARTSYS;
3187
3188         if (cam->state & DEV_DISCONNECTED) {
3189                 DBG(1, "Device not present");
3190                 mutex_unlock(&cam->fileop_mutex);
3191                 return -ENODEV;
3192         }
3193
3194         if (cam->state & DEV_MISCONFIGURED) {
3195                 DBG(1, "The camera is misconfigured. Close and open it "
3196                        "again.");
3197                 mutex_unlock(&cam->fileop_mutex);
3198                 return -EIO;
3199         }
3200
3201         V4LDBG(3, "sn9c102", cmd);
3202
3203         err = sn9c102_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
3204
3205         mutex_unlock(&cam->fileop_mutex);
3206
3207         return err;
3208 }
3209
3210 /*****************************************************************************/
3211
3212 static const struct file_operations sn9c102_fops = {
3213         .owner = THIS_MODULE,
3214         .open = sn9c102_open,
3215         .release = sn9c102_release,
3216         .ioctl = sn9c102_ioctl,
3217 #ifdef CONFIG_COMPAT
3218         .compat_ioctl = v4l_compat_ioctl32,
3219 #endif
3220         .read = sn9c102_read,
3221         .poll = sn9c102_poll,
3222         .mmap = sn9c102_mmap,
3223         .llseek = no_llseek,
3224 };
3225
3226 /*****************************************************************************/
3227
3228 /* It exists a single interface only. We do not need to validate anything. */
3229 static int
3230 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3231 {
3232         struct usb_device *udev = interface_to_usbdev(intf);
3233         struct sn9c102_device* cam;
3234         static unsigned int dev_nr;
3235         unsigned int i;
3236         int err = 0, r;
3237
3238         if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3239                 return -ENOMEM;
3240
3241         cam->usbdev = udev;
3242
3243         if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3244                 DBG(1, "kzalloc() failed");
3245                 err = -ENOMEM;
3246                 goto fail;
3247         }
3248
3249         if (!(cam->v4ldev = video_device_alloc())) {
3250                 DBG(1, "video_device_alloc() failed");
3251                 err = -ENOMEM;
3252                 goto fail;
3253         }
3254
3255         r = sn9c102_read_reg(cam, 0x00);
3256         if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {
3257                 DBG(1, "Sorry, this is not a SN9C1xx-based camera "
3258                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3259                 err = -ENODEV;
3260                 goto fail;
3261         }
3262
3263         cam->bridge = id->driver_info;
3264         switch (cam->bridge) {
3265         case BRIDGE_SN9C101:
3266         case BRIDGE_SN9C102:
3267                 DBG(2, "SN9C10[12] PC Camera Controller detected "
3268                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3269                 break;
3270         case BRIDGE_SN9C103:
3271                 DBG(2, "SN9C103 PC Camera Controller detected "
3272                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3273                 break;
3274         case BRIDGE_SN9C105:
3275                 DBG(2, "SN9C105 PC Camera Controller detected "
3276                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3277                 break;
3278         case BRIDGE_SN9C120:
3279                 DBG(2, "SN9C120 PC Camera Controller detected "
3280                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3281                 break;
3282         }
3283
3284         for  (i = 0; i < ARRAY_SIZE(sn9c102_sensor_table); i++) {
3285                 err = sn9c102_sensor_table[i](cam);
3286                 if (!err)
3287                         break;
3288         }
3289
3290         if (!err) {
3291                 DBG(2, "%s image sensor detected", cam->sensor.name);
3292                 DBG(3, "Support for %s maintained by %s",
3293                     cam->sensor.name, cam->sensor.maintainer);
3294         } else {
3295                 DBG(1, "No supported image sensor detected for this bridge");
3296                 err = -ENODEV;
3297                 goto fail;
3298         }
3299
3300         if (!(cam->bridge & cam->sensor.supported_bridge)) {
3301                 DBG(1, "Bridge not supported");
3302                 err = -ENODEV;
3303                 goto fail;
3304         }
3305
3306         if (sn9c102_init(cam)) {
3307                 DBG(1, "Initialization failed. I will retry on open().");
3308                 cam->state |= DEV_MISCONFIGURED;
3309         }
3310
3311         strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3312         cam->v4ldev->fops = &sn9c102_fops;
3313         cam->v4ldev->minor = video_nr[dev_nr];
3314         cam->v4ldev->release = video_device_release;
3315         cam->v4ldev->parent = &udev->dev;
3316
3317         init_completion(&cam->probe);
3318
3319         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3320                                     video_nr[dev_nr]);
3321         if (err) {
3322                 DBG(1, "V4L2 device registration failed");
3323                 if (err == -ENFILE && video_nr[dev_nr] == -1)
3324                         DBG(1, "Free /dev/videoX node not found");
3325                 video_nr[dev_nr] = -1;
3326                 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3327                 complete_all(&cam->probe);
3328                 goto fail;
3329         }
3330
3331         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor);
3332
3333         video_set_drvdata(cam->v4ldev, cam);
3334         cam->module_param.force_munmap = force_munmap[dev_nr];
3335         cam->module_param.frame_timeout = frame_timeout[dev_nr];
3336
3337         dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3338
3339 #ifdef CONFIG_VIDEO_ADV_DEBUG
3340         err = sn9c102_create_sysfs(cam);
3341         if (!err)
3342                 DBG(2, "Optional device control through 'sysfs' "
3343                        "interface ready");
3344         else
3345                 DBG(2, "Failed to create optional 'sysfs' interface for "
3346                        "device controlling. Error #%d", err);
3347 #else
3348         DBG(2, "Optional device control through 'sysfs' interface disabled");
3349         DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
3350                "configuration option to enable it.");
3351 #endif
3352
3353         usb_set_intfdata(intf, cam);
3354         kref_init(&cam->kref);
3355         usb_get_dev(cam->usbdev);
3356
3357         complete_all(&cam->probe);
3358
3359         return 0;
3360
3361 fail:
3362         if (cam) {
3363                 kfree(cam->control_buffer);
3364                 if (cam->v4ldev)
3365                         video_device_release(cam->v4ldev);
3366                 kfree(cam);
3367         }
3368         return err;
3369 }
3370
3371
3372 static void sn9c102_usb_disconnect(struct usb_interface* intf)
3373 {
3374         struct sn9c102_device* cam;
3375
3376         down_write(&sn9c102_dev_lock);
3377
3378         cam = usb_get_intfdata(intf);
3379
3380         DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3381
3382         if (cam->users) {
3383                 DBG(2, "Device /dev/video%d is open! Deregistration and "
3384                        "memory deallocation are deferred.",
3385                     cam->v4ldev->minor);
3386                 cam->state |= DEV_MISCONFIGURED;
3387                 sn9c102_stop_transfer(cam);
3388                 cam->state |= DEV_DISCONNECTED;
3389                 wake_up_interruptible(&cam->wait_frame);
3390                 wake_up(&cam->wait_stream);
3391         } else
3392                 cam->state |= DEV_DISCONNECTED;
3393
3394         wake_up_interruptible_all(&cam->wait_open);
3395
3396         kref_put(&cam->kref, sn9c102_release_resources);
3397
3398         up_write(&sn9c102_dev_lock);
3399 }
3400
3401
3402 static struct usb_driver sn9c102_usb_driver = {
3403         .name =       "sn9c102",
3404         .id_table =   sn9c102_id_table,
3405         .probe =      sn9c102_usb_probe,
3406         .disconnect = sn9c102_usb_disconnect,
3407 };
3408
3409 /*****************************************************************************/
3410
3411 static int __init sn9c102_module_init(void)
3412 {
3413         int err = 0;
3414
3415         KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION);
3416         KDBG(3, SN9C102_MODULE_AUTHOR);
3417
3418         if ((err = usb_register(&sn9c102_usb_driver)))
3419                 KDBG(1, "usb_register() failed");
3420
3421         return err;
3422 }
3423
3424
3425 static void __exit sn9c102_module_exit(void)
3426 {
3427         usb_deregister(&sn9c102_usb_driver);
3428 }
3429
3430
3431 module_init(sn9c102_module_init);
3432 module_exit(sn9c102_module_exit);