HashedPageTable.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_PPC32_HASHEDPAGETABLE_H
#define KERNEL_PROCESSOR_PPC32_HASHEDPAGETABLE_H

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

#define HTAB_VIRTUAL 0xC0100000

class HashedPageTable
{
  public:
    HashedPageTable();
    ~HashedPageTable();

    static HashedPageTable &instance();

    void initialise(Translations &translations, uint32_t ramMax);

    void addMapping(
        uint32_t effectiveAddress, uint32_t physicalAddress, uint32_t mode,
        uint32_t vsid);

    void removeMapping(uint32_t effectiveAddress, uint32_t vsid);

    bool isMapped(uint32_t effectiveAddress, uint32_t vsid);

    uint32_t getMapping(uint32_t effectiveAddress, uint32_t vsid);

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

    struct PTE
    {
        uint32_t v : 1;      // Entry valid?
        uint32_t vsid : 24;  // Virtual segment ID
        uint32_t h : 1;      // Hash function identifier
        uint32_t api : 6;    // Abbreviated page index.
        uint32_t rpn : 20;   // Physical page number.
        uint32_t reserved1 : 3;
        uint32_t r : 1;  // Reference bit.
        uint32_t c : 1;  // Change bit.
        uint32_t w : 1;  // Memory/cache control bits.
        uint32_t i : 1;
        uint32_t m : 1;
        uint32_t g : 1;
        uint32_t reserved2 : 1;
        uint32_t pp : 2;  // Page protection bits.
    };
    struct BATU
    {
        uint32_t bepi : 15;  // Effective page index.
        uint32_t unused : 4;
        uint32_t bl : 11;  // Block size mask.
        uint32_t vs : 1;   // Supervisor valid.
        uint32_t vp : 1;   // User valid.
    };
    struct BATL
    {
        uint32_t brpn : 15;  // Real page index.
        uint32_t unused1 : 10;
        uint32_t wimg : 4;  // Memory/cache control bits.
        uint32_t unused2 : 1;
        uint32_t pp : 2;  // Page access protections.
    };

    struct PTEG
    {
        PTE entries[8];
    };

    void setIBAT(
        size_t n, uintptr_t virt, physical_uintptr_t phys, size_t size,
        uint32_t mode);
    void setDBAT(
        size_t n, uintptr_t virt, physical_uintptr_t phys, size_t size,
        uint32_t mode);

    PTEG *m_pHtab;

    uint32_t m_Size;

    uint32_t m_Mask;

    static HashedPageTable m_Instance;
};

#endif