iic_mdd.cpp

Samsung公司S3C6400芯片的BSP源码包

BOOL
IIC_Close(PHW_OPEN_INFO pOpenContext)	//Context pointer returned from IIC_Open
{
    PHW_INIT_INFO  pInitContext = pOpenContext->pInitContext;

    BOOL            RetCode = TRUE;

    RETAILMSG (MSG_FUNCTION, (TEXT("+IIC_Close\r\n")));

    if ( !pInitContext ) {
        RETAILMSG (MSG_ERROR, (TEXT("!!IIC_Close: pInitContext == NULL!!\r\n")));
        SetLastError(ERROR_INVALID_HANDLE);
        return(FALSE);
    }

    // Use the OpenCS to make sure we don't collide with an in-progress open.
    EnterCriticalSection(&(pInitContext->OpenCS));
    // We do special for Power Manger and Device Manager.
    if (pOpenContext->AccessCode & DEVACCESS_BUSNAMESPACE) {


        // Remove the entry from the linked list
        RemoveEntryList(&pOpenContext->llist);

        LocalFree( pOpenContext );
    }
    else
    if ( pInitContext->OpenCnt ) {
        --(pInitContext->OpenCnt);

	    if ( ! pInitContext->OpenCnt ) {
	        RETAILMSG(MSG_INFO,
	                 (TEXT("IIC_Close: Last Close : Do Clost x%X\n\r"),
	                  pOpenContext));
	                  
			if ( !HW_CloseLast(pOpenContext) ) {
	            RETAILMSG (MSG_ERROR, (TEXT("HW_CloseLast failed.\r\n")));
	        }        
	        
	        HW_PowerDown(pInitContext);          
	    }   

        // If this was the handle with access permission, remove pointer
        if ( pOpenContext == pInitContext->pAccessOwner ) {
            RETAILMSG(MSG_INFO,
                     (TEXT("IIC_Close: Closed access owner handle\n\r"),
                      pOpenContext));

            pInitContext->pAccessOwner = NULL;
        }

        // Remove the entry from the linked list
        RemoveEntryList(&pOpenContext->llist);

        // Free all data allocated in open
        LocalFree( pOpenContext );
    } else {
        RETAILMSG (MSG_ERROR, (TEXT("!!Close of non-open serial port\r\n")));
        SetLastError(ERROR_INVALID_HANDLE);
        RetCode = FALSE;
    }

    // OK, other inits/opens can go ahead.
    LeaveCriticalSection(&(pInitContext->OpenCS));

    RETAILMSG (MSG_FUNCTION, (TEXT("-IIC_Close\r\n")));
    return(RetCode);
}


//////////
// Function Name : IIC_IOControl
// Function Description : Device IO control routine.
// Input : //      	DWORD | pOpenContext | value returned from IIC_Open call
//     				DWORD | dwCode | io control code to be performed
//      			PBYTE | pBufIn | input data to the device
//      			DWORD | dwLenIn | number of bytes being passed in
//      			PBYTE | pBufOut | output data from the device
//      			DWORD | dwLenOut |maximum number of bytes to receive from device
//      			PDWORD | pdwActualOut | actual number of bytes received from device
// Output : TRUE if success; FALSE if failure.
// Note : 
// Version : v0.1


