自学教程：C++ DBG_ERR函数代码示例

void System_OnStrgInit_INMEM(void){    static BOOL bStrg_init_INMEM = FALSE;    UINT32 i=0;    if(bStrg_init_INMEM)        return;    //check partition overlap    //part 0(FW area) must match loader reserved size,and next area can not overlap previos area    for(i=0;i<NAND_PARTITION_NUM;i++)    {        if(i==0)        {            if(NandPartition[i].uiPhySize<gBinInfo.ld.FWResvSize)            {               DBG_ERR("part0 %x < FWResvSize %x,cannot init/r/n",NandPartition[i].uiPhySize,gBinInfo.ld.FWResvSize);               return;            }        }        else        {            if(NandPartition[i].uiPhyAddr<NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize)            {                DBG_ERR("part%d start %x overlap part%d end %x,cannot init/r/n",i,NandPartition[i].uiPhyAddr,i-1,NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize);                return;            }        }    }    for(i=0;i<NAND_PARTITION_NUM;i++)    {        DX_HANDLE DxNandDev = Dx_GetObject(NandPartition[i].uiDxClassType);        UserNandInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_NAND);        UserNandInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_NAND);        UserNandInit.prt.uiDxClassType = NandPartition[i].uiDxClassType;        UserNandInit.prt.uiPhyAddr = NandPartition[i].uiPhyAddr;        UserNandInit.prt.uiPhySize = NandPartition[i].uiPhySize;        if(i==0)            UserNandInit.prt.uiResvSize = gBinInfo.ld.LdBlockCount; //FWS use loader block count as reserved blcok        else            UserNandInit.prt.uiResvSize = NandPartition[i].uiResvSize;        Dx_Init(DxNandDev,&UserNandInit,0,STORAGE_VER);    }    bStrg_init_INMEM = TRUE;}

void DrvTV_TurnOn(void){    DISPDEV_ID dev;    DBG_FUNC_BEGIN("/r/n");    if (g_localMode == DISP_TVMODE_NTSC)    {        dev = DISPDEV_ID_TVNTSC; //NTSC: 640x448    }    else if(g_localMode == DISP_TVMODE_PAL)    {        dev = DISPDEV_ID_TVPAL; //PAL: 640x528    }    else    {        DBG_ERR("mode=%d not support!/r/n", g_localMode);        return;    }    // Init TV object    /*    pDev->SEL.GET_PREDISPSIZE.DevID = dev;    pObj->devCtrl(DISPDEV_GET_PREDISPSIZE,pDev);    g_localSize.w     = pDev->SEL.GET_PREDISPSIZE.uiBufWidth;    g_localSize.h    = pDev->SEL.GET_PREDISPSIZE.uiBufHeight;    */    //IMPORTANT! for FAST BOOT, Photo App will ask disp size very early~    //Update size of first mode (before open)    //DxDisplay_UpdateModeInfo(g_TVDout<<4, g_localMode, &g_localSize);    pDev->SEL.OPEN_DEVICE.DevID = dev;    pObj->devCtrl(DISPDEV_OPEN_DEVICE,pDev);    g_TVBacklightEn = TRUE;    pObj->devCtrl(DISPDEV_GET_DISPSIZE,pDev);    g_localSize.w = pDev->SEL.GET_DISPSIZE.uiBufWidth;    g_localSize.h = pDev->SEL.GET_DISPSIZE.uiBufHeight;    if(pCurrentSize)        pCurrentSize[0] = g_localSize;    // Enable IDE    pObj->waitFrmEnd();    pCtrl->SEL.SET_ENABLE.bEn = TRUE;    pObj->dispCtrl(DISPCTRL_SET_ENABLE,pCtrl);#if 0    {    int i;    // Delay to wait for IDE stable    for (i=6; i>0; i--)    {        //ide_wait_frame_end();        pObj->waitFrmEnd();    }    }#endif    g_TVMode = g_localMode;}

/*    PreGet LCD size    PreGet LCD size    @param[in] pDevIF   Please refer to dispdevctrl.h for details.    @param[in] uiAddr   LCD Register Offset.    @param[in] uiValue  Assigned LCD Register Value    @return void*/static ER dispdev_getLcdMiSize(DISPDEV_GET_PRESIZE *tSize){    UINT32                  i;    tLCD_PARAM              *pMode      = NULL;    tLCD_PARAM              *pConfigMode= NULL;    PINMUX_LCDINIT          LcdMode;    UINT32                  ModeNumber;    PINMUX_FUNC_ID          PinFuncID;    //DISPDEV_IOCTRL_PARAM    DevIOCtrl;#if   (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD1)    DISPDEV_IOCTRL          pDispDevControl = pIFMiIoControl1;#elif (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD2)    DISPDEV_IOCTRL          pDispDevControl = pIFMiIoControl2;#endif    dispanl_debug(("getLcdSize START/r/n"));    if(pDispDevControl == NULL)    return E_PAR;    tSize->uiBufWidth = 0;    tSize->uiBufHeight = 0;    //    //  Sortig the SysInit Config Mode support    //#if (DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD1)    PinFuncID = PINMUX_FUNC_ID_LCD;#elif ((DISPLCDSEL_IFMI_TYPE == DISPLCDSEL_IFMI_LCD2))    PinFuncID = PINMUX_FUNC_ID_LCD2;#endif    LcdMode = pinmux_getDispMode(PinFuncID);    pConfigMode = dispdev_getConfigModeMI(&ModeNumber);    if((pConfigMode != NULL)&&(ModeNumber>0))    {        for(i=0;i<ModeNumber;i++)        {            if(pConfigMode[i].Panel.LCDMode == LcdMode)            {                pMode = (tLCD_PARAM*)&pConfigMode[i];                break;            }        }    }    if(pMode==NULL)    {        DBG_ERR("LCDMode=%d not support/r/n", LcdMode);        return E_NOSPT;    }    else    {        tSize->uiBufWidth = pMode->Panel.uiBufferWidth;        tSize->uiBufHeight = pMode->Panel.uiBufferHeight;    }    return E_OK;}

INT32 Lens_Focus_AfterZoomChanged(void){    if (Lens_Module_GetState() != LENS_STATE_IDLE)    {        if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)        {            DBG_ERR("%s, state incorrect, (%d)/r/n",__func__,Lens_Module_GetState());            return ERR_OPERATION_FAIL;        }    }    DBG_MSG("%s/r/n",__func__);    if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)    {        Lens_Module_SetState(LENS_STATE_FOCUSMOVING);        DBG_MSG("LENS_STATE_FOCUSMOVING/r/n");    // --> LENS_STATE_FOCUSMOVING    }    //gLensCtrlObj.pLens->focus_afterZoomMoving(0);    //if (category&FOCUS_PREEXC)    {        //Callback function        if(gLensCtrlObj.APICB!=NULL)        {            gLensCtrlObj.APICB(LENS_CB_FOCUS_START, NULL);        }        gLensCtrlObj.pLens->focus_doExc(ON, 0);    }    /* Move focus to 2M distance. */    #if 0    gLensCtrlObj.pLens->focus_go2(Lens_Focus_GetTable(Lens_Zoom_GetSection(ZOOM_CUR_SECTION)-1, 2));    #else    //gLensCtrlObj.pLens->focus_afterZoomMoving(0);    gLensCtrlObj.pLens->focus_afterZoomMoving(1);    #endif    //#NT#2010/08/19#Jeffery Chuang -end    if(Lens_Module_GetState() != LENS_STATE_ZOOMMOVING)    {        gLensCtrlObj.pLens->focus_doExc(OFF, 0);        Lens_Module_SetState(LENS_STATE_IDLE);        DBG_MSG("LENS_STATE_IDLE/r/n");    // --> LENS_STATE_IDLE    }    else // Don't turn off motor driver power.        LensCtrl_Focus_SetState(MOTOR_FOCUS_EXCITE_OFF,0);    //Callback function    if(gLensCtrlObj.APICB!=NULL)    {        gLensCtrlObj.APICB(LENS_CB_FOCUS_END, NULL);    }    return ERR_OK;}

/**    Get RAM disk Parameters*/static ER ramdsk_getParam(STRG_GET_PARAM_EVT uiEvt, UINT32 uiParam1, UINT32 uiParam2){    ER  eRet = E_NOSPT;    switch(uiEvt)    {    case STRG_GET_CAP_TAB:    {        memcpy((void *)uiParam1, (void *)&gRAMCap, sizeof(STRG_CAP));        eRet = E_OK;    }    break;    case STRG_GET_FAT_TABLE_PARAM:    {        UINT32 uiIndex=0;        PSTRG_FATINFO strgFATInfo = (PSTRG_FATINFO)uiParam2;        if(uiParam1 <= 8032)        {   uiIndex = STRG_FAT_SIZE_4MB_8MB;  }        else if ((uiParam1 > 8032) && (uiParam1 <= 16224))      // 8M        {   uiIndex = STRG_FAT_SIZE_8MB_16MB;  }        else if ((uiParam1 > 16224) && (uiParam1 <= 32448))     // 16M        {   uiIndex = STRG_FAT_SIZE_16MB_32MB;  }        else if ((uiParam1 > 32448) && (uiParam1 <= 64896))     // 32M        {   uiIndex = STRG_FAT_SIZE_32MB_64MB;  }        else if ((uiParam1 > 64896) && (uiParam1 <= 129792))    // 64M        {   uiIndex = STRG_FAT_SIZE_64MB_128MB;  }        else if ((uiParam1 > 129792) && (uiParam1 <= 259584))   // 128M        {   uiIndex = STRG_FAT_SIZE_128MB_256MB;  }        else if ((uiParam1 > 259584) && (uiParam1 <= 519168))   // 256M        {   uiIndex = STRG_FAT_SIZE_256MB_512MB;  }        else if ((uiParam1 > 519168) && (uiParam1 <= 1038336))  // 512M        {   uiIndex = STRG_FAT_SIZE_512MB_1024MB;  }        else if ((uiParam1 > 1038336) && (uiParam1 <= 2076672)) // 1024M        {   uiIndex = STRG_FAT_SIZE_1024MB_2048MB;  }        else if ((uiParam1 > 2076672) && (uiParam1 <= 4153344)) // 2048M        {   uiIndex = STRG_FAT_SIZE_2048MB_4096MB;  }        else if ((uiParam1 > 4153344) && (uiParam1 <= 8323072)) // 4096M        {   uiIndex = STRG_FAT_SIZE_4096MB_8192MB; }        else if((uiParam1 > 8323072) )        {   uiIndex = STRG_FAT_SIZE_8192MB_16384MB; }        strgFATInfo->uiHeadNum          = RamFATInfo[uiIndex][STRG_FAT_TBL_HEADNUM];        strgFATInfo->uiSectorNum        = RamFATInfo[uiIndex][STRG_FAT_TBL_SECTORNUM];        strgFATInfo->uiRelativeSector   = RamFATInfo[uiIndex][STRG_FAT_TBL_RELATIVESECTOR];        strgFATInfo->uiSectorPerCluster = RamFATInfo[uiIndex][STRG_FAT_TBL_SECPERCLUSTER];        strgFATInfo->uiResvSec          = RamFATInfo[uiIndex][STRG_FAT_TBL_RESERVEDSECTOR];        eRet = E_OK;    }    break;    default:        DBG_ERR("No Implement! uiEvt %d/r/n",uiEvt);        break;    }    return eRet;}

/*************************************************************************** *                                                                         * ***************************************************************************/int net_get_info(char *ifname, struct NET_CONFIG *netcfg){	struct ifreq ifr;	int skfd;	struct sockaddr_in *saddr;	if ( (skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {		DBG_ERR("socket error");		return -1;	}	saddr = (struct sockaddr_in *) &ifr.ifr_addr;	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);	if (ioctl(skfd, SIOCGIFADDR, &ifr) < 0) {		DBG_ERR("net_get_info: ioctl SIOCGIFADDR");		close(skfd);		return -1;	}	netcfg->ifaddr = saddr->sin_addr.s_addr;	DBG_NET("ifaddr=0x%x/n", netcfg->ifaddr);    	if (ioctl(skfd, SIOCGIFNETMASK, &ifr) < 0) {		DBG_ERR("net_get_info: ioctl SIOCGIFNETMASK");		close(skfd);		return -1;	}	netcfg->netmask = saddr->sin_addr.s_addr;	DBG_NET("netmask=0x%x/n", netcfg->netmask);    	if (ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0) {		DBG_ERR("net_get_info: ioctl SIOCGIFHWADDR");		close(skfd);		return -1;	}	memcpy(netcfg->mac, ifr.ifr_ifru.ifru_hwaddr.sa_data, IFHWADDRLEN);	DBG_NET("hwaddr=%02x:%02x:%02x:%02x:%02x:%02x/n", netcfg->mac[0],netcfg->mac[1],					netcfg->mac[2],netcfg->mac[3],netcfg->mac[4],netcfg->mac[5]);	close(skfd);	netcfg->gateway = net_get_gateway();	DBG_NET("gateway=0x%x/n", netcfg->gateway);    	netcfg->dns = net_get_dns();	return 0;}

static int isp_gpio_init(struct device_node *fdt_node, struct sensor_pwd_info *spinfo){    const char *sensors = NULL;    DBG_INFO("");    if (gpio_init(fdt_node, "reset-gpios", &spinfo->gpio_reset, 0)) {        goto fail;    }    if (of_property_read_string(fdt_node, "sensors", &sensors)) {        DBG_ERR("get sensors faild");        goto free_reset;    }    if (!strcmp(sensors, "front")) {        // default is power-down        if (gpio_init(fdt_node, "pwdn-front-gpios", &spinfo->gpio_front, 1)) {            goto free_reset;        }        spinfo->flag = SENSOR_FRONT;    } else if (!strcmp(sensors, "rear")) {        if (gpio_init(fdt_node, "pwdn-rear-gpios", &spinfo->gpio_rear, 1)) {            goto free_reset;        }        spinfo->flag = SENSOR_REAR;    } else if (!strcmp(sensors, "dual")) {        if (gpio_init(fdt_node, "pwdn-front-gpios", &spinfo->gpio_front, 1)) {            goto free_reset;        }        if (gpio_init(fdt_node, "pwdn-rear-gpios", &spinfo->gpio_rear, 1)) {            gpio_exit(&spinfo->gpio_front, 1);            goto free_reset;        }        spinfo->flag = SENSOR_DUAL;    } else {        DBG_ERR("sensors of dts is wrong");        goto free_reset;    }    return 0;  free_reset:    gpio_exit(&spinfo->gpio_reset, 0);  fail:    return -1;}

void System_OnStrgExit_FWS(void){    ER er;    er = FwSrv_Close();    if(er != FWSRV_ER_OK)    {        DBG_ERR("Close failed!/r/n");    }}

int setbaud_psam_card(psam_cos_t *pc){	u_char *buf = PSAM_COS_M(pc, buf);	if (SAM_SET_BUAD(PSAM_COS_M(pc, slot), PSAM_COS_M(pc, baud)) != 0)	{		DBG_ERR("Send setbaud fail! (slot: %d)!", PSAM_COS_M(pc, slot));		return -1;	}	if (SAM_GET_RESPONSE(PSAM_COS_M(pc, slot), buf) <= 0) 	{		DBG_ERR("Get setbaud response fail! (slot: %d)", PSAM_COS_M(pc, slot));		return -1;	}	return 0;}

static UINT32 WifiCmd_DispatchCmd(UINT32 cmd,WIFICMD_PAR_TYPE parType,UINT32 par,UINT32 *UserCB){    int i = 0;    UINT32 ret=0;    if(g_receiver)    {        while(g_pCmdTab[i].cmd != 0)        {            if(cmd == g_pCmdTab[i].cmd)            {                //UINT32 t1,t2;                //t1 = Perf_GetCurrent()/1000;                DBG_IND("cmd:%d evt:%x par:%d CB:%x wait:%x/r/n",g_pCmdTab[i].cmd,g_pCmdTab[i].event,par,g_pCmdTab[i].usrCB,g_pCmdTab[i].Waitflag);                if(g_pCmdTab[i].Waitflag)                {                    clr_flg(FLG_ID_WIFICMD, g_pCmdTab[i].Waitflag);                    g_result = 0;                }                if(gEventHandle && g_pCmdTab[i].event)                {                    if(parType==WIFICMD_PAR_NUM)                    {                        gEventHandle(g_pCmdTab[i].event,1,par);                    }                    else if(parType==WIFICMD_PAR_STR)                    {                        char  *parStr;//post event,data in stack would release                        parStr = WifiCmd_LockString();                        memset(parStr,'/0',WIFI_PAR_STR_LEN);                        sscanf((char *)par,"%s",parStr);                        gEventHandle(g_pCmdTab[i].event,1,parStr);                    }                    else                    {                        gEventHandle(g_pCmdTab[i].event,0);                    }                }                if(g_pCmdTab[i].Waitflag)                    ret = WifiCmd_WaitFinish(g_pCmdTab[i].Waitflag);                if(g_pCmdTab[i].usrCB)                    *UserCB = (UINT32)g_pCmdTab[i].usrCB;                //t2 = Perf_GetCurrent()/1000;                //DBG_ERR("time %d ms/r/n",t2-t1);                DBG_IND("ret %d/r/n",ret);                return ret;            }            i++;        }    }    else    {        DBG_ERR("should WifiCmd_ReceiveCmd enable/r/n");    }    return WIFI_CMD_NOT_FOUND;}

/** * @brief    start dhcp * @param    "char *ifname" : [IN]interface name * @return    pid */pid_t net_start_dhcpcd(char *ifname){    pid_t pid;    if ((pid = vfork()) == 0)    {        /* the child */        execlp(DHCPC_EXEC_PATH, DHCPC_EXEC_PATH, ifname, NULL);        DBG_ERR("exec dhcpcd failed");        _exit(0);    }    else if (pid < 0)    {        DBG_ERR("fork dhcpcd failed");        return  - 1;    }    return pid;}

void Lens_SetMDSignal(MD_SIGNAL signal, BOOL on){    if(gLensCtrlObj.pMotor)        gLensCtrlObj.pMotor->setSignal(signal,on);    else    {        DBG_ERR("Motor Obj not registered!/r/n");    }}

int get_file_size(char *file){	FILE *tmp;	int i = 0;	tmp = fopen(file, "rb");	DBG_ERR("file = %s", file);	DBG_ERR("file* = %p", tmp);	if (!tmp)		return 0;	fseek(tmp, 0, SEEK_END);	i = ftell(tmp);	DBG_ERR("size = %d", i);	fclose(tmp);	return i;}

/*************************************************************************** * Get a interface flag.                                                   * ***************************************************************************/int net_get_flag(char *ifname){	struct ifreq ifr;	int skfd;	if ( (skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {		DBG_ERR("socket error");		return -1;	}	strncpy(ifr.ifr_name, ifname, IFNAMSIZ);	if (ioctl(skfd, SIOCGIFFLAGS, &ifr) < 0) {		DBG_ERR("net_get_flag: ioctl SIOCGIFFLAGS");		close(skfd);		return -1;	}	close(skfd);	return ifr.ifr_flags;}

UINT32 DrvCARD2State(UINT32 StateID, UINT32 Value) // General Properties{    DBG_FUNC_BEGIN("/r/n");    if(StateID & DXGET)    {    UINT32 rvalue =  0;    StateID &= ~DXGET;    DBG_IND("get %08x/r/n", StateID);    switch(StateID)    {    case STORAGE_STATE_INSERT:        rvalue = DrvCARD2_DetStrgCard();        break;    case STORAGE_STATE_LOCK:        {        BOOL bLock = FALSE;        if(DrvCARD2_DetStrgCard())        {            bLock = DrvCARD2_DetStrgCardWP();        }        rvalue = bLock;        }        break;        break;    default:        DBG_ERR("state=0x%02X not support!/r/n", StateID);        break;    }    return rvalue;    }    else if(StateID & DXSET)    {    StateID &= ~DXSET;    DBG_IND("set %08x/r/n", StateID);    switch(StateID)    {    default:        DBG_ERR("state=0x%02X not support!/r/n", StateID);        break;    }    }    return DX_OK;}

INT32 Lens_Zoom_Stop(void){    UINT32 Status;    //#NT#2012/07/10#Isiah Chang -begin    //#NT#Correct Lens module state handler.    #if 0    if ((Lens_Module_GetState() == LENS_STATE_IDLE) || (Lens_Module_GetState() != LENS_STATE_ZOOMMOVING))    {        DBG_ERR("%s, state incorrect, (%d)/r/n",__func__,Lens_Module_GetState());        return ERR_OPERATION_FAIL;    }    #else    switch(Lens_Module_GetState())    {    case LENS_STATE_IDLE:        return ERR_OK;    case LENS_STATE_ZOOMMOVING:    case LENS_STATE_FOCUSMOVING:        break;    default:        DBG_ERR("%s, state incorrect, (%d)/r/n",__func__,Lens_Module_GetState());        return ERR_OPERATION_FAIL;    }    #endif    //#NT#2012/07/10#Isiah Chang -end    DBG_MSG("%s/r/n",__func__);    Status = gLensCtrlObj.pLens->zoom_release();    //Callback function    if(gLensCtrlObj.APICB!=NULL)    {        gLensCtrlObj.APICB(LENS_CB_ZOOM_END, NULL);    }    Lens_Module_SetState(LENS_STATE_IDLE);    DBG_MSG("LENS_STATE_IDLE/r/n");    // --> LENS_STATE_IDLE    if((Status>gLensCtrlObj.pLens->zoom_getMaxSection()) || (Status<gLensCtrlObj.pLens->zoom_getMinSection()))        return ERR_OPERATION_FAIL;    else        return ERR_OK;}

static int connect_acl_tdb(struct vfs_handle_struct *handle,				const char *service,				const char *user){	int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);	bool ok;	struct acl_common_config *config = NULL;	if (ret < 0) {		return ret;	}	if (!acl_tdb_init()) {		SMB_VFS_NEXT_DISCONNECT(handle);		return -1;	}	ok = init_acl_common_config(handle);	if (!ok) {		DBG_ERR("init_acl_common_config failed/n");		return -1;	}	/* Ensure we have the parameters correct if we're	 * using this module. */	DEBUG(2,("connect_acl_tdb: setting 'inherit acls = true' "		"'dos filemode = true' and "		"'force unknown acl user = true' for service %s/n",		service ));	lp_do_parameter(SNUM(handle->conn), "inherit acls", "true");	lp_do_parameter(SNUM(handle->conn), "dos filemode", "true");	lp_do_parameter(SNUM(handle->conn), "force unknown acl user", "true");	SMB_VFS_HANDLE_GET_DATA(handle, config,				struct acl_common_config,				return -1);	if (config->ignore_system_acls) {		DBG_NOTICE("setting 'create mask = 0666', "			   "'directory mask = 0777', "			   "'store dos attributes = yes' and all "			   "'map ...' options to 'no'/n");		lp_do_parameter(SNUM(handle->conn), "create mask", "0666");		lp_do_parameter(SNUM(handle->conn), "directory mask", "0777");		lp_do_parameter(SNUM(handle->conn), "map archive", "no");		lp_do_parameter(SNUM(handle->conn), "map hidden", "no");		lp_do_parameter(SNUM(handle->conn), "map readonly", "no");		lp_do_parameter(SNUM(handle->conn), "map system", "no");		lp_do_parameter(SNUM(handle->conn), "store dos attributes",				"yes");	}	return 0;}

VOIDwmainCRTStartup (    VOID    ){    PSVCHOST_OPTIONS lpOptions;    SERVICE_TABLE_ENTRYW *pServiceTable;    LPWSTR pszCmdLine;    /* Set a generic SEH filter and hard fail all critical errors */    SetUnhandledExceptionFilter(SvchostUnhandledExceptionFilter);    SetErrorMode(SEM_FAILCRITICALERRORS);    /* Initialize the heap allocator */    MemInit(GetProcessHeap());    /* Initialize the DLL database and lock */    InitializeListHead(&DllList);    InitializeCriticalSection(&ListLock);    /* Get the command-line and parse it to get the service group */    pszCmdLine = GetCommandLineW();    lpOptions = BuildCommandOptions(pszCmdLine);    if (lpOptions == NULL)    {        /* Without a valid command-line, there's nothing for us to do */        DBG_TRACE("Calling ExitProcess for %ws/n", pszCmdLine);        ExitProcess(0);    }    /* Now use the service group information to lookup all the services */    BuildServiceArray(lpOptions);    /* Convert the list of services in this group to the SCM format */    pServiceTable = BuildServiceTable();    if (pServiceTable == NULL)    {        /* This is critical, bail out without it */        MemFree(lpOptions);        return;    }    /* Initialize COM and RPC as needed for this service group */    if (CallPerInstanceInitFunctions(lpOptions) == FALSE)    {        /* Exit with a special code indicating COM/RPC setup has failed */        DBG_ERR("%s", "CallPerInstanceInitFunctions failed -- exiting!/n");        ExitProcess(1);    }    /* We're ready to go -- free the options buffer */    MemFree(lpOptions);    /* And call into ADVAPI32 to get our services going */    StartServiceCtrlDispatcherW(pServiceTable);}

PLENSCTRL_APPOBJ DrvLens_GetLensCtrlObj(void){    if(LensCtrlObj.pLens && LensCtrlObj.pMotor)        return &LensCtrlObj;    else    {        DBG_ERR("LensCtrl obj not initialized./r/n");        return NULL;    }}

BOOL UIStorageCheck_DCIMWritable(void){    UINT32 useFileDB =0;    useFileDB = UI_GetData(FL_IsUseFileDB);    if (useFileDB)    {        return TRUE;    }    else    {        char   DCIM_DIR[9] = "A://DCIM";        INT32 uiStatus = 0;        UINT8  ucAttrib = 0;        BOOL   ret = FALSE;        uiStatus = FileSys_GetAttrib(DCIM_DIR ,&ucAttrib);        if(uiStatus == FST_STA_OK)        {            if(ucAttrib & FS_ATTRIB_DIRECTORY)            {                if (UI_GetData(FL_CardStatus) == CARD_REMOVED)                    DBG_IND("SD Card is removed, DCIM is located on NAND./r/n");                if(ucAttrib & FS_ATTRIB_READ)                    DBG_ERR("A://DCIM Directory is READONLY./r/n");                else                {                    DBG_IND("A://DCIM Directory is existing and writable./r/n");                    ret = TRUE;                }            }            else                DBG_ERR("A://DCIM is not existing./r/n");        }        {            ret = TRUE;            DBG_IND("check_DCIM_writable: uiStatus=%d/r/n",uiStatus);        }        return ret;    }}

INT32 Lens_Focus_GetTable(UINT32 Section, UINT32 FocusDistance){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->focus_getTable(Section, FocusDistance);    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

UINT32 Lens_CheckLDSignal(LD_SIGNAL signal){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->getSignal(signal);    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

UINT32 Lens_Aperture_GetFNO(UINT32 ZoomSection,UINT32 IrisPos){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->aperture_getFNO(ZoomSection,IrisPos);    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

UINT32 Lens_Focus_GetLength_um(UINT32 ZoomSection){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->focus_getLength(ZoomSection);    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

INT32 Lens_Focus_GetRange(FOCUS_RANGE range){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->focus_getRange(range);    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

    void IO_InitADC(void)    {        if (adc_open(ADC_CH_VOLDET_BATTERY) != E_OK)        {            DBG_ERR("Can't open ADC channel for battery voltage detection/r/n");            return;        }        if (adc_open(ADC_CH_VOLDET_KEY1) != E_OK)        {            DBG_ERR("Can't open ADC channel for key key1 detection/r/n");            return;        }        if (adc_open(ADC_CH_VOLDET_KEY2) != E_OK)        {            DBG_ERR("Can't open ADC channel for key key1 detection/r/n");            return;        }        //650 Range is 250K Hz ~ 2M Hz        adc_setConfig(ADC_CONFIG_ID_OCLK_FREQ, 250000); //250K Hz        //battery voltage detection        adc_setChConfig(ADC_CH_VOLDET_BATTERY, ADC_CH_CONFIG_ID_SAMPLE_FREQ, 10000); //10K Hz, sample once about 100 us for CONTINUOUS mode        adc_setChConfig(ADC_CH_VOLDET_BATTERY, ADC_CH_CONFIG_ID_SAMPLE_MODE, (VOLDET_ADC_MODE) ? ADC_CH_SAMPLEMODE_CONTINUOUS : ADC_CH_SAMPLEMODE_ONESHOT);        adc_setChConfig(ADC_CH_VOLDET_BATTERY, ADC_CH_CONFIG_ID_INTEN, FALSE);        //key key1 detection        adc_setChConfig(ADC_CH_VOLDET_KEY1, ADC_CH_CONFIG_ID_SAMPLE_FREQ, 10000); //10K Hz, sample once about 100 us for CONTINUOUS mode        adc_setChConfig(ADC_CH_VOLDET_KEY1, ADC_CH_CONFIG_ID_SAMPLE_MODE, (VOLDET_ADC_MODE) ? ADC_CH_SAMPLEMODE_CONTINUOUS : ADC_CH_SAMPLEMODE_ONESHOT);        adc_setChConfig(ADC_CH_VOLDET_KEY1, ADC_CH_CONFIG_ID_INTEN, FALSE);        //key key2 detection        adc_setChConfig(ADC_CH_VOLDET_KEY2, ADC_CH_CONFIG_ID_SAMPLE_FREQ, 10000); //10K Hz, sample once about 100 us for CONTINUOUS mode        adc_setChConfig(ADC_CH_VOLDET_KEY2, ADC_CH_CONFIG_ID_SAMPLE_MODE, (VOLDET_ADC_MODE) ? ADC_CH_SAMPLEMODE_CONTINUOUS : ADC_CH_SAMPLEMODE_ONESHOT);        adc_setChConfig(ADC_CH_VOLDET_KEY2, ADC_CH_CONFIG_ID_INTEN, FALSE);        // Enable adc control logic        adc_setEnable(TRUE);        Delay_DelayMs(15); //wait ADC stable  //for pwr on speed up    }

/*************************************************************************** *                                                                         * ***************************************************************************/int net_renew_dhcpcd(pid_t pid){	if ( pid > 0 ) {		if ( kill(pid, SIGALRM) == 0 )			return 0;		DBG_ERR("net_disable_dhcpcd, kill error");	}	DBG("net_disable_dhcpcd, pid error/n");	return -1;}

IRIS_POS Lens_Aperture_GetPosition(void){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->aperture_getPosition();    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

INT32 Lens_Focus_GetPosition(void){    if(gLensCtrlObj.pLens)        return gLensCtrlObj.pLens->focus_getPostion();    else    {        DBG_ERR("Lens Obj not registered!/r/n");        return 0;    }}

struct ucl_config *read_ucl_xml(char const *file_path){	xmlNode *tmp = NULL;	xmlNode *cfg_node = NULL;	struct ucl_config *config = NULL;	LIBXML_TEST_VERSION	doc = xmlReadFile(file_path, NULL, 0);	if (doc == NULL) {		DBG_ERR("Cannot open %s/n", file_path);		return NULL;	}	root = xmlDocGetRootElement(doc);	assert(root != NULL);	for(tmp = root->children; tmp; tmp = tmp->next)	{			if (strcasecmp(tmp->name, "cfg") != 0) 			continue;		cfg_node = tmp->children;		cfg_node = cfg_node->next;		config = malloc(sizeof(struct ucl_config));		for(; cfg_node; cfg_node = cfg_node->next) {			int index;			if(cfg_node->type != XML_ELEMENT_NODE)				continue;			if (strcasecmp(xmlGetProp(cfg_node, "name"), "BootStrap") == 0)			{				index = STATE_BOOTSTRAP;				strcpy(config->states[index].name, "BootStrap");			}			if (strcasecmp(xmlGetProp(cfg_node, "name"), "Updater") == 0)			{				index = STATE_UPDATER;				strcpy(config->states[index].name, "Updater");			}			strcpy(config->states[index].device, xmlGetProp(cfg_node, "dev"));			config->states[index].vid = strtol(xmlGetProp(cfg_node, "vid"), NULL, 16);			config->states[index].pid = strtol(xmlGetProp(cfg_node, "pid"), NULL, 16);		}	}	return config;}