image_sensor.c

iv100b 驱动。。。 MTK6226的原始代码

    write_cmos_sensor(0x7A, 0x90);
    write_cmos_sensor(0x7B, 0xB0);
    write_cmos_sensor(0x7C, 0x80);
}   /* SIV100B_Write_Sensor_Initial_Setting */

/*************************************************************************
* FUNCTION
*   SIV100B_Init
*
* DESCRIPTION
*   This function initialize the registers of CMOS sensor and ISP control register.
*
* PARAMETERS
*   None
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_int8 SIV100B_Init(void)
{
    kal_uint8 iI;

    // set sensors chip enable pin to low to activate SIV100B
    REG_ISP_CMOS_SENSOR_MODE_CONFIG &= ~REG_CMOS_SENSOR_POWER_ON_BIT;
    set_isp_driving_current(camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para);

    // SIV100B's maximum MCLK is 24MHz
    ENABLE_CAMERA_TG_CLK_48M;
    ENABLE_CAMERA_PIXEL_CLKIN_ENABLE
    UPLL_Enable(UPLL_OWNER_ISP);

    cis_module_power_on(KAL_TRUE);  // power on CMOS sensor
    kal_sleep_task(2);  // delay for stable power

    /************************************************************************************
    *   To reset sensor, SIV100B requires to hold RESET pin low for at least 64 MCLKs   *
    *   The following formulates the RESET waveform                                     *
    ************************************************************************************/
    RESET_PIN_HIGH;
    RESET_PIN_LOW;
    for (iI = 0; iI < 0x40; iI++);
    RESET_PIN_HIGH;
    kal_sleep_task(2);  // delay for stable sensor

    /************************************************
    *   Setup sensor's sync signal output polarity  *
    ************************************************/
    SET_CMOS_CLOCK_POLARITY_LOW;
    SET_VSYNC_POLARITY_LOW; // valid line data in VSYNC low period
    SET_HSYNC_POLARITY_LOW; // valid pixel data in HSYNC high period
    ENABLE_CAMERA_INDATA_FORMAT;
    SET_CAMERA_INPUT_TYPE(INPUT_YUV422);

    // check sensor's device information
    if (read_cmos_sensor(0x01) != SIV100B_SENSOR_ID ||
        read_cmos_sensor(0x02) != SIV100B_SENSOR_VERSION) {
        return -1;
    }

    SIV100B_Write_Sensor_Initial_Setting();
//    camera_para_to_sensor();

    return 1;
}   /* SIV100B_Init() */

/*************************************************************************
* FUNCTION
*   ConfigVBlank
*
* DESCRIPTION
*   This function is to set VBlank size.
*
* PARAMETERS
*   iBlank: target VBlank size
*      iHz: banding frequency
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void ConfigVBlank(const kal_uint16 iBlank, const kal_uint8 iHz)
{
    /********************************************
    *   50Hz-relative registers can not be used *
    ********************************************/
    const kal_uint16 iVal2Write = iBlank - 1;

    ASSERT(iBlank < (1 << 10));

    switch (iHz) {
    case CAM_BANDING_50HZ:
    case CAM_BANDING_60HZ:
        write_cmos_sensor(0x20, (read_cmos_sensor(0x20) & 0xFC) | ((iVal2Write & 0x0300) >> 8));
        write_cmos_sensor(0x22, iVal2Write & 0x00FF);
        break;

//    case CAM_BANDING_50HZ:
        // SIV100B cannot use all blank size registers of 50Hz
//        write_cmos_sensor(0x23, (read_cmos_sensor(0x23) & 0xFC) | ((iVal2Write & 0x0300) >> 8));
//        write_cmos_sensor(0x25, iVal2Write & 0x00FF);
    }
}   /* ConfigVBlank */

