spca561: Input buffer may be changed on reg write.
(all sd): Cleanup code, 'const' added.
Signed-off-by: Jean-Francois Moine <moinejf@free.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
#define CONEX_CAM 1 /* special JPEG header */
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 3)
-static const char version[] = "2.1.3";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA USB Conexant Camera Driver");
reg_w(gspca_dev->dev, 0x006a, &val, 1);
}
-static __u8 cxsensor[] = {
+static const __u8 cxsensor[] = {
0x88, 0x12, 0x70, 0x01,
0x88, 0x0d, 0x02, 0x01,
0x88, 0x0f, 0x00, 0x01,
0x00
};
-static __u8 reg20[] = { 0x10, 0x42, 0x81, 0x19, 0xd3, 0xff, 0xa7, 0xff };
-static __u8 reg28[] = { 0x87, 0x00, 0x87, 0x00, 0x8f, 0xff, 0xea, 0xff };
-static __u8 reg10[] = { 0xb1, 0xb1 };
-static __u8 reg71a[] = { 0x08, 0x18, 0x0a, 0x1e }; /* 640 */
-static __u8 reg71b[] = { 0x04, 0x0c, 0x05, 0x0f };
+static const __u8 reg20[] = { 0x10, 0x42, 0x81, 0x19, 0xd3, 0xff, 0xa7, 0xff };
+static const __u8 reg28[] = { 0x87, 0x00, 0x87, 0x00, 0x8f, 0xff, 0xea, 0xff };
+static const __u8 reg10[] = { 0xb1, 0xb1 };
+static const __u8 reg71a[] = { 0x08, 0x18, 0x0a, 0x1e }; /* 640 */
+static const __u8 reg71b[] = { 0x04, 0x0c, 0x05, 0x0f };
/* 352{0x04,0x0a,0x06,0x12}; //352{0x05,0x0e,0x06,0x11}; //352 */
-static __u8 reg71c[] = { 0x02, 0x07, 0x03, 0x09 };
+static const __u8 reg71c[] = { 0x02, 0x07, 0x03, 0x09 };
/* 320{0x04,0x0c,0x05,0x0f}; //320 */
-static __u8 reg71d[] = { 0x02, 0x07, 0x03, 0x09 }; /* 176 */
-static __u8 reg7b[] = { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
+static const __u8 reg71d[] = { 0x02, 0x07, 0x03, 0x09 }; /* 176 */
+static const __u8 reg7b[] = { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff };
static void cx_sensor(struct gspca_dev*gspca_dev)
{
- __u8 val = 0;
+ __u8 val;
int i = 0;
__u8 bufread[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
- int length = 0;
- __u8 *ptsensor = cxsensor;
+ int length;
+ const __u8 *ptsensor = cxsensor;
reg_w(gspca_dev->dev, 0x0020, reg20, 8);
reg_w(gspca_dev->dev, 0x0028, reg28, 8);
reg_r(gspca_dev->dev, 0x00e7, bufread, 8);
}
-static __u8 cx_inits_176[] = {
+static const __u8 cx_inits_176[] = {
0x33, 0x81, 0xB0, 0x00, 0x90, 0x00, 0x0A, 0x03, /* 176x144 */
0x00, 0x03, 0x03, 0x03, 0x1B, 0x05, 0x30, 0x03,
0x65, 0x15, 0x18, 0x25, 0x03, 0x25, 0x08, 0x30,
0xF7, 0xFF, 0x88, 0xFF, 0x66, 0x02, 0x28, 0x02,
0x1E, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
-static __u8 cx_inits_320[] = {
+static const __u8 cx_inits_320[] = {
0x7f, 0x7f, 0x40, 0x01, 0xf0, 0x00, 0x02, 0x01,
0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x02, 0x01,
0x65, 0x45, 0xfa, 0x4c, 0x2c, 0xdf, 0xb9, 0x81,
0xf5, 0xff, 0x6d, 0xff, 0xf6, 0x01, 0x43, 0x02,
0xd3, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
-static __u8 cx_inits_352[] = {
+static const __u8 cx_inits_352[] = {
0x2e, 0x7c, 0x60, 0x01, 0x20, 0x01, 0x05, 0x03,
0x00, 0x06, 0x03, 0x06, 0x1b, 0x10, 0x05, 0x3b,
0x30, 0x25, 0x18, 0x25, 0x08, 0x30, 0x03, 0x25,
0xf5, 0xff, 0x6b, 0xff, 0xee, 0x01, 0x43, 0x02,
0xe4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
-static __u8 cx_inits_640[] = {
+static const __u8 cx_inits_640[] = {
0x7e, 0x7e, 0x80, 0x02, 0xe0, 0x01, 0x01, 0x01,
0x00, 0x02, 0x01, 0x02, 0x10, 0x30, 0x01, 0x01,
0x65, 0x45, 0xf7, 0x52, 0x2c, 0xdf, 0xb9, 0x81,
static int cx11646_initsize(struct gspca_dev *gspca_dev)
{
- __u8 *cxinit;
+ const __u8 *cxinit;
__u8 val;
static const __u8 reg12[] = { 0x08, 0x05, 0x07, 0x04, 0x24 };
static const __u8 reg17[] =
return val;
}
-static __u8 cx_jpeg_init[][8] = {
+static const __u8 cx_jpeg_init[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x15}, /* 1 */
{0x0f, 0x10, 0x12, 0x10, 0x0d, 0x15, 0x12, 0x11},
{0x12, 0x18, 0x16, 0x15, 0x19, 0x20, 0x35, 0x22},
};
-static __u8 cxjpeg_640[][8] = {
+static const __u8 cxjpeg_640[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x10}, /* 1 */
{0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d},
{0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28, 0x1a},
{0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00},
{0xFF, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} /* 27 */
};
-static __u8 cxjpeg_352[][8] = {
+static const __u8 cxjpeg_352[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x0d},
{0x09, 0x09, 0x0b, 0x09, 0x08, 0x0D, 0x0b, 0x0a},
{0x0b, 0x0e, 0x0d, 0x0d, 0x0f, 0x13, 0x1f, 0x14},
{0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00},
{0xFF, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
};
-static __u8 cxjpeg_320[][8] = {
+static const __u8 cxjpeg_320[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x05},
{0x03, 0x04, 0x04, 0x04, 0x03, 0x05, 0x04, 0x04},
{0x04, 0x05, 0x05, 0x05, 0x06, 0x07, 0x0c, 0x08},
{0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00},
{0xFF, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} /* 27 */
};
-static __u8 cxjpeg_176[][8] = {
+static const __u8 cxjpeg_176[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x0d},
{0x09, 0x09, 0x0B, 0x09, 0x08, 0x0D, 0x0B, 0x0A},
{0x0B, 0x0E, 0x0D, 0x0D, 0x0F, 0x13, 0x1F, 0x14},
{0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00},
{0xFF, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
};
-static __u8 cxjpeg_qtable[][8] = { /* 640 take with the zcx30x part */
+/* 640 take with the zcx30x part */
+static const __u8 cxjpeg_qtable[][8] = {
{0xff, 0xd8, 0xff, 0xdb, 0x00, 0x84, 0x00, 0x08},
{0x06, 0x06, 0x07, 0x06, 0x05, 0x08, 0x07, 0x07},
{0x07, 0x09, 0x09, 0x08, 0x0a, 0x0c, 0x14, 0x0a},
reg_w(gspca_dev->dev, 0x0055, &val, 1);
}
-static __u8 reg12[] = { 0x0a, 0x05, 0x07, 0x04, 0x19 };
-static __u8 regE5_8[] = { 0x88, 0x00, 0xd4, 0x01, 0x88, 0x01, 0x01, 0x01 };
-static __u8 regE5a[] = { 0x88, 0x0a, 0x0c, 0x01 };
-static __u8 regE5b[] = { 0x88, 0x0b, 0x12, 0x01 };
-static __u8 regE5c[] = { 0x88, 0x05, 0x01, 0x01 };
-static __u8 reg51[] = { 0x77, 0x03 };
-static __u8 reg70 = 0x03;
+static const __u8 reg12[] = { 0x0a, 0x05, 0x07, 0x04, 0x19 };
+static const __u8 regE5_8[] =
+ { 0x88, 0x00, 0xd4, 0x01, 0x88, 0x01, 0x01, 0x01 };
+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;
static void cx11646_jpeg(struct gspca_dev*gspca_dev)
{
__u8 val;
int i;
- int length = 8;
- __u8 Reg55 = 0x14;
- __u8 bufread[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
- int retry = 50;
+ 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, 0x00c0, &val, 1);
reg_r(gspca_dev->dev, 0x0001, &val, 1);
+ length = 8;
switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) {
case 0:
for (i = 0; i < 27; i++) {
val = 0x00;
reg_w(gspca_dev->dev, 0x0000, &val, 1);
/* wait for completion */
+ retry = 50;
while (retry--) {
reg_r(gspca_dev->dev, 0x0002, &val, 1);
/* 0x07 until 0x00 */
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); */
+/* val= 0x60; */
+/* reg_w(gspca_dev->dev, 0x00, 0x00, 0x003d, &val, 1); */
reg_r(gspca_dev->dev, 0x0099, &val, 1); /* ->0x07 */
while (cx_sensor_init[i][0]) {
cam->cam_mode = vga_mode;
cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
- sd->qindex = 0; /* set the quantization table */
+ sd->qindex = 0; /* set the quantization */
sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
if (data[0] == 0xff && data[1] == 0xd8) {
{
struct sd *sd = (struct sd *) gspca_dev;
__u8 regE5cbx[] = { 0x88, 0x00, 0xd4, 0x01, 0x88, 0x01, 0x01, 0x01 };
- __u8 reg51c[] = { 0x77, 0x03 };
+ __u8 reg51c[2];
__u8 bright;
__u8 colors;
__u8 val;
__u8 bufread[8];
bright = sd->brightness;
- colors = sd->colors;
regE5cbx[2] = bright;
- reg51c[1] = colors;
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 */
+ 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, ®70, 1);
{
struct sd *sd = (struct sd *) gspca_dev;
__u8 regE5acx[] = { 0x88, 0x0a, 0x0c, 0x01 }; /* seem MSB */
- /* __u8 regE5bcx[]={0x88,0x0b,0x12,0x01}; // LSB */
- __u8 reg51c[] = { 0x77, 0x03 };
+/* __u8 regE5bcx[] = { 0x88, 0x0b, 0x12, 0x01}; * LSB */
+ __u8 reg51c[2];
__u8 val;
- reg51c[1] = sd->colors;
regE5acx[2] = sd->contrast;
reg_w(gspca_dev->dev, 0x00e5, regE5acx, 4);
reg_r(gspca_dev->dev, 0x00e8, &val, 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, ®70, 1);
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 3)
-static const char version[] = "2.1.3";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("Etoms USB Camera Driver");
static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
{
{
.id = V4L2_CID_BRIGHTNESS,
.minimum = 1,
.maximum = 127,
.step = 1,
- .default_value = 63,
+#define BRIGHTNESS_DEF 63
+ .default_value = BRIGHTNESS_DEF,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
-#define SD_CONTRAST 1
{
{
.id = V4L2_CID_CONTRAST,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define CONTRAST_DEF 127
+ .default_value = CONTRAST_DEF,
},
.set = sd_setcontrast,
.get = sd_getcontrast,
},
-#define SD_COLOR 2
{
{
.id = V4L2_CID_SATURATION,
.minimum = 0,
.maximum = 15,
.step = 1,
- .default_value = 7,
+#define COLOR_DEF 7
+ .default_value = COLOR_DEF,
},
.set = sd_setcolors,
.get = sd_getcolors,
},
-#define SD_AUTOGAIN 3
{
{
.id = V4L2_CID_AUTOGAIN,
.minimum = 0,
.maximum = 1,
.step = 1,
- .default_value = 1,
+#define AUTOGAIN_DEF 1
+ .default_value = AUTOGAIN_DEF,
},
.set = sd_setautogain,
.get = sd_getautogain,
#define PAS106_REG0e 0x0e /* global gain [4..0](default 0x0e) */
#define PAS106_REG13 0x13 /* end i2c write */
-static __u8 GainRGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 };
+static const __u8 GainRGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 };
-static __u8 I2c2[] = { 0x08, 0x08, 0x08, 0x08, 0x0d };
+static const __u8 I2c2[] = { 0x08, 0x08, 0x08, 0x08, 0x0d };
-static __u8 I2c3[] = { 0x12, 0x05 };
+static const __u8 I2c3[] = { 0x12, 0x05 };
-static __u8 I2c4[] = { 0x41, 0x08 };
+static const __u8 I2c4[] = { 0x41, 0x08 };
static void reg_r(struct usb_device *dev,
__u16 index, __u8 *buffer, int len)
0, index, buffer, len, 500);
}
+static void reg_w_val(struct usb_device *dev,
+ __u16 index, __u8 val)
+{
+ __u8 data;
+
+ data = val;
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ 0, index, &data, 1, 500);
+}
+
static void reg_w(struct usb_device *dev,
- __u16 index, __u8 *buffer, __u16 len)
+ __u16 index, const __u8 *buffer, __u16 len)
{
__u8 tmpbuf[8];
0, index, tmpbuf, len, 500);
}
-static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 *buffer,
- __u16 length, __u8 mode)
+static int Et_i2cwrite(struct usb_device *dev, __u8 reg,
+ const __u8 *buffer,
+ __u16 len, __u8 mode)
{
-/* buffer should be [D0..D7] */
- int i, j;
- __u8 base = 0x40; /* sensor base for the pas106 */
- __u8 ptchcount = 0;
-
- ptchcount = (((length & 0x07) << 4) | (mode & 0x03));
-/* set the base address */
- reg_w(dev, ET_I2C_BASE, &base, 1);
-/* set count and prefetch */
- reg_w(dev, ET_I2C_COUNT, &ptchcount, 1);
-/* set the register base */
- reg_w(dev, ET_I2C_REG, ®, 1);
- j = length - 1;
- for (i = 0; i < length; i++) {
- reg_w(dev, (ET_I2C_DATA0 + j), &buffer[j], 1);
- j--;
- }
+ /* buffer should be [D0..D7] */
+ __u8 ptchcount;
+
+ /* set the base address */
+ reg_w_val(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);
+ /* set the register base */
+ reg_w_val(dev, ET_I2C_REG, reg);
+ while (--len >= 0)
+ reg_w_val(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 Et_i2cread(struct usb_device *dev, __u8 reg,
+ __u8 *buffer,
+ __u16 length, __u8 mode)
{
-/* buffer should be [D0..D7] */
+ /* buffer should be [D0..D7] */
int i, j;
- __u8 base = 0x40; /* sensor base for the pas106 */
__u8 ptchcount;
- __u8 prefetch = 0x02;
-
- ptchcount = (((length & 0x07) << 4) | (mode & 0x03));
-/* set the base address */
- reg_w(dev, ET_I2C_BASE, &base, 1);
-/* set count and prefetch */
- reg_w(dev, ET_I2C_COUNT, &ptchcount, 1);
-/* set the register base */
- reg_w(dev, ET_I2C_REG, ®, 1);
- reg_w(dev, ET_I2C_PREFETCH, &prefetch, 1);
- prefetch = 0x00;
- reg_w(dev, ET_I2C_PREFETCH, &prefetch, 1);
+
+ /* 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);
return 0;
}
-static int Et_videoOff(struct usb_device *dev)
+static int et_video(struct usb_device *dev, int on)
{
int err;
- __u8 stopvideo = 0;
- reg_w(dev, ET_GPIO_OUT, &stopvideo, 1);
+ reg_w_val(dev, ET_GPIO_OUT, on
+ ? 0x10 /* startvideo - set Bit5 */
+ : 0); /* stopvideo */
err = Et_WaitStatus(dev);
if (!err)
- PDEBUG(D_ERR, "timeout Et_waitStatus VideoON");
- return err;
-}
-
-static int Et_videoOn(struct usb_device *dev)
-{
- int err;
- __u8 startvideo = 0x10; /* set Bit5 */
-
- reg_w(dev, ET_GPIO_OUT, &startvideo, 1);
- err = Et_WaitStatus(dev);
- if (!err)
- PDEBUG(D_ERR, "timeout Et_waitStatus VideoOFF");
+ PDEBUG(D_ERR, "timeout video on/off");
return err;
}
static void Et_init2(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 value = 0x00;
- __u8 received = 0x00;
- __u8 FormLine[] = { 0x84, 0x03, 0x14, 0xf4, 0x01, 0x05 };
+ __u8 value;
+ __u8 received;
+ static const __u8 FormLine[] = { 0x84, 0x03, 0x14, 0xf4, 0x01, 0x05 };
PDEBUG(D_STREAM, "Open Init2 ET");
- value = 0x2f;
- reg_w(dev, ET_GPIO_DIR_CTRL, &value, 1);
- value = 0x10;
- reg_w(dev, ET_GPIO_OUT, &value, 1);
+ 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);
- value = 0x14; /* 0x14 // 0x16 enabled pattern */
- reg_w(dev, ET_ClCK, &value, 1);
- value = 0x1b;
- reg_w(dev, ET_CTRL, &value, 1);
+ reg_w_val(dev, ET_ClCK, 0x14); /* 0x14 // 0x16 enabled pattern */
+ reg_w_val(dev, ET_CTRL, 0x1b);
/* compression et subsampling */
if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode)
value = ET_COMP_VAL1; /* 320 */
else
value = ET_COMP_VAL0; /* 640 */
- reg_w(dev, ET_COMP, &value, 1);
- value = 0x1f;
- reg_w(dev, ET_MAXQt, &value, 1);
- value = 0x04;
- reg_w(dev, ET_MINQt, &value, 1);
+ reg_w_val(dev, ET_COMP, value);
+ reg_w_val(dev, ET_MAXQt, 0x1f);
+ reg_w_val(dev, ET_MINQt, 0x04);
/* undocumented registers */
- value = 0xff;
- reg_w(dev, ET_REG1d, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG1e, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG1f, &value, 1);
- value = 0x35;
- reg_w(dev, ET_REG20, &value, 1);
- value = 0x01;
- reg_w(dev, ET_REG21, &value, 1);
- value = 0x00;
- reg_w(dev, ET_REG22, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG23, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG24, &value, 1);
- value = 0x0f;
- reg_w(dev, ET_REG25, &value, 1);
+ 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);
/* colors setting */
- value = 0x11;
- reg_w(dev, 0x30, &value, 1); /* 0x30 */
- value = 0x40;
- reg_w(dev, 0x31, &value, 1);
- value = 0x00;
- reg_w(dev, 0x32, &value, 1);
- value = 0x00;
- reg_w(dev, ET_O_RED, &value, 1); /* 0x34 */
- value = 0x00;
- reg_w(dev, ET_O_GREEN1, &value, 1);
- value = 0x00;
- reg_w(dev, ET_O_BLUE, &value, 1);
- value = 0x00;
- reg_w(dev, ET_O_GREEN2, &value, 1);
+ 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);
/*************/
- value = 0x80;
- reg_w(dev, ET_G_RED, &value, 1); /* 0x4d */
- value = 0x80;
- reg_w(dev, ET_G_GREEN1, &value, 1);
- value = 0x80;
- reg_w(dev, ET_G_BLUE, &value, 1);
- value = 0x80;
- reg_w(dev, ET_G_GREEN2, &value, 1);
- value = 0x00;
- reg_w(dev, ET_G_GR_H, &value, 1);
- value = 0x00;
- reg_w(dev, ET_G_GB_H, &value, 1); /* 0x52 */
+ 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 */
/* Window control registers */
-
- value = 0x80; /* use cmc_out */
- reg_w(dev, 0x61, &value, 1);
-
- value = 0x02;
- reg_w(dev, 0x62, &value, 1);
- value = 0x03;
- reg_w(dev, 0x63, &value, 1);
- value = 0x14;
- reg_w(dev, 0x64, &value, 1);
- value = 0x0e;
- reg_w(dev, 0x65, &value, 1);
- value = 0x02;
- reg_w(dev, 0x66, &value, 1);
- value = 0x02;
- reg_w(dev, 0x67, &value, 1);
+ 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);
/**************************************/
- value = 0x8f;
- reg_w(dev, ET_SYNCHRO, &value, 1); /* 0x68 */
- value = 0x69; /* 0x6a //0x69 */
- reg_w(dev, ET_STARTX, &value, 1);
- value = 0x0d; /* 0x0d //0x0c */
- reg_w(dev, ET_STARTY, &value, 1);
- value = 0x80;
- reg_w(dev, ET_WIDTH_LOW, &value, 1);
- value = 0xe0;
- reg_w(dev, ET_HEIGTH_LOW, &value, 1);
- value = 0x60;
- reg_w(dev, ET_W_H_HEIGTH, &value, 1); /* 6d */
- value = 0x86;
- reg_w(dev, ET_REG6e, &value, 1);
- value = 0x01;
- reg_w(dev, ET_REG6f, &value, 1);
- value = 0x26;
- reg_w(dev, ET_REG70, &value, 1);
- value = 0x7a;
- reg_w(dev, ET_REG71, &value, 1);
- value = 0x01;
- reg_w(dev, ET_REG72, &value, 1);
+ 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);
/* Clock Pattern registers ***************** */
- value = 0x00;
- reg_w(dev, ET_REG73, &value, 1);
- value = 0x18; /* 0x28 */
- reg_w(dev, ET_REG74, &value, 1);
- value = 0x0f; /* 0x01 */
- reg_w(dev, ET_REG75, &value, 1);
+ reg_w_val(dev, ET_REG73, 0x00);
+ reg_w_val(dev, ET_REG74, 0x18); /* 0x28 */
+ reg_w_val(dev, ET_REG75, 0x0f); /* 0x01 */
/**********************************************/
- value = 0x20;
- reg_w(dev, 0x8a, &value, 1);
- value = 0x0f;
- reg_w(dev, 0x8d, &value, 1);
- value = 0x08;
- reg_w(dev, 0x8e, &value, 1);
+ reg_w_val(dev, 0x8a, 0x20);
+ reg_w_val(dev, 0x8d, 0x0f);
+ reg_w_val(dev, 0x8e, 0x08);
/**************************************/
- value = 0x08;
- reg_w(dev, 0x03, &value, 1);
- value = 0x03;
- reg_w(dev, ET_PXL_CLK, &value, 1);
- value = 0xff;
- reg_w(dev, 0x81, &value, 1);
- value = 0x00;
- reg_w(dev, 0x80, &value, 1);
- value = 0xff;
- reg_w(dev, 0x81, &value, 1);
- value = 0x20;
- reg_w(dev, 0x80, &value, 1);
- value = 0x01;
- reg_w(dev, 0x03, &value, 1);
- value = 0x00;
- reg_w(dev, 0x03, &value, 1);
- value = 0x08;
- reg_w(dev, 0x03, &value, 1);
+ 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_r(dev,0x0,ET_I2C_BASE,&received,1);
+/* reg_r(dev, ET_I2C_BASE, &received, 1);
always 0x40 as the pas106 ??? */
/* set the sensor */
- if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) {
- value = 0x04; /* 320 */
- reg_w(dev, ET_PXL_CLK, &value, 1);
- /* now set by fifo the FormatLine setting */
- reg_w(dev, 0x62, FormLine, 6);
- } else { /* 640 */
- /* setting PixelClock
- 0x03 mean 24/(3+1) = 6 Mhz
- 0x05 -> 24/(5+1) = 4 Mhz
- 0x0b -> 24/(11+1) = 2 Mhz
- 0x17 -> 24/(23+1) = 1 Mhz
- */
- value = 0x1e; /* 0x17 */
- reg_w(dev, ET_PXL_CLK, &value, 1);
- /* now set by fifo the FormatLine setting */
- reg_w(dev, 0x62, FormLine, 6);
- }
+ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode)
+ value = 0x04; /* 320 */
+ else /* 640 */
+ value = 0x1e; /* 0x17 * setting PixelClock
+ * 0x03 mean 24/(3+1) = 6 Mhz
+ * 0x05 -> 24/(5+1) = 4 Mhz
+ * 0x0b -> 24/(11+1) = 2 Mhz
+ * 0x17 -> 24/(23+1) = 1 Mhz
+ */
+ reg_w_val(dev, ET_PXL_CLK, value);
+ /* now set by fifo the FormatLine setting */
+ reg_w(dev, 0x62, FormLine, 6);
/* set exposure times [ 0..0x78] 0->longvalue 0x78->shortvalue */
- value = 0x47; /* 0x47; */
- reg_w(dev, 0x81, &value, 1);
- value = 0x40; /* 0x40; */
- reg_w(dev, 0x80, &value, 1);
+ reg_w_val(dev, 0x81, 0x47); /* 0x47; */
+ reg_w_val(dev, 0x80, 0x40); /* 0x40; */
/* Pedro change */
/* Brightness change Brith+ decrease value */
/* Brigth- increase value */
/* original value = 0x70; */
- value = 0x30; /* 0x20; */
- reg_w(dev, 0x81, &value, 1); /* set brightness */
- value = 0x20; /* 0x20; */
- reg_w(dev, 0x80, &value, 1);
+ reg_w_val(dev, 0x81, 0x30); /* 0x20; - set brightness */
+ reg_w_val(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;
- static __u8 I2cc[] = { 0x05, 0x02, 0x02, 0x05, 0x0d };
+ __u8 I2cc[] = { 0x05, 0x02, 0x02, 0x05, 0x0d };
__u8 i2cflags = 0x01;
/* __u8 green = 0; */
__u8 colors = sd->colors;
/* 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);
+ Et_i2cwrite(dev, PAS106_REG9, I2cc, sizeof I2cc, 1);
}
/* PDEBUG(D_CONF , "Etoms red %d blue %d green %d",
I2cc[3], I2cc[0], green); */
static void getcolors(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
- /* __u8 valblue = 0; */
+/* __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, &valblue, 1, 1); */
Et_i2cread(gspca_dev->dev, PAS106_REG9 + 3, &valred, 1, 1);
sd->colors = valred & 0x0f;
}
static void Et_init1(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 value = 0x00;
- __u8 received = 0x00;
-/* __u8 I2c0 [] ={0x0a,0x12,0x05,0x22,0xac,0x00,0x01,0x00}; */
+ __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 */
-/* __u8 I2c0 [] ={0x0a,0x12,0x05,0xfe,0xfe,0xc0,0x01,0x00};
+/* __u8 I2c0 [] = {0x0a, 0x12, 0x05, 0xfe, 0xfe, 0xc0, 0x01, 0x00};
* 1/60000 hmm ?? */
PDEBUG(D_STREAM, "Open Init1 ET");
- value = 7;
- reg_w(dev, ET_GPIO_DIR_CTRL, &value, 1);
+ reg_w_val(dev, ET_GPIO_DIR_CTRL, 7);
reg_r(dev, ET_GPIO_IN, &received, 1);
- value = 1;
- reg_w(dev, ET_RESET_ALL, &value, 1);
- value = 0;
- reg_w(dev, ET_RESET_ALL, &value, 1);
- value = 0x10;
- reg_w(dev, ET_ClCK, &value, 1);
- value = 0x19;
- reg_w(dev, ET_CTRL, &value, 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);
/* compression et subsampling */
if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode)
value = ET_COMP_VAL1;
else
value = ET_COMP_VAL0;
-
PDEBUG(D_STREAM, "Open mode %d Compression %d",
gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode,
value);
- reg_w(dev, ET_COMP, &value, 1);
- value = 0x1d;
- reg_w(dev, ET_MAXQt, &value, 1);
- value = 0x02;
- reg_w(dev, ET_MINQt, &value, 1);
+ reg_w_val(dev, ET_COMP, value);
+ reg_w_val(dev, ET_MAXQt, 0x1d);
+ reg_w_val(dev, ET_MINQt, 0x02);
/* undocumented registers */
- value = 0xff;
- reg_w(dev, ET_REG1d, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG1e, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG1f, &value, 1);
- value = 0x35;
- reg_w(dev, ET_REG20, &value, 1);
- value = 0x01;
- reg_w(dev, ET_REG21, &value, 1);
- value = 0x00;
- reg_w(dev, ET_REG22, &value, 1);
- value = 0xf7;
- reg_w(dev, ET_REG23, &value, 1);
- value = 0xff;
- reg_w(dev, ET_REG24, &value, 1);
- value = 0x07;
- reg_w(dev, ET_REG25, &value, 1);
+ 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);
/* colors setting */
- value = 0x80;
- reg_w(dev, ET_G_RED, &value, 1);
- value = 0x80;
- reg_w(dev, ET_G_GREEN1, &value, 1);
- value = 0x80;
- reg_w(dev, ET_G_BLUE, &value, 1);
- value = 0x80;
- reg_w(dev, ET_G_GREEN2, &value, 1);
- value = 0x00;
- reg_w(dev, ET_G_GR_H, &value, 1);
- value = 0x00;
- reg_w(dev, ET_G_GB_H, &value, 1);
+ 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);
/* Window control registers */
- value = 0xf0;
- reg_w(dev, ET_SYNCHRO, &value, 1);
- value = 0x56; /* 0x56 */
- reg_w(dev, ET_STARTX, &value, 1);
- value = 0x05; /* 0x04 */
- reg_w(dev, ET_STARTY, &value, 1);
- value = 0x60;
- reg_w(dev, ET_WIDTH_LOW, &value, 1);
- value = 0x20;
- reg_w(dev, ET_HEIGTH_LOW, &value, 1);
- value = 0x50;
- reg_w(dev, ET_W_H_HEIGTH, &value, 1);
- value = 0x86;
- reg_w(dev, ET_REG6e, &value, 1);
- value = 0x01;
- reg_w(dev, ET_REG6f, &value, 1);
- value = 0x86;
- reg_w(dev, ET_REG70, &value, 1);
- value = 0x14;
- reg_w(dev, ET_REG71, &value, 1);
- value = 0x00;
- reg_w(dev, ET_REG72, &value, 1);
+ 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);
/* Clock Pattern registers */
- value = 0x00;
- reg_w(dev, ET_REG73, &value, 1);
- value = 0x00;
- reg_w(dev, ET_REG74, &value, 1);
- value = 0x0a;
- reg_w(dev, ET_REG75, &value, 1);
- value = 0x04;
- reg_w(dev, ET_I2C_CLK, &value, 1);
- value = 0x01;
- reg_w(dev, ET_PXL_CLK, &value, 1);
+ 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);
/* set the sensor */
if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) {
I2c0[0] = 0x06;
- Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof(I2c0), 1);
- Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof(I2c2), 1);
+ Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
+ Et_i2cwrite(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);
+ Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
/* value = 0x1f; */
value = 0x04;
Et_i2cwrite(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);
+ Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1);
+ Et_i2cwrite(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);
+ Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1);
value = 0x04;
/* value = 0x10; */
Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1);
cam->cam_mode = vga_mode;
cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
}
- sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
- sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
- sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
- sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
+ sd->brightness = BRIGHTNESS_DEF;
+ sd->contrast = CONTRAST_DEF;
+ sd->colors = COLOR_DEF;
+ sd->autogain = AUTOGAIN_DEF;
return 0;
}
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- int err;
- __u8 value;
- PDEBUG(D_STREAM, "Initialize ET1");
if (sd->sensor == SENSOR_PAS106)
Et_init1(gspca_dev);
else
Et_init2(gspca_dev);
- value = 0x08;
- reg_w(dev, ET_RESET_ALL, &value, 1);
- err = Et_videoOff(dev);
- PDEBUG(D_STREAM, "Et_Init_VideoOff %d", err);
+ reg_w_val(dev, ET_RESET_ALL, 0x08);
+ et_video(dev, 0); /* video off */
return 0;
}
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- int err;
- __u8 value;
if (sd->sensor == SENSOR_PAS106)
Et_init1(gspca_dev);
else
Et_init2(gspca_dev);
- value = 0x08;
- reg_w(dev, ET_RESET_ALL, &value, 1);
- err = Et_videoOn(dev);
- PDEBUG(D_STREAM, "Et_VideoOn %d", err);
+ reg_w_val(dev, ET_RESET_ALL, 0x08);
+ et_video(dev, 1); /* video on */
}
static void sd_stopN(struct gspca_dev *gspca_dev)
{
- int err;
-
- err = Et_videoOff(gspca_dev->dev);
- PDEBUG(D_STREAM, "Et_VideoOff %d", err);
-
+ et_video(gspca_dev->dev, 0); /* video off */
}
static void sd_stop0(struct gspca_dev *gspca_dev)
__u8 brightness = sd->brightness;
for (i = 0; i < 4; i++)
- reg_w(gspca_dev->dev, (ET_O_RED + i), &brightness, 1);
+ reg_w_val(gspca_dev->dev, (ET_O_RED + i), brightness);
}
static void getbrightness(struct gspca_dev *gspca_dev)
struct sd *sd = (struct sd *) gspca_dev;
int i;
int brightness = 0;
- __u8 value = 0;
+ __u8 value;
for (i = 0; i < 4; i++) {
reg_r(gspca_dev->dev, (ET_O_RED + i), &value, 1);
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd;
struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev,
int packet_type,
struct gspca_frame *frame,
- __u8 *data,
+ const __u8 *data,
int len)
{
int i, j;
struct v4l2_control *ctrl)
{
struct gspca_dev *gspca_dev = priv;
- struct ctrl *ctrls;
+ const struct ctrl *ctrls;
int i, ret;
for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
{
struct gspca_dev *gspca_dev = priv;
- struct ctrl *ctrls;
+ const struct ctrl *ctrls;
int i, ret;
for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
#include <media/v4l2-common.h>
#include <linux/mutex.h>
-/* values in 2.6.27 */
-#ifndef V4L2_PIX_FMT_SPCA501
-#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1')
-#endif
-#ifndef V4L2_PIX_FMT_SPCA561
-#define V4L2_PIX_FMT_SPCA561 v4l2_fourcc('S', '5', '6', '1')
-#endif
-
-/* values in 2.6.26 */
-#ifndef V4L2_CID_POWER_LINE_FREQUENCY
-#define V4L2_CID_POWER_LINE_FREQUENCY (V4L2_CID_BASE+24)
-#endif
-#ifndef V4L2_CID_WHITE_BALANCE_TEMPERATURE
-#define V4L2_CID_WHITE_BALANCE_TEMPERATURE (V4L2_CID_BASE + 26)
-#endif
-#ifndef V4L2_CID_SHARPNESS
-#define V4L2_CID_SHARPNESS (V4L2_CID_BASE+27)
-#endif
-
#ifdef CONFIG_VIDEO_ADV_DEBUG
/* GSPCA our debug messages */
extern int gspca_debug;
short width;
short height;
short mode; /* subdriver value */
- short reserved; /* subdriver value */
};
struct cam {
char *dev_name;
/* subdriver description */
struct sd_desc {
/* information */
- char *name; /* sub-driver name */
+ const char *name; /* sub-driver name */
/* controls */
- struct ctrl *ctrls;
+ const struct ctrl *ctrls;
int nctrls;
/* operations */
cam_cf_op config; /* called on probe */
struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev,
int packet_type,
struct gspca_frame *frame,
- __u8 *data,
+ const __u8 *data,
int len);
#endif /* GSPCAV2_H */
#include "gspca.h"
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
__u16 MI_buf[242];
int h_size, v_size;
int intpipe;
- /* struct usb_device *dev = pcam->dev; */
+/* struct usb_device *dev = pcam->dev; */
+
memset(data, 0, sizeof data);
memset(MI_buf, 0, sizeof MI_buf);
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) 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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x093a, 0x050f), DVNM("Mars-Semi Pc-Camera")},
{}
};
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
MODULE_DESCRIPTION("OV519 USB Camera Driver");
static int reg_w(struct sd *sd, __u16 index, __u8 value)
{
int ret;
- __u8 buf[4];
+ __u8 data;
- buf[0] = value;
+ data = 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,
- &buf[0], 1, 500);
+ &data, 1, 500);
if (ret < 0)
PDEBUG(D_ERR, "Write reg [%02x] %02x failed", index, value);
return ret;
static int reg_r(struct sd *sd, __u16 index)
{
int ret;
- __u8 buf[4];
+ __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, &buf[0], 1, 500);
+ 0, index, &data, 1, 500);
if (ret >= 0)
- ret = buf[0];
+ ret = data;
else
PDEBUG(D_ERR, "Read reg [0x%02x] failed", index);
return ret;
/* Read 8 values from a OV519 register */
static int reg_r8(struct sd *sd,
- __u16 index)
+ __u16 index)
{
int ret;
__u8 buf[8];
};
static int write_regvals(struct sd *sd,
- struct ov_regvals *regvals,
+ const struct ov_regvals *regvals,
int n)
{
int rc;
}
static int write_i2c_regvals(struct sd *sd,
- struct ov_i2c_regvals *regvals,
+ const struct ov_i2c_regvals *regvals,
int n)
{
int rc;
static int ov8xx0_configure(struct sd *sd)
{
int rc;
- static struct ov_i2c_regvals norm_8610[] = {
+ static const struct ov_i2c_regvals norm_8610[] = {
{ 0x12, 0x80 },
{ 0x00, 0x00 },
{ 0x01, 0x80 },
* 0x05 (old driver setting): very overexposed, too much
* contrast
*/
- static struct ov_i2c_regvals norm_7610[] = {
+ static const struct ov_i2c_regvals norm_7610[] = {
{ 0x10, 0xff },
{ 0x16, 0x06 },
{ 0x28, 0x24 },
{ 0x0d, 0x24 },
};
- static struct ov_i2c_regvals norm_7620[] = {
+ static const struct ov_i2c_regvals norm_7620[] = {
{ 0x00, 0x00 }, /* gain */
{ 0x01, 0x80 }, /* blue gain */
{ 0x02, 0x80 }, /* red gain */
};
/* 7640 and 7648. The defaults should be OK for most registers. */
- static struct ov_i2c_regvals norm_7640[] = {
+ static const struct ov_i2c_regvals norm_7640[] = {
{ 0x12, 0x80 },
{ 0x12, 0x14 },
};
/* 7670. Defaults taken from OmniVision provided data,
* as provided by Jonathan Corbet of OLPC */
- static struct ov_i2c_regvals norm_7670[] = {
+ static const struct ov_i2c_regvals norm_7670[] = {
{ OV7670_REG_COM7, OV7670_COM7_RESET },
{ OV7670_REG_TSLB, 0x04 }, /* OV */
{ OV7670_REG_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
static int ov6xx0_configure(struct sd *sd)
{
int rc;
- static struct ov_i2c_regvals norm_6x20[] = {
+ static const struct ov_i2c_regvals norm_6x20[] = {
{ 0x12, 0x80 }, /* reset */
{ 0x11, 0x01 },
{ 0x03, 0x60 },
/* Toggle 0x12[2] off and on here? */
};
- static struct ov_i2c_regvals norm_6x30[] = {
+ static const struct ov_i2c_regvals norm_6x30[] = {
{ 0x12, 0x80 }, /* Reset */
{ 0x00, 0x1f }, /* Gain */
{ 0x01, 0x99 }, /* Blue gain */
struct cam *cam;
/* (from ov519_configure) */
- static struct ov_regvals init_519[] = {
+ static const struct ov_regvals init_519[] = {
{ 0x5a, 0x6d }, /* EnableSystem */
/* jfm trace usbsnoop3-1.txt */
/* jfm 53 = fb */
/* windows reads 0x55 at this point*/
};
- if (write_regvals(sd, init_519,
- sizeof init_519 / sizeof init_519[0]))
+ if (write_regvals(sd, init_519, ARRAY_SIZE(init_519)))
goto error;
/* jfm: not seen in windows trace */
if (ov519_init_compression(sd))
static int ov519_mode_init_regs(struct sd *sd,
int width, int height)
{
- static struct ov_regvals mode_init_519_ov7670[] = {
+ static const struct ov_regvals mode_init_519_ov7670[] = {
{ 0x5d, 0x03 }, /* Turn off suspend mode */
{ 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
{ 0x54, 0x0f }, /* bit2 (jpeg enable) */
/* windows reads 0x55 at this point, why? */
};
- static struct ov_regvals mode_init_519[] = {
+ static const struct ov_regvals mode_init_519[] = {
{ 0x5d, 0x03 }, /* Turn off suspend mode */
{ 0x53, 0x9f }, /* was 9b in 1.65-1.08 */
{ 0x54, 0x0f }, /* bit2 (jpeg enable) */
/******** Set the mode ********/
if (sd->sensor != SEN_OV7670) {
if (write_regvals(sd, mode_init_519,
- sizeof mode_init_519 / sizeof mode_init_519[0]))
+ ARRAY_SIZE(mode_init_519)))
return -EIO;
} else {
if (write_regvals(sd, mode_init_519_ov7670,
- sizeof mode_init_519_ov7670
- / sizeof mode_init_519_ov7670[0]))
+ ARRAY_SIZE(mode_init_519_ov7670)))
return -EIO;
}
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
/* Header of ov519 is 16 bytes:
case SEN_OV6630:
i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
case SEN_OV8610: {
- static __u8 ctab[] = {
+ static const __u8 ctab[] = {
0x03, 0x09, 0x0b, 0x0f, 0x53, 0x6f, 0x35, 0x7f
};
break;
}
case SEN_OV7620: {
- static __u8 ctab[] = {
+ static const __u8 ctab[] = {
0x01, 0x05, 0x09, 0x11, 0x15, 0x35, 0x37, 0x57,
0x5b, 0xa5, 0xa7, 0xc7, 0xc9, 0xcf, 0xef, 0xff
};
}
/* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x4052), DVNM("Creative Live! VISTA IM")},
{USB_DEVICE(0x041e, 0x405f), DVNM("Creative Live! VISTA VF0330")},
{USB_DEVICE(0x041e, 0x4060), DVNM("Creative Live! VISTA VF0350")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
MODULE_DESCRIPTION("Pixart PAC207");
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame,
- unsigned char *data,
+ __u8 *data,
int len)
{
unsigned char *sof;
n = pac207_decode_frame_data(gspca_dev, frame, data, len);
if (n)
- frame = gspca_frame_add(gspca_dev, LAST_PACKET,
- frame, NULL, 0);
+ gspca_frame_add(gspca_dev, LAST_PACKET,
+ frame, NULL, 0);
}
static void setbrightness(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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x4028), DVNM("Creative Webcam Vista Plus")},
{USB_DEVICE(0x093a, 0x2460), DVNM("Q-Tec Webcam 100")},
{USB_DEVICE(0x093a, 0x2463), DVNM("Philips spc200nc pac207")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 3)
-static const char version[] = "2.1.3";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
MODULE_DESCRIPTION("Pixart PAC7311");
int avg_lum;
unsigned char brightness;
-#define BRIGHTNESS_MAX 0x20
unsigned char contrast;
unsigned char colors;
unsigned char autogain;
static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
{
{
.id = V4L2_CID_BRIGHTNESS,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Brightness",
.minimum = 0,
+#define BRIGHTNESS_MAX 0x20
.maximum = BRIGHTNESS_MAX,
.step = 1,
- .default_value = 0x10,
+#define BRIGHTNESS_DEF 0x10
+ .default_value = BRIGHTNESS_DEF,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
-#define SD_CONTRAST 1
{
{
.id = V4L2_CID_CONTRAST,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define CONTRAST_DEF 127
+ .default_value = CONTRAST_DEF,
},
.set = sd_setcontrast,
.get = sd_getcontrast,
},
-#define SD_COLOR 2
{
{
.id = V4L2_CID_SATURATION,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define COLOR_DEF 127
+ .default_value = COLOR_DEF,
},
.set = sd_setcolors,
.get = sd_getcolors,
},
-#define SD_AUTOGAIN 3
{
{
.id = V4L2_CID_AUTOGAIN,
.minimum = 0,
.maximum = 1,
.step = 1,
- .default_value = 1,
+#define AUTOGAIN_DEF 1
+ .default_value = AUTOGAIN_DEF,
},
.set = sd_setautogain,
.get = sd_getautogain,
#define PAC7311_JPEG_HEADER_SIZE (sizeof pac7311_jpeg_header) /* (594) */
-const unsigned char pac7311_jpeg_header[] = {
+static const __u8 pac7311_jpeg_header[] = {
0xff, 0xd8,
0xff, 0xe0, 0x00, 0x03, 0x20,
0xff, 0xc0, 0x00, 0x11, 0x08,
};
static void reg_w(struct usb_device *dev,
- __u16 index,
- char *buffer, __u16 len)
+ __u16 index,
+ const char *buffer, __u16 len)
{
__u8 tmpbuf[8];
cam->cam_mode = vga_mode;
cam->nmodes = ARRAY_SIZE(vga_mode);
- sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
- sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
- sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
- sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
+ sd->brightness = BRIGHTNESS_DEF;
+ sd->contrast = CONTRAST_DEF;
+ sd->colors = COLOR_DEF;
+ sd->autogain = AUTOGAIN_DEF;
return 0;
}
/*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, 0x0e, 0x00); */
pac7311_reg_write(gspca_dev->dev, 0x0f, brightness);
/* load registers to sensor (Bit 0, auto clear) */
pac7311_reg_write(gspca_dev->dev, 0x11, 0x01);
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) gspca_dev;
#include "gspca.h"
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 3)
-static const char version[] = "2.1.3";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
{
{
.id = V4L2_CID_BRIGHTNESS,
.minimum = 0,
.maximum = 0xffff,
.step = 1,
- .default_value = 0x7fff,
+#define BRIGHTNESS_DEF 0x7fff
+ .default_value = BRIGHTNESS_DEF,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
-#define SD_CONTRAST 1
{
{
.id = V4L2_CID_CONTRAST,
.minimum = 0,
.maximum = 127,
.step = 1,
- .default_value = 63,
+#define CONTRAST_DEF 63
+ .default_value = CONTRAST_DEF,
},
.set = sd_setcontrast,
.get = sd_getcontrast,
},
-#define SD_COLOR 2
{
{
.id = V4L2_CID_SATURATION,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define COLOR_DEF 127
+ .default_value = COLOR_DEF,
},
.set = sd_setcolors,
.get = sd_getcolors,
},
-#define SD_AUTOGAIN 3
{
{
.id = V4L2_CID_AUTOGAIN,
.minimum = 0,
.maximum = 1,
.step = 1,
- .default_value = 1,
+#define AUTOGAIN_DEF 1
+ .default_value = AUTOGAIN_DEF,
},
.set = sd_setautogain,
.get = sd_getautogain,
};
/*Data from sn9c102p+hv71331r */
-static __u8 sn_hv7131[] = {
+static const __u8 sn_hv7131[] = {
0x00, 0x03, 0x64, 0x00, 0x1A, 0x20, 0x20, 0x20, 0xA1, 0x11,
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 reg9 */
0x02, 0x09, 0x00, 0x00, 0x00, 0x10, 0x03, 0x00, /* 00 */
/* reg1c reg1d reg1e reg1f reg20 reg21 reg22 reg23 */
};
-static __u8 sn_mi0360[] = {
+static const __u8 sn_mi0360[] = {
0x00, 0x61, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0xb1, 0x5d,
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 reg9 */
0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x03, 0x00,
/* reg1c reg1d reg1e reg1f reg20 reg21 reg22 reg23 */
};
-static __u8 sn_mo4000[] = {
+static const __u8 sn_mo4000[] = {
0x12, 0x23, 0x60, 0x00, 0x1A, 0x00, 0x20, 0x18, 0x81,
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 */
0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
0xd3, 0xdf, 0xea, 0xf5
};
-static __u8 sn_ov7648[] = {
+static const __u8 sn_ov7648[] = {
0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20, 0xA1, 0x6E, 0x18, 0x65,
0x00, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1E, 0x82,
0x07, 0x00, 0x00, 0x00, 0x00, 0x00
};
-static __u8 sn_ov7660[] = {
+static const __u8 sn_ov7660[] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 */
0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x81,
/* reg9 rega regb regc regd rege regf reg10 reg11*/
};
/* sequence specific to the sensors - !! index = SENSOR_xxx */
-static __u8 *sn_tb[] = {
+static const __u8 *sn_tb[] = {
sn_hv7131,
sn_mi0360,
sn_mo4000,
sn_ov7660
};
-static __u8 regsn20[] = {
+static const __u8 regsn20[] = {
0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
};
-static __u8 regsn20_sn9c325[] = {
+static const __u8 regsn20_sn9c325[] = {
0x0a, 0x3a, 0x56, 0x6c, 0x7e, 0x8d, 0x9a, 0xa4,
0xaf, 0xbb, 0xc5, 0xcd, 0xd5, 0xde, 0xe8, 0xed, 0xf5
};
-static __u8 reg84[] = {
+static const __u8 reg84[] = {
0x14, 0x00, 0x27, 0x00, 0x07, 0x00, 0xe5, 0x0f,
0xe4, 0x0f, 0x38, 0x00, 0x3e, 0x00, 0xc3, 0x0f,
/* 0x00, 0x00, 0x00, 0x00, 0x00 */
0xf7, 0x0f, 0x0a, 0x00, 0x00
};
-static __u8 reg84_sn9c325[] = {
+static const __u8 reg84_sn9c325[] = {
0x14, 0x00, 0x27, 0x00, 0x07, 0x00, 0xe4, 0x0f,
0xd3, 0x0f, 0x4b, 0x00, 0x48, 0x00, 0xc0, 0x0f,
0xf8, 0x0f, 0x00, 0x00, 0x00
};
-static __u8 hv7131r_sensor_init[][8] = {
+static const __u8 hv7131r_sensor_init[][8] = {
{0xC1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
{0xB1, 0x11, 0x34, 0x17, 0x7F, 0x00, 0x00, 0x10},
{0xD1, 0x11, 0x40, 0xFF, 0x7F, 0x7F, 0x7F, 0x10},
{0xA1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
{0xA1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
{0xA1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
- {0, 0, 0, 0, 0, 0, 0, 0}
+ {}
};
-static __u8 mi0360_sensor_init[][8] = {
+static const __u8 mi0360_sensor_init[][8] = {
{0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
{0xB1, 0x5D, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x10},
{0xB1, 0x5D, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x10},
/* {0xB1, 0x5D, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
{0xB1, 0x5D, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
{0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
- {0, 0, 0, 0, 0, 0, 0, 0}
+ {}
};
-static __u8 mo4000_sensor_init[][8] = {
+static const __u8 mo4000_sensor_init[][8] = {
{0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
- {0, 0, 0, 0, 0, 0, 0, 0}
+ {}
};
-static __u8 ov7660_sensor_init[][8] = {
+static const __u8 ov7660_sensor_init[][8] = {
{0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
{0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
/* Outformat ?? rawRGB */
{0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
{0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
/* here may start the isoc exchanges */
- {0, 0, 0, 0, 0, 0, 0, 0}
+ {}
};
/* reg0x04 reg0x07 reg 0x10 */
/* expo = (COM1 & 0x02) | (AECHH & 0x2f <<10) [ (AECh << 2) */
-static __u8 ov7648_sensor_init[][8] = {
+static const __u8 ov7648_sensor_init[][8] = {
{0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
{0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00},
{0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
{0xA1, 0x6E, 0x07, 0x66, 0x00, 0x00, 0x00, 0x10}, /* B.. */
{0xC1, 0x6E, 0x1A, 0x03, 0x65, 0x90, 0x00, 0x10}, /* Bright/Witen....*/
/* {0xC1, 0x6E, 0x16, 0x45, 0x40, 0x60, 0x00, 0x10}, * Bright/Witene */
- {0, 0, 0, 0, 0, 0, 0, 0}
+ {}
};
-static __u8 qtable4[] = {
+static const __u8 qtable4[] = {
0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06,
0x06, 0x08, 0x0A, 0x11,
0x0A, 0x0A, 0x08, 0x08, 0x0A, 0x15, 0x0F, 0x0F, 0x0C, 0x11, 0x19, 0x15,
const __u8 *buffer,
int len)
{
- __u8 tmpbuf[64];
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
- if (len > sizeof tmpbuf) {
- PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
- return;
+ if (len < 16) {
+ __u8 tmpbuf[16];
+
+ memcpy(tmpbuf, buffer, len);
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0x08,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ value, 0,
+ tmpbuf, len,
+ 500);
+ } else {
+ __u8 *tmpbuf;
+
+ tmpbuf = kmalloc(len, GFP_KERNEL);
+ memcpy(tmpbuf, buffer, len);
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0x08,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ value, 0,
+ tmpbuf, len,
+ 500);
+ kfree(tmpbuf);
}
-#endif
- memcpy(tmpbuf, buffer, len);
- usb_control_msg(dev,
- usb_sndctrlpipe(dev, 0),
- 0x08,
- USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
- value, 0,
- tmpbuf, len,
- 500);
}
/* write 2 bytes */
static void i2c_w2(struct gspca_dev *gspca_dev,
- __u8 *buffer)
+ const __u8 *buffer)
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
}
/* write 8 bytes */
-static void i2c_w8(struct usb_device *dev, __u8 *buffer)
+static void i2c_w8(struct usb_device *dev, const __u8 *buffer)
{
reg_w(dev, 0x08, buffer, 8);
msleep(1);
/* read 5 bytes */
static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg,
- __u8 *buffer)
+ __u8 *buffer)
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
__u8 reg02;
- static __u8 datasend[] = { 2, 0 };
+ static const __u8 datasend[] = { 2, 0 };
/* reg val1 val2 val3 val4 */
__u8 datarecd[6];
}
static int configure_gpio(struct gspca_dev *gspca_dev,
- __u8 *sn9c1xx)
+ const __u8 *sn9c1xx)
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
__u8 data;
__u8 regF1;
- __u8 *reg9a;
- static __u8 reg9a_def[] =
+ const __u8 *reg9a;
+ static const __u8 reg9a_def[] =
{0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
- static __u8 reg9a_sn9c120[] = /* from win trace */
+ static const __u8 reg9a_sn9c120[] = /* from win trace */
{0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
- static __u8 reg9a_sn9c325[] =
+ static const __u8 reg9a_sn9c325[] =
{0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
{
int i = 0;
struct usb_device *dev = gspca_dev->dev;
- static __u8 SetSensorClk[] = /* 0x08 Mclk */
+ static const __u8 SetSensorClk[] = /* 0x08 Mclk */
{ 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
while (hv7131r_sensor_init[i][0]) {
cam->epaddr = 0x01;
cam->cam_mode = vga_mode;
cam->nmodes = ARRAY_SIZE(vga_mode);
+
sd->qindex = 4; /* set the quantization table */
- sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
- sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
- sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
- sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
+ sd->brightness = BRIGHTNESS_DEF;
+ sd->contrast = CONTRAST_DEF;
+ sd->colors = COLOR_DEF;
+ sd->autogain = AUTOGAIN_DEF;
return 0;
}
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
-/* __u8 *sn9c1xx; */
+/* const __u8 *sn9c1xx; */
__u8 regF1;
__u8 regGpio[] = { 0x29, 0x74 };
unsigned int expo)
{
struct sd *sd = (struct sd *) gspca_dev;
- static __u8 doit[] = /* update sensor */
+ static const __u8 doit[] = /* update sensor */
{ 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
- static __u8 sensorgo[] = /* sensor on */
+ static const __u8 sensorgo[] = /* sensor on */
{ 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
- static __u8 gainMo[] =
+ static const __u8 gainMo[] =
{ 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
switch (sd->sensor) {
__u8 data;
__u8 reg1;
__u8 reg17;
- __u8 *sn9c1xx;
+ const __u8 *sn9c1xx;
int mode;
- static __u8 DC29[] = { 0x6a, 0x50, 0x00, 0x00, 0x50, 0x3c };
- static __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
- static __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
- static __u8 CA_sn9c120[] = { 0x14, 0xec, 0x0a, 0xf6 }; /* SN9C120 */
- static __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd }; /* MI0360 */
- static __u8 CE_sn9c325[] =
+ static const __u8 DC29[] = { 0x6a, 0x50, 0x00, 0x00, 0x50, 0x3c };
+ static const __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
+ static const __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
+ static const __u8 CA_sn9c120[] =
+ { 0x14, 0xec, 0x0a, 0xf6 }; /* SN9C120 */
+ static const __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd }; /* MI0360 */
+ static const __u8 CE_sn9c325[] =
{ 0x32, 0xdd, 0x32, 0xdd }; /* OV7648 - SN9C325 */
sn9c1xx = sn_tb[(int) sd->sensor];
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- static __u8 stophv7131[] =
+ static const __u8 stophv7131[] =
{ 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
- static __u8 stopmi0360[] =
+ static const __u8 stopmi0360[] =
{ 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
__u8 regF1;
__u8 data;
- __u8 *sn9c1xx;
+ const __u8 *sn9c1xx;
data = 0x0b;
switch (sd->sensor) {
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) 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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x0458, 0x7025), DVNM("Genius Eye 311Q")},
{USB_DEVICE(0x045e, 0x00f5), DVNM("MicroSoft VX3000")},
{USB_DEVICE(0x045e, 0x00f7), DVNM("MicroSoft VX1000")},
#include "gspca.h"
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver");
struct sd {
struct gspca_dev gspca_dev; /* !! must be the first item */
- unsigned char packet[ISO_MAX_SIZE + 128];
+ __u8 packet[ISO_MAX_SIZE + 128];
/* !! no more than 128 ff in an ISO packet */
unsigned char brightness;
static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
{
{
.id = V4L2_CID_BRIGHTNESS,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Brightness",
.minimum = 0,
- .maximum = 0xff,
+ .maximum = 255,
.step = 1,
- .default_value = 0x7f,
+#define BRIGHTNESS_DEF 127
+ .default_value = BRIGHTNESS_DEF,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
-#define SD_CONTRAST 1
{
{
.id = V4L2_CID_CONTRAST,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Contrast",
.minimum = 0,
- .maximum = 255,
+ .maximum = 63,
.step = 1,
- .default_value = 127,
+#define CONTRAST_DEF 31
+ .default_value = CONTRAST_DEF,
},
.set = sd_setcontrast,
.get = sd_getcontrast,
},
-#define SD_COLOR 2
{
{
.id = V4L2_CID_SATURATION,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Color",
.minimum = 0,
- .maximum = 255,
+ .maximum = 63,
.step = 1,
- .default_value = 127,
+#define COLOR_DEF 31
+ .default_value = COLOR_DEF,
},
.set = sd_setcolors,
.get = sd_getcolors,
#define SPCA500_OFFSET_DATA 16
-static __u16 spca500_visual_defaults[][3] = {
+static const __u16 spca500_visual_defaults[][3] = {
{0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
* hue (H byte) = 0,
* saturation/hue enable,
{0x00, 0x0001, 0x8202}, /* clock rate compensation = 1/25 sec/frame */
{0x0c, 0x0004, 0x0000},
/* set interface */
-
- {0, 0, 0}
+ {}
};
-static __u16 Clicksmart510_defaults[][3] = {
+static const __u16 Clicksmart510_defaults[][3] = {
{0x00, 0x00, 0x8211},
{0x00, 0x01, 0x82c0},
{0x00, 0x10, 0x82cb},
{}
};
-static unsigned char qtable_creative_pccam[2][64] = {
+static const __u8 qtable_creative_pccam[2][64] = {
{ /* Q-table Y-components */
0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
};
-static unsigned char qtable_kodak_ez200[2][64] = {
+static const __u8 qtable_kodak_ez200[2][64] = {
{ /* Q-table Y-components */
0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x05, 0x06,
0x01, 0x01, 0x01, 0x02, 0x03, 0x06, 0x06, 0x06,
0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a}
};
-static unsigned char qtable_pocketdv[2][64] = {
+static const __u8 qtable_pocketdv[2][64] = {
{ /* Q-table Y-components start registers 0x8800 */
0x06, 0x04, 0x04, 0x06, 0x0a, 0x10, 0x14, 0x18,
0x05, 0x05, 0x06, 0x08, 0x0a, 0x17, 0x18, 0x16,
0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28}
};
-static void spca5xxRegRead(struct usb_device *dev,
+static void reg_r(struct usb_device *dev,
__u16 index,
__u8 *buffer, __u16 length)
{
index, buffer, length, 500);
}
-static int reg_write(struct usb_device *dev,
+static int reg_w(struct usb_device *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),
req,
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
value, index, NULL, 0, 500);
- PDEBUG(D_USBO, "reg write: [0x%02x] = 0x%02x, 0x%x",
- index, value, ret);
if (ret < 0)
PDEBUG(D_ERR, "reg write: error %d", ret);
return ret;
}
/* returns: negative is error, pos or zero is data */
-static int reg_read(struct usb_device *dev,
+static int reg_r_12(struct usb_device *dev,
__u16 req, /* bRequest */
__u16 index, /* wIndex */
__u16 length) /* wLength (1 or 2 only) */
buf, length,
500); /* timeout */
if (ret < 0) {
- PDEBUG(D_ERR, "reg_read err %d", ret);
+ PDEBUG(D_ERR, "reg_r_12 err %d", ret);
return -1;
}
return (buf[1] << 8) + buf[0];
* a reg_read call.
* Returns: negative is error or timeout, zero is success.
*/
-static int reg_readwait(struct usb_device *dev,
+static int reg_r_wait(struct usb_device *dev,
__u16 reg, __u16 index, __u16 value)
{
int ret, cnt = 20;
while (--cnt > 0) {
- ret = reg_read(dev, reg, index, 1);
+ ret = reg_r_12(dev, reg, index, 1);
if (ret == value)
return 0;
msleep(50);
}
static int write_vector(struct gspca_dev *gspca_dev,
- __u16 data[][3])
+ 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_write(dev, data[i][0], data[i][2], data[i][1]);
+ ret = reg_w(dev, data[i][0], data[i][2], data[i][1]);
if (ret < 0)
return ret;
i++;
unsigned int request,
unsigned int ybase,
unsigned int cbase,
- unsigned char qtable[2][64])
+ const __u8 qtable[2][64])
{
struct usb_device *dev = gspca_dev->dev;
int i, err;
/* loop over y components */
for (i = 0; i < 64; i++) {
- err = reg_write(dev, request, ybase + i, qtable[0][i]);
+ err = reg_w(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(dev, request, cbase + i, qtable[1][i]);
if (err < 0)
return err;
}
{
__u8 Data[2];
- spca5xxRegRead(gspca_dev->dev, 0x0d04, Data, 2);
- PDEBUG(D_PACK, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x",
+ reg_r(gspca_dev->dev, 0x0d04, Data, 2);
+ PDEBUG(D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x",
Data[0], Data[1]);
}
{
__u8 Data[2];
- spca5xxRegRead(gspca_dev->dev, 0x0d05, Data, 2);
- PDEBUG(D_PACK, "ClickSmart310 init 0x0d05 0x%02x 0x%02x", Data[0],
- Data[1]);
- reg_write(gspca_dev->dev, 0x00, 0x8167, 0x5a);
+ reg_r(gspca_dev->dev, 0x0d05, Data, 2);
+ PDEBUG(D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x",
+ Data[0], Data[1]);
+ reg_w(gspca_dev->dev, 0x00, 0x8167, 0x5a);
spca500_ping310(gspca_dev);
- reg_write(gspca_dev->dev, 0x00, 0x8168, 0x22);
- reg_write(gspca_dev->dev, 0x00, 0x816a, 0xc0);
- reg_write(gspca_dev->dev, 0x00, 0x816b, 0x0b);
- reg_write(gspca_dev->dev, 0x00, 0x8169, 0x25);
- reg_write(gspca_dev->dev, 0x00, 0x8157, 0x5b);
- reg_write(gspca_dev->dev, 0x00, 0x8158, 0x5b);
- reg_write(gspca_dev->dev, 0x00, 0x813f, 0x03);
- reg_write(gspca_dev->dev, 0x00, 0x8151, 0x4a);
- reg_write(gspca_dev->dev, 0x00, 0x8153, 0x78);
- reg_write(gspca_dev->dev, 0x00, 0x0d01, 0x04);
+ 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);
/* 00 for adjust shutter */
- reg_write(gspca_dev->dev, 0x00, 0x0d02, 0x01);
- reg_write(gspca_dev->dev, 0x00, 0x8169, 0x25);
- reg_write(gspca_dev->dev, 0x00, 0x0d01, 0x02);
+ reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x8169, 0x25);
+ reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x02);
}
static void spca500_setmode(struct gspca_dev *gspca_dev,
int mode;
/* set x multiplier */
- reg_write(gspca_dev->dev, 0, 0x8001, xmult);
+ reg_w(gspca_dev->dev, 0, 0x8001, xmult);
/* set y multiplier */
- reg_write(gspca_dev->dev, 0, 0x8002, ymult);
+ reg_w(gspca_dev->dev, 0, 0x8002, ymult);
/* use compressed mode, VGA, with mode specific subsample */
mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode;
- reg_write(gspca_dev->dev, 0, 0x8003, mode << 4);
+ reg_w(gspca_dev->dev, 0, 0x8003, mode << 4);
}
static int spca500_full_reset(struct gspca_dev *gspca_dev)
int err;
/* send the reset command */
- err = reg_write(gspca_dev->dev, 0xe0, 0x0001, 0x0000);
+ err = reg_w(gspca_dev->dev, 0xe0, 0x0001, 0x0000);
if (err < 0)
return err;
/* wait for the reset to complete */
- err = reg_readwait(gspca_dev->dev, 0x06, 0x0000, 0x0000);
+ err = reg_r_wait(gspca_dev->dev, 0x06, 0x0000, 0x0000);
if (err < 0)
return err;
- err = reg_write(gspca_dev->dev, 0xe0, 0x0000, 0x0000);
+ err = reg_w(gspca_dev->dev, 0xe0, 0x0000, 0x0000);
if (err < 0)
return err;
- err = reg_readwait(gspca_dev->dev, 0x06, 0, 0);
+ err = reg_r_wait(gspca_dev->dev, 0x06, 0, 0);
if (err < 0) {
- PDEBUG(D_ERR, "reg_readwait() failed");
+ PDEBUG(D_ERR, "reg_r_wait() failed");
return err;
}
/* all ok */
}
spca500_ping310(gspca_dev);
- spca5xxRegRead(gspca_dev->dev, 0x0d00, &Data, 1);
+ reg_r(gspca_dev->dev, 0x0d00, &Data, 1);
/* need alt setting here */
PDEBUG(D_PACK, "ClickSmart310 sync alt: %d", gspca_dev->alt);
/* some unknow command from Aiptek pocket dv and family300 */
- reg_write(gspca_dev->dev, 0x00, 0x0d01, 0x01);
- reg_write(gspca_dev->dev, 0x00, 0x0d03, 0x00);
- reg_write(gspca_dev->dev, 0x00, 0x0d02, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x0d03, 0x00);
+ reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01);
/* enable drop packet */
- reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840,
qtable_pocketdv);
PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed on init");
/* set qtable index */
- reg_write(gspca_dev->dev, 0x00, 0x8880, 2);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 2);
/* family cam Quicksmart stuff */
- reg_write(gspca_dev->dev, 0x00, 0x800a, 0x00);
+ reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
/* Set agc transfer: synced inbetween frames */
- reg_write(gspca_dev->dev, 0x00, 0x820f, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01);
/* Init SDRAM - needed for SDRAM access */
- reg_write(gspca_dev->dev, 0x00, 0x870a, 0x04);
+ reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
/*Start init sequence or stream */
- reg_write(gspca_dev->dev, 0, 0x8003, 0x00);
+ reg_w(gspca_dev->dev, 0, 0x8003, 0x00);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
msleep(2000);
- if (reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ 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);
}
/* this function is called at probe time */
cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
}
sd->qindex = 5;
- sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
- sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
- sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
+ sd->brightness = BRIGHTNESS_DEF;
+ sd->contrast = CONTRAST_DEF;
+ sd->colors = COLOR_DEF;
return 0;
}
}
/* is there a sensor here ? */
- spca5xxRegRead(gspca_dev->dev, 0x8a04, &Data, 1);
+ 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",
gspca_dev->curr_mode, xmult, ymult);
spca500_setmode(gspca_dev, xmult, ymult);
/* enable drop packet */
- reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
- reg_write(gspca_dev->dev, 0x00, 0x8880, 3);
+ reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->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_write(gspca_dev->dev, 0x00, 0x870a, 0x04);
+ reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
msleep(500);
- if (reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
- PDEBUG(D_ERR, "reg_readwait() failed");
+ if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+ PDEBUG(D_ERR, "reg_r_wait() failed");
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->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_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
PDEBUG(D_ERR, "failed to enable drop packet");
- reg_write(gspca_dev->dev, 0x00, 0x8880, 3);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
err = spca50x_setup_qtable(gspca_dev,
0x00, 0x8800, 0x8840,
qtable_creative_pccam);
PDEBUG(D_ERR, "spca50x_setup_qtable failed");
/* Init SDRAM - needed for SDRAM access */
- reg_write(gspca_dev->dev, 0x00, 0x870a, 0x04);
+ reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- if (reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
- PDEBUG(D_ERR, "reg_readwait() failed");
+ if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+ PDEBUG(D_ERR, "reg_r_wait() failed");
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
break;
case CreativePCCam300: /* Creative PC-CAM 300 640x480 CCD */
case IntelPocketPCCamera: /* FIXME: Temporary fix for
PDEBUG(D_ERR, "spca500_full_reset failed");
/* enable drop packet */
- err = reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ err = reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
if (err < 0)
PDEBUG(D_ERR, "failed to enable drop packet");
- reg_write(gspca_dev->dev, 0x00, 0x8880, 3);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
err = spca50x_setup_qtable(gspca_dev,
0x00, 0x8800, 0x8840,
qtable_creative_pccam);
PDEBUG(D_ERR, "spca50x_setup_qtable failed");
spca500_setmode(gspca_dev, xmult, ymult);
- reg_write(gspca_dev->dev, 0x20, 0x0001, 0x0004);
+ reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- if (reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
- PDEBUG(D_ERR, "reg_readwait() failed");
+ if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+ PDEBUG(D_ERR, "reg_r_wait() failed");
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
- /* write_vector(gspca_dev, spca500_visual_defaults); */
+/* write_vector(gspca_dev, spca500_visual_defaults); */
break;
case KodakEZ200: /* Kodak EZ200 */
if (err < 0)
PDEBUG(D_ERR, "spca500_full_reset failed");
/* enable drop packet */
- reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
- reg_write(gspca_dev->dev, 0x00, 0x8880, 0);
+ reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 0);
err = spca50x_setup_qtable(gspca_dev,
0x00, 0x8800, 0x8840,
qtable_kodak_ez200);
PDEBUG(D_ERR, "spca50x_setup_qtable failed");
spca500_setmode(gspca_dev, xmult, ymult);
- reg_write(gspca_dev->dev, 0x20, 0x0001, 0x0004);
+ reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- if (reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
- PDEBUG(D_ERR, "reg_readwait() failed");
+ if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0)
+ PDEBUG(D_ERR, "reg_r_wait() failed");
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
- /* write_vector(gspca_dev, spca500_visual_defaults); */
+/* write_vector(gspca_dev, spca500_visual_defaults); */
break;
case BenqDC1016:
case ToptroIndus:
case AgfaCl20:
spca500_reinit(gspca_dev);
- reg_write(gspca_dev->dev, 0x00, 0x0d01, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01);
/* enable drop packet */
- reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->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_write(gspca_dev->dev, 0x00, 0x8880, 2);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 2);
/* familycam Quicksmart pocketDV stuff */
- reg_write(gspca_dev->dev, 0x00, 0x800a, 0x00);
+ reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
/* Set agc transfer: synced inbetween frames */
- reg_write(gspca_dev->dev, 0x00, 0x820f, 0x01);
+ reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01);
/* Init SDRAM - needed for SDRAM access */
- reg_write(gspca_dev->dev, 0x00, 0x870a, 0x04);
+ reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
spca500_setmode(gspca_dev, xmult, ymult);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44);
+ reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44);
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
break;
case LogitechTraveler:
case LogitechClickSmart510:
- reg_write(gspca_dev->dev, 0x02, 0x00, 0x00);
+ reg_w(gspca_dev->dev, 0x02, 0x00, 0x00);
/* enable drop packet */
- reg_write(gspca_dev->dev, 0x00, 0x850a, 0x0001);
+ reg_w(gspca_dev->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_write(gspca_dev->dev, 0x00, 0x8880, 3);
- reg_write(gspca_dev->dev, 0x00, 0x800a, 0x00);
+ reg_w(gspca_dev->dev, 0x00, 0x8880, 3);
+ reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00);
/* Init SDRAM - needed for SDRAM access */
- reg_write(gspca_dev->dev, 0x00, 0x870a, 0x04);
+ reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04);
spca500_setmode(gspca_dev, xmult, ymult);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- reg_readwait(gspca_dev->dev, 0, 0x8000, 0x44);
+ reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004);
+ reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44);
- spca5xxRegRead(gspca_dev->dev, 0x816b, &Data, 1);
- reg_write(gspca_dev->dev, 0x00, 0x816b, Data);
+ reg_r(gspca_dev->dev, 0x816b, &Data, 1);
+ reg_w(gspca_dev->dev, 0x00, 0x816b, Data);
write_vector(gspca_dev, Clicksmart510_defaults);
break;
}
static void sd_stopN(struct gspca_dev *gspca_dev)
{
- __u8 data = 0;
+ __u8 data;
- reg_write(gspca_dev->dev, 0, 0x8003, 0x00);
+ reg_w(gspca_dev->dev, 0, 0x8003, 0x00);
/* switch to video camera mode */
- reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004);
- spca5xxRegRead(gspca_dev->dev, 0x8000, &data, 1);
+ 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);
}
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) gspca_dev;
int i;
- unsigned char *s, *d;
- static unsigned char ffd9[] = {0xff, 0xd9};
+ __u8 *s, *d;
+ static __u8 ffd9[] = {0xff, 0xd9};
/* frames are jpeg 4.1.1 without 0xff escape */
if (data[0] == 0xff) {
ffd9, 2);
/* put the JPEG header in the new frame */
- jpeg_put_header(gspca_dev, frame,
- ((struct sd *) gspca_dev)->qindex,
- 0x22);
+ jpeg_put_header(gspca_dev, frame, sd->qindex, 0x22);
data += SPCA500_OFFSET_DATA;
len -= SPCA500_OFFSET_DATA;
{
struct sd *sd = (struct sd *) gspca_dev;
- reg_write(gspca_dev->dev, 0x00, 0x8167,
+ reg_w(gspca_dev->dev, 0x00, 0x8167,
(__u8) (sd->brightness - 128));
}
static void getbrightness(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
+ int ret;
- sd->brightness = reg_read(gspca_dev->dev, 0x00, 0x8167, 1) + 128;
+ ret = reg_r_12(gspca_dev->dev, 0x00, 0x8167, 1);
+ if (ret >= 0)
+ sd->brightness = ret + 128;
}
static void setcontrast(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
- reg_write(gspca_dev->dev, 0x00, 0x8168, sd->contrast >> 2);
+ reg_w(gspca_dev->dev, 0x00, 0x8168, sd->contrast);
}
static void getcontrast(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
+ int ret;
- sd->contrast = reg_read(gspca_dev->dev, 0x0, 0x8168, 1) << 2;
+ ret = reg_r_12(gspca_dev->dev, 0x0, 0x8168, 1);
+ if (ret >= 0)
+ sd->contrast = ret;
}
static void setcolors(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
- reg_write(gspca_dev->dev, 0x00, 0x8169, sd->colors >> 2);
+ reg_w(gspca_dev->dev, 0x00, 0x8169, sd->colors);
}
static void getcolors(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
+ int ret;
- sd->colors = reg_read(gspca_dev->dev, 0x0, 0x8169, 1) << 2;
+ ret = reg_r_12(gspca_dev->dev, 0x0, 0x8169, 1);
+ if (ret >= 0)
+ sd->colors = ret;
}
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
static 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,
/* -- 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(0x040a, 0x0300), DVNM("Kodak EZ200")},
{USB_DEVICE(0x041e, 0x400a), DVNM("Creative PC-CAM 300")},
{USB_DEVICE(0x046d, 0x0890), DVNM("Logitech QuickCam traveler")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA501 USB Camera Driver");
#define SPCA501_A33 0x10
/* Data for video camera initialization before capturing */
-static __u16 spca501_open_data[][3] = {
+static const __u16 spca501_open_data[][3] = {
/* bmRequest,value,index */
{0x2, 0x50, 0x00}, /* C/S enable soft reset */
*/
/* Data for chip initialization (set default values) */
-static __u16 spca501_init_data[][3] = {
+static const __u16 spca501_init_data[][3] = {
/* Set all the values to powerup defaults */
/* bmRequest,value,index */
{0x0, 0xAA, 0x00},
* Capture and decoding by Colin Peart.
* This is is for the 3com HomeConnect Lite which is spca501a based.
*/
-static __u16 spca501_3com_open_data[][3] = {
+static const __u16 spca501_3com_open_data[][3] = {
/* bmRequest,value,index */
{0x2, 0x0050, 0x0000}, /* C/S Enable TG soft reset, timing mode=010 */
{0x2, 0x0043, 0x0000}, /* C/S Disable TG soft reset, timing mode=010 */
* 2) Understand why some values seem to appear more than once
* 3) Write a small comment for each line of the following arrays.
*/
-static __u16 spca501c_arowana_open_data[][3] = {
+static const __u16 spca501c_arowana_open_data[][3] = {
/* bmRequest,value,index */
{0x02, 0x0007, 0x0005},
{0x02, 0xa048, 0x0000},
{}
};
-static __u16 spca501c_arowana_init_data[][3] = {
+static const __u16 spca501c_arowana_init_data[][3] = {
/* bmRequest,value,index */
{0x02, 0x0007, 0x0005},
{0x02, 0xa048, 0x0000},
/* Unknow camera from Ori Usbid 0x0000:0x0000 */
/* Based on snoops from Ori Cohen */
-static __u16 spca501c_mysterious_open_data[][3] = {
+static const __u16 spca501c_mysterious_open_data[][3] = {
{0x02, 0x000f, 0x0005},
{0x02, 0xa048, 0x0000},
{0x05, 0x0022, 0x0004},
};
/* Based on snoops from Ori Cohen */
-static __u16 spca501c_mysterious_init_data[][3] = {
+static const __u16 spca501c_mysterious_init_data[][3] = {
/* Part 3 */
/* TG registers */
/* {0x00, 0x0000, 0x0000}, */
}
static int write_vector(struct gspca_dev *gspca_dev,
- __u16 data[][3])
+ const __u16 data[][3])
{
struct usb_device *dev = gspca_dev->dev;
int ret, i = 0;
{
struct sd *sd = (struct sd *) gspca_dev;
- PDEBUG(D_STREAM, "SPCA501 init");
switch (sd->subtype) {
case ThreeComHomeConnectLite:
/* Special handling for 3com data */
reg_write(dev, SPCA501_REG_CTLRL, 0x01, 0x02);
/* HDG atleast the Intel CreateAndShare needs to have one of its
- * brightness / contrast / color set otherwise it assumes wath seems
+ * brightness / contrast / color set otherwise it assumes what seems
* max contrast. Note that strange enough setting any of these is
* enough to fix the max contrast problem, to be sure we set all 3 */
setbrightness(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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x040a, 0x0002), DVNM("Kodak DVC-325")},
{USB_DEVICE(0x0497, 0xc001), DVNM("Smile International")},
{USB_DEVICE(0x0506, 0x00df), DVNM("3Com HomeConnect Lite")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver");
/*
* Data to initialize a SPCA505. Common to the CCD and external modes
*/
-static __u16 spca505_init_data[][3] = {
+static const __u16 spca505_init_data[][3] = {
/* line bmRequest,value,index */
/* 1819 */
{SPCA50X_REG_GLOBAL, SPCA50X_GMISC3_SAA7113RST, SPCA50X_GLOBAL_MISC3},
/*
* Data to initialize the camera using the internal CCD
*/
-static __u16 spca505_open_data_ccd[][3] = {
+static const __u16 spca505_open_data_ccd[][3] = {
/* line bmRequest,value,index */
/* Internal CCD data set */
/* 1891 */ {0x3, 0x04, 0x01},
/*
* Data to initialize a SPCA505. Common to the CCD and external modes
*/
-static __u16 spca505b_init_data[][3] = {
+static const __u16 spca505b_init_data[][3] = {
/* start */
{0x02, 0x00, 0x00}, /* init */
{0x02, 0x00, 0x01},
/*
* Data to initialize the camera using the internal CCD
*/
-static __u16 spca505b_open_data_ccd[][3] = {
+static const __u16 spca505b_open_data_ccd[][3] = {
/* {0x02,0x00,0x00}, */
{0x03, 0x04, 0x01}, /* rst */
__u16 length) /* wLength (1 or 2 only) */
{
int ret;
- unsigned char buf[4];
+ __u8 buf[4];
buf[1] = 0;
ret = usb_control_msg(dev,
}
static int write_vector(struct gspca_dev *gspca_dev,
- __u16 data[][3])
+ const __u16 data[][3])
{
struct usb_device *dev = gspca_dev->dev;
int ret, i = 0;
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) 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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x401d), DVNM("Creative Webcam NX ULTRA")},
{USB_DEVICE(0x0733, 0x0430), DVNM("Intel PC Camera Pro")},
{}
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA508 USB Camera Driver");
* Initialization data: this is the first set-up data written to the
* device (before the open data).
*/
-static __u16 spca508_init_data[][3] =
+static const __u16 spca508_init_data[][3] =
#define IGN(x) /* nothing */
{
/* line URB value, index */
/*
* Initialization data for Intel EasyPC Camera CS110
*/
-static __u16 spca508cs110_init_data[][3] = {
+static const __u16 spca508cs110_init_data[][3] = {
{0x0000, 0x870b}, /* Reset CTL3 */
{0x0003, 0x8111}, /* Soft Reset compression, memory, TG & CDSP */
{0x0000, 0x8111}, /* Normal operation on reset */
{}
};
-static __u16 spca508_sightcam_init_data[][3] = {
+static const __u16 spca508_sightcam_init_data[][3] = {
/* This line seems to setup the frame/canvas */
/*368 */ {0x000f, 0x8402},
{0, 0}
};
-static __u16 spca508_sightcam2_init_data[][3] = {
+static const __u16 spca508_sightcam2_init_data[][3] = {
/* 35 */ {0x0020, 0x8112},
/* 36 */ {0x000f, 0x8402},
/*
* Initialization data for Creative Webcam Vista
*/
-static __u16 spca508_vista_init_data[][3] = {
+static const __u16 spca508_vista_init_data[][3] = {
{0x0008, 0x8200}, /* Clear register */
{0x0000, 0x870b}, /* Reset CTL3 */
{0x0020, 0x8112}, /* Video Drop packet enable */
}
static int write_vector(struct gspca_dev *gspca_dev,
- __u16 data[][3])
+ const __u16 data[][3])
{
struct usb_device *dev = gspca_dev->dev;
int ret, i = 0;
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) 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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x4018), DVNM("Creative Webcam Vista (PD1100)")},
{USB_DEVICE(0x0461, 0x0815), DVNM("Micro Innovation IC200")},
{USB_DEVICE(0x0733, 0x0110), DVNM("ViewQuest VQ110")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
PDEBUG(D_ERR, "reg write: error %d", ret);
}
-static void write_vector(struct gspca_dev *gspca_dev, __u16 data[][2])
+static void write_vector(struct gspca_dev *gspca_dev,
+ const __u16 data[][2])
{
struct usb_device *dev = gspca_dev->dev;
int i;
}
static void reg_w_buf(struct usb_device *dev,
- __u16 index, __u8 *buffer, __u16 length)
+ __u16 index, const __u8 *buffer, __u16 len)
{
+ __u8 tmpbuf[8];
+
+ memcpy(tmpbuf, buffer, len);
usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
0, /* request */
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0, /* value */
- index, buffer, length, 500);
+ index, tmpbuf, len, 500);
}
static void i2c_init(struct gspca_dev *gspca_dev, __u8 mode)
return ((int) value << 8) | vallsb;
}
-static __u16 spca561_init_data[][2] = {
+static const __u16 spca561_init_data[][2] = {
{0x0000, 0x8114}, /* Software GPIO output data */
{0x0001, 0x8114}, /* Software GPIO output data */
{0x0000, 0x8112}, /* Some kind of reset */
}
/******************** QC Express etch2 stuff ********************/
-static __u16 Pb100_1map8300[][2] = {
+static const __u16 Pb100_1map8300[][2] = {
/* reg, value */
{0x8320, 0x3304},
{0x8302, 0x000e},
{}
};
-static __u16 Pb100_2map8300[][2] = {
+static const __u16 Pb100_2map8300[][2] = {
/* reg, value */
{0x8339, 0x0000},
{0x8307, 0x00aa},
{}
};
-static __u16 spca561_161rev12A_data1[][2] = {
+static const __u16 spca561_161rev12A_data1[][2] = {
{0x21, 0x8118},
{0x01, 0x8114},
{0x00, 0x8112},
{0x04, 0x8802}, /* windows uses 08 */
{}
};
-static __u16 spca561_161rev12A_data2[][2] = {
+static const __u16 spca561_161rev12A_data2[][2] = {
{0x21, 0x8118},
{0x10, 0x8500},
{0x07, 0x8601},
};
static void sensor_mapwrite(struct gspca_dev *gspca_dev,
- __u16 sensormap[][2])
+ const __u16 sensormap[][2])
{
int i = 0;
__u8 usbval[2];
}
/* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x401a), DVNM("Creative Webcam Vista (PD1100)")},
{USB_DEVICE(0x041e, 0x403b), DVNM("Creative Webcam Vista (VF0010)")},
{USB_DEVICE(0x0458, 0x7004), DVNM("Genius VideoCAM Express V2")},
#include "gspca.h"
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
{
{
.id = V4L2_CID_BRIGHTNESS,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define BRIGHTNESS_DEF 127
+ .default_value = BRIGHTNESS_DEF,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
-#define SD_CONTRAST 1
{
{
.id = V4L2_CID_CONTRAST,
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define CONTRAST_DEF 127
+ .default_value = CONTRAST_DEF,
},
.set = sd_setcontrast,
.get = sd_getcontrast,
},
-#define SD_COLOR 2
{
{
.id = V4L2_CID_SATURATION,
.type = V4L2_CTRL_TYPE_INTEGER,
- .name = "Saturation",
+ .name = "Color",
.minimum = 0,
.maximum = 255,
.step = 1,
- .default_value = 127,
+#define COLOR_DEF 127
+ .default_value = COLOR_DEF,
},
.set = sd_setcolors,
.get = sd_getcolors,
},
-#define SD_FREQ 3
{
{
.id = V4L2_CID_POWER_LINE_FREQUENCY,
.minimum = 1,
.maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
.step = 1,
- .default_value = 1,
+#define FREQ_DEF 1
+ .default_value = FREQ_DEF,
},
.set = sd_setfreq,
.get = sd_getfreq,
cam->epaddr = 0x02;
gspca_dev->cam.cam_mode = vga_mode;
gspca_dev->cam.nmodes = sizeof vga_mode / sizeof vga_mode[0];
- sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
- sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
- sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
- sd->lightfreq = sd_ctrls[SD_FREQ].qctrl.default_value;
+ sd->brightness = BRIGHTNESS_DEF;
+ sd->contrast = CONTRAST_DEF;
+ sd->colors = COLOR_DEF;
+ sd->lightfreq = FREQ_DEF;
return 0;
}
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
static unsigned char ffd9[] = {0xff, 0xd9};
case V4L2_CID_POWER_LINE_FREQUENCY:
switch (menu->index) {
case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
- strcpy(menu->name, "50 Hz");
+ strcpy((char *) menu->name, "50 Hz");
return 0;
case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
- strcpy(menu->name, "60 Hz");
+ strcpy((char *) menu->name, "60 Hz");
return 0;
}
break;
#include "gspca.h"
#include "jpeg.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 1)
-static const char version[] = "2.1.1";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
struct sd {
struct gspca_dev gspca_dev; /* !! must be the first item */
- unsigned char packet[ISO_MAX_SIZE + 128];
+ __u8 packet[ISO_MAX_SIZE + 128];
/* !! no more than 128 ff in an ISO packet */
unsigned char brightness;
#define SPCA536_OFFSET_FRAMSEQ 1
/* Initialisation data for the Creative PC-CAM 600 */
-static __u16 spca504_pccam600_init_data[][3] = {
+static const __u16 spca504_pccam600_init_data[][3] = {
/* {0xa0, 0x0000, 0x0503}, * capture mode */
{0x00, 0x0000, 0x2000},
{0x00, 0x0013, 0x2301},
/* Creative PC-CAM 600 specific open data, sent before using the
* generic initialisation data from spca504_open_data.
*/
-static __u16 spca504_pccam600_open_data[][3] = {
+static const __u16 spca504_pccam600_open_data[][3] = {
{0x00, 0x0001, 0x2501},
{0x20, 0x0500, 0x0001}, /* snapshot mode */
{0x00, 0x0003, 0x2880},
};
/* Initialisation data for the logitech clicksmart 420 */
-static __u16 spca504A_clicksmart420_init_data[][3] = {
+static const __u16 spca504A_clicksmart420_init_data[][3] = {
/* {0xa0, 0x0000, 0x0503}, * capture mode */
{0x00, 0x0000, 0x2000},
{0x00, 0x0013, 0x2301},
};
/* clicksmart 420 open data ? */
-static __u16 spca504A_clicksmart420_open_data[][3] = {
+static const __u16 spca504A_clicksmart420_open_data[][3] = {
{0x00, 0x0001, 0x2501},
{0x20, 0x0502, 0x0000},
{0x06, 0x0000, 0x0000},
{}
};
-static unsigned char qtable_creative_pccam[2][64] = {
+static const __u8 qtable_creative_pccam[2][64] = {
{ /* Q-table Y-components */
0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
* except for one byte. Possibly a typo?
* NWG: 18/05/2003.
*/
-static unsigned char qtable_spca504_default[2][64] = {
+static const __u8 qtable_spca504_default[2][64] = {
{ /* Q-table Y-components */
0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
}
static int write_vector(struct gspca_dev *gspca_dev,
- __u16 data[][3])
+ const __u16 data[][3])
{
struct usb_device *dev = gspca_dev->dev;
int ret, i = 0;
unsigned int request,
unsigned int ybase,
unsigned int cbase,
- unsigned char qtable[2][64])
+ const __u8 qtable[2][64])
{
struct usb_device *dev = gspca_dev->dev;
int i, err;
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
struct sd *sd = (struct sd *) 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 = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x041e, 0x400b), DVNM("Creative PC-CAM 600")},
{USB_DEVICE(0x041e, 0x4012), DVNM("PC-Cam350")},
{USB_DEVICE(0x041e, 0x4013), DVNM("Creative Pccam750")},
#define MODULE_NAME "t613"
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 3)
-static const char version[] = "2.1.3";
-
-struct control_menu_info {
- int value;
- char name[32];
-};
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
#define MAX_GAMMA 0x10 /* 0 to 15 */
},
};
-static struct control_menu_info effects_control[] = {
- {0, "Normal"},
- {1, "Emboss"}, /* disabled */
- {2, "Monochrome"},
- {3, "Sepia"},
- {4, "Sketch"},
- {5, "Sun Effect"}, /* disabled */
- {6, "Negative"},
+static char *effects_control[] = {
+ "Normal",
+ "Emboss", /* disabled */
+ "Monochrome",
+ "Sepia",
+ "Sketch",
+ "Sun Effect", /* disabled */
+ "Negative",
};
-#define NUM_EFFECTS_CONTROL \
- (sizeof(effects_control)/sizeof(effects_control[0]))
-
static struct cam_mode vga_mode_t16[] = {
{V4L2_PIX_FMT_JPEG, 160, 120, 4},
{V4L2_PIX_FMT_JPEG, 176, 144, 3},
#define MAX_EFFECTS 7
/* easily done by soft, this table could be removed,
* i keep it here just in case */
-unsigned char effects_table[MAX_EFFECTS][6] = {
+static const __u8 effects_table[MAX_EFFECTS][6] = {
{0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00}, /* Normal */
{0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04}, /* Repujar */
{0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20}, /* Monochrome */
{0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40}, /* Negative */
};
-unsigned char gamma_table[MAX_GAMMA][34] = {
+static const __u8 gamma_table[MAX_GAMMA][34] = {
{0x90, 0x00, 0x91, 0x3e, 0x92, 0x69, 0x93, 0x85,
0x94, 0x95, 0x95, 0xa1, 0x96, 0xae, 0x97, 0xb9,
0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdb,
0xA0, 0xFF}
};
-static __u8 tas5130a_sensor_init[][8] = {
+static const __u8 tas5130a_sensor_init[][8] = {
{0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
{0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
{0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
static void t16RegWrite(struct usb_device *dev,
__u16 value,
- __u16 index, __u8 *buffer, __u16 len)
+ __u16 index,
+ const __u8 *buffer, __u16 len)
{
- __u8 tmpbuf[70];
-
-#ifdef CONFIG_VIDEO_ADV_DEBUG
- if (len > sizeof tmpbuf) {
- PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
+ if (buffer == NULL) {
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ value, index,
+ NULL, 0, 500);
return;
}
-#endif
- memcpy(tmpbuf, buffer, len);
- usb_control_msg(dev,
- usb_sndctrlpipe(dev, 0),
- 0, /* request */
- USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
- value, index, tmpbuf, len, 500);
+ if (len < 16) {
+ __u8 tmpbuf[16];
+
+ memcpy(tmpbuf, buffer, len);
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ value, index,
+ tmpbuf, len, 500);
+ } else {
+ __u8 *tmpbuf;
+
+ tmpbuf = kmalloc(len, GFP_KERNEL);
+ memcpy(tmpbuf, buffer, len);
+ usb_control_msg(dev,
+ usb_sndctrlpipe(dev, 0),
+ 0,
+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+ value, index,
+ tmpbuf, len, 500);
+ kfree(tmpbuf);
+ }
}
/* this function is called at probe time */
int i = 0;
__u8 test_byte;
- static unsigned char read_indexs[] =
+ static const __u8 read_indexs[] =
{ 0x06, 0x07, 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00, 0x00 };
- static unsigned char n1[6] =
+ static const __u8 n1[6] =
{0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
- static unsigned char n2[2] =
+ static const __u8 n2[2] =
{0x08, 0x00};
- static unsigned char nset[6] =
+ static const __u8 nset[6] =
{ 0x61, 0x68, 0x62, 0xff, 0x60, 0x07 };
- static unsigned char n3[6] =
+ static const __u8 n3[6] =
{0x61, 0x68, 0x65, 0x0a, 0x60, 0x04};
- static unsigned char n4[0x46] =
+ static const __u8 n4[0x46] =
{0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
0xac, 0x84, 0xad, 0x86, 0xaf, 0x46};
- static unsigned char nset4[18] = {
+ static const __u8 nset4[18] = {
0xe0, 0x60, 0xe1, 0xa8, 0xe2, 0xe0, 0xe3, 0x60, 0xe4, 0xa8,
0xe5, 0xe0, 0xe6, 0x60, 0xe7, 0xa8,
0xe8, 0xe0
};
/* ojo puede ser 0xe6 en vez de 0xe9 */
- static unsigned char nset2[20] = {
+ static const __u8 nset2[20] = {
0xd0, 0xbb, 0xd1, 0x28, 0xd2, 0x10, 0xd3, 0x10, 0xd4, 0xbb,
0xd5, 0x28, 0xd6, 0x1e, 0xd7, 0x27,
0xd8, 0xc8, 0xd9, 0xfc
};
- static unsigned char missing[8] =
+ static const __u8 missing[8] =
{ 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 };
- static unsigned char nset3[18] = {
+ static const __u8 nset3[18] = {
0xc7, 0x60, 0xc8, 0xa8, 0xc9, 0xe0, 0xca, 0x60, 0xcb, 0xa8,
0xcc, 0xe0, 0xcd, 0x60, 0xce, 0xa8,
0xcf, 0xe0
};
- static unsigned char nset5[4] =
+ static const __u8 nset5[4] =
{ 0x8f, 0x24, 0xc3, 0x00 }; /* bright */
- static unsigned char nset6[34] = {
+ static const __u8 nset6[34] = {
0x90, 0x00, 0x91, 0x1c, 0x92, 0x30, 0x93, 0x43, 0x94, 0x54,
0x95, 0x65, 0x96, 0x75, 0x97, 0x84,
0x98, 0x93, 0x99, 0xa1, 0x9a, 0xb0, 0x9b, 0xbd, 0x9c, 0xca,
0x9d, 0xd8, 0x9e, 0xe5, 0x9f, 0xf2,
0xa0, 0xff
}; /* Gamma */
- static unsigned char nset7[4] =
+ static const __u8 nset7[4] =
{ 0x66, 0xca, 0xa8, 0xf8 }; /* 50/60 Hz */
- static unsigned char nset9[4] =
+ static const __u8 nset9[4] =
{ 0x0b, 0x04, 0x0a, 0x78 };
- static unsigned char nset8[6] =
+ static const __u8 nset8[6] =
{ 0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00 };
- static unsigned char nset10[6] =
+ static const __u8 nset10[6] =
{ 0x0c, 0x03, 0xab, 0x10, 0x81, 0x20 };
t16RegWrite(dev, 0x01, 0x0000, n1, 0x06);
t16RegWrite(dev, 0x01, 0x0000, n3, 0x06);
t16RegWrite(dev, 0x01, 0x0000, n4, 0x46);
t16RegRead(dev, 0x0080, &test_byte, 1);
- t16RegWrite(dev, 0x00, 0x2c80, 0x00, 0x0);
+ t16RegWrite(dev, 0x00, 0x2c80, NULL, 0x0);
t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14);
t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12);
t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12);
- t16RegWrite(dev, 0x00, 0x3880, 0x00, 0x0);
- t16RegWrite(dev, 0x00, 0x3880, 0x00, 0x0);
- t16RegWrite(dev, 0x00, 0x338e, 0x00, 0x0);
+ t16RegWrite(dev, 0x00, 0x3880, NULL, 0x0);
+ t16RegWrite(dev, 0x00, 0x3880, NULL, 0x0);
+ t16RegWrite(dev, 0x00, 0x338e, NULL, 0x0);
t16RegWrite(dev, 0x01, 0x0000, nset5, 0x04);
- t16RegWrite(dev, 0x00, 0x00a9, 0x00, 0x0);
+ t16RegWrite(dev, 0x00, 0x00a9, NULL, 0x0);
t16RegWrite(dev, 0x01, 0x0000, nset6, 0x22);
- t16RegWrite(dev, 0x00, 0x86bb, 0x00, 0x0);
- t16RegWrite(dev, 0x00, 0x4aa6, 0x00, 0x0);
+ t16RegWrite(dev, 0x00, 0x86bb, NULL, 0x0);
+ t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0x0);
t16RegWrite(dev, 0x01, 0x0000, missing, 0x08);
- t16RegWrite(dev, 0x00, 0x2087, 0x00, 0x0);
- t16RegWrite(dev, 0x00, 0x2088, 0x00, 0x0);
- t16RegWrite(dev, 0x00, 0x2089, 0x00, 0x0);
+ t16RegWrite(dev, 0x00, 0x2087, NULL, 0x0);
+ t16RegWrite(dev, 0x00, 0x2088, NULL, 0x0);
+ t16RegWrite(dev, 0x00, 0x2089, NULL, 0x0);
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, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0x2880, NULL, 0x00);
t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14);
t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12);
t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12);
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
unsigned int brightness;
- unsigned char set6[4] = { 0x8f, 0x26, 0xc3, 0x80 };
+ __u8 set6[4] = { 0x8f, 0x26, 0xc3, 0x80 };
brightness = sd->brightness;
if (brightness < 7) {
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- unsigned char flipcmd[8] =
+ __u8 flipcmd[8] =
{ 0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09 };
if (sd->mirror == 1)
}
if (sd->effect == 1 || sd->effect == 4)
- t16RegWrite(dev, 0x00, 0x4aa6, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0x00);
else
- t16RegWrite(dev, 0x00, 0xfaa6, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0xfaa6, NULL, 0x00);
}
static void setwhitebalance(struct gspca_dev *gspca_dev)
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- unsigned char white_balance[8] =
+ __u8 white_balance[8] =
{ 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 };
if (sd->whitebalance == 1)
else
reg_to_write = (0x00a9 + ((contrast - 7) * 0x200));
- t16RegWrite(dev, 0x00, reg_to_write, 0x00, 0);
-
+ t16RegWrite(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 = 0x00;
+ __u16 reg_to_write;
reg_to_write = 0xc0bb + sd->colors * 0x100;
- t16RegWrite(dev, 0x00, reg_to_write, 0x00, 0);
+ t16RegWrite(dev, 0x00, reg_to_write, NULL, 0);
}
static void setgamma(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- __u16 reg_to_write = 0x00;
+ __u16 reg_to_write;
reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
- t16RegWrite(dev, 0x00, reg_to_write, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, reg_to_write, NULL, 0x00);
}
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
{
struct sd *sd = (struct sd *) gspca_dev;
+
*val = sd->brightness;
return *val;
}
return *val;
}
-
static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val)
{
struct sd *sd = (struct sd *) gspca_dev;
sd->autogain = val;
if (val != 0)
- t16RegWrite(dev, 0x00, 0xf48e, 0x00, 0);
+ t16RegWrite(dev, 0x00, 0xf48e, NULL, 0);
else
- t16RegWrite(dev, 0x00, 0xb48e, 0x00, 0);
+ t16RegWrite(dev, 0x00, 0xb48e, NULL, 0);
return 0;
}
int mode;
__u8 test_byte;
- static __u8 t1[] = { 0x66, 0x00, 0xa8, 0xe8 };
+ static const __u8 t1[] = { 0x66, 0x00, 0xa8, 0xe8 };
__u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
- static __u8 t3[] =
+ static const __u8 t3[] =
{ 0xb3, 0x07, 0xb4, 0x00, 0xb5, 0x88, 0xb6, 0x02, 0xb7, 0x06,
0xb8, 0x00, 0xb9, 0xe7, 0xba, 0x01 };
- static __u8 t4[] = { 0x0b, 0x04, 0x0a, 0x40 };
+ static const __u8 t4[] = { 0x0b, 0x04, 0x0a, 0x40 };
mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. mode;
switch (mode) {
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, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0x3c80, NULL, 0x00);
/* just in case and to keep sync with logs (for mine) */
t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
- t16RegWrite(dev, 0x00, 0x3c80, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0x3c80, NULL, 0x00);
/* 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, 0x1);
t16RegWrite(dev, 0x01, 0x0000, t3, 0x10);
- t16RegWrite(dev, 0x00, 0x0013, 0x00, 0x00);
+ t16RegWrite(dev, 0x00, 0x0013, NULL, 0x00);
t16RegWrite(dev, 0x01, 0x0000, t4, 0x4);
/* restart on each start, just in case, sometimes regs goes wrong
* when using controls from app */
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso packet length */
{
int sof = 0;
- static unsigned char ffd9[] = { 0xff, 0xd9 };
+ static __u8 ffd9[] = { 0xff, 0xd9 };
if (data[0] == 0x5a) {
/* Control Packet, after this came the header again,
static int sd_querymenu(struct gspca_dev *gspca_dev,
struct v4l2_querymenu *menu)
{
- memset(menu->name, 0, sizeof menu->name);
-
switch (menu->id) {
case V4L2_CID_POWER_LINE_FREQUENCY:
switch (menu->index) {
case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
- strcpy(menu->name, "50 Hz");
+ strcpy((char *) menu->name, "50 Hz");
return 0;
case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
- strcpy(menu->name, "60 Hz");
+ strcpy((char *) menu->name, "60 Hz");
return 0;
}
break;
case V4L2_CID_EFFECTS:
- if (menu->index < 0 || menu->index >= NUM_EFFECTS_CONTROL)
- return -EINVAL;
- strncpy((char *) menu->name,
- effects_control[menu->index].name, 32);
+ if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
+ strncpy((char *) menu->name,
+ effects_control[menu->index], 32);
+ return 0;
+ }
break;
}
- return 0;
+ return -EINVAL;
}
/* this function is called at open time */
}
/* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x17a1, 0x0128), DVNM("XPX Webcam")},
{}
};
-
MODULE_DEVICE_TABLE(usb, device_table);
/* -- device connect -- */
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("TV8532 USB Camera Driver");
#define TV8532_AD_ROWBEGIN_L 0x14
#define TV8532_AD_ROWBEGIN_H 0x15
-static __u32 tv_8532_eeprom_data[] = {
+static const __u32 tv_8532_eeprom_data[] = {
/* add dataL dataM dataH */
0x00010001, 0x01018011, 0x02050014, 0x0305001c,
0x040d001e, 0x0505001f, 0x06050519, 0x0705011b,
static void tv_8532ReadRegisters(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 data = 0;
+ __u8 data;
/* __u16 vid, pid; */
reg_r(dev, 0x0001, &data);
static void tv_8532_setReg(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 data = 0;
+ __u8 data;
__u8 value[2] = { 0, 0 };
data = ADCBEGINL;
static void tv_8532_PollReg(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 data = 0;
+ __u8 data;
int i;
/* strange polling from tgc */
static int sd_open(struct gspca_dev *gspca_dev)
{
struct usb_device *dev = gspca_dev->dev;
- __u8 data = 0;
- __u8 dataStart = 0;
- __u8 value[2] = { 0, 0 };
+ __u8 data;
+ __u8 dataStart;
+ __u8 value[2];
data = 0x32;
reg_w(dev, TV8532_AD_SLOPE, &data, 1);
}
/* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x046d, 0x0920), DVNM("QC Express")},
{USB_DEVICE(0x046d, 0x0921), DVNM("Labtec Webcam")},
{USB_DEVICE(0x0545, 0x808b), DVNM("Veo Stingray")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/VC032X USB Camera Driver");
{V4L2_PIX_FMT_JPEG, 640, 480, 0},
};
-static __u8 mi1310_socinitVGA_JPG[][4] = {
+static const __u8 mi1310_socinitVGA_JPG[][4] = {
{0xb0, 0x03, 0x19, 0xcc},
{0xb0, 0x04, 0x02, 0xcc},
{0xb3, 0x00, 0x64, 0xcc},
{0x03, 0x03, 0xc0, 0xbb},
{},
};
-static __u8 mi1310_socinitQVGA_JPG[][4] = {
+static const __u8 mi1310_socinitQVGA_JPG[][4] = {
{0xb0, 0x03, 0x19, 0xcc}, {0xb0, 0x04, 0x02, 0xcc},
{0xb3, 0x00, 0x64, 0xcc}, {0xb3, 0x00, 0x65, 0xcc},
{0xb3, 0x05, 0x00, 0xcc}, {0xb3, 0x06, 0x00, 0xcc},
{},
};
-static __u8 mi1320_gamma[17] = {
+static const __u8 mi1320_gamma[17] = {
0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
};
-static __u8 mi1320_matrix[9] = {
+static const __u8 mi1320_matrix[9] = {
0x54, 0xda, 0x06, 0xf1, 0x50, 0xf4, 0xf7, 0xea, 0x52
};
-static __u8 mi1320_initVGA_data[][4] = {
+static const __u8 mi1320_initVGA_data[][4] = {
{0xb3, 0x01, 0x01, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{0xb0, 0x03, 0x19, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{0xb0, 0x04, 0x02, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{0xb3, 0x5c, 0x01, 0xcc}, {0xb3, 0x01, 0x41, 0xcc},
{}
};
-static __u8 mi1320_initQVGA_data[][4] = {
+static const __u8 mi1320_initQVGA_data[][4] = {
{0xb3, 0x01, 0x01, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{0xb0, 0x03, 0x19, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{0xb0, 0x04, 0x02, 0xcc}, {0x00, 0x00, 0x33, 0xdd},
{}
};
-static __u8 po3130_gamma[17] = {
+static const __u8 po3130_gamma[17] = {
0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
};
-static __u8 po3130_matrix[9] = {
+static const __u8 po3130_matrix[9] = {
0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
};
-static __u8 po3130_initVGA_data[][4] = {
+static const __u8 po3130_initVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd}, {0xb0, 0x03, 0x01, 0xcc},
{0xb3, 0x00, 0x04, 0xcc}, {0xb3, 0x00, 0x24, 0xcc},
{0xb3, 0x5c, 0x00, 0xcc}, {0xb3, 0x01, 0x41, 0xcc},
{}
};
-static __u8 po3130_rundata[][4] = {
+static const __u8 po3130_rundata[][4] = {
{0x00, 0x47, 0x45, 0xaa}, {0x00, 0x48, 0x9b, 0xaa},
{0x00, 0x49, 0x3a, 0xaa}, {0x00, 0x4a, 0x01, 0xaa},
{0x00, 0x44, 0x40, 0xaa},
{}
};
-static __u8 po3130_initQVGA_data[][4] = {
+static const __u8 po3130_initQVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd}, {0xb0, 0x03, 0x09, 0xcc},
{0xb3, 0x00, 0x04, 0xcc}, {0xb3, 0x00, 0x24, 0xcc},
{}
};
-static __u8 hv7131r_gamma[17] = {
+static const __u8 hv7131r_gamma[17] = {
/* 0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
* 0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff */
0x04, 0x1a, 0x36, 0x55, 0x6f, 0x87, 0x9d, 0xb0, 0xc1,
0xcf, 0xda, 0xe4, 0xec, 0xf3, 0xf8, 0xfd, 0xff
};
-static __u8 hv7131r_matrix[9] = {
+static const __u8 hv7131r_matrix[9] = {
0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
};
-static __u8 hv7131r_initVGA_data[][4] = {
+static const __u8 hv7131r_initVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd}, {0xb0, 0x03, 0x01, 0xcc},
{0xb3, 0x00, 0x24, 0xcc},
{}
};
-static __u8 hv7131r_initQVGA_data[][4] = {
+static const __u8 hv7131r_initQVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd}, {0xb0, 0x03, 0x01, 0xcc},
{0xb3, 0x00, 0x24, 0xcc},
{}
};
-static __u8 ov7660_gamma[17] = {
+static const __u8 ov7660_gamma[17] = {
0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
};
-static __u8 ov7660_matrix[9] = {
+static const __u8 ov7660_matrix[9] = {
0x5a, 0xf0, 0xf6, 0xf3, 0x57, 0xf6, 0xf3, 0xef, 0x62
};
-static __u8 ov7660_initVGA_data[][4] = {
+static const __u8 ov7660_initVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd},
{0xb0, 0x03, 0x01, 0xcc},
{0x00, 0x29, 0x3c, 0xaa}, {0xb3, 0x01, 0x45, 0xcc},
{}
};
-static __u8 ov7660_initQVGA_data[][4] = {
+static const __u8 ov7660_initQVGA_data[][4] = {
{0xb0, 0x4d, 0x00, 0xcc}, {0xb3, 0x01, 0x01, 0xcc},
{0x00, 0x00, 0x50, 0xdd}, {0xb0, 0x03, 0x01, 0xcc},
{0xb3, 0x00, 0x21, 0xcc}, {0xb3, 0x00, 0x26, 0xcc},
{0x00, 0x00, 0x00, 0x00}
};
-static __u8 ov7660_50HZ[][4] = {
+static const __u8 ov7660_50HZ[][4] = {
{0x00, 0x3b, 0x08, 0xaa},
{0x00, 0x9d, 0x40, 0xaa},
{0x00, 0x13, 0xa7, 0xaa},
{0x00, 0x00, 0x00, 0x00}
};
-static __u8 ov7660_60HZ[][4] = {
+static const __u8 ov7660_60HZ[][4] = {
{0x00, 0x3b, 0x00, 0xaa},
{0x00, 0x9e, 0x40, 0xaa},
{0x00, 0x13, 0xa7, 0xaa},
{}
};
-static __u8 ov7660_NoFliker[][4] = {
+static const __u8 ov7660_NoFliker[][4] = {
{0x00, 0x13, 0x87, 0xaa},
{}
};
-static __u8 ov7670_initVGA_JPG[][4] = {
+static const __u8 ov7670_initVGA_JPG[][4] = {
{0xb3, 0x01, 0x05, 0xcc},
{0x00, 0x00, 0x30, 0xdd}, {0xb0, 0x03, 0x19, 0xcc},
{0x00, 0x00, 0x10, 0xdd},
{},
};
-static __u8 ov7670_initQVGA_JPG[][4] = {
+static const __u8 ov7670_initQVGA_JPG[][4] = {
{0xb3, 0x01, 0x05, 0xcc}, {0x00, 0x00, 0x30, 0xdd},
{0xb0, 0x03, 0x19, 0xcc}, {0x00, 0x00, 0x10, 0xdd},
{0xb0, 0x04, 0x02, 0xcc}, {0x00, 0x00, 0x10, 0xdd},
__u8 op;
};
-static struct sensor_info sensor_info_data[] = {
+static const struct sensor_info sensor_info_data[] = {
/* sensorId, I2cAdd, IdAdd, VpId, m1, m2, op */
{SENSOR_HV7131R, 0x80 | 0x11, 0x00, 0x0209, 0x24, 0x25, 0x01},
{SENSOR_OV7660, 0x80 | 0x21, 0x0a, 0x7660, 0x26, 0x26, 0x05},
int i;
__u8 data;
__u16 value;
- struct sensor_info *ptsensor_info;
+ const struct sensor_info *ptsensor_info;
reg_r(dev, 0xa1, 0xbfcf, &data, 1);
PDEBUG(D_PROBE, "check sensor header %d", data);
}
static __u8 i2c_write(struct usb_device *dev,
- __u8 reg, __u8 *val, __u8 size)
+ __u8 reg, const __u8 *val, __u8 size)
{
__u8 retbyte;
}
static void put_tab_to_reg(struct gspca_dev *gspca_dev,
- __u8 *tab, __u8 tabsize, __u16 addr)
+ const __u8 *tab, __u8 tabsize, __u16 addr)
{
int j;
__u16 ad = addr;
}
static void usb_exchange(struct gspca_dev *gspca_dev,
- __u8 data[][4])
+ const __u8 data[][4])
{
struct usb_device *dev = gspca_dev->dev;
int i = 0;
static void setlightfreq(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
- static __u8 (*ov7660_freq_tb[3])[4] =
+ static const __u8 (*ov7660_freq_tb[3])[4] =
{ov7660_NoFliker, ov7660_50HZ, ov7660_60HZ};
if (sd->sensor != SENSOR_OV7660)
{
struct sd *sd = (struct sd *) gspca_dev;
/* __u8 tmp2; */
- __u8 *GammaT = NULL;
- __u8 *MatrixT = NULL;
+ const __u8 *GammaT = NULL;
+ const __u8 *MatrixT = NULL;
int mode;
/* Assume start use the good resolution from gspca_dev->mode */
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
- unsigned char *data, /* isoc packet */
+ __u8 *data, /* isoc packet */
int len) /* iso pkt length */
{
struct sd *sd = (struct sd *) gspca_dev;
case V4L2_CID_POWER_LINE_FREQUENCY:
switch (menu->index) {
case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
- strcpy(menu->name, "NoFliker");
+ strcpy((char *) menu->name, "NoFliker");
return 0;
case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
- strcpy(menu->name, "50 Hz");
+ strcpy((char *) menu->name, "50 Hz");
return 0;
case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
- strcpy(menu->name, "60 Hz");
+ strcpy((char *) menu->name, "60 Hz");
return 0;
}
break;
}
/* sub-driver description */
-static struct sd_desc sd_desc = {
+static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
/* -- 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(0x046d, 0x0892), DVNM("Logitech Orbicam")},
{USB_DEVICE(0x046d, 0x0896), DVNM("Logitech Orbicam")},
{USB_DEVICE(0x0ac8, 0x0321), DVNM("Vimicro generic vc0321")},
#include "gspca.h"
-#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
-static const char version[] = "2.1.0";
+#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4)
+static const char version[] = "2.1.4";
MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>, "
"Serge A. Suchkov <Serge.A.S@tochka.ru>");
__u16 idx;
};
-static struct usb_action cs2102_Initial[] = {
+static const struct usb_action cs2102_Initial[] = {
{0xa1, 0x01, 0x0008},
{0xa1, 0x01, 0x0008},
{0xa0, 0x01, 0x0000},
{}
};
-static struct usb_action cs2102_InitialScale[] = {
+static const struct usb_action cs2102_InitialScale[] = {
{0xa1, 0x01, 0x0008},
{0xa1, 0x01, 0x0008},
{0xa0, 0x01, 0x0000},
{0xa0, 0x40, 0x0118},
{}
};
-static struct usb_action cs2102_50HZ[] = {
+static const struct usb_action cs2102_50HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x008c}, /* 00,0f,8c,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
{0xa0, 0xd0, 0x001f}, /* 00,1f,d0,cc */
{}
};
-static struct usb_action cs2102_50HZScale[] = {
+static const struct usb_action cs2102_50HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x0093}, /* 00,0f,93,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
{0xa0, 0xd0, 0x001f}, /* 00,1f,d0,cc */
{}
};
-static struct usb_action cs2102_60HZ[] = {
+static const struct usb_action cs2102_60HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x005d}, /* 00,0f,5d,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
{0xa0, 0xd0, 0x00c8}, /* 00,c8,d0,cc */
{}
};
-static struct usb_action cs2102_60HZScale[] = {
+static const struct usb_action cs2102_60HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x00b7}, /* 00,0f,b7,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
{0xa0, 0xe8, 0x001f}, /* 00,1f,e8,cc */
{}
};
-static struct usb_action cs2102_NoFliker[] = {
+static const struct usb_action cs2102_NoFliker[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x0059}, /* 00,0f,59,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
{0xa0, 0xc8, 0x001f}, /* 00,1f,c8,cc */
{}
};
-static struct usb_action cs2102_NoFlikerScale[] = {
+static const struct usb_action cs2102_NoFlikerScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0f, 0x0059}, /* 00,0f,59,aa */
{0xaa, 0x03, 0x0005}, /* 00,03,05,aa */
};
/* CS2102_KOCOM */
-static struct usb_action cs2102K_Initial[] = {
+static const struct usb_action cs2102K_Initial[] = {
{0xa0, 0x11, 0x0002},
{0xa0, 0x03, 0x0008},
{0xa0, 0x08, 0x0010},
{}
};
-static struct usb_action cs2102K_InitialScale[] = {
+static const struct usb_action cs2102K_InitialScale[] = {
{0xa0, 0x11, 0x0002},
{0xa0, 0x00, 0x0002},
{0xa0, 0x03, 0x0008},
{}
};
-static struct usb_action gc0305_Initial[] = { /* 640x480 */
+static const struct usb_action gc0305_Initial[] = { /* 640x480 */
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x03, 0x0008}, /* 00,08,03,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
{0xa0, 0x03, 0x0113}, /* 01,13,03,cc */
{}
};
-static struct usb_action gc0305_InitialScale[] = { /* 320x240 */
+static const struct usb_action gc0305_InitialScale[] = { /* 320x240 */
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x03, 0x0008}, /* 00,08,03,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
{0xa0, 0x03, 0x0113}, /* 01,13,03,cc */
{}
};
-static struct usb_action gc0305_50HZ[] = {
+static const struct usb_action gc0305_50HZ[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0002}, /* 00,83,02,aa */
{0xaa, 0x84, 0x0038}, /* 00,84,38,aa */ /* win: 00,84,ec */
/* {0xa0, 0x85, 0x018d}, * 01,8d,85,cc * * if 640x480 */
{}
};
-static struct usb_action gc0305_60HZ[] = {
+static const struct usb_action gc0305_60HZ[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0000}, /* 00,83,00,aa */
{0xaa, 0x84, 0x00ec}, /* 00,84,ec,aa */
{}
};
-static struct usb_action gc0305_NoFliker[] = {
+static const struct usb_action gc0305_NoFliker[] = {
{0xa0, 0x0c, 0x0100}, /* 01,00,0c,cc */
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0000}, /* 00,83,00,aa */
};
/* play poker with registers at your own risk !! */
-static struct usb_action hdcs2020xx_Initial[] = {
+static const struct usb_action hdcs2020xx_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x03, 0x0008},
{0xa0, 0x0e, 0x0010},
{}
};
-static struct usb_action hdcs2020xx_InitialScale[] = {
+static const struct usb_action hdcs2020xx_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x03, 0x0008},
{0xa0, 0x0e, 0x0010},
/* {0xa0, 0x18, 0x00fe}, */
{}
};
-static struct usb_action hdcs2020xb_Initial[] = {
+static const struct usb_action hdcs2020xb_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x11, 0x0002},
{0xa0, 0x03, 0x0008}, /* qtable 0x05 */
{0xa0, 0x40, 0x0118},
{}
};
-static struct usb_action hdcs2020xb_InitialScale[] = {
+static const struct usb_action hdcs2020xb_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x00, 0x0002},
{0xa0, 0x03, 0x0008},
{0xa0, 0x40, 0x0118},
{}
};
-static struct usb_action hdcs2020b_50HZ[] = {
+static const struct usb_action hdcs2020b_50HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x13, 0x0018}, /* 00,13,18,aa */
{0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
{0xa0, 0x2f, 0x001f}, /* 00,1f,2f,cc */
{}
};
-static struct usb_action hdcs2020b_60HZ[] = {
+static const struct usb_action hdcs2020b_60HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x13, 0x0031}, /* 00,13,31,aa */
{0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
{0xa0, 0x2c, 0x001f}, /* 00,1f,2c,cc */
{}
};
-static struct usb_action hdcs2020b_NoFliker[] = {
+static const struct usb_action hdcs2020b_NoFliker[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x13, 0x0010}, /* 00,13,10,aa */
{0xaa, 0x14, 0x0001}, /* 00,14,01,aa */
{}
};
-static struct usb_action hv7131bxx_Initial[] = {
+static const struct usb_action hv7131bxx_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x10, 0x0002},
{0xa0, 0x00, 0x0010},
{}
};
-static struct usb_action hv7131bxx_InitialScale[] = {
+static const struct usb_action hv7131bxx_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x00, 0x0002},
{0xa0, 0x00, 0x0010},
{}
};
-static struct usb_action hv7131cxx_Initial[] = {
+static const struct usb_action hv7131cxx_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x10, 0x0002},
{0xa0, 0x01, 0x0010},
{}
};
-static struct usb_action hv7131cxx_InitialScale[] = {
+static const struct usb_action hv7131cxx_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x00, 0x0002}, /* diff */
{}
};
-static struct usb_action icm105axx_Initial[] = {
+static const struct usb_action icm105axx_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x10, 0x0002},
{0xa0, 0x03, 0x0008},
{}
};
-static struct usb_action icm105axx_InitialScale[] = {
+static const struct usb_action icm105axx_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x00, 0x0002},
{0xa0, 0x03, 0x0008},
{0xa0, 0x40, 0x0118},
{}
};
-static struct usb_action icm105a_50HZ[] = {
+static const struct usb_action icm105a_50HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x0020}, /* 00,0c,20,aa */
{0xa0, 0xff, 0x0020}, /* 00,20,ff,cc */
{}
};
-static struct usb_action icm105a_50HZScale[] = {
+static const struct usb_action icm105a_50HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x008c}, /* 00,0c,8c,aa */
{0xa0, 0xc0, 0x01a8}, /* 01,a8,c0,cc */
{}
};
-static struct usb_action icm105a_60HZ[] = {
+static const struct usb_action icm105a_60HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
{0xa0, 0xff, 0x0020}, /* 00,20,ff,cc */
{}
};
-static struct usb_action icm105a_60HZScale[] = {
+static const struct usb_action icm105a_60HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x0008}, /* 00,0c,08,aa */
{0xa0, 0xc0, 0x01a8}, /* 01,a8,c0,cc */
{}
};
-static struct usb_action icm105a_NoFliker[] = {
+static const struct usb_action icm105a_NoFliker[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
{0xa0, 0xff, 0x0020}, /* 00,20,ff,cc */
{}
};
-static struct usb_action icm105a_NoFlikerScale[] = {
+static const struct usb_action icm105a_NoFlikerScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0x0d, 0x0003}, /* 00,0d,03,aa */
{0xaa, 0x0c, 0x0004}, /* 00,0c,04,aa */
{}
};
-static struct usb_action MC501CB_InitialScale[] = {
+static const struct usb_action MC501CB_InitialScale[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x00, 0x0002}, /* 00,02,00,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
{}
};
-static struct usb_action MC501CB_Initial[] = { /* 320x240 */
+static const struct usb_action MC501CB_Initial[] = { /* 320x240 */
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x10, 0x0002}, /* 00,02,10,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
{}
};
-static struct usb_action MC501CB_50HZ[] = {
+static const struct usb_action MC501CB_50HZ[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x001d}, /* 00,36,1D,aa */
{}
};
-static struct usb_action MC501CB_50HZScale[] = {
+static const struct usb_action MC501CB_50HZScale[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x003a}, /* 00,36,3A,aa */
{}
};
-static struct usb_action MC501CB_60HZ[] = {
+static const struct usb_action MC501CB_60HZ[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
{}
};
-static struct usb_action MC501CB_60HZScale[] = {
+static const struct usb_action MC501CB_60HZScale[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
{}
};
-static struct usb_action MC501CB_NoFliker[] = {
+static const struct usb_action MC501CB_NoFliker[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
{}
};
-static struct usb_action MC501CB_NoFlikerScale[] = {
+static const struct usb_action MC501CB_NoFlikerScale[] = {
{0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
{0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
{0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
};
/* from zs211.inf - HKR,%OV7620%,Initial - 640x480 */
-static struct usb_action OV7620_mode0[] = {
+static const struct usb_action OV7620_mode0[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x40, 0x0002}, /* 00,02,40,cc */
{0xa0, 0x00, 0x0008}, /* 00,08,00,cc */
};
/* from zs211.inf - HKR,%OV7620%,InitialScale - 320x240 */
-static struct usb_action OV7620_mode1[] = {
+static const struct usb_action OV7620_mode1[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x50, 0x0002}, /* 00,02,50,cc */
{0xa0, 0x03, 0x0008}, /* 00,08,00,cc */ /* mx change? */
};
/* from zs211.inf - HKR,%OV7620%\AE,50HZ */
-static struct usb_action OV7620_50HZ[] = {
+static const struct usb_action OV7620_50HZ[] = {
{0xaa, 0x13, 0x00a3}, /* 00,13,a3,aa */
{0xdd, 0x00, 0x0100}, /* 00,01,00,dd */
{0xaa, 0x2b, 0x0096}, /* 00,2b,96,aa */
};
/* from zs211.inf - HKR,%OV7620%\AE,60HZ */
-static struct usb_action OV7620_60HZ[] = {
+static const struct usb_action OV7620_60HZ[] = {
{0xaa, 0x13, 0x00a3}, /* 00,13,a3,aa */ /* (bug in zs211.inf) */
{0xdd, 0x00, 0x0100}, /* 00,01,00,dd */
{0xaa, 0x2b, 0x0000}, /* 00,2b,00,aa */
};
/* from zs211.inf - HKR,%OV7620%\AE,NoFliker */
-static struct usb_action OV7620_NoFliker[] = {
+static const struct usb_action OV7620_NoFliker[] = {
{0xaa, 0x13, 0x00a3}, /* 00,13,a3,aa */ /* (bug in zs211.inf) */
{0xdd, 0x00, 0x0100}, /* 00,01,00,dd */
{0xaa, 0x2b, 0x0000}, /* 00,2b,00,aa */
{}
};
-static struct usb_action ov7630c_Initial[] = {
+static const struct usb_action ov7630c_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x10, 0x0002},
{0xa0, 0x01, 0x0000},
{}
};
-static struct usb_action ov7630c_InitialScale[] = {
+static const struct usb_action ov7630c_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x00, 0x0002},
{0xa0, 0x03, 0x0008},
{}
};
-static struct usb_action pas106b_Initial_com[] = {
+static const struct usb_action pas106b_Initial_com[] = {
/* Sream and Sensor specific */
{0xa1, 0x01, 0x0010}, /* CMOSSensorSelect */
/* System */
{}
};
-static struct usb_action pas106b_Initial[] = { /* 176x144 */
+static const struct usb_action pas106b_Initial[] = { /* 176x144 */
/* JPEG control */
{0xa0, 0x03, 0x0008}, /* ClockSetting */
/* Sream and Sensor specific */
{}
};
-static struct usb_action pas106b_InitialScale[] = { /* 352x288 */
+static const struct usb_action pas106b_InitialScale[] = { /* 352x288 */
/* JPEG control */
{0xa0, 0x03, 0x0008}, /* ClockSetting */
/* Sream and Sensor specific */
{0xa0, 0xff, 0x0018}, /* Frame adjust */
{}
};
-static struct usb_action pas106b_50HZ[] = {
+static const struct usb_action pas106b_50HZ[] = {
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x06, 0x0191}, /* 01,91,06,cc */
{0xa0, 0x54, 0x0192}, /* 01,92,54,cc */
{0xa0, 0x04, 0x01a9}, /* 01,a9,04,cc */
{}
};
-static struct usb_action pas106b_60HZ[] = {
+static const struct usb_action pas106b_60HZ[] = {
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x06, 0x0191}, /* 01,91,06,cc */
{0xa0, 0x2e, 0x0192}, /* 01,92,2e,cc */
{0xa0, 0x04, 0x01a9}, /* 01,a9,04,cc */
{}
};
-static struct usb_action pas106b_NoFliker[] = {
+static const struct usb_action pas106b_NoFliker[] = {
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x06, 0x0191}, /* 01,91,06,cc */
{0xa0, 0x50, 0x0192}, /* 01,92,50,cc */
{}
};
-static struct usb_action pb03303x_Initial[] = {
+static const struct usb_action pb03303x_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x03, 0x0008},
{0xa0, 0x0a, 0x0010},
{}
};
-static struct usb_action pb03303x_InitialScale[] = {
+static const struct usb_action pb03303x_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x03, 0x0008},
{0xa0, 0x0a, 0x0010},
{0xa0, 0x42, 0x0180},
{}
};
-static struct usb_action pb0330xx_Initial[] = {
+static const struct usb_action pb0330xx_Initial[] = {
{0xa1, 0x01, 0x0008},
{0xa1, 0x01, 0x0008},
{0xa0, 0x01, 0x0000},
{}
};
-static struct usb_action pb0330xx_InitialScale[] = {
+static const struct usb_action pb0330xx_InitialScale[] = {
{0xa1, 0x01, 0x0008},
{0xa1, 0x01, 0x0008},
{0xa0, 0x01, 0x0000},
/* {0xa0, 0x00, 0x0007}, */
{}
};
-static struct usb_action pb0330_50HZ[] = {
+static const struct usb_action pb0330_50HZ[] = {
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
{0xa0, 0xee, 0x0192}, /* 01,92,ee,cc */
{0xa0, 0xc8, 0x001f}, /* 00,1f,c8,cc */
{}
};
-static struct usb_action pb0330_50HZScale[] = {
+static const struct usb_action pb0330_50HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
{0xa0, 0xf8, 0x001f}, /* 00,1f,f8,cc */
{}
};
-static struct usb_action pb0330_60HZ[] = {
+static const struct usb_action pb0330_60HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
{0xa0, 0x90, 0x001f}, /* 00,1f,90,cc */
{}
};
-static struct usb_action pb0330_60HZScale[] = {
+static const struct usb_action pb0330_60HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
{0xa0, 0x90, 0x001f}, /* 00,1f,90,cc */
{}
};
-static struct usb_action pb0330_NoFliker[] = {
+static const struct usb_action pb0330_NoFliker[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
{0xa0, 0x90, 0x001f}, /* 00,1f,90,cc */
{}
};
-static struct usb_action pb0330_NoFlikerScale[] = {
+static const struct usb_action pb0330_NoFlikerScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xa0, 0x00, 0x0190}, /* 01,90,00,cc */
{0xa0, 0x07, 0x0191}, /* 01,91,07,cc */
};
/* from oem9.inf - HKR,%PO2030%,Initial - 640x480 - (close to CS2102) */
-static struct usb_action PO2030_mode0[] = {
+static const struct usb_action PO2030_mode0[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x04, 0x0002}, /* 00,02,04,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
};
/* from oem9.inf - HKR,%PO2030%,InitialScale - 320x240 */
-static struct usb_action PO2030_mode1[] = {
+static const struct usb_action PO2030_mode1[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc */
{0xa0, 0x10, 0x0002}, /* 00,02,10,cc */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc */
{}
};
-static struct usb_action PO2030_50HZ[] = {
+static const struct usb_action PO2030_50HZ[] = {
{0xaa, 0x8d, 0x0008}, /* 00,8d,08,aa */
{0xaa, 0x1a, 0x0001}, /* 00,1a,01,aa */
{0xaa, 0x1b, 0x000a}, /* 00,1b,0a,aa */
{}
};
-static struct usb_action PO2030_60HZ[] = {
+static const struct usb_action PO2030_60HZ[] = {
{0xaa, 0x8d, 0x0008}, /* 00,8d,08,aa */
{0xaa, 0x1a, 0x0000}, /* 00,1a,00,aa */
{0xaa, 0x1b, 0x00de}, /* 00,1b,de,aa */
{}
};
-static struct usb_action PO2030_NoFliker[] = {
+static const struct usb_action PO2030_NoFliker[] = {
{0xa0, 0x02, 0x0180}, /* 01,80,02,cc */
{0xaa, 0x8d, 0x000d}, /* 00,8d,0d,aa */
{0xaa, 0x1a, 0x0000}, /* 00,1a,00,aa */
};
/* TEST */
-static struct usb_action tas5130CK_Initial[] = {
+static const struct usb_action tas5130CK_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x01, 0x003b},
{0xa0, 0x0e, 0x003a},
{}
};
-static struct usb_action tas5130CK_InitialScale[] = {
+static const struct usb_action tas5130CK_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x01, 0x003b},
{0xa0, 0x0e, 0x003a},
{}
};
-static struct usb_action tas5130cxx_Initial[] = {
+static const struct usb_action tas5130cxx_Initial[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x50, 0x0002},
{0xa0, 0x03, 0x0008},
{0xa0, 0x42, 0x0180},
{}
};
-static struct usb_action tas5130cxx_InitialScale[] = {
+static const struct usb_action tas5130cxx_InitialScale[] = {
{0xa0, 0x01, 0x0000},
{0xa0, 0x01, 0x0000},
{0xa0, 0x40, 0x0002},
{0xa0, 0x42, 0x0180},
{}
};
-static struct usb_action tas5130cxx_50HZ[] = {
+static const struct usb_action tas5130cxx_50HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0063}, /* 00,a4,63,aa */
{0xa0, 0x03, 0x009f}, /* 00,9f,03,cc */
{}
};
-static struct usb_action tas5130cxx_50HZScale[] = {
+static const struct usb_action tas5130cxx_50HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0077}, /* 00,a4,77,aa */
{0xa0, 0x03, 0x009f}, /* 00,9f,03,cc */
{}
};
-static struct usb_action tas5130cxx_60HZ[] = {
+static const struct usb_action tas5130cxx_60HZ[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0036}, /* 00,a4,36,aa */
{0xa0, 0x03, 0x009f}, /* 00,9f,03,cc */
{}
};
-static struct usb_action tas5130cxx_60HZScale[] = {
+static const struct usb_action tas5130cxx_60HZScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0077}, /* 00,a4,77,aa */
{0xa0, 0x03, 0x009f}, /* 00,9f,03,cc */
{}
};
-static struct usb_action tas5130cxx_NoFliker[] = {
+static const struct usb_action tas5130cxx_NoFliker[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0040}, /* 00,a4,40,aa */
{}
};
-static struct usb_action tas5130cxx_NoFlikerScale[] = {
+static const struct usb_action tas5130cxx_NoFlikerScale[] = {
{0xa0, 0x00, 0x0019}, /* 00,19,00,cc */
{0xaa, 0xa3, 0x0001}, /* 00,a3,01,aa */
{0xaa, 0xa4, 0x0090}, /* 00,a4,90,aa */
{}
};
-static struct usb_action tas5130c_vf0250_Initial[] = {
+static const struct usb_action tas5130c_vf0250_Initial[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc, */
{0xa0, 0x02, 0x0008}, /* 00,08,02,cc, */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc, */
{}
};
-static struct usb_action tas5130c_vf0250_InitialScale[] = {
+static const struct usb_action tas5130c_vf0250_InitialScale[] = {
{0xa0, 0x01, 0x0000}, /* 00,00,01,cc, */
{0xa0, 0x02, 0x0008}, /* 00,08,02,cc, */
{0xa0, 0x01, 0x0010}, /* 00,10,01,cc, */
{}
};
/* "50HZ" light frequency banding filter */
-static struct usb_action tas5130c_vf0250_50HZ[] = {
+static const struct usb_action tas5130c_vf0250_50HZ[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0001}, /* 00,83,01,aa */
{0xaa, 0x84, 0x00aa}, /* 00,84,aa,aa */
};
/* "50HZScale" light frequency banding filter */
-static struct usb_action tas5130c_vf0250_50HZScale[] = {
+static const struct usb_action tas5130c_vf0250_50HZScale[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0003}, /* 00,83,03,aa */
{0xaa, 0x84, 0x0054}, /* 00,84,54,aa */
};
/* "60HZ" light frequency banding filter */
-static struct usb_action tas5130c_vf0250_60HZ[] = {
+static const struct usb_action tas5130c_vf0250_60HZ[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0001}, /* 00,83,01,aa */
{0xaa, 0x84, 0x0062}, /* 00,84,62,aa */
};
/* "60HZScale" light frequency banding ilter */
-static struct usb_action tas5130c_vf0250_60HZScale[] = {
+static const struct usb_action tas5130c_vf0250_60HZScale[] = {
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0002}, /* 00,83,02,aa */
{0xaa, 0x84, 0x00c4}, /* 00,84,c4,aa */
};
/* "NoFliker" light frequency banding flter */
-static struct usb_action tas5130c_vf0250_NoFliker[] = {
+static const struct usb_action tas5130c_vf0250_NoFliker[] = {
{0xa0, 0x0c, 0x0100}, /* 01,00,0c,cc, */
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0000}, /* 00,83,00,aa */
};
/* "NoFlikerScale" light frequency banding filter */
-static struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
+static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = {
{0xa0, 0x0c, 0x0100}, /* 01,00,0c,cc, */
{0xaa, 0x82, 0x0000}, /* 00,82,00,aa */
{0xaa, 0x83, 0x0000}, /* 00,83,00,aa */
}
static void usb_exchange(struct usb_device *dev,
- struct usb_action *action)
+ const struct usb_action *action)
{
__u8 buffread;
{
struct sd *sd = (struct sd *) gspca_dev;
int i;
- __u8 *matrix;
- static __u8 gc0305_matrix[9] =
+ const __u8 *matrix;
+ static const __u8 gc0305_matrix[9] =
{0x50, 0xf8, 0xf8, 0xf8, 0x50, 0xf8, 0xf8, 0xf8, 0x50};
- static __u8 ov7620_matrix[9] =
+ static const __u8 ov7620_matrix[9] =
{0x58, 0xf4, 0xf4, 0xf4, 0x58, 0xf4, 0xf4, 0xf4, 0x58};
- static __u8 po2030_matrix[9] =
+ static const __u8 po2030_matrix[9] =
{0x60, 0xf0, 0xf0, 0xf0, 0x60, 0xf0, 0xf0, 0xf0, 0x60};
switch (sd->sensor) {
struct usb_device *dev = gspca_dev->dev;
int sharpness;
__u8 retbyte;
- static __u8 sharpness_tb[][2] = {
+ static const __u8 sharpness_tb[][2] = {
{0x02, 0x03},
{0x04, 0x07},
{0x08, 0x0f},
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- __u8 *Tgamma, *Tgradient;
+ const __u8 *Tgamma, *Tgradient;
int g, i, k;
- static __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 __u8 kgrad_tb[16] =
+ static const __u8 kgrad_tb[16] =
{0x1b, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x04};
- static __u8 Tgamma_1[16] =
+ static const __u8 Tgamma_1[16] =
{0x00, 0x00, 0x03, 0x0d, 0x1b, 0x2e, 0x45, 0x5f,
0x79, 0x93, 0xab, 0xc1, 0xd4, 0xe5, 0xf3, 0xff};
- static __u8 Tgradient_1[16] =
+ static const __u8 Tgradient_1[16] =
{0x00, 0x01, 0x05, 0x0b, 0x10, 0x15, 0x18, 0x1a,
0x1a, 0x18, 0x16, 0x14, 0x12, 0x0f, 0x0d, 0x06};
- static __u8 Tgamma_2[16] =
+ static const __u8 Tgamma_2[16] =
{0x01, 0x0c, 0x1f, 0x3a, 0x53, 0x6d, 0x85, 0x9c,
0xb0, 0xc2, 0xd1, 0xde, 0xe9, 0xf2, 0xf9, 0xff};
- static __u8 Tgradient_2[16] =
+ static const __u8 Tgradient_2[16] =
{0x05, 0x0f, 0x16, 0x1a, 0x19, 0x19, 0x17, 0x15,
0x12, 0x10, 0x0e, 0x0b, 0x09, 0x08, 0x06, 0x03};
- static __u8 Tgamma_3[16] =
+ static const __u8 Tgamma_3[16] =
{0x04, 0x16, 0x30, 0x4e, 0x68, 0x81, 0x98, 0xac,
0xbe, 0xcd, 0xda, 0xe4, 0xed, 0xf5, 0xfb, 0xff};
- static __u8 Tgradient_3[16] =
+ static const __u8 Tgradient_3[16] =
{0x0c, 0x16, 0x1b, 0x1c, 0x19, 0x18, 0x15, 0x12,
0x10, 0x0d, 0x0b, 0x09, 0x08, 0x06, 0x05, 0x03};
- static __u8 Tgamma_4[16] =
+ static const __u8 Tgamma_4[16] =
{0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff};
- static __u8 Tgradient_4[16] =
+ static const __u8 Tgradient_4[16] =
{0x26, 0x22, 0x20, 0x1c, 0x16, 0x13, 0x10, 0x0d,
0x0b, 0x09, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02};
- static __u8 Tgamma_5[16] =
+ static const __u8 Tgamma_5[16] =
{0x20, 0x4b, 0x6e, 0x8d, 0xa3, 0xb5, 0xc5, 0xd2,
0xdc, 0xe5, 0xec, 0xf2, 0xf6, 0xfa, 0xfd, 0xff};
- static __u8 Tgradient_5[16] =
+ static const __u8 Tgradient_5[16] =
{0x37, 0x26, 0x20, 0x1a, 0x14, 0x10, 0x0e, 0x0b,
0x09, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x02};
- static __u8 Tgamma_6[16] = /* ?? was gamma 5 */
+ static const __u8 Tgamma_6[16] = /* ?? was gamma 5 */
{0x24, 0x44, 0x64, 0x84, 0x9d, 0xb2, 0xc4, 0xd3,
0xe0, 0xeb, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff};
- static __u8 Tgradient_6[16] =
+ static const __u8 Tgradient_6[16] =
{0x18, 0x20, 0x20, 0x1c, 0x16, 0x13, 0x10, 0x0e,
0x0b, 0x09, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01};
- static __u8 *gamma_tb[] = {
+ static const __u8 *gamma_tb[] = {
0, Tgamma_1, Tgamma_2,
Tgamma_3, Tgamma_4, Tgamma_5, Tgamma_6
};
- static __u8 *gradient_tb[] = {
+ static const __u8 *gradient_tb[] = {
0, Tgradient_1, Tgradient_2,
Tgradient_3, Tgradient_4, Tgradient_5, Tgradient_6
};
{
struct sd *sd = (struct sd *) gspca_dev;
int i, mode;
- struct usb_action *zc3_freq;
- static struct usb_action *freq_tb[SENSOR_MAX][6] = {
+ const struct usb_action *zc3_freq;
+ static const struct usb_action *freq_tb[SENSOR_MAX][6] = {
/* SENSOR_CS2102 0 */
{cs2102_NoFliker, cs2102_NoFlikerScale,
cs2102_50HZ, cs2102_50HZScale,
int sensor;
__u8 bsensor;
int vga = 1; /* 1: vga, 0: sif */
- static __u8 gamma[SENSOR_MAX] = {
+ static const __u8 gamma[SENSOR_MAX] = {
5, /* SENSOR_CS2102 0 */
5, /* SENSOR_CS2102K 1 */
4, /* SENSOR_GC0305 2 */
{
struct sd *sd = (struct sd *) gspca_dev;
struct usb_device *dev = gspca_dev->dev;
- struct usb_action *zc3_init;
+ const struct usb_action *zc3_init;
int mode;
__u8 retbyte;
- static struct usb_action *init_tb[SENSOR_MAX][2] = {
+ static const struct usb_action *init_tb[SENSOR_MAX][2] = {
{cs2102_InitialScale, cs2102_Initial}, /* 0 */
{cs2102K_InitialScale, cs2102K_Initial}, /* 1 */
{gc0305_Initial, gc0305_InitialScale}, /* 2 */
case V4L2_CID_POWER_LINE_FREQUENCY:
switch (menu->index) {
case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
- strcpy(menu->name, "NoFliker");
+ strcpy((char *) menu->name, "NoFliker");
return 0;
case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
- strcpy(menu->name, "50 Hz");
+ strcpy((char *) menu->name, "50 Hz");
return 0;
case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
- strcpy(menu->name, "60 Hz");
+ strcpy((char *) menu->name, "60 Hz");
return 0;
}
break;
return -EINVAL;
}
-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],
};
#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(0x041e, 0x041e), DVNM("Creative WebCam Live!")},
{USB_DEVICE(0x041e, 0x4017), DVNM("Creative Webcam Mobile PD1090")},
{USB_DEVICE(0x041e, 0x401c), DVNM("Creative NX")},
projects / linux-2.6 / commitdiff