spca561.h

linux下的摄像头驱动

{ 0 , 0x000f , 0x8805 },
{ 0 , 0x003b , 0x8801 },
{ 0 , 0x0000 , 0x8800 },
	
 { 0x00, 0x00, 0x8805},
 { 0x00, 0x3C, 0x8801},
 { 0x00, 0x00, 0x8800},
 
 { 0x00, 0x90, 0x8604}, //144
 { 0x00, 0x00, 0x8605},
 { 0x00, 0xB0, 0x8603}, //176
 { 0x00, 0x02, 0x8201},
 { 0x00, 0x08, 0x8200},
 { 0x00, 0x01, 0x8200},
 
 
 { 0x00, 0x07, 0x8201},
 { 0x00, 0x08, 0x8200},
 { 0x00, 0x01, 0x8200},
 
 { 0x00, 0x08, 0x8620},
 { 0x00, 0x0C, 0x8620},
 { 0x00, 0x00, 0x8610},
// white balance
 { 0x00, 0x3F, 0x8611},
 { 0x00, 0x3F, 0x8612},
 { 0x00, 0x3F, 0x8613},
 { 0x00, 0x3F, 0x8614},
 { 0x00, 0x3F, 0x8615},
 
 
 { 0x00, 0x55, 0x8616},
 { 0x00, 0x3F, 0x8617},
 { 0x00, 0xF0, 0x8505},
 { 0x00, 0x32, 0x850A},
 /*******************/
// { 0 , 0x0081 , 0x8702 },
 /*******************/
// { 0x00, 0x00, 0x8500},
 { 0x00, 0x10, 0x8500}, // compression registers overwrite by start
 { 0x00, 0x07, 0x8601},
 { 0x00, 0x07, 0x8602},
 { 0x00, 0x01, 0x8801},
 { 0x00, 0x03, 0x8805},
 { 0x00, 0x00, 0x8800},
 
{ 0x00, 0x02, 0x8801},
{ 0x00, 0x0E, 0x8805},
{ 0x00, 0x00, 0x8800},

 { 0x00, 0x0C, 0x8620},
 /**********************/
 {0,0,0}
};
static void sensor_Reset(struct usb_spca50x *spca50x)
{
int err;
	err=spca50x_reg_write (spca50x->dev, 0, 0x8631,0xC8);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8634,0xC8);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8112,0x00);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8114,0x00);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8118,0x21);
	spca561_InitI2c(spca50x,0x14);
	spca561_WriteI2c(spca50x,1,0x0d);
	spca561_WriteI2c(spca50x,0,0x0d);
}
static int init_vista(struct usb_spca50x *spca50x)
{
int err;
	__u8 Reg8391[] = { 0x90,0x30,0x14,0x00,0x0c,0x00,0x00,0x00}; //14
	__u8 Reg8307[] = { 0xaa,0x00};
	
	err=spca50x_reg_write (spca50x->dev, 0, 0x8620,0x00);	//
	sensor_Reset(spca50x); 
	spca50x_write_vector(spca50x,spca561_vista_data) ;
	spca5xxRegWrite(spca50x->dev,0,0, 0x8307,Reg8307,2);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, 0x85);	// 0x27 clock
	spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391,8);
	spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391,8);	
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20);
	err=spca50x_reg_write(spca50x->dev, 0, 0x850b, 0x03); 
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x00);
	
	
	err=spca50x_reg_write (spca50x->dev, 0, 0x8118, 0x29);	
	err=spca50x_reg_write (spca50x->dev, 0, 0x8114, 0x00);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8620, 0x00);
	
	spca50x_write_vector(spca50x,spca561_vista_data) ;
	
	spca5xxRegWrite(spca50x->dev,0,0, 0x8307,Reg8307,2);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, 0x85);	// 0x27 clock
	spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391,8);
	spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391,8);	
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20);
	err=spca50x_reg_write(spca50x->dev, 0, 0x850b, 0x03); 
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x20);	//
	return 0;

}
/************************* End Vista stuff ***************************/

