sn9cxxx.h

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

    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 };
    //HV7131 __u8 CE[]={0x28, 0xec, 0x1e, 0xec };
    __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };	//MI0360
    //__u8 gain[] = { 0xB1, 0x5D, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10 };	//gain 
    //__u8 doit[] = { 0xB1, 0x5D, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };	//update sensor
    //__u8 sensorgo[] = { 0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };	//sensor on
    //__u8 expo[]={ 0xB1,0x5D,0x09,0x06,0x35,0x00,0x00,0x10 };// exposure 0x0635 -> 4 fp/s
    __u8 data = 0;
    __u8 regF1 = 0x00;
    int err = 0;
    __u8 *sn9c1xx = NULL;
    switch (spca50x->sensor) {
    case SENSOR_HV7131R:
	sn9c1xx = sn_hv7131;
	break;
    case SENSOR_MI0360:
	sn9c1xx = sn_mi0360;
	break;
    }
    if (sn9c1xx == NULL)
	return;
    sonixRegWrite(dev, 0x08, 0xf1, 0x0000, &regF1, 1);
    sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 1);
    sonixRegWrite(dev, 0x08, 0x01, 0x0000, &sn9c1xx[1], 2);
    sonixRegWrite(dev, 0x08, 0x08, 0x0000, &sn9c1xx[8], 2);
    sonixRegWrite(dev, 0x08, 0x17, 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:
	if ((err = sn9cxxx_probesensor(spca50x)) < 0)
	    return;
	break;
    }

    sonixRegWrite(dev, 0x08, 0x15, 0x0000, &sn9c1xx[0x15], 1);
    sonixRegWrite(dev, 0x08, 0x16, 0x0000, &sn9c1xx[0x16], 1);
    sonixRegWrite(dev, 0x08, 0x12, 0x0000, &sn9c1xx[0x12], 1);
    sonixRegWrite(dev, 0x08, 0x13, 0x0000, &sn9c1xx[0x13], 1);
    sonixRegWrite(dev, 0x08, 0x18, 0x0000, &sn9c1xx[0x18], 1);
    sonixRegWrite(dev, 0x08, 0xd2, 0x0000, &DC29[0], 1);
    sonixRegWrite(dev, 0x08, 0xd3, 0x0000, &DC29[1], 1);
    sonixRegWrite(dev, 0x08, 0xc6, 0x0000, &DC29[2], 1);
    sonixRegWrite(dev, 0x08, 0xc7, 0x0000, &DC29[3], 1);
    sonixRegWrite(dev, 0x08, 0xc8, 0x0000, &DC29[4], 1);
    sonixRegWrite(dev, 0x08, 0xc9, 0x0000, &DC29[5], 1);
    sonixRegWrite(dev, 0x08, 0x18, 0x0000, &sn9c1xx[0x18], 1);
    data = 0x60;
    sonixRegWrite(dev, 0x08, 0x17, 0x0000, &data, 1);
    sonixRegWrite(dev, 0x08, 0x05, 0x0000, &sn9c1xx[5], 1);
    sonixRegWrite(dev, 0x08, 0x07, 0x0000, &sn9c1xx[7], 1);
    sonixRegWrite(dev, 0x08, 0x06, 0x0000, &sn9c1xx[6], 1);
    sonixRegWrite(dev, 0x08, 0x14, 0x0000, &sn9c1xx[0x14], 1);
    sonixRegWrite(dev, 0x08, 0x20, 0x0000, regsn20, 0x11);
    for (i = 0; i < 8; i++)
	sonixRegWrite(dev, 0x08, 0x84, 0x0000, reg84, 0x15);
    data = 0x08;
    sonixRegWrite(dev, 0x08, 0x9a, 0x0000, &data, 1);
    data = 0x59;
    sonixRegWrite(dev, 0x08, 0x99, 0x0000, &data, 1);

    switch (spca50x->sensor) {
    case SENSOR_HV7131R:
	hv7131R_InitSensor(spca50x);
	break;
    case SENSOR_MI0360:
	mi0360_InitSensor(spca50x);
	break;
    }
    sonixRegWrite(dev, 0x08, 0xc0, 0x0000, C0, 6);
    sonixRegWrite(dev, 0x08, 0xca, 0x0000, CA, 4);
    sonixRegWrite(dev, 0x08, 0xce, 0x0000, CE, 4);	//?? {0x1e,0xdd,0x2d,0xe7}

    // here change size mode 0 -> VGA; 1 -> CIF
    data = 0x40 | sn9c1xx[0x18] | (spca50x->mode << 4);
    sonixRegWrite(dev, 0x08, 0x18, 0x0000, &data, 1);

    sonixRegWrite(dev, 0x08, 0x100, 0x0000, qtable3, 0x40);
    sonixRegWrite(dev, 0x08, 0x140, 0x0000, qtable3 + 0x40, 0x40);

    data = sn9c1xx[0x18] | (spca50x->mode << 4);
    sonixRegWrite(dev, 0x08, 0x18, 0x0000, &data, 1);
    data = 0x02;		//0x42
    sonixRegWrite(dev, 0x08, 0x01, 0x0000, &data, 1);
    data = 0x61;		//0x61
    sonixRegWrite(dev, 0x08, 0x17, 0x0000, &data, 1);
    if (spca50x->mode)
	data = 0x06;		//320 06clk 12Mhz
    else {

	if (spca50x->sensor == SENSOR_MI0360) {
	    data = 0x65;	//0x61
	    sonixRegWrite(dev, 0x08, 0x17, 0x0000, &data, 1);
	}
	data = 0x46;		//640 clk 24Mz 46
    }
    // enable video on
    sonixRegWrite(dev, 0x08, 0x01, 0x0000, &data, 1);

    err = sn9cxxx_setbrightness(spca50x);
    err = sn9cxxx_setcontrast(spca50x);
    /*FIXME Need to be in the brightness exposure setting */
    /*
    if (spca50x->sensor == SENSOR_MI0360) {	
	sn9c102p_i2cwritebuf(dev, gain);
	// sn9c102p_i2cwritebuf (dev,expo);
	sn9c102p_i2cwritebuf(dev, doit);
	sn9c102p_i2cwritebuf(dev, sensorgo);
    }
    */
    //sn9c102p_i2cwritebuf (dev,PreAInit);
    //sn9c102p_i2cwritebuf (dev,RInit);
}

