sysctrl.c

wince host 和 target PCI驱动程序

/*
 *  SYSCTRL.C - System Control Message Support for IDEVXD
 *
 *  Notes:
 *
 *	This file processes all the control messages sent by VMM.
 */

#include "idevxd.h"

//***Global variables

#pragma VxD_LOCKED_DATA_SEG
extern 	DWORD _stdcall Version(DWORD, DWORD, LPDIOC);
extern	DWORD	_stdcall GetPhysicalAddressFromLinear(DWORD, DWORD, LPDIOC);
extern  	DWORD _stdcall MapAndGetLinearFromPhysical(DWORD, DWORD, LPDIOC);
extern	DWORD _stdcall SendIDECommand(DWORD, DWORD, LPDIOC);
extern	DWORD _stdcall ReadIDEBuffer(DWORD, DWORD, LPDIOC);
extern  	DWORD _stdcall InitDVDDriveStatus(DWORD, DWORD, LPDIOC);
extern	DWORD _stdcall MechanicCheckOpen(DWORD, DWORD, LPDIOC);
extern  	DWORD _stdcall IDEVXD_CleanUp();

DWORD ( _stdcall *IDEVXD_W32_Proc[] )(DWORD, DWORD, LPDIOC) = {
        Version,
        GetPhysicalAddressFromLinear,
        MapAndGetLinearFromPhysical,
        SendIDECommand,
        ReadIDEBuffer, 
        InitDVDDriveStatus,
		  MechanicCheckOpen
        };

static	DWORD		gdwOverlayUsage = 0;//***Number of overlay windows usage

#define MAX_IDEVXD_W32_API (sizeof(IDEVXD_W32_Proc)/sizeof(DWORD))

#pragma VxD_LOCKED_CODE_SEG
DWORD _stdcall IDEVXD_W32_DeviceIOControl(DWORD  dwService,
                                        DWORD  dwDDB,
                                        DWORD  hDevice,
                                        LPDIOC lpDIOCParms)
{
    DWORD dwRetVal = 0;
#ifndef WIN95ONLY
	//***In the Windows95 Ioctl Mode, bit 2 to bit 13 is the service index
	//***My line of code here is to extract that service index out
	if (dwService != DIOC_OPEN && dwService != DIOC_CLOSEHANDLE)
		dwService = ((dwService & 0x3fff) >> 2) - IDECTRL_IOCTL_INDEX;
#endif  //WIN95ONLY
	 
    // DIOC_OPEN is sent when VxD is loaded w/ CreateFile 
    //  (this happens just after SYS_DYNAMIC_INIT)
    if ( dwService == DIOC_OPEN )
    {
        VXD_printf("IDEVXD: WIN32 DEVIOCTL supported!\n\r");
        // Must return 0 to tell WIN32 that this VxD supports DEVIOCTL
        dwRetVal = 0;
    }
    // DIOC_CLOSEHANDLE is sent when VxD is unloaded w/ CloseHandle
    //  (this happens just before SYS_DYNAMIC_EXIT)
    else if ( dwService == DIOC_CLOSEHANDLE )
    {
		  VXD_printf("CALL to CleanUp\n\r");
        // Dispatch to cleanup proc					  
        dwRetVal = IDEVXD_CleanUp();
    }
    else if ( dwService > MAX_IDEVXD_W32_API )
    {
		  VXD_printf("IDEVXD: Not supporting services\n\r");
        // Returning a positive value will cause the WIN32 DeviceIOControl
        // call to return FALSE, the error code can then be retrieved
        // via the WIN32 GetLastError
        dwRetVal = ERROR_NOT_SUPPORTED;
    }
    else
    {
#ifndef WIN95ONLY
        // CALL requested service
        dwRetVal = (IDEVXD_W32_Proc[dwService])(dwDDB, hDevice, lpDIOCParms);
#else	//WIN95ONLY
        // CALL requested service
        dwRetVal = (IDEVXD_W32_Proc[dwService-1])(dwDDB, hDevice, lpDIOCParms);
#endif //WIN95ONLY
    }
    return(dwRetVal);
}