/************************* QC Express etch2 stuff ********************/
static __u16 Pb100_1map8300 [][2] = {
/* reg, value */
{0x8320, 0x3304},
{0x8303, 0x0125},
{0x8304, 0x0169},
{0x8328, 0x000b},
{0x833c, 0x0007},
{0x832f, 0x0419},
{0x8307, 0x00aa},
{0x8339, 0x0000},
{0x8335, 0x0018},
{0x8309, 0x2048},
{0x8301, 0x0003},
{0x8302, 0x000e},
{0,0}
};
static __u16 Pb100_2map8300 [][2] = {
/* reg, value */
{0x8339, 0x0000},
{0x8307, 0x00aa},
{0,0}
};
static __u16 spca561_qcexpress2_data1[][3]= {
 { 0x00, 0x29, 0x8118 },
 { 0x00, 0x08, 0x8114 },
 { 0x00, 0x0e, 0x8112 },
 { 0x00, 0x92, 0x8804 },
 { 0x00, 0x04, 0x8802 },
 {0,0,0}
 };
static __u16 spca561_qcexpress2_data2[][3]= {
 { 0x00, 0x21, 0x8118 },
 { 0x00, 0x10, 0x8500 }, //11
 { 0x00, 0x07, 0x8601 },
 { 0x00, 0x07, 0x8602 },
 { 0x00, 0x04, 0x8501 },
 { 0x00, 0x21, 0x8118 },
 { 0x00, 0x02, 0x8201 },
 { 0x00, 0x08, 0x8200 },
 { 0x00, 0x01, 0x8200 },
 //
 { 0x00, 0x00, 0x8114 },
 { 0x00, 0x00, 0x8114 },
 { 0x00, 0x90, 0x8604 },
 { 0x00, 0x00, 0x8605 },
 { 0x00, 0xb0, 0x8603 },
 { 0x00, 0x00, 0x8610 },
 { 0x00, 0x3F, 0x8611 },
 { 0x00, 0x3F, 0x8612 },
 { 0x00, 0x3F, 0x8613 },
 { 0x00, 0x40, 0x8614 },
 { 0x00, 0x40, 0x8615 },
 { 0x00, 0x7a, 0x8616 },
 { 0x00, 0x40, 0x8617 },
 { 0x00, 0x0c, 0x8620 },
 { 0x00, 0xc8, 0x8631 },
 { 0x00, 0xc8, 0x8634 },
 { 0x00, 0x23, 0x8635 },
 { 0x00, 0x1f, 0x8636 },
 { 0x00, 0xdd, 0x8637 },
 { 0x00, 0xe1, 0x8638 },
 { 0x00, 0x1d, 0x8639 },
 { 0x00, 0x21, 0x863a },
 { 0x00, 0xe3, 0x863b },
 { 0x00, 0xdf, 0x863c },
 { 0x00, 0xf0, 0x8505 },
 { 0x00, 0x32, 0x850a }, 
 {0,0,0}
 };
 
static void sensor_mapwrite(struct usb_spca50x *spca50x, __u16 sensormap[][2])
{ int i = 0;
 __u8 usbval[]={0,0};
 
while (sensormap[i][0]){
 usbval[0] = sensormap[i][1] & 0xff;
 usbval[1] = (sensormap[i][1] >> 8) & 0xff;
 spca5xxRegWrite(spca50x->dev,0x00,0x00 ,sensormap[i][0] ,usbval ,2 );
 i++;	
}
}
static int init_qcexpress2(struct usb_spca50x *spca50x)
{
	int err;
	__u8 Reg8391[] = { 0x23,0x21,0x10,0x00,0x3a,0x00,0x00,0x00}; //14
	__u8 Reg8307[] = { 0xaa,0x00};
	spca50x_write_vector(spca50x,spca561_qcexpress2_data1) ;
	sensor_mapwrite (spca50x, Pb100_1map8300);
	spca50x_write_vector(spca50x,spca561_qcexpress2_data2) ;
	sensor_mapwrite (spca50x, Pb100_2map8300);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, 0x85);	// 0x27 clock
	spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391,8);
	spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391,8);
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20);
	err=spca50x_reg_write(spca50x->dev, 0, 0x850b, 0x03);
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x00);

