linux-cvs-patches
[Top] [All Lists]

CVS Update@linux-mips.org: linux

To: linux-cvs-patches@linux-mips.org
Subject: CVS Update@linux-mips.org: linux
From: ladis@linux-mips.org
Date: Thu, 01 Sep 2005 16:07:41 +0100
Reply-to: linux-mips@linux-mips.org
Sender: linux-cvs-patches-bounce@linux-mips.org
CVSROOT:        /home/cvs
Module name:    linux
Changes by:     ladis@ftp.linux-mips.org        05/09/01 16:07:34

Modified files:
        drivers/media/video: indycam.c indycam.h saa7191.c saa7191.h 
                             vino.c 

Log message:
        VINO driver version 0.0.5.

diff -urN linux/drivers/media/video/indycam.c 
linux/drivers/media/video/indycam.c
--- linux/drivers/media/video/indycam.c 2005/08/10 16:38:59     1.2
+++ linux/drivers/media/video/indycam.c 2005/09/01 15:07:34     1.3
@@ -27,15 +27,15 @@
 
 #include "indycam.h"
 
-//#define INDYCAM_DEBUG
-
-#define INDYCAM_MODULE_VERSION "0.0.3"
+#define INDYCAM_MODULE_VERSION "0.0.5"
 
 MODULE_DESCRIPTION("SGI IndyCam driver");
 MODULE_VERSION(INDYCAM_MODULE_VERSION);
 MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
 MODULE_LICENSE("GPL");
 
+// #define INDYCAM_DEBUG
+
 #ifdef INDYCAM_DEBUG
 #define dprintk(x...) printk("IndyCam: " x);
 #define indycam_regdump(client) indycam_regdump_debug(client)
@@ -48,14 +48,14 @@
 
 struct indycam {
        struct i2c_client *client;
-       int version;
+       u8 version;
 };
 
 static struct i2c_driver i2c_driver_indycam;
 
