V4L/DVB (8352): gspca: Buffers for USB exchanges cannot be in the stack.
authorJean-Francois Moine <moinejf@free.fr>
Mon, 14 Jul 2008 12:38:29 +0000 (09:38 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Sun, 20 Jul 2008 10:26:14 +0000 (07:26 -0300)
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>
22 files changed:
drivers/media/video/gspca/conex.c
drivers/media/video/gspca/etoms.c
drivers/media/video/gspca/gspca.c
drivers/media/video/gspca/gspca.h
drivers/media/video/gspca/mars.c
drivers/media/video/gspca/ov519.c
drivers/media/video/gspca/pac207.c
drivers/media/video/gspca/pac7311.c
drivers/media/video/gspca/sonixb.c
drivers/media/video/gspca/sonixj.c
drivers/media/video/gspca/spca500.c
drivers/media/video/gspca/spca501.c
drivers/media/video/gspca/spca505.c
drivers/media/video/gspca/spca506.c
drivers/media/video/gspca/spca508.c
drivers/media/video/gspca/spca561.c
drivers/media/video/gspca/stk014.c
drivers/media/video/gspca/sunplus.c
drivers/media/video/gspca/t613.c
drivers/media/video/gspca/tv8532.c
drivers/media/video/gspca/vc032x.c
drivers/media/video/gspca/zc3xx.c

index b5481017dd4fd72d138a0e30022c103b2bdcb208..013d593b0c678979faff6075900bdac237d08508 100644 (file)
@@ -25,8 +25,8 @@
 #define CONEX_CAM 1            /* special JPEG header */
 #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 USB Conexant Camera Driver");
@@ -119,40 +119,67 @@ static struct v4l2_pix_format vga_mode[] = {
                .priv = 0},
 };
 
-static void reg_r(struct usb_device *dev,
-                          __u16 index,
-                          __u8 *buffer, __u16 length)
+/* the read bytes are found in gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 index,
+                 __u16 len)
 {
+       struct usb_device *dev = gspca_dev->dev;
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       if (len > sizeof gspca_dev->usb_buf) {
+               err("reg_r: buffer overflow");
+               return;
+       }
+#endif
        usb_control_msg(dev,
                        usb_rcvctrlpipe(dev, 0),
                        0,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,
-                       index, buffer, length,
+                       index, gspca_dev->usb_buf, len,
                        500);
-       PDEBUG(D_USBI, "reg read [%02x] -> %02x ..", index, *buffer);
+       PDEBUG(D_USBI, "reg read [%02x] -> %02x ..",
+                       index, gspca_dev->usb_buf[0]);
+}
+
+/* the bytes to write are in gspca_dev->usb_buf */
+static void reg_w_val(struct gspca_dev *gspca_dev,
+                       __u16 index,
+                       __u8 val)
+{
+       struct usb_device *dev = gspca_dev->dev;
+
+       gspca_dev->usb_buf[0] = val;
+       usb_control_msg(dev,
+                       usb_sndctrlpipe(dev, 0),
+                       0,
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       0,
+                       index, gspca_dev->usb_buf, 1, 500);
 }
 
-static void reg_w(struct usb_device *dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                  __u16 index,
-                 const __u8 *buffer, __u16 len)
+                 const __u8 *buffer,
+                 __u16 len)
 {
-       __u8 tmpbuf[8];
+       struct usb_device *dev = gspca_dev->dev;
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-       if (len > sizeof tmpbuf) {
-               PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
+       if (len > sizeof gspca_dev->usb_buf) {
+               err("reg_w: buffer overflow");
                return;
        }
        PDEBUG(D_USBO, "reg write [%02x] = %02x..", index, *buffer);
 #endif
-       memcpy(tmpbuf, buffer, len);
+       memcpy(gspca_dev->usb_buf, buffer, len);
        usb_control_msg(dev,
                        usb_sndctrlpipe(dev, 0),
                        0,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,
-                       index, tmpbuf, len, 500);
+                       index, gspca_dev->usb_buf, len, 500);
 }
 
 static const __u8 cx_sensor_init[][4] = {
@@ -232,17 +259,14 @@ static const __u8 cx11646_fw1[][3] = {
 };
 static void cx11646_fw(struct gspca_dev*gspca_dev)
 {
-       __u8 val;
        int i = 0;
 
-       val = 0x02;
-       reg_w(gspca_dev->dev, 0x006a, &val, 1);
+       reg_w_val(gspca_dev, 0x006a, 0x02);
        while (cx11646_fw1[i][1]) {
-               reg_w(gspca_dev->dev, 0x006b, cx11646_fw1[i], 3);
+               reg_w(gspca_dev, 0x006b, cx11646_fw1[i], 3);
                i++;
        }
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x006a, &val, 1);
+       reg_w_val(gspca_dev, 0x006a, 0x00);
 }
 
 static const __u8 cxsensor[] = {
@@ -273,52 +297,47 @@ static const __u8 reg7b[] = { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
 
 static void cx_sensor(struct gspca_dev*gspca_dev)
 {
-       __u8 val;
        int i = 0;
-       __u8 bufread[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
        int length;
        const __u8 *ptsensor = cxsensor;
 
-       reg_w(gspca_dev->dev, 0x0020, reg20, 8);
-       reg_w(gspca_dev->dev, 0x0028, reg28, 8);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 8);
-       val = 0x03;
-       reg_w(gspca_dev->dev, 0x0092, &val, 1);
+       reg_w(gspca_dev, 0x0020, reg20, 8);
+       reg_w(gspca_dev, 0x0028, reg28, 8);
+       reg_w(gspca_dev, 0x0010, reg10, 8);
+       reg_w_val(gspca_dev, 0x0092, 0x03);
 
        switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
        case 0:
-               reg_w(gspca_dev->dev, 0x0071, reg71a, 4);
+               reg_w(gspca_dev, 0x0071, reg71a, 4);
                break;
        case 1:
-               reg_w(gspca_dev->dev, 0x0071, reg71b, 4);
+               reg_w(gspca_dev, 0x0071, reg71b, 4);
                break;
        default:
 /*     case 2: */
-               reg_w(gspca_dev->dev, 0x0071, reg71c, 4);
+               reg_w(gspca_dev, 0x0071, reg71c, 4);
                break;
        case 3:
-               reg_w(gspca_dev->dev, 0x0071, reg71d, 4);
+               reg_w(gspca_dev, 0x0071, reg71d, 4);
                break;
        }
-       reg_w(gspca_dev->dev, 0x007b, reg7b, 6);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00f8, &val, 1);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 8);
-       val = 0x41;
-       reg_w(gspca_dev->dev, 0x0098, &val, 1);
+       reg_w(gspca_dev, 0x007b, reg7b, 6);
+       reg_w_val(gspca_dev, 0x00f8, 0x00);
+       reg_w(gspca_dev, 0x0010, reg10, 8);
+       reg_w_val(gspca_dev, 0x0098, 0x41);
        for (i = 0; i < 11; i++) {
                if (i == 3 || i == 5 || i == 8)
                        length = 8;
                else
                        length = 4;
-               reg_w(gspca_dev->dev, 0x00e5, ptsensor, length);
+               reg_w(gspca_dev, 0x00e5, ptsensor, length);
                if (length == 4)
-                       reg_r(gspca_dev->dev, 0x00e8, &val, 1);
+                       reg_r(gspca_dev, 0x00e8, 1);
                else
-                       reg_r(gspca_dev->dev, 0x00e8, bufread, length);
+                       reg_r(gspca_dev, 0x00e8, length);
                ptsensor += length;
        }
-       reg_r(gspca_dev->dev, 0x00e7, bufread, 8);
+       reg_r(gspca_dev, 0x00e7, 8);
 }
 
 static const __u8 cx_inits_176[] = {
@@ -358,10 +377,9 @@ static const __u8 cx_inits_640[] = {
        0x77, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-static int cx11646_initsize(struct gspca_dev *gspca_dev)
+static void cx11646_initsize(struct gspca_dev *gspca_dev)
 {
        const __u8 *cxinit;
-       __u8 val;
        static const __u8 reg12[] = { 0x08, 0x05, 0x07, 0x04, 0x24 };
        static const __u8 reg17[] =
                        { 0x0a, 0x00, 0xf2, 0x01, 0x0f, 0x00, 0x97, 0x02 };
@@ -381,35 +399,29 @@ static int cx11646_initsize(struct gspca_dev *gspca_dev)
                cxinit = cx_inits_176;
                break;
        }
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x009a, &val, 1);
-       val = 0x10;
-       reg_w(gspca_dev->dev, 0x0010, &val, 1);
-       reg_w(gspca_dev->dev, 0x0012, reg12, 5);
-       reg_w(gspca_dev->dev, 0x0017, reg17, 8);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c0, &val, 1);
-       val = 0x04;
-       reg_w(gspca_dev->dev, 0x00c1, &val, 1);
-       val = 0x04;
-       reg_w(gspca_dev->dev, 0x00c2, &val, 1);
-
-       reg_w(gspca_dev->dev, 0x0061, cxinit, 8);
+       reg_w_val(gspca_dev, 0x009a, 0x01);
+       reg_w_val(gspca_dev, 0x0010, 0x10);
+       reg_w(gspca_dev, 0x0012, reg12, 5);
+       reg_w(gspca_dev, 0x0017, reg17, 8);
+       reg_w_val(gspca_dev, 0x00c0, 0x00);
+       reg_w_val(gspca_dev, 0x00c1, 0x04);
+       reg_w_val(gspca_dev, 0x00c2, 0x04);
+
+       reg_w(gspca_dev, 0x0061, cxinit, 8);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x00ca, cxinit, 8);
+       reg_w(gspca_dev, 0x00ca, cxinit, 8);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x00d2, cxinit, 8);
+       reg_w(gspca_dev, 0x00d2, cxinit, 8);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x00da, cxinit, 6);
+       reg_w(gspca_dev, 0x00da, cxinit, 6);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x0041, cxinit, 8);
+       reg_w(gspca_dev, 0x0041, cxinit, 8);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x0049, cxinit, 8);
+       reg_w(gspca_dev, 0x0049, cxinit, 8);
        cxinit += 8;
-       reg_w(gspca_dev->dev, 0x0051, cxinit, 2);
+       reg_w(gspca_dev, 0x0051, cxinit, 2);
 
-       reg_r(gspca_dev->dev, 0x0010, &val, 1);
-       return val;
+       reg_r(gspca_dev, 0x0010, 1);
 }
 
 static const __u8 cx_jpeg_init[][8] = {
@@ -636,26 +648,21 @@ static const __u8 cxjpeg_qtable[][8] = {
 
 static void cx11646_jpegInit(struct gspca_dev*gspca_dev)
 {
-       __u8 val;
        int i;
        int length;
 
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x00c0, &val, 1);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c3, &val, 1);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c0, &val, 1);
-       reg_r(gspca_dev->dev, 0x0001, &val, 1);
+       reg_w_val(gspca_dev, 0x00c0, 0x01);
+       reg_w_val(gspca_dev, 0x00c3, 0x00);
+       reg_w_val(gspca_dev, 0x00c0, 0x00);
+       reg_r(gspca_dev, 0x0001, 1);
        length = 8;
        for (i = 0; i < 79; i++) {
                if (i == 78)
                        length = 6;
-               reg_w(gspca_dev->dev, 0x0008, cx_jpeg_init[i], length);
+               reg_w(gspca_dev, 0x0008, cx_jpeg_init[i], length);
        }
-       reg_r(gspca_dev->dev, 0x0002, &val, 1);
-       val = 0x14;
-       reg_w(gspca_dev->dev, 0x0055, &val, 1);
+       reg_r(gspca_dev, 0x0002, 1);
+       reg_w_val(gspca_dev, 0x0055, 0x14);
 }
 
 static const __u8 reg12[] = { 0x0a, 0x05, 0x07, 0x04, 0x19 };
@@ -665,31 +672,26 @@ static const __u8 regE5a[] = { 0x88, 0x0a, 0x0c, 0x01 };
 static const __u8 regE5b[] = { 0x88, 0x0b, 0x12, 0x01 };
 static const __u8 regE5c[] = { 0x88, 0x05, 0x01, 0x01 };
 static const __u8 reg51[] = { 0x77, 0x03 };
-static const __u8 reg70 = 0x03;
+#define reg70 0x03
 
 static void cx11646_jpeg(struct gspca_dev*gspca_dev)
 {
-       __u8 val;
        int i;
        int length;
        __u8 Reg55;
-       __u8 bufread[8];
        int retry;
 
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x00c0, &val, 1);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c3, &val, 1);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c0, &val, 1);
-       reg_r(gspca_dev->dev, 0x0001, &val, 1);
+       reg_w_val(gspca_dev, 0x00c0, 0x01);
+       reg_w_val(gspca_dev, 0x00c3, 0x00);
+       reg_w_val(gspca_dev, 0x00c0, 0x00);
+       reg_r(gspca_dev, 0x0001, 1);
        length = 8;
        switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
        case 0:
                for (i = 0; i < 27; i++) {
                        if (i == 26)
                                length = 2;
-                       reg_w(gspca_dev->dev, 0x0008, cxjpeg_640[i], length);
+                       reg_w(gspca_dev, 0x0008, cxjpeg_640[i], length);
                }
                Reg55 = 0x28;
                break;
@@ -697,7 +699,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev)
                for (i = 0; i < 27; i++) {
                        if (i == 26)
                                length = 2;
-                       reg_w(gspca_dev->dev, 0x0008, cxjpeg_352[i], length);
+                       reg_w(gspca_dev, 0x0008, cxjpeg_352[i], length);
                }
                Reg55 = 0x16;
                break;
@@ -706,7 +708,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev)
                for (i = 0; i < 27; i++) {
                        if (i == 26)
                                length = 2;
-                       reg_w(gspca_dev->dev, 0x0008, cxjpeg_320[i], length);
+                       reg_w(gspca_dev, 0x0008, cxjpeg_320[i], length);
                }
                Reg55 = 0x14;
                break;
@@ -714,124 +716,98 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev)
                for (i = 0; i < 27; i++) {
                        if (i == 26)
                                length = 2;
-                       reg_w(gspca_dev->dev, 0x0008, cxjpeg_176[i], length);
+                       reg_w(gspca_dev, 0x0008, cxjpeg_176[i], length);
                }
                Reg55 = 0x0B;
                break;
        }
 
-       reg_r(gspca_dev->dev, 0x0002, &val, 1);
-       val = Reg55;
-       reg_w(gspca_dev->dev, 0x0055, &val, 1);
-       reg_r(gspca_dev->dev, 0x0002, &val, 1);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 2);
-       val = 0x02;
-       reg_w(gspca_dev->dev, 0x0054, &val, 1);
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x0054, &val, 1);
-       val = 0x94;
-       reg_w(gspca_dev->dev, 0x0000, &val, 1);
-       val = 0xc0;
-       reg_w(gspca_dev->dev, 0x0053, &val, 1);
-       val = 0xe1;
-       reg_w(gspca_dev->dev, 0x00fc, &val, 1);
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x0000, &val, 1);
+       reg_r(gspca_dev, 0x0002, 1);
+       reg_w_val(gspca_dev, 0x0055, Reg55);
+       reg_r(gspca_dev, 0x0002, 1);
+       reg_w(gspca_dev, 0x0010, reg10, 2);
+       reg_w_val(gspca_dev, 0x0054, 0x02);
+       reg_w_val(gspca_dev, 0x0054, 0x01);
+       reg_w_val(gspca_dev, 0x0000, 0x94);
+       reg_w_val(gspca_dev, 0x0053, 0xc0);
+       reg_w_val(gspca_dev, 0x00fc, 0xe1);
+       reg_w_val(gspca_dev, 0x0000, 0x00);
        /* wait for completion */
        retry = 50;
        while (retry--) {
-               reg_r(gspca_dev->dev, 0x0002, &val, 1);
+               reg_r(gspca_dev, 0x0002, 1);
                                                        /* 0x07 until 0x00 */
-               if (val == 0x00)
+               if (gspca_dev->usb_buf[0] == 0x00)
                        break;
-               val = 0x00;
-               reg_w(gspca_dev->dev, 0x0053, &val, 1);
+               reg_w_val(gspca_dev, 0x0053, 0x00);
        }
        if (retry == 0)
                PDEBUG(D_ERR, "Damned Errors sending jpeg Table");
        /* send the qtable now */
-       reg_r(gspca_dev->dev, 0x0001, &val, 1);         /* -> 0x18 */
+       reg_r(gspca_dev, 0x0001, 1);            /* -> 0x18 */
        length = 8;
        for (i = 0; i < 18; i++) {
                if (i == 17)
                        length = 2;
-               reg_w(gspca_dev->dev, 0x0008, cxjpeg_qtable[i], length);
+               reg_w(gspca_dev, 0x0008, cxjpeg_qtable[i], length);
 
        }
-       reg_r(gspca_dev->dev, 0x0002, &val, 1); /* 0x00 */
-       reg_r(gspca_dev->dev, 0x0053, &val, 1); /* 0x00 */
-       val = 0x02;
-       reg_w(gspca_dev->dev, 0x0054, &val, 1);
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x0054, &val, 1);
-       val = 0x94;
-       reg_w(gspca_dev->dev, 0x0000, &val, 1);
-       val = 0xc0;
-       reg_w(gspca_dev->dev, 0x0053, &val, 1);
-
-       reg_r(gspca_dev->dev, 0x0038, &val, 1); /* 0x40 */
-       reg_r(gspca_dev->dev, 0x0038, &val, 1); /* 0x40 */
-       reg_r(gspca_dev->dev, 0x001f, &val, 1); /* 0x38 */
-       reg_w(gspca_dev->dev, 0x0012, reg12, 5);
-       reg_w(gspca_dev->dev, 0x00e5, regE5_8, 8);
-       reg_r(gspca_dev->dev, 0x00e8, bufread, 8);
-       reg_w(gspca_dev->dev, 0x00e5, regE5a, 4);
-       reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */
-       val = 0x01;
-       reg_w(gspca_dev->dev, 0x009a, &val, 1);
-       reg_w(gspca_dev->dev, 0x00e5, regE5b, 4);
-       reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */
-       reg_w(gspca_dev->dev, 0x00e5, regE5c, 4);
-       reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */
-
-       reg_w(gspca_dev->dev, 0x0051, reg51, 2);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 2);
-       reg_w(gspca_dev->dev, 0x0070, &reg70, 1);
+       reg_r(gspca_dev, 0x0002, 1);    /* 0x00 */
+       reg_r(gspca_dev, 0x0053, 1);    /* 0x00 */
+       reg_w_val(gspca_dev, 0x0054, 0x02);
+       reg_w_val(gspca_dev, 0x0054, 0x01);
+       reg_w_val(gspca_dev, 0x0000, 0x94);
+       reg_w_val(gspca_dev, 0x0053, 0xc0);
+
+       reg_r(gspca_dev, 0x0038, 1);            /* 0x40 */
+       reg_r(gspca_dev, 0x0038, 1);            /* 0x40 */
+       reg_r(gspca_dev, 0x001f, 1);            /* 0x38 */
+       reg_w(gspca_dev, 0x0012, reg12, 5);
+       reg_w(gspca_dev, 0x00e5, regE5_8, 8);
+       reg_r(gspca_dev, 0x00e8, 8);
+       reg_w(gspca_dev, 0x00e5, regE5a, 4);
+       reg_r(gspca_dev, 0x00e8, 1);            /* 0x00 */
+       reg_w_val(gspca_dev, 0x009a, 0x01);
+       reg_w(gspca_dev, 0x00e5, regE5b, 4);
+       reg_r(gspca_dev, 0x00e8, 1);            /* 0x00 */
+       reg_w(gspca_dev, 0x00e5, regE5c, 4);
+       reg_r(gspca_dev, 0x00e8, 1);            /* 0x00 */
+
+       reg_w(gspca_dev, 0x0051, reg51, 2);
+       reg_w(gspca_dev, 0x0010, reg10, 2);
+       reg_w_val(gspca_dev, 0x0070, reg70);
 }
 
 static void cx11646_init1(struct gspca_dev *gspca_dev)
 {
-       __u8 val;
        int i = 0;
 
-       val = 0;
-       reg_w(gspca_dev->dev, 0x0010, &val, 1);
-       reg_w(gspca_dev->dev, 0x0053, &val, 1);
-       reg_w(gspca_dev->dev, 0x0052, &val, 1);
-       val = 0x2f;
-       reg_w(gspca_dev->dev, 0x009b, &val, 1);
-       val = 0x10;
-       reg_w(gspca_dev->dev, 0x009c, &val, 1);
-       reg_r(gspca_dev->dev, 0x0098, &val, 1);
-       val = 0x40;
-       reg_w(gspca_dev->dev, 0x0098, &val, 1);
-       reg_r(gspca_dev->dev, 0x0099, &val, 1);
-       val = 0x07;
-       reg_w(gspca_dev->dev, 0x0099, &val, 1);
-       val = 0x40;
-       reg_w(gspca_dev->dev, 0x0039, &val, 1);
-       val = 0xff;
-       reg_w(gspca_dev->dev, 0x003c, &val, 1);
-       val = 0x1f;
-       reg_w(gspca_dev->dev, 0x003f, &val, 1);
-       val = 0x40;
-       reg_w(gspca_dev->dev, 0x003d, &val, 1);
-/*     val= 0x60; */
-/*     reg_w(gspca_dev->dev, 0x00, 0x00, 0x003d, &val, 1); */
-       reg_r(gspca_dev->dev, 0x0099, &val, 1);                 /* ->0x07 */
+       reg_w_val(gspca_dev, 0x0010, 0x00);
+       reg_w_val(gspca_dev, 0x0053, 0x00);
+       reg_w_val(gspca_dev, 0x0052, 0x00);
+       reg_w_val(gspca_dev, 0x009b, 0x2f);
+       reg_w_val(gspca_dev, 0x009c, 0x10);
+       reg_r(gspca_dev, 0x0098, 1);
+       reg_w_val(gspca_dev, 0x0098, 0x40);
+       reg_r(gspca_dev, 0x0099, 1);
+       reg_w_val(gspca_dev, 0x0099, 0x07);
+       reg_w_val(gspca_dev, 0x0039, 0x40);
+       reg_w_val(gspca_dev, 0x003c, 0xff);
+       reg_w_val(gspca_dev, 0x003f, 0x1f);
+       reg_w_val(gspca_dev, 0x003d, 0x40);
+/*     reg_w_val(gspca_dev, 0x003d, 0x60); */
+       reg_r(gspca_dev, 0x0099, 1);                    /* ->0x07 */
 
        while (cx_sensor_init[i][0]) {
-               reg_w(gspca_dev->dev, 0x00e5, cx_sensor_init[i], 1);
-               reg_r(gspca_dev->dev, 0x00e8, &val, 1);         /* -> 0x00 */
+               reg_w_val(gspca_dev, 0x00e5, cx_sensor_init[i][0]);
+               reg_r(gspca_dev, 0x00e8, 1);            /* -> 0x00 */
                if (i == 1) {
-                       val = 1;
-                       reg_w(gspca_dev->dev, 0x00ed, &val, 1);
-                       reg_r(gspca_dev->dev, 0x00ed, &val, 1); /* -> 0x01 */
+                       reg_w_val(gspca_dev, 0x00ed, 0x01);
+                       reg_r(gspca_dev, 0x00ed, 1);    /* -> 0x01 */
                }
                i++;
        }
-       val = 0x00;
-       reg_w(gspca_dev->dev, 0x00c3, &val, 1);
+       reg_w_val(gspca_dev, 0x00c3, 0x00);
 }
 
 /* this function is called at probe time */
@@ -880,29 +856,23 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 static void sd_stop0(struct gspca_dev *gspca_dev)
 {
        int retry = 50;
-       __u8 val;
 
-       val = 0;
-       reg_w(gspca_dev->dev, 0x0000, &val, 1);
-       reg_r(gspca_dev->dev, 0x0002, &val, 1);
-       val = 0;
-       reg_w(gspca_dev->dev, 0x0053, &val, 1);
+       reg_w_val(gspca_dev, 0x0000, 0x00);
+       reg_r(gspca_dev, 0x0002, 1);
+       reg_w_val(gspca_dev, 0x0053, 0x00);
 
        while (retry--) {
-/*             reg_r(gspca_dev->dev, 0x0002, &val, 1);*/
-               reg_r(gspca_dev->dev, 0x0053, &val, 1);
-               if (val == 0)
+/*             reg_r(gspca_dev, 0x0002, 1);*/
+               reg_r(gspca_dev, 0x0053, 1);
+               if (gspca_dev->usb_buf[0] == 0)
                        break;
        }
-       val = 0;
-       reg_w(gspca_dev->dev, 0x0000, &val, 1);
-       reg_r(gspca_dev->dev, 0x0002, &val, 1);
-
-       val = 0;
-       reg_w(gspca_dev->dev, 0x0010, &val, 1);
-       reg_r(gspca_dev->dev, 0x0033, &val, 1);
-       val = 0xe0;
-       reg_w(gspca_dev->dev, 0x00fc, &val, 1);
+       reg_w_val(gspca_dev, 0x0000, 0x00);
+       reg_r(gspca_dev, 0x0002, 1);
+
+       reg_w_val(gspca_dev, 0x0010, 0x00);
+       reg_r(gspca_dev, 0x0033, 1);
+       reg_w_val(gspca_dev, 0x00fc, 0xe0);
 }
 
 static void sd_close(struct gspca_dev *gspca_dev)
@@ -937,22 +907,20 @@ static void setbrightness(struct gspca_dev*gspca_dev)
        __u8 reg51c[2];
        __u8 bright;
        __u8 colors;
-       __u8 val;
-       __u8 bufread[8];
 
        bright = sd->brightness;
        regE5cbx[2] = bright;
-       reg_w(gspca_dev->dev, 0x00e5, regE5cbx, 8);
-       reg_r(gspca_dev->dev, 0x00e8, bufread, 8);
-       reg_w(gspca_dev->dev, 0x00e5, regE5c, 4);
-       reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */
+       reg_w(gspca_dev, 0x00e5, regE5cbx, 8);
+       reg_r(gspca_dev, 0x00e8, 8);
+       reg_w(gspca_dev, 0x00e5, regE5c, 4);
+       reg_r(gspca_dev, 0x00e8, 1);            /* 0x00 */
 
        colors = sd->colors;
        reg51c[0] = 0x77;
        reg51c[1] = colors;
-       reg_w(gspca_dev->dev, 0x0051, reg51c, 2);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 2);
-       reg_w(gspca_dev->dev, 0x0070, &reg70, 1);
+       reg_w(gspca_dev, 0x0051, reg51c, 2);
+       reg_w(gspca_dev, 0x0010, reg10, 2);
+       reg_w_val(gspca_dev, 0x0070, reg70);
 }
 
 static void setcontrast(struct gspca_dev*gspca_dev)
@@ -961,16 +929,15 @@ static void setcontrast(struct gspca_dev*gspca_dev)
        __u8 regE5acx[] = { 0x88, 0x0a, 0x0c, 0x01 };   /* seem MSB */
 /*     __u8 regE5bcx[] = { 0x88, 0x0b, 0x12, 0x01};     * LSB */
        __u8 reg51c[2];
-       __u8 val;
 
        regE5acx[2] = sd->contrast;
-       reg_w(gspca_dev->dev, 0x00e5, regE5acx, 4);
-       reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */
+       reg_w(gspca_dev, 0x00e5, regE5acx, 4);
+       reg_r(gspca_dev, 0x00e8, 1);            /* 0x00 */
        reg51c[0] = 0x77;
        reg51c[1] = sd->colors;
-       reg_w(gspca_dev->dev, 0x0051, reg51c, 2);
-       reg_w(gspca_dev->dev, 0x0010, reg10, 2);
-       reg_w(gspca_dev->dev, 0x0070, &reg70, 1);
+       reg_w(gspca_dev, 0x0051, reg51c, 2);
+       reg_w(gspca_dev, 0x0010, reg10, 2);
+       reg_w_val(gspca_dev, 0x0070, reg70);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
index 1da6a182561ff2cab200fc9d0707a5c7fc52a023..5bb8dc1adbb77fd5da662136f968619efb0e05fa 100644 (file)
@@ -22,8 +22,8 @@
 
 #include "gspca.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("Etoms USB Camera Driver");
@@ -229,201 +229,215 @@ static const __u8 I2c3[] = { 0x12, 0x05 };
 
 static const __u8 I2c4[] = { 0x41, 0x08 };
 
-static void reg_r(struct usb_device *dev,
-                      __u16 index, __u8 *buffer, int len)
+/* read 'len' bytes to gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 index,
+                 __u16 len)
 {
+       struct usb_device *dev = gspca_dev->dev;
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       if (len > sizeof gspca_dev->usb_buf) {
+               err("reg_r: buffer overflow");
+               return;
+       }
+#endif
        usb_control_msg(dev,
                        usb_rcvctrlpipe(dev, 0),
                        0,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
-                       0, index, buffer, len, 500);
+                       0,
+                       index, gspca_dev->usb_buf, len, 500);
+       PDEBUG(D_USBI, "reg read [%02x] -> %02x ..",
+                       index, gspca_dev->usb_buf[0]);
 }
 
-static void reg_w_val(struct usb_device *dev,
-                       __u16 index, __u8 val)
+static void reg_w_val(struct gspca_dev *gspca_dev,
+                       __u16 index,
+                       __u8 val)
 {
-       __u8 data;
+       struct usb_device *dev = gspca_dev->dev;
 
-       data = val;
+       gspca_dev->usb_buf[0] = val;
        usb_control_msg(dev,
                        usb_sndctrlpipe(dev, 0),
                        0,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
-                       0, index, &data, 1, 500);
+                       0,
+                       index, gspca_dev->usb_buf, 1, 500);
 }
 
-static void reg_w(struct usb_device *dev,
-                 __u16 index, const __u8 *buffer, __u16 len)
+static void reg_w(struct gspca_dev *gspca_dev,
+                 __u16 index,
+                 const __u8 *buffer,
+                 __u16 len)
 {
-       __u8 tmpbuf[8];
+       struct usb_device *dev = gspca_dev->dev;
 
-       memcpy(tmpbuf, buffer, len);
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       if (len > sizeof gspca_dev->usb_buf) {
+               err("reg_w: buffer overflow");
+               return;
+       }
+       PDEBUG(D_USBO, "reg write [%02x] = %02x..", index, *buffer);
+#endif
+       memcpy(gspca_dev->usb_buf, buffer, len);
        usb_control_msg(dev,
                        usb_sndctrlpipe(dev, 0),
                        0,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
-                       0, index, tmpbuf, len, 500);
+                       0, index, gspca_dev->usb_buf, len, 500);
 }
 
-static int Et_i2cwrite(struct usb_device *dev, __u8 reg,
-                       const __u8 *buffer,
-                       __u16 len, __u8 mode)
+static int i2c_w(struct gspca_dev *gspca_dev,
+                __u8 reg,
+                const __u8 *buffer,
+                __u16 len, __u8 mode)
 {
        /* buffer should be [D0..D7] */
        __u8 ptchcount;
 
        /* set the base address */
-       reg_w_val(dev, ET_I2C_BASE, 0x40); /* sensor base for the pas106 */
+       reg_w_val(gspca_dev, ET_I2C_BASE, 0x40);
+                                        /* sensor base for the pas106 */
        /* set count and prefetch */
        ptchcount = ((len & 0x07) << 4) | (mode & 0x03);