static unsigned int sn9cxxx_getexposure(struct usb_spca50x *spca50x)
{
    __u8 expo[] = { 0, 0, 0, 0, 0 };
    int err = 0;
    switch (spca50x->sensor) {
    case SENSOR_HV7131R:
	err += sn9c102p_i2cread(spca50x, 0x25, expo, 5);	//read sensor exposure
	return (unsigned int) (expo[0] << 16 | expo[1] << 8 | expo[2]);
	break;
    case SENSOR_MI0360:
	err += sn9c102p_i2cread(spca50x, 0x09, expo, 5);	//read sensor exposure
	return (unsigned int) (expo[0] << 8 | expo[1]);
	break;
    }
    return 0;
}

static unsigned int sn9cxxx_setexposure(struct usb_spca50x *spca50x,
					unsigned int expo)
{
    __u8 Expodoit[] = { 0xc1, 0x11, 0x25, 0x07, 0x27, 0xc0, 0x00, 0x16 };
    __u8 doit[] = { 0xB1, 0x5D, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };	//update sensor
    __u8 sensorgo[] = { 0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };	//sensor on
    __u8 expoMi[] = { 0xB1, 0x5D, 0x09, 0x06, 0x35, 0x00, 0x00, 0x10 };	// exposure 0x0635 -> 4 fp/s
    unsigned int expotimes = expo;
    unsigned int expotimesret = 0;
    switch (spca50x->sensor) {
    case SENSOR_HV7131R:
	Expodoit[3] = (expotimes >> 16) & 0xff;
	Expodoit[4] = (expotimes >> 8) & 0xff;
	Expodoit[5] = (expotimes & 0xff);
	sn9c102p_i2cwritebuf(spca50x->dev, Expodoit);
	wait_ms(10);
	expotimesret = sn9cxxx_getexposure(spca50x);
	PDEBUG(3, "Exposure set %d ret %d ", expotimes, expotimesret);
	return expotimesret;
	break;
    case SENSOR_MI0360:
	if (expo > 0x0635)
	    expo = 0x0635;
	//if (expo < 0x0100)
	//   expo = 0x0100;
	if (expo < 0x003F)
	    expo = 0x003F;
	expoMi[3] = (expo >> 8) & 0xFF;
	expoMi[4] = expo & 0xff;
	sn9c102p_i2cwritebuf(spca50x->dev, expoMi);
	sn9c102p_i2cwritebuf(spca50x->dev, doit);
	sn9c102p_i2cwritebuf(spca50x->dev, sensorgo);
	expotimesret = sn9cxxx_getexposure(spca50x);
	PDEBUG(3, "Exposure set %d ret %d ", expotimes, expotimesret);
	return expotimesret;
	break;
    }
    return 0;
}

