ntdrivercode.txt

一个内核驱动的源代码,做内核开发的不错的参考程序

    if ( NT_SUCCESS(Status) )
    {
        // Clear device extension
        RtlZeroMemory((*ppDevObj)->DeviceExtension，sizeof(DEVICE_EXTENSION));
        
        // Create Symbolic link
        RtlInitUnicodeString(&Win32DeviceName，DOS_DEVICE_NAME);
        Status = IoCreateSymbolicLink( &Win32DeviceName，&NtDeviceName );
    }

    if ( !NT_SUCCESS(Status) )
    {
        IoDeleteDevice(*ppDevObj);
    }

    return Status ;
}

NTSTATUS HZMapPortAndMemory(IN PDEVICE_EXTENSION pDevEx)
{
    NTSTATUS           ntStatus = STATUS_UNSUCCESSFUL;
    PHYSICAL_ADDRESS   PortAddress，MemoryAddress，MappedAddress;
    PHYSICAL_ADDRESS   physicalAddressBase;
    ULONG              i，MemType，PortCount，MemoryLength;
    PVOID              PciCfgBasePointer;

    PciCfgBasePointer = (PVOID)(&pDevEx->PCIINFO) ;
    
    // for Amcc port
    MemType = 1;
    PortAddress.LowPart = pDevEx->PCIINFO.u.type0.BaseAddresses[AMCC_IO_INDEX] & 0xFFFFFFFC ;
    PortAddress.HighPart = 0;
    ntStatus = STATUS_UNSUCCESSFUL ;
    PortCount = 0 ;
    for ( i = 0 ; i < pDevEx->PortResourceCount; i ++ )
    {
        if ( PortAddress.LowPart == pDevEx->PortBase[i] )
        {
            PortCount = pDevEx->PortCount[i] ;
            ntStatus = STATUS_SUCCESS ;
            break ;
        }
    }
	
	if ( !NT_SUCCESS( ntStatus ) )
	{
		KdPrint( ("Alloc amcc port error!\n") ) ;
		return STATUS_UNSUCCESSFUL ;
	}

    if ( NT_SUCCESS( ntStatus ) )
    {
        ntStatus = HalTranslateBusAddress( 
			PCIBus，
            pDevEx->BusNumber，
            PortAddress，
            &MemType，
            &MappedAddress );

		if ( !NT_SUCCESS( ntStatus ) )
		{
			KdPrint( ("Alloc amcc port error!\n") ) ;
            return STATUS_UNSUCCESSFUL ;
		}

        if ( MemType == 0 )
        {
			// Port is accessed through memory space - so get a virtual
			// address.
			pDevEx->PortWasMapped = TRUE;
			pDevEx->AmccPortBase = MmMapIoSpace(MappedAddress，PortCount，FALSE);
		}
		else
		{
			pDevEx->PortWasMapped = FALSE;
			pDevEx->AmccPortBase = (PVOID)MappedAddress.LowPart;
		}
		pDevEx->AmccPortLength = PortCount; // get from HalAssignSlotResource
	}

    // for 前端I/O基地址
    MemType = 1;
    PortAddress.LowPart = pDevEx->PCIINFO.u.type0.BaseAddresses[FRONTEND_IO_INDEX] & 0xFFFFFFFC ;
    PortAddress.HighPart = 0;
    ntStatus = STATUS_UNSUCCESSFUL ;
    PortCount = 0 ;
    for ( i = 0 ; i < pDevEx->PortResourceCount; i ++ )
    {
        if ( PortAddress.LowPart == pDevEx->PortBase[i] )
        {
            PortCount = pDevEx->PortCount[i] ;
            ntStatus = STATUS_SUCCESS ;
            break ;
        }
	}

	if ( !NT_SUCCESS( ntStatus ) )
	{
		KdPrint( ("Alloc front port error!\n") ) ;
		return STATUS_UNSUCCESSFUL ;
	}

    if ( NT_SUCCESS( ntStatus ) )
    {
        ntStatus = HalTranslateBusAddress( 
                    PCIBus，
                    pDevEx->BusNumber，
                    PortAddress，
                    &MemType，
                    &MappedAddress );

		if ( !NT_SUCCESS( ntStatus ) )
		{
			KdPrint( ("Alloc front port error!\n") ) ;
            return STATUS_UNSUCCESSFUL ;
		}

        if ( MemType == 0 )
        {
            // Port is accessed through memory space - so get a virtual
            // address.
            pDevEx->PortWasMapped = TRUE;
            pDevEx->HZFrontendIoBaseAddress = MmMapIoSpace(MappedAddress，PortCount，FALSE);
        }
        else
        {
            pDevEx->PortWasMapped = FALSE;
            pDevEx->HZFrontendIoBaseAddress = (PVOID)MappedAddress.LowPart;
        }
        pDevEx->HZFrontendIoLength = PortCount; // get from HalAssignSlotResource
    }

    // for 后端I/O基地址
    MemType = 1;
    PortAddress.LowPart = pDevEx->PCIINFO.u.type0.BaseAddresses[BACKEND_IO_INDEX] & 0xFFFFFFFC ;
    PortAddress.HighPart = 0;
    ntStatus = STATUS_UNSUCCESSFUL ;
    PortCount = 0 ;
    for ( i = 0 ; i < pDevEx->PortResourceCount; i ++ )
    {
        if ( PortAddress.LowPart == pDevEx->PortBase[i] )
        {
            PortCount = pDevEx->PortCount[i] ;
            ntStatus = STATUS_SUCCESS ;
            break ;
        }
    }

	if ( !NT_SUCCESS( ntStatus ) )
	{
		KdPrint( ("Alloc back port error!\n") ) ;
		return STATUS_UNSUCCESSFUL ;
	}

    if ( NT_SUCCESS( ntStatus ) )
    {
        ntStatus = HalTranslateBusAddress( 
			PCIBus，
			pDevEx->BusNumber，
			PortAddress，
			&MemType，
			&MappedAddress );

		if ( !NT_SUCCESS( ntStatus ) )
		{
			KdPrint( ("Alloc back port error!\n") ) ;
            return STATUS_UNSUCCESSFUL ;
		}

        if ( MemType == 0 )
        {
            // Port is accessed through memory space - so get a virtual
            // address.
            pDevEx->PortWasMapped = TRUE;
            pDevEx->HZBackendIoBaseAddress = MmMapIoSpace(MappedAddress，PortCount，FALSE);
        }
        else
        {
            pDevEx->PortWasMapped = FALSE;
            pDevEx->HZBackendIoBaseAddress = (PVOID)MappedAddress.LowPart;
        }
        pDevEx->HZBackendIoLength = PortCount; // get from HalAssignSlotResource
    }

    // 前端memory基地址
    MemoryAddress.LowPart = pDevEx->PCIINFO.u.type0.BaseAddresses[FRONTEND_MEMORY_INDEX] & 0xFFFFFFF0 ;
    MemoryAddress.HighPart = 0;
    ntStatus = STATUS_UNSUCCESSFUL ;
    MemoryLength = 0;
    for ( i = 0 ; i < pDevEx->MemoryResourceCount; i ++ )
    {
        if ( MemoryAddress.LowPart == pDevEx->MemoryBase[i] )
        {
            MemoryLength = pDevEx->MemoryLength[i] ;
            ntStatus = STATUS_SUCCESS ;
            break ;
        }
    }

	if ( !NT_SUCCESS( ntStatus ) )
	{
		KdPrint( ("Alloc front memory error!\n") ) ;
		return STATUS_UNSUCCESSFUL ;
	}

    if ( MemoryLength == 0 && MemoryLength > 0x80000 )
        MemoryLength = 0x4000 ;
    if ( NT_SUCCESS( ntStatus ) )
    {    
        ULONG inIoSpace = 0 ;
	
        ntStatus = HalTranslateBusAddress (PCIBus，
			pDevEx->BusNumber，
			MemoryAddress，
			&inIoSpace，
			&physicalAddressBase );

		if ( !NT_SUCCESS( ntStatus ) )
		{
			KdPrint( ("Alloc front memory error!\n") ) ;
            return STATUS_UNSUCCESSFUL ;
		}

        if ( !inIoSpace )
        {               
            pDevEx->HZMemoryBase = MmMapIoSpace(physicalAddressBase，MemoryLength，FALSE) ;
            pDevEx->MemoryWasMapped = TRUE ;
        }
        else
        {
            pDevEx->MemoryWasMapped = FALSE ;
            *((PVOID *)pDevEx->HZMemoryBase) = (PVOID) physicalAddressBase.LowPart ;
        }
        pDevEx->HZMemoryLength = MemoryLength ;
    }

    if ( pDevEx->AmccPortBase == NULL || pDevEx->HZFrontendIoBaseAddress == NULL ||
         pDevEx->HZBackendIoBaseAddress == NULL || pDevEx->HZMemoryBase == NULL )
        ntStatus = STATUS_UNSUCCESSFUL ;

    return ntStatus ;
}