DWORD _stdcall Version(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{	
	DWORD *pdwVersion;

	VXD_printf("IDEVXD: Version\n\r");
	pdwVersion = (DWORD*)lpDIOCParms->lpvInBuffer;
	*pdwVersion = 0x0100;		//***VxD version 1.00
	return (NO_ERROR);
}

DWORD _stdcall GetPhysicalAddressFromLinear(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	DWORD			*pdwLinearAddr;
	DWORD			*pdwPhysicalAddr;

	VXD_printf("GetPhysicalAddressFromLinear\n\r");
	pdwLinearAddr = (DWORD *)lpDIOCParms->lpvInBuffer;
	pdwPhysicalAddr = (DWORD *)lpDIOCParms->lpvOutBuffer;
	*pdwPhysicalAddr = GetPhysicalFromLinear(*pdwLinearAddr);
	VXD_printf("VXD:Phys = %lx	Lin = %lx\n\r",*pdwPhysicalAddr,*pdwLinearAddr);
	return (NO_ERROR);
}

DWORD _stdcall MapAndGetLinearFromPhysical(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	DWORD	*pdwPhysicalAddr;
	DWORD *pdwLinearAddr;		

	VXD_printf("MapAndGetLinearFromPhysical\n\r");
	pdwPhysicalAddr = (DWORD *)lpDIOCParms->lpvInBuffer;
	pdwLinearAddr = (DWORD *)lpDIOCParms->lpvOutBuffer;
	*pdwLinearAddr = (DWORD)_MapPhysToLinear(*pdwPhysicalAddr,sizeof(DWORD),0);	
	return (NO_ERROR);
}

DWORD _stdcall SendIDECommand(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	PSENDDEVICEBUFFER pSendDevice;
	VXD_printf("VXD: SendIDECommand\n\r");
	pSendDevice = (PSENDDEVICEBUFFER)lpDIOCParms->lpvInBuffer;
	if (!SendDeviceCommand(pSendDevice->pwCommandBuffer,
                           pSendDevice->pwDataBuffer, 
                           pSendDevice->dwDataBufferSize))
        return (1);
   else
        return (NO_ERROR);
}

DWORD _stdcall ReadIDEBuffer(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	PREADDEVICEBUFFER pReadDevice;
	VXD_printf("VXD: ReadIDEBuffer\n\r");
	pReadDevice = (PREADDEVICEBUFFER)lpDIOCParms->lpvOutBuffer;
	if (!ReadDataBuffer(pReadDevice->pwDataBuffer, 
                       pReadDevice->dwDataBufferSize))
        return (1);
    else
        return (NO_ERROR);
}

DWORD _stdcall InitDVDDriveStatus(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	PDWORD pdwDVDErrorCode;
	VXD_printf("GetDVDDriveStatus\n\r");
	pdwDVDErrorCode = (DWORD *)lpDIOCParms->lpvOutBuffer;	
	if (!GetDVDDriveStatus(pdwDVDErrorCode))
        return (1);
	return (NO_ERROR);
}

DWORD _stdcall MechanicCheckOpen(DWORD dwDDB, DWORD hDevice, LPDIOC lpDIOCParms)
{
	BOOL *pfOpen;
	//VXD_printf("MechanicCheckOpen\n\r");
	pfOpen = (BOOL *)lpDIOCParms->lpvOutBuffer;
	IsDriveOpen(pfOpen);
	return (NO_ERROR);
}

DWORD _stdcall IDEVXD_CleanUp(void)
{
   VXD_printf("IDEVXD: CleanUp\n\r");
   return(VXD_SUCCESS);
}

/****************************************************************************
 *
 *	IDEVXD_Exit - This procedure gets called when the DLVxD is unloading
 *
 *	Exported.
 *
 *	ENTRY:	None.
 *
 *	EXIT:	VXD_SUCCESS or VXD_FAILURE.
 *
 ***************************************************************************/
DWORD _stdcall IDEVXD_Exit()
{
	VXD_printf("IDEVXD_Exit\n\r");
	return(VXD_SUCCESS);
}

#pragma VxD_ICODE_SEG
#pragma VxD_IDATA_SEG

/****************************************************************************
 *
 *	IDEVXD_Init - This procedure gets called the first time the DLVxD
 *		      is loaded
 *
 *	Exported.
 *
 *	ENTRY:	pDDB which is NULL is dynamically loaded.
 *
 *	EXIT:	VXD_SUCCESS or VXD_FAILURE.
 *
 ***************************************************************************/
DWORD _stdcall IDEVXD_Init()
{
	VXD_printf("IDEVXD: Dynamic Load\n\r");
	return(VXD_SUCCESS);
}