static __u16 sn9cxxx_setbrightness(struct usb_spca50x *spca50x)
{
    unsigned int expo, expotimesret;
    __u8 k2;
    switch (spca50x->sensor) {
    case SENSOR_HV7131R:
	expo = spca50x->brightness << 4;
	if (expo > 0x002dc6c0)
	    expo = 0x002dc6c0;
	if (expo < 0x02a0)
	    expo = 0x02a0;
	expotimesret = sn9cxxx_setexposure(spca50x, expo);

	break;
    case SENSOR_MI0360:
	expo = spca50x->brightness >> 4;
	expotimesret = sn9cxxx_setexposure(spca50x, expo);

	break;
    }
    k2 = spca50x->brightness >> 10;
    sonixRegWrite(spca50x->dev, 0x08, 0x96, 0x0000, &k2, 1);
    return 0;
}

static __u16 sn9cxxx_getbrightness(struct usb_spca50x *spca50x)
{
    /* hardcoded registers seem not readable */
     switch (spca50x->sensor) {
    case SENSOR_HV7131R:
    spca50x->brightness = 0x7fff;
    	break;
    case SENSOR_MI0360:
    spca50x->brightness = 0x1fff;
    break;
    }
    return 0;
}

static __u16 sn9cxxx_setcontrast(struct usb_spca50x *spca50x)
{
    __u8 k2;
    __u8 contrast[] = { 0x14, 0x00, 0x28, 0x00, 0x07, 0x00 };
    k2 = spca50x->contrast >> 8;
    if (k2 > 0x7f)
	k2 = 0x7f;
    contrast[2] = k2;
    contrast[0] = (k2 + 1) >> 1;
    contrast[4] = (k2 + 1) / 5;
    sonixRegWrite(spca50x->dev, 0x08, 0x84, 0x0000, contrast, 6);

    return 0;
}
static __u16 sn9cxxx_getcontrast(struct usb_spca50x *spca50x)
{
    /* hardcoded registers seem not readable */
    spca50x->contrast = 0x3f << 8; //0x28
    return 0;
}

#if 0
static void sn9cxxx_setAutobright(struct usb_spca50x *spca50x)
{				// GRR avg_lum from the header seem wrong set exposure on brightness instead
    // FIXME where is the avg luma value ??        
    unsigned int expotimes = 0;
    unsigned int expotimesret = 0;

    __u8 luma_mean = 110;
    __u8 luma_delta = 20;
    __u8 spring = 4;		// 4 choice so the gain registers follow with a little retard
    int delta;
    spin_lock_irq(&spca50x->v4l_lock);
    delta = spca50x->avg_lum;
    spin_unlock_irq(&spca50x->v4l_lock);
    //PDEBUG(0,"Error setting exposure delta %d",delta);

    if ((delta < (luma_mean - luma_delta)) ||
	(delta > (luma_mean + luma_delta))) {
	expotimes = sn9cxxx_getexposure(spca50x);
	expotimes += ((luma_mean - delta) >> spring);
	expotimesret = sn9cxxx_setexposure(spca50x, expotimes);
	if (expotimes != expotimesret)
	    PDEBUG(0, "Error setting exposure !");
    }

}

static void sn9cxxx_shutdown(struct usb_spca50x *spca50x)
{

}

#endif
#endif				//SONIXJPGUSB