pindriver.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//-----------------------------------------------------------------------------
//
// Copyright (C) 2003-2004, MOTOROLA, INC. All Rights Reserved
// THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
// BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
// MOTOROLA, INC.
//
//------------------------------------------------------------------------------
//
//  Copyright (C) 2004-2006, Freescale Semiconductor, Inc. All Rights Reserved.
//  THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
//  AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------
//
//  File:  PinDriver.cpp
//
//  Implementation of Pin driver interface
//
//------------------------------------------------------------------------------
#include <windows.h>
#include <ceddk.h>
#include <devload.h>
#include <NKIntr.h>
#include <camera.h>
#include <camera_ext.h>
#include "csp.h"
#include "prp.h"
#include "PrpClass.h"
#include "cameradbg.h"
#include "PinDriver.h"

//------------------------------------------------------------------------------
// External Functions
extern BOOL BSPCameraMemCpy(LPVOID pDst, LPCVOID pSrc, DWORD cbSize); 


//------------------------------------------------------------------------------
// External Variables


//------------------------------------------------------------------------------
// Defines


//------------------------------------------------------------------------------
// Types


//------------------------------------------------------------------------------
// Global Variables


//------------------------------------------------------------------------------
// Local Variables


//------------------------------------------------------------------------------
// Local Functions

EXTERN_C DWORD
PIN_Init(
    LPCTSTR Context,
    LPVOID lpvBusContext
    )
{    
    DEBUGMSG( ZONE_INIT, ( _T("PIN_Init: context %s\n"), Context ) );

    PPININITHANDLE pPinInitDev = new PININITHANDLE;
    
    if (NULL != pPinInitDev)
    {
        pPinInitDev->pCamDevice = reinterpret_cast<PCAMERADEVICE>(lpvBusContext);

        if (NULL == pPinInitDev->pCamDevice)
        {
            SetLastError( ERROR_INVALID_HANDLE );
            SAFEDELETE(pPinInitDev);
            RETAILMSG(ZONE_INIT|ZONE_ERROR, (_T("PIN_Init: Initialization Failed")));
        }
    }
    else
    {
        SetLastError(ERROR_OUTOFMEMORY);
    }

    DEBUGMSG( ZONE_INIT, ( _T("PIN_Init: returning 0x%08x\r\n"), reinterpret_cast<DWORD>( pPinInitDev ) ) );

    return reinterpret_cast<DWORD>( pPinInitDev );
}


EXTERN_C BOOL
PIN_Deinit(
    DWORD dwContext
    )
{
    DEBUGMSG( ZONE_INIT, ( _T("PIN_Deinit\r\n") ) );

    PPININITHANDLE pPinInitDev = reinterpret_cast<PPININITHANDLE>( dwContext );
    SAFEDELETE( pPinInitDev ) ;

    return TRUE;
}


