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