/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995, 1996, 1997, 1998  Microsoft Corporation

Module Name:  
    mem.hpp

Abstract:  
    Definitions for OHCD memory manager.
    
Notes: 

--*/
#ifndef _MEM_HPP_
#define _MEM_HPP_

#define USBPAGESIZE 4096    // Spec'ed to be 4kB
#define USBPAGEMASK USBPAGESIZE - 1

//
// Hook these if you want to track local memory allocations.
//
#define OHCD_Alloc  LocalAlloc
#define OHCD_Free   LocalFree

#define MEMLIST_NEXT_PA(pnode)  (pnode->dwPhysAddr + pnode->dwSize)


typedef struct tMEMLIST   MEMLIST;
typedef struct tMEMLIST* PMEMLIST;
struct tMEMLIST
{
    DWORD       dwVirtAddr;
    DWORD       dwPhysAddr;
    DWORD       dwSize;
    PMEMLIST    next;
    PMEMLIST    prev;
};




LPVOID AllocatePhysicalMemory(UINT cbSize, LPULONG ppaBuffer);
BOOL FreePhysicalMemory(LPVOID lpMemory, UINT cbSize);


#ifdef DEBUG
#define VALIDATE_HEAPS(fHighPri)  ValidateHeaps(fHighPri)
#else
#define VALIDATE_HEAPS(fHighPri)
#endif


//
// Flag defines for AllocateMemory / FreeMemory
//
#define USBALLOCF_SPECIAL       0x0001  // Special USBPAGE allocation
#define USBALLOCF_HIGHPRIORITY  0x0002  // Allocates from High Priority region first
#define USBALLOCF_NOBLOCK       0x0004  // Call doesn't block if no memory available.

class CPhysMem
{
public:
    CPhysMem(DWORD cbSize, DWORD cbHighPrioritySize, PUCHAR pVirtAddr, PUCHAR pPhysAddr);
    ~CPhysMem();

    EError
    AllocateMemory(
        UINT size,
        PUCHAR *pVirtAddr,
        ULONG *pPhysAddr,
        DWORD dwFlags = 0,
        BOOL* pfRequestingAbort = NULL);

    EError
    FreeMemory(
        PUCHAR virtAddr,
        ULONG physAddr,
        DWORD dwFlags = 0);

    EError
    ReleaseBlockedCalls();

    inline ULONG
    VaToPa(PUCHAR virtAddr);

    inline PUCHAR
    PaToVa(ULONG physAddr);

#ifdef DEBUG
    BOOL ValidateHeaps(BOOL fHighPri);

    EError DebugAllocateMemory(UINT size, PUCHAR * pVirtAddr,
            ULONG *pPhysAddr, DWORD dwFlags, BOOL * pfRequestingAbort,
            TCHAR *szFile, DWORD dwLine);

    EError DebugFreeMemory(PUCHAR virtAddr,ULONG physAddr,DWORD dwFlags,
            TCHAR *szFile, DWORD dwLine);

#endif

private:
    EError AddNodeToInUseList(PMEMLIST pNode, BOOL fHighPri);
    EError AddNodeToFreeList(PMEMLIST pNode, BOOL fHighPri);
    
    EError DeleteNode(PMEMLIST pNode);
    
    PMEMLIST CreateNewNode(DWORD dwSize, DWORD dwVirtAddr, DWORD dwPhysAddr);
    
    PMEMLIST FindFreeBlock(DWORD dwSize, BOOL fHighPri);
    EError RemoveNodeFromList(PMEMLIST pNode, PMEMLIST* pListHead);
    EError FreeList(PMEMLIST *ppHead);


    CRITICAL_SECTION m_csLock;
    HANDLE      m_hFreeMemEvent;

    // This is initially FALSE. It is set to TRUE when a thread blocks in
    // AllocateMemory and is never reset back to FALSE. While m_fHaveWaited
    // is FALSE, we won't pulse m_hFreeMemEvent on free and release calls.
    // This works around a performance problem in the kernel dealing with
    // manual-reset events but only until memory starts to become scarce.
    BOOL        m_fHaveWaited;

