tvichw32.cpp

《Delphi5企业级解决方案及应用剖析》参考程序 DELPHI 资料集

	if (HW32->fOpenDrive && HW32->fIsIRQSet && HW32->fMasked) {

        ((PLockedBuffer)HW32->fpLockedMemory)->LPT_BASE_PORT = HW32->fLPTBasePort;
        ((PLockedBuffer)HW32->fpLockedMemory)->MAX_BUF_LPT   = MAX_RING_BUFFER;
        ((PLockedBuffer)HW32->fpLockedMemory)->L_BUF_LPT     = 0;
        ((PLockedBuffer)HW32->fpLockedMemory)->N_ADD_LPT     = 0;
		((PLockedBuffer)HW32->fpLockedMemory)->N_SEL_LPT     = 0;
                
        HW32->fTerminated = FALSE;

        if (fWin95)
               HW32->fThreadHandle=
			     CreateThread(
					          NULL,
							  0,
							  (LPTHREAD_START_ROUTINE)&IRQProc95,
							  HW32,
							  0,
							  (LPDWORD)&HW32->fThreadId
							                   );
         else
               HW32->fThreadHandle=
			     CreateThread(
					          NULL,
							  0,
							  (LPTHREAD_START_ROUTINE)&IRQProcNT,
							  HW32,
							  0,
							  (LPDWORD)&HW32->fThreadId
    					                       );
			
	
	};

	
}
void  VICFN MaskIRQ(PVicHW32Descriptor HW32) 
{

	DWORD nByte = 0;
	if (HW32->fOpenDrive && HW32->fIsIRQSet && (!HW32->fMasked)) {
	

      	        HW32->fMasked = TRUE;
                DeviceIoControl(HW32->hDrv,
				    	        CtlCode(_DRV_MASK_INT_VEC),
					            NULL, 0, NULL, 0,
					            &nByte, NULL);

				HW32->fTerminated = true;

	            if(fWin95)  SetEvent(HW32->fLocEvent);
				else        ReleaseSemaphore(HW32->fLocEvent, 1, NULL);
				
                WaitForSingleObject(HW32->fThreadHandle,INFINITE);
	            CloseHandle(HW32->fThreadHandle);

	            CloseHandle(HW32->fLocEvent);
				HW32->fLocEvent = 0;
                
	            
	
	}
}

short  VICFN GetIRQNumber(PVicHW32Descriptor HW32) 
{
    return HW32->fIRQNumber;
	
}

void  VICFN SetIRQ(PVicHW32Descriptor HW32,
				   short              IRQNumber,
				   TOnHWInterrupt HWHandler) 
{

	if ((IRQNumber>0) && (IRQNumber<16) && HW32->fMasked) {
   	   HW32->fIRQNumber = IRQNumber;
	   HW32->fIsIRQSet = TRUE;
	   HW32->OnHWInterrupt = HWHandler;
	};
}

PVicHW32Descriptor  VICFN CloseTVicHW32(PVicHW32Descriptor HW32) 
{

    ULONG nByte;

	if (HW32 == NULL) return NULL;

	if (HW32->fOpenDrive) {
		SetHardAccess(HW32,TRUE);
		if (!HW32->fMasked) MaskIRQ(HW32);
		HW32->fOpenDrive = FALSE;

/*

		DeviceIoControl(HW32->hDrv,
		              CtlCode(_DRV_UNMAP_LPT_AREA),
					  &HW32->fLPTAddresses,4,
					  &HW32->fLPTAddresses,4,
					  &nByte,NULL);
*/
		DeviceIoControl(HW32->hDrv,
			          CtlCode(_DRV_UNLOCK_MEMORY),
					  &HW32->fMdl,4,
					  &HW32->fMdl,4,
					  &nByte,NULL);
		for (int i=0; i<HW32->fMappedAreas; i++)
			UnmapMemory(HW32,(ULONG)HW32->fMappedPointers[i],HW32->fMappedSizes[i]);
	  
		CloseStopUnloadDriver(HW32);
    }

  return NULL;

}

