sys/arch/hpc/stand/hpcboot/memory.cpp

   1 /*      $NetBSD: memory.cpp,v 1.9 2006/03/05 04:05:39 uwe 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
  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
  52 MemoryManager::~MemoryManager(void)
  53 {
  54         if (_memory)
  55                 VirtualFree(LPVOID(_memory), 0, MEM_RELEASE);
  56 }
  57
  58 void
  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
  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
 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
 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
 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
 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
 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
 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 //
 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
 259 MemoryManager_LockPages::~MemoryManager_LockPages(void)
 260 {
 261 }
 262
 263 paddr_t
 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 //
 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
 289 MemoryManager_VirtualCopy::~MemoryManager_VirtualCopy(void)
 290 {
 291 }
 292
 293 paddr_t
 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
 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 }