    DWORD       m_PaVaConversion;
    DWORD       m_dwTotalPhysMemSize;
    PUCHAR      m_pPhysicalBufferAddr;

    PMEMLIST    m_pNodeFreeListHead;
    
    DWORD       m_dwSpecialPA;
    DWORD       m_dwSpecialVA;
    BOOL        m_bSpecialTaken;
    
    DWORD       m_dwNormalPA;
    DWORD       m_dwNormalVA;
    DWORD       m_dwNormalSize;
    PMEMLIST    m_pInUseListHead;
    PMEMLIST    m_pFreeListHead;
    
    DWORD       m_dwHighPriorityPA;
    DWORD       m_dwHighPriorityVA;
    DWORD       m_dwHighPrioritySize;
    PMEMLIST    m_pHighPriorityInUseListHead;
    PMEMLIST    m_pHighPriorityFreeListHead;
};


#define FREELIST(fHighPri)  (fHighPri ? m_pHighPriorityFreeListHead : m_pFreeListHead)
#define INUSELIST(fHighPri) (fHighPri ? m_pHighPriorityInUseListHead : m_pInUseListHead)

inline ULONG
CPhysMem::VaToPa(PUCHAR virtAddr)
{
    if (virtAddr == NULL)
    {
        return(0);
    }
    else
    {
        return((ULONG)((ULONG)virtAddr + m_PaVaConversion));
    }
}

inline PUCHAR
CPhysMem::PaToVa(ULONG physAddr)
{
    if (physAddr == 0)
    {
        return(NULL);
    }
    else
    {
        return((PUCHAR)(physAddr - m_PaVaConversion));
    }
}


//---------------------------------------------------------------------
//
// Linked list helper functions
//
#define IsListEmpty(_ListHead)          ((_ListHead)->next == _ListHead)
#define EndOfList(_ListHead, _Entry)    (_ListHead == _Entry)

inline void
InitializeListHead(PMEMLIST _ListHead)
{
    _ListHead->next = _ListHead->prev = _ListHead;
}


inline PMEMLIST
FirstNode(
    PMEMLIST _ListHead
    ) 
{ 
    return(_ListHead->next); 
}


inline void
RemoveNode(
    PMEMLIST pNode
    )
{
    pNode->prev->next = pNode->next;
    pNode->next->prev = pNode->prev;
    pNode->next = NULL;
    pNode->prev = NULL;
}


inline void
InsertNodeBefore(
    PMEMLIST pNodeNew,
    PMEMLIST pNodeExisting
    )
{
    pNodeExisting->prev->next = pNodeNew;
    pNodeNew->prev = pNodeExisting->prev;
    pNodeNew->next = pNodeExisting;
    pNodeExisting->prev = pNodeNew;
}

#ifdef  DEBUG

#define     ALLOC_PHYS_MEM(poPhysMem, size, pVirtAddr, pPhysAddr, dwFlags, pfRequestingAbort) \
        poPhysMem->DebugAllocateMemory(size, pVirtAddr, pPhysAddr, dwFlags, pfRequestingAbort, \
                TEXT(__FILE__), (DWORD)__LINE__)

#define     FREE_PHYS_MEM(poPhysMem, virtAddr, physAddr, dwFlags) \
        poPhysMem->DebugFreeMemory(virtAddr, physAddr, dwFlags, \
                TEXT(__FILE__), (DWORD)__LINE__)

#else // DEBUG

#define     ALLOC_PHYS_MEM(poPhysMem, size, pVirtAddr, pPhysAddr, dwFlags, pfRequestingAbort) \
        poPhysMem->AllocateMemory(size, pVirtAddr, pPhysAddr, dwFlags, pfRequestingAbort)

#define     FREE_PHYS_MEM(poPhysMem, virtAddr, physAddr, dwFlags) \
        poPhysMem->FreeMemory(virtAddr, physAddr, dwFlags)

#endif  //DEBUG

#endif //_MEM_HPP_