Пример #1
0
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;
}
Пример #2
0
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;
}
Пример #3
0
/*
    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;
}
Пример #4
0
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;
}
Пример #5
0
/**
    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;
}
Пример #6
0
/***************************************************************************
 *                                                                         *
 ***************************************************************************/
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;

}
Пример #7
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;
}
Пример #8
0
void System_OnStrgExit_FWS(void)
{
    ER er;
    er = FwSrv_Close();
    if(er != FWSRV_ER_OK)
    {
        DBG_ERR("Close failed!\r\n");
    }
}
Пример #9
0
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;
}
Пример #10
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;

}
Пример #11
0
/**
 * @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;
}
Пример #12
0
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");
    }
}
Пример #13
0
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;
}
Пример #14
0
/***************************************************************************
 * 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;
}
Пример #15
0
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;
}
Пример #16
0
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;
}
Пример #17
0
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;
}
Пример #18
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);
}
Пример #19
0
PLENSCTRL_APPOBJ DrvLens_GetLensCtrlObj(void)
{
    if(LensCtrlObj.pLens && LensCtrlObj.pMotor)
        return &LensCtrlObj;
    else
    {
        DBG_ERR("LensCtrl obj not initialized.\r\n");
        return NULL;
    }
}
Пример #20
0
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;
    }
}
Пример #21
0
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;
    }
}
Пример #22
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;
    }
}
Пример #23
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;
    }
}
Пример #24
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;
    }
}
Пример #25
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;
    }
}
Пример #26
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
    }
Пример #27
0
/***************************************************************************
 *                                                                         *
 ***************************************************************************/
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;
}
Пример #28
0
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;
    }
}
Пример #29
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;
    }
}
Пример #30
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;
}