V4L/DVB (9503): v4l: remove inode argument from video_usercopy
[linux-2.6.git] / 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 <media/v4l2-ioctl.h>
39 #include <linux/mutex.h>
40 #include <linux/jiffies.h>
41
42 #include <asm/uaccess.h>
43
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;
56 };
57
58 /* cameras maximum */
59 #define MAX_CAMS 4
60
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) */
65
66 /* The three possible decimations */
67 #define QC_DECIMATION_1         0
68 #define QC_DECIMATION_2         2
69 #define QC_DECIMATION_4         4
70
71 #define BANNER "Colour QuickCam for Video4Linux v0.05"
72
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;
77
78 static inline void qcam_set_ack(struct qcam_device *qcam, unsigned int i)
79 {
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);
83 }
84
85 static inline unsigned int qcam_ready1(struct qcam_device *qcam)
86 {
87         return (parport_read_status(qcam->pport) & 0x8)?1:0;
88 }
89
90 static inline unsigned int qcam_ready2(struct qcam_device *qcam)
91 {
92         return (parport_read_data(qcam->pport) & 0x1)?1:0;
93 }
94
95 static unsigned int qcam_await_ready1(struct qcam_device *qcam,
96                                              int value)
97 {
98         unsigned long oldjiffies = jiffies;
99         unsigned int i;
100
101         for (oldjiffies = jiffies;
102              time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
103                 if (qcam_ready1(qcam) == value)
104                         return 0;
105
106         /* If the camera didn't respond within 1/25 second, poll slowly
107            for a while. */
108         for (i = 0; i < 50; i++)
109         {
110                 if (qcam_ready1(qcam) == value)
111                         return 0;
112                 msleep_interruptible(100);
113         }
114
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;
120 }
121
122 static unsigned int qcam_await_ready2(struct qcam_device *qcam, int value)
123 {
124         unsigned long oldjiffies = jiffies;
125         unsigned int i;
126
127         for (oldjiffies = jiffies;
128              time_before(jiffies, oldjiffies + msecs_to_jiffies(40)); )
129                 if (qcam_ready2(qcam) == value)
130                         return 0;
131
132         /* If the camera didn't respond within 1/25 second, poll slowly
133            for a while. */
134         for (i = 0; i < 50; i++)
135         {
136                 if (qcam_ready2(qcam) == value)
137                         return 0;
138                 msleep_interruptible(100);
139         }
140
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;
147 }
148
149 static int qcam_read_data(struct qcam_device *qcam)
150 {
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;
159 }
160
161 static int qcam_write_data(struct qcam_device *qcam, unsigned int data)
162 {
163         unsigned int idata;
164         parport_write_data(qcam->pport, data);
165         idata = qcam_read_data(qcam);
166         if (data != idata)
167         {
168                 printk(KERN_WARNING "cqcam: sent %x but received %x\n", data,
169                        idata);
170                 return 1;
171         }
172         return 0;
173 }
174
175 static inline int qcam_set(struct qcam_device *qcam, unsigned int cmd, unsigned int data)
176 {
177         if (qcam_write_data(qcam, cmd))
178                 return -1;
179         if (qcam_write_data(qcam, data))
180                 return -1;
181         return 0;
182 }
183
184 static inline int qcam_get(struct qcam_device *qcam, unsigned int cmd)
185 {
186         if (qcam_write_data(qcam, cmd))
187                 return -1;
188         return qcam_read_data(qcam);
189 }
190
191 static int qc_detect(struct qcam_device *qcam)
192 {
193         unsigned int stat, ostat, i, count = 0;
194
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;
206         }
207
208         if (probe < 2)
209                 return 0;
210
211         parport_write_control(qcam->pport, 0xc);
212
213         /* look for a heartbeat */
214         ostat = stat = parport_read_status(qcam->pport);
215         for (i=0; i<250; i++)
216         {
217                 mdelay(1);
218                 stat = parport_read_status(qcam->pport);
219                 if (ostat != stat)
220                 {
221                         if (++count >= 3) return 1;
222                         ostat = stat;
223                 }
224         }
225
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;
233
234         ostat = stat = parport_read_status(qcam->pport);
235         for (i=0; i<250; i++)
236         {
237                 mdelay(1);
238                 stat = parport_read_status(qcam->pport);
239                 if (ostat != stat)
240                 {
241                         if (++count >= 3) return 1;
242                         ostat = stat;
243                 }
244         }
245
246         /* no (or flatline) camera, give up */
247         return 0;
248 }
249
250 static void qc_reset(struct qcam_device *qcam)
251 {
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);
257 }
258
259 /* Reset the QuickCam and program for brightness, contrast,
260  * white-balance, and resolution. */
261
262 static void qc_setup(struct qcam_device *q)
263 {
264         qc_reset(q);
265
266         /* Set the brightness.  */
267         qcam_set(q, 11, q->brightness);
268
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);
273
274         /* Set top and left.  */
275         qcam_set(q, 0xd, q->top);
276         qcam_set(q, 0xf, q->left);
277
278         /* Set contrast and white balance.  */
279         qcam_set(q, 0x19, q->contrast);
280         qcam_set(q, 0x1f, q->whitebal);
281
282         /* Set the speed.  */
283         qcam_set(q, 45, 2);
284 }
285
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.  */
289
290 static unsigned int qcam_read_bytes(struct qcam_device *q, unsigned char *buf, unsigned int nbytes)
291 {
292         unsigned int bytes = 0;
293
294         qcam_set_ack(q, 0);
295         if (q->bidirectional)
296         {
297                 /* It's a bidirectional port */
298                 while (bytes < nbytes)
299                 {
300                         unsigned int lo1, hi1, lo2, hi2;
301                         unsigned char r, g, b;
302
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;
322                         }
323                 }
324         }
325         else
326         {
327                 /* It's a unidirectional port */
328                 int i = 0, n = bytes;
329                 unsigned char rgb[3];
330
331                 while (bytes < nbytes)
332                 {
333                         unsigned int hi, lo;
334
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];
353                                 }
354                         }
355                 }
356                 if (i) {
357                         i = 0;
358                         goto get_fragment;
359                 }
360         }
361         return bytes;
362 }
363
364 #define BUFSZ   150
365
366 static long qc_capture(struct qcam_device *q, char __user *buf, unsigned long len)
367 {
368         unsigned lines, pixelsperline, bitsperxfer;
369         unsigned int is_bi_dir = q->bidirectional;
370         size_t wantlen, outptr = 0;
371         char tmpbuf[BUFSZ];
372
373         if (!access_ok(VERIFY_WRITE, buf, len))
374                 return -EFAULT;
375
376         /* Wait for camera to become ready */
377         for (;;)
378         {
379                 int i = qcam_get(q, 41);
380                 if (i == -1) {
381                         qc_setup(q);
382                         return -EIO;
383                 }
384                 if ((i & 0x80) == 0)
385                         break;
386                 else
387                         schedule();
388         }
389
390         if (qcam_set(q, 7, (q->mode | (is_bi_dir?1:0)) + 1))
391                 return -EIO;
392
393         lines = q->height;
394         pixelsperline = q->width;
395         bitsperxfer = (is_bi_dir) ? 24 : 8;
396
397         if (is_bi_dir)
398         {
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;
406                 }
407                 qcam_set_ack(q, 1);
408                 if (qcam_await_ready1(q, 0)) {
409                         qc_setup(q);
410                         return -EIO;
411                 }
412         }
413
414         wantlen = lines * pixelsperline * 24 / 8;
415
416         while (wantlen)
417         {
418                 size_t t, s;
419                 s = (wantlen > BUFSZ)?BUFSZ:wantlen;
420                 t = qcam_read_bytes(q, tmpbuf, s);
421                 if (outptr < len)
422                 {
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;
428                 }
429                 wantlen -= t;
430                 if (t < s)
431                         break;
432                 cond_resched();
433         }
434
435         len = outptr;
436
437         if (wantlen)
438         {
439                 printk("qcam: short read.\n");
440                 if (is_bi_dir)
441                         parport_data_forward(q->pport);
442                 qc_setup(q);
443                 return len;
444         }
445
446         if (is_bi_dir)
447         {
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");
459                 }
460                 qcam_set_ack(q, 0);
461                 if (qcam_await_ready1(q, 1))
462                 {
463                         printk("qcam: no ack after EOF\n");
464                         parport_data_forward(q->pport);
465                         qc_setup(q);
466                         return len;
467                 }
468                 parport_data_forward(q->pport);
469                 mdelay(3);
470                 qcam_set_ack(q, 1);
471                 if (qcam_await_ready1(q, 0))
472                 {
473                         printk("qcam: no ack to port turnaround\n");
474                         qc_setup(q);
475                         return len;
476                 }
477         }
478         else
479         {
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");
492                 }
493         }
494
495         qcam_write_data(q, 0);
496         return len;
497 }
498
499 /*
500  *      Video4linux interfacing
501  */
502
503 static int qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
504 {
505         struct video_device *dev = video_devdata(file);
506         struct qcam_device *qcam=(struct qcam_device *)dev;
507
508         switch(cmd)
509         {
510                 case VIDIOCGCAP:
511                 {
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;
522                 }
523                 case VIDIOCGCHAN:
524                 {
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;
534                 }
535                 case VIDIOCSCHAN:
536                 {
537                         struct video_channel *v = arg;
538                         if(v->channel!=0)
539                                 return -EINVAL;
540                         return 0;
541                 }
542                 case VIDIOCGTUNER:
543                 {
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;
551                 }
552                 case VIDIOCSTUNER:
553                 {
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;
560                 }
561                 case VIDIOCGPICT:
562                 {
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;
572                 }
573                 case VIDIOCSPICT:
574                 {
575                         struct video_picture *p = arg;
576
577                         /*
578                          *      Sanity check args
579                          */
580                         if (p->depth != 24 || p->palette != VIDEO_PALETTE_RGB24)
581                                 return -EINVAL;
582
583                         /*
584                          *      Now load the camera.
585                          */
586                         qcam->brightness = p->brightness>>8;
587                         qcam->contrast = p->contrast>>8;
588                         qcam->whitebal = p->whiteness>>8;
589
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;
596                 }
597                 case VIDIOCSWIN:
598                 {
599                         struct video_window *vw = arg;
600
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;
609
610                         qcam->width = 80;
611                         qcam->height = 60;
612                         qcam->mode = QC_DECIMATION_4;
613
614                         if(vw->width>=160 && vw->height>=120)
615                         {
616                                 qcam->width = 160;
617                                 qcam->height = 120;
618                                 qcam->mode = QC_DECIMATION_2;
619                         }
620                         if(vw->width>=320 && vw->height>=240)
621                         {
622                                 qcam->width = 320;
623                                 qcam->height = 240;
624                                 qcam->mode = QC_DECIMATION_1;
625                         }
626                         qcam->mode |= QC_MILLIONS;
627 #if 0
628                         if(vw->width>=640 && vw->height>=480)
629                         {
630                                 qcam->width = 640;
631                                 qcam->height = 480;
632                                 qcam->mode = QC_BILLIONS | QC_DECIMATION_1;
633                         }
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;
643                 }
644                 case VIDIOCGWIN:
645                 {
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;
651                 }
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;
664         }
665         return 0;
666 }
667
668 static int qcam_ioctl(struct inode *inode, struct file *file,
669                       unsigned int cmd, unsigned long arg)
670 {
671         return video_usercopy(file, cmd, arg, qcam_do_ioctl);
672 }
673
674 static ssize_t qcam_read(struct file *file, char __user *buf,
675                          size_t count, loff_t *ppos)
676 {
677         struct video_device *v = video_devdata(file);
678         struct qcam_device *qcam=(struct qcam_device *)v;
679         int len;
680
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;
688 }
689
690 static int qcam_exclusive_open(struct inode *inode, struct file *file)
691 {
692         struct video_device *dev = video_devdata(file);
693         struct qcam_device *qcam = (struct qcam_device *)dev;
694
695         return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
696 }
697
698 static int qcam_exclusive_release(struct inode *inode, struct file *file)
699 {
700         struct video_device *dev = video_devdata(file);
701         struct qcam_device *qcam = (struct qcam_device *)dev;
702
703         clear_bit(0, &qcam->in_use);
704         return 0;
705 }
706
707 /* video device template */
708 static const struct file_operations qcam_fops = {
709         .owner          = THIS_MODULE,
710         .open           = qcam_exclusive_open,
711         .release        = qcam_exclusive_release,
712         .ioctl          = qcam_ioctl,
713 #ifdef CONFIG_COMPAT
714         .compat_ioctl   = v4l_compat_ioctl32,
715 #endif
716         .read           = qcam_read,
717         .llseek         = no_llseek,
718 };
719
720 static struct video_device qcam_template=
721 {
722         .name           = "Colour QuickCam",
723         .fops           = &qcam_fops,
724         .release        = video_device_release_empty,
725 };
726
727 /* Initialize the QuickCam driver control structure. */
728
729 static struct qcam_device *qcam_init(struct parport *port)
730 {
731         struct qcam_device *q;
732
733         q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
734         if(q==NULL)
735                 return NULL;
736
737         q->pport = port;
738         q->pdev = parport_register_device(port, "c-qcam", NULL, NULL,
739                                           NULL, 0, NULL);
740
741         q->bidirectional = (q->pport->modes & PARPORT_MODE_TRISTATE)?1:0;
742
743         if (q->pdev == NULL)
744         {
745                 printk(KERN_ERR "c-qcam: couldn't register for %s.\n",
746                        port->name);
747                 kfree(q);
748                 return NULL;
749         }
750
751         memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
752
753         mutex_init(&q->lock);
754         q->width = q->ccd_width = 320;
755         q->height = q->ccd_height = 240;
756         q->mode = QC_MILLIONS | QC_DECIMATION_1;
757         q->contrast = 192;
758         q->brightness = 240;
759         q->whitebal = 128;
760         q->top = 1;
761         q->left = 14;
762         return q;
763 }
764
765 static struct qcam_device *qcams[MAX_CAMS];
766 static unsigned int num_cams;
767
768 static int init_cqcam(struct parport *port)
769 {
770         struct qcam_device *qcam;
771
772         if (parport[0] != -1)
773         {
774                 /* The user gave specific instructions */
775                 int i, found = 0;
776                 for (i = 0; i < MAX_CAMS && parport[i] != -1; i++)
777                 {
778                         if (parport[0] == port->number)
779                                 found = 1;
780                 }
781                 if (!found)
782                         return -ENODEV;
783         }
784
785         if (num_cams == MAX_CAMS)
786                 return -ENOSPC;
787
788         qcam = qcam_init(port);
789         if (qcam==NULL)
790                 return -ENODEV;
791
792         parport_claim_or_block(qcam->pdev);
793
794         qc_reset(qcam);
795
796         if (probe && qc_detect(qcam)==0)
797         {
798                 parport_release(qcam->pdev);
799                 parport_unregister_device(qcam->pdev);
800                 kfree(qcam);
801                 return -ENODEV;
802         }
803
804         qc_setup(qcam);
805
806         parport_release(qcam->pdev);
807
808         if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
809                 printk(KERN_ERR "Unable to register Colour QuickCam on %s\n",
810                        qcam->pport->name);
811                 parport_unregister_device(qcam->pdev);
812                 kfree(qcam);
813                 return -ENODEV;
814         }
815
816         printk(KERN_INFO "video%d: Colour QuickCam found on %s\n",
817                qcam->vdev.num, qcam->pport->name);
818
819         qcams[num_cams++] = qcam;
820
821         return 0;
822 }
823
824 static void close_cqcam(struct qcam_device *qcam)
825 {
826         video_unregister_device(&qcam->vdev);
827         parport_unregister_device(qcam->pdev);
828         kfree(qcam);
829 }
830
831 static void cq_attach(struct parport *port)
832 {
833         init_cqcam(port);
834 }
835
836 static void cq_detach(struct parport *port)
837 {
838         /* Write this some day. */
839 }
840
841 static struct parport_driver cqcam_driver = {
842         .name = "cqcam",
843         .attach = cq_attach,
844         .detach = cq_detach,
845 };
846
847 static int __init cqcam_init (void)
848 {
849         printk(BANNER "\n");
850
851         return parport_register_driver(&cqcam_driver);
852 }
853
854 static void __exit cqcam_cleanup (void)
855 {
856         unsigned int i;
857
858         for (i = 0; i < num_cams; i++)
859                 close_cqcam(qcams[i]);
860
861         parport_unregister_driver(&cqcam_driver);
862 }
863
864 MODULE_AUTHOR("Philip Blundell <philb@gnu.org>");
865 MODULE_DESCRIPTION(BANNER);
866 MODULE_LICENSE("GPL");
867
868 /* FIXME: parport=auto would never have worked, surely? --RR */
869 MODULE_PARM_DESC(parport ,"parport=<auto|n[,n]...> for port detection method\n\
870 probe=<0|1|2> for camera detection method\n\
871 force_rgb=<0|1> for RGB data format (default BGR)");
872 module_param_array(parport, int, NULL, 0);
873 module_param(probe, int, 0);
874 module_param(force_rgb, bool, 0);
875 module_param(video_nr, int, 0);
876
877 module_init(cqcam_init);
878 module_exit(cqcam_cleanup);