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