-static const unsigned char initseq[] = {
+static const u8 initseq[] = {
        INDYCAM_CONTROL_AGCENA,         /* INDYCAM_CONTROL */
-       INDYCAM_SHUTTER_DEFAULT,        /* INDYCAM_SHUTTER */
+       INDYCAM_SHUTTER_60,             /* INDYCAM_SHUTTER */
        INDYCAM_GAIN_DEFAULT,           /* INDYCAM_GAIN */
        0x00,                           /* INDYCAM_BRIGHTNESS (read-only) */
        INDYCAM_RED_BALANCE_DEFAULT,    /* INDYCAM_RED_BALANCE */
@@ -66,12 +66,11 @@
 
 /* IndyCam register handling */
 
-static int indycam_read_reg(struct i2c_client *client, unsigned char reg,
-                            unsigned char *value)
+static int indycam_read_reg(struct i2c_client *client, u8 reg, u8 *value)
 {
        int ret;
 
-       if (reg == INDYCAM_RESET) {
+       if (reg == INDYCAM_REG_RESET) {
                dprintk("indycam_read_reg(): "
                        "skipping write-only register %d\n", reg);
                *value = 0;
@@ -79,24 +78,24 @@
        }
 
        ret = i2c_smbus_read_byte_data(client, reg);
+
        if (ret < 0) {
                printk(KERN_ERR "IndyCam: indycam_read_reg(): read failed, "
                       "register = 0x%02x\n", reg);
                return ret;
        }
 
-       *value = (unsigned char)ret;
+       *value = (u8)ret;
 
        return 0;
 }
 
-static int indycam_write_reg(struct i2c_client *client, unsigned char reg,
-                            unsigned char value)
+static int indycam_write_reg(struct i2c_client *client, u8 reg, u8 value)
 {
        int err;
 
-       if ((reg == INDYCAM_BRIGHTNESS)
-           || (reg == INDYCAM_VERSION)) {
+       if ((reg == INDYCAM_REG_BRIGHTNESS)
+           || (reg == INDYCAM_REG_VERSION)) {
                dprintk("indycam_write_reg(): "
                        "skipping read-only register %d\n", reg);
                return 0;
@@ -104,6 +103,7 @@
 
        dprintk("Writing Reg %d = 0x%02x\n", reg, value);
        err = i2c_smbus_write_byte_data(client, reg, value);
+
        if (err) {
                printk(KERN_ERR "IndyCam: indycam_write_reg(): write failed, "
                       "register = 0x%02x, value = 0x%02x\n", reg, value);
@@ -111,13 +111,12 @@
        return err;
 }
 
-static int indycam_write_block(struct i2c_client *client, unsigned char reg,
-                               unsigned char length, unsigned char *data)
+static int indycam_write_block(struct i2c_client *client, u8 reg,
+                              u8 length, u8 *data)
 {
-       unsigned char i;
-       int err;
+       int i, err;
 
-       for (i = reg; i < length; i++) {
+       for (i = 0; i < length; i++) {
                err = indycam_write_reg(client, reg + i, data[i]);
                if (err)
                        return err;
@@ -132,7 +131,7 @@
 static void indycam_regdump_debug(struct i2c_client *client)
 {
        int i;
-       unsigned char val;
+       u8 val;
 
        for (i = 0; i < 9; i++) {
                indycam_read_reg(client, i, &val);
@@ -141,76 +140,144 @@
 }
 #endif
 
-static int indycam_get_controls(struct i2c_client *client,
-                               struct indycam_control *ctrl)
+static int indycam_get_control(struct i2c_client *client,
+                              struct indycam_control *ctrl)
 {
-       unsigned char ctrl_reg;
+       struct indycam *camera = i2c_get_clientdata(client);
+       u8 reg;
+       int ret = 0;
 
-       indycam_read_reg(client, INDYCAM_CONTROL, &ctrl_reg);
-       ctrl->agc = (ctrl_reg & INDYCAM_CONTROL_AGCENA)
-               ? INDYCAM_VALUE_ENABLED
-               : INDYCAM_VALUE_DISABLED;
-       ctrl->awb = (ctrl_reg & INDYCAM_CONTROL_AWBCTL)
-               ? INDYCAM_VALUE_ENABLED
-               : INDYCAM_VALUE_DISABLED;
-       indycam_read_reg(client, INDYCAM_SHUTTER,
-                        (unsigned char *)&ctrl->shutter);
-       indycam_read_reg(client, INDYCAM_GAIN,
-                        (unsigned char *)&ctrl->gain);
-       indycam_read_reg(client, INDYCAM_RED_BALANCE,
-                        (unsigned char *)&ctrl->red_balance);
-       indycam_read_reg(client, INDYCAM_BLUE_BALANCE,
-                        (unsigned char *)&ctrl->blue_balance);
-       indycam_read_reg(client, INDYCAM_RED_SATURATION,
-                        (unsigned char *)&ctrl->red_saturation);
-       indycam_read_reg(client, INDYCAM_BLUE_SATURATION,
-                        (unsigned char *)&ctrl->blue_saturation);
-       indycam_read_reg(client, INDYCAM_GAMMA,
-                        (unsigned char *)&ctrl->gamma);
+       switch (ctrl->type) {
+       case INDYCAM_CONTROL_AGC:
+       case INDYCAM_CONTROL_AWB:
+               ret = indycam_read_reg(client, INDYCAM_REG_CONTROL, &reg);
+               if (ret)
+                       return -EIO;
+               if (ctrl->type == INDYCAM_CONTROL_AGC)
+                       ctrl->value = (reg & INDYCAM_CONTROL_AGCENA)
+                               ? 1 : 0;
+               else
+                       ctrl->value = (reg & INDYCAM_CONTROL_AWBCTL)
+                               ? 1 : 0;
+               break;
+       case INDYCAM_CONTROL_SHUTTER:
+               ret = indycam_read_reg(client, INDYCAM_REG_SHUTTER, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = ((s32)reg == 0x00) ? 0xff : ((s32)reg - 1);
+               break;
+       case INDYCAM_CONTROL_GAIN:
+               ret = indycam_read_reg(client, INDYCAM_REG_GAIN, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = (s32)reg;
+               break;
+       case INDYCAM_CONTROL_RED_BALANCE:
+               ret = indycam_read_reg(client, INDYCAM_REG_RED_BALANCE, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = (s32)reg;
+               break;
+       case INDYCAM_CONTROL_BLUE_BALANCE:
+               ret = indycam_read_reg(client, INDYCAM_REG_BLUE_BALANCE, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = (s32)reg;
+               break;
+       case INDYCAM_CONTROL_RED_SATURATION:
+               ret = indycam_read_reg(client,
+                                      INDYCAM_REG_RED_SATURATION, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = (s32)reg;
+               break;
+       case INDYCAM_CONTROL_BLUE_SATURATION:
+               ret = indycam_read_reg(client,
+                                      INDYCAM_REG_BLUE_SATURATION, &reg);
+               if (ret)
+                       return -EIO;
+               ctrl->value = (s32)reg;
+               break;
+       case INDYCAM_CONTROL_GAMMA:
+               if (camera->version == CAMERA_VERSION_MOOSE) {
+                       ret = indycam_read_reg(client,
+                                              INDYCAM_REG_GAMMA, &reg);
+                       if (ret)
+                               return -EIO;
+                       ctrl->value = (s32)reg;
+               } else {
+                       ctrl->value = INDYCAM_GAMMA_DEFAULT;
+               }
+               break;
+       default:
+               ret = -EINVAL;
+       }
 
-       return 0;
+       return ret;
 }
 
-static int indycam_set_controls(struct i2c_client *client,
-                               struct indycam_control *ctrl)
+static int indycam_set_control(struct i2c_client *client,
+                              struct indycam_control *ctrl)
 {
-       unsigned char ctrl_reg;
+       struct indycam *camera = i2c_get_clientdata(client);
+       u8 reg;
+       int ret = 0;
 
-       indycam_read_reg(client, INDYCAM_CONTROL, &ctrl_reg);
-       if (ctrl->agc != INDYCAM_VALUE_UNCHANGED) {
-               if (ctrl->agc)
-                       ctrl_reg |= INDYCAM_CONTROL_AGCENA;
-               else
-                       ctrl_reg &= ~INDYCAM_CONTROL_AGCENA;
-       }
-       if (ctrl->awb != INDYCAM_VALUE_UNCHANGED) {
-               if (ctrl->awb)
-                       ctrl_reg |= INDYCAM_CONTROL_AWBCTL;
-               else
-                       ctrl_reg &= ~INDYCAM_CONTROL_AWBCTL;
-       }
-       indycam_write_reg(client, INDYCAM_CONTROL, ctrl_reg);
+       switch (ctrl->type) {
+       case INDYCAM_CONTROL_AGC:
+       case INDYCAM_CONTROL_AWB:
+               ret = indycam_read_reg(client, INDYCAM_REG_CONTROL, &reg);
+               if (ret)
+                       break;
 
-       if (ctrl->shutter >= 0)
-               indycam_write_reg(client, INDYCAM_SHUTTER, ctrl->shutter);
-       if (ctrl->gain >= 0)
-               indycam_write_reg(client, INDYCAM_GAIN, ctrl->gain);
-       if (ctrl->red_balance >= 0)
-               indycam_write_reg(client, INDYCAM_RED_BALANCE,
-                                 ctrl->red_balance);
-       if (ctrl->blue_balance >= 0)
-               indycam_write_reg(client, INDYCAM_BLUE_BALANCE,
-                                 ctrl->blue_balance);
-       if (ctrl->red_saturation >= 0)
-               indycam_write_reg(client, INDYCAM_RED_SATURATION,
-                                 ctrl->red_saturation);
-       if (ctrl->blue_saturation >= 0)
-               indycam_write_reg(client, INDYCAM_BLUE_SATURATION,
-                                 ctrl->blue_saturation);
-       if (ctrl->gamma >= 0)
-               indycam_write_reg(client, INDYCAM_GAMMA, ctrl->gamma);
+               if (ctrl->type == INDYCAM_CONTROL_AGC) {
+                       if (ctrl->value)
+                               reg |= INDYCAM_CONTROL_AGCENA;
+                       else
+                               reg &= ~INDYCAM_CONTROL_AGCENA;
+               } else {
+                       if (ctrl->value)
+                               reg |= INDYCAM_CONTROL_AWBCTL;
+                       else
+                               reg &= ~INDYCAM_CONTROL_AWBCTL;
+               }
 
-       return 0;
+               ret = indycam_write_reg(client, INDYCAM_REG_CONTROL, reg);
+               break;
+       case INDYCAM_CONTROL_SHUTTER:
+               reg = (ctrl->value == 0xff) ? 0x00 : (ctrl->value + 1);
+               ret = indycam_write_reg(client, INDYCAM_REG_SHUTTER, reg);
+               break;
+       case INDYCAM_CONTROL_GAIN:
+               ret = indycam_write_reg(client, INDYCAM_REG_GAIN, ctrl->value);
+               break;
+       case INDYCAM_CONTROL_RED_BALANCE:
+               ret = indycam_write_reg(client, INDYCAM_REG_RED_BALANCE,
+                                       ctrl->value);
+               break;
+       case INDYCAM_CONTROL_BLUE_BALANCE:
+               ret = indycam_write_reg(client, INDYCAM_REG_BLUE_BALANCE,
+                                       ctrl->value);
+               break;
+       case INDYCAM_CONTROL_RED_SATURATION:
+               ret = indycam_write_reg(client, INDYCAM_REG_RED_SATURATION,
+                                       ctrl->value);
+               break;
+       case INDYCAM_CONTROL_BLUE_SATURATION:
+               ret = indycam_write_reg(client, INDYCAM_REG_BLUE_SATURATION,
+                                       ctrl->value);
+               break;
+       case INDYCAM_CONTROL_GAMMA:
+               if (camera->version == CAMERA_VERSION_MOOSE) {
+                       ret = indycam_write_reg(client, INDYCAM_REG_GAMMA,
+                                               ctrl->value);
+               }
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       return ret;
 }
 
 /* I2C-interface */
@@ -249,7 +316,8 @@
        if (err)
                goto out_free_camera;
 
-       camera->version = i2c_smbus_read_byte_data(client, INDYCAM_VERSION);
+       camera->version = i2c_smbus_read_byte_data(client,
+                                                  INDYCAM_REG_VERSION);
        if (camera->version != CAMERA_VERSION_INDY &&
            camera->version != CAMERA_VERSION_MOOSE) {
                err = -ENODEV;
@@ -262,8 +330,7 @@
        indycam_regdump(client);
 
        // initialize
-       err = indycam_write_block(client, 0, sizeof(initseq),
-                                 (unsigned char *)&initseq);
+       err = indycam_write_block(client, 0, sizeof(initseq), (u8 *)&initseq);
        if (err) {
                printk(KERN_ERR "IndyCam initalization failed\n");
                err = -EIO;
@@ -273,11 +340,10 @@
        indycam_regdump(client);
 
        // white balance
-       err = indycam_write_reg(client, INDYCAM_CONTROL,
+       err = indycam_write_reg(client, INDYCAM_REG_CONTROL,
                          INDYCAM_CONTROL_AGCENA | INDYCAM_CONTROL_AWBCTL);
        if (err) {
-               printk(KERN_ERR "IndyCam white balance "
-                      "initialization failed\n");
+               printk(KERN_ERR "IndyCam: White balancing camera failed\n");
                err = -EIO;
                goto out_detach_client;
        }
@@ -373,13 +439,11 @@
                /* TODO: convert values for indycam_set_controls() */
                break;
        }
-       case DECODER_INDYCAM_GET_CONTROLS: {
-               struct indycam_control *ctrl = arg;
-               indycam_get_controls(client, ctrl);
-       }
-       case DECODER_INDYCAM_SET_CONTROLS: {
-               struct indycam_control *ctrl = arg;
-               indycam_set_controls(client, ctrl);
+       case DECODER_INDYCAM_GET_CONTROL: {
+               return indycam_get_control(client, arg);
+       }
+       case DECODER_INDYCAM_SET_CONTROL: {
+               return indycam_set_control(client, arg);
        }
        default:
                return -EINVAL;
@@ -390,12 +454,12 @@
 
 static struct i2c_driver i2c_driver_indycam = {
        .owner          = THIS_MODULE,
-       .name           = "indycam",
-       .id             = I2C_DRIVERID_INDYCAM,
-       .flags          = I2C_DF_NOTIFY,
+       .name           = "indycam",
+       .id             = I2C_DRIVERID_INDYCAM,
+       .flags          = I2C_DF_NOTIFY,
        .attach_adapter = indycam_probe,
-       .detach_client  = indycam_detach,
-       .command        = indycam_command,
+       .detach_client  = indycam_detach,
+       .command        = indycam_command,
 };
 
 static int __init indycam_init(void)
diff -urN linux/drivers/media/video/indycam.h 
linux/drivers/media/video/indycam.h
--- linux/drivers/media/video/indycam.h 2005/08/10 16:38:59     1.2
+++ linux/drivers/media/video/indycam.h 2005/09/01 15:07:34     1.3
@@ -22,21 +22,21 @@
 #define INDYCAM_VERSION_MINOR(x)       ((x) & 0x0f)
 
 /* Register bus addresses */
-#define INDYCAM_CONTROL                        0x00
-#define INDYCAM_SHUTTER                        0x01
-#define INDYCAM_GAIN                   0x02
-#define INDYCAM_BRIGHTNESS             0x03 /* read-only */
-#define INDYCAM_RED_BALANCE            0x04
-#define INDYCAM_BLUE_BALANCE           0x05
-#define INDYCAM_RED_SATURATION         0x06
-#define INDYCAM_BLUE_SATURATION                0x07
-#define INDYCAM_GAMMA                  0x08
-#define INDYCAM_VERSION                        0x0e /* read-only */
-#define INDYCAM_RESET                  0x0f /* write-only */
-
-#define INDYCAM_LED                    0x46
-#define INDYCAM_ORIENTATION            0x47
-#define INDYCAM_BUTTON                 0x48
+#define INDYCAM_REG_CONTROL            0x00
+#define INDYCAM_REG_SHUTTER            0x01
+#define INDYCAM_REG_GAIN               0x02
+#define INDYCAM_REG_BRIGHTNESS         0x03 /* read-only */
+#define INDYCAM_REG_RED_BALANCE                0x04
+#define INDYCAM_REG_BLUE_BALANCE       0x05
+#define INDYCAM_REG_RED_SATURATION     0x06
+#define INDYCAM_REG_BLUE_SATURATION    0x07
+#define INDYCAM_REG_GAMMA              0x08
+#define INDYCAM_REG_VERSION            0x0e /* read-only */
+#define INDYCAM_REG_RESET              0x0f /* write-only */
+
+#define INDYCAM_REG_LED                        0x46
+#define INDYCAM_REG_ORIENTATION                0x47
+#define INDYCAM_REG_BUTTON             0x48
 
 /* Field definitions of registers */
 #define INDYCAM_CONTROL_AGCENA         (1<<0) /* automatic gain control */
@@ -59,13 +59,14 @@
 #define INDYCAM_ORIENTATION_BOTTOM_TO_TOP      0x40
 #define INDYCAM_BUTTON_RELEASED                        0x10
 
+/* Values for controls */
 #define INDYCAM_SHUTTER_MIN            0x00
 #define INDYCAM_SHUTTER_MAX            0xff
 #define INDYCAM_GAIN_MIN                0x00
 #define INDYCAM_GAIN_MAX                0xff
-#define INDYCAM_RED_BALANCE_MIN        0x00 /* the effect is the opposite? */
-#define INDYCAM_RED_BALANCE_MAX        0xff
-#define INDYCAM_BLUE_BALANCE_MIN        0x00 /* the effect is the opposite? */
+#define INDYCAM_RED_BALANCE_MIN                0x00
+#define INDYCAM_RED_BALANCE_MAX                0xff
+#define INDYCAM_BLUE_BALANCE_MIN        0x00
 #define INDYCAM_BLUE_BALANCE_MAX        0xff
 #define INDYCAM_RED_SATURATION_MIN      0x00
 #define INDYCAM_RED_SATURATION_MAX      0xff
@@ -74,34 +75,9 @@
 #define INDYCAM_GAMMA_MIN              0x00
 #define INDYCAM_GAMMA_MAX              0xff
 
-/* Driver interface definitions */
-
-#define INDYCAM_VALUE_ENABLED          1
-#define INDYCAM_VALUE_DISABLED         0
-#define INDYCAM_VALUE_UNCHANGED                -1
-
-/* When setting controls, a value of -1 leaves the control unchanged. */
-struct indycam_control {
-       int agc;        /* boolean */
-       int awb;        /* boolean */
-       int shutter;
-       int gain;
-       int red_balance;
-       int blue_balance;
-       int red_saturation;
-       int blue_saturation;
-       int gamma;
-};
-
-#define        DECODER_INDYCAM_GET_CONTROLS    _IOR('d', 193, struct 
indycam_control)
-#define        DECODER_INDYCAM_SET_CONTROLS    _IOW('d', 194, struct 
indycam_control)
-
-/* Default values for controls */
-
-#define INDYCAM_AGC_DEFAULT            INDYCAM_VALUE_ENABLED
-#define INDYCAM_AWB_DEFAULT            INDYCAM_VALUE_ENABLED
-
-#define INDYCAM_SHUTTER_DEFAULT                INDYCAM_SHUTTER_60
+#define INDYCAM_AGC_DEFAULT            1
+#define INDYCAM_AWB_DEFAULT            0
+#define INDYCAM_SHUTTER_DEFAULT                0xff
 #define INDYCAM_GAIN_DEFAULT           0x80
 #define INDYCAM_RED_BALANCE_DEFAULT    0x18
 #define INDYCAM_BLUE_BALANCE_DEFAULT   0xa4
@@ -109,4 +85,24 @@
 #define INDYCAM_BLUE_SATURATION_DEFAULT        0xc0
 #define INDYCAM_GAMMA_DEFAULT          0x80
 
+/* Driver interface definitions */
+
+#define INDYCAM_CONTROL_AGC                    0       /* boolean */
+#define INDYCAM_CONTROL_AWB                    1       /* boolean */
+#define INDYCAM_CONTROL_SHUTTER                        2
+#define INDYCAM_CONTROL_GAIN                   3
+#define INDYCAM_CONTROL_RED_BALANCE            4
+#define INDYCAM_CONTROL_BLUE_BALANCE           5
+#define INDYCAM_CONTROL_RED_SATURATION         6
+#define INDYCAM_CONTROL_BLUE_SATURATION                7
+#define INDYCAM_CONTROL_GAMMA                  8
+
+struct indycam_control {
+       u8 type;
+       s32 value;
+};
+
+#define        DECODER_INDYCAM_GET_CONTROL     _IOR('d', 193, struct 
indycam_control)
+#define        DECODER_INDYCAM_SET_CONTROL     _IOW('d', 194, struct 
indycam_control)
+
 #endif
diff -urN linux/drivers/media/video/saa7191.c 
linux/drivers/media/video/saa7191.c
--- linux/drivers/media/video/saa7191.c 2005/08/10 16:38:59     1.2
+++ linux/drivers/media/video/saa7191.c 2005/09/01 15:07:34     1.3
@@ -26,73 +26,97 @@
 
 #include "saa7191.h"
 
-#define SAA7191_MODULE_VERSION "0.0.3"
+#define SAA7191_MODULE_VERSION "0.0.5"
 
 MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
 MODULE_VERSION(SAA7191_MODULE_VERSION);
 MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
 MODULE_LICENSE("GPL");
 
-#define VINO_ADAPTER   (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
+// #define SAA7191_DEBUG
+
+#ifdef SAA7191_DEBUG
+#define dprintk(x...) printk("SAA7191: " x);
+#else
+#define dprintk(x...)
+#endif
+
+#define VINO_ADAPTER           (I2C_ALGO_SGI | I2C_HW_SGI_VINO)
+
+#define SAA7191_SYNC_COUNT     30
+#define SAA7191_SYNC_DELAY     100     /* milliseconds */
 
 struct saa7191 {
        struct i2c_client *client;
 
        /* the register values are stored here as the actual
         * I2C-registers are write-only */
-       unsigned char reg[25];
+       u8 reg[25];
 
-       unsigned char norm;
-       unsigned char input;
+       int input;
+       int norm;
 };
 
 static struct i2c_driver i2c_driver_saa7191;
 
-static const unsigned char initseq[] = {
+static const u8 initseq[] = {
        0,      /* Subaddress */
-       0x50,   /* SAA7191_REG_IDEL */
-       0x30,   /* SAA7191_REG_HSYB */
-       0x00,   /* SAA7191_REG_HSYS */
-       0xe8,   /* SAA7191_REG_HCLB */
-       0xb6,   /* SAA7191_REG_HCLS */
-       0xf4,   /* SAA7191_REG_HPHI */
-       0x01,   /* SAA7191_REG_LUMA - chrominance trap active (CVBS) */
-       0x00,   /* SAA7191_REG_HUEC */
-       0xf8,   /* SAA7191_REG_CKTQ */
-       0xf8,   /* SAA7191_REG_CKTS */
-       0x90,   /* SAA7191_REG_PLSE */
-       0x90,   /* SAA7191_REG_SESE */
-       0x00,   /* SAA7191_REG_GAIN */
-       0x0c,   /* SAA7191_REG_STDC - not SECAM, slow time constant */
-       0x78,   /* SAA7191_REG_IOCK - chrominance from CVBS, GPSW1 & 2 off */
-       0x99,   /* SAA7191_REG_CTL3 - automatic field detection */
-       0x00,   /* SAA7191_REG_CTL4 */
-       0x2c,   /* SAA7191_REG_CHCV */
+
+       0x50,   /* (0x50) SAA7191_REG_IDEL */
+
+       /* 50 Hz signal timing */
+       0x30,   /* (0x30) SAA7191_REG_HSYB */
+       0x00,   /* (0x00) SAA7191_REG_HSYS */
+       0xe8,   /* (0xe8) SAA7191_REG_HCLB */
+       0xb6,   /* (0xb6) SAA7191_REG_HCLS */
+       0xf4,   /* (0xf4) SAA7191_REG_HPHI */
+
+       /* control */
+       SAA7191_LUMA_APER_1,    /* (0x01) SAA7191_REG_LUMA - CVBS mode */
+       0x00,   /* (0x00) SAA7191_REG_HUEC */
+       0xf8,   /* (0xf8) SAA7191_REG_CKTQ */
+       0xf8,   /* (0xf8) SAA7191_REG_CKTS */
+       0x90,   /* (0x90) SAA7191_REG_PLSE */
+       0x90,   /* (0x90) SAA7191_REG_SESE */
+       0x00,   /* (0x00) SAA7191_REG_GAIN */
+       SAA7191_STDC_NFEN | SAA7191_STDC_HRMV,  /* (0x0c) SAA7191_REG_STDC
+                                                * - not SECAM,
+                                                * slow time constant */
+       SAA7191_IOCK_OEDC | SAA7191_IOCK_OEHS | SAA7191_IOCK_OEVS
+       | SAA7191_IOCK_OEDY,    /* (0x78) SAA7191_REG_IOCK
+                                * - chroma from CVBS, GPSW1 & 2 off */
+       SAA7191_CTL3_AUFD | SAA7191_CTL3_SCEN | SAA7191_CTL3_OFTS
+       | SAA7191_CTL3_YDEL0,   /* (0x99) SAA7191_REG_CTL3
+                                * - automatic field detection */
+       0x00,   /* (0x00) SAA7191_REG_CTL4 */
+       0x2c,   /* (0x2c) SAA7191_REG_CHCV - PAL nominal value */
        0x00,   /* unused */
        0x00,   /* unused */
-       0x34,   /* SAA7191_REG_HS6B */
-       0x0a,   /* SAA7191_REG_HS6S */
-       0xf4,   /* SAA7191_REG_HC6B */
-       0xce,   /* SAA7191_REG_HC6S */
-       0xf4,   /* SAA7191_REG_HP6I */
+
+       /* 60 Hz signal timing */
+       0x34,   /* (0x34) SAA7191_REG_HS6B */
+       0x0a,   /* (0x0a) SAA7191_REG_HS6S */
+       0xf4,   /* (0xf4) SAA7191_REG_HC6B */
+       0xce,   /* (0xce) SAA7191_REG_HC6S */
+       0xf4,   /* (0xf4) SAA7191_REG_HP6I */
 };
 
 /* SAA7191 register handling */
 
-static unsigned char saa7191_read_reg(struct i2c_client *client,
-                                     unsigned char reg)
+static u8 saa7191_read_reg(struct i2c_client *client,
+                          u8 reg)
 {
        return ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg];
 }
 
 static int saa7191_read_status(struct i2c_client *client,
-                              unsigned char *value)
+                              u8 *value)
 {
        int ret;
 
        ret = i2c_master_recv(client, value, 1);
        if (ret < 0) {
-               printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed");
+               printk(KERN_ERR "SAA7191: saa7191_read_status(): read 
failed\n");
                return ret;
        }
 
@@ -100,17 +124,16 @@
 }
 
 
-static int saa7191_write_reg(struct i2c_client *client, unsigned char reg,
-                            unsigned char value)
+static int saa7191_write_reg(struct i2c_client *client, u8 reg,
+                            u8 value)
 {
-
        ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg] = value;
        return i2c_smbus_write_byte_data(client, reg, value);
 }
 
 /* the first byte of data must be the first subaddress number (register) */
 static int saa7191_write_block(struct i2c_client *client,
-                              unsigned char length, unsigned char *data)
+                              u8 length, u8 *data)
 {
        int i;
        int ret;
@@ -123,7 +146,7 @@
        ret = i2c_master_send(client, data, length);
        if (ret < 0) {
                printk(KERN_ERR "SAA7191: saa7191_write_block(): "
-                      "write failed");
+                      "write failed\n");
                return ret;
        }
 
@@ -134,8 +157,9 @@
 
 static int saa7191_set_input(struct i2c_client *client, int input)
 {
-       unsigned char luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
-       unsigned char iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
+       struct saa7191 *decoder = i2c_get_clientdata(client);
+       u8 luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
+       u8 iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
        int err;
 
        switch (input) {
@@ -161,32 +185,20 @@
        if (err)
                return -EIO;
 
+       decoder->input = input;
+
        return 0;
 }
 
 static int saa7191_set_norm(struct i2c_client *client, int norm)
 {
        struct saa7191 *decoder = i2c_get_clientdata(client);
-       unsigned char stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
-       unsigned char ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
-       unsigned char chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
+       u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
+       u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
+       u8 chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
        int err;
 
        switch(norm) {
-       case SAA7191_NORM_AUTO: {
-               unsigned char status;
-
-               // does status depend on current norm ?
-               if (saa7191_read_status(client, &status))
-                       return -EIO;
-
-               stdc &= ~SAA7191_STDC_SECS;
-               ctl3 &= ~SAA7191_CTL3_FSEL;
-               ctl3 |= SAA7191_CTL3_AUFD;
-               chcv = (status & SAA7191_STATUS_FIDT)
-                              ? SAA7191_CHCV_NTSC : SAA7191_CHCV_PAL;
-               break;
-       }
        case SAA7191_NORM_PAL:
                stdc &= ~SAA7191_STDC_SECS;
                ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
@@ -219,60 +231,335 @@
 
        decoder->norm = norm;
 
+       dprintk("ctl3: %02x stdc: %02x chcv: %02x\n", ctl3,
+               stdc, chcv);
+       dprintk("norm: %d\n", norm);
+
        return 0;
 }
 
-static int saa7191_get_controls(struct i2c_client *client,
-                               struct saa7191_control *ctrl)
+static int saa7191_wait_for_signal(struct i2c_client *client, u8 *status)
 {
-       unsigned char hue = saa7191_read_reg(client, SAA7191_REG_HUEC);
-       unsigned char stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
+       int i = 0;
 
-       if (hue < 0x80) {
-               hue += 0x80;
-       } else {
-               hue -= 0x80;
+       dprintk("Checking for signal...\n");
+
+       for (i = 0; i < SAA7191_SYNC_COUNT; i++) {
+               if (saa7191_read_status(client, status))
+                       return -EIO;
+
+               if (((*status) & SAA7191_STATUS_HLCK) == 0) {
+                       dprintk("Signal found\n");
+                       return 0;
+               }
+
+               msleep(SAA7191_SYNC_DELAY);
        }
-       ctrl->hue = hue;
 
-       ctrl->vtrc = (stdc & SAA7191_STDC_VTRC)
-               ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+       dprintk("No signal\n");
 
-       return 0;
+       return -EBUSY;
 }
 
-static int saa7191_set_controls(struct i2c_client *client,
-                               struct saa7191_control *ctrl)
+static int saa7191_autodetect_norm_extended(struct i2c_client *client)
 {
-       int err;
+       u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
+       u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
+       u8 status;
+       int err = 0;
 
-       if (ctrl->hue >= 0) {
-               unsigned char hue = ctrl->hue & 0xff;
-               if (hue < 0x80) {
-                       hue += 0x80;
-               } else {
-                       hue -= 0x80;
+       dprintk("SAA7191 extended signal auto-detection...\n");
+
+       stdc &= ~SAA7191_STDC_SECS;
+       ctl3 &= ~(SAA7191_CTL3_FSEL);
+
+       err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
+       if (err) {
+               err = -EIO;
+               goto out;
+       }
+       err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
+       if (err) {
+               err = -EIO;
+               goto out;
+       }
+
+       ctl3 |= SAA7191_CTL3_AUFD;
+       err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
+       if (err) {
+               err = -EIO;
+               goto out;
+       }
+
+       msleep(SAA7191_SYNC_DELAY);
+
+       err = saa7191_wait_for_signal(client, &status);
+       if (err)
+               goto out;
+
+       if (status & SAA7191_STATUS_FIDT) {
+               /* 60Hz signal -> NTSC */
+               dprintk("60Hz signal: NTSC\n");
+               return saa7191_set_norm(client, SAA7191_NORM_NTSC);
+       }
+
+       /* 50Hz signal */
+       dprintk("50Hz signal: Trying PAL...\n");
+
+       /* try PAL first */
+       err = saa7191_set_norm(client, SAA7191_NORM_PAL);
+       if (err)
+               goto out;
+
+       msleep(SAA7191_SYNC_DELAY);
+
+       err = saa7191_wait_for_signal(client, &status);
+       if (err)
+               goto out;
+
+       /* not 50Hz ? */
+       if (status & SAA7191_STATUS_FIDT) {
+               dprintk("No 50Hz signal\n");
+               err = -EAGAIN;
+               goto out;
+       }
+
+       if (status & SAA7191_STATUS_CODE) {
+               dprintk("PAL\n");
+               return 0;
+       }
+
+       dprintk("No color detected with PAL - Trying SECAM...\n");
+
+       /* no color detected ? -> try SECAM */
+       err = saa7191_set_norm(client,
+                              SAA7191_NORM_SECAM);
+       if (err)
+               goto out;
+
+       msleep(SAA7191_SYNC_DELAY);
+
+       err = saa7191_wait_for_signal(client, &status);
+       if (err)
+               goto out;
+
+       /* not 50Hz ? */
+       if (status & SAA7191_STATUS_FIDT) {
+               dprintk("No 50Hz signal\n");
+               err = -EAGAIN;
+               goto out;
+       }
+
+       if (status & SAA7191_STATUS_CODE) {
+               /* Color detected -> SECAM */
+               dprintk("SECAM\n");
+               return 0;
+       }
+
+       dprintk("No color detected with SECAM - Going back to PAL.\n");
+
+       /* still no color detected ?
+        * -> set norm back to PAL */
+       err = saa7191_set_norm(client,
+                              SAA7191_NORM_PAL);
+       if (err)
+               goto out;
+
+out:
+       ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
+       if (ctl3 & SAA7191_CTL3_AUFD) {
+               ctl3 &= ~(SAA7191_CTL3_AUFD);
+               err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
+               if (err) {
+                       err = -EIO;
                }
-               err = saa7191_write_reg(client, SAA7191_REG_HUEC, hue);
-               if (err)
-                       return -EIO;
        }
-       if (ctrl->vtrc >= 0) {
-               unsigned char stdc =
-                       saa7191_read_reg(client, SAA7191_REG_STDC);
 
-               if (ctrl->vtrc) {
-                       stdc |= SAA7191_STDC_VTRC;
-               } else {
-                       stdc &= ~SAA7191_STDC_VTRC;
+       return err;
+}
+
+static int saa7191_autodetect_norm(struct i2c_client *client)
+{
+       u8 status;
+
+       dprintk("SAA7191 signal auto-detection...\n");
+
+       dprintk("Reading status...\n");
+
+       if (saa7191_read_status(client, &status))
+               return -EIO;
+
+       dprintk("Checking for signal...\n");
+
+       /* no signal ? */
+       if (status & SAA7191_STATUS_HLCK) {
+               dprintk("No signal\n");
+               return -EBUSY;
+       }
+
+       dprintk("Signal found\n");
+
+       if (status & SAA7191_STATUS_FIDT) {
+               /* 60hz signal -> NTSC */
+               dprintk("NTSC\n");
+               return saa7191_set_norm(client, SAA7191_NORM_NTSC);
+       } else {
+               /* 50hz signal -> PAL */
+               dprintk("PAL\n");
+               return saa7191_set_norm(client, SAA7191_NORM_PAL);
+       }
+}
+
+static int saa7191_get_control(struct i2c_client *client,
+                              struct saa7191_control *ctrl)
+{
+       u8 reg;
+       int ret = 0;
+
+       switch (ctrl->type) {
+       case SAA7191_CONTROL_BANDPASS:
+       case SAA7191_CONTROL_BANDPASS_WEIGHT:
+       case SAA7191_CONTROL_CORING:
+               reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
+               switch (ctrl->type) {
+               case SAA7191_CONTROL_BANDPASS:
+                       ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
+                               >> SAA7191_LUMA_BPSS_SHIFT;
+                       break;
+               case SAA7191_CONTROL_BANDPASS_WEIGHT:
+                       ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
+                               >> SAA7191_LUMA_APER_SHIFT;
+                       break;
+               case SAA7191_CONTROL_CORING:
+                       ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
+                               >> SAA7191_LUMA_CORI_SHIFT;
+                       break;
                }
+               break;
+       case SAA7191_CONTROL_FORCE_COLOUR:
+       case SAA7191_CONTROL_CHROMA_GAIN:
+               reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
+               if (ctrl->type == SAA7191_CONTROL_FORCE_COLOUR)
+                       ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
+               else
+                       ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
+                               >> SAA7191_GAIN_LFIS_SHIFT;
+               break;
+       case SAA7191_CONTROL_HUE:
+               reg = saa7191_read_reg(client, SAA7191_REG_HUEC);
+               if (reg < 0x80)
+                       reg += 0x80;
+               else
+                       reg -= 0x80;
+               ctrl->value = (s32)reg;
+               break;
+       case SAA7191_CONTROL_VTRC:
+               reg = saa7191_read_reg(client, SAA7191_REG_STDC);
+               ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
+               break;
+       case SAA7191_CONTROL_LUMA_DELAY:
+               reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
+               ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
+                       >> SAA7191_CTL3_YDEL_SHIFT;
+               if (ctrl->value >= 4)
+                       ctrl->value -= 8;
+               break;
+       case SAA7191_CONTROL_VNR:
+               reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
+               ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
+                       >> SAA7191_CTL4_VNOI_SHIFT;
+               break;
+       default:
+               ret = -EINVAL;
+       }
 
-               err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
-               if (err)
-                       return -EIO;
+       return ret;
+}
+
+static int saa7191_set_control(struct i2c_client *client,
+                              struct saa7191_control *ctrl)
+{
+       u8 reg;
+       int ret = 0;
+
+       switch (ctrl->type) {
+       case SAA7191_CONTROL_BANDPASS:
+       case SAA7191_CONTROL_BANDPASS_WEIGHT:
+       case SAA7191_CONTROL_CORING:
+               reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
+               switch (ctrl->type) {
+               case SAA7191_CONTROL_BANDPASS:
+                       reg &= ~SAA7191_LUMA_BPSS_MASK;
+                       reg |= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
+                               & SAA7191_LUMA_BPSS_MASK;
+                       break;
+               case SAA7191_CONTROL_BANDPASS_WEIGHT:
+                       reg &= ~SAA7191_LUMA_APER_MASK;
+                       reg |= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
+                               & SAA7191_LUMA_APER_MASK;
+                       break;
+               case SAA7191_CONTROL_CORING:
+                       reg &= ~SAA7191_LUMA_CORI_MASK;
+                       reg |= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
+                               & SAA7191_LUMA_CORI_MASK;
+                       break;
+               }
+               ret = saa7191_write_reg(client, SAA7191_REG_LUMA, reg);
+               break;
+       case SAA7191_CONTROL_FORCE_COLOUR:
+       case SAA7191_CONTROL_CHROMA_GAIN:
+               reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
+               if (ctrl->type == SAA7191_CONTROL_FORCE_COLOUR) {
+                       if (ctrl->value)
+                               reg |= SAA7191_GAIN_COLO;
+                       else
+                               reg &= ~SAA7191_GAIN_COLO;
+               } else {
+                       reg &= ~SAA7191_GAIN_LFIS_MASK;
+                       reg |= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
+                               & SAA7191_GAIN_LFIS_MASK;
+               }
+               ret = saa7191_write_reg(client, SAA7191_REG_GAIN, reg);
+               break;
+       case SAA7191_CONTROL_HUE:
+               reg = ctrl->value & 0xff;
+               if (reg < 0x80)
+                       reg += 0x80;
+               else
+                       reg -= 0x80;
+               ret = saa7191_write_reg(client, SAA7191_REG_HUEC, reg);
+               break;
+       case SAA7191_CONTROL_VTRC:
+               reg = saa7191_read_reg(client, SAA7191_REG_STDC);
+               if (ctrl->value)
+                       reg |= SAA7191_STDC_VTRC;
+               else
+                       reg &= ~SAA7191_STDC_VTRC;
+               ret = saa7191_write_reg(client, SAA7191_REG_STDC, reg);
+               break;
+       case SAA7191_CONTROL_LUMA_DELAY: {
+               s32 value = ctrl->value;
+               if (value < 0)
+                       value += 8;
+               reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
+               reg &= ~SAA7191_CTL3_YDEL_MASK;
+               reg |= (value << SAA7191_CTL3_YDEL_SHIFT)
+                       & SAA7191_CTL3_YDEL_MASK;
+               ret = saa7191_write_reg(client, SAA7191_REG_CTL3, reg);
+               break;
+       }
+       case SAA7191_CONTROL_VNR:
+               reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
+               reg &= ~SAA7191_CTL4_VNOI_MASK;
+               reg |= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
+                       & SAA7191_CTL4_VNOI_MASK;
+               ret = saa7191_write_reg(client, SAA7191_REG_CTL4, reg);
+               break;
+       default:
+               ret = -EINVAL;
        }
 
-       return 0;
+       return ret;
 }
 
 /* I2C-interface */
@@ -311,11 +598,7 @@
        if (err)
                goto out_free_decoder;
 
-       decoder->input = SAA7191_INPUT_COMPOSITE;
-       decoder->norm = SAA7191_NORM_AUTO;
-
-       err = saa7191_write_block(client, sizeof(initseq),
-                                 (unsigned char *)initseq);
+       err = saa7191_write_block(client, sizeof(initseq), (u8 *)initseq);
        if (err) {
                printk(KERN_ERR "SAA7191 initialization failed\n");
                goto out_detach_client;
@@ -323,6 +606,14 @@
 
        printk(KERN_INFO "SAA7191 initialized\n");
 
+       decoder->input = SAA7191_INPUT_COMPOSITE;
+       decoder->norm = SAA7191_NORM_PAL;
+
+       err = saa7191_autodetect_norm(client);
+       if (err && (err != -EBUSY)) {
+               printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");
+       }
+
        return 0;
 
 out_detach_client:
@@ -370,7 +661,7 @@
        }
        case DECODER_GET_STATUS: {
                int *iarg = arg;
-               unsigned char status;
+               u8 status;
                int res = 0;
 
                if (saa7191_read_status(client, &status)) {
@@ -406,7 +697,7 @@
 
                switch (*iarg) {
                case VIDEO_MODE_AUTO:
-                       return saa7191_set_norm(client, SAA7191_NORM_AUTO);
+                       return saa7191_autodetect_norm(client);
                case VIDEO_MODE_PAL:
                        return saa7191_set_norm(client, SAA7191_NORM_PAL);
                case VIDEO_MODE_NTSC:
@@ -448,38 +739,48 @@
                int err;
 
                val = (pic->hue >> 8) - 0x80;
+
                err = saa7191_write_reg(client, SAA7191_REG_HUEC, val);
                if (err)
                        return -EIO;
+
                break;
        }
        case DECODER_SAA7191_GET_STATUS: {
                struct saa7191_status *status = arg;
-               unsigned char status_reg;
+               u8 status_reg;
 
                if (saa7191_read_status(client, &status_reg))
                        return -EIO;
+
                status->signal = ((status_reg & SAA7191_STATUS_HLCK) == 0)
-                       ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
-               status->ntsc = (status_reg & SAA7191_STATUS_FIDT)
-                       ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
-               status->color = (status_reg & SAA7191_STATUS_CODE)
-                       ? SAA7191_VALUE_ENABLED : SAA7191_VALUE_DISABLED;
+                       ? 1 : 0;
+               status->signal_60hz = (status_reg & SAA7191_STATUS_FIDT)
+                       ? 1 : 0;
+               status->color = (status_reg & SAA7191_STATUS_CODE) ? 1 : 0;
 
                status->input = decoder->input;
                status->norm = decoder->norm;
+
+               break;
        }
        case DECODER_SAA7191_SET_NORM: {
                int *norm = arg;
-               return saa7191_set_norm(client, *norm);
+
+               switch (*norm) {
+               case SAA7191_NORM_AUTO:
+                       return saa7191_autodetect_norm(client);
+               case SAA7191_NORM_AUTO_EXT:
+                       return saa7191_autodetect_norm_extended(client);
+               default:
+                       return saa7191_set_norm(client, *norm);
+               }
+       }
+       case DECODER_SAA7191_GET_CONTROL: {
+               return saa7191_get_control(client, arg);
        }
-       case DECODER_SAA7191_GET_CONTROLS: {
-               struct saa7191_control *ctrl = arg;
-               return saa7191_get_controls(client, ctrl);
-       }
-       case DECODER_SAA7191_SET_CONTROLS: {
-               struct saa7191_control *ctrl = arg;
-               return saa7191_set_controls(client, ctrl);
+       case DECODER_SAA7191_SET_CONTROL: {
+               return saa7191_set_control(client, arg);
        }
        default:
                return -EINVAL;
@@ -490,12 +791,12 @@
 
 static struct i2c_driver i2c_driver_saa7191 = {
        .owner          = THIS_MODULE,
-       .name           = "saa7191",
-       .id             = I2C_DRIVERID_SAA7191,
-       .flags          = I2C_DF_NOTIFY,
+       .name           = "saa7191",
+       .id             = I2C_DRIVERID_SAA7191,
+       .flags          = I2C_DF_NOTIFY,
        .attach_adapter = saa7191_probe,
-       .detach_client  = saa7191_detach,
-       .command        = saa7191_command
+       .detach_client  = saa7191_detach,
+       .command        = saa7191_command
 };
 
 static int saa7191_init(void)
diff -urN linux/drivers/media/video/saa7191.h 
linux/drivers/media/video/saa7191.h
--- linux/drivers/media/video/saa7191.h 2005/08/10 16:38:59     1.2
+++ linux/drivers/media/video/saa7191.h 2005/09/01 15:07:34     1.3
@@ -24,8 +24,8 @@
 #define SAA7191_REG_HPHI       0x05
 #define SAA7191_REG_LUMA       0x06
 #define SAA7191_REG_HUEC       0x07
-#define SAA7191_REG_CKTQ       0x08
-#define SAA7191_REG_CKTS       0x09
+#define SAA7191_REG_CKTQ       0x08 /* bits 3-7 */
+#define SAA7191_REG_CKTS       0x09 /* bits 3-7 */
 #define SAA7191_REG_PLSE       0x0a
 #define SAA7191_REG_SESE       0x0b
 #define SAA7191_REG_GAIN       0x0c
@@ -43,30 +43,82 @@
 
 /* Status Register definitions */
 #define SAA7191_STATUS_CODE    0x01    /* color detected flag */
-#define SAA7191_STATUS_FIDT    0x20    /* format type NTSC/PAL */
-#define SAA7191_STATUS_HLCK    0x40    /* PLL unlocked/locked */
+#define SAA7191_STATUS_FIDT    0x20    /* signal type 50/60 Hz */
+#define SAA7191_STATUS_HLCK    0x40    /* PLL unlocked(1)/locked(0) */
 #define SAA7191_STATUS_STTC    0x80    /* tv/vtr time constant */
 
 /* Luminance Control Register definitions */
+/* input mode select bit:
+ * 0=CVBS (chrominance trap active), 1=S-Video (trap bypassed) */
 #define SAA7191_LUMA_BYPS      0x80
+/* pre-filter (only when chrominance trap is active) */
+#define SAA7191_LUMA_PREF      0x40
+/* aperture bandpass to select different characteristics with maximums
+ * (bits 4-5) */
+#define SAA7191_LUMA_BPSS_MASK 0x30
+#define SAA7191_LUMA_BPSS_SHIFT        4
+#define SAA7191_LUMA_BPSS_3    0x30
+#define SAA7191_LUMA_BPSS_2    0x20
+#define SAA7191_LUMA_BPSS_1    0x10
+#define SAA7191_LUMA_BPSS_0    0x00
+/* coring range for high frequency components according to 8-bit luminance
+ * (bits 2-3)
+ * 0=coring off, n= (+-)n LSB */
+#define SAA7191_LUMA_CORI_MASK 0x0c
+#define SAA7191_LUMA_CORI_SHIFT        2
+#define SAA7191_LUMA_CORI_3    0x0c
+#define SAA7191_LUMA_CORI_2    0x08
+#define SAA7191_LUMA_CORI_1    0x04
+#define SAA7191_LUMA_CORI_0    0x00
+/* aperture bandpass filter weights high frequency components of luminance
+ * signal (bits 0-1)
+ * 0=factor 0, 1=0.25, 2=0.5, 3=1 */
+#define SAA7191_LUMA_APER_MASK 0x03
+#define SAA7191_LUMA_APER_SHIFT        0
+#define SAA7191_LUMA_APER_3    0x03
+#define SAA7191_LUMA_APER_2    0x02
+#define SAA7191_LUMA_APER_1    0x01
+#define SAA7191_LUMA_APER_0    0x00
 
-/* Chroma Gain Control Settings Register definitions */
-/* 0=automatic colour-killer enabled, 1=forced colour on */
+/* Chrominance Gain Control Settings Register definitions */
+/* colour on: 0=automatic colour-killer enabled, 1=forced colour on */
 #define SAA7191_GAIN_COLO      0x80
+/* chrominance gain control (AGC filter)
+ * 0=loop filter time constant slow, 1=medium, 2=fast, 3=actual gain */
+#define SAA7191_GAIN_LFIS_MASK 0x60
+#define SAA7191_GAIN_LFIS_SHIFT        5
+#define SAA7191_GAIN_LFIS_3    0x60
+#define SAA7191_GAIN_LFIS_2    0x40
+#define SAA7191_GAIN_LFIS_1    0x20
+#define SAA7191_GAIN_LFIS_0    0x00
 
 /* Standard/Mode Control Register definitions */
 /* tv/vtr mode bit: 0=TV mode (slow time constant),
  * 1=VTR mode (fast time constant) */
 #define SAA7191_STDC_VTRC      0x80
+/* SAA7191B-specific functions enable (RTCO, ODD and GPSW0 outputs)
+ * 0=outputs set to high-impedance (circuit equals SAA7191), 1=enabled */
+#define SAA7191_STDC_NFEN      0x08
+/* HREF generation: 0=like SAA7191, 1=HREF is 8xLLC2 clocks earlier */
+#define SAA7191_STDC_HRMV      0x04
+/* general purpose switch 0
+ * (not used with VINO afaik) */
+#define SAA7191_STDC_GPSW0     0x02
 /* SECAM mode bit: 0=other standards, 1=SECAM */
 #define SAA7191_STDC_SECS      0x01
-/* the bit fields above must be or'd with this value */
-#define SAA7191_STDC_VALUE     0x0c
 
 /* I/O and Clock Control Register definitions */
 /* horizontal clock PLL: 0=PLL closed,
  * 1=PLL circuit open and horizontal freq fixed */
 #define SAA7191_IOCK_HPLL      0x80
+/* colour-difference output enable (outputs UV0-UV7) */
+#define SAA7191_IOCK_OEDC      0x40
+/* H-sync output enable */
+#define SAA7191_IOCK_OEHS      0x20
+/* V-sync output enable */
+#define SAA7191_IOCK_OEVS      0x10
+/* luminance output enable (outputs Y0-Y7) */
+#define SAA7191_IOCK_OEDY      0x08
 /* S-VHS bit (chrominance from CVBS or from chrominance input):
  * 0=controlled by BYPS-bit, 1=from chrominance input */
 #define SAA7191_IOCK_CHRS      0x04
@@ -83,11 +135,40 @@
 /* field select: (if AUFD=0)
  * 0=50Hz (625 lines), 1=60Hz (525 lines) */
 #define SAA7191_CTL3_FSEL      0x40
-/* the bit fields above must be or'd with this value */
-#define SAA7191_CTL3_VALUE     0x19
+/* SECAM cross-colour reduction enable */
+#define SAA7191_CTL3_SXCR      0x20
+/* sync and clamping pulse enable (HCL and HSY outputs) */
+#define SAA7191_CTL3_SCEN      0x10
+/* output format: 0=4:1:1, 1=4:2:2 (4:2:2 for VINO) */
+#define SAA7191_CTL3_OFTS      0x08
+/* luminance delay compensation
+ * 0=0*2/LLC,  1=+1*2/LLC, 2=+2*2/LLC, 3=+3*2/LLC,
+ * 4=-4*2/LLC, 5=-3*2/LLC, 6=-2*2/LLC, 7=-1*2/LLC
+ * step size = 2/LLC = 67.8ns for 50Hz, 81.5ns for 60Hz */
+#define SAA7191_CTL3_YDEL_MASK 0x07
+#define SAA7191_CTL3_YDEL_SHIFT        0
+#define SAA7191_CTL3_YDEL2     0x04
+#define SAA7191_CTL3_YDEL1     0x02
+#define SAA7191_CTL3_YDEL0     0x01
+
+/* Miscellaneous Control #2 Register definitions */
+/* select HREF position
+ * 0=normal, HREF is matched to YUV output port,
+ * 1=HREF is matched to CVBS input port */
+#define SAA7191_CTL4_HRFS      0x04
+/* vertical noise reduction
+ * 0=normal, 1=searching window, 2=auto-deflection, 3=reduction bypassed */
+#define SAA7191_CTL4_VNOI_MASK 0x03
+#define SAA7191_CTL4_VNOI_SHIFT        0
+#define SAA7191_CTL4_VNOI_3    0x03
+#define SAA7191_CTL4_VNOI_2    0x02
+#define SAA7191_CTL4_VNOI_1    0x01
+#define SAA7191_CTL4_VNOI_0    0x00
 
 /* Chrominance Gain Control Register definitions
- * (nominal value for UV CCIR level) */
+ * - for QAM-modulated input signals, effects output amplitude
+ * (SECAM gain fixed)
+ * (nominal values for UV CCIR level) */
 #define SAA7191_CHCV_NTSC      0x2c
 #define SAA7191_CHCV_PAL       0x59
 
@@ -99,16 +180,13 @@
 #define SAA7191_NORM_PAL       1
 #define SAA7191_NORM_NTSC      2
 #define SAA7191_NORM_SECAM     3
-
-#define SAA7191_VALUE_ENABLED          1
-#define SAA7191_VALUE_DISABLED         0
-#define SAA7191_VALUE_UNCHANGED                -1
+#define SAA7191_NORM_AUTO_EXT  4       /* extended auto-detection */
 
 struct saa7191_status {
-       /* 0=no signal, 1=signal active*/
+       /* 0=no signal, 1=signal detected */
        int signal;
        /* 0=50hz (pal) signal, 1=60hz (ntsc) signal */
-       int ntsc;
+       int signal_60hz;
        /* 0=no color detected, 1=color detected */
        int color;
 
@@ -118,22 +196,60 @@
        int norm;
 };
 
-#define SAA7191_HUE_MIN                0x00
-#define SAA7191_HUE_MAX                0xff
-#define SAA7191_HUE_DEFAULT    0x80
-
-#define SAA7191_VTRC_MIN       0x00
-#define SAA7191_VTRC_MAX       0x01
-#define SAA7191_VTRC_DEFAULT   0x00
+#define SAA7191_BANDPASS_MIN           0x00
+#define SAA7191_BANDPASS_MAX           0x03
+#define SAA7191_BANDPASS_DEFAULT       0x00
+
+#define SAA7191_BANDPASS_WEIGHT_MIN    0x00
+#define SAA7191_BANDPASS_WEIGHT_MAX    0x03
+#define SAA7191_BANDPASS_WEIGHT_DEFAULT        0x01
+
+#define SAA7191_CORING_MIN             0x00
+#define SAA7191_CORING_MAX             0x03
+#define SAA7191_CORING_DEFAULT         0x00
+
+#define SAA7191_HUE_MIN                        0x00
+#define SAA7191_HUE_MAX                        0xff
+#define SAA7191_HUE_DEFAULT            0x80
+
+#define SAA7191_VTRC_MIN               0x00
+#define SAA7191_VTRC_MAX               0x01
+#define SAA7191_VTRC_DEFAULT           0x00
+
+#define SAA7191_FORCE_COLOUR_MIN       0x00
+#define SAA7191_FORCE_COLOUR_MAX       0x01
+#define SAA7191_FORCE_COLOUR_DEFAULT   0x00
+
+#define SAA7191_CHROMA_GAIN_MIN                0x00
+#define SAA7191_CHROMA_GAIN_MAX                0x03
+#define SAA7191_CHROMA_GAIN_DEFAULT    0x00
+
+#define SAA7191_LUMA_DELAY_MIN         -0x04
+#define SAA7191_LUMA_DELAY_MAX         0x03
+#define SAA7191_LUMA_DELAY_DEFAULT     0x01
+
+#define SAA7191_VNR_MIN                        0x00
+#define SAA7191_VNR_MAX                        0x03
+#define SAA7191_VNR_DEFAULT            0x00
+
+#define SAA7191_CONTROL_BANDPASS       0
+#define SAA7191_CONTROL_BANDPASS_WEIGHT        1
+#define SAA7191_CONTROL_CORING         2
+#define SAA7191_CONTROL_FORCE_COLOUR   3       /* boolean */
+#define SAA7191_CONTROL_CHROMA_GAIN    4
+#define SAA7191_CONTROL_HUE            5
+#define SAA7191_CONTROL_VTRC           6       /* boolean */
+#define SAA7191_CONTROL_LUMA_DELAY     7
+#define SAA7191_CONTROL_VNR            8
 
 struct saa7191_control {
-       int hue;
-       int vtrc;
+       u8 type;
+       s32 value;
 };
 
 #define        DECODER_SAA7191_GET_STATUS      _IOR('d', 195, struct 
saa7191_status)
 #define        DECODER_SAA7191_SET_NORM        _IOW('d', 196, int)
-#define        DECODER_SAA7191_GET_CONTROLS    _IOR('d', 197, struct 
saa7191_control)
-#define        DECODER_SAA7191_SET_CONTROLS    _IOW('d', 198, struct 
saa7191_control)
+#define        DECODER_SAA7191_GET_CONTROL     _IOR('d', 197, struct 
saa7191_control)
+#define        DECODER_SAA7191_SET_CONTROL     _IOW('d', 198, struct 
saa7191_control)
 
 #endif
diff -urN linux/drivers/media/video/vino.c linux/drivers/media/video/vino.c
--- linux/drivers/media/video/vino.c    2005/08/10 16:38:59     1.9
+++ linux/drivers/media/video/vino.c    2005/09/01 15:07:34     1.10
@@ -12,15 +12,11 @@
 
 /*
  * TODO:
- * - remove "hacks" from memory allocation code and implement nopage()
+ * - remove "mark pages reserved-hacks" from memory allocation code
+ *   and implement nopage()
  * - check decimation, calculating and reporting image size when
  *   using decimation
- * - check vino_acquire_input(), vino_set_input() and channel
- *   ownership handling
- * - report VINO error-interrupts via ioctls ?
- * - implement picture controls (all implemented?)
- * - use macros for boolean values (?)
- * - implement user mode buffers and overlay (?)
+ * - implement read(), user mode buffers and overlay (?)
  */
 
 #include <linux/init.h>
@@ -59,18 +55,16 @@
  * debug info.
  * Note that the debug output also slows down the driver significantly */
 // #define VINO_DEBUG
+// #define VINO_DEBUG_INT
 
-#define VINO_MODULE_VERSION "0.0.3"
-#define VINO_VERSION_CODE KERNEL_VERSION(0, 0, 3)
+#define VINO_MODULE_VERSION "0.0.5"
+#define VINO_VERSION_CODE KERNEL_VERSION(0, 0, 5)
 
 MODULE_DESCRIPTION("SGI VINO Video4Linux2 driver");
 MODULE_VERSION(VINO_MODULE_VERSION);
 MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
 MODULE_LICENSE("GPL");
 
-#define mem_map_reserve(p) set_bit(PG_reserved, &((p)->flags))
-#define mem_map_unreserve(p) clear_bit(PG_reserved, &((p)->flags))
-
 #ifdef VINO_DEBUG
 #define dprintk(x...) printk("VINO: " x);
 #else
@@ -90,15 +84,16 @@
 #define VINO_MIN_HEIGHT                        32
 
 #define VINO_CLIPPING_START_ODD_D1     1
-#define VINO_CLIPPING_START_ODD_PAL    1
-#define VINO_CLIPPING_START_ODD_NTSC   1
+#define VINO_CLIPPING_START_ODD_PAL    15
+#define VINO_CLIPPING_START_ODD_NTSC   12
 
 #define VINO_CLIPPING_START_EVEN_D1    2
-#define VINO_CLIPPING_START_EVEN_PAL   2
-#define VINO_CLIPPING_START_EVEN_NTSC  2
+#define VINO_CLIPPING_START_EVEN_PAL   15
+#define VINO_CLIPPING_START_EVEN_NTSC  12
 
 #define VINO_INPUT_CHANNEL_COUNT       3
 
+/* the number is the index for vino_inputs */
 #define VINO_INPUT_NONE                        -1
 #define VINO_INPUT_COMPOSITE           0
 #define VINO_INPUT_SVIDEO              1
@@ -106,15 +101,13 @@
 
 #define VINO_PAGE_RATIO                        (PAGE_SIZE / VINO_PAGE_SIZE)
 
-#define VINO_FIFO_THRESHOLD_DEFAULT    512
+#define VINO_FIFO_THRESHOLD_DEFAULT    16
 
-/*#define VINO_FRAMEBUFFER_SIZE                (VINO_PAL_WIDTH * 
VINO_PAL_HEIGHT * 4 \
-  + 2 * PAGE_SIZE)*/
 #define VINO_FRAMEBUFFER_SIZE          ((VINO_PAL_WIDTH \
                                          * VINO_PAL_HEIGHT * 4 \
                                          + 3 * PAGE_SIZE) & ~(PAGE_SIZE - 1))
 
-#define VINO_FRAMEBUFFER_MAX_COUNT     8
+#define VINO_FRAMEBUFFER_COUNT_MAX     8
 
 #define VINO_FRAMEBUFFER_UNUSED                0
 #define VINO_FRAMEBUFFER_IN_USE                1
@@ -130,24 +123,27 @@
 #define VINO_DUMMY_DESC_COUNT          4
 #define VINO_DESC_FETCH_DELAY          5       /* microseconds */
 
+#define VINO_MAX_FRAME_SKIP_COUNT      128
+
 /* the number is the index for vino_data_formats */
 #define VINO_DATA_FMT_NONE             -1
 #define VINO_DATA_FMT_GREY             0
 #define VINO_DATA_FMT_RGB332           1
 #define VINO_DATA_FMT_RGB32            2
 #define VINO_DATA_FMT_YUV              3
-//#define VINO_DATA_FMT_RGB24          4
 
 #define VINO_DATA_FMT_COUNT            4
 
+/* the number is the index for vino_data_norms */
 #define VINO_DATA_NORM_NONE            -1
 #define VINO_DATA_NORM_NTSC            0
 #define VINO_DATA_NORM_PAL             1
 #define VINO_DATA_NORM_SECAM           2
 #define VINO_DATA_NORM_D1              3
-/* The following is a special entry that can be used to
+/* The following are special entries that can be used to
  * autodetect the norm. */
-#define VINO_DATA_NORM_AUTO            0xff
+#define VINO_DATA_NORM_AUTO            0xfe
+#define VINO_DATA_NORM_AUTO_EXT                0xff
 
 #define VINO_DATA_NORM_COUNT           4
 
@@ -231,7 +227,7 @@
        unsigned int head;
        unsigned int tail;
 
-       unsigned int data[VINO_FRAMEBUFFER_MAX_COUNT];
+       unsigned int data[VINO_FRAMEBUFFER_COUNT_MAX];
 };
 
 struct vino_framebuffer_queue {
@@ -245,13 +241,20 @@
        struct vino_framebuffer_fifo in;
        struct vino_framebuffer_fifo out;
 
-       struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_MAX_COUNT];
+       struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_COUNT_MAX];
 
        spinlock_t queue_lock;
        struct semaphore queue_sem;
        wait_queue_head_t frame_wait_queue;
 };
 
+struct vino_interrupt_data {
+       struct timeval timestamp;
+       unsigned int frame_counter;
+       unsigned int skip_count;
+       unsigned int skip;
+};
+
 struct vino_channel_settings {
        unsigned int channel;
 
@@ -284,6 +287,8 @@
 
        unsigned int users;
 
+       struct vino_interrupt_data int_data;
+
        /* V4L support */
        struct video_device *v4l_device;
 };
@@ -314,7 +319,7 @@
 /* Module parameters */
 
 /*
- * Using vino_pixel_conversion the ARGB32-format pixels supplied
+ * Using vino_pixel_conversion the ABGR32-format pixels supplied
  * by the VINO chip can be converted to more common formats
  * like RGBA32 (or probably RGB24 in the future). This way we
  * can give out data that can be specified correctly with
@@ -328,7 +333,9 @@
  * Use non-zero value to enable conversion.
  */
 static int vino_pixel_conversion = 0;
+
 module_param_named(pixelconv, vino_pixel_conversion, int, 0);
+
 MODULE_PARM_DESC(pixelconv,
                 "enable pixel conversion (non-zero value enables)");
 
@@ -344,15 +351,22 @@
 static const char *vino_v4l_device_name_a = "SGI VINO Channel A";
 static const char *vino_v4l_device_name_b = "SGI VINO Channel B";
 
+static void vino_capture_tasklet(unsigned long channel);
+
+DECLARE_TASKLET(vino_tasklet_a, vino_capture_tasklet, VINO_CHANNEL_A);
+DECLARE_TASKLET(vino_tasklet_b, vino_capture_tasklet, VINO_CHANNEL_B);
+
 static const struct vino_input vino_inputs[] = {
        {
                .name           = "Composite",
-               .std            = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
+               .std            = V4L2_STD_NTSC | V4L2_STD_PAL
+               | V4L2_STD_SECAM,
        },{
                .name           = "S-Video",
-               .std            = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
+               .std            = V4L2_STD_NTSC | V4L2_STD_PAL
+               | V4L2_STD_SECAM,
        },{
-               .name           = "D1 (IndyCam)",
+               .name           = "D1/IndyCam",
                .std            = V4L2_STD_NTSC,
        }
 };
@@ -375,15 +389,10 @@
                .colorspace     = V4L2_COLORSPACE_SRGB,
        },{
                .description    = "YUV 4:2:2",
-               .bpp            = 4,
+               .bpp            = 2,
                .pixelformat    = V4L2_PIX_FMT_YUYV, // XXX: swapped?
                .colorspace     = V4L2_COLORSPACE_SMPTE170M,
-       }/*,{
-               .description    = "24-bit RGB",
-               .bpp            = 3,
-               .pixelformat    = V4L2_PIX_FMT_RGB24,
-               .colorspace     = V4L2_COLORSPACE_SRGB,
-               }*/
+       }
 };
 
 static const struct vino_data_norm vino_data_norms[] = {
@@ -396,18 +405,18 @@
                .width          = VINO_NTSC_WIDTH,
                .height         = VINO_NTSC_HEIGHT,
                .odd            = {
-                       .top    = VINO_CLIPPING_START_ODD_NTSC,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_ODD_NTSC,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_ODD_NTSC
                        + VINO_NTSC_HEIGHT / 2 - 1,
-                       .right  = VINO_NTSC_WIDTH,
+                       .right  = VINO_NTSC_WIDTH,
                },
                .even           = {
-                       .top    = VINO_CLIPPING_START_EVEN_NTSC,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_EVEN_NTSC,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_EVEN_NTSC
                        + VINO_NTSC_HEIGHT / 2 - 1,
-                       .right  = VINO_NTSC_WIDTH,
+                       .right  = VINO_NTSC_WIDTH,
                },
        },{
                .description    = "PAL",
@@ -418,18 +427,18 @@
                .width          = VINO_PAL_WIDTH,
                .height         = VINO_PAL_HEIGHT,
                .odd            = {
-                       .top    = VINO_CLIPPING_START_ODD_PAL,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_ODD_PAL,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_ODD_PAL
                        + VINO_PAL_HEIGHT / 2 - 1,
-                       .right  = VINO_PAL_WIDTH,
+                       .right  = VINO_PAL_WIDTH,
                },
                .even           = {
-                       .top    = VINO_CLIPPING_START_EVEN_PAL,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_EVEN_PAL,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_EVEN_PAL
                        + VINO_PAL_HEIGHT / 2 - 1,
-                       .right  = VINO_PAL_WIDTH,
+                       .right  = VINO_PAL_WIDTH,
                },
        },{
                .description    = "SECAM",
@@ -440,21 +449,21 @@
                .width          = VINO_PAL_WIDTH,
                .height         = VINO_PAL_HEIGHT,
                .odd            = {
-                       .top    = VINO_CLIPPING_START_ODD_PAL,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_ODD_PAL,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_ODD_PAL
                        + VINO_PAL_HEIGHT / 2 - 1,
-                       .right  = VINO_PAL_WIDTH,
+                       .right  = VINO_PAL_WIDTH,
                },
                .even           = {
-                       .top    = VINO_CLIPPING_START_EVEN_PAL,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_EVEN_PAL,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_EVEN_PAL
                        + VINO_PAL_HEIGHT / 2 - 1,
-                       .right  = VINO_PAL_WIDTH,
+                       .right  = VINO_PAL_WIDTH,
                },
        },{
-               .description    = "NTSC (D1 input)",
+               .description    = "NTSC/D1",
                .std            = V4L2_STD_NTSC,
                .fps_min        = 6,
                .fps_max        = 30,
@@ -462,18 +471,18 @@
                .width          = VINO_NTSC_WIDTH,
                .height         = VINO_NTSC_HEIGHT,
                .odd            = {
-                       .top    = VINO_CLIPPING_START_ODD_D1,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_ODD_D1,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_ODD_D1
                        + VINO_NTSC_HEIGHT / 2 - 1,
-                       .right  = VINO_NTSC_WIDTH,
+                       .right  = VINO_NTSC_WIDTH,
                },
                .even           = {
-                       .top    = VINO_CLIPPING_START_EVEN_D1,
-                       .left   = 0,
+                       .top    = VINO_CLIPPING_START_EVEN_D1,
+                       .left   = 0,
                        .bottom = VINO_CLIPPING_START_EVEN_D1
                        + VINO_NTSC_HEIGHT / 2 - 1,
-                       .right  = VINO_NTSC_WIDTH,
+                       .right  = VINO_NTSC_WIDTH,
                },
        }
 };
@@ -490,7 +499,7 @@
                .step = 1,
                .default_value = INDYCAM_AGC_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_AGC, 0 },
        },{
                .id = V4L2_CID_AUTO_WHITE_BALANCE,
                .type = V4L2_CTRL_TYPE_BOOLEAN,
@@ -500,7 +509,7 @@
                .step = 1,
                .default_value = INDYCAM_AWB_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_AWB, 0 },
        },{
                .id = V4L2_CID_GAIN,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -510,7 +519,7 @@
                .step = 1,
                .default_value = INDYCAM_GAIN_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_GAIN, 0 },
        },{
                .id = V4L2_CID_PRIVATE_BASE,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -520,7 +529,7 @@
                .step = 1,
                .default_value = INDYCAM_RED_SATURATION_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_RED_SATURATION, 0 },
        },{
                .id = V4L2_CID_PRIVATE_BASE + 1,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -530,7 +539,7 @@
                .step = 1,
                .default_value = INDYCAM_BLUE_SATURATION_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_BLUE_SATURATION, 0 },
        },{
                .id = V4L2_CID_RED_BALANCE,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -540,7 +549,7 @@
                .step = 1,
                .default_value = INDYCAM_RED_BALANCE_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_RED_BALANCE, 0 },
        },{
                .id = V4L2_CID_BLUE_BALANCE,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -550,7 +559,7 @@
                .step = 1,
                .default_value = INDYCAM_BLUE_BALANCE_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_BLUE_BALANCE, 0 },
        },{
                .id = V4L2_CID_EXPOSURE,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -560,7 +569,7 @@
                .step = 1,
                .default_value = INDYCAM_SHUTTER_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_SHUTTER, 0 },
        },{
                .id = V4L2_CID_GAMMA,
                .type = V4L2_CTRL_TYPE_INTEGER,
@@ -570,11 +579,11 @@
                .step = 1,
                .default_value = INDYCAM_GAMMA_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { INDYCAM_CONTROL_GAMMA, 0 },
        }
 };
 
