/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*****************************************************************************
 *
 * Filename:
 * ---------
 *   image_sensor.c
 *
 * Project:
 * --------
 *   Maui_sw
 *
 * Description:
 * ------------
 *   Image sensor driver function
 *
 ****************************************************************************/
#include "drv_comm.h"
#include "IntrCtrl.h"
#include "reg_base.h"
#include "gpio_sw.h"
#include "sccb.h"
#include "isp_if.h"
#include "image_sensor.h"
#include "camera_para.h"
#include "upll_ctrl.h"
#include "med_api.h"


/* Global Valuable */
SensorInfo g_CCT_MainSensor = OV7660_OMNIVISION;

#if defined(SENSOR_ROTATE_0)
kal_uint8 g_CCT_FirstGrabColor = BAYER_R;
#else 
kal_uint8 g_CCT_FirstGrabColor = BAYER_Gb;
#endif 
kal_uint8 start_grab_x_offset = 0, start_grab_y_offset = 0;
kal_bool gVGAmode = KAL_TRUE, sensor_night_mode = KAL_FALSE, MPEG4_encode_mode = KAL_FALSE, g_bMJPEG_mode = KAL_FALSE;
kal_uint8 normal_gain = 0, night_gain = SENSOR_NIGHT_MODE_GAIN;
kal_uint8 preview_pclk_division = 0, capture_pclk_division = 0;
kal_uint16 dummy_pixels = 0, dummy_lines = 0, extra_exposure_lines = 0;
kal_uint16 exposure_lines = 0;
kal_uint16 sensor_global_gain = BASEGAIN, sensor_gain_base = 0x0;

/* Debug Message, Don't Care */
kal_uint16 sensor_frame_rate;

/* MAX/MIN Explosure Lines Used By AE Algorithm */
kal_uint16 MAX_EXPOSURE_LINES = (PIXEL_CLK / MIN_FRAME_RATE) / VGA_PERIOD_PIXEL_NUMS;
kal_uint8 MIN_EXPOSURE_LINES = 2;

/* Parameter For Engineer mode function */
kal_uint32 FAC_SENSOR_REG;

/* Image Sensor ID */
kal_uint16 sensor_id = 0;

kal_bool sensor_cap_state = KAL_FALSE;

#ifndef HW_SCCB


/*****************************************************************************
 * FUNCTION
 *  SCCB_send_byte
 * DESCRIPTION
 *  
 * PARAMETERS
 *  send_byte       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void SCCB_send_byte(kal_uint8 send_byte)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    volatile signed char i;
    volatile kal_uint32 j;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 7; i >= 0; i--)
    {   /* data bit 7~0 */
        if (send_byte & (1 << i))
        {
            SET_SCCB_DATA_HIGH;
        }
        else
        {
            SET_SCCB_DATA_LOW;
        }
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
        SET_SCCB_CLK_HIGH;
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
        SET_SCCB_CLK_LOW;
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
    }
    /* don't care bit, 9th bit */
    SET_SCCB_DATA_LOW;
    SET_SCCB_DATA_INPUT;
    SET_SCCB_CLK_HIGH;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SET_SCCB_CLK_LOW;
    SET_SCCB_DATA_OUTPUT;
}   /* SCCB_send_byte() */


/*****************************************************************************
 * FUNCTION
 *  SCCB_get_byte
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_uint8 SCCB_get_byte(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    volatile signed char i;
    volatile kal_uint32 j;
    kal_uint8 get_byte = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    SET_SCCB_DATA_INPUT;

    for (i = 7; i >= 0; i--)
    {   /* data bit 7~0 */
        SET_SCCB_CLK_HIGH;
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
        if (GET_SCCB_DATA_BIT)
            get_byte |= (1 << i);
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
        SET_SCCB_CLK_LOW;
        for (j = 0; j < SENSOR_I2C_DELAY; j++);
    }
    /* don't care bit, 9th bit */
    SET_SCCB_DATA_OUTPUT;
    SET_SCCB_DATA_HIGH;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SET_SCCB_CLK_HIGH;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SET_SCCB_CLK_LOW;

    return get_byte;
}   /* SCCB_get_byte() */

#endif /* HW_SCCB */ 


/*****************************************************************************
 * FUNCTION
 *  write_cmos_sensor
 * DESCRIPTION
 *  
 * PARAMETERS
 *  addr        [IN]        
 *  para        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void write_cmos_sensor(kal_uint32 addr, kal_uint32 para)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    volatile kal_uint32 j;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef HW_SCCB
    SET_SCCB_DATA_LENGTH(3);
    ENABLE_SCCB;
    REG_SCCB_DATA = OV76X0_WRITE_ID | SCCB_DATA_REG_ID_ADDRESS;
    REG_SCCB_DATA = addr;
    REG_SCCB_DATA = para;
    while (SCCB_IS_WRITTING)
    {
    };
#else /* HW_SCCB */ 
    I2C_START_TRANSMISSION;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(OV76X0_WRITE_ID);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(addr);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(para);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    I2C_STOP_TRANSMISSION;