-       reg_w_val(dev, ET_I2C_COUNT, ptchcount);
+       reg_w_val(gspca_dev, ET_I2C_COUNT, ptchcount);
        /* set the register base */
-       reg_w_val(dev, ET_I2C_REG, reg);
+       reg_w_val(gspca_dev, ET_I2C_REG, reg);
        while (--len >= 0)
-               reg_w_val(dev, ET_I2C_DATA0 + len, buffer[len]);
+               reg_w_val(gspca_dev, ET_I2C_DATA0 + len, buffer[len]);
        return 0;
 }
 
-static int Et_i2cread(struct usb_device *dev, __u8 reg,
-                       __u8 *buffer,
-                       __u16 length, __u8 mode)
+static int i2c_r(struct gspca_dev *gspca_dev,
+                       __u8 reg)
 {
-       /* buffer should be [D0..D7] */
-       int i, j;
-       __u8 ptchcount;
-
        /* set the base address */
-       reg_w_val(dev, ET_I2C_BASE, 0x40); /* sensor base for the pas106 */
-       /* set count and prefetch */
-       ptchcount = ((length & 0x07) << 4) | (mode & 0x03);
-       reg_w_val(dev, ET_I2C_COUNT, ptchcount);
-       /* set the register base */
-       reg_w_val(dev, ET_I2C_REG, reg);
-       reg_w_val(dev, ET_I2C_PREFETCH, 0x02);  /* prefetch */
-       reg_w_val(dev, ET_I2C_PREFETCH, 0);
-       j = length - 1;
-       for (i = 0; i < length; i++) {
-               reg_r(dev, (ET_I2C_DATA0 + j), &buffer[j], 1);
-               j--;
-       }
+       reg_w_val(gspca_dev, ET_I2C_BASE, 0x40);
+                                       /* sensor base for the pas106 */
+       /* set count and prefetch (cnd: 4 bits - mode: 4 bits) */
+       reg_w_val(gspca_dev, ET_I2C_COUNT, 0x11);
+       reg_w_val(gspca_dev, ET_I2C_REG, reg);  /* set the register base */
+       reg_w_val(gspca_dev, ET_I2C_PREFETCH, 0x02);    /* prefetch */
+       reg_w_val(gspca_dev, ET_I2C_PREFETCH, 0x00);
+       reg_r(gspca_dev, ET_I2C_DATA0, 1);      /* read one byte */
        return 0;
 }
 
-static int Et_WaitStatus(struct usb_device *dev)
+static int Et_WaitStatus(struct gspca_dev *gspca_dev)
 {
-       __u8 bytereceived;
        int retry = 10;
 
        while (retry--) {
-               reg_r(dev, ET_ClCK, &bytereceived, 1);
-               if (bytereceived != 0)
+               reg_r(gspca_dev, ET_ClCK, 1);
+               if (gspca_dev->usb_buf[0] != 0)
                        return 1;
        }
        return 0;
 }
 
-static int et_video(struct usb_device *dev, int on)
+static int et_video(struct gspca_dev *gspca_dev,
+                   int on)
 {
-       int err;
+       int ret;
 
-       reg_w_val(dev, ET_GPIO_OUT, on
-                               ? 0x10          /* startvideo - set Bit5 */
-                               : 0);           /* stopvideo */
-       err = Et_WaitStatus(dev);
-       if (!err)
+       reg_w_val(gspca_dev, ET_GPIO_OUT,
+                 on ? 0x10             /* startvideo - set Bit5 */
+                    : 0);              /* stopvideo */
+       ret = Et_WaitStatus(gspca_dev);
+       if (ret != 0)
                PDEBUG(D_ERR, "timeout video on/off");
-       return err;
+       return ret;
 }
 
 static void Et_init2(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        __u8 value;
-       __u8 received;
        static const __u8 FormLine[] = { 0x84, 0x03, 0x14, 0xf4, 0x01, 0x05 };
 
        PDEBUG(D_STREAM, "Open Init2 ET");
-       reg_w_val(dev, ET_GPIO_DIR_CTRL, 0x2f);
-       reg_w_val(dev, ET_GPIO_OUT, 0x10);
-       reg_r(dev, ET_GPIO_IN, &received, 1);
-       reg_w_val(dev, ET_ClCK, 0x14);  /* 0x14 // 0x16 enabled pattern */
-       reg_w_val(dev, ET_CTRL, 0x1b);
+       reg_w_val(gspca_dev, ET_GPIO_DIR_CTRL, 0x2f);
+       reg_w_val(gspca_dev, ET_GPIO_OUT, 0x10);
+       reg_r(gspca_dev, ET_GPIO_IN, 1);
+       reg_w_val(gspca_dev, ET_ClCK, 0x14); /* 0x14 // 0x16 enabled pattern */
+       reg_w_val(gspca_dev, ET_CTRL, 0x1b);
 
        /*  compression et subsampling */
        if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv)
                value = ET_COMP_VAL1;   /* 320 */
        else
                value = ET_COMP_VAL0;   /* 640 */
-       reg_w_val(dev, ET_COMP, value);
-       reg_w_val(dev, ET_MAXQt, 0x1f);
-       reg_w_val(dev, ET_MINQt, 0x04);
+       reg_w_val(gspca_dev, ET_COMP, value);
+       reg_w_val(gspca_dev, ET_MAXQt, 0x1f);
+       reg_w_val(gspca_dev, ET_MINQt, 0x04);
        /* undocumented registers */
-       reg_w_val(dev, ET_REG1d, 0xff);
-       reg_w_val(dev, ET_REG1e, 0xff);
-       reg_w_val(dev, ET_REG1f, 0xff);
-       reg_w_val(dev, ET_REG20, 0x35);
-       reg_w_val(dev, ET_REG21, 0x01);
-       reg_w_val(dev, ET_REG22, 0x00);
-       reg_w_val(dev, ET_REG23, 0xff);
-       reg_w_val(dev, ET_REG24, 0xff);
-       reg_w_val(dev, ET_REG25, 0x0f);
+       reg_w_val(gspca_dev, ET_REG1d, 0xff);
+       reg_w_val(gspca_dev, ET_REG1e, 0xff);
+       reg_w_val(gspca_dev, ET_REG1f, 0xff);
+       reg_w_val(gspca_dev, ET_REG20, 0x35);
+       reg_w_val(gspca_dev, ET_REG21, 0x01);
+       reg_w_val(gspca_dev, ET_REG22, 0x00);
+       reg_w_val(gspca_dev, ET_REG23, 0xff);
+       reg_w_val(gspca_dev, ET_REG24, 0xff);
+       reg_w_val(gspca_dev, ET_REG25, 0x0f);
        /* colors setting */
-       reg_w_val(dev, 0x30, 0x11);             /* 0x30 */
-       reg_w_val(dev, 0x31, 0x40);
-       reg_w_val(dev, 0x32, 0x00);
-       reg_w_val(dev, ET_O_RED, 0x00);         /* 0x34 */
-       reg_w_val(dev, ET_O_GREEN1, 0x00);
-       reg_w_val(dev, ET_O_BLUE, 0x00);
-       reg_w_val(dev, ET_O_GREEN2, 0x00);
+       reg_w_val(gspca_dev, 0x30, 0x11);               /* 0x30 */
+       reg_w_val(gspca_dev, 0x31, 0x40);
+       reg_w_val(gspca_dev, 0x32, 0x00);
+       reg_w_val(gspca_dev, ET_O_RED, 0x00);           /* 0x34 */
+       reg_w_val(gspca_dev, ET_O_GREEN1, 0x00);
+       reg_w_val(gspca_dev, ET_O_BLUE, 0x00);
+       reg_w_val(gspca_dev, ET_O_GREEN2, 0x00);
        /*************/
-       reg_w_val(dev, ET_G_RED, 0x80);         /* 0x4d */
-       reg_w_val(dev, ET_G_GREEN1, 0x80);
-       reg_w_val(dev, ET_G_BLUE, 0x80);
-       reg_w_val(dev, ET_G_GREEN2, 0x80);
-       reg_w_val(dev, ET_G_GR_H, 0x00);
-       reg_w_val(dev, ET_G_GB_H, 0x00);                /* 0x52 */
+       reg_w_val(gspca_dev, ET_G_RED, 0x80);           /* 0x4d */
+       reg_w_val(gspca_dev, ET_G_GREEN1, 0x80);
+       reg_w_val(gspca_dev, ET_G_BLUE, 0x80);
+       reg_w_val(gspca_dev, ET_G_GREEN2, 0x80);
+       reg_w_val(gspca_dev, ET_G_GR_H, 0x00);
+       reg_w_val(gspca_dev, ET_G_GB_H, 0x00);          /* 0x52 */
        /* Window control registers */
-       reg_w_val(dev, 0x61, 0x80);             /* use cmc_out */
-       reg_w_val(dev, 0x62, 0x02);
-       reg_w_val(dev, 0x63, 0x03);
-       reg_w_val(dev, 0x64, 0x14);
-       reg_w_val(dev, 0x65, 0x0e);
-       reg_w_val(dev, 0x66, 0x02);
-       reg_w_val(dev, 0x67, 0x02);
+       reg_w_val(gspca_dev, 0x61, 0x80);               /* use cmc_out */
+       reg_w_val(gspca_dev, 0x62, 0x02);
+       reg_w_val(gspca_dev, 0x63, 0x03);
+       reg_w_val(gspca_dev, 0x64, 0x14);
+       reg_w_val(gspca_dev, 0x65, 0x0e);
+       reg_w_val(gspca_dev, 0x66, 0x02);
+       reg_w_val(gspca_dev, 0x67, 0x02);
 
        /**************************************/
-       reg_w_val(dev, ET_SYNCHRO, 0x8f);       /* 0x68 */
-       reg_w_val(dev, ET_STARTX, 0x69);                /* 0x6a //0x69 */
-       reg_w_val(dev, ET_STARTY, 0x0d);                /* 0x0d //0x0c */
-       reg_w_val(dev, ET_WIDTH_LOW, 0x80);
-       reg_w_val(dev, ET_HEIGTH_LOW, 0xe0);
-       reg_w_val(dev, ET_W_H_HEIGTH, 0x60);    /* 6d */
-       reg_w_val(dev, ET_REG6e, 0x86);
-       reg_w_val(dev, ET_REG6f, 0x01);
-       reg_w_val(dev, ET_REG70, 0x26);
-       reg_w_val(dev, ET_REG71, 0x7a);
-       reg_w_val(dev, ET_REG72, 0x01);
+       reg_w_val(gspca_dev, ET_SYNCHRO, 0x8f);         /* 0x68 */
+       reg_w_val(gspca_dev, ET_STARTX, 0x69);          /* 0x6a //0x69 */
+       reg_w_val(gspca_dev, ET_STARTY, 0x0d);          /* 0x0d //0x0c */
+       reg_w_val(gspca_dev, ET_WIDTH_LOW, 0x80);
+       reg_w_val(gspca_dev, ET_HEIGTH_LOW, 0xe0);
+       reg_w_val(gspca_dev, ET_W_H_HEIGTH, 0x60);      /* 6d */
+       reg_w_val(gspca_dev, ET_REG6e, 0x86);
+       reg_w_val(gspca_dev, ET_REG6f, 0x01);
+       reg_w_val(gspca_dev, ET_REG70, 0x26);
+       reg_w_val(gspca_dev, ET_REG71, 0x7a);
+       reg_w_val(gspca_dev, ET_REG72, 0x01);
        /* Clock Pattern registers ***************** */
-       reg_w_val(dev, ET_REG73, 0x00);
-       reg_w_val(dev, ET_REG74, 0x18);         /* 0x28 */
-       reg_w_val(dev, ET_REG75, 0x0f);         /* 0x01 */
+       reg_w_val(gspca_dev, ET_REG73, 0x00);
+       reg_w_val(gspca_dev, ET_REG74, 0x18);           /* 0x28 */
+       reg_w_val(gspca_dev, ET_REG75, 0x0f);           /* 0x01 */
        /**********************************************/
-       reg_w_val(dev, 0x8a, 0x20);
-       reg_w_val(dev, 0x8d, 0x0f);
-       reg_w_val(dev, 0x8e, 0x08);
+       reg_w_val(gspca_dev, 0x8a, 0x20);
+       reg_w_val(gspca_dev, 0x8d, 0x0f);
+       reg_w_val(gspca_dev, 0x8e, 0x08);
        /**************************************/
-       reg_w_val(dev, 0x03, 0x08);
-       reg_w_val(dev, ET_PXL_CLK, 0x03);
-       reg_w_val(dev, 0x81, 0xff);
-       reg_w_val(dev, 0x80, 0x00);
-       reg_w_val(dev, 0x81, 0xff);
-       reg_w_val(dev, 0x80, 0x20);
-       reg_w_val(dev, 0x03, 0x01);
-       reg_w_val(dev, 0x03, 0x00);
-       reg_w_val(dev, 0x03, 0x08);
+       reg_w_val(gspca_dev, 0x03, 0x08);
+       reg_w_val(gspca_dev, ET_PXL_CLK, 0x03);
+       reg_w_val(gspca_dev, 0x81, 0xff);
+       reg_w_val(gspca_dev, 0x80, 0x00);
+       reg_w_val(gspca_dev, 0x81, 0xff);
+       reg_w_val(gspca_dev, 0x80, 0x20);
+       reg_w_val(gspca_dev, 0x03, 0x01);
+       reg_w_val(gspca_dev, 0x03, 0x00);
+       reg_w_val(gspca_dev, 0x03, 0x08);
        /********************************************/
 
-/*     reg_r(dev, ET_I2C_BASE, &received, 1);
+/*     reg_r(gspca_dev, ET_I2C_BASE, 1);
                                         always 0x40 as the pas106 ??? */
        /* set the sensor */
        if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv)
@@ -435,25 +449,24 @@ static void Et_init2(struct gspca_dev *gspca_dev)
                                         * 0x0b -> 24/(11+1) = 2 Mhz
                                         * 0x17 -> 24/(23+1) = 1 Mhz
                                         */
-       reg_w_val(dev, ET_PXL_CLK, value);
+       reg_w_val(gspca_dev, ET_PXL_CLK, value);
        /* now set by fifo the FormatLine setting */
-       reg_w(dev, 0x62, FormLine, 6);
+       reg_w(gspca_dev, 0x62, FormLine, 6);
 
        /* set exposure times [ 0..0x78] 0->longvalue 0x78->shortvalue */
-       reg_w_val(dev, 0x81, 0x47);             /* 0x47; */
-       reg_w_val(dev, 0x80, 0x40);             /* 0x40; */
+       reg_w_val(gspca_dev, 0x81, 0x47);       /* 0x47; */
+       reg_w_val(gspca_dev, 0x80, 0x40);       /* 0x40; */
        /* Pedro change */
        /* Brightness change Brith+ decrease value */
        /* Brigth- increase value */
        /* original value = 0x70; */
-       reg_w_val(dev, 0x81, 0x30);             /* 0x20; - set brightness */
-       reg_w_val(dev, 0x80, 0x20);             /* 0x20; */
+       reg_w_val(gspca_dev, 0x81, 0x30);       /* 0x20; - set brightness */
+       reg_w_val(gspca_dev, 0x80, 0x20);       /* 0x20; */
 }
 
 static void setcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 I2cc[] = { 0x05, 0x02, 0x02, 0x05, 0x0d };
        __u8 i2cflags = 0x01;
        /* __u8 green = 0; */
@@ -464,8 +477,8 @@ static void setcolors(struct gspca_dev *gspca_dev)
        /* green = 15 - ((((7*I2cc[0]) >> 2 ) + I2cc[3]) >> 1); */
        /* I2cc[1] = I2cc[2] = green; */
        if (sd->sensor == SENSOR_PAS106) {
-               Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3);
-               Et_i2cwrite(dev, PAS106_REG9, I2cc, sizeof I2cc, 1);
+               i2c_w(gspca_dev, PAS106_REG13, &i2cflags, 1, 3);
+               i2c_w(gspca_dev, PAS106_REG9, I2cc, sizeof I2cc, 1);
        }
 /*     PDEBUG(D_CONF , "Etoms red %d blue %d green %d",
                I2cc[3], I2cc[0], green); */
@@ -474,21 +487,17 @@ static void setcolors(struct gspca_dev *gspca_dev)
 static void getcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-/*     __u8 valblue; */
-       __u8 valred;
 
        if (sd->sensor == SENSOR_PAS106) {
-/*             Et_i2cread(gspca_dev->dev, PAS106_REG9, &valblue, 1, 1); */
-               Et_i2cread(gspca_dev->dev, PAS106_REG9 + 3, &valred, 1, 1);
-               sd->colors = valred & 0x0f;
+/*             i2c_r(gspca_dev, PAS106_REG9);           * blue */
+               i2c_r(gspca_dev, PAS106_REG9 + 3);      /* red */
+               sd->colors = gspca_dev->usb_buf[0] & 0x0f;
        }
 }
 
 static void Et_init1(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        __u8 value;
-       __u8 received;
 /*     __u8 I2c0 [] = {0x0a, 0x12, 0x05, 0x22, 0xac, 0x00, 0x01, 0x00}; */
        __u8 I2c0[] = { 0x0a, 0x12, 0x05, 0x6d, 0xcd, 0x00, 0x01, 0x00 };
                                                /* try 1/120 0x6d 0xcd 0x40 */
@@ -496,12 +505,12 @@ static void Et_init1(struct gspca_dev *gspca_dev)
                                                 * 1/60000 hmm ?? */
 
        PDEBUG(D_STREAM, "Open Init1 ET");
-       reg_w_val(dev, ET_GPIO_DIR_CTRL, 7);
-       reg_r(dev, ET_GPIO_IN, &received, 1);
-       reg_w_val(dev, ET_RESET_ALL, 1);
-       reg_w_val(dev, ET_RESET_ALL, 0);
-       reg_w_val(dev, ET_ClCK, 0x10);
-       reg_w_val(dev, ET_CTRL, 0x19);
+       reg_w_val(gspca_dev, ET_GPIO_DIR_CTRL, 7);
+       reg_r(gspca_dev, ET_GPIO_IN, 1);
+       reg_w_val(gspca_dev, ET_RESET_ALL, 1);
+       reg_w_val(gspca_dev, ET_RESET_ALL, 0);
+       reg_w_val(gspca_dev, ET_ClCK, 0x10);
+       reg_w_val(gspca_dev, ET_CTRL, 0x19);
        /*   compression et subsampling */
        if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv)
                value = ET_COMP_VAL1;
@@ -510,80 +519,79 @@ static void Et_init1(struct gspca_dev *gspca_dev)
        PDEBUG(D_STREAM, "Open mode %d Compression %d",
               gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv,
               value);
-       reg_w_val(dev, ET_COMP, value);
-       reg_w_val(dev, ET_MAXQt, 0x1d);
-       reg_w_val(dev, ET_MINQt, 0x02);
+       reg_w_val(gspca_dev, ET_COMP, value);
+       reg_w_val(gspca_dev, ET_MAXQt, 0x1d);
+       reg_w_val(gspca_dev, ET_MINQt, 0x02);
        /* undocumented registers */
-       reg_w_val(dev, ET_REG1d, 0xff);
-       reg_w_val(dev, ET_REG1e, 0xff);
-       reg_w_val(dev, ET_REG1f, 0xff);
-       reg_w_val(dev, ET_REG20, 0x35);
-       reg_w_val(dev, ET_REG21, 0x01);
-       reg_w_val(dev, ET_REG22, 0x00);
-       reg_w_val(dev, ET_REG23, 0xf7);
-       reg_w_val(dev, ET_REG24, 0xff);
-       reg_w_val(dev, ET_REG25, 0x07);
+       reg_w_val(gspca_dev, ET_REG1d, 0xff);
+       reg_w_val(gspca_dev, ET_REG1e, 0xff);
+       reg_w_val(gspca_dev, ET_REG1f, 0xff);
+       reg_w_val(gspca_dev, ET_REG20, 0x35);
+       reg_w_val(gspca_dev, ET_REG21, 0x01);
+       reg_w_val(gspca_dev, ET_REG22, 0x00);
+       reg_w_val(gspca_dev, ET_REG23, 0xf7);
+       reg_w_val(gspca_dev, ET_REG24, 0xff);
+       reg_w_val(gspca_dev, ET_REG25, 0x07);
        /* colors setting */
-       reg_w_val(dev, ET_G_RED, 0x80);
-       reg_w_val(dev, ET_G_GREEN1, 0x80);
-       reg_w_val(dev, ET_G_BLUE, 0x80);
-       reg_w_val(dev, ET_G_GREEN2, 0x80);
-       reg_w_val(dev, ET_G_GR_H, 0x00);
-       reg_w_val(dev, ET_G_GB_H, 0x00);
+       reg_w_val(gspca_dev, ET_G_RED, 0x80);
+       reg_w_val(gspca_dev, ET_G_GREEN1, 0x80);
+       reg_w_val(gspca_dev, ET_G_BLUE, 0x80);
+       reg_w_val(gspca_dev, ET_G_GREEN2, 0x80);
+       reg_w_val(gspca_dev, ET_G_GR_H, 0x00);
+       reg_w_val(gspca_dev, ET_G_GB_H, 0x00);
        /* Window control registers */
-       reg_w_val(dev, ET_SYNCHRO, 0xf0);
-       reg_w_val(dev, ET_STARTX, 0x56);                /* 0x56 */
-       reg_w_val(dev, ET_STARTY, 0x05);                /* 0x04 */
-       reg_w_val(dev, ET_WIDTH_LOW, 0x60);
-       reg_w_val(dev, ET_HEIGTH_LOW, 0x20);
-       reg_w_val(dev, ET_W_H_HEIGTH, 0x50);
-       reg_w_val(dev, ET_REG6e, 0x86);
-       reg_w_val(dev, ET_REG6f, 0x01);
-       reg_w_val(dev, ET_REG70, 0x86);
-       reg_w_val(dev, ET_REG71, 0x14);
-       reg_w_val(dev, ET_REG72, 0x00);
+       reg_w_val(gspca_dev, ET_SYNCHRO, 0xf0);
+       reg_w_val(gspca_dev, ET_STARTX, 0x56);          /* 0x56 */
+       reg_w_val(gspca_dev, ET_STARTY, 0x05);          /* 0x04 */
+       reg_w_val(gspca_dev, ET_WIDTH_LOW, 0x60);
+       reg_w_val(gspca_dev, ET_HEIGTH_LOW, 0x20);
+       reg_w_val(gspca_dev, ET_W_H_HEIGTH, 0x50);
+       reg_w_val(gspca_dev, ET_REG6e, 0x86);
+       reg_w_val(gspca_dev, ET_REG6f, 0x01);
+       reg_w_val(gspca_dev, ET_REG70, 0x86);
+       reg_w_val(gspca_dev, ET_REG71, 0x14);
+       reg_w_val(gspca_dev, ET_REG72, 0x00);
        /* Clock Pattern registers */
-       reg_w_val(dev, ET_REG73, 0x00);
-       reg_w_val(dev, ET_REG74, 0x00);
-       reg_w_val(dev, ET_REG75, 0x0a);
-       reg_w_val(dev, ET_I2C_CLK, 0x04);
-       reg_w_val(dev, ET_PXL_CLK, 0x01);
+       reg_w_val(gspca_dev, ET_REG73, 0x00);
+       reg_w_val(gspca_dev, ET_REG74, 0x00);
+       reg_w_val(gspca_dev, ET_REG75, 0x0a);
+       reg_w_val(gspca_dev, ET_I2C_CLK, 0x04);
+       reg_w_val(gspca_dev, ET_PXL_CLK, 0x01);
        /* set the sensor */
        if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
                I2c0[0] = 0x06;
-               Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
-               Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof I2c2, 1);
+               i2c_w(gspca_dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
+               i2c_w(gspca_dev, PAS106_REG9, I2c2, sizeof I2c2, 1);
                value = 0x06;
-               Et_i2cwrite(dev, PAS106_REG2, &value, 1, 1);
-               Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
+               i2c_w(gspca_dev, PAS106_REG2, &value, 1, 1);
+               i2c_w(gspca_dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
                /* value = 0x1f; */
                value = 0x04;
-               Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1);
+               i2c_w(gspca_dev, PAS106_REG0e, &value, 1, 1);
        } else {
                I2c0[0] = 0x0a;
 
-               Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
-               Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof I2c2, 1);
+               i2c_w(gspca_dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
+               i2c_w(gspca_dev, PAS106_REG9, I2c2, sizeof I2c2, 1);
                value = 0x0a;
-
-               Et_i2cwrite(dev, PAS106_REG2, &value, 1, 1);
-               Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
+               i2c_w(gspca_dev, PAS106_REG2, &value, 1, 1);
+               i2c_w(gspca_dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
                value = 0x04;
                /* value = 0x10; */
-               Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1);
+               i2c_w(gspca_dev, PAS106_REG0e, &value, 1, 1);
                /* bit 2 enable bit 1:2 select 0 1 2 3
                   value = 0x07;                                * curve 0 *
-                  Et_i2cwrite(dev,PAS106_REG0f,&value,1,1);
+                  i2c_w(gspca_dev, PAS106_REG0f, &value, 1, 1);
                 */
        }
 
 /*     value = 0x01; */
 /*     value = 0x22; */
-/*     Et_i2cwrite(dev, PAS106_REG5, &value, 1, 1); */
+/*     i2c_w(gspca_dev, PAS106_REG5, &value, 1, 1); */
        /* magnetude and sign bit for DAC */
-       Et_i2cwrite(dev, PAS106_REG7, I2c4, sizeof I2c4, 1);
+       i2c_w(gspca_dev, PAS106_REG7, I2c4, sizeof I2c4, 1);
        /* now set by fifo the whole colors setting */
-       reg_w(dev, ET_G_RED, GainRGBG, 6);
+       reg_w(gspca_dev, ET_G_RED, GainRGBG, 6);
        getcolors(gspca_dev);
        setcolors(gspca_dev);
 }
@@ -632,14 +640,13 @@ static int sd_config(struct gspca_dev *gspca_dev,
 static int sd_open(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
        if (sd->sensor == SENSOR_PAS106)
                Et_init1(gspca_dev);
        else
                Et_init2(gspca_dev);
-       reg_w_val(dev, ET_RESET_ALL, 0x08);
-       et_video(dev, 0);               /* video off */
+       reg_w_val(gspca_dev, ET_RESET_ALL, 0x08);
+       et_video(gspca_dev, 0);         /* video off */
        return 0;
 }
 
@@ -647,20 +654,19 @@ static int sd_open(struct gspca_dev *gspca_dev)
 static void sd_start(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
        if (sd->sensor == SENSOR_PAS106)
                Et_init1(gspca_dev);
        else
                Et_init2(gspca_dev);
 
-       reg_w_val(dev, ET_RESET_ALL, 0x08);
-       et_video(dev, 1);               /* video on */
+       reg_w_val(gspca_dev, ET_RESET_ALL, 0x08);
+       et_video(gspca_dev, 1);         /* video on */
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-       et_video(gspca_dev->dev, 0);    /* video off */
+       et_video(gspca_dev, 0);         /* video off */
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
@@ -678,7 +684,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
        __u8 brightness = sd->brightness;
 
        for (i = 0; i < 4; i++)
-               reg_w_val(gspca_dev->dev, (ET_O_RED + i), brightness);
+               reg_w_val(gspca_dev, ET_O_RED + i, brightness);
 }
 
 static void getbrightness(struct gspca_dev *gspca_dev)
@@ -686,11 +692,10 @@ static void getbrightness(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int i;
        int brightness = 0;
-       __u8 value;
 
        for (i = 0; i < 4; i++) {
-               reg_r(gspca_dev->dev, (ET_O_RED + i), &value, 1);
-               brightness += value;
+               reg_r(gspca_dev, ET_O_RED + i, 1);
+               brightness += gspca_dev->usb_buf[0];
        }
        sd->brightness = brightness >> 3;
 }
@@ -701,8 +706,8 @@ static void setcontrast(struct gspca_dev *gspca_dev)
        __u8 RGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 };
        __u8 contrast = sd->contrast;
 
-       memset(RGBG, contrast, sizeof RGBG - 2);
-       reg_w(gspca_dev->dev, ET_G_RED, RGBG, 6);
+       memset(RGBG, contrast, sizeof(RGBG) - 2);
+       reg_w(gspca_dev, ET_G_RED, RGBG, 6);
 }
 
 static void getcontrast(struct gspca_dev *gspca_dev)
@@ -710,11 +715,10 @@ static void getcontrast(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int i;
        int contrast = 0;
-       __u8 value = 0;
 
        for (i = 0; i < 4; i++) {
-               reg_r(gspca_dev->dev, (ET_G_RED + i), &value, 1);
-               contrast += value;
+               reg_r(gspca_dev, ET_G_RED + i, 1);
+               contrast += gspca_dev->usb_buf[0];
        }
        sd->contrast = contrast >> 2;
 }
@@ -722,12 +726,11 @@ static void getcontrast(struct gspca_dev *gspca_dev)
 static __u8 Et_getgainG(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 value = 0;
 
        if (sd->sensor == SENSOR_PAS106) {
-               Et_i2cread(gspca_dev->dev, PAS106_REG0e, &value, 1, 1);
-               PDEBUG(D_CONF, "Etoms gain G %d", value);
-               return value;
+               i2c_r(gspca_dev, PAS106_REG0e);
+               PDEBUG(D_CONF, "Etoms gain G %d", gspca_dev->usb_buf[0]);
+               return gspca_dev->usb_buf[0];
        }
        return 0x1f;
 }
@@ -735,12 +738,12 @@ static __u8 Et_getgainG(struct gspca_dev *gspca_dev)
 static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 i2cflags = 0x01;
 
        if (sd->sensor == SENSOR_PAS106) {
-               Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3);
-               Et_i2cwrite(dev, PAS106_REG0e, &gain, 1, 1);
+               __u8 i2cflags = 0x01;
+
+               i2c_w(gspca_dev, PAS106_REG13, &i2cflags, 1, 3);
+               i2c_w(gspca_dev, PAS106_REG0e, &gain, 1, 1);
        }
 }
 
@@ -751,8 +754,6 @@ static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain)
 
 static void setautogain(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 GRBG[] = { 0, 0, 0, 0 };
        __u8 luma = 0;
        __u8 luma_mean = 128;
        __u8 luma_delta = 20;
@@ -761,10 +762,10 @@ static void setautogain(struct gspca_dev *gspca_dev)
        __u8 r, g, b;
 
        Gbright = Et_getgainG(gspca_dev);
-       reg_r(dev, ET_LUMA_CENTER, GRBG, 4);
-       g = (GRBG[0] + GRBG[3]) >> 1;
-       r = GRBG[1];
-       b = GRBG[2];
+       reg_r(gspca_dev, ET_LUMA_CENTER, 4);
+       g = (gspca_dev->usb_buf[0] + gspca_dev->usb_buf[3]) >> 1;
+       r = gspca_dev->usb_buf[1];
+       b = gspca_dev->usb_buf[2];
        r = ((r << 8) - (r << 4) - (r << 3)) >> 10;
        b = ((b << 7) >> 10);
        g = ((g << 9) + (g << 7) + (g << 5)) >> 10;
index a566fd3948951a5ed0be114e1168860131468eb8..242f0fb68d6e27aebcf5b90f752a5223950bab35 100644 (file)
@@ -1347,9 +1347,11 @@ ok:
                gspca_dev->fr_i,
                gspca_dev->fr_o);
 
