V4L/DVB (8438): gspca: Lack of matrix for zc3xx - tas5130c (vf0250).
authorJean-Francois Moine <moinejf@free.fr>
Mon, 21 Jul 2008 08:42:17 +0000 (05:42 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Wed, 23 Jul 2008 22:00:31 +0000 (19:00 -0300)
Signed-off-by: Jean-Francois Moine <moinejf@free.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
drivers/media/video/gspca/zc3xx.c

index b761b11c5c6a45d8f9eba88b2620b127c322b456..f8d6f1780a45a14a9dbcd8e7b2c30d4e8e6bae51 100644 (file)
@@ -24,9 +24,6 @@
 
 #include "gspca.h"
 
-#define DRIVER_VERSION_NUMBER  KERNEL_VERSION(2, 1, 7)
-static const char version[] = "2.1.7";
-
 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>, "
                "Serge A. Suchkov <Serge.A.S@tochka.ru>");
 MODULE_DESCRIPTION("GSPCA ZC03xx/VC3xx USB Camera Driver");
@@ -49,7 +46,7 @@ struct sd {
        __u8 sharpness;
 
        char qindex;
-       char sensor;                    /* Type of image sensor chip */
+       signed char sensor;             /* Type of image sensor chip */
 /* !! values used in different tables */
 #define SENSOR_CS2102 0
 #define SENSOR_CS2102K 1
@@ -2205,10 +2202,10 @@ static const struct usb_action hdcs2020xb_InitialScale[] = {
 };
 static const struct usb_action hdcs2020b_50HZ[] = {
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
-       {0xaa, 0x13, 0x0018}, /* 00,13,18,aa */
-       {0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
-       {0xaa, 0x0e, 0x0005}, /* 00,0e,05,aa */
-       {0xaa, 0x19, 0x001f}, /* 00,19,1f,aa */
+       {0xaa, 0x13, 0x0018},                   /* 00,13,18,aa */
+       {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
+       {0xaa, 0x0e, 0x0005},                   /* 00,0e,05,aa */
+       {0xaa, 0x19, 0x001f},                   /* 00,19,1f,aa */
        {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH}, /* 01,90,00,cc */
        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID}, /* 01,91,02,cc */
        {0xa0, 0x76, ZC3XX_R192_EXPOSURELIMITLOW}, /* 01,92,76,cc */
@@ -2226,10 +2223,10 @@ static const struct usb_action hdcs2020b_50HZ[] = {
 };
 static const struct usb_action hdcs2020b_60HZ[] = {
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
-       {0xaa, 0x13, 0x0031}, /* 00,13,31,aa */
-       {0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
-       {0xaa, 0x0e, 0x0004}, /* 00,0e,04,aa */
-       {0xaa, 0x19, 0x00cd}, /* 00,19,cd,aa */
+       {0xaa, 0x13, 0x0031},                   /* 00,13,31,aa */
+       {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
+       {0xaa, 0x0e, 0x0004},                   /* 00,0e,04,aa */
+       {0xaa, 0x19, 0x00cd},                   /* 00,19,cd,aa */
        {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH}, /* 01,90,00,cc */
        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID}, /* 01,91,02,cc */
        {0xa0, 0x62, ZC3XX_R192_EXPOSURELIMITLOW}, /* 01,92,62,cc */
@@ -2247,10 +2244,10 @@ static const struct usb_action hdcs2020b_60HZ[] = {
 };
 static const struct usb_action hdcs2020b_NoFliker[] = {
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
-       {0xaa, 0x13, 0x0010}, /* 00,13,10,aa */
-       {0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
-       {0xaa, 0x0e, 0x0004}, /* 00,0e,04,aa */
-       {0xaa, 0x19, 0x0000}, /* 00,19,00,aa */
+       {0xaa, 0x13, 0x0010},                   /* 00,13,10,aa */
+       {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
+       {0xaa, 0x0e, 0x0004},                   /* 00,0e,04,aa */
+       {0xaa, 0x19, 0x0000},                   /* 00,19,00,aa */
        {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH}, /* 01,90,00,cc */
        {0xa0, 0x02, ZC3XX_R191_EXPOSURELIMITMID}, /* 01,91,02,cc */
        {0xa0, 0x70, ZC3XX_R192_EXPOSURELIMITLOW}, /* 01,92,70,cc */
@@ -4102,27 +4099,27 @@ static const struct usb_action pas106b_Initial_com[] = {
 
 static const struct usb_action pas106b_Initial[] = {   /* 176x144 */
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},          /* ClockSetting */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
 /* Sream and Sensor specific */
-       {0xa0, 0x0f, ZC3XX_R010_CMOSSENSORSELECT},      /* CMOSSensorSelect */
+       {0xa0, 0x0f, ZC3XX_R010_CMOSSENSORSELECT},
 /* Picture size */
-       {0xa0, 0x00, ZC3XX_R003_FRAMEWIDTHHIGH},  /* FrameWidthHigh 00 */
-       {0xa0, 0xb0, ZC3XX_R004_FRAMEWIDTHLOW},   /* FrameWidthLow B0 */
-       {0xa0, 0x00, ZC3XX_R005_FRAMEHEIGHTHIGH}, /* FrameHeightHigh 00 */
-       {0xa0, 0x90, ZC3XX_R006_FRAMEHEIGHTLOW},  /* FrameHightLow 90 */
+       {0xa0, 0x00, ZC3XX_R003_FRAMEWIDTHHIGH},
+       {0xa0, 0xb0, ZC3XX_R004_FRAMEWIDTHLOW},
+       {0xa0, 0x00, ZC3XX_R005_FRAMEHEIGHTHIGH},
+       {0xa0, 0x90, ZC3XX_R006_FRAMEHEIGHTLOW},
 /* System */
-       {0xa0, 0x01, ZC3XX_R001_SYSTEMOPERATING}, /* SystemOperating */
+       {0xa0, 0x01, ZC3XX_R001_SYSTEMOPERATING},
 /* Sream and Sensor specific */
-       {0xa0, 0x03, ZC3XX_R012_VIDEOCONTROLFUNC}, /* VideoControlFunction */
-       {0xa0, 0x01, ZC3XX_R012_VIDEOCONTROLFUNC}, /* VideoControlFunction */
+       {0xa0, 0x03, ZC3XX_R012_VIDEOCONTROLFUNC},
+       {0xa0, 0x01, ZC3XX_R012_VIDEOCONTROLFUNC},
 /* Sensor Interface */
-       {0xa0, 0x08, ZC3XX_R08D_COMPABILITYMODE},  /* Compatibily Mode */
+       {0xa0, 0x08, ZC3XX_R08D_COMPABILITYMODE},
 /* Window inside sensor array */
-       {0xa0, 0x03, ZC3XX_R09A_WINXSTARTLOW},  /* WinXStartLow */
-       {0xa0, 0x00, ZC3XX_R11A_FIRSTYLOW},     /* FirstYLow */
-       {0xa0, 0x03, ZC3XX_R11C_FIRSTXLOW},     /* FirstxLow */
-       {0xa0, 0x28, ZC3XX_R09C_WINHEIGHTLOW},  /* WinHeightLow */
-       {0xa0, 0x68, ZC3XX_R09E_WINWIDTHLOW},   /* WinWidthLow */
+       {0xa0, 0x03, ZC3XX_R09A_WINXSTARTLOW},
+       {0xa0, 0x00, ZC3XX_R11A_FIRSTYLOW},
+       {0xa0, 0x03, ZC3XX_R11C_FIRSTXLOW},
+       {0xa0, 0x28, ZC3XX_R09C_WINHEIGHTLOW},
+       {0xa0, 0x68, ZC3XX_R09E_WINWIDTHLOW},
 /* Init the sensor */
        {0xaa, 0x02, 0x0004},
        {0xaa, 0x08, 0x0000},
@@ -4135,40 +4132,40 @@ static const struct usb_action pas106b_Initial[] = {    /* 176x144 */
        {0xaa, 0x14, 0x0081},
 
 /* Other registors */
-       {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION}, /* SensorCorrection */
+       {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION},
 /* Frame retreiving */
-       {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* AutoAdjustFPS */
+       {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
 /* Gains */
-       {0xa0, 0xa0, ZC3XX_R1A8_DIGITALGAIN},   /* DigitalGain */
+       {0xa0, 0xa0, ZC3XX_R1A8_DIGITALGAIN},
 /* Unknown */
        {0xa0, 0x00, 0x01ad},
 /* Sharpness */
-       {0xa0, 0x03, ZC3XX_R1C5_SHARPNESSMODE}, /* SharpnessMode */
-       {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},   /* Sharpness05 */
+       {0xa0, 0x03, ZC3XX_R1C5_SHARPNESSMODE},
+       {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},
 /* Other registors */
-       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE}, /* OperationMode */
+       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE},
 /* Auto exposure and white balance */
-       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},     /* AWBStatus */
+       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},
 /*Dead pixels */
-       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE}, /* DeadPixelsMode */
+       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},
 /* EEPROM */
-       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},  /* EEPROMAccess */
+       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* ClockSetting */
-       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},   /* sharpness+ */
-       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},   /* sharpness- */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
+       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},
+       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},
 /* Other registers */
-       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE}, /* OperationMode */
+       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE},
 /* Auto exposure and white balance */