NTSTATUS HZUnMapPortAndMemory(IN PDEVICE_EXTENSION pDevEx)
{
    NTSTATUS   Status;

    if (pDevEx->PortWasMapped)
    {
        MmUnmapIoSpace(pDevEx->AmccPortBase             ， pDevEx->AmccPortLength      );
        MmUnmapIoSpace(pDevEx->HZFrontendIoBaseAddress， pDevEx->HZFrontendIoLength);
        MmUnmapIoSpace(pDevEx->HZBackendIoBaseAddress ， pDevEx->HZBackendIoLength );
    }
    
    Status = ZwUnmapViewOfSection ( (HANDLE) -1，
                                    pDevEx->HZMemoryBase );
    if ( !NT_SUCCESS(Status) )
    {
        KdPrint (("Unmap memory failed\n"));
    }
    return Status;
}

NTSTATUS HZInitAdapter( IN PIRP pIrp， IN PDEVICE_EXTENSION pDevEx )
{
    NTSTATUS   Status;
    PINITIALIZE_ADAPTER_STRU_IN     pIOBuffer ;
    ULONG   dwBufferOffsetIn32Bits ;
    BOOLEAN   bNegative  ;
    BOOLEAN   bMirror  ;
    BOOLEAN   bMode_Set=TRUE  ;
    BOOLEAN   bIsF_Trans  ;
    ULONG     dwBeam_Size ;
    ULONG     dwDiv_Size ;
    PBUFFER_NODE lpTmp = NULL ;

    pIOBuffer = (PINITIALIZE_ADAPTER_STRU_IN) pIrp->AssociatedIrp.SystemBuffer ;
    
    // initial print parameter
    {
        dwBufferOffsetIn32Bits          = pIOBuffer->dwSRAMBufferOffsetIn32Bits ;
        pDevEx->dwLastSramOffsetIn32Bits= pIOBuffer->dwLastSramOffsetIn32Bits ;
        pDevEx->dwWaitIACKPerMiliSecond = pIOBuffer->dwWaitIackTimesPerMiliSecond ;
        pDevEx->dwOneLineOutputIn32Bits = pIOBuffer->dwOneLineOutputIn32Bits ;
        pDevEx->dwTotalSramNum          = pIOBuffer->dwSramNum ;
		pDevEx->dwSramNumCounter = 0;

        bMirror  = pIOBuffer->bMirror  ;
		bNegative  = pIOBuffer->bNegative  ;
        dwBeam_Size  = pIOBuffer->dwBeam_Size  ;
        dwDiv_Size  = pIOBuffer->dwDiv_Size  ;
		bIsF_Trans = pIOBuffer->bJump ;
    }
    // 初始化控制变量
    {
        pDevEx->FOPR          = FOPR_INIT_VALUE ;
        pDevEx->FCR           = FCR_INIT_VALUE  ;
        pDevEx->BOPR0         = BOPR0_INIT_VALUE;
        pDevEx->BOPR1         = BOPR1_INIT_VALUE;
        pDevEx->BMR           = BMR_INIT_VALUE  ;
        pDevEx->bIsPreSend    = FALSE ;
    }
    // 复位控制卡
    {
        ResetOP(pDevEx) ;
    }
    // 设置NEGATIVE，MODE_SET，BEAM_SIZE，DIV_SIZE
    {/*
        if ( bMode_Set )
            SetMode_Set(pDevEx) ;
        SetBeam_Size(pDevEx，dwBeam_Size);
		if( bIsF_Trans )
			SetF_Trans(pDevEx);
        SetDiv_Size(pDevEx，dwDiv_Size);*/
        if ( bNegative )
            SetNegative(pDevEx) ;
        if ( bMirror )
            SetMirror(pDevEx) ;
    }    
    // 设置SRAM的偏移地址
    {                      
        SetSRAMBufferOffset(pDevEx，dwBufferOffsetIn32Bits) ;
    }
    // 设置中断源
    {
        if ( pDevEx->PortWasMapped )
            WRITE_REGISTER_ULONG( ((PULONG)pDevEx->AmccPortBase+AMCC_INTCSR_INDEX)， SELECT_INTERRUPT_SOURCE ) ;
        else
            WRITE_PORT_ULONG( ((PULONG)pDevEx->AmccPortBase+AMCC_INTCSR_INDEX)，SELECT_INTERRUPT_SOURCE ) ;
    }
    // 初始化内存链
    {
        lpTmp = (PBUFFER_NODE) pDevEx->lpHeadNode ;
        
        do {
            lpTmp->NodeFlag = NODE_EMPTY ;
            RtlZeroMemory(lpTmp->lpBuffer，0x80000) ;
            lpTmp = lpTmp->lpNextNode ;
        } while ( lpTmp != (PBUFFER_NODE)pDevEx->lpHeadNode ) ;
        pDevEx->lpWriteNode = pDevEx->lpHeadNode ;
        pDevEx->lpReadNode = pDevEx->lpHeadNode ;
    }
    // 初始化打印状态参数
    {
        pDevEx->Status = STATUS_SUCCESS ;
    }