-       if (gspca_dev->sd_desc->dq_callback)
+       if (gspca_dev->sd_desc->dq_callback) {
+               mutex_lock(&gspca_dev->usb_lock);
                gspca_dev->sd_desc->dq_callback(gspca_dev);
-
+               mutex_unlock(&gspca_dev->usb_lock);
+       }
        return j;
 }
 
index 78fccefcd576953edfb8c32dd309458805b68dbc..3fd2c4eee20433df38f18b4c539a04935841004c 100644 (file)
@@ -125,6 +125,7 @@ struct gspca_dev {
        struct cam cam;                         /* device information */
        const struct sd_desc *sd_desc;          /* subdriver description */
 
+       __u8 usb_buf[8];                        /* buffer for USB exchanges */
        struct urb *urb[MAX_NURBS];
 
        __u8 *frbuf;                            /* buffer for nframes */
index 23f3dba8012a2a960c9db6e9e720dcd4d1755571..88c2b02f380a191064b32de47454842595021d00 100644 (file)
@@ -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/Mars USB Camera Driver");
@@ -83,39 +83,53 @@ enum {
        REG_HW_MI_63,
        REG_HW_MI_64,
        REG_HW_MI_F1 = 0xf1,
-       ATTR_TOTAL_MI_REG = 242
+       ATTR_TOTAL_MI_REG = 0xf2
 };
 
-static int pcam_reg_write(struct usb_device *dev,
-                         __u16 index, __u8 *value, int len)
+/* the bytes to write are in gspca_dev->usb_buf */
+static int reg_w(struct gspca_dev *gspca_dev,
+                __u16 index, int len)
 {
        int rc;
 
-       rc = usb_control_msg(dev,
-                        usb_sndbulkpipe(dev, 4),
+       rc = usb_control_msg(gspca_dev->dev,
+                        usb_sndbulkpipe(gspca_dev->dev, 4),
                         0x12,
-/*             ?? 0xc8 = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_??? !? */
-                        0xc8,
+                        0xc8,          /* ?? */
                         0,             /* value */
-                        index, value, len, 500);
+                        index, gspca_dev->usb_buf, len, 500);
        if (rc < 0)
                PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
        return rc;
 }
 
-static void MISensor_BulkWrite(struct usb_device *dev,
-                               unsigned short *pch,
-                               char Address)
+static int reg_w_buf(struct gspca_dev *gspca_dev,
+                       __u16 index, __u8 *buf, int len)
 {
-       __u8 data[6];
+       int rc;
+
+       rc = usb_control_msg(gspca_dev->dev,
+                        usb_sndbulkpipe(gspca_dev->dev, 4),
+                        0x12,
+                        0xc8,          /* ?? */
+                        0,             /* value */
+                        index, buf, len, 500);
+       if (rc < 0)
+               PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
+       return rc;
+}
 
-       data[0] = 0x1f;
-       data[1] = 0;                    /* control byte */
-       data[2] = Address;
-       data[3] = *pch >> 8;            /* high byte */
-       data[4] = *pch;                 /* low byte */
+static void bulk_w(struct gspca_dev *gspca_dev,
+                  __u16 *pch,
+                  __u16 Address)
+{
+       gspca_dev->usb_buf[0] = 0x1f;
+       gspca_dev->usb_buf[1] = 0;                      /* control byte */
+       gspca_dev->usb_buf[2] = Address;
+       gspca_dev->usb_buf[3] = *pch >> 8;              /* high byte */
+       gspca_dev->usb_buf[4] = *pch;                   /* low byte */
 
-       pcam_reg_write(dev, Address, data, 5);
+       reg_w(gspca_dev, Address, 5);
 }
 
 /* this function is called at probe time */
@@ -142,33 +156,30 @@ static int sd_open(struct gspca_dev *gspca_dev)
 
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        int err_code;
-       __u8 data[12];
-       __u16 MI_buf[242];
+       __u8 *data;
+       __u16 *MI_buf;
        int h_size, v_size;
        int intpipe;
-/*     struct usb_device *dev = pcam->dev; */
-
-       memset(data, 0, sizeof data);
-       memset(MI_buf, 0, sizeof MI_buf);
 
        PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface);
-       if (usb_set_interface(dev, gspca_dev->iface, 8) < 0) {
+       if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8) < 0) {
                PDEBUG(D_ERR|D_STREAM, "Set packet size: set interface error");
                return;
        }
 
+       data = gspca_dev->usb_buf;
        data[0] = 0x01;         /* address */
        data[1] = 0x01;
 
-       err_code = pcam_reg_write(dev, data[0], data, 2);
+       err_code = reg_w(gspca_dev, data[0], 2);
        if (err_code < 0)
                return;
 
        /*
           Initialize the MR97113 chip register
         */
+       data = kmalloc(16, GFP_KERNEL);
        data[0] = 0x00;         /* address */
        data[1] = 0x0c | 0x01;  /* reg 0 */
        data[2] = 0x01;         /* reg 1 */
@@ -181,34 +192,34 @@ static void sd_start(struct gspca_dev *gspca_dev)
        data[6] = 4;            /* reg 5, H start */
        data[7] = 0xc0;         /* reg 6, gamma 1.5 */
        data[8] = 3;            /* reg 7, V start */
-/*     if(h_size == 320 ) */
+/*     if (h_size == 320 ) */
 /*             data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
 /*     else */
        data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
        data[10] = 0x5d;        /* reg 9, I2C device address
                                 *      [for PAS5101 (0x40)] [for MI (0x5d)] */
 
-       err_code = pcam_reg_write(dev, data[0], data, 11);
+       err_code = reg_w_buf(gspca_dev, data[0], data, 11);
+       kfree(data);
        if (err_code < 0)
                return;
 
+       data = gspca_dev->usb_buf;
        data[0] = 0x23;         /* address */
        data[1] = 0x09;         /* reg 35, append frame header */
 
-       err_code = pcam_reg_write(dev, data[0], data, 2);
-       if (err_code < 0) {
-               PDEBUG(D_ERR, "Register write failed");
+       err_code = reg_w(gspca_dev, data[0], 2);
+       if (err_code < 0)
                return;
-       }
 
-       data[0] = 0x3C;         /* address */
-/*     if (pcam->width == 1280) */
+       data[0] = 0x3c;         /* address */
+/*     if (gspca_dev->width == 1280) */
 /*             data[1] = 200;   * reg 60, pc-cam frame size
                                 *      (unit: 4KB) 800KB */
 /*     else */
        data[1] = 50;           /* 50 reg 60, pc-cam frame size
                                 *      (unit: 4KB) 200KB */
-       err_code = pcam_reg_write(dev, data[0], data, 2);
+       err_code = reg_w(gspca_dev, data[0], 2);
        if (err_code < 0)
                return;
 
@@ -250,19 +261,20 @@ static void sd_start(struct gspca_dev *gspca_dev)
        /* auto dark-gain */
        data[0] = 0x5e;         /* address */
 
-       err_code = pcam_reg_write(dev, data[0], data, 6);
+       err_code = reg_w(gspca_dev, data[0], 6);
        if (err_code < 0)
                return;
 
        data[0] = 0x67;
        data[1] = 0x13;         /* reg 103, first pixel B, disable sharpness */
-       err_code = pcam_reg_write(dev, data[0], data, 2);
+       err_code = reg_w(gspca_dev, data[0], 2);
        if (err_code < 0)
                return;
 
        /*
         * initialize the value of MI sensor...
         */
+       MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL);
        MI_buf[REG_HW_MI_1] = 0x000a;
        MI_buf[REG_HW_MI_2] = 0x000c;
        MI_buf[REG_HW_MI_3] = 0x0405;
@@ -304,48 +316,48 @@ static void sd_start(struct gspca_dev *gspca_dev)
        }
        MI_buf[0x20] = 0x1104;
 
-       MISensor_BulkWrite(dev, MI_buf + 1, 1);
-       MISensor_BulkWrite(dev, MI_buf + 2, 2);
-       MISensor_BulkWrite(dev, MI_buf + 3, 3);
-       MISensor_BulkWrite(dev, MI_buf + 4, 4);
-       MISensor_BulkWrite(dev, MI_buf + 5, 5);
-       MISensor_BulkWrite(dev, MI_buf + 6, 6);
-       MISensor_BulkWrite(dev, MI_buf + 7, 7);
-       MISensor_BulkWrite(dev, MI_buf + 9, 9);
-       MISensor_BulkWrite(dev, MI_buf + 0x0b, 0x0b);
-       MISensor_BulkWrite(dev, MI_buf + 0x0c, 0x0c);
-       MISensor_BulkWrite(dev, MI_buf + 0x0d, 0x0d);
-       MISensor_BulkWrite(dev, MI_buf + 0x1e, 0x1e);
-       MISensor_BulkWrite(dev, MI_buf + 0x20, 0x20);
-       MISensor_BulkWrite(dev, MI_buf + 0x2b, 0x2b);
-       MISensor_BulkWrite(dev, MI_buf + 0x2c, 0x2c);
-       MISensor_BulkWrite(dev, MI_buf + 0x2d, 0x2d);
-       MISensor_BulkWrite(dev, MI_buf + 0x2e, 0x2e);
-       MISensor_BulkWrite(dev, MI_buf + 0x35, 0x35);
-       MISensor_BulkWrite(dev, MI_buf + 0x5f, 0x5f);
-       MISensor_BulkWrite(dev, MI_buf + 0x60, 0x60);
-       MISensor_BulkWrite(dev, MI_buf + 0x61, 0x61);
-       MISensor_BulkWrite(dev, MI_buf + 0x62, 0x62);
-       MISensor_BulkWrite(dev, MI_buf + 0x63, 0x63);
-       MISensor_BulkWrite(dev, MI_buf + 0x64, 0x64);
-       MISensor_BulkWrite(dev, MI_buf + 0xf1, 0xf1);
-
-       intpipe = usb_sndintpipe(dev, 0);
-       err_code = usb_clear_halt(dev, intpipe);
+       bulk_w(gspca_dev, MI_buf + 1, 1);
+       bulk_w(gspca_dev, MI_buf + 2, 2);
+       bulk_w(gspca_dev, MI_buf + 3, 3);
+       bulk_w(gspca_dev, MI_buf + 4, 4);
+       bulk_w(gspca_dev, MI_buf + 5, 5);
+       bulk_w(gspca_dev, MI_buf + 6, 6);
+       bulk_w(gspca_dev, MI_buf + 7, 7);
+       bulk_w(gspca_dev, MI_buf + 9, 9);
+       bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b);
+       bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c);
+       bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d);
+       bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e);
+       bulk_w(gspca_dev, MI_buf + 0x20, 0x20);
+       bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b);
+       bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c);
+       bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d);
+       bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e);
+       bulk_w(gspca_dev, MI_buf + 0x35, 0x35);
+       bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f);
+       bulk_w(gspca_dev, MI_buf + 0x60, 0x60);
+       bulk_w(gspca_dev, MI_buf + 0x61, 0x61);
+       bulk_w(gspca_dev, MI_buf + 0x62, 0x62);
+       bulk_w(gspca_dev, MI_buf + 0x63, 0x63);
+       bulk_w(gspca_dev, MI_buf + 0x64, 0x64);
+       bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1);
+       kfree(MI_buf);
+
+       intpipe = usb_sndintpipe(gspca_dev->dev, 0);
+       err_code = usb_clear_halt(gspca_dev->dev, intpipe);
 
        data[0] = 0x00;
        data[1] = 0x4d;         /* ISOC transfering enable... */
-       pcam_reg_write(dev, data[0], data, 2);
+       reg_w(gspca_dev, data[0], 2);
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
        int result;
-       __u8 data[2];
 
-       data[0] = 1;
-       data[1] = 0;
-       result = pcam_reg_write(gspca_dev->dev, data[0], data, 2);
+       gspca_dev->usb_buf[0] = 1;
+       gspca_dev->usb_buf[1] = 0;
+       result = reg_w(gspca_dev, gspca_dev->usb_buf[0], 2);
        if (result < 0)
                PDEBUG(D_ERR, "Camera Stop failed");
 }
index ba245bafcd6fcea722de5306ee6a7b0357c065d3..08d99c3b78e2ddafcae52d32aa4aa70615c27e5d 100644 (file)
@@ -24,8 +24,8 @@
 
 #include "gspca.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("Jean-Francois Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("OV519 USB Camera Driver");
@@ -282,15 +282,14 @@ static unsigned char ov7670_abs_to_sm(unsigned char v)
 static int reg_w(struct sd *sd, __u16 index, __u8 value)
 {
        int ret;
-       __u8 data;
 
-       data = value;
+       sd->gspca_dev.usb_buf[0] = value;
        ret = usb_control_msg(sd->gspca_dev.dev,
                        usb_sndctrlpipe(sd->gspca_dev.dev, 0),
                        1,                      /* REQ_IO (ov518/519) */
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0, index,
-                       &data, 1, 500);
+                       sd->gspca_dev.usb_buf, 1, 500);
        if (ret < 0)
                PDEBUG(D_ERR, "Write reg [%02x] %02x failed", index, value);
        return ret;
@@ -301,16 +300,15 @@ static int reg_w(struct sd *sd, __u16 index, __u8 value)
 static int reg_r(struct sd *sd, __u16 index)
 {
        int ret;
-       __u8 data;
 
        ret = usb_control_msg(sd->gspca_dev.dev,
                        usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
                        1,                      /* REQ_IO */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                       0, index, &data, 1, 500);
+                       0, index, sd->gspca_dev.usb_buf, 1, 500);
 
        if (ret >= 0)
-               ret = data;
+               ret = sd->gspca_dev.usb_buf[0];
        else
                PDEBUG(D_ERR, "Read reg [0x%02x] failed", index);
        return ret;
@@ -321,16 +319,15 @@ static int reg_r8(struct sd *sd,
                  __u16 index)
 {
        int ret;
-       __u8 buf[8];
 
        ret = usb_control_msg(sd->gspca_dev.dev,
                        usb_rcvctrlpipe(sd->gspca_dev.dev, 0),
                        1,                      /* REQ_IO */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                       0, index, &buf[0], 8, 500);
+                       0, index, sd->gspca_dev.usb_buf, 8, 500);
 
        if (ret >= 0)
-               ret = buf[0];
+               ret = sd->gspca_dev.usb_buf[0];
        else
                PDEBUG(D_ERR, "Read reg 8 [0x%02x] failed", index);
        return ret;
index 5d68d3f42262990786fa0465a115ce6901b2c5b6..fa7abc411090c48e7803be522bda37640c36eea2 100644 (file)
@@ -27,8 +27,8 @@
 
 #include "gspca.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("Hans de Goede <j.w.r.degoede@hhs.nl>");
 MODULE_DESCRIPTION("Pixart PAC207");
@@ -187,18 +187,18 @@ static const __u8 PacReg72[] = { 0x00, 0x00, 0x36, 0x00 };
 static const unsigned char pac207_sof_marker[5] =
                { 0xff, 0xff, 0x00, 0xff, 0x96 };
 
-int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
+static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
        const u8 *buffer, u16 length)
 {
        struct usb_device *udev = gspca_dev->dev;
        int err;
-       u8 kbuf[8];
 
-       memcpy(kbuf, buffer, length);
+       memcpy(gspca_dev->usb_buf, buffer, length);
 
        err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x01,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
-                       0x00, index, kbuf, length, PAC207_CTRL_TIMEOUT);
+                       0x00, index,
+                       gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT);
        if (err < 0)
                PDEBUG(D_ERR,
                        "Failed to write registers to index 0x%04X, error %d)",
@@ -227,12 +227,12 @@ int pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value)
 int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
 {
        struct usb_device *udev = gspca_dev->dev;
-       u8 buff;
        int res;
 
        res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
-                       0x00, index, &buff, 1, PAC207_CTRL_TIMEOUT);
+                       0x00, index,
+                       gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT);
        if (res < 0) {
                PDEBUG(D_ERR,
                        "Failed to read a register (index 0x%04X, error %d)",
@@ -240,10 +240,9 @@ int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
                return res;
        }
 
-       return buff;
+       return gspca_dev->usb_buf[0];
 }
 
-
 /* this function is called at probe time */
 static int sd_config(struct gspca_dev *gspca_dev,
                        const struct usb_device_id *id)
index 1a2347aa7157215a8fb444d085b71b8ac87658c0..5c052e31be4adad49b2eb93e496e0d8c2e89e5a7 100644 (file)
@@ -23,8 +23,8 @@
 
 #include "gspca.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("Thomas Kaiser thomas@kaiser-linux.li");
 MODULE_DESCRIPTION("Pixart PAC7311");
@@ -206,46 +206,43 @@ static const __u8 pac7311_jpeg_header[] = {
        0x11, 0x00, 0x3f, 0x00
 };
 
-static void reg_w(struct usb_device *dev,
+static void reg_w_buf(struct gspca_dev *gspca_dev,
                  __u16 index,
                  const char *buffer, __u16 len)
 {
-       __u8 tmpbuf[8];
-
-       memcpy(tmpbuf, buffer, len);
-       usb_control_msg(dev,
-                       usb_sndctrlpipe(dev, 0),
+       memcpy(gspca_dev->usb_buf, buffer, len);
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        1,              /* request */
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,              /* value */
-                       index, tmpbuf, len,
+                       index, gspca_dev->usb_buf, len,
                        500);
 }
 
-static void pac7311_reg_read(struct usb_device *dev, __u16 index,
-                           __u8 *buffer)
+static __u8 reg_r(struct gspca_dev *gspca_dev,
+                            __u16 index)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,                      /* request */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,                      /* value */
-                       index, buffer, 1,
+                       index, gspca_dev->usb_buf, 1,
                        500);
+       return gspca_dev->usb_buf[0];
 }
 
-static void pac7311_reg_write(struct usb_device *dev,
-                             __u16 index,
-                             __u8 value)
+static void reg_w(struct gspca_dev *gspca_dev,
+                 __u16 index,
+                 __u8 value)
 {
-       __u8 buf;
-
-       buf = value;
-       usb_control_msg(dev,
-                       usb_sndctrlpipe(dev, 0),
+       gspca_dev->usb_buf[0] = value;
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        0,                      /* request */
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                       value, index, &buf, 1,
+                       value, index, gspca_dev->usb_buf, 1,
                        500);
 }
 
@@ -254,20 +251,19 @@ static int sd_config(struct gspca_dev *gspca_dev,
                        const struct usb_device_id *id)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        struct cam *cam;
 
        PDEBUG(D_CONF, "Find Sensor PAC7311");
-       pac7311_reg_write(dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0xff, 0x04);
-       pac7311_reg_write(dev, 0x27, 0x80);
-       pac7311_reg_write(dev, 0x28, 0xca);
-       pac7311_reg_write(dev, 0x29, 0x53);
-       pac7311_reg_write(dev, 0x2a, 0x0e);
-       pac7311_reg_write(dev, 0xff, 0x01);
-       pac7311_reg_write(dev, 0x3e, 0x20);
+       reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0xff, 0x04);
+       reg_w(gspca_dev, 0x27, 0x80);
+       reg_w(gspca_dev, 0x28, 0xca);
+       reg_w(gspca_dev, 0x29, 0x53);
+       reg_w(gspca_dev, 0x2a, 0x0e);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x3e, 0x20);
 
        cam = &gspca_dev->cam;
        cam->dev_name = (char *) id->driver_info;
@@ -289,11 +285,11 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
 /*jfm: inverted?*/
        brightness = BRIGHTNESS_MAX - sd->brightness;
-       pac7311_reg_write(gspca_dev->dev, 0xff, 0x04);
-/*     pac7311_reg_write(gspca_dev->dev, 0x0e, 0x00); */
-       pac7311_reg_write(gspca_dev->dev, 0x0f, brightness);
+       reg_w(gspca_dev, 0xff, 0x04);
+/*     reg_w(gspca_dev, 0x0e, 0x00); */
+       reg_w(gspca_dev, 0x0f, brightness);
        /* load registers to sensor (Bit 0, auto clear) */
-       pac7311_reg_write(gspca_dev->dev, 0x11, 0x01);
+       reg_w(gspca_dev, 0x11, 0x01);
        PDEBUG(D_CONF|D_STREAM, "brightness: %i", brightness);
 }
 
@@ -301,10 +297,10 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       pac7311_reg_write(gspca_dev->dev, 0xff, 0x01);
-       pac7311_reg_write(gspca_dev->dev, 0x80, sd->contrast);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x80, sd->contrast);
        /* load registers to sensor (Bit 0, auto clear) */
-       pac7311_reg_write(gspca_dev->dev, 0x11, 0x01);
+       reg_w(gspca_dev, 0x11, 0x01);
        PDEBUG(D_CONF|D_STREAM, "contrast: %i", sd->contrast);
 }
 
@@ -312,94 +308,93 @@ static void setcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       pac7311_reg_write(gspca_dev->dev, 0xff, 0x01);
-       pac7311_reg_write(gspca_dev->dev, 0x10, sd->colors);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x10, sd->colors);
        /* load registers to sensor (Bit 0, auto clear) */
-       pac7311_reg_write(gspca_dev->dev, 0x11, 0x01);
+       reg_w(gspca_dev, 0x11, 0x01);
        PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
 }
 
 /* this function is called at open time */
 static int sd_open(struct gspca_dev *gspca_dev)
 {
-       pac7311_reg_write(gspca_dev->dev, 0x78, 0x00);  /* Turn on LED */
+       reg_w(gspca_dev, 0x78, 0x00);   /* Turn on LED */
        return 0;
 }
 
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        struct sd *sd = (struct sd *) gspca_dev;
 
-       pac7311_reg_write(dev, 0xff, 0x01);
-       reg_w(dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8);
-       reg_w(dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8);
-       reg_w(dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8);
-       reg_w(dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8);
-       reg_w(dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8);
-       reg_w(dev, 0x002a, "\x00\x00\x00", 3);
-       reg_w(dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8);
-       reg_w(dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8);
-       reg_w(dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8);
-       reg_w(dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8);
-       reg_w(dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8);
-       reg_w(dev, 0x0066, "\xd0\xff", 2);
-       reg_w(dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6);
-       reg_w(dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8);
-       reg_w(dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8);
-       reg_w(dev, 0x008f, "\x18\x20", 2);
-       reg_w(dev, 0x0096, "\x01\x08\x04", 3);
-       reg_w(dev, 0x00a0, "\x44\x44\x44\x04", 4);
-       reg_w(dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8);
-       reg_w(dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5);
-
-       pac7311_reg_write(dev, 0xff, 0x04);
-       pac7311_reg_write(dev, 0x02, 0x04);
-       pac7311_reg_write(dev, 0x03, 0x54);
-       pac7311_reg_write(dev, 0x04, 0x07);
-       pac7311_reg_write(dev, 0x05, 0x2b);
-       pac7311_reg_write(dev, 0x06, 0x09);
-       pac7311_reg_write(dev, 0x07, 0x0f);
-       pac7311_reg_write(dev, 0x08, 0x09);
-       pac7311_reg_write(dev, 0x09, 0x00);
-       pac7311_reg_write(dev, 0x0c, 0x07);
-       pac7311_reg_write(dev, 0x0d, 0x00);
-       pac7311_reg_write(dev, 0x0e, 0x00);
-       pac7311_reg_write(dev, 0x0f, 0x62);
-       pac7311_reg_write(dev, 0x10, 0x08);
-       pac7311_reg_write(dev, 0x12, 0x07);
-       pac7311_reg_write(dev, 0x13, 0x00);
-       pac7311_reg_write(dev, 0x14, 0x00);
-       pac7311_reg_write(dev, 0x15, 0x00);
-       pac7311_reg_write(dev, 0x16, 0x00);
-       pac7311_reg_write(dev, 0x17, 0x00);
-       pac7311_reg_write(dev, 0x18, 0x00);
-       pac7311_reg_write(dev, 0x19, 0x00);
-       pac7311_reg_write(dev, 0x1a, 0x00);
-       pac7311_reg_write(dev, 0x1b, 0x03);
-       pac7311_reg_write(dev, 0x1c, 0xa0);
-       pac7311_reg_write(dev, 0x1d, 0x01);
-       pac7311_reg_write(dev, 0x1e, 0xf4);
-       pac7311_reg_write(dev, 0x21, 0x00);
-       pac7311_reg_write(dev, 0x22, 0x08);
-       pac7311_reg_write(dev, 0x24, 0x03);
-       pac7311_reg_write(dev, 0x26, 0x00);
-       pac7311_reg_write(dev, 0x27, 0x01);
-       pac7311_reg_write(dev, 0x28, 0xca);
-       pac7311_reg_write(dev, 0x29, 0x10);
-       pac7311_reg_write(dev, 0x2a, 0x06);
-       pac7311_reg_write(dev, 0x2b, 0x78);
-       pac7311_reg_write(dev, 0x2c, 0x00);
-       pac7311_reg_write(dev, 0x2d, 0x00);
-       pac7311_reg_write(dev, 0x2e, 0x00);
-       pac7311_reg_write(dev, 0x2f, 0x00);
-       pac7311_reg_write(dev, 0x30, 0x23);
-       pac7311_reg_write(dev, 0x31, 0x28);
-       pac7311_reg_write(dev, 0x32, 0x04);
-       pac7311_reg_write(dev, 0x33, 0x11);
-       pac7311_reg_write(dev, 0x34, 0x00);
-       pac7311_reg_write(dev, 0x35, 0x00);
-       pac7311_reg_write(dev, 0x11, 0x01);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w_buf(gspca_dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8);
+       reg_w_buf(gspca_dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8);
+       reg_w_buf(gspca_dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8);
+       reg_w_buf(gspca_dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8);
+       reg_w_buf(gspca_dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8);
+       reg_w_buf(gspca_dev, 0x002a, "\x00\x00\x00", 3);
+       reg_w_buf(gspca_dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8);
+       reg_w_buf(gspca_dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8);
+       reg_w_buf(gspca_dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8);
+       reg_w_buf(gspca_dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8);
+       reg_w_buf(gspca_dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8);
+       reg_w_buf(gspca_dev, 0x0066, "\xd0\xff", 2);
+       reg_w_buf(gspca_dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6);
+       reg_w_buf(gspca_dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8);
+       reg_w_buf(gspca_dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8);
+       reg_w_buf(gspca_dev, 0x008f, "\x18\x20", 2);
+       reg_w_buf(gspca_dev, 0x0096, "\x01\x08\x04", 3);
+       reg_w_buf(gspca_dev, 0x00a0, "\x44\x44\x44\x04", 4);
+       reg_w_buf(gspca_dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8);
+       reg_w_buf(gspca_dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5);
+
+       reg_w(gspca_dev, 0xff, 0x04);
+       reg_w(gspca_dev, 0x02, 0x04);
+       reg_w(gspca_dev, 0x03, 0x54);
+       reg_w(gspca_dev, 0x04, 0x07);
+       reg_w(gspca_dev, 0x05, 0x2b);
+       reg_w(gspca_dev, 0x06, 0x09);
+       reg_w(gspca_dev, 0x07, 0x0f);
+       reg_w(gspca_dev, 0x08, 0x09);
+       reg_w(gspca_dev, 0x09, 0x00);
+       reg_w(gspca_dev, 0x0c, 0x07);
+       reg_w(gspca_dev, 0x0d, 0x00);
+       reg_w(gspca_dev, 0x0e, 0x00);
+       reg_w(gspca_dev, 0x0f, 0x62);
+       reg_w(gspca_dev, 0x10, 0x08);
+       reg_w(gspca_dev, 0x12, 0x07);
+       reg_w(gspca_dev, 0x13, 0x00);
+       reg_w(gspca_dev, 0x14, 0x00);
+       reg_w(gspca_dev, 0x15, 0x00);
+       reg_w(gspca_dev, 0x16, 0x00);
+       reg_w(gspca_dev, 0x17, 0x00);
+       reg_w(gspca_dev, 0x18, 0x00);
+       reg_w(gspca_dev, 0x19, 0x00);
+       reg_w(gspca_dev, 0x1a, 0x00);
+       reg_w(gspca_dev, 0x1b, 0x03);
+       reg_w(gspca_dev, 0x1c, 0xa0);
+       reg_w(gspca_dev, 0x1d, 0x01);
+       reg_w(gspca_dev, 0x1e, 0xf4);
+       reg_w(gspca_dev, 0x21, 0x00);
+       reg_w(gspca_dev, 0x22, 0x08);
+       reg_w(gspca_dev, 0x24, 0x03);
+       reg_w(gspca_dev, 0x26, 0x00);
+       reg_w(gspca_dev, 0x27, 0x01);
+       reg_w(gspca_dev, 0x28, 0xca);
+       reg_w(gspca_dev, 0x29, 0x10);
+       reg_w(gspca_dev, 0x2a, 0x06);
+       reg_w(gspca_dev, 0x2b, 0x78);
+       reg_w(gspca_dev, 0x2c, 0x00);
+       reg_w(gspca_dev, 0x2d, 0x00);
+       reg_w(gspca_dev, 0x2e, 0x00);
+       reg_w(gspca_dev, 0x2f, 0x00);
+       reg_w(gspca_dev, 0x30, 0x23);
+       reg_w(gspca_dev, 0x31, 0x28);
+       reg_w(gspca_dev, 0x32, 0x04);
+       reg_w(gspca_dev, 0x33, 0x11);
+       reg_w(gspca_dev, 0x34, 0x00);
+       reg_w(gspca_dev, 0x35, 0x00);
+       reg_w(gspca_dev, 0x11, 0x01);
        setcontrast(gspca_dev);
        setbrightness(gspca_dev);
        setcolors(gspca_dev);
@@ -407,39 +402,39 @@ static void sd_start(struct gspca_dev *gspca_dev)
        /* set correct resolution */
        switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
        case 2:                                 /* 160x120 */
-               pac7311_reg_write(dev, 0xff, 0x04);
-               pac7311_reg_write(dev, 0x02, 0x03);
-               pac7311_reg_write(dev, 0xff, 0x01);
-               pac7311_reg_write(dev, 0x08, 0x09);
-               pac7311_reg_write(dev, 0x17, 0x20);
-               pac7311_reg_write(dev, 0x1b, 0x00);
-/*             pac7311_reg_write(dev, 0x80, 0x69); */
-               pac7311_reg_write(dev, 0x87, 0x10);
+               reg_w(gspca_dev, 0xff, 0x04);
+               reg_w(gspca_dev, 0x02, 0x03);
+               reg_w(gspca_dev, 0xff, 0x01);
+               reg_w(gspca_dev, 0x08, 0x09);
+               reg_w(gspca_dev, 0x17, 0x20);
+               reg_w(gspca_dev, 0x1b, 0x00);
+/*             reg_w(gspca_dev, 0x80, 0x69); */
+               reg_w(gspca_dev, 0x87, 0x10);
                break;
        case 1:                                 /* 320x240 */
-               pac7311_reg_write(dev, 0xff, 0x04);
-               pac7311_reg_write(dev, 0x02, 0x03);
-               pac7311_reg_write(dev, 0xff, 0x01);
-               pac7311_reg_write(dev, 0x08, 0x09);
-               pac7311_reg_write(dev, 0x17, 0x30);
-/*             pac7311_reg_write(dev, 0x80, 0x3f); */
-               pac7311_reg_write(dev, 0x87, 0x11);
+               reg_w(gspca_dev, 0xff, 0x04);
+               reg_w(gspca_dev, 0x02, 0x03);
+               reg_w(gspca_dev, 0xff, 0x01);
+               reg_w(gspca_dev, 0x08, 0x09);
+               reg_w(gspca_dev, 0x17, 0x30);
+/*             reg_w(gspca_dev, 0x80, 0x3f); */
+               reg_w(gspca_dev, 0x87, 0x11);
                break;
        case 0:                                 /* 640x480 */
