test_driver.cpp

CE device driver exam

// Test_Driver.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include <windows.h>
#include <ceddk.h>

#define S3C2410X_BASE_REG_PA_UART0              (0x50000000)            
#define S3C2410X_BASE_REG_PA_UART1              (0x50004000)            
#define S3C2410X_BASE_REG_PA_UART2              (0x50008000)       

#define WRITE_DATA 1

//#define CALLERBUFFER_TEST

#define BUFSIZE 256

#ifdef _MANAGED
#pragma managed(push, off)
#endif

typedef struct {
    UINT32 ULCON;                   // line control reg
    UINT32 UCON;                    // control reg
    UINT32 UFCON;                   // FIFO control reg
    UINT32 UMCON;                   // modem control reg
    UINT32 UTRSTAT;                 // tx/rx status reg
    UINT32 UERSTAT;                 // rx error status reg
    UINT32 UFSTAT;                  // FIFO status reg
    UINT32 UMSTAT;                  // modem status reg
    UINT32 UTXH;                    // tx buffer reg
    UINT32 URXH;                    // rx buffer reg
    UINT32 UBRDIV;                  // baud rate divisor

} S3C2410X_UART_REG, *PS3C2410X_UART_REG;


typedef struct {
	WCHAR *data;
	DWORD size;
} DATA_STRUCT, *pDATA_STRUCT;


volatile S3C2410X_UART_REG *g_pUARTReg;


/* Global Variables on SER Driver */  
HANDLE g_hInstance;
WCHAR achBuffer[BUFSIZE];
WCHAR DriverBuffer[MAX_PATH]; //=L"I am a Buffer in the Driver";