EXTERN_C BOOL
PIN_IOControl(
    DWORD  dwContext,
    DWORD  Ioctl,
    PUCHAR pInBufUnmapped,
    DWORD  InBufLen, 
    PUCHAR pOutBufUnmapped,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
   )
{
    DEBUGMSG(ZONE_FUNCTION, ( _T("PIN_IOControl(%08x): IOCTL:0x%x, InBuf:0x%x, InBufLen:%d, OutBuf:0x%x, OutBufLen:0x%x)\r\n"), dwContext, Ioctl, pInBufUnmapped, InBufLen, pOutBufUnmapped, OutBufLen ) );

    DWORD      dwErr      = ERROR_INVALID_PARAMETER;
    BOOL       bRc        = FALSE;
    PPINDEVICE pPinDevice = reinterpret_cast<PPINDEVICE>( dwContext );
    UCHAR * pInBuf = NULL;
    UCHAR * pOutBuf = NULL;

    pInBuf = pInBufUnmapped;    

    pOutBuf = pOutBufUnmapped;
	        
    switch ( Ioctl )
    {
     case IOCTL_CS_PROPERTY:
        DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x): IOCTL_CS_PROPERTY\r\n"), dwContext ) );

        __try 
        {
            CSPROPERTY csProp = {0};

            if ( ( NULL == pInBuf )
                 || ( InBufLen < sizeof ( CSPROPERTY ) )
                 || ( NULL == pdwBytesTransferred ) )
            {
                break;
            }
            
            if( !BSPCameraMemCpy( &csProp, pInBuf, sizeof( CSPROPERTY )))
            {
                RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): IOCTL_CS_PROPERTY. MapCallerPtr failed.\r\n"), dwContext));
                break;
            }

             if ( TRUE == IsEqualGUID( csProp.Set, CSPROPSETID_Connection ) )
            {
                 dwErr = pPinDevice->PinHandleConnectionRequests( &csProp, pOutBuf, OutBufLen, pdwBytesTransferred );
            }
            else
            {
                DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): Unsupported PropertySet Request for IOCTL_CS_PROPERTY%u\r\n"), dwContext, csProp.Set ) );
                dwErr = ERROR_NOT_SUPPORTED;
            }
        }
        __except ( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x):Exception in IOCTL_CS_PROPERTY"), dwContext ) );
        }

        break;

     case IOCTL_CS_BUFFERS:
        DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x): IOCTL_CS_BUFFERS\r\n"), dwContext ) );

        __try
        {
            CSBUFFER_INFO  csBufferInfo;

            if( ( NULL == pInBuf ) ||
                ( InBufLen  < sizeof( CSBUFFER_INFO )) ||
                ( !CeSafeCopyMemory( &csBufferInfo, pInBuf, sizeof( csBufferInfo ))))
            {
                if( pdwBytesTransferred )
                {
                    *pdwBytesTransferred = 0;
                }

                DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): IOCTL_CS_BUFFERS. Invalid parameters\r\n"), dwContext ) );
                break;
            }

            dwErr = pPinDevice->PinHandleBufferRequest( csBufferInfo, pOutBuf, OutBufLen, pdwBytesTransferred );
        }
        __except ( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x):Exception in IOCTL_CS_BUFFERS"), dwContext ) );
        }

        break;

     case IOCTL_STREAM_INSTANTIATE:
        DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x): IOCTL_STREAM_INSTANTIATE\r\n"), dwContext ) );

        __try 
        {
            CSPROPERTY_STREAMEX_S csPropStreamEx = {0};
            
            if ( ( NULL == pInBuf )
                 || ( InBufLen < sizeof ( CSPROPERTY_STREAMEX_S ) )
                 || ( NULL == pdwBytesTransferred ) )
            {
                DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): IOCTL_STREAM_INSTANTIATE. Insufficient buffer\r\n"), dwContext ) );
                break;
            }

            BSPCameraMemCpy( &csPropStreamEx, pInBuf, sizeof( CSPROPERTY_STREAMEX_S ));

            if ( TRUE == IsEqualGUID( csPropStreamEx.CsPin.Property.Set, CSPROPSETID_StreamEx ) )
            {
                switch ( csPropStreamEx.CsPin.Property.Id )
                {
                case CSPROPERTY_STREAMEX_INIT:
                    dwErr = pPinDevice->StreamInstantiate( &csPropStreamEx, pOutBuf, OutBufLen, pdwBytesTransferred );
                    break;

                default:
                    DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): Invalid Request\r\n"), dwContext ) );
                    break;
                }
            }
            else
            {
                DEBUGMSG( ZONE_IOCTL, ( _T("PIN_IOControl(%08x): Unsupported PropertySet Request for IOCTL_STREAM_INSTANTIATE%u\r\n"), dwContext, csPropStreamEx.CsPin.Property.Set ) );
                dwErr = ERROR_NOT_SUPPORTED;
            }
        }
        __except ( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x):Exception in IOCTL_STREAM_INSTANTIATE"), dwContext ) );
        }

        break;

     case IOCTL_SET_DIRECT_DISPLAY_MODE:
        RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL_SET_DIRECT_DISPLAY_MODE\r\n"), dwContext));
 
        __try 
        {
            DWORD  dwDirectDisMode;

            if( ( NULL == pInBuf )
                || ( InBufLen < sizeof( DWORD ))
                || ( !BSPCameraMemCpy( &dwDirectDisMode, pInBuf, sizeof( DWORD )) ))
            {
                DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): IOCTL_SET_DIRECT_DISPLAY_MODE. Invalid parameters\r\n"), dwContext ) );
                break;
            }

            dwErr = pPinDevice->PinSetDirectDisplayMode(dwDirectDisMode);
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x):Exception in IOCTL_SET_DIRECT_DISPLAY_MODE"), dwContext));
        }

        break;

     case IOCTL_SET_DIRECT_CAPTURE_MODE:
        RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL_SET_DIRECT_CAPTURE_MODE\r\n"), dwContext));

        __try 
        {
            DWORD  dwDirectCapMode;

            if( ( NULL == pInBuf )
                || ( InBufLen < sizeof( DWORD ))
                || ( !BSPCameraMemCpy( &dwDirectCapMode, pInBuf, sizeof( DWORD )) ))
            {
                DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): IOCTL_SET_DIRECT_CAPTURE_MODE. Invalid parameters\r\n"), dwContext ) );
                break;
            }

            pPinDevice->PinSetDirectCaptureMode(dwDirectCapMode);

            dwErr = ERROR_SUCCESS;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x):Exception in IOCTL_SET_DIRECT_CAPTURE_MODE"), dwContext));
        }
        break;

     case IOCTL_POWER_CAPABILITIES:
        DEBUGMSG(ZONE_WARN, (TEXT("PIN_IOControl(%08x): IOCTL_POWER_CAPABILITIES\r\n")));

        if(pOutBufUnmapped != NULL && OutBufLen == sizeof(POWER_CAPABILITIES))
        {
            PPOWER_CAPABILITIES ppc = (PPOWER_CAPABILITIES) pOutBufUnmapped;

            memset(ppc, 0, sizeof(POWER_CAPABILITIES));
             
            ppc->DeviceDx = DX_MASK(D0) | DX_MASK(D4);
            *pdwBytesTransferred = sizeof(POWER_CAPABILITIES);
            dwErr = ERROR_SUCCESS;
        }
        else
        {
            dwErr = ERROR_INVALID_PARAMETER;
        }
        break;

     case IOCTL_POWER_QUERY:
        if(pOutBufUnmapped!= NULL && OutBufLen == sizeof(CEDEVICE_POWER_STATE))
        {
            // return a good status on any valid query, since we are always ready to
            // change power states.
            CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE)pOutBufUnmapped;
            if(VALID_DX(NewDx))
            {
                // this is a valid Dx state so return a good status
                dwErr = ERROR_SUCCESS;
            }
            else
            {
                SetLastError(ERROR_INVALID_PARAMETER);
            }
       
            *pdwBytesTransferred = sizeof(CEDEVICE_POWER_STATE);
            DEBUGMSG(ZONE_WARN, (TEXT("PIN_IOControl(%08x): IOCTL_POWER_QUERY %u %s\r\n"),
                                    NewDx, dwErr? L"succeeded" : L"failed"));
        }
        else
        {
            dwErr = ERROR_INVALID_PARAMETER;
        }
       
        break;

     case IOCTL_POWER_GET:
        if(pOutBufUnmapped!= NULL && OutBufLen == sizeof(CEDEVICE_POWER_STATE))
        {
            CEDEVICE_POWER_STATE CurrentDx = pPinDevice->GetPowerState();
            *(PCEDEVICE_POWER_STATE)pOutBufUnmapped = CurrentDx;
            *pdwBytesTransferred = sizeof(CEDEVICE_POWER_STATE);
            dwErr = ERROR_SUCCESS;
            DEBUGMSG(ZONE_WARN, (TEXT("PIN_IOControl(%08x): IOCTL_POWER_GET: passing back %u\r\n"), CurrentDx));
        }
        else
        {
            dwErr = ERROR_INVALID_PARAMETER;
        }
      
        break;

     case IOCTL_POWER_SET:
        if(pOutBufUnmapped!= NULL && OutBufLen == sizeof(CEDEVICE_POWER_STATE))
        {
            CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE)pOutBufUnmapped;
            if(VALID_DX(NewDx))
            {
                pPinDevice->SetPowerState(NewDx);
                *pdwBytesTransferred = sizeof(CEDEVICE_POWER_STATE);
                dwErr = ERROR_SUCCESS;
                DEBUGMSG(ZONE_WARN, (TEXT("PIN_IOControl(%08x): IOCTL_POWER_SET %u: \r\n"), NewDx));
            }
            else
            {
                dwErr = ERROR_INVALID_PARAMETER;
                DEBUGMSG(ZONE_WARN, (TEXT("PIN_IOControl(%08x): IOCTL_POWER_SET: invalid state request %u\r\n"), NewDx));
            }
        }
        else
        {
            dwErr = ERROR_INVALID_PARAMETER;
        }
     
        break;
    
     default:
        DEBUGMSG( ZONE_IOCTL|ZONE_ERROR, ( _T("PIN_IOControl(%08x): Unsupported IOCTL code %u\r\n"), dwContext, Ioctl ) );
        dwErr = ERROR_NOT_SUPPORTED;
        break;
    }

    // pass back appropriate response codes
    SetLastError(dwErr);
    return ( ( dwErr == ERROR_SUCCESS ) ? TRUE : FALSE );
}


