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