/*************************************************************************
* FUNCTION
*   ConfigHBlank
*
* DESCRIPTION
*   This function is to set HBlank size.
*
* PARAMETERS
*   iBlank: target HBlank size
*      iHz: banding frequency
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void ConfigHBlank(const kal_uint16 iBlank, const kal_uint8 iHz)
{
    /********************************************
    *   50Hz-relative registers can not be used *
    ********************************************/
    const kal_uint16 iVal2Write = iBlank - 1;

    ASSERT(iBlank < (1 << 10));

    switch (iHz) {
    case CAM_BANDING_50HZ:
    case CAM_BANDING_60HZ:
        write_cmos_sensor(0x20, (read_cmos_sensor(0x20) & 0xCF) | ((iVal2Write & 0x0300) >> 4));
        write_cmos_sensor(0x21, iVal2Write & 0x00FF);
        break;

//    case CAM_BANDING_50HZ:
        // SIV100B cannot use all blank size registers of 50Hz
//        write_cmos_sensor(0x23, (read_cmos_sensor(0x23) & 0xCF) | ((iVal2Write & 0x0300) >> 4));
//        write_cmos_sensor(0x24, iVal2Write & 0x00FF);
    }
}   /* ConfigHBlank */

/*************************************************************************
* FUNCTION
*   SIV100B_PowerOff
*
* DESCRIPTION
*   This function is to turn off sensor module power.
*
* PARAMETERS
*   None
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_PowerOff(void)
{
    cis_module_power_on(KAL_FALSE); // power off sensor

    SET_SCCB_CLK_LOW;
    SET_SCCB_DATA_LOW;

    UPLL_Disable(UPLL_OWNER_ISP);
}   /* SIV100B_PowerOff */

/*************************************************************************
* FUNCTION
*   SIV100B_Get_I2C_ID
*
* DESCRIPTION
*   This function return the sensor read/write IDs of I2C I/F.
*
* PARAMETERS
*   *pI2C_WriteID : address pointer of sensor's I2C write id
*   *pI2C_ReadID  : address pointer of sensor's I2C read id
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_Get_I2C_ID(kal_uint8 *pI2C_WriteID, kal_uint8 *pI2C_ReadID)
{
    *pI2C_WriteID = SIV100B_I2C_WRITE_ID;
    *pI2C_ReadID = SIV100B_I2C_READ_ID;
}   /* SIV100B_Get_I2C_ID */

/*************************************************************************
* FUNCTION
*   SIV100B_GetSize
*
* DESCRIPTION
*   This function return the image width and height of image sensor.
*
* PARAMETERS
*   *pWidth : address pointer of horizontal effective pixels of image sensor
*  *pHeight : address pointer of vertical effective lines of image sensor
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_GetSize(kal_uint16 *pWidth, kal_uint16 *pHeight)
{
    *pWidth = IMAGE_SENSOR_VGA_WIDTH;   // valid pixel # in one frame
    *pHeight = IMAGE_SENSOR_VGA_HEIGHT; // valid line # in one frame
}   /* SIV100B_GetSize */

/*************************************************************************
* FUNCTION
*   SIV100B_GetPeriod
*
* DESCRIPTION
*   This function return the image width and height of image sensor.
*
* PARAMETERS
*   *pPixelNumber : address pointer of pixel numbers in one period of HSYNC
*   *pLineNumber : address pointer of line numbers in one period of VSYNC
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_GetPeriod(kal_uint16 *pPixelNumber, kal_uint16 *pLineNumber)
{
    /************************************
    *   No need for YUV sensor driver   *
    ************************************/
//    *pPixelNumber = VGA_PERIOD_PIXEL_NUMS;  // pixel numbers in one period of HSYNC
//    *pLineNumber = VGA_PERIOD_LINE_NUMS;    // line numbers in one period of VSYNC
}   /* SIV100B_GetPeriod */

