[PATCH] v4l: add TerraTec Cinergy 1400 DVB-T
[linux-2.6] / 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/videodev.h>
61 #include <linux/parport.h>
62
63 //#define DEBUG                         // Undef me for production
64
65 #ifdef DEBUG
66 #define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __FUNCTION__ , ##a)
67 #else
68 #define DPRINTF(x...)
69 #endif
70
71 /*
72  *      Defines, simple typedefs etc.
73  */
74
75 #define W9966_DRIVERNAME        "W9966CF Webcam"
76 #define W9966_MAXCAMS           4       // Maximum number of cameras
77 #define W9966_RBUFFER           2048    // Read buffer (must be an even number)
78 #define W9966_SRAMSIZE          131072  // 128kb
79 #define W9966_SRAMID            0x02    // check w9966cf.pdf
80
81 // Empirically determined window limits
82 #define W9966_WND_MIN_X         16
83 #define W9966_WND_MIN_Y         14
84 #define W9966_WND_MAX_X         705
85 #define W9966_WND_MAX_Y         253
86 #define W9966_WND_MAX_W         (W9966_WND_MAX_X - W9966_WND_MIN_X)
87 #define W9966_WND_MAX_H         (W9966_WND_MAX_Y - W9966_WND_MIN_Y)
88
89 // Keep track of our current state
90 #define W9966_STATE_PDEV        0x01
91 #define W9966_STATE_CLAIMED     0x02
92 #define W9966_STATE_VDEV        0x04
93
94 #define W9966_I2C_W_ID          0x48
95 #define W9966_I2C_R_ID          0x49
96 #define W9966_I2C_R_DATA        0x08
97 #define W9966_I2C_R_CLOCK       0x04
98 #define W9966_I2C_W_DATA        0x02
99 #define W9966_I2C_W_CLOCK       0x01
100
101 struct w9966_dev {
102         unsigned char dev_state;
103         unsigned char i2c_state;
104         unsigned short ppmode;
105         struct parport* pport;
106         struct pardevice* pdev;
107         struct video_device vdev;
108         unsigned short width;
109         unsigned short height;
110         unsigned char brightness;
111         signed char contrast;
112         signed char color;
113         signed char hue;
114 };
115
116 /*
117  *      Module specific properties
118  */
119
120 MODULE_AUTHOR("Jakob Kemi <jakob.kemi@post.utfors.se>");
121 MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (0.32)");
122 MODULE_LICENSE("GPL");
123
124
125 #ifdef MODULE
126 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = ""};
127 #else
128 static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "aggressive"};
129 #endif
130 module_param_array(pardev, charp, NULL, 0);
131 MODULE_PARM_DESC(pardev, "pardev: where to search for\n\
132 \teach camera. 'aggressive' means brute-force search.\n\
133 \tEg: >pardev=parport3,aggressive,parport2,parport1< would assign\n\
134 \tcam 1 to parport3 and search every parport for cam 2 etc...");
135
136 static int parmode = 0;
137 module_param(parmode, int, 0);
138 MODULE_PARM_DESC(parmode, "parmode: transfer mode (0=auto, 1=ecp, 2=epp");
139
140 static int video_nr = -1;
141 module_param(video_nr, int, 0);
142
143 /*
144  *      Private data
145  */
146
147 static struct w9966_dev w9966_cams[W9966_MAXCAMS];
148
149 /*
150  *      Private function declares
151  */
152
153 static inline void w9966_setState(struct w9966_dev* cam, int mask, int val);
154 static inline int  w9966_getState(struct w9966_dev* cam, int mask, int val);
155 static inline void w9966_pdev_claim(struct w9966_dev *vdev);
156 static inline void w9966_pdev_release(struct w9966_dev *vdev);
157
158 static int w9966_rReg(struct w9966_dev* cam, int reg);
159 static int w9966_wReg(struct w9966_dev* cam, int reg, int data);
160 #if 0
161 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);
162 #endif
163 static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data);
164 static int w9966_findlen(int near, int size, int maxlen);
165 static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor);
166 static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h);
167
168 static int  w9966_init(struct w9966_dev* cam, struct parport* port);
169 static void w9966_term(struct w9966_dev* cam);
170
171 static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state);
172 static inline int  w9966_i2c_setscl(struct w9966_dev* cam, int state);
173 static inline int  w9966_i2c_getsda(struct w9966_dev* cam);
174 static inline int  w9966_i2c_getscl(struct w9966_dev* cam);
175 static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);
176 #if 0
177 static int w9966_i2c_rbyte(struct w9966_dev* cam);
178 #endif
179
180 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
181                            unsigned int cmd, unsigned long arg);
182 static ssize_t w9966_v4l_read(struct file *file, char __user *buf,
183                               size_t count, loff_t *ppos);
184
185 static struct file_operations w9966_fops = {
186         .owner          = THIS_MODULE,
187         .open           = video_exclusive_open,
188         .release        = video_exclusive_release,
189         .ioctl          = w9966_v4l_ioctl,
190         .read           = w9966_v4l_read,
191         .llseek         = no_llseek,
192 };
193 static struct video_device w9966_template = {
194         .owner          = THIS_MODULE,
195         .name           = W9966_DRIVERNAME,
196         .type           = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
197         .hardware       = VID_HARDWARE_W9966,
198         .fops           = &w9966_fops,
199 };
200
201 /*
202  *      Private function defines
203  */
204
205
206 // Set camera phase flags, so we know what to uninit when terminating 
207 static inline void w9966_setState(struct w9966_dev* cam, int mask, int val)
208 {
209         cam->dev_state = (cam->dev_state & ~mask) ^ val;
210 }
211
212 // Get camera phase flags
213 static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)
214 {
215         return ((cam->dev_state & mask) == val);
216 }
217
218 // Claim parport for ourself
219 static inline void w9966_pdev_claim(struct w9966_dev* cam)
220 {
221         if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))
222                 return;
223         parport_claim_or_block(cam->pdev);
224         w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);
225 }
226
227 // Release parport for others to use
228 static inline void w9966_pdev_release(struct w9966_dev* cam)
229 {
230         if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))
231                 return;
232         parport_release(cam->pdev);
233         w9966_setState(cam, W9966_STATE_CLAIMED, 0);
234 }
235  
236 // Read register from W9966 interface-chip
237 // Expects a claimed pdev
238 // -1 on error, else register data (byte)
239 static int w9966_rReg(struct w9966_dev* cam, int reg)
240 {
241         // ECP, read, regtransfer, REG, REG, REG, REG, REG
242         const unsigned char addr = 0x80 | (reg & 0x1f);
243         unsigned char val;
244         
245         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
246                 return -1;
247         if (parport_write(cam->pport, &addr, 1) != 1)
248                 return -1;
249         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
250                 return -1;
251         if (parport_read(cam->pport, &val, 1) != 1)
252                 return -1;
253
254         return val;
255 }
256
257 // Write register to W9966 interface-chip
258 // Expects a claimed pdev
259 // -1 on error
260 static int w9966_wReg(struct w9966_dev* cam, int reg, int data)
261 {
262         // ECP, write, regtransfer, REG, REG, REG, REG, REG
263         const unsigned char addr = 0xc0 | (reg & 0x1f);
264         const unsigned char val = data;
265         
266         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
267                 return -1;
268         if (parport_write(cam->pport, &addr, 1) != 1)
269                 return -1;
270         if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
271                 return -1;
272         if (parport_write(cam->pport, &val, 1) != 1)
273                 return -1;
274
275         return 0;
276 }
277
278 // Initialize camera device. Setup all internal flags, set a
279 // default video mode, setup ccd-chip, register v4l device etc..
280 // Also used for 'probing' of hardware.
281 // -1 on error
282 static int w9966_init(struct w9966_dev* cam, struct parport* port)
283 {
284         if (cam->dev_state != 0)
285                 return -1;
286         
287         cam->pport = port;
288         cam->brightness = 128;
289         cam->contrast = 64;
290         cam->color = 64;
291         cam->hue = 0;
292
293 // Select requested transfer mode
294         switch(parmode)
295         {
296         default:        // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)
297         case 0:
298                 if (port->modes & PARPORT_MODE_ECP)
299                         cam->ppmode = IEEE1284_MODE_ECP;
300                 else if (port->modes & PARPORT_MODE_EPP)
301                         cam->ppmode = IEEE1284_MODE_EPP;
302                 else
303                         cam->ppmode = IEEE1284_MODE_ECP;
304                 break;  
305         case 1:         // hw- or sw-ecp
306                 cam->ppmode = IEEE1284_MODE_ECP;
307                 break;
308         case 2:         // hw- or sw-epp
309                 cam->ppmode = IEEE1284_MODE_EPP;
310         break;
311         }
312         
313 // Tell the parport driver that we exists
314         cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL);
315         if (cam->pdev == NULL) {
316                 DPRINTF("parport_register_device() failed\n");
317                 return -1;
318         }
319         w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);
320
321         w9966_pdev_claim(cam);
322         
323 // Setup a default capture mode
324         if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {
325                 DPRINTF("w9966_setup() failed.\n");
326                 return -1;
327         }
328
329         w9966_pdev_release(cam);
330
331 // Fill in the video_device struct and register us to v4l
332         memcpy(&cam->vdev, &w9966_template, sizeof(struct video_device));
333         cam->vdev.priv = cam;
334
335         if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) == -1)                 
336                 return -1;
337         
338         w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);
339         
340         // All ok
341         printk(
342                 "w9966cf: Found and initialized a webcam on %s.\n",
343                 cam->pport->name
344         );
345         return 0;
346 }
347
348
349 // Terminate everything gracefully
350 static void w9966_term(struct w9966_dev* cam)
351 {
352 // Unregister from v4l
353         if (w9966_getState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV)) {
354                 video_unregister_device(&cam->vdev);
355                 w9966_setState(cam, W9966_STATE_VDEV, 0);
356         }
357
358 // Terminate from IEEE1284 mode and release pdev block
359         if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
360                 w9966_pdev_claim(cam);
361                 parport_negotiate(cam->pport, IEEE1284_MODE_COMPAT);
362                 w9966_pdev_release(cam);
363         }
364
365 // Unregister from parport
366         if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
367                 parport_unregister_device(cam->pdev);
368                 w9966_setState(cam, W9966_STATE_PDEV, 0);
369         }
370 }
371
372
373 // Find a good length for capture window (used both for W and H)
374 // A bit ugly but pretty functional. The capture length
375 // have to match the downscale
376 static int w9966_findlen(int near, int size, int maxlen)
377 {
378         int bestlen = size;
379         int besterr = abs(near - bestlen);
380         int len;
381
382         for(len = size+1;len < maxlen;len++)
383         {
384                 int err;
385                 if ( ((64*size) %len) != 0)
386                         continue;
387
388                 err = abs(near - len);
389
390                 // Only continue as long as we keep getting better values
391                 if (err > besterr)
392                         break;
393                 
394                 besterr = err;
395                 bestlen = len;
396         }
397
398         return bestlen;
399 }
400
401 // Modify capture window (if necessary) 
402 // and calculate downscaling
403 // Return -1 on error
404 static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor)
405 {
406         int maxlen = max - min;
407         int len = *end - *beg + 1;
408         int newlen = w9966_findlen(len, size, maxlen);
409         int err = newlen - len; 
410
411         // Check for bad format
412         if (newlen > maxlen || newlen < size)
413                 return -1;
414
415         // Set factor (6 bit fixed)
416         *factor = (64*size) / newlen;
417         if (*factor == 64)
418                 *factor = 0x00; // downscale is disabled
419         else
420                 *factor |= 0x80; // set downscale-enable bit
421
422         // Modify old beginning and end
423         *beg -= err / 2;
424         *end += err - (err / 2);
425
426         // Move window if outside borders
427         if (*beg < min) {
428                 *end += min - *beg;
429                 *beg += min - *beg;
430         }
431         if (*end > max) {
432                 *beg -= *end - max;
433                 *end -= *end - max;
434         }
435
436         return 0;
437 }
438
439 // Setup the cameras capture window etc.
440 // Expects a claimed pdev
441 // return -1 on error
442 static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h)
443 {
444         unsigned int i;
445         unsigned int enh_s, enh_e;
446         unsigned char scale_x, scale_y;
447         unsigned char regs[0x1c];
448         unsigned char saa7111_regs[] = {
449                 0x21, 0x00, 0xd8, 0x23, 0x00, 0x80, 0x80, 0x00,
450                 0x88, 0x10, 0x80, 0x40, 0x40, 0x00, 0x01, 0x00,
451                 0x48, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
452                 0x00, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0xc0
453         };
454         
455         
456         if (w*h*2 > W9966_SRAMSIZE)
457         {
458                 DPRINTF("capture window exceeds SRAM size!.\n");
459                 w = 200; h = 160;       // Pick default values
460         }
461
462         w &= ~0x1;
463         if (w < 2) w = 2;
464         if (h < 1) h = 1;
465         if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;
466         if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;
467
468         cam->width = w;
469         cam->height = h;
470
471         enh_s = 0;      
472         enh_e = w*h*2;
473         
474 // Modify capture window if necessary and calculate downscaling
475         if (
476                 w9966_calcscale(w, W9966_WND_MIN_X, W9966_WND_MAX_X, &x1, &x2, &scale_x) != 0 ||
477                 w9966_calcscale(h, W9966_WND_MIN_Y, W9966_WND_MAX_Y, &y1, &y2, &scale_y) != 0
478         ) return -1;
479
480         DPRINTF(
481                 "%dx%d, x: %d<->%d, y: %d<->%d, sx: %d/64, sy: %d/64.\n",
482                 w, h, x1, x2, y1, y2, scale_x&~0x80, scale_y&~0x80
483         );
484         
485 // Setup registers
486         regs[0x00] = 0x00;                      // Set normal operation
487         regs[0x01] = 0x18;                      // Capture mode
488         regs[0x02] = scale_y;                   // V-scaling
489         regs[0x03] = scale_x;                   // H-scaling
490         
491         // Capture window       
492         regs[0x04] = (x1 & 0x0ff);              // X-start (8 low bits)
493         regs[0x05] = (x1 & 0x300)>>8;           // X-start (2 high bits)
494         regs[0x06] = (y1 & 0x0ff);              // Y-start (8 low bits)
495         regs[0x07] = (y1 & 0x300)>>8;           // Y-start (2 high bits)
496         regs[0x08] = (x2 & 0x0ff);              // X-end (8 low bits)
497         regs[0x09] = (x2 & 0x300)>>8;           // X-end (2 high bits)
498         regs[0x0a] = (y2 & 0x0ff);              // Y-end (8 low bits)
499
500         regs[0x0c] = W9966_SRAMID;              // SRAM-banks (1x 128kb)
501         
502         // Enhancement layer
503         regs[0x0d] = (enh_s& 0x000ff);          // Enh. start (0-7)
504         regs[0x0e] = (enh_s& 0x0ff00)>>8;       // Enh. start (8-15)
505         regs[0x0f] = (enh_s& 0x70000)>>16;      // Enh. start (16-17/18??)
506         regs[0x10] = (enh_e& 0x000ff);          // Enh. end (0-7)
507         regs[0x11] = (enh_e& 0x0ff00)>>8;       // Enh. end (8-15)
508         regs[0x12] = (enh_e& 0x70000)>>16;      // Enh. end (16-17/18??)
509
510         // Misc
511         regs[0x13] = 0x40;                      // VEE control (raw 4:2:2)
512         regs[0x17] = 0x00;                      // ???
513         regs[0x18] = cam->i2c_state = 0x00;     // Serial bus
514         regs[0x19] = 0xff;                      // I/O port direction control
515         regs[0x1a] = 0xff;                      // I/O port data register
516         regs[0x1b] = 0x10;                      // ???
517         
518         // SAA7111 chip settings
519         saa7111_regs[0x0a] = cam->brightness;
520         saa7111_regs[0x0b] = cam->contrast;
521         saa7111_regs[0x0c] = cam->color;
522         saa7111_regs[0x0d] = cam->hue;
523
524 // Reset (ECP-fifo & serial-bus)
525         if (w9966_wReg(cam, 0x00, 0x03) == -1)
526                 return -1;
527
528 // Write regs to w9966cf chip
529         for (i = 0; i < 0x1c; i++)
530                 if (w9966_wReg(cam, i, regs[i]) == -1)
531                         return -1;
532
533 // Write regs to saa7111 chip
534         for (i = 0; i < 0x20; i++)
535                 if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
536                         return -1;
537
538         return 0;
539 }
540
541 /*
542  *      Ugly and primitive i2c protocol functions
543  */
544
545 // Sets the data line on the i2c bus.
546 // Expects a claimed pdev.
547 static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)
548 {
549         if (state)
550                 cam->i2c_state |= W9966_I2C_W_DATA;
551         else
552                 cam->i2c_state &= ~W9966_I2C_W_DATA;
553         
554         w9966_wReg(cam, 0x18, cam->i2c_state);
555         udelay(5);
556 }
557
558 // Get peripheral clock line
559 // Expects a claimed pdev.
560 static inline int w9966_i2c_getscl(struct w9966_dev* cam)
561 {
562         const unsigned char state = w9966_rReg(cam, 0x18);
563         return ((state & W9966_I2C_R_CLOCK) > 0);
564 }
565
566 // Sets the clock line on the i2c bus.
567 // Expects a claimed pdev. -1 on error
568 static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)
569 {
570         unsigned long timeout;
571
572         if (state)
573                 cam->i2c_state |= W9966_I2C_W_CLOCK;
574         else
575                 cam->i2c_state &= ~W9966_I2C_W_CLOCK;
576
577         w9966_wReg(cam, 0x18, cam->i2c_state);
578         udelay(5);
579         
580         // we go to high, we also expect the peripheral to ack.
581         if (state) {
582                 timeout = jiffies + 100;
583                 while (!w9966_i2c_getscl(cam)) {
584                         if (time_after(jiffies, timeout))
585                                 return -1;
586                 }
587         }
588         return 0;
589 }
590
591 // Get peripheral data line
592 // Expects a claimed pdev.
593 static inline int w9966_i2c_getsda(struct w9966_dev* cam)
594 {
595         const unsigned char state = w9966_rReg(cam, 0x18);
596         return ((state & W9966_I2C_R_DATA) > 0);
597 }
598
599 // Write a byte with ack to the i2c bus.
600 // Expects a claimed pdev. -1 on error
601 static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)
602 {
603         int i;
604         for (i = 7; i >= 0; i--)
605         {
606                 w9966_i2c_setsda(cam, (data >> i) & 0x01);
607
608                 if (w9966_i2c_setscl(cam, 1) == -1)
609                         return -1;                      
610                 w9966_i2c_setscl(cam, 0);
611         }
612
613         w9966_i2c_setsda(cam, 1);
614         
615         if (w9966_i2c_setscl(cam, 1) == -1)
616                 return -1;
617         w9966_i2c_setscl(cam, 0);
618         
619         return 0;
620 }
621
622 // Read a data byte with ack from the i2c-bus
623 // Expects a claimed pdev. -1 on error
624 #if 0
625 static int w9966_i2c_rbyte(struct w9966_dev* cam)
626 {
627         unsigned char data = 0x00;
628         int i;  
629         
630         w9966_i2c_setsda(cam, 1);
631
632         for (i = 0; i < 8; i++)
633         {
634                 if (w9966_i2c_setscl(cam, 1) == -1)
635                         return -1;
636                 data = data << 1;
637                 if (w9966_i2c_getsda(cam))
638                         data |= 0x01;
639                 
640                 w9966_i2c_setscl(cam, 0);
641         }
642         return data;
643 }
644 #endif
645
646 // Read a register from the i2c device.
647 // Expects claimed pdev. -1 on error
648 #if 0
649 static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
650 {
651         int data;
652
653         w9966_i2c_setsda(cam, 0);
654         w9966_i2c_setscl(cam, 0);
655
656         if (
657                 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
658                 w9966_i2c_wbyte(cam, reg) == -1
659         )
660                 return -1;
661
662         w9966_i2c_setsda(cam, 1);
663         if (w9966_i2c_setscl(cam, 1) == -1)
664                 return -1;
665         w9966_i2c_setsda(cam, 0);
666         w9966_i2c_setscl(cam, 0);
667
668         if (
669                 w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 ||
670                 (data = w9966_i2c_rbyte(cam)) == -1
671         )
672                 return -1;
673
674         w9966_i2c_setsda(cam, 0);
675         
676         if (w9966_i2c_setscl(cam, 1) == -1)
677                 return -1;
678         w9966_i2c_setsda(cam, 1);
679         
680         return data;
681 }
682 #endif
683
684 // Write a register to the i2c device.
685 // Expects claimed pdev. -1 on error
686 static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
687 {
688         w9966_i2c_setsda(cam, 0);
689         w9966_i2c_setscl(cam, 0);
690
691         if (
692                 w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
693                 w9966_i2c_wbyte(cam, reg) == -1 ||
694                 w9966_i2c_wbyte(cam, data) == -1
695         )
696                 return -1;
697
698         w9966_i2c_setsda(cam, 0);
699         if (w9966_i2c_setscl(cam, 1) == -1)
700                 return -1;
701                 
702         w9966_i2c_setsda(cam, 1);
703
704         return 0;
705 }
706
707 /*
708  *      Video4linux interfacing
709  */
710
711 static int w9966_v4l_do_ioctl(struct inode *inode, struct file *file,
712                               unsigned int cmd, void *arg)
713 {
714         struct video_device *vdev = video_devdata(file);
715         struct w9966_dev *cam = vdev->priv;
716         
717         switch(cmd)
718         {
719         case VIDIOCGCAP:
720         {
721                 static struct video_capability vcap = {
722                         .name      = W9966_DRIVERNAME,
723                         .type      = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
724                         .channels  = 1,
725                         .maxwidth  = W9966_WND_MAX_W,
726                         .maxheight = W9966_WND_MAX_H,
727                         .minwidth  = 2,
728                         .minheight = 1,
729                 };
730                 struct video_capability *cap = arg;
731                 *cap = vcap;
732                 return 0;
733         }
734         case VIDIOCGCHAN:
735         {
736                 struct video_channel *vch = arg;
737                 if(vch->channel != 0)   // We only support one channel (#0)
738                         return -EINVAL;
739                 memset(vch,0,sizeof(*vch));
740                 strcpy(vch->name, "CCD-input");
741                 vch->type = VIDEO_TYPE_CAMERA;
742                 return 0;
743         }
744         case VIDIOCSCHAN:
745         {
746                 struct video_channel *vch = arg;
747                 if(vch->channel != 0)
748                         return -EINVAL;
749                 return 0;
750         }
751         case VIDIOCGTUNER:
752         {
753                 struct video_tuner *vtune = arg;
754                 if(vtune->tuner != 0)
755                         return -EINVAL;
756                 strcpy(vtune->name, "no tuner");
757                 vtune->rangelow = 0;
758                 vtune->rangehigh = 0;
759                 vtune->flags = VIDEO_TUNER_NORM;
760                 vtune->mode = VIDEO_MODE_AUTO;
761                 vtune->signal = 0xffff;
762                 return 0;
763         }
764         case VIDIOCSTUNER:
765         {
766                 struct video_tuner *vtune = arg;
767                 if (vtune->tuner != 0)
768                         return -EINVAL;
769                 if (vtune->mode != VIDEO_MODE_AUTO)
770                         return -EINVAL;
771                 return 0;
772         }
773         case VIDIOCGPICT:
774         {
775                 struct video_picture vpic = {
776                         cam->brightness << 8,   // brightness
777                         (cam->hue + 128) << 8,  // hue
778                         cam->color << 9,        // color
779                         cam->contrast << 9,     // contrast
780                         0x8000,                 // whiteness
781                         16, VIDEO_PALETTE_YUV422// bpp, palette format
782                 };
783                 struct video_picture *pic = arg;
784                 *pic = vpic;
785                 return 0;
786         }
787         case VIDIOCSPICT:
788         {
789                 struct video_picture *vpic = arg;
790                 if (vpic->depth != 16 || vpic->palette != VIDEO_PALETTE_YUV422)
791                         return -EINVAL;
792                         
793                 cam->brightness = vpic->brightness >> 8;
794                 cam->hue = (vpic->hue >> 8) - 128;
795                 cam->color = vpic->colour >> 9;
796                 cam->contrast = vpic->contrast >> 9;
797
798                 w9966_pdev_claim(cam);
799                 
800                 if (
801                         w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 ||
802                         w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 ||
803                         w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 ||
804                         w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1
805                 ) {
806                         w9966_pdev_release(cam);
807                         return -EIO;
808                 }
809                 
810                 w9966_pdev_release(cam);
811                 return 0;
812         }
813         case VIDIOCSWIN:
814         {
815                 int ret;
816                 struct video_window *vwin = arg;
817                 
818                 if (vwin->flags != 0)
819                         return -EINVAL;
820                 if (vwin->clipcount != 0)
821                         return -EINVAL;
822                 if (vwin->width < 2 || vwin->width > W9966_WND_MAX_W)
823                         return -EINVAL;         
824                 if (vwin->height < 1 || vwin->height > W9966_WND_MAX_H)
825                         return -EINVAL;
826
827                 // Update camera regs
828                 w9966_pdev_claim(cam);
829                 ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin->width, vwin->height);
830                 w9966_pdev_release(cam);
831                 
832                 if (ret != 0) {
833                         DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");
834                         return -EIO;
835                 }
836                 
837                 return 0;
838         }
839         case VIDIOCGWIN:
840         {
841                 struct video_window *vwin = arg;
842                 memset(vwin, 0, sizeof(*vwin));
843                 vwin->width = cam->width;
844                 vwin->height = cam->height;
845                 return 0;
846         }
847         // Unimplemented
848         case VIDIOCCAPTURE:     
849         case VIDIOCGFBUF:
850         case VIDIOCSFBUF:
851         case VIDIOCKEY:
852         case VIDIOCGFREQ:
853         case VIDIOCSFREQ:
854         case VIDIOCGAUDIO:
855         case VIDIOCSAUDIO:
856                 return -EINVAL;
857         default:
858                 return -ENOIOCTLCMD;
859         }
860         return 0;
861 }
862
863 static int w9966_v4l_ioctl(struct inode *inode, struct file *file,
864                            unsigned int cmd, unsigned long arg)
865 {
866         return video_usercopy(inode, file, cmd, arg, w9966_v4l_do_ioctl);
867 }
868
869 // Capture data
870 static ssize_t w9966_v4l_read(struct file *file, char  __user *buf,
871                               size_t count, loff_t *ppos)
872 {
873         struct video_device *vdev = video_devdata(file);
874         struct w9966_dev *cam = vdev->priv;
875         unsigned char addr = 0xa0;      // ECP, read, CCD-transfer, 00000
876         unsigned char __user *dest = (unsigned char __user *)buf;
877         unsigned long dleft = count;
878         unsigned char *tbuf;
879         
880         // Why would anyone want more than this??
881         if (count > cam->width * cam->height * 2)
882                 return -EINVAL;
883         
884         w9966_pdev_claim(cam);
885         w9966_wReg(cam, 0x00, 0x02);    // Reset ECP-FIFO buffer
886         w9966_wReg(cam, 0x00, 0x00);    // Return to normal operation
887         w9966_wReg(cam, 0x01, 0x98);    // Enable capture
888
889         // write special capture-addr and negotiate into data transfer  
890         if (
891                 (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_ADDR) != 0  )||
892                 (parport_write(cam->pport, &addr, 1) != 1                                               )||
893                 (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_DATA) != 0  )
894         ) {
895                 w9966_pdev_release(cam);
896                 return -EFAULT;
897         }
898
899         tbuf = kmalloc(W9966_RBUFFER, GFP_KERNEL);
900         if (tbuf == NULL) {
901                 count = -ENOMEM;
902                 goto out;
903         }
904
905         while(dleft > 0)
906         {
907                 unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
908         
909                 if (parport_read(cam->pport, tbuf, tsize) < tsize) {
910                         count = -EFAULT;
911                         goto out;
912                 }
913                 if (copy_to_user(dest, tbuf, tsize) != 0) {
914                         count = -EFAULT;
915                         goto out;
916                 }
917                 dest += tsize;
918                 dleft -= tsize;
919         }
920
921         w9966_wReg(cam, 0x01, 0x18);    // Disable capture
922
923 out:
924         kfree(tbuf);
925         w9966_pdev_release(cam);
926
927         return count;
928 }
929
930
931 // Called once for every parport on init
932 static void w9966_attach(struct parport *port)
933 {
934         int i;
935         
936         for (i = 0; i < W9966_MAXCAMS; i++)
937         {
938                 if (w9966_cams[i].dev_state != 0)       // Cam is already assigned
939                         continue;
940                 if (
941                         strcmp(pardev[i], "aggressive") == 0 ||
942                         strcmp(pardev[i], port->name) == 0
943                 ) {
944                         if (w9966_init(&w9966_cams[i], port) != 0)
945                         w9966_term(&w9966_cams[i]);
946                         break;  // return
947                 }
948         }
949 }
950
951 // Called once for every parport on termination
952 static void w9966_detach(struct parport *port)
953 {
954         int i;
955         for (i = 0; i < W9966_MAXCAMS; i++)
956         if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)
957                 w9966_term(&w9966_cams[i]);
958 }
959
960
961 static struct parport_driver w9966_ppd = {
962         .name = W9966_DRIVERNAME,
963         .attach = w9966_attach,
964         .detach = w9966_detach,
965 };
966
967 // Module entry point
968 static int __init w9966_mod_init(void)
969 {
970         int i;
971         for (i = 0; i < W9966_MAXCAMS; i++)
972                 w9966_cams[i].dev_state = 0;
973
974         return parport_register_driver(&w9966_ppd);
975 }
976
977 // Module cleanup
978 static void __exit w9966_mod_term(void)
979 {
980         parport_unregister_driver(&w9966_ppd);
981 }
982
983 module_init(w9966_mod_init);
984 module_exit(w9966_mod_term);