PVicHW32Descriptor  VICFN OpenTVicHW32(PVicHW32Descriptor HW32) 
{
		typedef struct _LocRec {
		PVOID pBuf;
        ULONG Sz;
	} LocRec, *PLocRec;

    LocRec Rec;

	if (HW32 == NULL) {

        HW32 = (PVicHW32Descriptor)malloc (sizeof(TVicHW32Descriptor));
		memset(HW32, 0, sizeof(TVicHW32Descriptor));

    };

	if (HW32->fOpenDrive) return HW32;

	ULONG nByte;
    ClearFields(HW32);
	
    InstallStartLoadDriver(HW32);
	                                 
    if (HW32->hDrv == INVALID_HANDLE_VALUE) {
			CloseStopUnloadDriver(HW32);
			InstallStartLoadDriver(HW32);
    };
	
	HW32->fLPTs = 0;
	HW32->fLPTBasePort = 0x378;
	HW32->fLPTNumber = 1;

	if (HW32->fOpenDrive = (HW32->hDrv != INVALID_HANDLE_VALUE)) {

      HW32->fPhysLoPart = 0x408;
	  HW32->fMemorySize = 6;

	  DeviceIoControl(HW32->hDrv,
		              CtlCode(_DRV_MAP_MEMORY),
					  &HW32->fInterface,24,
					  &HW32->fLPTAddresses,4,
					  &nByte,NULL);


	  for (int i = 0; i<3; i++) 
		  if ((*(HW32->fLPTAddresses+i)) !=0) HW32->fLPTs++;

      HW32->fLPTBasePort = *(HW32->fLPTAddresses+0);
	  HW32->fLPTNumber = 1;

	  HW32->fpLockedMemory = VirtualAlloc(0,
		                            4096,
									MEM_COMMIT,
									PAGE_READWRITE
									);
	  
    
      Rec.pBuf = HW32->fpLockedMemory;
	  Rec.Sz   = 4096;
      DeviceIoControl(HW32->hDrv,
                      CtlCode(_DRV_LOCK_MEMORY),
                      &Rec,8,&HW32->fMdl,4,
                      &nByte,NULL);
	  
      ((PLockedBuffer)HW32->fpLockedMemory)->LPT_BASE_PORT = HW32->fLPTBasePort;
      ((PLockedBuffer)HW32->fpLockedMemory)->MAX_BUF_LPT   = MAX_RING_BUFFER;
      ((PLockedBuffer)HW32->fpLockedMemory)->L_BUF_LPT     = 0;
      ((PLockedBuffer)HW32->fpLockedMemory)->N_ADD_LPT     = 0;
      ((PLockedBuffer)HW32->fpLockedMemory)->N_SEL_LPT     = 0;

	};
	
 	return HW32;
}

short  VICFN GetLPTNumPorts(PVicHW32Descriptor HW32) 
{
	return HW32->fLPTs;
}

short  VICFN GetLPTBasePort(PVicHW32Descriptor HW32) 
{
	return HW32->fLPTBasePort;
}

