zc030x_cameras.c

中星微301摄想头最新驱动

    zc030x_reg_read(udev, ZR(Sharpness01), value[1], 1);
    zc030x_reg_read(udev, ZR(Sharpness02), value[2], 1);
    zc030x_reg_read(udev, ZR(Sharpness03), value[3], 1);
    zc030x_reg_read(udev, ZR(Sharpness04), value[4], 1);
    zc030x_reg_write(udev, ZR(Sharpness05), value[5]);
    
    /* Return */
    return 0;
}

/* Send the gamma sequence */
int zc030x_send_gamma(struct usb_device *udev, const __u16 brightness, const __u16 contrast, const __u16 gamma)
{
    /* Iterator */
    int i = 0;
    /* Need to convert the value to emulated floating points */
    const FPNum dBrightness = CreateFPNumFromInt(((int)brightness - 32768));
    const FPNum dContrast = CreateFPNumFromInt(((int)contrast - 32768));
    const FPNum dGamma = CreateFPNumFromInt((int)gamma);
    FPNum OneOutOf256;
    FPNum OneOutOf32768;
    
    /* Init the FP Numbers */
    InitFPNum(&OneOutOf256, "0.00390625");
    InitFPNum(&OneOutOf32768, "0.000030517578125");

    /* Gamma matrix */
    {
        const __u8  * Gamma = zc030x_gamma_create_FPNum(Mul(dGamma, OneOutOf256), Mul(dBrightness, OneOutOf32768), Mul(dContrast, OneOutOf32768));
        PDEBUG(4, "Gamma matrix [%02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X]", Gamma[0x00], Gamma[0x01], Gamma[0x02], Gamma[0x03], Gamma[0x04], Gamma[0x05], Gamma[0x06], Gamma[0x07], Gamma[0x08], Gamma[0x09], Gamma[0x0a], Gamma[0x0b], Gamma[0x0c], Gamma[0x0d], Gamma[0x0e], Gamma[0x0f]);
        PDEBUG(4, "Gamma Slope matrix [%02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X]", Gamma[0x10], Gamma[0x11], Gamma[0x12], Gamma[0x13], Gamma[0x14], Gamma[0x15], Gamma[0x16], Gamma[0x17], Gamma[0x18], Gamma[0x19], Gamma[0x1a], Gamma[0x1b], Gamma[0x1c], Gamma[0x1d], Gamma[0x1e], Gamma[0x1f]);
    
        /* Check arguments */
        if (udev == NULL || Gamma == NULL)
        {
            PDEBUG(1, "udev or gamma is null");
            return -1;
        }
        
        /* Send the gamma sequence */
        for (; i < 32; i++)
            zc030x_reg_write(udev, ZR(Gamma00) + i, Gamma[i]);
    }
    /* Return */
    return 0;
}

/* Send the RGB to RGB conversion matrix */
int zc030x_send_RGBmatrix(struct usb_device *udev, __u8 matrix[3][4])
{

    /* Check arguments */
    if (udev == NULL)
    {
        PDEBUG(1, "udev is null");
        return -1;
    }
    
    /* Send the sharpness sequence */
    zc030x_reg_write(udev, ZR(RGB00), matrix[0][0]);
    zc030x_reg_write(udev, ZR(RGB01), matrix[0][1]);
    zc030x_reg_write(udev, ZR(RGB02), matrix[0][2]);
    zc030x_reg_write(udev, ZR(RGB03), matrix[0][3]);
    zc030x_reg_write(udev, ZR(RGB10), matrix[1][0]);
    zc030x_reg_write(udev, ZR(RGB11), matrix[1][1]);
    zc030x_reg_write(udev, ZR(RGB12), matrix[1][2]);
    zc030x_reg_write(udev, ZR(RGB13), matrix[1][3]);
    zc030x_reg_write(udev, ZR(RGB20), matrix[2][0]);
    zc030x_reg_write(udev, ZR(RGB21), matrix[2][1]);
    zc030x_reg_write(udev, ZR(RGB22), matrix[2][2]);
    zc030x_reg_write(udev, ZR(RGB23), matrix[2][3]);
    
    /* Return */
    return 0;
}

