cameradriver.cpp

三星2440原版bsp

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++


Module Name:

    CameraDriver.cpp

Abstract:

    Template camera driver for DSHOW

Notes:
    

Revision History:

--*/

#include <windows.h>
#include <devload.h>
#include <nkintr.h>

#define CAMINTERFACE
#include "CameraDriver.h"


#define RETAIL_ON	1
extern DWORD dwDisplayTimeout;
CAMINFO sCAMINFO;

extern UCHAR DRIVER_PREVIEW_ENABLE;

//TODO : More investigation needed for AdvertiseInterface

EXTERN_C
DWORD
CIS_Init(
    VOID * pContext
    )
{    
    CAMERADEVICE * pCamDev = NULL;
    DEBUGMSG(ZONE_INIT, (_T("CIS_Init: context %s\n"), pContext));
    RETAILMSG(1, (_T("Venus CIS_Init: context %s\n"), pContext));
    
    if( OEM_CERTIFY_TRUST != CeGetCallerTrust() )
    {
        SetLastError(ERROR_ACCESS_DENIED);
    }
    else
    {
        pCamDev = new CAMERADEVICE;
        
        if ( NULL != pCamDev )
        {
            // NOTE: real drivers would need to validate pContext before dereferencing the pointer
            if ( false == pCamDev->Initialize( pContext ) )
            {
                SetLastError( ERROR_INVALID_HANDLE );
                SAFEDELETE( pCamDev );
                DEBUGMSG( ZONE_INIT|ZONE_ERROR, ( _T("CIS_Init: Initialization Failed") ) );
            }
        }
        else
        {
            SetLastError( ERROR_OUTOFMEMORY );
        }
    }    
    DEBUGMSG( ZONE_INIT, ( _T("CIS_Init: returning 0x%08x\r\n"), reinterpret_cast<DWORD>( pCamDev ) ) );

    return reinterpret_cast<DWORD>( pCamDev );
}


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

    CAMERADEVICE * pCamDevice = reinterpret_cast<CAMERADEVICE *>( dwContext );
    SAFEDELETE( pCamDevice );

    return TRUE;
}


