drivers/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         pix->priv = 0;
 763         return 0;
 764 }
 765
 766 static int qcam_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 767 {
 768         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 769
 770         if (pix->height <= 60 || pix->width <= 80) {
 771                 pix->height = 60;
 772                 pix->width = 80;
 773         } else if (pix->height <= 120 || pix->width <= 160) {
 774                 pix->height = 120;
 775                 pix->width = 160;
 776         } else {
 777                 pix->height = 240;
 778                 pix->width = 320;
 779         }
 780         if (pix->pixelformat != V4L2_PIX_FMT_Y4 &&
 781             pix->pixelformat != V4L2_PIX_FMT_Y6)
 782                 pix->pixelformat = V4L2_PIX_FMT_Y4;
 783         pix->field = V4L2_FIELD_NONE;
 784         pix->bytesperline = pix->width;
 785         pix->sizeimage = pix->width * pix->height;
 786         /* Just a guess */
 787         pix->colorspace = V4L2_COLORSPACE_SRGB;
 788         pix->priv = 0;
 789         return 0;
 790 }
 791
 792 static int qcam_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
 793 {
 794         struct qcam *qcam = video_drvdata(file);
 795         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 796         int ret = qcam_try_fmt_vid_cap(file, fh, fmt);
 797
 798         if (ret)
 799                 return ret;
 800         if (vb2_is_busy(&qcam->vb_vidq))
 801                 return -EBUSY;
 802         qcam->width = 320;
 803         qcam->height = 240;
 804         if (pix->height == 60)
 805                 qcam->transfer_scale = 4;
 806         else if (pix->height == 120)
 807                 qcam->transfer_scale = 2;
 808         else
 809                 qcam->transfer_scale = 1;
 810         if (pix->pixelformat == V4L2_PIX_FMT_Y6)
 811                 qcam->bpp = 6;
 812         else
 813                 qcam->bpp = 4;
 814
 815         qc_setscanmode(qcam);
 816         /* We must update the camera before we grab. We could
 817            just have changed the grab size */
 818         qcam->status |= QC_PARAM_CHANGE;
 819         return 0;
 820 }
 821
 822 static int qcam_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
 823 {
 824         static struct v4l2_fmtdesc formats[] = {
 825                 { 0, 0, 0,
 826                   "4-Bit Monochrome", V4L2_PIX_FMT_Y4,
 827                   { 0, 0, 0, 0 }
 828                 },
 829                 { 1, 0, 0,
 830                   "6-Bit Monochrome", V4L2_PIX_FMT_Y6,
 831                   { 0, 0, 0, 0 }
 832                 },
 833         };
 834         enum v4l2_buf_type type = fmt->type;
 835
 836         if (fmt->index > 1)
 837                 return -EINVAL;
 838
 839         *fmt = formats[fmt->index];
 840         fmt->type = type;
 841         return 0;
 842 }
 843
 844 static int qcam_enum_framesizes(struct file *file, void *fh,
 845                                          struct v4l2_frmsizeenum *fsize)
 846 {
 847         static const struct v4l2_frmsize_discrete sizes[] = {
 848                 {  80,  60 },
 849                 { 160, 120 },
 850                 { 320, 240 },
 851         };
 852
 853         if (fsize->index > 2)
 854                 return -EINVAL;
 855         if (fsize->pixel_format != V4L2_PIX_FMT_Y4 &&
 856             fsize->pixel_format != V4L2_PIX_FMT_Y6)
 857                 return -EINVAL;
 858         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 859         fsize->discrete = sizes[fsize->index];
 860         return 0;
 861 }
 862
 863 static int qcam_s_ctrl(struct v4l2_ctrl *ctrl)
 864 {
 865         struct qcam *qcam =
 866                 container_of(ctrl->handler, struct qcam, hdl);
 867         int ret = 0;
 868
 869         switch (ctrl->id) {
 870         case V4L2_CID_BRIGHTNESS:
 871                 qcam->brightness = ctrl->val;
 872                 break;
 873         case V4L2_CID_CONTRAST:
 874                 qcam->contrast = ctrl->val;
 875                 break;
 876         case V4L2_CID_GAMMA:
 877                 qcam->whitebal = ctrl->val;
 878                 break;
 879         default:
 880                 ret = -EINVAL;
 881                 break;
 882         }
 883         if (ret == 0)
 884                 qcam->status |= QC_PARAM_CHANGE;
 885         return ret;
 886 }
 887
 888 static const struct v4l2_file_operations qcam_fops = {
 889         .owner          = THIS_MODULE,
 890         .open           = v4l2_fh_open,
 891         .release        = vb2_fop_release,
 892         .poll           = vb2_fop_poll,
 893         .unlocked_ioctl = video_ioctl2,
 894         .read           = vb2_fop_read,
 895         .mmap           = vb2_fop_mmap,
 896 };
 897
 898 static const struct v4l2_ioctl_ops qcam_ioctl_ops = {
 899         .vidioc_querycap                    = qcam_querycap,
 900         .vidioc_g_input                     = qcam_g_input,
 901         .vidioc_s_input                     = qcam_s_input,
 902         .vidioc_enum_input                  = qcam_enum_input,
 903         .vidioc_enum_fmt_vid_cap            = qcam_enum_fmt_vid_cap,
 904         .vidioc_enum_framesizes             = qcam_enum_framesizes,
 905         .vidioc_g_fmt_vid_cap               = qcam_g_fmt_vid_cap,
 906         .vidioc_s_fmt_vid_cap               = qcam_s_fmt_vid_cap,
 907         .vidioc_try_fmt_vid_cap             = qcam_try_fmt_vid_cap,
 908         .vidioc_reqbufs                     = vb2_ioctl_reqbufs,
 909         .vidioc_create_bufs                 = vb2_ioctl_create_bufs,
 910         .vidioc_prepare_buf                 = vb2_ioctl_prepare_buf,
 911         .vidioc_querybuf                    = vb2_ioctl_querybuf,
 912         .vidioc_qbuf                        = vb2_ioctl_qbuf,
 913         .vidioc_dqbuf                       = vb2_ioctl_dqbuf,
 914         .vidioc_streamon                    = vb2_ioctl_streamon,
 915         .vidioc_streamoff                   = vb2_ioctl_streamoff,
 916         .vidioc_log_status                  = v4l2_ctrl_log_status,
 917         .vidioc_subscribe_event             = v4l2_ctrl_subscribe_event,
 918         .vidioc_unsubscribe_event           = v4l2_event_unsubscribe,
 919 };
 920
 921 static const struct v4l2_ctrl_ops qcam_ctrl_ops = {
 922         .s_ctrl = qcam_s_ctrl,
 923 };
 924
 925 /* Initialize the QuickCam driver control structure.  This is where
 926  * defaults are set for people who don't have a config file.*/
 927
 928 static struct qcam *qcam_init(struct parport *port)
 929 {
 930         struct qcam *qcam;
 931         struct v4l2_device *v4l2_dev;
 932         struct vb2_queue *q;
 933         int err;
 934
 935         qcam = kzalloc(sizeof(struct qcam), GFP_KERNEL);
 936         if (qcam == NULL)
 937                 return NULL;
 938
 939         v4l2_dev = &qcam->v4l2_dev;
 940         snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "bw-qcam%d", num_cams);
 941
 942         if (v4l2_device_register(port->dev, v4l2_dev) < 0) {
 943                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
 944                 kfree(qcam);
 945                 return NULL;
 946         }
 947
 948         v4l2_ctrl_handler_init(&qcam->hdl, 3);
 949         v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
 950                           V4L2_CID_BRIGHTNESS, 0, 255, 1, 180);
 951         v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
 952                           V4L2_CID_CONTRAST, 0, 255, 1, 192);
 953         v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
 954                           V4L2_CID_GAMMA, 0, 255, 1, 105);
 955         if (qcam->hdl.error) {
 956                 v4l2_err(v4l2_dev, "couldn't register controls\n");
 957                 goto exit;
 958         }
 959
 960         mutex_init(&qcam->lock);
 961         mutex_init(&qcam->queue_lock);
 962
 963         /* initialize queue */
 964         q = &qcam->vb_vidq;
 965         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 966         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
 967         q->drv_priv = qcam;
 968         q->ops = &qcam_video_qops;
 969         q->mem_ops = &vb2_vmalloc_memops;
 970         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
 971         err = vb2_queue_init(q);
 972         if (err < 0) {
 973                 v4l2_err(v4l2_dev, "couldn't init vb2_queue for %s.\n", port->name);
 974                 goto exit;
 975         }
 976         qcam->vdev.queue = q;
 977         qcam->vdev.queue->lock = &qcam->queue_lock;
 978
 979         qcam->pport = port;
 980         qcam->pdev = parport_register_device(port, v4l2_dev->name, NULL, NULL,
 981                         NULL, 0, NULL);
 982         if (qcam->pdev == NULL) {
 983                 v4l2_err(v4l2_dev, "couldn't register for %s.\n", port->name);
 984                 goto exit;
 985         }
 986
 987         strlcpy(qcam->vdev.name, "Connectix QuickCam", sizeof(qcam->vdev.name));
 988         qcam->vdev.v4l2_dev = v4l2_dev;
 989         qcam->vdev.ctrl_handler = &qcam->hdl;
 990         qcam->vdev.fops = &qcam_fops;
 991         qcam->vdev.lock = &qcam->lock;
 992         qcam->vdev.ioctl_ops = &qcam_ioctl_ops;
 993         set_bit(V4L2_FL_USE_FH_PRIO, &qcam->vdev.flags);
 994         qcam->vdev.release = video_device_release_empty;
 995         video_set_drvdata(&qcam->vdev, qcam);
 996
 997         qcam->port_mode = (QC_ANY | QC_NOTSET);
 998         qcam->width = 320;
 999         qcam->height = 240;
