/* Kirby: add new-style driver {*/
static int AF_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int i4RetValue = 0;

    LOG_INF("Start\n");

    /* Kirby: add new-style driver { */
    g_pstAF_I2Cclient = client;

    g_pstAF_I2Cclient->addr = I2C_SLAVE_ADDRESS;

    g_pstAF_I2Cclient->addr = g_pstAF_I2Cclient->addr >> 1;

    //Register char driver
    i4RetValue = Register_AF_CharDrv();

    if(i4RetValue){

        LOG_INF(" register char device failed!\n");

        return i4RetValue;
    }

    spin_lock_init(&g_AF_SpinLock);

    LOG_INF("Attached!! \n");

    return 0;
}

/* Q1 : Try release multiple times. */
int BU6424AF_Release(struct inode *a_pstInode, struct file *a_pstFile)
{
	LOG_INF("Start\n");

	if (*g_pAF_Opened == 2) {
		char puSendCmd[2];

		puSendCmd[0] = (char)(0x00);
		puSendCmd[1] = (char)(0x00);
		i2c_master_send(g_pstAF_I2Cclient, puSendCmd, 2);
		LOG_INF("Wait\n");
		/*s4AF_WriteReg(200);
		msleep(20);
		s4AF_WriteReg(100);
		msleep(20);*/
	}

	if (*g_pAF_Opened) {
		LOG_INF("Free\n");

		spin_lock(g_pAF_SpinLock);
		*g_pAF_Opened = 0;
		spin_unlock(g_pAF_SpinLock);
	}

	LOG_INF("End\n");

	return 0;
}

int usb_dc_ep_check_cap(const struct usb_dc_ep_cfg_data *const cfg)
{
	u8_t ep_idx = EP_ADDR2IDX(cfg->ep_addr);

	if ((cfg->ep_type == USB_DC_EP_CONTROL) && ep_idx) {
		LOG_ERR("invalid endpoint configuration");
		return -1;
	}

	if (ep_idx >= NUM_OF_EP_MAX) {
		LOG_ERR("endpoint index/address out of range");
		return -1;
	}

	if (ep_idx & BIT(0)) {
		if (EP_ADDR2DIR(cfg->ep_addr) != USB_EP_DIR_IN) {
			LOG_INF("pre-selected as IN endpoint");
			return -1;
		}
	} else {
		if (EP_ADDR2DIR(cfg->ep_addr) != USB_EP_DIR_OUT) {
			LOG_INF("pre-selected as OUT endpoint");
			return -1;
		}
	}

	return 0;
}

//  *****************************************************
//  **** Read from the Peripheral register < 82h >
//  **** ------------------------------------------------
//  **** CL_UBYTE    adr    Peripheral Address
//  **** CL_UWORD    dat    Read data
//  *****************************************************
static CL_UWORD    I2C_read__FBAF( CL_UBYTE u08_adr )
{
        int  i4RetValue = 0;
    char pBuff[1] = {(char)(u08_adr & 0xFF)};
    CL_UWORD vRcvBuff=0;
        spin_lock(&g_AF_SpinLock);
    g_pstAF_I2Cclient->addr = (I2C_SLAVE_ADDRESS >> 1);
         g_pstAF_I2Cclient->ext_flag = (g_pstAF_I2Cclient->ext_flag)&(~I2C_DMA_FLAG);
        spin_unlock(&g_AF_SpinLock);

    i4RetValue = i2c_master_send(g_pstAF_I2Cclient, pBuff, 1);
    if (i4RetValue < 0 )
    {
        LOG_INF("[CAMERA SENSOR] read I2C send failed!!\n");
        return i4RetValue;
    }

    i4RetValue = i2c_master_recv(g_pstAF_I2Cclient, (u8*)&vRcvBuff, 2);
    if (i4RetValue != 2)
    {
        LOG_INF("[CAMERA SENSOR] I2C read failed!! \n");
        return i4RetValue;
    }
    //vRcvBuff=    ((vRcvBuff&0xFF) <<8) + ((vRcvBuff>> 8)&0xFF) ;
      vRcvBuff=((vRcvBuff<<8)&0xff00)|((vRcvBuff>>8)&0x00ff);

    LOG_INF("I2C r2 (%x %x) \n",u08_adr,vRcvBuff);

    return vRcvBuff;

}

/**
 * Constructor for the combi combiroutes
 * @param n		number of combi combiroutes to be created
 * @exception		Calls exit if no RAM available
 */