//set_alternate setting 0
	err=spca50x_reg_write (spca50x->dev, 0, 0x8118, 0x29);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8114, 0x00);	
//set_alternate setting 7

	spca50x_write_vector(spca50x,spca561_qcexpress2_data2) ;
	spca5xxRegWrite(spca50x->dev,0,0, 0x8307,Reg8307,2);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, 0x85);	// 0x27 clock
	spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391,8);
	spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391,8);
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20);
	err=spca50x_reg_write(spca50x->dev, 0, 0x850b, 0x03);
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x20);	//
	return 0;

}

/************************* End QC Express stuff **********************/
/************************* Core spca561 stuff ************************/
static int spca561_init(struct usb_spca50x *spca50x){
	int err;	
	
	switch (spca50x->customid){
	case 0x7004:
	case 0xa001:
	case 0x0815:
	case 0x0561:
	case 0xcdee:
	case 0x7e50:
	PDEBUG(0,"Find spca561 USB Product ID %x",spca50x->customid);
	spca50x_write_vector(spca50x,spca561_init_data) ;
	break;
	case 0x403b:
	PDEBUG(0,"Find spca561 USB Product ID %x",spca50x->customid);
	err= init_vista(spca50x);
	break;
	case 0x092a:
	case 0x0928:
	PDEBUG(0,"Find spca561 USB Product ID %x",spca50x->customid);
	err=init_qcexpress2(spca50x);
	break;
	default:
	PDEBUG(0,"Error reading USB Product ID from Global register");
	break;
	}
	return 0;
}
static void spca561_start(struct usb_spca50x *spca50x)
{
	int err;
	int Clck = 0;
	__u8 Reg8307[] = { 0xaa,0x00};
	
	__u8 Reg8391[] = { 0x90,0x30,0x1b,0x00,0x0c,0x00,0x00,0x00};
	__u8 Reg8391q[] = { 0x23,0x21,0x10,0x00,0x3a,0x00,0x00,0x00};
	
	switch (spca50x->customid){
	case 0x7004:
	case 0xa001:
	case 0x0815:
	case 0x0561:
	case 0xcdee:
	case 0x7e50:
	switch (spca50x->mode){
		case 0:
		case 1:
			Clck = 0x25;
		break;
		case 2:
			Clck = 0x22;
		break;
		case 3:
			Clck = 0x21;
		break;
		default:
			Clck = 0x25;
	 	break;
	}
	err=spca50x_reg_write (spca50x->dev, 0, 0x8500,spca50x->mode);	// mode
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, Clck);	// 0x27 clock
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20); 
	
	break;
	case 0x0928:
	case 0x092a:
	case 0x403b:
	switch (spca50x->mode){
		case 0: 
			Clck =(spca50x->customid == 0x403b) ? 0x8a : 0x8f;
		break;
		case 1:
			Clck = 0x8a;
		break;
		case 2:
			Clck = 0x85;
		break;
		case 3:
			Clck = 0x83;
		break;
		default:
			Clck = 0x25;
	 	break;
	}
	err=spca50x_reg_write (spca50x->dev, 0, 0x8500,spca50x->mode);	// 10 mode
	spca5xxRegWrite(spca50x->dev,0,0, 0x8307,Reg8307,2);
	err=spca50x_reg_write (spca50x->dev, 0, 0x8700, Clck);	// 0x8f 0x85 0x27 clock
	if (spca50x->customid == 0x403b){
		spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391,8);
		spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391,8);
	} else {
		spca5xxRegWrite(spca50x->dev,0,0, 0x8391,Reg8391q,8);
		spca5xxRegWrite(spca50x->dev,0,0, 0x8390,Reg8391q,8);
	}
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x10 | 0x20);
	
	err=spca50x_reg_write(spca50x->dev, 0, 0x850b, 0x03); 
	#if 0
	err=spca561_getcontrast(spca50x);
	PDEBUG(0, "Set constrast 0x8335 0x%02x", spca50x->contrast >> 10);
	err=spca561_setcontrast(spca50x);
	#endif
	break;
	default:
	PDEBUG(0,"Error reading USB Product ID from Global register");
	break;
	}
	
}
static void spca561_stop(struct usb_spca50x *spca50x){
	int err;
	err=spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x20); 
}
static __u16 spca561_setbrightness(struct usb_spca50x *spca50x)
{
	__u8 value = 0;
	value = spca50x->brightness >> 9;
	spca5xxRegWrite(spca50x->dev,0,value,0x8611,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,value,0x8612,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,value,0x8613,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,value,0x8614,NULL,0);
	return 0;
} 
static __u16 spca561_getbrightness(struct usb_spca50x *spca50x)
{
	__u8 value = 0;
	__u16 tot = 0;
	spca5xxRegRead(spca50x->dev,0,0,0x8611,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8612,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8613,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8614,&value,1);
	tot += value;
	spca50x->brightness = tot << 7;
	return 0;
} 
static __u16 spca561_setcontrast(struct usb_spca50x *spca50x)
{
	
	__u8 lowb = 0;
	#if 0
	lowb = (spca50x->contrast >> 10) & 0x7F;
	spca5xxRegWrite(spca50x->dev,0,0,0x8335,&lowb,1);
	PDEBUG(0, "Set constrast 0x8335 0x%02x", lowb);
	#endif
	lowb = (spca50x->contrast >> 8) & 0xFF;
	spca5xxRegWrite(spca50x->dev,0,lowb,0x8651,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,lowb,0x8652,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,lowb,0x8653,NULL,0);
	spca5xxRegWrite(spca50x->dev,0,lowb,0x8654,NULL,0);
	
	return 0;
}
static __u16 spca561_getcontrast(struct usb_spca50x *spca50x)
{
	__u8 value = 0;
	__u16 tot = 0;
	#if 0
	__u8 contrast = 0x18;
	spca5xxRegWrite(spca50x->dev,0,0, 0x8335,&contrast,1);
	/* always 0x8335 return 0 */
	spca5xxRegRead(spca50x->dev,0,0,0x8335,&value,1);
	spca50x->contrast = (value & 0x7f) << 10;
	PDEBUG(0, "Get constrast 0x8335 0x%02x", value);
	#endif
	value = 0;
	spca5xxRegRead(spca50x->dev,0,0,0x8651,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8652,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8653,&value,1);
	tot += value;
	spca5xxRegRead(spca50x->dev,0,0,0x8654,&value,1);
	tot += value;
	spca50x->contrast = tot << 6;
	return 0;
} 
static int spca561_config(struct usb_spca50x *spca50x)
{
	struct usb_device *dev = spca50x->dev;
	int data1, data2;
	// Read frm global register the USB product and vendor IDs, just to	
	// prove that we can communicate with the device.  This works, which
	// confirms at we are communicating properly and that the device
	// is a 561.
	data1 = spca50x_reg_read(dev, 0, 0x8104, 1);
	if (data1 < 0) PDEBUG(1,"Error reading USB Vendor ID from Global register");
	data2 = spca50x_reg_read(dev, 0, 0x8105, 1);
	if (data2 < 0)
		PDEBUG(1,"Error reading USB Vendor ID from Global register");
	PDEBUG(1, "Read from GLOBAL: USB Vendor ID 0x%02x%02x", data2, data1);

	data1=spca50x_reg_read(dev, 0, 0x8106, 1);
	if (data1 < 0)
		PDEBUG(1, "Error reading USB Product ID from Global register");
	data2 = spca50x_reg_read(dev, 0, 0x8107, 1);
	if (data2 < 0)
		PDEBUG(1, "Error reading USB Product ID from Global register");
	PDEBUG(1, "Read from GLOBAL: USB Product ID 0x%02x%02x", data2, data1);
	spca50x->customid = ((data2 << 8) | data1) & 0xffff;
	
	
	return 0; // success
}
 
#endif