-       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},     /* AWBStatus */
+       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},
 /*Dead pixels */
-       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE}, /* DeadPixelsMode */
+       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},
 /* EEPROM */
-       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},  /* EEPROMAccess */
+       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* ClockSetting */
-       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},   /* sharpness+ */
-       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},   /* sharpness- */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
+       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},
+       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},
 
        {0xa0, 0x58, ZC3XX_R10A_RGB00}, /* matrix */
        {0xa0, 0xf4, ZC3XX_R10B_RGB01},
@@ -4180,67 +4177,67 @@ static const struct usb_action pas106b_Initial[] = {    /* 176x144 */
        {0xa0, 0xf4, ZC3XX_R111_RGB21},
        {0xa0, 0x58, ZC3XX_R112_RGB22},
 /* Auto correction */
-       {0xa0, 0x03, ZC3XX_R181_WINXSTART},     /* WinXstart */
-       {0xa0, 0x08, ZC3XX_R182_WINXWIDTH},     /* WinXWidth */
-       {0xa0, 0x16, ZC3XX_R183_WINXCENTER},    /* WinXCenter */
-       {0xa0, 0x03, ZC3XX_R184_WINYSTART},     /* WinYStart */
-       {0xa0, 0x05, ZC3XX_R185_WINYWIDTH},     /* WinYWidth */
-       {0xa0, 0x14, ZC3XX_R186_WINYCENTER},    /* WinYCenter */
-       {0xa0, 0x00, ZC3XX_R180_AUTOCORRECTENABLE}, /* AutoCorrectEnable */
+       {0xa0, 0x03, ZC3XX_R181_WINXSTART},
+       {0xa0, 0x08, ZC3XX_R182_WINXWIDTH},
+       {0xa0, 0x16, ZC3XX_R183_WINXCENTER},
+       {0xa0, 0x03, ZC3XX_R184_WINYSTART},
+       {0xa0, 0x05, ZC3XX_R185_WINYWIDTH},
+       {0xa0, 0x14, ZC3XX_R186_WINYCENTER},
+       {0xa0, 0x00, ZC3XX_R180_AUTOCORRECTENABLE},
 
 /* Auto exposure and white balance */
-       {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* ExposureLimitHigh */
-       {0xa0, 0x03, ZC3XX_R191_EXPOSURELIMITMID},      /* ExposureLimitMid */
-       {0xa0, 0xb1, ZC3XX_R192_EXPOSURELIMITLOW},      /* ExposureLimitLow */
-       {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* AntiFlickerHigh */
-       {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* AntiFlickerLow */
-       {0xa0, 0x87, ZC3XX_R197_ANTIFLICKERLOW},        /* AntiFlickerLow */
-       {0xa0, 0x0c, ZC3XX_R18C_AEFREEZE},              /* AEBFreeze */
-       {0xa0, 0x18, ZC3XX_R18F_AEUNFREEZE},            /* AEBUnfreeze */
+       {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},
+       {0xa0, 0x03, ZC3XX_R191_EXPOSURELIMITMID},
+       {0xa0, 0xb1, ZC3XX_R192_EXPOSURELIMITLOW},
+       {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},
+       {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},
+       {0xa0, 0x87, ZC3XX_R197_ANTIFLICKERLOW},
+       {0xa0, 0x0c, ZC3XX_R18C_AEFREEZE},
+       {0xa0, 0x18, ZC3XX_R18F_AEUNFREEZE},
 /* sensor on */
        {0xaa, 0x07, 0x00b1},
        {0xaa, 0x05, 0x0003},
        {0xaa, 0x04, 0x0001},
        {0xaa, 0x03, 0x003b},
 /* Gains */
-       {0xa0, 0x20, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* DigitalLimitDiff */
-       {0xa0, 0x26, ZC3XX_R1AA_DIGITALGAINSTEP},       /* DigitalGainStep */
-       {0xa0, 0xa0, ZC3XX_R11D_GLOBALGAIN},            /* GlobalGain */
-       {0xa0, 0x60, ZC3XX_R11D_GLOBALGAIN},            /* GlobalGain */
+       {0xa0, 0x20, ZC3XX_R1A9_DIGITALLIMITDIFF},
+       {0xa0, 0x26, ZC3XX_R1AA_DIGITALGAINSTEP},
+       {0xa0, 0xa0, ZC3XX_R11D_GLOBALGAIN},
+       {0xa0, 0x60, ZC3XX_R11D_GLOBALGAIN},
 /* Auto correction */
-       {0xa0, 0x40, ZC3XX_R180_AUTOCORRECTENABLE},     /* AutoCorrectEnable */
+       {0xa0, 0x40, ZC3XX_R180_AUTOCORRECTENABLE},
        {0xa1, 0x01, 0x0180},                           /* AutoCorrectEnable */
-       {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* AutoCorrectEnable */
+       {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},
 /* Gains */
-       {0xa0, 0x40, ZC3XX_R116_RGAIN},                 /* RGain */
-       {0xa0, 0x40, ZC3XX_R117_GGAIN},                 /* GGain */
-       {0xa0, 0x40, ZC3XX_R118_BGAIN},                 /* BGain */
+       {0xa0, 0x40, ZC3XX_R116_RGAIN},
+       {0xa0, 0x40, ZC3XX_R117_GGAIN},
+       {0xa0, 0x40, ZC3XX_R118_BGAIN},
        {}
 };
 
 static const struct usb_action pas106b_InitialScale[] = {      /* 352x288 */
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},          /* ClockSetting */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
 /* Sream and Sensor specific */
-       {0xa0, 0x0f, ZC3XX_R010_CMOSSENSORSELECT},      /* CMOSSensorSelect */
+       {0xa0, 0x0f, ZC3XX_R010_CMOSSENSORSELECT},
 /* Picture size */
-       {0xa0, 0x01, ZC3XX_R003_FRAMEWIDTHHIGH},        /* FrameWidthHigh */
-       {0xa0, 0x60, ZC3XX_R004_FRAMEWIDTHLOW},         /* FrameWidthLow */
-       {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},       /* FrameHeightHigh */
-       {0xa0, 0x20, ZC3XX_R006_FRAMEHEIGHTLOW},        /* FrameHightLow */
+       {0xa0, 0x01, ZC3XX_R003_FRAMEWIDTHHIGH},
+       {0xa0, 0x60, ZC3XX_R004_FRAMEWIDTHLOW},
+       {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},
+       {0xa0, 0x20, ZC3XX_R006_FRAMEHEIGHTLOW},
 /* System */
-       {0xa0, 0x01, ZC3XX_R001_SYSTEMOPERATING},       /* SystemOperating */
+       {0xa0, 0x01, ZC3XX_R001_SYSTEMOPERATING},
 /* Sream and Sensor specific */
-       {0xa0, 0x03, ZC3XX_R012_VIDEOCONTROLFUNC}, /* VideoControlFunction */
-       {0xa0, 0x01, ZC3XX_R012_VIDEOCONTROLFUNC}, /* VideoControlFunction */
+       {0xa0, 0x03, ZC3XX_R012_VIDEOCONTROLFUNC},
+       {0xa0, 0x01, ZC3XX_R012_VIDEOCONTROLFUNC},
 /* Sensor Interface */
-       {0xa0, 0x08, ZC3XX_R08D_COMPABILITYMODE},       /* Compatibily Mode */
+       {0xa0, 0x08, ZC3XX_R08D_COMPABILITYMODE},
 /* Window inside sensor array */
-       {0xa0, 0x03, ZC3XX_R09A_WINXSTARTLOW},  /* WinXStartLow */
-       {0xa0, 0x00, ZC3XX_R11A_FIRSTYLOW},     /* FirstYLow */
-       {0xa0, 0x03, ZC3XX_R11C_FIRSTXLOW},     /* FirstxLow */
-       {0xa0, 0x28, ZC3XX_R09C_WINHEIGHTLOW},  /* WinHeightLow */
-       {0xa0, 0x68, ZC3XX_R09E_WINWIDTHLOW},   /* WinWidthLow */
+       {0xa0, 0x03, ZC3XX_R09A_WINXSTARTLOW},
+       {0xa0, 0x00, ZC3XX_R11A_FIRSTYLOW},
+       {0xa0, 0x03, ZC3XX_R11C_FIRSTXLOW},
+       {0xa0, 0x28, ZC3XX_R09C_WINHEIGHTLOW},
+       {0xa0, 0x68, ZC3XX_R09E_WINWIDTHLOW},
 /* Init the sensor */
        {0xaa, 0x02, 0x0004},
        {0xaa, 0x08, 0x0000},
@@ -4253,41 +4250,41 @@ static const struct usb_action pas106b_InitialScale[] = {       /* 352x288 */
        {0xaa, 0x14, 0x0081},
 
 /* Other registors */
-       {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION}, /* SensorCorrection */
+       {0xa0, 0x37, ZC3XX_R101_SENSORCORRECTION},
 /* Frame retreiving */
-       {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* AutoAdjustFPS */
+       {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS},
 /* Gains */
-       {0xa0, 0xa0, ZC3XX_R1A8_DIGITALGAIN},   /* DigitalGain */
+       {0xa0, 0xa0, ZC3XX_R1A8_DIGITALGAIN},
 /* Unknown */
        {0xa0, 0x00, 0x01ad},
 /* Sharpness */
-       {0xa0, 0x03, ZC3XX_R1C5_SHARPNESSMODE}, /* SharpnessMode */
-       {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},   /* Sharpness05 */
+       {0xa0, 0x03, ZC3XX_R1C5_SHARPNESSMODE},
+       {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},
 /* Other registors */
-       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE}, /* OperationMode */
+       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE},
 /* Auto exposure and white balance */
-       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},     /* AWBStatus */
-       {0xa0, 0x80, ZC3XX_R18D_YTARGET},       /* ????????? */
+       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},
+       {0xa0, 0x80, ZC3XX_R18D_YTARGET},
 /*Dead pixels */
-       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE}, /* DeadPixelsMode */
+       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},
 /* EEPROM */
-       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},  /* EEPROMAccess */
+       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* ClockSetting */
-       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},   /* sharpness+ */
-       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},   /* sharpness- */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
+       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},
+       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},
 /* Other registers */
