C++ MmUnmapIoSpace函数代码示例

uint32 peChecksumExecSections(uint8 *peBaseAddr, 
                              void *realBase, 
                              PEPROCESS proc, 
                              PKAPC_STATE apc, 
                              PHYSICAL_ADDRESS *physArr)
{
    uint16 numExecSections = peGetNumExecSections(peBaseAddr);
    uint32 checksum = 0, k, i, j, 
                        numRelocs = peGetNumberOfRelocs(peBaseAddr, realBase, proc, apc), 
                        relocDelta = peCalculateRelocDiff(peBaseAddr, realBase);
    uint8 *dataPtr = NULL;
    PHYSICAL_ADDRESS phys = {0};
    SectionData *execSections = (SectionData *) MmAllocateNonCachedMemory(
                                                numExecSections * sizeof(SectionData));
    peGetExecSections(peBaseAddr, execSections);
    
    //DbgPrint("Found %d relocations, delta of: %x\r\n", numRelocs, relocDelta);
    
    for (i = 0; i < numExecSections; i++)
    {   
        uint32 numpages = execSections[i].Size / 0x1000, size = execSections[i].Size;
        if (numpages * 0x1000 < execSections[i].Size)
            numpages++;
        for (k = 0; k < numpages; k++)
        {
            KeStackAttachProcess(proc, apc); 
            dataPtr = (uint8 *) MmMapIoSpace(MmGetPhysicalAddress((void *)(((uint32) realBase) +
                        execSections[i].VirtualAddress + (0x1000 * k))),
                        0x1000, 0);
            phys = MmGetPhysicalAddress((void *) dataPtr);

            for (j = 0; j < min(size, 0x1000); j++)
            {
                checksum += dataPtr[j];
            }
            MmUnmapIoSpace((void *) dataPtr, 0x1000);
            size -= 0x1000;
            KeUnstackDetachProcess(apc);
        }
    }
    
    // Subtract the relocations from the checksum
    // TODO Fix incase of lower load address
    checksum += numRelocs * (relocDelta & 0x000000FF);
    checksum += numRelocs * ((relocDelta & 0x0000FF00) >> 8);
    checksum += numRelocs * ((relocDelta & 0x00FF0000) >> 16);
    checksum += numRelocs * ((relocDelta & 0xFF000000) >> 24);
    
    
    MmFreeNonCachedMemory((void *) execSections, numExecSections * sizeof(SectionData));
    return checksum;
}

CRomiDisk::~CRomiDisk(
    )
{
    FreeDMABuffers();

    if ( m_vpSYSCONRegs)
    {
        MmUnmapIoSpace((PVOID)m_vpSYSCONRegs, sizeof(S3C6410_SYSCON_REG));
        m_vpSYSCONRegs= NULL;
    }

    if ( m_vpIOPORTRegs)
    {
        MmUnmapIoSpace((PVOID)m_vpIOPORTRegs, sizeof(S3C6410_GPIO_REG));
        m_vpIOPORTRegs= NULL;
    }

    if ( m_pDMAVirtualAddress )
    {
        PHYSICAL_ADDRESS PhysicalAddress;

        PhysicalAddress.LowPart = m_DMAPhyaddress.LowPart;
        HalFreeCommonBuffer(0, 0, PhysicalAddress, (PVOID)m_pDMAVirtualAddress, FALSE);
        m_pDMAVirtualAddress = NULL;
    }

    InterlockedDecrement(&m_lDeviceCount);

    DEBUGMSG(ZONE_INIT|ZONE_PCI, (_T(
        "Atapi!CRomiDisk::~CRomiDisk> device count(%d)\r\n"
        ), m_lDeviceCount));
}

void CameraDeinit()
{
    RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraDeInit\n")));

    if(s6410IOP != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410IOP, sizeof(S3C6410_GPIO_REG));
        s6410IOP = NULL;
    }
    if(s6410CAM != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410CAM, sizeof(S3C6410_CAMIF_REG));
        s6410CAM = NULL;
    }
    if(s6410PWR != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410PWR, sizeof(S3C6410_SYSCON_REG));
        s6410PWR = NULL;
    }

    ModuleDeinit();
    DeinitializeBuffer();

    