BOOL
IIC_IOControl(PHW_OPEN_INFO pOpenContext,
              DWORD dwCode, PBYTE pBufIn,
              DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,
              PDWORD pdwActualOut)
{
    BOOL            RetVal           = TRUE;        // Initialize to success
    PHW_INIT_INFO  	pInitContext; //= pOpenContext->pInitContext;

    if (pOpenContext==NULL) {
        SetLastError (ERROR_INVALID_HANDLE);
        return(FALSE);
    }
    pInitContext = pOpenContext->pInitContext;
    if ( pInitContext ) {

    } else {
        SetLastError (ERROR_INVALID_HANDLE);
        return(FALSE);
    }

    RETAILMSG (MSG_FUNCTION,
              (TEXT("+IIC_IOControl(0x%X, %d, 0x%X, %d, 0x%X, %d, 0x%X)\r\n"),
               pOpenContext, dwCode, pBufIn, dwLenIn, pBufOut,
               dwLenOut, pdwActualOut));
   
    if ( !pInitContext->OpenCnt ) {
        RETAILMSG (MSG_ERROR,
                  (TEXT(" IIC_IOControl - device was closed\r\n")));
        SetLastError (ERROR_INVALID_HANDLE);
        return(FALSE);
    }   
    
    // Make sure the caller has access permissions
    // NOTE : Pay attention here.  I hate to make this check repeatedly
    // below, so I'll optimize it here.  But as you add new ioctl's be
    // sure to account for them in this if check.
    if ( !( (dwCode == IOCTL_IIC_READ) ||
            (dwCode == IOCTL_IIC_WRITE) ||
            (dwCode == IOCTL_IIC_SET_CLOCK) ||
            (dwCode == IOCTL_IIC_GET_CLOCK) ||
            (dwCode == IOCTL_IIC_SET_MODE) ||
            (dwCode == IOCTL_IIC_GET_MODE) ||
            (dwCode == IOCTL_IIC_SET_FILTER) ||
            (dwCode == IOCTL_IIC_GET_FILTER) ||   
            (dwCode == IOCTL_IIC_SET_DELAY) ||
            (dwCode == IOCTL_IIC_GET_DELAY) ||                                       
            (dwCode == IOCTL_POWER_CAPABILITIES) ||
            (dwCode == IOCTL_POWER_QUERY) ||
            (dwCode == IOCTL_POWER_SET)) ) {
        // If not one of the above operations, then read or write
        // access permissions are required.
        if ( !(pOpenContext->AccessCode & (GENERIC_READ | GENERIC_WRITE) ) ) {
            RETAILMSG(MSG_ERROR,
                     (TEXT("IIC_Ioctl: Ioctl %x access permission failure x%X\n\r"),
                      dwCode, pOpenContext->AccessCode));
            SetLastError (ERROR_INVALID_ACCESS);
            return(FALSE);
		}
	}

   
	switch ( dwCode ) {  
	case IOCTL_POWER_CAPABILITIES:
		{
			PPOWER_CAPABILITIES ppc;

			if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(POWER_CAPABILITIES)) )
			{
				RetVal = FALSE;
       			SetLastError (ERROR_INVALID_PARAMETER);				
				break;
			}

			ppc = (PPOWER_CAPABILITIES)pBufOut;

			memset(ppc, 0, sizeof(POWER_CAPABILITIES));

			// support D0, D4
			ppc->DeviceDx = 0x11;

			// no wake
			// no inrush

			// Report our nominal power consumption in uAmps rather than mWatts.
			ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;

			//ppc->Power[D0] = 56000;

			*pdwActualOut = sizeof(POWER_CAPABILITIES);
		}
		break;	
	case IOCTL_POWER_QUERY:
		break;
	case IOCTL_POWER_SET:
	/*
		{
			CEDEVICE_POWER_STATE NewDx;
			RETAILMSG(1,(TEXT("[IIC]IOCTL_POWER_SET\n")));

			if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) )
			{
				RetVal = FALSE;
       			SetLastError (ERROR_INVALID_PARAMETER);				
				break;
			}

			NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;

			if ( VALID_DX(NewDx) )
			{

				switch ( NewDx )
				{
				case D0:
					if (g_Dx != D0)
					{
						HW_PowerUp(pInitContext);
						g_Dx = D0;
					}
					break;
				default:
					if (g_Dx != (_CEDEVICE_POWER_STATE)D4)
					{
						HW_PowerDown(pInitContext);
						g_Dx = (_CEDEVICE_POWER_STATE)D4;
					}
					break;
				}

				// return our state
				*(PCEDEVICE_POWER_STATE)pBufOut = g_Dx;


				*pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
			}
			else
			{
				RetVal = FALSE;
       			SetLastError (ERROR_INVALID_PARAMETER);		
			}
		}	
		*/	
		break;
	case IOCTL_IIC_WRITE:
        if ( (dwLenIn < sizeof(IIC_IO_DESC)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }		
    	EnterCriticalSection(&(pInitContext->CritSec));	
    	if(HW_Write(pOpenContext, (PIIC_IO_DESC)pBufIn))
    	{
    		// success
    	}
    	else
    	{
    		SetLastError(ERROR_TIMEOUT);
            RetVal = FALSE;	    		
    	}
    	LeaveCriticalSection(&(pInitContext->CritSec));	
		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;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }			
	    EnterCriticalSection(&(pInitContext->CritSec));	
	    if(HW_Read(pOpenContext, (PIIC_IO_DESC)pBufIn, (PIIC_IO_DESC)pBufOut))
	    {
	    	// success
			*pdwActualOut = sizeof(IIC_IO_DESC);		    	    	
	    }
	    else
	    {
	    	SetLastError(ERROR_TIMEOUT);
	    	*pdwActualOut = 0;
            RetVal = FALSE;	    	
	    }
	    LeaveCriticalSection(&(pInitContext->CritSec));	
        
		break;
				
	case IOCTL_IIC_SET_CLOCK:	
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }	
		pOpenContext->PDDContextVal.Clock = *(UINT32*)pBufIn;
		HW_SetClock(pOpenContext);
		pOpenContext->DirtyBit = 1;				
		break;
		
	case IOCTL_IIC_GET_CLOCK:	
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

		*(UINT32*)pBufIn = pOpenContext->PDDContextVal.Clock;
        // Return the size
        *pdwActualOut = sizeof(UINT32);		
		break;
		
	case IOCTL_IIC_SET_MODE:
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }	
		pOpenContext->PDDContextVal.ModeSel = (IIC_MODE)*(UINT32*)pBufIn;	
		pOpenContext->DirtyBit = 1;					
		break;
				
	case IOCTL_IIC_GET_MODE:		
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

		*(UINT32*)pBufIn = pOpenContext->PDDContextVal.ModeSel;
        // Return the size
        *pdwActualOut = sizeof(UINT32);		
		break;
		
	case IOCTL_IIC_SET_FILTER:		
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }	
		pOpenContext->PDDContextVal.FilterEnable = *(UINT32*)pBufIn;
		pOpenContext->DirtyBit = 1;						
		break;
		
	case IOCTL_IIC_GET_FILTER:	
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

		*(UINT32*)pBufIn = pOpenContext->PDDContextVal.FilterEnable;
        // Return the size
        *pdwActualOut = sizeof(UINT32);		
		break;
		
	case IOCTL_IIC_SET_DELAY:		
        if ( (dwLenIn < sizeof(UINT32)) || (NULL == pBufIn) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }	
		pOpenContext->PDDContextVal.Delay = (IIC_DELAY)*(UINT32*)pBufIn;
		pOpenContext->DirtyBit = 1;						
		break;
																
	case IOCTL_IIC_GET_DELAY:		
        if ( (dwLenOut < sizeof(UINT32)) || (NULL == pBufOut) ||
             (NULL == pdwActualOut) ) {
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            RETAILMSG (MSG_ERROR, (TEXT(" Invalid parameter\r\n")));
            break;
        }

		*(UINT32*)pBufIn = pOpenContext->PDDContextVal.Delay;
        // Return the size
        *pdwActualOut = sizeof(UINT32);		
		break;							
	}
    
    RETAILMSG (MSG_FUNCTION|(RetVal == FALSE?MSG_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);
}