void combiroutes(const unsigned short nr)
{
	unsigned short		i, j;
	struct sCombiroute *	pCombiroute;

	LOG_INF("started");
	
	m_nrCombiroutes = nr;
	m_pCombiroutes = malloc(m_nrCombiroutes * sizeof(struct sCombiroute));
	if(NULL == m_pCombiroutes) 
	{
		/* error allocating */
		LOG_ERR("cannot allocate RAM of train combiroutes");
		exit(EXIT_FAILURE);
	}
	pCombiroute = m_pCombiroutes;
	for(i = 0; i < m_nrCombiroutes; i++)
	{
		pCombiroute->name[0]	= '\0';
		pCombiroute->start	= NULL;
		pCombiroute->dest	= NULL;
		pCombiroute->partsAddPosition	= 0;

		for(j = 0; j < NRCOMBIPARTS; j++)
		{
			pCombiroute->pRoute[j]	= NULL;
		}

		pCombiroute++;
	}

	LOG_INF("ended");
}

/*************************************************************************************************
* Function    :  otp_wb_update
* Description :  Update WB correction
* Return      :  [bool] 0 : OTP data fail
                        1 : otp_WB update success
**************************************************************************************************/
bool otp_wb_update(BYTE zone)
{
    USHORT golden_g, current_g;


    if(!get_otp_wb(zone))  // get wb data from otp
    {
        LOG_INF("Get OTP WB data Err!\n");
        return 0;
    }

    golden_g = (golden_gr + golden_gb) / 2;
    current_g = (current_gr + current_gb) / 2;

    if(!golden_g || !current_g || !golden_r || !golden_b || !current_r || !current_b)
    {
        LOG_INF("WB update Err !\n");
        return 0;
    }

    r_ratio = 512 * golden_r * current_g /( golden_g * current_r );
    b_ratio = 512 * golden_b * current_g /( golden_g * current_b );

    wb_gain_set();

    LOG_INF("OTP WB update finished! \n");

    return 1;
}

//Main jobs:
// 1.check for device-specified errors, device not ready.
// 2.Initialize the device if it is opened for the first time.
// 3.Update f_op pointer.
// 4.Fill data structures into private_data
//CAM_RESET
static int AF_Open(struct inode * a_pstInode, struct file * a_pstFile)
{
    LOG_INF("Start \n");


    if(g_s4AF_Opened)
    {
        LOG_INF("The device is opened \n");
        return -EBUSY;
    }

    spin_lock(&g_AF_SpinLock);
    g_s4AF_Opened = 1;
    spin_unlock(&g_AF_SpinLock);
    I2C_func_POFF_____( );                    // reset the IC
    I2C_func_PON______( );                    // Power ON

    func_INITIALIZE( );                        // initialize the IC
    func_ReLOAD_FACT_DATA( );                // ReLoad Adjustment Data
    I2C_func_DSP_START( );                    // CLAF Function Enable

    EQ_CONTROL( 0x0004 );

    LOG_INF("End \n");
    return 0;
}

//Main jobs:
// 1.Deallocate anything that "open" allocated in private_data.
// 2.Shut down the device on last close.
// 3.Only called once on last time.
// Q1 : Try release multiple times.
static int AF_Release(struct inode * a_pstInode, struct file * a_pstFile)
{
    LOG_INF("Start \n");

    if (g_s4AF_Opened == 2)
    {
        g_sr = 5;
        s4AF_WriteReg(200);
        msleep(10);
        s4AF_WriteReg(100);
        msleep(10);
    }

    if (g_s4AF_Opened)
    {
        LOG_INF("Free \n");

        spin_lock(&g_AF_SpinLock);
        g_s4AF_Opened = 0;
         g_sr = 5;
        spin_unlock(&g_AF_SpinLock);
    }    

    LOG_INF("End \n");

    return 0;
}

/**
 * Constructor for the sections
 * @param nr		number of sections to be created
 * @exception       Calls exit if no RAM available
 */
void sections(const unsigned short nr) 
{
	unsigned short	i, j;
	struct sSection *	ptr;

	LOG_INF("started");
	
	m_nrSection = nr;
	m_pSection = malloc(m_nrSection * sizeof(struct sSection));
	if(NULL == m_pSection) 
	{
		/* error allocating */
		LOG_ERR("cannot allocate RAM of sections");
		exit(EXIT_FAILURE);
	}
	ptr = m_pSection;
	for(i = 0; i < m_nrSection; i++)
	{
		ptr->name[0]	= '\0';
		ptr->BI_occDetector	= NONEVALUE;
		ptr->DuoledAddPosition	= 0;
		ptr->line	= neutral;
		ptr->linePrev	= neutral;
		ptr->free	= false;
		ptr->wasFree	= false;
		ptr->route	= false;
		ptr->wasRoute	= false;
		for(j = 0; j < NRBLOCKPL; j++)
		{
			ptr->pDuoled[j] = NULL;
		}
		ptr++;
	}		
	LOG_INF("ended");
}

