git.oblomov.eu Git - linux-2.6/blob - 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);