drivers/usb/media/sn9c102_core.c

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