sn9cxxx.h

Linux下面摄像头最新源代码:支持200多中摄像头

	0x29, 0x29, 0x29, 0x29,
	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
	0x29, 0x29, 0x29, 0x29
};

#if 0
static __u8 qtable5[] = {
	0x05, 0x03, 0x03, 0x05, 0x03, 0x03, 0x05, 0x05, 0x05, 0x05, 0x07, 0x05,
	0x05, 0x07, 0x09, 0x0E,
	0x09, 0x09, 0x07, 0x07, 0x09, 0x11, 0x0C, 0x0C, 0x0A, 0x0E, 0x15, 0x11,
	0x15, 0x15, 0x13, 0x11,
	0x13, 0x13, 0x16, 0x18, 0x1F, 0x1C, 0x16, 0x18, 0x1D, 0x18, 0x13, 0x13,
	0x1C, 0x26, 0x1C, 0x1D,
	0x21, 0x23, 0x24, 0x24, 0x24, 0x15, 0x1A, 0x28, 0x29, 0x26, 0x23, 0x29,
	0x1F, 0x23, 0x24, 0x23,
	0x05, 0x07, 0x07, 0x09, 0x07, 0x09, 0x10, 0x09, 0x09, 0x10, 0x23, 0x16,
	0x13, 0x16, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x23, 0x23
};
static __u8 qtable6[] = {
	0x04, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x06, 0x04,
	0x04, 0x06, 0x07, 0x0C,
	0x07, 0x07, 0x06, 0x06, 0x07, 0x0E, 0x0A, 0x0A, 0x09, 0x0C, 0x11, 0x0E,
	0x11, 0x11, 0x10, 0x0E,
	0x10, 0x10, 0x13, 0x14, 0x1A, 0x17, 0x13, 0x14, 0x18, 0x14, 0x10, 0x10,
	0x17, 0x20, 0x17, 0x18,
	0x1B, 0x1D, 0x1E, 0x1E, 0x1E, 0x11, 0x16, 0x21, 0x23, 0x20, 0x1D, 0x23,
	0x1A, 0x1D, 0x1E, 0x1D,
	0x04, 0x06, 0x06, 0x07, 0x06, 0x07, 0x0D, 0x07, 0x07, 0x0D, 0x1D, 0x13,
	0x10, 0x13, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D,
	0x1D, 0x1D, 0x1D, 0x1D
};
static __u8 qtable7[] = {
	0x04, 0x02, 0x02, 0x04, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x05, 0x04,
	0x04, 0x05, 0x06, 0x0A,
	0x06, 0x06, 0x05, 0x05, 0x06, 0x0C, 0x08, 0x08, 0x07, 0x0A, 0x0E, 0x0C,
	0x0E, 0x0E, 0x0D, 0x0C,
	0x0D, 0x0D, 0x10, 0x11, 0x16, 0x13, 0x10, 0x11, 0x14, 0x11, 0x0D, 0x0D,
	0x13, 0x1A, 0x13, 0x14,
	0x17, 0x18, 0x19, 0x19, 0x19, 0x0E, 0x12, 0x1C, 0x1D, 0x1A, 0x18, 0x1D,
	0x16, 0x18, 0x19, 0x18,
	0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x0B, 0x06, 0x06, 0x0B, 0x18, 0x10,
	0x0D, 0x10, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	0x18, 0x18, 0x18, 0x18
};
static __u8 qtable8[] = {
	0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03,
	0x03, 0x04, 0x05, 0x08,
	0x05, 0x05, 0x04, 0x04, 0x05, 0x0A, 0x07, 0x07, 0x06, 0x08, 0x0C, 0x0A,
	0x0C, 0x0C, 0x0B, 0x0A,
	0x0B, 0x0B, 0x0D, 0x0E, 0x12, 0x10, 0x0D, 0x0E, 0x11, 0x0E, 0x0B, 0x0B,
	0x10, 0x16, 0x10, 0x11,
	0x13, 0x14, 0x15, 0x15, 0x15, 0x0C, 0x0F, 0x17, 0x18, 0x16, 0x14, 0x18,
	0x12, 0x14, 0x15, 0x14,
	0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x09, 0x05, 0x05, 0x09, 0x14, 0x0D,
	0x0B, 0x0D, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
	0x14, 0x14, 0x14, 0x14
};

static int
sn9c102p_status(struct usb_device *dev)
{
	__u8 status = 0;
	__u8 count = 10;
	while (count--) {
		status = 0;
		sonixRegRead(dev, 0x00, 0x08, 0x0000, &status, 1);
		if (status & 0x04)
			return 0;
		if (status & 0x08)
			return -EIO;
		wait_ms(1);
	}
	return -ETIMEDOUT;
}
#endif
static int
sn9c102p_i2cwrite(struct usb_spca50x *spca50x, __u8 * buffer, __u16 length)
{
	struct usb_device *dev = spca50x->dev;
	__u8 mode[] = { 0x81, 0x11, 0, 0, 0, 0, 0, 0x10 };
	/* is i2c ready */
	__u8 i2cbase = spca50x->i2c_base;
	__u8 i2cCtrl = spca50x->i2c_ctrl_reg;
	mode[0] = i2cCtrl;
	mode[1] = i2cbase;
	if (length > 5 || !buffer)
		return -1;
	mode[0] = mode[0] | length << 4;
	memcpy(&mode[2], buffer, length);
	sonixRegWrite(dev, 0x08, 0x08, 0x0000, mode, 8);
	return 0;
}

