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
read_lpstatus(struct qcam_device * q)96 static inline int read_lpstatus(struct qcam_device *q)
97 {
98 return parport_read_status(q->pport);
99 }
100
read_lpdata(struct qcam_device * q)101 static inline int read_lpdata(struct qcam_device *q)
102 {
103 return parport_read_data(q->pport);
104 }
105
write_lpdata(struct qcam_device * q,int d)106 static inline void write_lpdata(struct qcam_device *q, int d)
107 {
108 parport_write_data(q->pport, d);
109 }
110
write_lpcontrol(struct qcam_device * q,int d)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
qc_calibrate(struct qcam_device * q)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
qcam_init(struct parport * port)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
qc_command(struct qcam_device * q,int command)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
qc_readparam(struct qcam_device * q)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
qc_waithand(struct qcam_device * q,int val)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
qc_waithand2(struct qcam_device * q,int val)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
qc_detect(struct qcam_device * q)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
qc_reset(struct qcam_device * q)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
qc_setscanmode(struct qcam_device * q)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
qc_set(struct qcam_device * q)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 = DIV_ROUND_UP(val, 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
qc_readbytes(struct qcam_device * q,char buffer[])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
qc_capture(struct qcam_device * q,char __user * buf,unsigned long len)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 = DIV_ROUND_UP(transperline, 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
qcam_do_ioctl(struct file * file,unsigned int cmd,void * arg)709 static long qcam_do_ioctl(struct file *file, unsigned int cmd, void *arg)
710 {
711 struct video_device *dev = video_devdata(file);
712 struct qcam_device *qcam=(struct qcam_device *)dev;
713
714 switch(cmd)
715 {
716 case VIDIOCGCAP:
717 {
718 struct video_capability *b = arg;
719 strcpy(b->name, "Quickcam");
720 b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES|VID_TYPE_MONOCHROME;
721 b->channels = 1;
722 b->audios = 0;
723 b->maxwidth = 320;
724 b->maxheight = 240;
725 b->minwidth = 80;
726 b->minheight = 60;
727 return 0;
728 }
729 case VIDIOCGCHAN:
730 {
731 struct video_channel *v = arg;
732 if(v->channel!=0)
733 return -EINVAL;
734 v->flags=0;
735 v->tuners=0;
736 /* Good question.. its composite or SVHS so.. */
737 v->type = VIDEO_TYPE_CAMERA;
738 strcpy(v->name, "Camera");
739 return 0;
740 }
741 case VIDIOCSCHAN:
742 {
743 struct video_channel *v = arg;
744 if(v->channel!=0)
745 return -EINVAL;
746 return 0;
747 }
748 case VIDIOCGTUNER:
749 {
750 struct video_tuner *v = arg;
751 if(v->tuner)
752 return -EINVAL;
753 strcpy(v->name, "Format");
754 v->rangelow=0;
755 v->rangehigh=0;
756 v->flags= 0;
757 v->mode = VIDEO_MODE_AUTO;
758 return 0;
759 }
760 case VIDIOCSTUNER:
761 {
762 struct video_tuner *v = arg;
763 if(v->tuner)
764 return -EINVAL;
765 if(v->mode!=VIDEO_MODE_AUTO)
766 return -EINVAL;
767 return 0;
768 }
769 case VIDIOCGPICT:
770 {
771 struct video_picture *p = arg;
772 p->colour=0x8000;
773 p->hue=0x8000;
774 p->brightness=qcam->brightness<<8;
775 p->contrast=qcam->contrast<<8;
776 p->whiteness=qcam->whitebal<<8;
777 p->depth=qcam->bpp;
778 p->palette=VIDEO_PALETTE_GREY;
779 return 0;
780 }
781 case VIDIOCSPICT:
782 {
783 struct video_picture *p = arg;
784 if(p->palette!=VIDEO_PALETTE_GREY)
785 return -EINVAL;
786 if(p->depth!=4 && p->depth!=6)
787 return -EINVAL;
788
789 /*
790 * Now load the camera.
791 */
792
793 qcam->brightness = p->brightness>>8;
794 qcam->contrast = p->contrast>>8;
795 qcam->whitebal = p->whiteness>>8;
796 qcam->bpp = p->depth;
797
798 mutex_lock(&qcam->lock);
799 qc_setscanmode(qcam);
800 mutex_unlock(&qcam->lock);
801 qcam->status |= QC_PARAM_CHANGE;
802
803 return 0;
804 }
805 case VIDIOCSWIN:
806 {
807 struct video_window *vw = arg;
808 if(vw->flags)
809 return -EINVAL;
810 if(vw->clipcount)
811 return -EINVAL;
812 if(vw->height<60||vw->height>240)
813 return -EINVAL;
814 if(vw->width<80||vw->width>320)
815 return -EINVAL;
816
817 qcam->width = 320;
818 qcam->height = 240;
819 qcam->transfer_scale = 4;
820
821 if(vw->width>=160 && vw->height>=120)
822 {
823 qcam->transfer_scale = 2;
824 }
825 if(vw->width>=320 && vw->height>=240)
826 {
827 qcam->width = 320;
828 qcam->height = 240;
829 qcam->transfer_scale = 1;
830 }
831 mutex_lock(&qcam->lock);
832 qc_setscanmode(qcam);
833 mutex_unlock(&qcam->lock);
834
835 /* We must update the camera before we grab. We could
836 just have changed the grab size */
837 qcam->status |= QC_PARAM_CHANGE;
838
839 /* Ok we figured out what to use from our wide choice */
840 return 0;
841 }
842 case VIDIOCGWIN:
843 {
844 struct video_window *vw = arg;
845 memset(vw, 0, sizeof(*vw));
846 vw->width=qcam->width/qcam->transfer_scale;
847 vw->height=qcam->height/qcam->transfer_scale;
848 return 0;
849 }
850 case VIDIOCKEY:
851 return 0;
852 case VIDIOCCAPTURE:
853 case VIDIOCGFBUF:
854 case VIDIOCSFBUF:
855 case VIDIOCGFREQ:
856 case VIDIOCSFREQ:
857 case VIDIOCGAUDIO:
858 case VIDIOCSAUDIO:
859 return -EINVAL;
860 default:
861 return -ENOIOCTLCMD;
862 }
863 return 0;
864 }
865
qcam_ioctl(struct file * file,unsigned int cmd,unsigned long arg)866 static long qcam_ioctl(struct file *file,
867 unsigned int cmd, unsigned long arg)
868 {
869 return video_usercopy(file, cmd, arg, qcam_do_ioctl);
870 }
871
qcam_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)872 static ssize_t qcam_read(struct file *file, char __user *buf,
873 size_t count, loff_t *ppos)
874 {
875 struct video_device *v = video_devdata(file);
876 struct qcam_device *qcam=(struct qcam_device *)v;
877 int len;
878 parport_claim_or_block(qcam->pdev);
879
880 mutex_lock(&qcam->lock);
881
882 qc_reset(qcam);
883
884 /* Update the camera parameters if we need to */
885 if (qcam->status & QC_PARAM_CHANGE)
886 qc_set(qcam);
887
888 len=qc_capture(qcam, buf,count);
889
890 mutex_unlock(&qcam->lock);
891
892 parport_release(qcam->pdev);
893 return len;
894 }
895
qcam_exclusive_open(struct file * file)896 static int qcam_exclusive_open(struct file *file)
897 {
898 struct video_device *dev = video_devdata(file);
899 struct qcam_device *qcam = (struct qcam_device *)dev;
900
901 return test_and_set_bit(0, &qcam->in_use) ? -EBUSY : 0;
902 }
903
qcam_exclusive_release(struct file * file)904 static int qcam_exclusive_release(struct file *file)
905 {
906 struct video_device *dev = video_devdata(file);
907 struct qcam_device *qcam = (struct qcam_device *)dev;
908
909 clear_bit(0, &qcam->in_use);
910 return 0;
911 }
912
913 static const struct v4l2_file_operations qcam_fops = {
914 .owner = THIS_MODULE,
915 .open = qcam_exclusive_open,
916 .release = qcam_exclusive_release,
917 .ioctl = qcam_ioctl,
918 .read = qcam_read,
919 };
920 static struct video_device qcam_template=
921 {
922 .name = "Connectix Quickcam",
923 .fops = &qcam_fops,
924 .release = video_device_release_empty,
925 };
926
927 #define MAX_CAMS 4
928 static struct qcam_device *qcams[MAX_CAMS];
929 static unsigned int num_cams;
930
init_bwqcam(struct parport * port)931 static int init_bwqcam(struct parport *port)
932 {
933 struct qcam_device *qcam;
934
935 if (num_cams == MAX_CAMS)
936 {
937 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
938 return -ENOSPC;
939 }
940
941 qcam=qcam_init(port);
942 if(qcam==NULL)
943 return -ENODEV;
944
945 parport_claim_or_block(qcam->pdev);
946
947 qc_reset(qcam);
948
949 if(qc_detect(qcam)==0)
950 {
951 parport_release(qcam->pdev);
952 parport_unregister_device(qcam->pdev);
953 kfree(qcam);
954 return -ENODEV;
955 }
956 qc_calibrate(qcam);
957
958 parport_release(qcam->pdev);
959
960 printk(KERN_INFO "Connectix Quickcam on %s\n", qcam->pport->name);
961
962 if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
963 parport_unregister_device(qcam->pdev);
964 kfree(qcam);
965 return -ENODEV;
966 }
967
968 qcams[num_cams++] = qcam;
969
970 return 0;
971 }
972
close_bwqcam(struct qcam_device * qcam)973 static void close_bwqcam(struct qcam_device *qcam)
974 {
975 video_unregister_device(&qcam->vdev);
976 parport_unregister_device(qcam->pdev);
977 kfree(qcam);
978 }
979
980 /* The parport parameter controls which parports will be scanned.
981 * Scanning all parports causes some printers to print a garbage page.
982 * -- March 14, 1999 Billy Donahue <billy@escape.com> */
983 #ifdef MODULE
984 static char *parport[MAX_CAMS] = { NULL, };
985 module_param_array(parport, charp, NULL, 0);
986 #endif
987
accept_bwqcam(struct parport * port)988 static int accept_bwqcam(struct parport *port)
989 {
990 #ifdef MODULE
991 int n;
992
993 if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
994 /* user gave parport parameters */
995 for(n=0; parport[n] && n<MAX_CAMS; n++){
996 char *ep;
997 unsigned long r;
998 r = simple_strtoul(parport[n], &ep, 0);
999 if (ep == parport[n]) {
1000 printk(KERN_ERR
1001 "bw-qcam: bad port specifier \"%s\"\n",
1002 parport[n]);
1003 continue;
1004 }
1005 if (r == port->number)
1006 return 1;
1007 }
1008 return 0;
1009 }
1010 #endif
1011 return 1;
1012 }
1013
bwqcam_attach(struct parport * port)1014 static void bwqcam_attach(struct parport *port)
1015 {
1016 if (accept_bwqcam(port))
1017 init_bwqcam(port);
1018 }
1019
bwqcam_detach(struct parport * port)1020 static void bwqcam_detach(struct parport *port)
1021 {
1022 int i;
1023 for (i = 0; i < num_cams; i++) {
1024 struct qcam_device *qcam = qcams[i];
1025 if (qcam && qcam->pdev->port == port) {
1026 qcams[i] = NULL;
1027 close_bwqcam(qcam);
1028 }
1029 }
1030 }
1031
1032 static struct parport_driver bwqcam_driver = {
1033 .name = "bw-qcam",
1034 .attach = bwqcam_attach,
1035 .detach = bwqcam_detach,
1036 };
1037
exit_bw_qcams(void)1038 static void __exit exit_bw_qcams(void)
1039 {
1040 parport_unregister_driver(&bwqcam_driver);
1041 }
1042
init_bw_qcams(void)1043 static int __init init_bw_qcams(void)
1044 {
1045 #ifdef MODULE
1046 /* Do some sanity checks on the module parameters. */
1047 if (maxpoll > 5000) {
1048 printk("Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1049 maxpoll = 5000;
1050 }
1051
1052 if (yieldlines < 1) {
1053 printk("Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1054 yieldlines = 1;
1055 }
1056 #endif
1057 return parport_register_driver(&bwqcam_driver);
1058 }
1059
1060 module_init(init_bw_qcams);
1061 module_exit(exit_bw_qcams);
1062
1063 MODULE_LICENSE("GPL");
1064