drivers/media/video/bw-qcam.c

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