-#define VINO_SAA7191_V4L2_CONTROL_COUNT                2
+#define VINO_SAA7191_V4L2_CONTROL_COUNT                9
 
 struct v4l2_queryctrl vino_saa7191_v4l2_controls[] = {
        {
@@ -586,9 +595,59 @@
                .step = 1,
                .default_value = SAA7191_HUE_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { SAA7191_CONTROL_HUE, 0 },
        },{
                .id = V4L2_CID_PRIVATE_BASE,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Luminance Bandpass",
+               .minimum = SAA7191_BANDPASS_MIN,
+               .maximum = SAA7191_BANDPASS_MAX,
+               .step = 1,
+               .default_value = SAA7191_BANDPASS_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_BANDPASS, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 1,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Luminance Bandpass Weight",
+               .minimum = SAA7191_BANDPASS_WEIGHT_MIN,
+               .maximum = SAA7191_BANDPASS_WEIGHT_MAX,
+               .step = 1,
+               .default_value = SAA7191_BANDPASS_WEIGHT_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_BANDPASS_WEIGHT, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 2,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "HF Luminance Coring",
+               .minimum = SAA7191_CORING_MIN,
+               .maximum = SAA7191_CORING_MAX,
+               .step = 1,
+               .default_value = SAA7191_CORING_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_CORING, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 3,
+               .type = V4L2_CTRL_TYPE_BOOLEAN,
+               .name = "Force Colour",
+               .minimum = SAA7191_FORCE_COLOUR_MIN,
+               .maximum = SAA7191_FORCE_COLOUR_MAX,
+               .step = 1,
+               .default_value = SAA7191_FORCE_COLOUR_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_FORCE_COLOUR, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 4,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Chrominance Gain Control",
+               .minimum = SAA7191_CHROMA_GAIN_MIN,
+               .maximum = SAA7191_CHROMA_GAIN_MAX,
+               .step = 1,
+               .default_value = SAA7191_CHROMA_GAIN_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_CHROMA_GAIN, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 5,
                .type = V4L2_CTRL_TYPE_BOOLEAN,
                .name = "VTR Time Constant",
                .minimum = SAA7191_VTRC_MIN,
@@ -596,7 +655,27 @@
                .step = 1,
                .default_value = SAA7191_VTRC_DEFAULT,
                .flags = 0,
-               .reserved = { 0, 0 },
+               .reserved = { SAA7191_CONTROL_VTRC, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 6,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Luminance Delay Compensation",
+               .minimum = SAA7191_LUMA_DELAY_MIN,
+               .maximum = SAA7191_LUMA_DELAY_MAX,
+               .step = 1,
+               .default_value = SAA7191_LUMA_DELAY_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_LUMA_DELAY, 0 },
+       },{
+               .id = V4L2_CID_PRIVATE_BASE + 7,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Vertical Noise Reduction",
+               .minimum = SAA7191_VNR_MIN,
+               .maximum = SAA7191_VNR_MAX,
+               .step = 1,
+               .default_value = SAA7191_VNR_DEFAULT,
+               .flags = 0,
+               .reserved = { SAA7191_CONTROL_VNR, 0 },
        }
 };
 