/* Configure the camera */
int zc030x_configure_camera(struct usb_zc030x * dev, int width, int height, int quality)
{
    /* Iterator */
//    int i = 0;
    
    /* Debug this */
    PDEBUG(1, ">>> CONFCAM %dx%d:%d", width, height, quality);

    /* Allocate buffers */
    if (zc030x_allocate_buffers(dev) < 0)
    {
        PDEBUG(1, "Failed while allocating the buffers!");
        return -1;
    }
    
    /* Reset the camera */
    if (zc030x_reg_reset(dev->udev) != REG_OK)
    {
        PDEBUG(1, "Failed while resetting the camera!");
        return -1;
    }
    
    /* Send the I2C start sequence */
    zc030x_i2c_start(dev->udev, CamList[dev->type_id].pI2CInitSeq, dev->sensor_addr);
    
    /* Change the interface */
    usb_set_interface (dev->udev, 0, 6);

    /* Change the debug level */
    if (debug == 5) debug = 6;
    
    /* Reset the camera */
    zc030x_reg_write(dev->udev, ZR(SystemControl), ZV(Reset));
    /* Resend the sensor address after a reset */
    zc030x_reg_write(dev->udev, ZR(CMOSSensorSelect), dev->sensor_addr);
    /* Start operating */
    zc030x_reg_write(dev->udev, ZR(SystemOperating), ZV(Start));

    /* Reset the internal stuff */
    zc030x_reg_write(dev->udev, ZR(VideoControlFunc), SensorSizeList[dev->sensor_id].Enable | ZV(ResetSensor)|ZV(SensorTurnOn));
    zc030x_reg_write(dev->udev, ZR(VideoControlFunc), SensorSizeList[dev->sensor_id].Enable | ZV(SensorTurnOn));

    PDEBUG(1, "Please report this to the list [101=%02X, %s-VID%04X:PID%04X:SID-%s]", zc030x_reg_read(dev->udev, ZR(SensorCorrection), 1, 1), CamList[dev->type_id].Name, dev->udev->descriptor.idVendor, dev->udev->descriptor.idProduct, SensList[dev->sensor_id].Name);
    

    /* Set the window size */
    switch(SensList[dev->sensor_id].pSignature->sensor_id)
    {
        case TAS5130C:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, ZV(DoubleClock)) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode) , ZV(TASxxxxC)|ZV(Round9To8Bit));
            zc030x_reg_write(dev->udev, ZR(WinYStartHigh), ZV(HalfscalY_Default));
            if (currentheight < SensorSizeList[dev->sensor_id].Height)
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(HalfscalY_TASCVGA));
            else
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(FullscalY_TASCVGA));
                
            zc030x_reg_write(dev->udev, ZR(WinXStartHigh), ZV(HalfscalX_Default));
            if (currentwidth < SensorSizeList[dev->sensor_id].Width)
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(HalfscalX_TASCVGA));
            else
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(FullscalX_TASCVGA));
        break;
        case TAS5110B:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, ZV(DoubleClock)) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode) , ZV(TASxxxxC)|ZV(Round9To8Bit));
            zc030x_reg_write(dev->udev, ZR(WinYStartHigh), ZV(HalfscalY_Default));
            if (currentheight < SensorSizeList[dev->sensor_id].Height)
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(HalfscalY_TASCCIF));
            else
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(FullscalY_TASCCIF));
                
            zc030x_reg_write(dev->udev, ZR(WinXStartHigh), ZV(HalfscalX_Default));
            if (currentwidth < SensorSizeList[dev->sensor_id].Width)
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(HalfscalX_TASCCIF));
            else
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(FullscalX_TASCCIF));
        break;
            
        case ICM105A:
        case ICM102A:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, 0) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode), 0);
            zc030x_reg_write(dev->udev, ZR(WinYStartHigh), ZV(HalfscalY_Default));
            if (currentheight < SensorSizeList[dev->sensor_id].Height)
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(HalfscalY_ICM));
            else
                zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(FullscalY_ICM));
                
            zc030x_reg_write(dev->udev, ZR(WinXStartHigh), ZV(HalfscalX_Default));
            if (currentwidth < SensorSizeList[dev->sensor_id].Width)
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(HalfscalX_ICM));
            else
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(FullscalX_ICM));
        break;
        case OV7620:
        case OVCIF:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, 0) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode), ZV(OVSensor));
        break;
        case PAS202B:
        case PAS106B:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, width < SensorSizeList[dev->sensor_id].Width / 2 ? ZV(PCLCK_750Khz) : 0) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode), ZV(OVSensor));
            zc030x_reg_write(dev->udev, ZR(WinYStartHigh), ZV(HalfscalY_Default));
            zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(HalfscalY_Default));
            zc030x_reg_write(dev->udev, ZR(WinXStartHigh), ZV(HalfscalX_Default));
            if (currentwidth < SensorSizeList[dev->sensor_id].Width)
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(HalfscalX_PAS));
            else
                zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(FullscalX_PAS));
        break;
        case HDCS2020:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, width < SensorSizeList[dev->sensor_id].Width / 2 ? ZV(PCLCK_3Mhz) : 0) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            /* Sensor parameters */
            if (currentwidth >= SensorSizeList[dev->sensor_id].Width)
                zc030x_reg_write(dev->udev, ZR(SensorCorrection), SensorSizeList[dev->sensor_id].FirstPixel | ZV(FirstLineIsGBGBG));
                
        case HV7131B:
        default:
            /* Set the size */
            if (zc030x_reg_setsize(dev, width, height, 0) != REG_OK)
            {
                PDEBUG(1, "Failed while setting the size!");
                return -1;
            }
            zc030x_reg_write(dev->udev, ZR(CompabilityMode), 0);
            zc030x_reg_write(dev->udev, ZR(WinYStartHigh), ZV(HalfscalY_Default));
            zc030x_reg_write(dev->udev, ZR(WinYStartLow), ZV(HalfscalY_Default));
            zc030x_reg_write(dev->udev, ZR(WinXStartHigh), ZV(HalfscalX_Default));
            zc030x_reg_write(dev->udev, ZR(WinXStartLow), ZV(HalfscalX_Default));
        break;
    }
    
    /* Set the window size */
    switch(SensList[dev->sensor_id].pSignature->sensor_id)
    {
        case HDCS2020:
        case TAS5130C:
        case TAS5110B:
        if (currentheight < SensorSizeList[dev->sensor_id].Height)
        {
            zc030x_reg_write(dev->udev, ZR(MaxXHigh), 0x03);
            zc030x_reg_write(dev->udev, ZR(MaxXLow), 0xc0);
            zc030x_reg_write(dev->udev, ZR(ExposureTimeHigh), 0x01);
            zc030x_reg_write(dev->udev, ZR(ExposureTimeLow), 0x77);
            zc030x_reg_write(dev->udev, ZR(ExposureGain), 0x01);
        }
        else
        {
            zc030x_reg_write(dev->udev, ZR(MaxXHigh), ZV(XMaxHighDefault));
            zc030x_reg_write(dev->udev, ZR(MaxXLow), ZV(XMaxLowVGADefault));
            zc030x_reg_write(dev->udev, ZR(ExposureTimeHigh), ZV(DefExpTimeVGAHigh));
            zc030x_reg_write(dev->udev, ZR(ExposureTimeLow), ZV(DefExpTimeVGALow));
            zc030x_reg_write(dev->udev, ZR(ExposureGain), ZV(DefExpGainVGA));
        }    
        zc030x_reg_write(dev->udev, ZR(ExposureBlackLvl), 0x3c);
        break;
        default:
        break;
    }
    
    /* Set the automatic features */
    zc030x_reg_write(dev->udev, ZR(OperationMode), ZV(DigitalColorGain)|ZV(YGammaGain)|ZV(DigitalGlobalGain));

    /* Auto white balance */
    WriteDefaultValue(dev->udev, AWBStatus);
    /* Sharpness */
    zc030x_reg_write(dev->udev, ZR(SharpnessMode), ZV(UseAvgValue)|ZV(EnableSharpening));
    
    /* Write the Zc030x I2C registers */
    zc030x_i2c_writeconfig(dev->udev, SensConfList[dev->sensor_id]);

    /* Dead pixels */
    zc030x_reg_write(dev->udev, ZR(DeadPixelsMode), ZV(RemoveDeadPixels));
    zc030x_reg_write(dev->udev, ZR(EEPROMAccess), ZV(BatchReadControl));

    /* Enable autoexposure */
    zc030x_reg_write(dev->udev, ZR(AutoCorrectEnable), ZV(AutoWhiteBalance) | ZV(AutoColorGain) | ZV(AutoExpAntiFlick));
    /* Set the Auto exposure window */
    WriteDefaultValue(dev->udev, WinXStart);
    WriteDefaultValue(dev->udev, WinXWidth);
    WriteDefaultValue(dev->udev, WinXCenter);
    WriteDefaultValue(dev->udev, WinYStart);
    WriteDefaultValue(dev->udev, WinYWidth);
    WriteDefaultValue(dev->udev, WinYCenter);
    /* Control the AE */
    zc030x_reg_write(dev->udev, ZR(AEStatus), ZV(WinAndBlockWeight)|ZV(LargeCenterWindow));
    zc030x_reg_write(dev->udev, ZR(AEFreeze), MakeAELockRange(0x14));
    zc030x_reg_write(dev->udev, ZR(AEUnfreeze), MakeAELockRange(0x20));
    
    /* Sensor parameters */
    zc030x_reg_write(dev->udev, ZR(SensorCorrection), SensorSizeList[dev->sensor_id].FirstPixel);
    
    /* Reset the clock */
    zc030x_reg_write(dev->udev, ZR(ClockSetting), ZV(Rounding)|ZV(QuarterQuant));
    
    /* And send the sharpness informations */
    zc030x_send_sharpness(dev->udev, SharpnessControlSeq);
    
    /* Send the gamma sequence */
    zc030x_send_gamma(dev->udev, dev->Brightness, dev->Contrast, dev->Gamma);
    
    /* Send the RGB matrix sequence */
    zc030x_send_RGBmatrix(dev->udev, RGBMatrix);

    /* Set the gains */
    zc030x_reg_write(dev->udev, ZR(RGain), MakeGain(1,0));
    zc030x_reg_write(dev->udev, ZR(GGain), MakeGain(1,0));
    zc030x_reg_write(dev->udev, ZR(BGain), MakeGain(1,0));
    zc030x_reg_write(dev->udev, ZR(GlobalGain), MakeGain(1,0));
    
    zc030x_reg_write(dev->udev, ZR(DigitalGain), MakeDigitalGain(1,0));
    zc030x_reg_write(dev->udev, ZR(DigitalLimitDiff), MakeDigitalLimitDiff(0x0c));
    zc030x_reg_write(dev->udev, ZR(DigitalGainStep), MakeDigitalGainStep(2,4));

    
    /* Set the clocks now */
    zc030x_reg_write(dev->udev, ZR(Sync00Low) , 0x00);
    zc030x_reg_write(dev->udev, ZR(Sync00Mid) , 0x04);
    zc030x_reg_write(dev->udev, ZR(Sync00High), 0x20);
    zc030x_reg_write(dev->udev, ZR(Sync01Low) , 0x00);
    zc030x_reg_write(dev->udev, ZR(Sync01Mid) , 0x00);
    zc030x_reg_write(dev->udev, ZR(Sync01High), 0x84);
    
    
    /* The horizontal and vertical synchros */
    zc030x_reg_write(dev->udev, ZR(HSYNC_0) , 0xe3);
    zc030x_reg_write(dev->udev, ZR(HSYNC_1) , 0xec);
    zc030x_reg_write(dev->udev, ZR(HSYNC_2) , 0xf5);
    zc030x_reg_write(dev->udev, ZR(HSYNC_3) , 0xff);

    /* The PB0330 stuff */
    if (SensList[dev->sensor_id].pSignature->sensor_id == PB0330)
    {
        zc030x_reg_write(dev->udev, 0x1ad, 0x09);
        zc030x_reg_write(dev->udev, 0x1ae, 0x15);
        zc030x_reg_write(dev->udev, 0x1a9, 0x14);
        zc030x_reg_write(dev->udev, 0x197, 0x8a);
        zc030x_reg_write(dev->udev, 0x191, 0x07);
        zc030x_reg_write(dev->udev, 0x192, 0x8c);
    
        zc030x_reg_write(dev->udev, 0x101, 0x37);
        zc030x_reg_write(dev->udev, 0x11a, 0x00);
        zc030x_reg_write(dev->udev, 0x11c, 0x00);
        zc030x_reg_write(dev->udev, 0x11d, 0x60);
        zc030x_reg_write(dev->udev, 0x180, 0x42);
        zc030x_reg_write(dev->udev, 0x189, 0x06);
        zc030x_reg_write(dev->udev, 0x18c, 0x10);
        zc030x_reg_write(dev->udev, 0x18d, 0x6c);
        
        zc030x_reg_write(dev->udev, 0x019, 0x00);
        zc030x_reg_write(dev->udev, 0x087, 0x10);
        zc030x_reg_write(dev->udev, 0x08d, 0x08);
    }

    /* Mostly implemented yet */
    PDEBUG(1, "<<< CONFCAM");
    
    /* Reset the previous debug level */
    if (debug == 6) debug = 5;
    return 0;
}