drivers/usb/media/sn9c102_core.c

   1 /***************************************************************************
   2  * V4L2 driver for SN9C10x PC Camera Controllers                           *
   3  *                                                                         *
   4  * Copyright (C) 2004 by Luca Risolia <luca.risolia@studio.unibo.it>       *
   5  *                                                                         *
   6  * This program is free software; you can redistribute it and/or modify    *
   7  * it under the terms of the GNU General Public License as published by    *
   8  * the Free Software Foundation; either version 2 of the License, or       *
   9  * (at your option) any later version.                                     *
  10  *                                                                         *
  11  * This program is distributed in the hope that it will be useful,         *
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  14  * GNU General Public License for more details.                            *
  15  *                                                                         *
  16  * You should have received a copy of the GNU General Public License       *
  17  * along with this program; if not, write to the Free Software             *
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
  19  ***************************************************************************/
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/kernel.h>
  24 #include <linux/param.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/errno.h>
  27 #include <linux/slab.h>
  28 #include <linux/string.h>
  29 #include <linux/device.h>
  30 #include <linux/fs.h>
  31 #include <linux/delay.h>
  32 #include <linux/stddef.h>
  33 #include <linux/compiler.h>
  34 #include <linux/ioctl.h>
  35 #include <linux/poll.h>
  36 #include <linux/stat.h>
  37 #include <linux/mm.h>
  38 #include <linux/vmalloc.h>
  39 #include <linux/page-flags.h>
  40 #include <asm/page.h>
  41 #include <asm/uaccess.h>
  42
  43 #include "sn9c102.h"
  44
  45 /*****************************************************************************/
  46
  47 MODULE_DEVICE_TABLE(usb, sn9c102_id_table);
  48
  49 MODULE_AUTHOR(SN9C102_MODULE_AUTHOR " " SN9C102_AUTHOR_EMAIL);
  50 MODULE_DESCRIPTION(SN9C102_MODULE_NAME);
  51 MODULE_VERSION(SN9C102_MODULE_VERSION);
  52 MODULE_LICENSE(SN9C102_MODULE_LICENSE);
  53
  54 static short video_nr[] = {[0 ... SN9C102_MAX_DEVICES-1] = -1};
  55 module_param_array(video_nr, short, NULL, 0444);
  56 MODULE_PARM_DESC(video_nr,
  57                  "\n<-1|n[,...]> Specify V4L2 minor mode number."
  58                  "\n -1 = use next available (default)"
  59                  "\n  n = use minor number n (integer >= 0)"
  60                  "\nYou can specify up to "__MODULE_STRING(SN9C102_MAX_DEVICES)
  61                  " cameras this way."
  62                  "\nFor example:"
  63                  "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
  64                  "\nthe second camera and use auto for the first"
  65                  "\none and for every other camera."
  66                  "\n");
  67
  68 #ifdef SN9C102_DEBUG
  69 static unsigned short debug = SN9C102_DEBUG_LEVEL;
  70 module_param(debug, ushort, 0644);
  71 MODULE_PARM_DESC(debug,
  72                  "\n<n> Debugging information level, from 0 to 3:"
  73                  "\n0 = none (use carefully)"
  74                  "\n1 = critical errors"
  75                  "\n2 = significant informations"
  76                  "\n3 = more verbose messages"
  77                  "\nLevel 3 is useful for testing only, when only "
  78                  "one device is used."
  79                  "\nDefault value is "__MODULE_STRING(SN9C102_DEBUG_LEVEL)"."
  80                  "\n");
  81 #endif
  82
  83 /*****************************************************************************/
  84
  85 typedef char sn9c102_sof_header_t[12];
  86 typedef char sn9c102_eof_header_t[4];
  87
  88 static sn9c102_sof_header_t sn9c102_sof_header[] = {
  89         {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x00},
  90         {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96, 0x01},
  91 };
  92
  93
  94 static sn9c102_eof_header_t sn9c102_eof_header[] = {
  95         {0x00, 0x00, 0x00, 0x00},
  96         {0x40, 0x00, 0x00, 0x00},
  97         {0x80, 0x00, 0x00, 0x00},
  98         {0xc0, 0x00, 0x00, 0x00},
  99 };
 100
 101 /*****************************************************************************/
 102
 103 static void* rvmalloc(size_t size)
 104 {
 105         void* mem;
 106         unsigned long adr;
 107
 108         size = PAGE_ALIGN(size);
 109
 110         mem = vmalloc_32((unsigned long)size);
 111         if (!mem)
 112                 return NULL;
 113
 114         memset(mem, 0, size);
 115
 116         adr = (unsigned long)mem;
 117         while (size > 0) {
 118                 SetPageReserved(vmalloc_to_page((void *)adr));
 119                 adr += PAGE_SIZE;
 120                 size -= PAGE_SIZE;
 121         }
 122
 123         return mem;
 124 }
 125
 126
 127 static void rvfree(void* mem, size_t size)
 128 {
 129         unsigned long adr;
 130
 131         if (!mem)
 132                 return;
 133
 134         size = PAGE_ALIGN(size);
 135
 136         adr = (unsigned long)mem;
 137         while (size > 0) {
 138                 ClearPageReserved(vmalloc_to_page((void *)adr));
 139                 adr += PAGE_SIZE;
 140                 size -= PAGE_SIZE;
 141         }
 142
 143         vfree(mem);
 144 }
 145
 146
 147 static u32 sn9c102_request_buffers(struct sn9c102_device* cam, u32 count)
 148 {
 149         struct v4l2_pix_format* p = &(cam->sensor->pix_format);
 150         const size_t imagesize = (p->width * p->height * p->priv)/8;
 151         void* buff = NULL;
 152         u32 i;
 153
 154         if (count > SN9C102_MAX_FRAMES)
 155                 count = SN9C102_MAX_FRAMES;
 156
 157         cam->nbuffers = count;
 158         while (cam->nbuffers > 0) {
 159                 if ((buff = rvmalloc(cam->nbuffers * PAGE_ALIGN(imagesize))))
 160                         break;
 161                 cam->nbuffers--;
 162         }
 163
 164         for (i = 0; i < cam->nbuffers; i++) {
 165                 cam->frame[i].bufmem = buff + i*PAGE_ALIGN(imagesize);
 166                 cam->frame[i].buf.index = i;
 167                 cam->frame[i].buf.m.offset = i*PAGE_ALIGN(imagesize);
 168                 cam->frame[i].buf.length = imagesize;
 169                 cam->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 170                 cam->frame[i].buf.sequence = 0;
 171                 cam->frame[i].buf.field = V4L2_FIELD_NONE;
 172                 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
 173                 cam->frame[i].buf.flags = 0;
 174         }
 175
 176         return cam->nbuffers;
 177 }
 178
 179
 180 static void sn9c102_release_buffers(struct sn9c102_device* cam)
 181 {
 182         if (cam->nbuffers) {
 183                 rvfree(cam->frame[0].bufmem,
 184                        cam->nbuffers * cam->frame[0].buf.length);
 185                 cam->nbuffers = 0;
 186         }
 187 }
 188
 189
 190 static void sn9c102_empty_framequeues(struct sn9c102_device* cam)
 191 {
 192         u32 i;
 193
 194         INIT_LIST_HEAD(&cam->inqueue);
 195         INIT_LIST_HEAD(&cam->outqueue);
 196
 197         for (i = 0; i < SN9C102_MAX_FRAMES; i++) {
 198                 cam->frame[i].state = F_UNUSED;
 199                 cam->frame[i].buf.bytesused = 0;
 200         }
 201 }
 202
 203
 204 static void sn9c102_queue_unusedframes(struct sn9c102_device* cam)
 205 {
 206         unsigned long lock_flags;
 207         u32 i;
 208
 209         for (i = 0; i < cam->nbuffers; i++)
 210                 if (cam->frame[i].state == F_UNUSED) {
 211                         cam->frame[i].state = F_QUEUED;
 212                         spin_lock_irqsave(&cam->queue_lock, lock_flags);
 213                         list_add_tail(&cam->frame[i].frame, &cam->inqueue);
 214                         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
 215                 }
 216 }
 217
 218 /*****************************************************************************/
 219
 220 int sn9c102_write_reg(struct sn9c102_device* cam, u8 value, u16 index)
 221 {
 222         struct usb_device* udev = cam->usbdev;
 223         u8* buff = cam->control_buffer;
 224         int res;
 225
 226         *buff = value;
 227
 228         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 229                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 230         if (res < 0) {
 231                 DBG(3, "Failed to write a register (value 0x%02X, index "
 232                        "0x%02X, error %d)", value, index, res)
 233                 return -1;
 234         }
 235
 236         cam->reg[index] = value;
 237
 238         return 0;
 239 }
 240
 241
 242 /* NOTE: reading some registers always returns 0 */
 243 static int sn9c102_read_reg(struct sn9c102_device* cam, u16 index)
 244 {
 245         struct usb_device* udev = cam->usbdev;
 246         u8* buff = cam->control_buffer;
 247         int res;
 248
 249         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 250                               index, 0, buff, 1, SN9C102_CTRL_TIMEOUT);
 251         if (res < 0)
 252                 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
 253                     index, res)
 254
 255         return (res >= 0) ? (int)(*buff) : -1;
 256 }
 257
 258
 259 int sn9c102_pread_reg(struct sn9c102_device* cam, u16 index)
 260 {
 261         if (index > 0x1f)
 262                 return -EINVAL;
 263
 264         return cam->reg[index];
 265 }
 266
 267
 268 static int
 269 sn9c102_i2c_wait(struct sn9c102_device* cam, struct sn9c102_sensor* sensor)
 270 {
 271         int i, r;
 272
 273         for (i = 1; i <= 5; i++) {
 274                 r = sn9c102_read_reg(cam, 0x08);
 275                 if (r < 0)
 276                         return -EIO;
 277                 if (r & 0x04)
 278                         return 0;
 279                 if (sensor->frequency & SN9C102_I2C_400KHZ)
 280                         udelay(5*8);
 281                 else
 282                         udelay(16*8);
 283         }
 284         return -EBUSY;
 285 }
 286
 287
 288 static int
 289 sn9c102_i2c_detect_read_error(struct sn9c102_device* cam,
 290                               struct sn9c102_sensor* sensor)
 291 {
 292         int r;
 293         r = sn9c102_read_reg(cam, 0x08);
 294         return (r < 0 || (r >= 0 && !(r & 0x08))) ? -EIO : 0;
 295 }
 296
 297
 298 static int
 299 sn9c102_i2c_detect_write_error(struct sn9c102_device* cam,
 300                                struct sn9c102_sensor* sensor)
 301 {
 302         int r;
 303         r = sn9c102_read_reg(cam, 0x08);
 304         return (r < 0 || (r >= 0 && (r & 0x08))) ? -EIO : 0;
 305 }
 306
 307
 308 int
 309 sn9c102_i2c_try_read(struct sn9c102_device* cam,
 310                      struct sn9c102_sensor* sensor, u8 address)
 311 {
 312         struct usb_device* udev = cam->usbdev;
 313         u8* data = cam->control_buffer;
 314         int err = 0, res;
 315
 316         /* Write cycle - address */
 317         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 318                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) | 0x10;
 319         data[1] = sensor->slave_write_id;
 320         data[2] = address;
 321         data[7] = 0x10;
 322         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 323                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 324         if (res < 0)
 325                 err += res;
 326
 327         err += sn9c102_i2c_wait(cam, sensor);
 328
 329         /* Read cycle - 1 byte */
 330         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 331                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0) |
 332                   0x10 | 0x02;
 333         data[1] = sensor->slave_read_id;
 334         data[7] = 0x10;
 335         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 336                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 337         if (res < 0)
 338                 err += res;
 339
 340         err += sn9c102_i2c_wait(cam, sensor);
 341
 342         /* The read byte will be placed in data[4] */
 343         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, 0xc1,
 344                               0x0a, 0, data, 5, SN9C102_CTRL_TIMEOUT);
 345         if (res < 0)
 346                 err += res;
 347
 348         err += sn9c102_i2c_detect_read_error(cam, sensor);
 349
 350         if (err)
 351                 DBG(3, "I2C read failed for %s image sensor", sensor->name)
 352
 353         PDBGG("I2C read: address 0x%02X, value: 0x%02X", address, data[4])
 354
 355         return err ? -1 : (int)data[4];
 356 }
 357
 358
 359 int
 360 sn9c102_i2c_try_raw_write(struct sn9c102_device* cam,
 361                           struct sn9c102_sensor* sensor, u8 n, u8 data0,
 362                           u8 data1, u8 data2, u8 data3, u8 data4, u8 data5)
 363 {
 364         struct usb_device* udev = cam->usbdev;
 365         u8* data = cam->control_buffer;
 366         int err = 0, res;
 367
 368         /* Write cycle. It usually is address + value */
 369         data[0] = ((sensor->interface == SN9C102_I2C_2WIRES) ? 0x80 : 0) |
 370                   ((sensor->frequency & SN9C102_I2C_400KHZ) ? 0x01 : 0)
 371                   | ((n - 1) << 4);
 372         data[1] = data0;
 373         data[2] = data1;
 374         data[3] = data2;
 375         data[4] = data3;
 376         data[5] = data4;
 377         data[6] = data5;
 378         data[7] = 0x14;
 379         res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x08, 0x41,
 380                               0x08, 0, data, 8, SN9C102_CTRL_TIMEOUT);
 381         if (res < 0)
 382                 err += res;
 383
 384         err += sn9c102_i2c_wait(cam, sensor);
 385         err += sn9c102_i2c_detect_write_error(cam, sensor);
 386
 387         if (err)
 388                 DBG(3, "I2C write failed for %s image sensor", sensor->name)
 389
 390         PDBGG("I2C raw write: %u bytes, data0 = 0x%02X, data1 = 0x%02X, "
 391               "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X",
 392               n, data0, data1, data2, data3, data4, data5)
 393
 394         return err ? -1 : 0;
 395 }
 396
 397
 398 int
 399 sn9c102_i2c_try_write(struct sn9c102_device* cam,
 400                       struct sn9c102_sensor* sensor, u8 address, u8 value)
 401 {
 402         return sn9c102_i2c_try_raw_write(cam, sensor, 3,
 403                                          sensor->slave_write_id, address,
 404                                          value, 0, 0, 0);
 405 }
 406
 407
 408 int sn9c102_i2c_read(struct sn9c102_device* cam, u8 address)
 409 {
 410         if (!cam->sensor)
 411                 return -1;
 412
 413         return sn9c102_i2c_try_read(cam, cam->sensor, address);
 414 }
 415
 416
 417 int sn9c102_i2c_write(struct sn9c102_device* cam, u8 address, u8 value)
 418 {
 419         if (!cam->sensor)
 420                 return -1;
 421
 422         return sn9c102_i2c_try_write(cam, cam->sensor, address, value);
 423 }
 424
 425 /*****************************************************************************/
 426
 427 static void*
 428 sn9c102_find_sof_header(struct sn9c102_device* cam, void* mem, size_t len)
 429 {
 430         size_t soflen = sizeof(sn9c102_sof_header_t), i;
 431         u8 j, n = sizeof(sn9c102_sof_header) / soflen;
 432
 433         for (i = 0; (len >= soflen) && (i <= len - soflen); i++)
 434                 for (j = 0; j < n; j++)
 435                         /* It's enough to compare 7 bytes */
 436                         if (!memcmp(mem + i, sn9c102_sof_header[j], 7))
 437                                 /* Skips the header */
 438                                 return mem + i + soflen;
 439
 440         return NULL;
 441 }
 442
 443
 444 static void*
 445 sn9c102_find_eof_header(struct sn9c102_device* cam, void* mem, size_t len)
 446 {
 447         size_t eoflen = sizeof(sn9c102_eof_header_t), i;
 448         unsigned j, n = sizeof(sn9c102_eof_header) / eoflen;
 449
 450         if (cam->sensor->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
 451                 return NULL; /* EOF header does not exist in compressed data */
 452
 453         for (i = 0; (len >= eoflen) && (i <= len - eoflen); i++)
 454                 for (j = 0; j < n; j++)
 455                         if (!memcmp(mem + i, sn9c102_eof_header[j], eoflen))
 456                                 return mem + i;
 457
 458         return NULL;
 459 }
 460
 461
 462 static void sn9c102_urb_complete(struct urb *urb, struct pt_regs* regs)
 463 {
 464         struct sn9c102_device* cam = urb->context;
 465         struct sn9c102_frame_t** f;
 466         unsigned long lock_flags;
 467         u8 i;
 468         int err = 0;
 469
 470         if (urb->status == -ENOENT)
 471                 return;
 472
 473         f = &cam->frame_current;
 474
 475         if (cam->stream == STREAM_INTERRUPT) {
 476                 cam->stream = STREAM_OFF;
 477                 if ((*f))
 478                         (*f)->state = F_QUEUED;
 479                 DBG(3, "Stream interrupted")
 480                 wake_up_interruptible(&cam->wait_stream);
 481         }
 482
 483         if ((cam->state & DEV_DISCONNECTED)||(cam->state & DEV_MISCONFIGURED))
 484                 return;
 485
 486         if (cam->stream == STREAM_OFF || list_empty(&cam->inqueue))
 487                 goto resubmit_urb;
 488
 489         if (!(*f))
 490                 (*f) = list_entry(cam->inqueue.next, struct sn9c102_frame_t,
 491                                   frame);
 492
 493         for (i = 0; i < urb->number_of_packets; i++) {
 494                 unsigned int img, len, status;
 495                 void *pos, *sof, *eof;
 496
 497                 len = urb->iso_frame_desc[i].actual_length;
 498                 status = urb->iso_frame_desc[i].status;
 499                 pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 500
 501                 if (status) {
 502                         DBG(3, "Error in isochronous frame")
 503                         (*f)->state = F_ERROR;
 504                         continue;
 505                 }
 506
 507                 PDBGG("Isochrnous frame: length %u, #%u i", len, i)
 508
 509                 /*
 510                    NOTE: It is probably correct to assume that SOF and EOF
 511                          headers do not occur between two consecutive packets,
 512                          but who knows..Whatever is the truth, this assumption
 513                          doesn't introduce bugs.
 514                 */
 515
 516 redo:
 517                 sof = sn9c102_find_sof_header(cam, pos, len);
 518                 if (!sof) {
 519                         eof = sn9c102_find_eof_header(cam, pos, len);
 520                         if ((*f)->state == F_GRABBING) {
 521 end_of_frame:
 522                                 img = len;
 523
 524                                 if (eof)
 525                                         img = (eof > pos) ? eof - pos - 1 : 0;
 526
 527                                 if ((*f)->buf.bytesused+img>(*f)->buf.length) {
 528                                         u32 b = (*f)->buf.bytesused + img -
 529                                                 (*f)->buf.length;
 530                                         img = (*f)->buf.length -
 531                                               (*f)->buf.bytesused;
 532                                         DBG(3, "Expected EOF not found: "
 533                                                "video frame cut")
 534                                         if (eof)
 535                                                 DBG(3, "Exceeded limit: +%u "
 536                                                        "bytes", (unsigned)(b))
 537                                 }
 538
 539                                 memcpy((*f)->bufmem + (*f)->buf.bytesused, pos,
 540                                        img);
 541
 542                                 if ((*f)->buf.bytesused == 0)
 543                                         do_gettimeofday(&(*f)->buf.timestamp);
 544
 545                                 (*f)->buf.bytesused += img;
 546
 547                                 if ((*f)->buf.bytesused == (*f)->buf.length ||
 548                                     (cam->sensor->pix_format.pixelformat ==
 549                                                 V4L2_PIX_FMT_SN9C10X && eof)) {
 550                                         u32 b = (*f)->buf.bytesused;
 551                                         (*f)->state = F_DONE;
 552                                         (*f)->buf.sequence= ++cam->frame_count;
 553                                         spin_lock_irqsave(&cam->queue_lock,
 554                                                           lock_flags);
 555                                         list_move_tail(&(*f)->frame,
 556                                                        &cam->outqueue);
 557                                         if (!list_empty(&cam->inqueue))
 558                                                 (*f) = list_entry(
 559                                                         cam->inqueue.next,
 560                                                         struct sn9c102_frame_t,
 561                                                         frame );
 562                                         else
 563                                                 (*f) = NULL;
 564                                         spin_unlock_irqrestore(&cam->queue_lock
 565                                                                , lock_flags);
 566                                         DBG(3, "Video frame captured: "
 567                                                "%lu bytes", (unsigned long)(b))
 568
 569                                         if (!(*f))
 570                                                 goto resubmit_urb;
 571
 572                                 } else if (eof) {
 573                                         (*f)->state = F_ERROR;
 574                                         DBG(3, "Not expected EOF after %lu "
 575                                                "bytes of image data",
 576                                           (unsigned long)((*f)->buf.bytesused))
 577                                 }
 578
 579                                 if (sof) /* (1) */
 580                                         goto start_of_frame;
 581
 582                         } else if (eof) {
 583                                 DBG(3, "EOF without SOF")
 584                                 continue;
 585
 586                         } else {
 587                                 PDBGG("Ignoring pointless isochronous frame")
 588                                 continue;
 589                         }
 590
 591                 } else if ((*f)->state == F_QUEUED || (*f)->state == F_ERROR) {
 592 start_of_frame:
 593                         (*f)->state = F_GRABBING;
 594                         (*f)->buf.bytesused = 0;
 595                         len -= (sof - pos);
 596                         pos = sof;
 597                         DBG(3, "SOF detected: new video frame")
 598                         if (len)
 599                                 goto redo;
 600
 601                 } else if ((*f)->state == F_GRABBING) {
 602                         eof = sn9c102_find_eof_header(cam, pos, len);
 603                         if (eof && eof < sof)
 604                                 goto end_of_frame; /* (1) */
 605                         else {
 606                                 if (cam->sensor->pix_format.pixelformat ==
 607                                     V4L2_PIX_FMT_SN9C10X) {
 608                                         eof = sof-sizeof(sn9c102_sof_header_t);
 609                                         goto end_of_frame;
 610                                 } else {
 611                                         DBG(3, "SOF before expected EOF after "
 612                                                "%lu bytes of image data",
 613                                           (unsigned long)((*f)->buf.bytesused))
 614                                         goto start_of_frame;
 615                                 }
 616                         }
 617                 }
 618         }
 619
 620 resubmit_urb:
 621         urb->dev = cam->usbdev;
 622         err = usb_submit_urb(urb, GFP_ATOMIC);
 623         if (err < 0 && err != -EPERM) {
 624                 cam->state |= DEV_MISCONFIGURED;
 625                 DBG(1, "usb_submit_urb() failed")
 626         }
 627
 628         wake_up_interruptible(&cam->wait_frame);
 629 }
 630
 631
 632 static int sn9c102_start_transfer(struct sn9c102_device* cam)
 633 {
 634         struct usb_device *udev = cam->usbdev;
 635         struct urb* urb;
 636         const unsigned int wMaxPacketSize[] = {0, 128, 256, 384, 512,
 637                                                680, 800, 900, 1023};
 638         const unsigned int psz = wMaxPacketSize[SN9C102_ALTERNATE_SETTING];
 639         s8 i, j;
 640         int err = 0;
 641
 642         for (i = 0; i < SN9C102_URBS; i++) {
 643                 cam->transfer_buffer[i] = kmalloc(SN9C102_ISO_PACKETS * psz,
 644                                                   GFP_KERNEL);
 645                 if (!cam->transfer_buffer[i]) {
 646                         err = -ENOMEM;
 647                         DBG(1, "Not enough memory")
 648                         goto free_buffers;
 649                 }
 650         }
 651
 652         for (i = 0; i < SN9C102_URBS; i++) {
 653                 urb = usb_alloc_urb(SN9C102_ISO_PACKETS, GFP_KERNEL);
 654                 cam->urb[i] = urb;
 655                 if (!urb) {
 656                         err = -ENOMEM;
 657                         DBG(1, "usb_alloc_urb() failed")
 658                         goto free_urbs;
 659                 }
 660                 urb->dev = udev;
 661                 urb->context = cam;
 662                 urb->pipe = usb_rcvisocpipe(udev, 1);
 663                 urb->transfer_flags = URB_ISO_ASAP;
 664                 urb->number_of_packets = SN9C102_ISO_PACKETS;
 665                 urb->complete = sn9c102_urb_complete;
 666                 urb->transfer_buffer = cam->transfer_buffer[i];
 667                 urb->transfer_buffer_length = psz * SN9C102_ISO_PACKETS;
 668                 urb->interval = 1;
 669                 for (j = 0; j < SN9C102_ISO_PACKETS; j++) {
 670                         urb->iso_frame_desc[j].offset = psz * j;
 671                         urb->iso_frame_desc[j].length = psz;
 672                 }
 673         }
 674
 675         /* Enable video */
 676         if (!(cam->reg[0x01] & 0x04)) {
 677                 err = sn9c102_write_reg(cam, cam->reg[0x01] | 0x04, 0x01);
 678                 if (err) {
 679                         err = -EIO;
 680                         DBG(1, "I/O hardware error")
 681                         goto free_urbs;
 682                 }
 683         }
 684
 685         err = usb_set_interface(udev, 0, SN9C102_ALTERNATE_SETTING);
 686         if (err) {
 687                 DBG(1, "usb_set_interface() failed")
 688                 goto free_urbs;
 689         }
 690
 691         cam->frame_current = NULL;
 692
 693         for (i = 0; i < SN9C102_URBS; i++) {
 694                 err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 695                 if (err) {
 696                         for (j = i-1; j >= 0; j--)
 697                                 usb_kill_urb(cam->urb[j]);
 698                         DBG(1, "usb_submit_urb() failed, error %d", err)
 699                         goto free_urbs;
 700                 }
 701         }
 702
 703         return 0;
 704
 705 free_urbs:
 706         for (i = 0; (i < SN9C102_URBS) &&  cam->urb[i]; i++)
 707                 usb_free_urb(cam->urb[i]);
 708
 709 free_buffers:
 710         for (i = 0; (i < SN9C102_URBS) && cam->transfer_buffer[i]; i++)
 711                 kfree(cam->transfer_buffer[i]);
 712
 713         return err;
 714 }
 715
 716
 717 static int sn9c102_stop_transfer(struct sn9c102_device* cam)
 718 {
 719         struct usb_device *udev = cam->usbdev;
 720         s8 i;
 721         int err = 0;
 722
 723         if (cam->state & DEV_DISCONNECTED)
 724                 return 0;
 725
 726         for (i = SN9C102_URBS-1; i >= 0; i--) {
 727                 usb_kill_urb(cam->urb[i]);
 728                 usb_free_urb(cam->urb[i]);
 729                 kfree(cam->transfer_buffer[i]);
 730         }
 731
 732         err = usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 733         if (err)
 734                 DBG(3, "usb_set_interface() failed")
 735
 736         return err;
 737 }
 738
 739
 740 int sn9c102_stream_interrupt(struct sn9c102_device* cam)
 741 {
 742         int err = 0;
 743
 744         cam->stream = STREAM_INTERRUPT;
 745         err = wait_event_timeout(cam->wait_stream,
 746                                  (cam->stream == STREAM_OFF) ||
 747                                  (cam->state & DEV_DISCONNECTED),
 748                                  SN9C102_URB_TIMEOUT);
 749         if (err) {
 750                 cam->state |= DEV_MISCONFIGURED;
 751                 DBG(1, "The camera is misconfigured. To use "
 752                        "it, close and open /dev/video%d "
 753                        "again.", cam->v4ldev->minor)
 754                 return err;
 755         }
 756         if (cam->state & DEV_DISCONNECTED)
 757                 return -ENODEV;
 758
 759         return 0;
 760 }
 761
 762 /*****************************************************************************/
 763
 764 static u8 sn9c102_strtou8(const char* buff, size_t len, ssize_t* count)
 765 {
 766         char str[5];
 767         char* endp;
 768         unsigned long val;
 769
 770         if (len < 4) {
 771                 strncpy(str, buff, len);
 772                 str[len+1] = '\0';
 773         } else {
 774                 strncpy(str, buff, 4);
 775                 str[4] = '\0';
 776         }
 777
 778         val = simple_strtoul(str, &endp, 0);
 779
 780         *count = 0;
 781         if (val <= 0xff)
 782                 *count = (ssize_t)(endp - str);
 783         if ((*count) && (len == *count+1) && (buff[*count] == '\n'))
 784                 *count += 1;
 785
 786         return (u8)val;
 787 }
 788
 789 /*
 790    NOTE 1: being inside one of the following methods implies that the v4l
 791            device exists for sure (see kobjects and reference counters)
 792    NOTE 2: buffers are PAGE_SIZE long
 793 */
 794
 795 static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
 796 {
 797         struct sn9c102_device* cam;
 798         ssize_t count;
 799
 800         if (down_interruptible(&sn9c102_sysfs_lock))
 801                 return -ERESTARTSYS;
 802
 803         cam = video_get_drvdata(to_video_device(cd));
 804         if (!cam) {
 805                 up(&sn9c102_sysfs_lock);
 806                 return -ENODEV;
 807         }
 808
 809         count = sprintf(buf, "%u\n", cam->sysfs.reg);
 810
 811         up(&sn9c102_sysfs_lock);
 812
 813         return count;
 814 }
 815
 816
 817 static ssize_t
 818 sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
 819 {
 820         struct sn9c102_device* cam;
 821         u8 index;
 822         ssize_t count;
 823
 824         if (down_interruptible(&sn9c102_sysfs_lock))
 825                 return -ERESTARTSYS;
 826
 827         cam = video_get_drvdata(to_video_device(cd));
 828         if (!cam) {
 829                 up(&sn9c102_sysfs_lock);
 830                 return -ENODEV;
 831         }
 832
 833         index = sn9c102_strtou8(buf, len, &count);
 834         if (index > 0x1f || !count) {
 835                 up(&sn9c102_sysfs_lock);
 836                 return -EINVAL;
 837         }
 838
 839         cam->sysfs.reg = index;
 840
 841         DBG(2, "Moved SN9C10X register index to 0x%02X", cam->sysfs.reg)
 842         DBG(3, "Written bytes: %zd", count)
 843
 844         up(&sn9c102_sysfs_lock);
 845
 846         return count;
 847 }
 848
 849
 850 static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
 851 {
 852         struct sn9c102_device* cam;
 853         ssize_t count;
 854         int val;
 855
 856         if (down_interruptible(&sn9c102_sysfs_lock))
 857                 return -ERESTARTSYS;
 858
 859         cam = video_get_drvdata(to_video_device(cd));
 860         if (!cam) {
 861                 up(&sn9c102_sysfs_lock);
 862                 return -ENODEV;
 863         }
 864
 865         if ((val = sn9c102_read_reg(cam, cam->sysfs.reg)) < 0) {
 866                 up(&sn9c102_sysfs_lock);
 867                 return -EIO;
 868         }
 869
 870         count = sprintf(buf, "%d\n", val);
 871
 872         DBG(3, "Read bytes: %zd", count)
 873
 874         up(&sn9c102_sysfs_lock);
 875
 876         return count;
 877 }
 878
 879
 880 static ssize_t
 881 sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
 882 {
 883         struct sn9c102_device* cam;
 884         u8 value;
 885         ssize_t count;
 886         int err;
 887
 888         if (down_interruptible(&sn9c102_sysfs_lock))
 889                 return -ERESTARTSYS;
 890
 891         cam = video_get_drvdata(to_video_device(cd));
 892         if (!cam) {
 893                 up(&sn9c102_sysfs_lock);
 894                 return -ENODEV;
 895         }
 896
 897         value = sn9c102_strtou8(buf, len, &count);
 898         if (!count) {
 899                 up(&sn9c102_sysfs_lock);
 900                 return -EINVAL;
 901         }
 902
 903         err = sn9c102_write_reg(cam, value, cam->sysfs.reg);
 904         if (err) {
 905                 up(&sn9c102_sysfs_lock);
 906                 return -EIO;
 907         }
 908
 909         DBG(2, "Written SN9C10X reg. 0x%02X, val. 0x%02X",
 910             cam->sysfs.reg, value)
 911         DBG(3, "Written bytes: %zd", count)
 912
 913         up(&sn9c102_sysfs_lock);
 914
 915         return count;
 916 }
 917
 918
 919 static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
 920 {
 921         struct sn9c102_device* cam;
 922         ssize_t count;
 923
 924         if (down_interruptible(&sn9c102_sysfs_lock))
 925                 return -ERESTARTSYS;
 926
 927         cam = video_get_drvdata(to_video_device(cd));
 928         if (!cam) {
 929                 up(&sn9c102_sysfs_lock);
 930                 return -ENODEV;
 931         }
 932
 933         count = sprintf(buf, "%u\n", cam->sysfs.i2c_reg);
 934
 935         DBG(3, "Read bytes: %zd", count)
 936
 937         up(&sn9c102_sysfs_lock);
 938
 939         return count;
 940 }
 941
 942
 943 static ssize_t
 944 sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
 945 {
 946         struct sn9c102_device* cam;
 947         u8 index;
 948         ssize_t count;
 949
 950         if (down_interruptible(&sn9c102_sysfs_lock))
 951                 return -ERESTARTSYS;
 952
 953         cam = video_get_drvdata(to_video_device(cd));
 954         if (!cam) {
 955                 up(&sn9c102_sysfs_lock);
 956                 return -ENODEV;
 957         }
 958
 959         index = sn9c102_strtou8(buf, len, &count);
 960         if (!count) {
 961                 up(&sn9c102_sysfs_lock);
 962                 return -EINVAL;
 963         }
 964
 965         cam->sysfs.i2c_reg = index;
 966
 967         DBG(2, "Moved sensor register index to 0x%02X", cam->sysfs.i2c_reg)
 968         DBG(3, "Written bytes: %zd", count)
 969
 970         up(&sn9c102_sysfs_lock);
 971
 972         return count;
 973 }
 974
 975
 976 static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
 977 {
 978         struct sn9c102_device* cam;
 979         ssize_t count;
 980         int val;
 981
 982         if (down_interruptible(&sn9c102_sysfs_lock))
 983                 return -ERESTARTSYS;
 984
 985         cam = video_get_drvdata(to_video_device(cd));
 986         if (!cam) {
 987                 up(&sn9c102_sysfs_lock);
 988                 return -ENODEV;
 989         }
 990
 991         if (cam->sensor->slave_read_id == SN9C102_I2C_SLAVEID_UNAVAILABLE) {
 992                 up(&sn9c102_sysfs_lock);
 993                 return -ENOSYS;
 994         }
 995
 996         if ((val = sn9c102_i2c_read(cam, cam->sysfs.i2c_reg)) < 0) {
 997                 up(&sn9c102_sysfs_lock);
 998                 return -EIO;
 999         }
1000
1001         count = sprintf(buf, "%d\n", val);
1002
1003         DBG(3, "Read bytes: %zd", count)
1004
1005         up(&sn9c102_sysfs_lock);
1006
1007         return count;
1008 }
1009
1010
1011 static ssize_t
1012 sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
1013 {
1014         struct sn9c102_device* cam;
1015         u8 value;
1016         ssize_t count;
1017         int err;
1018
1019         if (down_interruptible(&sn9c102_sysfs_lock))
1020                 return -ERESTARTSYS;
1021
1022         cam = video_get_drvdata(to_video_device(cd));
1023         if (!cam) {
1024                 up(&sn9c102_sysfs_lock);
1025                 return -ENODEV;
1026         }
1027
1028         value = sn9c102_strtou8(buf, len, &count);
1029         if (!count) {
1030                 up(&sn9c102_sysfs_lock);
1031                 return -EINVAL;
1032         }
1033
1034         err = sn9c102_i2c_write(cam, cam->sysfs.i2c_reg, value);
1035         if (err) {
1036                 up(&sn9c102_sysfs_lock);
1037                 return -EIO;
1038         }
1039
1040         DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
1041             cam->sysfs.i2c_reg, value)
1042         DBG(3, "Written bytes: %zd", count)
1043
1044         up(&sn9c102_sysfs_lock);
1045
1046         return count;
1047 }
1048
1049
1050 static ssize_t
1051 sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
1052 {
1053         struct sn9c102_device* cam;
1054         enum sn9c102_bridge bridge;
1055         ssize_t res = 0;
1056         u8 value;
1057         ssize_t count;
1058
1059         if (down_interruptible(&sn9c102_sysfs_lock))
1060                 return -ERESTARTSYS;
1061
1062         cam = video_get_drvdata(to_video_device(cd));
1063         if (!cam) {
1064                 up(&sn9c102_sysfs_lock);
1065                 return -ENODEV;
1066         }
1067
1068         bridge = cam->bridge;
1069
1070         up(&sn9c102_sysfs_lock);
1071
1072         value = sn9c102_strtou8(buf, len, &count);
1073         if (!count)
1074                 return -EINVAL;
1075
1076         switch (bridge) {
1077         case BRIDGE_SN9C101:
1078         case BRIDGE_SN9C102:
1079                 if (value > 0x0f)
1080                         return -EINVAL;
1081                 if ((res = sn9c102_store_reg(cd, "0x11", 4)) >= 0)
1082                         res = sn9c102_store_val(cd, buf, len);
1083                 break;
1084         case BRIDGE_SN9C103:
1085                 if (value > 0x7f)
1086                         return -EINVAL;
1087                 if ((res = sn9c102_store_reg(cd, "0x04", 4)) >= 0)
1088                         res = sn9c102_store_val(cd, buf, len);
1089                 break;
1090         }
1091
1092         return res;
1093 }
1094
1095
1096 static ssize_t
1097 sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
1098 {
1099         ssize_t res = 0;
1100         u8 value;
1101         ssize_t count;
1102
1103         value = sn9c102_strtou8(buf, len, &count);
1104         if (!count || value > 0x7f)
1105                 return -EINVAL;
1106
1107         if ((res = sn9c102_store_reg(cd, "0x06", 4)) >= 0)
1108                 res = sn9c102_store_val(cd, buf, len);
1109
1110         return res;
1111 }
1112
1113
1114 static ssize_t
1115 sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
1116 {
1117         ssize_t res = 0;
1118         u8 value;
1119         ssize_t count;
1120
1121         value = sn9c102_strtou8(buf, len, &count);
1122         if (!count || value > 0x7f)
1123                 return -EINVAL;
1124
1125         if ((res = sn9c102_store_reg(cd, "0x05", 4)) >= 0)
1126                 res = sn9c102_store_val(cd, buf, len);
1127
1128         return res;
1129 }
1130
1131
1132 static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
1133                          sn9c102_show_reg, sn9c102_store_reg);
1134 static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
1135                          sn9c102_show_val, sn9c102_store_val);
1136 static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
1137                          sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
1138 static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
1139                          sn9c102_show_i2c_val, sn9c102_store_i2c_val);
1140 static CLASS_DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
1141 static CLASS_DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
1142 static CLASS_DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
1143
1144
1145 static void sn9c102_create_sysfs(struct sn9c102_device* cam)
1146 {
1147         struct video_device *v4ldev = cam->v4ldev;
1148
1149         video_device_create_file(v4ldev, &class_device_attr_reg);
1150         video_device_create_file(v4ldev, &class_device_attr_val);
1151         if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102)
1152                 video_device_create_file(v4ldev, &class_device_attr_green);
1153         else if (cam->bridge == BRIDGE_SN9C103) {
1154                 video_device_create_file(v4ldev, &class_device_attr_blue);
1155                 video_device_create_file(v4ldev, &class_device_attr_red);
1156         }
1157         if (cam->sensor->slave_write_id != SN9C102_I2C_SLAVEID_UNAVAILABLE ||
1158             cam->sensor->slave_read_id != SN9C102_I2C_SLAVEID_UNAVAILABLE) {
1159                 video_device_create_file(v4ldev, &class_device_attr_i2c_reg);
1160                 video_device_create_file(v4ldev, &class_device_attr_i2c_val);
1161         }
1162 }
1163
1164 /*****************************************************************************/
1165
1166 static int
1167 sn9c102_set_format(struct sn9c102_device* cam, struct v4l2_pix_format* fmt)
1168 {
1169         int err = 0;
1170
1171         if (fmt->pixelformat == V4L2_PIX_FMT_SN9C10X)
1172                 err += sn9c102_write_reg(cam, cam->reg[0x18] | 0x80, 0x18);
1173         else
1174                 err += sn9c102_write_reg(cam, cam->reg[0x18] & 0x7f, 0x18);
1175
1176         return err ? -EIO : 0;
1177 }
1178
1179
1180 static int
1181 sn9c102_set_compression(struct sn9c102_device* cam,
1182                         struct v4l2_jpegcompression* compression)
1183 {
1184         int err = 0;
1185
1186         if (compression->quality == 0)
1187                 err += sn9c102_write_reg(cam, cam->reg[0x17] | 0x01, 0x17);
1188         else if (compression->quality == 1)
1189                 err += sn9c102_write_reg(cam, cam->reg[0x17] & 0xfe, 0x17);
1190
1191         return err ? -EIO : 0;
1192 }
1193
1194
1195 static int sn9c102_set_scale(struct sn9c102_device* cam, u8 scale)
1196 {
1197         u8 r = 0;
1198         int err = 0;
1199
1200         if (scale == 1)
1201                 r = cam->reg[0x18] & 0xcf;
1202         else if (scale == 2) {
1203                 r = cam->reg[0x18] & 0xcf;
1204                 r |= 0x10;
1205         } else if (scale == 4)
1206                 r = cam->reg[0x18] | 0x20;
1207
1208         err += sn9c102_write_reg(cam, r, 0x18);
1209         if (err)
1210                 return -EIO;
1211
1212         PDBGG("Scaling factor: %u", scale)
1213
1214         return 0;
1215 }
1216
1217
1218 static int sn9c102_set_crop(struct sn9c102_device* cam, struct v4l2_rect* rect)
1219 {
1220         struct sn9c102_sensor* s = cam->sensor;
1221         u8 h_start = (u8)(rect->left - s->cropcap.bounds.left),
1222            v_start = (u8)(rect->top - s->cropcap.bounds.top),
1223            h_size = (u8)(rect->width / 16),
1224            v_size = (u8)(rect->height / 16);
1225         int err = 0;
1226
1227         err += sn9c102_write_reg(cam, h_start, 0x12);
1228         err += sn9c102_write_reg(cam, v_start, 0x13);
1229         err += sn9c102_write_reg(cam, h_size, 0x15);
1230         err += sn9c102_write_reg(cam, v_size, 0x16);
1231         if (err)
1232                 return -EIO;
1233
1234         PDBGG("h_start, v_start, h_size, v_size, ho_size, vo_size "
1235               "%u %u %u %u", h_start, v_start, h_size, v_size)
1236
1237         return 0;
1238 }
1239
1240
1241 static int sn9c102_init(struct sn9c102_device* cam)
1242 {
1243         struct sn9c102_sensor* s = cam->sensor;
1244         struct v4l2_control ctrl;
1245         struct v4l2_queryctrl *qctrl;
1246         struct v4l2_rect* rect;
1247         u8 i = 0, n = 0;
1248         int err = 0;
1249
1250         if (!(cam->state & DEV_INITIALIZED)) {
1251                 init_waitqueue_head(&cam->open);
1252                 qctrl = s->qctrl;
1253                 rect = &(s->cropcap.defrect);
1254         } else { /* use current values */
1255                 qctrl = s->_qctrl;
1256                 rect = &(s->_rect);
1257         }
1258
1259         err += sn9c102_set_scale(cam, rect->width / s->pix_format.width);
1260         err += sn9c102_set_crop(cam, rect);
1261         if (err)
1262                 return err;
1263
1264         if (s->init) {
1265                 err = s->init(cam);
1266                 if (err) {
1267                         DBG(3, "Sensor initialization failed")
1268                         return err;
1269                 }
1270         }
1271
1272         if (!(cam->state & DEV_INITIALIZED))
1273                 cam->compression.quality =  cam->reg[0x17] & 0x01 ? 0 : 1;
1274         else
1275                 err += sn9c102_set_compression(cam, &cam->compression);
1276         err += sn9c102_set_format(cam, &s->pix_format);
1277         if (err)
1278                 return err;
1279
1280         if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X)
1281                 DBG(3, "Compressed video format is active, quality %d",
1282                     cam->compression.quality)
1283         else
1284                 DBG(3, "Uncompressed video format is active")
1285
1286         if (s->set_crop)
1287                 if ((err = s->set_crop(cam, rect))) {
1288                         DBG(3, "set_crop() failed")
1289                         return err;
1290                 }
1291
1292         if (s->set_ctrl) {
1293                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1294                 for (i = 0; i < n; i++)
1295                         if (s->qctrl[i].id != 0 &&
1296                             !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) {
1297                                 ctrl.id = s->qctrl[i].id;
1298                                 ctrl.value = qctrl[i].default_value;
1299                                 err = s->set_ctrl(cam, &ctrl);
1300                                 if (err) {
1301                                         DBG(3, "Set %s control failed",
1302                                             s->qctrl[i].name)
1303                                         return err;
1304                                 }
1305                                 DBG(3, "Image sensor supports '%s' control",
1306                                     s->qctrl[i].name)
1307                         }
1308         }
1309
1310         if (!(cam->state & DEV_INITIALIZED)) {
1311                 init_MUTEX(&cam->fileop_sem);
1312                 spin_lock_init(&cam->queue_lock);
1313                 init_waitqueue_head(&cam->wait_frame);
1314                 init_waitqueue_head(&cam->wait_stream);
1315                 cam->nreadbuffers = 2;
1316                 memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl));
1317                 memcpy(&(s->_rect), &(s->cropcap.defrect),
1318                        sizeof(struct v4l2_rect));
1319                 cam->state |= DEV_INITIALIZED;
1320         }
1321
1322         DBG(2, "Initialization succeeded")
1323         return 0;
1324 }
1325
1326
1327 static void sn9c102_release_resources(struct sn9c102_device* cam)
1328 {
1329         down(&sn9c102_sysfs_lock);
1330
1331         DBG(2, "V4L2 device /dev/video%d deregistered", cam->v4ldev->minor)
1332         video_set_drvdata(cam->v4ldev, NULL);
1333         video_unregister_device(cam->v4ldev);
1334
1335         up(&sn9c102_sysfs_lock);
1336
1337         kfree(cam->control_buffer);
1338 }
1339
1340 /*****************************************************************************/
1341
1342 static int sn9c102_open(struct inode* inode, struct file* filp)
1343 {
1344         struct sn9c102_device* cam;
1345         int err = 0;
1346
1347         /*
1348            This is the only safe way to prevent race conditions with
1349            disconnect
1350         */
1351         if (!down_read_trylock(&sn9c102_disconnect))
1352                 return -ERESTARTSYS;
1353
1354         cam = video_get_drvdata(video_devdata(filp));
1355
1356         if (down_interruptible(&cam->dev_sem)) {
1357                 up_read(&sn9c102_disconnect);
1358                 return -ERESTARTSYS;
1359         }
1360
1361         if (cam->users) {
1362                 DBG(2, "Device /dev/video%d is busy...", cam->v4ldev->minor)
1363                 if ((filp->f_flags & O_NONBLOCK) ||
1364                     (filp->f_flags & O_NDELAY)) {
1365                         err = -EWOULDBLOCK;
1366                         goto out;
1367                 }
1368                 up(&cam->dev_sem);
1369                 err = wait_event_interruptible_exclusive(cam->open,
1370                                                   cam->state & DEV_DISCONNECTED
1371                                                          || !cam->users);
1372                 if (err) {
1373                         up_read(&sn9c102_disconnect);
1374                         return err;
1375                 }
1376                 if (cam->state & DEV_DISCONNECTED) {
1377                         up_read(&sn9c102_disconnect);
1378                         return -ENODEV;
1379                 }
1380                 down(&cam->dev_sem);
1381         }
1382
1383
1384         if (cam->state & DEV_MISCONFIGURED) {
1385                 err = sn9c102_init(cam);
1386                 if (err) {
1387                         DBG(1, "Initialization failed again. "
1388                                "I will retry on next open().")
1389                         goto out;
1390                 }
1391                 cam->state &= ~DEV_MISCONFIGURED;
1392         }
1393
1394         if ((err = sn9c102_start_transfer(cam)))
1395                 goto out;
1396
1397         filp->private_data = cam;
1398         cam->users++;
1399         cam->io = IO_NONE;
1400         cam->stream = STREAM_OFF;
1401         cam->nbuffers = 0;
1402         cam->frame_count = 0;
1403         sn9c102_empty_framequeues(cam);
1404
1405         DBG(3, "Video device /dev/video%d is open", cam->v4ldev->minor)
1406
1407 out:
1408         up(&cam->dev_sem);
1409         up_read(&sn9c102_disconnect);
1410         return err;
1411 }
1412
1413
1414 static int sn9c102_release(struct inode* inode, struct file* filp)
1415 {
1416         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1417
1418         down(&cam->dev_sem); /* prevent disconnect() to be called */
1419
1420         sn9c102_stop_transfer(cam);
1421
1422         sn9c102_release_buffers(cam);
1423
1424         if (cam->state & DEV_DISCONNECTED) {
1425                 sn9c102_release_resources(cam);
1426                 up(&cam->dev_sem);
1427                 kfree(cam);
1428                 return 0;
1429         }
1430
1431         cam->users--;
1432         wake_up_interruptible_nr(&cam->open, 1);
1433
1434         DBG(3, "Video device /dev/video%d closed", cam->v4ldev->minor)
1435
1436         up(&cam->dev_sem);
1437
1438         return 0;
1439 }
1440
1441
1442 static ssize_t
1443 sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
1444 {
1445         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1446         struct sn9c102_frame_t* f, * i;
1447         unsigned long lock_flags;
1448         int err = 0;
1449
1450         if (down_interruptible(&cam->fileop_sem))
1451                 return -ERESTARTSYS;
1452
1453         if (cam->state & DEV_DISCONNECTED) {
1454                 DBG(1, "Device not present")
1455                 up(&cam->fileop_sem);
1456                 return -ENODEV;
1457         }
1458
1459         if (cam->state & DEV_MISCONFIGURED) {
1460                 DBG(1, "The camera is misconfigured. Close and open it again.")
1461                 up(&cam->fileop_sem);
1462                 return -EIO;
1463         }
1464
1465         if (cam->io == IO_MMAP) {
1466                 DBG(3, "Close and open the device again to choose "
1467                        "the read method")
1468                 up(&cam->fileop_sem);
1469                 return -EINVAL;
1470         }
1471
1472         if (cam->io == IO_NONE) {
1473                 if (!sn9c102_request_buffers(cam, cam->nreadbuffers)) {
1474                         DBG(1, "read() failed, not enough memory")
1475                         up(&cam->fileop_sem);
1476                         return -ENOMEM;
1477                 }
1478                 cam->io = IO_READ;
1479                 cam->stream = STREAM_ON;
1480                 sn9c102_queue_unusedframes(cam);
1481         }
1482
1483         if (!count) {
1484                 up(&cam->fileop_sem);
1485                 return 0;
1486         }
1487
1488         if (list_empty(&cam->outqueue)) {
1489                 if (filp->f_flags & O_NONBLOCK) {
1490                         up(&cam->fileop_sem);
1491                         return -EAGAIN;
1492                 }
1493                 err = wait_event_interruptible
1494                       ( cam->wait_frame,
1495                         (!list_empty(&cam->outqueue)) ||
1496                         (cam->state & DEV_DISCONNECTED) );
1497                 if (err) {
1498                         up(&cam->fileop_sem);
1499                         return err;
1500                 }
1501                 if (cam->state & DEV_DISCONNECTED) {
1502                         up(&cam->fileop_sem);
1503                         return -ENODEV;
1504                 }
1505         }
1506
1507         f = list_entry(cam->outqueue.prev, struct sn9c102_frame_t, frame);
1508
1509         spin_lock_irqsave(&cam->queue_lock, lock_flags);
1510         list_for_each_entry(i, &cam->outqueue, frame)
1511                 i->state = F_UNUSED;
1512         INIT_LIST_HEAD(&cam->outqueue);
1513         spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
1514
1515         sn9c102_queue_unusedframes(cam);
1516
1517         if (count > f->buf.bytesused)
1518                 count = f->buf.bytesused;
1519
1520         if (copy_to_user(buf, f->bufmem, count)) {
1521                 up(&cam->fileop_sem);
1522                 return -EFAULT;
1523         }
1524         *f_pos += count;
1525
1526         PDBGG("Frame #%lu, bytes read: %zu", (unsigned long)f->buf.index,count)
1527
1528         up(&cam->fileop_sem);
1529
1530         return count;
1531 }
1532
1533
1534 static unsigned int sn9c102_poll(struct file *filp, poll_table *wait)
1535 {
1536         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1537         unsigned int mask = 0;
1538
1539         if (down_interruptible(&cam->fileop_sem))
1540                 return POLLERR;
1541
1542         if (cam->state & DEV_DISCONNECTED) {
1543                 DBG(1, "Device not present")
1544                 goto error;
1545         }
1546
1547         if (cam->state & DEV_MISCONFIGURED) {
1548                 DBG(1, "The camera is misconfigured. Close and open it again.")
1549                 goto error;
1550         }
1551
1552         if (cam->io == IO_NONE) {
1553                 if (!sn9c102_request_buffers(cam, 2)) {
1554                         DBG(1, "poll() failed, not enough memory")
1555                         goto error;
1556                 }
1557                 cam->io = IO_READ;
1558                 cam->stream = STREAM_ON;
1559         }
1560
1561         if (cam->io == IO_READ)
1562                 sn9c102_queue_unusedframes(cam);
1563
1564         poll_wait(filp, &cam->wait_frame, wait);
1565
1566         if (!list_empty(&cam->outqueue))
1567                 mask |= POLLIN | POLLRDNORM;
1568
1569         up(&cam->fileop_sem);
1570
1571         return mask;
1572
1573 error:
1574         up(&cam->fileop_sem);
1575         return POLLERR;
1576 }
1577
1578
1579 static void sn9c102_vm_open(struct vm_area_struct* vma)
1580 {
1581         struct sn9c102_frame_t* f = vma->vm_private_data;
1582         f->vma_use_count++;
1583 }
1584
1585
1586 static void sn9c102_vm_close(struct vm_area_struct* vma)
1587 {
1588         /* NOTE: buffers are not freed here */
1589         struct sn9c102_frame_t* f = vma->vm_private_data;
1590         f->vma_use_count--;
1591 }
1592
1593
1594 static struct vm_operations_struct sn9c102_vm_ops = {
1595         .open = sn9c102_vm_open,
1596         .close = sn9c102_vm_close,
1597 };
1598
1599
1600 static int sn9c102_mmap(struct file* filp, struct vm_area_struct *vma)
1601 {
1602         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1603         unsigned long size = vma->vm_end - vma->vm_start,
1604                       start = vma->vm_start,
1605                       pos,
1606                       page;
1607         u32 i;
1608
1609         if (down_interruptible(&cam->fileop_sem))
1610                 return -ERESTARTSYS;
1611
1612         if (cam->state & DEV_DISCONNECTED) {
1613                 DBG(1, "Device not present")
1614                 up(&cam->fileop_sem);
1615                 return -ENODEV;
1616         }
1617
1618         if (cam->state & DEV_MISCONFIGURED) {
1619                 DBG(1, "The camera is misconfigured. Close and open it again.")
1620                 up(&cam->fileop_sem);
1621                 return -EIO;
1622         }
1623
1624         if (cam->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
1625             size != PAGE_ALIGN(cam->frame[0].buf.length)) {
1626                 up(&cam->fileop_sem);
1627                 return -EINVAL;
1628         }
1629
1630         for (i = 0; i < cam->nbuffers; i++) {
1631                 if ((cam->frame[i].buf.m.offset>>PAGE_SHIFT) == vma->vm_pgoff)
1632                         break;
1633         }
1634         if (i == cam->nbuffers) {
1635                 up(&cam->fileop_sem);
1636                 return -EINVAL;
1637         }
1638
1639         /* VM_IO is eventually going to replace PageReserved altogether */
1640         vma->vm_flags |= VM_IO;
1641         vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1642
1643         pos = (unsigned long)cam->frame[i].bufmem;
1644         while (size > 0) { /* size is page-aligned */
1645                 page = vmalloc_to_pfn((void *)pos);
1646                 if (remap_pfn_range(vma, start, page, PAGE_SIZE,
1647                                     vma->vm_page_prot)) {
1648                         up(&cam->fileop_sem);
1649                         return -EAGAIN;
1650                 }
1651                 start += PAGE_SIZE;
1652                 pos += PAGE_SIZE;
1653                 size -= PAGE_SIZE;
1654         }
1655
1656         vma->vm_ops = &sn9c102_vm_ops;
1657         vma->vm_private_data = &cam->frame[i];
1658
1659         sn9c102_vm_open(vma);
1660
1661         up(&cam->fileop_sem);
1662
1663         return 0;
1664 }
1665
1666
1667 static int sn9c102_v4l2_ioctl(struct inode* inode, struct file* filp,
1668                               unsigned int cmd, void __user * arg)
1669 {
1670         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
1671
1672         switch (cmd) {
1673
1674         case VIDIOC_QUERYCAP:
1675         {
1676                 struct v4l2_capability cap = {
1677                         .driver = "sn9c102",
1678                         .version = SN9C102_MODULE_VERSION_CODE,
1679                         .capabilities = V4L2_CAP_VIDEO_CAPTURE |
1680                                         V4L2_CAP_READWRITE |
1681                                         V4L2_CAP_STREAMING,
1682                 };
1683
1684                 strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
1685                 if (usb_make_path(cam->usbdev, cap.bus_info,
1686                     sizeof(cap.bus_info)) < 0)
1687                         strlcpy(cap.bus_info, cam->dev.bus_id,
1688                                 sizeof(cap.bus_info));
1689
1690                 if (copy_to_user(arg, &cap, sizeof(cap)))
1691                         return -EFAULT;
1692
1693                 return 0;
1694         }
1695
1696         case VIDIOC_ENUMINPUT:
1697         {
1698                 struct v4l2_input i;
1699
1700                 if (copy_from_user(&i, arg, sizeof(i)))
1701                         return -EFAULT;
1702
1703                 if (i.index)
1704                         return -EINVAL;
1705
1706                 memset(&i, 0, sizeof(i));
1707                 strcpy(i.name, "USB");
1708
1709                 if (copy_to_user(arg, &i, sizeof(i)))
1710                         return -EFAULT;
1711
1712                 return 0;
1713         }
1714
1715         case VIDIOC_G_INPUT:
1716         case VIDIOC_S_INPUT:
1717         {
1718                 int index;
1719
1720                 if (copy_from_user(&index, arg, sizeof(index)))
1721                         return -EFAULT;
1722
1723                 if (index != 0)
1724                         return -EINVAL;
1725
1726                 return 0;
1727         }
1728
1729         case VIDIOC_QUERYCTRL:
1730         {
1731                 struct sn9c102_sensor* s = cam->sensor;
1732                 struct v4l2_queryctrl qc;
1733                 u8 i, n;
1734
1735                 if (copy_from_user(&qc, arg, sizeof(qc)))
1736                         return -EFAULT;
1737
1738                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1739                 for (i = 0; i < n; i++)
1740                         if (qc.id && qc.id == s->qctrl[i].id) {
1741                                 memcpy(&qc, &(s->qctrl[i]), sizeof(qc));
1742                                 if (copy_to_user(arg, &qc, sizeof(qc)))
1743                                         return -EFAULT;
1744                                 return 0;
1745                         }
1746
1747                 return -EINVAL;
1748         }
1749
1750         case VIDIOC_G_CTRL:
1751         {
1752                 struct sn9c102_sensor* s = cam->sensor;
1753                 struct v4l2_control ctrl;
1754                 int err = 0;
1755
1756                 if (!s->get_ctrl)
1757                         return -EINVAL;
1758
1759                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1760                         return -EFAULT;
1761
1762                 err = s->get_ctrl(cam, &ctrl);
1763
1764                 if (copy_to_user(arg, &ctrl, sizeof(ctrl)))
1765                         return -EFAULT;
1766
1767                 return err;
1768         }
1769
1770         case VIDIOC_S_CTRL:
1771         {
1772                 struct sn9c102_sensor* s = cam->sensor;
1773                 struct v4l2_control ctrl;
1774                 u8 i, n;
1775                 int err = 0;
1776
1777                 if (!s->set_ctrl)
1778                         return -EINVAL;
1779
1780                 if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1781                         return -EFAULT;
1782
1783                 n = sizeof(s->qctrl) / sizeof(s->qctrl[0]);
1784                 for (i = 0; i < n; i++)
1785                         if (ctrl.id == s->qctrl[i].id) {
1786                                 if (ctrl.value < s->qctrl[i].minimum ||
1787                                     ctrl.value > s->qctrl[i].maximum)
1788                                         return -ERANGE;
1789                                 ctrl.value -= ctrl.value % s->qctrl[i].step;
1790                                 break;
1791                         }
1792
1793                 if ((err = s->set_ctrl(cam, &ctrl)))
1794                         return err;
1795
1796                 s->_qctrl[i].default_value = ctrl.value;
1797
1798                 PDBGG("VIDIOC_S_CTRL: id %lu, value %lu",
1799                       (unsigned long)ctrl.id, (unsigned long)ctrl.value)
1800
1801                 return 0;
1802         }
1803
1804         case VIDIOC_CROPCAP:
1805         {
1806                 struct v4l2_cropcap* cc = &(cam->sensor->cropcap);
1807
1808                 cc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1809                 cc->pixelaspect.numerator = 1;
1810                 cc->pixelaspect.denominator = 1;
1811
1812                 if (copy_to_user(arg, cc, sizeof(*cc)))
1813                         return -EFAULT;
1814
1815                 return 0;
1816         }
1817
1818         case VIDIOC_G_CROP:
1819         {
1820                 struct sn9c102_sensor* s = cam->sensor;
1821                 struct v4l2_crop crop = {
1822                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
1823                 };
1824
1825                 memcpy(&(crop.c), &(s->_rect), sizeof(struct v4l2_rect));
1826
1827                 if (copy_to_user(arg, &crop, sizeof(crop)))
1828                         return -EFAULT;
1829
1830                 return 0;
1831         }
1832
1833         case VIDIOC_S_CROP:
1834         {
1835                 struct sn9c102_sensor* s = cam->sensor;
1836                 struct v4l2_crop crop;
1837                 struct v4l2_rect* rect;
1838                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
1839                 struct v4l2_pix_format* pix_format = &(s->pix_format);
1840                 u8 scale;
1841                 const enum sn9c102_stream_state stream = cam->stream;
1842                 const u32 nbuffers = cam->nbuffers;
1843                 u32 i;
1844                 int err = 0;
1845
1846                 if (copy_from_user(&crop, arg, sizeof(crop)))
1847                         return -EFAULT;
1848
1849                 rect = &(crop.c);
1850
1851                 if (crop.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1852                         return -EINVAL;
1853
1854                 for (i = 0; i < cam->nbuffers; i++)
1855                         if (cam->frame[i].vma_use_count) {
1856                                 DBG(3, "VIDIOC_S_CROP failed. "
1857                                        "Unmap the buffers first.")
1858                                 return -EINVAL;
1859                         }
1860
1861                 /* Preserve R,G or B origin */
1862                 rect->left = (s->_rect.left & 1L) ?
1863                              rect->left | 1L : rect->left & ~1L;
1864                 rect->top = (s->_rect.top & 1L) ?
1865                             rect->top | 1L : rect->top & ~1L;
1866
1867                 if (rect->width < 16)
1868                         rect->width = 16;
1869                 if (rect->height < 16)
1870                         rect->height = 16;
1871                 if (rect->width > bounds->width)
1872                         rect->width = bounds->width;
1873                 if (rect->height > bounds->height)
1874                         rect->height = bounds->height;
1875                 if (rect->left < bounds->left)
1876                         rect->left = bounds->left;
1877                 if (rect->top < bounds->top)
1878                         rect->top = bounds->top;
1879                 if (rect->left + rect->width > bounds->left + bounds->width)
1880                         rect->left = bounds->left+bounds->width - rect->width;
1881                 if (rect->top + rect->height > bounds->top + bounds->height)
1882                         rect->top = bounds->top+bounds->height - rect->height;
1883
1884                 rect->width &= ~15L;
1885                 rect->height &= ~15L;
1886
1887                 if (SN9C102_PRESERVE_IMGSCALE) {
1888                         /* Calculate the actual scaling factor */
1889                         u32 a, b;
1890                         a = rect->width * rect->height;
1891                         b = pix_format->width * pix_format->height;
1892                         scale = b ? (u8)((a / b) < 4 ? 1 :
1893                                         ((a / b) < 16 ? 2 : 4)) : 1;
1894                 } else
1895                         scale = 1;
1896
1897                 if (cam->stream == STREAM_ON)
1898                         if ((err = sn9c102_stream_interrupt(cam)))
1899                                 return err;
1900
1901                 if (copy_to_user(arg, &crop, sizeof(crop))) {
1902                         cam->stream = stream;
1903                         return -EFAULT;
1904                 }
1905
1906                 sn9c102_release_buffers(cam);
1907
1908                 err = sn9c102_set_crop(cam, rect);
1909                 if (s->set_crop)
1910                         err += s->set_crop(cam, rect);
1911                 err += sn9c102_set_scale(cam, scale);
1912
1913                 if (err) { /* atomic, no rollback in ioctl() */
1914                         cam->state |= DEV_MISCONFIGURED;
1915                         DBG(1, "VIDIOC_S_CROP failed because of hardware "
1916                                "problems. To use the camera, close and open "
1917                                "/dev/video%d again.", cam->v4ldev->minor)
1918                         return -EIO;
1919                 }
1920
1921                 s->pix_format.width = rect->width/scale;
1922                 s->pix_format.height = rect->height/scale;
1923                 memcpy(&(s->_rect), rect, sizeof(*rect));
1924
1925                 if (nbuffers != sn9c102_request_buffers(cam, nbuffers)) {
1926                         cam->state |= DEV_MISCONFIGURED;
1927                         DBG(1, "VIDIOC_S_CROP failed because of not enough "
1928                                "memory. To use the camera, close and open "
1929                                "/dev/video%d again.", cam->v4ldev->minor)
1930                         return -ENOMEM;
1931                 }
1932
1933                 cam->stream = stream;
1934
1935                 return 0;
1936         }
1937
1938         case VIDIOC_ENUM_FMT:
1939         {
1940                 struct v4l2_fmtdesc fmtd;
1941
1942                 if (copy_from_user(&fmtd, arg, sizeof(fmtd)))
1943                         return -EFAULT;
1944
1945                 if (fmtd.index == 0) {
1946                         strcpy(fmtd.description, "bayer rgb");
1947                         fmtd.pixelformat = V4L2_PIX_FMT_SBGGR8;
1948                 } else if (fmtd.index == 1) {
1949                         strcpy(fmtd.description, "compressed");
1950                         fmtd.pixelformat = V4L2_PIX_FMT_SN9C10X;
1951                         fmtd.flags = V4L2_FMT_FLAG_COMPRESSED;
1952                 } else
1953                         return -EINVAL;
1954
1955                 fmtd.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1956                 memset(&fmtd.reserved, 0, sizeof(fmtd.reserved));
1957
1958                 if (copy_to_user(arg, &fmtd, sizeof(fmtd)))
1959                         return -EFAULT;
1960
1961                 return 0;
1962         }
1963
1964         case VIDIOC_G_FMT:
1965         {
1966                 struct v4l2_format format;
1967                 struct v4l2_pix_format* pfmt = &(cam->sensor->pix_format);
1968
1969                 if (copy_from_user(&format, arg, sizeof(format)))
1970                         return -EFAULT;
1971
1972                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1973                         return -EINVAL;
1974
1975                 pfmt->bytesperline = (pfmt->pixelformat==V4L2_PIX_FMT_SN9C10X)
1976                                      ? 0 : (pfmt->width * pfmt->priv) / 8;
1977                 pfmt->sizeimage = pfmt->height * ((pfmt->width*pfmt->priv)/8);
1978                 pfmt->field = V4L2_FIELD_NONE;
1979                 memcpy(&(format.fmt.pix), pfmt, sizeof(*pfmt));
1980
1981                 if (copy_to_user(arg, &format, sizeof(format)))
1982                         return -EFAULT;
1983
1984                 return 0;
1985         }
1986
1987         case VIDIOC_TRY_FMT:
1988         case VIDIOC_S_FMT:
1989         {
1990                 struct sn9c102_sensor* s = cam->sensor;
1991                 struct v4l2_format format;
1992                 struct v4l2_pix_format* pix;
1993                 struct v4l2_pix_format* pfmt = &(s->pix_format);
1994                 struct v4l2_rect* bounds = &(s->cropcap.bounds);
1995                 struct v4l2_rect rect;
1996                 u8 scale;
1997                 const enum sn9c102_stream_state stream = cam->stream;
1998                 const u32 nbuffers = cam->nbuffers;
1999                 u32 i;
2000                 int err = 0;
2001
2002                 if (copy_from_user(&format, arg, sizeof(format)))
2003                         return -EFAULT;
2004
2005                 pix = &(format.fmt.pix);
2006
2007                 if (format.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2008                         return -EINVAL;
2009
2010                 memcpy(&rect, &(s->_rect), sizeof(rect));
2011
2012                 { /* calculate the actual scaling factor */
2013                         u32 a, b;
2014                         a = rect.width * rect.height;
2015                         b = pix->width * pix->height;
2016                         scale = b ? (u8)((a / b) < 4 ? 1 :
2017                                         ((a / b) < 16 ? 2 : 4)) : 1;
2018                 }
2019
2020                 rect.width = scale * pix->width;
2021                 rect.height = scale * pix->height;
2022
2023                 if (rect.width < 16)
2024                         rect.width = 16;
2025                 if (rect.height < 16)
2026                         rect.height = 16;
2027                 if (rect.width > bounds->left + bounds->width - rect.left)
2028                         rect.width = bounds->left + bounds->width - rect.left;
2029                 if (rect.height > bounds->top + bounds->height - rect.top)
2030                         rect.height = bounds->top + bounds->height - rect.top;
2031
2032                 rect.width &= ~15L;
2033                 rect.height &= ~15L;
2034
2035                 { /* adjust the scaling factor */
2036                         u32 a, b;
2037                         a = rect.width * rect.height;
2038                         b = pix->width * pix->height;
2039                         scale = b ? (u8)((a / b) < 4 ? 1 :
2040                                         ((a / b) < 16 ? 2 : 4)) : 1;
2041                 }
2042
2043                 pix->width = rect.width / scale;
2044                 pix->height = rect.height / scale;
2045
2046                 if (pix->pixelformat != V4L2_PIX_FMT_SN9C10X &&
2047                     pix->pixelformat != V4L2_PIX_FMT_SBGGR8)
2048                         pix->pixelformat = pfmt->pixelformat;
2049                 pix->priv = pfmt->priv; /* bpp */
2050                 pix->colorspace = pfmt->colorspace;
2051                 pix->bytesperline = (pix->pixelformat == V4L2_PIX_FMT_SN9C10X)
2052                                     ? 0 : (pix->width * pix->priv) / 8;
2053                 pix->sizeimage = pix->height * ((pix->width * pix->priv) / 8);
2054                 pix->field = V4L2_FIELD_NONE;
2055
2056                 if (cmd == VIDIOC_TRY_FMT) {
2057                         if (copy_to_user(arg, &format, sizeof(format)))
2058                                 return -EFAULT;
2059                         return 0;
2060                 }
2061
2062                 for (i = 0; i < cam->nbuffers; i++)
2063                         if (cam->frame[i].vma_use_count) {
2064                                 DBG(3, "VIDIOC_S_FMT failed. "
2065                                        "Unmap the buffers first.")
2066                                 return -EINVAL;
2067                         }
2068
2069                 if (cam->stream == STREAM_ON)
2070                         if ((err = sn9c102_stream_interrupt(cam)))
2071                                 return err;
2072
2073                 if (copy_to_user(arg, &format, sizeof(format))) {
2074                         cam->stream = stream;
2075                         return -EFAULT;
2076                 }
2077
2078                 sn9c102_release_buffers(cam);
2079
2080                 err += sn9c102_set_format(cam, pix);
2081                 err += sn9c102_set_crop(cam, &rect);
2082                 if (s->set_crop)
2083                         err += s->set_crop(cam, &rect);
2084                 err += sn9c102_set_scale(cam, scale);
2085
2086                 if (err) { /* atomic, no rollback in ioctl() */
2087                         cam->state |= DEV_MISCONFIGURED;
2088                         DBG(1, "VIDIOC_S_FMT failed because of hardware "
2089                                "problems. To use the camera, close and open "
2090                                "/dev/video%d again.", cam->v4ldev->minor)
2091                         return -EIO;
2092                 }
2093
2094                 memcpy(pfmt, pix, sizeof(*pix));
2095                 memcpy(&(s->_rect), &rect, sizeof(rect));
2096
2097                 if (nbuffers != sn9c102_request_buffers(cam, nbuffers)) {
2098                         cam->state |= DEV_MISCONFIGURED;
2099                         DBG(1, "VIDIOC_S_FMT failed because of not enough "
2100                                "memory. To use the camera, close and open "
2101                                "/dev/video%d again.", cam->v4ldev->minor)
2102                         return -ENOMEM;
2103                 }
2104
2105                 cam->stream = stream;
2106
2107                 return 0;
2108         }
2109
2110         case VIDIOC_G_JPEGCOMP:
2111         {
2112                 if (copy_to_user(arg, &cam->compression,
2113                                  sizeof(cam->compression)))
2114                         return -EFAULT;
2115
2116                 return 0;
2117         }
2118
2119         case VIDIOC_S_JPEGCOMP:
2120         {
2121                 struct v4l2_jpegcompression jc;
2122                 const enum sn9c102_stream_state stream = cam->stream;
2123                 int err = 0;
2124
2125                 if (copy_from_user(&jc, arg, sizeof(jc)))
2126                         return -EFAULT;
2127
2128                 if (jc.quality != 0 && jc.quality != 1)
2129                         return -EINVAL;
2130
2131                 if (cam->stream == STREAM_ON)
2132                         if ((err = sn9c102_stream_interrupt(cam)))
2133                                 return err;
2134
2135                 err += sn9c102_set_compression(cam, &jc);
2136                 if (err) { /* atomic, no rollback in ioctl() */
2137                         cam->state |= DEV_MISCONFIGURED;
2138                         DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2139                                "problems. To use the camera, close and open "
2140                                "/dev/video%d again.", cam->v4ldev->minor)
2141                         return -EIO;
2142                 }
2143
2144                 cam->compression.quality = jc.quality;
2145
2146                 cam->stream = stream;
2147
2148                 return 0;
2149         }
2150
2151         case VIDIOC_REQBUFS:
2152         {
2153                 struct v4l2_requestbuffers rb;
2154                 u32 i;
2155                 int err;
2156
2157                 if (copy_from_user(&rb, arg, sizeof(rb)))
2158                         return -EFAULT;
2159
2160                 if (rb.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2161                     rb.memory != V4L2_MEMORY_MMAP)
2162                         return -EINVAL;
2163
2164                 if (cam->io == IO_READ) {
2165                         DBG(3, "Close and open the device again to choose "
2166                                "the mmap I/O method")
2167                         return -EINVAL;
2168                 }
2169
2170                 for (i = 0; i < cam->nbuffers; i++)
2171                         if (cam->frame[i].vma_use_count) {
2172                                 DBG(3, "VIDIOC_REQBUFS failed. "
2173                                        "Previous buffers are still mapped.")
2174                                 return -EINVAL;
2175                         }
2176
2177                 if (cam->stream == STREAM_ON)
2178                         if ((err = sn9c102_stream_interrupt(cam)))
2179                                 return err;
2180
2181                 sn9c102_empty_framequeues(cam);
2182
2183                 sn9c102_release_buffers(cam);
2184                 if (rb.count)
2185                         rb.count = sn9c102_request_buffers(cam, rb.count);
2186
2187                 if (copy_to_user(arg, &rb, sizeof(rb))) {
2188                         sn9c102_release_buffers(cam);
2189                         cam->io = IO_NONE;
2190                         return -EFAULT;
2191                 }
2192
2193                 cam->io = rb.count ? IO_MMAP : IO_NONE;
2194
2195                 return 0;
2196         }
2197
2198         case VIDIOC_QUERYBUF:
2199         {
2200                 struct v4l2_buffer b;
2201
2202                 if (copy_from_user(&b, arg, sizeof(b)))
2203                         return -EFAULT;
2204
2205                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2206                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2207                         return -EINVAL;
2208
2209                 memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
2210
2211                 if (cam->frame[b.index].vma_use_count)
2212                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2213
2214                 if (cam->frame[b.index].state == F_DONE)
2215                         b.flags |= V4L2_BUF_FLAG_DONE;
2216                 else if (cam->frame[b.index].state != F_UNUSED)
2217                         b.flags |= V4L2_BUF_FLAG_QUEUED;
2218
2219                 if (copy_to_user(arg, &b, sizeof(b)))
2220                         return -EFAULT;
2221
2222                 return 0;
2223         }
2224
2225         case VIDIOC_QBUF:
2226         {
2227                 struct v4l2_buffer b;
2228                 unsigned long lock_flags;
2229
2230                 if (copy_from_user(&b, arg, sizeof(b)))
2231                         return -EFAULT;
2232
2233                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2234                     b.index >= cam->nbuffers || cam->io != IO_MMAP)
2235                         return -EINVAL;
2236
2237                 if (cam->frame[b.index].state != F_UNUSED)
2238                         return -EINVAL;
2239
2240                 cam->frame[b.index].state = F_QUEUED;
2241
2242                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2243                 list_add_tail(&cam->frame[b.index].frame, &cam->inqueue);
2244                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2245
2246                 PDBGG("Frame #%lu queued", (unsigned long)b.index)
2247
2248                 return 0;
2249         }
2250
2251         case VIDIOC_DQBUF:
2252         {
2253                 struct v4l2_buffer b;
2254                 struct sn9c102_frame_t *f;
2255                 unsigned long lock_flags;
2256                 int err = 0;
2257
2258                 if (copy_from_user(&b, arg, sizeof(b)))
2259                         return -EFAULT;
2260
2261                 if (b.type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io!= IO_MMAP)
2262                         return -EINVAL;
2263
2264                 if (list_empty(&cam->outqueue)) {
2265                         if (cam->stream == STREAM_OFF)
2266                                 return -EINVAL;
2267                         if (filp->f_flags & O_NONBLOCK)
2268                                 return -EAGAIN;
2269                         err = wait_event_interruptible
2270                               ( cam->wait_frame,
2271                                 (!list_empty(&cam->outqueue)) ||
2272                                 (cam->state & DEV_DISCONNECTED) );
2273                         if (err)
2274                                 return err;
2275                         if (cam->state & DEV_DISCONNECTED)
2276                                 return -ENODEV;
2277                 }
2278
2279                 spin_lock_irqsave(&cam->queue_lock, lock_flags);
2280                 f = list_entry(cam->outqueue.next, struct sn9c102_frame_t,
2281                                frame);
2282                 list_del(cam->outqueue.next);
2283                 spin_unlock_irqrestore(&cam->queue_lock, lock_flags);
2284
2285                 f->state = F_UNUSED;
2286
2287                 memcpy(&b, &f->buf, sizeof(b));
2288                 if (f->vma_use_count)
2289                         b.flags |= V4L2_BUF_FLAG_MAPPED;
2290
2291                 if (copy_to_user(arg, &b, sizeof(b)))
2292                         return -EFAULT;
2293
2294                 PDBGG("Frame #%lu dequeued", (unsigned long)f->buf.index)
2295
2296                 return 0;
2297         }
2298
2299         case VIDIOC_STREAMON:
2300         {
2301                 int type;
2302
2303                 if (copy_from_user(&type, arg, sizeof(type)))
2304                         return -EFAULT;
2305
2306                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2307                         return -EINVAL;
2308
2309                 if (list_empty(&cam->inqueue))
2310                         return -EINVAL;
2311
2312                 cam->stream = STREAM_ON;
2313
2314                 DBG(3, "Stream on")
2315
2316                 return 0;
2317         }
2318
2319         case VIDIOC_STREAMOFF:
2320         {
2321                 int type, err;
2322
2323                 if (copy_from_user(&type, arg, sizeof(type)))
2324                         return -EFAULT;
2325
2326                 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE || cam->io != IO_MMAP)
2327                         return -EINVAL;
2328
2329                 if (cam->stream == STREAM_ON)
2330                         if ((err = sn9c102_stream_interrupt(cam)))
2331                                 return err;
2332
2333                 sn9c102_empty_framequeues(cam);
2334
2335                 DBG(3, "Stream off")
2336
2337                 return 0;
2338         }
2339
2340         case VIDIOC_G_PARM:
2341         {
2342                 struct v4l2_streamparm sp;
2343
2344                 if (copy_from_user(&sp, arg, sizeof(sp)))
2345                         return -EFAULT;
2346
2347                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2348                         return -EINVAL;
2349
2350                 sp.parm.capture.extendedmode = 0;
2351                 sp.parm.capture.readbuffers = cam->nreadbuffers;
2352
2353                 if (copy_to_user(arg, &sp, sizeof(sp)))
2354                         return -EFAULT;
2355
2356                 return 0;
2357         }
2358
2359         case VIDIOC_S_PARM:
2360         {
2361                 struct v4l2_streamparm sp;
2362
2363                 if (copy_from_user(&sp, arg, sizeof(sp)))
2364                         return -EFAULT;
2365
2366                 if (sp.type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2367                         return -EINVAL;
2368
2369                 sp.parm.capture.extendedmode = 0;
2370
2371                 if (sp.parm.capture.readbuffers == 0)
2372                         sp.parm.capture.readbuffers = cam->nreadbuffers;
2373
2374                 if (sp.parm.capture.readbuffers > SN9C102_MAX_FRAMES)
2375                         sp.parm.capture.readbuffers = SN9C102_MAX_FRAMES;
2376
2377                 if (copy_to_user(arg, &sp, sizeof(sp)))
2378                         return -EFAULT;
2379
2380                 cam->nreadbuffers = sp.parm.capture.readbuffers;
2381
2382                 return 0;
2383         }
2384
2385         case VIDIOC_G_STD:
2386         case VIDIOC_S_STD:
2387         case VIDIOC_QUERYSTD:
2388         case VIDIOC_ENUMSTD:
2389         case VIDIOC_QUERYMENU:
2390                 return -EINVAL;
2391
2392         default:
2393                 return -EINVAL;
2394
2395         }
2396 }
2397
2398
2399 static int sn9c102_ioctl(struct inode* inode, struct file* filp,
2400                          unsigned int cmd, unsigned long arg)
2401 {
2402         struct sn9c102_device* cam = video_get_drvdata(video_devdata(filp));
2403         int err = 0;
2404
2405         if (down_interruptible(&cam->fileop_sem))
2406                 return -ERESTARTSYS;
2407
2408         if (cam->state & DEV_DISCONNECTED) {
2409                 DBG(1, "Device not present")
2410                 up(&cam->fileop_sem);
2411                 return -ENODEV;
2412         }
2413
2414         if (cam->state & DEV_MISCONFIGURED) {
2415                 DBG(1, "The camera is misconfigured. Close and open it again.")
2416                 up(&cam->fileop_sem);
2417                 return -EIO;
2418         }
2419
2420         err = sn9c102_v4l2_ioctl(inode, filp, cmd, (void __user *)arg);
2421
2422         up(&cam->fileop_sem);
2423
2424         return err;
2425 }
2426
2427
2428 static struct file_operations sn9c102_fops = {
2429         .owner =   THIS_MODULE,
2430         .open =    sn9c102_open,
2431         .release = sn9c102_release,
2432         .ioctl =   sn9c102_ioctl,
2433         .read =    sn9c102_read,
2434         .poll =    sn9c102_poll,
2435         .mmap =    sn9c102_mmap,
2436         .llseek =  no_llseek,
2437 };
2438
2439 /*****************************************************************************/
2440
2441 /* It exists a single interface only. We do not need to validate anything. */
2442 static int
2443 sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
2444 {
2445         struct usb_device *udev = interface_to_usbdev(intf);
2446         struct sn9c102_device* cam;
2447         static unsigned int dev_nr = 0;
2448         unsigned int i, n;
2449         int err = 0, r;
2450
2451         n = sizeof(sn9c102_id_table)/sizeof(sn9c102_id_table[0]);
2452         for (i = 0; i < n-1; i++)
2453                 if (udev->descriptor.idVendor==sn9c102_id_table[i].idVendor &&
2454                     udev->descriptor.idProduct==sn9c102_id_table[i].idProduct)
2455                         break;
2456         if (i == n-1)
2457                 return -ENODEV;
2458
2459         if (!(cam = kmalloc(sizeof(struct sn9c102_device), GFP_KERNEL)))
2460                 return -ENOMEM;
2461         memset(cam, 0, sizeof(*cam));
2462
2463         cam->usbdev = udev;
2464
2465         memcpy(&cam->dev, &udev->dev, sizeof(struct device));
2466
2467         if (!(cam->control_buffer = kmalloc(8, GFP_KERNEL))) {
2468                 DBG(1, "kmalloc() failed")
2469                 err = -ENOMEM;
2470                 goto fail;
2471         }
2472         memset(cam->control_buffer, 0, 8);
2473
2474         if (!(cam->v4ldev = video_device_alloc())) {
2475                 DBG(1, "video_device_alloc() failed")
2476                 err = -ENOMEM;
2477                 goto fail;
2478         }
2479
2480         init_MUTEX(&cam->dev_sem);
2481
2482         r = sn9c102_read_reg(cam, 0x00);
2483         if (r < 0 || r != 0x10) {
2484                 DBG(1, "Sorry, this is not a SN9C10x based camera "
2485                        "(vid/pid 0x%04X/0x%04X)",
2486                     sn9c102_id_table[i].idVendor,sn9c102_id_table[i].idProduct)
2487                 err = -ENODEV;
2488                 goto fail;
2489         }
2490
2491         cam->bridge = (sn9c102_id_table[i].idProduct & 0xffc0) == 0x6080 ?
2492                       BRIDGE_SN9C103 : BRIDGE_SN9C102;
2493         switch (cam->bridge) {
2494         case BRIDGE_SN9C101:
2495         case BRIDGE_SN9C102:
2496                 DBG(2, "SN9C10[12] PC Camera Controller detected "
2497                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2498                     sn9c102_id_table[i].idProduct)
2499                 break;
2500         case BRIDGE_SN9C103:
2501                 DBG(2, "SN9C103 PC Camera Controller detected "
2502                        "(vid/pid 0x%04X/0x%04X)", sn9c102_id_table[i].idVendor,
2503                     sn9c102_id_table[i].idProduct)
2504                 break;
2505         }
2506
2507         for  (i = 0; sn9c102_sensor_table[i]; i++) {
2508                 err = sn9c102_sensor_table[i](cam);
2509                 if (!err)
2510                         break;
2511         }
2512
2513         if (!err && cam->sensor) {
2514                 DBG(2, "%s image sensor detected", cam->sensor->name)
2515                 DBG(3, "Support for %s maintained by %s",
2516                     cam->sensor->name, cam->sensor->maintainer)
2517         } else {
2518                 DBG(1, "No supported image sensor detected")
2519                 err = -ENODEV;
2520                 goto fail;
2521         }
2522
2523         if (sn9c102_init(cam)) {
2524                 DBG(1, "Initialization failed. I will retry on open().")
2525                 cam->state |= DEV_MISCONFIGURED;
2526         }
2527
2528         strcpy(cam->v4ldev->name, "SN9C10x PC Camera");
2529         cam->v4ldev->owner = THIS_MODULE;
2530         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
2531         cam->v4ldev->hardware = VID_HARDWARE_SN9C102;
2532         cam->v4ldev->fops = &sn9c102_fops;
2533         cam->v4ldev->minor = video_nr[dev_nr];
2534         cam->v4ldev->release = video_device_release;
2535         video_set_drvdata(cam->v4ldev, cam);
2536
2537         down(&cam->dev_sem);
2538
2539         err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
2540                                     video_nr[dev_nr]);
2541         if (err) {
2542                 DBG(1, "V4L2 device registration failed")
2543                 if (err == -ENFILE && video_nr[dev_nr] == -1)
2544                         DBG(1, "Free /dev/videoX node not found")
2545                 video_nr[dev_nr] = -1;
2546                 dev_nr = (dev_nr < SN9C102_MAX_DEVICES-1) ? dev_nr+1 : 0;
2547                 up(&cam->dev_sem);
2548                 goto fail;
2549         }
2550
2551         DBG(2, "V4L2 device registered as /dev/video%d", cam->v4ldev->minor)
2552
2553         sn9c102_create_sysfs(cam);
2554
2555         usb_set_intfdata(intf, cam);
2556
2557         up(&cam->dev_sem);
2558
2559         return 0;
2560
2561 fail:
2562         if (cam) {
2563                 kfree(cam->control_buffer);
2564                 if (cam->v4ldev)
2565                         video_device_release(cam->v4ldev);
2566                 kfree(cam);
2567         }
2568         return err;
2569 }
2570
2571
2572 static void sn9c102_usb_disconnect(struct usb_interface* intf)
2573 {
2574         struct sn9c102_device* cam = usb_get_intfdata(intf);
2575
2576         if (!cam)
2577                 return;
2578
2579         down_write(&sn9c102_disconnect);
2580
2581         down(&cam->dev_sem);
2582
2583         DBG(2, "Disconnecting %s...", cam->v4ldev->name)
2584
2585         wake_up_interruptible_all(&cam->open);
2586
2587         if (cam->users) {
2588                 DBG(2, "Device /dev/video%d is open! Deregistration and "
2589                        "memory deallocation are deferred on close.",
2590                     cam->v4ldev->minor)
2591                 cam->state |= DEV_MISCONFIGURED;
2592                 sn9c102_stop_transfer(cam);
2593                 cam->state |= DEV_DISCONNECTED;
2594                 wake_up_interruptible(&cam->wait_frame);
2595                 wake_up_interruptible(&cam->wait_stream);
2596         } else {
2597                 cam->state |= DEV_DISCONNECTED;
2598                 sn9c102_release_resources(cam);
2599         }
2600
2601         up(&cam->dev_sem);
2602
2603         if (!cam->users)
2604                 kfree(cam);
2605
2606         up_write(&sn9c102_disconnect);
2607 }
2608
2609
2610 static struct usb_driver sn9c102_usb_driver = {
2611         .owner =      THIS_MODULE,
2612         .name =       "sn9c102",
2613         .id_table =   sn9c102_id_table,
2614         .probe =      sn9c102_usb_probe,
2615         .disconnect = sn9c102_usb_disconnect,
2616 };
2617
2618 /*****************************************************************************/
2619
2620 static int __init sn9c102_module_init(void)
2621 {
2622         int err = 0;
2623
2624         KDBG(2, SN9C102_MODULE_NAME " v" SN9C102_MODULE_VERSION)
2625         KDBG(3, SN9C102_MODULE_AUTHOR)
2626
2627         if ((err = usb_register(&sn9c102_usb_driver)))
2628                 KDBG(1, "usb_register() failed")
2629
2630         return err;
2631 }
2632
2633
2634 static void __exit sn9c102_module_exit(void)
2635 {
2636         usb_deregister(&sn9c102_usb_driver);
2637 }
2638
2639
2640 module_init(sn9c102_module_init);
2641 module_exit(sn9c102_module_exit);