kernel/core/processor/arm_926e/VirtualAddressSpace.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_ARM926E_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_ARM926E_VIRTUALADDRESSSPACE_H

#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/types.h"

class Arm926EVirtualAddressSpace : public VirtualAddressSpace
{
    friend class Processor;
    friend VirtualAddressSpace &VirtualAddressSpace::getKernelAddressSpace();

  public:
    //
    // VirtualAddressSpace Interface
    //
    virtual bool isAddressValid(void *virtualAddress);
    virtual bool isMapped(void *virtualAddress);

    virtual bool
    map(physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);
    virtual void getMapping(
        void *virtualAddress, physical_uintptr_t &physicalAddress,
        size_t &flags);
    virtual void setFlags(void *virtualAddress, size_t newFlags);
    virtual void unmap(void *virtualAddress);
    virtual void *allocateStack();
    virtual void freeStack(void *pStack);

    //
    // Needed for the PhysicalMemoryManager
    //
    bool mapPageStructures(
        physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);

    virtual VirtualAddressSpace *clone()
    {
        return 0;
    };

    virtual void revertToKernelAddressSpace(){};

  protected:
    virtual ~Arm926EVirtualAddressSpace();

  private:
    struct Translation
    {
        uint32_t entries[4096];
    } PACKED;

    struct SectionTable
    {
        uint32_t entry;  
    } PACKED;

    struct CoarseTable
    {
        uint32_t entries[256];
    } PACKED;

    struct FineTable
    {
        uint32_t entries[1024];
    };

    // http://www.atmel.com/dyn/resources/prod_documents/ARM_926EJS_TRM.pdf
    union FirstLevelDescriptor_Fault
    {
        uint32_t data;
        struct Desc
        {
            // bits indicate size and validity, outlined Table 3-3 in doc above
            uint32_t size_validity_1 : 1;
            uint32_t size_validity_2 : 1;
            uint32_t
                always0 : 30;  
        };
    };
    union FirstLevelDescriptor_Coarse
    {
        uint32_t data;
        struct Desc
        {
            // bits indicate size and validity, outlined Table 3-3 in doc above
            uint32_t size_validity_1 : 1;
            uint32_t size_validity_2 : 1;
            uint32_t always0_1 : 1;
            uint32_t always0_2 : 2;
            uint32_t always1 : 1;
            uint32_t domainctl : 3;
            uint32_t always0_3 : 1;
            uint32_t coarse_table_addr : 21;  
        };
    };
    union FirstLevelDescriptor_Section
    {
        uint32_t data;
        struct Desc
        {
            // bits indicate size and validity, outlined Table 3-3 in doc above
            uint32_t size_validity_1 : 1;
            uint32_t size_validity_2 : 1;
            uint32_t cb : 2;  // cache control
            uint32_t always1 : 1;
            uint32_t domainctl : 3;
            uint32_t always0 : 1;
            uint32_t perms : 2;  // access permission bits
            uint32_t always0_2 : 7;
            uint32_t section_address : 11;
        };
    };
    union FirstLevelDescriptor_Fine
    {
        uint32_t data;
        struct Desc
        {
            // bits indicate size and validity, outlined Table 3-3 in doc above
            uint32_t size_validity_1 : 1;
            uint32_t size_validity_2 : 1;
            uint32_t always0_1 : 1;
            uint32_t always0_2 : 2;
            uint32_t always1 : 1;
            uint32_t domainctl : 3;
            uint32_t always0_3 : 3;
            uint32_t coarse_table_addr : 19;
        };
    };

    Arm926EVirtualAddressSpace(
        void *Heap, physical_uintptr_t PhysicalPageDirectory,
        void *VirtualPageDirectory, void *VirtualPageTables);

    Arm926EVirtualAddressSpace();
    Arm926EVirtualAddressSpace(const Arm926EVirtualAddressSpace &);
    Arm926EVirtualAddressSpace &operator=(const Arm926EVirtualAddressSpace &);

    bool initialise();

    bool getPageTableEntry(void *virtualAddress, uint32_t *&pageTableEntry);
    uint32_t toFlags(size_t flags);
    size_t fromFlags(uint32_t Flags);

    physical_uintptr_t m_PhysicalPageDirectory;
    void *m_VirtualPageDirectory;
    void *m_VirtualPageTables;

    static Arm926EVirtualAddressSpace m_KernelSpace;
};

#endif