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