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;
}

NTSTATUS
BalloonEvtDeviceReleaseHardware (
    IN WDFDEVICE      Device,
    IN WDFCMRESLIST   ResourcesTranslated
    )
{
    PDEVICE_CONTEXT     devCtx = NULL;

    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);

    UNREFERENCED_PARAMETER(ResourcesTranslated);

    PAGED_CODE();

    devCtx = GetDeviceContext(Device);

    if(devCtx->PortBase && devCtx->PortMapped)
    {
        MmUnmapIoSpace( devCtx->PortBase,  devCtx->PortCount );
    }

    devCtx->PortBase = NULL;

    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
    return STATUS_SUCCESS;
}

RegCtrlG2D::~RegCtrlG2D()
{
    if (m_pG2DReg != NULL)
    {
        MmUnmapIoSpace((PVOID)m_pG2DReg, sizeof(G2D_REG));
        m_pG2DReg = NULL;
    }
}

VOID
NTAPI
HalpUnmapVirtualAddress(IN PVOID VirtualAddress,
                        IN ULONG NumberPages)
{
    /* Use kernel memory manager I/O map facilities */
    MmUnmapIoSpace(VirtualAddress, NumberPages << PAGE_SHIFT);
}

uint32 peGetNumberOfRelocs(uint8 *peBaseAddr, void *realBase, PEPROCESS proc, PKAPC_STATE apc)
{
    ImageDosHeader *dosHeader = NULL;
    ImageNtHeaders *ntHeaders = NULL;
    ImageSectionHeader *sectionHeader = NULL;
    ImageBaseRelocation *relocationPtr = NULL, *bkupRPtr = NULL;
    uint32 numRelocs = 0;
    PageTableEntry *pte = NULL;
    PHYSICAL_ADDRESS phys = {0};
    
    uint16 i, j = 0, execSectionCount = 0, numSections = 0;
    
    dosHeader = (ImageDosHeader *) peBaseAddr;
    ntHeaders = (ImageNtHeaders *) ((uint8 *) peBaseAddr + dosHeader->e_lfanew);
    numSections = ntHeaders->FileHeader.NumberOfSections;
    sectionHeader = (ImageSectionHeader *) &ntHeaders[1];
    
    for (i = 0; i < numSections; i++)
    {
        if(strncmp(sectionHeader[i].Name, ".reloc", 8) == 0)
            break;
    }
    if(strncmp(sectionHeader[i].Name, ".reloc", 8) != 0)
            return 0;
    /*DbgPrint("Found %.08s RVA: %x Characteristics: %x", sectionHeader[i].Name, 
                                                        sectionHeader[i].VirtualAddress,
                                                        sectionHeader[i].Characteristics);*/

    //KeStackAttachProcess(proc, apc);
    pte = pagingMapInPte(targetCR3, (uint8 *) (((uint32) realBase) +
                                sectionHeader[i].VirtualAddress));
    if (pte == NULL)
        return 0;
    phys.LowPart = pte->address << 12;
    pagingMapOutEntry(pte);

    relocationPtr = (ImageBaseRelocation *) MmMapIoSpace(phys,
            PAGE_SIZE,
            0);
    bkupRPtr = relocationPtr;        
    /*DbgPrint("%p + %x = %x", realBase, sectionHeader[i].VirtualAddress, (((uint32) realBase) +
                                sectionHeader[i].VirtualAddress));*/
    i = 0;
    do
    {       
        //DbgPrint("RP: %x %x\r\n", relocationPtr->VirtualAddress, relocationPtr->SizeOfBlock); 
        numRelocs += (relocationPtr->SizeOfBlock - sizeof(*relocationPtr)) / sizeof(uint16);
        relocationPtr = (ImageBaseRelocation *) ((uint8 *) relocationPtr + relocationPtr->SizeOfBlock);
        i++;
    } while(relocationPtr->SizeOfBlock != 0);
    MmUnmapIoSpace(bkupRPtr, PAGE_SIZE);
    //KeUnstackDetachProcess(apc);
   //DbgPrint("I %d\r\n", i);
   
    // Size of the table (minus the header) divided by the size of each entry
    // FIXME Figure out why this is the case
    return numRelocs - (i);
}

VOID
PushUnload( DRIVER_OBJECT* DriverObject )
{
    UNICODE_STRING DeviceLinkU;
    NTSTATUS ntStatus;
    PMAPINFO pMapInfo;
    PSINGLE_LIST_ENTRY pLink;

    DbgPrint("[Push] => (PushUnload)");

    RdUnload(DriverObject);

    //free resources
    pLink=PopEntryList(&lstMapInfo);
    while(pLink)
    {
        pMapInfo=CONTAINING_RECORD(pLink, MAPINFO, link);

        MmUnmapLockedPages(pMapInfo->pvu, pMapInfo->pMdl);
        IoFreeMdl(pMapInfo->pMdl);
        MmUnmapIoSpace(pMapInfo->pvk, pMapInfo->memSize);

        ExFreePool(pMapInfo);

        pLink=PopEntryList(&lstMapInfo);
    }


    //
    //  By default the I/O device is configured incorrectly or the
    // configuration parameters to the driver are incorrect.
    //
    ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;

    //
    // restore the call back routine, thus givinig chance to the
    // user mode application to unload dynamically the driver
    //
    ntStatus = PsSetCreateProcessNotifyRoutine(ProcessCallback, TRUE);

    IoDeleteDevice(DriverObject->DeviceObject);

    RtlInitUnicodeString(&DeviceLinkU, PUSH_SYMLINK_NAME);

    ntStatus=IoDeleteSymbolicLink(&DeviceLinkU);

    if (NT_SUCCESS(ntStatus))
    {
        IoDeleteDevice(DriverObject->DeviceObject);
    }
    else
    {
        DbgPrint("Error: IoDeleteSymbolicLink failed");
    }

    DbgPrint("[Push] <= (PushUnload)");
}