From 6a7eba24e4f0ff725d33159f6265e3a79d53a833 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Mon, 30 Jun 2008 15:50:11 -0300 Subject: V4L/DVB (8157): gspca: all subdrivers - remaning subdrivers added - remove the decoding helper and some specific frame decodings Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/etoms.c | 1062 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1062 insertions(+) create mode 100644 drivers/media/video/gspca/etoms.c (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c new file mode 100644 index 00000000000..c479f638413 --- /dev/null +++ b/drivers/media/video/gspca/etoms.c @@ -0,0 +1,1062 @@ +/* + * Etoms Et61x151 GPL Linux driver by Michel Xhaard (09/09/2004) + * + * V4L2 by Jean-Francois Moine + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define MODULE_NAME "etoms" + +#include "gspca.h" + +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0) +static const char version[] = "2.1.0"; + +MODULE_AUTHOR("Michel Xhaard "); +MODULE_DESCRIPTION("Etoms USB Camera Driver"); +MODULE_LICENSE("GPL"); + +/* specific webcam descriptor */ +struct sd { + struct gspca_dev gspca_dev; /* !! must be the first item */ + + unsigned char brightness; + unsigned char contrast; + unsigned char colors; + unsigned char autogain; + + char sensor; +#define SENSOR_PAS106 0 +#define SENSOR_TAS5130CXX 1 + signed char ag_cnt; +#define AG_CNT_START 13 +}; + +/* V4L2 controls supported by the driver */ +static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val); +static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val); +static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val); +static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val); +static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val); +static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val); +static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val); +static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val); + +static struct ctrl sd_ctrls[] = { +#define SD_BRIGHTNESS 0 + { + { + .id = V4L2_CID_BRIGHTNESS, + .type = V4L2_CTRL_TYPE_INTEGER, + .name = "Brightness", + .minimum = 1, + .maximum = 127, + .step = 1, + .default_value = 63, + }, + .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, + .step = 1, + .default_value = 127, + }, + .set = sd_setcontrast, + .get = sd_getcontrast, + }, +#define SD_COLOR 2 + { + { + .id = V4L2_CID_SATURATION, + .type = V4L2_CTRL_TYPE_INTEGER, + .name = "Color", + .minimum = 0, + .maximum = 15, + .step = 1, + .default_value = 7, + }, + .set = sd_setcolors, + .get = sd_getcolors, + }, +#define SD_AUTOGAIN 3 + { + { + .id = V4L2_CID_AUTOGAIN, + .type = V4L2_CTRL_TYPE_BOOLEAN, + .name = "Auto Gain", + .minimum = 0, + .maximum = 1, + .step = 1, + .default_value = 1, + }, + .set = sd_setautogain, + .get = sd_getautogain, + }, +}; + +static struct cam_mode vga_mode[] = { + {V4L2_PIX_FMT_SBGGR8, 320, 240, 1}, +/* {V4L2_PIX_FMT_SBGGR8, 640, 480, 0}, */ +}; + +static struct cam_mode sif_mode[] = { + {V4L2_PIX_FMT_SBGGR8, 176, 144, 1}, + {V4L2_PIX_FMT_SBGGR8, 352, 288, 0}, +}; + +#define ETOMS_ALT_SIZE_1000 12 + +#define ET_GPIO_DIR_CTRL 0x04 /* Control IO bit[0..5] (0 in 1 out) */ +#define ET_GPIO_OUT 0x05 /* Only IO data */ +#define ET_GPIO_IN 0x06 /* Read Only IO data */ +#define ET_RESET_ALL 0x03 +#define ET_ClCK 0x01 +#define ET_CTRL 0x02 /* enable i2c OutClck Powerdown mode */ + +#define ET_COMP 0x12 /* Compression register */ +#define ET_MAXQt 0x13 +#define ET_MINQt 0x14 +#define ET_COMP_VAL0 0x02 +#define ET_COMP_VAL1 0x03 + +#define ET_REG1d 0x1d +#define ET_REG1e 0x1e +#define ET_REG1f 0x1f +#define ET_REG20 0x20 +#define ET_REG21 0x21 +#define ET_REG22 0x22 +#define ET_REG23 0x23 +#define ET_REG24 0x24 +#define ET_REG25 0x25 +/* base registers for luma calculation */ +#define ET_LUMA_CENTER 0x39 + +#define ET_G_RED 0x4d +#define ET_G_GREEN1 0x4e +#define ET_G_BLUE 0x4f +#define ET_G_GREEN2 0x50 +#define ET_G_GR_H 0x51 +#define ET_G_GB_H 0x52 + +#define ET_O_RED 0x34 +#define ET_O_GREEN1 0x35 +#define ET_O_BLUE 0x36 +#define ET_O_GREEN2 0x37 + +#define ET_SYNCHRO 0x68 +#define ET_STARTX 0x69 +#define ET_STARTY 0x6a +#define ET_WIDTH_LOW 0x6b +#define ET_HEIGTH_LOW 0x6c +#define ET_W_H_HEIGTH 0x6d + +#define ET_REG6e 0x6e /* OBW */ +#define ET_REG6f 0x6f /* OBW */ +#define ET_REG70 0x70 /* OBW_AWB */ +#define ET_REG71 0x71 /* OBW_AWB */ +#define ET_REG72 0x72 /* OBW_AWB */ +#define ET_REG73 0x73 /* Clkdelay ns */ +#define ET_REG74 0x74 /* test pattern */ +#define ET_REG75 0x75 /* test pattern */ + +#define ET_I2C_CLK 0x8c +#define ET_PXL_CLK 0x60 + +#define ET_I2C_BASE 0x89 +#define ET_I2C_COUNT 0x8a +#define ET_I2C_PREFETCH 0x8b +#define ET_I2C_REG 0x88 +#define ET_I2C_DATA7 0x87 +#define ET_I2C_DATA6 0x86 +#define ET_I2C_DATA5 0x85 +#define ET_I2C_DATA4 0x84 +#define ET_I2C_DATA3 0x83 +#define ET_I2C_DATA2 0x82 +#define ET_I2C_DATA1 0x81 +#define ET_I2C_DATA0 0x80 + +#define PAS106_REG2 0x02 /* pxlClk = systemClk/(reg2) */ +#define PAS106_REG3 0x03 /* line/frame H [11..4] */ +#define PAS106_REG4 0x04 /* line/frame L [3..0] */ +#define PAS106_REG5 0x05 /* exposure time line offset(default 5) */ +#define PAS106_REG6 0x06 /* exposure time pixel offset(default 6) */ +#define PAS106_REG7 0x07 /* signbit Dac (default 0) */ +#define PAS106_REG9 0x09 +#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 __u8 I2c2[] = { 0x08, 0x08, 0x08, 0x08, 0x0d }; + +static __u8 I2c3[] = { 0x12, 0x05 }; + +static __u8 I2c4[] = { 0x41, 0x08 }; + +static void Et_RegRead(struct usb_device *dev, + __u16 index, __u8 *buffer, int len) +{ + usb_control_msg(dev, + usb_rcvctrlpipe(dev, 0), + 0, + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, + 0, index, buffer, len, 500); +} + +static void Et_RegWrite(struct usb_device *dev, + __u16 index, __u8 *buffer, __u16 len) +{ + usb_control_msg(dev, + usb_sndctrlpipe(dev, 0), + 0, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, + 0, index, buffer, len, 500); +} + +static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 * buffer, + __u16 length, __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 */ + Et_RegWrite(dev, ET_I2C_BASE, &base, 1); +/* set count and prefetch */ + Et_RegWrite(dev, ET_I2C_COUNT, &ptchcount, 1); +/* set the register base */ + Et_RegWrite(dev, ET_I2C_REG, ®, 1); + j = length - 1; + for (i = 0; i < length; i++) { + Et_RegWrite(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); + j--; + } + return 0; +} + +static int Et_i2cread(struct usb_device *dev, __u8 reg, __u8 * buffer, + __u16 length, __u8 mode) +{ +/* 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 */ + Et_RegWrite(dev, ET_I2C_BASE, &base, 1); +/* set count and prefetch */ + Et_RegWrite(dev, ET_I2C_COUNT, &ptchcount, 1); +/* set the register base */ + Et_RegWrite(dev, ET_I2C_REG, ®, 1); + Et_RegWrite(dev, ET_I2C_PREFETCH, &prefetch, 1); + prefetch = 0x00; + Et_RegWrite(dev, ET_I2C_PREFETCH, &prefetch, 1); + j = length - 1; + for (i = 0; i < length; i++) { + Et_RegRead(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); + j--; + } + return 0; +} + +static int Et_WaitStatus(struct usb_device *dev) +{ + __u8 bytereceived; + int retry = 10; + + while (retry--) { + Et_RegRead(dev, ET_ClCK, &bytereceived, 1); + if (bytereceived != 0) + return 1; + } + return 0; +} + +static int Et_videoOff(struct usb_device *dev) +{ + int err; + __u8 stopvideo = 0; + + Et_RegWrite(dev, ET_GPIO_OUT, &stopvideo, 1); + 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 */ + + Et_RegWrite(dev, ET_GPIO_OUT, &startvideo, 1); + err = Et_WaitStatus(dev); + if (!err) + PDEBUG(D_ERR, "timeout Et_waitStatus VideoOFF"); + 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 }; + + PDEBUG(D_STREAM, "Open Init2 ET"); + value = 0x2f; + Et_RegWrite(dev, ET_GPIO_DIR_CTRL, &value, 1); + value = 0x10; + Et_RegWrite(dev, ET_GPIO_OUT, &value, 1); + Et_RegRead(dev, ET_GPIO_IN, &received, 1); + value = 0x14; /* 0x14 // 0x16 enabled pattern */ + Et_RegWrite(dev, ET_ClCK, &value, 1); + value = 0x1b; + Et_RegWrite(dev, ET_CTRL, &value, 1); + + /* 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 */ + Et_RegWrite(dev, ET_COMP, &value, 1); + value = 0x1f; + Et_RegWrite(dev, ET_MAXQt, &value, 1); + value = 0x04; + Et_RegWrite(dev, ET_MINQt, &value, 1); + /* undocumented registers */ + value = 0xff; + Et_RegWrite(dev, ET_REG1d, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG1e, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG1f, &value, 1); + value = 0x35; + Et_RegWrite(dev, ET_REG20, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_REG21, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_REG22, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG23, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG24, &value, 1); + value = 0x0f; + Et_RegWrite(dev, ET_REG25, &value, 1); + /* colors setting */ + value = 0x11; + Et_RegWrite(dev, 0x30, &value, 1); /* 0x30 */ + value = 0x40; + Et_RegWrite(dev, 0x31, &value, 1); + value = 0x00; + Et_RegWrite(dev, 0x32, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_O_RED, &value, 1); /* 0x34 */ + value = 0x00; + Et_RegWrite(dev, ET_O_GREEN1, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_O_BLUE, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_O_GREEN2, &value, 1); + /*************/ + value = 0x80; + Et_RegWrite(dev, ET_G_RED, &value, 1); /* 0x4d */ + value = 0x80; + Et_RegWrite(dev, ET_G_GREEN1, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_G_BLUE, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_G_GREEN2, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_G_GR_H, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_G_GB_H, &value, 1); /* 0x52 */ + /* Window control registers */ + + value = 0x80; /* use cmc_out */ + Et_RegWrite(dev, 0x61, &value, 1); + + value = 0x02; + Et_RegWrite(dev, 0x62, &value, 1); + value = 0x03; + Et_RegWrite(dev, 0x63, &value, 1); + value = 0x14; + Et_RegWrite(dev, 0x64, &value, 1); + value = 0x0e; + Et_RegWrite(dev, 0x65, &value, 1); + value = 0x02; + Et_RegWrite(dev, 0x66, &value, 1); + value = 0x02; + Et_RegWrite(dev, 0x67, &value, 1); + + /**************************************/ + value = 0x8f; + Et_RegWrite(dev, ET_SYNCHRO, &value, 1); /* 0x68 */ + value = 0x69; /* 0x6a //0x69 */ + Et_RegWrite(dev, ET_STARTX, &value, 1); + value = 0x0d; /* 0x0d //0x0c */ + Et_RegWrite(dev, ET_STARTY, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_WIDTH_LOW, &value, 1); + value = 0xe0; + Et_RegWrite(dev, ET_HEIGTH_LOW, &value, 1); + value = 0x60; + Et_RegWrite(dev, ET_W_H_HEIGTH, &value, 1); /* 6d */ + value = 0x86; + Et_RegWrite(dev, ET_REG6e, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_REG6f, &value, 1); + value = 0x26; + Et_RegWrite(dev, ET_REG70, &value, 1); + value = 0x7a; + Et_RegWrite(dev, ET_REG71, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_REG72, &value, 1); + /* Clock Pattern registers ***************** */ + value = 0x00; + Et_RegWrite(dev, ET_REG73, &value, 1); + value = 0x18; /* 0x28 */ + Et_RegWrite(dev, ET_REG74, &value, 1); + value = 0x0f; /* 0x01 */ + Et_RegWrite(dev, ET_REG75, &value, 1); + /**********************************************/ + value = 0x20; + Et_RegWrite(dev, 0x8a, &value, 1); + value = 0x0f; + Et_RegWrite(dev, 0x8d, &value, 1); + value = 0x08; + Et_RegWrite(dev, 0x8e, &value, 1); + /**************************************/ + value = 0x08; + Et_RegWrite(dev, 0x03, &value, 1); + value = 0x03; + Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + value = 0xff; + Et_RegWrite(dev, 0x81, &value, 1); + value = 0x00; + Et_RegWrite(dev, 0x80, &value, 1); + value = 0xff; + Et_RegWrite(dev, 0x81, &value, 1); + value = 0x20; + Et_RegWrite(dev, 0x80, &value, 1); + value = 0x01; + Et_RegWrite(dev, 0x03, &value, 1); + value = 0x00; + Et_RegWrite(dev, 0x03, &value, 1); + value = 0x08; + Et_RegWrite(dev, 0x03, &value, 1); + /********************************************/ + + /* Et_RegRead(dev,0x0,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 */ + Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + /* now set by fifo the FormatLine setting */ + Et_RegWrite(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 */ + Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + /* now set by fifo the FormatLine setting */ + Et_RegWrite(dev, 0x62, FormLine, 6); + } + + /* set exposure times [ 0..0x78] 0->longvalue 0x78->shortvalue */ + value = 0x47; /* 0x47; */ + Et_RegWrite(dev, 0x81, &value, 1); + value = 0x40; /* 0x40; */ + Et_RegWrite(dev, 0x80, &value, 1); + /* Pedro change */ + /* Brightness change Brith+ decrease value */ + /* Brigth- increase value */ + /* original value = 0x70; */ + value = 0x30; /* 0x20; */ + Et_RegWrite(dev, 0x81, &value, 1); /* set brightness */ + value = 0x20; /* 0x20; */ + Et_RegWrite(dev, 0x80, &value, 1); +} + +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 i2cflags = 0x01; + /* __u8 green = 0; */ + __u8 colors = sd->colors; + + I2cc[3] = colors; /* red */ + I2cc[0] = 15 - colors; /* blue */ + /* green = 15 - ((((7*I2cc[0]) >> 2 ) + I2cc[3]) >> 1); */ + /* I2cc[1] = I2cc[2] = green; */ + if (sd->sensor == SENSOR_PAS106) { + Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3); + Et_i2cwrite(dev, PAS106_REG9, I2cc, sizeof(I2cc), 1); + } +/* 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 valred; + + if (sd->sensor == SENSOR_PAS106) { + /* Et_i2cread(gspca_dev->dev,PAS106_REG9,&valblue,1,1); */ + Et_i2cread(gspca_dev->dev, PAS106_REG9 + 3, &valred, 1, 1); + sd->colors = valred & 0x0f; + } +} + +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 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}; + * 1/60000 hmm ?? */ + + PDEBUG(D_STREAM, "Open Init1 ET"); + value = 7; + Et_RegWrite(dev, ET_GPIO_DIR_CTRL, &value, 1); + Et_RegRead(dev, ET_GPIO_IN, &received, 1); + value = 1; + Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + value = 0; + Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + value = 0x10; + Et_RegWrite(dev, ET_ClCK, &value, 1); + value = 0x19; + Et_RegWrite(dev, ET_CTRL, &value, 1); + /* 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); + Et_RegWrite(dev, ET_COMP, &value, 1); + value = 0x1d; + Et_RegWrite(dev, ET_MAXQt, &value, 1); + value = 0x02; + Et_RegWrite(dev, ET_MINQt, &value, 1); + /* undocumented registers */ + value = 0xff; + Et_RegWrite(dev, ET_REG1d, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG1e, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG1f, &value, 1); + value = 0x35; + Et_RegWrite(dev, ET_REG20, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_REG21, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_REG22, &value, 1); + value = 0xf7; + Et_RegWrite(dev, ET_REG23, &value, 1); + value = 0xff; + Et_RegWrite(dev, ET_REG24, &value, 1); + value = 0x07; + Et_RegWrite(dev, ET_REG25, &value, 1); + /* colors setting */ + value = 0x80; + Et_RegWrite(dev, ET_G_RED, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_G_GREEN1, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_G_BLUE, &value, 1); + value = 0x80; + Et_RegWrite(dev, ET_G_GREEN2, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_G_GR_H, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_G_GB_H, &value, 1); + /* Window control registers */ + value = 0xf0; + Et_RegWrite(dev, ET_SYNCHRO, &value, 1); + value = 0x56; /* 0x56 */ + Et_RegWrite(dev, ET_STARTX, &value, 1); + value = 0x05; /* 0x04 */ + Et_RegWrite(dev, ET_STARTY, &value, 1); + value = 0x60; + Et_RegWrite(dev, ET_WIDTH_LOW, &value, 1); + value = 0x20; + Et_RegWrite(dev, ET_HEIGTH_LOW, &value, 1); + value = 0x50; + Et_RegWrite(dev, ET_W_H_HEIGTH, &value, 1); + value = 0x86; + Et_RegWrite(dev, ET_REG6e, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_REG6f, &value, 1); + value = 0x86; + Et_RegWrite(dev, ET_REG70, &value, 1); + value = 0x14; + Et_RegWrite(dev, ET_REG71, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_REG72, &value, 1); + /* Clock Pattern registers */ + value = 0x00; + Et_RegWrite(dev, ET_REG73, &value, 1); + value = 0x00; + Et_RegWrite(dev, ET_REG74, &value, 1); + value = 0x0a; + Et_RegWrite(dev, ET_REG75, &value, 1); + value = 0x04; + Et_RegWrite(dev, ET_I2C_CLK, &value, 1); + value = 0x01; + Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + /* 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); + value = 0x06; + Et_i2cwrite(dev, PAS106_REG2, &value, 1, 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); + value = 0x0a; + + Et_i2cwrite(dev, PAS106_REG2, &value, 1, 1); + Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof(I2c3), 1); + value = 0x04; + /* value = 0x10; */ + Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1); + /* bit 2 enable bit 1:2 select 0 1 2 3 + value = 0x07; * curve 0 * + Et_i2cwrite(dev,PAS106_REG0f,&value,1,1); + */ + } + +/* value = 0x01; */ +/* value = 0x22; */ +/* Et_i2cwrite(dev, PAS106_REG5, &value, 1, 1); */ + /* magnetude and sign bit for DAC */ + Et_i2cwrite(dev, PAS106_REG7, I2c4, sizeof I2c4, 1); + /* now set by fifo the whole colors setting */ + Et_RegWrite(dev, ET_G_RED, GainRGBG, 6); + getcolors(gspca_dev); + setcolors(gspca_dev); +} + +/* this function is called at probe time */ +static int sd_config(struct gspca_dev *gspca_dev, + const struct usb_device_id *id) +{ + struct sd *sd = (struct sd *) gspca_dev; + struct cam *cam; + __u16 vendor; + __u16 product; + + vendor = id->idVendor; + product = id->idProduct; +/* switch (vendor) { */ +/* case 0x102c: * Etoms */ + switch (product) { + case 0x6151: + sd->sensor = SENSOR_PAS106; /* Etoms61x151 */ + break; + case 0x6251: + sd->sensor = SENSOR_TAS5130CXX; /* Etoms61x251 */ + break; +/* } */ +/* break; */ + } + cam = &gspca_dev->cam; + cam->dev_name = (char *) id->driver_info; + cam->epaddr = 1; + if (sd->sensor == SENSOR_PAS106) { + cam->cam_mode = sif_mode; + cam->nmodes = sizeof sif_mode / sizeof sif_mode[0]; + } else { + 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; + return 0; +} + +/* this function is called at open time */ +static int sd_open(struct gspca_dev *gspca_dev) +{ + 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; + Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + err = Et_videoOff(dev); + PDEBUG(D_STREAM, "Et_Init_VideoOff %d", err); + return 0; +} + +/* -- start the camera -- */ +static void sd_start(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + struct usb_device *dev = gspca_dev->dev; + int err; + __u8 value; + + if (sd->sensor == SENSOR_PAS106) + Et_init1(gspca_dev); + else + Et_init2(gspca_dev); + + value = 0x08; + Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + err = Et_videoOn(dev); + PDEBUG(D_STREAM, "Et_VideoOn %d", err); +} + +static void sd_stopN(struct gspca_dev *gspca_dev) +{ + int err; + + err = Et_videoOff(gspca_dev->dev); + PDEBUG(D_STREAM, "Et_VideoOff %d", err); + +} + +static void sd_stop0(struct gspca_dev *gspca_dev) +{ +} + +static void sd_close(struct gspca_dev *gspca_dev) +{ +} + +static void setbrightness(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + int i; + __u8 brightness = sd->brightness; + + for (i = 0; i < 4; i++) + Et_RegWrite(gspca_dev->dev, (ET_O_RED + i), &brightness, 1); +} + +static void getbrightness(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + int i; + int brightness = 0; + __u8 value = 0; + + for (i = 0; i < 4; i++) { + Et_RegRead(gspca_dev->dev, (ET_O_RED + i), &value, 1); + brightness += value; + } + sd->brightness = brightness >> 3; +} + +static void setcontrast(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + __u8 RGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 }; + __u8 contrast = sd->contrast; + + memset(RGBG, contrast, sizeof RGBG - 2); + Et_RegWrite(gspca_dev->dev, ET_G_RED, RGBG, 6); +} + +static void getcontrast(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + int i; + int contrast = 0; + __u8 value = 0; + + for (i = 0; i < 4; i++) { + Et_RegRead(gspca_dev->dev, (ET_G_RED + i), &value, 1); + contrast += value; + } + sd->contrast = contrast >> 2; +} + +static __u8 Et_getgainG(struct gspca_dev *gspca_dev) +{ + struct sd *sd = (struct sd *) gspca_dev; + __u8 value = 0; + + if (sd->sensor == SENSOR_PAS106) { + Et_i2cread(gspca_dev->dev, PAS106_REG0e, &value, 1, 1); + PDEBUG(D_CONF, "Etoms gain G %d", value); + return value; + } + return 0x1f; +} + +static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain) +{ + struct sd *sd = (struct sd *) gspca_dev; + struct usb_device *dev = gspca_dev->dev; + __u8 i2cflags = 0x01; + + if (sd->sensor == SENSOR_PAS106) { + Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3); + Et_i2cwrite(dev, PAS106_REG0e, &gain, 1, 1); + } +} + +#define BLIMIT(bright) \ + (__u8)((bright > 0x1f)?0x1f:((bright < 4)?3:bright)) +#define LIMIT(color) \ + (unsigned char)((color > 0xff)?0xff:((color < 0)?0:color)) + +static void setautogain(struct gspca_dev *gspca_dev) +{ + struct usb_device *dev = gspca_dev->dev; + __u8 GRBG[] = { 0, 0, 0, 0 }; + __u8 luma = 0; + __u8 luma_mean = 128; + __u8 luma_delta = 20; + __u8 spring = 4; + int Gbright = 0; + __u8 r, g, b; + + Gbright = Et_getgainG(gspca_dev); + Et_RegRead(dev, ET_LUMA_CENTER, GRBG, 4); + g = (GRBG[0] + GRBG[3]) >> 1; + r = GRBG[1]; + b = GRBG[2]; + r = ((r << 8) - (r << 4) - (r << 3)) >> 10; + b = ((b << 7) >> 10); + g = ((g << 9) + (g << 7) + (g << 5)) >> 10; + luma = LIMIT(r + g + b); + PDEBUG(D_FRAM, "Etoms luma G %d", luma); + if (luma < luma_mean - luma_delta || luma > luma_mean + luma_delta) { + Gbright += (luma_mean - luma) >> spring; + Gbright = BLIMIT(Gbright); + PDEBUG(D_FRAM, "Etoms Gbright %d", Gbright); + Et_setgainG(gspca_dev, (__u8) Gbright); + } +} + +#undef BLIMIT +#undef LIMIT + +static void sd_pkt_scan(struct gspca_dev *gspca_dev, + struct gspca_frame *frame, /* target */ + unsigned char *data, /* isoc packet */ + int len) /* iso packet length */ +{ + struct sd *sd; + int seqframe; + + seqframe = data[0] & 0x3f; + len = (int) (((data[0] & 0xc0) << 2) | data[1]); + if (seqframe == 0x3f) { + PDEBUG(D_FRAM, + "header packet found datalength %d !!", len); + PDEBUG(D_FRAM, "G %d R %d G %d B %d", + data[2], data[3], data[4], data[5]); + data += 30; + /* don't change datalength as the chips provided it */ + frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, + data, 0); + gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len); + sd = (struct sd *) gspca_dev; + if (sd->ag_cnt >= 0) { + if (--sd->ag_cnt < 0) { + sd->ag_cnt = AG_CNT_START; + setautogain(gspca_dev); + } + } + return; + } + if (len) { + data += 8; + gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len); + } else { /* Drop Packet */ + gspca_dev->last_packet_type = DISCARD_PACKET; + } +} + +static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + sd->brightness = val; + if (gspca_dev->streaming) + setbrightness(gspca_dev); + return 0; +} + +static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + getbrightness(gspca_dev); + *val = sd->brightness; + return 0; +} + +static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + sd->contrast = val; + if (gspca_dev->streaming) + setcontrast(gspca_dev); + return 0; +} + +static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + getcontrast(gspca_dev); + *val = sd->contrast; + return 0; +} + +static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + sd->colors = val; + if (gspca_dev->streaming) + setcolors(gspca_dev); + return 0; +} + +static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + getcolors(gspca_dev); + *val = sd->colors; + return 0; +} + +static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + sd->autogain = val; + if (val) + sd->ag_cnt = AG_CNT_START; + else + sd->ag_cnt = -1; + return 0; +} + +static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) +{ + struct sd *sd = (struct sd *) gspca_dev; + + *val = sd->autogain; + return 0; +} + +/* sub-driver description */ +static struct sd_desc sd_desc = { + .name = MODULE_NAME, + .ctrls = sd_ctrls, + .nctrls = ARRAY_SIZE(sd_ctrls), + .config = sd_config, + .open = sd_open, + .start = sd_start, + .stopN = sd_stopN, + .stop0 = sd_stop0, + .close = sd_close, + .pkt_scan = sd_pkt_scan, +}; + +/* -- module initialisation -- */ +#define DVNM(name) .driver_info = (kernel_ulong_t) name +static __devinitdata struct usb_device_id device_table[] = { + {USB_DEVICE(0x102c, 0x6151), DVNM("Qcam Sangha CIF")}, + {USB_DEVICE(0x102c, 0x6251), DVNM("Qcam xxxxxx VGA")}, + {} +}; + +MODULE_DEVICE_TABLE(usb, device_table); + +/* -- device connect -- */ +static int sd_probe(struct usb_interface *intf, + const struct usb_device_id *id) +{ + return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), + THIS_MODULE); +} + +static struct usb_driver sd_driver = { + .name = MODULE_NAME, + .id_table = device_table, + .probe = sd_probe, + .disconnect = gspca_disconnect, +}; + +/* -- module insert / remove -- */ +static int __init sd_mod_init(void) +{ + if (usb_register(&sd_driver) < 0) + return -1; + PDEBUG(D_PROBE, "v%s registered", version); + return 0; +} + +static void __exit sd_mod_exit(void) +{ + usb_deregister(&sd_driver); + PDEBUG(D_PROBE, "deregistered"); +} + +module_init(sd_mod_init); +module_exit(sd_mod_exit); -- cgit v1.2.3-70-g09d2 From 956e42d28f300f5bb928fb5850b3e3c0a8982d23 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Tue, 1 Jul 2008 10:03:42 -0300 Subject: V4L/DVB (8180): Source cleanup - compile error with VIDEO_ADV_DEBUG. main, etoms, mars, pac207, pac7311, sonixb, sonixj, spca500, spca505: Cleanup source. sunplus: Compilation error when VIDEO_ADV_DEBUG set. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/etoms.c | 4 ++-- drivers/media/video/gspca/gspca.c | 8 ++++---- drivers/media/video/gspca/mars.c | 6 ++++-- drivers/media/video/gspca/pac207.c | 24 ++++++++++++------------ drivers/media/video/gspca/pac7311.c | 3 ++- drivers/media/video/gspca/sonixb.c | 2 +- drivers/media/video/gspca/sonixj.c | 2 +- drivers/media/video/gspca/spca500.c | 9 +++++---- drivers/media/video/gspca/spca505.c | 2 +- drivers/media/video/gspca/sunplus.c | 6 +++--- 10 files changed, 35 insertions(+), 31 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index c479f638413..195b8123ba7 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -233,7 +233,7 @@ static void Et_RegWrite(struct usb_device *dev, 0, index, buffer, len, 500); } -static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 * buffer, +static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 *buffer, __u16 length, __u8 mode) { /* buffer should be [D0..D7] */ @@ -256,7 +256,7 @@ static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 * buffer, return 0; } -static int Et_i2cread(struct usb_device *dev, __u8 reg, __u8 * buffer, +static int Et_i2cread(struct usb_device *dev, __u8 reg, __u8 *buffer, __u16 length, __u8 mode) { /* buffer should be [D0..D7] */ diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c index c84e0b352f4..13cd9968f1f 100644 --- a/drivers/media/video/gspca/gspca.c +++ b/drivers/media/video/gspca/gspca.c @@ -28,9 +28,9 @@ #include #include #include -#include +#include #include -#include +#include #include #include "gspca.h" @@ -45,8 +45,8 @@ MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("GSPCA USB Camera Driver"); MODULE_LICENSE("GPL"); -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0) -static const char version[] = "2.1.0"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 1) +static const char version[] = "2.1.1"; static int video_nr = -1; diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c index 48b861d6829..d8cd2148f30 100644 --- a/drivers/media/video/gspca/mars.c +++ b/drivers/media/video/gspca/mars.c @@ -220,13 +220,15 @@ static void sd_start(struct gspca_dev *gspca_dev) if (0) { /* fixed dark-gain */ data[1] = 0; /* reg 94, Y Gain (1.75) */ data[2] = 0; /* reg 95, UV Gain (1.75) */ - data[3] = 0x3f; /* reg 96, Y Gain/UV Gain/disable auto dark-gain */ + data[3] = 0x3f; /* reg 96, Y Gain/UV Gain/disable + * auto dark-gain */ data[4] = 0; /* reg 97, set fixed dark level */ data[5] = 0; /* reg 98, don't care */ } else { /* auto dark-gain */ data[1] = 0; /* reg 94, Y Gain (auto) */ data[2] = 0; /* reg 95, UV Gain (1.75) */ - data[3] = 0x78; /* reg 96, Y Gain/UV Gain/disable auto dark-gain */ + data[3] = 0x78; /* reg 96, Y Gain/UV Gain/disable + * auto dark-gain */ switch (gspca_dev->width) { /* case 1280: */ /* data[4] = 154; diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c index 008954e755f..84986684c4d 100644 --- a/drivers/media/video/gspca/pac207.c +++ b/drivers/media/video/gspca/pac207.c @@ -452,30 +452,30 @@ static void pac207_do_auto_gain(struct gspca_dev *gspca_dev) for (i = 0; i < steps; i++) { if (avg_lum > desired_avg_lum) { - if (sd->gain > PAC207_GAIN_KNEE) { + if (sd->gain > PAC207_GAIN_KNEE) sd->gain--; - } else if (sd->exposure > PAC207_EXPOSURE_KNEE) { + else if (sd->exposure > PAC207_EXPOSURE_KNEE) sd->exposure--; - } else if (sd->gain > PAC207_GAIN_DEFAULT) { + else if (sd->gain > PAC207_GAIN_DEFAULT) sd->gain--; - } else if (sd->exposure > PAC207_EXPOSURE_MIN) { + else if (sd->exposure > PAC207_EXPOSURE_MIN) sd->exposure--; - } else if (sd->gain > PAC207_GAIN_MIN) { + else if (sd->gain > PAC207_GAIN_MIN) sd->gain--; - } else + else break; } else { - if (sd->gain < PAC207_GAIN_DEFAULT) { + if (sd->gain < PAC207_GAIN_DEFAULT) sd->gain++; - } else if (sd->exposure < PAC207_EXPOSURE_KNEE) { + else if (sd->exposure < PAC207_EXPOSURE_KNEE) sd->exposure++; - } else if (sd->gain < PAC207_GAIN_KNEE) { + else if (sd->gain < PAC207_GAIN_KNEE) sd->gain++; - } else if (sd->exposure < PAC207_EXPOSURE_MAX) { + else if (sd->exposure < PAC207_EXPOSURE_MAX) sd->exposure++; - } else if (sd->gain < PAC207_GAIN_MAX) { + else if (sd->gain < PAC207_GAIN_MAX) sd->gain++; - } else + else break; } } diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c index 8f51976db99..14eb25d8184 100644 --- a/drivers/media/video/gspca/pac7311.c +++ b/drivers/media/video/gspca/pac7311.c @@ -714,7 +714,8 @@ static __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x093a, 0x2601), DVNM("Philips SPC610NC")}, {USB_DEVICE(0x093a, 0x2603), DVNM("PAC7312")}, {USB_DEVICE(0x093a, 0x2608), DVNM("Trust WB-3300p")}, - {USB_DEVICE(0x093a, 0x260e), DVNM("Gigaware VGA PC Camera, Trust WB-3350p, SIGMA cam 2350")}, + {USB_DEVICE(0x093a, 0x260e), DVNM("Gigaware VGA PC Camera")}, + /* and also ', Trust WB-3350p, SIGMA cam 2350' */ {USB_DEVICE(0x093a, 0x260f), DVNM("SnakeCam")}, {USB_DEVICE(0x093a, 0x2621), DVNM("PAC731x")}, {} diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c index d26255ddfd5..80911a21e4a 100644 --- a/drivers/media/video/gspca/sonixb.c +++ b/drivers/media/video/gspca/sonixb.c @@ -831,7 +831,7 @@ static __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x0c45, 0x6007), DVNM("Sonix sn9c101 + Tas5110D")}, {USB_DEVICE(0x0c45, 0x6009), DVNM("spcaCam@120")}, {USB_DEVICE(0x0c45, 0x600d), DVNM("spcaCam@120")}, - {USB_DEVICE(0x0c45, 0x6011), DVNM("MAX Webcam Microdia-OV6650-SN9C101G")}, + {USB_DEVICE(0x0c45, 0x6011), DVNM("MAX Webcam Microdia")}, {USB_DEVICE(0x0c45, 0x6019), DVNM("Generic Sonix OV7630")}, {USB_DEVICE(0x0c45, 0x6024), DVNM("Generic Sonix Tas5130c")}, {USB_DEVICE(0x0c45, 0x6025), DVNM("Xcam Shanga")}, diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index 6180bc565ca..e6a49fe2c4e 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -1076,7 +1076,7 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev, | ((expo & 0x0003) << 4); i2c_w8(gspca_dev->dev, expoMo10); i2c_w8(gspca_dev->dev, gainMo); - PDEBUG(D_CONF," set exposure %d", + PDEBUG(D_CONF, "set exposure %d", ((expoMo10[3] & 0x07) << 10) | (expoMof[3] << 2) | ((expoMo10[3] & 0x30) >> 4)); diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c index c0dd969a310..e72fca5744a 100644 --- a/drivers/media/video/gspca/spca500.c +++ b/drivers/media/video/gspca/spca500.c @@ -336,7 +336,7 @@ static unsigned char qtable_kodak_ez200[2][64] = { }; static unsigned char qtable_pocketdv[2][64] = { - { /* Q-table Y-components start registers 0x8800 */ + { /* Q-table Y-components start registers 0x8800 */ 0x06, 0x04, 0x04, 0x06, 0x0a, 0x10, 0x14, 0x18, 0x05, 0x05, 0x06, 0x08, 0x0a, 0x17, 0x18, 0x16, 0x06, 0x05, 0x06, 0x0a, 0x10, 0x17, 0x1c, 0x16, @@ -346,7 +346,7 @@ static unsigned char qtable_pocketdv[2][64] = { 0x14, 0x1a, 0x1f, 0x23, 0x29, 0x30, 0x30, 0x28, 0x1d, 0x25, 0x26, 0x27, 0x2d, 0x28, 0x29, 0x28, }, - { /* Q-table C-components start registers 0x8840 */ + { /* Q-table C-components start registers 0x8840 */ 0x07, 0x07, 0x0a, 0x13, 0x28, 0x28, 0x28, 0x28, 0x07, 0x08, 0x0a, 0x1a, 0x28, 0x28, 0x28, 0x28, 0x0a, 0x0a, 0x16, 0x28, 0x28, 0x28, 0x28, 0x28, @@ -833,7 +833,8 @@ static void sd_start(struct gspca_dev *gspca_dev) * - NWG (Sat 29th March 2003) */ /* do a full reset */ - if ((err = spca500_full_reset(gspca_dev)) < 0) + err = spca500_full_reset(gspca_dev); + if (err < 0) PDEBUG(D_ERR, "spca500_full_reset failed"); /* enable drop packet */ @@ -918,7 +919,7 @@ static void sd_start(struct gspca_dev *gspca_dev) /* Init SDRAM - needed for SDRAM access */ reg_write(gspca_dev->dev, 0x00, 0x870a, 0x04); - spca500_setmode(gspca_dev,xmult,ymult); + spca500_setmode(gspca_dev, xmult, ymult); /* switch to video camera mode */ reg_write(gspca_dev->dev, 0x00, 0x8000, 0x0004); diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c index 5b23518d970..d8ff121c2c5 100644 --- a/drivers/media/video/gspca/spca505.c +++ b/drivers/media/video/gspca/spca505.c @@ -904,7 +904,7 @@ MODULE_DEVICE_TABLE(usb, device_table); static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id) { - return gspca_dev_probe(intf, id, &sd_desc, sizeof (struct sd), + return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), THIS_MODULE); } diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c index 52d1b32523b..25c5245725d 100644 --- a/drivers/media/video/gspca/sunplus.c +++ b/drivers/media/video/gspca/sunplus.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0) -static const char version[] = "2.1.0"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 1) +static const char version[] = "2.1.1"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver"); @@ -459,7 +459,7 @@ static int reg_write(struct usb_device *dev, USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, index, NULL, 0, 500); PDEBUG(D_PACK, "reg write: 0x%02x,0x%02x:0x%02x, 0x%x", - reg, index, value, ret); + req, index, value, ret); if (ret < 0) PDEBUG(D_ERR, "reg write: error %d", ret); return ret; -- cgit v1.2.3-70-g09d2 From bf7f0b98426b54c29ec8100a3f1963114c2f2ef0 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Thu, 3 Jul 2008 11:09:12 -0300 Subject: V4L/DVB (8193): gspca: Input buffer may be changed on reg write. Done for conex, etoms, pac7311, sonixj, t613 and tv8532. Code cleanup for some other subdrivers. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/conex.c | 41 +++--- drivers/media/video/gspca/etoms.c | 279 ++++++++++++++++++------------------ drivers/media/video/gspca/mars.c | 48 +++---- drivers/media/video/gspca/pac7311.c | 63 ++++---- drivers/media/video/gspca/sonixb.c | 2 +- drivers/media/video/gspca/sonixj.c | 17 ++- drivers/media/video/gspca/spca500.c | 2 +- drivers/media/video/gspca/sunplus.c | 2 +- drivers/media/video/gspca/t613.c | 33 +++-- drivers/media/video/gspca/tv8532.c | 13 +- 10 files changed, 257 insertions(+), 243 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c index b0294c9274e..473bea750b5 100644 --- a/drivers/media/video/gspca/conex.c +++ b/drivers/media/video/gspca/conex.c @@ -25,8 +25,8 @@ #define CONEX_CAM 1 /* special JPEG header */ #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, 3) +static const char version[] = "2.1.3"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA USB Conexant Camera Driver"); @@ -114,21 +114,29 @@ static void reg_r(struct usb_device *dev, 0, index, buffer, length, 500); - PDEBUG(D_USBI, "reg read i:%02x -> %02x", index, *buffer); + PDEBUG(D_USBI, "reg read [%02x] -> %02x ..", index, *buffer); } static void reg_w(struct usb_device *dev, __u16 index, - const __u8 *buffer, __u16 length) + const __u8 *buffer, __u16 len) { - PDEBUG(D_USBO, "reg write i:%02x = %02x", index, *buffer); + __u8 tmpbuf[8]; + +#ifdef CONFIG_VIDEO_ADV_DEBUG + if (len > sizeof tmpbuf) { + PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow"); + return; + } + PDEBUG(D_USBO, "reg write [%02x] = %02x..", index, *buffer); +#endif + memcpy(tmpbuf, buffer, len); usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, - index, (__u8 *) buffer, length, - 500); + index, tmpbuf, len, 500); } static const __u8 cx_sensor_init[][4] = { @@ -269,7 +277,7 @@ static void cx_sensor(struct gspca_dev*gspca_dev) reg_w(gspca_dev->dev, 0x0071, reg71b, 4); break; default: -/* case 2: */ +/* case 2: */ reg_w(gspca_dev->dev, 0x0071, reg71c, 4); break; case 3: @@ -662,8 +670,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, - cxjpeg_640[i], length); + reg_w(gspca_dev->dev, 0x0008, cxjpeg_640[i], length); } Reg55 = 0x28; break; @@ -671,8 +678,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, - cxjpeg_352[i], length); + reg_w(gspca_dev->dev, 0x0008, cxjpeg_352[i], length); } Reg55 = 0x16; break; @@ -681,8 +687,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, - cxjpeg_320[i], length); + reg_w(gspca_dev->dev, 0x0008, cxjpeg_320[i], length); } Reg55 = 0x14; break; @@ -690,8 +695,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, - cxjpeg_176[i], length); + reg_w(gspca_dev->dev, 0x0008, cxjpeg_176[i], length); } Reg55 = 0x0B; break; @@ -731,8 +735,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 18; i++) { if (i == 17) length = 2; - reg_w(gspca_dev->dev, 0x0008, - cxjpeg_qtable[i], length); + reg_w(gspca_dev->dev, 0x0008, cxjpeg_qtable[i], length); } reg_r(gspca_dev->dev, 0x0002, &val, 1); /* 0x00 */ @@ -866,7 +869,7 @@ static void sd_stop0(struct gspca_dev *gspca_dev) reg_w(gspca_dev->dev, 0x0053, &val, 1); while (retry--) { -/* reg_r (gspca_dev->dev,0x00,0x00,0x0002,&val,1);*/ +/* reg_r(gspca_dev->dev, 0x0002, &val, 1);*/ reg_r(gspca_dev->dev, 0x0053, &val, 1); if (val == 0) break; diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index 195b8123ba7..ed7a8f9c0d7 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -22,8 +22,8 @@ #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, 3) +static const char version[] = "2.1.3"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("Etoms USB Camera Driver"); @@ -213,7 +213,7 @@ static __u8 I2c3[] = { 0x12, 0x05 }; static __u8 I2c4[] = { 0x41, 0x08 }; -static void Et_RegRead(struct usb_device *dev, +static void reg_r(struct usb_device *dev, __u16 index, __u8 *buffer, int len) { usb_control_msg(dev, @@ -223,14 +223,17 @@ static void Et_RegRead(struct usb_device *dev, 0, index, buffer, len, 500); } -static void Et_RegWrite(struct usb_device *dev, +static void reg_w(struct usb_device *dev, __u16 index, __u8 *buffer, __u16 len) { + __u8 tmpbuf[8]; + + memcpy(tmpbuf, buffer, len); usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0, index, buffer, len, 500); + 0, index, tmpbuf, len, 500); } static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 *buffer, @@ -243,14 +246,14 @@ static int Et_i2cwrite(struct usb_device *dev, __u8 reg, __u8 *buffer, ptchcount = (((length & 0x07) << 4) | (mode & 0x03)); /* set the base address */ - Et_RegWrite(dev, ET_I2C_BASE, &base, 1); + reg_w(dev, ET_I2C_BASE, &base, 1); /* set count and prefetch */ - Et_RegWrite(dev, ET_I2C_COUNT, &ptchcount, 1); + reg_w(dev, ET_I2C_COUNT, &ptchcount, 1); /* set the register base */ - Et_RegWrite(dev, ET_I2C_REG, ®, 1); + reg_w(dev, ET_I2C_REG, ®, 1); j = length - 1; for (i = 0; i < length; i++) { - Et_RegWrite(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); + reg_w(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); j--; } return 0; @@ -267,17 +270,17 @@ static int Et_i2cread(struct usb_device *dev, __u8 reg, __u8 *buffer, ptchcount = (((length & 0x07) << 4) | (mode & 0x03)); /* set the base address */ - Et_RegWrite(dev, ET_I2C_BASE, &base, 1); + reg_w(dev, ET_I2C_BASE, &base, 1); /* set count and prefetch */ - Et_RegWrite(dev, ET_I2C_COUNT, &ptchcount, 1); + reg_w(dev, ET_I2C_COUNT, &ptchcount, 1); /* set the register base */ - Et_RegWrite(dev, ET_I2C_REG, ®, 1); - Et_RegWrite(dev, ET_I2C_PREFETCH, &prefetch, 1); + reg_w(dev, ET_I2C_REG, ®, 1); + reg_w(dev, ET_I2C_PREFETCH, &prefetch, 1); prefetch = 0x00; - Et_RegWrite(dev, ET_I2C_PREFETCH, &prefetch, 1); + reg_w(dev, ET_I2C_PREFETCH, &prefetch, 1); j = length - 1; for (i = 0; i < length; i++) { - Et_RegRead(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); + reg_r(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); j--; } return 0; @@ -289,7 +292,7 @@ static int Et_WaitStatus(struct usb_device *dev) int retry = 10; while (retry--) { - Et_RegRead(dev, ET_ClCK, &bytereceived, 1); + reg_r(dev, ET_ClCK, &bytereceived, 1); if (bytereceived != 0) return 1; } @@ -301,7 +304,7 @@ static int Et_videoOff(struct usb_device *dev) int err; __u8 stopvideo = 0; - Et_RegWrite(dev, ET_GPIO_OUT, &stopvideo, 1); + reg_w(dev, ET_GPIO_OUT, &stopvideo, 1); err = Et_WaitStatus(dev); if (!err) PDEBUG(D_ERR, "timeout Et_waitStatus VideoON"); @@ -313,7 +316,7 @@ static int Et_videoOn(struct usb_device *dev) int err; __u8 startvideo = 0x10; /* set Bit5 */ - Et_RegWrite(dev, ET_GPIO_OUT, &startvideo, 1); + reg_w(dev, ET_GPIO_OUT, &startvideo, 1); err = Et_WaitStatus(dev); if (!err) PDEBUG(D_ERR, "timeout Et_waitStatus VideoOFF"); @@ -329,156 +332,156 @@ static void Et_init2(struct gspca_dev *gspca_dev) PDEBUG(D_STREAM, "Open Init2 ET"); value = 0x2f; - Et_RegWrite(dev, ET_GPIO_DIR_CTRL, &value, 1); + reg_w(dev, ET_GPIO_DIR_CTRL, &value, 1); value = 0x10; - Et_RegWrite(dev, ET_GPIO_OUT, &value, 1); - Et_RegRead(dev, ET_GPIO_IN, &received, 1); + reg_w(dev, ET_GPIO_OUT, &value, 1); + reg_r(dev, ET_GPIO_IN, &received, 1); value = 0x14; /* 0x14 // 0x16 enabled pattern */ - Et_RegWrite(dev, ET_ClCK, &value, 1); + reg_w(dev, ET_ClCK, &value, 1); value = 0x1b; - Et_RegWrite(dev, ET_CTRL, &value, 1); + reg_w(dev, ET_CTRL, &value, 1); /* 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 */ - Et_RegWrite(dev, ET_COMP, &value, 1); + reg_w(dev, ET_COMP, &value, 1); value = 0x1f; - Et_RegWrite(dev, ET_MAXQt, &value, 1); + reg_w(dev, ET_MAXQt, &value, 1); value = 0x04; - Et_RegWrite(dev, ET_MINQt, &value, 1); + reg_w(dev, ET_MINQt, &value, 1); /* undocumented registers */ value = 0xff; - Et_RegWrite(dev, ET_REG1d, &value, 1); + reg_w(dev, ET_REG1d, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG1e, &value, 1); + reg_w(dev, ET_REG1e, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG1f, &value, 1); + reg_w(dev, ET_REG1f, &value, 1); value = 0x35; - Et_RegWrite(dev, ET_REG20, &value, 1); + reg_w(dev, ET_REG20, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_REG21, &value, 1); + reg_w(dev, ET_REG21, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_REG22, &value, 1); + reg_w(dev, ET_REG22, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG23, &value, 1); + reg_w(dev, ET_REG23, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG24, &value, 1); + reg_w(dev, ET_REG24, &value, 1); value = 0x0f; - Et_RegWrite(dev, ET_REG25, &value, 1); + reg_w(dev, ET_REG25, &value, 1); /* colors setting */ value = 0x11; - Et_RegWrite(dev, 0x30, &value, 1); /* 0x30 */ + reg_w(dev, 0x30, &value, 1); /* 0x30 */ value = 0x40; - Et_RegWrite(dev, 0x31, &value, 1); + reg_w(dev, 0x31, &value, 1); value = 0x00; - Et_RegWrite(dev, 0x32, &value, 1); + reg_w(dev, 0x32, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_O_RED, &value, 1); /* 0x34 */ + reg_w(dev, ET_O_RED, &value, 1); /* 0x34 */ value = 0x00; - Et_RegWrite(dev, ET_O_GREEN1, &value, 1); + reg_w(dev, ET_O_GREEN1, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_O_BLUE, &value, 1); + reg_w(dev, ET_O_BLUE, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_O_GREEN2, &value, 1); + reg_w(dev, ET_O_GREEN2, &value, 1); /*************/ value = 0x80; - Et_RegWrite(dev, ET_G_RED, &value, 1); /* 0x4d */ + reg_w(dev, ET_G_RED, &value, 1); /* 0x4d */ value = 0x80; - Et_RegWrite(dev, ET_G_GREEN1, &value, 1); + reg_w(dev, ET_G_GREEN1, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_G_BLUE, &value, 1); + reg_w(dev, ET_G_BLUE, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_G_GREEN2, &value, 1); + reg_w(dev, ET_G_GREEN2, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_G_GR_H, &value, 1); + reg_w(dev, ET_G_GR_H, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_G_GB_H, &value, 1); /* 0x52 */ + reg_w(dev, ET_G_GB_H, &value, 1); /* 0x52 */ /* Window control registers */ value = 0x80; /* use cmc_out */ - Et_RegWrite(dev, 0x61, &value, 1); + reg_w(dev, 0x61, &value, 1); value = 0x02; - Et_RegWrite(dev, 0x62, &value, 1); + reg_w(dev, 0x62, &value, 1); value = 0x03; - Et_RegWrite(dev, 0x63, &value, 1); + reg_w(dev, 0x63, &value, 1); value = 0x14; - Et_RegWrite(dev, 0x64, &value, 1); + reg_w(dev, 0x64, &value, 1); value = 0x0e; - Et_RegWrite(dev, 0x65, &value, 1); + reg_w(dev, 0x65, &value, 1); value = 0x02; - Et_RegWrite(dev, 0x66, &value, 1); + reg_w(dev, 0x66, &value, 1); value = 0x02; - Et_RegWrite(dev, 0x67, &value, 1); + reg_w(dev, 0x67, &value, 1); /**************************************/ value = 0x8f; - Et_RegWrite(dev, ET_SYNCHRO, &value, 1); /* 0x68 */ + reg_w(dev, ET_SYNCHRO, &value, 1); /* 0x68 */ value = 0x69; /* 0x6a //0x69 */ - Et_RegWrite(dev, ET_STARTX, &value, 1); + reg_w(dev, ET_STARTX, &value, 1); value = 0x0d; /* 0x0d //0x0c */ - Et_RegWrite(dev, ET_STARTY, &value, 1); + reg_w(dev, ET_STARTY, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_WIDTH_LOW, &value, 1); + reg_w(dev, ET_WIDTH_LOW, &value, 1); value = 0xe0; - Et_RegWrite(dev, ET_HEIGTH_LOW, &value, 1); + reg_w(dev, ET_HEIGTH_LOW, &value, 1); value = 0x60; - Et_RegWrite(dev, ET_W_H_HEIGTH, &value, 1); /* 6d */ + reg_w(dev, ET_W_H_HEIGTH, &value, 1); /* 6d */ value = 0x86; - Et_RegWrite(dev, ET_REG6e, &value, 1); + reg_w(dev, ET_REG6e, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_REG6f, &value, 1); + reg_w(dev, ET_REG6f, &value, 1); value = 0x26; - Et_RegWrite(dev, ET_REG70, &value, 1); + reg_w(dev, ET_REG70, &value, 1); value = 0x7a; - Et_RegWrite(dev, ET_REG71, &value, 1); + reg_w(dev, ET_REG71, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_REG72, &value, 1); + reg_w(dev, ET_REG72, &value, 1); /* Clock Pattern registers ***************** */ value = 0x00; - Et_RegWrite(dev, ET_REG73, &value, 1); + reg_w(dev, ET_REG73, &value, 1); value = 0x18; /* 0x28 */ - Et_RegWrite(dev, ET_REG74, &value, 1); + reg_w(dev, ET_REG74, &value, 1); value = 0x0f; /* 0x01 */ - Et_RegWrite(dev, ET_REG75, &value, 1); + reg_w(dev, ET_REG75, &value, 1); /**********************************************/ value = 0x20; - Et_RegWrite(dev, 0x8a, &value, 1); + reg_w(dev, 0x8a, &value, 1); value = 0x0f; - Et_RegWrite(dev, 0x8d, &value, 1); + reg_w(dev, 0x8d, &value, 1); value = 0x08; - Et_RegWrite(dev, 0x8e, &value, 1); + reg_w(dev, 0x8e, &value, 1); /**************************************/ value = 0x08; - Et_RegWrite(dev, 0x03, &value, 1); + reg_w(dev, 0x03, &value, 1); value = 0x03; - Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + reg_w(dev, ET_PXL_CLK, &value, 1); value = 0xff; - Et_RegWrite(dev, 0x81, &value, 1); + reg_w(dev, 0x81, &value, 1); value = 0x00; - Et_RegWrite(dev, 0x80, &value, 1); + reg_w(dev, 0x80, &value, 1); value = 0xff; - Et_RegWrite(dev, 0x81, &value, 1); + reg_w(dev, 0x81, &value, 1); value = 0x20; - Et_RegWrite(dev, 0x80, &value, 1); + reg_w(dev, 0x80, &value, 1); value = 0x01; - Et_RegWrite(dev, 0x03, &value, 1); + reg_w(dev, 0x03, &value, 1); value = 0x00; - Et_RegWrite(dev, 0x03, &value, 1); + reg_w(dev, 0x03, &value, 1); value = 0x08; - Et_RegWrite(dev, 0x03, &value, 1); + reg_w(dev, 0x03, &value, 1); /********************************************/ - /* Et_RegRead(dev,0x0,ET_I2C_BASE,&received,1); + /* reg_r(dev,0x0,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 */ - Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + reg_w(dev, ET_PXL_CLK, &value, 1); /* now set by fifo the FormatLine setting */ - Et_RegWrite(dev, 0x62, FormLine, 6); + reg_w(dev, 0x62, FormLine, 6); } else { /* 640 */ /* setting PixelClock 0x03 mean 24/(3+1) = 6 Mhz @@ -487,24 +490,24 @@ static void Et_init2(struct gspca_dev *gspca_dev) 0x17 -> 24/(23+1) = 1 Mhz */ value = 0x1e; /* 0x17 */ - Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + reg_w(dev, ET_PXL_CLK, &value, 1); /* now set by fifo the FormatLine setting */ - Et_RegWrite(dev, 0x62, FormLine, 6); + reg_w(dev, 0x62, FormLine, 6); } /* set exposure times [ 0..0x78] 0->longvalue 0x78->shortvalue */ value = 0x47; /* 0x47; */ - Et_RegWrite(dev, 0x81, &value, 1); + reg_w(dev, 0x81, &value, 1); value = 0x40; /* 0x40; */ - Et_RegWrite(dev, 0x80, &value, 1); + reg_w(dev, 0x80, &value, 1); /* Pedro change */ /* Brightness change Brith+ decrease value */ /* Brigth- increase value */ /* original value = 0x70; */ value = 0x30; /* 0x20; */ - Et_RegWrite(dev, 0x81, &value, 1); /* set brightness */ + reg_w(dev, 0x81, &value, 1); /* set brightness */ value = 0x20; /* 0x20; */ - Et_RegWrite(dev, 0x80, &value, 1); + reg_w(dev, 0x80, &value, 1); } static void setcolors(struct gspca_dev *gspca_dev) @@ -554,16 +557,16 @@ static void Et_init1(struct gspca_dev *gspca_dev) PDEBUG(D_STREAM, "Open Init1 ET"); value = 7; - Et_RegWrite(dev, ET_GPIO_DIR_CTRL, &value, 1); - Et_RegRead(dev, ET_GPIO_IN, &received, 1); + reg_w(dev, ET_GPIO_DIR_CTRL, &value, 1); + reg_r(dev, ET_GPIO_IN, &received, 1); value = 1; - Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + reg_w(dev, ET_RESET_ALL, &value, 1); value = 0; - Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + reg_w(dev, ET_RESET_ALL, &value, 1); value = 0x10; - Et_RegWrite(dev, ET_ClCK, &value, 1); + reg_w(dev, ET_ClCK, &value, 1); value = 0x19; - Et_RegWrite(dev, ET_CTRL, &value, 1); + reg_w(dev, ET_CTRL, &value, 1); /* compression et subsampling */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) value = ET_COMP_VAL1; @@ -573,77 +576,77 @@ static void Et_init1(struct gspca_dev *gspca_dev) PDEBUG(D_STREAM, "Open mode %d Compression %d", gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode, value); - Et_RegWrite(dev, ET_COMP, &value, 1); + reg_w(dev, ET_COMP, &value, 1); value = 0x1d; - Et_RegWrite(dev, ET_MAXQt, &value, 1); + reg_w(dev, ET_MAXQt, &value, 1); value = 0x02; - Et_RegWrite(dev, ET_MINQt, &value, 1); + reg_w(dev, ET_MINQt, &value, 1); /* undocumented registers */ value = 0xff; - Et_RegWrite(dev, ET_REG1d, &value, 1); + reg_w(dev, ET_REG1d, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG1e, &value, 1); + reg_w(dev, ET_REG1e, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG1f, &value, 1); + reg_w(dev, ET_REG1f, &value, 1); value = 0x35; - Et_RegWrite(dev, ET_REG20, &value, 1); + reg_w(dev, ET_REG20, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_REG21, &value, 1); + reg_w(dev, ET_REG21, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_REG22, &value, 1); + reg_w(dev, ET_REG22, &value, 1); value = 0xf7; - Et_RegWrite(dev, ET_REG23, &value, 1); + reg_w(dev, ET_REG23, &value, 1); value = 0xff; - Et_RegWrite(dev, ET_REG24, &value, 1); + reg_w(dev, ET_REG24, &value, 1); value = 0x07; - Et_RegWrite(dev, ET_REG25, &value, 1); + reg_w(dev, ET_REG25, &value, 1); /* colors setting */ value = 0x80; - Et_RegWrite(dev, ET_G_RED, &value, 1); + reg_w(dev, ET_G_RED, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_G_GREEN1, &value, 1); + reg_w(dev, ET_G_GREEN1, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_G_BLUE, &value, 1); + reg_w(dev, ET_G_BLUE, &value, 1); value = 0x80; - Et_RegWrite(dev, ET_G_GREEN2, &value, 1); + reg_w(dev, ET_G_GREEN2, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_G_GR_H, &value, 1); + reg_w(dev, ET_G_GR_H, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_G_GB_H, &value, 1); + reg_w(dev, ET_G_GB_H, &value, 1); /* Window control registers */ value = 0xf0; - Et_RegWrite(dev, ET_SYNCHRO, &value, 1); + reg_w(dev, ET_SYNCHRO, &value, 1); value = 0x56; /* 0x56 */ - Et_RegWrite(dev, ET_STARTX, &value, 1); + reg_w(dev, ET_STARTX, &value, 1); value = 0x05; /* 0x04 */ - Et_RegWrite(dev, ET_STARTY, &value, 1); + reg_w(dev, ET_STARTY, &value, 1); value = 0x60; - Et_RegWrite(dev, ET_WIDTH_LOW, &value, 1); + reg_w(dev, ET_WIDTH_LOW, &value, 1); value = 0x20; - Et_RegWrite(dev, ET_HEIGTH_LOW, &value, 1); + reg_w(dev, ET_HEIGTH_LOW, &value, 1); value = 0x50; - Et_RegWrite(dev, ET_W_H_HEIGTH, &value, 1); + reg_w(dev, ET_W_H_HEIGTH, &value, 1); value = 0x86; - Et_RegWrite(dev, ET_REG6e, &value, 1); + reg_w(dev, ET_REG6e, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_REG6f, &value, 1); + reg_w(dev, ET_REG6f, &value, 1); value = 0x86; - Et_RegWrite(dev, ET_REG70, &value, 1); + reg_w(dev, ET_REG70, &value, 1); value = 0x14; - Et_RegWrite(dev, ET_REG71, &value, 1); + reg_w(dev, ET_REG71, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_REG72, &value, 1); + reg_w(dev, ET_REG72, &value, 1); /* Clock Pattern registers */ value = 0x00; - Et_RegWrite(dev, ET_REG73, &value, 1); + reg_w(dev, ET_REG73, &value, 1); value = 0x00; - Et_RegWrite(dev, ET_REG74, &value, 1); + reg_w(dev, ET_REG74, &value, 1); value = 0x0a; - Et_RegWrite(dev, ET_REG75, &value, 1); + reg_w(dev, ET_REG75, &value, 1); value = 0x04; - Et_RegWrite(dev, ET_I2C_CLK, &value, 1); + reg_w(dev, ET_I2C_CLK, &value, 1); value = 0x01; - Et_RegWrite(dev, ET_PXL_CLK, &value, 1); + reg_w(dev, ET_PXL_CLK, &value, 1); /* set the sensor */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { I2c0[0] = 0x06; @@ -679,7 +682,7 @@ static void Et_init1(struct gspca_dev *gspca_dev) /* magnetude and sign bit for DAC */ Et_i2cwrite(dev, PAS106_REG7, I2c4, sizeof I2c4, 1); /* now set by fifo the whole colors setting */ - Et_RegWrite(dev, ET_G_RED, GainRGBG, 6); + reg_w(dev, ET_G_RED, GainRGBG, 6); getcolors(gspca_dev); setcolors(gspca_dev); } @@ -738,7 +741,7 @@ static int sd_open(struct gspca_dev *gspca_dev) else Et_init2(gspca_dev); value = 0x08; - Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + reg_w(dev, ET_RESET_ALL, &value, 1); err = Et_videoOff(dev); PDEBUG(D_STREAM, "Et_Init_VideoOff %d", err); return 0; @@ -758,7 +761,7 @@ static void sd_start(struct gspca_dev *gspca_dev) Et_init2(gspca_dev); value = 0x08; - Et_RegWrite(dev, ET_RESET_ALL, &value, 1); + reg_w(dev, ET_RESET_ALL, &value, 1); err = Et_videoOn(dev); PDEBUG(D_STREAM, "Et_VideoOn %d", err); } @@ -787,7 +790,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) __u8 brightness = sd->brightness; for (i = 0; i < 4; i++) - Et_RegWrite(gspca_dev->dev, (ET_O_RED + i), &brightness, 1); + reg_w(gspca_dev->dev, (ET_O_RED + i), &brightness, 1); } static void getbrightness(struct gspca_dev *gspca_dev) @@ -798,7 +801,7 @@ static void getbrightness(struct gspca_dev *gspca_dev) __u8 value = 0; for (i = 0; i < 4; i++) { - Et_RegRead(gspca_dev->dev, (ET_O_RED + i), &value, 1); + reg_r(gspca_dev->dev, (ET_O_RED + i), &value, 1); brightness += value; } sd->brightness = brightness >> 3; @@ -811,7 +814,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) __u8 contrast = sd->contrast; memset(RGBG, contrast, sizeof RGBG - 2); - Et_RegWrite(gspca_dev->dev, ET_G_RED, RGBG, 6); + reg_w(gspca_dev->dev, ET_G_RED, RGBG, 6); } static void getcontrast(struct gspca_dev *gspca_dev) @@ -822,7 +825,7 @@ static void getcontrast(struct gspca_dev *gspca_dev) __u8 value = 0; for (i = 0; i < 4; i++) { - Et_RegRead(gspca_dev->dev, (ET_G_RED + i), &value, 1); + reg_r(gspca_dev->dev, (ET_G_RED + i), &value, 1); contrast += value; } sd->contrast = contrast >> 2; @@ -870,7 +873,7 @@ static void setautogain(struct gspca_dev *gspca_dev) __u8 r, g, b; Gbright = Et_getgainG(gspca_dev); - Et_RegRead(dev, ET_LUMA_CENTER, GRBG, 4); + reg_r(dev, ET_LUMA_CENTER, GRBG, 4); g = (GRBG[0] + GRBG[3]) >> 1; r = GRBG[1]; b = GRBG[2]; diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c index d8cd2148f30..6556e0a330f 100644 --- a/drivers/media/video/gspca/mars.c +++ b/drivers/media/video/gspca/mars.c @@ -79,49 +79,35 @@ enum { }; static int pcam_reg_write(struct usb_device *dev, - __u16 index, unsigned char *value, int length) + __u16 index, __u8 *value, int len) { int rc; rc = usb_control_msg(dev, usb_sndbulkpipe(dev, 4), 0x12, -/* ?? 0xc8 = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_??? !? */ +/* ?? 0xc8 = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_??? !? */ 0xc8, 0, /* value */ - index, value, length, 500); - PDEBUG(D_USBO, "reg write: 0x%02X , result = 0x%x", index, rc); - + index, value, len, 500); if (rc < 0) - PDEBUG(D_ERR, "reg write: error %d", rc); + PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc); return rc; } -static void MISensor_BulkWrite(struct usb_device *dev, unsigned short *pch, - char Address) +static void MISensor_BulkWrite(struct usb_device *dev, + unsigned short *pch, + char Address) { - int result; - unsigned char data[6]; + __u8 data[6]; data[0] = 0x1f; - data[1] = 0; + data[1] = 0; /* control byte */ data[2] = Address; data[3] = *pch >> 8; /* high byte */ data[4] = *pch; /* low byte */ - data[5] = 0; - - result = usb_control_msg(dev, - usb_sndbulkpipe(dev, 4), - 0x12, -/* ?? 0xc8 = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_??? !? */ - 0xc8, - 0, /* value */ - Address, /* index */ - data, 5, 500); - PDEBUG(D_USBO, "bulk write 0x%02x = 0x%04x", Address, *pch); - if (result < 0) - PDEBUG(D_ERR, "reg write: error %d", result); + pcam_reg_write(dev, Address, data, 5); } /* this function is called at probe time */ @@ -167,7 +153,7 @@ static void sd_start(struct gspca_dev *gspca_dev) data[0] = 0x01; /* address */ data[1] = 0x01; - err_code = pcam_reg_write(dev, data[0], data, 0x02); + err_code = pcam_reg_write(dev, data[0], data, 2); if (err_code < 0) return; @@ -193,14 +179,14 @@ static void sd_start(struct gspca_dev *gspca_dev) data[10] = 0x5d; /* reg 9, I2C device address * [for PAS5101 (0x40)] [for MI (0x5d)] */ - err_code = pcam_reg_write(dev, data[0], data, 0x0b); + err_code = pcam_reg_write(dev, data[0], data, 11); if (err_code < 0) return; data[0] = 0x23; /* address */ data[1] = 0x09; /* reg 35, append frame header */ - err_code = pcam_reg_write(dev, data[0], data, 0x02); + err_code = pcam_reg_write(dev, data[0], data, 2); if (err_code < 0) { PDEBUG(D_ERR, "Register write failed"); return; @@ -213,7 +199,7 @@ static void sd_start(struct gspca_dev *gspca_dev) /* else */ data[1] = 50; /* 50 reg 60, pc-cam frame size * (unit: 4KB) 200KB */ - err_code = pcam_reg_write(dev, data[0], data, 0x02); + err_code = pcam_reg_write(dev, data[0], data, 2); if (err_code < 0) return; @@ -255,13 +241,13 @@ static void sd_start(struct gspca_dev *gspca_dev) /* auto dark-gain */ data[0] = 0x5e; /* address */ - err_code = pcam_reg_write(dev, data[0], data, 0x06); + err_code = pcam_reg_write(dev, data[0], data, 6); if (err_code < 0) return; data[0] = 0x67; data[1] = 0x13; /* reg 103, first pixel B, disable sharpness */ - err_code = pcam_reg_write(dev, data[0], data, 0x02); + err_code = pcam_reg_write(dev, data[0], data, 2); if (err_code < 0) return; @@ -340,7 +326,7 @@ static void sd_start(struct gspca_dev *gspca_dev) data[0] = 0x00; data[1] = 0x4d; /* ISOC transfering enable... */ - pcam_reg_write(dev, data[0], data, 0x02); + pcam_reg_write(dev, data[0], data, 2); } static void sd_stopN(struct gspca_dev *gspca_dev) diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c index 14eb25d8184..14cc49a4c2c 100644 --- a/drivers/media/video/gspca/pac7311.c +++ b/drivers/media/video/gspca/pac7311.c @@ -23,8 +23,8 @@ #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, 3) +static const char version[] = "2.1.3"; MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li"); MODULE_DESCRIPTION("Pixart PAC7311"); @@ -195,16 +195,18 @@ const unsigned char pac7311_jpeg_header[] = { }; static void reg_w(struct usb_device *dev, - __u16 req, - __u16 value, __u16 index, - __u8 *buffer, __u16 length) + char *buffer, __u16 len) { + __u8 tmpbuf[8]; + + memcpy(tmpbuf, buffer, len); usb_control_msg(dev, usb_sndctrlpipe(dev, 0), - req, + 1, /* request */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - value, index, buffer, length, + 0, /* value */ + index, tmpbuf, len, 500); } @@ -227,7 +229,12 @@ static void pac7311_reg_write(struct usb_device *dev, __u8 buf; buf = value; - reg_w(dev, 0x00, value, index, &buf, 1); + usb_control_msg(dev, + usb_sndctrlpipe(dev, 0), + 0, /* request */ + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + value, index, &buf, 1, + 500); } /* this function is called at probe time */ @@ -313,26 +320,26 @@ static void sd_start(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; pac7311_reg_write(dev, 0xff, 0x01); - reg_w(dev, 0x01, 0, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8); - reg_w(dev, 0x01, 0, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8); - reg_w(dev, 0x01, 0, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8); - reg_w(dev, 0x01, 0, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8); - reg_w(dev, 0x01, 0, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8); - reg_w(dev, 0x01, 0, 0x002a, "\x00\x00\x00", 3); - reg_w(dev, 0x01, 0, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8); - reg_w(dev, 0x01, 0, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8); - reg_w(dev, 0x01, 0, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8); - reg_w(dev, 0x01, 0, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8); - reg_w(dev, 0x01, 0, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8); - reg_w(dev, 0x01, 0, 0x0066, "\xd0\xff", 2); - reg_w(dev, 0x01, 0, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6); - reg_w(dev, 0x01, 0, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8); - reg_w(dev, 0x01, 0, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8); - reg_w(dev, 0x01, 0, 0x008f, "\x18\x20", 2); - reg_w(dev, 0x01, 0, 0x0096, "\x01\x08\x04", 3); - reg_w(dev, 0x01, 0, 0x00a0, "\x44\x44\x44\x04", 4); - reg_w(dev, 0x01, 0, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8); - reg_w(dev, 0x01, 0, 0x00f8, "\x3f\x00\x0a\x01\x00", 5); + reg_w(dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8); + reg_w(dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8); + reg_w(dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8); + reg_w(dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8); + reg_w(dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8); + reg_w(dev, 0x002a, "\x00\x00\x00", 3); + reg_w(dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8); + reg_w(dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8); + reg_w(dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8); + reg_w(dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8); + reg_w(dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8); + reg_w(dev, 0x0066, "\xd0\xff", 2); + reg_w(dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6); + reg_w(dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8); + reg_w(dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8); + reg_w(dev, 0x008f, "\x18\x20", 2); + reg_w(dev, 0x0096, "\x01\x08\x04", 3); + reg_w(dev, 0x00a0, "\x44\x44\x44\x04", 4); + reg_w(dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8); + reg_w(dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5); pac7311_reg_write(dev, 0xff, 0x04); pac7311_reg_write(dev, 0x02, 0x04); diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c index 7850efa4109..4baac51bf40 100644 --- a/drivers/media/video/gspca/sonixb.c +++ b/drivers/media/video/gspca/sonixb.c @@ -334,7 +334,7 @@ static void reg_r(struct usb_device *dev, static void reg_w(struct usb_device *dev, __u16 value, const __u8 *buffer, - __u16 len) + int len) { __u8 tmpbuf[32]; diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index e6a49fe2c4e..4f23b16c89a 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -24,8 +24,8 @@ #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, 3) +static const char version[] = "2.1.3"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver"); @@ -515,15 +515,24 @@ static void reg_r(struct usb_device *dev, static void reg_w(struct usb_device *dev, __u16 value, - __u8 *buffer, + 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; + } +#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, - buffer, len, + tmpbuf, len, 500); } diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c index e72fca5744a..1db5b33ad85 100644 --- a/drivers/media/video/gspca/spca500.c +++ b/drivers/media/video/gspca/spca500.c @@ -377,7 +377,7 @@ static int reg_write(struct usb_device *dev, ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), req, - USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 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); diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c index 25c5245725d..113c0710692 100644 --- a/drivers/media/video/gspca/sunplus.c +++ b/drivers/media/video/gspca/sunplus.c @@ -456,7 +456,7 @@ static int reg_write(struct usb_device *dev, ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), req, - USB_TYPE_VENDOR | USB_RECIP_DEVICE, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, index, NULL, 0, 500); PDEBUG(D_PACK, "reg write: 0x%02x,0x%02x:0x%02x, 0x%x", req, index, value, ret); diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c index c22b301ebae..de43118dec7 100644 --- a/drivers/media/video/gspca/t613.c +++ b/drivers/media/video/gspca/t613.c @@ -26,8 +26,8 @@ #define MODULE_NAME "t613" #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, 3) +static const char version[] = "2.1.3"; struct control_menu_info { int value; @@ -366,13 +366,22 @@ static void t16RegRead(struct usb_device *dev, static void t16RegWrite(struct usb_device *dev, __u16 value, - __u16 index, __u8 *buffer, __u16 length) + __u16 index, __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"); + 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, buffer, length, 500); + value, index, tmpbuf, len, 500); } /* this function is called at probe time */ @@ -491,24 +500,24 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) t16RegWrite(dev, 0x00, 0x3880, 0x00, 0x0); t16RegWrite(dev, 0x00, 0x3880, 0x00, 0x0); t16RegWrite(dev, 0x00, 0x338e, 0x00, 0x0); - t16RegWrite(dev, 0x01, 00, nset5, 0x04); + t16RegWrite(dev, 0x01, 0x0000, nset5, 0x04); t16RegWrite(dev, 0x00, 0x00a9, 0x00, 0x0); - t16RegWrite(dev, 0x01, 00, nset6, 0x22); + t16RegWrite(dev, 0x01, 0x0000, nset6, 0x22); t16RegWrite(dev, 0x00, 0x86bb, 0x00, 0x0); t16RegWrite(dev, 0x00, 0x4aa6, 0x00, 0x0); - t16RegWrite(dev, 0x01, 00, missing, 0x08); + 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, 0x01, 00, nset7, 0x4); - t16RegWrite(dev, 0x01, 00, nset10, 0x06); - t16RegWrite(dev, 0x01, 00, nset8, 0x06); - t16RegWrite(dev, 0x01, 00, nset9, 0x04); + 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, 0x0); + t16RegWrite(dev, 0x00, 0x2880, 0x00, 0x00); t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14); t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12); t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12); diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c index 6218441ba1f..6da5280b543 100644 --- a/drivers/media/video/gspca/tv8532.c +++ b/drivers/media/video/gspca/tv8532.c @@ -192,8 +192,7 @@ static void tv_8532WriteEEprom(struct gspca_dev *gspca_dev) datacmd = 0xb0;; reg_w(dev, TV8532_GPIO, &datacmd, 1); datacmd = TV8532_CMD_EEprom_Open; - reg_w(dev, TV8532_CTRL, &datacmd, - 1); + reg_w(dev, TV8532_CTRL, &datacmd, 1); /* msleep(1); */ while (tv_8532_eeprom_data[i]) { reg = (tv_8532_eeprom_data[i] & 0xff000000) >> 24; @@ -390,8 +389,7 @@ static int sd_open(struct gspca_dev *gspca_dev) tv_8532_setReg(gspca_dev); /*************************************************/ data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, - 1); + reg_w(dev, TV8532_GPIO_OE, &data, 1); /*************************************************/ tv_8532_setReg(gspca_dev); /*************************************************/ @@ -417,8 +415,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) static void sd_start(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 data = 0; - __u8 dataStart = 0; + __u8 data; __u8 value[2]; data = 0x32; @@ -459,8 +456,8 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(dev, TV8532_POINT_L, &data, 1); /* 0x2d */ data = TESTPTH; /* 0x04; */ reg_w(dev, TV8532_POINT_H, &data, 1); /* 0x2e */ - dataStart = TESTPTBL; /* 0x04; */ - reg_w(dev, TV8532_POINTB_L, &dataStart, 1); /* 0x2f */ + data = TESTPTBL; /* 0x04; */ + reg_w(dev, TV8532_POINTB_L, &data, 1); /* 0x2f */ data = TESTPTBH; /* 0x04; */ reg_w(dev, TV8532_POINTB_H, &data, 1); /* 0x30 */ data = TV8532_CMD_UPDATE; -- cgit v1.2.3-70-g09d2 From a5ae2062252e697d38e53dbbeb91460252208914 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Fri, 4 Jul 2008 11:16:16 -0300 Subject: V4L/DVB (8195): gspca: Input buffer overwritten in spca561 + cleanup code. spca561: Input buffer may be changed on reg write. (all sd): Cleanup code, 'const' added. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/conex.c | 98 ++++--- drivers/media/video/gspca/etoms.c | 546 ++++++++++++++---------------------- drivers/media/video/gspca/gspca.c | 6 +- drivers/media/video/gspca/gspca.h | 26 +- drivers/media/video/gspca/mars.c | 13 +- drivers/media/video/gspca/ov519.c | 60 ++-- drivers/media/video/gspca/pac207.c | 14 +- drivers/media/video/gspca/pac7311.c | 40 +-- drivers/media/video/gspca/sonixj.c | 165 ++++++----- drivers/media/video/gspca/spca500.c | 301 ++++++++++---------- drivers/media/video/gspca/spca501.c | 27 +- drivers/media/video/gspca/spca505.c | 22 +- drivers/media/video/gspca/spca508.c | 22 +- drivers/media/video/gspca/spca561.c | 30 +- drivers/media/video/gspca/stk014.c | 36 +-- drivers/media/video/gspca/sunplus.c | 28 +- drivers/media/video/gspca/t613.c | 198 ++++++------- drivers/media/video/gspca/tv8532.c | 22 +- drivers/media/video/gspca/vc032x.c | 80 +++--- drivers/media/video/gspca/zc3xx.c | 246 ++++++++-------- 20 files changed, 932 insertions(+), 1048 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c index 473bea750b5..6d50247b7ad 100644 --- a/drivers/media/video/gspca/conex.c +++ b/drivers/media/video/gspca/conex.c @@ -25,8 +25,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA USB Conexant Camera Driver"); @@ -229,7 +229,7 @@ static void cx11646_fw(struct gspca_dev*gspca_dev) 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, @@ -244,24 +244,24 @@ static __u8 cxsensor[] = { 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); @@ -305,7 +305,7 @@ static void cx_sensor(struct gspca_dev*gspca_dev) 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, @@ -314,7 +314,7 @@ static __u8 cx_inits_176[] = { 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, @@ -323,7 +323,7 @@ static __u8 cx_inits_320[] = { 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, @@ -332,7 +332,7 @@ static __u8 cx_inits_352[] = { 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, @@ -344,7 +344,7 @@ static __u8 cx_inits_640[] = { 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[] = @@ -396,7 +396,7 @@ static int cx11646_initsize(struct gspca_dev *gspca_dev) 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}, @@ -479,7 +479,7 @@ static __u8 cx_jpeg_init[][8] = { }; -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}, @@ -508,7 +508,7 @@ static __u8 cxjpeg_640[][8] = { {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}, @@ -537,7 +537,7 @@ static __u8 cxjpeg_352[][8] = { {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}, @@ -566,7 +566,7 @@ static __u8 cxjpeg_320[][8] = { {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}, @@ -595,7 +595,8 @@ static __u8 cxjpeg_176[][8] = { {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}, @@ -641,22 +642,23 @@ static void cx11646_jpegInit(struct gspca_dev*gspca_dev) 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); @@ -665,6 +667,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) 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++) { @@ -719,6 +722,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) 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 */ @@ -796,8 +800,8 @@ static void cx11646_init1(struct gspca_dev *gspca_dev) 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]) { @@ -827,7 +831,7 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; @@ -891,7 +895,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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) { @@ -914,21 +918,22 @@ static void setbrightness(struct gspca_dev*gspca_dev) { 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); @@ -938,14 +943,15 @@ static void setcontrast(struct gspca_dev*gspca_dev) { 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); diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index ed7a8f9c0d7..bbbe65923cf 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -22,8 +22,8 @@ #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 "); MODULE_DESCRIPTION("Etoms USB Camera Driver"); @@ -56,7 +56,6 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val); static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val); static struct ctrl sd_ctrls[] = { -#define SD_BRIGHTNESS 0 { { .id = V4L2_CID_BRIGHTNESS, @@ -65,12 +64,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -79,12 +78,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -93,12 +92,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -107,7 +106,8 @@ static struct ctrl sd_ctrls[] = { .minimum = 0, .maximum = 1, .step = 1, - .default_value = 1, +#define AUTOGAIN_DEF 1 + .default_value = AUTOGAIN_DEF, }, .set = sd_setautogain, .get = sd_getautogain, @@ -205,13 +205,13 @@ static struct cam_mode sif_mode[] = { #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) @@ -223,8 +223,21 @@ static void reg_r(struct usb_device *dev, 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]; @@ -236,48 +249,42 @@ static void reg_w(struct usb_device *dev, 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); @@ -299,222 +306,139 @@ static int Et_WaitStatus(struct usb_device *dev) 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; @@ -525,7 +449,7 @@ static void setcolors(struct gspca_dev *gspca_dev) /* 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); */ @@ -534,11 +458,11 @@ static void setcolors(struct gspca_dev *gspca_dev) static void getcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - /* __u8 valblue = 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; } @@ -547,126 +471,87 @@ static void getcolors(struct gspca_dev *gspca_dev) 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); @@ -720,10 +605,10 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; } @@ -732,18 +617,13 @@ static int sd_open(struct gspca_dev *gspca_dev) { 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; } @@ -752,27 +632,19 @@ static void sd_start(struct gspca_dev *gspca_dev) { 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) @@ -790,7 +662,7 @@ static void setbrightness(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) @@ -798,7 +670,7 @@ 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); @@ -895,7 +767,7 @@ static void setautogain(struct gspca_dev *gspca_dev) 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; diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c index b36913017d7..ad4721b0692 100644 --- a/drivers/media/video/gspca/gspca.c +++ b/drivers/media/video/gspca/gspca.c @@ -247,7 +247,7 @@ static void isoc_transfer(struct gspca_dev *gspca_dev) 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; @@ -1053,7 +1053,7 @@ static int vidioc_s_ctrl(struct file *file, void *priv, 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; @@ -1079,7 +1079,7 @@ static int vidioc_g_ctrl(struct file *file, void *priv, { 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; diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h index 9c894daf356..0d23e0a90c7 100644 --- a/drivers/media/video/gspca/gspca.h +++ b/drivers/media/video/gspca/gspca.h @@ -9,25 +9,6 @@ #include #include -/* 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; @@ -76,7 +57,6 @@ struct cam_mode { short width; short height; short mode; /* subdriver value */ - short reserved; /* subdriver value */ }; struct cam { char *dev_name; @@ -110,9 +90,9 @@ struct ctrl { /* 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 */ @@ -195,6 +175,6 @@ void gspca_disconnect(struct usb_interface *intf); 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 */ diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c index 6556e0a330f..c70ccc8fe68 100644 --- a/drivers/media/video/gspca/mars.c +++ b/drivers/media/video/gspca/mars.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver"); @@ -140,7 +140,8 @@ static void sd_start(struct gspca_dev *gspca_dev) __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); @@ -351,7 +352,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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; @@ -389,7 +390,7 @@ static void sd_pkt_scan(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), @@ -404,7 +405,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x093a, 0x050f), DVNM("Mars-Semi Pc-Camera")}, {} }; diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c index 7d6237f18ba..d92729ac41f 100644 --- a/drivers/media/video/gspca/ov519.c +++ b/drivers/media/video/gspca/ov519.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("OV519 USB Camera Driver"); @@ -266,15 +266,15 @@ static unsigned char ov7670_abs_to_sm(unsigned char v) 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; @@ -285,16 +285,16 @@ static int reg_w(struct sd *sd, __u16 index, __u8 value) 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; @@ -302,7 +302,7 @@ static int reg_r(struct sd *sd, __u16 index) /* Read 8 values from a OV519 register */ static int reg_r8(struct sd *sd, - __u16 index) + __u16 index) { int ret; __u8 buf[8]; @@ -528,7 +528,7 @@ struct ov_i2c_regvals { }; static int write_regvals(struct sd *sd, - struct ov_regvals *regvals, + const struct ov_regvals *regvals, int n) { int rc; @@ -543,7 +543,7 @@ static int write_regvals(struct sd *sd, } static int write_i2c_regvals(struct sd *sd, - struct ov_i2c_regvals *regvals, + const struct ov_i2c_regvals *regvals, int n) { int rc; @@ -569,7 +569,7 @@ static int write_i2c_regvals(struct sd *sd, 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 }, @@ -707,7 +707,7 @@ static int ov7xx0_configure(struct sd *sd) * 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 }, @@ -737,7 +737,7 @@ static int ov7xx0_configure(struct sd *sd) { 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 */ @@ -804,14 +804,14 @@ static int ov7xx0_configure(struct sd *sd) }; /* 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 */ @@ -1075,7 +1075,7 @@ static int ov7xx0_configure(struct sd *sd) 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 }, @@ -1118,7 +1118,7 @@ static int ov6xx0_configure(struct sd *sd) /* 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 */ @@ -1284,7 +1284,7 @@ static int sd_config(struct gspca_dev *gspca_dev, 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 */ @@ -1302,8 +1302,7 @@ static int sd_config(struct gspca_dev *gspca_dev, /* 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)) @@ -1389,7 +1388,7 @@ static int sd_open(struct gspca_dev *gspca_dev) 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) */ @@ -1412,7 +1411,7 @@ static int ov519_mode_init_regs(struct sd *sd, /* 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) */ @@ -1448,12 +1447,11 @@ static int ov519_mode_init_regs(struct sd *sd, /******** 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; } @@ -1883,7 +1881,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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: @@ -1982,7 +1980,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) 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 }; @@ -1991,7 +1989,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) 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 }; @@ -2104,7 +2102,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -2119,7 +2117,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(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")}, diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c index 84986684c4d..7e067456e62 100644 --- a/drivers/media/video/gspca/pac207.c +++ b/drivers/media/video/gspca/pac207.c @@ -27,8 +27,8 @@ #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 "); MODULE_DESCRIPTION("Pixart PAC207"); @@ -716,7 +716,7 @@ static int pac207_decode_frame_data(struct gspca_dev *gspca_dev, static void sd_pkt_scan(struct gspca_dev *gspca_dev, struct gspca_frame *frame, - unsigned char *data, + __u8 *data, int len) { unsigned char *sof; @@ -754,8 +754,8 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, 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) @@ -879,7 +879,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -895,7 +895,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x041e, 0x4028), DVNM("Creative Webcam Vista Plus")}, {USB_DEVICE(0x093a, 0x2460), DVNM("Q-Tec Webcam 100")}, {USB_DEVICE(0x093a, 0x2463), DVNM("Philips spc200nc pac207")}, diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c index 14cc49a4c2c..c2d4b6a4dcf 100644 --- a/drivers/media/video/gspca/pac7311.c +++ b/drivers/media/video/gspca/pac7311.c @@ -23,8 +23,8 @@ #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"); @@ -37,7 +37,6 @@ struct sd { int avg_lum; unsigned char brightness; -#define BRIGHTNESS_MAX 0x20 unsigned char contrast; unsigned char colors; unsigned char autogain; @@ -58,21 +57,21 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val); static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val); static struct ctrl sd_ctrls[] = { -#define SD_BRIGHTNESS 0 { { .id = V4L2_CID_BRIGHTNESS, .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, @@ -81,12 +80,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -95,12 +94,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -109,7 +108,8 @@ static struct ctrl sd_ctrls[] = { .minimum = 0, .maximum = 1, .step = 1, - .default_value = 1, +#define AUTOGAIN_DEF 1 + .default_value = AUTOGAIN_DEF, }, .set = sd_setautogain, .get = sd_getautogain, @@ -124,7 +124,7 @@ static struct cam_mode vga_mode[] = { #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, @@ -195,8 +195,8 @@ const unsigned char pac7311_jpeg_header[] = { }; static void reg_w(struct usb_device *dev, - __u16 index, - char *buffer, __u16 len) + __u16 index, + const char *buffer, __u16 len) { __u8 tmpbuf[8]; @@ -263,10 +263,10 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; } @@ -278,7 +278,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) /*jfm: inverted?*/ brightness = BRIGHTNESS_MAX - sd->brightness; pac7311_reg_write(gspca_dev->dev, 0xff, 0x04); - /* pac7311_reg_write(gspca_dev->dev, 0x0e, 0x00); */ +/* pac7311_reg_write(gspca_dev->dev, 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); @@ -502,7 +502,7 @@ static void setautogain(struct gspca_dev *gspca_dev, int luma) 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; diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index 4f23b16c89a..eb5e1bfd791 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver"); @@ -74,7 +74,6 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val); static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val); static struct ctrl sd_ctrls[] = { -#define SD_BRIGHTNESS 0 { { .id = V4L2_CID_BRIGHTNESS, @@ -83,12 +82,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -97,12 +96,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -111,12 +110,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -125,7 +124,8 @@ static struct ctrl sd_ctrls[] = { .minimum = 0, .maximum = 1, .step = 1, - .default_value = 1, +#define AUTOGAIN_DEF 1 + .default_value = AUTOGAIN_DEF, }, .set = sd_setautogain, .get = sd_getautogain, @@ -139,7 +139,7 @@ static struct cam_mode vga_mode[] = { }; /*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 */ @@ -150,7 +150,7 @@ static __u8 sn_hv7131[] = { /* 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, @@ -161,7 +161,7 @@ static __u8 sn_mi0360[] = { /* 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, @@ -174,13 +174,13 @@ static __u8 sn_mo4000[] = { 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*/ @@ -192,7 +192,7 @@ static __u8 sn_ov7660[] = { }; /* sequence specific to the sensors - !! index = SENSOR_xxx */ -static __u8 *sn_tb[] = { +static const __u8 *sn_tb[] = { sn_hv7131, sn_mi0360, sn_mo4000, @@ -200,28 +200,28 @@ static __u8 *sn_tb[] = { 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}, @@ -250,9 +250,9 @@ static __u8 hv7131r_sensor_init[][8] = { {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}, @@ -304,9 +304,9 @@ static __u8 mi0360_sensor_init[][8] = { /* {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}, @@ -327,9 +327,9 @@ static __u8 mo4000_sensor_init[][8] = { {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 */ @@ -420,12 +420,12 @@ static __u8 ov7660_sensor_init[][8] = { {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}, @@ -478,10 +478,10 @@ static __u8 ov7648_sensor_init[][8] = { {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, @@ -518,27 +518,36 @@ static void reg_w(struct usb_device *dev, 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; @@ -557,7 +566,7 @@ static void i2c_w2(struct gspca_dev *gspca_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); @@ -565,7 +574,7 @@ static void i2c_w8(struct usb_device *dev, __u8 *buffer) /* 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; @@ -591,7 +600,7 @@ static int probesensor(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; __u8 reg02; - static __u8 datasend[] = { 2, 0 }; + static const __u8 datasend[] = { 2, 0 }; /* reg val1 val2 val3 val4 */ __u8 datarecd[6]; @@ -618,18 +627,18 @@ static int probesensor(struct gspca_dev *gspca_dev) } 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}; @@ -697,7 +706,7 @@ static void hv7131R_InitSensor(struct gspca_dev *gspca_dev) { 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]) { @@ -971,11 +980,12 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; } @@ -984,7 +994,7 @@ static int sd_open(struct gspca_dev *gspca_dev) { 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 }; @@ -1036,11 +1046,11 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev, 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) { @@ -1164,14 +1174,15 @@ static void sd_start(struct gspca_dev *gspca_dev) __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]; @@ -1311,13 +1322,13 @@ static void sd_stopN(struct gspca_dev *gspca_dev) { 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) { @@ -1392,7 +1403,7 @@ static void setautogain(struct gspca_dev *gspca_dev) 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; @@ -1567,7 +1578,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -1582,7 +1593,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x0458, 0x7025), DVNM("Genius Eye 311Q")}, {USB_DEVICE(0x045e, 0x00f5), DVNM("MicroSoft VX3000")}, {USB_DEVICE(0x045e, 0x00f7), DVNM("MicroSoft VX1000")}, diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c index 1db5b33ad85..3a42506830f 100644 --- a/drivers/media/video/gspca/spca500.c +++ b/drivers/media/video/gspca/spca500.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver"); @@ -35,7 +35,7 @@ MODULE_LICENSE("GPL"); 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; @@ -70,44 +70,44 @@ static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val); 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, @@ -139,7 +139,7 @@ static struct cam_mode sif_mode[] = { #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, @@ -161,10 +161,9 @@ static __u16 spca500_visual_defaults[][3] = { {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}, @@ -293,7 +292,7 @@ static __u16 Clicksmart510_defaults[][3] = { {} }; -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, @@ -314,7 +313,7 @@ static unsigned char qtable_creative_pccam[2][64] = { 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, @@ -335,7 +334,7 @@ static unsigned char qtable_kodak_ez200[2][64] = { 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, @@ -357,7 +356,7 @@ static unsigned char qtable_pocketdv[2][64] = { 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) { @@ -369,25 +368,24 @@ static void spca5xxRegRead(struct usb_device *dev, 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) */ @@ -405,7 +403,7 @@ static int reg_read(struct usb_device *dev, 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]; @@ -416,13 +414,13 @@ static int reg_read(struct usb_device *dev, * 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); @@ -431,13 +429,13 @@ static int reg_readwait(struct usb_device *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; 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++; @@ -449,21 +447,21 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev, 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; } @@ -474,8 +472,8 @@ static void spca500_ping310(struct gspca_dev *gspca_dev) { __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]); } @@ -483,26 +481,26 @@ static void spca500_clksmart310_init(struct gspca_dev *gspca_dev) { __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, @@ -511,14 +509,14 @@ 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) @@ -526,20 +524,20 @@ 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 */ @@ -562,7 +560,7 @@ static int spca500_synch310(struct gspca_dev *gspca_dev) } 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); @@ -586,12 +584,12 @@ static void spca500_reinit(struct gspca_dev *gspca_dev) /* 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); @@ -599,22 +597,22 @@ static void spca500_reinit(struct gspca_dev *gspca_dev) 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 */ @@ -734,9 +732,9 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; } @@ -771,7 +769,7 @@ static void sd_start(struct gspca_dev *gspca_dev) } /* 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); @@ -782,33 +780,33 @@ static void sd_start(struct gspca_dev *gspca_dev) 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); @@ -816,16 +814,16 @@ static void sd_start(struct gspca_dev *gspca_dev) 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 @@ -838,10 +836,10 @@ static void sd_start(struct gspca_dev *gspca_dev) 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); @@ -849,18 +847,18 @@ static void sd_start(struct gspca_dev *gspca_dev) 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 */ @@ -869,8 +867,8 @@ static void sd_start(struct gspca_dev *gspca_dev) 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); @@ -878,18 +876,18 @@ static void sd_start(struct gspca_dev *gspca_dev) 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: @@ -902,56 +900,56 @@ static void sd_start(struct gspca_dev *gspca_dev) 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; } @@ -959,13 +957,13 @@ static void sd_start(struct gspca_dev *gspca_dev) 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); } @@ -979,13 +977,13 @@ static void sd_close(struct gspca_dev *gspca_dev) 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) { @@ -997,9 +995,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, 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; @@ -1031,43 +1027,52 @@ static void setbrightness(struct gspca_dev *gspca_dev) { 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) @@ -1131,7 +1136,7 @@ static int sd_getcolors(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, @@ -1143,7 +1148,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x040a, 0x0300), DVNM("Kodak EZ200")}, {USB_DEVICE(0x041e, 0x400a), DVNM("Creative PC-CAM 300")}, {USB_DEVICE(0x046d, 0x0890), DVNM("Logitech QuickCam traveler")}, diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c index c6468cf3506..417fbe2214b 100644 --- a/drivers/media/video/gspca/spca501.c +++ b/drivers/media/video/gspca/spca501.c @@ -23,8 +23,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SPCA501 USB Camera Driver"); @@ -151,7 +151,7 @@ static struct cam_mode vga_mode[] = { #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 */ @@ -257,7 +257,7 @@ static __u16 spca501_open_data[][3] = { */ /* 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}, @@ -544,7 +544,7 @@ static __u16 spca501_init_data[][3] = { * 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 */ @@ -639,7 +639,7 @@ static __u16 spca501_3com_open_data[][3] = { * 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}, @@ -661,7 +661,7 @@ static __u16 spca501c_arowana_open_data[][3] = { {} }; -static __u16 spca501c_arowana_init_data[][3] = { +static const __u16 spca501c_arowana_init_data[][3] = { /* bmRequest,value,index */ {0x02, 0x0007, 0x0005}, {0x02, 0xa048, 0x0000}, @@ -1595,7 +1595,7 @@ static __u16 spca501c_arowana_init_data[][3] = { /* 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}, @@ -1646,7 +1646,7 @@ static __u16 spca501c_mysterious_open_data[][3] = { }; /* 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}, */ @@ -1839,7 +1839,7 @@ static int reg_read(struct usb_device *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; @@ -2001,7 +2001,6 @@ static int sd_open(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - PDEBUG(D_STREAM, "SPCA501 init"); switch (sd->subtype) { case ThreeComHomeConnectLite: /* Special handling for 3com data */ @@ -2050,7 +2049,7 @@ static void sd_start(struct gspca_dev *gspca_dev) 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); @@ -2159,7 +2158,7 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -2174,7 +2173,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x040a, 0x0002), DVNM("Kodak DVC-325")}, {USB_DEVICE(0x0497, 0xc001), DVNM("Smile International")}, {USB_DEVICE(0x0506, 0x00df), DVNM("3Com HomeConnect Lite")}, diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c index d8ff121c2c5..30d174fc4b9 100644 --- a/drivers/media/video/gspca/spca505.c +++ b/drivers/media/video/gspca/spca505.c @@ -23,8 +23,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver"); @@ -91,7 +91,7 @@ static struct cam_mode vga_mode[] = { /* * 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}, @@ -130,7 +130,7 @@ static __u16 spca505_init_data[][3] = { /* * 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}, @@ -319,7 +319,7 @@ static __u16 spca505_open_data_ccd[][3] = { /* * 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}, @@ -383,7 +383,7 @@ static __u16 spca505b_init_data[][3] = { /* * 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 */ @@ -579,7 +579,7 @@ static int reg_read(struct usb_device *dev, __u16 length) /* wLength (1 or 2 only) */ { int ret; - unsigned char buf[4]; + __u8 buf[4]; buf[1] = 0; ret = usb_control_msg(dev, @@ -599,7 +599,7 @@ static int reg_read(struct usb_device *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; @@ -801,7 +801,7 @@ static void yyuv_decode(unsigned char *out, 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; @@ -878,7 +878,7 @@ static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -893,7 +893,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x041e, 0x401d), DVNM("Creative Webcam NX ULTRA")}, {USB_DEVICE(0x0733, 0x0430), DVNM("Intel PC Camera Pro")}, {} diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c index 2ccd877b998..3b54f41d21c 100644 --- a/drivers/media/video/gspca/spca508.c +++ b/drivers/media/video/gspca/spca508.c @@ -22,8 +22,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SPCA508 USB Camera Driver"); @@ -92,7 +92,7 @@ static struct cam_mode sif_mode[] = { * 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 */ @@ -584,7 +584,7 @@ static __u16 spca508_init_data[][3] = /* * 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 */ @@ -668,7 +668,7 @@ static __u16 spca508cs110_init_data[][3] = { {} }; -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}, @@ -752,7 +752,7 @@ static __u16 spca508_sightcam_init_data[][3] = { {0, 0} }; -static __u16 spca508_sightcam2_init_data[][3] = { +static const __u16 spca508_sightcam2_init_data[][3] = { /* 35 */ {0x0020, 0x8112}, /* 36 */ {0x000f, 0x8402}, @@ -1099,7 +1099,7 @@ static __u16 spca508_sightcam2_init_data[][3] = { /* * 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 */ @@ -1441,7 +1441,7 @@ static int reg_read(struct usb_device *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; @@ -1639,7 +1639,7 @@ static void yuvy_decode(unsigned char *out, 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; @@ -1717,7 +1717,7 @@ static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -1732,7 +1732,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x041e, 0x4018), DVNM("Creative Webcam Vista (PD1100)")}, {USB_DEVICE(0x0461, 0x0815), DVNM("Micro Innovation IC200")}, {USB_DEVICE(0x0733, 0x0110), DVNM("ViewQuest VQ110")}, diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c index dbd1648a655..8e39cbdda2a 100644 --- a/drivers/media/video/gspca/spca561.c +++ b/drivers/media/video/gspca/spca561.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver"); @@ -148,7 +148,8 @@ static void reg_w_val(struct usb_device *dev, __u16 index, __u16 value) 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; @@ -171,13 +172,16 @@ static void reg_r(struct usb_device *dev, } 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) @@ -227,7 +231,7 @@ static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __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 */ @@ -437,7 +441,7 @@ static void sensor_reset(struct gspca_dev *gspca_dev) } /******************** QC Express etch2 stuff ********************/ -static __u16 Pb100_1map8300[][2] = { +static const __u16 Pb100_1map8300[][2] = { /* reg, value */ {0x8320, 0x3304}, @@ -452,14 +456,14 @@ static __u16 Pb100_1map8300[][2] = { {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}, @@ -467,7 +471,7 @@ static __u16 spca561_161rev12A_data1[][2] = { {0x04, 0x8802}, /* windows uses 08 */ {} }; -static __u16 spca561_161rev12A_data2[][2] = { +static const __u16 spca561_161rev12A_data2[][2] = { {0x21, 0x8118}, {0x10, 0x8500}, {0x07, 0x8601}, @@ -513,7 +517,7 @@ static __u16 spca561_161rev12A_data2[][2] = { }; static void sensor_mapwrite(struct gspca_dev *gspca_dev, - __u16 sensormap[][2]) + const __u16 sensormap[][2]) { int i = 0; __u8 usbval[2]; @@ -956,7 +960,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -971,7 +975,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(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")}, diff --git a/drivers/media/video/gspca/stk014.c b/drivers/media/video/gspca/stk014.c index 6832fe0f340..ad59c5ab5d9 100644 --- a/drivers/media/video/gspca/stk014.c +++ b/drivers/media/video/gspca/stk014.c @@ -23,8 +23,8 @@ #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 "); MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver"); @@ -54,7 +54,6 @@ static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val); static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val); static struct ctrl sd_ctrls[] = { -#define SD_BRIGHTNESS 0 { { .id = V4L2_CID_BRIGHTNESS, @@ -63,12 +62,12 @@ static struct ctrl sd_ctrls[] = { .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, @@ -77,26 +76,26 @@ static struct ctrl sd_ctrls[] = { .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, @@ -105,7 +104,8 @@ static struct ctrl sd_ctrls[] = { .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, @@ -296,10 +296,10 @@ static int sd_config(struct gspca_dev *gspca_dev, 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; } @@ -408,7 +408,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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}; @@ -518,10 +518,10 @@ static int sd_querymenu(struct gspca_dev *gspca_dev, 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; diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c index 113c0710692..f2d03350858 100644 --- a/drivers/media/video/gspca/sunplus.c +++ b/drivers/media/video/gspca/sunplus.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 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 "); MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver"); @@ -35,7 +35,7 @@ MODULE_LICENSE("GPL"); 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; @@ -156,7 +156,7 @@ static struct cam_mode vga_mode2[] = { #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}, @@ -186,7 +186,7 @@ static __u16 spca504_pccam600_init_data[][3] = { /* 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}, @@ -195,7 +195,7 @@ static __u16 spca504_pccam600_open_data[][3] = { }; /* 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}, @@ -226,7 +226,7 @@ static __u16 spca504A_clicksmart420_init_data[][3] = { }; /* 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}, @@ -373,7 +373,7 @@ static __u16 spca504A_clicksmart420_open_data[][3] = { {} }; -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, @@ -398,7 +398,7 @@ static unsigned char qtable_creative_pccam[2][64] = { * 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, @@ -512,7 +512,7 @@ static int reg_read(struct usb_device *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; @@ -534,7 +534,7 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev, 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; @@ -1242,7 +1242,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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; @@ -1530,7 +1530,7 @@ static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -1545,7 +1545,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x041e, 0x400b), DVNM("Creative PC-CAM 600")}, {USB_DEVICE(0x041e, 0x4012), DVNM("PC-Cam350")}, {USB_DEVICE(0x041e, 0x4013), DVNM("Creative Pccam750")}, diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c index de43118dec7..4e69a8e1635 100644 --- a/drivers/media/video/gspca/t613.c +++ b/drivers/media/video/gspca/t613.c @@ -26,13 +26,8 @@ #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 */ @@ -227,19 +222,16 @@ static struct ctrl sd_ctrls[] = { }, }; -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}, @@ -252,7 +244,7 @@ static struct cam_mode vga_mode_t16[] = { #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 */ @@ -262,7 +254,7 @@ unsigned char effects_table[MAX_EFFECTS][6] = { {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, @@ -345,7 +337,7 @@ unsigned char gamma_table[MAX_GAMMA][34] = { 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}, @@ -366,22 +358,41 @@ static void t16RegRead(struct usb_device *dev, 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 */ @@ -421,18 +432,18 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) 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, @@ -442,40 +453,40 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) 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); @@ -493,31 +504,31 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) 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); @@ -530,7 +541,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; unsigned int brightness; - unsigned char set6[4] = { 0x8f, 0x26, 0xc3, 0x80 }; + __u8 set6[4] = { 0x8f, 0x26, 0xc3, 0x80 }; brightness = sd->brightness; if (brightness < 7) { @@ -548,7 +559,7 @@ static void setflip(struct gspca_dev *gspca_dev) 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) @@ -570,9 +581,9 @@ static void seteffect(struct gspca_dev *gspca_dev) } 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) @@ -580,7 +591,7 @@ 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) @@ -613,18 +624,17 @@ static void setcontrast(struct gspca_dev *gspca_dev) 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) @@ -635,11 +645,11 @@ static void setsharpness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; - __u16 reg_to_write = 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) @@ -655,6 +665,7 @@ 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; } @@ -677,7 +688,6 @@ static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val) return *val; } - static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val) { struct sd *sd = (struct sd *) gspca_dev; @@ -811,9 +821,9 @@ static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val) 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; } @@ -831,12 +841,12 @@ static void sd_start(struct gspca_dev *gspca_dev) 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) { @@ -860,16 +870,16 @@ static void sd_start(struct gspca_dev *gspca_dev) 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 */ @@ -892,11 +902,11 @@ static void sd_close(struct gspca_dev *gspca_dev) 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, @@ -935,27 +945,26 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, 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 */ @@ -966,7 +975,7 @@ static int sd_open(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), @@ -982,11 +991,10 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x17a1, 0x0128), DVNM("XPX Webcam")}, {} }; - MODULE_DEVICE_TABLE(usb, device_table); /* -- device connect -- */ diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c index 6da5280b543..8561234d65e 100644 --- a/drivers/media/video/gspca/tv8532.c +++ b/drivers/media/video/gspca/tv8532.c @@ -22,8 +22,8 @@ #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 "); MODULE_DESCRIPTION("TV8532 USB Camera Driver"); @@ -152,7 +152,7 @@ static struct cam_mode sif_mode[] = { #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, @@ -243,7 +243,7 @@ static int sd_config(struct gspca_dev *gspca_dev, static void tv_8532ReadRegisters(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 data = 0; + __u8 data; /* __u16 vid, pid; */ reg_r(dev, 0x0001, &data); @@ -275,7 +275,7 @@ static void tv_8532ReadRegisters(struct gspca_dev *gspca_dev) 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; @@ -320,7 +320,7 @@ static void tv_8532_setReg(struct gspca_dev *gspca_dev) 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 */ @@ -338,9 +338,9 @@ static void tv_8532_PollReg(struct gspca_dev *gspca_dev) 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); @@ -646,7 +646,7 @@ static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val) } /* 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), @@ -661,7 +661,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x046d, 0x0920), DVNM("QC Express")}, {USB_DEVICE(0x046d, 0x0921), DVNM("Labtec Webcam")}, {USB_DEVICE(0x0545, 0x808b), DVNM("Veo Stingray")}, diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c index 8b5f6d17d2a..4144e11c60b 100644 --- a/drivers/media/video/gspca/vc032x.c +++ b/drivers/media/video/gspca/vc032x.c @@ -24,8 +24,8 @@ #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 "); MODULE_DESCRIPTION("GSPCA/VC032X USB Camera Driver"); @@ -97,7 +97,7 @@ static struct cam_mode vc0323_mode[] = { {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}, @@ -249,7 +249,7 @@ static __u8 mi1310_socinitVGA_JPG[][4] = { {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}, @@ -323,14 +323,14 @@ static __u8 mi1310_socinitQVGA_JPG[][4] = { {}, }; -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}, @@ -409,7 +409,7 @@ static __u8 mi1320_initVGA_data[][4] = { {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}, @@ -478,15 +478,15 @@ static __u8 mi1320_initQVGA_data[][4] = { {} }; -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}, @@ -569,7 +569,7 @@ static __u8 po3130_initVGA_data[][4] = { {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}, @@ -584,7 +584,7 @@ static __u8 po3130_rundata[][4] = { {} }; -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}, @@ -670,16 +670,16 @@ static __u8 po3130_initQVGA_data[][4] = { {} }; -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}, @@ -722,7 +722,7 @@ static __u8 hv7131r_initVGA_data[][4] = { {} }; -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}, @@ -777,14 +777,14 @@ static __u8 hv7131r_initQVGA_data[][4] = { {} }; -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}, @@ -842,7 +842,7 @@ static __u8 ov7660_initVGA_data[][4] = { {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}, @@ -911,26 +911,26 @@ static __u8 ov7660_initQVGA_data[][4] = { {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}, @@ -1058,7 +1058,7 @@ static __u8 ov7670_initVGA_JPG[][4] = { {}, }; -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}, @@ -1200,7 +1200,7 @@ struct sensor_info { __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}, @@ -1282,7 +1282,7 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev) 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); @@ -1309,7 +1309,7 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev) } static __u8 i2c_write(struct usb_device *dev, - __u8 reg, __u8 *val, __u8 size) + __u8 reg, const __u8 *val, __u8 size) { __u8 retbyte; @@ -1341,7 +1341,7 @@ static __u8 i2c_write(struct usb_device *dev, } 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; @@ -1351,7 +1351,7 @@ static void put_tab_to_reg(struct gspca_dev *gspca_dev, } 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; @@ -1511,7 +1511,7 @@ static void setautogain(struct gspca_dev *gspca_dev) 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) @@ -1523,8 +1523,8 @@ static void sd_start(struct gspca_dev *gspca_dev) { 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 */ @@ -1673,7 +1673,7 @@ static void sd_close(struct gspca_dev *gspca_dev) 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; @@ -1739,13 +1739,13 @@ static int sd_querymenu(struct gspca_dev *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; @@ -1754,7 +1754,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev, } /* sub-driver description */ -static struct sd_desc sd_desc = { +static const struct sd_desc sd_desc = { .name = MODULE_NAME, .ctrls = sd_ctrls, .nctrls = ARRAY_SIZE(sd_ctrls), @@ -1770,7 +1770,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x046d, 0x0892), DVNM("Logitech Orbicam")}, {USB_DEVICE(0x046d, 0x0896), DVNM("Logitech Orbicam")}, {USB_DEVICE(0x0ac8, 0x0321), DVNM("Vimicro generic vc0321")}, diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c index ccd24cb92b3..878344e4d2e 100644 --- a/drivers/media/video/gspca/zc3xx.c +++ b/drivers/media/video/gspca/zc3xx.c @@ -24,8 +24,8 @@ #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 , " "Serge A. Suchkov "); @@ -190,7 +190,7 @@ struct usb_action { __u16 idx; }; -static struct usb_action cs2102_Initial[] = { +static const struct usb_action cs2102_Initial[] = { {0xa1, 0x01, 0x0008}, {0xa1, 0x01, 0x0008}, {0xa0, 0x01, 0x0000}, @@ -320,7 +320,7 @@ static struct usb_action cs2102_Initial[] = { {} }; -static struct usb_action cs2102_InitialScale[] = { +static const struct usb_action cs2102_InitialScale[] = { {0xa1, 0x01, 0x0008}, {0xa1, 0x01, 0x0008}, {0xa0, 0x01, 0x0000}, @@ -449,7 +449,7 @@ static struct usb_action cs2102_InitialScale[] = { {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 */ @@ -474,7 +474,7 @@ static struct usb_action cs2102_50HZ[] = { {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 */ @@ -499,7 +499,7 @@ static struct usb_action cs2102_50HZScale[] = { {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 */ @@ -524,7 +524,7 @@ static struct usb_action cs2102_60HZ[] = { {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 */ @@ -549,7 +549,7 @@ static struct usb_action cs2102_60HZScale[] = { {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 */ @@ -574,7 +574,7 @@ static struct usb_action cs2102_NoFliker[] = { {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 */ @@ -601,7 +601,7 @@ static struct usb_action cs2102_NoFlikerScale[] = { }; /* CS2102_KOCOM */ -static struct usb_action cs2102K_Initial[] = { +static const struct usb_action cs2102K_Initial[] = { {0xa0, 0x11, 0x0002}, {0xa0, 0x03, 0x0008}, {0xa0, 0x08, 0x0010}, @@ -860,7 +860,7 @@ static struct usb_action cs2102K_Initial[] = { {} }; -static struct usb_action cs2102K_InitialScale[] = { +static const struct usb_action cs2102K_InitialScale[] = { {0xa0, 0x11, 0x0002}, {0xa0, 0x00, 0x0002}, {0xa0, 0x03, 0x0008}, @@ -1437,7 +1437,7 @@ static struct usb_action cs2102K_InitialScale[] = { {} }; -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 */ @@ -1501,7 +1501,7 @@ static struct usb_action gc0305_Initial[] = { /* 640x480 */ {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 */ @@ -1564,7 +1564,7 @@ static struct usb_action gc0305_InitialScale[] = { /* 320x240 */ {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 */ @@ -1587,7 +1587,7 @@ static struct usb_action gc0305_50HZ[] = { /* {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 */ @@ -1611,7 +1611,7 @@ static struct usb_action gc0305_60HZ[] = { {} }; -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 */ @@ -1635,7 +1635,7 @@ static struct usb_action gc0305_NoFliker[] = { }; /* 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}, @@ -1780,7 +1780,7 @@ static struct usb_action hdcs2020xx_Initial[] = { {} }; -static struct usb_action hdcs2020xx_InitialScale[] = { +static const struct usb_action hdcs2020xx_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x03, 0x0008}, {0xa0, 0x0e, 0x0010}, @@ -1922,7 +1922,7 @@ static struct usb_action hdcs2020xx_InitialScale[] = { /* {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 */ @@ -2054,7 +2054,7 @@ static struct usb_action hdcs2020xb_Initial[] = { {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}, @@ -2182,7 +2182,7 @@ static struct usb_action hdcs2020xb_InitialScale[] = { {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 */ @@ -2203,7 +2203,7 @@ static struct usb_action hdcs2020b_50HZ[] = { {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 */ @@ -2224,7 +2224,7 @@ static struct usb_action hdcs2020b_60HZ[] = { {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 */ @@ -2246,7 +2246,7 @@ static struct usb_action hdcs2020b_NoFliker[] = { {} }; -static struct usb_action hv7131bxx_Initial[] = { +static const struct usb_action hv7131bxx_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x10, 0x0002}, {0xa0, 0x00, 0x0010}, @@ -2354,7 +2354,7 @@ static struct usb_action hv7131bxx_Initial[] = { {} }; -static struct usb_action hv7131bxx_InitialScale[] = { +static const struct usb_action hv7131bxx_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x00, 0x0002}, {0xa0, 0x00, 0x0010}, @@ -2460,7 +2460,7 @@ static struct usb_action hv7131bxx_InitialScale[] = { {} }; -static struct usb_action hv7131cxx_Initial[] = { +static const struct usb_action hv7131cxx_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x10, 0x0002}, {0xa0, 0x01, 0x0010}, @@ -2554,7 +2554,7 @@ static struct usb_action hv7131cxx_Initial[] = { {} }; -static struct usb_action hv7131cxx_InitialScale[] = { +static const struct usb_action hv7131cxx_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x00, 0x0002}, /* diff */ @@ -2655,7 +2655,7 @@ static struct usb_action hv7131cxx_InitialScale[] = { {} }; -static struct usb_action icm105axx_Initial[] = { +static const struct usb_action icm105axx_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x10, 0x0002}, {0xa0, 0x03, 0x0008}, @@ -2832,7 +2832,7 @@ static struct usb_action icm105axx_Initial[] = { {} }; -static struct usb_action icm105axx_InitialScale[] = { +static const struct usb_action icm105axx_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x00, 0x0002}, {0xa0, 0x03, 0x0008}, @@ -3011,7 +3011,7 @@ static struct usb_action icm105axx_InitialScale[] = { {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 */ @@ -3042,7 +3042,7 @@ static struct usb_action icm105a_50HZ[] = { {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 */ @@ -3075,7 +3075,7 @@ static struct usb_action icm105a_50HZScale[] = { {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 */ @@ -3106,7 +3106,7 @@ static struct usb_action icm105a_60HZ[] = { {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 */ @@ -3139,7 +3139,7 @@ static struct usb_action icm105a_60HZScale[] = { {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 */ @@ -3170,7 +3170,7 @@ static struct usb_action icm105a_NoFliker[] = { {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 */ @@ -3204,7 +3204,7 @@ static struct usb_action icm105a_NoFlikerScale[] = { {} }; -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 */ @@ -3324,7 +3324,7 @@ static struct usb_action MC501CB_InitialScale[] = { {} }; -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 */ @@ -3443,7 +3443,7 @@ static struct usb_action MC501CB_Initial[] = { /* 320x240 */ {} }; -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 */ @@ -3460,7 +3460,7 @@ static struct usb_action MC501CB_50HZ[] = { {} }; -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 */ @@ -3477,7 +3477,7 @@ static struct usb_action MC501CB_50HZScale[] = { {} }; -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 */ @@ -3494,7 +3494,7 @@ static struct usb_action MC501CB_60HZ[] = { {} }; -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 */ @@ -3511,7 +3511,7 @@ static struct usb_action MC501CB_60HZScale[] = { {} }; -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 */ @@ -3528,7 +3528,7 @@ static struct usb_action MC501CB_NoFliker[] = { {} }; -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 */ @@ -3541,7 +3541,7 @@ static struct usb_action MC501CB_NoFlikerScale[] = { }; /* 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 */ @@ -3612,7 +3612,7 @@ static struct usb_action OV7620_mode0[] = { }; /* 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? */ @@ -3683,7 +3683,7 @@ static struct usb_action OV7620_mode1[] = { }; /* 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 */ @@ -3702,7 +3702,7 @@ static struct usb_action OV7620_50HZ[] = { }; /* 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 */ @@ -3724,7 +3724,7 @@ static struct usb_action OV7620_60HZ[] = { }; /* 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 */ @@ -3743,7 +3743,7 @@ static struct usb_action OV7620_NoFliker[] = { {} }; -static struct usb_action ov7630c_Initial[] = { +static const struct usb_action ov7630c_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x10, 0x0002}, {0xa0, 0x01, 0x0000}, @@ -3900,7 +3900,7 @@ static struct usb_action ov7630c_Initial[] = { {} }; -static struct usb_action ov7630c_InitialScale[] = { +static const struct usb_action ov7630c_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x00, 0x0002}, {0xa0, 0x03, 0x0008}, @@ -4057,7 +4057,7 @@ static struct usb_action ov7630c_InitialScale[] = { {} }; -static struct usb_action pas106b_Initial_com[] = { +static const struct usb_action pas106b_Initial_com[] = { /* Sream and Sensor specific */ {0xa1, 0x01, 0x0010}, /* CMOSSensorSelect */ /* System */ @@ -4071,7 +4071,7 @@ static struct usb_action pas106b_Initial_com[] = { {} }; -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 */ @@ -4189,7 +4189,7 @@ static struct usb_action pas106b_Initial[] = { /* 176x144 */ {} }; -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 */ @@ -4312,7 +4312,7 @@ static struct usb_action pas106b_InitialScale[] = { /* 352x288 */ {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 */ @@ -4328,7 +4328,7 @@ static struct usb_action pas106b_50HZ[] = { {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 */ @@ -4344,7 +4344,7 @@ static struct usb_action pas106b_60HZ[] = { {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 */ @@ -4361,7 +4361,7 @@ static struct usb_action pas106b_NoFliker[] = { {} }; -static struct usb_action pb03303x_Initial[] = { +static const struct usb_action pb03303x_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x03, 0x0008}, {0xa0, 0x0a, 0x0010}, @@ -4507,7 +4507,7 @@ static struct usb_action pb03303x_Initial[] = { {} }; -static struct usb_action pb03303x_InitialScale[] = { +static const struct usb_action pb03303x_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x03, 0x0008}, {0xa0, 0x0a, 0x0010}, @@ -4655,7 +4655,7 @@ static struct usb_action pb03303x_InitialScale[] = { {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}, @@ -4770,7 +4770,7 @@ static struct usb_action pb0330xx_Initial[] = { {} }; -static struct usb_action pb0330xx_InitialScale[] = { +static const struct usb_action pb0330xx_InitialScale[] = { {0xa1, 0x01, 0x0008}, {0xa1, 0x01, 0x0008}, {0xa0, 0x01, 0x0000}, @@ -4883,7 +4883,7 @@ static struct usb_action pb0330xx_InitialScale[] = { /* {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 */ @@ -4899,7 +4899,7 @@ static struct usb_action pb0330_50HZ[] = { {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 */ @@ -4916,7 +4916,7 @@ static struct usb_action pb0330_50HZScale[] = { {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 */ @@ -4933,7 +4933,7 @@ static struct usb_action pb0330_60HZ[] = { {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 */ @@ -4950,7 +4950,7 @@ static struct usb_action pb0330_60HZScale[] = { {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 */ @@ -4967,7 +4967,7 @@ static struct usb_action pb0330_NoFliker[] = { {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 */ @@ -4986,7 +4986,7 @@ static struct usb_action pb0330_NoFlikerScale[] = { }; /* 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 */ @@ -5063,7 +5063,7 @@ static struct usb_action PO2030_mode0[] = { }; /* 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 */ @@ -5139,7 +5139,7 @@ static struct usb_action PO2030_mode1[] = { {} }; -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 */ @@ -5161,7 +5161,7 @@ static struct usb_action PO2030_50HZ[] = { {} }; -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 */ @@ -5183,7 +5183,7 @@ static struct usb_action PO2030_60HZ[] = { {} }; -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 */ @@ -5195,7 +5195,7 @@ static struct usb_action PO2030_NoFliker[] = { }; /* TEST */ -static struct usb_action tas5130CK_Initial[] = { +static const struct usb_action tas5130CK_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x01, 0x003b}, {0xa0, 0x0e, 0x003a}, @@ -5398,7 +5398,7 @@ static struct usb_action tas5130CK_Initial[] = { {} }; -static struct usb_action tas5130CK_InitialScale[] = { +static const struct usb_action tas5130CK_InitialScale[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x01, 0x003b}, {0xa0, 0x0e, 0x003a}, @@ -5606,7 +5606,7 @@ static struct usb_action tas5130CK_InitialScale[] = { {} }; -static struct usb_action tas5130cxx_Initial[] = { +static const struct usb_action tas5130cxx_Initial[] = { {0xa0, 0x01, 0x0000}, {0xa0, 0x50, 0x0002}, {0xa0, 0x03, 0x0008}, @@ -5695,7 +5695,7 @@ static struct usb_action tas5130cxx_Initial[] = { {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}, @@ -5785,7 +5785,7 @@ static struct usb_action tas5130cxx_InitialScale[] = { {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 */ @@ -5808,7 +5808,7 @@ static struct usb_action tas5130cxx_50HZ[] = { {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 */ @@ -5831,7 +5831,7 @@ static struct usb_action tas5130cxx_50HZScale[] = { {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 */ @@ -5854,7 +5854,7 @@ static struct usb_action tas5130cxx_60HZ[] = { {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 */ @@ -5877,7 +5877,7 @@ static struct usb_action tas5130cxx_60HZScale[] = { {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 */ @@ -5901,7 +5901,7 @@ static struct usb_action tas5130cxx_NoFliker[] = { {} }; -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 */ @@ -5925,7 +5925,7 @@ static struct usb_action tas5130cxx_NoFlikerScale[] = { {} }; -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, */ @@ -5989,7 +5989,7 @@ static struct usb_action tas5130c_vf0250_Initial[] = { {} }; -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, */ @@ -6053,7 +6053,7 @@ static struct usb_action tas5130c_vf0250_InitialScale[] = { {} }; /* "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 */ @@ -6078,7 +6078,7 @@ static struct usb_action tas5130c_vf0250_50HZ[] = { }; /* "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 */ @@ -6103,7 +6103,7 @@ static struct usb_action tas5130c_vf0250_50HZScale[] = { }; /* "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 */ @@ -6128,7 +6128,7 @@ static struct usb_action tas5130c_vf0250_60HZ[] = { }; /* "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 */ @@ -6153,7 +6153,7 @@ static struct usb_action tas5130c_vf0250_60HZScale[] = { }; /* "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 */ @@ -6176,7 +6176,7 @@ static struct usb_action tas5130c_vf0250_NoFliker[] = { }; /* "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 */ @@ -6272,7 +6272,7 @@ static __u8 i2c_write(struct usb_device *dev, } static void usb_exchange(struct usb_device *dev, - struct usb_action *action) + const struct usb_action *action) { __u8 buffread; @@ -6304,12 +6304,12 @@ static void setmatrix(struct gspca_dev *gspca_dev) { 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) { @@ -6361,7 +6361,7 @@ static void setsharpness(struct gspca_dev *gspca_dev) 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}, @@ -6380,55 +6380,55 @@ static void setcontrast(struct gspca_dev *gspca_dev) { 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 }; @@ -6529,8 +6529,8 @@ static int setlightfreq(struct gspca_dev *gspca_dev) { 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, @@ -6952,7 +6952,7 @@ static int sd_config(struct gspca_dev *gspca_dev, 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 */ @@ -7145,10 +7145,10 @@ static void sd_start(struct gspca_dev *gspca_dev) { 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 */ @@ -7451,13 +7451,13 @@ static int sd_querymenu(struct gspca_dev *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; @@ -7465,7 +7465,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev, 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], @@ -7480,7 +7480,7 @@ static struct sd_desc sd_desc = { }; #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")}, -- cgit v1.2.3-70-g09d2 From c2446b3eba97243acbe2ad0939a28b5edb97eae7 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Sat, 5 Jul 2008 11:49:20 -0300 Subject: V4L/DVB (8201): gspca: v4l2_pix_format in each subdriver. main: Parameter comp_fac removed. main, pac207: get_buff_size op removed. (all) v4l2_pix_format in each subdriver. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/conex.c | 54 ++++++++++----- drivers/media/video/gspca/etoms.c | 42 +++++++---- drivers/media/video/gspca/gspca.c | 134 +++++++----------------------------- drivers/media/video/gspca/gspca.h | 13 +--- drivers/media/video/gspca/mars.c | 18 +++-- drivers/media/video/gspca/ov519.c | 32 ++++++--- drivers/media/video/gspca/pac207.c | 33 ++++----- drivers/media/video/gspca/pac7311.c | 26 +++++-- drivers/media/video/gspca/sonixb.c | 41 ++++++++--- drivers/media/video/gspca/sonixj.c | 26 +++++-- drivers/media/video/gspca/spca500.c | 34 ++++++--- drivers/media/video/gspca/spca501.c | 26 +++++-- drivers/media/video/gspca/spca505.c | 38 +++++++--- drivers/media/video/gspca/spca506.c | 52 +++++++++----- drivers/media/video/gspca/spca508.c | 32 ++++++--- drivers/media/video/gspca/spca561.c | 32 ++++++--- drivers/media/video/gspca/stk014.c | 18 +++-- drivers/media/video/gspca/sunplus.c | 60 ++++++++++++---- drivers/media/video/gspca/t613.c | 38 +++++++--- drivers/media/video/gspca/tv8532.c | 20 ++++-- drivers/media/video/gspca/vc032x.c | 34 ++++++--- drivers/media/video/gspca/zc3xx.c | 36 +++++++--- 22 files changed, 519 insertions(+), 320 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c index 6d50247b7ad..b5481017dd4 100644 --- a/drivers/media/video/gspca/conex.c +++ b/drivers/media/video/gspca/conex.c @@ -25,8 +25,8 @@ #define CONEX_CAM 1 /* special JPEG header */ #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA USB Conexant Camera Driver"); @@ -52,7 +52,6 @@ static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val); static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val); static struct ctrl sd_ctrls[] = { -#define SD_BRIGHTNESS 0 { { .id = V4L2_CID_BRIGHTNESS, @@ -61,12 +60,12 @@ static struct ctrl sd_ctrls[] = { .minimum = 0, .maximum = 255, .step = 1, - .default_value = 0xd4, +#define BRIGHTNESS_DEF 0xd4 + .default_value = BRIGHTNESS_DEF, }, .set = sd_setbrightness, .get = sd_getbrightness, }, -#define SD_CONTRAST 1 { { .id = V4L2_CID_CONTRAST, @@ -75,12 +74,12 @@ static struct ctrl sd_ctrls[] = { .minimum = 0x0a, .maximum = 0x1f, .step = 1, - .default_value = 0x0c, +#define CONTRAST_DEF 0x0c + .default_value = CONTRAST_DEF, }, .set = sd_setcontrast, .get = sd_getcontrast, }, -#define SD_COLOR 2 { { .id = V4L2_CID_SATURATION, @@ -89,18 +88,35 @@ static struct ctrl sd_ctrls[] = { .minimum = 0, .maximum = 7, .step = 1, - .default_value = 3, +#define COLOR_DEF 3 + .default_value = COLOR_DEF, }, .set = sd_setcolors, .get = sd_getcolors, }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 176, 144, 3}, - {V4L2_PIX_FMT_JPEG, 320, 240, 2}, - {V4L2_PIX_FMT_JPEG, 352, 288, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 3}, + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; static void reg_r(struct usb_device *dev, @@ -269,7 +285,7 @@ static void cx_sensor(struct gspca_dev*gspca_dev) val = 0x03; reg_w(gspca_dev->dev, 0x0092, &val, 1); - switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: reg_w(gspca_dev->dev, 0x0071, reg71a, 4); break; @@ -350,7 +366,7 @@ static int cx11646_initsize(struct gspca_dev *gspca_dev) static const __u8 reg17[] = { 0x0a, 0x00, 0xf2, 0x01, 0x0f, 0x00, 0x97, 0x02 }; - switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: cxinit = cx_inits_640; break; @@ -668,7 +684,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) 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) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: for (i = 0; i < 27; i++) { if (i == 26) @@ -832,9 +848,9 @@ static int sd_config(struct gspca_dev *gspca_dev, cam->nmodes = sizeof vga_mode / sizeof vga_mode[0]; 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; + sd->brightness = BRIGHTNESS_DEF; + sd->contrast = CONTRAST_DEF; + sd->colors = COLOR_DEF; return 0; } diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index bbbe65923cf..4db33618af6 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("Etoms USB Camera Driver"); @@ -114,14 +114,30 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_SBGGR8, 320, 240, 1}, -/* {V4L2_PIX_FMT_SBGGR8, 640, 480, 0}, */ +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, +/* {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, */ }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_SBGGR8, 176, 144, 1}, - {V4L2_PIX_FMT_SBGGR8, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; #define ETOMS_ALT_SIZE_1000 12 @@ -334,7 +350,7 @@ static void Et_init2(struct gspca_dev *gspca_dev) reg_w_val(dev, ET_CTRL, 0x1b); /* compression et subsampling */ - if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) + if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) value = ET_COMP_VAL1; /* 320 */ else value = ET_COMP_VAL0; /* 640 */ @@ -410,7 +426,7 @@ static void Et_init2(struct gspca_dev *gspca_dev) /* 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) + if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) value = 0x04; /* 320 */ else /* 640 */ value = 0x1e; /* 0x17 * setting PixelClock @@ -487,12 +503,12 @@ static void Et_init1(struct gspca_dev *gspca_dev) 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) + if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) 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, + gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv, value); reg_w_val(dev, ET_COMP, value); reg_w_val(dev, ET_MAXQt, 0x1d); @@ -533,7 +549,7 @@ static void Et_init1(struct gspca_dev *gspca_dev) 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) { + if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { I2c0[0] = 0x06; Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1); Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof I2c2, 1); diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c index 1225c0fe26f..cb0aeb0c0a4 100644 --- a/drivers/media/video/gspca/gspca.c +++ b/drivers/media/video/gspca/gspca.c @@ -43,13 +43,11 @@ MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("GSPCA USB Camera Driver"); MODULE_LICENSE("GPL"); -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; static int video_nr = -1; -static int comp_fac = 30; /* Buffer size ratio when compressed in % */ - #ifdef CONFIG_VIDEO_ADV_DEBUG int gspca_debug = D_ERR | D_PROBE; EXPORT_SYMBOL(gspca_debug); @@ -361,58 +359,6 @@ static void rvfree(void *mem, unsigned long size) vfree(mem); } -static __u32 get_v4l2_depth(__u32 pixfmt) -{ - switch (pixfmt) { -/* case V4L2_PIX_FMT_BGR32: - case V4L2_PIX_FMT_RGB32: - return 32; */ - case V4L2_PIX_FMT_RGB24: /* 'RGB3' */ - case V4L2_PIX_FMT_BGR24: - return 24; -/* case V4L2_PIX_FMT_RGB565: * 'RGBP' */ - case V4L2_PIX_FMT_YUYV: /* 'YUYV' packed 4.2.2 */ - case V4L2_PIX_FMT_YYUV: /* 'YYUV' */ - return 16; - case V4L2_PIX_FMT_YUV420: /* 'YU12' planar 4.2.0 */ - case V4L2_PIX_FMT_SPCA501: /* 'S501' YUYV per line */ - return 12; - case V4L2_PIX_FMT_MJPEG: - case V4L2_PIX_FMT_JPEG: - case V4L2_PIX_FMT_SBGGR8: /* 'BA81' Bayer */ - case V4L2_PIX_FMT_SN9C10X: /* 'S910' SN9C10x compression */ - case V4L2_PIX_FMT_SPCA561: /* 'S561' compressed GBRG bayer */ - case V4L2_PIX_FMT_PAC207: /* 'P207' compressed BGGR bayer */ - return 8; - } - PDEBUG(D_ERR|D_CONF, "Unknown pixel format %c%c%c%c", - pixfmt & 0xff, - (pixfmt >> 8) & 0xff, - (pixfmt >> 16) & 0xff, - pixfmt >> 24); - return 24; -} - -static int gspca_get_buff_size(struct gspca_dev *gspca_dev, int mode) -{ - unsigned int size; - - if (gspca_dev->sd_desc->get_buff_size) - return gspca_dev->sd_desc->get_buff_size(gspca_dev, mode); - - size = gspca_dev->cam.cam_mode[mode].width * - gspca_dev->cam.cam_mode[mode].height * - get_v4l2_depth(gspca_dev->cam.cam_mode[mode].pixfmt) / 8; - if (!size) - return -ENOMEM; - - /* if compressed (JPEG), reduce the buffer size */ - if (gspca_is_compressed(gspca_dev->cam.cam_mode[mode].pixfmt)) - size = (size * comp_fac) / 100 + 600; /* (+ JPEG header sz) */ - - return size; -} - static int frame_alloc(struct gspca_dev *gspca_dev, unsigned int count) { @@ -420,15 +366,14 @@ static int frame_alloc(struct gspca_dev *gspca_dev, unsigned int frsz; int i; - frsz = gspca_get_buff_size(gspca_dev, gspca_dev->curr_mode); - if (frsz < 0) - return frsz; + i = gspca_dev->curr_mode; + frsz = gspca_dev->cam.cam_mode[i].sizeimage; PDEBUG(D_STREAM, "frame alloc frsz: %d", frsz); - if (count > GSPCA_MAX_FRAMES) - count = GSPCA_MAX_FRAMES; frsz = PAGE_ALIGN(frsz); PDEBUG(D_STREAM, "new fr_sz: %d", frsz); gspca_dev->frsz = frsz; + if (count > GSPCA_MAX_FRAMES) + count = GSPCA_MAX_FRAMES; if (gspca_dev->memory == V4L2_MEMORY_MMAP) { gspca_dev->frbuf = rvmalloc(frsz * count); if (!gspca_dev->frbuf) { @@ -711,7 +656,7 @@ static void gspca_set_default_mode(struct gspca_dev *gspca_dev) gspca_dev->curr_mode = i; gspca_dev->width = gspca_dev->cam.cam_mode[i].width; gspca_dev->height = gspca_dev->cam.cam_mode[i].height; - gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixfmt; + gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixelformat; } static int wxh_to_mode(struct gspca_dev *gspca_dev, @@ -739,11 +684,13 @@ static int gspca_get_mode(struct gspca_dev *gspca_dev, modeU = modeD = mode; while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) { if (--modeD >= 0) { - if (gspca_dev->cam.cam_mode[modeD].pixfmt == pixfmt) + if (gspca_dev->cam.cam_mode[modeD].pixelformat + == pixfmt) return modeD; } if (++modeU < gspca_dev->cam.nmodes) { - if (gspca_dev->cam.cam_mode[modeU].pixfmt == pixfmt) + if (gspca_dev->cam.cam_mode[modeU].pixelformat + == pixfmt) return modeU; } } @@ -761,7 +708,7 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, index = 0; j = 0; for (i = gspca_dev->cam.nmodes; --i >= 0; ) { - fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixfmt; + fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat; j = 0; for (;;) { if (fmt_tb[j] == fmt_tb[index]) @@ -795,20 +742,13 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *fmt) { struct gspca_dev *gspca_dev = priv; + int mode; if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) return -EINVAL; - fmt->fmt.pix.width = gspca_dev->width; - fmt->fmt.pix.height = gspca_dev->height; - fmt->fmt.pix.pixelformat = gspca_dev->pixfmt; - fmt->fmt.pix.field = V4L2_FIELD_NONE; - fmt->fmt.pix.bytesperline = get_v4l2_depth(fmt->fmt.pix.pixelformat) - * fmt->fmt.pix.width / 8; - fmt->fmt.pix.sizeimage = gspca_get_buff_size(gspca_dev, - gspca_dev->curr_mode); -/* (should be in the subdriver) */ - fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB; - fmt->fmt.pix.priv = 0; + mode = gspca_dev->curr_mode; + memcpy(&fmt->fmt.pix, &gspca_dev->cam.cam_mode[mode], + sizeof fmt->fmt.pix); return 0; } @@ -833,34 +773,19 @@ static int try_fmt_vid_cap(struct gspca_dev *gspca_dev, mode = wxh_to_mode(gspca_dev, w, h); /* OK if right palette */ - if (gspca_dev->cam.cam_mode[mode].pixfmt != fmt->fmt.pix.pixelformat) { + if (gspca_dev->cam.cam_mode[mode].pixelformat + != fmt->fmt.pix.pixelformat) { /* else, search the closest mode with the same pixel format */ mode2 = gspca_get_mode(gspca_dev, mode, fmt->fmt.pix.pixelformat); - if (mode2 >= 0) { + if (mode2 >= 0) mode = mode2; - } else { - - /* no chance, return this mode */ - fmt->fmt.pix.pixelformat = - gspca_dev->cam.cam_mode[mode].pixfmt; -#ifdef CONFIG_VIDEO_ADV_DEBUG - if (gspca_debug & D_CONF) { - PDEBUG_MODE("new format", - fmt->fmt.pix.pixelformat, - gspca_dev->cam.cam_mode[mode].width, - gspca_dev->cam.cam_mode[mode].height); - } -#endif - } +/* else + ; * no chance, return this mode */ } - fmt->fmt.pix.width = gspca_dev->cam.cam_mode[mode].width; - fmt->fmt.pix.height = gspca_dev->cam.cam_mode[mode].height; - fmt->fmt.pix.field = V4L2_FIELD_NONE; - fmt->fmt.pix.bytesperline = get_v4l2_depth(fmt->fmt.pix.pixelformat) - * fmt->fmt.pix.width / 8; - fmt->fmt.pix.sizeimage = gspca_get_buff_size(gspca_dev, mode); + memcpy(&fmt->fmt.pix, &gspca_dev->cam.cam_mode[mode], + sizeof fmt->fmt.pix); return mode; /* used when s_fmt */ } @@ -883,16 +808,6 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct gspca_dev *gspca_dev = priv; int ret; -#ifdef CONFIG_VIDEO_V4L1_COMPAT - /* if v4l1 got JPEG */ - if (fmt->fmt.pix.pixelformat == 0 - && gspca_dev->streaming) { - fmt->fmt.pix.width = gspca_dev->width; - fmt->fmt.pix.height = gspca_dev->height; - fmt->fmt.pix.pixelformat = gspca_dev->pixfmt; - return 0; - } -#endif if (mutex_lock_interruptible(&gspca_dev->queue_lock)) return -ERESTARTSYS; @@ -1994,6 +1909,3 @@ MODULE_PARM_DESC(debug, " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout" " 0x0100: v4l2"); #endif -module_param(comp_fac, int, 0644); -MODULE_PARM_DESC(comp_fac, - "Buffer size ratio when compressed in percent"); diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h index 05e8ee06071..945f1ab4c9e 100644 --- a/drivers/media/video/gspca/gspca.h +++ b/drivers/media/video/gspca/gspca.h @@ -52,15 +52,9 @@ extern int gspca_debug; #define ISO_MAX_SIZE 0x8000 /* max size of one URB buffer (32 Kb) */ /* device information - set at probe time */ -struct cam_mode { - __u32 pixfmt; - short width; - short height; - short mode; /* subdriver value */ -}; struct cam { char *dev_name; - struct cam_mode *cam_mode; /* size nmodes */ + struct v4l2_pix_format *cam_mode; /* size nmodes */ char nmodes; __u8 epaddr; }; @@ -80,7 +74,6 @@ typedef void (*cam_pkt_op) (struct gspca_dev *gspca_dev, struct gspca_frame *frame, __u8 *data, int len); -typedef int (*cam_get_buff_size_op) (struct gspca_dev *gspca_dev, int mode); struct ctrl { struct v4l2_queryctrl qctrl; @@ -102,12 +95,12 @@ struct sd_desc { cam_v_op stopN; /* called on stream off - main alt */ cam_v_op stop0; /* called on stream off - alt 0 */ cam_v_op close; /* called on close */ - cam_v_op dq_callback; /* called when a frame has been dequeued */ cam_pkt_op pkt_scan; +/* optional operations */ + cam_v_op dq_callback; /* called when a frame has been dequeued */ cam_jpg_op get_jcomp; cam_jpg_op set_jcomp; cam_qmnu_op querymenu; - cam_get_buff_size_op get_buff_size; /* optional */ }; /* packet types when moving from iso buf to frame buf */ diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c index c70ccc8fe68..23f3dba8012 100644 --- a/drivers/media/video/gspca/mars.c +++ b/drivers/media/video/gspca/mars.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver"); @@ -42,9 +42,17 @@ struct sd { static struct ctrl sd_ctrls[] = { }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 2}, - {V4L2_PIX_FMT_JPEG, 640, 480, 1}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 589, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, }; /* MI Register table //elvis */ diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c index d92729ac41f..70b4cac37a5 100644 --- a/drivers/media/video/gspca/ov519.c +++ b/drivers/media/video/gspca/ov519.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("OV519 USB Camera Driver"); @@ -126,13 +126,29 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240}, - {V4L2_PIX_FMT_JPEG, 640, 480}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 589, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_JPEG, 176, 144}, - {V4L2_PIX_FMT_JPEG, 352, 288}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 589, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 589, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; /* OV519 Camera interface register numbers */ diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c index ab83d7b6934..b580af92d23 100644 --- a/drivers/media/video/gspca/pac207.c +++ b/drivers/media/video/gspca/pac207.c @@ -27,8 +27,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Hans de Goede "); MODULE_DESCRIPTION("Pixart PAC207"); @@ -157,9 +157,18 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_PAC207, 176, 144, 1}, - {V4L2_PIX_FMT_PAC207, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = (176 + 2) * 144, + /* uncompressed, add 2 bytes / line for line header */ + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 / 2, /* compressed */ + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; static const __u8 pac207_sensor_init[][8] = { @@ -346,19 +355,6 @@ static void sd_close(struct gspca_dev *gspca_dev) { } -static int sd_get_buff_size_op(struct gspca_dev *gspca_dev, int mode) -{ - switch (gspca_dev->cam.cam_mode[mode].width) { - case 176: /* 176x144 */ - /* uncompressed, add 2 bytes / line for line header */ - return (176 + 2) * 144; - case 352: /* 352x288 */ - /* compressed */ - return 352 * 288 / 2; - } - return -EIO; /* should never happen */ -} - /* auto gain and exposure algorithm based on the knee algorithm described here: * */ static void pac207_do_auto_gain(struct gspca_dev *gspca_dev) @@ -632,7 +628,6 @@ static const struct sd_desc sd_desc = { .close = sd_close, .dq_callback = pac207_do_auto_gain, .pkt_scan = sd_pkt_scan, - .get_buff_size = sd_get_buff_size_op, }; /* -- module initialisation -- */ diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c index c2d4b6a4dcf..1a2347aa715 100644 --- a/drivers/media/video/gspca/pac7311.c +++ b/drivers/media/video/gspca/pac7311.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li"); MODULE_DESCRIPTION("Pixart PAC7311"); @@ -116,10 +116,22 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 160, 120, 2}, - {V4L2_PIX_FMT_JPEG, 320, 240, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; #define PAC7311_JPEG_HEADER_SIZE (sizeof pac7311_jpeg_header) /* (594) */ @@ -393,7 +405,7 @@ static void sd_start(struct gspca_dev *gspca_dev) setcolors(gspca_dev); /* set correct resolution */ - switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 2: /* 160x120 */ pac7311_reg_write(dev, 0xff, 0x04); pac7311_reg_write(dev, 0x02, 0x03); diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c index 4baac51bf40..57456873631 100644 --- a/drivers/media/video/gspca/sonixb.c +++ b/drivers/media/video/gspca/sonixb.c @@ -24,8 +24,8 @@ #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, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver"); @@ -95,15 +95,34 @@ static struct ctrl sd_ctrls[] = { }, }; -/* fixme: should have V4L2_PIX_FMT_SN9C10X */ -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_SN9C10X, 160, 120, 2}, - {V4L2_PIX_FMT_SN9C10X, 320, 240, 1}, - {V4L2_PIX_FMT_SN9C10X, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_SN9C10X, 176, 144, 1}, - {V4L2_PIX_FMT_SN9C10X, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; static const __u8 probe_ov7630[] = {0x08, 0x44}; @@ -592,7 +611,7 @@ static void sd_start(struct gspca_dev *gspca_dev) __u8 reg01, reg17; __u8 reg17_19[3]; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; switch (sd->sensor) { case SENSOR_HV7131R: sn9c10x = initHv7131; diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index eb5e1bfd791..3db6487a705 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver"); @@ -132,10 +132,22 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 160, 120, 2}, - {V4L2_PIX_FMT_JPEG, 320, 240, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; /*Data from sn9c102p+hv71331r */ @@ -1232,7 +1244,7 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(dev, 0x99, &data, 1); } - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; reg1 = 0x02; reg17 = 0x61; switch (sd->sensor) { diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c index 3a42506830f..d00f0f76e0e 100644 --- a/drivers/media/video/gspca/spca500.c +++ b/drivers/media/video/gspca/spca500.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver"); @@ -114,14 +114,30 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_JPEG, 176, 144, 1}, - {V4L2_PIX_FMT_JPEG, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; /* Frame packet header offsets for the spca500 */ @@ -515,7 +531,7 @@ static void spca500_setmode(struct gspca_dev *gspca_dev, 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; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; reg_w(gspca_dev->dev, 0, 0x8003, mode << 4); } diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c index 417fbe2214b..2064dc008af 100644 --- a/drivers/media/video/gspca/spca501.c +++ b/drivers/media/video/gspca/spca501.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA501 USB Camera Driver"); @@ -101,10 +101,22 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_SPCA501, 160, 120, 2}, - {V4L2_PIX_FMT_SPCA501, 320, 240, 1}, - {V4L2_PIX_FMT_SPCA501, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_SPCA501, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120 * 3 / 8, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_SPCA501, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_SPCA501, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; #define SPCA50X_REG_USB 0x2 /* spca505 501 */ @@ -2029,7 +2041,7 @@ static void sd_start(struct gspca_dev *gspca_dev) int mode; /* memorize the wanted pixel format */ - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; /* Enable ISO packet machine CTRL reg=2, * index=1 bitmask=0x2 (bit ordinal 1) */ diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c index 30d174fc4b9..5d28d23b837 100644 --- a/drivers/media/video/gspca/spca505.c +++ b/drivers/media/video/gspca/spca505.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver"); @@ -66,12 +66,32 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_YUYV, 160, 120, 5}, - {V4L2_PIX_FMT_YUYV, 176, 144, 4}, - {V4L2_PIX_FMT_YUYV, 320, 240, 2}, - {V4L2_PIX_FMT_YUYV, 352, 288, 1}, - {V4L2_PIX_FMT_YUYV, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 160 * 2, + .sizeimage = 160 * 120 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 5}, + {176, 144, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 176 * 2, + .sizeimage = 176 * 144 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 4}, + {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 320 * 2, + .sizeimage = 320 * 240 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {352, 288, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 352 * 2, + .sizeimage = 352 * 288 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 640 * 2, + .sizeimage = 640 * 480 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; #define SPCA50X_OFFSET_DATA 10 @@ -708,7 +728,7 @@ static void sd_start(struct gspca_dev *gspca_dev) * only once after loading module */ /* stopping usb registers Tomasz change */ reg_write(dev, 0x02, 0x0, 0x0); - switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: reg_write(dev, 0x04, 0x00, 0x00); reg_write(dev, 0x04, 0x06, 0x10); diff --git a/drivers/media/video/gspca/spca506.c b/drivers/media/video/gspca/spca506.c index 614fb3ad771..2d249b00bdc 100644 --- a/drivers/media/video/gspca/spca506.c +++ b/drivers/media/video/gspca/spca506.c @@ -25,8 +25,8 @@ #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, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA506 USB Camera Driver"); @@ -34,11 +34,11 @@ MODULE_LICENSE("GPL"); /* specific webcam descriptor */ struct sd { - struct gspca_dev gspca_dev; /* !! must be the first item */ + struct gspca_dev gspca_dev; /* !! must be the first item */ int buflen; - unsigned char tmpbuf[640 * 480 * 3]; /* YYUV per line */ - unsigned char tmpbuf2[640 * 480 * 2]; /* YUYV */ + __u8 tmpbuf[640 * 480 * 3]; /* YYUV per line */ + __u8 tmpbuf2[640 * 480 * 2]; /* YUYV */ unsigned char brightness; unsigned char contrast; @@ -117,12 +117,32 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_YUYV, 160, 120, 5}, - {V4L2_PIX_FMT_YUYV, 176, 144, 4}, - {V4L2_PIX_FMT_YUYV, 320, 240, 2}, - {V4L2_PIX_FMT_YUYV, 352, 288, 1}, - {V4L2_PIX_FMT_YUYV, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {160, 120, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 160 * 2, + .sizeimage = 160 * 120 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 5}, + {176, 144, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 176 * 2, + .sizeimage = 176 * 144 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 4}, + {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 320 * 2, + .sizeimage = 320 * 240 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {352, 288, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 352 * 2, + .sizeimage = 352 * 288 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 640 * 2, + .sizeimage = 640 * 480 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; #define SPCA50X_OFFSET_DATA 10 @@ -169,7 +189,7 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg) { int retry = 60; - unsigned char Data[2]; + __u8 Data[2]; reg_w(gspca_dev->dev, 0x07, reg, 0x0001); reg_w(gspca_dev->dev, 0x07, valeur, 0x0000); @@ -183,8 +203,8 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur, static int spca506_ReadI2c(struct gspca_dev *gspca_dev, __u16 reg) { int retry = 60; - unsigned char Data[2]; - unsigned char value; + __u8 Data[2]; + __u8 value; reg_w(gspca_dev->dev, 0x07, SAA7113_I2C_BASE_WRITE, 0x0004); reg_w(gspca_dev->dev, 0x07, reg, 0x0001); @@ -513,7 +533,7 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(dev, 0x05, 0x00, 0x0004); reg_w(dev, 0x03, 0x10, 0x0001); reg_w(dev, 0x03, 0x78, 0x0000); - switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: spca506_Setsize(gspca_dev, 0, 0x10, 0x10); break; @@ -593,7 +613,7 @@ static void yyuv_decode(unsigned char *out, 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; diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c index 3b54f41d21c..169238d40c9 100644 --- a/drivers/media/video/gspca/spca508.c +++ b/drivers/media/video/gspca/spca508.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA508 USB Camera Driver"); @@ -69,11 +69,27 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_YUYV, 160, 120, 3}, - {V4L2_PIX_FMT_YUYV, 176, 144, 2}, - {V4L2_PIX_FMT_YUYV, 320, 240, 1}, - {V4L2_PIX_FMT_YUYV, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {160, 120, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 160 * 2, + .sizeimage = 160 * 120 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 3}, + {176, 144, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 176 * 2, + .sizeimage = 176 * 144 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 320 * 2, + .sizeimage = 320 * 240 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 352 * 2, + .sizeimage = 352 * 288 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; /* Frame packet header offsets for the spca508 */ @@ -1574,7 +1590,7 @@ static void sd_start(struct gspca_dev *gspca_dev) { int mode; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; reg_write(gspca_dev->dev, 0x8500, mode); switch (mode) { case 0: diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c index 8e39cbdda2a..f0770ee595d 100644 --- a/drivers/media/video/gspca/spca561.c +++ b/drivers/media/video/gspca/spca561.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver"); @@ -97,11 +97,27 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_SGBRG8, 160, 120, 3}, - {V4L2_PIX_FMT_SGBRG8, 176, 144, 2}, - {V4L2_PIX_FMT_SPCA561, 320, 240, 1}, - {V4L2_PIX_FMT_SPCA561, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 3}, + {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 2}, + {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 4 / 8, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 4 / 8, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; /* @@ -655,7 +671,7 @@ static void sd_start(struct gspca_dev *gspca_dev) __u8 Reg8307[] = { 0xaa, 0x00 }; int mode; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; switch (sd->chip_revision) { case Rev072A: switch (mode) { diff --git a/drivers/media/video/gspca/stk014.c b/drivers/media/video/gspca/stk014.c index ad59c5ab5d9..d676cd16aa7 100644 --- a/drivers/media/video/gspca/stk014.c +++ b/drivers/media/video/gspca/stk014.c @@ -23,8 +23,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver"); @@ -112,9 +112,17 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240}, - {V4L2_PIX_FMT_JPEG, 640, 480}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; /* -- read a register -- */ diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c index f2d03350858..f66594a113a 100644 --- a/drivers/media/video/gspca/sunplus.c +++ b/drivers/media/video/gspca/sunplus.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver"); @@ -126,21 +126,53 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 2}, - {V4L2_PIX_FMT_JPEG, 640, 480, 1}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, }; -static struct cam_mode custom_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 2}, - {V4L2_PIX_FMT_JPEG, 464, 480, 1}, +static struct v4l2_pix_format custom_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 464, + .sizeimage = 464 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, }; -static struct cam_mode vga_mode2[] = { - {V4L2_PIX_FMT_JPEG, 176, 144, 4}, - {V4L2_PIX_FMT_JPEG, 320, 240, 3}, - {V4L2_PIX_FMT_JPEG, 352, 288, 2}, - {V4L2_PIX_FMT_JPEG, 640, 480, 1}, +static struct v4l2_pix_format vga_mode2[] = { + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 4}, + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 3}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, }; #define SPCA50X_OFFSET_DATA 10 @@ -655,7 +687,7 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev) __u8 Type; int rc; - Size = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + Size = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; Type = 0; switch (sd->bridge) { case BRIDGE_SPCA533: diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c index 96f01d26747..299f84584e8 100644 --- a/drivers/media/video/gspca/t613.c +++ b/drivers/media/video/gspca/t613.c @@ -26,8 +26,8 @@ #define MODULE_NAME "t613" #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; #define MAX_GAMMA 0x10 /* 0 to 15 */ @@ -232,12 +232,32 @@ static char *effects_control[] = { "Negative", }; -static struct cam_mode vga_mode_t16[] = { - {V4L2_PIX_FMT_JPEG, 160, 120, 4}, - {V4L2_PIX_FMT_JPEG, 176, 144, 3}, - {V4L2_PIX_FMT_JPEG, 320, 240, 2}, - {V4L2_PIX_FMT_JPEG, 352, 288, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode_t16[] = { + {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 160, + .sizeimage = 160 * 120 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 4}, + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 3}, + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 2}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; #define T16_OFFSET_DATA 631 @@ -848,7 +868,7 @@ static void sd_start(struct gspca_dev *gspca_dev) 0xb8, 0x00, 0xb9, 0xe7, 0xba, 0x01 }; static const __u8 t4[] = { 0x0b, 0x04, 0x0a, 0x40 }; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. priv; switch (mode) { case 1: /* 352x288 */ t2[1] = 0x40; diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c index 8561234d65e..f9bffd67991 100644 --- a/drivers/media/video/gspca/tv8532.c +++ b/drivers/media/video/gspca/tv8532.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("TV8532 USB Camera Driver"); @@ -81,9 +81,17 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_SBGGR8, 176, 144, 1}, - {V4L2_PIX_FMT_SBGGR8, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; /* @@ -440,7 +448,7 @@ static void sd_start(struct gspca_dev *gspca_dev) /************************************************/ data = TESTCOMP; /* 0x72 compressed mode */ reg_w(dev, TV8532_QUANT_COMP, &data, 1); /* 0x28 */ - if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) { + if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { /* 176x144 */ data = QCIFLINE; /* 0x84; // CIF | 4 packet */ reg_w(dev, TV8532_MODE_PACKET, &data, 1); /* 0x29 */ diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c index 4144e11c60b..afbbbd29056 100644 --- a/drivers/media/video/gspca/vc032x.c +++ b/drivers/media/video/gspca/vc032x.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/VC032X USB Camera Driver"); @@ -88,13 +88,29 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vc0321_mode[] = { - {V4L2_PIX_FMT_YUYV, 320, 240, 1}, - {V4L2_PIX_FMT_YUYV, 640, 480, 0}, +static struct v4l2_pix_format vc0321_mode[] = { + {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 320 * 2, + .sizeimage = 320 * 240 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE, + .bytesperline = 640 * 2, + .sizeimage = 640 * 480 * 2, + .colorspace = V4L2_COLORSPACE_SRGB, + .priv = 0}, }; -static struct cam_mode vc0323_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vc0323_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; static const __u8 mi1310_socinitVGA_JPG[][4] = { @@ -1535,7 +1551,7 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(gspca_dev->dev, 0xa0, 0xff, 0xbfef); } - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; switch (sd->sensor) { case SENSOR_HV7131R: GammaT = hv7131r_gamma; diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c index 63dd8916d6b..eed9a8baf4e 100644 --- a/drivers/media/video/gspca/zc3xx.c +++ b/drivers/media/video/gspca/zc3xx.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 4) -static const char version[] = "2.1.4"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) +static const char version[] = "2.1.5"; MODULE_AUTHOR("Michel Xhaard , " "Serge A. Suchkov "); @@ -173,14 +173,30 @@ static struct ctrl sd_ctrls[] = { }, }; -static struct cam_mode vga_mode[] = { - {V4L2_PIX_FMT_JPEG, 320, 240, 1}, - {V4L2_PIX_FMT_JPEG, 640, 480, 0}, +static struct v4l2_pix_format vga_mode[] = { + {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 320, + .sizeimage = 320 * 240 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 640, + .sizeimage = 640 * 480 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; -static struct cam_mode sif_mode[] = { - {V4L2_PIX_FMT_JPEG, 176, 144, 1}, - {V4L2_PIX_FMT_JPEG, 352, 288, 0}, +static struct v4l2_pix_format sif_mode[] = { + {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 176, + .sizeimage = 176 * 144 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 1}, + {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, + .bytesperline = 352, + .sizeimage = 352 * 288 * 3 / 8 + 590, + .colorspace = V4L2_COLORSPACE_JPEG, + .priv = 0}, }; /* usb exchanges */ @@ -6602,7 +6618,7 @@ static int setlightfreq(struct gspca_dev *gspca_dev) }; i = sd->lightfreq * 2; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; if (!mode) i++; /* 640x480 */ zc3_freq = freq_tb[(int) sd->sensor][i]; @@ -7170,7 +7186,7 @@ static void sd_start(struct gspca_dev *gspca_dev) /* 16 */ }; - mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode; + mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; zc3_init = init_tb[(int) sd->sensor][mode]; switch (sd->sensor) { case SENSOR_HV7131B: -- cgit v1.2.3-70-g09d2 From c41492c89a00630c7482eae25deaf9af91b73c98 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Mon, 7 Jul 2008 08:31:16 -0300 Subject: V4L/DVB (8231): gspca: Do not declare the webcams declared by other drivers. etoms: Do not declare the webcams declared by the driver et61x251. sonixb, sonixj: Do not declare the webcams declared by the driver sn9c102. zc3xx: Do not declare the webcams declared by the driver zc0301. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/etoms.c | 2 ++ drivers/media/video/gspca/sonixb.c | 2 ++ drivers/media/video/gspca/sonixj.c | 4 ++++ drivers/media/video/gspca/vc032x.c | 16 ++++++++-------- drivers/media/video/gspca/zc3xx.c | 23 +++++++++++++++++------ 5 files changed, 33 insertions(+), 14 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index 4db33618af6..1da6a182561 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -912,7 +912,9 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name static __devinitdata struct usb_device_id device_table[] = { +#ifndef CONFIG_USB_ET61X251 {USB_DEVICE(0x102c, 0x6151), DVNM("Qcam Sangha CIF")}, +#endif {USB_DEVICE(0x102c, 0x6251), DVNM("Qcam xxxxxx VGA")}, {} }; diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c index 3dbeadf23e1..95a6a8e98b9 100644 --- a/drivers/media/video/gspca/sonixb.c +++ b/drivers/media/video/gspca/sonixb.c @@ -858,6 +858,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name static __devinitdata struct usb_device_id device_table[] = { +#ifndef CONFIG_USB_SN9C102 {USB_DEVICE(0x0c45, 0x6001), DVNM("Genius VideoCAM NB")}, {USB_DEVICE(0x0c45, 0x6005), DVNM("Sweex Tas5110")}, {USB_DEVICE(0x0c45, 0x6007), DVNM("Sonix sn9c101 + Tas5110D")}, @@ -874,6 +875,7 @@ static __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x0c45, 0x602e), DVNM("Genius VideoCam Messenger")}, {USB_DEVICE(0x0c45, 0x60af), DVNM("Trust WB3100P")}, {USB_DEVICE(0x0c45, 0x60b0), DVNM("Genius VideoCam Look")}, +#endif {} }; MODULE_DEVICE_TABLE(usb, device_table); diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index 3db6487a705..4cb1421b880 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -1606,11 +1606,13 @@ static const struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name static const __devinitdata struct usb_device_id device_table[] = { +#ifndef CONFIG_USB_SN9C102 {USB_DEVICE(0x0458, 0x7025), DVNM("Genius Eye 311Q")}, {USB_DEVICE(0x045e, 0x00f5), DVNM("MicroSoft VX3000")}, {USB_DEVICE(0x045e, 0x00f7), DVNM("MicroSoft VX1000")}, {USB_DEVICE(0x0471, 0x0327), DVNM("Philips SPC 600 NC")}, {USB_DEVICE(0x0471, 0x0328), DVNM("Philips SPC 700 NC")}, +#endif {USB_DEVICE(0x0471, 0x0330), DVNM("Philips SPC 710NC")}, {USB_DEVICE(0x0c45, 0x6040), DVNM("Speed NVC 350K")}, {USB_DEVICE(0x0c45, 0x607c), DVNM("Sonix sn9c102p Hv7131R")}, @@ -1620,10 +1622,12 @@ static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x0c45, 0x60fc), DVNM("LG-LIC300")}, {USB_DEVICE(0x0c45, 0x612a), DVNM("Avant Camera")}, {USB_DEVICE(0x0c45, 0x612c), DVNM("Typhoon Rasy Cam 1.3MPix")}, +#ifndef CONFIG_USB_SN9C102 {USB_DEVICE(0x0c45, 0x6130), DVNM("Sonix Pccam")}, {USB_DEVICE(0x0c45, 0x6138), DVNM("Sn9c120 Mo4000")}, {USB_DEVICE(0x0c45, 0x613b), DVNM("Surfer SN-206")}, {USB_DEVICE(0x0c45, 0x613c), DVNM("Sonix Pccam168")}, +#endif {} }; MODULE_DEVICE_TABLE(usb, device_table); diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c index afbbbd29056..7ca6240c64e 100644 --- a/drivers/media/video/gspca/vc032x.c +++ b/drivers/media/video/gspca/vc032x.c @@ -1332,20 +1332,20 @@ static __u8 i2c_write(struct usb_device *dev, if (size > 3 || size < 1) return -EINVAL; reg_r(dev, 0xa1, 0xb33f, &retbyte, 1); - reg_w(dev, 0xa0, size , 0xb334); - reg_w(dev, 0xa0, reg , 0xb33a); + reg_w(dev, 0xa0, size, 0xb334); + reg_w(dev, 0xa0, reg, 0xb33a); switch (size) { case 1: - reg_w(dev, 0xa0, val[0] , 0xb336); + reg_w(dev, 0xa0, val[0], 0xb336); break; case 2: - reg_w(dev, 0xa0, val[0] , 0xb336); - reg_w(dev, 0xa0, val[1] , 0xb337); + reg_w(dev, 0xa0, val[0], 0xb336); + reg_w(dev, 0xa0, val[1], 0xb337); break; case 3: - reg_w(dev, 0xa0, val[0] , 0xb336); - reg_w(dev, 0xa0, val[1] , 0xb337); - reg_w(dev, 0xa0, val[2] , 0xb338); + reg_w(dev, 0xa0, val[0], 0xb336); + reg_w(dev, 0xa0, val[1], 0xb337); + reg_w(dev, 0xa0, val[2], 0xb338); break; default: reg_w(dev, 0xa0, 0x01, 0xb334); diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c index eed9a8baf4e..bac45a19365 100644 --- a/drivers/media/video/gspca/zc3xx.c +++ b/drivers/media/video/gspca/zc3xx.c @@ -7132,10 +7132,10 @@ static int sd_config(struct gspca_dev *gspca_dev, gspca_dev->nbalt--; if (vga) { cam->cam_mode = vga_mode; - cam->nmodes = sizeof vga_mode / sizeof vga_mode[0]; + cam->nmodes = ARRAY_SIZE(vga_mode); } else { cam->cam_mode = sif_mode; - cam->nmodes = sizeof sif_mode / sizeof sif_mode[0]; + cam->nmodes = ARRAY_SIZE(sif_mode); } sd->qindex = 1; sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value; @@ -7498,21 +7498,26 @@ static const struct sd_desc sd_desc = { #define DVNM(name) .driver_info = (kernel_ulong_t) name static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x041e, 0x041e), DVNM("Creative WebCam Live!")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x041e, 0x4017), DVNM("Creative Webcam Mobile PD1090")}, {USB_DEVICE(0x041e, 0x401c), DVNM("Creative NX")}, {USB_DEVICE(0x041e, 0x401e), DVNM("Creative Nx Pro")}, {USB_DEVICE(0x041e, 0x401f), DVNM("Creative Webcam Notebook PD1171")}, -/*0x041e, 0x4022*/ +#endif {USB_DEVICE(0x041e, 0x4029), DVNM("Creative WebCam Vista Pro")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x041e, 0x4034), DVNM("Creative Instant P0620")}, {USB_DEVICE(0x041e, 0x4035), DVNM("Creative Instant P0620D")}, {USB_DEVICE(0x041e, 0x4036), DVNM("Creative Live !")}, {USB_DEVICE(0x041e, 0x403a), DVNM("Creative Nx Pro 2")}, +#endif {USB_DEVICE(0x041e, 0x4051), DVNM("Creative Notebook Pro (VF0250)")}, {USB_DEVICE(0x041e, 0x4053), DVNM("Creative Live!Cam Video IM")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x0458, 0x7007), DVNM("Genius VideoCam V2")}, {USB_DEVICE(0x0458, 0x700c), DVNM("Genius VideoCam V3")}, {USB_DEVICE(0x0458, 0x700f), DVNM("Genius VideoCam Web V2")}, +#endif {USB_DEVICE(0x0461, 0x0a00), DVNM("MicroInnovation WebCam320")}, {USB_DEVICE(0x046d, 0x08a0), DVNM("Logitech QC IM")}, {USB_DEVICE(0x046d, 0x08a1), DVNM("Logitech QC IM 0x08A1 +sound")}, @@ -7521,10 +7526,12 @@ static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x046d, 0x08a6), DVNM("Logitech QCim")}, {USB_DEVICE(0x046d, 0x08a7), DVNM("Logitech QuickCam Image")}, {USB_DEVICE(0x046d, 0x08a9), DVNM("Logitech Notebook Deluxe")}, - {USB_DEVICE(0x046d, 0x08aa), DVNM("Labtec Webcam Notebook")}, + {USB_DEVICE(0x046d, 0x08aa), DVNM("Labtec Webcam Notebook")}, {USB_DEVICE(0x046d, 0x08ac), DVNM("Logitech QuickCam Cool")}, {USB_DEVICE(0x046d, 0x08ad), DVNM("Logitech QCCommunicate STX")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x046d, 0x08ae), DVNM("Logitech QuickCam for Notebooks")}, +#endif {USB_DEVICE(0x046d, 0x08af), DVNM("Logitech QuickCam Cool")}, {USB_DEVICE(0x046d, 0x08b9), DVNM("Logitech QC IM ???")}, {USB_DEVICE(0x046d, 0x08d7), DVNM("Logitech QCam STX")}, @@ -7537,18 +7544,22 @@ static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x0471, 0x032d), DVNM("Philips spc210nc")}, {USB_DEVICE(0x0471, 0x032e), DVNM("Philips spc315nc")}, {USB_DEVICE(0x055f, 0xc005), DVNM("Mustek Wcam300A")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x055f, 0xd003), DVNM("Mustek WCam300A")}, {USB_DEVICE(0x055f, 0xd004), DVNM("Mustek WCam300 AN")}, +#endif {USB_DEVICE(0x0698, 0x2003), DVNM("CTX M730V built in")}, -/*0x0ac8, 0x0301*/ {USB_DEVICE(0x0ac8, 0x0302), DVNM("Z-star Vimicro zc0302")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x0ac8, 0x301b), DVNM("Z-Star zc301b")}, {USB_DEVICE(0x0ac8, 0x303b), DVNM("Vimicro 0x303b")}, +#endif {USB_DEVICE(0x0ac8, 0x305b), DVNM("Z-star Vimicro zc0305b")}, +#ifndef CONFIG_USB_ZC0301 {USB_DEVICE(0x0ac8, 0x307b), DVNM("Z-Star 307b")}, {USB_DEVICE(0x10fd, 0x0128), DVNM("Typhoon Webshot II 300k 0x0128")}, -/*0x10fd, 0x804e*/ {USB_DEVICE(0x10fd, 0x8050), DVNM("Typhoon Webshot II USB 300k")}, +#endif {} /* end of entry */ }; #undef DVNAME -- cgit v1.2.3-70-g09d2 From 739570bb218bb4607df1f197282561e97a98e54a Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Mon, 14 Jul 2008 09:38:29 -0300 Subject: V4L/DVB (8352): gspca: Buffers for USB exchanges cannot be in the stack. gspca: Protect dq_callback() against simultaneous USB exchanges. Temporary buffer for USB exchanges added in the device struct. (all) Use a temporary buffer for all USB exchanges. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/conex.c | 385 ++++++++++++++----------------- drivers/media/video/gspca/etoms.c | 443 ++++++++++++++++++------------------ drivers/media/video/gspca/gspca.c | 6 +- drivers/media/video/gspca/gspca.h | 1 + drivers/media/video/gspca/mars.c | 158 +++++++------ drivers/media/video/gspca/ov519.c | 19 +- drivers/media/video/gspca/pac207.c | 19 +- drivers/media/video/gspca/pac7311.c | 336 +++++++++++++-------------- drivers/media/video/gspca/sonixb.c | 155 +++++++------ drivers/media/video/gspca/sonixj.c | 293 ++++++++++++------------ drivers/media/video/gspca/spca500.c | 265 +++++++++++---------- drivers/media/video/gspca/spca501.c | 23 +- drivers/media/video/gspca/spca505.c | 24 +- drivers/media/video/gspca/spca506.c | 35 ++- drivers/media/video/gspca/spca508.c | 37 ++- drivers/media/video/gspca/spca561.c | 115 +++++----- drivers/media/video/gspca/stk014.c | 86 ++++--- drivers/media/video/gspca/sunplus.c | 279 +++++++++++------------ drivers/media/video/gspca/t613.c | 176 +++++++------- drivers/media/video/gspca/tv8532.c | 360 +++++++++++++---------------- drivers/media/video/gspca/vc032x.c | 81 ++++--- drivers/media/video/gspca/zc3xx.c | 199 ++++++++-------- 22 files changed, 1700 insertions(+), 1795 deletions(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c index b5481017dd4..013d593b0c6 100644 --- a/drivers/media/video/gspca/conex.c +++ b/drivers/media/video/gspca/conex.c @@ -25,8 +25,8 @@ #define CONEX_CAM 1 /* special JPEG header */ #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA USB Conexant Camera Driver"); @@ -119,40 +119,67 @@ static struct v4l2_pix_format vga_mode[] = { .priv = 0}, }; -static void reg_r(struct usb_device *dev, - __u16 index, - __u8 *buffer, __u16 length) +/* the read bytes are found in gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 index, + __u16 len) { + struct usb_device *dev = gspca_dev->dev; + +#ifdef CONFIG_VIDEO_ADV_DEBUG + if (len > sizeof gspca_dev->usb_buf) { + err("reg_r: buffer overflow"); + return; + } +#endif usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, - index, buffer, length, + index, gspca_dev->usb_buf, len, 500); - PDEBUG(D_USBI, "reg read [%02x] -> %02x ..", index, *buffer); + PDEBUG(D_USBI, "reg read [%02x] -> %02x ..", + index, gspca_dev->usb_buf[0]); +} + +/* the bytes to write are in gspca_dev->usb_buf */ +static void reg_w_val(struct gspca_dev *gspca_dev, + __u16 index, + __u8 val) +{ + struct usb_device *dev = gspca_dev->dev; + + gspca_dev->usb_buf[0] = val; + usb_control_msg(dev, + usb_sndctrlpipe(dev, 0), + 0, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0, + index, gspca_dev->usb_buf, 1, 500); } -static void reg_w(struct usb_device *dev, +static void reg_w(struct gspca_dev *gspca_dev, __u16 index, - const __u8 *buffer, __u16 len) + const __u8 *buffer, + __u16 len) { - __u8 tmpbuf[8]; + struct usb_device *dev = gspca_dev->dev; #ifdef CONFIG_VIDEO_ADV_DEBUG - if (len > sizeof tmpbuf) { - PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow"); + if (len > sizeof gspca_dev->usb_buf) { + err("reg_w: buffer overflow"); return; } PDEBUG(D_USBO, "reg write [%02x] = %02x..", index, *buffer); #endif - memcpy(tmpbuf, buffer, len); + memcpy(gspca_dev->usb_buf, buffer, len); usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, - index, tmpbuf, len, 500); + index, gspca_dev->usb_buf, len, 500); } static const __u8 cx_sensor_init[][4] = { @@ -232,17 +259,14 @@ static const __u8 cx11646_fw1[][3] = { }; static void cx11646_fw(struct gspca_dev*gspca_dev) { - __u8 val; int i = 0; - val = 0x02; - reg_w(gspca_dev->dev, 0x006a, &val, 1); + reg_w_val(gspca_dev, 0x006a, 0x02); while (cx11646_fw1[i][1]) { - reg_w(gspca_dev->dev, 0x006b, cx11646_fw1[i], 3); + reg_w(gspca_dev, 0x006b, cx11646_fw1[i], 3); i++; } - val = 0x00; - reg_w(gspca_dev->dev, 0x006a, &val, 1); + reg_w_val(gspca_dev, 0x006a, 0x00); } static const __u8 cxsensor[] = { @@ -273,52 +297,47 @@ static const __u8 reg7b[] = { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff }; static void cx_sensor(struct gspca_dev*gspca_dev) { - __u8 val; int i = 0; - __u8 bufread[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; int length; const __u8 *ptsensor = cxsensor; - reg_w(gspca_dev->dev, 0x0020, reg20, 8); - reg_w(gspca_dev->dev, 0x0028, reg28, 8); - reg_w(gspca_dev->dev, 0x0010, reg10, 8); - val = 0x03; - reg_w(gspca_dev->dev, 0x0092, &val, 1); + reg_w(gspca_dev, 0x0020, reg20, 8); + reg_w(gspca_dev, 0x0028, reg28, 8); + reg_w(gspca_dev, 0x0010, reg10, 8); + reg_w_val(gspca_dev, 0x0092, 0x03); switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: - reg_w(gspca_dev->dev, 0x0071, reg71a, 4); + reg_w(gspca_dev, 0x0071, reg71a, 4); break; case 1: - reg_w(gspca_dev->dev, 0x0071, reg71b, 4); + reg_w(gspca_dev, 0x0071, reg71b, 4); break; default: /* case 2: */ - reg_w(gspca_dev->dev, 0x0071, reg71c, 4); + reg_w(gspca_dev, 0x0071, reg71c, 4); break; case 3: - reg_w(gspca_dev->dev, 0x0071, reg71d, 4); + reg_w(gspca_dev, 0x0071, reg71d, 4); break; } - reg_w(gspca_dev->dev, 0x007b, reg7b, 6); - val = 0x00; - reg_w(gspca_dev->dev, 0x00f8, &val, 1); - reg_w(gspca_dev->dev, 0x0010, reg10, 8); - val = 0x41; - reg_w(gspca_dev->dev, 0x0098, &val, 1); + reg_w(gspca_dev, 0x007b, reg7b, 6); + reg_w_val(gspca_dev, 0x00f8, 0x00); + reg_w(gspca_dev, 0x0010, reg10, 8); + reg_w_val(gspca_dev, 0x0098, 0x41); for (i = 0; i < 11; i++) { if (i == 3 || i == 5 || i == 8) length = 8; else length = 4; - reg_w(gspca_dev->dev, 0x00e5, ptsensor, length); + reg_w(gspca_dev, 0x00e5, ptsensor, length); if (length == 4) - reg_r(gspca_dev->dev, 0x00e8, &val, 1); + reg_r(gspca_dev, 0x00e8, 1); else - reg_r(gspca_dev->dev, 0x00e8, bufread, length); + reg_r(gspca_dev, 0x00e8, length); ptsensor += length; } - reg_r(gspca_dev->dev, 0x00e7, bufread, 8); + reg_r(gspca_dev, 0x00e7, 8); } static const __u8 cx_inits_176[] = { @@ -358,10 +377,9 @@ static const __u8 cx_inits_640[] = { 0x77, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -static int cx11646_initsize(struct gspca_dev *gspca_dev) +static void cx11646_initsize(struct gspca_dev *gspca_dev) { const __u8 *cxinit; - __u8 val; static const __u8 reg12[] = { 0x08, 0x05, 0x07, 0x04, 0x24 }; static const __u8 reg17[] = { 0x0a, 0x00, 0xf2, 0x01, 0x0f, 0x00, 0x97, 0x02 }; @@ -381,35 +399,29 @@ static int cx11646_initsize(struct gspca_dev *gspca_dev) cxinit = cx_inits_176; break; } - val = 0x01; - reg_w(gspca_dev->dev, 0x009a, &val, 1); - val = 0x10; - reg_w(gspca_dev->dev, 0x0010, &val, 1); - reg_w(gspca_dev->dev, 0x0012, reg12, 5); - reg_w(gspca_dev->dev, 0x0017, reg17, 8); - val = 0x00; - reg_w(gspca_dev->dev, 0x00c0, &val, 1); - val = 0x04; - reg_w(gspca_dev->dev, 0x00c1, &val, 1); - val = 0x04; - reg_w(gspca_dev->dev, 0x00c2, &val, 1); - - reg_w(gspca_dev->dev, 0x0061, cxinit, 8); + reg_w_val(gspca_dev, 0x009a, 0x01); + reg_w_val(gspca_dev, 0x0010, 0x10); + reg_w(gspca_dev, 0x0012, reg12, 5); + reg_w(gspca_dev, 0x0017, reg17, 8); + reg_w_val(gspca_dev, 0x00c0, 0x00); + reg_w_val(gspca_dev, 0x00c1, 0x04); + reg_w_val(gspca_dev, 0x00c2, 0x04); + + reg_w(gspca_dev, 0x0061, cxinit, 8); cxinit += 8; - reg_w(gspca_dev->dev, 0x00ca, cxinit, 8); + reg_w(gspca_dev, 0x00ca, cxinit, 8); cxinit += 8; - reg_w(gspca_dev->dev, 0x00d2, cxinit, 8); + reg_w(gspca_dev, 0x00d2, cxinit, 8); cxinit += 8; - reg_w(gspca_dev->dev, 0x00da, cxinit, 6); + reg_w(gspca_dev, 0x00da, cxinit, 6); cxinit += 8; - reg_w(gspca_dev->dev, 0x0041, cxinit, 8); + reg_w(gspca_dev, 0x0041, cxinit, 8); cxinit += 8; - reg_w(gspca_dev->dev, 0x0049, cxinit, 8); + reg_w(gspca_dev, 0x0049, cxinit, 8); cxinit += 8; - reg_w(gspca_dev->dev, 0x0051, cxinit, 2); + reg_w(gspca_dev, 0x0051, cxinit, 2); - reg_r(gspca_dev->dev, 0x0010, &val, 1); - return val; + reg_r(gspca_dev, 0x0010, 1); } static const __u8 cx_jpeg_init[][8] = { @@ -636,26 +648,21 @@ static const __u8 cxjpeg_qtable[][8] = { static void cx11646_jpegInit(struct gspca_dev*gspca_dev) { - __u8 val; int i; int length; - val = 0x01; - reg_w(gspca_dev->dev, 0x00c0, &val, 1); - val = 0x00; - reg_w(gspca_dev->dev, 0x00c3, &val, 1); - val = 0x00; - reg_w(gspca_dev->dev, 0x00c0, &val, 1); - reg_r(gspca_dev->dev, 0x0001, &val, 1); + reg_w_val(gspca_dev, 0x00c0, 0x01); + reg_w_val(gspca_dev, 0x00c3, 0x00); + reg_w_val(gspca_dev, 0x00c0, 0x00); + reg_r(gspca_dev, 0x0001, 1); length = 8; for (i = 0; i < 79; i++) { if (i == 78) length = 6; - reg_w(gspca_dev->dev, 0x0008, cx_jpeg_init[i], length); + reg_w(gspca_dev, 0x0008, cx_jpeg_init[i], length); } - reg_r(gspca_dev->dev, 0x0002, &val, 1); - val = 0x14; - reg_w(gspca_dev->dev, 0x0055, &val, 1); + reg_r(gspca_dev, 0x0002, 1); + reg_w_val(gspca_dev, 0x0055, 0x14); } static const __u8 reg12[] = { 0x0a, 0x05, 0x07, 0x04, 0x19 }; @@ -665,31 +672,26 @@ static const __u8 regE5a[] = { 0x88, 0x0a, 0x0c, 0x01 }; static const __u8 regE5b[] = { 0x88, 0x0b, 0x12, 0x01 }; static const __u8 regE5c[] = { 0x88, 0x05, 0x01, 0x01 }; static const __u8 reg51[] = { 0x77, 0x03 }; -static const __u8 reg70 = 0x03; +#define reg70 0x03 static void cx11646_jpeg(struct gspca_dev*gspca_dev) { - __u8 val; int i; int length; __u8 Reg55; - __u8 bufread[8]; int retry; - val = 0x01; - reg_w(gspca_dev->dev, 0x00c0, &val, 1); - val = 0x00; - reg_w(gspca_dev->dev, 0x00c3, &val, 1); - val = 0x00; - reg_w(gspca_dev->dev, 0x00c0, &val, 1); - reg_r(gspca_dev->dev, 0x0001, &val, 1); + reg_w_val(gspca_dev, 0x00c0, 0x01); + reg_w_val(gspca_dev, 0x00c3, 0x00); + reg_w_val(gspca_dev, 0x00c0, 0x00); + reg_r(gspca_dev, 0x0001, 1); length = 8; switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 0: for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, cxjpeg_640[i], length); + reg_w(gspca_dev, 0x0008, cxjpeg_640[i], length); } Reg55 = 0x28; break; @@ -697,7 +699,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, cxjpeg_352[i], length); + reg_w(gspca_dev, 0x0008, cxjpeg_352[i], length); } Reg55 = 0x16; break; @@ -706,7 +708,7 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, cxjpeg_320[i], length); + reg_w(gspca_dev, 0x0008, cxjpeg_320[i], length); } Reg55 = 0x14; break; @@ -714,124 +716,98 @@ static void cx11646_jpeg(struct gspca_dev*gspca_dev) for (i = 0; i < 27; i++) { if (i == 26) length = 2; - reg_w(gspca_dev->dev, 0x0008, cxjpeg_176[i], length); + reg_w(gspca_dev, 0x0008, cxjpeg_176[i], length); } Reg55 = 0x0B; break; } - reg_r(gspca_dev->dev, 0x0002, &val, 1); - val = Reg55; - reg_w(gspca_dev->dev, 0x0055, &val, 1); - reg_r(gspca_dev->dev, 0x0002, &val, 1); - reg_w(gspca_dev->dev, 0x0010, reg10, 2); - val = 0x02; - reg_w(gspca_dev->dev, 0x0054, &val, 1); - val = 0x01; - reg_w(gspca_dev->dev, 0x0054, &val, 1); - val = 0x94; - reg_w(gspca_dev->dev, 0x0000, &val, 1); - val = 0xc0; - reg_w(gspca_dev->dev, 0x0053, &val, 1); - val = 0xe1; - reg_w(gspca_dev->dev, 0x00fc, &val, 1); - val = 0x00; - reg_w(gspca_dev->dev, 0x0000, &val, 1); + reg_r(gspca_dev, 0x0002, 1); + reg_w_val(gspca_dev, 0x0055, Reg55); + reg_r(gspca_dev, 0x0002, 1); + reg_w(gspca_dev, 0x0010, reg10, 2); + reg_w_val(gspca_dev, 0x0054, 0x02); + reg_w_val(gspca_dev, 0x0054, 0x01); + reg_w_val(gspca_dev, 0x0000, 0x94); + reg_w_val(gspca_dev, 0x0053, 0xc0); + reg_w_val(gspca_dev, 0x00fc, 0xe1); + reg_w_val(gspca_dev, 0x0000, 0x00); /* wait for completion */ retry = 50; while (retry--) { - reg_r(gspca_dev->dev, 0x0002, &val, 1); + reg_r(gspca_dev, 0x0002, 1); /* 0x07 until 0x00 */ - if (val == 0x00) + if (gspca_dev->usb_buf[0] == 0x00) break; - val = 0x00; - reg_w(gspca_dev->dev, 0x0053, &val, 1); + reg_w_val(gspca_dev, 0x0053, 0x00); } if (retry == 0) PDEBUG(D_ERR, "Damned Errors sending jpeg Table"); /* send the qtable now */ - reg_r(gspca_dev->dev, 0x0001, &val, 1); /* -> 0x18 */ + reg_r(gspca_dev, 0x0001, 1); /* -> 0x18 */ length = 8; for (i = 0; i < 18; i++) { if (i == 17) length = 2; - reg_w(gspca_dev->dev, 0x0008, cxjpeg_qtable[i], length); + reg_w(gspca_dev, 0x0008, cxjpeg_qtable[i], length); } - reg_r(gspca_dev->dev, 0x0002, &val, 1); /* 0x00 */ - reg_r(gspca_dev->dev, 0x0053, &val, 1); /* 0x00 */ - val = 0x02; - reg_w(gspca_dev->dev, 0x0054, &val, 1); - val = 0x01; - reg_w(gspca_dev->dev, 0x0054, &val, 1); - val = 0x94; - reg_w(gspca_dev->dev, 0x0000, &val, 1); - val = 0xc0; - reg_w(gspca_dev->dev, 0x0053, &val, 1); - - reg_r(gspca_dev->dev, 0x0038, &val, 1); /* 0x40 */ - reg_r(gspca_dev->dev, 0x0038, &val, 1); /* 0x40 */ - reg_r(gspca_dev->dev, 0x001f, &val, 1); /* 0x38 */ - reg_w(gspca_dev->dev, 0x0012, reg12, 5); - reg_w(gspca_dev->dev, 0x00e5, regE5_8, 8); - reg_r(gspca_dev->dev, 0x00e8, bufread, 8); - reg_w(gspca_dev->dev, 0x00e5, regE5a, 4); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */ - val = 0x01; - reg_w(gspca_dev->dev, 0x009a, &val, 1); - reg_w(gspca_dev->dev, 0x00e5, regE5b, 4); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */ - reg_w(gspca_dev->dev, 0x00e5, regE5c, 4); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */ - - reg_w(gspca_dev->dev, 0x0051, reg51, 2); - reg_w(gspca_dev->dev, 0x0010, reg10, 2); - reg_w(gspca_dev->dev, 0x0070, ®70, 1); + reg_r(gspca_dev, 0x0002, 1); /* 0x00 */ + reg_r(gspca_dev, 0x0053, 1); /* 0x00 */ + reg_w_val(gspca_dev, 0x0054, 0x02); + reg_w_val(gspca_dev, 0x0054, 0x01); + reg_w_val(gspca_dev, 0x0000, 0x94); + reg_w_val(gspca_dev, 0x0053, 0xc0); + + reg_r(gspca_dev, 0x0038, 1); /* 0x40 */ + reg_r(gspca_dev, 0x0038, 1); /* 0x40 */ + reg_r(gspca_dev, 0x001f, 1); /* 0x38 */ + reg_w(gspca_dev, 0x0012, reg12, 5); + reg_w(gspca_dev, 0x00e5, regE5_8, 8); + reg_r(gspca_dev, 0x00e8, 8); + reg_w(gspca_dev, 0x00e5, regE5a, 4); + reg_r(gspca_dev, 0x00e8, 1); /* 0x00 */ + reg_w_val(gspca_dev, 0x009a, 0x01); + reg_w(gspca_dev, 0x00e5, regE5b, 4); + reg_r(gspca_dev, 0x00e8, 1); /* 0x00 */ + reg_w(gspca_dev, 0x00e5, regE5c, 4); + reg_r(gspca_dev, 0x00e8, 1); /* 0x00 */ + + reg_w(gspca_dev, 0x0051, reg51, 2); + reg_w(gspca_dev, 0x0010, reg10, 2); + reg_w_val(gspca_dev, 0x0070, reg70); } static void cx11646_init1(struct gspca_dev *gspca_dev) { - __u8 val; int i = 0; - val = 0; - reg_w(gspca_dev->dev, 0x0010, &val, 1); - reg_w(gspca_dev->dev, 0x0053, &val, 1); - reg_w(gspca_dev->dev, 0x0052, &val, 1); - val = 0x2f; - reg_w(gspca_dev->dev, 0x009b, &val, 1); - val = 0x10; - reg_w(gspca_dev->dev, 0x009c, &val, 1); - reg_r(gspca_dev->dev, 0x0098, &val, 1); - val = 0x40; - reg_w(gspca_dev->dev, 0x0098, &val, 1); - reg_r(gspca_dev->dev, 0x0099, &val, 1); - val = 0x07; - reg_w(gspca_dev->dev, 0x0099, &val, 1); - val = 0x40; - reg_w(gspca_dev->dev, 0x0039, &val, 1); - val = 0xff; - reg_w(gspca_dev->dev, 0x003c, &val, 1); - val = 0x1f; - reg_w(gspca_dev->dev, 0x003f, &val, 1); - val = 0x40; - reg_w(gspca_dev->dev, 0x003d, &val, 1); -/* val= 0x60; */ -/* reg_w(gspca_dev->dev, 0x00, 0x00, 0x003d, &val, 1); */ - reg_r(gspca_dev->dev, 0x0099, &val, 1); /* ->0x07 */ + reg_w_val(gspca_dev, 0x0010, 0x00); + reg_w_val(gspca_dev, 0x0053, 0x00); + reg_w_val(gspca_dev, 0x0052, 0x00); + reg_w_val(gspca_dev, 0x009b, 0x2f); + reg_w_val(gspca_dev, 0x009c, 0x10); + reg_r(gspca_dev, 0x0098, 1); + reg_w_val(gspca_dev, 0x0098, 0x40); + reg_r(gspca_dev, 0x0099, 1); + reg_w_val(gspca_dev, 0x0099, 0x07); + reg_w_val(gspca_dev, 0x0039, 0x40); + reg_w_val(gspca_dev, 0x003c, 0xff); + reg_w_val(gspca_dev, 0x003f, 0x1f); + reg_w_val(gspca_dev, 0x003d, 0x40); +/* reg_w_val(gspca_dev, 0x003d, 0x60); */ + reg_r(gspca_dev, 0x0099, 1); /* ->0x07 */ while (cx_sensor_init[i][0]) { - reg_w(gspca_dev->dev, 0x00e5, cx_sensor_init[i], 1); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* -> 0x00 */ + reg_w_val(gspca_dev, 0x00e5, cx_sensor_init[i][0]); + reg_r(gspca_dev, 0x00e8, 1); /* -> 0x00 */ if (i == 1) { - val = 1; - reg_w(gspca_dev->dev, 0x00ed, &val, 1); - reg_r(gspca_dev->dev, 0x00ed, &val, 1); /* -> 0x01 */ + reg_w_val(gspca_dev, 0x00ed, 0x01); + reg_r(gspca_dev, 0x00ed, 1); /* -> 0x01 */ } i++; } - val = 0x00; - reg_w(gspca_dev->dev, 0x00c3, &val, 1); + reg_w_val(gspca_dev, 0x00c3, 0x00); } /* this function is called at probe time */ @@ -880,29 +856,23 @@ static void sd_stopN(struct gspca_dev *gspca_dev) static void sd_stop0(struct gspca_dev *gspca_dev) { int retry = 50; - __u8 val; - val = 0; - reg_w(gspca_dev->dev, 0x0000, &val, 1); - reg_r(gspca_dev->dev, 0x0002, &val, 1); - val = 0; - reg_w(gspca_dev->dev, 0x0053, &val, 1); + reg_w_val(gspca_dev, 0x0000, 0x00); + reg_r(gspca_dev, 0x0002, 1); + reg_w_val(gspca_dev, 0x0053, 0x00); while (retry--) { -/* reg_r(gspca_dev->dev, 0x0002, &val, 1);*/ - reg_r(gspca_dev->dev, 0x0053, &val, 1); - if (val == 0) +/* reg_r(gspca_dev, 0x0002, 1);*/ + reg_r(gspca_dev, 0x0053, 1); + if (gspca_dev->usb_buf[0] == 0) break; } - val = 0; - reg_w(gspca_dev->dev, 0x0000, &val, 1); - reg_r(gspca_dev->dev, 0x0002, &val, 1); - - val = 0; - reg_w(gspca_dev->dev, 0x0010, &val, 1); - reg_r(gspca_dev->dev, 0x0033, &val, 1); - val = 0xe0; - reg_w(gspca_dev->dev, 0x00fc, &val, 1); + reg_w_val(gspca_dev, 0x0000, 0x00); + reg_r(gspca_dev, 0x0002, 1); + + reg_w_val(gspca_dev, 0x0010, 0x00); + reg_r(gspca_dev, 0x0033, 1); + reg_w_val(gspca_dev, 0x00fc, 0xe0); } static void sd_close(struct gspca_dev *gspca_dev) @@ -937,22 +907,20 @@ static void setbrightness(struct gspca_dev*gspca_dev) __u8 reg51c[2]; __u8 bright; __u8 colors; - __u8 val; - __u8 bufread[8]; bright = sd->brightness; regE5cbx[2] = bright; - reg_w(gspca_dev->dev, 0x00e5, regE5cbx, 8); - reg_r(gspca_dev->dev, 0x00e8, bufread, 8); - reg_w(gspca_dev->dev, 0x00e5, regE5c, 4); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */ + reg_w(gspca_dev, 0x00e5, regE5cbx, 8); + reg_r(gspca_dev, 0x00e8, 8); + reg_w(gspca_dev, 0x00e5, regE5c, 4); + reg_r(gspca_dev, 0x00e8, 1); /* 0x00 */ colors = sd->colors; reg51c[0] = 0x77; reg51c[1] = colors; - reg_w(gspca_dev->dev, 0x0051, reg51c, 2); - reg_w(gspca_dev->dev, 0x0010, reg10, 2); - reg_w(gspca_dev->dev, 0x0070, ®70, 1); + reg_w(gspca_dev, 0x0051, reg51c, 2); + reg_w(gspca_dev, 0x0010, reg10, 2); + reg_w_val(gspca_dev, 0x0070, reg70); } static void setcontrast(struct gspca_dev*gspca_dev) @@ -961,16 +929,15 @@ static void setcontrast(struct gspca_dev*gspca_dev) __u8 regE5acx[] = { 0x88, 0x0a, 0x0c, 0x01 }; /* seem MSB */ /* __u8 regE5bcx[] = { 0x88, 0x0b, 0x12, 0x01}; * LSB */ __u8 reg51c[2]; - __u8 val; regE5acx[2] = sd->contrast; - reg_w(gspca_dev->dev, 0x00e5, regE5acx, 4); - reg_r(gspca_dev->dev, 0x00e8, &val, 1); /* 0x00 */ + reg_w(gspca_dev, 0x00e5, regE5acx, 4); + reg_r(gspca_dev, 0x00e8, 1); /* 0x00 */ reg51c[0] = 0x77; reg51c[1] = sd->colors; - reg_w(gspca_dev->dev, 0x0051, reg51c, 2); - reg_w(gspca_dev->dev, 0x0010, reg10, 2); - reg_w(gspca_dev->dev, 0x0070, ®70, 1); + reg_w(gspca_dev, 0x0051, reg51c, 2); + reg_w(gspca_dev, 0x0010, reg10, 2); + reg_w_val(gspca_dev, 0x0070, reg70); } static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val) diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index 1da6a182561..5bb8dc1adbb 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("Etoms USB Camera Driver"); @@ -229,201 +229,215 @@ static const __u8 I2c3[] = { 0x12, 0x05 }; static const __u8 I2c4[] = { 0x41, 0x08 }; -static void reg_r(struct usb_device *dev, - __u16 index, __u8 *buffer, int len) +/* read 'len' bytes to gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 index, + __u16 len) { + struct usb_device *dev = gspca_dev->dev; + +#ifdef CONFIG_VIDEO_ADV_DEBUG + if (len > sizeof gspca_dev->usb_buf) { + err("reg_r: buffer overflow"); + return; + } +#endif usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0, index, buffer, len, 500); + 0, + index, gspca_dev->usb_buf, len, 500); + PDEBUG(D_USBI, "reg read [%02x] -> %02x ..", + index, gspca_dev->usb_buf[0]); } -static void reg_w_val(struct usb_device *dev, - __u16 index, __u8 val) +static void reg_w_val(struct gspca_dev *gspca_dev, + __u16 index, + __u8 val) { - __u8 data; + struct usb_device *dev = gspca_dev->dev; - data = val; + gspca_dev->usb_buf[0] = val; usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0, index, &data, 1, 500); + 0, + index, gspca_dev->usb_buf, 1, 500); } -static void reg_w(struct usb_device *dev, - __u16 index, const __u8 *buffer, __u16 len) +static void reg_w(struct gspca_dev *gspca_dev, + __u16 index, + const __u8 *buffer, + __u16 len) { - __u8 tmpbuf[8]; + struct usb_device *dev = gspca_dev->dev; - memcpy(tmpbuf, buffer, len); +#ifdef CONFIG_VIDEO_ADV_DEBUG + if (len > sizeof gspca_dev->usb_buf) { + err("reg_w: buffer overflow"); + return; + } + PDEBUG(D_USBO, "reg write [%02x] = %02x..", index, *buffer); +#endif + memcpy(gspca_dev->usb_buf, buffer, len); usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0, index, tmpbuf, len, 500); + 0, index, gspca_dev->usb_buf, len, 500); } -static int Et_i2cwrite(struct usb_device *dev, __u8 reg, - const __u8 *buffer, - __u16 len, __u8 mode) +static int i2c_w(struct gspca_dev *gspca_dev, + __u8 reg, + const __u8 *buffer, + __u16 len, __u8 mode) { /* buffer should be [D0..D7] */ __u8 ptchcount; /* set the base address */ - reg_w_val(dev, ET_I2C_BASE, 0x40); /* sensor base for the pas106 */ + reg_w_val(gspca_dev, ET_I2C_BASE, 0x40); + /* sensor base for the pas106 */ /* set count and prefetch */ ptchcount = ((len & 0x07) << 4) | (mode & 0x03); - reg_w_val(dev, ET_I2C_COUNT, ptchcount); + reg_w_val(gspca_dev, ET_I2C_COUNT, ptchcount); /* set the register base */ - reg_w_val(dev, ET_I2C_REG, reg); + reg_w_val(gspca_dev, ET_I2C_REG, reg); while (--len >= 0) - reg_w_val(dev, ET_I2C_DATA0 + len, buffer[len]); + reg_w_val(gspca_dev, ET_I2C_DATA0 + len, buffer[len]); return 0; } -static int Et_i2cread(struct usb_device *dev, __u8 reg, - __u8 *buffer, - __u16 length, __u8 mode) +static int i2c_r(struct gspca_dev *gspca_dev, + __u8 reg) { - /* buffer should be [D0..D7] */ - int i, j; - __u8 ptchcount; - /* set the base address */ - reg_w_val(dev, ET_I2C_BASE, 0x40); /* sensor base for the pas106 */ - /* set count and prefetch */ - ptchcount = ((length & 0x07) << 4) | (mode & 0x03); - reg_w_val(dev, ET_I2C_COUNT, ptchcount); - /* set the register base */ - reg_w_val(dev, ET_I2C_REG, reg); - reg_w_val(dev, ET_I2C_PREFETCH, 0x02); /* prefetch */ - reg_w_val(dev, ET_I2C_PREFETCH, 0); - j = length - 1; - for (i = 0; i < length; i++) { - reg_r(dev, (ET_I2C_DATA0 + j), &buffer[j], 1); - j--; - } + reg_w_val(gspca_dev, ET_I2C_BASE, 0x40); + /* sensor base for the pas106 */ + /* set count and prefetch (cnd: 4 bits - mode: 4 bits) */ + reg_w_val(gspca_dev, ET_I2C_COUNT, 0x11); + reg_w_val(gspca_dev, ET_I2C_REG, reg); /* set the register base */ + reg_w_val(gspca_dev, ET_I2C_PREFETCH, 0x02); /* prefetch */ + reg_w_val(gspca_dev, ET_I2C_PREFETCH, 0x00); + reg_r(gspca_dev, ET_I2C_DATA0, 1); /* read one byte */ return 0; } -static int Et_WaitStatus(struct usb_device *dev) +static int Et_WaitStatus(struct gspca_dev *gspca_dev) { - __u8 bytereceived; int retry = 10; while (retry--) { - reg_r(dev, ET_ClCK, &bytereceived, 1); - if (bytereceived != 0) + reg_r(gspca_dev, ET_ClCK, 1); + if (gspca_dev->usb_buf[0] != 0) return 1; } return 0; } -static int et_video(struct usb_device *dev, int on) +static int et_video(struct gspca_dev *gspca_dev, + int on) { - int err; + int ret; - reg_w_val(dev, ET_GPIO_OUT, on - ? 0x10 /* startvideo - set Bit5 */ - : 0); /* stopvideo */ - err = Et_WaitStatus(dev); - if (!err) + reg_w_val(gspca_dev, ET_GPIO_OUT, + on ? 0x10 /* startvideo - set Bit5 */ + : 0); /* stopvideo */ + ret = Et_WaitStatus(gspca_dev); + if (ret != 0) PDEBUG(D_ERR, "timeout video on/off"); - return err; + return ret; } static void Et_init2(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; __u8 value; - __u8 received; static const __u8 FormLine[] = { 0x84, 0x03, 0x14, 0xf4, 0x01, 0x05 }; PDEBUG(D_STREAM, "Open Init2 ET"); - reg_w_val(dev, ET_GPIO_DIR_CTRL, 0x2f); - reg_w_val(dev, ET_GPIO_OUT, 0x10); - reg_r(dev, ET_GPIO_IN, &received, 1); - reg_w_val(dev, ET_ClCK, 0x14); /* 0x14 // 0x16 enabled pattern */ - reg_w_val(dev, ET_CTRL, 0x1b); + reg_w_val(gspca_dev, ET_GPIO_DIR_CTRL, 0x2f); + reg_w_val(gspca_dev, ET_GPIO_OUT, 0x10); + reg_r(gspca_dev, ET_GPIO_IN, 1); + reg_w_val(gspca_dev, ET_ClCK, 0x14); /* 0x14 // 0x16 enabled pattern */ + reg_w_val(gspca_dev, ET_CTRL, 0x1b); /* compression et subsampling */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) value = ET_COMP_VAL1; /* 320 */ else value = ET_COMP_VAL0; /* 640 */ - reg_w_val(dev, ET_COMP, value); - reg_w_val(dev, ET_MAXQt, 0x1f); - reg_w_val(dev, ET_MINQt, 0x04); + reg_w_val(gspca_dev, ET_COMP, value); + reg_w_val(gspca_dev, ET_MAXQt, 0x1f); + reg_w_val(gspca_dev, ET_MINQt, 0x04); /* undocumented registers */ - reg_w_val(dev, ET_REG1d, 0xff); - reg_w_val(dev, ET_REG1e, 0xff); - reg_w_val(dev, ET_REG1f, 0xff); - reg_w_val(dev, ET_REG20, 0x35); - reg_w_val(dev, ET_REG21, 0x01); - reg_w_val(dev, ET_REG22, 0x00); - reg_w_val(dev, ET_REG23, 0xff); - reg_w_val(dev, ET_REG24, 0xff); - reg_w_val(dev, ET_REG25, 0x0f); + reg_w_val(gspca_dev, ET_REG1d, 0xff); + reg_w_val(gspca_dev, ET_REG1e, 0xff); + reg_w_val(gspca_dev, ET_REG1f, 0xff); + reg_w_val(gspca_dev, ET_REG20, 0x35); + reg_w_val(gspca_dev, ET_REG21, 0x01); + reg_w_val(gspca_dev, ET_REG22, 0x00); + reg_w_val(gspca_dev, ET_REG23, 0xff); + reg_w_val(gspca_dev, ET_REG24, 0xff); + reg_w_val(gspca_dev, ET_REG25, 0x0f); /* colors setting */ - reg_w_val(dev, 0x30, 0x11); /* 0x30 */ - reg_w_val(dev, 0x31, 0x40); - reg_w_val(dev, 0x32, 0x00); - reg_w_val(dev, ET_O_RED, 0x00); /* 0x34 */ - reg_w_val(dev, ET_O_GREEN1, 0x00); - reg_w_val(dev, ET_O_BLUE, 0x00); - reg_w_val(dev, ET_O_GREEN2, 0x00); + reg_w_val(gspca_dev, 0x30, 0x11); /* 0x30 */ + reg_w_val(gspca_dev, 0x31, 0x40); + reg_w_val(gspca_dev, 0x32, 0x00); + reg_w_val(gspca_dev, ET_O_RED, 0x00); /* 0x34 */ + reg_w_val(gspca_dev, ET_O_GREEN1, 0x00); + reg_w_val(gspca_dev, ET_O_BLUE, 0x00); + reg_w_val(gspca_dev, ET_O_GREEN2, 0x00); /*************/ - reg_w_val(dev, ET_G_RED, 0x80); /* 0x4d */ - reg_w_val(dev, ET_G_GREEN1, 0x80); - reg_w_val(dev, ET_G_BLUE, 0x80); - reg_w_val(dev, ET_G_GREEN2, 0x80); - reg_w_val(dev, ET_G_GR_H, 0x00); - reg_w_val(dev, ET_G_GB_H, 0x00); /* 0x52 */ + reg_w_val(gspca_dev, ET_G_RED, 0x80); /* 0x4d */ + reg_w_val(gspca_dev, ET_G_GREEN1, 0x80); + reg_w_val(gspca_dev, ET_G_BLUE, 0x80); + reg_w_val(gspca_dev, ET_G_GREEN2, 0x80); + reg_w_val(gspca_dev, ET_G_GR_H, 0x00); + reg_w_val(gspca_dev, ET_G_GB_H, 0x00); /* 0x52 */ /* Window control registers */ - reg_w_val(dev, 0x61, 0x80); /* use cmc_out */ - reg_w_val(dev, 0x62, 0x02); - reg_w_val(dev, 0x63, 0x03); - reg_w_val(dev, 0x64, 0x14); - reg_w_val(dev, 0x65, 0x0e); - reg_w_val(dev, 0x66, 0x02); - reg_w_val(dev, 0x67, 0x02); + reg_w_val(gspca_dev, 0x61, 0x80); /* use cmc_out */ + reg_w_val(gspca_dev, 0x62, 0x02); + reg_w_val(gspca_dev, 0x63, 0x03); + reg_w_val(gspca_dev, 0x64, 0x14); + reg_w_val(gspca_dev, 0x65, 0x0e); + reg_w_val(gspca_dev, 0x66, 0x02); + reg_w_val(gspca_dev, 0x67, 0x02); /**************************************/ - reg_w_val(dev, ET_SYNCHRO, 0x8f); /* 0x68 */ - reg_w_val(dev, ET_STARTX, 0x69); /* 0x6a //0x69 */ - reg_w_val(dev, ET_STARTY, 0x0d); /* 0x0d //0x0c */ - reg_w_val(dev, ET_WIDTH_LOW, 0x80); - reg_w_val(dev, ET_HEIGTH_LOW, 0xe0); - reg_w_val(dev, ET_W_H_HEIGTH, 0x60); /* 6d */ - reg_w_val(dev, ET_REG6e, 0x86); - reg_w_val(dev, ET_REG6f, 0x01); - reg_w_val(dev, ET_REG70, 0x26); - reg_w_val(dev, ET_REG71, 0x7a); - reg_w_val(dev, ET_REG72, 0x01); + reg_w_val(gspca_dev, ET_SYNCHRO, 0x8f); /* 0x68 */ + reg_w_val(gspca_dev, ET_STARTX, 0x69); /* 0x6a //0x69 */ + reg_w_val(gspca_dev, ET_STARTY, 0x0d); /* 0x0d //0x0c */ + reg_w_val(gspca_dev, ET_WIDTH_LOW, 0x80); + reg_w_val(gspca_dev, ET_HEIGTH_LOW, 0xe0); + reg_w_val(gspca_dev, ET_W_H_HEIGTH, 0x60); /* 6d */ + reg_w_val(gspca_dev, ET_REG6e, 0x86); + reg_w_val(gspca_dev, ET_REG6f, 0x01); + reg_w_val(gspca_dev, ET_REG70, 0x26); + reg_w_val(gspca_dev, ET_REG71, 0x7a); + reg_w_val(gspca_dev, ET_REG72, 0x01); /* Clock Pattern registers ***************** */ - reg_w_val(dev, ET_REG73, 0x00); - reg_w_val(dev, ET_REG74, 0x18); /* 0x28 */ - reg_w_val(dev, ET_REG75, 0x0f); /* 0x01 */ + reg_w_val(gspca_dev, ET_REG73, 0x00); + reg_w_val(gspca_dev, ET_REG74, 0x18); /* 0x28 */ + reg_w_val(gspca_dev, ET_REG75, 0x0f); /* 0x01 */ /**********************************************/ - reg_w_val(dev, 0x8a, 0x20); - reg_w_val(dev, 0x8d, 0x0f); - reg_w_val(dev, 0x8e, 0x08); + reg_w_val(gspca_dev, 0x8a, 0x20); + reg_w_val(gspca_dev, 0x8d, 0x0f); + reg_w_val(gspca_dev, 0x8e, 0x08); /**************************************/ - reg_w_val(dev, 0x03, 0x08); - reg_w_val(dev, ET_PXL_CLK, 0x03); - reg_w_val(dev, 0x81, 0xff); - reg_w_val(dev, 0x80, 0x00); - reg_w_val(dev, 0x81, 0xff); - reg_w_val(dev, 0x80, 0x20); - reg_w_val(dev, 0x03, 0x01); - reg_w_val(dev, 0x03, 0x00); - reg_w_val(dev, 0x03, 0x08); + reg_w_val(gspca_dev, 0x03, 0x08); + reg_w_val(gspca_dev, ET_PXL_CLK, 0x03); + reg_w_val(gspca_dev, 0x81, 0xff); + reg_w_val(gspca_dev, 0x80, 0x00); + reg_w_val(gspca_dev, 0x81, 0xff); + reg_w_val(gspca_dev, 0x80, 0x20); + reg_w_val(gspca_dev, 0x03, 0x01); + reg_w_val(gspca_dev, 0x03, 0x00); + reg_w_val(gspca_dev, 0x03, 0x08); /********************************************/ -/* reg_r(dev, ET_I2C_BASE, &received, 1); +/* reg_r(gspca_dev, ET_I2C_BASE, 1); always 0x40 as the pas106 ??? */ /* set the sensor */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) @@ -435,25 +449,24 @@ static void Et_init2(struct gspca_dev *gspca_dev) * 0x0b -> 24/(11+1) = 2 Mhz * 0x17 -> 24/(23+1) = 1 Mhz */ - reg_w_val(dev, ET_PXL_CLK, value); + reg_w_val(gspca_dev, ET_PXL_CLK, value); /* now set by fifo the FormatLine setting */ - reg_w(dev, 0x62, FormLine, 6); + reg_w(gspca_dev, 0x62, FormLine, 6); /* set exposure times [ 0..0x78] 0->longvalue 0x78->shortvalue */ - reg_w_val(dev, 0x81, 0x47); /* 0x47; */ - reg_w_val(dev, 0x80, 0x40); /* 0x40; */ + reg_w_val(gspca_dev, 0x81, 0x47); /* 0x47; */ + reg_w_val(gspca_dev, 0x80, 0x40); /* 0x40; */ /* Pedro change */ /* Brightness change Brith+ decrease value */ /* Brigth- increase value */ /* original value = 0x70; */ - reg_w_val(dev, 0x81, 0x30); /* 0x20; - set brightness */ - reg_w_val(dev, 0x80, 0x20); /* 0x20; */ + reg_w_val(gspca_dev, 0x81, 0x30); /* 0x20; - set brightness */ + reg_w_val(gspca_dev, 0x80, 0x20); /* 0x20; */ } static void setcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 I2cc[] = { 0x05, 0x02, 0x02, 0x05, 0x0d }; __u8 i2cflags = 0x01; /* __u8 green = 0; */ @@ -464,8 +477,8 @@ static void setcolors(struct gspca_dev *gspca_dev) /* green = 15 - ((((7*I2cc[0]) >> 2 ) + I2cc[3]) >> 1); */ /* I2cc[1] = I2cc[2] = green; */ if (sd->sensor == SENSOR_PAS106) { - Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3); - Et_i2cwrite(dev, PAS106_REG9, I2cc, sizeof I2cc, 1); + i2c_w(gspca_dev, PAS106_REG13, &i2cflags, 1, 3); + i2c_w(gspca_dev, PAS106_REG9, I2cc, sizeof I2cc, 1); } /* PDEBUG(D_CONF , "Etoms red %d blue %d green %d", I2cc[3], I2cc[0], green); */ @@ -474,21 +487,17 @@ static void setcolors(struct gspca_dev *gspca_dev) static void getcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; -/* __u8 valblue; */ - __u8 valred; if (sd->sensor == SENSOR_PAS106) { -/* Et_i2cread(gspca_dev->dev, PAS106_REG9, &valblue, 1, 1); */ - Et_i2cread(gspca_dev->dev, PAS106_REG9 + 3, &valred, 1, 1); - sd->colors = valred & 0x0f; +/* i2c_r(gspca_dev, PAS106_REG9); * blue */ + i2c_r(gspca_dev, PAS106_REG9 + 3); /* red */ + sd->colors = gspca_dev->usb_buf[0] & 0x0f; } } static void Et_init1(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; __u8 value; - __u8 received; /* __u8 I2c0 [] = {0x0a, 0x12, 0x05, 0x22, 0xac, 0x00, 0x01, 0x00}; */ __u8 I2c0[] = { 0x0a, 0x12, 0x05, 0x6d, 0xcd, 0x00, 0x01, 0x00 }; /* try 1/120 0x6d 0xcd 0x40 */ @@ -496,12 +505,12 @@ static void Et_init1(struct gspca_dev *gspca_dev) * 1/60000 hmm ?? */ PDEBUG(D_STREAM, "Open Init1 ET"); - reg_w_val(dev, ET_GPIO_DIR_CTRL, 7); - reg_r(dev, ET_GPIO_IN, &received, 1); - reg_w_val(dev, ET_RESET_ALL, 1); - reg_w_val(dev, ET_RESET_ALL, 0); - reg_w_val(dev, ET_ClCK, 0x10); - reg_w_val(dev, ET_CTRL, 0x19); + reg_w_val(gspca_dev, ET_GPIO_DIR_CTRL, 7); + reg_r(gspca_dev, ET_GPIO_IN, 1); + reg_w_val(gspca_dev, ET_RESET_ALL, 1); + reg_w_val(gspca_dev, ET_RESET_ALL, 0); + reg_w_val(gspca_dev, ET_ClCK, 0x10); + reg_w_val(gspca_dev, ET_CTRL, 0x19); /* compression et subsampling */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) value = ET_COMP_VAL1; @@ -510,80 +519,79 @@ static void Et_init1(struct gspca_dev *gspca_dev) PDEBUG(D_STREAM, "Open mode %d Compression %d", gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv, value); - reg_w_val(dev, ET_COMP, value); - reg_w_val(dev, ET_MAXQt, 0x1d); - reg_w_val(dev, ET_MINQt, 0x02); + reg_w_val(gspca_dev, ET_COMP, value); + reg_w_val(gspca_dev, ET_MAXQt, 0x1d); + reg_w_val(gspca_dev, ET_MINQt, 0x02); /* undocumented registers */ - reg_w_val(dev, ET_REG1d, 0xff); - reg_w_val(dev, ET_REG1e, 0xff); - reg_w_val(dev, ET_REG1f, 0xff); - reg_w_val(dev, ET_REG20, 0x35); - reg_w_val(dev, ET_REG21, 0x01); - reg_w_val(dev, ET_REG22, 0x00); - reg_w_val(dev, ET_REG23, 0xf7); - reg_w_val(dev, ET_REG24, 0xff); - reg_w_val(dev, ET_REG25, 0x07); + reg_w_val(gspca_dev, ET_REG1d, 0xff); + reg_w_val(gspca_dev, ET_REG1e, 0xff); + reg_w_val(gspca_dev, ET_REG1f, 0xff); + reg_w_val(gspca_dev, ET_REG20, 0x35); + reg_w_val(gspca_dev, ET_REG21, 0x01); + reg_w_val(gspca_dev, ET_REG22, 0x00); + reg_w_val(gspca_dev, ET_REG23, 0xf7); + reg_w_val(gspca_dev, ET_REG24, 0xff); + reg_w_val(gspca_dev, ET_REG25, 0x07); /* colors setting */ - reg_w_val(dev, ET_G_RED, 0x80); - reg_w_val(dev, ET_G_GREEN1, 0x80); - reg_w_val(dev, ET_G_BLUE, 0x80); - reg_w_val(dev, ET_G_GREEN2, 0x80); - reg_w_val(dev, ET_G_GR_H, 0x00); - reg_w_val(dev, ET_G_GB_H, 0x00); + reg_w_val(gspca_dev, ET_G_RED, 0x80); + reg_w_val(gspca_dev, ET_G_GREEN1, 0x80); + reg_w_val(gspca_dev, ET_G_BLUE, 0x80); + reg_w_val(gspca_dev, ET_G_GREEN2, 0x80); + reg_w_val(gspca_dev, ET_G_GR_H, 0x00); + reg_w_val(gspca_dev, ET_G_GB_H, 0x00); /* Window control registers */ - reg_w_val(dev, ET_SYNCHRO, 0xf0); - reg_w_val(dev, ET_STARTX, 0x56); /* 0x56 */ - reg_w_val(dev, ET_STARTY, 0x05); /* 0x04 */ - reg_w_val(dev, ET_WIDTH_LOW, 0x60); - reg_w_val(dev, ET_HEIGTH_LOW, 0x20); - reg_w_val(dev, ET_W_H_HEIGTH, 0x50); - reg_w_val(dev, ET_REG6e, 0x86); - reg_w_val(dev, ET_REG6f, 0x01); - reg_w_val(dev, ET_REG70, 0x86); - reg_w_val(dev, ET_REG71, 0x14); - reg_w_val(dev, ET_REG72, 0x00); + reg_w_val(gspca_dev, ET_SYNCHRO, 0xf0); + reg_w_val(gspca_dev, ET_STARTX, 0x56); /* 0x56 */ + reg_w_val(gspca_dev, ET_STARTY, 0x05); /* 0x04 */ + reg_w_val(gspca_dev, ET_WIDTH_LOW, 0x60); + reg_w_val(gspca_dev, ET_HEIGTH_LOW, 0x20); + reg_w_val(gspca_dev, ET_W_H_HEIGTH, 0x50); + reg_w_val(gspca_dev, ET_REG6e, 0x86); + reg_w_val(gspca_dev, ET_REG6f, 0x01); + reg_w_val(gspca_dev, ET_REG70, 0x86); + reg_w_val(gspca_dev, ET_REG71, 0x14); + reg_w_val(gspca_dev, ET_REG72, 0x00); /* Clock Pattern registers */ - reg_w_val(dev, ET_REG73, 0x00); - reg_w_val(dev, ET_REG74, 0x00); - reg_w_val(dev, ET_REG75, 0x0a); - reg_w_val(dev, ET_I2C_CLK, 0x04); - reg_w_val(dev, ET_PXL_CLK, 0x01); + reg_w_val(gspca_dev, ET_REG73, 0x00); + reg_w_val(gspca_dev, ET_REG74, 0x00); + reg_w_val(gspca_dev, ET_REG75, 0x0a); + reg_w_val(gspca_dev, ET_I2C_CLK, 0x04); + reg_w_val(gspca_dev, ET_PXL_CLK, 0x01); /* set the sensor */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { I2c0[0] = 0x06; - Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1); - Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof I2c2, 1); + i2c_w(gspca_dev, PAS106_REG2, I2c0, sizeof I2c0, 1); + i2c_w(gspca_dev, PAS106_REG9, I2c2, sizeof I2c2, 1); value = 0x06; - Et_i2cwrite(dev, PAS106_REG2, &value, 1, 1); - Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1); + i2c_w(gspca_dev, PAS106_REG2, &value, 1, 1); + i2c_w(gspca_dev, PAS106_REG3, I2c3, sizeof I2c3, 1); /* value = 0x1f; */ value = 0x04; - Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1); + i2c_w(gspca_dev, PAS106_REG0e, &value, 1, 1); } else { I2c0[0] = 0x0a; - Et_i2cwrite(dev, PAS106_REG2, I2c0, sizeof I2c0, 1); - Et_i2cwrite(dev, PAS106_REG9, I2c2, sizeof I2c2, 1); + i2c_w(gspca_dev, PAS106_REG2, I2c0, sizeof I2c0, 1); + i2c_w(gspca_dev, PAS106_REG9, I2c2, sizeof I2c2, 1); value = 0x0a; - - Et_i2cwrite(dev, PAS106_REG2, &value, 1, 1); - Et_i2cwrite(dev, PAS106_REG3, I2c3, sizeof I2c3, 1); + i2c_w(gspca_dev, PAS106_REG2, &value, 1, 1); + i2c_w(gspca_dev, PAS106_REG3, I2c3, sizeof I2c3, 1); value = 0x04; /* value = 0x10; */ - Et_i2cwrite(dev, PAS106_REG0e, &value, 1, 1); + i2c_w(gspca_dev, PAS106_REG0e, &value, 1, 1); /* bit 2 enable bit 1:2 select 0 1 2 3 value = 0x07; * curve 0 * - Et_i2cwrite(dev,PAS106_REG0f,&value,1,1); + i2c_w(gspca_dev, PAS106_REG0f, &value, 1, 1); */ } /* value = 0x01; */ /* value = 0x22; */ -/* Et_i2cwrite(dev, PAS106_REG5, &value, 1, 1); */ +/* i2c_w(gspca_dev, PAS106_REG5, &value, 1, 1); */ /* magnetude and sign bit for DAC */ - Et_i2cwrite(dev, PAS106_REG7, I2c4, sizeof I2c4, 1); + i2c_w(gspca_dev, PAS106_REG7, I2c4, sizeof I2c4, 1); /* now set by fifo the whole colors setting */ - reg_w(dev, ET_G_RED, GainRGBG, 6); + reg_w(gspca_dev, ET_G_RED, GainRGBG, 6); getcolors(gspca_dev); setcolors(gspca_dev); } @@ -632,14 +640,13 @@ static int sd_config(struct gspca_dev *gspca_dev, static int sd_open(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; if (sd->sensor == SENSOR_PAS106) Et_init1(gspca_dev); else Et_init2(gspca_dev); - reg_w_val(dev, ET_RESET_ALL, 0x08); - et_video(dev, 0); /* video off */ + reg_w_val(gspca_dev, ET_RESET_ALL, 0x08); + et_video(gspca_dev, 0); /* video off */ return 0; } @@ -647,20 +654,19 @@ static int sd_open(struct gspca_dev *gspca_dev) static void sd_start(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; if (sd->sensor == SENSOR_PAS106) Et_init1(gspca_dev); else Et_init2(gspca_dev); - reg_w_val(dev, ET_RESET_ALL, 0x08); - et_video(dev, 1); /* video on */ + reg_w_val(gspca_dev, ET_RESET_ALL, 0x08); + et_video(gspca_dev, 1); /* video on */ } static void sd_stopN(struct gspca_dev *gspca_dev) { - et_video(gspca_dev->dev, 0); /* video off */ + et_video(gspca_dev, 0); /* video off */ } static void sd_stop0(struct gspca_dev *gspca_dev) @@ -678,7 +684,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) __u8 brightness = sd->brightness; for (i = 0; i < 4; i++) - reg_w_val(gspca_dev->dev, (ET_O_RED + i), brightness); + reg_w_val(gspca_dev, ET_O_RED + i, brightness); } static void getbrightness(struct gspca_dev *gspca_dev) @@ -686,11 +692,10 @@ static void getbrightness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; int i; int brightness = 0; - __u8 value; for (i = 0; i < 4; i++) { - reg_r(gspca_dev->dev, (ET_O_RED + i), &value, 1); - brightness += value; + reg_r(gspca_dev, ET_O_RED + i, 1); + brightness += gspca_dev->usb_buf[0]; } sd->brightness = brightness >> 3; } @@ -701,8 +706,8 @@ static void setcontrast(struct gspca_dev *gspca_dev) __u8 RGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 }; __u8 contrast = sd->contrast; - memset(RGBG, contrast, sizeof RGBG - 2); - reg_w(gspca_dev->dev, ET_G_RED, RGBG, 6); + memset(RGBG, contrast, sizeof(RGBG) - 2); + reg_w(gspca_dev, ET_G_RED, RGBG, 6); } static void getcontrast(struct gspca_dev *gspca_dev) @@ -710,11 +715,10 @@ static void getcontrast(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; int i; int contrast = 0; - __u8 value = 0; for (i = 0; i < 4; i++) { - reg_r(gspca_dev->dev, (ET_G_RED + i), &value, 1); - contrast += value; + reg_r(gspca_dev, ET_G_RED + i, 1); + contrast += gspca_dev->usb_buf[0]; } sd->contrast = contrast >> 2; } @@ -722,12 +726,11 @@ static void getcontrast(struct gspca_dev *gspca_dev) static __u8 Et_getgainG(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - __u8 value = 0; if (sd->sensor == SENSOR_PAS106) { - Et_i2cread(gspca_dev->dev, PAS106_REG0e, &value, 1, 1); - PDEBUG(D_CONF, "Etoms gain G %d", value); - return value; + i2c_r(gspca_dev, PAS106_REG0e); + PDEBUG(D_CONF, "Etoms gain G %d", gspca_dev->usb_buf[0]); + return gspca_dev->usb_buf[0]; } return 0x1f; } @@ -735,12 +738,12 @@ static __u8 Et_getgainG(struct gspca_dev *gspca_dev) static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; - __u8 i2cflags = 0x01; if (sd->sensor == SENSOR_PAS106) { - Et_i2cwrite(dev, PAS106_REG13, &i2cflags, 1, 3); - Et_i2cwrite(dev, PAS106_REG0e, &gain, 1, 1); + __u8 i2cflags = 0x01; + + i2c_w(gspca_dev, PAS106_REG13, &i2cflags, 1, 3); + i2c_w(gspca_dev, PAS106_REG0e, &gain, 1, 1); } } @@ -751,8 +754,6 @@ static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain) static void setautogain(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 GRBG[] = { 0, 0, 0, 0 }; __u8 luma = 0; __u8 luma_mean = 128; __u8 luma_delta = 20; @@ -761,10 +762,10 @@ static void setautogain(struct gspca_dev *gspca_dev) __u8 r, g, b; Gbright = Et_getgainG(gspca_dev); - reg_r(dev, ET_LUMA_CENTER, GRBG, 4); - g = (GRBG[0] + GRBG[3]) >> 1; - r = GRBG[1]; - b = GRBG[2]; + reg_r(gspca_dev, ET_LUMA_CENTER, 4); + g = (gspca_dev->usb_buf[0] + gspca_dev->usb_buf[3]) >> 1; + r = gspca_dev->usb_buf[1]; + b = gspca_dev->usb_buf[2]; r = ((r << 8) - (r << 4) - (r << 3)) >> 10; b = ((b << 7) >> 10); g = ((g << 9) + (g << 7) + (g << 5)) >> 10; diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c index a566fd39489..242f0fb68d6 100644 --- a/drivers/media/video/gspca/gspca.c +++ b/drivers/media/video/gspca/gspca.c @@ -1347,9 +1347,11 @@ ok: gspca_dev->fr_i, gspca_dev->fr_o); - if (gspca_dev->sd_desc->dq_callback) + if (gspca_dev->sd_desc->dq_callback) { + mutex_lock(&gspca_dev->usb_lock); gspca_dev->sd_desc->dq_callback(gspca_dev); - + mutex_unlock(&gspca_dev->usb_lock); + } return j; } diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h index 78fccefcd57..3fd2c4eee20 100644 --- a/drivers/media/video/gspca/gspca.h +++ b/drivers/media/video/gspca/gspca.h @@ -125,6 +125,7 @@ struct gspca_dev { struct cam cam; /* device information */ const struct sd_desc *sd_desc; /* subdriver description */ + __u8 usb_buf[8]; /* buffer for USB exchanges */ struct urb *urb[MAX_NURBS]; __u8 *frbuf; /* buffer for nframes */ diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c index 23f3dba8012..88c2b02f380 100644 --- a/drivers/media/video/gspca/mars.c +++ b/drivers/media/video/gspca/mars.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver"); @@ -83,39 +83,53 @@ enum { REG_HW_MI_63, REG_HW_MI_64, REG_HW_MI_F1 = 0xf1, - ATTR_TOTAL_MI_REG = 242 + ATTR_TOTAL_MI_REG = 0xf2 }; -static int pcam_reg_write(struct usb_device *dev, - __u16 index, __u8 *value, int len) +/* the bytes to write are in gspca_dev->usb_buf */ +static int reg_w(struct gspca_dev *gspca_dev, + __u16 index, int len) { int rc; - rc = usb_control_msg(dev, - usb_sndbulkpipe(dev, 4), + rc = usb_control_msg(gspca_dev->dev, + usb_sndbulkpipe(gspca_dev->dev, 4), 0x12, -/* ?? 0xc8 = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_??? !? */ - 0xc8, + 0xc8, /* ?? */ 0, /* value */ - index, value, len, 500); + index, gspca_dev->usb_buf, len, 500); if (rc < 0) PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc); return rc; } -static void MISensor_BulkWrite(struct usb_device *dev, - unsigned short *pch, - char Address) +static int reg_w_buf(struct gspca_dev *gspca_dev, + __u16 index, __u8 *buf, int len) { - __u8 data[6]; + int rc; + + rc = usb_control_msg(gspca_dev->dev, + usb_sndbulkpipe(gspca_dev->dev, 4), + 0x12, + 0xc8, /* ?? */ + 0, /* value */ + index, buf, len, 500); + if (rc < 0) + PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc); + return rc; +} - data[0] = 0x1f; - data[1] = 0; /* control byte */ - data[2] = Address; - data[3] = *pch >> 8; /* high byte */ - data[4] = *pch; /* low byte */ +static void bulk_w(struct gspca_dev *gspca_dev, + __u16 *pch, + __u16 Address) +{ + gspca_dev->usb_buf[0] = 0x1f; + gspca_dev->usb_buf[1] = 0; /* control byte */ + gspca_dev->usb_buf[2] = Address; + gspca_dev->usb_buf[3] = *pch >> 8; /* high byte */ + gspca_dev->usb_buf[4] = *pch; /* low byte */ - pcam_reg_write(dev, Address, data, 5); + reg_w(gspca_dev, Address, 5); } /* this function is called at probe time */ @@ -142,33 +156,30 @@ static int sd_open(struct gspca_dev *gspca_dev) static void sd_start(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; int err_code; - __u8 data[12]; - __u16 MI_buf[242]; + __u8 *data; + __u16 *MI_buf; int h_size, v_size; int intpipe; -/* struct usb_device *dev = pcam->dev; */ - - memset(data, 0, sizeof data); - memset(MI_buf, 0, sizeof MI_buf); PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface); - if (usb_set_interface(dev, gspca_dev->iface, 8) < 0) { + if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8) < 0) { PDEBUG(D_ERR|D_STREAM, "Set packet size: set interface error"); return; } + data = gspca_dev->usb_buf; data[0] = 0x01; /* address */ data[1] = 0x01; - err_code = pcam_reg_write(dev, data[0], data, 2); + err_code = reg_w(gspca_dev, data[0], 2); if (err_code < 0) return; /* Initialize the MR97113 chip register */ + data = kmalloc(16, GFP_KERNEL); data[0] = 0x00; /* address */ data[1] = 0x0c | 0x01; /* reg 0 */ data[2] = 0x01; /* reg 1 */ @@ -181,34 +192,34 @@ static void sd_start(struct gspca_dev *gspca_dev) data[6] = 4; /* reg 5, H start */ data[7] = 0xc0; /* reg 6, gamma 1.5 */ data[8] = 3; /* reg 7, V start */ -/* if(h_size == 320 ) */ +/* if (h_size == 320 ) */ /* data[9]= 0x56; * reg 8, 24MHz, 2:1 scale down */ /* else */ data[9] = 0x52; /* reg 8, 24MHz, no scale down */ data[10] = 0x5d; /* reg 9, I2C device address * [for PAS5101 (0x40)] [for MI (0x5d)] */ - err_code = pcam_reg_write(dev, data[0], data, 11); + err_code = reg_w_buf(gspca_dev, data[0], data, 11); + kfree(data); if (err_code < 0) return; + data = gspca_dev->usb_buf; data[0] = 0x23; /* address */ data[1] = 0x09; /* reg 35, append frame header */ - err_code = pcam_reg_write(dev, data[0], data, 2); - if (err_code < 0) { - PDEBUG(D_ERR, "Register write failed"); + err_code = reg_w(gspca_dev, data[0], 2); + if (err_code < 0) return; - } - data[0] = 0x3C; /* address */ -/* if (pcam->width == 1280) */ + data[0] = 0x3c; /* address */ +/* if (gspca_dev->width == 1280) */ /* data[1] = 200; * reg 60, pc-cam frame size * (unit: 4KB) 800KB */ /* else */ data[1] = 50; /* 50 reg 60, pc-cam frame size * (unit: 4KB) 200KB */ - err_code = pcam_reg_write(dev, data[0], data, 2); + err_code = reg_w(gspca_dev, data[0], 2); if (err_code < 0) return; @@ -250,19 +261,20 @@ static void sd_start(struct gspca_dev *gspca_dev) /* auto dark-gain */ data[0] = 0x5e; /* address */ - err_code = pcam_reg_write(dev, data[0], data, 6); + err_code = reg_w(gspca_dev, data[0], 6); if (err_code < 0) return; data[0] = 0x67; data[1] = 0x13; /* reg 103, first pixel B, disable sharpness */ - err_code = pcam_reg_write(dev, data[0], data, 2); + err_code = reg_w(gspca_dev, data[0], 2); if (err_code < 0) return; /* * initialize the value of MI sensor... */ + MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL); MI_buf[REG_HW_MI_1] = 0x000a; MI_buf[REG_HW_MI_2] = 0x000c; MI_buf[REG_HW_MI_3] = 0x0405; @@ -304,48 +316,48 @@ static void sd_start(struct gspca_dev *gspca_dev) } MI_buf[0x20] = 0x1104; - MISensor_BulkWrite(dev, MI_buf + 1, 1); - MISensor_BulkWrite(dev, MI_buf + 2, 2); - MISensor_BulkWrite(dev, MI_buf + 3, 3); - MISensor_BulkWrite(dev, MI_buf + 4, 4); - MISensor_BulkWrite(dev, MI_buf + 5, 5); - MISensor_BulkWrite(dev, MI_buf + 6, 6); - MISensor_BulkWrite(dev, MI_buf + 7, 7); - MISensor_BulkWrite(dev, MI_buf + 9, 9); - MISensor_BulkWrite(dev, MI_buf + 0x0b, 0x0b); - MISensor_BulkWrite(dev, MI_buf + 0x0c, 0x0c); - MISensor_BulkWrite(dev, MI_buf + 0x0d, 0x0d); - MISensor_BulkWrite(dev, MI_buf + 0x1e, 0x1e); - MISensor_BulkWrite(dev, MI_buf + 0x20, 0x20); - MISensor_BulkWrite(dev, MI_buf + 0x2b, 0x2b); - MISensor_BulkWrite(dev, MI_buf + 0x2c, 0x2c); - MISensor_BulkWrite(dev, MI_buf + 0x2d, 0x2d); - MISensor_BulkWrite(dev, MI_buf + 0x2e, 0x2e); - MISensor_BulkWrite(dev, MI_buf + 0x35, 0x35); - MISensor_BulkWrite(dev, MI_buf + 0x5f, 0x5f); - MISensor_BulkWrite(dev, MI_buf + 0x60, 0x60); - MISensor_BulkWrite(dev, MI_buf + 0x61, 0x61); - MISensor_BulkWrite(dev, MI_buf + 0x62, 0x62); - MISensor_BulkWrite(dev, MI_buf + 0x63, 0x63); - MISensor_BulkWrite(dev, MI_buf + 0x64, 0x64); - MISensor_BulkWrite(dev, MI_buf + 0xf1, 0xf1); - - intpipe = usb_sndintpipe(dev, 0); - err_code = usb_clear_halt(dev, intpipe); + bulk_w(gspca_dev, MI_buf + 1, 1); + bulk_w(gspca_dev, MI_buf + 2, 2); + bulk_w(gspca_dev, MI_buf + 3, 3); + bulk_w(gspca_dev, MI_buf + 4, 4); + bulk_w(gspca_dev, MI_buf + 5, 5); + bulk_w(gspca_dev, MI_buf + 6, 6); + bulk_w(gspca_dev, MI_buf + 7, 7); + bulk_w(gspca_dev, MI_buf + 9, 9); + bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b); + bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c); + bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d); + bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e); + bulk_w(gspca_dev, MI_buf + 0x20, 0x20); + bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b); + bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c); + bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d); + bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e); + bulk_w(gspca_dev, MI_buf + 0x35, 0x35); + bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f); + bulk_w(gspca_dev, MI_buf + 0x60, 0x60); + bulk_w(gspca_dev, MI_buf + 0x61, 0x61); + bulk_w(gspca_dev, MI_buf + 0x62, 0x62); + bulk_w(gspca_dev, MI_buf + 0x63, 0x63); + bulk_w(gspca_dev, MI_buf + 0x64, 0x64); + bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1); + kfree(MI_buf); + + intpipe = usb_sndintpipe(gspca_dev->dev, 0); + err_code = usb_clear_halt(gspca_dev->dev, intpipe); data[0] = 0x00; data[1] = 0x4d; /* ISOC transfering enable... */ - pcam_reg_write(dev, data[0], data, 2); + reg_w(gspca_dev, data[0], 2); } static void sd_stopN(struct gspca_dev *gspca_dev) { int result; - __u8 data[2]; - data[0] = 1; - data[1] = 0; - result = pcam_reg_write(gspca_dev->dev, data[0], data, 2); + gspca_dev->usb_buf[0] = 1; + gspca_dev->usb_buf[1] = 0; + result = reg_w(gspca_dev, gspca_dev->usb_buf[0], 2); if (result < 0) PDEBUG(D_ERR, "Camera Stop failed"); } diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c index ba245bafcd6..08d99c3b78e 100644 --- a/drivers/media/video/gspca/ov519.c +++ b/drivers/media/video/gspca/ov519.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("OV519 USB Camera Driver"); @@ -282,15 +282,14 @@ static unsigned char ov7670_abs_to_sm(unsigned char v) static int reg_w(struct sd *sd, __u16 index, __u8 value) { int ret; - __u8 data; - data = value; + sd->gspca_dev.usb_buf[0] = value; ret = usb_control_msg(sd->gspca_dev.dev, usb_sndctrlpipe(sd->gspca_dev.dev, 0), 1, /* REQ_IO (ov518/519) */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, index, - &data, 1, 500); + sd->gspca_dev.usb_buf, 1, 500); if (ret < 0) PDEBUG(D_ERR, "Write reg [%02x] %02x failed", index, value); return ret; @@ -301,16 +300,15 @@ static int reg_w(struct sd *sd, __u16 index, __u8 value) static int reg_r(struct sd *sd, __u16 index) { int ret; - __u8 data; ret = usb_control_msg(sd->gspca_dev.dev, usb_rcvctrlpipe(sd->gspca_dev.dev, 0), 1, /* REQ_IO */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - 0, index, &data, 1, 500); + 0, index, sd->gspca_dev.usb_buf, 1, 500); if (ret >= 0) - ret = data; + ret = sd->gspca_dev.usb_buf[0]; else PDEBUG(D_ERR, "Read reg [0x%02x] failed", index); return ret; @@ -321,16 +319,15 @@ static int reg_r8(struct sd *sd, __u16 index) { int ret; - __u8 buf[8]; ret = usb_control_msg(sd->gspca_dev.dev, usb_rcvctrlpipe(sd->gspca_dev.dev, 0), 1, /* REQ_IO */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - 0, index, &buf[0], 8, 500); + 0, index, sd->gspca_dev.usb_buf, 8, 500); if (ret >= 0) - ret = buf[0]; + ret = sd->gspca_dev.usb_buf[0]; else PDEBUG(D_ERR, "Read reg 8 [0x%02x] failed", index); return ret; diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c index 5d68d3f4226..fa7abc41109 100644 --- a/drivers/media/video/gspca/pac207.c +++ b/drivers/media/video/gspca/pac207.c @@ -27,8 +27,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Hans de Goede "); MODULE_DESCRIPTION("Pixart PAC207"); @@ -187,18 +187,18 @@ static const __u8 PacReg72[] = { 0x00, 0x00, 0x36, 0x00 }; static const unsigned char pac207_sof_marker[5] = { 0xff, 0xff, 0x00, 0xff, 0x96 }; -int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index, +static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index, const u8 *buffer, u16 length) { struct usb_device *udev = gspca_dev->dev; int err; - u8 kbuf[8]; - memcpy(kbuf, buffer, length); + memcpy(gspca_dev->usb_buf, buffer, length); err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x01, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0x00, index, kbuf, length, PAC207_CTRL_TIMEOUT); + 0x00, index, + gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT); if (err < 0) PDEBUG(D_ERR, "Failed to write registers to index 0x%04X, error %d)", @@ -227,12 +227,12 @@ int pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value) int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index) { struct usb_device *udev = gspca_dev->dev; - u8 buff; int res; res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, - 0x00, index, &buff, 1, PAC207_CTRL_TIMEOUT); + 0x00, index, + gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT); if (res < 0) { PDEBUG(D_ERR, "Failed to read a register (index 0x%04X, error %d)", @@ -240,10 +240,9 @@ int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index) return res; } - return buff; + return gspca_dev->usb_buf[0]; } - /* this function is called at probe time */ static int sd_config(struct gspca_dev *gspca_dev, const struct usb_device_id *id) diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c index 1a2347aa715..5c052e31be4 100644 --- a/drivers/media/video/gspca/pac7311.c +++ b/drivers/media/video/gspca/pac7311.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li"); MODULE_DESCRIPTION("Pixart PAC7311"); @@ -206,46 +206,43 @@ static const __u8 pac7311_jpeg_header[] = { 0x11, 0x00, 0x3f, 0x00 }; -static void reg_w(struct usb_device *dev, +static void reg_w_buf(struct gspca_dev *gspca_dev, __u16 index, const char *buffer, __u16 len) { - __u8 tmpbuf[8]; - - memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + memcpy(gspca_dev->usb_buf, buffer, len); + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 1, /* request */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, tmpbuf, len, + index, gspca_dev->usb_buf, len, 500); } -static void pac7311_reg_read(struct usb_device *dev, __u16 index, - __u8 *buffer) +static __u8 reg_r(struct gspca_dev *gspca_dev, + __u16 index) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, 1, + index, gspca_dev->usb_buf, 1, 500); + return gspca_dev->usb_buf[0]; } -static void pac7311_reg_write(struct usb_device *dev, - __u16 index, - __u8 value) +static void reg_w(struct gspca_dev *gspca_dev, + __u16 index, + __u8 value) { - __u8 buf; - - buf = value; - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + gspca_dev->usb_buf[0] = value; + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - value, index, &buf, 1, + value, index, gspca_dev->usb_buf, 1, 500); } @@ -254,20 +251,19 @@ static int sd_config(struct gspca_dev *gspca_dev, const struct usb_device_id *id) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; struct cam *cam; PDEBUG(D_CONF, "Find Sensor PAC7311"); - pac7311_reg_write(dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x27, 0x80); - pac7311_reg_write(dev, 0x28, 0xca); - pac7311_reg_write(dev, 0x29, 0x53); - pac7311_reg_write(dev, 0x2a, 0x0e); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x3e, 0x20); + reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x27, 0x80); + reg_w(gspca_dev, 0x28, 0xca); + reg_w(gspca_dev, 0x29, 0x53); + reg_w(gspca_dev, 0x2a, 0x0e); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x3e, 0x20); cam = &gspca_dev->cam; cam->dev_name = (char *) id->driver_info; @@ -289,11 +285,11 @@ static void setbrightness(struct gspca_dev *gspca_dev) /*jfm: inverted?*/ brightness = BRIGHTNESS_MAX - sd->brightness; - pac7311_reg_write(gspca_dev->dev, 0xff, 0x04); -/* pac7311_reg_write(gspca_dev->dev, 0x0e, 0x00); */ - pac7311_reg_write(gspca_dev->dev, 0x0f, brightness); + reg_w(gspca_dev, 0xff, 0x04); +/* reg_w(gspca_dev, 0x0e, 0x00); */ + reg_w(gspca_dev, 0x0f, brightness); /* load registers to sensor (Bit 0, auto clear) */ - pac7311_reg_write(gspca_dev->dev, 0x11, 0x01); + reg_w(gspca_dev, 0x11, 0x01); PDEBUG(D_CONF|D_STREAM, "brightness: %i", brightness); } @@ -301,10 +297,10 @@ static void setcontrast(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - pac7311_reg_write(gspca_dev->dev, 0xff, 0x01); - pac7311_reg_write(gspca_dev->dev, 0x80, sd->contrast); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x80, sd->contrast); /* load registers to sensor (Bit 0, auto clear) */ - pac7311_reg_write(gspca_dev->dev, 0x11, 0x01); + reg_w(gspca_dev, 0x11, 0x01); PDEBUG(D_CONF|D_STREAM, "contrast: %i", sd->contrast); } @@ -312,94 +308,93 @@ static void setcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - pac7311_reg_write(gspca_dev->dev, 0xff, 0x01); - pac7311_reg_write(gspca_dev->dev, 0x10, sd->colors); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x10, sd->colors); /* load registers to sensor (Bit 0, auto clear) */ - pac7311_reg_write(gspca_dev->dev, 0x11, 0x01); + reg_w(gspca_dev, 0x11, 0x01); PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors); } /* this function is called at open time */ static int sd_open(struct gspca_dev *gspca_dev) { - pac7311_reg_write(gspca_dev->dev, 0x78, 0x00); /* Turn on LED */ + reg_w(gspca_dev, 0x78, 0x00); /* Turn on LED */ return 0; } static void sd_start(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; struct sd *sd = (struct sd *) gspca_dev; - pac7311_reg_write(dev, 0xff, 0x01); - reg_w(dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8); - reg_w(dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8); - reg_w(dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8); - reg_w(dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8); - reg_w(dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8); - reg_w(dev, 0x002a, "\x00\x00\x00", 3); - reg_w(dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8); - reg_w(dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8); - reg_w(dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8); - reg_w(dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8); - reg_w(dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8); - reg_w(dev, 0x0066, "\xd0\xff", 2); - reg_w(dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6); - reg_w(dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8); - reg_w(dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8); - reg_w(dev, 0x008f, "\x18\x20", 2); - reg_w(dev, 0x0096, "\x01\x08\x04", 3); - reg_w(dev, 0x00a0, "\x44\x44\x44\x04", 4); - reg_w(dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8); - reg_w(dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5); - - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x02, 0x04); - pac7311_reg_write(dev, 0x03, 0x54); - pac7311_reg_write(dev, 0x04, 0x07); - pac7311_reg_write(dev, 0x05, 0x2b); - pac7311_reg_write(dev, 0x06, 0x09); - pac7311_reg_write(dev, 0x07, 0x0f); - pac7311_reg_write(dev, 0x08, 0x09); - pac7311_reg_write(dev, 0x09, 0x00); - pac7311_reg_write(dev, 0x0c, 0x07); - pac7311_reg_write(dev, 0x0d, 0x00); - pac7311_reg_write(dev, 0x0e, 0x00); - pac7311_reg_write(dev, 0x0f, 0x62); - pac7311_reg_write(dev, 0x10, 0x08); - pac7311_reg_write(dev, 0x12, 0x07); - pac7311_reg_write(dev, 0x13, 0x00); - pac7311_reg_write(dev, 0x14, 0x00); - pac7311_reg_write(dev, 0x15, 0x00); - pac7311_reg_write(dev, 0x16, 0x00); - pac7311_reg_write(dev, 0x17, 0x00); - pac7311_reg_write(dev, 0x18, 0x00); - pac7311_reg_write(dev, 0x19, 0x00); - pac7311_reg_write(dev, 0x1a, 0x00); - pac7311_reg_write(dev, 0x1b, 0x03); - pac7311_reg_write(dev, 0x1c, 0xa0); - pac7311_reg_write(dev, 0x1d, 0x01); - pac7311_reg_write(dev, 0x1e, 0xf4); - pac7311_reg_write(dev, 0x21, 0x00); - pac7311_reg_write(dev, 0x22, 0x08); - pac7311_reg_write(dev, 0x24, 0x03); - pac7311_reg_write(dev, 0x26, 0x00); - pac7311_reg_write(dev, 0x27, 0x01); - pac7311_reg_write(dev, 0x28, 0xca); - pac7311_reg_write(dev, 0x29, 0x10); - pac7311_reg_write(dev, 0x2a, 0x06); - pac7311_reg_write(dev, 0x2b, 0x78); - pac7311_reg_write(dev, 0x2c, 0x00); - pac7311_reg_write(dev, 0x2d, 0x00); - pac7311_reg_write(dev, 0x2e, 0x00); - pac7311_reg_write(dev, 0x2f, 0x00); - pac7311_reg_write(dev, 0x30, 0x23); - pac7311_reg_write(dev, 0x31, 0x28); - pac7311_reg_write(dev, 0x32, 0x04); - pac7311_reg_write(dev, 0x33, 0x11); - pac7311_reg_write(dev, 0x34, 0x00); - pac7311_reg_write(dev, 0x35, 0x00); - pac7311_reg_write(dev, 0x11, 0x01); + reg_w(gspca_dev, 0xff, 0x01); + reg_w_buf(gspca_dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8); + reg_w_buf(gspca_dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8); + reg_w_buf(gspca_dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8); + reg_w_buf(gspca_dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8); + reg_w_buf(gspca_dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8); + reg_w_buf(gspca_dev, 0x002a, "\x00\x00\x00", 3); + reg_w_buf(gspca_dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8); + reg_w_buf(gspca_dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8); + reg_w_buf(gspca_dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8); + reg_w_buf(gspca_dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8); + reg_w_buf(gspca_dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8); + reg_w_buf(gspca_dev, 0x0066, "\xd0\xff", 2); + reg_w_buf(gspca_dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6); + reg_w_buf(gspca_dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8); + reg_w_buf(gspca_dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8); + reg_w_buf(gspca_dev, 0x008f, "\x18\x20", 2); + reg_w_buf(gspca_dev, 0x0096, "\x01\x08\x04", 3); + reg_w_buf(gspca_dev, 0x00a0, "\x44\x44\x44\x04", 4); + reg_w_buf(gspca_dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8); + reg_w_buf(gspca_dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5); + + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x02, 0x04); + reg_w(gspca_dev, 0x03, 0x54); + reg_w(gspca_dev, 0x04, 0x07); + reg_w(gspca_dev, 0x05, 0x2b); + reg_w(gspca_dev, 0x06, 0x09); + reg_w(gspca_dev, 0x07, 0x0f); + reg_w(gspca_dev, 0x08, 0x09); + reg_w(gspca_dev, 0x09, 0x00); + reg_w(gspca_dev, 0x0c, 0x07); + reg_w(gspca_dev, 0x0d, 0x00); + reg_w(gspca_dev, 0x0e, 0x00); + reg_w(gspca_dev, 0x0f, 0x62); + reg_w(gspca_dev, 0x10, 0x08); + reg_w(gspca_dev, 0x12, 0x07); + reg_w(gspca_dev, 0x13, 0x00); + reg_w(gspca_dev, 0x14, 0x00); + reg_w(gspca_dev, 0x15, 0x00); + reg_w(gspca_dev, 0x16, 0x00); + reg_w(gspca_dev, 0x17, 0x00); + reg_w(gspca_dev, 0x18, 0x00); + reg_w(gspca_dev, 0x19, 0x00); + reg_w(gspca_dev, 0x1a, 0x00); + reg_w(gspca_dev, 0x1b, 0x03); + reg_w(gspca_dev, 0x1c, 0xa0); + reg_w(gspca_dev, 0x1d, 0x01); + reg_w(gspca_dev, 0x1e, 0xf4); + reg_w(gspca_dev, 0x21, 0x00); + reg_w(gspca_dev, 0x22, 0x08); + reg_w(gspca_dev, 0x24, 0x03); + reg_w(gspca_dev, 0x26, 0x00); + reg_w(gspca_dev, 0x27, 0x01); + reg_w(gspca_dev, 0x28, 0xca); + reg_w(gspca_dev, 0x29, 0x10); + reg_w(gspca_dev, 0x2a, 0x06); + reg_w(gspca_dev, 0x2b, 0x78); + reg_w(gspca_dev, 0x2c, 0x00); + reg_w(gspca_dev, 0x2d, 0x00); + reg_w(gspca_dev, 0x2e, 0x00); + reg_w(gspca_dev, 0x2f, 0x00); + reg_w(gspca_dev, 0x30, 0x23); + reg_w(gspca_dev, 0x31, 0x28); + reg_w(gspca_dev, 0x32, 0x04); + reg_w(gspca_dev, 0x33, 0x11); + reg_w(gspca_dev, 0x34, 0x00); + reg_w(gspca_dev, 0x35, 0x00); + reg_w(gspca_dev, 0x11, 0x01); setcontrast(gspca_dev); setbrightness(gspca_dev); setcolors(gspca_dev); @@ -407,39 +402,39 @@ static void sd_start(struct gspca_dev *gspca_dev) /* set correct resolution */ switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { case 2: /* 160x120 */ - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x02, 0x03); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x08, 0x09); - pac7311_reg_write(dev, 0x17, 0x20); - pac7311_reg_write(dev, 0x1b, 0x00); -/* pac7311_reg_write(dev, 0x80, 0x69); */ - pac7311_reg_write(dev, 0x87, 0x10); + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x02, 0x03); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x08, 0x09); + reg_w(gspca_dev, 0x17, 0x20); + reg_w(gspca_dev, 0x1b, 0x00); +/* reg_w(gspca_dev, 0x80, 0x69); */ + reg_w(gspca_dev, 0x87, 0x10); break; case 1: /* 320x240 */ - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x02, 0x03); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x08, 0x09); - pac7311_reg_write(dev, 0x17, 0x30); -/* pac7311_reg_write(dev, 0x80, 0x3f); */ - pac7311_reg_write(dev, 0x87, 0x11); + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x02, 0x03); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x08, 0x09); + reg_w(gspca_dev, 0x17, 0x30); +/* reg_w(gspca_dev, 0x80, 0x3f); */ + reg_w(gspca_dev, 0x87, 0x11); break; case 0: /* 640x480 */ - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x02, 0x03); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x08, 0x08); - pac7311_reg_write(dev, 0x17, 0x00); -/* pac7311_reg_write(dev, 0x80, 0x1c); */ - pac7311_reg_write(dev, 0x87, 0x12); + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x02, 0x03); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x08, 0x08); + reg_w(gspca_dev, 0x17, 0x00); +/* reg_w(gspca_dev, 0x80, 0x1c); */ + reg_w(gspca_dev, 0x87, 0x12); break; } /* start stream */ - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x78, 0x04); - pac7311_reg_write(dev, 0x78, 0x05); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x78, 0x04); + reg_w(gspca_dev, 0x78, 0x05); if (sd->autogain) { sd->ag_cnt = AG_CNT_START; @@ -451,18 +446,16 @@ static void sd_start(struct gspca_dev *gspca_dev) static void sd_stopN(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x27, 0x80); - pac7311_reg_write(dev, 0x28, 0xca); - pac7311_reg_write(dev, 0x29, 0x53); - pac7311_reg_write(dev, 0x2a, 0x0e); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x3e, 0x20); - pac7311_reg_write(dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x27, 0x80); + reg_w(gspca_dev, 0x28, 0xca); + reg_w(gspca_dev, 0x29, 0x53); + reg_w(gspca_dev, 0x2a, 0x0e); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x3e, 0x20); + reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ } static void sd_stop0(struct gspca_dev *gspca_dev) @@ -472,18 +465,16 @@ static void sd_stop0(struct gspca_dev *gspca_dev) /* this function is called at close time */ static void sd_close(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - - pac7311_reg_write(dev, 0xff, 0x04); - pac7311_reg_write(dev, 0x27, 0x80); - pac7311_reg_write(dev, 0x28, 0xca); - pac7311_reg_write(dev, 0x29, 0x53); - pac7311_reg_write(dev, 0x2a, 0x0e); - pac7311_reg_write(dev, 0xff, 0x01); - pac7311_reg_write(dev, 0x3e, 0x20); - pac7311_reg_write(dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ - pac7311_reg_write(dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x27, 0x80); + reg_w(gspca_dev, 0x28, 0xca); + reg_w(gspca_dev, 0x29, 0x53); + reg_w(gspca_dev, 0x2a, 0x0e); + reg_w(gspca_dev, 0xff, 0x01); + reg_w(gspca_dev, 0x3e, 0x20); + reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ + reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */ } static void setautogain(struct gspca_dev *gspca_dev, int luma) @@ -491,11 +482,9 @@ static void setautogain(struct gspca_dev *gspca_dev, int luma) int luma_mean = 128; int luma_delta = 20; __u8 spring = 5; - __u8 Pxclk; int Gbright; - pac7311_reg_read(gspca_dev->dev, 0x02, &Pxclk); - Gbright = Pxclk; + Gbright = reg_r(gspca_dev, 0x02); PDEBUG(D_FRAM, "luma mean %d", luma); if (luma < luma_mean - luma_delta || luma > luma_mean + luma_delta) { @@ -505,10 +494,10 @@ static void setautogain(struct gspca_dev *gspca_dev, int luma) else if (Gbright < 4) Gbright = 4; PDEBUG(D_FRAM, "gbright %d", Gbright); - pac7311_reg_write(gspca_dev->dev, 0xff, 0x04); - pac7311_reg_write(gspca_dev->dev, 0x0f, Gbright); + reg_w(gspca_dev, 0xff, 0x04); + reg_w(gspca_dev, 0x0f, Gbright); /* load registers to sensor (Bit 0, auto clear) */ - pac7311_reg_write(gspca_dev->dev, 0x11, 0x01); + reg_w(gspca_dev, 0x11, 0x01); } } @@ -623,11 +612,8 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, static void getbrightness(struct gspca_dev *gspca_dev) { -/* __u8 brightness = 0; - - pac7311_reg_read(gspca_dev->dev, 0x0008, &brightness); - spca50x->brightness = brightness; - return spca50x->brightness; */ +/* sd->brightness = reg_r(gspca_dev, 0x08); + return sd->brightness; */ /* PDEBUG(D_CONF, "Called pac7311_getbrightness: Not implemented yet"); */ } diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c index 5d231319880..ce8b28f504d 100644 --- a/drivers/media/video/gspca/sonixb.c +++ b/drivers/media/video/gspca/sonixb.c @@ -384,64 +384,82 @@ static const __u8 tas5130_sensor_init[][8] = { {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10}, }; -static void reg_r(struct usb_device *dev, - __u16 value, __u8 *buffer) +/* get one byte in gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 value) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, 0, /* index */ - buffer, 1, + gspca_dev->usb_buf, 1, 500); } -static void reg_w(struct usb_device *dev, - __u16 value, - const __u8 *buffer, - int len) +static void reg_w(struct gspca_dev *gspca_dev, + __u16 value, + const __u8 *buffer, + int len) { - __u8 tmpbuf[48]; - #ifdef CONFIG_VIDEO_ADV_DEBUG - if (len > sizeof tmpbuf) { + if (len > sizeof gspca_dev->usb_buf) { PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow"); return; } #endif + memcpy(gspca_dev->usb_buf, buffer, len); + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), + 0x08, /* request */ + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, + value, + 0, /* index */ + gspca_dev->usb_buf, len, + 500); +} + +static void reg_w_big(struct gspca_dev *gspca_dev, + __u16 value, + const __u8 *buffer, + int len) +{ + __u8 *tmpbuf; + + tmpbuf = kmalloc(len, GFP_KERNEL); memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0x08, /* request */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, 0, /* index */ tmpbuf, len, 500); + kfree(tmpbuf); } -static int i2c_w(struct usb_device *dev, const __u8 *buffer) +static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer) { int retry = 60; - __u8 ByteReceive; /* is i2c ready */ - reg_w(dev, 0x08, buffer, 8); + reg_w(gspca_dev, 0x08, buffer, 8); while (retry--) { msleep(10); - reg_r(dev, 0x08, &ByteReceive); - if (ByteReceive == 4) + reg_r(gspca_dev, 0x08); + if (gspca_dev->usb_buf[0] == 4) return 0; } return -1; } -static void i2c_w_vector(struct usb_device *dev, +static void i2c_w_vector(struct gspca_dev *gspca_dev, const __u8 buffer[][8], int len) { for (;;) { - reg_w(dev, 0x08, *buffer, 8); + reg_w(gspca_dev, 0x08, *buffer, 8); len -= 8; if (len <= 0) break; @@ -460,7 +478,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) {0xa0, 0x60, 0x06, 0x11, 0x99, 0x04, 0x94, 0x15}; i2cOV6650[3] = sd->brightness; - if (i2c_w(gspca_dev->dev, i2cOV6650) < 0) + if (i2c_w(gspca_dev, i2cOV6650) < 0) goto err; break; } @@ -470,7 +488,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) /* change reg 0x06 */ i2cOV[3] = sd->brightness; - if (i2c_w(gspca_dev->dev, i2cOV) < 0) + if (i2c_w(gspca_dev, i2cOV) < 0) goto err; break; } @@ -480,11 +498,11 @@ static void setbrightness(struct gspca_dev *gspca_dev) i2c1[3] = sd->brightness >> 3; i2c1[2] = 0x0e; - if (i2c_w(gspca_dev->dev, i2c1) < 0) + if (i2c_w(gspca_dev, i2c1) < 0) goto err; i2c1[3] = 0x01; i2c1[2] = 0x13; - if (i2c_w(gspca_dev->dev, i2c1) < 0) + if (i2c_w(gspca_dev, i2c1) < 0) goto err; break; } @@ -500,18 +518,18 @@ static void setbrightness(struct gspca_dev *gspca_dev) /* change reg 0x10 */ i2cpexpo[4] = 0xff - sd->brightness; -/* if(i2c_w(gspca_dev->dev,i2cpexpo1) < 0) +/* if(i2c_w(gspca_dev,i2cpexpo1) < 0) goto err; */ -/* if(i2c_w(gspca_dev->dev,i2cpdoit) < 0) +/* if(i2c_w(gspca_dev,i2cpdoit) < 0) goto err; */ - if (i2c_w(gspca_dev->dev, i2cpexpo) < 0) + if (i2c_w(gspca_dev, i2cpexpo) < 0) goto err; - if (i2c_w(gspca_dev->dev, i2cpdoit) < 0) + if (i2c_w(gspca_dev, i2cpdoit) < 0) goto err; i2cp202[3] = sd->brightness >> 3; - if (i2c_w(gspca_dev->dev, i2cp202) < 0) + if (i2c_w(gspca_dev, i2cp202) < 0) goto err; - if (i2c_w(gspca_dev->dev, i2cpdoit) < 0) + if (i2c_w(gspca_dev, i2cpdoit) < 0) goto err; break; } @@ -522,7 +540,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) value = 0xff - sd->brightness; i2c[4] = value; PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]); - if (i2c_w(gspca_dev->dev, i2c) < 0) + if (i2c_w(gspca_dev, i2c) < 0) goto err; break; } @@ -551,14 +569,14 @@ static void setsensorgain(struct gspca_dev *gspca_dev) {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10}; i2c[4] = 255 - gain; - if (i2c_w(gspca_dev->dev, i2c) < 0) + if (i2c_w(gspca_dev, i2c) < 0) goto err; break; } case SENSOR_OV6650: { __u8 i2c[] = {0xa0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; i2c[3] = gain; - if (i2c_w(gspca_dev->dev, i2c) < 0) + if (i2c_w(gspca_dev, i2c) < 0) goto err; break; } @@ -578,10 +596,10 @@ static void setgain(struct gspca_dev *gspca_dev) /* red and blue gain */ rgb_value = gain << 4 | gain; - reg_w(gspca_dev->dev, 0x10, &rgb_value, 1); + reg_w(gspca_dev, 0x10, &rgb_value, 1); /* green gain */ rgb_value = gain; - reg_w(gspca_dev->dev, 0x11, &rgb_value, 1); + reg_w(gspca_dev, 0x11, &rgb_value, 1); if (sd->sensor_has_gain) setsensorgain(gspca_dev); @@ -604,7 +622,7 @@ static void setexposure(struct gspca_dev *gspca_dev) if (reg > 15) reg = 15; reg = (reg << 4) | 0x0b; - reg_w(gspca_dev->dev, 0x19, ®, 1); + reg_w(gspca_dev, 0x19, ®, 1); break; } case SENSOR_OV6650: { @@ -613,7 +631,7 @@ static void setexposure(struct gspca_dev *gspca_dev) if (i2c[3] > 15) i2c[3] = 15; i2c[3] |= 0xc0; - if (i2c_w(gspca_dev->dev, i2c) < 0) + if (i2c_w(gspca_dev, i2c) < 0) PDEBUG(D_ERR, "i2c error exposure"); break; } @@ -721,22 +739,20 @@ static int sd_config(struct gspca_dev *gspca_dev, sd->exposure = EXPOSURE_DEF; sd->autogain = AUTOGAIN_DEF; if (sd->sensor == SENSOR_OV7630_3) /* jfm: from win trace */ - reg_w(gspca_dev->dev, 0x01, probe_ov7630, sizeof probe_ov7630); + reg_w(gspca_dev, 0x01, probe_ov7630, sizeof probe_ov7630); return 0; } /* this function is called at open time */ static int sd_open(struct gspca_dev *gspca_dev) { - __u8 ByteReceive; - - reg_r(gspca_dev->dev, 0x00, &ByteReceive); - if (ByteReceive != 0x10) + reg_r(gspca_dev, 0x00); + if (gspca_dev->usb_buf[0] != 0x10) return -ENODEV; return 0; } -static void pas106_i2cinit(struct usb_device *dev) +static void pas106_i2cinit(struct gspca_dev *gspca_dev) { int i; const __u8 *data; @@ -747,7 +763,7 @@ static void pas106_i2cinit(struct usb_device *dev) while (--i >= 0) { memcpy(&i2c1[2], data, 2); /* copy 2 bytes from the template */ - if (i2c_w(dev, i2c1) < 0) + if (i2c_w(gspca_dev, i2c1) < 0) PDEBUG(D_ERR, "i2c error pas106"); data += 2; } @@ -757,7 +773,6 @@ static void pas106_i2cinit(struct usb_device *dev) static void sd_start(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; int mode, l; const __u8 *sn9c10x; __u8 reg01, reg17; @@ -835,75 +850,75 @@ static void sd_start(struct gspca_dev *gspca_dev) } /* reg 0x01 bit 2 video transfert on */ - reg_w(dev, 0x01, ®01, 1); + reg_w(gspca_dev, 0x01, ®01, 1); /* reg 0x17 SensorClk enable inv Clk 0x60 */ - reg_w(dev, 0x17, ®17, 1); + reg_w(gspca_dev, 0x17, ®17, 1); /*fixme: for ov7630 102 - reg_w(dev, 0x01, {0x06, sn9c10x[1]}, 2); */ + reg_w(gspca_dev, 0x01, {0x06, sn9c10x[1]}, 2); */ /* Set the registers from the template */ - reg_w(dev, 0x01, sn9c10x, l); + reg_w_big(gspca_dev, 0x01, sn9c10x, l); switch (sd->sensor) { case SENSOR_HV7131R: - i2c_w_vector(dev, hv7131_sensor_init, + i2c_w_vector(gspca_dev, hv7131_sensor_init, sizeof hv7131_sensor_init); break; case SENSOR_OV6650: - i2c_w_vector(dev, ov6650_sensor_init, + i2c_w_vector(gspca_dev, ov6650_sensor_init, sizeof ov6650_sensor_init); break; case SENSOR_OV7630: - i2c_w_vector(dev, ov7630_sensor_init_com, + i2c_w_vector(gspca_dev, ov7630_sensor_init_com, sizeof ov7630_sensor_init_com); msleep(200); - i2c_w_vector(dev, ov7630_sensor_init, + i2c_w_vector(gspca_dev, ov7630_sensor_init, sizeof ov7630_sensor_init); break; case SENSOR_OV7630_3: - i2c_w_vector(dev, ov7630_sensor_init_com, + i2c_w_vector(gspca_dev, ov7630_sensor_init_com, sizeof ov7630_sensor_init_com); msleep(200); - i2c_w_vector(dev, ov7630_sensor_init_3, + i2c_w_vector(gspca_dev, ov7630_sensor_init_3, sizeof ov7630_sensor_init_3); break; case SENSOR_PAS106: - pas106_i2cinit(dev); + pas106_i2cinit(gspca_dev); break; case SENSOR_PAS202: - i2c_w_vector(dev, pas202_sensor_init, + i2c_w_vector(gspca_dev, pas202_sensor_init, sizeof pas202_sensor_init); break; case SENSOR_TAS5110: - i2c_w_vector(dev, tas5110_sensor_init, + i2c_w_vector(gspca_dev, tas5110_sensor_init, sizeof tas5110_sensor_init); break; default: /* case SENSOR_TAS5130CXX: */ - i2c_w_vector(dev, tas5130_sensor_init, + i2c_w_vector(gspca_dev, tas5130_sensor_init, sizeof tas5130_sensor_init); break; } /* H_size V_size 0x28, 0x1e maybe 640x480 */ - reg_w(dev, 0x15, reg15, 2); + reg_w(gspca_dev, 0x15, reg15, 2); /* compression register */ - reg_w(dev, 0x18, ®17_19[1], 1); + reg_w(gspca_dev, 0x18, ®17_19[1], 1); if (sd->sensor != SENSOR_OV7630_3) { /* H_start */ - reg_w(dev, 0x12, &sn9c10x[0x12 - 1], 1); + reg_w(gspca_dev, 0x12, &sn9c10x[0x12 - 1], 1); /* V_START */ - reg_w(dev, 0x13, &sn9c10x[0x13 - 1], 1); + reg_w(gspca_dev, 0x13, &sn9c10x[0x13 - 1], 1); } /* reset 0x17 SensorClk enable inv Clk 0x60 */ /*fixme: ov7630 [17]=68 8f (+20 if 102)*/ - reg_w(dev, 0x17, ®17_19[0], 1); + reg_w(gspca_dev, 0x17, ®17_19[0], 1); /*MCKSIZE ->3 */ /*fixme: not ov7630*/ if (sd->sensor != SENSOR_OV7630_3) - reg_w(dev, 0x19, ®17_19[2], 1); + reg_w(gspca_dev, 0x19, ®17_19[2], 1); /* AE_STRX AE_STRY AE_ENDX AE_ENDY */ - reg_w(dev, 0x1c, &sn9c10x[0x1c - 1], 4); + reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4); /* Enable video transfert */ - reg_w(dev, 0x01, &sn9c10x[0], 1); + reg_w(gspca_dev, 0x01, &sn9c10x[0], 1); /* Compression */ - reg_w(dev, 0x18, ®17_19[1], 2); + reg_w(gspca_dev, 0x18, ®17_19[1], 2); msleep(20); setgain(gspca_dev); @@ -919,7 +934,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev) __u8 ByteSend; ByteSend = 0x09; /* 0X00 */ - reg_w(gspca_dev->dev, 0x01, &ByteSend, 1); + reg_w(gspca_dev, 0x01, &ByteSend, 1); } static void sd_stop0(struct gspca_dev *gspca_dev) diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c index 4cb1421b880..30e840dca48 100644 --- a/drivers/media/video/gspca/sonixj.c +++ b/drivers/media/video/gspca/sonixj.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver"); @@ -512,42 +512,40 @@ static const __u8 qtable4[] = { 0x29, 0x29, 0x29, 0x29 }; -static void reg_r(struct usb_device *dev, - __u16 value, - __u8 *buffer, int len) +/* read bytes (len < sizeof gspca_dev->usb_buf) to gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 value, int len) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, 0, - buffer, len, + gspca_dev->usb_buf, len, 500); } -static void reg_w(struct usb_device *dev, +static void reg_w(struct gspca_dev *gspca_dev, __u16 value, const __u8 *buffer, int len) { - if (len < 16) { - __u8 tmpbuf[16]; - - memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + if (len <= sizeof gspca_dev->usb_buf) { + memcpy(gspca_dev->usb_buf, buffer, len); + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0x08, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, 0, - tmpbuf, len, + gspca_dev->usb_buf, len, 500); } else { __u8 *tmpbuf; tmpbuf = kmalloc(len, GFP_KERNEL); memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0x08, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, 0, @@ -557,12 +555,11 @@ static void reg_w(struct usb_device *dev, } } -/* write 2 bytes */ +/* I2C write 2 bytes */ static void i2c_w2(struct gspca_dev *gspca_dev, const __u8 *buffer) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 mode[8]; /* is i2c ready */ @@ -574,22 +571,21 @@ static void i2c_w2(struct gspca_dev *gspca_dev, mode[5] = 0; mode[6] = 0; mode[7] = 0x10; - reg_w(dev, 0x08, mode, 8); + reg_w(gspca_dev, 0x08, mode, 8); } -/* write 8 bytes */ -static void i2c_w8(struct usb_device *dev, const __u8 *buffer) +/* I2C write 8 bytes */ +static void i2c_w8(struct gspca_dev *gspca_dev, + const __u8 *buffer) { - reg_w(dev, 0x08, buffer, 8); + reg_w(gspca_dev, 0x08, buffer, 8); msleep(1); } -/* read 5 bytes */ -static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg, - __u8 *buffer) +/* read 5 bytes in gspca_dev->usb_buf */ +static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 mode[8]; mode[0] = sd->i2c_ctrl_reg | 0x10; @@ -600,40 +596,39 @@ static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg, mode[5] = 0; mode[6] = 0; mode[7] = 0x10; - i2c_w8(dev, mode); + i2c_w8(gspca_dev, mode); mode[0] = sd->i2c_ctrl_reg | (5 << 4) | 0x02; mode[2] = 0; - i2c_w8(dev, mode); - reg_r(dev, 0x0a, buffer, 5); + i2c_w8(gspca_dev, mode); + reg_r(gspca_dev, 0x0a, 5); } static int probesensor(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 reg02; static const __u8 datasend[] = { 2, 0 }; /* reg val1 val2 val3 val4 */ - __u8 datarecd[6]; i2c_w2(gspca_dev, datasend); /* should write 0xa1 0x11 0x02 0x00 0x00 0x00 0x00 the 0x10 is add by i2cw */ msleep(10); reg02 = 0x66; - reg_w(dev, 0x02, ®02, 1); /* Gpio on */ + reg_w(gspca_dev, 0x02, ®02, 1); /* Gpio on */ msleep(10); - i2c_r5(gspca_dev, 0, datarecd); /* read sensor id */ - if (datarecd[0] == 0x02 - && datarecd[1] == 0x09 - && datarecd[2] == 0x01 - && datarecd[3] == 0x00 - && datarecd[4] == 0x00) { + i2c_r5(gspca_dev, 0); /* read sensor id */ + if (gspca_dev->usb_buf[0] == 0x02 + && gspca_dev->usb_buf[1] == 0x09 + && gspca_dev->usb_buf[2] == 0x01 + && gspca_dev->usb_buf[3] == 0x00 + && gspca_dev->usb_buf[4] == 0x00) { PDEBUG(D_PROBE, "Find Sensor sn9c102P HV7131R"); sd->sensor = SENSOR_HV7131R; return SENSOR_HV7131R; } PDEBUG(D_PROBE, "Find Sensor %d %d %d", - datarecd[0], datarecd[1], datarecd[2]); + gspca_dev->usb_buf[0], gspca_dev->usb_buf[1], + gspca_dev->usb_buf[2]); PDEBUG(D_PROBE, "Sensor sn9c102P Not found"); return -ENODEV; } @@ -642,7 +637,6 @@ static int configure_gpio(struct gspca_dev *gspca_dev, const __u8 *sn9c1xx) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 data; __u8 regF1; const __u8 *reg9a; @@ -655,14 +649,15 @@ static int configure_gpio(struct gspca_dev *gspca_dev, regF1 = 0x00; - reg_w(dev, 0xf1, ®F1, 1); + reg_w(gspca_dev, 0xf1, ®F1, 1); - reg_w(dev, 0x01, &sn9c1xx[0], 1); /*fixme:jfm was [1] en v1*/ + reg_w(gspca_dev, 0x01, &sn9c1xx[0], 1); + /*fixme:jfm was [1] en v1*/ /* configure gpio */ - reg_w(dev, 0x01, &sn9c1xx[1], 2); - reg_w(dev, 0x08, &sn9c1xx[8], 2); - reg_w(dev, 0x17, &sn9c1xx[0x17], 3); + reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2); + reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2); + reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 3); switch (sd->customid) { case SN9C325: reg9a = reg9a_sn9c325; @@ -674,37 +669,37 @@ static int configure_gpio(struct gspca_dev *gspca_dev, reg9a = reg9a_def; break; } - reg_w(dev, 0x9a, reg9a, 6); + reg_w(gspca_dev, 0x9a, reg9a, 6); data = 0x60; /*fixme:jfm 60 00 00 (3) */ - reg_w(dev, 0xd4, &data, 1); + reg_w(gspca_dev, 0xd4, &data, 1); - reg_w(dev, 0x03, &sn9c1xx[3], 0x0f); + reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f); switch (sd->customid) { case SN9C120: /* from win trace */ data = 0x61; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); data = 0x20; - reg_w(dev, 0x17, &data, 1); + reg_w(gspca_dev, 0x17, &data, 1); data = 0x60; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); break; case SN9C325: data = 0x43; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); data = 0xae; - reg_w(dev, 0x17, &data, 1); + reg_w(gspca_dev, 0x17, &data, 1); data = 0x42; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); break; default: data = 0x43; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); data = 0x61; - reg_w(dev, 0x17, &data, 1); + reg_w(gspca_dev, 0x17, &data, 1); data = 0x42; - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &data, 1); } if (sd->sensor == SENSOR_HV7131R) { @@ -717,24 +712,22 @@ static int configure_gpio(struct gspca_dev *gspca_dev, static void hv7131R_InitSensor(struct gspca_dev *gspca_dev) { int i = 0; - struct usb_device *dev = gspca_dev->dev; static const __u8 SetSensorClk[] = /* 0x08 Mclk */ { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 }; while (hv7131r_sensor_init[i][0]) { - i2c_w8(dev, hv7131r_sensor_init[i]); + i2c_w8(gspca_dev, hv7131r_sensor_init[i]); i++; } - i2c_w8(dev, SetSensorClk); + i2c_w8(gspca_dev, SetSensorClk); } static void mi0360_InitSensor(struct gspca_dev *gspca_dev) { int i = 0; - struct usb_device *dev = gspca_dev->dev; while (mi0360_sensor_init[i][0]) { - i2c_w8(dev, mi0360_sensor_init[i]); + i2c_w8(gspca_dev, mi0360_sensor_init[i]); i++; } } @@ -742,21 +735,19 @@ static void mi0360_InitSensor(struct gspca_dev *gspca_dev) static void mo4000_InitSensor(struct gspca_dev *gspca_dev) { int i = 0; - struct usb_device *dev = gspca_dev->dev; while (mo4000_sensor_init[i][0]) { - i2c_w8(dev, mo4000_sensor_init[i]); + i2c_w8(gspca_dev, mo4000_sensor_init[i]); i++; } } static void ov7648_InitSensor(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; int i = 0; while (ov7648_sensor_init[i][0]) { - i2c_w8(dev, ov7648_sensor_init[i]); + i2c_w8(gspca_dev, ov7648_sensor_init[i]); i++; } } @@ -764,10 +755,9 @@ static void ov7648_InitSensor(struct gspca_dev *gspca_dev) static void ov7660_InitSensor(struct gspca_dev *gspca_dev) { int i = 0; - struct usb_device *dev = gspca_dev->dev; while (ov7660_sensor_init[i][0]) { - i2c_w8(dev, ov7660_sensor_init[i]); + i2c_w8(gspca_dev, ov7660_sensor_init[i]); i++; } } @@ -1005,51 +995,52 @@ static int sd_config(struct gspca_dev *gspca_dev, static int sd_open(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; /* const __u8 *sn9c1xx; */ __u8 regF1; __u8 regGpio[] = { 0x29, 0x74 }; /* setup a selector by customid */ regF1 = 0x01; - reg_w(dev, 0xf1, ®F1, 1); - reg_r(dev, 0x00, ®F1, 1); /* -> regF1 = 0x00 */ - reg_w(dev, 0xf1, ®F1, 1); - reg_r(dev, 0x00, ®F1, 1); + reg_w(gspca_dev, 0xf1, ®F1, 1); + reg_r(gspca_dev, 0x00, 1); /* -> regF1 = 0x00 */ + regF1 = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0xf1, ®F1, 1); + reg_r(gspca_dev, 0x00, 1); + regF1 = gspca_dev->usb_buf[0]; switch (sd->customid) { case SN9C102P: if (regF1 != 0x11) return -ENODEV; - reg_w(dev, 0x02, ®Gpio[1], 1); + reg_w(gspca_dev, 0x02, ®Gpio[1], 1); break; case SN9C105: if (regF1 != 0x11) return -ENODEV; - reg_w(dev, 0x02, regGpio, 2); + reg_w(gspca_dev, 0x02, regGpio, 2); break; case SN9C110: if (regF1 != 0x12) return -ENODEV; regGpio[1] = 0x62; - reg_w(dev, 0x02, ®Gpio[1], 1); + reg_w(gspca_dev, 0x02, ®Gpio[1], 1); break; case SN9C120: if (regF1 != 0x12) return -ENODEV; regGpio[1] = 0x70; - reg_w(dev, 0x02, regGpio, 2); + reg_w(gspca_dev, 0x02, regGpio, 2); break; default: /* case SN9C325: */ if (regF1 != 0x12) return -ENODEV; regGpio[1] = 0x62; - reg_w(dev, 0x02, ®Gpio[1], 1); + reg_w(gspca_dev, 0x02, ®Gpio[1], 1); break; } regF1 = 0x01; - reg_w(dev, 0xf1, ®F1, 1); + reg_w(gspca_dev, 0xf1, ®F1, 1); return 0; } @@ -1073,7 +1064,7 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev, Expodoit[3] = expo >> 16; Expodoit[4] = expo >> 8; Expodoit[5] = expo; - i2c_w8(gspca_dev->dev, Expodoit); + i2c_w8(gspca_dev, Expodoit); break; } case SENSOR_MI0360: { @@ -1086,9 +1077,9 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev, expo = 0x0001; expoMi[3] = expo >> 8; expoMi[4] = expo; - i2c_w8(gspca_dev->dev, expoMi); - i2c_w8(gspca_dev->dev, doit); - i2c_w8(gspca_dev->dev, sensorgo); + i2c_w8(gspca_dev, expoMi); + i2c_w8(gspca_dev, doit); + i2c_w8(gspca_dev, sensorgo); break; } case SENSOR_MO4000: { @@ -1102,11 +1093,11 @@ static unsigned int setexposure(struct gspca_dev *gspca_dev, else if (expo < 0x0001) expo = 0x0001; expoMof[3] = (expo & 0x03fc) >> 2; - i2c_w8(gspca_dev->dev, expoMof); + i2c_w8(gspca_dev, expoMof); expoMo10[3] = ((expo & 0x1c00) >> 10) | ((expo & 0x0003) << 4); - i2c_w8(gspca_dev->dev, expoMo10); - i2c_w8(gspca_dev->dev, gainMo); + i2c_w8(gspca_dev, expoMo10); + i2c_w8(gspca_dev, gainMo); PDEBUG(D_CONF, "set exposure %d", ((expoMo10[3] & 0x07) << 10) | (expoMof[3] << 2) @@ -1145,7 +1136,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) } k2 = sd->brightness >> 10; - reg_w(gspca_dev->dev, 0x96, &k2, 1); + reg_w(gspca_dev, 0x96, &k2, 1); } static void setcontrast(struct gspca_dev *gspca_dev) @@ -1160,7 +1151,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) contrast[2] = k2; contrast[0] = (k2 + 1) >> 1; contrast[4] = (k2 + 1) / 5; - reg_w(gspca_dev->dev, 0x84, contrast, 6); + reg_w(gspca_dev, 0x84, contrast, 6); } static void setcolors(struct gspca_dev *gspca_dev) @@ -1174,14 +1165,13 @@ static void setcolors(struct gspca_dev *gspca_dev) data = (colour + 32) & 0x7f; /* blue */ else data = (-colour + 32) & 0x7f; /* red */ - reg_w(gspca_dev->dev, 0x05, &data, 1); + reg_w(gspca_dev, 0x05, &data, 1); } /* -- start the camera -- */ static void sd_start(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; int i; __u8 data; __u8 reg1; @@ -1203,45 +1193,45 @@ static void sd_start(struct gspca_dev *gspca_dev) /*fixme:jfm this sequence should appear at end of sd_start */ /* with data = 0x44; - reg_w(dev, 0x01, &data, 1); */ - reg_w(dev, 0x15, &sn9c1xx[0x15], 1); - reg_w(dev, 0x16, &sn9c1xx[0x16], 1); - reg_w(dev, 0x12, &sn9c1xx[0x12], 1); - reg_w(dev, 0x13, &sn9c1xx[0x13], 1); - reg_w(dev, 0x18, &sn9c1xx[0x18], 1); - reg_w(dev, 0xd2, &DC29[0], 1); - reg_w(dev, 0xd3, &DC29[1], 1); - reg_w(dev, 0xc6, &DC29[2], 1); - reg_w(dev, 0xc7, &DC29[3], 1); - reg_w(dev, 0xc8, &DC29[4], 1); - reg_w(dev, 0xc9, &DC29[5], 1); + reg_w(gspca_dev, 0x01, &data, 1); */ + reg_w(gspca_dev, 0x15, &sn9c1xx[0x15], 1); + reg_w(gspca_dev, 0x16, &sn9c1xx[0x16], 1); + reg_w(gspca_dev, 0x12, &sn9c1xx[0x12], 1); + reg_w(gspca_dev, 0x13, &sn9c1xx[0x13], 1); + reg_w(gspca_dev, 0x18, &sn9c1xx[0x18], 1); + reg_w(gspca_dev, 0xd2, &DC29[0], 1); + reg_w(gspca_dev, 0xd3, &DC29[1], 1); + reg_w(gspca_dev, 0xc6, &DC29[2], 1); + reg_w(gspca_dev, 0xc7, &DC29[3], 1); + reg_w(gspca_dev, 0xc8, &DC29[4], 1); + reg_w(gspca_dev, 0xc9, &DC29[5], 1); /*fixme:jfm end of ending sequence */ - reg_w(dev, 0x18, &sn9c1xx[0x18], 1); + reg_w(gspca_dev, 0x18, &sn9c1xx[0x18], 1); if (sd->customid == SN9C325) data = 0xae; else data = 0x60; - reg_w(dev, 0x17, &data, 1); - reg_w(dev, 0x05, &sn9c1xx[5], 1); - reg_w(dev, 0x07, &sn9c1xx[7], 1); - reg_w(dev, 0x06, &sn9c1xx[6], 1); - reg_w(dev, 0x14, &sn9c1xx[0x14], 1); + reg_w(gspca_dev, 0x17, &data, 1); + reg_w(gspca_dev, 0x05, &sn9c1xx[5], 1); + reg_w(gspca_dev, 0x07, &sn9c1xx[7], 1); + reg_w(gspca_dev, 0x06, &sn9c1xx[6], 1); + reg_w(gspca_dev, 0x14, &sn9c1xx[0x14], 1); if (sd->customid == SN9C325) { - reg_w(dev, 0x20, regsn20_sn9c325, 0x11); + reg_w(gspca_dev, 0x20, regsn20_sn9c325, 0x11); for (i = 0; i < 8; i++) - reg_w(dev, 0x84, reg84_sn9c325, 0x15); + reg_w(gspca_dev, 0x84, reg84_sn9c325, 0x15); data = 0x0a; - reg_w(dev, 0x9a, &data, 1); + reg_w(gspca_dev, 0x9a, &data, 1); data = 0x60; - reg_w(dev, 0x99, &data, 1); + reg_w(gspca_dev, 0x99, &data, 1); } else { - reg_w(dev, 0x20, regsn20, 0x11); + reg_w(gspca_dev, 0x20, regsn20, 0x11); for (i = 0; i < 8; i++) - reg_w(dev, 0x84, reg84, 0x15); + reg_w(gspca_dev, 0x84, reg84, 0x15); data = 0x08; - reg_w(dev, 0x9a, &data, 1); + reg_w(gspca_dev, 0x9a, &data, 1); data = 0x59; - reg_w(dev, 0x99, &data, 1); + reg_w(gspca_dev, 0x99, &data, 1); } mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; @@ -1294,38 +1284,38 @@ static void sd_start(struct gspca_dev *gspca_dev) } break; } - reg_w(dev, 0xc0, C0, 6); + reg_w(gspca_dev, 0xc0, C0, 6); switch (sd->customid) { case SN9C120: /*jfm ?? */ - reg_w(dev, 0xca, CA_sn9c120, 4); + reg_w(gspca_dev, 0xca, CA_sn9c120, 4); break; default: - reg_w(dev, 0xca, CA, 4); + reg_w(gspca_dev, 0xca, CA, 4); break; } switch (sd->customid) { case SN9C120: /*jfm ?? */ case SN9C325: - reg_w(dev, 0xce, CE_sn9c325, 4); + reg_w(gspca_dev, 0xce, CE_sn9c325, 4); break; default: - reg_w(dev, 0xce, CE, 4); + reg_w(gspca_dev, 0xce, CE, 4); /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */ break; } /* here change size mode 0 -> VGA; 1 -> CIF */ data = 0x40 | sn9c1xx[0x18] | (mode << 4); - reg_w(dev, 0x18, &data, 1); + reg_w(gspca_dev, 0x18, &data, 1); - reg_w(dev, 0x100, qtable4, 0x40); - reg_w(dev, 0x140, qtable4 + 0x40, 0x40); + reg_w(gspca_dev, 0x100, qtable4, 0x40); + reg_w(gspca_dev, 0x140, qtable4 + 0x40, 0x40); data = sn9c1xx[0x18] | (mode << 4); - reg_w(dev, 0x18, &data, 1); + reg_w(gspca_dev, 0x18, &data, 1); - reg_w(dev, 0x17, ®17, 1); - reg_w(dev, 0x01, ®1, 1); + reg_w(gspca_dev, 0x17, ®17, 1); + reg_w(gspca_dev, 0x01, ®1, 1); setbrightness(gspca_dev); setcontrast(gspca_dev); } @@ -1333,7 +1323,6 @@ static void sd_start(struct gspca_dev *gspca_dev) static void sd_stopN(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; static const __u8 stophv7131[] = { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 }; static const __u8 stopmi0360[] = @@ -1345,11 +1334,11 @@ static void sd_stopN(struct gspca_dev *gspca_dev) data = 0x0b; switch (sd->sensor) { case SENSOR_HV7131R: - i2c_w8(dev, stophv7131); + i2c_w8(gspca_dev, stophv7131); data = 0x2b; break; case SENSOR_MI0360: - i2c_w8(dev, stopmi0360); + i2c_w8(gspca_dev, stopmi0360); data = 0x29; break; case SENSOR_MO4000: @@ -1362,12 +1351,12 @@ static void sd_stopN(struct gspca_dev *gspca_dev) break; } sn9c1xx = sn_tb[(int) sd->sensor]; - reg_w(dev, 0x01, &sn9c1xx[1], 1); - reg_w(dev, 0x17, &sn9c1xx[0x17], 1); - reg_w(dev, 0x01, &sn9c1xx[1], 1); - reg_w(dev, 0x01, &data, 1); + reg_w(gspca_dev, 0x01, &sn9c1xx[1], 1); + reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 1); + reg_w(gspca_dev, 0x01, &sn9c1xx[1], 1); + reg_w(gspca_dev, 0x01, &data, 1); regF1 = 0x01; - reg_w(dev, 0xf1, ®F1, 1); + reg_w(gspca_dev, 0xf1, ®F1, 1); } static void sd_stop0(struct gspca_dev *gspca_dev) @@ -1463,33 +1452,35 @@ static unsigned int getexposure(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; __u8 hexpo, mexpo, lexpo; - __u8 expo[6]; switch (sd->sensor) { case SENSOR_HV7131R: /* read sensor exposure */ - i2c_r5(gspca_dev, 0x25, expo); - return (expo[0] << 16) | (expo[1] << 8) | expo[2]; + i2c_r5(gspca_dev, 0x25); + return (gspca_dev->usb_buf[0] << 16) + | (gspca_dev->usb_buf[1] << 8) + | gspca_dev->usb_buf[2]; case SENSOR_MI0360: /* read sensor exposure */ - i2c_r5(gspca_dev, 0x09, expo); - return (expo[0] << 8) | expo[1]; + i2c_r5(gspca_dev, 0x09); + return (gspca_dev->usb_buf[0] << 8) + | gspca_dev->usb_buf[1]; case SENSOR_MO4000: - i2c_r5(gspca_dev, 0x0e, expo); - hexpo = 0; /* expo[1] & 0x07; */ - mexpo = 0x40; /* expo[2] &0xff; */ - lexpo = (expo[1] & 0x30) >> 4; + i2c_r5(gspca_dev, 0x0e); + hexpo = 0; /* gspca_dev->usb_buf[1] & 0x07; */ + mexpo = 0x40; /* gspca_dev->usb_buf[2] & 0xff; */ + lexpo = (gspca_dev->usb_buf[1] & 0x30) >> 4; PDEBUG(D_CONF, "exposure %d", (hexpo << 10) | (mexpo << 2) | lexpo); return (hexpo << 10) | (mexpo << 2) | lexpo; default: /* case SENSOR_OV7660: */ /* read sensor exposure */ - i2c_r5(gspca_dev, 0x04, expo); - hexpo = expo[3] & 0x2f; - lexpo = expo[0] & 0x02; - i2c_r5(gspca_dev, 0x08, expo); - mexpo = expo[2]; + i2c_r5(gspca_dev, 0x04); + hexpo = gspca_dev->usb_buf[3] & 0x2f; + lexpo = gspca_dev->usb_buf[0] & 0x02; + i2c_r5(gspca_dev, 0x08); + mexpo = gspca_dev->usb_buf[2]; return (hexpo << 10) | (mexpo << 2) | lexpo; } } diff --git a/drivers/media/video/gspca/spca500.c b/drivers/media/video/gspca/spca500.c index d00f0f76e0e..15620611879 100644 --- a/drivers/media/video/gspca/spca500.c +++ b/drivers/media/video/gspca/spca500.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver"); @@ -372,26 +372,27 @@ static const __u8 qtable_pocketdv[2][64] = { 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28} }; -static void reg_r(struct usb_device *dev, - __u16 index, - __u8 *buffer, __u16 length) +/* read 'len' bytes to gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 index, + __u16 length) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, length, 500); + index, gspca_dev->usb_buf, length, 500); } -static int reg_w(struct usb_device *dev, +static int reg_w(struct gspca_dev *gspca_dev, __u16 req, __u16 index, __u16 value) { int ret; PDEBUG(D_USBO, "reg write: [0x%02x] = 0x%02x", index, value); - ret = usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + ret = usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), req, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, index, NULL, 0, 500); @@ -401,28 +402,27 @@ static int reg_w(struct usb_device *dev, } /* returns: negative is error, pos or zero is data */ -static int reg_r_12(struct usb_device *dev, +static int reg_r_12(struct gspca_dev *gspca_dev, __u16 req, /* bRequest */ __u16 index, /* wIndex */ __u16 length) /* wLength (1 or 2 only) */ { int ret; - __u8 buf[2]; - buf[1] = 0; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + gspca_dev->usb_buf[1] = 0; + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), req, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ index, - buf, length, + gspca_dev->usb_buf, length, 500); /* timeout */ if (ret < 0) { PDEBUG(D_ERR, "reg_r_12 err %d", ret); return -1; } - return (buf[1] << 8) + buf[0]; + return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0]; } /* @@ -430,13 +430,13 @@ static int reg_r_12(struct usb_device *dev, * a reg_read call. * Returns: negative is error or timeout, zero is success. */ -static int reg_r_wait(struct usb_device *dev, +static int reg_r_wait(struct gspca_dev *gspca_dev, __u16 reg, __u16 index, __u16 value) { int ret, cnt = 20; while (--cnt > 0) { - ret = reg_r_12(dev, reg, index, 1); + ret = reg_r_12(gspca_dev, reg, index, 1); if (ret == value) return 0; msleep(50); @@ -447,11 +447,10 @@ static int reg_r_wait(struct usb_device *dev, static int write_vector(struct gspca_dev *gspca_dev, const __u16 data[][3]) { - struct usb_device *dev = gspca_dev->dev; int ret, i = 0; while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) { - ret = reg_w(dev, data[i][0], data[i][2], data[i][1]); + ret = reg_w(gspca_dev, data[i][0], data[i][2], data[i][1]); if (ret < 0) return ret; i++; @@ -465,19 +464,18 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev, unsigned int cbase, const __u8 qtable[2][64]) { - struct usb_device *dev = gspca_dev->dev; int i, err; /* loop over y components */ for (i = 0; i < 64; i++) { - err = reg_w(dev, request, ybase + i, qtable[0][i]); + err = reg_w(gspca_dev, request, ybase + i, qtable[0][i]); if (err < 0) return err; } /* loop over c components */ for (i = 0; i < 64; i++) { - err = reg_w(dev, request, cbase + i, qtable[1][i]); + err = reg_w(gspca_dev, request, cbase + i, qtable[1][i]); if (err < 0) return err; } @@ -486,37 +484,33 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev, static void spca500_ping310(struct gspca_dev *gspca_dev) { - __u8 Data[2]; - - reg_r(gspca_dev->dev, 0x0d04, Data, 2); + reg_r(gspca_dev, 0x0d04, 2); PDEBUG(D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x", - Data[0], Data[1]); + gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]); } static void spca500_clksmart310_init(struct gspca_dev *gspca_dev) { - __u8 Data[2]; - - reg_r(gspca_dev->dev, 0x0d05, Data, 2); + reg_r(gspca_dev, 0x0d05, 2); PDEBUG(D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x", - Data[0], Data[1]); - reg_w(gspca_dev->dev, 0x00, 0x8167, 0x5a); + gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]); + reg_w(gspca_dev, 0x00, 0x8167, 0x5a); spca500_ping310(gspca_dev); - reg_w(gspca_dev->dev, 0x00, 0x8168, 0x22); - reg_w(gspca_dev->dev, 0x00, 0x816a, 0xc0); - reg_w(gspca_dev->dev, 0x00, 0x816b, 0x0b); - reg_w(gspca_dev->dev, 0x00, 0x8169, 0x25); - reg_w(gspca_dev->dev, 0x00, 0x8157, 0x5b); - reg_w(gspca_dev->dev, 0x00, 0x8158, 0x5b); - reg_w(gspca_dev->dev, 0x00, 0x813f, 0x03); - reg_w(gspca_dev->dev, 0x00, 0x8151, 0x4a); - reg_w(gspca_dev->dev, 0x00, 0x8153, 0x78); - reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x04); + reg_w(gspca_dev, 0x00, 0x8168, 0x22); + reg_w(gspca_dev, 0x00, 0x816a, 0xc0); + reg_w(gspca_dev, 0x00, 0x816b, 0x0b); + reg_w(gspca_dev, 0x00, 0x8169, 0x25); + reg_w(gspca_dev, 0x00, 0x8157, 0x5b); + reg_w(gspca_dev, 0x00, 0x8158, 0x5b); + reg_w(gspca_dev, 0x00, 0x813f, 0x03); + reg_w(gspca_dev, 0x00, 0x8151, 0x4a); + reg_w(gspca_dev, 0x00, 0x8153, 0x78); + reg_w(gspca_dev, 0x00, 0x0d01, 0x04); /* 00 for adjust shutter */ - reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01); - reg_w(gspca_dev->dev, 0x00, 0x8169, 0x25); - reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x02); + reg_w(gspca_dev, 0x00, 0x0d02, 0x01); + reg_w(gspca_dev, 0x00, 0x8169, 0x25); + reg_w(gspca_dev, 0x00, 0x0d01, 0x02); } static void spca500_setmode(struct gspca_dev *gspca_dev, @@ -525,14 +519,14 @@ static void spca500_setmode(struct gspca_dev *gspca_dev, int mode; /* set x multiplier */ - reg_w(gspca_dev->dev, 0, 0x8001, xmult); + reg_w(gspca_dev, 0, 0x8001, xmult); /* set y multiplier */ - reg_w(gspca_dev->dev, 0, 0x8002, ymult); + reg_w(gspca_dev, 0, 0x8002, ymult); /* use compressed mode, VGA, with mode specific subsample */ mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; - reg_w(gspca_dev->dev, 0, 0x8003, mode << 4); + reg_w(gspca_dev, 0, 0x8003, mode << 4); } static int spca500_full_reset(struct gspca_dev *gspca_dev) @@ -540,18 +534,18 @@ static int spca500_full_reset(struct gspca_dev *gspca_dev) int err; /* send the reset command */ - err = reg_w(gspca_dev->dev, 0xe0, 0x0001, 0x0000); + err = reg_w(gspca_dev, 0xe0, 0x0001, 0x0000); if (err < 0) return err; /* wait for the reset to complete */ - err = reg_r_wait(gspca_dev->dev, 0x06, 0x0000, 0x0000); + err = reg_r_wait(gspca_dev, 0x06, 0x0000, 0x0000); if (err < 0) return err; - err = reg_w(gspca_dev->dev, 0xe0, 0x0000, 0x0000); + err = reg_w(gspca_dev, 0xe0, 0x0000, 0x0000); if (err < 0) return err; - err = reg_r_wait(gspca_dev->dev, 0x06, 0, 0); + err = reg_r_wait(gspca_dev, 0x06, 0, 0); if (err < 0) { PDEBUG(D_ERR, "reg_r_wait() failed"); return err; @@ -568,15 +562,13 @@ static int spca500_full_reset(struct gspca_dev *gspca_dev) /* up-port the same feature as in 2.4.x kernel */ static int spca500_synch310(struct gspca_dev *gspca_dev) { - __u8 Data; - if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0) < 0) { PDEBUG(D_ERR, "Set packet size: set interface error"); goto error; } spca500_ping310(gspca_dev); - reg_r(gspca_dev->dev, 0x0d00, &Data, 1); + reg_r(gspca_dev, 0x0d00, 1); /* need alt setting here */ PDEBUG(D_PACK, "ClickSmart310 sync alt: %d", gspca_dev->alt); @@ -600,12 +592,12 @@ static void spca500_reinit(struct gspca_dev *gspca_dev) /* some unknow command from Aiptek pocket dv and family300 */ - reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01); - reg_w(gspca_dev->dev, 0x00, 0x0d03, 0x00); - reg_w(gspca_dev->dev, 0x00, 0x0d02, 0x01); + reg_w(gspca_dev, 0x00, 0x0d01, 0x01); + reg_w(gspca_dev, 0x00, 0x0d03, 0x00); + reg_w(gspca_dev, 0x00, 0x0d02, 0x01); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_pocketdv); @@ -613,22 +605,23 @@ static void spca500_reinit(struct gspca_dev *gspca_dev) PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed on init"); /* set qtable index */ - reg_w(gspca_dev->dev, 0x00, 0x8880, 2); + reg_w(gspca_dev, 0x00, 0x8880, 2); /* family cam Quicksmart stuff */ - reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00); + reg_w(gspca_dev, 0x00, 0x800a, 0x00); /* Set agc transfer: synced inbetween frames */ - reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01); + reg_w(gspca_dev, 0x00, 0x820f, 0x01); /* Init SDRAM - needed for SDRAM access */ - reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04); + reg_w(gspca_dev, 0x00, 0x870a, 0x04); /*Start init sequence or stream */ - - reg_w(gspca_dev->dev, 0, 0x8003, 0x00); + reg_w(gspca_dev, 0, 0x8003, 0x00); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); msleep(2000); - if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0) - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) { + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); + } } /* this function is called at probe time */ @@ -785,9 +778,10 @@ static void sd_start(struct gspca_dev *gspca_dev) } /* is there a sensor here ? */ - reg_r(gspca_dev->dev, 0x8a04, &Data, 1); - PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02X", Data); - PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02X, Ymult: 0x%02X", + reg_r(gspca_dev, 0x8a04, 1); + PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02x", + gspca_dev->usb_buf[0]); + PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x", gspca_dev->curr_mode, xmult, ymult); /* setup qtable */ @@ -796,33 +790,34 @@ static void sd_start(struct gspca_dev *gspca_dev) spca500_setmode(gspca_dev, xmult, ymult); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); - reg_w(gspca_dev->dev, 0x00, 0x8880, 3); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x8880, 3); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_creative_pccam); if (err < 0) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); /* Init SDRAM - needed for SDRAM access */ - reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04); + reg_w(gspca_dev, 0x00, 0x870a, 0x04); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); msleep(500); - if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0) + if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) PDEBUG(D_ERR, "reg_r_wait() failed"); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); spca500_synch310(gspca_dev); write_vector(gspca_dev, spca500_visual_defaults); spca500_setmode(gspca_dev, xmult, ymult); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); PDEBUG(D_ERR, "failed to enable drop packet"); - reg_w(gspca_dev->dev, 0x00, 0x8880, 3); + reg_w(gspca_dev, 0x00, 0x8880, 3); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_creative_pccam); @@ -830,16 +825,17 @@ static void sd_start(struct gspca_dev *gspca_dev) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); /* Init SDRAM - needed for SDRAM access */ - reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04); + reg_w(gspca_dev, 0x00, 0x870a, 0x04); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); - if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0) + if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) PDEBUG(D_ERR, "reg_r_wait() failed"); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); break; case CreativePCCam300: /* Creative PC-CAM 300 640x480 CCD */ case IntelPocketPCCamera: /* FIXME: Temporary fix for @@ -852,10 +848,10 @@ static void sd_start(struct gspca_dev *gspca_dev) PDEBUG(D_ERR, "spca500_full_reset failed"); /* enable drop packet */ - err = reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); + err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001); if (err < 0) PDEBUG(D_ERR, "failed to enable drop packet"); - reg_w(gspca_dev->dev, 0x00, 0x8880, 3); + reg_w(gspca_dev, 0x00, 0x8880, 3); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_creative_pccam); @@ -863,16 +859,17 @@ static void sd_start(struct gspca_dev *gspca_dev) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); spca500_setmode(gspca_dev, xmult, ymult); - reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004); + reg_w(gspca_dev, 0x20, 0x0001, 0x0004); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); - if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0) + if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) PDEBUG(D_ERR, "reg_r_wait() failed"); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); /* write_vector(gspca_dev, spca500_visual_defaults); */ break; @@ -883,8 +880,8 @@ static void sd_start(struct gspca_dev *gspca_dev) if (err < 0) PDEBUG(D_ERR, "spca500_full_reset failed"); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); - reg_w(gspca_dev->dev, 0x00, 0x8880, 0); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x8880, 0); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_kodak_ez200); @@ -892,16 +889,17 @@ static void sd_start(struct gspca_dev *gspca_dev) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); spca500_setmode(gspca_dev, xmult, ymult); - reg_w(gspca_dev->dev, 0x20, 0x0001, 0x0004); + reg_w(gspca_dev, 0x20, 0x0001, 0x0004); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); - if (reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44) != 0) + if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) PDEBUG(D_ERR, "reg_r_wait() failed"); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); /* write_vector(gspca_dev, spca500_visual_defaults); */ break; @@ -916,56 +914,58 @@ static void sd_start(struct gspca_dev *gspca_dev) case ToptroIndus: case AgfaCl20: spca500_reinit(gspca_dev); - reg_w(gspca_dev->dev, 0x00, 0x0d01, 0x01); + reg_w(gspca_dev, 0x00, 0x0d01, 0x01); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_pocketdv); if (err < 0) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); - reg_w(gspca_dev->dev, 0x00, 0x8880, 2); + reg_w(gspca_dev, 0x00, 0x8880, 2); /* familycam Quicksmart pocketDV stuff */ - reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00); + reg_w(gspca_dev, 0x00, 0x800a, 0x00); /* Set agc transfer: synced inbetween frames */ - reg_w(gspca_dev->dev, 0x00, 0x820f, 0x01); + reg_w(gspca_dev, 0x00, 0x820f, 0x01); /* Init SDRAM - needed for SDRAM access */ - reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04); + reg_w(gspca_dev, 0x00, 0x870a, 0x04); spca500_setmode(gspca_dev, xmult, ymult); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); - reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44); + reg_r_wait(gspca_dev, 0, 0x8000, 0x44); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); break; case LogitechTraveler: case LogitechClickSmart510: - reg_w(gspca_dev->dev, 0x02, 0x00, 0x00); + reg_w(gspca_dev, 0x02, 0x00, 0x00); /* enable drop packet */ - reg_w(gspca_dev->dev, 0x00, 0x850a, 0x0001); + reg_w(gspca_dev, 0x00, 0x850a, 0x0001); err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840, qtable_creative_pccam); if (err < 0) PDEBUG(D_ERR, "spca50x_setup_qtable failed"); - reg_w(gspca_dev->dev, 0x00, 0x8880, 3); - reg_w(gspca_dev->dev, 0x00, 0x800a, 0x00); + reg_w(gspca_dev, 0x00, 0x8880, 3); + reg_w(gspca_dev, 0x00, 0x800a, 0x00); /* Init SDRAM - needed for SDRAM access */ - reg_w(gspca_dev->dev, 0x00, 0x870a, 0x04); + reg_w(gspca_dev, 0x00, 0x870a, 0x04); spca500_setmode(gspca_dev, xmult, ymult); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); - reg_r_wait(gspca_dev->dev, 0, 0x8000, 0x44); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); + reg_r_wait(gspca_dev, 0, 0x8000, 0x44); - reg_r(gspca_dev->dev, 0x816b, &Data, 1); - reg_w(gspca_dev->dev, 0x00, 0x816b, Data); + reg_r(gspca_dev, 0x816b, 1); + Data = gspca_dev->usb_buf[0]; + reg_w(gspca_dev, 0x00, 0x816b, Data); write_vector(gspca_dev, Clicksmart510_defaults); break; } @@ -973,14 +973,13 @@ static void sd_start(struct gspca_dev *gspca_dev) static void sd_stopN(struct gspca_dev *gspca_dev) { - __u8 data; - - reg_w(gspca_dev->dev, 0, 0x8003, 0x00); + reg_w(gspca_dev, 0, 0x8003, 0x00); /* switch to video camera mode */ - reg_w(gspca_dev->dev, 0x00, 0x8000, 0x0004); - reg_r(gspca_dev->dev, 0x8000, &data, 1); - PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x", data); + reg_w(gspca_dev, 0x00, 0x8000, 0x0004); + reg_r(gspca_dev, 0x8000, 1); + PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x", + gspca_dev->usb_buf[0]); } static void sd_stop0(struct gspca_dev *gspca_dev) @@ -1043,7 +1042,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - reg_w(gspca_dev->dev, 0x00, 0x8167, + reg_w(gspca_dev, 0x00, 0x8167, (__u8) (sd->brightness - 128)); } @@ -1052,7 +1051,7 @@ static void getbrightness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; int ret; - ret = reg_r_12(gspca_dev->dev, 0x00, 0x8167, 1); + ret = reg_r_12(gspca_dev, 0x00, 0x8167, 1); if (ret >= 0) sd->brightness = ret + 128; } @@ -1061,7 +1060,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - reg_w(gspca_dev->dev, 0x00, 0x8168, sd->contrast); + reg_w(gspca_dev, 0x00, 0x8168, sd->contrast); } static void getcontrast(struct gspca_dev *gspca_dev) @@ -1069,7 +1068,7 @@ static void getcontrast(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; int ret; - ret = reg_r_12(gspca_dev->dev, 0x0, 0x8168, 1); + ret = reg_r_12(gspca_dev, 0x0, 0x8168, 1); if (ret >= 0) sd->contrast = ret; } @@ -1078,7 +1077,7 @@ static void setcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - reg_w(gspca_dev->dev, 0x00, 0x8169, sd->colors); + reg_w(gspca_dev, 0x00, 0x8169, sd->colors); } static void getcolors(struct gspca_dev *gspca_dev) @@ -1086,7 +1085,7 @@ static void getcolors(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; int ret; - ret = reg_r_12(gspca_dev->dev, 0x0, 0x8169, 1); + ret = reg_r_12(gspca_dev, 0x0, 0x8169, 1); if (ret >= 0) sd->colors = ret; } diff --git a/drivers/media/video/gspca/spca501.c b/drivers/media/video/gspca/spca501.c index 2064dc008af..8cee6748d38 100644 --- a/drivers/media/video/gspca/spca501.c +++ b/drivers/media/video/gspca/spca501.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA501 USB Camera Driver"); @@ -1826,28 +1826,27 @@ static int reg_write(struct usb_device *dev, } /* returns: negative is error, pos or zero is data */ -static int reg_read(struct usb_device *dev, +static int reg_read(struct gspca_dev *gspca_dev, __u16 req, /* bRequest */ __u16 index, /* wIndex */ __u16 length) /* wLength (1 or 2 only) */ { int ret; - __u8 buf[2]; - buf[1] = 0; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + gspca_dev->usb_buf[1] = 0; + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), req, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ index, - buf, length, + gspca_dev->usb_buf, length, 500); /* timeout */ if (ret < 0) { PDEBUG(D_ERR, "reg_read err %d", ret); return -1; } - return (buf[1] << 8) + buf[0]; + return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0]; } static int write_vector(struct gspca_dev *gspca_dev, @@ -1883,7 +1882,7 @@ static void getbrightness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; __u16 brightness; - brightness = reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x11, 2); + brightness = reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x11, 2); sd->brightness = brightness << 1; } @@ -1913,8 +1912,8 @@ static void getcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - sd->colors = reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x0c, 2); -/* sd->hue = (reg_read(gspca_dev->dev, SPCA501_REG_CCDSP, 0x13, */ + sd->colors = reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x0c, 2); +/* sd->hue = (reg_read(gspca_dev, SPCA501_REG_CCDSP, 0x13, */ /* 2) & 0xFF) << 8; */ } diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c index 5d28d23b837..ddea6e140aa 100644 --- a/drivers/media/video/gspca/spca505.c +++ b/drivers/media/video/gspca/spca505.c @@ -23,8 +23,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver"); @@ -593,29 +593,27 @@ static int reg_write(struct usb_device *dev, } /* returns: negative is error, pos or zero is data */ -static int reg_read(struct usb_device *dev, +static int reg_read(struct gspca_dev *gspca_dev, __u16 reg, /* bRequest */ __u16 index, /* wIndex */ __u16 length) /* wLength (1 or 2 only) */ { int ret; - __u8 buf[4]; - buf[1] = 0; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + gspca_dev->usb_buf[1] = 0; + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), reg, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, (__u16) 0, /* value */ (__u16) index, - buf, - length, + gspca_dev->usb_buf, length, 500); /* timeout */ if (ret < 0) { PDEBUG(D_ERR, "reg_read err %d", ret); return -1; } - return (buf[1] << 8) + buf[0]; + return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0]; } static int write_vector(struct gspca_dev *gspca_dev, @@ -697,7 +695,7 @@ static int sd_open(struct gspca_dev *gspca_dev) write_vector(gspca_dev, spca505b_open_data_ccd); else write_vector(gspca_dev, spca505_open_data_ccd); - ret = reg_read(gspca_dev->dev, 6, 0x16, 2); + ret = reg_read(gspca_dev, 6, 0x16, 2); if (ret < 0) { PDEBUG(D_ERR|D_STREAM, @@ -874,8 +872,8 @@ static void getbrightness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; sd->brightness = 255 - - ((reg_read(gspca_dev->dev, 5, 0x01, 1) >> 2) - + (reg_read(gspca_dev->dev, 5, 0x0, 1) << 6)); + - ((reg_read(gspca_dev, 5, 0x01, 1) >> 2) + + (reg_read(gspca_dev, 5, 0x0, 1) << 6)); } static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val) diff --git a/drivers/media/video/gspca/spca506.c b/drivers/media/video/gspca/spca506.c index 2d249b00bdc..143203c1fd9 100644 --- a/drivers/media/video/gspca/spca506.c +++ b/drivers/media/video/gspca/spca506.c @@ -25,8 +25,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA506 USB Camera Driver"); @@ -153,17 +153,18 @@ static struct v4l2_pix_format vga_mode[] = { #define SAA7113_hue 0x0d /* defaults 0x00 */ #define SAA7113_I2C_BASE_WRITE 0x4a -static void reg_r(struct usb_device *dev, +/* read 'len' bytes to gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, __u16 req, __u16 index, - __u8 *buffer, __u16 length) + __u16 length) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), req, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, length, + index, gspca_dev->usb_buf, length, 500); } @@ -189,13 +190,12 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg) { int retry = 60; - __u8 Data[2]; reg_w(gspca_dev->dev, 0x07, reg, 0x0001); reg_w(gspca_dev->dev, 0x07, valeur, 0x0000); while (retry--) { - reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2); - if ((Data[0] | Data[1]) == 0x00) + reg_r(gspca_dev, 0x07, 0x0003, 2); + if ((gspca_dev->usb_buf[0] | gspca_dev->usb_buf[1]) == 0x00) break; } } @@ -203,21 +203,19 @@ static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur, static int spca506_ReadI2c(struct gspca_dev *gspca_dev, __u16 reg) { int retry = 60; - __u8 Data[2]; - __u8 value; reg_w(gspca_dev->dev, 0x07, SAA7113_I2C_BASE_WRITE, 0x0004); reg_w(gspca_dev->dev, 0x07, reg, 0x0001); reg_w(gspca_dev->dev, 0x07, 0x01, 0x0002); while (--retry) { - reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2); - if ((Data[0] | Data[1]) == 0x00) + reg_r(gspca_dev, 0x07, 0x0003, 2); + if ((gspca_dev->usb_buf[0] | gspca_dev->usb_buf[1]) == 0x00) break; } if (retry == 0) return -1; - reg_r(gspca_dev->dev, 0x07, 0x0000, &value, 1); - return value; + reg_r(gspca_dev, 0x07, 0x0000, 1); + return gspca_dev->usb_buf[0]; } static void spca506_SetNormeInput(struct gspca_dev *gspca_dev, @@ -437,7 +435,6 @@ static void sd_start(struct gspca_dev *gspca_dev) struct usb_device *dev = gspca_dev->dev; __u16 norme; __u16 channel; - __u8 Data[2]; /**************************************/ reg_w(dev, 0x03, 0x00, 0x0004); @@ -555,8 +552,8 @@ static void sd_start(struct gspca_dev *gspca_dev) /* compress setting and size */ /* set i2c luma */ reg_w(dev, 0x02, 0x01, 0x0000); - reg_w(dev, 0x03, 0x12, 0x000); - reg_r(dev, 0x04, 0x0001, Data, 2); + reg_w(dev, 0x03, 0x12, 0x0000); + reg_r(gspca_dev, 0x04, 0x0001, 2); PDEBUG(D_STREAM, "webcam started"); spca506_GetNormeInput(gspca_dev, &norme, &channel); spca506_SetNormeInput(gspca_dev, norme, channel); diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c index 7f262f23841..d8cd93866a4 100644 --- a/drivers/media/video/gspca/spca508.c +++ b/drivers/media/video/gspca/spca508.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA508 USB Camera Driver"); @@ -1433,26 +1433,26 @@ static int reg_write(struct usb_device *dev, /* read 1 byte */ /* returns: negative is error, pos or zero is data */ -static int reg_read(struct usb_device *dev, +static int reg_read(struct gspca_dev *gspca_dev, __u16 index) /* wIndex */ { int ret; - __u8 data; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, /* register */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - (__u16) 0, /* value */ + 0, /* value */ index, - &data, 1, + gspca_dev->usb_buf, 1, 500); /* timeout */ - PDEBUG(D_USBI, "reg read i:%04x --> %02x", index, data); + PDEBUG(D_USBI, "reg read i:%04x --> %02x", + index, gspca_dev->usb_buf[0]); if (ret < 0) { PDEBUG(D_ERR|D_USBI, "reg_read err %d", ret); return ret; } - return data; + return gspca_dev->usb_buf[0]; } static int write_vector(struct gspca_dev *gspca_dev, @@ -1475,15 +1475,12 @@ static int sd_config(struct gspca_dev *gspca_dev, const struct usb_device_id *id) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; struct cam *cam; - __u16 vendor; __u16 product; int data1, data2; - vendor = id->idVendor; product = id->idProduct; - switch (vendor) { + switch (id->idVendor) { case 0x0130: /* Clone webcam */ /* switch (product) { */ /* case 0x0130: */ @@ -1535,15 +1532,15 @@ static int sd_config(struct gspca_dev *gspca_dev, * prove that we can communicate with the device. This works, which * confirms at we are communicating properly and that the device * is a 508. */ - data1 = reg_read(dev, 0x8104); - data2 = reg_read(dev, 0x8105); + data1 = reg_read(gspca_dev, 0x8104); + data2 = reg_read(gspca_dev, 0x8105); PDEBUG(D_PROBE, "Webcam Vendor ID: 0x%02x%02x", data2, data1); - data1 = reg_read(dev, 0x8106); - data2 = reg_read(dev, 0x8107); + data1 = reg_read(gspca_dev, 0x8106); + data2 = reg_read(gspca_dev, 0x8107); PDEBUG(D_PROBE, "Webcam Product ID: 0x%02x%02x", data2, data1); - data1 = reg_read(dev, 0x8621); + data1 = reg_read(gspca_dev, 0x8621); PDEBUG(D_PROBE, "Window 1 average luminance: %d", data1); cam = &gspca_dev->cam; @@ -1711,7 +1708,7 @@ static void getbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - sd->brightness = reg_read(gspca_dev->dev, 0x8651); + sd->brightness = reg_read(gspca_dev, 0x8651); } static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val) diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c index f0770ee595d..b659bd0f788 100644 --- a/drivers/media/video/gspca/spca561.c +++ b/drivers/media/video/gspca/spca561.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver"); @@ -177,27 +177,28 @@ static void write_vector(struct gspca_dev *gspca_dev, } } -static void reg_r(struct usb_device *dev, - __u16 index, __u8 *buffer, __u16 length) +/* read 'len' bytes to gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 index, __u16 length) { - usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, length, 500); + index, gspca_dev->usb_buf, length, 500); } -static void reg_w_buf(struct usb_device *dev, +static void reg_w_buf(struct gspca_dev *gspca_dev, __u16 index, const __u8 *buffer, __u16 len) { - __u8 tmpbuf[8]; - - memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, usb_sndctrlpipe(dev, 0), + memcpy(gspca_dev->usb_buf, buffer, len); + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, tmpbuf, len, 500); + index, gspca_dev->usb_buf, len, 500); } static void i2c_init(struct gspca_dev *gspca_dev, __u8 mode) @@ -211,7 +212,6 @@ static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg) int retry = 60; __u8 DataLow; __u8 DataHight; - __u8 Data; DataLow = valeur; DataHight = valeur >> 8; @@ -219,8 +219,8 @@ static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg) reg_w_val(gspca_dev->dev, DataLow, 0x8805); reg_w_val(gspca_dev->dev, DataHight, 0x8800); while (retry--) { - reg_r(gspca_dev->dev, 0x8803, &Data, 1); - if (!Data) + reg_r(gspca_dev, 0x8803, 1); + if (!gspca_dev->usb_buf[0]) break; } } @@ -230,20 +230,21 @@ static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode) int retry = 60; __u8 value; __u8 vallsb; - __u8 Data; reg_w_val(gspca_dev->dev, 0x92, 0x8804); reg_w_val(gspca_dev->dev, reg, 0x8801); reg_w_val(gspca_dev->dev, (mode | 0x01), 0x8802); while (retry--) { - reg_r(gspca_dev->dev, 0x8803, &Data, 1); - if (!Data) + reg_r(gspca_dev, 0x8803, 1); + if (!gspca_dev->usb_buf) break; } if (retry == 0) return -1; - reg_r(gspca_dev->dev, 0x8800, &value, 1); - reg_r(gspca_dev->dev, 0x8805, &vallsb, 1); + reg_r(gspca_dev, 0x8800, 1); + value = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8805, 1); + vallsb = gspca_dev->usb_buf[0]; return ((int) value << 8) | vallsb; } @@ -541,7 +542,7 @@ static void sensor_mapwrite(struct gspca_dev *gspca_dev, while (sensormap[i][0]) { usbval[0] = sensormap[i][1]; usbval[1] = sensormap[i][1] >> 8; - reg_w_buf(gspca_dev->dev, sensormap[i][0], usbval, 2); + reg_w_buf(gspca_dev, sensormap[i][0], usbval, 2); i++; } } @@ -559,7 +560,6 @@ static int sd_config(struct gspca_dev *gspca_dev, const struct usb_device_id *id) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; struct cam *cam; __u16 vendor, product; __u8 data1, data2; @@ -568,11 +568,15 @@ static int sd_config(struct gspca_dev *gspca_dev, * prove that we can communicate with the device. This works, which * confirms at we are communicating properly and that the device * is a 561. */ - reg_r(dev, 0x8104, &data1, 1); - reg_r(dev, 0x8105, &data2, 1); + reg_r(gspca_dev, 0x8104, 1); + data1 = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8105, 1); + data2 = gspca_dev->usb_buf[0]; vendor = (data2 << 8) | data1; - reg_r(dev, 0x8106, &data1, 1); - reg_r(dev, 0x8107, &data2, 1); + reg_r(gspca_dev, 0x8106, 1); + data1 = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8107, 1); + data2 = gspca_dev->usb_buf[0]; product = (data2 << 8) | data1; if (vendor != id->idVendor || product != id->idProduct) { PDEBUG(D_PROBE, "Bad vendor / product from device"); @@ -656,8 +660,8 @@ static void setcontrast(struct gspca_dev *gspca_dev) Reg8391[0] = expotimes & 0xff; /* exposure */ Reg8391[1] = 0x18 | (expotimes >> 8); Reg8391[2] = sd->brightness; /* gain */ - reg_w_buf(dev, 0x8391, Reg8391, 8); - reg_w_buf(dev, 0x8390, Reg8391, 8); + reg_w_buf(gspca_dev, 0x8391, Reg8391, 8); + reg_w_buf(gspca_dev, 0x8390, Reg8391, 8); break; } } @@ -714,10 +718,11 @@ static void sd_start(struct gspca_dev *gspca_dev) * is sufficient to push raw frames at ~20fps */ reg_w_val(dev, 0x8500, mode); } /* -- qq@kuku.eu.org */ - reg_w_buf(dev, 0x8307, Reg8307, 2); - reg_w_val(dev, 0x8700, Clck); /* 0x8f 0x85 0x27 clock */ - reg_w_val(dev, 0x8112, 0x1e | 0x20); - reg_w_val(dev, 0x850b, 0x03); + reg_w_buf(gspca_dev, 0x8307, Reg8307, 2); + reg_w_val(gspca_dev->dev, 0x8700, Clck); + /* 0x8f 0x85 0x27 clock */ + reg_w_val(gspca_dev->dev, 0x8112, 0x1e | 0x20); + reg_w_val(gspca_dev->dev, 0x850b, 0x03); setcontrast(gspca_dev); break; } @@ -752,10 +757,14 @@ static void setautogain(struct gspca_dev *gspca_dev) switch (sd->chip_revision) { case Rev072A: - reg_r(gspca_dev->dev, 0x8621, &Gr, 1); - reg_r(gspca_dev->dev, 0x8622, &R, 1); - reg_r(gspca_dev->dev, 0x8623, &B, 1); - reg_r(gspca_dev->dev, 0x8624, &Gb, 1); + reg_r(gspca_dev, 0x8621, 1); + Gr = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8622, 1); + R = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8623, 1); + B = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8624, 1); + Gb = gspca_dev->usb_buf[0]; y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8; /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */ /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */ @@ -867,20 +876,19 @@ static void setbrightness(struct gspca_dev *gspca_dev) static void getbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - __u8 value; __u16 tot; switch (sd->chip_revision) { case Rev072A: tot = 0; - reg_r(gspca_dev->dev, 0x8611, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8612, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8613, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8614, &value, 1); - tot += value; + reg_r(gspca_dev, 0x8611, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8612, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8613, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8614, 1); + tot += gspca_dev->usb_buf[0]; sd->brightness = tot >> 2; break; default: @@ -893,20 +901,19 @@ static void getbrightness(struct gspca_dev *gspca_dev) static void getcontrast(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - __u8 value; __u16 tot; switch (sd->chip_revision) { case Rev072A: tot = 0; - reg_r(gspca_dev->dev, 0x8651, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8652, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8653, &value, 1); - tot += value; - reg_r(gspca_dev->dev, 0x8654, &value, 1); - tot += value; + reg_r(gspca_dev, 0x8651, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8652, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8653, 1); + tot += gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0x8654, 1); + tot += gspca_dev->usb_buf[0]; sd->contrast = tot << 6; break; default: diff --git a/drivers/media/video/gspca/stk014.c b/drivers/media/video/gspca/stk014.c index d676cd16aa7..c78ee0d3e59 100644 --- a/drivers/media/video/gspca/stk014.c +++ b/drivers/media/video/gspca/stk014.c @@ -23,8 +23,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Jean-Francois Moine "); MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver"); @@ -127,7 +127,7 @@ static struct v4l2_pix_format vga_mode[] = { /* -- read a register -- */ static int reg_r(struct gspca_dev *gspca_dev, - __u16 index, __u8 *buf) + __u16 index) { struct usb_device *dev = gspca_dev->dev; int ret; @@ -137,11 +137,13 @@ static int reg_r(struct gspca_dev *gspca_dev, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0x00, index, - buf, 1, + gspca_dev->usb_buf, 1, 500); - if (ret < 0) + if (ret < 0) { PDEBUG(D_ERR, "reg_r err %d", ret); - return ret; + return ret; + } + return gspca_dev->usb_buf[0]; } /* -- write a register -- */ @@ -164,58 +166,55 @@ static int reg_w(struct gspca_dev *gspca_dev, return ret; } -/* -- get a value -- */ +/* -- get a bulk value (4 bytes) -- */ static int rcv_val(struct gspca_dev *gspca_dev, - int ads, - int len) + int ads) { struct usb_device *dev = gspca_dev->dev; int alen, ret; - unsigned char bulk_buf[4]; reg_w(gspca_dev, 0x634, (ads >> 16) & 0xff); reg_w(gspca_dev, 0x635, (ads >> 8) & 0xff); reg_w(gspca_dev, 0x636, ads & 0xff); reg_w(gspca_dev, 0x637, 0); - reg_w(gspca_dev, 0x638, len & 0xff); - reg_w(gspca_dev, 0x639, len >> 8); + reg_w(gspca_dev, 0x638, 4); /* len & 0xff */ + reg_w(gspca_dev, 0x639, 0); /* len >> 8 */ reg_w(gspca_dev, 0x63a, 0); reg_w(gspca_dev, 0x63b, 0); reg_w(gspca_dev, 0x630, 5); - if (len > sizeof bulk_buf) - return -1; ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, 5), - bulk_buf, - len, + gspca_dev->usb_buf, + 4, /* length */ &alen, - 500); /* timeout in milliseconds */ + 500); /* timeout in milliseconds */ return ret; } -/* -- send a value -- */ +/* -- send a bulk value -- */ static int snd_val(struct gspca_dev *gspca_dev, int ads, unsigned int val) { struct usb_device *dev = gspca_dev->dev; int alen, ret; - __u8 value, seq; - unsigned char bulk_buf[4]; + __u8 seq = 0; if (ads == 0x003f08) { - ret = reg_r(gspca_dev, 0x0704, &value); + ret = reg_r(gspca_dev, 0x0704); if (ret < 0) goto ko; - ret = reg_r(gspca_dev, 0x0705, &seq); + ret = reg_r(gspca_dev, 0x0705); if (ret < 0) goto ko; - ret = reg_r(gspca_dev, 0x0650, &value); + seq = ret; /* keep the sequence number */ + ret = reg_r(gspca_dev, 0x0650); if (ret < 0) goto ko; reg_w(gspca_dev, 0x654, seq); - } else + } else { reg_w(gspca_dev, 0x654, (ads >> 16) & 0xff); + } reg_w(gspca_dev, 0x655, (ads >> 8) & 0xff); reg_w(gspca_dev, 0x656, ads & 0xff); reg_w(gspca_dev, 0x657, 0); @@ -224,13 +223,13 @@ static int snd_val(struct gspca_dev *gspca_dev, reg_w(gspca_dev, 0x65a, 0); reg_w(gspca_dev, 0x65b, 0); reg_w(gspca_dev, 0x650, 5); - bulk_buf[0] = (val >> 24) & 0xff; - bulk_buf[1] = (val >> 16) & 0xff; - bulk_buf[2] = (val >> 8) & 0xff; - bulk_buf[3] = val & 0xff; + gspca_dev->usb_buf[0] = val >> 24; + gspca_dev->usb_buf[1] = val >> 16; + gspca_dev->usb_buf[2] = val >> 8; + gspca_dev->usb_buf[3] = val; ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 6), - bulk_buf, + gspca_dev->usb_buf, 4, &alen, 500); /* timeout in milliseconds */ @@ -303,7 +302,7 @@ static int sd_config(struct gspca_dev *gspca_dev, cam->dev_name = (char *) id->driver_info; cam->epaddr = 0x02; gspca_dev->cam.cam_mode = vga_mode; - gspca_dev->cam.nmodes = sizeof vga_mode / sizeof vga_mode[0]; + gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode); sd->brightness = BRIGHTNESS_DEF; sd->contrast = CONTRAST_DEF; sd->colors = COLOR_DEF; @@ -314,16 +313,15 @@ static int sd_config(struct gspca_dev *gspca_dev, /* this function is called at open time */ static int sd_open(struct gspca_dev *gspca_dev) { - __u8 value; int ret; /* check if the device responds */ usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1); - ret = reg_r(gspca_dev, 0x0740, &value); + ret = reg_r(gspca_dev, 0x0740); if (ret < 0) return ret; - if (value != 0xff) { - PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", value); + if (ret != 0xff) { + PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", ret); return -1; } return 0; @@ -332,7 +330,6 @@ static int sd_open(struct gspca_dev *gspca_dev) /* -- start the camera -- */ static void sd_start(struct gspca_dev *gspca_dev) { - __u8 dum; int ret, value; /* work on alternate 1 */ @@ -355,11 +352,11 @@ static void sd_start(struct gspca_dev *gspca_dev) gspca_dev->iface, gspca_dev->alt); goto out; } - ret = reg_r(gspca_dev, 0x0630, &dum); + ret = reg_r(gspca_dev, 0x0630); if (ret < 0) goto out; - rcv_val(gspca_dev, 0x000020, 4); /* << (value ff ff ff ff) */ - ret = reg_r(gspca_dev, 0x0650, &dum); + rcv_val(gspca_dev, 0x000020); /* << (value ff ff ff ff) */ + ret = reg_r(gspca_dev, 0x0650); if (ret < 0) goto out; snd_val(gspca_dev, 0x000020, 0xffffffff); @@ -389,14 +386,13 @@ out: static void sd_stopN(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 value; set_par(gspca_dev, 0x02000000); set_par(gspca_dev, 0x02000000); usb_set_interface(dev, gspca_dev->iface, 1); - reg_r(gspca_dev, 0x0630, &value); - rcv_val(gspca_dev, 0x000020, 4); /* << (value ff ff ff ff) */ - reg_r(gspca_dev, 0x0650, &value); + reg_r(gspca_dev, 0x0630); + rcv_val(gspca_dev, 0x000020); /* << (value ff ff ff ff) */ + reg_r(gspca_dev, 0x0650); snd_val(gspca_dev, 0x000020, 0xffffffff); reg_w(gspca_dev, 0x0620, 0); reg_w(gspca_dev, 0x0630, 0); @@ -538,10 +534,10 @@ static int sd_querymenu(struct gspca_dev *gspca_dev, } /* sub-driver description */ -static struct sd_desc sd_desc = { +static const struct sd_desc sd_desc = { .name = MODULE_NAME, .ctrls = sd_ctrls, - .nctrls = sizeof sd_ctrls / sizeof sd_ctrls[0], + .nctrls = ARRAY_SIZE(sd_ctrls), .config = sd_config, .open = sd_open, .start = sd_start, @@ -554,7 +550,7 @@ static struct sd_desc sd_desc = { /* -- module initialisation -- */ #define DVNM(name) .driver_info = (kernel_ulong_t) name -static __devinitdata struct usb_device_id device_table[] = { +static const __devinitdata struct usb_device_id device_table[] = { {USB_DEVICE(0x05e1, 0x0893), DVNM("Syntek DV4000")}, {} }; diff --git a/drivers/media/video/gspca/sunplus.c b/drivers/media/video/gspca/sunplus.c index f66594a113a..acd4a077198 100644 --- a/drivers/media/video/gspca/sunplus.c +++ b/drivers/media/video/gspca/sunplus.c @@ -24,8 +24,8 @@ #include "gspca.h" #include "jpeg.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver"); @@ -452,7 +452,7 @@ static const __u8 qtable_spca504_default[2][64] = { 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e} }; -static void spca5xxRegRead(struct usb_device *dev, +static void reg_r(struct usb_device *dev, __u16 req, __u16 index, __u8 *buffer, __u16 length) @@ -466,7 +466,7 @@ static void spca5xxRegRead(struct usb_device *dev, 500); } -static void spca5xxRegWrite(struct usb_device *dev, +static void reg_w(struct usb_device *dev, __u16 req, __u16 value, __u16 index, @@ -480,7 +480,8 @@ static void spca5xxRegWrite(struct usb_device *dev, 500); } -static int reg_write(struct usb_device *dev, +/* write req / index / value */ +static int reg_w_riv(struct usb_device *dev, __u16 req, __u16 index, __u16 value) { int ret; @@ -490,57 +491,56 @@ static int reg_write(struct usb_device *dev, req, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, index, NULL, 0, 500); - PDEBUG(D_PACK, "reg write: 0x%02x,0x%02x:0x%02x, 0x%x", + PDEBUG(D_USBO, "reg write: 0x%02x,0x%02x:0x%02x, %d", req, index, value, ret); if (ret < 0) PDEBUG(D_ERR, "reg write: error %d", ret); return ret; } -static int reg_read_info(struct usb_device *dev, +/* read 1 byte */ +static int reg_r_1(struct gspca_dev *gspca_dev, __u16 value) /* wValue */ { int ret; - __u8 data; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0x20, /* request */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, 0, /* index */ - &data, 1, + gspca_dev->usb_buf, 1, 500); /* timeout */ if (ret < 0) { - PDEBUG(D_ERR, "reg_read_info err %d", ret); + PDEBUG(D_ERR, "reg_r_1 err %d", ret); return 0; } - return data; + return gspca_dev->usb_buf[0]; } -/* returns: negative is error, pos or zero is data */ -static int reg_read(struct usb_device *dev, +/* read 1 or 2 bytes - returns < 0 if error */ +static int reg_r_12(struct gspca_dev *gspca_dev, __u16 req, /* bRequest */ __u16 index, /* wIndex */ __u16 length) /* wLength (1 or 2 only) */ { int ret; - __u8 buf[2]; - buf[1] = 0; - ret = usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + gspca_dev->usb_buf[1] = 0; + ret = usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), req, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ index, - buf, length, + gspca_dev->usb_buf, length, 500); if (ret < 0) { PDEBUG(D_ERR, "reg_read err %d", ret); return -1; } - return (buf[1] << 8) + buf[0]; + return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0]; } static int write_vector(struct gspca_dev *gspca_dev, @@ -550,7 +550,7 @@ static int write_vector(struct gspca_dev *gspca_dev, int ret, i = 0; while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) { - ret = reg_write(dev, data[i][0], data[i][2], data[i][1]); + ret = reg_w_riv(dev, data[i][0], data[i][2], data[i][1]); if (ret < 0) { PDEBUG(D_ERR, "Register write failed for 0x%x,0x%x,0x%x", @@ -573,14 +573,14 @@ static int spca50x_setup_qtable(struct gspca_dev *gspca_dev, /* loop over y components */ for (i = 0; i < 64; i++) { - err = reg_write(dev, request, ybase + i, qtable[0][i]); + err = reg_w_riv(dev, request, ybase + i, qtable[0][i]); if (err < 0) return err; } /* loop over c components */ for (i = 0; i < 64; i++) { - err = reg_write(dev, request, cbase + i, qtable[1][i]); + err = reg_w_riv(dev, request, cbase + i, qtable[1][i]); if (err < 0) return err; } @@ -593,14 +593,14 @@ static void spca504_acknowledged_command(struct gspca_dev *gspca_dev, struct usb_device *dev = gspca_dev->dev; __u8 notdone; - reg_write(dev, req, idx, val); - notdone = reg_read(dev, 0x01, 0x0001, 1); - reg_write(dev, req, idx, val); + reg_w_riv(dev, req, idx, val); + notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1); + reg_w_riv(dev, req, idx, val); PDEBUG(D_FRAM, "before wait 0x%x", notdone); msleep(200); - notdone = reg_read(dev, 0x01, 0x0001, 1); + notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1); PDEBUG(D_FRAM, "after wait 0x%x", notdone); } @@ -612,8 +612,8 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev, __u8 status; __u8 endcode; - reg_write(dev, req, idx, val); - status = reg_read(dev, 0x01, 0x0001, 1); + reg_w_riv(dev, req, idx, val); + status = reg_r_12(gspca_dev, 0x01, 0x0001, 1); endcode = stat; PDEBUG(D_FRAM, "Status 0x%x Need 0x%x", status, stat); if (!count) @@ -622,8 +622,8 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev, while (--count > 0) { msleep(10); /* gsmart mini2 write a each wait setting 1 ms is enought */ -/* reg_write(dev, req, idx, val); */ - status = reg_read(dev, 0x01, 0x0001, 1); +/* reg_w_riv(dev, req, idx, val); */ + status = reg_r_12(gspca_dev, 0x01, 0x0001, 1); if (status == endcode) { PDEBUG(D_FRAM, "status 0x%x after wait 0x%x", status, 200 - count); @@ -632,34 +632,31 @@ static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev, } } -static int spca504B_PollingDataReady(struct usb_device *dev) +static int spca504B_PollingDataReady(struct gspca_dev *gspca_dev) { - __u8 DataReady; int count = 10; while (--count > 0) { - spca5xxRegRead(dev, 0x21, 0, &DataReady, 1); - if ((DataReady & 0x01) == 0) + reg_r(gspca_dev->dev, 0x21, 0, gspca_dev->usb_buf, 1); + if ((gspca_dev->usb_buf[0] & 0x01) == 0) break; msleep(10); } - return DataReady; + return gspca_dev->usb_buf[0]; } static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 DataReady; int count = 50; while (--count > 0) { - spca5xxRegRead(dev, 0x21, 1, &DataReady, 1); - - if (DataReady) { - DataReady = 0; - spca5xxRegWrite(dev, 0x21, 0, 1, &DataReady, 1); - spca5xxRegRead(dev, 0x21, 1, &DataReady, 1); - spca504B_PollingDataReady(dev); + reg_r(dev, 0x21, 1, gspca_dev->usb_buf, 1); + if (gspca_dev->usb_buf[0] != 0) { + gspca_dev->usb_buf[0] = 0; + reg_w(dev, 0x21, 0, 1, gspca_dev->usb_buf, 1); + reg_r(dev, 0x21, 1, gspca_dev->usb_buf, 1); + spca504B_PollingDataReady(gspca_dev); break; } msleep(10); @@ -669,14 +666,15 @@ static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev) static void spca50x_GetFirmware(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 FW[5]; - __u8 ProductInfo[64]; + __u8 *data; - spca5xxRegRead(dev, 0x20, 0, FW, 5); + data = kmalloc(64, GFP_KERNEL); + reg_r(dev, 0x20, 0, data, 5); PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ", - FW[0], FW[1], FW[2], FW[3], FW[4]); - spca5xxRegRead(dev, 0x23, 0, ProductInfo, 64); - spca5xxRegRead(dev, 0x23, 1, ProductInfo, 64); + data[0], data[1], data[2], data[3], data[4]); + reg_r(dev, 0x23, 0, data, 64); + reg_r(dev, 0x23, 1, data, 64); + kfree(data); } static void spca504B_SetSizeType(struct gspca_dev *gspca_dev) @@ -691,32 +689,35 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev) Type = 0; switch (sd->bridge) { case BRIDGE_SPCA533: - spca5xxRegWrite(dev, 0x31, 0, 0, NULL, 0); + reg_w(dev, 0x31, 0, 0, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); - rc = spca504B_PollingDataReady(dev); + rc = spca504B_PollingDataReady(gspca_dev); spca50x_GetFirmware(gspca_dev); - Type = 2; - spca5xxRegWrite(dev, 0x24, 0, 8, &Type, 1); - spca5xxRegRead(dev, 0x24, 8, &Type, 1); + gspca_dev->usb_buf[0] = 2; /* type */ + reg_w(dev, 0x24, 0, 8, gspca_dev->usb_buf, 1); + reg_r(dev, 0x24, 8, gspca_dev->usb_buf, 1); - spca5xxRegWrite(dev, 0x25, 0, 4, &Size, 1); - spca5xxRegRead(dev, 0x25, 4, &Size, 1); - rc = spca504B_PollingDataReady(dev); + gspca_dev->usb_buf[0] = Size; + reg_w(dev, 0x25, 0, 4, gspca_dev->usb_buf, 1); + reg_r(dev, 0x25, 4, gspca_dev->usb_buf, 1); /* size */ + rc = spca504B_PollingDataReady(gspca_dev); /* Init the cam width height with some values get on init ? */ - spca5xxRegWrite(dev, 0x31, 0, 4, NULL, 0); + reg_w(dev, 0x31, 0, 4, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); - rc = spca504B_PollingDataReady(dev); + rc = spca504B_PollingDataReady(gspca_dev); break; default: /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA536: */ + gspca_dev->usb_buf[0] = Size; + reg_w(dev, 0x25, 0, 4, gspca_dev->usb_buf, 1); + reg_r(dev, 0x25, 4, gspca_dev->usb_buf, 1); /* size */ Type = 6; - spca5xxRegWrite(dev, 0x25, 0, 4, &Size, 1); - spca5xxRegRead(dev, 0x25, 4, &Size, 1); - spca5xxRegWrite(dev, 0x27, 0, 0, &Type, 1); - spca5xxRegRead(dev, 0x27, 0, &Type, 1); - rc = spca504B_PollingDataReady(dev); + gspca_dev->usb_buf[0] = Type; + reg_w(dev, 0x27, 0, 0, gspca_dev->usb_buf, 1); + reg_r(dev, 0x27, 0, gspca_dev->usb_buf, 1); /* type */ + rc = spca504B_PollingDataReady(gspca_dev); break; case BRIDGE_SPCA504: Size += 3; @@ -733,21 +734,20 @@ static void spca504B_SetSizeType(struct gspca_dev *gspca_dev) break; case BRIDGE_SPCA504C: /* capture mode */ - reg_write(dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x0); - reg_write(dev, 0x20, 0x01, 0x0500 | (Size & 0x0f)); + reg_w_riv(dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00); + reg_w_riv(dev, 0x20, 0x01, 0x0500 | (Size & 0x0f)); break; } } static void spca504_wait_status(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; int cnt; cnt = 256; while (--cnt > 0) { /* With this we get the status, when return 0 it's all ok */ - if (reg_read(dev, 0x06, 0x00, 1) == 0) + if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0) return; msleep(10); } @@ -756,11 +756,11 @@ static void spca504_wait_status(struct gspca_dev *gspca_dev) static void spca504B_setQtable(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; - __u8 Data = 3; - spca5xxRegWrite(dev, 0x26, 0, 0, &Data, 1); - spca5xxRegRead(dev, 0x26, 0, &Data, 1); - spca504B_PollingDataReady(dev); + gspca_dev->usb_buf[0] = 3; + reg_w(dev, 0x26, 0, 0, gspca_dev->usb_buf, 1); + reg_r(dev, 0x26, 0, gspca_dev->usb_buf, 1); + spca504B_PollingDataReady(gspca_dev); } static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev) @@ -777,24 +777,24 @@ static void sp5xx_initContBrigHueRegisters(struct gspca_dev *gspca_dev) default: /* case BRIDGE_SPCA533: */ /* case BRIDGE_SPCA504B: */ - spca5xxRegWrite(dev, 0, 0, 0x21a7, NULL, 0); /* brightness */ - spca5xxRegWrite(dev, 0, 0x20, 0x21a8, NULL, 0); /* contrast */ - spca5xxRegWrite(dev, 0, 0, 0x21ad, NULL, 0); /* hue */ - spca5xxRegWrite(dev, 0, 1, 0x21ac, NULL, 0); /* sat/hue */ - spca5xxRegWrite(dev, 0, 0x20, 0x21ae, NULL, 0); /* saturation */ - spca5xxRegWrite(dev, 0, 0, 0x21a3, NULL, 0); /* gamma */ + reg_w(dev, 0, 0, 0x21a7, NULL, 0); /* brightness */ + reg_w(dev, 0, 0x20, 0x21a8, NULL, 0); /* contrast */ + reg_w(dev, 0, 0, 0x21ad, NULL, 0); /* hue */ + reg_w(dev, 0, 1, 0x21ac, NULL, 0); /* sat/hue */ + reg_w(dev, 0, 0x20, 0x21ae, NULL, 0); /* saturation */ + reg_w(dev, 0, 0, 0x21a3, NULL, 0); /* gamma */ break; case BRIDGE_SPCA536: - spca5xxRegWrite(dev, 0, 0, 0x20f0, NULL, 0); - spca5xxRegWrite(dev, 0, 0x21, 0x20f1, NULL, 0); - spca5xxRegWrite(dev, 0, 0x40, 0x20f5, NULL, 0); - spca5xxRegWrite(dev, 0, 1, 0x20f4, NULL, 0); - spca5xxRegWrite(dev, 0, 0x40, 0x20f6, NULL, 0); - spca5xxRegWrite(dev, 0, 0, 0x2089, NULL, 0); + reg_w(dev, 0, 0, 0x20f0, NULL, 0); + reg_w(dev, 0, 0x21, 0x20f1, NULL, 0); + reg_w(dev, 0, 0x40, 0x20f5, NULL, 0); + reg_w(dev, 0, 1, 0x20f4, NULL, 0); + reg_w(dev, 0, 0x40, 0x20f6, NULL, 0); + reg_w(dev, 0, 0, 0x2089, NULL, 0); break; } if (pollreg) - spca504B_PollingDataReady(dev); + spca504B_PollingDataReady(gspca_dev); } /* this function is called at probe time */ @@ -872,7 +872,8 @@ static int sd_config(struct gspca_dev *gspca_dev, case 0x504a: /* try to get the firmware as some cam answer 2.0.1.2.2 * and should be a spca504b then overwrite that setting */ - spca5xxRegRead(dev, 0x20, 0, &fw, 1); + reg_r(dev, 0x20, 0, gspca_dev->usb_buf, 1); + fw = gspca_dev->usb_buf[0]; if (fw == 1) { sd->subtype = AiptekMiniPenCam13; sd->bridge = BRIDGE_SPCA504; @@ -1048,38 +1049,37 @@ static int sd_open(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; int rc; - __u8 Data; __u8 i; __u8 info[6]; int err_code; switch (sd->bridge) { case BRIDGE_SPCA504B: - spca5xxRegWrite(dev, 0x1d, 0, 0, NULL, 0); - spca5xxRegWrite(dev, 0, 1, 0x2306, NULL, 0); - spca5xxRegWrite(dev, 0, 0, 0x0d04, NULL, 0); - spca5xxRegWrite(dev, 0, 0, 0x2000, NULL, 0); - spca5xxRegWrite(dev, 0, 0x13, 0x2301, NULL, 0); - spca5xxRegWrite(dev, 0, 0, 0x2306, NULL, 0); + reg_w(dev, 0x1d, 0, 0, NULL, 0); + reg_w(dev, 0, 1, 0x2306, NULL, 0); + reg_w(dev, 0, 0, 0x0d04, NULL, 0); + reg_w(dev, 0, 0, 0x2000, NULL, 0); + reg_w(dev, 0, 0x13, 0x2301, NULL, 0); + reg_w(dev, 0, 0, 0x2306, NULL, 0); /* fall thru */ case BRIDGE_SPCA533: - rc = spca504B_PollingDataReady(dev); + rc = spca504B_PollingDataReady(gspca_dev); spca50x_GetFirmware(gspca_dev); break; case BRIDGE_SPCA536: spca50x_GetFirmware(gspca_dev); - spca5xxRegRead(dev, 0x00, 0x5002, &Data, 1); - Data = 0; - spca5xxRegWrite(dev, 0x24, 0, 0, &Data, 1); - spca5xxRegRead(dev, 0x24, 0, &Data, 1); - rc = spca504B_PollingDataReady(dev); - spca5xxRegWrite(dev, 0x34, 0, 0, NULL, 0); + reg_r(dev, 0x00, 0x5002, gspca_dev->usb_buf, 1); + gspca_dev->usb_buf[0] = 0; + reg_w(dev, 0x24, 0, 0, gspca_dev->usb_buf, 1); + reg_r(dev, 0x24, 0, gspca_dev->usb_buf, 1); + rc = spca504B_PollingDataReady(gspca_dev); + reg_w(dev, 0x34, 0, 0, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); break; case BRIDGE_SPCA504C: /* pccam600 */ PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)"); - reg_write(dev, 0xe0, 0x0000, 0x0000); - reg_write(dev, 0xe0, 0x0000, 0x0001); /* reset */ + reg_w_riv(dev, 0xe0, 0x0000, 0x0000); + reg_w_riv(dev, 0xe0, 0x0000, 0x0001); /* reset */ spca504_wait_status(gspca_dev); if (sd->subtype == LogitechClickSmart420) write_vector(gspca_dev, @@ -1100,7 +1100,7 @@ static int sd_open(struct gspca_dev *gspca_dev) if (sd->subtype == AiptekMiniPenCam13) { /*****************************/ for (i = 0; i < 6; i++) - info[i] = reg_read_info(dev, i); + info[i] = reg_r_1(gspca_dev, i); PDEBUG(D_STREAM, "Read info: %d %d %d %d %d %d." " Should be 1,0,2,2,0,0", @@ -1126,14 +1126,14 @@ static int sd_open(struct gspca_dev *gspca_dev) 6, 0, 0x86, 1); */ /* spca504A_acknowledged_command (gspca_dev, 0x24, 0, 0, 0x9D, 1); */ - reg_write(dev, 0x0, 0x270c, 0x5); /* L92 sno1t.txt */ - reg_write(dev, 0x0, 0x2310, 0x5); + reg_w_riv(dev, 0x0, 0x270c, 0x05); /* L92 sno1t.txt */ + reg_w_riv(dev, 0x0, 0x2310, 0x05); spca504A_acknowledged_command(gspca_dev, 0x01, 0x0f, 0, 0xff, 0); } /* setup qtable */ - reg_write(dev, 0, 0x2000, 0); - reg_write(dev, 0, 0x2883, 1); + reg_w_riv(dev, 0, 0x2000, 0); + reg_w_riv(dev, 0, 0x2883, 1); err_code = spca50x_setup_qtable(gspca_dev, 0x00, 0x2800, 0x2840, @@ -1166,20 +1166,20 @@ static void sd_start(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA536: */ if (sd->subtype == MegapixV4 || sd->subtype == LogitechClickSmart820) { - spca5xxRegWrite(dev, 0xf0, 0, 0, NULL, 0); + reg_w(dev, 0xf0, 0, 0, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); - spca5xxRegRead(dev, 0xf0, 4, NULL, 0); + reg_r(dev, 0xf0, 4, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); } else { - spca5xxRegWrite(dev, 0x31, 0, 4, NULL, 0); + reg_w(dev, 0x31, 0, 4, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); - rc = spca504B_PollingDataReady(dev); + rc = spca504B_PollingDataReady(gspca_dev); } break; case BRIDGE_SPCA504: if (sd->subtype == AiptekMiniPenCam13) { for (i = 0; i < 6; i++) - info[i] = reg_read_info(dev, i); + info[i] = reg_r_1(gspca_dev, i); PDEBUG(D_STREAM, "Read info: %d %d %d %d %d %d." " Should be 1,0,2,2,0,0", @@ -1197,7 +1197,7 @@ static void sd_start(struct gspca_dev *gspca_dev) } else { spca504_acknowledged_command(gspca_dev, 0x24, 8, 3); for (i = 0; i < 6; i++) - info[i] = reg_read_info(dev, i); + info[i] = reg_r_1(gspca_dev, i); PDEBUG(D_STREAM, "Read info: %d %d %d %d %d %d." " Should be 1,0,2,2,0,0", @@ -1207,8 +1207,8 @@ static void sd_start(struct gspca_dev *gspca_dev) spca504_acknowledged_command(gspca_dev, 0x24, 0, 0); } spca504B_SetSizeType(gspca_dev); - reg_write(dev, 0x0, 0x270c, 0x5); /* L92 sno1t.txt */ - reg_write(dev, 0x0, 0x2310, 0x5); + reg_w_riv(dev, 0x0, 0x270c, 0x05); /* L92 sno1t.txt */ + reg_w_riv(dev, 0x0, 0x2310, 0x05); break; case BRIDGE_SPCA504C: if (sd->subtype == LogitechClickSmart420) { @@ -1217,13 +1217,13 @@ static void sd_start(struct gspca_dev *gspca_dev) } else { write_vector(gspca_dev, spca504_pccam600_init_data); } - enable = (sd->autogain ? 0x4 : 0x1); - reg_write(dev, 0x0c, 0x0000, enable); /* auto exposure */ - reg_write(dev, 0xb0, 0x0000, enable); /* auto whiteness */ + enable = (sd->autogain ? 0x04 : 0x01); + reg_w_riv(dev, 0x0c, 0x0000, enable); /* auto exposure */ + reg_w_riv(dev, 0xb0, 0x0000, enable); /* auto whiteness */ /* set default exposure compensation and whiteness balance */ - reg_write(dev, 0x30, 0x0001, 800); /* ~ 20 fps */ - reg_write(dev, 0x30, 0x0002, 1600); + reg_w_riv(dev, 0x30, 0x0001, 800); /* ~ 20 fps */ + reg_w_riv(dev, 0x30, 0x0002, 1600); spca504B_SetSizeType(gspca_dev); break; } @@ -1240,13 +1240,13 @@ static void sd_stopN(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA533: */ /* case BRIDGE_SPCA536: */ /* case BRIDGE_SPCA504B: */ - spca5xxRegWrite(dev, 0x31, 0, 0, NULL, 0); + reg_w(dev, 0x31, 0, 0, NULL, 0); spca504B_WaitCmdStatus(gspca_dev); - spca504B_PollingDataReady(dev); + spca504B_PollingDataReady(gspca_dev); break; case BRIDGE_SPCA504: case BRIDGE_SPCA504C: - reg_write(dev, 0x00, 0x2000, 0x0000); + reg_w_riv(dev, 0x00, 0x2000, 0x0000); if (sd->subtype == AiptekMiniPenCam13) { /* spca504a aiptek */ @@ -1258,7 +1258,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev) 0x0f, 0x00, 0xff, 1); } else { spca504_acknowledged_command(gspca_dev, 0x24, 0, 0); - reg_write(dev, 0x01, 0x000f, 0x0); + reg_w_riv(dev, 0x01, 0x000f, 0x00); } break; } @@ -1383,10 +1383,10 @@ static void setbrightness(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - reg_write(dev, 0x0, 0x21a7, sd->brightness); + reg_w_riv(dev, 0x0, 0x21a7, sd->brightness); break; case BRIDGE_SPCA536: - reg_write(dev, 0x0, 0x20f0, sd->brightness); + reg_w_riv(dev, 0x0, 0x20f0, sd->brightness); break; } } @@ -1394,7 +1394,6 @@ static void setbrightness(struct gspca_dev *gspca_dev) static void getbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u16 brightness = 0; switch (sd->bridge) { @@ -1403,10 +1402,10 @@ static void getbrightness(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - brightness = reg_read(dev, 0x0, 0x21a7, 2); + brightness = reg_r_12(gspca_dev, 0x00, 0x21a7, 2); break; case BRIDGE_SPCA536: - brightness = reg_read(dev, 0x0, 0x20f0, 2); + brightness = reg_r_12(gspca_dev, 0x00, 0x20f0, 2); break; } sd->brightness = ((brightness & 0xff) - 128) % 255; @@ -1423,10 +1422,10 @@ static void setcontrast(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - reg_write(dev, 0x0, 0x21a8, sd->contrast); + reg_w_riv(dev, 0x0, 0x21a8, sd->contrast); break; case BRIDGE_SPCA536: - reg_write(dev, 0x0, 0x20f1, sd->contrast); + reg_w_riv(dev, 0x0, 0x20f1, sd->contrast); break; } } @@ -1434,7 +1433,6 @@ static void setcontrast(struct gspca_dev *gspca_dev) static void getcontrast(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; switch (sd->bridge) { default: @@ -1442,10 +1440,10 @@ static void getcontrast(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - sd->contrast = reg_read(dev, 0x0, 0x21a8, 2); + sd->contrast = reg_r_12(gspca_dev, 0x00, 0x21a8, 2); break; case BRIDGE_SPCA536: - sd->contrast = reg_read(dev, 0x0, 0x20f1, 2); + sd->contrast = reg_r_12(gspca_dev, 0x00, 0x20f1, 2); break; } } @@ -1461,10 +1459,10 @@ static void setcolors(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - reg_write(dev, 0x0, 0x21ae, sd->colors); + reg_w_riv(dev, 0x0, 0x21ae, sd->colors); break; case BRIDGE_SPCA536: - reg_write(dev, 0x0, 0x20f6, sd->colors); + reg_w_riv(dev, 0x0, 0x20f6, sd->colors); break; } } @@ -1472,7 +1470,6 @@ static void setcolors(struct gspca_dev *gspca_dev) static void getcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; switch (sd->bridge) { default: @@ -1480,10 +1477,10 @@ static void getcolors(struct gspca_dev *gspca_dev) /* case BRIDGE_SPCA504B: */ /* case BRIDGE_SPCA504: */ /* case BRIDGE_SPCA504C: */ - sd->colors = reg_read(dev, 0x0, 0x21ae, 2) >> 1; + sd->colors = reg_r_12(gspca_dev, 0x00, 0x21ae, 2) >> 1; break; case BRIDGE_SPCA536: - sd->colors = reg_read(dev, 0x0, 0x20f6, 2) >> 1; + sd->colors = reg_r_12(gspca_dev, 0x00, 0x20f6, 2) >> 1; break; } } diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c index 299f84584e8..00f47e463a0 100644 --- a/drivers/media/video/gspca/t613.c +++ b/drivers/media/video/gspca/t613.c @@ -26,8 +26,8 @@ #define MODULE_NAME "t613" #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; #define MAX_GAMMA 0x10 /* 0 to 15 */ @@ -365,48 +365,49 @@ static const __u8 tas5130a_sensor_init[][8] = { {}, }; -static void t16RegRead(struct usb_device *dev, - __u16 index, __u8 *buffer, __u16 length) +/* read 1 byte */ +static int reg_r_1(struct gspca_dev *gspca_dev, + __u16 index) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0, /* request */ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, length, 500); + index, + gspca_dev->usb_buf, 1, 500); + return gspca_dev->usb_buf[0]; } -static void t16RegWrite(struct usb_device *dev, +static void reg_w(struct gspca_dev *gspca_dev, __u16 value, __u16 index, const __u8 *buffer, __u16 len) { if (buffer == NULL) { - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, index, NULL, 0, 500); return; } - if (len < 16) { - __u8 tmpbuf[16]; - - memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + if (len <= sizeof gspca_dev->usb_buf) { + memcpy(gspca_dev->usb_buf, buffer, len); + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, index, - tmpbuf, len, 500); + gspca_dev->usb_buf, len, 500); } else { __u8 *tmpbuf; tmpbuf = kmalloc(len, GFP_KERNEL); memcpy(tmpbuf, buffer, len); - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), 0, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, value, index, @@ -443,8 +444,6 @@ static int sd_config(struct gspca_dev *gspca_dev, static int init_default_parameters(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - /* some of this registers are not really neded, because * they are overriden by setbrigthness, setcontrast, etc, * but wont hurt anyway, and can help someone with similar webcam @@ -509,49 +508,49 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) static const __u8 nset10[6] = { 0x0c, 0x03, 0xab, 0x10, 0x81, 0x20 }; - t16RegWrite(dev, 0x01, 0x0000, n1, 0x06); - t16RegWrite(dev, 0x01, 0x0000, nset, 0x06); - t16RegRead(dev, 0x0063, &test_byte, 1); - t16RegWrite(dev, 0x01, 0x0000, n2, 0x02); + reg_w(gspca_dev, 0x01, 0x0000, n1, 0x06); + reg_w(gspca_dev, 0x01, 0x0000, nset, 0x06); + reg_r_1(gspca_dev, 0x0063); + reg_w(gspca_dev, 0x01, 0x0000, n2, 0x02); while (read_indexs[i] != 0x00) { - t16RegRead(dev, read_indexs[i], &test_byte, 1); - PDEBUG(D_CONF, "Reg 0x%x => 0x%x", read_indexs[i], + test_byte = reg_r_1(gspca_dev, read_indexs[i]); + PDEBUG(D_CONF, "Reg 0x%02x => 0x%02x", read_indexs[i], test_byte); i++; } - t16RegWrite(dev, 0x01, 0x0000, n3, 0x06); - t16RegWrite(dev, 0x01, 0x0000, n4, 0x46); - t16RegRead(dev, 0x0080, &test_byte, 1); - t16RegWrite(dev, 0x00, 0x2c80, NULL, 0); - t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14); - t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12); - t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12); - t16RegWrite(dev, 0x00, 0x3880, NULL, 0); - t16RegWrite(dev, 0x00, 0x3880, NULL, 0); - t16RegWrite(dev, 0x00, 0x338e, NULL, 0); - t16RegWrite(dev, 0x01, 0x0000, nset5, 0x04); - t16RegWrite(dev, 0x00, 0x00a9, NULL, 0); - t16RegWrite(dev, 0x01, 0x0000, nset6, 0x22); - t16RegWrite(dev, 0x00, 0x86bb, NULL, 0); - t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0); - - t16RegWrite(dev, 0x01, 0x0000, missing, 0x08); - - t16RegWrite(dev, 0x00, 0x2087, NULL, 0); - t16RegWrite(dev, 0x00, 0x2088, NULL, 0); - t16RegWrite(dev, 0x00, 0x2089, NULL, 0); - - t16RegWrite(dev, 0x01, 0x0000, nset7, 0x04); - t16RegWrite(dev, 0x01, 0x0000, nset10, 0x06); - t16RegWrite(dev, 0x01, 0x0000, nset8, 0x06); - t16RegWrite(dev, 0x01, 0x0000, nset9, 0x04); - - t16RegWrite(dev, 0x00, 0x2880, NULL, 0); - t16RegWrite(dev, 0x01, 0x0000, nset2, 0x14); - t16RegWrite(dev, 0x01, 0x0000, nset3, 0x12); - t16RegWrite(dev, 0x01, 0x0000, nset4, 0x12); + reg_w(gspca_dev, 0x01, 0x0000, n3, 0x06); + reg_w(gspca_dev, 0x01, 0x0000, n4, 0x46); + reg_r_1(gspca_dev, 0x0080); + reg_w(gspca_dev, 0x00, 0x2c80, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14); + reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12); + reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12); + reg_w(gspca_dev, 0x00, 0x3880, NULL, 0); + reg_w(gspca_dev, 0x00, 0x3880, NULL, 0); + reg_w(gspca_dev, 0x00, 0x338e, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, nset5, 0x04); + reg_w(gspca_dev, 0x00, 0x00a9, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, nset6, 0x22); + reg_w(gspca_dev, 0x00, 0x86bb, NULL, 0); + reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0); + + reg_w(gspca_dev, 0x01, 0x0000, missing, 0x08); + + reg_w(gspca_dev, 0x00, 0x2087, NULL, 0); + reg_w(gspca_dev, 0x00, 0x2088, NULL, 0); + reg_w(gspca_dev, 0x00, 0x2089, NULL, 0); + + reg_w(gspca_dev, 0x01, 0x0000, nset7, 0x04); + reg_w(gspca_dev, 0x01, 0x0000, nset10, 0x06); + reg_w(gspca_dev, 0x01, 0x0000, nset8, 0x06); + reg_w(gspca_dev, 0x01, 0x0000, nset9, 0x04); + + reg_w(gspca_dev, 0x00, 0x2880, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14); + reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12); + reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12); return 0; } @@ -559,7 +558,6 @@ static int init_default_parameters(struct gspca_dev *gspca_dev) static void setbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; unsigned int brightness; __u8 set6[4] = { 0x8f, 0x26, 0xc3, 0x80 }; brightness = sd->brightness; @@ -571,13 +569,12 @@ static void setbrightness(struct gspca_dev *gspca_dev) set6[3] = 0x00 + ((brightness - 7) * 0xa); } - t16RegWrite(dev, 0x01, 0x0000, set6, 4); + reg_w(gspca_dev, 0x01, 0x0000, set6, 4); } static void setflip(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 flipcmd[8] = { 0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09 }; @@ -585,15 +582,14 @@ static void setflip(struct gspca_dev *gspca_dev) if (sd->mirror == 1) flipcmd[3] = 0x01; - t16RegWrite(dev, 0x01, 0x0000, flipcmd, 8); + reg_w(gspca_dev, 0x01, 0x0000, flipcmd, 8); } static void seteffect(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; - t16RegWrite(dev, 0x01, 0x0000, effects_table[sd->effect], 0x06); + reg_w(gspca_dev, 0x01, 0x0000, effects_table[sd->effect], 0x06); if (sd->effect == 1 || sd->effect == 5) { PDEBUG(D_CONF, "This effect have been disabled for webcam \"safety\""); @@ -601,15 +597,14 @@ static void seteffect(struct gspca_dev *gspca_dev) } if (sd->effect == 1 || sd->effect == 4) - t16RegWrite(dev, 0x00, 0x4aa6, NULL, 0); + reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0); else - t16RegWrite(dev, 0x00, 0xfaa6, NULL, 0); + reg_w(gspca_dev, 0x00, 0xfaa6, NULL, 0); } static void setwhitebalance(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 white_balance[8] = { 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 }; @@ -617,25 +612,23 @@ static void setwhitebalance(struct gspca_dev *gspca_dev) if (sd->whitebalance == 1) white_balance[7] = 0x3c; - t16RegWrite(dev, 0x01, 0x0000, white_balance, 8); + reg_w(gspca_dev, 0x01, 0x0000, white_balance, 8); } static void setlightfreq(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 }; if (sd->freq == 2) /* 60hz */ freq[1] = 0x00; - t16RegWrite(dev, 0x1, 0x0000, freq, 0x4); + reg_w(gspca_dev, 0x1, 0x0000, freq, 0x4); } static void setcontrast(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; unsigned int contrast = sd->contrast; __u16 reg_to_write = 0x00; @@ -644,17 +637,16 @@ static void setcontrast(struct gspca_dev *gspca_dev) else reg_to_write = (0x00a9 + ((contrast - 7) * 0x200)); - t16RegWrite(dev, 0x00, reg_to_write, NULL, 0); + reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0); } static void setcolors(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u16 reg_to_write; reg_to_write = 0xc0bb + sd->colors * 0x100; - t16RegWrite(dev, 0x00, reg_to_write, NULL, 0); + reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0); } static void setgamma(struct gspca_dev *gspca_dev) @@ -664,12 +656,11 @@ static void setgamma(struct gspca_dev *gspca_dev) static void setsharpness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; __u16 reg_to_write; reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness; - t16RegWrite(dev, 0x00, reg_to_write, NULL, 0); + reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0); } static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val) @@ -837,13 +828,12 @@ static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val) static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; sd->autogain = val; if (val != 0) - t16RegWrite(dev, 0x00, 0xf48e, NULL, 0); + reg_w(gspca_dev, 0x00, 0xf48e, NULL, 0); else - t16RegWrite(dev, 0x00, 0xb48e, NULL, 0); + reg_w(gspca_dev, 0x00, 0xb48e, NULL, 0); return 0; } @@ -857,9 +847,7 @@ static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val) static void sd_start(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; int mode; - __u8 test_byte; static const __u8 t1[] = { 0x66, 0x00, 0xa8, 0xe8 }; __u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 }; @@ -886,21 +874,21 @@ static void sd_start(struct gspca_dev *gspca_dev) break; } - t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[0], 0x8); - t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[1], 0x8); - t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[2], 0x8); - t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8); - t16RegWrite(dev, 0x00, 0x3c80, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[0], 0x8); + reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[1], 0x8); + reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[2], 0x8); + reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8); + reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0); /* just in case and to keep sync with logs (for mine) */ - t16RegWrite(dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8); - t16RegWrite(dev, 0x00, 0x3c80, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8); + reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0); /* just in case and to keep sync with logs (for mine) */ - t16RegWrite(dev, 0x01, 0x0000, t1, 4); - t16RegWrite(dev, 0x01, 0x0000, t2, 6); - t16RegRead(dev, 0x0012, &test_byte, 0x01); - t16RegWrite(dev, 0x01, 0x0000, t3, 0x10); - t16RegWrite(dev, 0x00, 0x0013, NULL, 0); - t16RegWrite(dev, 0x01, 0x0000, t4, 0x4); + reg_w(gspca_dev, 0x01, 0x0000, t1, 4); + reg_w(gspca_dev, 0x01, 0x0000, t2, 6); + reg_r_1(gspca_dev, 0x0012); + reg_w(gspca_dev, 0x01, 0x0000, t3, 0x10); + reg_w(gspca_dev, 0x00, 0x0013, NULL, 0); + reg_w(gspca_dev, 0x01, 0x0000, t4, 0x4); /* restart on each start, just in case, sometimes regs goes wrong * when using controls from app */ setbrightness(gspca_dev); diff --git a/drivers/media/video/gspca/tv8532.c b/drivers/media/video/gspca/tv8532.c index f9bffd67991..0b793899095 100644 --- a/drivers/media/video/gspca/tv8532.c +++ b/drivers/media/video/gspca/tv8532.c @@ -22,8 +22,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard "); MODULE_DESCRIPTION("TV8532 USB Camera Driver"); @@ -168,63 +168,74 @@ static const __u32 tv_8532_eeprom_data[] = { 0x0c0509f1, 0 }; -static void reg_r(struct usb_device *dev, - __u16 index, __u8 *buffer) +static int reg_r(struct gspca_dev *gspca_dev, + __u16 index) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), TV8532_REQ_RegRead, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, sizeof(__u8), + index, gspca_dev->usb_buf, 1, 500); + return gspca_dev->usb_buf[0]; } -static void reg_w(struct usb_device *dev, - __u16 index, __u8 *buffer, __u16 length) +/* write 1 byte */ +static void reg_w_1(struct gspca_dev *gspca_dev, + __u16 index, __u8 value) { - usb_control_msg(dev, - usb_sndctrlpipe(dev, 0), + gspca_dev->usb_buf[0] = value; + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), TV8532_REQ_RegWrite, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, /* value */ - index, buffer, length, 500); + index, gspca_dev->usb_buf, 1, 500); +} + +/* write 2 bytes */ +static void reg_w_2(struct gspca_dev *gspca_dev, + __u16 index, __u8 val1, __u8 val2) +{ + gspca_dev->usb_buf[0] = val1; + gspca_dev->usb_buf[1] = val2; + usb_control_msg(gspca_dev->dev, + usb_sndctrlpipe(gspca_dev->dev, 0), + TV8532_REQ_RegWrite, + USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0, /* value */ + index, gspca_dev->usb_buf, 2, 500); } static void tv_8532WriteEEprom(struct gspca_dev *gspca_dev) { int i = 0; - __u8 reg, data0, data1, data2, datacmd; - struct usb_device *dev = gspca_dev->dev; + __u8 reg, data0, data1, data2; - datacmd = 0xb0;; - reg_w(dev, TV8532_GPIO, &datacmd, 1); - datacmd = TV8532_CMD_EEprom_Open; - reg_w(dev, TV8532_CTRL, &datacmd, 1); + reg_w_1(gspca_dev, TV8532_GPIO, 0xb0); + reg_w_1(gspca_dev, TV8532_CTRL, TV8532_CMD_EEprom_Open); /* msleep(1); */ while (tv_8532_eeprom_data[i]) { reg = (tv_8532_eeprom_data[i] & 0xff000000) >> 24; - reg_w(dev, TV8532_EEprom_Add, ®, 1); + reg_w_1(gspca_dev, TV8532_EEprom_Add, reg); /* msleep(1); */ data0 = (tv_8532_eeprom_data[i] & 0x000000ff); - reg_w(dev, TV8532_EEprom_DataL, &data0, 1); + reg_w_1(gspca_dev, TV8532_EEprom_DataL, data0); /* msleep(1); */ - data1 = (tv_8532_eeprom_data[i] & 0x0000FF00) >> 8; - reg_w(dev, TV8532_EEprom_DataM, &data1, 1); + data1 = (tv_8532_eeprom_data[i] & 0x0000ff00) >> 8; + reg_w_1(gspca_dev, TV8532_EEprom_DataM, data1); /* msleep(1); */ - data2 = (tv_8532_eeprom_data[i] & 0x00FF0000) >> 16; - reg_w(dev, TV8532_EEprom_DataH, &data2, 1); + data2 = (tv_8532_eeprom_data[i] & 0x00ff0000) >> 16; + reg_w_1(gspca_dev, TV8532_EEprom_DataH, data2); /* msleep(1); */ - datacmd = 0; - reg_w(dev, TV8532_EEprom_Write, &datacmd, 1); + reg_w_1(gspca_dev, TV8532_EEprom_Write, 0); /* msleep(10); */ i++; } - datacmd = i; - reg_w(dev, TV8532_EEprom_TableLength, &datacmd, 1); + reg_w_1(gspca_dev, TV8532_EEprom_TableLength, i); /* msleep(1); */ - datacmd = TV8532_CMD_EEprom_Close; - reg_w(dev, TV8532_CTRL, &datacmd, 1); + reg_w_1(gspca_dev, TV8532_CTRL, TV8532_CMD_EEprom_Close); msleep(10); } @@ -250,154 +261,121 @@ static int sd_config(struct gspca_dev *gspca_dev, static void tv_8532ReadRegisters(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; __u8 data; -/* __u16 vid, pid; */ - reg_r(dev, 0x0001, &data); + data = reg_r(gspca_dev, 0x0001); PDEBUG(D_USBI, "register 0x01-> %x", data); - reg_r(dev, 0x0002, &data); + data = reg_r(gspca_dev, 0x0002); PDEBUG(D_USBI, "register 0x02-> %x", data); - reg_r(dev, TV8532_ADWIDTH_L, &data); - reg_r(dev, TV8532_ADWIDTH_H, &data); - reg_r(dev, TV8532_QUANT_COMP, &data); - reg_r(dev, TV8532_MODE_PACKET, &data); - reg_r(dev, TV8532_SETCLK, &data); - reg_r(dev, TV8532_POINT_L, &data); - reg_r(dev, TV8532_POINT_H, &data); - reg_r(dev, TV8532_POINTB_L, &data); - reg_r(dev, TV8532_POINTB_H, &data); - reg_r(dev, TV8532_BUDGET_L, &data); - reg_r(dev, TV8532_BUDGET_H, &data); - reg_r(dev, TV8532_VID_L, &data); - reg_r(dev, TV8532_VID_H, &data); - reg_r(dev, TV8532_PID_L, &data); - reg_r(dev, TV8532_PID_H, &data); - reg_r(dev, TV8532_DeviceID, &data); - reg_r(dev, TV8532_AD_COLBEGIN_L, &data); - reg_r(dev, TV8532_AD_COLBEGIN_H, &data); - reg_r(dev, TV8532_AD_ROWBEGIN_L, &data); - reg_r(dev, TV8532_AD_ROWBEGIN_H, &data); + reg_r(gspca_dev, TV8532_ADWIDTH_L); + reg_r(gspca_dev, TV8532_ADWIDTH_H); + reg_r(gspca_dev, TV8532_QUANT_COMP); + reg_r(gspca_dev, TV8532_MODE_PACKET); + reg_r(gspca_dev, TV8532_SETCLK); + reg_r(gspca_dev, TV8532_POINT_L); + reg_r(gspca_dev, TV8532_POINT_H); + reg_r(gspca_dev, TV8532_POINTB_L); + reg_r(gspca_dev, TV8532_POINTB_H); + reg_r(gspca_dev, TV8532_BUDGET_L); + reg_r(gspca_dev, TV8532_BUDGET_H); + reg_r(gspca_dev, TV8532_VID_L); + reg_r(gspca_dev, TV8532_VID_H); + reg_r(gspca_dev, TV8532_PID_L); + reg_r(gspca_dev, TV8532_PID_H); + reg_r(gspca_dev, TV8532_DeviceID); + reg_r(gspca_dev, TV8532_AD_COLBEGIN_L); + reg_r(gspca_dev, TV8532_AD_COLBEGIN_H); + reg_r(gspca_dev, TV8532_AD_ROWBEGIN_L); + reg_r(gspca_dev, TV8532_AD_ROWBEGIN_H); } static void tv_8532_setReg(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 data; - __u8 value[2] = { 0, 0 }; - - data = ADCBEGINL; - reg_w(dev, TV8532_AD_COLBEGIN_L, &data, 1); /* 0x10 */ - data = ADCBEGINH; /* also digital gain */ - reg_w(dev, TV8532_AD_COLBEGIN_H, &data, 1); - data = TV8532_CMD_UPDATE; - reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */ - - data = 0x0a; - reg_w(dev, TV8532_GPIO_OE, &data, 1); + reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_L, + ADCBEGINL); /* 0x10 */ + reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_H, + ADCBEGINH); /* also digital gain */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, + TV8532_CMD_UPDATE); /* 0x00<-0x84 */ + + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0a); /******************************************************/ - data = ADHEIGHL; - reg_w(dev, TV8532_ADHEIGHT_L, &data, 1); /* 0e */ - data = ADHEIGHH; - reg_w(dev, TV8532_ADHEIGHT_H, &data, 1); /* 0f */ - value[0] = EXPOL; - value[1] = EXPOH; /* 350d 0x014c; */ - reg_w(dev, TV8532_EXPOSURE, value, 2); /* 1c */ - data = ADCBEGINL; - reg_w(dev, TV8532_AD_COLBEGIN_L, &data, 1); /* 0x10 */ - data = ADCBEGINH; /* also digital gain */ - reg_w(dev, TV8532_AD_COLBEGIN_H, &data, 1); - data = ADRBEGINL; - reg_w(dev, TV8532_AD_ROWBEGIN_L, &data, 1); /* 0x14 */ - - data = 0x00; - reg_w(dev, TV8532_AD_SLOPE, &data, 1); /* 0x91 */ - data = 0x02; - reg_w(dev, TV8532_AD_BITCTRL, &data, 1); /* 0x94 */ - - - data = TV8532_CMD_EEprom_Close; - reg_w(dev, TV8532_CTRL, &data, 1); /* 0x01 */ - - data = 0x00; - reg_w(dev, TV8532_AD_SLOPE, &data, 1); /* 0x91 */ - data = TV8532_CMD_UPDATE; - reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */ + reg_w_1(gspca_dev, TV8532_ADHEIGHT_L, ADHEIGHL); /* 0e */ + reg_w_1(gspca_dev, TV8532_ADHEIGHT_H, ADHEIGHH); /* 0f */ + reg_w_2(gspca_dev, TV8532_EXPOSURE, + EXPOL, EXPOH); /* 350d 0x014c; 1c */ + reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_L, + ADCBEGINL); /* 0x10 */ + reg_w_1(gspca_dev, TV8532_AD_COLBEGIN_H, + ADCBEGINH); /* also digital gain */ + reg_w_1(gspca_dev, TV8532_AD_ROWBEGIN_L, + ADRBEGINL); /* 0x14 */ + + reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x00); /* 0x91 */ + reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x02); /* 0x94 */ + + reg_w_1(gspca_dev, TV8532_CTRL, + TV8532_CMD_EEprom_Close); /* 0x01 */ + + reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x00); /* 0x91 */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, + TV8532_CMD_UPDATE); /* 0x00<-0x84 */ } static void tv_8532_PollReg(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 data; int i; /* strange polling from tgc */ for (i = 0; i < 10; i++) { - data = TESTCLK; /* 0x48; //0x08; */ - reg_w(dev, TV8532_SETCLK, &data, 1); /* 0x2c */ - data = TV8532_CMD_UPDATE; - reg_w(dev, TV8532_PART_CTRL, &data, 1); - data = 0x01; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_SETCLK, + TESTCLK); /* 0x48; //0x08; 0x2c */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, TV8532_CMD_UPDATE); + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01); /* 0x31 */ } } /* this function is called at open time */ static int sd_open(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 data; - __u8 dataStart; - __u8 value[2]; - - data = 0x32; - reg_w(dev, TV8532_AD_SLOPE, &data, 1); - data = 0; - reg_w(dev, TV8532_AD_BITCTRL, &data, 1); + reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x32); + reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x00); tv_8532ReadRegisters(gspca_dev); - data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, 1); - value[0] = ADHEIGHL; - value[1] = ADHEIGHH; /* 401d 0x0169; */ - reg_w(dev, TV8532_ADHEIGHT_L, value, 2); /* 0e */ - value[0] = EXPOL; - value[1] = EXPOH; /* 350d 0x014c; */ - reg_w(dev, TV8532_EXPOSURE, value, 2); /* 1c */ - data = ADWIDTHL; /* 0x20; */ - reg_w(dev, TV8532_ADWIDTH_L, &data, 1); /* 0x0c */ - data = ADWIDTHH; - reg_w(dev, TV8532_ADWIDTH_H, &data, 1); /* 0x0d */ + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b); + reg_w_2(gspca_dev, TV8532_ADHEIGHT_L, ADHEIGHL, + ADHEIGHH); /* 401d 0x0169; 0e */ + reg_w_2(gspca_dev, TV8532_EXPOSURE, EXPOL, + EXPOH); /* 350d 0x014c; 1c */ + reg_w_1(gspca_dev, TV8532_ADWIDTH_L, ADWIDTHL); /* 0x20; 0x0c */ + reg_w_1(gspca_dev, TV8532_ADWIDTH_H, ADWIDTHH); /* 0x0d */ /*******************************************************************/ - data = TESTCOMP; /* 0x72 compressed mode */ - reg_w(dev, TV8532_QUANT_COMP, &data, 1); /* 0x28 */ - data = TESTLINE; /* 0x84; // CIF | 4 packet */ - reg_w(dev, TV8532_MODE_PACKET, &data, 1); /* 0x29 */ + reg_w_1(gspca_dev, TV8532_QUANT_COMP, + TESTCOMP); /* 0x72 compressed mode 0x28 */ + reg_w_1(gspca_dev, TV8532_MODE_PACKET, + TESTLINE); /* 0x84; // CIF | 4 packet 0x29 */ /************************************************/ - data = TESTCLK; /* 0x48; //0x08; */ - reg_w(dev, TV8532_SETCLK, &data, 1); /* 0x2c */ - data = TESTPTL; /* 0x38; */ - reg_w(dev, TV8532_POINT_L, &data, 1); /* 0x2d */ - data = TESTPTH; /* 0x04; */ - reg_w(dev, TV8532_POINT_H, &data, 1); /* 0x2e */ - dataStart = TESTPTBL; /* 0x04; */ - reg_w(dev, TV8532_POINTB_L, &dataStart, 1); /* 0x2f */ - data = TESTPTBH; /* 0x04; */ - reg_w(dev, TV8532_POINTB_H, &data, 1); /* 0x30 */ - data = TV8532_CMD_UPDATE; - reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */ + reg_w_1(gspca_dev, TV8532_SETCLK, + TESTCLK); /* 0x48; //0x08; 0x2c */ + reg_w_1(gspca_dev, TV8532_POINT_L, + TESTPTL); /* 0x38; 0x2d */ + reg_w_1(gspca_dev, TV8532_POINT_H, + TESTPTH); /* 0x04; 0x2e */ + reg_w_1(gspca_dev, TV8532_POINTB_L, + TESTPTBL); /* 0x04; 0x2f */ + reg_w_1(gspca_dev, TV8532_POINTB_H, + TESTPTBH); /* 0x04; 0x30 */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, + TV8532_CMD_UPDATE); /* 0x00<-0x84 */ /*************************************************/ - data = 0x01; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01); /* 0x31 */ msleep(200); - data = 0x00; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00); /* 0x31 */ /*************************************************/ tv_8532_setReg(gspca_dev); /*************************************************/ - data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, 1); + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b); /*************************************************/ tv_8532_setReg(gspca_dev); /*************************************************/ @@ -408,94 +386,72 @@ static int sd_open(struct gspca_dev *gspca_dev) static void setbrightness(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - __u8 value[2]; - __u8 data; int brightness = sd->brightness; - value[1] = (brightness >> 8) & 0xff; - value[0] = (brightness) & 0xff; - reg_w(gspca_dev->dev, TV8532_EXPOSURE, value, 2); /* 1c */ - data = TV8532_CMD_UPDATE; - reg_w(gspca_dev->dev, TV8532_PART_CTRL, &data, 1); + reg_w_2(gspca_dev, TV8532_EXPOSURE, + brightness >> 8, brightness); /* 1c */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, TV8532_CMD_UPDATE); } /* -- start the camera -- */ static void sd_start(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 data; - __u8 value[2]; - - data = 0x32; - reg_w(dev, TV8532_AD_SLOPE, &data, 1); - data = 0; - reg_w(dev, TV8532_AD_BITCTRL, &data, 1); + reg_w_1(gspca_dev, TV8532_AD_SLOPE, 0x32); + reg_w_1(gspca_dev, TV8532_AD_BITCTRL, 0x00); tv_8532ReadRegisters(gspca_dev); - data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, 1); - value[0] = ADHEIGHL; - value[1] = ADHEIGHH; /* 401d 0x0169; */ - reg_w(dev, TV8532_ADHEIGHT_L, value, 2); /* 0e */ -/* value[0] = EXPOL; value[1] =EXPOH; * 350d 0x014c; */ -/* reg_w(dev,TV8532_REQ_RegWrite,0,TV8532_EXPOSURE,value,2); * 1c */ + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b); + reg_w_2(gspca_dev, TV8532_ADHEIGHT_L, + ADHEIGHL, ADHEIGHH); /* 401d 0x0169; 0e */ +/* reg_w_2(gspca_dev, TV8532_EXPOSURE, + EXPOL, EXPOH); * 350d 0x014c; 1c */ setbrightness(gspca_dev); - data = ADWIDTHL; /* 0x20; */ - reg_w(dev, TV8532_ADWIDTH_L, &data, 1); /* 0x0c */ - data = ADWIDTHH; - reg_w(dev, TV8532_ADWIDTH_H, &data, 1); /* 0x0d */ + reg_w_1(gspca_dev, TV8532_ADWIDTH_L, ADWIDTHL); /* 0x20; 0x0c */ + reg_w_1(gspca_dev, TV8532_ADWIDTH_H, ADWIDTHH); /* 0x0d */ /************************************************/ - data = TESTCOMP; /* 0x72 compressed mode */ - reg_w(dev, TV8532_QUANT_COMP, &data, 1); /* 0x28 */ + reg_w_1(gspca_dev, TV8532_QUANT_COMP, + TESTCOMP); /* 0x72 compressed mode 0x28 */ if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { /* 176x144 */ - data = QCIFLINE; /* 0x84; // CIF | 4 packet */ - reg_w(dev, TV8532_MODE_PACKET, &data, 1); /* 0x29 */ + reg_w_1(gspca_dev, TV8532_MODE_PACKET, + QCIFLINE); /* 0x84; // CIF | 4 packet 0x29 */ } else { /* 352x288 */ - data = TESTLINE; /* 0x84; // CIF | 4 packet */ - reg_w(dev, TV8532_MODE_PACKET, &data, 1); /* 0x29 */ + reg_w_1(gspca_dev, TV8532_MODE_PACKET, + TESTLINE); /* 0x84; // CIF | 4 packet 0x29 */ } /************************************************/ - data = TESTCLK; /* 0x48; //0x08; */ - reg_w(dev, TV8532_SETCLK, &data, 1); /* 0x2c */ - data = TESTPTL; /* 0x38; */ - reg_w(dev, TV8532_POINT_L, &data, 1); /* 0x2d */ - data = TESTPTH; /* 0x04; */ - reg_w(dev, TV8532_POINT_H, &data, 1); /* 0x2e */ - data = TESTPTBL; /* 0x04; */ - reg_w(dev, TV8532_POINTB_L, &data, 1); /* 0x2f */ - data = TESTPTBH; /* 0x04; */ - reg_w(dev, TV8532_POINTB_H, &data, 1); /* 0x30 */ - data = TV8532_CMD_UPDATE; - reg_w(dev, TV8532_PART_CTRL, &data, 1); /* 0x00<-0x84 */ + reg_w_1(gspca_dev, TV8532_SETCLK, + TESTCLK); /* 0x48; //0x08; 0x2c */ + reg_w_1(gspca_dev, TV8532_POINT_L, + TESTPTL); /* 0x38; 0x2d */ + reg_w_1(gspca_dev, TV8532_POINT_H, + TESTPTH); /* 0x04; 0x2e */ + reg_w_1(gspca_dev, TV8532_POINTB_L, + TESTPTBL); /* 0x04; 0x2f */ + reg_w_1(gspca_dev, TV8532_POINTB_H, + TESTPTBH); /* 0x04; 0x30 */ + reg_w_1(gspca_dev, TV8532_PART_CTRL, + TV8532_CMD_UPDATE); /* 0x00<-0x84 */ /************************************************/ - data = 0x01; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x01); /* 0x31 */ msleep(200); - data = 0x00; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00); /* 0x31 */ /************************************************/ tv_8532_setReg(gspca_dev); /************************************************/ - data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, 1); + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b); /************************************************/ tv_8532_setReg(gspca_dev); /************************************************/ tv_8532_PollReg(gspca_dev); - data = 0x00; - reg_w(dev, TV8532_UDP_UPDATE, &data, 1); /* 0x31 */ + reg_w_1(gspca_dev, TV8532_UDP_UPDATE, 0x00); /* 0x31 */ } static void sd_stopN(struct gspca_dev *gspca_dev) { - struct usb_device *dev = gspca_dev->dev; - __u8 data; - - data = 0x0b; - reg_w(dev, TV8532_GPIO_OE, &data, 1); + reg_w_1(gspca_dev, TV8532_GPIO_OE, 0x0b); } static void sd_stop0(struct gspca_dev *gspca_dev) diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c index 668e024aaa8..dd7c1389f38 100644 --- a/drivers/media/video/gspca/vc032x.c +++ b/drivers/media/video/gspca/vc032x.c @@ -1227,17 +1227,18 @@ static const struct sensor_info sensor_info_data[] = { {SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01}, }; -static void reg_r(struct usb_device *dev, - __u16 req, - __u16 index, - __u8 *buffer, __u16 length) +/* read 'len' bytes in gspca_dev->usb_buf */ +static void reg_r(struct gspca_dev *gspca_dev, + __u16 req, + __u16 index, + __u16 len) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), req, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, /* value */ - index, buffer, length, + index, gspca_dev->usb_buf, len, 500); } @@ -1254,55 +1255,55 @@ static void reg_w(struct usb_device *dev, 500); } -static void vc032x_read_sensor_register(struct usb_device *dev, +static void read_sensor_register(struct gspca_dev *gspca_dev, __u16 address, __u16 *value) { + struct usb_device *dev = gspca_dev->dev; __u8 ldata, mdata, hdata; - __u8 tmpvalue = 0; int retry = 50; - ldata = 0; - mdata = 0; - hdata = 0; + *value = 0; - reg_r(dev, 0xa1, 0xb33f, &tmpvalue, 1); + reg_r(gspca_dev, 0xa1, 0xb33f, 1); /*PDEBUG(D_PROBE, " I2c Bus Busy Wait 0x%02X ", tmpvalue); */ - if (!(tmpvalue & 0x02)) { - PDEBUG(D_ERR, "I2c Bus Busy Wait %d", tmpvalue & 0x02); + if (!(gspca_dev->usb_buf[0] & 0x02)) { + PDEBUG(D_ERR, "I2c Bus Busy Wait %d", + gspca_dev->usb_buf[0] & 0x02); return; } reg_w(dev, 0xa0, address, 0xb33a); reg_w(dev, 0xa0, 0x02, 0xb339); - tmpvalue = 0; - reg_r(dev, 0xa1, 0xb33b, &tmpvalue, 1); - while (retry-- && tmpvalue) { - reg_r(dev, 0xa1, 0xb33b, &tmpvalue, 1); + reg_r(gspca_dev, 0xa1, 0xb33b, 1); + while (retry-- && gspca_dev->usb_buf[0]) { + reg_r(gspca_dev, 0xa1, 0xb33b, 1); /* PDEBUG(D_PROBE, "Read again 0xb33b %d", tmpvalue); */ msleep(1); } - reg_r(dev, 0xa1, 0xb33e, &hdata, 1); - reg_r(dev, 0xa1, 0xb33d, &mdata, 1); - reg_r(dev, 0xa1, 0xb33c, &ldata, 1); + reg_r(gspca_dev, 0xa1, 0xb33e, 1); + hdata = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0xa1, 0xb33d, 1); + mdata = gspca_dev->usb_buf[0]; + reg_r(gspca_dev, 0xa1, 0xb33c, 1); + ldata = gspca_dev->usb_buf[0]; PDEBUG(D_PROBE, "Read Sensor h (0x%02X) m (0x%02X) l (0x%02X)", hdata, mdata, ldata); - tmpvalue = 0; - reg_r(dev, 0xa1, 0xb334, &tmpvalue, 1); - if (tmpvalue == 0x02) + reg_r(gspca_dev, 0xa1, 0xb334, 1); + if (gspca_dev->usb_buf[0] == 0x02) *value = (ldata << 8) + mdata; else *value = ldata; } + static int vc032x_probe_sensor(struct gspca_dev *gspca_dev) { struct usb_device *dev = gspca_dev->dev; int i; - __u8 data; __u16 value; const struct sensor_info *ptsensor_info; - reg_r(dev, 0xa1, 0xbfcf, &data, 1); - PDEBUG(D_PROBE, "check sensor header %d", data); + reg_r(gspca_dev, 0xa1, 0xbfcf, 1); + PDEBUG(D_PROBE, "check sensor header %d", gspca_dev->usb_buf[0]); for (i = 0; i < ARRAY_SIZE(sensor_info_data); i++) { ptsensor_info = &sensor_info_data[i]; reg_w(dev, 0xa0, 0x02, 0xb334); @@ -1315,7 +1316,7 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev) "check sensor VC032X -> %d Add -> ox%02X!", i, ptsensor_info->I2cAdd); */ reg_w(dev, 0xa0, ptsensor_info->op, 0xb301); - vc032x_read_sensor_register(dev, ptsensor_info->IdAdd, &value); + read_sensor_register(gspca_dev, ptsensor_info->IdAdd, &value); if (value == ptsensor_info->VpId) { /* PDEBUG(D_PROBE, "find sensor VC032X -> ox%04X!", ptsensor_info->VpId); */ @@ -1325,14 +1326,14 @@ static int vc032x_probe_sensor(struct gspca_dev *gspca_dev) return -1; } -static __u8 i2c_write(struct usb_device *dev, +static __u8 i2c_write(struct gspca_dev *gspca_dev, __u8 reg, const __u8 *val, __u8 size) { - __u8 retbyte; + struct usb_device *dev = gspca_dev->dev; if (size > 3 || size < 1) return -EINVAL; - reg_r(dev, 0xa1, 0xb33f, &retbyte, 1); + reg_r(gspca_dev, 0xa1, 0xb33f, 1); reg_w(dev, 0xa0, size, 0xb334); reg_w(dev, 0xa0, reg, 0xb33a); switch (size) { @@ -1353,8 +1354,8 @@ static __u8 i2c_write(struct usb_device *dev, return -EINVAL; } reg_w(dev, 0xa0, 0x01, 0xb339); - reg_r(dev, 0xa1, 0xb33b, &retbyte, 1); - return retbyte == 0; + reg_r(gspca_dev, 0xa1, 0xb33b, 1); + return gspca_dev->usb_buf[0] == 0; } static void put_tab_to_reg(struct gspca_dev *gspca_dev, @@ -1382,10 +1383,10 @@ static void usb_exchange(struct gspca_dev *gspca_dev, ((data[i][0])<<8) | data[i][1]); break; case 0xaa: /* i2c op */ - i2c_write(dev, data[i][1], &data[i][2], 1); + i2c_write(gspca_dev, data[i][1], &data[i][2], 1); break; case 0xbb: /* i2c op */ - i2c_write(dev, data[i][0], &data[i][1], 2); + i2c_write(gspca_dev, data[i][0], &data[i][1], 2); break; case 0xdd: msleep(data[i][2] + 10); @@ -1417,7 +1418,6 @@ static int sd_config(struct gspca_dev *gspca_dev, struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; struct cam *cam; - __u8 tmp2[4]; int sensor; __u16 product; @@ -1488,10 +1488,10 @@ static int sd_config(struct gspca_dev *gspca_dev, sd->lightfreq = FREQ_DEF; if (sd->bridge == BRIDGE_VC0321) { - reg_r(dev, 0x8a, 0, tmp2, 3); + reg_r(gspca_dev, 0x8a, 0, 3); reg_w(dev, 0x87, 0x00, 0x0f0f); - reg_r(dev, 0x8b, 0, tmp2, 3); + reg_r(gspca_dev, 0x8b, 0, 3); reg_w(dev, 0x88, 0x00, 0x0202); } return 0; @@ -1525,7 +1525,6 @@ static void setlightfreq(struct gspca_dev *gspca_dev) static void sd_start(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; -/* __u8 tmp2; */ const __u8 *GammaT = NULL; const __u8 *MatrixT = NULL; int mode; @@ -1627,7 +1626,7 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(gspca_dev->dev, 0xa0, 0x40, 0xb824); */ /* Only works for HV7131R ?? - reg_r (gspca_dev->dev, 0xa1, 0xb881, &tmp2, 1); + reg_r (gspca_dev, 0xa1, 0xb881, 1); reg_w(gspca_dev->dev, 0xa0, 0xfe01, 0xb881); reg_w(gspca_dev->dev, 0xa0, 0x79, 0xb801); */ diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c index bac45a19365..548c4c8c3f3 100644 --- a/drivers/media/video/gspca/zc3xx.c +++ b/drivers/media/video/gspca/zc3xx.c @@ -24,8 +24,8 @@ #include "gspca.h" -#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5) -static const char version[] = "2.1.5"; +#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7) +static const char version[] = "2.1.7"; MODULE_AUTHOR("Michel Xhaard , " "Serge A. Suchkov "); @@ -6214,23 +6214,27 @@ static const struct usb_action tas5130c_vf0250_NoFlikerScale[] = { {} }; -static void reg_r_i(struct usb_device *dev, - __u16 index, __u8 *buffer) +static int reg_r_i(struct gspca_dev *gspca_dev, + __u16 index) { - usb_control_msg(dev, - usb_rcvctrlpipe(dev, 0), + usb_control_msg(gspca_dev->dev, + usb_rcvctrlpipe(gspca_dev->dev, 0), 0xa1, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0x01, /* value */ - index, buffer, 1, + index, gspca_dev->usb_buf, 1, 500); + return gspca_dev->usb_buf[0]; } -static void reg_r(struct usb_device *dev, - __u16 index, __u8 *buffer) +static int reg_r(struct gspca_dev *gspca_dev, + __u16 index) { - reg_r_i(dev, index, buffer); - PDEBUG(D_USBI, "reg r [%04x] -> %02x", index, *buffer); + int ret; + + ret = reg_r_i(gspca_dev, index); + PDEBUG(D_USBI, "reg r [%04x] -> %02x", index, ret); + return ret; } static void reg_w_i(struct usb_device *dev, @@ -6253,55 +6257,54 @@ static void reg_w(struct usb_device *dev, reg_w_i(dev, value, index); } -static __u16 i2c_read(struct usb_device *dev, __u8 reg) +static __u16 i2c_read(struct gspca_dev *gspca_dev, + __u8 reg) { __u8 retbyte; __u8 retval[2]; - reg_w_i(dev, reg, 0x92); - reg_w_i(dev, 0x02, 0x90); /* <- read command */ + reg_w_i(gspca_dev->dev, reg, 0x92); + reg_w_i(gspca_dev->dev, 0x02, 0x90); /* <- read command */ msleep(25); - reg_r_i(dev, 0x0091, &retbyte); /* read status */ - reg_r_i(dev, 0x0095, &retval[0]); /* read Lowbyte */ - reg_r_i(dev, 0x0096, &retval[1]); /* read Hightbyte */ + retbyte = reg_r_i(gspca_dev, 0x0091); /* read status */ + retval[0] = reg_r_i(gspca_dev, 0x0095); /* read Lowbyte */ + retval[1] = reg_r_i(gspca_dev, 0x0096); /* read Hightbyte */ PDEBUG(D_USBO, "i2c r [%02x] -> (%02x) %02x%02x", reg, retbyte, retval[1], retval[0]); return (retval[1] << 8) | retval[0]; } -static __u8 i2c_write(struct usb_device *dev, +static __u8 i2c_write(struct gspca_dev *gspca_dev, __u8 reg, __u8 valL, __u8 valH) { __u8 retbyte; - reg_w_i(dev, reg, 0x92); - reg_w_i(dev, valL, 0x93); - reg_w_i(dev, valH, 0x94); - reg_w_i(dev, 0x01, 0x90); /* <- write command */ + reg_w_i(gspca_dev->dev, reg, 0x92); + reg_w_i(gspca_dev->dev, valL, 0x93); + reg_w_i(gspca_dev->dev, valH, 0x94); + reg_w_i(gspca_dev->dev, 0x01, 0x90); /* <- write command */ msleep(5); - reg_r_i(dev, 0x0091, &retbyte); /* read status */ + retbyte = reg_r_i(gspca_dev, 0x0091); /* read status */ PDEBUG(D_USBO, "i2c w [%02x] %02x%02x (%02x)", reg, valH, valL, retbyte); return retbyte; } -static void usb_exchange(struct usb_device *dev, +static void usb_exchange(struct gspca_dev *gspca_dev, const struct usb_action *action) { - __u8 buffread; - while (action->req) { switch (action->req) { case 0xa0: /* write register */ - reg_w(dev, action->val, action->idx); + reg_w(gspca_dev->dev, action->val, action->idx); break; case 0xa1: /* read status */ - reg_r(dev, action->idx, &buffread); + reg_r(gspca_dev, action->idx); break; case 0xaa: - i2c_write(dev, + i2c_write(gspca_dev, action->val, /* reg */ action->idx & 0xff, /* valL */ action->idx >> 8); /* valH */ @@ -6376,7 +6379,6 @@ static void setsharpness(struct gspca_dev *gspca_dev) struct sd *sd = (struct sd *) gspca_dev; struct usb_device *dev = gspca_dev->dev; int sharpness; - __u8 retbyte; static const __u8 sharpness_tb[][2] = { {0x02, 0x03}, {0x04, 0x07}, @@ -6386,9 +6388,9 @@ static void setsharpness(struct gspca_dev *gspca_dev) sharpness = sd->sharpness; reg_w(dev, sharpness_tb[sharpness][0], 0x01c6); - reg_r(dev, 0x01c8, &retbyte); - reg_r(dev, 0x01c9, &retbyte); - reg_r(dev, 0x01ca, &retbyte); + reg_r(gspca_dev, 0x01c8); + reg_r(gspca_dev, 0x01c9); + reg_r(gspca_dev, 0x01ca); reg_w(dev, sharpness_tb[sharpness][1], 0x01cb); } @@ -6398,7 +6400,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) struct usb_device *dev = gspca_dev->dev; const __u8 *Tgamma, *Tgradient; int g, i, k; - static const __u8 kgamma_tb[16] = /* delta for contrast */ + static const __u8 kgamma_tb[16] = /* delta for contrast */ {0x15, 0x0d, 0x0a, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08}; static const __u8 kgrad_tb[16] = @@ -6623,7 +6625,7 @@ static int setlightfreq(struct gspca_dev *gspca_dev) i++; /* 640x480 */ zc3_freq = freq_tb[(int) sd->sensor][i]; if (zc3_freq != NULL) { - usb_exchange(gspca_dev->dev, zc3_freq); + usb_exchange(gspca_dev, zc3_freq); switch (sd->sensor) { case SENSOR_GC0305: if (mode /* if 320x240 */ @@ -6687,44 +6689,45 @@ static void start_2wr_probe(struct usb_device *dev, int sensor) /* msleep(2); */ } -static int sif_probe(struct usb_device *dev) +static int sif_probe(struct gspca_dev *gspca_dev) { __u16 checkword; - start_2wr_probe(dev, 0x0f); /* PAS106 */ - reg_w(dev, 0x08, 0x008d); + start_2wr_probe(gspca_dev->dev, 0x0f); /* PAS106 */ + reg_w(gspca_dev->dev, 0x08, 0x008d); msleep(150); - checkword = ((i2c_read(dev, 0x00) & 0x0f) << 4) - | ((i2c_read(dev, 0x01) & 0xf0) >> 4); + checkword = ((i2c_read(gspca_dev, 0x00) & 0x0f) << 4) + | ((i2c_read(gspca_dev, 0x01) & 0xf0) >> 4); PDEBUG(D_PROBE, "probe sif 0x%04x", checkword); if (checkword == 0x0007) { - send_unknown(dev, SENSOR_PAS106); + send_unknown(gspca_dev->dev, SENSOR_PAS106); return 0x0f; /* PAS106 */ } return -1; } -static int vga_2wr_probe(struct usb_device *dev) +static int vga_2wr_probe(struct gspca_dev *gspca_dev) { + struct usb_device *dev = gspca_dev->dev; __u8 retbyte; __u16 checkword; start_2wr_probe(dev, 0x00); /* HV7131B */ - i2c_write(dev, 0x01, 0xaa, 0x00); - retbyte = i2c_read(dev, 0x01); + i2c_write(gspca_dev, 0x01, 0xaa, 0x00); + retbyte = i2c_read(gspca_dev, 0x01); if (retbyte != 0) return 0x00; /* HV7131B */ start_2wr_probe(dev, 0x04); /* CS2102 */ - i2c_write(dev, 0x01, 0xaa, 0x00); - retbyte = i2c_read(dev, 0x01); + i2c_write(gspca_dev, 0x01, 0xaa, 0x00); + retbyte = i2c_read(gspca_dev, 0x01); if (retbyte != 0) return 0x04; /* CS2102 */ start_2wr_probe(dev, 0x06); /* OmniVision */ reg_w(dev, 0x08, 0x8d); - i2c_write(dev, 0x11, 0xaa, 0x00); - retbyte = i2c_read(dev, 0x11); + i2c_write(gspca_dev, 0x11, 0xaa, 0x00); + retbyte = i2c_read(gspca_dev, 0x11); if (retbyte != 0) { /* (should have returned 0xaa) --> Omnivision? */ /* reg_r 0x10 -> 0x06 --> */ @@ -6732,45 +6735,45 @@ static int vga_2wr_probe(struct usb_device *dev) } start_2wr_probe(dev, 0x08); /* HDCS2020 */ - i2c_write(dev, 0x15, 0xaa, 0x00); - retbyte = i2c_read(dev, 0x15); + i2c_write(gspca_dev, 0x15, 0xaa, 0x00); + retbyte = i2c_read(gspca_dev, 0x15); if (retbyte != 0) return 0x08; /* HDCS2020 */ start_2wr_probe(dev, 0x0a); /* PB0330 */ - i2c_write(dev, 0x07, 0xaa, 0xaa); - retbyte = i2c_read(dev, 0x07); + i2c_write(gspca_dev, 0x07, 0xaa, 0xaa); + retbyte = i2c_read(gspca_dev, 0x07); if (retbyte != 0) return 0x0a; /* PB0330 */ - retbyte = i2c_read(dev, 0x03); + retbyte = i2c_read(gspca_dev, 0x03); if (retbyte != 0) return 0x0a; /* PB0330 ?? */ - retbyte = i2c_read(dev, 0x04); + retbyte = i2c_read(gspca_dev, 0x04); if (retbyte != 0) return 0x0a; /* PB0330 ?? */ start_2wr_probe(dev, 0x0c); /* ICM105A */ - i2c_write(dev, 0x01, 0x11, 0x00); - retbyte = i2c_read(dev, 0x01); + i2c_write(gspca_dev, 0x01, 0x11, 0x00); + retbyte = i2c_read(gspca_dev, 0x01); if (retbyte != 0) return 0x0c; /* ICM105A */ start_2wr_probe(dev, 0x0e); /* PAS202BCB */ reg_w(dev, 0x08, 0x8d); - i2c_write(dev, 0x03, 0xaa, 0x00); + i2c_write(gspca_dev, 0x03, 0xaa, 0x00); msleep(500); - retbyte = i2c_read(dev, 0x03); + retbyte = i2c_read(gspca_dev, 0x03); if (retbyte != 0) return 0x0e; /* PAS202BCB */ start_2wr_probe(dev, 0x02); /* ?? */ - i2c_write(dev, 0x01, 0xaa, 0x00); - retbyte = i2c_read(dev, 0x01); + i2c_write(gspca_dev, 0x01, 0xaa, 0x00); + retbyte = i2c_read(gspca_dev, 0x01); if (retbyte != 0) return 0x02; /* ?? */ ov_check: - reg_r(dev, 0x0010, &retbyte); /* ?? */ - reg_r(dev, 0x0010, &retbyte); + reg_r(gspca_dev, 0x0010); /* ?? */ + reg_r(gspca_dev, 0x0010); reg_w(dev, 0x01, 0x0000); reg_w(dev, 0x01, 0x0001); @@ -6779,10 +6782,10 @@ ov_check: reg_w(dev, 0x08, 0x008d); msleep(500); reg_w(dev, 0x01, 0x0012); - i2c_write(dev, 0x12, 0x80, 0x00); /* sensor reset */ - retbyte = i2c_read(dev, 0x0a); + i2c_write(gspca_dev, 0x12, 0x80, 0x00); /* sensor reset */ + retbyte = i2c_read(gspca_dev, 0x0a); checkword = retbyte << 8; - retbyte = i2c_read(dev, 0x0b); + retbyte = i2c_read(gspca_dev, 0x0b); checkword |= retbyte; PDEBUG(D_PROBE, "probe 2wr ov vga 0x%04x", checkword); switch (checkword) { @@ -6821,7 +6824,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) /*fixme: lack of 8b=b3 (11,12)-> 10, 8b=e0 (14,15,16)-> 12 found in gspcav1*/ reg_w(dev, 0x02, 0x0010); - reg_r(dev, 0x10, &retbyte); + reg_r(gspca_dev, 0x10); reg_w(dev, 0x01, 0x0000); reg_w(dev, 0x00, 0x0010); reg_w(dev, 0x01, 0x0001); @@ -6829,23 +6832,23 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) reg_w(dev, 0x03, 0x0012); reg_w(dev, 0x01, 0x0012); reg_w(dev, 0x05, 0x0012); - retbyte = i2c_read(dev, 0x14); + retbyte = i2c_read(gspca_dev, 0x14); if (retbyte != 0) return 0x11; /* HV7131R */ - retbyte = i2c_read(dev, 0x15); + retbyte = i2c_read(gspca_dev, 0x15); if (retbyte != 0) return 0x11; /* HV7131R */ - retbyte = i2c_read(dev, 0x16); + retbyte = i2c_read(gspca_dev, 0x16); if (retbyte != 0) return 0x11; /* HV7131R */ reg_w(dev, 0x02, 0x0010); - reg_r(dev, 0x000b, &retbyte); + retbyte = reg_r(gspca_dev, 0x000b); checkword = retbyte << 8; - reg_r(dev, 0x000a, &retbyte); + retbyte = reg_r(gspca_dev, 0x000a); checkword |= retbyte; PDEBUG(D_PROBE, "probe 3wr vga 1 0x%04x", checkword); - reg_r(dev, 0x0010, &retbyte); + reg_r(gspca_dev, 0x0010); /* this is tested only once anyway */ i = 0; while (chipset_revision_sensor[i].revision) { @@ -6863,7 +6866,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) reg_w(dev, 0x0a, 0x0010); reg_w(dev, 0x03, 0x0012); reg_w(dev, 0x01, 0x0012); - retbyte = i2c_read(dev, 0x00); + retbyte = i2c_read(gspca_dev, 0x00); if (retbyte != 0) { PDEBUG(D_PROBE, "probe 3wr vga type 0a ?"); return 0x0a; /* ?? */ @@ -6876,7 +6879,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) reg_w(dev, 0x03, 0x0012); msleep(2); reg_w(dev, 0x01, 0x0012); - retbyte = i2c_read(dev, 0x00); + retbyte = i2c_read(gspca_dev, 0x00); if (retbyte != 0) { PDEBUG(D_PROBE, "probe 3wr vga type %02x", retbyte); send_unknown(dev, SENSOR_GC0305); @@ -6890,8 +6893,8 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) reg_w(dev, 0x06, 0x0010); reg_w(dev, 0x01, 0x0012); reg_w(dev, 0x05, 0x0012); - if (i2c_read(dev, 0x1c) == 0x7f /* OV7610 - manufacturer ID */ - && i2c_read(dev, 0x1d) == 0xa2) { + if (i2c_read(gspca_dev, 0x1c) == 0x7f /* OV7610 - manufacturer ID */ + && i2c_read(gspca_dev, 0x1d) == 0xa2) { send_unknown(dev, SENSOR_OV7620); return 0x06; /* OmniVision confirm ? */ } @@ -6905,13 +6908,13 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) /* msleep(150); */ reg_w(dev, 0x01, 0x12); reg_w(dev, 0x05, 0x12); - retbyte = i2c_read(dev, 0x00); /* ID 0 */ + retbyte = i2c_read(gspca_dev, 0x00); /* ID 0 */ checkword = retbyte << 8; - retbyte = i2c_read(dev, 0x01); /* ID 1 */ + retbyte = i2c_read(gspca_dev, 0x01); /* ID 1 */ checkword |= retbyte; PDEBUG(D_PROBE, "probe 3wr vga 2 0x%04x", checkword); if (checkword == 0x2030) { - retbyte = i2c_read(dev, 0x02); /* revision number */ + retbyte = i2c_read(gspca_dev, 0x02); /* revision number */ PDEBUG(D_PROBE, "sensor PO2030 rev 0x%02x", retbyte); send_unknown(dev, SENSOR_PO2030); return checkword; @@ -6925,7 +6928,7 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) reg_w(dev, 0x01, 0x12); reg_w(dev, 0x05, 0x01); reg_w(dev, 0xd3, 0x8b); - retbyte = i2c_read(dev, 0x01); + retbyte = i2c_read(gspca_dev, 0x01); if (retbyte != 0) { PDEBUG(D_PROBE, "probe 3wr vga type 0a ?"); return 0x0a; /* ?? */ @@ -6936,7 +6939,6 @@ static int vga_3wr_probe(struct gspca_dev *gspca_dev) static int zcxx_probeSensor(struct gspca_dev *gspca_dev) { struct sd *sd = (struct sd *) gspca_dev; - struct usb_device *dev = gspca_dev->dev; int sensor, sensor2; switch (sd->sensor) { @@ -6944,7 +6946,7 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev) case SENSOR_TAS5130C_VF0250: return -1; /* don't probe */ } - sensor = vga_2wr_probe(dev); + sensor = vga_2wr_probe(gspca_dev); if (sensor >= 0) { if (sensor < 0x7600) return sensor; @@ -6956,7 +6958,7 @@ static int zcxx_probeSensor(struct gspca_dev *gspca_dev) return sensor; return sensor2; } - return sif_probe(dev); + return sif_probe(gspca_dev); } /* this function is called at probe time */ @@ -6966,7 +6968,6 @@ static int sd_config(struct gspca_dev *gspca_dev, struct sd *sd = (struct sd *) gspca_dev; struct cam *cam; int sensor; - __u8 bsensor; int vga = 1; /* 1: vga, 0: sif */ static const __u8 gamma[SENSOR_MAX] = { 5, /* SENSOR_CS2102 0 */ @@ -7122,7 +7123,7 @@ static int sd_config(struct gspca_dev *gspca_dev, reg_w(gspca_dev->dev, 0x02, 0x0010); else reg_w(gspca_dev->dev, sensor & 0x0f, 0x0010); - reg_r(gspca_dev->dev, 0x0010, &bsensor); + reg_r(gspca_dev, 0x0010); } cam = &gspca_dev->cam; @@ -7163,7 +7164,6 @@ static void sd_start(struct gspca_dev *gspca_dev) struct usb_device *dev = gspca_dev->dev; const struct usb_action *zc3_init; int mode; - __u8 retbyte; static const struct usb_action *init_tb[SENSOR_MAX][2] = { {cs2102_InitialScale, cs2102_Initial}, /* 0 */ {cs2102K_InitialScale, cs2102K_Initial}, /* 1 */ @@ -7194,7 +7194,7 @@ static void sd_start(struct gspca_dev *gspca_dev) zcxx_probeSensor(gspca_dev); break; case SENSOR_PAS106: - usb_exchange(dev, pas106b_Initial_com); + usb_exchange(gspca_dev, pas106b_Initial_com); break; case SENSOR_PB0330: if (mode) { @@ -7210,14 +7210,14 @@ static void sd_start(struct gspca_dev *gspca_dev) } break; } - usb_exchange(dev, zc3_init); + usb_exchange(gspca_dev, zc3_init); switch (sd->sensor) { case SENSOR_GC0305: case SENSOR_OV7620: case SENSOR_PO2030: msleep(100); /* ?? */ - reg_r(dev, 0x0002, &retbyte); /* --> 0x40 */ + reg_r(gspca_dev, 0x0002); /* --> 0x40 */ reg_w(dev, 0x09, 0x01ad); /* (from win traces) */ reg_w(dev, 0x15, 0x01ae); reg_w(dev, 0x0d, 0x003a); @@ -7230,11 +7230,11 @@ static void sd_start(struct gspca_dev *gspca_dev) setbrightness(gspca_dev); switch (sd->sensor) { case SENSOR_OV7620: - reg_r(dev, 0x0008, &retbyte); + reg_r(gspca_dev, 0x0008); reg_w(dev, 0x00, 0x0008); break; case SENSOR_GC0305: - reg_r(dev, 0x0008, &retbyte); + reg_r(gspca_dev, 0x0008); /* fall thru */ case SENSOR_PO2030: reg_w(dev, 0x03, 0x0008); @@ -7259,7 +7259,7 @@ static void sd_start(struct gspca_dev *gspca_dev) setmatrix(gspca_dev); /* one more time? */ switch (sd->sensor) { case SENSOR_OV7620: - reg_r(dev, 0x0180, &retbyte); /* from win */ + reg_r(gspca_dev, 0x0180); /* from win */ reg_w(dev, 0x00, 0x0180); break; default: @@ -7277,7 +7277,7 @@ static void sd_start(struct gspca_dev *gspca_dev) break; case SENSOR_PO2030: reg_w(dev, 0x40, 0x0117); /* (from win traces) */ - reg_r(dev, 0x0180, &retbyte); + reg_r(gspca_dev, 0x0180); break; } @@ -7289,22 +7289,23 @@ static void sd_start(struct gspca_dev *gspca_dev) reg_w(dev, 0x15, 0x01ae); reg_w(dev, 0x40, 0x0180); reg_w(dev, 0x40, 0x0117); - reg_r(dev, 0x0180, &retbyte); + reg_r(gspca_dev, 0x0180); sd->autogain = 1; setautogain(gspca_dev); break; case SENSOR_OV7620: - i2c_read(dev, 0x13); /*fixme: returns 0xa3 */ - i2c_write(dev, 0x13, 0xa3, 0x00); /*fixme: same to send? */ + i2c_read(gspca_dev, 0x13); /*fixme: returns 0xa3 */ + i2c_write(gspca_dev, 0x13, 0xa3, 0x00); + /*fixme: returned value to send? */ reg_w(dev, 0x40, 0x0117); /* (from win traces) */ - reg_r(dev, 0x0180, &retbyte); + reg_r(gspca_dev, 0x0180); setautogain(gspca_dev); msleep(500); break; case SENSOR_PO2030: msleep(500); - reg_r(dev, 0x0008, &retbyte); - reg_r(dev, 0x0007, &retbyte); + reg_r(gspca_dev, 0x0008); + reg_r(gspca_dev, 0x0007); reg_w(dev, 0x00, 0x0007); /* (from win traces) */ reg_w(dev, 0x02, 0x0008); break; -- cgit v1.2.3-70-g09d2 From d20b27478d6ccf7c4c8de4f09db2bdbaec82a6c0 Mon Sep 17 00:00:00 2001 From: Jean-Francois Moine Date: Fri, 18 Jul 2008 05:52:04 -0300 Subject: V4L/DVB (8415): gspca: Infinite loop in i2c_w() of etoms. Signed-off-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- drivers/media/video/gspca/etoms.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'drivers/media/video/gspca/etoms.c') diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c index 5bb8dc1adbb..8ab4ea7201a 100644 --- a/drivers/media/video/gspca/etoms.c +++ b/drivers/media/video/gspca/etoms.c @@ -292,7 +292,7 @@ static void reg_w(struct gspca_dev *gspca_dev, static int i2c_w(struct gspca_dev *gspca_dev, __u8 reg, const __u8 *buffer, - __u16 len, __u8 mode) + int len, __u8 mode) { /* buffer should be [D0..D7] */ __u8 ptchcount; -- cgit v1.2.3-70-g09d2