#endif /* HW_SCCB */ 
}   /* write_cmos_sensor() */


/*****************************************************************************
 * FUNCTION
 *  read_cmos_sensor
 * DESCRIPTION
 *  
 * PARAMETERS
 *  addr        [IN]        
 * RETURNS
 *  
 *****************************************************************************/
kal_uint32 read_cmos_sensor(kal_uint32 addr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    volatile kal_uint32 j;
    kal_uint8 get_byte = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef HW_SCCB
    SET_SCCB_DATA_LENGTH(2);
    ENABLE_SCCB;
    REG_SCCB_DATA = OV76X0_WRITE_ID | SCCB_DATA_REG_ID_ADDRESS;
    REG_SCCB_DATA = addr;
    while (SCCB_IS_WRITTING)
    {
    };
    ENABLE_SCCB;
    REG_SCCB_DATA = OV76X0_READ_ID | SCCB_DATA_REG_ID_ADDRESS;
    REG_SCCB_DATA = 0;
    while (SCCB_IS_READING)
    {
    };
    get_byte = REG_SCCB_READ_DATA & 0xFF;
#else /* HW_SCCB */ 
    I2C_START_TRANSMISSION;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(OV76X0_WRITE_ID);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(addr);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    I2C_STOP_TRANSMISSION;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    I2C_START_TRANSMISSION;
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    SCCB_send_byte(OV76X0_READ_ID);
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    get_byte = SCCB_get_byte();
    for (j = 0; j < SENSOR_I2C_DELAY; j++);
    I2C_STOP_TRANSMISSION;
#endif /* HW_SCCB */ 

    return get_byte;
}   /* read_cmos_sensor() */


/*****************************************************************************
 * FUNCTION
 *  write_OV7680_shutter
 * DESCRIPTION
 *  
 * PARAMETERS
 *  shutter     [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void write_OV7680_shutter(kal_uint16 shutter)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    write_cmos_sensor(0x10, shutter & 0xFF);
    write_cmos_sensor(0x0f, shutter >> 8);
}   /* write_OV7680_shutter */


/*****************************************************************************
 * FUNCTION
 *  read_OV7680_shutter
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_uint16 read_OV7680_shutter(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    exposure_lines = (read_cmos_sensor(0x0f) << 8) | read_cmos_sensor(0x10);

    return exposure_lines;
}   /* read_OV7680_shutter */


/*****************************************************************************
 * FUNCTION
 *  write_OV7680_gain
 * DESCRIPTION
 *  
 * PARAMETERS
 *  gain        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void write_OV7680_gain(kal_uint16 gain)
{
}   /* write_OV7680_gain */


/*****************************************************************************
 * FUNCTION
 *  read_OV7680_gain
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
kal_uint16 read_OV7680_gain(void)
{
    return BASEGAIN;
}   /* read_OV7680_gain */


/*****************************************************************************
 * FUNCTION
 *  set_OV7680_dummy
 * DESCRIPTION
 *  
 * PARAMETERS
 *  pixels      [IN]        
 *  lines       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void set_OV7680_dummy(kal_uint16 pixels, kal_uint16 lines)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 temp;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    temp = read_cmos_sensor(0x2A);
    pixels += ((0xB0 & 0x70) << 4) | 0x0B;

    write_cmos_sensor(0x2B, pixels & 0xFF);
    write_cmos_sensor(0x2C, lines & 0xFF);
    write_cmos_sensor(0x2A, ((pixels >> 4) & 0x70) | ((lines >> 8) & 0x0F) | (temp & 0x80));
}   /* set_OV7680_dummy */

typedef struct
{
    kal_uint8 addr;
    kal_uint8 value;
}
sensor_reg;

sensor_reg OV7680_Init_Reg[103] = 
{
    {0x14, 0xc2},
    {0x63, 0x0b},
    {0x64, 0x01},
    {0x65, 0x0c},
    {0x12, 0x01},
    {0x0c, 0x06},
    {0x82, 0x9a},
    {0x22, 0x40},
    {0x23, 0x20},
    {0x31, 0x11},
    {0x40, 0x10},
    {0x4a, 0x42},
    {0x4b, 0x64},
    {0x67, 0x50},
    {0x6b, 0x00},
    {0x6c, 0x00},
    {0x6d, 0x00},
    {0x6e, 0x00},
    {0x42, 0x4a},
    {0x45, 0x40},
    {0x3f, 0x46},
    {0x48, 0x20},
    {0x65, 0x8c},
    {0x66, 0x02},
    {0x67, 0x5c},
    {0x12, 0x00},
    {0x0c, 0x16},
    {0x82, 0x9c},