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