V4L/DVB (8352): gspca: Buffers for USB exchanges cannot be in the stack.

gspca:    Protect dq_callback() against simultaneous USB exchanges.
          Temporary buffer for USB exchanges added in the device struct.
(all)     Use a temporary buffer for all USB exchanges.

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

1 files changed, 138 insertions, 141 deletions

diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c
index f66594a113a7..acd4a077198a 100644
--- a/drivers/media/video/gspca/sunplus.c
+++ b/drivers/media/video/gspca/sunplus.c
@@ -24,8 +24,8 @@
 #include "gspca.h"
 #include "jpeg.h"
 
-#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 1, 5)
-static const char version[] = "2.1.5";
+#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(2, 1, 7)
+static const char version[] = "2.1.7";
 
 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
@@ -452,7 +452,7 @@ static const __u8 qtable_spca504_default[2][64] = {
          0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
 };
 
-static void spca5xxRegRead(struct usb_device *dev,
+static void reg_r(struct usb_device *dev,
                            __u16 req,
                            __u16 index,
                            __u8 *buffer, __u16 length)
@@ -466,7 +466,7 @@ static void spca5xxRegRead(struct usb_device *dev,
                         500);
 }
 
-static void spca5xxRegWrite(struct usb_device *dev,
+static void reg_w(struct usb_device *dev,
                             __u16 req,
                             __u16 value,
                             __u16 index,
@@ -480,7 +480,8 @@ static void spca5xxRegWrite(struct usb_device *dev,
                         500);
 }
 
-static int reg_write(struct usb_device *dev,
+/* write req / index / value */
+static int reg_w_riv(struct usb_device *dev,
                      __u16 req, __u16 index, __u16 value)
 {
         int ret;
@@ -490,57 +491,56 @@ static int reg_write(struct usb_device *dev,
                         req,
                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value, index, NULL, 0, 500);
-        PDEBUG(D_PACK, "reg write: 0x%02x,0x%02x:0x%02x, 0x%x",
+        PDEBUG(D_USBO, "reg write: 0x%02x,0x%02x:0x%02x, %d",
                 req, index, value, ret);
         if (ret < 0)
                 PDEBUG(D_ERR, "reg write: error %d", ret);
         return ret;
 }
 
-static int reg_read_info(struct usb_device *dev,
+/* read 1 byte */
+static int reg_r_1(struct gspca_dev *gspca_dev,
                         __u16 value)    /* wValue */
 {
         int ret;
-        __u8 data;
 
-        ret = usb_control_msg(dev,
-                        usb_rcvctrlpipe(dev, 0),
+        ret = usb_control_msg(gspca_dev->dev,
+                        usb_rcvctrlpipe(gspca_dev->dev, 0),
                         0x20,                   /* request */
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         value,
                         0,                      /* index */
-                        &data, 1,
+                        gspca_dev->usb_buf, 1,
                         500);                   /* timeout */
         if (ret < 0) {
-                PDEBUG(D_ERR, "reg_read_info err %d", ret);
+                PDEBUG(D_ERR, "reg_r_1 err %d", ret);
                 return 0;
         }
-        return data;
+        return gspca_dev->usb_buf[0];
 }
 
-/* returns: negative is error, pos or zero is data */
-static int reg_read(struct usb_device *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) */
 {
         int ret;
-        __u8 buf[2];
 
-        buf[1] = 0;
-        ret = usb_control_msg(dev,
-                        usb_rcvctrlpipe(dev, 0),
+        gspca_dev->usb_buf[1] = 0;
+        ret = usb_control_msg(gspca_dev->dev,
+                        usb_rcvctrlpipe(gspca_dev->dev, 0),
                         req,
                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                         0,              /* value */
                         index,
-                        buf, length,
+                        gspca_dev->usb_buf, length,
                         500);
         if (ret < 0) {
                 PDEBUG(D_ERR, "reg_read err %d", ret);
                 return -1;
         }
-        return (buf[1] << 8) + buf[0];
+        return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
 }
 
 static int write_vector(struct gspca_dev *gspca_dev,
@@ -550,7 +550,7 @@ static int write_vector(struct gspca_dev *gspca_dev,
         int ret, i = 0;
 
         while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
-                ret = reg_write(dev, data[i][0], data[i][2], data[i][1]);
+                ret = reg_w_riv(dev, data[i][0], data[i][2], data[i][1]);
                 if (ret < 0) {
                         PDEBUG(D_ERR,
                                 "Register write failed for 0x%x,0x%x,0x%x",
@@ -573,14 +573,14 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
 
         /* loop over y components */
         for (i = 0; i < 64; i++) {
-                err = reg_write(dev, request, ybase + i, qtable[0][i]);
+                err = reg_w_riv(dev, request, ybase + i, qtable[0][i]);
                 if (err < 0)
                         return err;
         }
 
         /* loop over c components */
         for (i = 0; i < 64; i++) {
-                err = reg_write(dev, request, cbase + i, qtable[1][i]);
+                err = reg_w_riv(dev, request, cbase + i, qtable[1][i]);
                 if (err < 0)
                         return err;
         }
@@ -593,14 +593,14 @@ static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
         struct usb_device *dev = gspca_dev->dev;
         __u8 notdone;
 
-        reg_write(dev, req, idx, val);
-        notdone = reg_read(dev, 0x01, 0x0001, 1);
-        reg_write(dev, req, idx, val);
+        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);
 
         msleep(200);
-        notdone = reg_read(dev, 0x01, 0x0001, 1);
+        notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
         PDEBUG(D_FRAM, "after wait 0x%x", notdone);
 }
 
@@ -612,8 +612,8 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
         __u8 status;
         __u8 endcode;
 
-        reg_write(dev, req, idx, val);
-        status = reg_read(dev, 0x01, 0x0001, 1);
+        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);
         if (!count)
@@ -622,8 +622,8 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
         while (--count > 0) {
                 msleep(10);
                 /* gsmart mini2 write a each wait setting 1 ms is enought */
-/*              reg_write(dev, req, idx, val); */
-                status = reg_read(dev, 0x01, 0x0001, 1);
+/*              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",
                                 status, 200 - count);
@@ -632,34 +632,31 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
         }
 }
 
-static int spca504B_PollingDataReady(struct usb_device *dev)
+static int spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
 {
-        __u8 DataReady;
         int count = 10;
 
         while (--count > 0) {
-                spca5xxRegRead(dev, 0x21, 0, &DataReady, 1);
-                if ((DataReady & 0x01) == 0)
+                reg_r(gspca_dev->dev, 0x21, 0, gspca_dev->usb_buf, 1);
+                if ((gspca_dev->usb_buf[0] & 0x01) == 0)
                         break;
                 msleep(10);
         }
-        return DataReady;
+        return gspca_dev->usb_buf[0];
 }
 
 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 DataReady;
         int count = 50;
 
         while (--count > 0) {
-                spca5xxRegRead(dev, 0x21, 1, &DataReady, 1);
-
-                if (DataReady) {
-                        DataReady = 0;
-                        spca5xxRegWrite(dev, 0x21, 0, 1, &DataReady, 1);
-                        spca5xxRegRead(dev, 0x21, 1, &DataReady, 1);
-                        spca504B_PollingDataReady(dev);
+                reg_r(dev, 0x21, 1, gspca_dev->usb_buf, 1);
+                if (gspca_dev->usb_buf[0] != 0) {
+                        gspca_dev->usb_buf[0] = 0;
+                        reg_w(dev, 0x21, 0, 1, gspca_dev->usb_buf, 1);
+                        reg_r(dev, 0x21, 1, gspca_dev->usb_buf, 1);
+                        spca504B_PollingDataReady(gspca_dev);
                         break;
                 }
                 msleep(10);
@@ -669,14 +666,15 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 FW[5];
-        __u8 ProductInfo[64];
+        __u8 *data;
 
-        spca5xxRegRead(dev, 0x20, 0, FW, 5);
+        data = kmalloc(64, GFP_KERNEL);
+        reg_r(dev, 0x20, 0, data, 5);
         PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ",
-                FW[0], FW[1], FW[2], FW[3], FW[4]);
-        spca5xxRegRead(dev, 0x23, 0, ProductInfo, 64);
-        spca5xxRegRead(dev, 0x23, 1, ProductInfo, 64);
+                data[0], data[1], data[2], data[3], data[4]);
+        reg_r(dev, 0x23, 0, data, 64);
+        reg_r(dev, 0x23, 1, data, 64);
+        kfree(data);
 }
 
 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
@@ -691,32 +689,35 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
         Type = 0;
         switch (sd->bridge) {
         case BRIDGE_SPCA533:
-                spca5xxRegWrite(dev, 0x31, 0, 0, NULL, 0);
+                reg_w(dev, 0x31, 0, 0, NULL, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
-                rc = spca504B_PollingDataReady(dev);
+                rc = spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
-                Type = 2;
-                spca5xxRegWrite(dev, 0x24, 0, 8, &Type, 1);
-                spca5xxRegRead(dev, 0x24, 8, &Type, 1);
+                gspca_dev->usb_buf[0] = 2;                      /* type */
+                reg_w(dev, 0x24, 0, 8, gspca_dev->usb_buf, 1);
+                reg_r(dev, 0x24, 8, gspca_dev->usb_buf, 1);
 
-                spca5xxRegWrite(dev, 0x25, 0, 4, &Size, 1);
-                spca5xxRegRead(dev, 0x25, 4, &Size, 1);
-                rc = spca504B_PollingDataReady(dev);
+                gspca_dev->usb_buf[0] = Size;
+                reg_w(dev, 0x25, 0, 4, gspca_dev->usb_buf, 1);
+                reg_r(dev, 0x25, 4, gspca_dev->usb_buf, 1);     /* size */
+                rc = spca504B_PollingDataReady(gspca_dev);
 
                 /* Init the cam width height with some values get on init ? */
-                spca5xxRegWrite(dev, 0x31, 0, 4, NULL, 0);
+                reg_w(dev, 0x31, 0, 4, NULL, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
-                rc = spca504B_PollingDataReady(dev);
+                rc = spca504B_PollingDataReady(gspca_dev);
                 break;
         default:
 /* case BRIDGE_SPCA504B: */
 /* case BRIDGE_SPCA536: */
+                gspca_dev->usb_buf[0] = Size;
+                reg_w(dev, 0x25, 0, 4, gspca_dev->usb_buf, 1);
+                reg_r(dev, 0x25, 4, gspca_dev->usb_buf, 1);     /* size */
                 Type = 6;
-                spca5xxRegWrite(dev, 0x25, 0, 4, &Size, 1);
-                spca5xxRegRead(dev, 0x25, 4, &Size, 1);
-                spca5xxRegWrite(dev, 0x27, 0, 0, &Type, 1);
-                spca5xxRegRead(dev, 0x27, 0, &Type, 1);
-                rc = spca504B_PollingDataReady(dev);
+                gspca_dev->usb_buf[0] = Type;
+                reg_w(dev, 0x27, 0, 0, gspca_dev->usb_buf, 1);
+                reg_r(dev, 0x27, 0, gspca_dev->usb_buf, 1);     /* type */
+                rc = spca504B_PollingDataReady(gspca_dev);
                 break;
         case BRIDGE_SPCA504:
                 Size += 3;
@@ -733,21 +734,20 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
                 break;
         case BRIDGE_SPCA504C:
                 /* capture mode */
-                reg_write(dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x0);
-                reg_write(dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
+                reg_w_riv(dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
+                reg_w_riv(dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
                 break;
         }
 }
 
 static void spca504_wait_status(struct gspca_dev *gspca_dev)
 {
-        struct usb_device *dev = gspca_dev->dev;
         int cnt;
 
         cnt = 256;
         while (--cnt > 0) {
                 /* With this we get the status, when return 0 it's all ok */
-                if (reg_read(dev, 0x06, 0x00, 1) == 0)
+                if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0)
                         return;
                 msleep(10);
         }
@@ -756,11 +756,11 @@ static void spca504_wait_status(struct gspca_dev *gspca_dev)
 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
 {
         struct usb_device *dev = gspca_dev->dev;
-        __u8 Data = 3;
 
-        spca5xxRegWrite(dev, 0x26, 0, 0, &Data, 1);
-        spca5xxRegRead(dev, 0x26, 0, &Data, 1);
-        spca504B_PollingDataReady(dev);
+        gspca_dev->usb_buf[0] = 3;
+        reg_w(dev, 0x26, 0, 0, gspca_dev->usb_buf, 1);
+        reg_r(dev, 0x26, 0, gspca_dev->usb_buf, 1);
+        spca504B_PollingDataReady(gspca_dev);
 }
 
 static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
@@ -777,24 +777,24 @@ static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev)
         default:
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA504B: */
-                spca5xxRegWrite(dev, 0, 0, 0x21a7, NULL, 0);    /* brightness */
-                spca5xxRegWrite(dev, 0, 0x20, 0x21a8, NULL, 0); /* contrast */
-                spca5xxRegWrite(dev, 0, 0, 0x21ad, NULL, 0);    /* hue */
-                spca5xxRegWrite(dev, 0, 1, 0x21ac, NULL, 0);    /* sat/hue */
-                spca5xxRegWrite(dev, 0, 0x20, 0x21ae, NULL, 0); /* saturation */
-                spca5xxRegWrite(dev, 0, 0, 0x21a3, NULL, 0);    /* gamma */
+                reg_w(dev, 0, 0, 0x21a7, NULL, 0);      /* brightness */
+                reg_w(dev, 0, 0x20, 0x21a8, NULL, 0);   /* contrast */
+                reg_w(dev, 0, 0, 0x21ad, NULL, 0);      /* hue */
+                reg_w(dev, 0, 1, 0x21ac, NULL, 0);      /* sat/hue */
+                reg_w(dev, 0, 0x20, 0x21ae, NULL, 0);   /* saturation */
+                reg_w(dev, 0, 0, 0x21a3, NULL, 0);      /* gamma */
                 break;
         case BRIDGE_SPCA536:
-                spca5xxRegWrite(dev, 0, 0, 0x20f0, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0x21, 0x20f1, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0x40, 0x20f5, NULL, 0);
-                spca5xxRegWrite(dev, 0, 1, 0x20f4, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0x40, 0x20f6, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0, 0x2089, NULL, 0);
+                reg_w(dev, 0, 0, 0x20f0, NULL, 0);
+                reg_w(dev, 0, 0x21, 0x20f1, NULL, 0);
+                reg_w(dev, 0, 0x40, 0x20f5, NULL, 0);
+                reg_w(dev, 0, 1, 0x20f4, NULL, 0);
+                reg_w(dev, 0, 0x40, 0x20f6, NULL, 0);
+                reg_w(dev, 0, 0, 0x2089, NULL, 0);
                 break;
         }
         if (pollreg)
-                spca504B_PollingDataReady(dev);
+                spca504B_PollingDataReady(gspca_dev);
 }
 
 /* this function is called at probe time */
@@ -872,7 +872,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 case 0x504a:
 /* try to get the firmware as some cam answer 2.0.1.2.2
  * and should be a spca504b then overwrite that setting */
-                        spca5xxRegRead(dev, 0x20, 0, &fw, 1);
+                        reg_r(dev, 0x20, 0, gspca_dev->usb_buf, 1);
+                        fw = gspca_dev->usb_buf[0];
                         if (fw == 1) {
                                 sd->subtype = AiptekMiniPenCam13;
                                 sd->bridge = BRIDGE_SPCA504;
@@ -1048,38 +1049,37 @@ static int sd_open(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         struct usb_device *dev = gspca_dev->dev;
         int rc;
-        __u8 Data;
         __u8 i;
         __u8 info[6];
         int err_code;
 
         switch (sd->bridge) {
         case BRIDGE_SPCA504B:
-                spca5xxRegWrite(dev, 0x1d, 0, 0, NULL, 0);
-                spca5xxRegWrite(dev, 0, 1, 0x2306, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0, 0x0d04, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0, 0x2000, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0x13, 0x2301, NULL, 0);
-                spca5xxRegWrite(dev, 0, 0, 0x2306, NULL, 0);
+                reg_w(dev, 0x1d, 0, 0, NULL, 0);
+                reg_w(dev, 0, 1, 0x2306, NULL, 0);
+                reg_w(dev, 0, 0, 0x0d04, NULL, 0);
+                reg_w(dev, 0, 0, 0x2000, NULL, 0);
+                reg_w(dev, 0, 0x13, 0x2301, NULL, 0);
+                reg_w(dev, 0, 0, 0x2306, NULL, 0);
                 /* fall thru */
         case BRIDGE_SPCA533:
-                rc = spca504B_PollingDataReady(dev);
+                rc = spca504B_PollingDataReady(gspca_dev);
                 spca50x_GetFirmware(gspca_dev);
                 break;
         case BRIDGE_SPCA536:
                 spca50x_GetFirmware(gspca_dev);
-                spca5xxRegRead(dev, 0x00, 0x5002, &Data, 1);
-                Data = 0;
-                spca5xxRegWrite(dev, 0x24, 0, 0, &Data, 1);
-                spca5xxRegRead(dev, 0x24, 0, &Data, 1);
-                rc = spca504B_PollingDataReady(dev);
-                spca5xxRegWrite(dev, 0x34, 0, 0, NULL, 0);
+                reg_r(dev, 0x00, 0x5002, gspca_dev->usb_buf, 1);
+                gspca_dev->usb_buf[0] = 0;
+                reg_w(dev, 0x24, 0, 0, gspca_dev->usb_buf, 1);
+                reg_r(dev, 0x24, 0, gspca_dev->usb_buf, 1);
+                rc = spca504B_PollingDataReady(gspca_dev);
+                reg_w(dev, 0x34, 0, 0, NULL, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
                 break;
         case BRIDGE_SPCA504C:   /* pccam600 */
                 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
-                reg_write(dev, 0xe0, 0x0000, 0x0000);
-                reg_write(dev, 0xe0, 0x0000, 0x0001);   /* reset */
+                reg_w_riv(dev, 0xe0, 0x0000, 0x0000);
+                reg_w_riv(dev, 0xe0, 0x0000, 0x0001);   /* reset */
                 spca504_wait_status(gspca_dev);
                 if (sd->subtype == LogitechClickSmart420)
                         write_vector(gspca_dev,
@@ -1100,7 +1100,7 @@ static int sd_open(struct gspca_dev *gspca_dev)
                 if (sd->subtype == AiptekMiniPenCam13) {
                         /*****************************/
                         for (i = 0; i < 6; i++)
-                                info[i] = reg_read_info(dev, i);
+                                info[i] = reg_r_1(gspca_dev, i);
                         PDEBUG(D_STREAM,
                                 "Read info: %d %d %d %d %d %d."
                                 " Should be 1,0,2,2,0,0",
@@ -1126,14 +1126,14 @@ static int sd_open(struct gspca_dev *gspca_dev)
                                                         6, 0, 0x86, 1); */
 /*                      spca504A_acknowledged_command (gspca_dev, 0x24,
                                                         0, 0, 0x9D, 1); */
-                        reg_write(dev, 0x0, 0x270c, 0x5); /* L92 sno1t.txt */
-                        reg_write(dev, 0x0, 0x2310, 0x5);
+                        reg_w_riv(dev, 0x0, 0x270c, 0x05); /* L92 sno1t.txt */
+                        reg_w_riv(dev, 0x0, 0x2310, 0x05);
                         spca504A_acknowledged_command(gspca_dev, 0x01,
                                                         0x0f, 0, 0xff, 0);
                 }
                 /* setup qtable */
-                reg_write(dev, 0, 0x2000, 0);
-                reg_write(dev, 0, 0x2883, 1);
+                reg_w_riv(dev, 0, 0x2000, 0);
+                reg_w_riv(dev, 0, 0x2883, 1);
                 err_code = spca50x_setup_qtable(gspca_dev,
                                                 0x00, 0x2800,
                                                 0x2840,
@@ -1166,20 +1166,20 @@ static void sd_start(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA536: */
                 if (sd->subtype == MegapixV4 ||
                     sd->subtype == LogitechClickSmart820) {
-                        spca5xxRegWrite(dev, 0xf0, 0, 0, NULL, 0);
+                        reg_w(dev, 0xf0, 0, 0, NULL, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
-                        spca5xxRegRead(dev, 0xf0, 4, NULL, 0);
+                        reg_r(dev, 0xf0, 4, NULL, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
                 } else {
-                        spca5xxRegWrite(dev, 0x31, 0, 4, NULL, 0);
+                        reg_w(dev, 0x31, 0, 4, NULL, 0);
                         spca504B_WaitCmdStatus(gspca_dev);
-                        rc = spca504B_PollingDataReady(dev);
+                        rc = spca504B_PollingDataReady(gspca_dev);
                 }
                 break;
         case BRIDGE_SPCA504:
                 if (sd->subtype == AiptekMiniPenCam13) {
                         for (i = 0; i < 6; i++)
-                                info[i] = reg_read_info(dev, i);
+                                info[i] = reg_r_1(gspca_dev, i);
                         PDEBUG(D_STREAM,
                                 "Read info: %d %d %d %d %d %d."
                                 " Should be 1,0,2,2,0,0",
@@ -1197,7 +1197,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
                         for (i = 0; i < 6; i++)
-                                info[i] = reg_read_info(dev, i);
+                                info[i] = reg_r_1(gspca_dev, i);
                         PDEBUG(D_STREAM,
                                 "Read info: %d %d %d %d %d %d."
                                 " Should be 1,0,2,2,0,0",
@@ -1207,8 +1207,8 @@ static void sd_start(struct gspca_dev *gspca_dev)
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
                 }
                 spca504B_SetSizeType(gspca_dev);
-                reg_write(dev, 0x0, 0x270c, 0x5);       /* L92 sno1t.txt */
-                reg_write(dev, 0x0, 0x2310, 0x5);
+                reg_w_riv(dev, 0x0, 0x270c, 0x05);      /* L92 sno1t.txt */
+                reg_w_riv(dev, 0x0, 0x2310, 0x05);
                 break;
         case BRIDGE_SPCA504C:
                 if (sd->subtype == LogitechClickSmart420) {
@@ -1217,13 +1217,13 @@ static void sd_start(struct gspca_dev *gspca_dev)
                 } else {
                         write_vector(gspca_dev, spca504_pccam600_init_data);
                 }
-                enable = (sd->autogain ? 0x4 : 0x1);
-                reg_write(dev, 0x0c, 0x0000, enable);   /* auto exposure */
-                reg_write(dev, 0xb0, 0x0000, enable);   /* auto whiteness */
+                enable = (sd->autogain ? 0x04 : 0x01);
+                reg_w_riv(dev, 0x0c, 0x0000, enable);   /* auto exposure */
+                reg_w_riv(dev, 0xb0, 0x0000, enable);   /* auto whiteness */
 
                 /* set default exposure compensation and whiteness balance */
-                reg_write(dev, 0x30, 0x0001, 800);      /* ~ 20 fps */
-                reg_write(dev, 0x30, 0x0002, 1600);
+                reg_w_riv(dev, 0x30, 0x0001, 800);      /* ~ 20 fps */
+                reg_w_riv(dev, 0x30, 0x0002, 1600);
                 spca504B_SetSizeType(gspca_dev);
                 break;
         }
@@ -1240,13 +1240,13 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA533: */
 /*      case BRIDGE_SPCA536: */
 /*      case BRIDGE_SPCA504B: */
-                spca5xxRegWrite(dev, 0x31, 0, 0, NULL, 0);
+                reg_w(dev, 0x31, 0, 0, NULL, 0);
                 spca504B_WaitCmdStatus(gspca_dev);
-                spca504B_PollingDataReady(dev);
+                spca504B_PollingDataReady(gspca_dev);
                 break;
         case BRIDGE_SPCA504:
         case BRIDGE_SPCA504C:
-                reg_write(dev, 0x00, 0x2000, 0x0000);
+                reg_w_riv(dev, 0x00, 0x2000, 0x0000);
 
                 if (sd->subtype == AiptekMiniPenCam13) {
                         /* spca504a aiptek */
@@ -1258,7 +1258,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                                                         0x0f, 0x00, 0xff, 1);
                 } else {
                         spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
-                        reg_write(dev, 0x01, 0x000f, 0x0);
+                        reg_w_riv(dev, 0x01, 0x000f, 0x00);
                 }
                 break;
         }
@@ -1383,10 +1383,10 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                reg_write(dev, 0x0, 0x21a7, sd->brightness);
+                reg_w_riv(dev, 0x0, 0x21a7, sd->brightness);
                 break;
         case BRIDGE_SPCA536:
-                reg_write(dev, 0x0, 0x20f0, sd->brightness);
+                reg_w_riv(dev, 0x0, 0x20f0, sd->brightness);
                 break;
         }
 }
@@ -1394,7 +1394,6 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 static void getbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
         __u16 brightness = 0;
 
         switch (sd->bridge) {
@@ -1403,10 +1402,10 @@ static void getbrightness(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                brightness = reg_read(dev, 0x0, 0x21a7, 2);
+                brightness = reg_r_12(gspca_dev, 0x00, 0x21a7, 2);
                 break;
         case BRIDGE_SPCA536:
-                brightness = reg_read(dev, 0x0, 0x20f0, 2);
+                brightness = reg_r_12(gspca_dev, 0x00, 0x20f0, 2);
                 break;
         }
         sd->brightness = ((brightness & 0xff) - 128) % 255;
@@ -1423,10 +1422,10 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                reg_write(dev, 0x0, 0x21a8, sd->contrast);
+                reg_w_riv(dev, 0x0, 0x21a8, sd->contrast);
                 break;
         case BRIDGE_SPCA536:
-                reg_write(dev, 0x0, 0x20f1, sd->contrast);
+                reg_w_riv(dev, 0x0, 0x20f1, sd->contrast);
                 break;
         }
 }
@@ -1434,7 +1433,6 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 static void getcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
 
         switch (sd->bridge) {
         default:
@@ -1442,10 +1440,10 @@ static void getcontrast(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                sd->contrast = reg_read(dev, 0x0, 0x21a8, 2);
+                sd->contrast = reg_r_12(gspca_dev, 0x00, 0x21a8, 2);
                 break;
         case BRIDGE_SPCA536:
-                sd->contrast = reg_read(dev, 0x0, 0x20f1, 2);
+                sd->contrast = reg_r_12(gspca_dev, 0x00, 0x20f1, 2);
                 break;
         }
 }
@@ -1461,10 +1459,10 @@ static void setcolors(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                reg_write(dev, 0x0, 0x21ae, sd->colors);
+                reg_w_riv(dev, 0x0, 0x21ae, sd->colors);
                 break;
         case BRIDGE_SPCA536:
-                reg_write(dev, 0x0, 0x20f6, sd->colors);
+                reg_w_riv(dev, 0x0, 0x20f6, sd->colors);
                 break;
         }
 }
@@ -1472,7 +1470,6 @@ static void setcolors(struct gspca_dev *gspca_dev)
 static void getcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        struct usb_device *dev = gspca_dev->dev;
 
         switch (sd->bridge) {
         default:
@@ -1480,10 +1477,10 @@ static void getcolors(struct gspca_dev *gspca_dev)
 /*      case BRIDGE_SPCA504B: */
 /*      case BRIDGE_SPCA504: */
 /*      case BRIDGE_SPCA504C: */
-                sd->colors = reg_read(dev, 0x0, 0x21ae, 2) >> 1;
+                sd->colors = reg_r_12(gspca_dev, 0x00, 0x21ae, 2) >> 1;
                 break;
         case BRIDGE_SPCA536:
-                sd->colors = reg_read(dev, 0x0, 0x20f6, 2) >> 1;
+                sd->colors = reg_r_12(gspca_dev, 0x00, 0x20f6, 2) >> 1;
                 break;
         }
 }