kernel/core/processor/armv7/PhysicalMemoryManager.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_PROCESSOR_ARMV7_PHYSICALMEMORYMANAGER_H
#define KERNEL_PROCESSOR_ARMV7_PHYSICALMEMORYMANAGER_H

#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/utilities/RangeList.h"

class ArmV7PhysicalMemoryManager : public PhysicalMemoryManager
{
  public:
    inline static ArmV7PhysicalMemoryManager &instance()
    {
        return m_Instance;
    }

    //
    // PhysicalMemoryManager Interface
    //
    virtual physical_uintptr_t allocatePage();
    virtual void freePage(physical_uintptr_t page);
    virtual void pin(physical_uintptr_t page){};
    virtual bool allocateRegion(
        MemoryRegion &Region, size_t cPages, size_t pageConstraints,
        size_t Flags, physical_uintptr_t start = -1);

    void initialise(const BootstrapStruct_t &info);

  protected:
    ArmV7PhysicalMemoryManager();
    virtual ~ArmV7PhysicalMemoryManager();

  private:
    ArmV7PhysicalMemoryManager(const ArmV7PhysicalMemoryManager &);
    ArmV7PhysicalMemoryManager &operator=(const ArmV7PhysicalMemoryManager &);

    virtual void freePageUnlocked(physical_uintptr_t page);

    virtual void unmapRegion(MemoryRegion *pRegion);

    class PageStack
    {
      public:
        PageStack() INITIALISATION_ONLY;
        physical_uintptr_t allocate(size_t constraints);
        void free(physical_uintptr_t physicalAddress);
        inline ~PageStack()
        {
        }

      private:
        PageStack(const PageStack &);
        PageStack &operator=(const PageStack &);

#ifdef ARM_BEAGLE
// physical_uintptr_t m_Stack[0x10000000 / sizeof(physical_uintptr_t)]; // 256
// MB, one entry per address  physical_uintptr_t m_Stack[1024];
#else
        physical_uintptr_t m_Stack[1];
#endif
        void *m_Stack;
        size_t m_StackMax;
        size_t m_StackSize;
    };

    PageStack m_PageStack;

    RangeList<physical_uintptr_t> m_PhysicalRanges;

    RangeList<physical_uintptr_t> m_NonRAMRanges;

    RangeList<uintptr_t> m_VirtualMemoryRegions;

    static ArmV7PhysicalMemoryManager m_Instance;

    Spinlock m_Lock, m_RegionLock;
};

#endif