Pull new-efi-memmap into release branch
This commit is contained in:
commit
5833f1420b
|
@ -239,57 +239,30 @@ is_available_memory (efi_memory_desc_t *md)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
typedef struct kern_memdesc {
|
||||||
* Trim descriptor MD so its starts at address START_ADDR. If the descriptor covers
|
u64 attribute;
|
||||||
* memory that is normally available to the kernel, issue a warning that some memory
|
u64 start;
|
||||||
* is being ignored.
|
u64 num_pages;
|
||||||
*/
|
} kern_memdesc_t;
|
||||||
static void
|
|
||||||
trim_bottom (efi_memory_desc_t *md, u64 start_addr)
|
|
||||||
{
|
|
||||||
u64 num_skipped_pages;
|
|
||||||
|
|
||||||
if (md->phys_addr >= start_addr || !md->num_pages)
|
static kern_memdesc_t *kern_memmap;
|
||||||
return;
|
|
||||||
|
|
||||||
num_skipped_pages = (start_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
|
|
||||||
if (num_skipped_pages > md->num_pages)
|
|
||||||
num_skipped_pages = md->num_pages;
|
|
||||||
|
|
||||||
if (is_available_memory(md))
|
|
||||||
printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
|
|
||||||
"at 0x%lx\n", __FUNCTION__,
|
|
||||||
(num_skipped_pages << EFI_PAGE_SHIFT) >> 10,
|
|
||||||
md->phys_addr, start_addr - IA64_GRANULE_SIZE);
|
|
||||||
/*
|
|
||||||
* NOTE: Don't set md->phys_addr to START_ADDR because that could cause the memory
|
|
||||||
* descriptor list to become unsorted. In such a case, md->num_pages will be
|
|
||||||
* zero, so the Right Thing will happen.
|
|
||||||
*/
|
|
||||||
md->phys_addr += num_skipped_pages << EFI_PAGE_SHIFT;
|
|
||||||
md->num_pages -= num_skipped_pages;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
static void
|
||||||
trim_top (efi_memory_desc_t *md, u64 end_addr)
|
walk (efi_freemem_callback_t callback, void *arg, u64 attr)
|
||||||
{
|
{
|
||||||
u64 num_dropped_pages, md_end_addr;
|
kern_memdesc_t *k;
|
||||||
|
u64 start, end, voff;
|
||||||
|
|
||||||
md_end_addr = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
|
voff = (attr == EFI_MEMORY_WB) ? PAGE_OFFSET : __IA64_UNCACHED_OFFSET;
|
||||||
|
for (k = kern_memmap; k->start != ~0UL; k++) {
|
||||||
if (md_end_addr <= end_addr || !md->num_pages)
|
if (k->attribute != attr)
|
||||||
return;
|
continue;
|
||||||
|
start = PAGE_ALIGN(k->start);
|
||||||
num_dropped_pages = (md_end_addr - end_addr) >> EFI_PAGE_SHIFT;
|
end = (k->start + (k->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK;
|
||||||
if (num_dropped_pages > md->num_pages)
|
if (start < end)
|
||||||
num_dropped_pages = md->num_pages;
|
if ((*callback)(start + voff, end + voff, arg) < 0)
|
||||||
|
return;
|
||||||
if (is_available_memory(md))
|
}
|
||||||
printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
|
|
||||||
"at 0x%lx\n", __FUNCTION__,
|
|
||||||
(num_dropped_pages << EFI_PAGE_SHIFT) >> 10,
|
|
||||||
md->phys_addr, end_addr);
|
|
||||||
md->num_pages -= num_dropped_pages;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -299,148 +272,19 @@ trim_top (efi_memory_desc_t *md, u64 end_addr)
|
||||||
void
|
void
|
||||||
efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
|
efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
|
||||||
{
|
{
|
||||||
int prev_valid = 0;
|
walk(callback, arg, EFI_MEMORY_WB);
|
||||||
struct range {
|
|
||||||
u64 start;
|
|
||||||
u64 end;
|
|
||||||
} prev, curr;
|
|
||||||
void *efi_map_start, *efi_map_end, *p, *q;
|
|
||||||
efi_memory_desc_t *md, *check_md;
|
|
||||||
u64 efi_desc_size, start, end, granule_addr, last_granule_addr, first_non_wb_addr = 0;
|
|
||||||
unsigned long total_mem = 0;
|
|
||||||
|
|
||||||
efi_map_start = __va(ia64_boot_param->efi_memmap);
|
|
||||||
efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
|
|
||||||
efi_desc_size = ia64_boot_param->efi_memdesc_size;
|
|
||||||
|
|
||||||
for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
|
|
||||||
md = p;
|
|
||||||
|
|
||||||
/* skip over non-WB memory descriptors; that's all we're interested in... */
|
|
||||||
if (!(md->attribute & EFI_MEMORY_WB))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* granule_addr is the base of md's first granule.
|
|
||||||
* [granule_addr - first_non_wb_addr) is guaranteed to
|
|
||||||
* be contiguous WB memory.
|
|
||||||
*/
|
|
||||||
granule_addr = GRANULEROUNDDOWN(md->phys_addr);
|
|
||||||
first_non_wb_addr = max(first_non_wb_addr, granule_addr);
|
|
||||||
|
|
||||||
if (first_non_wb_addr < md->phys_addr) {
|
|
||||||
trim_bottom(md, granule_addr + IA64_GRANULE_SIZE);
|
|
||||||
granule_addr = GRANULEROUNDDOWN(md->phys_addr);
|
|
||||||
first_non_wb_addr = max(first_non_wb_addr, granule_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (q = p; q < efi_map_end; q += efi_desc_size) {
|
|
||||||
check_md = q;
|
|
||||||
|
|
||||||
if ((check_md->attribute & EFI_MEMORY_WB) &&
|
|
||||||
(check_md->phys_addr == first_non_wb_addr))
|
|
||||||
first_non_wb_addr += check_md->num_pages << EFI_PAGE_SHIFT;
|
|
||||||
else
|
|
||||||
break; /* non-WB or hole */
|
|
||||||
}
|
|
||||||
|
|
||||||
last_granule_addr = GRANULEROUNDDOWN(first_non_wb_addr);
|
|
||||||
if (last_granule_addr < md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT))
|
|
||||||
trim_top(md, last_granule_addr);
|
|
||||||
|
|
||||||
if (is_available_memory(md)) {
|
|
||||||
if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) >= max_addr) {
|
|
||||||
if (md->phys_addr >= max_addr)
|
|
||||||
continue;
|
|
||||||
md->num_pages = (max_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
|
|
||||||
first_non_wb_addr = max_addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (total_mem >= mem_limit)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if (total_mem + (md->num_pages << EFI_PAGE_SHIFT) > mem_limit) {
|
|
||||||
unsigned long limit_addr = md->phys_addr;
|
|
||||||
|
|
||||||
limit_addr += mem_limit - total_mem;
|
|
||||||
limit_addr = GRANULEROUNDDOWN(limit_addr);
|
|
||||||
|
|
||||||
if (md->phys_addr > limit_addr)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
md->num_pages = (limit_addr - md->phys_addr) >>
|
|
||||||
EFI_PAGE_SHIFT;
|
|
||||||
first_non_wb_addr = max_addr = md->phys_addr +
|
|
||||||
(md->num_pages << EFI_PAGE_SHIFT);
|
|
||||||
}
|
|
||||||
total_mem += (md->num_pages << EFI_PAGE_SHIFT);
|
|
||||||
|
|
||||||
if (md->num_pages == 0)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
curr.start = PAGE_OFFSET + md->phys_addr;
|
|
||||||
curr.end = curr.start + (md->num_pages << EFI_PAGE_SHIFT);
|
|
||||||
|
|
||||||
if (!prev_valid) {
|
|
||||||
prev = curr;
|
|
||||||
prev_valid = 1;
|
|
||||||
} else {
|
|
||||||
if (curr.start < prev.start)
|
|
||||||
printk(KERN_ERR "Oops: EFI memory table not ordered!\n");
|
|
||||||
|
|
||||||
if (prev.end == curr.start) {
|
|
||||||
/* merge two consecutive memory ranges */
|
|
||||||
prev.end = curr.end;
|
|
||||||
} else {
|
|
||||||
start = PAGE_ALIGN(prev.start);
|
|
||||||
end = prev.end & PAGE_MASK;
|
|
||||||
if ((end > start) && (*callback)(start, end, arg) < 0)
|
|
||||||
return;
|
|
||||||
prev = curr;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (prev_valid) {
|
|
||||||
start = PAGE_ALIGN(prev.start);
|
|
||||||
end = prev.end & PAGE_MASK;
|
|
||||||
if (end > start)
|
|
||||||
(*callback)(start, end, arg);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Walk the EFI memory map to pull out leftover pages in the lower
|
* Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that
|
||||||
* memory regions which do not end up in the regular memory map and
|
* has memory that is available for uncached allocator.
|
||||||
* stick them into the uncached allocator
|
|
||||||
*
|
|
||||||
* The regular walk function is significantly more complex than the
|
|
||||||
* uncached walk which means it really doesn't make sense to try and
|
|
||||||
* marge the two.
|
|
||||||
*/
|
*/
|
||||||
void __init
|
void
|
||||||
efi_memmap_walk_uc (efi_freemem_callback_t callback)
|
efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg)
|
||||||
{
|
{
|
||||||
void *efi_map_start, *efi_map_end, *p;
|
walk(callback, arg, EFI_MEMORY_UC);
|
||||||
efi_memory_desc_t *md;
|
|
||||||
u64 efi_desc_size, start, end;
|
|
||||||
|
|
||||||
efi_map_start = __va(ia64_boot_param->efi_memmap);
|
|
||||||
efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
|
|
||||||
efi_desc_size = ia64_boot_param->efi_memdesc_size;
|
|
||||||
|
|
||||||
for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
|
|
||||||
md = p;
|
|
||||||
if (md->attribute == EFI_MEMORY_UC) {
|
|
||||||
start = PAGE_ALIGN(md->phys_addr);
|
|
||||||
end = PAGE_ALIGN((md->phys_addr+(md->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK);
|
|
||||||
if ((*callback)(start, end, NULL) < 0)
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Look for the PAL_CODE region reported by EFI and maps it using an
|
* Look for the PAL_CODE region reported by EFI and maps it using an
|
||||||
* ITR to enable safe PAL calls in virtual mode. See IA-64 Processor
|
* ITR to enable safe PAL calls in virtual mode. See IA-64 Processor
|
||||||
|
@ -862,3 +706,307 @@ efi_uart_console_only(void)
|
||||||
printk(KERN_ERR "Malformed %s value\n", name);
|
printk(KERN_ERR "Malformed %s value\n", name);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#define efi_md_size(md) (md->num_pages << EFI_PAGE_SHIFT)
|
||||||
|
|
||||||
|
static inline u64
|
||||||
|
kmd_end(kern_memdesc_t *kmd)
|
||||||
|
{
|
||||||
|
return (kmd->start + (kmd->num_pages << EFI_PAGE_SHIFT));
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline u64
|
||||||
|
efi_md_end(efi_memory_desc_t *md)
|
||||||
|
{
|
||||||
|
return (md->phys_addr + efi_md_size(md));
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int
|
||||||
|
efi_wb(efi_memory_desc_t *md)
|
||||||
|
{
|
||||||
|
return (md->attribute & EFI_MEMORY_WB);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int
|
||||||
|
efi_uc(efi_memory_desc_t *md)
|
||||||
|
{
|
||||||
|
return (md->attribute & EFI_MEMORY_UC);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Look for the first granule aligned memory descriptor memory
|
||||||
|
* that is big enough to hold EFI memory map. Make sure this
|
||||||
|
* descriptor is atleast granule sized so it does not get trimmed
|
||||||
|
*/
|
||||||
|
struct kern_memdesc *
|
||||||
|
find_memmap_space (void)
|
||||||
|
{
|
||||||
|
u64 contig_low=0, contig_high=0;
|
||||||
|
u64 as = 0, ae;
|
||||||
|
void *efi_map_start, *efi_map_end, *p, *q;
|
||||||
|
efi_memory_desc_t *md, *pmd = NULL, *check_md;
|
||||||
|
u64 space_needed, efi_desc_size;
|
||||||
|
unsigned long total_mem = 0;
|
||||||
|
|
||||||
|
efi_map_start = __va(ia64_boot_param->efi_memmap);
|
||||||
|
efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
|
||||||
|
efi_desc_size = ia64_boot_param->efi_memdesc_size;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Worst case: we need 3 kernel descriptors for each efi descriptor
|
||||||
|
* (if every entry has a WB part in the middle, and UC head and tail),
|
||||||
|
* plus one for the end marker.
|
||||||
|
*/
|
||||||
|
space_needed = sizeof(kern_memdesc_t) *
|
||||||
|
(3 * (ia64_boot_param->efi_memmap_size/efi_desc_size) + 1);
|
||||||
|
|
||||||
|
for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
|
||||||
|
md = p;
|
||||||
|
if (!efi_wb(md)) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
|
||||||
|
contig_low = GRANULEROUNDUP(md->phys_addr);
|
||||||
|
contig_high = efi_md_end(md);
|
||||||
|
for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
|
||||||
|
check_md = q;
|
||||||
|
if (!efi_wb(check_md))
|
||||||
|
break;
|
||||||
|
if (contig_high != check_md->phys_addr)
|
||||||
|
break;
|
||||||
|
contig_high = efi_md_end(check_md);
|
||||||
|
}
|
||||||
|
contig_high = GRANULEROUNDDOWN(contig_high);
|
||||||
|
}
|
||||||
|
if (!is_available_memory(md) || md->type == EFI_LOADER_DATA)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* Round ends inward to granule boundaries */
|
||||||
|
as = max(contig_low, md->phys_addr);
|
||||||
|
ae = min(contig_high, efi_md_end(md));
|
||||||
|
|
||||||
|
/* keep within max_addr= command line arg */
|
||||||
|
ae = min(ae, max_addr);
|
||||||
|
if (ae <= as)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* avoid going over mem= command line arg */
|
||||||
|
if (total_mem + (ae - as) > mem_limit)
|
||||||
|
ae -= total_mem + (ae - as) - mem_limit;
|
||||||
|
|
||||||
|
if (ae <= as)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (ae - as > space_needed)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (p >= efi_map_end)
|
||||||
|
panic("Can't allocate space for kernel memory descriptors");
|
||||||
|
|
||||||
|
return __va(as);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Walk the EFI memory map and gather all memory available for kernel
|
||||||
|
* to use. We can allocate partial granules only if the unavailable
|
||||||
|
* parts exist, and are WB.
|
||||||
|
*/
|
||||||
|
void
|
||||||
|
efi_memmap_init(unsigned long *s, unsigned long *e)
|
||||||
|
{
|
||||||
|
struct kern_memdesc *k, *prev = 0;
|
||||||
|
u64 contig_low=0, contig_high=0;
|
||||||
|
u64 as, ae, lim;
|
||||||
|
void *efi_map_start, *efi_map_end, *p, *q;
|
||||||
|
efi_memory_desc_t *md, *pmd = NULL, *check_md;
|
||||||
|
u64 efi_desc_size;
|
||||||
|
unsigned long total_mem = 0;
|
||||||
|
|
||||||
|
k = kern_memmap = find_memmap_space();
|
||||||
|
|
||||||
|
efi_map_start = __va(ia64_boot_param->efi_memmap);
|
||||||
|
efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
|
||||||
|
efi_desc_size = ia64_boot_param->efi_memdesc_size;
|
||||||
|
|
||||||
|
for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
|
||||||
|
md = p;
|
||||||
|
if (!efi_wb(md)) {
|
||||||
|
if (efi_uc(md) && (md->type == EFI_CONVENTIONAL_MEMORY ||
|
||||||
|
md->type == EFI_BOOT_SERVICES_DATA)) {
|
||||||
|
k->attribute = EFI_MEMORY_UC;
|
||||||
|
k->start = md->phys_addr;
|
||||||
|
k->num_pages = md->num_pages;
|
||||||
|
k++;
|
||||||
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
|
||||||
|
contig_low = GRANULEROUNDUP(md->phys_addr);
|
||||||
|
contig_high = efi_md_end(md);
|
||||||
|
for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
|
||||||
|
check_md = q;
|
||||||
|
if (!efi_wb(check_md))
|
||||||
|
break;
|
||||||
|
if (contig_high != check_md->phys_addr)
|
||||||
|
break;
|
||||||
|
contig_high = efi_md_end(check_md);
|
||||||
|
}
|
||||||
|
contig_high = GRANULEROUNDDOWN(contig_high);
|
||||||
|
}
|
||||||
|
if (!is_available_memory(md))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Round ends inward to granule boundaries
|
||||||
|
* Give trimmings to uncached allocator
|
||||||
|
*/
|
||||||
|
if (md->phys_addr < contig_low) {
|
||||||
|
lim = min(efi_md_end(md), contig_low);
|
||||||
|
if (efi_uc(md)) {
|
||||||
|
if (k > kern_memmap && (k-1)->attribute == EFI_MEMORY_UC &&
|
||||||
|
kmd_end(k-1) == md->phys_addr) {
|
||||||
|
(k-1)->num_pages += (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
|
||||||
|
} else {
|
||||||
|
k->attribute = EFI_MEMORY_UC;
|
||||||
|
k->start = md->phys_addr;
|
||||||
|
k->num_pages = (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
|
||||||
|
k++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
as = contig_low;
|
||||||
|
} else
|
||||||
|
as = md->phys_addr;
|
||||||
|
|
||||||
|
if (efi_md_end(md) > contig_high) {
|
||||||
|
lim = max(md->phys_addr, contig_high);
|
||||||
|
if (efi_uc(md)) {
|
||||||
|
if (lim == md->phys_addr && k > kern_memmap &&
|
||||||
|
(k-1)->attribute == EFI_MEMORY_UC &&
|
||||||
|
kmd_end(k-1) == md->phys_addr) {
|
||||||
|
(k-1)->num_pages += md->num_pages;
|
||||||
|
} else {
|
||||||
|
k->attribute = EFI_MEMORY_UC;
|
||||||
|
k->start = lim;
|
||||||
|
k->num_pages = (efi_md_end(md) - lim) >> EFI_PAGE_SHIFT;
|
||||||
|
k++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ae = contig_high;
|
||||||
|
} else
|
||||||
|
ae = efi_md_end(md);
|
||||||
|
|
||||||
|
/* keep within max_addr= command line arg */
|
||||||
|
ae = min(ae, max_addr);
|
||||||
|
if (ae <= as)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* avoid going over mem= command line arg */
|
||||||
|
if (total_mem + (ae - as) > mem_limit)
|
||||||
|
ae -= total_mem + (ae - as) - mem_limit;
|
||||||
|
|
||||||
|
if (ae <= as)
|
||||||
|
continue;
|
||||||
|
if (prev && kmd_end(prev) == md->phys_addr) {
|
||||||
|
prev->num_pages += (ae - as) >> EFI_PAGE_SHIFT;
|
||||||
|
total_mem += ae - as;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
k->attribute = EFI_MEMORY_WB;
|
||||||
|
k->start = as;
|
||||||
|
k->num_pages = (ae - as) >> EFI_PAGE_SHIFT;
|
||||||
|
total_mem += ae - as;
|
||||||
|
prev = k++;
|
||||||
|
}
|
||||||
|
k->start = ~0L; /* end-marker */
|
||||||
|
|
||||||
|
/* reserve the memory we are using for kern_memmap */
|
||||||
|
*s = (u64)kern_memmap;
|
||||||
|
*e = (u64)++k;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
efi_initialize_iomem_resources(struct resource *code_resource,
|
||||||
|
struct resource *data_resource)
|
||||||
|
{
|
||||||
|
struct resource *res;
|
||||||
|
void *efi_map_start, *efi_map_end, *p;
|
||||||
|
efi_memory_desc_t *md;
|
||||||
|
u64 efi_desc_size;
|
||||||
|
char *name;
|
||||||
|
unsigned long flags;
|
||||||
|
|
||||||
|
efi_map_start = __va(ia64_boot_param->efi_memmap);
|
||||||
|
efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
|
||||||
|
efi_desc_size = ia64_boot_param->efi_memdesc_size;
|
||||||
|
|
||||||
|
res = NULL;
|
||||||
|
|
||||||
|
for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
|
||||||
|
md = p;
|
||||||
|
|
||||||
|
if (md->num_pages == 0) /* should not happen */
|
||||||
|
continue;
|
||||||
|
|
||||||
|
flags = IORESOURCE_MEM;
|
||||||
|
switch (md->type) {
|
||||||
|
|
||||||
|
case EFI_MEMORY_MAPPED_IO:
|
||||||
|
case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
|
||||||
|
continue;
|
||||||
|
|
||||||
|
case EFI_LOADER_CODE:
|
||||||
|
case EFI_LOADER_DATA:
|
||||||
|
case EFI_BOOT_SERVICES_DATA:
|
||||||
|
case EFI_BOOT_SERVICES_CODE:
|
||||||
|
case EFI_CONVENTIONAL_MEMORY:
|
||||||
|
if (md->attribute & EFI_MEMORY_WP) {
|
||||||
|
name = "System ROM";
|
||||||
|
flags |= IORESOURCE_READONLY;
|
||||||
|
} else {
|
||||||
|
name = "System RAM";
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case EFI_ACPI_MEMORY_NVS:
|
||||||
|
name = "ACPI Non-volatile Storage";
|
||||||
|
flags |= IORESOURCE_BUSY;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case EFI_UNUSABLE_MEMORY:
|
||||||
|
name = "reserved";
|
||||||
|
flags |= IORESOURCE_BUSY | IORESOURCE_DISABLED;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case EFI_RESERVED_TYPE:
|
||||||
|
case EFI_RUNTIME_SERVICES_CODE:
|
||||||
|
case EFI_RUNTIME_SERVICES_DATA:
|
||||||
|
case EFI_ACPI_RECLAIM_MEMORY:
|
||||||
|
default:
|
||||||
|
name = "reserved";
|
||||||
|
flags |= IORESOURCE_BUSY;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((res = kcalloc(1, sizeof(struct resource), GFP_KERNEL)) == NULL) {
|
||||||
|
printk(KERN_ERR "failed to alocate resource for iomem\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
res->name = name;
|
||||||
|
res->start = md->phys_addr;
|
||||||
|
res->end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;
|
||||||
|
res->flags = flags;
|
||||||
|
|
||||||
|
if (insert_resource(&iomem_resource, res) < 0)
|
||||||
|
kfree(res);
|
||||||
|
else {
|
||||||
|
/*
|
||||||
|
* We don't know which region contains
|
||||||
|
* kernel data so we try it repeatedly and
|
||||||
|
* let the resource manager test it.
|
||||||
|
*/
|
||||||
|
insert_resource(res, code_resource);
|
||||||
|
insert_resource(res, data_resource);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
@ -78,6 +78,19 @@ struct screen_info screen_info;
|
||||||
unsigned long vga_console_iobase;
|
unsigned long vga_console_iobase;
|
||||||
unsigned long vga_console_membase;
|
unsigned long vga_console_membase;
|
||||||
|
|
||||||
|
static struct resource data_resource = {
|
||||||
|
.name = "Kernel data",
|
||||||
|
.flags = IORESOURCE_BUSY | IORESOURCE_MEM
|
||||||
|
};
|
||||||
|
|
||||||
|
static struct resource code_resource = {
|
||||||
|
.name = "Kernel code",
|
||||||
|
.flags = IORESOURCE_BUSY | IORESOURCE_MEM
|
||||||
|
};
|
||||||
|
extern void efi_initialize_iomem_resources(struct resource *,
|
||||||
|
struct resource *);
|
||||||
|
extern char _text[], _end[], _etext[];
|
||||||
|
|
||||||
unsigned long ia64_max_cacheline_size;
|
unsigned long ia64_max_cacheline_size;
|
||||||
unsigned long ia64_iobase; /* virtual address for I/O accesses */
|
unsigned long ia64_iobase; /* virtual address for I/O accesses */
|
||||||
EXPORT_SYMBOL(ia64_iobase);
|
EXPORT_SYMBOL(ia64_iobase);
|
||||||
|
@ -171,6 +184,22 @@ sort_regions (struct rsvd_region *rsvd_region, int max)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Request address space for all standard resources
|
||||||
|
*/
|
||||||
|
static int __init register_memory(void)
|
||||||
|
{
|
||||||
|
code_resource.start = ia64_tpa(_text);
|
||||||
|
code_resource.end = ia64_tpa(_etext) - 1;
|
||||||
|
data_resource.start = ia64_tpa(_etext);
|
||||||
|
data_resource.end = ia64_tpa(_end) - 1;
|
||||||
|
efi_initialize_iomem_resources(&code_resource, &data_resource);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
__initcall(register_memory);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* reserve_memory - setup reserved memory areas
|
* reserve_memory - setup reserved memory areas
|
||||||
*
|
*
|
||||||
|
@ -211,6 +240,9 @@ reserve_memory (void)
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
efi_memmap_init(&rsvd_region[n].start, &rsvd_region[n].end);
|
||||||
|
n++;
|
||||||
|
|
||||||
/* end of memory marker */
|
/* end of memory marker */
|
||||||
rsvd_region[n].start = ~0UL;
|
rsvd_region[n].start = ~0UL;
|
||||||
rsvd_region[n].end = ~0UL;
|
rsvd_region[n].end = ~0UL;
|
||||||
|
|
|
@ -205,23 +205,18 @@ EXPORT_SYMBOL(uncached_free_page);
|
||||||
static int __init
|
static int __init
|
||||||
uncached_build_memmap(unsigned long start, unsigned long end, void *arg)
|
uncached_build_memmap(unsigned long start, unsigned long end, void *arg)
|
||||||
{
|
{
|
||||||
long length;
|
long length = end - start;
|
||||||
unsigned long vstart, vend;
|
|
||||||
int node;
|
int node;
|
||||||
|
|
||||||
length = end - start;
|
|
||||||
vstart = start + __IA64_UNCACHED_OFFSET;
|
|
||||||
vend = end + __IA64_UNCACHED_OFFSET;
|
|
||||||
|
|
||||||
dprintk(KERN_ERR "uncached_build_memmap(%lx %lx)\n", start, end);
|
dprintk(KERN_ERR "uncached_build_memmap(%lx %lx)\n", start, end);
|
||||||
|
|
||||||
memset((char *)vstart, 0, length);
|
memset((char *)start, 0, length);
|
||||||
|
|
||||||
node = paddr_to_nid(start);
|
node = paddr_to_nid(start - __IA64_UNCACHED_OFFSET);
|
||||||
|
|
||||||
for (; vstart < vend ; vstart += PAGE_SIZE) {
|
for (; start < end ; start += PAGE_SIZE) {
|
||||||
dprintk(KERN_INFO "sticking %lx into the pool!\n", vstart);
|
dprintk(KERN_INFO "sticking %lx into the pool!\n", start);
|
||||||
gen_pool_free(uncached_pool[node], vstart, PAGE_SIZE);
|
gen_pool_free(uncached_pool[node], start, PAGE_SIZE);
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
|
|
@ -16,10 +16,11 @@
|
||||||
* - initrd (optional)
|
* - initrd (optional)
|
||||||
* - command line string
|
* - command line string
|
||||||
* - kernel code & data
|
* - kernel code & data
|
||||||
|
* - Kernel memory map built from EFI memory map
|
||||||
*
|
*
|
||||||
* More could be added if necessary
|
* More could be added if necessary
|
||||||
*/
|
*/
|
||||||
#define IA64_MAX_RSVD_REGIONS 5
|
#define IA64_MAX_RSVD_REGIONS 6
|
||||||
|
|
||||||
struct rsvd_region {
|
struct rsvd_region {
|
||||||
unsigned long start; /* virtual address of beginning of element */
|
unsigned long start; /* virtual address of beginning of element */
|
||||||
|
@ -33,6 +34,7 @@ extern void find_memory (void);
|
||||||
extern void reserve_memory (void);
|
extern void reserve_memory (void);
|
||||||
extern void find_initrd (void);
|
extern void find_initrd (void);
|
||||||
extern int filter_rsvd_memory (unsigned long start, unsigned long end, void *arg);
|
extern int filter_rsvd_memory (unsigned long start, unsigned long end, void *arg);
|
||||||
|
extern void efi_memmap_init(unsigned long *, unsigned long *);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* For rounding an address to the next IA64_GRANULE_SIZE or order
|
* For rounding an address to the next IA64_GRANULE_SIZE or order
|
||||||
|
|
Reference in New Issue