V4L/DVB (8788): v4l: replace video_get_drvdata(video_devdata(filp)) with video_drvdat...
[linux-2.6.git] / drivers / media / video / w9966.c
1 /*
2         Winbond w9966cf Webcam parport driver.
3
4         Version 0.32
5
6         Copyright (C) 2001 Jakob Kemi <jakob.kemi@post.utfors.se>
7
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.
12
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.
17
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.
21 */
22 /*
23         Supported devices:
24         *Lifeview FlyCam Supra (using the Philips saa7111a chip)
25
26         Does any other model using the w9966 interface chip exist ?
27
28         Todo:
29
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)
32
33         *Add support for other ccd-control chips than the saa7111
34         please send me feedback on what kind of chips you have.
35
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.
39
40         *Add probing for onboard SRAM, port directions etc. (if possible)
41
42         *Add support for the hardware compressed modes (maybe using v4l2)
43
44         *Fix better support for the capture window (no skewed images, v4l
45         interface to capt. window)
46
47         *Probably some bugs that I don't know of
48
49         Please support me by sending feedback!
50
51         Changes:
52
53         Alan Cox:       Removed RGB mode for kernel merge, added THIS_MODULE
54                         and owner support for newer module locks
55 */
56
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>
64
65 /*#define DEBUG*/                               /* Undef me for production */
66
67 #ifdef DEBUG
68 #define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __func__ , ##a)
69 #else
70 #define DPRINTF(x...)
71 #endif
72
73 /*
74  *      Defines, simple typedefs etc.
75  */
76
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
82
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)
90
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
95
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
102
103 struct w9966_dev {
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;
114         signed char color;
115         signed char hue;
116         unsigned long in_use;
117 };
118
119 /*
120  *      Module specific properties
121  */
122
123 MODULE_AUTHOR("Jakob Kemi <jakob.kemi@post.utfors.se>");
124 MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (0.32)");
125 MODULE_LICENSE("GPL");
126
127
128 #ifdef MODULE
129 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = ""};
130 #else
131 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "aggressive"};
132 #endif
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...");
138
139 static int parmode;
140 module_param(parmode, int, 0);
141 MODULE_PARM_DESC(parmode, "parmode: transfer mode (0=auto, 1=ecp, 2=epp");
142
143 static int video_nr = -1;
144 module_param(video_nr, int, 0);
145
146 /*
147  *      Private data
148  */
149
150 static struct w9966_dev w9966_cams[W9966_MAXCAMS];
151
152 /*
153  *      Private function declares
154  */
155
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);
160
161 static int w9966_rReg(struct w9966_dev* cam, int reg);
162 static int w9966_wReg(struct w9966_dev* cam, int reg, int data);
163 #if 0
164 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);
165 #endif
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);
170
171 static int  w9966_init(struct w9966_dev* cam, struct parport* port);
172 static void w9966_term(struct w9966_dev* cam);
173
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);
179 #if 0
180 static int w9966_i2c_rbyte(struct w9966_dev* cam);
181 #endif
182
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);
187
188 static int w9966_exclusive_open(struct inode *inode, struct file *file)
189 {
190         struct w9966_dev *cam = video_drvdata(file);
191
192         return test_and_set_bit(0, &cam->in_use) ? -EBUSY : 0;
193 }
194
195 static int w9966_exclusive_release(struct inode *inode, struct file *file)
196 {
197         struct w9966_dev *cam = video_drvdata(file);
198
199         clear_bit(0, &cam->in_use);
200         return 0;
201 }
202
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,
208 #ifdef CONFIG_COMPAT
209         .compat_ioctl   = v4l_compat_ioctl32,
210 #endif
211         .read           = w9966_v4l_read,
212         .llseek         = no_llseek,
213 };
214 static struct video_device w9966_template = {
215         .name           = W9966_DRIVERNAME,
216         .fops           = &w9966_fops,
217         .release        = video_device_release_empty,
218 };
219
220 /*
221  *      Private function defines
222  */
223
224
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)
227 {
228         cam->dev_state = (cam->dev_state & ~mask) ^ val;
229 }
230
231 // Get camera phase flags
232 static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)
233 {
234         return ((cam->dev_state & mask) == val);
235 }
236
237 // Claim parport for ourself
238 static inline void w9966_pdev_claim(struct w9966_dev* cam)
239 {
240         if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))
241                 return;
242         parport_claim_or_block(cam->pdev);
243         w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);
244 }
245
246 // Release parport for others to use
247 static inline void w9966_pdev_release(struct w9966_dev* cam)
248 {
249         if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))
250                 return;
251         parport_release(cam->pdev);
252         w9966_setState(cam, W9966_STATE_CLAIMED, 0);
253 }
254
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)
259 {
260         // ECP, read, regtransfer, REG, REG, REG, REG, REG
261         const unsigned char addr = 0x80 | (reg & 0x1f);
262         unsigned char val;
263
264         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
265                 return -1;
266         if (parport_write(cam->pport, &addr, 1) != 1)
267                 return -1;
268         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
269                 return -1;
270         if (parport_read(cam->pport, &val, 1) != 1)
271                 return -1;
272
273         return val;
274 }
275
276 // Write register to W9966 interface-chip
277 // Expects a claimed pdev
278 // -1 on error
279 static int w9966_wReg(struct w9966_dev* cam, int reg, int data)
280 {
281         // ECP, write, regtransfer, REG, REG, REG, REG, REG
282         const unsigned char addr = 0xc0 | (reg & 0x1f);
283         const unsigned char val = data;
284
285         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
286                 return -1;
287         if (parport_write(cam->pport, &addr, 1) != 1)
288                 return -1;
289         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
290                 return -1;
291         if (parport_write(cam->pport, &val, 1) != 1)
292                 return -1;
293
294         return 0;
295 }
296
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.
300 // -1 on error
301 static int w9966_init(struct w9966_dev* cam, struct parport* port)
302 {
303         if (cam->dev_state != 0)
304                 return -1;
305
306         cam->pport = port;
307         cam->brightness = 128;
308         cam->contrast = 64;
309         cam->color = 64;
310         cam->hue = 0;
311
312 // Select requested transfer mode
313         switch(parmode)
314         {
315         default:        // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)
316         case 0:
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;
321                 else
322                         cam->ppmode = IEEE1284_MODE_ECP;
323                 break;
324         case 1:         // hw- or sw-ecp
325                 cam->ppmode = IEEE1284_MODE_ECP;
326                 break;
327         case 2:         // hw- or sw-epp
328                 cam->ppmode = IEEE1284_MODE_EPP;
329         break;
330         }
331
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");
336                 return -1;
337         }
338         w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);
339
340         w9966_pdev_claim(cam);
341
342 // Setup a default capture mode
343         if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {
344                 DPRINTF("w9966_setup() failed.\n");
345                 return -1;
346         }
347
348         w9966_pdev_release(cam);
349
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);
353
354         if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0)
355                 return -1;
356
357         w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);
358
359         // All ok
360         printk(
361                 "w9966cf: Found and initialized a webcam on %s.\n",
362                 cam->pport->name
363         );
364         return 0;
365 }
366
367
368 // Terminate everything gracefully
369 static void w9966_term(struct w9966_dev* cam)
370 {
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);
375         }
376
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);
382         }
383
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);
388         }
389 }
390
391
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)
396 {
397         int bestlen = size;
398         int besterr = abs(near - bestlen);
399         int len;
400
401         for(len = size+1;len < maxlen;len++)
402         {
403                 int err;
404                 if ( ((64*size) %len) != 0)
405                         continue;
406
407                 err = abs(near - len);
408
409                 // Only continue as long as we keep getting better values
410                 if (err > besterr)
411                         break;
412
413                 besterr = err;
414                 bestlen = len;
415         }
416
417         return bestlen;
418 }
419
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)
424 {
425         int maxlen = max - min;
426         int len = *end - *beg + 1;
427         int newlen = w9966_findlen(len, size, maxlen);
428         int err = newlen - len;
429
430         // Check for bad format
431         if (newlen > maxlen || newlen < size)
432                 return -1;
433
434         // Set factor (6 bit fixed)
435         *factor = (64*size) / newlen;
436         if (*factor == 64)
437                 *factor = 0x00; // downscale is disabled
438         else
439                 *factor |= 0x80; // set downscale-enable bit
440
441         // Modify old beginning and end
442         *beg -= err / 2;
443         *end += err - (err / 2);
444
445         // Move window if outside borders
446         if (*beg < min) {
447                 *end += min - *beg;
448                 *beg += min - *beg;
449         }
450         if (*end > max) {
451                 *beg -= *end - max;
452                 *end -= *end - max;
453         }
454
455         return 0;
456 }
457
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)
462 {
463         unsigned int i;
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
472         };
473
474
475         if (w*h*2 > W9966_SRAMSIZE)
476         {
477                 DPRINTF("capture window exceeds SRAM size!.\n");
478                 w = 200; h = 160;       // Pick default values
479         }
480
481         w &= ~0x1;
482         if (w < 2) w = 2;
483         if (h < 1) h = 1;
484         if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;
485         if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;
486
487         cam->width = w;
488         cam->height = h;
489
490         enh_s = 0;
491         enh_e = w*h*2;
492
493 // Modify capture window if necessary and calculate downscaling
494         if (
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
497         ) return -1;
498
499         DPRINTF(
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
502         );
503
504 // Setup registers
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
509
510         // Capture window
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)
518
519         regs[0x0c] = W9966_SRAMID;              // SRAM-banks (1x 128kb)
520
521         // Enhancement layer
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??)
528
529         // Misc
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;                      // ???
536
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;
542
543 // Reset (ECP-fifo & serial-bus)
544         if (w9966_wReg(cam, 0x00, 0x03) == -1)
545                 return -1;
546
547 // Write regs to w9966cf chip
548         for (i = 0; i < 0x1c; i++)
549                 if (w9966_wReg(cam, i, regs[i]) == -1)
550                         return -1;
551
552 // Write regs to saa7111 chip
553         for (i = 0; i < 0x20; i++)
554                 if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
555                         return -1;
556
557         return 0;
558 }
559
560 /*
561  *      Ugly and primitive i2c protocol functions
562  */
563
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)
567 {
568         if (state)
569                 cam->i2c_state |= W9966_I2C_W_DATA;
570         else
571                 cam->i2c_state &= ~W9966_I2C_W_DATA;
572
573         w9966_wReg(cam, 0x18, cam->i2c_state);
574         udelay(5);
575 }
576
577 // Get peripheral clock line
578 // Expects a claimed pdev.
579 static inline int w9966_i2c_getscl(struct w9966_dev* cam)
580 {
581         const unsigned char state = w9966_rReg(cam, 0x18);
582         return ((state & W9966_I2C_R_CLOCK) > 0);
583 }
584
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)
588 {
589         unsigned long timeout;
590
591         if (state)
592                 cam->i2c_state |= W9966_I2C_W_CLOCK;
593         else
594                 cam->i2c_state &= ~W9966_I2C_W_CLOCK;
595
596         w9966_wReg(cam, 0x18, cam->i2c_state);
597         udelay(5);
598
599         // we go to high, we also expect the peripheral to ack.
600         if (state) {
601                 timeout = jiffies + 100;
602                 while (!w9966_i2c_getscl(cam)) {
603                         if (time_after(jiffies, timeout))
604                                 return -1;
605                 }
606         }
607         return 0;
608 }
609
610 // Get peripheral data line
611 // Expects a claimed pdev.
612 static inline int w9966_i2c_getsda(struct w9966_dev* cam)
613 {
614         const unsigned char state = w9966_rReg(cam, 0x18);
615         return ((state & W9966_I2C_R_DATA) > 0);
616 }
617
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)
621 {
622         int i;
623         for (i = 7; i >= 0; i--)
624         {
625                 w9966_i2c_setsda(cam, (data >> i) & 0x01);
626
627                 if (w9966_i2c_setscl(cam, 1) == -1)
628                         return -1;
629                 w9966_i2c_setscl(cam, 0);
630         }
631
632         w9966_i2c_setsda(cam, 1);
633
634         if (w9966_i2c_setscl(cam, 1) == -1)
635                 return -1;
636         w9966_i2c_setscl(cam, 0);
637
638         return 0;
639 }
640
641 // Read a data byte with ack from the i2c-bus
642 // Expects a claimed pdev. -1 on error
643 #if 0
644 static int w9966_i2c_rbyte(struct w9966_dev* cam)
645 {
646         unsigned char data = 0x00;
647         int i;
648
649         w9966_i2c_setsda(cam, 1);
650
651         for (i = 0; i < 8; i++)
652         {
653                 if (w9966_i2c_setscl(cam, 1) == -1)
654                         return -1;
655                 data = data << 1;
656                 if (w9966_i2c_getsda(cam))
657                         data |= 0x01;
658
659                 w9966_i2c_setscl(cam, 0);
660         }
661         return data;
662 }
663 #endif
664
665 // Read a register from the i2c device.
666 // Expects claimed pdev. -1 on error
667 #if 0
668 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
669 {
670         int data;
671
672         w9966_i2c_setsda(cam, 0);
673         w9966_i2c_setscl(cam, 0);
674
675         if (
676                 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
677                 w9966_i2c_wbyte(cam, reg) == -1
678         )
679                 return -1;
680
681         w9966_i2c_setsda(cam, 1);
682         if (w9966_i2c_setscl(cam, 1) == -1)
683                 return -1;
684         w9966_i2c_setsda(cam, 0);
685         w9966_i2c_setscl(cam, 0);
686
687         if (
688                 w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 ||
689                 (data = w9966_i2c_rbyte(cam)) == -1
690         )
691                 return -1;
692
693         w9966_i2c_setsda(cam, 0);
694
695         if (w9966_i2c_setscl(cam, 1) == -1)
696                 return -1;
697         w9966_i2c_setsda(cam, 1);
698
699         return data;
700 }
701 #endif
702
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)
706 {
707         w9966_i2c_setsda(cam, 0);
708         w9966_i2c_setscl(cam, 0);
709
710         if (
711                 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
712                 w9966_i2c_wbyte(cam, reg) == -1 ||
713                 w9966_i2c_wbyte(cam, data) == -1
714         )
715                 return -1;
716
717         w9966_i2c_setsda(cam, 0);
718         if (w9966_i2c_setscl(cam, 1) == -1)
719                 return -1;
720
721         w9966_i2c_setsda(cam, 1);
722
723         return 0;
724 }
725
726 /*
727  *      Video4linux interfacing
728  */
729
730 static int w9966_v4l_do_ioctl(struct inode *inode, struct file *file,
731                               unsigned int cmd, void *arg)
732 {
733         struct w9966_dev *cam = video_drvdata(file);
734
735         switch(cmd)
736         {
737         case VIDIOCGCAP:
738         {
739                 static struct video_capability vcap = {
740                         .name      = W9966_DRIVERNAME,
741                         .type      = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
742                         .channels  = 1,
743                         .maxwidth  = W9966_WND_MAX_W,
744                         .maxheight = W9966_WND_MAX_H,
745                         .minwidth  = 2,
746                         .minheight = 1,
747                 };
748                 struct video_capability *cap = arg;
749                 *cap = vcap;
750                 return 0;
751         }
752         case VIDIOCGCHAN:
753         {
754                 struct video_channel *vch = arg;
755                 if(vch->channel != 0)   // We only support one channel (#0)
756                         return -EINVAL;
757                 memset(vch,0,sizeof(*vch));
758                 strcpy(vch->name, "CCD-input");
759                 vch->type = VIDEO_TYPE_CAMERA;
760                 return 0;
761         }
762         case VIDIOCSCHAN:
763         {
764                 struct video_channel *vch = arg;
765                 if(vch->channel != 0)
766                         return -EINVAL;
767                 return 0;
768         }
769         case VIDIOCGTUNER:
770         {
771                 struct video_tuner *vtune = arg;
772                 if(vtune->tuner != 0)
773                         return -EINVAL;
774                 strcpy(vtune->name, "no tuner");
775                 vtune->rangelow = 0;
776                 vtune->rangehigh = 0;
777                 vtune->flags = VIDEO_TUNER_NORM;
778                 vtune->mode = VIDEO_MODE_AUTO;
779                 vtune->signal = 0xffff;
780                 return 0;
781         }
782         case VIDIOCSTUNER:
783         {
784                 struct video_tuner *vtune = arg;
785                 if (vtune->tuner != 0)
786                         return -EINVAL;
787                 if (vtune->mode != VIDEO_MODE_AUTO)
788                         return -EINVAL;
789                 return 0;
790         }
791         case VIDIOCGPICT:
792         {
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
798                         0x8000,                 // whiteness
799                         16, VIDEO_PALETTE_YUV422// bpp, palette format
800                 };
801                 struct video_picture *pic = arg;
802                 *pic = vpic;
803                 return 0;
804         }
805         case VIDIOCSPICT:
806         {
807                 struct video_picture *vpic = arg;
808                 if (vpic->depth != 16 || (vpic->palette != VIDEO_PALETTE_YUV422 && vpic->palette != VIDEO_PALETTE_YUYV))
809                         return -EINVAL;
810
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;
815
816                 w9966_pdev_claim(cam);
817
818                 if (
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
823                 ) {
824                         w9966_pdev_release(cam);
825                         return -EIO;
826                 }
827
828                 w9966_pdev_release(cam);
829                 return 0;
830         }
831         case VIDIOCSWIN:
832         {
833                 int ret;
834                 struct video_window *vwin = arg;
835
836                 if (vwin->flags != 0)
837                         return -EINVAL;
838                 if (vwin->clipcount != 0)
839                         return -EINVAL;
840                 if (vwin->width < 2 || vwin->width > W9966_WND_MAX_W)
841                         return -EINVAL;
842                 if (vwin->height < 1 || vwin->height > W9966_WND_MAX_H)
843                         return -EINVAL;
844
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);
849
850                 if (ret != 0) {
851                         DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");
852                         return -EIO;
853                 }
854
855                 return 0;
856         }
857         case VIDIOCGWIN:
858         {
859                 struct video_window *vwin = arg;
860                 memset(vwin, 0, sizeof(*vwin));
861                 vwin->width = cam->width;
862                 vwin->height = cam->height;
863                 return 0;
864         }
865         // Unimplemented
866         case VIDIOCCAPTURE:
867         case VIDIOCGFBUF:
868         case VIDIOCSFBUF:
869         case VIDIOCKEY:
870         case VIDIOCGFREQ:
871         case VIDIOCSFREQ:
872         case VIDIOCGAUDIO:
873         case VIDIOCSAUDIO:
874                 return -EINVAL;
875         default:
876                 return -ENOIOCTLCMD;
877         }
878         return 0;
879 }
880
881 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
882                            unsigned int cmd, unsigned long arg)
883 {
884         return video_usercopy(inode, file, cmd, arg, w9966_v4l_do_ioctl);
885 }
886
887 // Capture data
888 static ssize_t w9966_v4l_read(struct file *file, char  __user *buf,
889                               size_t count, loff_t *ppos)
890 {
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;
895         unsigned char *tbuf;
896
897         // Why would anyone want more than this??
898         if (count > cam->width * cam->height * 2)
899                 return -EINVAL;
900
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
905
906         // write special capture-addr and negotiate into data transfer
907         if (
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  )
911         ) {
912                 w9966_pdev_release(cam);
913                 return -EFAULT;
914         }
915
916         tbuf = kmalloc(W9966_RBUFFER, GFP_KERNEL);
917         if (tbuf == NULL) {
918                 count = -ENOMEM;
919                 goto out;
920         }
921
922         while(dleft > 0)
923         {
924                 unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
925
926                 if (parport_read(cam->pport, tbuf, tsize) < tsize) {
927                         count = -EFAULT;
928                         goto out;
929                 }
930                 if (copy_to_user(dest, tbuf, tsize) != 0) {
931                         count = -EFAULT;
932                         goto out;
933                 }
934                 dest += tsize;
935                 dleft -= tsize;
936         }
937
938         w9966_wReg(cam, 0x01, 0x18);    // Disable capture
939
940 out:
941         kfree(tbuf);
942         w9966_pdev_release(cam);
943
944         return count;
945 }
946
947
948 // Called once for every parport on init
949 static void w9966_attach(struct parport *port)
950 {
951         int i;
952
953         for (i = 0; i < W9966_MAXCAMS; i++)
954         {
955                 if (w9966_cams[i].dev_state != 0)       // Cam is already assigned
956                         continue;
957                 if (
958                         strcmp(pardev[i], "aggressive") == 0 ||
959                         strcmp(pardev[i], port->name) == 0
960                 ) {
961                         if (w9966_init(&w9966_cams[i], port) != 0)
962                         w9966_term(&w9966_cams[i]);
963                         break;  // return
964                 }
965         }
966 }
967
968 // Called once for every parport on termination
969 static void w9966_detach(struct parport *port)
970 {
971         int i;
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]);
975 }
976
977
978 static struct parport_driver w9966_ppd = {
979         .name = W9966_DRIVERNAME,
980         .attach = w9966_attach,
981         .detach = w9966_detach,
982 };
983
984 // Module entry point
985 static int __init w9966_mod_init(void)
986 {
987         int i;
988         for (i = 0; i < W9966_MAXCAMS; i++)
989                 w9966_cams[i].dev_state = 0;
990
991         return parport_register_driver(&w9966_ppd);
992 }
993
994 // Module cleanup
995 static void __exit w9966_mod_term(void)
996 {
997         parport_unregister_driver(&w9966_ppd);
998 }
999
1000 module_init(w9966_mod_init);
1001 module_exit(w9966_mod_term);