2 Winbond w9966cf Webcam parport driver.
6 Copyright (C) 2001 Jakob Kemi <jakob.kemi@post.utfors.se>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *Lifeview FlyCam Supra (using the Philips saa7111a chip)
26 Does any other model using the w9966 interface chip exist ?
30 *Add a working EPP mode, since DMA ECP read isn't implemented
31 in the parport drivers. (That's why it's so sloow)
33 *Add support for other ccd-control chips than the saa7111
34 please send me feedback on what kind of chips you have.
36 *Add proper probing. I don't know what's wrong with the IEEE1284
37 parport drivers but (IEEE1284_MODE_NIBBLE|IEEE1284_DEVICE_ID)
38 and nibble read seems to be broken for some peripherals.
40 *Add probing for onboard SRAM, port directions etc. (if possible)
42 *Add support for the hardware compressed modes (maybe using v4l2)
44 *Fix better support for the capture window (no skewed images, v4l
45 interface to capt. window)
47 *Probably some bugs that I don't know of
49 Please support me by sending feedback!
53 Alan Cox: Removed RGB mode for kernel merge, added THIS_MODULE
54 and owner support for newer module locks
57 #include <linux/module.h>
58 #include <linux/init.h>
59 #include <linux/delay.h>
60 #include <linux/videodev2.h>
61 #include <media/v4l2-common.h>
62 #include <media/v4l2-ioctl.h>
63 #include <linux/parport.h>
65 /*#define DEBUG*/ /* Undef me for production */
68 #define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __func__ , ##a)
74 * Defines, simple typedefs etc.
77 #define W9966_DRIVERNAME "W9966CF Webcam"
78 #define W9966_MAXCAMS 4 // Maximum number of cameras
79 #define W9966_RBUFFER 2048 // Read buffer (must be an even number)
80 #define W9966_SRAMSIZE 131072 // 128kb
81 #define W9966_SRAMID 0x02 // check w9966cf.pdf
83 // Empirically determined window limits
84 #define W9966_WND_MIN_X 16
85 #define W9966_WND_MIN_Y 14
86 #define W9966_WND_MAX_X 705
87 #define W9966_WND_MAX_Y 253
88 #define W9966_WND_MAX_W (W9966_WND_MAX_X - W9966_WND_MIN_X)
89 #define W9966_WND_MAX_H (W9966_WND_MAX_Y - W9966_WND_MIN_Y)
91 // Keep track of our current state
92 #define W9966_STATE_PDEV 0x01
93 #define W9966_STATE_CLAIMED 0x02
94 #define W9966_STATE_VDEV 0x04
96 #define W9966_I2C_W_ID 0x48
97 #define W9966_I2C_R_ID 0x49
98 #define W9966_I2C_R_DATA 0x08
99 #define W9966_I2C_R_CLOCK 0x04
100 #define W9966_I2C_W_DATA 0x02
101 #define W9966_I2C_W_CLOCK 0x01
104 unsigned char dev_state;
105 unsigned char i2c_state;
106 unsigned short ppmode;
107 struct parport* pport;
108 struct pardevice* pdev;
109 struct video_device vdev;
110 unsigned short width;
111 unsigned short height;
112 unsigned char brightness;
113 signed char contrast;
116 unsigned long in_use;
120 * Module specific properties
123 MODULE_AUTHOR("Jakob Kemi <jakob.kemi@post.utfors.se>");
124 MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (0.32)");
125 MODULE_LICENSE("GPL");
129 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = ""};
131 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "aggressive"};
133 module_param_array(pardev, charp, NULL, 0);
134 MODULE_PARM_DESC(pardev, "pardev: where to search for\n\
135 \teach camera. 'aggressive' means brute-force search.\n\
136 \tEg: >pardev=parport3,aggressive,parport2,parport1< would assign\n\
137 \tcam 1 to parport3 and search every parport for cam 2 etc...");
140 module_param(parmode, int, 0);
141 MODULE_PARM_DESC(parmode, "parmode: transfer mode (0=auto, 1=ecp, 2=epp");
143 static int video_nr = -1;
144 module_param(video_nr, int, 0);
150 static struct w9966_dev w9966_cams[W9966_MAXCAMS];
153 * Private function declares
156 static inline void w9966_setState(struct w9966_dev* cam, int mask, int val);
157 static inline int w9966_getState(struct w9966_dev* cam, int mask, int val);
158 static inline void w9966_pdev_claim(struct w9966_dev *vdev);
159 static inline void w9966_pdev_release(struct w9966_dev *vdev);
161 static int w9966_rReg(struct w9966_dev* cam, int reg);
162 static int w9966_wReg(struct w9966_dev* cam, int reg, int data);
164 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);
166 static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data);
167 static int w9966_findlen(int near, int size, int maxlen);
168 static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor);
169 static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h);
171 static int w9966_init(struct w9966_dev* cam, struct parport* port);
172 static void w9966_term(struct w9966_dev* cam);
174 static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state);
175 static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state);
176 static inline int w9966_i2c_getsda(struct w9966_dev* cam);
177 static inline int w9966_i2c_getscl(struct w9966_dev* cam);
178 static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);
180 static int w9966_i2c_rbyte(struct w9966_dev* cam);
183 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
184 unsigned int cmd, unsigned long arg);
185 static ssize_t w9966_v4l_read(struct file *file, char __user *buf,
186 size_t count, loff_t *ppos);
188 static int w9966_exclusive_open(struct inode *inode, struct file *file)
190 struct w9966_dev *cam = video_drvdata(file);
192 return test_and_set_bit(0, &cam->in_use) ? -EBUSY : 0;
195 static int w9966_exclusive_release(struct inode *inode, struct file *file)
197 struct w9966_dev *cam = video_drvdata(file);
199 clear_bit(0, &cam->in_use);
203 static const struct file_operations w9966_fops = {
204 .owner = THIS_MODULE,
205 .open = w9966_exclusive_open,
206 .release = w9966_exclusive_release,
207 .ioctl = w9966_v4l_ioctl,
209 .compat_ioctl = v4l_compat_ioctl32,
211 .read = w9966_v4l_read,
214 static struct video_device w9966_template = {
215 .name = W9966_DRIVERNAME,
217 .release = video_device_release_empty,
221 * Private function defines
225 // Set camera phase flags, so we know what to uninit when terminating
226 static inline void w9966_setState(struct w9966_dev* cam, int mask, int val)
228 cam->dev_state = (cam->dev_state & ~mask) ^ val;
231 // Get camera phase flags
232 static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)
234 return ((cam->dev_state & mask) == val);
237 // Claim parport for ourself
238 static inline void w9966_pdev_claim(struct w9966_dev* cam)
240 if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))
242 parport_claim_or_block(cam->pdev);
243 w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);
246 // Release parport for others to use
247 static inline void w9966_pdev_release(struct w9966_dev* cam)
249 if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))
251 parport_release(cam->pdev);
252 w9966_setState(cam, W9966_STATE_CLAIMED, 0);
255 // Read register from W9966 interface-chip
256 // Expects a claimed pdev
257 // -1 on error, else register data (byte)
258 static int w9966_rReg(struct w9966_dev* cam, int reg)
260 // ECP, read, regtransfer, REG, REG, REG, REG, REG
261 const unsigned char addr = 0x80 | (reg & 0x1f);
264 if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
266 if (parport_write(cam->pport, &addr, 1) != 1)
268 if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
270 if (parport_read(cam->pport, &val, 1) != 1)
276 // Write register to W9966 interface-chip
277 // Expects a claimed pdev
279 static int w9966_wReg(struct w9966_dev* cam, int reg, int data)
281 // ECP, write, regtransfer, REG, REG, REG, REG, REG
282 const unsigned char addr = 0xc0 | (reg & 0x1f);
283 const unsigned char val = data;
285 if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
287 if (parport_write(cam->pport, &addr, 1) != 1)
289 if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
291 if (parport_write(cam->pport, &val, 1) != 1)
297 // Initialize camera device. Setup all internal flags, set a
298 // default video mode, setup ccd-chip, register v4l device etc..
299 // Also used for 'probing' of hardware.
301 static int w9966_init(struct w9966_dev* cam, struct parport* port)
303 if (cam->dev_state != 0)
307 cam->brightness = 128;
312 // Select requested transfer mode
315 default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)
317 if (port->modes & PARPORT_MODE_ECP)
318 cam->ppmode = IEEE1284_MODE_ECP;
319 else if (port->modes & PARPORT_MODE_EPP)
320 cam->ppmode = IEEE1284_MODE_EPP;
322 cam->ppmode = IEEE1284_MODE_ECP;
324 case 1: // hw- or sw-ecp
325 cam->ppmode = IEEE1284_MODE_ECP;
327 case 2: // hw- or sw-epp
328 cam->ppmode = IEEE1284_MODE_EPP;
332 // Tell the parport driver that we exists
333 cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL);
334 if (cam->pdev == NULL) {
335 DPRINTF("parport_register_device() failed\n");
338 w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);
340 w9966_pdev_claim(cam);
342 // Setup a default capture mode
343 if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {
344 DPRINTF("w9966_setup() failed.\n");
348 w9966_pdev_release(cam);
350 // Fill in the video_device struct and register us to v4l
351 memcpy(&cam->vdev, &w9966_template, sizeof(struct video_device));
352 video_set_drvdata(&cam->vdev, cam);
354 if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0)
357 w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);
361 "w9966cf: Found and initialized a webcam on %s.\n",
368 // Terminate everything gracefully
369 static void w9966_term(struct w9966_dev* cam)
371 // Unregister from v4l
372 if (w9966_getState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV)) {
373 video_unregister_device(&cam->vdev);
374 w9966_setState(cam, W9966_STATE_VDEV, 0);
377 // Terminate from IEEE1284 mode and release pdev block
378 if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
379 w9966_pdev_claim(cam);
380 parport_negotiate(cam->pport, IEEE1284_MODE_COMPAT);
381 w9966_pdev_release(cam);
384 // Unregister from parport
385 if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
386 parport_unregister_device(cam->pdev);
387 w9966_setState(cam, W9966_STATE_PDEV, 0);
392 // Find a good length for capture window (used both for W and H)
393 // A bit ugly but pretty functional. The capture length
394 // have to match the downscale
395 static int w9966_findlen(int near, int size, int maxlen)
398 int besterr = abs(near - bestlen);
401 for(len = size+1;len < maxlen;len++)
404 if ( ((64*size) %len) != 0)
407 err = abs(near - len);
409 // Only continue as long as we keep getting better values
420 // Modify capture window (if necessary)
421 // and calculate downscaling
422 // Return -1 on error
423 static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor)
425 int maxlen = max - min;
426 int len = *end - *beg + 1;
427 int newlen = w9966_findlen(len, size, maxlen);
428 int err = newlen - len;
430 // Check for bad format
431 if (newlen > maxlen || newlen < size)
434 // Set factor (6 bit fixed)
435 *factor = (64*size) / newlen;
437 *factor = 0x00; // downscale is disabled
439 *factor |= 0x80; // set downscale-enable bit
441 // Modify old beginning and end
443 *end += err - (err / 2);
445 // Move window if outside borders
458 // Setup the cameras capture window etc.
459 // Expects a claimed pdev
460 // return -1 on error
461 static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h)
464 unsigned int enh_s, enh_e;
465 unsigned char scale_x, scale_y;
466 unsigned char regs[0x1c];
467 unsigned char saa7111_regs[] = {
468 0x21, 0x00, 0xd8, 0x23, 0x00, 0x80, 0x80, 0x00,
469 0x88, 0x10, 0x80, 0x40, 0x40, 0x00, 0x01, 0x00,
470 0x48, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
471 0x00, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0xc0
475 if (w*h*2 > W9966_SRAMSIZE)
477 DPRINTF("capture window exceeds SRAM size!.\n");
478 w = 200; h = 160; // Pick default values
484 if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;
485 if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;
493 // Modify capture window if necessary and calculate downscaling
495 w9966_calcscale(w, W9966_WND_MIN_X, W9966_WND_MAX_X, &x1, &x2, &scale_x) != 0 ||
496 w9966_calcscale(h, W9966_WND_MIN_Y, W9966_WND_MAX_Y, &y1, &y2, &scale_y) != 0
500 "%dx%d, x: %d<->%d, y: %d<->%d, sx: %d/64, sy: %d/64.\n",
501 w, h, x1, x2, y1, y2, scale_x&~0x80, scale_y&~0x80
505 regs[0x00] = 0x00; // Set normal operation
506 regs[0x01] = 0x18; // Capture mode
507 regs[0x02] = scale_y; // V-scaling
508 regs[0x03] = scale_x; // H-scaling
511 regs[0x04] = (x1 & 0x0ff); // X-start (8 low bits)
512 regs[0x05] = (x1 & 0x300)>>8; // X-start (2 high bits)
513 regs[0x06] = (y1 & 0x0ff); // Y-start (8 low bits)
514 regs[0x07] = (y1 & 0x300)>>8; // Y-start (2 high bits)
515 regs[0x08] = (x2 & 0x0ff); // X-end (8 low bits)
516 regs[0x09] = (x2 & 0x300)>>8; // X-end (2 high bits)
517 regs[0x0a] = (y2 & 0x0ff); // Y-end (8 low bits)
519 regs[0x0c] = W9966_SRAMID; // SRAM-banks (1x 128kb)
522 regs[0x0d] = (enh_s& 0x000ff); // Enh. start (0-7)
523 regs[0x0e] = (enh_s& 0x0ff00)>>8; // Enh. start (8-15)
524 regs[0x0f] = (enh_s& 0x70000)>>16; // Enh. start (16-17/18??)
525 regs[0x10] = (enh_e& 0x000ff); // Enh. end (0-7)
526 regs[0x11] = (enh_e& 0x0ff00)>>8; // Enh. end (8-15)
527 regs[0x12] = (enh_e& 0x70000)>>16; // Enh. end (16-17/18??)
530 regs[0x13] = 0x40; // VEE control (raw 4:2:2)
531 regs[0x17] = 0x00; // ???
532 regs[0x18] = cam->i2c_state = 0x00; // Serial bus
533 regs[0x19] = 0xff; // I/O port direction control
534 regs[0x1a] = 0xff; // I/O port data register
535 regs[0x1b] = 0x10; // ???
537 // SAA7111 chip settings
538 saa7111_regs[0x0a] = cam->brightness;
539 saa7111_regs[0x0b] = cam->contrast;
540 saa7111_regs[0x0c] = cam->color;
541 saa7111_regs[0x0d] = cam->hue;
543 // Reset (ECP-fifo & serial-bus)
544 if (w9966_wReg(cam, 0x00, 0x03) == -1)
547 // Write regs to w9966cf chip
548 for (i = 0; i < 0x1c; i++)
549 if (w9966_wReg(cam, i, regs[i]) == -1)
552 // Write regs to saa7111 chip
553 for (i = 0; i < 0x20; i++)
554 if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
561 * Ugly and primitive i2c protocol functions
564 // Sets the data line on the i2c bus.
565 // Expects a claimed pdev.
566 static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)
569 cam->i2c_state |= W9966_I2C_W_DATA;
571 cam->i2c_state &= ~W9966_I2C_W_DATA;
573 w9966_wReg(cam, 0x18, cam->i2c_state);
577 // Get peripheral clock line
578 // Expects a claimed pdev.
579 static inline int w9966_i2c_getscl(struct w9966_dev* cam)
581 const unsigned char state = w9966_rReg(cam, 0x18);
582 return ((state & W9966_I2C_R_CLOCK) > 0);
585 // Sets the clock line on the i2c bus.
586 // Expects a claimed pdev. -1 on error
587 static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)
589 unsigned long timeout;
592 cam->i2c_state |= W9966_I2C_W_CLOCK;
594 cam->i2c_state &= ~W9966_I2C_W_CLOCK;
596 w9966_wReg(cam, 0x18, cam->i2c_state);
599 // we go to high, we also expect the peripheral to ack.
601 timeout = jiffies + 100;
602 while (!w9966_i2c_getscl(cam)) {
603 if (time_after(jiffies, timeout))
610 // Get peripheral data line
611 // Expects a claimed pdev.
612 static inline int w9966_i2c_getsda(struct w9966_dev* cam)
614 const unsigned char state = w9966_rReg(cam, 0x18);
615 return ((state & W9966_I2C_R_DATA) > 0);
618 // Write a byte with ack to the i2c bus.
619 // Expects a claimed pdev. -1 on error
620 static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)
623 for (i = 7; i >= 0; i--)
625 w9966_i2c_setsda(cam, (data >> i) & 0x01);
627 if (w9966_i2c_setscl(cam, 1) == -1)
629 w9966_i2c_setscl(cam, 0);
632 w9966_i2c_setsda(cam, 1);
634 if (w9966_i2c_setscl(cam, 1) == -1)
636 w9966_i2c_setscl(cam, 0);
641 // Read a data byte with ack from the i2c-bus
642 // Expects a claimed pdev. -1 on error
644 static int w9966_i2c_rbyte(struct w9966_dev* cam)
646 unsigned char data = 0x00;
649 w9966_i2c_setsda(cam, 1);
651 for (i = 0; i < 8; i++)
653 if (w9966_i2c_setscl(cam, 1) == -1)
656 if (w9966_i2c_getsda(cam))
659 w9966_i2c_setscl(cam, 0);
665 // Read a register from the i2c device.
666 // Expects claimed pdev. -1 on error
668 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
672 w9966_i2c_setsda(cam, 0);
673 w9966_i2c_setscl(cam, 0);
676 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
677 w9966_i2c_wbyte(cam, reg) == -1
681 w9966_i2c_setsda(cam, 1);
682 if (w9966_i2c_setscl(cam, 1) == -1)
684 w9966_i2c_setsda(cam, 0);
685 w9966_i2c_setscl(cam, 0);
688 w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 ||
689 (data = w9966_i2c_rbyte(cam)) == -1
693 w9966_i2c_setsda(cam, 0);
695 if (w9966_i2c_setscl(cam, 1) == -1)
697 w9966_i2c_setsda(cam, 1);
703 // Write a register to the i2c device.
704 // Expects claimed pdev. -1 on error
705 static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
707 w9966_i2c_setsda(cam, 0);
708 w9966_i2c_setscl(cam, 0);
711 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
712 w9966_i2c_wbyte(cam, reg) == -1 ||
713 w9966_i2c_wbyte(cam, data) == -1
717 w9966_i2c_setsda(cam, 0);
718 if (w9966_i2c_setscl(cam, 1) == -1)
721 w9966_i2c_setsda(cam, 1);
727 * Video4linux interfacing
730 static int w9966_v4l_do_ioctl(struct inode *inode, struct file *file,
731 unsigned int cmd, void *arg)
733 struct w9966_dev *cam = video_drvdata(file);
739 static struct video_capability vcap = {
740 .name = W9966_DRIVERNAME,
741 .type = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
743 .maxwidth = W9966_WND_MAX_W,
744 .maxheight = W9966_WND_MAX_H,
748 struct video_capability *cap = arg;
754 struct video_channel *vch = arg;
755 if(vch->channel != 0) // We only support one channel (#0)
757 memset(vch,0,sizeof(*vch));
758 strcpy(vch->name, "CCD-input");
759 vch->type = VIDEO_TYPE_CAMERA;
764 struct video_channel *vch = arg;
765 if(vch->channel != 0)
771 struct video_tuner *vtune = arg;
772 if(vtune->tuner != 0)
774 strcpy(vtune->name, "no tuner");
776 vtune->rangehigh = 0;
777 vtune->flags = VIDEO_TUNER_NORM;
778 vtune->mode = VIDEO_MODE_AUTO;
779 vtune->signal = 0xffff;
784 struct video_tuner *vtune = arg;
785 if (vtune->tuner != 0)
787 if (vtune->mode != VIDEO_MODE_AUTO)
793 struct video_picture vpic = {
794 cam->brightness << 8, // brightness
795 (cam->hue + 128) << 8, // hue
796 cam->color << 9, // color
797 cam->contrast << 9, // contrast
799 16, VIDEO_PALETTE_YUV422// bpp, palette format
801 struct video_picture *pic = arg;
807 struct video_picture *vpic = arg;
808 if (vpic->depth != 16 || (vpic->palette != VIDEO_PALETTE_YUV422 && vpic->palette != VIDEO_PALETTE_YUYV))
811 cam->brightness = vpic->brightness >> 8;
812 cam->hue = (vpic->hue >> 8) - 128;
813 cam->color = vpic->colour >> 9;
814 cam->contrast = vpic->contrast >> 9;
816 w9966_pdev_claim(cam);
819 w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 ||
820 w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 ||
821 w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 ||
822 w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1
824 w9966_pdev_release(cam);
828 w9966_pdev_release(cam);
834 struct video_window *vwin = arg;
836 if (vwin->flags != 0)
838 if (vwin->clipcount != 0)
840 if (vwin->width < 2 || vwin->width > W9966_WND_MAX_W)
842 if (vwin->height < 1 || vwin->height > W9966_WND_MAX_H)
845 // Update camera regs
846 w9966_pdev_claim(cam);
847 ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin->width, vwin->height);
848 w9966_pdev_release(cam);
851 DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");
859 struct video_window *vwin = arg;
860 memset(vwin, 0, sizeof(*vwin));
861 vwin->width = cam->width;
862 vwin->height = cam->height;
881 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
882 unsigned int cmd, unsigned long arg)
884 return video_usercopy(inode, file, cmd, arg, w9966_v4l_do_ioctl);
888 static ssize_t w9966_v4l_read(struct file *file, char __user *buf,
889 size_t count, loff_t *ppos)
891 struct w9966_dev *cam = video_drvdata(file);
892 unsigned char addr = 0xa0; // ECP, read, CCD-transfer, 00000
893 unsigned char __user *dest = (unsigned char __user *)buf;
894 unsigned long dleft = count;
897 // Why would anyone want more than this??
898 if (count > cam->width * cam->height * 2)
901 w9966_pdev_claim(cam);
902 w9966_wReg(cam, 0x00, 0x02); // Reset ECP-FIFO buffer
903 w9966_wReg(cam, 0x00, 0x00); // Return to normal operation
904 w9966_wReg(cam, 0x01, 0x98); // Enable capture
906 // write special capture-addr and negotiate into data transfer
908 (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_ADDR) != 0 )||
909 (parport_write(cam->pport, &addr, 1) != 1 )||
910 (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_DATA) != 0 )
912 w9966_pdev_release(cam);
916 tbuf = kmalloc(W9966_RBUFFER, GFP_KERNEL);
924 unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
926 if (parport_read(cam->pport, tbuf, tsize) < tsize) {
930 if (copy_to_user(dest, tbuf, tsize) != 0) {
938 w9966_wReg(cam, 0x01, 0x18); // Disable capture
942 w9966_pdev_release(cam);
948 // Called once for every parport on init
949 static void w9966_attach(struct parport *port)
953 for (i = 0; i < W9966_MAXCAMS; i++)
955 if (w9966_cams[i].dev_state != 0) // Cam is already assigned
958 strcmp(pardev[i], "aggressive") == 0 ||
959 strcmp(pardev[i], port->name) == 0
961 if (w9966_init(&w9966_cams[i], port) != 0)
962 w9966_term(&w9966_cams[i]);
968 // Called once for every parport on termination
969 static void w9966_detach(struct parport *port)
972 for (i = 0; i < W9966_MAXCAMS; i++)
973 if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)
974 w9966_term(&w9966_cams[i]);
978 static struct parport_driver w9966_ppd = {
979 .name = W9966_DRIVERNAME,
980 .attach = w9966_attach,
981 .detach = w9966_detach,
984 // Module entry point
985 static int __init w9966_mod_init(void)
988 for (i = 0; i < W9966_MAXCAMS; i++)
989 w9966_cams[i].dev_state = 0;
991 return parport_register_driver(&w9966_ppd);
995 static void __exit w9966_mod_term(void)
997 parport_unregister_driver(&w9966_ppd);
1000 module_init(w9966_mod_init);
1001 module_exit(w9966_mod_term);