static void
sn9c102p_i2cwritebuf(struct usb_device *dev, __u8 * buffer)
{
	sonixRegWrite(dev, 0x08, 0x08, 0x0000, buffer, 8);
	wait_ms(1);
}

static int
sn9c102p_i2cread(struct usb_spca50x *spca50x, __u8 reg,
		 __u8 * buffer, __u16 length)
{
	struct usb_device *dev = spca50x->dev;
	__u8 i2cbase = spca50x->i2c_base;
	__u8 i2cCtrl = spca50x->i2c_ctrl_reg;
	int err = 0;
	__u8 mode[] = { 0x91, 0x11, 0, 0, 0, 0, 0, 0x10 };
	__u8 result[] = { 0, 0, 0, 0, 0 };
	mode[0] = i2cCtrl | 0x10;
	mode[1] = i2cbase;
	if (length > 5 || !buffer)
		return -1;
	mode[2] = reg;
	sonixRegWrite(dev, 0x08, 0x08, 0x0000, mode, 8);
	wait_ms(1);
	mode[2] = 0;
	mode[0] = i2cCtrl | length << 4 | 0x02;
	sonixRegWrite(dev, 0x08, 0x08, 0x0000, mode, 8);
	wait_ms(1);
	sonixRegRead(dev, 0x00, 0x0a, 0x0000, result, 5);
	memcpy(buffer, result, length);
	return err;
}

static int
sn9cxxx_probesensor(struct usb_spca50x *spca50x)
{
	struct usb_device *dev = spca50x->dev;
	int err = 0;
	__u8 reg02 = 0x66;
	/* reg val1 val2 val3 val4 */
	__u8 datasend[] = { 0, 0, 0, 0, 0 };
	__u8 datarecd[] = { 0, 0, 0, 0, 0 };
	datasend[0] = 2;	//sensor wakeup
	err = sn9c102p_i2cwrite(spca50x, datasend, 2);
	//should write 0xa1 0x11 0x02 0x00 0x00 0x00 0x00 the 0x10 is add by i2cw
	wait_ms(10);
	sonixRegWrite(dev, 0x08, 0x02, 0x0000, &reg02, 1);	//Gpio on
	wait_ms(10);
	err += sn9c102p_i2cread(spca50x, 0, datarecd, 5);	//read sensor id
	if (err)
		goto errors;
	if (datarecd[0] == 0x02 && datarecd[1] == 0x09 && datarecd[2] == 0x01
	    && datarecd[3] == 0x00 && datarecd[4] == 0x00) {
		PDEBUG(1, "Find Sensor sn9c102P HV7131R");
		spca50x->sensor = SENSOR_HV7131R;
		return SENSOR_HV7131R;
	}
	PDEBUG(0, "Find Sensor %d %d %d", datarecd[0], datarecd[1],
	       datarecd[2]);
	PDEBUG(0, "Sensor sn9c102P Not found Contact [e-mail] ");
	return -ENODEV;
      errors:PDEBUG(0,
	       "Sensor sn9c102P too many errors Contact [e-mail] ");
	return -ENODEV;
}