-               pac7311_reg_write(dev, 0xff, 0x04);
-               pac7311_reg_write(dev, 0x02, 0x03);
-               pac7311_reg_write(dev, 0xff, 0x01);
-               pac7311_reg_write(dev, 0x08, 0x08);
-               pac7311_reg_write(dev, 0x17, 0x00);
-/*             pac7311_reg_write(dev, 0x80, 0x1c); */
-               pac7311_reg_write(dev, 0x87, 0x12);
+               reg_w(gspca_dev, 0xff, 0x04);
+               reg_w(gspca_dev, 0x02, 0x03);
+               reg_w(gspca_dev, 0xff, 0x01);
+               reg_w(gspca_dev, 0x08, 0x08);
+               reg_w(gspca_dev, 0x17, 0x00);
+/*             reg_w(gspca_dev, 0x80, 0x1c); */
+               reg_w(gspca_dev, 0x87, 0x12);
                break;
        }
 
        /* start stream */
-       pac7311_reg_write(dev, 0xff, 0x01);
-       pac7311_reg_write(dev, 0x78, 0x04);
-       pac7311_reg_write(dev, 0x78, 0x05);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x78, 0x04);
+       reg_w(gspca_dev, 0x78, 0x05);
 
        if (sd->autogain) {
                sd->ag_cnt = AG_CNT_START;
@@ -451,18 +446,16 @@ static void sd_start(struct gspca_dev *gspca_dev)
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-
-       pac7311_reg_write(dev, 0xff, 0x04);
-       pac7311_reg_write(dev, 0x27, 0x80);
-       pac7311_reg_write(dev, 0x28, 0xca);
-       pac7311_reg_write(dev, 0x29, 0x53);
-       pac7311_reg_write(dev, 0x2a, 0x0e);
-       pac7311_reg_write(dev, 0xff, 0x01);
-       pac7311_reg_write(dev, 0x3e, 0x20);
-       pac7311_reg_write(dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0xff, 0x04);
+       reg_w(gspca_dev, 0x27, 0x80);
+       reg_w(gspca_dev, 0x28, 0xca);
+       reg_w(gspca_dev, 0x29, 0x53);
+       reg_w(gspca_dev, 0x2a, 0x0e);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x3e, 0x20);
+       reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
@@ -472,18 +465,16 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 /* this function is called at close time */
 static void sd_close(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-
-       pac7311_reg_write(dev, 0xff, 0x04);
-       pac7311_reg_write(dev, 0x27, 0x80);
-       pac7311_reg_write(dev, 0x28, 0xca);
-       pac7311_reg_write(dev, 0x29, 0x53);
-       pac7311_reg_write(dev, 0x2a, 0x0e);
-       pac7311_reg_write(dev, 0xff, 0x01);
-       pac7311_reg_write(dev, 0x3e, 0x20);
-       pac7311_reg_write(dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
-       pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0xff, 0x04);
+       reg_w(gspca_dev, 0x27, 0x80);
+       reg_w(gspca_dev, 0x28, 0xca);
+       reg_w(gspca_dev, 0x29, 0x53);
+       reg_w(gspca_dev, 0x2a, 0x0e);
+       reg_w(gspca_dev, 0xff, 0x01);
+       reg_w(gspca_dev, 0x3e, 0x20);
+       reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
+       reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
 }
 
 static void setautogain(struct gspca_dev *gspca_dev, int luma)
@@ -491,11 +482,9 @@ static void setautogain(struct gspca_dev *gspca_dev, int luma)
        int luma_mean = 128;
        int luma_delta = 20;
        __u8 spring = 5;
-       __u8 Pxclk;
        int Gbright;
 
-       pac7311_reg_read(gspca_dev->dev, 0x02, &Pxclk);
-       Gbright = Pxclk;
+       Gbright = reg_r(gspca_dev, 0x02);
        PDEBUG(D_FRAM, "luma mean %d", luma);
        if (luma < luma_mean - luma_delta ||
            luma > luma_mean + luma_delta) {
@@ -505,10 +494,10 @@ static void setautogain(struct gspca_dev *gspca_dev, int luma)
                else if (Gbright < 4)
                        Gbright = 4;
                PDEBUG(D_FRAM, "gbright %d", Gbright);
-               pac7311_reg_write(gspca_dev->dev, 0xff, 0x04);
-               pac7311_reg_write(gspca_dev->dev, 0x0f, Gbright);
+               reg_w(gspca_dev, 0xff, 0x04);
+               reg_w(gspca_dev, 0x0f, Gbright);
                /* load registers to sensor (Bit 0, auto clear) */
-               pac7311_reg_write(gspca_dev->dev, 0x11, 0x01);
+               reg_w(gspca_dev, 0x11, 0x01);
        }
 }
 
@@ -623,11 +612,8 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 
 static void getbrightness(struct gspca_dev *gspca_dev)
 {
-/*     __u8 brightness = 0;
-
-       pac7311_reg_read(gspca_dev->dev, 0x0008, &brightness);
-       spca50x->brightness = brightness;
-       return spca50x->brightness;     */
+/*     sd->brightness = reg_r(gspca_dev, 0x08);
+       return sd->brightness;  */
 /*     PDEBUG(D_CONF, "Called pac7311_getbrightness: Not implemented yet"); */
 }
 
index 5d23131988076ab9f2ebcd63750f42dcb0ce285e..ce8b28f504d395e466a7ce03e0706c1350809789 100644 (file)
@@ -384,64 +384,82 @@ static const __u8 tas5130_sensor_init[][8] = {
        {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
 };
 
-static void reg_r(struct usb_device *dev,
-                        __u16 value, __u8 *buffer)
+/* get one byte in gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 value)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,                      /* request */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                        value,
                        0,                      /* index */
-                       buffer, 1,
+                       gspca_dev->usb_buf, 1,
                        500);
 }
 
-static void reg_w(struct usb_device *dev,
-                         __u16 value,
-                         const __u8 *buffer,
-                         int len)
+static void reg_w(struct gspca_dev *gspca_dev,
+                 __u16 value,
+                 const __u8 *buffer,
+                 int len)
 {
-       __u8 tmpbuf[48];
-
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-       if (len > sizeof tmpbuf) {
+       if (len > sizeof gspca_dev->usb_buf) {
                PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
                return;
        }
 #endif
+       memcpy(gspca_dev->usb_buf, buffer, len);
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
+                       0x08,                   /* request */
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+                       value,
+                       0,                      /* index */
+                       gspca_dev->usb_buf, len,
+                       500);
+}
+
+static void reg_w_big(struct gspca_dev *gspca_dev,
+                 __u16 value,
+                 const __u8 *buffer,
+                 int len)
+{
+       __u8 *tmpbuf;
+
+       tmpbuf = kmalloc(len, GFP_KERNEL);
        memcpy(tmpbuf, buffer, len);
-       usb_control_msg(dev,
-                       usb_sndctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        0x08,                   /* request */
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                        value,
                        0,                      /* index */
                        tmpbuf, len,
                        500);
+       kfree(tmpbuf);
 }
 
-static int i2c_w(struct usb_device *dev, const __u8 *buffer)
+static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
 {
        int retry = 60;
-       __u8 ByteReceive;
 
        /* is i2c ready */
-       reg_w(dev, 0x08, buffer, 8);
+       reg_w(gspca_dev, 0x08, buffer, 8);
        while (retry--) {
                msleep(10);
-               reg_r(dev, 0x08, &ByteReceive);
-               if (ByteReceive == 4)
+               reg_r(gspca_dev, 0x08);
+               if (gspca_dev->usb_buf[0] == 4)
                        return 0;
        }
        return -1;
 }
 
-static void i2c_w_vector(struct usb_device *dev,
+static void i2c_w_vector(struct gspca_dev *gspca_dev,
                        const __u8 buffer[][8], int len)
 {
        for (;;) {
-               reg_w(dev, 0x08, *buffer, 8);
+               reg_w(gspca_dev, 0x08, *buffer, 8);
                len -= 8;
                if (len <= 0)
                        break;
@@ -460,7 +478,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                        {0xa0, 0x60, 0x06, 0x11, 0x99, 0x04, 0x94, 0x15};
 
                i2cOV6650[3] = sd->brightness;
-               if (i2c_w(gspca_dev->dev, i2cOV6650) < 0)
+               if (i2c_w(gspca_dev, i2cOV6650) < 0)
                         goto err;
                break;
            }
@@ -470,7 +488,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
                /* change reg 0x06 */
                i2cOV[3] = sd->brightness;
-               if (i2c_w(gspca_dev->dev, i2cOV) < 0)
+               if (i2c_w(gspca_dev, i2cOV) < 0)
                        goto err;
                break;
            }
@@ -480,11 +498,11 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
                i2c1[3] = sd->brightness >> 3;
                i2c1[2] = 0x0e;
-               if (i2c_w(gspca_dev->dev, i2c1) < 0)
+               if (i2c_w(gspca_dev, i2c1) < 0)
                        goto err;
                i2c1[3] = 0x01;
                i2c1[2] = 0x13;
-               if (i2c_w(gspca_dev->dev, i2c1) < 0)
+               if (i2c_w(gspca_dev, i2c1) < 0)
                        goto err;
                break;
            }
@@ -500,18 +518,18 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 
                /* change reg 0x10 */
                i2cpexpo[4] = 0xff - sd->brightness;
-/*             if(i2c_w(gspca_dev->dev,i2cpexpo1) < 0)
+/*             if(i2c_w(gspca_dev,i2cpexpo1) < 0)
                        goto err; */
-/*             if(i2c_w(gspca_dev->dev,i2cpdoit) < 0)
+/*             if(i2c_w(gspca_dev,i2cpdoit) < 0)
                        goto err; */
-               if (i2c_w(gspca_dev->dev, i2cpexpo) < 0)
+               if (i2c_w(gspca_dev, i2cpexpo) < 0)
                        goto err;
-               if (i2c_w(gspca_dev->dev, i2cpdoit) < 0)
+               if (i2c_w(gspca_dev, i2cpdoit) < 0)
                        goto err;
                i2cp202[3] = sd->brightness >> 3;
-               if (i2c_w(gspca_dev->dev, i2cp202) < 0)
+               if (i2c_w(gspca_dev, i2cp202) < 0)
                        goto err;
-               if (i2c_w(gspca_dev->dev, i2cpdoit) < 0)
+               if (i2c_w(gspca_dev, i2cpdoit) < 0)
                        goto err;
                break;
            }
@@ -522,7 +540,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                value = 0xff - sd->brightness;
                i2c[4] = value;
                PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
-               if (i2c_w(gspca_dev->dev, i2c) < 0)
+               if (i2c_w(gspca_dev, i2c) < 0)
                        goto err;
                break;
            }
@@ -551,14 +569,14 @@ static void setsensorgain(struct gspca_dev *gspca_dev)
                        {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 
                i2c[4] = 255 - gain;
-               if (i2c_w(gspca_dev->dev, i2c) < 0)
+               if (i2c_w(gspca_dev, i2c) < 0)
                        goto err;
                break;
            }
        case SENSOR_OV6650: {
                __u8 i2c[] = {0xa0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
                i2c[3] = gain;
-               if (i2c_w(gspca_dev->dev, i2c) < 0)
+               if (i2c_w(gspca_dev, i2c) < 0)
                        goto err;
                break;
            }
@@ -578,10 +596,10 @@ static void setgain(struct gspca_dev *gspca_dev)
 
        /* red and blue gain */
        rgb_value = gain << 4 | gain;
-       reg_w(gspca_dev->dev, 0x10, &rgb_value, 1);
+       reg_w(gspca_dev, 0x10, &rgb_value, 1);
        /* green gain */
        rgb_value = gain;
-       reg_w(gspca_dev->dev, 0x11, &rgb_value, 1);
+       reg_w(gspca_dev, 0x11, &rgb_value, 1);
 
        if (sd->sensor_has_gain)
                setsensorgain(gspca_dev);
@@ -604,7 +622,7 @@ static void setexposure(struct gspca_dev *gspca_dev)
                if (reg > 15)
                        reg = 15;
                reg = (reg << 4) | 0x0b;
-               reg_w(gspca_dev->dev, 0x19, &reg, 1);
+               reg_w(gspca_dev, 0x19, &reg, 1);
                break;
            }
        case SENSOR_OV6650: {
@@ -613,7 +631,7 @@ static void setexposure(struct gspca_dev *gspca_dev)
                if (i2c[3] > 15)
                        i2c[3] = 15;
                i2c[3] |= 0xc0;
-               if (i2c_w(gspca_dev->dev, i2c) < 0)
+               if (i2c_w(gspca_dev, i2c) < 0)
                        PDEBUG(D_ERR, "i2c error exposure");
                break;
            }
@@ -721,22 +739,20 @@ static int sd_config(struct gspca_dev *gspca_dev,
        sd->exposure = EXPOSURE_DEF;
        sd->autogain = AUTOGAIN_DEF;
        if (sd->sensor == SENSOR_OV7630_3)      /* jfm: from win trace */
-               reg_w(gspca_dev->dev, 0x01, probe_ov7630, sizeof probe_ov7630);
+               reg_w(gspca_dev, 0x01, probe_ov7630, sizeof probe_ov7630);
        return 0;
 }
 
 /* this function is called at open time */
 static int sd_open(struct gspca_dev *gspca_dev)
 {
-       __u8 ByteReceive;
-
-       reg_r(gspca_dev->dev, 0x00, &ByteReceive);
-       if (ByteReceive != 0x10)
+       reg_r(gspca_dev, 0x00);
+       if (gspca_dev->usb_buf[0] != 0x10)
                return -ENODEV;
        return 0;
 }
 
-static void pas106_i2cinit(struct usb_device *dev)
+static void pas106_i2cinit(struct gspca_dev *gspca_dev)
 {
        int i;
        const __u8 *data;
@@ -747,7 +763,7 @@ static void pas106_i2cinit(struct usb_device *dev)
        while (--i >= 0) {
                memcpy(&i2c1[2], data, 2);
                                        /* copy 2 bytes from the template */
-               if (i2c_w(dev, i2c1) < 0)
+               if (i2c_w(gspca_dev, i2c1) < 0)
                        PDEBUG(D_ERR, "i2c error pas106");
                data += 2;
        }
@@ -757,7 +773,6 @@ static void pas106_i2cinit(struct usb_device *dev)
 static void sd_start(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        int mode, l;
        const __u8 *sn9c10x;
        __u8 reg01, reg17;
@@ -835,75 +850,75 @@ static void sd_start(struct gspca_dev *gspca_dev)
        }
 
        /* reg 0x01 bit 2 video transfert on */
-       reg_w(dev, 0x01, &reg01, 1);
+       reg_w(gspca_dev, 0x01, &reg01, 1);
        /* reg 0x17 SensorClk enable inv Clk 0x60 */
-       reg_w(dev, 0x17, &reg17, 1);
+       reg_w(gspca_dev, 0x17, &reg17, 1);
 /*fixme: for ov7630 102
-       reg_w(dev, 0x01, {0x06, sn9c10x[1]}, 2); */
+       reg_w(gspca_dev, 0x01, {0x06, sn9c10x[1]}, 2); */
        /* Set the registers from the template */
-       reg_w(dev, 0x01, sn9c10x, l);
+       reg_w_big(gspca_dev, 0x01, sn9c10x, l);
        switch (sd->sensor) {
        case SENSOR_HV7131R:
-               i2c_w_vector(dev, hv7131_sensor_init,
+               i2c_w_vector(gspca_dev, hv7131_sensor_init,
                                sizeof hv7131_sensor_init);
                break;
        case SENSOR_OV6650:
-               i2c_w_vector(dev, ov6650_sensor_init,
+               i2c_w_vector(gspca_dev, ov6650_sensor_init,
                                sizeof ov6650_sensor_init);
                break;
        case SENSOR_OV7630:
-               i2c_w_vector(dev, ov7630_sensor_init_com,
+               i2c_w_vector(gspca_dev, ov7630_sensor_init_com,
                                sizeof ov7630_sensor_init_com);
                msleep(200);
-               i2c_w_vector(dev, ov7630_sensor_init,
+               i2c_w_vector(gspca_dev, ov7630_sensor_init,
                                sizeof ov7630_sensor_init);
                break;
        case SENSOR_OV7630_3:
-               i2c_w_vector(dev, ov7630_sensor_init_com,
+               i2c_w_vector(gspca_dev, ov7630_sensor_init_com,
                                sizeof ov7630_sensor_init_com);
                msleep(200);
-               i2c_w_vector(dev, ov7630_sensor_init_3,
+               i2c_w_vector(gspca_dev, ov7630_sensor_init_3,
                                sizeof ov7630_sensor_init_3);
                break;
        case SENSOR_PAS106:
-               pas106_i2cinit(dev);
+               pas106_i2cinit(gspca_dev);
                break;
        case SENSOR_PAS202:
-               i2c_w_vector(dev, pas202_sensor_init,
+               i2c_w_vector(gspca_dev, pas202_sensor_init,
                                sizeof pas202_sensor_init);
                break;
        case SENSOR_TAS5110:
-               i2c_w_vector(dev, tas5110_sensor_init,
+               i2c_w_vector(gspca_dev, tas5110_sensor_init,
                                sizeof tas5110_sensor_init);
                break;
        default:
 /*     case SENSOR_TAS5130CXX: */
-               i2c_w_vector(dev, tas5130_sensor_init,
+               i2c_w_vector(gspca_dev, tas5130_sensor_init,
                                sizeof tas5130_sensor_init);
                break;
        }
        /* H_size V_size  0x28, 0x1e maybe 640x480 */
-       reg_w(dev, 0x15, reg15, 2);
+       reg_w(gspca_dev, 0x15, reg15, 2);
        /* compression register */
-       reg_w(dev, 0x18, &reg17_19[1], 1);
+       reg_w(gspca_dev, 0x18, &reg17_19[1], 1);
        if (sd->sensor != SENSOR_OV7630_3) {
                /* H_start */
-               reg_w(dev, 0x12, &sn9c10x[0x12 - 1], 1);
+               reg_w(gspca_dev, 0x12, &sn9c10x[0x12 - 1], 1);
                /* V_START */
-               reg_w(dev, 0x13, &sn9c10x[0x13 - 1], 1);
+               reg_w(gspca_dev, 0x13, &sn9c10x[0x13 - 1], 1);
        }
        /* reset 0x17 SensorClk enable inv Clk 0x60 */
                                /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
-       reg_w(dev, 0x17, &reg17_19[0], 1);
+       reg_w(gspca_dev, 0x17, &reg17_19[0], 1);
        /*MCKSIZE ->3 */        /*fixme: not ov7630*/
        if (sd->sensor != SENSOR_OV7630_3)
-               reg_w(dev, 0x19, &reg17_19[2], 1);
+               reg_w(gspca_dev, 0x19, &reg17_19[2], 1);
        /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
-       reg_w(dev, 0x1c, &sn9c10x[0x1c - 1], 4);
+       reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4);
        /* Enable video transfert */
-       reg_w(dev, 0x01, &sn9c10x[0], 1);
+       reg_w(gspca_dev, 0x01, &sn9c10x[0], 1);
        /* Compression */
-       reg_w(dev, 0x18, &reg17_19[1], 2);
+       reg_w(gspca_dev, 0x18, &reg17_19[1], 2);
        msleep(20);
 
        setgain(gspca_dev);
@@ -919,7 +934,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
        __u8 ByteSend;
 
        ByteSend = 0x09;        /* 0X00 */
-       reg_w(gspca_dev->dev, 0x01, &ByteSend, 1);
+       reg_w(gspca_dev, 0x01, &ByteSend, 1);
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
index 4cb1421b8807d8fb266cbf22147fddc4fd35e7af..30e840dca481aff0616bac45bac28a6cf8c67df9 100644 (file)
@@ -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/SONIX JPEG USB Camera Driver");
@@ -512,42 +512,40 @@ static const __u8 qtable4[] = {
        0x29, 0x29, 0x29, 0x29
 };
 
-static void reg_r(struct usb_device *dev,
-                 __u16 value,
-                 __u8 *buffer, int len)
+/* read <len> bytes (len < sizeof gspca_dev->usb_buf) to gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 value, int len)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                        value, 0,
-                       buffer, len,
+                       gspca_dev->usb_buf, len,
                        500);
 }
 
-static void reg_w(struct usb_device *dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                          __u16 value,
                          const __u8 *buffer,
                          int len)
 {
-       if (len < 16) {
-               __u8 tmpbuf[16];
-
-               memcpy(tmpbuf, buffer, len);
-               usb_control_msg(dev,
-                               usb_sndctrlpipe(dev, 0),
+       if (len <= sizeof gspca_dev->usb_buf) {
+               memcpy(gspca_dev->usb_buf, buffer, len);
+               usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
                                0x08,
                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                                value, 0,
-                               tmpbuf, len,
+                               gspca_dev->usb_buf, len,
                                500);
        } else {
                __u8 *tmpbuf;
 
                tmpbuf = kmalloc(len, GFP_KERNEL);
                memcpy(tmpbuf, buffer, len);
-               usb_control_msg(dev,
-                               usb_sndctrlpipe(dev, 0),
+               usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
                                0x08,
                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                                value, 0,
@@ -557,12 +555,11 @@ static void reg_w(struct usb_device *dev,
        }
 }
 
-/* write 2 bytes */
+/* I2C write 2 bytes */
 static void i2c_w2(struct gspca_dev *gspca_dev,
                   const __u8 *buffer)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 mode[8];
 
        /* is i2c ready */
@@ -574,22 +571,21 @@ static void i2c_w2(struct gspca_dev *gspca_dev,
        mode[5] = 0;
        mode[6] = 0;
        mode[7] = 0x10;
-       reg_w(dev, 0x08, mode, 8);
+       reg_w(gspca_dev, 0x08, mode, 8);
 }
 
-/* write 8 bytes */
-static void i2c_w8(struct usb_device *dev, const __u8 *buffer)
+/* I2C write 8 bytes */
+static void i2c_w8(struct gspca_dev *gspca_dev,
+                  const __u8 *buffer)
 {
-       reg_w(dev, 0x08, buffer, 8);
+       reg_w(gspca_dev, 0x08, buffer, 8);
        msleep(1);
 }
 
-/* read 5 bytes */
-static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg,
-                  __u8 *buffer)
+/* read 5 bytes in gspca_dev->usb_buf */
+static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 mode[8];
 
        mode[0] = sd->i2c_ctrl_reg | 0x10;
@@ -600,40 +596,39 @@ static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg,
        mode[5] = 0;
        mode[6] = 0;
        mode[7] = 0x10;
-       i2c_w8(dev, mode);
+       i2c_w8(gspca_dev, mode);
        mode[0] = sd->i2c_ctrl_reg | (5 << 4) | 0x02;
        mode[2] = 0;
-       i2c_w8(dev, mode);
-       reg_r(dev, 0x0a, buffer, 5);
+       i2c_w8(gspca_dev, mode);
+       reg_r(gspca_dev, 0x0a, 5);
 }
 
 static int probesensor(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 reg02;
        static const __u8 datasend[] = { 2, 0 };
        /* reg val1 val2 val3 val4 */
-       __u8 datarecd[6];
 
        i2c_w2(gspca_dev, datasend);
 /* should write 0xa1 0x11 0x02 0x00 0x00 0x00 0x00 the 0x10 is add by i2cw */
        msleep(10);
        reg02 = 0x66;
-       reg_w(dev, 0x02, &reg02, 1);            /* Gpio on */
+       reg_w(gspca_dev, 0x02, &reg02, 1);              /* Gpio on */
        msleep(10);
-       i2c_r5(gspca_dev, 0, datarecd);         /* read sensor id */
-       if (datarecd[0] == 0x02
-           && datarecd[1] == 0x09
-           && datarecd[2] == 0x01
-           && datarecd[3] == 0x00
-           && datarecd[4] == 0x00) {
+       i2c_r5(gspca_dev, 0);                           /* read sensor id */
+       if (gspca_dev->usb_buf[0] == 0x02
+           && gspca_dev->usb_buf[1] == 0x09
+           && gspca_dev->usb_buf[2] == 0x01
+           && gspca_dev->usb_buf[3] == 0x00
+           && gspca_dev->usb_buf[4] == 0x00) {
                PDEBUG(D_PROBE, "Find Sensor sn9c102P HV7131R");
                sd->sensor = SENSOR_HV7131R;
                return SENSOR_HV7131R;
        }
        PDEBUG(D_PROBE, "Find Sensor %d %d %d",
-               datarecd[0], datarecd[1], datarecd[2]);
+               gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
+               gspca_dev->usb_buf[2]);
        PDEBUG(D_PROBE, "Sensor sn9c102P Not found");
        return -ENODEV;
 }
@@ -642,7 +637,6 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
                          const __u8 *sn9c1xx)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 data;
        __u8 regF1;
        const __u8 *reg9a;
@@ -655,14 +649,15 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
 
 
        regF1 = 0x00;
-       reg_w(dev, 0xf1, &regF1, 1);
+       reg_w(gspca_dev, 0xf1, &regF1, 1);
 
-       reg_w(dev, 0x01, &sn9c1xx[0], 1);       /*fixme:jfm was [1] en v1*/
+       reg_w(gspca_dev, 0x01, &sn9c1xx[0], 1);
+                                               /*fixme:jfm was [1] en v1*/
 
        /* configure gpio */
-       reg_w(dev, 0x01, &sn9c1xx[1], 2);
-       reg_w(dev, 0x08, &sn9c1xx[8], 2);
-       reg_w(dev, 0x17, &sn9c1xx[0x17], 3);
+       reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2);
+       reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
+       reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 3);
        switch (sd->customid) {
        case SN9C325:
                reg9a = reg9a_sn9c325;
@@ -674,37 +669,37 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
                reg9a = reg9a_def;
                break;
        }
-       reg_w(dev, 0x9a, reg9a, 6);
+       reg_w(gspca_dev, 0x9a, reg9a, 6);
 
        data = 0x60;                            /*fixme:jfm 60 00 00 (3) */
-       reg_w(dev, 0xd4, &data, 1);
+       reg_w(gspca_dev, 0xd4, &data, 1);
 
-       reg_w(dev, 0x03, &sn9c1xx[3], 0x0f);
+       reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
 
        switch (sd->customid) {
        case SN9C120:                           /* from win trace */
                data = 0x61;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
                data = 0x20;
-               reg_w(dev, 0x17, &data, 1);
+               reg_w(gspca_dev, 0x17, &data, 1);
                data = 0x60;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
                break;
        case SN9C325:
                data = 0x43;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
                data = 0xae;
-               reg_w(dev, 0x17, &data, 1);
+               reg_w(gspca_dev, 0x17, &data, 1);
                data = 0x42;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
                break;
        default:
                data = 0x43;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
                data = 0x61;
-               reg_w(dev, 0x17, &data, 1);
+               reg_w(gspca_dev, 0x17, &data, 1);
                data = 0x42;
-               reg_w(dev, 0x01, &data, 1);
+               reg_w(gspca_dev, 0x01, &data, 1);
        }
 
        if (sd->sensor == SENSOR_HV7131R) {
@@ -717,24 +712,22 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
 static void hv7131R_InitSensor(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       struct usb_device *dev = gspca_dev->dev;
        static const __u8 SetSensorClk[] =      /* 0x08 Mclk */
                { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
 
        while (hv7131r_sensor_init[i][0]) {
-               i2c_w8(dev, hv7131r_sensor_init[i]);
+               i2c_w8(gspca_dev, hv7131r_sensor_init[i]);
                i++;
        }
-       i2c_w8(dev, SetSensorClk);
+       i2c_w8(gspca_dev, SetSensorClk);
 }
 
 static void mi0360_InitSensor(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       struct usb_device *dev = gspca_dev->dev;
 
        while (mi0360_sensor_init[i][0]) {
-               i2c_w8(dev, mi0360_sensor_init[i]);
+               i2c_w8(gspca_dev, mi0360_sensor_init[i]);
                i++;
        }
 }
@@ -742,21 +735,19 @@ static void mi0360_InitSensor(struct gspca_dev *gspca_dev)
 static void mo4000_InitSensor(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       struct usb_device *dev = gspca_dev->dev;
 
        while (mo4000_sensor_init[i][0]) {
-               i2c_w8(dev, mo4000_sensor_init[i]);
+               i2c_w8(gspca_dev, mo4000_sensor_init[i]);
                i++;
        }
 }
 
 static void ov7648_InitSensor(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        int i = 0;
 
        while (ov7648_sensor_init[i][0]) {
-               i2c_w8(dev, ov7648_sensor_init[i]);
+               i2c_w8(gspca_dev, ov7648_sensor_init[i]);
                i++;
        }
 }
@@ -764,10 +755,9 @@ static void ov7648_InitSensor(struct gspca_dev *gspca_dev)
 static void ov7660_InitSensor(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       struct usb_device *dev = gspca_dev->dev;
 
        while (ov7660_sensor_init[i][0]) {
-               i2c_w8(dev, ov7660_sensor_init[i]);
+               i2c_w8(gspca_dev, ov7660_sensor_init[i]);
                i++;
        }
 }
@@ -1005,51 +995,52 @@ static int sd_config(struct gspca_dev *gspca_dev,
 static int sd_open(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 /*     const __u8 *sn9c1xx; */
        __u8 regF1;
        __u8 regGpio[] = { 0x29, 0x74 };
 
        /* setup a selector by customid */
        regF1 = 0x01;
-       reg_w(dev, 0xf1, &regF1, 1);
-       reg_r(dev, 0x00, &regF1, 1);    /* -> regF1 = 0x00 */
-       reg_w(dev, 0xf1, &regF1, 1);
-       reg_r(dev, 0x00, &regF1, 1);
+       reg_w(gspca_dev, 0xf1, &regF1, 1);
+       reg_r(gspca_dev, 0x00, 1);              /* -> regF1 = 0x00 */
+       regF1 = gspca_dev->usb_buf[0];
+       reg_w(gspca_dev, 0xf1, &regF1, 1);
+       reg_r(gspca_dev, 0x00, 1);
+       regF1 = gspca_dev->usb_buf[0];
        switch (sd->customid) {
        case SN9C102P:
                if (regF1 != 0x11)
                        return -ENODEV;
-               reg_w(dev, 0x02, &regGpio[1], 1);
+               reg_w(gspca_dev, 0x02, &regGpio[1], 1);
                break;
        case SN9C105:
                if (regF1 != 0x11)
                        return -ENODEV;
-               reg_w(dev, 0x02, regGpio, 2);
+               reg_w(gspca_dev, 0x02, regGpio, 2);
                break;
        case SN9C110:
                if (regF1 != 0x12)
                        return -ENODEV;
                regGpio[1] = 0x62;
-               reg_w(dev, 0x02, &regGpio[1], 1);
+               reg_w(gspca_dev, 0x02, &regGpio[1], 1);
                break;
        case SN9C120:
                if (regF1 != 0x12)
                        return -ENODEV;
                regGpio[1] = 0x70;
-               reg_w(dev, 0x02, regGpio, 2);
+               reg_w(gspca_dev, 0x02, regGpio, 2);
                break;
        default:
 /*     case SN9C325: */
                if (regF1 != 0x12)
                        return -ENODEV;
                regGpio[1] = 0x62;
-               reg_w(dev, 0x02, &regGpio[1], 1);
+               reg_w(gspca_dev, 0x02, &regGpio[1], 1);
                break;
        }
 
        regF1 = 0x01;
-       reg_w(dev, 0xf1, &regF1, 1);
+       reg_w(gspca_dev, 0xf1, &regF1, 1);
 
        return 0;
 }
@@ -1073,7 +1064,7 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                Expodoit[3] = expo >> 16;
                Expodoit[4] = expo >> 8;
                Expodoit[5] = expo;
-               i2c_w8(gspca_dev->dev, Expodoit);
+               i2c_w8(gspca_dev, Expodoit);
                break;
            }
        case SENSOR_MI0360: {
@@ -1086,9 +1077,9 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                        expo = 0x0001;
                expoMi[3] = expo >> 8;
                expoMi[4] = expo;
-               i2c_w8(gspca_dev->dev, expoMi);
-               i2c_w8(gspca_dev->dev, doit);
-               i2c_w8(gspca_dev->dev, sensorgo);
+               i2c_w8(gspca_dev, expoMi);
+               i2c_w8(gspca_dev, doit);
+               i2c_w8(gspca_dev, sensorgo);
                break;
            }
        case SENSOR_MO4000: {
@@ -1102,11 +1093,11 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev,
                else if (expo < 0x0001)
                        expo = 0x0001;
                expoMof[3] = (expo & 0x03fc) >> 2;
-               i2c_w8(gspca_dev->dev, expoMof);
+               i2c_w8(gspca_dev, expoMof);
                expoMo10[3] = ((expo & 0x1c00) >> 10)
                                | ((expo & 0x0003) << 4);
-               i2c_w8(gspca_dev->dev, expoMo10);
-               i2c_w8(gspca_dev->dev, gainMo);
+               i2c_w8(gspca_dev, expoMo10);
+               i2c_w8(gspca_dev, gainMo);
                PDEBUG(D_CONF, "set exposure %d",
                        ((expoMo10[3] & 0x07) << 10)
                        | (expoMof[3] << 2)
@@ -1145,7 +1136,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
        }
 
        k2 = sd->brightness >> 10;
-       reg_w(gspca_dev->dev, 0x96, &k2, 1);
+       reg_w(gspca_dev, 0x96, &k2, 1);
 }
 
 static void setcontrast(struct gspca_dev *gspca_dev)
@@ -1160,7 +1151,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
        contrast[2] = k2;
        contrast[0] = (k2 + 1) >> 1;
        contrast[4] = (k2 + 1) / 5;
-       reg_w(gspca_dev->dev, 0x84, contrast, 6);
+       reg_w(gspca_dev, 0x84, contrast, 6);
 }
 
 static void setcolors(struct gspca_dev *gspca_dev)
@@ -1174,14 +1165,13 @@ static void setcolors(struct gspca_dev *gspca_dev)
                data = (colour + 32) & 0x7f;    /* blue */
        else
                data = (-colour + 32) & 0x7f;   /* red */
-       reg_w(gspca_dev->dev, 0x05, &data, 1);
+       reg_w(gspca_dev, 0x05, &data, 1);
 }
 
 /* -- start the camera -- */
 static void sd_start(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        int i;
        __u8 data;
        __u8 reg1;
@@ -1203,45 +1193,45 @@ static void sd_start(struct gspca_dev *gspca_dev)
 /*fixme:jfm this sequence should appear at end of sd_start */
 /* with
        data = 0x44;
-       reg_w(dev, 0x01, &data, 1); */
-       reg_w(dev, 0x15, &sn9c1xx[0x15], 1);
-       reg_w(dev, 0x16, &sn9c1xx[0x16], 1);
-       reg_w(dev, 0x12, &sn9c1xx[0x12], 1);
-       reg_w(dev, 0x13, &sn9c1xx[0x13], 1);
-       reg_w(dev, 0x18, &sn9c1xx[0x18], 1);
-       reg_w(dev, 0xd2, &DC29[0], 1);
-       reg_w(dev, 0xd3, &DC29[1], 1);
-       reg_w(dev, 0xc6, &DC29[2], 1);
-       reg_w(dev, 0xc7, &DC29[3], 1);
-       reg_w(dev, 0xc8, &DC29[4], 1);
-       reg_w(dev, 0xc9, &DC29[5], 1);
+       reg_w(gspca_dev, 0x01, &data, 1); */
+       reg_w(gspca_dev, 0x15, &sn9c1xx[0x15], 1);
+       reg_w(gspca_dev, 0x16, &sn9c1xx[0x16], 1);
+       reg_w(gspca_dev, 0x12, &sn9c1xx[0x12], 1);
+       reg_w(gspca_dev, 0x13, &sn9c1xx[0x13], 1);
+       reg_w(gspca_dev, 0x18, &sn9c1xx[0x18], 1);
+       reg_w(gspca_dev, 0xd2, &DC29[0], 1);
+       reg_w(gspca_dev, 0xd3, &DC29[1], 1);
+       reg_w(gspca_dev, 0xc6, &DC29[2], 1);
+       reg_w(gspca_dev, 0xc7, &DC29[3], 1);
+       reg_w(gspca_dev, 0xc8, &DC29[4], 1);
+       reg_w(gspca_dev, 0xc9, &DC29[5], 1);
 /*fixme:jfm end of ending sequence */
-       reg_w(dev, 0x18, &sn9c1xx[0x18], 1);
+       reg_w(gspca_dev, 0x18, &sn9c1xx[0x18], 1);
        if (sd->customid == SN9C325)
                data = 0xae;
        else
                data = 0x60;
-       reg_w(dev, 0x17, &data, 1);
-       reg_w(dev, 0x05, &sn9c1xx[5], 1);
-       reg_w(dev, 0x07, &sn9c1xx[7], 1);
-       reg_w(dev, 0x06, &sn9c1xx[6], 1);
-       reg_w(dev, 0x14, &sn9c1xx[0x14], 1);
+       reg_w(gspca_dev, 0x17, &data, 1);
+       reg_w(gspca_dev, 0x05, &sn9c1xx[5], 1);
+       reg_w(gspca_dev, 0x07, &sn9c1xx[7], 1);
+       reg_w(gspca_dev, 0x06, &sn9c1xx[6], 1);
+       reg_w(gspca_dev, 0x14, &sn9c1xx[0x14], 1);
        if (sd->customid == SN9C325) {
-               reg_w(dev, 0x20, regsn20_sn9c325, 0x11);
+               reg_w(gspca_dev, 0x20, regsn20_sn9c325, 0x11);
                for (i = 0; i < 8; i++)
-                       reg_w(dev, 0x84, reg84_sn9c325, 0x15);
+                       reg_w(gspca_dev, 0x84, reg84_sn9c325, 0x15);
                data = 0x0a;
-               reg_w(dev, 0x9a, &data, 1);
+               reg_w(gspca_dev, 0x9a, &data, 1);
                data = 0x60;
-               reg_w(dev, 0x99, &data, 1);
+               reg_w(gspca_dev, 0x99, &data, 1);
        } else {
-               reg_w(dev, 0x20, regsn20, 0x11);
+               reg_w(gspca_dev, 0x20, regsn20, 0x11);
                for (i = 0; i < 8; i++)
-                       reg_w(dev, 0x84, reg84, 0x15);
+                       reg_w(gspca_dev, 0x84, reg84, 0x15);
                data = 0x08;
-               reg_w(dev, 0x9a, &data, 1);
+               reg_w(gspca_dev, 0x9a, &data, 1);
                data = 0x59;
-               reg_w(dev, 0x99, &data, 1);
+               reg_w(gspca_dev, 0x99, &data, 1);
        }
 
        mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
@@ -1294,38 +1284,38 @@ static void sd_start(struct gspca_dev *gspca_dev)
                }
                break;
        }
-       reg_w(dev, 0xc0, C0, 6);
+       reg_w(gspca_dev, 0xc0, C0, 6);
        switch (sd->customid) {
        case SN9C120:                   /*jfm ?? */
-               reg_w(dev, 0xca, CA_sn9c120, 4);
+               reg_w(gspca_dev, 0xca, CA_sn9c120, 4);
                break;
        default:
-               reg_w(dev, 0xca, CA, 4);
+               reg_w(gspca_dev, 0xca, CA, 4);
                break;
        }
        switch (sd->customid) {
        case SN9C120:                   /*jfm ?? */
        case SN9C325:
-               reg_w(dev, 0xce, CE_sn9c325, 4);
+               reg_w(gspca_dev, 0xce, CE_sn9c325, 4);
                break;
        default:
-               reg_w(dev, 0xce, CE, 4);
+               reg_w(gspca_dev, 0xce, CE, 4);
                                        /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
                break;
        }
 
        /* here change size mode 0 -> VGA; 1 -> CIF */
        data = 0x40 | sn9c1xx[0x18] | (mode << 4);
-       reg_w(dev, 0x18, &data, 1);
+       reg_w(gspca_dev, 0x18, &data, 1);
 
-       reg_w(dev, 0x100, qtable4, 0x40);
-       reg_w(dev, 0x140, qtable4 + 0x40, 0x40);
+       reg_w(gspca_dev, 0x100, qtable4, 0x40);
+       reg_w(gspca_dev, 0x140, qtable4 + 0x40, 0x40);
 
        data = sn9c1xx[0x18] | (mode << 4);
-       reg_w(dev, 0x18, &data, 1);
+       reg_w(gspca_dev, 0x18, &data, 1);
 
-       reg_w(dev, 0x17, &reg17, 1);
-       reg_w(dev, 0x01, &reg1, 1);
+       reg_w(gspca_dev, 0x17, &reg17, 1);
+       reg_w(gspca_dev, 0x01, &reg1, 1);
        setbrightness(gspca_dev);
        setcontrast(gspca_dev);
 }
@@ -1333,7 +1323,6 @@ static void sd_start(struct gspca_dev *gspca_dev)
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        static const __u8 stophv7131[] =
                { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
        static const __u8 stopmi0360[] =
@@ -1345,11 +1334,11 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
        data = 0x0b;
        switch (sd->sensor) {
        case SENSOR_HV7131R:
-               i2c_w8(dev, stophv7131);
+               i2c_w8(gspca_dev, stophv7131);
                data = 0x2b;
                break;
        case SENSOR_MI0360:
-               i2c_w8(dev, stopmi0360);
+               i2c_w8(gspca_dev, stopmi0360);
                data = 0x29;
                break;
        case SENSOR_MO4000:
@@ -1362,12 +1351,12 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                break;
        }
        sn9c1xx = sn_tb[(int) sd->sensor];
-       reg_w(dev, 0x01, &sn9c1xx[1], 1);
-       reg_w(dev, 0x17, &sn9c1xx[0x17], 1);
-       reg_w(dev, 0x01, &sn9c1xx[1], 1);
-       reg_w(dev, 0x01, &data, 1);
+       reg_w(gspca_dev, 0x01, &sn9c1xx[1], 1);
+       reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 1);
+       reg_w(gspca_dev, 0x01, &sn9c1xx[1], 1);
+       reg_w(gspca_dev, 0x01, &data, 1);
        regF1 = 0x01;
-       reg_w(dev, 0xf1, &regF1, 1);
+       reg_w(gspca_dev, 0xf1, &regF1, 1);
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
@@ -1463,33 +1452,35 @@ static unsigned int getexposure(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        __u8 hexpo, mexpo, lexpo;
-       __u8 expo[6];
 
        switch (sd->sensor) {
        case SENSOR_HV7131R:
                /* read sensor exposure */
-               i2c_r5(gspca_dev, 0x25, expo);
-               return (expo[0] << 16) | (expo[1] << 8) | expo[2];
+               i2c_r5(gspca_dev, 0x25);
+               return (gspca_dev->usb_buf[0] << 16)
+                       | (gspca_dev->usb_buf[1] << 8)
+                       | gspca_dev->usb_buf[2];
        case SENSOR_MI0360:
                /* read sensor exposure */
-               i2c_r5(gspca_dev, 0x09, expo);
-               return (expo[0] << 8) | expo[1];
+               i2c_r5(gspca_dev, 0x09);
+               return (gspca_dev->usb_buf[0] << 8)
+                       | gspca_dev->usb_buf[1];
        case SENSOR_MO4000:
-               i2c_r5(gspca_dev, 0x0e, expo);
-               hexpo = 0;              /* expo[1] & 0x07; */
-               mexpo = 0x40;           /* expo[2] &0xff; */
-               lexpo = (expo[1] & 0x30) >> 4;
+               i2c_r5(gspca_dev, 0x0e);
+               hexpo = 0;              /* gspca_dev->usb_buf[1] & 0x07; */
+               mexpo = 0x40;           /* gspca_dev->usb_buf[2] & 0xff; */
+               lexpo = (gspca_dev->usb_buf[1] & 0x30) >> 4;
                PDEBUG(D_CONF, "exposure %d",
                        (hexpo << 10) | (mexpo << 2) | lexpo);
                return (hexpo << 10) | (mexpo << 2) | lexpo;
        default:
 /*     case SENSOR_OV7660: */
                /* read sensor exposure */
-               i2c_r5(gspca_dev, 0x04, expo);
-               hexpo = expo[3] & 0x2f;
-               lexpo = expo[0] & 0x02;
-               i2c_r5(gspca_dev, 0x08, expo);
-               mexpo = expo[2];
+               i2c_r5(gspca_dev, 0x04);
+               hexpo = gspca_dev->usb_buf[3] & 0x2f;
+               lexpo = gspca_dev->usb_buf[0] & 0x02;
+               i2c_r5(gspca_dev, 0x08);
+               mexpo = gspca_dev->usb_buf[2];
                return (hexpo << 10) | (mexpo << 2) | lexpo;
        }
 }
index d00f0f76e0e3cd1bd24559b917a7da598893e373..15620611879555a7797cd8c4675530ac0e77c4cb 100644 (file)
@@ -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/SPCA500 USB Camera Driver");
@@ -372,26 +372,27 @@ static const __u8 qtable_pocketdv[2][64] = {
         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28}
 };
 
-static void reg_r(struct usb_device *dev,
-                          __u16 index,
-                          __u8 *buffer, __u16 length)
+/* read 'len' bytes to gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 index,
+                 __u16 length)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,              /* value */
-                       index, buffer, length, 500);
+                       index, gspca_dev->usb_buf, length, 500);
 }
 
