Commit 82e25491 authored by Jean-Francois Moine's avatar Jean-Francois Moine Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (10380): gspca - t613: Cleanup and optimize code. 



Signed-off-by: default avatarJean-Francois Moine <moinejf@free.fr>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 5932028f

drivers/media/video/gspca/t613.c

+182 −197
Original line number Diff line number Diff line
@@ -37,18 +37,18 @@ MODULE_LICENSE("GPL"); 
struct sd {

	struct gspca_dev gspca_dev;	/* !! must be the first item */



	unsigned char brightness;

	unsigned char contrast;

	unsigned char colors;

	unsigned char autogain;

	unsigned char gamma;

	unsigned char sharpness;

	unsigned char freq;

	unsigned char whitebalance;

	unsigned char mirror;

	unsigned char effect;



	__u8 sensor;

	u8 brightness;

	u8 contrast;

	u8 colors;

	u8 autogain;

	u8 gamma;

	u8 sharpness;

	u8 freq;

	u8 whitebalance;

	u8 mirror;

	u8 effect;



	u8 sensor;

#define SENSOR_TAS5130A 0

#define SENSOR_OM6802 1

};
@@ -78,7 +78,6 @@ static int sd_querymenu(struct gspca_dev *gspca_dev, 
			struct v4l2_querymenu *menu);



static struct ctrl sd_ctrls[] = {

#define SD_BRIGHTNESS 0

	{

	 {

	  .id = V4L2_CID_BRIGHTNESS,
@@ -87,12 +86,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 14,

	  .step = 1,

	  .default_value = 8,

#define BRIGHTNESS_DEF 8

	  .default_value = BRIGHTNESS_DEF,

	  },

	 .set = sd_setbrightness,

	 .get = sd_getbrightness,

	 },

#define SD_CONTRAST 1

	{

	 {

	  .id = V4L2_CID_CONTRAST,
@@ -101,12 +100,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 0x0d,

	  .step = 1,

	  .default_value = 0x07,

#define CONTRAST_DEF 0x07

	  .default_value = CONTRAST_DEF,

	  },

	 .set = sd_setcontrast,

	 .get = sd_getcontrast,

	 },

#define SD_COLOR 2