-       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE}, /* OperationMode */
+       {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE},
 /* Auto exposure and white balance */
-       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},     /* AWBStatus */
+       {0xa0, 0x06, ZC3XX_R189_AWBSTATUS},
 /*Dead pixels */
-       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE}, /* DeadPixelsMode */
+       {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},
 /* EEPROM */
-       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},  /* EEPROMAccess */
+       {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},
 /* JPEG control */
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* ClockSetting */
-       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},   /* sharpness+ */
-       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},   /* sharpness- */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
+       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},
+       {0xa0, 0x0f, ZC3XX_R1CB_SHARPNESS05},
 
        {0xa0, 0x58, ZC3XX_R10A_RGB00}, /* matrix */
        {0xa0, 0xf4, ZC3XX_R10B_RGB01},
@@ -4299,43 +4296,43 @@ static const struct usb_action pas106b_InitialScale[] = {       /* 352x288 */
        {0xa0, 0xf4, ZC3XX_R111_RGB21},
        {0xa0, 0x58, ZC3XX_R112_RGB22},
 /* Auto correction */
-       {0xa0, 0x03, ZC3XX_R181_WINXSTART},     /* WinXstart */
-       {0xa0, 0x08, ZC3XX_R182_WINXWIDTH},     /* WinXWidth */
-       {0xa0, 0x16, ZC3XX_R183_WINXCENTER},    /* WinXCenter */
-       {0xa0, 0x03, ZC3XX_R184_WINYSTART},     /* WinYStart */
-       {0xa0, 0x05, ZC3XX_R185_WINYWIDTH},     /* WinYWidth */
-       {0xa0, 0x14, ZC3XX_R186_WINYCENTER},    /* WinYCenter */
-       {0xa0, 0x00, ZC3XX_R180_AUTOCORRECTENABLE}, /* AutoCorrectEnable */
+       {0xa0, 0x03, ZC3XX_R181_WINXSTART},
+       {0xa0, 0x08, ZC3XX_R182_WINXWIDTH},
+       {0xa0, 0x16, ZC3XX_R183_WINXCENTER},
+       {0xa0, 0x03, ZC3XX_R184_WINYSTART},
+       {0xa0, 0x05, ZC3XX_R185_WINYWIDTH},
+       {0xa0, 0x14, ZC3XX_R186_WINYCENTER},
+       {0xa0, 0x00, ZC3XX_R180_AUTOCORRECTENABLE},
 
 /* Auto exposure and white balance */
-       {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH}, /* ExposureLimitHigh 0 */
-       {0xa0, 0x03, ZC3XX_R191_EXPOSURELIMITMID},  /* ExposureLimitMid */
-       {0xa0, 0xb1, ZC3XX_R192_EXPOSURELIMITLOW},  /* ExposureLimitLow 0xb1 */
+       {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},
+       {0xa0, 0x03, ZC3XX_R191_EXPOSURELIMITMID},
+       {0xa0, 0xb1, ZC3XX_R192_EXPOSURELIMITLOW},
 
-       {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},   /* AntiFlickerHigh 0x00 */
-       {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},    /* AntiFlickerLow 0x00 */
-       {0xa0, 0x87, ZC3XX_R197_ANTIFLICKERLOW},    /* AntiFlickerLow 0x87 */
+       {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},
+       {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},
+       {0xa0, 0x87, ZC3XX_R197_ANTIFLICKERLOW},
 
-       {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},      /* AEBFreeze 0x10 0x0c */
-       {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},    /* AEBUnfreeze 0x30 0x18 */
+       {0xa0, 0x10, ZC3XX_R18C_AEFREEZE},
+       {0xa0, 0x20, ZC3XX_R18F_AEUNFREEZE},
 /* sensor on */
        {0xaa, 0x07, 0x00b1},
        {0xaa, 0x05, 0x0003},
        {0xaa, 0x04, 0x0001},
        {0xaa, 0x03, 0x003b},
 /* Gains */
-       {0xa0, 0x20, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* DigitalLimitDiff */
-       {0xa0, 0x26, ZC3XX_R1AA_DIGITALGAINSTEP},       /* DigitalGainStep */
-       {0xa0, 0xa0, ZC3XX_R11D_GLOBALGAIN},    /* GlobalGain */
-       {0xa0, 0x60, ZC3XX_R11D_GLOBALGAIN},    /* GlobalGain */
+       {0xa0, 0x20, ZC3XX_R1A9_DIGITALLIMITDIFF},
+       {0xa0, 0x26, ZC3XX_R1AA_DIGITALGAINSTEP},
+       {0xa0, 0xa0, ZC3XX_R11D_GLOBALGAIN},
+       {0xa0, 0x60, ZC3XX_R11D_GLOBALGAIN},
 /* Auto correction */
-       {0xa0, 0x40, ZC3XX_R180_AUTOCORRECTENABLE},     /* AutoCorrectEnable */
+       {0xa0, 0x40, ZC3XX_R180_AUTOCORRECTENABLE},
        {0xa1, 0x01, 0x0180},                           /* AutoCorrectEnable */
-       {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* AutoCorrectEnable */
+       {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},
 /* Gains */
-       {0xa0, 0x40, ZC3XX_R116_RGAIN},         /* RGain */
-       {0xa0, 0x40, ZC3XX_R117_GGAIN},         /* GGain */
-       {0xa0, 0x40, ZC3XX_R118_BGAIN},         /* BGain */
+       {0xa0, 0x40, ZC3XX_R116_RGAIN},
+       {0xa0, 0x40, ZC3XX_R117_GGAIN},
+       {0xa0, 0x40, ZC3XX_R118_BGAIN},
 
        {0xa0, 0x00, 0x0007},                   /* AutoCorrectEnable */
        {0xa0, 0xff, ZC3XX_R018_FRAMELOST},     /* Frame adjust */
@@ -4459,8 +4456,8 @@ static const struct usb_action pb03303x_Initial[] = {
        {0xa0, 0x50, ZC3XX_R112_RGB22},
 
        {0xa1, 0x01, 0x0008},
-       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* clock ? */
-       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},   /* sharpness+ */
+       {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
+       {0xa0, 0x08, ZC3XX_R1C6_SHARPNESS00},
        {0xa1, 0x01, 0x01c8},
        {0xa1, 0x01, 0x01c9},
        {0xa1, 0x01, 0x01ca},
@@ -5984,7 +5981,7 @@ static const struct usb_action tas5130c_vf0250_Initial[] = {
        {0xaa, 0x1b, 0x0000},           /* 00,1b,00,aa, */
        {0xaa, 0x13, 0x0002},           /* 00,13,02,aa, */
        {0xaa, 0x15, 0x0004},           /* 00,15,04,aa */
-       {0xaa, 0x01, 0x0000},
+/*??   {0xaa, 0x01, 0x0000}, */
        {0xaa, 0x01, 0x0000},
        {0xaa, 0x1a, 0x0000},           /* 00,1a,00,aa, */
        {0xaa, 0x1c, 0x0017},           /* 00,1c,17,aa, */
@@ -6000,8 +5997,8 @@ static const struct usb_action tas5130c_vf0250_Initial[] = {
        {0xaa, 0x0f, 0x00a0},           /* 00,0f,a0,aa, */
        {0xaa, 0x10, 0x0000},           /* 00,10,00,aa, */
        {0xaa, 0x11, 0x00a0},           /* 00,11,a0,aa, */
-       {0xa0, 0x00, 0x0039},
-       {0xa1, 0x01, 0x0037},
+/*??   {0xa0, 0x00, 0x0039},
+       {0xa1, 0x01, 0x0037}, */
        {0xaa, 0x16, 0x0001},           /* 00,16,01,aa, */
        {0xaa, 0x17, 0x00e8},           /* 00,17,e6,aa, (e6 -> e8) */
        {0xaa, 0x18, 0x0002},           /* 00,18,02,aa, */
@@ -6272,7 +6269,7 @@ static void reg_w(struct usb_device *dev,
                        __u8 value,
                        __u16 index)
 {
-       PDEBUG(D_USBO, "reg w %02x -> [%04x]", value, index);
+       PDEBUG(D_USBO, "reg w [%04x] = %02x", index, value);
        reg_w_i(dev, value, index);
 }
 
@@ -6280,17 +6277,17 @@ static __u16 i2c_read(struct gspca_dev *gspca_dev,
                        __u8 reg)
 {
        __u8 retbyte;
-       __u8 retval[2];
+       __u16 retval;
 
        reg_w_i(gspca_dev->dev, reg, 0x92);
        reg_w_i(gspca_dev->dev, 0x02, 0x90);            /* <- read command */
        msleep(25);
        retbyte = reg_r_i(gspca_dev, 0x0091);           /* read status */
-       retval[0] = reg_r_i(gspca_dev, 0x0095);         /* read Lowbyte */
-       retval[1] = reg_r_i(gspca_dev, 0x0096);         /* read Hightbyte */
-       PDEBUG(D_USBO, "i2c r [%02x] -> (%02x) %02x%02x",
-                       reg, retbyte, retval[1], retval[0]);
-       return (retval[1] << 8) | retval[0];
+       retval = reg_r_i(gspca_dev, 0x0095);            /* read Lowbyte */
+       retval |= reg_r_i(gspca_dev, 0x0096) << 8;      /* read Hightbyte */
+       PDEBUG(D_USBO, "i2c r [%02x] -> %04x (%02x)",
+                       reg, retval, retbyte);
+       return retval;
 }
 
 static __u8 i2c_write(struct gspca_dev *gspca_dev,
@@ -6306,7 +6303,7 @@ static __u8 i2c_write(struct gspca_dev *gspca_dev,
        reg_w_i(gspca_dev->dev, 0x01, 0x90);            /* <- write command */
        msleep(5);
        retbyte = reg_r_i(gspca_dev, 0x0091);           /* read status */
-       PDEBUG(D_USBO, "i2c w [%02x] %02x%02x (%02x)",
+       PDEBUG(D_USBO, "i2c w [%02x] %02x%02x (%02x)",
                        reg, valH, valL, retbyte);
        return retbyte;
 }
@@ -6349,6 +6346,8 @@ static void setmatrix(struct gspca_dev *gspca_dev)
                {0x58, 0xf4, 0xf4, 0xf4, 0x58, 0xf4, 0xf4, 0xf4, 0x58};
        static const __u8 po2030_matrix[9] =
                {0x60, 0xf0, 0xf0, 0xf0, 0x60, 0xf0, 0xf0, 0xf0, 0x60};
+       static const __u8 vf0250_matrix[9] =
+               {0x7b, 0xea, 0xea, 0xea, 0x7b, 0xea, 0xea, 0xea, 0x7b};
 
        switch (sd->sensor) {
        case SENSOR_GC0305:
@@ -6363,8 +6362,9 @@ static void setmatrix(struct gspca_dev *gspca_dev)
        case SENSOR_PO2030:
                matrix = po2030_matrix;
                break;
-       case SENSOR_TAS5130C_VF0250:    /* no matrix? */
-               return;
+       case SENSOR_TAS5130C_VF0250:
+               matrix = vf0250_matrix;
+               break;
        default:                /* matrix already loaded */
                return;
        }
@@ -6744,7 +6744,7 @@ static int vga_2wr_probe(struct gspca_dev *gspca_dev)
                return 0x04;                    /* CS2102 */
 
        start_2wr_probe(dev, 0x06);             /* OmniVision */
-       reg_w(dev, 0x08, 0x8d);
+       reg_w(dev, 0x08, 0x008d);
        i2c_write(gspca_dev, 0x11, 0xaa, 0x00);
        retbyte = i2c_read(gspca_dev, 0x11);
        if (retbyte != 0) {
@@ -6778,7 +6778,7 @@ static int vga_2wr_probe(struct gspca_dev *gspca_dev)
                return 0x0c;                    /* ICM105A */
 
        start_2wr_probe(dev, 0x0e);             /* PAS202BCB */
-       reg_w(dev, 0x08, 0x8d);
+       reg_w(dev, 0x08, 0x008d);
        i2c_write(gspca_dev, 0x03, 0xaa, 0x00);
        msleep(500);
        retbyte = i2c_read(gspca_dev, 0x03);
@@ -6830,7 +6830,6 @@ static const struct sensor_by_chipset_revision chipset_revision_sensor[] = {
        {0x8001, 0x13},
        {0x8000, 0x14},         /* CS2102K */
        {0x8400, 0x15},         /* TAS5130K */
-       {0, 0}
 };
 
 static int vga_3wr_probe(struct gspca_dev *gspca_dev)
@@ -6843,7 +6842,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
 
 /*fixme: lack of 8b=b3 (11,12)-> 10, 8b=e0 (14,15,16)-> 12 found in gspcav1*/
        reg_w(dev, 0x02, 0x0010);
-       reg_r(gspca_dev, 0x10);
+       reg_r(gspca_dev, 0x0010);
        reg_w(dev, 0x01, 0x0000);
        reg_w(dev, 0x00, 0x0010);
        reg_w(dev, 0x01, 0x0001);
@@ -6869,17 +6868,15 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        PDEBUG(D_PROBE, "probe 3wr vga 1 0x%04x", checkword);
        reg_r(gspca_dev, 0x0010);
        /* this is tested only once anyway */
-       i = 0;
-       while (chipset_revision_sensor[i].revision) {
+       for (i = 0; i < ARRAY_SIZE(chipset_revision_sensor); i++) {
                if (chipset_revision_sensor[i].revision == checkword) {
                        sd->chip_revision = checkword;
                        send_unknown(dev, SENSOR_PB0330);
                        return chipset_revision_sensor[i].internal_sensor_id;
                }
-               i++;
        }
 
-       reg_w(dev, 0x01, 0x0000);
+       reg_w(dev, 0x01, 0x0000);       /* check ?? */
        reg_w(dev, 0x01, 0x0001);
        reg_w(dev, 0xdd, 0x008b);
        reg_w(dev, 0x0a, 0x0010);
@@ -6901,8 +6898,11 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        retbyte = i2c_read(gspca_dev, 0x00);
        if (retbyte != 0) {
                PDEBUG(D_PROBE, "probe 3wr vga type %02x", retbyte);
-               send_unknown(dev, SENSOR_GC0305);
-               return retbyte;         /* 0x29 = gc0305 - should continue? */
+               if (retbyte == 0x11)                    /* VF0250 */
+                       return 0x0250;
+               if (retbyte == 0x29)                    /* gc0305 */
+                       send_unknown(dev, SENSOR_GC0305);
+               return retbyte;
        }
 
        reg_w(dev, 0x01, 0x0000);       /* check OmniVision */
@@ -6918,18 +6918,18 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
                return 0x06;            /* OmniVision confirm ? */
        }
 
-       reg_w(dev, 0x01, 0x00);
-       reg_w(dev, 0x00, 0x02);
-       reg_w(dev, 0x01, 0x10);
-       reg_w(dev, 0x01, 0x01);
-       reg_w(dev, 0xee, 0x8b);
-       reg_w(dev, 0x03, 0x12);
+       reg_w(dev, 0x01, 0x0000);
+       reg_w(dev, 0x00, 0x0002);
+       reg_w(dev, 0x01, 0x0010);
+       reg_w(dev, 0x01, 0x0001);
+       reg_w(dev, 0xee, 0x008b);
+       reg_w(dev, 0x03, 0x0012);
 /*     msleep(150); */
-       reg_w(dev, 0x01, 0x12);
-       reg_w(dev, 0x05, 0x12);
-       retbyte = i2c_read(gspca_dev, 0x00);            /* ID 0 */
+       reg_w(dev, 0x01, 0x0012);
+       reg_w(dev, 0x05, 0x0012);
+       retbyte = i2c_read(gspca_dev, 0x0000);          /* ID 0 */
        checkword = retbyte << 8;
-       retbyte = i2c_read(gspca_dev, 0x01);            /* ID 1 */
+       retbyte = i2c_read(gspca_dev, 0x0001);          /* ID 1 */
        checkword |= retbyte;
        PDEBUG(D_PROBE, "probe 3wr vga 2 0x%04x", checkword);
        if (checkword == 0x2030) {
@@ -6939,14 +6939,14 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
                return checkword;
        }
 
-       reg_w(dev, 0x01, 0x00);
-       reg_w(dev, 0x0a, 0x10);
-       reg_w(dev, 0xd3, 0x8b);
-       reg_w(dev, 0x01, 0x01);
-       reg_w(dev, 0x03, 0x12);
-       reg_w(dev, 0x01, 0x12);
-       reg_w(dev, 0x05, 0x01);
-       reg_w(dev, 0xd3, 0x8b);
+       reg_w(dev, 0x01, 0x0000);
+       reg_w(dev, 0x0a, 0x0010);
+       reg_w(dev, 0xd3, 0x008b);
+       reg_w(dev, 0x01, 0x0001);
+       reg_w(dev, 0x03, 0x0012);
+       reg_w(dev, 0x01, 0x0012);
+       reg_w(dev, 0x05, 0x0001);
+       reg_w(dev, 0xd3, 0x008b);
        retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0) {
                PDEBUG(D_PROBE, "probe 3wr vga type 0a ?");
@@ -6962,7 +6962,9 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev)
 
        switch (sd->sensor) {
        case SENSOR_MC501CB:
+               return -1;              /* don't probe */
        case SENSOR_TAS5130C_VF0250:
+                               /* may probe but with write in reg 0x0010 */
                return -1;              /* don't probe */
        }
        sensor = vga_2wr_probe(gspca_dev);
@@ -7010,6 +7012,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
        /* define some sensors from the vendor/product */
        sd->sharpness = 2;
+       sd->sensor = -1;
        switch (id->idVendor) {
        case 0x041e:                            /* Creative */
                switch (id->idProduct) {
@@ -7119,6 +7122,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
                        PDEBUG(D_PROBE, "Find Sensor GC0305");
                        sd->sensor = SENSOR_GC0305;
                        break;
+               case 0x0250:
+                       PDEBUG(D_PROBE, "Sensor Tas5130 (VF0250)");
+                       sd->sensor =  SENSOR_TAS5130C_VF0250;
+                       break;
                case 0x2030:
                        PDEBUG(D_PROBE, "Find Sensor PO2030");
                        sd->sensor = SENSOR_PO2030;
@@ -7235,6 +7242,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
        case SENSOR_GC0305:
        case SENSOR_OV7620:
        case SENSOR_PO2030:
+       case SENSOR_TAS5130C_VF0250:
                msleep(100);                    /* ?? */
                reg_r(gspca_dev, 0x0002);       /* --> 0x40 */
                reg_w(dev, 0x09, 0x01ad);       /* (from win traces) */
@@ -7605,7 +7613,7 @@ static int __init sd_mod_init(void)
 {
        if (usb_register(&sd_driver) < 0)
                return -1;
-       PDEBUG(D_PROBE, "v%s registered", version);
+       PDEBUG(D_PROBE, "registered");
        return 0;
 }