V4L/DVB (12692): gspca - sunplus: Optimize code.

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

1 files changed, 165 insertions, 207 deletions

diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c
index e9481fa77749..ffbe3f625ddb 100644
--- a/drivers/media/video/gspca/sunplus.c
+++ b/drivers/media/video/gspca/sunplus.c
@@ -32,22 +32,22 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        unsigned char brightness;
-        unsigned char contrast;
-        unsigned char colors;
-        unsigned char autogain;
+        u8 brightness;
+        u8 contrast;
+        u8 colors;
+        u8 autogain;
         u8 quality;
 #define QUALITY_MIN 70
 #define QUALITY_MAX 95
 #define QUALITY_DEF 85
 
-        char bridge;
+        u8 bridge;
 #define BRIDGE_SPCA504 0
 #define BRIDGE_SPCA504B 1
 #define BRIDGE_SPCA504C 2
 #define BRIDGE_SPCA533 3
 #define BRIDGE_SPCA536 4
-        char subtype;
+        u8 subtype;
 #define AiptekMiniPenCam13 1
 #define LogitechClickSmart420 2
 #define LogitechClickSmart820 3
@@ -68,7 +68,6 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
 
 static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -77,12 +76,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 0xff,
                 .step    = 1,
-                .default_value = 0,
+#define BRIGHTNESS_DEF 0
+                .default_value = BRIGHTNESS_DEF,
             },
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
-#define SD_CONTRAST 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -91,12 +90,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 0xff,
                 .step    = 1,
-                .default_value = 0x20,
+#define CONTRAST_DEF 0x20
+                .default_value = CONTRAST_DEF,
             },
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
-#define SD_COLOR 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
@@ -105,12 +104,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 0xff,
                 .step    = 1,
-                .default_value = 0x1a,
+#define COLOR_DEF 0x1a
+                .default_value = COLOR_DEF,
             },
             .set = sd_setcolors,
             .get = sd_getcolors,
         },