	{

	 {

	  .id = V4L2_CID_SATURATION,
@@ -115,7 +114,8 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 0x0f,

	  .step = 1,

	  .default_value = 0x05,

#define COLORS_DEF 0x05

	  .default_value = COLORS_DEF,

	  },

	 .set = sd_setcolors,

	 .get = sd_getcolors,
@@ -135,7 +135,6 @@ static struct ctrl sd_ctrls[] = { 
	 .set = sd_setgamma,

	 .get = sd_getgamma,

	 },

#define SD_AUTOGAIN 4

	{

	 {

	  .id = V4L2_CID_GAIN,	/* here, i activate only the lowlight,
@@ -146,12 +145,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 1,

	  .step = 1,

	  .default_value = 0x01,

#define AUTOGAIN_DEF 0x01

	  .default_value = AUTOGAIN_DEF,

	  },

	 .set = sd_setlowlight,

	 .get = sd_getlowlight,

	 },

#define SD_MIRROR 5

	{

	 {

	  .id = V4L2_CID_HFLIP,
@@ -160,12 +159,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 1,

	  .step = 1,

	  .default_value = 0,

#define MIRROR_DEF 0

	  .default_value = MIRROR_DEF,

	  },

	 .set = sd_setflip,

	 .get = sd_getflip

	},

#define SD_LIGHTFREQ 6

	{

	 {

	  .id = V4L2_CID_POWER_LINE_FREQUENCY,
@@ -174,12 +173,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 1,		/* 1 -> 0x50, 2->0x60 */

	  .maximum = 2,

	  .step = 1,

	  .default_value = 1,

#define FREQ_DEF 1

	  .default_value = FREQ_DEF,

	  },

	 .set = sd_setfreq,

	 .get = sd_getfreq},



#define SD_WHITE_BALANCE 7

	{

	 {

	  .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
@@ -188,12 +187,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 1,

	  .step = 1,

	  .default_value = 0,

#define WHITE_BALANCE_DEF 0

	  .default_value = WHITE_BALANCE_DEF,

	  },

	 .set = sd_setwhitebalance,

	 .get = sd_getwhitebalance

	},

#define SD_SHARPNESS 8		/* (aka definition on win) */

	{

	 {

	  .id = V4L2_CID_SHARPNESS,
@@ -202,12 +201,12 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 15,

	  .step = 1,

	  .default_value = 0x06,

#define SHARPNESS_DEF 0x06

	  .default_value = SHARPNESS_DEF,

	  },

	 .set = sd_setsharpness,

	 .get = sd_getsharpness,

	 },

#define SD_EFFECTS 9

	{

	 {

	  .id = V4L2_CID_EFFECTS,
@@ -216,7 +215,8 @@ static struct ctrl sd_ctrls[] = { 
	  .minimum = 0,

	  .maximum = 4,

	  .step = 1,

	  .default_value = 0,

#define EFFECTS_DEF 0

	  .default_value = EFFECTS_DEF,

	  },

	 .set = sd_seteffect,

	 .get = sd_geteffect
@@ -263,28 +263,22 @@ static const struct v4l2_pix_format vga_mode_t16[] = { 


/* sensor specific data */

struct additional_sensor_data {

	const __u8 data1[20];

	const __u8 data2[18];

	const __u8 data3[18];

	const __u8 data4[4];

	const __u8 data5[6];

	const __u8 stream[4];

	const u8 data1[10];

	const u8 data2[9];

	const u8 data3[9];

	const u8 data4[4];

	const u8 data5[6];

	const u8 stream[4];

};



const static struct additional_sensor_data sensor_data[] = {

    {				/* TAS5130A */

	.data1 =

		{0xd0, 0xbb, 0xd1, 0x28, 0xd2, 0x10, 0xd3, 0x10,

		 0xd4, 0xbb, 0xd5, 0x28, 0xd6, 0x1e, 0xd7, 0x27,

		 0xd8, 0xc8, 0xd9, 0xfc},

		{0xbb, 0x28, 0x10, 0x10, 0xbb, 0x28, 0x1e, 0x27,

		 0xc8, 0xfc},

	.data2 =

		{0xe0, 0x60, 0xe1, 0xa8, 0xe2, 0xe0, 0xe3, 0x60,

		 0xe4, 0xa8, 0xe5, 0xe0, 0xe6, 0x60, 0xe7, 0xa8,

		 0xe8, 0xe0},

	.data3 =

		{0xc7, 0x60, 0xc8, 0xa8, 0xc9, 0xe0, 0xca, 0x60,

		 0xcb, 0xa8, 0xcc, 0xe0, 0xcd, 0x60, 0xce, 0xa8,

		 0xcf, 0xe0},

		{0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,

		 0xe0},

	.data4 =	/* Freq (50/60Hz). Splitted for test purpose */

		{0x66, 0x00, 0xa8, 0xe8},

	.data5 =
@@ -294,17 +288,11 @@ const static struct additional_sensor_data sensor_data[] = { 
    },

    {				/* OM6802 */

	.data1 =

		{0xd0, 0xc2, 0xd1, 0x28, 0xd2, 0x0f, 0xd3, 0x22,

		 0xd4, 0xcd, 0xd5, 0x27, 0xd6, 0x2c, 0xd7, 0x06,

		 0xd8, 0xb3, 0xd9, 0xfc},

		{0xc2, 0x28, 0x0f, 0x22, 0xcd, 0x27, 0x2c, 0x06,

		 0xb3, 0xfc},

	.data2 =

		{0xe0, 0x80, 0xe1, 0xff, 0xe2, 0xff, 0xe3, 0x80,

		 0xe4, 0xff, 0xe5, 0xff, 0xe6, 0x80, 0xe7, 0xff,

		 0xe8, 0xff},

	.data3 =

		{0xc7, 0x80, 0xc8, 0xff, 0xc9, 0xff, 0xca, 0x80,

		 0xcb, 0xff, 0xcc, 0xff, 0xcd, 0x80, 0xce, 0xff,

		 0xcf, 0xff},

		{0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,

		 0xff},

	.data4 =	/*Freq (50/60Hz). Splitted for test purpose */

		{0x66, 0xca, 0xa8, 0xf0 },

	.data5 =	/* this could be removed later */
@@ -317,7 +305,7 @@ const static struct additional_sensor_data sensor_data[] = { 
#define MAX_EFFECTS 7

/* easily done by soft, this table could be removed,

 * i keep it here just in case */

static const __u8 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 */
@@ -327,90 +315,58 @@ static const __u8 effects_table[MAX_EFFECTS][6] = { 
	{0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40},	/* Negative */

};



static const __u8 gamma_table[GAMMA_MAX][34] = {

	{0x90, 0x00, 0x91, 0x3e, 0x92, 0x69, 0x93, 0x85,	/* 0 */

	 0x94, 0x95, 0x95, 0xa1, 0x96, 0xae, 0x97, 0xb9,

	 0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdb,

	 0x9c, 0xe3, 0x9d, 0xea, 0x9e, 0xf1, 0x9f, 0xf8,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x33, 0x92, 0x5a, 0x93, 0x75,	/* 1 */

	 0x94, 0x85, 0x95, 0x93, 0x96, 0xa1, 0x97, 0xad,

	 0x98, 0xb7, 0x99, 0xc2, 0x9a, 0xcb, 0x9b, 0xd4,

	 0x9c, 0xde, 0x9D, 0xe7, 0x9e, 0xf0, 0x9f, 0xf7,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x2f, 0x92, 0x51, 0x93, 0x6b,	/* 2 */

	 0x94, 0x7c, 0x95, 0x8a, 0x96, 0x99, 0x97, 0xa6,

	 0x98, 0xb1, 0x99, 0xbc, 0x9a, 0xc6, 0x9b, 0xd0,

	 0x9c, 0xdb, 0x9d, 0xe4, 0x9e, 0xed, 0x9f, 0xf6,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x29, 0x92, 0x48, 0x93, 0x60,	/* 3 */

	 0x94, 0x72, 0x95, 0x81, 0x96, 0x90, 0x97, 0x9e,

	 0x98, 0xaa, 0x99, 0xb5, 0x9a, 0xbf, 0x9b, 0xcb,

	 0x9c, 0xd6, 0x9d, 0xe1, 0x9e, 0xeb, 0x9f, 0xf5,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x23, 0x92, 0x3f, 0x93, 0x55,	/* 4 */

	 0x94, 0x68, 0x95, 0x77, 0x96, 0x86, 0x97, 0x95,

	 0x98, 0xa2, 0x99, 0xad, 0x9a, 0xb9, 0x9b, 0xc6,

	 0x9c, 0xd2, 0x9d, 0xde, 0x9e, 0xe9, 0x9f, 0xf4,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x1b, 0x92, 0x33, 0x93, 0x48,	/* 5 */

	 0x94, 0x59, 0x95, 0x69, 0x96, 0x79, 0x97, 0x87,

	 0x98, 0x96, 0x99, 0xa3, 0x9a, 0xb1, 0x9b, 0xbe,

	 0x9c, 0xcc, 0x9d, 0xda, 0x9e, 0xe7, 0x9f, 0xf3,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x02, 0x92, 0x10, 0x93, 0x20,	/* 6 */

	 0x94, 0x32, 0x95, 0x40, 0x96, 0x57, 0x97, 0x67,

	 0x98, 0x77, 0x99, 0x88, 0x9a, 0x99, 0x9b, 0xaa,

	 0x9c, 0xbb, 0x9d, 0xcc, 0x9e, 0xdd, 0x9f, 0xee,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x02, 0x92, 0x14, 0x93, 0x26,	/* 7 */

	 0x94, 0x38, 0x95, 0x4a, 0x96, 0x60, 0x97, 0x70,

	 0x98, 0x80, 0x99, 0x90, 0x9a, 0xa0, 0x9b, 0xb0,

	 0x9c, 0xc0, 0x9D, 0xd0, 0x9e, 0xe0, 0x9f, 0xf0,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x10, 0x92, 0x22, 0x93, 0x35,	/* 8 */

	 0x94, 0x47, 0x95, 0x5a, 0x96, 0x69, 0x97, 0x79,

	 0x98, 0x88, 0x99, 0x97, 0x9a, 0xa7, 0x9b, 0xb6,

	 0x9c, 0xc4, 0x9d, 0xd3, 0x9e, 0xe0, 0x9f, 0xf0,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x10, 0x92, 0x26, 0x93, 0x40,	/* 9 */

	 0x94, 0x54, 0x95, 0x65, 0x96, 0x75, 0x97, 0x84,

	 0x98, 0x93, 0x99, 0xa1, 0x9a, 0xb0, 0x9b, 0xbd,

	 0x9c, 0xca, 0x9d, 0xd6, 0x9e, 0xe0, 0x9f, 0xf0,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x18, 0x92, 0x2b, 0x93, 0x44,	/* 10 */

	 0x94, 0x60, 0x95, 0x70, 0x96, 0x80, 0x97, 0x8e,

	 0x98, 0x9c, 0x99, 0xaa, 0x9a, 0xb7, 0x9b, 0xc4,

	 0x9c, 0xd0, 0x9d, 0xd8, 0x9e, 0xe2, 0x9f, 0xf0,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x1a, 0x92, 0x34, 0x93, 0x52,	/* 11 */

	 0x94, 0x66, 0x95, 0x7e, 0x96, 0x8D, 0x97, 0x9B,

	 0x98, 0xa8, 0x99, 0xb4, 0x9a, 0xc0, 0x9b, 0xcb,

	 0x9c, 0xd6, 0x9d, 0xe1, 0x9e, 0xeb, 0x9f, 0xf5,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x3f, 0x92, 0x5a, 0x93, 0x6e,	/* 12 */

	 0x94, 0x7f, 0x95, 0x8e, 0x96, 0x9c, 0x97, 0xa8,

	 0x98, 0xb4, 0x99, 0xbf, 0x9a, 0xc9, 0x9b, 0xd3,

	 0x9c, 0xdc, 0x9d, 0xe5, 0x9e, 0xee, 0x9f, 0xf6,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x54, 0x92, 0x6f, 0x93, 0x83,	/* 13 */

	 0x94, 0x93, 0x95, 0xa0, 0x96, 0xad, 0x97, 0xb7,

	 0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdc,

	 0x9c, 0xe4, 0x9d, 0xeb, 0x9e, 0xf2, 0x9f, 0xf9,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x6e, 0x92, 0x88, 0x93, 0x9a,	/* 14 */

	 0x94, 0xa8, 0x95, 0xb3, 0x96, 0xbd, 0x97, 0xc6,

	 0x98, 0xcf, 0x99, 0xd6, 0x9a, 0xdd, 0x9b, 0xe3,

	 0x9c, 0xe9, 0x9d, 0xef, 0x9e, 0xf4, 0x9f, 0xfa,

	 0xa0, 0xff},

	{0x90, 0x00, 0x91, 0x93, 0x92, 0xa8, 0x93, 0xb7,	/* 15 */

	 0x94, 0xc1, 0x95, 0xca, 0x96, 0xd2, 0x97, 0xd8,

	 0x98, 0xde, 0x99, 0xe3, 0x9a, 0xe8, 0x9b, 0xed,

	 0x9c, 0xf1, 0x9d, 0xf5, 0x9e, 0xf8, 0x9f, 0xfc,

	 0xa0, 0xff}

static const u8 gamma_table[GAMMA_MAX][17] = {

	{0x00, 0x3e, 0x69, 0x85, 0x95, 0xa1, 0xae, 0xb9,	/* 0 */

	 0xc2, 0xcb, 0xd4, 0xdb, 0xe3, 0xea, 0xf1, 0xf8,

	 0xff},

	{0x00, 0x33, 0x5a, 0x75, 0x85, 0x93, 0xa1, 0xad,	/* 1 */

	 0xb7, 0xc2, 0xcb, 0xd4, 0xde, 0xe7, 0xf0, 0xf7,

	 0xff},

	{0x00, 0x2f, 0x51, 0x6b, 0x7c, 0x8a, 0x99, 0xa6,	/* 2 */

	 0xb1, 0xbc, 0xc6, 0xd0, 0xdb, 0xe4, 0xed, 0xf6,

	 0xff},

	{0x00, 0x29, 0x48, 0x60, 0x72, 0x81, 0x90, 0x9e,	/* 3 */

	 0xaa, 0xb5, 0xbf, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,

	 0xff},

	{0x00, 0x23, 0x3f, 0x55, 0x68, 0x77, 0x86, 0x95,	/* 4 */

	 0xa2, 0xad, 0xb9, 0xc6, 0xd2, 0xde, 0xe9, 0xf4,

	 0xff},

	{0x00, 0x1b, 0x33, 0x48, 0x59, 0x69, 0x79, 0x87,	/* 5 */

	 0x96, 0xa3, 0xb1, 0xbe, 0xcc, 0xda, 0xe7, 0xf3,

	 0xff},

	{0x00, 0x02, 0x10, 0x20, 0x32, 0x40, 0x57, 0x67,	/* 6 */

	 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,

	 0xff},

	{0x00, 0x02, 0x14, 0x26, 0x38, 0x4a, 0x60, 0x70,	/* 7 */

	 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,

	 0xff},

	{0x00, 0x10, 0x22, 0x35, 0x47, 0x5a, 0x69, 0x79,	/* 8 */

	 0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe0, 0xf0,

	 0xff},

	{0x00, 0x10, 0x26, 0x40, 0x54, 0x65, 0x75, 0x84,	/* 9 */

	 0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd6, 0xe0, 0xf0,

	 0xff},

	{0x00, 0x18, 0x2b, 0x44, 0x60, 0x70, 0x80, 0x8e,	/* 10 */

	 0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xd8, 0xe2, 0xf0,

	 0xff},

	{0x00, 0x1a, 0x34, 0x52, 0x66, 0x7e, 0x8D, 0x9B,	/* 11 */

	 0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,

	 0xff},

	{0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8,	/* 12 */

	 0xb4, 0xbf, 0xc9, 0xd3, 0xdc, 0xe5, 0xee, 0xf6,

	 0xff},

	{0x00, 0x54, 0x6f, 0x83, 0x93, 0xa0, 0xad, 0xb7,	/* 13 */

	 0xc2, 0xcb, 0xd4, 0xdc, 0xe4, 0xeb, 0xf2, 0xf9,

	 0xff},

	{0x00, 0x6e, 0x88, 0x9a, 0xa8, 0xb3, 0xbd, 0xc6,	/* 14 */

	 0xcf, 0xd6, 0xdd, 0xe3, 0xe9, 0xef, 0xf4, 0xfa,

	 0xff},

	{0x00, 0x93, 0xa8, 0xb7, 0xc1, 0xca, 0xd2, 0xd8,	/* 15 */

	 0xde, 0xe3, 0xe8, 0xed, 0xf1, 0xf5, 0xf8, 0xfc,

	 0xff}

};



static const __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},
@@ -418,11 +374,11 @@ static const __u8 tas5130a_sensor_init[][8] = { 
	{},

};



static __u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};

static u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};



/* read 1 byte */

static int reg_r(struct gspca_dev *gspca_dev,

		   __u16 index)

static u8 reg_r(struct gspca_dev *gspca_dev,

		   u16 index)

{

	usb_control_msg(gspca_dev->dev,

			usb_rcvctrlpipe(gspca_dev->dev, 0),
@@ -435,7 +391,7 @@ static int reg_r(struct gspca_dev *gspca_dev, 
}



static void reg_w(struct gspca_dev *gspca_dev,

		  __u16 index)

		  u16 index)

{

	usb_control_msg(gspca_dev->dev,

			usb_sndctrlpipe(gspca_dev->dev, 0),
@@ -446,7 +402,7 @@ static void reg_w(struct gspca_dev *gspca_dev, 
}



static void reg_w_buf(struct gspca_dev *gspca_dev,

		  const __u8 *buffer, __u16 len)

		  const u8 *buffer, u16 len)

{

	if (len <= USB_BUF_SZ) {

		memcpy(gspca_dev->usb_buf, buffer, len);
@@ -457,7 +413,7 @@ static void reg_w_buf(struct gspca_dev *gspca_dev, 
				0x01, 0,

				gspca_dev->usb_buf, len, 500);

	} else {

		__u8 *tmpbuf;

		u8 *tmpbuf;



		tmpbuf = kmalloc(len, GFP_KERNEL);

		memcpy(tmpbuf, buffer, len);
@@ -471,14 +427,41 @@ static void reg_w_buf(struct gspca_dev *gspca_dev, 
	}

}



/* write values to consecutive registers */

static void reg_w_ixbuf(struct gspca_dev *gspca_dev,

			u8 reg,

			const u8 *buffer, u16 len)

{

	int i;

	u8 *p, *tmpbuf;



	if (len * 2 <= USB_BUF_SZ)

		p = tmpbuf = gspca_dev->usb_buf;

	else

		p = tmpbuf = kmalloc(len * 2, GFP_KERNEL);

	i = len;

	while (--i >= 0) {

		*p++ = reg++;

		*p++ = *buffer++;

	}

	usb_control_msg(gspca_dev->dev,

			usb_sndctrlpipe(gspca_dev->dev, 0),

			0,

			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,

			0x01, 0,

			tmpbuf, len * 2, 500);

	if (len * 2 > USB_BUF_SZ)

		kfree(tmpbuf);

}



/* Reported as OM6802*/

static void om6802_sensor_init(struct gspca_dev *gspca_dev)

{

	int i;

	const __u8 *p;

	__u8 byte;

	__u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05};

	static const __u8 sensor_init[] = {

	const u8 *p;

	u8 byte;

	u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05};

	static const u8 sensor_init[] = {

		0xdf, 0x6d,

		0xdd, 0x18,

		0x5a, 0xe0,
@@ -542,15 +525,16 @@ static int sd_config(struct gspca_dev *gspca_dev, 
	cam->cam_mode = vga_mode_t16;

	cam->nmodes = ARRAY_SIZE(vga_mode_t16);



	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 = COLORS_DEF;

	sd->gamma = GAMMA_DEF;

	sd->mirror = sd_ctrls[SD_MIRROR].qctrl.default_value;

	sd->freq = sd_ctrls[SD_LIGHTFREQ].qctrl.default_value;

	sd->whitebalance = sd_ctrls[SD_WHITE_BALANCE].qctrl.default_value;

	sd->sharpness = sd_ctrls[SD_SHARPNESS].qctrl.default_value;

	sd->effect = sd_ctrls[SD_EFFECTS].qctrl.default_value;

	sd->autogain = AUTOGAIN_DEF;

	sd->mirror = MIRROR_DEF;

	sd->freq = FREQ_DEF;

	sd->whitebalance = WHITE_BALANCE_DEF;

	sd->sharpness = SHARPNESS_DEF;

	sd->effect = EFFECTS_DEF;

	return 0;

}
@@ -558,7 +542,7 @@ static void setbrightness(struct gspca_dev *gspca_dev) 
{

	struct sd *sd = (struct sd *) gspca_dev;

	unsigned int brightness;

	__u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 };

	u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 };



	brightness = sd->brightness;

	if (brightness < 7) {
@@ -575,7 +559,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) 
{

	struct sd *sd = (struct sd *) gspca_dev;

	unsigned int contrast = sd->contrast;

	__u16 reg_to_write;

	u16 reg_to_write;



	if (contrast < 7)

		reg_to_write = 0x8ea9 - contrast * 0x200;
@@ -588,7 +572,7 @@ static void setcontrast(struct gspca_dev *gspca_dev) 
static void setcolors(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	__u16 reg_to_write;

	u16 reg_to_write;



	reg_to_write = 0x80bb + sd->colors * 0x100;	/* was 0xc0 */

	reg_w(gspca_dev, reg_to_write);
@@ -599,14 +583,15 @@ static void setgamma(struct gspca_dev *gspca_dev) 
	struct sd *sd = (struct sd *) gspca_dev;



	PDEBUG(D_CONF, "Gamma: %d", sd->gamma);

	reg_w_buf(gspca_dev, gamma_table[sd->gamma], sizeof gamma_table[0]);

	reg_w_ixbuf(gspca_dev, 0x90,

		gamma_table[sd->gamma], sizeof gamma_table[0]);

}



static void setwhitebalance(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;



	__u8 white_balance[8] =

	u8 white_balance[8] =

		{0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38};



	if (sd->whitebalance)
@@ -618,7 +603,7 @@ static void setwhitebalance(struct gspca_dev *gspca_dev) 
static void setsharpness(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	__u16 reg_to_write;

	u16 reg_to_write;



	reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
@@ -634,18 +619,18 @@ static int sd_init(struct gspca_dev *gspca_dev) 
	 * to see the initial parameters.*/

	struct sd *sd = (struct sd *) gspca_dev;

	int i;

	__u8 byte, test_byte;

	u8 byte, test_byte;



	static const __u8 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 const __u8 n1[] =

		  0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00 };

	static const u8 n1[] =

			{0x08, 0x03, 0x09, 0x03, 0x12, 0x04};

	static const __u8 n2[] =

	static const u8 n2[] =

			{0x08, 0x00};

	static const __u8 n3[] =

	static const u8 n3[] =

			{0x61, 0x68, 0x65, 0x0a, 0x60, 0x04};

	static const __u8 n4[] =

	static const u8 n4[] =

		{0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,

		 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,

		 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
@@ -655,10 +640,10 @@ static int sd_init(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 const __u8 nset9[4] =

			{ 0x0b, 0x04, 0x0a, 0x78 };

	static const __u8 nset8[6] =

	static const u8 nset8[6] =

			{ 0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00 };

	static const u8 nset9[4] =

			{ 0x0b, 0x04, 0x0a, 0x78 };



	byte = reg_r(gspca_dev, 0x06);

	test_byte = reg_r(gspca_dev, 0x07);
@@ -703,11 +688,11 @@ static int sd_init(struct gspca_dev *gspca_dev) 
	reg_r(gspca_dev, 0x0080);

	reg_w(gspca_dev, 0x2c80);



	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data1,

	reg_w_ixbuf(gspca_dev, 0xd0, sensor_data[sd->sensor].data1,

			sizeof sensor_data[sd->sensor].data1);

	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data3,

			sizeof sensor_data[sd->sensor].data3);

	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data2,

	reg_w_ixbuf(gspca_dev, 0xc7, sensor_data[sd->sensor].data2,

			sizeof sensor_data[sd->sensor].data2);

	reg_w_ixbuf(gspca_dev, 0xe0, sensor_data[sd->sensor].data2,

			sizeof sensor_data[sd->sensor].data2);



	reg_w(gspca_dev, 0x3880);
@@ -734,11 +719,11 @@ static int sd_init(struct gspca_dev *gspca_dev) 


	reg_w(gspca_dev, 0x2880);



	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data1,

	reg_w_ixbuf(gspca_dev, 0xd0, sensor_data[sd->sensor].data1,

			sizeof sensor_data[sd->sensor].data1);

	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data3,

			sizeof sensor_data[sd->sensor].data3);

	reg_w_buf(gspca_dev, sensor_data[sd->sensor].data2,

	reg_w_ixbuf(gspca_dev, 0xc7, sensor_data[sd->sensor].data2,

			sizeof sensor_data[sd->sensor].data2);

	reg_w_ixbuf(gspca_dev, 0xe0, sensor_data[sd->sensor].data2,

			sizeof sensor_data[sd->sensor].data2);



	return 0;
@@ -747,7 +732,7 @@ static int sd_init(struct gspca_dev *gspca_dev) 
static void setflip(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	__u8 flipcmd[8] =

	u8 flipcmd[8] =

		{0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09};



	if (sd->mirror)
@@ -777,7 +762,7 @@ static void seteffect(struct gspca_dev *gspca_dev) 
static void setlightfreq(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	__u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };

	u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };



	if (sd->freq == 2)	/* 60hz */

		freq[1] = 0x00;
@@ -790,17 +775,17 @@ static void setlightfreq(struct gspca_dev *gspca_dev) 
static void poll_sensor(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	static const __u8 poll1[] =

	static const u8 poll1[] =

		{0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82,

		 0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34,

		 0x74, 0x32, 0x75, 0x92, 0x76, 0x00, 0x09, 0x01,

		 0x60, 0x14};

	static const __u8 poll2[] =

	static const u8 poll2[] =

		{0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9,

		 0x73, 0x02, 0x73, 0x02, 0x60, 0x14};

	static const __u8 poll3[] =

	static const u8 poll3[] =

		{0x87, 0x3f, 0x88, 0x20, 0x89, 0x2d};

	static const __u8 poll4[] =

	static const u8 poll4[] =

		{0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f,

		 0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,

		 0xc2, 0x80, 0xc3, 0x10};
@@ -818,13 +803,14 @@ static int sd_start(struct gspca_dev *gspca_dev) 
{

	struct sd *sd = (struct sd *) gspca_dev;

	int i, mode;

	__u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };

	static const __u8 t3[] =

		{ 0xb3, 0x07, 0xb4, 0x00, 0xb5, 0x88, 0xb6, 0x02, 0xb7, 0x06,

		  0xb8, 0x00, 0xb9, 0xe7, 0xba, 0x01 };

	u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };

	static const u8 t3[] =

		{ 0x07, 0x00, 0x88, 0x02, 0x06, 0x00, 0xe7, 0x01 };



	mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. priv;

	switch (mode) {

	case 0:		/* 640x480 (0x00) */

		break;

	case 1:		/* 352x288 */

		t2[1] = 0x40;

		break;
@@ -834,11 +820,10 @@ static int sd_start(struct gspca_dev *gspca_dev) 
	case 3:		/* 176x144 */

		t2[1] = 0x50;

		break;

	case 4:		/* 160x120 */

	default:

/*	case 4:		 * 160x120 */

		t2[1] = 0x20;

		break;

	default:	/* 640x480 (0x00) */

		break;

	}



	if (sd->sensor == SENSOR_TAS5130A) {
@@ -860,7 +845,7 @@ static int sd_start(struct gspca_dev *gspca_dev) 
			sizeof sensor_data[sd->sensor].data4);

	reg_r(gspca_dev, 0x0012);

	reg_w_buf(gspca_dev, t2, sizeof t2);

	reg_w_buf(gspca_dev, t3, sizeof t3);

	reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3);

	reg_w(gspca_dev, 0x0013);

	msleep(15);

	reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
@@ -890,10 +875,10 @@ static void sd_stopN(struct gspca_dev *gspca_dev) 


static void sd_pkt_scan(struct gspca_dev *gspca_dev,

			struct gspca_frame *frame,	/* target */

			__u8 *data,			/* isoc packet */

			u8 *data,			/* isoc packet */

			int len)			/* iso packet length */

{

	static __u8 ffd9[] = { 0xff, 0xd9 };

	static u8 ffd9[] = { 0xff, 0xd9 };



	if (data[0] == 0x5a) {

		/* Control Packet, after this came the header again,