Web lists-archives.com

Re: [Spca50x-devs] gspcav2-0.2.8 tascorp 0x17a1:0x0128 recognized but don't get it working




Ok, sorry, bad version, change your t613.c for this one attached. I think this was.

2008/5/27 marc_und_ramona <bdhg08-registry@xxxxxxxx>:
Hi,

thanks for your reply. I just tried that file but it gives me errors when comiling:

------------------------------------------------------------------------------------------------

Script started on Tue 27 May 2008 08:39:38 PM CEST
debian:/usr/local/src/gspcav2-0.1.0# make -f Makefile.standalone 
make -C /lib/modules/2.6.18-6-amd64/build SUBDIRS=/usr/local/src/gspcav2-0.1.0 modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.18-6-amd64'
  CC [M]  /usr/local/src/gspcav2-0.1.0/conex.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/etoms.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/gspca.o
/usr/local/src/gspcav2-0.1.0/gspca.c: In function 'gspca_frame_add':
/usr/local/src/gspcav2-0.1.0/gspca.c:197: warning: format '%d' expects type 'int', but argument 2 has type 'long int'
/usr/local/src/gspcav2-0.1.0/gspca.c: In function 'create_urbs':
/usr/local/src/gspcav2-0.1.0/gspca.c:477: warning: assignment from incompatible pointer type
/usr/local/src/gspcav2-0.1.0/gspca.c: In function 'dev_read':
/usr/local/src/gspcav2-0.1.0/gspca.c:1522: warning: format '%d' expects type 'int', but argument 3 has type 'size_t'
/usr/local/src/gspcav2-0.1.0/gspca.c:1588: warning: format '%d' expects type 'int', but argument 2 has type 'size_t'
/usr/local/src/gspcav2-0.1.0/gspca.c:1597: warning: format '%d' expects type 'int', but argument 3 has type 'size_t'
  CC [M]  /usr/local/src/gspcav2-0.1.0/mars.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/ov519.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/pac207.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/pac7311.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/sonixb.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/sonixj.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca500.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca501.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca505.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca506.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca508.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/spca561.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/stk014.o
/usr/local/src/gspcav2-0.1.0/stk014.c: In function 'sd_pkt_scan':
/usr/local/src/gspcav2-0.1.0/stk014.c:422: warning: format '%d' expects type 'int', but argument 2 has type 'long int'
/usr/local/src/gspcav2-0.1.0/stk014.c:447: warning: format '%d' expects type 'int', but argument 2 has type 'long int'
  CC [M]  /usr/local/src/gspcav2-0.1.0/sunplus.o
  CC [M]  /usr/local/src/gspcav2-0.1.0/t613.o
