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