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