VOID WriteSerialByte(PCHAR string, int numberofchars)
{
	
	for (int i=0; i<numberofchars; i++)
	{
		while(((g_pUARTReg->UTRSTAT) & 0x02) == 0);
		g_pUARTReg->UTXH = (UINT32) string[i];
	}
	return;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL WINAPI  
DllEntry(HANDLE hinstDLL, 
              DWORD dwReason, 
              LPVOID /* lpvReserved */)
{
    switch(dwReason)
    {
    case DLL_PROCESS_ATTACH:
        g_hInstance = hinstDLL;
        RETAILMSG(1,(TEXT("Test Driver : DLL_PROCESS_ATTACH\n")));
        return TRUE;
    case DLL_PROCESS_DETACH:
        RETAILMSG(1,(TEXT("Test Driver : DLL_PROCESS_DETACH\n")));
        break;
    }

    return TRUE;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL TES_Close(DWORD hOpenContext)
{
    BOOL bRet = TRUE;
    RETAILMSG(1,(TEXT("Test Driver : TES_Close\n")));

    return bRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL TES_Deinit(DWORD hDeviceContext)
{
    BOOL bRet = TRUE;

	RETAILMSG(1,(TEXT("Test Driver : TES_Deinit :: Deinitialize Memory for I2C and LED \r\n")));

	if (g_pUARTReg)
    {
        MmUnmapIoSpace((PVOID)g_pUARTReg, sizeof(S3C2410X_UART_REG));
        g_pUARTReg = NULL;
    }

    return bRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD TES_Init(DWORD dwContext)
{
     DWORD dwRet = 0;
//	 PHYSICAL_ADDRESS PA;
	 CHAR string[] = "\r\n Test Driver :: Windows Embedded CE 6.0 !!! \r\n";

	 RETAILMSG(1,(TEXT("Test Application Driver : TES_Init :: Initialize Memory for Serial port \r\n")));

// Initialize memory for Serial port (Debug port)
/*
     PA.QuadPart = S3C2410X_BASE_REG_PA_UART1;

     g_pUARTReg =(volatile S3C2410X_UART_REG  *) MmMapIoSpace(PA, sizeof(S3C2410X_UART_REG), FALSE);

     if(!g_pUARTReg)
     {
        RETAILMSG(1,(TEXT("Test Driver : TES_Init :: Memory for Serial port Initialize Failed !!!\r\n")));
	    return dwRet;
     }
*/
	 g_pUARTReg = (volatile S3C2410X_UART_REG *)VirtualAlloc(0, sizeof *g_pUARTReg, MEM_RESERVE, PAGE_NOACCESS);
	 
	 if (g_pUARTReg == NULL)
	 {
        RETAILMSG(1,(TEXT("Test Driver : TES_Init :: VirtualAlloc failed for Serial port !\r\n")));
	 }
	 else
	 {
		 if (!VirtualCopy((PVOID)g_pUARTReg, (PVOID)(S3C2410X_BASE_REG_PA_UART1 >> 8), sizeof *g_pUARTReg, PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE))
        {
            RETAILMSG(1,(TEXT("Test Driver : TES_Init :: VirtualCopy failed for Serial port !\r\n")));
            VirtualFree((PVOID)g_pUARTReg, 0, MEM_RELEASE);
            g_pUARTReg = NULL;
        }
     }

	dwRet=1;

	WriteSerialByte(string, sizeof(string));


    return dwRet;
} 


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL TES_IOControl(DWORD hOpenContext, 
                   DWORD dwCode, 
                   PBYTE pBufIn, 
                   DWORD dwLenIn, 
                   PBYTE pBufOut, 
                   DWORD dwLenOut, 
                   PDWORD pdwActualOut)
{
    BOOL bRet = TRUE;
	PVOID validPointer = NULL;
   
	switch(dwCode)
	{

	case WRITE_DATA :

		pDATA_STRUCT pData = (DATA_STRUCT *)pBufIn;

#ifdef CALLERBUFFER_TEST
		
		__try
		{
			if( S_OK == CeOpenCallerBuffer(&validPointer, (PVOID)(pData->data), (DWORD)pData->size, ARG_I_WSTR, FALSE))
			{
				RETAILMSG(1,(TEXT("Test Driver : CeOpenCallerBuffer OK. \r\n")));

				memcpy (DriverBuffer, validPointer, sizeof(DriverBuffer)); 

				RETAILMSG(1,(TEXT("Test Driver : Received application buffer : %s \r\n"),DriverBuffer));

				CeCloseCallerBuffer((PVOID)validPointer, (PVOID)pData->data, (DWORD)pData->size, ARG_I_WSTR);
			}
			else
			{
				RETAILMSG(1,(TEXT("Test Driver :CeOpenCallerBuffer FAILED !!! . \r\n")));
			}

		}

		__except (EXCEPTION_EXECUTE_HANDLER)
		{
			RETAILMSG(1,(TEXT(" Invalid argument passed in IO_CTL. \r\n")));
		}

#else

		RETAILMSG(1,(TEXT("Test Driver : Not using the CeOpenCallerBuffer. \r\n")));

		// !!!!  Critical error can be occured when caller's buffer to be copyed into the Driver's Buffer 
		// !!!!  if not using a Access Checking. 
        __try
		{

			memcpy (DriverBuffer, pData->data, sizeof(DriverBuffer)); 

			RETAILMSG(1,(TEXT("Test Driver : Received application buffer : %s \r\n"),DriverBuffer));

		}
		__except(1)
		{

			RETAILMSG(1,(TEXT("Test Driver : There are wrong parameters \r\n")));

		}

//		pData->size = sizeof(DriverBuffer);

#endif

		break;

	}
	
	return bRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD TES_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode)
{
    DWORD dwRet = 0;
   
    dwRet = 1;
	
	RETAILMSG(1,(TEXT("Test Driver : TES_Open :: Opened driver for Application \r\n")));
    return dwRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TES_PowerDown(DWORD hDeviceContext)
{
    RETAILMSG(1,(TEXT("Test Driver : TES_PowerDown :: \r\n")));
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TES_PowerUp(DWORD hDeviceContext)
{
    RETAILMSG(1,(TEXT("Test Driver : TES_PowerUp :: \r\n")));
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD TES_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
    DWORD dwRet = 0;
   
	DWORD cbBuffer = wcslen(achBuffer) + 1;
    dwRet = min(cbBuffer, Count);
    wcsncpy((LPWSTR)pBuffer, achBuffer, dwRet);
	
	RETAILMSG(1,(TEXT("Test Driver : TES_Read \r\n")));
    return dwRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD TES_Seek(DWORD hOpenContext, long Amount, DWORD Type)
{
    DWORD dwRet = 0;
    RETAILMSG(1,(TEXT("Test Driver : TES_Seek \r\n")));
    return dwRet;
} 

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD TES_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes)
{
    DWORD dwRet = 0;
    
	dwRet = min(BUFSIZE, NumberOfBytes);
    wcsncpy(achBuffer, (LPWSTR)pSourceBytes, dwRet);

	RETAILMSG(1,(TEXT("Test Driver : TES_Write \r\n")));
    return dwRet;
}


#ifdef _MANAGED
#pragma managed(pop)
#endif