@@ -638,9 +717,10 @@
  */
 static int i2c_vino_client_reg(struct i2c_client *client)
 {
+       unsigned long flags;
        int ret = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
        switch (client->driver->id) {
        case I2C_DRIVERID_SAA7191:
                if (vino_drvdata->decoder.driver)
@@ -657,16 +737,17 @@
        default:
                ret = -ENODEV;
        }
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return ret;
 }
 
 static int i2c_vino_client_unreg(struct i2c_client *client)
 {
+       unsigned long flags;
        int ret = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
        if (client == vino_drvdata->decoder.driver) {
                if (vino_drvdata->decoder.owner != VINO_NO_CHANNEL)
                        ret = -EBUSY;
@@ -678,7 +759,7 @@
                else
                        vino_drvdata->camera.driver = NULL;
        }
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return ret;
 }
@@ -726,7 +807,7 @@
        dprintk("vino_free_buffer_with_count(): count = %d\n", count);
 
        for (i = 0; i < count; i++) {
-               mem_map_unreserve(virt_to_page(fb->desc_table.virtual[i]));
+               ClearPageReserved(virt_to_page(fb->desc_table.virtual[i]));
                dma_unmap_single(NULL,
                                 fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
                                 PAGE_SIZE, DMA_FROM_DEVICE);
@@ -804,7 +885,7 @@
                                dma_data_addr + VINO_PAGE_SIZE * j;
                }
 
