1 /* $NetBSD: memory.cpp,v 1.5 2002/02/04 17:32:02 uch 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <memory.h> 40 #include <console.h> 41 42 MemoryManager::MemoryManager(Console *&cons, size_t pagesize) 43 : _cons(cons) 44 { 45 _debug = FALSE; 46 _page_size = pagesize; 47 48 int mask = _page_size; 49 for (_page_shift = 0; !(mask & 1); _page_shift++) 50 mask >>= 1; 51 52 _page_per_region = WCE_REGION_SIZE / _page_size; 53 _nbank = 0; 54 _addr_table_idx = 0; 55 _addr_table = 0; 56 _memory = 0; 57 } 58 59 MemoryManager::~MemoryManager(void) 60 { 61 if (_memory) 62 VirtualFree(LPVOID(_memory), 0, MEM_RELEASE); 63 } 64 65 void 66 MemoryManager::loadBank(paddr_t paddr, psize_t psize) 67 { 68 struct MemoryManager::bank *b = &_bank[_nbank++]; 69 b->addr = paddr; 70 b->size = psize; 71 DPRINTF((TEXT("[%d] 0x%08x size 0x%08x\n"), _nbank - 1, 72 b->addr, b->size)); 73 } 74 75 BOOL 76 MemoryManager::reservePage(vsize_t size, BOOL page_commit) 77 { 78 // My virtual memory space 79 vaddr_t vbase; 80 vsize_t vsize; 81 82 int i, npage; 83 84 if (size == 0) 85 return FALSE; 86 87 // reserve all virtual memory. 88 vsize = roundRegion(size); 89 npage = roundPage(size) / _page_size; 90 91 size_t tabsz = sizeof(struct AddressTranslationTable) * npage; 92 _addr_table = static_cast <struct AddressTranslationTable *> 93 (malloc(tabsz)); 94 if (_addr_table == NULL) { 95 DPRINTF((TEXT("can't allocate memory for translation table.\n"))); 96 return FALSE; 97 } 98 DPRINTF((TEXT("address translation table %d pages.(%d byte)\n"), npage, 99 tabsz)); 100 101 if (page_commit) 102 vbase = vaddr_t(VirtualAlloc(0, vsize, MEM_RESERVE, 103 PAGE_NOACCESS)); 104 else 105 vbase = vaddr_t(VirtualAlloc(0, vsize, MEM_COMMIT, 106 PAGE_READWRITE | PAGE_NOCACHE)); 107 108 if (vbase == 0) { 109 DPRINTF((TEXT("can't allocate memory\n"))); 110 return FALSE; 111 } 112 _memory = vbase; 113 114 // find physical address of allocated page. 115 AddressTranslationTable *tab = _addr_table; 116 _naddr_table = 0; 117 for (i = 0; i < npage; i++) { 118 vaddr_t vaddr; 119 paddr_t paddr = ~0; 120 121 if (page_commit) 122 // now map to physical page. 123 vaddr = vaddr_t(VirtualAlloc( 124 LPVOID(vbase + _page_size * i), 125 _page_size, MEM_COMMIT, 126 PAGE_READWRITE | PAGE_NOCACHE)); 127 else 128 vaddr = vbase + _page_size * i; 129 130 paddr = searchPage(vaddr); 131 132 if (paddr == ~0) { 133 DPRINTF((TEXT("page#%d not found\n"), i)); 134 break; 135 } else { 136 #ifdef MEMORY_MAP_DEBUG 137 DPRINTF((TEXT("page %d vaddr=0x%08x paddr=0x%08x\n"), 138 _naddr_table, vaddr, paddr)); 139 #endif 140 tab->vaddr = vaddr; 141 tab->paddr = paddr; 142 ++tab; 143 ++_naddr_table; 144 } 145 } 146 147 #ifdef MEMORY_MAP_DEBUG 148 // dump virtual <-> physical address table 149 tab = _addr_table; 150 for (i = 0; i < _naddr_table;) { 151 for (int j = 0; j < 4; j++, i++, tab++) 152 DPRINTF((TEXT("%08x=%08x "), tab->vaddr, tab->paddr)); 153 DPRINTF((TEXT("\n"))); 154 } 155 #endif 156 DPRINTF((TEXT("allocated %d page. mapped %d page.\n"), npage, 157 _naddr_table)); 158 159 return TRUE; 160 } 161 162 BOOL 163 MemoryManager::getPage(vaddr_t &vaddr, paddr_t &paddr) 164 { 165 /* get plain page from the top */ 166 if (_addr_table_idx >= _naddr_table || 167 _addr_table == NULL) 168 return FALSE; 169 170 int idx = --_naddr_table; 171 172 AddressTranslationTable *tab = &_addr_table[idx]; 173 vaddr = tab->vaddr; 174 paddr = tab->paddr; 175 176 return TRUE; 177 } 178 179 BOOL 180 MemoryManager::getTaggedPage(vaddr_t &vaddr, paddr_t &paddr) 181 { 182 /* get tagged page from the bottom */ 183 if (_addr_table_idx >= _naddr_table || 184 _addr_table == NULL) { 185 DPRINTF((TEXT("page insufficient.\n"))); 186 return FALSE; 187 } 188 AddressTranslationTable *tab = 189 &_addr_table[_addr_table_idx++]; 190 vaddr = tab->vaddr; 191 paddr = tab->paddr; 192 193 return TRUE; 194 } 195 196 BOOL 197 MemoryManager::getTaggedPage(vaddr_t &v, paddr_t &p, 198 struct PageTag **pvec, paddr_t &pvec_paddr) 199 { 200 if (!getTaggedPage(v, p)) 201 return FALSE; 202 203 *pvec =(struct PageTag *)v; 204 memset(*pvec, 0, sizeof(struct PageTag)); 205 v += sizeof(struct PageTag); 206 pvec_paddr = p; 207 p += sizeof(struct PageTag); 208 209 return TRUE; 210 } 211 212 vaddr_t 213 MemoryManager::mapPhysicalPage(paddr_t paddr, psize_t size, u_int32_t flags) 214 { 215 paddr_t pstart = truncPage(paddr); 216 paddr_t pend = roundPage(paddr + size); 217 psize_t psize = pend - pstart; 218 219 LPVOID p = VirtualAlloc(0, psize, MEM_RESERVE, PAGE_NOACCESS); 220 221 int ok = VirtualCopy(p, LPVOID(pstart >> 8), psize, 222 flags | PAGE_NOCACHE | PAGE_PHYSICAL); 223 if (!ok) { 224 DPRINTF((TEXT("can't map physical address 0x%08x\n"), paddr)); 225 return ~0; 226 } 227 #if 0 228 DPRINTF((TEXT("start=0x%08x end=0x%08x size=0x%08x return=0x%08x\n"), 229 pstart, pend, psize, vaddr_t(p) + vaddr_t(paddr - pstart))); 230 231 #endif 232 233 return vaddr_t(p) + vaddr_t(paddr - pstart); 234 } 235 236 void 237 MemoryManager::unmapPhysicalPage(vaddr_t vaddr) 238 { 239 int ok = VirtualFree(LPVOID(truncPage(vaddr)), 0, MEM_RELEASE); 240 if (!ok) 241 DPRINTF((TEXT("can't release memory\n"))); 242 } 243 244 u_int32_t 245 MemoryManager::readPhysical4(paddr_t paddr) 246 { 247 vaddr_t v = mapPhysicalPage(paddr, 4, PAGE_READONLY); 248 u_int32_t val = *(u_int32_t *)v; 249 unmapPhysicalPage(v); 250 return val; 251 } 252 253 // 254 // Use LockPages() 255 // 256 MemoryManager_LockPages::MemoryManager_LockPages 257 (BOOL(*lock_pages)(LPVOID, DWORD, PDWORD, int), 258 BOOL(*unlock_pages)(LPVOID, DWORD), 259 Console *&cons, size_t pagesize, int shift) 260 : MemoryManager(cons, pagesize) 261 { 262 _lock_pages = lock_pages; 263 _unlock_pages = unlock_pages; 264 _shift = shift; 265 DPRINTF((TEXT("MemoryManager: LockPages\n"))); 266 } 267 268 MemoryManager_LockPages::~MemoryManager_LockPages(void) 269 { 270 } 271 272 paddr_t 273 MemoryManager_LockPages::searchPage(vaddr_t vaddr) 274 { 275 paddr_t paddr = ~0; 276 277 if (!_lock_pages(LPVOID(vaddr), _page_size, PDWORD(&paddr), 1)) 278 return paddr; 279 280 if (!_unlock_pages(LPVOID(vaddr), _page_size)) { 281 DPRINTF((TEXT("can't unlock pages\n"))); 282 } 283 284 return(paddr >>(_page_shift - _shift)) << _page_shift; 285 } 286 287 // 288 // Use VirtualCopy() 289 // 290 MemoryManager_VirtualCopy::MemoryManager_VirtualCopy(Console *&cons, 291 size_t pagesize) 292 : MemoryManager(cons, pagesize) 293 { 294 _search_guess = 0; 295 DPRINTF((TEXT("MemoryManager: VirtualCopy\n"))); 296 } 297 298 MemoryManager_VirtualCopy::~MemoryManager_VirtualCopy(void) 299 { 300 } 301 302 paddr_t 303 MemoryManager_VirtualCopy::searchPage(vaddr_t vaddr) 304 { 305 paddr_t paddr = ~0; 306 int i; 307 308 // search all D-RAM bank. 309 setMagic(vaddr); 310 retry: 311 for (i = 0; i < _nbank; i++) { 312 paddr = searchBank(i); 313 if (paddr != ~0) 314 break; 315 } 316 if (_search_guess != 0 && paddr == ~0) { 317 _search_guess = 0; 318 goto retry; 319 } 320 321 clearMagic(); 322 323 return paddr; 324 } 325 326 paddr_t 327 MemoryManager_VirtualCopy::searchBank(int banknum) 328 { 329 LPVOID ref; 330 paddr_t paddr, pstart, pend, pfound = ~0; 331 paddr_t bstart, bend; 332 vaddr_t ofs; 333 334 bstart = _bank[banknum].addr; 335 bend = _bank[banknum].addr + _bank[banknum].size; 336 337 pstart = _search_guess ? _search_guess : bstart; 338 pend = bend; 339 340 if (pstart < bstart || pstart >= pend) 341 return pfound; 342 343 // reserve physical reference region 344 ref = VirtualAlloc(0, BLOCK_SIZE, MEM_RESERVE, PAGE_NOACCESS); 345 if (ref == 0) { 346 DPRINTF((TEXT("can't allocate virtual memory.\n"))); 347 return pfound; 348 } 349 350 for (paddr = pstart; paddr < pend; paddr += BLOCK_SIZE) { 351 if (!VirtualCopy(ref, LPVOID(paddr >> 8), BLOCK_SIZE, 352 PAGE_READONLY | PAGE_NOCACHE | PAGE_PHYSICAL)) { 353 DPRINTF((TEXT("can't map physical addr 0x%08x(->0x%08x)\n"), 354 ref, paddr)); 355 goto release; 356 } 357 358 // search magic in this region. 359 ofs = checkMagicRegion(vaddr_t(ref), BLOCK_SIZE, _page_size); 360 361 // decommit reference region. 362 if (!VirtualFree(ref, BLOCK_SIZE, MEM_DECOMMIT)) { 363 DPRINTF((TEXT("can't decommit addr 0x%08x(->0x%08x)\n"), 364 ref, paddr)); 365 goto release; 366 } 367 368 if (ofs != ~0) { 369 pfound = paddr + ofs; 370 _search_guess = paddr; 371 break; 372 } 373 } 374 release: 375 if (!VirtualFree(ref, 0, MEM_RELEASE)) 376 DPRINTF((TEXT("can't release memory\n"))); 377 378 return pfound; 379 } 380