//    CloseHandle(hCaptureThread);
//    CloseHandle(hPreviewThread);
    bCaptureThreadExit = TRUE;
    SetEvent(hCaptureEvent);
    bPreviewThreadExit = TRUE;
    SetEvent(hPreviewEvent);
    CloseHandle(hCaptureEvent);
    CloseHandle(hPreviewEvent);
    RETAILMSG(CAM_INOUT,(TEXT("------------------CameraDeInit\n")));
}

/*************************************************************************************
// 		Function: BspBattDeallocResource
// 	     Purpose:dellloc resource for battery driver
//       Returns: N/A
//***********************************************************************************/
void 
BspBattDeallocResource( void)
{
	DPNOK(0);
    DeinitPinMuxMutex(g_hADCMutex);
    g_hADCMutex = NULL;

    g_bLedThreadExit = TRUE;
    if(g_hevLEDStatus)
        CloseHandle(g_hevLEDStatus);
        g_hevLEDStatus = NULL;	
    if(g_hNotifyLedThread)
        CloseHandle(g_hNotifyLedThread);
        g_hNotifyLedThread = NULL;	
    if (g_hevBatteryStatus)
	CloseHandle(g_hevBatteryStatus);
    g_hevBatteryStatus = NULL;

#if 1
	DPSTR("MmUnmapIoSpace");
	MmUnmapIoSpace(g_pBspArgs, sizeof(BSP_ARGS));
	MmUnmapIoSpace(v_p2450IOP, sizeof(S3C2450_IOPORT_REG));
	MmUnmapIoSpace(v_pADCregs, sizeof(S3C2450_ADC_REG));
	MmUnmapIoSpace(v_pUSBCtrlAddr, sizeof(S3C2450_USBD_REG));	
#endif
 	

	
	
//    BspPowerStatesManagerDeInit();
//    CspRegUnMap();
}//endof BspBatDeallocResource

//-----------------------------------------------------------------------------
//
//  Function:  SMARTREFLEX_DeinitPolicy
//
//  Policy uninitialization
//
BOOL
SMARTREFLEX_DeinitPolicy(
    HANDLE hPolicyAdapter
    )
{
    BOOL rc = FALSE;

    RETAILMSG(ZONE_FUNCTION, (
      L"+SMARTREFLEX_DeinitPolicy(0x%08x)\r\n",
      hPolicyAdapter
      ));

    // validate parameters
    if (hPolicyAdapter != (HANDLE)&s_SmartReflexLoadPolicyInfo)
        {
        RETAILMSG (ZONE_ERROR, (L"ERROR: SMARTREFLEX_DeinitPolicy:"
            L"Incorrect context parameter\r\n"
            ));
        goto cleanUp;
        }

    //unmap vdd1 voltage register to virtual memory
    MmUnmapIoSpace(s_VddOptimizationInfo[0].pPrcmRegistryAddress,sizeof(UINT32));

    //unmap vdd2 voltage register to virtual memory
    MmUnmapIoSpace(s_VddOptimizationInfo[1].pPrcmRegistryAddress,sizeof(UINT32));

    //unregisted DVFS change callback function
    PmxUnregisterConstraintCallback(s_SmartReflexLoadPolicyInfo.hDvfsConstraint,
                                    DvfsConstraintCallback
                                    );

    //release DVFS constraint handler
    PmxReleaseConstraint(s_SmartReflexLoadPolicyInfo.hDvfsConstraint);

    //stop thread gracefuly
    if (s_SmartReflexLoadPolicyInfo.hSmartReflexSensingThread != NULL)
        {
        s_SmartReflexLoadPolicyInfo.bExitThread = TRUE;
        SetEvent(s_SmartReflexLoadPolicyInfo.hSmartReflexSensingEvent);
        WaitForSingleObject(s_SmartReflexLoadPolicyInfo.hSmartReflexSensingThread, INFINITE);
        CloseHandle(s_SmartReflexLoadPolicyInfo.hSmartReflexSensingThread);
        }

    //close sync event hanle
    CloseHandle(s_SmartReflexLoadPolicyInfo.hSmartReflexSensingEvent);

    // clear main policy structure
    memset(&s_SmartReflexLoadPolicyInfo, 0, sizeof(SmartReflexPolicyInfo_t));

    rc = TRUE;

cleanUp:
    RETAILMSG(ZONE_FUNCTION, (L"-SMARTREFLEX_DeinitPolicy()\r\n"));
    return rc;
}

