drivers/staging/media/sn9c102/sn9c102_core.c

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