hwreadwrite.cpp

Windows下Hardware直接读写

#include "StdAfx.h"



#include "driverinstall.h"
//#include "ntddk.h"
#include <winioctl.h>
#include ".\hwreadwrite.h"

CHwReadWrite::CHwReadWrite(void)
{
	m_hDevice = INVALID_HANDLE_VALUE;
	//get current path
	DWORD driverLocLen = GetCurrentDirectory(MAX_PATH,
                                       m_cDriverLocation
                                       );

    if (!driverLocLen) {


        return;
    }

    //
    // Setup path name to driver file.
    //

    strcat(m_cDriverLocation, "\\pciop.sys");
	m_hDevice = InitHwRwDriver("pciop", m_cDriverLocation);
	//InitHwRwDriver("pciop", "F:\\ddk_instance\\hwdirect\\objchk_wxp_x86\\i386\\pciop.sys");
}

CHwReadWrite::~CHwReadWrite(void)
{
	//CloseHwRwDriver("pciop", "F:\\ddk_instance\\hwdirect\\objchk_wxp_x86\\i386\\pciop.sys");
	CloseHwRwDriver("pciop", m_cDriverLocation);
}

bool CHwReadWrite::GetFirstPciConfig(PCIDEVQUERY pciQuery)
{
	return false;
}

// Init the device driver, open the service and start, return the handle
HANDLE CHwReadWrite::InitHwRwDriver(char* DriverName, char* DriverLocationFile)
{
	if(m_hDevice != INVALID_HANDLE_VALUE)
		return m_hDevice;
	
	if(ManageDriver(DriverName, DriverLocationFile, DRIVER_FUNC_INSTALL)){
		m_hDevice = CreateFile( "\\\\.\\PCIOP",
                GENERIC_READ | GENERIC_WRITE,
                0,
                NULL,
                CREATE_ALWAYS,
                FILE_ATTRIBUTE_NORMAL,
                NULL);
	
	}
	else {
		m_hDevice = INVALID_HANDLE_VALUE;
	}
	return m_hDevice;
}


void CHwReadWrite::CloseHwRwDriver(char* DriverName, char* DriverLocationFile)
{
	if(m_hDevice != INVALID_HANDLE_VALUE)
	{
		CloseHandle ( m_hDevice );
		ManageDriver(DriverName, DriverLocationFile, DRIVER_FUNC_REMOVE);
	}
	m_hDevice = INVALID_HANDLE_VALUE;
}

int CHwReadWrite::GetAllPciConfig(void)
{
	int ret = 0;
	PCIDEVQUERY pciQuery;
	PCIQUERYRESULT pciRet;
	ULONG bytesReturned;

	pciQuery.first = TRUE;
	pciQuery.vendorId = 0xFFFF;
	pciQuery.deviceId = 0xFFFF;
	pciQuery.busNum = 0;
	pciQuery.slotNum.u.bits.DeviceNumber = 0;
	pciQuery.slotNum.u.bits.FunctionNumber = 0;

	
	DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_PCIOP_GET_PCIDEVICE, 
                                        &pciQuery, 
                                        sizeof(PCIDEVQUERY), 
                                        &pciRet,
                                        sizeof(PCIQUERYRESULT),
                                        &bytesReturned,
                                        NULL 
                                        );



	while(bytesReturned == sizeof(PCIQUERYRESULT))
	{
		
		ret++;
		listPciQueryResults.AddTail(pciRet);
		pciQuery = pciRet.pciQuery;
		pciQuery.first = FALSE;
		DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_PCIOP_GET_PCIDEVICE, 
                                        &pciQuery, 
                                        sizeof(PCIDEVQUERY), 
                                        &pciRet,
                                        sizeof(PCIQUERYRESULT),
                                        &bytesReturned,
                                        NULL 
                                        );

	
	}
	return ret;
}