void commInit(void) 
{
	LOG_INF("started");
	sockKill = false;
	pthread_create(& sockThread, NULL, sockFunction, (void *) sock);

	LOG_INF("ended");
}

//-----------------------------------------------------------------------------
MBOOL TdriMgrImp::uninit(void)
{
    MBOOL Result = MTRUE;
    int i;
    //
    GLOBAL_PROFILING_LOG_PRINT(__func__);
    GLOBAL_PROFILING_LOG_PRINT("Uninit TdriMgr");
    //
    Mutex::Autolock lock(mLock);
    //
    LOG_INF("mInitCount(%d)",mInitCount);
    //
    android_atomic_dec(&mInitCount);
    //
    if(mInitCount > 0) {
        goto EXIT;
    }


    for(i=TPIPE_DRV_CQ01; i<=TPIPE_DRV_CQ02; i++) {
        if(i == TPIPE_DRV_CQ01) {
            pIspDrv->lockSemaphoreCq1();
            tdriMgrInfo[i].pDescriptorArray = NULL;
            tdriMgrInfo[i].pDesriptorNum = 0;
            tdriMgrInfo[i].pTopCtlEn1 = 0;
            tdriMgrInfo[i].pTopCtlEn2 = 0;
            tdriMgrInfo[i].pTopCtlDma = 0;
            pIspDrv->unlockSemaphoreCq1();
        } else if (i == TPIPE_DRV_CQ02) {
            pIspDrv->lockSemaphoreCq2();
            tdriMgrInfo[i].pDescriptorArray = NULL;
            tdriMgrInfo[i].pDesriptorNum = 0;
            tdriMgrInfo[i].pTopCtlEn1 = 0;
            tdriMgrInfo[i].pTopCtlEn2 = 0;
            tdriMgrInfo[i].pTopCtlDma = 0;
            pIspDrv->unlockSemaphoreCq2();
        } else {
            LOG_ERR("[ERROR]not support this tdri cq(%d) number \n");
        }
    }


    //tpipe driver
    pTdriDri->uninit();
    pTdriDri->destroyInstance();
    pTdriDri = NULL;

    //isp drv
    pIspDrv->setCallbacks(NULL, NULL);
    pIspDrv->uninit();
    pIspDrv->destroyInstance();
    pIspDrv = NULL;

    LOG_INF("Release\n");

EXIT:
    return Result;
}

