[ARM] pxa: Gumstix Verdex PCMCIA support
[linux-2.6/verdex.git] / drivers / media / video / c-qcam.c
blob85cf1778827adee718ba6ad930bfec12d37be25d
1 /*
2 * Video4Linux Colour QuickCam driver
3 * Copyright 1997-2000 Philip Blundell <philb@gnu.org>
5 * Module parameters:
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
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
15 * force_rgb=1 -- force data format to RGB (default is BGR)
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>
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>
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>
42 #include <asm/uaccess.h>
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;
58 /* cameras maximum */
59 #define MAX_CAMS 4
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) */
66 /* The three possible decimations */
67 #define QC_DECIMATION_1 0
68 #define QC_DECIMATION_2 2
69 #define QC_DECIMATION_4 4
71 #define BANNER "Colour QuickCam for Video4Linux v0.05"
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;
78 static inline void qcam_set_ack(struct qcam_device *qcam, unsigned int i)
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);
85 static inline unsigned int qcam_ready1(struct qcam_device *qcam)
87 return (parport_read_status(qcam->pport) & 0x8)?1:0;
90 static inline unsigned int qcam_ready2(struct qcam_device *qcam)
92 return (parport_read_data(qcam->pport) & 0x1)?1:0;
95 static unsigned int qcam_await_ready1(struct qcam_device *qcam,
96 int value)
98 unsigned long oldjiffies = jiffies;
99 unsigned int i;
101 for (oldjiffies = jiffies;
102 time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
103 if (qcam_ready1(qcam) == value)
104 return 0;
106 /* If the camera didn't respond within 1/25 second, poll slowly
107 for a while. */
108 for (i = 0; i < 50; i++)
110 if (qcam_ready1(qcam) == value)
111 return 0;
112 msleep_interruptible(100);
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;
122 static unsigned int qcam_await_ready2(struct qcam_device *qcam, int value)
124 unsigned long oldjiffies = jiffies;
125 unsigned int i;
127 for (oldjiffies = jiffies;
128 time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
129 if (qcam_ready2(qcam) == value)
130 return 0;
132 /* If the camera didn't respond within 1/25 second, poll slowly
133 for a while. */
134 for (i = 0; i < 50; i++)
136 if (qcam_ready2(qcam) == value)
137 return 0;
138 msleep_interruptible(100);
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;
149 static int qcam_read_data(struct qcam_device *qcam)
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;
161 static int qcam_write_data(struct qcam_device *qcam, unsigned int data)
163 unsigned int idata;
164 parport_write_data(qcam->pport, data);
165 idata = qcam_read_data(qcam);
166 if (data != idata)
168 printk(KERN_WARNING "cqcam: sent %x but received %x\n", data,
169 idata);
170 return 1;
172 return 0;
175 static inline int qcam_set(struct qcam_device *qcam, unsigned int cmd, unsigned int data)
177 if (qcam_write_data(qcam, cmd))
178 return -1;
179 if (qcam_write_data(qcam, data))
180 return -1;
181 return 0;
184 static inline int qcam_get(struct qcam_device *qcam, unsigned int cmd)
186 if (qcam_write_data(qcam, cmd))
187 return -1;
188 return qcam_read_data(qcam);
191 static int qc_detect(struct qcam_device *qcam)
193 unsigned int stat, ostat, i, count = 0;
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;
208 if (probe < 2)
209 return 0;
211 parport_write_control(qcam->pport, 0xc);
213 /* look for a heartbeat */
214 ostat = stat = parport_read_status(qcam->pport);
215 for (i=0; i<250; i++)
217 mdelay(1);
218 stat = parport_read_status(qcam->pport);
219 if (ostat != stat)
221 if (++count >= 3) return 1;
222 ostat = stat;
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;
234 ostat = stat = parport_read_status(qcam->pport);
235 for (i=0; i<250; i++)
237 mdelay(1);
238 stat = parport_read_status(qcam->pport);
239 if (ostat != stat)
241 if (++count >= 3) return 1;
242 ostat = stat;
246 /* no (or flatline) camera, give up */
247 return 0;
250 static void qc_reset(struct qcam_device *qcam)
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);
259 /* Reset the QuickCam and program for brightness, contrast,
260 * white-balance, and resolution. */
262 static void qc_setup(struct qcam_device *q)
264 qc_reset(q);
266 /* Set the brightness. */
267 qcam_set(q, 11, q->brightness);
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);
274 /* Set top and left. */
275 qcam_set(q, 0xd, q->top);
276 qcam_set(q, 0xf, q->left);
278 /* Set contrast and white balance. */
279 qcam_set(q, 0x19, q->contrast);
280 qcam_set(q, 0x1f, q->whitebal);
282 /* Set the speed. */
283 qcam_set(q, 45, 2);
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. */
290 static unsigned int qcam_read_bytes(struct qcam_device *q, unsigned char *buf, unsigned int nbytes)
292 unsigned int bytes = 0;
294 qcam_set_ack(q, 0);
295 if (q->bidirectional)
297 /* It's a bidirectional port */
298 while (bytes < nbytes)
300 unsigned int lo1, hi1, lo2, hi2;
301 unsigned char r, g, b;
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;
325 else
327 /* It's a unidirectional port */
328 int i = 0, n = bytes;
329 unsigned char rgb[3];
331 while (bytes < nbytes)
333 unsigned int hi, lo;
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];
356 if (i) {
357 i = 0;
358 goto get_fragment;
361 return bytes;
364 #define BUFSZ 150
366 static long qc_capture(struct qcam_device *q, char __user *buf, unsigned long len)
368 unsigned lines, pixelsperline, bitsperxfer;
369 unsigned int is_bi_dir = q->bidirectional;
370 size_t wantlen, outptr = 0;
371 char tmpbuf[BUFSZ];
373 if (!access_ok(VERIFY_WRITE, buf, len))
374 return -EFAULT;
376 /* Wait for camera to become ready */
377 for (;;)
379 int i = qcam_get(q, 41);
380 if (i == -1) {
381 qc_setup(q);
382 return -EIO;
384 if ((i & 0x80) == 0)
385 break;
386 else
387 schedule();
390 if (qcam_set(q, 7, (q->mode | (is_bi_dir?1:0)) + 1))
391 return -EIO;
393 lines = q->height;
394 pixelsperline = q->width;
395 bitsperxfer = (is_bi_dir) ? 24 : 8;
397 if (is_bi_dir)
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;
407 qcam_set_ack(q, 1);
408 if (qcam_await_ready1(q, 0)) {
409 qc_setup(q);
410 return -EIO;
414 wantlen = lines * pixelsperline * 24 / 8;
416 while (wantlen)
418 size_t t, s;
419 s = (wantlen > BUFSZ)?BUFSZ:wantlen;
420 t = qcam_read_bytes(q, tmpbuf, s);
421 if (outptr < len)
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;
429 wantlen -= t;
430 if (t < s)
431 break;
432 cond_resched();
435 len = outptr;
437 if (wantlen)
439 printk("qcam: short read.\n");
440 if (is_bi_dir)
441 parport_data_forward(q->pport);
442 qc_setup(q);
443 return len;
446 if (is_bi_dir)
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");
460 qcam_set_ack(q, 0);
461 if (qcam_await_ready1(q, 1))
463 printk("qcam: no ack after EOF\n");
464 parport_data_forward(q->pport);
465 qc_setup(q);
466 return len;
468 parport_data_forward(q->pport);
469 mdelay(3);
470 qcam_set_ack(q, 1);
471 if (qcam_await_ready1(q, 0))
473 printk("qcam: no ack to port turnaround\n");
474 qc_setup(q);
475 return len;
478 else
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");
495 qcam_write_data(q, 0);
496 return len;
500 * Video4linux interfacing
503 static long qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
505 struct video_device *dev = video_devdata(file);
506 struct qcam_device *qcam=(struct qcam_device *)dev;
508 switch(cmd)
510 case VIDIOCGCAP:
512 struct video_capability *b = arg;
513 strcpy(b->name, "Quickcam");
514 b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES;
515 b->channels = 1;
516 b->audios = 0;
517 b->maxwidth = 320;
518 b->maxheight = 240;
519 b->minwidth = 80;
520 b->minheight = 60;
521 return 0;
523 case VIDIOCGCHAN:
525 struct video_channel *v = arg;
526 if(v->channel!=0)
527 return -EINVAL;
528 v->flags=0;
529 v->tuners=0;
530 /* Good question.. its composite or SVHS so.. */
531 v->type = VIDEO_TYPE_CAMERA;
532 strcpy(v->name, "Camera");
533 return 0;
535 case VIDIOCSCHAN:
537 struct video_channel *v = arg;
538 if(v->channel!=0)
539 return -EINVAL;
540 return 0;
542 case VIDIOCGTUNER:
544 struct video_tuner *v = arg;
545 if(v->tuner)
546 return -EINVAL;
547 memset(v,0,sizeof(*v));
548 strcpy(v->name, "Format");
549 v->mode = VIDEO_MODE_AUTO;
550 return 0;
552 case VIDIOCSTUNER:
554 struct video_tuner *v = arg;
555 if(v->tuner)
556 return -EINVAL;
557 if(v->mode!=VIDEO_MODE_AUTO)
558 return -EINVAL;
559 return 0;
561 case VIDIOCGPICT:
563 struct video_picture *p = arg;
564 p->colour=0x8000;
565 p->hue=0x8000;
566 p->brightness=qcam->brightness<<8;
567 p->contrast=qcam->contrast<<8;
568 p->whiteness=qcam->whitebal<<8;
569 p->depth=24;
570 p->palette=VIDEO_PALETTE_RGB24;
571 return 0;
573 case VIDIOCSPICT:
575 struct video_picture *p = arg;
578 * Sanity check args
580 if (p->depth != 24 || p->palette != VIDEO_PALETTE_RGB24)
581 return -EINVAL;
584 * Now load the camera.
586 qcam->brightness = p->brightness>>8;
587 qcam->contrast = p->contrast>>8;
588 qcam->whitebal = p->whiteness>>8;
590 mutex_lock(&qcam->lock);
591 parport_claim_or_block(qcam->pdev);
592 qc_setup(qcam);
593 parport_release(qcam->pdev);
594 mutex_unlock(&qcam->lock);
595 return 0;
597 case VIDIOCSWIN:
599 struct video_window *vw = arg;
601 if(vw->flags)
602 return -EINVAL;
603 if(vw->clipcount)
604 return -EINVAL;
605 if(vw->height<60||vw->height>240)
606 return -EINVAL;
607 if(vw->width<80||vw->width>320)
608 return -EINVAL;
610 qcam->width = 80;
611 qcam->height = 60;
612 qcam->mode = QC_DECIMATION_4;
614 if(vw->width>=160 && vw->height>=120)
616 qcam->width = 160;
617 qcam->height = 120;
618 qcam->mode = QC_DECIMATION_2;
620 if(vw->width>=320 && vw->height>=240)
622 qcam->width = 320;
623 qcam->height = 240;
624 qcam->mode = QC_DECIMATION_1;
626 qcam->mode |= QC_MILLIONS;
627 #if 0
628 if(vw->width>=640 && vw->height>=480)
630 qcam->width = 640;
631 qcam->height = 480;
632 qcam->mode = QC_BILLIONS | QC_DECIMATION_1;
634 #endif
635 /* Ok we figured out what to use from our
636 wide choice */
637 mutex_lock(&qcam->lock);
638 parport_claim_or_block(qcam->pdev);
639 qc_setup(qcam);
640 parport_release(qcam->pdev);
641 mutex_unlock(&qcam->lock);
642 return 0;
644 case VIDIOCGWIN:
646 struct video_window *vw = arg;
647 memset(vw, 0, sizeof(*vw));
648 vw->width=qcam->width;
649 vw->height=qcam->height;
650 return 0;
652 case VIDIOCKEY:
653 return 0;
654 case VIDIOCCAPTURE:
655 case VIDIOCGFBUF:
656 case VIDIOCSFBUF:
657 case VIDIOCGFREQ:
658 case VIDIOCSFREQ:
659 case VIDIOCGAUDIO:
660 case VIDIOCSAUDIO:
661 return -EINVAL;
662 default:
663 return -ENOIOCTLCMD;
665 return 0;
668 static long qcam_ioctl(struct file *file,
669 unsigned int cmd, unsigned long arg)
671 return video_usercopy(file, cmd, arg, qcam_do_ioctl);
674 static ssize_t qcam_read(struct file *file, char __user *buf,
675 size_t count, loff_t *ppos)
677 struct video_device *v = video_devdata(file);
678 struct qcam_device *qcam=(struct qcam_device *)v;
679 int len;
681 mutex_lock(&qcam->lock);
682 parport_claim_or_block(qcam->pdev);
683 /* Probably should have a semaphore against multiple users */
684 len = qc_capture(qcam, buf,count);
685 parport_release(qcam->pdev);
686 mutex_unlock(&qcam->lock);
687 return len;
690 static int qcam_exclusive_open(struct file *file)
692 struct video_device *dev = video_devdata(file);
693 struct qcam_device *qcam = (struct qcam_device *)dev;
695 return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
698 static int qcam_exclusive_release(struct file *file)
700 struct video_device *dev = video_devdata(file);
701 struct qcam_device *qcam = (struct qcam_device *)dev;
703 clear_bit(0, &qcam->in_use);
704 return 0;
707 /* video device template */
708 static const struct v4l2_file_operations qcam_fops = {
709 .owner = THIS_MODULE,
710 .open = qcam_exclusive_open,
711 .release = qcam_exclusive_release,
712 .ioctl = qcam_ioctl,
713 .read = qcam_read,
716 static struct video_device qcam_template=
718 .name = "Colour QuickCam",
719 .fops = &qcam_fops,
720 .release = video_device_release_empty,
723 /* Initialize the QuickCam driver control structure. */
725 static struct qcam_device *qcam_init(struct parport *port)
727 struct qcam_device *q;
729 q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
730 if(q==NULL)
731 return NULL;
733 q->pport = port;
734 q->pdev = parport_register_device(port, "c-qcam", NULL, NULL,
735 NULL, 0, NULL);
737 q->bidirectional = (q->pport->modes & PARPORT_MODE_TRISTATE)?1:0;
739 if (q->pdev == NULL)
741 printk(KERN_ERR "c-qcam: couldn't register for %s.\n",
742 port->name);
743 kfree(q);
744 return NULL;
747 memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
749 mutex_init(&q->lock);
750 q->width = q->ccd_width = 320;
751 q->height = q->ccd_height = 240;
752 q->mode = QC_MILLIONS | QC_DECIMATION_1;
753 q->contrast = 192;
754 q->brightness = 240;
755 q->whitebal = 128;
756 q->top = 1;
757 q->left = 14;
758 return q;
761 static struct qcam_device *qcams[MAX_CAMS];
762 static unsigned int num_cams;
764 static int init_cqcam(struct parport *port)
766 struct qcam_device *qcam;
768 if (parport[0] != -1)
770 /* The user gave specific instructions */
771 int i, found = 0;
772 for (i = 0; i < MAX_CAMS && parport[i] != -1; i++)
774 if (parport[0] == port->number)
775 found = 1;
777 if (!found)
778 return -ENODEV;
781 if (num_cams == MAX_CAMS)
782 return -ENOSPC;
784 qcam = qcam_init(port);
785 if (qcam==NULL)
786 return -ENODEV;
788 parport_claim_or_block(qcam->pdev);
790 qc_reset(qcam);
792 if (probe && qc_detect(qcam)==0)
794 parport_release(qcam->pdev);
795 parport_unregister_device(qcam->pdev);
796 kfree(qcam);
797 return -ENODEV;
800 qc_setup(qcam);
802 parport_release(qcam->pdev);
804 if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
805 printk(KERN_ERR "Unable to register Colour QuickCam on %s\n",
806 qcam->pport->name);
807 parport_unregister_device(qcam->pdev);
808 kfree(qcam);
809 return -ENODEV;
812 printk(KERN_INFO "video%d: Colour QuickCam found on %s\n",
813 qcam->vdev.num, qcam->pport->name);
815 qcams[num_cams++] = qcam;
817 return 0;
820 static void close_cqcam(struct qcam_device *qcam)
822 video_unregister_device(&qcam->vdev);
823 parport_unregister_device(qcam->pdev);
824 kfree(qcam);
827 static void cq_attach(struct parport *port)
829 init_cqcam(port);
832 static void cq_detach(struct parport *port)
834 /* Write this some day. */
837 static struct parport_driver cqcam_driver = {
838 .name = "cqcam",
839 .attach = cq_attach,
840 .detach = cq_detach,
843 static int __init cqcam_init (void)
845 printk(BANNER "\n");
847 return parport_register_driver(&cqcam_driver);
850 static void __exit cqcam_cleanup (void)
852 unsigned int i;
854 for (i = 0; i < num_cams; i++)
855 close_cqcam(qcams[i]);
857 parport_unregister_driver(&cqcam_driver);
860 MODULE_AUTHOR("Philip Blundell <philb@gnu.org>");
861 MODULE_DESCRIPTION(BANNER);
862 MODULE_LICENSE("GPL");
864 /* FIXME: parport=auto would never have worked, surely? --RR */
865 MODULE_PARM_DESC(parport ,"parport=<auto|n[,n]...> for port detection method\n\
866 probe=<0|1|2> for camera detection method\n\
867 force_rgb=<0|1> for RGB data format (default BGR)");
868 module_param_array(parport, int, NULL, 0);
869 module_param(probe, int, 0);
870 module_param(force_rgb, bool, 0);
871 module_param(video_nr, int, 0);
873 module_init(cqcam_init);
874 module_exit(cqcam_cleanup);