iic_mdd.cpp

6410BSP3

                return FALSE;
            }

            *pdwActualOut = sizeof(POWER_CAPABILITIES);
        }
        break;    
    case IOCTL_POWER_QUERY:
        break;
    case IOCTL_POWER_SET:
        break;
    case IOCTL_IIC_WRITE:
        if ( (dwLenIn < sizeof(IIC_IO_DESC)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }        

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_I_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_WRITE for IN buf.\r\n")));
            return FALSE;
        }

        EnterCriticalSection(&(pInitContext->CritSec));
        if((HW_Write(pOpenContext, (PIIC_IO_DESC)pMarshalledInBuf))==NULL)
        {
            SetLastError(ERROR_TIMEOUT);
            RetVal = FALSE;                
        }
        LeaveCriticalSection(&(pInitContext->CritSec));    

        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_I_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_WRITE for IN buf.\r\n")));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_READ:    
        if ( (dwLenIn < sizeof(IIC_IO_DESC)) || (NULL == pBufIn) || (dwLenOut < sizeof(IIC_IO_DESC)) || (NULL == pBufOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }            

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_I_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_READ for IN buf.\r\n")));
            return FALSE;
        }
        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pBufOut, dwLenOut, ARG_O_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_READ for OUT buf.\r\n")));
            return FALSE;
        }

        EnterCriticalSection(&(pInitContext->CritSec));    
        if(HW_Read(pOpenContext, (PIIC_IO_DESC)pMarshalledInBuf, (PIIC_IO_DESC)pMarshalledOutBuf))
        {
            // success
            *pdwActualOut = sizeof(IIC_IO_DESC);                        
        }
        else
        {
            SetLastError(ERROR_TIMEOUT);
            *pdwActualOut = 0;
            RetVal = FALSE;            
        }
        LeaveCriticalSection(&(pInitContext->CritSec));    
        
        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_I_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_READ for IN buf.\r\n")));
            return FALSE;
        }
        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pBufOut, dwLenOut, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_READ for OUT buf.\r\n")));
            return FALSE;
        }

        break;
                
    case IOCTL_IIC_SET_CLOCK:    
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

        __try
        {
            EnterCriticalSection(&(pInitContext->CritSec));
            pOpenContext->PDDContextVal.Clock = *(UINT32*)pBufIn;
            HW_SetClock(pOpenContext);
            pOpenContext->DirtyBit = TRUE;
            LeaveCriticalSection(&(pInitContext->CritSec));
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(1, (L"[IOCTL_IIC_SET_CLOCK] exception...\n"));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_GET_CLOCK:    
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_GET_CLOCK for IN buf.\r\n")));
            return FALSE;
        }

        *(UINT32*)pMarshalledInBuf = pOpenContext->PDDContextVal.Clock;
        // Return the size
        *pdwActualOut = sizeof(UINT32);        

        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_GET_CLOCK for IN buf.\r\n")));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_SET_MODE:
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }    

        __try
        {
            pOpenContext->PDDContextVal.ModeSel = (IIC_MODE)*(UINT32*)pBufIn;
            pOpenContext->DirtyBit = TRUE;
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(1, (L"[IOCTL_IIC_SET_MODE] exception...\n"));
            return FALSE;
        }
        break;
                
    case IOCTL_IIC_GET_MODE:        
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_GET_MODE for IN buf.\r\n")));
            return FALSE;
        }

        *(UINT32*)pMarshalledInBuf = pOpenContext->PDDContextVal.ModeSel;
        // Return the size
        *pdwActualOut = sizeof(UINT32);        

        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_GET_MODE for IN buf.\r\n")));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_SET_FILTER:        
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }    

        __try
        {
            pOpenContext->PDDContextVal.FilterEnable = *(UINT32*)pBufIn;
            pOpenContext->DirtyBit = TRUE;
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(1, (L"[IOCTL_IIC_SET_FILTER] exception...\n"));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_GET_FILTER:    
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_GET_FILTER for IN buf.\r\n")));
            return FALSE;
        }

        *(UINT32*)pMarshalledInBuf = pOpenContext->PDDContextVal.FilterEnable;
        // Return the size
        *pdwActualOut = sizeof(UINT32);        

        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_GET_FILTER for IN buf.\r\n")));
            return FALSE;
        }
        break;
        
    case IOCTL_IIC_SET_DELAY:        
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }    

        __try
        {
            pOpenContext->PDDContextVal.Delay = (IIC_DELAY)*(UINT32*)pBufIn;
            pOpenContext->DirtyBit = TRUE;
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(1, (L"[IOCTL_IIC_SET_DELAY] exception...\n"));
            return FALSE;
        }
        break;
                                                                
    case IOCTL_IIC_GET_DELAY:        
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            DEBUGMSG (ZONE_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

        if(FAILED(CeOpenCallerBuffer(&pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeOpenCallerBuffer failed in IOCTL_IIC_GET_DELAY for IN buf.\r\n")));
            return FALSE;
        }

        *(UINT32*)pMarshalledInBuf = pOpenContext->PDDContextVal.Delay;
        // Return the size
        *pdwActualOut = sizeof(UINT32);        

        if(FAILED(CeCloseCallerBuffer(pMarshalledInBuf, pBufIn, dwLenIn, ARG_IO_PTR)))
        {
            RETAILMSG(1, (TEXT("IIC_IOControl: CeCloseCallerBuffer failed in IOCTL_IIC_GET_DELAY for IN buf.\r\n")));
            return FALSE;
        }
        break;                            
    }
    
    DEBUGMSG (ZONE_FUNCTION|(RetVal == FALSE?ZONE_ERROR:0),
              (TEXT("-IIC_IOControl %s Ecode=%d (len=%d)\r\n"),
               (RetVal == TRUE) ? TEXT("Success") : TEXT("Error"),
               GetLastError(), (NULL == pdwActualOut) ? 0 : *pdwActualOut));

    return(RetVal);        
}

void IIC_PowerUp(
            PHW_INIT_INFO    pInitContext                        /* Context pointer returned from IIC_Init*/
)
{
    HW_PowerUp(pInitContext);
}

void IIC_PowerDown(
            PHW_INIT_INFO    pInitContext                        /* Context pointer returned from IIC_Init*/
)
{
    HW_PowerDown(pInitContext);
}