/*************************************************************************
* FUNCTION
*	SIV100B_Preview
*
* DESCRIPTION
*	This function configure the sensor to preview mode.
*
* PARAMETERS
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_Preview(image_sensor_exposure_window_struct *pImage_Window, image_sensor_config_struct *pSensor_Config_Data)
{
    kal_uint8 iHV_Mirror = 0;
    kal_uint8 iStartX = 0, iStartY = 1;
    kal_uint8 iTemp = 0;
    volatile kal_uint16 iRetry;
    static kal_uint16 iBound = 0x00FF;

    write_cmos_sensor(0x40, 0x80);  // enable *NORMAL* AE
    write_cmos_sensor(0x60, 0xC8);  // enable AWB
    
    if (pSensor_Config_Data->frame_rate == 0x0F) {  // MPEG4 Encode Mode
        g_bVideoMode = KAL_TRUE;

        // config TG for video recorder mode
        SET_TG_OUTPUT_CLK_DIVIDER(3);   // MCLK = 12MHz
        SET_CMOS_RISING_EDGE(0);
        SET_CMOS_FALLING_EDGE(2);
        SET_TG_PIXEL_CLK_DIVIDER(3);
        SET_CMOS_DATA_LATCH(2);
    }else {
        g_bVideoMode = KAL_FALSE;
        g_bCaptureMode = KAL_FALSE;

        iTemp = read_cmos_sensor(0x04) & 0xF3;
        write_cmos_sensor(0x04, iTemp | 0x00);  // set CLK divider to 1/2
        // config TG for camera preview mode
        SET_TG_OUTPUT_CLK_DIVIDER(1);
        SET_CMOS_RISING_EDGE(0);
        SET_CMOS_FALLING_EDGE(1);
        SET_TG_PIXEL_CLK_DIVIDER(1);
        SET_CMOS_DATA_LATCH(1);
    }

    iHV_Mirror = read_cmos_sensor(0x04) & 0xFC;
    switch (pSensor_Config_Data->image_mirror) {
    case IMAGE_NORMAL:
        iHV_Mirror |= 0x00;
        if (g_bVideoMode == KAL_TRUE) {
            SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CbYCrY1);
            iStartX = 0;
            iStartY = 1;
        }else {
            SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CbYCrY1);
            iStartX = 0;
            iStartY = 1;
        }
        break;

    case IMAGE_HV_MIRROR:
        iHV_Mirror |= 0x03;
        if (g_bVideoMode == KAL_TRUE) {
            SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CbYCrY1);
            iStartX = 0;
            iStartY = 1;
        }else {
            SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CbYCrY1);
            iStartX = 0;
            iStartY = 1;
        }
        break;

    default:
        ASSERT(0);
    }
    write_cmos_sensor(0x04, iHV_Mirror);

    pImage_Window->grab_start_x = iStartX;
    pImage_Window->grab_start_y = iStartY;
    pImage_Window->exposure_window_width = IMAGE_SENSOR_VGA_WIDTH - iStartX;
    pImage_Window->exposure_window_height = IMAGE_SENSOR_VGA_HEIGHT - iStartY;

    for (iRetry = 0; iRetry < iBound; iRetry++) {
        /********************************
        *   0x7F[0] = 1 when AE stable  *
        ********************************/
        if ((read_cmos_sensor(0x7F) & 0x01) != 0) {
            break;
        }
    }
}   /* SIV100B_Preview */

