Kernel/armv7 - Fixed lack of in*/out* functions
[tpg/acess2.git] / Kernel / include / tpl_mm_phys_stack.h
1 /*
2  * Acess2 Core
3  * 
4  * include/tpl_mm_phys.h
5  * Physical Memory Manager Template
6  */
7 #define DEBUG   0
8
9 /**
10  * \file tpl_mm_phys.h
11  * \brief Template physical memory manager
12  *
13  * An extensible physical memory manager
14  *
15  * Usage: Requires NUM_MM_PHYS_RANGES to be set to the number of address
16  * "classes" wanted.
17  * MAX_PHYS_PAGES - Used to calculate structure sizes
18  * PADDR_TYPE
19  */
20
21 // === PROTOTYPES ===
22 //void  MM_InitPhys_Multiboot(tMBoot_Info *MBoot);
23 //tPAddr        MM_AllocPhysRange(int Num, int Bits);
24 //tPAddr        MM_AllocPhys(void);
25 //void  MM_RefPhys(tPAddr PAddr);
26 //void  MM_DerefPhys(tPAddr PAddr);
27  int    MM_int_GetRangeID( tPAddr Addr );
28  int    MM_int_IsPhysUnavail( tPageNum Page );
29
30 // === GLOBALS ===
31 tMutex  glPhysicalPages;
32 //Uint64        *gaPageStacks[NUM_MM_PHYS_RANGES];      // Page stacks
33  int    giPageStackSizes[NUM_MM_PHYS_RANGES];   // Points to the first unused slot
34 Uint32  *gaiPageReferences = (void*)MM_PAGE_COUNTS;     // Reference Counts
35 Uint64  giMaxPhysPage = 0;      // Maximum Physical page
36
37 // === CODE ===
38 /**
39  * \brief Initialise the physical memory map using a Multiboot 1 map
40  */
41 void MM_Tpl_InitPhys(int MaxRAMPage)
42 {
43         const int       PAGE_SIZE = 0x1000;
44         const int       pagesPerPageOnStack = PAGE_SIZE / sizeof(gaPageStack[0]);
45          int    i;
46         tPageNum        page;
47
48 //      ENTER("pMBoot=%p", MBoot);
49         
50         giMaxPhysPage = MaxRAMPage;
51         
52         tPAddr  page = 0;
53         for( i = 0; i < NUM_MM_PHYS_RANGES; i ++ )
54         {
55                 for( ; page < giPageRangeMax[i] && page < giMaxPhysPage; page ++ )
56                 {
57                          int    rangeSize;
58
59                         rangeSize = MM_int_IsPhysUnavail(page);
60                         if( rangeSize > 0 ) {
61                                 page += rangeSize;
62                                 continue;
63                         }
64                         // Page is avaliable for use
65         
66                         // Check if the page stack is allocated
67                         tVAddr  stack_page = &gaPageStacks[i][giPageStackSizes[i]&~pagesPerPageOnStack];
68                         if( !MM_GetPhysAddr( stack_page ) ) {
69                                 MM_Map( stack_page, page*PAGE_SIZE );
70                         }
71                         else {
72                                 gaPageStacks[i][ giPageStackSizes[i] ] = page;
73                                 giPageStackSizes[i] ++;
74                         }
75                 }
76         }
77         
78         LEAVE('-');
79 }
80
81 /**
82  * \brief Allocate a contiguous range of physical pages with a maximum
83  *        bit size of \a MaxBits
84  * \param Pages Number of pages to allocate
85  * \param MaxBits       Maximum size of the physical address
86  * \note If \a MaxBits is <= 0, any sized address is used (with preference
87  *       to higher addresses)
88  */
89 tPAddr MM_AllocPhysRange(int Pages, int MaxBits)
90 {
91         tPAddr  addr, ret;
92          int    rangeID;
93          int    nFree = 0, i;
94         
95         ENTER("iPages iBits", Pages, MaxBits);
96         
97         if( MaxBits <= 0 || MaxBits >= 64 )     // Speedup for the common case
98                 rangeID = MM_PHYS_MAX;
99         else
100                 rangeID = MM_int_GetRangeID( (1LL << MaxBits) - 1 );
101         
102         LOG("rangeID = %i", rangeID);
103         
104         Mutex_Acquire(&glPhysicalPages);
105         
106         // Check if the range actually has any free pages
107         while(giPageStackSizes[rangeID] == 0 && rangeID)
108                 rangeID --;
109         
110         LOG("rangeID = %i", rangeID);
111         
112         // What the? Oh, man. No free pages
113         if(giPageStackSizes[rangeID] == 0) {
114                 Mutex_Release(&glPhysicalPages);
115                 // TODO: Page out / attack the cache
116                 // ATM. Just Warning
117                 Warning(" MM_AllocPhysRange: Out of free pages");
118                 Log_Warning("Arch",
119                         "Out of memory (unable to fulfil request for %i pages), zero remaining",
120                         Pages
121                         );
122                 LEAVE('i', 0);
123                 return 0;
124         }
125         
126         // Check if there is enough in the range
127         if(giPhysRangeFree[rangeID] >= Pages)
128         {
129                 LOG("{%i,0x%x -> 0x%x}",
130                         giPhysRangeFree[rangeID],
131                         giPhysRangeFirst[rangeID], giPhysRangeLast[rangeID]
132                         );
133                 // Do a cheap scan, scanning upwards from the first free page in
134                 // the range
135                 nFree = 0;
136                 addr = giPhysRangeFirst[ rangeID ];
137                 while( addr <= giPhysRangeLast[ rangeID ] )
138                 {
139                         //Log(" MM_AllocPhysRange: addr = 0x%x", addr);
140                         // Check the super bitmap
141                         if( gaSuperBitmap[addr >> (6+6)] + 1 == 0 ) {
142                                 LOG("nFree = %i = 0 (super) (0x%x)", nFree, addr);
143                                 nFree = 0;
144                                 addr += 1LL << (6+6);
145                                 addr &= ~0xFFF; // (1LL << 6+6) - 1
146                                 continue;
147                         }
148                         // Check page block (64 pages)
149                         if( gaMainBitmap[addr >> 6] + 1 == 0) {
150                                 LOG("nFree = %i = 0 (main) (0x%x)", nFree, addr);
151                                 nFree = 0;
152                                 addr += 1LL << (6);
153                                 addr &= ~0x3F;
154                                 continue;
155                         }
156                         // Check individual page
157                         if( gaMainBitmap[addr >> 6] & (1LL << (addr & 63)) ) {
158                                 LOG("nFree = %i = 0 (page) (0x%x)", nFree, addr);
159                                 nFree = 0;
160                                 addr ++;
161                                 continue;
162                         }
163                         nFree ++;
164                         addr ++;
165                         LOG("nFree(%i) == %i (0x%x)", nFree, Pages, addr);
166                         if(nFree == Pages)
167                                 break;
168                 }
169                 LOG("nFree = %i", nFree);
170                 // If we don't find a contiguous block, nFree will not be equal
171                 // to Num, so we set it to zero and do the expensive lookup.
172                 if(nFree != Pages)      nFree = 0;
173         }
174         
175         if( !nFree )
176         {
177                 // Oops. ok, let's do an expensive check (scan down the list
178                 // until a free range is found)
179                 nFree = 1;
180                 addr = giPhysRangeLast[ rangeID ];
181                 // TODO
182                 Mutex_Release(&glPhysicalPages);
183                 // TODO: Page out
184                 // ATM. Just Warning
185                 Warning(" MM_AllocPhysRange: Out of memory (unable to fulfil request for %i pages)", Pages);
186                 Log_Warning("Arch",
187                         "Out of memory (unable to fulfil request for %i pages)",
188                         Pages   
189                         );
190                 LEAVE('i', 0);
191                 return 0;
192         }
193         LOG("nFree = %i, addr = 0x%08x", nFree, addr);
194         
195         // Mark pages as allocated
196         addr -= Pages;
197         for( i = 0; i < Pages; i++, addr++ )
198         {
199                 gaMainBitmap[addr >> 6] |= 1LL << (addr & 63);
200                 rangeID = MM_int_GetRangeID(addr << 12);
201                 giPhysRangeFree[ rangeID ] --;
202                 LOG("%x == %x", addr, giPhysRangeFirst[ rangeID ]);
203                 if(addr == giPhysRangeFirst[ rangeID ])
204                         giPhysRangeFirst[ rangeID ] += 1;
205         }
206         ret = addr;     // Save the return address
207         
208         // Update super bitmap
209         Pages += addr & (64-1);
210         addr &= ~(64-1);
211         Pages = (Pages + (64-1)) & ~(64-1);
212         for( i = 0; i < Pages/64; i++ )
213         {
214                 if( gaMainBitmap[ addr >> 6 ] + 1 == 0 )
215                         gaSuperBitmap[addr>>12] |= 1LL << ((addr >> 6) & 63);
216         }
217         
218         Mutex_Release(&glPhysicalPages);
219         LEAVE('x', ret << 12);
220         return ret << 12;
221 }
222
223 /**
224  * \brief Allocate a single physical page, with no preference as to address
225  *        size.
226  */
227 tPAddr MM_AllocPhys(void)
228 {
229          int    i;
230         
231         // Hack to allow allocation during setup
232         for(i = 0; i < NUM_STATIC_ALLOC; i++) {
233                 if( gaiStaticAllocPages[i] ) {
234                         tPAddr  ret = gaiStaticAllocPages[i];
235                         gaiStaticAllocPages[i] = 0;
236                         Log("MM_AllocPhys: Return %x, static alloc %i", ret, i);
237                         return ret;
238                 }
239         }
240         
241         return MM_AllocPhysRange(1, -1);
242 }
243
244 /**
245  * \brief Reference a physical page
246  */
247 void MM_RefPhys(tPAddr PAddr)
248 {
249         Uint64  page = PAddr >> 12;
250         
251         if( PAddr >> 12 > giMaxPhysPage )       return ;
252         
253         if( gaMainBitmap[ page >> 6 ] & (1LL << (page&63)) )
254         {
255                 // Reference again
256                 gaMultiBitmap[ page >> 6 ] |= 1LL << (page&63);
257                 gaiPageReferences[ page ] ++;
258         }
259         else
260         {
261                 // Allocate
262                 gaMainBitmap[page >> 6] |= 1LL << (page&63);
263                 if( gaMainBitmap[page >> 6 ] + 1 == 0 )
264                         gaSuperBitmap[page>> 12] |= 1LL << ((page >> 6) & 63);
265         }
266 }
267
268 /**
269  * \brief Dereference a physical page
270  */
271 void MM_DerefPhys(tPAddr PAddr)
272 {
273         Uint64  page = PAddr >> 12;
274         
275         if( PAddr >> 12 > giMaxPhysPage )       return ;
276         
277         if( gaMultiBitmap[ page >> 6 ] & (1LL << (page&63)) ) {
278                 gaiPageReferences[ page ] --;
279                 if( gaiPageReferences[ page ] == 1 )
280                         gaMultiBitmap[ page >> 6 ] &= ~(1LL << (page&63));
281                 if( gaiPageReferences[ page ] == 0 )
282                         gaMainBitmap[ page >> 6 ] &= ~(1LL << (page&63));
283         }
284         else
285                 gaMainBitmap[ page >> 6 ] &= ~(1LL << (page&63));
286         
287         // Update the free counts if the page was freed
288         if( !(gaMainBitmap[ page >> 6 ] & (1LL << (page&63))) )
289         {
290                  int    rangeID;
291                 rangeID = MM_int_GetRangeID( PAddr );
292                 giPhysRangeFree[ rangeID ] ++;
293                 if( giPhysRangeFirst[rangeID] > page )
294                         giPhysRangeFirst[rangeID] = page;
295                 if( giPhysRangeLast[rangeID] < page )
296                         giPhysRangeLast[rangeID] = page;
297         }
298         
299         // If the bitmap entry is not -1, unset the bit in the super bitmap
300         if(gaMainBitmap[ page >> 6 ] + 1 != 0 ) {
301                 gaSuperBitmap[page >> 12] &= ~(1LL << ((page >> 6) & 63));
302         }
303 }
304
305 /**
306  * \brief Takes a physical address and returns the ID of its range
307  * \param Addr  Physical address of page
308  * \return Range ID from eMMPhys_Ranges
309  */
310 int MM_int_GetRangeID( tPAddr Addr )
311 {
312         if(Addr >> 32)
313                 return MM_PHYS_MAX;
314         else if(Addr >> 24)
315                 return MM_PHYS_32BIT;
316         else if(Addr >> 20)
317                 return MM_PHYS_24BIT;
318         else if(Addr >> 16)
319                 return MM_PHYS_20BIT;
320         else
321                 return MM_PHYS_16BIT;
322 }

UCC git Repository :: git.ucc.asn.au