1 /* $NetBSD: memory.cpp,v 1.10 2008/04/28 20:23:20 martin Exp $ */
2
3 /*-
4 * Copyright (c) 2001, 2002 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 #include <memory.h>
33 #include <console.h>
34
MemoryManager(Console * & cons,size_t pagesize)35 MemoryManager::MemoryManager(Console *&cons, size_t pagesize)
36 : _cons(cons)
37 {
38 _debug = FALSE;
39 _page_size = pagesize;
40
41 int mask = _page_size;
42 for (_page_shift = 0; !(mask & 1); _page_shift++)
43 mask >>= 1;
44
45 _page_per_region = WCE_REGION_SIZE / _page_size;
46 _nbank = 0;
47 _addr_table_idx = 0;
48 _addr_table = 0;
49 _memory = 0;
50 }
51
~MemoryManager(void)52 MemoryManager::~MemoryManager(void)
53 {
54 if (_memory)
55 VirtualFree(LPVOID(_memory), 0, MEM_RELEASE);
56 }
57
58 void
loadBank(paddr_t paddr,psize_t psize)59 MemoryManager::loadBank(paddr_t paddr, psize_t psize)
60 {
61 struct MemoryManager::bank *b = &_bank[_nbank++];
62 b->addr = paddr;
63 b->size = psize;
64 DPRINTF((TEXT("[%d] 0x%08x size 0x%08x\n"), _nbank - 1,
65 b->addr, b->size));
66 }
67
68 BOOL
reservePage(vsize_t size,BOOL page_commit)69 MemoryManager::reservePage(vsize_t size, BOOL page_commit)
70 {
71 // My virtual memory space
72 vaddr_t vbase;
73 vsize_t vsize;
74
75 int i, npage;
76
77 if (size == 0)
78 return FALSE;
79
80 // reserve all virtual memory.
81 vsize = roundRegion(size);
82 npage = roundPage(size) / _page_size;
83
84 size_t tabsz = sizeof(struct AddressTranslationTable) * npage;
85 _addr_table = static_cast <struct AddressTranslationTable *>
86 (malloc(tabsz));
87 if (_addr_table == NULL) {
88 DPRINTF((TEXT("can't allocate memory for translation table.\n")));
89 return FALSE;
90 }
91 DPRINTF((TEXT("address translation table %d pages. (0x%x bytes)\n"),
92 npage, tabsz));
93
94 if (page_commit)
95 vbase = vaddr_t(VirtualAlloc(0, vsize, MEM_RESERVE,
96 PAGE_NOACCESS));
97 else
98 vbase = vaddr_t(VirtualAlloc(0, vsize, MEM_COMMIT,
99 PAGE_READWRITE | PAGE_NOCACHE));
100
101 if (vbase == 0) {
102 DPRINTF((TEXT("can't allocate memory\n")));
103 return FALSE;
104 }
105 _memory = vbase;
106
107 // find physical address of allocated page.
108 AddressTranslationTable *tab = _addr_table;
109 _naddr_table = 0;
110 for (i = 0; i < npage; i++) {
111 vaddr_t vaddr;
112 paddr_t paddr = ~0;
113
114 if (page_commit)
115 // now map to physical page.
116 vaddr = vaddr_t(VirtualAlloc(
117 LPVOID(vbase + _page_size * i),
118 _page_size, MEM_COMMIT,
119 PAGE_READWRITE | PAGE_NOCACHE));
120 else
121 vaddr = vbase + _page_size * i;
122
123 paddr = searchPage(vaddr);
124
125 if (paddr == ~0) {
126 DPRINTF((TEXT("page#%d not found\n"), i));
127 break;
128 } else {
129 #ifdef MEMORY_MAP_DEBUG
130 DPRINTF((TEXT("page %d vaddr=0x%08x paddr=0x%08x\n"),
131 _naddr_table, vaddr, paddr));
132 #endif
133 tab->vaddr = vaddr;
134 tab->paddr = paddr;
135 ++tab;
136 ++_naddr_table;
137 }
138 }
139
140 #ifdef MEMORY_MAP_DEBUG
141 // dump virtual <-> physical address table
142 tab = _addr_table;
143 for (i = 0; i < _naddr_table;) {
144 for (int j = 0; j < 4; j++, i++, tab++)
145 DPRINTF((TEXT("%08x=%08x "), tab->vaddr, tab->paddr));
146 DPRINTF((TEXT("\n")));
147 }
148 #endif
149 DPRINTF((TEXT("allocated %d page. mapped %d page.\n"), npage,
150 _naddr_table));
151
152 return TRUE;
153 }
154
155 BOOL
getPage(vaddr_t & vaddr,paddr_t & paddr)156 MemoryManager::getPage(vaddr_t &vaddr, paddr_t &paddr)
157 {
158 /* get plain page from the top */
159 if (_addr_table_idx >= _naddr_table ||
160 _addr_table == NULL)
161 return FALSE;
162
163 int idx = --_naddr_table;
164
165 AddressTranslationTable *tab = &_addr_table[idx];
166 vaddr = tab->vaddr;
167 paddr = tab->paddr;
168
169 return TRUE;
170 }
171
172 BOOL
getTaggedPage(vaddr_t & vaddr,paddr_t & paddr)173 MemoryManager::getTaggedPage(vaddr_t &vaddr, paddr_t &paddr)
174 {
175 /* get tagged page from the bottom */
176 if (_addr_table_idx >= _naddr_table ||
177 _addr_table == NULL) {
178 DPRINTF((TEXT("page insufficient.\n")));
179 return FALSE;
180 }
181 AddressTranslationTable *tab =
182 &_addr_table[_addr_table_idx++];
183 vaddr = tab->vaddr;
184 paddr = tab->paddr;
185
186 return TRUE;
187 }
188
189 BOOL
getTaggedPage(vaddr_t & v,paddr_t & p,struct PageTag ** pvec,paddr_t & pvec_paddr)190 MemoryManager::getTaggedPage(vaddr_t &v, paddr_t &p,
191 struct PageTag **pvec, paddr_t &pvec_paddr)
192 {
193 if (!getTaggedPage(v, p))
194 return FALSE;
195
196 *pvec =(struct PageTag *)v;
197 memset(*pvec, 0, sizeof(struct PageTag));
198 v += sizeof(struct PageTag);
199 pvec_paddr = p;
200 p += sizeof(struct PageTag);
201
202 return TRUE;
203 }
204
205 vaddr_t
mapPhysicalPage(paddr_t paddr,psize_t size,uint32_t flags)206 MemoryManager::mapPhysicalPage(paddr_t paddr, psize_t size, uint32_t flags)
207 {
208 paddr_t pstart = truncPage(paddr);
209 paddr_t pend = roundPage(paddr + size);
210 psize_t psize = pend - pstart;
211
212 LPVOID p = VirtualAlloc(0, psize, MEM_RESERVE, PAGE_NOACCESS);
213
214 int ok = VirtualCopy(p, LPVOID(pstart >> 8), psize,
215 flags | PAGE_NOCACHE | PAGE_PHYSICAL);
216 if (!ok) {
217 DPRINTF((TEXT("can't map physical address 0x%08x\n"), paddr));
218 return ~0;
219 }
220 #if 0
221 DPRINTF((TEXT("start=0x%08x end=0x%08x size=0x%08x return=0x%08x\n"),
222 pstart, pend, psize, vaddr_t(p) + vaddr_t(paddr - pstart)));
223 #endif
224 return vaddr_t(p) + vaddr_t(paddr - pstart);
225 }
226
227 void
unmapPhysicalPage(vaddr_t vaddr)228 MemoryManager::unmapPhysicalPage(vaddr_t vaddr)
229 {
230 int ok = VirtualFree(LPVOID(truncPage(vaddr)), 0, MEM_RELEASE);
231 if (!ok)
232 DPRINTF((TEXT("can't release memory\n")));
233 }
234
235 uint32_t
readPhysical4(paddr_t paddr)236 MemoryManager::readPhysical4(paddr_t paddr)
237 {
238 vaddr_t v = mapPhysicalPage(paddr, 4, PAGE_READONLY);
239 uint32_t val = *(uint32_t *)v;
240 unmapPhysicalPage(v);
241 return val;
242 }
243
244 //
245 // Use LockPages()
246 //
MemoryManager_LockPages(BOOL (* lock_pages)(LPVOID,DWORD,PDWORD,int),BOOL (* unlock_pages)(LPVOID,DWORD),Console * & cons,size_t pagesize,int shift)247 MemoryManager_LockPages::MemoryManager_LockPages
248 (BOOL(*lock_pages)(LPVOID, DWORD, PDWORD, int),
249 BOOL(*unlock_pages)(LPVOID, DWORD),
250 Console *&cons, size_t pagesize, int shift)
251 : MemoryManager(cons, pagesize)
252 {
253 _lock_pages = lock_pages;
254 _unlock_pages = unlock_pages;
255 _shift = shift;
256 DPRINTF((TEXT("MemoryManager: LockPages\n")));
257 }
258
~MemoryManager_LockPages(void)259 MemoryManager_LockPages::~MemoryManager_LockPages(void)
260 {
261 }
262
263 paddr_t
searchPage(vaddr_t vaddr)264 MemoryManager_LockPages::searchPage(vaddr_t vaddr)
265 {
266 paddr_t paddr = ~0;
267
268 if (!_lock_pages(LPVOID(vaddr), _page_size, PDWORD(&paddr), 1))
269 return paddr;
270
271 if (!_unlock_pages(LPVOID(vaddr), _page_size)) {
272 DPRINTF((TEXT("can't unlock pages\n")));
273 }
274
275 return(paddr >>(_page_shift - _shift)) << _page_shift;
276 }
277
278 //
279 // Use VirtualCopy()
280 //
MemoryManager_VirtualCopy(Console * & cons,size_t pagesize)281 MemoryManager_VirtualCopy::MemoryManager_VirtualCopy(Console *&cons,
282 size_t pagesize)
283 : MemoryManager(cons, pagesize)
284 {
285 _search_guess = 0;
286 DPRINTF((TEXT("MemoryManager: VirtualCopy\n")));
287 }
288
~MemoryManager_VirtualCopy(void)289 MemoryManager_VirtualCopy::~MemoryManager_VirtualCopy(void)
290 {
291 }
292
293 paddr_t
searchPage(vaddr_t vaddr)294 MemoryManager_VirtualCopy::searchPage(vaddr_t vaddr)
295 {
296 paddr_t paddr = ~0;
297 int i;
298
299 // search all D-RAM bank.
300 setMagic(vaddr);
301 retry:
302 for (i = 0; i < _nbank; i++) {
303 paddr = searchBank(i);
304 if (paddr != ~0)
305 break;
306 }
307 if (_search_guess != 0 && paddr == ~0) {
308 _search_guess = 0;
309 goto retry;
310 }
311
312 clearMagic();
313
314 return paddr;
315 }
316
317 paddr_t
searchBank(int banknum)318 MemoryManager_VirtualCopy::searchBank(int banknum)
319 {
320 LPVOID ref;
321 paddr_t paddr, pstart, pend, pfound = ~0;
322 paddr_t bstart, bend;
323 vaddr_t ofs;
324
325 bstart = _bank[banknum].addr;
326 bend = _bank[banknum].addr + _bank[banknum].size;
327
328 pstart = _search_guess ? _search_guess : bstart;
329 pend = bend;
330
331 if (pstart < bstart || pstart >= pend)
332 return pfound;
333
334 // reserve physical reference region
335 ref = VirtualAlloc(0, BLOCK_SIZE, MEM_RESERVE, PAGE_NOACCESS);
336 if (ref == 0) {
337 DPRINTF((TEXT("can't allocate virtual memory.\n")));
338 return pfound;
339 }
340
341 for (paddr = pstart; paddr < pend; paddr += BLOCK_SIZE) {
342 if (!VirtualCopy(ref, LPVOID(paddr >> 8), BLOCK_SIZE,
343 PAGE_READONLY | PAGE_NOCACHE | PAGE_PHYSICAL)) {
344 DPRINTF((TEXT("can't map physical addr 0x%08x(->0x%08x)\n"),
345 ref, paddr));
346 goto release;
347 }
348
349 // search magic in this region.
350 ofs = checkMagicRegion(vaddr_t(ref), BLOCK_SIZE, _page_size);
351
352 // decommit reference region.
353 if (!VirtualFree(ref, BLOCK_SIZE, MEM_DECOMMIT)) {
354 DPRINTF((TEXT("can't decommit addr 0x%08x(->0x%08x)\n"),
355 ref, paddr));
356 goto release;
357 }
358
359 if (ofs != ~0) {
360 pfound = paddr + ofs;
361 _search_guess = paddr;
362 break;
363 }
364 }
365 release:
366 if (!VirtualFree(ref, 0, MEM_RELEASE))
367 DPRINTF((TEXT("can't release memory\n")));
368
369 return pfound;
370 }
371