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