short  VICFN GetPortByte(PVicHW32Descriptor HW32,short PortAddr) 
{
	DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;
	
	if (!HW32->fOpenDrive) return 0xff;

	if (HW32->fHardAccess) {
		DeviceIoControl(HW32->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  VICFN SetPortByte(PVicHW32Descriptor HW32,short PortAddr, short nNewValue) 
{
	DWORD nByte = 0;
	struct _Rec {
		DWORD PortNumber;
		DWORD DataPort;
	} Rec;

	if (!HW32->fOpenDrive)
		return;

	if (HW32->fHardAccess) {
		Rec.PortNumber	= (DWORD)PortAddr;
		Rec.DataPort	= (DWORD)nNewValue & 0x000000ff;
		DeviceIoControl(HW32->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
        }
    }


	
}

short  VICFN GetPortWord(PVicHW32Descriptor HW32,short PortAddr) 
{
	DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;

	if (!HW32->fOpenDrive)
		return short(0xffff);

	if (HW32->fHardAccess) {
		DeviceIoControl(HW32->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  VICFN SetPortWord(PVicHW32Descriptor HW32,short PortAddr, short nNewValue) 
{
	DWORD nByte = 0;
	struct _Rec {
		DWORD PortNumber;
		DWORD DataPort;
	} Rec;

	if (!HW32->fOpenDrive)
		return;

	if (HW32->fHardAccess) {
		Rec.PortNumber	= (DWORD)PortAddr;
		Rec.DataPort	= (DWORD)nNewValue;
		DeviceIoControl(HW32->hDrv,
						CtlCode(_DRV_HARD_WRITE_PORTW),
						&Rec, sizeof(Rec), NULL, 0,
						&nByte, NULL);
	} else {
		__asm {
           mov ax, nNewValue
           mov dx, PortAddr
           out dx, ax
        }
    }



	
}

long VICFN GetPortLong(PVicHW32Descriptor HW32,short PortAddr) 
{

	DWORD nByte = 0, PortNumber= (DWORD)PortAddr, DataPort = 0;

	if (!HW32->fOpenDrive)
		return 0xffffffff;

	if (HW32->fHardAccess) {
		DeviceIoControl(HW32->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 VICFN SetPortLong(PVicHW32Descriptor HW32,short PortAddr, long nNewValue) 
{
	DWORD nByte = 0;
	struct _Rec {
		DWORD PortNumber;
		DWORD DataPort;
	} Rec;

	if (!HW32->fOpenDrive)
		return;

	if (HW32->fHardAccess) {
		Rec.PortNumber	= (DWORD)PortAddr;
		Rec.DataPort	= nNewValue;
		DeviceIoControl(HW32->hDrv,
						CtlCode(_DRV_HARD_WRITE_PORTL),
						&Rec, sizeof(Rec), NULL, 0,
						&nByte, NULL);
	} else {
		__asm {
           mov eax, nNewValue
           mov dx,  PortAddr
           out dx,eax
        }
    }

	
}

long VICFN MapPhysToLinear(PVicHW32Descriptor HW32,long PhAddr, long PhSize) 
{

	ULONG MP,nByte = 0;
	int   i;
	
	if (!HW32->fOpenDrive) return 0;

	for (i=0; i<HW32->fMappedAreas; i++) {
			
		if ( (ULONG)PhAddr == (ULONG)HW32->fMappedAddresses[i])
		  return (long)HW32->fMappedPointers[i];
	};

	if (HW32->fMappedAreas == MaxMappedAreas) return 0;
	HW32->fMemorySize = (ULONG)PhSize;
	HW32->fPhysLoPart = (ULONG)PhAddr;
	DeviceIoControl(HW32->hDrv,
					CtlCode(_DRV_MAP_MEMORY),
					&HW32->fInterface, 24,
					&MP, 4,
                    &nByte, NULL);
    HW32->fMappedSizes[HW32->fMappedAreas] = PhSize;
	HW32->fMappedPointers[HW32->fMappedAreas] = (PVOID)MP;
	HW32->fMappedAddresses[HW32->fMappedAreas] = PhAddr;
	HW32->fMappedAreas++;
	
	return MP;

}

void VICFN UnmapMemory(PVicHW32Descriptor HW32,long PhAddr, long PhSize) 
{

    ULONG	nByte;
	int i,j;

    if (!HW32->fOpenDrive ) return;

    for (i=0; i<HW32->fMappedAreas; i++) {

		if ((ULONG)PhAddr == (ULONG)HW32->fMappedAddresses[i]) {

		 	DeviceIoControl(HW32->hDrv,
		    				CtlCode(_DRV_UNMAP_MEMORY),
			    			&HW32->fMappedPointers[i], 4,
				    		NULL, 0, &nByte, NULL);
			for (j=i; j<(HW32->fMappedAreas-1); j++) {
				HW32->fMappedPointers[j] = HW32->fMappedPointers[j+1];
                                HW32->fMappedAddresses[j] = HW32->fMappedAddresses[j+1];
				HW32->fMappedSizes[j] = HW32->fMappedSizes[j+1];
            };
			--HW32->fMappedAreas;
                        return;
		};
	};
}

void VICFN LPTStrobe(PVicHW32Descriptor HW32) 
{
    if (!HW32->fOpenDrive) return;
    SetPin(HW32,1,FALSE);
    for (int i = 0; i<1000; i++);
    SetPin(HW32,1,TRUE);
}

BOOL VICFN GetLPTAckwl(PVicHW32Descriptor HW32) 
{
	return (!GetPin(HW32,10));
}

BOOL VICFN GetLPTBusy(PVicHW32Descriptor HW32) 
{
	return (GetPin(HW32,11));
}

BOOL VICFN GetLPTPaperEnd(PVicHW32Descriptor HW32) 
{
    return (GetPin(HW32,12));
}

BOOL VICFN GetLPTSlct(PVicHW32Descriptor HW32) 
{
	return (!GetPin(HW32,13));
}

void VICFN LPTAutofd(PVicHW32Descriptor HW32,BOOL Flag) 
{
	SetPin(HW32,14,!Flag);
}

BOOL VICFN GetLPTError(PVicHW32Descriptor HW32) 
{
	return (!GetPin(HW32,15));
}

void VICFN LPTInit(PVicHW32Descriptor HW32) 
{
    SetPin(HW32,16,FALSE);
	for (int i=1; i<1000; i++);
	SetPin(HW32,16,TRUE);

}

void VICFN LPTSlctIn(PVicHW32Descriptor HW32) 
{
    SetPin(HW32,16,FALSE);
	short data = HW32->fDataPorts[2] & 0xf7;
    HW32->fDataPorts[2] = (BYTE)data;
	SetPortByte(HW32,HW32->fLPTBasePort+2,data);
}

BOOL VICFN LPTPrintChar(PVicHW32Descriptor HW32,short ch) 
{
	BOOL Result = FALSE;
	if (HW32->fOpenDrive) {
		SetPortByte(HW32,HW32->fLPTBasePort,(USHORT)(UCHAR)ch);
		if (!GetLPTError(HW32) && !GetLPTBusy(HW32)) {
			LPTStrobe(HW32);
			Result = TRUE;
        };
	};
	return Result;
}

BOOL VICFN GetPin(PVicHW32Descriptor HW32,short nPin) 
{
    BYTE data,ofs,n;
	BOOL Result = FALSE;
    if (!HW32->fOpenDrive || (nPin>17) || (nPin<=0)) return Result;
	n = nPin - 1;
	ofs = PinsPort[n];
	data = (BYTE)GetPortByte(HW32,HW32->fLPTBasePort+ofs);
    Result = (data & MaskPins[n]) != 0;
	if (Negative[n]) Result = !Result;
	return Result;	
}

void VICFN SetPin(PVicHW32Descriptor HW32,short nPin, BOOL bNewValue) 
{
   BYTE data,ofs,n;
   if (!HW32->fOpenDrive || (nPin>17) || (nPin<=0)) return;
   n = nPin-1;
   ofs    = PinsPort[n];
   data   = HW32->fDataPorts[ofs];
   if (bNewValue != Negative[n]) data = data | MaskPins[n];
   else data = data & (~MaskPins[n]);
   SetPortByte(HW32,HW32->fLPTBasePort+ofs,(short)data);
   HW32->fDataPorts[ofs] = data;
}


short VICFN GetMem(PVicHW32Descriptor HW32,long MappedAddr, long Offset) 
{
    if ((!HW32->fOpenDrive) ) return 0;

	return (short)*(PUCHAR)(MappedAddr+Offset);
}

void VICFN SetMem(PVicHW32Descriptor HW32,long MappedAddr, long Offset, short nNewValue) 
{
    if ((!HW32->fOpenDrive) || (MappedAddr<100)) return;
		
    *(PUCHAR)(MappedAddr+Offset) = (UCHAR)nNewValue;

}

short VICFN GetMemW(PVicHW32Descriptor HW32,long MappedAddr, long Offset) 
{
	if ((!HW32->fOpenDrive) || (MappedAddr<100)) return 0;
		
	return (short)*(PUSHORT)(MappedAddr+Offset);
	
}

void VICFN SetMemW(PVicHW32Descriptor HW32,long MappedAddr, long Offset, short nNewValue) 
{
	if ((!HW32->fOpenDrive) || (MappedAddr<100)) return;

    *(PUSHORT)(MappedAddr+Offset) = (USHORT)nNewValue;
}

long VICFN GetMemL(PVicHW32Descriptor HW32,long MappedAddr, long Offset) 
{
	if ((!HW32->fOpenDrive) || (MappedAddr<100)) return 0;

	return (long)*(PULONG)(MappedAddr+Offset);
	
}

void VICFN SetMemL(PVicHW32Descriptor HW32,long MappedAddr, long Offset, long nNewValue) 
{
	if ((!HW32->fOpenDrive) || (MappedAddr<100)) return;

    *(PULONG)(MappedAddr+Offset) = (ULONG)nNewValue;

	
}


BOOL VICFN GetActiveHW(PVicHW32Descriptor HW32) 
{
	return HW32->fOpenDrive;
}

short VICFN GetMappedAreas(PVicHW32Descriptor HW32) 
{
	return HW32->fMappedAreas;
}

long VICFN DebugCode(PVicHW32Descriptor HW32) 
{
	return HW32->fDebugCode;
}
//-------------------------------------------------------------
BOOL 
APIENTRY DllMain(HANDLE hModule, 
                 DWORD  ul_reason_for_call, 
                 LPVOID lpReserved)
{
    switch( ul_reason_for_call ) {
		case DLL_PROCESS_ATTACH:
		//case DLL_THREAD_ATTACH:
            fWin95 = (GetVersion() & 0x80000000) != 0;
			break;
	}
	return TRUE;
};

//-------------------------------------------------------------