2 * Video4Linux Colour QuickCam driver
3 * Copyright 1997-2000 Philip Blundell <philb@gnu.org>
7 * parport=auto -- probe all parports (default)
8 * parport=0 -- parport0 becomes qcam1
9 * parport=2,0,1 -- parports 2,0,1 are tried in that order
11 * probe=0 -- do no probing, assume camera is present
12 * probe=1 -- use IEEE-1284 autoprobe data only (default)
13 * probe=2 -- probe aggressively for cameras
15 * force_rgb=1 -- force data format to RGB (default is BGR)
17 * The parport parameter controls which parports will be scanned.
18 * Scanning all parports causes some printers to print a garbage page.
19 * -- March 14, 1999 Billy Donahue <billy@escape.com>
21 * Fixed data format to BGR, added force_rgb parameter. Added missing
22 * parport_unregister_driver() on module removal.
23 * -- May 28, 2000 Claudio Matsuoka <claudio@conectiva.com>
26 #include <linux/module.h>
27 #include <linux/delay.h>
28 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
34 #include <linux/parport.h>
35 #include <linux/sched.h>
36 #include <linux/videodev.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39 #include <linux/mutex.h>
40 #include <linux/jiffies.h>
42 #include <asm/uaccess.h>
45 struct video_device vdev
;
46 struct pardevice
*pdev
;
47 struct parport
*pport
;
49 int ccd_width
, ccd_height
;
51 int contrast
, brightness
, whitebal
;
53 unsigned int bidirectional
;
60 /* The three possible QuickCam modes */
61 #define QC_MILLIONS 0x18
62 #define QC_BILLIONS 0x10
63 #define QC_THOUSANDS 0x08 /* with VIDEC compression (not supported) */
65 /* The three possible decimations */
66 #define QC_DECIMATION_1 0
67 #define QC_DECIMATION_2 2
68 #define QC_DECIMATION_4 4
70 #define BANNER "Colour QuickCam for Video4Linux v0.05"
72 static int parport
[MAX_CAMS
] = { [1 ... MAX_CAMS
-1] = -1 };
75 static int video_nr
= -1;
77 static inline void qcam_set_ack(struct qcam_device
*qcam
, unsigned int i
)
79 /* note: the QC specs refer to the PCAck pin by voltage, not
80 software level. PC ports have builtin inverters. */
81 parport_frob_control(qcam
->pport
, 8, i
?8:0);
84 static inline unsigned int qcam_ready1(struct qcam_device
*qcam
)
86 return (parport_read_status(qcam
->pport
) & 0x8)?1:0;
89 static inline unsigned int qcam_ready2(struct qcam_device
*qcam
)
91 return (parport_read_data(qcam
->pport
) & 0x1)?1:0;
94 static unsigned int qcam_await_ready1(struct qcam_device
*qcam
,
97 unsigned long oldjiffies
= jiffies
;
100 for (oldjiffies
= jiffies
;
101 time_before(jiffies
, oldjiffies
+ msecs_to_jiffies(40)); )
102 if (qcam_ready1(qcam
) == value
)
105 /* If the camera didn't respond within 1/25 second, poll slowly
107 for (i
= 0; i
< 50; i
++)
109 if (qcam_ready1(qcam
) == value
)
111 msleep_interruptible(100);
114 /* Probably somebody pulled the plug out. Not much we can do. */
115 printk(KERN_ERR
"c-qcam: ready1 timeout (%d) %x %x\n", value
,
116 parport_read_status(qcam
->pport
),
117 parport_read_control(qcam
->pport
));
121 static unsigned int qcam_await_ready2(struct qcam_device
*qcam
, int value
)
123 unsigned long oldjiffies
= jiffies
;
126 for (oldjiffies
= jiffies
;
127 time_before(jiffies
, oldjiffies
+ msecs_to_jiffies(40)); )
128 if (qcam_ready2(qcam
) == value
)
131 /* If the camera didn't respond within 1/25 second, poll slowly
133 for (i
= 0; i
< 50; i
++)
135 if (qcam_ready2(qcam
) == value
)
137 msleep_interruptible(100);
140 /* Probably somebody pulled the plug out. Not much we can do. */
141 printk(KERN_ERR
"c-qcam: ready2 timeout (%d) %x %x %x\n", value
,
142 parport_read_status(qcam
->pport
),
143 parport_read_control(qcam
->pport
),
144 parport_read_data(qcam
->pport
));
148 static int qcam_read_data(struct qcam_device
*qcam
)
151 qcam_set_ack(qcam
, 0);
152 if (qcam_await_ready1(qcam
, 1)) return -1;
153 idata
= parport_read_status(qcam
->pport
) & 0xf0;
154 qcam_set_ack(qcam
, 1);
155 if (qcam_await_ready1(qcam
, 0)) return -1;
156 idata
|= (parport_read_status(qcam
->pport
) >> 4);
160 static int qcam_write_data(struct qcam_device
*qcam
, unsigned int data
)
163 parport_write_data(qcam
->pport
, data
);
164 idata
= qcam_read_data(qcam
);
167 printk(KERN_WARNING
"cqcam: sent %x but received %x\n", data
,
174 static inline int qcam_set(struct qcam_device
*qcam
, unsigned int cmd
, unsigned int data
)
176 if (qcam_write_data(qcam
, cmd
))
178 if (qcam_write_data(qcam
, data
))
183 static inline int qcam_get(struct qcam_device
*qcam
, unsigned int cmd
)
185 if (qcam_write_data(qcam
, cmd
))
187 return qcam_read_data(qcam
);
190 static int qc_detect(struct qcam_device
*qcam
)
192 unsigned int stat
, ostat
, i
, count
= 0;
194 /* The probe routine below is not very reliable. The IEEE-1284
195 probe takes precedence. */
196 /* XXX Currently parport provides no way to distinguish between
197 "the IEEE probe was not done" and "the probe was done, but
198 no device was found". Fix this one day. */
199 if (qcam
->pport
->probe_info
[0].class == PARPORT_CLASS_MEDIA
200 && qcam
->pport
->probe_info
[0].model
201 && !strcmp(qcam
->pdev
->port
->probe_info
[0].model
,
202 "Color QuickCam 2.0")) {
203 printk(KERN_DEBUG
"QuickCam: Found by IEEE1284 probe.\n");
210 parport_write_control(qcam
->pport
, 0xc);
212 /* look for a heartbeat */
213 ostat
= stat
= parport_read_status(qcam
->pport
);
214 for (i
=0; i
<250; i
++)
217 stat
= parport_read_status(qcam
->pport
);
220 if (++count
>= 3) return 1;
225 /* Reset the camera and try again */
226 parport_write_control(qcam
->pport
, 0xc);
227 parport_write_control(qcam
->pport
, 0x8);
229 parport_write_control(qcam
->pport
, 0xc);
233 ostat
= stat
= parport_read_status(qcam
->pport
);
234 for (i
=0; i
<250; i
++)
237 stat
= parport_read_status(qcam
->pport
);
240 if (++count
>= 3) return 1;
245 /* no (or flatline) camera, give up */
249 static void qc_reset(struct qcam_device
*qcam
)
251 parport_write_control(qcam
->pport
, 0xc);
252 parport_write_control(qcam
->pport
, 0x8);
254 parport_write_control(qcam
->pport
, 0xc);
258 /* Reset the QuickCam and program for brightness, contrast,
259 * white-balance, and resolution. */
261 static void qc_setup(struct qcam_device
*q
)
265 /* Set the brightness. */
266 qcam_set(q
, 11, q
->brightness
);
268 /* Set the height and width. These refer to the actual
269 CCD area *before* applying the selected decimation. */
270 qcam_set(q
, 17, q
->ccd_height
);
271 qcam_set(q
, 19, q
->ccd_width
/ 2);
273 /* Set top and left. */
274 qcam_set(q
, 0xd, q
->top
);
275 qcam_set(q
, 0xf, q
->left
);
277 /* Set contrast and white balance. */
278 qcam_set(q
, 0x19, q
->contrast
);
279 qcam_set(q
, 0x1f, q
->whitebal
);
285 /* Read some bytes from the camera and put them in the buffer.
286 nbytes should be a multiple of 3, because bidirectional mode gives
287 us three bytes at a time. */
289 static unsigned int qcam_read_bytes(struct qcam_device
*q
, unsigned char *buf
, unsigned int nbytes
)
291 unsigned int bytes
= 0;
294 if (q
->bidirectional
)
296 /* It's a bidirectional port */
297 while (bytes
< nbytes
)
299 unsigned int lo1
, hi1
, lo2
, hi2
;
300 unsigned char r
, g
, b
;
302 if (qcam_await_ready2(q
, 1)) return bytes
;
303 lo1
= parport_read_data(q
->pport
) >> 1;
304 hi1
= ((parport_read_status(q
->pport
) >> 3) & 0x1f) ^ 0x10;
306 if (qcam_await_ready2(q
, 0)) return bytes
;
307 lo2
= parport_read_data(q
->pport
) >> 1;
308 hi2
= ((parport_read_status(q
->pport
) >> 3) & 0x1f) ^ 0x10;
310 r
= (lo1
| ((hi1
& 1)<<7));
311 g
= ((hi1
& 0x1e)<<3) | ((hi2
& 0x1e)>>1);
312 b
= (lo2
| ((hi2
& 1)<<7));
326 /* It's a unidirectional port */
327 int i
= 0, n
= bytes
;
328 unsigned char rgb
[3];
330 while (bytes
< nbytes
)
334 if (qcam_await_ready1(q
, 1)) return bytes
;
335 hi
= (parport_read_status(q
->pport
) & 0xf0);
337 if (qcam_await_ready1(q
, 0)) return bytes
;
338 lo
= (parport_read_status(q
->pport
) & 0xf0);
341 rgb
[(i
= bytes
++ % 3)] = (hi
| (lo
>> 4)) ^ 0x88;
365 static long qc_capture(struct qcam_device
*q
, char __user
*buf
, unsigned long len
)
367 unsigned lines
, pixelsperline
, bitsperxfer
;
368 unsigned int is_bi_dir
= q
->bidirectional
;
369 size_t wantlen
, outptr
= 0;
372 if (!access_ok(VERIFY_WRITE
, buf
, len
))
375 /* Wait for camera to become ready */
378 int i
= qcam_get(q
, 41);
389 if (qcam_set(q
, 7, (q
->mode
| (is_bi_dir
?1:0)) + 1))
393 pixelsperline
= q
->width
;
394 bitsperxfer
= (is_bi_dir
) ? 24 : 8;
398 /* Turn the port around */
399 parport_data_reverse(q
->pport
);
402 if (qcam_await_ready1(q
, 1)) {
407 if (qcam_await_ready1(q
, 0)) {
413 wantlen
= lines
* pixelsperline
* 24 / 8;
418 s
= (wantlen
> BUFSZ
)?BUFSZ
:wantlen
;
419 t
= qcam_read_bytes(q
, tmpbuf
, s
);
422 size_t sz
= len
- outptr
;
424 if (__copy_to_user(buf
+outptr
, tmpbuf
, sz
))
438 printk("qcam: short read.\n");
440 parport_data_forward(q
->pport
);
449 l
= qcam_read_bytes(q
, tmpbuf
, 3);
451 } while (l
&& (tmpbuf
[0] == 0x7e || tmpbuf
[1] == 0x7e || tmpbuf
[2] == 0x7e));
453 if (tmpbuf
[0] != 0xe || tmpbuf
[1] != 0x0 || tmpbuf
[2] != 0xf)
454 printk("qcam: bad EOF\n");
456 if (tmpbuf
[0] != 0xf || tmpbuf
[1] != 0x0 || tmpbuf
[2] != 0xe)
457 printk("qcam: bad EOF\n");
460 if (qcam_await_ready1(q
, 1))
462 printk("qcam: no ack after EOF\n");
463 parport_data_forward(q
->pport
);
467 parport_data_forward(q
->pport
);
470 if (qcam_await_ready1(q
, 0))
472 printk("qcam: no ack to port turnaround\n");
481 l
= qcam_read_bytes(q
, tmpbuf
, 1);
483 } while (l
&& tmpbuf
[0] == 0x7e);
484 l
= qcam_read_bytes(q
, tmpbuf
+1, 2);
486 if (tmpbuf
[0] != 0xe || tmpbuf
[1] != 0x0 || tmpbuf
[2] != 0xf)
487 printk("qcam: bad EOF\n");
489 if (tmpbuf
[0] != 0xf || tmpbuf
[1] != 0x0 || tmpbuf
[2] != 0xe)
490 printk("qcam: bad EOF\n");
494 qcam_write_data(q
, 0);
499 * Video4linux interfacing
502 static int qcam_do_ioctl(struct inode
*inode
, struct file
*file
,
503 unsigned int cmd
, void *arg
)
505 struct video_device
*dev
= video_devdata(file
);
506 struct qcam_device
*qcam
=(struct qcam_device
*)dev
;
512 struct video_capability
*b
= arg
;
513 strcpy(b
->name
, "Quickcam");
514 b
->type
= VID_TYPE_CAPTURE
|VID_TYPE_SCALES
;
525 struct video_channel
*v
= arg
;
530 /* Good question.. its composite or SVHS so.. */
531 v
->type
= VIDEO_TYPE_CAMERA
;
532 strcpy(v
->name
, "Camera");
537 struct video_channel
*v
= arg
;
544 struct video_tuner
*v
= arg
;
547 memset(v
,0,sizeof(*v
));
548 strcpy(v
->name
, "Format");
549 v
->mode
= VIDEO_MODE_AUTO
;
554 struct video_tuner
*v
= arg
;
557 if(v
->mode
!=VIDEO_MODE_AUTO
)
563 struct video_picture
*p
= arg
;
566 p
->brightness
=qcam
->brightness
<<8;
567 p
->contrast
=qcam
->contrast
<<8;
568 p
->whiteness
=qcam
->whitebal
<<8;
570 p
->palette
=VIDEO_PALETTE_RGB24
;
575 struct video_picture
*p
= arg
;
580 if (p
->depth
!= 24 || p
->palette
!= VIDEO_PALETTE_RGB24
)
584 * Now load the camera.
586 qcam
->brightness
= p
->brightness
>>8;
587 qcam
->contrast
= p
->contrast
>>8;
588 qcam
->whitebal
= p
->whiteness
>>8;
590 mutex_lock(&qcam
->lock
);
591 parport_claim_or_block(qcam
->pdev
);
593 parport_release(qcam
->pdev
);
594 mutex_unlock(&qcam
->lock
);
599 struct video_window
*vw
= arg
;
605 if(vw
->height
<60||vw
->height
>240)
607 if(vw
->width
<80||vw
->width
>320)
612 qcam
->mode
= QC_DECIMATION_4
;
614 if(vw
->width
>=160 && vw
->height
>=120)
618 qcam
->mode
= QC_DECIMATION_2
;
620 if(vw
->width
>=320 && vw
->height
>=240)
624 qcam
->mode
= QC_DECIMATION_1
;
626 qcam
->mode
|= QC_MILLIONS
;
628 if(vw
->width
>=640 && vw
->height
>=480)
632 qcam
->mode
= QC_BILLIONS
| QC_DECIMATION_1
;
635 /* Ok we figured out what to use from our
637 mutex_lock(&qcam
->lock
);
638 parport_claim_or_block(qcam
->pdev
);
640 parport_release(qcam
->pdev
);
641 mutex_unlock(&qcam
->lock
);
646 struct video_window
*vw
= arg
;
647 memset(vw
, 0, sizeof(*vw
));
648 vw
->width
=qcam
->width
;
649 vw
->height
=qcam
->height
;
668 static int qcam_ioctl(struct inode
*inode
, struct file
*file
,
669 unsigned int cmd
, unsigned long arg
)
671 return video_usercopy(inode
, file
, cmd
, arg
, qcam_do_ioctl
);
674 static ssize_t
qcam_read(struct file
*file
, char __user
*buf
,
675 size_t count
, loff_t
*ppos
)
677 struct video_device
*v
= video_devdata(file
);
678 struct qcam_device
*qcam
=(struct qcam_device
*)v
;
681 mutex_lock(&qcam
->lock
);
682 parport_claim_or_block(qcam
->pdev
);
683 /* Probably should have a semaphore against multiple users */
684 len
= qc_capture(qcam
, buf
,count
);
685 parport_release(qcam
->pdev
);
686 mutex_unlock(&qcam
->lock
);
690 /* video device template */
691 static const struct file_operations qcam_fops
= {
692 .owner
= THIS_MODULE
,
693 .open
= video_exclusive_open
,
694 .release
= video_exclusive_release
,
697 .compat_ioctl
= v4l_compat_ioctl32
,
703 static struct video_device qcam_template
=
705 .name
= "Colour QuickCam",
709 /* Initialize the QuickCam driver control structure. */
711 static struct qcam_device
*qcam_init(struct parport
*port
)
713 struct qcam_device
*q
;
715 q
= kmalloc(sizeof(struct qcam_device
), GFP_KERNEL
);
720 q
->pdev
= parport_register_device(port
, "c-qcam", NULL
, NULL
,
723 q
->bidirectional
= (q
->pport
->modes
& PARPORT_MODE_TRISTATE
)?1:0;
727 printk(KERN_ERR
"c-qcam: couldn't register for %s.\n",
733 memcpy(&q
->vdev
, &qcam_template
, sizeof(qcam_template
));
735 mutex_init(&q
->lock
);
736 q
->width
= q
->ccd_width
= 320;
737 q
->height
= q
->ccd_height
= 240;
738 q
->mode
= QC_MILLIONS
| QC_DECIMATION_1
;
747 static struct qcam_device
*qcams
[MAX_CAMS
];
748 static unsigned int num_cams
;
750 static int init_cqcam(struct parport
*port
)
752 struct qcam_device
*qcam
;
754 if (parport
[0] != -1)
756 /* The user gave specific instructions */
758 for (i
= 0; i
< MAX_CAMS
&& parport
[i
] != -1; i
++)
760 if (parport
[0] == port
->number
)
767 if (num_cams
== MAX_CAMS
)
770 qcam
= qcam_init(port
);
774 parport_claim_or_block(qcam
->pdev
);
778 if (probe
&& qc_detect(qcam
)==0)
780 parport_release(qcam
->pdev
);
781 parport_unregister_device(qcam
->pdev
);
788 parport_release(qcam
->pdev
);
790 if (video_register_device(&qcam
->vdev
, VFL_TYPE_GRABBER
, video_nr
) < 0) {
791 printk(KERN_ERR
"Unable to register Colour QuickCam on %s\n",
793 parport_unregister_device(qcam
->pdev
);
798 printk(KERN_INFO
"video%d: Colour QuickCam found on %s\n",
799 qcam
->vdev
.minor
, qcam
->pport
->name
);
801 qcams
[num_cams
++] = qcam
;
806 static void close_cqcam(struct qcam_device
*qcam
)
808 video_unregister_device(&qcam
->vdev
);
809 parport_unregister_device(qcam
->pdev
);
813 static void cq_attach(struct parport
*port
)
818 static void cq_detach(struct parport
*port
)
820 /* Write this some day. */
823 static struct parport_driver cqcam_driver
= {
829 static int __init
cqcam_init (void)
833 return parport_register_driver(&cqcam_driver
);
836 static void __exit
cqcam_cleanup (void)
840 for (i
= 0; i
< num_cams
; i
++)
841 close_cqcam(qcams
[i
]);
843 parport_unregister_driver(&cqcam_driver
);
846 MODULE_AUTHOR("Philip Blundell <philb@gnu.org>");
847 MODULE_DESCRIPTION(BANNER
);
848 MODULE_LICENSE("GPL");
850 /* FIXME: parport=auto would never have worked, surely? --RR */
851 MODULE_PARM_DESC(parport
,"parport=<auto|n[,n]...> for port detection method\n\
852 probe=<0|1|2> for camera detection method\n\
853 force_rgb=<0|1> for RGB data format (default BGR)");
854 module_param_array(parport
, int, NULL
, 0);
855 module_param(probe
, int, 0);
856 module_param(force_rgb
, bool, 0);
857 module_param(video_nr
, int, 0);
859 module_init(cqcam_init
);
860 module_exit(cqcam_cleanup
);