-static int reg_w(struct usb_device *dev,
+static int reg_w(struct gspca_dev *gspca_dev,
                     __u16 req, __u16 index, __u16 value)
 {
        int ret;
 
        PDEBUG(D_USBO, "reg write: [0x%02x] = 0x%02x", index, value);
-       ret = usb_control_msg(dev,
-                       usb_sndctrlpipe(dev, 0),
+       ret = usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        req,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        value, index, NULL, 0, 500);
@@ -401,28 +402,27 @@ static int reg_w(struct usb_device *dev,
 }
 
 /* returns: negative is error, pos or zero is data */
-static int reg_r_12(struct usb_device *dev,
+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);           /* timeout */
        if (ret < 0) {
                PDEBUG(D_ERR, "reg_r_12 err %d", ret);
                return -1;
        }
-       return (buf[1] << 8) + buf[0];
+       return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
 }
 
 /*
@@ -430,13 +430,13 @@ static int reg_r_12(struct usb_device *dev,
  * a reg_read call.
  * Returns: negative is error or timeout, zero is success.
  */
-static int reg_r_wait(struct usb_device *dev,
+static int reg_r_wait(struct gspca_dev *gspca_dev,
                        __u16 reg, __u16 index, __u16 value)
 {
        int ret, cnt = 20;
 
        while (--cnt > 0) {
-               ret = reg_r_12(dev, reg, index, 1);
+               ret = reg_r_12(gspca_dev, reg, index, 1);
                if (ret == value)
                        return 0;
                msleep(50);
@@ -447,11 +447,10 @@ static int reg_r_wait(struct usb_device *dev,
 static int write_vector(struct gspca_dev *gspca_dev,
                        const __u16 data[][3])
 {
-       struct usb_device *dev = gspca_dev->dev;
        int ret, i = 0;
 
        while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
-               ret = reg_w(dev, data[i][0], data[i][2], data[i][1]);
+               ret = reg_w(gspca_dev, data[i][0], data[i][2], data[i][1]);
                if (ret < 0)
                        return ret;
                i++;
@@ -465,19 +464,18 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
                                unsigned int cbase,
                                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(dev, request, ybase + i, qtable[0][i]);
+               err = reg_w(gspca_dev, request, ybase + i, qtable[0][i]);
                if (err < 0)
                        return err;
        }
 
        /* loop over c components */
        for (i = 0; i < 64; i++) {
-               err = reg_w(dev, request, cbase + i, qtable[1][i]);
+               err = reg_w(gspca_dev, request, cbase + i, qtable[1][i]);
                if (err < 0)
                        return err;
        }
@@ -486,37 +484,33 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
 
 static void spca500_ping310(struct gspca_dev *gspca_dev)
 {
-       __u8 Data[2];
-
-       reg_r(gspca_dev->dev, 0x0d04, Data, 2);
+       reg_r(gspca_dev, 0x0d04, 2);
        PDEBUG(D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x",
-               Data[0], Data[1]);
+               gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
 }
 
 static void spca500_clksmart310_init(struct gspca_dev *gspca_dev)
 {
-       __u8 Data[2];
-
-       reg_r(gspca_dev->dev, 0x0d05, Data, 2);
+       reg_r(gspca_dev, 0x0d05, 2);
        PDEBUG(D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x",
-               Data[0], Data[1]);
-       reg_w(gspca_dev->dev, 0x00, 0x8167, 0x5a);
+               gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
+       reg_w(gspca_dev, 0x00, 0x8167, 0x5a);
        spca500_ping310(gspca_dev);
 
-       reg_w(gspca_dev->dev, 0x00, 0x8168, 0x22);
-       reg_w(gspca_dev->dev, 0x00, 0x816a, 0xc0);
-       reg_w(gspca_dev->dev, 0x00, 0x816b, 0x0b);
-       reg_w(gspca_dev->dev, 0x00, 0x8169, 0x25);
-       reg_w(gspca_dev->dev, 0x00, 0x8157, 0x5b);
-       reg_w(gspca_dev->dev, 0x00, 0x8158, 0x5b);
-       reg_w(gspca_dev->dev, 0x00, 0x813f, 0x03);
-       reg_w(gspca_dev->dev, 0x00, 0x8151, 0x4a);
-       reg_w(gspca_dev->dev, 0x00, 0x8153, 0x78);
-       reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x04);
+       reg_w(gspca_dev, 0x00, 0x8168, 0x22);
+       reg_w(gspca_dev, 0x00, 0x816a, 0xc0);
+       reg_w(gspca_dev, 0x00, 0x816b, 0x0b);
+       reg_w(gspca_dev, 0x00, 0x8169, 0x25);
+       reg_w(gspca_dev, 0x00, 0x8157, 0x5b);
+       reg_w(gspca_dev, 0x00, 0x8158, 0x5b);
+       reg_w(gspca_dev, 0x00, 0x813f, 0x03);
+       reg_w(gspca_dev, 0x00, 0x8151, 0x4a);
+       reg_w(gspca_dev, 0x00, 0x8153, 0x78);
+       reg_w(gspca_dev, 0x00, 0x0d01, 0x04);
                                                /* 00 for adjust shutter */
-       reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01);
-       reg_w(gspca_dev->dev, 0x00, 0x8169, 0x25);
-       reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x02);
+       reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
+       reg_w(gspca_dev, 0x00, 0x8169, 0x25);
+       reg_w(gspca_dev, 0x00, 0x0d01, 0x02);
 }
 
 static void spca500_setmode(struct gspca_dev *gspca_dev,
@@ -525,14 +519,14 @@ static void spca500_setmode(struct gspca_dev *gspca_dev,
        int mode;
 
        /* set x multiplier */
-       reg_w(gspca_dev->dev, 0, 0x8001, xmult);
+       reg_w(gspca_dev, 0, 0x8001, xmult);
 
        /* set y multiplier */
-       reg_w(gspca_dev->dev, 0, 0x8002, ymult);
+       reg_w(gspca_dev, 0, 0x8002, ymult);
 
        /* use compressed mode, VGA, with mode specific subsample */
        mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
-       reg_w(gspca_dev->dev, 0, 0x8003, mode << 4);
+       reg_w(gspca_dev, 0, 0x8003, mode << 4);
 }
 
 static int spca500_full_reset(struct gspca_dev *gspca_dev)
@@ -540,18 +534,18 @@ static int spca500_full_reset(struct gspca_dev *gspca_dev)
        int err;
 
        /* send the reset command */
-       err = reg_w(gspca_dev->dev, 0xe0, 0x0001, 0x0000);
+       err = reg_w(gspca_dev, 0xe0, 0x0001, 0x0000);
        if (err < 0)
                return err;
 
        /* wait for the reset to complete */
-       err = reg_r_wait(gspca_dev->dev, 0x06, 0x0000, 0x0000);
+       err = reg_r_wait(gspca_dev, 0x06, 0x0000, 0x0000);
        if (err < 0)
                return err;
-       err = reg_w(gspca_dev->dev, 0xe0, 0x0000, 0x0000);
+       err = reg_w(gspca_dev, 0xe0, 0x0000, 0x0000);
        if (err < 0)
                return err;
-       err = reg_r_wait(gspca_dev->dev, 0x06, 0, 0);
+       err = reg_r_wait(gspca_dev, 0x06, 0, 0);
        if (err < 0) {
                PDEBUG(D_ERR, "reg_r_wait() failed");
                return err;
@@ -568,15 +562,13 @@ static int spca500_full_reset(struct gspca_dev *gspca_dev)
 /* up-port the same feature as in 2.4.x kernel */
 static int spca500_synch310(struct gspca_dev *gspca_dev)
 {
-       __u8 Data;
-
        if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0) < 0) {
                PDEBUG(D_ERR, "Set packet size: set interface error");
                goto error;
        }
        spca500_ping310(gspca_dev);
 
-       reg_r(gspca_dev->dev, 0x0d00, &Data, 1);
+       reg_r(gspca_dev, 0x0d00, 1);
 
        /* need alt setting here */
        PDEBUG(D_PACK, "ClickSmart310 sync alt: %d", gspca_dev->alt);
@@ -600,12 +592,12 @@ static void spca500_reinit(struct gspca_dev *gspca_dev)
 
        /* some unknow command from Aiptek pocket dv and family300 */
 
-       reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01);
-       reg_w(gspca_dev->dev, 0x00, 0x0d03, 0x00);
-       reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01);
+       reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
+       reg_w(gspca_dev, 0x00, 0x0d03, 0x00);
+       reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
 
        /* enable drop packet */
-       reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+       reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 
        err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840,
                                 qtable_pocketdv);
@@ -613,22 +605,23 @@ static void spca500_reinit(struct gspca_dev *gspca_dev)
                PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed on init");
 
        /* set qtable index */
-       reg_w(gspca_dev->dev, 0x00, 0x8880, 2);
+       reg_w(gspca_dev, 0x00, 0x8880, 2);
        /* family cam Quicksmart stuff */
-       reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
+       reg_w(gspca_dev, 0x00, 0x800a, 0x00);
        /* Set agc transfer: synced inbetween frames */
-       reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01);
+       reg_w(gspca_dev, 0x00, 0x820f, 0x01);
        /* Init SDRAM - needed for SDRAM access */
-       reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
+       reg_w(gspca_dev, 0x00, 0x870a, 0x04);
        /*Start init sequence or stream */
-
-       reg_w(gspca_dev->dev, 0, 0x8003, 0x00);
+       reg_w(gspca_dev, 0, 0x8003, 0x00);
        /* switch to video camera mode */
-       reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+       reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
        msleep(2000);
-       if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-       reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+       if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) {
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
+       }
 }
 
 /* this function is called at probe time */
@@ -785,9 +778,10 @@ static void sd_start(struct gspca_dev *gspca_dev)
        }
 
        /* is there a sensor here ? */
-       reg_r(gspca_dev->dev, 0x8a04, &Data, 1);
-       PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02X", Data);
-       PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02X, Ymult: 0x%02X",
+       reg_r(gspca_dev, 0x8a04, 1);
+       PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02x",
+               gspca_dev->usb_buf[0]);
+       PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x",
                gspca_dev->curr_mode, xmult, ymult);
 
        /* setup qtable */
@@ -796,33 +790,34 @@ static void sd_start(struct gspca_dev *gspca_dev)
                 spca500_setmode(gspca_dev, xmult, ymult);
 
                /* enable drop packet */
-               reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
+               reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
+               reg_w(gspca_dev, 0x00, 0x8880, 3);
                err = spca50x_setup_qtable(gspca_dev,
                                           0x00, 0x8800, 0x8840,
                                           qtable_creative_pccam);
                if (err < 0)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
                /* Init SDRAM - needed for SDRAM access */
-               reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
+               reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
                msleep(500);
-               if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+               if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
                        PDEBUG(D_ERR, "reg_r_wait() failed");
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
 
                spca500_synch310(gspca_dev);
 
                write_vector(gspca_dev, spca500_visual_defaults);
                spca500_setmode(gspca_dev, xmult, ymult);
                /* enable drop packet */
-               reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+               reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
                        PDEBUG(D_ERR, "failed to enable drop packet");
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
+               reg_w(gspca_dev, 0x00, 0x8880, 3);
                err = spca50x_setup_qtable(gspca_dev,
                                           0x00, 0x8800, 0x8840,
                                           qtable_creative_pccam);
@@ -830,16 +825,17 @@ static void sd_start(struct gspca_dev *gspca_dev)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 
                /* Init SDRAM - needed for SDRAM access */
-               reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
+               reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 
-               if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+               if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
                        PDEBUG(D_ERR, "reg_r_wait() failed");
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
                break;
        case CreativePCCam300:          /* Creative PC-CAM 300 640x480 CCD */
        case IntelPocketPCCamera:       /* FIXME: Temporary fix for
@@ -852,10 +848,10 @@ static void sd_start(struct gspca_dev *gspca_dev)
                        PDEBUG(D_ERR, "spca500_full_reset failed");
 
                /* enable drop packet */
-               err = reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+               err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
                if (err < 0)
                        PDEBUG(D_ERR, "failed to enable drop packet");
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
+               reg_w(gspca_dev, 0x00, 0x8880, 3);
                err = spca50x_setup_qtable(gspca_dev,
                                           0x00, 0x8800, 0x8840,
                                           qtable_creative_pccam);
@@ -863,16 +859,17 @@ static void sd_start(struct gspca_dev *gspca_dev)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
 
                spca500_setmode(gspca_dev, xmult, ymult);
-               reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004);
+               reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 
-               if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+               if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
                        PDEBUG(D_ERR, "reg_r_wait() failed");
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
 
 /*             write_vector(gspca_dev, spca500_visual_defaults); */
                break;
@@ -883,8 +880,8 @@ static void sd_start(struct gspca_dev *gspca_dev)
                if (err < 0)
                        PDEBUG(D_ERR, "spca500_full_reset failed");
                /* enable drop packet */
-               reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 0);
+               reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
+               reg_w(gspca_dev, 0x00, 0x8880, 0);
                err = spca50x_setup_qtable(gspca_dev,
                                           0x00, 0x8800, 0x8840,
                                           qtable_kodak_ez200);
@@ -892,16 +889,17 @@ static void sd_start(struct gspca_dev *gspca_dev)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
                spca500_setmode(gspca_dev, xmult, ymult);
 
-               reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004);
+               reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
 
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 
-               if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+               if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
                        PDEBUG(D_ERR, "reg_r_wait() failed");
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
 
 /*             write_vector(gspca_dev, spca500_visual_defaults); */
                break;
@@ -916,56 +914,58 @@ static void sd_start(struct gspca_dev *gspca_dev)
        case ToptroIndus:
        case AgfaCl20:
                spca500_reinit(gspca_dev);
-               reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01);
+               reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
                /* enable drop packet */
-               reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+               reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 
                err = spca50x_setup_qtable(gspca_dev,
                                   0x00, 0x8800, 0x8840, qtable_pocketdv);
                if (err < 0)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 2);
+               reg_w(gspca_dev, 0x00, 0x8880, 2);
 
                /* familycam Quicksmart pocketDV stuff */
-               reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
+               reg_w(gspca_dev, 0x00, 0x800a, 0x00);
                /* Set agc transfer: synced inbetween frames */
-               reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01);
+               reg_w(gspca_dev, 0x00, 0x820f, 0x01);
                /* Init SDRAM - needed for SDRAM access */
-               reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
+               reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 
                spca500_setmode(gspca_dev, xmult, ymult);
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
 
-               reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44);
+               reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
                break;
        case LogitechTraveler:
        case LogitechClickSmart510:
-               reg_w(gspca_dev->dev, 0x02, 0x00, 0x00);
+               reg_w(gspca_dev, 0x02, 0x00, 0x00);
                /* enable drop packet */
-               reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+               reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
 
                err = spca50x_setup_qtable(gspca_dev,
                                        0x00, 0x8800,
                                        0x8840, qtable_creative_pccam);
                if (err < 0)
                        PDEBUG(D_ERR, "spca50x_setup_qtable failed");
-               reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
-               reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
+               reg_w(gspca_dev, 0x00, 0x8880, 3);
+               reg_w(gspca_dev, 0x00, 0x800a, 0x00);
                /* Init SDRAM - needed for SDRAM access */
-               reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
+               reg_w(gspca_dev, 0x00, 0x870a, 0x04);
 
                spca500_setmode(gspca_dev, xmult, ymult);
 
                /* switch to video camera mode */
-               reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
-               reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44);
+               reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
+               reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
 
-               reg_r(gspca_dev->dev, 0x816b, &Data, 1);
-               reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
+               reg_r(gspca_dev, 0x816b, 1);
+               Data = gspca_dev->usb_buf[0];
+               reg_w(gspca_dev, 0x00, 0x816b, Data);
                write_vector(gspca_dev, Clicksmart510_defaults);
                break;
        }
@@ -973,14 +973,13 @@ static void sd_start(struct gspca_dev *gspca_dev)
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-       __u8 data;
-
-       reg_w(gspca_dev->dev, 0, 0x8003, 0x00);
+       reg_w(gspca_dev, 0, 0x8003, 0x00);
 
        /* switch to video camera mode */
-       reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
-       reg_r(gspca_dev->dev, 0x8000, &data, 1);
-       PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x", data);
+       reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
+       reg_r(gspca_dev, 0x8000, 1);
+       PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x",
+               gspca_dev->usb_buf[0]);
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
@@ -1043,7 +1042,7 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       reg_w(gspca_dev->dev, 0x00, 0x8167,
+       reg_w(gspca_dev, 0x00, 0x8167,
                        (__u8) (sd->brightness - 128));
 }
 
@@ -1052,7 +1051,7 @@ static void getbrightness(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;
 
-       ret = reg_r_12(gspca_dev->dev, 0x00, 0x8167, 1);
+       ret = reg_r_12(gspca_dev, 0x00, 0x8167, 1);
        if (ret >= 0)
                sd->brightness = ret + 128;
 }
