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 int 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 mutex_lock(&qcam->lock);
678 parport_claim_or_block(qcam->pdev);
679
680 qc_reset(qcam);
681
682 /* Update the camera parameters if we need to */
683 if (qcam->status & QC_PARAM_CHANGE)
684 qc_set(qcam);
685
686 len = qc_capture(qcam, vbuf, size);
687
688 parport_release(qcam->pdev);
689 mutex_unlock(&qcam->lock);
690 if (len != size)
691 vb->state = VB2_BUF_STATE_ERROR;
692 vb2_set_plane_payload(vb, 0, len);
693 return 0;
694 }
695
696 static struct vb2_ops qcam_video_qops = {
697 .queue_setup = queue_setup,
698 .buf_queue = buffer_queue,
699 .buf_finish = buffer_finish,
700 .wait_prepare = vb2_ops_wait_prepare,
701 .wait_finish = vb2_ops_wait_finish,
702 };
703
704 /*
705 * Video4linux interfacing
706 */
707
qcam_querycap(struct file * file,void * priv,struct v4l2_capability * vcap)708 static int qcam_querycap(struct file *file, void *priv,
709 struct v4l2_capability *vcap)
710 {
711 struct qcam *qcam = video_drvdata(file);
712
713 strlcpy(vcap->driver, qcam->v4l2_dev.name, sizeof(vcap->driver));
714 strlcpy(vcap->card, "Connectix B&W Quickcam", sizeof(vcap->card));
715 strlcpy(vcap->bus_info, qcam->pport->name, sizeof(vcap->bus_info));
716 vcap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
717 V4L2_CAP_STREAMING;
718 vcap->capabilities = vcap->device_caps | V4L2_CAP_DEVICE_CAPS;
719 return 0;
720 }
721
qcam_enum_input(struct file * file,void * fh,struct v4l2_input * vin)722 static int qcam_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
723 {
724 if (vin->index > 0)
725 return -EINVAL;
726 strlcpy(vin->name, "Camera", sizeof(vin->name));
727 vin->type = V4L2_INPUT_TYPE_CAMERA;
728 vin->audioset = 0;
729 vin->tuner = 0;
730 vin->std = 0;
731 vin->status = 0;
732 return 0;
733 }
734
qcam_g_input(struct file * file,void * fh,unsigned int * inp)735 static int qcam_g_input(struct file *file, void *fh, unsigned int *inp)
736 {
737 *inp = 0;
738 return 0;
739 }
740
qcam_s_input(struct file * file,void * fh,unsigned int inp)741 static int qcam_s_input(struct file *file, void *fh, unsigned int inp)
742 {
743 return (inp > 0) ? -EINVAL : 0;
744 }
745
qcam_g_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)746 static int qcam_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
747 {
748 struct qcam *qcam = video_drvdata(file);
749 struct v4l2_pix_format *pix = &fmt->fmt.pix;
750
751 pix->width = qcam->width / qcam->transfer_scale;
752 pix->height = qcam->height / qcam->transfer_scale;
753 pix->pixelformat = (qcam->bpp == 4) ? V4L2_PIX_FMT_Y4 : V4L2_PIX_FMT_Y6;
754 pix->field = V4L2_FIELD_NONE;
755 pix->bytesperline = pix->width;
756 pix->sizeimage = pix->width * pix->height;
757 /* Just a guess */
758 pix->colorspace = V4L2_COLORSPACE_SRGB;
759 pix->priv = 0;
760 return 0;
761 }
762
qcam_try_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)763 static int qcam_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
764 {
765 struct v4l2_pix_format *pix = &fmt->fmt.pix;
766
767 if (pix->height <= 60 || pix->width <= 80) {
768 pix->height = 60;
769 pix->width = 80;
770 } else if (pix->height <= 120 || pix->width <= 160) {
771 pix->height = 120;
772 pix->width = 160;
773 } else {
774 pix->height = 240;
775 pix->width = 320;
776 }
777 if (pix->pixelformat != V4L2_PIX_FMT_Y4 &&
778 pix->pixelformat != V4L2_PIX_FMT_Y6)
779 pix->pixelformat = V4L2_PIX_FMT_Y4;
780 pix->field = V4L2_FIELD_NONE;
781 pix->bytesperline = pix->width;
782 pix->sizeimage = pix->width * pix->height;
783 /* Just a guess */
784 pix->colorspace = V4L2_COLORSPACE_SRGB;
785 pix->priv = 0;
786 return 0;
787 }
788
qcam_s_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * fmt)789 static int qcam_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
790 {
791 struct qcam *qcam = video_drvdata(file);
792 struct v4l2_pix_format *pix = &fmt->fmt.pix;
793 int ret = qcam_try_fmt_vid_cap(file, fh, fmt);
794
795 if (ret)
796 return ret;
797 if (vb2_is_busy(&qcam->vb_vidq))
798 return -EBUSY;
799 qcam->width = 320;
800 qcam->height = 240;
801 if (pix->height == 60)
802 qcam->transfer_scale = 4;
803 else if (pix->height == 120)
804 qcam->transfer_scale = 2;
805 else
806 qcam->transfer_scale = 1;
807 if (pix->pixelformat == V4L2_PIX_FMT_Y6)
808 qcam->bpp = 6;
809 else
810 qcam->bpp = 4;
811
812 qc_setscanmode(qcam);
813 /* We must update the camera before we grab. We could
814 just have changed the grab size */
815 qcam->status |= QC_PARAM_CHANGE;
816 return 0;
817 }
818
qcam_enum_fmt_vid_cap(struct file * file,void * fh,struct v4l2_fmtdesc * fmt)819 static int qcam_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
820 {
821 static struct v4l2_fmtdesc formats[] = {
822 { 0, 0, 0,
823 "4-Bit Monochrome", V4L2_PIX_FMT_Y4,
824 { 0, 0, 0, 0 }
825 },
826 { 1, 0, 0,
827 "6-Bit Monochrome", V4L2_PIX_FMT_Y6,
828 { 0, 0, 0, 0 }
829 },
830 };
831 enum v4l2_buf_type type = fmt->type;
832
833 if (fmt->index > 1)
834 return -EINVAL;
835
836 *fmt = formats[fmt->index];
837 fmt->type = type;
838 return 0;
839 }
840
qcam_enum_framesizes(struct file * file,void * fh,struct v4l2_frmsizeenum * fsize)841 static int qcam_enum_framesizes(struct file *file, void *fh,
842 struct v4l2_frmsizeenum *fsize)
843 {
844 static const struct v4l2_frmsize_discrete sizes[] = {
845 { 80, 60 },
846 { 160, 120 },
847 { 320, 240 },
848 };
849
850 if (fsize->index > 2)
851 return -EINVAL;
852 if (fsize->pixel_format != V4L2_PIX_FMT_Y4 &&
853 fsize->pixel_format != V4L2_PIX_FMT_Y6)
854 return -EINVAL;
855 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
856 fsize->discrete = sizes[fsize->index];
857 return 0;
858 }
859
qcam_s_ctrl(struct v4l2_ctrl * ctrl)860 static int qcam_s_ctrl(struct v4l2_ctrl *ctrl)
861 {
862 struct qcam *qcam =
863 container_of(ctrl->handler, struct qcam, hdl);
864 int ret = 0;
865
866 switch (ctrl->id) {
867 case V4L2_CID_BRIGHTNESS:
868 qcam->brightness = ctrl->val;
869 break;
870 case V4L2_CID_CONTRAST:
871 qcam->contrast = ctrl->val;
872 break;
873 case V4L2_CID_GAMMA:
874 qcam->whitebal = ctrl->val;
875 break;
876 default:
877 ret = -EINVAL;
878 break;
879 }
880 if (ret == 0)
881 qcam->status |= QC_PARAM_CHANGE;
882 return ret;
883 }
884
885 static const struct v4l2_file_operations qcam_fops = {
886 .owner = THIS_MODULE,
887 .open = v4l2_fh_open,
888 .release = vb2_fop_release,
889 .poll = vb2_fop_poll,
890 .unlocked_ioctl = video_ioctl2,
891 .read = vb2_fop_read,
892 .mmap = vb2_fop_mmap,
893 };
894
895 static const struct v4l2_ioctl_ops qcam_ioctl_ops = {
896 .vidioc_querycap = qcam_querycap,
897 .vidioc_g_input = qcam_g_input,
898 .vidioc_s_input = qcam_s_input,
899 .vidioc_enum_input = qcam_enum_input,
900 .vidioc_enum_fmt_vid_cap = qcam_enum_fmt_vid_cap,
901 .vidioc_enum_framesizes = qcam_enum_framesizes,
902 .vidioc_g_fmt_vid_cap = qcam_g_fmt_vid_cap,
903 .vidioc_s_fmt_vid_cap = qcam_s_fmt_vid_cap,
904 .vidioc_try_fmt_vid_cap = qcam_try_fmt_vid_cap,
905 .vidioc_reqbufs = vb2_ioctl_reqbufs,
906 .vidioc_create_bufs = vb2_ioctl_create_bufs,
907 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
908 .vidioc_querybuf = vb2_ioctl_querybuf,
909 .vidioc_qbuf = vb2_ioctl_qbuf,
910 .vidioc_dqbuf = vb2_ioctl_dqbuf,
911 .vidioc_streamon = vb2_ioctl_streamon,
912 .vidioc_streamoff = vb2_ioctl_streamoff,
913 .vidioc_log_status = v4l2_ctrl_log_status,
914 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
915 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
916 };
917
918 static const struct v4l2_ctrl_ops qcam_ctrl_ops = {
919 .s_ctrl = qcam_s_ctrl,
920 };
921
922 /* Initialize the QuickCam driver control structure. This is where
923 * defaults are set for people who don't have a config file.*/
924
qcam_init(struct parport * port)925 static struct qcam *qcam_init(struct parport *port)
926 {
927 struct qcam *qcam;
928 struct v4l2_device *v4l2_dev;
929 struct vb2_queue *q;
930 int err;
931
932 qcam = kzalloc(sizeof(struct qcam), GFP_KERNEL);
933 if (qcam == NULL)
934 return NULL;
935
936 v4l2_dev = &qcam->v4l2_dev;
937 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "bw-qcam%d", num_cams);
938
939 if (v4l2_device_register(port->dev, v4l2_dev) < 0) {
940 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
941 kfree(qcam);
942 return NULL;
943 }
944
945 v4l2_ctrl_handler_init(&qcam->hdl, 3);
946 v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
947 V4L2_CID_BRIGHTNESS, 0, 255, 1, 180);
948 v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
949 V4L2_CID_CONTRAST, 0, 255, 1, 192);
950 v4l2_ctrl_new_std(&qcam->hdl, &qcam_ctrl_ops,
951 V4L2_CID_GAMMA, 0, 255, 1, 105);
952 if (qcam->hdl.error) {
953 v4l2_err(v4l2_dev, "couldn't register controls\n");
954 goto exit;
955 }
956
957 mutex_init(&qcam->lock);
958 mutex_init(&qcam->queue_lock);
959
960 /* initialize queue */
961 q = &qcam->vb_vidq;
962 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
963 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
964 q->drv_priv = qcam;
965 q->ops = &qcam_video_qops;
966 q->mem_ops = &vb2_vmalloc_memops;
967 err = vb2_queue_init(q);
968 if (err < 0) {
969 v4l2_err(v4l2_dev, "couldn't init vb2_queue for %s.\n", port->name);
970 goto exit;
971 }
972 qcam->vdev.queue = q;
973 qcam->vdev.queue->lock = &qcam->queue_lock;
974
975 qcam->pport = port;
976 qcam->pdev = parport_register_device(port, v4l2_dev->name, NULL, NULL,
977 NULL, 0, NULL);
978 if (qcam->pdev == NULL) {
979 v4l2_err(v4l2_dev, "couldn't register for %s.\n", port->name);
980 goto exit;
981 }
982
983 strlcpy(qcam->vdev.name, "Connectix QuickCam", sizeof(qcam->vdev.name));
984 qcam->vdev.v4l2_dev = v4l2_dev;
985 qcam->vdev.ctrl_handler = &qcam->hdl;
986 qcam->vdev.fops = &qcam_fops;
987 qcam->vdev.lock = &qcam->lock;
988 qcam->vdev.ioctl_ops = &qcam_ioctl_ops;
989 set_bit(V4L2_FL_USE_FH_PRIO, &qcam->vdev.flags);
990 qcam->vdev.release = video_device_release_empty;
991 video_set_drvdata(&qcam->vdev, qcam);
992
993 qcam->port_mode = (QC_ANY | QC_NOTSET);
994 qcam->width = 320;
995 qcam->height = 240;
996 qcam->bpp = 4;
997 qcam->transfer_scale = 2;
998 qcam->contrast = 192;
999 qcam->brightness = 180;
1000 qcam->whitebal = 105;
1001 qcam->top = 1;
1002 qcam->left = 14;
1003 qcam->mode = -1;
1004 qcam->status = QC_PARAM_CHANGE;
1005 return qcam;
1006
1007 exit:
1008 v4l2_ctrl_handler_free(&qcam->hdl);
1009 kfree(qcam);
1010 return NULL;
1011 }
1012
qc_calibrate(struct qcam * q)1013 static int qc_calibrate(struct qcam *q)
1014 {
1015 /*
1016 * Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
1017 * The white balance is an individual value for each
1018 * quickcam.
1019 */
1020
1021 int value;
1022 int count = 0;
1023
1024 qc_command(q, 27); /* AutoAdjustOffset */
1025 qc_command(q, 0); /* Dummy Parameter, ignored by the camera */
1026
1027 /* GetOffset (33) will read 255 until autocalibration */
1028 /* is finished. After that, a value of 1-254 will be */
1029 /* returned. */
1030
1031 do {
1032 qc_command(q, 33);
1033 value = qc_readparam(q);
1034 mdelay(1);
1035 schedule();
1036 count++;
1037 } while (value == 0xff && count < 2048);
1038
1039 q->whitebal = value;
1040 return value;
1041 }
1042
init_bwqcam(struct parport * port)1043 static int init_bwqcam(struct parport *port)
1044 {
1045 struct qcam *qcam;
1046
1047 if (num_cams == MAX_CAMS) {
1048 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
1049 return -ENOSPC;
1050 }
1051
1052 qcam = qcam_init(port);
1053 if (qcam == NULL)
1054 return -ENODEV;
1055
1056 parport_claim_or_block(qcam->pdev);
1057
1058 qc_reset(qcam);
1059
1060 if (qc_detect(qcam) == 0) {
1061 parport_release(qcam->pdev);
1062 parport_unregister_device(qcam->pdev);
1063 kfree(qcam);
1064 return -ENODEV;
1065 }
1066 qc_calibrate(qcam);
1067 v4l2_ctrl_handler_setup(&qcam->hdl);
1068
1069 parport_release(qcam->pdev);
1070
1071 v4l2_info(&qcam->v4l2_dev, "Connectix Quickcam on %s\n", qcam->pport->name);
1072
1073 if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1074 parport_unregister_device(qcam->pdev);
1075 kfree(qcam);
1076 return -ENODEV;
1077 }
1078
1079 qcams[num_cams++] = qcam;
1080
1081 return 0;
1082 }
1083
close_bwqcam(struct qcam * qcam)1084 static void close_bwqcam(struct qcam *qcam)
1085 {
1086 video_unregister_device(&qcam->vdev);
1087 v4l2_ctrl_handler_free(&qcam->hdl);
1088 parport_unregister_device(qcam->pdev);
1089 kfree(qcam);
1090 }
1091
1092 /* The parport parameter controls which parports will be scanned.
1093 * Scanning all parports causes some printers to print a garbage page.
1094 * -- March 14, 1999 Billy Donahue <billy@escape.com> */
1095 #ifdef MODULE
1096 static char *parport[MAX_CAMS] = { NULL, };
1097 module_param_array(parport, charp, NULL, 0);
1098 #endif
1099
accept_bwqcam(struct parport * port)1100 static int accept_bwqcam(struct parport *port)
1101 {
1102 #ifdef MODULE
1103 int n;
1104
1105 if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
1106 /* user gave parport parameters */
1107 for (n = 0; n < MAX_CAMS && parport[n]; n++) {
1108 char *ep;
1109 unsigned long r;
1110 r = simple_strtoul(parport[n], &ep, 0);
1111 if (ep == parport[n]) {
1112 printk(KERN_ERR
1113 "bw-qcam: bad port specifier \"%s\"\n",
1114 parport[n]);
1115 continue;
1116 }
1117 if (r == port->number)
1118 return 1;
1119 }
1120 return 0;
1121 }
1122 #endif
1123 return 1;
1124 }
1125
bwqcam_attach(struct parport * port)1126 static void bwqcam_attach(struct parport *port)
1127 {
1128 if (accept_bwqcam(port))
1129 init_bwqcam(port);
1130 }
1131
bwqcam_detach(struct parport * port)1132 static void bwqcam_detach(struct parport *port)
1133 {
1134 int i;
1135 for (i = 0; i < num_cams; i++) {
1136 struct qcam *qcam = qcams[i];
1137 if (qcam && qcam->pdev->port == port) {
1138 qcams[i] = NULL;
1139 close_bwqcam(qcam);
1140 }
1141 }
1142 }
1143
1144 static struct parport_driver bwqcam_driver = {
1145 .name = "bw-qcam",
1146 .attach = bwqcam_attach,
1147 .detach = bwqcam_detach,
1148 };
1149
exit_bw_qcams(void)1150 static void __exit exit_bw_qcams(void)
1151 {
1152 parport_unregister_driver(&bwqcam_driver);
1153 }
1154
init_bw_qcams(void)1155 static int __init init_bw_qcams(void)
1156 {
1157 #ifdef MODULE
1158 /* Do some sanity checks on the module parameters. */
1159 if (maxpoll > 5000) {
1160 printk(KERN_INFO "Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1161 maxpoll = 5000;
1162 }
1163
1164 if (yieldlines < 1) {
1165 printk(KERN_INFO "Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1166 yieldlines = 1;
1167 }
1168 #endif
1169 return parport_register_driver(&bwqcam_driver);
1170 }
1171
1172 module_init(init_bw_qcams);
1173 module_exit(exit_bw_qcams);
1174
1175 MODULE_LICENSE("GPL");
1176 MODULE_VERSION("0.0.3");
1177