V4L/DVB (8252): buf-dma-sg.c: avoid clearing memory twice
[linux-2.6] / 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);