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