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