📄 tvichw32ctl.cpp
字号:
UnmapMemory((ULONG)fMappedPointers[i],fMappedSizes[i]);
CloseStopUnloadDriver();
}
}
BOOL CTVicHW32Ctrl::OpenDriver()
{
typedef struct _LocRec {
PVOID pBuf;
ULONG Sz;
} LocRec, *PLocRec;
LocRec Rec;
if (fOpenDrive) return TRUE;
ULONG nByte;
ClearFields();
InstallStartLoadDriver();
if (hDrv == INVALID_HANDLE_VALUE) {
CloseStopUnloadDriver();
InstallStartLoadDriver();
};
fLPTs = 0;
fLPTBasePort = 0x378;
fLPTNumber = 1;
if (fOpenDrive = (hDrv != INVALID_HANDLE_VALUE)) {
fPhysLoPart = 0x408;
fMemorySize = 6;
DeviceIoControl(hDrv,
CtlCode(_DRV_MAP_MEMORY),
&fInterface,24,
&fLPTAddresses,4,
&nByte,NULL);
for (int i = 0; i<3; i++)
if ((*(fLPTAddresses+i)) !=0) fLPTs++;
fLPTBasePort = *(fLPTAddresses+0);
fLPTNumber = 1;
fpLockedMemory = VirtualAlloc(0,
4096,
MEM_COMMIT,
PAGE_READWRITE
);
Rec.pBuf = fpLockedMemory;
Rec.Sz = 4096;
DeviceIoControl(hDrv,
CtlCode(_DRV_LOCK_MEMORY),
&Rec,8,&fMdl,4,
&nByte,NULL);
((PLockedBuffer)fpLockedMemory)->LPT_BASE_PORT = fLPTBasePort;
((PLockedBuffer)fpLockedMemory)->MAX_BUF_LPT = MAX_RING_BUFFER;
((PLockedBuffer)fpLockedMemory)->L_BUF_LPT = 0;
((PLockedBuffer)fpLockedMemory)->N_ADD_LPT = 0;
((PLockedBuffer)fpLockedMemory)->N_SEL_LPT = 0;
};
return fOpenDrive;
}
short CTVicHW32Ctrl::GetLPTNumPorts()
{
return fLPTs;
}
short CTVicHW32Ctrl::GetLPTBasePort()
{
return fLPTBasePort;
}
short CTVicHW32Ctrl::GetPort(short PortAddr)
{
DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;
if (!fOpenDrive) return 0xff;
if (fHardAccess) {
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_READ_PORT),
&PortNumber, sizeof(PortNumber),
&DataPort, sizeof(DataPort),
&nByte, NULL);
} else {
__asm {
mov dx, word ptr PortNumber
in al,dx
mov byte ptr DataPort, al
}
}
return (LOWORD(DataPort) & 0x00ff);
}
void CTVicHW32Ctrl::SetPort(short PortAddr, short nNewValue)
{
DWORD nByte = 0;
struct _Rec {
DWORD PortNumber;
DWORD DataPort;
} Rec;
if (!fOpenDrive)
return;
if (fHardAccess) {
Rec.PortNumber = (DWORD)PortAddr;
Rec.DataPort = (DWORD)nNewValue & 0x000000ff;
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_WRITE_PORT),
&Rec, sizeof(Rec), NULL, 0,
&nByte, NULL);
} else {
__asm {
mov al, byte ptr nNewValue
mov dx, word ptr PortAddr
out dx, al
}
}
SetModifiedFlag();
}
short CTVicHW32Ctrl::GetPortW(short PortAddr)
{
DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;
if (!fOpenDrive)
return short(0xffff);
if (fHardAccess) {
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_READ_PORTW),
&PortNumber, sizeof(PortNumber),
&DataPort, sizeof(DataPort),
&nByte, NULL);
} else {
__asm {
mov dx,word ptr PortNumber
in ax,dx
mov word ptr DataPort,ax
}
}
return LOWORD(DataPort);
}
void CTVicHW32Ctrl::SetPortW(short PortAddr, short nNewValue)
{
DWORD nByte = 0;
struct _Rec {
DWORD PortNumber;
DWORD DataPort;
} Rec;
if (!fOpenDrive)
return;
if (fHardAccess) {
Rec.PortNumber = (DWORD)PortAddr;
Rec.DataPort = (DWORD)nNewValue;
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_WRITE_PORTW),
&Rec, sizeof(Rec), NULL, 0,
&nByte, NULL);
} else {
__asm {
mov ax, nNewValue
mov dx, PortAddr
out dx, ax
}
}
SetModifiedFlag();
}
long CTVicHW32Ctrl::GetPortL(short PortAddr)
{
DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;
if (!fOpenDrive)
return 0xffffffff;
if (fHardAccess) {
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_READ_PORTL),
&PortNumber, sizeof(PortNumber),
&DataPort, sizeof(DataPort),
&nByte, NULL);
} else {
__asm {
mov dx,word ptr PortNumber
in eax,dx
mov DataPort,eax
}
}
return DataPort;
}
void CTVicHW32Ctrl::SetPortL(short PortAddr, long nNewValue)
{
DWORD nByte = 0;
struct _Rec {
DWORD PortNumber;
DWORD DataPort;
} Rec;
if (!fOpenDrive)
return;
if (fHardAccess) {
Rec.PortNumber = (DWORD)PortAddr;
Rec.DataPort = nNewValue;
DeviceIoControl(hDrv,
CtlCode(_DRV_HARD_WRITE_PORTL),
&Rec, sizeof(Rec), NULL, 0,
&nByte, NULL);
} else {
__asm {
mov eax, nNewValue
mov dx, PortAddr
out dx,eax
}
}
SetModifiedFlag();
}
long CTVicHW32Ctrl::MapPhysToLinear(long PhAddr, long PhSize)
{
ULONG MP,nByte = 0;
int i;
if (!fOpenDrive) return 0;
for (i=0; i<fMappedAreas; i++) {
if ( (ULONG)PhAddr == (ULONG)fMappedAddresses[i])
return (long)fMappedPointers[i];
};
if (fMappedAreas == MaxMappedAreas) return 0;
fMemorySize = (ULONG)PhSize;
fPhysLoPart = (ULONG)PhAddr;
DeviceIoControl(hDrv,
CtlCode(_DRV_MAP_MEMORY),
&fInterface, 24,
&MP, 4,
&nByte, NULL);
fMappedSizes[fMappedAreas] = PhSize;
fMappedPointers[fMappedAreas] = (PVOID)MP;
fMappedAddresses[fMappedAreas] = PhAddr;
fMappedAreas++;
return MP;
}
void CTVicHW32Ctrl::UnmapMemory(long PhAddr, long PhSize)
{
ULONG nByte;
int i,j;
if (!fOpenDrive ) return;
for (i=0; i<fMappedAreas; i++) {
if ((ULONG)PhAddr == (ULONG)fMappedAddresses[i]) {
DeviceIoControl(hDrv,
CtlCode(_DRV_UNMAP_MEMORY),
&fMappedPointers[i], 4,
NULL, 0, &nByte, NULL);
for (j=i; j<(fMappedAreas-1); j++) {
fMappedPointers[j] = fMappedPointers[j+1];
fMappedAddresses[j] = fMappedAddresses[j+1];
fMappedSizes[j] = fMappedSizes[j+1];
};
--fMappedAreas;
return;
};
};
}
void CTVicHW32Ctrl::LPTStrobe()
{
if (!fOpenDrive) return;
SetPin(1,FALSE);
for (int i = 0; i<1000; i++);
SetPin(1,TRUE);
}
BOOL CTVicHW32Ctrl::GetLPTAckwl()
{
return (!GetPin(10));
}
BOOL CTVicHW32Ctrl::GetLPTBusy()
{
return (GetPin(11));
}
BOOL CTVicHW32Ctrl::GetLPTPaperEnd()
{
return (GetPin(12));
}
BOOL CTVicHW32Ctrl::GetLPTSlct()
{
return (!GetPin(13));
}
void CTVicHW32Ctrl::LPTAutofd(BOOL Flag)
{
SetPin(14,!Flag);
}
BOOL CTVicHW32Ctrl::GetLPTError()
{
return (!GetPin(15));
}
void CTVicHW32Ctrl::LPTInit()
{
SetPin(16,FALSE);
for (int i=1; i<1000; i++);
SetPin(16,TRUE);
// TODO: Add your dispatch handler code here
}
void CTVicHW32Ctrl::LPTSlctIn()
{
SetPin(16,FALSE);
short data = fDataPorts[2] & 0xf7;
fDataPorts[2] = (BYTE)data;
SetPort(fLPTBasePort+2,data);
}
BOOL CTVicHW32Ctrl::LPTPrintChar(short ch)
{
BOOL Result = FALSE;
if (fOpenDrive) {
SetPort(fLPTBasePort,(USHORT)(UCHAR)ch);
if (!GetLPTError() && !GetLPTBusy()) {
LPTStrobe();
Result = TRUE;
};
};
return Result;
}
BOOL CTVicHW32Ctrl::GetPin(short nPin)
{
BYTE data,ofs,n;
BOOL Result = FALSE;
if (!fOpenDrive || (nPin>17) || (nPin<=0)) return Result;
n = nPin - 1;
ofs = PinsPort[n];
data = (BYTE)GetPort(fLPTBasePort+ofs);
Result = (data & MaskPins[n]) != 0;
if (Negative[n]) Result = !Result;
return Result;
}
void CTVicHW32Ctrl::SetPin(short nPin, BOOL bNewValue)
{
BYTE data,ofs,n;
if (!fOpenDrive || (nPin>17) || (nPin<=0)) return;
n = nPin-1;
ofs = PinsPort[n];
data = fDataPorts[ofs];
if (bNewValue != Negative[n]) data = data | MaskPins[n];
else data = data & (~MaskPins[n]);
SetPort(fLPTBasePort+ofs,(short)data);
fDataPorts[ofs] = data;
SetModifiedFlag();
}
short CTVicHW32Ctrl::GetMem(long MappedAddr, long Offset)
{
if ((!fOpenDrive) ) return 0;
return (short)*(PUCHAR)(MappedAddr+Offset);
}
void CTVicHW32Ctrl::SetMem(long MappedAddr, long Offset, short nNewValue)
{
if ((!fOpenDrive) || (MappedAddr<100)) return;
*(PUCHAR)(MappedAddr+Offset) = (UCHAR)nNewValue;
SetModifiedFlag();
}
short CTVicHW32Ctrl::GetMemW(long MappedAddr, long Offset)
{
if ((!fOpenDrive) || (MappedAddr<100)) return 0;
return (short)*(PUSHORT)(MappedAddr+Offset);
}
void CTVicHW32Ctrl::SetMemW(long MappedAddr, long Offset, short nNewValue)
{
if ((!fOpenDrive) || (MappedAddr<100)) return;
*(PUSHORT)(MappedAddr+Offset) = (USHORT)nNewValue;
SetModifiedFlag();
}
long CTVicHW32Ctrl::GetMemL(long MappedAddr, long Offset)
{
if ((!fOpenDrive) || (MappedAddr<100)) return 0;
return (long)*(PULONG)(MappedAddr+Offset);
}
void CTVicHW32Ctrl::SetMemL(long MappedAddr, long Offset, long nNewValue)
{
if ((!fOpenDrive) || (MappedAddr<100)) return;
*(PULONG)(MappedAddr+Offset) = (ULONG)nNewValue;
SetModifiedFlag();
}
BOOL CTVicHW32Ctrl::GetActiveHW()
{
return fOpenDrive;
}
short CTVicHW32Ctrl::GetMappedAreas()
{
return fMappedAreas;
}
long CTVicHW32Ctrl::DebugCode()
{
return fDebugCode;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -