示例#1
0
/*********************************************************************************************************
** 函数名称: _hotplugDevCreate
** 功能描述: 安装 hotplug 消息设备
** 输 入  : NONE
** 输 出  : 设备是否创建成功
** 全局变量: 
** 调用模块: 
                                           API 函数
*********************************************************************************************************/
INT  _hotplugDevCreate (VOID)
{
    if (_G_iHotplugDrvNum <= 0) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
        _ErrorHandle(ERROR_IO_NO_DRIVER);
        return  (PX_ERROR);
    }
    
    _G_hotplugdev.HOTPDEV_plineFile = LW_NULL;
    _G_hotplugdev.HOTPDEV_ulMutex   = API_SemaphoreMCreate("hotplug_lock", LW_PRIO_DEF_CEILING, 
                                                           LW_OPTION_DELETE_SAFE | 
                                                           LW_OPTION_INHERIT_PRIORITY |
                                                           LW_OPTION_OBJECT_GLOBAL,
                                                           LW_NULL);
    if (_G_hotplugdev.HOTPDEV_ulMutex == LW_OBJECT_HANDLE_INVALID) {
        return  (PX_ERROR);
    }
    
    SEL_WAKE_UP_LIST_INIT(&_G_hotplugdev.HOTPDEV_selwulList);
    
    if (iosDevAddEx(&_G_hotplugdev.HOTPDEV_devhdrHdr, LW_HOTPLUG_DEV_PATH, 
                    _G_iHotplugDrvNum, DT_CHR) != ERROR_NONE) {
        API_SemaphoreMDelete(&_G_hotplugdev.HOTPDEV_ulMutex);
        SEL_WAKE_UP_LIST_TERM(&_G_hotplugdev.HOTPDEV_selwulList);
        return  (PX_ERROR);
    }
    
    return  (ERROR_NONE);
}
示例#2
0
文件: pipe.c 项目: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: API_PipeDevCreate
** 功能描述: 创建一个管道设备
** 输 入  : 
**           pcName                        管道名称
**           ulNMessages                   管道中消息数量
**           stNBytes                      每一条消息的最大字节数
** 输 出  : ERROR
** 全局变量: 
** 调用模块: 
                                           API 函数
*********************************************************************************************************/
LW_API 
INT  API_PipeDevCreate (PCHAR  pcName, 
                        ULONG  ulNMessages, 
                        size_t stNBytes)
{
    REGISTER PLW_PIPE_DEV        p_pipedev;
    
    if (LW_CPU_GET_CUR_NESTING()) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
        _ErrorHandle(ERROR_KERNEL_IN_ISR);
        return  (PX_ERROR);
    }
    
    if (_G_iPipeDrvNum <= 0) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
        _ErrorHandle(ERROR_IO_NO_DRIVER);
        return  (PX_ERROR);
    }
    
    p_pipedev = (PLW_PIPE_DEV)__SHEAP_ALLOC(sizeof(LW_PIPE_DEV));
    if (p_pipedev == LW_NULL) {
        _DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
        _ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
        return  (PX_ERROR);
    }
    lib_bzero(p_pipedev, sizeof(LW_PIPE_DEV));
    
    p_pipedev->PIPEDEV_iAbortFlag = 0;
    p_pipedev->PIPEDEV_ulRTimeout = LW_OPTION_WAIT_INFINITE;             /*  初始化为永久等待           */
    p_pipedev->PIPEDEV_ulWTimeout = LW_OPTION_WAIT_INFINITE;             /*  初始化为永久等待           */
    
    p_pipedev->PIPEDEV_hWriteLock = API_SemaphoreBCreate("pipe_wsync", 
                                                          LW_TRUE,
                                                          _G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
                                                          LW_NULL);
    if (!p_pipedev->PIPEDEV_hWriteLock) {
        __SHEAP_FREE((PVOID)p_pipedev);
        return  (PX_ERROR);
    }

    p_pipedev->PIPEDEV_hMsgQueue  = API_MsgQueueCreate("pipe_msg",
                                                       ulNMessages, stNBytes,
                                                       _G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
                                                       LW_NULL);
    if (!p_pipedev->PIPEDEV_hMsgQueue) {
        API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
        __SHEAP_FREE((PVOID)p_pipedev);
        return  (PX_ERROR);
    }
    
    SEL_WAKE_UP_LIST_INIT(&p_pipedev->PIPEDEV_selwulList);
    
    if (iosDevAddEx(&p_pipedev->PIPEDEV_devhdrHdr, pcName, _G_iPipeDrvNum, DT_FIFO) != ERROR_NONE) {
        API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
        API_MsgQueueDelete(&p_pipedev->PIPEDEV_hMsgQueue);
        SEL_WAKE_UP_LIST_TERM(&p_pipedev->PIPEDEV_selwulList);
        __SHEAP_FREE((PVOID)p_pipedev);
        _DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
        _ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
        return  (PX_ERROR);
    }
    
    p_pipedev->PIPEDEV_timeCreate = lib_time(LW_NULL);
    
    return  (ERROR_NONE);
}
示例#3
0
文件: can.c 项目: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: __canDevInit
** 功能描述: 创建 CAN 设备
** 输 入  :
**           pcanDev           CAN 设备
**           uiRdFrameSize     接收缓冲区大小
**           uiWrtFrameSize    发送缓冲区大小
** 输 出  : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __canDevInit (__CAN_DEV *pcanDev,
                         UINT       uiRdFrameSize,
                         UINT       uiWrtFrameSize)
{
    REGISTER INT    iErrLevel = 0;

    pcanDev->CAN_ulSendTimeout = LW_OPTION_WAIT_INFINITE;               /*  初始化为永久等待            */
    pcanDev->CAN_ulRecvTimeout = LW_OPTION_WAIT_INFINITE;               /*  初始化为永久等待            */

    pcanDev->CAN_pcanqRecvQueue = __canInitQueue(uiRdFrameSize);        /*  创建读缓冲区                */
    if (pcanDev->CAN_pcanqRecvQueue == LW_NULL) {                       /*  创建失败                    */
        _DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
        _ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
        return  (PX_ERROR);
    }

    pcanDev->CAN_pcanqSendQueue = __canInitQueue(uiWrtFrameSize);       /*  创建读缓冲区                */
    if (pcanDev->CAN_pcanqSendQueue == LW_NULL) {                       /*  创建失败                    */
        _DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
        _ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
        iErrLevel = 1;
        goto    __error_handle;
    }
    pcanDev->CAN_canstatWriteState.CANSTAT_bBufEmpty = LW_TRUE;         /*  发送队列空                  */
    pcanDev->CAN_uiBusState                         = CAN_DEV_BUS_ERROR_NONE;
    /*  发送队列空                  */
    pcanDev->CAN_ulRcvSemB = API_SemaphoreBCreate("can_rsync",
                             LW_FALSE,
                             LW_OPTION_WAIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
                             LW_NULL);             /*  读同步                      */
    if (!pcanDev->CAN_ulRcvSemB) {
        iErrLevel = 2;
        goto    __error_handle;
    }

    pcanDev->CAN_ulSendSemB = API_SemaphoreBCreate("can_wsync",
                              LW_TRUE,
                              LW_OPTION_WAIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
                              LW_NULL);            /*  写同步                      */
    if (!pcanDev->CAN_ulSendSemB) {
        iErrLevel = 3;
        goto    __error_handle;
    }

    pcanDev->CAN_ulMutexSemM = API_SemaphoreMCreate("can_lock",
                               LW_PRIO_DEF_CEILING,
                               (LW_OPTION_WAIT_FIFO |
                                LW_OPTION_DELETE_SAFE |
                                LW_OPTION_INHERIT_PRIORITY |
                                LW_OPTION_OBJECT_GLOBAL),
                               LW_NULL);           /*  互斥访问控制信号量          */
    if (!pcanDev->CAN_ulMutexSemM) {
        iErrLevel = 4;
        goto    __error_handle;
    }

    SEL_WAKE_UP_LIST_INIT(&pcanDev->CAN_selwulList);                    /*  初始化 select 等待链        */

    LW_SPIN_INIT(&pcanDev->CAN_slLock);                                 /*  初始化自旋锁                */

    return  (ERROR_NONE);

__error_handle:
    if (iErrLevel > 3) {
        API_SemaphoreBDelete(&pcanDev->CAN_ulSendSemB);                 /*  删除写同步                  */
    }
    if (iErrLevel > 2) {
        API_SemaphoreBDelete(&pcanDev->CAN_ulRcvSemB);                  /*  删除读同步                  */
    }
    if (iErrLevel > 1) {
        __canDeleteQueue(pcanDev->CAN_pcanqSendQueue);                  /*  删除读缓冲区                */
    }
    if (iErrLevel > 0) {
        __canDeleteQueue(pcanDev->CAN_pcanqRecvQueue);                  /*  删除写缓冲区                */
    }
    return  (PX_ERROR);
}