-               mem_map_reserve(virt_to_page(fb->desc_table.virtual[i]));
+               SetPageReserved(virt_to_page(fb->desc_table.virtual[i]));
        }
 
        /* page_count needs to be set anyway, because the descriptor table has
@@ -891,7 +972,7 @@
                                dma_data_addr + VINO_PAGE_SIZE * j;
                }
 
-               mem_map_reserve(virt_to_page(fb->desc_table.virtual[i]));
+               SetPageReserved(virt_to_page(fb->desc_table.virtual[i]));
        }
 
        /* page_count needs to be set anyway, because the descriptor table has
@@ -932,7 +1013,7 @@
 
 /* Framebuffer fifo functions (need to be locked externally) */
 
-static void vino_fifo_init(struct vino_framebuffer_fifo *f,
+static inline void vino_fifo_init(struct vino_framebuffer_fifo *f,
                           unsigned int length)
 {
        f->length = 0;
@@ -940,16 +1021,18 @@
        f->head = 0;
        f->tail = 0;
 
-       if (length > VINO_FRAMEBUFFER_MAX_COUNT)
-               length = VINO_FRAMEBUFFER_MAX_COUNT;
+       if (length > VINO_FRAMEBUFFER_COUNT_MAX)
+               length = VINO_FRAMEBUFFER_COUNT_MAX;
 
        f->length = length;
 }
 
 /* returns true/false */
-static int vino_fifo_has_id(struct vino_framebuffer_fifo *f, unsigned int id)
+static inline int vino_fifo_has_id(struct vino_framebuffer_fifo *f,
+                                  unsigned int id)
 {
        unsigned int i;
+
        for (i = f->head; i == (f->tail - 1); i = (i + 1) % f->length) {
                if (f->data[i] == id)
                        return 1;
@@ -958,13 +1041,15 @@
        return 0;
 }
 
+#if 0
 /* returns true/false */
-static int vino_fifo_full(struct vino_framebuffer_fifo *f)
+static inline int vino_fifo_full(struct vino_framebuffer_fifo *f)
 {
        return (f->used == f->length);
 }
+#endif
 
-static unsigned int vino_fifo_get_used(struct vino_framebuffer_fifo *f)
+static inline unsigned int vino_fifo_get_used(struct vino_framebuffer_fifo *f)
 {
        return f->used;
 }
@@ -1075,8 +1160,8 @@
 
        down(&q->queue_sem);
 
-       if (*length > VINO_FRAMEBUFFER_MAX_COUNT)
-               *length = VINO_FRAMEBUFFER_MAX_COUNT;
+       if (*length > VINO_FRAMEBUFFER_COUNT_MAX)
+               *length = VINO_FRAMEBUFFER_COUNT_MAX;
 
        q->length = 0;
 
@@ -1312,6 +1397,7 @@
        return ret;
 }
 
+#if 0
 static int vino_queue_get_total(struct vino_framebuffer_queue *q,
                                unsigned int *total)
 {
@@ -1337,6 +1423,7 @@
 
        return ret;
 }
+#endif
 
 static struct vino_framebuffer *vino_queue_peek(struct
                                                vino_framebuffer_queue *q,
@@ -1470,12 +1557,14 @@
 
        dprintk("update_line_size(): before: w = %d, d = %d, "
                "line_size = %d\n", w, d, vcs->line_size);
+
         /* line size must be multiple of 8 bytes */
        lsize = (bpp * (w / d)) & ~7;
        w = (lsize / bpp) * d;
 
        vcs->clipping.right = vcs->clipping.left + w;
        vcs->line_size = lsize;
+
        dprintk("update_line_size(): after: w = %d, d = %d, "
                "line_size = %d\n", w, d, vcs->line_size);
 }
@@ -1531,7 +1620,7 @@
 }
 
 /* execute with input_lock locked */
-static void vino_set_default_clipping(struct vino_channel_settings *vcs)
+static inline void vino_set_default_clipping(struct vino_channel_settings *vcs)
 {
        vino_set_clipping(vcs, 0, 0, vino_data_norms[vcs->data_norm].width,
                          vino_data_norms[vcs->data_norm].height);
@@ -1555,8 +1644,7 @@
 
        if (d < 1) {
                d = 1;
-       }
-       if (d > 8) {
+       } else if (d > 8) {
                d = 8;
        }
 
@@ -1569,7 +1657,7 @@
 }
 
 /* execute with input_lock locked */
-static void vino_reset_scaling(struct vino_channel_settings *vcs)
+static inline void vino_set_default_scaling(struct vino_channel_settings *vcs)
 {
        vino_set_scaling(vcs, vcs->clipping.right - vcs->clipping.left,
                         vcs->clipping.bottom - vcs->clipping.top);
@@ -1648,7 +1736,8 @@
 }
 
 /* execute with input_lock locked */
