V4L/DVB (10372): gspca - sonixj: Cleanup code.

Signed-off-by: Jean-Francois Moine <moinejf@free.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index db8db0c6bbb9b29b045d506f0b8ef7a0dd902b96..59363e077bbfff51cc28a31da1113a6b254dc66d 100644 (file)
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -36,28 +36,28 @@ struct sd {
        struct gspca_dev gspca_dev;     /* !! must be the first item */
 
        atomic_t avg_lum;
-       unsigned int exposure;
-
-       __u16 brightness;
-       __u8 contrast;
-       __u8 colors;
-       __u8 autogain;
-       __u8 blue;
-       __u8 red;
+       u32 exposure;
+
+       u16 brightness;
+       u8 contrast;
+       u8 colors;
+       u8 autogain;
+       u8 blue;
+       u8 red;
        u8 gamma;
-       __u8 vflip;                     /* ov7630 only */
-       __u8 infrared;                  /* mi0360 only */
+       u8 vflip;                       /* ov7630 only */
+       u8 infrared;                    /* mi0360 only */
 
-       __s8 ag_cnt;
+       s8 ag_cnt;
 #define AG_CNT_START 13
 
-       __u8 bridge;
+       u8 bridge;
 #define BRIDGE_SN9C102P 0
 #define BRIDGE_SN9C105 1
 #define BRIDGE_SN9C110 2
 #define BRIDGE_SN9C120 3
 #define BRIDGE_SN9C325 4
-       __u8 sensor;                    /* Type of image sensor chip */
+       u8 sensor;                      /* Type of image sensor chip */
 #define SENSOR_HV7131R 0
 #define SENSOR_MI0360 1
 #define SENSOR_MO4000 2
@@ -65,7 +65,7 @@ struct sd {
 #define SENSOR_OV7630 4
 #define SENSOR_OV7648 5
 #define SENSOR_OV7660 6
-       __u8 i2c_base;
+       u8 i2c_base;
 };
 
 /* V4L2 controls supported by the driver */
@@ -349,20 +349,20 @@ static const u8 *sn_tb[] = {
        sn_ov7660
 };
 
-static const __u8 gamma_def[17] = {
+static const u8 gamma_def[17] = {
        0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
        0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
 };
 
 
 /* color matrix and offsets */
-static const __u8 reg84[] = {
+static const u8 reg84[] = {
        0x14, 0x00, 0x27, 0x00, 0x07, 0x00,     /* YR YG YB gains */
        0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00,     /* UR UG UB */
        0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,     /* VR VG VB */
        0x00, 0x00, 0x00                        /* YUV offsets */
 };
-static const __u8 hv7131r_sensor_init[][8] = {
+static const u8 hv7131r_sensor_init[][8] = {
        {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
        {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
        {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
@@ -393,9 +393,9 @@ static const __u8 hv7131r_sensor_init[][8] = {
        {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
        {}
 };
-static const __u8 mi0360_sensor_init[][8] = {
+static const u8 mi0360_sensor_init[][8] = {
        {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
-       {0xb1, 0x5d, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x10},
+       {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
        {0xb1, 0x5d, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
        {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
@@ -416,7 +416,7 @@ static const __u8 mi0360_sensor_init[][8] = {
        {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
-       {0xd1, 0x5d, 0x2F, 0xF7, 0xB0, 0x00, 0x04, 0x10},
+       {0xd1, 0x5d, 0x2f, 0xf7, 0xB0, 0x00, 0x04, 0x10},
        {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
        {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
@@ -447,7 +447,7 @@ static const __u8 mi0360_sensor_init[][8] = {
        {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
        {}
 };
-static const __u8 mo4000_sensor_init[][8] = {
+static const u8 mo4000_sensor_init[][8] = {
        {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
        {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
@@ -470,7 +470,7 @@ static const __u8 mo4000_sensor_init[][8] = {
        {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
        {}
 };
-static __u8 om6802_sensor_init[][8] = {
+static const u8 om6802_sensor_init[][8] = {
        {0xa0, 0x34, 0x90, 0x05, 0x00, 0x00, 0x00, 0x10},
        {0xa0, 0x34, 0x49, 0x85, 0x00, 0x00, 0x00, 0x10},
        {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
@@ -504,7 +504,7 @@ static __u8 om6802_sensor_init[][8] = {
 /*     {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10}, */
        {}
 };
-static const __u8 ov7630_sensor_init[][8] = {
+static const u8 ov7630_sensor_init[][8] = {
        {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
        {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 /* win: delay 20ms */
@@ -558,7 +558,7 @@ static const __u8 ov7630_sensor_init[][8] = {
        {}
 };
 
-static const __u8 ov7648_sensor_init[][8] = {
+static const u8 ov7648_sensor_init[][8] = {
        {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
        {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},       /* reset */
        {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
@@ -604,7 +604,7 @@ static const __u8 ov7648_sensor_init[][8] = {
        {}
 };
 
-static const __u8 ov7660_sensor_init[][8] = {
+static const u8 ov7660_sensor_init[][8] = {
        {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
 /*             (delay 20ms) */
        {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
@@ -693,28 +693,28 @@ static const __u8 ov7660_sensor_init[][8] = {
        {}
 };
 
-static const __u8 qtable4[] = {
-       0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06,
-       0x06, 0x08, 0x0a, 0x11,
-       0x0a, 0x0a, 0x08, 0x08, 0x0a, 0x15, 0x0f, 0x0f, 0x0c, 0x11, 0x19, 0x15,
-       0x19, 0x19, 0x17, 0x15,
-       0x17, 0x17, 0x1b, 0x1d, 0x25, 0x21, 0x1b, 0x1d, 0x23, 0x1d, 0x17, 0x17,
-       0x21, 0x2e, 0x21, 0x23,
-       0x27, 0x29, 0x2c, 0x2c, 0x2c, 0x19, 0x1f, 0x30, 0x32, 0x2e, 0x29, 0x32,
-       0x25, 0x29, 0x2c, 0x29,
-       0x06, 0x08, 0x08, 0x0a, 0x08, 0x0a, 0x13, 0x0a, 0x0a, 0x13, 0x29, 0x1b,
-       0x17, 0x1b, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
-       0x29, 0x29, 0x29, 0x29
+static const u8 qtable4[] = {
+       0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06,
+       0x06, 0x06, 0x08, 0x06, 0x06, 0x08, 0x0a, 0x11,
+       0x0a, 0x0a, 0x08, 0x08, 0x0a, 0x15, 0x0f, 0x0f,
+       0x0c, 0x11, 0x19, 0x15, 0x19, 0x19, 0x17, 0x15,
+       0x17, 0x17, 0x1b, 0x1d, 0x25, 0x21, 0x1b, 0x1d,
+       0x23, 0x1d, 0x17, 0x17, 0x21, 0x2e, 0x21, 0x23,
+       0x27, 0x29, 0x2c, 0x2c, 0x2c, 0x19, 0x1f, 0x30,
+       0x32, 0x2e, 0x29, 0x32, 0x25, 0x29, 0x2c, 0x29,
+       0x06, 0x08, 0x08, 0x0a, 0x08, 0x0a, 0x13, 0x0a,
+       0x0a, 0x13, 0x29, 0x1b, 0x17, 0x1b, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+       0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29
 };
 
 /* read <len> bytes to gspca_dev->usb_buf */
 static void reg_r(struct gspca_dev *gspca_dev,
-                 __u16 value, int len)
+                 u16 value, int len)
 {
 #ifdef GSPCA_DEBUG
        if (len > USB_BUF_SZ) {
@@ -733,8 +733,8 @@ static void reg_r(struct gspca_dev *gspca_dev,
 }
 
 static void reg_w1(struct gspca_dev *gspca_dev,
-                  __u16 value,
-                  __u8 data)
+                  u16 value,
+                  u8 data)
 {
        PDEBUG(D_USBO, "reg_w1 [%02x] = %02x", value, data);
        gspca_dev->usb_buf[0] = data;
@@ -748,8 +748,8 @@ static void reg_w1(struct gspca_dev *gspca_dev,
                        500);
 }
 static void reg_w(struct gspca_dev *gspca_dev,
-                         __u16 value,
-                         const __u8 *buffer,
+                         u16 value,
+                         const u8 *buffer,
                          int len)
 {
        PDEBUG(D_USBO, "reg_w [%02x] = %02x %02x ..",
@@ -771,7 +771,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
 }
 
 /* I2C write 1 byte */
-static void i2c_w1(struct gspca_dev *gspca_dev, __u8 reg, __u8 val)
+static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
@@ -796,7 +796,7 @@ static void i2c_w1(struct gspca_dev *gspca_dev, __u8 reg, __u8 val)
 
 /* I2C write 8 bytes */
 static void i2c_w8(struct gspca_dev *gspca_dev,
-                  const __u8 *buffer)
+                  const u8 *buffer)
 {
        memcpy(gspca_dev->usb_buf, buffer, 8);
        usb_control_msg(gspca_dev->dev,
@@ -810,10 +810,10 @@ static void i2c_w8(struct gspca_dev *gspca_dev,
 }
 
 /* read 5 bytes in gspca_dev->usb_buf */
-static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg)
+static void i2c_r5(struct gspca_dev *gspca_dev, u8 reg)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 mode[8];
+       u8 mode[8];
 
        mode[0] = 0x81 | 0x10;
        mode[1] = sd->i2c_base;
@@ -855,15 +855,15 @@ static int probesensor(struct gspca_dev *gspca_dev)
 }
 
 static int configure_gpio(struct gspca_dev *gspca_dev,
-                         const __u8 *sn9c1xx)
+                         const u8 *sn9c1xx)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       const __u8 *reg9a;
-       static const __u8 reg9a_def[] =
+       const u8 *reg9a;
+       static const u8 reg9a_def[] =
                {0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
-       static const __u8 reg9a_sn9c325[] =
+       static const u8 reg9a_sn9c325[] =
                {0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
-       static const __u8 regd4[] = {0x60, 0x00, 0x00};
+       static const u8 regd4[] = {0x60, 0x00, 0x00};
 
        reg_w1(gspca_dev, 0xf1, 0x00);
        reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
@@ -931,7 +931,7 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
 static void hv7131R_InitSensor(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       static const __u8 SetSensorClk[] =      /* 0x08 Mclk */
+       static const u8 SetSensorClk[] =        /* 0x08 Mclk */
                { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
 
        while (hv7131r_sensor_init[i][0]) {
@@ -1059,8 +1059,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
 static int sd_init(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 regGpio[] = { 0x29, 0x74 };
-       __u8 regF1;
+       u8 regGpio[] = { 0x29, 0x74 };
+       u8 regF1;
 
        /* setup a selector by bridge */
        reg_w1(gspca_dev, 0xf1, 0x01);
@@ -1100,20 +1100,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
        return 0;
 }
 
-static unsigned int setexposure(struct gspca_dev *gspca_dev,
-                               unsigned int expo)
+static u32 setexposure(struct gspca_dev *gspca_dev,
+                       u32 expo)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       static const __u8 doit[] =              /* update sensor */
-               { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
-       static const __u8 sensorgo[] =          /* sensor on */
-               { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
-       static const __u8 gainMo[] =
-               { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
 
        switch (sd->sensor) {
        case SENSOR_HV7131R: {
-               __u8 Expodoit[] =
+               u8 Expodoit[] =
                        { 0xc1, 0x11, 0x25, 0x07, 0x27, 0xc0, 0x00, 0x16 };
 
                Expodoit[3] = expo >> 16;
@@ -1123,8 +1117,12 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                break;
            }
        case SENSOR_MI0360: {
-               __u8 expoMi[] =  /* exposure 0x0635 -> 4 fp/s 0x10 */
+               u8 expoMi[] =    /* exposure 0x0635 -> 4 fp/s 0x10 */
                        { 0xb1, 0x5d, 0x09, 0x06, 0x35, 0x00, 0x00, 0x16 };
+               static const u8 doit[] =                /* update sensor */
+                       { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
+               static const u8 sensorgo[] =            /* sensor on */
+                       { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
 
                if (expo > 0x0635)
                        expo = 0x0635;
@@ -1138,10 +1136,12 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                break;
            }
        case SENSOR_MO4000: {
-               __u8 expoMof[] =
+               u8 expoMof[] =
                        { 0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10 };
-               __u8 expoMo10[] =
+               u8 expoMo10[] =
                        { 0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10 };
+               static const u8 gainMo[] =
+                       { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
 
                if (expo > 0x1fff)
                        expo = 0x1fff;
@@ -1160,7 +1160,7 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                break;
            }
        case SENSOR_OM6802: {
-               __u8 gainOm[] =
+               u8 gainOm[] =
                        { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
 
                if (expo > 0x03ff)
@@ -1181,7 +1181,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        unsigned int expo;
-       __u8 k2;
+       u8 k2;
 
        k2 = ((int) sd->brightness - 0x8000) >> 10;
        switch (sd->sensor) {
@@ -1211,8 +1211,8 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 static void setcontrast(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 k2;
-       __u8 contrast[6];
+       u8 k2;
+       u8 contrast[6];
 
        k2 = sd->contrast * 0x30 / (CONTRAST_MAX + 1) + 0x10;   /* 10..40 */
        contrast[0] = (k2 + 1) / 2;             /* red */
@@ -1228,8 +1228,8 @@ static void setcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        int i, v;
-       __u8 reg8a[12];                 /* U & V gains */
-       static __s16 uv[6] = {          /* same as reg84 in signed decimal */
+       u8 reg8a[12];                   /* U & V gains */
+       static s16 uv[6] = {            /* same as reg84 in signed decimal */
                -24, -38, 64,           /* UR UG UB */
                 62, -51, -9            /* VR VG VB */
        };
@@ -1297,13 +1297,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        int i;
-       __u8 reg1, reg17, reg18;
-       const __u8 *sn9c1xx;
+       u8 reg1, reg17, reg18;
+       const u8 *sn9c1xx;
        int mode;
-       static const __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
-       static const __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
-       static const __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };    /* MI0360 */
-       static const __u8 CE_ov76xx[] =
+       static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
+       static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
+       static const u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };      /* MI0360 */
+       static const u8 CE_ov76xx[] =
                                { 0x32, 0xdd, 0x32, 0xdd };
 
        sn9c1xx = sn_tb[(int) sd->sensor];
@@ -1460,14 +1460,14 @@ static int sd_start(struct gspca_dev *gspca_dev)
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       static const __u8 stophv7131[] =
+       static const u8 stophv7131[] =
                { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
-       static const __u8 stopmi0360[] =
+       static const u8 stopmi0360[] =
                { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
-       static const __u8 stopov7648[] =
+       static const u8 stopov7648[] =
                { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
-       __u8 data;
-       const __u8 *sn9c1xx;
+       u8 data;
+       const u8 *sn9c1xx;
 
        data = 0x0b;
        switch (sd->sensor) {
@@ -1503,8 +1503,8 @@ static void do_autogain(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int delta;
        int expotimes;
-       __u8 luma_mean = 130;
-       __u8 luma_delta = 20;
+       u8 luma_mean = 130;
+       u8 luma_delta = 20;
 
        /* Thanks S., without your advice, autobright should not work :) */
        if (sd->ag_cnt < 0)
@@ -1546,7 +1546,7 @@ static void do_autogain(struct gspca_dev *gspca_dev)
 /* This function is run at interrupt level. */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                        struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;