static void
hv7131R_InitSensor(struct usb_spca50x *spca50x)
{
	int i = 0;
	struct usb_device *dev = spca50x->dev;
	__u8 SetSensorClk[] = { 0xA1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };	//0x08 Mclk

	while (hv7131r_sensor_init[i][0]) {
		sn9c102p_i2cwritebuf(dev, hv7131r_sensor_init[i]);
		i++;
	}
	sn9c102p_i2cwritebuf(dev, SetSensorClk);
}
static void
mi0360_InitSensor(struct usb_spca50x *spca50x)
{
	int i = 0;
	struct usb_device *dev = spca50x->dev;

	while (mi0360_sensor_init[i][0]) {
		sn9c102p_i2cwritebuf(dev, mi0360_sensor_init[i]);
		i++;
	}
}
static void
mo4000_InitSensor(struct usb_spca50x *spca50x)
{
	int i = 0;
	struct usb_device *dev = spca50x->dev;

	while (mo4000_sensor_init[i][0]) {
		sn9c102p_i2cwritebuf(dev, mo4000_sensor_init[i]);
		i++;
	}
}
static void
ov7660_InitSensor(struct usb_spca50x *spca50x)
{
	int i = 0;
	struct usb_device *dev = spca50x->dev;

	while (ov7660_sensor_init[i][0]) {
		sn9c102p_i2cwritebuf(dev, ov7660_sensor_init[i]);
		i++;
	}
}
static int
sn9cxxx_init(struct usb_spca50x *spca50x)
{
	struct usb_device *dev = spca50x->dev;
	int err = 0;
	__u8 *sn9c1xx = NULL;
	__u8 regF1 = 0x01;
	__u8 regGpio[] = { 0x29, 0x74 };
	__u8 data = 0x00;
	/* setup a selector by customid */
	switch (spca50x->sensor) {
	case SENSOR_HV7131R:
		sn9c1xx = sn_hv7131;
		break;
	case SENSOR_MI0360:
		sn9c1xx = sn_mi0360;
		break;
	case SENSOR_MO4000:
		sn9c1xx = sn_mo4000;
		break;
	case SENSOR_OV7660:
		sn9c1xx = sn_ov7660;
		break;
	}
	if (sn9c1xx == NULL)
		return -ENODEV;
	sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);
	sonixRegRead(dev, 0x00, 0x00, 0x0000, &regF1, 1);
	sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);
	sonixRegRead(dev, 0x00, 0x00, 0x0000, &regF1, 1);
	switch (spca50x->customid) {
	case SN9C102P:
		if (regF1 != 0x11)
			return -ENODEV;
		sonixRegWrite(dev, 0x08, 0x02, 0x0000, &regGpio[1], 1);
	case SN9C105:
		if (regF1 != 0x11)
			return -ENODEV;
		sonixRegWrite(dev, 0x08, 0x02, 0x0000, regGpio, 2);
		break;
	case SN9C110:
		if (regF1 != 0x12)
			return -ENODEV;
		regGpio[1] = 0x62;
		sonixRegWrite(dev, 0x08, 0x02, 0x0000, &regGpio[1], 1);
		break;
		break;
	case SN9C120:
		if (regF1 != 0x12)
			return -ENODEV;
		regGpio[1] = 0x70;
		sonixRegWrite(dev, 0x08, 0x02, 0x0000, regGpio, 2);
		break;
	}

	regF1 = 0x01;
	sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);

	regF1 = 0x00;
	sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);

	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 1);

	// configure gpio 
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 2);

	sonixRegWrite(dev, 0x08, 0x08, 0x0000, &sn9c1xx[8], 2);

	sonixRegWrite(dev, 0x08, 0x017, 0x0000, &sn9c1xx[0x17], 3);

	sonixRegWrite(dev, 0x08, 0x9a, 0x0000, reg9a, 6);

	data = 0x60;
	sonixRegWrite(dev, 0x08, 0xD4, 0x0000, &data, 1);

	sonixRegWrite(dev, 0x08, 0x03, 0x0000, &sn9c1xx[3], 0x0f);

	data = 0x43;
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &data, 1);

	data = 0x61;
	sonixRegWrite(dev, 0x08, 0x17, 0x0000, &data, 1);

	data = 0x42;
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &data, 1);
	switch (spca50x->sensor) {
	case SENSOR_HV7131R:
		// probe sensor
		if ((err = sn9cxxx_probesensor(spca50x)) < 0)
			return -ENODEV;
		break;
	}

	return 0;
}
static void
sn9cxxx_stopN(struct usb_spca50x *spca50x)
{
	struct usb_device *dev = spca50x->dev;
	__u8 stophv7131[] = { 0xA1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
	__u8 stopmi0360[] = { 0xB1, 0x5D, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
	__u8 regF1 = 0x01;
	__u8 data = 0x0b;
	__u8 *sn9c1xx = NULL;
	switch (spca50x->sensor) {
	case SENSOR_HV7131R:
		sn9c1xx = sn_hv7131;
		data = 0x2b;
		sn9c102p_i2cwritebuf(dev, stophv7131);
		break;
	case SENSOR_MI0360:
		sn9c1xx = sn_mi0360;
		data = 0x29;
		sn9c102p_i2cwritebuf(dev, stopmi0360);
		break;
	case SENSOR_MO4000:
		sn9c1xx = sn_mo4000;
		break;
	case SENSOR_OV7660:
		sn9c1xx = sn_ov7660;
		break;
	}
	if (sn9c1xx == NULL)
		return;
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 1);
	sonixRegWrite(dev, 0x08, 0x17, 0x0000, &sn9c1xx[0x17], 1);
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 1);
	sonixRegWrite(dev, 0x08, 0x01, 0x0000, &data, 1);
	sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);
}
static void
sn9cxxx_start(struct usb_spca50x *spca50x)
{
	struct usb_device *dev = spca50x->dev;
	int i;
	__u8 DC29[] = { 0x6a, 0x50, 0x00, 0x00, 0x50, 0x3c };
	__u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
	__u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
	__u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };	//MI0360
	__u8 data = 0;
	__u8 regF1 = 0x00;
	__u8 reg17 = 0x61;
	__u8 reg1 = 0x02;
	int err = 0;
	__u8 *sn9c1xx = NULL;
	switch (spca50x->sensor) {
	case SENSOR_HV7131R:
		sn9c1xx = sn_hv7131;
		break;
	case SENSOR_MI0360:
		sn9c1xx = sn_mi0360;
		break;
	case SENSOR_MO4000:
		sn9c1xx = sn_mo4000;
		break;
	case SENSOR_OV7660:
		sn9c1xx = sn_ov7660;