SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/sn9c102/sn9c102_core.c

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