/*************************************************************************
* FUNCTION
*   SID201A_Capture
*
* DESCRIPTION
*   This function configures the sensor to capture mode.
*
* PARAMETERS
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void SIV100B_Capture(image_sensor_exposure_window_struct *pImage_Window, image_sensor_config_struct *pSensor_Config_Data)
{
    kal_uint8 iStartX = 0, iStartY = 1, iTemp;
    kal_uint32 iExp;

	kal_prompt_trace(MOD_CC,"SIV100B_Capture==1===%s","  start  ");
    g_bCaptureMode = KAL_TRUE;

    if (pSensor_Config_Data->frame_rate == 0xF0) {
        /************************************
        *   Webcam mode, AE/AWB still on    *
        ************************************/
        ConfigVBlank(WEBCAM_MODE_VBLANK, CAM_BANDING_50HZ);
        ConfigHBlank(WEBCAM_MODE_HBLANK, CAM_BANDING_50HZ);
    }else {
        /********************************
        *   Normal camera capture mode  *
        ********************************/
        write_cmos_sensor(0x40, 0x00);  // disable AE
        write_cmos_sensor(0x60, 0x00);  // disable AWB
        
        if (pImage_Window->image_target_width <= IMAGE_SENSOR_VGA_WIDTH &&
            pImage_Window->image_target_height <= IMAGE_SENSOR_VGA_HEIGHT) {
            /********************************************************
            *   This part captures image size equal to or under VGA *
            ********************************************************/
            if (pImage_Window->digital_zoom_factor >= (ISP_DIGITAL_ZOOM_INTERVAL << 1)) {
                iTemp = read_cmos_sensor(0x04) & 0xF3;
                write_cmos_sensor(0x04, iTemp | 0x04);  // set CLK divider = 1/4
                SET_TG_PIXEL_CLK_DIVIDER(3);
                SET_CMOS_DATA_LATCH(2);

                iExp = (read_cmos_sensor(0x30) << 8) | read_cmos_sensor(0x31);
                 if (iExp == 1) {
                    iTemp >>= 1;
                    write_cmos_sensor(0x30, 0x00);
                    write_cmos_sensor(0x31, 0x01);
                }else {
                    iExp = (((iExp << 3) + iTemp) >> 1);
                    write_cmos_sensor(0x30, (iExp >> 11) & 0x00FF);
                    write_cmos_sensor(0x31, (iExp >> 3) & 0x00FF);
                }
            }
        }
		else if (pImage_Window->image_target_width > IMAGE_SENSOR_VGA_WIDTH &&
                  pImage_Window->image_target_height > IMAGE_SENSOR_VGA_HEIGHT) {
            /********************************************
            *   This part captures image size over VGA  *
            ********************************************/
            iTemp = read_cmos_sensor(0x04) & 0xF3;
            write_cmos_sensor(0x04, iTemp | 0x0C);  // set CLK divider = 1/16 

            SET_TG_PIXEL_CLK_DIVIDER(15);
            SET_CMOS_DATA_LATCH(8);
 
            iExp = (read_cmos_sensor(0x30) << 8) | read_cmos_sensor(0x31);
            iExp += 4;  // round

            write_cmos_sensor(0x03, 0x00); 		//Brad.Oh 070914
            
            if (pImage_Window->digital_zoom_factor >= (ISP_DIGITAL_ZOOM_INTERVAL << 1)) {
                /********************************************************
                *   Capture SXGA resolution with zoom factor over 2x    *
                ********************************************************/
                ConfigHBlank(CP_1M_MODE_ZOOM_HBLANK, CAM_BANDING_50HZ);
                if (g_bNightMode == KAL_TRUE) {
                    if (g_iBanding == CAM_BANDING_50HZ) {
                        iExp = iExp * (PV_MODE_HVP_PERIOD + PV_MODE_HBLANK_50HZ_NIGHT) / (PV_MODE_HVP_PERIOD + CP_1M_MODE_ZOOM_HBLANK);
                    }else {
                        iExp = iExp * (PV_MODE_HVP_PERIOD + PV_MODE_HBLANK_60HZ_NIGHT) / (PV_MODE_HVP_PERIOD + CP_1M_MODE_ZOOM_HBLANK);
                    }
                }else {
                    if (g_iBanding == CAM_BANDING_50HZ) {
                        iExp = iExp * (PV_MODE_HVP_PERIOD + PV_MODE_HBLANK_50HZ_NORMAL) / (PV_MODE_HVP_PERIOD + CP_1M_MODE_ZOOM_HBLANK);
                    }else {
                        iExp = iExp * (PV_MODE_HVP_PERIOD + PV_MODE_HBLANK_60HZ_NORMAL) / (PV_MODE_HVP_PERIOD + CP_1M_MODE_ZOOM_HBLANK);