sn9cxxx.h

来自「spca5xx video for linux (v4l) driver」· C头文件 代码 · 共 930 行 · 第 1/3 页

    0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06,
	0x06, 0x08, 0x0A, 0x11,
    0x0A, 0x0A, 0x08, 0x08, 0x0A, 0x15, 0x0F, 0x0F, 0x0C, 0x11, 0x19, 0x15,
	0x19, 0x19, 0x17, 0x15,
    0x17, 0x17, 0x1B, 0x1D, 0x25, 0x21, 0x1B, 0x1D, 0x23, 0x1D, 0x17, 0x17,
	0x21, 0x2E, 0x21, 0x23,
    0x27, 0x29, 0x2C, 0x2C, 0x2C, 0x19, 0x1F, 0x30, 0x32, 0x2E, 0x29, 0x32,
	0x25, 0x29, 0x2C, 0x29,
    0x06, 0x08, 0x08, 0x0A, 0x08, 0x0A, 0x13, 0x0A, 0x0A, 0x13, 0x29, 0x1B,
	0x17, 0x1B, 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, 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, mi0360_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_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;
    }
    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)