@@ -1061,7 +1060,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       reg_w(gspca_dev->dev, 0x00, 0x8168, sd->contrast);
+       reg_w(gspca_dev, 0x00, 0x8168, sd->contrast);
 }
 
 static void getcontrast(struct gspca_dev *gspca_dev)
@@ -1069,7 +1068,7 @@ static void getcontrast(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;
 
-       ret = reg_r_12(gspca_dev->dev, 0x0, 0x8168, 1);
+       ret = reg_r_12(gspca_dev, 0x0, 0x8168, 1);
        if (ret >= 0)
                sd->contrast = ret;
 }
@@ -1078,7 +1077,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       reg_w(gspca_dev->dev, 0x00, 0x8169, sd->colors);
+       reg_w(gspca_dev, 0x00, 0x8169, sd->colors);
 }
 
 static void getcolors(struct gspca_dev *gspca_dev)
@@ -1086,7 +1085,7 @@ static void getcolors(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;
 
-       ret = reg_r_12(gspca_dev->dev, 0x0, 0x8169, 1);
+       ret = reg_r_12(gspca_dev, 0x0, 0x8169, 1);
        if (ret >= 0)
                sd->colors = ret;
 }
index 2064dc008af113327fce8f1f3171f4be9ed112fd..8cee6748d38fa01fc882bf8cd05bc69542d29f8f 100644 (file)
@@ -23,8 +23,8 @@
 
 #include "gspca.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/SPCA501 USB Camera Driver");
@@ -1826,28 +1826,27 @@ static int reg_write(struct usb_device *dev,
 }
 
 /* returns: negative is error, pos or zero is data */
-static int reg_read(struct usb_device *dev,
+static int reg_read(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);                   /* timeout */
        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,
@@ -1883,7 +1882,7 @@ static void getbrightness(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        __u16 brightness;
 
-       brightness = reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x11, 2);
+       brightness = reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x11, 2);
        sd->brightness = brightness << 1;
 }
 
@@ -1913,8 +1912,8 @@ static void getcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       sd->colors = reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x0c, 2);
-/*     sd->hue = (reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x13, */
+       sd->colors = reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x0c, 2);
+/*     sd->hue = (reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x13, */
 /*                     2) & 0xFF) << 8; */
 }
 
index 5d28d23b8375007f7e648ac904f2eb2beee8afb0..ddea6e140aa833bbc1d7b7167da0354828834406 100644 (file)
@@ -23,8 +23,8 @@
 
 #include "gspca.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/SPCA505 USB Camera Driver");
@@ -593,29 +593,27 @@ static int reg_write(struct usb_device *dev,
 }
 
 /* returns: negative is error, pos or zero is data */
-static int reg_read(struct usb_device *dev,
+static int reg_read(struct gspca_dev *gspca_dev,
                        __u16 reg,      /* bRequest */
                        __u16 index,    /* wIndex */
                        __u16 length)   /* wLength (1 or 2 only) */
 {
        int ret;
-       __u8 buf[4];
 
-       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),
                        reg,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        (__u16) 0,              /* value */
                        (__u16) index,
-                       buf,
-                       length,
+                       gspca_dev->usb_buf, length,
                        500);                   /* timeout */
        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,
@@ -697,7 +695,7 @@ static int sd_open(struct gspca_dev *gspca_dev)
                write_vector(gspca_dev, spca505b_open_data_ccd);
        else
                write_vector(gspca_dev, spca505_open_data_ccd);
-       ret = reg_read(gspca_dev->dev, 6, 0x16, 2);
+       ret = reg_read(gspca_dev, 6, 0x16, 2);
 
        if (ret < 0) {
                PDEBUG(D_ERR|D_STREAM,
@@ -874,8 +872,8 @@ static void getbrightness(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
 
        sd->brightness = 255
-               - ((reg_read(gspca_dev->dev, 5, 0x01, 1) >> 2)
-                       + (reg_read(gspca_dev->dev, 5, 0x0, 1) << 6));
+               - ((reg_read(gspca_dev, 5, 0x01, 1) >> 2)
+                       + (reg_read(gspca_dev, 5, 0x0, 1) << 6));
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
index 2d249b00bdcd6c3e49145bc0483bcbb118c09b95..143203c1fd9fbf92772f26714321e31ce8097561 100644 (file)
@@ -25,8 +25,8 @@
 
 #include "gspca.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/SPCA506 USB Camera Driver");
@@ -153,17 +153,18 @@ static struct v4l2_pix_format vga_mode[] = {
 #define SAA7113_hue 0x0d       /* defaults 0x00 */
 #define SAA7113_I2C_BASE_WRITE 0x4a
 
-static void reg_r(struct usb_device *dev,
+/* read 'len' bytes to gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
                  __u16 req,
                  __u16 index,
-                 __u8 *buffer, __u16 length)
+                 __u16 length)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       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, buffer, length,
+                       index, gspca_dev->usb_buf, length,
                        500);
 }
 
@@ -189,13 +190,12 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur,
                             __u16 reg)
 {
        int retry = 60;
-       __u8 Data[2];
 
        reg_w(gspca_dev->dev, 0x07, reg, 0x0001);
        reg_w(gspca_dev->dev, 0x07, valeur, 0x0000);
        while (retry--) {
-               reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2);
-               if ((Data[0] | Data[1]) == 0x00)
+               reg_r(gspca_dev, 0x07, 0x0003, 2);
+               if ((gspca_dev->usb_buf[0] | gspca_dev->usb_buf[1]) == 0x00)
                        break;
        }
 }
@@ -203,21 +203,19 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur,
 static int spca506_ReadI2c(struct gspca_dev *gspca_dev, __u16 reg)
 {
        int retry = 60;
-       __u8 Data[2];
-       __u8 value;
 
        reg_w(gspca_dev->dev, 0x07, SAA7113_I2C_BASE_WRITE, 0x0004);
        reg_w(gspca_dev->dev, 0x07, reg, 0x0001);
        reg_w(gspca_dev->dev, 0x07, 0x01, 0x0002);
        while (--retry) {
-               reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2);
-               if ((Data[0] | Data[1]) == 0x00)
+               reg_r(gspca_dev, 0x07, 0x0003, 2);
+               if ((gspca_dev->usb_buf[0] | gspca_dev->usb_buf[1]) == 0x00)
                        break;
        }
        if (retry == 0)
                return -1;
-       reg_r(gspca_dev->dev, 0x07, 0x0000, &value, 1);
-       return value;
+       reg_r(gspca_dev, 0x07, 0x0000, 1);
+       return gspca_dev->usb_buf[0];
 }
 
 static void spca506_SetNormeInput(struct gspca_dev *gspca_dev,
@@ -437,7 +435,6 @@ static void sd_start(struct gspca_dev *gspca_dev)
        struct usb_device *dev = gspca_dev->dev;
        __u16 norme;
        __u16 channel;
-       __u8 Data[2];
 
        /**************************************/
        reg_w(dev, 0x03, 0x00, 0x0004);
@@ -555,8 +552,8 @@ static void sd_start(struct gspca_dev *gspca_dev)
        /* compress setting and size */
        /* set i2c luma */
        reg_w(dev, 0x02, 0x01, 0x0000);
-       reg_w(dev, 0x03, 0x12, 0x000);
-       reg_r(dev, 0x04, 0x0001, Data, 2);
+       reg_w(dev, 0x03, 0x12, 0x0000);
+       reg_r(gspca_dev, 0x04, 0x0001, 2);
        PDEBUG(D_STREAM, "webcam started");
        spca506_GetNormeInput(gspca_dev, &norme, &channel);
        spca506_SetNormeInput(gspca_dev, norme, channel);
index 7f262f23841e87cdfce11c6cb48b300184162705..d8cd93866a4a6c6b9aec8f73c844ceca0420eceb 100644 (file)
@@ -22,8 +22,8 @@
 
 #include "gspca.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/SPCA508 USB Camera Driver");
@@ -1433,26 +1433,26 @@ static int reg_write(struct usb_device *dev,
 
 /* read 1 byte */
 /* returns: negative is error, pos or zero is data */
-static int reg_read(struct usb_device *dev,
+static int reg_read(struct gspca_dev *gspca_dev,
                        __u16 index)    /* wIndex */
 {
        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),
                        0,                      /* register */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                       (__u16) 0,              /* value */
+                       0,              /* value */
                        index,
-                       &data, 1,
+                       gspca_dev->usb_buf, 1,
                        500);                   /* timeout */
-       PDEBUG(D_USBI, "reg read i:%04x --> %02x", index, data);
+       PDEBUG(D_USBI, "reg read i:%04x --> %02x",
+               index, gspca_dev->usb_buf[0]);
        if (ret < 0) {
                PDEBUG(D_ERR|D_USBI, "reg_read err %d", ret);
                return ret;
        }
-       return data;
+       return gspca_dev->usb_buf[0];
 }
 
 static int write_vector(struct gspca_dev *gspca_dev,
@@ -1475,15 +1475,12 @@ static int sd_config(struct gspca_dev *gspca_dev,
                        const struct usb_device_id *id)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        struct cam *cam;
-       __u16 vendor;
        __u16 product;
        int data1, data2;
 
-       vendor = id->idVendor;
        product = id->idProduct;
-       switch (vendor) {
+       switch (id->idVendor) {
        case 0x0130:            /* Clone webcam */
 /*             switch (product) { */
 /*             case 0x0130: */
@@ -1535,15 +1532,15 @@ static int sd_config(struct gspca_dev *gspca_dev,
         * prove that we can communicate with the device.  This works, which
         * confirms at we are communicating properly and that the device
         * is a 508. */
-       data1 = reg_read(dev, 0x8104);
-       data2 = reg_read(dev, 0x8105);
+       data1 = reg_read(gspca_dev, 0x8104);
+       data2 = reg_read(gspca_dev, 0x8105);
        PDEBUG(D_PROBE, "Webcam Vendor ID: 0x%02x%02x", data2, data1);
 
-       data1 = reg_read(dev, 0x8106);
-       data2 = reg_read(dev, 0x8107);
+       data1 = reg_read(gspca_dev, 0x8106);
+       data2 = reg_read(gspca_dev, 0x8107);
        PDEBUG(D_PROBE, "Webcam Product ID: 0x%02x%02x", data2, data1);
 
-       data1 = reg_read(dev, 0x8621);
+       data1 = reg_read(gspca_dev, 0x8621);
        PDEBUG(D_PROBE, "Window 1 average luminance: %d", data1);
 
        cam = &gspca_dev->cam;
@@ -1711,7 +1708,7 @@ static void getbrightness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
-       sd->brightness = reg_read(gspca_dev->dev, 0x8651);
+       sd->brightness = reg_read(gspca_dev, 0x8651);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
index f0770ee595d8d866d642c9622b53bf40f18cf9be..b659bd0f788da4d86afbbf2b21787ab443756637 100644 (file)
@@ -24,8 +24,8 @@
 
 #include "gspca.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/SPCA561 USB Camera Driver");
@@ -177,27 +177,28 @@ static void write_vector(struct gspca_dev *gspca_dev,
        }
 }
 
-static void reg_r(struct usb_device *dev,
-                 __u16 index, __u8 *buffer, __u16 length)
+/* read 'len' bytes to gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 index, __u16 length)
 {
-       usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,                      /* request */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,                      /* value */
-                       index, buffer, length, 500);
+                       index, gspca_dev->usb_buf, length, 500);
 }
 
-static void reg_w_buf(struct usb_device *dev,
+static void reg_w_buf(struct gspca_dev *gspca_dev,
                      __u16 index, const __u8 *buffer, __u16 len)
 {
-       __u8 tmpbuf[8];
-
-       memcpy(tmpbuf, buffer, len);
-       usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+       memcpy(gspca_dev->usb_buf, buffer, len);
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        0,                      /* request */
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,                      /* value */
-                       index, tmpbuf, len, 500);
+                       index, gspca_dev->usb_buf, len, 500);
 }
 
 static void i2c_init(struct gspca_dev *gspca_dev, __u8 mode)
@@ -211,7 +212,6 @@ static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg)
        int retry = 60;
        __u8 DataLow;
        __u8 DataHight;
-       __u8 Data;
 
        DataLow = valeur;
        DataHight = valeur >> 8;
@@ -219,8 +219,8 @@ static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg)
        reg_w_val(gspca_dev->dev, DataLow, 0x8805);
        reg_w_val(gspca_dev->dev, DataHight, 0x8800);
        while (retry--) {
-               reg_r(gspca_dev->dev, 0x8803, &Data, 1);
-               if (!Data)
+               reg_r(gspca_dev, 0x8803, 1);
+               if (!gspca_dev->usb_buf[0])
                        break;
        }
 }
@@ -230,20 +230,21 @@ static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
        int retry = 60;
        __u8 value;
        __u8 vallsb;
-       __u8 Data;
 
        reg_w_val(gspca_dev->dev, 0x92, 0x8804);
        reg_w_val(gspca_dev->dev, reg, 0x8801);
        reg_w_val(gspca_dev->dev, (mode | 0x01), 0x8802);
        while (retry--) {
-               reg_r(gspca_dev->dev, 0x8803, &Data, 1);
-               if (!Data)
+               reg_r(gspca_dev, 0x8803, 1);
+               if (!gspca_dev->usb_buf)
                        break;
        }
        if (retry == 0)
                return -1;
-       reg_r(gspca_dev->dev, 0x8800, &value, 1);
-       reg_r(gspca_dev->dev, 0x8805, &vallsb, 1);
+       reg_r(gspca_dev, 0x8800, 1);
+       value = gspca_dev->usb_buf[0];
+       reg_r(gspca_dev, 0x8805, 1);
+       vallsb = gspca_dev->usb_buf[0];
        return ((int) value << 8) | vallsb;
 }
 
@@ -541,7 +542,7 @@ static void sensor_mapwrite(struct gspca_dev *gspca_dev,
        while (sensormap[i][0]) {
                usbval[0] = sensormap[i][1];
                usbval[1] = sensormap[i][1] >> 8;
-               reg_w_buf(gspca_dev->dev, sensormap[i][0], usbval, 2);
+               reg_w_buf(gspca_dev, sensormap[i][0], usbval, 2);
                i++;
        }
 }
@@ -559,7 +560,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
                     const struct usb_device_id *id)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        struct cam *cam;
        __u16 vendor, product;
        __u8 data1, data2;
@@ -568,11 +568,15 @@ static int sd_config(struct gspca_dev *gspca_dev,
         * prove that we can communicate with the device.  This works, which
         * confirms at we are communicating properly and that the device
         * is a 561. */
-       reg_r(dev, 0x8104, &data1, 1);
-       reg_r(dev, 0x8105, &data2, 1);
+       reg_r(gspca_dev, 0x8104, 1);
+       data1 = gspca_dev->usb_buf[0];
+       reg_r(gspca_dev, 0x8105, 1);
+       data2 = gspca_dev->usb_buf[0];
        vendor = (data2 << 8) | data1;
-       reg_r(dev, 0x8106, &data1, 1);
-       reg_r(dev, 0x8107, &data2, 1);
+       reg_r(gspca_dev, 0x8106, 1);
+       data1 = gspca_dev->usb_buf[0];
+       reg_r(gspca_dev, 0x8107, 1);
+       data2 = gspca_dev->usb_buf[0];
        product = (data2 << 8) | data1;
        if (vendor != id->idVendor || product != id->idProduct) {
                PDEBUG(D_PROBE, "Bad vendor / product from device");
@@ -656,8 +660,8 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                Reg8391[0] = expotimes & 0xff;  /* exposure */
                Reg8391[1] = 0x18 | (expotimes >> 8);
                Reg8391[2] = sd->brightness;    /* gain */
-               reg_w_buf(dev, 0x8391, Reg8391, 8);
-               reg_w_buf(dev, 0x8390, Reg8391, 8);
+               reg_w_buf(gspca_dev, 0x8391, Reg8391, 8);
+               reg_w_buf(gspca_dev, 0x8390, Reg8391, 8);
                break;
            }
        }
@@ -714,10 +718,11 @@ static void sd_start(struct gspca_dev *gspca_dev)
                         * is sufficient to push raw frames at ~20fps */
                        reg_w_val(dev, 0x8500, mode);
                }               /* -- qq@kuku.eu.org */
-               reg_w_buf(dev, 0x8307, Reg8307, 2);
-               reg_w_val(dev, 0x8700, Clck);   /* 0x8f 0x85 0x27 clock */
-               reg_w_val(dev, 0x8112, 0x1e | 0x20);
-               reg_w_val(dev, 0x850b, 0x03);
+               reg_w_buf(gspca_dev, 0x8307, Reg8307, 2);
+               reg_w_val(gspca_dev->dev, 0x8700, Clck);
+                                               /* 0x8f 0x85 0x27 clock */
+               reg_w_val(gspca_dev->dev, 0x8112, 0x1e | 0x20);
+               reg_w_val(gspca_dev->dev, 0x850b, 0x03);
                setcontrast(gspca_dev);
                break;
        }
@@ -752,10 +757,14 @@ static void setautogain(struct gspca_dev *gspca_dev)
 
        switch (sd->chip_revision) {
        case Rev072A:
-               reg_r(gspca_dev->dev, 0x8621, &Gr, 1);
-               reg_r(gspca_dev->dev, 0x8622, &R, 1);
-               reg_r(gspca_dev->dev, 0x8623, &B, 1);
-               reg_r(gspca_dev->dev, 0x8624, &Gb, 1);
+               reg_r(gspca_dev, 0x8621, 1);
+               Gr = gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8622, 1);
+               R = gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8623, 1);
+               B = gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8624, 1);
+               Gb = gspca_dev->usb_buf[0];
                y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
                /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
                /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
@@ -867,20 +876,19 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 static void getbrightness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 value;
        __u16 tot;
 
        switch (sd->chip_revision) {
        case Rev072A:
                tot = 0;
-               reg_r(gspca_dev->dev, 0x8611, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8612, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8613, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8614, &value, 1);
-               tot += value;
+               reg_r(gspca_dev, 0x8611, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8612, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8613, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8614, 1);
+               tot += gspca_dev->usb_buf[0];
                sd->brightness = tot >> 2;
                break;
        default:
@@ -893,20 +901,19 @@ static void getbrightness(struct gspca_dev *gspca_dev)
 static void getcontrast(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 value;
        __u16 tot;
 
        switch (sd->chip_revision) {
        case Rev072A:
                tot = 0;
-               reg_r(gspca_dev->dev, 0x8651, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8652, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8653, &value, 1);
-               tot += value;
-               reg_r(gspca_dev->dev, 0x8654, &value, 1);
-               tot += value;
+               reg_r(gspca_dev, 0x8651, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8652, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8653, 1);
+               tot += gspca_dev->usb_buf[0];
+               reg_r(gspca_dev, 0x8654, 1);
+               tot += gspca_dev->usb_buf[0];
                sd->contrast = tot << 6;
                break;
        default:
index d676cd16aa74d67c7802860fb648e94ff0daac21..c78ee0d3e59bface920e16ac31539af824d839b1 100644 (file)
@@ -23,8 +23,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("Jean-Francois Moine <http://moinejf.free.fr>");
 MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
@@ -127,7 +127,7 @@ static struct v4l2_pix_format vga_mode[] = {
 
 /* -- read a register -- */
 static int reg_r(struct gspca_dev *gspca_dev,
-                       __u16 index, __u8 *buf)
+                       __u16 index)
 {
        struct usb_device *dev = gspca_dev->dev;
        int ret;
@@ -137,11 +137,13 @@ static int reg_r(struct gspca_dev *gspca_dev,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0x00,
                        index,
-                       buf, 1,
+                       gspca_dev->usb_buf, 1,
                        500);
-       if (ret < 0)
+       if (ret < 0) {
                PDEBUG(D_ERR, "reg_r err %d", ret);
-       return ret;
+               return ret;
+       }
+       return gspca_dev->usb_buf[0];
 }
 
 /* -- write a register -- */
@@ -164,58 +166,55 @@ static int reg_w(struct gspca_dev *gspca_dev,
        return ret;
 }
 
-/* -- get a value -- */
+/* -- get a bulk value (4 bytes) -- */
 static int rcv_val(struct gspca_dev *gspca_dev,
-                       int ads,
-                       int len)
+                       int ads)
 {
        struct usb_device *dev = gspca_dev->dev;
        int alen, ret;
-       unsigned char bulk_buf[4];
 
        reg_w(gspca_dev, 0x634, (ads >> 16) & 0xff);
        reg_w(gspca_dev, 0x635, (ads >> 8) & 0xff);
        reg_w(gspca_dev, 0x636, ads & 0xff);
        reg_w(gspca_dev, 0x637, 0);
-       reg_w(gspca_dev, 0x638, len & 0xff);
-       reg_w(gspca_dev, 0x639, len >> 8);
+       reg_w(gspca_dev, 0x638, 4);     /* len & 0xff */
+       reg_w(gspca_dev, 0x639, 0);     /* len >> 8 */
        reg_w(gspca_dev, 0x63a, 0);
        reg_w(gspca_dev, 0x63b, 0);
        reg_w(gspca_dev, 0x630, 5);
-       if (len > sizeof bulk_buf)
-               return -1;
        ret = usb_bulk_msg(dev,
                        usb_rcvbulkpipe(dev, 5),
-                       bulk_buf,
-                       len,
+                       gspca_dev->usb_buf,
+                       4,              /* length */
                        &alen,
-                       500);   /* timeout in milliseconds */
+                       500);           /* timeout in milliseconds */
        return ret;
 }
 
-/* -- send a value -- */
+/* -- send a bulk value -- */
 static int snd_val(struct gspca_dev *gspca_dev,
                        int ads,
                        unsigned int val)
 {
        struct usb_device *dev = gspca_dev->dev;
        int alen, ret;
-       __u8 value, seq;
-       unsigned char bulk_buf[4];
+       __u8 seq = 0;
 
        if (ads == 0x003f08) {
-               ret = reg_r(gspca_dev, 0x0704, &value);
+               ret = reg_r(gspca_dev, 0x0704);
                if (ret < 0)
                        goto ko;
-               ret = reg_r(gspca_dev, 0x0705, &seq);
+               ret = reg_r(gspca_dev, 0x0705);
                if (ret < 0)
                        goto ko;
-               ret = reg_r(gspca_dev, 0x0650, &value);
+               seq = ret;              /* keep the sequence number */
+               ret = reg_r(gspca_dev, 0x0650);
                if (ret < 0)
                        goto ko;
                reg_w(gspca_dev, 0x654, seq);
-       } else
+       } else {
                reg_w(gspca_dev, 0x654, (ads >> 16) & 0xff);
+       }
        reg_w(gspca_dev, 0x655, (ads >> 8) & 0xff);
        reg_w(gspca_dev, 0x656, ads & 0xff);
        reg_w(gspca_dev, 0x657, 0);
@@ -224,13 +223,13 @@ static int snd_val(struct gspca_dev *gspca_dev,
        reg_w(gspca_dev, 0x65a, 0);
        reg_w(gspca_dev, 0x65b, 0);
        reg_w(gspca_dev, 0x650, 5);
-       bulk_buf[0] = (val >> 24) & 0xff;
-       bulk_buf[1] = (val >> 16) & 0xff;
-       bulk_buf[2] = (val >> 8) & 0xff;
-       bulk_buf[3] = val & 0xff;
+       gspca_dev->usb_buf[0] = val >> 24;
+       gspca_dev->usb_buf[1] = val >> 16;
+       gspca_dev->usb_buf[2] = val >> 8;
+       gspca_dev->usb_buf[3] = val;
        ret = usb_bulk_msg(dev,
                        usb_sndbulkpipe(dev, 6),
-                       bulk_buf,
+                       gspca_dev->usb_buf,
                        4,
                        &alen,
                        500);   /* timeout in milliseconds */
@@ -303,7 +302,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
        cam->dev_name = (char *) id->driver_info;
        cam->epaddr = 0x02;
        gspca_dev->cam.cam_mode = vga_mode;
-       gspca_dev->cam.nmodes = sizeof vga_mode / sizeof vga_mode[0];
+       gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
        sd->brightness = BRIGHTNESS_DEF;
        sd->contrast = CONTRAST_DEF;
        sd->colors = COLOR_DEF;
@@ -314,16 +313,15 @@ static int sd_config(struct gspca_dev *gspca_dev,
 /* this function is called at open time */
 static int sd_open(struct gspca_dev *gspca_dev)
 {
-       __u8 value;
        int ret;
 
        /* check if the device responds */
        usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
-       ret = reg_r(gspca_dev, 0x0740, &value);
+       ret = reg_r(gspca_dev, 0x0740);
        if (ret < 0)
                return ret;
-       if (value != 0xff) {
-               PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", value);
+       if (ret != 0xff) {
+               PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", ret);
                return -1;
        }
        return 0;
@@ -332,7 +330,6 @@ static int sd_open(struct gspca_dev *gspca_dev)
 /* -- start the camera -- */
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-       __u8 dum;
        int ret, value;
 
        /* work on alternate 1 */
@@ -355,11 +352,11 @@ static void sd_start(struct gspca_dev *gspca_dev)
                        gspca_dev->iface, gspca_dev->alt);
                goto out;
        }
-       ret = reg_r(gspca_dev, 0x0630, &dum);
+       ret = reg_r(gspca_dev, 0x0630);
        if (ret < 0)
                goto out;
-       rcv_val(gspca_dev, 0x000020, 4);        /* << (value ff ff ff ff) */
-       ret = reg_r(gspca_dev, 0x0650, &dum);
+       rcv_val(gspca_dev, 0x000020);   /* << (value ff ff ff ff) */
+       ret = reg_r(gspca_dev, 0x0650);
        if (ret < 0)
                goto out;
        snd_val(gspca_dev, 0x000020, 0xffffffff);
@@ -389,14 +386,13 @@ out:
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
        struct usb_device *dev = gspca_dev->dev;
-       __u8 value;
 
        set_par(gspca_dev, 0x02000000);
        set_par(gspca_dev, 0x02000000);
        usb_set_interface(dev, gspca_dev->iface, 1);
-       reg_r(gspca_dev, 0x0630, &value);
-       rcv_val(gspca_dev, 0x000020, 4);        /* << (value ff ff ff ff) */
-       reg_r(gspca_dev, 0x0650, &value);
+       reg_r(gspca_dev, 0x0630);
+       rcv_val(gspca_dev, 0x000020);   /* << (value ff ff ff ff) */
+       reg_r(gspca_dev, 0x0650);
        snd_val(gspca_dev, 0x000020, 0xffffffff);
        reg_w(gspca_dev, 0x0620, 0);
        reg_w(gspca_dev, 0x0630, 0);
@@ -538,10 +534,10 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
 }
 
 /* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
        .name = MODULE_NAME,
        .ctrls = sd_ctrls,
-       .nctrls = sizeof sd_ctrls / sizeof sd_ctrls[0],
+       .nctrls = ARRAY_SIZE(sd_ctrls),
        .config = sd_config,
        .open = sd_open,
        .start = sd_start,
@@ -554,7 +550,7 @@ static struct sd_desc sd_desc = {
 
 /* -- module initialisation -- */
 #define DVNM(name) .driver_info = (kernel_ulong_t) name
-static __devinitdata struct usb_device_id device_table[] = {
+static const __devinitdata struct usb_device_id device_table[] = {
        {USB_DEVICE(0x05e1, 0x0893), DVNM("Syntek DV4000")},
        {}
 };
index f66594a113a7e841ce0dfd191217429b61a6666a..acd4a077198a9eae6790edfa64b8bb7506c424db 100644 (file)
@@ -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;
        }
 }
index 299f84584e82ae202124040fef51599c982892ba..00f47e463a05b8ccef3449ec3640fe45fe03e680 100644 (file)
@@ -26,8 +26,8 @@
 
 #define MODULE_NAME "t613"
 #include "gspca.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";
 
 #define MAX_GAMMA 0x10         /* 0 to 15 */
 
@@ -365,48 +365,49 @@ static const __u8 tas5130a_sensor_init[][8] = {
        {},
 };
 
-static void t16RegRead(struct usb_device *dev,
-                      __u16 index, __u8 *buffer, __u16 length)
+/* read 1 byte */
+static int reg_r_1(struct gspca_dev *gspca_dev,
+                  __u16 index)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0,              /* request */
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,              /* value */
-                       index, buffer, length, 500);
+                       index,
+                       gspca_dev->usb_buf, 1, 500);
+       return gspca_dev->usb_buf[0];
 }
 