/usr/local/src/gspcav2-0.1.0/t613.c: In function 'init_default_parameters':
/usr/local/src/gspcav2-0.1.0/t613.c:426: warning: unused variable 'nset1'
/usr/local/src/gspcav2-0.1.0/t613.c: In function 'setgamma':
/usr/local/src/gspcav2-0.1.0/t613.c:622: error: 'x' undeclared (first use in this function)
/usr/local/src/gspcav2-0.1.0/t613.c:622: error: (Each undeclared identifier is reported only once
/usr/local/src/gspcav2-0.1.0/t613.c:622: error: for each function it appears in.)
/usr/local/src/gspcav2-0.1.0/t613.c:622: error: expected ';' before 'printk'
/usr/local/src/gspcav2-0.1.0/t613.c: In function 'sd_start':
/usr/local/src/gspcav2-0.1.0/t613.c:911: warning: passing argument 5 of 't16RegWrite' from incompatible pointer type
/usr/local/src/gspcav2-0.1.0/t613.c:862: warning: unused variable 'n6'
/usr/local/src/gspcav2-0.1.0/t613.c:858: warning: unused variable 'n5'
/usr/local/src/gspcav2-0.1.0/t613.c:852: warning: unused variable 'n4'
make[2]: *** [/usr/local/src/gspcav2-0.1.0/t613.o] Error 1
make[1]: *** [_module_/usr/local/src/gspcav2-0.1.0] Error 2
make[1]: Leaving directory `/usr/src/linux-headers-2.6.18-6-amd64'
make: *** [driver] Error 2
debian:/usr/local/src/gspcav2-0.1.0#
Script done on Tue 27 May 2008 08:39:54 PM CEST





--- Zorro <azerizorrofox@xxxxxxxxx> schrieb am Mo, 26.5.2008:
Von: Zorro <azerizorrofox@xxxxxxxxx>

Betreff: Re: [Spca50x-devs] gspcav2-0.2.8 tascorp 0x17a1:0x0128 recognized but don't get it working
An: bdhg08-registry@xxxxxxxx, "SPCA50x Linux Device Driver Development" <spca50x-devs@xxxxxxxxxxxxxxxxxxxxx>
Datum: Montag, 26. Mai 2008, 21:43

Hi, im with an 17a1:0128 too, but it isn't tascorp (aparently). I'm working with Leandro (he is working, i'm only trying what he codes), because de id is the same, but the sensor seem to be different, not at all, but different.

Try what i have  attached, if you can seee something (gamma has to be fixed), you have the same camera as me.

2008/5/26 marc_und_ramona <bdhg08-registry@xxxxxxxx>:
Hi,

the main error I get is in dmesg or /var/log/messages


gspca main driver: no TV norms defined!

Also my monitor turns black if i start xawtv or v4l-conf .... .

Rgds


--- Jean-Francois Moine <moinejf@xxxxxxx> schrieb am So, 25.5.2008:
Von: Jean-Francois Moine <moinejf@xxxxxxx>
Betreff: Re: [Spca50x-devs] gspcav2-0.2.8 tascorp 0x17a1:0x0128 recognized but don't get it working
An: bdhg08-registry@xxxxxxxx
Datum: Sonntag, 25. Mai 2008, 15:12

> Hi there,
>
> I'm trying now since almost a week and I don't get my tascorp
>
0x17a1:0x0128 working. I get no output (only a black area) when
> running camorama, mplayer or zoneminder. My system:
>
> - debian etch 2.6.18-6-amd64
> - gspcav2-0.2.8
>
> Here is my lsusb; dmesg; tail /var/log/messages. Any ideas? Thanks in

> advance

Hello,

There was a bug in the versions <= 0.2.8 for the Bayer webcams. It
should be fixed in the last release (actual 0.2.10).

If you still have errors, please, contact the author of the subdriver:

Leandro Costantino <le_costantino@xxxxxxxxxxxxxxxxxxxxxx>

Cheers.

--
Ken ar c'hentañ | ** Breizh ha Linux atav! **

Jef | http://moinejf.free.fr/


Gesendet von Yahoo! Mail.
Dem pfiffigeren Posteingang.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Spca50x-devs mailing list
Spca50x-devs@xxxxxxxxxxxxxxxxxxxxx
https://lists.sourceforge.net/lists/listinfo/spca50x-devs


-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Spca50x-devs mailing list
Spca50x-devs@xxxxxxxxxxxxxxxxxxxxx
https://lists.sourceforge.net/lists/listinfo/spca50x-devs


Gesendet von Yahoo! Mail.
Dem pfiffigeren Posteingang.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Spca50x-devs mailing list
Spca50x-devs@xxxxxxxxxxxxxxxxxxxxx
https://lists.sourceforge.net/lists/listinfo/spca50x-devs


#define MODULE_NAME "t613"
#include "gspca.h"
#define DRIVER_VERSION_NUMBER	KERNEL_VERSION(0, 0, 21)
static const char version[] = "0.0.21";
#define MAX_GAMMA 0x10 //0 to 15

//From LUVCVIEW
#define V4L2_CID_POWER_LINE_FREQUENCY  (V4L2_CID_PRIVATE_BASE+1)
#define V4L2_CID_SHARPNESS  (V4L2_CID_PRIVATE_BASE+0)
#define V4L2_CID_WHITE_BALANCE_TEMPERATURE_AUTO (V4L2_CID_PRIVATE_BASE + 2 )
#define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 3 )


#define BRIDGE_T16 1

MODULE_AUTHOR("Leandro Costantino <le_costantino@xxxxxxxxxxxxxxxxxxxxxx>");
MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance ) USB Camera Driver");
MODULE_LICENSE("GPL");

/*
 *Notes: * t613  + tas5130A
         * Focus to light do not balance well as in win. Quality in win is not good, but its kinda better.
 *       * Fix some "extraneous bytes", most of apps will show the image anyway
 *       * Gamma table, is there, but its really doing something?
 *       * 7~8 Fps, its ok, max on win its 10. 
 *         Costantino Leandro 
 */



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

   unsigned char packet[ISO_MAX_SIZE + 128]; // !! no more than 128 ff in an ISO packet

   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;
   char qindex;
   char bridge;
   char subtype;

};

/* 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_setlowlight(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_querymenu (struct gspca_dev *gspca_dev,struct v4l2_querymenu *menu);


//just in case  someone need to pass it as mod parameter, and use it as in vmicro/ztar module, function its already here
static void setlightfreq(struct gspca_dev *gspca_dev);

static struct ctrl sd_ctrls[] =
{
#define SD_BRIGHTNESS 0
     {
	  {
	       .id      = V4L2_CID_BRIGHTNESS,
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Brightness",
	       .minimum = 0,
	       .maximum = 0xf,
	       .step    = 1,
	       .default_value = 0x9,
	  },
	.set = sd_setbrightness,
	.get = sd_getbrightness,
     },
#define SD_CONTRAST 1
     {
	  {
	     .id      = V4L2_CID_CONTRAST,
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Contrast",
	       .minimum = 0,
	       .maximum = 0xD,
	       .step    = 1,
	       .default_value = 0x7,
	  },
	.set = sd_setcontrast,
	.get = sd_getcontrast,
     },
#define SD_COLOR 2
     {
	  {
	     .id      = V4L2_CID_SATURATION,
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Color",
	       .minimum = 0,
	       .maximum = 0xF,
	       .step    = 1,
	       .default_value = 0x5,
	  },
	.set = sd_setcolors,
	.get = sd_getcolors,
     },
#define SD_AUTOGAIN 3

     {
	  {
	     .id      = V4L2_CID_GAIN,  //here, i activate only the lowlight, some apps dont bring up the backligth_compensation control)
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Low Light",
	       .minimum = 0,
	       .maximum = 1,
	       .step    = 1,
	       .default_value = 0x1,
	  },
	.set = sd_setlowlight,
	.get = sd_getlowlight,
     },
#define SD_GAMMA 4
     {
	  {
	     .id      = V4L2_CID_GAMMA, //(gamma on win )
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Gamma ( Untested )",
	       .minimum = 0,
	       .maximum = MAX_GAMMA,
	       .step    = 1,
	       .default_value = 0x9,
	  },
	.set = sd_setgamma,
	.get = sd_getgamma,
     },
#define SD_SHARPNESS 5  // (aka definition on win )
     {
	  {
	       .id      = V4L2_CID_SHARPNESS,
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "Sharpness",
	       .minimum = 0,
	       .maximum = MAX_GAMMA , //0 to 16
	       .step    = 1,
	       .default_value = 0x6,
	  },
	.set = sd_setsharpness,
	.get = sd_getsharpness,
     },
#define SD_LIGHTFREQ 6
     {
	  {
	     .id      = V4L2_CID_POWER_LINE_FREQUENCY,
	       .type    = V4L2_CTRL_TYPE_MENU,
	       .name    = "Light Frequency Filter",
	       .minimum = 0, //0 -> 0x50, 1->0x60
	       .maximum = 1 ,
	       .step    = 1,
	       .default_value = 0,
	  },
	.set = sd_setfreq,
	.get = sd_getfreq
     },

#define SD_WHITE_BALANCE 7
     {
	  {
	       .id      = V4L2_CID_WHITE_BALANCE_TEMPERATURE_AUTO,
	       .type    = V4L2_CTRL_TYPE_INTEGER,
	       .name    = "White Balance",
	       .minimum = 0,
	       .maximum = 1 ,
	       .step    = 1,
	       .default_value = 1,
	  },
	.set = sd_setwhitebalance,
	.get = sd_getwhitebalance
     },
#define SD_MIRROR 8
     {
	  {
               .id      = V4L2_CID_HFLIP,
               .type    = V4L2_CTRL_TYPE_BOOLEAN,
	       .name    = "Mirror Image",
	       .minimum = 0,
	       .maximum = 1 ,
	       .step    = 1,
	       .default_value = 0,
	  },
	.set = sd_setflip,
	.get = sd_getflip
     },

#define SD_EFFECTS 8
     {
	  {
               .id      = V4L2_CID_EFFECTS,
               .type    = V4L2_CTRL_TYPE_MENU,
	       .name    = "Webcam Effects",
	       .minimum = 0,
	       .maximum = 4 ,
	       .step    = 1,
	       .default_value = 0,
	  },
	.set = sd_seteffect,
	.get = sd_geteffect
     },

};

static struct control_menu_info flicker_control[] =
{
   { 0,    "50 Hz" },
   { 1,    "60 Hz"  },

};
#define NUM_FLICKER_CONTROL (sizeof(flicker_control)/sizeof(flicker_control[0]))
static struct control_menu_info effects_control[] =
{
   { 0,    "Normal" },
   { 1,    "Emboss"  }, //disabled
   { 2,    "Monochrome"  },
   { 3,    "Sepia"  },
   { 4,    "Sketch"  },
   { 5,    "Sun Effect"  }, //disabled
   { 6,    "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},
     {V4L2_PIX_FMT_JPEG, 320, 240, 2},
     {V4L2_PIX_FMT_JPEG, 352, 288, 1},
     {V4L2_PIX_FMT_JPEG, 640, 480, 0},

}
;
#define T16_OFFSET_DATA 631
#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]=
{
    {0xa8,0xe8,0xc6,0xd2,0xc0,0x00}, //Normal
    {0xa8,0xc8,0xc6,0x52,0xc0,0x04},//Repujar
    {0xa8,0xe8,0xc6,0xd2,0xc0,0x20}, //Monochrome
    {0xa8,0xe8,0xc6,0xd2,0xc0,0x80}, //Sepia
    {0xa8,0xc8,0xc6,0x52,0xc0,0x02}, //Croquis
    {0xa8,0xc8,0xc6,0xd2,0xc0,0x10}, //Sun Effect
    {0xa8,0xc8,0xc6,0xd2,0xc0,0x40}, //Negative
};



unsigned char 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 ,0x9c ,0xe3 ,0x9d ,0xea ,0x9e ,0xf1 ,0x9f ,0xf8 ,0xa0 ,0xff },
     {0x90 ,0x00 ,0x91 ,0x33 ,0x92 ,0x5A ,0x93 ,0x75 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 ,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 __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},
     {0x62,0x07,0x63,0x03,0x64,0x00,0x60,0x09},
     {0,0,0,0,0,0,0,0 },

};

static __u8 unknown_sensor_init[][6]={
{0x61, 0x68, 0x62, 0xff, 0x60, 0x07},
{ 0x62, 0xdf, 0x64, 0x6d, 0x60, 0x05},
{0x62, 0xdd, 0x64 ,0x18, 0x60, 0x05},
{0x62, 0x5a, 0x64, 0xe0, 0x60, 0x05},
{0x62, 0x5c, 0x64, 0x07, 0x60 ,0x05},
{0x62, 0x5d, 0x64, 0xb0, 0x60,0x05},
{0x62, 0x5e, 0x64, 0x1e,0x60, 0x05},
{0x62, 0x60, 0x64, 0x71, 0x60, 0x05},
{0x62, 0xef, 0x64, 0x00, 0x60, 0x05},
{0x62, 0xe9, 0x64, 0x00, 0x60, 0x05},
{0x62, 0xea, 0x64, 0x00, 0x60, 0x05},
{0x62, 0x90, 0x64, 0x24, 0x60, 0x05},
{0x62, 0x91, 0x64, 0xb2, 0x60, 0x05},
{0x62, 0x82, 0x64, 0x32, 0x60, 0x05},
{0x62, 0xfd, 0x64, 0x00, 0x60, 0x05},
{0x62, 0xfd, 0x64, 0x01, 0x60, 0x05},
{0x62, 0xfd ,0x64,0x41,0x60, 0x05},
{0x00,0x00,0x00,0x00,0x00,0x00},
};

static void t16RegRead(struct usb_device *dev,
		       __u16 reg,
		       __u16 value,
		       __u16 index,
		       __u8 *buffer, __u16 length)
{
   usb_control_msg(dev,
		   usb_rcvctrlpipe(dev, 0),
		   reg,
		   USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		   (__u16) value, (__u16) index, buffer, length,
		   500);
}

static void t16RegWrite(struct usb_device *dev,
			__u16 reg,
			__u16 value,
			__u16 index,
			__u8 *buffer, __u16 length)
{
   usb_control_msg(dev,
		   usb_sndctrlpipe(dev, 0),
		   reg,
		   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		   (__u16) value, (__u16) index, buffer, length,
		   500);
}

/* 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 0x17a1:
        //t613  + tas5130A
	//Currently one sensor supported...
	sd->freq = 0;
	sd->bridge = BRIDGE_T16;
	break;

      default:
	break;;
     }

   cam = &gspca_dev->cam;
   cam->dev_name = (char *) id->driver_info;
   cam->epaddr = 0x01;

   switch (sd->bridge)
     {

      default:
      case BRIDGE_T16:
	cam->cam_mode = vga_mode_t16;
	cam->nmodes = sizeof vga_mode_t16 / sizeof vga_mode_t16[0];
	break;
	
     }
   sd->qindex = 4;		
   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->gamma = sd_ctrls[SD_GAMMA].qctrl.default_value;
   sd->sharpness = sd_ctrls[SD_SHARPNESS].qctrl.default_value;
   sd->freq = sd_ctrls[SD_LIGHTFREQ].qctrl.default_value;
   sd->whitebalance = sd_ctrls[SD_WHITE_BALANCE].qctrl.default_value;
   sd->mirror = sd_ctrls[SD_MIRROR].qctrl.default_value;
   sd->effect = sd_ctrls[SD_EFFECTS].qctrl.default_value;
   return 0;
}

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 to see the initial parameters.*/
   int i=0;
   __u8 test_byte;
  
   unsigned char read_indexs[]={0x06,0x07,0x0a,0x0b,0x66,0x80,0x81,0x8e,0x8f,0xa5,0xa6,0xa8,0xbb,0xbc,0xc6,0x00,0x00};
   unsigned char n1[6]={0x08,0x03,0x09,0x03,0x12,0x04};
unsigned char n2[2]={0x08,0x00};
   unsigned char nset[6]={0x61,0x68,0x62,0xff,0x60,0x07};
   unsigned char n3[6]={0x61,0x68,0x65,0x0a,0x60,0x04};

   unsigned char 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 ,0xa2 ,0x60 ,0xa5 ,0x30 ,0xa6, 0x3a ,0xa8 ,0xe8,
    	0xae, 0x05 ,0xb1, 0x00, 0xbb ,0x04 ,0xbc, 0x48 ,0xbe ,0x36 ,0xc6, 0x88, 0xe9, 0x00 ,0xc5, 0xc0,
    	0x65 ,0x0a ,0xbb ,0x86 ,0xaf ,0x58, 0xb0, 0x68 ,0x87 ,0x40 ,0x89, 0x2b ,0x8d, 0xff ,0x83 ,0x40,
0xac,0x84,0xad,0x86,0xaf,0x46
};
   unsigned char nset1[50]={
	0x80 ,0x3c ,0x81 ,0x68 ,0x83 ,0xa0 ,0x84 ,0x20 ,0x8a ,0x5c ,0x8b ,0x4c ,0x8c ,0x88 ,0x8e ,0xb4,
	0x8f ,0x24 ,0xa1 ,0xb1 ,0xa2 ,0x30 ,0xa5 ,0x18 ,0xa6 ,0x4a ,0xae ,0x03 ,0xb1 ,0x44 ,0xb2 ,0x08,
	0xb7 ,0x06 ,0xb9 ,0xe7 ,0xbb ,0xc4 ,0xbc ,0x4a ,0xbe ,0x36 ,0xbf ,0xff ,0xc2 ,0x88 ,0xc5 ,0xc0,
	0xc6 ,0xd2
     };

   unsigned char 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

   unsigned char nset2[20]={
	0xd0,0xbb,0xd1,0x28,0xd2,0x10,0xd3,0x10,0xd4,0xbb,0xd5,0x28,0xd6,0x1e,0xd7,0x27,
	0xd8,0xc8,0xd9,0xfc
     };
unsigned char missing[8]={   0x87,0x20, 0x88, 0x20, 0x89, 0x20, 0x80 ,0x38};
   unsigned char nset3[18]={
	0xc7,0x60,0xc8,0xa8,0xc9,0xe0,0xca,0x60,0xcb,0xa8,0xcc,0xe0,0xcd,0x60,0xce,0xa8,
	0xcf,0xe0
     };
   unsigned char nset5[4]={0x8f,0x24,0xc3,0x00}; //bright   

   unsigned char 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
   unsigned char nset7[4]={0x66,0xca,0xa8,0xf8}; //50/60 Hz
   unsigned char nset9[4]={0x0b,0x04,0x0a,0x78};
   unsigned char nset8[6]={0xa8,0xf0,0xc6,0x88,0xc0,0x00};
   unsigned char nset10[6]={0x0c,0x03,0xab,0x10,0x81,0x20};

    t16RegWrite(dev, 0x00,0x01,0x0000,n1,0x06);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset,0x06);
  t16RegRead(dev,0x00,0x00,0x0063,  &test_byte,1);
   t16RegWrite(dev, 0x00,0x01,0x0000,n2,0x02);

   while( read_indexs[i] != 0x00 )
    {
        t16RegRead(dev,0x00,0x00,read_indexs[i],  &test_byte,1);
        PDEBUG( D_CONF, "Reg 0x%x => 0x%x\n",read_indexs[i],test_byte);
        i++;
    }
   t16RegWrite(dev, 0x00,0x01,0x0000,n3,0x06);
   t16RegWrite(dev, 0x00,0x01,0x0000,n4,0x46);
  t16RegRead(dev,0x00,0x00,0x0080,  &test_byte,1);
t16RegWrite(dev, 0x00,0x00,0x2c80,0x00,0x0);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset2,0x14);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset3,0x12);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset4,0x12);
t16RegWrite(dev, 0x00,0x00,0x3880,0x00,0x0);
t16RegWrite(dev, 0x00,0x00,0x3880,0x00,0x0);
t16RegWrite(dev, 0x00,0x00,0x338e,0x00,0x0);
   t16RegWrite(dev, 0x00,0x01,00,nset5,0x04);
t16RegWrite(dev, 0x00,0x00,0x00a9,0x00,0x0);
   t16RegWrite(dev, 0x00,0x01,00,nset6,0x22);
   t16RegWrite(dev, 0x00,0x00,0x86bb,0x00,0x0);
   t16RegWrite(dev, 0x00,0x00,0x4aa6,0x00,0x0);
t16RegWrite(dev, 0x00,0x01,00,missing,0x08);

   t16RegWrite(dev, 0x00,0x00,0x2087,0x00,0x0);
   t16RegWrite(dev, 0x00,0x00,0x2088,0x00,0x0);
   t16RegWrite(dev, 0x00,0x00,0x2089,0x00,0x0);

   t16RegWrite(dev, 0x00,0x01,00,nset7,0x4);
   t16RegWrite(dev, 0x00,0x01,00,nset10,0x06);
   t16RegWrite(dev, 0x00,0x01,00,nset8,0x06);
   t16RegWrite(dev, 0x00,0x01,00,nset9,0x04);
t16RegWrite(dev, 0x00,0x00,0x2880,0x00,0x0);
  t16RegWrite(dev, 0x00,0x01,0x0000,nset2,0x14);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset3,0x12);
   t16RegWrite(dev, 0x00,0x01,0x0000,nset4,0x12);

   
   return 0;
}


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};
   brightness = sd->brightness;

   if( brightness < 7 )
     set6[3]= 0x70 - ( brightness * 0xa);
   else
     {
	set6[1]= 0x24;
	set6[3]= 0x00 + (( brightness-7) * 0xa);
     }

   t16RegWrite(dev, 0x00,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;
 
   unsigned char flipcmd[8]= {0x62,0x07,0x63,0x03,0x64,0x00,0x60,0x09};
   
   if( sd->mirror  == 1 )
      flipcmd[3] = 0x01;
   
   t16RegWrite(dev, 0x00,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;

   //just in case...
   if( sd->effect >= MAX_EFFECTS  )
      sd->effect=0;
   
   t16RegWrite(dev,0x00,0x01,0x0000, effects_table[sd->effect],0x6);
   if( sd->effect == 1 || sd->effect ==5 )
   {
      PDEBUG( D_CONF, "This effect have been disabled for webcam \"safety\"\n");
      return;
   }
   
   if( sd->effect == 1 || sd->effect == 4 )
     t16RegWrite(dev,0x00,0x00,0x4aa6,0x00,0x00);
   else
     t16RegWrite(dev,0x00,0x00,0xfaa6,0x00,0x00);

}

static void setwhitebalance(struct gspca_dev *gspca_dev)
{
   struct sd *sd = (struct sd *) gspca_dev;
   struct usb_device *dev = gspca_dev->dev;
 
   unsigned char white_balance[8]= {0x87,0x20,0x88,0x20,0x89,0x20,0x80,0x38};

   if( sd->whitebalance == 1 )
     white_balance[7]=0x3c;

   t16RegWrite(dev, 0x00,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 == 1 ) //60hz
     freq[1]= 0x00;

   t16RegWrite(dev,0x00,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;

   if( contrast < 7 )
     reg_to_write = 0x8ea9 - (0x200 * contrast);
   else
     reg_to_write = ( 0x00a9 + ( (contrast-7) * 0x200 ));

   t16RegWrite(dev,0x00,0x00,reg_to_write,0x00,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;

   reg_to_write = 0xc0bb + (sd->colors * 0x100);
   t16RegWrite(dev,0x00, 0x00,reg_to_write,0x00,0);
   

}

static void setgamma(struct gspca_dev *gspca_dev)
{

   struct sd *sd = (struct sd *) gspca_dev;
   struct usb_device *dev = gspca_dev->dev;
return;
   printk( KERN_INFO " Gamma: %d\n", sd->gamma);

   if(  sd->gamma >= MAX_GAMMA)
     sd->gamma = 5;

   t16RegWrite(dev, 0x00,0x01,0x0000, gamma_table[sd->gamma],34);

}

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;
   reg_to_write = (0x0aa6) + (0x1000 * sd->sharpness);

   t16RegWrite(dev, 0x00,0x00,reg_to_write, 0x00,0x00);

}

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;
   *val = sd->brightness;
   return *val;
}


static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   sd->whitebalance = val;
   if (gspca_dev->streaming)
     setwhitebalance(gspca_dev);
   return 0;
}

static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   *val = sd->whitebalance;
   return *val;
}


static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   sd->mirror = val;
   if (gspca_dev->streaming)
     setflip(gspca_dev);
   return 0;
}

static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   *val = sd->mirror;
   return *val;
}

static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;


   sd->effect = val;
   if (gspca_dev->streaming)
     seteffect(gspca_dev);
   return 0;

}

static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   *val = sd->effect;
   return *val;
}

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;
   *val = sd->contrast;
   return *val;
}

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;

   *val = sd->colors;
   return 0;
}

static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   sd->gamma = val;
   if (gspca_dev->streaming)
     setgamma(gspca_dev);

   return 0;
}

static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;
   *val = sd->gamma;
   return 0;
}

static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   sd->freq = val;
   if (gspca_dev->streaming)
     setlightfreq(gspca_dev);
   return 0;
}

static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;
   *val = sd->freq;
   return 0;
}

static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   sd->sharpness = val;
   if (gspca_dev->streaming)
     setsharpness(gspca_dev);
   return 0;
}

static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;
   *val = sd->sharpness;
   return 0;
}

/* Low Light set  here......*/
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 == 1 )
     t16RegWrite(dev, 0x00,0x00,0xf48e,0x00,0);
   else
     t16RegWrite(dev, 0x00,0x00,0xb48e,0x00,0);

   return 0;
}

static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
{
   struct sd *sd = (struct sd *) gspca_dev;

   *val = sd->autogain;
   return 0;
}

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;
   __u8 test_byte;
   int i=0;
   unsigned char t1[]={0x66,0xca,0xa8,0xf0};
   unsigned char t2[]={0x07,0x00,0x0d,0x60,0x0e,0x80};

   unsigned char t3[]={0xb3,0x07,0xb4,0x00,0xb5,0x88,0xb6,0x02,0xb7,0x06,0xb8,0x00,0xb9,0xe7,0xba,0x01};
   unsigned char t4[]={0x0b,0x04,0x0a,0x78};
 unsigned char n1[6]={0x61,0x68,0x62,0xff,0x60,0x07};
   unsigned char n2[6]={0x61,0x68,0x65,0x0a,0x60,0x04};

   unsigned char n3[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 ,0xa2 ,0x60 ,0xa5 ,0x30 ,0xa6, 0x3a ,0xa8 ,0xe8,
    	0xae, 0x05 ,0xb1, 0x00, 0xbb ,0x04 ,0xbc, 0x48 ,0xbe ,0x36 ,0xc6, 0x88, 0xe9, 0x00 ,0xc5, 0xc0,
    	0x65 ,0x0a ,0xbb ,0x86 ,0xaf ,0x58, 0xb0, 0x68 ,0x87 ,0x40 ,0x89, 0x2b ,0x8d, 0xff ,0x83 ,0x40,
0xac,0x84,0xad,0x86,0xaf,0x46

};

   unsigned char n4[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

   unsigned char n5[20]={
	0xd0,0xbb,0xd1,0x28,0xd2,0x10,0xd3,0x10,0xd4,0xbb,0xd5,0x28,0xd6,0x1e,0xd7,0x27,
	0xd8,0xc8,0xd9,0xfc
     };
   unsigned char n6[18]={
	0xc7,0x60,0xc8,0xa8,0xc9,0xe0,0xca,0x60,0xcb,0xa8,0xcc,0xe0,0xcd,0x60,0xce,0xa8,
	0xcf,0xe0
     };

   switch( sd->bridge)
     {
      default:
      case BRIDGE_T16:
	mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode;
	switch(mode)
	  {
	   case 1:  //352x288
	     t2[1] = 0x5c;
	     break;;
	   case 2: //320x240
	     t2[1] = 0x10;
	     break;;
	   case 3: //176x144
	     t2[1] = 0x50;
	     break;;
	   case 4: //160x120
	     t2[1] =0x20;
	     break;;
	   default: //640x480 (0x00)
	     break;;
	  }
	break;;
     }
   t16RegWrite(dev, 0x00,0x01,0x0000,n1,0x6);
   t16RegWrite(dev, 0x00,0x01,0x0000,n2,0x6);
   t16RegWrite(dev, 0x00,0x01,0x0000,n3,0x46);
t16RegWrite(dev, 0x00,0x01,0x0000,n5,0x14);
   t16RegWrite(dev, 0x00,0x01,0x0000,n4,0x12);
   t16RegWrite(dev, 0x00,0x01,0x0000,n6,0x12);
 t16RegWrite(dev, 0x00,0x01,0x0000,t2,6);
t16RegWrite(dev, 0x00,0x01,0x0000,t3,0x10);
t16RegWrite(dev,0x00,0x00,0x0013,0x00,0x00);
t16RegWrite(dev,0x00,0x00,0x02a4,0x00,0x00);
t16RegWrite(dev,0x00,0x00,0x00a4,0x00,0x00);
t16RegWrite(dev,0x00,0x00,0x03a4,0x00,0x00);
t16RegWrite(dev,0x00,0x00,0x00a4,0x00,0x00);

t16RegWrite(dev,0x00,0x00,0x0109,0x00,0x00);
while( unknown_sensor_init[i][0] != 0x00 )
{
   t16RegWrite(dev, 0x00,0x01,0x0000,unknown_sensor_init[i],0x6);
    i++;
}
t16RegWrite(dev, 0x00,0x00,0x3880,0x00,0x00);


t16RegWrite(dev, 0x00,0x01,0x0000,t1,4);
t16RegRead(dev,0x00,0x00,0x0012,&test_byte,0x1);
t16RegWrite(dev, 0x00,0x01,0x0000,t2,6);
t16RegWrite(dev, 0x00,0x01,0x0000,t3,0x10);
t16RegWrite(dev,0x00,0x00,0x0013,0x00,0x00);
t16RegWrite(dev, 0x00,0x01,0x0000,t4,0x4);
t16RegWrite(dev, 0x00,0x01,0x0000,t4,0x4);


   setbrightness(gspca_dev);
   setcontrast(gspca_dev);
   setcolors( gspca_dev);
//   seteffect(gspca_dev);
//   setflip( gspca_dev);
   
}

static void sd_stopN(struct gspca_dev *gspca_dev)
{
}

static void sd_stop0(struct gspca_dev *gspca_dev)
{
}

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
			int len)			// iso packet length
{
   int sof = 0;
   static unsigned char ffd9[] = {0xff, 0xd9};


   if( data[0] == 0x5a )
     {
	//Control Packet, after this came the header again, but extra bytes came in the packet before this , sometimes an EOF arrives, sometimes not...
	return;
     }

   if( data[len-1] == 0xff && data[len] ==0xd9 )
     {
	//Just in case, i have seen packets with the marker, other's do not include it...
	data+=2;
	len -=4;
     }

   else if( data[2] == 0xff && data[3] == 0xd8 )
     {
        sof=1;
	data+=2;
	len -=2;
     }
   else
     {
	data += 2;
	len -= 2;
     }

   if (sof)
     {
	//extra bytes..... , could be processed too but would be a waste of time, right now leave the application and libjpeg do it for ourserlves..
	frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
				ffd9, 2);
	gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len );
	return;
     }

   gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
   return;

}

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:
		 
	         if( menu->index < 0 || menu->index >= NUM_FLICKER_CONTROL )
	                 return -EINVAL;
	         strncpy(menu->name,flicker_control[menu->index].name,32);
	         break;;
      case V4L2_CID_EFFECTS:
	 	 if( menu->index < 0 || menu->index >= NUM_EFFECTS_CONTROL )
	                 return -EINVAL;
	         strncpy(menu->name,effects_control[menu->index].name,32);
	         break;;
      default:
	  break;;
     };
   
   
   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;

   switch (sd->bridge)
     {
      case BRIDGE_T16:
	init_default_parameters(gspca_dev);
	break;;
      default:
	break;;

     }
   return 0;
}

/* sub-driver description */
static struct sd_desc sd_desc =
{
   .name = MODULE_NAME,
     .ctrls = sd_ctrls,
     .nctrls = sizeof sd_ctrls / sizeof sd_ctrls[0],
     .config = sd_config,
     .open = sd_open,
     .start = sd_start,
     .stopN = sd_stopN,
     .stop0 = sd_stop0,
     .close = sd_close,
     .pkt_scan = sd_pkt_scan,
     .querymenu = sd_querymenu, 
};

/* -- module initialisation -- */
#define DVNM(name) .driver_info = (kernel_ulong_t) name
static __devinitdata struct usb_device_id device_table[] =
{
     {USB_DEVICE(0x17a1, 0x0128), DVNM("XPX Webcam")},

     {}
};
MODULE_DEVICE_TABLE(usb, device_table);

/* -- device connect -- */
static int sd_probe(struct usb_interface *intf,
		    const struct usb_device_id *id)
{
   PDEBUG(D_PROBE, "camera probe");
   return gspca_dev_probe(intf, id, &sd_desc, sizeof (struct sd));
}

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);


		
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Spca50x-devs mailing list
Spca50x-devs@xxxxxxxxxxxxxxxxxxxxx
https://lists.sourceforge.net/lists/listinfo/spca50x-devs