pindriver.cpp

freescale i.mx31 BSP CE5.0全部源码

//-----------------------------------------------------------------------------
//
// 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, Freescale Semiconductor, Inc. All Rights Reserved
//  THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
//  BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
//  Freescale Semiconductor, Inc.
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  File:  PinDriver.cpp
//
//  Implementation of Pin driver interface
//
//------------------------------------------------------------------------------
#include <windows.h>
#include <ceddk.h>
#include <devload.h>
#include <NKIntr.h>
#include <camera.h>
#include "mxarm11.h"
#include "cameradbg.h"
#include "PinDriver.h"


//------------------------------------------------------------------------------
// External Functions

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

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

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

    RETAILMSG(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)
{
    RETAILMSG(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 pInBuf,
    DWORD  InBufLen, 
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
    )
{
    RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL:0x%x, InBuf:0x%x, InBufLen:%d, OutBuf:0x%x, OutBufLen:0x%x)\r\n"), dwContext, Ioctl, pInBuf, InBufLen, pOutBuf, OutBufLen));

    DWORD      dwErr      = ERROR_INVALID_PARAMETER;
    BOOL       bRc        = FALSE;
    PPINDEVICE pPinDevice = reinterpret_cast<PPINDEVICE>(dwContext);

    if (NULL == MapCallerPtr(pdwBytesTransferred, sizeof(DWORD)))
    {
        RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): MapCallerPtr failed for dwBytesTransferred.\r\n"), dwContext));
        return dwErr;
    }
        
    switch (Ioctl)
    {
        case IOCTL_CS_PROPERTY:
            RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL_CS_PROPERTY\r\n"), dwContext));

            __try 
            {
                PCSPROPERTY pCsProp =  NULL;

                if ((NULL == pInBuf) || (InBufLen < sizeof(CSPROPERTY)) || (NULL == pdwBytesTransferred))
                {
                    break;
                }
            
                pCsProp = reinterpret_cast<PCSPROPERTY>(MapCallerPtr(pInBuf, sizeof(CSPROPERTY)));

                if (NULL == pCsProp)
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): IOCTL_CS_PROPERTY. MapCallerPtr failed.\r\n"), dwContext));
                    break;
                }

                if (TRUE == IsEqualGUID(pCsProp->Set, CSPROPSETID_Connection))
                {
                    dwErr = pPinDevice->PinHandleConnectionRequests(pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
                }
                else if (TRUE == IsEqualGUID(pCsProp->Set, CSPROPSETID_VPConfig ) )
                {
                    dwErr = pPinDevice->PinHandleVPConfigRequests( pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
                }
                else if (TRUE == IsEqualGUID(pCsProp->Set, CSPROPSETID_Stream ) )
                {
                    switch(pCsProp->Id)
                    {
                        case CSPROPERTY_STREAM_ALLOCATOR:
                            dwErr = pPinDevice->PinHandleStreamRequests( pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
                            break;

                        default:
                            RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): Unknown Property Request for IOCTL_CS_PROPERTY%u\r\n"), dwContext, pCsProp->Set));
                            break;
                    }
                }
                else
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): Unsupported PropertySet Request for IOCTL_CS_PROPERTY%u\r\n"), dwContext, pCsProp->Set));
                    dwErr = ERROR_NOT_SUPPORTED;
                }
            }
            __except (EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x):Exception in IOCTL_CS_PROPERTY"), dwContext));
            }

            break;

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

            __try 
            {
                if ((NULL == pInBuf)
                    || (InBufLen < (sizeof (CSSTREAM_HEADER) + sizeof(CS_FRAME_INFO)))
                    || (NULL == pdwBytesTransferred))
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): IOCTL_CS_READ_STREAM. Invalid parameters\r\n"), dwContext));
                    break;
                }

                if (NULL == MapCallerPtr(pInBuf, InBufLen))
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): IOCTL_CS_READ_STREAM. MapCallerPtr failed for input buffer\r\n"), dwContext));
                    break;
                }

                dwErr = pPinDevice->PinHandleReadStreamRequests(pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
            }
            __except (EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x):Exception in IOCTL_CS_READ_STREAM"), dwContext));
            }

            break;

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

                PCSPROPERTY_STREAMEX_S pCsPropStreamEx = NULL; 

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

                pCsPropStreamEx = reinterpret_cast<PCSPROPERTY_STREAMEX_S>(MapCallerPtr( pInBuf, sizeof ( CSPROPERTY_STREAMEX_S)));

                if (NULL == pCsPropStreamEx)
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): MapCallerPtr failed\r\n"), dwContext));
                    break;
                }

                //RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL_STREAM_INSTANTIATE.  PinId = %d\r\n"), dwContext,  pCsPropStreamEx->CsPin.PinId));
                if (TRUE == IsEqualGUID(pCsPropStreamEx->CsPin.Property.Set, CSPROPSETID_StreamEx ) )
                {
                    switch (pCsPropStreamEx->CsPin.Property.Id)
                    {
                        case CSPROPERTY_STREAMEX_INIT:
                            dwErr = pPinDevice->StreamInstantiate(pCsPropStreamEx, pOutBuf, OutBufLen, pdwBytesTransferred);
                            break;

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

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

                if (NULL == pdwBytesTransferred)
                {
                    RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x): IOCTL_CS_ALLOCATE_BUFFERS. Insufficient buffer\r\n"), dwContext));
                    break ;
                }

                dwErr = pPinDevice->PinHandleAllocateBuffers(pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
            }
            __except(EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(ZONE_IOCTL|ZONE_ERROR, (_T("PIN_IOControl(%08x):Exception in IOCTL_CS_ALLOCATE_BUFFERS"), dwContext));
            }

            break;

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

                dwErr = pPinDevice->PinSetDirectDisplayMode(InBufLen);
            }
            __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:
            __try 
            {
                RETAILMSG(ZONE_IOCTL, (_T("PIN_IOControl(%08x): IOCTL_SET_DIRECT_CAPTURE_MODE\r\n"), dwContext));

                pPinDevice->PinSetDirectCaptureMode(InBufLen);

                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;

        default:
            RETAILMSG(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
    )
{
    RETAILMSG(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)
    {
        RETAILMSG(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);
            RETAILMSG(ZONE_INIT|ZONE_ERROR, (_T("PIN_Init: Initialization Failed")));
        }

    }

    return reinterpret_cast<DWORD>(pPinDevice);
}


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


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


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


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


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


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


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