mirror of https://github.com/OpenIPC/firmware.git
811 lines
19 KiB
C
811 lines
19 KiB
C
#include "xm_type.h"
|
||
#include "xm_comm_isp.h"
|
||
#include "xm_comm_sns.h"
|
||
#include "xm_sns_ctrl.h"
|
||
#include "mpi_isp.h"
|
||
#include "mpi_ae.h"
|
||
#include "mpi_awb.h"
|
||
#include "xm_awb_comm.h"
|
||
|
||
#include "xm_print.h"
|
||
#include "Camera.h"
|
||
|
||
|
||
#include "xm530_tmp.h"
|
||
#include "xm510_isp.h"
|
||
|
||
|
||
#include "extCfg.h"
|
||
extern XM_S32 SysActiveSizeGet(XM_U16 *pu16ImgW,XM_U16 *pu16ImgH);
|
||
extern XM_U8 gSnsDevAddr;
|
||
extern XM_U32 gSnsRegAddrByte;
|
||
extern XM_U32 gSnsRegDataByte;
|
||
extern XM_U16 gu16FullLines;
|
||
|
||
|
||
extern XM_U8 gu8MaxShutterOfst;
|
||
extern XM_U8 gu8Fps;
|
||
extern XM_U8 gAppEncoderinfo; // 0: AHD 1:CVI 2:TVI
|
||
extern XM_U32 gu32AGainNow;
|
||
extern XM_U32 gu32AGainMin;
|
||
extern XM_U32 gu32DGainNow;
|
||
extern XM_U32 gu32DGainMin;
|
||
extern XM_U8 gu8BlcDpcFlg;
|
||
|
||
void sensor_input_2(XM_U32 u32Addr,XM_U16 u16Num)
|
||
{
|
||
XM_U32 u32Tmp;
|
||
XM_U16 u16i;
|
||
const XM_U16 *pu16Data = NULL;
|
||
pu16Data=(const XM_U16 *)u32Addr;
|
||
for(u16i = 0; u16i<u16Num; u16i ++)
|
||
{
|
||
if( (u16Num>2) && (u16i < u16Num-2) &&
|
||
(*(pu16Data+u16i*2+0)== 0xF5) && (*(pu16Data+u16i*2+1) == 0xA5) &&
|
||
(*(pu16Data+(u16i+1)*2+0)== 0x5A) && (*(pu16Data+(u16i+1)*2+1) == 0x5F))
|
||
{
|
||
u16i += 2;
|
||
u32Tmp = *(pu16Data+u16i*2+0) & 0xFF;
|
||
u32Tmp = (u32Tmp << 8) | (*(pu16Data+u16i*2+1)&0xFF);
|
||
SysDelay_ms(u32Tmp);
|
||
|
||
//DEBUG("Sleepms:\n");
|
||
//PrintInt(8, u32Tmp); DBG("\r\n");
|
||
}
|
||
else
|
||
{
|
||
sensor_write_register((XM_U32)*(pu16Data+u16i*2+0),(XM_U32)*(pu16Data+u16i*2+1));
|
||
|
||
//PrintHex(8, (XM_U32)*(pu16Data+u16i*2+0)); DBG(" ");
|
||
//PrintHex(8, (XM_U32)*(pu16Data+u16i*2+1)); DBG("\r\n");
|
||
}
|
||
}
|
||
return ;
|
||
}
|
||
|
||
void sensor_input_1(XM_U32 u32Addr,XM_U16 u16Num)
|
||
{
|
||
XM_U32 u32Tmp;
|
||
XM_U16 u16i;
|
||
const XM_U8 *pu8Data = NULL;
|
||
pu8Data=(const XM_U8 *)u32Addr;
|
||
for(u16i = 0; u16i<u16Num; u16i ++)
|
||
{
|
||
if( (u16Num>2) && (u16i < u16Num-2) &&
|
||
(*(pu8Data+u16i*2+0)== 0xF5) && (*(pu8Data+u16i*2+1) == 0xA5) &&
|
||
(*(pu8Data+(u16i+1)*2+0)== 0x5A) && (*(pu8Data+(u16i+1)*2+1) == 0x5F))
|
||
{
|
||
u16i += 2;
|
||
u32Tmp = *(pu8Data+u16i*2+0) & 0xFF;
|
||
u32Tmp = (u32Tmp << 8) | (*(pu8Data+u16i*2+1)&0xFF);
|
||
SysDelay_ms(u32Tmp);
|
||
|
||
//DEBUG("Sleepms:\n");
|
||
//PrintInt(8, u32Tmp); DBG("\r\n");
|
||
}
|
||
else
|
||
{
|
||
sensor_write_register((XM_U32)*(pu8Data+u16i*2+0),(XM_U32)*(pu8Data+u16i*2+1));
|
||
|
||
//PrintHex(8, (XM_U32)*(pu8Data+u16i*2+0)); DBG(" ");
|
||
//PrintHex(8, (XM_U32)*(pu8Data+u16i*2+1)); DBG("\r\n");
|
||
}
|
||
}
|
||
return ;
|
||
}
|
||
|
||
|
||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD> д<><D0B4>Sensor
|
||
//u32Addr: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>ַ
|
||
//u16Num: <20>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
//u8Mode: 0:Read From E2 1:Read From RAM
|
||
int sensor_write_ex(XM_U8 u8Mode, XM_U32 u32Addr, XM_U16 u16Num)
|
||
{
|
||
XM_U16 au16RegAddr[2];
|
||
XM_U16 au16RegData[2];
|
||
XM_U16 u16i,u16Len;
|
||
XM_S32 (*pFun_cfgRead)(XM_U8 u8Bytes, XM_U32 u32Add,XM_U8 *pu8Data) = NULL;
|
||
if(u16Num > 0)
|
||
{
|
||
#ifdef DEBUG_ON
|
||
DEBUG("sensor_write_ex:\n");
|
||
#endif
|
||
pFun_cfgRead = ExtCfg_Read_V2;
|
||
u16Len = gSnsRegAddrByte+gSnsRegDataByte;
|
||
for(u16i = 0; u16i<u16Num; u16i ++)
|
||
{
|
||
au16RegAddr[0] = au16RegData[0] = 0;
|
||
au16RegAddr[1] = au16RegData[1] = 0;
|
||
(*pFun_cfgRead)(gSnsRegAddrByte, u32Addr, (XM_U8*)&au16RegAddr[0]); // Addr
|
||
(*pFun_cfgRead)(gSnsRegDataByte, u32Addr+gSnsRegAddrByte, (XM_U8*)&au16RegData[0]); // Data
|
||
(*pFun_cfgRead)(gSnsRegAddrByte, u32Addr+u16Len, (XM_U8*)&au16RegAddr[1]); // Addr
|
||
(*pFun_cfgRead)(gSnsRegDataByte, u32Addr+gSnsRegAddrByte+u16Len, (XM_U8*)&au16RegData[1]); // Data
|
||
if( (u16Num>2) && (u16i < u16Num-2) &&
|
||
(au16RegAddr[0]== 0xF5) && (au16RegData[0] == 0xA5) &&
|
||
(au16RegAddr[1]== 0x5A) && (au16RegData[1] == 0x5F))
|
||
{
|
||
u16i += 2;
|
||
au16RegAddr[0] = au16RegData[0] = 0;
|
||
u32Addr += (XM_U32)u16Len*2;
|
||
(*pFun_cfgRead)(gSnsRegAddrByte, u32Addr, (XM_U8*)&au16RegAddr[0]);
|
||
(*pFun_cfgRead)(gSnsRegDataByte, u32Addr+gSnsRegAddrByte, (XM_U8*)&au16RegData[0]);
|
||
|
||
au16RegAddr[0] = au16RegAddr[0] & 0xFF;
|
||
au16RegAddr[0] = (au16RegAddr[0] << 8) | (au16RegData[0]&0xFF);
|
||
SysDelay_ms((XM_U32)au16RegAddr[0]);
|
||
#ifdef DEBUG_ON
|
||
DBG("Sleepms:");
|
||
PrintInt(8, au16RegAddr[0]);
|
||
ENTER();
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
sensor_write_register((XM_U32)au16RegAddr[0],(XM_U32)au16RegData[0]);
|
||
#ifdef DEBUG_ON
|
||
PrintHex(8, au16RegAddr[0]); DBG(" ");
|
||
PrintHex(8, au16RegData[0]);
|
||
ENTER();
|
||
#endif
|
||
}
|
||
u32Addr += u16Len;
|
||
}
|
||
#ifdef DEBUG_ON
|
||
DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
|
||
#endif
|
||
}
|
||
return XM_SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
XM_S32 cmos_set_mirror_flip_ex(XM_U8 u8Mirror,XM_U8 u8Flip)
|
||
{
|
||
XM_U8 u8SnsRegNum,u8IspRegNum,u8Tmp,u8Mode = 0;
|
||
XM_U8 u8i;
|
||
XM_U16 u16Ofst = 0;
|
||
XM_U32 u32Addr,u32Tmp;
|
||
XM_U16 u16HOfst,u16VOfst;
|
||
u8SnsRegNum = 0;
|
||
u8IspRegNum = 0;
|
||
if(ExtCfg_BaseAddrGet(0xFF, ROM_FUN_MF, &u32Addr) != XM_SUCCESS)
|
||
return XM_FAILURE;
|
||
ExtCfg_Read_V2(1,u32Addr, &u8Mode);
|
||
ExtCfg_Read_V2(1,u32Addr+1, &u8SnsRegNum);
|
||
ExtCfg_Read_V2(1,u32Addr+2, &u8IspRegNum);
|
||
|
||
u32Tmp = (XM_U32)u8SnsRegNum*(gSnsRegAddrByte+gSnsRegDataByte)*4;
|
||
u32Tmp += (XM_U32)u8IspRegNum*8*4;
|
||
u32Tmp += (((u8Mode>>6)&0x01)+((u8Mode>>7)&0x01))*4; // cut
|
||
|
||
u32Addr += 3;
|
||
u8Tmp = 0;
|
||
if(gu8Fps==30)
|
||
{
|
||
u8Tmp = 1;
|
||
}
|
||
u8Tmp += gAppEncoderinfo*2;
|
||
for(u8i = 0; u8i < 6; u8i ++)
|
||
{
|
||
if(u8i == u8Tmp)
|
||
{
|
||
break;
|
||
}
|
||
if((1<<u8i) & u8Mode)
|
||
u32Addr += u32Tmp;
|
||
}
|
||
u16Ofst = 2*u8Flip+u8Mirror;
|
||
u8Mode = u8Mode>>6;
|
||
// IspCut
|
||
u16HOfst = 0xFFFF;
|
||
u16VOfst = 0xFFFF;
|
||
if(u8Mode > 0) // Need Cut
|
||
{
|
||
ExtCfg_Read_V2(1,u32Addr+u16Ofst, &u8Tmp);
|
||
switch(u8Mode)
|
||
{
|
||
// H
|
||
case 0x01: u16HOfst = u8Tmp;
|
||
u32Addr += 4;
|
||
break;
|
||
// V
|
||
case 0x02: u16VOfst = u8Tmp;
|
||
u32Addr += 4;
|
||
break;
|
||
// H & V
|
||
case 0x03: u16HOfst = u8Tmp;
|
||
ExtCfg_Read_V2(1,u32Addr+u16Ofst+4, &u8Tmp);
|
||
u16VOfst = u8Tmp;
|
||
u32Addr += 8;
|
||
break;
|
||
default:
|
||
#ifdef DEBUG_ON
|
||
ERR("cmos_set_mirror_flip_ex failed!\n");
|
||
#endif
|
||
break;
|
||
}
|
||
}
|
||
u32Tmp = (XM_U32)u16Ofst*u8SnsRegNum*(gSnsRegAddrByte+gSnsRegDataByte);
|
||
#ifdef DEBUG_ON
|
||
DEBUG("cmos_set_mirror_flip_ex:\n");
|
||
PrintInt(8, (XM_S32)gu8Fps);
|
||
PrintInt(8, (XM_S32)gAppEncoderinfo); ENTER();
|
||
PrintInt(8, (XM_S32)u8Mirror);
|
||
PrintInt(8, (XM_S32)u8Flip); ENTER();
|
||
PrintInt(8, (XM_S32)u16HOfst);
|
||
PrintInt(8, (XM_S32)u16VOfst); ENTER();
|
||
#endif
|
||
sensor_write_ex(1, u32Addr+u32Tmp, (XM_U16)u8SnsRegNum);
|
||
|
||
VI_WinSet(0, u8Mirror, u8Flip, u16HOfst, u16VOfst);
|
||
|
||
#if 0
|
||
if(u16HOfst != 0xFFFF)
|
||
{
|
||
DEBUG("Cut H:\n");
|
||
PrintInt(8, (XM_U32)u16HOfst); ENTER();
|
||
|
||
}
|
||
if(u16VOfst != 0xFFFF)
|
||
{
|
||
DEBUG("Cut V:\n");
|
||
PrintInt(8, (XM_U32)u16VOfst); ENTER();
|
||
}
|
||
#endif
|
||
u32Addr += (XM_U32)4*u8SnsRegNum*(gSnsRegAddrByte+gSnsRegDataByte);
|
||
u32Tmp = (XM_U32)u16Ofst*u8IspRegNum*8;
|
||
ExtCft_WriteIsp(1, u32Addr+u32Tmp, u8IspRegNum);
|
||
#ifdef DEBUG_ON
|
||
DEBUG("cmos_set_mirror_flip_ex over ~~~~\n");
|
||
#endif
|
||
|
||
return XM_SUCCESS;
|
||
}
|
||
|
||
|
||
XM_S32 cmos_get_ae_default_ext(AE_SENSOR_DEFAULT_V2_S *pstAeSnsDft)
|
||
{
|
||
XM_U32 u32Addr,u32Tmp;
|
||
XM_U8 u8i;
|
||
if(ExtCfg_BaseAddrGet(0, ROM_FUN_AEDEF, &u32Addr) != XM_SUCCESS)
|
||
return XM_FAILURE;
|
||
|
||
// MinShutter
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MinIntTime = u32Tmp;
|
||
// MinAgain
|
||
u32Addr += 1;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MinAgain = u32Tmp<<4;
|
||
// MaxAgain
|
||
u32Addr += 1;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(2,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MaxAgain = u32Tmp<<4;
|
||
// MinDgain
|
||
u32Addr += 2;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MinDgain = u32Tmp<<4;
|
||
//MaxDgain
|
||
u32Addr += 1;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(2,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MaxDgain = u32Tmp<<4;
|
||
//MaxIspDgain
|
||
u32Addr += 2;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(2,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32MaxISPDgain = u32Tmp<<4;
|
||
//UpdateCfg
|
||
u32Addr += 2;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(4,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32UpdateCfg = u32Tmp;
|
||
//MaxShutterOfst
|
||
u32Addr += 4;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
gu8MaxShutterOfst = u32Tmp;
|
||
|
||
//InitExp
|
||
u32Addr += 1;
|
||
for(u8i=0; u8i<4; u8i ++)
|
||
{
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(4,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u32InitExp[u8i] = u32Tmp;
|
||
u32Addr += 4;
|
||
}
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(2,u32Addr, (XM_U8*)&u32Tmp);
|
||
pstAeSnsDft->u16AlgMode = u32Tmp;
|
||
u32Addr += 2;
|
||
|
||
#if(defined SOC_SYSTEM) || (defined SOC_ALIOS)
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_AEAWBINFO, &u32Addr);
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(4,u32Addr+1, (XM_U8*)&u32Tmp);
|
||
for(u8i=0; u8i<4; u8i ++)
|
||
{
|
||
pstAeSnsDft->u32InitExp[u8i] = u32Tmp;
|
||
}
|
||
#endif
|
||
|
||
|
||
#ifdef DEBUG_ON
|
||
DEBUG("cmos_get_ae_default_ext:\n");
|
||
PrintInt(8, pstAeSnsDft->u32MinIntTime); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MaxIntTime); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MinAgain); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MaxAgain); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MinDgain); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MaxDgain); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32MaxISPDgain); ENTER();
|
||
PrintHex(8, pstAeSnsDft->u32UpdateCfg); ENTER();
|
||
PrintInt(8, gu8MaxShutterOfst); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32InitExp[0]); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32InitExp[1]); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32InitExp[2]); ENTER();
|
||
PrintInt(8, pstAeSnsDft->u32InitExp[3]); ENTER();
|
||
PrintHex(8, (XM_U32)pstAeSnsDft->u16AlgMode); ENTER();
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
//u8GainMode: 0:Again 1:Dgain
|
||
static void cmos_gain_calc_table( XM_U8 u8GainMode,
|
||
XM_U32 u32InTimes,
|
||
AE_SENSOR_GAININFO_S *pstAeSnsGainInfo)
|
||
{
|
||
#ifdef DEBUG_ON
|
||
static XM_U8 su8Flg = 0;
|
||
#endif
|
||
XM_U32 u32Addr,u32Tmp,u32AddrTmp,u32Min;
|
||
XM_U8 u8i,u8Num,u8Mode,u8Width,u8BitOfstR,u8BitOfstL;
|
||
XM_U32 tmp = 0;
|
||
if(XM_NULL == pstAeSnsGainInfo)
|
||
{
|
||
#ifdef DEBUG_ON
|
||
ERR("null pointer when get ae sensor gain info value!\n");
|
||
#endif
|
||
return;
|
||
}
|
||
if(u8GainMode)
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_TABDGAIN, &u32Addr);
|
||
else
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_TABAGAIN, &u32Addr);
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
u8Mode = u32Tmp;
|
||
if(u8Mode==2) // Table
|
||
{
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr+1, (XM_U8*)&u32Tmp);
|
||
u8Num = u32Tmp;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr+2, (XM_U8*)&u32Tmp);
|
||
u8BitOfstR = u32Tmp&0x7;
|
||
u8BitOfstL = (u32Tmp>>3)&0x07;
|
||
u8Width = ((u32Tmp>>6)&0x03)+1;
|
||
u32Addr += 3;
|
||
|
||
u32AddrTmp = u32Addr+(XM_U32)u8Width*0;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(u8Width,u32AddrTmp, (XM_U8*)&u32Tmp);
|
||
u32Min = (u32Tmp<<u8BitOfstL)>>u8BitOfstR;
|
||
|
||
u32AddrTmp = u32Addr+(XM_U32)u8Width*(u8Num-1);
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(u8Width,u32AddrTmp, (XM_U8*)&u32Tmp);
|
||
u32Tmp = (u32Tmp<<u8BitOfstL)>>u8BitOfstR;
|
||
#ifdef DEBUG_ON
|
||
if(!(su8Flg & (1<<u8GainMode)))
|
||
{
|
||
su8Flg |= (1<<u8GainMode);
|
||
DEBUG("cmos_gain_calc_table:\n");
|
||
PrintInt(8, (int)u8GainMode); ENTER();
|
||
PrintInt(8, (int)u8Num);ENTER();
|
||
for(u8i = 0x0; u8i < u8Num; u8i++)
|
||
{
|
||
u32AddrTmp = u32Addr+(XM_U32)u8Width*u8i;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(u8Width,u32AddrTmp, (XM_U8*)&u32Tmp);
|
||
u32Tmp = (u32Tmp<<u8BitOfstL)>>u8BitOfstR;
|
||
PrintInt(8, (int)u32Tmp); DBG(" ");
|
||
}
|
||
DBG("Over~~~"); ENTER();
|
||
}
|
||
#endif
|
||
if (u32InTimes >= u32Tmp)
|
||
{
|
||
tmp = (u8Num-1);
|
||
pstAeSnsGainInfo->u32SnsTimes = u32Tmp;
|
||
}
|
||
else
|
||
{
|
||
for(u8i = 0x0; u8i <= u8Num-1; u8i++)
|
||
{
|
||
u32AddrTmp = u32Addr+(XM_U32)u8Width*u8i;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(u8Width,u32AddrTmp, (XM_U8*)&u32Tmp);
|
||
u32Tmp = (u32Tmp<<u8BitOfstL)>>u8BitOfstR;
|
||
if(u32InTimes <u32Tmp)
|
||
{
|
||
break;
|
||
}
|
||
tmp = u8i;
|
||
pstAeSnsGainInfo->u32SnsTimes = u32Tmp;
|
||
}
|
||
}
|
||
pstAeSnsGainInfo->u32GainDb = tmp;
|
||
|
||
if(u8GainMode)
|
||
{
|
||
gu32DGainNow = pstAeSnsGainInfo->u32SnsTimes;
|
||
gu32DGainMin = u32Min;
|
||
}
|
||
else
|
||
{
|
||
gu32AGainNow = pstAeSnsGainInfo->u32SnsTimes;
|
||
gu32AGainMin = u32Min;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
XM_VOID cmos_again_calc_table_ex(XM_U32 u32InTimes,AE_SENSOR_GAININFO_S *pstAeSnsGainInfo)
|
||
{
|
||
cmos_gain_calc_table(0, u32InTimes, pstAeSnsGainInfo);
|
||
return;
|
||
}
|
||
|
||
|
||
XM_VOID cmos_dgain_calc_table_ex(XM_U32 u32InTimes,AE_SENSOR_GAININFO_S *pstAeSnsGainInfo)
|
||
{
|
||
cmos_gain_calc_table(1, u32InTimes, pstAeSnsGainInfo);
|
||
return;
|
||
}
|
||
|
||
#if 0
|
||
// ˼<><CBBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ1 :200w<30><77><EFBFBD><EFBFBD>
|
||
static XM_VOID cmos_gains_update_sms1(XM_U32 u32Again, XM_U32 u32Dgain)
|
||
{
|
||
static XM_U32 su32AGain = 0xFFFFFFF;
|
||
static XM_U32 su32DGain = 0xFFFFFFF;
|
||
unsigned int tmp[2];
|
||
if((su32AGain == u32Again) && (su32DGain==u32Dgain))
|
||
return ;
|
||
su32AGain = u32Again;
|
||
su32DGain = u32Dgain;
|
||
|
||
// 2. Update
|
||
tmp[0] = (u32Again&0x0F) | 0x10;
|
||
tmp[1] = u32Again/16;
|
||
switch(tmp[1])
|
||
{
|
||
case 0: tmp[1] = 0x3;
|
||
break;
|
||
case 1: tmp[1] = 0x7;
|
||
break;
|
||
case 2: tmp[1] = 0xF;
|
||
break;
|
||
case 3:
|
||
default: tmp[1] = 0x1F;
|
||
break;
|
||
}
|
||
switch(u32Dgain)
|
||
{
|
||
case 1: u32Dgain = 0;
|
||
break;
|
||
case 2: u32Dgain = 1;
|
||
break;
|
||
case 4: u32Dgain = 3;
|
||
break;
|
||
default:
|
||
#ifdef DEBUG_ON
|
||
ERR("Err!\n");
|
||
#endif
|
||
break;
|
||
}
|
||
tmp[1] |= (u32Dgain<<5);
|
||
sensor_write_register(0x3e08, tmp[1]);
|
||
sensor_write_register(0x3e09, tmp[0]);
|
||
return;
|
||
}
|
||
|
||
XM_VOID cmos_gains_update_ex(XM_U32 u32Again, XM_U32 u32Dgain)
|
||
{
|
||
XM_U32 u32Addr;
|
||
XM_U8 u8Mode;
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_UPDATEGAIN, &u32Addr);
|
||
ExtCfg_Read_V2(1,u32Addr, &u8Mode);
|
||
if(u8Mode == 0x11)
|
||
{
|
||
cmos_gains_update_sms1(u32Again, u32Dgain);
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
XM_VOID cmos_inttime_update_ex(XM_U32 u32IntTime)
|
||
{
|
||
static XM_U32 su32IntTimeLst = 0xFFFFFFF;
|
||
XM_U32 u32Addr,u32Tmp,u32Mask,u32Data;
|
||
XM_U8 u8Num,u8i;
|
||
if(su32IntTimeLst == u32IntTime) return;
|
||
su32IntTimeLst = u32IntTime;
|
||
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_UPDATESHUT, &u32Addr);
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr, (XM_U8*)&u32Tmp);
|
||
if(u32Tmp == 1) u32IntTime = gu16FullLines - u32IntTime;
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr+1, (XM_U8*)&u32Tmp);
|
||
u32IntTime = u32IntTime<<((u32Tmp>>4)&0x0F);
|
||
u32IntTime = u32IntTime>>(u32Tmp&0x0F);
|
||
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(1,u32Addr+2, (XM_U8*)&u32Tmp);
|
||
u8Num = u32Tmp;
|
||
u32Addr = u32Addr+3;
|
||
u32Mask = (1<<8*gSnsRegDataByte)-1;
|
||
//DEBUG("Time:\n");
|
||
for(u8i=0; u8i<u8Num; u8i ++)
|
||
{
|
||
u32Tmp = 0;
|
||
ExtCfg_Read_V2(gSnsRegAddrByte,u32Addr, (XM_U8*)&u32Tmp);
|
||
u32Data = u32IntTime&u32Mask;
|
||
sensor_write_register(u32Tmp, u32Data);
|
||
|
||
u32Addr += gSnsRegAddrByte;
|
||
u32IntTime = u32IntTime>>(8*gSnsRegDataByte);
|
||
|
||
//PrintHex(8, (XM_U64)u32Tmp);
|
||
//PrintHex(8, (XM_U64)u32Data); DBG("\r\n");
|
||
}
|
||
//DBG("\r\n");
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
|
||
/* the function of sensor set fps */
|
||
XM_VOID cmos_fps_set_ex(XM_U8 u8Fps, AE_SENSOR_DEFAULT_S *pstAeSnsDft)
|
||
{
|
||
XM_U8 u8MaxOfst = gu8MaxShutterOfst;
|
||
XM_U32 u32Addr;
|
||
XM_U8 u8SnsRegNum,u8IspRegNum;
|
||
XM_U16 u16MaxLine;
|
||
XM_U8 u8Mode;
|
||
XM_U32 u32Len;
|
||
if(pstAeSnsDft == NULL)
|
||
{
|
||
#ifdef DEBUG_ON
|
||
ERR("cmos_fps_set_ex err!~~~~\n");
|
||
#endif
|
||
return;
|
||
}
|
||
#ifdef DEBUG_ON
|
||
DEBUG("cmos_fps_set_ex start:\n");
|
||
#endif
|
||
|
||
if(ExtCfg_BaseAddrGet(0, ROM_FUN_FPS, &u32Addr)==XM_SUCCESS)
|
||
{
|
||
u8SnsRegNum = 0;
|
||
u8IspRegNum = 0;
|
||
u16MaxLine = 1125;
|
||
|
||
ExtCfg_Read_V2(1,u32Addr, &u8Mode);
|
||
ExtCfg_Read_V2(1,u32Addr+1, &u8SnsRegNum);
|
||
ExtCfg_Read_V2(1,u32Addr+2, &u8IspRegNum);
|
||
u32Len = (gSnsRegDataByte+gSnsRegAddrByte)*u8SnsRegNum+8*u8IspRegNum+3;
|
||
u32Addr += 3;
|
||
|
||
switch(gAppEncoderinfo)
|
||
{
|
||
// CVI
|
||
case 1: if(u8Mode&0x02)
|
||
u32Addr+= u32Len*2;
|
||
break;
|
||
// TVI
|
||
case 2: if(u8Mode&0x04)
|
||
{
|
||
if(u8Mode&0x02) u32Addr+= u32Len*4;
|
||
else u32Addr+= u32Len*2;
|
||
}
|
||
break;
|
||
// AHD
|
||
case 0:
|
||
default: break;
|
||
}
|
||
if(u8Fps == 30) // NTSC
|
||
{
|
||
u32Addr += u32Len;
|
||
}
|
||
ExtCfg_Read_V2(1,u32Addr, &u8Fps);
|
||
u32Addr += 1;
|
||
ExtCfg_Read_V2(2,u32Addr, (XM_U8*)&u16MaxLine);
|
||
u32Addr += 2;
|
||
sensor_write_ex(1, u32Addr, (XM_U16)u8SnsRegNum);
|
||
|
||
// Write Isp Reg
|
||
u32Addr += (XM_U32)(gSnsRegAddrByte+gSnsRegDataByte)*u8SnsRegNum;
|
||
ExtCft_WriteIsp(1, u32Addr, u8IspRegNum);
|
||
|
||
gu16FullLines = u16MaxLine;
|
||
pstAeSnsDft->u32MaxIntTime = (XM_U32)gu16FullLines-u8MaxOfst;
|
||
pstAeSnsDft->u32LinesPer500ms = (XM_U32)gu16FullLines*u8Fps/2;
|
||
pstAeSnsDft->u32FullLinesStd = (XM_U32)gu16FullLines;
|
||
}
|
||
gu8Fps = u8Fps;
|
||
|
||
#ifdef DEBUG_ON
|
||
PrintInt(8, (XM_U32)gu8Fps); ENTER();
|
||
PrintInt(8, (XM_U32)gu16FullLines); ENTER();
|
||
DEBUG("cmos_fps_set_ex over~~~~~~\n");
|
||
#endif
|
||
|
||
return;
|
||
}
|
||
|
||
void gainLogic_ex(XM_U32 u32AllGain)
|
||
{
|
||
static XM_U8 su8Idx = 0xFF;//[bit0~bit3]:Vstd [bit4~bit7]:Agc
|
||
|
||
XM_U32 u32Addr,u32AddrTmp;
|
||
XM_U8 u8RegNum,u8GainNum,u8i,u8Gain,u8Mode,u8FpsModeNow,u8j;
|
||
XM_U32 u32Reg,u32Val;
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_GAINLOGIC, &u32Addr);
|
||
ExtCfg_Read_V2(1,u32Addr+2, &u8RegNum);
|
||
ExtCfg_Read_V2(1,u32Addr+3, &u8GainNum);
|
||
ExtCfg_Read_V2(1,u32Addr+4, &u8Mode);
|
||
gu8BlcDpcFlg = u8Mode & 0xF0;
|
||
u8Mode = u8Mode & 0x0F;
|
||
u32Val = gSnsRegDataByte*u8RegNum*(u8GainNum+1);
|
||
//RegList
|
||
u32Addr += 5;
|
||
//gainList
|
||
u32AddrTmp = u32Addr+(XM_U32)u8RegNum*gSnsRegAddrByte;
|
||
for(u8i=0;u8i<u8GainNum;u8i ++)
|
||
{
|
||
ExtCfg_Read_V2(1,u32AddrTmp+u8i, &u8Gain);
|
||
if(u32AllGain<u8Gain)
|
||
break;
|
||
}
|
||
u32AddrTmp += u8GainNum;
|
||
//RegDataList
|
||
switch(gu8Fps)
|
||
{
|
||
case 30: u8FpsModeNow = 1;
|
||
break;
|
||
case 50: u8FpsModeNow = 2;
|
||
break;
|
||
case 60: u8FpsModeNow = 3;
|
||
break;
|
||
case 25:
|
||
default: u8FpsModeNow = 0;
|
||
break;
|
||
}
|
||
if(((su8Idx&0x0F) != u8FpsModeNow) || (((su8Idx>>4)&0x0F) != u8i))
|
||
{
|
||
su8Idx = ((u8i&0x0F)<<4)|(u8FpsModeNow&0x0F);
|
||
|
||
for(u8j=0; u8j < 4; u8j ++)
|
||
{
|
||
if(u8j == u8FpsModeNow)
|
||
break;
|
||
if((1<<u8j) & u8Mode)
|
||
{
|
||
u32AddrTmp += u32Val;
|
||
}
|
||
}
|
||
u32AddrTmp += (XM_U32)u8RegNum*gSnsRegDataByte*u8i;
|
||
#ifdef DEBUG_ON
|
||
DBG("gainLogic:\r\n");
|
||
PrintInt(8, u32AllGain);
|
||
DBG("\r\n");
|
||
#endif
|
||
for(u8i=0;u8i<u8RegNum;u8i ++)
|
||
{
|
||
u32Reg = 0;
|
||
ExtCfg_Read_V2(gSnsRegAddrByte,u32Addr+gSnsRegAddrByte*u8i, (XM_U8*)&u32Reg);
|
||
u32Val = 0;
|
||
ExtCfg_Read_V2(gSnsRegDataByte,u32AddrTmp+gSnsRegDataByte*u8i, (XM_U8*)&u32Val);
|
||
sensor_write_register(u32Reg, u32Val);
|
||
|
||
#ifdef DEBUG_ON
|
||
PrintHex(8, u32Reg);
|
||
PrintHex(8, u32Val);
|
||
DBG("\r\n");
|
||
#endif
|
||
}
|
||
#ifdef DEBUG_ON
|
||
DBG("\r\n");
|
||
#endif
|
||
}
|
||
}
|
||
|
||
void shutLogic_ex(XM_U32 u32IntTime)
|
||
{
|
||
static XM_U32 su32IntTime = 0;
|
||
|
||
XM_U32 u32Addr,u32AddrTmp;
|
||
XM_U8 u8RegNum,u8RegNum2,u8i;
|
||
XM_U32 u32Reg,u32Val;
|
||
XM_U16 u16ThrL,u16ThrH;
|
||
if(su32IntTime == u32IntTime) return;
|
||
su32IntTime = u32IntTime;
|
||
|
||
ExtCfg_BaseAddrGet(0, ROM_FUN_SHUTLOGIC, &u32Addr);
|
||
ExtCfg_Read_V2(1,u32Addr+2, &u8RegNum);
|
||
ExtCfg_Read_V2(1,u32Addr+3, &u8RegNum2);
|
||
ExtCfg_Read_V2(2,u32Addr+4, (XM_U8 *)&u16ThrL);
|
||
ExtCfg_Read_V2(2,u32Addr+6, (XM_U8 *)&u16ThrH);
|
||
|
||
#ifdef DEBUG_ON
|
||
DBG("shutLogic:\r\n");
|
||
PrintInt(8, u32IntTime);
|
||
DBG("\r\n");
|
||
#endif
|
||
|
||
// logic1
|
||
u32Addr += 8;
|
||
u32AddrTmp = 0;
|
||
if(u32IntTime<u16ThrL)
|
||
{
|
||
u32AddrTmp = u32Addr+(XM_U32)u8RegNum*gSnsRegAddrByte;
|
||
}
|
||
else if(u32IntTime>u16ThrH)
|
||
{
|
||
u32AddrTmp = u32Addr+(XM_U32)u8RegNum*gSnsRegAddrByte+(XM_U32)u8RegNum*gSnsRegDataByte;
|
||
}
|
||
if(u32AddrTmp != 0)
|
||
{
|
||
for(u8i=0;u8i<u8RegNum;u8i ++)
|
||
{
|
||
u32Reg = 0;
|
||
ExtCfg_Read_V2(gSnsRegAddrByte,u32Addr+gSnsRegAddrByte*u8i, (XM_U8*)&u32Reg);
|
||
u32Val = 0;
|
||
ExtCfg_Read_V2(gSnsRegDataByte,u32AddrTmp+gSnsRegDataByte*u8i, (XM_U8*)&u32Val);
|
||
sensor_write_register(u32Reg, u32Val);
|
||
|
||
#ifdef DEBUG_ON
|
||
PrintHex(8, u32Reg);
|
||
PrintHex(8, u32Val);
|
||
DBG("\r\n");
|
||
#endif
|
||
}
|
||
}
|
||
// logic2
|
||
if(u8RegNum2 != 0)
|
||
{
|
||
u32Addr += (XM_U32)u8RegNum*gSnsRegAddrByte+(XM_U32)u8RegNum*gSnsRegDataByte*2;
|
||
u32AddrTmp = u32Addr+(XM_U32)u8RegNum2*gSnsRegAddrByte;
|
||
for(u8i=0;u8i<u8RegNum2;u8i ++)
|
||
{
|
||
u32Reg = 0;
|
||
ExtCfg_Read_V2(gSnsRegAddrByte,u32Addr+gSnsRegAddrByte*u8i, (XM_U8*)&u32Reg);
|
||
u32Val = 0;
|
||
ExtCfg_Read_V2(gSnsRegDataByte,u32AddrTmp+gSnsRegDataByte*u8i, (XM_U8*)&u32Val);
|
||
sensor_write_register(u32Reg, u32Val);
|
||
|
||
#ifdef DEBUG_ON
|
||
PrintHex(8, u32Reg);
|
||
PrintHex(8, u32Val);
|
||
DBG("\r\n");
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|