git.oblomov.eu Git - linux-2.6/blob - 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 <linux/byteorder/generic.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 int
 468 sn9c102_i2c_try_write(struct sn9c102_device* cam,
 469                       const struct sn9c102_sensor* sensor, 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,
1042                                              class_dev));
1043         if (!cam) {
1044                 mutex_unlock(&sn9c102_sysfs_lock);
1045                 return -ENODEV;
1046         }
1047
1048         count = sprintf(buf, "%u\n", cam->sysfs.reg);
1049
1050         mutex_unlock(&sn9c102_sysfs_lock);
1051
1052         return count;
1053 }
1054
1055
1056 static ssize_t
1057 sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
1058                   const char* buf, size_t len)
1059 {
1060         struct sn9c102_device* cam;
1061         u16 index;
1062         ssize_t count;
1063
1064         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1065                 return -ERESTARTSYS;
1066
1067         cam = video_get_drvdata(container_of(cd, struct video_device,
1068                                              class_dev));
1069         if (!cam) {
1070                 mutex_unlock(&sn9c102_sysfs_lock);
1071                 return -ENODEV;
1072         }
1073
1074         index = sn9c102_strtou16(buf, len, &count);
1075         if (index >= ARRAY_SIZE(cam->reg) || !count) {
1076                 mutex_unlock(&sn9c102_sysfs_lock);
1077                 return -EINVAL;
1078         }
1079
1080         cam->sysfs.reg = index;
1081
1082         DBG(2, "Moved SN9C1XX register index to 0x%02X", cam->sysfs.reg);
1083         DBG(3, "Written bytes: %zd", count);
1084
1085         mutex_unlock(&sn9c102_sysfs_lock);
1086
1087         return count;
1088 }
1089
1090
1091 static ssize_t sn9c102_show_val(struct device* cd,
1092                                 struct device_attribute *attr, char* buf)
1093 {
1094         struct sn9c102_device* cam;
1095         ssize_t count;
1096         int val;
1097
1098         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1099                 return -ERESTARTSYS;
1100
1101         cam = video_get_drvdata(container_of(cd, struct video_device,
1102                                              class_dev));
1103         if (!cam) {
1104                 mutex_unlock(&sn9c102_sysfs_lock);
1105                 return -ENODEV;
1106         }
1107
1108         if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
1109                 mutex_unlock(&sn9c102_sysfs_lock);
1110                 return -EIO;
1111         }
1112
1113         count = sprintf(buf, "%d\n", val);
1114
1115         DBG(3, "Read bytes: %zd, value: %d", count, val);
1116
1117         mutex_unlock(&sn9c102_sysfs_lock);
1118
1119         return count;
1120 }
1121
1122
1123 static ssize_t
1124 sn9c102_store_val(struct device* cd, struct device_attribute *attr,
1125                   const char* buf, size_t len)
1126 {
1127         struct sn9c102_device* cam;
1128         u16 value;
1129         ssize_t count;
1130         int err;
1131
1132         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1133                 return -ERESTARTSYS;
1134
1135         cam = video_get_drvdata(container_of(cd, struct video_device,
1136                                              class_dev));
1137         if (!cam) {
1138                 mutex_unlock(&sn9c102_sysfs_lock);
1139                 return -ENODEV;
1140         }
1141
1142         value = sn9c102_strtou16(buf, len, &count);
1143         if (!count) {
1144                 mutex_unlock(&sn9c102_sysfs_lock);
1145                 return -EINVAL;
1146         }
1147
1148         err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
1149         if (err) {
1150                 mutex_unlock(&sn9c102_sysfs_lock);
1151                 return -EIO;
1152         }
1153
1154         DBG(2, "Written SN9C1XX reg. 0x%02X, val. 0x%02X",
1155             cam->sysfs.reg, value);
1156         DBG(3, "Written bytes: %zd", count);
1157
1158         mutex_unlock(&sn9c102_sysfs_lock);
1159
1160         return count;
1161 }
1162
1163
1164 static ssize_t sn9c102_show_i2c_reg(struct device* cd,
1165                                     struct device_attribute *attr, char* buf)
1166 {
1167         struct sn9c102_device* cam;
1168         ssize_t count;
1169
1170         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1171                 return -ERESTARTSYS;
1172
1173         cam = video_get_drvdata(container_of(cd, struct video_device,
1174                                              class_dev));
1175         if (!cam) {
1176                 mutex_unlock(&sn9c102_sysfs_lock);
1177                 return -ENODEV;
1178         }
1179
1180         count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
1181
1182         DBG(3, "Read bytes: %zd", count);
1183
1184         mutex_unlock(&sn9c102_sysfs_lock);
1185
1186         return count;
1187 }
1188
1189
1190 static ssize_t
1191 sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
1192                       const char* buf, size_t len)
1193 {
1194         struct sn9c102_device* cam;
1195         u16 index;
1196         ssize_t count;
1197
1198         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1199                 return -ERESTARTSYS;
1200
1201         cam = video_get_drvdata(container_of(cd, struct video_device,
1202                                              class_dev));
1203         if (!cam) {
1204                 mutex_unlock(&sn9c102_sysfs_lock);
1205                 return -ENODEV;
1206         }
1207
1208         index = sn9c102_strtou16(buf, len, &count);
1209         if (!count) {
1210                 mutex_unlock(&sn9c102_sysfs_lock);
1211                 return -EINVAL;
1212         }
1213
1214         cam->sysfs.i2c_reg = index;
1215
1216         DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg);
1217         DBG(3, "Written bytes: %zd", count);
1218
1219         mutex_unlock(&sn9c102_sysfs_lock);
1220
1221         return count;
1222 }
1223
1224
1225 static ssize_t sn9c102_show_i2c_val(struct device* cd,
1226                                     struct device_attribute *attr, char* buf)
1227 {
1228         struct sn9c102_device* cam;
1229         ssize_t count;
1230         int val;
1231
1232         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1233                 return -ERESTARTSYS;
1234
1235         cam = video_get_drvdata(container_of(cd, struct video_device,
1236                                              class_dev));
1237         if (!cam) {
1238                 mutex_unlock(&sn9c102_sysfs_lock);
1239                 return -ENODEV;
1240         }
1241
1242         if (!(cam->sensor.sysfs_ops & SN9C102_I2C_READ)) {
1243                 mutex_unlock(&sn9c102_sysfs_lock);
1244                 return -ENOSYS;
1245         }
1246
1247         if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
1248                 mutex_unlock(&sn9c102_sysfs_lock);
1249                 return -EIO;
1250         }
1251
1252         count = sprintf(buf, "%d\n", val);
1253
1254         DBG(3, "Read bytes: %zd, value: %d", count, val);
1255
1256         mutex_unlock(&sn9c102_sysfs_lock);
1257
1258         return count;
1259 }
1260
1261
1262 static ssize_t
1263 sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
1264                       const char* buf, size_t len)
1265 {
1266         struct sn9c102_device* cam;
1267         u16 value;
1268         ssize_t count;
1269         int err;
1270
1271         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1272                 return -ERESTARTSYS;
1273
1274         cam = video_get_drvdata(container_of(cd, struct video_device,
1275                                              class_dev));
1276         if (!cam) {
1277                 mutex_unlock(&sn9c102_sysfs_lock);
1278                 return -ENODEV;
1279         }
1280
1281         if (!(cam->sensor.sysfs_ops & SN9C102_I2C_WRITE)) {
1282                 mutex_unlock(&sn9c102_sysfs_lock);
1283                 return -ENOSYS;
1284         }
1285
1286         value = sn9c102_strtou16(buf, len, &count);
1287         if (!count) {
1288                 mutex_unlock(&sn9c102_sysfs_lock);
1289                 return -EINVAL;
1290         }
1291
1292         err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1293         if (err) {
1294                 mutex_unlock(&sn9c102_sysfs_lock);
1295                 return -EIO;
1296         }
1297
1298         DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1299             cam->sysfs.i2c_reg, value);
1300         DBG(3, "Written bytes: %zd", count);
1301
1302         mutex_unlock(&sn9c102_sysfs_lock);
1303
1304         return count;
1305 }
1306
1307
1308 static ssize_t
1309 sn9c102_store_green(struct device* cd, struct device_attribute *attr,
1310                     const char* buf, size_t len)
1311 {
1312         struct sn9c102_device* cam;
1313         enum sn9c102_bridge bridge;
1314         ssize_t res = 0;
1315         u16 value;
1316         ssize_t count;
1317
1318         if (mutex_lock_interruptible(&sn9c102_sysfs_lock))
1319                 return -ERESTARTSYS;
1320
1321         cam = video_get_drvdata(container_of(cd, struct video_device,
1322                                              class_dev));
1323         if (!cam) {
1324                 mutex_unlock(&sn9c102_sysfs_lock);
1325                 return -ENODEV;
1326         }
1327
1328         bridge = cam->bridge;
1329
1330         mutex_unlock(&sn9c102_sysfs_lock);
1331
1332         value = sn9c102_strtou16(buf, len, &count);
1333         if (!count)
1334                 return -EINVAL;
1335
1336         switch (bridge) {
1337         case BRIDGE_SN9C101:
1338         case BRIDGE_SN9C102:
1339                 if (value > 0x0f)
1340                         return -EINVAL;
1341                 if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
1342                         res = sn9c102_store_val(cd, attr, buf, len);
1343                 break;
1344         case BRIDGE_SN9C103:
1345         case BRIDGE_SN9C105:
1346         case BRIDGE_SN9C120:
1347                 if (value > 0x7f)
1348                         return -EINVAL;
1349                 if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
1350                         res = sn9c102_store_val(cd, attr, buf, len);
1351                 break;
1352         }
1353
1354         return res;
1355 }
1356
1357
1358 static ssize_t
1359 sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
1360                    const char* buf, size_t len)
1361 {
1362         ssize_t res = 0;
1363         u16 value;
1364         ssize_t count;
1365
1366         value = sn9c102_strtou16(buf, len, &count);
1367         if (!count || value > 0x7f)
1368                 return -EINVAL;
1369
1370         if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
1371                 res = sn9c102_store_val(cd, attr, buf, len);
1372
1373         return res;
1374 }
1375
1376
1377 static ssize_t
1378 sn9c102_store_red(struct device* cd, struct device_attribute *attr,
1379                   const char* buf, size_t len)
1380 {
1381         ssize_t res = 0;
1382         u16 value;
1383         ssize_t count;
1384
1385         value = sn9c102_strtou16(buf, len, &count);
1386         if (!count || value > 0x7f)
1387                 return -EINVAL;
1388
1389         if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
1390                 res = sn9c102_store_val(cd, attr, buf, len);
1391
1392         return res;
1393 }
1394
1395
1396 static ssize_t sn9c102_show_frame_header(struct device* cd,
1397                                          struct device_attribute *attr,
1398                                          char* buf)
1399 {
1400         struct sn9c102_device* cam;
1401         ssize_t count;
1402
1403         cam = video_get_drvdata(container_of(cd, struct video_device,
1404                                              class_dev));
1405         if (!cam)
1406                 return -ENODEV;
1407
1408         count = sizeof(cam->sysfs.frame_header);
1409         memcpy(buf, cam->sysfs.frame_header, count);
1410
1411         DBG(3, "Frame header, read bytes: %zd", count);
1412
1413         return count;
1414 }
1415
1416
1417 static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR, sn9c102_show_reg, sn9c102_store_reg);
1418 static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, sn9c102_show_val, sn9c102_store_val);
1419 static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1420                    sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1421 static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1422                    sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1423 static DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1424 static DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1425 static DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1426 static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
1427
1428
1429 static int sn9c102_create_sysfs(struct sn9c102_device* cam)
1430 {
1431         struct device *classdev = &(cam->v4ldev->class_dev);
1432         int err = 0;
1433
1434         if ((err = device_create_file(classdev, &dev_attr_reg)))
1435                 goto err_out;
1436         if ((err = device_create_file(classdev, &dev_attr_val)))
1437                 goto err_reg;
1438         if ((err = device_create_file(classdev, &dev_attr_frame_header)))
1439                 goto err_val;
1440
1441         if (cam->sensor.sysfs_ops) {
1442                 if ((err = device_create_file(classdev, &dev_attr_i2c_reg)))
1443                         goto err_frame_header;
1444                 if ((err = device_create_file(classdev, &dev_attr_i2c_val)))
1445                         goto err_i2c_reg;
1446         }
1447
1448         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
1449                 if ((err = device_create_file(classdev, &dev_attr_green)))
1450                         goto err_i2c_val;
1451         } else {
1452                 if ((err = device_create_file(classdev, &dev_attr_blue)))
1453                         goto err_i2c_val;
1454                 if ((err = device_create_file(classdev, &dev_attr_red)))
1455                         goto err_blue;
1456         }
1457
1458         return 0;
1459
1460 err_blue:
1461         device_remove_file(classdev, &dev_attr_blue);
1462 err_i2c_val:
1463         if (cam->sensor.sysfs_ops)
1464                 device_remove_file(classdev, &dev_attr_i2c_val);
1465 err_i2c_reg:
1466         if (cam->sensor.sysfs_ops)
1467                 device_remove_file(classdev, &dev_attr_i2c_reg);
1468 err_frame_header:
1469         device_remove_file(classdev, &dev_attr_frame_header);
1470 err_val:
1471         device_remove_file(classdev, &dev_attr_val);
1472 err_reg:
1473         device_remove_file(classdev, &dev_attr_reg);
1474 err_out:
1475         return err;
1476 }
1477 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1478
1479 /*****************************************************************************/
1480
1481 static int
1482 sn9c102_set_pix_format(struct sn9c102_device* cam, struct v4l2_pix_format* pix)
1483 {
1484         int err = 0;
1485
1486         if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
1487             pix->pixelformat == V4L2_PIX_FMT_JPEG) {
1488                 switch (cam->bridge) {
1489                 case BRIDGE_SN9C101:
1490                 case BRIDGE_SN9C102:
1491                 case BRIDGE_SN9C103:
1492                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1493                                                  0x18);
1494                         break;
1495                 case BRIDGE_SN9C105:
1496                 case BRIDGE_SN9C120:
1497                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1498                                                  0x18);
1499                         break;
1500                 }
1501         } else {
1502                 switch (cam->bridge) {
1503                 case BRIDGE_SN9C101:
1504                 case BRIDGE_SN9C102:
1505                 case BRIDGE_SN9C103:
1506                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f,
1507                                                  0x18);
1508                         break;
1509                 case BRIDGE_SN9C105:
1510                 case BRIDGE_SN9C120:
1511                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80,
1512                                                  0x18);
1513                         break;
1514                 }
1515         }
1516
1517         return err ? -EIO : 0;
1518 }
1519
1520
1521 static int
1522 sn9c102_set_compression(struct sn9c102_device* cam,
1523                         struct v4l2_jpegcompression* compression)
1524 {
1525         int i, err = 0;
1526
1527         switch (cam->bridge) {
1528         case BRIDGE_SN9C101:
1529         case BRIDGE_SN9C102:
1530         case BRIDGE_SN9C103:
1531                 if (compression->quality == 0)
1532                         err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01,
1533                                                  0x17);
1534                 else if (compression->quality == 1)
1535                         err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe,
1536                                                  0x17);
1537                 break;
1538         case BRIDGE_SN9C105:
1539         case BRIDGE_SN9C120:
1540                 if (compression->quality == 0) {
1541                         for (i = 0; i <= 63; i++) {
1542                                 err += sn9c102_write_reg(cam,
1543                                                          SN9C102_Y_QTABLE1[i],
1544                                                          0x100 + i);
1545                                 err += sn9c102_write_reg(cam,
1546                                                          SN9C102_UV_QTABLE1[i],
1547                                                          0x140 + i);
1548                         }
1549                         err += sn9c102_write_reg(cam, cam->reg[0x18] & 0xbf,
1550                                                  0x18);
1551                 } else if (compression->quality == 1) {
1552                         for (i = 0; i <= 63; i++) {
1553                                 err += sn9c102_write_reg(cam,
1554                                                          SN9C102_Y_QTABLE1[i],
1555                                                          0x100 + i);
1556                                 err += sn9c102_write_reg(cam,
1557                                                          SN9C102_UV_QTABLE1[i],
1558                                                          0x140 + i);
1559                         }
1560                         err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x40,
1561                                                  0x18);
1562                 }
1563                 break;
1564         }
1565
1566         return err ? -EIO : 0;
1567 }
1568
1569
1570 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1571 {
1572         u8 r = 0;
1573         int err = 0;
1574
1575         if (scale == 1)
1576                 r = cam->reg[0x18] & 0xcf;
1577         else if (scale == 2) {
1578                 r = cam->reg[0x18] & 0xcf;
1579                 r |= 0x10;
1580         } else if (scale == 4)
1581                 r = cam->reg[0x18] | 0x20;
1582
1583         err += sn9c102_write_reg(cam, r, 0x18);
1584         if (err)
1585                 return -EIO;
1586
1587         PDBGG("Scaling factor: %u", scale);
1588
1589         return 0;
1590 }
1591
1592
1593 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1594 {
1595         struct sn9c102_sensor* s = &cam->sensor;
1596         u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1597            v_start = (u8)(rect->top - s->cropcap.bounds.top),
1598            h_size = (u8)(rect->width / 16),
1599            v_size = (u8)(rect->height / 16);
1600         int err = 0;
1601
1602         err += sn9c102_write_reg(cam, h_start, 0x12);
1603         err += sn9c102_write_reg(cam, v_start, 0x13);
1604         err += sn9c102_write_reg(cam, h_size, 0x15);
1605         err += sn9c102_write_reg(cam, v_size, 0x16);
1606         if (err)
1607                 return -EIO;
1608
1609         PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1610               "%u %u %u %u", h_start, v_start, h_size, v_size);
1611
1612         return 0;
1613 }
1614
1615
1616 static int sn9c102_init(struct sn9c102_device* cam)
1617 {
1618         struct sn9c102_sensor* s = &cam->sensor;
1619         struct v4l2_control ctrl;
1620         struct v4l2_queryctrl *qctrl;
1621         struct v4l2_rect* rect;
1622         u8 i = 0;
1623         int err = 0;
1624
1625         if (!(cam->state & DEV_INITIALIZED)) {
1626                 mutex_init(&cam->open_mutex);
1627                 init_waitqueue_head(&cam->wait_open);
1628                 qctrl = s->qctrl;
1629                 rect = &(s->cropcap.defrect);
1630         } else { /* use current values */
1631                 qctrl = s->_qctrl;
1632                 rect = &(s->_rect);
1633         }
1634
1635         err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1636         err += sn9c102_set_crop(cam, rect);
1637         if (err)
1638                 return err;
1639
1640         if (s->init) {
1641                 err = s->init(cam);
1642                 if (err) {
1643                         DBG(3, "Sensor initialization failed");
1644                         return err;
1645                 }
1646         }
1647
1648         if (!(cam->state & DEV_INITIALIZED))
1649                 if (cam->bridge == BRIDGE_SN9C101 ||
1650                     cam->bridge == BRIDGE_SN9C102 ||
1651                     cam->bridge == BRIDGE_SN9C103) {
1652                         if (s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1653                                 s->pix_format.pixelformat= V4L2_PIX_FMT_SBGGR8;
1654                         cam->compression.quality =  cam->reg[0x17] & 0x01 ?
1655                                                     0 : 1;
1656                 } else {
1657                         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1658                                 s->pix_format.pixelformat = V4L2_PIX_FMT_JPEG;
1659                         cam->compression.quality =  cam->reg[0x18] & 0x40 ?
1660                                                     0 : 1;
1661                         err += sn9c102_set_compression(cam, &cam->compression);
1662                 }
1663         else
1664                 err += sn9c102_set_compression(cam, &cam->compression);
1665         err += sn9c102_set_pix_format(cam, &s->pix_format);
1666         if (s->set_pix_format)
1667                 err += s->set_pix_format(cam, &s->pix_format);
1668         if (err)
1669                 return err;
1670
1671         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X ||
1672             s->pix_format.pixelformat == V4L2_PIX_FMT_JPEG)
1673                 DBG(3, "Compressed video format is active, quality %d",
1674                     cam->compression.quality);
1675         else
1676                 DBG(3, "Uncompressed video format is active");
1677
1678         if (s->set_crop)
1679                 if ((err = s->set_crop(cam, rect))) {
1680                         DBG(3, "set_crop() failed");
1681                         return err;
1682                 }
1683
1684         if (s->set_ctrl) {
1685                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
1686                         if (s->qctrl[i].id != 0 &&
1687                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1688                                 ctrl.id = s->qctrl[i].id;
1689                                 ctrl.value = qctrl[i].default_value;
1690                                 err = s->set_ctrl(cam, &ctrl);
1691                                 if (err) {
1692                                         DBG(3, "Set %s control failed",
1693                                             s->qctrl[i].name);
1694                                         return err;
1695                                 }
1696                                 DBG(3, "Image sensor supports '%s' control",
1697                                     s->qctrl[i].name);
1698                         }
1699         }
1700
1701         if (!(cam->state & DEV_INITIALIZED)) {
1702                 mutex_init(&cam->fileop_mutex);
1703                 spin_lock_init(&cam->queue_lock);
1704                 init_waitqueue_head(&cam->wait_frame);
1705                 init_waitqueue_head(&cam->wait_stream);
1706                 cam->nreadbuffers = 2;
1707                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1708                 memcpy(&(s->_rect), &(s->cropcap.defrect),
1709                        sizeof(struct v4l2_rect));
1710                 cam->state |= DEV_INITIALIZED;
1711         }
1712
1713         DBG(2, "Initialization succeeded");
1714         return 0;
1715 }
1716
1717 /*****************************************************************************/
1718
1719 static void sn9c102_release_resources(struct kref *kref)
1720 {
1721         struct sn9c102_device *cam;
1722
1723         mutex_lock(&sn9c102_sysfs_lock);
1724
1725         cam = container_of(kref, struct sn9c102_device, kref);
1726
1727         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor);
1728         video_set_drvdata(cam->v4ldev, NULL);
1729         video_unregister_device(cam->v4ldev);
1730         usb_put_dev(cam->usbdev);
1731         kfree(cam->control_buffer);
1732         kfree(cam);
1733
1734         mutex_unlock(&sn9c102_sysfs_lock);
1735
1736 }
1737
1738
1739 static int sn9c102_open(struct inode* inode, struct file* filp)
1740 {
1741         struct sn9c102_device* cam;
1742         int err = 0;
1743
1744         /*
1745            A read_trylock() in open() is the only safe way to prevent race
1746            conditions with disconnect(), one close() and multiple (not
1747            necessarily simultaneous) attempts to open(). For example, it
1748            prevents from waiting for a second access, while the device
1749            structure is being deallocated, after a possible disconnect() and
1750            during a following close() holding the write lock: given that, after
1751            this deallocation, no access will be possible anymore, using the
1752            non-trylock version would have let open() gain the access to the
1753            device structure improperly.
1754            For this reason the lock must also not be per-device.
1755         */
1756         if (!down_read_trylock(&sn9c102_dev_lock))
1757                 return -ERESTARTSYS;
1758
1759         cam = video_get_drvdata(video_devdata(filp));
1760
1761         if (wait_for_completion_interruptible(&cam->probe)) {
1762                 up_read(&sn9c102_dev_lock);
1763                 return -ERESTARTSYS;
1764         }
1765
1766         kref_get(&cam->kref);
1767
1768         /*
1769             Make sure to isolate all the simultaneous opens.
1770         */
1771         if (mutex_lock_interruptible(&cam->open_mutex)) {
1772                 kref_put(&cam->kref, sn9c102_release_resources);
1773                 up_read(&sn9c102_dev_lock);
1774                 return -ERESTARTSYS;
1775         }
1776
1777         if (cam->state & DEV_DISCONNECTED) {
1778                 DBG(1, "Device not present");
1779                 err = -ENODEV;
1780                 goto out;
1781         }
1782
1783         if (cam->users) {
1784                 DBG(2, "Device /dev/video%d is already in use",
1785                        cam->v4ldev->minor);
1786                 DBG(3, "Simultaneous opens are not supported");
1787                 /*
1788                    open() must follow the open flags and should block
1789                    eventually while the device is in use.
1790                 */
1791                 if ((filp->f_flags & O_NONBLOCK) ||
1792                     (filp->f_flags & O_NDELAY)) {
1793                         err = -EWOULDBLOCK;
1794                         goto out;
1795                 }
1796                 DBG(2, "A blocking open() has been requested. Wait for the "
1797                        "device to be released...");
1798                 up_read(&sn9c102_dev_lock);
1799                 /*
1800                    We will not release the "open_mutex" lock, so that only one
1801                    process can be in the wait queue below. This way the process
1802                    will be sleeping while holding the lock, without loosing its
1803                    priority after any wake_up().
1804                 */
1805                 err = wait_event_interruptible_exclusive(cam->wait_open,
1806                                                 (cam->state & DEV_DISCONNECTED)
1807                                                          || !cam->users);
1808                 down_read(&sn9c102_dev_lock);
1809                 if (err)
1810                         goto out;
1811                 if (cam->state & DEV_DISCONNECTED) {
1812                         err = -ENODEV;
1813                         goto out;
1814                 }
1815         }
1816
1817         if (cam->state & DEV_MISCONFIGURED) {
1818                 err = sn9c102_init(cam);
1819                 if (err) {
1820                         DBG(1, "Initialization failed again. "
1821                                "I will retry on next open().");
1822                         goto out;
1823                 }
1824                 cam->state &= ~DEV_MISCONFIGURED;
1825         }
1826
1827         if ((err = sn9c102_start_transfer(cam)))
1828                 goto out;
1829
1830         filp->private_data = cam;
1831         cam->users++;
1832         cam->io = IO_NONE;
1833         cam->stream = STREAM_OFF;
1834         cam->nbuffers = 0;
1835         cam->frame_count = 0;
1836         sn9c102_empty_framequeues(cam);
1837
1838         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor);
1839
1840 out:
1841         mutex_unlock(&cam->open_mutex);
1842         if (err)
1843                 kref_put(&cam->kref, sn9c102_release_resources);
1844
1845         up_read(&sn9c102_dev_lock);
1846         return err;
1847 }
1848
1849
1850 static int sn9c102_release(struct inode* inode, struct file* filp)
1851 {
1852         struct sn9c102_device* cam;
1853
1854         down_write(&sn9c102_dev_lock);
1855
1856         cam = video_get_drvdata(video_devdata(filp));
1857
1858         sn9c102_stop_transfer(cam);
1859         sn9c102_release_buffers(cam);
1860         cam->users--;
1861         wake_up_interruptible_nr(&cam->wait_open, 1);
1862
1863         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor);
1864
1865         kref_put(&cam->kref, sn9c102_release_resources);
1866
1867         up_write(&sn9c102_dev_lock);
1868
1869         return 0;
1870 }
1871
1872
1873 static ssize_t
1874 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1875 {
1876         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1877         struct sn9c102_frame_t* f, * i;
1878         unsigned long lock_flags;
1879         long timeout;
1880         int err = 0;
1881
1882         if (mutex_lock_interruptible(&cam->fileop_mutex))
1883                 return -ERESTARTSYS;
1884
1885         if (cam->state & DEV_DISCONNECTED) {
1886                 DBG(1, "Device not present");
1887                 mutex_unlock(&cam->fileop_mutex);
1888                 return -ENODEV;
1889         }
1890
1891         if (cam->state & DEV_MISCONFIGURED) {
1892                 DBG(1, "The camera is misconfigured. Close and open it "
1893                        "again.");
1894                 mutex_unlock(&cam->fileop_mutex);
1895                 return -EIO;
1896         }
1897
1898         if (cam->io == IO_MMAP) {
1899                 DBG(3, "Close and open the device again to choose "
1900                        "the read method");
1901                 mutex_unlock(&cam->fileop_mutex);
1902                 return -EBUSY;
1903         }
1904
1905         if (cam->io == IO_NONE) {
1906                 if (!sn9c102_request_buffers(cam,cam->nreadbuffers, IO_READ)) {
1907                         DBG(1, "read() failed, not enough memory");
1908                         mutex_unlock(&cam->fileop_mutex);
1909                         return -ENOMEM;
1910                 }
1911                 cam->io = IO_READ;
1912                 cam->stream = STREAM_ON;
1913         }
1914
1915         if (list_empty(&cam->inqueue)) {
1916                 if (!list_empty(&cam->outqueue))
1917                         sn9c102_empty_framequeues(cam);
1918                 sn9c102_queue_unusedframes(cam);
1919         }
1920
1921         if (!count) {
1922                 mutex_unlock(&cam->fileop_mutex);
1923                 return 0;
1924         }
1925
1926         if (list_empty(&cam->outqueue)) {
1927                 if (filp->f_flags & O_NONBLOCK) {
1928                         mutex_unlock(&cam->fileop_mutex);
1929                         return -EAGAIN;
1930                 }
1931                 if (!cam->module_param.frame_timeout) {
1932                         err = wait_event_interruptible
1933                               ( cam->wait_frame,
1934                                 (!list_empty(&cam->outqueue)) ||
1935                                 (cam->state & DEV_DISCONNECTED) ||
1936                                 (cam->state & DEV_MISCONFIGURED) );
1937                         if (err) {
1938                                 mutex_unlock(&cam->fileop_mutex);
1939                                 return err;
1940                         }
1941                 } else {
1942                         timeout = wait_event_interruptible_timeout
1943                                   ( cam->wait_frame,
1944                                     (!list_empty(&cam->outqueue)) ||
1945                                     (cam->state & DEV_DISCONNECTED) ||
1946                                     (cam->state & DEV_MISCONFIGURED),
1947                                     cam->module_param.frame_timeout *
1948                                     1000 * msecs_to_jiffies(1) );
1949                         if (timeout < 0) {
1950                                 mutex_unlock(&cam->fileop_mutex);
1951                                 return timeout;
1952                         } else if (timeout == 0 &&
1953                                    !(cam->state & DEV_DISCONNECTED)) {
1954                                 DBG(1, "Video frame timeout elapsed");
1955                                 mutex_unlock(&cam->fileop_mutex);
1956                                 return -EIO;
1957                         }
1958                 }
1959                 if (cam->state & DEV_DISCONNECTED) {
1960                         mutex_unlock(&cam->fileop_mutex);
1961                         return -ENODEV;
1962                 }
1963                 if (cam->state & DEV_MISCONFIGURED) {
1964                         mutex_unlock(&cam->fileop_mutex);
1965                         return -EIO;
1966                 }
1967         }
1968
1969         f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1970
1971         if (count > f->buf.bytesused)
1972                 count = f->buf.bytesused;
1973
1974         if (copy_to_user(buf, f->bufmem, count)) {
1975                 err = -EFAULT;
1976                 goto exit;
1977         }
1978         *f_pos += count;
1979
1980 exit:
1981         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1982         list_for_each_entry(i, &cam->outqueue, frame)
1983                 i->state = F_UNUSED;
1984         INIT_LIST_HEAD(&cam->outqueue);
1985         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1986
1987         sn9c102_queue_unusedframes(cam);
1988
1989         PDBGG("Frame #%lu, bytes read: %zu",
1990               (unsigned long)f->buf.index, count);
1991
1992         mutex_unlock(&cam->fileop_mutex);
1993
1994         return count;
1995 }
1996
1997
1998 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1999 {
2000         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2001         struct sn9c102_frame_t* f;
2002         unsigned long lock_flags;
2003         unsigned int mask = 0;
2004
2005         if (mutex_lock_interruptible(&cam->fileop_mutex))
2006                 return POLLERR;
2007
2008         if (cam->state & DEV_DISCONNECTED) {
2009                 DBG(1, "Device not present");
2010                 goto error;
2011         }
2012
2013         if (cam->state & DEV_MISCONFIGURED) {
2014                 DBG(1, "The camera is misconfigured. Close and open it "
2015                        "again.");
2016                 goto error;
2017         }
2018
2019         if (cam->io == IO_NONE) {
2020                 if (!sn9c102_request_buffers(cam, cam->nreadbuffers,
2021                                              IO_READ)) {
2022                         DBG(1, "poll() failed, not enough memory");
2023                         goto error;
2024                 }
2025                 cam->io = IO_READ;
2026                 cam->stream = STREAM_ON;
2027         }
2028
2029         if (cam->io == IO_READ) {
2030                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2031                 list_for_each_entry(f, &cam->outqueue, frame)
2032                         f->state = F_UNUSED;
2033                 INIT_LIST_HEAD(&cam->outqueue);
2034                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2035                 sn9c102_queue_unusedframes(cam);
2036         }
2037
2038         poll_wait(filp, &cam->wait_frame, wait);
2039
2040         if (!list_empty(&cam->outqueue))
2041                 mask |= POLLIN | POLLRDNORM;
2042
2043         mutex_unlock(&cam->fileop_mutex);
2044
2045         return mask;
2046
2047 error:
2048         mutex_unlock(&cam->fileop_mutex);
2049         return POLLERR;
2050 }
2051
2052
2053 static void sn9c102_vm_open(struct vm_area_struct* vma)
2054 {
2055         struct sn9c102_frame_t* f = vma->vm_private_data;
2056         f->vma_use_count++;
2057 }
2058
2059
2060 static void sn9c102_vm_close(struct vm_area_struct* vma)
2061 {
2062         /* NOTE: buffers are not freed here */
2063         struct sn9c102_frame_t* f = vma->vm_private_data;
2064         f->vma_use_count--;
2065 }
2066
2067
2068 static struct vm_operations_struct sn9c102_vm_ops = {
2069         .open = sn9c102_vm_open,
2070         .close = sn9c102_vm_close,
2071 };
2072
2073
2074 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
2075 {
2076         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2077         unsigned long size = vma->vm_end - vma->vm_start,
2078                       start = vma->vm_start;
2079         void *pos;
2080         u32 i;
2081
2082         if (mutex_lock_interruptible(&cam->fileop_mutex))
2083                 return -ERESTARTSYS;
2084
2085         if (cam->state & DEV_DISCONNECTED) {
2086                 DBG(1, "Device not present");
2087                 mutex_unlock(&cam->fileop_mutex);
2088                 return -ENODEV;
2089         }
2090
2091         if (cam->state & DEV_MISCONFIGURED) {
2092                 DBG(1, "The camera is misconfigured. Close and open it "
2093                        "again.");
2094                 mutex_unlock(&cam->fileop_mutex);
2095                 return -EIO;
2096         }
2097
2098         if (!(vma->vm_flags & (VM_WRITE | VM_READ))) {
2099                 mutex_unlock(&cam->fileop_mutex);
2100                 return -EACCES;
2101         }
2102
2103         if (cam->io != IO_MMAP ||
2104             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
2105                 mutex_unlock(&cam->fileop_mutex);
2106                 return -EINVAL;
2107         }
2108
2109         for (i = 0; i < cam->nbuffers; i++) {
2110                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
2111                         break;
2112         }
2113         if (i == cam->nbuffers) {
2114                 mutex_unlock(&cam->fileop_mutex);
2115                 return -EINVAL;
2116         }
2117
2118         vma->vm_flags |= VM_IO;
2119         vma->vm_flags |= VM_RESERVED;
2120
2121         pos = cam->frame[i].bufmem;
2122         while (size > 0) { /* size is page-aligned */
2123                 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
2124                         mutex_unlock(&cam->fileop_mutex);
2125                         return -EAGAIN;
2126                 }
2127                 start += PAGE_SIZE;
2128                 pos += PAGE_SIZE;
2129                 size -= PAGE_SIZE;
2130         }
2131
2132         vma->vm_ops = &sn9c102_vm_ops;
2133         vma->vm_private_data = &cam->frame[i];
2134         sn9c102_vm_open(vma);
2135
2136         mutex_unlock(&cam->fileop_mutex);
2137
2138         return 0;
2139 }
2140
2141 /*****************************************************************************/
2142
2143 static int
2144 sn9c102_vidioc_querycap(struct sn9c102_device* cam, void __user * arg)
2145 {
2146         struct v4l2_capability cap = {
2147                 .driver = "sn9c102",
2148                 .version = SN9C102_MODULE_VERSION_CODE,
2149                 .capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2150                                 V4L2_CAP_STREAMING,
2151         };
2152
2153         strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
2154         if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
2155                 strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
2156                         sizeof(cap.bus_info));
2157
2158         if (copy_to_user(arg, &cap, sizeof(cap)))
2159                 return -EFAULT;
2160
2161         return 0;
2162 }
2163
2164
2165 static int
2166 sn9c102_vidioc_enuminput(struct sn9c102_device* cam, void __user * arg)
2167 {
2168         struct v4l2_input i;
2169
2170         if (copy_from_user(&i, arg, sizeof(i)))
2171                 return -EFAULT;
2172
2173         if (i.index)
2174                 return -EINVAL;
2175
2176         memset(&i, 0, sizeof(i));
2177         strcpy(i.name, "Camera");
2178         i.type = V4L2_INPUT_TYPE_CAMERA;
2179
2180         if (copy_to_user(arg, &i, sizeof(i)))
2181                 return -EFAULT;
2182
2183         return 0;
2184 }
2185
2186
2187 static int
2188 sn9c102_vidioc_g_input(struct sn9c102_device* cam, void __user * arg)
2189 {
2190         int index = 0;
2191
2192         if (copy_to_user(arg, &index, sizeof(index)))
2193                 return -EFAULT;
2194
2195         return 0;
2196 }
2197
2198
2199 static int
2200 sn9c102_vidioc_s_input(struct sn9c102_device* cam, void __user * arg)
2201 {
2202         int index;
2203
2204         if (copy_from_user(&index, arg, sizeof(index)))
2205                 return -EFAULT;
2206
2207         if (index != 0)
2208                 return -EINVAL;
2209
2210         return 0;
2211 }
2212
2213
2214 static int
2215 sn9c102_vidioc_query_ctrl(struct sn9c102_device* cam, void __user * arg)
2216 {
2217         struct sn9c102_sensor* s = &cam->sensor;
2218         struct v4l2_queryctrl qc;
2219         u8 i;
2220
2221         if (copy_from_user(&qc, arg, sizeof(qc)))
2222                 return -EFAULT;
2223
2224         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2225                 if (qc.id && qc.id == s->qctrl[i].id) {
2226                         memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
2227                         if (copy_to_user(arg, &qc, sizeof(qc)))
2228                                 return -EFAULT;
2229                         return 0;
2230                 }
2231
2232         return -EINVAL;
2233 }
2234
2235
2236 static int
2237 sn9c102_vidioc_g_ctrl(struct sn9c102_device* cam, void __user * arg)
2238 {
2239         struct sn9c102_sensor* s = &cam->sensor;
2240         struct v4l2_control ctrl;
2241         int err = 0;
2242         u8 i;
2243
2244         if (!s->get_ctrl && !s->set_ctrl)
2245                 return -EINVAL;
2246
2247         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2248                 return -EFAULT;
2249
2250         if (!s->get_ctrl) {
2251                 for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2252                         if (ctrl.id && ctrl.id == s->qctrl[i].id) {
2253                                 ctrl.value = s->_qctrl[i].default_value;
2254                                 goto exit;
2255                         }
2256                 return -EINVAL;
2257         } else
2258                 err = s->get_ctrl(cam, &ctrl);
2259
2260 exit:
2261         if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
2262                 return -EFAULT;
2263
2264         PDBGG("VIDIOC_G_CTRL: id %lu, value %lu",
2265               (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2266
2267         return err;
2268 }
2269
2270
2271 static int
2272 sn9c102_vidioc_s_ctrl(struct sn9c102_device* cam, void __user * arg)
2273 {
2274         struct sn9c102_sensor* s = &cam->sensor;
2275         struct v4l2_control ctrl;
2276         u8 i;
2277         int err = 0;
2278
2279         if (!s->set_ctrl)
2280                 return -EINVAL;
2281
2282         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
2283                 return -EFAULT;
2284
2285         for (i = 0; i < ARRAY_SIZE(s->qctrl); i++)
2286                 if (ctrl.id == s->qctrl[i].id) {
2287                         if (s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)
2288                                 return -EINVAL;
2289                         if (ctrl.value < s->qctrl[i].minimum ||
2290                             ctrl.value > s->qctrl[i].maximum)
2291                                 return -ERANGE;
2292                         ctrl.value -= ctrl.value % s->qctrl[i].step;
2293                         break;
2294                 }
2295
2296         if ((err = s->set_ctrl(cam, &ctrl)))
2297                 return err;
2298
2299         s->_qctrl[i].default_value = ctrl.value;
2300
2301         PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
2302               (unsigned long)ctrl.id, (unsigned long)ctrl.value);
2303
2304         return 0;
2305 }
2306
2307
2308 static int
2309 sn9c102_vidioc_cropcap(struct sn9c102_device* cam, void __user * arg)
2310 {
2311         struct v4l2_cropcap* cc = &(cam->sensor.cropcap);
2312
2313         cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2314         cc->pixelaspect.numerator = 1;
2315         cc->pixelaspect.denominator = 1;
2316
2317         if (copy_to_user(arg, cc, sizeof(*cc)))
2318                 return -EFAULT;
2319
2320         return 0;
2321 }
2322
2323
2324 static int
2325 sn9c102_vidioc_g_crop(struct sn9c102_device* cam, void __user * arg)
2326 {
2327         struct sn9c102_sensor* s = &cam->sensor;
2328         struct v4l2_crop crop = {
2329                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2330         };
2331
2332         memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
2333
2334         if (copy_to_user(arg, &crop, sizeof(crop)))
2335                 return -EFAULT;
2336
2337         return 0;
2338 }
2339
2340
2341 static int
2342 sn9c102_vidioc_s_crop(struct sn9c102_device* cam, void __user * arg)
2343 {
2344         struct sn9c102_sensor* s = &cam->sensor;
2345         struct v4l2_crop crop;
2346         struct v4l2_rect* rect;
2347         struct v4l2_rect* bounds = &(s->cropcap.bounds);
2348         struct v4l2_pix_format* pix_format = &(s->pix_format);
2349         u8 scale;
2350         const enum sn9c102_stream_state stream = cam->stream;
2351         const u32 nbuffers = cam->nbuffers;
2352         u32 i;
2353         int err = 0;
2354
2355         if (copy_from_user(&crop, arg, sizeof(crop)))
2356                 return -EFAULT;
2357
2358         rect = &(crop.c);
2359
2360         if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2361                 return -EINVAL;
2362
2363         if (cam->module_param.force_munmap)
2364                 for (i = 0; i < cam->nbuffers; i++)
2365                         if (cam->frame[i].vma_use_count) {
2366                                 DBG(3, "VIDIOC_S_CROP failed. "
2367                                        "Unmap the buffers first.");
2368                                 return -EBUSY;
2369                         }
2370
2371         /* Preserve R,G or B origin */
2372         rect->left = (s->_rect.left & 1L) ? rect->left | 1L : rect->left & ~1L;
2373         rect->top = (s->_rect.top & 1L) ? rect->top | 1L : rect->top & ~1L;
2374
2375         if (rect->width < 16)
2376                 rect->width = 16;
2377         if (rect->height < 16)
2378                 rect->height = 16;
2379         if (rect->width > bounds->width)
2380                 rect->width = bounds->width;
2381         if (rect->height > bounds->height)
2382                 rect->height = bounds->height;
2383         if (rect->left < bounds->left)
2384                 rect->left = bounds->left;
2385         if (rect->top < bounds->top)
2386                 rect->top = bounds->top;
2387         if (rect->left + rect->width > bounds->left + bounds->width)
2388                 rect->left = bounds->left+bounds->width - rect->width;
2389         if (rect->top + rect->height > bounds->top + bounds->height)
2390                 rect->top = bounds->top+bounds->height - rect->height;
2391
2392         rect->width &= ~15L;
2393         rect->height &= ~15L;
2394
2395         if (SN9C102_PRESERVE_IMGSCALE) {
2396                 /* Calculate the actual scaling factor */
2397                 u32 a, b;
2398                 a = rect->width * rect->height;
2399                 b = pix_format->width * pix_format->height;
2400                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2401         } else
2402                 scale = 1;
2403
2404         if (cam->stream == STREAM_ON)
2405                 if ((err = sn9c102_stream_interrupt(cam)))
2406                         return err;
2407
2408         if (copy_to_user(arg, &crop, sizeof(crop))) {
2409                 cam->stream = stream;
2410                 return -EFAULT;
2411         }
2412
2413         if (cam->module_param.force_munmap || cam->io == IO_READ)
2414                 sn9c102_release_buffers(cam);
2415
2416         err = sn9c102_set_crop(cam, rect);
2417         if (s->set_crop)
2418                 err += s->set_crop(cam, rect);
2419         err += sn9c102_set_scale(cam, scale);
2420
2421         if (err) { /* atomic, no rollback in ioctl() */
2422                 cam->state |= DEV_MISCONFIGURED;
2423                 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
2424                        "use the camera, close and open /dev/video%d again.",
2425                     cam->v4ldev->minor);
2426                 return -EIO;
2427         }
2428
2429         s->pix_format.width = rect->width/scale;
2430         s->pix_format.height = rect->height/scale;
2431         memcpy(&(s->_rect), rect, sizeof(*rect));
2432
2433         if ((cam->module_param.force_munmap || cam->io == IO_READ) &&
2434             nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2435                 cam->state |= DEV_MISCONFIGURED;
2436                 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
2437                        "use the camera, close and open /dev/video%d again.",
2438                     cam->v4ldev->minor);
2439                 return -ENOMEM;
2440         }
2441
2442         if (cam->io == IO_READ)
2443                 sn9c102_empty_framequeues(cam);
2444         else if (cam->module_param.force_munmap)
2445                 sn9c102_requeue_outqueue(cam);
2446
2447         cam->stream = stream;
2448
2449         return 0;
2450 }
2451
2452
2453 static int
2454 sn9c102_vidioc_enum_framesizes(struct sn9c102_device* cam, void __user * arg)
2455 {
2456         struct v4l2_frmsizeenum frmsize;
2457
2458         if (copy_from_user(&frmsize, arg, sizeof(frmsize)))
2459                 return -EFAULT;
2460
2461         if (frmsize.index != 0)
2462                 return -EINVAL;
2463
2464         switch (cam->bridge) {
2465         case BRIDGE_SN9C101:
2466         case BRIDGE_SN9C102:
2467         case BRIDGE_SN9C103:
2468                 if (frmsize.pixel_format != V4L2_PIX_FMT_SN9C10X &&
2469                     frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2470                         return -EINVAL;
2471         case BRIDGE_SN9C105:
2472         case BRIDGE_SN9C120:
2473                 if (frmsize.pixel_format != V4L2_PIX_FMT_JPEG &&
2474                     frmsize.pixel_format != V4L2_PIX_FMT_SBGGR8)
2475                         return -EINVAL;
2476         }
2477
2478         frmsize.type = V4L2_FRMSIZE_TYPE_STEPWISE;
2479         frmsize.stepwise.min_width = frmsize.stepwise.step_width = 16;
2480         frmsize.stepwise.min_height = frmsize.stepwise.step_height = 16;
2481         frmsize.stepwise.max_width = cam->sensor.cropcap.bounds.width;
2482         frmsize.stepwise.max_height = cam->sensor.cropcap.bounds.height;
2483         memset(&frmsize.reserved, 0, sizeof(frmsize.reserved));
2484
2485         if (copy_to_user(arg, &frmsize, sizeof(frmsize)))
2486                 return -EFAULT;
2487
2488         return 0;
2489 }
2490
2491
2492 static int
2493 sn9c102_vidioc_enum_fmt(struct sn9c102_device* cam, void __user * arg)
2494 {
2495         struct v4l2_fmtdesc fmtd;
2496
2497         if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
2498                 return -EFAULT;
2499
2500         if (fmtd.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2501                 return -EINVAL;
2502
2503         if (fmtd.index == 0) {
2504                 strcpy(fmtd.description, "bayer rgb");
2505                 fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
2506         } else if (fmtd.index == 1) {
2507                 switch (cam->bridge) {
2508                 case BRIDGE_SN9C101:
2509                 case BRIDGE_SN9C102:
2510                 case BRIDGE_SN9C103:
2511                         strcpy(fmtd.description, "compressed");
2512                         fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
2513                         break;
2514                 case BRIDGE_SN9C105:
2515                 case BRIDGE_SN9C120:
2516                         strcpy(fmtd.description, "JPEG");
2517                         fmtd.pixelformat = V4L2_PIX_FMT_JPEG;
2518                         break;
2519                 }
2520                 fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
2521         } else
2522                 return -EINVAL;
2523
2524         fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2525         memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
2526
2527         if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
2528                 return -EFAULT;
2529
2530         return 0;
2531 }
2532
2533
2534 static int
2535 sn9c102_vidioc_g_fmt(struct sn9c102_device* cam, void __user * arg)
2536 {
2537         struct v4l2_format format;
2538         struct v4l2_pix_format* pfmt = &(cam->sensor.pix_format);
2539
2540         if (copy_from_user(&format, arg, sizeof(format)))
2541                 return -EFAULT;
2542
2543         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2544                 return -EINVAL;
2545
2546         pfmt->colorspace = (pfmt->pixelformat == V4L2_PIX_FMT_JPEG) ?
2547                            V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2548         pfmt->bytesperline = (pfmt->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2549                               pfmt->pixelformat == V4L2_PIX_FMT_JPEG)
2550                              ? 0 : (pfmt->width * pfmt->priv) / 8;
2551         pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
2552         pfmt->field = V4L2_FIELD_NONE;
2553         memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
2554
2555         if (copy_to_user(arg, &format, sizeof(format)))
2556                 return -EFAULT;
2557
2558         return 0;
2559 }
2560
2561
2562 static int
2563 sn9c102_vidioc_try_s_fmt(struct sn9c102_device* cam, unsigned int cmd,
2564                          void __user * arg)
2565 {
2566         struct sn9c102_sensor* s = &cam->sensor;
2567         struct v4l2_format format;
2568         struct v4l2_pix_format* pix;
2569         struct v4l2_pix_format* pfmt = &(s->pix_format);
2570         struct v4l2_rect* bounds = &(s->cropcap.bounds);
2571         struct v4l2_rect rect;
2572         u8 scale;
2573         const enum sn9c102_stream_state stream = cam->stream;
2574         const u32 nbuffers = cam->nbuffers;
2575         u32 i;
2576         int err = 0;
2577
2578         if (copy_from_user(&format, arg, sizeof(format)))
2579                 return -EFAULT;
2580
2581         pix = &(format.fmt.pix);
2582
2583         if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2584                 return -EINVAL;
2585
2586         memcpy(&rect, &(s->_rect), sizeof(rect));
2587
2588         { /* calculate the actual scaling factor */
2589                 u32 a, b;
2590                 a = rect.width * rect.height;
2591                 b = pix->width * pix->height;
2592                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2593         }
2594
2595         rect.width = scale * pix->width;
2596         rect.height = scale * pix->height;
2597
2598         if (rect.width < 16)
2599                 rect.width = 16;
2600         if (rect.height < 16)
2601                 rect.height = 16;
2602         if (rect.width > bounds->left + bounds->width - rect.left)
2603                 rect.width = bounds->left + bounds->width - rect.left;
2604         if (rect.height > bounds->top + bounds->height - rect.top)
2605                 rect.height = bounds->top + bounds->height - rect.top;
2606
2607         rect.width &= ~15L;
2608         rect.height &= ~15L;
2609
2610         { /* adjust the scaling factor */
2611                 u32 a, b;
2612                 a = rect.width * rect.height;
2613                 b = pix->width * pix->height;
2614                 scale = b ? (u8)((a / b) < 4 ? 1 : ((a / b) < 16 ? 2 : 4)) : 1;
2615         }
2616
2617         pix->width = rect.width / scale;
2618         pix->height = rect.height / scale;
2619
2620         switch (cam->bridge) {
2621         case BRIDGE_SN9C101:
2622         case BRIDGE_SN9C102:
2623         case BRIDGE_SN9C103:
2624                 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2625                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2626                         pix->pixelformat = pfmt->pixelformat;
2627                 break;
2628         case BRIDGE_SN9C105:
2629         case BRIDGE_SN9C120:
2630                 if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
2631                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2632                         pix->pixelformat = pfmt->pixelformat;
2633                 break;
2634         }
2635         pix->priv = pfmt->priv; /* bpp */
2636         pix->colorspace = (pix->pixelformat == V4L2_PIX_FMT_JPEG) ?
2637                           V4L2_COLORSPACE_JPEG : V4L2_COLORSPACE_SRGB;
2638         pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X ||
2639                              pix->pixelformat == V4L2_PIX_FMT_JPEG)
2640                             ? 0 : (pix->width * pix->priv) / 8;
2641         pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2642         pix->field = V4L2_FIELD_NONE;
2643
2644         if (cmd == VIDIOC_TRY_FMT) {
2645                 if (copy_to_user(arg, &format, sizeof(format)))
2646                         return -EFAULT;
2647                 return 0;
2648         }
2649
2650         if (cam->module_param.force_munmap)
2651                 for (i = 0; i < cam->nbuffers; i++)
2652                         if (cam->frame[i].vma_use_count) {
2653                                 DBG(3, "VIDIOC_S_FMT failed. Unmap the "
2654                                        "buffers first.");
2655                                 return -EBUSY;
2656                         }
2657
2658         if (cam->stream == STREAM_ON)
2659                 if ((err = sn9c102_stream_interrupt(cam)))
2660                         return err;
2661
2662         if (copy_to_user(arg, &format, sizeof(format))) {
2663                 cam->stream = stream;
2664                 return -EFAULT;
2665         }
2666
2667         if (cam->module_param.force_munmap  || cam->io == IO_READ)
2668                 sn9c102_release_buffers(cam);
2669
2670         err += sn9c102_set_pix_format(cam, pix);
2671         err += sn9c102_set_crop(cam, &rect);
2672         if (s->set_pix_format)
2673                 err += s->set_pix_format(cam, pix);
2674         if (s->set_crop)
2675                 err += s->set_crop(cam, &rect);
2676         err += sn9c102_set_scale(cam, scale);
2677
2678         if (err) { /* atomic, no rollback in ioctl() */
2679                 cam->state |= DEV_MISCONFIGURED;
2680                 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2681                        "use the camera, close and open /dev/video%d again.",
2682                     cam->v4ldev->minor);
2683                 return -EIO;
2684         }
2685
2686         memcpy(pfmt, pix, sizeof(*pix));
2687         memcpy(&(s->_rect), &rect, sizeof(rect));
2688
2689         if ((cam->module_param.force_munmap  || cam->io == IO_READ) &&
2690             nbuffers != sn9c102_request_buffers(cam, nbuffers, cam->io)) {
2691                 cam->state |= DEV_MISCONFIGURED;
2692                 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2693                        "use the camera, close and open /dev/video%d again.",
2694                     cam->v4ldev->minor);
2695                 return -ENOMEM;
2696         }
2697
2698         if (cam->io == IO_READ)
2699                 sn9c102_empty_framequeues(cam);
2700         else if (cam->module_param.force_munmap)
2701                 sn9c102_requeue_outqueue(cam);
2702
2703         cam->stream = stream;
2704
2705         return 0;
2706 }
2707
2708
2709 static int
2710 sn9c102_vidioc_g_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2711 {
2712         if (copy_to_user(arg, &cam->compression, sizeof(cam->compression)))
2713                 return -EFAULT;
2714
2715         return 0;
2716 }
2717
2718
2719 static int
2720 sn9c102_vidioc_s_jpegcomp(struct sn9c102_device* cam, void __user * arg)
2721 {
2722         struct v4l2_jpegcompression jc;
2723         const enum sn9c102_stream_state stream = cam->stream;
2724         int err = 0;
2725
2726         if (copy_from_user(&jc, arg, sizeof(jc)))
2727                 return -EFAULT;
2728
2729         if (jc.quality != 0 && jc.quality != 1)
2730                 return -EINVAL;
2731
2732         if (cam->stream == STREAM_ON)
2733                 if ((err = sn9c102_stream_interrupt(cam)))
2734                         return err;
2735
2736         err += sn9c102_set_compression(cam, &jc);
2737         if (err) { /* atomic, no rollback in ioctl() */
2738                 cam->state |= DEV_MISCONFIGURED;
2739                 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2740                        "problems. To use the camera, close and open "
2741                        "/dev/video%d again.", cam->v4ldev->minor);
2742                 return -EIO;
2743         }
2744
2745         cam->compression.quality = jc.quality;
2746
2747         cam->stream = stream;
2748
2749         return 0;
2750 }
2751
2752
2753 static int
2754 sn9c102_vidioc_reqbufs(struct sn9c102_device* cam, void __user * arg)
2755 {
2756         struct v4l2_requestbuffers rb;
2757         u32 i;
2758         int err;
2759
2760         if (copy_from_user(&rb, arg, sizeof(rb)))
2761                 return -EFAULT;
2762
2763         if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2764             rb.memory != V4L2_MEMORY_MMAP)
2765                 return -EINVAL;
2766
2767         if (cam->io == IO_READ) {
2768                 DBG(3, "Close and open the device again to choose the mmap "
2769                        "I/O method");
2770                 return -EBUSY;
2771         }
2772
2773         for (i = 0; i < cam->nbuffers; i++)
2774                 if (cam->frame[i].vma_use_count) {
2775                         DBG(3, "VIDIOC_REQBUFS failed. Previous buffers are "
2776                                "still mapped.");
2777                         return -EBUSY;
2778                 }
2779
2780         if (cam->stream == STREAM_ON)
2781                 if ((err = sn9c102_stream_interrupt(cam)))
2782                         return err;
2783
2784         sn9c102_empty_framequeues(cam);
2785
2786         sn9c102_release_buffers(cam);
2787         if (rb.count)
2788                 rb.count = sn9c102_request_buffers(cam, rb.count, IO_MMAP);
2789
2790         if (copy_to_user(arg, &rb, sizeof(rb))) {
2791                 sn9c102_release_buffers(cam);
2792                 cam->io = IO_NONE;
2793                 return -EFAULT;
2794         }
2795
2796         cam->io = rb.count ? IO_MMAP : IO_NONE;
2797
2798         return 0;
2799 }
2800
2801
2802 static int
2803 sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
2804 {
2805         struct v4l2_buffer b;
2806
2807         if (copy_from_user(&b, arg, sizeof(b)))
2808                 return -EFAULT;
2809
2810         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2811             b.index >= cam->nbuffers || cam->io != IO_MMAP)
2812                 return -EINVAL;
2813
2814         memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2815
2816         if (cam->frame[b.index].vma_use_count)
2817                 b.flags |= V4L2_BUF_FLAG_MAPPED;
2818
2819         if (cam->frame[b.index].state == F_DONE)
2820                 b.flags |= V4L2_BUF_FLAG_DONE;
2821         else if (cam->frame[b.index].state != F_UNUSED)
2822                 b.flags |= V4L2_BUF_FLAG_QUEUED;
2823
2824         if (copy_to_user(arg, &b, sizeof(b)))
2825                 return -EFAULT;
2826
2827         return 0;
2828 }
2829
2830
2831 static int
2832 sn9c102_vidioc_qbuf(struct sn9c102_device* cam, void __user * arg)
2833 {
2834         struct v4l2_buffer b;
2835         unsigned long lock_flags;
2836
2837         if (copy_from_user(&b, arg, sizeof(b)))
2838                 return -EFAULT;
2839
2840         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2841             b.index >= cam->nbuffers || cam->io != IO_MMAP)
2842                 return -EINVAL;
2843
2844         if (cam->frame[b.index].state != F_UNUSED)
2845                 return -EINVAL;
2846
2847         cam->frame[b.index].state = F_QUEUED;
2848
2849         spin_lock_irqsave(&cam->queue_lock, lock_flags);
2850         list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2851         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2852
2853         PDBGG("Frame #%lu queued", (unsigned long)b.index);
2854
2855         return 0;
2856 }
2857
2858
2859 static int
2860 sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
2861                      void __user * arg)
2862 {
2863         struct v4l2_buffer b;
2864         struct sn9c102_frame_t *f;
2865         unsigned long lock_flags;
2866         long timeout;
2867         int err = 0;
2868
2869         if (copy_from_user(&b, arg, sizeof(b)))
2870                 return -EFAULT;
2871
2872         if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2873                 return -EINVAL;
2874
2875         if (list_empty(&cam->outqueue)) {
2876                 if (cam->stream == STREAM_OFF)
2877                         return -EINVAL;
2878                 if (filp->f_flags & O_NONBLOCK)
2879                         return -EAGAIN;
2880                 if (!cam->module_param.frame_timeout) {
2881                         err = wait_event_interruptible
2882                               ( cam->wait_frame,
2883                                 (!list_empty(&cam->outqueue)) ||
2884                                 (cam->state & DEV_DISCONNECTED) ||
2885                                 (cam->state & DEV_MISCONFIGURED) );
2886                         if (err)
2887                                 return err;
2888                 } else {
2889                         timeout = wait_event_interruptible_timeout
2890                                   ( cam->wait_frame,
2891                                     (!list_empty(&cam->outqueue)) ||
2892                                     (cam->state & DEV_DISCONNECTED) ||
2893                                     (cam->state & DEV_MISCONFIGURED),
2894                                     cam->module_param.frame_timeout *
2895                                     1000 * msecs_to_jiffies(1) );
2896                         if (timeout < 0)
2897                                 return timeout;
2898                         else if (timeout == 0 &&
2899                                  !(cam->state & DEV_DISCONNECTED)) {
2900                                 DBG(1, "Video frame timeout elapsed");
2901                                 return -EIO;
2902                         }
2903                 }
2904                 if (cam->state & DEV_DISCONNECTED)
2905                         return -ENODEV;
2906                 if (cam->state & DEV_MISCONFIGURED)
2907                         return -EIO;
2908         }
2909
2910         spin_lock_irqsave(&cam->queue_lock, lock_flags);
2911         f = list_entry(cam->outqueue.next, struct sn9c102_frame_t, frame);
2912         list_del(cam->outqueue.next);
2913         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2914
2915         f->state = F_UNUSED;
2916
2917         memcpy(&b, &f->buf, sizeof(b));
2918         if (f->vma_use_count)
2919                 b.flags |= V4L2_BUF_FLAG_MAPPED;
2920
2921         if (copy_to_user(arg, &b, sizeof(b)))
2922                 return -EFAULT;
2923
2924         PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index);
2925
2926         return 0;
2927 }
2928
2929
2930 static int
2931 sn9c102_vidioc_streamon(struct sn9c102_device* cam, void __user * arg)
2932 {
2933         int type;
2934
2935         if (copy_from_user(&type, arg, sizeof(type)))
2936                 return -EFAULT;
2937
2938         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2939                 return -EINVAL;
2940
2941         cam->stream = STREAM_ON;
2942
2943         DBG(3, "Stream on");
2944
2945         return 0;
2946 }
2947
2948
2949 static int
2950 sn9c102_vidioc_streamoff(struct sn9c102_device* cam, void __user * arg)
2951 {
2952         int type, err;
2953
2954         if (copy_from_user(&type, arg, sizeof(type)))
2955                 return -EFAULT;
2956
2957         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2958                 return -EINVAL;
2959
2960         if (cam->stream == STREAM_ON)
2961                 if ((err = sn9c102_stream_interrupt(cam)))
2962                         return err;
2963
2964         sn9c102_empty_framequeues(cam);
2965
2966         DBG(3, "Stream off");
2967
2968         return 0;
2969 }
2970
2971
2972 static int
2973 sn9c102_vidioc_g_parm(struct sn9c102_device* cam, void __user * arg)
2974 {
2975         struct v4l2_streamparm sp;
2976
2977         if (copy_from_user(&sp, arg, sizeof(sp)))
2978                 return -EFAULT;
2979
2980         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2981                 return -EINVAL;
2982
2983         sp.parm.capture.extendedmode = 0;
2984         sp.parm.capture.readbuffers = cam->nreadbuffers;
2985
2986         if (copy_to_user(arg, &sp, sizeof(sp)))
2987                 return -EFAULT;
2988
2989         return 0;
2990 }
2991
2992
2993 static int
2994 sn9c102_vidioc_s_parm(struct sn9c102_device* cam, void __user * arg)
2995 {
2996         struct v4l2_streamparm sp;
2997
2998         if (copy_from_user(&sp, arg, sizeof(sp)))
2999                 return -EFAULT;
3000
3001         if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3002                 return -EINVAL;
3003
3004         sp.parm.capture.extendedmode = 0;
3005
3006         if (sp.parm.capture.readbuffers == 0)
3007                 sp.parm.capture.readbuffers = cam->nreadbuffers;
3008
3009         if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
3010                 sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
3011
3012         if (copy_to_user(arg, &sp, sizeof(sp)))
3013                 return -EFAULT;
3014
3015         cam->nreadbuffers = sp.parm.capture.readbuffers;
3016
3017         return 0;
3018 }
3019
3020
3021 static int
3022 sn9c102_vidioc_enumaudio(struct sn9c102_device* cam, void __user * arg)
3023 {
3024         struct v4l2_audio audio;
3025
3026         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3027                 return -EINVAL;
3028
3029         if (copy_from_user(&audio, arg, sizeof(audio)))
3030                 return -EFAULT;
3031
3032         if (audio.index != 0)
3033                 return -EINVAL;
3034
3035         strcpy(audio.name, "Microphone");
3036         audio.capability = 0;
3037         audio.mode = 0;
3038
3039         if (copy_to_user(arg, &audio, sizeof(audio)))
3040                 return -EFAULT;
3041
3042         return 0;
3043 }
3044
3045
3046 static int
3047 sn9c102_vidioc_g_audio(struct sn9c102_device* cam, void __user * arg)
3048 {
3049         struct v4l2_audio audio;
3050
3051         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3052                 return -EINVAL;
3053
3054         if (copy_from_user(&audio, arg, sizeof(audio)))
3055                 return -EFAULT;
3056
3057         memset(&audio, 0, sizeof(audio));
3058         strcpy(audio.name, "Microphone");
3059
3060         if (copy_to_user(arg, &audio, sizeof(audio)))
3061                 return -EFAULT;
3062
3063         return 0;
3064 }
3065
3066
3067 static int
3068 sn9c102_vidioc_s_audio(struct sn9c102_device* cam, void __user * arg)
3069 {
3070         struct v4l2_audio audio;
3071
3072         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
3073                 return -EINVAL;
3074
3075         if (copy_from_user(&audio, arg, sizeof(audio)))
3076                 return -EFAULT;
3077
3078         if (audio.index != 0)
3079                 return -EINVAL;
3080
3081         return 0;
3082 }
3083
3084
3085 static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
3086                               unsigned int cmd, void __user * arg)
3087 {
3088         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3089
3090         switch (cmd) {
3091
3092         case VIDIOC_QUERYCAP:
3093                 return sn9c102_vidioc_querycap(cam, arg);
3094
3095         case VIDIOC_ENUMINPUT:
3096                 return sn9c102_vidioc_enuminput(cam, arg);
3097
3098         case VIDIOC_G_INPUT:
3099                 return sn9c102_vidioc_g_input(cam, arg);
3100
3101         case VIDIOC_S_INPUT:
3102                 return sn9c102_vidioc_s_input(cam, arg);
3103
3104         case VIDIOC_QUERYCTRL:
3105                 return sn9c102_vidioc_query_ctrl(cam, arg);
3106
3107         case VIDIOC_G_CTRL:
3108                 return sn9c102_vidioc_g_ctrl(cam, arg);
3109
3110         case VIDIOC_S_CTRL:
3111                 return sn9c102_vidioc_s_ctrl(cam, arg);
3112
3113         case VIDIOC_CROPCAP:
3114                 return sn9c102_vidioc_cropcap(cam, arg);
3115
3116         case VIDIOC_G_CROP:
3117                 return sn9c102_vidioc_g_crop(cam, arg);
3118
3119         case VIDIOC_S_CROP:
3120                 return sn9c102_vidioc_s_crop(cam, arg);
3121
3122         case VIDIOC_ENUM_FRAMESIZES:
3123                 return sn9c102_vidioc_enum_framesizes(cam, arg);
3124
3125         case VIDIOC_ENUM_FMT:
3126                 return sn9c102_vidioc_enum_fmt(cam, arg);
3127
3128         case VIDIOC_G_FMT:
3129                 return sn9c102_vidioc_g_fmt(cam, arg);
3130
3131         case VIDIOC_TRY_FMT:
3132         case VIDIOC_S_FMT:
3133                 return sn9c102_vidioc_try_s_fmt(cam, cmd, arg);
3134
3135         case VIDIOC_G_JPEGCOMP:
3136                 return sn9c102_vidioc_g_jpegcomp(cam, arg);
3137
3138         case VIDIOC_S_JPEGCOMP:
3139                 return sn9c102_vidioc_s_jpegcomp(cam, arg);
3140
3141         case VIDIOC_REQBUFS:
3142                 return sn9c102_vidioc_reqbufs(cam, arg);
3143
3144         case VIDIOC_QUERYBUF:
3145                 return sn9c102_vidioc_querybuf(cam, arg);
3146
3147         case VIDIOC_QBUF:
3148                 return sn9c102_vidioc_qbuf(cam, arg);
3149
3150         case VIDIOC_DQBUF:
3151                 return sn9c102_vidioc_dqbuf(cam, filp, arg);
3152
3153         case VIDIOC_STREAMON:
3154                 return sn9c102_vidioc_streamon(cam, arg);
3155
3156         case VIDIOC_STREAMOFF:
3157                 return sn9c102_vidioc_streamoff(cam, arg);
3158
3159         case VIDIOC_G_PARM:
3160                 return sn9c102_vidioc_g_parm(cam, arg);
3161
3162         case VIDIOC_S_PARM:
3163                 return sn9c102_vidioc_s_parm(cam, arg);
3164
3165         case VIDIOC_ENUMAUDIO:
3166                 return sn9c102_vidioc_enumaudio(cam, arg);
3167
3168         case VIDIOC_G_AUDIO:
3169                 return sn9c102_vidioc_g_audio(cam, arg);
3170
3171         case VIDIOC_S_AUDIO:
3172                 return sn9c102_vidioc_s_audio(cam, arg);
3173
3174         case VIDIOC_G_STD:
3175         case VIDIOC_S_STD:
3176         case VIDIOC_QUERYSTD:
3177         case VIDIOC_ENUMSTD:
3178         case VIDIOC_QUERYMENU:
3179         case VIDIOC_ENUM_FRAMEINTERVALS:
3180                 return -EINVAL;
3181
3182         default:
3183                 return -EINVAL;
3184
3185         }
3186 }
3187
3188
3189 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
3190                          unsigned int cmd, unsigned long arg)
3191 {
3192         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
3193         int err = 0;
3194
3195         if (mutex_lock_interruptible(&cam->fileop_mutex))
3196                 return -ERESTARTSYS;
3197
3198         if (cam->state & DEV_DISCONNECTED) {
3199                 DBG(1, "Device not present");
3200                 mutex_unlock(&cam->fileop_mutex);
3201                 return -ENODEV;
3202         }
3203
3204         if (cam->state & DEV_MISCONFIGURED) {
3205                 DBG(1, "The camera is misconfigured. Close and open it "
3206                        "again.");
3207                 mutex_unlock(&cam->fileop_mutex);
3208                 return -EIO;
3209         }
3210
3211         V4LDBG(3, "sn9c102", cmd);
3212
3213         err = sn9c102_ioctl_v4l2(inode, filp, cmd, (void __user *)arg);
3214
3215         mutex_unlock(&cam->fileop_mutex);
3216
3217         return err;
3218 }
3219
3220 /*****************************************************************************/
3221
3222 static const struct file_operations sn9c102_fops = {
3223         .owner = THIS_MODULE,
3224         .open = sn9c102_open,
3225         .release = sn9c102_release,
3226         .ioctl = sn9c102_ioctl,
3227         .compat_ioctl = v4l_compat_ioctl32,
3228         .read = sn9c102_read,
3229         .poll = sn9c102_poll,
3230         .mmap = sn9c102_mmap,
3231         .llseek = no_llseek,
3232 };
3233
3234 /*****************************************************************************/
3235
3236 /* It exists a single interface only. We do not need to validate anything. */
3237 static int
3238 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
3239 {
3240         struct usb_device *udev = interface_to_usbdev(intf);
3241         struct sn9c102_device* cam;
3242         static unsigned int dev_nr = 0;
3243         unsigned int i;
3244         int err = 0, r;
3245
3246         if (!(cam = kzalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
3247                 return -ENOMEM;
3248
3249         cam->usbdev = udev;
3250
3251         if (!(cam->control_buffer = kzalloc(8, GFP_KERNEL))) {
3252                 DBG(1, "kzalloc() failed");
3253                 err = -ENOMEM;
3254                 goto fail;
3255         }
3256
3257         if (!(cam->v4ldev = video_device_alloc())) {
3258                 DBG(1, "video_device_alloc() failed");
3259                 err = -ENOMEM;
3260                 goto fail;
3261         }
3262
3263         r = sn9c102_read_reg(cam, 0x00);
3264         if (r < 0 || (r != 0x10 && r != 0x11 && r != 0x12)) {
3265                 DBG(1, "Sorry, this is not a SN9C1xx-based camera "
3266                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3267                 err = -ENODEV;
3268                 goto fail;
3269         }
3270
3271         cam->bridge = id->driver_info;
3272         switch (cam->bridge) {
3273         case BRIDGE_SN9C101:
3274         case BRIDGE_SN9C102:
3275                 DBG(2, "SN9C10[12] PC Camera Controller detected "
3276                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3277                 break;
3278         case BRIDGE_SN9C103:
3279                 DBG(2, "SN9C103 PC Camera Controller detected "
3280                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3281                 break;
3282         case BRIDGE_SN9C105:
3283                 DBG(2, "SN9C105 PC Camera Controller detected "
3284                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3285                 break;
3286         case BRIDGE_SN9C120:
3287                 DBG(2, "SN9C120 PC Camera Controller detected "
3288                        "(vid:pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
3289                 break;
3290         }
3291
3292         for  (i = 0; i < ARRAY_SIZE(sn9c102_sensor_table); i++) {
3293                 err = sn9c102_sensor_table[i](cam);
3294                 if (!err)
3295                         break;
3296         }
3297
3298         if (!err) {
3299                 DBG(2, "%s image sensor detected", cam->sensor.name);
3300                 DBG(3, "Support for %s maintained by %s",
3301                     cam->sensor.name, cam->sensor.maintainer);
3302         } else {
3303                 DBG(1, "No supported image sensor detected for this bridge");
3304                 err = -ENODEV;
3305                 goto fail;
3306         }
3307
3308         if (!(cam->bridge & cam->sensor.supported_bridge)) {
3309                 DBG(1, "Bridge not supported");
3310                 err = -ENODEV;
3311                 goto fail;
3312         }
3313
3314         if (sn9c102_init(cam)) {
3315                 DBG(1, "Initialization failed. I will retry on open().");
3316                 cam->state |= DEV_MISCONFIGURED;
3317         }
3318
3319         strcpy(cam->v4ldev->name, "SN9C1xx PC Camera");
3320         cam->v4ldev->owner = THIS_MODULE;
3321         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
3322         cam->v4ldev->fops = &sn9c102_fops;
3323         cam->v4ldev->minor = video_nr[dev_nr];
3324         cam->v4ldev->release = video_device_release;
3325
3326         init_completion(&cam->probe);
3327
3328         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
3329                                     video_nr[dev_nr]);
3330         if (err) {
3331                 DBG(1, "V4L2 device registration failed");
3332                 if (err == -ENFILE && video_nr[dev_nr] == -1)
3333                         DBG(1, "Free /dev/videoX node not found");
3334                 video_nr[dev_nr] = -1;
3335                 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3336                 complete_all(&cam->probe);
3337                 goto fail;
3338         }
3339
3340         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor);
3341
3342         video_set_drvdata(cam->v4ldev, cam);
3343         cam->module_param.force_munmap = force_munmap[dev_nr];
3344         cam->module_param.frame_timeout = frame_timeout[dev_nr];
3345
3346         dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
3347
3348 #ifdef CONFIG_VIDEO_ADV_DEBUG
3349         err = sn9c102_create_sysfs(cam);
3350         if (!err)
3351                 DBG(2, "Optional device control through 'sysfs' "
3352                        "interface ready");
3353         else
3354                 DBG(2, "Failed to create optional 'sysfs' interface for "
3355                        "device controlling. Error #%d", err);
3356 #else
3357         DBG(2, "Optional device control through 'sysfs' interface disabled");
3358         DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
3359                "configuration option to enable it.");
3360 #endif
3361
3362         usb_set_intfdata(intf, cam);
3363         kref_init(&cam->kref);
3364         usb_get_dev(cam->usbdev);
3365
3366         complete_all(&cam->probe);
3367
3368         return 0;
3369
3370 fail:
3371         if (cam) {
3372                 kfree(cam->control_buffer);
3373                 if (cam->v4ldev)
3374                         video_device_release(cam->v4ldev);
3375                 kfree(cam);
3376         }
3377         return err;
3378 }
3379
3380
3381 static void sn9c102_usb_disconnect(struct usb_interface* intf)
3382 {
3383         struct sn9c102_device* cam;
3384
3385         down_write(&sn9c102_dev_lock);
3386
3387         cam = usb_get_intfdata(intf);
3388
3389         DBG(2, "Disconnecting %s...", cam->v4ldev->name);
3390
3391         if (cam->users) {
3392                 DBG(2, "Device /dev/video%d is open! Deregistration and "
3393                        "memory deallocation are deferred.",
3394                     cam->v4ldev->minor);
3395                 cam->state |= DEV_MISCONFIGURED;
3396                 sn9c102_stop_transfer(cam);
3397                 cam->state |= DEV_DISCONNECTED;
3398                 wake_up_interruptible(&cam->wait_frame);
3399                 wake_up(&cam->wait_stream);
3400         } else
3401                 cam->state |= DEV_DISCONNECTED;
3402
3403         wake_up_interruptible_all(&cam->wait_open);
3404
3405         kref_put(&cam->kref, sn9c102_release_resources);
3406
3407         up_write(&sn9c102_dev_lock);
3408 }
3409
3410
3411 static struct usb_driver sn9c102_usb_driver = {
3412         .name =       "sn9c102",
3413         .id_table =   sn9c102_id_table,
3414         .probe =      sn9c102_usb_probe,
3415         .disconnect = sn9c102_usb_disconnect,
3416 };
3417
3418 /*****************************************************************************/
3419
3420 static int __init sn9c102_module_init(void)
3421 {
3422         int err = 0;
3423
3424         KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION);
3425         KDBG(3, SN9C102_MODULE_AUTHOR);
3426
3427         if ((err = usb_register(&sn9c102_usb_driver)))
3428                 KDBG(1, "usb_register() failed");
3429
3430         return err;
3431 }
3432
3433
3434 static void __exit sn9c102_module_exit(void)
3435 {
3436         usb_deregister(&sn9c102_usb_driver);
3437 }
3438
3439
3440 module_init(sn9c102_module_init);
3441 module_exit(sn9c102_module_exit);