![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memmap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src|
Return to memmap.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src |
1.1 root 1: // Support for building memory maps suitable for int 15 e820 calls.
2: //
3: // Copyright (C) 2008,2009 Kevin O'Connor <[email protected]>
4: //
5: // This file may be distributed under the terms of the GNU LGPLv3 license.
6:
7: #include "memmap.h" // struct e820entry
8: #include "util.h" // dprintf.h
9: #include "biosvar.h" // SET_EBDA
10:
11:
12: /****************************************************************
13: * e820 memory map
14: ****************************************************************/
15:
16: // Remove an entry from the e820_list.
17: static void
18: remove_e820(int i)
19: {
20: e820_count--;
21: memmove(&e820_list[i], &e820_list[i+1]
22: , sizeof(e820_list[0]) * (e820_count - i));
23: }
24:
25: // Insert an entry in the e820_list at the given position.
26: static void
27: insert_e820(int i, u64 start, u64 size, u32 type)
28: {
29: if (e820_count >= CONFIG_MAX_E820) {
30: dprintf(1, "Overflowed e820 list!\n");
31: return;
32: }
33:
34: memmove(&e820_list[i+1], &e820_list[i]
35: , sizeof(e820_list[0]) * (e820_count - i));
36: e820_count++;
37: struct e820entry *e = &e820_list[i];
38: e->start = start;
39: e->size = size;
40: e->type = type;
41: }
42:
43: // Show the current e820_list.
44: static void
1.1.1.2 ! root 45: dump_map(void)
1.1 root 46: {
47: dprintf(1, "e820 map has %d items:\n", e820_count);
48: int i;
49: for (i=0; i<e820_count; i++) {
50: struct e820entry *e = &e820_list[i];
51: u64 e_end = e->start + e->size;
52: dprintf(1, " %d: %08x%08x - %08x%08x = %d\n", i
53: , (u32)(e->start >> 32), (u32)e->start
54: , (u32)(e_end >> 32), (u32)e_end
55: , e->type);
56: }
57: }
58:
59: // Add a new entry to the list. This scans for overlaps and keeps the
60: // list sorted.
61: void
62: add_e820(u64 start, u64 size, u32 type)
63: {
64: dprintf(8, "Add to e820 map: %08x %08x %d\n", (u32)start, (u32)size, type);
65:
66: if (! size)
67: // Huh? Nothing to do.
68: return;
69:
70: // Find position of new item (splitting existing item if needed).
71: u64 end = start + size;
72: int i;
73: for (i=0; i<e820_count; i++) {
74: struct e820entry *e = &e820_list[i];
75: u64 e_end = e->start + e->size;
76: if (start > e_end)
77: continue;
78: // Found position - check if an existing item needs to be split.
79: if (start > e->start) {
80: if (type == e->type) {
81: // Same type - merge them.
82: size += start - e->start;
83: start = e->start;
84: } else {
85: // Split existing item.
86: e->size = start - e->start;
87: i++;
88: if (e_end > end)
89: insert_e820(i, end, e_end - end, e->type);
90: }
91: }
92: break;
93: }
94: // Remove/adjust existing items that are overlapping.
95: while (i<e820_count) {
96: struct e820entry *e = &e820_list[i];
97: if (end < e->start)
98: // No overlap - done.
99: break;
100: u64 e_end = e->start + e->size;
101: if (end >= e_end) {
102: // Existing item completely overlapped - remove it.
103: remove_e820(i);
104: continue;
105: }
106: // Not completely overlapped - adjust its start.
107: e->start = end;
108: e->size = e_end - end;
109: if (type == e->type) {
110: // Same type - merge them.
111: size += e->size;
112: remove_e820(i);
113: }
114: break;
115: }
116: // Insert new item.
117: if (type != E820_HOLE)
118: insert_e820(i, start, size, type);
119: //dump_map();
120: }
121:
122: // Find highest area of 32bit memory that can hold the given size.
123: struct e820entry *
124: find_high_area(u32 size)
125: {
126: int i;
127: for (i=e820_count-1; i>=0; i--) {
128: struct e820entry *e = &e820_list[i];
129: u64 end = e->start + e->size;
130: if (e->type != E820_RAM || end > 0xffffffff || e->size < size)
131: continue;
132: if (end < 1024*1024 + size)
133: break;
134: return e;
135: }
136: return NULL;
137: }
138:
139: // Prep for memmap stuff - init bios table locations.
140: void
1.1.1.2 ! root 141: memmap_setup(void)
1.1 root 142: {
143: e820_count = 0;
144: }
145:
146: // Report on final memory locations.
147: void
1.1.1.2 ! root 148: memmap_finalize(void)
1.1 root 149: {
150: dump_map();
151: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.