1027 lines
28 KiB
C
1027 lines
28 KiB
C
#include "efi/efi.h"
|
|
#include "etherboot.h"
|
|
#include "elf.h"
|
|
#include "sal.h"
|
|
#include "pal.h"
|
|
|
|
#warning "Place a declaration of lookup_efi_nic somewhere useful"
|
|
EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE *lookup_efi_nic(int index);
|
|
|
|
#warning "Place the declaraction of __call someplace more appropriate\n"
|
|
extern EFI_STATUS __call(void *,...);
|
|
|
|
/* Keep 16M free in case EFI needs to allocate some memory.
|
|
* In the worst case this is only 1/8 the memory on an Itanium.
|
|
*/
|
|
#define EFI_RESERVE_LOW_PAGES ((8*1024*1024)/EFI_PAGE_SIZE)
|
|
#define EFI_RESERVE_HIGH_PAGES ((8*1024*1024)/EFI_PAGE_SIZE)
|
|
|
|
struct console_info {
|
|
uint16_t num_cols;
|
|
uint16_t num_rows;
|
|
uint16_t orig_x;
|
|
uint16_t orig_y;
|
|
};
|
|
|
|
struct efi_mem_map {
|
|
uint64_t map_size;
|
|
uint64_t map_key;
|
|
uint64_t descriptor_size;
|
|
uint32_t descriptor_version;
|
|
uint32_t pad;
|
|
EFI_MEMORY_DESCRIPTOR map[64];
|
|
};
|
|
|
|
struct efi_info {
|
|
int flags;
|
|
#define READ_SYSTAB 1
|
|
#define READ_FPSWA 2
|
|
#define READ_MEMMAP 4
|
|
#define READ_CONINFO 8
|
|
EFI_SYSTEM_TABLE *systab;
|
|
void *fpswa;
|
|
struct efi_mem_map mem_map;
|
|
struct console_info coninfo;
|
|
};
|
|
|
|
|
|
unsigned long io_base;
|
|
|
|
/* local globals */
|
|
static struct efi_info efi_info;
|
|
static EFI_HANDLE etherboot_handle;
|
|
static EFI_BOOT_SERVICES *boot_services;
|
|
static SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
|
|
static SIMPLE_INPUT_INTERFACE *conin;
|
|
static void *mps_table;
|
|
static void *acpi20_table;
|
|
static void *smbios_table;
|
|
static void *nii_table;
|
|
|
|
/* local functions */
|
|
|
|
static EFI_STATUS efi_locate_handle(
|
|
EFI_LOCATE_SEARCH_TYPE search_type,
|
|
EFI_GUID *protocol, void *search_key,
|
|
UINTN *buffer_size, EFI_HANDLE *buffer)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_NOT_FOUND;
|
|
return __call(boot_services->LocateHandle,
|
|
search_type, protocol, search_key, buffer_size, buffer);
|
|
}
|
|
|
|
static EFI_STATUS efi_handle_protocol(EFI_HANDLE handle, EFI_GUID *protocol, void **interface)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_UNSUPPORTED;
|
|
return __call(boot_services->HandleProtocol, handle, protocol, interface);
|
|
}
|
|
|
|
static EFI_STATUS efi_locate_device_path(EFI_GUID *protocol, EFI_DEVICE_PATH **device_path,
|
|
EFI_HANDLE *device)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_NOT_FOUND;
|
|
return __call(boot_services->LocateDevicePath, protocol, device_path, device);
|
|
}
|
|
|
|
static EFI_STATUS efi_allocate_pages(EFI_ALLOCATE_TYPE type, EFI_MEMORY_TYPE memory_type,
|
|
UINTN pages, EFI_PHYSICAL_ADDRESS *memory)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_OUT_OF_RESOURCES;
|
|
return __call(boot_services->AllocatePages,
|
|
type, memory_type, pages, memory);
|
|
}
|
|
|
|
static EFI_STATUS efi_free_pages(EFI_PHYSICAL_ADDRESS memory, UINTN pages)
|
|
{
|
|
if(pages == 0)
|
|
return EFI_SUCCESS;
|
|
if (!boot_services)
|
|
return EFI_INVALID_PARAMETER;
|
|
return __call(boot_services->FreePages, memory, pages);
|
|
}
|
|
|
|
static EFI_STATUS efi_get_memory_map(UINTN *map_size, EFI_MEMORY_DESCRIPTOR *map,
|
|
UINTN *map_key, UINTN *descriptor_size, UINT32 *descriptor_version)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_INVALID_PARAMETER;
|
|
return __call(boot_services->GetMemoryMap,
|
|
map_size, map, map_key, descriptor_size, descriptor_version);
|
|
}
|
|
|
|
static EFI_STATUS efi_free_pool(void *buffer)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_INVALID_PARAMETER;
|
|
return __call(boot_services->FreePool, buffer);
|
|
}
|
|
static EFI_STATUS efi_stall(UINTN microseconds)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_UNSUPPORTED;
|
|
return __call(boot_services->Stall, microseconds);
|
|
}
|
|
|
|
static EFI_STATUS efi_set_watchdog_timer(
|
|
UINTN timeout, UINT64 watchdog_code, UINTN data_size, CHAR16 *watchdog_data)
|
|
{
|
|
if (!boot_services)
|
|
return EFI_UNSUPPORTED;
|
|
return __call(boot_services->SetWatchdogTimer,
|
|
timeout, watchdog_code, data_size, watchdog_data);
|
|
}
|
|
|
|
|
|
static void efi_exit_boot_services(struct efi_mem_map *map)
|
|
{
|
|
EFI_STATUS status;
|
|
if (!boot_services)
|
|
return;
|
|
status = __call(boot_services->ExitBootServices,
|
|
etherboot_handle, map->map_key);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("ExitBootServices failed: %lx\n", status);
|
|
}
|
|
conout = 0;
|
|
conin = 0;
|
|
boot_services = 0;
|
|
}
|
|
|
|
static void efi_free_memory(struct efi_mem_map *map)
|
|
{
|
|
EFI_MEMORY_DESCRIPTOR *desc, *tail;
|
|
#define next_desc(desc, size) ((EFI_MEMORY_DESCRIPTOR *)(((char *)(desc)) + (size)))
|
|
tail = next_desc(map->map, map->map_size);
|
|
for(desc = map->map; desc < tail; desc = next_desc(desc, map->descriptor_size)) {
|
|
EFI_STATUS status;
|
|
EFI_PHYSICAL_ADDRESS start, end;
|
|
UINTN pages;
|
|
int may_free;
|
|
|
|
start = desc->PhysicalStart;
|
|
pages = desc->NumberOfPages;
|
|
end = start + pages * EFI_PAGE_SIZE;
|
|
|
|
|
|
may_free = 0;
|
|
/* The only canidates are Loader Code and Data */
|
|
if ((desc->Type == EfiLoaderData) ||
|
|
(desc->Type == EfiLoaderCode))
|
|
may_free = 1;
|
|
|
|
/* Don't free anything etherboot lives in */
|
|
if ((may_free) &&
|
|
(start < virt_to_phys(_end)) &&
|
|
(end > virt_to_phys(_text)))
|
|
may_free = 0;
|
|
|
|
/* Continue if it is not memory we want to free */
|
|
if (!may_free)
|
|
continue;
|
|
|
|
status = efi_free_pages(start, pages);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("free_pages: %lx\n", status);
|
|
}
|
|
}
|
|
#undef next_desc
|
|
}
|
|
|
|
static void read_efi_mem_map(struct efi_mem_map *map)
|
|
{
|
|
EFI_STATUS status;
|
|
map->map_size = sizeof(map->map);
|
|
status = efi_get_memory_map(
|
|
&map->map_size, map->map, &map->map_key,
|
|
&map->descriptor_size, &map->descriptor_version);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("read_efi_mem_map failed: %lx\n", status);
|
|
map->map_size = 0;
|
|
}
|
|
/* map->descriptor_size should only grow larger */
|
|
/* map->descriptor_version should only increase and retain
|
|
* a backward compatible format.
|
|
*/
|
|
}
|
|
|
|
#if 0
|
|
static const char *efi_mem_type_name(uint32_t type)
|
|
{
|
|
const char *type_name;
|
|
if (type == EfiReservedMemoryType)
|
|
type_name = "EfiReservedMemoryType ";
|
|
else if (type == EfiLoaderCode)
|
|
type_name = "EfiLoaderCode ";
|
|
else if (type == EfiLoaderData)
|
|
type_name = "EfiLoaderData ";
|
|
else if (type == EfiBootServicesCode)
|
|
type_name = "EfiBootServicesCode ";
|
|
else if (type == EfiBootServicesData)
|
|
type_name = "EfiBootServicesData ";
|
|
else if (type == EfiRuntimeServicesCode)
|
|
type_name = "EfiRuntimeServicesCode ";
|
|
else if (type == EfiRuntimeServicesData)
|
|
type_name = "EfiRuntimeServicesData ";
|
|
else if (type == EfiConventionalMemory)
|
|
type_name = "EfiConventionalMemory ";
|
|
else if (type == EfiUnusableMemory)
|
|
type_name = "EfiUnusableMemory ";
|
|
else if (type == EfiACPIReclaimMemory)
|
|
type_name = "EfiACPIReclaimMemory ";
|
|
else if (type == EfiACPIMemoryNVS)
|
|
type_name = "EfiACPIMemoryNVS ";
|
|
else if (type == EfiMemoryMappedIO)
|
|
type_name = "EfiMemoryMappedIO ";
|
|
else if (type == EfiMemoryMappedIOPortSpace)
|
|
type_name = "EfiMemoryMappedIOPortSpace";
|
|
else if (type == EfiPalCode)
|
|
type_name = "EfiPalCode ";
|
|
else
|
|
type_name = "???? ";
|
|
return type_name;
|
|
}
|
|
|
|
static void print_efi_mem_map(struct efi_mem_map *map)
|
|
{
|
|
EFI_MEMORY_DESCRIPTOR *desc, *end;
|
|
#define next_desc(desc, size) ((EFI_MEMORY_DESCRIPTOR *)(((char *)(desc)) + (size)))
|
|
end = next_desc(map->map, map->map_size);
|
|
for(desc = map->map; desc < end ; desc = next_desc(desc, map->descriptor_size)) {
|
|
const char *mem_type;
|
|
unsigned long start, end, virt, virt_end;
|
|
uint64_t attr;
|
|
mem_type = efi_mem_type_name(desc->Type);
|
|
start = desc->PhysicalStart;
|
|
end = start + desc->NumberOfPages*EFI_PAGE_SIZE;
|
|
virt = desc->VirtualStart;
|
|
virt_end = virt + desc->NumberOfPages*EFI_PAGE_SIZE;
|
|
attr = desc->Attribute;
|
|
printf( "mem: %hhx %s @ %#lx-%#lx",
|
|
desc->Type, mem_type, start, end);
|
|
if (attr & EFI_MEMORY_UC)
|
|
printf("UC ");
|
|
if (attr & EFI_MEMORY_WC)
|
|
printf("WC ");
|
|
if (attr & EFI_MEMORY_WT)
|
|
printf("WT ");
|
|
if (attr & EFI_MEMORY_WB)
|
|
printf("WB ");
|
|
if (attr & EFI_MEMORY_UCE)
|
|
printf("UCE ");
|
|
|
|
if (attr & EFI_MEMORY_WP)
|
|
printf("WP ");
|
|
if (attr & EFI_MEMORY_RP)
|
|
printf("RP ");
|
|
if (attr & EFI_MEMORY_XP)
|
|
printf("XP ");
|
|
|
|
if (attr & EFI_MEMORY_RUNTIME)
|
|
printf("RUNTIME ");
|
|
|
|
printf("\n");
|
|
}
|
|
#undef next_desc
|
|
}
|
|
#endif
|
|
|
|
static void efi_allocate_memory(struct efi_mem_map *map)
|
|
{
|
|
EFI_MEMORY_DESCRIPTOR *desc, *end;
|
|
unsigned long low_free, high_free;
|
|
|
|
#define next_desc(desc, size) ((EFI_MEMORY_DESCRIPTOR *)(((char *)(desc)) + (size)))
|
|
end = next_desc(map->map, map->map_size);
|
|
/* Find out how much memory is free */
|
|
low_free = high_free = 0;
|
|
for(desc = map->map; desc < end ; desc = next_desc(desc, map->descriptor_size)) {
|
|
unsigned long start, middle, end;
|
|
if (desc->Type != EfiConventionalMemory)
|
|
continue;
|
|
start = desc->PhysicalStart;
|
|
end = desc->PhysicalStart + (desc->NumberOfPages*EFI_PAGE_SIZE);
|
|
if (start < 0x100000000UL) {
|
|
if (end > 0x100000000UL) {
|
|
middle = 0x10000000UL;
|
|
} else {
|
|
middle = end;
|
|
}
|
|
} else {
|
|
middle = start;
|
|
}
|
|
|
|
low_free += (middle - start)/EFI_PAGE_SIZE;
|
|
high_free += (end - middle)/EFI_PAGE_SIZE;
|
|
}
|
|
/* O.k. Now allocate all of the conventional memory, reserving only a tiny
|
|
* fraction for efi.
|
|
*/
|
|
for(desc = map->map; desc < end ; desc = next_desc(desc, map->descriptor_size)) {
|
|
EFI_STATUS status;
|
|
EFI_PHYSICAL_ADDRESS address;
|
|
UINTN pages;
|
|
unsigned long start, middle, end;
|
|
unsigned long low_pages, high_pages;
|
|
if (desc->Type != EfiConventionalMemory)
|
|
continue;
|
|
start = desc->PhysicalStart;
|
|
end = desc->PhysicalStart + (desc->NumberOfPages*EFI_PAGE_SIZE);
|
|
if (start < 0x100000000UL) {
|
|
if (end > 0x100000000UL) {
|
|
middle = 0x10000000UL;
|
|
} else {
|
|
middle = end;
|
|
}
|
|
} else {
|
|
middle = start;
|
|
}
|
|
low_pages = (middle - start)/EFI_PAGE_SIZE;
|
|
high_pages = (end - middle)/EFI_PAGE_SIZE;
|
|
if (low_pages && (low_free > EFI_RESERVE_LOW_PAGES)) {
|
|
address = start;
|
|
pages = low_pages;
|
|
if ((low_free - pages) < EFI_RESERVE_LOW_PAGES) {
|
|
pages = low_free - EFI_RESERVE_LOW_PAGES;
|
|
}
|
|
status = efi_allocate_pages(
|
|
AllocateAddress, EfiLoaderData, pages, &address);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("allocate_pages @%lx for %ld pages failed: %ld\n",
|
|
desc->PhysicalStart, pages, status);
|
|
}
|
|
low_free -= pages;
|
|
}
|
|
if (high_pages && (high_free > EFI_RESERVE_HIGH_PAGES)) {
|
|
address = middle;
|
|
pages = high_pages;
|
|
if ((high_free - pages) < EFI_RESERVE_HIGH_PAGES) {
|
|
pages = high_free - EFI_RESERVE_HIGH_PAGES;
|
|
}
|
|
status = efi_allocate_pages(
|
|
AllocateAddress, EfiLoaderData, pages, &address);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("allocate_pages @%lx for %ld pages failed: %ld\n",
|
|
desc->PhysicalStart, pages, status);
|
|
}
|
|
high_free -= pages;
|
|
}
|
|
}
|
|
#undef next_desc
|
|
}
|
|
|
|
static void set_io_base(struct efi_mem_map *map)
|
|
{
|
|
EFI_MEMORY_DESCRIPTOR *desc, *end;
|
|
|
|
io_base = ia64_get_kr0(); /* Default to ar.kr0 */
|
|
|
|
#define next_desc(desc, size) ((EFI_MEMORY_DESCRIPTOR *)(((char *)(desc)) + (size)))
|
|
end = next_desc(map->map, map->map_size);
|
|
|
|
for(desc = map->map; desc < end ; desc = next_desc(desc, map->descriptor_size)) {
|
|
if (desc->Type == EfiMemoryMappedIOPortSpace) {
|
|
io_base = desc->PhysicalStart;
|
|
break;
|
|
}
|
|
}
|
|
#undef next_desc
|
|
}
|
|
|
|
#define MAX_EFI_DEVICES 32
|
|
static void efi_stop_nics(void)
|
|
{
|
|
static EFI_GUID simple_net_protocol = EFI_SIMPLE_NETWORK_PROTOCOL;
|
|
EFI_SIMPLE_NETWORK *simple;
|
|
EFI_STATUS status;
|
|
EFI_HANDLE handles[MAX_EFI_DEVICES];
|
|
EFI_HANDLE handle;
|
|
UINTN devices;
|
|
unsigned i;
|
|
|
|
if (!boot_services)
|
|
return;
|
|
|
|
devices = sizeof(handles);
|
|
status = efi_locate_handle(
|
|
ByProtocol, &simple_net_protocol, 0, &devices, handles);
|
|
if (status != EFI_SUCCESS)
|
|
return;
|
|
devices /= sizeof(handles[0]);
|
|
for(i = 0; i < devices; i++) {
|
|
void *that;
|
|
handle = handles[i];
|
|
status = efi_handle_protocol(handle, &simple_net_protocol, &that);
|
|
if (status != EFI_SUCCESS)
|
|
continue;
|
|
simple = that;
|
|
if ((simple->Mode->State == EfiSimpleNetworkInitialized)) {
|
|
status = __call(simple->Shutdown, simple);
|
|
status = __call(simple->Stop, simple);
|
|
}
|
|
else if (simple->Mode->State == EfiSimpleNetworkStarted) {
|
|
status = __call(simple->Stop, simple);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void efi_get_coninfo(struct console_info *info)
|
|
{
|
|
EFI_STATUS status;
|
|
UINTN cols, rows;
|
|
|
|
/* Initialize with some silly safe values */
|
|
info->num_cols = 80;
|
|
info->num_rows = 24;
|
|
info->orig_x = 0;
|
|
info->orig_y = 0;
|
|
|
|
status = EFI_UNSUPPORTED;
|
|
if (conout) {
|
|
status = __call(conout->QueryMode, conout, conout->Mode->Mode, &cols, &rows);
|
|
if (status) {
|
|
printf("QueryMode Failed cannout get console parameters: %ld\n", status);
|
|
} else {
|
|
info->num_cols = cols;
|
|
info->num_rows = rows;
|
|
info->orig_x = conout->Mode->CursorColumn;
|
|
info->orig_y = conout->Mode->CursorRow;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void *efi_get_fpswa(void)
|
|
{
|
|
static EFI_GUID fpswa_protocol = FPSWA_PROTOCOL;
|
|
EFI_STATUS status;
|
|
EFI_HANDLE fpswa_handle;
|
|
UINTN devices;
|
|
void *result;
|
|
|
|
/* The FPSWA is the Floating Point Software Assist driver,
|
|
* to some extent it makes sense but it has one large flaw.
|
|
* It fails to install an EFI Configuration table, so the
|
|
* OS does not need assistance from the bootloader to find it.
|
|
*/
|
|
devices = sizeof(fpswa_handle);
|
|
status = efi_locate_handle(
|
|
ByProtocol, &fpswa_protocol, 0, &devices, &fpswa_handle);
|
|
if (status != EFI_SUCCESS)
|
|
return 0;
|
|
|
|
status = efi_handle_protocol(
|
|
fpswa_handle, &fpswa_protocol, &result);
|
|
if (status != EFI_SUCCESS)
|
|
return 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Exported functions */
|
|
|
|
|
|
void arch_main(in_call_data_t *data, va_list params)
|
|
{
|
|
EFI_STATUS status;
|
|
unsigned char *note, *end;
|
|
|
|
/* IA64 doesn't have an in_call() implementation; start.S
|
|
* passes in this parameter directly on the stack instead of
|
|
* as part of the in_call_data_t structure or the parameter
|
|
* list. params is unusable: don't attempt to access it.
|
|
*/
|
|
struct Elf_Bhdr *ptr = (struct Elf_Bhdr *)data;
|
|
|
|
memset(&efi_info, 0, sizeof(efi_info));
|
|
note = ((char *)bhdr) + sizeof(*bhdr);
|
|
end = ((char *)bhdr) + bhdr->b_size;
|
|
if (bhdr->b_signature != 0x0E1FB007) {
|
|
printf("Bad bhdr(%lx) signature(%x)!\n",
|
|
(unsigned long) bhdr, bhdr->b_signature);
|
|
note = end = 0;
|
|
}
|
|
while(note < end) {
|
|
Elf_Nhdr *hdr;
|
|
unsigned char *n_name, *n_desc, *next;
|
|
hdr = (Elf_Nhdr *)note;
|
|
n_name = note + sizeof(*hdr);
|
|
n_desc = n_name + ((hdr->n_namesz + 3) & ~3);
|
|
next = n_desc + ((hdr->n_descsz + 3) & ~3);
|
|
if (next > end)
|
|
break;
|
|
#if 0
|
|
printf("n_type: %x n_name(%d): n_desc(%d): \n",
|
|
hdr->n_type, hdr->n_namesz, hdr->n_descsz);
|
|
#endif
|
|
if ((hdr->n_namesz == 10) &&
|
|
(memcmp(n_name, "Etherboot", 10) == 0)) {
|
|
switch(hdr->n_type) {
|
|
case EB_IA64_IMAGE_HANDLE:
|
|
{
|
|
uint64_t *handlep = (void *)n_desc;
|
|
etherboot_handle = (EFI_HANDLE)(*handlep);
|
|
break;
|
|
}
|
|
case EB_IA64_SYSTAB:
|
|
{
|
|
uint64_t *systabp = (void *)n_desc;
|
|
efi_info.systab = (void *)(*systabp);
|
|
efi_info.flags |= READ_SYSTAB;
|
|
break;
|
|
}
|
|
case EB_IA64_FPSWA:
|
|
{
|
|
uint64_t*fpswap = (void *)n_desc;
|
|
efi_info.fpswa = (void *)(*fpswap);
|
|
efi_info.flags |= READ_FPSWA;
|
|
break;
|
|
}
|
|
case EB_IA64_CONINFO:
|
|
{
|
|
struct console_info *coninfop = (void *)n_desc;
|
|
efi_info.coninfo = *coninfop;
|
|
efi_info.flags |= READ_CONINFO;
|
|
break;
|
|
}
|
|
case EB_IA64_MEMMAP:
|
|
{
|
|
struct efi_mem_map *mem_mapp = (void *)n_desc;
|
|
efi_info.mem_map = *mem_mapp;
|
|
efi_info.flags |= READ_MEMMAP;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
note = next;
|
|
}
|
|
if (!(efi_info.flags & READ_SYSTAB)) {
|
|
printf("No EFI systab\n");
|
|
return;
|
|
}
|
|
|
|
/* If I have an efi memory map assume ExitBootServices has been called.
|
|
*/
|
|
#warning "FIXME see if there is a better test for boot services still being active "
|
|
printf("FIXME Develop a better test for boot services still being active\n");
|
|
if (!(efi_info.flags & READ_MEMMAP)) {
|
|
conout = efi_info.systab->ConOut;
|
|
conin = efi_info.systab->ConIn;
|
|
boot_services = efi_info.systab->BootServices;
|
|
}
|
|
|
|
if (!(efi_info.flags & READ_CONINFO)) {
|
|
efi_info.flags |= READ_CONINFO;
|
|
efi_get_coninfo(&efi_info.coninfo);
|
|
}
|
|
if (!(efi_info.flags & READ_FPSWA)) {
|
|
efi_info.flags |= READ_FPSWA;
|
|
efi_info.fpswa = efi_get_fpswa();
|
|
}
|
|
if (!(efi_info.flags & READ_MEMMAP)) {
|
|
efi_info.flags |= READ_MEMMAP;
|
|
read_efi_mem_map(&efi_info.mem_map);
|
|
/* Allocate all of the memory efi can spare */
|
|
efi_allocate_memory(&efi_info.mem_map);
|
|
/* Now refresh the memory map */
|
|
read_efi_mem_map(&efi_info.mem_map);
|
|
}
|
|
/* Get the io_base for legacy i/o */
|
|
set_io_base(&efi_info.mem_map);
|
|
|
|
/* Attempt to disable the watchdog timer..
|
|
* Nothing useful can be done if this fails, so ignore the return code.
|
|
*/
|
|
status = efi_set_watchdog_timer(0, 1, 0, 0);
|
|
|
|
/* Shutdown efi network drivers so efi doesn't get too confused */
|
|
efi_stop_nics();
|
|
|
|
if (efi_info.systab) {
|
|
static const EFI_GUID mps_table_guid = MPS_TABLE_GUID;
|
|
static const EFI_GUID acpi20_table_guid = ACPI_20_TABLE_GUID;
|
|
static const EFI_GUID smbios_table_guid = SMBIOS_TABLE_GUID;
|
|
static const EFI_GUID sal_system_table_guid = SAL_SYSTEM_TABLE_GUID;
|
|
static const EFI_GUID nii_table_guid = EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL;
|
|
EFI_SYSTEM_TABLE *systab;
|
|
unsigned i;
|
|
systab = efi_info.systab;
|
|
for(i = 0; i < systab->NumberOfTableEntries; i++) {
|
|
EFI_GUID *guid;
|
|
void *table = systab->ConfigurationTable[i].VendorTable;
|
|
guid = &systab->ConfigurationTable[i].VendorGuid;
|
|
|
|
#if 0
|
|
printf("GUID: %x-%hx-%hx-%hhx-%hhx-%hhx-%hhx-%hhx-%hhx-%hhx-%hhx Table: %lx\n",
|
|
guid->Data1, guid->Data2, guid->Data3,
|
|
guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
|
|
guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
|
|
table);
|
|
#endif
|
|
|
|
if (memcmp(guid, &mps_table_guid, 16) == 0) {
|
|
mps_table = table;
|
|
}
|
|
if (memcmp(guid, &acpi20_table_guid, 16) == 0) {
|
|
acpi20_table = table;
|
|
}
|
|
if (memcmp(guid, &smbios_table_guid, 16) == 0) {
|
|
smbios_table = table;
|
|
}
|
|
if (memcmp(guid, &sal_system_table_guid, 16) == 0) {
|
|
parse_sal_system_table(table);
|
|
}
|
|
if (memcmp(guid, &nii_table_guid, 16) == 0) {
|
|
nii_table = table;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void arch_on_exit(int status __unused)
|
|
{
|
|
if (!boot_services)
|
|
return;
|
|
read_efi_mem_map(&efi_info.mem_map);
|
|
efi_free_memory(&efi_info.mem_map);
|
|
}
|
|
|
|
void arch_relocate_to(unsigned long addr)
|
|
{
|
|
EFI_PHYSICAL_ADDRESS address, end;
|
|
UINTN pages;
|
|
EFI_STATUS status;
|
|
|
|
if (!boot_services)
|
|
return;
|
|
|
|
/* Find the efi pages where the new etherboot will sit */
|
|
address = addr & ~(EFI_PAGE_SIZE -1);
|
|
end = (addr + (_end - _text) + EFI_PAGE_SIZE -1) & ~EFI_PAGE_SIZE;
|
|
pages = (end - address)/EFI_PAGE_SIZE;
|
|
|
|
/* Reallocate the memory for the new copy of etherboot as LoaderCode */
|
|
status = efi_free_pages(address, pages);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("efi_free_pages failed!: %lx\n", status);
|
|
return;
|
|
}
|
|
status = efi_allocate_pages(AllocateAddress, EfiLoaderCode, pages, &address);
|
|
if (status != EFI_SUCCESS) {
|
|
printf("efi_allocate_pages failed! %lx\n", status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
struct meminfo meminfo;
|
|
void get_memsizes(void)
|
|
{
|
|
EFI_MEMORY_DESCRIPTOR *desc, *end;
|
|
struct efi_mem_map *map;
|
|
#define next_desc(desc, size) ((EFI_MEMORY_DESCRIPTOR *)(((char *)(desc)) + (size)))
|
|
|
|
map = &efi_info.mem_map;
|
|
end = next_desc(map->map, map->map_size);
|
|
|
|
meminfo.map_count = 0;
|
|
for(desc = map->map; desc < end ; desc = next_desc(desc, map->descriptor_size)) {
|
|
uint64_t start, size, end;
|
|
unsigned long mem_k;
|
|
|
|
start = desc->PhysicalStart;
|
|
size = desc->NumberOfPages*EFI_PAGE_SIZE;
|
|
end = start + size;
|
|
|
|
if ((desc->Type != EfiLoaderCode) &&
|
|
(desc->Type != EfiLoaderData)) {
|
|
continue;
|
|
}
|
|
|
|
meminfo.map[meminfo.map_count].addr = start;
|
|
meminfo.map[meminfo.map_count].size = size;
|
|
meminfo.map[meminfo.map_count].type = E820_RAM;
|
|
meminfo.map_count++;
|
|
|
|
end >>= 10;
|
|
mem_k = end;
|
|
if (end & 0xFFFFFFFF00000000ULL) {
|
|
mem_k = 0xFFFFFFFF;
|
|
}
|
|
/* Set the base basememsize */
|
|
if ((mem_k <= 640) && (meminfo.basememsize <= mem_k)) {
|
|
meminfo.basememsize = mem_k;
|
|
}
|
|
/* Set the total memsize */
|
|
if ((mem_k >= 1024) && (meminfo.memsize <= (mem_k - 1024))) {
|
|
meminfo.memsize = mem_k - 1024;
|
|
}
|
|
if (meminfo.map_count == E820MAX)
|
|
break;
|
|
}
|
|
#undef next_desc
|
|
}
|
|
|
|
|
|
EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE *lookup_efi_nic(int index)
|
|
{
|
|
static EFI_GUID protocol = EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL;
|
|
EFI_HANDLE handles[MAX_EFI_DEVICES];
|
|
EFI_STATUS status;
|
|
UINTN devices;
|
|
void *that;
|
|
|
|
if (!boot_services)
|
|
return 0;
|
|
if (index < 0) {
|
|
return 0;
|
|
}
|
|
devices = sizeof(handles);
|
|
status = efi_locate_handle(
|
|
ByProtocol, &protocol, 0, &devices, handles);
|
|
if (status != EFI_SUCCESS)
|
|
return 0;
|
|
devices /= sizeof(handles[0]);
|
|
if (index >= devices)
|
|
return 0;
|
|
status = efi_handle_protocol(handles[index], &protocol, &that);
|
|
if (status != EFI_SUCCESS)
|
|
return 0;
|
|
return that;
|
|
}
|
|
|
|
#if defined(CONSOLE_FIRMWARE)
|
|
void console_putc(int c)
|
|
{
|
|
CHAR16 str[2];
|
|
if (!conout)
|
|
return;
|
|
str[0] = c;
|
|
str[1] = 0;
|
|
__call(conout->OutputString, conout, str);
|
|
}
|
|
|
|
static int efi_have_key = 0;
|
|
static int efi_key;
|
|
int console_ischar(void)
|
|
{
|
|
EFI_STATUS status;
|
|
EFI_INPUT_KEY new_key;
|
|
if (!conin)
|
|
return 0;
|
|
if (efi_have_key) {
|
|
return 1;
|
|
}
|
|
status = __call(conin->ReadKeyStroke, conin, &new_key);
|
|
if (status == EFI_SUCCESS) {
|
|
if ((new_key.UnicodeChar >= 0) && (new_key.UnicodeChar < 0x7f)) {
|
|
efi_have_key = 1;
|
|
efi_key = new_key.UnicodeChar;
|
|
}
|
|
else if (new_key.ScanCode == 0x17) {
|
|
efi_have_key = 1;
|
|
efi_key = K_ESC;
|
|
}
|
|
}
|
|
return efi_have_key;
|
|
}
|
|
|
|
int console_getc(void)
|
|
{
|
|
if (efi_have_key) {
|
|
efi_have_key = 0;
|
|
}
|
|
|
|
return efi_key;
|
|
}
|
|
#endif /* CONSOLE_FIRMWARE */
|
|
|
|
#define NAME "Etherboot"
|
|
#define FIRMWARE "EFI"
|
|
|
|
#define SZ(X) ((sizeof(X)+3) & ~3)
|
|
#define CP(D,S) (memcpy(&(D), &(S), sizeof(S)))
|
|
|
|
|
|
struct elf_notes {
|
|
/* CAREFUL this structure is carefully arranged to avoid
|
|
* alignment problems.
|
|
*/
|
|
/* The note header */
|
|
struct Elf_Bhdr hdr;
|
|
|
|
/* First the Fixed sized entries that must be well aligned */
|
|
|
|
/* Insert a nop record so the next record is 64bit aligned */
|
|
Elf_Nhdr nf0;
|
|
|
|
/* Pointer to bootp data */
|
|
Elf_Nhdr nf1;
|
|
char nf1_name[SZ(EB_PARAM_NOTE)];
|
|
uint64_t nf1_bootp_data;
|
|
|
|
/* Pointer to ELF header */
|
|
Elf_Nhdr nf2;
|
|
char nf2_name[SZ(EB_PARAM_NOTE)];
|
|
uint64_t nf2_header;
|
|
|
|
/* The EFI systab pointer */
|
|
Elf_Nhdr nf3;
|
|
char nf3_name[SZ(EB_PARAM_NOTE)];
|
|
uint64_t nf3_systab;
|
|
|
|
/* The FPSWA pointer */
|
|
Elf_Nhdr nf4;
|
|
char nf4_name[SZ(EB_PARAM_NOTE)];
|
|
uint64_t nf4_fpswa;
|
|
|
|
/* The memory map */
|
|
Elf_Nhdr nf5;
|
|
char nf5_name[SZ(EB_PARAM_NOTE)];
|
|
struct efi_mem_map nf5_map;
|
|
|
|
/* The console info, silly but elilo passes it... */
|
|
Elf_Nhdr nf6;
|
|
char nf6_name[SZ(EB_PARAM_NOTE)];
|
|
struct console_info nf6_coninfo;
|
|
|
|
/* Then the variable sized data string data where alignment does not matter */
|
|
|
|
/* The bootloader name */
|
|
Elf_Nhdr nv1;
|
|
char nv1_desc[SZ(NAME)];
|
|
/* The bootloader version */
|
|
Elf_Nhdr nv2;
|
|
char nv2_desc[SZ(VERSION)];
|
|
/* The firmware type */
|
|
Elf_Nhdr nv3;
|
|
char nv3_desc[SZ(FIRMWARE)];
|
|
/* Name of the loaded image */
|
|
Elf_Nhdr nv4;
|
|
char nv4_loaded_image[128];
|
|
/* An empty command line */
|
|
Elf_Nhdr nv5;
|
|
char nv5_cmdline[SZ("")];
|
|
};
|
|
|
|
#define ELF_NOTE_COUNT (6+5)
|
|
|
|
static struct elf_notes notes;
|
|
struct Elf_Bhdr *prepare_boot_params(void *header)
|
|
{
|
|
/* Shutdown the boot services */
|
|
if (boot_services) {
|
|
efi_get_coninfo(&efi_info.coninfo);
|
|
read_efi_mem_map(&efi_info.mem_map);
|
|
efi_exit_boot_services(&efi_info.mem_map);
|
|
}
|
|
|
|
memset(¬es, 0, sizeof(notes));
|
|
notes.hdr.b_signature = 0x0E1FB007;
|
|
notes.hdr.b_size = sizeof(notes);
|
|
notes.hdr.b_checksum = 0;
|
|
notes.hdr.b_records = ELF_NOTE_COUNT;
|
|
|
|
/* Initialize the fixed length entries. */
|
|
|
|
/* Align the fixed length entries to a 64bit boundary */
|
|
notes.nf0.n_namesz = 0;
|
|
notes.nf0.n_descsz = 0;
|
|
notes.nf0.n_type = EBN_NOP;
|
|
|
|
notes.nf1.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf1.n_descsz = sizeof(notes.nf1_bootp_data);
|
|
notes.nf1.n_type = EB_BOOTP_DATA;
|
|
CP(notes.nf1_name, EB_PARAM_NOTE);
|
|
notes.nf1_bootp_data = virt_to_phys(&bootp_data);
|
|
|
|
notes.nf2.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf2.n_descsz = sizeof(notes.nf2_header);
|
|
notes.nf2.n_type = EB_HEADER;
|
|
CP(notes.nf2_name, EB_PARAM_NOTE);
|
|
notes.nf2_header = virt_to_phys(header);
|
|
|
|
notes.nf3.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf3.n_descsz = sizeof(notes.nf3_systab);
|
|
notes.nf3.n_type = EB_IA64_SYSTAB;
|
|
CP(notes.nf3_name, EB_PARAM_NOTE);
|
|
notes.nf3_systab = (unsigned long)efi_info.systab;
|
|
|
|
notes.nf4.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf4.n_descsz = sizeof(notes.nf4_fpswa);
|
|
notes.nf4.n_type = EB_IA64_FPSWA;
|
|
CP(notes.nf4_name, EB_PARAM_NOTE);
|
|
notes.nf4_fpswa = (unsigned long)efi_info.fpswa;
|
|
|
|
notes.nf5.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf5.n_descsz = sizeof(notes.nf5_map);
|
|
notes.nf5.n_type = EB_IA64_MEMMAP;
|
|
CP(notes.nf5_name, EB_PARAM_NOTE);
|
|
notes.nf5_map = efi_info.mem_map;
|
|
|
|
notes.nf6.n_namesz = sizeof(EB_PARAM_NOTE);
|
|
notes.nf6.n_descsz = sizeof(notes.nf6_coninfo);
|
|
notes.nf6.n_type = EB_IA64_CONINFO;
|
|
CP(notes.nf6_name, EB_PARAM_NOTE);
|
|
notes.nf6_coninfo = efi_info.coninfo;
|
|
|
|
/* Initialize the variable length entries */
|
|
notes.nv1.n_namesz = 0;
|
|
notes.nv1.n_descsz = sizeof(NAME);
|
|
notes.nv1.n_type = EBN_BOOTLOADER_NAME;
|
|
CP(notes.nv1_desc, NAME);
|
|
|
|
notes.nv2.n_namesz = 0;
|
|
notes.nv2.n_descsz = sizeof(VERSION);
|
|
notes.nv2.n_type = EBN_BOOTLOADER_VERSION;
|
|
CP(notes.nv2_desc, VERSION);
|
|
|
|
notes.nv3.n_namesz = 0;
|
|
notes.nv3.n_descsz = sizeof(FIRMWARE);
|
|
notes.nv3.n_type = EBN_FIRMWARE_TYPE;
|
|
CP(notes.nv3_desc, FIRMWARE);
|
|
|
|
/* Attempt to pass the name of the loaded image */
|
|
notes.nv4.n_namesz = 0;
|
|
notes.nv4.n_descsz = sizeof(notes.nv4_loaded_image);
|
|
notes.nv4.n_type = EBN_LOADED_IMAGE;
|
|
memcpy(¬es.nv4_loaded_image, KERNEL_BUF, sizeof(notes.nv4_loaded_image));
|
|
|
|
/* Pass an empty command line for now */
|
|
notes.nv5.n_namesz = 0;
|
|
notes.nv5.n_descsz = sizeof("");
|
|
notes.nv5.n_type = EBN_COMMAND_LINE;
|
|
CP(notes.nv5_cmdline, "");
|
|
|
|
notes.hdr.b_checksum = ipchksum(¬es, sizeof(notes));
|
|
/* Like UDP invert a 0 checksum to show that a checksum is present */
|
|
if (notes.hdr.b_checksum == 0) {
|
|
notes.hdr.b_checksum = 0xffff;
|
|
}
|
|
|
|
return ¬es.hdr;
|
|
}
|
|
|
|
int elf_start(unsigned long machine __unused, unsigned long entry, unsigned long params)
|
|
{
|
|
struct elf_notes *notes;
|
|
int result;
|
|
/* Since we can do both be polite and also pass the linux
|
|
* ia64_boot_param table.
|
|
*/
|
|
static struct ia64_boot_param {
|
|
uint64_t command_line; /* physical address of command line arguments */
|
|
uint64_t efi_systab; /* physical address of EFI system table */
|
|
uint64_t efi_memmap; /* physical address of EFI memory map */
|
|
uint64_t efi_memmap_size; /* size of EFI memory map */
|
|
uint64_t efi_memdesc_size; /* size of an EFI memory map descriptor */
|
|
uint32_t efi_memdesc_version; /* memory descriptor version */
|
|
struct {
|
|
uint16_t num_cols; /* number of columns on console output device */
|
|
uint16_t num_rows; /* number of rows on console output device */
|
|
uint16_t orig_x; /* cursor's x position */
|
|
uint16_t orig_y; /* cursor's y position */
|
|
} console_info;
|
|
uint64_t fpswa; /* physical address of the fpswa interface */
|
|
uint64_t initrd_start;
|
|
uint64_t initrd_size;
|
|
} bp;
|
|
|
|
notes = phys_to_virt(params);
|
|
/* If I don't have notes don't attempt to start the image */
|
|
if (notes == 0) {
|
|
return -2;
|
|
}
|
|
|
|
bp.command_line = (unsigned long)¬es->nv5_cmdline;
|
|
bp.efi_systab = notes->nf3_systab;
|
|
bp.efi_memmap = (unsigned long)¬es->nf5_map.map;
|
|
bp.efi_memmap_size = notes->nf5_map.map_size;
|
|
bp.efi_memdesc_size = notes->nf5_map.descriptor_size;
|
|
bp.efi_memdesc_version = notes->nf5_map.descriptor_version;
|
|
bp.console_info.num_cols = notes->nf6_coninfo.num_cols;
|
|
bp.console_info.num_rows = notes->nf6_coninfo.num_rows;
|
|
bp.console_info.orig_x = notes->nf6_coninfo.orig_x;
|
|
bp.console_info.orig_y = notes->nf6_coninfo.orig_y;
|
|
bp.fpswa = notes->nf4_fpswa;
|
|
bp.initrd_start = 0;
|
|
bp.initrd_size = 0;
|
|
|
|
|
|
asm volatile(
|
|
";;\n\t"
|
|
"mov r28=%2\n\t"
|
|
"mov out0=%3\n\t"
|
|
"br.call.sptk.few rp=%1\n\t"
|
|
"mov %0=r8\n\t"
|
|
: "=r" (result)
|
|
: "b"(entry), "r"(&bp),"r"(params)
|
|
);
|
|
return result;
|
|
}
|