git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/bw-qcam.c

   1 /*
   2  *    QuickCam Driver For Video4Linux.
   3  *
   4  *      Video4Linux conversion work by Alan Cox.
   5  *      Parport compatibility by Phil Blundell.
   6  *      Busy loop avoidance by Mark Cooke.
   7  *
   8  *    Module parameters:
   9  *
  10  *      maxpoll=<1 - 5000>
  11  *
  12  *        When polling the QuickCam for a response, busy-wait for a
  13  *        maximum of this many loops. The default of 250 gives little
  14  *        impact on interactive response.
  15  *
  16  *        NOTE: If this parameter is set too high, the processor
  17  *              will busy wait until this loop times out, and then
  18  *              slowly poll for a further 5 seconds before failing
  19  *              the transaction. You have been warned.
  20  *
  21  *      yieldlines=<1 - 250>
  22  *
  23  *        When acquiring a frame from the camera, the data gathering
  24  *        loop will yield back to the scheduler after completing
  25  *        this many lines. The default of 4 provides a trade-off
  26  *        between increased frame acquisition time and impact on
  27  *        interactive response.
  28  */
  29
  30 /* qcam-lib.c -- Library for programming with the Connectix QuickCam.
  31  * See the included documentation for usage instructions and details
  32  * of the protocol involved. */
  33
  34
  35 /* Version 0.5, August 4, 1996 */
  36 /* Version 0.7, August 27, 1996 */
  37 /* Version 0.9, November 17, 1996 */
  38
  39
  40 /******************************************************************
  41
  42 Copyright (C) 1996 by Scott Laird
  43
  44 Permission is hereby granted, free of charge, to any person obtaining
  45 a copy of this software and associated documentation files (the
  46 "Software"), to deal in the Software without restriction, including
  47 without limitation the rights to use, copy, modify, merge, publish,
  48 distribute, sublicense, and/or sell copies of the Software, and to
  49 permit persons to whom the Software is furnished to do so, subject to
  50 the following conditions:
  51
  52 The above copyright notice and this permission notice shall be
  53 included in all copies or substantial portions of the Software.
  54
  55 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  56 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  57 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  58 IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
  59 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  60 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  61 OTHER DEALINGS IN THE SOFTWARE.
  62
  63 ******************************************************************/
  64
  65 #include <linux/module.h>
  66 #include <linux/delay.h>
  67 #include <linux/errno.h>
  68 #include <linux/fs.h>
  69 #include <linux/init.h>
  70 #include <linux/kernel.h>
  71 #include <linux/slab.h>
  72 #include <linux/mm.h>
  73 #include <linux/parport.h>
  74 #include <linux/sched.h>
  75 #include <linux/videodev.h>
  76 #include <media/v4l2-common.h>
  77 #include <media/v4l2-ioctl.h>
  78 #include <linux/mutex.h>
  79 #include <asm/uaccess.h>
  80
  81 #include "bw-qcam.h"
  82
  83 static unsigned int maxpoll=250;   /* Maximum busy-loop count for qcam I/O */
  84 static unsigned int yieldlines=4;  /* Yield after this many during capture */
  85 static int video_nr = -1;
  86 static unsigned int force_init;         /* Whether to probe aggressively */
  87
  88 module_param(maxpoll, int, 0);
  89 module_param(yieldlines, int, 0);
  90 module_param(video_nr, int, 0);
  91
  92 /* Set force_init=1 to avoid detection by polling status register and
  93  * immediately attempt to initialize qcam */
  94 module_param(force_init, int, 0);
  95
  96 static inline int read_lpstatus(struct qcam_device *q)
  97 {
  98         return parport_read_status(q->pport);
  99 }
 100
 101 static inline int read_lpdata(struct qcam_device *q)
 102 {
 103         return parport_read_data(q->pport);
 104 }
 105
 106 static inline void write_lpdata(struct qcam_device *q, int d)
 107 {
 108         parport_write_data(q->pport, d);
 109 }
 110
 111 static inline void write_lpcontrol(struct qcam_device *q, int d)
 112 {
 113         if (d & 0x20) {
 114                 /* Set bidirectional mode to reverse (data in) */
 115                 parport_data_reverse(q->pport);
 116         } else {
 117                 /* Set bidirectional mode to forward (data out) */
 118                 parport_data_forward(q->pport);
 119         }
 120
 121         /* Now issue the regular port command, but strip out the
 122          * direction flag */
 123         d &= ~0x20;
 124         parport_write_control(q->pport, d);
 125 }
 126
 127 static int qc_waithand(struct qcam_device *q, int val);
 128 static int qc_command(struct qcam_device *q, int command);
 129 static int qc_readparam(struct qcam_device *q);
 130 static int qc_setscanmode(struct qcam_device *q);
 131 static int qc_readbytes(struct qcam_device *q, char buffer[]);
 132
 133 static struct video_device qcam_template;
 134
 135 static int qc_calibrate(struct qcam_device *q)
 136 {
 137         /*
 138          *      Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
 139          *      The white balance is an individiual value for each
 140          *      quickcam.
 141          */
 142
 143         int value;
 144         int count = 0;
 145
 146         qc_command(q, 27);      /* AutoAdjustOffset */
 147         qc_command(q, 0);       /* Dummy Parameter, ignored by the camera */
 148
 149         /* GetOffset (33) will read 255 until autocalibration */
 150         /* is finished. After that, a value of 1-254 will be */
 151         /* returned. */
 152
 153         do {
 154                 qc_command(q, 33);
 155                 value = qc_readparam(q);
 156                 mdelay(1);
 157                 schedule();
 158                 count++;
 159         } while (value == 0xff && count<2048);
 160
 161         q->whitebal = value;
 162         return value;
 163 }
 164
 165 /* Initialize the QuickCam driver control structure.  This is where
 166  * defaults are set for people who don't have a config file.*/
 167
 168 static struct qcam_device *qcam_init(struct parport *port)
 169 {
 170         struct qcam_device *q;
 171
 172         q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
 173         if(q==NULL)
 174                 return NULL;
 175
 176         q->pport = port;
 177         q->pdev = parport_register_device(port, "bw-qcam", NULL, NULL,
 178                                           NULL, 0, NULL);
 179         if (q->pdev == NULL)
 180         {
 181                 printk(KERN_ERR "bw-qcam: couldn't register for %s.\n",
 182                        port->name);
 183                 kfree(q);
 184                 return NULL;
 185         }
 186
 187         memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
 188
 189         mutex_init(&q->lock);
 190
 191         q->port_mode = (QC_ANY | QC_NOTSET);
 192         q->width = 320;
 193         q->height = 240;
 194         q->bpp = 4;
 195         q->transfer_scale = 2;
 196         q->contrast = 192;
 197         q->brightness = 180;
 198         q->whitebal = 105;
 199         q->top = 1;
 200         q->left = 14;
 201         q->mode = -1;
 202         q->status = QC_PARAM_CHANGE;
 203         return q;
 204 }
 205
 206
 207 /* qc_command is probably a bit of a misnomer -- it's used to send
 208  * bytes *to* the camera.  Generally, these bytes are either commands
 209  * or arguments to commands, so the name fits, but it still bugs me a
 210  * bit.  See the documentation for a list of commands. */
 211
 212 static int qc_command(struct qcam_device *q, int command)
 213 {
 214         int n1, n2;
 215         int cmd;
 216
 217         write_lpdata(q, command);
 218         write_lpcontrol(q, 6);
 219
 220         n1 = qc_waithand(q, 1);
 221
 222         write_lpcontrol(q, 0xe);
 223         n2 = qc_waithand(q, 0);
 224
 225         cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
 226         return cmd;
 227 }
 228
 229 static int qc_readparam(struct qcam_device *q)
 230 {
 231         int n1, n2;
 232         int cmd;
 233
 234         write_lpcontrol(q, 6);
 235         n1 = qc_waithand(q, 1);
 236
 237         write_lpcontrol(q, 0xe);
 238         n2 = qc_waithand(q, 0);
 239
 240         cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
 241         return cmd;
 242 }
 243
 244 /* qc_waithand busy-waits for a handshake signal from the QuickCam.
 245  * Almost all communication with the camera requires handshaking. */
 246
 247 static int qc_waithand(struct qcam_device *q, int val)
 248 {
 249         int status;
 250         int runs=0;
 251
 252         if (val)
 253         {
 254                 while (!((status = read_lpstatus(q)) & 8))
 255                 {
 256                         /* 1000 is enough spins on the I/O for all normal
 257                            cases, at that point we start to poll slowly
 258                            until the camera wakes up. However, we are
 259                            busy blocked until the camera responds, so
 260                            setting it lower is much better for interactive
 261                            response. */
 262
 263                         if(runs++>maxpoll)
 264                         {
 265                                 msleep_interruptible(5);
 266                         }
 267                         if(runs>(maxpoll+1000)) /* 5 seconds */
 268                                 return -1;
 269                 }
 270         }
 271         else
 272         {
 273                 while (((status = read_lpstatus(q)) & 8))
 274                 {
 275                         /* 1000 is enough spins on the I/O for all normal
 276                            cases, at that point we start to poll slowly
 277                            until the camera wakes up. However, we are
 278                            busy blocked until the camera responds, so
 279                            setting it lower is much better for interactive
 280                            response. */
 281
 282                         if(runs++>maxpoll)
 283                         {
 284                                 msleep_interruptible(5);
 285                         }
 286                         if(runs++>(maxpoll+1000)) /* 5 seconds */
 287                                 return -1;
 288                 }
 289         }
 290
 291         return status;
 292 }
 293
 294 /* Waithand2 is used when the qcam is in bidirectional mode, and the
 295  * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
 296  * (bit 3 of status register).  It also returns the last value read,
 297  * since this data is useful. */
 298
 299 static unsigned int qc_waithand2(struct qcam_device *q, int val)
 300 {
 301         unsigned int status;
 302         int runs=0;
 303
 304         do
 305         {
 306                 status = read_lpdata(q);
 307                 /* 1000 is enough spins on the I/O for all normal
 308                    cases, at that point we start to poll slowly
 309                    until the camera wakes up. However, we are
 310                    busy blocked until the camera responds, so
 311                    setting it lower is much better for interactive
 312                    response. */
 313
 314                 if(runs++>maxpoll)
 315                 {
 316                         msleep_interruptible(5);
 317                 }
 318                 if(runs++>(maxpoll+1000)) /* 5 seconds */
 319                         return 0;
 320         }
 321         while ((status & 1) != val);
 322
 323         return status;
 324 }
 325
 326
 327 /* Try to detect a QuickCam.  It appears to flash the upper 4 bits of
 328    the status register at 5-10 Hz.  This is only used in the autoprobe
 329    code.  Be aware that this isn't the way Connectix detects the
 330    camera (they send a reset and try to handshake), but this should be
 331    almost completely safe, while their method screws up my printer if
 332    I plug it in before the camera. */
 333
 334 static int qc_detect(struct qcam_device *q)
 335 {
 336         int reg, lastreg;
 337         int count = 0;
 338         int i;
 339
 340         if (force_init)
 341                 return 1;
 342
 343         lastreg = reg = read_lpstatus(q) & 0xf0;
 344
 345         for (i = 0; i < 500; i++)
 346         {
 347                 reg = read_lpstatus(q) & 0xf0;
 348                 if (reg != lastreg)
 349                         count++;
 350                 lastreg = reg;
 351                 mdelay(2);
 352         }
 353
 354
 355 #if 0
 356         /* Force camera detection during testing. Sometimes the camera
 357            won't be flashing these bits. Possibly unloading the module
 358            in the middle of a grab? Or some timeout condition?
 359            I've seen this parameter as low as 19 on my 450Mhz box - mpc */
 360         printk("Debugging: QCam detection counter <30-200 counts as detected>: %d\n", count);
 361         return 1;
 362 #endif
 363
 364         /* Be (even more) liberal in what you accept...  */
 365
 366         if (count > 20 && count < 400) {
 367                 return 1;       /* found */
 368         } else {
 369                 printk(KERN_ERR "No Quickcam found on port %s\n",
 370                         q->pport->name);
 371                 printk(KERN_DEBUG "Quickcam detection counter: %u\n", count);
 372                 return 0;       /* not found */
 373         }
 374 }
 375
 376
 377 /* Reset the QuickCam.  This uses the same sequence the Windows
 378  * QuickPic program uses.  Someone with a bi-directional port should
 379  * check that bi-directional mode is detected right, and then
 380  * implement bi-directional mode in qc_readbyte(). */
 381
 382 static void qc_reset(struct qcam_device *q)
 383 {
 384         switch (q->port_mode & QC_FORCE_MASK)
 385         {
 386                 case QC_FORCE_UNIDIR:
 387                         q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
 388                         break;
 389
 390                 case QC_FORCE_BIDIR:
 391                         q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
 392                         break;
 393
 394                 case QC_ANY:
 395                         write_lpcontrol(q, 0x20);
 396                         write_lpdata(q, 0x75);
 397
 398                         if (read_lpdata(q) != 0x75) {
 399                                 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
 400                         } else {
 401                                 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
 402                         }
 403                         break;
 404         }
 405
 406         write_lpcontrol(q, 0xb);
 407         udelay(250);
 408         write_lpcontrol(q, 0xe);
 409         qc_setscanmode(q);              /* in case port_mode changed */
 410 }
 411
 412
 413 /* Decide which scan mode to use.  There's no real requirement that
 414  * the scanmode match the resolution in q->height and q-> width -- the
 415  * camera takes the picture at the resolution specified in the
 416  * "scanmode" and then returns the image at the resolution specified
 417  * with the resolution commands.  If the scan is bigger than the
 418  * requested resolution, the upper-left hand corner of the scan is
 419  * returned.  If the scan is smaller, then the rest of the image
 420  * returned contains garbage. */
 421
 422 static int qc_setscanmode(struct qcam_device *q)
 423 {
 424         int old_mode = q->mode;
 425
 426         switch (q->transfer_scale)
 427         {
 428                 case 1:
 429                         q->mode = 0;
 430                         break;
 431                 case 2:
 432                         q->mode = 4;
 433                         break;
 434                 case 4:
 435                         q->mode = 8;
 436                         break;
 437         }
 438
 439         switch (q->bpp)
 440         {
 441                 case 4:
 442                         break;
 443                 case 6:
 444                         q->mode += 2;
 445                         break;
 446         }
 447
 448         switch (q->port_mode & QC_MODE_MASK)
 449         {
 450                 case QC_BIDIR:
 451                         q->mode += 1;
 452                         break;
 453                 case QC_NOTSET:
 454                 case QC_UNIDIR:
 455                         break;
 456         }
 457
 458         if (q->mode != old_mode)
 459                 q->status |= QC_PARAM_CHANGE;
 460
 461         return 0;
 462 }
 463
 464
 465 /* Reset the QuickCam and program for brightness, contrast,
 466  * white-balance, and resolution. */
 467
 468 static void qc_set(struct qcam_device *q)
 469 {
 470         int val;
 471         int val2;
 472
 473         qc_reset(q);
 474
 475         /* Set the brightness.  Yes, this is repetitive, but it works.
 476          * Shorter versions seem to fail subtly.  Feel free to try :-). */
 477         /* I think the problem was in qc_command, not here -- bls */
 478
 479         qc_command(q, 0xb);
 480         qc_command(q, q->brightness);
 481
 482         val = q->height / q->transfer_scale;
 483         qc_command(q, 0x11);
 484         qc_command(q, val);
 485         if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
 486                 /* The normal "transfers per line" calculation doesn't seem to work
 487                    as expected here (and yet it works fine in qc_scan).  No idea
 488                    why this case is the odd man out.  Fortunately, Laird's original
 489                    working version gives me a good way to guess at working values.
 490                    -- bls */
 491                 val = q->width;
 492                 val2 = q->transfer_scale * 4;
 493         } else {
 494                 val = q->width * q->bpp;
 495                 val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
 496                     q->transfer_scale;
 497         }
 498         val = DIV_ROUND_UP(val, val2);
 499         qc_command(q, 0x13);
 500         qc_command(q, val);
 501
 502         /* Setting top and left -- bls */
 503         qc_command(q, 0xd);
 504         qc_command(q, q->top);
 505         qc_command(q, 0xf);
 506         qc_command(q, q->left / 2);
 507
 508         qc_command(q, 0x19);
 509         qc_command(q, q->contrast);
 510         qc_command(q, 0x1f);
 511         qc_command(q, q->whitebal);
 512
 513         /* Clear flag that we must update the grabbing parameters on the camera
 514            before we grab the next frame */
 515         q->status &= (~QC_PARAM_CHANGE);
 516 }
 517
 518 /* Qc_readbytes reads some bytes from the QC and puts them in
 519    the supplied buffer.  It returns the number of bytes read,
 520    or -1 on error. */
 521
 522 static inline int qc_readbytes(struct qcam_device *q, char buffer[])
 523 {
 524         int ret=1;
 525         unsigned int hi, lo;
 526         unsigned int hi2, lo2;
 527         static int state;
 528
 529         if (buffer == NULL)
 530         {
 531                 state = 0;
 532                 return 0;
 533         }
 534
 535         switch (q->port_mode & QC_MODE_MASK)
 536         {
 537                 case QC_BIDIR:          /* Bi-directional Port */
 538                         write_lpcontrol(q, 0x26);
 539                         lo = (qc_waithand2(q, 1) >> 1);
 540                         hi = (read_lpstatus(q) >> 3) & 0x1f;
 541                         write_lpcontrol(q, 0x2e);
 542                         lo2 = (qc_waithand2(q, 0) >> 1);
 543                         hi2 = (read_lpstatus(q) >> 3) & 0x1f;
 544                         switch (q->bpp)
 545                         {
 546                                 case 4:
 547                                         buffer[0] = lo & 0xf;
 548                                         buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
 549                                         buffer[2] = (hi & 0x1e) >> 1;
 550                                         buffer[3] = lo2 & 0xf;
 551                                         buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
 552                                         buffer[5] = (hi2 & 0x1e) >> 1;
 553                                         ret = 6;
 554                                         break;
 555                                 case 6:
 556                                         buffer[0] = lo & 0x3f;
 557                                         buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
 558                                         buffer[2] = lo2 & 0x3f;
 559                                         buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
 560                                         ret = 4;
 561                                         break;
 562                         }
 563                         break;
 564
 565                 case QC_UNIDIR: /* Unidirectional Port */
 566                         write_lpcontrol(q, 6);
 567                         lo = (qc_waithand(q, 1) & 0xf0) >> 4;
 568                         write_lpcontrol(q, 0xe);
 569                         hi = (qc_waithand(q, 0) & 0xf0) >> 4;
 570
 571                         switch (q->bpp)
 572                         {
 573                                 case 4:
 574                                         buffer[0] = lo;
 575                                         buffer[1] = hi;
 576                                         ret = 2;
 577                                         break;
 578                                 case 6:
 579                                         switch (state)
 580                                         {
 581                                                 case 0:
 582                                                         buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
 583                                                         q->saved_bits = (hi & 3) << 4;
 584                                                         state = 1;
 585                                                         ret = 1;
 586                                                         break;
 587                                                 case 1:
 588                                                         buffer[0] = lo | q->saved_bits;
 589                                                         q->saved_bits = hi << 2;
 590                                                         state = 2;
 591                                                         ret = 1;
 592                                                         break;
 593                                                 case 2:
 594                                                         buffer[0] = ((lo & 0xc) >> 2) | q->saved_bits;
 595                                                         buffer[1] = ((lo & 3) << 4) | hi;
 596                                                         state = 0;
 597                                                         ret = 2;
 598                                                         break;
 599                                         }
 600                                         break;
 601                         }
 602                         break;
 603         }
 604         return ret;
 605 }
 606
 607 /* requests a scan from the camera.  It sends the correct instructions
 608  * to the camera and then reads back the correct number of bytes.  In
 609  * previous versions of this routine the return structure contained
 610  * the raw output from the camera, and there was a 'qc_convertscan'
 611  * function that converted that to a useful format.  In version 0.3 I
 612  * rolled qc_convertscan into qc_scan and now I only return the
 613  * converted scan.  The format is just an one-dimensional array of
 614  * characters, one for each pixel, with 0=black up to n=white, where
 615  * n=2^(bit depth)-1.  Ask me for more details if you don't understand
 616  * this. */
 617
 618 static long qc_capture(struct qcam_device * q, char __user *buf, unsigned long len)
 619 {
 620         int i, j, k, yield;
 621         int bytes;
 622         int linestotrans, transperline;
 623         int divisor;
 624         int pixels_per_line;
 625         int pixels_read = 0;
 626         int got=0;
 627         char buffer[6];
 628         int  shift=8-q->bpp;
 629         char invert;
 630
 631         if (q->mode == -1)
 632                 return -ENXIO;
 633
 634         qc_command(q, 0x7);
 635         qc_command(q, q->mode);
 636
 637         if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
 638         {
 639                 write_lpcontrol(q, 0x2e);       /* turn port around */
 640                 write_lpcontrol(q, 0x26);
 641                 (void) qc_waithand(q, 1);
 642                 write_lpcontrol(q, 0x2e);
 643                 (void) qc_waithand(q, 0);
 644         }
 645
 646         /* strange -- should be 15:63 below, but 4bpp is odd */
 647         invert = (q->bpp == 4) ? 16 : 63;
 648
 649         linestotrans = q->height / q->transfer_scale;
 650         pixels_per_line = q->width / q->transfer_scale;
 651         transperline = q->width * q->bpp;
 652         divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
 653             q->transfer_scale;
 654         transperline = DIV_ROUND_UP(transperline, divisor);
 655
 656         for (i = 0, yield = yieldlines; i < linestotrans; i++)
 657         {
 658                 for (pixels_read = j = 0; j < transperline; j++)
 659                 {
 660                         bytes = qc_readbytes(q, buffer);
 661                         for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++)
 662                         {
 663                                 int o;
 664                                 if (buffer[k] == 0 && invert == 16)
 665                                 {
 666                                         /* 4bpp is odd (again) -- inverter is 16, not 15, but output
 667                                            must be 0-15 -- bls */
 668                                         buffer[k] = 16;
 669                                 }
 670                                 o=i*pixels_per_line + pixels_read + k;
 671                                 if(o<len)
 672                                 {
 673                                         got++;
 674                                         put_user((invert - buffer[k])<<shift, buf+o);
 675                                 }
 676                         }
 677                         pixels_read += bytes;
 678                 }
 679                 (void) qc_readbytes(q, NULL);   /* reset state machine */
 680
 681                 /* Grabbing an entire frame from the quickcam is a lengthy
 682                    process. We don't (usually) want to busy-block the
 683                    processor for the entire frame. yieldlines is a module
 684                    parameter. If we yield every line, the minimum frame
 685                    time will be 240 / 200 = 1.2 seconds. The compile-time
 686                    default is to yield every 4 lines. */
 687                 if (i >= yield) {
 688                         msleep_interruptible(5);
 689                         yield = i + yieldlines;
 690                 }
 691         }
 692
 693         if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
 694         {
 695                 write_lpcontrol(q, 2);
 696                 write_lpcontrol(q, 6);
 697                 udelay(3);
 698                 write_lpcontrol(q, 0xe);
 699         }
 700         if(got<len)
 701                 return got;
 702         return len;
 703 }
 704
 705 /*
 706  *      Video4linux interfacing
 707  */
 708
 709 static int qcam_do_ioctl(struct inode *inode, struct file *file,
 710                          unsigned int cmd, void *arg)
 711 {
 712         struct video_device *dev = video_devdata(file);
 713         struct qcam_device *qcam=(struct qcam_device *)dev;
 714
 715         switch(cmd)
 716         {
 717                 case VIDIOCGCAP:
 718                 {
 719                         struct video_capability *b = arg;
 720                         strcpy(b->name, "Quickcam");
 721                         b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES|VID_TYPE_MONOCHROME;
 722                         b->channels = 1;
 723                         b->audios = 0;
 724                         b->maxwidth = 320;
 725                         b->maxheight = 240;
 726                         b->minwidth = 80;
 727                         b->minheight = 60;
 728                         return 0;
 729                 }
 730                 case VIDIOCGCHAN:
 731                 {
 732                         struct video_channel *v = arg;
 733                         if(v->channel!=0)
 734                                 return -EINVAL;
 735                         v->flags=0;
 736                         v->tuners=0;
 737                         /* Good question.. its composite or SVHS so.. */
 738                         v->type = VIDEO_TYPE_CAMERA;
 739                         strcpy(v->name, "Camera");
 740                         return 0;
 741                 }
 742                 case VIDIOCSCHAN:
 743                 {
 744                         struct video_channel *v = arg;
 745                         if(v->channel!=0)
 746                                 return -EINVAL;
 747                         return 0;
 748                 }
 749                 case VIDIOCGTUNER:
 750                 {
 751                         struct video_tuner *v = arg;
 752                         if(v->tuner)
 753                                 return -EINVAL;
 754                         strcpy(v->name, "Format");
 755                         v->rangelow=0;
 756                         v->rangehigh=0;
 757                         v->flags= 0;
 758                         v->mode = VIDEO_MODE_AUTO;
 759                         return 0;
 760                 }
 761                 case VIDIOCSTUNER:
 762                 {
 763                         struct video_tuner *v = arg;
 764                         if(v->tuner)
 765                                 return -EINVAL;
 766                         if(v->mode!=VIDEO_MODE_AUTO)
 767                                 return -EINVAL;
 768                         return 0;
 769                 }
 770                 case VIDIOCGPICT:
 771                 {
 772                         struct video_picture *p = arg;
 773                         p->colour=0x8000;
 774                         p->hue=0x8000;
 775                         p->brightness=qcam->brightness<<8;
 776                         p->contrast=qcam->contrast<<8;
 777                         p->whiteness=qcam->whitebal<<8;
 778                         p->depth=qcam->bpp;
 779                         p->palette=VIDEO_PALETTE_GREY;
 780                         return 0;
 781                 }
 782                 case VIDIOCSPICT:
 783                 {
 784                         struct video_picture *p = arg;
 785                         if(p->palette!=VIDEO_PALETTE_GREY)
 786                                 return -EINVAL;
 787                         if(p->depth!=4 && p->depth!=6)
 788                                 return -EINVAL;
 789
 790                         /*
 791                          *      Now load the camera.
 792                          */
 793
 794                         qcam->brightness = p->brightness>>8;
 795                         qcam->contrast = p->contrast>>8;
 796                         qcam->whitebal = p->whiteness>>8;
 797                         qcam->bpp = p->depth;
 798
 799                         mutex_lock(&qcam->lock);
 800                         qc_setscanmode(qcam);
 801                         mutex_unlock(&qcam->lock);
 802                         qcam->status |= QC_PARAM_CHANGE;
 803
 804                         return 0;
 805                 }
 806                 case VIDIOCSWIN:
 807                 {
 808                         struct video_window *vw = arg;
 809                         if(vw->flags)
 810                                 return -EINVAL;
 811                         if(vw->clipcount)
 812                                 return -EINVAL;
 813                         if(vw->height<60||vw->height>240)
 814                                 return -EINVAL;
 815                         if(vw->width<80||vw->width>320)
 816                                 return -EINVAL;
 817
 818                         qcam->width = 320;
 819                         qcam->height = 240;
 820                         qcam->transfer_scale = 4;
 821
 822                         if(vw->width>=160 && vw->height>=120)
 823                         {
 824                                 qcam->transfer_scale = 2;
 825                         }
 826                         if(vw->width>=320 && vw->height>=240)
 827                         {
 828                                 qcam->width = 320;
 829                                 qcam->height = 240;
 830                                 qcam->transfer_scale = 1;
 831                         }
 832                         mutex_lock(&qcam->lock);
 833                         qc_setscanmode(qcam);
 834                         mutex_unlock(&qcam->lock);
 835
 836                         /* We must update the camera before we grab. We could
 837                            just have changed the grab size */
 838                         qcam->status |= QC_PARAM_CHANGE;
 839
 840                         /* Ok we figured out what to use from our wide choice */
 841                         return 0;
 842                 }
 843                 case VIDIOCGWIN:
 844                 {
 845                         struct video_window *vw = arg;
 846                         memset(vw, 0, sizeof(*vw));
 847                         vw->width=qcam->width/qcam->transfer_scale;
 848                         vw->height=qcam->height/qcam->transfer_scale;
 849                         return 0;
 850                 }
 851                 case VIDIOCKEY:
 852                         return 0;
 853                 case VIDIOCCAPTURE:
 854                 case VIDIOCGFBUF:
 855                 case VIDIOCSFBUF:
 856                 case VIDIOCGFREQ:
 857                 case VIDIOCSFREQ:
 858                 case VIDIOCGAUDIO:
 859                 case VIDIOCSAUDIO:
 860                         return -EINVAL;
 861                 default:
 862                         return -ENOIOCTLCMD;
 863         }
 864         return 0;
 865 }
 866
 867 static int qcam_ioctl(struct inode *inode, struct file *file,
 868                      unsigned int cmd, unsigned long arg)
 869 {
 870         return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
 871 }
 872
 873 static ssize_t qcam_read(struct file *file, char __user *buf,
 874                          size_t count, loff_t *ppos)
 875 {
 876         struct video_device *v = video_devdata(file);
 877         struct qcam_device *qcam=(struct qcam_device *)v;
 878         int len;
 879         parport_claim_or_block(qcam->pdev);
 880
 881         mutex_lock(&qcam->lock);
 882
 883         qc_reset(qcam);
 884
 885         /* Update the camera parameters if we need to */
 886         if (qcam->status & QC_PARAM_CHANGE)
 887                 qc_set(qcam);
 888
 889         len=qc_capture(qcam, buf,count);
 890
 891         mutex_unlock(&qcam->lock);
 892
 893         parport_release(qcam->pdev);
 894         return len;
 895 }
 896
 897 static int qcam_exclusive_open(struct inode *inode, struct file *file)
 898 {
 899         struct video_device *dev = video_devdata(file);
 900         struct qcam_device *qcam = (struct qcam_device *)dev;
 901
 902         return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
 903 }
 904
 905 static int qcam_exclusive_release(struct inode *inode, struct file *file)
 906 {
 907         struct video_device *dev = video_devdata(file);
 908         struct qcam_device *qcam = (struct qcam_device *)dev;
 909
 910         clear_bit(0, &qcam->in_use);
 911         return 0;
 912 }
 913
 914 static const struct file_operations qcam_fops = {
 915         .owner          = THIS_MODULE,
 916         .open           = qcam_exclusive_open,
 917         .release        = qcam_exclusive_release,
 918         .ioctl          = qcam_ioctl,
 919 #ifdef CONFIG_COMPAT
 920         .compat_ioctl   = v4l_compat_ioctl32,
 921 #endif
 922         .read           = qcam_read,
 923         .llseek         = no_llseek,
 924 };
 925 static struct video_device qcam_template=
 926 {
 927         .name           = "Connectix Quickcam",
 928         .fops           = &qcam_fops,
 929         .release        = video_device_release_empty,
 930 };
 931
 932 #define MAX_CAMS 4
 933 static struct qcam_device *qcams[MAX_CAMS];
 934 static unsigned int num_cams;
 935
 936 static int init_bwqcam(struct parport *port)
 937 {
 938         struct qcam_device *qcam;
 939
 940         if (num_cams == MAX_CAMS)
 941         {
 942                 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
 943                 return -ENOSPC;
 944         }
 945
 946         qcam=qcam_init(port);
 947         if(qcam==NULL)
 948                 return -ENODEV;
 949
 950         parport_claim_or_block(qcam->pdev);
 951
 952         qc_reset(qcam);
 953
 954         if(qc_detect(qcam)==0)
 955         {
 956                 parport_release(qcam->pdev);
 957                 parport_unregister_device(qcam->pdev);
 958                 kfree(qcam);
 959                 return -ENODEV;
 960         }
 961         qc_calibrate(qcam);
 962
 963         parport_release(qcam->pdev);
 964
 965         printk(KERN_INFO "Connectix Quickcam on %s\n", qcam->pport->name);
 966
 967         if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
 968                 parport_unregister_device(qcam->pdev);
 969                 kfree(qcam);
 970                 return -ENODEV;
 971         }
 972
 973         qcams[num_cams++] = qcam;
 974
 975         return 0;
 976 }
 977
 978 static void close_bwqcam(struct qcam_device *qcam)
 979 {
 980         video_unregister_device(&qcam->vdev);
 981         parport_unregister_device(qcam->pdev);
 982         kfree(qcam);
 983 }
 984
 985 /* The parport parameter controls which parports will be scanned.
 986  * Scanning all parports causes some printers to print a garbage page.
 987  *       -- March 14, 1999  Billy Donahue <billy@escape.com> */
 988 #ifdef MODULE
 989 static char *parport[MAX_CAMS] = { NULL, };
 990 module_param_array(parport, charp, NULL, 0);
 991 #endif
 992
 993 static int accept_bwqcam(struct parport *port)
 994 {
 995 #ifdef MODULE
 996         int n;
 997
 998         if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
 999                 /* user gave parport parameters */
1000                 for(n=0; parport[n] && n<MAX_CAMS; n++){
1001                         char *ep;
1002                         unsigned long r;
1003                         r = simple_strtoul(parport[n], &ep, 0);
1004                         if (ep == parport[n]) {
1005                                 printk(KERN_ERR
1006                                         "bw-qcam: bad port specifier \"%s\"\n",
1007                                         parport[n]);
1008                                 continue;
1009                         }
1010                         if (r == port->number)
1011                                 return 1;
1012                 }
1013                 return 0;
1014         }
1015 #endif
1016         return 1;
1017 }
1018
1019 static void bwqcam_attach(struct parport *port)
1020 {
1021         if (accept_bwqcam(port))
1022                 init_bwqcam(port);
1023 }
1024
1025 static void bwqcam_detach(struct parport *port)
1026 {
1027         int i;
1028         for (i = 0; i < num_cams; i++) {
1029                 struct qcam_device *qcam = qcams[i];
1030                 if (qcam && qcam->pdev->port == port) {
1031                         qcams[i] = NULL;
1032                         close_bwqcam(qcam);
1033                 }
1034         }
1035 }
1036
1037 static struct parport_driver bwqcam_driver = {
1038         .name   = "bw-qcam",
1039         .attach = bwqcam_attach,
1040         .detach = bwqcam_detach,
1041 };
1042
1043 static void __exit exit_bw_qcams(void)
1044 {
1045         parport_unregister_driver(&bwqcam_driver);
1046 }
1047
1048 static int __init init_bw_qcams(void)
1049 {
1050 #ifdef MODULE
1051         /* Do some sanity checks on the module parameters. */
1052         if (maxpoll > 5000) {
1053                 printk("Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1054                 maxpoll = 5000;
1055         }
1056
1057         if (yieldlines < 1) {
1058                 printk("Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1059                 yieldlines = 1;
1060         }
1061 #endif
1062         return parport_register_driver(&bwqcam_driver);
1063 }
1064
1065 module_init(init_bw_qcams);
1066 module_exit(exit_bw_qcams);
1067
1068 MODULE_LICENSE("GPL");