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