sn9cxxx.h

应用于linux系统的usb接口的摄像头驱动

    0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
	0x29, 0x29, 0x29, 0x29,
    0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
	0x29, 0x29, 0x29, 0x29,
    0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
	0x29, 0x29, 0x29, 0x29
};
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
};
#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);
}
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;
    __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 0;
}


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 CtrlA320[] = { 0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10 };	//Mclk
    //__u8 CtrlA640[] = { 0xA1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };//Mclk/2 BOUMM 
    __u8 CtrlA640[] = { 0xA1, 0x11, 0x01, 0x28, 0x00, 0x00, 0x00, 0x10 };	//Mckl/4
    while (hv7131r_sensor_init[i][0]) {
	sn9c102p_i2cwritebuf(dev, hv7131r_sensor_init[i]);
	i++;
    }
    if (spca50x->mode)
	sn9c102p_i2cwritebuf(dev, CtrlA320);
    else
	sn9c102p_i2cwritebuf(dev, CtrlA640);
}
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, hv7131r_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;
    }
    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 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_stop(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;
    }