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; }
VOID wmainCRTStartup ( 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; }