NTSTATUS
PLxEvtDeviceReleaseHardware(
    IN  WDFDEVICE Device,
    IN  WDFCMRESLIST ResourcesTranslated
    )
/*++

Routine Description:

    Unmap the resources that were mapped in PLxEvtDevicePrepareHardware.
    This will only be called when the device stopped for resource rebalance,
    surprise-removed or query-removed.

Arguments:

    Device - A handle to the WDFDEVICE

    ResourcesTranslated - The translated PnP resources associated with the
        device.  This is what is important to a PCI device.

Return Value:

    NT status code - failure will result in the device stack being torn down

--*/
{
	KdPrint(("Entry PLxEvtDeviceReleaseHardware Routine"));
    PDEVICE_EXTENSION   devExt;
    NTSTATUS status = STATUS_SUCCESS;

    UNREFERENCED_PARAMETER(ResourcesTranslated);

    PAGED_CODE();

    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
                "--> PLxEvtDeviceReleaseHardware");

    devExt = PLxGetDeviceContext(Device);

    if (devExt->RegsBase) {

        MmUnmapIoSpace(devExt->RegsBase, devExt->RegsLength);
        devExt->RegsBase = NULL;
    }

    if(devExt->SRAMBase){
        MmUnmapIoSpace(devExt->SRAMBase, devExt->SRAMLength);
        devExt->SRAMBase = NULL;
    }

    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
                "<-- PLxEvtDeviceReleaseHardware");

	KdPrint(("Leave PLxEvtDeviceReleaseHardware Routine"));
    return status;
}

VOID
ScrLoadFontTable(UINT32 CodePage)
{
    PHYSICAL_ADDRESS BaseAddress;
    PUCHAR Bitplane;
    PUCHAR FontBitfield = NULL;
    NTSTATUS Status = STATUS_SUCCESS;

    FontBitfield = (PUCHAR) ExAllocatePoolWithTag(NonPagedPool, 2048, TAG_BLUE);
    if(FontBitfield)
    {
        /* open bit plane for font table access */
        OpenBitPlane();

        /* get pointer to video memory */
        BaseAddress.QuadPart = BITPLANE_BASE;
        Bitplane = (PUCHAR)MmMapIoSpace (BaseAddress, 0xFFFF, MmNonCached);

        Status = ExtractFont(CodePage, FontBitfield);
        if (NT_SUCCESS(Status))
            LoadFont(Bitplane, FontBitfield);

        MmUnmapIoSpace(Bitplane, 0xFFFF);
        ExFreePool(FontBitfield);

        /* close bit plane */
        CloseBitPlane();
    }
}

VOID
SynthCleanup(
    IN   PGLOBAL_SYNTH_INFO pGDI
)

/*++

Routine Description:

    Clean up all resources allocated by our initialization

Arguments:

    pGDI - Pointer to global data

Return Value:

    NONE

--*/

{
    //
    //  Owning driver will remove all devices and free global data
    //

    if (pGDI->Hw.SynthBase && pGDI->MemType == 0) {
        ASSERT(pGDI->Key == SYNTH_KEY);
        MmUnmapIoSpace(pGDI->Hw.SynthBase, NUMBER_OF_SYNTH_PORTS);
    }
    pGDI->Hw.SynthBase = NULL;
}