//-----------------------------------------------------------------------------
MBOOL
TdriMgrImp::
flushSetting(
    ISP_DRV_CQ_ENUM ispCq
)
{
    LOCAL_PROFILING_LOG_AUTO_START(Event_TdriMgr);
    LOCAL_PROFILING_LOG_PRINT("flushSetting");

    LOG_INF("E:Cq(%d)",ispCq);
    //
    if(tdriMgrCqMap[ispCq].tdriMgrCQ == TPIPE_DRV_CQ01) {
        pIspDrv->lockSemaphoreCq1();
        // flush setting
        ::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ01].tdriTurningSetting, 0x00, sizeof(TDRI_MGR_TPIPE_TABLE_TURNING));
        ::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg, 0x00, sizeof(TdriDrvCfg));
        tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg.updateTdri.updateType = TPIPE_DRV_UPDATE_TYPE_CQ1_TURNING_SAVE;
        refreshTableSetting(TPIPE_DRV_CQ01, 0xffffffff);  // refresh all setting
        tdriMgrInfo[TPIPE_DRV_CQ01].tdriMgrCfg.updateTdri.partUpdateFlag = 0xffffffff; // clean Tpipe update flag
        handleTpipeTable(TPIPE_DRV_CQ01);

        pIspDrv->setTurnTopEn1(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->setTurnTopEn2(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->setTurnTopDma(ISP_DRV_CQ01, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->flushTurnCqTable(ISP_DRV_CQ01);
        //
        pIspDrv->unlockSemaphoreCq1();
    }
    else if(tdriMgrCqMap[ispCq].tdriMgrCQ == TPIPE_DRV_CQ02) {
        pIspDrv->lockSemaphoreCq2();
        // flush setting
        ::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ02].tdriTurningSetting, 0x00, sizeof(TDRI_MGR_TPIPE_TABLE_TURNING));
        ::memset((char*)&tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg, 0x00, sizeof(TdriDrvCfg));
        tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg.updateTdri.updateType = TPIPE_DRV_UPDATE_TYPE_CQ2_TURNING_SAVE;
        refreshTableSetting(TPIPE_DRV_CQ02, 0xffffffff);  // refresh all setting
        tdriMgrInfo[TPIPE_DRV_CQ02].tdriMgrCfg.updateTdri.partUpdateFlag = 0xffffffff; // clean Tpipe update flag
        handleTpipeTable(TPIPE_DRV_CQ02);


        pIspDrv->setTurnTopEn1(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->setTurnTopEn2(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->setTurnTopDma(ISP_DRV_CQ02, ISP_DRV_TURNING_TOP_RESET);
        pIspDrv->flushTurnCqTable(ISP_DRV_CQ02);
        //
        pIspDrv->unlockSemaphoreCq2();
    }
    else {
        LOG_WRN("not support this tMgrCq(%d) for flush",tdriMgrCqMap[ispCq].tdriMgrCQ);
        return MFALSE;
    }

    LOG_INF("X\n",ispCq);
    LOCAL_PROFILING_LOG_PRINT("End flushSetting");

    return MTRUE;

}

/*************************************************************************************************
* Function    :  otp_update()
* Description :  update otp data from otp , it otp data is valid,
                 it include get ID and WB update function
* Return      :  [bool] 0 : update fail
                        1 : update success
**************************************************************************************************/
bool otp_update(BYTE update_sensor_otp_awb, BYTE update_sensor_otp_lsc)
{
    BYTE zone = 0x01;
    BYTE FLG  = 0x00;
    BYTE MID = 0x00;
    int i;

    LOG_INF("update_sensor_otp_awb: %d, update_sensor_otp_lsc: %d\n", update_sensor_otp_awb, update_sensor_otp_lsc );

    for(i=0;i<3;i++)
    {
        FLG = get_otp_flag(zone);
        if(FLG == VALID_OTP)
            break;
        else
            zone++;
    }
    if(i==3)
    {
        LOG_INF("No OTP Data or OTP data is invalid!!!\n");
        return 0;
    }

    MID =     get_otp_module_id(zone);
#ifdef DEBUG_IMX135_OTP
    get_otp_lens_id(zone);
    get_otp_vcm_id(zone);
#endif

    if(MID != TRULY_ID) //Select
    {
        LOG_INF("No Truly Module !!!!\n");
        return 0;
    }

    if(0 != update_sensor_otp_awb && _otp_awb_set == 0) {
        if(otp_wb_update(zone)){
  		    spin_lock(&imx135_otp_lock);
            _otp_awb_set = 1;
            spin_unlock(&imx135_otp_lock);
        }
    }


    if(0 != update_sensor_otp_lsc && _otp_lsc_set == 0)
    {
        if(!otp_lenc_update())
        {
            LOG_INF("OTP Update LSC Err\n");
            return 0;
        }
		spin_lock(&imx135_otp_lock);
        _otp_lsc_set = 1;
     	spin_unlock(&imx135_otp_lock);
    }
    return 1;
}

/** 
 * Destructor. 
 *
 * To free the allocated RAM, call this function before terminating the program.
 */
void duoledDestroy(void) 
{
	LOG_INF("started");
	free(m_pDuoled);
	m_pDuoled = NULL;
	m_nrDuoled = 0;
	m_DuoledAddPosition = 0;
	LOG_INF("ended");
}

MdpMgr *MdpMgr::createInstance()
{
    LOG_INF("+");

    DBG_LOG_CONFIG(imageio, mdpmgr);
    static MdpMgrImp singleton;

    LOG_INF("-");    
    return &singleton;
}

void
display_windows_ce_infos (void)
{
  Uint32 i;
  char *param;
  WCHAR wparam[PARAMAX_LEN + 1];
  OSVERSIONINFO vinfo;
  static const char *action_names[] = {
    "SPI_GETPLATFORMMANUFACTURER",
    "SPI_GETPLATFORMNAME",
    "SPI_GETPLATFORMTYPE"
  };
  static const Uint32 actions[] = {
    SPI_GETPLATFORMMANUFACTURER,
    SPI_GETPLATFORMNAME,
    SPI_GETPLATFORMTYPE
  };
  for (i = 0; i < sizeof (actions) / sizeof (Uint32); i++)
    {
      if (SystemParametersInfo (actions[i], PARAMAX_LEN, wparam, 0) == FALSE)
        {
          LOG_ERR ("SystemParametersInfo(%s) "
                   "failed (error %i)", action_names[i], GetLastError ());
          continue;
        }
      param = wide_char_to_bytes (wparam, 0, CP_ACP);
      if (param == NULL)
        {
          continue;
        }
      LOG_INF ("%s %s", action_names[i], param);
      free_memory (param);
    }

  if (GetVersionEx (&vinfo) == FALSE)
    {
      LOG_ERR ("GetVersionEx() " "failed (error %i)", GetLastError ());
    }
  else
    {
      if (vinfo.dwPlatformId != VER_PLATFORM_WIN32_CE)
        {
          LOG_ERR ("this system is not a Windows Embedded CE OS");
        }
      else
        {
          LOG_INF ("Windows Mobile %i.%i", vinfo.dwMajorVersion,
                   vinfo.dwMinorVersion);
        }
    }

  LOG_INF ("SM_CXSCREEN: %i; SM_CYSCREEN: %i",
           GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN));
}

