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