// HelpMapMMIOSpace: Map MMIO space
bool HelpMapMMIOSpace(
    uint64  address,         // IN
    size_t  size,            // IN
    uint64* mappedAddress,   // OUT
    uint64* mappedSize)      // OUT
{
    bool result = false;
    void* pLinearAddress = NULL;
    PHYSICAL_ADDRESS physicalAddress;

    ResetPoolMemory(&physicalAddress, sizeof(PHYSICAL_ADDRESS));
    physicalAddress.QuadPart = address;

    pLinearAddress = static_cast<PUCHAR>(MmMapIoSpace(physicalAddress, size, MmNonCached));

    if (NULL != pLinearAddress)
    {
        if (MmIsAddressValid(pLinearAddress))
        {
            *mappedAddress = reinterpret_cast<uint64>(pLinearAddress);
            *mappedSize = size;
            result = true;
        }
        else
        {
            MmUnmapIoSpace(pLinearAddress, size);
        }
    }

    return result;
}

// The function that initilize the register for HSMMC Control.
BOOL CSDHControllerCh1::InitHSMMC() {
    volatile S3C6410_HSMMC_REG *pHSMMC = NULL;
    PHYSICAL_ADDRESS    ioPhysicalBase = {0,0};

    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_HSMMC1;
    pHSMMC = (volatile S3C6410_HSMMC_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_HSMMC_REG), FALSE);
    if (pHSMMC == NULL) {
        RETAILMSG(TRUE, (TEXT("[HSMMC1] HSMMC Special Register is *NOT* mapped.\n")));
        return FALSE;
    }

#ifdef _SRCCLK_48MHZ_
    RETAILMSG(TRUE, (TEXT("[HSMMC1] Setting registers for the USB48MHz (EXTCLK) : HSMMCCon.\n")));
    // Set the clock source to USB_PHY for CLKMMC1
    pHSMMC->CONTROL2 = (pHSMMC->CONTROL2 & ~(0xffffffff)) |
        (0x3<<9) |  // Debounce Filter Count 0x3=64 iSDCLK
        (0x1<<8) |  // SDCLK Hold Enable
        (0x3<<4);   // Base Clock Source = External Clock
#else
    RETAILMSG(TRUE, (TEXT("[HSMMC1] Setting registers for the EPLL : HSMMCCon.\n")));
    // Set the clock source to EPLL out for CLKMMC1
    pHSMMC->CONTROL2 = (pHSMMC->CONTROL2 & ~(0xffffffff)) |
        (0x3<<9) |  // Debounce Filter Count 0x3=64 iSDCLK
        (0x1<<8) |  // SDCLK Hold Enable
        (0x2<<4);   // Base Clock Source = EPLL out
#endif

    MmUnmapIoSpace((PVOID)pHSMMC, sizeof(S3C6410_HSMMC_REG));
    return TRUE;
}

VOID
XenGfxFreeResources(XENGFX_DEVICE_EXTENSION *pXenGfxExtension)
{
    PAGED_CODE();
    // T & S Level 3
    XenGfxDisableVCrtcs(pXenGfxExtension);

    if (pXenGfxExtension->pSources != NULL) {
        ExFreePoolWithTag(pXenGfxExtension->pSources, XENGFX_TAG);
        pXenGfxExtension->pSources = NULL;
    }

    XenGfxFreeVCrtcBanks(pXenGfxExtension);

    if (pXenGfxExtension->pXgfxRegs != NULL) {
        MmUnmapIoSpace(pXenGfxExtension->pXgfxRegs,
                       pXenGfxExtension->XgfxRegistersDescriptor.u.Memory.Length);
        pXenGfxExtension->pXgfxRegs = NULL;
        pXenGfxExtension->pGartRegs = NULL;
        pXenGfxExtension->pVCrtcsRegs = NULL;
        pXenGfxExtension->pGlobalRegs = NULL;        
        pXenGfxExtension->pGartBaseReg = NULL;
    }

    RtlZeroMemory(&pXenGfxExtension->GraphicsApertureDescriptor,
                  sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
    RtlZeroMemory(&pXenGfxExtension->XgfxRegistersDescriptor,
                  sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));

    pXenGfxExtension->pPhysicalDeviceObject = NULL;
    pXenGfxExtension->hDxgkHandle = NULL;
}

 ~CPdd6410Serial3()
 {
     if(m_pSysconRegs)
     {
         m_pSysconRegs->PCLK_GATE  &= ~PCLK_UART3;        // UART3
         m_pSysconRegs->SCLK_GATE  &= ~SCLK_UART;        // UART0~3
     }
     if (m_pIOPregs!=NULL)
     {
         MmUnmapIoSpace((PVOID)m_pIOPregs, sizeof(S3C6410_GPIO_REG));
     }
     if (m_pSysconRegs!=NULL)
     {
         MmUnmapIoSpace((PVOID)m_pSysconRegs, sizeof(S3C6410_SYSCON_REG));
     }
 }