1000         qcam->bpp = 4;
1001         qcam->transfer_scale = 2;
1002         qcam->contrast = 192;
1003         qcam->brightness = 180;
1004         qcam->whitebal = 105;
1005         qcam->top = 1;
1006         qcam->left = 14;
1007         qcam->mode = -1;
1008         qcam->status = QC_PARAM_CHANGE;
1009         return qcam;
1010
1011 exit:
1012         v4l2_ctrl_handler_free(&qcam->hdl);
1013         kfree(qcam);
1014         return NULL;
1015 }
1016
1017 static int qc_calibrate(struct qcam *q)
1018 {
1019         /*
1020          *      Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
1021          *      The white balance is an individual value for each
1022          *      quickcam.
1023          */
1024
1025         int value;
1026         int count = 0;
1027
1028         qc_command(q, 27);      /* AutoAdjustOffset */
1029         qc_command(q, 0);       /* Dummy Parameter, ignored by the camera */
1030
1031         /* GetOffset (33) will read 255 until autocalibration */
1032         /* is finished. After that, a value of 1-254 will be */
1033         /* returned. */
1034
1035         do {
1036                 qc_command(q, 33);
1037                 value = qc_readparam(q);
1038                 mdelay(1);
1039                 schedule();
1040                 count++;
1041         } while (value == 0xff && count < 2048);
1042
1043         q->whitebal = value;
1044         return value;
1045 }
1046
1047 static int init_bwqcam(struct parport *port)
1048 {
1049         struct qcam *qcam;
1050
1051         if (num_cams == MAX_CAMS) {
1052                 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
1053                 return -ENOSPC;
1054         }
1055
1056         qcam = qcam_init(port);
1057         if (qcam == NULL)
1058                 return -ENODEV;
1059
1060         parport_claim_or_block(qcam->pdev);
1061
1062         qc_reset(qcam);
1063
1064         if (qc_detect(qcam) == 0) {
1065                 parport_release(qcam->pdev);
1066                 parport_unregister_device(qcam->pdev);
1067                 kfree(qcam);
1068                 return -ENODEV;
1069         }
1070         qc_calibrate(qcam);
1071         v4l2_ctrl_handler_setup(&qcam->hdl);
1072
1073         parport_release(qcam->pdev);
1074
1075         v4l2_info(&qcam->v4l2_dev, "Connectix Quickcam on %s\n", qcam->pport->name);
1076
1077         if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1078                 parport_unregister_device(qcam->pdev);
1079                 kfree(qcam);
1080                 return -ENODEV;
1081         }
1082
1083         qcams[num_cams++] = qcam;
1084
1085         return 0;
1086 }
1087
1088 static void close_bwqcam(struct qcam *qcam)
1089 {
1090         video_unregister_device(&qcam->vdev);
1091         v4l2_ctrl_handler_free(&qcam->hdl);
1092         parport_unregister_device(qcam->pdev);
1093         kfree(qcam);
1094 }
1095
1096 /* The parport parameter controls which parports will be scanned.
1097  * Scanning all parports causes some printers to print a garbage page.
1098  *       -- March 14, 1999  Billy Donahue <billy@escape.com> */
1099 #ifdef MODULE
1100 static char *parport[MAX_CAMS] = { NULL, };
1101 module_param_array(parport, charp, NULL, 0);
1102 #endif
1103
1104 static int accept_bwqcam(struct parport *port)
1105 {
1106 #ifdef MODULE
1107         int n;
1108
1109         if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
1110                 /* user gave parport parameters */
1111                 for (n = 0; n < MAX_CAMS && parport[n]; n++) {
1112                         char *ep;
1113                         unsigned long r;
1114                         r = simple_strtoul(parport[n], &ep, 0);
1115                         if (ep == parport[n]) {
1116                                 printk(KERN_ERR
1117                                         "bw-qcam: bad port specifier \"%s\"\n",
1118                                         parport[n]);
1119                                 continue;
1120                         }
1121                         if (r == port->number)
1122                                 return 1;
1123                 }
1124                 return 0;
1125         }
1126 #endif
1127         return 1;
1128 }
1129
1130 static void bwqcam_attach(struct parport *port)
1131 {
1132         if (accept_bwqcam(port))
1133                 init_bwqcam(port);
1134 }
1135
1136 static void bwqcam_detach(struct parport *port)
1137 {
1138         int i;
1139         for (i = 0; i < num_cams; i++) {
1140                 struct qcam *qcam = qcams[i];
1141                 if (qcam && qcam->pdev->port == port) {
1142                         qcams[i] = NULL;
1143                         close_bwqcam(qcam);
1144                 }
1145         }
1146 }
1147
1148 static struct parport_driver bwqcam_driver = {
1149         .name   = "bw-qcam",
1150         .attach = bwqcam_attach,
1151         .detach = bwqcam_detach,
1152 };
1153
1154 static void __exit exit_bw_qcams(void)
1155 {
1156         parport_unregister_driver(&bwqcam_driver);
1157 }
1158
1159 static int __init init_bw_qcams(void)
1160 {
1161 #ifdef MODULE
1162         /* Do some sanity checks on the module parameters. */
1163         if (maxpoll > 5000) {
1164                 printk(KERN_INFO "Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1165                 maxpoll = 5000;
1166         }
1167
1168         if (yieldlines < 1) {
1169                 printk(KERN_INFO "Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1170                 yieldlines = 1;
1171         }
1172 #endif
1173         return parport_register_driver(&bwqcam_driver);
1174 }
1175
1176 module_init(init_bw_qcams);
1177 module_exit(exit_bw_qcams);
1178
1179 MODULE_LICENSE("GPL");
1180 MODULE_VERSION("0.0.3");