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