-static void t16RegWrite(struct usb_device *dev,
+static void reg_w(struct gspca_dev *gspca_dev,
                        __u16 value,
                        __u16 index,
                        const __u8 *buffer, __u16 len)
 {
        if (buffer == NULL) {
-               usb_control_msg(dev,
-                               usb_sndctrlpipe(dev, 0),
+               usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
                                0,
                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                                value, index,
                                NULL, 0, 500);
                return;
        }
-       if (len < 16) {
-               __u8 tmpbuf[16];
-
-               memcpy(tmpbuf, buffer, len);
-               usb_control_msg(dev,
-                               usb_sndctrlpipe(dev, 0),
+       if (len <= sizeof gspca_dev->usb_buf) {
+               memcpy(gspca_dev->usb_buf, buffer, len);
+               usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
                                0,
                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                                value, index,
-                               tmpbuf, len, 500);
+                               gspca_dev->usb_buf, len, 500);
        } else {
                __u8 *tmpbuf;
 
                tmpbuf = kmalloc(len, GFP_KERNEL);
                memcpy(tmpbuf, buffer, len);
-               usb_control_msg(dev,
-                               usb_sndctrlpipe(dev, 0),
+               usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
                                0,
                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                                value, index,
@@ -443,8 +444,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
 static int init_default_parameters(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-
        /* some of this registers are not really neded, because
         * they are overriden by setbrigthness, setcontrast, etc,
         * but wont hurt anyway, and can help someone with similar webcam
@@ -509,49 +508,49 @@ static int init_default_parameters(struct gspca_dev *gspca_dev)
        static const __u8 nset10[6] =
                        { 0x0c, 0x03, 0xab, 0x10, 0x81, 0x20 };
 
-       t16RegWrite(dev, 0x01, 0x0000, n1, 0x06);
-       t16RegWrite(dev, 0x01, 0x0000, nset, 0x06);
-       t16RegRead(dev, 0x0063, &test_byte, 1);
-       t16RegWrite(dev, 0x01, 0x0000, n2, 0x02);
+       reg_w(gspca_dev, 0x01, 0x0000, n1, 0x06);
+       reg_w(gspca_dev, 0x01, 0x0000, nset, 0x06);
+       reg_r_1(gspca_dev, 0x0063);
+       reg_w(gspca_dev, 0x01, 0x0000, n2, 0x02);
 
        while (read_indexs[i] != 0x00) {
-               t16RegRead(dev, read_indexs[i], &test_byte, 1);
-               PDEBUG(D_CONF, "Reg 0x%x => 0x%x", read_indexs[i],
+               test_byte = reg_r_1(gspca_dev, read_indexs[i]);
+               PDEBUG(D_CONF, "Reg 0x%02x => 0x%02x", read_indexs[i],
                       test_byte);
                i++;
        }
 
-       t16RegWrite(dev, 0x01, 0x0000, n3, 0x06);
-       t16RegWrite(dev, 0x01, 0x0000, n4, 0x46);
-       t16RegRead(dev, 0x0080, &test_byte, 1);
-       t16RegWrite(dev, 0x00, 0x2c80, NULL, 0);
-       t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14);
-       t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12);
-       t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12);
-       t16RegWrite(dev, 0x00, 0x3880, NULL, 0);
-       t16RegWrite(dev, 0x00, 0x3880, NULL, 0);
-       t16RegWrite(dev, 0x00, 0x338e, NULL, 0);
-       t16RegWrite(dev, 0x01, 0x0000, nset5, 0x04);
-       t16RegWrite(dev, 0x00, 0x00a9, NULL, 0);
-       t16RegWrite(dev, 0x01, 0x0000, nset6, 0x22);
-       t16RegWrite(dev, 0x00, 0x86bb, NULL, 0);
-       t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0);
-
-       t16RegWrite(dev, 0x01, 0x0000, missing, 0x08);
-
-       t16RegWrite(dev, 0x00, 0x2087, NULL, 0);
-       t16RegWrite(dev, 0x00, 0x2088, NULL, 0);
-       t16RegWrite(dev, 0x00, 0x2089, NULL, 0);
-
-       t16RegWrite(dev, 0x01, 0x0000, nset7, 0x04);
-       t16RegWrite(dev, 0x01, 0x0000, nset10, 0x06);
-       t16RegWrite(dev, 0x01, 0x0000, nset8, 0x06);
-       t16RegWrite(dev, 0x01, 0x0000, nset9, 0x04);
-
-       t16RegWrite(dev, 0x00, 0x2880, NULL, 0);
-       t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14);
-       t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12);
-       t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12);
+       reg_w(gspca_dev, 0x01, 0x0000, n3, 0x06);
+       reg_w(gspca_dev, 0x01, 0x0000, n4, 0x46);
+       reg_r_1(gspca_dev, 0x0080);
+       reg_w(gspca_dev, 0x00, 0x2c80, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14);
+       reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12);
+       reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12);
+       reg_w(gspca_dev, 0x00, 0x3880, NULL, 0);
+       reg_w(gspca_dev, 0x00, 0x3880, NULL, 0);
+       reg_w(gspca_dev, 0x00, 0x338e, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, nset5, 0x04);
+       reg_w(gspca_dev, 0x00, 0x00a9, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, nset6, 0x22);
+       reg_w(gspca_dev, 0x00, 0x86bb, NULL, 0);
+       reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0);
+
+       reg_w(gspca_dev, 0x01, 0x0000, missing, 0x08);
+
+       reg_w(gspca_dev, 0x00, 0x2087, NULL, 0);
+       reg_w(gspca_dev, 0x00, 0x2088, NULL, 0);
+       reg_w(gspca_dev, 0x00, 0x2089, NULL, 0);
+
+       reg_w(gspca_dev, 0x01, 0x0000, nset7, 0x04);
+       reg_w(gspca_dev, 0x01, 0x0000, nset10, 0x06);
+       reg_w(gspca_dev, 0x01, 0x0000, nset8, 0x06);
+       reg_w(gspca_dev, 0x01, 0x0000, nset9, 0x04);
+
+       reg_w(gspca_dev, 0x00, 0x2880, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14);
+       reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12);
+       reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12);
 
        return 0;
 }
@@ -559,7 +558,6 @@ static int init_default_parameters(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;
        unsigned int brightness;
        __u8 set6[4] = { 0x8f, 0x26, 0xc3, 0x80 };
        brightness = sd->brightness;
@@ -571,13 +569,12 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                set6[3] = 0x00 + ((brightness - 7) * 0xa);
        }
 
-       t16RegWrite(dev, 0x01, 0x0000, set6, 4);
+       reg_w(gspca_dev, 0x01, 0x0000, set6, 4);
 }
 
 static void setflip(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
        __u8 flipcmd[8] =
            { 0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09 };
@@ -585,15 +582,14 @@ static void setflip(struct gspca_dev *gspca_dev)
        if (sd->mirror == 1)
                flipcmd[3] = 0x01;
 
-       t16RegWrite(dev, 0x01, 0x0000, flipcmd, 8);
+       reg_w(gspca_dev, 0x01, 0x0000, flipcmd, 8);
 }
 
 static void seteffect(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
-       t16RegWrite(dev, 0x01, 0x0000, effects_table[sd->effect], 0x06);
+       reg_w(gspca_dev, 0x01, 0x0000, effects_table[sd->effect], 0x06);
        if (sd->effect == 1 || sd->effect == 5) {
                PDEBUG(D_CONF,
                       "This effect have been disabled for webcam \"safety\"");
@@ -601,15 +597,14 @@ static void seteffect(struct gspca_dev *gspca_dev)
        }
 
        if (sd->effect == 1 || sd->effect == 4)
-               t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0);
+               reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0);
        else
-               t16RegWrite(dev, 0x00, 0xfaa6, NULL, 0);
+               reg_w(gspca_dev, 0x00, 0xfaa6, NULL, 0);
 }
 
 static void setwhitebalance(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
        __u8 white_balance[8] =
            { 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 };
@@ -617,25 +612,23 @@ static void setwhitebalance(struct gspca_dev *gspca_dev)
        if (sd->whitebalance == 1)
                white_balance[7] = 0x3c;
 
-       t16RegWrite(dev, 0x01, 0x0000, white_balance, 8);
+       reg_w(gspca_dev, 0x01, 0x0000, white_balance, 8);
 }
 
 static void setlightfreq(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };
 
        if (sd->freq == 2)      /* 60hz */
                freq[1] = 0x00;
 
-       t16RegWrite(dev, 0x1, 0x0000, freq, 0x4);
+       reg_w(gspca_dev, 0x1, 0x0000, freq, 0x4);
 }
 
 static void setcontrast(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        unsigned int contrast = sd->contrast;
        __u16 reg_to_write = 0x00;
 
@@ -644,17 +637,16 @@ static void setcontrast(struct gspca_dev *gspca_dev)
        else
                reg_to_write = (0x00a9 + ((contrast - 7) * 0x200));
 
-       t16RegWrite(dev, 0x00, reg_to_write, NULL, 0);
+       reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
 }
 
 static void setcolors(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u16 reg_to_write;
 
        reg_to_write = 0xc0bb + sd->colors * 0x100;
-       t16RegWrite(dev, 0x00, reg_to_write, NULL, 0);
+       reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
 }
 
 static void setgamma(struct gspca_dev *gspca_dev)
@@ -664,12 +656,11 @@ static void setgamma(struct gspca_dev *gspca_dev)
 static void setsharpness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        __u16 reg_to_write;
 
        reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
 
-       t16RegWrite(dev, 0x00, reg_to_write, NULL, 0);
+       reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
@@ -837,13 +828,12 @@ static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
 
        sd->autogain = val;
        if (val != 0)
-               t16RegWrite(dev, 0x00, 0xf48e, NULL, 0);
+               reg_w(gspca_dev, 0x00, 0xf48e, NULL, 0);
        else
-               t16RegWrite(dev, 0x00, 0xb48e, NULL, 0);
+               reg_w(gspca_dev, 0x00, 0xb48e, NULL, 0);
        return 0;
 }
 
@@ -857,9 +847,7 @@ static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
 
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        int mode;
-       __u8 test_byte;
 
        static const __u8 t1[] = { 0x66, 0x00, 0xa8, 0xe8 };
        __u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
@@ -886,21 +874,21 @@ static void sd_start(struct gspca_dev *gspca_dev)
                break;
        }
 
-       t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[0], 0x8);
-       t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[1], 0x8);
-       t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[2], 0x8);
-       t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
-       t16RegWrite(dev, 0x00, 0x3c80, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[0], 0x8);
+       reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[1], 0x8);
+       reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[2], 0x8);
+       reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
+       reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0);
                /* just in case and to keep sync with logs  (for mine) */
-       t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
-       t16RegWrite(dev, 0x00, 0x3c80, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
+       reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0);
                /* just in case and to keep sync with logs  (for mine) */
-       t16RegWrite(dev, 0x01, 0x0000, t1, 4);
-       t16RegWrite(dev, 0x01, 0x0000, t2, 6);
-       t16RegRead(dev, 0x0012, &test_byte, 0x01);
-       t16RegWrite(dev, 0x01, 0x0000, t3, 0x10);
-       t16RegWrite(dev, 0x00, 0x0013, NULL, 0);
-       t16RegWrite(dev, 0x01, 0x0000, t4, 0x4);
+       reg_w(gspca_dev, 0x01, 0x0000, t1, 4);
+       reg_w(gspca_dev, 0x01, 0x0000, t2, 6);
+       reg_r_1(gspca_dev, 0x0012);
+       reg_w(gspca_dev, 0x01, 0x0000, t3, 0x10);
+       reg_w(gspca_dev, 0x00, 0x0013, NULL, 0);
+       reg_w(gspca_dev, 0x01, 0x0000, t4, 0x4);
        /* restart on each start, just in case, sometimes regs goes wrong
         * when using controls from app */
        setbrightness(gspca_dev);
index f9bffd67991eb37f1751ed3d4c8a88e332a2cac7..0b793899095f29d09a6e4e99b415495c8ea2b617 100644 (file)
@@ -22,8 +22,8 @@
 
 #include "gspca.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("TV8532 USB Camera Driver");
@@ -168,63 +168,74 @@ static const __u32 tv_8532_eeprom_data[] = {
        0x0c0509f1, 0
 };
 
-static void reg_r(struct usb_device *dev,
-                 __u16 index, __u8 *buffer)
+static int reg_r(struct gspca_dev *gspca_dev,
+                __u16 index)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        TV8532_REQ_RegRead,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,      /* value */
-                       index, buffer, sizeof(__u8),
+                       index, gspca_dev->usb_buf, 1,
                        500);
+       return gspca_dev->usb_buf[0];
 }
 
-static void reg_w(struct usb_device *dev,
-                 __u16 index, __u8 *buffer, __u16 length)
+/* write 1 byte */
+static void reg_w_1(struct gspca_dev *gspca_dev,
+                 __u16 index, __u8 value)
 {
-       usb_control_msg(dev,
-                       usb_sndctrlpipe(dev, 0),
+       gspca_dev->usb_buf[0] = value;
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
                        TV8532_REQ_RegWrite,
                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0,      /* value */
-                       index, buffer, length, 500);
+                       index, gspca_dev->usb_buf, 1, 500);
+}
+
+/* write 2 bytes */
+static void reg_w_2(struct gspca_dev *gspca_dev,
+                 __u16 index, __u8 val1, __u8 val2)
+{
+       gspca_dev->usb_buf[0] = val1;
+       gspca_dev->usb_buf[1] = val2;
+       usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
+                       TV8532_REQ_RegWrite,
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       0,      /* value */
+                       index, gspca_dev->usb_buf, 2, 500);
 }
 
 static void tv_8532WriteEEprom(struct gspca_dev *gspca_dev)
 {
        int i = 0;
-       __u8 reg, data0, data1, data2, datacmd;
-       struct usb_device *dev = gspca_dev->dev;
+       __u8 reg, data0, data1, data2;
 
-       datacmd = 0xb0;;
-       reg_w(dev, TV8532_GPIO, &datacmd, 1);
-       datacmd = TV8532_CMD_EEprom_Open;
-       reg_w(dev, TV8532_CTRL, &datacmd, 1);
+       reg_w_1(gspca_dev, TV8532_GPIO, 0xb0);
+       reg_w_1(gspca_dev, TV8532_CTRL, TV8532_CMD_EEprom_Open);
 /*     msleep(1); */
        while (tv_8532_eeprom_data[i]) {
                reg = (tv_8532_eeprom_data[i] & 0xff000000) >> 24;
-               reg_w(dev, TV8532_EEprom_Add, &reg, 1);
+               reg_w_1(gspca_dev, TV8532_EEprom_Add, reg);
                /* msleep(1); */
                data0 = (tv_8532_eeprom_data[i] & 0x000000ff);
-               reg_w(dev, TV8532_EEprom_DataL, &data0, 1);
+               reg_w_1(gspca_dev, TV8532_EEprom_DataL, data0);
                /* msleep(1); */
-               data1 = (tv_8532_eeprom_data[i] & 0x0000FF00) >> 8;
-               reg_w(dev, TV8532_EEprom_DataM, &data1, 1);
+               data1 = (tv_8532_eeprom_data[i] & 0x0000ff00) >> 8;
+               reg_w_1(gspca_dev, TV8532_EEprom_DataM, data1);
                /* msleep(1); */
-               data2 = (tv_8532_eeprom_data[i] & 0x00FF0000) >> 16;
-               reg_w(dev, TV8532_EEprom_DataH, &data2, 1);
+               data2 = (tv_8532_eeprom_data[i] & 0x00ff0000) >> 16;
+               reg_w_1(gspca_dev, TV8532_EEprom_DataH, data2);
                /* msleep(1); */
-               datacmd = 0;
-               reg_w(dev, TV8532_EEprom_Write, &datacmd, 1);
+               reg_w_1(gspca_dev, TV8532_EEprom_Write, 0);
                /* msleep(10); */
                i++;
        }
-       datacmd = i;
-       reg_w(dev, TV8532_EEprom_TableLength, &datacmd, 1);
+       reg_w_1(gspca_dev, TV8532_EEprom_TableLength, i);
 /*     msleep(1); */
-       datacmd = TV8532_CMD_EEprom_Close;
-       reg_w(dev, TV8532_CTRL, &datacmd, 1);
+       reg_w_1(gspca_dev, TV8532_CTRL, TV8532_CMD_EEprom_Close);
        msleep(10);
 }
 
@@ -250,154 +261,121 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
 static void tv_8532ReadRegisters(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
        __u8 data;
-/*     __u16 vid, pid; */
 
-       reg_r(dev, 0x0001, &data);
+       data = reg_r(gspca_dev, 0x0001);
        PDEBUG(D_USBI, "register 0x01-> %x", data);
-       reg_r(dev, 0x0002, &data);
+       data = reg_r(gspca_dev, 0x0002);
        PDEBUG(D_USBI, "register 0x02-> %x", data);
-       reg_r(dev, TV8532_ADWIDTH_L, &data);
-       reg_r(dev, TV8532_ADWIDTH_H, &data);
-       reg_r(dev, TV8532_QUANT_COMP, &data);
-       reg_r(dev, TV8532_MODE_PACKET, &data);
-       reg_r(dev, TV8532_SETCLK, &data);
-       reg_r(dev, TV8532_POINT_L, &data);
-       reg_r(dev, TV8532_POINT_H, &data);
-       reg_r(dev, TV8532_POINTB_L, &data);
-       reg_r(dev, TV8532_POINTB_H, &data);
-       reg_r(dev, TV8532_BUDGET_L, &data);
-       reg_r(dev, TV8532_BUDGET_H, &data);
-       reg_r(dev, TV8532_VID_L, &data);
-       reg_r(dev, TV8532_VID_H, &data);
-       reg_r(dev, TV8532_PID_L, &data);
-       reg_r(dev, TV8532_PID_H, &data);
-       reg_r(dev, TV8532_DeviceID, &data);
-       reg_r(dev, TV8532_AD_COLBEGIN_L, &data);
-       reg_r(dev, TV8532_AD_COLBEGIN_H, &data);
-       reg_r(dev, TV8532_AD_ROWBEGIN_L, &data);
-       reg_r(dev, TV8532_AD_ROWBEGIN_H, &data);
+       reg_r(gspca_dev, TV8532_ADWIDTH_L);
+       reg_r(gspca_dev, TV8532_ADWIDTH_H);
+       reg_r(gspca_dev, TV8532_QUANT_COMP);
+       reg_r(gspca_dev, TV8532_MODE_PACKET);
+       reg_r(gspca_dev, TV8532_SETCLK);
+       reg_r(gspca_dev, TV8532_POINT_L);
+       reg_r(gspca_dev, TV8532_POINT_H);
+       reg_r(gspca_dev, TV8532_POINTB_L);
+       reg_r(gspca_dev, TV8532_POINTB_H);
+       reg_r(gspca_dev, TV8532_BUDGET_L);
+       reg_r(gspca_dev, TV8532_BUDGET_H);
+       reg_r(gspca_dev, TV8532_VID_L);
+       reg_r(gspca_dev, TV8532_VID_H);
+       reg_r(gspca_dev, TV8532_PID_L);
+       reg_r(gspca_dev, TV8532_PID_H);
+       reg_r(gspca_dev, TV8532_DeviceID);
+       reg_r(gspca_dev, TV8532_AD_COLBEGIN_L);
+       reg_r(gspca_dev, TV8532_AD_COLBEGIN_H);
+       reg_r(gspca_dev, TV8532_AD_ROWBEGIN_L);
+       reg_r(gspca_dev, TV8532_AD_ROWBEGIN_H);
 }
 
 static void tv_8532_setReg(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 data;
-       __u8 value[2] = { 0, 0 };
-
-       data = ADCBEGINL;
-       reg_w(dev, TV8532_AD_COLBEGIN_L, &data, 1);     /* 0x10 */
-       data = ADCBEGINH;       /* also digital gain */
-       reg_w(dev, TV8532_AD_COLBEGIN_H, &data, 1);
-       data = TV8532_CMD_UPDATE;
-       reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */
-
-       data = 0x0a;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
+       reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_L,
+                       ADCBEGINL);                     /* 0x10 */
+       reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_H,
+                       ADCBEGINH);                     /* also digital gain */
+       reg_w_1(gspca_dev, TV8532_PART_CTRL,
+                       TV8532_CMD_UPDATE);             /* 0x00<-0x84 */
+
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0a);
        /******************************************************/
-       data = ADHEIGHL;
-       reg_w(dev, TV8532_ADHEIGHT_L, &data, 1);        /* 0e */
-       data = ADHEIGHH;
-       reg_w(dev, TV8532_ADHEIGHT_H, &data, 1);        /* 0f */
-       value[0] = EXPOL;
-       value[1] = EXPOH;       /* 350d 0x014c; */
-       reg_w(dev, TV8532_EXPOSURE, value, 2);  /* 1c */
-       data = ADCBEGINL;
-       reg_w(dev, TV8532_AD_COLBEGIN_L, &data, 1);     /* 0x10 */
-       data = ADCBEGINH;       /* also digital gain */
-       reg_w(dev, TV8532_AD_COLBEGIN_H, &data, 1);
-       data = ADRBEGINL;
-       reg_w(dev, TV8532_AD_ROWBEGIN_L, &data, 1);     /* 0x14 */
-
-       data = 0x00;
-       reg_w(dev, TV8532_AD_SLOPE, &data, 1);  /* 0x91 */
-       data = 0x02;
-       reg_w(dev, TV8532_AD_BITCTRL, &data, 1);        /* 0x94 */
-
-
-       data = TV8532_CMD_EEprom_Close;
-       reg_w(dev, TV8532_CTRL, &data, 1);      /* 0x01 */
-
-       data = 0x00;
-       reg_w(dev, TV8532_AD_SLOPE, &data, 1);  /* 0x91 */
-       data = TV8532_CMD_UPDATE;
-       reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */
+       reg_w_1(gspca_dev, TV8532_ADHEIGHT_L, ADHEIGHL); /* 0e */
+       reg_w_1(gspca_dev, TV8532_ADHEIGHT_H, ADHEIGHH); /* 0f */
+       reg_w_2(gspca_dev, TV8532_EXPOSURE,
+                       EXPOL, EXPOH);                  /* 350d 0x014c; 1c */
+       reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_L,
+                       ADCBEGINL);                     /* 0x10 */
+       reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_H,
+                       ADCBEGINH);                     /* also digital gain */
+       reg_w_1(gspca_dev, TV8532_AD_ROWBEGIN_L,
+                       ADRBEGINL);                     /* 0x14 */
+
+       reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x00);      /* 0x91 */
+       reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x02);    /* 0x94 */
+
+       reg_w_1(gspca_dev, TV8532_CTRL,
+                       TV8532_CMD_EEprom_Close);       /* 0x01 */
+
+       reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x00);      /* 0x91 */
+       reg_w_1(gspca_dev, TV8532_PART_CTRL,
+                       TV8532_CMD_UPDATE);             /* 0x00<-0x84 */
 }
 
 static void tv_8532_PollReg(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 data;
        int i;
 
        /* strange polling from tgc */
        for (i = 0; i < 10; i++) {
-               data = TESTCLK; /* 0x48; //0x08; */
-               reg_w(dev, TV8532_SETCLK, &data, 1);    /* 0x2c */
-               data = TV8532_CMD_UPDATE;
-               reg_w(dev, TV8532_PART_CTRL, &data, 1);
-               data = 0x01;
-               reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+               reg_w_1(gspca_dev, TV8532_SETCLK,
+                       TESTCLK);               /* 0x48; //0x08; 0x2c */
+               reg_w_1(gspca_dev, TV8532_PART_CTRL, TV8532_CMD_UPDATE);
+               reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01);    /* 0x31 */
        }
 }
 
 /* this function is called at open time */
 static int sd_open(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 data;
-       __u8 dataStart;
-       __u8 value[2];
-
-       data = 0x32;
-       reg_w(dev, TV8532_AD_SLOPE, &data, 1);
-       data = 0;
-       reg_w(dev, TV8532_AD_BITCTRL, &data, 1);
+       reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x32);
+       reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x00);
        tv_8532ReadRegisters(gspca_dev);
-       data = 0x0b;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
-       value[0] = ADHEIGHL;
-       value[1] = ADHEIGHH;    /* 401d 0x0169; */
-       reg_w(dev, TV8532_ADHEIGHT_L, value, 2);        /* 0e */
-       value[0] = EXPOL;
-       value[1] = EXPOH;       /* 350d 0x014c; */
-       reg_w(dev, TV8532_EXPOSURE, value, 2);  /* 1c */
-       data = ADWIDTHL;        /* 0x20; */
-       reg_w(dev, TV8532_ADWIDTH_L, &data, 1); /* 0x0c */
-       data = ADWIDTHH;
-       reg_w(dev, TV8532_ADWIDTH_H, &data, 1); /* 0x0d */
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b);
+       reg_w_2(gspca_dev, TV8532_ADHEIGHT_L, ADHEIGHL,
+                               ADHEIGHH);      /* 401d 0x0169; 0e */
+       reg_w_2(gspca_dev, TV8532_EXPOSURE, EXPOL,
+                               EXPOH);         /* 350d 0x014c; 1c */
+       reg_w_1(gspca_dev, TV8532_ADWIDTH_L, ADWIDTHL); /* 0x20; 0x0c */
+       reg_w_1(gspca_dev, TV8532_ADWIDTH_H, ADWIDTHH); /* 0x0d */
 
        /*******************************************************************/
-       data = TESTCOMP;        /* 0x72 compressed mode */
-       reg_w(dev, TV8532_QUANT_COMP, &data, 1);        /* 0x28 */
-       data = TESTLINE;        /* 0x84; // CIF | 4 packet */
-       reg_w(dev, TV8532_MODE_PACKET, &data, 1);       /* 0x29 */
+       reg_w_1(gspca_dev, TV8532_QUANT_COMP,
+                       TESTCOMP);      /* 0x72 compressed mode 0x28 */
+       reg_w_1(gspca_dev, TV8532_MODE_PACKET,
+                       TESTLINE);      /* 0x84; // CIF | 4 packet 0x29 */
 
        /************************************************/
-       data = TESTCLK;         /* 0x48; //0x08; */
-       reg_w(dev, TV8532_SETCLK, &data, 1);    /* 0x2c */
-       data = TESTPTL;         /* 0x38; */
-       reg_w(dev, TV8532_POINT_L, &data, 1);   /* 0x2d */
-       data = TESTPTH;         /* 0x04; */
-       reg_w(dev, TV8532_POINT_H, &data, 1);   /* 0x2e */
-       dataStart = TESTPTBL;   /* 0x04; */
-       reg_w(dev, TV8532_POINTB_L, &dataStart, 1);     /* 0x2f */
-       data = TESTPTBH;        /* 0x04; */
-       reg_w(dev, TV8532_POINTB_H, &data, 1);  /* 0x30 */
-       data = TV8532_CMD_UPDATE;
-       reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */
+       reg_w_1(gspca_dev, TV8532_SETCLK,
+                       TESTCLK);               /* 0x48; //0x08; 0x2c */
+       reg_w_1(gspca_dev, TV8532_POINT_L,
+                       TESTPTL);               /* 0x38; 0x2d */
+       reg_w_1(gspca_dev, TV8532_POINT_H,
+                       TESTPTH);               /* 0x04; 0x2e */
+       reg_w_1(gspca_dev, TV8532_POINTB_L,
+                       TESTPTBL);              /* 0x04; 0x2f */
+       reg_w_1(gspca_dev, TV8532_POINTB_H,
+                       TESTPTBH);              /* 0x04; 0x30 */
+       reg_w_1(gspca_dev, TV8532_PART_CTRL,
+                       TV8532_CMD_UPDATE);     /* 0x00<-0x84 */
        /*************************************************/
-       data = 0x01;
-       reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+       reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01);    /* 0x31 */
        msleep(200);
-       data = 0x00;
-       reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+       reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00);    /* 0x31 */
        /*************************************************/
        tv_8532_setReg(gspca_dev);
        /*************************************************/
-       data = 0x0b;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b);
        /*************************************************/
        tv_8532_setReg(gspca_dev);
        /*************************************************/
@@ -408,94 +386,72 @@ static int sd_open(struct gspca_dev *gspca_dev)
 static void setbrightness(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       __u8 value[2];
-       __u8 data;
        int brightness = sd->brightness;
 
-       value[1] = (brightness >> 8) & 0xff;
-       value[0] = (brightness) & 0xff;
-       reg_w(gspca_dev->dev, TV8532_EXPOSURE, value, 2);       /* 1c */
-       data = TV8532_CMD_UPDATE;
-       reg_w(gspca_dev->dev, TV8532_PART_CTRL, &data, 1);
+       reg_w_2(gspca_dev, TV8532_EXPOSURE,
+               brightness >> 8, brightness);           /* 1c */
+       reg_w_1(gspca_dev, TV8532_PART_CTRL, TV8532_CMD_UPDATE);
 }
 
 /* -- start the camera -- */
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 data;
-       __u8 value[2];
-
-       data = 0x32;
-       reg_w(dev, TV8532_AD_SLOPE, &data, 1);
-       data = 0;
-       reg_w(dev, TV8532_AD_BITCTRL, &data, 1);
+       reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x32);
+       reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x00);
        tv_8532ReadRegisters(gspca_dev);
-       data = 0x0b;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
-       value[0] = ADHEIGHL;
-       value[1] = ADHEIGHH;    /* 401d 0x0169; */
-       reg_w(dev, TV8532_ADHEIGHT_L, value, 2);        /* 0e */
-/*     value[0] = EXPOL; value[1] =EXPOH;               * 350d 0x014c; */
-/*     reg_w(dev,TV8532_REQ_RegWrite,0,TV8532_EXPOSURE,value,2);  * 1c */
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b);
+       reg_w_2(gspca_dev, TV8532_ADHEIGHT_L,
+               ADHEIGHL, ADHEIGHH);    /* 401d 0x0169; 0e */
+/*     reg_w_2(gspca_dev, TV8532_EXPOSURE,
+               EXPOL, EXPOH);           * 350d 0x014c; 1c */
        setbrightness(gspca_dev);
 
-       data = ADWIDTHL;        /* 0x20; */
-       reg_w(dev, TV8532_ADWIDTH_L, &data, 1); /* 0x0c */
-       data = ADWIDTHH;
-       reg_w(dev, TV8532_ADWIDTH_H, &data, 1); /* 0x0d */
+       reg_w_1(gspca_dev, TV8532_ADWIDTH_L, ADWIDTHL); /* 0x20; 0x0c */
+       reg_w_1(gspca_dev, TV8532_ADWIDTH_H, ADWIDTHH); /* 0x0d */
 
        /************************************************/
-       data = TESTCOMP;        /* 0x72 compressed mode */
-       reg_w(dev, TV8532_QUANT_COMP, &data, 1);        /* 0x28 */
+       reg_w_1(gspca_dev, TV8532_QUANT_COMP,
+                       TESTCOMP);      /* 0x72 compressed mode 0x28 */
        if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
                /* 176x144 */
-               data = QCIFLINE;        /* 0x84; // CIF | 4 packet */
-               reg_w(dev, TV8532_MODE_PACKET, &data, 1);       /* 0x29 */
+               reg_w_1(gspca_dev, TV8532_MODE_PACKET,
+                       QCIFLINE);      /* 0x84; // CIF | 4 packet 0x29 */
        } else {
                /* 352x288 */
-               data = TESTLINE;        /* 0x84; // CIF | 4 packet */
-               reg_w(dev, TV8532_MODE_PACKET, &data, 1);       /* 0x29 */
+               reg_w_1(gspca_dev, TV8532_MODE_PACKET,
+                       TESTLINE);      /* 0x84; // CIF | 4 packet 0x29 */
        }
        /************************************************/
-       data = TESTCLK;         /* 0x48; //0x08; */
-       reg_w(dev, TV8532_SETCLK, &data, 1);    /* 0x2c */
-       data = TESTPTL;         /* 0x38; */
-       reg_w(dev, TV8532_POINT_L, &data, 1);   /* 0x2d */
-       data = TESTPTH;         /* 0x04; */
-       reg_w(dev, TV8532_POINT_H, &data, 1);   /* 0x2e */
-       data = TESTPTBL;        /* 0x04; */
-       reg_w(dev, TV8532_POINTB_L, &data, 1);  /* 0x2f */
-       data = TESTPTBH;        /* 0x04; */
-       reg_w(dev, TV8532_POINTB_H, &data, 1);  /* 0x30 */
-       data = TV8532_CMD_UPDATE;
-       reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */
+       reg_w_1(gspca_dev, TV8532_SETCLK,
+                       TESTCLK);               /* 0x48; //0x08; 0x2c */
+       reg_w_1(gspca_dev, TV8532_POINT_L,
+                       TESTPTL);               /* 0x38; 0x2d */
+       reg_w_1(gspca_dev, TV8532_POINT_H,
+                       TESTPTH);               /* 0x04; 0x2e */
+       reg_w_1(gspca_dev, TV8532_POINTB_L,
+                       TESTPTBL);              /* 0x04; 0x2f */
+       reg_w_1(gspca_dev, TV8532_POINTB_H,
+                       TESTPTBH);              /* 0x04; 0x30 */
+       reg_w_1(gspca_dev, TV8532_PART_CTRL,
+                       TV8532_CMD_UPDATE);     /* 0x00<-0x84 */
        /************************************************/
-       data = 0x01;
-       reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+       reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01);    /* 0x31 */
        msleep(200);
-       data = 0x00;
-       reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+       reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00);    /* 0x31 */
        /************************************************/
        tv_8532_setReg(gspca_dev);
        /************************************************/
-       data = 0x0b;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b);
        /************************************************/
        tv_8532_setReg(gspca_dev);
        /************************************************/
        tv_8532_PollReg(gspca_dev);
-       data = 0x00;
-       reg_w(dev, TV8532_UDP_UPDATE, &data, 1);        /* 0x31 */
+       reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00);    /* 0x31 */
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
-       struct usb_device *dev = gspca_dev->dev;
-       __u8 data;
-
-       data = 0x0b;
-       reg_w(dev, TV8532_GPIO_OE, &data, 1);
+       reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b);
 }
 
 static void sd_stop0(struct gspca_dev *gspca_dev)