-static void vino_set_default_framerate(struct vino_channel_settings *vcs)
+static inline void vino_set_default_framerate(struct
+                                             vino_channel_settings *vcs)
 {
        vino_set_framerate(vcs, vino_data_norms[vcs->data_norm].fps_max);
 }
@@ -1686,6 +1775,9 @@
         * should be more than enough time */
        udelay(VINO_DESC_FETCH_DELAY);
 
+       dprintk("vino_dma_setup(): start desc = %08x, next 4 desc = %08x\n",
+               ch->start_desc_tbl, ch->next_4_desc);
+
        /* set the alpha register */
        ch->alpha = vcs->alpha;
 
@@ -1699,9 +1791,6 @@
                VINO_CLIP_EVEN(norm->even.top +
                               vcs->clipping.bottom / 2 - 1) |
                VINO_CLIP_X(vcs->clipping.right);
-       /* FIXME: end-of-field bug workaround
-                      VINO_CLIP_X(VINO_PAL_WIDTH);
-        */
 
        /* set the size of actual content in the buffer (DECIMATION !) */
        fb->data_size = ((vcs->clipping.right - vcs->clipping.left) /
@@ -1801,7 +1890,7 @@
 }
 
 /* (execute only with vino_lock locked) */
-static void vino_dma_start(struct vino_channel_settings *vcs)
+static inline void vino_dma_start(struct vino_channel_settings *vcs)
 {
        u32 ctrl = vino->control;
 
@@ -1812,12 +1901,14 @@
 }
 
 /* (execute only with vino_lock locked) */
-static void vino_dma_stop(struct vino_channel_settings *vcs)
+static inline void vino_dma_stop(struct vino_channel_settings *vcs)
 {
        u32 ctrl = vino->control;
 
        ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
                ~VINO_CTRL_A_DMA_ENBL : ~VINO_CTRL_B_DMA_ENBL;
+       ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
+               ~VINO_CTRL_A_INT : ~VINO_CTRL_B_INT;
        vino->control = ctrl;
        dprintk("vino_dma_stop():\n");
 }
@@ -1901,7 +1992,7 @@
        struct vino_framebuffer *fb;
        unsigned int incoming, id;
        int err = 0;
-       unsigned long flags, flags2;
+       unsigned long flags;
 
        dprintk("vino_capture_next():\n");
 
@@ -1942,10 +2033,6 @@
                goto out;
        }
 
-       spin_lock_irqsave(&fb->state_lock, flags2);
-       fb->state = VINO_FRAMEBUFFER_UNUSED;
-       spin_unlock_irqrestore(&fb->state_lock, flags2);
-
        if (start) {
                vcs->capturing = 1;
        }
@@ -1963,7 +2050,7 @@
        return err;
 }
 
-static int vino_is_capturing(struct vino_channel_settings *vcs)
+static inline int vino_is_capturing(struct vino_channel_settings *vcs)
 {
        int ret;
        unsigned long flags;
@@ -2075,6 +2162,7 @@
        dprintk("vino_capture_stop():\n");
 
        spin_lock_irqsave(&vcs->capture_lock, flags);
+
        /* unset capturing to stop queue processing */
        vcs->capturing = 0;
 
@@ -2120,6 +2208,7 @@
        spin_unlock_irqrestore(&vcs->capture_lock, flags);
 }
 
+#if 0
 static int vino_capture_failed(struct vino_channel_settings *vcs)
 {
        struct vino_framebuffer *fb;
@@ -2164,9 +2253,31 @@
 
        return 0;
 }
+#endif
 
-static void vino_frame_done(struct vino_channel_settings *vcs,
-                           unsigned int fc)
+static void vino_skip_frame(struct vino_channel_settings *vcs)
+{
+       struct vino_framebuffer *fb;
+       unsigned long flags;
+       unsigned int id;
+
+       spin_lock_irqsave(&vcs->capture_lock, flags);
+       fb = vino_queue_peek(&vcs->fb_queue, &id);
+       if (!fb) {
+               spin_unlock_irqrestore(&vcs->capture_lock, flags);
+               dprintk("vino_skip_frame(): vino_queue_peek() failed!\n");
+               return;
+       }
+       spin_unlock_irqrestore(&vcs->capture_lock, flags);
+
+       spin_lock_irqsave(&fb->state_lock, flags);
+       fb->state = VINO_FRAMEBUFFER_UNUSED;
+       spin_unlock_irqrestore(&fb->state_lock, flags);
+
+       vino_capture_next(vcs, 0);
+}
+
+static void vino_frame_done(struct vino_channel_settings *vcs)
 {
        struct vino_framebuffer *fb;
        unsigned long flags;
@@ -2180,8 +2291,9 @@
        }
        spin_unlock_irqrestore(&vcs->capture_lock, flags);
 
-       fb->frame_counter = fc;
-       do_gettimeofday(&fb->timestamp);
+       fb->frame_counter = vcs->int_data.frame_counter;
+       memcpy(&fb->timestamp, &vcs->int_data.timestamp,
+              sizeof(struct timeval));
 
        spin_lock_irqsave(&fb->state_lock, flags);
        if (fb->state == VINO_FRAMEBUFFER_IN_USE)
@@ -2193,72 +2305,175 @@
        vino_capture_next(vcs, 0);
 }
 
+static void vino_capture_tasklet(unsigned long channel) {
+       struct vino_channel_settings *vcs;
+
+       vcs = (channel == VINO_CHANNEL_A)
+               ? &vino_drvdata->a : &vino_drvdata->b;
+
+       if (vcs->int_data.skip)
+               vcs->int_data.skip_count++;
+
+       if (vcs->int_data.skip && (vcs->int_data.skip_count
+                                  <= VINO_MAX_FRAME_SKIP_COUNT)) {
+               vino_skip_frame(vcs);
+       } else {
+               vcs->int_data.skip_count = 0;
+               vino_frame_done(vcs);
+       }
+}
+
 static irqreturn_t vino_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
-       u32 intr;
+       u32 ctrl, intr;
        unsigned int fc_a, fc_b;
-       int done_a = 0;
-       int done_b = 0;
-
-       spin_lock(&vino_drvdata->vino_lock);
+       int handled_a = 0, skip_a = 0, done_a = 0;
+       int handled_b = 0, skip_b = 0, done_b = 0;
 
-       intr = vino->intr_status;
-       fc_a = vino->a.field_counter / 2;
-       fc_b = vino->b.field_counter / 2;
+#ifdef VINO_DEBUG_INT
+       int loop = 0;
+       unsigned int line_count = vino->a.line_count,
+               page_index = vino->a.page_index,
+               field_counter = vino->a.field_counter,
+               start_desc_tbl = vino->a.start_desc_tbl,
+               next_4_desc = vino->a.next_4_desc;
+       unsigned int line_count_2,
+               page_index_2,
+               field_counter_2,
+               start_desc_tbl_2,
+               next_4_desc_2;
+#endif
 
-       // TODO: handle error-interrupts in some special way ?
+       spin_lock(&vino_drvdata->vino_lock);
 
