memory api

/*
    Purpose: Linux specific low-level memory operations
    Author: Reece W.
    License: All Rights Reserved J. Reece Wilson
*/
#pragma once

const size_t OL_ACCESS_READ         = (1 << 0);
const size_t OL_ACCESS_WRITE        = (1 << 1);
const size_t OL_ACCESS_EXECUTE      = (1 << 2);

enum OLCacheType
{
    kCacheCache          = 0,
    kCacheWriteCombined  = 1,
    kCacheNoCache        = 2,
    kCacheWriteThrough   = 3, // read cache, write cache and physical
    kCacheWriteProtected = 4  // read cache, write physical
};

struct OLPageEntry
{
    pgprot_t prot;
    size_t access;
    OLCacheType cache;
};

// Describes mapped memory
class OLGenericMappedBuffer : public OObject
{
public:
    virtual error_t GetVAStart(size_t &)                            = 0;
    virtual error_t GetVAEnd(size_t &)                              = 0;
    virtual error_t GetLength(size_t &)                             = 0;
    virtual error_t Unmap()                                         = 0;
};

// Describes a virtual buffer [or two if shared between user and kernel] pre-PTE allocation
class OLBufferDescription : public OObject
{
public:
    // Add/remove/modify pages in virtual buffer
    virtual bool    PageIsPresent(size_t idx)                       = 0;
    virtual error_t PageInsert   (size_t idx, page_k page)          = 0;
    virtual error_t PagePhysAddr (size_t idx, phys_addr_t & addr)   = 0;
    virtual error_t PageCount    (size_t & count)                   = 0;

    // Temporarily access pages within this descriptior
    virtual error_t PageMap      (size_t idx, void * & addr)        = 0;
    virtual void    PageUnmap    (void * addr)                      = 0;

    // Map
    virtual error_t SetupKernelAddress(size_t & address)            = 0;
    virtual error_t SetupUserAddress(task_k task, size_t & address) = 0;
     // OUncontrollableRef -> life is controlled by OLBufferDescriptions container [or lack thereof]
    virtual error_t MapKernel(const OUncontrollableRef<OLGenericMappedBuffer> kernel, OLPageEntry pte) = 0;
    virtual error_t MapUser  (const OUncontrollableRef<OLGenericMappedBuffer> kernel, OLPageEntry pte) = 0;

    // Remap
    virtual error_t UpdateKernel(OLPageEntry pte)                    = 0;
    virtual error_t UpdateUser  (OLPageEntry pte)                    = 0;
    virtual error_t UpdateAll   (OLPageEntry pte)                    = 0;
};

enum OLPageLocation
{
    kPageInvalid = -1,
    kPageDMAVeryLow, // ZONE_DMA     < 16M
    kPageDMA4GB,     // ZONE_DMA32   < 2 ^ 32 -1
    kPageNormal      // ZONE_NORMAL
};

class OLMemoryInterface
{
public:
    virtual OLPageLocation GetPageLocation(size_t max)                                = 0;           // nvidya demands ranges of (0, (1 << adapter bits) - 1)
    virtual page_k AllocatePage(OLPageLocation location)                              = 0;
    virtual void   FreePage(page_k page)                                              = 0;

    virtual phys_addr_t   PhysPage(page_k page)                                       = 0;
    virtual void *         MapPage(page_k page)                                       = 0;
    virtual void         UnmapPage(void * virt)                                       = 0;

    virtual void        UpdatePageEntryCache (OLPageEntry &, OLCacheType cache)       = 0;
    virtual void        UpdatePageEntryAccess(OLPageEntry &, size_t access)           = 0;
    virtual OLPageEntry CreatePageEntry(size_t access, OLCacheType cache)             = 0;

    virtual error_t NewBuilder(const OOutlivableRef<OLBufferDescription> builder)     = 0;

};

LIBLINUX_SYM error_t GetLinuxMemoryInterface(const OUncontrollableRef<OLMemoryInterface> interface);