pagetable.hh revision 7733 
17768SAli.Saidi@ARM.com/*
27768SAli.Saidi@ARM.com * Copyright (c) 2010 ARM Limited
37768SAli.Saidi@ARM.com * All rights reserved
47768SAli.Saidi@ARM.com *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2002-2005 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Ali Saidi
41 */
42
43#ifndef __ARCH_ARM_PAGETABLE_H__
44#define __ARCH_ARM_PAGETABLE_H__
45
46#include "arch/arm/isa_traits.hh"
47#include "arch/arm/utility.hh"
48#include "arch/arm/vtophys.hh"
49#include "config/full_system.hh"
50
51#include "sim/serialize.hh"
52
53namespace ArmISA {
54
55struct VAddr
56{
57    VAddr(Addr a) { panic("not implemented yet."); }
58};
59
60
61// ITB/DTB page table entry
62struct PTE
63{
64    void serialize(std::ostream &os)
65    {
66        panic("Need to implement PTE serialization\n");
67    }
68
69    void unserialize(Checkpoint *cp, const std::string &section)
70    {
71        panic("Need to implement PTE serialization\n");
72    }
73
74};
75
76// ITB/DTB table entry
77struct TlbEntry
78{
79  public:
80    enum MemoryType {
81        StronglyOrdered,
82        Device,
83        Normal
84    };
85    enum DomainType {
86        DomainNoAccess = 0,
87        DomainClient,
88        DomainReserved,
89        DomainManager
90    };
91
92    // Matching variables
93    Addr pfn;
94    Addr size;              // Size of this entry, == Type of TLB Rec
95    Addr vpn;               // Virtual Page Number
96    uint32_t asid;          // Address Space Identifier
97    uint8_t N;              // Number of bits in pagesize
98    bool global;
99    bool valid;
100
101    // Type of memory
102    bool nonCacheable;     // Can we wrap this in mtype?
103    bool sNp;      // Section descriptor
104
105    // Memory Attributes
106    MemoryType mtype;
107    uint8_t innerAttrs;
108    uint8_t outerAttrs;
109    bool shareable;
110    uint32_t attributes;    // Memory attributes formatted for PAR
111
112
113    // Access permissions
114    bool xn;                // Execute Never
115    uint8_t ap;           // Access permissions bits
116    uint8_t domain;       // Access Domain
117
118    //Construct an entry that maps to physical address addr for SE mode
119    TlbEntry(Addr _asn, Addr _vaddr, Addr _paddr)
120    {
121        pfn = _paddr >> PageShift;
122        size = PageBytes - 1;
123        asid = _asn;
124        global = false;
125        valid = true;
126
127        vpn = _vaddr >> PageShift;
128
129        nonCacheable = sNp = false;
130
131        xn = 0;
132        ap = 0; // ???
133        domain = DomainClient; //???
134    }
135
136    TlbEntry()
137    {}
138
139    void
140    updateVaddr(Addr new_vaddr)
141    {
142        vpn = new_vaddr >> PageShift;
143    }
144
145    Addr
146    pageStart()
147    {
148        return pfn << PageShift;
149    }
150
151    bool
152    match(Addr va, uint8_t cid)
153    {
154        Addr v = vpn << N;
155        if (valid && va >= v && va <= v + size && (global || cid == asid))
156            return true;
157        return false;
158    }
159
160    Addr
161    pAddr(Addr va)
162    {
163        return (pfn << N) | (va & size);
164    }
165
166    void
167    serialize(std::ostream &os)
168    {
169        SERIALIZE_SCALAR(pfn);
170        SERIALIZE_SCALAR(size);
171        SERIALIZE_SCALAR(vpn);
172        SERIALIZE_SCALAR(asid);
173        SERIALIZE_SCALAR(N);
174        SERIALIZE_SCALAR(global);
175        SERIALIZE_SCALAR(valid);
176        SERIALIZE_SCALAR(nonCacheable);
177        SERIALIZE_SCALAR(sNp);
178        SERIALIZE_ENUM(mtype);
179        SERIALIZE_SCALAR(innerAttrs);
180        SERIALIZE_SCALAR(outerAttrs);
181        SERIALIZE_SCALAR(shareable);
182        SERIALIZE_SCALAR(attributes);
183        SERIALIZE_SCALAR(xn);
184        SERIALIZE_SCALAR(ap);
185        SERIALIZE_SCALAR(domain);
186    }
187    void
188    unserialize(Checkpoint *cp, const std::string &section)
189    {
190        UNSERIALIZE_SCALAR(pfn);
191        UNSERIALIZE_SCALAR(size);
192        UNSERIALIZE_SCALAR(vpn);
193        UNSERIALIZE_SCALAR(asid);
194        UNSERIALIZE_SCALAR(N);
195        UNSERIALIZE_SCALAR(global);
196        UNSERIALIZE_SCALAR(valid);
197        UNSERIALIZE_SCALAR(nonCacheable);
198        UNSERIALIZE_SCALAR(sNp);
199        UNSERIALIZE_ENUM(mtype);
200        UNSERIALIZE_SCALAR(innerAttrs);
201        UNSERIALIZE_SCALAR(outerAttrs);
202        UNSERIALIZE_SCALAR(shareable);
203        UNSERIALIZE_SCALAR(attributes);
204        UNSERIALIZE_SCALAR(xn);
205        UNSERIALIZE_SCALAR(ap);
206        UNSERIALIZE_SCALAR(domain);
207    }
208
209};
210
211
212
213};
214#endif // __ARCH_ARM_PAGETABLE_H__
215
216