-       if (intr & VINO_INTSTAT_A) {
-               if (intr & VINO_INTSTAT_A_EOF) {
-                       vino_drvdata->a.field++;
-                       if (vino_drvdata->a.field > 1) {
+       while ((intr = vino->intr_status)) {
+               fc_a = vino->a.field_counter >> 1;
+               fc_b = vino->b.field_counter >> 1;
+
+               /* handle error-interrupts in some special way ?
+                * --> skips frames */
+               if (intr & VINO_INTSTAT_A) {
+                       if (intr & VINO_INTSTAT_A_EOF) {
+                               vino_drvdata->a.field++;
+                               if (vino_drvdata->a.field > 1) {
+                                       vino_dma_stop(&vino_drvdata->a);
+                                       vino_clear_interrupt(&vino_drvdata->a);
+                                       vino_drvdata->a.field = 0;
+                                       done_a = 1;
+                               } else {
+                                       if (vino->a.page_index
+                                           != vino_drvdata->a.line_size) {
+                                               vino->a.line_count = 0;
+                                               vino->a.page_index =
+                                                       vino_drvdata->
+                                                       a.line_size;
+                                               vino->a.next_4_desc =
+                                                       vino->a.start_desc_tbl;
+                                       }
+                               }
+                               dprintk("channel A end-of-field "
+                                       "interrupt: %04x\n", intr);
+                       } else {
                                vino_dma_stop(&vino_drvdata->a);
                                vino_clear_interrupt(&vino_drvdata->a);
                                vino_drvdata->a.field = 0;
-                               done_a = 1;
+                               skip_a = 1;
+                               dprintk("channel A error interrupt: %04x\n",
+                                       intr);
                        }
-                       dprintk("intr: channel A end-of-field interrupt: "
-                               "%04x\n", intr);
-               } else {
-                       vino_dma_stop(&vino_drvdata->a);
-                       vino_clear_interrupt(&vino_drvdata->a);
-                       done_a = 1;
-                       dprintk("channel A error interrupt: %04x\n", intr);
+
+#ifdef VINO_DEBUG_INT
+                       line_count_2 = vino->a.line_count;
+                       page_index_2 = vino->a.page_index;
+                       field_counter_2 = vino->a.field_counter;
+                       start_desc_tbl_2 = vino->a.start_desc_tbl;
+                       next_4_desc_2 = vino->a.next_4_desc;
+
+                       printk("intr = %04x, loop = %d, field = %d\n",
+                              intr, loop, vino_drvdata->a.field);
+                       printk("1- line count = %04d, page index = %04d, "
+                              "start = %08x, next = %08x\n"
+                              "   fieldc = %d, framec = %d\n",
+                              line_count, page_index, start_desc_tbl,
+                              next_4_desc, field_counter, fc_a);
+                       printk("12-line count = %04d, page index = %04d, "
+                              "   start = %08x, next = %08x\n",
+                              line_count_2, page_index_2, start_desc_tbl_2,
+                              next_4_desc_2);
+
+                       if (done_a)
+                               printk("\n");
+#endif
                }
-       }
-       if (intr & VINO_INTSTAT_B) {
-               if (intr & VINO_INTSTAT_B_EOF) {
-                       vino_drvdata->b.field++;
-                       if (vino_drvdata->b.field > 1) {
+
+               if (intr & VINO_INTSTAT_B) {
+                       if (intr & VINO_INTSTAT_B_EOF) {
+                               vino_drvdata->b.field++;
+                               if (vino_drvdata->b.field > 1) {
+                                       vino_dma_stop(&vino_drvdata->b);
+                                       vino_clear_interrupt(&vino_drvdata->b);
+                                       vino_drvdata->b.field = 0;
+                                       done_b = 1;
+                               }
+                               dprintk("channel B end-of-field "
+                                       "interrupt: %04x\n", intr);
+                       } else {
                                vino_dma_stop(&vino_drvdata->b);
                                vino_clear_interrupt(&vino_drvdata->b);
                                vino_drvdata->b.field = 0;
-                               done_b = 1;
+                               skip_b = 1;
+                               dprintk("channel B error interrupt: %04x\n",
+                                       intr);
                        }
-                       dprintk("intr: channel B end-of-field interrupt: "
-                               "%04x\n", intr);
-               } else {
-                       vino_dma_stop(&vino_drvdata->b);
-                       vino_clear_interrupt(&vino_drvdata->b);
-                       done_b = 1;
-                       dprintk("channel B error interrupt: %04x\n", intr);
                }
-       }
 
-       /* always remember to clear interrupt status */
-       vino->intr_status = ~intr;
+               /* Always remember to clear interrupt status.
+                * Disable VINO interrupts while we do this. */
+               ctrl = vino->control;
+               vino->control = ctrl & ~(VINO_CTRL_A_INT | VINO_CTRL_B_INT);
+               vino->intr_status = ~intr;
+               vino->control = ctrl;
+
+               spin_unlock(&vino_drvdata->vino_lock);
+
+               if ((!handled_a) && (done_a || skip_a)) {
+                       if (!skip_a) {
+                               do_gettimeofday(&vino_drvdata->
+                                               a.int_data.timestamp);
+                               vino_drvdata->a.int_data.frame_counter = fc_a;
+                       }
+                       vino_drvdata->a.int_data.skip = skip_a;
 
-       spin_unlock(&vino_drvdata->vino_lock);
+                       dprintk("channel A %s, interrupt: %d\n",
+                               skip_a ? "skipping frame" : "frame done",
+                               intr);
+                       tasklet_hi_schedule(&vino_tasklet_a);
+                       handled_a = 1;
+               }
+
+               if ((!handled_b) && (done_b || skip_b)) {
+                       if (!skip_b) {
+                               do_gettimeofday(&vino_drvdata->
+                                               b.int_data.timestamp);
+                               vino_drvdata->b.int_data.frame_counter = fc_b;
+                       }
+                       vino_drvdata->b.int_data.skip = skip_b;
 
-       if (done_a) {
-               vino_frame_done(&vino_drvdata->a, fc_a);
-               dprintk("channel A frame done, interrupt: %d\n", intr);
-       }
-       if (done_b) {
-               vino_frame_done(&vino_drvdata->b, fc_b);
-               dprintk("channel B frame done, interrupt: %d\n", intr);
+                       dprintk("channel B %s, interrupt: %d\n",
+                               skip_b ? "skipping frame" : "frame done",
+                               intr);
+                       tasklet_hi_schedule(&vino_tasklet_b);
+                       handled_b = 1;
+               }
+
+#ifdef VINO_DEBUG_INT
+               loop++;
+#endif
+               spin_lock(&vino_drvdata->vino_lock);
        }
 
+       spin_unlock(&vino_drvdata->vino_lock);
+
        return IRQ_HANDLED;
 }
 
@@ -2278,11 +2493,13 @@
        }
 }
 
-static int vino_get_saa7191_norm(int norm)
+static int vino_get_saa7191_norm(unsigned int data_norm)
 {
-       switch (norm) {
+       switch (data_norm) {
        case VINO_DATA_NORM_AUTO:
                return SAA7191_NORM_AUTO;
+       case VINO_DATA_NORM_AUTO_EXT:
+               return SAA7191_NORM_AUTO_EXT;
        case VINO_DATA_NORM_PAL:
                return SAA7191_NORM_PAL;
        case VINO_DATA_NORM_NTSC:
@@ -2296,6 +2513,57 @@
        }
 }
 
+static int vino_get_from_saa7191_norm(int saa7191_norm)
+{
+       switch (saa7191_norm) {
+       case SAA7191_NORM_PAL:
+               return VINO_DATA_NORM_PAL;
+       case SAA7191_NORM_NTSC:
+               return VINO_DATA_NORM_NTSC;
+       case SAA7191_NORM_SECAM:
+               return VINO_DATA_NORM_SECAM;
+       default:
+               printk(KERN_ERR "VINO: vino_get_from_saa7191_norm(): "
+                      "invalid norm!\n");
+               return VINO_DATA_NORM_NONE;
+       }
+}
+
+static int vino_saa7191_set_norm(unsigned int *data_norm)
+{
+       int saa7191_norm, new_data_norm;
+       int err = 0;
+
+       saa7191_norm = vino_get_saa7191_norm(*data_norm);
+
+       err = i2c_decoder_command(DECODER_SAA7191_SET_NORM,
+                                 &saa7191_norm);
+       if (err)
+               goto out;
+
+       if ((*data_norm == VINO_DATA_NORM_AUTO)
+           || (*data_norm == VINO_DATA_NORM_AUTO_EXT)) {
+               struct saa7191_status status;
+
+               err = i2c_decoder_command(DECODER_SAA7191_GET_STATUS,
+                                         &status);
+               if (err)
+                       goto out;
+
+               new_data_norm =
+                       vino_get_from_saa7191_norm(status.norm);
+               if (new_data_norm == VINO_DATA_NORM_NONE) {
+                       err = -EINVAL;
+                       goto out;
+               }
+
+               *data_norm = (unsigned int)new_data_norm;
+       }
+
+out:
+       return err;
+}
+
 /* execute with input_lock locked */
 static int vino_is_input_owner(struct vino_channel_settings *vcs)
 {
@@ -2312,11 +2580,12 @@
 
 static int vino_acquire_input(struct vino_channel_settings *vcs)
 {
+       unsigned long flags;
        int ret = 0;
 
        dprintk("vino_acquire_input():\n");
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
        /* First try D1 and then SAA7191 */
        if (vino_drvdata->camera.driver
@@ -2331,23 +2600,48 @@
                vcs->data_norm = VINO_DATA_NORM_D1;
        } else if (vino_drvdata->decoder.driver
                   && (vino_drvdata->decoder.owner == VINO_NO_CHANNEL)) {
+               int input, data_norm;
                int saa7191_input;
-               int saa7191_norm;
 
                if (i2c_use_client(vino_drvdata->decoder.driver)) {
                        ret = -ENODEV;
                        goto out;
                }
 
-               vino_drvdata->decoder.owner = vcs->channel;
-               vcs->input = VINO_INPUT_COMPOSITE;
-               vcs->data_norm = VINO_DATA_NORM_PAL;
+               input = VINO_INPUT_COMPOSITE;
+
+               saa7191_input = vino_get_saa7191_input(input);
+               ret = i2c_decoder_command(DECODER_SET_INPUT,
+                                         &saa7191_input);
+               if (ret) {
+                       ret = -EINVAL;
+                       goto out;
+               }
+
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
-               saa7191_input = vino_get_saa7191_input(vcs->input);
-               i2c_decoder_command(DECODER_SET_INPUT, &saa7191_input);
+               /* Don't hold spinlocks while auto-detecting norm
+                * as it may take a while... */
 
-               saa7191_norm = vino_get_saa7191_norm(vcs->data_norm);
-               i2c_decoder_command(DECODER_SAA7191_SET_NORM, &saa7191_norm);
+               data_norm = VINO_DATA_NORM_AUTO_EXT;
+
+               ret = vino_saa7191_set_norm(&data_norm);
+               if ((ret == -EBUSY) || (ret == -EAGAIN)) {
+                       data_norm = VINO_DATA_NORM_PAL;
+                       ret = vino_saa7191_set_norm(&data_norm);
+               }
+
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
+               if (ret) {
+                       ret = -EINVAL;
+                       goto out;
+               }
+
+               vino_drvdata->decoder.owner = vcs->channel;
+
+               vcs->input = input;
+               vcs->data_norm = data_norm;
        } else {
                vcs->input = (vcs->channel == VINO_CHANNEL_A) ?
                        vino_drvdata->b.input : vino_drvdata->a.input;
@@ -2360,15 +2654,14 @@
                goto out;
        }
 
-       if (vino_is_input_owner(vcs)) {
-               vino_set_default_clipping(vcs);
-               vino_set_default_framerate(vcs);
-       }
+       vino_set_default_clipping(vcs);
+       vino_set_default_scaling(vcs);
+       vino_set_default_framerate(vcs);
 
        dprintk("vino_acquire_input(): %s\n", vino_inputs[vcs->input].name);
 
 out:
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return ret;
 }
@@ -2377,16 +2670,17 @@
 {
        struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
                &vino_drvdata->b : &vino_drvdata->a;
+       unsigned long flags;
        int ret = 0;
 
        dprintk("vino_set_input():\n");
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
        if (vcs->input == input)
                goto out;
 
-       switch(input) {
+       switch (input) {
        case VINO_INPUT_COMPOSITE:
        case VINO_INPUT_SVIDEO:
                if (!vino_drvdata->decoder.driver) {
@@ -2403,19 +2697,43 @@
                }
 
                if (vino_drvdata->decoder.owner == vcs->channel) {
+                       int data_norm;
                        int saa7191_input;
-                       int saa7191_norm;
 
-                       vcs->input = input;
-                       vcs->data_norm = VINO_DATA_NORM_PAL;
+                       saa7191_input = vino_get_saa7191_input(input);
+                       ret = i2c_decoder_command(DECODER_SET_INPUT,
+                                                 &saa7191_input);
+                       if (ret) {
+                               vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
+                               ret = -EINVAL;
+                               goto out;
+                       }
+
+                       spin_unlock_irqrestore(&vino_drvdata->input_lock, 
flags);
+
+                       /* Don't hold spinlocks while auto-detecting norm
+                        * as it may take a while... */
+
+                       data_norm = VINO_DATA_NORM_AUTO_EXT;
+
+                       ret = vino_saa7191_set_norm(&data_norm);
+                       if ((ret  == -EBUSY) || (ret == -EAGAIN)) {
+                               data_norm = VINO_DATA_NORM_PAL;
+                               ret = vino_saa7191_set_norm(&data_norm);
+                       }
 
-                       saa7191_input = vino_get_saa7191_input(vcs->input);
-                       i2c_decoder_command(DECODER_SET_INPUT, &saa7191_input);
-                       saa7191_norm = vino_get_saa7191_norm(vcs->data_norm);
-                       i2c_decoder_command(DECODER_SAA7191_SET_NORM,
-                                           &saa7191_norm);
+                       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
+                       if (ret) {
+                               vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
+                               ret = -EINVAL;
+                               goto out;
+                       }
+
+                       vcs->input = input;
+                       vcs->data_norm = data_norm;
                } else {
-                       if (vcs2->input != input) {
+                       if (input != vcs2->input) {
                                ret = -EBUSY;
                                goto out;
                        }
@@ -2470,12 +2788,13 @@
        }
 
        vino_set_default_clipping(vcs);
+       vino_set_default_scaling(vcs);
        vino_set_default_framerate(vcs);
 
        dprintk("vino_set_input(): %s\n", vino_inputs[vcs->input].name);
 
 out:
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return ret;
 }
@@ -2484,10 +2803,11 @@
 {
        struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
                &vino_drvdata->b : &vino_drvdata->a;
+       unsigned long flags;
 
        dprintk("vino_release_input():\n");
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
        /* Release ownership of the channel
         * and if the other channel takes input from
@@ -2510,34 +2830,61 @@
        }
        vcs->input = VINO_INPUT_NONE;
 
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 }
 
 /* execute with input_lock locked */
 static int vino_set_data_norm(struct vino_channel_settings *vcs,
-                             unsigned int data_norm)
+                             unsigned int data_norm,
+                             unsigned long *flags)
 {
-       int saa7191_norm;
+       int err = 0;
+
+       if (data_norm == vcs->data_norm)
+               return 0;
 
        switch (vcs->input) {
        case VINO_INPUT_D1:
                /* only one "norm" supported */
-               if (data_norm != VINO_DATA_NORM_D1)
+               if ((data_norm != VINO_DATA_NORM_D1)
+                   && (data_norm != VINO_DATA_NORM_AUTO)
+                   && (data_norm != VINO_DATA_NORM_AUTO_EXT))
                        return -EINVAL;
                break;
        case VINO_INPUT_COMPOSITE:
-       case VINO_INPUT_SVIDEO:
+       case VINO_INPUT_SVIDEO: {
+               if ((data_norm != VINO_DATA_NORM_PAL)
+                   && (data_norm != VINO_DATA_NORM_NTSC)
+                   && (data_norm != VINO_DATA_NORM_SECAM)
+                   && (data_norm != VINO_DATA_NORM_AUTO)
+                   && (data_norm != VINO_DATA_NORM_AUTO_EXT))
+                       return -EINVAL;
 
-               saa7191_norm = vino_get_saa7191_norm(data_norm);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, *flags);
+
+               /* Don't hold spinlocks while setting norm
+                * as it may take a while... */
+
+               err = vino_saa7191_set_norm(&data_norm);
+
+               spin_lock_irqsave(&vino_drvdata->input_lock, *flags);
+
+               if (err)
+                       goto out;
 
-               i2c_decoder_command(DECODER_SAA7191_SET_NORM, &saa7191_norm);
                vcs->data_norm = data_norm;
+
+               vino_set_default_clipping(vcs);
+               vino_set_default_scaling(vcs);
+               vino_set_default_framerate(vcs);
                break;
+       }
        default:
                return -EINVAL;
        }
 
-       return 0;
+out:
+       return err;
 }
 
 /* V4L2 helper functions */
@@ -2557,8 +2904,9 @@
 static int vino_enum_data_norm(struct vino_channel_settings *vcs, __u32 index)
 {
        int data_norm = VINO_DATA_NORM_NONE;
+       unsigned long flags;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
        switch(vcs->input) {
        case VINO_INPUT_COMPOSITE:
        case VINO_INPUT_SVIDEO:
@@ -2576,7 +2924,7 @@
                }
                break;
        }
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return data_norm;
 }
@@ -2584,8 +2932,9 @@
 static int vino_enum_input(struct vino_channel_settings *vcs, __u32 index)
 {
        int input = VINO_INPUT_NONE;
+       unsigned long flags;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
        if (vino_drvdata->decoder.driver && vino_drvdata->camera.driver) {
                switch (index) {
                case 0:
@@ -2614,7 +2963,7 @@
                        break;
                }
        }
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return input;
 }
@@ -2703,15 +3052,16 @@
 }
 
 static int vino_v4l2_g_input(struct vino_channel_settings *vcs,
-                            struct v4l2_input *i)
+                            unsigned int *i)
 {
        __u32 index;
        int input;
+       unsigned long flags;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
        input = vcs->input;
        index = vino_find_input_index(vcs);
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        dprintk("input = %d\n", input);
 
@@ -2719,23 +3069,18 @@
                return -EINVAL;
        }
 
-       memset(i, 0, sizeof(struct v4l2_input));
-
-       i->index = index;
-       i->type = V4L2_INPUT_TYPE_CAMERA;
-       i->std = vino_inputs[input].std;
-       strcpy(i->name, vino_inputs[input].name);
+       *i = index;
 
        return 0;
 }
 
 static int vino_v4l2_s_input(struct vino_channel_settings *vcs,
-                            struct v4l2_input *i)
+                            unsigned int *i)
 {
        int input;
-       dprintk("requested input = %d\n", i->index);
+       dprintk("requested input = %d\n", *i);
 
-       input = vino_enum_input(vcs, i->index);
+       input = vino_enum_input(vcs, *i);
        if (input == VINO_INPUT_NONE)
                return -EINVAL;
 
@@ -2746,7 +3091,9 @@
                             struct v4l2_standard *s)
 {
        int index = s->index;
-       int data_norm = vino_enum_data_norm(vcs, index);
+       int data_norm;
+
+       data_norm = vino_enum_data_norm(vcs, index);
        dprintk("standard index = %d\n", index);
 
        if (data_norm == VINO_DATA_NORM_NONE)
@@ -2770,13 +3117,55 @@
        return 0;
 }
 
+static int vino_v4l2_querystd(struct vino_channel_settings *vcs,
+                             v4l2_std_id *std)
+{
+       unsigned long flags;
+       int err = 0;
+
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
+       switch (vcs->input) {
+       case VINO_INPUT_D1:
+               *std = vino_inputs[vcs->input].std;
+               break;
+       case VINO_INPUT_COMPOSITE:
+       case VINO_INPUT_SVIDEO: {
+               struct saa7191_status status;
+
+               i2c_decoder_command(DECODER_SAA7191_GET_STATUS, &status);
+
+               if (status.signal) {
+                       if (status.signal_60hz) {
+                               *std = V4L2_STD_NTSC;
+                       } else {
+                               *std = V4L2_STD_PAL | V4L2_STD_SECAM;
+                       }
+               } else {
+                       *std = vino_inputs[vcs->input].std;
+               }
+               break;
+       }
+       default:
+               err = -EINVAL;
+       }
+
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
+
+       return err;
+}
+
 static int vino_v4l2_g_std(struct vino_channel_settings *vcs,
                           v4l2_std_id *std)
 {
-       spin_lock(&vino_drvdata->input_lock);
-       dprintk("current standard = %d\n", vcs->data_norm);
+       unsigned long flags;
+
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
        *std = vino_data_norms[vcs->data_norm].std;
-       spin_unlock(&vino_drvdata->input_lock);
+       dprintk("current standard = %d\n", vcs->data_norm);
+
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return 0;
 }
@@ -2784,13 +3173,18 @@
 static int vino_v4l2_s_std(struct vino_channel_settings *vcs,
                           v4l2_std_id *std)
 {
+       unsigned long flags;
        int ret = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
+       if (!vino_is_input_owner(vcs)) {
+               ret = -EBUSY;
+               goto out;
+       }
 
        /* check if the standard is valid for the current input */
-       if (vino_is_input_owner(vcs)
-           && (vino_inputs[vcs->input].std & (*std))) {
+       if ((*std) & vino_inputs[vcs->input].std) {
                dprintk("standard accepted\n");
 
                /* change the video norm for SAA7191
@@ -2799,24 +3193,33 @@
                if (vcs->input == VINO_INPUT_D1)
                        goto out;
 
-               if ((*std) & V4L2_STD_PAL) {
-                       vino_set_data_norm(vcs, VINO_DATA_NORM_PAL);
-                       vcs->data_norm = VINO_DATA_NORM_PAL;
+               if (((*std) & V4L2_STD_PAL)
+                   && ((*std) & V4L2_STD_NTSC)
+                   && ((*std) & V4L2_STD_SECAM)) {
+                       ret = vino_set_data_norm(vcs, VINO_DATA_NORM_AUTO_EXT,
+                                                &flags);
+               } else if ((*std) & V4L2_STD_PAL) {
+                       ret = vino_set_data_norm(vcs, VINO_DATA_NORM_PAL,
+                                                &flags);
                } else if ((*std) & V4L2_STD_NTSC) {
-                       vino_set_data_norm(vcs, VINO_DATA_NORM_NTSC);
-                       vcs->data_norm = VINO_DATA_NORM_NTSC;
+                       ret = vino_set_data_norm(vcs, VINO_DATA_NORM_NTSC,
+                                                &flags);
                } else if ((*std) & V4L2_STD_SECAM) {
-                       vino_set_data_norm(vcs, VINO_DATA_NORM_SECAM);
-                       vcs->data_norm = VINO_DATA_NORM_SECAM;
+                       ret = vino_set_data_norm(vcs, VINO_DATA_NORM_SECAM,
+                                                &flags);
                } else {
                        ret = -EINVAL;
                }
+
+               if (ret) {
+                       ret = -EINVAL;
+               }
        } else {
                ret = -EINVAL;
        }
 
 out:
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return ret;
 }
@@ -2854,6 +3257,7 @@
                             struct v4l2_format *f)
 {
        struct vino_channel_settings tempvcs;
+       unsigned long flags;
 
        switch (f->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
@@ -2862,13 +3266,13 @@
                dprintk("requested: w = %d, h = %d\n",
                       pf->width, pf->height);
 
-               spin_lock(&vino_drvdata->input_lock);
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
                memcpy(&tempvcs, vcs, sizeof(struct vino_channel_settings));
-               spin_unlock(&vino_drvdata->input_lock);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
                tempvcs.data_format = vino_find_data_format(pf->pixelformat);
                if (tempvcs.data_format == VINO_DATA_FMT_NONE) {
-                       tempvcs.data_format = VINO_DATA_FMT_RGB32;
+                       tempvcs.data_format = VINO_DATA_FMT_GREY;
                        pf->pixelformat =
                                vino_data_formats[tempvcs.data_format].
                                pixelformat;
@@ -2907,10 +3311,13 @@
 static int vino_v4l2_g_fmt(struct vino_channel_settings *vcs,
                           struct v4l2_format *f)
 {
+       unsigned long flags;
+
        switch (f->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
                struct v4l2_pix_format *pf = &f->fmt.pix;
-               spin_lock(&vino_drvdata->input_lock);
+
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
                pf->width = (vcs->clipping.right - vcs->clipping.left) /
                        vcs->decimation;
@@ -2929,7 +3336,7 @@
 
                pf->priv = 0;
 
-               spin_unlock(&vino_drvdata->input_lock);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
                break;
        }
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
@@ -2944,20 +3351,18 @@
                           struct v4l2_format *f)
 {
        int data_format;
+       unsigned long flags;
 
        switch (f->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
                struct v4l2_pix_format *pf = &f->fmt.pix;
-               spin_lock(&vino_drvdata->input_lock);
 
-               if (!vino_is_input_owner(vcs)) {
-                       spin_unlock(&vino_drvdata->input_lock);
-                       return -EINVAL;
-               }
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
                data_format = vino_find_data_format(pf->pixelformat);
+
                if (data_format == VINO_DATA_FMT_NONE) {
-                       vcs->data_format = VINO_DATA_FMT_RGB32;
+                       vcs->data_format = VINO_DATA_FMT_GREY;
                        pf->pixelformat =
                                vino_data_formats[vcs->data_format].
                                pixelformat;
@@ -2984,7 +3389,7 @@
 
                pf->priv = 0;
 
-               spin_unlock(&vino_drvdata->input_lock);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
                break;
        }
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
@@ -2999,12 +3404,15 @@
                             struct v4l2_cropcap *ccap)
 {
        const struct vino_data_norm *norm;
+       unsigned long flags;
 
        switch (ccap->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-               spin_lock(&vino_drvdata->input_lock);
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
                norm = &vino_data_norms[vcs->data_norm];
-               spin_unlock(&vino_drvdata->input_lock);
+
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
                ccap->bounds.left = 0;
                ccap->bounds.top = 0;
@@ -3027,16 +3435,18 @@
 static int vino_v4l2_g_crop(struct vino_channel_settings *vcs,
                            struct v4l2_crop *c)
 {
+       unsigned long flags;
+
        switch (c->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-               spin_lock(&vino_drvdata->input_lock);
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
                c->c.left = vcs->clipping.left;
                c->c.top = vcs->clipping.top;
                c->c.width = vcs->clipping.right - vcs->clipping.left;
                c->c.height = vcs->clipping.bottom - vcs->clipping.top;
 
-               spin_unlock(&vino_drvdata->input_lock);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
                break;
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
        default:
@@ -3049,18 +3459,16 @@
 static int vino_v4l2_s_crop(struct vino_channel_settings *vcs,
                            struct v4l2_crop *c)
 {
+       unsigned long flags;
+
        switch (c->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-               spin_lock(&vino_drvdata->input_lock);
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
-               if (!vino_is_input_owner(vcs)) {
-                       spin_unlock(&vino_drvdata->input_lock);
-                       return -EINVAL;
-               }
                vino_set_clipping(vcs, c->c.left, c->c.top,
                                  c->c.width, c->c.height);
 
-               spin_unlock(&vino_drvdata->input_lock);
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
                break;
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
        default:
@@ -3073,6 +3481,8 @@
 static int vino_v4l2_g_parm(struct vino_channel_settings *vcs,
                            struct v4l2_streamparm *sp)
 {
+       unsigned long flags;
+
        switch (sp->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
                struct v4l2_captureparm *cp = &sp->parm.capture;
@@ -3081,9 +3491,11 @@
                cp->capability = V4L2_CAP_TIMEPERFRAME;
                cp->timeperframe.numerator = 1;
 
-               spin_lock(&vino_drvdata->input_lock);
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
                cp->timeperframe.denominator = vcs->fps;
-               spin_unlock(&vino_drvdata->input_lock);
+
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
                // TODO: cp->readbuffers = xxx;
                break;
@@ -3099,15 +3511,13 @@
 static int vino_v4l2_s_parm(struct vino_channel_settings *vcs,
                            struct v4l2_streamparm *sp)
 {
+       unsigned long flags;
+
        switch (sp->type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
                struct v4l2_captureparm *cp = &sp->parm.capture;
 
-               spin_lock(&vino_drvdata->input_lock);
-               if (!vino_is_input_owner(vcs)) {
-                       spin_unlock(&vino_drvdata->input_lock);
-                       return -EINVAL;
-               }
+               spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
                if ((cp->timeperframe.numerator == 0) ||
                    (cp->timeperframe.denominator == 0)) {
@@ -3117,7 +3527,8 @@
                        vino_set_framerate(vcs, cp->timeperframe.denominator /
                                           cp->timeperframe.numerator);
                }
-               spin_unlock(&vino_drvdata->input_lock);
+
+               spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
                // TODO: set buffers according to cp->readbuffers
                break;
@@ -3144,21 +3555,23 @@
                        return -EINVAL;
                }
 
-               if (vino_is_capturing(vcs)) {
-                       dprintk("busy, capturing\n");
-                       return -EBUSY;
-               }
-
                dprintk("count = %d\n", rb->count);
                if (rb->count > 0) {
+                       if (vino_is_capturing(vcs)) {
+                               dprintk("busy, capturing\n");
+                               return -EBUSY;
+                       }
+
                        if (vino_queue_has_mapped_buffers(&vcs->fb_queue)) {
                                dprintk("busy, buffers still mapped\n");
                                return -EBUSY;
                        } else {
+                               vcs->streaming = 0;
                                vino_queue_free(&vcs->fb_queue);
                                vino_queue_init(&vcs->fb_queue, &rb->count);
                        }
                } else {
+                       vcs->streaming = 0;
                        vino_capture_stop(vcs);
                        vino_queue_free(&vcs->fb_queue);
                }
@@ -3301,12 +3714,12 @@
                err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
                if (err) {
                        dprintk("vino_queue_get_incoming() failed\n");
-                       return -EIO;
+                       return -EINVAL;
                }
                err = vino_queue_get_outgoing(&vcs->fb_queue, &outgoing);
                if (err) {
                        dprintk("vino_queue_get_outgoing() failed\n");
-                       return -EIO;
+                       return -EINVAL;
                }
 
                dprintk("incoming = %d, outgoing = %d\n", incoming, outgoing);
@@ -3326,8 +3739,10 @@
                        if (err) {
                                err = vino_wait_for_frame(vcs);
                                if (err) {
-                                       /* interrupted */
-                                       vino_capture_failed(vcs);
+                                       /* interrupted or
+                                        * no frames captured because
+                                        * of frame skipping */
+                                       // vino_capture_failed(vcs);
                                        return -EIO;
                                }
                        }
@@ -3340,10 +3755,12 @@
                }
 
                err = vino_check_buffer(vcs, fb);
+
+               vino_v4l2_get_buffer_status(vcs, fb, b);
+
                if (err)
                        return -EIO;
 
-               vino_v4l2_get_buffer_status(vcs, fb, b);
                break;
        }
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
@@ -3400,8 +3817,8 @@
        if (!vcs->streaming)
                return 0;
 