EXTERN_C
BOOL
CIS_IOControl(
    DWORD   dwContext,
    DWORD   Ioctl,
    UCHAR * pInBufUnmapped,
    DWORD   InBufLen, 
    UCHAR * pOutBufUnmapped,
    DWORD   OutBufLen,
    DWORD * pdwBytesTransferred
   )
{
	RETAILMSG( RETAIL_ON, ( _T("+CIS_IOControl(%08x): IOCTL:0x%x, InBuf:0x%x, InBufLen:%d, OutBuf:0x%x, OutBufLen:0x%x)\r\n"), dwContext, Ioctl, pInBufUnmapped, InBufLen, pOutBufUnmapped, OutBufLen ) );

	UCHAR * pInBuf = NULL;
	UCHAR * pOutBuf = NULL;
	DWORD dwErr = ERROR_SUCCESS;//ERROR_INVALID_PARAMETER;
	BOOL  bRc   = FALSE;
	static unsigned int time=0,old_time=0;
	CSPROPERTY       * pCsProp = NULL;

	if(IOCTL_CS_PROPERTY == Ioctl)
	{
		if ( ( NULL == pInBufUnmapped )
	     		|| ( InBufLen < sizeof ( CSPROPERTY ) )
	     		|| ( NULL == pdwBytesTransferred ) )
		{
		    	SetLastError( dwErr );
			RETAILMSG(1, (TEXT("CIS_IOControl: Invalid input parameters\r\n")));
		    	return bRc;
		}

		pInBuf = (UCHAR*) MapCallerPtr( pInBufUnmapped, InBufLen );
		if(( pInBuf == NULL ) && ( pInBufUnmapped != NULL ))
		{
		    	RETAILMSG(1, ( _T("CIS_IOControl(%08x): CIS_IOControl. MapCallerPtr failed for incoming buffer.\r\n"), dwContext ) );

		    	return ERROR_INVALID_PARAMETER;
		}

		pOutBuf = (UCHAR*) MapCallerPtr( pOutBufUnmapped, OutBufLen );
		if (( NULL == pOutBuf ) && ( pOutBufUnmapped != NULL ))
		{
		    	RETAILMSG( 1, ( _T("CIS_IOControl(%08x): CIS_IOControl. MapCallerPtr failed for outgoing buffer.\r\n"), dwContext ) );

		    	return ERROR_INVALID_PARAMETER;
		}

		if ( NULL == MapCallerPtr( pdwBytesTransferred, sizeof ( DWORD ) ) )
		{
		    	RETAILMSG( 1, ( _T("CIS_IOControl(%08x): CIS_IOControl. MapCallerPtr failed for dwBytesTransferred.\r\n"), dwContext ) );

		    	return ERROR_INVALID_PARAMETER;
		}

		pCsProp = reinterpret_cast<CSPROPERTY *>( MapCallerPtr( pInBuf, sizeof ( CSPROPERTY ) ) );

		if ( NULL == pCsProp )
		{
		    	RETAILMSG( 1, (_T("CIS_IOControl(%08x): MapCallerPtr failed for input buffer.\r\n"), dwContext ) );

		    	return ERROR_INVALID_PARAMETER;
		}
	}

	RETAILMSG(RETAIL_ON, (TEXT("CIS_IOControl\r\n")));

	CAMERAOPENHANDLE * pCamOpenHandle = reinterpret_cast<CAMERAOPENHANDLE *>( dwContext );

	CAMERADEVICE     * pCamDevice     = pCamOpenHandle->pCamDevice;
	if(NULL == pCamDevice)
	{
		RETAILMSG(1, (TEXT("CIS_IOControl: pCamDevice is not valid\r\n")));
		return ERROR_INVALID_PARAMETER;
	}
    
    switch ( Ioctl )
    {
        case IOCTL_CS_PROPERTY:
        {
            DEBUGMSG( ZONE_IOCTL, ( _T("CIS_IOControl(%08x): IOCTL_CS_PROPERTY\r\n"), dwContext ) );

            __try 
            {
                if ( TRUE == IsEqualGUID( pCsProp->Set, CSPROPSETID_Pin ) )
                {   
                    dwErr = pCamDevice->AdapterHandlePinRequests( pInBuf, InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, CSPROPSETID_VERSION ) )
                {
                    dwErr = pCamDevice->AdapterHandleVersion( pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, PROPSETID_VIDCAP_VIDEOPROCAMP ) )
                {   
                    dwErr = pCamDevice->AdapterHandleVidProcAmpRequests( pInBuf,InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, PROPSETID_VIDCAP_CAMERACONTROL ) )
                {   
                    dwErr = pCamDevice->AdapterHandleCamControlRequests( pInBuf,InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, PROPSETID_VIDCAP_VIDEOCOMPRESSION ) )
                {   
                    dwErr = pCamDevice->AdapterHandleCompressionRequests( pInBuf,InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, PROPSETID_VIDCAP_VIDEOCONTROL ) )
                {   
                    dwErr = pCamDevice->AdapterHandleVideoControlRequests( pInBuf,InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else if ( TRUE == IsEqualGUID( pCsProp->Set, PROPSETID_VIDCAP_DROPPEDFRAMES) )
                {   
                    dwErr = pCamDevice->AdapterHandleDroppedFramesRequests( pInBuf,InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred );
                }
                else
                {
                    DEBUGMSG( ZONE_IOCTL, ( _T("CIS_IOControl(%08x): Unsupported PropertySet Request%u\r\n"), dwContext, pCsProp->Set ) );
                    dwErr = ERROR_NOT_SUPPORTED;
                }
            }
            __except ( EXCEPTION_EXECUTE_HANDLER )
            {
                DEBUGMSG( ZONE_IOCTL, ( _T("CIS_IOControl(%08x):Exception in IOCTL_CS_PROPERTY"), dwContext ) );
            }

            break;
        }

		case IOCTL_CAM_SHOW :
			RETAILMSG(RETAIL_ON,(TEXT("CAMERA:IOCTL_CAM_SHOW(%x)\r\n"),InBufLen));
			break;

		case IOCTL_CAM_HIDE :
			RETAILMSG(RETAIL_ON,(TEXT("CAMERA:IOCTL_CAM_HIDE\r\n")));
			break;

		case IOCTL_CAM_SETPOS :
			time = GetTickCount();
			RETAILMSG(RETAIL_ON,(TEXT("Capture time:%d msec\r\n"), (time)));
			old_time = time;
			break;

		case CAM_IOCTL_MOVIE_START:			// for MPEG4
		case IOCTL_CAM_CONT :
			RETAILMSG(RETAIL_ON,(TEXT("CAMERA:IOCTL_CAM_CONT\r\n")));
/*
			// Enable camera interrupt
			pCamDevice->m_rS2440INT->INTMSK &= ~( 1 << IRQ_CAM );
			pCamDevice->m_rS2440INT->INTSUBMSK &= ~(( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));

			pCamDevice->Camif_Capture(CAPTURE_ON, CAPTURE_ON);
*/
			pCamDevice->CameraEnable();
			dwDisplayTimeout = INFINITE;

			pCamDevice->m_dwFrameCount = 0;		// for MPEG4
			break;

		case CAM_IOCTL_MOVIE_STOP:		// for MPEG4
		case IOCTL_CAM_STOP :
			RETAILMSG(RETAIL_ON,(TEXT("CAMERA:IOCTL_CAM_STOP\r\n")));
/*
			// Disable camera interrupt
			pCamDevice->m_rS2440INT->INTMSK |= ( 1 << IRQ_CAM );
			pCamDevice->m_rS2440INT->INTSUBMSK |= (( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));

			//clear the pending interrupts
			if (pCamDevice->m_rS2440INT->INTPND & ( 1 << IRQ_CAM ))
				pCamDevice->m_rS2440INT->INTPND |= ( 1 << IRQ_CAM );
			pCamDevice->m_rS2440INT->SRCPND |= ( 1 << IRQ_CAM );
			pCamDevice->m_rS2440INT->SUBSRCPND |= (( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));

			pCamDevice->Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);

			//DisplayEnable = 0;

			DRIVER_PREVIEW_ENABLE = 2;
			RETAILMSG(RETAIL_ON,(TEXT("IOCTL_CAM_STOP: DRIVER_PREVIEW_ENABLE is 2\r\n")));
*/
			pCamDevice->CameraDisable();
			//dwDisplayTimeout = INFINITE;
			break;

		// for MPEG4