V4L/DVB (6944a): Fix Regression VIDIOCGMBUF ioctl hangs on bttv driver
[linux-2.6] / drivers / media / video / bw-qcam.c
1 /*
2  *    QuickCam Driver For Video4Linux.
3  *
4  *      Video4Linux conversion work by Alan Cox.
5  *      Parport compatibility by Phil Blundell.
6  *      Busy loop avoidance by Mark Cooke.
7  *
8  *    Module parameters:
9  *
10  *      maxpoll=<1 - 5000>
11  *
12  *        When polling the QuickCam for a response, busy-wait for a
13  *        maximum of this many loops. The default of 250 gives little
14  *        impact on interactive response.
15  *
16  *        NOTE: If this parameter is set too high, the processor
17  *              will busy wait until this loop times out, and then
18  *              slowly poll for a further 5 seconds before failing
19  *              the transaction. You have been warned.
20  *
21  *      yieldlines=<1 - 250>
22  *
23  *        When acquiring a frame from the camera, the data gathering
24  *        loop will yield back to the scheduler after completing
25  *        this many lines. The default of 4 provides a trade-off
26  *        between increased frame acquisition time and impact on
27  *        interactive response.
28  */
29
30 /* qcam-lib.c -- Library for programming with the Connectix QuickCam.
31  * See the included documentation for usage instructions and details
32  * of the protocol involved. */
33
34
35 /* Version 0.5, August 4, 1996 */
36 /* Version 0.7, August 27, 1996 */
37 /* Version 0.9, November 17, 1996 */
38
39
40 /******************************************************************
41
42 Copyright (C) 1996 by Scott Laird
43
44 Permission is hereby granted, free of charge, to any person obtaining
45 a copy of this software and associated documentation files (the
46 "Software"), to deal in the Software without restriction, including
47 without limitation the rights to use, copy, modify, merge, publish,
48 distribute, sublicense, and/or sell copies of the Software, and to
49 permit persons to whom the Software is furnished to do so, subject to
50 the following conditions:
51
52 The above copyright notice and this permission notice shall be
53 included in all copies or substantial portions of the Software.
54
55 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
56 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
57 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
58 IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
59 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
60 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
61 OTHER DEALINGS IN THE SOFTWARE.
62
63 ******************************************************************/
64
65 #include <linux/module.h>
66 #include <linux/delay.h>
67 #include <linux/errno.h>
68 #include <linux/fs.h>
69 #include <linux/init.h>
70 #include <linux/kernel.h>
71 #include <linux/slab.h>
72 #include <linux/mm.h>
73 #include <linux/parport.h>
74 #include <linux/sched.h>
75 #include <linux/videodev.h>
76 #include <media/v4l2-common.h>
77 #include <linux/mutex.h>
78 #include <asm/uaccess.h>
79
80 #include "bw-qcam.h"
81
82 static unsigned int maxpoll=250;   /* Maximum busy-loop count for qcam I/O */
83 static unsigned int yieldlines=4;  /* Yield after this many during capture */
84 static int video_nr = -1;
85
86 module_param(maxpoll, int, 0);
87 module_param(yieldlines, int, 0);
88 module_param(video_nr, int, 0);
89
90 static inline int read_lpstatus(struct qcam_device *q)
91 {
92         return parport_read_status(q->pport);
93 }
94
95 static inline int read_lpdata(struct qcam_device *q)
96 {
97         return parport_read_data(q->pport);
98 }
99
100 static inline void write_lpdata(struct qcam_device *q, int d)
101 {
102         parport_write_data(q->pport, d);
103 }
104
105 static inline void write_lpcontrol(struct qcam_device *q, int d)
106 {
107         if (d & 0x20) {
108                 /* Set bidirectional mode to reverse (data in) */
109                 parport_data_reverse(q->pport);
110         } else {
111                 /* Set bidirectional mode to forward (data out) */
112                 parport_data_forward(q->pport);
113         }
114
115         /* Now issue the regular port command, but strip out the
116          * direction flag */
117         d &= ~0x20;
118         parport_write_control(q->pport, d);
119 }
120
121 static int qc_waithand(struct qcam_device *q, int val);
122 static int qc_command(struct qcam_device *q, int command);
123 static int qc_readparam(struct qcam_device *q);
124 static int qc_setscanmode(struct qcam_device *q);
125 static int qc_readbytes(struct qcam_device *q, char buffer[]);
126
127 static struct video_device qcam_template;
128
129 static int qc_calibrate(struct qcam_device *q)
130 {
131         /*
132          *      Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
133          *      The white balance is an individiual value for each
134          *      quickcam.
135          */
136
137         int value;
138         int count = 0;
139
140         qc_command(q, 27);      /* AutoAdjustOffset */
141         qc_command(q, 0);       /* Dummy Parameter, ignored by the camera */
142
143         /* GetOffset (33) will read 255 until autocalibration */
144         /* is finished. After that, a value of 1-254 will be */
145         /* returned. */
146
147         do {
148                 qc_command(q, 33);
149                 value = qc_readparam(q);
150                 mdelay(1);
151                 schedule();
152                 count++;
153         } while (value == 0xff && count<2048);
154
155         q->whitebal = value;
156         return value;
157 }
158
159 /* Initialize the QuickCam driver control structure.  This is where
160  * defaults are set for people who don't have a config file.*/
161
162 static struct qcam_device *qcam_init(struct parport *port)
163 {
164         struct qcam_device *q;
165
166         q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
167         if(q==NULL)
168                 return NULL;
169
170         q->pport = port;
171         q->pdev = parport_register_device(port, "bw-qcam", NULL, NULL,
172                                           NULL, 0, NULL);
173         if (q->pdev == NULL)
174         {
175                 printk(KERN_ERR "bw-qcam: couldn't register for %s.\n",
176                        port->name);
177                 kfree(q);
178                 return NULL;
179         }
180
181         memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
182
183         mutex_init(&q->lock);
184
185         q->port_mode = (QC_ANY | QC_NOTSET);
186         q->width = 320;
187         q->height = 240;
188         q->bpp = 4;
189         q->transfer_scale = 2;
190         q->contrast = 192;
191         q->brightness = 180;
192         q->whitebal = 105;
193         q->top = 1;
194         q->left = 14;
195         q->mode = -1;
196         q->status = QC_PARAM_CHANGE;
197         return q;
198 }
199
200
201 /* qc_command is probably a bit of a misnomer -- it's used to send
202  * bytes *to* the camera.  Generally, these bytes are either commands
203  * or arguments to commands, so the name fits, but it still bugs me a
204  * bit.  See the documentation for a list of commands. */
205
206 static int qc_command(struct qcam_device *q, int command)
207 {
208         int n1, n2;
209         int cmd;
210
211         write_lpdata(q, command);
212         write_lpcontrol(q, 6);
213
214         n1 = qc_waithand(q, 1);
215
216         write_lpcontrol(q, 0xe);
217         n2 = qc_waithand(q, 0);
218
219         cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
220         return cmd;
221 }
222
223 static int qc_readparam(struct qcam_device *q)
224 {
225         int n1, n2;
226         int cmd;
227
228         write_lpcontrol(q, 6);
229         n1 = qc_waithand(q, 1);
230
231         write_lpcontrol(q, 0xe);
232         n2 = qc_waithand(q, 0);
233
234         cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
235         return cmd;
236 }
237
238 /* qc_waithand busy-waits for a handshake signal from the QuickCam.
239  * Almost all communication with the camera requires handshaking. */
240
241 static int qc_waithand(struct qcam_device *q, int val)
242 {
243         int status;
244         int runs=0;
245
246         if (val)
247         {
248                 while (!((status = read_lpstatus(q)) & 8))
249                 {
250                         /* 1000 is enough spins on the I/O for all normal
251                            cases, at that point we start to poll slowly
252                            until the camera wakes up. However, we are
253                            busy blocked until the camera responds, so
254                            setting it lower is much better for interactive
255                            response. */
256
257                         if(runs++>maxpoll)
258                         {
259                                 msleep_interruptible(5);
260                         }
261                         if(runs>(maxpoll+1000)) /* 5 seconds */
262                                 return -1;
263                 }
264         }
265         else
266         {
267                 while (((status = read_lpstatus(q)) & 8))
268                 {
269                         /* 1000 is enough spins on the I/O for all normal
270                            cases, at that point we start to poll slowly
271                            until the camera wakes up. However, we are
272                            busy blocked until the camera responds, so
273                            setting it lower is much better for interactive
274                            response. */
275
276                         if(runs++>maxpoll)
277                         {
278                                 msleep_interruptible(5);
279                         }
280                         if(runs++>(maxpoll+1000)) /* 5 seconds */
281                                 return -1;
282                 }
283         }
284
285         return status;
286 }
287
288 /* Waithand2 is used when the qcam is in bidirectional mode, and the
289  * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
290  * (bit 3 of status register).  It also returns the last value read,
291  * since this data is useful. */
292
293 static unsigned int qc_waithand2(struct qcam_device *q, int val)
294 {
295         unsigned int status;
296         int runs=0;
297
298         do
299         {
300                 status = read_lpdata(q);
301                 /* 1000 is enough spins on the I/O for all normal
302                    cases, at that point we start to poll slowly
303                    until the camera wakes up. However, we are
304                    busy blocked until the camera responds, so
305                    setting it lower is much better for interactive
306                    response. */
307
308                 if(runs++>maxpoll)
309                 {
310                         msleep_interruptible(5);
311                 }
312                 if(runs++>(maxpoll+1000)) /* 5 seconds */
313                         return 0;
314         }
315         while ((status & 1) != val);
316
317         return status;
318 }
319
320
321 /* Try to detect a QuickCam.  It appears to flash the upper 4 bits of
322    the status register at 5-10 Hz.  This is only used in the autoprobe
323    code.  Be aware that this isn't the way Connectix detects the
324    camera (they send a reset and try to handshake), but this should be
325    almost completely safe, while their method screws up my printer if
326    I plug it in before the camera. */
327
328 static int qc_detect(struct qcam_device *q)
329 {
330         int reg, lastreg;
331         int count = 0;
332         int i;
333
334         lastreg = reg = read_lpstatus(q) & 0xf0;
335
336         for (i = 0; i < 500; i++)
337         {
338                 reg = read_lpstatus(q) & 0xf0;
339                 if (reg != lastreg)
340                         count++;
341                 lastreg = reg;
342                 mdelay(2);
343         }
344
345
346 #if 0
347         /* Force camera detection during testing. Sometimes the camera
348            won't be flashing these bits. Possibly unloading the module
349            in the middle of a grab? Or some timeout condition?
350            I've seen this parameter as low as 19 on my 450Mhz box - mpc */
351         printk("Debugging: QCam detection counter <30-200 counts as detected>: %d\n", count);
352         return 1;
353 #endif
354
355         /* Be (even more) liberal in what you accept...  */
356
357 /*      if (count > 30 && count < 200) */
358         if (count > 20 && count < 400) {
359                 return 1;       /* found */
360         } else {
361                 printk(KERN_ERR "No Quickcam found on port %s\n",
362                         q->pport->name);
363                 return 0;       /* not found */
364         }
365 }
366
367
368 /* Reset the QuickCam.  This uses the same sequence the Windows
369  * QuickPic program uses.  Someone with a bi-directional port should
370  * check that bi-directional mode is detected right, and then
371  * implement bi-directional mode in qc_readbyte(). */
372
373 static void qc_reset(struct qcam_device *q)
374 {
375         switch (q->port_mode & QC_FORCE_MASK)
376         {
377                 case QC_FORCE_UNIDIR:
378                         q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
379                         break;
380
381                 case QC_FORCE_BIDIR:
382                         q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
383                         break;
384
385                 case QC_ANY:
386                         write_lpcontrol(q, 0x20);
387                         write_lpdata(q, 0x75);
388
389                         if (read_lpdata(q) != 0x75) {
390                                 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
391                         } else {
392                                 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
393                         }
394                         break;
395         }
396
397         write_lpcontrol(q, 0xb);
398         udelay(250);
399         write_lpcontrol(q, 0xe);
400         qc_setscanmode(q);              /* in case port_mode changed */
401 }
402
403
404 /* Decide which scan mode to use.  There's no real requirement that
405  * the scanmode match the resolution in q->height and q-> width -- the
406  * camera takes the picture at the resolution specified in the
407  * "scanmode" and then returns the image at the resolution specified
408  * with the resolution commands.  If the scan is bigger than the
409  * requested resolution, the upper-left hand corner of the scan is
410  * returned.  If the scan is smaller, then the rest of the image
411  * returned contains garbage. */
412
413 static int qc_setscanmode(struct qcam_device *q)
414 {
415         int old_mode = q->mode;
416
417         switch (q->transfer_scale)
418         {
419                 case 1:
420                         q->mode = 0;
421                         break;
422                 case 2:
423                         q->mode = 4;
424                         break;
425                 case 4:
426                         q->mode = 8;
427                         break;
428         }
429
430         switch (q->bpp)
431         {
432                 case 4:
433                         break;
434                 case 6:
435                         q->mode += 2;
436                         break;
437         }
438
439         switch (q->port_mode & QC_MODE_MASK)
440         {
441                 case QC_BIDIR:
442                         q->mode += 1;
443                         break;
444                 case QC_NOTSET:
445                 case QC_UNIDIR:
446                         break;
447         }
448
449         if (q->mode != old_mode)
450                 q->status |= QC_PARAM_CHANGE;
451
452         return 0;
453 }
454
455
456 /* Reset the QuickCam and program for brightness, contrast,
457  * white-balance, and resolution. */
458
459 static void qc_set(struct qcam_device *q)
460 {
461         int val;
462         int val2;
463
464         qc_reset(q);
465
466         /* Set the brightness.  Yes, this is repetitive, but it works.
467          * Shorter versions seem to fail subtly.  Feel free to try :-). */
468         /* I think the problem was in qc_command, not here -- bls */
469
470         qc_command(q, 0xb);
471         qc_command(q, q->brightness);
472
473         val = q->height / q->transfer_scale;
474         qc_command(q, 0x11);
475         qc_command(q, val);
476         if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
477                 /* The normal "transfers per line" calculation doesn't seem to work
478                    as expected here (and yet it works fine in qc_scan).  No idea
479                    why this case is the odd man out.  Fortunately, Laird's original
480                    working version gives me a good way to guess at working values.
481                    -- bls */
482                 val = q->width;
483                 val2 = q->transfer_scale * 4;
484         } else {
485                 val = q->width * q->bpp;
486                 val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
487                     q->transfer_scale;
488         }
489         val = (val + val2 - 1) / val2;
490         qc_command(q, 0x13);
491         qc_command(q, val);
492
493         /* Setting top and left -- bls */
494         qc_command(q, 0xd);
495         qc_command(q, q->top);
496         qc_command(q, 0xf);
497         qc_command(q, q->left / 2);
498
499         qc_command(q, 0x19);
500         qc_command(q, q->contrast);
501         qc_command(q, 0x1f);
502         qc_command(q, q->whitebal);
503
504         /* Clear flag that we must update the grabbing parameters on the camera
505            before we grab the next frame */
506         q->status &= (~QC_PARAM_CHANGE);
507 }
508
509 /* Qc_readbytes reads some bytes from the QC and puts them in
510    the supplied buffer.  It returns the number of bytes read,
511    or -1 on error. */
512
513 static inline int qc_readbytes(struct qcam_device *q, char buffer[])
514 {
515         int ret=1;
516         unsigned int hi, lo;
517         unsigned int hi2, lo2;
518         static int state = 0;
519
520         if (buffer == NULL)
521         {
522                 state = 0;
523                 return 0;
524         }
525
526         switch (q->port_mode & QC_MODE_MASK)
527         {
528                 case QC_BIDIR:          /* Bi-directional Port */
529                         write_lpcontrol(q, 0x26);
530                         lo = (qc_waithand2(q, 1) >> 1);
531                         hi = (read_lpstatus(q) >> 3) & 0x1f;
532                         write_lpcontrol(q, 0x2e);
533                         lo2 = (qc_waithand2(q, 0) >> 1);
534                         hi2 = (read_lpstatus(q) >> 3) & 0x1f;
535                         switch (q->bpp)
536                         {
537                                 case 4:
538                                         buffer[0] = lo & 0xf;
539                                         buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
540                                         buffer[2] = (hi & 0x1e) >> 1;
541                                         buffer[3] = lo2 & 0xf;
542                                         buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
543                                         buffer[5] = (hi2 & 0x1e) >> 1;
544                                         ret = 6;
545                                         break;
546                                 case 6:
547                                         buffer[0] = lo & 0x3f;
548                                         buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
549                                         buffer[2] = lo2 & 0x3f;
550                                         buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
551                                         ret = 4;
552                                         break;
553                         }
554                         break;
555
556                 case QC_UNIDIR: /* Unidirectional Port */
557                         write_lpcontrol(q, 6);
558                         lo = (qc_waithand(q, 1) & 0xf0) >> 4;
559                         write_lpcontrol(q, 0xe);
560                         hi = (qc_waithand(q, 0) & 0xf0) >> 4;
561
562                         switch (q->bpp)
563                         {
564                                 case 4:
565                                         buffer[0] = lo;
566                                         buffer[1] = hi;
567                                         ret = 2;
568                                         break;
569                                 case 6:
570                                         switch (state)
571                                         {
572                                                 case 0:
573                                                         buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
574                                                         q->saved_bits = (hi & 3) << 4;
575                                                         state = 1;
576                                                         ret = 1;
577                                                         break;
578                                                 case 1:
579                                                         buffer[0] = lo | q->saved_bits;
580                                                         q->saved_bits = hi << 2;
581                                                         state = 2;
582                                                         ret = 1;
583                                                         break;
584                                                 case 2:
585                                                         buffer[0] = ((lo & 0xc) >> 2) | q->saved_bits;
586                                                         buffer[1] = ((lo & 3) << 4) | hi;
587                                                         state = 0;
588                                                         ret = 2;
589                                                         break;
590                                         }
591                                         break;
592                         }
593                         break;
594         }
595         return ret;
596 }
597
598 /* requests a scan from the camera.  It sends the correct instructions
599  * to the camera and then reads back the correct number of bytes.  In
600  * previous versions of this routine the return structure contained
601  * the raw output from the camera, and there was a 'qc_convertscan'
602  * function that converted that to a useful format.  In version 0.3 I
603  * rolled qc_convertscan into qc_scan and now I only return the
604  * converted scan.  The format is just an one-dimensional array of
605  * characters, one for each pixel, with 0=black up to n=white, where
606  * n=2^(bit depth)-1.  Ask me for more details if you don't understand
607  * this. */
608
609 static long qc_capture(struct qcam_device * q, char __user *buf, unsigned long len)
610 {
611         int i, j, k, yield;
612         int bytes;
613         int linestotrans, transperline;
614         int divisor;
615         int pixels_per_line;
616         int pixels_read = 0;
617         int got=0;
618         char buffer[6];
619         int  shift=8-q->bpp;
620         char invert;
621
622         if (q->mode == -1)
623                 return -ENXIO;
624
625         qc_command(q, 0x7);
626         qc_command(q, q->mode);
627
628         if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
629         {
630                 write_lpcontrol(q, 0x2e);       /* turn port around */
631                 write_lpcontrol(q, 0x26);
632                 (void) qc_waithand(q, 1);
633                 write_lpcontrol(q, 0x2e);
634                 (void) qc_waithand(q, 0);
635         }
636
637         /* strange -- should be 15:63 below, but 4bpp is odd */
638         invert = (q->bpp == 4) ? 16 : 63;
639
640         linestotrans = q->height / q->transfer_scale;
641         pixels_per_line = q->width / q->transfer_scale;
642         transperline = q->width * q->bpp;
643         divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
644             q->transfer_scale;
645         transperline = (transperline + divisor - 1) / divisor;
646
647         for (i = 0, yield = yieldlines; i < linestotrans; i++)
648         {
649                 for (pixels_read = j = 0; j < transperline; j++)
650                 {
651                         bytes = qc_readbytes(q, buffer);
652                         for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++)
653                         {
654                                 int o;
655                                 if (buffer[k] == 0 && invert == 16)
656                                 {
657                                         /* 4bpp is odd (again) -- inverter is 16, not 15, but output
658                                            must be 0-15 -- bls */
659                                         buffer[k] = 16;
660                                 }
661                                 o=i*pixels_per_line + pixels_read + k;
662                                 if(o<len)
663                                 {
664                                         got++;
665                                         put_user((invert - buffer[k])<<shift, buf+o);
666                                 }
667                         }
668                         pixels_read += bytes;
669                 }
670                 (void) qc_readbytes(q, NULL);   /* reset state machine */
671
672                 /* Grabbing an entire frame from the quickcam is a lengthy
673                    process. We don't (usually) want to busy-block the
674                    processor for the entire frame. yieldlines is a module
675                    parameter. If we yield every line, the minimum frame
676                    time will be 240 / 200 = 1.2 seconds. The compile-time
677                    default is to yield every 4 lines. */
678                 if (i >= yield) {
679                         msleep_interruptible(5);
680                         yield = i + yieldlines;
681                 }
682         }
683
684         if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR)
685         {
686                 write_lpcontrol(q, 2);
687                 write_lpcontrol(q, 6);
688                 udelay(3);
689                 write_lpcontrol(q, 0xe);
690         }
691         if(got<len)
692                 return got;
693         return len;
694 }
695
696 /*
697  *      Video4linux interfacing
698  */
699
700 static int qcam_do_ioctl(struct inode *inode, struct file *file,
701                          unsigned int cmd, void *arg)
702 {
703         struct video_device *dev = video_devdata(file);
704         struct qcam_device *qcam=(struct qcam_device *)dev;
705
706         switch(cmd)
707         {
708                 case VIDIOCGCAP:
709                 {
710                         struct video_capability *b = arg;
711                         strcpy(b->name, "Quickcam");
712                         b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES|VID_TYPE_MONOCHROME;
713                         b->channels = 1;
714                         b->audios = 0;
715                         b->maxwidth = 320;
716                         b->maxheight = 240;
717                         b->minwidth = 80;
718                         b->minheight = 60;
719                         return 0;
720                 }
721                 case VIDIOCGCHAN:
722                 {
723                         struct video_channel *v = arg;
724                         if(v->channel!=0)
725                                 return -EINVAL;
726                         v->flags=0;
727                         v->tuners=0;
728                         /* Good question.. its composite or SVHS so.. */
729                         v->type = VIDEO_TYPE_CAMERA;
730                         strcpy(v->name, "Camera");
731                         return 0;
732                 }
733                 case VIDIOCSCHAN:
734                 {
735                         struct video_channel *v = arg;
736                         if(v->channel!=0)
737                                 return -EINVAL;
738                         return 0;
739                 }
740                 case VIDIOCGTUNER:
741                 {
742                         struct video_tuner *v = arg;
743                         if(v->tuner)
744                                 return -EINVAL;
745                         strcpy(v->name, "Format");
746                         v->rangelow=0;
747                         v->rangehigh=0;
748                         v->flags= 0;
749                         v->mode = VIDEO_MODE_AUTO;
750                         return 0;
751                 }
752                 case VIDIOCSTUNER:
753                 {
754                         struct video_tuner *v = arg;
755                         if(v->tuner)
756                                 return -EINVAL;
757                         if(v->mode!=VIDEO_MODE_AUTO)
758                                 return -EINVAL;
759                         return 0;
760                 }
761                 case VIDIOCGPICT:
762                 {
763                         struct video_picture *p = arg;
764                         p->colour=0x8000;
765                         p->hue=0x8000;
766                         p->brightness=qcam->brightness<<8;
767                         p->contrast=qcam->contrast<<8;
768                         p->whiteness=qcam->whitebal<<8;
769                         p->depth=qcam->bpp;
770                         p->palette=VIDEO_PALETTE_GREY;
771                         return 0;
772                 }
773                 case VIDIOCSPICT:
774                 {
775                         struct video_picture *p = arg;
776                         if(p->palette!=VIDEO_PALETTE_GREY)
777                                 return -EINVAL;
778                         if(p->depth!=4 && p->depth!=6)
779                                 return -EINVAL;
780
781                         /*
782                          *      Now load the camera.
783                          */
784
785                         qcam->brightness = p->brightness>>8;
786                         qcam->contrast = p->contrast>>8;
787                         qcam->whitebal = p->whiteness>>8;
788                         qcam->bpp = p->depth;
789
790                         mutex_lock(&qcam->lock);
791                         qc_setscanmode(qcam);
792                         mutex_unlock(&qcam->lock);
793                         qcam->status |= QC_PARAM_CHANGE;
794
795                         return 0;
796                 }
797                 case VIDIOCSWIN:
798                 {
799                         struct video_window *vw = arg;
800                         if(vw->flags)
801                                 return -EINVAL;
802                         if(vw->clipcount)
803                                 return -EINVAL;
804                         if(vw->height<60||vw->height>240)
805                                 return -EINVAL;
806                         if(vw->width<80||vw->width>320)
807                                 return -EINVAL;
808
809                         qcam->width = 320;
810                         qcam->height = 240;
811                         qcam->transfer_scale = 4;
812
813                         if(vw->width>=160 && vw->height>=120)
814                         {
815                                 qcam->transfer_scale = 2;
816                         }
817                         if(vw->width>=320 && vw->height>=240)
818                         {
819                                 qcam->width = 320;
820                                 qcam->height = 240;
821                                 qcam->transfer_scale = 1;
822                         }
823                         mutex_lock(&qcam->lock);
824                         qc_setscanmode(qcam);
825                         mutex_unlock(&qcam->lock);
826
827                         /* We must update the camera before we grab. We could
828                            just have changed the grab size */
829                         qcam->status |= QC_PARAM_CHANGE;
830
831                         /* Ok we figured out what to use from our wide choice */
832                         return 0;
833                 }
834                 case VIDIOCGWIN:
835                 {
836                         struct video_window *vw = arg;
837                         memset(vw, 0, sizeof(*vw));
838                         vw->width=qcam->width/qcam->transfer_scale;
839                         vw->height=qcam->height/qcam->transfer_scale;
840                         return 0;
841                 }
842                 case VIDIOCKEY:
843                         return 0;
844                 case VIDIOCCAPTURE:
845                 case VIDIOCGFBUF:
846                 case VIDIOCSFBUF:
847                 case VIDIOCGFREQ:
848                 case VIDIOCSFREQ:
849                 case VIDIOCGAUDIO:
850                 case VIDIOCSAUDIO:
851                         return -EINVAL;
852                 default:
853                         return -ENOIOCTLCMD;
854         }
855         return 0;
856 }
857
858 static int qcam_ioctl(struct inode *inode, struct file *file,
859                      unsigned int cmd, unsigned long arg)
860 {
861         return video_usercopy(inode, file, cmd, arg, qcam_do_ioctl);
862 }
863
864 static ssize_t qcam_read(struct file *file, char __user *buf,
865                          size_t count, loff_t *ppos)
866 {
867         struct video_device *v = video_devdata(file);
868         struct qcam_device *qcam=(struct qcam_device *)v;
869         int len;
870         parport_claim_or_block(qcam->pdev);
871
872         mutex_lock(&qcam->lock);
873
874         qc_reset(qcam);
875
876         /* Update the camera parameters if we need to */
877         if (qcam->status & QC_PARAM_CHANGE)
878                 qc_set(qcam);
879
880         len=qc_capture(qcam, buf,count);
881
882         mutex_unlock(&qcam->lock);
883
884         parport_release(qcam->pdev);
885         return len;
886 }
887
888 static const struct file_operations qcam_fops = {
889         .owner          = THIS_MODULE,
890         .open           = video_exclusive_open,
891         .release        = video_exclusive_release,
892         .ioctl          = qcam_ioctl,
893         .compat_ioctl   = v4l_compat_ioctl32,
894         .read           = qcam_read,
895         .llseek         = no_llseek,
896 };
897 static struct video_device qcam_template=
898 {
899         .owner          = THIS_MODULE,
900         .name           = "Connectix Quickcam",
901         .type           = VID_TYPE_CAPTURE,
902         .fops           = &qcam_fops,
903 };
904
905 #define MAX_CAMS 4
906 static struct qcam_device *qcams[MAX_CAMS];
907 static unsigned int num_cams = 0;
908
909 static int init_bwqcam(struct parport *port)
910 {
911         struct qcam_device *qcam;
912
913         if (num_cams == MAX_CAMS)
914         {
915                 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
916                 return -ENOSPC;
917         }
918
919         qcam=qcam_init(port);
920         if(qcam==NULL)
921                 return -ENODEV;
922
923         parport_claim_or_block(qcam->pdev);
924
925         qc_reset(qcam);
926
927         if(qc_detect(qcam)==0)
928         {
929                 parport_release(qcam->pdev);
930                 parport_unregister_device(qcam->pdev);
931                 kfree(qcam);
932                 return -ENODEV;
933         }
934         qc_calibrate(qcam);
935
936         parport_release(qcam->pdev);
937
938         printk(KERN_INFO "Connectix Quickcam on %s\n", qcam->pport->name);
939
940         if(video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr)==-1)
941         {
942                 parport_unregister_device(qcam->pdev);
943                 kfree(qcam);
944                 return -ENODEV;
945         }
946
947         qcams[num_cams++] = qcam;
948
949         return 0;
950 }
951
952 static void close_bwqcam(struct qcam_device *qcam)
953 {
954         video_unregister_device(&qcam->vdev);
955         parport_unregister_device(qcam->pdev);
956         kfree(qcam);
957 }
958
959 /* The parport parameter controls which parports will be scanned.
960  * Scanning all parports causes some printers to print a garbage page.
961  *       -- March 14, 1999  Billy Donahue <billy@escape.com> */
962 #ifdef MODULE
963 static char *parport[MAX_CAMS] = { NULL, };
964 module_param_array(parport, charp, NULL, 0);
965 #endif
966
967 static int accept_bwqcam(struct parport *port)
968 {
969 #ifdef MODULE
970         int n;
971
972         if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
973                 /* user gave parport parameters */
974                 for(n=0; parport[n] && n<MAX_CAMS; n++){
975                         char *ep;
976                         unsigned long r;
977                         r = simple_strtoul(parport[n], &ep, 0);
978                         if (ep == parport[n]) {
979                                 printk(KERN_ERR
980                                         "bw-qcam: bad port specifier \"%s\"\n",
981                                         parport[n]);
982                                 continue;
983                         }
984                         if (r == port->number)
985                                 return 1;
986                 }
987                 return 0;
988         }
989 #endif
990         return 1;
991 }
992
993 static void bwqcam_attach(struct parport *port)
994 {
995         if (accept_bwqcam(port))
996                 init_bwqcam(port);
997 }
998
999 static void bwqcam_detach(struct parport *port)
1000 {
1001         int i;
1002         for (i = 0; i < num_cams; i++) {
1003                 struct qcam_device *qcam = qcams[i];
1004                 if (qcam && qcam->pdev->port == port) {
1005                         qcams[i] = NULL;
1006                         close_bwqcam(qcam);
1007                 }
1008         }
1009 }
1010
1011 static struct parport_driver bwqcam_driver = {
1012         .name   = "bw-qcam",
1013         .attach = bwqcam_attach,
1014         .detach = bwqcam_detach,
1015 };
1016
1017 static void __exit exit_bw_qcams(void)
1018 {
1019         parport_unregister_driver(&bwqcam_driver);
1020 }
1021
1022 static int __init init_bw_qcams(void)
1023 {
1024 #ifdef MODULE
1025         /* Do some sanity checks on the module parameters. */
1026         if (maxpoll > 5000) {
1027                 printk("Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1028                 maxpoll = 5000;
1029         }
1030
1031         if (yieldlines < 1) {
1032                 printk("Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1033                 yieldlines = 1;
1034         }
1035 #endif
1036         return parport_register_driver(&bwqcam_driver);
1037 }
1038
1039 module_init(init_bw_qcams);
1040 module_exit(exit_bw_qcams);
1041
1042 MODULE_LICENSE("GPL");