-       vino_capture_stop(vcs);
        vcs->streaming = 0;
+       vino_capture_stop(vcs);
 
        return 0;
 }
@@ -3409,10 +3826,11 @@
 static int vino_v4l2_queryctrl(struct vino_channel_settings *vcs,
                               struct v4l2_queryctrl *queryctrl)
 {
+       unsigned long flags;
        int i;
        int err = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
        switch (vcs->input) {
        case VINO_INPUT_D1:
@@ -3422,6 +3840,7 @@
                                memcpy(queryctrl,
                                       &vino_indycam_v4l2_controls[i],
                                       sizeof(struct v4l2_queryctrl));
+                               queryctrl->reserved[0] = 0;
                                goto found;
                        }
                }
@@ -3436,6 +3855,7 @@
                                memcpy(queryctrl,
                                       &vino_saa7191_v4l2_controls[i],
                                       sizeof(struct v4l2_queryctrl));
+                               queryctrl->reserved[0] = 0;
                                goto found;
                        }
                }
@@ -3447,7 +3867,7 @@
        }
 
  found:
-       spin_unlock(&vino_drvdata->input_lock);
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return err;
 }
@@ -3455,70 +3875,72 @@
 static int vino_v4l2_g_ctrl(struct vino_channel_settings *vcs,
                            struct v4l2_control *control)
 {
-       struct indycam_control indycam_ctrl;
-       struct saa7191_control saa7191_ctrl;
+       unsigned long flags;
+       int i;
        int err = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
 
        switch (vcs->input) {
-       case VINO_INPUT_D1:
-               i2c_camera_command(DECODER_INDYCAM_GET_CONTROLS,
-                                  &indycam_ctrl);
+       case VINO_INPUT_D1: {
+               struct indycam_control indycam_ctrl;
 
-               switch(control->id) {
-               case V4L2_CID_AUTOGAIN:
-                       control->value = indycam_ctrl.agc;
-                       break;
-               case V4L2_CID_AUTO_WHITE_BALANCE:
-                       control->value = indycam_ctrl.awb;
-                       break;
-               case V4L2_CID_GAIN:
-                       control->value = indycam_ctrl.gain;
-                       break;
-               case V4L2_CID_PRIVATE_BASE:
-                       control->value = indycam_ctrl.red_saturation;
-                       break;
-               case V4L2_CID_PRIVATE_BASE + 1:
-                       control->value = indycam_ctrl.blue_saturation;
-                       break;
-               case V4L2_CID_RED_BALANCE:
-                       control->value = indycam_ctrl.red_balance;
-                       break;
-               case V4L2_CID_BLUE_BALANCE:
-                       control->value = indycam_ctrl.blue_balance;
-                       break;
-               case V4L2_CID_EXPOSURE:
-                       control->value = indycam_ctrl.shutter;
-                       break;
-               case V4L2_CID_GAMMA:
-                       control->value = indycam_ctrl.gamma;
-                       break;
-               default:
+               for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
+                       if (vino_indycam_v4l2_controls[i].id ==
+                           control->id) {
+                               goto found1;
+                       }
+               }
+
+               err = -EINVAL;
+               goto out;
+
+found1:
+               indycam_ctrl.type = vino_indycam_v4l2_controls[i].reserved[0];
+
+               err = i2c_camera_command(DECODER_INDYCAM_GET_CONTROL,
+                                        &indycam_ctrl);
+               if (err) {
                        err = -EINVAL;
+                       goto out;
                }
+
+               control->value = indycam_ctrl.value;
                break;
+       }
        case VINO_INPUT_COMPOSITE:
-       case VINO_INPUT_SVIDEO:
-               i2c_decoder_command(DECODER_SAA7191_GET_CONTROLS,
-                                  &saa7191_ctrl);
+       case VINO_INPUT_SVIDEO: {
+               struct saa7191_control saa7191_ctrl;
 
-               switch(control->id) {
-               case V4L2_CID_HUE:
-                       control->value = saa7191_ctrl.hue;
-                       break;
-               case V4L2_CID_PRIVATE_BASE:
-                       control->value = saa7191_ctrl.vtrc;
-                       break;
-               default:
+               for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
+                       if (vino_saa7191_v4l2_controls[i].id ==
+                           control->id) {
+                               goto found2;
+                       }
+               }
+
+               err = -EINVAL;
+               goto out;
+
+found2:
+               saa7191_ctrl.type = vino_saa7191_v4l2_controls[i].reserved[0];
+
+               err = i2c_decoder_command(DECODER_SAA7191_GET_CONTROL,
+                                         &saa7191_ctrl);
+               if (err) {
                        err = -EINVAL;
+                       goto out;
                }
+
+               control->value = saa7191_ctrl.value;
                break;
+       }
        default:
                err =  -EINVAL;
        }
 
-       spin_unlock(&vino_drvdata->input_lock);
+out:
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return err;
 }
@@ -3526,15 +3948,21 @@
 static int vino_v4l2_s_ctrl(struct vino_channel_settings *vcs,
                            struct v4l2_control *control)
 {
-       struct indycam_control indycam_ctrl;
-       struct saa7191_control saa7191_ctrl;
+       unsigned long flags;
        int i;
        int err = 0;
 
-       spin_lock(&vino_drvdata->input_lock);
+       spin_lock_irqsave(&vino_drvdata->input_lock, flags);
+
+       if (!vino_is_input_owner(vcs)) {
+               err = -EBUSY;
+               goto out;
+       }
 
        switch (vcs->input) {
-       case VINO_INPUT_D1:
+       case VINO_INPUT_D1: {
+               struct indycam_control indycam_ctrl;
+
                for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
                        if (vino_indycam_v4l2_controls[i].id ==
                            control->id) {
@@ -3543,65 +3971,31 @@
                                    && (control->value <=
                                        vino_indycam_v4l2_controls[i].
                                        maximum)) {
-                                       goto ok1;
+                                       goto found1;
                                } else {
                                        err = -ERANGE;
-                                       goto error;
+                                       goto out;
                                }
                        }
                }
+
                err = -EINVAL;
-               goto error;
+               goto out;
 
-ok1:
-               indycam_ctrl.agc = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.awb = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.shutter = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.gain = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.red_balance = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.blue_balance = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.red_saturation = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.blue_saturation = INDYCAM_VALUE_UNCHANGED;
-               indycam_ctrl.gamma = INDYCAM_VALUE_UNCHANGED;
-
-               switch(control->id) {
-               case V4L2_CID_AUTOGAIN:
-                       indycam_ctrl.agc = control->value;
-                       break;
-               case V4L2_CID_AUTO_WHITE_BALANCE:
-                       indycam_ctrl.awb = control->value;
-                       break;
-               case V4L2_CID_GAIN:
-                       indycam_ctrl.gain = control->value;
-                       break;
-               case V4L2_CID_PRIVATE_BASE:
-                       indycam_ctrl.red_saturation = control->value;
-                       break;
-               case V4L2_CID_PRIVATE_BASE + 1:
-                       indycam_ctrl.blue_saturation = control->value;
-                       break;
-               case V4L2_CID_RED_BALANCE:
-                       indycam_ctrl.red_balance = control->value;
-                       break;
-               case V4L2_CID_BLUE_BALANCE:
-                       indycam_ctrl.blue_balance = control->value;
-                       break;
-               case V4L2_CID_EXPOSURE:
-                       indycam_ctrl.shutter = control->value;
-                       break;
-               case V4L2_CID_GAMMA:
-                       indycam_ctrl.gamma = control->value;
-                       break;
-               default:
-                       err =  -EINVAL;
-               }
+found1:
+               indycam_ctrl.type = vino_indycam_v4l2_controls[i].reserved[0];
+               indycam_ctrl.value = control->value;
 
-               if (!err)
-                       i2c_camera_command(DECODER_INDYCAM_SET_CONTROLS,
-                                          &indycam_ctrl);
+               err = i2c_camera_command(DECODER_INDYCAM_SET_CONTROL,
+                                        &indycam_ctrl);
+               if (err)
+                       err = -EINVAL;
                break;
+       }
        case VINO_INPUT_COMPOSITE:
-       case VINO_INPUT_SVIDEO:
+       case VINO_INPUT_SVIDEO: {
+               struct saa7191_control saa7191_ctrl;
+
                for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
                        if (vino_saa7191_v4l2_controls[i].id ==
                            control->id) {
@@ -3610,41 +4004,32 @@
                                    && (control->value <=
                                        vino_saa7191_v4l2_controls[i].
                                        maximum)) {
-                                       goto ok2;
+                                       goto found2;
                                } else {
                                        err = -ERANGE;
-                                       goto error;
+                                       goto out;
                                }
                        }
                }
                err = -EINVAL;
-               goto error;
+               goto out;
 
-ok2:
-               saa7191_ctrl.hue = SAA7191_VALUE_UNCHANGED;
-               saa7191_ctrl.vtrc = SAA7191_VALUE_UNCHANGED;
-
-               switch(control->id) {
-               case V4L2_CID_HUE:
-                       saa7191_ctrl.hue = control->value;
-                       break;
-               case V4L2_CID_PRIVATE_BASE:
-                       saa7191_ctrl.vtrc = control->value;
-                       break;
-               default:
-                       err =  -EINVAL;
-               }
+found2:
+               saa7191_ctrl.type = vino_saa7191_v4l2_controls[i].reserved[0];
+               saa7191_ctrl.value = control->value;
 
-               if (!err)
-                       i2c_decoder_command(DECODER_SAA7191_SET_CONTROLS,
-                                           &saa7191_ctrl);
+               err = i2c_decoder_command(DECODER_SAA7191_SET_CONTROL,
+                                         &saa7191_ctrl);
+               if (err)
+                       err = -EINVAL;
                break;
+       }
        default:
                err =  -EINVAL;
        }
 
-error:
-       spin_unlock(&vino_drvdata->input_lock);
+out:
+       spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
 
        return err;
 }
@@ -3864,9 +4249,9 @@
 over:
        dprintk("poll(): data %savailable\n",
                (outgoing > 0) ? "" : "not ");
-       if (outgoing > 0) {
+
+       if (outgoing > 0)
                ret = POLLIN | POLLRDNORM;
-       }
 
 error:
 
@@ -3879,6 +4264,7 @@
        struct video_device *dev = video_devdata(file);
        struct vino_channel_settings *vcs = video_get_drvdata(dev);
 
+#ifdef VINO_DEBUG
        switch (_IOC_TYPE(cmd)) {
        case 'v':
                dprintk("ioctl(): V4L1 unsupported (0x%08x)\n", cmd);
@@ -3890,9 +4276,9 @@
        default:
                dprintk("ioctl(): unsupported command 0x%08x\n", cmd);
        }
+#endif
 
        switch (cmd) {
-       /* TODO: V4L1 interface (use compatibility layer?) */
        /* V4L2 interface */
        case VIDIOC_QUERYCAP: {
                vino_v4l2_querycap(arg);
@@ -3910,6 +4296,9 @@
        case VIDIOC_ENUMSTD: {
                return vino_v4l2_enumstd(vcs, arg);
        }
+       case VIDIOC_QUERYSTD: {
+               return vino_v4l2_querystd(vcs, arg);
+       }
        case VIDIOC_G_STD: {
                return vino_v4l2_g_std(vcs, arg);
        }
@@ -4099,8 +4488,7 @@
                return -ENODEV;
        }
 
-       printk(KERN_INFO "VINO with chip ID %ld, revision %ld found\n",
-              VINO_ID_VALUE(rev_id), VINO_REV_NUM(rev_id));
+       printk(KERN_INFO "VINO revision %ld found\n", VINO_REV_NUM(rev_id));
 
        return 0;
 }

<Prev in Thread] Current Thread [Next in Thread>