V4L/DVB (6715): ivtv: Remove unnecessary register update
[linux-2.6/verdex.git] / drivers / media / video / bw-qcam.c
blob58423525591fbce1f1e3f876713b8e47f3bced79
1 /*
2 * QuickCam Driver For Video4Linux.
4 * Video4Linux conversion work by Alan Cox.
5 * Parport compatibility by Phil Blundell.
6 * Busy loop avoidance by Mark Cooke.
8 * Module parameters:
10 * maxpoll=<1 - 5000>
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.
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.
21 * yieldlines=<1 - 250>
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.
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. */
35 /* Version 0.5, August 4, 1996 */
36 /* Version 0.7, August 27, 1996 */
37 /* Version 0.9, November 17, 1996 */
40 /******************************************************************
42 Copyright (C) 1996 by Scott Laird
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:
52 The above copyright notice and this permission notice shall be
53 included in all copies or substantial portions of the Software.
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.
63 ******************************************************************/
65 #include <linux/module.h>
66 #include <linux/delay.h>
67 #include <linux/errno.h>
68 #include <linux/fs.h>
69 #include <linux/init.h>
70 #include <linux/kernel.h>
71 #include <linux/slab.h>
72 #include <linux/mm.h>
73 #include <linux/parport.h>
74 #include <linux/sched.h>
75 #include <linux/videodev.h>
76 #include <media/v4l2-common.h>
77 #include <linux/mutex.h>
78 #include <asm/uaccess.h>
80 #include "bw-qcam.h"
82 static unsigned int maxpoll=250; /* Maximum busy-loop count for qcam I/O */
83 static unsigned int yieldlines=4; /* Yield after this many during capture */
84 static int video_nr = -1;
86 module_param(maxpoll, int, 0);
87 module_param(yieldlines, int, 0);
88 module_param(video_nr, int, 0);
90 static inline int read_lpstatus(struct qcam_device *q)
92 return parport_read_status(q->pport);
95 static inline int read_lpdata(struct qcam_device *q)
97 return parport_read_data(q->pport);
100 static inline void write_lpdata(struct qcam_device *q, int d)
102 parport_write_data(q->pport, d);
105 static inline void write_lpcontrol(struct qcam_device *q, int d)
107 if (d & 0x20) {
108 /* Set bidirectional mode to reverse (data in) */
109 parport_data_reverse(q->pport);
110 } else {
111 /* Set bidirectional mode to forward (data out) */
112 parport_data_forward(q->pport);
115 /* Now issue the regular port command, but strip out the
116 * direction flag */
117 d &= ~0x20;
118 parport_write_control(q->pport, d);
121 static int qc_waithand(struct qcam_device *q, int val);
122 static int qc_command(struct qcam_device *q, int command);
123 static int qc_readparam(struct qcam_device *q);
124 static int qc_setscanmode(struct qcam_device *q);
125 static int qc_readbytes(struct qcam_device *q, char buffer[]);
127 static struct video_device qcam_template;
129 static int qc_calibrate(struct qcam_device *q)
132 * Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
133 * The white balance is an individiual value for each
134 * quickcam.
137 int value;
138 int count = 0;
140 qc_command(q, 27); /* AutoAdjustOffset */
141 qc_command(q, 0); /* Dummy Parameter, ignored by the camera */
143 /* GetOffset (33) will read 255 until autocalibration */
144 /* is finished. After that, a value of 1-254 will be */
145 /* returned. */
147 do {
148 qc_command(q, 33);
149 value = qc_readparam(q);
150 mdelay(1);
151 schedule();
152 count++;
153 } while (value == 0xff && count<2048);
155 q->whitebal = value;
156 return value;
159 /* Initialize the QuickCam driver control structure. This is where
160 * defaults are set for people who don't have a config file.*/
162 static struct qcam_device *qcam_init(struct parport *port)
164 struct qcam_device *q;
166 q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
167 if(q==NULL)
168 return NULL;
170 q->pport = port;
171 q->pdev = parport_register_device(port, "bw-qcam", NULL, NULL,
172 NULL, 0, NULL);
173 if (q->pdev == NULL)
175 printk(KERN_ERR "bw-qcam: couldn't register for %s.\n",
176 port->name);
177 kfree(q);
178 return NULL;
181 memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
183 mutex_init(&q->lock);
185 q->port_mode = (QC_ANY | QC_NOTSET);
186 q->width = 320;
187 q->height = 240;
188 q->bpp = 4;
189 q->transfer_scale = 2;
190 q->contrast = 192;
191 q->brightness = 180;
192 q->whitebal = 105;
193 q->top = 1;
194 q->left = 14;
195 q->mode = -1;
196 q->status = QC_PARAM_CHANGE;
197 return q;
201 /* qc_command is probably a bit of a misnomer -- it's used to send
202 * bytes *to* the camera. Generally, these bytes are either commands
203 * or arguments to commands, so the name fits, but it still bugs me a
204 * bit. See the documentation for a list of commands. */
206 static int qc_command(struct qcam_device *q, int command)
208 int n1, n2;
209 int cmd;
211 write_lpdata(q, command);
212 write_lpcontrol(q, 6);
214 n1 = qc_waithand(q, 1);
216 write_lpcontrol(q, 0xe);
217 n2 = qc_waithand(q, 0);
219 cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
220 return cmd;
223 static int qc_readparam(struct qcam_device *q)
225 int n1, n2;
226 int cmd;
228 write_lpcontrol(q, 6);
229 n1 = qc_waithand(q, 1);
231 write_lpcontrol(q, 0xe);
232 n2 = qc_waithand(q, 0);
234 cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
235 return cmd;
238 /* qc_waithand busy-waits for a handshake signal from the QuickCam.
239 * Almost all communication with the camera requires handshaking. */
241 static int qc_waithand(struct qcam_device *q, int val)
243 int status;
244 int runs=0;
246 if (val)
248 while (!((status = read_lpstatus(q)) & 8))
250 /* 1000 is enough spins on the I/O for all normal
251 cases, at that point we start to poll slowly
252 until the camera wakes up. However, we are
253 busy blocked until the camera responds, so
254 setting it lower is much better for interactive
255 response. */
257 if(runs++>maxpoll)
259 msleep_interruptible(5);
261 if(runs>(maxpoll+1000)) /* 5 seconds */
262 return -1;
265 else
267 while (((status = read_lpstatus(q)) & 8))
269 /* 1000 is enough spins on the I/O for all normal
270 cases, at that point we start to poll slowly
271 until the camera wakes up. However, we are
272 busy blocked until the camera responds, so
273 setting it lower is much better for interactive
274 response. */
276 if(runs++>maxpoll)
278 msleep_interruptible(5);
280 if(runs++>(maxpoll+1000)) /* 5 seconds */
281 return -1;
285 return status;
288 /* Waithand2 is used when the qcam is in bidirectional mode, and the
289 * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
290 * (bit 3 of status register). It also returns the last value read,
291 * since this data is useful. */
293 static unsigned int qc_waithand2(struct qcam_device *q, int val)
295 unsigned int status;
296 int runs=0;
300 status = read_lpdata(q);
301 /* 1000 is enough spins on the I/O for all normal
302 cases, at that point we start to poll slowly
303 until the camera wakes up. However, we are
304 busy blocked until the camera responds, so
305 setting it lower is much better for interactive
306 response. */
308 if(runs++>maxpoll)
310 msleep_interruptible(5);
312 if(runs++>(maxpoll+1000)) /* 5 seconds */
313 return 0;
315 while ((status & 1) != val);
317 return status;
321 /* Try to detect a QuickCam. It appears to flash the upper 4 bits of
322 the status register at 5-10 Hz. This is only used in the autoprobe
323 code. Be aware that this isn't the way Connectix detects the
324 camera (they send a reset and try to handshake), but this should be
325 almost completely safe, while their method screws up my printer if
326 I plug it in before the camera. */
328 static int qc_detect(struct qcam_device *q)
330 int reg, lastreg;
331 int count = 0;
332 int i;
334 lastreg = reg = read_lpstatus(q) & 0xf0;
336 for (i = 0; i < 500; i++)
338 reg = read_lpstatus(q) & 0xf0;
339 if (reg != lastreg)
340 count++;
341 lastreg = reg;
342 mdelay(2);
346 #if 0
347 /* Force camera detection during testing. Sometimes the camera
348 won't be flashing these bits. Possibly unloading the module
349 in the middle of a grab? Or some timeout condition?
350 I've seen this parameter as low as 19 on my 450Mhz box - mpc */
351 printk("Debugging: QCam detection counter <30-200 counts as detected>: %d\n", count);
352 return 1;
353 #endif
355 /* Be (even more) liberal in what you accept... */
357 /* if (count > 30 && count < 200) */
358 if (count > 20 && count < 400) {
359 return 1; /* found */
360 } else {
361 printk(KERN_ERR "No Quickcam found on port %s\n",
362 q->pport->name);
363 return 0; /* not found */
368 /* Reset the QuickCam. This uses the same sequence the Windows
369 * QuickPic program uses. Someone with a bi-directional port should
370 * check that bi-directional mode is detected right, and then
371 * implement bi-directional mode in qc_readbyte(). */
373 static void qc_reset(struct qcam_device *q)
375 switch (q->port_mode & QC_FORCE_MASK)
377 case QC_FORCE_UNIDIR:
378 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
379 break;
381 case QC_FORCE_BIDIR:
382 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
383 break;
385 case QC_ANY:
386 write_lpcontrol(q, 0x20);
387 write_lpdata(q, 0x75);
389 if (read_lpdata(q) != 0x75) {
390 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
391 } else {
392 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
394 break;
397 write_lpcontrol(q, 0xb);
398 udelay(250);
399 write_lpcontrol(q, 0xe);
400 qc_setscanmode(q); /* in case port_mode changed */
404 /* Decide which scan mode to use. There's no real requirement that
405 * the scanmode match the resolution in q->height and q-> width -- the
406 * camera takes the picture at the resolution specified in the
407 * "scanmode" and then returns the image at the resolution specified
408 * with the resolution commands. If the scan is bigger than the
409 * requested resolution, the upper-left hand corner of the scan is
410 * returned. If the scan is smaller, then the rest of the image
411 * returned contains garbage. */
413 static int qc_setscanmode(struct qcam_device *q)
415 int old_mode = q->mode;
417 switch (q->transfer_scale)
419 case 1:
420 q->mode = 0;
421 break;
422 case 2:
423 q->mode = 4;
424 break;
425 case 4:
426 q->mode = 8;
427 break;
430 switch (q->bpp)
432 case 4:
433 break;
434 case 6:
435 q->mode += 2;
436 break;
439 switch (q->port_mode & QC_MODE_MASK)
441 case QC_BIDIR:
442 q->mode += 1;
443 break;
444 case QC_NOTSET:
445 case QC_UNIDIR:
446 break;
449 if (q->mode != old_mode)
450 q->status |= QC_PARAM_CHANGE;
452 return 0;
456 /* Reset the QuickCam and program for brightness, contrast,
457 * white-balance, and resolution. */
459 static void qc_set(struct qcam_device *q)
461 int val;
462 int val2;
464 qc_reset(q);
466 /* Set the brightness. Yes, this is repetitive, but it works.
467 * Shorter versions seem to fail subtly. Feel free to try :-). */
468 /* I think the problem was in qc_command, not here -- bls */
470 qc_command(q, 0xb);
471 qc_command(q, q->brightness);
473 val = q->height / q->transfer_scale;
474 qc_command(q, 0x11);
475 qc_command(q, val);
476 if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
477 /* The normal "transfers per line" calculation doesn't seem to work
478 as expected here (and yet it works fine in qc_scan). No idea
479 why this case is the odd man out. Fortunately, Laird's original
480 working version gives me a good way to guess at working values.
481 -- bls */
482 val = q->width;
483 val2 = q->transfer_scale * 4;
484 } else {
485 val = q->width * q->bpp;
486 val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
487 q->transfer_scale;
489 val = (val + val2 - 1) / val2;
490 qc_command(q, 0x13);
491 qc_command(q, val);
493 /* Setting top and left -- bls */
494 qc_command(q, 0xd);
495 qc_command(q, q->top);
496 qc_command(q, 0xf);
497 qc_command(q, q->left / 2);
499 qc_command(q, 0x19);
500 qc_command(q, q->contrast);
501 qc_command(q, 0x1f);
502 qc_command(q, q->whitebal);
504 /* Clear flag that we must update the grabbing parameters on the camera
505 before we grab the next frame */
506 q->status &= (~QC_PARAM_CHANGE);
509 /* Qc_readbytes reads some bytes from the QC and puts them in
510 the supplied buffer. It returns the number of bytes read,
511 or -1 on error. */
513 static inline int qc_readbytes(struct qcam_device *q, char buffer[])
515 int ret=1;
516 unsigned int hi, lo;
517 unsigned int hi2, lo2;
518 static int state = 0;
520 if (buffer == NULL)
522 state = 0;
523 return 0;
526 switch (q->port_mode & QC_MODE_MASK)
528 case QC_BIDIR: /* Bi-directional Port */
529 write_lpcontrol(q, 0x26);
530 lo = (qc_waithand2(q, 1) >> 1);
531 hi = (read_lpstatus(q) >> 3) & 0x1f;
532 write_lpcontrol(q, 0x2e);
533 lo2 = (qc_waithand2(q, 0) >> 1);
534 hi2 = (read_lpstatus(q) >> 3) & 0x1f;
535 switch (q->bpp)
537 case 4:
538 buffer[0] = lo & 0xf;
539 buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
540 buffer[2] = (hi & 0x1e) >> 1;
541 buffer[3] = lo2 & 0xf;
542 buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
543 buffer[5] = (hi2 & 0x1e) >> 1;
544 ret = 6;
545 break;
546 case 6:
547 buffer[0] = lo & 0x3f;
548 buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
549 buffer[2] = lo2 & 0x3f;
550 buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
551 ret = 4;
552 break;
554 break;
556 case QC_UNIDIR: /* Unidirectional Port */
557 write_lpcontrol(q, 6);
558 lo = (qc_waithand(q, 1) & 0xf0) >> 4;
559 write_lpcontrol(q, 0xe);
560 hi = (qc_waithand(q, 0) & 0xf0) >> 4;
562 switch (q->bpp)
564 case 4:
565 buffer[0] = lo;
566 buffer[1] = hi;
567 ret = 2;
568 break;
569 case 6:
570 switch (state)
572 case 0:
573 buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
574 q->saved_bits = (hi & 3) << 4;
575 state = 1;
576 ret = 1;
577 break;
578 case 1:
579 buffer[0] = lo | q->saved_bits;
580 q->saved_bits = hi << 2;
581 state = 2;
582 ret = 1;
583 break;
584 case 2:
585 buffer[0] = ((lo & 0xc) >> 2) | q->saved_bits;
586 buffer[1] = ((lo & 3) << 4) | hi;
587 state = 0;
588 ret = 2;
589 break;
591 break;
593 break;
595 return ret;
598 /* requests a scan from the camera. It sends the correct instructions
599 * to the camera and then reads back the correct number of bytes. In
600 * previous versions of this routine the return structure contained
601 * the raw output from the camera, and there was a 'qc_convertscan'
602 * function that converted that to a useful format. In version 0.3 I
603 * rolled qc_convertscan into qc_scan and now I only return the
604 * converted scan. The format is just an one-dimensional array of
605 * characters, one for each pixel, with 0=black up to n=white, where
606 * n=2^(bit depth)-1. Ask me for more details if you don't understand
607 * this. */
609 static long qc_capture(struct qcam_device * q, char __user *buf, unsigned long len)
611 int i, j, k, yield;
612 int bytes;
613 int linestotrans, transperline;
614 int divisor;
615 int pixels_per_line;
616 int pixels_read = 0;
617 int got=0;
618 char buffer[6];
619 int shift=8-q->bpp;
620 char invert;
622 if (q->mode == -1)
623 return -ENXIO;
625 qc_command(q, 0x7);
626 qc_command(q, q->mode);
628 if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
630 write_lpcontrol(q, 0x2e); /* turn port around */
631 write_lpcontrol(q, 0x26);
632 (void) qc_waithand(q, 1);
633 write_lpcontrol(q, 0x2e);
634 (void) qc_waithand(q, 0);
637 /* strange -- should be 15:63 below, but 4bpp is odd */
638 invert = (q->bpp == 4) ? 16 : 63;
640 linestotrans = q->height / q->transfer_scale;
641 pixels_per_line = q->width / q->transfer_scale;
642 transperline = q->width * q->bpp;
643 divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
644 q->transfer_scale;
645 transperline = (transperline + divisor - 1) / divisor;
647 for (i = 0, yield = yieldlines; i < linestotrans; i++)
649 for (pixels_read = j = 0; j < transperline; j++)
651 bytes = qc_readbytes(q, buffer);
652 for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++)
654 int o;
655 if (buffer[k] == 0 && invert == 16)
657 /* 4bpp is odd (again) -- inverter is 16, not 15, but output
658 must be 0-15 -- bls */
659 buffer[k] = 16;
661 o=i*pixels_per_line + pixels_read + k;
662 if(o<len)
664 got++;
665 put_user((invert - buffer[k])<<shift, buf+o);
668 pixels_read += bytes;
670 (void) qc_readbytes(q, NULL); /* reset state machine */
672 /* Grabbing an entire frame from the quickcam is a lengthy
673 process. We don't (usually) want to busy-block the
674 processor for the entire frame. yieldlines is a module
675 parameter. If we yield every line, the minimum frame
676 time will be 240 / 200 = 1.2 seconds. The compile-time
677 default is to yield every 4 lines. */
678 if (i >= yield) {
679 msleep_interruptible(5);
680 yield = i + yieldlines;
684 if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
686 write_lpcontrol(q, 2);
687 write_lpcontrol(q, 6);
688 udelay(3);
689 write_lpcontrol(q, 0xe);
691 if(got<len)
692 return got;
693 return len;
697 * Video4linux interfacing
700 static int qcam_do_ioctl(struct inode *inode, struct file *file,
701 unsigned int cmd, void *arg)
703 struct video_device *dev = video_devdata(file);
704 struct qcam_device *qcam=(struct qcam_device *)dev;
706 switch(cmd)
708 case VIDIOCGCAP:
710 struct video_capability *b = arg;
711 strcpy(b->name, "Quickcam");
712 b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES|VID_TYPE_MONOCHROME;
713 b->channels = 1;
714 b->audios = 0;
715 b->maxwidth = 320;
716 b->maxheight = 240;
717 b->minwidth = 80;
718 b->minheight = 60;
719 return 0;
721 case VIDIOCGCHAN:
723 struct video_channel *v = arg;
724 if(v->channel!=0)
725 return -EINVAL;
726 v->flags=0;
727 v->tuners=0;
728 /* Good question.. its composite or SVHS so.. */
729 v->type = VIDEO_TYPE_CAMERA;
730 strcpy(v->name, "Camera");
731 return 0;
733 case VIDIOCSCHAN:
735 struct video_channel *v = arg;
736 if(v->channel!=0)
737 return -EINVAL;
738 return 0;
740 case VIDIOCGTUNER:
742 struct video_tuner *v = arg;
743 if(v->tuner)
744 return -EINVAL;
745 strcpy(v->name, "Format");
746 v->rangelow=0;
747 v->rangehigh=0;
748 v->flags= 0;
749 v->mode = VIDEO_MODE_AUTO;
750 return 0;
752 case VIDIOCSTUNER:
754 struct video_tuner *v = arg;
755 if(v->tuner)
756 return -EINVAL;
757 if(v->mode!=VIDEO_MODE_AUTO)
758 return -EINVAL;
759 return 0;
761 case VIDIOCGPICT:
763 struct video_picture *p = arg;
764 p->colour=0x8000;
765 p->hue=0x8000;
766 p->brightness=qcam->brightness<<8;
767 p->contrast=qcam->contrast<<8;
768 p->whiteness=qcam->whitebal<<8;
769 p->depth=qcam->bpp;
770 p->palette=VIDEO_PALETTE_GREY;
771 return 0;
773 case VIDIOCSPICT:
775 struct video_picture *p = arg;
776 if(p->palette!=VIDEO_PALETTE_GREY)
777 return -EINVAL;
778 if(p->depth!=4 && p->depth!=6)
779 return -EINVAL;
782 * Now load the camera.
785 qcam->brightness = p->brightness>>8;
786 qcam->contrast = p->contrast>>8;
787 qcam->whitebal = p->whiteness>>8;
788 qcam->bpp = p->depth;
790 mutex_lock(&qcam->lock);
791 qc_setscanmode(qcam);
792 mutex_unlock(&qcam->lock);
793 qcam->status |= QC_PARAM_CHANGE;
795 return 0;
797 case VIDIOCSWIN:
799 struct video_window *vw = arg;
800 if(vw->flags)
801 return -EINVAL;
802 if(vw->clipcount)
803 return -EINVAL;
804 if(vw->height<60||vw->height>240)
805 return -EINVAL;
806 if(vw->width<80||vw->width>320)
807 return -EINVAL;
809 qcam->width = 320;
810 qcam->height = 240;
811 qcam->transfer_scale = 4;
813 if(vw->width>=160 && vw->height>=120)
815 qcam->transfer_scale = 2;
817 if(vw->width>=320 && vw->height>=240)
819 qcam->width = 320;
820 qcam->height = 240;
821 qcam->transfer_scale = 1;
823 mutex_lock(&qcam->lock);
824 qc_setscanmode(qcam);
825 mutex_unlock(&qcam->lock);
827 /* We must update the camera before we grab. We could
828 just have changed the grab size */
829 qcam->status |= QC_PARAM_CHANGE;
831 /* Ok we figured out what to use from our wide choice */
832 return 0;
834 case VIDIOCGWIN:
836 struct video_window *vw = arg;
837 memset(vw, 0, sizeof(*vw));
838 vw->width=qcam->width/qcam->transfer_scale;
839 vw->height=qcam->height/qcam->transfer_scale;
840 return 0;
842 case VIDIOCKEY:
843 return 0;
844 case VIDIOCCAPTURE:
845 case VIDIOCGFBUF:
846 case VIDIOCSFBUF:
847 case VIDIOCGFREQ:
848 case VIDIOCSFREQ:
849 case VIDIOCGAUDIO:
850 case VIDIOCSAUDIO:
851 return -EINVAL;
852 default:
853 return -ENOIOCTLCMD;
855 return 0;
858 static int qcam_ioctl(struct inode *inode, struct file *file,
859 unsigned int cmd, unsigned long arg)
861 return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
864 static ssize_t qcam_read(struct file *file, char __user *buf,
865 size_t count, loff_t *ppos)
867 struct video_device *v = video_devdata(file);
868 struct qcam_device *qcam=(struct qcam_device *)v;
869 int len;
870 parport_claim_or_block(qcam->pdev);
872 mutex_lock(&qcam->lock);
874 qc_reset(qcam);
876 /* Update the camera parameters if we need to */
877 if (qcam->status & QC_PARAM_CHANGE)
878 qc_set(qcam);
880 len=qc_capture(qcam, buf,count);
882 mutex_unlock(&qcam->lock);
884 parport_release(qcam->pdev);
885 return len;
888 static const struct file_operations qcam_fops = {
889 .owner = THIS_MODULE,
890 .open = video_exclusive_open,
891 .release = video_exclusive_release,
892 .ioctl = qcam_ioctl,
893 .compat_ioctl = v4l_compat_ioctl32,
894 .read = qcam_read,
895 .llseek = no_llseek,
897 static struct video_device qcam_template=
899 .owner = THIS_MODULE,
900 .name = "Connectix Quickcam",
901 .type = VID_TYPE_CAPTURE,
902 .fops = &qcam_fops,
905 #define MAX_CAMS 4
906 static struct qcam_device *qcams[MAX_CAMS];
907 static unsigned int num_cams = 0;
909 static int init_bwqcam(struct parport *port)
911 struct qcam_device *qcam;
913 if (num_cams == MAX_CAMS)
915 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
916 return -ENOSPC;
919 qcam=qcam_init(port);
920 if(qcam==NULL)
921 return -ENODEV;
923 parport_claim_or_block(qcam->pdev);
925 qc_reset(qcam);
927 if(qc_detect(qcam)==0)
929 parport_release(qcam->pdev);
930 parport_unregister_device(qcam->pdev);
931 kfree(qcam);
932 return -ENODEV;
934 qc_calibrate(qcam);
936 parport_release(qcam->pdev);
938 printk(KERN_INFO "Connectix Quickcam on %s\n", qcam->pport->name);
940 if(video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr)==-1)
942 parport_unregister_device(qcam->pdev);
943 kfree(qcam);
944 return -ENODEV;
947 qcams[num_cams++] = qcam;
949 return 0;
952 static void close_bwqcam(struct qcam_device *qcam)
954 video_unregister_device(&qcam->vdev);
955 parport_unregister_device(qcam->pdev);
956 kfree(qcam);
959 /* The parport parameter controls which parports will be scanned.
960 * Scanning all parports causes some printers to print a garbage page.
961 * -- March 14, 1999 Billy Donahue <billy@escape.com> */
962 #ifdef MODULE
963 static char *parport[MAX_CAMS] = { NULL, };
964 module_param_array(parport, charp, NULL, 0);
965 #endif
967 static int accept_bwqcam(struct parport *port)
969 #ifdef MODULE
970 int n;
972 if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
973 /* user gave parport parameters */
974 for(n=0; parport[n] && n<MAX_CAMS; n++){
975 char *ep;
976 unsigned long r;
977 r = simple_strtoul(parport[n], &ep, 0);
978 if (ep == parport[n]) {
979 printk(KERN_ERR
980 "bw-qcam: bad port specifier \"%s\"\n",
981 parport[n]);
982 continue;
984 if (r == port->number)
985 return 1;
987 return 0;
989 #endif
990 return 1;
993 static void bwqcam_attach(struct parport *port)
995 if (accept_bwqcam(port))
996 init_bwqcam(port);
999 static void bwqcam_detach(struct parport *port)
1001 int i;
1002 for (i = 0; i < num_cams; i++) {
1003 struct qcam_device *qcam = qcams[i];
1004 if (qcam && qcam->pdev->port == port) {
1005 qcams[i] = NULL;
1006 close_bwqcam(qcam);
1011 static struct parport_driver bwqcam_driver = {
1012 .name = "bw-qcam",
1013 .attach = bwqcam_attach,
1014 .detach = bwqcam_detach,
1017 static void __exit exit_bw_qcams(void)
1019 parport_unregister_driver(&bwqcam_driver);
1022 static int __init init_bw_qcams(void)
1024 #ifdef MODULE
1025 /* Do some sanity checks on the module parameters. */
1026 if (maxpoll > 5000) {
1027 printk("Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1028 maxpoll = 5000;
1031 if (yieldlines < 1) {
1032 printk("Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1033 yieldlines = 1;
1035 #endif
1036 return parport_register_driver(&bwqcam_driver);
1039 module_init(init_bw_qcams);
1040 module_exit(exit_bw_qcams);
1042 MODULE_LICENSE("GPL");