index 668e024aaa8f593e6c38fe2cd86bd943dd789f6d..dd7c1389f38d44da6687ac8a2f4c2dff9ba984c5 100644 (file)
@@ -1227,17 +1227,18 @@ static const struct sensor_info sensor_info_data[] = {
        {SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01},
 };
 
-static void reg_r(struct usb_device *dev,
-                          __u16 req,
-                          __u16 index,
-                          __u8 *buffer, __u16 length)
+/* read 'len' bytes in gspca_dev->usb_buf */
+static void reg_r(struct gspca_dev *gspca_dev,
+                 __u16 req,
+                 __u16 index,
+                 __u16 len)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        req,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        1,                      /* value */
-                       index, buffer, length,
+                       index, gspca_dev->usb_buf, len,
                        500);
 }
 
@@ -1254,55 +1255,55 @@ static void reg_w(struct usb_device *dev,
                        500);
 }
 
-static void vc032x_read_sensor_register(struct usb_device *dev,
+static void read_sensor_register(struct gspca_dev *gspca_dev,
                                __u16 address, __u16 *value)
 {
+       struct usb_device *dev = gspca_dev->dev;
        __u8 ldata, mdata, hdata;
-       __u8 tmpvalue = 0;
        int retry = 50;
-       ldata = 0;
-       mdata = 0;
-       hdata = 0;
+
        *value = 0;
 
-       reg_r(dev, 0xa1, 0xb33f, &tmpvalue, 1);
+       reg_r(gspca_dev, 0xa1, 0xb33f, 1);
        /*PDEBUG(D_PROBE, " I2c Bus Busy Wait  0x%02X ", tmpvalue); */
-       if (!(tmpvalue & 0x02)) {
-               PDEBUG(D_ERR, "I2c Bus Busy Wait %d", tmpvalue & 0x02);
+       if (!(gspca_dev->usb_buf[0] & 0x02)) {
+               PDEBUG(D_ERR, "I2c Bus Busy Wait %d",
+                       gspca_dev->usb_buf[0] & 0x02);
                return;
        }
        reg_w(dev, 0xa0, address, 0xb33a);
        reg_w(dev, 0xa0, 0x02, 0xb339);
 
-       tmpvalue = 0;
-       reg_r(dev, 0xa1, 0xb33b, &tmpvalue, 1);
-       while (retry-- && tmpvalue) {
-               reg_r(dev, 0xa1, 0xb33b, &tmpvalue, 1);
+       reg_r(gspca_dev, 0xa1, 0xb33b, 1);
+       while (retry-- && gspca_dev->usb_buf[0]) {
+               reg_r(gspca_dev, 0xa1, 0xb33b, 1);
 /*             PDEBUG(D_PROBE, "Read again 0xb33b %d", tmpvalue); */
                msleep(1);
        }
-       reg_r(dev, 0xa1, 0xb33e, &hdata, 1);
-       reg_r(dev, 0xa1, 0xb33d, &mdata, 1);
-       reg_r(dev, 0xa1, 0xb33c, &ldata, 1);
+       reg_r(gspca_dev, 0xa1, 0xb33e, 1);
+       hdata = gspca_dev->usb_buf[0];
+       reg_r(gspca_dev, 0xa1, 0xb33d, 1);
+       mdata = gspca_dev->usb_buf[0];
+       reg_r(gspca_dev, 0xa1, 0xb33c, 1);
+       ldata = gspca_dev->usb_buf[0];
        PDEBUG(D_PROBE, "Read Sensor h (0x%02X) m (0x%02X) l (0x%02X)",
                hdata, mdata, ldata);
-       tmpvalue = 0;
-       reg_r(dev, 0xa1, 0xb334, &tmpvalue, 1);
-       if (tmpvalue == 0x02)
+       reg_r(gspca_dev, 0xa1, 0xb334, 1);
+       if (gspca_dev->usb_buf[0] == 0x02)
                *value = (ldata << 8) + mdata;
        else
                *value = ldata;
 }
+
 static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
 {
        struct usb_device *dev = gspca_dev->dev;
        int i;
-       __u8 data;
        __u16 value;
        const struct sensor_info *ptsensor_info;
 
-       reg_r(dev, 0xa1, 0xbfcf, &data, 1);
-       PDEBUG(D_PROBE, "check sensor header %d", data);
+       reg_r(gspca_dev, 0xa1, 0xbfcf, 1);
+       PDEBUG(D_PROBE, "check sensor header %d", gspca_dev->usb_buf[0]);
        for (i = 0; i < ARRAY_SIZE(sensor_info_data); i++) {
                ptsensor_info = &sensor_info_data[i];
                reg_w(dev, 0xa0, 0x02, 0xb334);
@@ -1315,7 +1316,7 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
                        "check sensor VC032X -> %d Add -> ox%02X!",
                        i, ptsensor_info->I2cAdd); */
                reg_w(dev, 0xa0, ptsensor_info->op, 0xb301);
-               vc032x_read_sensor_register(dev, ptsensor_info->IdAdd, &value);
+               read_sensor_register(gspca_dev, ptsensor_info->IdAdd, &value);
                if (value == ptsensor_info->VpId) {
 /*                     PDEBUG(D_PROBE, "find sensor VC032X -> ox%04X!",
                                ptsensor_info->VpId); */
@@ -1325,14 +1326,14 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
        return -1;
 }
 
-static __u8 i2c_write(struct usb_device *dev,
+static __u8 i2c_write(struct gspca_dev *gspca_dev,
                        __u8 reg, const __u8 *val, __u8 size)
 {
-       __u8 retbyte;
+       struct usb_device *dev = gspca_dev->dev;
 
        if (size > 3 || size < 1)
                return -EINVAL;
-       reg_r(dev, 0xa1, 0xb33f, &retbyte, 1);
+       reg_r(gspca_dev, 0xa1, 0xb33f, 1);
        reg_w(dev, 0xa0, size, 0xb334);
        reg_w(dev, 0xa0, reg, 0xb33a);
        switch (size) {
@@ -1353,8 +1354,8 @@ static __u8 i2c_write(struct usb_device *dev,
                return -EINVAL;
        }
        reg_w(dev, 0xa0, 0x01, 0xb339);
-       reg_r(dev, 0xa1, 0xb33b, &retbyte, 1);
-       return retbyte == 0;
+       reg_r(gspca_dev, 0xa1, 0xb33b, 1);
+       return gspca_dev->usb_buf[0] == 0;
 }
 
 static void put_tab_to_reg(struct gspca_dev *gspca_dev,
@@ -1382,10 +1383,10 @@ static void usb_exchange(struct gspca_dev *gspca_dev,
                                        ((data[i][0])<<8) | data[i][1]);
                        break;
                case 0xaa:                      /* i2c op */
-                       i2c_write(dev, data[i][1], &data[i][2], 1);
+                       i2c_write(gspca_dev, data[i][1], &data[i][2], 1);
                        break;
                case 0xbb:                      /* i2c op */
-                       i2c_write(dev, data[i][0], &data[i][1], 2);
+                       i2c_write(gspca_dev, data[i][0], &data[i][1], 2);
                        break;
                case 0xdd:
                        msleep(data[i][2] + 10);
@@ -1417,7 +1418,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
        struct sd *sd = (struct sd *) gspca_dev;
        struct usb_device *dev = gspca_dev->dev;
        struct cam *cam;
-       __u8 tmp2[4];
        int sensor;
        __u16 product;
 
@@ -1488,10 +1488,10 @@ static int sd_config(struct gspca_dev *gspca_dev,
        sd->lightfreq = FREQ_DEF;
 
        if (sd->bridge == BRIDGE_VC0321) {
-               reg_r(dev, 0x8a, 0, tmp2, 3);
+               reg_r(gspca_dev, 0x8a, 0, 3);
                reg_w(dev, 0x87, 0x00, 0x0f0f);
 
-               reg_r(dev, 0x8b, 0, tmp2, 3);
+               reg_r(gspca_dev, 0x8b, 0, 3);
                reg_w(dev, 0x88, 0x00, 0x0202);
        }
        return 0;
@@ -1525,7 +1525,6 @@ static void setlightfreq(struct gspca_dev *gspca_dev)
 static void sd_start(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-/*     __u8 tmp2; */
        const __u8 *GammaT = NULL;
        const __u8 *MatrixT = NULL;
        int mode;
@@ -1627,7 +1626,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
                reg_w(gspca_dev->dev, 0xa0, 0x40, 0xb824);
                */
                /* Only works for HV7131R ??
-               reg_r (gspca_dev->dev, 0xa1, 0xb881, &tmp2, 1);
+               reg_r (gspca_dev, 0xa1, 0xb881, 1);
                reg_w(gspca_dev->dev, 0xa0, 0xfe01, 0xb881);
                reg_w(gspca_dev->dev, 0xa0, 0x79, 0xb801);
                */
index bac45a193653cdf36a59e24652dbe79424939041..548c4c8c3f33db301fe15d5fd037b565abf8d5c4 100644 (file)
@@ -24,8 +24,8 @@
 
 #include "gspca.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>, "
                "Serge A. Suchkov <Serge.A.S@tochka.ru>");
@@ -6214,23 +6214,27 @@ static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
        {}
 };
 
-static void reg_r_i(struct usb_device *dev,
-               __u16 index, __u8 *buffer)
+static int reg_r_i(struct gspca_dev *gspca_dev,
+               __u16 index)
 {
-       usb_control_msg(dev,
-                       usb_rcvctrlpipe(dev, 0),
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
                        0xa1,
                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                        0x01,                   /* value */
-                       index, buffer, 1,
+                       index, gspca_dev->usb_buf, 1,
                        500);
+       return gspca_dev->usb_buf[0];
 }
 
-static void reg_r(struct usb_device *dev,
-               __u16 index, __u8 *buffer)
+static int reg_r(struct gspca_dev *gspca_dev,
+               __u16 index)
 {
-       reg_r_i(dev, index, buffer);
-       PDEBUG(D_USBI, "reg r [%04x] -> %02x", index, *buffer);
+       int ret;
+
+       ret = reg_r_i(gspca_dev, index);
+       PDEBUG(D_USBI, "reg r [%04x] -> %02x", index, ret);
+       return ret;
 }
 
 static void reg_w_i(struct usb_device *dev,
@@ -6253,55 +6257,54 @@ static void reg_w(struct usb_device *dev,
        reg_w_i(dev, value, index);
 }
 
-static __u16 i2c_read(struct usb_device *dev, __u8 reg)
+static __u16 i2c_read(struct gspca_dev *gspca_dev,
+                       __u8 reg)
 {
        __u8 retbyte;
        __u8 retval[2];
 
-       reg_w_i(dev, reg, 0x92);
-       reg_w_i(dev, 0x02, 0x90);               /* <- read command */
+       reg_w_i(gspca_dev->dev, reg, 0x92);
+       reg_w_i(gspca_dev->dev, 0x02, 0x90);            /* <- read command */
        msleep(25);
-       reg_r_i(dev, 0x0091, &retbyte);         /* read status */
-       reg_r_i(dev, 0x0095, &retval[0]);       /* read Lowbyte */
-       reg_r_i(dev, 0x0096, &retval[1]);       /* read Hightbyte */
+       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];
 }
 
-static __u8 i2c_write(struct usb_device *dev,
+static __u8 i2c_write(struct gspca_dev *gspca_dev,
                        __u8 reg,
                        __u8 valL,
                        __u8 valH)
 {
        __u8 retbyte;
 
-       reg_w_i(dev, reg, 0x92);
-       reg_w_i(dev, valL, 0x93);
-       reg_w_i(dev, valH, 0x94);
-       reg_w_i(dev, 0x01, 0x90);               /* <- write command */
+       reg_w_i(gspca_dev->dev, reg, 0x92);
+       reg_w_i(gspca_dev->dev, valL, 0x93);
+       reg_w_i(gspca_dev->dev, valH, 0x94);
+       reg_w_i(gspca_dev->dev, 0x01, 0x90);            /* <- write command */
        msleep(5);
-       reg_r_i(dev, 0x0091, &retbyte);         /* read status */
+       retbyte = reg_r_i(gspca_dev, 0x0091);           /* read status */
        PDEBUG(D_USBO, "i2c w [%02x] %02x%02x (%02x)",
                        reg, valH, valL, retbyte);
        return retbyte;
 }
 
-static void usb_exchange(struct usb_device *dev,
+static void usb_exchange(struct gspca_dev *gspca_dev,
                        const struct usb_action *action)
 {
-       __u8 buffread;
-
        while (action->req) {
                switch (action->req) {
                case 0xa0:      /* write register */
-                       reg_w(dev, action->val, action->idx);
+                       reg_w(gspca_dev->dev, action->val, action->idx);
                        break;
                case 0xa1:      /* read status */
-                       reg_r(dev, action->idx, &buffread);
+                       reg_r(gspca_dev, action->idx);
                        break;
                case 0xaa:
-                       i2c_write(dev,
+                       i2c_write(gspca_dev,
                                  action->val,                  /* reg */
                                  action->idx & 0xff,           /* valL */
                                  action->idx >> 8);            /* valH */
@@ -6376,7 +6379,6 @@ static void setsharpness(struct gspca_dev *gspca_dev)
        struct sd *sd = (struct sd *) gspca_dev;
        struct usb_device *dev = gspca_dev->dev;
        int sharpness;
-       __u8 retbyte;
        static const __u8 sharpness_tb[][2] = {
                {0x02, 0x03},
                {0x04, 0x07},
@@ -6386,9 +6388,9 @@ static void setsharpness(struct gspca_dev *gspca_dev)
 
        sharpness = sd->sharpness;
        reg_w(dev, sharpness_tb[sharpness][0], 0x01c6);
-       reg_r(dev, 0x01c8, &retbyte);
-       reg_r(dev, 0x01c9, &retbyte);
-       reg_r(dev, 0x01ca, &retbyte);
+       reg_r(gspca_dev, 0x01c8);
+       reg_r(gspca_dev, 0x01c9);
+       reg_r(gspca_dev, 0x01ca);
        reg_w(dev, sharpness_tb[sharpness][1], 0x01cb);
 }
 
@@ -6398,7 +6400,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
        struct usb_device *dev = gspca_dev->dev;
        const __u8 *Tgamma, *Tgradient;
        int g, i, k;
-       static const __u8 kgamma_tb[16] =               /* delta for contrast */
+       static const __u8 kgamma_tb[16] =       /* delta for contrast */
                {0x15, 0x0d, 0x0a, 0x09, 0x08, 0x08, 0x08, 0x08,
                 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
        static const __u8 kgrad_tb[16] =
@@ -6623,7 +6625,7 @@ static int setlightfreq(struct gspca_dev *gspca_dev)
                i++;                    /* 640x480 */
        zc3_freq = freq_tb[(int) sd->sensor][i];
        if (zc3_freq != NULL) {
-               usb_exchange(gspca_dev->dev, zc3_freq);
+               usb_exchange(gspca_dev, zc3_freq);
                switch (sd->sensor) {
                case SENSOR_GC0305:
                        if (mode                        /* if 320x240 */
@@ -6687,44 +6689,45 @@ static void start_2wr_probe(struct usb_device *dev, int sensor)
 /*     msleep(2); */
 }
 
-static int sif_probe(struct usb_device *dev)
+static int sif_probe(struct gspca_dev *gspca_dev)
 {
        __u16 checkword;
 
-       start_2wr_probe(dev, 0x0f);             /* PAS106 */
-       reg_w(dev, 0x08, 0x008d);
+       start_2wr_probe(gspca_dev->dev, 0x0f);          /* PAS106 */
+       reg_w(gspca_dev->dev, 0x08, 0x008d);
        msleep(150);
-       checkword = ((i2c_read(dev, 0x00) & 0x0f) << 4)
-                       | ((i2c_read(dev, 0x01) & 0xf0) >> 4);
+       checkword = ((i2c_read(gspca_dev, 0x00) & 0x0f) << 4)
+                       | ((i2c_read(gspca_dev, 0x01) & 0xf0) >> 4);
        PDEBUG(D_PROBE, "probe sif 0x%04x", checkword);
        if (checkword == 0x0007) {
-               send_unknown(dev, SENSOR_PAS106);
+               send_unknown(gspca_dev->dev, SENSOR_PAS106);
                return 0x0f;                    /* PAS106 */
        }
        return -1;
 }
 
-static int vga_2wr_probe(struct usb_device *dev)
+static int vga_2wr_probe(struct gspca_dev *gspca_dev)
 {
+       struct usb_device *dev = gspca_dev->dev;
        __u8 retbyte;
        __u16 checkword;
 
        start_2wr_probe(dev, 0x00);             /* HV7131B */
-       i2c_write(dev, 0x01, 0xaa, 0x00);
-       retbyte = i2c_read(dev, 0x01);
+       i2c_write(gspca_dev, 0x01, 0xaa, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0)
                return 0x00;                    /* HV7131B */
 
        start_2wr_probe(dev, 0x04);             /* CS2102 */
-       i2c_write(dev, 0x01, 0xaa, 0x00);
-       retbyte = i2c_read(dev, 0x01);
+       i2c_write(gspca_dev, 0x01, 0xaa, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0)
                return 0x04;                    /* CS2102 */
 
        start_2wr_probe(dev, 0x06);             /* OmniVision */
        reg_w(dev, 0x08, 0x8d);
-       i2c_write(dev, 0x11, 0xaa, 0x00);
-       retbyte = i2c_read(dev, 0x11);
+       i2c_write(gspca_dev, 0x11, 0xaa, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x11);
        if (retbyte != 0) {
                /* (should have returned 0xaa) --> Omnivision? */
                /* reg_r 0x10 -> 0x06 -->  */
@@ -6732,45 +6735,45 @@ static int vga_2wr_probe(struct usb_device *dev)
        }
 
        start_2wr_probe(dev, 0x08);             /* HDCS2020 */
-       i2c_write(dev, 0x15, 0xaa, 0x00);
-       retbyte = i2c_read(dev, 0x15);
+       i2c_write(gspca_dev, 0x15, 0xaa, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x15);
        if (retbyte != 0)
                return 0x08;                    /* HDCS2020 */
 
        start_2wr_probe(dev, 0x0a);             /* PB0330 */
-       i2c_write(dev, 0x07, 0xaa, 0xaa);
-       retbyte = i2c_read(dev, 0x07);
+       i2c_write(gspca_dev, 0x07, 0xaa, 0xaa);
+       retbyte = i2c_read(gspca_dev, 0x07);
        if (retbyte != 0)
                return 0x0a;                    /* PB0330 */
-       retbyte = i2c_read(dev, 0x03);
+       retbyte = i2c_read(gspca_dev, 0x03);
        if (retbyte != 0)
                return 0x0a;                    /* PB0330 ?? */
-       retbyte = i2c_read(dev, 0x04);
+       retbyte = i2c_read(gspca_dev, 0x04);
        if (retbyte != 0)
                return 0x0a;                    /* PB0330 ?? */
 
        start_2wr_probe(dev, 0x0c);             /* ICM105A */
-       i2c_write(dev, 0x01, 0x11, 0x00);
-       retbyte = i2c_read(dev, 0x01);
+       i2c_write(gspca_dev, 0x01, 0x11, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0)
                return 0x0c;                    /* ICM105A */
 
        start_2wr_probe(dev, 0x0e);             /* PAS202BCB */
        reg_w(dev, 0x08, 0x8d);
-       i2c_write(dev, 0x03, 0xaa, 0x00);
+       i2c_write(gspca_dev, 0x03, 0xaa, 0x00);
        msleep(500);
-       retbyte = i2c_read(dev, 0x03);
+       retbyte = i2c_read(gspca_dev, 0x03);
        if (retbyte != 0)
                return 0x0e;                    /* PAS202BCB */
 
        start_2wr_probe(dev, 0x02);             /* ?? */
-       i2c_write(dev, 0x01, 0xaa, 0x00);
-       retbyte = i2c_read(dev, 0x01);
+       i2c_write(gspca_dev, 0x01, 0xaa, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0)
                return 0x02;                    /* ?? */
 ov_check:
-       reg_r(dev, 0x0010, &retbyte);           /* ?? */
-       reg_r(dev, 0x0010, &retbyte);
+       reg_r(gspca_dev, 0x0010);               /* ?? */
+       reg_r(gspca_dev, 0x0010);
 
        reg_w(dev, 0x01, 0x0000);
        reg_w(dev, 0x01, 0x0001);
@@ -6779,10 +6782,10 @@ ov_check:
        reg_w(dev, 0x08, 0x008d);
        msleep(500);
        reg_w(dev, 0x01, 0x0012);
-       i2c_write(dev, 0x12, 0x80, 0x00);       /* sensor reset */
-       retbyte = i2c_read(dev, 0x0a);
+       i2c_write(gspca_dev, 0x12, 0x80, 0x00); /* sensor reset */
+       retbyte = i2c_read(gspca_dev, 0x0a);
        checkword = retbyte << 8;
-       retbyte = i2c_read(dev, 0x0b);
+       retbyte = i2c_read(gspca_dev, 0x0b);
        checkword |= retbyte;
        PDEBUG(D_PROBE, "probe 2wr ov vga 0x%04x", checkword);
        switch (checkword) {
@@ -6821,7 +6824,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(dev, 0x10, &retbyte);
+       reg_r(gspca_dev, 0x10);
        reg_w(dev, 0x01, 0x0000);
        reg_w(dev, 0x00, 0x0010);
        reg_w(dev, 0x01, 0x0001);
@@ -6829,23 +6832,23 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        reg_w(dev, 0x03, 0x0012);
        reg_w(dev, 0x01, 0x0012);
        reg_w(dev, 0x05, 0x0012);
-       retbyte = i2c_read(dev, 0x14);
+       retbyte = i2c_read(gspca_dev, 0x14);
        if (retbyte != 0)
                return 0x11;                    /* HV7131R */
-       retbyte = i2c_read(dev, 0x15);
+       retbyte = i2c_read(gspca_dev, 0x15);
        if (retbyte != 0)
                return 0x11;                    /* HV7131R */
-       retbyte = i2c_read(dev, 0x16);
+       retbyte = i2c_read(gspca_dev, 0x16);
        if (retbyte != 0)
                return 0x11;                    /* HV7131R */
 
        reg_w(dev, 0x02, 0x0010);
-       reg_r(dev, 0x000b, &retbyte);
+       retbyte = reg_r(gspca_dev, 0x000b);
        checkword = retbyte << 8;
-       reg_r(dev, 0x000a, &retbyte);
+       retbyte = reg_r(gspca_dev, 0x000a);
        checkword |= retbyte;
        PDEBUG(D_PROBE, "probe 3wr vga 1 0x%04x", checkword);
-       reg_r(dev, 0x0010, &retbyte);
+       reg_r(gspca_dev, 0x0010);
        /* this is tested only once anyway */
        i = 0;
        while (chipset_revision_sensor[i].revision) {
@@ -6863,7 +6866,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        reg_w(dev, 0x0a, 0x0010);
        reg_w(dev, 0x03, 0x0012);
        reg_w(dev, 0x01, 0x0012);
-       retbyte = i2c_read(dev, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x00);
        if (retbyte != 0) {
                PDEBUG(D_PROBE, "probe 3wr vga type 0a ?");
                return 0x0a;                    /* ?? */
@@ -6876,7 +6879,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        reg_w(dev, 0x03, 0x0012);
        msleep(2);
        reg_w(dev, 0x01, 0x0012);
-       retbyte = i2c_read(dev, 0x00);
+       retbyte = i2c_read(gspca_dev, 0x00);
        if (retbyte != 0) {
                PDEBUG(D_PROBE, "probe 3wr vga type %02x", retbyte);
                send_unknown(dev, SENSOR_GC0305);
@@ -6890,8 +6893,8 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        reg_w(dev, 0x06, 0x0010);
        reg_w(dev, 0x01, 0x0012);
        reg_w(dev, 0x05, 0x0012);
-       if (i2c_read(dev, 0x1c) == 0x7f /* OV7610 - manufacturer ID */
-           && i2c_read(dev, 0x1d) == 0xa2) {
+       if (i2c_read(gspca_dev, 0x1c) == 0x7f   /* OV7610 - manufacturer ID */
+           && i2c_read(gspca_dev, 0x1d) == 0xa2) {
                send_unknown(dev, SENSOR_OV7620);
                return 0x06;            /* OmniVision confirm ? */
        }
@@ -6905,13 +6908,13 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
 /*     msleep(150); */
        reg_w(dev, 0x01, 0x12);
        reg_w(dev, 0x05, 0x12);
-       retbyte = i2c_read(dev, 0x00);          /* ID 0 */
+       retbyte = i2c_read(gspca_dev, 0x00);            /* ID 0 */
        checkword = retbyte << 8;
-       retbyte = i2c_read(dev, 0x01);          /* ID 1 */
+       retbyte = i2c_read(gspca_dev, 0x01);            /* ID 1 */
        checkword |= retbyte;
        PDEBUG(D_PROBE, "probe 3wr vga 2 0x%04x", checkword);
        if (checkword == 0x2030) {
-               retbyte = i2c_read(dev, 0x02);  /* revision number */
+               retbyte = i2c_read(gspca_dev, 0x02);    /* revision number */
                PDEBUG(D_PROBE, "sensor PO2030 rev 0x%02x", retbyte);
                send_unknown(dev, SENSOR_PO2030);
                return checkword;
@@ -6925,7 +6928,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
        reg_w(dev, 0x01, 0x12);
        reg_w(dev, 0x05, 0x01);
        reg_w(dev, 0xd3, 0x8b);
-       retbyte = i2c_read(dev, 0x01);
+       retbyte = i2c_read(gspca_dev, 0x01);
        if (retbyte != 0) {
                PDEBUG(D_PROBE, "probe 3wr vga type 0a ?");
                return 0x0a;                    /* ?? */
@@ -6936,7 +6939,6 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev)
 static int zcxx_probeSensor(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;
-       struct usb_device *dev = gspca_dev->dev;
        int sensor, sensor2;
 
        switch (sd->sensor) {
@@ -6944,7 +6946,7 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev)
        case SENSOR_TAS5130C_VF0250:
                return -1;              /* don't probe */
        }
-       sensor = vga_2wr_probe(dev);
+       sensor = vga_2wr_probe(gspca_dev);
        if (sensor >= 0) {
                if (sensor < 0x7600)
                        return sensor;
@@ -6956,7 +6958,7 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev)
                        return sensor;
                return sensor2;
        }
-       return sif_probe(dev);
+       return sif_probe(gspca_dev);
 }
 
 /* this function is called at probe time */
@@ -6966,7 +6968,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
        struct sd *sd = (struct sd *) gspca_dev;
        struct cam *cam;
        int sensor;
-       __u8 bsensor;
        int vga = 1;            /* 1: vga, 0: sif */
        static const __u8 gamma[SENSOR_MAX] = {
                5,      /* SENSOR_CS2102 0 */
@@ -7122,7 +7123,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
                        reg_w(gspca_dev->dev, 0x02, 0x0010);
                else
                        reg_w(gspca_dev->dev, sensor & 0x0f, 0x0010);
-               reg_r(gspca_dev->dev, 0x0010, &bsensor);
+               reg_r(gspca_dev, 0x0010);
        }
 
        cam = &gspca_dev->cam;
@@ -7163,7 +7164,6 @@ static void sd_start(struct gspca_dev *gspca_dev)
        struct usb_device *dev = gspca_dev->dev;
        const struct usb_action *zc3_init;
        int mode;
-       __u8 retbyte;
        static const struct usb_action *init_tb[SENSOR_MAX][2] = {
                {cs2102_InitialScale, cs2102_Initial},          /* 0 */
                {cs2102K_InitialScale, cs2102K_Initial},        /* 1 */
@@ -7194,7 +7194,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
                zcxx_probeSensor(gspca_dev);
                break;
        case SENSOR_PAS106:
-               usb_exchange(dev, pas106b_Initial_com);
+               usb_exchange(gspca_dev, pas106b_Initial_com);
                break;
        case SENSOR_PB0330:
                if (mode) {
@@ -7210,14 +7210,14 @@ static void sd_start(struct gspca_dev *gspca_dev)
                }
                break;
        }
-       usb_exchange(dev, zc3_init);
+       usb_exchange(gspca_dev, zc3_init);
 
        switch (sd->sensor) {
        case SENSOR_GC0305:
        case SENSOR_OV7620:
        case SENSOR_PO2030:
                msleep(100);                    /* ?? */
-               reg_r(dev, 0x0002, &retbyte);   /* --> 0x40 */
+               reg_r(gspca_dev, 0x0002);       /* --> 0x40 */
                reg_w(dev, 0x09, 0x01ad);       /* (from win traces) */
                reg_w(dev, 0x15, 0x01ae);
                reg_w(dev, 0x0d, 0x003a);
@@ -7230,11 +7230,11 @@ static void sd_start(struct gspca_dev *gspca_dev)
        setbrightness(gspca_dev);
        switch (sd->sensor) {
        case SENSOR_OV7620:
-               reg_r(dev, 0x0008, &retbyte);
+               reg_r(gspca_dev, 0x0008);
                reg_w(dev, 0x00, 0x0008);
                break;
        case SENSOR_GC0305:
-               reg_r(dev, 0x0008, &retbyte);
+               reg_r(gspca_dev, 0x0008);
                /* fall thru */
        case SENSOR_PO2030:
                reg_w(dev, 0x03, 0x0008);
@@ -7259,7 +7259,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
        setmatrix(gspca_dev);                   /* one more time? */
        switch (sd->sensor) {
        case SENSOR_OV7620:
-               reg_r(dev, 0x0180, &retbyte);   /* from win */
+               reg_r(gspca_dev, 0x0180);       /* from win */
                reg_w(dev, 0x00, 0x0180);
                break;
        default:
@@ -7277,7 +7277,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
                break;
        case SENSOR_PO2030:
                reg_w(dev, 0x40, 0x0117);       /* (from win traces) */
-               reg_r(dev, 0x0180, &retbyte);
+               reg_r(gspca_dev, 0x0180);
                break;
        }
 
@@ -7289,22 +7289,23 @@ static void sd_start(struct gspca_dev *gspca_dev)
                reg_w(dev, 0x15, 0x01ae);
                reg_w(dev, 0x40, 0x0180);
                reg_w(dev, 0x40, 0x0117);
-               reg_r(dev, 0x0180, &retbyte);
+               reg_r(gspca_dev, 0x0180);
                sd->autogain = 1;
                setautogain(gspca_dev);
                break;
        case SENSOR_OV7620:
-               i2c_read(dev, 0x13);            /*fixme: returns 0xa3 */
-               i2c_write(dev, 0x13, 0xa3, 0x00); /*fixme: same to send? */
+               i2c_read(gspca_dev, 0x13);      /*fixme: returns 0xa3 */
+               i2c_write(gspca_dev, 0x13, 0xa3, 0x00);
+                                        /*fixme: returned value to send? */
                reg_w(dev, 0x40, 0x0117);       /* (from win traces) */
-               reg_r(dev, 0x0180, &retbyte);
+               reg_r(gspca_dev, 0x0180);
                setautogain(gspca_dev);
                msleep(500);
                break;
        case SENSOR_PO2030:
                msleep(500);
-               reg_r(dev, 0x0008, &retbyte);
-               reg_r(dev, 0x0007, &retbyte);
+               reg_r(gspca_dev, 0x0008);
+               reg_r(gspca_dev, 0x0007);
                reg_w(dev, 0x00, 0x0007);       /* (from win traces) */
                reg_w(dev, 0x02, 0x0008);
                break;