int CHwReadWrite::TestBufferIo(void)
{
	char inBuf[60] = "ha wa u";
	char outBuf[80] = "error";
	ULONG bytesReturned;
	DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_PCIOP_BUFFERED_TEST, 
                                        &inBuf, 
                                        sizeof(inBuf), 
                                        &outBuf,
                                        sizeof(outBuf),
                                        &bytesReturned,
                                        NULL 
                                        );
	return 0;
}

bool CHwReadWrite::GetPortVal(WORD wPortAddr, PDWORD pdwPortVal, BYTE bSize)
{
	IOPORTRWP ipPortRwp;
	ipPortRwp.isRead = true;
	ipPortRwp.portAddress = wPortAddr;
	ipPortRwp.rwSize = bSize;
	DWORD rdRet = 0;
	ULONG bytesReturned;

	DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_PORT_READ_WRITE, 
                                        &ipPortRwp, 
                                        sizeof(IOPORTRWP), 
                                        &rdRet,
                                        sizeof(rdRet),
                                        &bytesReturned,
                                        NULL 
                                        );
	if(bytesReturned == 0)
	{
		return false;
	}
	else
	{
		*pdwPortVal = rdRet;
		return true;
	}
}

bool CHwReadWrite::SetPortVal(WORD wPortAddr, DWORD dwPortVal, BYTE bSize)
{
	IOPORTRWP ipPortRwp;
	ipPortRwp.isRead = false;
	ipPortRwp.portAddress = wPortAddr;
	ipPortRwp.portValue = dwPortVal;
	ipPortRwp.rwSize = bSize;
	
	ULONG bytesReturned;

	DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_PORT_READ_WRITE, 
                                        &ipPortRwp, 
                                        sizeof(IOPORTRWP), 
                                        &dwPortVal,
                                        sizeof(dwPortVal),
                                        &bytesReturned,
                                        NULL 
                                        );
	if(bytesReturned == 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}


// Get the Memory Data from physical address
bool CHwReadWrite::GetMemoryData(PBYTE phyAddress, unsigned long rSize, PBYTE rBuffer)
{
	if(rBuffer == NULL)
	{
		return false;
	}
	MEMORYRP memRq;
	BOOL bRet;
	memRq.isRead = TRUE;
	memRq.memoryAddress = (ULONG)phyAddress;
	memRq.rSize = rSize;

	ULONG bytesReturned;

	bRet = DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_MEMORY_READ_WRITE, 
                                        &memRq, 
                                        sizeof(MEMORYRP), 
                                        rBuffer,
                                        rSize,
                                        &bytesReturned,
                                        NULL 
                                        );
	if(bytesReturned == 0 || bRet == FALSE)
	{
		return false;
	}
	else
	{
		return true;
	}

}



// Write the Memory Data to physical address
bool CHwReadWrite::SetMemoryData(PBYTE phyAddress, unsigned long rSize, PBYTE rBuffer)
{
	
	if(rBuffer == NULL)
	{
		return false;
	}
	MEMORYRP memRq;
	BOOL bRet;
	memRq.isRead = FALSE;
	memRq.memoryAddress = (ULONG)phyAddress;
	memRq.rSize = rSize;

	ULONG bytesReturned=0;

	bRet = DeviceIoControl ( m_hDevice, 
                   (DWORD) IOCTL_MEMORY_READ_WRITE, 
                                        &memRq, 
                                        sizeof(MEMORYRP), 
                                        rBuffer,
                                        rSize,
                                        &bytesReturned,
                                        NULL 
                                        );
	if(bytesReturned == 0 || bRet == FALSE)
	{
		return false;
	}
	else
	{
		return true;
	}
	return false;
}

// Test if the byte is writable
bool CHwReadWrite::TestMemoryWritable(PBYTE memAddress, unsigned long offset)
{
	BYTE bOrig;
	BYTE bTest;
	if(GetMemoryData(memAddress+offset, 1, &bOrig))
	{
		bTest = bOrig+1;
		if(SetMemoryData(memAddress+offset, 1, &bTest))
		{
			if(GetMemoryData(memAddress+offset, 1, &bTest))
			{
				if(bTest == bOrig+1)
				{
					return true;
				}
			}
		}
	}
	return false;	
}