EXTERN_C
DWORD
PIN_Open(
    DWORD Context, 
    DWORD Access,
    DWORD ShareMode
    )
{
    DEBUGMSG( ZONE_FUNCTION, ( _T("PIN_Open(%x, 0x%x, 0x%x)\r\n"), Context, Access, ShareMode ) );

    UNREFERENCED_PARAMETER( ShareMode );
    UNREFERENCED_PARAMETER( Access );

    // TODO : HANDLE ShareMode and Access parameters
    
    PPININITHANDLE pPinInit = reinterpret_cast<PPININITHANDLE>( Context );

    ASSERT( NULL != pPinInit );
    PPINDEVICE pPinDevice = new PINDEVICE;

    if ( NULL == pPinDevice )
    {
        DEBUGMSG( ZONE_FUNCTION, ( _T("PIN_Open(%x): Not enough memory to create pin device\r\n"), Context ) );
    }
    else
    {
	    if ( FALSE == pPinDevice->InitializeSubDevice( pPinInit->pCamDevice ) )
        {
            SAFEDELETE( pPinDevice );
            DEBUGMSG( ZONE_INIT|ZONE_ERROR, ( _T("PIN_Open: Initialization Failed") ) );
        }

    }

    return reinterpret_cast<DWORD>( pPinDevice );
}


EXTERN_C BOOL  
PIN_Close(
    DWORD Context
    ) 
{
    DEBUGMSG( ZONE_FUNCTION, ( _T("PIN_Close(%x)\r\n"), Context ) );
    
    PPINDEVICE pPinDev = reinterpret_cast<PPINDEVICE>( Context );
    pPinDev->CloseSubDevice( );
    SAFEDELETE( pPinDev );
    
    return TRUE;
}