drivers/media/video/c-qcam.c

   1 /*
   2  *      Video4Linux Colour QuickCam driver
   3  *      Copyright 1997-2000 Philip Blundell <philb@gnu.org>
   4  *
   5  *    Module parameters:
   6  *
   7  *      parport=auto      -- probe all parports (default)
   8  *      parport=0         -- parport0 becomes qcam1
   9  *      parport=2,0,1     -- parports 2,0,1 are tried in that order
  10  *
  11  *      probe=0           -- do no probing, assume camera is present
  12  *      probe=1           -- use IEEE-1284 autoprobe data only (default)
  13  *      probe=2           -- probe aggressively for cameras
  14  *
  15  *      force_rgb=1       -- force data format to RGB (default is BGR)
  16  *
  17  * The parport parameter controls which parports will be scanned.
  18  * Scanning all parports causes some printers to print a garbage page.
  19  *       -- March 14, 1999  Billy Donahue <billy@escape.com>
  20  *
  21  * Fixed data format to BGR, added force_rgb parameter. Added missing
  22  * parport_unregister_driver() on module removal.
  23  *       -- May 28, 2000  Claudio Matsuoka <claudio@conectiva.com>
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/delay.h>
  28 #include <linux/errno.h>
  29 #include <linux/fs.h>
  30 #include <linux/init.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/mm.h>
  34 #include <linux/parport.h>
  35 #include <linux/sched.h>
  36 #include <linux/videodev.h>
  37 #include <media/v4l2-common.h>
  38 #include <media/v4l2-ioctl.h>
  39 #include <linux/mutex.h>
  40 #include <linux/jiffies.h>
  41
  42 #include <asm/uaccess.h>
  43
  44 struct qcam_device {
  45         struct video_device vdev;
  46         struct pardevice *pdev;
  47         struct parport *pport;
  48         int width, height;
  49         int ccd_width, ccd_height;
  50         int mode;
  51         int contrast, brightness, whitebal;
  52         int top, left;
  53         unsigned int bidirectional;
  54         unsigned long in_use;
  55         struct mutex lock;
  56 };
  57
  58 /* cameras maximum */
  59 #define MAX_CAMS 4
  60
  61 /* The three possible QuickCam modes */
  62 #define QC_MILLIONS     0x18
  63 #define QC_BILLIONS     0x10
  64 #define QC_THOUSANDS    0x08    /* with VIDEC compression (not supported) */
  65
  66 /* The three possible decimations */
  67 #define QC_DECIMATION_1         0
  68 #define QC_DECIMATION_2         2
  69 #define QC_DECIMATION_4         4
  70
  71 #define BANNER "Colour QuickCam for Video4Linux v0.05"
  72
  73 static int parport[MAX_CAMS] = { [1 ... MAX_CAMS-1] = -1 };
  74 static int probe = 2;
  75 static int force_rgb;
  76 static int video_nr = -1;
  77
  78 static inline void qcam_set_ack(struct qcam_device *qcam, unsigned int i)
  79 {
  80         /* note: the QC specs refer to the PCAck pin by voltage, not
  81            software level.  PC ports have builtin inverters. */
  82         parport_frob_control(qcam->pport, 8, i?8:0);
  83 }
  84
  85 static inline unsigned int qcam_ready1(struct qcam_device *qcam)
  86 {
  87         return (parport_read_status(qcam->pport) & 0x8)?1:0;
  88 }
  89
  90 static inline unsigned int qcam_ready2(struct qcam_device *qcam)
  91 {
  92         return (parport_read_data(qcam->pport) & 0x1)?1:0;
  93 }
  94
  95 static unsigned int qcam_await_ready1(struct qcam_device *qcam,
  96                                              int value)
  97 {
  98         unsigned long oldjiffies = jiffies;
  99         unsigned int i;
 100
 101         for (oldjiffies = jiffies;
 102              time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
 103                 if (qcam_ready1(qcam) == value)
 104                         return 0;
 105
 106         /* If the camera didn't respond within 1/25 second, poll slowly
 107            for a while. */
 108         for (i = 0; i < 50; i++)
 109         {
 110                 if (qcam_ready1(qcam) == value)
 111                         return 0;
 112                 msleep_interruptible(100);
 113         }
 114
 115         /* Probably somebody pulled the plug out.  Not much we can do. */
 116         printk(KERN_ERR "c-qcam: ready1 timeout (%d) %x %x\n", value,
 117                parport_read_status(qcam->pport),
 118                parport_read_control(qcam->pport));
 119         return 1;
 120 }
 121
 122 static unsigned int qcam_await_ready2(struct qcam_device *qcam, int value)
 123 {
 124         unsigned long oldjiffies = jiffies;
 125         unsigned int i;
 126
 127         for (oldjiffies = jiffies;
 128              time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
 129                 if (qcam_ready2(qcam) == value)
 130                         return 0;
 131
 132         /* If the camera didn't respond within 1/25 second, poll slowly
 133            for a while. */
 134         for (i = 0; i < 50; i++)
 135         {
 136                 if (qcam_ready2(qcam) == value)
 137                         return 0;
 138                 msleep_interruptible(100);
 139         }
 140
 141         /* Probably somebody pulled the plug out.  Not much we can do. */
 142         printk(KERN_ERR "c-qcam: ready2 timeout (%d) %x %x %x\n", value,
 143                parport_read_status(qcam->pport),
 144                parport_read_control(qcam->pport),
 145                parport_read_data(qcam->pport));
 146         return 1;
 147 }
 148
 149 static int qcam_read_data(struct qcam_device *qcam)
 150 {
 151         unsigned int idata;
 152         qcam_set_ack(qcam, 0);
 153         if (qcam_await_ready1(qcam, 1)) return -1;
 154         idata = parport_read_status(qcam->pport) & 0xf0;
 155         qcam_set_ack(qcam, 1);
 156         if (qcam_await_ready1(qcam, 0)) return -1;
 157         idata |= (parport_read_status(qcam->pport) >> 4);
 158         return idata;
 159 }
 160
 161 static int qcam_write_data(struct qcam_device *qcam, unsigned int data)
 162 {
 163         unsigned int idata;
 164         parport_write_data(qcam->pport, data);
 165         idata = qcam_read_data(qcam);
 166         if (data != idata)
 167         {
 168                 printk(KERN_WARNING "cqcam: sent %x but received %x\n", data,
 169                        idata);
 170                 return 1;
 171         }
 172         return 0;
 173 }
 174
 175 static inline int qcam_set(struct qcam_device *qcam, unsigned int cmd, unsigned int data)
 176 {
 177         if (qcam_write_data(qcam, cmd))
 178                 return -1;
 179         if (qcam_write_data(qcam, data))
 180                 return -1;
 181         return 0;
 182 }
 183
 184 static inline int qcam_get(struct qcam_device *qcam, unsigned int cmd)
 185 {
 186         if (qcam_write_data(qcam, cmd))
 187                 return -1;
 188         return qcam_read_data(qcam);
 189 }
 190
 191 static int qc_detect(struct qcam_device *qcam)
 192 {
 193         unsigned int stat, ostat, i, count = 0;
 194
 195         /* The probe routine below is not very reliable.  The IEEE-1284
 196            probe takes precedence. */
 197         /* XXX Currently parport provides no way to distinguish between
 198            "the IEEE probe was not done" and "the probe was done, but
 199            no device was found".  Fix this one day. */
 200         if (qcam->pport->probe_info[0].class == PARPORT_CLASS_MEDIA
 201             && qcam->pport->probe_info[0].model
 202             && !strcmp(qcam->pdev->port->probe_info[0].model,
 203                        "Color QuickCam 2.0")) {
 204                 printk(KERN_DEBUG "QuickCam: Found by IEEE1284 probe.\n");
 205                 return 1;
 206         }
 207
 208         if (probe < 2)
 209                 return 0;
 210
 211         parport_write_control(qcam->pport, 0xc);
 212
 213         /* look for a heartbeat */
 214         ostat = stat = parport_read_status(qcam->pport);
 215         for (i=0; i<250; i++)
 216         {
 217                 mdelay(1);
 218                 stat = parport_read_status(qcam->pport);
 219                 if (ostat != stat)
 220                 {
 221                         if (++count >= 3) return 1;
 222                         ostat = stat;
 223                 }
 224         }
 225
 226         /* Reset the camera and try again */
 227         parport_write_control(qcam->pport, 0xc);
 228         parport_write_control(qcam->pport, 0x8);
 229         mdelay(1);
 230         parport_write_control(qcam->pport, 0xc);
 231         mdelay(1);
 232         count = 0;
 233
 234         ostat = stat = parport_read_status(qcam->pport);
 235         for (i=0; i<250; i++)
 236         {
 237                 mdelay(1);
 238                 stat = parport_read_status(qcam->pport);
 239                 if (ostat != stat)
 240                 {
 241                         if (++count >= 3) return 1;
 242                         ostat = stat;
 243                 }
 244         }
 245
 246         /* no (or flatline) camera, give up */
 247         return 0;
 248 }
 249
 250 static void qc_reset(struct qcam_device *qcam)
 251 {
 252         parport_write_control(qcam->pport, 0xc);
 253         parport_write_control(qcam->pport, 0x8);
 254         mdelay(1);
 255         parport_write_control(qcam->pport, 0xc);
 256         mdelay(1);
 257 }
 258
 259 /* Reset the QuickCam and program for brightness, contrast,
 260  * white-balance, and resolution. */
 261
 262 static void qc_setup(struct qcam_device *q)
 263 {
 264         qc_reset(q);
 265
 266         /* Set the brightness.  */
 267         qcam_set(q, 11, q->brightness);
 268
 269         /* Set the height and width.  These refer to the actual
 270            CCD area *before* applying the selected decimation.  */
 271         qcam_set(q, 17, q->ccd_height);
 272         qcam_set(q, 19, q->ccd_width / 2);
 273
 274         /* Set top and left.  */
 275         qcam_set(q, 0xd, q->top);
 276         qcam_set(q, 0xf, q->left);
 277
 278         /* Set contrast and white balance.  */
 279         qcam_set(q, 0x19, q->contrast);
 280         qcam_set(q, 0x1f, q->whitebal);
 281
 282         /* Set the speed.  */
 283         qcam_set(q, 45, 2);
 284 }
 285
 286 /* Read some bytes from the camera and put them in the buffer.
 287    nbytes should be a multiple of 3, because bidirectional mode gives
 288    us three bytes at a time.  */
 289
 290 static unsigned int qcam_read_bytes(struct qcam_device *q, unsigned char *buf, unsigned int nbytes)
 291 {
 292         unsigned int bytes = 0;
 293
 294         qcam_set_ack(q, 0);
 295         if (q->bidirectional)
 296         {
 297                 /* It's a bidirectional port */
 298                 while (bytes < nbytes)
 299                 {
 300                         unsigned int lo1, hi1, lo2, hi2;
 301                         unsigned char r, g, b;
 302
 303                         if (qcam_await_ready2(q, 1)) return bytes;
 304                         lo1 = parport_read_data(q->pport) >> 1;
 305                         hi1 = ((parport_read_status(q->pport) >> 3) & 0x1f) ^ 0x10;
 306                         qcam_set_ack(q, 1);
 307                         if (qcam_await_ready2(q, 0)) return bytes;
 308                         lo2 = parport_read_data(q->pport) >> 1;
 309                         hi2 = ((parport_read_status(q->pport) >> 3) & 0x1f) ^ 0x10;
 310                         qcam_set_ack(q, 0);
 311                         r = (lo1 | ((hi1 & 1)<<7));
 312                         g = ((hi1 & 0x1e)<<3) | ((hi2 & 0x1e)>>1);
 313                         b = (lo2 | ((hi2 & 1)<<7));
 314                         if (force_rgb) {
 315                                 buf[bytes++] = r;
 316                                 buf[bytes++] = g;
 317                                 buf[bytes++] = b;
 318                         } else {
 319                                 buf[bytes++] = b;
 320                                 buf[bytes++] = g;
 321                                 buf[bytes++] = r;
 322                         }
 323                 }
 324         }
 325         else
 326         {
 327                 /* It's a unidirectional port */
 328                 int i = 0, n = bytes;
 329                 unsigned char rgb[3];
 330
 331                 while (bytes < nbytes)
 332                 {
 333                         unsigned int hi, lo;
 334
 335                         if (qcam_await_ready1(q, 1)) return bytes;
 336                         hi = (parport_read_status(q->pport) & 0xf0);
 337                         qcam_set_ack(q, 1);
 338                         if (qcam_await_ready1(q, 0)) return bytes;
 339                         lo = (parport_read_status(q->pport) & 0xf0);
 340                         qcam_set_ack(q, 0);
 341                         /* flip some bits */
 342                         rgb[(i = bytes++ % 3)] = (hi | (lo >> 4)) ^ 0x88;
 343                         if (i >= 2) {
 344 get_fragment:
 345                                 if (force_rgb) {
 346                                         buf[n++] = rgb[0];
 347                                         buf[n++] = rgb[1];
 348                                         buf[n++] = rgb[2];
 349                                 } else {
 350                                         buf[n++] = rgb[2];
 351                                         buf[n++] = rgb[1];
 352                                         buf[n++] = rgb[0];
 353                                 }
 354                         }
 355                 }
 356                 if (i) {
 357                         i = 0;
 358                         goto get_fragment;
 359                 }
 360         }
 361         return bytes;
 362 }
 363
 364 #define BUFSZ   150
 365
 366 static long qc_capture(struct qcam_device *q, char __user *buf, unsigned long len)
 367 {
 368         unsigned lines, pixelsperline, bitsperxfer;
 369         unsigned int is_bi_dir = q->bidirectional;
 370         size_t wantlen, outptr = 0;
 371         char tmpbuf[BUFSZ];
 372
 373         if (!access_ok(VERIFY_WRITE, buf, len))
 374                 return -EFAULT;
 375
 376         /* Wait for camera to become ready */
 377         for (;;)
 378         {
 379                 int i = qcam_get(q, 41);
 380                 if (i == -1) {
 381                         qc_setup(q);
 382                         return -EIO;
 383                 }
 384                 if ((i & 0x80) == 0)
 385                         break;
 386                 else
 387                         schedule();
 388         }
 389
 390         if (qcam_set(q, 7, (q->mode | (is_bi_dir?1:0)) + 1))
 391                 return -EIO;
 392
 393         lines = q->height;
 394         pixelsperline = q->width;
 395         bitsperxfer = (is_bi_dir) ? 24 : 8;
 396
 397         if (is_bi_dir)
 398         {
 399                 /* Turn the port around */
 400                 parport_data_reverse(q->pport);
 401                 mdelay(3);
 402                 qcam_set_ack(q, 0);
 403                 if (qcam_await_ready1(q, 1)) {
 404                         qc_setup(q);
 405                         return -EIO;
 406                 }
 407                 qcam_set_ack(q, 1);
 408                 if (qcam_await_ready1(q, 0)) {
 409                         qc_setup(q);
 410                         return -EIO;
 411                 }
 412         }
 413
 414         wantlen = lines * pixelsperline * 24 / 8;
 415
 416         while (wantlen)
 417         {
 418                 size_t t, s;
 419                 s = (wantlen > BUFSZ)?BUFSZ:wantlen;
 420                 t = qcam_read_bytes(q, tmpbuf, s);
 421                 if (outptr < len)
 422                 {
 423                         size_t sz = len - outptr;
 424                         if (sz > t) sz = t;
 425                         if (__copy_to_user(buf+outptr, tmpbuf, sz))
 426                                 break;
 427                         outptr += sz;
 428                 }
 429                 wantlen -= t;
 430                 if (t < s)
 431                         break;
 432                 cond_resched();
 433         }
 434
 435         len = outptr;
 436
 437         if (wantlen)
 438         {
 439                 printk("qcam: short read.\n");
 440                 if (is_bi_dir)
 441                         parport_data_forward(q->pport);
 442                 qc_setup(q);
 443                 return len;
 444         }
 445
 446         if (is_bi_dir)
 447         {
 448                 int l;
 449                 do {
 450                         l = qcam_read_bytes(q, tmpbuf, 3);
 451                         cond_resched();
 452                 } while (l && (tmpbuf[0] == 0x7e || tmpbuf[1] == 0x7e || tmpbuf[2] == 0x7e));
 453                 if (force_rgb) {
 454                         if (tmpbuf[0] != 0xe || tmpbuf[1] != 0x0 || tmpbuf[2] != 0xf)
 455                                 printk("qcam: bad EOF\n");
 456                 } else {
 457                         if (tmpbuf[0] != 0xf || tmpbuf[1] != 0x0 || tmpbuf[2] != 0xe)
 458                                 printk("qcam: bad EOF\n");
 459                 }
 460                 qcam_set_ack(q, 0);
 461                 if (qcam_await_ready1(q, 1))
 462                 {
 463                         printk("qcam: no ack after EOF\n");
 464                         parport_data_forward(q->pport);
 465                         qc_setup(q);
 466                         return len;
 467                 }
 468                 parport_data_forward(q->pport);
 469                 mdelay(3);
 470                 qcam_set_ack(q, 1);
 471                 if (qcam_await_ready1(q, 0))
 472                 {
 473                         printk("qcam: no ack to port turnaround\n");
 474                         qc_setup(q);
 475                         return len;
 476                 }
 477         }
 478         else
 479         {
 480                 int l;
 481                 do {
 482                         l = qcam_read_bytes(q, tmpbuf, 1);
 483                         cond_resched();
 484                 } while (l && tmpbuf[0] == 0x7e);
 485                 l = qcam_read_bytes(q, tmpbuf+1, 2);
 486                 if (force_rgb) {
 487                         if (tmpbuf[0] != 0xe || tmpbuf[1] != 0x0 || tmpbuf[2] != 0xf)
 488                                 printk("qcam: bad EOF\n");
 489                 } else {
 490                         if (tmpbuf[0] != 0xf || tmpbuf[1] != 0x0 || tmpbuf[2] != 0xe)
 491                                 printk("qcam: bad EOF\n");
 492                 }
 493         }
 494
 495         qcam_write_data(q, 0);
 496         return len;
 497 }
 498
 499 /*
 500  *      Video4linux interfacing
 501  */
 502
 503 static int qcam_do_ioctl(struct inode *inode, struct file *file,
 504                          unsigned int cmd, void *arg)
 505 {
 506         struct video_device *dev = video_devdata(file);
 507         struct qcam_device *qcam=(struct qcam_device *)dev;
 508
 509         switch(cmd)
 510         {
 511                 case VIDIOCGCAP:
 512                 {
 513                         struct video_capability *b = arg;
 514                         strcpy(b->name, "Quickcam");
 515                         b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES;
 516                         b->channels = 1;
 517                         b->audios = 0;
 518                         b->maxwidth = 320;
 519                         b->maxheight = 240;
 520                         b->minwidth = 80;
 521                         b->minheight = 60;
 522                         return 0;
 523                 }
 524                 case VIDIOCGCHAN:
 525                 {
 526                         struct video_channel *v = arg;
 527                         if(v->channel!=0)
 528                                 return -EINVAL;
 529                         v->flags=0;
 530                         v->tuners=0;
 531                         /* Good question.. its composite or SVHS so.. */
 532                         v->type = VIDEO_TYPE_CAMERA;
 533                         strcpy(v->name, "Camera");
 534                         return 0;
 535                 }
 536                 case VIDIOCSCHAN:
 537                 {
 538                         struct video_channel *v = arg;
 539                         if(v->channel!=0)
 540                                 return -EINVAL;
 541                         return 0;
 542                 }
 543                 case VIDIOCGTUNER:
 544                 {
 545                         struct video_tuner *v = arg;
 546                         if(v->tuner)
 547                                 return -EINVAL;
 548                         memset(v,0,sizeof(*v));
 549                         strcpy(v->name, "Format");
 550                         v->mode = VIDEO_MODE_AUTO;
 551                         return 0;
 552                 }
 553                 case VIDIOCSTUNER:
 554                 {
 555                         struct video_tuner *v = arg;
 556                         if(v->tuner)
 557                                 return -EINVAL;
 558                         if(v->mode!=VIDEO_MODE_AUTO)
 559                                 return -EINVAL;
 560                         return 0;
 561                 }
 562                 case VIDIOCGPICT:
 563                 {
 564                         struct video_picture *p = arg;
 565                         p->colour=0x8000;
 566                         p->hue=0x8000;
 567                         p->brightness=qcam->brightness<<8;
 568                         p->contrast=qcam->contrast<<8;
 569                         p->whiteness=qcam->whitebal<<8;
 570                         p->depth=24;
 571                         p->palette=VIDEO_PALETTE_RGB24;
 572                         return 0;
 573                 }
 574                 case VIDIOCSPICT:
 575                 {
 576                         struct video_picture *p = arg;
 577
 578                         /*
 579                          *      Sanity check args
 580                          */
 581                         if (p->depth != 24 || p->palette != VIDEO_PALETTE_RGB24)
 582                                 return -EINVAL;
 583
 584                         /*
 585                          *      Now load the camera.
 586                          */
 587                         qcam->brightness = p->brightness>>8;
 588                         qcam->contrast = p->contrast>>8;
 589                         qcam->whitebal = p->whiteness>>8;
 590
 591                         mutex_lock(&qcam->lock);
 592                         parport_claim_or_block(qcam->pdev);
 593                         qc_setup(qcam);
 594                         parport_release(qcam->pdev);
 595                         mutex_unlock(&qcam->lock);
 596                         return 0;
 597                 }
 598                 case VIDIOCSWIN:
 599                 {
 600                         struct video_window *vw = arg;
 601
 602                         if(vw->flags)
 603                                 return -EINVAL;
 604                         if(vw->clipcount)
 605                                 return -EINVAL;
 606                         if(vw->height<60||vw->height>240)
 607                                 return -EINVAL;
 608                         if(vw->width<80||vw->width>320)
 609                                 return -EINVAL;
 610
 611                         qcam->width = 80;
 612                         qcam->height = 60;
 613                         qcam->mode = QC_DECIMATION_4;
 614
 615                         if(vw->width>=160 && vw->height>=120)
 616                         {
 617                                 qcam->width = 160;
 618                                 qcam->height = 120;
 619                                 qcam->mode = QC_DECIMATION_2;
 620                         }
 621                         if(vw->width>=320 && vw->height>=240)
 622                         {
 623                                 qcam->width = 320;
 624                                 qcam->height = 240;
 625                                 qcam->mode = QC_DECIMATION_1;
 626                         }
 627                         qcam->mode |= QC_MILLIONS;
 628 #if 0
 629                         if(vw->width>=640 && vw->height>=480)
 630                         {
 631                                 qcam->width = 640;
 632                                 qcam->height = 480;
 633                                 qcam->mode = QC_BILLIONS | QC_DECIMATION_1;
 634                         }
 635 #endif
 636                         /* Ok we figured out what to use from our
 637                            wide choice */
 638                         mutex_lock(&qcam->lock);
 639                         parport_claim_or_block(qcam->pdev);
 640                         qc_setup(qcam);
 641                         parport_release(qcam->pdev);
 642                         mutex_unlock(&qcam->lock);
 643                         return 0;
 644                 }
 645                 case VIDIOCGWIN:
 646                 {
 647                         struct video_window *vw = arg;
 648                         memset(vw, 0, sizeof(*vw));
 649                         vw->width=qcam->width;
 650                         vw->height=qcam->height;
 651                         return 0;
 652                 }
 653                 case VIDIOCKEY:
 654                         return 0;
 655                 case VIDIOCCAPTURE:
 656                 case VIDIOCGFBUF:
 657                 case VIDIOCSFBUF:
 658                 case VIDIOCGFREQ:
 659                 case VIDIOCSFREQ:
 660                 case VIDIOCGAUDIO:
 661                 case VIDIOCSAUDIO:
 662                         return -EINVAL;
 663                 default:
 664                         return -ENOIOCTLCMD;
 665         }
 666         return 0;
 667 }
 668
 669 static int qcam_ioctl(struct inode *inode, struct file *file,
 670                      unsigned int cmd, unsigned long arg)
 671 {
 672         return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
 673 }
 674
 675 static ssize_t qcam_read(struct file *file, char __user *buf,
 676                          size_t count, loff_t *ppos)
 677 {
 678         struct video_device *v = video_devdata(file);
 679         struct qcam_device *qcam=(struct qcam_device *)v;
 680         int len;
 681
 682         mutex_lock(&qcam->lock);
 683         parport_claim_or_block(qcam->pdev);
 684         /* Probably should have a semaphore against multiple users */
 685         len = qc_capture(qcam, buf,count);
 686         parport_release(qcam->pdev);
 687         mutex_unlock(&qcam->lock);
 688         return len;
 689 }
 690
 691 static int qcam_exclusive_open(struct inode *inode, struct file *file)
 692 {
 693         struct video_device *dev = video_devdata(file);
 694         struct qcam_device *qcam = (struct qcam_device *)dev;
 695
 696         return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
 697 }
 698
 699 static int qcam_exclusive_release(struct inode *inode, struct file *file)
 700 {
 701         struct video_device *dev = video_devdata(file);
 702         struct qcam_device *qcam = (struct qcam_device *)dev;
 703
 704         clear_bit(0, &qcam->in_use);
 705         return 0;
 706 }
 707
 708 /* video device template */
 709 static const struct file_operations qcam_fops = {
 710         .owner          = THIS_MODULE,
 711         .open           = qcam_exclusive_open,
 712         .release        = qcam_exclusive_release,
 713         .ioctl          = qcam_ioctl,
 714 #ifdef CONFIG_COMPAT
 715         .compat_ioctl   = v4l_compat_ioctl32,
 716 #endif
 717         .read           = qcam_read,
 718         .llseek         = no_llseek,
 719 };
 720
 721 static struct video_device qcam_template=
 722 {
 723         .name           = "Colour QuickCam",
 724         .fops           = &qcam_fops,
 725         .release        = video_device_release_empty,
 726 };
 727
 728 /* Initialize the QuickCam driver control structure. */
 729
 730 static struct qcam_device *qcam_init(struct parport *port)
 731 {
 732         struct qcam_device *q;
 733
 734         q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
 735         if(q==NULL)
 736                 return NULL;
 737
 738         q->pport = port;
 739         q->pdev = parport_register_device(port, "c-qcam", NULL, NULL,
 740                                           NULL, 0, NULL);
 741
 742         q->bidirectional = (q->pport->modes & PARPORT_MODE_TRISTATE)?1:0;
 743
 744         if (q->pdev == NULL)
 745         {
 746                 printk(KERN_ERR "c-qcam: couldn't register for %s.\n",
 747                        port->name);
 748                 kfree(q);
 749                 return NULL;
 750         }
 751
 752         memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
 753
 754         mutex_init(&q->lock);
 755         q->width = q->ccd_width = 320;
 756         q->height = q->ccd_height = 240;
 757         q->mode = QC_MILLIONS | QC_DECIMATION_1;
 758         q->contrast = 192;
 759         q->brightness = 240;
 760         q->whitebal = 128;
 761         q->top = 1;
 762         q->left = 14;
 763         return q;
 764 }
 765
 766 static struct qcam_device *qcams[MAX_CAMS];
 767 static unsigned int num_cams;
 768
 769 static int init_cqcam(struct parport *port)
 770 {
 771         struct qcam_device *qcam;
 772
 773         if (parport[0] != -1)
 774         {
 775                 /* The user gave specific instructions */
 776                 int i, found = 0;
 777                 for (i = 0; i < MAX_CAMS && parport[i] != -1; i++)
 778                 {
 779                         if (parport[0] == port->number)
 780                                 found = 1;
 781                 }
 782                 if (!found)
 783                         return -ENODEV;
 784         }
 785
 786         if (num_cams == MAX_CAMS)
 787                 return -ENOSPC;
 788
 789         qcam = qcam_init(port);
 790         if (qcam==NULL)
 791                 return -ENODEV;
 792
 793         parport_claim_or_block(qcam->pdev);
 794
 795         qc_reset(qcam);
 796
 797         if (probe && qc_detect(qcam)==0)
 798         {
 799                 parport_release(qcam->pdev);
 800                 parport_unregister_device(qcam->pdev);
 801                 kfree(qcam);
 802                 return -ENODEV;
 803         }
 804
 805         qc_setup(qcam);
 806
 807         parport_release(qcam->pdev);
 808
 809         if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
 810                 printk(KERN_ERR "Unable to register Colour QuickCam on %s\n",
 811                        qcam->pport->name);
 812                 parport_unregister_device(qcam->pdev);
 813                 kfree(qcam);
 814                 return -ENODEV;
 815         }
 816
 817         printk(KERN_INFO "video%d: Colour QuickCam found on %s\n",
 818                qcam->vdev.minor, qcam->pport->name);
 819
 820         qcams[num_cams++] = qcam;
 821
 822         return 0;
 823 }
 824
 825 static void close_cqcam(struct qcam_device *qcam)
 826 {
 827         video_unregister_device(&qcam->vdev);
 828         parport_unregister_device(qcam->pdev);
 829         kfree(qcam);
 830 }
 831
 832 static void cq_attach(struct parport *port)
 833 {
 834         init_cqcam(port);
 835 }
 836
 837 static void cq_detach(struct parport *port)
 838 {
 839         /* Write this some day. */
 840 }
 841
 842 static struct parport_driver cqcam_driver = {
 843         .name = "cqcam",
 844         .attach = cq_attach,
 845         .detach = cq_detach,
 846 };
 847
 848 static int __init cqcam_init (void)
 849 {
 850         printk(BANNER "\n");
 851
 852         return parport_register_driver(&cqcam_driver);
 853 }
 854
 855 static void __exit cqcam_cleanup (void)
 856 {
 857         unsigned int i;
 858
 859         for (i = 0; i < num_cams; i++)
 860                 close_cqcam(qcams[i]);
 861
 862         parport_unregister_driver(&cqcam_driver);
 863 }
 864
 865 MODULE_AUTHOR("Philip Blundell <philb@gnu.org>");
 866 MODULE_DESCRIPTION(BANNER);
 867 MODULE_LICENSE("GPL");
 868
 869 /* FIXME: parport=auto would never have worked, surely? --RR */
 870 MODULE_PARM_DESC(parport ,"parport=<auto|n[,n]...> for port detection method\n\
 871 probe=<0|1|2> for camera detection method\n\
 872 force_rgb=<0|1> for RGB data format (default BGR)");
 873 module_param_array(parport, int, NULL, 0);
 874 module_param(probe, int, 0);
 875 module_param(force_rgb, bool, 0);
 876 module_param(video_nr, int, 0);
 877
 878 module_init(cqcam_init);
 879 module_exit(cqcam_cleanup);