/*
 * @implemented
 */
VOID
EXPORT
NdisMUnmapIoSpace(
    IN  NDIS_HANDLE MiniportAdapterHandle,
    IN  PVOID       VirtualAddress,
    IN  UINT        Length)
/*
 * FUNCTION: Un-maps space previously mapped with NdisMMapIoSpace
 * ARGUMENTS:
 *     MiniportAdapterHandle: handle originally passed into MiniportInitialize
 *     VirtualAddress: Address to un-map
 *     Length: length of the mapped memory space
 * NOTES:
 *     - Must be called at IRQL = PASSIVE_LEVEL
 *     - Must only be called from MiniportInitialize and MiniportHalt
 *     - See also: NdisMMapIoSpace
 * BUGS:
 *     - Depends on MmUnmapIoSpace to Do The Right Thing in all cases
 */
{
  PAGED_CODE();

  ASSERT(MiniportAdapterHandle);

  MmUnmapIoSpace(VirtualAddress, Length);
}

CPdd6410Uart::~CPdd6410Uart()
{
    InitModem(FALSE);
    if (m_hISTEvent)
    {
        m_bTerminated=TRUE;
        ThreadStart();
        SetEvent(m_hISTEvent);
        ThreadTerminated(1000);
        InterruptDisable( m_dwSysIntr );         
        CloseHandle(m_hISTEvent);
    };
    if (m_pReg6410Uart)
    {
        delete m_pReg6410Uart;
    }
    if (m_XmitFlushDone)
    {
        CloseHandle(m_XmitFlushDone);
    }
    if (m_pRegVirtualAddr != NULL)
    {
        MmUnmapIoSpace((PVOID)m_pRegVirtualAddr,sizeof(S3C6410_UART_REG));
    }        
}

NTSTATUS
TpmEvtDeviceReleaseHardware(
							IN  WDFDEVICE Device,
							IN  WDFCMRESLIST ResourcesTranslated
    )
{
    PTPM_CONTEXT                TpmContext;

	PAGED_CODE();

    TpmContext = GetTpmContext(Device);

    KdPrintEx((DPFLTR_PNPMEM_ID, DPFLTR_INFO_LEVEL,
        "TpmEvtDeviceReleaseHardware\n"));

#if _NT_TARGET_VERSION >= 0x601
    if(TpmContext->hEntropySource)
        EntropyUnregisterSource(TpmContext->hEntropySource);
    TpmContext->hEntropySource = NULL;
#endif

    if(TpmContext->MemAddr)
        MmUnmapIoSpace(TpmContext->MemAddr,TpmContext->MemLen);
    TpmContext->MemAddr = NULL;
    TpmContext->MemLen  = 0;

    KdPrintEx((DPFLTR_PNPMEM_ID, DPFLTR_INFO_LEVEL,
        "TpmEvtDeviceReleaseHardware exited with Status code 0x%x\n",STATUS_SUCCESS));

    return STATUS_SUCCESS;
}