2 * QuickCam Driver For Video4Linux.
4 * This version only works as a module.
6 * Video4Linux conversion work by Alan Cox.
7 * Parport compatibility by Phil Blundell.
8 * Busy loop avoidance by Mark Cooke.
14 * When polling the QuickCam for a response, busy-wait for a
15 * maximum of this many loops. The default of 250 gives little
16 * impact on interactive response.
18 * NOTE: If this parameter is set too high, the processor
19 * will busy wait until this loop times out, and then
20 * slowly poll for a further 5 seconds before failing
21 * the transaction. You have been warned.
23 * yieldlines=<1 - 250>
25 * When acquiring a frame from the camera, the data gathering
26 * loop will yield back to the scheduler after completing
27 * this many lines. The default of 4 provides a trade-off
28 * between increased frame acquisition time and impact on
29 * interactive response.
32 /* qcam-lib.c -- Library for programming with the Connectix QuickCam.
33 * See the included documentation for usage instructions and details
34 * of the protocol involved. */
37 /* Version 0.5, August 4, 1996 */
38 /* Version 0.7, August 27, 1996 */
39 /* Version 0.9, November 17, 1996 */
42 /******************************************************************
44 Copyright (C) 1996 by Scott Laird
46 Permission is hereby granted, free of charge, to any person obtaining
47 a copy of this software and associated documentation files (the
48 "Software"), to deal in the Software without restriction, including
49 without limitation the rights to use, copy, modify, merge, publish,
50 distribute, sublicense, and/or sell copies of the Software, and to
51 permit persons to whom the Software is furnished to do so, subject to
52 the following conditions:
54 The above copyright notice and this permission notice shall be
55 included in all copies or substantial portions of the Software.
57 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
58 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
59 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
60 IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
61 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
62 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
63 OTHER DEALINGS IN THE SOFTWARE.
65 ******************************************************************/
67 #include <linux/module.h>
68 #include <linux/delay.h>
69 #include <linux/errno.h>
71 #include <linux/init.h>
72 #include <linux/kernel.h>
73 #include <linux/malloc.h>
75 #include <linux/parport.h>
76 #include <linux/sched.h>
77 #include <linux/version.h>
78 #include <linux/videodev.h>
79 #include <asm/semaphore.h>
80 #include <asm/uaccess.h>
84 static unsigned int maxpoll
=250; /* Maximum busy-loop count for qcam I/O */
85 static unsigned int yieldlines
=4; /* Yield after this many during capture */
87 #if LINUX_VERSION_CODE >= 0x020117
88 MODULE_PARM(maxpoll
,"i");
89 MODULE_PARM(yieldlines
,"i");
92 extern __inline__
int read_lpstatus(struct qcam_device
*q
)
94 return parport_read_status(q
->pport
);
97 extern __inline__
int read_lpcontrol(struct qcam_device
*q
)
99 return parport_read_control(q
->pport
);
102 extern __inline__
int read_lpdata(struct qcam_device
*q
)
104 return parport_read_data(q
->pport
);
107 extern __inline__
void write_lpdata(struct qcam_device
*q
, int d
)
109 parport_write_data(q
->pport
, d
);
112 extern __inline__
void write_lpcontrol(struct qcam_device
*q
, int d
)
114 parport_write_control(q
->pport
, d
);
117 static int qc_waithand(struct qcam_device
*q
, int val
);
118 static int qc_command(struct qcam_device
*q
, int command
);
119 static int qc_readparam(struct qcam_device
*q
);
120 static int qc_setscanmode(struct qcam_device
*q
);
121 static int qc_readbytes(struct qcam_device
*q
, char buffer
[]);
123 static struct video_device qcam_template
;
125 static int qc_calibrate(struct qcam_device
*q
)
128 * Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
129 * The white balance is an individiual value for each
136 qc_command(q
, 27); /* AutoAdjustOffset */
137 qc_command(q
, 0); /* Dummy Parameter, ignored by the camera */
139 /* GetOffset (33) will read 255 until autocalibration */
140 /* is finished. After that, a value of 1-254 will be */
145 value
= qc_readparam(q
);
149 } while (value
== 0xff && count
<2048);
155 /* Initialize the QuickCam driver control structure. This is where
156 * defaults are set for people who don't have a config file.*/
158 static struct qcam_device
*qcam_init(struct parport
*port
)
160 struct qcam_device
*q
;
162 q
= kmalloc(sizeof(struct qcam_device
), GFP_KERNEL
);
167 q
->pdev
= parport_register_device(port
, "bw-qcam", NULL
, NULL
,
171 printk(KERN_ERR
"bw-qcam: couldn't register for %s.\n",
177 memcpy(&q
->vdev
, &qcam_template
, sizeof(qcam_template
));
179 init_MUTEX(&q
->lock
);
181 q
->port_mode
= (QC_ANY
| QC_NOTSET
);
185 q
->transfer_scale
= 2;
192 q
->status
= QC_PARAM_CHANGE
;
197 /* qc_command is probably a bit of a misnomer -- it's used to send
198 * bytes *to* the camera. Generally, these bytes are either commands
199 * or arguments to commands, so the name fits, but it still bugs me a
200 * bit. See the documentation for a list of commands. */
202 static int qc_command(struct qcam_device
*q
, int command
)
207 write_lpdata(q
, command
);
208 write_lpcontrol(q
, 6);
210 n1
= qc_waithand(q
, 1);
212 write_lpcontrol(q
, 0xe);
213 n2
= qc_waithand(q
, 0);
215 cmd
= (n1
& 0xf0) | ((n2
& 0xf0) >> 4);
219 static int qc_readparam(struct qcam_device
*q
)
224 write_lpcontrol(q
, 6);
225 n1
= qc_waithand(q
, 1);
227 write_lpcontrol(q
, 0xe);
228 n2
= qc_waithand(q
, 0);
230 cmd
= (n1
& 0xf0) | ((n2
& 0xf0) >> 4);
234 /* qc_waithand busy-waits for a handshake signal from the QuickCam.
235 * Almost all communication with the camera requires handshaking. */
237 static int qc_waithand(struct qcam_device
*q
, int val
)
244 while (!((status
= read_lpstatus(q
)) & 8))
246 /* 1000 is enough spins on the I/O for all normal
247 cases, at that point we start to poll slowly
248 until the camera wakes up. However, we are
249 busy blocked until the camera responds, so
250 setting it lower is much better for interactive
255 current
->state
=TASK_INTERRUPTIBLE
;
256 schedule_timeout(HZ
/200);
258 if(runs
>(maxpoll
+1000)) /* 5 seconds */
264 while (((status
= read_lpstatus(q
)) & 8))
266 /* 1000 is enough spins on the I/O for all normal
267 cases, at that point we start to poll slowly
268 until the camera wakes up. However, we are
269 busy blocked until the camera responds, so
270 setting it lower is much better for interactive
275 current
->state
=TASK_INTERRUPTIBLE
;
276 schedule_timeout(HZ
/200);
278 if(runs
++>(maxpoll
+1000)) /* 5 seconds */
286 /* Waithand2 is used when the qcam is in bidirectional mode, and the
287 * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
288 * (bit 3 of status register). It also returns the last value read,
289 * since this data is useful. */
291 static unsigned int qc_waithand2(struct qcam_device
*q
, int val
)
298 status
= read_lpdata(q
);
299 /* 1000 is enough spins on the I/O for all normal
300 cases, at that point we start to poll slowly
301 until the camera wakes up. However, we are
302 busy blocked until the camera responds, so
303 setting it lower is much better for interactive
308 current
->state
=TASK_INTERRUPTIBLE
;
309 schedule_timeout(HZ
/200);
311 if(runs
++>(maxpoll
+1000)) /* 5 seconds */
314 while ((status
& 1) != val
);
320 /* Try to detect a QuickCam. It appears to flash the upper 4 bits of
321 the status register at 5-10 Hz. This is only used in the autoprobe
322 code. Be aware that this isn't the way Connectix detects the
323 camera (they send a reset and try to handshake), but this should be
324 almost completely safe, while their method screws up my printer if
325 I plug it in before the camera. */
327 static int qc_detect(struct qcam_device
*q
)
333 lastreg
= reg
= read_lpstatus(q
) & 0xf0;
335 for (i
= 0; i
< 500; i
++)
337 reg
= read_lpstatus(q
) & 0xf0;
346 /* Force camera detection during testing. Sometimes the camera
347 won't be flashing these bits. Possibly unloading the module
348 in the middle of a grab? Or some timeout condition?
349 I've seen this parameter as low as 19 on my 450Mhz box - mpc */
350 printk("Debugging: QCam detection counter <30-200 counts as detected>: %d\n", count
);
354 /* Be (even more) liberal in what you accept... */
356 /* if (count > 30 && count < 200) */
357 if (count
> 20 && count
< 300)
358 return 1; /* found */
360 return 0; /* not found */
364 /* Reset the QuickCam. This uses the same sequence the Windows
365 * QuickPic program uses. Someone with a bi-directional port should
366 * check that bi-directional mode is detected right, and then
367 * implement bi-directional mode in qc_readbyte(). */
369 static void qc_reset(struct qcam_device
*q
)
371 switch (q
->port_mode
& QC_FORCE_MASK
)
373 case QC_FORCE_UNIDIR
:
374 q
->port_mode
= (q
->port_mode
& ~QC_MODE_MASK
) | QC_UNIDIR
;
378 q
->port_mode
= (q
->port_mode
& ~QC_MODE_MASK
) | QC_BIDIR
;
382 write_lpcontrol(q
, 0x20);
383 write_lpdata(q
, 0x75);
385 if (read_lpdata(q
) != 0x75) {
386 q
->port_mode
= (q
->port_mode
& ~QC_MODE_MASK
) | QC_BIDIR
;
388 q
->port_mode
= (q
->port_mode
& ~QC_MODE_MASK
) | QC_UNIDIR
;
393 write_lpcontrol(q
, 0xb);
395 write_lpcontrol(q
, 0xe);
396 qc_setscanmode(q
); /* in case port_mode changed */
400 /* Decide which scan mode to use. There's no real requirement that
401 * the scanmode match the resolution in q->height and q-> width -- the
402 * camera takes the picture at the resolution specified in the
403 * "scanmode" and then returns the image at the resolution specified
404 * with the resolution commands. If the scan is bigger than the
405 * requested resolution, the upper-left hand corner of the scan is
406 * returned. If the scan is smaller, then the rest of the image
407 * returned contains garbage. */
409 static int qc_setscanmode(struct qcam_device
*q
)
411 int old_mode
= q
->mode
;
413 switch (q
->transfer_scale
)
435 switch (q
->port_mode
& QC_MODE_MASK
)
445 if (q
->mode
!= old_mode
)
446 q
->status
|= QC_PARAM_CHANGE
;
452 /* Reset the QuickCam and program for brightness, contrast,
453 * white-balance, and resolution. */
455 void qc_set(struct qcam_device
*q
)
462 /* Set the brightness. Yes, this is repetitive, but it works.
463 * Shorter versions seem to fail subtly. Feel free to try :-). */
464 /* I think the problem was in qc_command, not here -- bls */
467 qc_command(q
, q
->brightness
);
469 val
= q
->height
/ q
->transfer_scale
;
472 if ((q
->port_mode
& QC_MODE_MASK
) == QC_UNIDIR
&& q
->bpp
== 6) {
473 /* The normal "transfers per line" calculation doesn't seem to work
474 as expected here (and yet it works fine in qc_scan). No idea
475 why this case is the odd man out. Fortunately, Laird's original
476 working version gives me a good way to guess at working values.
479 val2
= q
->transfer_scale
* 4;
481 val
= q
->width
* q
->bpp
;
482 val2
= (((q
->port_mode
& QC_MODE_MASK
) == QC_BIDIR
) ? 24 : 8) *
485 val
= (val
+ val2
- 1) / val2
;
489 /* Setting top and left -- bls */
491 qc_command(q
, q
->top
);
493 qc_command(q
, q
->left
/ 2);
496 qc_command(q
, q
->contrast
);
498 qc_command(q
, q
->whitebal
);
500 /* Clear flag that we must update the grabbing parameters on the camera
501 before we grab the next frame */
502 q
->status
&= (~QC_PARAM_CHANGE
);
505 /* Qc_readbytes reads some bytes from the QC and puts them in
506 the supplied buffer. It returns the number of bytes read,
509 extern __inline__
int qc_readbytes(struct qcam_device
*q
, char buffer
[])
513 unsigned int hi2
, lo2
;
514 static int state
= 0;
522 switch (q
->port_mode
& QC_MODE_MASK
)
524 case QC_BIDIR
: /* Bi-directional Port */
525 write_lpcontrol(q
, 0x26);
526 lo
= (qc_waithand2(q
, 1) >> 1);
527 hi
= (read_lpstatus(q
) >> 3) & 0x1f;
528 write_lpcontrol(q
, 0x2e);
529 lo2
= (qc_waithand2(q
, 0) >> 1);
530 hi2
= (read_lpstatus(q
) >> 3) & 0x1f;
534 buffer
[0] = lo
& 0xf;
535 buffer
[1] = ((lo
& 0x70) >> 4) | ((hi
& 1) << 3);
536 buffer
[2] = (hi
& 0x1e) >> 1;
537 buffer
[3] = lo2
& 0xf;
538 buffer
[4] = ((lo2
& 0x70) >> 4) | ((hi2
& 1) << 3);
539 buffer
[5] = (hi2
& 0x1e) >> 1;
543 buffer
[0] = lo
& 0x3f;
544 buffer
[1] = ((lo
& 0x40) >> 6) | (hi
<< 1);
545 buffer
[2] = lo2
& 0x3f;
546 buffer
[3] = ((lo2
& 0x40) >> 6) | (hi2
<< 1);
552 case QC_UNIDIR
: /* Unidirectional Port */
553 write_lpcontrol(q
, 6);
554 lo
= (qc_waithand(q
, 1) & 0xf0) >> 4;
555 write_lpcontrol(q
, 0xe);
556 hi
= (qc_waithand(q
, 0) & 0xf0) >> 4;
569 buffer
[0] = (lo
<< 2) | ((hi
& 0xc) >> 2);
570 q
->saved_bits
= (hi
& 3) << 4;
575 buffer
[0] = lo
| q
->saved_bits
;
576 q
->saved_bits
= hi
<< 2;
581 buffer
[0] = ((lo
& 0xc) >> 2) | q
->saved_bits
;
582 buffer
[1] = ((lo
& 3) << 4) | hi
;
594 /* requests a scan from the camera. It sends the correct instructions
595 * to the camera and then reads back the correct number of bytes. In
596 * previous versions of this routine the return structure contained
597 * the raw output from the camera, and there was a 'qc_convertscan'
598 * function that converted that to a useful format. In version 0.3 I
599 * rolled qc_convertscan into qc_scan and now I only return the
600 * converted scan. The format is just an one-dimensional array of
601 * characters, one for each pixel, with 0=black up to n=white, where
602 * n=2^(bit depth)-1. Ask me for more details if you don't understand
605 long qc_capture(struct qcam_device
* q
, char *buf
, unsigned long len
)
609 int linestotrans
, transperline
;
622 qc_command(q
, q
->mode
);
624 if ((q
->port_mode
& QC_MODE_MASK
) == QC_BIDIR
)
626 write_lpcontrol(q
, 0x2e); /* turn port around */
627 write_lpcontrol(q
, 0x26);
628 (void) qc_waithand(q
, 1);
629 write_lpcontrol(q
, 0x2e);
630 (void) qc_waithand(q
, 0);
633 /* strange -- should be 15:63 below, but 4bpp is odd */
634 invert
= (q
->bpp
== 4) ? 16 : 63;
636 linestotrans
= q
->height
/ q
->transfer_scale
;
637 pixels_per_line
= q
->width
/ q
->transfer_scale
;
638 transperline
= q
->width
* q
->bpp
;
639 divisor
= (((q
->port_mode
& QC_MODE_MASK
) == QC_BIDIR
) ? 24 : 8) *
641 transperline
= (transperline
+ divisor
- 1) / divisor
;
643 for (i
= 0, yield
= yieldlines
; i
< linestotrans
; i
++)
645 for (pixels_read
= j
= 0; j
< transperline
; j
++)
647 bytes
= qc_readbytes(q
, buffer
);
648 for (k
= 0; k
< bytes
&& (pixels_read
+ k
) < pixels_per_line
; k
++)
651 if (buffer
[k
] == 0 && invert
== 16)
653 /* 4bpp is odd (again) -- inverter is 16, not 15, but output
654 must be 0-15 -- bls */
657 o
=i
*pixels_per_line
+ pixels_read
+ k
;
661 put_user((invert
- buffer
[k
])<<shift
, buf
+o
);
664 pixels_read
+= bytes
;
666 (void) qc_readbytes(q
, 0); /* reset state machine */
668 /* Grabbing an entire frame from the quickcam is a lengthy
669 process. We don't (usually) want to busy-block the
670 processor for the entire frame. yieldlines is a module
671 parameter. If we yield every line, the minimum frame
672 time will be 240 / 200 = 1.2 seconds. The compile-time
673 default is to yield every 4 lines. */
675 current
->state
=TASK_INTERRUPTIBLE
;
676 schedule_timeout(HZ
/200);
677 yield
= i
+ yieldlines
;
681 if ((q
->port_mode
& QC_MODE_MASK
) == QC_BIDIR
)
683 write_lpcontrol(q
, 2);
684 write_lpcontrol(q
, 6);
686 write_lpcontrol(q
, 0xe);
694 * Video4linux interfacing
697 static int qcam_open(struct video_device
*dev
, int flags
)
703 static void qcam_close(struct video_device
*dev
)
708 static long qcam_write(struct video_device
*v
, const char *buf
, unsigned long count
, int noblock
)
713 static int qcam_ioctl(struct video_device
*dev
, unsigned int cmd
, void *arg
)
715 struct qcam_device
*qcam
=(struct qcam_device
*)dev
;
721 struct video_capability b
;
722 strcpy(b
.name
, "Quickcam");
723 b
.type
= VID_TYPE_CAPTURE
|VID_TYPE_SCALES
|VID_TYPE_MONOCHROME
;
730 if(copy_to_user(arg
, &b
,sizeof(b
)))
736 struct video_channel v
;
737 if(copy_from_user(&v
, arg
, sizeof(v
)))
743 /* Good question.. its composite or SVHS so.. */
744 v
.type
= VIDEO_TYPE_CAMERA
;
745 strcpy(v
.name
, "Camera");
746 if(copy_to_user(arg
, &v
, sizeof(v
)))
753 if(copy_from_user(&v
, arg
,sizeof(v
)))
761 struct video_tuner v
;
762 if(copy_from_user(&v
, arg
, sizeof(v
))!=0)
766 strcpy(v
.name
, "Format");
770 v
.mode
= VIDEO_MODE_AUTO
;
771 if(copy_to_user(arg
,&v
,sizeof(v
))!=0)
777 struct video_tuner v
;
778 if(copy_from_user(&v
, arg
, sizeof(v
))!=0)
782 if(v
.mode
!=VIDEO_MODE_AUTO
)
788 struct video_picture p
;
791 p
.brightness
=qcam
->brightness
<<8;
792 p
.contrast
=qcam
->contrast
<<8;
793 p
.whiteness
=qcam
->whitebal
<<8;
795 p
.palette
=VIDEO_PALETTE_GREY
;
796 if(copy_to_user(arg
, &p
, sizeof(p
)))
802 struct video_picture p
;
803 if(copy_from_user(&p
, arg
, sizeof(p
)))
805 if(p
.palette
!=VIDEO_PALETTE_GREY
)
807 if(p
.depth
!=4 && p
.depth
!=6)
811 * Now load the camera.
814 qcam
->brightness
= p
.brightness
>>8;
815 qcam
->contrast
= p
.contrast
>>8;
816 qcam
->whitebal
= p
.whiteness
>>8;
820 qc_setscanmode(qcam
);
822 qcam
->status
|= QC_PARAM_CHANGE
;
828 struct video_window vw
;
829 if(copy_from_user(&vw
, arg
,sizeof(vw
)))
835 if(vw
.height
<60||vw
.height
>240)
837 if(vw
.width
<80||vw
.width
>320)
842 qcam
->transfer_scale
= 4;
844 if(vw
.width
>=160 && vw
.height
>=120)
846 qcam
->transfer_scale
= 2;
848 if(vw
.width
>=320 && vw
.height
>=240)
852 qcam
->transfer_scale
= 1;
855 qc_setscanmode(qcam
);
858 /* We must update the camera before we grab. We could
859 just have changed the grab size */
860 qcam
->status
|= QC_PARAM_CHANGE
;
862 /* Ok we figured out what to use from our wide choice */
867 struct video_window vw
;
868 memset(&vw
, 0, sizeof(vw
));
869 vw
.width
=qcam
->width
/qcam
->transfer_scale
;
870 vw
.height
=qcam
->height
/qcam
->transfer_scale
;
871 if(copy_to_user(arg
, &vw
, sizeof(vw
)))
897 static long qcam_read(struct video_device
*v
, char *buf
, unsigned long count
, int noblock
)
899 struct qcam_device
*qcam
=(struct qcam_device
*)v
;
901 parport_claim_or_block(qcam
->pdev
);
907 /* Update the camera parameters if we need to */
908 if (qcam
->status
& QC_PARAM_CHANGE
)
911 len
=qc_capture(qcam
, buf
,count
);
915 parport_release(qcam
->pdev
);
919 static struct video_device qcam_template
=
921 name
: "Connectix Quickcam",
922 type
: VID_TYPE_CAPTURE
,
923 hardware
: VID_HARDWARE_QCAM_BW
,
932 static struct qcam_device
*qcams
[MAX_CAMS
];
933 static unsigned int num_cams
= 0;
935 int init_bwqcam(struct parport
*port
)
937 struct qcam_device
*qcam
;
939 if (num_cams
== MAX_CAMS
)
941 printk(KERN_ERR
"Too many Quickcams (max %d)\n", MAX_CAMS
);
945 qcam
=qcam_init(port
);
949 parport_claim_or_block(qcam
->pdev
);
953 if(qc_detect(qcam
)==0)
955 parport_release(qcam
->pdev
);
956 parport_unregister_device(qcam
->pdev
);
962 parport_release(qcam
->pdev
);
964 printk(KERN_INFO
"Connectix Quickcam on %s\n", qcam
->pport
->name
);
966 if(video_register_device(&qcam
->vdev
, VFL_TYPE_GRABBER
)==-1)
968 parport_unregister_device(qcam
->pdev
);
973 qcams
[num_cams
++] = qcam
;
978 void close_bwqcam(struct qcam_device
*qcam
)
980 video_unregister_device(&qcam
->vdev
);
981 parport_unregister_device(qcam
->pdev
);
985 /* The parport parameter controls which parports will be scanned.
986 * Scanning all parports causes some printers to print a garbage page.
987 * -- March 14, 1999 Billy Donahue <billy@escape.com> */
989 static char *parport
[MAX_CAMS
] = { NULL
, };
990 MODULE_PARM(parport
, "1-" __MODULE_STRING(MAX_CAMS
) "s");
994 int init_module(void)
996 struct parport
*port
;
998 if(parport
[0] && strncmp(parport
[0], "auto", 4)){
999 /* user gave parport parameters */
1000 for(n
=0; parport
[n
] && n
<MAX_CAMS
; n
++){
1003 r
= simple_strtoul(parport
[n
], &ep
, 0);
1004 if(ep
== parport
[n
]){
1006 "bw-qcam: bad port specifier \"%s\"\n",
1010 for (port
=parport_enumerate(); port
; port
=port
->next
){
1017 return (num_cams
)?0:-ENODEV
;
1019 /* no parameter or "auto" */
1020 for (port
= parport_enumerate(); port
; port
=port
->next
)
1023 /* Do some sanity checks on the module parameters. */
1024 if (maxpoll
> 5000) {
1025 printk("Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1029 if (yieldlines
< 1) {
1030 printk("Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1034 return (num_cams
)?0:-ENODEV
;
1037 void cleanup_module(void)
1040 for (i
= 0; i
< num_cams
; i
++)
1041 close_bwqcam(qcams
[i
]);
1044 int __init
init_bw_qcams(struct video_init
*unused
)
1046 struct parport
*port
;
1048 for (port
= parport_enumerate(); port
; port
=port
->next
)