PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / media / parport / bw-qcam.c
blobd12bd33f39cb3c7f322a0ef4d2965d1ebfa542c6
1 /*
2 * QuickCam Driver For Video4Linux.
4 * Video4Linux conversion work by Alan Cox.
5 * Parport compatibility by Phil Blundell.
6 * Busy loop avoidance by Mark Cooke.
8 * Module parameters:
10 * maxpoll=<1 - 5000>
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.
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.
21 * yieldlines=<1 - 250>
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.
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. */
35 /* Version 0.5, August 4, 1996 */
36 /* Version 0.7, August 27, 1996 */
37 /* Version 0.9, November 17, 1996 */
40 /******************************************************************
42 Copyright (C) 1996 by Scott Laird
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:
52 The above copyright notice and this permission notice shall be
53 included in all copies or substantial portions of the Software.
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.
63 ******************************************************************/
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>
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
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 */
98 #define QC_MODE_MASK 0x07
99 #define QC_FORCE_MASK 0x70
101 #define MAX_HEIGHT 243
102 #define MAX_WIDTH 336
104 /* Bit fields for status flags */
105 #define QC_PARAM_CHANGE 0x01 /* Camera status change has occurred */
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;
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 */
133 module_param(maxpoll, int, 0);
134 module_param(yieldlines, int, 0);
135 module_param(video_nr, int, 0);
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);
141 #define MAX_CAMS 4
142 static struct qcam *qcams[MAX_CAMS];
143 static unsigned int num_cams;
145 static inline int read_lpstatus(struct qcam *q)
147 return parport_read_status(q->pport);
150 static inline int read_lpdata(struct qcam *q)
152 return parport_read_data(q->pport);
155 static inline void write_lpdata(struct qcam *q, int d)
157 parport_write_data(q->pport, d);
160 static void write_lpcontrol(struct qcam *q, int d)
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);
170 /* Now issue the regular port command, but strip out the
171 * direction flag */
172 d &= ~0x20;
173 parport_write_control(q->pport, d);
177 /* qc_waithand busy-waits for a handshake signal from the QuickCam.
178 * Almost all communication with the camera requires handshaking. */
180 static int qc_waithand(struct qcam *q, int val)
182 int status;
183 int runs = 0;
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. */
194 if (runs++ > maxpoll)
195 msleep_interruptible(5);
196 if (runs > (maxpoll + 1000)) /* 5 seconds */
197 return -1;
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. */
208 if (runs++ > maxpoll)
209 msleep_interruptible(5);
210 if (runs++ > (maxpoll + 1000)) /* 5 seconds */
211 return -1;
215 return status;
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. */
223 static unsigned int qc_waithand2(struct qcam *q, int val)
225 unsigned int status;
226 int runs = 0;
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. */
237 if (runs++ > maxpoll)
238 msleep_interruptible(5);
239 if (runs++ > (maxpoll + 1000)) /* 5 seconds */
240 return 0;
241 } while ((status & 1) != val);
243 return status;
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. */
251 static int qc_command(struct qcam *q, int command)
253 int n1, n2;
254 int cmd;
256 write_lpdata(q, command);
257 write_lpcontrol(q, 6);
259 n1 = qc_waithand(q, 1);
261 write_lpcontrol(q, 0xe);
262 n2 = qc_waithand(q, 0);
264 cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
265 return cmd;
268 static int qc_readparam(struct qcam *q)
270 int n1, n2;
271 int cmd;
273 write_lpcontrol(q, 6);
274 n1 = qc_waithand(q, 1);
276 write_lpcontrol(q, 0xe);
277 n2 = qc_waithand(q, 0);
279 cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
280 return cmd;
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. */
291 static int qc_detect(struct qcam *q)
293 int reg, lastreg;
294 int count = 0;
295 int i;
297 if (force_init)
298 return 1;
300 lastreg = reg = read_lpstatus(q) & 0xf0;
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);
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
320 /* Be (even more) liberal in what you accept... */
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 */
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. */
341 static int qc_setscanmode(struct qcam *q)
343 int old_mode = q->mode;
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;
357 switch (q->bpp) {
358 case 4:
359 break;
360 case 6:
361 q->mode += 2;
362 break;
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;
374 if (q->mode != old_mode)
375 q->status |= QC_PARAM_CHANGE;
377 return 0;
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(). */
386 static void qc_reset(struct qcam *q)
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;
393 case QC_FORCE_BIDIR:
394 q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
395 break;
397 case QC_ANY:
398 write_lpcontrol(q, 0x20);
399 write_lpdata(q, 0x75);
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;
408 write_lpcontrol(q, 0xb);
409 udelay(250);
410 write_lpcontrol(q, 0xe);
411 qc_setscanmode(q); /* in case port_mode changed */
416 /* Reset the QuickCam and program for brightness, contrast,
417 * white-balance, and resolution. */
419 static void qc_set(struct qcam *q)
421 int val;
422 int val2;
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 */
428 qc_command(q, 0xb);
429 qc_command(q, q->brightness);
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;
447 val = DIV_ROUND_UP(val, val2);
448 qc_command(q, 0x13);
449 qc_command(q, val);
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);
457 qc_command(q, 0x19);
458 qc_command(q, q->contrast);
459 qc_command(q, 0x1f);
460 qc_command(q, q->whitebal);
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);
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. */
471 static inline int qc_readbytes(struct qcam *q, char buffer[])
473 int ret = 1;
474 unsigned int hi, lo;
475 unsigned int hi2, lo2;
476 static int state;
478 if (buffer == NULL) {
479 state = 0;
480 return 0;
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;
509 break;
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;
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;
544 break;
546 break;
548 return ret;
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. */
562 static long qc_capture(struct qcam *q, u8 *buf, unsigned long len)
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;
575 if (q->mode == -1)
576 return -ENXIO;
578 qc_command(q, 0x7);
579 qc_command(q, q->mode);
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);
589 /* strange -- should be 15:63 below, but 4bpp is odd */
590 invert = (q->bpp == 4) ? 16 : 63;
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);
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;
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;
616 pixels_read += bytes;
618 qc_readbytes(q, NULL); /* reset state machine */
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;
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);
638 if (got < len)
639 return got;
640 return len;
643 /* ------------------------------------------------------------------
644 Videobuf operations
645 ------------------------------------------------------------------*/
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[])
650 struct qcam *dev = vb2_get_drv_priv(vq);
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;
665 static void buffer_queue(struct vb2_buffer *vb)
667 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
670 static int buffer_finish(struct vb2_buffer *vb)
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;
677 mutex_lock(&qcam->lock);
678 parport_claim_or_block(qcam->pdev);
680 qc_reset(qcam);
682 /* Update the camera parameters if we need to */
683 if (qcam->status & QC_PARAM_CHANGE)
684 qc_set(qcam);
686 len = qc_capture(qcam, vbuf, size);
688 parport_release(qcam->pdev);
689 mutex_unlock(&qcam->lock);
690 v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
691 if (len != size)
692 vb->state = VB2_BUF_STATE_ERROR;
693 vb2_set_plane_payload(vb, 0, len);
694 return 0;
697 static struct vb2_ops qcam_video_qops = {
698 .queue_setup = queue_setup,
699 .buf_queue = buffer_queue,
700 .buf_finish = buffer_finish,
701 .wait_prepare = vb2_ops_wait_prepare,
702 .wait_finish = vb2_ops_wait_finish,
706 * Video4linux interfacing
709 static int qcam_querycap(struct file *file, void *priv,
710 struct v4l2_capability *vcap)
712 struct qcam *qcam = video_drvdata(file);
714 strlcpy(vcap->driver, qcam->v4l2_dev.name, sizeof(vcap->driver));
715 strlcpy(vcap->card, "Connectix B&W Quickcam", sizeof(vcap->card));
716 strlcpy(vcap->bus_info, qcam->pport->name, sizeof(vcap->bus_info));
717 vcap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
718 V4L2_CAP_STREAMING;
719 vcap->capabilities = vcap->device_caps | V4L2_CAP_DEVICE_CAPS;
720 return 0;
723 static int qcam_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
725 if (vin->index > 0)
726 return -EINVAL;
727 strlcpy(vin->name, "Camera", sizeof(vin->name));
728 vin->type = V4L2_INPUT_TYPE_CAMERA;
729 vin->audioset = 0;
730 vin->tuner = 0;
731 vin->std = 0;
732 vin->status = 0;
733 return 0;
736 static int qcam_g_input(struct file *file, void *fh, unsigned int *inp)
738 *inp = 0;
739 return 0;
742 static int qcam_s_input(struct file *file, void *fh, unsigned int inp)
744 return (inp > 0) ? -EINVAL : 0;
747 static int qcam_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
749 struct qcam *qcam = video_drvdata(file);
750 struct v4l2_pix_format *pix = &fmt->fmt.pix;
752 pix->width = qcam->width / qcam->transfer_scale;
753 pix->height = qcam->height / qcam->transfer_scale;
754 pix->pixelformat = (qcam->bpp == 4) ? V4L2_PIX_FMT_Y4 : V4L2_PIX_FMT_Y6;
755 pix->field = V4L2_FIELD_NONE;
756 pix->bytesperline = pix->width;
757 pix->sizeimage = pix->width * pix->height;
758 /* Just a guess */
759 pix->colorspace = V4L2_COLORSPACE_SRGB;
760 pix->priv = 0;
761 return 0;
764 static int qcam_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
766 struct v4l2_pix_format *pix = &fmt->fmt.pix;
768 if (pix->height <= 60 || pix->width <= 80) {
769 pix->height = 60;
770 pix->width = 80;
771 } else if (pix->height <= 120 || pix->width <= 160) {
772 pix->height = 120;
773 pix->width = 160;
774 } else {
775 pix->height = 240;
776 pix->width = 320;
778 if (pix->pixelformat != V4L2_PIX_FMT_Y4 &&
779 pix->pixelformat != V4L2_PIX_FMT_Y6)
780 pix->pixelformat = V4L2_PIX_FMT_Y4;
781 pix->field = V4L2_FIELD_NONE;
782 pix->bytesperline = pix->width;
783 pix->sizeimage = pix->width * pix->height;
784 /* Just a guess */
785 pix->colorspace = V4L2_COLORSPACE_SRGB;
786 pix->priv = 0;
787 return 0;
790 static int qcam_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *fmt)
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);
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;
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;
820 static int qcam_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *fmt)
822 static struct v4l2_fmtdesc formats[] = {
823 { 0, 0, 0,
824 "4-Bit Monochrome", V4L2_PIX_FMT_Y4,
825 { 0, 0, 0, 0 }
827 { 1, 0, 0,
828 "6-Bit Monochrome", V4L2_PIX_FMT_Y6,
829 { 0, 0, 0, 0 }
832 enum v4l2_buf_type type = fmt->type;
834 if (fmt->index > 1)
835 return -EINVAL;
837 *fmt = formats[fmt->index];
838 fmt->type = type;
839 return 0;
842 static int qcam_enum_framesizes(struct file *file, void *fh,
843 struct v4l2_frmsizeenum *fsize)
845 static const struct v4l2_frmsize_discrete sizes[] = {
846 { 80, 60 },
847 { 160, 120 },
848 { 320, 240 },
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;
861 static int qcam_s_ctrl(struct v4l2_ctrl *ctrl)
863 struct qcam *qcam =
864 container_of(ctrl->handler, struct qcam, hdl);
865 int ret = 0;
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;
881 if (ret == 0)
882 qcam->status |= QC_PARAM_CHANGE;
883 return ret;
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,
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,
919 static const struct v4l2_ctrl_ops qcam_ctrl_ops = {
920 .s_ctrl = qcam_s_ctrl,
923 /* Initialize the QuickCam driver control structure. This is where
924 * defaults are set for people who don't have a config file.*/
926 static struct qcam *qcam_init(struct parport *port)
928 struct qcam *qcam;
929 struct v4l2_device *v4l2_dev;
930 struct vb2_queue *q;
931 int err;
933 qcam = kzalloc(sizeof(struct qcam), GFP_KERNEL);
934 if (qcam == NULL)
935 return NULL;
937 v4l2_dev = &qcam->v4l2_dev;
938 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "bw-qcam%d", num_cams);
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;
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;
958 mutex_init(&qcam->lock);
959 mutex_init(&qcam->queue_lock);
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_type = 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;
974 qcam->vdev.queue = q;
975 qcam->vdev.queue->lock = &qcam->queue_lock;
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;
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 set_bit(V4L2_FL_USE_FH_PRIO, &qcam->vdev.flags);
992 qcam->vdev.release = video_device_release_empty;
993 video_set_drvdata(&qcam->vdev, qcam);
995 qcam->port_mode = (QC_ANY | QC_NOTSET);
996 qcam->width = 320;
997 qcam->height = 240;
998 qcam->bpp = 4;
999 qcam->transfer_scale = 2;
1000 qcam->contrast = 192;
1001 qcam->brightness = 180;
1002 qcam->whitebal = 105;
1003 qcam->top = 1;
1004 qcam->left = 14;
1005 qcam->mode = -1;
1006 qcam->status = QC_PARAM_CHANGE;
1007 return qcam;
1009 exit:
1010 v4l2_ctrl_handler_free(&qcam->hdl);
1011 kfree(qcam);
1012 return NULL;
1015 static int qc_calibrate(struct qcam *q)
1018 * Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
1019 * The white balance is an individual value for each
1020 * quickcam.
1023 int value;
1024 int count = 0;
1026 qc_command(q, 27); /* AutoAdjustOffset */
1027 qc_command(q, 0); /* Dummy Parameter, ignored by the camera */
1029 /* GetOffset (33) will read 255 until autocalibration */
1030 /* is finished. After that, a value of 1-254 will be */
1031 /* returned. */
1033 do {
1034 qc_command(q, 33);
1035 value = qc_readparam(q);
1036 mdelay(1);
1037 schedule();
1038 count++;
1039 } while (value == 0xff && count < 2048);
1041 q->whitebal = value;
1042 return value;
1045 static int init_bwqcam(struct parport *port)
1047 struct qcam *qcam;
1049 if (num_cams == MAX_CAMS) {
1050 printk(KERN_ERR "Too many Quickcams (max %d)\n", MAX_CAMS);
1051 return -ENOSPC;
1054 qcam = qcam_init(port);
1055 if (qcam == NULL)
1056 return -ENODEV;
1058 parport_claim_or_block(qcam->pdev);
1060 qc_reset(qcam);
1062 if (qc_detect(qcam) == 0) {
1063 parport_release(qcam->pdev);
1064 parport_unregister_device(qcam->pdev);
1065 kfree(qcam);
1066 return -ENODEV;
1068 qc_calibrate(qcam);
1069 v4l2_ctrl_handler_setup(&qcam->hdl);
1071 parport_release(qcam->pdev);
1073 v4l2_info(&qcam->v4l2_dev, "Connectix Quickcam on %s\n", qcam->pport->name);
1075 if (video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1076 parport_unregister_device(qcam->pdev);
1077 kfree(qcam);
1078 return -ENODEV;
1081 qcams[num_cams++] = qcam;
1083 return 0;
1086 static void close_bwqcam(struct qcam *qcam)
1088 video_unregister_device(&qcam->vdev);
1089 v4l2_ctrl_handler_free(&qcam->hdl);
1090 parport_unregister_device(qcam->pdev);
1091 kfree(qcam);
1094 /* The parport parameter controls which parports will be scanned.
1095 * Scanning all parports causes some printers to print a garbage page.
1096 * -- March 14, 1999 Billy Donahue <billy@escape.com> */
1097 #ifdef MODULE
1098 static char *parport[MAX_CAMS] = { NULL, };
1099 module_param_array(parport, charp, NULL, 0);
1100 #endif
1102 static int accept_bwqcam(struct parport *port)
1104 #ifdef MODULE
1105 int n;
1107 if (parport[0] && strncmp(parport[0], "auto", 4) != 0) {
1108 /* user gave parport parameters */
1109 for (n = 0; n < MAX_CAMS && parport[n]; n++) {
1110 char *ep;
1111 unsigned long r;
1112 r = simple_strtoul(parport[n], &ep, 0);
1113 if (ep == parport[n]) {
1114 printk(KERN_ERR
1115 "bw-qcam: bad port specifier \"%s\"\n",
1116 parport[n]);
1117 continue;
1119 if (r == port->number)
1120 return 1;
1122 return 0;
1124 #endif
1125 return 1;
1128 static void bwqcam_attach(struct parport *port)
1130 if (accept_bwqcam(port))
1131 init_bwqcam(port);
1134 static void bwqcam_detach(struct parport *port)
1136 int i;
1137 for (i = 0; i < num_cams; i++) {
1138 struct qcam *qcam = qcams[i];
1139 if (qcam && qcam->pdev->port == port) {
1140 qcams[i] = NULL;
1141 close_bwqcam(qcam);
1146 static struct parport_driver bwqcam_driver = {
1147 .name = "bw-qcam",
1148 .attach = bwqcam_attach,
1149 .detach = bwqcam_detach,
1152 static void __exit exit_bw_qcams(void)
1154 parport_unregister_driver(&bwqcam_driver);
1157 static int __init init_bw_qcams(void)
1159 #ifdef MODULE
1160 /* Do some sanity checks on the module parameters. */
1161 if (maxpoll > 5000) {
1162 printk(KERN_INFO "Connectix Quickcam max-poll was above 5000. Using 5000.\n");
1163 maxpoll = 5000;
1166 if (yieldlines < 1) {
1167 printk(KERN_INFO "Connectix Quickcam yieldlines was less than 1. Using 1.\n");
1168 yieldlines = 1;
1170 #endif
1171 return parport_register_driver(&bwqcam_driver);
1174 module_init(init_bw_qcams);
1175 module_exit(exit_bw_qcams);
1177 MODULE_LICENSE("GPL");
1178 MODULE_VERSION("0.0.3");