void commDestroy(void) 
{
	void * ptr;
	
	LOG_INF("started");
	sockKill = true;
	pthread_join(sockThread, & ptr);
	free(pOutString);
	free(pInString);
	LOG_INF("ended");
}

/**
 * Init function for the sections
 *
 * Here, all sections are initialised according to the state of the occupancy
 * detectors.
 */
void sectionsInit(void) 
{
	struct sSection *		ptr = m_pSection;  
	struct sDuoled *	pDuoled;
	unsigned short 		i;
	unsigned short 		j;
	LOG_INF("started");
	
	/* Note: all vars are initialised, also the ones which are not
	 * used anymore, e.g. slave sections
	 */
	assert(NULL != ptr);
	for (i = 0; i < m_nrSection; i++) 
	{
		ptr->route         = false;
		ptr->wasRoute      = false;
		ptr->line          = neutral;
		ptr->linePrev      = neutral;
		j = 0;
		while(NULL != (pDuoled = sectionGetDuoled(ptr, j)))
		{
			duoledSetMode(pDuoled, ledOff);
			j++;
		}
		/* check if there are occupied sections and set the color on the 
		 * desk accordingly
		 */
		if(registerBitGet(ptr->BI_occDetector)) 
		{
			ptr->free = false;
			ptr->wasFree = false;
			j = 0;
			while(NULL != (pDuoled = sectionGetDuoled(ptr, j)))
			{
				duoledSetOccupied(pDuoled, true);
				j++;
			}
		}
		else 
		{
			ptr->free = true;
			ptr->wasFree = true;
			j = 0;
			while(NULL != (pDuoled = sectionGetDuoled(ptr, j)))
			{
				duoledSetOccupied(pDuoled, false);
				j++;
			}
		}
		ptr++;
	}
	LOG_INF("ended"); 
}

/*************************************************************************************************
* Function    :  get_otp_lens_id
* Description :  get otp LENS_ID value
* Parameters  :  [BYTE] zone : OTP PAGE index , 0x00~0x0f
* Return      :  [BYTE] 0 : OTP data fail
                 other value : LENS ID data
**************************************************************************************************/
BYTE get_otp_lens_id(BYTE zone)
{
    BYTE lens_id = 0;
    if(!start_read_otp(zone))
    {
        LOG_INF("Start read Page %d Fail!\n", zone);
        return 0;
    }
    lens_id = read_cmos_sensor(0x3B09);
    LOG_INF("OTP_Lens ID: 0x%02x.\n",lens_id);
    return lens_id;
}

/*************************************************************************************************
* Function    :  get_light_id
* Description :  get otp environment light temperature value
* Parameters  :  [BYTE] zone : OTP PAGE index , 0x00~0x0f
* Return      :  [BYTE] 0 : OTP data fail
                        other value : driver ID data
                        BIT0:D65(6500K) EN
                        BIT1:D50(5100K) EN
                        BIT2:CWF(4000K) EN
                        BIT3:A Light(2800K) EN
**************************************************************************************************/
BYTE get_light_id(BYTE zone)
{
    BYTE light_id = 0;
    if(!start_read_otp(zone))
    {
        LOG_INF("Start read Page %d Fail!\n", zone);
        return 0;
    }
    light_id = read_cmos_sensor(0x3B0C);
    LOG_INF("OTP_Light ID: 0x%02x.\n",light_id);
    return light_id;
}