1 /* -*-C++-*- $NetBSD: memory.h,v 1.8 2008/04/28 20:23:20 martin Exp $ */
2
3 /*-
4 * Copyright (c) 2001 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by UCHIYAMA Yasushi.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifndef _HPCBOOT_MEMORY_H_
33 #define _HPCBOOT_MEMORY_H_
34
35 #undef MEMORY_MAP_DEBUG // super verbose.
36
37 #include <hpcboot.h>
38 class Console;
39
40 template <class T>
41 inline T
ROUND(const T v,const T x)42 ROUND(const T v, const T x) {
43 return((v + x - 1) / x) * x;
44 }
45
46 template <class T>
47 inline T
TRUNC(const T v,const T x)48 TRUNC(const T v, const T x) {
49 return(v / x) * x;
50 }
51
52 #define MAX_MEM_BANK 16
53 class MemoryManager {
54 private:
55 struct bank {
56 paddr_t addr;
57 psize_t size;
58 };
59 // Windows CE application virtual memory size
60 enum { WCE_VMEM_MAX = 32 * 1024 * 1024 };
61 // Windows CE VirtualAlloc() boundary
62 enum { WCE_REGION_SIZE = 64 * 1024 };
63
64 protected:
65 // Console options.
66 Console *&_cons;
67 BOOL _debug;
68
69 enum { BLOCK_SIZE = WCE_REGION_SIZE * 64 }; // 4MByte
70
71 // Pagesize, D-RAM bank
72 vsize_t _page_size;
73 int _page_shift;
74 int _page_per_region;
75 struct bank _bank[MAX_MEM_BANK];
76 int _nbank;
77
78 // Allocated memory
79 vaddr_t _memory;
80
81 // Virtual <-> Physical table
82 int _naddr_table;
83 struct AddressTranslationTable {
84 vaddr_t vaddr;
85 paddr_t paddr;
86 }
87 *_addr_table;
88 int _addr_table_idx;
89
90 public:
getPageSize(void)91 vsize_t getPageSize(void) { return _page_size; }
92
getTaggedPageSize(void)93 vsize_t getTaggedPageSize(void)
94 { return _page_size - sizeof(struct PageTag); }
estimateTaggedPageSize(vsize_t sz)95 vsize_t estimateTaggedPageSize(vsize_t sz) {
96 vsize_t tsz = getTaggedPageSize();
97 return ((sz + tsz - 1) / tsz) * _page_size;
98 }
roundPage(uint32_t v)99 uint32_t roundPage(uint32_t v) { return ROUND(v, _page_size); }
truncPage(uint32_t v)100 uint32_t truncPage(uint32_t v) { return TRUNC(v, _page_size); }
roundRegion(uint32_t v)101 uint32_t roundRegion(uint32_t v)
102 { return ROUND(v, uint32_t(WCE_REGION_SIZE)); }
truncRegion(uint32_t v)103 uint32_t truncRegion(uint32_t v)
104 { return TRUNC(v, uint32_t(WCE_REGION_SIZE)); }
105
106 // Physical address ops.
107 vaddr_t mapPhysicalPage(paddr_t paddr, psize_t size, uint32_t flags);
108 void unmapPhysicalPage(vaddr_t vaddr);
109 uint32_t readPhysical4(paddr_t paddr);
110 // return physical address of coresspoing virtual address.
111 virtual paddr_t searchPage(vaddr_t vaddr) = 0;
112
113 MemoryManager(Console *&cons, size_t pagesize);
114 virtual ~MemoryManager(void);
setDebug(void)115 BOOL &setDebug(void) { return _debug; }
init(void)116 virtual BOOL init(void) { return TRUE; }
117
118 // initialize page pool
119 BOOL reservePage(vsize_t size, BOOL page_commit = FALSE);
120 // register D-RAM banks
121 void loadBank(paddr_t paddr, psize_t psize);
122 // get 1 page from high address of pool.
123 BOOL getPage(vaddr_t &vaddr, paddr_t &paddr);
124 // get tagged page from low address of pool.
125 BOOL getTaggedPage(vaddr_t &vaddr, paddr_t &paddr);
126 BOOL getTaggedPage(vaddr_t &v, paddr_t &p, struct PageTag **pvec,
127 paddr_t &pvec_paddr);
128 };
129
130 //
131 // Use LockPages()
132 //
133 class MemoryManager_LockPages : public MemoryManager {
134 private:
135 BOOL(*_lock_pages)(LPVOID, DWORD, PDWORD, int);
136 BOOL(*_unlock_pages)(LPVOID, DWORD);
137 int _shift;
138
139 public:
140 MemoryManager_LockPages(BOOL(*)(LPVOID, DWORD, PDWORD, int),
141 BOOL(*)(LPVOID, DWORD), Console *&, size_t, int = 0);
142 virtual ~MemoryManager_LockPages(void);
143 paddr_t searchPage(vaddr_t vaddr);
144 };
145
146 //
147 // Use VirtualCopy()
148 //
149 class MemoryManager_VirtualCopy : public MemoryManager {
150 private:
151 // search guess
152 paddr_t _search_guess;
153
154 // Memory marker
155 uint32_t _magic0, _magic1;
156 volatile uint32_t *_magic_addr;
157 enum {
158 MAGIC_CHECK_DONE = 0xac1dcafe,
159 MAGIC_CHECK_DUMMY = 0xa5a5a5a5
160 };
setMagic(vaddr_t v)161 void setMagic(vaddr_t v) {
162 _magic_addr =(uint32_t *)v;
163 while ((_magic0 = Random()) == MAGIC_CHECK_DONE)
164 ;
165 while ((_magic1 = Random()) == MAGIC_CHECK_DONE)
166 ;
167 _magic_addr[0] = _magic0;
168 _magic_addr[1] = _magic1;
169 }
checkMagic(vaddr_t v)170 BOOL checkMagic(vaddr_t v) {
171 volatile uint32_t *marker =(uint32_t *)v;
172 return (marker[0] == _magic0) && (marker[1] == _magic1);
173 }
clearMagic(void)174 void clearMagic(void) {
175 _magic_addr[0] = MAGIC_CHECK_DONE;
176 _magic_addr[1] = MAGIC_CHECK_DONE;
177 }
178 vaddr_t checkMagicRegion(vaddr_t start, vsize_t size,
179 vsize_t step = 8) {
180 for (vaddr_t ref = start; ref < start + size; ref += step)
181 if (checkMagic(ref))
182 return ref - start;
183 return ~0;
184 }
185 paddr_t searchBank(int banknum);
186
187 public:
188 MemoryManager_VirtualCopy(Console *&, size_t);
189 virtual ~MemoryManager_VirtualCopy(void);
190 paddr_t searchPage(vaddr_t vaddr);
191 };
192
193 #endif // _HPCBOOT_MEMORY_H_
194