-#define SD_AUTOGAIN 3
         {
             {
                 .id      = V4L2_CID_AUTOGAIN,
@@ -119,7 +118,8 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-                .default_value = 1,
+#define AUTOGAIN_DEF 1
+                .default_value = AUTOGAIN_DEF,
             },
             .set = sd_setautogain,
             .get = sd_getautogain,
@@ -181,14 +181,20 @@ static const struct v4l2_pix_format vga_mode2[] = {
 #define SPCA504_PCCAM600_OFFSET_MODE     5
 #define SPCA504_PCCAM600_OFFSET_DATA     14
  /* Frame packet header offsets for the spca533 */
-#define SPCA533_OFFSET_DATA      16
+#define SPCA533_OFFSET_DATA     16
 #define SPCA533_OFFSET_FRAMSEQ  15
 /* Frame packet header offsets for the spca536 */
-#define SPCA536_OFFSET_DATA      4
-#define SPCA536_OFFSET_FRAMSEQ   1
+#define SPCA536_OFFSET_DATA     4
+#define SPCA536_OFFSET_FRAMSEQ  1
+
+struct cmd {
+        u8 req;
+        u16 val;
+        u16 idx;
+};
 
 /* Initialisation data for the Creative PC-CAM 600 */
-static const __u16 spca504_pccam600_init_data[][3] = {
+static const struct cmd spca504_pccam600_init_data[] = {
 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
         {0x00, 0x0000, 0x2000},
         {0x00, 0x0013, 0x2301},
@@ -212,22 +218,20 @@ static const __u16 spca504_pccam600_init_data[][3] = {
         {0x00, 0x0003, 0x2000},
         {0x00, 0x0013, 0x2301},
         {0x00, 0x0003, 0x2000},
-        {}
 };
 
 /* Creative PC-CAM 600 specific open data, sent before using the
  * generic initialisation data from spca504_open_data.
  */
-static const __u16 spca504_pccam600_open_data[][3] = {
+static const struct cmd spca504_pccam600_open_data[] = {
         {0x00, 0x0001, 0x2501},
         {0x20, 0x0500, 0x0001}, /* snapshot mode */
         {0x00, 0x0003, 0x2880},
         {0x00, 0x0001, 0x2881},
-        {}
 };
 
 /* Initialisation data for the logitech clicksmart 420 */
-static const __u16 spca504A_clicksmart420_init_data[][3] = {
+static const struct cmd spca504A_clicksmart420_init_data[] = {
 /*      {0xa0, 0x0000, 0x0503},  * capture mode */
         {0x00, 0x0000, 0x2000},
         {0x00, 0x0013, 0x2301},
@@ -244,7 +248,7 @@ static const __u16 spca504A_clicksmart420_init_data[][3] = {
         {0xb0, 0x0001, 0x0000},
 
 
-        {0x0a1, 0x0080, 0x0001},
+        {0xa1, 0x0080, 0x0001},
         {0x30, 0x0049, 0x0000},
         {0x30, 0x0060, 0x0005},
         {0x0c, 0x0004, 0x0000},
@@ -254,11 +258,10 @@ static const __u16 spca504A_clicksmart420_init_data[][3] = {
         {0x00, 0x0003, 0x2000},
         {0x00, 0x0000, 0x2000},
 
-        {}
 };
 
 /* clicksmart 420 open data ? */
-static const __u16 spca504A_clicksmart420_open_data[][3] = {
+static const struct cmd spca504A_clicksmart420_open_data[] = {
         {0x00, 0x0001, 0x2501},
         {0x20, 0x0502, 0x0000},
         {0x06, 0x0000, 0x0000},
@@ -402,10 +405,9 @@ static const __u16 spca504A_clicksmart420_open_data[][3] = {
         {0x00, 0x0028, 0x287f},
 
         {0xa0, 0x0000, 0x0503},
-        {}
 };
 
-static const __u8 qtable_creative_pccam[2][64] = {
+static const u8 qtable_creative_pccam[2][64] = {
         {                               /* Q-table Y-components */
          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
@@ -430,7 +432,7 @@ static const __u8 qtable_creative_pccam[2][64] = {
  *              except for one byte. Possibly a typo?
  *              NWG: 18/05/2003.
  */
-static const __u8 qtable_spca504_default[2][64] = {
+static const u8 qtable_spca504_default[2][64] = {
         {                               /* Q-table Y-components */
          0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
          0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
@@ -454,9 +456,9 @@ static const __u8 qtable_spca504_default[2][64] = {
 
 /* read <len> bytes to gspca_dev->usb_buf */
 static void reg_r(struct gspca_dev *gspca_dev,
-                  __u16 req,
-                  __u16 index,
-                  __u16 len)
+                  u8 req,
+                  u16 index,
+                  u16 len)
 {
 #ifdef GSPCA_DEBUG
         if (len > USB_BUF_SZ) {
@@ -474,31 +476,26 @@ static void reg_r(struct gspca_dev *gspca_dev,
                         500);
 }
 
-/* write <len> bytes from gspca_dev->usb_buf */
-static void reg_w(struct gspca_dev *gspca_dev,
-                   __u16 req,
-                   __u16 value,
-                   __u16 index,
-                   __u16 len)
+/* write one byte */
+static void reg_w_1(struct gspca_dev *gspca_dev,
+                   u8 req,
+                   u16 value,
+                   u16 index,
+                   u16 byte)
 {
-#ifdef GSPCA_DEBUG
-        if (len > USB_BUF_SZ) {
-                err("reg_w: buffer overflow");
-                return;
-        }
-#endif
+        gspca_dev->usb_buf[0] = byte;
         usb_control_msg(gspca_dev->dev,
                         usb_sndctrlpipe(gspca_dev->dev, 0),
                         req,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value, index,
-                        len ? gspca_dev->usb_buf : NULL, len,
+                        gspca_dev->usb_buf, 1,
                         500);
 }
 
 /* write req / index / value */
 static int reg_w_riv(struct usb_device *dev,
-                     __u16 req, __u16 index, __u16 value)
+                     u8 req, u16 index, u16 value)
 {
         int ret;
 
@@ -516,7 +513,7 @@ static int reg_w_riv(struct usb_device *dev,
 
 /* read 1 byte */
 static int reg_r_1(struct gspca_dev *gspca_dev,
-                        __u16 value)    /* wValue */
+                        u16 value)      /* wValue */
 {
         int ret;
 
@@ -537,9 +534,9 @@ static int reg_r_1(struct gspca_dev *gspca_dev,
 
 /* read 1 or 2 bytes - returns < 0 if error */
 static int reg_r_12(struct gspca_dev *gspca_dev,
-                        __u16 req,      /* bRequest */
-                        __u16 index,    /* wIndex */
-                        __u16 length)   /* wLength (1 or 2 only) */
+                        u8 req,         /* bRequest */
+                        u16 index,      /* wIndex */
+                        u16 length)     /* wLength (1 or 2 only) */
 {
         int ret;
 
@@ -560,43 +557,40 @@ static int reg_r_12(struct gspca_dev *gspca_dev,
 }
 
 static int write_vector(struct gspca_dev *gspca_dev,
-                        const __u16 data[][3])
+                        const struct cmd *data, int ncmds)
 {
         struct usb_device *dev = gspca_dev->dev;
-        int ret, i = 0;
+        int ret;
 
-        while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
-                ret = reg_w_riv(dev, data[i][0], data[i][2], data[i][1]);
+        while (--ncmds >= 0) {
+                ret = reg_w_riv(dev, data->req, data->idx, data->val);
                 if (ret < 0) {
                         PDEBUG(D_ERR,
-                                "Register write failed for 0x%x,0x%x,0x%x",
-                                data[i][0], data[i][1], data[i][2]);
+                           "Register write failed for 0x%02x, 0x%04x, 0x%04x",
+                                data->req, data->val, data->idx);
                         return ret;
                 }
-                i++;
+                data++;
         }
         return 0;
 }
 
 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
-                                unsigned int request,
-                                unsigned int ybase,
-                                unsigned int cbase,
-                                const __u8 qtable[2][64])
+                                const u8 qtable[2][64])
 {
         struct usb_device *dev = gspca_dev->dev;
         int i, err;
 
         /* loop over y components */
         for (i = 0; i < 64; i++) {
-                err = reg_w_riv(dev, request, ybase + i, qtable[0][i]);
+                err = reg_w_riv(dev, 0x00, 0x2800 + i, qtable[0][i]);
                 if (err < 0)
                         return err;
         }
 
         /* loop over c components */
         for (i = 0; i < 64; i++) {
-                err = reg_w_riv(dev, request, cbase + i, qtable[1][i]);
+                err = reg_w_riv(dev, 0x00, 0x2840 + i, qtable[1][i]);
                 if (err < 0)
                         return err;
         }
@@ -604,34 +598,34 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
 }
 
 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
-                             __u16 req, __u16 idx, __u16 val)
+                             u8 req, u16 idx, u16 val)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 notdone;
+        int notdone;
 
         reg_w_riv(dev, req, idx, val);
         notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
         reg_w_riv(dev, req, idx, val);
 
-        PDEBUG(D_FRAM, "before wait 0x%x", notdone);
+        PDEBUG(D_FRAM, "before wait 0x%04x", notdone);
 
         msleep(200);
         notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
-        PDEBUG(D_FRAM, "after wait 0x%x", notdone);
+        PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
 }
 
 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
-                        __u16 req,
-                        __u16 idx, __u16 val, __u8 stat, __u8 count)
+                        u8 req,
+                        u16 idx, u16 val, u8 stat, u8 count)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 status;
-        __u8 endcode;
+        int status;
+        u8 endcode;
 
         reg_w_riv(dev, req, idx, val);
         status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
         endcode = stat;
-        PDEBUG(D_FRAM, "Status 0x%x Need 0x%x", status, stat);
+        PDEBUG(D_FRAM, "Status 0x%x Need 0x%04x", status, stat);
         if (!count)
                 return;
         count = 200;
@@ -641,7 +635,7 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
 /*              reg_w_riv(dev, req, idx, val); */
                 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
                 if (status == endcode) {
-                        PDEBUG(D_FRAM, "status 0x%x after wait 0x%x",
+                        PDEBUG(D_FRAM, "status 0x%04x after wait %d",
                                 status, 200 - count);
                                 break;
                 }
@@ -668,8 +662,7 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
         while (--count > 0) {
                 reg_r(gspca_dev, 0x21, 1, 1);
                 if (gspca_dev->usb_buf[0] != 0) {
-                        gspca_dev->usb_buf[0] = 0;
-                        reg_w(gspca_dev, 0x21, 0, 1, 1);
+                        reg_w_1(gspca_dev, 0x21, 0, 1, 0);
                         reg_r(gspca_dev, 0x21, 1, 1);
                         spca504B_PollingDataReady(gspca_dev);
                         break;
@@ -680,7 +673,7 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
 
 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
 {
-        __u8 *data;
+        u8 *data;
 
         data = gspca_dev->usb_buf;
         reg_r(gspca_dev, 0x20, 0, 5);
@@ -694,41 +687,34 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        __u8 Size;
-        __u8 Type;
+        u8 Size;
         int rc;
 
-        Size = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
-        Type = 0;
+        Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
         switch (sd->bridge) {
         case BRIDGE_SPCA533:
-                reg_w(gspca_dev, 0x31, 0, 0, 0);
+                reg_w_riv(dev, 0x31, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 rc = spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
-                gspca_dev->usb_buf[0] = 2;                      /* type */
-                reg_w(gspca_dev, 0x24, 0, 8, 1);
+                reg_w_1(gspca_dev, 0x24, 0, 8, 2);              /* type */
                 reg_r(gspca_dev, 0x24, 8, 1);
 
-                gspca_dev->usb_buf[0] = Size;
-                reg_w(gspca_dev, 0x25, 0, 4, 1);
+                reg_w_1(gspca_dev, 0x25, 0, 4, Size);
                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
                 rc = spca504B_PollingDataReady(gspca_dev);
 
                 /* Init the cam width height with some values get on init ? */
-                reg_w(gspca_dev, 0x31, 0, 4, 0);
+                reg_w_riv(dev, 0x31, 0, 0x04);
                 spca504B_WaitCmdStatus(gspca_dev);
                 rc = spca504B_PollingDataReady(gspca_dev);
                 break;
         default:
 /* case BRIDGE_SPCA504B: */
 /* case BRIDGE_SPCA536: */
-                gspca_dev->usb_buf[0] = Size;
-                reg_w(gspca_dev, 0x25, 0, 4, 1);
+                reg_w_1(gspca_dev, 0x25, 0, 4, Size);
                 reg_r(gspca_dev, 0x25, 4, 1);                   /* size */
-                Type = 6;
-                gspca_dev->usb_buf[0] = Type;
-                reg_w(gspca_dev, 0x27, 0, 0, 1);
+                reg_w_1(gspca_dev, 0x27, 0, 0, 6);
                 reg_r(gspca_dev, 0x27, 0, 1);                   /* type */
                 rc = spca504B_PollingDataReady(gspca_dev);
                 break;
@@ -768,17 +754,51 @@ static void spca504_wait_status(struct gspca_dev *gspca_dev)
 
 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
 {
-        gspca_dev->usb_buf[0] = 3;
-        reg_w(gspca_dev, 0x26, 0, 0, 1);
+        reg_w_1(gspca_dev, 0x26, 0, 0, 3);
         reg_r(gspca_dev, 0x26, 0, 1);
         spca504B_PollingDataReady(gspca_dev);
 }
 
-static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
+        reg_w_riv(dev, 0x00, reg, sd->brightness);
+}
+
+static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
+        reg_w_riv(dev, 0x00, reg, sd->contrast);
+}
+
+static void setcolors(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
+        u16 reg;
+
+        reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
+        reg_w_riv(dev, 0x00, reg, sd->colors);
+}
+
+static void init_ctl_reg(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct usb_device *dev = gspca_dev->dev;
         int pollreg = 1;
 
+        setbrightness(gspca_dev);
+        setcontrast(gspca_dev);
+        setcolors(gspca_dev);
+
         switch (sd->bridge) {
         case BRIDGE_SPCA504:
         case BRIDGE_SPCA504C:
@@ -787,20 +807,14 @@ static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
         default:
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA504B: */
-                reg_w(gspca_dev, 0, 0, 0x21a7, 0);      /* brightness */
-                reg_w(gspca_dev, 0, 0x20, 0x21a8, 0);   /* contrast */
-                reg_w(gspca_dev, 0, 0, 0x21ad, 0);      /* hue */
-                reg_w(gspca_dev, 0, 1, 0x21ac, 0);      /* sat/hue */
-                reg_w(gspca_dev, 0, 0x20, 0x21ae, 0);   /* saturation */
-                reg_w(gspca_dev, 0, 0, 0x21a3, 0);      /* gamma */
+                reg_w_riv(dev, 0, 0x00, 0x21ad);        /* hue */
+                reg_w_riv(dev, 0, 0x01, 0x21ac);        /* sat/hue */
+                reg_w_riv(dev, 0, 0x00, 0x21a3);        /* gamma */
                 break;
         case BRIDGE_SPCA536:
-                reg_w(gspca_dev, 0, 0, 0x20f0, 0);
-                reg_w(gspca_dev, 0, 0x21, 0x20f1, 0);
-                reg_w(gspca_dev, 0, 0x40, 0x20f5, 0);
-                reg_w(gspca_dev, 0, 1, 0x20f4, 0);
-                reg_w(gspca_dev, 0, 0x40, 0x20f6, 0);
-                reg_w(gspca_dev, 0, 0, 0x2089, 0);
+                reg_w_riv(dev, 0, 0x40, 0x20f5);
+                reg_w_riv(dev, 0, 0x01, 0x20f4);
+                reg_w_riv(dev, 0, 0x00, 0x2089);
                 break;
         }
         if (pollreg)
@@ -855,9 +869,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 cam->nmodes = ARRAY_SIZE(vga_mode2);
                 break;
         }
-        sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
-        sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
-        sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->colors = COLOR_DEF;
+        sd->autogain = AUTOGAIN_DEF;
         sd->quality = QUALITY_DEF;
         return 0;
 }
@@ -867,32 +882,29 @@ static int sd_init(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        int rc;
-        __u8 i;
-        __u8 info[6];
-        int err_code;
+        int i, err_code;
+        u8 info[6];
 
         switch (sd->bridge) {
         case BRIDGE_SPCA504B:
-                reg_w(gspca_dev, 0x1d, 0, 0, 0);
-                reg_w(gspca_dev, 0, 1, 0x2306, 0);
-                reg_w(gspca_dev, 0, 0, 0x0d04, 0);
-                reg_w(gspca_dev, 0, 0, 0x2000, 0);
-                reg_w(gspca_dev, 0, 0x13, 0x2301, 0);
-                reg_w(gspca_dev, 0, 0, 0x2306, 0);
+                reg_w_riv(dev, 0x1d, 0x00, 0);
+                reg_w_riv(dev, 0, 0x01, 0x2306);
+                reg_w_riv(dev, 0, 0x00, 0x0d04);
+                reg_w_riv(dev, 0, 0x00, 0x2000);
+                reg_w_riv(dev, 0, 0x13, 0x2301);
+                reg_w_riv(dev, 0, 0x00, 0x2306);
                 /* fall thru */
         case BRIDGE_SPCA533:
-                rc = spca504B_PollingDataReady(gspca_dev);
+                spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
                 break;
         case BRIDGE_SPCA536:
                 spca50x_GetFirmware(gspca_dev);
                 reg_r(gspca_dev, 0x00, 0x5002, 1);
-                gspca_dev->usb_buf[0] = 0;
-                reg_w(gspca_dev, 0x24, 0, 0, 1);
+                reg_w_1(gspca_dev, 0x24, 0, 0, 0);
                 reg_r(gspca_dev, 0x24, 0, 1);
-                rc = spca504B_PollingDataReady(gspca_dev);
-                reg_w(gspca_dev, 0x34, 0, 0, 0);
+                spca504B_PollingDataReady(gspca_dev);
+                reg_w_riv(dev, 0x34, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 break;
         case BRIDGE_SPCA504C:   /* pccam600 */
@@ -902,12 +914,13 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 spca504_wait_status(gspca_dev);
                 if (sd->subtype == LogitechClickSmart420)
                         write_vector(gspca_dev,
-                                        spca504A_clicksmart420_open_data);
+                                spca504A_clicksmart420_open_data,
+                                ARRAY_SIZE(spca504A_clicksmart420_open_data));
                 else
-                        write_vector(gspca_dev, spca504_pccam600_open_data);
+                        write_vector(gspca_dev, spca504_pccam600_open_data,
+                                ARRAY_SIZE(spca504_pccam600_open_data));
                 err_code = spca50x_setup_qtable(gspca_dev,
-                                                0x00, 0x2800,
-                                                0x2840, qtable_creative_pccam);
+                                                qtable_creative_pccam);
                 if (err_code < 0) {
                         PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed");
                         return err_code;
@@ -945,8 +958,8 @@ static int sd_init(struct gspca_dev *gspca_dev)
                                                         6, 0, 0x86, 1); */
 /*                      spca504A_acknowledged_command (gspca_dev, 0x24,
                                                         0, 0, 0x9D, 1); */
-                        reg_w_riv(dev, 0x0, 0x270c, 0x05); /* L92 sno1t.txt */
-                        reg_w_riv(dev, 0x0, 0x2310, 0x05);
+                        reg_w_riv(dev, 0x00, 0x270c, 0x05); /* L92 sno1t.txt */
+                        reg_w_riv(dev, 0x00, 0x2310, 0x05);
                         spca504A_acknowledged_command(gspca_dev, 0x01,
                                                         0x0f, 0, 0xff, 0);
                 }
@@ -954,8 +967,6 @@ static int sd_init(struct gspca_dev *gspca_dev)
                 reg_w_riv(dev, 0, 0x2000, 0);
                 reg_w_riv(dev, 0, 0x2883, 1);
                 err_code = spca50x_setup_qtable(gspca_dev,
-                                                0x00, 0x2800,
-                                                0x2840,
                                                 qtable_spca504_default);
                 if (err_code < 0) {
                         PDEBUG(D_ERR, "spca50x_setup_qtable failed");
@@ -970,10 +981,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
-        int rc;
         int enable;
-        __u8 i;
-        __u8 info[6];
+        int i;
+        u8 info[6];
 
         /* create the JPEG header */
         sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
@@ -991,17 +1001,20 @@ static int sd_start(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA536: */
-                if (sd->subtype == MegapixV4 ||
-                    sd->subtype == LogitechClickSmart820 ||
-                    sd->subtype == MegaImageVI) {
-                        reg_w(gspca_dev, 0xf0, 0, 0, 0);
+                switch (sd->subtype) {
+                case MegapixV4:
+                case LogitechClickSmart820:
+                case MegaImageVI:
+                        reg_w_riv(dev, 0xf0, 0, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
                         reg_r(gspca_dev, 0xf0, 4, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
-                } else {
-                        reg_w(gspca_dev, 0x31, 0, 4, 0);
+                        break;
+                default:
+                        reg_w_riv(dev, 0x31, 0, 0x04);
                         spca504B_WaitCmdStatus(gspca_dev);
-                        rc = spca504B_PollingDataReady(gspca_dev);
+                        spca504B_PollingDataReady(gspca_dev);
+                        break;
                 }
                 break;
         case BRIDGE_SPCA504:
@@ -1035,15 +1048,17 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
                 }
                 spca504B_SetSizeType(gspca_dev);
-                reg_w_riv(dev, 0x0, 0x270c, 0x05);      /* L92 sno1t.txt */
-                reg_w_riv(dev, 0x0, 0x2310, 0x05);
+                reg_w_riv(dev, 0x00, 0x270c, 0x05);     /* L92 sno1t.txt */
+                reg_w_riv(dev, 0x00, 0x2310, 0x05);
                 break;
         case BRIDGE_SPCA504C:
                 if (sd->subtype == LogitechClickSmart420) {
                         write_vector(gspca_dev,
-                                        spca504A_clicksmart420_init_data);
+                                spca504A_clicksmart420_init_data,
+                                ARRAY_SIZE(spca504A_clicksmart420_init_data));
                 } else {
-                        write_vector(gspca_dev, spca504_pccam600_init_data);
+                        write_vector(gspca_dev, spca504_pccam600_init_data,
+                                ARRAY_SIZE(spca504_pccam600_init_data));
                 }
                 enable = (sd->autogain ? 0x04 : 0x01);
                 reg_w_riv(dev, 0x0c, 0x0000, enable);   /* auto exposure */
@@ -1055,7 +1070,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
                 spca504B_SetSizeType(gspca_dev);
                 break;
         }
-        sp5xx_initContBrigHueRegisters(gspca_dev);
+        init_ctl_reg(gspca_dev);
         return 0;
 }
 
@@ -1069,7 +1084,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA536: */
 /*      case BRIDGE_SPCA504B: */
-                reg_w(gspca_dev, 0x31, 0, 0, 0);
+                reg_w_riv(dev, 0x31, 0, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 spca504B_PollingDataReady(gspca_dev);
                 break;
@@ -1087,7 +1102,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                                                         0x0f, 0x00, 0xff, 1);
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
-                        reg_w_riv(dev, 0x01, 0x000f, 0x00);
+                        reg_w_riv(dev, 0x01, 0x000f, 0x0000);
                 }
                 break;
         }
@@ -1102,12 +1117,12 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 
 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;
         int i, sof = 0;
-        static unsigned char ffd9[] = {0xff, 0xd9};
+        static u8 ffd9[] = {0xff, 0xd9};
 
 /* frames are jpeg 4.1.1 without 0xff escape */
         switch (sd->bridge) {
@@ -1195,63 +1210,6 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
 }
 
-static void setbrightness(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21a7, sd->brightness);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f0, sd->brightness);
-                break;
-        }
-}
-
-static void setcontrast(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21a8, sd->contrast);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f1, sd->contrast);
-                break;
-        }
-}
-
-static void setcolors(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
-
-        switch (sd->bridge) {
-        default:
-/*      case BRIDGE_SPCA533: */
-/*      case BRIDGE_SPCA504B: */
-/*      case BRIDGE_SPCA504: */
-/*      case BRIDGE_SPCA504C: */
-                reg_w_riv(dev, 0x0, 0x21ae, sd->colors);
-                break;
-        case BRIDGE_SPCA536:
-                reg_w_riv(dev, 0x0, 0x20f6, sd->colors);
-                break;
-        }
-}
-
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;